diff --git a/game/client/NextBot/C_NextBot.cpp b/game/client/NextBot/C_NextBot.cpp
new file mode 100644
index 00000000..13d55012
--- /dev/null
+++ b/game/client/NextBot/C_NextBot.cpp
@@ -0,0 +1,245 @@
+// C_NextBot.cpp
+// Client-side implementation of Next generation bot system
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+#include "C_NextBot.h"
+#include "debugoverlay_shared.h"
+#include <bitbuf.h>
+#include "viewrender.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#undef NextBot
+
+ConVar NextBotShadowDist( "nb_shadow_dist", "400" );
+
+//-----------------------------------------------------------------------------
+IMPLEMENT_CLIENTCLASS_DT( C_NextBotCombatCharacter, DT_NextBot, NextBotCombatCharacter )
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+C_NextBotCombatCharacter::C_NextBotCombatCharacter()
+{
+	// Left4Dead have surfaces too steep for IK to work properly
+	m_EntClientFlags |= ENTCLIENTFLAG_DONTUSEIK;
+
+	m_shadowType = SHADOWS_SIMPLE;
+	m_forcedShadowType = SHADOWS_NONE;
+	m_bForceShadowType = false;
+
+	TheClientNextBots().Register( this );
+}
+
+
+//-----------------------------------------------------------------------------
+C_NextBotCombatCharacter::~C_NextBotCombatCharacter()
+{
+	TheClientNextBots().UnRegister( this );
+}
+
+
+//-----------------------------------------------------------------------------
+void C_NextBotCombatCharacter::Spawn( void )
+{
+	BaseClass::Spawn();
+}
+
+
+//-----------------------------------------------------------------------------
+void C_NextBotCombatCharacter::UpdateClientSideAnimation()
+{
+	if (IsDormant())
+	{
+		return;
+	}
+
+	BaseClass::UpdateClientSideAnimation();
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void C_NextBotCombatCharacter::UpdateShadowLOD( void )
+{
+	ShadowType_t oldShadowType = m_shadowType;
+
+	if ( m_bForceShadowType )
+	{
+		m_shadowType = m_forcedShadowType;
+	}
+	else
+	{
+#ifdef NEED_SPLITSCREEN_INTEGRATION
+		FOR_EACH_VALID_SPLITSCREEN_PLAYER( hh )
+		{
+			C_BasePlayer *pl = C_BasePlayer::GetLocalPlayer(hh);
+			if ( pl )
+			{
+				Vector delta = GetAbsOrigin() - C_BasePlayer::GetLocalPlayer(hh)->GetAbsOrigin();
+#else
+		{
+			if ( C_BasePlayer::GetLocalPlayer() )
+			{
+				Vector delta = GetAbsOrigin() - C_BasePlayer::GetLocalPlayer()->GetAbsOrigin();
+#endif
+				if ( delta.IsLengthLessThan( NextBotShadowDist.GetFloat() ) )
+				{
+					m_shadowType = SHADOWS_RENDER_TO_TEXTURE_DYNAMIC;
+				}
+				else
+				{
+					m_shadowType = SHADOWS_SIMPLE;
+				}
+			}
+			else
+			{
+				m_shadowType = SHADOWS_SIMPLE;
+			}
+		}
+	}
+
+	if ( oldShadowType != m_shadowType )
+	{
+		DestroyShadow();
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+ShadowType_t C_NextBotCombatCharacter::ShadowCastType( void ) 
+{
+	if ( !IsVisible() )
+		return SHADOWS_NONE;
+
+	if ( m_shadowTimer.IsElapsed() )
+	{
+		m_shadowTimer.Start( 0.15f );
+		UpdateShadowLOD();
+	}
+
+	return m_shadowType;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+bool C_NextBotCombatCharacter::GetForcedShadowCastType( ShadowType_t* pForcedShadowType ) const
+{
+	if ( pForcedShadowType )
+	{
+		*pForcedShadowType = m_forcedShadowType;
+	}
+	return m_bForceShadowType;
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Singleton accessor.
+ * By returning a reference, we guarantee construction of the 
+ * instance before its first use.
+ */
+C_NextBotManager &TheClientNextBots( void )
+{
+	static C_NextBotManager manager;
+	return manager;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+C_NextBotManager::C_NextBotManager( void )
+{
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+C_NextBotManager::~C_NextBotManager()
+{
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void C_NextBotManager::Register( C_NextBotCombatCharacter *bot )
+{
+	m_botList.AddToTail( bot );
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void C_NextBotManager::UnRegister( C_NextBotCombatCharacter *bot )
+{
+	m_botList.FindAndRemove( bot );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool C_NextBotManager::SetupInFrustumData( void )
+{
+#ifdef ENABLE_AFTER_INTEGRATION
+	// Done already this frame.
+	if ( IsInFrustumDataValid() )
+		return true;
+
+	// Can we use the view data yet?
+	if ( !FrustumCache()->IsValid() )
+		return false;
+
+	// Get the number of active bots.
+	int nBotCount = m_botList.Count();
+
+	// Reset.
+	for ( int iBot = 0; iBot < nBotCount; ++iBot )
+	{
+		// Get the current bot.
+		C_NextBotCombatCharacter *pBot = m_botList[iBot];
+		if ( !pBot )
+			continue;
+
+		pBot->InitFrustumData();
+	}
+
+	FOR_EACH_VALID_SPLITSCREEN_PLAYER( iSlot )
+	{
+		ACTIVE_SPLITSCREEN_PLAYER_GUARD( iSlot );
+		// Get the active local player.
+		C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+		if ( !pPlayer )
+			continue;
+
+		for ( int iBot = 0; iBot < nBotCount; ++iBot )
+		{
+			// Get the current bot.
+			C_NextBotCombatCharacter *pBot = m_botList[iBot];
+			if ( !pBot )
+				continue;
+
+			// Are we in the view frustum?
+			Vector vecMin, vecMax;
+			pBot->CollisionProp()->WorldSpaceAABB( &vecMin, &vecMax );
+			bool bInFrustum = !FrustumCache()->m_Frustums[iSlot].CullBox( vecMin, vecMax );
+		
+			if ( bInFrustum )
+			{
+				Vector vecSegment;
+				VectorSubtract( pBot->GetAbsOrigin(), pPlayer->GetAbsOrigin(), vecSegment );
+				float flDistance = vecSegment.LengthSqr();
+				if ( flDistance < pBot->GetInFrustumDistanceSqr() )
+				{
+					pBot->SetInFrustumDistanceSqr( flDistance );
+				}	
+
+				pBot->SetInFrustum( true );
+			}
+		}
+	}
+
+	// Mark as setup this frame.
+	m_nInFrustumFrame = gpGlobals->framecount;
+#endif
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------
diff --git a/game/client/NextBot/C_NextBot.h b/game/client/NextBot/C_NextBot.h
new file mode 100644
index 00000000..c26d7b9b
--- /dev/null
+++ b/game/client/NextBot/C_NextBot.h
@@ -0,0 +1,134 @@
+// C_NextBot.h
+// Next generation bot system
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _C_NEXT_BOT_H_
+#define _C_NEXT_BOT_H_
+
+#include "c_ai_basenpc.h"
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+* The interface holding IBody information
+*/
+class IBodyClient
+{
+public:
+	enum ActivityType 
+	{ 
+		MOTION_CONTROLLED_XY	= 0x0001,	// XY position and orientation of the bot is driven by the animation.
+		MOTION_CONTROLLED_Z		= 0x0002,	// Z position of the bot is driven by the animation.
+		ACTIVITY_UNINTERRUPTIBLE= 0x0004,	// activity can't be changed until animation finishes
+		ACTIVITY_TRANSITORY		= 0x0008,	// a short animation that takes over from the underlying animation momentarily, resuming it upon completion
+		ENTINDEX_PLAYBACK_RATE	= 0x0010,	// played back at different rates based on entindex
+	};
+};
+
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * The client-side implementation of the NextBot
+ */
+class C_NextBotCombatCharacter : public C_BaseCombatCharacter
+{
+public:
+	DECLARE_CLASS( C_NextBotCombatCharacter, C_BaseCombatCharacter );
+	DECLARE_CLIENTCLASS();
+
+	C_NextBotCombatCharacter();
+	virtual ~C_NextBotCombatCharacter();
+
+public:	
+	virtual void Spawn( void );
+	virtual void UpdateClientSideAnimation( void );
+	virtual ShadowType_t ShadowCastType( void );
+	virtual bool IsNextBot() { return true; }
+	void ForceShadowCastType( bool bForce, ShadowType_t forcedShadowType = SHADOWS_NONE ) { m_bForceShadowType = bForce; m_forcedShadowType = forcedShadowType; }
+	bool GetForcedShadowCastType( ShadowType_t* pForcedShadowType ) const;
+
+	// Local In View Data.
+	void InitFrustumData( void )						{ m_bInFrustum = false; m_flFrustumDistanceSqr = FLT_MAX; m_nInFrustumFrame = gpGlobals->framecount; }
+	bool IsInFrustumValid( void )						{ return ( m_nInFrustumFrame == gpGlobals->framecount ); }
+	void SetInFrustum( bool bInFrustum )				{ m_bInFrustum = bInFrustum; }
+	bool IsInFrustum( void )							{ return m_bInFrustum; }
+	void SetInFrustumDistanceSqr( float flDistance )	{ m_flFrustumDistanceSqr = flDistance; }
+	float GetInFrustumDistanceSqr( void )				{ return m_flFrustumDistanceSqr; }
+
+private:
+	ShadowType_t	m_shadowType;			// Are we LOD'd to simple shadows?
+	CountdownTimer m_shadowTimer;	// Timer to throttle checks for shadow LOD
+	ShadowType_t	m_forcedShadowType;
+	bool			m_bForceShadowType;
+	void UpdateShadowLOD( void );
+
+	// Local In View Data.
+	int			m_nInFrustumFrame;
+	bool		m_bInFrustum;
+	float		m_flFrustumDistanceSqr;
+
+private:
+	C_NextBotCombatCharacter( const C_NextBotCombatCharacter & );				// not defined, not accessible
+};
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * The C_NextBotManager manager 
+ */
+class C_NextBotManager
+{
+public:
+	C_NextBotManager( void );
+	~C_NextBotManager();
+
+	/**
+	 * Execute functor for each NextBot in the system.
+	 * If a functor returns false, stop iteration early
+	 * and return false.
+	 */	
+	template < typename Functor >
+	bool ForEachCombatCharacter( Functor &func )
+	{
+		for( int i=0; i < m_botList.Count(); ++i )
+		{
+			C_NextBotCombatCharacter *character = m_botList[i];
+			if ( character->IsPlayer() )
+			{
+				continue;
+			}
+
+			if ( character->IsDormant() )
+			{
+				continue;
+			}
+
+			if ( !func( character ) )
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	int	 GetActiveCount()						    { return m_botList.Count(); }
+
+	bool SetupInFrustumData( void );
+	bool IsInFrustumDataValid( void )				{ return ( m_nInFrustumFrame == gpGlobals->framecount ); }
+
+private:
+	friend class C_NextBotCombatCharacter;
+
+	void Register( C_NextBotCombatCharacter *bot );
+	void UnRegister( C_NextBotCombatCharacter *bot );
+
+	CUtlVector< C_NextBotCombatCharacter * > m_botList;				///< list of all active NextBots
+
+	int	m_nInFrustumFrame;
+};
+
+// singleton accessor
+extern C_NextBotManager &TheClientNextBots( void );
+
+
+#endif // _C_NEXT_BOT_H_
diff --git a/game/client/client_cstrike.vpc b/game/client/client_cstrike.vpc
new file mode 100644
index 00000000..19429718
--- /dev/null
+++ b/game/client/client_cstrike.vpc
@@ -0,0 +1,275 @@
+//-----------------------------------------------------------------------------
+//	CLIENT_CSTRIKE.VPC
+//
+//	Project Script
+//-----------------------------------------------------------------------------
+
+$Macro SRCDIR		"..\.."
+$Macro GAMENAME 	"cstrike"
+
+$Include "$SRCDIR\game\client\client_base.vpc"
+
+$Configuration
+{
+	$Compiler
+	{
+		$AdditionalIncludeDirectories		"$BASE;$SRCDIR\game\shared\cstrike\control,.\cstrike,.\cstrike\control,.\cstrike\VGUI,$SRCDIR\game\shared\cstrike"
+		$PreprocessorDefinitions			"$BASE;CSTRIKE_DLL;NEXT_BOT"
+	}
+}
+
+$Project "Client (CStrike)"
+{
+	$Folder "Replay"
+	{
+		$File	"cstrike\cs_replay.cpp"
+		$File	"cstrike\cs_replay.h"
+	}
+	
+	$Folder	"Source Files"
+	{
+		-$File	"$SRCDIR\game\shared\weapon_parse_default.cpp"
+		
+		$File	"c_team_objectiveresource.cpp"
+		$File	"c_team_objectiveresource.h"
+		$File	"c_team_train_watcher.cpp"
+		$File	"c_team_train_watcher.h"
+		$File	"hud_base_account.cpp"
+		$File	"hud_base_account.h"
+		$File	"hud_voicestatus.cpp"
+		$File	"hud_baseachievement_tracker.cpp"
+		$File	"hud_baseachievement_tracker.h"
+		$File	"$SRCDIR\game\client\hud_vote.h"
+		$File	"$SRCDIR\game\client\hud_vote.cpp"
+		$File	"$SRCDIR\game\shared\predicted_viewmodel.cpp"
+		$File	"$SRCDIR\game\shared\predicted_viewmodel.h"
+		
+		$Folder	"CounterStrike DLL"
+		{
+			$File	"$SRCDIR\game\shared\cstrike\cs_achievement_constants.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_achievementdefs.h"
+			$File   "$SRCDIR\game\shared\cs_achievements_and_stats_interface.cpp"
+			$File   "$SRCDIR\game\shared\cs_achievements_and_stats_interface.h"
+			$File	"$SRCDIR\game\shared\cstrike\achievements_cs.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\achievements_cs.h"
+			$File	"$SRCDIR\game\shared\cstrike\basecsgrenade_projectile.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\basecsgrenade_projectile.h"
+			$File	"cstrike\buy_presets\buy_preset.cpp"
+			$File	"cstrike\buy_presets\buy_preset_debug.cpp"
+			$File	"cstrike\buy_presets\buy_preset_debug.h"
+			$File	"cstrike\buy_presets\buy_preset_weapon_info.cpp"
+			$File	"cstrike\buy_presets\buy_presets.cpp"
+			$File	"cstrike\buy_presets\buy_presets.h"
+			$File	"cstrike\c_cs_hostage.cpp"
+			$File	"cstrike\c_cs_hostage.h"
+			$File	"cstrike\c_cs_player.cpp"
+			$File	"cstrike\c_cs_player.h"
+			$File	"cstrike\c_cs_playerresource.cpp"
+			$File	"cstrike\c_cs_playerresource.h"
+			$File	"cstrike\c_cs_team.cpp"
+			$File	"cstrike\c_cs_team.h"
+			$File	"cstrike\c_csrootpanel.cpp"
+			$File	"cstrike\c_csrootpanel.h"
+			$File	"cstrike\c_plantedc4.cpp"
+			$File	"cstrike\c_plantedc4.h"
+			$File	"cstrike\c_te_radioicon.cpp"
+			$File	"cstrike\c_te_shotgun_shot.cpp"
+			$File	"cstrike\clientmode_csnormal.cpp"
+			$File	"cstrike\clientmode_csnormal.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_ammodef.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_ammodef.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamemovement.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamerules.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamerules.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamestats_shared.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamestats_shared.h"
+			$File	"$SRCDIR\game\shared\steamworks_gamestats.cpp"
+			$File	"$SRCDIR\game\shared\steamworks_gamestats.h"			
+			$File	"cstrike\cs_in_main.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_player_shared.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_playeranimstate.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_playeranimstate.h"
+			$File	"cstrike\cs_prediction.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_shareddefs.cpp"
+			$File	"cstrike\cs_client_gamestats.cpp"
+			$File	"cstrike\cs_client_gamestats.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_usermessages.cpp"
+			$File	"cstrike\cs_view_scene.cpp"
+			$File	"cstrike\cs_view_scene.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_weapon_parse.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_weapon_parse.h"
+			$File	"cstrike\fx_cs_blood.cpp"
+			$File	"cstrike\fx_cs_blood.h"
+			$File	"cstrike\fx_cs_impacts.cpp"
+			$File	"cstrike\fx_cs_knifeslash.cpp"
+			$File	"cstrike\fx_cs_muzzleflash.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\fx_cs_shared.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\fx_cs_shared.h"
+			$File	"cstrike\fx_cs_weaponfx.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\bot\shared_util.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\bot\shared_util.h"
+			$File	"cstrike\vgui_rootpanel_cs.cpp"
+			
+			$Folder "HUD Elements"
+			{
+				$File	"cstrike\cs_hud_ammo.cpp"
+				$File	"cstrike\cs_hud_chat.cpp"
+				$File	"cstrike\cs_hud_chat.h"
+				$File	"cstrike\cs_hud_damageindicator.cpp"
+				$File	"cstrike\cs_hud_freezepanel.cpp"
+				$File	"cstrike\cs_hud_freezepanel.h"
+				$File	"cstrike\cs_hud_playerhealth.cpp"
+				$File	"cstrike\cs_hud_playerhealth.h"			
+				$File	"cstrike\cs_hud_health.cpp"
+				$File	"cstrike\cs_hud_scope.cpp"
+				$File	"cstrike\cs_hud_target_id.cpp"
+				$File	"cstrike\cs_hud_weaponselection.cpp"
+				$File	"cstrike\hud_account.cpp"
+				$File	"cstrike\hud_armor.cpp"
+				$File	"cstrike\hud_c4.cpp"
+				$File	"cstrike\hud_deathnotice.cpp"
+				$File	"cstrike\hud_defuser.cpp"
+				$File	"cstrike\hud_flashbang.cpp"
+				$File	"cstrike\hud_hostagerescue.cpp"
+				$File	"cstrike\hud_progressbar.cpp"
+				$File	"cstrike\hud_radar.cpp"
+				$File	"cstrike\hud_radar.h"
+				$File	"cstrike\hud_roundtimer.cpp"
+				$File	"cstrike\hud_scenarioicon.cpp"
+				$File	"cstrike\hud_shopping_cart.cpp"
+				$File	"cstrike\cs_hud_achievement_announce.cpp"
+				$File	"cstrike\cs_hud_achievement_announce.h"
+				$File	"cstrike\cs_hud_achievement_tracker.cpp"
+				$File	"cstrike\radio_status.cpp"
+				$File	"cstrike\radio_status.h"
+			}
+			
+			$Folder "Weapon"
+			{
+				$File	"$SRCDIR\game\shared\cstrike\weapon_ak47.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_aug.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_awp.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_basecsgrenade.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_basecsgrenade.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_c4.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_c4.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_csbase.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_csbase.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_csbasegun.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_csbasegun.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_deagle.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_elite.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_famas.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_fiveseven.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_flashbang.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_flashbang.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_g3sg1.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_galil.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_glock.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_hegrenade.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_hegrenade.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_knife.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_knife.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_m249.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_m3.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_m4a1.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_mac10.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_mp5navy.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_p228.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_p90.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_scout.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_sg550.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_sg552.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_smokegrenade.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_smokegrenade.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_tmp.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_ump45.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_usp.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_xm1014.cpp"
+			}
+
+			$Folder	"vgui"
+			{
+				$File	"cstrike\VGUI\achievement_stats_summary.cpp"
+				$File	"cstrike\VGUI\achievement_stats_summary.h"
+				$File	"cstrike\VGUI\achievements_page.cpp"
+				$File	"cstrike\VGUI\achievements_page.h"
+				$File	"cstrike\VGUI\stats_summary.cpp"
+				$File	"cstrike\VGUI\stats_summary.h"
+				$File	"cstrike\VGUI\stat_card.cpp"
+				$File	"cstrike\VGUI\stat_card.h"
+				$File	"cstrike\VGUI\base_stats_page.cpp"
+				$File	"cstrike\VGUI\base_stats_page.h"
+				$File	"cstrike\VGUI\match_stats_page.cpp"
+				$File	"cstrike\VGUI\match_stats_page.h"
+				$File	"cstrike\VGUI\lifetime_stats_page.cpp"
+				$File	"cstrike\VGUI\lifetime_stats_page.h"
+				$File	"cstrike\VGUI\bordered_panel.cpp"
+				$File	"cstrike\VGUI\bordered_panel.h"
+				$File	"cstrike\VGUI\backgroundpanel.cpp"
+				$File	"cstrike\VGUI\backgroundpanel.h"
+				$File	"cstrike\VGUI\buymouseoverpanelbutton.h"
+				$File	"cstrike\VGUI\buypreset_imageinfo.cpp"
+				$File	"cstrike\VGUI\buypreset_listbox.cpp"
+				$File	"cstrike\VGUI\buypreset_listbox.h"
+				$File	"cstrike\VGUI\buypreset_panel.cpp"
+				$File	"cstrike\VGUI\buypreset_weaponsetlabel.h"
+				$File	"cstrike\VGUI\career_box.cpp"
+				$File	"cstrike\VGUI\career_box.h"
+				$File	"cstrike\VGUI\career_button.cpp"
+				$File	"cstrike\VGUI\career_button.h"
+				$File	"cstrike\VGUI\counterstrikeviewport.cpp"
+				$File	"cstrike\VGUI\counterstrikeviewport.h"
+				$File	"cstrike\VGUI\cstrikebuyequipmenu.cpp"
+				$File	"cstrike\VGUI\cstrikebuyequipmenu.h"
+				$File	"cstrike\VGUI\cstrikebuymenu.cpp"
+				$File	"cstrike\VGUI\cstrikebuymenu.h"
+				$File	"cstrike\VGUI\cstrikebuysubmenu.h"
+				$File	"cstrike\VGUI\cstrikeclassmenu.cpp"
+				$File	"cstrike\VGUI\cstrikeclassmenu.h"
+				$File	"cstrike\VGUI\cstrikeclientscoreboard.cpp"
+				$File	"cstrike\VGUI\cstrikeclientscoreboard.h"
+				$File	"cstrike\VGUI\cstrikespectatorgui.cpp"
+				$File	"cstrike\VGUI\cstrikespectatorgui.h"
+				$File	"cstrike\VGUI\cstriketeammenu.cpp"
+				$File	"cstrike\VGUI\cstriketeammenu.h"
+				$File	"cstrike\VGUI\cstriketextwindow.cpp"
+				$File	"cstrike\VGUI\cstriketextwindow.h"
+				$File	"cstrike\vgui_c4panel.cpp"
+				$File	"cstrike\vgui_viewc4panel.cpp"
+				$File	"cstrike\VGUI\win_panel_round.cpp"
+				$File	"cstrike\VGUI\win_panel_round.h"
+			}
+
+			$Folder	"NextBot"
+			{
+				$File	"NextBot\C_NextBot.cpp"
+				$File	"NextBot\C_NextBot.h"
+			}
+		}
+
+		$Folder	"game_controls"
+		{
+			$File	"game_controls\buymenu.cpp"
+			$File	"game_controls\buysubmenu.cpp"
+			$File	"game_controls\classmenu.cpp"
+		}
+	}
+	
+	$Folder	"Header Files"
+	{
+
+		$Folder	"game_controls header files"
+		{
+			$File	"game_controls\buymenu.h"
+			$File	"game_controls\buysubmenu.h"
+			$File	"game_controls\classmenu.h"
+		}
+	}
+
+	$Folder	"Link Libraries" 
+	{
+		$Lib vtf
+	}
+
+}
diff --git a/game/client/cstrike/VGUI/achievement_stats_summary.cpp b/game/client/cstrike/VGUI/achievement_stats_summary.cpp
new file mode 100644
index 00000000..81ef2983
--- /dev/null
+++ b/game/client/cstrike/VGUI/achievement_stats_summary.cpp
@@ -0,0 +1,120 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "achievement_stats_summary.h"
+#include "achievements_page.h"
+#include "lifetime_stats_page.h"
+#include "match_stats_page.h"
+#include "stats_summary.h"
+
+#include <stdio.h>
+
+using namespace vgui;
+
+#include <vgui/ILocalize.h>
+#include "vgui/ISurface.h"
+
+#include "filesystem.h"
+#include <KeyValues.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+
+const int cDialogWidth = 900;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CAchievementAndStatsSummary::CAchievementAndStatsSummary(vgui::Panel *parent) : BaseClass(parent, "AchievementAndStatsSummary")
+{
+    SetDeleteSelfOnClose(false);
+    //SetBounds(0, 0, 640, 384);
+    SetBounds(0, 0, 900, 780);
+    SetMinimumSize( 640, 780 );
+    SetSizeable( false );
+
+    SetTitle("#GameUI_CreateAchievementsAndStats", true);
+    SetOKButtonText("#GameUI_Close");
+    SetCancelButtonVisible(false);
+
+	m_pStatsSummary = new CStatsSummary( this, "StatsSummary" );
+    m_pAchievementsPage = new CAchievementsPage(this, "AchievementsPage");
+    m_pLifetimeStatsPage = new CLifetimeStatsPage(this, "StatsPage");
+	m_pMatchStatsPage = new CMatchStatsPage(this, "MatchStatsPage");
+
+	AddPage(m_pStatsSummary, "#GameUI_Stats_Summary");
+	AddPage(m_pAchievementsPage, "#GameUI_Achievements_Tab");    
+	AddPage(m_pMatchStatsPage, "#GameUI_MatchStats");
+	AddPage(m_pLifetimeStatsPage, "#GameUI_LifetimeStats");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CAchievementAndStatsSummary::~CAchievementAndStatsSummary()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CAchievementAndStatsSummary::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	int screenWide, screenTall;
+	surface()->GetScreenSize( screenWide, screenTall );
+
+	// [smessick] Close the achievements dialog for a low resolution screen.
+	if ( screenWide < cAchievementsDialogMinWidth )
+	{
+		OnOK( true );
+		Close();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: runs the server when the OK button is pressed
+//-----------------------------------------------------------------------------
+bool CAchievementAndStatsSummary::OnOK(bool applyOnly)
+{
+    BaseClass::OnOK(applyOnly);
+
+    return true;
+}
+
+//----------------------------------------------------------
+// Purpose: Preserve our width to the one in the .res file
+//----------------------------------------------------------
+void CAchievementAndStatsSummary::OnSizeChanged(int newWide, int newTall)
+{
+    // Lock the width, but allow height scaling
+    if ( newWide != cDialogWidth )
+    {
+        SetSize( cDialogWidth, newTall );
+        return;
+    }
+
+    BaseClass::OnSizeChanged(newWide, newTall);
+}
+
+//----------------------------------------------------------
+// Purpose: Processes when summary dialog is activated.
+//----------------------------------------------------------
+void CAchievementAndStatsSummary::Activate()
+{
+	m_pStatsSummary->MakeReadyForUse();
+	m_pStatsSummary->UpdateStatsData();
+    m_pAchievementsPage->UpdateAchievementDialogInfo();
+    m_pLifetimeStatsPage->UpdateStatsData();
+	m_pMatchStatsPage->UpdateStatsData();
+
+    BaseClass::Activate();
+}
diff --git a/game/client/cstrike/VGUI/achievement_stats_summary.h b/game/client/cstrike/VGUI/achievement_stats_summary.h
new file mode 100644
index 00000000..c73b4d73
--- /dev/null
+++ b/game/client/cstrike/VGUI/achievement_stats_summary.h
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef ACHIEVEMENTANDSTATSSUMMARY_H
+#define ACHIEVEMENTANDSTATSSUMMARY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/PropertyDialog.h>
+
+class CAchievementsPage;
+class CLifetimeStatsPage;
+class CMatchStatsPage;
+class StatCard;
+class CStatsSummary;
+
+const int cAchievementsDialogMinWidth = 1024; // don't show this screen for lower resolutions
+
+//-----------------------------------------------------------------------------
+// Purpose: dialog for displaying the achievements/stats summary
+//-----------------------------------------------------------------------------
+class CAchievementAndStatsSummary : public vgui::PropertyDialog
+{
+    DECLARE_CLASS_SIMPLE( CAchievementAndStatsSummary, vgui::PropertyDialog );
+
+public:
+    CAchievementAndStatsSummary(vgui::Panel *parent);
+    ~CAchievementAndStatsSummary();
+
+    virtual void Activate();
+
+	void OnKeyCodePressed( vgui::KeyCode code )
+	{
+		if ( code == KEY_XBUTTON_B )
+		{
+			Close();
+		}
+		else
+		{
+			BaseClass::OnKeyCodePressed(code);
+		}
+	}
+
+protected:
+    virtual bool OnOK(bool applyOnly);
+    virtual void OnSizeChanged( int newWide, int newTall );
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+private:
+    CAchievementsPage*  m_pAchievementsPage;
+    CLifetimeStatsPage* m_pLifetimeStatsPage;
+	CMatchStatsPage*	m_pMatchStatsPage;
+	CStatsSummary*		m_pStatsSummary;
+};
+
+
+#endif // ACHIEVEMENTANDSTATSSUMMARY_H
diff --git a/game/client/cstrike/VGUI/achievements_page.cpp b/game/client/cstrike/VGUI/achievements_page.cpp
new file mode 100644
index 00000000..bc6036e3
--- /dev/null
+++ b/game/client/cstrike/VGUI/achievements_page.cpp
@@ -0,0 +1,1061 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Display a list of achievements for the current game
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "achievements_page.h"
+#include "vgui_controls/Button.h"
+#include "vgui/ILocalize.h"
+#include "ixboxsystem.h"
+#include "iachievementmgr.h"
+#include "filesystem.h"
+#include "vgui_controls/ImagePanel.h"
+#include "vgui_controls/ComboBox.h"
+#include "vgui_controls/CheckButton.h"
+#include "fmtstr.h"
+#include "c_cs_playerresource.h"
+#include "stat_card.h"
+#include <vgui/IInput.h>
+
+#include "../../../public/steam/steam_api.h"
+#include "achievementmgr.h"
+#include "../../../../public/vgui/IScheme.h"
+#include "../vgui_controls/ScrollBar.h"
+#include "achievements_cs.h"
+
+extern CAchievementMgr g_AchievementMgrCS;
+
+using namespace vgui;
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+KeyValues *g_pPreloadedCSAchievementPageItemLayout = NULL;
+KeyValues *g_pPreloadedCSAchievementPageGroupLayout = NULL;
+
+// Shared helper functions so xbox and pc can share as much code as possible while coming from different bases.
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the parameter pIconPanel to display the specified achievement's icon file.
+//-----------------------------------------------------------------------------
+bool CSLoadAchievementIconForPage( vgui::ImagePanel* pIconPanel, CCSBaseAchievement* pAchievement, const char *pszExt /*= NULL*/ )
+{
+    char imagePath[_MAX_PATH];
+    Q_strncpy( imagePath, "achievements\\", sizeof(imagePath) );
+    Q_strncat( imagePath, pAchievement->GetName(), sizeof(imagePath), COPY_ALL_CHARACTERS );
+    if ( pszExt )
+    {
+        Q_strncat( imagePath, pszExt, sizeof(imagePath), COPY_ALL_CHARACTERS );
+    }
+    Q_strncat( imagePath, ".vtf", sizeof(imagePath), COPY_ALL_CHARACTERS );
+
+    char checkFile[_MAX_PATH];
+    Q_snprintf( checkFile, sizeof(checkFile), "materials\\vgui\\%s", imagePath );
+    if ( !g_pFullFileSystem->FileExists( checkFile ) )
+    {
+        Q_snprintf( imagePath, sizeof(imagePath), "hud\\icon_locked.vtf" );
+    }
+
+    pIconPanel->SetShouldScaleImage( true );
+    pIconPanel->SetImage( imagePath );
+    pIconPanel->SetVisible( true );
+
+    return pIconPanel->IsVisible();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the parameter pIconPanel to display the specified achievement's icon file.
+//-----------------------------------------------------------------------------
+bool CSLoadIconForPage( vgui::ImagePanel* pIconPanel, const char* pFilename, const char *pszExt /*= NULL*/ )
+{
+    char imagePath[_MAX_PATH];
+    Q_strncpy( imagePath, "achievements\\", sizeof(imagePath) );
+    Q_strncat( imagePath, pFilename, sizeof(imagePath), COPY_ALL_CHARACTERS );
+    if ( pszExt )
+    {
+        Q_strncat( imagePath, pszExt, sizeof(imagePath), COPY_ALL_CHARACTERS );
+    }
+    Q_strncat( imagePath, ".vtf", sizeof(imagePath), COPY_ALL_CHARACTERS );
+
+    char checkFile[_MAX_PATH];
+    Q_snprintf( checkFile, sizeof(checkFile), "materials\\vgui\\%s", imagePath );
+    if ( !g_pFullFileSystem->FileExists( checkFile ) )
+    {
+        Q_snprintf( imagePath, sizeof(imagePath), "hud\\icon_locked.vtf" );
+    }
+
+    pIconPanel->SetShouldScaleImage( true );
+    pIconPanel->SetImage( imagePath );
+    pIconPanel->SetVisible( true );
+
+    return pIconPanel->IsVisible();
+}
+
+//-----------------------------------------------------------------------------
+// The bias is to ensure the percentage bar gets plenty orange before it reaches the text,
+// as the white-on-grey is hard to read.
+//-----------------------------------------------------------------------------
+Color CSLerpColorsForPage ( Color cStart, Color cEnd, float flPercent )
+{
+    float r = (float)((float)(cStart.r()) + (float)(cEnd.r() - cStart.r()) * Bias( flPercent, 0.75 ) );
+    float g = (float)((float)(cStart.g()) + (float)(cEnd.g() - cStart.g()) * Bias( flPercent, 0.75 ) );
+    float b = (float)((float)(cStart.b()) + (float)(cEnd.b() - cStart.b()) * Bias( flPercent, 0.75 ) );
+    float a = (float)((float)(cStart.a()) + (float)(cEnd.a() - cStart.a()) * Bias( flPercent, 0.75 ) );
+    return Color( r, g, b, a );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Shares common percentage bar calculations/color settings between xbox and pc.
+//			Not really intended for robustness or reuse across many panels.
+// Input  : pFrame - assumed to have certain child panels (see below)
+//			*pAchievement - source achievement to poll for progress. Non progress achievements will not show a percentage bar.
+//-----------------------------------------------------------------------------
+void CSUpdateProgressBarForPage( vgui::EditablePanel* pPanel, CCSBaseAchievement* pAchievement, Color clrProgressBar )
+{
+    ///*
+    if ( pAchievement->GetGoal() > 1 )
+    {
+        bool bShowProgress = true;
+
+        // if this achievement gets saved with game and we're not in a level and have not achieved it, then we do not have any state 
+        // for this achievement, don't show progress
+        if ( ( pAchievement->GetFlags() & ACH_SAVE_WITH_GAME ) && /*!GameUI().IsInLevel() &&*/ !pAchievement->IsAchieved() )
+        {
+            bShowProgress = false;
+        }
+
+        float flCompletion = 0.0f;
+
+        // Once achieved, we can't rely on count. If they've completed the achievement just set to 100%.
+        int iCount = pAchievement->GetCount();
+        if ( pAchievement->IsAchieved() )
+        {
+            flCompletion = 1.0f;
+            iCount = pAchievement->GetGoal();
+        }
+        else if ( bShowProgress )
+        {
+            flCompletion = ( ((float)pAchievement->GetCount()) / ((float)pAchievement->GetGoal()) );
+            // In rare cases count can exceed goal and not be achieved (switch local storage on X360, take saved game from different user on PC).
+            // These will self-correct with continued play, but if we're in that state don't show more than 100% achieved.
+            flCompletion = MIN( flCompletion, 1.0 );
+        }
+
+        char szPercentageText[ 256 ] = "";
+        if  ( bShowProgress )
+        {
+            Q_snprintf( szPercentageText, 256, "%d/%d", iCount, pAchievement->GetGoal() );			
+        }	
+
+        pPanel->SetControlString( "PercentageText", szPercentageText );
+        pPanel->SetControlVisible( "PercentageText", true );
+        pPanel->SetControlVisible( "CompletionText", true );
+
+        vgui::ImagePanel *pPercentageBar	= (vgui::ImagePanel*)pPanel->FindChildByName( "PercentageBar" );
+        vgui::ImagePanel *pPercentageBarBkg = (vgui::ImagePanel*)pPanel->FindChildByName( "PercentageBarBackground" );
+
+        if ( pPercentageBar && pPercentageBarBkg )
+        {
+            pPercentageBar->SetFillColor( clrProgressBar );
+            pPercentageBar->SetWide( pPercentageBarBkg->GetWide() * flCompletion );
+
+            pPanel->SetControlVisible( "PercentageBarBackground", IsX360() ? bShowProgress : true );
+            pPanel->SetControlVisible( "PercentageBar", true );
+        }
+    }
+    //*/
+}
+
+// TODO: revisit this once other games are rebuilt using the updated IAchievement interface
+bool CSGameSupportsAchievementTrackerForPage()
+{
+    const char *pGame = Q_UnqualifiedFileName( engine->GetGameDirectory() );
+    return ( !Q_stricmp( pGame, "cstrike" ) );
+}
+
+//////////////////////////////////////////////////////////////////////////
+// PC Implementation
+//////////////////////////////////////////////////////////////////////////
+
+
+
+int AchivementSortPredicate( CCSBaseAchievement* const* pLeft, CCSBaseAchievement* const* pRight )
+{
+	if ( (*pLeft)->IsAchieved() && !(*pRight)->IsAchieved() )
+		return -1;
+
+	if ( !(*pLeft)->IsAchieved() && (*pRight)->IsAchieved() )
+		return 1;
+
+	if ( (*pLeft)->GetAchievementID() < (*pRight)->GetAchievementID() )
+		return -1;
+
+	if ( (*pLeft)->GetAchievementID() > (*pRight)->GetAchievementID() )
+		return 1;
+
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: creates child panels, passes down name to pick up any settings from res files.
+//-----------------------------------------------------------------------------
+CAchievementsPage::CAchievementsPage(vgui::Panel *parent, const char *name) : BaseClass(parent, "CSAchievementsDialog")
+{
+	m_iFixedWidth = 900; // Give this an initial value in order to set a proper size
+    SetBounds(0, 0, 900, 780);
+    SetMinimumSize( 256, 780 );
+
+	m_pStatCard = new StatCard(this, "ignored");
+
+    m_pAchievementsList = new vgui::PanelListPanel( this, "listpanel_achievements" );
+    m_pAchievementsList->SetFirstColumnWidth( 0 );
+
+    m_pGroupsList = new vgui::PanelListPanel( this, "listpanel_groups" );
+    m_pGroupsList->SetFirstColumnWidth( 0 );
+
+    m_pListBG = new vgui::ImagePanel( this, "listpanel_background" );
+
+    m_pPercentageBarBackground = SETUP_PANEL( new ImagePanel( this, "PercentageBarBackground" ) );
+    m_pPercentageBar = SETUP_PANEL( new ImagePanel( this, "PercentageBar" ) );    
+
+	ListenForGameEvent( "player_stats_updated" );
+	ListenForGameEvent( "achievement_earned_local" );
+
+    // int that holds the highest number achievement id we've found
+    int iHighestAchievementIDSeen = -1;
+    int iNextGroupBoundary = 1000;
+
+    Q_memset( m_AchievementGroups, 0, sizeof(m_AchievementGroups) );
+    m_iNumAchievementGroups = 0;
+
+    // Base groups
+    int iCount = g_AchievementMgrCS.GetAchievementCount();
+    for ( int i = 0; i < iCount; ++i )
+    {
+        CCSBaseAchievement* pAchievement = dynamic_cast<CCSBaseAchievement*>(g_AchievementMgrCS.GetAchievementByIndex( i ));
+
+        if ( !pAchievement )
+            continue;
+
+        int iAchievementID = pAchievement->GetAchievementID();
+
+        if ( iAchievementID > iHighestAchievementIDSeen )
+        {
+            // if it's crossed the next group boundary, create a new group
+            if ( iAchievementID >= iNextGroupBoundary )
+            {
+                int iNewGroupBoundary = iAchievementID;
+                CreateNewAchievementGroup( iNewGroupBoundary, iNewGroupBoundary+99 );
+
+                iNextGroupBoundary = iNewGroupBoundary + 100;
+            }
+
+            iHighestAchievementIDSeen = iAchievementID;
+        }
+    }
+
+	LoadControlSettings("resource/ui/CSAchievementsDialog.res");
+	UpdateTotalProgressDisplay();
+    CreateOrUpdateComboItems( true );
+
+    // Default display shows the first achievement group
+    UpdateAchievementList(1001, 1100);
+
+	m_bStatsDirty = true;
+	m_bAchievementsDirty = true;
+}
+
+CAchievementsPage::~CAchievementsPage()
+{
+    g_AchievementMgrCS.SaveGlobalStateIfDirty( false );		// check for saving here to store achievements we want pinned to HUD
+
+    m_pAchievementsList->DeleteAllItems();
+    delete m_pAchievementsList;
+    delete m_pPercentageBarBackground;
+    delete m_pPercentageBar;
+}
+
+void CAchievementsPage::CreateNewAchievementGroup( int iMinRange, int iMaxRange )
+{
+    m_AchievementGroups[m_iNumAchievementGroups].m_iMinRange = iMinRange;
+    m_AchievementGroups[m_iNumAchievementGroups].m_iMaxRange = iMaxRange;
+    m_iNumAchievementGroups++;
+}
+
+//----------------------------------------------------------
+// Get the width we're going to lock at
+//----------------------------------------------------------
+void CAchievementsPage::ApplySettings( KeyValues *pResourceData )
+{
+    m_iFixedWidth = pResourceData->GetInt( "wide", 512 );
+
+    BaseClass::ApplySettings( pResourceData );
+}
+
+//----------------------------------------------------------
+// Preserve our width to the one in the .res file
+//----------------------------------------------------------
+void CAchievementsPage::OnSizeChanged(int newWide, int newTall)
+{
+    // Lock the width, but allow height scaling
+    if ( newWide != m_iFixedWidth )
+    {
+        SetSize( m_iFixedWidth, newTall );
+        return;
+    }
+
+    BaseClass::OnSizeChanged(newWide, newTall);
+}
+
+//----------------------------------------------------------
+// Re-populate the achievement list with the selected group
+//----------------------------------------------------------
+void CAchievementsPage::UpdateAchievementList(CAchievementsPageGroupPanel* groupPanel)
+{
+    if (!groupPanel)
+        return;
+
+    UpdateAchievementList( groupPanel->GetFirstAchievementID(), groupPanel->GetLastAchievementID() );
+
+    vgui::IScheme *pGroupScheme = scheme()->GetIScheme( GetScheme() );
+
+    // Update active status for button display
+    for (int i = 0; i < m_pGroupsList->GetItemCount(); i++)
+    {
+        CAchievementsPageGroupPanel *pPanel = (CAchievementsPageGroupPanel*)m_pGroupsList->GetItemPanel(i);
+        if ( pPanel )
+        {
+            if ( pPanel != groupPanel )
+            {
+                pPanel->SetGroupActive( false );
+            }
+            else
+            {
+                pPanel->SetGroupActive( true );
+            }
+
+            pPanel->UpdateAchievementInfo( pGroupScheme );
+        }
+    }
+}
+
+void CAchievementsPage::UpdateTotalProgressDisplay()
+{
+	// Set up total completion percentage bar
+	float flCompletion = 0.0f;
+
+	int iCount = g_AchievementMgrCS.GetAchievementCount();
+	int nUnlocked = 0;
+
+	if ( iCount > 0 )
+	{
+		for ( int i = 0; i < iCount; ++i )
+		{
+			CCSBaseAchievement* pAchievement = dynamic_cast<CCSBaseAchievement*>(g_AchievementMgrCS.GetAchievementByIndex( i ));
+
+			if ( pAchievement && pAchievement->IsAchieved() )
+				++nUnlocked;
+		}
+
+		flCompletion = (((float)nUnlocked) / ((float)g_AchievementMgrCS.GetAchievementCount()));
+	}
+
+	char szPercentageText[64];
+	V_sprintf_safe( szPercentageText, "%d / %d",
+		nUnlocked, g_AchievementMgrCS.GetAchievementCount() );
+
+	SetControlString( "PercentageText", szPercentageText );
+	SetControlVisible( "PercentageText", true );
+	SetControlVisible( "CompletionText", true );
+
+	vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
+
+	Color clrHighlight = pScheme->GetColor( "NewGame.SelectionColor", Color(255, 255, 255, 255) );
+	Color clrWhite(255, 255, 255, 255);
+
+	Color cProgressBar = Color( static_cast<float>( clrHighlight.r() ) * ( 1.0f - flCompletion ) + static_cast<float>( clrWhite.r() ) * flCompletion,
+		static_cast<float>( clrHighlight.g() ) * ( 1.0f - flCompletion ) + static_cast<float>( clrWhite.g() ) * flCompletion,
+		static_cast<float>( clrHighlight.b() ) * ( 1.0f - flCompletion ) + static_cast<float>( clrWhite.b() ) * flCompletion,
+		static_cast<float>( clrHighlight.a() ) * ( 1.0f - flCompletion ) + static_cast<float>( clrWhite.a() ) * flCompletion );
+
+	m_pPercentageBar->SetFgColor( cProgressBar );
+	m_pPercentageBar->SetWide( m_pPercentageBarBackground->GetWide() * flCompletion );
+
+	SetControlVisible( "PercentageBarBackground", true );
+	SetControlVisible( "PercentageBar", true );
+}
+
+//----------------------------------------------------------
+// Re-populate the achievement list with the selected group
+//----------------------------------------------------------
+void CAchievementsPage::UpdateAchievementList(int minID, int maxID)
+{
+    int iMinRange = minID;
+    int iMaxRange = maxID;
+
+	int iCount = g_AchievementMgrCS.GetAchievementCount();
+
+	CUtlVector<CCSBaseAchievement*> sortedAchivementList;
+	sortedAchivementList.EnsureCapacity(iCount);
+
+    for ( int i = 0; i < iCount; ++i )
+    {		
+        CCSBaseAchievement* pAchievement = dynamic_cast<CCSBaseAchievement*>(g_AchievementMgrCS.GetAchievementByIndex(i));
+
+        if ( !pAchievement )
+            continue;
+
+        int iAchievementID = pAchievement->GetAchievementID();
+
+        if ( iAchievementID < iMinRange || iAchievementID > iMaxRange )
+            continue;
+
+        // don't show hidden achievements if not achieved
+        if ( pAchievement->ShouldHideUntilAchieved() && !pAchievement->IsAchieved() )
+            continue;
+
+		sortedAchivementList.AddToTail(pAchievement);
+	}
+
+	sortedAchivementList.Sort(AchivementSortPredicate);
+
+	m_pAchievementsList->DeleteAllItems();
+
+	FOR_EACH_VEC(sortedAchivementList, i)
+	{
+		CCSBaseAchievement* pAchievement = sortedAchivementList[i];
+
+		CAchievementsPageItemPanel *pAchievementItemPanel = new CAchievementsPageItemPanel( m_pAchievementsList, "AchievementDialogItemPanel");
+		pAchievementItemPanel->SetAchievementInfo(pAchievement);
+
+		// force all our new panel to have the correct internal layout and size so that our parent container can layout properly
+		pAchievementItemPanel->InvalidateLayout(true, true);
+
+		m_pAchievementsList->AddItem( NULL, pAchievementItemPanel );
+	}
+
+	m_pAchievementsList->MoveScrollBarToTop();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads settings from achievementsdialog.res in hl2/resource/ui/
+//			Sets up progress bar displaying total achievement unlocking progress by the user.
+//-----------------------------------------------------------------------------
+void CAchievementsPage::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+    BaseClass::ApplySchemeSettings( pScheme );
+
+	m_pGroupsList->SetBgColor(Color(86,86,86,255));
+
+	SetBgColor(Color(86,86,86,255));
+
+	// Set text color for percentage
+	Panel *pPanel;
+	pPanel = FindChildByName("PercentageText");
+	if (pPanel)
+	{
+		pPanel->SetFgColor(Color(157, 194, 80, 255));
+	}
+
+	// Set text color for achievement earned label
+	pPanel = FindChildByName("AchievementsEarnedLabel");
+	if (pPanel)
+	{
+		pPanel->SetFgColor(Color(157, 194, 80, 255));
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Each sub-panel gets its data updated
+//-----------------------------------------------------------------------------
+void CAchievementsPage::UpdateAchievementDialogInfo( void )
+{
+    // Hide the group list scrollbar
+    if (m_pGroupsList->GetScrollbar())
+    {
+        m_pGroupsList->GetScrollbar()->SetWide(0);
+    }
+
+    int iCount = m_pAchievementsList->GetItemCount();
+    vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
+
+    int i;
+    for ( i = 0; i < iCount; i++ )
+    {
+        CAchievementsPageItemPanel *pPanel = (CAchievementsPageItemPanel*)m_pAchievementsList->GetItemPanel(i);
+        if ( pPanel )
+        {
+            pPanel->UpdateAchievementInfo( pScheme );
+        }
+    }
+
+    // Update all group panels
+    int iGroupCount = m_pGroupsList->GetItemCount();
+    for ( i = 0; i < iGroupCount; i++ )
+    {
+        CAchievementsPageGroupPanel *pPanel = (CAchievementsPageGroupPanel*)m_pGroupsList->GetItemPanel(i);
+        if ( pPanel )
+        {
+            pPanel->UpdateAchievementInfo( pScheme );
+
+            if ( pPanel->IsGroupActive() )
+            {
+                UpdateAchievementList( pPanel );
+            }
+        }
+    }
+
+    // update the groups and overall progress bar
+    CreateOrUpdateComboItems( false );	// update them with new achieved counts	
+
+	UpdateTotalProgressDisplay();
+
+	m_pStatCard->UpdateInfo();
+
+	m_bAchievementsDirty = false;
+	m_bStatsDirty = false;
+}
+
+void CAchievementsPage::CreateOrUpdateComboItems( bool bCreate )
+{
+    // Build up achievement group names
+    for ( int i=0;i<m_iNumAchievementGroups;i++ )
+    {
+        char buf[128];
+
+		int achievementRangeStart = (m_AchievementGroups[i].m_iMinRange / 1000) * 1000;
+        Q_snprintf( buf, sizeof(buf), "#Achievement_Group_%d", achievementRangeStart );
+
+        wchar_t *wzGroupName = g_pVGuiLocalize->Find( buf );
+
+        if ( !wzGroupName )
+        {
+            wzGroupName = L"Need Title ( %s1 of %s2 )";
+        }
+
+        wchar_t wzGroupTitle[128];
+
+        if ( wzGroupName )
+        {
+            // Determine number of achievements in the group which have been awarded
+            int numAwarded = 0;
+            int numTested = 0;
+            for (int j = m_AchievementGroups[i].m_iMinRange; j < m_AchievementGroups[i].m_iMaxRange; j++)
+            {
+                IAchievement* pCur = g_AchievementMgrCS.GetAchievementByID( j );
+
+                if ( !pCur )
+                    continue;
+
+                numTested++;
+
+                if ( pCur->IsAchieved() )
+                {
+                    numAwarded++;
+                }
+            }
+
+            wchar_t wzNumUnlocked[8];
+            V_snwprintf( wzNumUnlocked, ARRAYSIZE( wzNumUnlocked ), L"%d", numAwarded );
+
+            wchar_t wzNumAchievements[8];
+            V_snwprintf( wzNumAchievements, ARRAYSIZE( wzNumAchievements ), L"%d", numTested );
+
+            g_pVGuiLocalize->ConstructString( wzGroupTitle, sizeof( wzGroupTitle ), wzGroupName, 0 );
+        }
+
+        KeyValues *pKV = new KeyValues( "grp" );
+        pKV->SetInt( "minrange", m_AchievementGroups[i].m_iMinRange );
+        pKV->SetInt( "maxrange", m_AchievementGroups[i].m_iMaxRange );
+
+        if ( bCreate )
+        {
+            // Create an achievement group instance
+            CAchievementsPageGroupPanel *achievementGroupPanel = new CAchievementsPageGroupPanel( m_pGroupsList, this, "AchievementDialogGroupPanel", i );
+            achievementGroupPanel->SetGroupInfo( wzGroupTitle, m_AchievementGroups[i].m_iMinRange, m_AchievementGroups[i].m_iMaxRange );
+
+            if (i == 0)
+            {
+                achievementGroupPanel->SetGroupActive(true);
+            }
+            else
+            {
+                achievementGroupPanel->SetGroupActive(false);
+            }
+
+            m_pGroupsList->AddItem( NULL, achievementGroupPanel );
+        }
+    }
+
+	m_pStatCard->UpdateInfo();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: creates child panels, passes down name to pick up any settings from res files.
+//-----------------------------------------------------------------------------
+CAchievementsPageItemPanel::CAchievementsPageItemPanel( vgui::PanelListPanel *parent, const char* name) : BaseClass( parent, name )
+{    
+    m_pParent = parent;
+    m_pSchemeSettings = NULL;
+
+    m_pAchievementIcon = SETUP_PANEL(new vgui::ImagePanel( this, "AchievementIcon" ));
+    m_pAchievementNameLabel = new vgui::Label( this, "AchievementName", "name" );
+    m_pAchievementDescLabel = new vgui::Label( this, "AchievementDesc", "desc" );
+    m_pPercentageBar = SETUP_PANEL( new ImagePanel( this, "PercentageBar" ) );
+    m_pPercentageText = new vgui::Label( this, "PercentageText", "" );
+    m_pAwardDate = new vgui::Label( this, "AwardDate", "date" );
+    m_pShowOnHUDButton = new vgui::CheckButton( this, "ShowOnHudToggle", "" );
+    m_pShowOnHUDButton->SetMouseInputEnabled( true );
+    m_pShowOnHUDButton->SetEnabled( true );
+    m_pShowOnHUDButton->SetCheckButtonCheckable( true );
+    m_pShowOnHUDButton->AddActionSignalTarget( this );
+
+    m_pHiddenHUDToggleButton = new CHiddenHUDToggleButton( this, "HiddenHUDToggle", "" );
+    m_pHiddenHUDToggleButton->SetPaintBorderEnabled( false );
+
+
+    SetMouseInputEnabled( true );
+    parent->SetMouseInputEnabled( true );
+}
+
+CAchievementsPageItemPanel::~CAchievementsPageItemPanel()
+{
+    delete m_pAchievementIcon;
+    delete m_pAchievementNameLabel;
+    delete m_pAchievementDescLabel;
+    delete m_pPercentageBar;
+    delete m_pPercentageText;
+    delete m_pAwardDate;
+    delete m_pShowOnHUDButton;
+    delete m_pHiddenHUDToggleButton;
+}
+
+void CAchievementsPageItemPanel::ToggleShowOnHUDButton()
+{
+    if (m_pShowOnHUDButton)
+    {
+        m_pShowOnHUDButton->SetSelected( !m_pShowOnHUDButton->IsSelected() );
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates displayed achievement data. In applyschemesettings, and when gameui activates.
+//-----------------------------------------------------------------------------
+void CAchievementsPageItemPanel::UpdateAchievementInfo( vgui::IScheme* pScheme )
+{
+    if ( m_pSourceAchievement && m_pSchemeSettings )
+    {
+        //=============================================================================
+        // HPE_BEGIN:
+        // [dwenger] Get achievement name and description text from the localized file
+        //=============================================================================
+
+        // Set name, description and unlocked state text
+        m_pAchievementNameLabel->SetText( ACHIEVEMENT_LOCALIZED_NAME( m_pSourceAchievement ) );
+        m_pAchievementDescLabel->SetText( ACHIEVEMENT_LOCALIZED_DESC( m_pSourceAchievement ) );
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+        // Setup icon
+        // get the vtfFilename from the path.
+
+        // Display percentage completion for progressive achievements
+        // Set up total completion percentage bar. Goal > 1 means its a progress achievement.
+        CSUpdateProgressBarForPage( this, m_pSourceAchievement, m_clrProgressBar );
+
+        if ( m_pSourceAchievement->IsAchieved() )
+        {
+            CSLoadAchievementIconForPage( m_pAchievementIcon, m_pSourceAchievement );
+
+            SetBgColor( pScheme->GetColor( "AchievementsLightGrey", Color(255, 0, 0, 255) ) );
+
+            m_pAchievementNameLabel->SetFgColor( pScheme->GetColor( "SteamLightGreen", Color(255, 255, 255, 255) ) );
+
+            Color fgColor = pScheme->GetColor( "Label.TextBrightColor", Color(255, 255, 255, 255) );
+            m_pAchievementDescLabel->SetFgColor( fgColor );
+            m_pPercentageText->SetFgColor( fgColor );
+            m_pShowOnHUDButton->SetVisible( false );
+            m_pShowOnHUDButton->SetSelected( false );
+            m_pHiddenHUDToggleButton->SetVisible( false );
+            m_pAwardDate->SetVisible( true );
+            m_pAwardDate->SetFgColor( pScheme->GetColor( "SteamLightGreen", Color(255, 255, 255, 255) ) );
+
+            // Assign the award date text
+            int year, month, day, hour, minute, second;
+            if ( m_pSourceAchievement->GetAwardTime(year, month, day, hour, minute, second) )
+			{
+				char dateBuffer[32] = "";
+				Q_snprintf( dateBuffer, 32, "%4d-%02d-%02d", year, month, day );
+				m_pAwardDate->SetText( dateBuffer );
+			}
+			else
+				m_pAwardDate->SetText( "" );
+        }
+        else
+        {
+            CSLoadAchievementIconForPage( m_pAchievementIcon, m_pSourceAchievement, "_bw" );
+
+            SetBgColor( pScheme->GetColor( "AchievementsDarkGrey", Color(255, 0, 0, 255) ) );
+
+            Color fgColor = pScheme->GetColor( "AchievementsInactiveFG", Color(255, 255, 255, 255) );
+            m_pAchievementNameLabel->SetFgColor( fgColor );
+            m_pAchievementDescLabel->SetFgColor( fgColor );
+            m_pPercentageText->SetFgColor( fgColor );
+
+            if ( CSGameSupportsAchievementTrackerForPage() )
+            {
+                m_pShowOnHUDButton->SetVisible( !m_pSourceAchievement->ShouldHideUntilAchieved() );
+                m_pShowOnHUDButton->SetSelected( m_pSourceAchievement->ShouldShowOnHUD() );
+
+                m_pHiddenHUDToggleButton->SetVisible( !m_pSourceAchievement->ShouldHideUntilAchieved() );
+            }
+            else
+            {
+                m_pShowOnHUDButton->SetVisible( false );
+                m_pHiddenHUDToggleButton->SetVisible( false );
+            }
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Makes a local copy of a pointer to the achievement entity stored on the client.
+//-----------------------------------------------------------------------------
+void CAchievementsPageItemPanel::SetAchievementInfo( CCSBaseAchievement* pAchievement )
+{
+    if ( !pAchievement )
+    {
+        Assert( 0 );
+        return;
+    }
+
+    m_pSourceAchievement = pAchievement;
+    m_iSourceAchievementIndex = pAchievement->GetAchievementID();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CAchievementsPageItemPanel::PreloadResourceFile( void )
+{
+    const char *controlResourceName = "resource/ui/AchievementItem.res";
+
+    g_pPreloadedCSAchievementPageItemLayout = new KeyValues(controlResourceName);
+    g_pPreloadedCSAchievementPageItemLayout->LoadFromFile(g_pFullFileSystem, controlResourceName);
+
+/*
+	// precache all achievement icons
+	int iCount = g_AchievementMgrCS.GetAchievementCount();
+	for ( int i = 0; i < iCount; ++i )
+	{
+		CCSBaseAchievement* pAchievement = dynamic_cast<CCSBaseAchievement*>(g_AchievementMgrCS.GetAchievementByIndex( i ));
+		char imagePath[_MAX_PATH];
+
+		Q_strncpy( imagePath, "achievements\\", sizeof(imagePath) );
+		Q_strncat( imagePath, pAchievement->GetName(), sizeof(imagePath), COPY_ALL_CHARACTERS );
+		Q_strncat( imagePath, "_bw", sizeof(imagePath), COPY_ALL_CHARACTERS );
+		Q_strncat( imagePath, ".vtf", sizeof(imagePath), COPY_ALL_CHARACTERS );
+
+		scheme()->GetImage(imagePath, true);
+
+		Q_strncpy( imagePath, "achievements\\", sizeof(imagePath) );
+		Q_strncat( imagePath, pAchievement->GetName(), sizeof(imagePath), COPY_ALL_CHARACTERS );
+		Q_strncat( imagePath, ".vtf", sizeof(imagePath), COPY_ALL_CHARACTERS );
+
+		scheme()->GetImage(imagePath, true);
+	}
+*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads settings from hl2/resource/ui/achievementitem.res
+//			Sets display info for this achievement item.
+//-----------------------------------------------------------------------------
+void CAchievementsPageItemPanel::ApplySchemeSettings( vgui::IScheme* pScheme )
+{
+    if ( !g_pPreloadedCSAchievementPageItemLayout )
+    {
+        PreloadResourceFile();
+    }
+
+    LoadControlSettings( "", NULL, g_pPreloadedCSAchievementPageItemLayout );
+
+    m_pSchemeSettings = pScheme;
+
+    if ( !m_pSourceAchievement )
+    {
+        return;
+    }
+
+    BaseClass::ApplySchemeSettings( pScheme );
+
+    // m_pSchemeSettings must be set for this.
+    UpdateAchievementInfo( pScheme );
+}
+
+void CAchievementsPageItemPanel::OnCheckButtonChecked(Panel *panel)
+{
+    if ( CSGameSupportsAchievementTrackerForPage() && panel == m_pShowOnHUDButton && m_pSourceAchievement )
+    {
+        m_pSourceAchievement->SetShowOnHUD( m_pShowOnHUDButton->IsSelected() );
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: creates child panels, passes down name to pick up any settings from res files.
+//-----------------------------------------------------------------------------
+CAchievementsPageGroupPanel::CAchievementsPageGroupPanel( vgui::PanelListPanel *parent, CAchievementsPage *owner, const char* name, int iListItemID ) : BaseClass( parent, name )
+{
+    m_pParent = parent;
+    m_pOwner = owner;
+    m_pSchemeSettings = NULL;
+
+    m_pGroupIcon = SETUP_PANEL(new vgui::ImagePanel( this, "GroupIcon" ));
+    m_pAchievementGroupLabel = new vgui::Label( this, "GroupName", "name" );
+    m_pPercentageText = new vgui::Label( this, "GroupPercentageText", "1/1" );
+    m_pPercentageBar = SETUP_PANEL( new ImagePanel( this, "GroupPercentageBar" ) );
+    m_pGroupButton = new CGroupButton( this, "GroupButton", "" );
+    m_pGroupButton->SetPos( 0, 0 );
+    m_pGroupButton->SetZPos( 20 );
+    m_pGroupButton->SetWide( 256 );
+    m_pGroupButton->SetTall( 64 );
+    SetMouseInputEnabled( true );
+    parent->SetMouseInputEnabled( true );
+
+    m_bActiveButton = false;
+}
+
+CAchievementsPageGroupPanel::~CAchievementsPageGroupPanel()
+{
+    delete m_pAchievementGroupLabel;
+    delete m_pPercentageBar;
+    delete m_pPercentageText;
+    delete m_pGroupIcon;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads settings from hl2/resource/ui/achievementitem.res
+//			Sets display info for this achievement item.
+//-----------------------------------------------------------------------------
+void CAchievementsPageGroupPanel::ApplySchemeSettings( vgui::IScheme* pScheme )
+{
+    if ( !g_pPreloadedCSAchievementPageGroupLayout )
+    {
+        PreloadResourceFile();
+    }
+
+    LoadControlSettings( "", NULL, g_pPreloadedCSAchievementPageGroupLayout );
+
+    m_pSchemeSettings = pScheme;
+
+    BaseClass::ApplySchemeSettings( pScheme );
+
+    // m_pSchemeSettings must be set for this.
+    UpdateAchievementInfo( pScheme );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates displayed achievement data. In ApplySchemeSettings(), and
+//          when gameui activates.
+//-----------------------------------------------------------------------------
+void CAchievementsPageGroupPanel::UpdateAchievementInfo( vgui::IScheme* pScheme )
+{
+    if ( m_pSchemeSettings )
+    {
+        int numAwarded = 0;
+        int numTested = 0;
+
+        char buf[128];
+        int achievementRangeStart = (m_iFirstAchievementID / 1000) * 1000;
+        Q_snprintf( buf, sizeof(buf), "#Achievement_Group_%d", achievementRangeStart );
+
+        wchar_t *wzGroupName = g_pVGuiLocalize->Find( buf );
+
+        if ( !wzGroupName )
+        {
+            wzGroupName = L"Need Title ( %s1 of %s2 )";
+        }
+
+        wchar_t wzGroupTitle[128];
+
+        if ( wzGroupName )
+        {
+            // Determine number of achievements in the group which have been awarded
+            for (int i = m_iFirstAchievementID; i < m_iLastAchievementID; i++)
+            {
+                IAchievement* pCur = g_AchievementMgrCS.GetAchievementByID( i );
+
+                if ( !pCur )
+                    continue;
+
+                numTested++;
+
+                if ( pCur->IsAchieved() )
+                {
+                    numAwarded++;
+                }
+            }
+
+            wchar_t wzNumUnlocked[8];
+            V_snwprintf( wzNumUnlocked, ARRAYSIZE( wzNumUnlocked ), L"%d", numAwarded );
+
+            wchar_t wzNumAchievements[8];
+            V_snwprintf( wzNumAchievements,ARRAYSIZE( wzNumAchievements ), L"%d", numTested );
+
+            g_pVGuiLocalize->ConstructString( wzGroupTitle, sizeof( wzGroupTitle ), wzGroupName, 2, wzNumUnlocked, wzNumAchievements );
+        }
+
+        // Set group name text
+        m_pAchievementGroupLabel->SetText( wzGroupTitle );//m_pGroupName );
+        m_pAchievementGroupLabel->SetFgColor(Color(157, 194, 80, 255));
+
+        char*   buff[32];
+        Q_snprintf( (char*)buff, 32, "%d / %d", numAwarded, numTested );
+        m_pPercentageText->SetText( (const char*)buff );
+        m_pPercentageText->SetFgColor(Color(157, 194, 80, 255));
+
+        if ( !m_bActiveButton )
+        {
+            CSLoadIconForPage( m_pGroupIcon, "achievement-btn-up" );
+        }
+        else
+        {
+            CSLoadIconForPage( m_pGroupIcon, "achievement-btn-select" );
+        }
+
+        // Update the percentage complete bar
+        vgui::ImagePanel *pPercentageBar	= (vgui::ImagePanel*)FindChildByName( "GroupPercentageBar" );
+        vgui::ImagePanel *pPercentageBarBkg = (vgui::ImagePanel*)FindChildByName( "GroupPercentageBarBackground" );
+
+        if ( pPercentageBar && pPercentageBarBkg )
+        {
+            float flCompletion = (float)numAwarded / (float)numTested;
+            pPercentageBar->SetFillColor( Color(157, 194, 80, 255) );
+            pPercentageBar->SetWide( pPercentageBarBkg->GetWide() * flCompletion );
+
+            SetControlVisible( "GroupPercentageBarBackground", true );
+            SetControlVisible( "GroupPercentageBar", true );
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CAchievementsPageGroupPanel::PreloadResourceFile( void )
+{
+    const char *controlResourceName = "resource/ui/AchievementGroup.res";
+
+    g_pPreloadedCSAchievementPageGroupLayout = new KeyValues(controlResourceName);
+    g_pPreloadedCSAchievementPageGroupLayout->LoadFromFile(g_pFullFileSystem, controlResourceName);
+
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Assigns a name and achievement id bounds for an achievement group.
+//-----------------------------------------------------------------------------
+void CAchievementsPageGroupPanel::SetGroupInfo( const wchar_t* name, int firstAchievementID, int lastAchievementID )
+{
+    // Store away the group name
+    short   _textLen = (short)wcslen(name) + 1;
+    m_pGroupName = new wchar_t[_textLen];
+    Q_memcpy( m_pGroupName, name, _textLen * sizeof(wchar_t) );
+
+    // Store off the start & end achievement IDs
+    m_iFirstAchievementID = firstAchievementID;
+    m_iLastAchievementID = lastAchievementID;
+}
+
+CGroupButton::CGroupButton( vgui::Panel *pParent, const char *pName, const char *pText ) : 
+BaseClass( pParent, pName, pText )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the case where the user presses an achievement group button.
+//-----------------------------------------------------------------------------
+void CGroupButton::DoClick( void )
+{
+    // Process when a group button is hit
+    CAchievementsPageGroupPanel*    pParent = static_cast<CAchievementsPageGroupPanel*>(GetParent());
+
+    if (pParent)
+    {
+        CAchievementsPage*  pAchievementsPage = static_cast<CAchievementsPage*>(pParent->GetOwner());
+
+        if (pAchievementsPage)
+        {
+            // Update the list of group achievements
+            pAchievementsPage->UpdateAchievementList( pParent );
+        }
+    }
+}
+
+void CAchievementsPage::OnPageShow()
+{
+	m_pGroupsList->GetScrollbar()->SetWide(0);
+}
+
+void CAchievementsPage::FireGameEvent( IGameEvent *event )
+{
+	const char *type = event->GetName();
+
+	if ( 0 == Q_strcmp( type, "achievement_earned_local" ) )
+		m_bAchievementsDirty = true;
+
+	if ( 0 == Q_strcmp( type, "player_stats_updated" ) )
+		m_bStatsDirty = true;
+}
+
+void CAchievementsPage::OnThink()
+{
+	vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
+
+	if ( m_bAchievementsDirty )
+	{
+		UpdateAchievementDialogInfo();
+	}
+	else if ( m_bStatsDirty )
+	{
+		// Update progress for currently displayed achievements
+		int itemId = m_pAchievementsList->FirstItem();
+
+		while (itemId != m_pAchievementsList->InvalidItemID() )
+		{
+			CAchievementsPageItemPanel *pAchievementItem = dynamic_cast<CAchievementsPageItemPanel*>(m_pAchievementsList->GetItemPanel(itemId));
+			pAchievementItem->UpdateAchievementInfo(pScheme);
+
+			itemId = m_pAchievementsList->NextItem(itemId);
+		}
+		m_bStatsDirty = false;
+	}
+}
+
+CHiddenHUDToggleButton::CHiddenHUDToggleButton( vgui::Panel *pParent, const char *pName, const char *pText ) : 
+BaseClass( pParent, pName, pText )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the case where the user shift-clicks on an un-awarded achievement.
+//-----------------------------------------------------------------------------
+void CHiddenHUDToggleButton::DoClick( void )
+{
+    if ( input()->IsKeyDown(KEY_LSHIFT) || input()->IsKeyDown(KEY_RSHIFT) ) 
+    {
+        // Process when a group button is hit
+        CAchievementsPageItemPanel*    pParent = static_cast<CAchievementsPageItemPanel*>(GetParent());
+
+        if (pParent)
+        {
+            pParent->ToggleShowOnHUDButton();
+        }
+    }
+}
diff --git a/game/client/cstrike/VGUI/achievements_page.h b/game/client/cstrike/VGUI/achievements_page.h
new file mode 100644
index 00000000..2066b1db
--- /dev/null
+++ b/game/client/cstrike/VGUI/achievements_page.h
@@ -0,0 +1,218 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSACHIEVEMENTSPAGE_H
+#define CSACHIEVEMENTSPAGE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vgui_controls/PanelListPanel.h"
+#include "vgui_controls/Label.h"
+#include "tier1/KeyValues.h"
+#include "vgui_controls/PropertyPage.h"
+#include "vgui_controls/Button.h"
+#include "c_cs_player.h"
+#include "vgui_avatarimage.h"
+#include "GameEventListener.h"
+
+class CCSBaseAchievement;
+class IScheme;
+class CAchievementsPageGroupPanel;
+class StatCard;
+
+#define ACHIEVED_ICON_PATH "hud/icon_check.vtf"
+#define LOCK_ICON_PATH "hud/icon_locked.vtf"
+
+// Loads an achievement's icon into a specified image panel, or turns the panel off if no achievement icon was found.
+bool CSLoadAchievementIconForPage( vgui::ImagePanel* pIconPanel, CCSBaseAchievement *pAchievement, const char *pszExt = NULL );
+
+// Loads an achievement's icon into a specified image panel, or turns the panel off if no achievement icon was found.
+bool CSLoadIconForPage( vgui::ImagePanel* pIconPanel, const char* pFilename, const char *pszExt = NULL );
+
+// Updates a listed achievement item's progress bar. 
+void CSUpdateProgressBarForPage( vgui::EditablePanel* pPanel, CCSBaseAchievement *pAchievement, Color clrProgressBar );
+
+//////////////////////////////////////////////////////////////////////////// 
+// PC version
+//////////////////////////////////////////////////////////////////////////
+class CAchievementsPage : public vgui::PropertyPage, public CGameEventListener
+{
+    DECLARE_CLASS_SIMPLE ( CAchievementsPage, vgui::PropertyPage );
+
+public:
+    CAchievementsPage( vgui::Panel *parent, const char *name );
+    ~CAchievementsPage();
+
+    virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+	void UpdateTotalProgressDisplay();
+	virtual void UpdateAchievementDialogInfo( void );
+
+	virtual void OnPageShow();
+	virtual void OnThink();
+
+    virtual void ApplySettings( KeyValues *pResourceData );
+    virtual void OnSizeChanged( int newWide, int newTall );
+
+	virtual void FireGameEvent( IGameEvent *event );
+
+    void CreateNewAchievementGroup( int iMinRange, int iMaxRange );
+    void CreateOrUpdateComboItems( bool bCreate );
+    void UpdateAchievementList(CAchievementsPageGroupPanel* groupPanel);
+    void UpdateAchievementList(int minID, int maxID);
+
+    vgui::PanelListPanel	*m_pAchievementsList;
+    vgui::ImagePanel		*m_pListBG;
+
+    vgui::PanelListPanel    *m_pGroupsList;
+    vgui::ImagePanel        *m_pGroupListBG;
+
+    vgui::ImagePanel		*m_pPercentageBarBackground;
+    vgui::ImagePanel		*m_pPercentageBar;
+
+	StatCard*				m_pStatCard;
+
+    int m_iFixedWidth;
+
+	bool m_bStatsDirty;
+	bool m_bAchievementsDirty;
+
+    typedef struct 
+    {
+        int m_iMinRange;
+        int m_iMaxRange;
+    } achievement_group_t;
+
+    int m_iNumAchievementGroups;
+
+    achievement_group_t m_AchievementGroups[15];
+};
+
+class CHiddenHUDToggleButton : public vgui::Button
+{
+    DECLARE_CLASS_SIMPLE( CHiddenHUDToggleButton, vgui::Button );
+
+public:
+
+    CHiddenHUDToggleButton(  vgui::Panel *pParent, const char *pName, const char *pText );
+
+    virtual void DoClick( void );
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Individual item panel, displaying stats for one achievement
+class CAchievementsPageItemPanel : public vgui::EditablePanel
+{
+    DECLARE_CLASS_SIMPLE( CAchievementsPageItemPanel, vgui::EditablePanel );
+
+public:
+    CAchievementsPageItemPanel( vgui::PanelListPanel *parent, const char* name);
+    ~CAchievementsPageItemPanel();
+
+    void SetAchievementInfo ( CCSBaseAchievement* pAchievement );
+    CCSBaseAchievement* GetAchievementInfo( void ) { return m_pSourceAchievement; }
+    void UpdateAchievementInfo( vgui::IScheme *pScheme );
+    virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+    void ToggleShowOnHUDButton();
+
+    MESSAGE_FUNC_PTR( OnCheckButtonChecked, "CheckButtonChecked", panel );
+
+private:
+	static void PreloadResourceFile();
+
+    CCSBaseAchievement*		m_pSourceAchievement;
+    int	                    m_iSourceAchievementIndex;
+
+    vgui::PanelListPanel    *m_pParent;
+
+    vgui::Label             *m_pAchievementNameLabel;
+    vgui::Label             *m_pAchievementDescLabel;
+    vgui::Label             *m_pPercentageText;   
+    vgui::Label             *m_pAwardDate;   
+
+    vgui::ImagePanel        *m_pLockedIcon;
+    vgui::ImagePanel        *m_pAchievementIcon;
+
+    vgui::ImagePanel        *m_pPercentageBarBackground;
+    vgui::ImagePanel        *m_pPercentageBar;
+
+    vgui::CheckButton       *m_pShowOnHUDButton;
+
+    vgui::IScheme           *m_pSchemeSettings;
+
+    CHiddenHUDToggleButton  *m_pHiddenHUDToggleButton;
+
+    CPanelAnimationVar( Color, m_clrProgressBar, "ProgressBarColor", "140 140 140 255" );
+};
+
+class CGroupButton : public vgui::Button
+{
+    DECLARE_CLASS_SIMPLE( CGroupButton, vgui::Button );
+
+public:
+
+    CGroupButton(  vgui::Panel *pParent, const char *pName, const char *pText );
+
+    virtual void DoClick( void );
+};
+
+//////////////////////////////////////////////////////////////////////////
+// Individual achievement group panel, displaying info for one achievement group
+class CAchievementsPageGroupPanel : public vgui::EditablePanel
+{
+    DECLARE_CLASS_SIMPLE( CAchievementsPageGroupPanel, vgui::EditablePanel );
+
+public:
+    CAchievementsPageGroupPanel( vgui::PanelListPanel *parent, CAchievementsPage *owner, const char* name, int iListItemID );
+    ~CAchievementsPageGroupPanel();
+
+    void SetGroupInfo ( const wchar_t* name, int firstAchievementID, int lastAchievementID );
+    void UpdateAchievementInfo( vgui::IScheme *pScheme );
+    virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+    int GetFirstAchievementID() { return m_iFirstAchievementID; }
+    int GetLastAchievementID() { return m_iLastAchievementID; }
+
+    vgui::PanelListPanel* GetParent() { return m_pParent; }
+    CAchievementsPage* GetOwner() { return m_pOwner; }
+
+    void SetGroupActive(bool active) { m_bActiveButton = active; }
+    bool IsGroupActive() { return m_bActiveButton; }
+
+private:
+    void PreloadResourceFile( void );
+
+    vgui::PanelListPanel    *m_pParent;
+    CAchievementsPage       *m_pOwner;
+
+    vgui::Label             *m_pAchievementGroupLabel;
+    vgui::Label             *m_pPercentageText;
+
+    CGroupButton            *m_pGroupButton;
+
+    vgui::ImagePanel        *m_pGroupIcon;
+
+    vgui::ImagePanel        *m_pPercentageBarBackground;
+    vgui::ImagePanel        *m_pPercentageBar;
+
+    vgui::IScheme           *m_pSchemeSettings;
+
+    bool                    m_bActiveButton;
+
+    CPanelAnimationVar( Color, m_clrProgressBar, "ProgressBarColor", "140 140 140 255" );
+
+    int m_iFirstAchievementID;
+    int m_iLastAchievementID;
+
+    wchar_t                 *m_pGroupName;
+};
+
+
+
+#endif // CSACHIEVEMENTSPAGE_H
diff --git a/game/client/cstrike/VGUI/backgroundpanel.cpp b/game/client/cstrike/VGUI/backgroundpanel.cpp
new file mode 100644
index 00000000..c875217e
--- /dev/null
+++ b/game/client/cstrike/VGUI/backgroundpanel.cpp
@@ -0,0 +1,676 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "backgroundpanel.h"
+
+#include <vgui/IVGui.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui_controls/Label.h>
+#include <vgui/ILocalize.h>
+#include "vgui_controls/BuildGroup.h"
+#include "vgui_controls/BitmapImagePanel.h"
+
+using namespace vgui;
+
+#define DEBUG_WINDOW_RESIZING 0
+#define DEBUG_WINDOW_REPOSITIONING 0
+
+//-----------------------------------------------------------------------------
+const int NumSegments = 7;
+static int coord[NumSegments+1] = {
+	0,
+	1,
+	2,
+	3,
+	4,
+	6,
+	9,
+	10
+};
+
+//-----------------------------------------------------------------------------
+void DrawRoundedBackground( Color bgColor, int wide, int tall )
+{
+	int x1, x2, y1, y2;
+	surface()->DrawSetColor(bgColor);
+	surface()->DrawSetTextColor(bgColor);
+
+	int i;
+
+	// top-left corner --------------------------------------------------------
+	int xDir = 1;
+	int yDir = -1;
+	int xIndex = 0;
+	int yIndex = NumSegments - 1;
+	int xMult = 1;
+	int yMult = 1;
+	int x = 0;
+	int y = 0;
+	for ( i=0; i<NumSegments; ++i )
+	{
+		x1 = MIN( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		x2 = MAX( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		y1 = MAX( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		y2 = y + coord[NumSegments];
+		surface()->DrawFilledRect( x1, y1, x2, y2 );
+
+		xIndex += xDir;
+		yIndex += yDir;
+	}
+
+	// top-right corner -------------------------------------------------------
+	xDir = 1;
+	yDir = -1;
+	xIndex = 0;
+	yIndex = NumSegments - 1;
+	x = wide;
+	y = 0;
+	xMult = -1;
+	yMult = 1;
+	for ( i=0; i<NumSegments; ++i )
+	{
+		x1 = MIN( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		x2 = MAX( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		y1 = MAX( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		y2 = y + coord[NumSegments];
+		surface()->DrawFilledRect( x1, y1, x2, y2 );
+		xIndex += xDir;
+		yIndex += yDir;
+	}
+
+	// bottom-right corner ----------------------------------------------------
+	xDir = 1;
+	yDir = -1;
+	xIndex = 0;
+	yIndex = NumSegments - 1;
+	x = wide;
+	y = tall;
+	xMult = -1;
+	yMult = -1;
+	for ( i=0; i<NumSegments; ++i )
+	{
+		x1 = MIN( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		x2 = MAX( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		y1 = y - coord[NumSegments];
+		y2 = MIN( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		surface()->DrawFilledRect( x1, y1, x2, y2 );
+		xIndex += xDir;
+		yIndex += yDir;
+	}
+
+	// bottom-left corner -----------------------------------------------------
+	xDir = 1;
+	yDir = -1;
+	xIndex = 0;
+	yIndex = NumSegments - 1;
+	x = 0;
+	y = tall;
+	xMult = 1;
+	yMult = -1;
+	for ( i=0; i<NumSegments; ++i )
+	{
+		x1 = MIN( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		x2 = MAX( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		y1 = y - coord[NumSegments];
+		y2 = MIN( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		surface()->DrawFilledRect( x1, y1, x2, y2 );
+		xIndex += xDir;
+		yIndex += yDir;
+	}
+
+	// paint between top left and bottom left ---------------------------------
+	x1 = 0;
+	x2 = coord[NumSegments];
+	y1 = coord[NumSegments];
+	y2 = tall - coord[NumSegments];
+	surface()->DrawFilledRect( x1, y1, x2, y2 );
+
+	// paint between left and right -------------------------------------------
+	x1 = coord[NumSegments];
+	x2 = wide - coord[NumSegments];
+	y1 = 0;
+	y2 = tall;
+	surface()->DrawFilledRect( x1, y1, x2, y2 );
+	
+	// paint between top right and bottom right -------------------------------
+	x1 = wide - coord[NumSegments];
+	x2 = wide;
+	y1 = coord[NumSegments];
+	y2 = tall - coord[NumSegments];
+	surface()->DrawFilledRect( x1, y1, x2, y2 );
+}
+
+//-----------------------------------------------------------------------------
+void DrawRoundedBorder( Color borderColor, int wide, int tall )
+{
+	int x1, x2, y1, y2;
+	surface()->DrawSetColor(borderColor);
+	surface()->DrawSetTextColor(borderColor);
+
+	int i;
+
+	// top-left corner --------------------------------------------------------
+	int xDir = 1;
+	int yDir = -1;
+	int xIndex = 0;
+	int yIndex = NumSegments - 1;
+	int xMult = 1;
+	int yMult = 1;
+	int x = 0;
+	int y = 0;
+	for ( i=0; i<NumSegments; ++i )
+	{
+		x1 = MIN( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		x2 = MAX( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		y1 = MIN( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		y2 = MAX( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		surface()->DrawFilledRect( x1, y1, x2, y2 );
+
+		xIndex += xDir;
+		yIndex += yDir;
+	}
+
+	// top-right corner -------------------------------------------------------
+	xDir = 1;
+	yDir = -1;
+	xIndex = 0;
+	yIndex = NumSegments - 1;
+	x = wide;
+	y = 0;
+	xMult = -1;
+	yMult = 1;
+	for ( i=0; i<NumSegments; ++i )
+	{
+		x1 = MIN( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		x2 = MAX( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		y1 = MIN( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		y2 = MAX( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		surface()->DrawFilledRect( x1, y1, x2, y2 );
+		xIndex += xDir;
+		yIndex += yDir;
+	}
+
+	// bottom-right corner ----------------------------------------------------
+	xDir = 1;
+	yDir = -1;
+	xIndex = 0;
+	yIndex = NumSegments - 1;
+	x = wide;
+	y = tall;
+	xMult = -1;
+	yMult = -1;
+	for ( i=0; i<NumSegments; ++i )
+	{
+		x1 = MIN( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		x2 = MAX( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		y1 = MIN( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		y2 = MAX( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		surface()->DrawFilledRect( x1, y1, x2, y2 );
+		xIndex += xDir;
+		yIndex += yDir;
+	}
+
+	// bottom-left corner -----------------------------------------------------
+	xDir = 1;
+	yDir = -1;
+	xIndex = 0;
+	yIndex = NumSegments - 1;
+	x = 0;
+	y = tall;
+	xMult = 1;
+	yMult = -1;
+	for ( i=0; i<NumSegments; ++i )
+	{
+		x1 = MIN( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		x2 = MAX( x + coord[xIndex]*xMult, x + coord[xIndex+1]*xMult );
+		y1 = MIN( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		y2 = MAX( y + coord[yIndex]*yMult, y + coord[yIndex+1]*yMult );
+		surface()->DrawFilledRect( x1, y1, x2, y2 );
+		xIndex += xDir;
+		yIndex += yDir;
+	}
+
+	// top --------------------------------------------------------------------
+	x1 = coord[NumSegments];
+	x2 = wide - coord[NumSegments];
+	y1 = 0;
+	y2 = 1;
+	surface()->DrawFilledRect( x1, y1, x2, y2 );
+
+	// bottom -----------------------------------------------------------------
+	x1 = coord[NumSegments];
+	x2 = wide - coord[NumSegments];
+	y1 = tall - 1;
+	y2 = tall;
+	surface()->DrawFilledRect( x1, y1, x2, y2 );
+
+	// left -------------------------------------------------------------------
+	x1 = 0;
+	x2 = 1;
+	y1 = coord[NumSegments];
+	y2 = tall - coord[NumSegments];
+	surface()->DrawFilledRect( x1, y1, x2, y2 );
+
+	// right ------------------------------------------------------------------
+	x1 = wide - 1;
+	x2 = wide;
+	y1 = coord[NumSegments];
+	y2 = tall - coord[NumSegments];
+	surface()->DrawFilledRect( x1, y1, x2, y2 );
+}
+
+//-----------------------------------------------------------------------------
+class CaptionLabel : public Label
+{
+public:
+	CaptionLabel(Panel *parent, const char *panelName, const char *text) : Label(parent, panelName, text)
+	{
+	}
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
+	{
+		Label::ApplySchemeSettings( pScheme );
+		SetFont( pScheme->GetFont( "MenuTitle", IsProportional() ) );
+	}
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: transform a normalized value into one that is scaled based the minimum
+//          of the horizontal and vertical ratios
+//-----------------------------------------------------------------------------
+static int GetAlternateProportionalValueFromNormal(int normalizedValue)
+{
+	int wide, tall;
+	GetHudSize( wide, tall );
+	int proH, proW;
+	surface()->GetProportionalBase( proW, proH );
+	double scaleH = (double)tall / (double)proH;
+	double scaleW = (double)wide / (double)proW;
+	double scale = (scaleW < scaleH) ? scaleW : scaleH;
+
+	return (int)( normalizedValue * scale );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: transform a standard scaled value into one that is scaled based the minimum
+//          of the horizontal and vertical ratios
+//-----------------------------------------------------------------------------
+int GetAlternateProportionalValueFromScaled( HScheme hScheme, int scaledValue)
+{
+	return GetAlternateProportionalValueFromNormal( scheme()->GetProportionalNormalizedValueEx( hScheme,  scaledValue ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: moves and resizes a single control
+//-----------------------------------------------------------------------------
+static void RepositionControl( Panel *pPanel )
+{
+	int x, y, w, h;
+	pPanel->GetBounds(x, y, w, h);
+
+#if DEBUG_WINDOW_RESIZING
+	int x1, y1, w1, h1;
+	pPanel->GetBounds(x1, y1, w1, h1);
+	int x2, y2, w2, h2;
+	x2 = scheme()->GetProportionalNormalizedValueEx( pPanel->GetScheme(),  x1 );
+	y2 = scheme()->GetProportionalNormalizedValueEx( pPanel->GetScheme(),  y1 );
+	w2 = scheme()->GetProportionalNormalizedValueEx( pPanel->GetScheme(),  w1 );
+	h2 = scheme()->GetProportionalNormalizedValueEx( pPanel->GetScheme(),  h1 );
+#endif
+
+	x = GetAlternateProportionalValueFromScaled( pPanel->GetScheme(), x );
+	y = GetAlternateProportionalValueFromScaled( pPanel->GetScheme(), y );
+	w = GetAlternateProportionalValueFromScaled( pPanel->GetScheme(), w );
+	h = GetAlternateProportionalValueFromScaled( pPanel->GetScheme(), h );
+
+	pPanel->SetBounds(x, y, w, h);
+
+#if DEBUG_WINDOW_RESIZING
+	DevMsg( "Resizing '%s' from (%d,%d) %dx%d to (%d,%d) %dx%d -- initially was (%d,%d) %dx%d\n",
+		pPanel->GetName(), x1, y1, w1, h1, x, y, w, h, x2, y2, w2, h2 );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets colors etc for background image panels
+//-----------------------------------------------------------------------------
+void ApplyBackgroundSchemeSettings( EditablePanel *pWindow, vgui::IScheme *pScheme )
+{
+	Color bgColor = Color( 255, 255, 255, pScheme->GetColor( "BgColor", Color( 0, 0, 0, 0 ) )[3] );
+	Color fgColor = pScheme->GetColor( "FgColor", Color( 0, 0, 0, 0 ) );
+
+	if ( !pWindow )
+		return;
+
+	CBitmapImagePanel *pBitmapPanel;
+
+	// corners --------------------------------------------
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "TopLeftPanel" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( bgColor );
+	}
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "TopRightPanel" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( bgColor );
+	}
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "BottomLeftPanel" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( bgColor );
+	}
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "BottomRightPanel" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( bgColor );
+	}
+
+	// background -----------------------------------------
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "TopSolid" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( bgColor );
+	}
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "UpperMiddleSolid" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( bgColor );
+	}
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "LowerMiddleSolid" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( bgColor );
+	}
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "BottomSolid" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( bgColor );
+	}
+
+	// Logo -----------------------------------------------
+	pBitmapPanel = dynamic_cast< CBitmapImagePanel * >(pWindow->FindChildByName( "ExclamationPanel" ));
+	if ( pBitmapPanel )
+	{
+		pBitmapPanel->setImageColor( fgColor );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Re-aligns background image panels so they are touching.
+//-----------------------------------------------------------------------------
+static void FixupBackgroundPanels( EditablePanel *pWindow, int offsetX, int offsetY )
+{
+	if ( !pWindow )
+		return;
+
+	int screenWide, screenTall;
+	pWindow->GetSize( screenWide, screenTall );
+
+	int inset = GetAlternateProportionalValueFromNormal( 20 );
+	int cornerSize = GetAlternateProportionalValueFromNormal( 10 );
+
+	int titleHeight = GetAlternateProportionalValueFromNormal( 42 );
+	int mainHeight = GetAlternateProportionalValueFromNormal( 376 );
+
+	int logoSize = titleHeight;
+
+	int captionInset = GetAlternateProportionalValueFromNormal( 76 );
+
+	Panel *pPanel;
+
+	// corners --------------------------------------------
+	pPanel = pWindow->FindChildByName( "TopLeftPanel" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( offsetX + inset, offsetY + inset, cornerSize, cornerSize );
+	}
+
+	pPanel = pWindow->FindChildByName( "TopRightPanel" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( screenWide - offsetX - inset - cornerSize, offsetY + inset, cornerSize, cornerSize );
+	}
+
+	pPanel = pWindow->FindChildByName( "BottomLeftPanel" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( offsetX + inset, screenTall - offsetY - inset - cornerSize, cornerSize, cornerSize );
+	}
+
+	pPanel = pWindow->FindChildByName( "BottomRightPanel" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( screenWide - offsetX - inset - cornerSize, screenTall - offsetY - inset - cornerSize, cornerSize, cornerSize );
+	}
+
+	// background -----------------------------------------
+	pPanel = pWindow->FindChildByName( "TopSolid" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( offsetX + inset + cornerSize, offsetY + inset, screenWide - 2*offsetX - 2*inset - 2*cornerSize, cornerSize );
+	}
+
+	pPanel = pWindow->FindChildByName( "UpperMiddleSolid" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( offsetX + inset, offsetY + inset + cornerSize, screenWide - 2*offsetX - 2*inset, titleHeight );
+	}
+
+	pPanel = pWindow->FindChildByName( "LowerMiddleSolid" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( offsetX + inset + cornerSize, screenTall - offsetY - inset - cornerSize, screenWide - 2*offsetX - 2*inset - 2*cornerSize, cornerSize );
+	}
+
+	pPanel = pWindow->FindChildByName( "BottomSolid" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( offsetX + inset, screenTall - offsetY - inset - cornerSize - mainHeight, screenWide - 2*offsetX - 2*inset, mainHeight );
+	}
+
+	// transparent border ---------------------------------
+	pPanel = pWindow->FindChildByName( "TopClear" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( 0, 0, screenWide, offsetY + inset );
+	}
+
+	pPanel = pWindow->FindChildByName( "BottomClear" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( 0, screenTall - offsetY - inset, screenWide, offsetY + inset );
+	}
+
+	pPanel = pWindow->FindChildByName( "LeftClear" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( 0, offsetY + inset, offsetX + inset, screenTall - 2*offsetY - 2*inset );
+	}
+
+	pPanel = pWindow->FindChildByName( "RightClear" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -20 );
+		pPanel->SetBounds( screenWide - offsetX - inset, offsetY + inset, offsetX + inset, screenTall - 2*offsetY - 2*inset );
+	}
+
+	// Logo -----------------------------------------------
+	int logoInset = (cornerSize + titleHeight - logoSize)/2;
+	pPanel = pWindow->FindChildByName( "ExclamationPanel" );
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -19 ); // higher than the background
+		pPanel->SetBounds( offsetX + inset + logoInset, offsetY + inset + logoInset, logoSize, logoSize );
+	}
+
+	// Title caption --------------------------------------
+	pPanel = dynamic_cast< Label * >(pWindow->FindChildByName( "CaptionLabel" ));
+	if ( pPanel )
+	{
+		pPanel->SetZPos( -19 ); // higher than the background
+		pPanel->SetBounds( offsetX + captionInset/*inset + 2*logoInset + logoSize*/, offsetY + inset + logoInset, screenWide, logoSize );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates background image panels
+//-----------------------------------------------------------------------------
+void CreateBackground( EditablePanel *pWindow )
+{
+	// corners --------------------------------------------
+	new CBitmapImagePanel( pWindow, "TopLeftPanel", "gfx/vgui/round_corner_nw" );
+	new CBitmapImagePanel( pWindow, "TopRightPanel", "gfx/vgui/round_corner_ne" );
+	new CBitmapImagePanel( pWindow, "BottomLeftPanel", "gfx/vgui/round_corner_sw" );
+	new CBitmapImagePanel( pWindow, "BottomRightPanel", "gfx/vgui/round_corner_se" );
+
+	// background -----------------------------------------
+	new CBitmapImagePanel( pWindow, "TopSolid", "gfx/vgui/solid_background" );
+	new CBitmapImagePanel( pWindow, "UpperMiddleSolid", "gfx/vgui/solid_background" );
+	new CBitmapImagePanel( pWindow, "LowerMiddleSolid", "gfx/vgui/solid_background" );
+	new CBitmapImagePanel( pWindow, "BottomSolid", "gfx/vgui/solid_background" );
+
+	// transparent border ---------------------------------
+	new CBitmapImagePanel( pWindow, "TopClear", "gfx/vgui/trans_background" );
+	new CBitmapImagePanel( pWindow, "BottomClear", "gfx/vgui/trans_background" );
+	new CBitmapImagePanel( pWindow, "LeftClear", "gfx/vgui/trans_background" );
+	new CBitmapImagePanel( pWindow, "RightClear", "gfx/vgui/trans_background" );
+
+	// Logo -----------------------------------------------
+	new CBitmapImagePanel( pWindow, "ExclamationPanel", "gfx/vgui/CS_logo" );
+
+	// Title caption --------------------------------------
+	Panel *pPanel = dynamic_cast< Label * >(pWindow->FindChildByName( "CaptionLabel" ));
+	if ( !pPanel )
+		new CaptionLabel( pWindow, "CaptionLabel", "" );
+}
+
+void ResizeWindowControls( EditablePanel *pWindow, int tall, int wide, int offsetX, int offsetY )
+{
+	if (!pWindow || !pWindow->GetBuildGroup() || !pWindow->GetBuildGroup()->GetPanelList())
+		return;
+
+	CUtlVector<PHandle> *panelList = pWindow->GetBuildGroup()->GetPanelList();
+	CUtlVector<Panel *> resizedPanels;
+	CUtlVector<Panel *> movedPanels;
+
+	// Resize to account for 1.25 aspect ratio (1280x1024) screens
+	{
+		for ( int i = 0; i < panelList->Size(); ++i )
+		{
+			PHandle handle = (*panelList)[i];
+
+			Panel *panel = handle.Get();
+
+			bool found = false;
+			for ( int j = 0; j < resizedPanels.Size(); ++j )
+			{
+				if (panel == resizedPanels[j])
+					found = true;
+			}
+
+			if (!panel || found)
+			{
+				continue;
+			}
+
+			resizedPanels.AddToTail( panel ); // don't move a panel more than once
+
+			if ( panel != pWindow )
+			{
+				RepositionControl( panel );
+			}
+		}
+	}
+
+	// and now re-center them.  Woohoo!
+	for ( int i = 0; i < panelList->Size(); ++i )
+	{
+		PHandle handle = (*panelList)[i];
+
+		Panel *panel = handle.Get();
+
+		bool found = false;
+		for ( int j = 0; j < movedPanels.Size(); ++j )
+		{
+			if (panel == movedPanels[j])
+				found = true;
+		}
+
+		if (!panel || found)
+		{
+			continue;
+		}
+
+		movedPanels.AddToTail( panel ); // don't move a panel more than once
+
+		if ( panel != pWindow )
+		{
+			int x, y;
+
+			panel->GetPos( x, y );
+			panel->SetPos( x + offsetX, y + offsetY );
+
+#if DEBUG_WINDOW_REPOSITIONING
+			DevMsg( "Repositioning '%s' from (%d,%d) to (%d,%d) -- a distance of (%d,%d)\n",
+				panel->GetName(), x, y, x + offsetX, y + offsetY, offsetX, offsetY );
+#endif
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resizes windows to fit completely on-screen (for 1280x1024), and
+//          centers them on the screen.  Sub-controls are also resized and moved.
+//-----------------------------------------------------------------------------
+void LayoutBackgroundPanel( EditablePanel *pWindow )
+{
+	if ( !pWindow )
+		return;
+
+	int screenW, screenH;
+	GetHudSize( screenW, screenH );
+
+	int wide, tall;
+	pWindow->GetSize( wide, tall );
+
+	int offsetX = 0;
+	int offsetY = 0;
+
+	// Slide everything over to the center
+	pWindow->SetBounds( 0, 0, screenW, screenH );
+
+	if ( wide != screenW || tall != screenH )
+	{
+		wide = GetAlternateProportionalValueFromScaled( pWindow->GetScheme(), wide);
+		tall = GetAlternateProportionalValueFromScaled( pWindow->GetScheme(), tall);
+
+		offsetX = (screenW - wide)/2;
+		offsetY = (screenH - tall)/2;
+
+		ResizeWindowControls( pWindow, tall, wide, offsetX, offsetY );
+	}
+
+	// now that the panels are moved/resized, look for some bg panels, and re-align them
+	FixupBackgroundPanels( pWindow, offsetX, offsetY );
+}
+
+//-----------------------------------------------------------------------------
+
diff --git a/game/client/cstrike/VGUI/backgroundpanel.h b/game/client/cstrike/VGUI/backgroundpanel.h
new file mode 100644
index 00000000..5edf22e8
--- /dev/null
+++ b/game/client/cstrike/VGUI/backgroundpanel.h
@@ -0,0 +1,53 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSBACKGROUND_H
+#define CSBACKGROUND_H
+
+#include <vgui_controls/Frame.h>
+#include <vgui_controls/EditablePanel.h>
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates background image panels
+//-----------------------------------------------------------------------------
+void CreateBackground( vgui::EditablePanel *pWindow );
+
+//-----------------------------------------------------------------------------
+// Purpose: Resizes windows to fit completely on-screen (for 1280x1024), and
+//          centers them on the screen.  Sub-controls are also resized and moved.
+//-----------------------------------------------------------------------------
+void LayoutBackgroundPanel( vgui::EditablePanel *pWindow );
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets colors etc for background image panels
+//-----------------------------------------------------------------------------
+void ApplyBackgroundSchemeSettings( vgui::EditablePanel *pWindow, vgui::IScheme *pScheme );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ResizeWindowControls( vgui::EditablePanel *pWindow, int tall, int wide, int offsetX, int offsetY );
+
+//-----------------------------------------------------------------------------
+// Purpose: transform a standard scaled value into one that is scaled based the minimum
+//          of the horizontal and vertical ratios
+//-----------------------------------------------------------------------------
+int GetAlternateProportionalValueFromScaled( vgui::HScheme scheme, int scaledValue );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void DrawRoundedBackground( Color bgColor, int wide, int tall );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void DrawRoundedBorder( Color borderColor, int wide, int tall );
+
+//-----------------------------------------------------------------------------
+
+#endif // CSBACKGROUND_H
diff --git a/game/client/cstrike/VGUI/base_stats_page.cpp b/game/client/cstrike/VGUI/base_stats_page.cpp
new file mode 100644
index 00000000..ab27865b
--- /dev/null
+++ b/game/client/cstrike/VGUI/base_stats_page.cpp
@@ -0,0 +1,359 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "tier3/tier3.h"
+#include "vgui/ILocalize.h"
+#include "lifetime_stats_page.h"
+#include <vgui_controls/SectionedListPanel.h>
+#include "cs_client_gamestats.h" 
+#include "filesystem.h"
+#include "cs_weapon_parse.h"
+#include "buy_presets/buy_presets.h"
+#include "../vgui_controls/ScrollBar.h"
+#include "stat_card.h"
+
+using namespace vgui;
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+KeyValues *g_pPreloadedCSBaseStatGroupLayout = NULL;
+
+//-----------------------------------------------------------------------------
+// Purpose: creates child panels, passes down name to pick up any settings from res files.
+//-----------------------------------------------------------------------------
+CBaseStatsPage::CBaseStatsPage(vgui::Panel *parent, const char *name) : BaseClass(parent, "CSBaseStatsDialog")
+{
+	vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
+
+	m_listItemFont = pScheme->GetFont( "StatsPageText", IsProportional() );
+
+	m_statsList = new SectionedListPanel( this, "StatsList" );
+	m_statsList->SetClickable(false);
+	m_statsList->SetDrawHeaders(false);
+
+	m_bottomBar = new ImagePanel(this, "BottomBar");
+
+	m_pGroupsList = new vgui::PanelListPanel( this, "listpanel_groups" );
+	m_pGroupsList->SetFirstColumnWidth( 0 );
+
+	SetBounds(0, 0, 900, 780);
+	SetMinimumSize( 256, 780 );
+
+	SetBgColor(GetSchemeColor("ListPanel.BgColor", GetBgColor(), pScheme));
+
+	m_pStatCard = new StatCard(this, "ignored");
+
+	ListenForGameEvent( "player_stats_updated" );
+
+	m_bStatsDirty = true;
+}
+
+CBaseStatsPage::~CBaseStatsPage()
+{
+	delete m_statsList;
+}
+
+
+void CBaseStatsPage::MoveToFront()
+{
+    UpdateStatsData();
+	m_pStatCard->UpdateInfo();
+}
+
+void CBaseStatsPage::UpdateStatsData()
+{
+	// Hide the group list scrollbar
+	if (m_pGroupsList->GetScrollbar())
+	{
+		m_pGroupsList->GetScrollbar()->SetWide(0);
+	}
+
+	UpdateGroupPanels();
+	RepopulateStats();
+
+	m_bStatsDirty = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads settings from statsdialog.res in hl2/resource/ui/
+//-----------------------------------------------------------------------------
+void CBaseStatsPage::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+    BaseClass::ApplySchemeSettings( pScheme );
+    LoadControlSettings("resource/ui/CSBaseStatsDialog.res");
+
+	m_statsList->SetClickable(false);
+	m_statsList->SetDrawHeaders(false);
+
+	m_statsList->SetVerticalScrollbar(true);
+
+	SetBgColor(Color(86,86,86,255));
+
+	//Remove any pre-existing sections and add then fresh (this can happen on a resolution change)
+	m_statsList->RemoveAllSections();
+
+	m_statsList->AddSection( 0, "Players");
+
+	m_statsList->SetFontSection(0, m_listItemFont);
+
+	m_pGroupsList->SetBgColor(Color(86,86,86,255));
+	m_statsList->SetBgColor(Color(52,52,52,255));
+}
+
+void CBaseStatsPage::SetActiveStatGroup (CBaseStatGroupPanel* groupPanel)
+{
+	for (int i = 0; i < m_pGroupsList->GetItemCount(); i++)
+	{
+		CBaseStatGroupPanel *pPanel = (CBaseStatGroupPanel*)m_pGroupsList->GetItemPanel(i);
+		if ( pPanel )
+		{
+			if ( pPanel != groupPanel )
+			{
+				pPanel->SetGroupActive( false );
+			}
+			else
+			{
+				pPanel->SetGroupActive( true );
+			}
+		}
+	}
+} 
+
+void CBaseStatsPage::UpdateGroupPanels()
+{
+	int iGroupCount = m_pGroupsList->GetItemCount();
+	vgui::IScheme *pGroupScheme = scheme()->GetIScheme( GetScheme() );
+
+	for ( int i = 0; i < iGroupCount; i++ )
+	{
+		CBaseStatGroupPanel *pPanel = (CBaseStatGroupPanel*)m_pGroupsList->GetItemPanel(i);
+		if ( pPanel )
+		{
+			pPanel->Update( pGroupScheme );
+		}
+	}
+}
+
+
+
+void CBaseStatsPage::OnSizeChanged(int newWide, int newTall)
+{
+	BaseClass::OnSizeChanged(newWide, newTall);
+
+	if (m_statsList)
+	{
+		int labelX, labelY, listX, listY, listWide, listTall;
+		m_statsList->GetBounds(listX, listY, listWide, listTall);
+
+		if (m_bottomBar)
+		{
+			m_bottomBar->GetPos(labelX, labelY);
+			m_bottomBar->SetPos(labelX, listY + listTall);
+		}
+	}
+}
+
+const wchar_t* CBaseStatsPage::TranslateWeaponKillIDToAlias( int statKillID )
+{
+	CSWeaponID weaponIDIndex = WEAPON_MAX;
+	for ( int i = 0; WeaponName_StatId_Table[i].killStatId != CSSTAT_UNDEFINED; ++i )
+	{
+		if( WeaponName_StatId_Table[i].killStatId == statKillID )
+		{
+			weaponIDIndex = WeaponName_StatId_Table[i].weaponId;
+			break;
+		}
+	}
+
+	if (weaponIDIndex == WEAPON_MAX)
+	{
+		return NULL;
+	}
+	else
+	{
+		return WeaponIDToDisplayName(weaponIDIndex);
+	}
+}
+
+const wchar_t* CBaseStatsPage::LocalizeTagOrUseDefault( const char* tag, const wchar_t* def )
+{
+	const wchar_t* result = g_pVGuiLocalize->Find( tag );
+
+	if ( !result )
+		result = def ? def : L"\0";
+
+	return result;
+}
+
+CBaseStatGroupPanel* CBaseStatsPage::AddGroup( const wchar_t* name, const char* title_tag, const wchar_t* def )
+{
+	CBaseStatGroupPanel* newGroup = new CBaseStatGroupPanel( m_pGroupsList, this, "StatGroupPanel", 0 );
+	newGroup->SetGroupInfo( name, LocalizeTagOrUseDefault( title_tag, def ) );
+	newGroup->SetGroupActive( false );
+
+	m_pGroupsList->AddItem( NULL, newGroup );
+
+	return newGroup;
+}
+
+void CBaseStatsPage::FireGameEvent( IGameEvent * event )
+{
+	const char *type = event->GetName();
+
+	if ( 0 == Q_strcmp( type, "player_stats_updated" ) )
+		m_bStatsDirty = true;
+}
+
+void CBaseStatsPage::OnThink()
+{
+	if ( m_bStatsDirty )
+		UpdateStatsData();
+}
+
+CBaseStatGroupPanel::CBaseStatGroupPanel( vgui::PanelListPanel *parent, CBaseStatsPage *owner, const char* name, int iListItemID ) : BaseClass( parent, name )
+{
+	m_pParent = parent;
+	m_pOwner = owner;
+	m_pSchemeSettings = NULL;
+
+	m_pGroupIcon = SETUP_PANEL(new vgui::ImagePanel( this, "GroupIcon" ));
+	m_pBaseStatGroupLabel = new vgui::Label( this, "GroupName", "name" );
+	m_pGroupButton = new CBaseStatGroupButton(this, "GroupButton", "" );
+	m_pGroupButton->SetPos( 0, 0 );
+	m_pGroupButton->SetZPos( 20 );
+	m_pGroupButton->SetWide( 256 );
+	m_pGroupButton->SetTall( 64 );
+	SetMouseInputEnabled( true );
+	parent->SetMouseInputEnabled( true );
+
+	m_bActiveButton = false;
+}
+
+CBaseStatGroupPanel::~CBaseStatGroupPanel()
+{
+	delete m_pBaseStatGroupLabel;
+	delete m_pGroupIcon;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the parameter pIconPanel to display the specified achievement's icon file.
+//-----------------------------------------------------------------------------
+bool CBaseStatGroupPanel::LoadIcon( const char* pFilename)
+{
+	char imagePath[_MAX_PATH];
+	Q_strncpy( imagePath, "achievements\\", sizeof(imagePath) );
+	Q_strncat( imagePath, pFilename, sizeof(imagePath), COPY_ALL_CHARACTERS );
+	Q_strncat( imagePath, ".vtf", sizeof(imagePath), COPY_ALL_CHARACTERS );
+
+	char checkFile[_MAX_PATH];
+	Q_snprintf( checkFile, sizeof(checkFile), "materials\\vgui\\%s", imagePath );
+	if ( !g_pFullFileSystem->FileExists( checkFile ) )
+	{
+		Q_snprintf( imagePath, sizeof(imagePath), "hud\\icon_locked.vtf" );
+	}
+
+	m_pGroupIcon->SetShouldScaleImage( true );
+	m_pGroupIcon->SetImage( imagePath );
+	m_pGroupIcon->SetVisible( true );
+
+	return m_pGroupIcon->IsVisible();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Loads settings from hl2/resource/ui/achievementitem.res
+//			Sets display info for this achievement item.
+//-----------------------------------------------------------------------------
+void CBaseStatGroupPanel::ApplySchemeSettings( vgui::IScheme* pScheme )
+{
+	if ( !g_pPreloadedCSBaseStatGroupLayout )
+	{
+		PreloadResourceFile();
+	}
+
+	LoadControlSettings( "", NULL, g_pPreloadedCSBaseStatGroupLayout );
+
+	m_pSchemeSettings = pScheme;
+
+	BaseClass::ApplySchemeSettings( pScheme );
+}
+
+void CBaseStatGroupPanel::Update( vgui::IScheme* pScheme )
+{
+	if ( m_pSchemeSettings )
+	{
+
+		// Set group name text
+		m_pBaseStatGroupLabel->SetText( m_pGroupTitle );
+		m_pBaseStatGroupLabel->SetFgColor(Color(157, 194, 80, 255));
+
+		if ( !m_bActiveButton )
+		{
+			LoadIcon( "achievement-btn-up" );
+		}
+		else
+		{
+			LoadIcon( "achievement-btn-select" );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CBaseStatGroupPanel::PreloadResourceFile( void )
+{
+	const char *controlResourceName = "resource/ui/StatGroup.res";
+
+	g_pPreloadedCSBaseStatGroupLayout = new KeyValues(controlResourceName);
+	g_pPreloadedCSBaseStatGroupLayout->LoadFromFile(g_pFullFileSystem, controlResourceName);
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Assigns a name and achievement id bounds for an achievement group.
+//-----------------------------------------------------------------------------
+void CBaseStatGroupPanel::SetGroupInfo ( const wchar_t* name, const wchar_t* title)
+{
+	// Store away the group name
+	short   _textLen = (short)wcslen(name) + 1;
+	m_pGroupName = new wchar_t[_textLen];
+	Q_memcpy( m_pGroupName, name, _textLen * sizeof(wchar_t) );
+
+	_textLen = (short)wcslen(title) + 1;
+	m_pGroupTitle = new wchar_t[_textLen];
+	Q_memcpy( m_pGroupTitle, title, _textLen * sizeof(wchar_t) );
+}
+
+
+CBaseStatGroupButton::CBaseStatGroupButton( vgui::Panel *pParent, const char *pName, const char *pText ) :
+BaseClass( pParent, pName, pText )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the case where the user presses an achievement group button.
+//-----------------------------------------------------------------------------
+void CBaseStatGroupButton::DoClick( void )
+{
+	// Process when a group button is hit
+	CBaseStatGroupPanel*    pParent = static_cast<CBaseStatGroupPanel*>(GetParent());
+
+	if (pParent)
+	{
+		CBaseStatsPage*  pBaseStatsPage = static_cast<CBaseStatsPage*>(pParent->GetOwner());
+
+		if (pBaseStatsPage)
+		{
+			pBaseStatsPage->SetActiveStatGroup( pParent );
+			pBaseStatsPage->UpdateStatsData();
+		}
+	}
+}
diff --git a/game/client/cstrike/VGUI/base_stats_page.h b/game/client/cstrike/VGUI/base_stats_page.h
new file mode 100644
index 00000000..e22ec323
--- /dev/null
+++ b/game/client/cstrike/VGUI/base_stats_page.h
@@ -0,0 +1,135 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSBASESTATSPAGE_H
+#define CSBASESTATSPAGE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vgui_controls/PanelListPanel.h"
+#include "vgui_controls/Label.h"
+#include "tier1/KeyValues.h"
+#include "vgui_controls/PropertyPage.h"
+#include "vgui_controls/Button.h"
+#include "vgui_controls/ImagePanel.h"
+#include "GameEventListener.h"
+
+struct PlayerStatData_t;
+class IScheme;
+class CBaseStatGroupPanel;
+class StatCard;
+struct StatsCollection_t;
+struct RoundStatsDirectAverage_t;
+
+class CBaseStatsPage : public vgui::PropertyPage, public CGameEventListener
+{
+    DECLARE_CLASS_SIMPLE ( CBaseStatsPage, vgui::PropertyPage );
+
+public:
+    CBaseStatsPage( vgui::Panel *parent, const char *name );
+	
+	~CBaseStatsPage();
+	
+    virtual void ApplySchemeSettings( vgui::IScheme *pScheme );    
+    virtual void MoveToFront();
+	virtual void OnSizeChanged(int wide, int tall);
+	virtual void OnThink();
+
+	void UpdateStatsData();
+	void SetActiveStatGroup (CBaseStatGroupPanel* groupPanel);
+
+	virtual void FireGameEvent( IGameEvent * event );
+
+protected:
+
+	void UpdateGroupPanels();
+	CBaseStatGroupPanel* AddGroup( const wchar_t* name, const char* title_tag, const wchar_t* def = NULL );
+	const wchar_t* TranslateWeaponKillIDToAlias( int statKillID );
+	const wchar_t* LocalizeTagOrUseDefault( const char* tag, const wchar_t* def = NULL );
+	
+	virtual void RepopulateStats() = 0;	
+
+	vgui::SectionedListPanel	*m_statsList;
+	vgui::HFont					m_listItemFont;
+
+private:
+
+	vgui::PanelListPanel		*m_pGroupsList;
+	vgui::ImagePanel* m_bottomBar;
+	StatCard*	m_pStatCard;
+	bool		m_bStatsDirty;
+};
+
+
+
+
+class CBaseStatGroupButton : public vgui::Button
+{
+	DECLARE_CLASS_SIMPLE( CBaseStatGroupButton, vgui::Button );
+
+public:
+
+	CBaseStatGroupButton(  vgui::Panel *pParent, const char *pName, const char *pText );
+
+	virtual void DoClick( void );
+};
+
+
+
+
+
+class CBaseStatGroupPanel : public vgui::EditablePanel
+{
+	DECLARE_CLASS_SIMPLE( CBaseStatGroupPanel, vgui::EditablePanel );
+
+public:
+	CBaseStatGroupPanel( vgui::PanelListPanel *parent, CBaseStatsPage *owner, const char* name, int iListItemID );
+	~CBaseStatGroupPanel();
+
+	void SetGroupInfo ( const wchar_t* name, const wchar_t* title);
+	
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+	void Update( vgui::IScheme* pScheme );
+
+	vgui::PanelListPanel* GetParent() { return m_pParent; }
+	CBaseStatsPage* GetOwner() { return m_pOwner; }
+
+	void SetGroupActive(bool active) { m_bActiveButton = active; }
+	bool IsGroupActive() { return m_bActiveButton; }
+
+protected:
+
+	// Loads an icon into a specified image panel, or turns the panel off if no icon was found.
+	bool LoadIcon( const char* pFilename);
+
+private:
+	void PreloadResourceFile( void );
+
+	vgui::PanelListPanel    *m_pParent;
+	CBaseStatsPage       *m_pOwner;
+
+	vgui::Label             *m_pBaseStatGroupLabel;	
+
+	CBaseStatGroupButton            *m_pGroupButton;
+
+	vgui::ImagePanel        *m_pGroupIcon;
+
+	vgui::IScheme           *m_pSchemeSettings;
+
+	bool                    m_bActiveButton;
+
+	wchar_t                 *m_pGroupName;
+	wchar_t                 *m_pGroupTitle;
+};
+
+
+
+
+
+#endif // CSBASESTATSPAGE_H
diff --git a/game/client/cstrike/VGUI/bordered_panel.cpp b/game/client/cstrike/VGUI/bordered_panel.cpp
new file mode 100644
index 00000000..cec1d702
--- /dev/null
+++ b/game/client/cstrike/VGUI/bordered_panel.cpp
@@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//-------------------------------------------------------------
+// File:		BorderedPanel.cpp
+// Desc: 		
+// Author: 		Peter Freese <peter@hiddenpath.com>
+// Date: 		2009/05/20
+// Copyright:	© 2009 Hidden Path Entertainment
+//-------------------------------------------------------------
+
+#include "cbase.h"
+#include "bordered_panel.h"
+#include "backgroundpanel.h"	// rounded border support
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+void BorderedPanel::PaintBackground()
+{
+	int wide, tall;
+	GetSize( wide, tall );
+
+	DrawRoundedBackground( GetBgColor(), wide, tall );
+	DrawRoundedBorder( GetFgColor(), wide, tall );
+}
+
+DECLARE_BUILD_FACTORY( BorderedPanel );
+
diff --git a/game/client/cstrike/VGUI/bordered_panel.h b/game/client/cstrike/VGUI/bordered_panel.h
new file mode 100644
index 00000000..7279f10b
--- /dev/null
+++ b/game/client/cstrike/VGUI/bordered_panel.h
@@ -0,0 +1,35 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//-------------------------------------------------------------
+// File:		bordered_panel.h
+// Desc: 		
+// Author: 		Peter Freese <peter@hiddenpath.com>
+// Date: 		2009/05/20
+// Copyright:	© 2009 Hidden Path Entertainment
+//-------------------------------------------------------------
+
+#ifndef INCLUDED_BorderedPanel
+#define INCLUDED_BorderedPanel
+#pragma once
+
+#include <vgui_controls/EditablePanel.h>
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Editable panel with a forced rounded/outlined border
+//-----------------------------------------------------------------------------
+class BorderedPanel : public EditablePanel
+{
+public:
+	DECLARE_CLASS_SIMPLE( BorderedPanel, EditablePanel );
+
+	BorderedPanel( Panel *parent, const char *name ) : 
+	EditablePanel( parent, name )
+	{
+	}
+
+	void PaintBackground();
+};
+
+
+#endif // INCLUDED_BorderedPanel
diff --git a/game/client/cstrike/VGUI/buymouseoverpanelbutton.h b/game/client/cstrike/VGUI/buymouseoverpanelbutton.h
new file mode 100644
index 00000000..9e5abbf6
--- /dev/null
+++ b/game/client/cstrike/VGUI/buymouseoverpanelbutton.h
@@ -0,0 +1,397 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef BUYMOUSEOVERPANELBUTTON_H
+#define BUYMOUSEOVERPANELBUTTON_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <KeyValues.h>
+#include <filesystem.h>
+#include "mouseoverpanelbutton.h"
+#include "hud.h"
+#include "c_cs_player.h"
+#include "cs_gamerules.h"
+#include "cstrike/bot/shared_util.h"
+#include <vgui/ISurface.h>
+#include <vgui/ILocalize.h>
+#include <vgui_controls/ImagePanel.h>
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Triggers a new panel when the mouse goes over the button
+//-----------------------------------------------------------------------------
+class BuyMouseOverPanelButton : public MouseOverPanelButton
+{
+private:
+	typedef MouseOverPanelButton BaseClass;
+public:
+	BuyMouseOverPanelButton(vgui::Panel *parent, const char *panelName, vgui::EditablePanel *panel) :
+	  MouseOverPanelButton( parent, panelName, panel)	
+	  {
+		m_iPrice = 0;
+		m_iPreviousPrice = 0;
+		m_iASRestrict = 0;
+		m_iDEUseOnly = 0;
+		m_command = NULL;
+		m_bIsBargain = false;
+
+		m_pBlackMarketPrice = NULL;//new EditablePanel( parent, "BlackMarket_Labels" );
+		if ( m_pBlackMarketPrice )
+		{
+			m_pBlackMarketPrice->LoadControlSettings( "Resource/UI/BlackMarket_Labels.res" );
+
+			int x,y,wide,tall;
+			GetClassPanel()->GetBounds( x, y, wide, tall );
+			m_pBlackMarketPrice->SetBounds( x, y, wide, tall );
+			int px, py;
+			GetClassPanel()->GetPinOffset( px, py );
+			int rx, ry;
+			GetClassPanel()->GetResizeOffset( rx, ry );
+			// Apply pin settings from template, too
+			m_pBlackMarketPrice->SetAutoResize( GetClassPanel()->GetPinCorner(), GetClassPanel()->GetAutoResize(), px, py, rx, ry );
+		}
+	  }
+
+	virtual void ApplySettings( KeyValues *resourceData ) 
+	{
+		BaseClass::ApplySettings( resourceData );
+
+		KeyValues *kv = resourceData->FindKey( "cost", false );
+		if( kv ) // if this button has a cost defined for it
+		{
+			m_iPrice = kv->GetInt(); // save the price away
+		}
+
+		kv = resourceData->FindKey( "as_restrict", false );
+		if( kv ) // if this button has a map limitation for it
+		{
+			m_iASRestrict = kv->GetInt(); // save the as_restrict away
+		}
+		
+		kv = resourceData->FindKey( "de_useonly", false );
+		if( kv ) // if this button has a map limitation for it
+		{
+			m_iDEUseOnly = kv->GetInt(); // save the de_useonly away
+		}
+
+		if ( m_command )
+		{
+			delete[] m_command;
+			m_command = NULL;
+		}
+		kv = resourceData->FindKey( "command", false );
+		if ( kv )
+		{
+			m_command = CloneString( kv->GetString() );
+		}
+
+		SetPriceState();
+		SetMapTypeState();
+	}
+
+	int GetASRestrict() { return m_iASRestrict; }
+
+	int GetDEUseOnly() { return m_iDEUseOnly; }
+
+	virtual void PerformLayout()
+	{
+		BaseClass::PerformLayout();
+		SetPriceState();
+		SetMapTypeState();
+
+#ifndef CS_SHIELD_ENABLED
+		if ( !Q_stricmp( GetName(), "shield" ) )
+		{
+			SetVisible( false );
+			SetEnabled( false );
+		}
+#endif
+	}
+	
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
+	{
+		BaseClass::ApplySchemeSettings( pScheme );
+
+		m_avaliableColor = pScheme->GetColor( "Label.TextColor", Color( 0, 0, 0, 0 ) );
+		m_unavailableColor = pScheme->GetColor( "Label.DisabledFgColor2", Color( 0, 0, 0, 0 ) );
+		m_bargainColor = Color( 0, 255, 0, 192 );
+
+		SetPriceState();
+		SetMapTypeState();
+	}
+
+	void SetPriceState()
+	{
+		if ( CSGameRules() && CSGameRules()->IsBlackMarket() )
+		{
+			SetMarketState();
+		}
+		else
+		{
+			if ( GetParent() )
+			{
+				Panel *pPanel = dynamic_cast< Panel * >(GetParent()->FindChildByName( "MarketSticker" ) ); 
+
+				if ( pPanel )
+				{
+					pPanel->SetVisible( false );
+				}
+			}
+
+			m_bIsBargain = false;
+		}
+
+		C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+		if ( m_iPrice &&  ( pPlayer && m_iPrice > pPlayer->GetAccount() ) )
+		{
+			SetFgColor( m_unavailableColor );
+			SetCommand( "buy_unavailable" );
+		}
+		else
+		{
+			if ( m_bIsBargain == false )
+			{
+				SetFgColor( m_avaliableColor );
+			}
+			else
+			{
+				SetFgColor( m_bargainColor );
+			}
+			
+			SetCommand( m_command );
+		}
+	}
+
+	void SetMarketState( void )
+	{
+		Panel *pClassPanel = GetClassPanel();
+		if ( pClassPanel )
+		{
+			pClassPanel->SetVisible( false );
+		}
+
+		if ( m_pBlackMarketPrice )
+		{
+			Label *pLabel = dynamic_cast< Label * >(m_pBlackMarketPrice->FindChildByName( "pricelabel" ) );
+
+			if ( pLabel )
+			{
+				const int BufLen = 2048;
+				wchar_t wbuf[BufLen] = L"";
+				const wchar_t *formatStr = g_pVGuiLocalize->Find("#Cstrike_MarketPreviousPrice");
+
+				if ( !formatStr )
+					formatStr = L"%s1";
+
+				char strPrice[16];
+				wchar_t szPrice[64];
+				Q_snprintf( strPrice, sizeof( strPrice ), "%d", m_iPreviousPrice );
+
+				g_pVGuiLocalize->ConvertANSIToUnicode( strPrice, szPrice, sizeof(szPrice));
+
+				g_pVGuiLocalize->ConstructString( wbuf, sizeof(wbuf), formatStr, 1, szPrice );
+				pLabel->SetText( wbuf );
+				pLabel->SetVisible( true );
+			}
+
+			pLabel = dynamic_cast< Label * >(m_pBlackMarketPrice->FindChildByName( "price" ) );
+
+			if ( pLabel )
+			{
+				const int BufLen = 2048;
+				wchar_t wbuf[BufLen] = L"";
+				const wchar_t *formatStr = g_pVGuiLocalize->Find("#Cstrike_MarketCurrentPrice");
+
+				if ( !formatStr )
+					formatStr = L"%s1";
+
+				char strPrice[16];
+				wchar_t szPrice[64];
+				Q_snprintf( strPrice, sizeof( strPrice ), "%d", m_iPrice );
+
+				g_pVGuiLocalize->ConvertANSIToUnicode( strPrice, szPrice, sizeof(szPrice));
+
+				g_pVGuiLocalize->ConstructString( wbuf, sizeof(wbuf), formatStr, 1, szPrice );
+				pLabel->SetText( wbuf );
+				pLabel->SetVisible( true );
+			}
+
+			pLabel = dynamic_cast< Label * >(m_pBlackMarketPrice->FindChildByName( "difference" ) );
+
+			if ( pLabel )
+			{
+				const int BufLen = 2048;
+				wchar_t wbuf[BufLen] = L"";
+				const wchar_t *formatStr = g_pVGuiLocalize->Find("#Cstrike_MarketDeltaPrice");
+
+				if ( !formatStr )
+					formatStr = L"%s1";
+
+				char strPrice[16];
+				wchar_t szPrice[64];
+
+				int iDifference = m_iPreviousPrice - m_iPrice;
+
+				if ( iDifference >= 0 )
+				{
+					pLabel->SetFgColor( m_bargainColor );
+				}
+				else
+				{
+					pLabel->SetFgColor( Color( 192, 28, 0, 255 ) );
+				}
+
+				Q_snprintf( strPrice, sizeof( strPrice ), "%d", abs( iDifference ) );
+
+				g_pVGuiLocalize->ConvertANSIToUnicode( strPrice, szPrice, sizeof(szPrice));
+
+				g_pVGuiLocalize->ConstructString( wbuf, sizeof(wbuf), formatStr, 1, szPrice );
+				pLabel->SetText( wbuf );
+				pLabel->SetVisible( true );
+			}
+
+			ImagePanel *pImage = dynamic_cast< ImagePanel * >(m_pBlackMarketPrice->FindChildByName( "classimage" ) );	
+
+			if ( pImage )
+			{
+				ImagePanel *pClassImage = dynamic_cast< ImagePanel * >(GetClassPanel()->FindChildByName( "classimage" ) );	
+
+				if ( pClassImage )
+				{
+					pImage->SetSize( pClassImage->GetWide(), pClassImage->GetTall() );
+					pImage->SetImage( pClassImage->GetImage() );
+				}
+			}
+
+			if ( GetParent() )
+			{
+				Panel *pPanel = dynamic_cast< Panel * >(GetParent()->FindChildByName( "MarketSticker" ) ); 
+
+				if ( pPanel )
+				{
+					if ( m_bIsBargain )
+					{
+						pPanel->SetVisible( true );
+					}
+					else
+					{
+						pPanel->SetVisible( false );
+					}
+				}
+			}
+		}
+	}
+
+	void SetMapTypeState()
+	{
+		CCSGameRules *pRules = CSGameRules();
+
+		if ( pRules ) 
+		{
+			if( pRules->IsVIPMap() )
+			{
+				if ( m_iASRestrict )
+				{
+					SetFgColor( m_unavailableColor );
+					SetCommand( "buy_unavailable" );
+				}
+			}
+
+			if ( !pRules->IsBombDefuseMap() )
+			{
+				if ( m_iDEUseOnly )
+				{
+					SetFgColor( m_unavailableColor );
+					SetCommand( "buy_unavailable" );
+				}
+			}
+		}
+	}
+
+	void SetBargainButton( bool state )
+	{
+		m_bIsBargain = state;
+	}
+
+	void SetCurrentPrice( int iPrice )
+	{
+		m_iPrice = iPrice;
+	}
+
+	void SetPreviousPrice( int iPrice )
+	{
+		m_iPreviousPrice = iPrice;
+	}
+
+	const char *GetBuyCommand( void )
+	{
+		return m_command;
+	}
+	
+	virtual void ShowPage()
+	{
+		if ( g_lastPanel )
+		{
+			for( int i = 0; i< g_lastPanel->GetParent()->GetChildCount(); i++ )
+			{
+				MouseOverPanelButton *buyButton = dynamic_cast<MouseOverPanelButton *>(g_lastPanel->GetParent()->GetChild(i));
+
+				if ( buyButton )
+				{
+					buyButton->HidePage();
+				}
+			}
+		}
+
+		BaseClass::ShowPage();
+
+		if ( !Q_stricmp( m_command, "vguicancel" ) )
+			return;
+
+		if ( CSGameRules() && CSGameRules()->IsBlackMarket() )
+		{
+			if ( m_pBlackMarketPrice && !m_pBlackMarketPrice->IsVisible() )
+			{
+				m_pBlackMarketPrice->SetVisible( true );
+			}
+		}
+	}
+
+	virtual void HidePage()
+	{
+		BaseClass::HidePage();
+
+		if ( m_pBlackMarketPrice && m_pBlackMarketPrice->IsVisible() )
+		{
+			m_pBlackMarketPrice->SetVisible( false );
+		}
+	}
+
+private:
+
+	int m_iPrice;
+	int m_iPreviousPrice;
+	int m_iASRestrict;
+	int m_iDEUseOnly;
+	bool m_bIsBargain;
+
+	Color m_avaliableColor;
+	Color m_unavailableColor;
+	Color m_bargainColor;
+
+	char *m_command;
+
+public:
+		vgui::EditablePanel *m_pBlackMarketPrice;
+};
+
+
+#endif // BUYMOUSEOVERPANELBUTTON_H
diff --git a/game/client/cstrike/VGUI/buypreset_imageinfo.cpp b/game/client/cstrike/VGUI/buypreset_imageinfo.cpp
new file mode 100644
index 00000000..69f93cce
--- /dev/null
+++ b/game/client/cstrike/VGUI/buypreset_imageinfo.cpp
@@ -0,0 +1,577 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#include "weapon_csbase.h"
+#include "cs_ammodef.h"
+
+#include <vgui/IVGui.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui_controls/Label.h>
+#include <vgui/ILocalize.h>
+#include "vgui_controls/BuildGroup.h"
+#include "vgui_controls/BitmapImagePanel.h"
+#include "vgui_controls/TextEntry.h"
+#include "vgui_controls/TextImage.h"
+#include "vgui_controls/RichText.h"
+#include "vgui_controls/QueryBox.h"
+#include "career_box.h"
+#include "buypreset_listbox.h"
+#include "buypreset_weaponsetlabel.h"
+
+#include "cstrike/bot/shared_util.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+using namespace vgui;
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+WeaponImageInfo::WeaponImageInfo()
+{
+	m_needLayout = m_isCentered = false;
+	m_left = m_top = m_wide = m_tall = 0;
+	m_isPrimary = false;
+	memset( &m_weapon,	0, sizeof(ImageInfo) );
+	memset( &m_ammo,	0, sizeof(ImageInfo) );
+	m_weaponScale = m_ammoScale = 0;
+	m_pAmmoText = new TextImage( "" );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+WeaponImageInfo::~WeaponImageInfo()
+{
+	delete m_pAmmoText;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponImageInfo::ApplyTextSettings( vgui::IScheme *pScheme, bool isProportional )
+{
+	Color color = pScheme->GetColor( "FgColor", Color( 0, 0, 0, 0 ) );
+
+	m_pAmmoText->SetColor( color );
+	m_pAmmoText->SetFont( pScheme->GetFont( "Default", isProportional ) );
+	m_pAmmoText->SetWrap( false );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponImageInfo::SetBounds( int left, int top, int wide, int tall )
+{
+	m_left = left;
+	m_top = top;
+	m_wide = wide;
+	m_tall = tall;
+	m_needLayout = true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponImageInfo::SetCentered( bool isCentered )
+{
+	m_isCentered = isCentered;
+	m_needLayout = true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponImageInfo::SetScaleAt1024( int weaponScale, int ammoScale )
+{
+	m_weaponScale = weaponScale;
+	m_ammoScale = ammoScale;
+	m_needLayout = true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponImageInfo::SetWeapon( const BuyPresetWeapon *pWeapon, bool isPrimary, bool useCurrentAmmoType )
+{
+	m_pAmmoText->SetText( L"" );
+	m_weapon.image = NULL;
+	m_ammo.image = NULL;
+	m_isPrimary = isPrimary;
+
+	if ( !pWeapon )
+		return;
+
+	wchar_t *multiplierString = g_pVGuiLocalize->Find("#Cstrike_BuyMenuPresetMultiplier");
+	if ( !multiplierString )
+		multiplierString = L"";
+	const int BufLen = 32;
+	wchar_t buf[BufLen];
+
+	if ( pWeapon->GetAmmoType() == AMMO_CLIPS )
+	{
+		CSWeaponID weaponID = pWeapon->GetWeaponID();
+		const CCSWeaponInfo *info = GetWeaponInfo( weaponID );
+		int numClips = pWeapon->GetAmmoAmount();
+		if ( info )
+		{
+			int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
+			int buyClipSize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
+
+			int maxClips = (buyClipSize > 0) ? ceil(maxRounds/(float)buyClipSize) : 0;
+			numClips = MIN( numClips, maxClips );
+			m_weapon.image = scheme()->GetImage( ImageFnameFromWeaponID( weaponID, m_isPrimary ), true );
+			if ( numClips == 0 )
+			{
+				m_ammo.image = NULL;
+			}
+			else if ( info->m_WeaponType == WEAPONTYPE_SHOTGUN )
+			{
+				m_ammo.image = scheme()->GetImage( "gfx/vgui/shell", true );
+			}
+			else if ( isPrimary )
+			{
+				m_ammo.image = scheme()->GetImage( "gfx/vgui/bullet", true );
+			}
+			else
+			{
+				m_ammo.image = scheme()->GetImage( "gfx/vgui/cartridge", true );
+			}
+
+			if ( numClips > 1 )
+			{
+				g_pVGuiLocalize->ConstructString( buf, sizeof(buf), multiplierString, 1, NumAsWString( numClips ) );
+				m_pAmmoText->SetText( buf );
+			}
+			else
+			{
+				m_pAmmoText->SetText( L"" );
+			}
+		}
+		else if ( numClips > 0 || !useCurrentAmmoType )
+		{
+			if ( useCurrentAmmoType )
+			{
+				CSWeaponID currentID = GetClientWeaponID( isPrimary );
+				m_weapon.image = scheme()->GetImage( ImageFnameFromWeaponID( currentID, m_isPrimary ), true );
+				info = GetWeaponInfo( currentID );
+				if ( !info )
+				{
+					m_weapon.image = NULL;
+					numClips = 0;
+				}
+				else if ( info->m_WeaponType == WEAPONTYPE_SHOTGUN )
+				{
+					m_ammo.image = scheme()->GetImage( "gfx/vgui/shell", true );
+				}
+				else if ( isPrimary )
+				{
+					m_ammo.image = scheme()->GetImage( "gfx/vgui/bullet", true );
+				}
+				else
+				{
+					m_ammo.image = scheme()->GetImage( "gfx/vgui/cartridge", true );
+				}
+			}
+			else
+			{
+				m_weapon.image = scheme()->GetImage( ImageFnameFromWeaponID( weaponID, m_isPrimary ), true );
+				if ( numClips == 0 )
+				{
+					m_ammo.image = NULL;
+				}
+				else if ( isPrimary )
+				{
+					m_ammo.image = scheme()->GetImage( "gfx/vgui/bullet", true );
+				}
+				else
+				{
+					m_ammo.image = scheme()->GetImage( "gfx/vgui/cartridge", true );
+				}
+			}
+			if ( numClips > 1 )
+			{
+				g_pVGuiLocalize->ConstructString( buf, sizeof(buf), multiplierString, 1, NumAsWString( numClips ) );
+				m_pAmmoText->SetText( buf );
+			}
+			else
+			{
+				m_pAmmoText->SetText( L"" );
+			}
+		}
+	}
+	m_needLayout = true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponImageInfo::Paint()
+{
+	if ( m_needLayout )
+		PerformLayout();
+
+	m_weapon.Paint();
+	m_ammo.Paint();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponImageInfo::PaintText()
+{
+	if ( m_needLayout )
+		PerformLayout();
+
+	m_pAmmoText->Paint();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponImageInfo::PerformLayout()
+{
+	m_needLayout = false;
+
+	m_weapon.FitInBounds( m_left, m_top, m_wide*0.8, m_tall, m_isCentered, m_weaponScale );
+	int ammoX = MIN( m_wide*5/6, m_weapon.w );
+	int ammoSize = m_tall * 9 / 16;
+	if ( !m_isPrimary )
+	{
+		ammoSize = ammoSize * 25 / 40;
+		ammoX = MIN( m_wide*5/6, m_weapon.w*3/4 );
+	}
+	if ( ammoX + ammoSize > m_wide )
+	{
+		ammoX = m_wide - ammoSize;
+	}
+	m_ammo.FitInBounds( m_left + ammoX, m_top + m_tall - ammoSize, ammoSize, ammoSize, false, m_ammoScale );
+
+	int w, h;
+	m_pAmmoText->ResizeImageToContent();
+	m_pAmmoText->GetSize( w, h );
+	if ( m_isPrimary )
+	{
+		if ( m_ammoScale < 75 )
+		{
+			m_pAmmoText->SetPos( m_left + ammoX + ammoSize*1.25f - w, m_top + m_tall - h );
+		}
+		else
+		{
+			m_pAmmoText->SetPos( m_left + ammoX + ammoSize - w, m_top + m_tall - h );
+		}
+	}
+	else
+	{
+		m_pAmmoText->SetPos( m_left + ammoX + ammoSize, m_top + m_tall - h );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+WeaponLabel::WeaponLabel(Panel *parent, const char *panelName) : BaseClass( parent, panelName )
+{
+	SetSize( 10, 10 );
+	SetMouseInputEnabled( false );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+WeaponLabel::~WeaponLabel()
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponLabel::SetWeapon( const BuyPresetWeapon *pWeapon, bool isPrimary, bool showAmmo )
+{
+	BuyPresetWeapon weapon(WEAPON_NONE);
+	if ( pWeapon )
+		weapon = *pWeapon;
+	if ( !showAmmo )
+		weapon.SetAmmoAmount( 0 );
+	m_weapon.SetWeapon( &weapon, isPrimary, false );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponLabel::ApplySchemeSettings(IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	m_weapon.ApplyTextSettings( pScheme, IsProportional() );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponLabel::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	int wide, tall;
+	GetSize( wide, tall );
+	m_weapon.SetBounds( 0, 0, wide, tall );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void WeaponLabel::Paint()
+{
+	BaseClass::Paint();
+
+	m_weapon.Paint();
+	m_weapon.PaintText();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+ItemImageInfo::ItemImageInfo()
+{
+	m_needLayout = false;
+	m_left = m_top = m_wide = m_tall = 0;
+	m_count = 0;
+	memset( &m_image, 0, sizeof(ImageInfo) );
+	m_pText = new TextImage( "" );
+
+	SetBounds( 0, 0, 100, 100 );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+ItemImageInfo::~ItemImageInfo()
+{
+	delete m_pText;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void ItemImageInfo::ApplyTextSettings( vgui::IScheme *pScheme, bool isProportional )
+{
+	Color color = pScheme->GetColor( "Label.TextColor", Color( 0, 0, 0, 0 ) );
+
+	m_pText->SetColor( color );
+	m_pText->SetFont( pScheme->GetFont( "Default", isProportional ) );
+	m_pText->SetWrap( false );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void ItemImageInfo::SetBounds( int left, int top, int wide, int tall )
+{
+	m_left = left;
+	m_top = top;
+	m_wide = wide;
+	m_tall = tall;
+	m_needLayout = true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void ItemImageInfo::SetItem( const char *imageFname, int count )
+{
+	m_pText->SetText( L"" );
+	m_count = count;
+
+	if ( imageFname )
+		m_image.image = scheme()->GetImage( imageFname, true );
+	else
+		m_image.image = NULL;
+
+	if ( count > 1 )
+	{
+		wchar_t *multiplierString = g_pVGuiLocalize->Find("#Cstrike_BuyMenuPresetMultiplier");
+		if ( !multiplierString )
+			multiplierString = L"";
+		const int BufLen = 32;
+		wchar_t buf[BufLen];
+
+		g_pVGuiLocalize->ConstructString( buf, sizeof(buf), multiplierString, 1, NumAsWString( count ) );
+		m_pText->SetText( buf );
+	}
+	m_needLayout = true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void ItemImageInfo::Paint()
+{
+	if ( m_needLayout )
+		PerformLayout();
+
+	if ( m_count )
+		m_image.Paint();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void ItemImageInfo::PaintText()
+{
+	if ( m_needLayout )
+		PerformLayout();
+
+	m_pText->Paint();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void ItemImageInfo::PerformLayout()
+{
+	m_needLayout = false;
+
+	m_image.FitInBounds( m_left, m_top, m_wide, m_tall, false, 0 );
+
+	int w, h;
+	m_pText->ResizeImageToContent();
+	m_pText->GetSize( w, h );
+	m_pText->SetPos( m_left + m_image.w - w, m_top + m_tall - h );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+EquipmentLabel::EquipmentLabel(Panel *parent, const char *panelName, const char *imageFname) : BaseClass( parent, panelName )
+{
+	SetSize( 10, 10 );
+	m_item.SetItem( imageFname, 0 );
+	SetMouseInputEnabled( false );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+EquipmentLabel::~EquipmentLabel()
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void EquipmentLabel::SetItem( const char *imageFname, int count )
+{
+	m_item.SetItem( imageFname, count );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void EquipmentLabel::ApplySchemeSettings(IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	m_item.ApplyTextSettings( pScheme, IsProportional() );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void EquipmentLabel::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	int wide, tall;
+	GetSize( wide, tall );
+	m_item.SetBounds( 0, 0, wide, tall );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void EquipmentLabel::Paint()
+{
+	BaseClass::Paint();
+
+	m_item.Paint();
+	m_item.PaintText();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+/// Helper function: draws a simple dashed line
+void DrawDashedLine(int x0, int y0, int x1, int y1, int dashLen, int gapLen)
+{
+	// work out which way the line goes
+	if ((x1 - x0) > (y1 - y0))
+	{
+		// x direction line
+		while (1)
+		{
+			if (x0 + dashLen > x1)
+			{
+				// draw partial
+				surface()->DrawFilledRect(x0, y0, x1, y1+1);
+			}
+			else
+			{
+				surface()->DrawFilledRect(x0, y0, x0 + dashLen, y1+1);
+			}
+
+			x0 += dashLen;
+
+			if (x0 + gapLen > x1)
+				break;
+
+			x0 += gapLen;
+		}
+	}
+	else
+	{
+		// y direction
+		while (1)
+		{
+			if (y0 + dashLen > y1)
+			{
+				// draw partial
+				surface()->DrawFilledRect(x0, y0, x1+1, y1);
+			}
+			else
+			{
+				surface()->DrawFilledRect(x0, y0, x1+1, y0 + dashLen);
+			}
+
+			y0 += dashLen;
+
+			if (y0 + gapLen > y1)
+				break;
+
+			y0 += gapLen;
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+void ImageInfo::Paint()
+{
+	if ( !image )
+		return;
+
+	image->SetSize( w, h );
+	image->SetPos( x, y );
+	image->Paint();
+	image->SetSize( 0, 0 );	// restore image size to content size to not mess up other places that use the same image
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void ImageInfo::FitInBounds( int baseX, int baseY, int width, int height, bool center, int scaleAt1024, bool halfHeight )
+{
+	if ( !image )
+	{
+		x = y = w = h = 0;
+		return;
+	}
+
+	image->GetContentSize(fullW, fullH);
+
+	if ( scaleAt1024 )
+	{
+		int screenW, screenH;
+		GetHudSize( screenW, screenH );
+
+		w = fullW * screenW / 1024 * scaleAt1024 / 100;
+		h = fullH * screenW / 1024 * scaleAt1024 / 100;
+
+		if ( fullH > 64 && scaleAt1024 == 100 )
+		{
+			w = w * 64 / fullH;
+			h = h * 64 / fullH;
+		}
+
+		if ( h > height * 1.2 )
+			scaleAt1024 = 0;
+	}
+	if ( !scaleAt1024 )
+	{
+		w = fullW;
+		h = fullH;
+
+		if ( h != height )
+		{
+			w = (int) w * 1.0f * height / h;
+			h = height;
+		}
+
+		if ( w > width )
+		{
+			h = (int) h * 1.0f * width / w;
+			w = width;
+		}
+	}
+
+	if ( center )
+	{
+		x = baseX + (width - w)/2;
+	}
+	else
+	{
+		x = baseX;
+	}
+	y = baseY + (height - h)/2;
+}
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/client/cstrike/VGUI/buypreset_listbox.cpp b/game/client/cstrike/VGUI/buypreset_listbox.cpp
new file mode 100644
index 00000000..add8dd75
--- /dev/null
+++ b/game/client/cstrike/VGUI/buypreset_listbox.cpp
@@ -0,0 +1,406 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#include <KeyValues.h>
+#include <vgui/MouseCode.h>
+#include <vgui/IInput.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+
+#include <vgui_controls/EditablePanel.h>
+#include <vgui_controls/ScrollBar.h>
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+#include <vgui_controls/Controls.h>
+#include "buypreset_listbox.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+using namespace vgui;
+
+#ifndef max
+#define max(a,b)            (((a) > (b)) ? (a) : (b))
+#endif
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+BuyPresetListBox::BuyPresetListBox( vgui::Panel *parent, char const *panelName ) : Panel( parent, panelName )
+{
+	m_visibleIndex = 0;
+	m_lastSize = 0;
+
+	SetBounds( 0, 0, 100, 100 );
+
+	m_vbar = new ScrollBar(this, "PanelListPanelVScroll", true);
+	m_vbar->SetBounds( 0, 0, 20, 20 );
+	m_vbar->SetVisible(true);
+	m_vbar->AddActionSignalTarget( this );
+
+	m_pPanelEmbedded = new EditablePanel(this, "PanelListEmbedded");
+	m_pPanelEmbedded->SetBounds(0, 0, 20, 20);
+	m_pPanelEmbedded->SetPaintBackgroundEnabled( false );
+	m_pPanelEmbedded->SetPaintBorderEnabled(false);
+
+	if( IsProportional() )
+	{
+		int width, height;
+		int sw,sh;
+		surface()->GetProportionalBase( width, height );
+		GetHudSize(sw, sh);
+
+		// resize scrollbar, etc
+		m_iScrollbarSize = static_cast<int>( static_cast<float>( SCROLLBAR_SIZE )*( static_cast<float>( sw )/ static_cast<float>( width )));
+		m_iDefaultHeight = static_cast<int>( static_cast<float>( DEFAULT_HEIGHT )*( static_cast<float>( sw )/ static_cast<float>( width )));
+		m_iPanelBuffer = static_cast<int>( static_cast<float>( PANELBUFFER )*( static_cast<float>( sw )/ static_cast<float>( width )));
+	}
+	else
+	{
+		m_iScrollbarSize = SCROLLBAR_SIZE;
+		m_iDefaultHeight = DEFAULT_HEIGHT;
+		m_iPanelBuffer = PANELBUFFER;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+BuyPresetListBox::~BuyPresetListBox()
+{
+	// free data from table
+	DeleteAllItems();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Passes commands up to the parent
+ */
+void BuyPresetListBox::OnCommand( const char *command )
+{
+	GetParent()->OnCommand( command );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Scrolls the list according to the mouse wheel movement
+ */
+void BuyPresetListBox::OnMouseWheeled(int delta)
+{
+	int scale = 3;
+	if ( m_items.Count() )
+	{
+		Panel *panel = m_items[0].panel;
+		if ( panel )
+		{
+			scale = panel->GetTall() + m_iPanelBuffer;
+		}
+	}
+	int val = m_vbar->GetValue();
+	val -= (delta * scale);
+	m_vbar->SetValue(val);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Computes vertical pixels needed by listbox contents
+ */
+int	BuyPresetListBox::computeVPixelsNeeded( void )
+{
+	int pixels = 0;
+
+	int i; 
+	for ( i = 0; i < m_items.Count(); i++ )
+	{
+		Panel *panel = m_items[i].panel;
+		if ( !panel )
+			continue;
+
+		int w, h;
+		panel->GetSize( w, h );
+
+		pixels += m_iPanelBuffer; // add in buffer. between items.
+		pixels += h;	
+	}
+
+	pixels += m_iPanelBuffer; // add in buffer below last item
+
+	return pixels;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Adds an item to the end of the listbox.  UserData is assumed to be a pointer that can be freed by the listbox if non-NULL.
+ */
+int BuyPresetListBox::AddItem( vgui::Panel *panel, void * userData )
+{
+	assert(panel);
+
+	DataItem item = { panel, userData };
+
+	panel->SetParent( m_pPanelEmbedded );
+
+	m_items.AddToTail( item );
+
+	InvalidateLayout();
+	return m_items.Count();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Exchanges two items in the listbox
+ */
+void BuyPresetListBox::SwapItems( int index1, int index2 )
+{
+	if ( index1 < 0 || index2 < 0 || index1 >= m_items.Count() || index2 >= m_items.Count() )
+	{
+		return;
+	}
+
+	DataItem temp = m_items[index1];
+	m_items[index1] = m_items[index2];
+	m_items[index2] = temp;
+
+	InvalidateLayout();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the number of items in the listbox
+ */
+int	BuyPresetListBox::GetItemCount( void ) const
+{
+	return m_items.Count();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the panel in the given index, or NULL
+ */
+Panel * BuyPresetListBox::GetItemPanel(int index) const
+{
+	if ( index < 0 || index >= m_items.Count() )
+		return NULL;
+
+	return m_items[index].panel;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the userData in the given index, or NULL
+ */
+void * BuyPresetListBox::GetItemUserData(int index)
+{
+	if ( index < 0 || index >= m_items.Count() )
+	{
+		return NULL;
+	}
+
+	return m_items[index].userData;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Sets the userData in the given index
+ */
+void BuyPresetListBox::SetItemUserData( int index, void * userData )
+{
+	if ( index < 0 || index >= m_items.Count() )
+		return;
+
+	m_items[index].userData = userData;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Removes an item from the table (changing the indices of all following items), deleting the panel and userData
+ */
+void BuyPresetListBox::RemoveItem(int index)
+{
+	if ( index < 0 || index >= m_items.Count() )
+		return;
+
+	DataItem item = m_items[index];
+	if ( item.panel )
+	{
+		item.panel->MarkForDeletion();
+	}
+	if ( item.userData )
+	{
+		delete item.userData;
+	}
+
+	m_items.Remove( index );
+
+	InvalidateLayout();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  clears the listbox, deleting all panels and userData
+ */
+void BuyPresetListBox::DeleteAllItems()
+{
+	while ( m_items.Count() )
+	{
+		RemoveItem( 0 );
+	}
+
+	// move the scrollbar to the top of the list
+	m_vbar->SetValue(0);
+	InvalidateLayout();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Handles Count changes
+ */
+void BuyPresetListBox::OnSizeChanged(int wide, int tall)
+{
+	BaseClass::OnSizeChanged(wide, tall);
+	InvalidateLayout();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Positions listbox items, etc after internal changes
+ */
+void BuyPresetListBox::PerformLayout()
+{
+	int wide, tall;
+	GetSize( wide, tall );
+
+	int vpixels = computeVPixelsNeeded();
+
+	int visibleIndex = m_visibleIndex;
+
+	//!! need to make it recalculate scroll positions
+	m_vbar->SetVisible(true);
+	m_vbar->SetEnabled(false);
+	m_vbar->SetRange( 0, (MAX( 0, vpixels - tall + m_iDefaultHeight ))  );
+	m_vbar->SetRangeWindow( m_iDefaultHeight );
+	m_vbar->SetButtonPressedScrollValue( m_iDefaultHeight ); // standard height of labels/buttons etc.
+	m_vbar->SetPos(wide - m_iScrollbarSize, 1);
+	m_vbar->SetSize(m_iScrollbarSize, tall - 2);
+
+	m_visibleIndex = visibleIndex;
+
+	int top = MAX( 0, m_vbar->GetValue() );
+
+	m_pPanelEmbedded->SetPos( 1, -top );
+	m_pPanelEmbedded->SetSize( wide-m_iScrollbarSize -2, vpixels );
+
+	// Now lay out the controls on the embedded panel
+	int y = 0;
+	int h = 0;
+	int totalh = 0;
+	
+	int i;
+	for ( i = 0; i < m_items.Count(); i++, y += h )
+	{
+		// add in a little buffer between panels
+		y += m_iPanelBuffer;
+		DataItem item = m_items[i];
+
+		h = item.panel->GetTall();
+
+		totalh += h;
+		item.panel->SetBounds( 8, y, wide - m_iScrollbarSize - 8 - 8, h );
+		item.panel->InvalidateLayout();
+	}
+
+	if ( m_visibleIndex >= 0 && m_visibleIndex < m_items.Count() )
+	{
+
+		int vpos = 0;
+
+		int tempWide, tempTall;
+		GetSize( tempWide, tempTall );
+
+		int vtop, vbottom;
+		m_vbar->GetRange( vtop, vbottom );
+
+		int tempTop = MAX( 0, m_vbar->GetValue() ); // top pixel in the embedded panel
+		int bottom = tempTop + tempTall - 2;
+
+		int itemTop, itemLeft, itemBottom, itemRight;
+		m_items[m_visibleIndex].panel->GetBounds( itemLeft, itemTop, itemRight, itemBottom );
+		itemBottom += itemTop;
+		itemRight += itemLeft;
+
+		if ( itemTop < tempTop )
+		{
+			// item's top is too high
+			vpos -= ( tempTop - itemTop );
+
+			m_vbar->SetValue(vpos);
+			OnSliderMoved(vpos);
+		}
+		else if ( itemBottom > bottom )
+		{
+			// item's bottom is too low
+			vpos += ( itemBottom - bottom );
+
+			m_vbar->SetValue(vpos);
+			OnSliderMoved(vpos);
+		}
+	}
+
+	if ( m_lastSize == vpixels )
+	{
+		m_visibleIndex = -1;
+	}
+	m_lastSize = vpixels;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Try to ensure that the given index is visible
+ */
+void BuyPresetListBox::MakeItemVisible( int index )
+{
+	m_visibleIndex = index;
+	m_lastSize = 0;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Loads colors, fonts, etc
+ */
+void BuyPresetListBox::ApplySchemeSettings(IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+
+	SetBgColor(GetSchemeColor("BuyPresetListBox.BgColor", GetBgColor(), pScheme));
+
+	SetBorder(pScheme->GetBorder("BrowserBorder"));
+	m_vbar->SetBorder(pScheme->GetBorder("BrowserBorder"));
+
+	PerformLayout();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Handles slider being dragged
+ */
+void BuyPresetListBox::OnSliderMoved( int position )
+{
+	InvalidateLayout();
+	Repaint();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Moves slider to the top
+ */
+void BuyPresetListBox::MoveScrollBarToTop()
+{
+	m_vbar->SetValue(0);
+	OnSliderMoved(0);
+}
+
diff --git a/game/client/cstrike/VGUI/buypreset_listbox.h b/game/client/cstrike/VGUI/buypreset_listbox.h
new file mode 100644
index 00000000..68d6de69
--- /dev/null
+++ b/game/client/cstrike/VGUI/buypreset_listbox.h
@@ -0,0 +1,78 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef BUYPRESET_LISTBOX_H
+#define BUYPRESET_LISTBOX_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui/VGUI.h>
+#include <vgui_controls/Panel.h>
+
+#include <utlvector.h>
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  ListBox-style control with behavior needed by weapon lists for BuyPreset editing
+ */
+class BuyPresetListBox : public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( BuyPresetListBox, vgui::Panel );
+
+public:
+	BuyPresetListBox( vgui::Panel *parent, char const *panelName );
+	~BuyPresetListBox();
+
+	virtual int AddItem( vgui::Panel *panel, void * userData );	///< Adds an item to the end of the listbox.  UserData is assumed to be a pointer that can be freed by the listbox if non-NULL.
+	virtual int	GetItemCount( void ) const;						///< Returns the number of items in the listbox
+	void SwapItems( int index1, int index2 );					///< Exchanges two items in the listbox
+	void MakeItemVisible( int index );							///< Try to ensure that the given index is visible
+
+	vgui::Panel * GetItemPanel( int index ) const;				///< Returns the panel in the given index, or NULL
+	void * GetItemUserData( int index );						///< Returns the userData in the given index, or NULL
+	void SetItemUserData( int index, void * userData );			///< Sets the userData in the given index
+
+	virtual void RemoveItem( int index );						///< Removes an item from the table (changing the indices of all following items), deleting the panel and userData
+	virtual void DeleteAllItems();								///< clears the listbox, deleting all panels and userData
+
+	// overrides
+	virtual void OnSizeChanged(int wide, int tall);				////< Handles size changes
+	MESSAGE_FUNC_INT( OnSliderMoved, "ScrollBarSliderMoved", position );	///< Handles slider being dragged
+	virtual void OnMouseWheeled(int delta);						///< Scrolls the list according to the mouse wheel movement
+	virtual void MoveScrollBarToTop();							///< Moves slider to the top
+
+protected:
+
+	virtual int	computeVPixelsNeeded( void );					///< Computes vertical pixels needed by listbox contents
+
+	virtual void PerformLayout();								///< Positions listbox items, etc after internal changes
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );	///< Loads colors, fonts, etc
+
+	virtual void OnCommand( const char *command );				///< Passes commands up to the parent
+
+private:
+	enum { SCROLLBAR_SIZE = 18, DEFAULT_HEIGHT = 24, PANELBUFFER = 5 };
+
+	typedef struct dataitem_s
+	{
+		vgui::Panel *panel;
+		void * userData;
+	} DataItem;
+	CUtlVector< DataItem >	m_items;
+
+	vgui::ScrollBar			*m_vbar;
+	vgui::Panel				*m_pPanelEmbedded;
+
+	int						m_iScrollbarSize;
+	int						m_iDefaultHeight;
+	int						m_iPanelBuffer;
+
+	int						m_visibleIndex;
+	int						m_lastSize;
+};
+
+#endif // BUYPRESET_LISTBOX_H
diff --git a/game/client/cstrike/VGUI/buypreset_panel.cpp b/game/client/cstrike/VGUI/buypreset_panel.cpp
new file mode 100644
index 00000000..321984b4
--- /dev/null
+++ b/game/client/cstrike/VGUI/buypreset_panel.cpp
@@ -0,0 +1,447 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#include "weapon_csbase.h"
+#include "cs_ammodef.h"
+
+#include <vgui/IVGui.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui_controls/Label.h>
+#include <vgui/ILocalize.h>
+#include "vgui_controls/BuildGroup.h"
+#include "vgui_controls/BitmapImagePanel.h"
+#include "vgui_controls/TextEntry.h"
+#include "vgui_controls/TextImage.h"
+#include "vgui_controls/RichText.h"
+#include "vgui_controls/QueryBox.h"
+#include "career_box.h"
+#include "buypreset_listbox.h"
+#include "buypreset_weaponsetlabel.h"
+#include "backgroundpanel.h"
+
+#include "cstrike/bot/shared_util.h"
+
+using namespace vgui;
+
+const float horizTitleRatio = 18.0f/68.0f;
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+/*
+class PresetNameTextEntry : public TextEntry
+{
+public:
+	PresetNameTextEntry(Panel *parent, CBuyPresetEditMainMenu *menu, const char *name ) : TextEntry( parent, name )
+	{
+		m_pMenu = menu;
+	}
+
+	virtual void FireActionSignal()
+	{
+		TextEntry::FireActionSignal();
+		if ( m_pMenu )
+		{
+			m_pMenu->SetDirty();
+		}
+	}
+	
+private:
+	CBuyPresetEditMainMenu *m_pMenu;
+};
+*/
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+int GetScaledValue( HScheme hScheme, int unscaled )
+{
+	int val = scheme()->GetProportionalScaledValueEx( hScheme, unscaled );
+	return GetAlternateProportionalValueFromScaled( hScheme, val );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+class PresetBackgroundPanel : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+
+public:
+	PresetBackgroundPanel( vgui::Panel *parent, const char *panelName ) : BaseClass( parent, panelName )
+	{
+	};
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
+	{
+		BaseClass::ApplySchemeSettings( pScheme );
+		SetBorder( pScheme->GetBorder("ButtonBorder") );
+		m_lineColor = pScheme->GetColor( "Border.Bright", Color( 0, 0, 0, 0 ) );
+	}
+
+	virtual void ApplySettings( KeyValues *inResourceData )
+	{
+		BaseClass::ApplySettings( inResourceData );
+
+		m_lines.RemoveAll();
+		KeyValues *lines = inResourceData->FindKey( "lines", false );
+		if ( lines )
+		{
+			KeyValues *line = lines->GetFirstValue();
+			while ( line )
+			{
+				const char *str = line->GetString( NULL, "" );
+				Vector4D p;
+				int numPoints = sscanf( str, "%f %f %f %f", &p[0], &p[1], &p[2], &p[3] );
+				if ( numPoints == 4 )
+				{
+					m_lines.AddToTail( p );
+				}
+				line = line->GetNextValue();
+			}
+		}
+	}
+
+	virtual void PaintBackground( void )
+	{
+		BaseClass::PaintBackground();
+
+		vgui::surface()->DrawSetColor( m_lineColor );
+		vgui::surface()->DrawSetTextColor( m_lineColor );
+		for ( int i=0; i<m_scaledLines.Count(); ++i )
+		{
+			int x1, x2, y1, y2;
+
+			x1 = m_scaledLines[i][0];
+			y1 = m_scaledLines[i][1];
+			x2 = m_scaledLines[i][2];
+			y2 = m_scaledLines[i][3];
+
+			vgui::surface()->DrawFilledRect( x1, y1, x2, y2 );
+		}
+	}
+
+	virtual void PerformLayout( void )
+	{
+		m_scaledLines.RemoveAll();
+		for ( int i=0; i<m_lines.Count(); ++i )
+		{
+			int x1, x2, y1, y2;
+
+			x1 = GetScaledValue( GetScheme(), m_lines[i][0] );
+			y1 = GetScaledValue( GetScheme(), m_lines[i][1] );
+			x2 = GetScaledValue( GetScheme(), m_lines[i][2] );
+			y2 = GetScaledValue( GetScheme(), m_lines[i][3] );
+
+			if ( x1 == x2 )
+			{
+				++x2;
+			}
+
+			if ( y1 == y2 )
+			{
+				++y2;
+			}
+
+			m_scaledLines.AddToTail( Vector4D( x1, y1, x2, y2 ) );
+		}
+	}
+
+private:
+	Color m_lineColor;
+	CUtlVector< Vector4D > m_lines;
+	CUtlVector< Vector4D > m_scaledLines;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+BuyPresetEditPanel::BuyPresetEditPanel( Panel *parent, const char *panelName, const char *resourceFilename, int fallbackIndex, bool editableName ) : BaseClass( parent, panelName )
+{
+	SetProportional( parent->IsProportional() );
+	if ( IsProportional() )
+	{
+		m_baseWide = m_baseTall = scheme()->GetProportionalScaledValueEx( GetScheme(), 100 );
+	}
+	else
+	{
+		m_baseWide = m_baseTall = 100;
+	}
+	SetSize( m_baseWide, m_baseTall );
+
+	m_fallbackIndex = fallbackIndex;
+
+	m_pBgPanel = new PresetBackgroundPanel( this, "mainBackground" );
+
+	m_pTitleEntry = NULL;
+	m_pTitleLabel = NULL;
+	m_pCostLabel = NULL;
+	/*
+	m_pTitleEntry = new PresetNameTextEntry( this, dynamic_cast<CBuyPresetEditMainMenu *>(parent), "titleEntry" );
+	m_pTitleLabel = new Label( this, "title", "" );
+	m_pCostLabel = new Label( this, "cost", "" );
+	*/
+
+	m_pPrimaryWeapon = new WeaponLabel( this, "primary" );
+	m_pSecondaryWeapon = new WeaponLabel( this, "secondary" );
+
+	m_pHEGrenade = new EquipmentLabel( this, "hegrenade" );
+	m_pSmokeGrenade = new EquipmentLabel( this, "smokegrenade" );
+	m_pFlashbangs = new EquipmentLabel( this, "flashbang" );
+
+	m_pDefuser = new EquipmentLabel( this, "defuser" );
+	m_pNightvision = new EquipmentLabel( this, "nightvision" );
+
+	m_pArmor = new EquipmentLabel( this, "armor" );
+
+	if ( resourceFilename )
+	{
+		LoadControlSettings( resourceFilename );
+	}
+
+	int x, y, w, h;
+	m_pBgPanel->GetBounds( x, y, w, h );
+
+	m_baseWide = x + w;
+	m_baseTall = y + h;
+	SetSize( m_baseWide, m_baseTall );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+BuyPresetEditPanel::~BuyPresetEditPanel()
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void BuyPresetEditPanel::SetWeaponSet( const WeaponSet *pWeaponSet, bool current )
+{
+	// set to empty state
+	Reset();
+
+	// now fill in items
+	if ( pWeaponSet )
+	{
+		if ( m_pTitleLabel )
+		{
+			m_pTitleLabel->SetText( SharedVarArgs( "#Cstrike_BuyPresetChoice%d", m_fallbackIndex ) );
+		}
+		if ( m_pTitleEntry )
+		{
+			m_pTitleEntry->SetText( SharedVarArgs( "#Cstrike_BuyPresetChoice%d", m_fallbackIndex ) );
+		}
+
+		if ( m_pCostLabel )
+		{
+			const int BufLen = 256;
+			wchar_t wbuf[BufLen];
+			g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+				g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+				1, NumAsWString( pWeaponSet->FullCost() ) );
+			m_pCostLabel->SetText( wbuf );
+		}
+
+		m_pPrimaryWeapon->SetWeapon( &pWeaponSet->m_primaryWeapon, true, true );
+		m_pSecondaryWeapon->SetWeapon( &pWeaponSet->m_secondaryWeapon, false, true );
+
+		if ( pWeaponSet->m_HEGrenade )
+			m_pHEGrenade->SetItem( "gfx/vgui/hegrenade_square", 1 );
+		if ( pWeaponSet->m_smokeGrenade )
+			m_pSmokeGrenade->SetItem( "gfx/vgui/smokegrenade_square", 1 );
+		if ( pWeaponSet->m_flashbangs )
+			m_pFlashbangs->SetItem( "gfx/vgui/flashbang_square", pWeaponSet->m_flashbangs );
+
+		if ( pWeaponSet->m_defuser )
+			m_pDefuser->SetItem( "gfx/vgui/defuser", 1 );
+		if ( pWeaponSet->m_nightvision )
+			m_pNightvision->SetItem( "gfx/vgui/nightvision", 1 );
+
+		if ( pWeaponSet->m_armor )
+		{
+			if ( pWeaponSet->m_helmet )
+				m_pArmor->SetItem( "gfx/vgui/kevlar_helmet", 1 );
+			else
+				m_pArmor->SetItem( "gfx/vgui/kevlar", 1 );
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void BuyPresetEditPanel::SetText( const wchar_t *text )
+{
+	if ( !text )
+		text = L"";
+	if ( m_pTitleLabel )
+	{
+		m_pTitleLabel->SetText( text );
+	}
+	if ( m_pTitleEntry )
+	{
+		m_pTitleEntry->SetText( text );
+	}
+	InvalidateLayout();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Handle command callbacks
+ */
+void BuyPresetEditPanel::OnCommand( const char *command )
+{
+	if (stricmp(command, "close"))
+	{
+		PostActionSignal( new KeyValues("Command", "command", SharedVarArgs( "%s %d", command, m_fallbackIndex )) );
+	}
+
+	BaseClass::OnCommand(command);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void BuyPresetEditPanel::ApplySchemeSettings(IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+	SetBgColor( Color( 0, 0, 0, 0 ) );
+
+	IBorder *pBorder = NULL;
+
+	int i;
+
+	for (i = 0; i < GetChildCount(); i++)
+	{
+		// perform auto-layout on the child panel
+		Panel *child = GetChild(i);
+		if (!child)
+			continue;
+
+		if ( !stricmp( "button", child->GetClassName() ) )
+		{
+			Button *pButton = dynamic_cast<Button *>(child);
+			if ( pButton )
+			{
+				pButton->SetDefaultBorder( pBorder );
+				pButton->SetDepressedBorder( pBorder );
+				pButton->SetKeyFocusBorder( pBorder );
+			}
+		}
+	}
+
+	pBorder = pScheme->GetBorder("BuyPresetButtonBorder");
+
+	const int NumButtons = 4;
+	const char * buttonNames[4] = { "editPrimary", "editSecondary", "editGrenades", "editEquipment" };
+	for ( i=0; i<NumButtons; ++i )
+	{
+		Panel *pPanel = FindChildByName( buttonNames[i] );
+		if ( pPanel )
+		{
+			pPanel->SetBorder( pBorder );
+			if ( !stricmp( "button", pPanel->GetClassName() ) )
+			{
+				Button *pButton = dynamic_cast<Button *>(pPanel);
+				if ( pButton )
+				{
+					pButton->SetDefaultBorder( pBorder );
+					pButton->SetDepressedBorder( pBorder );
+					pButton->SetKeyFocusBorder( pBorder );
+
+					Color fgColor, bgColor;
+					fgColor = GetSchemeColor("Label.TextDullColor", GetFgColor(), pScheme);
+					bgColor = Color( 0, 0, 0, 0 );
+					pButton->SetDefaultColor( fgColor, bgColor );
+				}
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Overrides EditablePanel's resizing of children to scale them proportionally to the main panel's change.
+ */
+void BuyPresetEditPanel::OnSizeChanged( int wide, int tall )
+{
+	if ( !m_baseWide )
+		m_baseWide = 1;
+	if ( !m_baseTall )
+		m_baseTall = 1;
+
+	Panel::OnSizeChanged(wide, tall);
+	InvalidateLayout();
+
+	if ( wide == m_baseWide && tall == m_baseTall )
+	{
+		Repaint();
+		return;
+	}
+
+	float xScale = wide / (float) m_baseWide;
+	float yScale = tall / (float) m_baseTall;
+
+	for (int i = 0; i < GetChildCount(); i++)
+	{
+		// perform auto-layout on the child panel
+		Panel *child = GetChild(i);
+		if (!child)
+			continue;
+
+		int x, y, w, t;
+		child->GetBounds(x, y, w, t);
+
+		int newX = (int) x * xScale;
+		int newY = (int) y * yScale;
+		int newW = (int) (x+w) * xScale - newX;
+		int newT = (int) t * yScale;
+
+		// make sure the child isn't too big...
+		if(newX+newW>wide)
+		{
+			continue;
+		}
+		
+		if(newY+newT>tall)
+		{
+			continue;
+		}
+
+		child->SetBounds(newX, newY, newW, newT);
+		child->InvalidateLayout();
+	}
+	Repaint();
+
+	// update the baselines
+	m_baseWide = wide;
+	m_baseTall = tall;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void BuyPresetEditPanel::Reset()
+{
+	if ( m_pTitleLabel )
+	{
+		m_pTitleLabel->SetText( "#Cstrike_BuyPresetNewChoice" );
+	}
+	if ( m_pTitleEntry )
+	{
+		m_pTitleEntry->SetText( "#Cstrike_BuyPresetNewChoice" );
+	}
+	if ( m_pCostLabel )
+	{
+		m_pCostLabel->SetText( "" );
+	}
+
+	BuyPresetWeapon weapon;
+	m_pPrimaryWeapon->SetWeapon( &weapon, true, false );
+	m_pSecondaryWeapon->SetWeapon( &weapon, false, false );
+
+	m_pHEGrenade->SetItem( NULL, 1 );
+	m_pSmokeGrenade->SetItem( NULL, 1 );
+	m_pFlashbangs->SetItem( NULL, 1 );
+
+	m_pDefuser->SetItem( NULL, 1 );
+	m_pNightvision->SetItem( NULL, 1 );
+
+	m_pArmor->SetItem( NULL, 1 );
+}
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/client/cstrike/VGUI/buypreset_weaponsetlabel.h b/game/client/cstrike/VGUI/buypreset_weaponsetlabel.h
new file mode 100644
index 00000000..9c205ad3
--- /dev/null
+++ b/game/client/cstrike/VGUI/buypreset_weaponsetlabel.h
@@ -0,0 +1,302 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef BUYPRESET_WEAPONSETLABEL_H
+#define BUYPRESET_WEAPONSETLABEL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui/VGUI.h>
+#include <vgui_controls/Panel.h>
+#include <vgui/IImage.h>
+
+namespace vgui
+{
+	class TextImage;
+	class TextEntry;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/// Helper function: draws a simple dashed line
+void DrawDashedLine(int x0, int y0, int x1, int y1, int dashLen, int gapLen);
+
+//--------------------------------------------------------------------------------------------------------------
+// Purpose: Wraps an IImage to perform resizes properly
+class BuyPresetImage : public vgui::IImage
+{
+public:
+	BuyPresetImage( vgui::IImage *realImage )
+	{
+		m_image = realImage;
+		if ( m_image )
+		{
+			m_image->GetSize( m_wide, m_tall );
+		}
+		else
+		{
+			m_wide = m_tall = 0;
+		}
+	}
+
+	// Call to Paint the image
+	// Image will draw within the current panel context at the specified position
+	virtual void Paint()
+	{
+		if ( !m_image )
+			return;
+
+		m_image->Paint();
+	}
+
+	// Set the position of the image
+	virtual void SetPos(int x, int y)
+	{
+		if ( !m_image )
+			return;
+
+		m_image->SetPos( x, y );
+	}
+
+	// Gets the size of the content
+	virtual void GetContentSize(int &wide, int &tall)
+	{
+		if ( !m_image )
+			return;
+
+		m_image->GetSize( wide, tall );
+	}
+
+	// Get the size the image will actually draw in (usually defaults to the content size)
+	virtual void GetSize(int &wide, int &tall)
+	{
+		if ( !m_image )
+		{
+			wide = tall = 0;
+			return;
+		}
+
+		wide = m_wide;
+		tall = m_tall;
+	}
+
+	// Sets the size of the image
+	virtual void SetSize(int wide, int tall)
+	{
+		m_wide = wide;
+		m_tall = tall;
+		if ( !m_image )
+			return;
+
+		m_image->SetSize( wide, tall );
+	}
+
+	// Set the draw color 
+	virtual void SetColor(Color col)
+	{
+		if ( !m_image )
+			return;
+
+		m_image->SetColor( col );
+	}
+
+	virtual bool Evict()
+	{
+		return false;
+	}
+
+	virtual int GetNumFrames()
+	{
+		return 0;
+	}
+
+	virtual void SetFrame( int nFrame )
+	{
+	}
+
+	virtual vgui::HTexture GetID()
+	{
+		return 0;
+	}
+
+	virtual void SetRotation( int iRotation )
+	{
+		return;
+	}
+
+private:
+	vgui::IImage *m_image;
+	int m_wide, m_tall;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+struct ImageInfo {
+	vgui::IImage *image;
+	int w;
+	int h;
+	int x;
+	int y;
+	int fullW;
+	int fullH;
+
+	void FitInBounds( int baseX, int baseY, int width, int height, bool center, int scaleAt1024, bool halfHeight = false );
+	void Paint();
+};
+
+//--------------------------------------------------------------------------------------------------------------
+class WeaponImageInfo
+{
+public:
+	WeaponImageInfo();
+	~WeaponImageInfo();
+
+	void SetBounds( int left, int top, int wide, int tall );
+	void SetCentered( bool isCentered );
+	void SetScaleAt1024( int weaponScale, int ammoScale );
+	void SetWeapon( const BuyPresetWeapon *pWeapon, bool isPrimary, bool useCurrentAmmoType );
+
+	void ApplyTextSettings( vgui::IScheme *pScheme, bool isProportional );
+
+	void Paint();
+	void PaintText();
+
+private:
+	void PerformLayout();
+
+	int m_left;
+	int m_top;
+	int m_wide;
+	int m_tall;
+
+	bool m_isPrimary;
+
+	int m_weaponScale;
+	int m_ammoScale;
+
+	bool m_needLayout;
+	bool m_isCentered;
+	ImageInfo m_weapon;
+	ImageInfo m_ammo;
+
+	vgui::TextImage *m_pAmmoText;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+class ItemImageInfo
+{
+public:
+	ItemImageInfo();
+	~ItemImageInfo();
+
+	void SetBounds( int left, int top, int wide, int tall );
+	void SetItem( const char *imageFname, int count );
+	void ApplyTextSettings( vgui::IScheme *pScheme, bool isProportional );
+
+	void Paint();
+	void PaintText();
+
+private:
+	void PerformLayout();
+
+	int m_left;
+	int m_top;
+	int m_wide;
+	int m_tall;
+
+	int m_count;
+
+	bool m_needLayout;
+	ImageInfo m_image;
+
+	vgui::TextImage *m_pText;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+class WeaponLabel : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+public:
+	WeaponLabel(vgui::Panel *parent, const char *panelName);
+	~WeaponLabel();
+
+	void SetWeapon( const BuyPresetWeapon *pWeapon, bool isPrimary, bool showAmmo = false );
+
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	virtual void PerformLayout();
+	virtual void Paint();
+
+protected:
+	WeaponImageInfo m_weapon;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+class EquipmentLabel : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+public:
+	EquipmentLabel(vgui::Panel *parent, const char *panelName, const char *imageFname = NULL);
+	~EquipmentLabel();
+
+	void SetItem( const char *imageFname, int count );
+
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	virtual void PerformLayout();
+	virtual void Paint();
+
+protected:
+	ItemImageInfo m_item;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * BuyPresetEditPanel is a panel displaying a graphical representation of a buy preset.
+ */
+class BuyPresetEditPanel : public vgui::EditablePanel
+{
+	typedef vgui::EditablePanel BaseClass;
+public:
+	BuyPresetEditPanel( vgui::Panel *parent, const char *panelName, const char *resourceFilename, int fallbackIndex, bool editableName );
+	virtual ~BuyPresetEditPanel();
+
+	void SetWeaponSet( const WeaponSet *pWeaponSet, bool current );
+	virtual void SetText( const wchar_t *text );
+
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	void OnCommand( const char *command);					///< Handle command callbacks
+
+	virtual void OnSizeChanged( int wide, int tall );
+
+	void SetPanelBgColor( Color color ) { if (m_pBgPanel) m_pBgPanel->SetBgColor( color ); }
+
+protected:
+	void Reset();
+
+	vgui::Panel *m_pBgPanel;
+
+	vgui::TextEntry *m_pTitleEntry;
+	vgui::Label *m_pTitleLabel;
+	vgui::Label *m_pCostLabel;
+
+	WeaponLabel *m_pPrimaryWeapon;
+	WeaponLabel *m_pSecondaryWeapon;
+
+	EquipmentLabel *m_pHEGrenade;
+	EquipmentLabel *m_pSmokeGrenade;
+	EquipmentLabel *m_pFlashbangs;
+
+	EquipmentLabel *m_pDefuser;
+	EquipmentLabel *m_pNightvision;
+
+	EquipmentLabel *m_pArmor;
+
+	int m_baseWide;
+	int m_baseTall;
+
+	int m_fallbackIndex;
+};
+
+
+#endif // BUYPRESET_WEAPONSETLABEL_H
diff --git a/game/client/cstrike/VGUI/career_box.cpp b/game/client/cstrike/VGUI/career_box.cpp
new file mode 100644
index 00000000..308a44bb
--- /dev/null
+++ b/game/client/cstrike/VGUI/career_box.cpp
@@ -0,0 +1,1296 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+// Author: Matthew D. Campbell (matt@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+
+#include <vgui/KeyCode.h>
+#include "career_box.h"
+#include "career_button.h"
+#include "buypreset_listbox.h"
+#include <vgui_controls/TextImage.h>
+#include <vgui_controls/CheckButton.h>
+#include <vgui_controls/ComboBox.h>
+#include "cs_ammodef.h"
+#include "weapon_csbase.h"
+#include "backgroundpanel.h"
+#include "cs_gamerules.h"
+
+#include <vgui/IInput.h>
+#include "bot/shared_util.h"
+#include <vgui_controls/BitmapImagePanel.h>
+#include <vgui/ISurface.h>
+#include <vgui/ILocalize.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+#ifndef max
+#define max(a,b)            (((a) > (b)) ? (a) : (b))
+#endif
+
+using namespace vgui;
+
+//--------------------------------------------------------------------------------------------------------------
+class ConVarToggleCheckButton : public vgui::CheckButton
+{
+	DECLARE_CLASS_SIMPLE( ConVarToggleCheckButton, vgui::CheckButton );
+
+public:
+	ConVarToggleCheckButton( vgui::Panel *parent, const char *panelName, const char *text );
+	~ConVarToggleCheckButton();
+
+	virtual void	SetSelected( bool state );
+
+	virtual void	Paint();
+
+	void			Reset();
+	void			ApplyChanges();
+	bool			HasBeenModified();
+	void			SetConVar( const char *name );
+
+	virtual void ApplySettings( KeyValues *inResourceData )
+	{
+		BaseClass::ApplySettings( inResourceData );
+
+		const char *name = inResourceData->GetString( "convar", NULL );
+		if ( name )
+		{
+			SetConVar( name );
+		}
+	}
+
+private:
+	MESSAGE_FUNC( OnButtonChecked, "CheckButtonChecked" );
+
+	char			*m_pszCvarName;
+	bool			m_bStartValue;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+ConVarToggleCheckButton::ConVarToggleCheckButton( Panel *parent, const char *panelName, const char *text )
+ : CheckButton( parent, panelName, text )
+{
+	m_pszCvarName = NULL;
+	AddActionSignalTarget( this );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+ConVarToggleCheckButton::~ConVarToggleCheckButton()
+{
+	if ( m_pszCvarName )
+		delete[] m_pszCvarName;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void ConVarToggleCheckButton::SetConVar( const char *name )
+{
+	if ( m_pszCvarName )
+		delete[] m_pszCvarName;
+
+	m_pszCvarName = CloneString( name );
+
+	if (m_pszCvarName && *m_pszCvarName)
+	{
+		Reset();
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void ConVarToggleCheckButton::Paint()
+{
+	if ( !m_pszCvarName || !m_pszCvarName[ 0 ] ) 
+	{
+		BaseClass::Paint();
+		return;
+	}
+
+	// Look up current value
+	ConVar const *var = cvar->FindVar( m_pszCvarName );
+	if ( !var )
+		return;
+	bool value = var->GetBool();
+	
+	if (value != m_bStartValue)
+	{
+		SetSelected( value );
+		m_bStartValue = value;
+	}
+	BaseClass::Paint();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void ConVarToggleCheckButton::ApplyChanges()
+{
+	m_bStartValue = IsSelected();
+	ConVar *var = (ConVar *)cvar->FindVar( m_pszCvarName );
+	if ( !var )
+		return;
+	var->SetValue(m_bStartValue);
+
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void ConVarToggleCheckButton::Reset()
+{
+	ConVar const *var = cvar->FindVar( m_pszCvarName );
+	if ( !var )
+		return;
+	m_bStartValue = var->GetBool();
+	SetSelected(m_bStartValue);
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+bool ConVarToggleCheckButton::HasBeenModified()
+{
+	return IsSelected() != m_bStartValue;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void ConVarToggleCheckButton::SetSelected( bool state )
+{
+	BaseClass::SetSelected( state );
+
+	if ( !m_pszCvarName || !m_pszCvarName[ 0 ] ) 
+		return;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void ConVarToggleCheckButton::OnButtonChecked()
+{
+	if (HasBeenModified())
+	{
+		PostActionSignal(new KeyValues("ControlModified"));
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+CCareerBaseBox::CCareerBaseBox(Panel *parent, const char *panelName, bool loadResources, bool useCareerButtons) : Frame(parent, panelName, false)
+{
+// @TODO:	SetScheme("CareerBoxScheme");
+	SetScheme("ClientScheme");
+	SetProportional( true );
+	SetMoveable(false);
+	SetSizeable(false);
+
+	m_bgColor = Color( 0, 0, 0, 0 );
+	m_borderColor = Color( 0, 0, 0, 0 );
+
+	m_pTextLabel = new Label( this, "TextLabel", "" );
+
+	if ( useCareerButtons )
+	{
+		m_pOkButton = new CCareerButton( this, "OkButton", "", "", false );
+		m_pCancelButton = new CCareerButton( this, "CancelButton", "", "", false );
+	}
+	else
+	{
+		m_pOkButton = new Button( this, "OkButton", "" );
+		m_pCancelButton = new Button( this, "CancelButton", "" );
+	}
+	m_pOkButton->SetVisible(false);
+	if ( useCareerButtons )
+	{
+		m_buttons.PutElement( m_pOkButton );
+		m_buttons.PutElement( m_pCancelButton );
+	}
+	m_cancelFocus = false;
+
+	if (loadResources)
+	{
+		const int BufLen = strlen(panelName) + 32;
+		char *buf = new char[BufLen];
+		Q_snprintf( buf, BufLen, "Resource/Career/%s.res", panelName );
+		LoadControlSettings( buf );
+		delete[] buf;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+vgui::Panel * CCareerBaseBox::CreateControlByName(const char *controlName)
+{
+	if ( Q_stricmp( controlName, "ConVarCheckButton" ) == 0 )
+	{
+		ConVarToggleCheckButton *button = new ConVarToggleCheckButton( NULL, controlName, "" );
+		m_conVarCheckButtons.PutElement( button );
+		return button;
+	}
+
+	return BaseClass::CreateControlByName( controlName );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::SetCancelButtonAsDefault()
+{
+	m_cancelFocus = true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::SetLabelText( const wchar_t *text )
+{
+	m_pTextLabel->SetText(text);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::SetLabelText( const char *text )
+{
+	m_pTextLabel->SetText(text);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	for (int i=0; i<m_buttons.GetCount(); ++i)
+	{
+		m_buttons[i]->SetArmedSound("UI/buttonrollover.wav");
+		m_buttons[i]->SetDepressedSound("UI/buttonclick.wav");
+		m_buttons[i]->SetReleasedSound("UI/buttonclickrelease.wav");
+	}
+
+	m_bgColor = GetSchemeColor("Popup.BgColor", Color( 64, 64, 64, 255 ), pScheme);
+	m_borderColor = GetSchemeColor("FgColor", Color( 64, 64, 64, 255 ), pScheme);
+
+	SetBorder( pScheme->GetBorder( "BaseBorder" ) );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::PerformLayout( )
+{
+	BaseClass::PerformLayout();
+
+	int x, y, w, h;
+	GetBounds(x, y, w, h);
+
+	int screenWide, screenTall;
+	GetHudSize( screenWide, screenTall );
+	if ( x + w/2 != screenWide/2 )
+	{
+		SetPos( screenWide/2 - w/2, screenTall/2 - h/2 );
+		GetBounds(x, y, w, h);
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::PaintBackground( )
+{
+	int wide, tall;
+	GetSize( wide, tall );
+
+	DrawRoundedBackground( m_bgColor, wide, tall );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::PaintBorder( )
+{
+	int wide, tall;
+	GetSize( wide, tall );
+
+	DrawRoundedBorder( m_borderColor, wide, tall );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::ShowWindow()
+{
+	SetVisible( true );
+	SetEnabled( true );
+	MoveToFront();
+
+	if ( m_pCancelButton->IsVisible() && m_cancelFocus )
+	{
+		m_pCancelButton->RequestFocus();
+	}
+	else if ( m_pOkButton->IsVisible() )
+	{
+		m_pOkButton->RequestFocus();
+	}
+	else	 // handle message boxes with no button
+	{
+		RequestFocus();
+	}
+
+	InvalidateLayout();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::DoModal()
+{
+	ShowWindow();
+	input()->SetAppModalSurface(GetVPanel());
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::OnKeyCodeTyped(KeyCode code)
+{
+	if (code == KEY_ESCAPE)
+	{
+		OnCommand("Cancel");
+	}
+	else if (code == KEY_ENTER)
+	{
+		BaseClass::OnKeyCodeTyped( KEY_SPACE );
+	}
+	else
+	{
+		BaseClass::OnKeyCodeTyped(code);
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::OnCommand(const char *command)
+{
+	KeyValues *okSettings = new KeyValues( "GetCommand" );
+	if ( m_pOkButton->RequestInfo( okSettings ) )
+	{
+		const char *okCommand = okSettings->GetString( "command", "Ok" );
+		if ( stricmp(command, okCommand) == 0 )
+		{
+			for (int i=0; i<m_conVarCheckButtons.GetCount(); ++i)
+			{
+				m_conVarCheckButtons[i]->ApplyChanges();
+			}
+		}
+	}
+
+	if (stricmp(command, "close"))
+	{
+		PostActionSignal( new KeyValues("Command", "command", command) );
+	}
+
+	BaseClass::OnCommand(command);
+
+	Close();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerBaseBox::AddButton( vgui::Button *pButton )
+{
+	m_buttons.PutElement( pButton );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CCareerQueryBox::CCareerQueryBox(vgui::Panel *parent, const char *panelName, const char *resourceName) : CCareerBaseBox(parent, panelName, (resourceName == NULL))
+{
+	if ( resourceName )
+	{
+		LoadControlSettings( resourceName );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CCareerQueryBox::CCareerQueryBox(const char *title, const char *labelText, const char *panelName, vgui::Panel *parent) : CCareerBaseBox(parent, panelName)
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CCareerQueryBox::CCareerQueryBox(const wchar_t *title, const wchar_t *labelText, const char *panelName, vgui::Panel *parent) : CCareerBaseBox(parent, panelName)
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CCareerQueryBox::~CCareerQueryBox()
+{
+}
+
+// sorted order weapon list -----------------------------------------------------------------------
+const int NUM_SECONDARY_WEAPONS = 7;
+static CSWeaponID s_secondaryWeapons[NUM_SECONDARY_WEAPONS] =
+{
+	WEAPON_NONE,
+	WEAPON_USP,
+	WEAPON_GLOCK,
+	WEAPON_DEAGLE,
+	WEAPON_ELITE,
+	WEAPON_P228,
+	WEAPON_FIVESEVEN,
+};
+
+const int NUM_PRIMARY_WEAPONS = 23;
+static CSWeaponID s_primaryWeapons[NUM_PRIMARY_WEAPONS] =
+{
+	WEAPON_NONE,
+
+	// Assault Rifles
+	CSWeaponID(-WEAPONTYPE_RIFLE),
+	WEAPON_SG552,
+	WEAPON_AUG,
+	WEAPON_AK47,
+	WEAPON_M4A1,
+	WEAPON_GALIL,
+	WEAPON_FAMAS,
+
+	// Snipers
+	CSWeaponID(-WEAPONTYPE_SNIPER_RIFLE),
+	WEAPON_AWP,
+	WEAPON_SG550,
+	WEAPON_G3SG1,
+	WEAPON_SCOUT,
+
+	// SMG
+	CSWeaponID(-WEAPONTYPE_SUBMACHINEGUN),
+	WEAPON_P90,
+	WEAPON_UMP45,
+	WEAPON_MP5NAVY,
+	WEAPON_MAC10,
+	WEAPON_TMP,
+
+	// Heavy
+	CSWeaponID(-WEAPONTYPE_SHOTGUN),
+	WEAPON_M249,
+	WEAPON_XM1014,
+	WEAPON_M3,
+//	WEAPON_SHIELDGUN,
+};
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+class CWeaponButton : public vgui::Button
+{
+	typedef vgui::Button BaseClass;
+
+public:
+	CWeaponButton( BuyPresetListBox *pParent, CSWeaponID weaponID, bool isPrimary ) : BaseClass( pParent->GetParent(), SharedVarArgs( "WeaponButton%d", weaponID ), "" )
+	{
+		m_isPrimary = isPrimary;
+		m_pImage = NULL;
+		m_pTitleImage = new TextImage( WeaponIDToDisplayName( weaponID ) );
+		m_pCostImage = new TextImage( L"" );
+
+		m_pListBox = pParent;
+		BuyPresetWeapon weapon( weaponID );
+		SetWeapon( weapon );
+	}
+
+	virtual ~CWeaponButton() { delete m_pTitleImage; delete m_pCostImage; }
+
+	virtual void ApplySchemeSettings( IScheme *pScheme );
+
+	virtual Color GetBgColor() { return (IsCurrent()) ? m_selectedBgColor : Button::GetBgColor(); }
+	virtual Color GetFgColor() { return (IsCurrent()) ? m_selectedFgColor : Button::GetFgColor(); }
+
+	void SetCurrent() { s_current = this; }
+	bool IsCurrent() const { return s_current == this; }
+
+	void SetWeapon( const BuyPresetWeapon& weapon );
+	const BuyPresetWeapon& GetWeapon() { return m_weapon; }
+
+	virtual void Paint();
+	virtual void PerformLayout();
+	virtual void PaintBorder() {}
+
+	virtual void OnMousePressed( MouseCode code )
+	{
+		if ( code == MOUSE_LEFT )
+		{
+			SetCurrent();
+			m_pListBox->GetParent()->OnCommand( "select_weapon" );
+		}
+		Button::OnMousePressed( code );
+	}
+
+	virtual void OnMouseDoublePressed( MouseCode code )
+	{
+		if ( code == MOUSE_LEFT )
+		{
+			SetCurrent();
+			m_pListBox->GetParent()->OnCommand( "select_weapon" );
+			m_pListBox->GetParent()->OnCommand( "popup_ok" );
+		}
+		Button::OnMouseDoublePressed( code );
+	}
+
+protected:
+	static CWeaponButton * s_current;
+	BuyPresetListBox * m_pListBox;
+	BuyPresetWeapon m_weapon;
+
+	IImage *m_pImage;
+	TextImage *m_pTitleImage;
+	TextImage *m_pCostImage;
+	int m_imageWide;
+	int m_imageTall;
+	int m_imageX;
+	int m_imageY;
+
+	Color m_selectedBgColor;
+	Color m_selectedFgColor;
+
+	bool m_isPrimary;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+CWeaponButton * CWeaponButton::s_current = NULL;
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponButton::ApplySchemeSettings( IScheme *pScheme )
+{
+	CWeaponButton * current = s_current; // save off current so Button::ApplySchemeSettings() can get the right colors
+	s_current = NULL;
+	Button::ApplySchemeSettings( pScheme );
+	m_selectedBgColor = GetSchemeColor( "Button.ArmedBgColor", Button::GetBgColor(), pScheme );
+	m_selectedFgColor = GetSchemeColor( "Button.ArmedTextColor", Button::GetFgColor(), pScheme );
+	s_current = current;
+	m_pTitleImage->SetColor( pScheme->GetColor( "Button.TextColor", Color() ) );
+	m_pTitleImage->SetFont( pScheme->GetFont( "Default", IsProportional() ) );
+	m_pTitleImage->SetWrap( true );
+	m_pCostImage->SetColor( pScheme->GetColor( "Button.TextColor", Color() ) );
+	m_pCostImage->SetFont( pScheme->GetFont( "Default", IsProportional() ) );
+	m_pCostImage->SetWrap( true );
+	SetWeapon( m_weapon );
+	SetBorder( NULL );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponButton::SetWeapon( const BuyPresetWeapon& weapon )
+{
+	m_weapon = weapon;
+	if ( m_weapon.GetName() )
+	{
+		// weapon string
+		const wchar_t * name = m_weapon.GetName();
+		m_pTitleImage->SetText( name );
+
+		// cost string
+		CCSWeaponInfo *info = GetWeaponInfo( m_weapon.GetWeaponID() );
+		if ( info )
+		{
+			const int BufLen = 256;
+			wchar_t wbuf[BufLen];
+			g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+				g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+				1, NumAsWString( info->GetWeaponPrice() ) );
+			m_pCostImage->SetText( wbuf );
+		}
+		else
+		{
+			m_pCostImage->SetText( L"" );
+		}
+	}
+	else
+	{
+		m_pTitleImage->SetText( L"" );
+		m_pCostImage->SetText( L"" );
+	}
+
+	m_pTitleImage->ResizeImageToContent();
+	m_pCostImage->ResizeImageToContent();
+
+	InvalidateLayout( true, false );
+
+	m_pImage = scheme()->GetImage( ImageFnameFromWeaponID( m_weapon.GetWeaponID(), m_isPrimary ), true );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponButton::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// Calculate some sizes
+	int oldWide, oldTall;
+	GetSize( oldWide, oldTall );
+
+	const float IMAGE_PERCENT = 0.42f;
+	const float TITLE_PERCENT = 0.45f;
+	const float COST_PERCENT = 1.0f - TITLE_PERCENT - IMAGE_PERCENT;
+
+	int maxTitleWide = (int) oldWide * TITLE_PERCENT;
+	int maxImageWide = (int) oldWide * IMAGE_PERCENT;
+	int maxCostWide = (int) oldWide * COST_PERCENT;
+	int textTall = surface()->GetFontTall( m_pTitleImage->GetFont() ) * 2;
+	if ( oldTall != textTall )
+	{
+		oldTall = textTall;
+		SetSize( oldWide, oldTall );
+		m_pListBox->InvalidateLayout();
+	}
+
+	// Position the weapon name
+	{
+		m_pTitleImage->SetSize( maxTitleWide, oldTall );
+		m_pTitleImage->RecalculateNewLinePositions();
+		m_pTitleImage->ResizeImageToContent();
+
+		int textContentWide, textContentTall;
+		m_pTitleImage->GetSize( textContentWide, textContentTall );
+
+		if ( textContentTall < textTall )
+		{
+			m_pTitleImage->SetSize( maxTitleWide, textContentTall );
+			m_pTitleImage->SetPos( maxImageWide, (textTall - textContentTall) / 2 );
+		}
+		else
+		{
+			m_pTitleImage->SetPos( maxImageWide, 0 );
+		}
+	}
+
+	// Position the weapon cost
+	{
+		m_pCostImage->SetSize( maxCostWide, oldTall );
+		m_pCostImage->RecalculateNewLinePositions();
+		m_pCostImage->ResizeImageToContent();
+
+		int textContentWide, textContentTall;
+		m_pCostImage->GetSize( textContentWide, textContentTall );
+
+		if ( textContentTall < textTall )
+		{
+			m_pCostImage->SetSize( maxCostWide, textContentTall );
+			m_pCostImage->SetPos( oldWide - maxCostWide, (textTall - textContentTall) / 2 );
+		}
+		else
+		{
+			m_pCostImage->SetPos( oldWide - maxCostWide, 0 );
+		}
+	}
+
+
+	// Position the weapon image
+	m_pImage = scheme()->GetImage( ImageFnameFromWeaponID( m_weapon.GetWeaponID(), m_isPrimary ), true );
+
+	int maxImageTall = textTall;
+
+	m_pImage->GetContentSize( m_imageWide, m_imageTall );
+	if ( m_imageTall > maxImageTall )
+	{
+		m_imageWide = (int) m_imageWide * 1.0f * maxImageTall / m_imageTall;
+		m_imageTall = maxImageTall;
+	}
+	if ( m_imageWide > maxImageWide )
+	{
+		m_imageTall = (int) m_imageTall * 1.0f * maxImageWide / m_imageWide;
+		m_imageWide = maxImageWide;
+	}
+	m_imageY = (textTall - m_imageTall) / 2;
+	m_imageX = (((int) oldWide * IMAGE_PERCENT) - m_imageWide) / 2;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponButton::Paint()
+{
+	if ( m_pImage )
+	{
+		m_pImage->SetSize( m_imageWide, m_imageTall );
+		m_pImage->SetPos( m_imageX, m_imageY );
+		m_pImage->Paint();
+		m_pImage->SetSize( 0, 0 );
+	}
+	m_pTitleImage->Paint();
+	m_pCostImage->Paint();
+
+	BaseClass::Paint();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+class WeaponComboBox : public vgui::ComboBox
+{
+public:
+	WeaponComboBox( CWeaponSelectBox *parent, const char *name, int numEntries, bool editable )
+		: ComboBox( parent, name, numEntries, editable )
+	{
+		m_pBox = parent;
+	}
+
+	virtual void OnSetText( const wchar_t *newText )
+	{
+		ComboBox::OnSetText( newText );
+		if ( m_pBox )
+			m_pBox->UpdateClips();
+	}
+	
+private:
+	CWeaponSelectBox *m_pBox;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+CWeaponSelectBox::CWeaponSelectBox(vgui::Panel *parent, WeaponSet *pWeaponSet, bool isSecondary ) : CCareerBaseBox(parent, "BuyBoxSelectWeapon", false)
+{
+	m_pWeaponSet = pWeaponSet;
+	m_isSecondary = isSecondary;
+
+	m_numWeapons = NUM_PRIMARY_WEAPONS;
+	m_weaponIDs = s_primaryWeapons;
+
+	BuyPresetWeapon *weapon;
+	if ( !m_isSecondary )
+	{
+		weapon = &m_pWeaponSet->m_primaryWeapon;
+		if ( !IsPrimaryWeapon( weapon->GetWeaponID() ) && weapon->GetWeaponID() != WEAPON_NONE )
+		{
+			BuyPresetWeapon tmp( WEAPON_NONE );
+			m_pWeaponSet->m_primaryWeapon = tmp;
+		}
+	}
+	else
+	{
+		m_numWeapons = NUM_SECONDARY_WEAPONS;
+		m_weaponIDs = s_secondaryWeapons;
+		weapon = &m_pWeaponSet->m_secondaryWeapon;
+		if ( !IsSecondaryWeapon( weapon->GetWeaponID() ) && weapon->GetWeaponID() != WEAPON_NONE )
+		{
+			BuyPresetWeapon tmp( WEAPON_NONE );
+			*weapon = tmp;
+		}
+	}
+
+	int maxClips = 0;
+	const CCSWeaponInfo *info = GetWeaponInfo( weapon->GetWeaponID() );
+	if ( info )
+	{
+		int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
+		int buyClipSize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
+		maxClips = (buyClipSize > 0) ? ceil(maxRounds/(float)buyClipSize) : 0;
+	}
+	else
+	{
+		maxClips = NUM_CLIPS_FOR_CURRENT; // so we can buy ammo for our current gun
+	}
+
+	m_pClips = new WeaponComboBox( this, "Clips", 2*maxClips+1, false );
+	m_pClips->SetOpenDirection( Menu::UP );
+	m_pListBox = new BuyPresetListBox( this, "WeaponListBox" );
+	m_pBullets = new Label( this, "bullets", "" );
+
+	int selectedWeaponIndex = -1;
+	int i;
+	for ( i=0; i<m_numWeapons; ++i )
+	{
+		if ( m_weaponIDs[i] < 0 )
+		{
+			const char *text = "";
+			switch ( (int)m_weaponIDs[i] )
+			{
+			case -WEAPONTYPE_RIFLE:
+				text = "#Cstrike_BuyPresetCategoryRifle";
+				break;
+			case -WEAPONTYPE_SNIPER_RIFLE:
+				text = "#Cstrike_BuyPresetCategorySniper";
+				break;
+			case -WEAPONTYPE_SUBMACHINEGUN:
+				text = "#Cstrike_BuyPresetCategorySMG";
+				break;
+			case -WEAPONTYPE_SHOTGUN:
+				text = "#Cstrike_BuyPresetCategoryHeavy";
+				break;
+			}
+			Label *pLabel = new Label( m_pListBox, SharedVarArgs("weaponlabel%d", i), text );
+			m_pListBox->AddItem( pLabel, NULL );
+		}
+		else
+		{
+			CWeaponButton *pWeaponButton = new CWeaponButton( m_pListBox, m_weaponIDs[i], !m_isSecondary );
+			m_pListBox->AddItem( pWeaponButton, NULL );
+			if ( m_weaponIDs[i] == weapon->GetWeaponID() )
+			{
+				pWeaponButton->SetCurrent();
+				selectedWeaponIndex = i;
+			}
+		}
+	}
+	m_pListBox->MakeItemVisible( selectedWeaponIndex );
+
+	LoadControlSettings( "resource/UI/BuyPreset/BoxSelectWeapon.res" );
+	PopulateControls();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CWeaponSelectBox::~CWeaponSelectBox()
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponSelectBox::ActivateBuildMode()
+{
+	SetClipsVisible( true );
+	m_pListBox->DeleteAllItems();
+	BaseClass::ActivateBuildMode();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponSelectBox::SetClipsVisible( bool visible )
+{
+	SetLabelVisible( visible );
+	m_pClips->SetVisible( visible );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponSelectBox::PopulateControls()
+{
+	BuyPresetWeapon *weapon;
+	if (!m_isSecondary)
+	{
+		weapon = &m_pWeaponSet->m_primaryWeapon;
+	}
+	else
+	{
+		weapon = &m_pWeaponSet->m_secondaryWeapon;
+	}
+
+	int i;
+	int maxClips = 0;
+	const CCSWeaponInfo *info = GetWeaponInfo( weapon->GetWeaponID() );
+	if ( info )
+	{
+		int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
+		int buyClipSize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
+		maxClips = (buyClipSize > 0) ? ceil(maxRounds/(float)buyClipSize) : 0;
+	}
+	else
+	{
+		maxClips = NUM_CLIPS_FOR_CURRENT;
+	}
+	m_pClips->SetNumberOfEditLines( 2*maxClips+1 );
+
+	SetClipsVisible( maxClips != 0 );
+
+	m_pClips->DeleteAllItems();
+
+	// populate clips combo box
+	m_pClips->AddItem( "#Cstrike_BuyPresetEditWeaponFullClips", NULL );
+
+	const int BufLen = 64;
+	wchar_t buf[BufLen];
+	for ( i=maxClips-1; i>=0; --i )
+	{
+		const char* clipsOrMore = "#Cstrike_BuyPresetEditClipsOrMore";
+		const char* clips = "#Cstrike_BuyPresetEditClips";
+		if ( i == 1 )
+		{
+			clipsOrMore = "#Cstrike_BuyPresetEditClipOrMore";
+			clips = "#Cstrike_BuyPresetEditClip";
+		}
+		g_pVGuiLocalize->ConstructString( buf, sizeof(buf),
+			g_pVGuiLocalize->Find( clipsOrMore ),
+			1, NumAsWString( i ));
+		m_pClips->AddItem( buf, NULL );
+		g_pVGuiLocalize->ConstructString( buf, sizeof(buf),
+			g_pVGuiLocalize->Find( clips ),
+			1, NumAsWString( i ));
+		m_pClips->AddItem( buf, NULL );
+	}
+
+	// now select the proper entry
+	int clipIndexToSelect = weapon->GetFillAmmo();
+	clipIndexToSelect += 2 * weapon->GetAmmoAmount();
+	clipIndexToSelect = maxClips*2 - clipIndexToSelect;
+	m_pClips->ActivateItemByRow( clipIndexToSelect );
+
+	if ( m_isSecondary )
+	{
+		Panel *pPanel = FindChildByName( "TitleLabel" );
+		if ( pPanel )
+		{
+			const wchar_t *title = g_pVGuiLocalize->Find( "#Cstrike_BuyPresetWizardSecondary" );
+			if ( title )
+				PostMessage(pPanel, new KeyValues("SetText", "text", title));
+		}
+	}
+
+	UpdateClips();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponSelectBox::UpdateClips()
+{
+	if ( !m_pClips )
+		return;
+
+	int numEntries = m_pClips->GetItemCount();
+	int activeID = m_pClips->GetActiveItem();
+	int combined = numEntries - activeID + 1;
+	int numClips = combined/2 - 1;
+	//bool isFill = (combined%2) != 0;
+
+	BuyPresetWeapon *weapon;
+	if (!m_isSecondary)
+	{
+		weapon = &m_pWeaponSet->m_primaryWeapon;
+	}
+	else
+	{
+		weapon = &m_pWeaponSet->m_secondaryWeapon;
+	}
+
+	const CCSWeaponInfo *info = GetWeaponInfo( weapon->GetWeaponID() );
+	if ( info )
+	{
+		int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
+		int buyClipSize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
+		m_pBullets->SetVisible( true );
+
+		const int BufLen = 64;
+		wchar_t buf[BufLen];
+		g_pVGuiLocalize->ConstructString( buf, sizeof(buf),
+			g_pVGuiLocalize->Find( "#Cstrike_BuyPresetsBullets" ),
+			2, NumAsWString( MIN( maxRounds, numClips * buyClipSize ) ), NumAsWString( maxRounds ) );
+		m_pBullets->SetText( buf );
+	}
+	else
+	{
+		m_pBullets->SetVisible( false );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponSelectBox::ApplySchemeSettings( IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+
+	HFont font = pScheme->GetFont("Default", IsProportional());
+	int tall = surface()->GetFontTall(font) + 2;
+	if ( font != INVALID_FONT )
+	{
+		Menu *pMenu = m_pClips->GetMenu();
+		pMenu->SetMenuItemHeight( tall );
+	}
+
+	for ( int i=0; i<m_pListBox->GetItemCount(); ++i )
+	{
+		if ( m_weaponIDs[i] >= 0 )
+		{
+			CWeaponButton *pButton = static_cast< CWeaponButton * >(m_pListBox->GetItemPanel(i));
+			if ( pButton && pButton->IsCurrent() )
+			{
+				m_pListBox->MakeItemVisible( i );
+			}
+		}
+		else
+		{
+			// it's a caption label
+			Label *pLabel = static_cast< Label * >(m_pListBox->GetItemPanel(i));
+			if ( pLabel )
+			{
+				pLabel->SetContentAlignment( Label::a_center );
+				pLabel->SetBorder( pScheme->GetBorder( "ButtonBorder" ) );
+				pLabel->SetBgColor( pScheme->GetColor( "Frame.BgColor", Color( 0, 0, 0, 255 ) ) );
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CSWeaponID CWeaponSelectBox::GetSelectedWeaponID()
+{
+	int selectedIndex = -1;
+	for ( int i=0; i<m_pListBox->GetItemCount(); ++i )
+	{
+		if ( m_weaponIDs[selectedIndex] >= 0 )
+		{
+			CWeaponButton *pButton = static_cast< CWeaponButton * >(m_pListBox->GetItemPanel(i));
+			if ( pButton && pButton->IsCurrent() )
+			{
+				selectedIndex = i;
+			}
+		}
+	}
+	if ( selectedIndex >= 0 )
+	{
+		return m_weaponIDs[selectedIndex];
+	}
+
+	return WEAPON_NONE;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CWeaponSelectBox::OnCommand(const char *command)
+{
+	if (!stricmp(command, "select_weapon"))
+	{
+		CSWeaponID weaponID = GetSelectedWeaponID();
+		BuyPresetWeapon weapon( weaponID );
+		if ( m_isSecondary )
+		{
+			m_pWeaponSet->m_secondaryWeapon = weapon;
+		}
+		else
+		{
+			m_pWeaponSet->m_primaryWeapon = weapon;
+		}
+
+		PopulateControls();
+		return;
+	}
+
+	if (!stricmp(command, "popup_ok"))
+	{
+		if ( !m_pClips )
+			return;
+
+		int numEntries = m_pClips->GetItemCount();
+		int activeID = m_pClips->GetActiveItem();
+		int combined = numEntries - activeID + 1;
+		int numClips = combined/2 - 1;
+		bool isFill = (combined%2) != 0;
+
+		BuyPresetWeapon weapon( GetSelectedWeaponID() );
+		weapon.SetAmmoType( AMMO_CLIPS );
+		weapon.SetAmmoAmount( numClips );
+		weapon.SetFillAmmo( isFill );
+
+		if ( m_isSecondary )
+		{
+			m_pWeaponSet->m_secondaryWeapon = weapon;
+		}
+		else
+		{
+			m_pWeaponSet->m_primaryWeapon = weapon;
+		}
+		BaseClass::OnCommand( command );
+	}
+	else
+	{
+		BaseClass::OnCommand(command);
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+class EquipmentComboBox : public ComboBox
+{
+public:
+	EquipmentComboBox( CBaseSelectBox *parent, const char *name, int numEntries, bool editable )
+		: ComboBox( parent, name, numEntries, editable )
+	{
+		m_pBox = parent;
+	}
+
+	virtual void OnSetText( const wchar_t *newText )
+	{
+		ComboBox::OnSetText( newText );
+		m_pBox->OnControlChanged();
+	}
+	
+private:
+	CBaseSelectBox *m_pBox;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+CGrenadeSelectBox::CGrenadeSelectBox( vgui::Panel *parent, WeaponSet *pWeaponSet ) : BaseClass( parent, "BuyBoxSelectGrenades", false )
+{
+	m_pWeaponSet = pWeaponSet;
+
+	// Equipment controls
+	m_pHEGrenade = new EquipmentComboBox( this, "hegrenade", 2, false );
+	m_pSmokeGrenade = new EquipmentComboBox( this, "smokegrenade", 2, false );
+	m_pFlashbangs = new EquipmentComboBox( this, "flashbangs", 3, false );
+
+	// Equipment images
+	m_pHEGrenadeImage = new EquipmentLabel( this, "HEGrenadeImage" );
+	m_pSmokeGrenadeImage = new EquipmentLabel( this, "SmokeGrenadeImage" );
+	m_pFlashbangImage = new EquipmentLabel( this, "FlashbangImage" );
+
+	m_pHELabel    = new Label( this, "HECost", "" );
+	m_pSmokeLabel = new Label( this, "SmokeCost", "" );
+	m_pFlashLabel = new Label( this, "FlashCost", "" );
+
+	LoadControlSettings( "Resource/UI/BuyPreset/BoxSelectGrenades.res" );
+
+	// Add entries to the combo boxes
+	m_pHEGrenade->AddItem( "0", NULL );
+	m_pHEGrenade->AddItem( "1", NULL );
+
+	m_pSmokeGrenade->AddItem( "0", NULL );
+	m_pSmokeGrenade->AddItem( "1", NULL );
+
+	m_pFlashbangs->AddItem( "0", NULL );
+	m_pFlashbangs->AddItem( "1", NULL );
+	m_pFlashbangs->AddItem( "2", NULL );
+
+	// populate the data
+	m_pHEGrenade->ActivateItemByRow( m_pWeaponSet->m_HEGrenade );
+	m_pSmokeGrenade->ActivateItemByRow( m_pWeaponSet->m_smokeGrenade );
+	m_pFlashbangs->ActivateItemByRow( m_pWeaponSet->m_flashbangs );
+
+	m_pHEGrenadeImage->SetItem( "gfx/vgui/hegrenade_square", 1 );
+	m_pSmokeGrenadeImage->SetItem( "gfx/vgui/smokegrenade_square", 1 );
+	m_pFlashbangImage->SetItem( "gfx/vgui/flashbang_square", 1 );
+
+	OnControlChanged();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CGrenadeSelectBox::OnControlChanged()
+{
+	const int BufLen = 256;
+	wchar_t wbuf[BufLen];
+
+	CCSWeaponInfo *info;
+
+	int numGrenades;
+	info = GetWeaponInfo( WEAPON_HEGRENADE );
+	if ( info )
+	{
+		numGrenades = m_pHEGrenade->GetActiveItem();
+		g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+			g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+			1, NumAsWString( info->GetWeaponPrice() * numGrenades ) );
+		m_pHELabel->SetText( wbuf );
+	}
+
+	info = GetWeaponInfo( WEAPON_SMOKEGRENADE );
+	if ( info )
+	{
+		numGrenades = m_pSmokeGrenade->GetActiveItem();
+		g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+			g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+			1, NumAsWString( info->GetWeaponPrice() * numGrenades ) );
+		m_pSmokeLabel->SetText( wbuf );
+	}
+
+	info = GetWeaponInfo( WEAPON_FLASHBANG );
+	if ( info )
+	{
+		numGrenades = m_pFlashbangs->GetActiveItem();
+		g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+			g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+			1, NumAsWString( info->GetWeaponPrice() * numGrenades ) );
+		m_pFlashLabel->SetText( wbuf );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CGrenadeSelectBox::OnCommand( const char *command )
+{
+	if (!stricmp(command, "popup_ok"))
+	{
+		// stuff values back in m_pWeaponSet
+		m_pWeaponSet->m_HEGrenade    = m_pHEGrenade->GetActiveItem();
+		m_pWeaponSet->m_smokeGrenade = m_pSmokeGrenade->GetActiveItem();
+		m_pWeaponSet->m_flashbangs   = m_pFlashbangs->GetActiveItem();
+	}
+	BaseClass::OnCommand( command );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+CEquipmentSelectBox::CEquipmentSelectBox( vgui::Panel *parent, WeaponSet *pWeaponSet ) : BaseClass( parent, "BuyBoxSelectEquipment", false )
+{
+	m_pWeaponSet = pWeaponSet;
+
+	// Equipment controls
+	m_pKevlar      = new EquipmentComboBox( this, "kevlar", 2, false );
+	m_pHelmet      = new EquipmentComboBox( this, "helmet", 2, false );
+	m_pDefuser     = new EquipmentComboBox( this, "defuser", 2, false );
+	m_pNightvision = new EquipmentComboBox( this, "nightvision", 2, false );
+
+	// Equipment labels
+	m_pKevlarLabel      = new Label( this, "kevlarCost", "" );
+	m_pHelmetLabel      = new Label( this, "helmetCost", "" );
+	m_pDefuserLabel     = new Label( this, "defuserCost", "" );
+	m_pNightvisionLabel = new Label( this, "nightvisionCost", "" );
+
+	// Equipment images
+	m_pKevlarImage      = new EquipmentLabel( this, "KevlarImage" );
+	m_pHelmetImage      = new EquipmentLabel( this, "HelmetImage" );
+	m_pDefuserImage     = new EquipmentLabel( this, "DefuserImage" );
+	m_pNightvisionImage = new EquipmentLabel( this, "NightvisionImage" );
+
+	LoadControlSettings( "Resource/UI/BuyPreset/BoxSelectEquipment.res" );
+
+	// Add entries to the combo boxes
+	m_pKevlar->AddItem( "0", NULL );
+	m_pKevlar->AddItem( "1", NULL );
+
+	m_pHelmet->AddItem( "0", NULL );
+	m_pHelmet->AddItem( "1", NULL );
+
+	m_pDefuser->AddItem( "0", NULL );
+	m_pDefuser->AddItem( "1", NULL );
+
+	m_pNightvision->AddItem( "0", NULL );
+	m_pNightvision->AddItem( "1", NULL );
+
+	// populate the data
+	m_pKevlar->ActivateItemByRow( ( m_pWeaponSet->m_armor > 0 ) );
+	m_pHelmet->ActivateItemByRow( ( m_pWeaponSet->m_armor && m_pWeaponSet->m_helmet ) );
+	m_pDefuser->ActivateItemByRow( m_pWeaponSet->m_defuser );
+	m_pNightvision->ActivateItemByRow( m_pWeaponSet->m_nightvision );
+
+	m_pKevlarImage->SetItem( "gfx/vgui/kevlar", 1 );
+	m_pHelmetImage->SetItem( "gfx/vgui/helmet", 1 );
+	m_pDefuserImage->SetItem( "gfx/vgui/defuser", 1 );
+	m_pNightvisionImage->SetItem( "gfx/vgui/nightvision", 1 );
+
+	OnControlChanged();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CEquipmentSelectBox::OnControlChanged()
+{
+	const int BufLen = 256;
+	wchar_t wbuf[BufLen];
+
+	int iHelmetPrice = HELMET_PRICE;
+	int iKevlarPrice = KEVLAR_PRICE;
+	int iNVGPrice = NVG_PRICE;
+
+	if ( CSGameRules()->IsBlackMarket() )
+	{
+		iHelmetPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_ASSAULTSUIT ) - CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
+		iKevlarPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
+		iNVGPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_NVG );
+	}
+
+	int count = m_pKevlar->GetActiveItem();
+	g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+		g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+		1, NumAsWString( iKevlarPrice * count ) );
+	m_pKevlarLabel->SetText( wbuf );
+
+	m_pHelmet->SetEnabled( count );
+	if ( !count && m_pHelmet->GetActiveItem() )
+		m_pHelmet->ActivateItemByRow( 0 );
+
+	count = m_pHelmet->GetActiveItem();
+	g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+		g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+		1, NumAsWString( iHelmetPrice * count ) );
+	m_pHelmetLabel->SetText( wbuf );
+
+	count = m_pDefuser->GetActiveItem();
+	g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+		g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+		1, NumAsWString( DEFUSEKIT_PRICE * count ) );
+	m_pDefuserLabel->SetText( wbuf );
+
+	count = m_pNightvision->GetActiveItem();
+	g_pVGuiLocalize->ConstructString( wbuf, sizeof( wbuf ),
+		g_pVGuiLocalize->Find( "#Cstrike_BuyPresetPlainCost" ),
+		1, NumAsWString( NVG_PRICE * count ) );
+	m_pNightvisionLabel->SetText( wbuf );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CEquipmentSelectBox::OnCommand( const char *command )
+{
+	if (!stricmp(command, "popup_ok"))
+	{
+		// stuff values back in m_pWeaponSet
+		m_pWeaponSet->m_armor       = m_pKevlar->GetActiveItem() ? 100 : 0;
+		m_pWeaponSet->m_helmet      = m_pWeaponSet->m_armor && m_pHelmet->GetActiveItem();
+		m_pWeaponSet->m_defuser     = m_pDefuser->GetActiveItem();
+		m_pWeaponSet->m_nightvision = m_pNightvision->GetActiveItem();
+	}
+	BaseClass::OnCommand( command );
+}
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/client/cstrike/VGUI/career_box.h b/game/client/cstrike/VGUI/career_box.h
new file mode 100644
index 00000000..7506308e
--- /dev/null
+++ b/game/client/cstrike/VGUI/career_box.h
@@ -0,0 +1,202 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+// Author: Matthew D. Campbell (matt@turtlerockstudios.com), 2003
+
+#ifndef CAREER_BOX_H
+#define CAREER_BOX_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <KeyValues.h>
+#include <vgui_controls/Frame.h>
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+#include <vgui_controls/TextEntry.h>
+#include "weapon_csbase.h"
+#include "buy_presets/buy_presets.h"
+#include "buypreset_listbox.h"
+#include "buypreset_weaponsetlabel.h"
+
+class ConVarToggleCheckButton;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Base class for career popup dialogs (handles custom backgrounds, etc)
+ */
+class CCareerBaseBox : public vgui::Frame
+{
+public:
+	CCareerBaseBox(vgui::Panel *parent, const char *panelName, bool loadResources = true, bool useCareerButtons = false );
+	virtual void ShowWindow();
+	void DoModal();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void PaintBackground();
+	virtual void PaintBorder();
+	virtual void PerformLayout();
+	void SetLabelText( const char *text );
+	void SetLabelText( const wchar_t *text );
+	void SetCancelButtonAsDefault();
+	vgui::Button * GetOkButton() { return m_pOkButton; }
+	virtual vgui::Panel *CreateControlByName(const char *controlName);
+
+private:
+	typedef vgui::Frame BaseClass;
+	vgui::Button		*m_pOkButton;
+	vgui::Button		*m_pCancelButton;
+	vgui::Dar<vgui::Button *> m_buttons;
+	vgui::Dar<ConVarToggleCheckButton *> m_conVarCheckButtons;
+
+	Color					 m_bgColor;
+	Color					 m_borderColor;
+	vgui::Label				*m_pTextLabel;
+	bool					 m_cancelFocus;
+
+protected:
+	void SetLabelVisible( bool visible ) { m_pTextLabel->SetVisible( visible ); }
+	virtual void OnKeyCodeTyped( vgui::KeyCode code );
+	virtual void OnCommand( const char *command );			///< Handle button presses
+	void AddButton( vgui::Button *pButton );				///< Add a button to our list of buttons for rollover sounds
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Popup dialog with functionality similar to QueryBox, bot with different layout
+ */
+class CCareerQueryBox : public CCareerBaseBox
+{
+public:
+	CCareerQueryBox(vgui::Panel *parent, const char *panelName, const char *resourceName = NULL);
+	CCareerQueryBox(const char *title, const char *labelText, const char *panelName, vgui::Panel *parent = NULL);
+	CCareerQueryBox(const wchar_t *title, const wchar_t *labelText, const char *panelName, vgui::Panel *parent = NULL);
+
+	virtual ~CCareerQueryBox();
+ 
+private:
+	typedef CCareerBaseBox BaseClass;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Popup dialog for selecting and editing a primary weapon (ammo to buy, side-availability)
+ */
+class CWeaponSelectBox : public CCareerBaseBox
+{
+public:
+	CWeaponSelectBox( vgui::Panel *parent, WeaponSet *pWeaponSet, bool isSecondary );
+
+	virtual ~CWeaponSelectBox();
+
+	virtual void ActivateBuildMode();
+
+	void UpdateClips();
+
+protected:
+	virtual void OnCommand( const char *command );
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+private:
+	void PopulateControls();
+	void SetClipsVisible( bool visible );
+
+	CSWeaponID GetSelectedWeaponID();
+
+	typedef CCareerBaseBox BaseClass;
+	vgui::ComboBox *m_pClips;	///< Number of clips to purchase
+	vgui::Label *m_pBullets;	///< Label showing "M of N Bullets"
+
+	WeaponSet *m_pWeaponSet;	///< WeaponSet being edited
+	bool m_isSecondary;			///< is this weapon primary or secondary?
+	BuyPresetListBox *m_pListBox;	///< List of weapons from which to choose
+
+	int m_numWeapons;
+	CSWeaponID *m_weaponIDs;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Base class for editing grenades and equipment
+ */
+class CBaseSelectBox : public CCareerBaseBox
+{
+	typedef CCareerBaseBox BaseClass;
+
+public:
+	CBaseSelectBox( vgui::Panel *parent, const char *panelName, bool loadResources = true ) : BaseClass( parent, panelName, loadResources ) {}
+
+	virtual void OnControlChanged() = 0;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Popup dialog for editing grenades in a buy preset fallback
+ */
+class CGrenadeSelectBox : public CBaseSelectBox
+{
+	typedef CBaseSelectBox BaseClass;
+
+public:
+	CGrenadeSelectBox( vgui::Panel *parent, WeaponSet *pWeaponSet );
+
+	void OnControlChanged();		///< Updates item costs
+
+private:
+	WeaponSet *m_pWeaponSet;		///< WeaponSet being edited
+
+	// Equipment controls
+	vgui::ComboBox		*m_pHEGrenade;
+	EquipmentLabel		*m_pHEGrenadeImage;
+	vgui::Label			*m_pHELabel;
+
+	vgui::ComboBox		*m_pSmokeGrenade;
+	EquipmentLabel		*m_pSmokeGrenadeImage;
+	vgui::Label			*m_pSmokeLabel;
+
+	vgui::ComboBox		*m_pFlashbangs;
+	EquipmentLabel		*m_pFlashbangImage;
+	vgui::Label			*m_pFlashLabel;
+
+	virtual void OnCommand( const char *command );
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Popup dialog for selecting an equipment set
+ */
+class CEquipmentSelectBox : public CBaseSelectBox
+{
+	typedef CBaseSelectBox BaseClass;
+
+public:
+	CEquipmentSelectBox( vgui::Panel *parent, WeaponSet *pWeaponSet );
+
+	void OnControlChanged();
+
+private:
+	WeaponSet *m_pWeaponSet;		///< WeaponSet being edited
+
+	// Equipment controls
+	vgui::ComboBox		*m_pKevlar;
+	vgui::Label			*m_pKevlarLabel;
+	EquipmentLabel		*m_pKevlarImage;
+
+	vgui::ComboBox		*m_pHelmet;
+	vgui::Label			*m_pHelmetLabel;
+	EquipmentLabel		*m_pHelmetImage;
+
+	vgui::ComboBox		*m_pDefuser;
+	vgui::Label			*m_pDefuserLabel;
+	EquipmentLabel		*m_pDefuserImage;
+
+	vgui::ComboBox		*m_pNightvision;
+	vgui::Label			*m_pNightvisionLabel;
+	EquipmentLabel		*m_pNightvisionImage;
+
+	virtual void OnCommand( const char *command );
+};
+
+#endif // CAREER_BOX_H
diff --git a/game/client/cstrike/VGUI/career_button.cpp b/game/client/cstrike/VGUI/career_button.cpp
new file mode 100644
index 00000000..24bf779d
--- /dev/null
+++ b/game/client/cstrike/VGUI/career_button.cpp
@@ -0,0 +1,189 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#include <convar.h>
+#include "cdll_int.h"
+#include <ienginevgui.h>
+#include "filesystem.h"
+#include <vgui/ISystem.h>
+#include "career_button.h"
+
+#include <vgui_controls/Label.h>
+#include <vgui_controls/URLLabel.h>
+#include <vgui_controls/ComboBox.h>
+#include <vgui/ISurface.h>
+#include <vgui/ILocalize.h>
+#include <vgui_controls/ScrollBar.h>
+#include <vgui_controls/BuildGroup.h>
+#include <vgui_controls/ImageList.h>
+#include <vgui_controls/TextImage.h>
+#include <vgui_controls/Button.h>
+
+#include "KeyValues.h"
+
+using namespace vgui;
+
+#ifndef _DEBUG
+#define PROPORTIONAL_CAREER_FRAMES 1
+#endif
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+CCareerButton::CCareerButton(vgui::Panel *parent, const char *buttonName, const char *buttonText, const char *image, bool textFirst) : BaseClass( parent, buttonName, "" )
+{
+	m_armedBorder = NULL;
+
+	m_textImage = new TextImage(buttonText);
+	m_image = scheme()->GetImage(image, true);
+	m_textFirst = textFirst;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerButton::SetImage( const char *image )
+{
+	m_image = scheme()->GetImage(image, true);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerButton::Paint()
+{
+	int buttonWide, buttonTall;
+	GetSize(buttonWide, buttonTall);
+
+	int imageWide, imageTall;
+	if ( m_image )
+	{
+		m_image->GetSize(imageWide, imageTall);
+	}
+	else
+	{
+		imageWide = imageTall = 0;
+	}
+
+	int textOffset = m_textPad;
+
+	if (m_textFirst)
+	{
+		if ( m_image )
+		{
+			m_image->SetPos(buttonWide - imageWide - m_imagePad, (buttonTall - imageTall)/2);
+			m_image->Paint();
+		}
+	}
+	else
+	{
+		if ( m_image )
+		{
+			m_image->SetPos(m_imagePad, (buttonTall - imageTall)/2);
+			m_image->Paint();
+		}
+		textOffset += imageWide + m_imagePad;
+	}
+
+	int textTall, textWide;
+	m_textImage->GetSize(textWide, textTall);
+
+	int textSpace = buttonWide - imageWide - m_imagePad - 2*m_textPad;
+
+	if ( IsEnabled() )
+	{
+		m_textImage->SetColor( m_textNormalColor );
+	}
+	else
+	{
+		m_textImage->SetColor( m_textDisabledColor );
+	}
+	m_textImage->SetPos(textOffset + (textSpace - textWide)/2, (buttonTall - textTall)/2);
+	m_textImage->Paint();
+
+	if (HasFocus()  && IsEnabled() )
+	{
+		int x0, y0, x1, y1;
+		x0 = 3, y0 = 3, x1 = buttonWide - 4 , y1 = buttonTall - 2;
+		DrawFocusBorder(x0, y0, x1, y1);
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerButton::SetArmedBorder(IBorder *border)
+{
+	m_armedBorder = border;
+	InvalidateLayout(false);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+IBorder* CCareerButton::GetBorder(bool depressed, bool armed, bool selected, bool keyfocus)
+{
+	if ( /*_buttonBorderEnabled &&*/ armed && !depressed && IsEnabled() )
+	{
+		return m_armedBorder;
+	}
+
+	return BaseClass::GetBorder( depressed, armed, selected, keyfocus );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCareerButton::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	SetDefaultBorder( pScheme->GetBorder("CareerButtonBorder") );
+	SetDepressedBorder( pScheme->GetBorder("CareerButtonDepressedBorder") );
+	m_armedBorder = pScheme->GetBorder("CareerButtonArmedBorder");
+
+	m_textNormalColor = pScheme->GetColor( "Label.TextBrightColor", Color(255, 255, 255, 255) );
+	m_textDisabledColor = pScheme->GetColor( "Label.DisabledFgColor2", Color(128, 128, 128, 255) );
+	m_textImage->SetColor( m_textNormalColor );
+	if ( m_image )
+	{
+		m_image->SetColor( GetFgColor() );
+	}
+
+	m_textImage->SetFont( pScheme->GetFont( "Default", IsProportional() ) );
+
+	m_textPad = atoi(pScheme->GetResourceString( "CareerButtonTextPad" ));
+	m_imagePad = atoi(pScheme->GetResourceString( "CareerButtonImagePad" ));
+	if (IsProportional())
+	{
+		m_textPad = scheme()->GetProportionalScaledValueEx( GetScheme(),m_textPad);
+		m_imagePad = scheme()->GetProportionalScaledValueEx( GetScheme(),m_imagePad);
+	}
+
+	const int BufLen = 128;
+	char buf[BufLen];
+	GetText(buf, BufLen);
+	m_textImage->SetText(buf);
+	m_textImage->ResizeImageToContent();
+
+	int buttonWide, buttonTall;
+	GetSize(buttonWide, buttonTall);
+
+	int imageWide, imageTall;
+	if ( m_image )
+	{
+		m_image->GetSize(imageWide, imageTall);
+	}
+	else
+	{
+		imageWide = imageTall = 0;
+	}
+
+	int textSpace = buttonWide - imageWide - m_imagePad - 2*m_textPad;
+
+	int textWide, textTall;
+	m_textImage->GetContentSize(textWide, textTall);
+	if (textSpace < textWide)
+		m_textImage->SetSize(textSpace, textTall);
+
+	Color bgColor = pScheme->GetColor( "CareerButtonBG", Color(0, 0, 0, 0) );
+	SetDefaultColor( bgColor, bgColor );
+	SetArmedColor( bgColor, bgColor );
+	SetDepressedColor( bgColor, bgColor );
+}
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/client/cstrike/VGUI/career_button.h b/game/client/cstrike/VGUI/career_button.h
new file mode 100644
index 00000000..96dabdd0
--- /dev/null
+++ b/game/client/cstrike/VGUI/career_button.h
@@ -0,0 +1,57 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef CAREER_BUTTON_H
+#define CAREER_BUTTON_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui/VGUI.h>
+#include <vgui_controls/Frame.h>
+#include <vgui_controls/Controls.h>
+#include <vgui_controls/BitmapImagePanel.h>
+#include <vgui_controls/PanelListPanel.h>
+#include <vgui_controls/Button.h>
+#include <vgui/KeyCode.h>
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  This class adds border functionality necessary for next/prev/start buttons on map and bot screens
+ */
+class CCareerButton : public vgui::Button
+{
+public:
+	CCareerButton(vgui::Panel *parent, const char *buttonName, const char *buttonText, const char *image, bool textFirst );
+
+	// Set armed button border attributes.  Added in CCareerButton.
+	virtual void SetArmedBorder(vgui::IBorder *border);
+
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	virtual void Paint();
+
+	void SetImage( const char *image );
+
+protected:
+
+	// Get button border attributes.
+	virtual vgui::IBorder *GetBorder(bool depressed, bool armed, bool selected, bool keyfocus);
+
+	vgui::IBorder *m_armedBorder;
+	vgui::IImage *m_image;
+	vgui::TextImage *m_textImage;
+	bool m_textFirst;
+	int m_textPad;
+	int m_imagePad;
+
+	Color m_textNormalColor;
+	Color m_textDisabledColor;
+
+private:
+	typedef vgui::Button BaseClass;
+};
+
+#endif // CAREER_BUTTON_H
diff --git a/game/client/cstrike/VGUI/counterstrikeviewport.cpp b/game/client/cstrike/VGUI/counterstrikeviewport.cpp
new file mode 100644
index 00000000..d1f85776
--- /dev/null
+++ b/game/client/cstrike/VGUI/counterstrikeviewport.cpp
@@ -0,0 +1,322 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client DLL VGUI2 Viewport
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+
+#pragma warning( disable : 4800  )  // disable forcing int to bool performance warning
+
+// VGUI panel includes
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include <KeyValues.h>
+#include <vgui/Cursor.h>
+#include <vgui/IScheme.h>
+#include <vgui/IVGui.h>
+#include <vgui/ILocalize.h>
+#include <vgui/VGUI.h>
+
+// client dll/engine defines
+#include "hud.h"
+#include <voice_status.h>
+
+// cstrike specific dialogs
+#include "cstriketextwindow.h"
+#include "cstriketeammenu.h"
+#include "cstrikeclassmenu.h"
+#include "cstrikebuymenu.h"
+#include "cstrikebuyequipmenu.h"
+#include "cstrikespectatorgui.h"
+#include "cstrikeclientscoreboard.h"
+#include "clientmode_csnormal.h"
+#include "IGameUIFuncs.h"
+
+// viewport definitions
+#include <baseviewport.h>
+#include "counterstrikeviewport.h"
+#include "cs_gamerules.h"
+// #include "c_user_message_register.h"
+#include "vguicenterprint.h"
+#include "text_message.h"
+
+
+static void OpenPanelWithCheck( const char *panelToOpen, const char *panelToCheck )
+{
+	IViewPortPanel *checkPanel = gViewPortInterface->FindPanelByName( panelToCheck );
+	if ( !checkPanel || !checkPanel->IsVisible() )
+	{
+		gViewPortInterface->ShowPanel( panelToOpen, true );
+	}
+}
+
+
+CON_COMMAND( buyequip, "Show equipment buy menu" )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if( pPlayer && pPlayer->m_lifeState == LIFE_ALIVE && pPlayer->State_Get() == STATE_ACTIVE )
+	{
+		if( !pPlayer->IsInBuyZone() )
+		{
+			internalCenterPrint->Print( "#Cstrike_NotInBuyZone" );
+		}
+		else if( CSGameRules()->IsBuyTimeElapsed() )
+		{
+			char strBuyTime[16];
+			Q_snprintf( strBuyTime, sizeof( strBuyTime ), "%d", (int)CSGameRules()->GetBuyTimeLength() );
+			
+			wchar_t buffer[128];
+			wchar_t buytime[16];
+			g_pVGuiLocalize->ConvertANSIToUnicode( strBuyTime, buytime, sizeof(buytime) );
+			g_pVGuiLocalize->ConstructString( buffer, sizeof(buffer), g_pVGuiLocalize->Find("#Cstrike_TitlesTXT_Cant_buy"), 1, buytime );
+			internalCenterPrint->Print( buffer );
+		}
+		else
+		{
+			if( pPlayer->GetTeamNumber() == TEAM_CT )
+			{
+				OpenPanelWithCheck( PANEL_BUY_EQUIP_CT, PANEL_BUY_CT );
+			}
+			else if( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
+			{
+				OpenPanelWithCheck( PANEL_BUY_EQUIP_TER, PANEL_BUY_TER );
+			}
+		}
+	}
+}
+
+CON_COMMAND( buymenu, "Show main buy menu" )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if( pPlayer )
+	{
+		if ( pPlayer->m_lifeState != LIFE_ALIVE && pPlayer->State_Get() != STATE_ACTIVE )
+			return;
+
+		if( !pPlayer->IsInBuyZone() )
+		{
+			internalCenterPrint->Print( "#Cstrike_NotInBuyZone" );
+		}
+		else if( CSGameRules()->IsBuyTimeElapsed() )
+		{
+			char strBuyTime[16];
+			Q_snprintf( strBuyTime, sizeof( strBuyTime ), "%d", (int)CSGameRules()->GetBuyTimeLength() );
+
+			wchar_t buffer[128];
+			wchar_t buytime[16];
+			g_pVGuiLocalize->ConvertANSIToUnicode( strBuyTime, buytime, sizeof(buytime) );
+			g_pVGuiLocalize->ConstructString( buffer, sizeof(buffer), g_pVGuiLocalize->Find("#Cstrike_TitlesTXT_Cant_buy"), 1, buytime );
+			internalCenterPrint->Print( buffer );
+		}
+		else
+		{
+			if( pPlayer->GetTeamNumber() == TEAM_CT )
+			{
+				OpenPanelWithCheck( PANEL_BUY_CT, PANEL_BUY_EQUIP_CT );
+			}
+			else if( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
+			{
+				OpenPanelWithCheck( PANEL_BUY_TER, PANEL_BUY_EQUIP_TER );
+			}
+		}
+	}
+}
+
+CON_COMMAND( chooseteam, "Choose a new team" )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( pPlayer && pPlayer->CanShowTeamMenu() )
+	{
+		gViewPortInterface->ShowPanel( PANEL_TEAM, true );
+	}
+}
+
+CON_COMMAND_F( spec_help, "Show spectator help screen", FCVAR_CLIENTCMD_CAN_EXECUTE)
+{
+	if ( gViewPortInterface )
+		gViewPortInterface->ShowPanel( PANEL_INFO, true );
+}
+
+CON_COMMAND_F( spec_menu, "Activates spectator menu", FCVAR_CLIENTCMD_CAN_EXECUTE)
+{
+	bool bShowIt = true;
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( pPlayer && !pPlayer->IsObserver() )
+		return;
+
+	if ( args.ArgC() == 2 )
+	{
+		 bShowIt = atoi( args[ 1 ] ) == 1;
+	}
+	
+	if ( gViewPortInterface )
+		gViewPortInterface->ShowPanel( PANEL_SPECMENU, bShowIt );
+}
+
+CON_COMMAND_F( togglescores, "Toggles score panel", FCVAR_CLIENTCMD_CAN_EXECUTE)
+{
+	if ( !gViewPortInterface )
+		return;
+	
+	IViewPortPanel *scoreboard = gViewPortInterface->FindPanelByName( PANEL_SCOREBOARD );
+
+	if ( !scoreboard )
+		return;
+
+	if ( scoreboard->IsVisible() )
+	{
+		gViewPortInterface->ShowPanel( scoreboard, false );
+		GetClientVoiceMgr()->StopSquelchMode();
+	}
+	else
+	{
+		gViewPortInterface->ShowPanel( scoreboard, true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the VGUI subsystem starts up
+//			Creates the sub panels and initialises them
+//-----------------------------------------------------------------------------
+void CounterStrikeViewport::Start( IGameUIFuncs *pGameUIFuncs, IGameEventManager2 * pGameEventManager )
+{
+	BaseClass::Start( pGameUIFuncs, pGameEventManager );
+}
+
+void CounterStrikeViewport::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	gHUD.InitColors( pScheme );
+
+	SetPaintBackgroundEnabled( false );
+}
+
+
+IViewPortPanel* CounterStrikeViewport::CreatePanelByName(const char *szPanelName)
+{
+	IViewPortPanel* newpanel = NULL;
+
+	// overwrite MOD specific panel creation
+
+	if ( Q_strcmp(PANEL_SCOREBOARD, szPanelName) == 0)
+	{
+		newpanel = new CCSClientScoreBoardDialog( this );
+	}
+
+	else if ( Q_strcmp(PANEL_SPECGUI, szPanelName) == 0 )
+	{
+		newpanel = new CCSSpectatorGUI( this );	
+	}
+
+	else if ( Q_strcmp(PANEL_CLASS_CT, szPanelName) == 0 )
+	{
+		newpanel = new CClassMenu_CT( this );	
+	}
+
+	else if ( Q_strcmp(PANEL_CLASS_TER, szPanelName) == 0 )
+	{
+		newpanel = new CClassMenu_TER( this );	
+	}
+
+	else if ( Q_strcmp(PANEL_BUY_CT, szPanelName) == 0 )
+	{
+		newpanel = new CCSBuyMenu_CT( this );
+	}
+
+	else if ( Q_strcmp(PANEL_BUY_TER, szPanelName) == 0 )
+	{
+		newpanel = new CCSBuyMenu_TER( this );
+	}
+
+	else if ( Q_strcmp(PANEL_BUY_EQUIP_CT, szPanelName) == 0 )
+	{
+		newpanel = new CCSBuyEquipMenu_CT( this );
+	}
+
+	else if ( Q_strcmp(PANEL_BUY_EQUIP_TER, szPanelName) == 0 )
+	{
+		newpanel = new CCSBuyEquipMenu_TER( this );
+	}
+
+	else if ( Q_strcmp(PANEL_TEAM, szPanelName) == 0 )
+	{
+		newpanel = new CCSTeamMenu( this );
+	}
+
+	else if ( Q_strcmp(PANEL_INFO, szPanelName) == 0 )
+	{
+		newpanel = new CCSTextWindow( this );
+	}
+
+	else
+	{
+		// create a generic base panel, don't add twice
+		newpanel = BaseClass::CreatePanelByName( szPanelName );
+	}
+
+	return newpanel; 
+}
+
+void CounterStrikeViewport::CreateDefaultPanels( void )
+{
+	AddNewPanel( CreatePanelByName( PANEL_TEAM ), "PANEL_TEAM" );
+	AddNewPanel( CreatePanelByName( PANEL_CLASS_CT ), "PANEL_CLASS_CT" );
+	AddNewPanel( CreatePanelByName( PANEL_CLASS_TER ), "PANEL_CLASS_TER" );
+
+	AddNewPanel( CreatePanelByName( PANEL_BUY_CT ), "PANEL_BUY_CT" );
+	AddNewPanel( CreatePanelByName( PANEL_BUY_TER ), "PANEL_BUY_TER" );
+	AddNewPanel( CreatePanelByName( PANEL_BUY_EQUIP_CT ), "PANEL_BUY_EQUIP_CT" );
+	AddNewPanel( CreatePanelByName( PANEL_BUY_EQUIP_TER ), "PANEL_BUY_EQUIP_TER" );
+
+	BaseClass::CreateDefaultPanels();
+
+}
+
+int CounterStrikeViewport::GetDeathMessageStartHeight( void )
+{
+	int x = YRES(2);
+
+	if ( g_pSpectatorGUI && g_pSpectatorGUI->IsVisible() )
+	{
+		x += g_pSpectatorGUI->GetTopBarHeight();
+	}
+
+	return x;
+}
+
+/*
+==========================
+HUD_ChatInputPosition
+
+Sets the location of the input for chat text
+==========================
+*/
+//MIKETODO: positioning of chat text (and other engine output)
+/*
+	#include "Exports.h"
+
+	void CL_DLLEXPORT HUD_ChatInputPosition( int *x, int *y )
+	{
+		RecClChatInputPosition( x, y );
+		if ( gViewPortInterface )
+		{
+			gViewPortInterface->ChatInputPosition( x, y );
+		}
+	}
+
+	EXPOSE_SINGLE_INTERFACE(CounterStrikeViewport, IClientVGUI, CLIENTVGUI_INTERFACE_VERSION);
+*/
diff --git a/game/client/cstrike/VGUI/counterstrikeviewport.h b/game/client/cstrike/VGUI/counterstrikeviewport.h
new file mode 100644
index 00000000..25591676
--- /dev/null
+++ b/game/client/cstrike/VGUI/counterstrikeviewport.h
@@ -0,0 +1,61 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef COUNTERSTRIKEVIEWPORT_H
+#define COUNTERSTRIKEVIEWPORT_H
+
+#include "cs_shareddefs.h"
+#include "baseviewport.h"
+
+
+using namespace vgui;
+
+namespace vgui 
+{
+	class Panel;
+	class Label;
+	class CBitmapImagePanel;
+}
+
+class CCSTeamMenu;
+class CCSClassMenu;
+class CCSSpectatorGUI;
+class CCSClientScoreBoard;
+class CBuyMenu;
+class CCSClientScoreBoardDialog;
+
+
+
+//==============================================================================
+class CounterStrikeViewport : public CBaseViewport
+{
+
+private:
+	DECLARE_CLASS_SIMPLE( CounterStrikeViewport, CBaseViewport );
+
+public:
+
+	IViewPortPanel* CreatePanelByName(const char *szPanelName);
+	void CreateDefaultPanels( void );
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void Start( IGameUIFuncs *pGameUIFuncs, IGameEventManager2 * pGameEventManager );
+		
+	int GetDeathMessageStartHeight( void );
+
+	virtual void ShowBackGround(bool bShow) 
+	{
+		m_pBackGround->SetVisible( false );	// CS:S menus paint their own backgrounds...
+	}
+
+private:
+	void CenterWindow( vgui::Frame *win );
+
+};
+
+
+#endif // COUNTERSTRIKEVIEWPORT_H
diff --git a/game/client/cstrike/VGUI/cstrikebuyequipmenu.cpp b/game/client/cstrike/VGUI/cstrikebuyequipmenu.cpp
new file mode 100644
index 00000000..ed8f013e
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikebuyequipmenu.cpp
@@ -0,0 +1,111 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cstrikebuyequipmenu.h"
+#include "cs_shareddefs.h"
+#include "cstrikebuysubmenu.h"
+#include "backgroundpanel.h"
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor for CT Equipment menu
+//-----------------------------------------------------------------------------
+CCSBuyEquipMenu_CT::CCSBuyEquipMenu_CT(IViewPort *pViewPort) : CBuyMenu( pViewPort )
+{
+	SetTitle( "#Cstrike_Buy_Menu", true);
+
+	SetProportional( true );
+
+	m_pMainMenu = new CCSBuySubMenu( this, "BuySubMenu" );
+	m_pMainMenu->LoadControlSettings( "Resource/UI/BuyEquipment_CT.res" );
+	m_pMainMenu->SetVisible( false );
+
+	m_iTeam = TEAM_CT;
+
+	CreateBackground( this );
+	m_backgroundLayoutFinished = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor for Terrorist Equipment menu
+//-----------------------------------------------------------------------------
+CCSBuyEquipMenu_TER::CCSBuyEquipMenu_TER(IViewPort *pViewPort) : CBuyMenu( pViewPort )
+{
+	SetTitle( "#Cstrike_Buy_Menu", true);
+
+	SetProportional( true );
+
+	m_pMainMenu = new CCSBuySubMenu( this, "BuySubMenu" );
+	m_pMainMenu->LoadControlSettings( "Resource/UI/BuyEquipment_TER.res" );
+	m_pMainMenu->SetVisible( false );
+
+	m_iTeam = TEAM_TERRORIST;
+
+	CreateBackground( this );
+	m_backgroundLayoutFinished = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The CS background is painted by image panels, so we should do nothing
+//-----------------------------------------------------------------------------
+void CCSBuyEquipMenu_CT::PaintBackground()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Scale / center the window
+//-----------------------------------------------------------------------------
+void CCSBuyEquipMenu_CT::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// stretch the window to fullscreen
+	if ( !m_backgroundLayoutFinished )
+		LayoutBackgroundPanel( this );
+	m_backgroundLayoutFinished = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBuyEquipMenu_CT::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	ApplyBackgroundSchemeSettings( this, pScheme );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The CS background is painted by image panels, so we should do nothing
+//-----------------------------------------------------------------------------
+void CCSBuyEquipMenu_TER::PaintBackground()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Scale / center the window
+//-----------------------------------------------------------------------------
+void CCSBuyEquipMenu_TER::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// stretch the window to fullscreen
+	if ( !m_backgroundLayoutFinished )
+		LayoutBackgroundPanel( this );
+	m_backgroundLayoutFinished = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBuyEquipMenu_TER::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	ApplyBackgroundSchemeSettings( this, pScheme );
+}
+
diff --git a/game/client/cstrike/VGUI/cstrikebuyequipmenu.h b/game/client/cstrike/VGUI/cstrikebuyequipmenu.h
new file mode 100644
index 00000000..425bd88d
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikebuyequipmenu.h
@@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSTRIKEBUYEQUIPMENU_H
+#define CSTRIKEBUYEQUIPMENU_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/WizardPanel.h>
+
+#include <buymenu.h>
+
+namespace vgui
+{
+	class Panel;
+}
+
+//============================
+// CT Equipment menu
+//============================
+class CCSBuyEquipMenu_CT : public CBuyMenu
+{
+private:
+	typedef vgui::WizardPanel BaseClass;
+
+public:
+	CCSBuyEquipMenu_CT(IViewPort *pViewPort);
+
+	virtual const char *GetName( void ) { return PANEL_BUY_EQUIP_CT; }
+
+	// Background panel -------------------------------------------------------
+
+public:
+	virtual void PaintBackground();
+	virtual void PerformLayout();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	bool m_backgroundLayoutFinished;
+
+	// End background panel ---------------------------------------------------
+};
+
+
+//============================
+// Terrorist Equipment menu
+//============================
+
+class CCSBuyEquipMenu_TER : public CBuyMenu
+{
+private:
+	typedef vgui::WizardPanel BaseClass;
+
+public:
+	CCSBuyEquipMenu_TER(IViewPort *pViewPort);
+
+	virtual const char *GetName( void ) { return PANEL_BUY_EQUIP_TER; }
+
+	// Background panel -------------------------------------------------------
+
+public:
+	virtual void PaintBackground();
+	virtual void PerformLayout();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	bool m_backgroundLayoutFinished;
+
+	// End background panel ---------------------------------------------------
+};
+
+#endif // CSTRIKEBUYEQUIPMENU_H
diff --git a/game/client/cstrike/VGUI/cstrikebuymenu.cpp b/game/client/cstrike/VGUI/cstrikebuymenu.cpp
new file mode 100644
index 00000000..e637c89e
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikebuymenu.cpp
@@ -0,0 +1,883 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cstrikebuysubmenu.h"
+#include "cstrikebuymenu.h"
+#include "cs_shareddefs.h"
+#include "backgroundpanel.h"
+#include "buy_presets/buy_presets.h"
+#include "cstrike/bot/shared_util.h"
+#include <vgui/ISurface.h>
+#include <vgui/ILocalize.h>
+#include "buypreset_weaponsetlabel.h"
+#include "career_box.h"
+#include "cs_gamerules.h"
+#include "vgui_controls/RichText.h"
+#include "cs_weapon_parse.h"
+#include "c_cs_player.h"
+#include "cs_ammodef.h"
+
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+/**
+ *  This button resizes any images to fit in the width/height constraints
+ */
+class BuyPresetButton : public vgui::Button
+{
+	typedef vgui::Button BaseClass;
+
+public:
+	BuyPresetButton(vgui::Panel *parent, const char *buttonName, const char *buttonText );
+	virtual ~BuyPresetButton();
+
+	virtual void PerformLayout( void );
+	virtual void ClearImages( void );
+
+	virtual void SetFgColor( Color c )
+	{
+		BaseClass::SetFgColor( c );
+	}
+
+	void SetAvailable( bool available )
+	{
+		m_available = available;
+	}
+
+	virtual int AddImage( vgui::IImage *image, int offset )
+	{
+		if ( image )
+		{
+			if ( !m_available )
+			{
+                image->SetColor( Color( 128, 128, 128, 255 ) );
+			}
+		}
+		return BaseClass::AddImage( image, offset );
+	}
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
+	{
+		BaseClass::ApplySchemeSettings( pScheme );
+		m_availableColor = pScheme->GetColor( "Label.TextColor", Color( 0, 0, 0, 0 ) );
+		m_unavailableColor = pScheme->GetColor( "Label.DisabledFgColor2", Color( 0, 0, 0, 0 ) );
+	}
+
+	virtual Color GetButtonFgColor( void )
+	{
+		return ( m_available ) ? m_availableColor : m_unavailableColor;
+	}
+
+private:
+
+	bool m_available;
+	Color m_availableColor;
+	Color m_unavailableColor;
+};
+
+//-----------------------------------------------------------------------------
+BuyPresetButton::BuyPresetButton(vgui::Panel *parent, const char *buttonName, const char *buttonText ) : Button( parent, buttonName, buttonText )
+{
+	m_available = false;
+}
+
+//-----------------------------------------------------------------------------
+BuyPresetButton::~BuyPresetButton()
+{
+	ClearImages();
+}
+
+//-----------------------------------------------------------------------------
+void BuyPresetButton::ClearImages( void )
+{
+	int imageCount = GetImageCount();
+	for ( int i=0; i<imageCount; ++i )
+	{
+		BuyPresetImage *image = dynamic_cast< BuyPresetImage * >(GetImageAtIndex( i ));
+		if ( image )
+		{
+			delete image;
+		}
+	}
+
+	Button::ClearImages();
+}
+
+//-----------------------------------------------------------------------------
+void BuyPresetButton::PerformLayout( void )
+{
+	// resize images
+	int imageCount = GetImageCount();
+	if ( imageCount > 1 )
+	{
+		int wide, tall;
+		GetSize( wide, tall );
+
+		for ( int i=1; i<imageCount; ++i )
+		{
+			IImage *image = GetImageAtIndex( i );
+			if ( image )
+			{
+				int imageWide, imageTall;
+				image->GetSize( imageWide, imageTall );
+
+				float scaleX = 1.0f, scaleY = 1.0f;
+				float widthPercent = 0.2f;
+				if ( i == 1 )
+				{
+					widthPercent = 0.6f;
+				}
+
+				if ( imageWide > wide * widthPercent )
+				{
+					scaleX = (float)wide * widthPercent / (float)imageWide;
+				}
+				if ( imageTall > tall )
+				{
+					scaleY = (float)tall / (float)imageTall;
+				}
+
+				float scale = MIN( scaleX, scaleY );
+				if ( scale < 1.0f )
+				{
+					imageWide *= scale;
+					imageTall *= scale;
+					image->SetSize( imageWide, imageTall );
+				}
+			}
+		}
+	}
+
+	Button::PerformLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSBuyMenu_CT::CCSBuyMenu_CT(IViewPort *pViewPort) : CCSBaseBuyMenu( pViewPort, "BuySubMenu_CT" )
+{
+	m_pMainMenu->LoadControlSettings( "Resource/UI/BuyMenu_CT.res" );
+	m_pMainMenu->SetVisible( false );
+
+	m_iTeam = TEAM_CT;
+
+	CreateBackground( this );
+	m_backgroundLayoutFinished = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSBuyMenu_TER::CCSBuyMenu_TER(IViewPort *pViewPort) : CCSBaseBuyMenu( pViewPort, "BuySubMenu_TER" )
+{
+	m_pMainMenu->LoadControlSettings( "Resource/UI/BuyMenu_TER.res" );
+	m_pMainMenu->SetVisible( false );
+
+	m_iTeam = TEAM_TERRORIST;
+
+	CreateBackground( this );
+	m_backgroundLayoutFinished = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSBaseBuyMenu::CCSBaseBuyMenu(IViewPort *pViewPort, const char *subPanelName) : CBuyMenu( pViewPort )
+{
+	SetTitle( "#Cstrike_Buy_Menu", true);
+
+	SetProportional( true );
+
+	m_pMainMenu = new CCSBuySubMenu( this, subPanelName );
+	m_pMainMenu->SetSize( 10, 10 ); // Quiet "parent not sized yet" spew
+#if USE_BUY_PRESETS
+	for ( int i=0; i<NUM_BUY_PRESET_BUTTONS; ++i )
+	{
+		m_pBuyPresetButtons[i] = new BuyPresetButton( m_pMainMenu, VarArgs( "BuyPresetButton%c", 'A' + i ), "" );
+	}
+ 	m_pMoney = new Label( m_pMainMenu, "money", "" );
+	//=============================================================================
+	// HPE_BEGIN:
+	// [pfreese] mainBackground was the little orange box outside that buy window
+	// that shouldn't have been there. Maybe this was left over from some
+	// copied code.
+	//=============================================================================
+	
+	m_pMainBackground = NULL;
+//	m_pMainBackground = new Panel( m_pMainMenu, "mainBackground" );
+	
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	m_pLoadout = new BuyPresetEditPanel( m_pMainMenu, "loadoutPanel", "Resource/UI/Loadout.res", 0, false );
+#else
+	for ( int i=0; i<NUM_BUY_PRESET_BUTTONS; ++i )
+	{
+		m_pBuyPresetButtons[i] = NULL;
+	}
+	m_pMoney = NULL;
+	m_pMainBackground = NULL;
+#endif // USE_BUY_PRESETS
+ 	m_lastMoney = -1;
+
+	m_pBlackMarket = new EditablePanel( m_pMainMenu, "BlackMarket_Bargains" );
+	m_pBlackMarket->LoadControlSettings( "Resource/UI/BlackMarket_Bargains.res" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBaseBuyMenu::SetVisible(bool state)
+{
+	BaseClass::SetVisible(state);
+
+	if ( state )
+	{
+		Panel *defaultButton = FindChildByName( "CancelButton" );
+		if ( defaultButton )
+		{
+			defaultButton->RequestFocus();
+		}
+		SetMouseInputEnabled( true );
+		m_pMainMenu->SetMouseInputEnabled( true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: shows/hides the buy menu
+//-----------------------------------------------------------------------------
+void CCSBaseBuyMenu::ShowPanel(bool bShow)
+{
+	CBuyMenu::ShowPanel( bShow );
+
+#if USE_BUY_PRESETS
+	if ( bShow )
+	{
+		UpdateBuyPresets( true );
+	}
+#endif // USE_BUY_PRESETS
+}
+
+//-----------------------------------------------------------------------------
+static void GetPanelBounds( Panel *pPanel, wrect_t& bounds )
+{
+	if ( !pPanel )
+	{
+		bounds.bottom = bounds.left = bounds.right = bounds.top = 0;
+	}
+	else
+	{
+		pPanel->GetBounds( bounds.left, bounds.top, bounds.right, bounds.bottom );
+		bounds.right += bounds.left;
+		bounds.bottom += bounds.top;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void CCSBaseBuyMenu::Paint()
+{
+#if USE_BUY_PRESETS
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	int account = (pPlayer) ? pPlayer->GetAccount() : 0;
+
+	if ( m_pMoney && m_lastMoney != account )
+	{
+		m_lastMoney = account;
+
+		const int BufLen = 128;
+		wchar_t wbuf[BufLen] = L"";
+		const wchar_t *formatStr = g_pVGuiLocalize->Find("#Cstrike_Current_Money");
+		if ( !formatStr )
+			formatStr = L"%s1";
+		g_pVGuiLocalize->ConstructString( wbuf, sizeof(wbuf), formatStr, 1, NumAsWString( m_lastMoney ) );
+		m_pMoney->SetText( wbuf );
+	}
+#endif // USE_BUY_PRESETS
+
+	CBuyMenu::Paint();
+}
+
+//-----------------------------------------------------------------------------
+void CCSBaseBuyMenu::UpdateBuyPresets( bool showDefaultPanel )
+{
+	bool setPanelVisible = false;
+	if ( !showDefaultPanel )
+	{
+		setPanelVisible = true;
+	}
+
+	if ( !TheBuyPresets )
+		TheBuyPresets = new BuyPresetManager();
+
+	int i;
+	// show buy preset buttons
+	int numPresets = MIN( TheBuyPresets->GetNumPresets(), NUM_BUY_PRESET_BUTTONS );
+	for ( i=0; i<numPresets; ++i )
+	{
+		if ( !m_pBuyPresetButtons[i] )
+			continue;
+
+		const BuyPreset *preset = TheBuyPresets->GetPreset(i);
+
+		int setIndex;
+		int currentCost = -1;
+		WeaponSet currentSet;
+		const WeaponSet *fullSet = NULL;
+		for ( setIndex = 0; setIndex < preset->GetNumSets(); ++setIndex )
+		{
+			const WeaponSet *itemSet = preset->GetSet( setIndex );
+			if ( itemSet )
+			{
+				itemSet->GetCurrent( currentCost, currentSet );
+				if ( currentCost >= 0 )
+				{
+					fullSet = itemSet;
+					break;
+				}
+			}
+		}
+
+		if ( !fullSet && preset->GetNumSets() )
+		{
+			fullSet = preset->GetSet( 0 );
+		}
+
+		// set the button's images
+		m_pBuyPresetButtons[i]->ClearImages();
+		m_pBuyPresetButtons[i]->SetTextImageIndex( 0 );
+		m_pBuyPresetButtons[i]->SetText( "" );
+
+		m_pBuyPresetButtons[i]->SetAvailable( currentCost >= 0 );
+
+		const char *imageName = "";
+		if ( fullSet )
+		{
+			if ( fullSet->GetPrimaryWeapon().GetWeaponID() != WEAPON_NONE )
+			{
+				imageName = ImageFnameFromWeaponID( fullSet->GetPrimaryWeapon().GetWeaponID(), true );
+				BuyPresetImage * image = new BuyPresetImage( scheme()->GetImage(imageName, true) );
+				m_pBuyPresetButtons[i]->AddImage( image, 0 );
+			}
+			if ( fullSet->GetSecondaryWeapon().GetWeaponID() != WEAPON_NONE )
+			{
+				imageName = ImageFnameFromWeaponID( fullSet->GetSecondaryWeapon().GetWeaponID(), false );
+				BuyPresetImage * image = new BuyPresetImage( scheme()->GetImage(imageName, true) );
+				m_pBuyPresetButtons[i]->AddImage( image, 0 );
+			}
+		}
+
+		int displayCost = currentCost;
+		if ( displayCost < 0 )
+			displayCost = 0;
+
+		const int BufLen = 1024;
+		char aBuf[BufLen];
+		Q_snprintf(aBuf, BufLen, "#Cstrike_BuyMenuPreset%d", i + 1);
+		m_pBuyPresetButtons[i]->SetText( g_pVGuiLocalize->Find(aBuf) );
+		Q_snprintf(aBuf, BufLen, "cl_buy_favorite %d", i + 1);
+		m_pBuyPresetButtons[i]->SetCommand( aBuf );
+		m_pBuyPresetButtons[i]->SetVisible( true );
+		m_pBuyPresetButtons[i]->SetEnabled( true );
+	}
+
+	// hide unused buy preset buttons
+	for ( i=numPresets+1; i<NUM_BUY_PRESET_BUTTONS; ++i )
+	{
+		if ( m_pBuyPresetButtons[i] )
+		{
+			m_pBuyPresetButtons[i]->SetVisible( false );
+			m_pBuyPresetButtons[i]->SetEnabled( true );
+		}
+	}
+
+	HandleBlackMarket();
+}
+
+const char *g_pWeaponNames[] =
+{
+	" ",
+	"#Cstrike_TitlesTXT_P228",
+	"#Cstrike_TitlesTXT_Glock18",
+	"#Cstrike_TitlesTXT_Scout",
+	"#Cstrike_TitlesTXT_HE_Grenade",
+	"#Cstrike_TitlesTXT_XM1014",
+	" ",
+	"#Cstrike_TitlesTXT_Mac10",
+	"#Cstrike_TitlesTXT_Aug",
+	"#Cstrike_TitlesTXT_Smoke_Grenade",
+	"#Cstrike_TitlesTXT_Dual40",
+	"#Cstrike_TitlesTXT_FiveSeven",
+	"#Cstrike_TitlesTXT_UMP45",
+	"#Cstrike_TitlesTXT_SG550",
+	"#Cstrike_TitlesTXT_Galil",
+	"#Cstrike_TitlesTXT_Famas",
+	"#Cstrike_TitlesTXT_USP45",
+	"#Cstrike_TitlesTXT_Magnum",
+	"#Cstrike_TitlesTXT_mp5navy",
+	"#Cstrike_TitlesTXT_ESM249",
+	"#Cstrike_TitlesTXT_Leone12",
+	"#Cstrike_TitlesTXT_M4A1",
+	"#Cstrike_TitlesTXT_tmp",
+	"#Cstrike_TitlesTXT_G3SG1",
+	"#Cstrike_TitlesTXT_Flashbang",
+	"#Cstrike_TitlesTXT_DesertEagle",
+	"#Cstrike_TitlesTXT_SG552",
+	"#Cstrike_TitlesTXT_AK47",
+	" ",
+	"#Cstrike_TitlesTXT_FNP90",
+	" ",
+	"#Cstrike_TitlesTXT_Kevlar_Vest",
+	"#Cstrike_TitlesTXT_Kevlar_Vest_Ballistic_Helmet",
+	"#Cstrike_TitlesTXT_Nightvision_Goggles"
+};
+
+int GetWeeklyBargain( void )
+{
+	if ( CSGameRules() == NULL || CSGameRules()->m_pPrices == NULL )
+		return 0;
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( pPlayer == NULL )
+		return 0;
+
+	int iBestIndex = 0;
+	int iBestBargain = 99999;
+
+	for ( int i = 1; i < WEAPON_MAX; i++ )
+	{
+		if ( i == WEAPON_SHIELDGUN )
+			continue;
+
+		CCSWeaponInfo *info = GetWeaponInfo( (CSWeaponID)i );
+
+		if ( info == NULL )
+			continue;
+
+		if ( info->m_iTeam == TEAM_UNASSIGNED || info->m_iTeam == pPlayer->m_iTeamNum )
+		{		
+			int iBargain = info->GetWeaponPrice() - info->GetPrevousPrice();
+
+			if ( iBargain < iBestBargain )
+			{
+				iBestIndex = i;
+				iBestBargain = iBargain;
+			}
+		}
+	}
+
+	return iBestIndex;
+}
+
+#ifdef _DEBUG
+ConVar cs_testbargain( "cs_testbargain", "1" );
+#endif
+
+void CCSBaseBuyMenu::HandleBlackMarket( void )
+{	
+	if ( CSGameRules() == NULL )
+		return;
+
+	if ( m_pLoadout )
+	{
+		if ( CSGameRules()->IsBlackMarket() )
+		{
+			if ( CSGameRules()->m_pPrices == NULL )
+				return;
+
+			if ( m_pBlackMarket == NULL )
+				return;
+
+			int iBargain = GetWeeklyBargain();
+			CCSWeaponInfo *info = GetWeaponInfo( (CSWeaponID)iBargain );
+
+			wchar_t *wszWeaponName = g_pVGuiLocalize->Find( g_pWeaponNames[iBargain]);
+
+			if ( wszWeaponName == NULL )
+				return;
+
+			if ( info == NULL )
+				return;
+
+			m_pLoadout->SetVisible( false );
+			Label *pLabel = dynamic_cast< Label * >(m_pMainMenu->FindChildByName( "loadoutLabel" ));
+
+			if ( pLabel )
+			{
+				pLabel->SetVisible( false );
+			}
+
+			pLabel = dynamic_cast< Label * >(m_pBlackMarket->FindChildByName( "MarketHeadline" ));
+
+			if ( pLabel )
+			{
+				const int BufLen = 2048;
+				
+				wchar_t wbuf[BufLen] = L"";
+				const wchar_t *formatStr = g_pVGuiLocalize->Find("#Cstrike_MarketHeadline");
+	
+				if ( !formatStr )
+					formatStr = L"%s1";
+
+				g_pVGuiLocalize->ConstructString( wbuf, sizeof(wbuf), formatStr, 1, wszWeaponName );
+				pLabel->SetText( wbuf );
+			}
+
+			pLabel = dynamic_cast< Label * >(m_pBlackMarket->FindChildByName( "MarketBargain" ));
+
+			if ( pLabel )
+			{
+				const int BufLen = 2048;
+				wchar_t wbuf[BufLen] = L"";
+				const wchar_t *formatStr = g_pVGuiLocalize->Find("#Cstrike_MarketBargain");
+				
+				if ( !formatStr )
+					formatStr = L"%s1";
+
+				g_pVGuiLocalize->ConstructString( wbuf, sizeof(wbuf), formatStr, 1, wszWeaponName );
+				pLabel->SetText( wbuf );
+			}
+
+			pLabel = dynamic_cast< Label * >(m_pBlackMarket->FindChildByName( "MarketStickerPrice" ));
+
+			if ( pLabel )
+			{
+				char wbuf[16];
+
+				Q_snprintf( wbuf, 16, "%d", CSGameRules()->m_pPrices->iCurrentPrice[iBargain] );
+
+				pLabel->SetText( wbuf );
+			}
+
+			RichText *pText = dynamic_cast< RichText * >(m_pBlackMarket->FindChildByName( "MarketDescription" ));
+
+			if ( pText )
+			{
+				char wbuf[2048];
+				g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find("#Cstrike_MarketDescription"), wbuf, 2048 );
+
+				pText->SetText( "" );
+				pText->InsertPossibleURLString( wbuf, Color( 255, 255, 255, 255 ), Color( 255, 176, 0, 255 ) );
+				pText->SetVerticalScrollbar( false );
+				pText->SetPaintBorderEnabled( false );
+				pText->SetUnderlineFont( m_hUnderlineFont );
+			}
+
+			pLabel = dynamic_cast< Label * >(m_pBlackMarket->FindChildByName( "MarketBargainIcon" ));
+			
+			if ( pLabel )
+			{
+				char wbuff[12];
+				Q_snprintf( wbuff, 12, "%c", info->iconActive->cCharacterInFont );
+				
+				pLabel->SetText( wbuff );
+			}
+
+			Button *pButton = dynamic_cast< Button * >(m_pMainMenu->FindChildByName( "BargainbuyButton" ));
+
+			if ( pButton )
+			{
+				char command[512];
+				char *pWeaponName = Q_stristr( info->szClassName, "_" );
+
+				if ( pWeaponName )
+				{
+					pWeaponName++;
+
+					Q_snprintf( command, 512, "buy %s", pWeaponName );
+				}
+
+				pButton->SetCommand( command );
+				pButton->SetVisible( true );
+			}
+
+
+			m_pBlackMarket->SetVisible( true );
+			m_pBlackMarket->SetZPos( -2 );
+		}
+		else
+		{
+			WeaponSet ws;
+
+			TheBuyPresets->GetCurrentLoadout( &ws );
+			m_pLoadout->SetWeaponSet( &ws, true );
+
+			m_pLoadout->SetVisible( true );
+			Panel *pLabel = dynamic_cast< Label * >(m_pMainMenu->FindChildByName( "loadoutLabel" ));
+
+			if ( pLabel )
+			{
+				pLabel->SetVisible( true );
+			}
+
+			if ( m_pBlackMarket )
+			{
+				m_pBlackMarket->SetVisible( false );
+
+				Button *pButton = dynamic_cast< Button * >(m_pMainMenu->FindChildByName( "BargainbuyButton" ));
+
+				if ( pButton )
+				{
+					pButton->SetVisible( false );
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The CS background is painted by image panels, so we should do nothing
+//-----------------------------------------------------------------------------
+void CCSBaseBuyMenu::PaintBackground()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Scale / center the window
+//-----------------------------------------------------------------------------
+void CCSBaseBuyMenu::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// stretch the window to fullscreen
+	if ( !m_backgroundLayoutFinished )
+		LayoutBackgroundPanel( this );
+	m_backgroundLayoutFinished = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBaseBuyMenu::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	ApplyBackgroundSchemeSettings( this, pScheme );
+
+	if ( m_pMainBackground )
+	{
+		m_pMainBackground->SetBorder(pScheme->GetBorder("ButtonDepressedBorder"));
+		m_pMainBackground->SetBgColor( GetSchemeColor( "Button.BgColor", GetBgColor(), pScheme ) );
+	}
+
+	m_hUnderlineFont = pScheme->GetFont( "CSUnderline", IsProportional() );
+
+#if USE_BUY_PRESETS
+	UpdateBuyPresets( true );
+#endif // USE_BUY_PRESETS
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+static bool IsWeaponInvalid( CSWeaponID weaponID )
+{
+	if ( weaponID == WEAPON_NONE )
+		return false;
+
+	return !CanBuyWeapon( WEAPON_NONE, WEAPON_NONE, weaponID );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBuySubMenu::OnThink()
+{
+	UpdateVestHelmPrice();
+	BaseClass::OnThink();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: When buying vest+helmet, if you already have a vest with no damage
+// then the price is reduced to just the helmet.  Because this can change during
+// the game, we need to update the enable/disable state of the menu item dynamically.
+//-----------------------------------------------------------------------------
+void CCSBuySubMenu::UpdateVestHelmPrice()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer == NULL )
+		return;
+
+	BuyMouseOverPanelButton *pButton = dynamic_cast< BuyMouseOverPanelButton * > ( FindChildByName( "kevlar_helmet", false ) );
+	if ( pButton )
+	{
+		// Set its price to the current value from the player.
+		pButton->SetCurrentPrice( pPlayer->GetCurrentAssaultSuitPrice() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBuySubMenu::OnCommand( const char *command )
+{
+#if USE_BUY_PRESETS
+	const char *buyPresetSetString = "cl_buy_favorite_query_set ";
+	if ( !strnicmp( command, buyPresetSetString, strlen( buyPresetSetString ) ) )
+	{
+		bool invalid = IsWeaponInvalid( GetClientWeaponID( true ) ) || IsWeaponInvalid( GetClientWeaponID( false ) );
+		if ( invalid )
+		{
+			// can't save the favorite because it has an invalid weapon (colt for a T, etc)
+			C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+			if ( pPlayer )
+			{
+				pPlayer->EmitSound( "BuyPreset.CantBuy" );
+			}
+
+			if ( cl_buy_favorite_nowarn.GetBool() )
+			{
+				BaseClass::OnCommand( "vguicancel" );
+			}
+			else
+			{
+				CCareerQueryBox *pBox = new CCareerQueryBox( this, "SetLoadoutError", "Resource/UI/SetLoadoutError.res" );
+				pBox->AddActionSignalTarget( this );
+				pBox->DoModal();
+			}
+		}
+		else
+		{
+			// can save
+			if ( cl_buy_favorite_quiet.GetBool() )
+			{
+				BaseClass::OnCommand( VarArgs( "cl_buy_favorite_set %d", atoi( command + strlen( buyPresetSetString ) ) ) );
+			}
+			else
+			{
+				CCareerQueryBox *pBox = new CCareerQueryBox( this, "SetLoadoutQuery", "Resource/UI/SetLoadoutQuery.res" );
+				pBox->SetCancelButtonAsDefault();
+				if ( pBox->GetOkButton() )
+				{
+					pBox->GetOkButton()->SetCommand( VarArgs( "cl_buy_favorite_set %d", atoi( command + strlen( buyPresetSetString ) ) ) );
+				}
+				pBox->AddActionSignalTarget( this );
+				pBox->DoModal();
+			}
+		}
+		return;
+	}
+#endif // USE_BUY_PRESETS
+
+	if ( FStrEq( command, "buy_unavailable" ) )
+	{
+		C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+		if ( pPlayer )
+		{
+			pPlayer->EmitSound( "BuyPreset.CantBuy" );
+		}
+		BaseClass::OnCommand( "vguicancel" );
+		return;
+	}
+
+	BaseClass::OnCommand( command );
+}
+
+void CCSBuySubMenu::OnSizeChanged(int newWide, int newTall)
+{
+	m_backgroundLayoutFinished = false;
+	BaseClass::OnSizeChanged( newWide, newTall );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBuySubMenu::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// Buy submenus need to be shoved over for widescreen
+	int screenW, screenH;
+	GetHudSize( screenW, screenH );
+
+	int fullW, fullH;
+	fullW = scheme()->GetProportionalScaledValueEx( GetScheme(), 640 );
+	fullH = scheme()->GetProportionalScaledValueEx( GetScheme(), 480 );
+
+	fullW = GetAlternateProportionalValueFromScaled( GetScheme(), fullW );
+	fullH = GetAlternateProportionalValueFromScaled( GetScheme(), fullH );
+
+	int offsetX = (screenW - fullW)/2;
+	int offsetY = (screenH - fullH)/2;
+
+	if ( !m_backgroundLayoutFinished )
+		ResizeWindowControls( this, GetWide(), GetTall(), offsetX, offsetY );
+	m_backgroundLayoutFinished = true;
+
+	HandleBlackMarket();
+}
+
+void CCSBuySubMenu::HandleBlackMarket( void )
+{
+	if ( CSGameRules() == NULL )
+		return;
+
+	int iBestBargain = 99999;
+	BuyMouseOverPanelButton *pButtonBargain = NULL;
+
+	for (int i = 0; i < GetChildCount(); i++)
+	{
+		BuyMouseOverPanelButton *pButton = dynamic_cast< BuyMouseOverPanelButton * > ( GetChild(i) );
+		if (!pButton)
+			continue;
+		
+		pButton->SetBargainButton( false );
+
+		const char *pWeaponName = Q_stristr( pButton->GetBuyCommand(), " " );
+
+		if ( pWeaponName )
+		{
+			pWeaponName++;
+
+			int iWeaponID = AliasToWeaponID(GetTranslatedWeaponAlias(pWeaponName));
+
+			if ( iWeaponID == 0 )
+				continue;
+
+			CCSWeaponInfo *info = GetWeaponInfo( (CSWeaponID)iWeaponID );
+
+			if ( info == NULL )
+				continue;
+
+			if ( CSGameRules()->IsBlackMarket() == false )
+			{
+                //=============================================================================
+                // HPE_BEGIN:
+                // [dwenger] Removed to avoid clearing of default price when not in black market mode
+                //=============================================================================
+
+                // pButton->SetCurrentPrice( info->GetDefaultPrice() );
+
+                //=============================================================================
+                // HPE_END
+                //=============================================================================
+			}
+			else
+			{
+				int iBargain = info->GetWeaponPrice() - info->GetPrevousPrice();
+
+				pButton->SetCurrentPrice( info->GetWeaponPrice() );
+				pButton->SetPreviousPrice( info->GetPrevousPrice() );
+
+				if ( iBargain < iBestBargain )
+				{
+					iBestBargain = iBargain;
+					pButtonBargain = pButton;
+				}
+			}
+		}
+	}
+
+	if ( pButtonBargain )
+	{
+		pButtonBargain->SetBargainButton( true );
+	}
+}
+
+
+
diff --git a/game/client/cstrike/VGUI/cstrikebuymenu.h b/game/client/cstrike/VGUI/cstrikebuymenu.h
new file mode 100644
index 00000000..a97e07b8
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikebuymenu.h
@@ -0,0 +1,102 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSTRIKEBUYMENU_H
+#define CSTRIKEBUYMENU_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/WizardPanel.h>
+
+#include <buymenu.h>
+
+class BuyPresetEditPanel;
+class BuyPresetButton;
+
+namespace vgui
+{
+	class Panel;
+	class Button;
+	class Label;
+}
+
+enum
+{
+	NUM_BUY_PRESET_BUTTONS = 4,
+};
+
+//============================
+// Base CS buy Menu
+//============================
+class CCSBaseBuyMenu : public CBuyMenu
+{
+private:
+	typedef vgui::WizardPanel BaseClass;
+
+public:
+	CCSBaseBuyMenu(IViewPort *pViewPort, const char *subPanelName);
+
+	virtual void ShowPanel( bool bShow );
+	virtual void Paint( void );
+	virtual void SetVisible( bool state );
+
+	void HandleBlackMarket( void );
+
+private:
+	void UpdateBuyPresets( bool showDefaultPanel = false );	///< Update the Buy Preset buttons and their info panels on the main buy menu
+	vgui::Panel *m_pMainBackground;
+	BuyPresetButton *m_pBuyPresetButtons[NUM_BUY_PRESET_BUTTONS];
+	BuyPresetEditPanel *m_pLoadout;
+	vgui::Label *m_pMoney;
+	int m_lastMoney;
+
+	vgui::EditablePanel *m_pBlackMarket;
+	HFont m_hUnderlineFont;
+
+	// Background panel -------------------------------------------------------
+
+public:
+	virtual void PaintBackground();
+	virtual void PerformLayout();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+	bool m_backgroundLayoutFinished;
+
+	// End background panel ---------------------------------------------------
+};
+
+//============================
+// CT main buy Menu
+//============================
+class CCSBuyMenu_CT : public CCSBaseBuyMenu
+{
+private:
+	typedef vgui::WizardPanel BaseClass;
+
+public:
+	CCSBuyMenu_CT(IViewPort *pViewPort);
+
+	virtual const char *GetName( void ) { return PANEL_BUY_CT; }
+};
+
+
+//============================
+// Terrorist main buy Menu
+//============================
+class CCSBuyMenu_TER : public CCSBaseBuyMenu
+{
+private:
+	typedef vgui::WizardPanel BaseClass;
+
+public:
+	CCSBuyMenu_TER(IViewPort *pViewPort);
+	
+	virtual const char *GetName( void ) { return PANEL_BUY_TER; }
+};
+
+#endif // CSTRIKEBUYMENU_H
diff --git a/game/client/cstrike/VGUI/cstrikebuysubmenu.h b/game/client/cstrike/VGUI/cstrikebuysubmenu.h
new file mode 100644
index 00000000..ccd0edd2
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikebuysubmenu.h
@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSBUYSUBMENU_H
+#define CSBUYSUBMENU_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <buysubmenu.h>
+#include <buymouseoverpanelbutton.h>
+
+using namespace vgui;
+
+class CCSBuySubMenu : public CBuySubMenu
+{
+private:
+	DECLARE_CLASS_SIMPLE(CCSBuySubMenu, CBuySubMenu); 
+
+public:
+	CCSBuySubMenu (vgui::Panel *parent,const char *name = "BuySubMenu") : CBuySubMenu( parent, name )
+	{
+		m_backgroundLayoutFinished = false;
+	}; 
+	
+protected:
+
+	virtual void OnThink();
+	void UpdateVestHelmPrice();
+
+	virtual void OnCommand( const char *command );
+
+	MouseOverPanelButton* CreateNewMouseOverPanelButton(EditablePanel * panel)
+	{ 
+		return new BuyMouseOverPanelButton(this, NULL, panel);
+	}
+
+	CBuySubMenu* CreateNewSubMenu() { return new CCSBuySubMenu( this, "BuySubMenu" ); }
+
+	// Background panel -------------------------------------------------------
+
+	virtual void PerformLayout();
+	virtual void OnSizeChanged(int newWide, int newTall);	// called after the size of a panel has been changed
+	
+	void HandleBlackMarket( void );
+
+	bool m_backgroundLayoutFinished;
+
+	// End background panel ---------------------------------------------------
+};
+
+#endif //CSBUYSUBMENU_H
diff --git a/game/client/cstrike/VGUI/cstrikeclassmenu.cpp b/game/client/cstrike/VGUI/cstrikeclassmenu.cpp
new file mode 100644
index 00000000..374f7ced
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikeclassmenu.cpp
@@ -0,0 +1,272 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cstrikeclassmenu.h"
+
+#include <KeyValues.h>
+#include <filesystem.h>
+#include <vgui_controls/Button.h>
+#include <vgui/IVGui.h>
+
+#include "hud.h" // for gEngfuncs
+#include "cs_gamerules.h"
+
+using namespace vgui;
+
+
+// ----------------------------------------------------------------------------- //
+// Class image panels. These maintain a list of the class image panels so 
+// it can render 3D images into them.
+// ----------------------------------------------------------------------------- //
+
+CUtlVector<CCSClassImagePanel*> g_ClassImagePanels;
+
+
+CCSClassImagePanel::CCSClassImagePanel( vgui::Panel *pParent, const char *pName )
+	: vgui::ImagePanel( pParent, pName )
+{
+	g_ClassImagePanels.AddToTail( this );
+	m_ModelName[0] = 0;
+}
+
+CCSClassImagePanel::~CCSClassImagePanel()
+{
+	g_ClassImagePanels.FindAndRemove( this );
+}
+
+void CCSClassImagePanel::ApplySettings( KeyValues *inResourceData )
+{
+	const char *pName = inResourceData->GetString( "3DModel" );
+	if ( pName )
+	{
+		Q_strncpy( m_ModelName, pName, sizeof( m_ModelName ) );
+	}
+	
+	BaseClass::ApplySettings( inResourceData );
+}
+
+
+void CCSClassImagePanel::Paint()
+{
+	BaseClass::Paint();
+}
+
+
+// ----------------------------------------------------------------------------- //
+// CClassMenu_TER
+// ----------------------------------------------------------------------------- //
+
+CClassMenu_TER::CClassMenu_TER(IViewPort *pViewPort) : CClassMenu(pViewPort, PANEL_CLASS_TER)
+{
+	LoadControlSettings( "Resource/UI/ClassMenu_TER.res" );
+	CreateBackground( this );
+	m_backgroundLayoutFinished = false;
+}
+
+const char *CClassMenu_TER::GetName( void ) 
+{ 
+	return PANEL_CLASS_TER; 
+}
+
+void CClassMenu_TER::ShowPanel(bool bShow)
+{
+	if ( bShow)
+	{
+		engine->CheckPoint( "ClassMenu" );
+	}
+
+	BaseClass::ShowPanel( bShow );
+
+}
+
+void CClassMenu_TER::SetVisible(bool state)
+{
+	BaseClass::SetVisible(state);
+
+	if ( state )
+	{
+		Panel *pAutoButton = FindChildByName( "autoselect_t" );
+		if ( pAutoButton )
+		{
+			pAutoButton->RequestFocus();
+		}
+	}
+}
+
+bool modelExists( const char *search, const CUtlVector< const char * > &names )
+{
+	for ( int i=0; i<names.Count(); ++i )
+	{
+		if ( Q_stristr( names[i], search ) != NULL )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void CClassMenu_TER::Update()
+{
+	C_CSPlayer *pLocalPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( pLocalPlayer && pLocalPlayer->PlayerClass() >= FIRST_T_CLASS && pLocalPlayer->PlayerClass() <= LAST_T_CLASS )
+	{
+		SetVisibleButton( "CancelButton", true );
+	}
+	else
+	{
+		SetVisibleButton( "CancelButton", false ); 
+	}
+
+	// if we don't have the new models installed,
+	// turn off the militia and spetsnaz buttons
+	SetVisibleButton( "militia", false );
+}
+
+
+Panel *CClassMenu_TER::CreateControlByName(const char *controlName)
+{
+	if ( Q_stricmp( controlName, "CSClassImagePanel" ) == 0 )
+	{
+		return new CCSClassImagePanel( NULL, controlName );
+	}
+
+	return BaseClass::CreateControlByName( controlName );
+}
+
+
+
+// ----------------------------------------------------------------------------- //
+// CClassMenu_CT
+// ----------------------------------------------------------------------------- //
+
+CClassMenu_CT::CClassMenu_CT(IViewPort *pViewPort) : CClassMenu(pViewPort, PANEL_CLASS_CT)
+{
+	LoadControlSettings( "Resource/UI/ClassMenu_CT.res" );
+	CreateBackground( this );
+	m_backgroundLayoutFinished = false;
+}
+
+Panel *CClassMenu_CT::CreateControlByName(const char *controlName)
+{
+	if ( Q_stricmp( controlName, "CSClassImagePanel" ) == 0 )
+	{
+		return new CCSClassImagePanel( NULL, controlName );
+	}
+
+	return BaseClass::CreateControlByName( controlName );
+}
+
+const char *CClassMenu_CT::GetName( void ) 
+{ 
+	return PANEL_CLASS_CT; 
+}
+
+void CClassMenu_CT::ShowPanel(bool bShow)
+{
+	if ( bShow)
+	{
+		engine->CheckPoint( "ClassMenu" );
+	}
+
+	BaseClass::ShowPanel( bShow );
+
+}
+
+void CClassMenu_CT::SetVisible(bool state)
+{
+	BaseClass::SetVisible(state);
+
+	if ( state )
+	{
+		Panel *pAutoButton = FindChildByName( "autoselect_ct" );
+		if ( pAutoButton )
+		{
+			pAutoButton->RequestFocus();
+		}
+	}
+}
+
+void CClassMenu_CT::Update()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( pPlayer && pPlayer->PlayerClass() >= FIRST_CT_CLASS && pPlayer->PlayerClass() <= LAST_CT_CLASS )
+	{
+		SetVisibleButton( "CancelButton", true );
+	}
+	else
+	{
+		SetVisibleButton( "CancelButton", false ); 
+	}
+
+	// if we don't have the new models installed,
+	// turn off the militia and spetsnaz buttons
+	SetVisibleButton( "spetsnaz", false );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The CS background is painted by image panels, so we should do nothing
+//-----------------------------------------------------------------------------
+void CClassMenu_TER::PaintBackground()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Scale / center the window
+//-----------------------------------------------------------------------------
+void CClassMenu_TER::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// stretch the window to fullscreen
+	if ( !m_backgroundLayoutFinished )
+		LayoutBackgroundPanel( this );
+	m_backgroundLayoutFinished = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CClassMenu_TER::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	ApplyBackgroundSchemeSettings( this, pScheme );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The CS background is painted by image panels, so we should do nothing
+//-----------------------------------------------------------------------------
+void CClassMenu_CT::PaintBackground()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Scale / center the window
+//-----------------------------------------------------------------------------
+void CClassMenu_CT::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// stretch the window to fullscreen
+	if ( !m_backgroundLayoutFinished )
+		LayoutBackgroundPanel( this );
+	m_backgroundLayoutFinished = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CClassMenu_CT::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	ApplyBackgroundSchemeSettings( this, pScheme );
+}
+
diff --git a/game/client/cstrike/VGUI/cstrikeclassmenu.h b/game/client/cstrike/VGUI/cstrikeclassmenu.h
new file mode 100644
index 00000000..96a991f2
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikeclassmenu.h
@@ -0,0 +1,107 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSCLASSMENU_H
+#define CSCLASSMENU_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <classmenu.h>
+#include <vgui_controls/EditablePanel.h>
+#include <filesystem.h>
+#include <cs_shareddefs.h>
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "vgui_controls/ImagePanel.h"
+#include "backgroundpanel.h"
+
+using namespace vgui;
+
+
+//-----------------------------------------------------------------------------
+// These are maintained in a list so the renderer can draw a 3D character
+// model on top of them.
+//-----------------------------------------------------------------------------
+
+class CCSClassImagePanel : public vgui::ImagePanel
+{
+public:
+
+	typedef vgui::ImagePanel BaseClass;
+
+	CCSClassImagePanel( vgui::Panel *pParent, const char *pName );
+	virtual ~CCSClassImagePanel();
+	virtual void ApplySettings( KeyValues *inResourceData );
+	virtual void Paint();
+
+
+public:
+	char m_ModelName[128];
+};
+
+extern CUtlVector<CCSClassImagePanel*> g_ClassImagePanels;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the Terrorist class menu
+//-----------------------------------------------------------------------------
+
+class CClassMenu_TER : public CClassMenu
+{
+private:
+	DECLARE_CLASS_SIMPLE( CClassMenu_TER, CClassMenu );
+
+	// Background panel -------------------------------------------------------
+
+public:
+	virtual void PaintBackground();
+	virtual void PerformLayout();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	bool m_backgroundLayoutFinished;
+
+	// End background panel ---------------------------------------------------
+	
+public:
+	CClassMenu_TER(IViewPort *pViewPort);
+	virtual Panel* CreateControlByName(const char *controlName);
+	const char *GetName( void );
+	void ShowPanel(bool bShow);
+	void Update();
+	virtual void SetVisible(bool state);
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the Counter-Terrorist class menu
+//-----------------------------------------------------------------------------
+
+class CClassMenu_CT : public CClassMenu
+{
+private:
+	DECLARE_CLASS_SIMPLE( CClassMenu_CT, CClassMenu );
+
+	// Background panel -------------------------------------------------------
+
+public:
+	virtual void PaintBackground();
+	virtual void PerformLayout();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	bool m_backgroundLayoutFinished;
+
+	// End background panel ---------------------------------------------------
+	
+public:
+	CClassMenu_CT(IViewPort *pViewPort);
+	virtual Panel *CreateControlByName(const char *controlName);
+	const char *GetName( void );
+	void ShowPanel(bool bShow);
+	void Update();
+	virtual void SetVisible(bool state);
+};
+
+#endif // CSCLASSMENU_H
diff --git a/game/client/cstrike/VGUI/cstrikeclientscoreboard.cpp b/game/client/cstrike/VGUI/cstrikeclientscoreboard.cpp
new file mode 100644
index 00000000..eb2a6527
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikeclientscoreboard.cpp
@@ -0,0 +1,1596 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "cstrikeclientscoreboard.h"
+#include "c_team.h"
+#include "c_cs_playerresource.h"
+#include "c_cs_player.h"
+#include "cs_gamerules.h"
+#include "backgroundpanel.h"
+#include "clientmode.h"
+
+#include <KeyValues.h>
+
+#include <vgui/IScheme.h>
+#include <vgui/ILocalize.h>
+#include <vgui/ISurface.h>
+#include <vgui/IVGui.h>
+#include <vgui_controls/SectionedListPanel.h>
+#include <vgui_controls/ScalableImagePanel.h>
+#include "VGuiMatSurface/IMatSystemSurface.h"
+
+#include "voice_status.h"
+#include "vgui_avatarimage.h"
+
+#include "achievementmgr.h"
+#include "engine/imatchmaking.h"
+
+using namespace vgui;
+
+const int kInvalidImageID = -1;
+const int kMaxMVPCount = 9999;
+const float kScaleMVP = 0.75f;					// scale of the MVP star relative to the player name height
+const float kUpdateInterval = 1.0f;				// how often the scoreboard refreshes
+const float kTeamScoreMargin = 0.15f;			// margin as a ratio of avatar height
+const float kTeamScoreLineLeadingRatio = 0.25f;	// padding as a ratio of avatar height
+
+// CT player data colors
+ConVar cl_scoreboard_ct_color_red( "cl_scoreboard_ct_color_red", "150", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard CT player data red channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_ct_color_green( "cl_scoreboard_ct_color_green", "200", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard CT player data green channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_ct_color_blue( "cl_scoreboard_ct_color_blue", "255", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard CT player data blue channel", true, 0.0f, true, 255.0f );
+
+// T player data colors
+ConVar cl_scoreboard_t_color_red( "cl_scoreboard_t_color_red", "240", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard T player data red channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_t_color_green( "cl_scoreboard_t_color_green", "90", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard T player data green channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_t_color_blue( "cl_scoreboard_t_color_blue", "90", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard T player data blue channel", true, 0.0f, true, 255.0f );
+
+// Dead player data colors
+ConVar cl_scoreboard_dead_color_red( "cl_scoreboard_dead_color_red", "125", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard dead player data red channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_dead_color_green( "cl_scoreboard_dead_color_green", "125", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard dead player data green channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_dead_color_blue( "cl_scoreboard_dead_color_blue", "125", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard dead player data blue channel", true, 0.0f, true, 255.0f );
+
+// Clan colors
+ConVar cl_scoreboard_clan_ct_color_red( "cl_scoreboard_clan_ct_color_red", "150", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard CT player clan tag red channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_clan_ct_color_green( "cl_scoreboard_clan_ct_color_green", "200", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard CT player clan tag green channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_clan_ct_color_blue( "cl_scoreboard_clan_ct_color_blue", "255", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard CT player clan tag blue channel", true, 0.0f, true, 255.0f );
+
+ConVar cl_scoreboard_clan_t_color_red( "cl_scoreboard_clan_t_color_red", "240", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard T player clan tag red channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_clan_t_color_green( "cl_scoreboard_clan_t_color_green", "90", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard T player clan tag green channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_clan_t_color_blue( "cl_scoreboard_clan_t_color_blue", "90", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard T player clan tag blue channel", true, 0.0f, true, 255.0f );
+
+ConVar cl_scoreboard_dead_clan_color_red( "cl_scoreboard_dead_clan_color_red", "125", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard dead player clan tag red channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_dead_clan_color_green( "cl_scoreboard_dead_clan_color_green", "125", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard dead player clan tag green channel", true, 0.0f, true, 255.0f );
+ConVar cl_scoreboard_dead_clan_color_blue( "cl_scoreboard_dead_clan_color_blue", "125", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Scoreboard dead player clan tag blue channel", true, 0.0f, true, 255.0f );
+
+
+// [tj] These ConVars are defined at various places in the global scope. Just declaring them here so we can use them
+extern ConVar mp_winlimit;
+extern ConVar mp_maxrounds;
+extern ConVar mp_timelimit;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSClientScoreBoardDialog::CCSClientScoreBoardDialog( IViewPort *pViewPort ) : CClientScoreBoardDialog( pViewPort ),
+	m_DeadPlayerDataColor( 125, 125, 125, 125 ),
+	m_PlayerDataBgColor( 0, 0, 0, 0 ),
+	m_DeadPlayerClanColor( 125, 125, 125, 125 )
+{
+	m_teamDisplayT.playerDataColor = Color( 240, 90, 90, 255 );
+	m_teamDisplayT.playerClanColor = Color( 240, 90, 90, 255 );
+
+	m_teamDisplayCT.playerDataColor = Color( 150, 200, 255, 255 );
+	m_teamDisplayCT.playerClanColor = Color( 150, 200, 255, 255 );
+
+    m_iImageDead = kInvalidImageID;
+    m_iImageDominated = kInvalidImageID;
+    m_iImageNemesis = kInvalidImageID;
+    m_iImageBomb = kInvalidImageID;
+    m_iImageVIP = kInvalidImageID;
+    m_iImageFriend = kInvalidImageID;
+    m_iImageNemesisDead = kInvalidImageID;
+    m_iImageDominationDead = kInvalidImageID;
+
+	m_pWinConditionLabel = new Label( this, "WinConditionLabel", "" );
+	m_pClockLabel = new Label( this, "Icon_Clock", "" );
+
+    m_pLabelMapName = new Label( this, "MapName", "" );
+	m_pServerLabel = new Label( this, "ServerNameLabel", "" );
+
+    ListenForGameEvent( "server_spawn" );
+    ListenForGameEvent( "game_newmap" );
+    ListenForGameEvent( "match_end_conditions" );
+    ListenForGameEvent( "cs_win_panel_match" );
+
+    SetDialogVariable( "server", "" );
+    SetVisible( false );
+    SetProportional(true);
+    SetPaintBorderEnabled(false);
+    SetScheme( "ClientScheme" );
+
+	// [pfreese] Make the scoreboard a popup so it renders over the chat interface (which is also a popup). Hacky.
+	MakePopup();
+	
+    m_listItemFont = NULL;
+
+    m_LocalPlayerItemID = -1;
+    m_iImageMVP = -1;
+
+    m_gameOver = false;
+
+    if ( g_pClientMode &&
+		 g_pClientMode->GetMapName() )
+    {
+		V_wcsncpy( m_pMapName, g_pClientMode->GetMapName(), sizeof( m_pMapName ) );
+        SetDialogVariable( "mapname", m_pMapName );
+        m_pLabelMapName->SetVisible( true );
+    }
+
+    SetKeyBoardInputEnabled( true );
+
+    for ( int i = 0; i < cMaxScoreLines; ++i )
+    {
+		PlayerDisplay* pPlayerDisplay;
+
+		pPlayerDisplay = &m_teamDisplayCT.playerDisplay[i];
+		pPlayerDisplay->pClanLabel = NULL;
+		pPlayerDisplay->pNameLabel = NULL;
+		pPlayerDisplay->pScoreLabel = NULL;
+		pPlayerDisplay->pDeathsLabel = NULL;
+		pPlayerDisplay->pPingLabel = NULL;
+		pPlayerDisplay->pMVPCountLabel = NULL;
+		pPlayerDisplay->pAvatar = NULL;
+		pPlayerDisplay->pStatusImage = NULL;
+		pPlayerDisplay->pMVPImage = NULL;
+		pPlayerDisplay->pSelect = NULL;
+
+		pPlayerDisplay = &m_teamDisplayT.playerDisplay[i];
+		pPlayerDisplay->pClanLabel = NULL;
+		pPlayerDisplay->pNameLabel = NULL;
+		pPlayerDisplay->pScoreLabel = NULL;
+		pPlayerDisplay->pDeathsLabel = NULL;
+		pPlayerDisplay->pPingLabel = NULL;
+		pPlayerDisplay->pMVPCountLabel = NULL;
+		pPlayerDisplay->pAvatar = NULL;
+		pPlayerDisplay->pStatusImage = NULL;
+		pPlayerDisplay->pMVPImage = NULL;
+		pPlayerDisplay->pSelect = NULL;
+	}
+
+	m_pServerName[0] = L'\0';
+    m_pStatsEnabled[0] = L'\0';
+    m_pStatsDisabled[0] = L'\0';
+
+	m_MVPXOffset = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CCSClientScoreBoardDialog::~CCSClientScoreBoardDialog()
+{
+    for (int i = 0; i < cMaxScoreLines; ++i)
+    {
+		PlayerDisplay* pPlayerDisplay;
+
+		pPlayerDisplay = &m_teamDisplayCT.playerDisplay[i];
+		delete pPlayerDisplay->pClanLabel;
+        delete pPlayerDisplay->pNameLabel;
+        delete pPlayerDisplay->pScoreLabel;
+        delete pPlayerDisplay->pDeathsLabel;
+        delete pPlayerDisplay->pPingLabel;
+		delete pPlayerDisplay->pMVPCountLabel;
+		delete pPlayerDisplay->pAvatar;
+        delete pPlayerDisplay->pStatusImage;
+		delete pPlayerDisplay->pMVPImage;
+		delete pPlayerDisplay->pSelect;
+
+		pPlayerDisplay = &m_teamDisplayT.playerDisplay[i];
+		delete pPlayerDisplay->pClanLabel;
+		delete pPlayerDisplay->pNameLabel;
+		delete pPlayerDisplay->pScoreLabel;
+		delete pPlayerDisplay->pDeathsLabel;
+		delete pPlayerDisplay->pPingLabel;
+		delete pPlayerDisplay->pMVPCountLabel;
+		delete pPlayerDisplay->pAvatar;
+		delete pPlayerDisplay->pStatusImage;
+		delete pPlayerDisplay->pMVPImage;
+		delete pPlayerDisplay->pSelect;
+    }
+}
+
+const wchar_t *LocalizeFindSafe( const char *pTokenName )
+{
+	const wchar_t *pStr = g_pVGuiLocalize->Find( pTokenName );
+	return pStr ? pStr : L"\0";
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply scheme settings
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+    BaseClass::ApplySchemeSettings( pScheme );
+
+	//
+	// [smessick] Note: ApplySchemeSettings is called multiple times for the scoreboard.
+	// Therefore, we must make sure to delete previously allocated items.
+	//
+
+    LoadControlSettings( "Resource/UI/scoreboard.res" );
+
+    //Just used for a background alpha value.  50% opacity
+    m_listItemFont = pScheme->GetFont( "ScoreboardBody_1", IsProportional() );
+    m_listItemFontSmaller = pScheme->GetFont( "ScoreboardBody_2", IsProportional() );
+    m_listItemFontSmallest = pScheme->GetFont( "ScoreboardBody_3", IsProportional() );
+	m_MVPFont = pScheme->GetFont( "ScoreboardMVP", IsProportional() );
+
+    SetBgColor( Color( 0, 0, 0, 0 ) );
+    SetBorder( pScheme->GetBorder( "BaseBorder" ) );
+
+    // turn off the default player list since we have our own
+    if ( m_pPlayerList )
+    {
+        m_pPlayerList->SetVisible( false );
+    }
+
+	// Set the player colors from the convars.
+	UpdatePlayerColors();
+
+	m_MVPXOffset = scheme()->GetProportionalScaledValueEx( GetScheme(), 2 );
+
+	SetupTeamDisplay( m_teamDisplayCT, "CT" );
+	SetupTeamDisplay( m_teamDisplayT, "T" );
+
+	// Set the server name (in the case of a resolution change).
+	if ( m_pServerName[0] == L'\0' &&
+		 g_pClientMode->GetServerName() != NULL )
+	{
+		V_wcsncpy( m_pServerName, g_pClientMode->GetServerName(), sizeof( m_pServerName ) );
+	}
+
+	// Cache the stats enabled string.
+	if ( m_pStatsEnabled[0] == L'\0' )
+	{
+		V_wcsncpy( m_pStatsEnabled, LocalizeFindSafe( "#Cstrike_Scoreboard_StatsEnabled" ), sizeof( m_pStatsEnabled ) );
+	}
+
+	// Cache the stats disabled string.
+	if ( m_pStatsDisabled[0] == L'\0' )
+	{
+		V_wcsncpy( m_pStatsDisabled, LocalizeFindSafe( "#Cstrike_Scoreboard_StatsDisabled" ), sizeof( m_pStatsDisabled ) );
+	}
+ 
+    SetVisible( false );
+}
+
+
+void CCSClientScoreBoardDialog::SetupTeamDisplay( TeamDisplayInfo& teamDisplay, const char* szTeamPrefix )
+{
+	const int selectMargin = scheme()->GetProportionalScaledValueEx( GetScheme(), 1 );
+	const int mvpLabelWidth = scheme()->GetProportionalScaledValueEx( GetScheme(), 20 );
+	const int mvpLabelYOffset = scheme()->GetProportionalScaledValueEx( GetScheme(), 2 );
+
+	char tmpName[32];
+
+	V_snprintf( tmpName, sizeof(tmpName), "%sPlayerArea", szTeamPrefix );
+	Panel *pPlayerArea = FindChildByName( tmpName );
+
+	V_snprintf( tmpName, sizeof(tmpName), "%sPlayerAvatar0", szTeamPrefix );
+	Panel *pPlayerAvatar0 = FindChildByName( tmpName );
+
+	V_snprintf( tmpName, sizeof(tmpName), "%sPlayerClan0", szTeamPrefix );
+	Panel *pPlayerClan0 = FindChildByName( tmpName );
+
+	V_snprintf( tmpName, sizeof(tmpName), "%sPlayerName0", szTeamPrefix );
+	Panel *pPlayerName0 = FindChildByName( tmpName );
+
+	V_snprintf( tmpName, sizeof(tmpName), "%sPlayerStatus0", szTeamPrefix );
+	Panel *pPlayerStatus0 = FindChildByName( tmpName );
+
+	V_snprintf( tmpName, sizeof(tmpName), "%sPlayerScore0", szTeamPrefix );
+	Panel *pPlayerScore0 = FindChildByName( tmpName );
+
+	V_snprintf( tmpName, sizeof(tmpName), "%sPlayerDeaths0", szTeamPrefix );
+	Panel *pPlayerDeaths0 = FindChildByName( tmpName );
+
+	V_snprintf( tmpName, sizeof(tmpName), "%sPlayerLatency0", szTeamPrefix );
+	Panel *pPlayerLatency0 = FindChildByName( tmpName );
+
+	// Get the bounds of the player area.
+	int playerX = 0;
+	int playerY = 0;
+	int playerWide = 0;
+	int playerTall = 0;
+	if ( pPlayerArea )
+		pPlayerArea->GetBounds( playerX, playerY, playerWide, playerTall );
+
+	// determine the line height needed
+	int x, y, wide, tall;
+	teamDisplay.scoreAreaLineHeight = 0;
+	teamDisplay.scoreAreaMinX = INT_MAX;
+	teamDisplay.scoreAreaMaxX = INT_MIN;
+
+	if ( pPlayerAvatar0 != NULL )
+	{
+		pPlayerAvatar0->GetBounds( x, y, wide, tall );
+		teamDisplay.scoreAreaLineHeight = MAX( tall, teamDisplay.scoreAreaLineHeight );
+		teamDisplay.scoreAreaMinX = MIN( teamDisplay.scoreAreaMinX, x );
+		teamDisplay.scoreAreaMaxX = MAX( teamDisplay.scoreAreaMaxX, x + wide );
+	}
+	if ( pPlayerClan0 != NULL )
+	{
+		pPlayerClan0->GetBounds( x, y, wide, tall );
+		teamDisplay.scoreAreaLineHeight = MAX( tall, teamDisplay.scoreAreaLineHeight );
+		teamDisplay.scoreAreaMinX = MIN( teamDisplay.scoreAreaMinX, x );
+		teamDisplay.scoreAreaMaxX = MAX( teamDisplay.scoreAreaMaxX, x + wide );
+	}
+	if ( pPlayerName0 != NULL )
+	{
+		pPlayerName0->GetBounds( x, y, wide, tall );
+		teamDisplay.scoreAreaLineHeight = MAX( tall, teamDisplay.scoreAreaLineHeight );
+		teamDisplay.scoreAreaMinX = MIN( teamDisplay.scoreAreaMinX, x );
+		teamDisplay.scoreAreaMaxX = MAX( teamDisplay.scoreAreaMaxX, x + wide );
+	}
+	if ( pPlayerScore0 != NULL )
+	{
+		pPlayerScore0->GetBounds( x, y, wide, tall );
+		teamDisplay.scoreAreaLineHeight = MAX( tall, teamDisplay.scoreAreaLineHeight );
+		teamDisplay.scoreAreaMinX = MIN( teamDisplay.scoreAreaMinX, x );
+		teamDisplay.scoreAreaMaxX = MAX( teamDisplay.scoreAreaMaxX, x + wide );
+	}
+	if ( pPlayerDeaths0 != NULL )
+	{
+		pPlayerDeaths0->GetBounds( x, y, wide, tall );
+		teamDisplay.scoreAreaLineHeight = MAX( tall, teamDisplay.scoreAreaLineHeight );
+		teamDisplay.scoreAreaMinX = MIN( teamDisplay.scoreAreaMinX, x );
+		teamDisplay.scoreAreaMaxX = MAX( teamDisplay.scoreAreaMaxX, x + wide );
+	}
+	if ( pPlayerLatency0 != NULL )
+	{
+		pPlayerLatency0->GetBounds( x, y, wide, tall );
+		teamDisplay.scoreAreaLineHeight = MAX( tall, teamDisplay.scoreAreaLineHeight );
+		teamDisplay.scoreAreaMinX = MIN( teamDisplay.scoreAreaMinX, x );
+		teamDisplay.scoreAreaMaxX = MAX( teamDisplay.scoreAreaMaxX, x + wide );
+	}
+	if ( pPlayerStatus0 != NULL )
+	{
+		pPlayerStatus0->GetBounds( x, y, wide, tall );
+		teamDisplay.scoreAreaLineHeight = MAX( tall, teamDisplay.scoreAreaLineHeight );
+		teamDisplay.scoreAreaMinX = MIN( teamDisplay.scoreAreaMinX, x );
+		teamDisplay.scoreAreaMaxX = MAX( teamDisplay.scoreAreaMaxX, x + wide );
+	}
+
+	int marginY = RoundFloatToInt(teamDisplay.scoreAreaLineHeight * kTeamScoreMargin);
+
+	teamDisplay.scoreAreaInnerHeight = playerTall - 2 * marginY;
+	teamDisplay.scoreAreaLinePreferredLeading = RoundFloatToInt(teamDisplay.scoreAreaLineHeight * kTeamScoreLineLeadingRatio);
+	teamDisplay.scoreAreaStartY = playerY + marginY;
+	teamDisplay.maxPlayersVisible = MIN(cMaxScoreLines, teamDisplay.scoreAreaInnerHeight / teamDisplay.scoreAreaLineHeight);
+
+	// Calculate the starting point for player data.
+	int startY = teamDisplay.scoreAreaStartY;
+	int spacingY = teamDisplay.scoreAreaLineHeight + teamDisplay.scoreAreaLinePreferredLeading;
+
+	for ( int i = 0; i < cMaxScoreLines; ++i, startY += spacingY )
+	{
+		PlayerDisplay& playerDisplay = teamDisplay.playerDisplay[i];
+
+		int wide = 0;
+		int tall = 0;
+		int x = 0;
+		int y = 0;
+
+		// avatar
+		if ( pPlayerAvatar0 != NULL )
+		{
+			pPlayerAvatar0->GetBounds( x, y, wide, tall );
+			V_snprintf( tmpName, 32, "_%s_playeravatar%d", szTeamPrefix, i );
+			delete playerDisplay.pAvatar;
+			playerDisplay.pAvatar = (CAvatarImagePanel*)SETUP_PANEL( new CAvatarImagePanel( this, tmpName ) );
+			playerDisplay.pAvatar->SetBounds( x, startY, wide, tall );
+			playerDisplay.pAvatar->SetDefaultAvatar( scheme()->GetImage( &teamDisplay == &m_teamDisplayCT ? CSTRIKE_DEFAULT_CT_AVATAR : CSTRIKE_DEFAULT_T_AVATAR, true ) );
+			playerDisplay.pAvatar->SetShouldDrawFriendIcon( false );
+			playerDisplay.pAvatar->SetShouldScaleImage( true );
+			playerDisplay.pAvatar->SetVisible( false );
+		}
+
+		// clan
+		if ( pPlayerClan0 != NULL )
+		{
+			pPlayerClan0->GetBounds( x, y, wide, tall );
+			V_snprintf( tmpName, 32, "_%s_playerclan%d", szTeamPrefix, i );
+			delete playerDisplay.pClanLabel;
+			playerDisplay.pClanLabel = (Label*)SETUP_PANEL( new Label( this, tmpName, tmpName ) );
+			playerDisplay.pClanLabel->SetFont( m_listItemFont );
+			playerDisplay.pClanLabel->SetBounds( x, startY, wide, tall );
+			playerDisplay.pClanLabel->SetBgColor( m_PlayerDataBgColor );
+			playerDisplay.pClanLabel->SetFgColor( m_teamDisplayCT.playerClanColor );
+			playerDisplay.pClanLabel->SetContentAlignment( Label::a_east );
+			playerDisplay.pClanLabel->SetVisible( false );
+		}
+
+		// name
+		if ( pPlayerName0 != NULL )
+		{
+			pPlayerName0->GetBounds( x, y, wide, tall );
+			V_snprintf( tmpName, 32, "_%s_playername%d", szTeamPrefix, i );
+			delete playerDisplay.pNameLabel;
+			playerDisplay.pNameLabel = (Label*)SETUP_PANEL( new Label( this, tmpName, tmpName ) );
+			playerDisplay.pNameLabel->SetFont( m_listItemFont );
+			playerDisplay.pNameLabel->SetBounds( x, startY, wide, tall);
+			playerDisplay.pNameLabel->SetBgColor( m_PlayerDataBgColor );
+			playerDisplay.pNameLabel->SetFgColor( m_teamDisplayCT.playerDataColor );
+			playerDisplay.pNameLabel->SetContentAlignment( Label::a_west );
+			playerDisplay.pNameLabel->SetVisible( false );
+
+			// mvp
+			int wideMVP = RoundFloatToInt(teamDisplay.scoreAreaLineHeight * kScaleMVP);
+			int tallMVP = RoundFloatToInt(teamDisplay.scoreAreaLineHeight * kScaleMVP);
+			int yMVP = ( teamDisplay.scoreAreaLineHeight - tallMVP ) / 2;
+
+			V_snprintf( tmpName, 32, "_%s_mvp%d", szTeamPrefix, i );
+			delete playerDisplay.pMVPImage;
+			playerDisplay.pMVPImage = (ImagePanel*)SETUP_PANEL( new ImagePanel( this, tmpName ) );
+			playerDisplay.pMVPImage->SetBounds( x, startY + yMVP, wideMVP, tallMVP );
+			playerDisplay.pMVPImage->SetImage( "../hud/scoreboard_mvp" );
+			playerDisplay.pMVPImage->SetShouldScaleImage( true );
+			playerDisplay.pMVPImage->SetVisible( false );
+
+			// mvp count
+			V_snprintf( tmpName, 32, "_%s_mvpcount%d", szTeamPrefix, i );
+			delete playerDisplay.pMVPCountLabel;
+			playerDisplay.pMVPCountLabel = (Label*)SETUP_PANEL( new Label( this, tmpName, "" ) );
+			playerDisplay.pMVPCountLabel->SetFont( m_MVPFont );
+			playerDisplay.pMVPCountLabel->SetBounds( 0, -mvpLabelYOffset, mvpLabelWidth, tallMVP );
+			playerDisplay.pMVPCountLabel->SetVisible( false );
+
+			// Pin to the mvp image.
+			V_snprintf( tmpName, 32, "_%s_mvp%d", szTeamPrefix, i );
+			playerDisplay.pMVPCountLabel->PinToSibling( tmpName, PIN_CENTER_LEFT, PIN_CENTER_RIGHT );
+		}
+
+		// score
+		if ( pPlayerScore0 != NULL )
+		{
+			pPlayerScore0->GetBounds( x, y, wide, tall );
+			V_snprintf( tmpName, 32, "_%s_playerscore%d", szTeamPrefix, i );
+			delete playerDisplay.pScoreLabel;
+			playerDisplay.pScoreLabel = (Label*)SETUP_PANEL( new Label( this, tmpName, "" ) );
+			playerDisplay.pScoreLabel->SetFont( m_listItemFont );
+			playerDisplay.pScoreLabel->SetBounds( x, startY, wide, tall );
+			playerDisplay.pScoreLabel->SetBgColor( m_PlayerDataBgColor );
+			playerDisplay.pScoreLabel->SetFgColor( m_teamDisplayCT.playerDataColor );
+			playerDisplay.pScoreLabel->SetContentAlignment( Label::a_center );
+			playerDisplay.pScoreLabel->SetVisible( false );
+		}
+
+		// deaths
+		if ( pPlayerDeaths0 != NULL )
+		{
+			pPlayerDeaths0->GetBounds( x, y, wide, tall );
+			V_snprintf( tmpName, 32, "_%s_playerdeaths%d", szTeamPrefix, i );
+			delete playerDisplay.pDeathsLabel;
+			playerDisplay.pDeathsLabel = (Label*)SETUP_PANEL( new Label( this, tmpName, "" ) );
+			playerDisplay.pDeathsLabel->SetFont( m_listItemFont );
+			playerDisplay.pDeathsLabel->SetBounds( x, startY, wide, tall );
+			playerDisplay.pDeathsLabel->SetBgColor( m_PlayerDataBgColor );
+			playerDisplay.pDeathsLabel->SetFgColor( m_teamDisplayCT.playerDataColor );
+			playerDisplay.pDeathsLabel->SetContentAlignment( Label::a_center );
+			playerDisplay.pDeathsLabel->SetVisible( false );
+		}
+
+		// latency
+		if ( pPlayerLatency0 != NULL )
+		{
+			pPlayerLatency0->GetBounds( x, y, wide, tall );
+			V_snprintf( tmpName, 32, "_%s_playerping%d", szTeamPrefix, i );
+			delete playerDisplay.pPingLabel;
+			playerDisplay.pPingLabel = (Label*)SETUP_PANEL( new Label( this, tmpName, "" ) );
+			playerDisplay.pPingLabel->SetFont( m_listItemFont );
+			playerDisplay.pPingLabel->SetBounds( x, startY, wide, tall );
+			playerDisplay.pPingLabel->SetBgColor( m_PlayerDataBgColor );
+			playerDisplay.pPingLabel->SetFgColor( m_teamDisplayCT.playerDataColor );
+			playerDisplay.pPingLabel->SetContentAlignment( Label::a_center );
+			playerDisplay.pPingLabel->SetVisible( false );
+		}
+
+		// status
+		if ( pPlayerStatus0 != NULL )
+		{
+			pPlayerStatus0->GetBounds( x, y, wide, tall );
+			V_snprintf( tmpName, 32, "_%s_playerstatus%d", szTeamPrefix, i );
+			delete playerDisplay.pStatusImage;
+			playerDisplay.pStatusImage = (ImagePanel*)SETUP_PANEL( new ImagePanel( this, tmpName ) );
+			playerDisplay.pStatusImage->SetBounds( x, startY, wide, tall );
+			playerDisplay.pStatusImage->SetImage( "../hud/scoreboard_dead" );
+			playerDisplay.pStatusImage->SetShouldScaleImage( true );
+			playerDisplay.pStatusImage->SetVisible( false );
+		}
+
+		// select
+		{
+			int x1 = teamDisplay.scoreAreaMinX - selectMargin;
+			int y1 = startY - selectMargin;
+			int x2 = teamDisplay.scoreAreaMaxX + selectMargin;
+			int y2 = startY + teamDisplay.scoreAreaLineHeight + selectMargin;
+
+			V_snprintf( tmpName, 32, "_%s_playerselect%d", szTeamPrefix, i );
+			delete playerDisplay.pSelect;
+			playerDisplay.pSelect = (ImagePanel*)SETUP_PANEL( new ImagePanel( this, tmpName ) );
+			playerDisplay.pSelect->SetBounds( x1, y1, x2 - x1, y2 - y1 );
+			playerDisplay.pSelect->SetImage( "../vgui/scoreboard/scoreboard-select" );
+			playerDisplay.pSelect->SetShouldScaleImage( true );
+			playerDisplay.pSelect->SetVisible( false );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for sorting players
+//-----------------------------------------------------------------------------
+int CCSClientScoreBoardDialog::PlayerSortFunction( PlayerScoreInfo* const* pLeft, PlayerScoreInfo* const* pRight )
+{
+	// a return value < 0 puts pLeft earlier in the list, > 0 puts pRight earlier
+    const PlayerScoreInfo* pPlayer1 = *pLeft;
+    const PlayerScoreInfo* pPlayer2 = *pRight;
+    Assert( pPlayer1 && pPlayer2 );
+
+    // bail out early if either player is an empty slot, i.e. has a player index of -1
+    if( pPlayer1->playerIndex == -1 )
+		return 1;
+    if( pPlayer2->playerIndex == -1 )
+		return -1;
+
+    // first compare scores
+    if ( pPlayer1->frags > pPlayer2->frags )
+		return -1;
+    if ( pPlayer1->frags < pPlayer2->frags )
+		return 1;
+
+    // second compare deaths
+    if ( pPlayer1->deaths > pPlayer2->deaths )
+		return 1;
+    if ( pPlayer1->deaths < pPlayer2->deaths )
+		return -1;
+
+    // if score and deaths are the same, use player index to get deterministic sort
+    if ( pPlayer1->playerIndex < pPlayer2->playerIndex )
+		return -1;
+	else
+		return 1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates the dialog
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::Update()
+{
+    if ( m_pServerLabel )
+    {
+        m_pServerLabel->SetText( m_pServerName );
+    }
+
+	// Update the stats status.
+    CAchievementMgr *pAchievementMgr = dynamic_cast<CAchievementMgr*>( engine->GetAchievementMgr() );
+    if ( pAchievementMgr != NULL &&
+		 pAchievementMgr->CheckAchievementsEnabled() )
+	{
+		SetDialogVariable( "statsstatus", m_pStatsEnabled );
+	}
+	else
+	{
+		SetDialogVariable( "statsstatus", m_pStatsDisabled );
+	}
+
+    UpdateTeamInfo();
+    UpdatePlayerList();
+    UpdateSpectatorList();
+	UpdateHLTVList();
+    UpdateMatchEndText();
+	UpdateMvpElements();
+
+    // update every second
+    m_fNextUpdateTime = gpGlobals->curtime + kUpdateInterval;
+
+    // Catch the case where we call ShowPanel before ApplySchemeSettings, eg when going from windowed <-> fullscreen
+    if ( m_pImageList == NULL )
+    {
+        InvalidateLayout( true, true );
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates information about teams
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::UpdateTeamInfo()
+{
+	if ( g_PR == NULL )
+	{
+		return;
+	}
+
+    // update the team sections in the scoreboard
+    for ( int teamIndex = TEAM_TERRORIST; teamIndex <= TEAM_CT; teamIndex++ )
+    {
+        wchar_t *teamName = NULL;
+        C_Team *team = GetGlobalTeam( teamIndex );
+        if ( team )
+        {
+            // choose dialog variables to set depending on team
+            const char *pDialogVarTeamName = NULL;
+            const char *pDialogVarAliveCount = NULL;
+			const char *pDialogVarTeamScore = NULL;
+            switch ( teamIndex )
+            {
+            case TEAM_TERRORIST:
+                teamName = g_pVGuiLocalize->Find( "#Cstrike_Team_T" );
+                pDialogVarTeamName = "t_teamname";
+				pDialogVarAliveCount = "t_alivecount";
+				pDialogVarTeamScore = "t_totalteamscore";
+                break;
+            case TEAM_CT:
+                teamName = g_pVGuiLocalize->Find( "#Cstrike_Team_CT" );
+                pDialogVarTeamName = "ct_teamname";
+				pDialogVarAliveCount = "ct_alivecount";
+				pDialogVarTeamScore = "ct_totalteamscore";
+                break;
+            default:
+                Assert( false );
+                break;
+            }
+
+			// Set the team name if it hasn't been set.
+            wchar_t name[64];
+            if ( !teamName && team && team->Get_Name() != NULL )
+            {
+                g_pVGuiLocalize->ConvertANSIToUnicode( team->Get_Name(), name, sizeof( name ) );
+                teamName = name;
+            }
+
+			// Count the players on the team.
+            int numPlayers = 0;
+			int numAlive = 0;
+            for ( int playerIndex = 1 ; playerIndex <= MAX_PLAYERS; playerIndex++ )
+            {
+                if ( g_PR->IsConnected( playerIndex ) && g_PR->GetTeam( playerIndex ) == teamIndex )
+                {
+                    numPlayers++;
+					if ( g_PR->IsAlive( playerIndex ) )
+					{
+						++numAlive;
+					}
+                }				
+            }
+
+            SetDialogVariable( pDialogVarTeamName, teamName );
+
+			// Team score
+            wchar_t wNumScore[16];
+            V_snwprintf( wNumScore, ARRAYSIZE( wNumScore ), L"%i", team->Get_Score() );
+            SetDialogVariable( pDialogVarTeamScore, wNumScore );
+
+			// Number of alive players
+			wchar_t numAliveString[32];
+            V_snwprintf( numAliveString, ARRAYSIZE( numAliveString ), L"%i / %i", numAlive, numPlayers);
+            SetDialogVariable( pDialogVarAliveCount, numAliveString );
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Helper to shrink font size when a string gets too long for its label
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::AdjustFontToFit( const char *pString, vgui::Label *pLabel )
+{
+	if ( !pString || !pLabel )
+		return;
+
+	int len = Q_strlen( pString );
+	if ( !len )
+		return;
+
+	int arraySize = len + 1;
+	wchar_t *pWideString = new wchar_t[arraySize];
+	V_UTF8ToUnicode( pString, pWideString, (arraySize * sizeof(wchar_t)) );
+
+	int stringWidth, stringHeight;
+	g_pMatSystemSurface->GetTextSize( m_listItemFont, pWideString, stringWidth, stringHeight );
+
+	int labelWidth = pLabel->GetWide();
+	if ( stringWidth <= labelWidth )
+	{
+		pLabel->SetFont( m_listItemFont );
+	}
+	else
+	{
+		g_pMatSystemSurface->GetTextSize( m_listItemFontSmaller, pWideString, stringWidth, stringHeight );
+		if ( stringWidth <= labelWidth )
+		{
+			pLabel->SetFont( m_listItemFontSmaller );
+		}
+		else
+		{
+			pLabel->SetFont(m_listItemFontSmallest);
+		}
+	}
+	delete [] pWideString;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates the player list
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::UpdatePlayerList()
+{
+    m_teamDisplayT.playerScores.PurgeAndDeleteElements();
+    m_teamDisplayCT.playerScores.PurgeAndDeleteElements();
+
+    C_CSPlayer *pLocalPlayer = C_CSPlayer::GetLocalCSPlayer();
+    if ( !pLocalPlayer )
+        return;
+
+	// Set the player colors from the convars.
+	UpdatePlayerColors();
+
+    for( int playerIndex = 1 ; playerIndex <= MAX_PLAYERS; playerIndex++ )
+    {
+        if( g_PR->IsConnected( playerIndex ) )
+        {
+            PlayerScoreInfo* playerScoreInfo = new PlayerScoreInfo;
+            if ( !GetPlayerScoreInfo( playerIndex, *playerScoreInfo ) )
+			{
+                delete playerScoreInfo;
+				continue;
+			}
+
+            if ( g_PR->GetTeam( playerIndex ) == TEAM_TERRORIST )
+            {
+                m_teamDisplayT.playerScores.AddToTail(playerScoreInfo);
+            }
+            else if ( g_PR->GetTeam( playerIndex ) == TEAM_CT )
+            {
+                m_teamDisplayCT.playerScores.AddToTail(playerScoreInfo);
+            }
+            else
+            {
+				// [mhansen] make sure we don't leak here
+                delete playerScoreInfo;
+            }
+        }
+    }
+
+    // Sort the lists of players
+    m_teamDisplayT.playerScores.Sort(PlayerSortFunction);
+    m_teamDisplayCT.playerScores.Sort(PlayerSortFunction);
+
+    // Force the local player to be visible when he is below the visible portion of the sorted list
+	if ( pLocalPlayer->GetTeamNumber() == TEAM_TERRORIST )
+		ForceLocalPlayerVisible(m_teamDisplayT);
+	else if ( pLocalPlayer->GetTeamNumber() == TEAM_CT )
+		ForceLocalPlayerVisible(m_teamDisplayCT);
+
+	UpdateTeamPlayerDisplay(m_teamDisplayT);
+	UpdateTeamPlayerDisplay(m_teamDisplayCT);
+}
+
+void CCSClientScoreBoardDialog::UpdateTeamPlayerDisplay( TeamDisplayInfo& teamDisplay )
+{
+	const int selectMargin = scheme()->GetProportionalScaledValueEx( GetScheme(), 1 );
+
+	C_CS_PlayerResource *cs_PR = dynamic_cast<C_CS_PlayerResource *>( g_PR );
+	if ( !cs_PR )
+		return;
+	int iLocalPlayerIndex = GetLocalPlayerIndex();
+
+	int maxTeamSize = MAX(m_teamDisplayT.playerScores.Count(), m_teamDisplayCT.playerScores.Count());
+
+	// adjust spacing
+	int leadingAvailable = teamDisplay.scoreAreaInnerHeight - maxTeamSize * teamDisplay.scoreAreaLineHeight;
+	int leading = 0;
+	if ( maxTeamSize > 1 )	// only makes sense if we have more than one player
+	{
+		leading = clamp(leadingAvailable / (maxTeamSize - 1), 0, teamDisplay.scoreAreaLinePreferredLeading);
+	}
+	int spacingY = teamDisplay.scoreAreaLineHeight + leading;
+
+	// temp values for updating just the y position of elements
+	int xPos, yPos;
+
+	int i = 0;
+	int startY = teamDisplay.scoreAreaStartY;
+	for ( i = 0; i < MIN( cMaxScoreLines, teamDisplay.playerScores.Count() ); ++i, startY += spacingY )
+	{
+		if ( startY + teamDisplay.scoreAreaLineHeight > teamDisplay.scoreAreaStartY + teamDisplay.scoreAreaInnerHeight )
+			break;
+
+		PlayerDisplay& playerDisplay = teamDisplay.playerDisplay[i];
+
+		const PlayerScoreInfo* pPlayerScore = teamDisplay.playerScores[i];
+		if ( pPlayerScore )
+		{
+			int playerIndex = pPlayerScore->playerIndex;
+
+			const char* pUTF8Name = pPlayerScore->szName;
+
+// 			int bufsize;
+// 			if ( g_PR->IsFakePlayer( playerIndex ) )
+// 				bufsize = strlen( oldName ) * 2 + 14 + 1;
+// 			else
+// 				bufsize = strlen( oldName ) * 2 + 1;
+// 
+// 			char *newName = (char *)_alloca( bufsize );
+// 			UTIL_MakeSafeName( oldName, newName, bufsize );
+
+			if ( pUTF8Name != NULL && V_strlen( pUTF8Name ) > 0 )
+			{
+				bool isAlive = cs_PR->IsAlive( playerIndex );
+				Color fgColor = ( isAlive ? teamDisplay.playerDataColor : m_DeadPlayerDataColor );
+				Color fgClanColor = ( isAlive ? teamDisplay.playerClanColor : m_DeadPlayerClanColor );
+
+				if ( playerDisplay.pNameLabel != NULL )
+				{
+					AdjustFontToFit( pUTF8Name, playerDisplay.pNameLabel );
+
+					playerDisplay.pNameLabel->SetVisible( true );
+					playerDisplay.pNameLabel->SetText( pUTF8Name );
+					playerDisplay.pNameLabel->SetBgColor( m_PlayerDataBgColor );
+					playerDisplay.pNameLabel->SetFgColor( fgColor );
+					playerDisplay.pNameLabel->GetPos(xPos, yPos);
+					playerDisplay.pNameLabel->SetPos(xPos, startY);
+
+					int tallMVP = RoundFloatToInt(teamDisplay.scoreAreaLineHeight * kScaleMVP);
+					int yMVP = ( teamDisplay.scoreAreaLineHeight - tallMVP ) / 2;
+					playerDisplay.pMVPImage->SetPos( xPos, startY + yMVP);
+				}
+
+				if ( playerDisplay.pClanLabel != NULL )
+				{
+					const char* pUTF8Clan = pPlayerScore->szClanTag;
+					AdjustFontToFit( pUTF8Clan, playerDisplay.pClanLabel );
+
+					playerDisplay.pClanLabel->SetVisible( true );
+					playerDisplay.pClanLabel->SetText( pUTF8Clan );
+					playerDisplay.pClanLabel->SetBgColor( m_PlayerDataBgColor );
+					playerDisplay.pClanLabel->SetFgColor( fgClanColor );
+					playerDisplay.pClanLabel->GetPos(xPos, yPos);
+					playerDisplay.pClanLabel->SetPos(xPos, startY);
+				}
+
+				char tmpbuf[16];
+
+				if ( playerDisplay.pScoreLabel != NULL )
+				{
+					Q_snprintf( tmpbuf, sizeof( tmpbuf ), "%d", pPlayerScore->frags);
+					playerDisplay.pScoreLabel->SetVisible( true );
+					playerDisplay.pScoreLabel->SetText( tmpbuf );
+					playerDisplay.pScoreLabel->SetBgColor( m_PlayerDataBgColor );
+					playerDisplay.pScoreLabel->SetFgColor( fgColor );
+					playerDisplay.pScoreLabel->GetPos(xPos, yPos);
+					playerDisplay.pScoreLabel->SetPos(xPos, startY);
+				}
+
+				if ( playerDisplay.pDeathsLabel != NULL )
+				{
+					Q_snprintf( tmpbuf, sizeof( tmpbuf ), "%d", pPlayerScore->deaths);
+					playerDisplay.pDeathsLabel->SetVisible( true );
+					playerDisplay.pDeathsLabel->SetText( tmpbuf );
+					playerDisplay.pDeathsLabel->SetBgColor( m_PlayerDataBgColor );
+					playerDisplay.pDeathsLabel->SetFgColor( fgColor );
+					playerDisplay.pDeathsLabel->GetPos(xPos, yPos);
+					playerDisplay.pDeathsLabel->SetPos(xPos, startY);
+
+				}
+
+				if ( playerDisplay.pPingLabel != NULL )
+				{
+					if ( pPlayerScore->ping >= 0 )
+						Q_snprintf( tmpbuf, sizeof( tmpbuf ), "%d", pPlayerScore->ping);
+					else
+						Q_strcpy( tmpbuf, "BOT");
+
+					playerDisplay.pPingLabel->SetVisible( true );
+					playerDisplay.pPingLabel->SetText( tmpbuf );
+					playerDisplay.pPingLabel->SetBgColor( m_PlayerDataBgColor );
+					playerDisplay.pPingLabel->SetFgColor( fgColor );
+					playerDisplay.pPingLabel->GetPos(xPos, yPos);
+					playerDisplay.pPingLabel->SetPos(xPos, startY);
+
+				}
+			}
+
+			if ( playerDisplay.pStatusImage != NULL )
+			{
+				if ( pPlayerScore->szStatus == NULL )
+				{
+					playerDisplay.pStatusImage->SetVisible( false );
+				}
+				else
+				{
+					playerDisplay.pStatusImage->SetVisible( true );
+					playerDisplay.pStatusImage->SetImage( pPlayerScore->szStatus );
+					playerDisplay.pStatusImage->GetPos(xPos, yPos);
+					playerDisplay.pStatusImage->SetPos(xPos, startY);
+					playerDisplay.pStatusImage->SetDrawColor(pPlayerScore->bStatusPlayerColor ? teamDisplay.playerDataColor : COLOR_WHITE);
+				}
+			}
+
+			if ( playerDisplay.pAvatar != NULL )
+			{
+				playerDisplay.pAvatar->SetVisible( true );
+				playerDisplay.pAvatar->SetPlayer( playerIndex, k_EAvatarSize32x32 );				
+				playerDisplay.pAvatar->GetPos(xPos, yPos);
+				playerDisplay.pAvatar->SetPos(xPos, startY);
+			}
+
+			if ( playerDisplay.pSelect != NULL )
+			{
+				playerDisplay.pSelect->SetVisible( pPlayerScore->playerIndex == iLocalPlayerIndex );
+				playerDisplay.pSelect->SetPos(teamDisplay.scoreAreaMinX - selectMargin, startY - selectMargin);
+			}
+		}
+	}
+
+	// set any remaining entries to non-visible
+	for ( ; i < cMaxScoreLines; ++i )
+	{
+		PlayerDisplay& playerDisplay = teamDisplay.playerDisplay[i];
+
+		if ( playerDisplay.pClanLabel != NULL )
+			playerDisplay.pClanLabel->SetVisible(false);
+
+		if ( playerDisplay.pNameLabel != NULL )
+			playerDisplay.pNameLabel->SetVisible(false);
+
+		if ( playerDisplay.pScoreLabel != NULL )
+			playerDisplay.pScoreLabel->SetVisible(false);
+
+		if ( playerDisplay.pDeathsLabel != NULL )
+			playerDisplay.pDeathsLabel->SetVisible(false);
+
+		if ( playerDisplay.pPingLabel != NULL )
+			playerDisplay.pPingLabel->SetVisible(false);
+
+		if ( playerDisplay.pStatusImage != NULL )
+			playerDisplay.pStatusImage->SetVisible(false);
+
+		if ( playerDisplay.pAvatar != NULL )
+			playerDisplay.pAvatar->SetVisible( false );
+
+		if ( playerDisplay.pMVPImage != NULL )
+			playerDisplay.pMVPImage->SetVisible( false );
+
+		if ( playerDisplay.pMVPCountLabel != NULL )
+			playerDisplay.pMVPCountLabel->SetVisible( false );
+
+		if ( playerDisplay.pSelect != NULL )
+			playerDisplay.pSelect->SetVisible( false );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates the spectator list
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::UpdateSpectatorList()
+{
+	if ( g_PR == NULL )
+	{
+		return;
+	}
+
+	const int listTextLen = 100;
+	wchar_t listText[listTextLen];
+	listText[0] = L'\0';
+
+	const wchar_t *delimText = L", ";
+	const int delimTextLen = V_wcslen( delimText );
+
+	// Count the number of spectators and build up a list.
+	int nSpectators = 0;
+	for ( int playerIndex = 1 ; playerIndex <= MAX_PLAYERS; ++playerIndex )
+	{
+		if ( ShouldShowAsSpectator( playerIndex ) )
+		{
+			const char *playerName = g_PR->GetPlayerName( playerIndex );
+			if ( playerName != NULL )
+			{
+				// Convert the name to wide char.
+				wchar_t playerBuf[MAX_PLAYER_NAME_LENGTH];
+				playerBuf[0] = L'\0';
+				V_UTF8ToUnicode( playerName, playerBuf, sizeof( playerBuf ) );
+
+				//
+				// Check to see if there is space for the player name and delimiter.
+				//
+
+				bool addDelim = ( nSpectators > 0 );
+
+				int playerNameLen = V_wcslen( playerBuf );
+				if ( addDelim )
+				{
+					playerNameLen += delimTextLen;
+				}
+
+				int currentLen = V_wcslen( listText );
+				int remainingLen = listTextLen - currentLen - playerNameLen - 1;
+				if ( remainingLen >= 0 )
+				{
+					// Append the delimiter.
+					if ( addDelim )
+					{
+						V_wcscat_safe( listText, delimText );
+					}
+
+					// Append the player name.
+					V_wcscat_safe( listText, playerBuf );
+				}
+			}
+
+			++nSpectators;
+		}
+	}
+
+	wchar_t labelText[512];
+	labelText[0] = L'\0';
+
+	if ( nSpectators == 0 )
+	{
+		// No spectators.
+		wchar_t *noSpectators = g_pVGuiLocalize->Find( "#Cstrike_Scoreboard_NoSpectators" );
+		if ( noSpectators != NULL )
+		{
+			V_wcsncpy( labelText, noSpectators, sizeof( labelText ) );
+		}
+	}
+	else
+	{
+		// Build the text for the number of spectators.
+		const int countTextLen = 16;
+		wchar_t countText[countTextLen];
+		countText[0] = L'\0';
+		V_snwprintf( countText, countTextLen, L"%i", nSpectators );
+		countText[countTextLen - 1] = L'\0';
+
+		// Build the combined count and spectator list text.
+		wchar_t *formatLabel = g_pVGuiLocalize->Find( ( nSpectators == 1 ) ? "#Cstrike_Scoreboard_Spectator" : "#Cstrike_Scoreboard_Spectators" );
+		if ( formatLabel != NULL )
+		{
+			g_pVGuiLocalize->ConstructString( labelText, sizeof( labelText ), formatLabel, 2, countText, listText );
+		}
+	}
+
+	SetDialogVariable( "spectators", labelText );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Display the number of HLTV viewers
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::UpdateHLTVList( void )
+{
+	// Build the text for the number of viewers.
+	const int countTextLen = 16;
+	wchar_t countText[countTextLen];
+	countText[0] = L'\0';
+	V_snwprintf( countText, countTextLen, L"%i", m_HLTVSpectators );
+	countText[countTextLen - 1] = L'\0';
+
+	// Build the combined text.
+	wchar_t labelText[512];
+	labelText[0] = L'\0';
+	wchar_t *formatLabel = g_pVGuiLocalize->Find( "#Cstrike_Scoreboard_HLTV" );
+	if ( formatLabel != NULL )
+	{
+		g_pVGuiLocalize->ConstructString( labelText, sizeof( labelText ), formatLabel, 1, countText );
+	}
+
+	SetDialogVariable( "sourcetv", labelText );
+}
+
+/**
+*	Special processing for MVP UI elements
+*/
+void CCSClientScoreBoardDialog::UpdateMvpElements()
+{
+	C_CS_PlayerResource *cs_PR = dynamic_cast<C_CS_PlayerResource *>( g_PR );
+	if ( cs_PR == NULL )
+	{
+		return;
+	}
+
+	for ( int teamIndex = TEAM_TERRORIST; teamIndex <= TEAM_CT; ++teamIndex )
+	{
+		TeamDisplayInfo& teamDisplay = ( teamIndex == TEAM_TERRORIST ) ? m_teamDisplayT : m_teamDisplayCT;
+
+		for ( int i = 0; i < cMaxScoreLines && i < teamDisplay.playerScores.Count(); ++i )
+		{
+			PlayerDisplay& playerDisplay = teamDisplay.playerDisplay[i];
+
+			// Get the player index.
+			int playerIndex = -1;
+			if ( teamDisplay.playerScores[i] != NULL )
+			{
+				playerIndex = teamDisplay.playerScores[i]->playerIndex;
+			}
+
+			if ( playerIndex == -1 )
+				continue;
+
+			// early out fail conditions
+			if ( playerDisplay.pNameLabel == NULL || playerDisplay.pMVPImage == NULL || playerDisplay.pMVPCountLabel == NULL )
+				continue;
+
+			// Get the number of MVPs and cap it.
+			int numMVPs = MIN( kMaxMVPCount, cs_PR->GetNumMVPs( playerIndex ) );
+
+			// No MVPs.
+			if ( numMVPs == 0 )
+			{
+				playerDisplay.pMVPImage->SetVisible( false );
+				playerDisplay.pMVPCountLabel->SetVisible( false );
+				continue;
+			}
+
+			// Get the dimensions of the player label.
+			int xName = 0;
+			int yName = 0;
+			int wideName = 0;
+			int tallName = 0;
+			playerDisplay.pNameLabel->GetBounds( xName, yName, wideName, tallName );
+
+			wchar_t playerName[64];
+			playerDisplay.pNameLabel->GetText( playerName, sizeof(playerName) );
+
+			// Find the actual width of the rendered player name.
+			int actualWideName = 0;
+			int actualTallName = 0;
+			g_pMatSystemSurface->GetTextSize( playerDisplay.pNameLabel->GetFont(), playerName, actualWideName, actualTallName );
+			if ( actualWideName > wideName )
+			{
+				actualWideName = wideName;
+			}
+
+			// Get the dimensions of the mvp image.
+			int xMVPImage = 0;
+			int yMVPImage = 0;
+			int wideMVPImage = 0;
+			int tallMVPImage = 0;
+			playerDisplay.pMVPImage->GetBounds( xMVPImage, yMVPImage, wideMVPImage, tallMVPImage );
+
+			// The MVP label is hidden for only one star.
+			bool showMVPNumber = ( numMVPs > 1 );
+
+			// Set the MVP label text and get the actual size.
+			int actualWideMVPLabel = 0;
+			if ( showMVPNumber )
+			{
+				const int mvpTextSize = 8;
+				wchar_t mvpText[mvpTextSize];
+				V_snwprintf( mvpText, ARRAYSIZE( mvpText ), L"%i", numMVPs );
+				playerDisplay.pMVPCountLabel->SetText( mvpText );
+				playerDisplay.pMVPCountLabel->SetVisible( true );
+
+				int actualTallMVPLabel = 0;
+				g_pMatSystemSurface->GetTextSize( playerDisplay.pMVPCountLabel->GetFont(), mvpText, actualWideMVPLabel, actualTallMVPLabel );
+			}
+
+			// Calculate the total width of the mvp stuff.
+			int wideMVPTotal = wideMVPImage;
+			if ( showMVPNumber )
+			{
+				wideMVPTotal += actualWideMVPLabel;
+			}
+
+			// Calculate the optimal place for the mvp.
+			int x = xName + actualWideName + m_MVPXOffset;
+
+			// Get the position of the status image.
+			if ( playerDisplay.pStatusImage )
+			{
+				int xStatus = 0;
+				int yStatus = 0;
+				playerDisplay.pStatusImage->GetPos( xStatus, yStatus );
+
+				if ( x + wideMVPTotal > xStatus )
+				{
+					// Don't run over the status image. Back up.
+					x = xStatus - wideMVPTotal;
+				}
+			}
+
+			playerDisplay.pMVPImage->SetPos( x, yMVPImage );
+			playerDisplay.pMVPImage->SetVisible( true );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether the specified player index is a spectator
+//-----------------------------------------------------------------------------
+bool CCSClientScoreBoardDialog::ShouldShowAsSpectator( int iPlayerIndex )
+{
+    C_CS_PlayerResource *cs_PR = dynamic_cast<C_CS_PlayerResource *>( g_PR );
+    if ( !cs_PR )
+        return false;
+
+    // see if player is connected
+    if ( cs_PR->IsConnected( iPlayerIndex ) ) 
+    {
+        // either spectator or unassigned team should show in spectator list
+        int iTeam = cs_PR->GetTeam( iPlayerIndex );
+        if ( TEAM_SPECTATOR == iTeam || TEAM_UNASSIGNED == iTeam )
+            return true;
+    }
+    return false;
+}
+
+
+void CCSClientScoreBoardDialog::FireGameEvent( IGameEvent *event )
+{
+	if ( event == NULL )
+		return;
+
+    const char *pEventName = event->GetName();
+	if ( pEventName == NULL )
+		return;
+
+    if ( Q_strcmp( pEventName, "server_spawn" ) == 0 )
+    {
+        // set server name in scoreboard
+        const char *hostname = event->GetString( "hostname" );
+		if ( hostname != NULL )
+		{
+			wchar_t wzHostName[256];
+			g_pVGuiLocalize->ConvertANSIToUnicode( hostname, wzHostName, sizeof( wzHostName ) );
+			g_pVGuiLocalize->ConstructString( m_pServerName, sizeof(m_pServerName), g_pVGuiLocalize->Find( "#Cstrike_SB_Server" ), 1, wzHostName );
+
+			if ( m_pServerLabel )
+			{
+				m_pServerLabel->SetText( m_pServerName );
+			}
+
+			if ( m_gameOver )
+			{
+				ResetFromGameOverState();
+			}
+
+			// Save the server name for use after this panel is reconstructed
+			if ( g_pClientMode )
+			{
+				g_pClientMode->SetServerName( m_pServerName );
+			}
+		}
+    }
+    else if ( Q_strcmp( pEventName, "game_newmap" ) == 0 )
+    {
+        const char *mapName = event->GetString( "mapname" );
+		if ( mapName != NULL )
+		{
+			g_pVGuiLocalize->ConvertANSIToUnicode( mapName, m_pMapName, sizeof( m_pMapName ) );
+			SetDialogVariable( "mapname", m_pMapName );
+
+			if ( m_gameOver )
+			{
+				ResetFromGameOverState();
+			}
+
+			// Save the map name for use after this panel is reconstructed
+			if ( g_pClientMode )
+			{
+				g_pClientMode->SetMapName( m_pMapName );
+			}
+		}
+    }
+    else if ( Q_strcmp( pEventName, "match_end_conditions" ) == 0 )
+    {
+        UpdateMatchEndText();
+    }
+    else if ( Q_strcmp( pEventName, "cs_win_panel_match" ) == 0 )
+    {
+        m_gameOver = true;
+        UpdateMatchEndText();
+    }
+
+	BaseClass::FireGameEvent( event );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a new row to the scoreboard, from the playerinfo structure
+//-----------------------------------------------------------------------------
+bool CCSClientScoreBoardDialog::GetPlayerScoreInfo( int playerIndex, PlayerScoreInfo& playerScoreInfo )
+{
+	if ( g_PR == NULL )
+		return false;
+
+    // Clean up the player name
+    const char *oldName = g_PR->GetPlayerName( playerIndex );
+	if ( oldName == NULL )
+		return false;
+
+	playerScoreInfo.szName = g_PR->GetPlayerName( playerIndex );
+
+    playerScoreInfo.playerIndex = playerIndex;
+    playerScoreInfo.frags = g_PR->GetPlayerScore( playerIndex );
+    playerScoreInfo.deaths = g_PR->GetDeaths( playerIndex );
+
+    if ( g_PR->GetPing( playerIndex ) < 1 )
+    {
+        if ( g_PR->IsFakePlayer( playerIndex ) )
+        {
+			playerScoreInfo.ping = -1;
+        }
+        else
+        {
+			playerScoreInfo.ping = 0;
+        }
+    }
+    else
+    {
+		playerScoreInfo.ping = g_PR->GetPing( playerIndex );
+    }
+
+    // get CS specific infos
+    C_CS_PlayerResource *cs_PR = dynamic_cast<C_CS_PlayerResource *>( g_PR );
+
+    C_CSPlayer *pLocalPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+    if ( !cs_PR || !pLocalPlayer )
+	{
+        return false;
+	}
+
+	// Get the clan tag
+	playerScoreInfo.szClanTag = cs_PR->GetClanTag( playerIndex );
+
+    bool bShowExtraInfo = 
+        ( pLocalPlayer->GetTeamNumber() == TEAM_UNASSIGNED ) || // we're not spawned yet
+        ( pLocalPlayer->GetTeamNumber() == TEAM_SPECTATOR ) || // we are a spectator
+        ( pLocalPlayer->IsPlayerDead() && mp_forcecamera.GetInt() == OBS_ALLOW_ALL ) ||	 // we are dead and allowed to spectate opponents
+        ( pLocalPlayer->GetTeamNumber() == g_PR->GetTeam( playerIndex ) ); // we're on the same team
+
+	playerScoreInfo.szStatus = NULL;
+	playerScoreInfo.bStatusPlayerColor = false;
+
+	// set the status icon; lowest priority icons are tested first, and highest last
+
+	if ( cs_PR->IsVIP( playerIndex ) && bShowExtraInfo )
+	{
+		playerScoreInfo.szStatus = "../hud/scoreboard_clock";
+		playerScoreInfo.bStatusPlayerColor = true;
+	}
+
+	if ( !g_PR->IsAlive( playerIndex ) && g_PR->GetTeam( playerIndex ) > TEAM_SPECTATOR )
+	{
+		playerScoreInfo.szStatus = "../hud/scoreboard_dead";
+	}
+
+    if ( g_PR->IsHLTV( playerIndex ) )
+    {
+//         // show #spectators in class field, it's transmitted as player's score
+//         char numspecs[32];
+//         Q_snprintf( numspecs, sizeof( numspecs ), "%i Spectators", m_HLTVSpectators );
+//         kv->SetString( "class", numspecs );
+    }
+
+    // Set the dominated icon
+	if ( pLocalPlayer->IsPlayerDominatingMe( playerIndex ) )
+	{
+		if ( g_PR->IsAlive( playerIndex ) )
+		{
+			playerScoreInfo.szStatus = "../hud/scoreboard_nemesis";
+		}
+		else
+		{
+			playerScoreInfo.szStatus = "../hud/scoreboard_nemesis-dead";
+		}
+	}
+
+	if ( pLocalPlayer->IsPlayerDominated(playerIndex) )
+	{
+		if ( g_PR->IsAlive( playerIndex ) )
+		{
+			playerScoreInfo.szStatus = "../hud/scoreboard_dominated";
+		}
+		else
+		{
+			playerScoreInfo.szStatus = "../hud/scoreboard_domination-dead";
+		}
+	}
+
+	if ( cs_PR->HasC4( playerIndex ) && bShowExtraInfo )
+	{
+ 		playerScoreInfo.szStatus = "../hud/scoreboard_bomb";
+		playerScoreInfo.bStatusPlayerColor = true;
+	}
+
+	if ( cs_PR->HasDefuser( playerIndex ) && bShowExtraInfo )
+	{
+		playerScoreInfo.szStatus = "../hud/scoreboard_defuser";
+		playerScoreInfo.bStatusPlayerColor = true;
+	}
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates the time/round remaining display and server and map name
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::UpdateMatchEndText()
+{
+	// Hide the win condition.
+	if ( m_pWinConditionLabel )
+	{
+		m_pWinConditionLabel->SetVisible( false );
+	}
+
+	// Hide the clock.
+	if ( m_pClockLabel )
+	{
+		m_pClockLabel->SetVisible( false );
+	}
+
+	if ( !m_gameOver )
+	{
+		SetDialogVariable( "mapname", m_pMapName );
+
+		wchar_t wzMatchEndCausesLabel[128], wzMatchEndCause[32];
+
+		// Time limit
+		if ( mp_timelimit.GetInt() != 0 )
+		{
+			int timeTillEndOfMatch = CSGameRules()->GetMapRemainingTime();
+			bool showTime = ( timeTillEndOfMatch != -1 );
+			if ( showTime )
+			{
+				if ( m_pWinConditionLabel )
+				{
+					V_snwprintf( wzMatchEndCause, ARRAYSIZE( wzMatchEndCause ), L"%.2i:%.2i", timeTillEndOfMatch / 60, timeTillEndOfMatch % 60 );
+					g_pVGuiLocalize->ConstructString( wzMatchEndCausesLabel, sizeof( wzMatchEndCausesLabel ),
+						g_pVGuiLocalize->Find( "#Cstrike_Time_LeftVariable" ), 1, wzMatchEndCause );
+					m_pWinConditionLabel->SetText( wzMatchEndCausesLabel );
+					m_pWinConditionLabel->SetVisible( true );
+				}
+
+				if ( m_pClockLabel )
+				{
+					m_pClockLabel->SetVisible( true );
+				}
+			}
+		}
+		// Round limit
+		else if ( mp_maxrounds.GetInt() != 0 )
+		{
+			if ( m_pWinConditionLabel )
+			{
+				// Get the number of rounds played.
+				int roundsPlayed = 0;
+				for ( int teamIndex = TEAM_TERRORIST; teamIndex <= TEAM_CT; teamIndex++ )
+				{
+					C_Team *team = GetGlobalTeam( teamIndex );
+					if ( team )
+					{
+						roundsPlayed += team->Get_Score();
+					}
+				}
+
+				V_snwprintf( wzMatchEndCause, ARRAYSIZE( wzMatchEndCause ), L"%d", mp_maxrounds.GetInt() - roundsPlayed );
+				g_pVGuiLocalize->ConstructString( wzMatchEndCausesLabel, sizeof( wzMatchEndCausesLabel ),
+					g_pVGuiLocalize->Find( "#Cstrike_Rounds_LeftVariable" ), 1, wzMatchEndCause );
+				m_pWinConditionLabel->SetText( wzMatchEndCausesLabel );
+				m_pWinConditionLabel->SetVisible( true );
+			}
+		}
+		// Win limit
+		else if ( mp_winlimit.GetInt() != 0 )
+		{
+			if ( m_pWinConditionLabel )
+			{
+				V_snwprintf( wzMatchEndCause, ARRAYSIZE( wzMatchEndCause ), L"%d", mp_winlimit.GetInt() );
+				g_pVGuiLocalize->ConstructString( wzMatchEndCausesLabel, sizeof( wzMatchEndCausesLabel ),
+					g_pVGuiLocalize->Find( "#Cstrike_Wins_NeededVariable" ), 1, wzMatchEndCause );
+				m_pWinConditionLabel->SetText( wzMatchEndCausesLabel );
+				m_pWinConditionLabel->SetVisible( true );
+			}
+		}
+	}
+}
+
+// Resets all changes made by the scoreboard's state at the match end
+void CCSClientScoreBoardDialog::ResetFromGameOverState()
+{
+    m_gameOver = false;
+
+    if ( m_pLabelMapName )
+    {
+        m_pLabelMapName->SetVisible( true );
+    }
+
+    UpdateMatchEndText();
+}
+
+// [tj] We hook into the show command so we can lock or unlock all the elements that need to be hidden
+//
+// [pfreese] This used to enable/disable keyboard input, but since the scoreboard is now a popup, we have
+// to leave the keyboard disabled
+void CCSClientScoreBoardDialog::ShowPanel( bool state )
+{
+    BaseClass::ShowPanel(state);
+
+    int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "hide_for_scoreboard" );
+
+    if ( state )
+    {	
+        gHUD.LockRenderGroup( iRenderGroup );
+    }
+    else
+    {		
+        gHUD.UnlockRenderGroup( iRenderGroup );
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Grabs the player data colors from the convars.
+//-----------------------------------------------------------------------------
+void CCSClientScoreBoardDialog::UpdatePlayerColors( void )
+{
+	m_teamDisplayT.playerDataColor.SetColor( cl_scoreboard_t_color_red.GetInt(), cl_scoreboard_t_color_green.GetInt(), cl_scoreboard_t_color_blue.GetInt(), 255 );
+	m_teamDisplayCT.playerDataColor.SetColor( cl_scoreboard_ct_color_red.GetInt(), cl_scoreboard_ct_color_green.GetInt(), cl_scoreboard_ct_color_blue.GetInt(), 255 );
+	m_DeadPlayerDataColor.SetColor( cl_scoreboard_dead_color_red.GetInt(), cl_scoreboard_dead_color_green.GetInt(), cl_scoreboard_dead_color_blue.GetInt(), 255 );
+	m_teamDisplayT.playerClanColor.SetColor( cl_scoreboard_clan_t_color_red.GetInt(), cl_scoreboard_clan_t_color_green.GetInt(), cl_scoreboard_clan_t_color_blue.GetInt(), 255 );
+	m_teamDisplayCT.playerClanColor.SetColor( cl_scoreboard_clan_ct_color_red.GetInt(), cl_scoreboard_clan_ct_color_green.GetInt(), cl_scoreboard_clan_ct_color_blue.GetInt(), 255 );
+	m_DeadPlayerClanColor.SetColor( cl_scoreboard_dead_clan_color_red.GetInt(), cl_scoreboard_dead_clan_color_green.GetInt(), cl_scoreboard_dead_clan_color_blue.GetInt(), 255 );
+}
+
+// [tj] Disabling joystick input if you are dead.
+void CCSClientScoreBoardDialog::OnThink()
+{
+    BaseClass::OnThink();
+
+#ifdef _XBOX
+    C_CSPlayer *pLocalPlayer = C_CSPlayer::GetLocalCSPlayer();
+    if ( pLocalPlayer )
+    {
+        bool mouseEnabled = IsMouseInputEnabled();
+        if (pLocalPlayer->IsAlive() == mouseEnabled)
+        {
+            SetMouseInputEnabled( !mouseEnabled );
+        }
+    }
+#endif
+}
+
+bool CCSClientScoreBoardDialog::ForceLocalPlayerVisible( TeamDisplayInfo& teamDisplay )
+{
+	int iLocalPlayerIndex = GetLocalPlayerIndex();
+
+	// Look for the local player in the non-visible portion of the member list
+	for (int i = teamDisplay.maxPlayersVisible; i < teamDisplay.playerScores.Count(); ++i)
+	{
+		PlayerScoreInfo*  pPlayerScore = teamDisplay.playerScores[i];
+		Assert(pPlayerScore != NULL);
+
+		// Determine if this is the local player's entry
+		if ( pPlayerScore->playerIndex == iLocalPlayerIndex )
+		{
+			// Remove the local player entry from the current position
+			teamDisplay.playerScores.Remove(i);
+
+			// Re-insert the local player entry at the end of the visible list
+			teamDisplay.playerScores.InsertBefore( teamDisplay.maxPlayersVisible - 1, pPlayerScore );
+
+			return true;
+		}
+	}
+	return false;
+}
diff --git a/game/client/cstrike/VGUI/cstrikeclientscoreboard.h b/game/client/cstrike/VGUI/cstrikeclientscoreboard.h
new file mode 100644
index 00000000..2a2e4098
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikeclientscoreboard.h
@@ -0,0 +1,153 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSTRIKECLIENTSCOREBOARDDIALOG_H
+#define CSTRIKECLIENTSCOREBOARDDIALOG_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <clientscoreboarddialog.h>
+#include <vgui_controls/ImagePanel.h>
+#include "cs_shareddefs.h"
+#include <vgui_controls/Frame.h>
+#include "vgui_avatarimage.h"
+
+
+const int cMaxScoreLines = 32;  // This value must be > 2
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Game ScoreBoard
+//-----------------------------------------------------------------------------
+class CCSClientScoreBoardDialog : public CClientScoreBoardDialog
+{
+private:
+    DECLARE_CLASS_SIMPLE( CCSClientScoreBoardDialog, CClientScoreBoardDialog );
+
+public:
+    CCSClientScoreBoardDialog( IViewPort *pViewPort );
+    ~CCSClientScoreBoardDialog();
+
+    virtual void Update();
+
+    // vgui overrides for rounded corner background
+    void UpdateMvpElements();
+    virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+	virtual void ResetFromGameOverState();
+
+    // [tj] Hook in here to hide other UI
+    virtual void ShowPanel( bool state ); 
+
+    // [tj] So we can do processing every frame
+    virtual void OnThink();
+
+protected:
+
+	struct PlayerScoreInfo
+	{
+		const char*		szName;
+		const char*		szClanTag;
+		int				playerIndex;
+		int				frags;
+		int				deaths;
+		int				ping;
+		const char*		szStatus;
+		bool			bStatusPlayerColor;
+	};
+
+	struct PlayerDisplay
+	{
+		vgui::Label*			pNameLabel;
+		vgui::Label*			pClanLabel;
+		vgui::Label*			pScoreLabel;
+		vgui::Label*			pDeathsLabel;
+		vgui::Label*			pPingLabel;
+		vgui::Label*			pMVPCountLabel;
+		CAvatarImagePanel*		pAvatar;
+		vgui::ImagePanel*		pStatusImage;
+		vgui::ImagePanel*		pMVPImage;
+		vgui::ImagePanel*		pSelect;
+	};
+
+	struct TeamDisplayInfo
+	{
+		Color					playerDataColor;
+		Color					playerClanColor;
+		PlayerDisplay			playerDisplay[cMaxScoreLines];
+		CUtlVector<PlayerScoreInfo*>  playerScores;		// For sorting team members outside of the listboxes
+		int						scoreAreaInnerHeight;
+		int						scoreAreaLineHeight;
+		int						scoreAreaLinePreferredLeading;
+		int						scoreAreaStartY;
+		int						scoreAreaMinX;
+		int						scoreAreaMaxX;
+		int						maxPlayersVisible;
+	};
+
+	bool GetPlayerScoreInfo( int playerIndex, PlayerScoreInfo& playerScoreInfo );
+	void UpdateTeamPlayerDisplay( TeamDisplayInfo& teamDisplay );
+	void SetupTeamDisplay( TeamDisplayInfo& teamDisplay, const char* szTeamPrefix );
+
+	void UpdateTeamInfo();
+	void UpdatePlayerList();
+
+	bool ForceLocalPlayerVisible( TeamDisplayInfo& teamDisplay );
+	void UpdateSpectatorList();
+	void UpdateHLTVList( void );
+	void UpdateMatchEndText();
+
+	bool ShouldShowAsSpectator( int iPlayerIndex );
+	void FireGameEvent( IGameEvent *event );
+
+	void UpdatePlayerColors( void );
+	void AdjustFontToFit( const char *pString, vgui::Label *pLabel );
+
+	static int PlayerSortFunction( PlayerScoreInfo* const* pPS1, PlayerScoreInfo* const* pPS2 );
+
+private:
+    vgui::HFont					m_listItemFont;
+    vgui::HFont                 m_listItemFontSmaller;
+    vgui::HFont                 m_listItemFontSmallest;
+    vgui::HFont                 m_MVPFont;
+
+    int			m_iImageDead;
+    int			m_iImageMVP; // Not used in the section list explicitly.  Drawn over it
+    int			m_iImageDominated;
+    int			m_iImageNemesis;
+    int			m_iImageBomb;
+    int			m_iImageVIP;
+    int			m_iImageFriend;
+    int         m_iImageNemesisDead;
+    int         m_iImageDominationDead;
+
+	Color			m_DeadPlayerDataColor;
+	Color			m_PlayerDataBgColor;
+	Color			m_DeadPlayerClanColor;
+
+	vgui::Label*	m_pWinConditionLabel;
+	vgui::Label*	m_pClockLabel;
+	vgui::Label*	m_pLabelMapName;
+	vgui::Label*	m_pServerLabel;
+
+    bool			m_gameOver;
+
+    wchar_t			m_pMapName[256];
+    wchar_t			m_pServerName[256];
+    wchar_t			m_pStatsEnabled[256];
+    wchar_t			m_pStatsDisabled[256];
+
+    int m_LocalPlayerItemID;
+	int m_MVPXOffset;
+
+	TeamDisplayInfo	m_teamDisplayT;
+	TeamDisplayInfo	m_teamDisplayCT;
+};
+
+
+#endif // CSTRIKECLIENTSCOREBOARDDIALOG_H
diff --git a/game/client/cstrike/VGUI/cstrikespectatorgui.cpp b/game/client/cstrike/VGUI/cstrikespectatorgui.cpp
new file mode 100644
index 00000000..9c633c1d
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikespectatorgui.cpp
@@ -0,0 +1,2324 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cstrikespectatorgui.h"
+#include "hud.h"
+#include "cs_shareddefs.h"
+
+#include <vgui/ILocalize.h>
+#include <vgui/ISurface.h>
+#include <filesystem.h>
+#include "cs_gamerules.h"
+#include "c_team.h"
+#include "c_cs_playerresource.h"
+#include "c_plantedc4.h"
+#include "c_cs_hostage.h"
+#include "vtf/vtf.h"
+#include "clientmode.h"
+#include <vgui_controls/AnimationController.h>
+#include "voice_status.h"
+#include "hud_radar.h"
+
+using namespace vgui;
+DECLARE_HUDELEMENT( CCSMapOverview )
+
+extern ConVar overview_health;
+extern ConVar overview_names;
+extern ConVar overview_tracks;
+extern ConVar overview_locked;
+extern ConVar overview_alpha;
+extern ConVar cl_radaralpha;
+ConVar cl_radar_locked( "cl_radar_locked", "0", FCVAR_ARCHIVE, "Lock the angle of the radar display?" );
+
+void PreferredOverviewModeChanged( IConVar *pConVar, const char *oldString, float flOldValue )
+{
+	ConVarRef var( pConVar );
+	char cmd[32];
+	V_snprintf( cmd, sizeof( cmd ), "overview_mode %d\n", var.GetInt() );
+	engine->ClientCmd( cmd );
+}
+ConVar overview_preferred_mode( "overview_preferred_mode", "1", FCVAR_ARCHIVE, "Preferred overview mode", PreferredOverviewModeChanged );
+
+ConVar overview_preferred_view_size( "overview_preferred_view_size", "600", FCVAR_ARCHIVE, "Preferred overview view size" );
+
+#define HOSTAGE_RESCUE_DURATION (2.5f)
+#define BOMB_FADE_DURATION (2.5f)
+#define DEATH_ICON_FADE (7.5f)
+#define DEATH_ICON_DURATION (10.0f)
+#define LAST_SEEN_ICON_DURATION (4.0f)
+#define DIFFERENCE_THRESHOLD (200.0f)
+
+// To make your own green radar file from the map overview file, turn this on, and include vtf.lib
+#define no_GENERATE_RADAR_FILE
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSSpectatorGUI::CCSSpectatorGUI(IViewPort *pViewPort) : CSpectatorGUI(pViewPort)
+{
+	m_pCTLabel =	NULL;
+	m_pCTScore =	NULL;
+	m_pTerLabel =	NULL;
+	m_pTerScore =	NULL;
+	m_pTimer =		NULL;
+	m_pTimerLabel =	NULL;
+	m_pDivider =	NULL;
+	m_pExtraInfo =	NULL;
+
+	m_modifiedWidths = false;
+
+	m_scoreWidth = 0;
+	m_extraInfoWidth = 0;
+
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSSpectatorGUI::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	// Grab some control pointers
+	m_pCTLabel =	dynamic_cast<Label *>(FindChildByName("CTScoreLabel"));
+	m_pCTScore =	dynamic_cast<Label *>(FindChildByName("CTScoreValue"));
+	m_pTerLabel =	dynamic_cast<Label *>(FindChildByName("TerScoreLabel"));
+	m_pTerScore =	dynamic_cast<Label *>(FindChildByName("TerScoreValue"));
+
+	m_pTimer =		dynamic_cast<Label *>(FindChildByName("timerclock"));
+	m_pTimerLabel =	dynamic_cast<Label *>(FindChildByName("timerlabel"));
+
+	m_pDivider =	dynamic_cast<Panel *>(FindChildByName("DividerBar"));
+
+	m_pExtraInfo =	dynamic_cast<Label *>(FindChildByName("extrainfo"));
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resets the list of players
+//-----------------------------------------------------------------------------
+void CCSSpectatorGUI::UpdateSpectatorPlayerList()
+{
+	C_Team *cts = GetGlobalTeam( TEAM_CT );
+	if ( cts )
+	{
+		wchar_t frags[ 10 ];
+		_snwprintf( frags, ARRAYSIZE( frags ), L"%i",  cts->Get_Score()  );
+
+		SetLabelText( "CTScoreValue", frags );
+	}
+
+	C_Team *ts = GetGlobalTeam( TEAM_TERRORIST );
+	if ( ts )
+	{
+		wchar_t frags[ 10 ];
+		_snwprintf( frags, ARRAYSIZE( frags ), L"%i", ts->Get_Score()  );
+		
+		SetLabelText( "TERScoreValue", frags );
+	}
+}
+
+bool CCSSpectatorGUI::NeedsUpdate( void )
+{
+	C_CSPlayer *player = C_CSPlayer::GetLocalCSPlayer();
+	if ( !player )
+		return false;
+
+	if ( m_nLastAccount != player->GetAccount() )
+		return true;
+
+	if ( m_nLastTime != (int)CSGameRules()->GetRoundRemainingTime() )
+		return true;
+
+	if ( m_nLastSpecMode != player->GetObserverMode() )
+		return true;
+
+	if ( m_nLastSpecTarget != player->GetObserverTarget() )
+		return true;
+
+	return BaseClass::NeedsUpdate();
+}
+
+//=============================================================================
+// HPE_BEGIN:
+// [smessick]
+//=============================================================================
+void CCSSpectatorGUI::ShowPanel( bool bShow )
+{
+	BaseClass::ShowPanel( bShow );
+
+	if ( bShow )
+	{
+		// Resend the overview command.
+		char cmd[32];
+		V_snprintf( cmd, sizeof( cmd ), "overview_mode %d\n", overview_preferred_mode.GetInt() );
+		engine->ClientCmd( cmd );
+	}
+}
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates the timer label if one exists
+//-----------------------------------------------------------------------------
+void CCSSpectatorGUI::UpdateTimer()
+{
+	// these could be NULL if players modified the UI
+	if ( !ControlsPresent() )
+		return;
+
+	Color timerColor = m_pTimer->GetFgColor();
+	if( g_PlantedC4s.Count() > 0 )
+	{
+		m_pTimer->SetText( "\\" ); // bomb icon  
+		m_pTimerLabel->SetVisible( false );
+
+		if( g_PlantedC4s[0]->m_flNextGlow > gpGlobals->curtime + 0.1f )
+			timerColor[3] = 80;
+		else
+			timerColor[3] = 255;
+
+		m_pTimer->SetFgColor( timerColor );
+		return;
+	}
+
+	timerColor[3] = 255;
+	m_pTimer->SetFgColor( timerColor );
+	m_pTimer->SetText( "e" ); // clock icon
+	
+	m_nLastTime = (int)( CSGameRules()->GetRoundRemainingTime() );
+
+	if ( m_nLastTime < 0 )
+		 m_nLastTime  = 0;
+
+	wchar_t szText[ 63 ];
+	_snwprintf ( szText, ARRAYSIZE( szText ), L"%d:%02d", (m_nLastTime / 60), (m_nLastTime % 60) );
+	szText[62] = 0;
+
+	SetLabelText("timerlabel", szText );
+	m_pTimerLabel->SetVisible( true );
+}
+
+void CCSSpectatorGUI::UpdateAccount()
+{
+	C_CSPlayer *player = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( !player )
+		return;
+
+	m_nLastAccount = player->GetAccount();
+
+	if ( (player->GetTeamNumber() == TEAM_TERRORIST) || (player->GetTeamNumber() == TEAM_CT) )
+	{
+		wchar_t szText[ 63 ];
+		_snwprintf ( szText, ARRAYSIZE( szText ), L"$%i", m_nLastAccount );
+		szText[62] = 0;
+
+		SetLabelText( "extrainfo", szText );
+	}
+}
+
+
+/*bool CCSSpectatorGUI::CanSpectateTeam( int iTeam )
+{
+	bool bRetVal = true;
+	int iTeamOnly = 0;// TODO = gCSViewPortInterface->GetForceCamera();
+
+	// if we're not a spectator or HLTV and iTeamOnly is set
+	if ( C_BasePlayer::GetLocalPlayer()->GetTeamNumber() // && !gEngfuncs.IsSpectateOnly() 
+	&& iTeamOnly )
+	{
+		// then we want to force the same team
+		if ( C_BasePlayer::GetLocalPlayer()->GetTeamNumber() != iTeam )
+		{
+			bRetVal = false;
+		}
+	}
+
+	return bRetVal;
+}*/
+
+void CCSSpectatorGUI::Update()
+{
+	BaseClass::Update();
+	
+	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+
+	if( pLocalPlayer )
+	{
+		m_nLastSpecMode = pLocalPlayer->GetObserverMode();
+		m_nLastSpecTarget = pLocalPlayer->GetObserverTarget();
+	}
+
+	UpdateTimer();
+
+	UpdateAccount();
+
+	UpdateSpectatorPlayerList();
+
+	if ( pLocalPlayer )
+	{
+		ResizeControls();
+	}
+
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Save off widths for sizing calculations
+//-----------------------------------------------------------------------------
+void CCSSpectatorGUI::StoreWidths( void )
+{
+	if ( !ControlsPresent() )
+		return;
+
+	if ( !m_modifiedWidths )
+	{
+		m_scoreWidth = m_pCTScore->GetWide();
+		int terScoreWidth = m_pTerScore->GetWide();
+
+		m_extraInfoWidth = m_pExtraInfo->GetWide();
+
+		if ( m_scoreWidth != terScoreWidth )
+		{
+			m_pTerScore = NULL; // We're working with a modified res file.  Don't muck things up playing with positioning.
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Resize controls so scores & map names are not cut off
+//-----------------------------------------------------------------------------
+void CCSSpectatorGUI::ResizeControls( void )
+{
+	if ( !ControlsPresent() )
+		return;
+
+	int x1, y1, w1, t1;
+	int x2, y2, w2, t2;
+
+	StoreWidths();
+
+	// ensure scores are wide enough
+	int wCT, hCT, wTer, hTer;
+	m_pCTScore->GetBounds( x1, y1, w1, t1 );
+	m_pCTScore->GetContentSize( wCT, hCT );
+	m_pTerScore->GetBounds( x2, y2, w2, t2 );
+	m_pTerScore->GetContentSize( wTer, hTer );
+	
+	int desiredScoreWidth = m_scoreWidth;
+	desiredScoreWidth = MAX( desiredScoreWidth, wCT );
+	desiredScoreWidth = MAX( desiredScoreWidth, wTer );
+
+	int diff = desiredScoreWidth - w1;
+	if ( diff != 0 )
+	{
+		m_pCTScore->GetBounds( x1, y1, w1, t1 );
+		m_pCTScore->SetBounds( x1 - diff, y1, w1 + diff, t1 );
+
+		m_pTerScore->GetBounds( x1, y1, w1, t1 );
+		m_pTerScore->SetBounds( x1 - diff, y1, w1 + diff, t1 );
+
+		m_pCTLabel->GetPos( x1, y1 );
+		m_pCTLabel->SetPos( x1 - diff, y1 );
+
+		m_pTerLabel->GetPos( x1, y1 );
+		m_pTerLabel->SetPos( x1 - diff, y1 );
+
+		m_modifiedWidths = true;
+	}
+
+	// ensure extra info is wide enough
+	int wExtra, hExtra;
+	m_pExtraInfo->GetBounds( x1, y1, w1, t1 );
+	m_pExtraInfo->GetContentSize( wExtra, hExtra );
+
+	int desiredExtraWidth = m_extraInfoWidth;
+	desiredExtraWidth = MAX( desiredExtraWidth, wExtra );
+
+	diff = desiredExtraWidth - w1;
+	if ( diff != 0 )
+	{
+		m_pExtraInfo->GetBounds( x1, y1, w1, t1 );
+		m_pExtraInfo->SetBounds( x1 - diff, y1, w1 + diff, t1 );
+
+		m_pTimer->GetPos( x1, y1 );
+		m_pTimer->SetPos( x1 - diff, y1 );
+
+		m_pTimerLabel->GetPos( x1, y1 );
+		m_pTimerLabel->SetPos( x1 - diff, y1 );
+
+		m_pDivider->GetPos( x1, y1 );
+		m_pDivider->SetPos( x1 - diff, y1 );
+
+		m_pCTScore->GetPos( x1, y1 );
+		m_pCTScore->SetPos( x1 - diff, y1 );
+
+		m_pCTLabel->GetPos( x1, y1 );
+		m_pCTLabel->SetPos( x1 - diff, y1 );
+
+		m_pTerScore->GetPos( x1, y1 );
+		m_pTerScore->SetPos( x1 - diff, y1 );
+
+		m_pTerLabel->GetPos( x1, y1 );
+		m_pTerLabel->SetPos( x1 - diff, y1 );
+
+		m_modifiedWidths = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Verify controls are present to resize
+//-----------------------------------------------------------------------------
+bool CCSSpectatorGUI::ControlsPresent( void ) const
+{
+	return ( m_pCTLabel != NULL &&
+		m_pCTScore != NULL &&
+		m_pTerLabel != NULL &&
+		m_pTerScore != NULL &&
+		m_pTimer != NULL &&
+		m_pTimerLabel != NULL &&
+		m_pDivider != NULL &&
+		m_pExtraInfo != NULL );
+}
+
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+static int AdjustValue( int curValue, int targetValue, int amount )
+{
+	if ( curValue > targetValue )
+	{
+		curValue -= amount;
+
+		if ( curValue < targetValue )
+			curValue = targetValue;
+	}
+	else if ( curValue < targetValue )
+	{
+		curValue += amount;
+
+		if ( curValue > targetValue )
+			curValue = targetValue;
+	}
+
+	return curValue;
+}
+
+void CCSMapOverview::InitTeamColorsAndIcons()
+{
+	BaseClass::InitTeamColorsAndIcons();
+
+	Q_memset( m_TeamIconsSelf, 0, sizeof(m_TeamIconsSelf) );
+	Q_memset( m_TeamIconsDead, 0, sizeof(m_TeamIconsDead) );
+	Q_memset( m_TeamIconsOffscreen, 0, sizeof(m_TeamIconsOffscreen) );
+	Q_memset( m_TeamIconsDeadOffscreen, 0, sizeof(m_TeamIconsDeadOffscreen) );
+
+	m_bombIconPlanted = -1;
+	m_bombIconDropped = -1;
+	m_bombIconCarried = -1;
+	m_bombRingPlanted = -1;
+	m_bombRingDropped = -1;
+	m_bombRingCarried = -1;
+	m_bombRingCarriedOffscreen = -1;
+	m_radioFlash = -1;
+	m_radioFlashOffscreen = -1;
+	m_radarTint = -1;
+	m_hostageFollowing = -1;
+	m_hostageFollowingOffscreen = -1;
+	m_playerFacing = -1;
+	m_cameraIconFirst = -1;
+	m_cameraIconThird = -1;
+	m_cameraIconFree = -1;
+	m_hostageRescueIcon = -1;
+	m_bombSiteIconA = -1;
+	m_bombSiteIconB = -1;
+
+
+	//setup team red
+	m_TeamColors[MAP_ICON_T] = COLOR_RED;
+	m_TeamIcons[MAP_ICON_T] = AddIconTexture( "sprites/player_red_small" );
+	m_TeamIconsSelf[MAP_ICON_T] = AddIconTexture( "sprites/player_red_self" );
+	m_TeamIconsDead[MAP_ICON_T] = AddIconTexture( "sprites/player_red_dead" );
+	m_TeamIconsOffscreen[MAP_ICON_T] = AddIconTexture( "sprites/player_red_offscreen" );
+	m_TeamIconsDeadOffscreen[MAP_ICON_T] = AddIconTexture( "sprites/player_red_dead_offscreen" );
+
+	// setup team blue
+	m_TeamColors[MAP_ICON_CT] = COLOR_BLUE;
+	m_TeamIcons[MAP_ICON_CT] = AddIconTexture( "sprites/player_blue_small" );
+	m_TeamIconsSelf[MAP_ICON_CT] = AddIconTexture( "sprites/player_blue_self" );
+	m_TeamIconsDead[MAP_ICON_CT] = AddIconTexture( "sprites/player_blue_dead" );
+	m_TeamIconsOffscreen[MAP_ICON_CT] = AddIconTexture( "sprites/player_blue_offscreen" );
+	m_TeamIconsDeadOffscreen[MAP_ICON_CT] = AddIconTexture( "sprites/player_blue_dead_offscreen" );
+
+	// setup team other
+	m_TeamColors[MAP_ICON_HOSTAGE] = COLOR_GREY;
+	m_TeamIcons[MAP_ICON_HOSTAGE] = AddIconTexture( "sprites/player_hostage_small" );
+	m_TeamIconsSelf[MAP_ICON_HOSTAGE] = -1;
+	m_TeamIconsDead[MAP_ICON_HOSTAGE] = AddIconTexture( "sprites/player_hostage_dead" );
+	m_TeamIconsOffscreen[MAP_ICON_HOSTAGE] = AddIconTexture( "sprites/player_hostage_offscreen" );
+	m_TeamIconsDeadOffscreen[MAP_ICON_HOSTAGE] = AddIconTexture( "sprites/player_hostage_dead_offscreen" );
+
+	m_bombIconPlanted = AddIconTexture( "sprites/bomb_planted" );
+	m_bombIconDropped = AddIconTexture( "sprites/bomb_dropped" );
+	m_bombIconCarried = AddIconTexture( "sprites/bomb_carried" );
+
+	m_bombRingPlanted = AddIconTexture( "sprites/bomb_planted_ring" );
+	m_bombRingDropped = AddIconTexture( "sprites/bomb_dropped_ring" );
+	m_bombRingCarried = AddIconTexture( "sprites/bomb_carried_ring" );
+	m_bombRingCarriedOffscreen = AddIconTexture( "sprites/bomb_carried_ring_offscreen" );
+
+	m_hostageFollowing = AddIconTexture( "sprites/hostage_following" );
+	m_hostageFollowingOffscreen = AddIconTexture( "sprites/hostage_following_offscreen" );
+	m_playerFacing = AddIconTexture( "sprites/player_tick" );
+	m_cameraIconFirst = AddIconTexture( "sprites/spectator_eye" );
+	m_cameraIconThird = AddIconTexture( "sprites/spectator_3rdcam" );
+	m_cameraIconFree = AddIconTexture( "sprites/spectator_freecam" );
+	m_hostageRescueIcon = AddIconTexture( "sprites/objective_rescue" );;
+	m_bombSiteIconA = AddIconTexture( "sprites/objective_site_a" );;
+	m_bombSiteIconB = AddIconTexture( "sprites/objective_site_b" );;
+
+	m_radioFlash = AddIconTexture("sprites/player_radio_ring");
+	m_radioFlashOffscreen = AddIconTexture("sprites/player_radio_ring_offscreen");
+
+	m_radarTint = AddIconTexture("sprites/radar_trans");
+
+}
+
+//-----------------------------------------------------------------------------
+void CCSMapOverview::ApplySchemeSettings(vgui::IScheme *scheme)
+{
+	BaseClass::ApplySchemeSettings( scheme );
+
+	m_hIconFont = scheme->GetFont( "DefaultSmall", true );
+}
+
+//-----------------------------------------------------------------------------
+void CCSMapOverview::Update( void )
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+
+	if ( !pPlayer )
+		return;
+
+	int team = pPlayer->GetTeamNumber();
+
+	// if dead with fadetoblack on, we can't show anything
+	if ( mp_fadetoblack.GetBool() && team > TEAM_SPECTATOR && !pPlayer->IsAlive() )
+	{
+		SetMode( MAP_MODE_OFF );
+		return;
+	}
+
+	bool inRadarMode = (GetMode() == MAP_MODE_RADAR);
+	int specmode = pPlayer->GetObserverMode();
+	// if alive, we can only be in radar mode
+	if( !inRadarMode  &&  pPlayer->IsAlive())
+	{
+		SetMode( MAP_MODE_RADAR );
+		inRadarMode = true;
+	}
+
+	if( inRadarMode )
+	{
+		if( specmode > OBS_MODE_DEATHCAM )
+		{
+			// If fully dead, we don't want to be radar any more
+			SetMode( m_playerPreferredMode );
+			m_flChangeSpeed = 0;
+		}
+		else
+		{
+			SetFollowEntity(pPlayer->entindex());
+			UpdatePlayers();
+		}
+	}
+
+	BaseClass::Update();
+
+	if ( GetSpectatorMode() == OBS_MODE_CHASE )
+	{
+		// Follow the local player in chase cam, so the map rotates using the local player's angles
+		SetFollowEntity( pPlayer->entindex() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+CCSMapOverview::CSMapPlayer_t* CCSMapOverview::GetCSInfoForPlayerIndex( int index )
+{
+	if ( index < 0 || index >= MAX_PLAYERS )
+		return NULL;
+
+	return &m_PlayersCSInfo[ index ];
+}
+
+//-----------------------------------------------------------------------------
+CCSMapOverview::CSMapPlayer_t* CCSMapOverview::GetCSInfoForPlayer(MapPlayer_t *player)
+{
+	if( player == NULL )
+		return NULL;
+
+	for( int i = 0; i < MAX_PLAYERS; i++ )
+	{
+		if( &m_Players[i] == player )
+			return &m_PlayersCSInfo[i];
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+CCSMapOverview::CSMapPlayer_t* CCSMapOverview::GetCSInfoForHostage(MapPlayer_t *hostage)
+{
+	if( hostage == NULL )
+		return NULL;
+
+	for( int i = 0; i < MAX_HOSTAGES; i++ )
+	{
+		if( &m_Hostages[i] == hostage )
+			return &m_HostagesCSInfo[i];
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+#define TIME_SPOTS_STAY_SEEN (0.5f)
+#define TIME_UNTIL_ENEMY_SEEN (0.5f)
+// rules that define if you can see a player on the overview or not
+bool CCSMapOverview::CanPlayerBeSeen( MapPlayer_t *player )
+{
+	C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
+
+	if (!localPlayer || !player )
+		return false;
+
+	CSMapPlayer_t *csPlayer = GetCSInfoForPlayer(player);
+		
+	if ( !csPlayer )
+		return false;
+
+	if( GetMode() == MAP_MODE_RADAR )
+	{
+		// This level will be for all the RadarMode thinking.  Base class will be the old way for the other modes.
+		float now = gpGlobals->curtime;
+
+		if( player->position == Vector(0,0,0) )
+			return false; // Invalid guy.
+
+		// draw special icons if within time
+		if ( csPlayer->overrideExpirationTime != -1  &&  csPlayer->overrideExpirationTime > gpGlobals->curtime )
+			return true;
+
+		// otherwise, not dead people
+		if( player->health <= 0 )
+			return false;
+
+		if( localPlayer->GetTeamNumber() == player->team )
+			return true;// always yes for teammates.
+
+		// and a living enemy needs to have been seen recently, and have been for a while
+		if( csPlayer->timeLastSeen != -1  
+			&& ( now - csPlayer->timeLastSeen < TIME_SPOTS_STAY_SEEN ) 
+			&& ( now - csPlayer->timeFirstSeen > TIME_UNTIL_ENEMY_SEEN )
+			)
+			return true;
+
+		return false;
+	}
+	else if( player->health <= 0 )
+	{
+		// Have to be under the overriden icon time to draw when dead.
+		if ( csPlayer->overrideExpirationTime == -1  ||  csPlayer->overrideExpirationTime <= gpGlobals->curtime )
+			return false;
+	}
+	
+	return BaseClass::CanPlayerBeSeen(player);
+}
+
+bool CCSMapOverview::CanHostageBeSeen( MapPlayer_t *hostage )
+{
+	C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
+
+	if ( !localPlayer || !hostage )
+		return false;
+
+
+	CSMapPlayer_t *csHostage = GetCSInfoForHostage(hostage);
+
+	if ( !csHostage )
+		return false;
+
+	if( GetMode() == MAP_MODE_RADAR )
+	{
+		// This level will be for all the RadarMode thinking.  Base class will be the old way for the other modes.
+		float now = gpGlobals->curtime;
+
+		if( hostage->position == Vector(0,0,0) )
+			return false; // Invalid guy.
+
+		// draw special icons if within time
+		if ( csHostage->overrideExpirationTime != -1  &&  csHostage->overrideExpirationTime > gpGlobals->curtime )
+			return true;
+
+		// otherwise, not dead people
+		if( hostage->health <= 0 )
+			return false;
+
+		if( localPlayer->GetTeamNumber() == hostage->team )
+			return true;// always yes for teammates.
+
+		// and a living enemy needs to have been seen recently
+		if( csHostage->timeLastSeen != -1  &&  now - csHostage->timeLastSeen < TIME_SPOTS_STAY_SEEN )
+			return true;
+
+		return false;
+	}
+	else if( hostage->health <= 0 )
+	{
+		// Have to be under the overriden icon time to draw when dead.
+		if ( csHostage->overrideExpirationTime == -1  ||  csHostage->overrideExpirationTime <= gpGlobals->curtime )
+			return false;
+	}
+
+	return BaseClass::CanPlayerBeSeen(hostage);
+}
+
+CCSMapOverview::CCSMapOverview( const char *pElementName ) : BaseClass( pElementName )
+{
+	m_nRadarMapTextureID = -1;
+
+	g_pMapOverview = this;  // for cvars access etc
+
+	// restore non-radar modes
+	switch ( overview_preferred_mode.GetInt() )
+	{
+	case MAP_MODE_INSET:
+		m_playerPreferredMode = MAP_MODE_INSET;
+		break;
+
+	case MAP_MODE_FULL:
+		m_playerPreferredMode = MAP_MODE_FULL;
+		break;
+
+	default:
+		m_playerPreferredMode = MAP_MODE_OFF;
+		break;
+	}
+}
+
+void CCSMapOverview::Init( void )
+{
+	BaseClass::Init();
+
+	// register for events as client listener
+	ListenForGameEvent( "hostage_killed" );
+	ListenForGameEvent( "hostage_rescued" );
+	ListenForGameEvent( "bomb_defused" );
+	ListenForGameEvent( "bomb_exploded" );
+}
+
+CCSMapOverview::~CCSMapOverview()
+{
+	g_pMapOverview = NULL;
+
+	//TODO release Textures ? clear lists
+}
+
+void CCSMapOverview::UpdatePlayers()
+{
+	if( !m_goalIconsLoaded )
+		UpdateGoalIcons();
+
+	UpdateHostages();// Update before players so players can spot them
+
+	UpdateBomb();// Before players so player can properly spot where it is in this update
+
+	UpdateFlashes();
+
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+	if ( !pCSPR )
+		return;
+
+	float now = gpGlobals->curtime;
+
+	CBasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
+	if( localPlayer == NULL )
+		return;
+
+	MapPlayer_t *localMapPlayer = GetPlayerByUserID(localPlayer->GetUserID());
+	if( localMapPlayer == NULL )
+		return;
+
+	for ( int i = 1; i<= gpGlobals->maxClients; i++)
+	{
+		MapPlayer_t *player = &m_Players[i-1];
+		CSMapPlayer_t *playerCS = GetCSInfoForPlayerIndex(i-1);
+
+		if ( !playerCS )
+			continue;
+
+		// update from global player resources
+		if ( pCSPR->IsConnected(i) )
+		{
+			player->health = pCSPR->GetHealth( i );
+
+			if ( !pCSPR->IsAlive( i ) )
+			{
+				// Safety actually happens after a TKPunish.
+				player->health = 0;
+				playerCS->isDead = true;
+			}
+
+			if ( player->team != pCSPR->GetTeam( i ) )
+			{
+				player->team = pCSPR->GetTeam( i );
+
+				if( player == localMapPlayer )
+					player->icon = m_TeamIconsSelf[ GetIconNumberFromTeamNumber(player->team) ];
+				else
+					player->icon = m_TeamIcons[ GetIconNumberFromTeamNumber(player->team) ];
+
+				player->color = m_TeamColors[ GetIconNumberFromTeamNumber(player->team) ];
+			}
+		}
+
+		Vector position = player->position;
+		QAngle angles = player->angle;
+		C_BasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+		if ( pPlayer && !pPlayer->IsDormant() )
+		{
+			// update position of active players in our PVS
+			position = pPlayer->EyePosition();
+			angles = pPlayer->EyeAngles();
+
+			SetPlayerPositions( i-1, position, angles );
+		}
+	}
+
+	if ( GetMode() == MAP_MODE_RADAR )
+	{
+		// Check for teammates spotting the bomb
+		if ( m_bomb.state != CSMapBomb_t::BOMB_INVALID && pCSPR->IsBombSpotted() )
+		{
+			SetBombSeen( true );
+		}
+
+		// Check for teammates spotting enemy players
+		for ( int i = 1; i<= gpGlobals->maxClients; ++i )
+		{
+			if ( !pCSPR->IsConnected(i) )
+				continue;
+
+			if ( !pCSPR->IsAlive(i) )
+				continue;
+
+			if ( pCSPR->GetTeam(i) == localMapPlayer->team )
+				continue;
+
+			if ( pCSPR->IsPlayerSpotted(i) )
+			{
+				SetPlayerSeen( i-1 );
+
+				MapPlayer_t *baseEnemy = &m_Players[i-1];
+				if( baseEnemy->health > 0 )
+				{
+					// They were just seen, so if they are alive get rid of their "last known" icon
+					CSMapPlayer_t *csEnemy = GetCSInfoForPlayerIndex(i-1);
+
+					if ( csEnemy )
+					{
+						csEnemy->overrideIcon = -1;
+						csEnemy->overrideIconOffscreen = -1;
+						csEnemy->overridePosition = Vector(0, 0, 0);
+						csEnemy->overrideAngle = QAngle(0, 0, 0);
+						csEnemy->overrideFadeTime = -1;
+						csEnemy->overrideExpirationTime = -1;
+					}
+				}
+			}
+		}
+
+		for( int i = 1; i<= gpGlobals->maxClients; i++ )
+		{
+			MapPlayer_t *player = &m_Players[i-1];
+			CSMapPlayer_t *playerCS = GetCSInfoForPlayerIndex(i-1);
+			C_BasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+
+			if ( !pPlayer || !playerCS )
+				continue;
+
+			float timeSinceLastSeen = now - playerCS->timeLastSeen;
+			if( timeSinceLastSeen < 0.25f )
+				continue;
+			if( player->health <= 0 )
+				continue;// We don't need to spot dead guys, since they always show
+			if( player->team == localMapPlayer->team )
+				continue;// We don't need to spot our own guys
+
+			// Now that everyone has had a say on people they can see for us, go through and handle baddies that can no longer be seen.
+			if( playerCS->timeLastSeen != now  &&  player->health > 0 )
+			{
+				// We are not seen now, but if we were seen recently (and for long enough),
+				// put up a "last known" icon and clear timelastseen
+				// if they are alive.  Death icon is more important, which is why the health check above.
+				if( timeSinceLastSeen < 0.5f  && ( playerCS->timeLastSeen != -1 ) )
+				{
+					if( now - playerCS->timeFirstSeen > TIME_UNTIL_ENEMY_SEEN )
+					{
+						playerCS->overrideIcon = m_TeamIcons[ GetIconNumberFromTeamNumber(player->team) ];;
+						playerCS->overrideIconOffscreen = m_TeamIconsOffscreen[ GetIconNumberFromTeamNumber(player->team) ];
+						playerCS->overridePosition = player->position;
+						playerCS->overrideFadeTime = -1;
+						playerCS->overrideExpirationTime = now + LAST_SEEN_ICON_DURATION;
+						playerCS->overrideAngle = player->angle;
+					}
+					playerCS->timeLastSeen = -1;
+					playerCS->timeFirstSeen = -1;
+				}
+			}
+		}
+	}
+}
+
+void CCSMapOverview::UpdateHostages()
+{
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+	if ( !pCSPR )
+		return;
+
+	for( int i=0; i < MAX_HOSTAGES; i++ )
+	{
+		if( pCSPR->IsHostageAlive( i ) )
+		{
+			MapPlayer_t *hostage = GetHostageByEntityID( pCSPR->GetHostageEntityID(i) );
+			if( hostage == NULL )
+				hostage = &m_Hostages[i];// Don't have entry yet, so need one.  This'll only happen once, at start of map
+
+			CSMapPlayer_t *hostageCS = GetCSInfoForHostage(hostage);
+
+			if ( !hostageCS )
+				return;
+
+			if( !hostageCS->isDead )
+			{
+				hostage->index = pCSPR->GetHostageEntityID(i);
+				hostage->position = pCSPR->GetHostagePosition( i );
+				hostage->health = 100; // Hostages don't have health available from pCSPR.
+				hostage->angle = QAngle(0, 0, 0); // No facing, like no health
+				hostage->team = TEAM_CT; // CT in terms of who sees them
+				hostage->icon = m_TeamIcons[ MAP_ICON_HOSTAGE ]; // But hostage for icon.
+				hostage->color = m_TeamColors[ MAP_ICON_HOSTAGE ];
+				hostageCS->isHostage = true;
+
+//				engine->Con_NPrintf( i + 15, "ID:%d Pos:(%.0f,%.0f,%.0f)", hostage->index, hostage->position.x, hostage->position.y, hostage->position.z );
+			}
+			else
+			{
+//				engine->Con_NPrintf( i + 15, "Mostly Dead" );
+			}
+		}
+		else
+		{
+//			engine->Con_NPrintf( i + 15, "Dead" );
+		}
+	}
+}
+
+void CCSMapOverview::UpdateBomb()
+{
+	if( m_bomb.state == CSMapBomb_s::BOMB_GONE )
+		return;// no more updates until map restart
+
+	float now = gpGlobals->curtime;
+
+	// First, decide if it has been too long since the bomb has been seen to clear visibility timers.
+	if( now - m_bomb.timeLastSeen >= TIME_SPOTS_STAY_SEEN  &&  m_bomb.timeFirstSeen != -1 )
+	{
+		SetBombSeen( false );
+	}
+
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+	if ( !pCSPR )
+		return;
+
+	float biggestRadius = 0, smallestRadius = 0;
+	if ( g_PlantedC4s.Count() > 0 )
+	{
+		// bomb is planted
+		C_PlantedC4 *pC4 = g_PlantedC4s[0];
+
+		if( pC4->IsBombActive() )
+		{
+			m_bomb.position = pC4->GetAbsOrigin();
+			m_bomb.state = CSMapBomb_t::BOMB_PLANTED;
+			m_bomb.ringTravelTime = 3.0f;
+			smallestRadius = m_flIconSize;
+			biggestRadius = m_flIconSize * 15.0f;
+		}
+		else
+		{
+			// Defused or exploded
+			m_bomb.state = CSMapBomb_t::BOMB_GONE;
+		}
+	}
+	else if ( pCSPR->HasC4( 0 ) )
+	{
+		// bomb dropped 
+		Vector pos = pCSPR->GetC4Postion();
+
+		if ( pos.x != 0 || pos.y != 0 || pos.z != 0 )
+		{
+			m_bomb.position = pos;
+			m_bomb.state = CSMapBomb_t::BOMB_DROPPED;
+			m_bomb.ringTravelTime = 6.0f;
+			smallestRadius = m_flIconSize;
+			biggestRadius = m_flIconSize * 10.0f;
+		}
+		else
+		{
+			m_bomb.state = CSMapBomb_t::BOMB_INVALID;
+			//Not a bomb map.  Man, what a weird system instead of IsBombMap.  If nobody has it, and it isn't on the ground, then it isn't a bomb map.
+		}
+	}
+	else
+	{
+		for( int i = 1; i<= gpGlobals->maxClients; i++ )
+		{
+			if( pCSPR->HasC4(i) )
+			{
+				C_BasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+				if( pPlayer == NULL  ||  pPlayer->IsDormant() )
+				{
+					// Dormant or no player means we are relying on RadarUpdate messages so we can trust the MapOverview position.
+					MapPlayer_t *player = &m_Players[i-1];
+					m_bomb.position = player->position;
+				}
+				else
+				{
+					// Update players is about to put this Real Data in the player sturct, and we don't want the bomb pos lagged one update behind
+					m_bomb.position = pPlayer->GetAbsOrigin();
+				}
+
+				m_bomb.state = CSMapBomb_t::BOMB_CARRIED;
+				m_bomb.ringTravelTime = 0;
+				smallestRadius = m_flIconSize * 1.2f;
+				biggestRadius = m_flIconSize * 1.2f;
+				break;
+			}
+		}
+	}
+
+	int alpha = GetMasterAlpha();
+
+	if( m_bomb.currentRingRadius == m_bomb.maxRingRadius  ||  m_bomb.ringTravelTime == 0 )
+	{
+		m_bomb.currentRingRadius = smallestRadius;
+		m_bomb.maxRingRadius = biggestRadius;
+		m_bomb.currentRingAlpha = alpha;
+	}
+	else
+	{
+		m_bomb.currentRingRadius += (m_bomb.maxRingRadius - m_flIconSize) * gpGlobals->frametime / m_bomb.ringTravelTime;
+		m_bomb.currentRingRadius = MIN( m_bomb.currentRingRadius, m_bomb.maxRingRadius );
+		m_bomb.currentRingAlpha = (alpha - 55) * ((m_bomb.maxRingRadius - m_bomb.currentRingRadius) / (m_bomb.maxRingRadius - m_flIconSize)) + 55;
+	}
+}
+
+bool CCSMapOverview::ShouldDraw( void )
+{
+	int alpha = GetMasterAlpha();
+	if( alpha == 0 )
+		return false;// we have been set to fully transparent
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick] Turn off large map display when in freezecam.
+	//=============================================================================
+	if ( IsInFreezeCam() && GetMode() == MAP_MODE_FULL )
+	{
+		return false;
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	float now = gpGlobals->curtime;
+	if( GetMode() == MAP_MODE_RADAR )
+	{
+		if ( (GET_HUDELEMENT( CHudRadar ))->ShouldDraw() == false )
+		{
+			return false; 
+		}
+
+		// We have to be alive and not blind to draw in this mode.
+		C_CSPlayer *pCSPlayer = C_CSPlayer::GetLocalCSPlayer();
+		if( !pCSPlayer || pCSPlayer->GetObserverMode() == OBS_MODE_DEATHCAM ) 
+		{
+			return false;
+		}
+		else if (pCSPlayer->m_flFlashBangTime > now)
+		{
+			return false;
+		}
+	}
+
+	return BaseClass::ShouldDraw();
+}
+
+CCSMapOverview::MapPlayer_t* CCSMapOverview::GetHostageByEntityID( int entityID )
+{
+	for (int i=0; i<MAX_HOSTAGES; i++)
+	{
+		if ( m_Hostages[i].index == entityID )
+			return &m_Hostages[i];
+	}
+
+	return NULL;
+}
+
+CCSMapOverview::MapPlayer_t* CCSMapOverview::GetPlayerByEntityID( int entityID )
+{
+	C_BasePlayer *realPlayer = UTIL_PlayerByIndex(entityID);
+
+	if( realPlayer == NULL )
+		return NULL;
+
+	for (int i=0; i<MAX_PLAYERS; i++)
+	{
+		MapPlayer_t *player = &m_Players[i];
+
+		if ( player->userid == realPlayer->GetUserID() )
+			return player;
+	}
+
+	return NULL;
+}
+
+#define BORDER_WIDTH 4
+bool CCSMapOverview::AdjustPointToPanel(Vector2D *pos)
+{
+	if( pos == NULL )
+		return false;
+
+	int mapInset = GetBorderSize();// This gives us the amount inside the panel that the background is drawing.
+	if( mapInset != 0 )
+		mapInset += BORDER_WIDTH; // And this gives us the border inside the map edge to give us room for offscreen icons.
+
+	int x,y,w,t;
+
+	//MapTpPanel has already offset the x and y.  That's why we use 0 for left and top.
+	GetBounds( x,y,w,t );
+
+	bool madeChange = false;
+	if( pos->x < mapInset )
+	{
+		pos->x = mapInset;
+		madeChange = true;
+	}
+	if( pos->x > w - mapInset )
+	{
+		pos->x = w - mapInset;
+		madeChange = true;
+	}
+	if( pos->y < mapInset )
+	{
+		pos->y = mapInset;
+		madeChange = true;
+	}
+	if( pos->y > t - mapInset )
+	{
+		pos->y = t - mapInset;
+		madeChange = true;
+	}
+
+	return madeChange;
+}
+
+void CCSMapOverview::DrawMapTexture()
+{
+	int alpha = GetMasterAlpha();
+
+	if( GetMode() == MAP_MODE_FULL )
+		SetBgColor( Color(0,0,0,0) );// no background in big mode
+	else
+		SetBgColor( Color(0,0,0,alpha * 0.5) );
+
+	int textureIDToUse = m_nMapTextureID;
+	bool foundRadarVersion = false;
+	if( m_nRadarMapTextureID != -1 && GetMode() == MAP_MODE_RADAR )
+	{
+		textureIDToUse = m_nRadarMapTextureID;
+		foundRadarVersion = true;
+	}
+
+	int mapInset = GetBorderSize();
+	int pwidth, pheight; 
+	GetSize(pwidth, pheight);
+
+	if ( textureIDToUse > 0 )
+	{
+		// We are drawing to the whole panel with a little border
+		Vector2D panelTL = Vector2D( mapInset, mapInset );
+		Vector2D panelTR = Vector2D( pwidth - mapInset, mapInset );
+		Vector2D panelBR = Vector2D( pwidth - mapInset, pheight - mapInset );
+		Vector2D panelBL = Vector2D( mapInset, pheight - mapInset );
+
+		// So where are those four points on the great big map?
+		Vector2D textureTL = PanelToMap( panelTL );// The top left corner of the display is where on the master map?
+		textureTL /= OVERVIEW_MAP_SIZE;// Texture Vec2D is 0 to 1
+		Vector2D textureTR = PanelToMap( panelTR );
+		textureTR /= OVERVIEW_MAP_SIZE;
+		Vector2D textureBR = PanelToMap( panelBR );
+		textureBR /= OVERVIEW_MAP_SIZE;
+		Vector2D textureBL = PanelToMap( panelBL );
+		textureBL /= OVERVIEW_MAP_SIZE;
+
+		Vertex_t points[4] =
+		{
+			// To draw a textured polygon, the first column is where you want to draw (to), and the second is what you want to draw (from).
+			// We want to draw to the panel (pulled in for a border), and we want to draw the part of the map texture that should be seen.
+			// First column is in panel coords, second column is in 0-1 texture coords
+			Vertex_t( panelTL, textureTL ),
+			Vertex_t( panelTR, textureTR ),
+			Vertex_t( panelBR, textureBR ),
+			Vertex_t( panelBL, textureBL )
+		};
+
+		surface()->DrawSetColor( 255, 255, 255, alpha );
+		surface()->DrawSetTexture( textureIDToUse );
+		surface()->DrawTexturedPolygon( 4, points );
+	}
+
+	// If we didn't find the greenscale version of the map, then at least do a tint.
+	if( !foundRadarVersion && GetMode() == MAP_MODE_RADAR )
+	{
+		surface()->DrawSetColor( 0,255,0, alpha / 4 );
+		surface()->DrawFilledRect( mapInset, mapInset, m_vSize.x - 1 - mapInset, m_vSize.y - 1 - mapInset );
+	}
+}
+
+void CCSMapOverview::DrawBomb()
+{
+    if( m_bomb.state == CSMapBomb_t::BOMB_INVALID )
+		return;
+
+	CBasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
+	if( localPlayer == NULL )
+		return;
+	MapPlayer_t *localMapPlayer = GetPlayerByUserID(localPlayer->GetUserID());
+	if( localMapPlayer == NULL )
+		return;
+	float now = gpGlobals->curtime;
+
+	if( localMapPlayer->team == TEAM_CT )
+	{
+		// CT's only get to see it if...
+
+		if( localMapPlayer->health <= 0 )
+		{
+			if ( mp_forcecamera.GetInt() != OBS_ALLOW_ALL )
+				return;// They're dead and spectating isn't restricted 
+		}
+		else if( (m_bomb.timeLastSeen == -1)  
+			||  ( now - m_bomb.timeLastSeen >= TIME_SPOTS_STAY_SEEN ) 
+			||  ( now - m_bomb.timeFirstSeen < TIME_UNTIL_ENEMY_SEEN ) 
+			)
+		{
+			return;// It's in view
+		}
+	}
+	// else if you aren't CT you can always see it
+
+	int bombIcon;
+	int bombRing;
+	int bombRingOffscreen;
+	switch(m_bomb.state) 
+	{
+		case CSMapBomb_t::BOMB_DROPPED:
+		{
+			bombIcon = m_bombIconDropped;
+			bombRing = m_bombRingDropped;
+			bombRingOffscreen = m_bombRingDropped;
+			break;
+		}
+		case CSMapBomb_t::BOMB_CARRIED:
+		{
+			bombIcon = m_bombIconCarried;
+			bombRing = m_bombRingCarried;
+			bombRingOffscreen = m_bombRingCarriedOffscreen;
+			break;
+		}
+		case CSMapBomb_t::BOMB_PLANTED:
+		{
+			bombIcon = m_bombIconPlanted;
+			bombRing = m_bombRingPlanted;
+			bombRingOffscreen = m_bombRingPlanted;
+			break;
+		}
+		case CSMapBomb_t::BOMB_GONE:
+		{
+			bombIcon = m_bombIconPlanted;
+			bombRing = m_bombRingPlanted;
+			bombRingOffscreen = m_bombRingPlanted;
+			break;
+		}
+	default:
+		return;
+	}
+
+	int alpha = 255;
+
+	if( m_bomb.timeGone != -1  &&  m_bomb.timeFade <= gpGlobals->curtime )
+		alpha *= 1 - ( (float)(gpGlobals->curtime - m_bomb.timeFade) / (float)(m_bomb.timeGone - m_bomb.timeFade) );
+
+	if( m_bomb.state != CSMapBomb_t::BOMB_GONE )
+		DrawIconCS(bombRing, bombRingOffscreen, m_bomb.position, m_bomb.currentRingRadius, 0, m_bomb.currentRingAlpha);
+	DrawIconCS(bombIcon, bombIcon, m_bomb.position, m_flIconSize, 0, alpha);
+}
+
+bool CCSMapOverview::DrawIconCS( int textureID, int offscreenTextureID, Vector pos, float scale, float angle, int alpha, bool allowRotation, const char *text, Color *textColor, float status, Color *statusColor )
+{
+	if( GetMode() == MAP_MODE_RADAR  &&  cl_radaralpha.GetInt() == 0 )
+		return false;
+
+	if( alpha <= 0 )
+		return false;
+
+	Vector2D pospanel = WorldToMap( pos );
+	pospanel = MapToPanel( pospanel );
+
+	int idToUse = textureID;
+	float angleToUse = angle;
+
+	Vector2D oldPos = pospanel;
+	Vector2D adjustment(0,0);
+	if( AdjustPointToPanel( &pospanel ) )
+	{
+		if( offscreenTextureID == -1 )
+			return false; //Doesn't want to draw if off screen.
+
+		// Move it in to on panel, and change the icon.
+		idToUse = offscreenTextureID;
+		// And point towards the original spot
+		adjustment = Vector2D(pospanel.x - oldPos.x, pospanel.y - oldPos.y);
+		QAngle adjustmentAngles;
+		Vector adjustment3D(adjustment.x, -adjustment.y, 0); // Y gets flipped in WorldToMap
+		VectorAngles(adjustment3D, adjustmentAngles) ;
+		if( allowRotation )
+		{
+			// Some icons don't want to rotate even when off radar
+			angleToUse = adjustmentAngles[YAW];
+
+			// And the angle needs to be in world space, not panel space.
+			if( m_bFollowAngle )
+			{
+				angleToUse += m_fViewAngle;
+			}
+			else 
+			{
+				if ( m_bRotateMap )
+					angleToUse += 180.0f;
+				else
+					angleToUse += 90.0f;
+			}
+		}
+
+		// Don't draw names for icons that are offscreen (bunches up and looks bad)
+		text = NULL;
+	}
+
+	int d = GetPixelOffset( scale );
+
+	Vector offset;
+
+	offset.x = -scale;	offset.y = scale;
+	VectorYawRotate( offset, angleToUse, offset );
+	Vector2D pos1 = WorldToMap( pos + offset );
+	Vector2D pos1Panel = MapToPanel(pos1);
+	pos1Panel.x += adjustment.x;
+	pos1Panel.y += adjustment.y;
+
+	offset.x = scale;	offset.y = scale;
+	VectorYawRotate( offset, angleToUse, offset );
+	Vector2D pos2 = WorldToMap( pos + offset );
+	Vector2D pos2Panel = MapToPanel(pos2);
+	pos2Panel.x += adjustment.x;
+	pos2Panel.y += adjustment.y;
+
+	offset.x = scale;	offset.y = -scale;
+	VectorYawRotate( offset, angleToUse, offset );
+	Vector2D pos3 = WorldToMap( pos + offset );
+	Vector2D pos3Panel = MapToPanel(pos3);
+	pos3Panel.x += adjustment.x;
+	pos3Panel.y += adjustment.y;
+
+	offset.x = -scale;	offset.y = -scale;
+	VectorYawRotate( offset, angleToUse, offset );
+	Vector2D pos4 = WorldToMap( pos + offset );
+	Vector2D pos4Panel = MapToPanel(pos4);
+	pos4Panel.x += adjustment.x;
+	pos4Panel.y += adjustment.y;
+
+	Vertex_t points[4] =
+	{
+		Vertex_t( pos1Panel, Vector2D(0,0) ),
+			Vertex_t( pos2Panel, Vector2D(1,0) ),
+			Vertex_t( pos3Panel, Vector2D(1,1) ),
+			Vertex_t( pos4Panel, Vector2D(0,1) )
+	};
+
+	surface()->DrawSetColor( 255, 255, 255, alpha );
+	surface()->DrawSetTexture( idToUse );
+	surface()->DrawTexturedPolygon( 4, points );
+
+	pospanel.y += d + 4;
+
+	if ( status >=0.0f  && status <= 1.0f && statusColor )
+	{
+		// health bar is 50x3 pixels
+		surface()->DrawSetColor( 0,0,0,255 );
+		surface()->DrawFilledRect( pospanel.x-d, pospanel.y-1, pospanel.x+d, pospanel.y+1 );
+
+		int length = (float)(d*2)*status;
+		surface()->DrawSetColor( statusColor->r(), statusColor->g(), statusColor->b(), 255 );
+		surface()->DrawFilledRect( pospanel.x-d, pospanel.y-1, pospanel.x-d+length, pospanel.y+1 );
+
+		pospanel.y += 3;
+	}
+
+	if ( text && textColor )
+	{
+		wchar_t iconText[ MAX_PLAYER_NAME_LENGTH*2 ];
+
+		g_pVGuiLocalize->ConvertANSIToUnicode( text, iconText, sizeof( iconText ) );
+
+		int wide, tall;
+		surface()->GetTextSize( m_hIconFont, iconText, wide, tall );
+
+		int x = pospanel.x-(wide/2);
+		int y = pospanel.y;
+
+		// draw black shadow text
+		surface()->DrawSetTextColor( 0, 0, 0, 255 );
+		surface()->DrawSetTextPos( x+1, y );
+		surface()->DrawPrintText( iconText, wcslen(iconText) );
+
+		// draw name in color 
+		surface()->DrawSetTextColor( textColor->r(), textColor->g(), textColor->b(), 255 );
+		surface()->DrawSetTextPos( x, y );
+		surface()->DrawPrintText( iconText, wcslen(iconText) );
+	}
+
+	return true;
+}
+
+void CCSMapOverview::DrawMapPlayers()
+{
+	DrawGoalIcons();
+	DrawHostages();
+
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+	surface()->DrawSetTextFont( m_hIconFont );
+
+	Color colorGreen( 0, 255, 0, 255 );	// health bar color
+	CBasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
+
+	for (int i=0; i < MAX_PLAYERS; i++)
+	{
+		int alpha = 255;
+		MapPlayer_t *player = &m_Players[i];
+		CSMapPlayer_t *playerCS = GetCSInfoForPlayerIndex(i);
+
+		if ( !playerCS )
+			continue;
+
+		if ( !CanPlayerBeSeen( player ) )
+			continue;
+
+		float status = -1;
+		const char *name = NULL;
+
+		if ( m_bShowNames && CanPlayerNameBeSeen( player ) )
+			name = player->name;
+
+		if ( m_bShowHealth && CanPlayerHealthBeSeen( player ) )
+			status = player->health/100.0f;
+
+		// Now draw them
+		if( playerCS->overrideExpirationTime > gpGlobals->curtime )// If dead, an X, if alive, an alpha'd normal icon
+		{
+			int alphaToUse = alpha;
+			if( playerCS->overrideFadeTime != -1 && playerCS->overrideFadeTime <= gpGlobals->curtime )
+			{
+				// Fade linearly from fade start to disappear
+				alphaToUse *= 1 - (float)(gpGlobals->curtime - playerCS->overrideFadeTime) / (float)(playerCS->overrideExpirationTime - playerCS->overrideFadeTime);
+			}
+
+			DrawIconCS( playerCS->overrideIcon, playerCS->overrideIconOffscreen, playerCS->overridePosition, m_flIconSize * 1.1f, GetViewAngle(), player->health > 0 ? alphaToUse / 2 : alphaToUse, true, name, &player->color, -1, &colorGreen );
+			if( player->health > 0 )
+				DrawIconCS( m_playerFacing, -1, playerCS->overridePosition, m_flIconSize * 1.1f, playerCS->overrideAngle[YAW], player->health > 0 ? alphaToUse / 2 : alphaToUse, true, name, &player->color, status, &colorGreen );
+		}
+		else
+		{
+			float zDifference = 0;
+			if( localPlayer )
+			{	
+				if( (localPlayer->GetObserverMode() != OBS_MODE_NONE) && localPlayer->GetObserverTarget() )
+					zDifference = player->position.z - localPlayer->GetObserverTarget()->GetAbsOrigin().z;
+				else
+					zDifference = player->position.z - localPlayer->GetAbsOrigin().z;
+			}
+
+			float sizeForRing = m_flIconSize * 1.4f;
+			float sizeForPlayer = m_flIconSize * 1.1f; // The 1.1 is because the player dots are shrunken a little, so their facing pip can have some space to live
+			if ( zDifference > DIFFERENCE_THRESHOLD )
+			{
+				// A dot above is bigger and a little fuzzy now.
+				sizeForRing *= 1.4f;
+				sizeForPlayer *= 1.4f;
+				alpha *= 0.5f;
+			}
+			else if ( zDifference < -DIFFERENCE_THRESHOLD )
+			{
+				// A dot below is smaller.
+				sizeForRing *= 0.7f;
+				sizeForPlayer *= 0.7f;
+			}
+
+			bool showTalkRing = localPlayer && (localPlayer->GetTeamNumber() == player->team || localPlayer->GetTeamNumber() == TEAM_SPECTATOR);
+
+			if( showTalkRing && playerCS->currentFlashAlpha > 0 )// Flash type
+			{
+				// Make them flash a halo
+				DrawIconCS(m_radioFlash, m_radioFlashOffscreen, player->position, sizeForRing, player->angle[YAW], playerCS->currentFlashAlpha);
+			}
+			else if( showTalkRing && pCSPR->IsAlive( i + 1 ) && GetClientVoiceMgr()->IsPlayerSpeaking( i + 1) ) // Or solid on type
+			{
+				// Make them show a halo
+				DrawIconCS(m_radioFlash, m_radioFlashOffscreen, player->position, sizeForRing, player->angle[YAW], 255);
+			}
+			
+			bool doingLocalPlayer = GetPlayerByUserID(localPlayer->GetUserID()) == player;
+			float angleForPlayer = GetViewAngle();
+
+			if( doingLocalPlayer )
+			{
+				sizeForPlayer *= 4.0f; // The self icon is really big since it has a camera view cone attached.
+				angleForPlayer = player->angle[YAW];// And, the self icon now rotates, natch.
+			}
+
+			int offscreenIcon = m_TeamIconsOffscreen[GetIconNumberFromTeamNumber(player->team)];
+			DrawIconCS( player->icon, offscreenIcon, player->position, sizeForPlayer, angleForPlayer, alpha, true, name, &player->color, status, &colorGreen );
+			if( !doingLocalPlayer )
+			{
+				// Draw the facing for everyone but the local player.
+				if( player->health > 0 )
+					DrawIconCS( m_playerFacing, -1, player->position, sizeForPlayer, player->angle[YAW], alpha, true, name, &player->color, status, &colorGreen );
+			}
+		}
+	}
+
+	DrawBomb();// After players so it can draw on top
+}
+
+void CCSMapOverview::DrawHostages()
+{
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+	if ( !pCSPR )
+		return;
+
+	surface()->DrawSetTextFont( m_hIconFont );
+
+	Color colorGreen( 0, 255, 0, 255 );	// health bar color
+	CBasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
+
+	for (int i=0; i < MAX_HOSTAGES; i++)
+	{
+		int alpha = 255;
+		MapPlayer_t *hostage = GetHostageByEntityID( pCSPR->GetHostageEntityID(i) );
+		if( hostage == NULL )
+			continue;
+
+		CSMapPlayer_t *hostageCS = GetCSInfoForHostage(hostage);
+
+		if ( !hostageCS )
+			continue;
+
+		if ( !CanHostageBeSeen( hostage ) )
+		{
+//			engine->Con_NPrintf( i + 30, "Can't be seen." );
+			continue;
+		}
+
+		float status = -1;
+		const char *name = NULL;
+
+		if( hostageCS->overrideExpirationTime > gpGlobals->curtime )// If dead, an X, if alive, an alpha'd normal icon
+		{
+//			engine->Con_NPrintf( i + 30, "ID:%d Override Pos:(%.0f,%.0f,%.0f)", hostage->index, hostageCS->overridePosition.x, hostageCS->overridePosition.y, hostageCS->overridePosition.z );
+			int alphaToUse = alpha;
+			if( hostageCS->overrideFadeTime != -1 && hostageCS->overrideFadeTime <= gpGlobals->curtime )
+			{
+				// Fade linearly from fade start to disappear
+				alphaToUse *= 1 - (float)(gpGlobals->curtime - hostageCS->overrideFadeTime) / (float)(hostageCS->overrideExpirationTime - hostageCS->overrideFadeTime);
+			}
+
+			DrawIconCS( hostageCS->overrideIcon, hostageCS->overrideIconOffscreen, hostageCS->overridePosition, m_flIconSize, hostageCS->overrideAngle[YAW], hostage->health > 0 ? alphaToUse / 2 : alphaToUse, true, name, &hostage->color, status, &colorGreen );
+		}
+		else
+		{
+			if( localPlayer && localPlayer->GetTeamNumber() == hostage->team && hostageCS->currentFlashAlpha > 0 )
+			{
+				// Make them flash a halo
+				DrawIconCS(m_radioFlash, m_radioFlashOffscreen, hostage->position, m_flIconSize * 1.4f, hostage->angle[YAW], hostageCS->currentFlashAlpha);
+			}
+
+//			engine->Con_NPrintf( i + 30, "ID:%d Pos:(%.0f,%.0f,%.0f)", hostage->index, hostage->position.x, hostage->position.y, hostage->position.z );
+			int normalIcon, offscreenIcon;
+			float zDifference = 0;
+			if( localPlayer )
+			{	
+				if( (localPlayer->GetObserverMode() != OBS_MODE_NONE) && localPlayer->GetObserverTarget() )
+					zDifference = hostage->position.z - localPlayer->GetObserverTarget()->GetAbsOrigin().z;
+				else
+					zDifference = hostage->position.z - localPlayer->GetAbsOrigin().z;
+			}
+
+			float sizeForHostage = m_flIconSize;
+			if( zDifference > DIFFERENCE_THRESHOLD )
+			{
+				// A dot above is bigger and a little fuzzy now.
+				sizeForHostage = m_flIconSize * 1.5f;
+				alpha *= 0.5f;
+			}
+			else if( zDifference < -DIFFERENCE_THRESHOLD )
+			{
+				// A dot below is smaller.
+				sizeForHostage = m_flIconSize * 0.6f;
+			}
+
+			normalIcon = hostage->icon;
+			offscreenIcon = m_TeamIconsOffscreen[ MAP_ICON_HOSTAGE ];
+			DrawIconCS( normalIcon, offscreenIcon, hostage->position, sizeForHostage, GetViewAngle(), alpha, true, name, &hostage->color, status, &colorGreen );
+
+			if( pCSPR->IsHostageFollowingSomeone( i ) )
+			{
+				// If they are following a CT, then give them a little extra symbol to show it.
+				DrawIconCS( m_hostageFollowing, m_hostageFollowingOffscreen, hostage->position, sizeForHostage, hostage->angle[YAW], alpha );
+			}
+		}
+	}
+}
+void CCSMapOverview::SetMap(const char * levelname)
+{
+	BaseClass::SetMap(levelname);
+
+	int wide, tall;
+	surface()->DrawGetTextureSize( m_nMapTextureID, wide, tall );
+	if( wide == 0 && tall == 0 )
+	{
+		m_nMapTextureID = -1;
+		m_nRadarMapTextureID = -1;
+		return;// No map image, so no radar image
+	}
+
+	char radarFileName[MAX_PATH];
+	Q_snprintf(radarFileName, MAX_PATH, "%s_radar", m_MapKeyValues->GetString("material"));
+	m_nRadarMapTextureID = surface()->CreateNewTextureID();
+	surface()->DrawSetTextureFile(m_nRadarMapTextureID, radarFileName, true, false);
+	int radarWide = -1;
+	int radarTall = -1;
+	surface()->DrawGetTextureSize(m_nRadarMapTextureID, radarWide, radarTall);
+	bool radarTextureFound = false;
+	if( radarWide == wide  &&  radarTall == tall )
+	{
+		// Unbelievable that these is no failure return from SetTextureFile, and not
+		// even a ValidTexture check on the ID.  So I can check if it is different from
+		// the original.  It'll be a 32x32 default if not present.
+		radarTextureFound = true;
+	}
+
+	if( !radarTextureFound )
+	{
+		if( !CreateRadarImage(m_MapKeyValues->GetString("material"), radarFileName) )
+			m_nRadarMapTextureID = -1;
+	}
+
+	ClearGoalIcons();
+}
+
+bool CCSMapOverview::CreateRadarImage(const char *mapName, const char * radarFileName)
+{
+#ifdef GENERATE_RADAR_FILE
+	char fullFileName[MAX_PATH];
+	Q_snprintf(fullFileName, MAX_PATH, "materials/%s.vtf", mapName);
+	char fullRadarFileName[MAX_PATH];
+	Q_snprintf(fullRadarFileName, MAX_PATH, "materials/%s.vtf", radarFileName);
+
+	// Not found, so try to make one
+	FileHandle_t fp;
+	fp = ::filesystem->Open( fullFileName, "rb" );
+	if( !fp )
+	{
+		return false;
+	}
+	::filesystem->Seek( fp, 0, FILESYSTEM_SEEK_TAIL );
+	int srcVTFLength = ::filesystem->Tell( fp );
+	::filesystem->Seek( fp, 0, FILESYSTEM_SEEK_HEAD );
+
+	CUtlBuffer buf;
+	buf.EnsureCapacity( srcVTFLength );
+	int overviewMapBytesRead = ::filesystem->Read( buf.Base(), srcVTFLength, fp );
+	::filesystem->Close( fp );
+
+	buf.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );// Need to set these explicitly since ->Read goes straight to memory and skips them.
+	buf.SeekPut( CUtlBuffer::SEEK_HEAD, overviewMapBytesRead );
+
+	IVTFTexture *radarTexture = CreateVTFTexture();
+	if (radarTexture->Unserialize(buf))
+	{
+		ImageFormat oldImageFormat = radarTexture->Format();
+		radarTexture->ConvertImageFormat(IMAGE_FORMAT_RGBA8888, false);
+		unsigned char *imageData = radarTexture->ImageData(0,0,0);
+		int size = radarTexture->ComputeTotalSize(); // in bytes!
+		unsigned char *pEnd = imageData + size;
+
+		for( ; imageData < pEnd; imageData += 4 )
+		{
+			imageData[0] = 0; // R
+			imageData[2] = 0; // B
+		}
+
+		radarTexture->ConvertImageFormat(oldImageFormat, false);
+
+		buf.Clear();
+		radarTexture->Serialize(buf);
+
+		fp = ::filesystem->Open(fullRadarFileName, "wb");
+		::filesystem->Write(buf.Base(), buf.TellPut(), fp);
+		::filesystem->Close(fp);
+		DestroyVTFTexture(radarTexture);
+		buf.Purge();
+
+		// And need a vmt file to go with it.
+		char vmtFilename[MAX_PATH];
+		Q_snprintf(vmtFilename, MAX_PATH, "%s", fullRadarFileName);
+		char *extension = &vmtFilename[Q_strlen(vmtFilename) - 3];
+		*extension++ = 'v';
+		*extension++ = 'm';
+		*extension++ = 't';
+		*extension++ = '\0';
+		fp = ::filesystem->Open(vmtFilename, "wt");
+		::filesystem->Write("\"UnlitGeneric\"\n", 15, fp);
+		::filesystem->Write("{\n", 2, fp);
+		::filesystem->Write("\t\"$translucent\" \"1\"\n", 20, fp);
+		::filesystem->Write("\t\"$basetexture\" \"", 17, fp);
+		::filesystem->Write(radarFileName, Q_strlen(radarFileName), fp);
+		::filesystem->Write("\"\n", 2, fp);
+		::filesystem->Write("\t\"$vertexalpha\" \"1\"\n", 20, fp);
+		::filesystem->Write("\t\"$vertexcolor\" \"1\"\n", 20, fp);
+		::filesystem->Write("\t\"$no_fullbright\" \"1\"\n", 22, fp);
+		::filesystem->Write("\t\"$ignorez\" \"1\"\n", 16, fp);
+		::filesystem->Write("}\n", 2, fp);
+		::filesystem->Close(fp);
+
+		m_nRadarMapTextureID = surface()->CreateNewTextureID();
+		surface()->DrawSetTextureFile( m_nRadarMapTextureID, radarFileName, true, true);
+		return true;
+	}
+#endif
+	return false;
+}
+
+void CCSMapOverview::ResetRound()
+{
+	BaseClass::ResetRound();
+
+	for (int i=0; i<MAX_PLAYERS; i++)
+	{
+		CSMapPlayer_t *p = &m_PlayersCSInfo[i];
+
+		p->isDead = false;
+
+		p->overrideFadeTime = -1;
+		p->overrideExpirationTime = -1;
+		p->overrideIcon = -1;
+		p->overrideIconOffscreen = -1;
+		p->overridePosition = Vector( 0, 0, 0);
+		p->overrideAngle = QAngle(0, 0, 0);
+
+		p->timeLastSeen = -1;
+		p->timeFirstSeen = -1;
+		p->isHostage = false;
+
+		p->flashUntilTime = -1;
+		p->nextFlashPeakTime = -1;
+		p->currentFlashAlpha = 0;
+	}
+
+	for (int i=0; i<MAX_HOSTAGES; i++)
+	{
+		MapPlayer_t *basep = &m_Hostages[i];
+		CSMapPlayer_t *p = &m_HostagesCSInfo[i];
+
+		basep->health = 100;
+		Q_memset( basep->trail, 0, sizeof(basep->trail) );
+		basep->position = Vector( 0, 0, 0 );
+		basep->index = 0;
+
+		p->isDead = false;
+
+		p->overrideFadeTime = -1;
+		p->overrideExpirationTime = -1;
+		p->overrideIcon = -1;
+		p->overrideIconOffscreen = -1;
+		p->overridePosition = Vector( 0, 0, 0);
+		p->overrideAngle = QAngle(0, 0, 0);
+
+		p->timeLastSeen = -1;
+		p->timeFirstSeen = -1;
+		p->isHostage = false;
+
+		p->flashUntilTime = -1;
+		p->nextFlashPeakTime = -1;
+		p->currentFlashAlpha = 0;
+	}
+
+	m_bomb.position = Vector(0,0,0);
+	m_bomb.state = CSMapBomb_t::BOMB_INVALID;
+	m_bomb.timeLastSeen = -1;
+	m_bomb.timeFirstSeen = -1;
+	m_bomb.timeFade = -1;
+	m_bomb.timeGone = -1;
+
+	m_bomb.currentRingRadius = -1;
+	m_bomb.currentRingAlpha = -1;
+	m_bomb.maxRingRadius = -1;
+	m_bomb.ringTravelTime = -1;
+
+	m_goalIconsLoaded = false;
+}
+
+void CCSMapOverview::DrawCamera()
+{
+	C_BasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
+
+	if (!localPlayer)
+		return;
+
+	if( localPlayer->GetObserverMode() == OBS_MODE_ROAMING )
+	{
+		// Instead of the programmer-art red dot, we'll draw an icon for when our camera is roaming.
+		int alpha = 255;
+		DrawIconCS(m_cameraIconFree, m_cameraIconFree, localPlayer->GetAbsOrigin(), m_flIconSize * 3.0f, localPlayer->EyeAngles()[YAW], alpha);
+	}
+	else if( localPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
+	{
+		if( localPlayer->GetObserverTarget() )
+		{
+			// Fade it if it is on top of a player dot.  And don't rotate it.
+			int alpha = 255 * 0.5f;
+			DrawIconCS(m_cameraIconFirst, m_cameraIconFirst, localPlayer->GetObserverTarget()->GetAbsOrigin(), m_flIconSize * 1.5f, GetViewAngle(), alpha);
+		}
+	}
+	else if( localPlayer->GetObserverMode() == OBS_MODE_CHASE )
+	{
+		if( localPlayer->GetObserverTarget() )
+		{
+			// Or Draw the third-camera a little bigger. (Needs room to be off the dot being followed)
+			int alpha = 255;
+			DrawIconCS(m_cameraIconThird, m_cameraIconThird, localPlayer->GetObserverTarget()->GetAbsOrigin(), m_flIconSize * 3.0f, localPlayer->EyeAngles()[YAW], alpha);
+		}
+	}
+}
+
+void CCSMapOverview::FireGameEvent( IGameEvent *event )
+{
+	const char * type = event->GetName();
+
+	if ( Q_strcmp(type,"hostage_killed") == 0 )
+	{
+		MapPlayer_t *hostage = GetHostageByEntityID( event->GetInt("hostage") );
+
+//		DevMsg("Hostage id %d just died.\n", event->GetInt("hostage"));
+
+		if ( !hostage )
+			return;
+
+		CSMapPlayer_t *hostageCS = GetCSInfoForHostage(hostage);
+
+		if ( !hostageCS )
+			return;
+
+		hostage->health = 0;
+		hostageCS->isDead = true;
+		Q_memset( hostage->trail, 0, sizeof(hostage->trail) ); // clear trails
+
+		hostageCS->overrideIcon = m_TeamIconsDead[MAP_ICON_HOSTAGE];
+		hostageCS->overrideIconOffscreen = hostageCS->overrideIcon;
+		hostageCS->overridePosition = hostage->position;
+		hostageCS->overrideAngle = hostage->angle;
+		hostageCS->overrideFadeTime = gpGlobals->curtime + DEATH_ICON_FADE;
+		hostageCS->overrideExpirationTime = gpGlobals->curtime + DEATH_ICON_DURATION;
+	}
+	else if ( Q_strcmp(type,"hostage_rescued") == 0 )
+	{
+		MapPlayer_t *hostage = GetHostageByEntityID( event->GetInt("hostage") );
+
+//		DevMsg("Hostage id %d just got rescued.\n", event->GetInt("hostage"));
+
+		if ( !hostage )
+			return;
+
+		CSMapPlayer_t *hostageCS = GetCSInfoForHostage(hostage);
+
+		if ( !hostageCS )
+			return;
+
+		hostage->health = 0;
+		hostageCS->isDead = true;
+		Q_memset( hostage->trail, 0, sizeof(hostage->trail) ); // clear trails
+
+		hostageCS->overrideIcon = hostage->icon;
+		hostageCS->overrideIconOffscreen = -1;
+		hostageCS->overridePosition = hostage->position;
+		hostageCS->overrideAngle = hostage->angle;
+		hostageCS->overrideFadeTime = gpGlobals->curtime;
+		hostageCS->overrideExpirationTime = gpGlobals->curtime + HOSTAGE_RESCUE_DURATION;
+	}
+	else if ( Q_strcmp(type,"bomb_defused") == 0 )
+	{
+		m_bomb.state = CSMapBomb_t::BOMB_GONE;
+		m_bomb.timeFade = gpGlobals->curtime;
+		m_bomb.timeGone = gpGlobals->curtime + BOMB_FADE_DURATION;
+	}
+	else if ( Q_strcmp(type,"bomb_exploded") == 0 )
+	{
+		m_bomb.state = CSMapBomb_t::BOMB_GONE;
+		m_bomb.timeFade = gpGlobals->curtime;
+		m_bomb.timeGone = gpGlobals->curtime + BOMB_FADE_DURATION;
+	}
+	else if ( Q_strcmp(type,"player_death") == 0 )
+	{
+		MapPlayer_t *player = GetPlayerByUserID( event->GetInt("userid") );
+
+		if ( !player )
+			return;
+
+		player->health = 0;
+		Q_memset( player->trail, 0, sizeof(player->trail) ); // clear trails
+
+		CSMapPlayer_t *playerCS = GetCSInfoForPlayer(player);
+
+		if ( !playerCS )
+			return;
+
+		playerCS->isDead = true;
+		playerCS->overrideIcon = m_TeamIconsDead[GetIconNumberFromTeamNumber(player->team)];
+		playerCS->overrideIconOffscreen = playerCS->overrideIcon;
+		playerCS->overridePosition = player->position;
+		playerCS->overrideAngle = player->angle;
+		playerCS->overrideFadeTime = gpGlobals->curtime + DEATH_ICON_FADE;
+		playerCS->overrideExpirationTime = gpGlobals->curtime + DEATH_ICON_DURATION;
+	}
+	else if ( Q_strcmp(type,"player_team") == 0 )
+	{
+		MapPlayer_t *player = GetPlayerByUserID( event->GetInt("userid") );
+
+		if ( !player )
+			return;
+
+		CBasePlayer *localPlayer = C_BasePlayer::GetLocalPlayer();
+		if( localPlayer == NULL )
+			return;
+		MapPlayer_t *localMapPlayer = GetPlayerByUserID(localPlayer->GetUserID());
+
+		player->team = event->GetInt("team");
+
+		if( player == localMapPlayer )
+			player->icon = m_TeamIconsSelf[ GetIconNumberFromTeamNumber(player->team) ];
+		else
+			player->icon = m_TeamIcons[ GetIconNumberFromTeamNumber(player->team) ];
+
+		player->color = m_TeamColors[ GetIconNumberFromTeamNumber(player->team) ];
+	}
+	else
+	{
+		BaseClass::FireGameEvent(event);
+	}
+}
+
+void CCSMapOverview::SetMode(int mode)
+{
+	if ( mode == MAP_MODE_RADAR )
+	{
+		m_flChangeSpeed = 0; // change size instantly
+		// We want the _output_ of the radar to be consistant, so we need to take the map scale in to account.
+		float desiredZoom = (DESIRED_RADAR_RESOLUTION * m_fMapScale) / (OVERVIEW_MAP_SIZE * m_fFullZoom);
+
+		g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( this, "zoom", desiredZoom, 0.0, 0, vgui::AnimationController::INTERPOLATOR_LINEAR );
+
+		if( CBasePlayer::GetLocalPlayer() )
+			SetFollowEntity( CBasePlayer::GetLocalPlayer()->entindex() );
+
+		SetPaintBackgroundType( 2 );// rounded corners
+		ShowPanel( true );
+	}
+	else if ( mode == MAP_MODE_INSET )
+	{
+		SetPaintBackgroundType( 2 );// rounded corners
+
+		float desiredZoom = (overview_preferred_view_size.GetFloat() * m_fMapScale) / (OVERVIEW_MAP_SIZE * m_fFullZoom);
+
+		g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( this, "zoom", desiredZoom, 0.0f, 0.2f, vgui::AnimationController::INTERPOLATOR_LINEAR );
+	}
+	else 
+	{
+		SetPaintBackgroundType( 0 );// square corners
+
+		float desiredZoom = 1.0f;
+
+		g_pClientMode->GetViewportAnimationController()->RunAnimationCommand( this, "zoom", desiredZoom, 0.0f, 0.2f, vgui::AnimationController::INTERPOLATOR_LINEAR );
+	}
+
+	BaseClass::SetMode(mode);
+}
+
+void CCSMapOverview::UpdateSizeAndPosition()
+{
+	int x,y,w,h;
+
+	vgui::surface()->GetScreenSize( w, h );
+
+	switch( m_nMode )
+	{
+	case MAP_MODE_RADAR:
+		{
+			// To allow custom hud scripts to work, get our size from the HudRadar element that people already tweak.
+			int x, y, w, t;
+			(GET_HUDELEMENT( CHudRadar ))->GetBounds(x, y, w, t);
+			m_vPosition.x = x;
+			m_vPosition.y = y;
+
+			if ( g_pSpectatorGUI && g_pSpectatorGUI->IsVisible() )
+			{
+				m_vPosition.y += g_pSpectatorGUI->GetTopBarHeight();
+			}
+
+			m_vSize.x = w;
+			m_vSize.y = w;// Intentionally not 't'.  We need to enforce square-ness to prevent people from seeing more of the map by fiddling their HudLayout
+			break;
+		}
+
+	case MAP_MODE_INSET:
+		{
+			m_vPosition.x = XRES(16);
+			m_vPosition.y = YRES(16);
+
+			if ( g_pSpectatorGUI && g_pSpectatorGUI->IsVisible() )
+			{
+				m_vPosition.y += g_pSpectatorGUI->GetTopBarHeight();
+			}
+
+			m_vSize.x = w/4;
+			m_vSize.y = m_vSize.x/1.333;
+			break;
+		}
+
+	case MAP_MODE_FULL:
+	default:
+		{
+			m_vSize.x = w;
+			m_vSize.y = h;
+
+			m_vPosition.x = 0;
+			m_vPosition.y = 0;
+
+			if ( g_pSpectatorGUI && g_pSpectatorGUI->IsVisible() )
+			{
+				m_vPosition.y += g_pSpectatorGUI->GetTopBarHeight();
+				m_vSize.y -= g_pSpectatorGUI->GetTopBarHeight();
+				m_vSize.y -= g_pSpectatorGUI->GetBottomBarHeight();
+			}
+			break;
+		}
+	}
+
+	GetBounds( x,y,w,h );
+
+	if ( m_flChangeSpeed > 0 )
+	{
+		// adjust slowly
+		int pixels = m_flChangeSpeed * gpGlobals->frametime;
+		x = AdjustValue( x, m_vPosition.x, pixels );
+		y = AdjustValue( y, m_vPosition.y, pixels );
+		w = AdjustValue( w, m_vSize.x, pixels );
+		h = AdjustValue( h, m_vSize.y, pixels );
+	}
+	else
+	{
+		// set instantly
+		x = m_vPosition.x;
+		y = m_vPosition.y;
+		w = m_vSize.x;
+		h = m_vSize.y;
+	}
+
+	SetBounds( x,y,w,h );
+}
+
+void CCSMapOverview::SetPlayerSeen( int index )
+{
+	CSMapPlayer_t *pCS = GetCSInfoForPlayerIndex(index);
+
+	float now = gpGlobals->curtime;
+
+	if( pCS )
+	{
+		if( pCS->timeLastSeen == -1 )
+			pCS->timeFirstSeen = now;
+
+		pCS->timeLastSeen = now;
+	}
+}
+
+void CCSMapOverview::SetBombSeen( bool seen )
+{
+	if( seen )
+	{
+		float now = gpGlobals->curtime;
+
+		if( m_bomb.timeLastSeen == -1 )
+			m_bomb.timeFirstSeen = now;
+
+		m_bomb.timeLastSeen = now;
+	}
+	else
+	{
+		m_bomb.timeFirstSeen = -1;
+		m_bomb.timeLastSeen = -1;
+	}
+}
+
+void CCSMapOverview::FlashEntity( int entityID )
+{
+	MapPlayer_t *player = GetPlayerByEntityID(entityID);
+	if( player == NULL )
+		return;
+
+	CSMapPlayer_t *playerCS = GetCSInfoForPlayer(player);
+
+	if ( !playerCS )
+		return;
+
+	playerCS->flashUntilTime = gpGlobals->curtime + 2.0f;
+	playerCS->currentFlashAlpha = 255;
+	playerCS->nextFlashPeakTime = gpGlobals->curtime + 0.5f;
+}
+
+void CCSMapOverview::UpdateFlashes()
+{
+	float now = gpGlobals->curtime;
+	for (int i=0; i<MAX_PLAYERS; i++)
+	{
+		CSMapPlayer_t *playerCS = GetCSInfoForPlayerIndex(i);
+		if( playerCS->flashUntilTime <= now )
+		{
+			// Flashing over.
+			playerCS->currentFlashAlpha = 0;
+		}
+		else
+		{
+			if( playerCS->nextFlashPeakTime <= now )
+			{
+				// Time for a peak
+				playerCS->currentFlashAlpha = 255;
+				playerCS->nextFlashPeakTime = now + 0.5f;
+				playerCS->nextFlashPeakTime = MIN( playerCS->nextFlashPeakTime, playerCS->flashUntilTime );
+			}
+			else
+			{
+				// Just fade away
+				playerCS->currentFlashAlpha -= ((playerCS->currentFlashAlpha * gpGlobals->frametime) / (playerCS->nextFlashPeakTime - now));
+				playerCS->currentFlashAlpha = MAX( 0, playerCS->currentFlashAlpha );
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+void CCSMapOverview::SetPlayerPreferredMode( int mode )
+{
+	// A player has given an explicit overview_mode command, so we need to honor that when we are done being the radar.
+	m_playerPreferredMode = mode;
+
+	// save off non-radar preferred modes
+	switch ( mode )
+	{
+	case MAP_MODE_OFF:
+		overview_preferred_mode.SetValue( MAP_MODE_OFF );
+		break;
+
+	case MAP_MODE_INSET:
+		overview_preferred_mode.SetValue( MAP_MODE_INSET );
+		break;
+
+	case MAP_MODE_FULL:
+		overview_preferred_mode.SetValue( MAP_MODE_FULL );
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void CCSMapOverview::SetPlayerPreferredViewSize( float viewSize )
+{
+	overview_preferred_view_size.SetValue( viewSize );
+}
+
+
+//-----------------------------------------------------------------------------
+int CCSMapOverview::GetIconNumberFromTeamNumber( int teamNumber )
+{
+	switch(teamNumber) 
+	{
+	case TEAM_TERRORIST:
+		return MAP_ICON_T;
+
+	case TEAM_CT:
+		return MAP_ICON_CT;
+
+	default:
+		return MAP_ICON_HOSTAGE;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void CCSMapOverview::ClearGoalIcons()
+{
+	m_goalIcons.RemoveAll();
+}
+
+//-----------------------------------------------------------------------------
+void CCSMapOverview::UpdateGoalIcons()
+{
+	// The goal entities don't exist on the client, so we have to get them from the CS Resource.
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+	if ( !pCSPR )
+		return;
+
+	Vector bombA = pCSPR->GetBombsiteAPosition();
+	if( bombA != vec3_origin )
+	{
+		CSMapGoal_t bombGoalA;
+		bombGoalA.position = bombA;
+		bombGoalA.iconToUse = m_bombSiteIconA;
+		m_goalIcons.AddToTail( bombGoalA );
+		m_goalIconsLoaded = true;
+	}
+
+	Vector bombB = pCSPR->GetBombsiteBPosition();
+	if( bombB != vec3_origin )
+	{
+		CSMapGoal_t bombGoalB;
+		bombGoalB.position = bombB;
+		bombGoalB.iconToUse = m_bombSiteIconB;
+		m_goalIcons.AddToTail( bombGoalB );
+		m_goalIconsLoaded = true;
+	}
+
+	for( int rescueIndex = 0; rescueIndex < MAX_HOSTAGE_RESCUES; rescueIndex++ )
+	{
+		Vector hostageI = pCSPR->GetHostageRescuePosition( rescueIndex );
+		if( hostageI != vec3_origin )
+		{
+			CSMapGoal_t hostageGoalI;
+			hostageGoalI.position = hostageI;
+			hostageGoalI.iconToUse = m_hostageRescueIcon;
+			m_goalIcons.AddToTail( hostageGoalI );
+			m_goalIconsLoaded = true;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void CCSMapOverview::DrawGoalIcons()
+{
+	for( int iconIndex = 0; iconIndex < m_goalIcons.Count(); iconIndex++ )
+	{
+		// Goal icons are drawn without turning, but with edge adjustment.
+		CSMapGoal_t *currentIcon = &(m_goalIcons[iconIndex]);
+		int alpha = 255;
+		DrawIconCS(currentIcon->iconToUse, currentIcon->iconToUse, currentIcon->position, m_flIconSize, GetViewAngle(), alpha, false);
+	}
+}
+
+//-----------------------------------------------------------------------------
+bool CCSMapOverview::IsRadarLocked() 
+{
+	return cl_radar_locked.GetBool();
+}
+
+//-----------------------------------------------------------------------------
+int CCSMapOverview::GetMasterAlpha( void )
+{
+	// The master alpha is the alpha that the map wants to draw at.  The background will be at half that, and the icons
+	// will always be full.  (The icons fade themselves for functional reasons like seen-recently.)
+	int alpha = 255;
+	if( GetMode() == MAP_MODE_RADAR )
+		alpha = cl_radaralpha.GetInt();
+	else
+		alpha = overview_alpha.GetFloat() * 255;
+	alpha = clamp( alpha, 0, 255 );
+
+	return alpha;
+}
+
+//-----------------------------------------------------------------------------
+int CCSMapOverview::GetBorderSize( void )
+{
+	switch( GetMode() )
+	{
+		case MAP_MODE_RADAR:
+			return 4;
+		case MAP_MODE_INSET:
+			return 4;
+		case MAP_MODE_FULL:
+		default:
+			return 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+Vector2D CCSMapOverview::PanelToMap( const Vector2D &panelPos )
+{
+	// This is the reversing of baseclass's MapToPanel
+	int pwidth, pheight; 
+	GetSize(pwidth, pheight);
+	float viewAngle = GetViewAngle();
+	float fScale = (m_fZoom * m_fFullZoom) / OVERVIEW_MAP_SIZE;
+
+	Vector offset;
+	offset.x = (panelPos.x - (pwidth * 0.5f)) / pheight;
+	offset.y = (panelPos.y - (pheight * 0.5f)) / pheight;
+
+	offset.x /= fScale;
+	offset.y /= fScale;
+
+	VectorYawRotate( offset, -viewAngle, offset );
+
+	Vector2D mapPos;
+	mapPos.x = offset.x + m_MapCenter.x;
+	mapPos.y = offset.y + m_MapCenter.y;
+
+	return mapPos;
+}
diff --git a/game/client/cstrike/VGUI/cstrikespectatorgui.h b/game/client/cstrike/VGUI/cstrikespectatorgui.h
new file mode 100644
index 00000000..5064812b
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstrikespectatorgui.h
@@ -0,0 +1,279 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSSPECTATORGUI_H
+#define CSSPECTATORGUI_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "spectatorgui.h"
+#include "mapoverview.h"
+#include "cs_shareddefs.h"
+
+extern ConVar mp_playerid; // in cs_gamerules.h
+extern ConVar mp_forcecamera; // in gamevars_shared.h
+extern ConVar mp_fadetoblack;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Cstrike Spectator UI
+//-----------------------------------------------------------------------------
+class CCSSpectatorGUI : public CSpectatorGUI
+{
+private:
+	DECLARE_CLASS_SIMPLE( CCSSpectatorGUI, CSpectatorGUI );
+
+public:
+	CCSSpectatorGUI( IViewPort *pViewPort );
+		
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	virtual void UpdateSpectatorPlayerList( void );
+	virtual void Update( void );
+	virtual bool NeedsUpdate( void );
+	//=============================================================================
+	// HPE_BEGIN:
+	// [smessick]
+	//=============================================================================
+	virtual void ShowPanel( bool bShow );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+protected:
+
+	void UpdateTimer();
+	void UpdateAccount();
+
+	int		m_nLastAccount;
+	int		m_nLastTime;
+	int		m_nLastSpecMode;
+	CBaseEntity	*m_nLastSpecTarget;
+
+	void StoreWidths( void );
+	void ResizeControls( void );
+	bool ControlsPresent( void ) const;
+
+	vgui::Label *m_pCTLabel;
+	vgui::Label *m_pCTScore;
+	vgui::Label *m_pTerLabel;
+	vgui::Label *m_pTerScore;
+	vgui::Label *m_pTimer;
+	vgui::Label *m_pTimerLabel;
+	vgui::Panel *m_pDivider;
+	vgui::Label *m_pExtraInfo;
+
+	bool m_modifiedWidths;
+
+	int m_scoreWidth;
+	int m_extraInfoWidth;
+};
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+#define DESIRED_RADAR_RESOLUTION 450 
+
+class CCSMapOverview : public CMapOverview
+{
+	DECLARE_CLASS_SIMPLE( CCSMapOverview, CMapOverview );
+
+public:	
+
+	enum
+	{
+		MAP_ICON_T = 0,
+		MAP_ICON_CT,
+		MAP_ICON_HOSTAGE,
+		MAP_ICON_COUNT
+	};
+
+	CCSMapOverview( const char *pElementName );
+	virtual ~CCSMapOverview();
+
+	virtual bool ShouldDraw( void );
+	vgui::Panel *GetAsPanel(){ return this; }
+	virtual bool AllowConCommandsWhileAlive(){return false;}
+	virtual void SetPlayerPreferredMode( int mode );
+	virtual void SetPlayerPreferredViewSize( float viewSize );
+	virtual void ApplySchemeSettings( vgui::IScheme *scheme );
+
+protected:	// private structures & types
+
+	// list of game events the hLTV takes care of
+
+	typedef struct {
+		int		xpos;
+		int		ypos;
+	} FootStep_t;	
+
+	// Extra stuff in a this-level parallel array
+	typedef struct CSMapPlayer_s {
+		int		overrideIcon; // if not -1, the icon to use instead
+		int		overrideIconOffscreen; // to use with overrideIcon
+		float	overrideFadeTime; // Time to start fading the override icon
+		float	overrideExpirationTime; // Time to not use the override icon any more
+		Vector	overridePosition; // Where the overridden icon will draw
+		QAngle	overrideAngle; // And at what angle
+		bool	isDead;		// Death latch, since client can be behind the times on health messages.
+		float	timeLastSeen; // curtime that we last saw this guy.
+		float	timeFirstSeen; // curtime that we started seeing this guy
+		bool	isHostage;	// Not a full player, a hostage.  Special icon, different death event
+		float	flashUntilTime;
+		float	nextFlashPeakTime;
+		int		currentFlashAlpha;
+	} CSMapPlayer_t;
+
+	typedef struct CSMapBomb_s
+	{
+		Vector position;
+
+		enum BombState
+		{
+			BOMB_PLANTED,	//planted and ticking down
+			BOMB_DROPPED,	//dropped and lying loose
+			BOMB_CARRIED,	//in the arms of a player
+			BOMB_GONE,		//defused or exploded, but was planted
+			BOMB_INVALID	//no bomb
+		};
+		BombState state;
+
+		float timeLastSeen;
+		float timeFirstSeen;
+		float timeFade;
+		float timeGone;
+
+		float currentRingRadius;
+		float currentRingAlpha;
+		float maxRingRadius;
+		float ringTravelTime;
+	} CSMapBomb_t;
+
+	typedef struct CSMapGoal_s
+	{
+		Vector position;
+		int iconToUse;
+	} CSMapGoal_t;
+
+public: // IViewPortPanel interface:
+
+	virtual void Update();
+	virtual void Init( void );
+
+	// both vgui::Frame and IViewPortPanel define these, so explicitly define them here as passthroughs to vgui
+	vgui::VPANEL GetVPanel( void ) { return BaseClass::GetVPanel(); }
+	virtual bool IsVisible() { return BaseClass::IsVisible(); }
+	virtual void SetParent(vgui::VPANEL parent) { BaseClass::SetParent(parent); }
+
+	// IGameEventListener
+
+	virtual void FireGameEvent( IGameEvent *event);
+
+	// VGUI overrides
+
+	// Player settings:
+	void SetPlayerSeen( int index );
+	void SetBombSeen( bool seen );
+
+	// general settings:
+	virtual void SetMap(const char * map);
+	virtual void SetMode( int mode );
+
+	// Object settings
+	virtual void	FlashEntity( int entityID );
+
+	// rules that define if you can see a player on the overview or not
+	virtual bool CanPlayerBeSeen(MapPlayer_t *player);
+
+	virtual int GetIconNumberFromTeamNumber( int teamNumber );
+
+protected:
+
+	virtual void	DrawCamera();
+	virtual void	DrawMapTexture();
+	virtual void	DrawMapPlayers();
+	void			DrawHostages();
+	void			DrawBomb();
+	void			DrawGoalIcons();
+	virtual void	ResetRound();
+	virtual void	InitTeamColorsAndIcons();
+	virtual void	UpdateSizeAndPosition();
+	void			UpdateGoalIcons();
+	void			ClearGoalIcons();
+	virtual bool	IsRadarLocked();
+	Vector2D		PanelToMap( const Vector2D &panelPos );
+
+	bool			AdjustPointToPanel(Vector2D *pos);
+	MapPlayer_t*	GetPlayerByEntityID( int entityID );
+	MapPlayer_t*	GetHostageByEntityID( int entityID );
+	virtual void	UpdatePlayers();
+	void			UpdateHostages();///< Update hostages in the MapPlayer list
+	void			UpdateBomb();
+	void			UpdateFlashes();
+	bool			CreateRadarImage(const char *mapName, const char *radarFileName);
+	virtual bool	RunHudAnimations(){ return false; }
+
+private:
+	bool			DrawIconCS(	int textureID,
+		int offscreenTextureID,
+		Vector pos,
+		float scale,
+		float angle,
+		int alpha,
+		bool allowRotation = true,
+		const char *text = NULL,
+		Color *textColor = NULL,
+		float status = -1,
+		Color *statusColor = NULL 
+		);
+
+	int GetMasterAlpha( void );// The main alpha that the map part should be, determined by using the mode to look at the right convar
+	int GetBorderSize( void );// How far in from the edge of the panel we draw, based on mode.  Let's the background fancy corners show.
+	CSMapPlayer_t* GetCSInfoForPlayerIndex( int index );
+	CSMapPlayer_t* GetCSInfoForPlayer(MapPlayer_t *player);
+	CSMapPlayer_t* GetCSInfoForHostage(MapPlayer_t *hostage);
+	bool CanHostageBeSeen(MapPlayer_t *hostage);
+
+	CSMapPlayer_t	m_PlayersCSInfo[MAX_PLAYERS];
+	CSMapBomb_t		m_bomb;
+	MapPlayer_t		m_Hostages[MAX_HOSTAGES];
+	CSMapPlayer_t	m_HostagesCSInfo[MAX_HOSTAGES];
+
+	CUtlVector< CSMapGoal_t > m_goalIcons;
+	bool m_goalIconsLoaded;
+
+	int		m_TeamIconsSelf[MAP_ICON_COUNT];
+	int		m_TeamIconsDead[MAP_ICON_COUNT];
+	int		m_TeamIconsOffscreen[MAP_ICON_COUNT];
+	int		m_TeamIconsDeadOffscreen[MAP_ICON_COUNT];
+
+	int		m_bombIconPlanted;
+	int		m_bombIconDropped;
+	int		m_bombIconCarried;
+	int		m_bombRingPlanted;
+	int		m_bombRingDropped;
+	int		m_bombRingCarried;
+	int		m_bombRingCarriedOffscreen;
+	int		m_radioFlash;
+	int		m_radioFlashOffscreen;
+	int		m_radarTint;
+	int		m_hostageFollowing;
+	int		m_hostageFollowingOffscreen;
+	int		m_playerFacing;
+	int		m_cameraIconFirst;
+	int		m_cameraIconThird;
+	int		m_cameraIconFree;
+	int		m_hostageRescueIcon;
+	int		m_bombSiteIconA;
+	int		m_bombSiteIconB;
+
+	int	 m_nRadarMapTextureID;	// texture id for radar version of current overview image
+
+	int m_playerPreferredMode; // The mode the player wants to be in for when we aren't being the radar
+};
+
+#endif // CSSPECTATORGUI_H
diff --git a/game/client/cstrike/VGUI/cstriketeammenu.cpp b/game/client/cstrike/VGUI/cstriketeammenu.cpp
new file mode 100644
index 00000000..4b390881
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstriketeammenu.cpp
@@ -0,0 +1,201 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cstriketeammenu.h"
+#include "backgroundpanel.h"
+#include <convar.h>
+#include "hud.h" // for gEngfuncs
+#include "c_cs_player.h"
+#include "cs_gamerules.h"
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSTeamMenu::CCSTeamMenu(IViewPort *pViewPort) : CTeamMenu(pViewPort)
+{
+	CreateBackground( this );
+	m_backgroundLayoutFinished = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CCSTeamMenu::~CCSTeamMenu()
+{
+}
+
+void CCSTeamMenu::ShowPanel(bool bShow)
+{
+	if ( bShow )
+	{
+		engine->CheckPoint( "TeamMenu" );
+	}
+
+	BaseClass::ShowPanel( bShow );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called to update the menu with new information
+//-----------------------------------------------------------------------------
+void CCSTeamMenu::Update( void )
+{
+	BaseClass::Update();
+
+	const ConVar *allowspecs =  cvar->FindVar( "mp_allowspectators" );
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	
+	if ( !pPlayer || !CSGameRules() )
+		return;
+
+	if ( allowspecs && allowspecs->GetBool() )
+	{
+		// if we're not already a CT or T...or the freeze time isn't over yet...or we're dead
+		if ( pPlayer->GetTeamNumber() == TEAM_UNASSIGNED || 
+			CSGameRules()->IsFreezePeriod() || 
+			( pPlayer && pPlayer->IsPlayerDead() ) )
+		{
+			SetVisibleButton("specbutton", true);
+		}
+		else
+		{
+			SetVisibleButton("specbutton", false);
+		}
+	}
+	else
+	{
+		SetVisibleButton("specbutton", false );
+	}
+
+	m_bVIPMap = false;
+
+	char mapName[MAX_MAP_NAME];
+
+	Q_FileBase( engine->GetLevelName(), mapName, sizeof(mapName) );
+
+	if ( !Q_strncmp( mapName, "maps/as_", 8 ) )
+	{
+		m_bVIPMap = true;
+	}
+		
+	// if this isn't a VIP map or we're a spectator/terrorist, then disable the VIP button
+	if ( !CSGameRules()->IsVIPMap() || ( pPlayer->GetTeamNumber() != TEAM_CT ) )
+	{
+		SetVisibleButton("vipbutton", false);
+	}
+	else // this must be a VIP map and we must already be a CT
+	{
+		SetVisibleButton("vipbutton", true);
+	}
+
+	if( pPlayer->GetTeamNumber() == TEAM_UNASSIGNED ) // we aren't on a team yet
+	{
+		SetVisibleButton("CancelButton", false); 
+	}
+	else
+	{
+		SetVisibleButton("CancelButton", true); 
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSTeamMenu::SetVisible(bool state)
+{
+	BaseClass::SetVisible(state);
+
+	if ( state )
+	{
+		Button *pAutoButton = dynamic_cast< Button* >( FindChildByName( "autobutton" ) );
+		if ( pAutoButton )
+		{
+			pAutoButton->RequestFocus();
+			pAutoButton->SetArmed( true );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: When a team button is pressed it triggers this function to 
+//			cause the player to join a team
+//-----------------------------------------------------------------------------
+void CCSTeamMenu::OnCommand( const char *command )
+{
+	if ( Q_stricmp( command, "vguicancel" ) )
+	{
+		engine->ClientCmd( command );
+	}
+	
+	
+	BaseClass::OnCommand(command);
+
+	gViewPortInterface->ShowBackGround( false );
+	OnClose();
+}
+
+
+void CCSTeamMenu::OnKeyCodePressed( vgui::KeyCode code )
+{
+	if ( code == KEY_ENTER )
+	{
+		Button *pAutoButton = dynamic_cast< Button* >( FindChildByName( "autobutton" ) );
+		if ( pAutoButton )
+		{
+			pAutoButton->DoClick();
+		}
+	}
+	else
+	{
+		BaseClass::OnKeyCodePressed( code );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the visibility of a button by name
+//-----------------------------------------------------------------------------
+void CCSTeamMenu::SetVisibleButton(const char *textEntryName, bool state)
+{
+	Button *entry = dynamic_cast<Button *>(FindChildByName(textEntryName));
+	if (entry)
+	{
+		entry->SetVisible(state);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The CS background is painted by image panels, so we should do nothing
+//-----------------------------------------------------------------------------
+void CCSTeamMenu::PaintBackground()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Scale / center the window
+//-----------------------------------------------------------------------------
+void CCSTeamMenu::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// stretch the window to fullscreen
+	if ( !m_backgroundLayoutFinished )
+		LayoutBackgroundPanel( this );
+	m_backgroundLayoutFinished = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSTeamMenu::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	ApplyBackgroundSchemeSettings( this, pScheme );
+}
+
diff --git a/game/client/cstrike/VGUI/cstriketeammenu.h b/game/client/cstrike/VGUI/cstriketeammenu.h
new file mode 100644
index 00000000..7b2ab0e8
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstriketeammenu.h
@@ -0,0 +1,54 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSTEAMMENU_H
+#define CSTEAMMENU_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <teammenu.h>
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays the team menu
+//-----------------------------------------------------------------------------
+class CCSTeamMenu : public CTeamMenu
+{
+private:
+	DECLARE_CLASS_SIMPLE( CCSTeamMenu, CTeamMenu );
+		
+public:
+	CCSTeamMenu(IViewPort *pViewPort);
+	~CCSTeamMenu();
+
+	void Update();
+	void ShowPanel( bool bShow );
+	virtual void SetVisible(bool state);
+
+private:
+	enum { NUM_TEAMS = 3 };
+
+	// VGUI2 override
+	virtual void OnCommand( const char *command);
+	virtual void OnKeyCodePressed( vgui::KeyCode code );
+	// helper functions
+	void SetVisibleButton(const char *textEntryName, bool state);
+
+	bool m_bVIPMap;
+
+	// Background panel -------------------------------------------------------
+
+public:
+	virtual void PaintBackground();
+	virtual void PerformLayout();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	bool m_backgroundLayoutFinished;
+
+	// End background panel ---------------------------------------------------
+};
+
+#endif // CSTEAMMENU_H
diff --git a/game/client/cstrike/VGUI/cstriketextwindow.cpp b/game/client/cstrike/VGUI/cstriketextwindow.cpp
new file mode 100644
index 00000000..feedd23f
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstriketextwindow.cpp
@@ -0,0 +1,146 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cstriketextwindow.h"
+#include "backgroundpanel.h"
+#include <cdll_client_int.h>
+
+#include <vgui/IScheme.h>
+#include <vgui/ILocalize.h>
+#include <vgui/ISurface.h>
+#include <filesystem.h>
+#include <KeyValues.h>
+#include <convar.h>
+#include <vgui_controls/ImageList.h>
+
+#include <vgui_controls/TextEntry.h>
+#include <vgui_controls/Button.h>
+#include <vgui_controls/BuildGroup.h>
+
+#include "IGameUIFuncs.h" // for key bindings
+#include <igameresources.h>
+extern IGameUIFuncs *gameuifuncs; // for key binding details
+
+#include <game/client/iviewport.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSTextWindow::CCSTextWindow(IViewPort *pViewPort) : CTextWindow( pViewPort )
+{
+	SetProportional( true );
+
+	m_iScoreBoardKey = BUTTON_CODE_INVALID; // this is looked up in Activate()
+
+	CreateBackground( this );
+	m_backgroundLayoutFinished = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CCSTextWindow::~CCSTextWindow()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSTextWindow::Update()
+{
+	BaseClass::Update();
+
+	m_pOK->RequestFocus();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSTextWindow::SetVisible(bool state)
+{
+	BaseClass::SetVisible(state);
+
+	if ( state )
+	{
+		m_pOK->RequestFocus();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: shows the text window
+//-----------------------------------------------------------------------------
+void CCSTextWindow::ShowPanel(bool bShow)
+{
+	if ( bShow )
+	{
+		// get key binding if shown
+		if ( m_iScoreBoardKey == BUTTON_CODE_INVALID ) // you need to lookup the jump key AFTER the engine has loaded
+		{
+			m_iScoreBoardKey = gameuifuncs->GetButtonCodeForBind( "showscores" );
+		}
+	}
+
+	BaseClass::ShowPanel( bShow );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSTextWindow::OnKeyCodePressed( KeyCode code )
+{
+	//We manually intercept the ENTER key so in case the button loses focus
+	//ENTER still moves you through the MOTD screen.
+	if ( code == KEY_ENTER || code == KEY_XBUTTON_A || code == KEY_XBUTTON_B )
+	{
+		m_pOK->DoClick();
+	}	
+	else if ( m_iScoreBoardKey != BUTTON_CODE_INVALID && m_iScoreBoardKey == code )
+	{
+		gViewPortInterface->ShowPanel( PANEL_SCOREBOARD, true );
+		gViewPortInterface->PostMessageToPanel( PANEL_SCOREBOARD, new KeyValues( "PollHideCode", "code", code ) );
+	}
+	else
+	{
+		BaseClass::OnKeyCodePressed( code );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The CS background is painted by image panels, so we should do nothing
+//-----------------------------------------------------------------------------
+void CCSTextWindow::PaintBackground()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Scale / center the window
+//-----------------------------------------------------------------------------
+void CCSTextWindow::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	// stretch the window to fullscreen
+	if ( !m_backgroundLayoutFinished )
+		LayoutBackgroundPanel( this );
+	m_backgroundLayoutFinished = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSTextWindow::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	ApplyBackgroundSchemeSettings( this, pScheme );
+}
+
diff --git a/game/client/cstrike/VGUI/cstriketextwindow.h b/game/client/cstrike/VGUI/cstriketextwindow.h
new file mode 100644
index 00000000..bd7c707a
--- /dev/null
+++ b/game/client/cstrike/VGUI/cstriketextwindow.h
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSTEXTWINDOW_H
+#define CSTEXTWINDOW_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vguitextwindow.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: displays the MOTD
+//-----------------------------------------------------------------------------
+
+class CCSTextWindow : public CTextWindow
+{
+private:
+	DECLARE_CLASS_SIMPLE( CCSTextWindow, CTextWindow );
+
+public:
+	CCSTextWindow(IViewPort *pViewPort);
+	virtual ~CCSTextWindow();
+
+	virtual void Update();
+	virtual void SetVisible(bool state);
+	virtual void ShowPanel( bool bShow );
+	virtual void OnKeyCodePressed(vgui::KeyCode code);
+
+protected:
+	ButtonCode_t m_iScoreBoardKey;
+
+	// Background panel -------------------------------------------------------
+
+public:
+	virtual void PaintBackground();
+	virtual void PerformLayout();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	bool m_backgroundLayoutFinished;
+
+	// End background panel ---------------------------------------------------
+};
+
+
+#endif // CSTEXTWINDOW_H
diff --git a/game/client/cstrike/VGUI/lifetime_stats_page.cpp b/game/client/cstrike/VGUI/lifetime_stats_page.cpp
new file mode 100644
index 00000000..89c01296
--- /dev/null
+++ b/game/client/cstrike/VGUI/lifetime_stats_page.cpp
@@ -0,0 +1,257 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "lifetime_stats_page.h"
+#include <vgui_controls/SectionedListPanel.h>
+#include "cs_client_gamestats.h"
+
+using namespace vgui;
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: creates child panels, passes down name to pick up any settings from res files.
+//-----------------------------------------------------------------------------
+CLifetimeStatsPage::CLifetimeStatsPage(vgui::Panel *parent, const char *name) : BaseClass(parent, "CSLifetimeStatsDialog")
+{
+	m_allStatsGroupPanel =					AddGroup( L"all",      "Stats_Button_All",       L"All" );
+	m_detailedWeaponStatsGroupPanel =		AddGroup( L"weapon",   "Stats_Button_Weapon",    L"Weapon Stats" );
+	m_specialSkillsStatsGroupPanel =		AddGroup( L"skills",   "Stats_Button_Skills",    L"Special Skills" );
+	m_mapAndMiscellanyStatsGroupPanel =		AddGroup( L"map",      "Stats_Button_Misc",      L"Miscellaneous" );
+	m_mapVictoryStatsGroupPanel =			AddGroup( L"map",      "Stats_Button_Victories", L"Map Victories" );
+	m_missionAndObjectiveStatsGroupPanel =	AddGroup( L"mission",  "Stats_Button_Mission",   L"Mission && Objectives" );
+
+	m_allStatsGroupPanel->SetGroupActive(true);
+}
+//-----------------------------------------------------------------------------
+// Purpose: Loads settings from statsdialog.res in hl2/resource/ui/
+//-----------------------------------------------------------------------------
+void CLifetimeStatsPage::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	LoadControlSettings("resource/ui/CSLifetimeStatsDialog.res");
+
+	m_statsList->AddColumnToSection( 0, "name", "", SectionedListPanel::COLUMN_CENTER, 280);
+	m_statsList->AddColumnToSection( 0, "playerValue", "", SectionedListPanel::COLUMN_CENTER, 250);
+}
+
+void CLifetimeStatsPage::RepopulateStats()
+{
+	m_statsList->RemoveAll();
+
+	const StatsCollection_t& personalLifetimeStats = g_CSClientGameStats.GetLifetimeStats();
+
+	if (m_missionAndObjectiveStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		AddSimpleStat(CSSTAT_ROUNDS_WON, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_KILLS, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_DEATHS, personalLifetimeStats);
+		AddKillToDeathStat(personalLifetimeStats);
+		AddSimpleStat(CSSTAT_DAMAGE, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_NUM_BOMBS_PLANTED, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_NUM_BOMBS_DEFUSED, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_NUM_HOSTAGES_RESCUED, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_PISTOLROUNDS_WON, personalLifetimeStats);
+	}
+
+	if (m_specialSkillsStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		AddSimpleStat(CSSTAT_MVPS, personalLifetimeStats);
+		AddFavoriteWeaponStat(personalLifetimeStats);
+		AddSimpleStat(CSSTAT_SHOTS_FIRED, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_SHOTS_HIT, personalLifetimeStats);
+		AddAccuracyStat(personalLifetimeStats);
+		AddSimpleStat(CSSTAT_DOMINATIONS, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_DOMINATION_OVERKILLS, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_REVENGES, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_KILLS_HEADSHOT, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_KILLS_AGAINST_ZOOMED_SNIPER, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_KILLS_ENEMY_BLINDED, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_KILLS_ENEMY_WEAPON, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_KILLS_KNIFE_FIGHT, personalLifetimeStats);
+	}
+
+	if (m_mapAndMiscellanyStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		AddSimpleStat(CSSTAT_MONEY_EARNED, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_DECAL_SPRAYS, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_NIGHTVISION_DAMAGE, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_NUM_BROKEN_WINDOWS, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_WEAPONS_DONATED, personalLifetimeStats);
+	}
+
+	if (m_mapVictoryStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		AddSimpleStat(CSSTAT_MAP_WINS_CS_ASSAULT, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_CS_COMPOUND, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_CS_HAVANA, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_CS_ITALY, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_CS_MILITIA, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_CS_OFFICE, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_AZTEC, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_CBBLE, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_CHATEAU, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_DUST2, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_DUST, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_INFERNO, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_NUKE, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_PIRANESI, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_PORT, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_PRODIGY, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_TIDES, personalLifetimeStats);
+		AddSimpleStat(CSSTAT_MAP_WINS_DE_TRAIN, personalLifetimeStats);
+	}
+
+
+	if (m_detailedWeaponStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		CSStatType_t hitsStat = CSSTAT_HITS_DEAGLE;
+		CSStatType_t shotsStat = CSSTAT_SHOTS_DEAGLE;
+		for (CSStatType_t killStat = CSSTAT_KILLS_DEAGLE ; killStat <= CSSTAT_KILLS_HEGRENADE ; killStat = (CSStatType_t)(killStat + 1))
+		{
+			if (shotsStat <= CSSTAT_SHOTS_M249)
+			{
+				AddSimpleStat(shotsStat, personalLifetimeStats);
+			}
+			if (hitsStat <= CSSTAT_HITS_M249)
+			{
+				AddSimpleStat(hitsStat, personalLifetimeStats);
+			}
+			AddSimpleStat(killStat, personalLifetimeStats);
+
+			hitsStat = (CSStatType_t)(hitsStat + 1);
+			shotsStat = (CSStatType_t)(shotsStat + 1);
+		}
+	}
+
+	int itemCount = m_statsList->GetItemCount();
+	for (int i = 0; i < itemCount ; ++i)
+	{
+		m_statsList->SetItemBgColor(i, Color(0,0,0,0));
+	}
+}
+
+int CLifetimeStatsPage::AddSimpleStat( int desiredStat, const StatsCollection_t& personalLifetimeStats)
+{
+	PlayerStatData_t stat = g_CSClientGameStats.GetStatById(desiredStat);
+
+	KeyValues *pKeyValues = new KeyValues( "data" );
+	pKeyValues->SetWString( "name", stat.pStatDisplayName );
+	pKeyValues->SetFloat( "playerValue", 0 );
+
+	char buf[64];
+	Q_snprintf( buf, sizeof( buf ), "%d", personalLifetimeStats[stat.iStatId] );
+	pKeyValues->SetString( "playerValue", (personalLifetimeStats[stat.iStatId])?buf:"" );
+
+	int newItem = m_statsList->AddItem(0, pKeyValues);
+	pKeyValues->deleteThis();
+
+	m_statsList->SetItemFont(newItem , m_listItemFont);
+	m_statsList->SetItemFgColor(newItem, Color(197,197,197,255));
+
+	return newItem;
+}
+
+int CLifetimeStatsPage::AddFavoriteWeaponStat(const StatsCollection_t& personalLifetimeStats)
+{
+	PlayerStatData_t statPlayerBestWeapon;
+	statPlayerBestWeapon.iStatId = CSSTAT_UNDEFINED;
+
+	int previousBestKills = 0;
+
+	for (CSStatType_t statId = CSSTAT_KILLS_DEAGLE ; statId <= CSSTAT_KILLS_M249; statId = (CSStatType_t)(statId + 1))
+	{
+		PlayerStatData_t stat = g_CSClientGameStats.GetStatById( statId );
+
+		//Compare this to previous Weapons
+		int playerKillsWithWeapon = personalLifetimeStats[statId];
+		{
+			if (playerKillsWithWeapon > previousBestKills)
+			{
+				statPlayerBestWeapon = stat;
+				previousBestKills = playerKillsWithWeapon;
+			}
+		}
+	}
+
+	KeyValues *pKeyValues = new KeyValues( "data" );
+	pKeyValues->SetWString( "name", LocalizeTagOrUseDefault( "Stats_FavoriteWeapon", L"Favorite Weapon" ) );
+
+	pKeyValues->SetWString( "playerValue", TranslateWeaponKillIDToAlias(statPlayerBestWeapon.iStatId) );
+
+	int newItem = m_statsList->AddItem(0, pKeyValues);
+	pKeyValues->deleteThis();
+
+	m_statsList->SetItemFont(newItem , m_listItemFont);
+	m_statsList->SetItemFgColor(newItem, Color(197,197,197,255));
+
+	return newItem;
+}
+
+
+int CLifetimeStatsPage::AddKillToDeathStat(const StatsCollection_t& personalLifetimeStats)
+{
+	PlayerStatData_t statKills = g_CSClientGameStats.GetStatById(CSSTAT_KILLS);
+	PlayerStatData_t statDeaths = g_CSClientGameStats.GetStatById(CSSTAT_DEATHS);
+
+	KeyValues *pKeyValues = new KeyValues( "data" );
+	pKeyValues->SetWString( "name", LocalizeTagOrUseDefault( "Stats_KillToDeathRatio", L"Kill to Death Ratio" ) );
+	pKeyValues->SetFloat( "playerValue", 0 );
+
+	float playerKills = personalLifetimeStats[statKills.iStatId];
+	float playerDeaths = personalLifetimeStats[statDeaths.iStatId];
+	float playerKillToDeathRatio = 1.0f;
+
+	if (playerDeaths > 0)
+	{
+		playerKillToDeathRatio = playerKills / playerDeaths;
+	}
+
+	char buf[64];
+	Q_snprintf( buf, sizeof( buf ), "%.2f", playerKillToDeathRatio );
+	pKeyValues->SetString( "playerValue", (playerKillToDeathRatio)?buf:""  );
+
+	int newItem = m_statsList->AddItem(0, pKeyValues);
+	pKeyValues->deleteThis();
+
+	m_statsList->SetItemFont(newItem , m_listItemFont);
+	m_statsList->SetItemFgColor(newItem, Color(197,197,197,255));
+
+	return newItem;
+}
+
+int CLifetimeStatsPage::AddAccuracyStat(const StatsCollection_t& personalLifetimeStats)
+{
+	PlayerStatData_t statHits = g_CSClientGameStats.GetStatById(CSSTAT_SHOTS_HIT);
+	PlayerStatData_t statShots = g_CSClientGameStats.GetStatById(CSSTAT_SHOTS_FIRED);
+
+	KeyValues *pKeyValues = new KeyValues( "data" );
+	pKeyValues->SetWString( "name", LocalizeTagOrUseDefault( "Stats_Accuracy", L"Accuracy" ) );
+	pKeyValues->SetFloat( "playerValue", 0 );
+
+	float playerHits = personalLifetimeStats[statHits.iStatId];
+	float playerShots = personalLifetimeStats[statShots.iStatId];
+	float playerAccuracy = 0.0;
+
+	if (playerShots > 0)
+	{
+		playerAccuracy = 100.0f * playerHits / playerShots;
+	}
+
+	char buf[64];
+	Q_snprintf( buf, sizeof( buf ), "%.1f%%", playerAccuracy );
+	pKeyValues->SetString( "playerValue", (playerAccuracy)?buf:""  );
+
+	int newItem = m_statsList->AddItem(0, pKeyValues);
+	pKeyValues->deleteThis();
+
+	m_statsList->SetItemFont(newItem , m_listItemFont);
+	m_statsList->SetItemFgColor(newItem, Color(197,197,197,255));
+
+	return newItem;
+}
+
diff --git a/game/client/cstrike/VGUI/lifetime_stats_page.h b/game/client/cstrike/VGUI/lifetime_stats_page.h
new file mode 100644
index 00000000..8a2af6be
--- /dev/null
+++ b/game/client/cstrike/VGUI/lifetime_stats_page.h
@@ -0,0 +1,40 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSLifetimeSTATSPAGE_H
+#define CSLifetimeSTATSPAGE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "base_stats_page.h"
+
+class CLifetimeStatsPage : public CBaseStatsPage
+{
+    DECLARE_CLASS_SIMPLE ( CLifetimeStatsPage, CBaseStatsPage );
+
+public:
+    CLifetimeStatsPage( vgui::Panel *parent, const char *name );
+	
+    virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	void RepopulateStats();
+	int AddSimpleStat( int desiredStat, const StatsCollection_t& personalLifetimeStats);
+	int AddAccuracyStat(const StatsCollection_t& personalLifetimeStats);
+	int AddFavoriteWeaponStat(const StatsCollection_t& personalLifetimeStats);
+	int AddKillToDeathStat(const StatsCollection_t& personalLifetimeStats);	
+
+	CBaseStatGroupPanel* m_allStatsGroupPanel;
+	CBaseStatGroupPanel* m_detailedWeaponStatsGroupPanel;
+	CBaseStatGroupPanel* m_specialSkillsStatsGroupPanel;
+	CBaseStatGroupPanel* m_mapAndMiscellanyStatsGroupPanel;
+	CBaseStatGroupPanel* m_mapVictoryStatsGroupPanel;
+	CBaseStatGroupPanel* m_missionAndObjectiveStatsGroupPanel;
+	
+
+};
+
+#endif // CSLifetimeSTATSPAGE_H
diff --git a/game/client/cstrike/VGUI/match_stats_page.cpp b/game/client/cstrike/VGUI/match_stats_page.cpp
new file mode 100644
index 00000000..9130176e
--- /dev/null
+++ b/game/client/cstrike/VGUI/match_stats_page.cpp
@@ -0,0 +1,334 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "match_stats_page.h"
+#include <vgui_controls/SectionedListPanel.h>
+#include "c_team.h"
+#include "cs_client_gamestats.h"
+
+using namespace vgui;
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: creates child panels, passes down name to pick up any settings from res files.
+//-----------------------------------------------------------------------------
+CMatchStatsPage::CMatchStatsPage(vgui::Panel *parent, const char *name) : BaseClass(parent, "CSMatchStatsDialog")
+{	
+	m_allStatsGroupPanel =					AddGroup( L"all",      "Stats_Button_All",       L"All" );
+	m_detailedWeaponStatsGroupPanel =		AddGroup( L"weapon",   "Stats_Button_Weapon",    L"Weapon Stats" );
+	m_specialSkillsStatsGroupPanel =		AddGroup( L"skills",   "Stats_Button_Skills",    L"Special Skills" );
+	m_mapAndMiscellanyStatsGroupPanel =		AddGroup( L"map",      "Stats_Button_Misc",      L"Miscellaneous" );
+	m_missionAndObjectiveStatsGroupPanel =	AddGroup( L"mission",  "Stats_Button_Mission",   L"Mission && Objectives" );
+
+	m_allStatsGroupPanel->SetGroupActive(true);
+
+	m_ResetNotice = new Label( this, "ResetNotice", "");
+}
+//-----------------------------------------------------------------------------
+// Purpose: Loads settings from statsdialog.res in hl2/resource/ui/
+//-----------------------------------------------------------------------------
+void CMatchStatsPage::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+    BaseClass::ApplySchemeSettings( pScheme );
+    LoadControlSettings("resource/ui/CSMatchStatsDialog.res");  
+	m_statsList->AddColumnToSection( 0, "name", "", SectionedListPanel::COLUMN_CENTER, 180);
+	m_statsList->AddColumnToSection( 0, "playerValue", "", SectionedListPanel::COLUMN_CENTER, 100);
+	m_statsList->AddColumnToSection( 0, "ctValue", "", SectionedListPanel::COLUMN_CENTER, 100);
+	m_statsList->AddColumnToSection( 0, "tValue", " ", SectionedListPanel::COLUMN_CENTER, 100);	
+	m_statsList->AddColumnToSection( 0, "serverValue", "", SectionedListPanel::COLUMN_CENTER, 100);	
+}
+
+void CMatchStatsPage::RepopulateStats()
+{
+	m_statsList->RemoveAll();
+
+	RoundStatsDirectAverage_t*	tStats = g_CSClientGameStats.GetDirectTStatsAverages();
+	RoundStatsDirectAverage_t*	ctStats = g_CSClientGameStats.GetDirectCTStatsAverages();
+	RoundStatsDirectAverage_t*	serverStats = g_CSClientGameStats.GetDirectPlayerStatsAverages();
+	const StatsCollection_t&	personalMatchStats = g_CSClientGameStats.GetMatchStats();
+	
+	if (m_missionAndObjectiveStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		AddSimpleStat(CSSTAT_ROUNDS_WON, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_KILLS, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_DEATHS, personalMatchStats, tStats, ctStats, serverStats);
+		AddKillToDeathStat(personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_DAMAGE, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_NUM_BOMBS_PLANTED, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_NUM_BOMBS_DEFUSED, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_NUM_HOSTAGES_RESCUED, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_PISTOLROUNDS_WON, personalMatchStats, tStats, ctStats, serverStats);
+	}
+
+	if (m_specialSkillsStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		AddSimpleStat(CSSTAT_MVPS, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_SHOTS_FIRED, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_SHOTS_HIT, personalMatchStats, tStats, ctStats, serverStats);		
+		AddAccuracyStat(personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_DOMINATIONS, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_DOMINATION_OVERKILLS, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_REVENGES, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_KILLS_HEADSHOT, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_KILLS_AGAINST_ZOOMED_SNIPER, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_KILLS_ENEMY_BLINDED, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_KILLS_ENEMY_WEAPON, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_KILLS_KNIFE_FIGHT, personalMatchStats, tStats, ctStats, serverStats);
+	}
+
+	if (m_mapAndMiscellanyStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		AddSimpleStat(CSSTAT_MONEY_EARNED, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_DECAL_SPRAYS, personalMatchStats, tStats, ctStats, serverStats);		
+		AddSimpleStat(CSSTAT_NIGHTVISION_DAMAGE, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_NUM_BROKEN_WINDOWS, personalMatchStats, tStats, ctStats, serverStats);
+		AddSimpleStat(CSSTAT_WEAPONS_DONATED, personalMatchStats, tStats, ctStats, serverStats);
+	}	
+
+	if (m_detailedWeaponStatsGroupPanel->IsGroupActive() || m_allStatsGroupPanel->IsGroupActive())
+	{
+		CSStatType_t hitsStat = CSSTAT_HITS_DEAGLE;
+		CSStatType_t shotsStat = CSSTAT_SHOTS_DEAGLE;
+		for (CSStatType_t killStat = CSSTAT_KILLS_DEAGLE ; killStat <= CSSTAT_KILLS_HEGRENADE ; killStat = (CSStatType_t)(killStat + 1))
+		{
+			if (shotsStat <= CSSTAT_SHOTS_M249)
+			{
+				AddSimpleStat(shotsStat, personalMatchStats, tStats, ctStats, serverStats);
+		}
+
+			if (hitsStat <= CSSTAT_HITS_M249)
+			{
+				AddSimpleStat(hitsStat, personalMatchStats, tStats, ctStats, serverStats);
+	}
+			AddSimpleStat(killStat, personalMatchStats, tStats, ctStats, serverStats);
+
+			hitsStat = (CSStatType_t)(hitsStat + 1);
+			shotsStat = (CSStatType_t)(shotsStat + 1);
+		}
+	}
+
+	int itemCount = m_statsList->GetItemCount();
+	for (int i = 0; i < itemCount ; ++i)
+	{
+		m_statsList->SetItemBgColor(i, Color(0,0,0,0));
+	}
+}
+
+int CMatchStatsPage::AddSimpleStat( int desiredStat, const StatsCollection_t& personalMatchStats, RoundStatsDirectAverage_t* tStats, RoundStatsDirectAverage_t* ctStats, RoundStatsDirectAverage_t* serverStats )
+{
+	PlayerStatData_t stat = g_CSClientGameStats.GetStatById(desiredStat);
+
+	KeyValues *pKeyValues = new KeyValues( "data" );
+	pKeyValues->SetWString( "name", stat.pStatDisplayName );
+	pKeyValues->SetFloat( "playerValue", 0 );
+
+	char buf[64];
+	Q_snprintf( buf, sizeof( buf ), "%d", personalMatchStats[stat.iStatId] );
+	pKeyValues->SetString( "playerValue", (personalMatchStats[stat.iStatId])?buf:"" );
+
+	if (desiredStat == CSSTAT_ROUNDS_WON)
+	{
+		C_Team *ts = GetGlobalTeam(TEAM_TERRORIST);
+		if (ts)
+		{
+			Q_snprintf( buf, sizeof( buf ), "%d", ts->Get_Score() );
+			pKeyValues->SetString( "tValue", buf );
+		}
+
+		C_Team *cts = GetGlobalTeam(TEAM_CT);
+		if (cts){
+			Q_snprintf( buf, sizeof( buf ), "%d", cts->Get_Score());
+			pKeyValues->SetString( "ctValue", buf );
+		}
+	}
+	else
+	{
+		Q_snprintf( buf, sizeof( buf ), "%.1f", tStats->m_fStat[stat.iStatId] );
+		pKeyValues->SetString( "tValue", (tStats->m_fStat[stat.iStatId]||personalMatchStats[stat.iStatId])?buf:"" );
+
+		Q_snprintf( buf, sizeof( buf ), "%.1f", ctStats->m_fStat[stat.iStatId] );
+		pKeyValues->SetString( "ctValue", (ctStats->m_fStat[stat.iStatId]||personalMatchStats[stat.iStatId])?buf:"" );
+	}
+
+	Q_snprintf( buf, sizeof( buf ), "%.1f", serverStats->m_fStat[stat.iStatId] );
+	pKeyValues->SetString( "serverValue", (serverStats->m_fStat[stat.iStatId]||personalMatchStats[stat.iStatId])?buf:"" );
+
+	int newItem = m_statsList->AddItem(0, pKeyValues);		
+	pKeyValues->deleteThis();
+
+	m_statsList->SetItemFont(newItem , m_listItemFont);
+	m_statsList->SetItemFgColor(newItem, Color(197,197,197,255));
+
+	return newItem;
+}
+
+
+int CMatchStatsPage::AddKillToDeathStat(const StatsCollection_t& personalMatchStats, RoundStatsDirectAverage_t* tStats, RoundStatsDirectAverage_t* ctStats, RoundStatsDirectAverage_t* serverStats )
+{
+	PlayerStatData_t statKills = g_CSClientGameStats.GetStatById(CSSTAT_KILLS);
+	PlayerStatData_t statDeaths = g_CSClientGameStats.GetStatById(CSSTAT_DEATHS);
+
+	KeyValues *pKeyValues = new KeyValues( "data" );
+
+	pKeyValues->SetWString( "name", LocalizeTagOrUseDefault( "Stats_KillToDeathRatio", L"Kill to Death Ratio" ) );
+	pKeyValues->SetFloat( "playerValue", 0 );
+
+	float playerKills = personalMatchStats[statKills.iStatId];
+	float tKills = tStats->m_fStat[statKills.iStatId];
+	float ctKills = ctStats->m_fStat[statKills.iStatId];
+	float serverKills = serverStats->m_fStat[statKills.iStatId];
+
+	float playerDeaths = personalMatchStats[statDeaths.iStatId];
+	float tDeaths = tStats->m_fStat[statDeaths.iStatId];
+	float ctDeaths = ctStats->m_fStat[statDeaths.iStatId];
+	float serverDeaths = serverStats->m_fStat[statDeaths.iStatId];
+	
+	char buf[64];
+
+	if (playerDeaths > 0)
+	{
+		float playerKillToDeathRatio = playerKills / playerDeaths;
+		Q_snprintf( buf, sizeof( buf ), "%.2f", playerKillToDeathRatio );
+		pKeyValues->SetString( "playerValue", (playerKillToDeathRatio)?buf:"" );
+	}
+	else
+	{
+		pKeyValues->SetString( "playerValue", "" );
+	}
+
+
+	if (tDeaths > 0)
+	{
+		float tKillToDeathRatio = tKills / tDeaths;
+		Q_snprintf( buf, sizeof( buf ), "%.2f", tKillToDeathRatio );
+		pKeyValues->SetString( "tValue", ((playerKills&&playerDeaths)||tKillToDeathRatio)?buf:"" );	
+
+	}
+	else
+	{
+		pKeyValues->SetString( "tValue", "" );
+	}
+
+	if (ctDeaths > 0)
+	{
+		float ctKillToDeathRatio = ctKills / ctDeaths;
+		Q_snprintf( buf, sizeof( buf ), "%.2f", ctKillToDeathRatio);
+		pKeyValues->SetString( "ctValue", ((playerKills&&playerDeaths)||ctKillToDeathRatio)?buf:"" );		
+	}
+	else
+	{
+		pKeyValues->SetString( "ctValue", "" );
+	}
+
+	if (serverDeaths > 0)
+	{
+		float serverKillToDeathRatio = serverKills / serverDeaths;
+		Q_snprintf( buf, sizeof( buf ), "%.2f", serverKillToDeathRatio );
+		pKeyValues->SetString( "serverValue", ((playerKills&&playerDeaths)||serverKillToDeathRatio)?buf:"" );		
+	}
+	else
+	{
+		pKeyValues->SetString( "serverValue", "" );
+	}
+
+	
+
+	int newItem = m_statsList->AddItem(0, pKeyValues);		
+	pKeyValues->deleteThis();
+
+	m_statsList->SetItemFont(newItem , m_listItemFont);
+	m_statsList->SetItemFgColor(newItem, Color(197,197,197,255));
+
+	return newItem;
+}
+
+
+
+int CMatchStatsPage::AddAccuracyStat(const StatsCollection_t& personalMatchStats, RoundStatsDirectAverage_t* tStats, RoundStatsDirectAverage_t* ctStats, RoundStatsDirectAverage_t* serverStats )
+{
+	PlayerStatData_t statHits = g_CSClientGameStats.GetStatById(CSSTAT_SHOTS_HIT);
+	PlayerStatData_t statShots = g_CSClientGameStats.GetStatById(CSSTAT_SHOTS_FIRED);
+
+	KeyValues *pKeyValues = new KeyValues( "data" );
+	pKeyValues->SetWString( "name", LocalizeTagOrUseDefault( "Stats_Accuracy", L"Accuracy" ) );
+	pKeyValues->SetFloat( "playerValue", 0 );
+
+	float playerHits = personalMatchStats[statHits.iStatId];
+	float tHits = tStats->m_fStat[statHits.iStatId];
+	float ctHits = ctStats->m_fStat[statHits.iStatId];
+	float serverHits = serverStats->m_fStat[statHits.iStatId];
+
+	float playerShots = personalMatchStats[statShots.iStatId];
+	float tShots = tStats->m_fStat[statShots.iStatId];
+	float ctShots = ctStats->m_fStat[statShots.iStatId];
+	float serverShots = serverStats->m_fStat[statShots.iStatId];
+
+	float playerAccuracy = 0.0;
+	float tAccuracy = 0.0;
+	float ctAccuracy = 0.0;
+	float serverAccuracy = 0.0;
+
+	if (playerShots > 0)
+	{
+		playerAccuracy = 100.0f * playerHits / playerShots;
+	}
+
+	if (tShots > 0)
+	{
+		tAccuracy = 100.0f * tHits / tShots;
+	}
+
+	if (ctShots > 0)
+	{
+		ctAccuracy = 100.0f * ctHits / ctShots;
+	}
+
+	if (serverShots > 0)
+	{
+		serverAccuracy = 100.0f * serverHits / serverShots;
+	}
+
+	char buf[64];
+	Q_snprintf( buf, sizeof( buf ), "%.1f%%", playerAccuracy );
+	pKeyValues->SetString( "playerValue", (playerAccuracy)?buf:"" );
+
+	Q_snprintf( buf, sizeof( buf ), "%.1f%%", tAccuracy);
+	pKeyValues->SetString( "tValue", (playerAccuracy||tAccuracy)?buf:"" );
+
+	Q_snprintf( buf, sizeof( buf ), "%.1f%%", ctAccuracy );
+	pKeyValues->SetString( "ctValue", (playerAccuracy||ctAccuracy)?buf:"" );
+
+	Q_snprintf( buf, sizeof( buf ), "%.1f%%", serverAccuracy );
+	pKeyValues->SetString( "serverValue", (playerAccuracy||serverAccuracy)?buf:"" );
+
+	int newItem = m_statsList->AddItem(0, pKeyValues);		
+	pKeyValues->deleteThis();
+
+	m_statsList->SetItemFont(newItem , m_listItemFont);
+	m_statsList->SetItemFgColor(newItem, Color(197,197,197,255));
+
+	return newItem;
+}
+
+
+void CMatchStatsPage::OnSizeChanged(int newWide, int newTall)
+{
+	BaseClass::OnSizeChanged(newWide, newTall);
+
+	if (m_statsList)
+	{
+		if (m_ResetNotice)
+		{
+			int labelX, labelY, listX, listY, listWide, listTall;
+			m_statsList->GetBounds(listX, listY, listWide, listTall);
+
+			m_ResetNotice->GetPos(labelX, labelY);
+			m_ResetNotice->SetPos(labelX, listY + listTall + 4);
+		}
+	}
+}
diff --git a/game/client/cstrike/VGUI/match_stats_page.h b/game/client/cstrike/VGUI/match_stats_page.h
new file mode 100644
index 00000000..9c859027
--- /dev/null
+++ b/game/client/cstrike/VGUI/match_stats_page.h
@@ -0,0 +1,39 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSMATCHSTATSPAGE_H
+#define CSMATCHSTATSPAGE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "base_stats_page.h"
+
+class CMatchStatsPage : public CBaseStatsPage
+{
+    DECLARE_CLASS_SIMPLE ( CMatchStatsPage, CBaseStatsPage );
+
+public:
+    CMatchStatsPage( vgui::Panel *parent, const char *name );
+	
+    virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	void RepopulateStats();
+	int AddSimpleStat( int desiredStat, const StatsCollection_t& personalMatchStats, RoundStatsDirectAverage_t* tStats, RoundStatsDirectAverage_t* ctStats, RoundStatsDirectAverage_t* serverStats );
+	int AddAccuracyStat(const StatsCollection_t& personalMatchStats, RoundStatsDirectAverage_t* tStats, RoundStatsDirectAverage_t* ctStats, RoundStatsDirectAverage_t* serverStats );
+	int AddKillToDeathStat(const StatsCollection_t& personalMatchStats, RoundStatsDirectAverage_t* tStats, RoundStatsDirectAverage_t* ctStats, RoundStatsDirectAverage_t* serverStats );
+	virtual void OnSizeChanged(int wide, int tall);
+
+	CBaseStatGroupPanel* m_allStatsGroupPanel;
+	CBaseStatGroupPanel* m_detailedWeaponStatsGroupPanel;
+	CBaseStatGroupPanel* m_specialSkillsStatsGroupPanel;
+	CBaseStatGroupPanel* m_mapAndMiscellanyStatsGroupPanel;
+	CBaseStatGroupPanel* m_missionAndObjectiveStatsGroupPanel;
+
+	vgui::Label*	m_ResetNotice;
+};
+
+#endif // CSMATCHSTATSPAGE_H
diff --git a/game/client/cstrike/VGUI/stat_card.cpp b/game/client/cstrike/VGUI/stat_card.cpp
new file mode 100644
index 00000000..648b2863
--- /dev/null
+++ b/game/client/cstrike/VGUI/stat_card.cpp
@@ -0,0 +1,106 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Create and display a win panel at the end of a round displaying interesting stats and info about the round.
+//
+// $NoKeywords: $
+//=============================================================================//
+ 
+#include "cbase.h"
+#include "stat_card.h"
+#include "vgui_controls/AnimationController.h"
+#include "iclientmode.h"
+#include "c_playerresource.h"
+#include <vgui_controls/Label.h>
+#include <vgui/ILocalize.h>
+#include <vgui/ISurface.h>
+#include "fmtstr.h"
+#include "../../public/steam/steam_api.h"
+#include "c_cs_player.h"
+#include "cs_gamestats_shared.h"
+#include "cs_client_gamestats.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+StatCard::StatCard(vgui::Panel *parent, const char *name) : BaseClass(parent, "CSStatCard")
+{
+	//m_pAvatarDefault = new ImagePanel(this, "");
+	//m_pBackgroundArt = new ImagePanel(this, "BackgroundArt");
+	m_pAvatar = new CAvatarImagePanel(this, "Avatar");
+	m_pAvatar->SetShouldScaleImage(true);
+	m_pAvatar->SetShouldDrawFriendIcon(false);
+	m_pAvatar->SetSize(64,64);
+	
+	m_pName= new Label(this, "Name", "Name");
+	m_pKillToDeathRatio = new Label(this, "KillToDeath", "KillToDeath");
+	m_pStars = new Label(this, "Stars", "Stars");
+}
+
+StatCard::~StatCard()
+{
+
+}
+
+
+void StatCard::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	LoadControlSettings("Resource/UI/CSStatCard.res");
+
+	//m_pBackgroundArt->SetShouldScaleImage(true);
+	//m_pBackgroundArt->SetImage("../VGUI/achievements/achievement-btn-up");
+	
+	SetBgColor(Color(0,0,0,0));
+
+	UpdateInfo();
+}
+
+void StatCard::UpdateInfo()
+{
+	const StatsCollection_t& personalLifetimeStats = g_CSClientGameStats.GetLifetimeStats();
+
+	int stars = personalLifetimeStats[CSSTAT_MVPS];
+	float kills = personalLifetimeStats[CSSTAT_KILLS];
+	float deaths = personalLifetimeStats[CSSTAT_DEATHS];
+	wchar_t buf[64], numBuf[64];
+
+	if (deaths > 0)
+	{
+		float killToDeath = kills / deaths;
+		
+		_snwprintf( numBuf, ARRAYSIZE( numBuf ), L"%.2f", killToDeath);
+		g_pVGuiLocalize->ConstructString( buf, sizeof(buf),
+			g_pVGuiLocalize->Find( "#GameUI_Stats_LastMatch_KDRatio" ), 1, numBuf );		
+		m_pKillToDeathRatio->SetText( buf );
+	}
+	else
+	{
+		m_pKillToDeathRatio->SetText("");
+	}
+
+	_snwprintf( numBuf, ARRAYSIZE( numBuf ), L"%i", stars);
+	g_pVGuiLocalize->ConstructString( buf, sizeof(buf),
+		g_pVGuiLocalize->Find( "#GameUI_Stats_LastMatch_MVPS" ), 1, numBuf );		
+	m_pStars->SetText( buf );
+
+	if (steamapicontext)
+	{
+		ISteamFriends* friends = steamapicontext->SteamFriends();
+		if (friends)
+		{
+			m_pName->SetText(friends->GetPersonaName());
+		}
+	}
+
+	// Display the player avatar
+	if (m_pAvatar && steamapicontext && steamapicontext->SteamUser())
+	{
+		m_pAvatar->SetPlayer( steamapicontext->SteamUser()->GetSteamID(), k_EAvatarSize64x64 );	
+		m_pAvatar->SetVisible( true );
+	}
+}
diff --git a/game/client/cstrike/VGUI/stat_card.h b/game/client/cstrike/VGUI/stat_card.h
new file mode 100644
index 00000000..5a393ab5
--- /dev/null
+++ b/game/client/cstrike/VGUI/stat_card.h
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef STATCARD_H
+#define STATCARD_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui/IScheme.h>
+#include "hud.h"
+#include "hudelement.h"
+#include "vgui_avatarimage.h"
+#include "cs_shareddefs.h"
+#include <vgui_controls/EditablePanel.h>
+
+using namespace vgui;
+
+class StatCard : public EditablePanel
+{
+private:
+	DECLARE_CLASS_SIMPLE( StatCard, EditablePanel );
+
+public:
+	StatCard(vgui::Panel *parent, const char *name);
+    ~StatCard();
+	
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );	
+	void UpdateInfo();
+
+protected:
+	
+
+	ImagePanel*			m_pAvatarDefault;
+	//ImagePanel*			m_pBackgroundArt;
+	CAvatarImagePanel*	m_pAvatar;
+
+	Label* m_pName;
+	Label* m_pKillToDeathRatio;
+	Label* m_pStars;
+	
+
+private:
+};
+
+#endif //STATCARD_H
\ No newline at end of file
diff --git a/game/client/cstrike/VGUI/stats_summary.cpp b/game/client/cstrike/VGUI/stats_summary.cpp
new file mode 100644
index 00000000..b2224c02
--- /dev/null
+++ b/game/client/cstrike/VGUI/stats_summary.cpp
@@ -0,0 +1,684 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Display a list of achievements for the current game
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "stats_summary.h"
+#include "vgui_controls/Button.h"
+#include "vgui/ILocalize.h"
+#include "ixboxsystem.h"
+#include "iachievementmgr.h"
+#include "filesystem.h"
+#include "vgui_controls/ImagePanel.h"
+#include "vgui_controls/ComboBox.h"
+#include "vgui_controls/CheckButton.h"
+#include "vgui_controls/ImageList.h"
+#include "fmtstr.h"
+#include "c_cs_playerresource.h"
+
+#include "../../../public/steam/steam_api.h"
+#include "achievementmgr.h"
+#include "../../../../public/vgui/IScheme.h"
+#include "../vgui_controls/ScrollBar.h"
+#include "stat_card.h"
+
+#include "weapon_csbase.h"
+#include "cs_weapon_parse.h"
+#include "buy_presets/buy_presets.h"
+#include "win_panel_round.h"
+#include "cs_client_gamestats.h"
+#include "achievements_cs.h"
+#include "ienginevgui.h"
+
+
+#define STAT_NUM_ARRAY_LENGTH	8
+
+using namespace vgui;
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+#include <locale.h>
+
+extern CAchievementMgr g_AchievementMgrCS;
+
+const int maxRecentAchievementToDisplay = 10;
+
+/**
+ *	public ConvertNumberToMantissaSuffixForm()
+ *
+ *		Convert a floating point number to a string form incorporating a mantissa and a magnitude suffix (such as "K" for thousands).
+ *
+ *  Parameters:
+ * 		fNum -
+ * 		textBuffer - output buffer
+ * 		textBufferLen - size of output buffer in characters
+ * 		bTrimTrailingZeros - indicates whether to remove trailing zeros of numbers without suffixes (e.g., "32.00000" becomes "32")
+ * 		iSignificantDigits - the desired number of significant digits in the result (e.g, "1.23" has 3 significant digits)
+ *
+ *	Returns:
+ *		bool - true on success
+ */
+bool ConvertNumberToMantissaSuffixForm(float fNum, wchar_t* textBuffer, int textBufferLen, bool bTrimTrailingZeros = true, int iSignificantDigits = 3)
+{
+	// we need room for at least iSignificantDigits + 3 characters
+	Assert(textBufferLen >= iSignificantDigits + 3);
+
+	// find the correct power of 1000 exponent
+	Assert(fNum >= 0.0f);
+	int iExponent = 0;
+	while (fNum >= powf(10.0f, iExponent + 3))
+	{
+		iExponent += 3;
+	}
+
+	// look in the localization table for the matching suffix; fallback to lower suffixes when necessary
+	wchar_t *pSuffix = NULL;
+	for (; iExponent > 0; iExponent -= 3)
+	{
+		char localizationToken[64];
+		V_snprintf(localizationToken, sizeof(localizationToken), "#GameUI_NumSuffix_E%i", iExponent);
+		pSuffix = g_pVGuiLocalize->Find(localizationToken);
+		if (pSuffix != NULL)
+			break;
+	}
+
+	V_snwprintf(textBuffer, textBufferLen, L"%f", fNum / powf(10.0f, iExponent));
+	textBuffer[textBufferLen - 1] = L'\0';
+
+	lconv* pLocaleSettings = localeconv();
+	wchar_t decimalWChar = *pLocaleSettings->decimal_point;
+	wchar_t* pDecimalPos = wcschr(textBuffer, decimalWChar);
+	if (pDecimalPos == NULL)
+	{
+		Msg("ConvertNumberToMantissaSuffixForm(): decimal point not found in string %S for value %f\n", textBuffer, fNum);
+		return false;
+	}
+
+	// trim trailing zeros
+	int iNumCharsInBuffer = wcslen(textBuffer);
+	if (pSuffix == NULL && bTrimTrailingZeros)
+	{
+		wchar_t* pLastChar;
+		for (pLastChar = &textBuffer[iNumCharsInBuffer - 1]; pLastChar > pDecimalPos; --pLastChar)
+		{
+			if (*pLastChar != L'0')	// note that this is checking for '0', not a NULL terminator
+				break;
+
+			*pLastChar = L'\0';
+		}
+		if (pLastChar == pDecimalPos)
+			*pLastChar = L'\0';
+	}
+
+	// truncate the mantissa to the right of the decimal point so that it doesn't exceed the significant digits
+	if (pDecimalPos != NULL && iNumCharsInBuffer > iSignificantDigits + 1)
+	{
+		if (pDecimalPos - &textBuffer[0] < iSignificantDigits)
+			textBuffer[iSignificantDigits + 1] = L'\0'; // truncate at the correct number of significant digits
+		else
+			*pDecimalPos = L'\0';	// no room for any digits to the right of the decimal point, just truncate it at the "."
+	}
+
+	if (pSuffix != NULL)
+	{
+#ifdef WIN32
+		int retVal = V_snwprintf( textBuffer, textBufferLen, L"%s%s", textBuffer, pSuffix );
+#else
+		int retVal = V_snwprintf( textBuffer, textBufferLen, L"%S%S", textBuffer, pSuffix );
+#endif 
+
+		if ( retVal < 0 )
+		{
+			Msg("ConvertNumberToMantissaSuffixForm(): unable to add suffix %S for value %f (buffer size was %i)\n", pSuffix, fNum, textBufferLen);
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+CStatsSummary::CStatsSummary(vgui::Panel *parent, const char *name) : BaseClass(parent, "CSAchievementsDialog"),
+	m_StatImageMap(DefLessFunc(CSStatType_t))
+{
+	m_iFixedWidth = 900; // Give this an initial value in order to set a proper size
+	SetBounds(0, 0, 900, 780);
+	SetMinimumSize(256, 780);
+
+	m_pStatCard = new StatCard(this, "ignored");
+
+	m_pImageList = NULL;
+	m_iDefaultWeaponImage = -1;
+	m_iDefaultMapImage = -1;
+
+	m_pImagePanelFavWeapon = new ImagePanel(this, "FavoriteWeaponImage");
+	m_pImagePanelLastMapFavWeapon = new ImagePanel(this, "FavWeaponIcon");
+	m_pImagePanelFavMap = new ImagePanel(this, "FavoriteMapImage");
+
+	//Setup the recent achievement list by adding all achieved achievements to the list
+	m_pRecentAchievementsList = new vgui::PanelListPanel(this, "RecentAchievementsListPanel");
+	m_pRecentAchievementsList->SetFirstColumnWidth(0);
+
+	ListenForGameEvent( "player_stats_updated" );
+	ListenForGameEvent( "achievement_earned_local" );
+
+	m_bRecentAchievementsDirty = true;
+	m_bStatsDirty = true;
+}
+
+CStatsSummary::~CStatsSummary()
+{
+	if (m_pRecentAchievementsList)
+	{
+		m_pRecentAchievementsList->DeleteAllItems();
+	}
+
+	delete m_pRecentAchievementsList;
+	delete m_pImageList;
+}
+
+void CStatsSummary::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+	LoadControlSettings("Resource/UI/CSStatsSummary.res");
+
+	SetBgColor(Color(86,86,86,255));
+
+	if (m_pImageList)
+		delete m_pImageList;
+	m_pImageList = new ImageList(false);
+
+	if (m_pImageList)
+	{
+		//Load defaults
+		m_iDefaultWeaponImage = m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/defaultweapon", true));
+		m_iDefaultMapImage = m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_cs_generic_map", true));
+
+		//load weapon images
+		m_StatImageMap.Insert(CSSTAT_KILLS_DEAGLE, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/deserteagle", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_USP, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/usp45", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_GLOCK, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/glock18", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_P228, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/p228", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_ELITE, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/elites", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_FIVESEVEN, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/fiveseven", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_AWP, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/awp", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_AK47, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/ak47", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_M4A1, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/m4a1", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_AUG, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/aug", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_SG552, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/sg552", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_SG550, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/sg550", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_GALIL, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/galil", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_FAMAS, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/famas", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_SCOUT, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/scout", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_G3SG1, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/g3sg1", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_P90, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/p90", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_MP5NAVY, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/mp5", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_TMP, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/tmp", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_MAC10, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/mac10", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_UMP45, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/ump45", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_M3, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/m3", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_XM1014, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/xm1014", true)));
+		m_StatImageMap.Insert(CSSTAT_KILLS_M249, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/fav_weap/m249", true)));
+
+		//load map images
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_CS_ASSAULT, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_cs_assault", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_CS_COMPOUND, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_cs_compound", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_CS_HAVANA, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_cs_havana", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_CS_ITALY, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_cs_italy", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_CS_MILITIA, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_cs_militia", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_CS_OFFICE, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_cs_office", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_AZTEC, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_aztec", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_CBBLE, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_cbble", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_CHATEAU, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_chateau", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_DUST2, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_dust2", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_DUST, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_dust", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_INFERNO, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_inferno", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_NUKE, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_nuke", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_PIRANESI, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_piranesi", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_PORT, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_port", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_PRODIGY, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_prodigy", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_TIDES, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_tides", true)));
+		m_StatImageMap.Insert(CSSTAT_MAP_WINS_DE_TRAIN, m_pImageList->AddImage(scheme()->GetImage("gfx/vgui/summary_maps/summary_de_train", true)));
+	}
+}
+//----------------------------------------------------------
+// Get the width we're going to lock at
+//----------------------------------------------------------
+void CStatsSummary::ApplySettings(KeyValues *pResourceData)
+{
+	m_iFixedWidth = pResourceData->GetInt("wide", 512);
+
+	BaseClass::ApplySettings(pResourceData);
+}
+
+//----------------------------------------------------------
+// Preserve our width to the one in the .res file
+//----------------------------------------------------------
+void CStatsSummary::OnSizeChanged(int newWide, int newTall)
+{	
+	// Lock the width, but allow height scaling
+	if (newWide != m_iFixedWidth)
+	{
+		SetSize(m_iFixedWidth, newTall);
+		return;
+	}
+
+	BaseClass::OnSizeChanged(newWide, newTall);
+}
+
+
+void CStatsSummary::OnThink()
+{
+	if ( m_bRecentAchievementsDirty )
+		UpdateRecentAchievements();
+
+	if ( m_bStatsDirty )
+		UpdateStatsData();
+}
+
+
+void CStatsSummary::OnPageShow()
+{	
+	UpdateStatsData();
+	UpdateRecentAchievements();	
+}
+
+//----------------------------------------------------------
+// Update all of the stats displays
+//----------------------------------------------------------
+void CStatsSummary::UpdateStatsData()
+{
+	UpdateStatsSummary();
+	UpdateKillHistory();
+	UpdateFavoriteWeaponData();
+	UpdateMapsData();
+
+
+	UpdateLastMatchStats();
+	m_pStatCard->UpdateInfo();
+
+	m_bStatsDirty = false;
+}
+
+//----------------------------------------------------------
+// Update the stats located in the stats summary section
+//----------------------------------------------------------
+void CStatsSummary::UpdateStatsSummary()
+{
+	DisplayCompressedLocalizedStat(CSSTAT_ROUNDS_PLAYED, "roundsplayed");
+	DisplayCompressedLocalizedStat(CSSTAT_ROUNDS_WON, "roundswon");
+	DisplayCompressedLocalizedStat(CSSTAT_SHOTS_HIT, "shotshit");
+	DisplayCompressedLocalizedStat(CSSTAT_SHOTS_FIRED, "shotsfired");
+
+	wchar_t tempWNumString[STAT_NUM_ARRAY_LENGTH];
+	
+	//Calculate Win Ratio
+	int wins = g_CSClientGameStats.GetStatById(CSSTAT_ROUNDS_WON).iStatValue;
+	int rounds = g_CSClientGameStats.GetStatById(CSSTAT_ROUNDS_PLAYED).iStatValue;
+	float winRatio = 0;	
+	if (rounds > 0)
+	{
+		winRatio = ((float)wins / (float)rounds) * 100.0f;
+	}
+	V_snwprintf(tempWNumString, ARRAYSIZE(tempWNumString), L"%.1f%%", winRatio);	
+	SetDialogVariable("winratio", tempWNumString);
+
+	
+	//Calculate accuracy
+	int hits = g_CSClientGameStats.GetStatById(CSSTAT_SHOTS_HIT).iStatValue;
+	int shots = g_CSClientGameStats.GetStatById(CSSTAT_SHOTS_FIRED).iStatValue;
+	float accuracy = 0;	
+	if (shots > 0)
+	{
+		accuracy = ((float)hits / (float)shots) * 100.0f;
+	}
+	V_snwprintf(tempWNumString, ARRAYSIZE(tempWNumString), L"%.1f%%", accuracy);	
+	SetDialogVariable("hitratio", tempWNumString);
+}
+
+//----------------------------------------------------------
+// Update the stats located in the stats summary section
+//----------------------------------------------------------
+void CStatsSummary::UpdateKillHistory()
+{
+	DisplayCompressedLocalizedStat(CSSTAT_KILLS, "kills");
+	DisplayCompressedLocalizedStat(CSSTAT_DEATHS, "deaths");
+
+	wchar_t tempWNumString[STAT_NUM_ARRAY_LENGTH];
+
+	//Calculate Win Ratio
+	int kills = g_CSClientGameStats.GetStatById(CSSTAT_KILLS).iStatValue;
+	int deaths = g_CSClientGameStats.GetStatById(CSSTAT_DEATHS).iStatValue;
+	float killDeathRatio = 0;	
+	if (deaths > 0)
+	{
+		killDeathRatio = (float)kills / (float)deaths;
+	}
+	V_snwprintf(tempWNumString, ARRAYSIZE(tempWNumString), L"%.1f", killDeathRatio);	
+	SetDialogVariable("killdeathratio", tempWNumString);
+}
+//----------------------------------------------------------
+// Update the stats located in the favorite weapon section
+//----------------------------------------------------------
+void CStatsSummary::UpdateFavoriteWeaponData()
+{
+	// First set the image to the favorite weapon
+	if (m_pImageList)
+	{
+		//start with a dummy stat
+		const WeaponName_StatId* pFavoriteWeaponStatEntry = NULL;
+
+		//Find the weapon stat with the most kills
+		int numKills = 0;
+		for (int i = 0; WeaponName_StatId_Table[i].killStatId != CSSTAT_UNDEFINED; ++i)
+		{
+			// ignore weapons with no hit counts (knife and grenade)
+			if (WeaponName_StatId_Table[i].hitStatId == CSSTAT_UNDEFINED )
+				continue;
+
+			const WeaponName_StatId& weaponStatEntry = WeaponName_StatId_Table[i];
+			PlayerStatData_t stat = g_CSClientGameStats.GetStatById(weaponStatEntry.killStatId);
+			if (stat.iStatValue > numKills)
+			{
+				pFavoriteWeaponStatEntry = &weaponStatEntry;
+				numKills = stat.iStatValue;
+			}
+		}
+
+		if (pFavoriteWeaponStatEntry)
+		{			
+			CUtlMap<CSStatType_t, int>::IndexType_t idx = m_StatImageMap.Find((CSStatType_t)pFavoriteWeaponStatEntry->killStatId);
+			if (m_StatImageMap.IsValidIndex(idx))
+			{
+				m_pImagePanelFavWeapon->SetImage(m_pImageList->GetImage(m_StatImageMap[idx]));
+			}
+			
+			DisplayCompressedLocalizedStat(pFavoriteWeaponStatEntry->hitStatId, "weaponhits", "#GameUI_Stats_WeaponShotsHit");
+			DisplayCompressedLocalizedStat(pFavoriteWeaponStatEntry->shotStatId, "weaponshotsfired", "#GameUI_Stats_WeaponShotsFired");
+			DisplayCompressedLocalizedStat(pFavoriteWeaponStatEntry->killStatId, "weaponkills", "#GameUI_Stats_WeaponKills");
+
+			//Calculate accuracy
+			int kills = g_CSClientGameStats.GetStatById(pFavoriteWeaponStatEntry->killStatId).iStatValue;
+			int shots = g_CSClientGameStats.GetStatById(pFavoriteWeaponStatEntry->shotStatId).iStatValue;
+			float killsPerShot = 0;	
+			if (shots > 0)
+			{
+				killsPerShot = (float)kills / (float)shots;
+			}
+			wchar_t tempWNumString[STAT_NUM_ARRAY_LENGTH];
+			V_snwprintf(tempWNumString, ARRAYSIZE(tempWNumString), L"%.1f", (killsPerShot));
+			DisplayFormattedLabel("#GameUI_Stats_WeaponKillRatio", tempWNumString, "weaponkillratio");
+		}
+		else
+		{
+			if (m_iDefaultWeaponImage != -1)
+			{
+				m_pImagePanelFavWeapon->SetImage(m_pImageList->GetImage(m_iDefaultWeaponImage));
+			}
+			DisplayFormattedLabel("#GameUI_Stats_WeaponShotsHit", L"0", "weaponhits");
+			DisplayFormattedLabel("#GameUI_Stats_WeaponShotsFired", L"0", "weaponshotsfired");
+			DisplayFormattedLabel("#GameUI_Stats_WeaponKills", L"0", "weaponkills");
+			DisplayFormattedLabel("#GameUI_Stats_WeaponKillRatio", L"0", "weaponkillratio");		
+		}
+	}
+}
+
+//----------------------------------------------------------
+// Update the stats located in the favorite weapon section
+//----------------------------------------------------------
+void CStatsSummary::UpdateMapsData()
+{
+	//start with a dummy stat
+	const MapName_MapStatId* pFavoriteMapStat = NULL;
+	int numRounds = 0;
+	for (int i = 0; MapName_StatId_Table[i].statWinsId != CSSTAT_UNDEFINED; ++i)
+	{
+		const MapName_MapStatId& mapStatId = MapName_StatId_Table[i];
+		PlayerStatData_t stat = g_CSClientGameStats.GetStatById(mapStatId.statRoundsId);
+		if (stat.iStatValue > numRounds)
+		{
+			pFavoriteMapStat = &mapStatId;
+			numRounds = stat.iStatValue;
+		}
+	}
+
+	if (pFavoriteMapStat)
+	{	
+		CUtlMap<CSStatType_t, int>::IndexType_t idx = m_StatImageMap.Find((CSStatType_t)pFavoriteMapStat->statWinsId);
+		if (m_StatImageMap.IsValidIndex(idx))
+		{
+			m_pImagePanelFavMap->SetImage(m_pImageList->GetImage(m_StatImageMap[idx]));
+		}
+		
+		// map name
+		SetDialogVariable("mapname", pFavoriteMapStat->szMapName);
+
+		// rounds played
+		DisplayCompressedLocalizedStat(pFavoriteMapStat->statRoundsId,"mapplayed", "#GameUI_Stats_MapPlayed");
+		DisplayCompressedLocalizedStat(pFavoriteMapStat->statWinsId, "mapwins", "#GameUI_Stats_MapWins");
+
+		//Calculate Win Ratio
+		int wins = g_CSClientGameStats.GetStatById(pFavoriteMapStat->statWinsId).iStatValue;
+		int rounds = g_CSClientGameStats.GetStatById(pFavoriteMapStat->statRoundsId).iStatValue;
+		float winRatio = 0;	
+		if (rounds > 0)
+		{
+			winRatio = ((float)wins / (float)rounds) * 100.0f;
+		}
+		wchar_t tempWNumString[STAT_NUM_ARRAY_LENGTH];
+		V_snwprintf(tempWNumString, ARRAYSIZE(tempWNumString), L"%.1f%%", winRatio);	
+		DisplayFormattedLabel("#GameUI_Stats_MapWinRatio", tempWNumString, "mapwinratio");				
+	}
+	else
+	{
+		if (m_iDefaultMapImage != -1)
+		{
+			m_pImagePanelFavMap->SetImage(m_pImageList->GetImage(m_iDefaultMapImage));
+		}
+		SetDialogVariable("mapname", L"");
+		DisplayFormattedLabel("#GameUI_Stats_MapPlayed", L"0", "mapplayed");				
+		DisplayFormattedLabel("#GameUI_Stats_MapWins", L"0", "mapwins");				
+		DisplayFormattedLabel("#GameUI_Stats_MapWinRatio", L"0", "mapwinratio");	
+	}
+}
+
+int CStatsSummary::AchivementDateSortPredicate( CCSBaseAchievement* const* pLeft, CCSBaseAchievement* const* pRight )
+{
+	if (!pLeft || !pRight || !(*pLeft) || ! (*pRight))
+	{
+		return 0;
+	}
+
+	if	((*pLeft)->GetSortKey() < (*pRight)->GetSortKey())
+	{
+		return	1;
+	}
+	else if ((*pLeft)->GetSortKey() > (*pRight)->GetSortKey())
+	{
+		return -1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+void CStatsSummary::UpdateRecentAchievements()
+{
+	CUtlVector<CCSBaseAchievement*> sortedAchivementList;
+
+	//Get a list of all the achievements that have been earned
+	int iCount = g_AchievementMgrCS.GetAchievementCount();
+	sortedAchivementList.EnsureCapacity(iCount);
+
+	for (int i = 0; i < iCount; ++i)
+	{
+		CCSBaseAchievement* pAchievement = (CCSBaseAchievement*)g_AchievementMgrCS.GetAchievementByIndex(i);
+		if (pAchievement && pAchievement->IsAchieved())
+		{
+			sortedAchivementList.AddToTail(pAchievement);
+		}
+	}
+
+	//Sort the earned achievements by time and date earned.
+	sortedAchivementList.Sort(AchivementDateSortPredicate);
+
+	//Clear the UI list
+	m_pRecentAchievementsList->DeleteAllItems();	
+
+	// Add each achievement in the sorted list as a panel.
+	int numPanelsToAdd = MIN(maxRecentAchievementToDisplay, sortedAchivementList.Count());
+	for ( int i = 0; i < numPanelsToAdd; i++ )
+	{
+		CCSBaseAchievement* pAchievement = sortedAchivementList[i];
+		if (pAchievement)
+		{
+			CAchievementsPageItemPanel *achievementItemPanel = new CAchievementsPageItemPanel(m_pRecentAchievementsList, "AchievementDialogItemPanel");
+			achievementItemPanel->SetAchievementInfo(pAchievement);
+
+			// force all our new panel to have the correct internal layout and size so that our parent container can layout properly
+			achievementItemPanel->InvalidateLayout(true, true);
+
+			m_pRecentAchievementsList->AddItem(NULL, achievementItemPanel);
+		}
+	}
+
+	m_bRecentAchievementsDirty = false;
+}
+
+void CStatsSummary::UpdateLastMatchStats()
+{
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_T_ROUNDS_WON, "lastmatchtwins", "#GameUI_Stats_LastMatch_TWins");			
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_CT_ROUNDS_WON, "lastmatchctwins", "#GameUI_Stats_LastMatch_CTWins");			
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_ROUNDS_WON, "lastmatchwins", "#GameUI_Stats_LastMatch_RoundsWon");			
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_MAX_PLAYERS, "lastmatchmaxplayers", "#GameUI_Stats_LastMatch_MaxPlayers");		
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_MVPS, "lastmatchstars", "#GameUI_Stats_LastMatch_MVPS");
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_KILLS, "lastmatchkills", "#GameUI_Stats_WeaponKills");
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_DEATHS, "lastmatchdeaths", "#GameUI_Stats_LastMatch_Deaths");	
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_DAMAGE, "lastmatchtotaldamage", "#GameUI_Stats_LastMatch_Damage");	
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_DOMINATIONS, "lastmatchdominations", "#GameUI_Stats_LastMatch_Dominations");
+	DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_REVENGES, "lastmatchrevenges", "#GameUI_Stats_LastMatch_Revenges");
+
+	UpdateLastMatchFavoriteWeaponStats();
+
+	wchar_t tempWNumString[STAT_NUM_ARRAY_LENGTH];
+
+	//Calculate Kill:Death ratio
+	int deaths = g_CSClientGameStats.GetStatById(CSSTAT_LASTMATCH_DEATHS).iStatValue;
+	int kills = g_CSClientGameStats.GetStatById(CSSTAT_LASTMATCH_KILLS).iStatValue;
+	float killDeathRatio = deaths;	
+	if (deaths != 0)
+	{
+		killDeathRatio = (float)kills / (float)deaths;
+	}	
+	V_snwprintf(tempWNumString, ARRAYSIZE(tempWNumString), L"%.1f", killDeathRatio);	
+	DisplayFormattedLabel("#GameUI_Stats_LastMatch_KDRatio", tempWNumString, "lastmatchkilldeathratio");		
+
+	//Calculate cost per kill
+	PlayerStatData_t statMoneySpent = g_CSClientGameStats.GetStatById(CSSTAT_LASTMATCH_MONEYSPENT);
+	int costPerKill = 0;
+	if (kills > 0)
+	{
+		costPerKill = statMoneySpent.iStatValue / kills;
+	}	
+	ConvertNumberToMantissaSuffixForm(costPerKill, tempWNumString, STAT_NUM_ARRAY_LENGTH);
+	DisplayFormattedLabel("#GameUI_Stats_LastMatch_MoneySpentPerKill", tempWNumString, "lastmatchmoneyspentperkill");	
+}
+
+void CStatsSummary::UpdateLastMatchFavoriteWeaponStats()
+{
+	wchar_t tempWNumString[STAT_NUM_ARRAY_LENGTH];
+
+	PlayerStatData_t statFavWeaponId = g_CSClientGameStats.GetStatById(CSSTAT_LASTMATCH_FAVWEAPON_ID);
+	const WeaponName_StatId& favoriteWeaponStat = GetWeaponTableEntryFromWeaponId((CSWeaponID)statFavWeaponId.iStatValue);
+
+	// If we have a valid weapon use it's data; otherwise use nothing. We check the shot ID to make sure it is a weapon with bullets.
+	if (favoriteWeaponStat.hitStatId != CSSTAT_UNDEFINED)
+	{
+		// Set the image and (non-copyright) name of this weapon
+		CUtlMap<CSStatType_t, int>::IndexType_t idx = m_StatImageMap.Find((CSStatType_t)favoriteWeaponStat.killStatId);
+		if (m_StatImageMap.IsValidIndex(idx))
+		{
+			m_pImagePanelLastMapFavWeapon->SetImage(m_pImageList->GetImage(m_StatImageMap[idx]));
+		}
+
+		const wchar_t* tempName = WeaponIDToDisplayName(favoriteWeaponStat.weaponId);
+		if (tempName)
+		{
+			SetDialogVariable("lastmatchfavweaponname", tempName);
+		}
+		else
+		{
+			SetDialogVariable("lastmatchfavweaponname", L"");
+		}
+
+		DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_FAVWEAPON_KILLS, "lastmatchfavweaponkills", "#GameUI_Stats_WeaponKills");			
+		DisplayCompressedLocalizedStat(CSSTAT_LASTMATCH_FAVWEAPON_HITS, "lastmatchfavweaponhits", "#GameUI_Stats_WeaponShotsHit");			
+
+		int shots = g_CSClientGameStats.GetStatById(CSSTAT_LASTMATCH_FAVWEAPON_SHOTS).iStatValue;
+		int hits = g_CSClientGameStats.GetStatById(CSSTAT_LASTMATCH_FAVWEAPON_HITS).iStatValue;
+		float accuracy = 0.0f;
+		if (shots != 0)
+		{
+			accuracy = ((float)hits / (float)shots) * 100.0f;
+		}
+		V_snwprintf(tempWNumString, ARRAYSIZE(tempWNumString), L"%.1f%%", accuracy);
+		DisplayFormattedLabel("#GameUI_Stats_LastMatch_FavWeaponAccuracy", tempWNumString, "lastmatchfavweaponaccuracy");	
+	}
+	else
+	{
+		if (m_iDefaultWeaponImage != -1)
+		{
+			m_pImagePanelLastMapFavWeapon->SetImage(m_pImageList->GetImage(m_iDefaultWeaponImage));
+		}
+
+
+		//Set this label to diferent text, indicating that there is not a favorite weapon
+		SetDialogVariable("lastmatchfavweaponname", g_pVGuiLocalize->Find("#GameUI_Stats_LastMatch_NoFavWeapon"));
+
+		DisplayFormattedLabel("#GameUI_Stats_WeaponKills", L"0", "lastmatchfavweaponkills");
+		DisplayFormattedLabel("#GameUI_Stats_WeaponShotsHit", L"0", "lastmatchfavweaponhits");
+		DisplayFormattedLabel("#GameUI_Stats_LastMatch_FavWeaponAccuracy", L"0", "lastmatchfavweaponaccuracy");
+	}
+}
+
+void CStatsSummary::FireGameEvent( IGameEvent *event )
+{
+	const char *type = event->GetName();
+
+	if ( 0 == Q_strcmp( type, "achievement_earned_local" ) )
+	{
+		m_bRecentAchievementsDirty = true;
+	}
+
+	else if ( 0 == Q_strcmp( type, "player_stats_updated" ) )
+	{
+		m_bStatsDirty = true;
+	}	
+}
+
+void CStatsSummary::DisplayCompressedLocalizedStat(CSStatType_t stat, const char* dialogVariable, const char* localizationToken /* = NULL */)
+{
+	wchar_t tempWNumString[STAT_NUM_ARRAY_LENGTH];
+	int statValue = g_CSClientGameStats.GetStatById(stat).iStatValue;
+	ConvertNumberToMantissaSuffixForm(statValue, tempWNumString, STAT_NUM_ARRAY_LENGTH);
+	if (localizationToken)
+	{
+		DisplayFormattedLabel(localizationToken, tempWNumString, dialogVariable);	
+	}
+	else
+	{
+		SetDialogVariable(dialogVariable, tempWNumString);
+	}
+}
+
+
+void CStatsSummary::DisplayFormattedLabel( const char* localizationToken, const wchar_t* valueText, const char* dialogVariable )
+{
+	wchar_t tempWStatString[256];
+	g_pVGuiLocalize->ConstructString(tempWStatString, sizeof(tempWStatString),
+		g_pVGuiLocalize->Find(localizationToken), 1, valueText);
+	SetDialogVariable(dialogVariable, tempWStatString);
+}
diff --git a/game/client/cstrike/VGUI/stats_summary.h b/game/client/cstrike/VGUI/stats_summary.h
new file mode 100644
index 00000000..e4e0c419
--- /dev/null
+++ b/game/client/cstrike/VGUI/stats_summary.h
@@ -0,0 +1,84 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSSTATSSUMMARY_H
+#define CSSTATSSUMMARY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vgui_controls/PanelListPanel.h"
+#include "vgui_controls/Label.h"
+#include "tier1/KeyValues.h"
+#include "vgui_controls/PropertyPage.h"
+#include "vgui_controls/Button.h"
+#include "c_cs_player.h"
+#include "cs_gamestats_shared.h"
+#include "achievements_page.h"
+#include "GameEventListener.h"
+#include "utlmap.h"
+
+class IAchievement;
+class IScheme;
+class CAchievementsPageGroupPanel;
+class StatCard;
+class CCSBaseAchievement;
+
+class CStatsSummary : public vgui::PropertyPage, public CGameEventListener
+{
+	DECLARE_CLASS_SIMPLE ( CStatsSummary, vgui::PropertyPage );
+
+public:
+	CStatsSummary( vgui::Panel *parent, const char *name );
+	~CStatsSummary();
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void ApplySettings( KeyValues *pResourceData );
+	virtual void OnSizeChanged( int newWide, int newTall );
+	virtual void FireGameEvent( IGameEvent *event );
+
+	virtual void OnThink();
+	virtual void OnPageShow();
+
+	void UpdateStatsData();
+	void UpdateStatsSummary();
+	void UpdateKillHistory();
+	void UpdateFavoriteWeaponData();
+	void UpdateMapsData();
+	void UpdateRecentAchievements();
+	void UpdateLastMatchStats();
+
+	void UpdateLastMatchFavoriteWeaponStats();
+
+private:
+
+	static int AchivementDateSortPredicate( CCSBaseAchievement* const* pLeft, CCSBaseAchievement* const* pRight);
+	void DisplayCompressedLocalizedStat(CSStatType_t stat, const char* dialogVariable, const char* localizationToken = NULL);
+	void DisplayFormattedLabel(const char* localizationToken, const wchar_t* valueText, const char* dialogVariable);
+	
+	int m_iFixedWidth;
+	int m_iDefaultWeaponImage;
+	int m_iDefaultMapImage;
+
+	vgui::Label*		m_pLabelRoundsPlayed;
+	vgui::Label*		m_pLabelRoundsWon;
+	vgui::ImagePanel*	m_pImagePanelFavWeapon;
+	vgui::ImagePanel*	m_pImagePanelLastMapFavWeapon;
+	vgui::ImagePanel*	m_pImagePanelFavMap;
+
+	vgui::ImageList		*m_pImageList;
+
+	vgui::PanelListPanel	*m_pRecentAchievementsList;
+
+	StatCard*			m_pStatCard;
+	
+	bool				m_bRecentAchievementsDirty;
+	bool				m_bStatsDirty;
+
+	CUtlMap<CSStatType_t, int> m_StatImageMap;
+};
+#endif // CSSTATSSUMMARY_H
\ No newline at end of file
diff --git a/game/client/cstrike/VGUI/win_panel_round.cpp b/game/client/cstrike/VGUI/win_panel_round.cpp
new file mode 100644
index 00000000..7c05f267
--- /dev/null
+++ b/game/client/cstrike/VGUI/win_panel_round.cpp
@@ -0,0 +1,470 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Create and display a win panel at the end of a round displaying interesting stats and info about the round.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "win_panel_round.h"
+#include "vgui_controls/AnimationController.h"
+#include "iclientmode.h"
+#include "c_playerresource.h"
+#include <vgui_controls/Label.h>
+#include <vgui/ILocalize.h>
+#include <vgui/ISurface.h>
+#include <vgui/ISystem.h>
+#include "fmtstr.h"
+#include "cs_gamestats_shared.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+ConVar cl_round_win_fade_time( "cl_round_win_fade_time", "1.5", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+
+DECLARE_HUDELEMENT_DEPTH( WinPanel_Round, 1 );	// 1 is foreground
+extern const wchar_t *LocalizeFindSafe( const char *pTokenName );
+
+
+// helper function for converting wstrings to upper-case inline
+// NB: this returns a pointer to a static buffer
+wchar_t* UpperCaseWideString( const wchar_t* wszSource )
+{
+	static wchar_t wszBuffer[256];
+	V_wcsncpy(wszBuffer, wszSource, sizeof(wszBuffer));
+	V_wcsupr(wszBuffer);
+	return wszBuffer;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+WinPanel_Round::WinPanel_Round( const char *pElementName ) :
+	BorderedPanel( NULL, pElementName ),
+	CHudElement( pElementName ),
+	m_bIsFading(false),
+	m_fFadeBeginTime(0.0f)
+{
+	SetSize( 10, 10 ); // Quiet "parent not sized yet" spew
+	SetParent(g_pClientMode->GetViewport());	
+
+	SetScheme( "ClientScheme" );
+
+	RegisterForRenderGroup( "hide_for_scoreboard" );
+
+	m_bShouldBeVisible = false;
+}
+
+WinPanel_Round::~WinPanel_Round()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void WinPanel_Round::Reset()
+{
+	Hide();	
+}
+
+void WinPanel_Round::Init()
+{
+	CHudElement::Init();
+
+	// listen for events
+	ListenForGameEvent( "round_end" );
+	ListenForGameEvent( "round_start" );
+	ListenForGameEvent( "cs_win_panel_round" );
+	ListenForGameEvent( "cs_win_panel_match" );
+	ListenForGameEvent( "round_mvp" );
+
+	InitLayout();
+	
+	m_bShouldBeVisible = false;
+	m_bShowTimerDefend = false;
+	m_bShowTimerAttack = false;
+}
+
+
+void WinPanel_Round::InitLayout()
+{
+	// reload control settings when resolution changes to force update of proportional layout
+	LoadControlSettings("Resource/UI/Win_Round.res");
+
+	CAvatarImagePanel* pMVP_Avatar = dynamic_cast<CAvatarImagePanel*>(FindChildByName("MVP_Avatar"));
+	pMVP_Avatar->SetDefaultAvatar(scheme()->GetImage( CSTRIKE_DEFAULT_AVATAR, true));
+	pMVP_Avatar->SetShouldDrawFriendIcon(false);
+}
+
+
+void WinPanel_Round::VidInit()
+{	
+}
+
+//=============================================================================
+// HPE_BEGIN:
+// [Forrest] Allow win panel to be turned off on client
+//=============================================================================
+ConVar cl_nowinpanel(
+	"cl_nowinpanel",
+	"0",
+	FCVAR_ARCHIVE,
+	"Turn on/off win panel on client"
+	);
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+void WinPanel_Round::FireGameEvent( IGameEvent* event )
+{
+	const char *pEventName = event->GetName();
+
+	if ( Q_strcmp( "round_end", pEventName ) == 0 )
+	{
+	}		
+	else if ( Q_strcmp( "round_start", pEventName ) == 0 )
+	{		
+		Hide();		
+	}
+	else if( Q_strcmp( "cs_win_panel_match", pEventName ) == 0 )
+	{	
+		Hide();
+	}
+	else if( Q_strcmp( "round_mvp", pEventName ) == 0 )
+	{		
+		C_BasePlayer *basePlayer = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+		CSMvpReason_t mvpReason = (CSMvpReason_t)event->GetInt( "reason" );
+
+		if( basePlayer )
+		{
+			SetMVP( ToCSPlayer( basePlayer ), mvpReason );
+		}
+	}
+	else if ( Q_strcmp( "cs_win_panel_round", pEventName ) == 0 )
+	{
+		/*
+		"show_timer_defend"	"bool"
+		"show_timer_attack"	"bool"
+		"timer_time"		"int"
+
+		"final_event"		"byte"		// 0 - no event, 1 - bomb exploded, 2 - flag capped, 3 - timer expired
+
+		"funfact_type"		"byte"		//WINPANEL_FUNFACT in cs_shareddef.h
+		"funfact_player"	"byte"
+		"funfact_data1"		"long"
+		"funfact_data2"		"long"
+		"funfact_data3"		"long"
+		*/
+
+		if ( !g_PR )
+			return;
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [Forrest] Check if win panel is disabled.
+		//=============================================================================
+		static ConVarRef sv_nowinpanel( "sv_nowinpanel" );
+		if ( sv_nowinpanel.GetBool() || cl_nowinpanel.GetBool() )
+			return;
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+		m_bShowTimerDefend = event->GetBool( "show_timer_defend" );
+		m_bShowTimerAttack = event->GetBool( "show_timer_attack" );
+		int iTimerTime = event->GetInt( "timer_time" );
+
+		int minutes = clamp( iTimerTime / 60, 0, 99 );
+		int seconds = clamp( iTimerTime % 60, 0, 59 );
+
+		wchar_t time[8];
+		_snwprintf( time, ARRAYSIZE( time ), L"%d:%02d", minutes, seconds );
+
+		SetDialogVariable("TIMER_TEXT", time);
+
+		// Final Fun Fact
+		SetFunFactLabel( L"");
+		int iFunFactPlayer = event->GetInt("funfact_player");
+		const char* funfactToken = event->GetString("funfact_token", "");
+
+		if (strlen(funfactToken) != 0)
+		{
+			wchar_t funFactText[256];
+			wchar_t playerText[64];
+			wchar_t dataText1[8], dataText2[8], dataText3[8];
+			int param1 = event->GetInt("funfact_data1");
+			int param2 = event->GetInt("funfact_data2");
+			int param3 = event->GetInt("funfact_data3");
+			if ( iFunFactPlayer >= 1 && iFunFactPlayer <= MAX_PLAYERS )
+			{
+				const char* playerName = g_PR->GetPlayerName( iFunFactPlayer );
+				if( playerName && Q_strcmp( playerName, PLAYER_UNCONNECTED_NAME ) != 0 && Q_strcmp( playerName, PLAYER_ERROR_NAME ) != 0 )
+				{
+					V_strtowcs( g_PR->GetPlayerName( iFunFactPlayer ), 64, playerText, sizeof( playerText ) );
+				}
+				else
+				{
+#ifdef WIN32
+					_snwprintf( playerText, ARRAYSIZE( playerText ), L"%s", LocalizeFindSafe( "#winpanel_former_player" ) );
+#else
+					_snwprintf( playerText, ARRAYSIZE( playerText ), L"%S", LocalizeFindSafe( "#winpanel_former_player" ) );
+#endif
+				}
+			}
+			else
+			{
+				_snwprintf( playerText, ARRAYSIZE( playerText ), L"" );
+			}
+			_snwprintf( dataText1, ARRAYSIZE( dataText1 ), L"%i", param1 );
+			_snwprintf( dataText2, ARRAYSIZE( dataText2 ), L"%i", param2 );
+			_snwprintf( dataText3, ARRAYSIZE( dataText3 ), L"%i", param3 );
+			g_pVGuiLocalize->ConstructString( funFactText, sizeof(funFactText), (wchar_t *)LocalizeFindSafe(funfactToken), 4,
+				playerText, dataText1, dataText2, dataText3 );
+			SetFunFactLabel(funFactText);
+		}
+
+		int iEndEvent = event->GetInt( "final_event" );
+
+		//Map the round end events onto localized strings
+		const char* endEventToString[RoundEndReason_Count];
+		V_memset(endEventToString, 0, sizeof(endEventToString));
+
+		//terrorist win events
+		endEventToString[Target_Bombed] = "#winpanel_end_target_bombed";
+		endEventToString[VIP_Assassinated] = "#winpanel_end_vip_assassinated";
+		endEventToString[Terrorists_Escaped] = "#winpanel_end_terrorists_escaped";
+		endEventToString[Terrorists_Win] = "#winpanel_end_terrorists__kill";
+		endEventToString[Hostages_Not_Rescued] = "#winpanel_end_hostages_not_rescued";
+		endEventToString[VIP_Not_Escaped] = "#winpanel_end_vip_not_escaped";
+
+		//CT win events
+		endEventToString[VIP_Escaped] = "#winpanel_end_vip_escaped";
+		endEventToString[CTs_PreventEscape] = "#winpanel_end_cts_prevent_escape";
+		endEventToString[Escaping_Terrorists_Neutralized] = "#winpanel_end_escaping_terrorists_neutralized";
+		endEventToString[Bomb_Defused] = "#winpanel_end_bomb_defused";
+		endEventToString[CTs_Win] = "#winpanel_end_cts_win";
+		endEventToString[All_Hostages_Rescued] = "#winpanel_end_all_hostages_rescued";
+		endEventToString[Target_Saved] = "#winpanel_end_target_saved";
+		endEventToString[Terrorists_Not_Escaped] = "#winpanel_end_terrorists_not_escaped";
+
+		//We don't show a round end panel for these
+		endEventToString[Game_Commencing] = "";
+		endEventToString[Round_Draw] = "";
+
+		const wchar_t* wszEventMessage = NULL;
+		if(iEndEvent >=0 && iEndEvent < RoundEndReason_Count)
+			wszEventMessage = LocalizeFindSafe(endEventToString[iEndEvent]);
+
+		if ( wszEventMessage != NULL )
+		{
+			SetDialogVariable("WIN_DESCRIPTION", UpperCaseWideString(wszEventMessage));
+		}
+		else
+		{
+			SetDialogVariable("WIN_DESCRIPTION", "");
+		}
+
+		Label* pWinLabel = dynamic_cast<Label*>(FindChildByName("WinLabel"));
+		switch(iEndEvent)
+		{
+		case Target_Bombed:
+		case VIP_Assassinated:
+		case Terrorists_Escaped:
+		case Terrorists_Win:
+		case Hostages_Not_Rescued:            
+		case VIP_Not_Escaped:
+			pWinLabel->SetText(UpperCaseWideString(LocalizeFindSafe("#winpanel_t_win")));
+			pWinLabel->SetFgColor(Color(184,0,0,255));
+			break;
+
+		case VIP_Escaped:
+		case CTs_PreventEscape:
+		case Escaping_Terrorists_Neutralized:
+		case Bomb_Defused:
+		case CTs_Win:
+		case All_Hostages_Rescued:
+		case Target_Saved:
+		case Terrorists_Not_Escaped:
+			pWinLabel->SetText(UpperCaseWideString(LocalizeFindSafe("#winpanel_ct_win")));
+			pWinLabel->SetFgColor(Color(71,152,237,255));
+			break;
+
+		case Round_Draw:
+			pWinLabel->SetText(UpperCaseWideString(LocalizeFindSafe("#winpanel_draw")));
+			pWinLabel->SetFgColor(Color(204,204,204,255));
+			break;
+		}
+
+		//[tj]	We set the icon to the generic one right before we show it.
+		//		The expected result is that we replace it immediately with
+		//		the round MVP. if there is none, we just use the generic.
+		SetMVP( NULL, CSMVP_UNDEFINED );
+
+		Show();
+	}
+}
+
+void WinPanel_Round::SetMVP( C_CSPlayer* pPlayer, CSMvpReason_t reason )
+{
+	CAvatarImagePanel* pMVP_Avatar = dynamic_cast<CAvatarImagePanel*>(FindChildByName("MVP_Avatar"));
+	
+	if ( pMVP_Avatar )
+	{
+		pMVP_Avatar->ClearAvatar();
+	}
+
+	//First set the text to the name of the player
+	//=============================================================================
+	// HPE_BEGIN:
+	// [Forrest] Allow MVP to be turned off for a server
+	//=============================================================================
+	bool isThereAnMVP = ( pPlayer != NULL );
+	if ( isThereAnMVP )
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	{
+
+		const char* mvpReasonToken = NULL;
+		switch ( reason )
+		{
+		case CSMVP_ELIMINATION:
+			mvpReasonToken = "winpanel_mvp_award_kills";
+			break;
+		case CSMVP_BOMBPLANT:
+			mvpReasonToken = "winpanel_mvp_award_bombplant";
+			break;
+		case CSMVP_BOMBDEFUSE:
+			mvpReasonToken = "winpanel_mvp_award_bombdefuse";
+			break;
+		case CSMVP_HOSTAGERESCUE:
+			mvpReasonToken = "winpanel_mvp_award_rescue";
+			break;
+		default:
+			mvpReasonToken = "winpanel_mvp_award";
+			break;
+		}
+
+		wchar_t wszBuf[256], wszPlayerName[64];
+		g_pVGuiLocalize->ConvertANSIToUnicode(UTIL_SafeName(pPlayer->GetPlayerName()), wszPlayerName, sizeof(wszPlayerName));
+
+		wchar_t *pReason = (wchar_t *)LocalizeFindSafe( mvpReasonToken );
+		if ( !pReason )
+		{
+			pReason = L"%s1";
+		}
+
+		g_pVGuiLocalize->ConstructString( wszBuf, sizeof( wszBuf ), pReason, 1, wszPlayerName );
+		SetDialogVariable( "MVP_TEXT", wszBuf );
+
+		player_info_t pi;
+		if ( engine->GetPlayerInfo(pPlayer->entindex(), &pi) )
+		{
+			if ( pMVP_Avatar )
+			{
+				pMVP_Avatar->SetDefaultAvatar( GetDefaultAvatarImage( pPlayer ) );
+				pMVP_Avatar->SetPlayer( pPlayer, k_EAvatarSize64x64 );
+			}
+		}
+	}
+	else
+	{
+		SetDialogVariable( "MVP_TEXT", "");
+	}
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [Forrest] Allow MVP to be turned off for a server
+	//=============================================================================
+	// The avatar image and its accompanying elements should be hidden if there is no MVP for the round.
+	if ( pMVP_Avatar )
+	{
+		pMVP_Avatar->SetVisible( isThereAnMVP );
+	}
+	ImagePanel* pMVP_AvatarGlow = dynamic_cast<ImagePanel*>(FindChildByName("MVP_AvatarGlow"));
+	if ( pMVP_AvatarGlow )
+	{
+		pMVP_AvatarGlow->SetVisible( isThereAnMVP );
+	}
+	ImagePanel* pMVP_Foreground_Star = dynamic_cast<ImagePanel*>(FindChildByName("MVP_Foreground_Star"));
+	if ( pMVP_Foreground_Star )
+	{
+		pMVP_Foreground_Star->SetVisible( isThereAnMVP );
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+void WinPanel_Round::SetFunFactLabel( const wchar *szFunFact )
+{
+	SetDialogVariable( "FUNFACT", szFunFact );
+}
+
+void WinPanel_Round::Show( void )
+{
+	int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "hide_for_round_panel" );
+	if ( iRenderGroup >= 0)
+	{
+		gHUD.LockRenderGroup( iRenderGroup );
+	}
+
+	m_bShouldBeVisible = true;
+	SetAlpha(255);
+	m_bIsFading = false;
+}
+
+void WinPanel_Round::Hide( void )
+{
+	if ( m_bShouldBeVisible && !m_bIsFading )
+	{
+		m_bIsFading = true;
+		m_fFadeBeginTime = gpGlobals->realtime;
+	}
+}
+
+void WinPanel_Round::OnThink()
+{
+	if ( m_bShouldBeVisible && m_bIsFading )
+	{
+		float fAlpha = 1.0f - (gpGlobals->realtime - m_fFadeBeginTime) / cl_round_win_fade_time.GetFloat();
+
+		if (fAlpha >= 0.0f)
+		{
+			SetAlpha(RoundFloatToInt(fAlpha * 255.0f));
+		}
+		else
+		{
+			int iRenderGroup = gHUD.LookupRenderGroupIndexByName( "hide_for_round_panel" );
+			if ( iRenderGroup >= 0 )
+			{
+				gHUD.UnlockRenderGroup( iRenderGroup );
+			}
+			m_bShouldBeVisible = false;
+			SetAlpha(0);			
+			m_bIsFading = false;
+		}
+	}
+}
+
+void WinPanel_Round::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	SetFgColor(Color(251,176,59,255));
+	SetBgColor(Color(0,0,0,212));
+}
+
+void WinPanel_Round::OnScreenSizeChanged( int nOldWide, int nOldTall )
+{
+	BaseClass::OnScreenSizeChanged(nOldWide, nOldTall);
+
+	InitLayout();
+
+
+}
+
+bool WinPanel_Round::ShouldDraw( void )
+{
+	return ( m_bShouldBeVisible && CHudElement::ShouldDraw());
+}
diff --git a/game/client/cstrike/VGUI/win_panel_round.h b/game/client/cstrike/VGUI/win_panel_round.h
new file mode 100644
index 00000000..f5a6d7e5
--- /dev/null
+++ b/game/client/cstrike/VGUI/win_panel_round.h
@@ -0,0 +1,65 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Create and display a win panel at the end of a round displaying interesting stats and info about the round.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CSWINPANEL_ROUND_H
+#define CSWINPANEL_ROUND_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "VGUI/bordered_panel.h"
+#include <game/client/iviewport.h>
+#include <vgui/IScheme.h>
+#include "hud.h"
+#include "hudelement.h"
+#include "c_cs_player.h"
+#include "vgui_avatarimage.h"
+
+#include "cs_shareddefs.h"
+
+using namespace vgui;
+
+class WinPanel_Round : public BorderedPanel, public CHudElement
+{
+private:
+	DECLARE_CLASS_SIMPLE( WinPanel_Round, BorderedPanel );
+
+public:
+	WinPanel_Round(const char *pElementName);
+    ~WinPanel_Round();
+
+	virtual void Reset();
+	virtual void Init();
+	virtual void VidInit();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void FireGameEvent( IGameEvent * event );
+	virtual bool ShouldDraw( void );
+	virtual void Paint( void ) {};
+	virtual void OnScreenSizeChanged(int nOldWide, int nOldTall);
+
+	virtual void OnThink();
+
+	void InitLayout();
+	void Show();
+	void Hide();
+
+protected:
+	void SetMVP( C_CSPlayer* pPlayer, CSMvpReason_t reason );
+	void SetFunFactLabel( const wchar *szFunFact );
+
+private:
+	bool m_bShowTimerDefend;
+	bool m_bShowTimerAttack;
+
+	bool m_bShouldBeVisible;
+
+	// fade tracking
+	bool m_bIsFading;
+	float m_fFadeBeginTime;
+};
+
+#endif //CSWINPANEL_ROUND_H
\ No newline at end of file
diff --git a/game/client/cstrike/buy_presets/buy_preset.cpp b/game/client/cstrike/buy_presets/buy_preset.cpp
new file mode 100644
index 00000000..369fccc8
--- /dev/null
+++ b/game/client/cstrike/buy_presets/buy_preset.cpp
@@ -0,0 +1,1195 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#include "buy_preset_debug.h"
+#include "buy_presets.h"
+#include "weapon_csbase.h"
+#include "cs_ammodef.h"
+#include "cs_gamerules.h"
+#include "cstrike/bot/shared_util.h"
+#include "vgui/ILocalize.h"
+#include <vgui_controls/Controls.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+extern ConVar cl_rebuy;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns true if the local player is a CT and the map is a defuse map.
+ */
+static bool CanBuyDefuser()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	return ( pPlayer && pPlayer->GetTeamNumber() == TEAM_CT && CSGameRules()->IsBombDefuseMap() );
+}
+
+
+void BuyPresetManager::GetCurrentLoadout( WeaponSet *weaponSet )
+{
+	if ( !weaponSet )
+		return;
+
+	C_CSPlayer *player = C_CSPlayer::GetLocalCSPlayer();
+	if ( !player )
+		return;
+
+	CWeaponCSBase *pWeapon;
+	const CCSWeaponInfo *pInfo;
+
+	int ammo[MAX_AMMO_TYPES];
+	memset( ammo, 0, sizeof(ammo) );
+	FillClientAmmo( ammo );
+
+	weaponSet->Reset();
+
+	// Grab current armor values
+	weaponSet->m_armor = ( player->ArmorValue() > 0 ) ? 100 : 0;
+	weaponSet->m_helmet = player->HasHelmet();
+
+	// Grab current smoke grenade
+	pWeapon = dynamic_cast< CWeaponCSBase * >(player->GetCSWeapon( WEAPON_SMOKEGRENADE ));
+	pInfo = GetWeaponInfo( WEAPON_SMOKEGRENADE );
+	int ammoType = (pInfo)?pInfo->iAmmoType:0;
+	weaponSet->m_smokeGrenade = (pWeapon && player->GetAmmoCount( ammoType ));
+
+	// Grab current HE grenade
+	pWeapon = dynamic_cast< CWeaponCSBase * >(player->GetCSWeapon( WEAPON_HEGRENADE ));
+	pInfo = GetWeaponInfo( WEAPON_HEGRENADE );
+	ammoType = (pInfo)?pInfo->iAmmoType:0;
+	weaponSet->m_HEGrenade = (pWeapon && player->GetAmmoCount( ammoType ));
+
+	// Grab current flashbangs
+	pWeapon = dynamic_cast< CWeaponCSBase * >(player->GetCSWeapon( WEAPON_FLASHBANG ));
+	pInfo = GetWeaponInfo( WEAPON_FLASHBANG );
+	ammoType = (pInfo)?pInfo->iAmmoType:0;
+	weaponSet->m_flashbangs = (!pWeapon) ? 0 : player->GetAmmoCount( ammoType );
+
+	// Grab current equipment
+	weaponSet->m_defuser = player->HasDefuser();
+	weaponSet->m_nightvision = player->HasNightVision();
+
+	// Grab current primary weapon
+	CSWeaponID primaryID = GetClientWeaponID( true );		///< The local player's current primary weapon
+	pInfo = GetWeaponInfo( primaryID );
+	if ( pInfo )
+	{
+		int roundsNeeded = ammo[pInfo->iAmmoType];
+		int buySize = GetCSAmmoDef()->GetBuySize( pInfo->iAmmoType );
+		int numClips = ceil(roundsNeeded/(float)buySize);
+
+		weaponSet->m_primaryWeapon.SetWeaponID( primaryID );
+		weaponSet->m_primaryWeapon.SetAmmoType( AMMO_CLIPS );
+		weaponSet->m_primaryWeapon.SetAmmoAmount( numClips );
+		weaponSet->m_primaryWeapon.SetFillAmmo( false );
+	}
+
+	// Grab current pistol
+	CSWeaponID secondaryID = GetClientWeaponID( false );	///< The local player's current pistol
+	pInfo = GetWeaponInfo( secondaryID );
+	if ( pInfo )
+	{
+		int roundsNeeded = ammo[pInfo->iAmmoType];
+		int buySize = GetCSAmmoDef()->GetBuySize( pInfo->iAmmoType );
+		int numClips = ceil(roundsNeeded/(float)buySize);
+
+		weaponSet->m_secondaryWeapon.SetWeaponID( secondaryID );
+		weaponSet->m_secondaryWeapon.SetAmmoType( AMMO_CLIPS );
+		weaponSet->m_secondaryWeapon.SetAmmoAmount( numClips );
+		weaponSet->m_secondaryWeapon.SetFillAmmo( false );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+WeaponSet::WeaponSet()
+{
+	Reset();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Sets reasonable defaults for an empty weapon set: no primary/secondary weapons, no equipment, and
+ *  everything optional.
+ */
+void WeaponSet::Reset()
+{
+	BuyPresetWeapon blank;
+	m_primaryWeapon = blank;
+	m_secondaryWeapon = blank;
+
+	m_armor = 0;
+	m_helmet = false;
+	m_smokeGrenade = false;
+	m_HEGrenade = false;
+	m_flashbangs = 0;
+	m_defuser = false;
+	m_nightvision = false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Constructs a WeaponSet containing everything that could be purchased right now.  The cost is also
+ *  returned, and is -1 if the set is not purchasable (as opposed to completely purchased already, in
+ *  which case cost is 0.)
+ */
+void WeaponSet::GetCurrent( int& cost, WeaponSet& ws ) const
+{
+	cost = -1;
+	ws.Reset();
+
+	if ( !engine->IsConnected() )
+		return;
+
+	C_CSPlayer *player = CCSPlayer::GetLocalCSPlayer();
+	if ( !player )
+		return;
+
+	if ( player->GetTeamNumber() != TEAM_CT && player->GetTeamNumber() != TEAM_TERRORIST )
+		return;
+
+	// we're connected, and a valid team, so we can purchase
+	cost = 0;
+
+	if ( player->IsVIP() )
+		return; // can't buy anything as the VIP
+
+	int iHelmetPrice = HELMET_PRICE;
+	int iKevlarPrice = KEVLAR_PRICE;
+	int iNVGPrice = NVG_PRICE;
+
+	if ( CSGameRules()->IsBlackMarket() )
+	{
+		iHelmetPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_ASSAULTSUIT ) - CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
+		iKevlarPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
+		iNVGPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_NVG );
+	}
+
+	//-------------------------------------------------------------------------
+	//-------------------------------------------------------------------------
+	// Buy any required items
+
+	//-------------------------------------------------------------------------
+	// Armor
+	if ( m_armor > player->ArmorValue() )
+	{
+		cost += iKevlarPrice;
+		ws.m_armor = 100;
+	}
+
+	if ( (m_helmet && m_armor > 0) && !player->HasHelmet() )
+	{
+		cost += iHelmetPrice;
+		ws.m_armor = 100;
+		ws.m_helmet = true;
+	}
+
+	CWeaponCSBase *pWeapon;
+	CCSWeaponInfo *pInfo;
+
+	//-------------------------------------------------------------------------
+	// Smoke grenade
+	pWeapon = dynamic_cast< CWeaponCSBase * >(player->GetCSWeapon( WEAPON_SMOKEGRENADE ));
+	pInfo = GetWeaponInfo( WEAPON_SMOKEGRENADE );
+	int ammoType = (pInfo)?pInfo->iAmmoType:0;
+
+	bool hasSmokeGrenade = (pWeapon && player->GetAmmoCount( ammoType ));
+	if ( m_smokeGrenade && !hasSmokeGrenade )
+	{
+		cost += pInfo->GetWeaponPrice();
+		ws.m_smokeGrenade = true;
+		hasSmokeGrenade = true;
+	}
+
+	//-------------------------------------------------------------------------
+	// HE grenade
+	pWeapon = dynamic_cast< CWeaponCSBase * >(player->GetCSWeapon( WEAPON_HEGRENADE ));
+	pInfo = GetWeaponInfo( WEAPON_HEGRENADE );
+	ammoType = (pInfo)?pInfo->iAmmoType:0;
+
+	bool hasHEGrenade = (pWeapon && player->GetAmmoCount( ammoType ));
+	if ( m_HEGrenade && !hasHEGrenade )
+	{
+		cost += pInfo->GetWeaponPrice();
+		ws.m_HEGrenade = true;
+		hasHEGrenade = true;
+	}
+
+	//-------------------------------------------------------------------------
+	// Flashbang grenades
+	pWeapon = dynamic_cast< CWeaponCSBase * >(player->GetCSWeapon( WEAPON_FLASHBANG ));
+	pInfo = GetWeaponInfo( WEAPON_FLASHBANG );
+	ammoType = (pInfo)?pInfo->iAmmoType:0;
+
+	int numFlashbangs = (!pWeapon) ? 0 : player->GetAmmoCount( ammoType );
+	if ( m_flashbangs && numFlashbangs < m_flashbangs )
+	{
+		int count = m_flashbangs - numFlashbangs;
+		cost += pInfo->GetWeaponPrice() * count;
+		ws.m_flashbangs = count;
+		numFlashbangs += count;
+	}
+
+	//-------------------------------------------------------------------------
+	// defuser
+	if ( m_defuser && player->GetTeamNumber() == TEAM_CT && !player->HasDefuser() && CanBuyDefuser() )
+	{
+		cost += DEFUSEKIT_PRICE;
+		ws.m_defuser = true;
+	}
+
+	//-------------------------------------------------------------------------
+	// nightvision goggles
+	if ( m_nightvision && !player->HasNightVision() )
+	{
+		cost += iNVGPrice;
+		ws.m_nightvision = true;
+	}
+
+	//-------------------------------------------------------------------------
+	// Construct a list of weapons to buy from.
+	CSWeaponID primaryID = GetClientWeaponID( true );		///< The local player's current primary weapon
+	CSWeaponID secondaryID = GetClientWeaponID( false );	///< The local player's current pistol
+
+	BuyPresetWeaponList primaryWeapons;
+	primaryWeapons.AddToTail( m_primaryWeapon );
+
+	BuyPresetWeaponList secondaryWeapons;
+	secondaryWeapons.AddToTail( m_secondaryWeapon );
+
+	/**
+	 *  Determine best weapons & ammo to purchase
+	 *
+	 *  For each primary weapon in the list, do the following until one satisfies the current money situation:
+	 *    1. buy primary weapon and its ammo (NEED TO WATCH FOR WEAPONS PLAYER CANNOT BUY!!!)
+	 *    2. for each non-optional secondary weapon (if any),
+	 *         try to buy it and its ammo
+	 *    3. when a set can be purchased, add it to the total cost and stop processing
+	 *  If we can't purchase the primary weapon, or a required secondary weapon, the WeaponSet can't be bought,
+	 *  so we return -1.
+	 *
+	 *  To find if a weapon is owned, we can compare it's weaponID to either primaryID or secondaryID from above.
+	 */
+
+	int currentCost = cost;
+	int ammo[MAX_AMMO_TYPES];
+	memset( ammo, 0, sizeof(ammo) );
+	FillClientAmmo( ammo );
+	const BuyPresetWeapon *primaryWeaponToBuy = NULL;
+	const BuyPresetWeapon *secondaryWeaponToBuy = NULL;
+	int primaryClipsToBuy = 0;
+	int secondaryClipsToBuy = 0;
+	int currentNonWeaponCost = currentCost;
+	bool doneBuyingWeapons = false;
+
+	int currentCash = player->GetAccount();
+
+	//-------------------------------------------------------------------------
+	// Try to buy the primary weapon
+	int i;
+	for ( i=0; i<primaryWeapons.Count() && !doneBuyingWeapons; ++i )
+	{
+		const BuyPresetWeapon *primaryWeapon = &primaryWeapons[i];
+		primaryWeaponToBuy = NULL;
+		int primaryClips = 0;
+		primaryClipsToBuy = 0;
+		currentCost = currentNonWeaponCost;
+		FillClientAmmo( ammo );
+
+		CSWeaponID weaponID = primaryWeapon->GetWeaponID();
+		if ( weaponID == WEAPON_NONE )
+			weaponID = primaryID;
+
+		CCSWeaponInfo *primaryInfo = GetWeaponInfo( weaponID );
+		int primaryAmmoCost = 0;
+		int primaryAmmoBuySize = 0;
+		if ( primaryInfo )
+		{
+			primaryClips = CalcClipsNeeded( primaryWeapon, primaryInfo, ammo );
+			int primaryWeaponCost = ( weaponID != primaryID ) ? primaryInfo->GetWeaponPrice() : 0;
+			primaryAmmoCost = GetCSAmmoDef()->GetCost( primaryInfo->iAmmoType );
+			primaryAmmoBuySize = GetCSAmmoDef()->GetBuySize( primaryInfo->iAmmoType );
+			currentCost += primaryWeaponCost;
+			currentCost += primaryAmmoCost * primaryClips;
+			ammo[primaryInfo->iAmmoType] += primaryClips * primaryAmmoBuySize;
+
+			CURRENTCOST_DEBUG("\t%5.5d (%s)\n", primaryWeaponCost, WeaponIDToAlias( weaponID ));
+			CURRENTCOST_DEBUG("\t%5.5d (ammo x %d)\n", primaryAmmoCost * primaryClips, primaryClips);
+			if ( currentCash < currentCost )
+			{
+				currentCost = currentNonWeaponCost;	// can't afford it, so try the next weapon
+				continue;
+			}
+
+			// check for as_* maps, and CTs buying AK47s, etc
+			if ( !CanBuyWeapon(primaryID, secondaryID, weaponID) && weaponID != primaryID )
+			{
+				currentCost = currentNonWeaponCost;	// can't buy it, so try the next weapon
+				continue;
+			}
+
+			primaryWeaponToBuy = primaryWeapon;
+			primaryClipsToBuy = primaryClips;
+		}
+
+		if ( !secondaryWeapons.Count() )
+		{
+			CURRENTCOST_DEBUG("\t\t\tDone buying weapons (no secondary)\n");
+			break;
+		}
+
+		//-------------------------------------------------------------------------
+		// Try to buy a (required) secondary weapon to go with primaryWeaponToBuy.
+		// If not, reset cost to not reflect either weapon, so we can look at buying
+		// the next primary weapon in the list.
+		int j;
+		for ( j=0; j<secondaryWeapons.Count(); ++j )
+		{
+			const BuyPresetWeapon *secondaryWeapon = &secondaryWeapons[j];
+
+			// reset ammo counts and cost
+			secondaryWeaponToBuy = NULL;
+			secondaryClipsToBuy = 0;
+			currentCost = currentNonWeaponCost;
+			FillClientAmmo( ammo );
+
+			// add in ammo we're already buying for the primary weapon to the client's actual ammo
+			if ( primaryInfo )
+			{
+				currentCost += ( weaponID != primaryID ) ? primaryInfo->GetWeaponPrice() : 0;
+				currentCost += primaryAmmoCost * primaryClips;
+				ammo[primaryInfo->iAmmoType] += primaryClips * primaryAmmoBuySize;
+			}
+
+			int currentCostWithoutSecondary = currentCost;
+
+			CSWeaponID weaponID = secondaryWeapon->GetWeaponID();
+			if ( weaponID == WEAPON_NONE )
+				weaponID = secondaryID;
+
+			CCSWeaponInfo *secondaryInfo = GetWeaponInfo( weaponID );
+			if ( !secondaryInfo )
+			{
+				currentCost = currentCostWithoutSecondary;
+				continue;
+			}
+
+			int secondaryClips = CalcClipsNeeded( secondaryWeapon, secondaryInfo, ammo );
+			int secondaryWeaponCost = ( weaponID != secondaryID ) ? secondaryInfo->GetWeaponPrice() : 0;
+			int secondaryAmmoCost = GetCSAmmoDef()->GetCost( secondaryInfo->iAmmoType );
+			int secondaryAmmoBuySize = GetCSAmmoDef()->GetBuySize( secondaryInfo->iAmmoType );
+			currentCost += secondaryWeaponCost;
+			currentCost += secondaryAmmoCost * secondaryClips;
+			ammo[secondaryInfo->iAmmoType] += secondaryClips * secondaryAmmoBuySize;
+
+			CURRENTCOST_DEBUG("\t%5.5d (%s)\n", secondaryWeaponCost, WeaponIDToAlias( weaponID ));
+			CURRENTCOST_DEBUG("\t%5.5d (ammo x %d)\n", secondaryAmmoCost * secondaryClips, secondaryClips);
+			if ( currentCash < currentCost )
+			{
+				currentCost = currentCostWithoutSecondary;	// can't afford it, so skip
+				continue;
+			}
+
+			// check for as_* maps, and CTs buying elites, etc
+			if ( !CanBuyWeapon(primaryID, secondaryID, weaponID) && weaponID != secondaryID )
+			{
+				currentCost = currentCostWithoutSecondary;	// can't buy it, so skip
+				continue;
+			}
+
+			// We found both a primary and secondary weapon to buy.  Stop looking for more.
+			secondaryWeaponToBuy = secondaryWeapon;
+			secondaryClipsToBuy = secondaryClips;
+			doneBuyingWeapons = true;
+			CURRENTCOST_DEBUG("\t\t\tDone buying weapons (primary && secondary)\n");
+			break;
+		}
+	}
+
+	// Update our cost to reflect the weapons and ammo purchased
+	cost = currentCost;
+
+	if ( primaryWeaponToBuy )
+	{
+		BuyPresetWeapon weapon = *primaryWeaponToBuy;
+		weapon.SetAmmoAmount( primaryClipsToBuy );
+		weapon.SetAmmoType( AMMO_CLIPS );
+		ws.m_primaryWeapon = weapon;
+	}
+	else
+	{
+		// If we failed to buy a primary weapon, and one was in the list, bail - the player can't afford this WeaponSet.
+		for ( int i=0; i<primaryWeapons.Count(); ++i )
+		{
+			int weaponID = primaryWeapons[i].GetWeaponID();
+			if ( weaponID != WEAPON_NONE )
+			{
+				cost = -1;
+				ws.Reset();
+				return;
+			}
+		}
+	}
+
+	if ( secondaryWeaponToBuy )
+	{
+		BuyPresetWeapon weapon = *secondaryWeaponToBuy;
+		weapon.SetAmmoAmount( secondaryClipsToBuy );
+		weapon.SetAmmoType( AMMO_CLIPS );
+		ws.m_secondaryWeapon = weapon;
+	}
+	else
+	{
+		// If we failed to buy a required secondary weapon, and one was in the list, bail - the player can't afford this WeaponSet.
+		for ( int i=0; i<secondaryWeapons.Count(); ++i )
+		{
+			int weaponID = secondaryWeapons[i].GetWeaponID();
+			if ( weaponID != WEAPON_NONE )
+			{
+				cost = -1;
+				ws.Reset();
+				return;
+			}
+		}
+	}
+
+	//-------------------------------------------------------------------------
+	// now any extra ammo, in rebuy order
+	const char *remainder = SharedParse( cl_rebuy.GetString() );
+	const char *token;
+
+	while ( remainder )
+	{
+		token = SharedGetToken();
+		if ( !token || !*token )
+			return;
+
+		if ( !stricmp( token, "PrimaryAmmo" ) )
+		{
+			if ( primaryWeaponToBuy )
+			{
+				CSWeaponID id = primaryWeaponToBuy->GetWeaponID();
+				if ( id == WEAPON_NONE )
+					id = primaryID;
+
+				if ( primaryWeaponToBuy->GetFillAmmo() )
+				{
+					const CCSWeaponInfo *info = GetWeaponInfo( id );
+					if ( info )
+					{
+						int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
+						int ammoCost = GetCSAmmoDef()->GetCost( info->iAmmoType );
+						int ammoBuySize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
+						int roundsLeft = maxRounds - ammo[info->iAmmoType];
+						int clipsLeft = (ammoBuySize > 0) ? ceil(roundsLeft / (float)ammoBuySize) : 0;
+						while ( clipsLeft > 0 && cost + ammoCost <= currentCash )
+						{
+							ws.m_primaryWeapon.SetAmmoAmount( ws.m_primaryWeapon.GetAmmoAmount() + 1 );
+							--clipsLeft;
+							ammo[info->iAmmoType] += MIN(maxRounds, ammoBuySize);
+							cost += ammoCost;
+						}
+					}
+				}
+			}
+		}
+		else if ( !stricmp( token, "SecondaryAmmo" ) )
+		{
+			if ( secondaryWeaponToBuy )
+			{
+				if ( secondaryWeaponToBuy->GetFillAmmo() )
+				{
+					CSWeaponID weaponID = secondaryWeaponToBuy->GetWeaponID();
+					if ( weaponID == WEAPON_NONE )
+						weaponID = secondaryID;
+
+					const CCSWeaponInfo *info = GetWeaponInfo( weaponID );
+					if ( info )
+					{
+						int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
+						int ammoCost = GetCSAmmoDef()->GetCost( info->iAmmoType );
+						int ammoBuySize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
+						int roundsLeft = maxRounds - ammo[info->iAmmoType];
+						int clipsLeft = (ammoBuySize > 0) ? ceil(roundsLeft / (float)ammoBuySize) : 0;
+						while ( clipsLeft > 0 && cost + ammoCost <= currentCash )
+						{
+							ws.m_secondaryWeapon.SetAmmoAmount( ws.m_secondaryWeapon.GetAmmoAmount() + 1 );
+							--clipsLeft;
+							ammo[info->iAmmoType] += MIN(maxRounds, ammoBuySize);
+							cost += ammoCost;
+						}
+					}
+				}
+			}
+		}
+
+		remainder = SharedParse( remainder );
+	}
+
+	if ( cost > currentCash )
+	{
+		cost = -1; // can't buy it
+		ws.Reset();
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Constructs a WeaponSet containing everything that can be purchased.
+ *  The cost (including extra cash) is also calculated and returned.
+ */
+void WeaponSet::GetFromScratch( int& cost, WeaponSet& ws ) const
+{
+	cost = 0;
+	ws.Reset();
+
+	int ammo[MAX_AMMO_TYPES];
+	memset( ammo, 0, sizeof(ammo) );
+
+	int iHelmetPrice = HELMET_PRICE;
+	int iKevlarPrice = KEVLAR_PRICE;
+	int iNVGPrice = NVG_PRICE;
+
+	if ( CSGameRules()->IsBlackMarket() )
+	{
+		iHelmetPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_ASSAULTSUIT ) - CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
+		iKevlarPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
+		iNVGPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_NVG ); 
+	}
+
+	//-------------------------------------------------------------------------
+	// Primary weapon
+	CCSWeaponInfo *primaryInfo = GetWeaponInfo( m_primaryWeapon.GetWeaponID() );
+	if ( primaryInfo )
+	{
+		int primaryClips = CalcClipsNeeded( &m_primaryWeapon, primaryInfo, ammo );
+		int primaryWeaponCost = primaryInfo->GetWeaponPrice();
+		int primaryAmmoCost = GetCSAmmoDef()->GetCost( primaryInfo->iAmmoType );
+		int primaryAmmoBuySize = GetCSAmmoDef()->GetBuySize( primaryInfo->iAmmoType );
+		cost += primaryWeaponCost;
+		cost += primaryAmmoCost * primaryClips;
+		ammo[primaryInfo->iAmmoType] += primaryClips * primaryAmmoBuySize;
+
+		ws.m_primaryWeapon = m_primaryWeapon;
+		ws.m_primaryWeapon.SetAmmoAmount( primaryClips );
+		ws.m_primaryWeapon.SetAmmoType( AMMO_CLIPS );
+		ws.m_primaryWeapon.SetFillAmmo( false );
+	}
+
+	//-------------------------------------------------------------------------
+	// secondary weapon
+	CCSWeaponInfo *secondaryInfo = GetWeaponInfo( m_secondaryWeapon.GetWeaponID() );
+	if ( secondaryInfo )
+	{
+		int secondaryClips = CalcClipsNeeded( &m_secondaryWeapon, secondaryInfo, ammo );
+		int secondaryWeaponCost = secondaryInfo->GetWeaponPrice();
+		int secondaryAmmoCost = GetCSAmmoDef()->GetCost( secondaryInfo->iAmmoType );
+		int secondaryAmmoBuySize = GetCSAmmoDef()->GetBuySize( secondaryInfo->iAmmoType );
+		cost += secondaryWeaponCost;
+		cost += secondaryAmmoCost * secondaryClips;
+		ammo[secondaryInfo->iAmmoType] += secondaryClips * secondaryAmmoBuySize;
+
+		ws.m_secondaryWeapon = m_secondaryWeapon;
+		ws.m_secondaryWeapon.SetAmmoAmount( secondaryClips );
+		ws.m_secondaryWeapon.SetAmmoType( AMMO_CLIPS );
+		ws.m_secondaryWeapon.SetFillAmmo( false );
+	}
+
+	//-------------------------------------------------------------------------
+	// equipment
+	if ( m_armor )
+	{
+		cost += (m_helmet) ? (iKevlarPrice + iHelmetPrice) : iKevlarPrice;
+		ws.m_armor = m_armor;
+		ws.m_helmet = m_helmet;
+	}
+
+	if ( m_smokeGrenade )
+	{
+		CCSWeaponInfo *pInfo = GetWeaponInfo( WEAPON_SMOKEGRENADE );
+		cost += ( pInfo ) ? pInfo->GetWeaponPrice() : 0;
+		ws.m_smokeGrenade = m_smokeGrenade;
+	}
+
+	if ( m_HEGrenade )
+	{
+		CCSWeaponInfo *pInfo = GetWeaponInfo( WEAPON_HEGRENADE );
+		cost += ( pInfo ) ? pInfo->GetWeaponPrice() : 0;
+		ws.m_HEGrenade = m_HEGrenade;
+	}
+
+	CCSWeaponInfo *pInfo = GetWeaponInfo( WEAPON_FLASHBANG );
+	cost += ( pInfo ) ? pInfo->GetWeaponPrice() * m_flashbangs : 0;
+	ws.m_flashbangs = m_flashbangs;
+
+	if ( m_defuser )
+	{
+		cost += DEFUSEKIT_PRICE;
+		ws.m_defuser = m_defuser;
+	}
+
+	if ( m_nightvision )
+	{
+		cost += iNVGPrice;
+		ws.m_nightvision = m_nightvision;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Convenience function that wraps GetFromScratch() and discards the generated WeaponSet.  Returns the cost
+ *  to buy the full WeaponSet from scratch.
+ */
+int WeaponSet::FullCost() const
+{
+	WeaponSet fullSet;
+	int cost = 0;
+	GetFromScratch( cost, fullSet );
+	return cost;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Generates a list of buy commands that will buy the current WeaponSet.
+ */
+void WeaponSet::GenerateBuyCommands( char command[BUY_PRESET_COMMAND_LEN] ) const
+{
+	command[0] = 0;
+	char *tmp = command;
+	int remainder = BUY_PRESET_COMMAND_LEN;
+	int i;
+
+	CSWeaponID primaryID = GetClientWeaponID( true );		///< The local player's current primary weapon
+	CSWeaponID secondaryID = GetClientWeaponID( false );	///< The local player's current pistol
+
+	//-------------------------------------------------------------------------
+	// Primary weapon
+	CSWeaponID weaponID = m_primaryWeapon.GetWeaponID();
+	if ( weaponID == WEAPON_NONE )
+		weaponID = primaryID;
+	const CCSWeaponInfo *primaryInfo = GetWeaponInfo( weaponID );
+	if ( primaryInfo )
+	{
+		if ( weaponID != primaryID )
+		{
+			tmp = BufPrintf( tmp, remainder, "buy %s\n", WeaponIDToAlias(weaponID) );
+		}
+		for ( i=0; i<m_primaryWeapon.GetAmmoAmount(); ++i )
+		{
+			tmp = BufPrintf( tmp, remainder, "buyammo1\n" );
+		}
+	}
+
+	//-------------------------------------------------------------------------
+	// secondary weapon
+	weaponID = m_secondaryWeapon.GetWeaponID();
+	if ( weaponID == WEAPON_NONE )
+		weaponID = secondaryID;
+	const CCSWeaponInfo *secondaryInfo = GetWeaponInfo( weaponID );
+	if ( secondaryInfo )
+	{
+		if ( weaponID != secondaryID )
+		{
+			tmp = BufPrintf( tmp, remainder, "buy %s\n", WeaponIDToAlias(weaponID) );
+		}
+		for ( i=0; i<m_secondaryWeapon.GetAmmoAmount(); ++i )
+		{
+			tmp = BufPrintf( tmp, remainder, "buyammo2\n" );
+		}
+	}
+
+	//-------------------------------------------------------------------------
+	// equipment
+	if ( m_armor )
+	{
+		if ( m_helmet )
+		{
+			tmp = BufPrintf( tmp, remainder, "buy vesthelm\n" );
+		}
+		else
+		{
+			tmp = BufPrintf( tmp, remainder, "buy vest\n" );
+		}
+	}
+
+	if ( m_smokeGrenade )
+	{
+		tmp = BufPrintf( tmp, remainder, "buy smokegrenade\n" );
+	}
+
+	if ( m_HEGrenade )
+	{
+		tmp = BufPrintf( tmp, remainder, "buy hegrenade\n" );
+	}
+
+	for ( i=0; i<m_flashbangs; ++i )
+	{
+		tmp = BufPrintf( tmp, remainder, "buy flashbang\n" );
+	}
+
+	if ( m_defuser )
+	{
+		tmp = BufPrintf( tmp, remainder, "buy defuser\n" );
+	}
+
+	if ( m_nightvision )
+	{
+		tmp = BufPrintf( tmp, remainder, "buy nvgs\n" );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Return images out of a subdir, so when the buy preset system resizes the images, they don't resize in the
+ *  main buy menu.
+ */
+const char *ImageFnameFromWeaponID( CSWeaponID weaponID, bool isPrimary )
+{
+	switch (weaponID)
+	{
+	case WEAPON_NONE:
+		return "gfx/vgui/defaultweapon";
+	case WEAPON_SCOUT:
+		return "gfx/vgui/scout";
+	case WEAPON_XM1014:
+		return "gfx/vgui/xm1014";
+	case WEAPON_MAC10:
+		return "gfx/vgui/mac10";
+	case WEAPON_AUG:
+		return "gfx/vgui/aug";
+	case WEAPON_UMP45:
+		return "gfx/vgui/ump45";
+	case WEAPON_SG550:
+		return "gfx/vgui/sg550";
+	case WEAPON_GALIL:
+		return "gfx/vgui/galil";
+	case WEAPON_FAMAS:
+		return "gfx/vgui/famas";
+	case WEAPON_AWP:
+		return "gfx/vgui/awp";
+	case WEAPON_MP5NAVY:
+		return "gfx/vgui/mp5";
+	case WEAPON_M249:
+		return "gfx/vgui/m249";
+	case WEAPON_M3:
+		return "gfx/vgui/m3";
+	case WEAPON_M4A1:
+		return "gfx/vgui/m4a1";
+	case WEAPON_TMP:
+		return "gfx/vgui/tmp";
+	case WEAPON_G3SG1:
+		return "gfx/vgui/g3sg1";
+	case WEAPON_SG552:
+		return "gfx/vgui/sg552";
+	case WEAPON_AK47:
+		return "gfx/vgui/ak47";
+	case WEAPON_P90:
+		return "gfx/vgui/p90";
+	case WEAPON_SHIELDGUN:
+		return "gfx/vgui/shield";
+
+	case WEAPON_USP:
+		return "gfx/vgui/usp45";
+	case WEAPON_GLOCK:
+		return "gfx/vgui/glock18";
+	case WEAPON_DEAGLE:
+		return "gfx/vgui/deserteagle";
+	case WEAPON_ELITE:
+		return "gfx/vgui/elites";
+	case WEAPON_P228:
+		return "gfx/vgui/p228";
+	case WEAPON_FIVESEVEN:
+		return "gfx/vgui/fiveseven";
+
+	default:
+		return "";
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+BuyPreset::BuyPreset()
+{
+	SetName( L"" );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+BuyPreset::BuyPreset( const BuyPreset& other )
+{
+	*this = other;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+BuyPreset::~BuyPreset()
+{
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void BuyPreset::SetName( const wchar_t *name )
+{
+	wcsncpy( m_name, name, MaxBuyPresetName );
+	if ( m_name[0] == 0 )
+	{
+		const wchar_t * defaultName = g_pVGuiLocalize->Find( "#Cstrike_BuyPresetBlank" );
+		if ( defaultName )
+		{
+			wcsncpy( m_name, defaultName, MaxBuyPresetName );
+		}
+	}
+	m_name[MaxBuyPresetName-1] = 0;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+// Parse KeyValues string into a BuyPresetWeapon vector
+static void ParseWeaponString( const char *str, BuyPresetWeaponList& weapons, bool isPrimary )
+{
+	weapons.RemoveAll();
+
+	if ( !str )
+		return;
+
+	const char *remainder = SharedParse( str );
+	const char *token;
+
+	const int BufLen = 32;
+	char tmpBuf[BufLen];
+	tmpBuf[0] = '\0';
+	char weaponBuf[BufLen];
+	weaponBuf[0] = '\0';
+	char clipModifier = 0;
+	int numClips = 0;
+
+	while ( remainder )
+	{
+		token = SharedGetToken();
+		if ( !token || strlen(token) >= BufLen )
+			return;
+
+		Q_strncpy( tmpBuf, token, BufLen );
+		tmpBuf[BufLen - 1] = 0;
+		char *tmp = tmpBuf;
+		while ( *tmp )
+		{
+			if ( *tmp == '/' )
+			{
+				*tmp = ' ';
+			}
+			++tmp;
+		}
+		// sscanf is safe, since the size of the string being scanned is at least as small as any individual destination buffer
+		if ( sscanf( tmpBuf, "%s %d%c", weaponBuf, &numClips, &clipModifier ) != 3 )
+			return;
+
+		CSWeaponID weaponID = AliasToWeaponID( weaponBuf );
+		if ( weaponID != WEAPON_NONE )
+		{
+			const CCSWeaponInfo *info = GetWeaponInfo( weaponID );
+			if ( info )
+			{
+				int maxRounds = GetCSAmmoDef()->MaxCarry( info->iAmmoType );
+				int buySize = GetCSAmmoDef()->GetBuySize( info->iAmmoType );
+				numClips = MIN(ceil(maxRounds/(float)buySize), MAX(0, numClips));
+				if ( ((!isPrimary) ^ IsPrimaryWeapon( weaponID )) == 0 )
+					return;
+			}
+			else
+			{
+				numClips = MIN(NUM_CLIPS_FOR_CURRENT, MAX(0, numClips));
+			}
+		}
+		else
+		{
+			numClips = MIN(NUM_CLIPS_FOR_CURRENT, MAX(0, numClips));
+		}
+
+		BuyPresetWeapon weapon( weaponID );
+		weapon.SetAmmoType( AMMO_CLIPS );
+		weapon.SetAmmoAmount( numClips );
+		weapon.SetFillAmmo( (clipModifier == '+') );
+		weapons.AddToTail( weapon );
+
+		remainder = SharedParse( remainder );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Populates data from a KeyValues structure, for loading
+ */
+void BuyPreset::Parse( KeyValues *data )
+{
+	m_name[0] = 0;
+	m_weaponList.RemoveAll();
+
+	if (!data)
+		return;
+
+	//-------------------------------------------------------------------------
+	// Read name
+	wcsncpy( m_name, data->GetWString( "PresetName", L""), MaxBuyPresetName );
+	m_name[ MaxBuyPresetName - 1 ] = 0;
+	PRESET_DEBUG( "Parsing Buy Preset %ls\n", m_name );
+
+	int version = data->GetInt( "Version", 0 );
+	if ( version < 4 || version > 4 )
+	{
+		PRESET_DEBUG( "Invalid preset version %d\n", version );
+		return;
+	}
+
+	const char *primaryString = data->GetString( "Primary", NULL );
+	const char *secondaryString = data->GetString( "Secondary", NULL );
+	const char *equipmentString = data->GetString( "Equipment", NULL );
+
+	CUtlVector< BuyPresetWeapon > weapons;
+	ParseWeaponString( primaryString, weapons, true );
+
+	WeaponSet ws;
+	if ( weapons.Count() )
+		ws.m_primaryWeapon = weapons[0];
+
+	weapons.RemoveAll();
+	ParseWeaponString( secondaryString, weapons, false );
+	if ( weapons.Count() )
+		ws.m_secondaryWeapon = weapons[0];
+
+	// parse equipment
+	if ( equipmentString )
+	{
+		const char *remainder = SharedParse( equipmentString );
+		const char *token;
+
+		const int BufLen = 32;
+		char tmpBuf[BufLen];
+		char itemBuf[BufLen];
+		int intVal;
+
+		while ( remainder )
+		{
+			token = SharedGetToken();
+			if ( !token || Q_strlen(token) >= BufLen )
+				break;
+
+			Q_strncpy( tmpBuf, token, BufLen );
+			tmpBuf[BufLen - 1] = 0;
+			char *tmp = tmpBuf;
+			while ( *tmp )
+			{
+				if ( *tmp == '/' )
+				{
+					*tmp = ' ';
+				}
+				++tmp;
+			}
+			// sscanf is safe, since the size of the string being scanned is at least as small as any individual destination buffer
+			if ( sscanf( tmpBuf, "%s %d", itemBuf, &intVal ) != 2 )
+				break;
+
+			if ( !strcmp( itemBuf, "vest" ) )
+			{
+				ws.m_armor = (intVal > 0) ? 100 : 0;
+				ws.m_helmet = false;
+			}
+			else if ( !strcmp( itemBuf, "vesthelm" ) )
+			{
+				ws.m_armor = (intVal > 0) ? 100 : 0;
+				ws.m_helmet = true;
+			}
+			else if ( !strcmp( itemBuf, "defuser" ) )
+			{
+				ws.m_defuser = (intVal > 0);
+			}
+			else if ( !strcmp( itemBuf, "nvgs" ) )
+			{
+				ws.m_nightvision = (intVal > 0);
+			}
+			else if ( !strcmp( itemBuf, "sgren" ) )
+			{
+				ws.m_smokeGrenade = (intVal > 0);
+			}
+			else if ( !strcmp( itemBuf, "hegren" ) )
+			{
+				ws.m_HEGrenade = (intVal > 0);
+			}
+			else if ( !strcmp( itemBuf, "flash" ) )
+			{
+				ws.m_flashbangs = MIN( 2, MAX( 0, intVal ) );
+			}
+
+			remainder = SharedParse( remainder );
+		}
+
+		m_weaponList.AddToTail( ws );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+// Build a string of weapons+ammo for KeyValues saving/loading
+static const char* ConstructWeaponString( const BuyPresetWeapon& weapon )
+{
+	const int WeaponLen = 1024;
+	static char weaponString[WeaponLen];
+	weaponString[0] = 0;
+	int remainder = WeaponLen;
+	char *tmp = weaponString;
+
+	tmp = BufPrintf( tmp, remainder, "%s/%d%c",
+		WeaponIDToAlias( weapon.GetWeaponID() ),
+		weapon.GetAmmoAmount(),
+		(weapon.GetFillAmmo()) ? '+' : '=' );
+	return weaponString;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Fills in a KeyValues structure with data, for saving
+ */
+void BuyPreset::Save( KeyValues *data )
+{
+	//-------------------------------------------------------------------------
+	// Save name and version
+	KeyValues *presetKey = data->CreateNewKey();
+	presetKey->SetWString( "PresetName", m_name );
+
+	/**
+	 *  Version History
+	 *  ---------------
+	 *
+	 *  PRE-RELEASE
+	 *  1.  2/2004
+	 *      First-pass implementation.  Allowed for multiple weapons per fallback.
+	 *      Individual items could be marked optional.  Cash reserve could be specified.
+	 *  2.  3/2004
+	 *      Second-pass implementation.  Removed multiple weapons per fallback.  The
+	 *      pistol could be marked optional.  A preset could be marked as 'use for
+	 *      Autobuy'.
+	 *
+	 *  CZ RELEASE
+	 *  3.  4/22/2004
+	 *      The first released version.  Removed optional/required status.  Also
+	 *      removed the cash reserve and autobuy status.  Corresponds to streamlined
+	 *      editing interface mocked up by Greg Coomer.
+	 *
+	 *  CS:S RELEASE
+	 *  4.  3/10/2004
+	 *      Removed fallbacks to correspond to new UI.
+	 */
+	presetKey->SetInt( "Version", 4 );
+	if ( m_weaponList.Count() > 0 )
+	{
+		//-------------------------------------------------------------------------
+		// Save a fallback WeaponSet
+		const WeaponSet& ws = m_weaponList[0];
+
+		presetKey->SetString( "Primary", ConstructWeaponString( ws.m_primaryWeapon ) );
+		presetKey->SetString( "Secondary", ConstructWeaponString( ws.m_secondaryWeapon ) );
+
+		presetKey->SetString( "Equipment",
+			SharedVarArgs("vest%s/%d flash/%d sgren/%d hegren/%d defuser/%d nvgs/%d",
+			(ws.m_helmet)?"helm":"", ws.m_armor,
+			ws.m_flashbangs,
+			ws.m_smokeGrenade,
+			ws.m_HEGrenade,
+			ws.m_defuser,
+			ws.m_nightvision
+			) );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Calculates the full cost of the preset, which is exactly the full cost of the first fallback WeaponSet
+ */
+int BuyPreset::FullCost() const
+{
+	if ( m_weaponList.Count() == 0 )
+		return 0;
+
+	return m_weaponList[0].FullCost();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the specified fallback WeaponSet, or NULL if it doesn't exist
+ */
+const WeaponSet * BuyPreset::GetSet( int index ) const
+{
+	if ( index < 0 || index >= m_weaponList.Count() )
+		return NULL;
+
+	return &(m_weaponList[index]);
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Deletes a fallback
+ */
+void BuyPreset::DeleteSet( int index )
+{
+	if ( index < 0 || index >= m_weaponList.Count() )
+		return;
+
+	m_weaponList.Remove( index );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Switches the order of two fallbacks
+ */
+void BuyPreset::SwapSet( int firstIndex, int secondIndex )
+{
+	if ( firstIndex < 0 || firstIndex >= m_weaponList.Count() )
+		return;
+
+	if ( secondIndex < 0 || secondIndex >= m_weaponList.Count() )
+		return;
+
+	WeaponSet tmpSet = m_weaponList[firstIndex];
+	m_weaponList[firstIndex] = m_weaponList[secondIndex];
+	m_weaponList[secondIndex] = tmpSet;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Replaces a fallback with the supplied WeaponSet
+ */
+void BuyPreset::ReplaceSet( int index, const WeaponSet& weaponSet )
+{
+	if ( index < 0 || index > m_weaponList.Count() )
+		return;
+
+	if ( index == m_weaponList.Count() )
+	{
+		m_weaponList.AddToTail( weaponSet );
+	}
+	else
+	{
+		m_weaponList[index] = weaponSet;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/client/cstrike/buy_presets/buy_preset_debug.cpp b/game/client/cstrike/buy_presets/buy_preset_debug.cpp
new file mode 100644
index 00000000..afe3e23f
--- /dev/null
+++ b/game/client/cstrike/buy_presets/buy_preset_debug.cpp
@@ -0,0 +1,65 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+// Author: Matthew D. Campbell (matt@turtlerockstudios.com), 2004
+
+#include "cbase.h"
+#include "buy_preset_debug.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#ifdef _DEBUG
+#define BUY_PRESET_DEBUGGING 1
+#else
+#define BUY_PRESET_DEBUGGING 0
+#endif
+
+#if BUY_PRESET_DEBUGGING
+
+static ConVar cl_preset_debug( "cl_preset_debug", "0", 0, "Controls debug information about buy presets" );
+
+//--------------------------------------------------------------------------------------------------------------
+bool IsPresetDebuggingEnabled()
+{
+	return cl_preset_debug.GetInt() >= 1.0f;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+bool IsPresetFullCostDebuggingEnabled()
+{
+	return cl_preset_debug.GetInt() == 2.0f;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+bool IsPresetCurrentCostDebuggingEnabled()
+{
+	return cl_preset_debug.GetInt() == 3.0f;
+}
+
+#else // ! BUY_PRESET_DEBUGGING
+
+//--------------------------------------------------------------------------------------------------------------
+bool IsPresetDebuggingEnabled()
+{
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+bool IsPresetFullCostDebuggingEnabled()
+{
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+bool IsPresetCurrentCostDebuggingEnabled()
+{
+	return false;
+}
+
+#endif // ! BUY_PRESET_DEBUGGING
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/client/cstrike/buy_presets/buy_preset_debug.h b/game/client/cstrike/buy_presets/buy_preset_debug.h
new file mode 100644
index 00000000..ded580bb
--- /dev/null
+++ b/game/client/cstrike/buy_presets/buy_preset_debug.h
@@ -0,0 +1,25 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef BUY_PRESET_DEBUG_H
+#define BUY_PRESET_DEBUG_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//--------------------------------------------------------------------------------------------------------------
+// Utility functions for the debugging macros below
+bool IsPresetDebuggingEnabled();			///< cl_preset_debug >= 1.0f
+bool IsPresetFullCostDebuggingEnabled();	///< cl_preset_debug == 2.0f
+bool IsPresetCurrentCostDebuggingEnabled();	///< cl_preset_debug == 3.0f
+
+//--------------------------------------------------------------------------------------------------------------
+// Macros for conditional debugging of buy presets
+#define PRESET_DEBUG		if (IsPresetDebuggingEnabled())				DevMsg
+#define FULLCOST_DEBUG		if (IsPresetFullCostDebuggingEnabled())		DevMsg
+#define CURRENTCOST_DEBUG	if (IsPresetCurrentCostDebuggingEnabled())	DevMsg
+
+#endif // BUY_PRESET_DEBUG_H
diff --git a/game/client/cstrike/buy_presets/buy_preset_weapon_info.cpp b/game/client/cstrike/buy_presets/buy_preset_weapon_info.cpp
new file mode 100644
index 00000000..24c47518
--- /dev/null
+++ b/game/client/cstrike/buy_presets/buy_preset_weapon_info.cpp
@@ -0,0 +1,364 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: BuyPresetWeapon implementation, and misc knowledge relating to weapons
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#include "buy_preset_debug.h"
+#include "buy_presets.h"
+#include "weapon_csbase.h"
+#include "cs_ammodef.h"
+#include "cs_gamerules.h"
+#include "cstrike/bot/shared_util.h"
+#include <vgui/ILocalize.h>
+#include <vgui_controls/Controls.h>
+#include "c_cs_player.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+struct WeaponDisplayNameInfo
+{
+	CSWeaponID id;
+	const char *displayName;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+// NOTE: Array must be NULL-terminated
+static WeaponDisplayNameInfo weaponDisplayNameInfo[] = 
+{
+	{ WEAPON_P228,		"#Cstrike_TitlesTXT_P228" },
+	{ WEAPON_GLOCK,		"#Cstrike_TitlesTXT_Glock18" },
+	{ WEAPON_SCOUT,		"#Cstrike_TitlesTXT_Scout" },
+	{ WEAPON_XM1014,	"#Cstrike_TitlesTXT_AutoShotgun" },
+	{ WEAPON_MAC10,		"#Cstrike_TitlesTXT_Mac10_Short" },
+	{ WEAPON_AUG,		"#Cstrike_TitlesTXT_Aug" },
+	{ WEAPON_ELITE,		"#Cstrike_TitlesTXT_Beretta96G" },
+	{ WEAPON_FIVESEVEN,	"#Cstrike_TitlesTXT_ESFiveSeven" },
+	{ WEAPON_UMP45,		"#Cstrike_TitlesTXT_KMUMP45" },
+	{ WEAPON_SG550,		"#Cstrike_TitlesTXT_SG550" },
+	{ WEAPON_GALIL,		"#Cstrike_TitlesTXT_Galil" },
+	{ WEAPON_FAMAS,		"#Cstrike_TitlesTXT_Famas" },
+	{ WEAPON_USP,		"#Cstrike_TitlesTXT_USP45" },
+	{ WEAPON_AWP,		"#Cstrike_TitlesTXT_ArcticWarfareMagnum" },
+	{ WEAPON_MP5NAVY,	"#Cstrike_TitlesTXT_mp5navy" },
+	{ WEAPON_M249,		"#Cstrike_TitlesTXT_ESM249" },
+	{ WEAPON_M3,		"#Cstrike_TitlesTXT_Leone12" },
+	{ WEAPON_M4A1,		"#Cstrike_TitlesTXT_M4A1_Short" },
+	{ WEAPON_TMP,		"#Cstrike_TitlesTXT_tmp" },
+	{ WEAPON_G3SG1,		"#Cstrike_TitlesTXT_G3SG1" },
+	{ WEAPON_DEAGLE,	"#Cstrike_TitlesTXT_DesertEagle" },
+	{ WEAPON_SG552,		"#Cstrike_TitlesTXT_SG552" },
+	{ WEAPON_AK47,		"#Cstrike_TitlesTXT_AK47" },
+	{ WEAPON_P90,		"#Cstrike_TitlesTXT_ESC90" },
+	{ WEAPON_SHIELDGUN,	"#Cstrike_TitlesTXT_TactShield" },
+
+	{ WEAPON_NONE,		"#Cstrike_CurrentWeapon" }
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the display name for a weapon, based on it's weaponID
+ */
+const wchar_t* WeaponIDToDisplayName( CSWeaponID weaponID )
+{
+	for( int i=0; weaponDisplayNameInfo[i].displayName; ++i )
+		if ( weaponDisplayNameInfo[i].id == weaponID )
+			return g_pVGuiLocalize->Find( weaponDisplayNameInfo[i].displayName );
+
+	return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+BuyPresetWeapon::BuyPresetWeapon()
+{
+	m_name = NULL;
+	m_weaponID = WEAPON_NONE;
+	m_ammoType = AMMO_CLIPS;
+	m_ammoAmount = 0;
+	m_fillAmmo = true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+BuyPresetWeapon::BuyPresetWeapon( CSWeaponID weaponID )
+{
+	m_name = WeaponIDToDisplayName( weaponID );
+	m_weaponID = weaponID;
+	m_ammoType = AMMO_CLIPS;
+	m_ammoAmount = (weaponID == WEAPON_NONE) ? 0 : 1;
+	m_fillAmmo = true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+BuyPresetWeapon& BuyPresetWeapon::operator= (const BuyPresetWeapon& other)
+{
+	m_name = other.m_name;
+	m_weaponID = other.m_weaponID;
+	m_ammoType = other.m_ammoType;
+	m_ammoAmount = other.m_ammoAmount;
+	m_fillAmmo = other.m_fillAmmo;
+
+	return *this;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Sets the WEAPON_* weapon ID (and resets ammo, etc)
+ */
+void BuyPresetWeapon::SetWeaponID( CSWeaponID weaponID )
+{
+	m_name = WeaponIDToDisplayName( weaponID );
+	m_weaponID = weaponID;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the number of clips that will have to be bought for the specified BuyPresetWeapon
+ */
+int CalcClipsNeeded( const BuyPresetWeapon *pWeapon, const CCSWeaponInfo *pInfo, const int ammo[MAX_AMMO_TYPES] )
+{
+	if ( !pWeapon || !pInfo )
+		return 0;
+
+	int maxRounds = GetCSAmmoDef()->MaxCarry( pInfo->iAmmoType );
+	int buySize = GetCSAmmoDef()->GetBuySize( pInfo->iAmmoType );
+
+	int numClips = 0;
+	if ( buySize && pInfo->iAmmoType >= 0 )
+	{
+		switch ( pWeapon->GetAmmoType() )
+		{
+		case AMMO_CLIPS:
+			numClips = pWeapon->GetAmmoAmount();
+			if ( pWeapon->GetWeaponID() == WEAPON_NONE && numClips >= 4 )
+			{
+				numClips = ceil(maxRounds/(float)buySize);
+			}
+			numClips = MIN( ceil(maxRounds/(float)buySize), numClips );
+
+			numClips -= ammo[pInfo->iAmmoType]/buySize;
+			if ( numClips < 0 || ammo[pInfo->iAmmoType] == maxRounds )
+			{
+				numClips = 0;
+			}
+			break;
+		case AMMO_ROUNDS:
+			{
+				int roundsNeeded = pWeapon->GetAmmoAmount() - ammo[pInfo->iAmmoType];
+				if ( roundsNeeded > 0 )
+				{
+					numClips = ceil(roundsNeeded/(float)buySize);
+				}
+				else
+				{
+					numClips = 0;
+				}
+			}
+			break;
+		case AMMO_PERCENT:
+			{
+				int roundsNeeded = maxRounds*pWeapon->GetAmmoAmount() - ammo[pInfo->iAmmoType];
+				roundsNeeded *= 0.01f;
+				if ( roundsNeeded > 0 )
+				{
+					numClips = ceil(roundsNeeded/(float)buySize);
+				}
+				else
+				{
+					numClips = 0;
+				}
+			}
+			break;
+		}
+	}
+	return numClips;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns true if the client can currently buy the weapon according to class/gamemode restrictions.  Returns
+ *  true also if the player owns the weapon already.
+ */
+bool CanBuyWeapon( CSWeaponID currentPrimaryID, CSWeaponID currentSecondaryID, CSWeaponID weaponID )
+{
+	if ( currentPrimaryID == WEAPON_SHIELDGUN && weaponID == WEAPON_ELITE )
+	{
+		 return false;
+	}
+
+	if ( currentSecondaryID == WEAPON_ELITE && weaponID == WEAPON_SHIELDGUN )
+	{
+		 return false;
+	}
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( !pPlayer )
+		return false;
+
+	CCSWeaponInfo *info = GetWeaponInfo( weaponID );
+	if ( !info )
+		return false;
+
+	/// @TODO: assasination maps have a specific set of weapons that can be used in them.
+	if ( info->m_iTeam != TEAM_UNASSIGNED && pPlayer->GetTeamNumber() != info->m_iTeam )
+		return false;
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns true if the CSWeaponType is a primary class
+ */
+static bool IsPrimaryWeaponClassID( CSWeaponType classId )
+{
+	switch (classId)
+	{
+	case WEAPONTYPE_SUBMACHINEGUN:
+	case WEAPONTYPE_SHOTGUN:
+	case WEAPONTYPE_MACHINEGUN:
+	case WEAPONTYPE_RIFLE:
+	case WEAPONTYPE_SNIPER_RIFLE:
+		return true;
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns true if the weapon ID is for a primary weapon
+ */
+static bool IsPrimaryWeaponID( CSWeaponID id )
+{
+	if ( id == WEAPON_SHIELDGUN )
+		return true;
+
+	CCSWeaponInfo *info = GetWeaponInfo( id );
+	if ( !info )
+		return false;
+
+	return IsPrimaryWeaponClassID( info->m_WeaponType );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns true if the CSWeaponType is a secondary class
+ */
+static bool IsSecondaryWeaponClassID( CSWeaponType classId )
+{
+	return (classId == WEAPONTYPE_PISTOL);
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns true if the weapon ID is for a secondary weapon
+ */
+static bool IsSecondaryWeaponID( CSWeaponID id )
+{
+	if ( id == WEAPON_SHIELDGUN )
+		return false;
+
+	CCSWeaponInfo *info = GetWeaponInfo( id );
+	if ( !info )
+		return false;
+
+	return IsSecondaryWeaponClassID( info->m_WeaponType );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Fills the ammo array with the ammo currently owned by the local player
+ */
+void FillClientAmmo( int ammo[MAX_AMMO_TYPES] )
+{
+	int i;
+	for ( i=0; i<MAX_AMMO_TYPES; ++i )
+	{
+		ammo[i] = 0;
+	}
+
+	C_CSPlayer *localPlayer = CCSPlayer::GetLocalCSPlayer();
+	if ( !localPlayer )
+		return;
+
+	for ( i=0; i<WEAPON_MAX; ++i )
+	{
+		CSWeaponID gameWeaponID = (CSWeaponID)i;
+		if ( gameWeaponID == WEAPON_NONE || gameWeaponID >= WEAPON_SHIELDGUN )
+			continue;
+
+		const CCSWeaponInfo *info = GetWeaponInfo( gameWeaponID );
+		if ( !info )
+			continue;
+
+		int clientAmmoType = info->iAmmoType;
+		int clientAmmoCount = localPlayer->GetAmmoCount( clientAmmoType );
+		if ( clientAmmoCount > 0 )
+		{
+			ammo[ clientAmmoType ] = MAX( ammo[ clientAmmoType ], clientAmmoCount );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: returns the weapon in the specified slot
+//-----------------------------------------------------------------------------
+CWeaponCSBase *GetWeaponInSlot( int iSlot, int iSlotPos )
+{
+	C_CSPlayer *player = C_CSPlayer::GetLocalCSPlayer();
+	if ( !player )
+		return NULL;
+
+	for ( int i = 0; i < MAX_WEAPONS; i++ )
+	{
+		CWeaponCSBase *pWeapon = dynamic_cast< CWeaponCSBase * >(player->GetWeapon(i));
+		
+		if ( pWeapon == NULL )
+			continue;
+
+		if ( pWeapon->GetSlot() == iSlot && pWeapon->GetPosition() == iSlotPos )
+			return pWeapon;
+	}
+
+	return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the client's WEAPON_* value for the currently owned weapon, or WEAPON_NONE if no weapon is owned
+ */
+CSWeaponID GetClientWeaponID( bool primary )
+{
+	C_CSPlayer *localPlayer = CCSPlayer::GetLocalCSPlayer();
+	if ( !localPlayer )
+		return WEAPON_NONE;
+
+	int slot = (primary)?0:1;
+	CWeaponCSBase *pWeapon = GetWeaponInSlot( slot, slot );
+	if ( !pWeapon )
+		return WEAPON_NONE;
+
+	return pWeapon->GetWeaponID();
+}
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/client/cstrike/buy_presets/buy_presets.cpp b/game/client/cstrike/buy_presets/buy_presets.cpp
new file mode 100644
index 00000000..7badf8f2
--- /dev/null
+++ b/game/client/cstrike/buy_presets/buy_presets.cpp
@@ -0,0 +1,454 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#include "buy_preset_debug.h"
+#include "buy_presets.h"
+#include "weapon_csbase.h"
+#include "game/client/iviewport.h"
+#include "filesystem.h"
+#include <vgui/ILocalize.h>
+#include <vgui_controls/Controls.h>
+#include "c_cs_player.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+BuyPresetManager *TheBuyPresets = NULL;
+
+#if USE_BUY_PRESETS
+//--------------------------------------------------------------------------------------------------------------
+ConVar cl_buy_favorite_quiet( "cl_buy_favorite_quiet", "0", FCVAR_ARCHIVE | FCVAR_CLIENTCMD_CAN_EXECUTE, "Skips the prompt when saving a buy favorite in the buy menu" );
+ConVar cl_buy_favorite_nowarn( "cl_buy_favorite_nowarn", "0", FCVAR_ARCHIVE | FCVAR_CLIENTCMD_CAN_EXECUTE, "Skips the error prompt when saving an invalid buy favorite" );
+
+//--------------------------------------------------------------------------------------------------------------
+static void PrintBuyPresetUsage( void )
+{
+	if ( TheBuyPresets->GetNumPresets() )
+	{
+		Msg( "usage:  cl_buy_favorite <1...%d>\n", TheBuyPresets->GetNumPresets() );
+		for ( int i=0; i<TheBuyPresets->GetNumPresets(); ++i )
+		{
+			const BuyPreset *preset = TheBuyPresets->GetPreset( i );
+			if ( preset && preset->GetName() && preset->GetName()[0] )
+			{
+				char buffer[64];
+				g_pVGuiLocalize->ConvertUnicodeToANSI( preset->GetName(), buffer, sizeof( buffer ) );
+				Msg( " %d. %s\n", i+1, buffer );
+			}
+		}
+	}
+	else
+	{
+		Msg( "cl_buy_favorite: no favorites are defined\n" );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Callback function for handling the "cl_buy_favorite" command
+ */
+CON_COMMAND_F( cl_buy_favorite, "Purchase a favorite weapon/equipment loadout", FCVAR_CLIENTCMD_CAN_EXECUTE )
+{
+	if ( !engine->IsConnected() )
+		return;
+
+	if ( !TheBuyPresets )
+		TheBuyPresets = new BuyPresetManager();
+
+	if ( args.ArgC() != 2 )
+	{
+		PRESET_DEBUG( "cl_buy_favorite: no favorite specified\n" );
+		PrintBuyPresetUsage();
+		return;
+	}
+
+	int presetIndex = atoi( args[1] ) - 1;
+	if ( presetIndex < 0 || presetIndex >= TheBuyPresets->GetNumPresets() )
+	{
+		PRESET_DEBUG( "cl_buy_favorite: favorite %d doesn't exist\n", presetIndex );
+		PrintBuyPresetUsage();
+		return;
+	}
+
+	TheBuyPresets->PurchasePreset( presetIndex );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Callback function for handling the "cl_buy_favorite_set" command
+ */
+CON_COMMAND_F( cl_buy_favorite_set, "Saves the current loadout as a favorite", FCVAR_CLIENTCMD_CAN_EXECUTE )
+{
+	if ( !engine->IsConnected() )
+		return;
+
+	if ( !TheBuyPresets )
+		TheBuyPresets = new BuyPresetManager();
+
+	if ( args.ArgC() != 2 )
+	{
+		PRESET_DEBUG( "cl_buy_favorite_set: no favorite specified\n" );
+		PrintBuyPresetUsage();
+		return;
+	}
+
+	int presetIndex = atoi( args[ 1 ] ) - 1;
+	if ( presetIndex < 0 || presetIndex >= TheBuyPresets->GetNumPresets() )
+	{
+		PRESET_DEBUG( "cl_buy_favorite_set: favorite %d doesn't exist\n", presetIndex );
+		PrintBuyPresetUsage();
+		return;
+	}
+
+	const BuyPreset *preset = TheBuyPresets->GetPreset( presetIndex );
+	if ( !preset )
+	{
+		return;
+	}
+
+	WeaponSet ws;
+	TheBuyPresets->GetCurrentLoadout( &ws );
+	BuyPreset newPreset( *preset );
+	newPreset.ReplaceSet( 0, ws );
+
+	TheBuyPresets->SetPreset( presetIndex, &newPreset );
+	TheBuyPresets->Save();
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer )
+	{
+		pPlayer->EmitSound( "BuyPreset.Updated" );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Callback function for handling the "cl_buy_favorite_reset" command
+ */
+void __CmdFunc_BuyPresetsReset(void)
+{
+	if ( !engine->IsConnected() )
+		return;
+
+	if ( !TheBuyPresets )
+		TheBuyPresets = new BuyPresetManager();
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( !pPlayer || ( pPlayer->GetTeamNumber() != TEAM_CT && pPlayer->GetTeamNumber() != TEAM_TERRORIST ) )
+	{
+		return;
+	}
+
+	TheBuyPresets->ResetEditToDefaults();
+	TheBuyPresets->SetPresets( TheBuyPresets->GetEditPresets() );
+	TheBuyPresets->Save();
+}
+ConCommand cl_buy_favorite_reset( "cl_buy_favorite_reset", __CmdFunc_BuyPresetsReset, "Reset favorite loadouts to the default", FCVAR_CLIENTCMD_CAN_EXECUTE );
+#endif // USE_BUY_PRESETS
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Creates the BuyPresetManager singleton
+ */
+BuyPresetManager::BuyPresetManager()
+{
+	m_loadedTeam = TEAM_UNASSIGNED;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Resets the BuyPresetManager, loading BuyPresets from disk.  If no presets are defined, it loads the
+ *  default presets instead.
+ */
+void BuyPresetManager::VerifyLoadedTeam( void )
+{
+#if USE_BUY_PRESETS
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( !pPlayer )
+		return;
+
+	int playerTeam = pPlayer->GetTeamNumber();
+
+	if ( playerTeam == m_loadedTeam )
+		return;
+
+	if ( playerTeam != TEAM_CT && playerTeam != TEAM_TERRORIST )
+		return;
+
+	m_presets.RemoveAll();
+
+	const char *filename = "cfg/BuyPresets_TER.vdf";
+	if ( playerTeam == TEAM_CT )
+	{
+		filename = "cfg/BuyPresets_CT.vdf";
+	}
+
+	KeyValues *data;
+	KeyValues *presetKey;
+	data = new KeyValues( "Presets" );
+	bool fileExists = data->LoadFromFile( filesystem, filename, NULL );
+
+	presetKey = data->GetFirstSubKey();
+	while ( presetKey )
+	{
+		BuyPreset preset;
+		preset.Parse( presetKey );
+		m_presets.AddToTail(preset);
+
+		presetKey = presetKey->GetNextKey();
+	}
+
+	if ( !m_presets.Count() )
+	{
+		const char *filename = "cfg/BuyPresetsDefault_TER.vdf";
+		if ( playerTeam == TEAM_CT )
+		{
+			filename = "cfg/BuyPresetsDefault_CT.vdf";
+		}
+
+		KeyValues *data;
+		KeyValues *presetKey;
+		data = new KeyValues( "Presets" );
+		data->LoadFromFile( filesystem, filename, NULL );
+
+		presetKey = data->GetFirstSubKey();
+		while ( presetKey )
+		{
+			BuyPreset preset;
+			preset.Parse( presetKey );
+			m_presets.AddToTail(preset);
+
+			presetKey = presetKey->GetNextKey();
+		}
+
+		data->deleteThis();
+	}
+
+	// Guarantee we have at least this many presets, even if they are blank
+	while ( m_presets.Count() < NUM_PRESETS )
+	{
+		BuyPreset preset;
+		m_presets.AddToTail(preset);
+	}
+
+	data->deleteThis();
+	m_editPresets = m_presets;
+
+	if ( !fileExists )
+		Save();
+#endif // USE_BUY_PRESETS
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Loads the default presets into the editing presets (e.g. when hitting the "Use Defaults" button)
+ */
+void BuyPresetManager::ResetEditToDefaults( void )
+{
+#if USE_BUY_PRESETS
+	VerifyLoadedTeam();
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( !pPlayer )
+		return;
+
+	int playerTeam = pPlayer->GetTeamNumber();
+
+	if ( playerTeam != TEAM_CT && playerTeam != TEAM_TERRORIST )
+		return;
+
+	m_editPresets.RemoveAll();
+
+	const char *filename = "cfg/BuyPresetsDefault_TER.vdf";
+	if ( playerTeam == TEAM_CT )
+	{
+		filename = "cfg/BuyPresetsDefault_CT.vdf";
+	}
+
+	KeyValues *data;
+	KeyValues *presetKey;
+	data = new KeyValues( "Presets" );
+	data->LoadFromFile( filesystem, filename, NULL );
+
+	presetKey = data->GetFirstSubKey();
+	while ( presetKey )
+	{
+		BuyPreset preset;
+		preset.Parse( presetKey );
+		m_editPresets.AddToTail(preset);
+
+		presetKey = presetKey->GetNextKey();
+	}
+
+	data->deleteThis();
+#endif // USE_BUY_PRESETS
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Saves the current BuyPresets to disk
+ */
+void BuyPresetManager::Save()
+{
+#if USE_BUY_PRESETS
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( !pPlayer )
+		return;
+
+	const char *filename = "cfg/BuyPresets_TER.vdf";
+	switch ( pPlayer->GetTeamNumber() )
+	{
+	case TEAM_CT:
+		filename = "cfg/BuyPresets_CT.vdf";
+		break;
+	case TEAM_TERRORIST:
+		filename = "cfg/BuyPresets_TER.vdf";
+		break;
+	default:
+		return; // don't bother saving presets unless we're on a team
+	}
+
+	KeyValues *data = new KeyValues( "Presets" );
+	for( int i=0; i<m_presets.Count(); ++i )
+	{
+		m_presets[i].Save( data );
+	}
+	data->SaveToFile( filesystem, filename, NULL );
+	data->deleteThis();
+#endif // USE_BUY_PRESETS
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the specified "live" preset, or NULL if it doesn't exist
+ */
+const BuyPreset * BuyPresetManager::GetPreset( int index ) const
+{
+	if ( index < 0 || index >= m_presets.Count() )
+	{
+		return NULL;
+	}
+
+	return &(m_presets[index]);
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void BuyPresetManager::SetPreset( int index, const BuyPreset *preset )
+{
+	if ( index < 0 || index >= m_presets.Count() || !preset )
+	{
+		return;
+	}
+
+	m_presets[index] = *preset;
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the specified editing preset, or NULL if it doesn't exist
+ */
+BuyPreset * BuyPresetManager::GetEditPreset( int index )
+{
+	if ( index < 0 || index >= m_editPresets.Count() )
+	{
+		return NULL;
+	}
+
+	return &(m_editPresets[index]);
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Generates and sends buy commands to buy a specific preset
+ */
+void BuyPresetManager::PurchasePreset( int presetIndex )
+{
+	if ( presetIndex >= 0 && presetIndex < m_presets.Count() )
+	{
+		const BuyPreset *preset = &(m_presets[presetIndex]);
+
+		int setIndex;
+		for ( setIndex = 0; setIndex < preset->GetNumSets(); ++setIndex )
+		{
+			// Try to buy this weapon set.
+			const WeaponSet *itemSet = preset->GetSet( setIndex );
+			if ( itemSet )
+			{
+				int currentCost;
+				WeaponSet currentSet;
+				itemSet->GetCurrent( currentCost, currentSet );
+				if ( currentCost > 0 )
+				{
+					PRESET_DEBUG( "cl_buy_favorite: buying %ls for a total of $%d.\n",
+						preset->GetName(),
+						currentCost );
+					char buf[BUY_PRESET_COMMAND_LEN];
+					currentSet.GenerateBuyCommands( buf );
+
+					// Send completed string
+					PRESET_DEBUG( "%s\n", buf );
+					engine->ClientCmd( buf );
+					return;
+				}
+				else if ( currentCost == 0 )
+				{
+					C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+					if ( pPlayer )
+					{
+						pPlayer->EmitSound( "BuyPreset.AlreadyBought" );
+					}
+
+					// We have everything already.  Let the player know.
+					if ( setIndex == 0 )
+					{
+						PRESET_DEBUG( "cl_buy_favorite: already have a complete %ls set.\n", preset->GetName() );
+					}
+					else
+					{
+						PRESET_DEBUG( "cl_buy_favorite: can't afford anything better from %ls.\n", preset->GetName() );
+					}
+					return;
+				}
+			}
+		}
+
+		C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+		if ( pPlayer )
+		{
+			pPlayer->EmitSound( "BuyPreset.CantBuy" );
+		}
+
+		PRESET_DEBUG( "cl_buy_favorite: can't afford anything better from %ls.\n", preset->GetName() );
+		return;
+	}
+
+	// We failed to buy anything.  Let the player know.
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer )
+	{
+		pPlayer->EmitSound( "BuyPreset.CantBuy" );
+	}
+
+	PRESET_DEBUG( "cl_buy_favorite: preset %d doesn't exist.\n", presetIndex );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/client/cstrike/buy_presets/buy_presets.h b/game/client/cstrike/buy_presets/buy_presets.h
new file mode 100644
index 00000000..086e6baa
--- /dev/null
+++ b/game/client/cstrike/buy_presets/buy_presets.h
@@ -0,0 +1,276 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef BUY_PRESETS_H
+#define BUY_PRESETS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define USE_BUY_PRESETS 1
+
+/**
+ * CLASS STRUCTURE:
+ *  Buy presets are managed by TheBuyPresetManager, which has a list of BuyPreset objects.
+ *  Each BuyPreset has a list of fallback WeaponSets.  Each WeaponSet is a complete set of
+ *  weapons and equipment that could be purchased by a buy preset.
+ *
+ * BUYING:
+ *  When purchasing a buy preset, the fallback WeaponSets are considered in order from first
+ *  to last.  When one is deemed to be purchasable, the buy commands are generated and
+ *  processing stops.
+ *
+ * EDITING:
+ *  When editing buy presets, TheBuyPresetManager maintains a second list of BuyPresets, to
+ *  allow an all-or-nothing undo system.  The editing is done on two main VGUI menus: a
+ *  list of the four main buy presets (CBuyPresetEditMainMenu), and a menu showing the
+ *  fallbacks for a single preset (CBuyPresetEditOutfitListMenu).
+ *
+ *  Presets and fallbacks can be copied, created, deleted, etc from these pages.  From the
+ *  fallback menu, a wizard can edit the contents of a fallback, specifying primary weapon,
+ *  pistol, and equipment.
+ */
+
+#include "weapon_csbase.h"
+#include <KeyValues.h>
+#include <utlvector.h>
+
+class BuyPreset;
+class CCSWeaponInfo;
+
+//--------------------------------------------------------------------------------------------------------------
+enum BuyPresetStringSizes
+{
+	BUY_PRESET_COMMAND_LEN = 256,
+	MaxBuyPresetName = 64,
+	MaxBuyPresetImageFname = 64,
+};
+
+enum AmmoSizeType
+{
+	AMMO_PERCENT,
+	AMMO_CLIPS,
+	AMMO_ROUNDS
+};
+
+enum { NUM_PRESETS = 4 };
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  A BuyPresetWeapon stores the mp.dll version of the WeaponID, the increment for buying ammo (clips, rounds, etc),
+ *  the number of increments to buy, etc.  This is the basic info for buying a weapon that is present in an
+ *  item set.
+ */
+class BuyPresetWeapon
+{
+public:
+	BuyPresetWeapon();
+	BuyPresetWeapon( CSWeaponID weaponID );
+	BuyPresetWeapon& operator= (const BuyPresetWeapon& other);
+
+	const wchar_t*	GetName() const { return m_name; }				///< Returns the display name corresponding to the weapon ID
+	CSWeaponID		GetWeaponID() const { return m_weaponID; }		///< Returns the WEAPON_* weapon ID
+	void			SetWeaponID( CSWeaponID weaponID );				///< Sets the WEAPON_* weapon ID (and resets ammo, etc)
+
+	void			SetAmmoType( AmmoSizeType ammoType ) { m_ammoType = ammoType; }	///< Sets the ammo type - percent (unused), clips, or rounds (unused)
+	void			SetAmmoAmount( int ammoAmount ) { m_ammoAmount = ammoAmount; }	///< Sets the amount of ammo, in units relevant to the ammo type
+	void			SetFillAmmo( bool fill ) { m_fillAmmo = fill; }	///< Sets whether the weapon's ammo should be topped off
+
+	AmmoSizeType	GetAmmoType() const { return m_ammoType; }		///< Returns ammo type - percent (unused), clips, or rounds (unused)
+	int				GetAmmoAmount() const { return m_ammoAmount; }	///< Returns the amount of ammo, in units relevant to the ammo type
+	bool			GetFillAmmo() const { return m_fillAmmo; }		///< Returns true if the weapon's ammo should be topped off
+
+protected:
+	const wchar_t	*m_name;
+	CSWeaponID		m_weaponID;
+	AmmoSizeType	m_ammoType;
+	int				m_ammoAmount;
+	bool			m_fillAmmo;
+};
+
+typedef CUtlVector< BuyPresetWeapon > BuyPresetWeaponList;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  A WeaponSet is part of a buy preset.  Each buy preset is composed of a series of (fallback) WeaponSets.
+ *  The WeaponSet contains a snapshot of a set of weapons and equipment that should be bought.
+ */
+class WeaponSet
+{
+public:
+	WeaponSet();
+
+	void GetCurrent( int& cost, WeaponSet& ws ) const;								///< Generates a WeaponSet containing only items that would be bought right now
+	void GetFromScratch( int& cost, WeaponSet& ws ) const;							///< Generates a WeaponSet containing everything that would be bought from scratch
+
+	void GenerateBuyCommands( char command[BUY_PRESET_COMMAND_LEN] ) const;			///< Generates a list of commands to buy the current WeaponSet.
+
+	int FullCost() const;															///< Calculates the full cost of the WeaponSet, including all optional items
+
+	void Reset( void );
+
+	const BuyPresetWeapon& GetPrimaryWeapon() const { return m_primaryWeapon; }
+	const BuyPresetWeapon& GetSecondaryWeapon() const { return m_secondaryWeapon; }
+
+	BuyPresetWeapon m_primaryWeapon;
+	BuyPresetWeapon m_secondaryWeapon;
+
+	// Equipment --------------------------------
+	int		m_armor;
+	bool	m_helmet;
+	bool	m_smokeGrenade;
+	bool	m_HEGrenade;
+	int		m_flashbangs;
+	bool	m_defuser;
+	bool	m_nightvision;
+};
+
+typedef CUtlVector< WeaponSet > WeaponSetList;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  The BuyPreset is a complete representation of a buy preset.  Essentially, it consists of the preset name,
+ *  whether or not the preset is used for autobuy, and a list of fallback WeaponSets.
+ */
+class BuyPreset
+{
+public:
+	BuyPreset();
+	~BuyPreset();
+	BuyPreset(const BuyPreset& other);
+
+	void SetName( const wchar_t *name );
+	const wchar_t * GetName() const { return m_name; }
+
+	void Parse( KeyValues *data );								///< Populates data from a KeyValues structure, for loading
+	void Save( KeyValues *data );								///< Fills in a KeyValues structure with data, for saving
+
+	int GetNumSets() const { return m_weaponList.Count(); }		///< Returns the number of fallback WeaponSets
+	const WeaponSet * GetSet( int index ) const;				///< Returns the specified fallback WeaponSet, or NULL if it doesn't exist
+
+	int FullCost() const;										///< Calculates the full cost of the preset, which is exactly the full cost of the first fallback WeaponSet
+
+	// editing functions --------------------
+	void DeleteSet( int index );								///< Deletes a fallback
+	void SwapSet( int firstIndex, int secondIndex );			///< Switches the order of two fallbacks
+	void ReplaceSet( int index, const WeaponSet& weaponSet );	///< Replaces a fallback with the supplied WeaponSet
+
+private:
+	wchar_t m_name[MaxBuyPresetName];
+
+	WeaponSetList m_weaponList;
+};
+
+typedef CUtlVector< BuyPreset > BuyPresetList;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  The BuyPresetManager singleton manages saving/loading/buying the individual BuyPresets.  It also tracks the
+ *  ownership of some items that aren't explicitly known by the client (defuser, nightvision).
+ *
+ *  Two sets of BuyPresets are maintained - the live set used for purchasing, and a set that is acted upon for
+ *  editing.  This provides the basic save changes/abandon changes ability when editing presets.
+ */
+class BuyPresetManager
+{
+public:
+	BuyPresetManager();
+
+	void Save();
+
+	void PurchasePreset( int presetIndex );							///< Generates and sends buy commands to buy a specific preset
+
+	int GetNumPresets() { VerifyLoadedTeam(); return m_presets.Count(); }
+	const BuyPreset * GetPreset( int index ) const;					///< Returns the specified "live" preset, or NULL if it doesn't exist
+	void SetPreset( int index, const BuyPreset *preset );
+
+	void SetPresets( const BuyPresetList& presets ) { m_presets = presets; }
+
+	void SetEditPresets( const BuyPresetList& presets ) { m_editPresets = presets; }
+	int GetNumEditPresets() const { return m_editPresets.Count(); }
+
+	BuyPreset * GetEditPreset( int index );							///< Returns the specified editing preset, or NULL if it doesn't exist
+	const CUtlVector< BuyPreset >& GetEditPresets() const { return m_editPresets; }
+
+	void ResetEditPresets() { m_editPresets = m_presets; }			///< Resets the editing presets to the live presets (e.g. when starting editing)
+	void ResetEditToDefaults( void );							///< Loads the default presets into the editing presets (e.g. when hitting the "Use Defaults" button)
+
+	void GetCurrentLoadout( WeaponSet *weaponSet );
+
+private:
+	BuyPresetList	m_presets;		///< Current (live) presets
+	BuyPresetList	m_editPresets;	///< BuyPresets used when editing
+
+	int m_loadedTeam;
+	void VerifyLoadedTeam( void );
+};
+
+//--------------------------------------------------------------------------------------------------------------
+extern BuyPresetManager *TheBuyPresets;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Functions for controlling the display of the various buy preset editing menus.  Opening one closes any
+ *  others open.
+ */
+enum { REOPEN_YES, REOPEN_NO, REOPEN_DONTCHANGE };					///< Determines if we need to re-open the buy menu when done editing.
+void ShowBuyPresetMainMenu( bool runUpdate, int reopenBuyMenu );	///< Open the main preset editing menu
+void ShowBuyPresetEditMenu( int presetIndex );						///< Open the menu for editing the list of fallbacks for an individual preset
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the image filename for a given WEAPON_* weapon ID.  Primary is specified because WEAPON_NONE returns
+ *  separate images for primary and pistol, to facilitate showing an outline version for "Current Weapon".
+ */
+const char *ImageFnameFromWeaponID( CSWeaponID weaponID, bool isPrimary );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Constructs a list of weapons that will satisfy the any unfinished weapon-specific career tasks:
+ *   1.  If there are no unfinished career tasks, the source list is returned
+ *   2.  If there are unfinished career tasks, all weapons that can be used for the tasks are added
+ *       to the front of the list.  This list of career weapons is sorted according to the order of
+ *       weapons in the source list, so that if any weapons in the source list can be used for career
+ *       tasks, they will be.
+ */
+BuyPresetWeaponList CareerWeaponList( const BuyPresetWeaponList& source, bool isPrimary, CSWeaponID currentClientID );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the number of clips that will have to be bought for the specified BuyPresetWeapon
+ */
+class CCSWeaponInfo;
+int CalcClipsNeeded( const BuyPresetWeapon *pWeapon, const CCSWeaponInfo *pInfo, const int ammo[MAX_AMMO_TYPES] );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Fills the ammo array with the ammo currently owned by the local player
+ */
+void FillClientAmmo( int ammo[MAX_AMMO_TYPES] );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns true if the client can currently buy the weapon according to class/gamemode restrictions.  Returns
+ *  true also if the player owns the weapon already.
+ */
+bool CanBuyWeapon( CSWeaponID currentPrimaryID, CSWeaponID currentSecondaryID, CSWeaponID weaponID );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Returns the display name for a weapon, based on it's weaponID
+ */
+const wchar_t* WeaponIDToDisplayName( CSWeaponID weaponID );
+
+//--------------------------------------------------------------------------------------------------------------
+// If our weapon is NONE, we want to be able to buy up to this many clips for the current gun we're holding
+enum { NUM_CLIPS_FOR_CURRENT = 4 };
+
+#if USE_BUY_PRESETS
+extern ConVar cl_buy_favorite_quiet;
+extern ConVar cl_buy_favorite_nowarn;
+#endif // USE_BUY_PRESETS
+
+#endif // BUY_PRESETS_H
diff --git a/game/client/cstrike/c_cs_hostage.cpp b/game/client/cstrike/c_cs_hostage.cpp
new file mode 100644
index 00000000..afbfe773
--- /dev/null
+++ b/game/client/cstrike/c_cs_hostage.cpp
@@ -0,0 +1,518 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client side C_CHostage class
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_cs_hostage.h"
+#include <bitbuf.h>
+#include "ragdoll_shared.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+#undef CHostage
+
+//-----------------------------------------------------------------------------
+
+static float HOSTAGE_HEAD_TURN_RATE = 130;
+
+
+CUtlVector< C_CHostage* > g_Hostages;
+CUtlVector< EHANDLE > g_HostageRagdolls;
+
+extern ConVar g_ragdoll_fadespeed;
+
+//-----------------------------------------------------------------------------
+const int NumInterestingPoseParameters = 6;
+static const char* InterestingPoseParameters[NumInterestingPoseParameters] =
+{
+	"body_yaw",
+	"spine_yaw",
+	"neck_trans",
+	"head_pitch",
+	"head_yaw",
+	"head_roll"
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+class C_LowViolenceHostageDeathModel : public C_BaseAnimating
+{
+public:
+	DECLARE_CLASS( C_LowViolenceHostageDeathModel, C_BaseAnimating );
+	
+	C_LowViolenceHostageDeathModel();
+	~C_LowViolenceHostageDeathModel();
+
+	bool SetupLowViolenceModel( C_CHostage *pHostage );
+
+	// fading out
+	void ClientThink( void );
+
+private:
+
+	void Interp_Copy( VarMapping_t *pDest, CBaseEntity *pSourceEntity, VarMapping_t *pSrc );
+
+	float m_flFadeOutStart;
+};
+
+//-----------------------------------------------------------------------------
+C_LowViolenceHostageDeathModel::C_LowViolenceHostageDeathModel()
+{
+}
+
+//-----------------------------------------------------------------------------
+C_LowViolenceHostageDeathModel::~C_LowViolenceHostageDeathModel()
+{
+}
+
+//-----------------------------------------------------------------------------
+void C_LowViolenceHostageDeathModel::Interp_Copy( VarMapping_t *pDest, CBaseEntity *pSourceEntity, VarMapping_t *pSrc )
+{
+	if ( !pDest || !pSrc )
+		return;
+
+	if ( pDest->m_Entries.Count() != pSrc->m_Entries.Count() )
+	{
+		Assert( false );
+		return;
+	}
+
+	int c = pDest->m_Entries.Count();
+	for ( int i = 0; i < c; i++ )
+	{
+		pDest->m_Entries[ i ].watcher->Copy( pSrc->m_Entries[i].watcher );
+	}
+}
+
+//-----------------------------------------------------------------------------
+bool C_LowViolenceHostageDeathModel::SetupLowViolenceModel( C_CHostage *pHostage )
+{
+	const model_t *model = pHostage->GetModel();
+	const char *pModelName = modelinfo->GetModelName( model );
+	if ( InitializeAsClientEntity( pModelName, RENDER_GROUP_OPAQUE_ENTITY ) == false )
+	{
+		Release();
+		return false;
+	}
+
+	// Play the low-violence death anim
+	if ( LookupSequence( "death1" ) == -1 )
+	{
+		Release();
+		return false;
+	}
+
+	m_flFadeOutStart = gpGlobals->curtime + 5.0f;
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+
+	SetSequence( LookupSequence( "death1" ) );
+	ForceClientSideAnimationOn();
+
+	if ( pHostage && !pHostage->IsDormant() )
+	{
+		SetNetworkOrigin( pHostage->GetAbsOrigin() );
+		SetAbsOrigin( pHostage->GetAbsOrigin() );
+		SetAbsVelocity( pHostage->GetAbsVelocity() );
+
+		// move my current model instance to the ragdoll's so decals are preserved.
+		pHostage->SnatchModelInstance( this );
+
+		SetAbsAngles( pHostage->GetRenderAngles() );
+		SetNetworkAngles( pHostage->GetRenderAngles() );
+
+		CStudioHdr *pStudioHdr = GetModelPtr();
+
+		// update pose parameters
+		float poseParameter[MAXSTUDIOPOSEPARAM];
+		GetPoseParameters( pStudioHdr, poseParameter );
+		for ( int i=0; i<NumInterestingPoseParameters; ++i )
+		{
+			int poseParameterIndex = LookupPoseParameter( pStudioHdr, InterestingPoseParameters[i] );
+			SetPoseParameter( pStudioHdr, poseParameterIndex, poseParameter[poseParameterIndex] );
+		}
+	}
+
+	Interp_Reset( GetVarMapping() );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+void C_LowViolenceHostageDeathModel::ClientThink( void )
+{
+	if ( m_flFadeOutStart > gpGlobals->curtime )
+	{
+		 return;
+	}
+
+	int iAlpha = GetRenderColor().a;
+
+	iAlpha = MAX( iAlpha - ( g_ragdoll_fadespeed.GetInt() * gpGlobals->frametime ), 0 );
+
+	SetRenderMode( kRenderTransAlpha );
+	SetRenderColorA( iAlpha );
+
+	if ( iAlpha == 0 )
+	{
+		Release();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_CHostage::RecvProxy_Rescued( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	C_CHostage *pHostage= (C_CHostage *) pStruct;
+	
+	bool isRescued = pData->m_Value.m_Int != 0;
+
+	if ( isRescued && !pHostage->m_isRescued )
+	{
+		// hostage was rescued
+		pHostage->m_flDeadOrRescuedTime = gpGlobals->curtime + 2;
+		pHostage->SetRenderMode( kRenderGlow );
+		pHostage->SetNextClientThink( gpGlobals->curtime );
+	}
+
+	pHostage->m_isRescued = isRescued;
+}
+
+//-----------------------------------------------------------------------------
+IMPLEMENT_CLIENTCLASS_DT(C_CHostage, DT_CHostage, CHostage)
+	
+	RecvPropInt( RECVINFO( m_isRescued ), 0, C_CHostage::RecvProxy_Rescued ),
+	RecvPropInt( RECVINFO( m_iHealth ) ),
+	RecvPropInt( RECVINFO( m_iMaxHealth ) ),
+	RecvPropInt( RECVINFO( m_lifeState ) ),
+	
+	RecvPropEHandle( RECVINFO( m_leader ) ),
+
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_CHostage::C_CHostage()
+{
+	g_Hostages.AddToTail( this );
+
+	m_flDeadOrRescuedTime = 0.0;
+	m_flLastBodyYaw = 0;
+	m_createdLowViolenceRagdoll = false;
+	
+	// TODO: Get IK working on the steep slopes CS has, then enable it on characters.
+	m_EntClientFlags |= ENTCLIENTFLAG_DONTUSEIK;
+
+	// set the model so the PlayerAnimState uses the Hostage activities/sequences
+	SetModelName( "models/Characters/Hostage_01.mdl" );
+
+	m_PlayerAnimState = CreateHostageAnimState( this, this, LEGANIM_8WAY, false );
+	
+	m_leader = NULL;
+	m_blinkTimer.Invalidate();
+	m_seq = -1;
+
+	m_flCurrentHeadPitch = 0;
+	m_flCurrentHeadYaw = 0;
+
+	m_eyeAttachment = -1;
+	m_chestAttachment = -1;
+	m_headYawPoseParam = -1;
+	m_headPitchPoseParam = -1;
+	m_lookAt = Vector( 0, 0, 0 );
+	m_isInit = false;
+	m_lookAroundTimer.Invalidate();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_CHostage::~C_CHostage()
+{
+	g_Hostages.FindAndRemove( this );
+	m_PlayerAnimState->Release();
+}
+
+//-----------------------------------------------------------------------------
+void C_CHostage::Spawn( void )
+{
+	m_leader = NULL;
+	m_blinkTimer.Invalidate();
+}
+
+//-----------------------------------------------------------------------------
+bool C_CHostage::ShouldDraw( void )
+{
+	if ( m_createdLowViolenceRagdoll )
+		return false;
+
+	return BaseClass::ShouldDraw();
+}
+
+//-----------------------------------------------------------------------------
+C_BaseAnimating * C_CHostage::BecomeRagdollOnClient()
+{
+	if ( g_RagdollLVManager.IsLowViolence() )
+	{
+		// We can't just play the low-violence anim ourselves, since we're about to be deleted by the server.
+		// So, let's create another entity that can play the anim and stick around.
+		C_LowViolenceHostageDeathModel *pLowViolenceModel = new C_LowViolenceHostageDeathModel();
+		m_createdLowViolenceRagdoll = pLowViolenceModel->SetupLowViolenceModel( this );
+		if ( m_createdLowViolenceRagdoll )
+		{
+			UpdateVisibility();
+			g_HostageRagdolls.AddToTail( pLowViolenceModel );
+			return pLowViolenceModel;
+		}
+		else
+		{
+			// if we don't have a low-violence death anim, don't create a ragdoll.
+			return NULL;
+		}
+	}
+
+	C_BaseAnimating *pRagdoll = BaseClass::BecomeRagdollOnClient();
+	if ( pRagdoll && pRagdoll != this )
+	{
+		g_HostageRagdolls.AddToTail( pRagdoll );
+	}
+	return pRagdoll;
+}
+
+//-----------------------------------------------------------------------------
+/** 
+ * Set up attachment and pose param indices.
+ * We can't do this in the constructor or Spawn() because the data isn't 
+ * there yet.
+ */
+void C_CHostage::Initialize( )
+{
+	m_eyeAttachment = LookupAttachment( "eyes" );
+	m_chestAttachment = LookupAttachment( "chest" );
+
+	m_headYawPoseParam = LookupPoseParameter( "head_yaw" );
+	GetPoseParameterRange( m_headYawPoseParam, m_headYawMin, m_headYawMax );
+
+	m_headPitchPoseParam = LookupPoseParameter( "head_pitch" );
+	GetPoseParameterRange( m_headPitchPoseParam, m_headPitchMin, m_headPitchMax );
+
+	m_bodyYawPoseParam = LookupPoseParameter( "body_yaw" );
+	GetPoseParameterRange( m_bodyYawPoseParam, m_bodyYawMin, m_bodyYawMax );
+
+	Vector pos;
+	QAngle angles;
+
+	if (!GetAttachment( m_eyeAttachment, pos, angles ))
+	{
+		m_vecViewOffset = Vector( 0, 0, 50.0f );
+	}
+	else
+	{
+		m_vecViewOffset = pos - GetAbsOrigin();
+	}
+
+
+	if (!GetAttachment( m_chestAttachment, pos, angles ))
+	{
+		m_lookAt = Vector( 0, 0, 0 );
+	}
+	else
+	{
+		Vector forward;
+		AngleVectors( angles, &forward );
+		m_lookAt = EyePosition() + 100.0f * forward;
+	}
+}
+
+//-----------------------------------------------------------------------------
+CWeaponCSBase* C_CHostage::CSAnim_GetActiveWeapon()
+{
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+bool C_CHostage::CSAnim_CanMove()
+{
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+/**
+ * Orient head and eyes towards m_lookAt.
+ */
+void C_CHostage::UpdateLookAt( CStudioHdr *pStudioHdr )
+{
+	if (!m_isInit)
+	{
+		m_isInit = true;
+		Initialize( );
+	}
+
+	// head yaw
+	if (m_headYawPoseParam < 0 || m_bodyYawPoseParam < 0 || m_headPitchPoseParam < 0)
+		return;
+
+	if (GetLeader())
+	{
+		m_lookAt = GetLeader()->EyePosition();
+	}
+	
+	// orient eyes
+	m_viewtarget = m_lookAt;
+
+	// blinking
+	if (m_blinkTimer.IsElapsed())
+	{
+		m_blinktoggle = !m_blinktoggle;
+		m_blinkTimer.Start( RandomFloat( 1.5f, 4.0f ) );
+	}
+
+	// Figure out where we want to look in world space.
+	QAngle desiredAngles;
+	Vector to = m_lookAt - EyePosition();
+	VectorAngles( to, desiredAngles );
+
+	// Figure out where our body is facing in world space.
+	float poseParams[MAXSTUDIOPOSEPARAM];
+	GetPoseParameters( pStudioHdr, poseParams );
+	QAngle bodyAngles( 0, 0, 0 );
+	bodyAngles[YAW] = GetRenderAngles()[YAW] + RemapVal( poseParams[m_bodyYawPoseParam], 0, 1, m_bodyYawMin, m_bodyYawMax );
+
+
+	float flBodyYawDiff = bodyAngles[YAW] - m_flLastBodyYaw;
+	m_flLastBodyYaw = bodyAngles[YAW];
+	
+
+	// Set the head's yaw.
+	float desired = AngleNormalize( desiredAngles[YAW] - bodyAngles[YAW] );
+	desired = clamp( desired, m_headYawMin, m_headYawMax );
+	m_flCurrentHeadYaw = ApproachAngle( desired, m_flCurrentHeadYaw, HOSTAGE_HEAD_TURN_RATE * gpGlobals->frametime );
+
+	// Counterrotate the head from the body rotation so it doesn't rotate past its target.
+	m_flCurrentHeadYaw = AngleNormalize( m_flCurrentHeadYaw - flBodyYawDiff );
+	desired = clamp( desired, m_headYawMin, m_headYawMax );
+	
+	SetPoseParameter( pStudioHdr, m_headYawPoseParam, m_flCurrentHeadYaw );
+
+	
+	// Set the head's yaw.
+	desired = AngleNormalize( desiredAngles[PITCH] );
+	desired = clamp( desired, m_headPitchMin, m_headPitchMax );
+	
+	m_flCurrentHeadPitch = ApproachAngle( desired, m_flCurrentHeadPitch, HOSTAGE_HEAD_TURN_RATE * gpGlobals->frametime );
+	m_flCurrentHeadPitch = AngleNormalize( m_flCurrentHeadPitch );
+	SetPoseParameter( pStudioHdr, m_headPitchPoseParam, m_flCurrentHeadPitch );
+
+	SetPoseParameter( pStudioHdr, "head_roll", 0.0f );
+}
+
+
+//-----------------------------------------------------------------------------
+/**
+ * Look around at various interesting things
+ */
+void C_CHostage::LookAround( void )
+{
+	if (GetLeader() == NULL && m_lookAroundTimer.IsElapsed())
+	{
+		m_lookAroundTimer.Start( RandomFloat( 3.0f, 15.0f ) );
+
+		Vector forward;
+		QAngle angles = GetAbsAngles();
+		angles[ YAW ] += RandomFloat( m_headYawMin, m_headYawMax );
+		angles[ PITCH ] += RandomFloat( m_headPitchMin, m_headPitchMax );
+		AngleVectors( angles, &forward );
+		m_lookAt = EyePosition() + 100.0f * forward;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void C_CHostage::UpdateClientSideAnimation()
+{
+	if (IsDormant())
+	{
+		return;
+	}
+
+	m_PlayerAnimState->Update( GetAbsAngles()[YAW], GetAbsAngles()[PITCH] );
+
+	// initialize pose parameters
+	char *setToZero[] =
+	{
+		"spine_yaw",
+		"head_roll"
+	};
+	CStudioHdr *pStudioHdr = GetModelPtr();
+	for ( int i=0; i < ARRAYSIZE( setToZero ); i++ )
+	{
+		int index = LookupPoseParameter( pStudioHdr, setToZero[i] );
+		if ( index >= 0 )
+			SetPoseParameter( pStudioHdr, index, 0 );
+	}
+
+	// orient head and eyes
+	LookAround();
+	UpdateLookAt( pStudioHdr );
+
+
+	BaseClass::UpdateClientSideAnimation();
+}
+
+//-----------------------------------------------------------------------------
+void C_CHostage::ClientThink()
+{
+	C_BaseCombatCharacter::ClientThink();
+
+	int speed = 2;
+	int a = m_clrRender->a;
+
+	a = MAX( 0, a - speed );
+
+	SetRenderColorA( a );
+
+	if ( m_clrRender->a > 0 )
+	{
+		SetNextClientThink( gpGlobals->curtime + 0.001 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+bool C_CHostage::WasRecentlyKilledOrRescued( void )
+{
+	return ( gpGlobals->curtime < m_flDeadOrRescuedTime );
+}
+
+//-----------------------------------------------------------------------------
+void C_CHostage::OnPreDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnPreDataChanged( updateType );
+
+	m_OldLifestate = m_lifeState;
+}
+
+//-----------------------------------------------------------------------------
+void C_CHostage::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( m_OldLifestate != m_lifeState )
+	{
+		if( m_lifeState == LIFE_DEAD || m_lifeState == LIFE_DYING )
+			m_flDeadOrRescuedTime = gpGlobals->curtime + 2;
+	}
+}
+
+//-----------------------------------------------------------------------------
+void C_CHostage::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
+{
+	static ConVar *violence_hblood = cvar->FindVar( "violence_hblood" );
+	if ( violence_hblood && !violence_hblood->GetBool() )
+		return;
+
+	BaseClass::ImpactTrace( pTrace, iDamageType, pCustomImpactName );
+}
+
diff --git a/game/client/cstrike/c_cs_hostage.h b/game/client/cstrike/c_cs_hostage.h
new file mode 100644
index 00000000..35ba2f97
--- /dev/null
+++ b/game/client/cstrike/c_cs_hostage.h
@@ -0,0 +1,123 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client side CHostage class
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_CHOSTAGE_H
+#define C_CHOSTAGE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_ai_basenpc.h"
+#include "utlvector.h"
+#include "util_shared.h"
+#include "cs_playeranimstate.h"
+#include "c_cs_player.h"
+
+
+// for shared code
+#define CHostage C_CHostage
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * The client-side implementation of the Hostage
+ */
+class C_CHostage : public C_BaseCombatCharacter, public ICSPlayerAnimStateHelpers
+{
+public:
+	DECLARE_CLASS( C_CHostage, C_BaseCombatCharacter );
+	DECLARE_CLIENTCLASS();
+
+	C_CHostage();
+	virtual ~C_CHostage();
+
+// ICSPlayerAnimState overrides.
+public:
+	virtual CWeaponCSBase* CSAnim_GetActiveWeapon();
+	virtual bool CSAnim_CanMove();
+
+public:	
+	virtual void Spawn( void );
+	virtual void UpdateClientSideAnimation();
+
+	void OnPreDataChanged( DataUpdateType_t updateType );
+	void OnDataChanged( DataUpdateType_t updateType );
+
+	bool IsRescued( void ) { return m_isRescued; }
+	bool WasRecentlyKilledOrRescued( void );
+
+	int GetHealth( void ) const { return m_iHealth; }
+	int GetMaxHealth( void ) const { return m_iMaxHealth; }
+
+	virtual void ClientThink( void );
+
+	C_CSPlayer *GetLeader( void ) const;			// return who we are following or NULL
+
+	virtual C_BaseAnimating * BecomeRagdollOnClient();
+	virtual bool ShouldDraw( void );
+
+	void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName );
+private:
+	int  m_OldLifestate;
+	int  m_iMaxHealth;
+
+	ICSPlayerAnimState *m_PlayerAnimState;
+
+	CNetworkVar( EHANDLE, m_leader );				// who we are following, or NULL
+
+	CNetworkVar( bool, m_isRescued );
+	float m_flDeadOrRescuedTime;
+	static void RecvProxy_Rescued( const CRecvProxyData *pData, void *pStruct, void *pOut );
+
+	CountdownTimer m_blinkTimer;
+
+	Vector m_lookAt;		// point in space we are looking at
+	void UpdateLookAt( CStudioHdr *pStudioHdr );	// orient head and eyes towards m_lookAt
+	void LookAround( void );										// look around at various interesting things
+	CountdownTimer m_lookAroundTimer;
+
+	bool m_isInit;
+	void Initialize( void );						// set up attachment and pose param indices
+
+	int m_eyeAttachment;
+	int m_chestAttachment;
+
+	int m_bodyYawPoseParam;
+	float m_bodyYawMin;
+	float m_bodyYawMax;
+
+	int m_headYawPoseParam;
+	float m_headYawMin;
+	float m_headYawMax;
+	float m_flCurrentHeadYaw;
+	float m_flLastBodyYaw;
+
+	int m_headPitchPoseParam;
+	float m_headPitchMin;
+	float m_headPitchMax;
+	float m_flCurrentHeadPitch;
+
+	int m_seq;
+
+	bool m_createdLowViolenceRagdoll;
+	
+private:
+	C_CHostage( const C_CHostage & );				// not defined, not accessible
+};
+
+
+inline C_CSPlayer *C_CHostage::GetLeader( void ) const
+{
+	return ToCSPlayer( m_leader.m_Value );
+}
+
+
+extern CUtlVector< C_CHostage* > g_Hostages;
+extern CUtlVector< EHANDLE > g_HostageRagdolls;
+
+
+#endif // C_CHOSTAGE_H
diff --git a/game/client/cstrike/c_cs_player.cpp b/game/client/cstrike/c_cs_player.cpp
new file mode 100644
index 00000000..d4bfd07b
--- /dev/null
+++ b/game/client/cstrike/c_cs_player.cpp
@@ -0,0 +1,2553 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_cs_player.h"
+#include "c_user_message_register.h"
+#include "view.h"
+#include "iclientvehicle.h"
+#include "ivieweffects.h"
+#include "input.h"
+#include "IEffects.h"
+#include "fx.h"
+#include "c_basetempentity.h"
+#include "hud_macros.h"	//HOOK_COMMAND
+#include "engine/ivdebugoverlay.h"
+#include "smoke_fog_overlay.h"
+#include "bone_setup.h"
+#include "in_buttons.h"
+#include "r_efx.h"
+#include "dlight.h"
+#include "shake.h"
+#include "cl_animevent.h"
+#include "c_physicsprop.h"
+#include "props_shared.h"
+#include "obstacle_pushaway.h"
+#include "death_pose.h"
+
+#include "effect_dispatch_data.h"	//for water ripple / splash effect
+#include "c_te_effect_dispatch.h"	//ditto
+#include "c_te_legacytempents.h"
+#include "cs_gamerules.h"
+#include "fx_cs_blood.h"
+#include "c_cs_playerresource.h"
+#include "c_team.h"
+
+#include "history_resource.h"
+#include "ragdoll_shared.h"
+#include "collisionutils.h"
+
+// NVNT - haptics system for spectating
+#include "haptics/haptic_utils.h"
+
+#include "steam/steam_api.h"
+
+#include "cs_blackmarket.h"				// for vest/helmet prices
+
+#if defined( CCSPlayer )
+	#undef CCSPlayer
+#endif
+
+#include "materialsystem/imesh.h"		//for materials->FindMaterial
+#include "iviewrender.h"				//for view->
+
+#include "iviewrender_beams.h"			// flashlight beam
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Adding and externing variables needed for the freezecam
+//=============================================================================
+
+static Vector WALL_MIN(-WALL_OFFSET,-WALL_OFFSET,-WALL_OFFSET);
+static Vector WALL_MAX(WALL_OFFSET,WALL_OFFSET,WALL_OFFSET);
+
+extern ConVar	spec_freeze_time;
+extern ConVar	spec_freeze_traveltime;
+extern ConVar	spec_freeze_distance_min;
+extern ConVar	spec_freeze_distance_max;
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+ConVar cl_left_hand_ik( "cl_left_hand_ik", "0", 0, "Attach player's left hand to rifle with IK." );
+
+ConVar cl_ragdoll_physics_enable( "cl_ragdoll_physics_enable", "1", 0, "Enable/disable ragdoll physics." );
+
+ConVar cl_minmodels( "cl_minmodels", "0", 0, "Uses one player model for each team." );
+ConVar cl_min_ct( "cl_min_ct", "1", 0, "Controls which CT model is used when cl_minmodels is set.", true, 1, true, 4 );
+ConVar cl_min_t( "cl_min_t", "1", 0, "Controls which Terrorist model is used when cl_minmodels is set.", true, 1, true, 4 );
+const float CycleLatchTolerance = 0.15;	// amount we can diverge from the server's cycle before we're corrected
+
+extern ConVar mp_playerid_delay;
+extern ConVar mp_playerid_hold;
+extern ConVar sv_allowminmodels;
+
+class CAddonInfo
+{
+public:
+	const char *m_pAttachmentName;
+	const char *m_pWeaponClassName;	// The addon uses the w_ model from this weapon.
+	const char *m_pModelName;		//If this is present, will use this model instead of looking up the weapon
+	const char *m_pHolsterName;
+};
+
+
+
+// These must follow the ADDON_ ordering.
+CAddonInfo g_AddonInfo[] =
+{
+	{ "grenade0",	"weapon_flashbang",		0, 0 },
+	{ "grenade1",	"weapon_flashbang",		0, 0 },
+	{ "grenade2",	"weapon_hegrenade",		0, 0 },
+	{ "grenade3",	"weapon_smokegrenade",	0, 0 },
+	{ "c4",			"weapon_c4",			0, 0 },
+	{ "defusekit",	0,						"models/weapons/w_defuser.mdl", 0 },
+	{ "primary",	0,						0, 0 },	// Primary addon model is looked up based on m_iPrimaryAddon
+	{ "pistol",		0,						0, 0 },	// Pistol addon model is looked up based on m_iSecondaryAddon
+	{ "eholster",	0,						"models/weapons/w_eq_eholster_elite.mdl", "models/weapons/w_eq_eholster.mdl" },
+};
+
+// -------------------------------------------------------------------------------- //
+// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
+// -------------------------------------------------------------------------------- //
+
+class C_TEPlayerAnimEvent : public C_BaseTempEntity
+{
+public:
+	DECLARE_CLASS( C_TEPlayerAnimEvent, C_BaseTempEntity );
+	DECLARE_CLIENTCLASS();
+
+	virtual void PostDataUpdate( DataUpdateType_t updateType )
+	{
+		// Create the effect.
+		C_CSPlayer *pPlayer = dynamic_cast< C_CSPlayer* >( m_hPlayer.Get() );
+		if ( pPlayer && !pPlayer->IsDormant() )
+		{
+			pPlayer->DoAnimationEvent( (PlayerAnimEvent_t)m_iEvent.Get(), m_nData );
+		}
+	}
+
+public:
+	CNetworkHandle( CBasePlayer, m_hPlayer );
+	CNetworkVar( int, m_iEvent );
+	CNetworkVar( int, m_nData );
+};
+
+IMPLEMENT_CLIENTCLASS_EVENT( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent, CTEPlayerAnimEvent );
+
+BEGIN_RECV_TABLE_NOBASE( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent )
+	RecvPropEHandle( RECVINFO( m_hPlayer ) ),
+	RecvPropInt( RECVINFO( m_iEvent ) ),
+	RecvPropInt( RECVINFO( m_nData ) )
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA( C_CSPlayer )
+#ifdef CS_SHIELD_ENABLED
+	DEFINE_PRED_FIELD( m_bShieldDrawn, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+#endif
+	DEFINE_PRED_FIELD_TOL( m_flStamina, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.1f ),
+	DEFINE_PRED_FIELD( m_flCycle, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_iShotsFired, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_iDirection, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bResumeZoom, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_iLastZoom, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+vgui::IImage* GetDefaultAvatarImage( C_BasePlayer *pPlayer )
+{
+	vgui::IImage* result = NULL;
+
+	switch ( pPlayer ? pPlayer->GetTeamNumber() : TEAM_MAXCOUNT )
+	{
+		case TEAM_TERRORIST: 
+			result = vgui::scheme()->GetImage( CSTRIKE_DEFAULT_T_AVATAR, true );
+			break;
+
+		case TEAM_CT:		 
+			result = vgui::scheme()->GetImage( CSTRIKE_DEFAULT_CT_AVATAR, true );
+			break;
+
+		default:
+			result = vgui::scheme()->GetImage( CSTRIKE_DEFAULT_AVATAR, true );
+			break;
+	}
+
+	return result;
+}
+
+// ----------------------------------------------------------------------------- //
+// Client ragdoll entity.
+// ----------------------------------------------------------------------------- //
+
+float g_flDieTranslucentTime = 0.6;
+
+class C_CSRagdoll : public C_BaseAnimatingOverlay
+{
+public:
+	DECLARE_CLASS( C_CSRagdoll, C_BaseAnimatingOverlay );
+	DECLARE_CLIENTCLASS();
+
+	C_CSRagdoll();
+	~C_CSRagdoll();
+
+	virtual void OnDataChanged( DataUpdateType_t type );
+
+	int GetPlayerEntIndex() const;
+	IRagdoll* GetIRagdoll() const;
+	void GetRagdollInitBoneArrays( matrix3x4_t *pDeltaBones0, matrix3x4_t *pDeltaBones1, matrix3x4_t *pCurrentBones, float boneDt ) OVERRIDE;
+
+	void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName );
+
+	virtual void ComputeFxBlend();
+	virtual bool IsTransparent();
+	bool IsInitialized() { return m_bInitialized; }
+	// fading ragdolls don't cast shadows
+	virtual ShadowType_t ShadowCastType() 
+	{ 
+		if ( m_flRagdollSinkStart == -1 )
+			return BaseClass::ShadowCastType();
+		return SHADOWS_NONE;
+	}
+
+	virtual void ValidateModelIndex( void );
+
+private:
+
+	C_CSRagdoll( const C_CSRagdoll & ) {}
+
+	void Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity );
+
+	void CreateLowViolenceRagdoll( void );
+	void CreateCSRagdoll( void );
+
+private:
+
+	EHANDLE	m_hPlayer;
+	CNetworkVector( m_vecRagdollVelocity );
+	CNetworkVector( m_vecRagdollOrigin );
+	CNetworkVar(int, m_iDeathPose );
+	CNetworkVar(int, m_iDeathFrame );
+	float m_flRagdollSinkStart;
+	bool m_bInitialized;
+	bool m_bCreatedWhilePlaybackSkipping;
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT_NOBASE( C_CSRagdoll, DT_CSRagdoll, CCSRagdoll )
+	RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
+	RecvPropVector( RECVINFO(m_vecRagdollOrigin) ),
+	RecvPropEHandle( RECVINFO( m_hPlayer ) ),
+	RecvPropInt( RECVINFO( m_nModelIndex ) ),
+	RecvPropInt( RECVINFO(m_nForceBone) ),
+	RecvPropVector( RECVINFO(m_vecForce) ),
+	RecvPropVector( RECVINFO( m_vecRagdollVelocity ) ),
+	RecvPropInt( RECVINFO(m_iDeathPose) ),
+	RecvPropInt( RECVINFO(m_iDeathFrame) ),
+	RecvPropInt(RECVINFO(m_iTeamNum)),
+	RecvPropInt( RECVINFO(m_bClientSideAnimation)),
+END_RECV_TABLE()
+
+
+C_CSRagdoll::C_CSRagdoll()
+{
+	m_flRagdollSinkStart = -1;
+	m_bInitialized = false;
+	m_bCreatedWhilePlaybackSkipping = engine->IsSkippingPlayback();
+}
+
+C_CSRagdoll::~C_CSRagdoll()
+{
+	PhysCleanupFrictionSounds( this );
+}
+
+void C_CSRagdoll::GetRagdollInitBoneArrays( matrix3x4_t *pDeltaBones0, matrix3x4_t *pDeltaBones1, matrix3x4_t *pCurrentBones, float boneDt )
+{
+	// otherwise use the death pose to set up the ragdoll
+	ForceSetupBonesAtTime( pDeltaBones0, gpGlobals->curtime - boneDt );
+	GetRagdollCurSequenceWithDeathPose( this, pDeltaBones1, gpGlobals->curtime, m_iDeathPose, m_iDeathFrame );
+	SetupBones( pCurrentBones, MAXSTUDIOBONES, BONE_USED_BY_ANYTHING, gpGlobals->curtime );
+}
+
+void C_CSRagdoll::Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity )
+{
+	if ( !pSourceEntity )
+		return;
+
+	VarMapping_t *pSrc = pSourceEntity->GetVarMapping();
+	VarMapping_t *pDest = GetVarMapping();
+
+	// Find all the VarMapEntry_t's that represent the same variable.
+	for ( int i = 0; i < pDest->m_Entries.Count(); i++ )
+	{
+		VarMapEntry_t *pDestEntry = &pDest->m_Entries[i];
+		for ( int j=0; j < pSrc->m_Entries.Count(); j++ )
+		{
+			VarMapEntry_t *pSrcEntry = &pSrc->m_Entries[j];
+			if ( !Q_strcmp( pSrcEntry->watcher->GetDebugName(),
+				pDestEntry->watcher->GetDebugName() ) )
+			{
+				pDestEntry->watcher->Copy( pSrcEntry->watcher );
+				break;
+			}
+		}
+	}
+}
+
+void C_CSRagdoll::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
+{
+	IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
+
+	if( !pPhysicsObject )
+		return;
+
+	Vector dir = pTrace->endpos - pTrace->startpos;
+
+	if ( iDamageType == DMG_BLAST )
+	{
+		dir *= 4000;  // adjust impact strenght
+
+		// apply force at object mass center
+		pPhysicsObject->ApplyForceCenter( dir );
+	}
+	else
+	{
+		Vector hitpos;
+
+		VectorMA( pTrace->startpos, pTrace->fraction, dir, hitpos );
+		VectorNormalize( dir );
+
+		dir *= 4000;  // adjust impact strenght
+
+		// apply force where we hit it
+		pPhysicsObject->ApplyForceOffset( dir, hitpos );
+
+		// Blood spray!
+		FX_CS_BloodSpray( hitpos, dir, 10 );
+	}
+
+	m_pRagdoll->ResetRagdollSleepAfterTime();
+}
+
+
+void C_CSRagdoll::ValidateModelIndex( void )
+{
+	if ( sv_allowminmodels.GetBool() && cl_minmodels.GetBool() )
+	{
+		if ( GetTeamNumber() == TEAM_CT )
+		{
+			int index = cl_min_ct.GetInt() - 1;
+			if ( index >= 0 && index < CTPlayerModels.Count() )
+			{
+				m_nModelIndex = modelinfo->GetModelIndex(CTPlayerModels[index]);
+			}
+		}
+		else if ( GetTeamNumber() == TEAM_TERRORIST )
+		{
+			int index = cl_min_t.GetInt() - 1;
+			if ( index >= 0 && index < TerroristPlayerModels.Count() )
+			{
+				m_nModelIndex = modelinfo->GetModelIndex(TerroristPlayerModels[index]);
+			}
+		}
+	}
+
+	BaseClass::ValidateModelIndex();
+}
+
+
+void C_CSRagdoll::CreateLowViolenceRagdoll( void )
+{
+	// Just play a death animation.
+	// Find a death anim to play.
+	int iMinDeathAnim = 9999, iMaxDeathAnim = -9999;
+	for ( int iAnim=1; iAnim < 100; iAnim++ )
+	{
+		char str[512];
+		Q_snprintf( str, sizeof( str ), "death%d", iAnim );
+		if ( LookupSequence( str ) == -1 )
+			break;
+
+		iMinDeathAnim = MIN( iMinDeathAnim, iAnim );
+		iMaxDeathAnim = MAX( iMaxDeathAnim, iAnim );
+	}
+
+	if ( iMinDeathAnim == 9999 )
+	{
+		CreateCSRagdoll();
+		return;
+	}
+
+	SetNetworkOrigin( m_vecRagdollOrigin );
+	SetAbsOrigin( m_vecRagdollOrigin );
+	SetAbsVelocity( m_vecRagdollVelocity );
+
+	C_CSPlayer *pPlayer = dynamic_cast< C_CSPlayer* >( m_hPlayer.Get() );
+	if ( pPlayer )
+	{
+		if ( !pPlayer->IsDormant() )
+		{
+			// move my current model instance to the ragdoll's so decals are preserved.
+			pPlayer->SnatchModelInstance( this );
+		}
+
+		SetAbsAngles( pPlayer->GetRenderAngles() );
+		SetNetworkAngles( pPlayer->GetRenderAngles() );
+	}
+
+	int iDeathAnim = RandomInt( iMinDeathAnim, iMaxDeathAnim );
+	char str[512];
+	Q_snprintf( str, sizeof( str ), "death%d", iDeathAnim );
+	SetSequence( LookupSequence( str ) );
+	ForceClientSideAnimationOn();
+
+	Interp_Reset( GetVarMapping() );
+}
+
+
+void C_CSRagdoll::CreateCSRagdoll()
+{
+	// First, initialize all our data. If we have the player's entity on our client,
+	// then we can make ourselves start out exactly where the player is.
+	C_CSPlayer *pPlayer = dynamic_cast< C_CSPlayer* >( m_hPlayer.Get() );
+
+	// mark this to prevent model changes from overwriting the death sequence with the server sequence
+	SetReceivedSequence();
+
+	if ( pPlayer && !pPlayer->IsDormant() )
+	{
+		// move my current model instance to the ragdoll's so decals are preserved.
+		pPlayer->SnatchModelInstance( this );
+
+		VarMapping_t *varMap = GetVarMapping();
+
+		// Copy all the interpolated vars from the player entity.
+		// The entity uses the interpolated history to get bone velocity.
+		bool bRemotePlayer = (pPlayer != C_BasePlayer::GetLocalPlayer());
+		if ( bRemotePlayer )
+		{
+			Interp_Copy( pPlayer );
+
+			SetAbsAngles( pPlayer->GetRenderAngles() );
+			GetRotationInterpolator().Reset();
+
+			m_flAnimTime = pPlayer->m_flAnimTime;
+			SetSequence( pPlayer->GetSequence() );
+			m_flPlaybackRate = pPlayer->GetPlaybackRate();
+		}
+		else
+		{
+			// This is the local player, so set them in a default
+			// pose and slam their velocity, angles and origin
+			SetAbsOrigin( m_vecRagdollOrigin );
+
+			SetAbsAngles( pPlayer->GetRenderAngles() );
+
+			SetAbsVelocity( m_vecRagdollVelocity );
+
+			int iSeq = LookupSequence( "walk_lower" );
+			if ( iSeq == -1 )
+			{
+				Assert( false );	// missing walk_lower?
+				iSeq = 0;
+			}
+
+			SetSequence( iSeq );	// walk_lower, basic pose
+			SetCycle( 0.0 );
+
+			// go ahead and set these on the player in case the code below decides to set up bones using
+			// that entity instead of this one.  The local player may not have valid animation
+			pPlayer->SetSequence( iSeq );	// walk_lower, basic pose
+			pPlayer->SetCycle( 0.0 );
+
+			Interp_Reset( varMap );
+		}
+	}
+	else
+	{
+		// overwrite network origin so later interpolation will
+		// use this position
+		SetNetworkOrigin( m_vecRagdollOrigin );
+
+		SetAbsOrigin( m_vecRagdollOrigin );
+		SetAbsVelocity( m_vecRagdollVelocity );
+
+		Interp_Reset( GetVarMapping() );
+	}
+
+	// Turn it into a ragdoll.
+	if ( cl_ragdoll_physics_enable.GetInt() )
+	{
+		// Make us a ragdoll..
+		m_nRenderFX = kRenderFxRagdoll;
+
+		matrix3x4_t boneDelta0[MAXSTUDIOBONES];
+		matrix3x4_t boneDelta1[MAXSTUDIOBONES];
+		matrix3x4_t currentBones[MAXSTUDIOBONES];
+		const float boneDt = 0.05f;
+
+		//=============================================================================
+		// [pfreese], [tj]
+		// There are visual problems with the attempted blending of the 
+		// death pose animations in C_CSRagdoll::GetRagdollInitBoneArrays. The version
+		// in C_BasePlayer::GetRagdollInitBoneArrays doesn't attempt to blend death
+		// poses, so if the player is relevant, use that one regardless of whether the 
+		// player is the local one or not.
+		//=============================================================================
+		if ( pPlayer && !pPlayer->IsDormant() )
+		{
+			pPlayer->GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
+		}
+		else
+		{
+			GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
+		}
+
+		InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt );
+		m_flRagdollSinkStart = -1;
+	}
+	else
+	{
+		m_flRagdollSinkStart = gpGlobals->curtime;
+		DestroyShadow();
+		ClientLeafSystem()->SetRenderGroup( GetRenderHandle(), RENDER_GROUP_TRANSLUCENT_ENTITY );
+	}
+	m_bInitialized = true;
+}
+
+
+void C_CSRagdoll::ComputeFxBlend( void )
+{
+	if ( m_flRagdollSinkStart == -1 )
+	{
+		BaseClass::ComputeFxBlend();
+	}
+	else
+	{
+		float elapsed = gpGlobals->curtime - m_flRagdollSinkStart;
+		float flVal = RemapVal( elapsed, 0, g_flDieTranslucentTime, 255, 0 );
+		flVal = clamp( flVal, 0, 255 );
+		m_nRenderFXBlend = (int)flVal;
+
+#ifdef _DEBUG
+		m_nFXComputeFrame = gpGlobals->framecount;
+#endif
+	}
+}
+
+
+bool C_CSRagdoll::IsTransparent( void )
+{
+	if ( m_flRagdollSinkStart == -1 )
+	{
+		return BaseClass::IsTransparent();
+	}
+	else
+	{
+		return true;
+	}
+}
+
+
+void C_CSRagdoll::OnDataChanged( DataUpdateType_t type )
+{
+	BaseClass::OnDataChanged( type );
+
+	if ( type == DATA_UPDATE_CREATED )
+	{
+		// Prevent replays from creating ragdolls on the first frame of playback after skipping through playback.
+		// If a player died (leaving a ragdoll) previous to the first frame of replay playback,
+		// their ragdoll wasn't yet initialized because OnDataChanged events are queued but not processed
+		// until the first render. 
+		if ( engine->IsPlayingDemo() && m_bCreatedWhilePlaybackSkipping )
+		{
+			Release();
+			return;
+		}
+
+		if ( g_RagdollLVManager.IsLowViolence() )
+		{
+			CreateLowViolenceRagdoll();
+		}
+		else
+		{
+			CreateCSRagdoll();
+		}
+	}
+	else
+	{
+		if ( !cl_ragdoll_physics_enable.GetInt() )
+		{
+			// Don't let it set us back to a ragdoll with data from the server.
+			m_nRenderFX = kRenderFxNone;
+		}
+	}
+}
+
+IRagdoll* C_CSRagdoll::GetIRagdoll() const
+{
+	return m_pRagdoll;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when the player toggles nightvision
+// Input  : *pData - the int value of the nightvision state
+//			*pStruct - the player
+//			*pOut -
+//-----------------------------------------------------------------------------
+void RecvProxy_NightVision( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	C_CSPlayer *pPlayerData = (C_CSPlayer *) pStruct;
+
+	bool bNightVisionOn = ( pData->m_Value.m_Int > 0 );
+
+	if ( pPlayerData->m_bNightVisionOn != bNightVisionOn )
+	{
+		if ( bNightVisionOn )
+			 pPlayerData->m_flNightVisionAlpha = 1;
+	}
+
+	pPlayerData->m_bNightVisionOn = bNightVisionOn;
+}
+
+void RecvProxy_FlashTime( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	C_CSPlayer *pPlayerData = (C_CSPlayer *) pStruct;
+
+	if( pPlayerData != C_BasePlayer::GetLocalPlayer() )
+		return;
+
+	if ( (pPlayerData->m_flFlashDuration != pData->m_Value.m_Float) && pData->m_Value.m_Float > 0 )
+	{
+		pPlayerData->m_flFlashAlpha = 1;
+	}
+
+	pPlayerData->m_flFlashDuration = pData->m_Value.m_Float;
+	pPlayerData->m_flFlashBangTime = gpGlobals->curtime + pPlayerData->m_flFlashDuration;
+}
+
+void RecvProxy_HasDefuser( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	C_CSPlayer *pPlayerData = (C_CSPlayer *)pStruct;
+
+	if (pPlayerData == NULL)
+	{
+		return;
+	}
+
+	bool drawIcon = false;
+
+	if (pData->m_Value.m_Int == 0)
+	{
+		pPlayerData->RemoveDefuser();
+	}
+	else
+	{
+		if (pPlayerData->HasDefuser() == false)
+		{
+			drawIcon = true;
+		}
+		pPlayerData->GiveDefuser();
+	}
+
+	if (pPlayerData->IsLocalPlayer() && drawIcon)
+	{
+		// add to pickup history
+		CHudHistoryResource *pHudHR = GET_HUDELEMENT( CHudHistoryResource );
+
+		if ( pHudHR )
+		{
+			pHudHR->AddToHistory(HISTSLOT_ITEM, "defuser_pickup");
+		}
+	}
+}
+
+void C_CSPlayer::RecvProxy_CycleLatch( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	// This receive proxy looks to see if the server's value is close enough to what we think it should
+	// be.  We've been running the same code; this is an error correction for changes we didn't simulate
+	// while they were out of PVS.
+	C_CSPlayer *pPlayer = (C_CSPlayer *)pStruct;
+	if( pPlayer->IsLocalPlayer() )
+		return; // Don't need to fixup ourselves.
+
+	float incomingCycle = (float)(pData->m_Value.m_Int) / 16; // Came in as 4 bit fixed point
+	float currentCycle = pPlayer->GetCycle();
+	bool closeEnough = fabs(currentCycle - incomingCycle) < CycleLatchTolerance;
+	if( fabs(currentCycle - incomingCycle) > (1 - CycleLatchTolerance) )
+	{
+		closeEnough = true;// Handle wrapping around 1->0
+	}
+
+	if( !closeEnough )
+	{
+		// Server disagrees too greatly.  Correct our value.
+		if ( pPlayer && pPlayer->GetTeam() )
+		{
+			DevMsg( 2, "%s %s(%d): Cycle latch wants to correct %.2f in to %.2f.\n",
+				pPlayer->GetTeam()->Get_Name(), pPlayer->GetPlayerName(), pPlayer->entindex(), currentCycle, incomingCycle );
+		}
+		pPlayer->SetServerIntendedCycle( incomingCycle );
+	}
+}
+
+void __MsgFunc_ReloadEffect( bf_read &msg )
+{
+	int iPlayer = msg.ReadShort();
+	C_CSPlayer *pPlayer = dynamic_cast< C_CSPlayer* >( C_BaseEntity::Instance( iPlayer ) );
+	if ( pPlayer )
+		pPlayer->PlayReloadEffect();
+
+}
+USER_MESSAGE_REGISTER( ReloadEffect );
+
+BEGIN_RECV_TABLE_NOBASE( C_CSPlayer, DT_CSLocalPlayerExclusive )
+	RecvPropFloat( RECVINFO(m_flStamina) ),
+	RecvPropInt( RECVINFO( m_iDirection ) ),
+	RecvPropInt( RECVINFO( m_iShotsFired ) ),
+	RecvPropFloat( RECVINFO( m_flVelocityModifier ) ),
+
+	RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [tj]Set up the receive table for per-client domination data
+    //=============================================================================
+
+    RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominated ), RecvPropBool( RECVINFO( m_bPlayerDominated[0] ) ) ),
+    RecvPropArray3( RECVINFO_ARRAY( m_bPlayerDominatingMe ), RecvPropBool( RECVINFO( m_bPlayerDominatingMe[0] ) ) )
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+END_RECV_TABLE()
+
+
+BEGIN_RECV_TABLE_NOBASE( C_CSPlayer, DT_CSNonLocalPlayerExclusive )
+	RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
+END_RECV_TABLE()
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_CSPlayer, DT_CSPlayer, CCSPlayer )
+	RecvPropDataTable( "cslocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_CSLocalPlayerExclusive) ),
+	RecvPropDataTable( "csnonlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_CSNonLocalPlayerExclusive) ),
+	RecvPropInt( RECVINFO( m_iAddonBits ) ),
+	RecvPropInt( RECVINFO( m_iPrimaryAddon ) ),
+	RecvPropInt( RECVINFO( m_iSecondaryAddon ) ),
+	RecvPropInt( RECVINFO( m_iThrowGrenadeCounter ) ),
+	RecvPropInt( RECVINFO( m_iPlayerState ) ),
+	RecvPropInt( RECVINFO( m_iAccount ) ),
+	RecvPropInt( RECVINFO( m_bInBombZone ) ),
+	RecvPropInt( RECVINFO( m_bInBuyZone ) ),
+	RecvPropInt( RECVINFO( m_iClass ) ),
+	RecvPropInt( RECVINFO( m_ArmorValue ) ),
+	RecvPropFloat( RECVINFO( m_angEyeAngles[0] ) ),
+	RecvPropFloat( RECVINFO( m_angEyeAngles[1] ) ),
+	RecvPropFloat( RECVINFO( m_flStamina ) ),
+	RecvPropInt( RECVINFO( m_bHasDefuser ), 0, RecvProxy_HasDefuser ),
+	RecvPropInt( RECVINFO( m_bNightVisionOn), 0, RecvProxy_NightVision ),
+	RecvPropBool( RECVINFO( m_bHasNightVision ) ),
+
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [dwenger] Added for fun-fact support
+    //=============================================================================
+
+    //RecvPropBool( RECVINFO( m_bPickedUpDefuser ) ),
+    //RecvPropBool( RECVINFO( m_bDefusedWithPickedUpKit ) ),
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+    RecvPropBool( RECVINFO( m_bInHostageRescueZone ) ),
+	RecvPropInt( RECVINFO( m_ArmorValue ) ),
+	RecvPropBool( RECVINFO( m_bIsDefusing ) ),
+	RecvPropBool( RECVINFO( m_bResumeZoom ) ),
+	RecvPropInt( RECVINFO( m_iLastZoom ) ),
+
+#ifdef CS_SHIELD_ENABLED
+	RecvPropBool( RECVINFO( m_bHasShield ) ),
+	RecvPropBool( RECVINFO( m_bShieldDrawn ) ),
+#endif
+	RecvPropInt( RECVINFO( m_bHasHelmet ) ),
+	RecvPropVector( RECVINFO( m_vecRagdollVelocity ) ),
+	RecvPropFloat( RECVINFO( m_flFlashDuration ), 0, RecvProxy_FlashTime ),
+	RecvPropFloat( RECVINFO( m_flFlashMaxAlpha)),
+	RecvPropInt( RECVINFO( m_iProgressBarDuration ) ),
+	RecvPropFloat( RECVINFO( m_flProgressBarStartTime ) ),
+	RecvPropEHandle( RECVINFO( m_hRagdoll ) ),
+	RecvPropInt( RECVINFO( m_cycleLatch ), 0, &C_CSPlayer::RecvProxy_CycleLatch ),
+
+END_RECV_TABLE()
+
+
+
+C_CSPlayer::C_CSPlayer() :
+	m_iv_angEyeAngles( "C_CSPlayer::m_iv_angEyeAngles" )
+{
+	m_PlayerAnimState = CreatePlayerAnimState( this, this, LEGANIM_9WAY, true );
+
+	m_angEyeAngles.Init();
+
+	AddVar( &m_angEyeAngles, &m_iv_angEyeAngles, LATCH_SIMULATION_VAR );
+
+	m_iLastAddonBits = m_iAddonBits = 0;
+	m_iLastPrimaryAddon = m_iLastSecondaryAddon = WEAPON_NONE;
+	m_iProgressBarDuration = 0;
+	m_flProgressBarStartTime = 0.0f;
+	m_ArmorValue = 0;
+	m_bHasHelmet = false;
+	m_iIDEntIndex = 0;
+	m_delayTargetIDTimer.Reset();
+	m_iOldIDEntIndex = 0;
+	m_holdTargetIDTimer.Reset();
+	m_iDirection = 0;
+
+	m_Activity = ACT_IDLE;
+
+	m_pFlashlightBeam = NULL;
+	m_fNextThinkPushAway = 0.0f;
+
+	m_serverIntendedCycle = -1.0f;
+
+	view->SetScreenOverlayMaterial( NULL );
+
+    m_bPlayingFreezeCamSound = false;
+}
+
+
+C_CSPlayer::~C_CSPlayer()
+{
+	RemoveAddonModels();
+
+	ReleaseFlashlight();
+
+	m_PlayerAnimState->Release();
+}
+
+
+bool C_CSPlayer::HasDefuser() const
+{
+	return m_bHasDefuser;
+}
+
+void C_CSPlayer::GiveDefuser()
+{
+	m_bHasDefuser = true;
+}
+
+void C_CSPlayer::RemoveDefuser()
+{
+	m_bHasDefuser = false;
+}
+
+bool C_CSPlayer::HasNightVision() const
+{
+	return m_bHasNightVision;
+}
+
+bool C_CSPlayer::IsVIP() const
+{
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+
+	if ( !pCSPR )
+		return false;
+
+	return pCSPR->IsVIP( entindex() );
+}
+
+C_CSPlayer* C_CSPlayer::GetLocalCSPlayer()
+{
+	return (C_CSPlayer*)C_BasePlayer::GetLocalPlayer();
+}
+
+
+CSPlayerState C_CSPlayer::State_Get() const
+{
+	return m_iPlayerState;
+}
+
+
+float C_CSPlayer::GetMinFOV() const
+{
+	// Min FOV for AWP.
+	return 10;
+}
+
+
+int C_CSPlayer::GetAccount() const
+{
+	return m_iAccount;
+}
+
+
+int C_CSPlayer::PlayerClass() const
+{
+	return m_iClass;
+}
+
+bool C_CSPlayer::IsInBuyZone()
+{
+	return m_bInBuyZone;
+}
+
+bool C_CSPlayer::CanShowTeamMenu() const
+{
+	return true;
+}
+
+
+int C_CSPlayer::ArmorValue() const
+{
+	return m_ArmorValue;
+}
+
+bool C_CSPlayer::HasHelmet() const
+{
+	return m_bHasHelmet;
+}
+
+int C_CSPlayer::GetCurrentAssaultSuitPrice()
+{
+	// WARNING: This price logic also exists in CCSPlayer::AttemptToBuyAssaultSuit
+	// and must be kept in sync if changes are made.
+
+	int fullArmor = ArmorValue() >= 100 ? 1 : 0;
+	if ( fullArmor && !HasHelmet() )
+	{
+		return HELMET_PRICE;
+	}
+	else if ( !fullArmor && HasHelmet() )
+	{
+		return KEVLAR_PRICE;
+	}
+	else
+	{
+		// NOTE: This applies to the case where you already have both
+		// as well as the case where you have neither.  In the case
+		// where you have both, the item should still have a price
+		// and become disabled when you have little or no money left.
+		return ASSAULTSUIT_PRICE;
+	}
+}
+
+const QAngle& C_CSPlayer::GetRenderAngles()
+{
+	if ( IsRagdoll() )
+	{
+		return vec3_angle;
+	}
+	else
+	{
+		return m_PlayerAnimState->GetRenderAngles();
+	}
+}
+
+
+float g_flFattenAmt = 4;
+void C_CSPlayer::GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType )
+{
+	if ( shadowType == SHADOWS_SIMPLE )
+	{
+		// Don't let the render bounds change when we're using blobby shadows, or else the shadow
+		// will pop and stretch.
+		mins = CollisionProp()->OBBMins();
+		maxs = CollisionProp()->OBBMaxs();
+	}
+	else
+	{
+		GetRenderBounds( mins, maxs );
+
+		// We do this because the normal bbox calculations don't take pose params into account, and
+		// the rotation of the guy's upper torso can place his gun a ways out of his bbox, and
+		// the shadow will get cut off as he rotates.
+		//
+		// Thus, we give it some padding here.
+		mins -= Vector( g_flFattenAmt, g_flFattenAmt, 0 );
+		maxs += Vector( g_flFattenAmt, g_flFattenAmt, 0 );
+	}
+}
+
+
+void C_CSPlayer::GetRenderBounds( Vector& theMins, Vector& theMaxs )
+{
+	// TODO POSTSHIP - this hack/fix goes hand-in-hand with a fix in CalcSequenceBoundingBoxes in utils/studiomdl/simplify.cpp.
+	// When we enable the fix in CalcSequenceBoundingBoxes, we can get rid of this.
+	//
+	// What we're doing right here is making sure it only uses the bbox for our lower-body sequences since,
+	// with the current animations and the bug in CalcSequenceBoundingBoxes, are WAY bigger than they need to be.
+	C_BaseAnimating::GetRenderBounds( theMins, theMaxs );
+
+	// If we're ducking, we should reduce the render height by the difference in standing and ducking heights.
+	// This prevents shadows from drawing above ducking players etc.
+	if ( GetFlags() & FL_DUCKING )
+	{
+		theMaxs.z -= 18.5f;
+	}
+}
+
+
+bool C_CSPlayer::GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const
+{
+	if ( shadowType == SHADOWS_SIMPLE )
+	{
+		// Blobby shadows should sit directly underneath us.
+		pDirection->Init( 0, 0, -1 );
+		return true;
+	}
+	else
+	{
+		return BaseClass::GetShadowCastDirection( pDirection, shadowType );
+	}
+}
+
+
+void C_CSPlayer::VPhysicsUpdate( IPhysicsObject *pPhysics )
+{
+	BaseClass::VPhysicsUpdate( pPhysics );
+}
+
+
+int C_CSPlayer::GetIDTarget() const
+{
+	if ( !m_delayTargetIDTimer.IsElapsed() )
+		return 0;
+
+	if ( m_iIDEntIndex )
+	{
+		return m_iIDEntIndex;
+	}
+
+	if ( m_iOldIDEntIndex && !m_holdTargetIDTimer.IsElapsed() )
+	{
+		return m_iOldIDEntIndex;
+	}
+
+	return 0;
+}
+
+
+void InitializeAddonModelFromWeapon( CWeaponCSBase *weapon, C_BreakableProp *addon )
+{
+	if ( !weapon )
+	{
+		return;
+	}
+
+	const CCSWeaponInfo& weaponInfo = weapon->GetCSWpnData();
+	if ( weaponInfo.m_szAddonModel[0] == 0 )
+	{
+		addon->InitializeAsClientEntity( weaponInfo.szWorldModel, RENDER_GROUP_OPAQUE_ENTITY );
+	}
+	else
+	{
+		addon->InitializeAsClientEntity( weaponInfo.m_szAddonModel, RENDER_GROUP_OPAQUE_ENTITY );
+	}
+}
+
+void C_CSPlayer::CreateAddonModel( int i )
+{
+	COMPILE_TIME_ASSERT( (sizeof( g_AddonInfo ) / sizeof( g_AddonInfo[0] )) == NUM_ADDON_BITS );
+
+	// Create the model entity.
+	CAddonInfo *pAddonInfo = &g_AddonInfo[i];
+
+	int iAttachment = LookupAttachment( pAddonInfo->m_pAttachmentName );
+	if ( iAttachment <= 0 )
+		return;
+
+	C_BreakableProp *pEnt = new C_BreakableProp;
+
+	int addonType = (1<<i);
+	if ( addonType == ADDON_PISTOL || addonType == ADDON_PRIMARY )
+	{
+		CCSWeaponInfo *weaponInfo = GetWeaponInfo( (CSWeaponID)((addonType == ADDON_PRIMARY) ? m_iPrimaryAddon.Get() : m_iSecondaryAddon.Get()) );
+		if ( !weaponInfo )
+		{
+			Warning( "C_CSPlayer::CreateAddonModel: Unable to get weapon info.\n" );
+			pEnt->Release();
+			return;
+		}
+		if ( weaponInfo->m_szAddonModel[0] == 0 )
+		{
+			pEnt->InitializeAsClientEntity( weaponInfo->szWorldModel, RENDER_GROUP_OPAQUE_ENTITY );
+		}
+		else
+		{
+			pEnt->InitializeAsClientEntity( weaponInfo->m_szAddonModel, RENDER_GROUP_OPAQUE_ENTITY );
+		}
+	}
+	else if( pAddonInfo->m_pModelName )
+	{
+		if ( addonType == ADDON_PISTOL2 && !(m_iAddonBits & ADDON_PISTOL ) )
+		{
+			pEnt->InitializeAsClientEntity( pAddonInfo->m_pHolsterName, RENDER_GROUP_OPAQUE_ENTITY );
+		}
+		else
+		{
+			pEnt->InitializeAsClientEntity( pAddonInfo->m_pModelName, RENDER_GROUP_OPAQUE_ENTITY );
+		}
+	}
+	else
+	{
+		WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( pAddonInfo->m_pWeaponClassName );
+		if ( hWpnInfo == GetInvalidWeaponInfoHandle() )
+		{
+			Assert( false );
+			return;
+		}
+
+		CCSWeaponInfo *pWeaponInfo = dynamic_cast< CCSWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+		if ( pWeaponInfo )
+		{
+			if ( pWeaponInfo->m_szAddonModel[0] == 0 )
+				pEnt->InitializeAsClientEntity( pWeaponInfo->szWorldModel, RENDER_GROUP_OPAQUE_ENTITY );
+			else
+				pEnt->InitializeAsClientEntity( pWeaponInfo->m_szAddonModel, RENDER_GROUP_OPAQUE_ENTITY );
+		}
+		else
+		{
+			pEnt->Release();
+			Warning( "C_CSPlayer::CreateAddonModel: Unable to get weapon info for %s.\n", pAddonInfo->m_pWeaponClassName );
+			return;
+		}
+	}
+
+	if ( Q_strcmp( pAddonInfo->m_pAttachmentName, "c4" ) )
+	{
+		// fade out all attached models except C4
+		pEnt->SetFadeMinMax( 400, 500 );
+	}
+
+	// Create the addon.
+	CAddonModel *pAddon = &m_AddonModels[m_AddonModels.AddToTail()];
+
+	pAddon->m_hEnt = pEnt;
+	pAddon->m_iAddon = i;
+	pAddon->m_iAttachmentPoint = iAttachment;
+	pEnt->SetParent( this, pAddon->m_iAttachmentPoint );
+	pEnt->SetLocalOrigin( Vector( 0, 0, 0 ) );
+	pEnt->SetLocalAngles( QAngle( 0, 0, 0 ) );
+	if ( IsLocalPlayer() )
+	{
+		pEnt->SetSolid( SOLID_NONE );
+		pEnt->RemoveEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID );
+	}
+}
+
+
+void C_CSPlayer::UpdateAddonModels()
+{
+	int iCurAddonBits = m_iAddonBits;
+
+	// Don't put addon models on the local player unless in third person.
+	if ( IsLocalPlayer() && !C_BasePlayer::ShouldDrawLocalPlayer() )
+		iCurAddonBits = 0;
+
+	// If the local player is observing this entity in first-person mode, get rid of its addons.
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE && pPlayer->GetObserverTarget() == this )
+		iCurAddonBits = 0;
+
+	// Any changes to the attachments we should have?
+	if ( m_iLastAddonBits == iCurAddonBits &&
+		m_iLastPrimaryAddon == m_iPrimaryAddon &&
+		m_iLastSecondaryAddon == m_iSecondaryAddon )
+	{
+		return;
+	}
+
+	bool rebuildPistol2Addon = false;
+	if ( m_iSecondaryAddon == WEAPON_ELITE && ((m_iLastAddonBits ^ iCurAddonBits) & ADDON_PISTOL) != 0 )
+	{
+		rebuildPistol2Addon = true;
+	}
+	m_iLastAddonBits = iCurAddonBits;
+	m_iLastPrimaryAddon = m_iPrimaryAddon;
+	m_iLastSecondaryAddon = m_iSecondaryAddon;
+
+	// Get rid of any old models.
+	int i,iNext;
+	for ( i=m_AddonModels.Head(); i != m_AddonModels.InvalidIndex(); i = iNext )
+	{
+		iNext = m_AddonModels.Next( i );
+		CAddonModel *pModel = &m_AddonModels[i];
+
+		int addonBit = 1<<pModel->m_iAddon;
+		if ( !( iCurAddonBits & addonBit ) || (rebuildPistol2Addon && addonBit == ADDON_PISTOL2) )
+		{
+			if ( pModel->m_hEnt.Get() )
+				pModel->m_hEnt->Release();
+
+			m_AddonModels.Remove( i );
+		}
+	}
+
+	// Figure out which models we have now.
+	int curModelBits = 0;
+	FOR_EACH_LL( m_AddonModels, j )
+	{
+		curModelBits |= (1<<m_AddonModels[j].m_iAddon);
+	}
+
+	// Add any new models.
+	for ( i=0; i < NUM_ADDON_BITS; i++ )
+	{
+		if ( (iCurAddonBits & (1<<i)) && !( curModelBits & (1<<i) ) )
+		{
+			// Ok, we're supposed to have this one.
+			CreateAddonModel( i );
+		}
+	}
+}
+
+
+void C_CSPlayer::RemoveAddonModels()
+{
+	m_iAddonBits = 0;
+	UpdateAddonModels();
+}
+
+
+void C_CSPlayer::NotifyShouldTransmit( ShouldTransmitState_t state )
+{
+	// Remove all addon models if we go out of the PVS.
+	if ( state == SHOULDTRANSMIT_END )
+	{
+		RemoveAddonModels();
+
+		if( m_pFlashlightBeam != NULL )
+		{
+			ReleaseFlashlight();
+		}
+	}
+
+	BaseClass::NotifyShouldTransmit( state );
+}
+
+
+void C_CSPlayer::UpdateSoundEvents()
+{
+	int iNext;
+	for ( int i=m_SoundEvents.Head(); i != m_SoundEvents.InvalidIndex(); i = iNext )
+	{
+		iNext = m_SoundEvents.Next( i );
+
+		CCSSoundEvent *pEvent = &m_SoundEvents[i];
+		if ( gpGlobals->curtime >= pEvent->m_flEventTime )
+		{
+			CLocalPlayerFilter filter;
+			EmitSound( filter, GetSoundSourceIndex(), STRING( pEvent->m_SoundName ) );
+
+			m_SoundEvents.Remove( i );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void C_CSPlayer::UpdateMinModels( void )
+{
+	int modelIndex = m_nModelIndex;
+
+	// cl_minmodels convar dependent on sv_allowminmodels convar
+
+	if ( !IsVIP() && sv_allowminmodels.GetBool() && cl_minmodels.GetBool() && !IsLocalPlayer() )
+	{
+		if ( GetTeamNumber() == TEAM_CT )
+		{
+			int index = cl_min_ct.GetInt() - 1;
+			if ( index >= 0 && index < CTPlayerModels.Count() )
+			{
+				modelIndex = modelinfo->GetModelIndex( CTPlayerModels[index] );
+			}
+		}
+		else if ( GetTeamNumber() == TEAM_TERRORIST )
+		{
+			int index = cl_min_t.GetInt() - 1;
+			if ( index >= 0 && index < TerroristPlayerModels.Count() )
+			{
+				modelIndex = modelinfo->GetModelIndex( TerroristPlayerModels[index] );
+			}
+		}
+	}
+
+	SetModelByIndex( modelIndex );
+}
+
+// NVNT gate for spectating.
+static bool inSpectating_Haptics = false;
+//-----------------------------------------------------------------------------
+void C_CSPlayer::ClientThink()
+{
+	BaseClass::ClientThink();
+
+	UpdateSoundEvents();
+
+	UpdateAddonModels();
+
+	UpdateIDTarget();
+
+	if ( gpGlobals->curtime >= m_fNextThinkPushAway )
+	{
+		PerformObstaclePushaway( this );
+		m_fNextThinkPushAway =  gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL;
+	}
+
+	// NVNT - check for spectating forces
+	if ( IsLocalPlayer() )
+	{
+		if ( GetTeamNumber() == TEAM_SPECTATOR || !this->IsAlive() || GetLocalOrInEyeCSPlayer() != this )
+		{
+			if (!inSpectating_Haptics)
+			{
+				if ( haptics )
+					haptics->SetNavigationClass("spectate");
+
+				inSpectating_Haptics = true;
+			}
+		}
+		else
+		{
+			if (inSpectating_Haptics)
+			{
+				if ( haptics )
+					haptics->SetNavigationClass("on_foot");
+
+				inSpectating_Haptics = false;
+			}
+		}
+
+		if ( m_iObserverMode == OBS_MODE_FREEZECAM )
+		{
+			//=============================================================================
+			// HPE_BEGIN:
+			// [Forrest] Added sv_disablefreezecam check
+			//=============================================================================
+			static ConVarRef sv_disablefreezecam( "sv_disablefreezecam" );
+			if ( !m_bPlayingFreezeCamSound && !cl_disablefreezecam.GetBool() && !sv_disablefreezecam.GetBool() )
+				//=============================================================================
+				// HPE_END
+				//=============================================================================
+			{
+				// Play sound
+				m_bPlayingFreezeCamSound = true;
+
+				CLocalPlayerFilter filter;
+				EmitSound_t ep;
+				ep.m_nChannel = CHAN_VOICE;
+				ep.m_pSoundName =  "UI/freeze_cam.wav";
+				ep.m_flVolume = VOL_NORM;
+				ep.m_SoundLevel = SNDLVL_NORM;
+				ep.m_bEmitCloseCaption = false;
+
+				EmitSound( filter, GetSoundSourceIndex(), ep );
+			}
+		}
+		else
+		{
+			m_bPlayingFreezeCamSound = false;
+		}
+	}
+}
+
+
+void C_CSPlayer::OnDataChanged( DataUpdateType_t type )
+{
+	BaseClass::OnDataChanged( type );
+
+	if ( type == DATA_UPDATE_CREATED )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+
+		if ( IsLocalPlayer() )
+		{
+			if ( CSGameRules() && CSGameRules()->IsBlackMarket() )
+			{
+				CSGameRules()->m_pPrices = NULL;
+				CSGameRules()->m_StringTableBlackMarket = NULL;
+				CSGameRules()->GetBlackMarketPriceList();
+
+				CSGameRules()->SetBlackMarketPrices( false );
+			}
+		}
+	}
+
+	UpdateVisibility();
+}
+
+
+void C_CSPlayer::ValidateModelIndex( void )
+{
+	UpdateMinModels();
+}
+
+
+void C_CSPlayer::PostDataUpdate( DataUpdateType_t updateType )
+{
+	// C_BaseEntity assumes we're networking the entity's angles, so pretend that it
+	// networked the same value we already have.
+	SetNetworkAngles( GetLocalAngles() );
+
+	BaseClass::PostDataUpdate( updateType );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_CSPlayer::Interpolate( float currentTime )
+{
+	if ( !BaseClass::Interpolate( currentTime ) )
+		return false;
+
+	if ( CSGameRules()->IsFreezePeriod() )
+	{
+		// don't interpolate players position during freeze period
+		SetAbsOrigin( GetNetworkOrigin() );
+	}
+
+	return true;
+}
+
+int	C_CSPlayer::GetMaxHealth() const
+{
+	return 100;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the local player, or the player being spectated in-eye
+//-----------------------------------------------------------------------------
+C_CSPlayer* GetLocalOrInEyeCSPlayer( void )
+{
+	C_CSPlayer *player = C_CSPlayer::GetLocalCSPlayer();
+
+	if( player && player->GetObserverMode() == OBS_MODE_IN_EYE )
+	{
+		C_BaseEntity *target = player->GetObserverTarget();
+
+		if( target && target->IsPlayer() )
+		{
+			return ToCSPlayer( target );
+		}
+	}
+	return player;
+}
+
+#define MAX_FLASHBANG_OPACITY 75.0f
+
+//-----------------------------------------------------------------------------
+// Purpose: Update this client's targetid entity
+//-----------------------------------------------------------------------------
+void C_CSPlayer::UpdateIDTarget()
+{
+	if ( !IsLocalPlayer() )
+		return;
+
+	// Clear old target and find a new one
+	m_iIDEntIndex = 0;
+
+	// don't show IDs if mp_playerid == 2
+	if ( mp_playerid.GetInt() == 2 )
+		return;
+
+	// don't show IDs if mp_fadetoblack is on
+	if ( mp_fadetoblack.GetBool() && !IsAlive() )
+		return;
+
+	// don't show IDs in chase spec mode
+	if ( GetObserverMode() == OBS_MODE_CHASE ||
+		 GetObserverMode() == OBS_MODE_DEATHCAM )
+		 return;
+
+	//Check how much of a screen fade we have.
+	//if it's more than 75 then we can't see what's going on so we don't display the id.
+	byte color[4];
+	bool blend;
+	vieweffects->GetFadeParams( &color[0], &color[1], &color[2], &color[3], &blend );
+
+	if ( color[3] > MAX_FLASHBANG_OPACITY && ( IsAlive() || GetObserverMode() == OBS_MODE_IN_EYE ) )
+		 return;
+
+	trace_t tr;
+	Vector vecStart, vecEnd;
+	VectorMA( MainViewOrigin(), 2500, MainViewForward(), vecEnd );
+	VectorMA( MainViewOrigin(), 10,   MainViewForward(), vecStart );
+	UTIL_TraceLine( vecStart, vecEnd, MASK_VISIBLE_AND_NPCS, GetLocalOrInEyeCSPlayer(), COLLISION_GROUP_NONE, &tr );
+	if ( !tr.startsolid && !tr.DidHitNonWorldEntity() )
+	{
+		CTraceFilterSimple filter( GetLocalOrInEyeCSPlayer(), COLLISION_GROUP_NONE );
+
+		// Check for player hitboxes extending outside their collision bounds
+		const float rayExtension = 40.0f;
+		UTIL_ClipTraceToPlayers(vecStart, vecEnd + MainViewForward() * rayExtension, MASK_SOLID|CONTENTS_HITBOX, &filter, &tr );
+	}
+
+	if ( !tr.startsolid && tr.DidHitNonWorldEntity() )
+	{
+		C_BaseEntity *pEntity = tr.m_pEnt;
+
+		if ( pEntity && (pEntity != this) )
+		{
+			if ( mp_playerid.GetInt() == 1 ) // only show team names
+			{
+				if ( pEntity->GetTeamNumber() != GetTeamNumber() )
+				{
+					return;
+				}
+			}
+
+			//Adrian: If there's a smoke cloud in my way, don't display the name
+			//We check this AFTER we found a player, just so we don't go thru this for nothing.
+			for ( int i = 0; i < m_SmokeGrenades.Count(); i++ )
+			{
+				C_BaseParticleEntity *pSmokeGrenade = (C_BaseParticleEntity*)m_SmokeGrenades.Element( i );
+
+				if ( pSmokeGrenade )
+				{
+					float flHit1, flHit2;
+
+					float flRadius = ( SMOKEGRENADE_PARTICLERADIUS * NUM_PARTICLES_PER_DIMENSION + 1 ) * 0.5f;
+
+					Vector vPos = pSmokeGrenade->GetAbsOrigin();
+
+					/*debugoverlay->AddBoxOverlay( pSmokeGrenade->GetAbsOrigin(), Vector( flRadius, flRadius, flRadius ),
+					 Vector( -flRadius, -flRadius, -flRadius ), QAngle( 0, 0, 0 ), 255, 0, 0, 255, 0.2 );*/
+
+					if ( IntersectInfiniteRayWithSphere( MainViewOrigin(), MainViewForward(), vPos, flRadius, &flHit1, &flHit2 ) )
+					{
+						 return;
+					}
+				}
+			}
+
+			if ( !GetIDTarget() && ( !m_iOldIDEntIndex || m_holdTargetIDTimer.IsElapsed() ) )
+			{
+				// track when we first mouse over the target
+				m_delayTargetIDTimer.Start( mp_playerid_delay.GetFloat() );
+			}
+			m_iIDEntIndex = pEntity->entindex();
+
+			m_iOldIDEntIndex = m_iIDEntIndex;
+			m_holdTargetIDTimer.Start( mp_playerid_hold.GetFloat() );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Input handling
+//-----------------------------------------------------------------------------
+bool C_CSPlayer::CreateMove( float flInputSampleTime, CUserCmd *pCmd )
+{
+	// Bleh... we will wind up needing to access bones for attachments in here.
+	C_BaseAnimating::AutoAllowBoneAccess boneaccess( true, true );
+
+	return BaseClass::CreateMove( flInputSampleTime, pCmd );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Flash this entity on the radar
+//-----------------------------------------------------------------------------
+bool C_CSPlayer::IsInHostageRescueZone()
+{
+	return 	m_bInHostageRescueZone;
+}
+
+CWeaponCSBase* C_CSPlayer::GetActiveCSWeapon() const
+{
+	return dynamic_cast< CWeaponCSBase* >( GetActiveWeapon() );
+}
+
+CWeaponCSBase* C_CSPlayer::GetCSWeapon( CSWeaponID id ) const
+{
+	for (int i=0;i<MAX_WEAPONS;i++)
+	{
+		CBaseCombatWeapon *weapon = GetWeapon( i );
+		if ( weapon )
+		{
+			CWeaponCSBase *csWeapon = dynamic_cast< CWeaponCSBase * >( weapon );
+			if ( csWeapon )
+			{
+				if ( id == csWeapon->GetWeaponID() )
+				{
+					return csWeapon;
+				}
+			}
+		}
+	}
+
+	return NULL;
+}
+
+//REMOVEME
+/*
+void C_CSPlayer::SetFireAnimation( PLAYER_ANIM playerAnim )
+{
+	Activity idealActivity = ACT_WALK;
+
+	// Figure out stuff about the current state.
+	float speed = GetAbsVelocity().Length2D();
+	bool isMoving = ( speed != 0.0f ) ? true : false;
+	bool isDucked = ( GetFlags() & FL_DUCKING ) ? true : false;
+	bool isStillJumping = false; //!( GetFlags() & FL_ONGROUND );
+	bool isRunning = false;
+
+	if ( speed > ARBITRARY_RUN_SPEED )
+	{
+		isRunning = true;
+	}
+
+	// Now figure out what to do based on the current state and the new state.
+	switch ( playerAnim )
+	{
+	default:
+	case PLAYER_RELOAD:
+	case PLAYER_ATTACK1:
+	case PLAYER_IDLE:
+	case PLAYER_WALK:
+		// Are we still jumping?
+		// If so, keep playing the jump animation.
+		if ( !isStillJumping )
+		{
+			idealActivity = ACT_WALK;
+
+			if ( isDucked )
+			{
+				idealActivity = !isMoving ? ACT_CROUCHIDLE : ACT_RUN_CROUCH;
+			}
+			else
+			{
+				if ( isRunning )
+				{
+					idealActivity = ACT_RUN;
+				}
+				else
+				{
+					idealActivity = isMoving ? ACT_WALK : ACT_IDLE;
+				}
+			}
+
+			// Allow body yaw to override for standing and turning in place
+			idealActivity = m_PlayerAnimState.BodyYawTranslateActivity( idealActivity );
+		}
+		break;
+
+	case PLAYER_JUMP:
+		idealActivity = ACT_HOP;
+		break;
+
+	case PLAYER_DIE:
+		// Uses Ragdoll now???
+		idealActivity = ACT_DIESIMPLE;
+		break;
+
+	// FIXME:  Use overlays for reload, start/leave aiming, attacking
+	case PLAYER_START_AIMING:
+	case PLAYER_LEAVE_AIMING:
+		idealActivity = ACT_WALK;
+		break;
+	}
+
+	CWeaponCSBase *pWeapon = GetActiveCSWeapon();
+
+	if ( pWeapon )
+	{
+		Activity aWeaponActivity = idealActivity;
+
+		if ( playerAnim == PLAYER_ATTACK1 )
+		{
+			switch ( idealActivity )
+			{
+				case ACT_WALK:
+				default:
+					aWeaponActivity = ACT_PLAYER_WALK_FIRE;
+					break;
+				case ACT_RUN:
+					aWeaponActivity = ACT_PLAYER_RUN_FIRE;
+					break;
+				case ACT_IDLE:
+					aWeaponActivity = ACT_PLAYER_IDLE_FIRE;
+					break;
+				case ACT_CROUCHIDLE:
+					aWeaponActivity = ACT_PLAYER_CROUCH_FIRE;
+					break;
+				case ACT_RUN_CROUCH:
+					aWeaponActivity = ACT_PLAYER_CROUCH_WALK_FIRE;
+					break;
+			}
+		}
+
+		m_PlayerAnimState.SetWeaponLayerSequence( pWeapon->GetCSWpnData().m_szAnimExtension, aWeaponActivity );
+	}
+}
+*/
+
+ShadowType_t C_CSPlayer::ShadowCastType( void )
+{
+	if ( !IsVisible() )
+		 return SHADOWS_NONE;
+
+	return SHADOWS_RENDER_TO_TEXTURE_DYNAMIC;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether or not we can switch to the given weapon.
+// Input  : pWeapon -
+//-----------------------------------------------------------------------------
+bool C_CSPlayer::Weapon_CanSwitchTo( CBaseCombatWeapon *pWeapon )
+{
+	if ( !pWeapon->CanDeploy() )
+		return false;
+
+	if ( GetActiveWeapon() )
+	{
+		if ( !GetActiveWeapon()->CanHolster() )
+			return false;
+	}
+
+	return true;
+}
+
+
+void C_CSPlayer::UpdateClientSideAnimation()
+{
+	// We do this in a different order than the base class.
+	// We need our cycle to be valid for when we call the playeranimstate update code,
+	// or else it'll synchronize the upper body anims with the wrong cycle.
+	if ( GetSequence() != -1 )
+	{
+		// move frame forward
+		FrameAdvance( 0.0f ); // 0 means to use the time we last advanced instead of a constant
+	}
+
+	// Update the animation data. It does the local check here so this works when using
+	// a third-person camera (and we don't have valid player angles).
+	if ( this == C_CSPlayer::GetLocalCSPlayer() )
+		m_PlayerAnimState->Update( EyeAngles()[YAW], m_angEyeAngles[PITCH] );
+	else
+		m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );
+
+	if ( GetSequence() != -1 )
+	{
+		// latch old values
+		OnLatchInterpolatedVariables( LATCH_ANIMATION_VAR );
+	}
+}
+
+
+float g_flMuzzleFlashScale=1;
+
+void C_CSPlayer::ProcessMuzzleFlashEvent()
+{
+	CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+
+	// Reenable when the weapons have muzzle flash attachments in the right spot.
+	if ( this == pLocalPlayer )
+		return; // don't show own world muzzle flashs in for localplayer
+
+	if ( pLocalPlayer && pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
+	{
+		// also don't show in 1st person spec mode
+		if ( pLocalPlayer->GetObserverTarget() == this )
+			return;
+	}
+
+	CWeaponCSBase *pWeapon = GetActiveCSWeapon();
+
+	if ( !pWeapon )
+		return;
+
+	bool hasMuzzleFlash = (pWeapon->GetMuzzleFlashStyle() != CS_MUZZLEFLASH_NONE);
+
+	Vector vector;
+	QAngle angles;
+
+	int iAttachment = LookupAttachment( "muzzle_flash" );
+
+	if ( iAttachment >= 0 )
+	{
+		bool bFoundAttachment = GetAttachment( iAttachment, vector, angles );
+		// If we have an attachment, then stick a light on it.
+		if ( bFoundAttachment )
+		{
+			if ( hasMuzzleFlash )
+			{
+				dlight_t *el = effects->CL_AllocDlight( LIGHT_INDEX_MUZZLEFLASH + index );
+				el->origin = vector;
+				el->radius = 70;
+				el->decay = el->radius / 0.05f;
+				el->die = gpGlobals->curtime + 0.05f;
+				el->color.r = 255;
+				el->color.g = 192;
+				el->color.b = 64;
+				el->color.exponent = 5;
+			}
+
+			int shellType = GetShellForAmmoType( pWeapon->GetCSWpnData().szAmmo1 );
+
+			QAngle playerAngle = EyeAngles();
+			Vector vForward, vRight, vUp;
+
+			AngleVectors( playerAngle, &vForward, &vRight, &vUp );
+
+			QAngle angVelocity;
+			Vector vVel = vRight * 100 + vUp * 20;
+			VectorAngles( vVel, angVelocity );
+
+			if ( pWeapon->GetMaxClip1() > 0 )
+			{
+				tempents->CSEjectBrass( vector, angVelocity, 120, shellType, this  );
+			}
+		}
+	}
+
+	if ( hasMuzzleFlash )
+	{
+		iAttachment = pWeapon->GetMuzzleAttachment();
+
+		if ( iAttachment > 0 )
+		{
+			float flScale = pWeapon->GetCSWpnData().m_flMuzzleScale;
+			flScale *= 0.75;
+			FX_MuzzleEffectAttached( flScale, pWeapon->GetRefEHandle(), iAttachment, NULL, false );
+
+		}
+	}
+}
+
+const QAngle& C_CSPlayer::EyeAngles()
+{
+	if ( IsLocalPlayer() && !g_nKillCamMode )
+	{
+		return BaseClass::EyeAngles();
+	}
+	else
+	{
+		return m_angEyeAngles;
+	}
+}
+
+bool C_CSPlayer::ShouldDraw( void )
+{
+	// If we're dead, our ragdoll will be drawn for us instead.
+	if ( !IsAlive() )
+		return false;
+
+	if( GetTeamNumber() == TEAM_SPECTATOR )
+		return false;
+
+	if( IsLocalPlayer() )
+	{
+		if ( IsRagdoll() )
+			return true;
+	}
+
+	return BaseClass::ShouldDraw();
+}
+
+
+bool FindWeaponAttachmentBone( C_BaseCombatWeapon *pWeapon, int &iWeaponBone )
+{
+	if ( !pWeapon )
+		return false;
+
+	CStudioHdr *pHdr = pWeapon->GetModelPtr();
+	if ( !pHdr )
+		return false;
+
+	for ( iWeaponBone=0; iWeaponBone < pHdr->numbones(); iWeaponBone++ )
+	{
+		if ( stricmp( pHdr->pBone( iWeaponBone )->pszName(), "L_Hand_Attach" ) == 0 )
+			break;
+	}
+
+	return iWeaponBone != pHdr->numbones();
+}
+
+
+bool FindMyAttachmentBone( C_BaseAnimating *pModel, int &iBone, CStudioHdr *pHdr )
+{
+	if ( !pHdr )
+		return false;
+
+	for ( iBone=0; iBone < pHdr->numbones(); iBone++ )
+	{
+		if ( stricmp( pHdr->pBone( iBone )->pszName(), "Valvebiped.Bip01_L_Hand" ) == 0 )
+			break;
+	}
+
+	return iBone != pHdr->numbones();
+}
+
+
+inline bool IsBoneChildOf( CStudioHdr *pHdr, int iBone, int iParent )
+{
+	if ( iBone == iParent )
+		return false;
+
+	while ( iBone != -1 )
+	{
+		if ( iBone == iParent )
+			return true;
+
+		iBone = pHdr->pBone( iBone )->parent;
+	}
+	return false;
+}
+
+void ApplyDifferenceTransformToChildren(
+	C_BaseAnimating *pModel,
+	const matrix3x4_t &mSource,
+	const matrix3x4_t &mDest,
+	int iParentBone )
+{
+	CStudioHdr *pHdr = pModel->GetModelPtr();
+	if ( !pHdr )
+		return;
+
+	// Build a matrix to go from mOriginalHand to mHand.
+	// ( mDest * Inverse( mSource ) ) * mSource = mDest
+	matrix3x4_t mSourceInverse, mToDest;
+	MatrixInvert( mSource, mSourceInverse );
+	ConcatTransforms( mDest, mSourceInverse, mToDest );
+
+	// Now multiply iMyBone and all its children by mToWeaponBone.
+	for ( int i=0; i < pHdr->numbones(); i++ )
+	{
+		if ( IsBoneChildOf( pHdr, i, iParentBone ) )
+		{
+			matrix3x4_t &mCur = pModel->GetBoneForWrite( i );
+			matrix3x4_t mNew;
+			ConcatTransforms( mToDest, mCur, mNew );
+			mCur = mNew;
+		}
+	}
+}
+
+
+void GetCorrectionMatrices(
+	const matrix3x4_t &mShoulder,
+	const matrix3x4_t &mElbow,
+	const matrix3x4_t &mHand,
+	matrix3x4_t &mShoulderCorrection,
+	matrix3x4_t &mElbowCorrection
+	)
+{
+	extern void Studio_AlignIKMatrix( matrix3x4_t &mMat, const Vector &vAlignTo );
+
+	// Get the positions of each node so we can get the direction vectors.
+	Vector vShoulder, vElbow, vHand;
+	MatrixPosition( mShoulder, vShoulder );
+	MatrixPosition( mElbow, vElbow );
+	MatrixPosition( mHand, vHand );
+
+	// Get rid of the translation.
+	matrix3x4_t mOriginalShoulder = mShoulder;
+	matrix3x4_t mOriginalElbow = mElbow;
+	MatrixSetColumn( Vector( 0, 0, 0 ), 3, mOriginalShoulder );
+	MatrixSetColumn( Vector( 0, 0, 0 ), 3, mOriginalElbow );
+
+	// Let the IK code align them like it would if we did IK on the joint.
+	matrix3x4_t mAlignedShoulder = mOriginalShoulder;
+	matrix3x4_t mAlignedElbow = mOriginalElbow;
+	Studio_AlignIKMatrix( mAlignedShoulder, vElbow-vShoulder );
+	Studio_AlignIKMatrix( mAlignedElbow, vHand-vElbow );
+
+	// Figure out the transformation from the aligned bones to the original ones.
+	matrix3x4_t mInvAlignedShoulder, mInvAlignedElbow;
+	MatrixInvert( mAlignedShoulder, mInvAlignedShoulder );
+	MatrixInvert( mAlignedElbow, mInvAlignedElbow );
+
+	ConcatTransforms( mInvAlignedShoulder, mOriginalShoulder, mShoulderCorrection );
+	ConcatTransforms( mInvAlignedElbow, mOriginalElbow, mElbowCorrection );
+}
+
+
+void C_CSPlayer::BuildTransformations( CStudioHdr *pHdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed )
+{
+	// First, setup our model's transformations like normal.
+	BaseClass::BuildTransformations( pHdr, pos, q, cameraTransform, boneMask, boneComputed );
+
+	if ( IsLocalPlayer() && !C_BasePlayer::ShouldDrawLocalPlayer() )
+		return;
+
+	if ( !cl_left_hand_ik.GetInt() )
+		return;
+
+	// If our current weapon has a bone named L_Hand_Attach, then we attach the player's
+	// left hand (Valvebiped.Bip01_L_Hand) to it.
+	C_BaseCombatWeapon *pWeapon = GetActiveWeapon();
+
+	if ( !pWeapon )
+		return;
+
+	// Have the weapon setup its bones.
+	pWeapon->SetupBones( NULL, 0, BONE_USED_BY_ANYTHING, gpGlobals->curtime );
+
+	int iWeaponBone = 0;
+	if ( FindWeaponAttachmentBone( pWeapon, iWeaponBone ) )
+	{
+		int iMyBone = 0;
+		if ( FindMyAttachmentBone( this, iMyBone, pHdr ) )
+		{
+			int iHand = iMyBone;
+			int iElbow = pHdr->pBone( iHand )->parent;
+			int iShoulder = pHdr->pBone( iElbow )->parent;
+			matrix3x4_t *pBones = &GetBoneForWrite( 0 );
+
+			// Store off the original hand position.
+			matrix3x4_t mSource = pBones[iHand];
+
+
+			// Figure out the rotation offset from the current shoulder and elbow bone rotations
+			// and what the IK code's alignment code is going to produce, because we'll have to
+			// re-apply that offset after the IK runs.
+			matrix3x4_t mShoulderCorrection, mElbowCorrection;
+			GetCorrectionMatrices( pBones[iShoulder], pBones[iElbow], pBones[iHand], mShoulderCorrection, mElbowCorrection );
+
+
+			// Do the IK solution.
+			Vector vHandTarget;
+			MatrixPosition( pWeapon->GetBone( iWeaponBone ), vHandTarget );
+			Studio_SolveIK( iShoulder, iElbow, iHand, vHandTarget, pBones );
+
+
+			// Now reapply the rotation correction.
+			matrix3x4_t mTempShoulder = pBones[iShoulder];
+			matrix3x4_t mTempElbow = pBones[iElbow];
+			ConcatTransforms( mTempShoulder, mShoulderCorrection, pBones[iShoulder] );
+			ConcatTransforms( mTempElbow, mElbowCorrection, pBones[iElbow] );
+
+
+			// Now apply the transformation on the hand to the fingers.
+			matrix3x4_t &mDest = GetBoneForWrite( iHand );
+			ApplyDifferenceTransformToChildren( this, mSource, mDest, iHand );
+		}
+	}
+}
+
+
+C_BaseAnimating * C_CSPlayer::BecomeRagdollOnClient()
+{
+	return NULL;
+}
+
+
+IRagdoll* C_CSPlayer::GetRepresentativeRagdoll() const
+{
+	if ( m_hRagdoll.Get() )
+	{
+		C_CSRagdoll *pRagdoll = (C_CSRagdoll*)m_hRagdoll.Get();
+
+		return pRagdoll->GetIRagdoll();
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+
+void C_CSPlayer::PlayReloadEffect()
+{
+	// Only play the effect for other players.
+	if ( this == C_CSPlayer::GetLocalCSPlayer() )
+	{
+		Assert( false ); // We shouldn't have been sent this message.
+		return;
+	}
+
+	// Get the view model for our current gun.
+	CWeaponCSBase *pWeapon = GetActiveCSWeapon();
+	if ( !pWeapon )
+		return;
+
+	// The weapon needs two models, world and view, but can only cache one. Synthesize the other.
+	const CCSWeaponInfo &info = pWeapon->GetCSWpnData();
+	const model_t *pModel = modelinfo->GetModel( modelinfo->GetModelIndex( info.szViewModel ) );
+	if ( !pModel )
+		return;
+	CStudioHdr studioHdr( modelinfo->GetStudiomodel( pModel ), mdlcache );
+	if ( !studioHdr.IsValid() )
+		return;
+
+	// Find the reload animation.
+	for ( int iSeq=0; iSeq < studioHdr.GetNumSeq(); iSeq++ )
+	{
+		mstudioseqdesc_t *pSeq = &studioHdr.pSeqdesc( iSeq );
+
+		if ( pSeq->activity == ACT_VM_RELOAD )
+		{
+			float poseParameters[MAXSTUDIOPOSEPARAM];
+			memset( poseParameters, 0, sizeof( poseParameters ) );
+			float cyclesPerSecond = Studio_CPS( &studioHdr, *pSeq, iSeq, poseParameters );
+
+			// Now read out all the sound events with their timing
+			for ( int iEvent=0; iEvent < pSeq->numevents; iEvent++ )
+			{
+				mstudioevent_t *pEvent = pSeq->pEvent( iEvent );
+
+				if ( pEvent->event == CL_EVENT_SOUND )
+				{
+					CCSSoundEvent event;
+					event.m_SoundName = pEvent->options;
+					event.m_flEventTime = gpGlobals->curtime + pEvent->cycle / cyclesPerSecond;
+					m_SoundEvents.AddToTail( event );
+				}
+			}
+
+			break;
+		}
+	}
+}
+
+void C_CSPlayer::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
+{
+	if ( event == PLAYERANIMEVENT_THROW_GRENADE )
+	{
+		// Let the server handle this event. It will update m_iThrowGrenadeCounter and the client will
+		// pick up the event in CCSPlayerAnimState.
+	}
+	else
+	{
+		m_PlayerAnimState->DoAnimationEvent( event, nData );
+	}
+}
+
+void C_CSPlayer::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
+{
+	if( event == 7001 )
+	{
+		bool bInWater = ( enginetrace->GetPointContents(origin) & CONTENTS_WATER );
+
+		//Msg( "run event ( %d )\n", bInWater ? 1 : 0 );
+
+		if( bInWater )
+		{
+			//run splash
+			CEffectData data;
+
+			//trace up from foot position to the water surface
+			trace_t tr;
+			Vector vecTrace(0,0,1024);
+			UTIL_TraceLine( origin, origin + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr );
+			if ( tr.fractionleftsolid )
+			{
+				data.m_vOrigin = origin + (vecTrace * tr.fractionleftsolid);
+			}
+			else
+			{
+				data.m_vOrigin = origin;
+			}
+
+			data.m_vNormal = Vector( 0,0,1 );
+			data.m_flScale = random->RandomFloat( 4.0f, 5.0f );
+			DispatchEffect( "watersplash", data );
+		}
+	}
+	else if( event == 7002 )
+	{
+		bool bInWater = ( enginetrace->GetPointContents(origin) & CONTENTS_WATER );
+
+		//Msg( "walk event ( %d )\n", bInWater ? 1 : 0 );
+
+		if( bInWater )
+		{
+			//walk ripple
+			CEffectData data;
+
+			//trace up from foot position to the water surface
+			trace_t tr;
+			Vector vecTrace(0,0,1024);
+			UTIL_TraceLine( origin, origin + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr );
+			if ( tr.fractionleftsolid )
+			{
+				data.m_vOrigin = origin + (vecTrace * tr.fractionleftsolid);
+			}
+			else
+			{
+				data.m_vOrigin = origin;
+			}
+
+			data.m_vNormal = Vector( 0,0,1 );
+			data.m_flScale = random->RandomFloat( 4.0f, 7.0f );
+			DispatchEffect( "waterripple", data );
+		}
+	}
+	else
+		BaseClass::FireEvent( origin, angles, event, options );
+}
+
+
+void C_CSPlayer::SetActivity( Activity eActivity )
+{
+	m_Activity = eActivity;
+}
+
+
+Activity C_CSPlayer::GetActivity() const
+{
+	return m_Activity;
+}
+
+
+const Vector& C_CSPlayer::GetRenderOrigin( void )
+{
+	if ( m_hRagdoll.Get() )
+	{
+		C_CSRagdoll *pRagdoll = (C_CSRagdoll*)m_hRagdoll.Get();
+		if ( pRagdoll->IsInitialized() )
+			return pRagdoll->GetRenderOrigin();
+	}
+
+	return BaseClass::GetRenderOrigin();
+}
+
+
+void C_CSPlayer::Simulate( void )
+{
+	if( this != C_BasePlayer::GetLocalPlayer() )
+	{
+		if ( IsEffectActive( EF_DIMLIGHT ) )
+		{
+			QAngle eyeAngles = EyeAngles();
+			Vector vForward;
+			AngleVectors( eyeAngles, &vForward );
+
+			int iAttachment = LookupAttachment( "muzzle_flash" );
+
+			if ( iAttachment < 0 )
+				return;
+
+			Vector vecOrigin;
+			QAngle dummy;
+			GetAttachment( iAttachment, vecOrigin, dummy );
+
+			trace_t tr;
+			UTIL_TraceLine( vecOrigin, vecOrigin + (vForward * 200), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+
+			if( !m_pFlashlightBeam )
+			{
+				BeamInfo_t beamInfo;
+				beamInfo.m_nType = TE_BEAMPOINTS;
+				beamInfo.m_vecStart = tr.startpos;
+				beamInfo.m_vecEnd = tr.endpos;
+				beamInfo.m_pszModelName = "sprites/glow01.vmt";
+				beamInfo.m_pszHaloName = "sprites/glow01.vmt";
+				beamInfo.m_flHaloScale = 3.0;
+				beamInfo.m_flWidth = 8.0f;
+				beamInfo.m_flEndWidth = 35.0f;
+				beamInfo.m_flFadeLength = 300.0f;
+				beamInfo.m_flAmplitude = 0;
+				beamInfo.m_flBrightness = 60.0;
+				beamInfo.m_flSpeed = 0.0f;
+				beamInfo.m_nStartFrame = 0.0;
+				beamInfo.m_flFrameRate = 0.0;
+				beamInfo.m_flRed = 255.0;
+				beamInfo.m_flGreen = 255.0;
+				beamInfo.m_flBlue = 255.0;
+				beamInfo.m_nSegments = 8;
+				beamInfo.m_bRenderable = true;
+				beamInfo.m_flLife = 0.5;
+				beamInfo.m_nFlags = FBEAM_FOREVER | FBEAM_ONLYNOISEONCE | FBEAM_NOTILE | FBEAM_HALOBEAM;
+
+				m_pFlashlightBeam = beams->CreateBeamPoints( beamInfo );
+			}
+
+			if( m_pFlashlightBeam )
+			{
+				BeamInfo_t beamInfo;
+				beamInfo.m_vecStart = tr.startpos;
+				beamInfo.m_vecEnd = tr.endpos;
+				beamInfo.m_flRed = 255.0;
+				beamInfo.m_flGreen = 255.0;
+				beamInfo.m_flBlue = 255.0;
+
+				beams->UpdateBeamInfo( m_pFlashlightBeam, beamInfo );
+
+				dlight_t *el = effects->CL_AllocDlight( 0 );
+				el->origin = tr.endpos;
+				el->radius = 50;
+				el->color.r = 200;
+				el->color.g = 200;
+				el->color.b = 200;
+				el->die = gpGlobals->curtime + 0.1;
+			}
+		}
+		else if ( m_pFlashlightBeam )
+		{
+			ReleaseFlashlight();
+		}
+	}
+
+	BaseClass::Simulate();
+}
+
+void C_CSPlayer::ReleaseFlashlight( void )
+{
+	if( m_pFlashlightBeam )
+	{
+		m_pFlashlightBeam->flags = 0;
+		m_pFlashlightBeam->die = gpGlobals->curtime - 1;
+
+		m_pFlashlightBeam = NULL;
+	}
+}
+
+bool C_CSPlayer::HasC4( void )
+{
+	if( this == C_CSPlayer::GetLocalPlayer() )
+	{
+		return Weapon_OwnsThisType( "weapon_c4" );
+	}
+	else
+	{
+		C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+
+		return pCSPR->HasC4( entindex() );
+	}
+}
+
+void C_CSPlayer::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
+{
+	static ConVar *violence_hblood = cvar->FindVar( "violence_hblood" );
+	if ( violence_hblood && !violence_hblood->GetBool() )
+		return;
+
+	BaseClass::ImpactTrace( pTrace, iDamageType, pCustomImpactName );
+}
+
+
+//-----------------------------------------------------------------------------
+void C_CSPlayer::CalcObserverView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
+{
+	/**
+	 * TODO: Fix this!
+	// CS:S standing eyeheight is above the collision volume, so we need to pull it
+	// down when we go into close quarters.
+	float maxEyeHeightAboveBounds = VEC_VIEW_SCALED( this ).z - VEC_HULL_MAX_SCALED( this ).z;
+	if ( GetObserverMode() == OBS_MODE_IN_EYE &&
+		maxEyeHeightAboveBounds > 0.0f &&
+		GetObserverTarget() &&
+		GetObserverTarget()->IsPlayer() )
+	{
+		const float eyeClearance = 12.0f; // eye pos must be this far below the ceiling
+
+		C_CSPlayer *target = ToCSPlayer( GetObserverTarget() );
+
+		Vector offset = eyeOrigin - GetAbsOrigin();
+
+		Vector vHullMin = VEC_HULL_MIN_SCALED( this );
+		vHullMin.z = 0.0f;
+		Vector vHullMax = VEC_HULL_MAX_SCALED( this );
+
+		Vector start = GetAbsOrigin();
+		start.z += vHullMax.z;
+		Vector end = start;
+		end.z += eyeClearance + VEC_VIEW_SCALED( this ).z - vHullMax_SCALED( this ).z;
+
+		vHullMax.z = 0.0f;
+
+		Vector fudge( 1, 1, 0 );
+		vHullMin += fudge;
+		vHullMax -= fudge;
+
+		trace_t trace;
+		Ray_t ray;
+		ray.Init( start, end, vHullMin, vHullMax );
+		UTIL_TraceRay( ray, MASK_PLAYERSOLID, target, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
+
+		if ( trace.fraction < 1.0f )
+		{
+			float est = start.z + trace.fraction * (end.z - start.z) - GetAbsOrigin().z - eyeClearance;
+			if ( ( target->GetFlags() & FL_DUCKING ) == 0 && !target->GetFallVelocity() && !target->IsDucked() )
+			{
+				offset.z = est;
+			}
+			else
+			{
+				offset.z = MIN( est, offset.z );
+			}
+			eyeOrigin.z = GetAbsOrigin().z + offset.z;
+		}
+	}
+	*/
+
+	BaseClass::CalcObserverView( eyeOrigin, eyeAngles, fov );
+}
+
+//=============================================================================
+// HPE_BEGIN:
+//=============================================================================
+// [tj] checks if this player has another given player on their Steam friends list.
+bool C_CSPlayer::HasPlayerAsFriend(C_CSPlayer* player)
+{
+    if (!steamapicontext || !steamapicontext->SteamFriends() || !steamapicontext->SteamUtils() || !player)
+    {
+        return false;
+    }
+
+    player_info_t pi;
+    if ( !engine->GetPlayerInfo( player->entindex(), &pi ) )
+    {
+        return false;
+    }
+
+    if ( !pi.friendsID )
+    {
+        return false;
+    }
+
+    // check and see if they're on the local player's friends list
+    CSteamID steamID( pi.friendsID, 1, steamapicontext->SteamUtils()->GetConnectedUniverse(), k_EAccountTypeIndividual );
+    return steamapicontext->SteamFriends()->HasFriend( steamID, k_EFriendFlagImmediate);
+}
+
+// [menglish] Returns whether this player is dominating or is being dominated by the specified player
+bool C_CSPlayer::IsPlayerDominated( int iPlayerIndex )
+{
+	return m_bPlayerDominated.Get( iPlayerIndex );
+}
+
+bool C_CSPlayer::IsPlayerDominatingMe( int iPlayerIndex )
+{
+	return m_bPlayerDominatingMe.Get( iPlayerIndex );
+}
+
+
+// helper interpolation functions
+namespace Interpolators
+{
+	inline float Linear( float t ) { return t; }
+
+	inline float SmoothStep( float t )
+	{
+		t = 3 * t * t - 2.0f * t * t * t;
+		return t;
+	}
+
+	inline float SmoothStep2( float t )
+	{
+		return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
+	}
+
+	inline float SmoothStepStart( float t )
+	{
+		t = 0.5f * t;
+		t = 3 * t * t - 2.0f * t * t * t;
+		t = t* 2.0f;
+		return t;
+	}
+
+	inline float SmoothStepEnd( float t )
+	{
+		t = 0.5f * t + 0.5f;
+		t = 3 * t * t - 2.0f * t * t * t;
+		t = (t - 0.5f) * 2.0f;
+		return t;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculate the view for the player while he's in freeze frame observer mode
+//-----------------------------------------------------------------------------
+void C_CSPlayer::CalcFreezeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
+{
+	C_BaseEntity *pTarget = GetObserverTarget();
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [Forrest] Added sv_disablefreezecam check
+	//=============================================================================
+	static ConVarRef sv_disablefreezecam( "sv_disablefreezecam" );
+	if ( !pTarget || cl_disablefreezecam.GetBool() || sv_disablefreezecam.GetBool() )
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	{
+		return CalcDeathCamView( eyeOrigin, eyeAngles, fov );
+	}
+
+	// pick a zoom camera target
+	Vector vLookAt = pTarget->GetObserverCamOrigin();	// Returns ragdoll origin if they're ragdolled
+	vLookAt += GetChaseCamViewOffset( pTarget );
+
+	// look over ragdoll, not through
+	if ( !pTarget->IsAlive() )
+		vLookAt.z += pTarget->GetBaseAnimating() ? VEC_DEAD_VIEWHEIGHT_SCALED( pTarget->GetBaseAnimating() ).z : VEC_DEAD_VIEWHEIGHT.z;
+
+	// Figure out a view position in front of the target
+	Vector vEyeOnPlane = eyeOrigin;
+	vEyeOnPlane.z = vLookAt.z;
+	Vector vToTarget = vLookAt - vEyeOnPlane;
+	VectorNormalize( vToTarget );
+
+	// goal position of camera is pulled away from target by m_flFreezeFrameDistance
+	Vector vTargetPos = vLookAt - (vToTarget * m_flFreezeFrameDistance);
+
+	// Now trace out from the target, so that we're put in front of any walls
+	trace_t trace;
+	C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
+	UTIL_TraceHull( vLookAt, vTargetPos, WALL_MIN, WALL_MAX, MASK_SOLID, pTarget, COLLISION_GROUP_NONE, &trace );
+	C_BaseEntity::PopEnableAbsRecomputations();
+	if ( trace.fraction < 1.0 )
+	{
+		// The camera's going to be really close to the target. So we don't end up
+		// looking at someone's chest, aim close freezecams at the target's eyes.
+		vTargetPos = trace.endpos;
+
+		// To stop all close in views looking up at character's chins, move the view up.
+		vTargetPos.z += fabs(vLookAt.z - vTargetPos.z) * 0.85;
+		C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
+		UTIL_TraceHull( vLookAt, vTargetPos, WALL_MIN, WALL_MAX, MASK_SOLID, pTarget, COLLISION_GROUP_NONE, &trace );
+		C_BaseEntity::PopEnableAbsRecomputations();
+		vTargetPos = trace.endpos;
+	}
+
+	// Look directly at the target
+	vToTarget = vLookAt - vTargetPos;
+	VectorNormalize( vToTarget );
+	VectorAngles( vToTarget, eyeAngles );
+
+	float fCurTime = gpGlobals->curtime - m_flFreezeFrameStartTime;
+	float fInterpolant = clamp( fCurTime / spec_freeze_traveltime.GetFloat(), 0.0f, 1.0f );
+	fInterpolant = Interpolators::SmoothStepEnd( fInterpolant );
+
+	// move the eye toward our killer
+	VectorLerp( m_vecFreezeFrameStart, vTargetPos, fInterpolant, eyeOrigin );
+
+	if ( fCurTime >= spec_freeze_traveltime.GetFloat() && !m_bSentFreezeFrame )
+	{
+		IGameEvent *pEvent = gameeventmanager->CreateEvent( "freezecam_started" );
+		if ( pEvent )
+		{
+			gameeventmanager->FireEventClientSide( pEvent );
+		}
+
+		m_bSentFreezeFrame = true;
+		view->FreezeFrame( spec_freeze_time.GetFloat() );
+	}
+}
+
+float C_CSPlayer::GetDeathCamInterpolationTime()
+{
+	static ConVarRef sv_disablefreezecam( "sv_disablefreezecam" );
+	if ( cl_disablefreezecam.GetBool() || sv_disablefreezecam.GetBool() || !GetObserverTarget() )
+		return spec_freeze_time.GetFloat();
+	else
+		return CS_DEATH_ANIMATION_TIME;
+
+}
+
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
diff --git a/game/client/cstrike/c_cs_player.h b/game/client/cstrike/c_cs_player.h
new file mode 100644
index 00000000..0d50a20b
--- /dev/null
+++ b/game/client/cstrike/c_cs_player.h
@@ -0,0 +1,419 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#ifndef C_CS_PLAYER_H
+#define C_CS_PLAYER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "cs_playeranimstate.h"
+#include "c_baseplayer.h"
+#include "cs_shareddefs.h"
+#include "weapon_csbase.h"
+#include "baseparticleentity.h"
+#include "beamdraw.h"
+
+
+class C_PhysicsProp;
+
+extern ConVar cl_disablefreezecam;
+
+class CAddonModel
+{
+public:
+	CHandle<C_BaseAnimating> m_hEnt;	// The model for the addon.
+	int m_iAddon;						// One of the ADDON_ bits telling which model this is.
+	int m_iAttachmentPoint;				// Which attachment point on the player model this guy is on.
+};
+
+
+
+class C_CSPlayer : public C_BasePlayer, public ICSPlayerAnimStateHelpers
+{
+public:
+	DECLARE_CLASS( C_CSPlayer, C_BasePlayer );
+	DECLARE_CLIENTCLASS();
+	DECLARE_PREDICTABLE();
+	DECLARE_INTERPOLATION();
+
+	C_CSPlayer();
+	~C_CSPlayer();
+
+	virtual void Simulate();
+
+	bool HasDefuser() const;
+
+	void GiveDefuser();
+	void RemoveDefuser();
+
+	bool HasNightVision() const;
+
+	static C_CSPlayer* GetLocalCSPlayer();
+	CSPlayerState State_Get() const;
+
+	virtual float GetMinFOV() const;
+
+	// Get how much $$$ this guy has.
+	int GetAccount() const;
+
+	// Returns one of the CS_CLASS_ enums.
+	int PlayerClass() const;
+
+	bool IsInBuyZone();
+	bool CanShowTeamMenu() const;	// Returns true if we're allowed to show the team menu right now.
+
+	// Get the amount of armor the player has.
+	int ArmorValue() const;
+	bool HasHelmet() const;
+	int GetCurrentAssaultSuitPrice();
+
+	virtual const QAngle& EyeAngles();
+	virtual const QAngle& GetRenderAngles();
+	virtual void CalcObserverView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov );
+
+	virtual void			GetRenderBounds( Vector& theMins, Vector& theMaxs );
+	virtual void			GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType );
+	virtual bool			GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const;
+
+	virtual void VPhysicsUpdate( IPhysicsObject *pPhysics );
+
+	// Get the ID target entity index. The ID target is the player that is behind our crosshairs, used to
+	// display the player's name.
+	int GetIDTarget() const;
+
+	virtual void NotifyShouldTransmit( ShouldTransmitState_t state );
+	virtual void ClientThink();
+
+	virtual void OnDataChanged( DataUpdateType_t type );
+	virtual void PostDataUpdate( DataUpdateType_t updateType );
+	virtual bool Interpolate( float currentTime );
+	virtual void UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity  );
+	virtual surfacedata_t * GetFootstepSurface( const Vector &origin, const char *surfaceName );
+	virtual void ValidateModelIndex( void );
+
+	virtual int	GetMaxHealth() const;
+
+	bool		Weapon_CanSwitchTo(C_BaseCombatWeapon *pWeapon);
+
+	virtual void UpdateClientSideAnimation();
+	virtual void ProcessMuzzleFlashEvent();
+
+	virtual const Vector& GetRenderOrigin( void );
+
+	bool CreateMove( float flInputSampleTime, CUserCmd *pCmd );
+
+	CUtlVector< C_BaseParticleEntity* > m_SmokeGrenades;
+
+	virtual bool ShouldDraw( void );
+	virtual void BuildTransformations( CStudioHdr *pStudioHdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed );
+
+	virtual C_BaseAnimating * BecomeRagdollOnClient();
+	virtual IRagdoll* GetRepresentativeRagdoll() const;
+
+	void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName );
+
+	// Have this player play the sounds from his view model's reload animation.
+	void PlayReloadEffect();
+
+	virtual void FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options );
+
+	bool		 HasC4( void );
+
+	virtual void CreateLightEffects( void ) {}	//no dimlight effects
+
+	// Sometimes the server wants to update the client's cycle to get the two to run in sync (for proper hit detection)
+	virtual void SetServerIntendedCycle( float intended ) { m_serverIntendedCycle = intended; }
+	virtual float GetServerIntendedCycle( void ) { return m_serverIntendedCycle; }
+
+	virtual bool ShouldReceiveProjectedTextures( int flags )
+	{
+		return ( this != C_BasePlayer::GetLocalPlayer() );
+	}
+
+	void ClearSoundEvents()
+	{
+		m_SoundEvents.RemoveAll();
+	}
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Returns whether this player is dominating or is being dominated by the specified player
+	//=============================================================================
+	bool IsPlayerDominated( int iPlayerIndex );
+	bool IsPlayerDominatingMe( int iPlayerIndex );
+
+	virtual void CalcFreezeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov );
+
+	virtual float GetDeathCamInterpolationTime();
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+
+// Called by shared code.
+public:
+
+	// ICSPlayerAnimState overrides.
+	virtual CWeaponCSBase* CSAnim_GetActiveWeapon();
+	virtual bool CSAnim_CanMove();
+
+
+	void DoAnimationEvent( PlayerAnimEvent_t event, int nData = 0 );
+
+
+// Implemented in shared code.
+public:
+	virtual float GetPlayerMaxSpeed();
+
+	void GetBulletTypeParameters(
+		int iBulletType,
+		float &fPenetrationPower,
+		float &flPenetrationDistance );
+
+	void FireBullet(
+		Vector vecSrc,
+		const QAngle &shootAngles,
+		float flDistance,
+		int iPenetration,
+		int iBulletType,
+		int iDamage,
+		float flRangeModifier,
+		CBaseEntity *pevAttacker,
+		bool bDoEffects,
+		float xSpread, float ySpread );
+
+	void KickBack(
+		float up_base,
+		float lateral_base,
+		float up_modifier,
+		float lateral_modifier,
+		float up_max,
+		float lateral_max,
+		int direction_change );
+
+	// Returns true if the player is allowed to move.
+	bool CanMove() const;
+
+	void OnJump( float fImpulse );
+	void OnLand( float fVelocity );
+
+	bool HasC4() const;	// Is this player carrying a C4 bomb?
+	bool IsVIP() const;	// Is this player the VIP?
+
+	virtual void SetAnimation( PLAYER_ANIM playerAnim );
+
+
+public:
+
+	void UpdateIDTarget( void );
+	void RemoveAddonModels( void );
+	void UpdateMinModels( void );
+
+	void SetActivity( Activity eActivity );
+	Activity GetActivity( void ) const;
+
+	ICSPlayerAnimState *GetPlayerAnimState() { return m_PlayerAnimState; }
+
+public:
+
+	ICSPlayerAnimState *m_PlayerAnimState;
+
+	// Used to control animation state.
+	Activity m_Activity;
+
+	// Predicted variables.
+	CNetworkVar( bool, m_bResumeZoom );
+	CNetworkVar( int , m_iLastZoom ); // after firing a shot, set the FOV to 90, and after showing the animation, bring the FOV back to last zoom level.
+	CNetworkVar( CSPlayerState, m_iPlayerState );	// SupraFiend: this gives the current state in the joining process, the states are listed above
+	CNetworkVar( bool, m_bIsDefusing );			// tracks whether this player is currently defusing a bomb
+	CNetworkVar( bool, m_bInBombZone );
+	CNetworkVar( bool, m_bInBuyZone );
+	CNetworkVar( int, m_iThrowGrenadeCounter );	// used to trigger grenade throw animations.
+
+	bool IsInHostageRescueZone( void );
+
+	// This is a combination of the ADDON_ flags in cs_shareddefs.h.
+	CNetworkVar( int, m_iAddonBits );
+
+	// Clients don't know about holstered weapons, so we need to be told about them here
+	CNetworkVar( int, m_iPrimaryAddon );
+	CNetworkVar( int, m_iSecondaryAddon );
+
+	// How long the progress bar takes to get to the end. If this is 0, then the progress bar
+	// should not be drawn.
+	CNetworkVar( int, m_iProgressBarDuration );
+
+	// When the progress bar should start.
+	CNetworkVar( float, m_flProgressBarStartTime );
+
+	CNetworkVar( float, m_flStamina );
+	CNetworkVar( int, m_iDirection );	// The current lateral kicking direction; 1 = right,  0 = left
+	CNetworkVar( int, m_iShotsFired );	// number of shots fired recently
+	CNetworkVar( bool, m_bNightVisionOn );
+	CNetworkVar( bool, m_bHasNightVision );
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [dwenger] Added for fun-fact support
+    //=============================================================================
+
+    //CNetworkVar( bool, m_bPickedUpDefuser );
+    //CNetworkVar( bool, m_bDefusedWithPickedUpKit );
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+    CNetworkVar( float, m_flVelocityModifier );
+
+	bool		m_bDetected;
+
+	EHANDLE	m_hRagdoll;
+
+	CWeaponCSBase* GetActiveCSWeapon() const;
+	CWeaponCSBase* GetCSWeapon( CSWeaponID id ) const;
+
+	virtual ShadowType_t		ShadowCastType();
+
+#ifdef CS_SHIELD_ENABLED
+	bool HasShield( void ) { return m_bHasShield; }
+	bool IsShieldDrawn( void ) { return m_bShieldDrawn;	}
+	void SetShieldDrawnState( bool bState ) { m_bShieldDrawn = bState; }
+#else
+	bool HasShield( void ) { return false; }
+	bool IsShieldDrawn( void ) { return false; }
+	void SetShieldDrawnState( bool bState ) {}
+#endif
+
+	float m_flNightVisionAlpha;
+
+	float m_flFlashAlpha;
+	float m_flFlashBangTime;
+	CNetworkVar( float, m_flFlashMaxAlpha );
+	CNetworkVar( float, m_flFlashDuration );
+
+	// Having the RecvProxy in the player allows us to keep the var private
+	static void RecvProxy_CycleLatch( const CRecvProxyData *pData, void *pStruct, void *pOut );
+
+	// Bots and hostages auto-duck during jumps
+	bool m_duckUntilOnGround;
+
+	Vector m_lastStandingPos; // used by the gamemovement code for finding ladders
+
+	void SurpressLadderChecks( const Vector& pos, const Vector& normal );
+	bool CanGrabLadder( const Vector& pos, const Vector& normal );
+
+//=============================================================================
+// HPE_BEGIN:
+//=============================================================================
+
+// [tj] checks if this player has another given player on their Steam friends list.
+	bool HasPlayerAsFriend(C_CSPlayer* player);
+
+private:
+	CountdownTimer m_ladderSurpressionTimer;
+	Vector m_lastLadderNormal;
+	Vector m_lastLadderPos;
+
+	void UpdateRadar();
+	void UpdateSoundEvents();
+
+	void CreateAddonModel( int i );
+	void UpdateAddonModels();
+
+	void PushawayThink();
+
+	int		m_iAccount;
+	bool	m_bHasHelmet;
+	int		m_iClass;
+	int		m_ArmorValue;
+	QAngle	m_angEyeAngles;
+	bool	m_bHasDefuser;
+	bool	m_bInHostageRescueZone;
+	float	m_fNextThinkPushAway;
+
+    bool    m_bPlayingFreezeCamSound;
+
+#ifdef CS_SHIELD_ENABLED
+	bool	m_bHasShield;
+	bool	m_bShieldDrawn;
+#endif
+
+	Vector m_vecRagdollVelocity;
+
+	CInterpolatedVar< QAngle >	m_iv_angEyeAngles;
+
+	// ID Target
+	int					m_iIDEntIndex;
+	CountdownTimer		m_delayTargetIDTimer;
+
+	// Show the ID target after the cursor leaves the entity
+	int					m_iOldIDEntIndex;
+	CountdownTimer		m_holdTargetIDTimer;
+
+	void ReleaseFlashlight( void );
+	Beam_t	*m_pFlashlightBeam;
+
+	class CCSSoundEvent
+	{
+	public:
+		string_t m_SoundName;
+		float m_flEventTime;	// Play the event when gpGlobals->curtime goes past this.
+	};
+	CUtlLinkedList<CCSSoundEvent,int> m_SoundEvents;
+
+
+	// This is the list of addons hanging off the guy (grenades, C4, nightvision, etc).
+	CUtlLinkedList<CAddonModel, int> m_AddonModels;
+	int m_iLastAddonBits;
+	int m_iLastPrimaryAddon;
+	int m_iLastSecondaryAddon;
+
+	int m_cycleLatch;				// server periodically updates this to fix up our anims, here it is a 4 bit fixed point
+	float m_serverIntendedCycle;	// server periodically updates this to fix up our anims, here it is the float we want, or -1 for no override
+
+
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [tj] Network variables that track who are dominating and being dominated by
+    //=============================================================================
+
+    CNetworkArray( bool, m_bPlayerDominated, MAX_PLAYERS+1 );		// array of state per other player whether player is dominating other players
+    CNetworkArray( bool, m_bPlayerDominatingMe, MAX_PLAYERS+1 );	// array of state per other player whether other players are dominating this player
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+
+
+	C_CSPlayer( const C_CSPlayer & );
+};
+
+C_CSPlayer* GetLocalOrInEyeCSPlayer( void );
+
+inline C_CSPlayer *ToCSPlayer( CBaseEntity *pEntity )
+{
+	if ( !pEntity || !pEntity->IsPlayer() )
+		return NULL;
+
+	return dynamic_cast<C_CSPlayer*>( pEntity );
+}
+
+namespace vgui
+{
+	class IImage;
+}
+
+vgui::IImage* GetDefaultAvatarImage( C_BasePlayer *pPlayer );
+
+
+
+
+#endif // C_CS_PLAYER_H
diff --git a/game/client/cstrike/c_cs_playerresource.cpp b/game/client/cstrike/c_cs_playerresource.cpp
new file mode 100644
index 00000000..767fc2ca
--- /dev/null
+++ b/game/client/cstrike/c_cs_playerresource.cpp
@@ -0,0 +1,206 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: CS's custom C_PlayerResource
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_cs_playerresource.h"
+#include <shareddefs.h>
+#include <cs_shareddefs.h>
+#include "hud.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+IMPLEMENT_CLIENTCLASS_DT(C_CS_PlayerResource, DT_CSPlayerResource, CCSPlayerResource)
+	RecvPropInt( RECVINFO( m_iPlayerC4 ) ),
+	RecvPropInt( RECVINFO( m_iPlayerVIP ) ),
+	RecvPropVector( RECVINFO(m_vecC4) ),
+	RecvPropArray3( RECVINFO_ARRAY(m_bHostageAlive), RecvPropInt( RECVINFO(m_bHostageAlive[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_isHostageFollowingSomeone), RecvPropInt( RECVINFO(m_isHostageFollowingSomeone[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_iHostageEntityIDs), RecvPropInt( RECVINFO(m_iHostageEntityIDs[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_iHostageX), RecvPropInt( RECVINFO(m_iHostageX[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_iHostageY), RecvPropInt( RECVINFO(m_iHostageY[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_iHostageZ), RecvPropInt( RECVINFO(m_iHostageZ[0]))),
+	RecvPropVector( RECVINFO(m_bombsiteCenterA) ),
+	RecvPropVector( RECVINFO(m_bombsiteCenterB) ),
+	RecvPropArray3( RECVINFO_ARRAY(m_hostageRescueX), RecvPropInt( RECVINFO(m_hostageRescueX[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_hostageRescueY), RecvPropInt( RECVINFO(m_hostageRescueY[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_hostageRescueZ), RecvPropInt( RECVINFO(m_hostageRescueZ[0]))),
+	RecvPropInt( RECVINFO( m_bBombSpotted ) ),
+	RecvPropArray3( RECVINFO_ARRAY(m_bPlayerSpotted), RecvPropInt( RECVINFO(m_bPlayerSpotted[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_iMVPs), RecvPropInt( RECVINFO(m_iMVPs[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_bHasDefuser), RecvPropInt( RECVINFO(m_bHasDefuser[0]))),
+	RecvPropArray3( RECVINFO_ARRAY(m_szClan), RecvPropString( RECVINFO(m_szClan[0]))),
+END_RECV_TABLE()
+ 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_CS_PlayerResource::C_CS_PlayerResource()
+{
+	m_Colors[TEAM_TERRORIST] = COLOR_RED;
+	m_Colors[TEAM_CT] = COLOR_BLUE;
+	memset( m_iMVPs, 0, sizeof( m_iMVPs ) );
+	memset( m_bHasDefuser, 0, sizeof( m_bHasDefuser ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_CS_PlayerResource::~C_CS_PlayerResource()
+{
+}
+
+bool C_CS_PlayerResource::IsVIP(int iIndex )
+{
+	return m_iPlayerVIP == iIndex;
+}
+
+bool C_CS_PlayerResource::HasC4(int iIndex )
+{
+	return m_iPlayerC4 == iIndex;
+}
+
+bool C_CS_PlayerResource::IsHostageAlive(int iIndex)
+{
+	if ( iIndex < 0 || iIndex >= MAX_HOSTAGES )
+		return false;
+
+	return m_bHostageAlive[iIndex];
+}
+
+bool C_CS_PlayerResource::IsHostageFollowingSomeone(int iIndex)
+{
+	if ( iIndex < 0 || iIndex >= MAX_HOSTAGES )
+		return false;
+
+	return m_isHostageFollowingSomeone[iIndex];
+}
+
+int C_CS_PlayerResource::GetHostageEntityID(int iIndex)
+{
+	if ( iIndex < 0 || iIndex >= MAX_HOSTAGES )
+		return -1;
+
+	return m_iHostageEntityIDs[iIndex];
+}
+
+const Vector C_CS_PlayerResource::GetHostagePosition( int iIndex )
+{
+	if ( iIndex < 0 || iIndex >= MAX_HOSTAGES )
+		return vec3_origin;
+
+	Vector ret;
+
+	ret.x = m_iHostageX[iIndex];
+	ret.y = m_iHostageY[iIndex];
+	ret.z = m_iHostageZ[iIndex];
+
+	return ret;
+}
+
+const Vector C_CS_PlayerResource::GetC4Postion()
+{
+	if ( m_iPlayerC4 > 0 )
+	{
+		// C4 is carried by player
+		C_BasePlayer *pPlayer = UTIL_PlayerByIndex( m_iPlayerC4 );
+
+		if ( pPlayer )
+		{
+			return pPlayer->GetAbsOrigin();
+		}
+	}
+
+	// C4 is lying on ground
+	return m_vecC4;
+}
+
+const Vector C_CS_PlayerResource::GetBombsiteAPosition()
+{
+	return m_bombsiteCenterA;
+}
+
+const Vector C_CS_PlayerResource::GetBombsiteBPosition()
+{
+	return m_bombsiteCenterB;
+}
+
+const Vector C_CS_PlayerResource::GetHostageRescuePosition( int iIndex )
+{
+	if ( iIndex < 0 || iIndex >= MAX_HOSTAGE_RESCUES )
+		return vec3_origin;
+
+	Vector ret;
+
+	ret.x = m_hostageRescueX[iIndex];
+	ret.y = m_hostageRescueY[iIndex];
+	ret.z = m_hostageRescueZ[iIndex];
+
+	return ret;
+}
+
+int C_CS_PlayerResource::GetPlayerClass( int iIndex )
+{
+	if ( !IsConnected( iIndex ) )
+	{
+		return CS_CLASS_NONE;
+	}
+
+	return m_iPlayerClasses[ iIndex ];
+}
+
+//--------------------------------------------------------------------------------------------------------
+bool C_CS_PlayerResource::IsBombSpotted( void ) const
+{
+	return m_bBombSpotted;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+bool C_CS_PlayerResource::IsPlayerSpotted( int iIndex )
+{
+	if ( !IsConnected( iIndex ) )
+		return false;
+
+	return m_bPlayerSpotted[iIndex];
+}
+
+//-----------------------------------------------------------------------------
+const char *C_CS_PlayerResource::GetClanTag( int iIndex )
+{
+	if ( iIndex < 1 || iIndex > MAX_PLAYERS )
+	{
+		Assert( false );
+		return "";
+	}
+
+	if ( !IsConnected( iIndex ) )
+		return "";
+
+	return m_szClan[iIndex];
+}
+
+//-----------------------------------------------------------------------------
+int C_CS_PlayerResource::GetNumMVPs( int iIndex )
+{
+	if ( !IsConnected( iIndex ) )
+		return false;
+
+	return m_iMVPs[iIndex];
+} 
+
+//-----------------------------------------------------------------------------
+bool C_CS_PlayerResource::HasDefuser( int iIndex )
+{
+	if ( !IsConnected( iIndex ) )
+		return false;
+
+	return m_bHasDefuser[iIndex];
+} 
diff --git a/game/client/cstrike/c_cs_playerresource.h b/game/client/cstrike/c_cs_playerresource.h
new file mode 100644
index 00000000..6665bf21
--- /dev/null
+++ b/game/client/cstrike/c_cs_playerresource.h
@@ -0,0 +1,76 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: CS's custom C_PlayerResource
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_CS_PLAYERRESOURCE_H
+#define C_CS_PLAYERRESOURCE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cs_shareddefs.h"
+#include "c_playerresource.h"
+
+class C_CS_PlayerResource : public C_PlayerResource
+{
+	DECLARE_CLASS( C_CS_PlayerResource, C_PlayerResource );
+public:
+	DECLARE_CLIENTCLASS();
+
+					C_CS_PlayerResource();
+	virtual			~C_CS_PlayerResource();
+
+	bool			IsVIP(int iIndex );
+	bool			HasC4(int iIndex );
+	bool			IsHostageAlive(int iIndex);
+	bool			IsHostageFollowingSomeone(int iIndex);
+	const Vector	GetHostagePosition( int index );
+	int				GetHostageEntityID(int iIndex);
+	const Vector	GetC4Postion();
+	const Vector	GetBombsiteAPosition();
+	const Vector	GetBombsiteBPosition();
+	const Vector	GetHostageRescuePosition( int index );
+	int				GetPlayerClass( int iIndex );
+
+	bool			IsBombSpotted( void ) const;
+	bool			IsPlayerSpotted( int iIndex );
+
+	const char		*GetClanTag( int index );
+
+	int				GetNumMVPs( int iIndex );
+	bool			HasDefuser( int iIndex );
+
+protected:
+
+	int		m_iPlayerC4;	// entity index of C4 carrier or 0
+	int		m_iPlayerVIP;	// entity index of VIP player or 0
+	Vector	m_vecC4;		// position of C4
+	Vector	m_bombsiteCenterA;	
+	Vector	m_bombsiteCenterB;	
+
+	bool	m_bHostageAlive[MAX_HOSTAGES];
+	bool	m_isHostageFollowingSomeone[MAX_HOSTAGES];
+	int		m_iHostageEntityIDs[MAX_HOSTAGES];
+	int		m_iHostageX[MAX_HOSTAGES];
+	int		m_iHostageY[MAX_HOSTAGES];
+	int		m_iHostageZ[MAX_HOSTAGES];
+
+	int		m_hostageRescueX[MAX_HOSTAGE_RESCUES];
+	int		m_hostageRescueY[MAX_HOSTAGE_RESCUES];
+	int		m_hostageRescueZ[MAX_HOSTAGE_RESCUES];
+
+	bool	m_bBombSpotted;
+	bool	m_bPlayerSpotted[ MAX_PLAYERS + 1 ];
+	int		m_iPlayerClasses[ MAX_PLAYERS + 1 ];
+
+	char	m_szClan[MAX_PLAYERS+1][MAX_CLAN_TAG_LENGTH];
+
+	int		m_iMVPs[ MAX_PLAYERS + 1 ];	 
+	bool	m_bHasDefuser[ MAX_PLAYERS + 1 ];
+};
+
+
+#endif // C_CS_PLAYERRESOURCE_H
diff --git a/game/client/cstrike/c_cs_team.cpp b/game/client/cstrike/c_cs_team.cpp
new file mode 100644
index 00000000..721858a9
--- /dev/null
+++ b/game/client/cstrike/c_cs_team.cpp
@@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client side C_CSTeam class
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "engine/IEngineSound.h"
+#include "hud.h"
+#include "recvproxy.h"
+#include "c_cs_team.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_CSTeam, DT_CSTeam, CCSTeam)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_CSTeam::C_CSTeam()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_CSTeam::~C_CSTeam()
+{
+}
+
diff --git a/game/client/cstrike/c_cs_team.h b/game/client/cstrike/c_cs_team.h
new file mode 100644
index 00000000..97cfa6b6
--- /dev/null
+++ b/game/client/cstrike/c_cs_team.h
@@ -0,0 +1,35 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client side CTFTeam class
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_CS_TEAM_H
+#define C_CS_TEAM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_team.h"
+#include "shareddefs.h"
+
+class C_BaseEntity;
+class C_BaseObject;
+class CBaseTechnology;
+
+//-----------------------------------------------------------------------------
+// Purpose: TF's Team manager
+//-----------------------------------------------------------------------------
+class C_CSTeam : public C_Team
+{
+	DECLARE_CLASS( C_CSTeam, C_Team );
+public:
+	DECLARE_CLIENTCLASS();
+
+					C_CSTeam();
+	virtual			~C_CSTeam();
+};
+
+
+#endif // C_CS_TEAM_H
diff --git a/game/client/cstrike/c_csrootpanel.cpp b/game/client/cstrike/c_csrootpanel.cpp
new file mode 100644
index 00000000..2fa0648e
--- /dev/null
+++ b/game/client/cstrike/c_csrootpanel.cpp
@@ -0,0 +1,86 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_csrootpanel.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/IVGui.h>
+#include "clientmode_csnormal.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//-----------------------------------------------------------------------------
+C_CSRootPanel::C_CSRootPanel( vgui::VPANEL parent )
+	: BaseClass( NULL, "CounterStrike Root Panel" )
+{
+	SetParent( parent );
+	SetPaintEnabled( false );
+	SetPaintBorderEnabled( false );
+	SetPaintBackgroundEnabled( false );
+
+	// This panel does post child painting
+	SetPostChildPaintEnabled( true );
+
+	int w, h;
+	surface()->GetScreenSize( w, h );
+
+	// Make it screen sized
+	SetBounds( 0, 0, w, h );
+
+	// Ask for OnTick messages
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_CSRootPanel::~C_CSRootPanel( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_CSRootPanel::PostChildPaint()
+{
+	BaseClass::PostChildPaint();
+
+	// Draw all panel effects
+	RenderPanelEffects();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: For each panel effect, check if it wants to draw and draw it on
+//  this panel/surface if so
+//-----------------------------------------------------------------------------
+void C_CSRootPanel::RenderPanelEffects( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_CSRootPanel::OnTick( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reset effects on level load/shutdown
+//-----------------------------------------------------------------------------
+void C_CSRootPanel::LevelInit( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_CSRootPanel::LevelShutdown( void )
+{
+}
+
diff --git a/game/client/cstrike/c_csrootpanel.h b/game/client/cstrike/c_csrootpanel.h
new file mode 100644
index 00000000..ca7bb452
--- /dev/null
+++ b/game/client/cstrike/c_csrootpanel.h
@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_CSRootPanel_H
+#define C_CSRootPanel_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/EditablePanel.h>
+#include "utlvector.h"
+
+class CPanelEffect;
+class ITFHintItem;
+
+// Serial under of effect, for safe lookup
+typedef unsigned int EFFECT_HANDLE;
+
+//-----------------------------------------------------------------------------
+// Purpose: Sits between engine and client .dll panels
+//  Responsible for drawing screen overlays
+//-----------------------------------------------------------------------------
+class C_CSRootPanel : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+public:
+						C_CSRootPanel( vgui::VPANEL parent );
+	virtual				~C_CSRootPanel( void );
+
+	// Draw Panel effects here
+	virtual void		PostChildPaint();
+
+	// Clear list of Panel Effects
+	virtual void		LevelInit( void );
+	virtual void		LevelShutdown( void );
+
+	// Run effects and let them decide whether to remove themselves
+	void				OnTick( void );
+
+private:
+
+	// Render all panel effects
+	void		RenderPanelEffects( void );
+
+	// List of current panel effects
+	CUtlVector< CPanelEffect *> m_Effects;
+};
+
+extern C_CSRootPanel *g_pTF2RootPanel;
+
+#endif // C_CSRootPanel_H
diff --git a/game/client/cstrike/c_plantedc4.cpp b/game/client/cstrike/c_plantedc4.cpp
new file mode 100644
index 00000000..d745e326
--- /dev/null
+++ b/game/client/cstrike/c_plantedc4.cpp
@@ -0,0 +1,219 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "c_plantedc4.h"
+#include "c_te_legacytempents.h"
+#include "tempent.h"
+#include "engine/IEngineSound.h"
+#include "dlight.h"
+#include "iefx.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include <bitbuf.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define PLANTEDC4_MSG_JUSTBLEW 1
+
+ConVar cl_c4dynamiclight( "cl_c4dynamiclight", "0", 0, "Draw dynamic light when planted c4 flashes" );
+
+IMPLEMENT_CLIENTCLASS_DT(C_PlantedC4, DT_PlantedC4, CPlantedC4)
+	RecvPropBool( RECVINFO(m_bBombTicking) ),
+	RecvPropFloat( RECVINFO(m_flC4Blow) ),
+	RecvPropFloat( RECVINFO(m_flTimerLength) ),
+	RecvPropFloat( RECVINFO(m_flDefuseLength) ),
+	RecvPropFloat( RECVINFO(m_flDefuseCountDown) ),
+END_RECV_TABLE()
+
+CUtlVector< C_PlantedC4* > g_PlantedC4s;
+
+C_PlantedC4::C_PlantedC4()
+{
+	g_PlantedC4s.AddToTail( this );
+
+	m_flNextRadarFlashTime = gpGlobals->curtime;
+	m_bRadarFlash = true;
+	m_pC4Explosion = NULL;
+
+	// Don't beep right away, leave time for the planting sound
+	m_flNextGlow = gpGlobals->curtime + 1.0;
+	m_flNextBeep = gpGlobals->curtime + 1.0;
+}
+
+
+C_PlantedC4::~C_PlantedC4()
+{
+	g_PlantedC4s.FindAndRemove( this );
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Upon the new round remove the remaining bomb explosion particle effect
+	//=============================================================================
+	
+	if (m_pC4Explosion)
+	{
+		m_pC4Explosion->SetRemoveFlag();
+	}
+	 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+void C_PlantedC4::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	
+	// Remove us from the list of planted C4s.
+	if ( bDormant )
+	{
+		g_PlantedC4s.FindAndRemove( this );
+	}
+	else
+	{
+		if ( g_PlantedC4s.Find( this ) == -1 )
+			g_PlantedC4s.AddToTail( this );
+	}
+}
+
+void C_PlantedC4::Spawn( void )
+{
+	BaseClass::Spawn();
+
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+}
+
+void C_PlantedC4::ClientThink( void )
+{
+	BaseClass::ClientThink();
+
+	// If it's dormant, don't beep or anything..
+	if ( IsDormant() )
+		return;
+
+	if ( !m_bBombTicking )
+	{
+		// disable C4 thinking if not armed
+		SetNextClientThink( CLIENT_THINK_NEVER );
+		return;
+	}
+
+	if( gpGlobals->curtime > m_flNextBeep )
+	{
+		// as it gets closer to going off, increase the radius
+
+		CLocalPlayerFilter filter;
+		float attenuation;
+		float freq;
+
+		//the percent complete of the bomb timer
+		float fComplete = ( ( m_flC4Blow - gpGlobals->curtime ) / m_flTimerLength );
+		
+		fComplete = clamp( fComplete, 0.0f, 1.0f );
+
+		attenuation = MIN( 0.3 + 0.6 * fComplete, 1.0 );
+		
+		CSoundParameters params;
+
+		if ( GetParametersForSound( "C4.PlantSound", params, NULL ) )
+		{
+			EmitSound_t ep( params );
+			ep.m_SoundLevel = ATTN_TO_SNDLVL( attenuation );
+			ep.m_pOrigin = &GetAbsOrigin();
+
+			EmitSound( filter, SOUND_FROM_WORLD, ep );
+		}
+
+		freq = MAX( 0.1 + 0.9 * fComplete, 0.15 );
+
+		m_flNextBeep = gpGlobals->curtime + freq;
+	}
+
+	if( gpGlobals->curtime > m_flNextGlow )
+	{
+		int modelindex = modelinfo->GetModelIndex( "sprites/ledglow.vmt" );
+
+		float scale = 0.8f;
+		Vector vPos = GetAbsOrigin();
+		const Vector offset( 0, 0, 4 );
+
+		// See if the c4 ended up underwater - we need to pull the flash up, or it won't get seen
+		if ( enginetrace->GetPointContents( vPos ) & (CONTENTS_WATER|CONTENTS_SLIME) )
+		{
+			C_CSPlayer *player = GetLocalOrInEyeCSPlayer();
+			if ( player )
+			{
+				const Vector& eyes = player->EyePosition();
+
+				if ( ( enginetrace->GetPointContents( eyes ) & (CONTENTS_WATER|CONTENTS_SLIME) ) == 0 )
+				{
+					// trace from the player to the water
+					trace_t waterTrace;
+					UTIL_TraceLine( eyes, vPos, (CONTENTS_WATER|CONTENTS_SLIME), player, COLLISION_GROUP_NONE, &waterTrace );
+
+					if( waterTrace.allsolid != 1 )
+					{
+						// now trace from the C4 to the edge of the water (in case there was something solid in the water)
+						trace_t solidTrace;
+						UTIL_TraceLine( vPos, waterTrace.endpos, MASK_SOLID, this, COLLISION_GROUP_NONE, &solidTrace );
+
+						if( solidTrace.allsolid != 1 )
+						{
+							float waterDist = (solidTrace.endpos - vPos).Length();
+							float remainingDist = (solidTrace.endpos - eyes).Length();
+
+							scale = scale * remainingDist / ( remainingDist + waterDist );
+							vPos = solidTrace.endpos;
+						}
+					}
+				}
+			}
+		}
+
+		vPos += offset;
+
+		tempents->TempSprite( vPos, vec3_origin, scale, modelindex, kRenderTransAdd, 0, 1.0, 0.05, FTENT_SPRANIMATE | FTENT_SPRANIMATELOOP );
+
+		if( cl_c4dynamiclight.GetBool() )
+		{
+			dlight_t *dl;
+
+			dl = effects->CL_AllocDlight( entindex() );
+
+			if( dl ) 
+			{
+				dl->origin = GetAbsOrigin() + offset; // can't use vPos because it might have been moved
+				dl->color.r = 255;
+				dl->color.g = 0;
+				dl->color.b = 0;
+				dl->radius = 64;
+				dl->die = gpGlobals->curtime + 0.01;
+			}
+		}
+
+		float freq = 0.1 + 0.9 * ( ( m_flC4Blow - gpGlobals->curtime ) / m_flTimerLength );
+
+		if( freq < 0.15 ) freq = 0.15;
+
+		m_flNextGlow = gpGlobals->curtime + freq;
+	}
+}
+
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Create the client side explosion particle effect for when the bomb explodes and hide the bomb
+//=============================================================================
+void C_PlantedC4::Explode( void )
+{
+	m_pC4Explosion = ParticleProp()->Create( "bomb_explosion_huge", PATTACH_ABSORIGIN );
+	AddEffects( EF_NODRAW );
+	SetDormant( true );
+}
+//=============================================================================
+// HPE_END
+//=============================================================================
\ No newline at end of file
diff --git a/game/client/cstrike/c_plantedc4.h b/game/client/cstrike/c_plantedc4.h
new file mode 100644
index 00000000..b5ae7c7e
--- /dev/null
+++ b/game/client/cstrike/c_plantedc4.h
@@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#ifndef C_PLANTEDC4_H
+#define C_PLANTEDC4_H
+
+#include "cbase.h"
+#include "in_buttons.h"
+#include "decals.h"
+
+#include "c_cs_player.h"
+
+#include "utlvector.h"
+
+// ------------------------------------------------------------------------------------------ //
+// CPlantedC4 class.
+// For now to show the planted c4 on the radar - client proxy to remove the CBaseAnimating 
+// network vars?
+// ------------------------------------------------------------------------------------------ //
+
+class C_PlantedC4 : public C_BaseAnimating
+{
+public:
+	DECLARE_CLASS( C_PlantedC4, CBaseAnimating );
+	DECLARE_CLIENTCLASS();
+
+	C_PlantedC4();
+	virtual ~C_PlantedC4();
+
+	void Explode( void );
+	void Spawn( void );
+	virtual void SetDormant( bool bDormant );
+
+	void ClientThink( void );
+
+	int GetSecondsRemaining( void ) { return ceil( m_flC4Blow - gpGlobals->curtime ); }
+
+	inline bool IsBombActive( void ) { return m_bBombTicking; }
+	CNetworkVar( bool, m_bBombTicking );
+
+	float m_flNextGlow;
+	float m_flNextBeep;
+
+	float m_flC4Blow;
+	float m_flTimerLength;
+
+	CNetworkVar( float, m_flDefuseLength );	
+	CNetworkVar( float, m_flDefuseCountDown ); 
+
+	float GetDefuseProgress( void )
+	{	
+		float flProgress = 1.0f;
+
+		if( m_flDefuseLength > 0.0 )
+		{
+			flProgress = ( ( m_flDefuseCountDown - gpGlobals->curtime ) / m_flDefuseLength );
+		}
+
+		return flProgress;
+	}
+
+	float	m_flNextRadarFlashTime;	// next time to change flash state
+	bool	m_bRadarFlash;			// is the flash on or off
+	CNewParticleEffect *m_pC4Explosion; // client side explosion particle effect for the bomb
+};
+
+extern CUtlVector< C_PlantedC4* > g_PlantedC4s;
+
+#endif //C_PLANTEDC4_H
\ No newline at end of file
diff --git a/game/client/cstrike/c_te_radioicon.cpp b/game/client/cstrike/c_te_radioicon.cpp
new file mode 100644
index 00000000..c49c11bb
--- /dev/null
+++ b/game/client/cstrike/c_te_radioicon.cpp
@@ -0,0 +1,74 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_basetempentity.h"
+#include "c_cs_player.h"
+#include "hud_radar.h"
+#include "radio_status.h"
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Kills Player Attachments
+//-----------------------------------------------------------------------------
+class C_TERadioIcon : public C_BaseTempEntity
+{
+public:
+	DECLARE_CLASS( C_TERadioIcon, C_BaseTempEntity );
+	DECLARE_CLIENTCLASS();
+
+					C_TERadioIcon( void );
+	virtual			~C_TERadioIcon( void );
+
+	virtual void	PostDataUpdate( DataUpdateType_t updateType );
+
+public:
+	int m_iAttachToClient;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TERadioIcon::C_TERadioIcon( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TERadioIcon::~C_TERadioIcon( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bool - 
+//-----------------------------------------------------------------------------
+void C_TERadioIcon::PostDataUpdate( DataUpdateType_t updateType )
+{
+	//Flash them on the radar
+	//this could be in a better place.
+	C_CSPlayer *pPlayer = static_cast<C_CSPlayer*>( cl_entitylist->GetEnt(m_iAttachToClient) );
+
+	if ( pPlayer && !pPlayer->IsDormant() )
+	{
+		// Create the flashy above player's head
+		RadioManager()->UpdateRadioStatus( m_iAttachToClient, 1.5f );
+	}
+	
+	Radar_FlashPlayer( m_iAttachToClient );
+}
+
+IMPLEMENT_CLIENTCLASS_EVENT_DT(C_TERadioIcon, DT_TERadioIcon, CTERadioIcon)
+	RecvPropInt( RECVINFO(m_iAttachToClient)),
+END_RECV_TABLE()
diff --git a/game/client/cstrike/c_te_shotgun_shot.cpp b/game/client/cstrike/c_te_shotgun_shot.cpp
new file mode 100644
index 00000000..e4687631
--- /dev/null
+++ b/game/client/cstrike/c_te_shotgun_shot.cpp
@@ -0,0 +1,100 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "fx_cs_shared.h"
+#include "c_cs_player.h"
+#include "c_basetempentity.h"
+#include <cliententitylist.h>
+
+
+class C_TEFireBullets : public C_BaseTempEntity
+{
+public:
+	DECLARE_CLASS( C_TEFireBullets, C_BaseTempEntity );
+	DECLARE_CLIENTCLASS();
+
+	virtual void	PostDataUpdate( DataUpdateType_t updateType );
+
+public:
+	int		m_iPlayer;
+	Vector	m_vecOrigin;
+	QAngle	m_vecAngles;
+	int		m_iWeaponID;
+	int		m_iMode;
+	int		m_iSeed;
+	float	m_fInaccuracy;
+	float	m_fSpread;
+};
+
+
+void C_TEFireBullets::PostDataUpdate( DataUpdateType_t updateType )
+{
+	// Create the effect.
+	
+	m_vecAngles.z = 0;
+	
+	FX_FireBullets( 
+		m_iPlayer+1,
+		m_vecOrigin,
+		m_vecAngles,
+		m_iWeaponID,
+		m_iMode,
+		m_iSeed,
+		m_fInaccuracy,
+		m_fSpread
+		);
+}
+
+
+IMPLEMENT_CLIENTCLASS_EVENT( C_TEFireBullets, DT_TEFireBullets, CTEFireBullets );
+
+
+BEGIN_RECV_TABLE_NOBASE(C_TEFireBullets, DT_TEFireBullets)
+	RecvPropVector( RECVINFO( m_vecOrigin ) ),
+	RecvPropFloat( RECVINFO( m_vecAngles[0] ) ),
+	RecvPropFloat( RECVINFO( m_vecAngles[1] ) ),
+	RecvPropInt( RECVINFO( m_iWeaponID ) ),
+	RecvPropInt( RECVINFO( m_iMode ) ), 
+	RecvPropInt( RECVINFO( m_iSeed ) ),
+	RecvPropInt( RECVINFO( m_iPlayer ) ),
+	RecvPropFloat( RECVINFO( m_fInaccuracy ) ),
+	RecvPropFloat( RECVINFO( m_fSpread ) ),
+END_RECV_TABLE()
+
+
+class C_TEPlantBomb : public C_BaseTempEntity
+{
+public:
+	DECLARE_CLASS( C_TEPlantBomb, C_BaseTempEntity );
+	DECLARE_CLIENTCLASS();
+
+	virtual void	PostDataUpdate( DataUpdateType_t updateType );
+
+public:
+	int		m_iPlayer;
+	Vector	m_vecOrigin;
+	PlantBombOption_t	m_option;
+};
+
+
+void C_TEPlantBomb::PostDataUpdate( DataUpdateType_t updateType )
+{
+	// Create the effect.
+	FX_PlantBomb( m_iPlayer+1, m_vecOrigin, m_option );
+}
+
+
+IMPLEMENT_CLIENTCLASS_EVENT( C_TEPlantBomb, DT_TEPlantBomb, CTEPlantBomb );
+
+
+BEGIN_RECV_TABLE_NOBASE(C_TEPlantBomb, DT_TEPlantBomb)
+	RecvPropVector( RECVINFO( m_vecOrigin ) ),
+	RecvPropInt( RECVINFO( m_iPlayer ) ),
+	RecvPropInt( RECVINFO( m_option ) ),
+END_RECV_TABLE()
+
+
diff --git a/game/client/cstrike/clientmode_csnormal.cpp b/game/client/cstrike/clientmode_csnormal.cpp
new file mode 100644
index 00000000..87b5cc52
--- /dev/null
+++ b/game/client/cstrike/clientmode_csnormal.cpp
@@ -0,0 +1,1108 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "clientmode_csnormal.h"
+#include "cdll_client_int.h"
+#include "iinput.h"
+#include "vgui/ISurface.h"
+#include "vgui/IPanel.h"
+#include <vgui_controls/AnimationController.h>
+#include "ivmodemanager.h"
+#include "buymenu.h"
+#include "filesystem.h"
+#include "vgui/IVGui.h"
+#include "hud_basechat.h"
+#include "view_shared.h"
+#include "view.h"
+#include "ivrenderview.h"
+#include "cstrikeclassmenu.h"
+#include "model_types.h"
+#include "iefx.h"
+#include "dlight.h"
+#include <imapoverview.h>
+#include "c_playerresource.h"
+#include "c_soundscape.h"
+#include <KeyValues.h>
+#include "text_message.h"
+#include "panelmetaclassmgr.h"
+#include "vguicenterprint.h"
+#include "physpropclientside.h"
+#include "c_weapon__stubs.h"
+#include <engine/IEngineSound.h>
+#include "c_cs_hostage.h"
+#include "buy_presets/buy_presets.h"
+#include "bitbuf.h"
+#include "usermessages.h"
+#include "prediction.h"
+#include "datacache/imdlcache.h"
+//=============================================================================
+// HPE_BEGIN:
+// [tj] Needed to retrieve achievement text
+// [menglish] Need access to message macros
+//=============================================================================
+ 
+#include "achievementmgr.h"
+#include "hud_macros.h"
+#include "c_plantedc4.h"
+#include "tier1/fmtstr.h"
+#include "history_resource.h"
+#include "cs_client_gamestats.h"
+
+// [tj] We need to forward declare this, since the definition is all inside the implementation file 
+class CHudHintDisplay;
+ 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+void __MsgFunc_MatchEndConditions( bf_read &msg );
+
+class CHudChat;
+
+ConVar default_fov( "default_fov", "90", FCVAR_CHEAT );
+
+IClientMode *g_pClientMode = NULL;
+
+// This is a temporary entity used to render the player's model while drawing the class selection menu.
+CHandle<C_BaseAnimatingOverlay> g_ClassImagePlayer;	// player
+CHandle<C_BaseAnimating> g_ClassImageWeapon;	// weapon
+
+STUB_WEAPON_CLASS( cycler_weapon,	WeaponCycler,	C_BaseCombatWeapon );
+STUB_WEAPON_CLASS( weapon_cubemap,	WeaponCubemap,	C_BaseCombatWeapon );
+
+//-----------------------------------------------------------------------------
+// HACK: the detail sway convars are archive, and default to 0.  Existing CS:S players thus have no detail
+// prop sway.  We'll force them to DoD's default values for now.  What we really need in the long run is
+// a system to apply changes to archived convars' defaults to existing players.
+extern ConVar cl_detail_max_sway;
+extern ConVar cl_detail_avoid_radius;
+extern ConVar cl_detail_avoid_force;
+extern ConVar cl_detail_avoid_recover_speed;
+
+//-----------------------------------------------------------------------------
+ConVar cl_autobuy(
+	"cl_autobuy",
+	"",
+	FCVAR_USERINFO,
+	"The order in which autobuy will attempt to purchase items" );
+
+//-----------------------------------------------------------------------------
+ConVar cl_rebuy(
+	"cl_rebuy",
+	"",
+	FCVAR_USERINFO,
+	"The order in which rebuy will attempt to repurchase items" );
+
+//-----------------------------------------------------------------------------
+void SetBuyData( const ConVar &buyVar, const char *filename )
+{
+	// if we already have autobuy data, don't bother re-parsing the text file
+	if ( *buyVar.GetString() )
+		return;
+
+	// First, look for a mapcycle file in the cfg directory, which is preferred
+	char szRecommendedName[ 256 ];
+	char szResolvedName[ 256 ];
+	V_sprintf_safe( szRecommendedName, "cfg/%s", filename );
+	V_strcpy_safe( szResolvedName, szRecommendedName );
+	if ( filesystem->FileExists( szResolvedName, "GAME" ) )
+	{
+		Msg( "Loading '%s'.\n", szResolvedName );
+	}
+	else
+	{
+		// Check the root
+		V_strcpy_safe( szResolvedName, filename );
+		if ( filesystem->FileExists( szResolvedName, "GAME" ) )
+		{
+			Msg( "Loading '%s'  ('%s' was not found.)\n", szResolvedName, szRecommendedName );
+		}
+		else
+		{
+
+			// Try cfg/xxx_default.txt
+			V_strcpy_safe( szResolvedName, szRecommendedName );
+			char *dotTxt = V_stristr( szResolvedName, ".txt" );
+			Assert( dotTxt );
+			if ( dotTxt )
+			{
+				V_strcpy( dotTxt, "_default.txt" );
+			}
+			if ( !filesystem->FileExists( szResolvedName, "GAME" ) )
+			{
+				Warning( "Not loading buy data.  Neither '%s' nor %s were found.\n", szResolvedName, szRecommendedName );
+				return;
+			}
+			Msg( "Loading '%s'\n", szResolvedName );
+		}
+	}
+
+	CUtlBuffer buf;
+	if ( !filesystem->ReadFile( szResolvedName, "GAME", buf ) )
+	{
+		// WAT
+		Warning( "Failed to load '%s'.\n", szResolvedName );
+		return;
+	}
+	buf.PutChar('\0');
+
+	char token[256];
+	char buystring[256];
+	V_sprintf_safe( buystring, "setinfo %s \"", buyVar.GetName() );
+
+	const char *pfile = engine->ParseFile( (const char *)buf.Base(), token, sizeof(token) );
+
+	bool first = true;
+
+	while (pfile != NULL)
+	{
+		if (first)
+		{
+			first = false;
+		}
+		else
+		{
+			Q_strncat(buystring, " ", sizeof(buystring), COPY_ALL_CHARACTERS);
+		}
+
+		Q_strncat(buystring, token, sizeof(buystring), COPY_ALL_CHARACTERS);
+
+		pfile = engine->ParseFile( pfile, token, sizeof(token) );
+	}
+
+	Q_strncat(buystring, "\"", sizeof(buystring), COPY_ALL_CHARACTERS);
+
+	engine->ClientCmd(buystring);
+}
+
+void MsgFunc_KillCam(bf_read &msg) 
+{
+	C_CSPlayer *pPlayer = ToCSPlayer( C_BasePlayer::GetLocalPlayer() );
+
+	if ( !pPlayer )
+		return;
+
+	int newMode = msg.ReadByte();
+
+	if ( newMode != g_nKillCamMode )
+	{
+#if !defined( NO_ENTITY_PREDICTION )
+		if ( g_nKillCamMode == OBS_MODE_NONE )
+		{
+			// kill cam is switch on, turn off prediction
+			g_bForceCLPredictOff = true;
+		}
+		else if ( newMode == OBS_MODE_NONE )
+		{
+			// kill cam is switched off, restore old prediction setting is we switch back to normal mode
+			g_bForceCLPredictOff = false;
+		}
+#endif
+		g_nKillCamMode = newMode;
+	}
+
+	g_nKillCamTarget1	= msg.ReadByte();
+	g_nKillCamTarget2	= msg.ReadByte();
+}
+
+// --------------------------------------------------------------------------------- //
+// CCSModeManager.
+// --------------------------------------------------------------------------------- //
+
+class CCSModeManager : public IVModeManager
+{
+public:
+	virtual void	Init();
+	virtual void	SwitchMode( bool commander, bool force ) {}
+	virtual void	LevelInit( const char *newmap );
+	virtual void	LevelShutdown( void );
+	virtual void	ActivateMouse( bool isactive ) {}
+};
+
+static CCSModeManager g_ModeManager;
+IVModeManager *modemanager = ( IVModeManager * )&g_ModeManager;
+
+// --------------------------------------------------------------------------------- //
+// CCSModeManager implementation.
+// --------------------------------------------------------------------------------- //
+
+#define SCREEN_FILE		"scripts/vgui_screens.txt"
+
+void CCSModeManager::Init()
+{
+	g_pClientMode = GetClientModeNormal();
+	
+	PanelMetaClassMgr()->LoadMetaClassDefinitionFile( SCREEN_FILE );
+}
+
+void CCSModeManager::LevelInit( const char *newmap )
+{
+	g_pClientMode->LevelInit( newmap );
+
+	SetBuyData( cl_autobuy, "autobuy.txt" );
+	SetBuyData( cl_rebuy, "rebuy.txt" );
+
+#if !defined( NO_ENTITY_PREDICTION )
+	if ( g_nKillCamMode > OBS_MODE_NONE )
+	{
+		g_bForceCLPredictOff = false;
+	}
+#endif
+
+	g_nKillCamMode		= OBS_MODE_NONE;
+	g_nKillCamTarget1	= 0;
+	g_nKillCamTarget2	= 0;
+
+	// HACK: the detail sway convars are archive, and default to 0.  Existing CS:S players thus have no detail
+	// prop sway.  We'll force them to DoD's default values for now.
+	if ( !cl_detail_max_sway.GetFloat() &&
+		!cl_detail_avoid_radius.GetFloat() &&
+		!cl_detail_avoid_force.GetFloat() &&
+		!cl_detail_avoid_recover_speed.GetFloat() )
+	{
+		cl_detail_max_sway.SetValue( "5" );
+		cl_detail_avoid_radius.SetValue( "64" );
+		cl_detail_avoid_force.SetValue( "0.4" );
+		cl_detail_avoid_recover_speed.SetValue( "0.25" );
+	}
+}
+
+void CCSModeManager::LevelShutdown( void )
+{
+	g_pClientMode->LevelShutdown();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+ClientModeCSNormal::ClientModeCSNormal()
+{
+	HOOK_MESSAGE( MatchEndConditions );
+}
+
+void ClientModeCSNormal::Init()
+{
+	BaseClass::Init();
+
+	ListenForGameEvent( "round_end" );
+	ListenForGameEvent( "round_start" );
+	ListenForGameEvent( "player_team" );
+	ListenForGameEvent( "player_death" );
+	ListenForGameEvent( "bomb_planted" );
+	ListenForGameEvent( "bomb_exploded" );
+	ListenForGameEvent( "bomb_defused" );
+	ListenForGameEvent( "hostage_killed" );
+	ListenForGameEvent( "hostage_hurt" );	
+
+	usermessages->HookMessage( "KillCam", MsgFunc_KillCam );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Add the shared HUD elements to the render groups responsible for hiding 
+	//		conflicting UI
+	//=============================================================================
+	CHudElement* hintBox = (CHudElement*)GET_HUDELEMENT( CHudHintDisplay );
+	if (hintBox)
+	{
+		hintBox->RegisterForRenderGroup("hide_for_scoreboard");
+		hintBox->RegisterForRenderGroup("hide_for_round_panel");
+	}
+
+
+	CHudElement* historyResource = (CHudElement*)GET_HUDELEMENT( CHudHistoryResource );
+	if (historyResource)
+	{
+		historyResource->RegisterForRenderGroup("hide_for_scoreboard");		
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+void ClientModeCSNormal::InitViewport()
+{
+	BaseClass::InitViewport();
+
+	m_pViewport = new CounterStrikeViewport();
+	m_pViewport->Start( gameuifuncs, gameeventmanager );
+}
+
+
+void ClientModeCSNormal::Update()
+{
+	BaseClass::Update();
+
+	// Override the hud's visibility if this is a logo (like E3 demo) map.
+	if ( CSGameRules() && CSGameRules()->IsLogoMap() )
+		m_pViewport->SetVisible( false );
+}
+
+
+/*
+void ClientModeCSNormal::UpdateSpectatorMode( void )
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+
+	if ( !pPlayer )
+		return;
+
+	IMapOverview * overviewmap = m_pViewport->GetMapOverviewInterface();
+
+	if ( !overviewmap )
+		return;
+
+	overviewmap->SetTime( gpGlobals->curtime );
+
+	int obs_mode = pPlayer->GetObserverMode();
+
+	if ( obs_mode < OBS_MODE_IN_EYE )
+		return;
+
+	Vector worldpos = pPlayer->GetLocalOrigin();
+	QAngle angles; engine->GetViewAngles( angles );
+
+	C_BaseEntity *target = pPlayer->GetObserverTarget();
+
+	if ( target && (obs_mode == OBS_MODE_IN_EYE || obs_mode == OBS_MODE_CHASE) )
+	{
+		worldpos = target->GetAbsOrigin();
+
+		if ( obs_mode == OBS_MODE_IN_EYE )
+		{
+			angles = target->GetAbsAngles();
+		}
+	}
+
+	Vector2D mappos = overviewmap->WorldToMap( worldpos );
+
+	overviewmap->SetCenter( mappos );
+	overviewmap->SetAngle( angles.y );	
+	
+	for ( int i = 1; i<= MAX_PLAYERS; i++)
+	{
+		C_BaseEntity *ent = ClientEntityList().GetEnt( i );
+
+		if ( !ent || !ent->IsPlayer() )
+			continue;
+
+		C_BasePlayer *p = ToBasePlayer( ent );
+
+		// update position of active players in our PVS
+		Vector position = p->GetAbsOrigin();
+		QAngle angle = p->GetAbsAngles();
+
+		if ( p->IsDormant() )
+		{
+			// if player is not in PVS, use PlayerResources data
+			position = g_PR->GetPosition( i );
+			angles[1] = g_PR->GetViewAngle( i );
+		}
+		
+		overviewmap->SetPlayerPositions( i-1, position, angles );
+	}
+} */
+
+//-----------------------------------------------------------------------------
+// Purpose: We've received a keypress from the engine. Return 1 if the engine is allowed to handle it.
+//-----------------------------------------------------------------------------
+int	ClientModeCSNormal::KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
+{
+	// don't process input in LogoMaps
+	if( CSGameRules() && CSGameRules()->IsLogoMap() )
+		return 1;
+	
+	return BaseClass::KeyInput( down, keynum, pszCurrentBinding );
+}
+
+
+
+IClientMode *GetClientModeNormal()
+{
+	static ClientModeCSNormal g_ClientModeNormal;
+	return &g_ClientModeNormal;
+}
+
+
+ClientModeCSNormal* GetClientModeCSNormal()
+{
+	Assert( dynamic_cast< ClientModeCSNormal* >( GetClientModeNormal() ) );
+
+	return static_cast< ClientModeCSNormal* >( GetClientModeNormal() );
+}
+
+float ClientModeCSNormal::GetViewModelFOV( void )
+{
+	return 74.0f;
+}
+
+int ClientModeCSNormal::GetDeathMessageStartHeight( void )
+{
+	return m_pViewport->GetDeathMessageStartHeight();
+}
+
+void ClientModeCSNormal::FireGameEvent( IGameEvent *event )
+{
+	CBaseHudChat *pHudChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
+	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+	CLocalPlayerFilter filter;
+	
+	if ( !pLocalPlayer || !pHudChat )
+		return;
+
+	const char *eventname = event->GetName();
+
+	if ( !eventname || !eventname[0] )
+		return;
+
+	if ( Q_strcmp( "round_start", eventname ) == 0 )
+	{
+		// recreate all client side physics props
+		C_PhysPropClientside::RecreateAll();
+
+		// remove hostage ragdolls
+		for ( int i=0; i<g_HostageRagdolls.Count(); ++i )
+		{
+			// double-check that the EHANDLE is still valid
+			if ( g_HostageRagdolls[i] )
+			{
+				g_HostageRagdolls[i]->Release();
+			}
+		}
+		g_HostageRagdolls.RemoveAll();
+
+		// Just tell engine to clear decals
+		engine->ClientCmd( "r_cleardecals\n" );
+
+		//stop any looping sounds
+		enginesound->StopAllSounds( true );
+
+		Soundscape_OnStopAllSounds();	// Tell the soundscape system.
+	}
+
+
+	else if ( Q_strcmp( "round_end", eventname ) == 0 )
+	{
+		int winningTeam = event->GetInt("winner");
+		int reason = event->GetInt("reason");
+
+		// play endround announcer sound
+		if ( winningTeam == TEAM_CT )
+		{
+			if ( reason == Bomb_Defused )
+			{
+				C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Event.BombDefused");
+			}
+			else
+			{
+				C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Event.CTWin");
+			}
+		}
+		else if ( winningTeam == TEAM_TERRORIST )
+		{
+			C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Event.TERWin");
+		}
+		else
+		{
+			C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Event.RoundDraw");
+		}
+		
+		//=============================================================================
+		// HPE_BEGIN:
+		// [pfreese] Only show centerprint message for game commencing; the rest of 
+		// these messages are handled by the end-of-round panel.
+		// [Forrest] Show all centerprint messages if the end-of-round panel is disabled.
+		//=============================================================================
+		static ConVarRef sv_nowinpanel( "sv_nowinpanel" );
+		static ConVarRef cl_nowinpanel( "cl_nowinpanel" );
+		if ( reason == Game_Commencing || sv_nowinpanel.GetBool() || cl_nowinpanel.GetBool() )
+		{
+			internalCenterPrint->Print( hudtextmessage->LookupString( event->GetString("message") ) );
+
+			// we are starting a new round; clear the current match stats
+			g_CSClientGameStats.ResetMatchStats();
+		}
+		
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+	}
+
+	else if ( Q_strcmp( "player_team", eventname ) == 0 )
+	{
+		CBaseHudChat *pHudChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
+		C_BasePlayer *pPlayer = USERID2PLAYER( event->GetInt("userid") );
+		
+		if ( !pPlayer )
+			return;
+
+		bool bDisconnected = event->GetBool("disconnect");
+
+		if ( bDisconnected )
+			return;
+
+		int iTeam = event->GetInt("team");
+
+		if ( pPlayer->IsLocalPlayer() )
+		{
+			// that's me
+			pPlayer->TeamChange( iTeam );
+		}
+
+		if ( iTeam == TEAM_SPECTATOR )
+			pHudChat->Printf( CHAT_FILTER_NONE, hudtextmessage->LookupString( "#Game_join_spectators" ), pPlayer->GetPlayerName() );
+		else if ( iTeam == TEAM_TERRORIST )
+			pHudChat->Printf( CHAT_FILTER_NONE, hudtextmessage->LookupString( "#Game_join_terrorist" ), pPlayer->GetPlayerName() );
+		else if ( iTeam == TEAM_CT )
+			pHudChat->Printf( CHAT_FILTER_NONE, hudtextmessage->LookupString( "#Game_join_ct" ), pPlayer->GetPlayerName() );
+	}
+
+	else if ( Q_strcmp( "bomb_planted", eventname ) == 0 )
+	{
+		//C_BasePlayer *pPlayer = USERID2PLAYER( event->GetInt("userid") );
+
+		// show centerprint message
+		internalCenterPrint->Print( "#Cstrike_TitlesTXT_Bomb_Planted" );
+
+		// play sound
+		 C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Event.BombPlanted")  ;
+	}
+
+	else if ( Q_strcmp( "bomb_defused", eventname ) == 0 )
+	{
+		// C_BasePlayer *pPlayer = USERID2PLAYER( event->GetInt("userid") );
+	}
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Tell the client side bomb that the bomb has exploding here creating the explosion particle effect
+	//=============================================================================
+	 
+	else if ( Q_strcmp( "bomb_exploded", eventname ) == 0 )
+	{
+		if ( g_PlantedC4s.Count() > 0 )
+		{
+			// bomb is planted
+			C_PlantedC4 *pC4 = g_PlantedC4s[0];
+			pC4->Explode();
+		}
+	}
+	 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	else if ( Q_strcmp( "hostage_killed", eventname ) == 0 )
+	{
+		// play sound for spectators and CTs
+		if ( pLocalPlayer->IsObserver() || (pLocalPlayer->GetTeamNumber() == TEAM_CT) )
+		{
+			C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Event.HostageKilled")  ;
+		}
+
+		// Show warning to killer
+		if ( pLocalPlayer->GetUserID() == event->GetInt("userid") )
+		{
+			internalCenterPrint->Print( "#Cstrike_TitlesTXT_Killed_Hostage" );
+		}
+	}
+
+	else if ( Q_strcmp( "hostage_hurt", eventname ) == 0 )
+	{
+		// Let the loacl player know he harmed a hostage
+		if ( pLocalPlayer->GetUserID() == event->GetInt("userid") )
+		{
+			internalCenterPrint->Print( "#Cstrike_TitlesTXT_Injured_Hostage" );
+		}
+	}
+
+	else if ( Q_strcmp( "player_death", eventname ) == 0 )
+	{
+		C_BasePlayer *pPlayer = USERID2PLAYER( event->GetInt("userid") );
+
+		C_CSPlayer* csPlayer = ToCSPlayer(pPlayer);
+		if (csPlayer)
+		{
+			csPlayer->ClearSoundEvents();
+		}
+
+		if ( pPlayer == C_BasePlayer::GetLocalPlayer() )
+		{
+			// we just died, hide any buy panels
+			gViewPortInterface->ShowPanel( PANEL_BUY, false );
+			gViewPortInterface->ShowPanel( PANEL_BUY_CT, false );
+			gViewPortInterface->ShowPanel( PANEL_BUY_TER, false );
+			gViewPortInterface->ShowPanel( PANEL_BUY_EQUIP_CT, false );
+			gViewPortInterface->ShowPanel( PANEL_BUY_EQUIP_TER, false );
+		}
+	}
+
+	else if ( Q_strcmp( "player_changename", eventname ) == 0 )
+	{
+		return; // server sends a colorized text string for this
+	}
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [tj] We handle this here instead of in the base class 
+    //      The reason is that we don't use string tables to localize.
+    //      Instead, we use the steam localization mechanism.
+    //
+    // [dwenger] Remove dependency on stats system for name of achievement.
+    //=============================================================================
+     
+    else if ( Q_strcmp( "achievement_earned", eventname ) == 0 )
+    {
+        CBaseHudChat *hudChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
+        int iPlayerIndex = event->GetInt( "player" );
+        C_BasePlayer *pPlayer = UTIL_PlayerByIndex( iPlayerIndex );
+        int iAchievement = event->GetInt( "achievement" );
+
+        if ( !hudChat || !pPlayer )
+            return;
+
+
+        CAchievementMgr *pAchievementMgr = dynamic_cast<CAchievementMgr *>( engine->GetAchievementMgr() );
+        if ( !pAchievementMgr )
+            return;
+
+        IAchievement *pAchievement = pAchievementMgr->GetAchievementByID( iAchievement );
+        if ( pAchievement )
+        {
+            if ( !pPlayer->IsDormant() && pPlayer->ShouldAnnounceAchievement() )
+            {
+                pPlayer->SetNextAchievementAnnounceTime( gpGlobals->curtime + ACHIEVEMENT_ANNOUNCEMENT_MIN_TIME );
+
+                //Do something for the player - Actually we should probably do this client-side when the achievement is first earned.
+                if (pPlayer->IsLocalPlayer()) 
+                {
+                }
+                pPlayer->OnAchievementAchieved( iAchievement );
+            }
+
+            if ( g_PR )
+            {
+                wchar_t wszPlayerName[MAX_PLAYER_NAME_LENGTH];
+                g_pVGuiLocalize->ConvertANSIToUnicode( g_PR->GetPlayerName( iPlayerIndex ), wszPlayerName, sizeof( wszPlayerName ) );
+
+                wchar_t achievementName[1024];
+                const wchar_t* constAchievementName = &achievementName[0];
+
+                constAchievementName = ACHIEVEMENT_LOCALIZED_NAME( pAchievement );
+
+                if (constAchievementName)
+                {
+                    wchar_t wszLocalizedString[128];
+                    g_pVGuiLocalize->ConstructString( wszLocalizedString, sizeof( wszLocalizedString ), g_pVGuiLocalize->Find( "#Achievement_Earned" ), 2, wszPlayerName, constAchievementName/*wszAchievementString*/ );
+
+                    char szLocalized[128];
+                    g_pVGuiLocalize->ConvertUnicodeToANSI( wszLocalizedString, szLocalized, sizeof( szLocalized ) );
+
+                    hudChat->ChatPrintf( iPlayerIndex, CHAT_FILTER_ACHIEVEMENT, "%s", szLocalized );
+
+					/*
+                    if (pPlayer->IsLocalPlayer()) 
+                    {
+                        char achievementDescription[1024];
+                        const char* constAchievementDescription = &achievementDescription[0];
+
+                        constAchievementDescription = pUserStats->GetAchievementDisplayAttribute( pAchievement->GetName(), "desc" );  
+                        hudChat->ChatPrintf( iPlayerIndex, CHAT_FILTER_ACHIEVEMENT, "(%s)", constAchievementDescription );
+                    }
+					*/
+                }
+            }
+        }
+    }
+     
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+    
+
+	else
+	{
+		BaseClass::FireGameEvent( event );
+	}
+}
+
+
+void RemoveClassImageEntity()
+{
+	C_BaseAnimating *pEnt = g_ClassImagePlayer.Get();
+	if ( pEnt )
+	{
+		pEnt->Remove();
+		g_ClassImagePlayer = NULL;
+	}
+
+	pEnt = g_ClassImageWeapon.Get();
+	if ( pEnt )
+	{
+		pEnt->Remove();
+		g_ClassImagePlayer = NULL;
+	}
+}
+
+
+bool ShouldRecreateClassImageEntity( C_BaseAnimating *pEnt, const char *pNewModelName )
+{
+	if ( !pNewModelName || !pNewModelName[0] )
+		return false;
+
+	if ( !pEnt )
+		return true;
+
+	const model_t *pModel = pEnt->GetModel();
+
+	if ( !pModel )
+		return true;
+
+	const char *pName = modelinfo->GetModelName( pModel );
+	if ( !pName )
+		return true;
+
+	// reload only if names are different
+	const char *pNameNoPath = V_UnqualifiedFileName( pName );
+	const char *pNewModelNameNoPath = V_UnqualifiedFileName( pNewModelName );
+	return( Q_stricmp( pNameNoPath, pNewModelNameNoPath ) != 0 );
+}
+
+
+void UpdateClassImageEntity( 
+	const char *pModelName,
+	int x, int y, int width, int height )
+{
+	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+	
+	if ( !pLocalPlayer )
+		return;
+
+	MDLCACHE_CRITICAL_SECTION();
+
+	const char *pWeaponName = "models/weapons/w_rif_ak47.mdl";
+	const char *pWeaponSequence = "Walk_Upper_AK";
+
+	int i;
+	for ( i=0; i<CTPlayerModels.Count(); ++i )
+	{
+		if ( Q_strcasecmp( pModelName, CTPlayerModels[i] ) == 0 )
+		{
+			// give CTs a M4
+			pWeaponName = "models/weapons/w_rif_m4a1.mdl";
+			pWeaponSequence = "Walk_Upper_M4";
+			break;
+		}
+	}
+
+	if ( pLocalPlayer->IsAlive() && pLocalPlayer->GetActiveWeapon() )
+	{
+		C_WeaponCSBase *weapon = dynamic_cast< C_WeaponCSBase * >(pLocalPlayer->GetActiveWeapon());
+		if ( weapon )
+		{
+			pWeaponName = weapon->GetWorldModel();
+			pWeaponSequence = VarArgs("Walk_Upper_%s", weapon->GetCSWpnData().m_szAnimExtension);
+		}
+	}
+
+	C_BaseAnimatingOverlay *pPlayerModel = g_ClassImagePlayer.Get();
+
+	// Does the entity even exist yet?
+	bool recreatePlayer = ShouldRecreateClassImageEntity( pPlayerModel, pModelName );
+	if ( recreatePlayer )
+	{
+		if ( pPlayerModel )
+			pPlayerModel->Remove();
+
+		pPlayerModel = new C_BaseAnimatingOverlay;
+		pPlayerModel->InitializeAsClientEntity( pModelName, RENDER_GROUP_OPAQUE_ENTITY );
+		pPlayerModel->AddEffects( EF_NODRAW ); // don't let the renderer draw the model normally
+
+		// let player walk ahead
+		pPlayerModel->SetSequence( pPlayerModel->LookupSequence( "walk_lower" ) );
+		pPlayerModel->SetPoseParameter( "move_yaw", 0.0f ); // move_yaw
+		pPlayerModel->SetPoseParameter( "body_pitch", 10.0f ); // body_pitch, look down a bit
+		pPlayerModel->SetPoseParameter( "body_yaw", 0.0f ); // body_yaw
+		pPlayerModel->SetPoseParameter( "move_y", 0.0f ); // move_y
+		pPlayerModel->SetPoseParameter( "move_x", 1.0f ); // move_x, walk forward
+		pPlayerModel->m_flAnimTime = gpGlobals->curtime;
+
+		g_ClassImagePlayer = pPlayerModel;
+	}
+
+	C_BaseAnimating *pWeaponModel = g_ClassImageWeapon.Get();
+
+	// Does the entity even exist yet?
+	if ( recreatePlayer || ShouldRecreateClassImageEntity( pWeaponModel, pWeaponName ) )
+	{
+		if ( pWeaponModel )
+			pWeaponModel->Remove();
+
+		pWeaponModel = new C_BaseAnimating;
+		pWeaponModel->InitializeAsClientEntity( pWeaponName, RENDER_GROUP_OPAQUE_ENTITY );
+		pWeaponModel->AddEffects( EF_NODRAW ); // don't let the renderer draw the model normally
+		pWeaponModel->FollowEntity( pPlayerModel ); // attach to player model
+		pWeaponModel->m_flAnimTime = gpGlobals->curtime;
+		g_ClassImageWeapon = pWeaponModel;
+	}
+
+	Vector origin = pLocalPlayer->EyePosition();
+	Vector lightOrigin = origin;
+
+	// find a spot inside the world for the dlight's origin, or it won't illuminate the model
+	Vector testPos( origin.x - 100, origin.y, origin.z + 100 );
+	trace_t tr;
+	UTIL_TraceLine( origin, testPos, MASK_OPAQUE, pLocalPlayer, COLLISION_GROUP_NONE, &tr );
+	if ( tr.fraction == 1.0f )
+	{
+		lightOrigin = tr.endpos;
+	}
+	else
+	{
+		// Now move the model away so we get the correct illumination
+		lightOrigin = tr.endpos + Vector( 1, 0, -1 );	// pull out from the solid
+		Vector start = lightOrigin;
+		Vector end = lightOrigin + Vector( 100, 0, -100 );
+		UTIL_TraceLine( start, end, MASK_OPAQUE, pLocalPlayer, COLLISION_GROUP_NONE, &tr );
+		origin = tr.endpos;
+	}
+
+	// move player model in front of our view
+	pPlayerModel->SetAbsOrigin( origin );
+	pPlayerModel->SetAbsAngles( QAngle( 0, 210, 0 ) );
+
+	// wacky hacky, set upper body animation
+	pPlayerModel->m_SequenceTransitioner.CheckForSequenceChange( 
+		pPlayerModel->GetModelPtr(),
+		pPlayerModel->LookupSequence( "walk_lower" ),
+		false,
+		true
+	);
+	pPlayerModel->m_SequenceTransitioner.UpdateCurrent( 
+		pPlayerModel->GetModelPtr(),
+		pPlayerModel->LookupSequence( "walk_lower" ),
+		pPlayerModel->GetCycle(),
+		pPlayerModel->GetPlaybackRate(),
+		gpGlobals->realtime
+	);
+
+	// Now, blend the lower and upper (aim) anims together
+	pPlayerModel->SetNumAnimOverlays( 2 );
+	int numOverlays = pPlayerModel->GetNumAnimOverlays();
+	for ( i=0; i < numOverlays; ++i )
+	{
+		C_AnimationLayer *layer = pPlayerModel->GetAnimOverlay( i );
+
+		layer->m_flCycle = pPlayerModel->GetCycle();
+		if ( i )
+			layer->m_nSequence = pPlayerModel->LookupSequence( pWeaponSequence );
+		else
+			layer->m_nSequence = pPlayerModel->LookupSequence( "walk_lower" );
+
+		layer->m_flPlaybackRate = 1.0;
+		layer->m_flWeight = 1.0f;
+		layer->SetOrder( i );
+	}
+
+	pPlayerModel->FrameAdvance( gpGlobals->frametime );
+
+	// Now draw it.
+	CViewSetup view;
+	view.x = x;
+	view.y = y;
+	view.width = width;
+	view.height = height;
+
+	view.m_bOrtho = false;
+	view.fov = 54;
+
+	view.origin = origin + Vector( -110, -5, -5 );
+
+	Vector vMins, vMaxs;
+	pPlayerModel->C_BaseAnimating::GetRenderBounds( vMins, vMaxs );
+	view.origin.z += ( vMins.z + vMaxs.z ) * 0.55f;
+
+	view.angles.Init();
+	view.zNear = VIEW_NEARZ;
+	view.zFar = 1000;
+
+	Frustum dummyFrustum;
+	render->Push3DView( view, 0, NULL, dummyFrustum );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [mhansen] We don't want to light the model in the world.  We want it to 
+	// always be lit normal like even if you are standing in a dark (or green) area
+	// in the world.
+	//=============================================================================
+	CMatRenderContextPtr pRenderContext( materials );
+	pRenderContext->SetLightingOrigin( vec3_origin );
+	pRenderContext->SetAmbientLight( 0.4, 0.4, 0.4 );
+
+	static Vector white[6] = 
+	{
+		Vector( 0.4, 0.4, 0.4 ),
+		Vector( 0.4, 0.4, 0.4 ),
+		Vector( 0.4, 0.4, 0.4 ),
+		Vector( 0.4, 0.4, 0.4 ),
+		Vector( 0.4, 0.4, 0.4 ),
+		Vector( 0.4, 0.4, 0.4 ),
+	};
+
+	g_pStudioRender->SetAmbientLightColors( white );
+	g_pStudioRender->SetLocalLights( 0, NULL );
+
+	modelrender->SuppressEngineLighting( true );
+	float color[3] = { 1.0f, 1.0f, 1.0f };
+	render->SetColorModulation( color );
+	render->SetBlend( 1.0f );
+	pPlayerModel->DrawModel( STUDIO_RENDER );
+
+	if ( pWeaponModel )
+	{
+		pWeaponModel->DrawModel( STUDIO_RENDER );
+	}
+
+	modelrender->SuppressEngineLighting( false );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	render->PopView( dummyFrustum );
+}
+
+
+bool WillPanelBeVisible( vgui::VPANEL hPanel )
+{
+	while ( hPanel )
+	{
+		if ( !vgui::ipanel()->IsVisible( hPanel ) )
+			return false;
+
+		hPanel = vgui::ipanel()->GetParent( hPanel );
+	}
+	return true;
+}
+
+
+
+void ClientModeCSNormal::PostRenderVGui()
+{
+	// If the team menu is up, then we will render the model of the character that is currently selected.
+	for ( int i=0; i < g_ClassImagePanels.Count(); i++ )
+	{
+		CCSClassImagePanel *pPanel = g_ClassImagePanels[i];
+		if ( WillPanelBeVisible( pPanel->GetVPanel() ) )
+		{
+			// Ok, we have a visible class image panel.
+			int x, y, w, h;
+			pPanel->GetBounds( x, y, w, h );
+			pPanel->LocalToScreen( x, y );
+
+			// Allow for the border.
+			x += 3;
+			y += 5;
+			w -= 2;
+			h -= 10;
+
+			UpdateClassImageEntity( g_ClassImagePanels[i]->m_ModelName, x, y, w, h );
+			return;
+		}
+	}
+}
+
+bool ClientModeCSNormal::ShouldDrawViewModel( void )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	
+	if( pPlayer && pPlayer->GetFOV() != CSGameRules()->DefaultFOV() )
+	{
+		CWeaponCSBase *pWpn = pPlayer->GetActiveCSWeapon();
+
+		if( pWpn && pWpn->HideViewModelWhenZoomed() )
+		{
+			return false;
+		}
+	}
+
+	return BaseClass::ShouldDrawViewModel();
+}
+
+
+bool ClientModeCSNormal::CanRecordDemo( char *errorMsg, int length ) const
+{
+	C_CSPlayer *player = C_CSPlayer::GetLocalCSPlayer();
+	if ( !player )
+	{
+		return true;
+	}
+
+	if ( !player->IsAlive() )
+	{
+		return true;
+	}
+
+	// don't start recording while flashed, as it would remove the flash
+	if ( player->m_flFlashBangTime > gpGlobals->curtime )
+	{
+		Q_strncpy( errorMsg, "Cannot record demos while blind.", length );
+		return false;
+	}
+
+	// don't start recording while smoke grenades are spewing smoke, as the existing smoke would be destroyed
+	C_BaseEntityIterator it;
+	C_BaseEntity *ent;
+	while ( (ent = it.Next()) != NULL )
+	{
+		if ( Q_strcmp( ent->GetClassname(), "class C_ParticleSmokeGrenade" ) == 0 )
+		{
+			Q_strncpy( errorMsg, "Cannot record demos while a smoke grenade is active.", length );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Save server information shown to the client in a persistent place
+//=============================================================================
+ 
+void ClientModeCSNormal::SetServerName(wchar_t* name)
+{
+	V_wcsncpy(m_pServerName, name, sizeof( m_pServerName ) );
+}
+
+void ClientModeCSNormal::SetMapName(wchar_t* name)
+{
+	V_wcsncpy(m_pMapName, name, sizeof( m_pMapName ) );
+}
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+// Receive the PlayerIgnited user message and send out a clientside event for achievements to hook.
+void __MsgFunc_MatchEndConditions( bf_read &msg )
+{
+	int iFragLimit = (int) msg.ReadLong();
+	int iMaxRounds = (int) msg.ReadLong();
+	int iWinRounds = (int) msg.ReadLong();
+	int iTimeLimit = (int) msg.ReadLong();
+
+	IGameEvent *event = gameeventmanager->CreateEvent( "match_end_conditions" );
+	if ( event )
+	{
+		event->SetInt( "frags", iFragLimit );
+		event->SetInt( "max_rounds", iMaxRounds );
+		event->SetInt( "win_rounds", iWinRounds );
+		event->SetInt( "time", iTimeLimit );
+		gameeventmanager->FireEventClientSide( event );
+	}
+}
diff --git a/game/client/cstrike/clientmode_csnormal.h b/game/client/cstrike/clientmode_csnormal.h
new file mode 100644
index 00000000..38e60583
--- /dev/null
+++ b/game/client/cstrike/clientmode_csnormal.h
@@ -0,0 +1,68 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef CS_CLIENTMODE_H
+#define CS_CLIENTMODE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "clientmode_shared.h"
+#include "counterstrikeviewport.h"
+
+class ClientModeCSNormal : public ClientModeShared 
+{
+DECLARE_CLASS( ClientModeCSNormal, ClientModeShared );
+
+private:
+
+// IClientMode overrides.
+public:
+
+					ClientModeCSNormal();
+
+	virtual void	Init();
+	virtual void	InitViewport();
+	virtual void	Update();
+
+	virtual int		KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
+
+	virtual float	GetViewModelFOV( void );
+
+	int				GetDeathMessageStartHeight( void );
+
+	virtual void	FireGameEvent( IGameEvent *event );
+	virtual void	PostRenderVGui();
+
+	virtual bool	ShouldDrawViewModel( void );
+
+	virtual bool	CanRecordDemo( char *errorMsg, int length ) const;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Save server information shown to the client in a persistent place
+	//=============================================================================
+	 
+	virtual wchar_t* GetServerName() { return m_pServerName; }
+	virtual void SetServerName(wchar_t* name);
+	virtual wchar_t* GetMapName() { return m_pMapName; }
+	virtual void SetMapName(wchar_t* name);
+
+private:
+	wchar_t			m_pServerName[256];
+	wchar_t			m_pMapName[256];
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+};
+
+
+extern IClientMode *GetClientModeNormal();
+extern ClientModeCSNormal* GetClientModeCSNormal();
+
+
+#endif // CS_CLIENTMODE_H
diff --git a/game/client/cstrike/cs_client_gamestats.cpp b/game/client/cstrike/cs_client_gamestats.cpp
new file mode 100644
index 00000000..8a8ea542
--- /dev/null
+++ b/game/client/cstrike/cs_client_gamestats.cpp
@@ -0,0 +1,789 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//-------------------------------------------------------------
+// File:		cs_client_gamestats.cpp
+// Desc: 		Manages client side stat storage, accumulation, and access
+// Author: 		Peter Freese <peter@hiddenpath.com>
+// Date: 		2009/09/11
+// Copyright:	© 2009 Hidden Path Entertainment
+//
+// Keywords: 	
+//-------------------------------------------------------------
+
+#include "cbase.h"
+#include "cs_client_gamestats.h"
+#include "achievementmgr.h"
+#include "engine/imatchmaking.h"
+#include "ipresence.h"
+#include "usermessages.h"
+#include "c_cs_player.h"
+#include "achievements_cs.h"
+#include "vgui/ILocalize.h"
+#include "c_team.h"
+#include "../shared/steamworks_gamestats.h"
+
+CCSClientGameStats g_CSClientGameStats;
+
+void MsgFunc_PlayerStatsUpdate( bf_read &msg )
+{
+	g_CSClientGameStats.MsgFunc_PlayerStatsUpdate(msg);
+}
+
+void MsgFunc_MatchStatsUpdate( bf_read &msg )
+{
+	g_CSClientGameStats.MsgFunc_MatchStatsUpdate(msg);
+}
+
+CCSClientGameStats::StatContainerList_t* CCSClientGameStats::s_StatLists = new CCSClientGameStats::StatContainerList_t();
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSClientGameStats::CCSClientGameStats() 
+{
+	m_bSteamStatsDownload = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called at init time after all systems are init'd.  We have to
+//			do this in PostInit because the Steam app ID is not available earlier
+//-----------------------------------------------------------------------------
+void CCSClientGameStats::PostInit()
+{
+	// listen for events
+	ListenForGameEvent( "player_stats_updated" );
+	ListenForGameEvent( "user_data_downloaded" );
+	ListenForGameEvent( "round_end" );
+	ListenForGameEvent( "round_start" );
+
+
+	usermessages->HookMessage( "PlayerStatsUpdate", ::MsgFunc_PlayerStatsUpdate );
+	usermessages->HookMessage( "MatchStatsUpdate", ::MsgFunc_MatchStatsUpdate );
+
+	GetSteamWorksSGameStatsUploader().StartSession();
+
+	m_RoundEndReason = Invalid_Round_End_Reason;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called at level shutdown
+//-----------------------------------------------------------------------------
+void CCSClientGameStats::LevelShutdownPreEntity()
+{
+	// This is a good opportunity to update our last match stats
+	UpdateLastMatchStats();
+
+	// upload user stats to Steam on every map change
+	UpdateSteamStats();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called at app shutdown
+//-----------------------------------------------------------------------------
+void CCSClientGameStats::Shutdown()
+{
+	GetSteamWorksSGameStatsUploader().EndSession();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSClientGameStats::LevelShutdownPreClearSteamAPIContext( void )
+{
+	UploadRoundData();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the stats have changed in-game
+//-----------------------------------------------------------------------------
+void CCSClientGameStats::FireGameEvent( IGameEvent *event )
+{
+	const char *pEventName = event->GetName();
+	if ( 0 == Q_strcmp( pEventName, "player_stats_updated" ) )
+	{
+		UpdateSteamStats();
+	}
+	else if ( 0 == Q_strcmp( pEventName, "user_data_downloaded" ) )
+	{
+		RetrieveSteamStats();
+	}
+	else if ( Q_strcmp( pEventName, "round_end" ) == 0 )
+	{
+		// Store off the reason the round ended. Used with the OGS data.
+		m_RoundEndReason = event->GetInt( "reason", Invalid_Round_End_Reason );
+
+		// update player count for last match stats
+		int iCurrentPlayerCount = 0;
+		if ( GetGlobalTeam(TEAM_CT) != NULL )
+			iCurrentPlayerCount += GetGlobalTeam(TEAM_CT)->Get_Number_Players();
+		if ( GetGlobalTeam(TEAM_TERRORIST) != NULL )
+			iCurrentPlayerCount += GetGlobalTeam(TEAM_TERRORIST)->Get_Number_Players();
+
+		m_matchMaxPlayerCount = MAX(m_matchMaxPlayerCount, iCurrentPlayerCount);
+	}
+
+	// The user stats for a round get sent piece meal, so we'll wait until a new round starts
+	// before sending the previous round stats.
+	else if ( Q_strcmp( pEventName, "round_start" ) == 0 && m_roundStats[CSSTAT_PLAYTIME] > 0 )
+	{
+		SRoundData *pRoundStatData = new SRoundData( &m_roundStats);
+		C_CSPlayer *pPlayer = ToCSPlayer( C_BasePlayer::GetLocalPlayer() );
+		if ( pPlayer )
+		{
+			// Our current money + what we spent is what we started with at the beginning of round
+			pRoundStatData->nStartingMoney = pPlayer->GetAccount() + m_roundStats[CSSTAT_MONEY_SPENT];
+		}
+		m_RoundStatData.AddToTail( pRoundStatData );
+		UploadRoundData();
+		m_roundStats.Reset();
+	}	
+}
+
+void CCSClientGameStats::RetrieveSteamStats()
+{
+	Assert( steamapicontext->SteamUserStats() );
+	if ( !steamapicontext->SteamUserStats() )
+		return;
+
+	// we shouldn't be downloading stats more than once
+	Assert(m_bSteamStatsDownload == false);
+	if (m_bSteamStatsDownload)
+		return;
+
+	int nStatFailCount = 0;
+	for ( int i = 0; i < CSSTAT_MAX; ++i )
+	{
+		if ( CSStatProperty_Table[i].szSteamName == NULL )
+			continue;
+
+		int iData;
+		if ( steamapicontext->SteamUserStats()->GetStat( CSStatProperty_Table[i].szSteamName, &iData ) )
+		{	
+			m_lifetimeStats[CSStatProperty_Table[i].statId] = iData;
+		}
+		else
+		{
+			++nStatFailCount;
+		}
+	}
+
+	if ( nStatFailCount > 0 )
+	{
+		Msg("RetrieveSteamStats: failed to get %i stats\n", nStatFailCount);
+		return;
+	}
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_stats_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+
+	m_bSteamStatsDownload = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Uploads stats for current Steam user to Steam
+//-----------------------------------------------------------------------------
+void CCSClientGameStats::UpdateSteamStats()
+{
+	// only upload if Steam is running
+	if ( !steamapicontext->SteamUserStats() )
+		return; 
+
+	CAchievementMgr *pAchievementMgr = dynamic_cast<CAchievementMgr *>( engine->GetAchievementMgr() );
+	Assert(pAchievementMgr != NULL);
+	if (!pAchievementMgr)
+		return;
+
+	// don't upload any stats if we haven't successfully download stats yet
+	if ( !m_bSteamStatsDownload )
+	{
+		// try to periodically download stats from Steam if we haven't gotten them yet
+		static float fLastStatsRetrieveTime = 0.0f;
+		const float kRetrieveInterval = 30.0f;
+		if ( gpGlobals->curtime > fLastStatsRetrieveTime + kRetrieveInterval )
+		{
+			pAchievementMgr->DownloadUserData();
+			fLastStatsRetrieveTime = gpGlobals->curtime;
+		}
+
+		return;
+	}
+
+	for ( int i = 0; i < CSSTAT_MAX; ++i )
+	{
+		if ( CSStatProperty_Table[i].szSteamName == NULL )
+			continue;
+
+		// set the stats locally in Steam client
+		steamapicontext->SteamUserStats()->SetStat( CSStatProperty_Table[i].szSteamName, m_lifetimeStats[CSStatProperty_Table[i].statId]);
+	}
+
+	// let the achievement manager know the stats have changed
+	pAchievementMgr->SetDirty(true);
+}
+
+CON_COMMAND_F( stats_reset, "Resets all player stats", FCVAR_CLIENTDLL )
+{
+	g_CSClientGameStats.ResetAllStats();
+}
+
+CON_COMMAND_F( stats_dump, "Dumps all player stats", FCVAR_DEVELOPMENTONLY )
+{
+	Msg( "Accumulated stats on Steam\n");
+
+	const StatsCollection_t& accumulatedStats = g_CSClientGameStats.GetLifetimeStats();
+
+	for ( int i = 0; i < CSSTAT_MAX; ++i )
+	{
+		if ( CSStatProperty_Table[i].szSteamName == NULL )
+			continue;
+
+		Msg( "%42s: %i\n", CSStatProperty_Table[i].szSteamName, accumulatedStats[CSStatProperty_Table[i].statId]);
+	}
+}
+
+#if defined(_DEBUG)
+CON_COMMAND_F( stats_preload, "Load stats with data ripe for getting achievmenets", FCVAR_DEVELOPMENTONLY )
+{
+	struct DataSet
+	{
+		CSStatType_t	statId;
+		int				value;
+	};
+
+	DataSet statData[] = 
+	{
+		{ CSSTAT_KILLS, 9999},
+		{ CSSTAT_ROUNDS_WON, 4999},
+		{ CSSTAT_PISTOLROUNDS_WON, 249},
+		{ CSSTAT_MONEY_EARNED, 49999999},
+		{ CSSTAT_DAMAGE, 999999},
+		{ CSSTAT_KILLS_DEAGLE, 199},
+		{ CSSTAT_KILLS_USP, 199},
+		{ CSSTAT_KILLS_GLOCK, 199},
+		{ CSSTAT_KILLS_P228, 199},
+		{ CSSTAT_KILLS_ELITE, 99},
+		{ CSSTAT_KILLS_FIVESEVEN, 99},
+		{ CSSTAT_KILLS_AWP, 999},
+		{ CSSTAT_KILLS_AK47, 999},
+		{ CSSTAT_KILLS_M4A1, 999},
+		{ CSSTAT_KILLS_AUG, 499},
+		{ CSSTAT_KILLS_SG552, 499},
+		{ CSSTAT_KILLS_SG550, 499},
+		{ CSSTAT_KILLS_GALIL, 499},
+		{ CSSTAT_KILLS_FAMAS, 499},
+		{ CSSTAT_KILLS_SCOUT, 999},
+		{ CSSTAT_KILLS_G3SG1, 499},
+		{ CSSTAT_KILLS_P90, 999},
+		{ CSSTAT_KILLS_MP5NAVY, 999},
+		{ CSSTAT_KILLS_TMP, 499},
+		{ CSSTAT_KILLS_MAC10, 499},
+		{ CSSTAT_KILLS_UMP45, 999},
+		{ CSSTAT_KILLS_M3, 199},
+		{ CSSTAT_KILLS_XM1014, 199},
+		{ CSSTAT_KILLS_M249, 499},
+		{ CSSTAT_KILLS_KNIFE, 99},
+		{ CSSTAT_KILLS_HEGRENADE, 499},
+		{ CSSTAT_KILLS_HEADSHOT, 249},
+		{ CSSTAT_KILLS_ENEMY_WEAPON, 99},
+		{ CSSTAT_KILLS_ENEMY_BLINDED, 24},
+		{ CSSTAT_NUM_BOMBS_DEFUSED, 99},
+		{ CSSTAT_NUM_BOMBS_PLANTED, 99},
+		{ CSSTAT_NUM_HOSTAGES_RESCUED, 499},
+		{ CSSTAT_KILLS_KNIFE_FIGHT, 99},
+		{ CSSTAT_DECAL_SPRAYS, 99},
+		{ CSSTAT_NIGHTVISION_DAMAGE, 4999},
+		{ CSSTAT_KILLS_AGAINST_ZOOMED_SNIPER, 99},
+		{ CSSTAT_MAP_WINS_CS_ASSAULT, 99},
+		{ CSSTAT_MAP_WINS_CS_COMPOUND, 99},
+		{ CSSTAT_MAP_WINS_CS_HAVANA, 99},
+		{ CSSTAT_MAP_WINS_CS_ITALY, 99},
+		{ CSSTAT_MAP_WINS_CS_MILITIA, 99},
+		{ CSSTAT_MAP_WINS_CS_OFFICE, 99},
+		{ CSSTAT_MAP_WINS_DE_AZTEC, 99},
+		{ CSSTAT_MAP_WINS_DE_CBBLE, 99},
+		{ CSSTAT_MAP_WINS_DE_CHATEAU, 99},
+		{ CSSTAT_MAP_WINS_DE_DUST2, 99},
+		{ CSSTAT_MAP_WINS_DE_DUST, 99},
+		{ CSSTAT_MAP_WINS_DE_INFERNO, 99},
+		{ CSSTAT_MAP_WINS_DE_NUKE, 99},
+		{ CSSTAT_MAP_WINS_DE_PIRANESI, 99},
+		{ CSSTAT_MAP_WINS_DE_PORT, 99},
+		{ CSSTAT_MAP_WINS_DE_PRODIGY, 99},
+		{ CSSTAT_MAP_WINS_DE_TIDES, 99},
+		{ CSSTAT_MAP_WINS_DE_TRAIN, 99},
+		{ CSSTAT_WEAPONS_DONATED, 99},
+		{ CSSTAT_DOMINATIONS, 9},
+		{ CSSTAT_DOMINATION_OVERKILLS, 99},
+		{ CSSTAT_REVENGES, 19},
+	};
+
+	StatsCollection_t& lifetimeStats = const_cast<StatsCollection_t&>(g_CSClientGameStats.GetLifetimeStats());
+
+	for ( int i = 0; i < ARRAYSIZE(statData); ++i )
+	{
+		CSStatType_t statId = statData[i].statId;
+		lifetimeStats[statId] = statData[i].value;
+	}
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_stats_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+}
+#endif
+
+#if defined(_DEBUG)
+CON_COMMAND_F( stats_corrupt, "Load stats with corrupt values", FCVAR_DEVELOPMENTONLY )
+{
+	struct DataSet
+	{
+		CSStatType_t	statId;
+		int				value;
+	};
+
+	DataSet badData[] = 
+	{
+		{ CSSTAT_SHOTS_HIT,						0x40000089	},
+		{ CSSTAT_SHOTS_FIRED,					0x400002BE	},
+		{ CSSTAT_KILLS,							0x40000021	},
+		{ CSSTAT_DEATHS,						0x00000056	},
+		{ CSSTAT_DAMAGE,						0x00000FE3	},
+		{ CSSTAT_NUM_BOMBS_PLANTED, 			0x00000004	},
+		{ CSSTAT_NUM_BOMBS_DEFUSED, 			0x00000000	},
+		{ CSSTAT_PLAYTIME,						0x40000F46	},
+		{ CSSTAT_ROUNDS_WON,					0x40000028	},
+		{ CSSTAT_ROUNDS_PLAYED,					0x40001019	},
+		{ CSSTAT_PISTOLROUNDS_WON,				0x00000001	},
+		{ CSSTAT_MONEY_EARNED,					0x00021E94	},
+		{ CSSTAT_KILLS_DEAGLE,					0x00000009	},
+		{ CSSTAT_KILLS_USP,						0x00000000	},
+		{ CSSTAT_KILLS_GLOCK,					0x00000002	},
+		{ CSSTAT_KILLS_P228,					0x00000000	},
+		{ CSSTAT_KILLS_ELITE,					0x00000000	},
+		{ CSSTAT_KILLS_FIVESEVEN,				0x00000000	},
+		{ CSSTAT_KILLS_AWP,						0x00000000	},
+		{ CSSTAT_KILLS_AK47,					0x00000001	},
+		{ CSSTAT_KILLS_M4A1,					0x00000000	},
+		{ CSSTAT_KILLS_AUG,						0x00000000	},
+		{ CSSTAT_KILLS_SG552, 					0x00000000	},
+		{ CSSTAT_KILLS_SG550, 					0x00000000	},
+		{ CSSTAT_KILLS_GALIL, 					0x00000000	},
+		{ CSSTAT_KILLS_FAMAS, 					0x00000001	},
+		{ CSSTAT_KILLS_SCOUT, 					0x00000000	},
+		{ CSSTAT_KILLS_G3SG1, 					0x00000000	},
+		{ CSSTAT_KILLS_P90,						0x00000001	},
+		{ CSSTAT_KILLS_MP5NAVY,					0x00000000	},
+		{ CSSTAT_KILLS_TMP,						0x00000002	},
+		{ CSSTAT_KILLS_MAC10,					0x00000000	},
+		{ CSSTAT_KILLS_UMP45,					0x00000001	},
+		{ CSSTAT_KILLS_M3,						0x00000000	},
+		{ CSSTAT_KILLS_XM1014,					0x0000000A	},
+		{ CSSTAT_KILLS_M249,					0x00000000	},
+		{ CSSTAT_KILLS_KNIFE,					0x00000000	},
+		{ CSSTAT_KILLS_HEGRENADE,				0x00000000	},
+		{ CSSTAT_SHOTS_DEAGLE,					0x0000004C	},
+		{ CSSTAT_SHOTS_USP,						0x00000001	},
+		{ CSSTAT_SHOTS_GLOCK,					0x00000017	},
+		{ CSSTAT_SHOTS_P228,					0x00000000	},
+		{ CSSTAT_SHOTS_ELITE,					0x00000000	},
+		{ CSSTAT_SHOTS_FIVESEVEN,				0x00000000	},
+		{ CSSTAT_SHOTS_AWP,						0x00000000	},
+		{ CSSTAT_SHOTS_AK47,					0x0000000E	},
+		{ CSSTAT_SHOTS_M4A1,					0x00000000	},
+		{ CSSTAT_SHOTS_AUG,						0x00000000	},
+		{ CSSTAT_SHOTS_SG552,					0x00000000	},
+		{ CSSTAT_SHOTS_SG550,					0x00000008	},
+		{ CSSTAT_SHOTS_GALIL,					0x00000000	},
+		{ CSSTAT_SHOTS_FAMAS,					0x00000010	},
+		{ CSSTAT_SHOTS_SCOUT,					0x00000000	},
+		{ CSSTAT_SHOTS_G3SG1,					0x00000000	},
+		{ CSSTAT_SHOTS_P90,						0x0000007F	},
+		{ CSSTAT_SHOTS_MP5NAVY, 				0x00000000	},
+		{ CSSTAT_SHOTS_TMP,						0x00000010	},
+		{ CSSTAT_SHOTS_MAC10,					0x00000000	},
+		{ CSSTAT_SHOTS_UMP45,					0x00000015	},
+		{ CSSTAT_SHOTS_M3,						0x00000009	},
+		{ CSSTAT_SHOTS_XM1014,					0x0000024C	},
+		{ CSSTAT_SHOTS_M249,					0x00000000	},
+		{ CSSTAT_HITS_DEAGLE,					0x00000019	},
+		{ CSSTAT_HITS_USP,						0x00000000	},
+		{ CSSTAT_HITS_GLOCK,					0x0000000A	},
+		{ CSSTAT_HITS_P228,						0x00000000	},
+		{ CSSTAT_HITS_ELITE,					0x00000000	},
+		{ CSSTAT_HITS_FIVESEVEN,				0x00000000	},
+		{ CSSTAT_HITS_AWP,						0x00000000	},
+		{ CSSTAT_HITS_AK47,						0x00000003	},
+		{ CSSTAT_HITS_M4A1,						0x00000000	},
+		{ CSSTAT_HITS_AUG,						0x00000000	},
+		{ CSSTAT_HITS_SG552,					0x00000000	},
+		{ CSSTAT_HITS_SG550,					0x00000001	},
+		{ CSSTAT_HITS_GALIL,					0x00000000	},
+		{ CSSTAT_HITS_FAMAS,					0x00000007	},
+		{ CSSTAT_HITS_SCOUT,					0x00000000	},
+		{ CSSTAT_HITS_G3SG1,					0x00000000	},
+		{ CSSTAT_HITS_P90,						0x0000000D	},
+		{ CSSTAT_HITS_MP5NAVY,					0x00000000	},
+		{ CSSTAT_HITS_TMP,						0x00000006	},
+		{ CSSTAT_HITS_MAC10,					0x00000000	},
+		{ CSSTAT_HITS_UMP45,					0x00000006	},
+		{ CSSTAT_HITS_M3,						0x00000000	},
+		{ CSSTAT_HITS_XM1014,					0x0000004C	},
+		{ CSSTAT_HITS_M249,						0x00000000	},
+		{ CSSTAT_KILLS_HEADSHOT,				0x00000013	},
+		{ CSSTAT_KILLS_ENEMY_BLINDED,			0x00000002	},
+		{ CSSTAT_KILLS_ENEMY_WEAPON,			0x00000002	},
+		{ CSSTAT_KILLS_KNIFE_FIGHT,				0x00000000	},
+		{ CSSTAT_DECAL_SPRAYS,					0x00000000	},
+		{ CSSTAT_NIGHTVISION_DAMAGE,			0x00000000	},
+		{ CSSTAT_NUM_HOSTAGES_RESCUED,			0x00000000	},
+		{ CSSTAT_NUM_BROKEN_WINDOWS,			0x00000000	},
+		{ CSSTAT_KILLS_AGAINST_ZOOMED_SNIPER,	0x00000000	},
+		{ CSSTAT_WEAPONS_DONATED,				0x00000000	},
+		{ CSSTAT_DOMINATIONS,					0x00000001	},
+		{ CSSTAT_DOMINATION_OVERKILLS,			0x00000000	},
+		{ CSSTAT_REVENGES,						0x00000000	},
+		{ CSSTAT_MVPS,							0x00000005	},
+		{ CSSTAT_MAP_WINS_CS_ASSAULT,			0x00000000	},
+		{ CSSTAT_MAP_WINS_CS_COMPOUND,			0x00000000	},
+		{ CSSTAT_MAP_WINS_CS_HAVANA,			0x00000000	},
+		{ CSSTAT_MAP_WINS_CS_ITALY,				0x40000002	},
+		{ CSSTAT_MAP_WINS_CS_MILITIA,			0x00000000	},
+		{ CSSTAT_MAP_WINS_CS_OFFICE,			0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_AZTEC,				0x0000000A	},
+		{ CSSTAT_MAP_WINS_DE_CBBLE,				0x40000000	},
+		{ CSSTAT_MAP_WINS_DE_CHATEAU,			0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_DUST2,				0x0000000B	},
+		{ CSSTAT_MAP_WINS_DE_DUST,				0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_INFERNO,			0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_NUKE,				0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_PIRANESI,			0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_PORT,				0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_PRODIGY,			0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_TIDES,				0x00000000	},
+		{ CSSTAT_MAP_WINS_DE_TRAIN,				0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_CS_ASSAULT, 		0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_CS_COMPOUND,		0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_CS_HAVANA,			0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_CS_ITALY,			0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_CS_MILITIA, 		0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_CS_OFFICE,			0x00000003	},
+		{ CSSTAT_MAP_ROUNDS_DE_AZTEC,			0x00000019	},
+		{ CSSTAT_MAP_ROUNDS_DE_CBBLE,			0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_CHATEAU, 		0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_DUST2,			0x00000014	},
+		{ CSSTAT_MAP_ROUNDS_DE_DUST,			0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_INFERNO, 		0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_NUKE,			0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_PIRANESI,		0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_PORT,			0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_PRODIGY, 		0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_TIDES,			0x00000000	},
+		{ CSSTAT_MAP_ROUNDS_DE_TRAIN,			0x00000000	},
+		{ CSSTAT_LASTMATCH_T_ROUNDS_WON,		0x00000000	},
+		{ CSSTAT_LASTMATCH_CT_ROUNDS_WON,		0x00000000	},
+		{ CSSTAT_LASTMATCH_ROUNDS_WON,			0x40000000	},
+		{ CSSTAT_LASTMATCH_KILLS,				0x00000000	},
+		{ CSSTAT_LASTMATCH_DEATHS,				0x00000000	},
+		{ CSSTAT_LASTMATCH_MVPS,				0x00000000	},
+		{ CSSTAT_LASTMATCH_DAMAGE,				0x00000000	},
+		{ CSSTAT_LASTMATCH_MONEYSPENT,			0x00000000	},
+		{ CSSTAT_LASTMATCH_DOMINATIONS,			0x00000000	},
+		{ CSSTAT_LASTMATCH_REVENGES,			0x00000000	},
+		{ CSSTAT_LASTMATCH_MAX_PLAYERS,			0x0000001B	},
+		{ CSSTAT_LASTMATCH_FAVWEAPON_ID,		0x00000000	},
+		{ CSSTAT_LASTMATCH_FAVWEAPON_SHOTS,		0x00000000	},
+		{ CSSTAT_LASTMATCH_FAVWEAPON_HITS,		0x00000000	},
+		{ CSSTAT_LASTMATCH_FAVWEAPON_KILLS,		0x00000000	},
+	};
+
+	StatsCollection_t& lifetimeStats = const_cast<StatsCollection_t&>(g_CSClientGameStats.GetLifetimeStats());
+	for ( int i = 0; i < ARRAYSIZE(badData); ++i )
+	{
+		CSStatType_t statId = badData[i].statId;
+		lifetimeStats[statId] = badData[i].value;
+	}
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_stats_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+}
+#endif
+
+int CCSClientGameStats::GetStatCount()
+{
+	return CSSTAT_MAX;
+}
+
+PlayerStatData_t CCSClientGameStats::GetStatByIndex( int index )
+{
+	PlayerStatData_t statData;
+
+	statData.iStatId = CSStatProperty_Table[index].statId;
+	statData.iStatValue = m_lifetimeStats[statData.iStatId];
+
+	// we can make this more efficient by caching the localized names
+	statData.pStatDisplayName = g_pVGuiLocalize->Find( CSStatProperty_Table[index].szLocalizationToken );
+
+	return statData;
+}
+
+PlayerStatData_t CCSClientGameStats::GetStatById( int id )
+{
+	Assert(id >= 0 && id < CSSTAT_MAX);
+	if ( id >= 0 && id < CSSTAT_MAX)
+	{
+		return GetStatByIndex(id);
+	}
+	else
+	{
+		PlayerStatData_t dummy;
+		dummy.pStatDisplayName = NULL;
+		dummy.iStatId = CSSTAT_UNDEFINED;
+		dummy.iStatValue = 0;
+		return dummy;
+	}
+}
+
+void CCSClientGameStats::UpdateStats( const StatsCollection_t &stats )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( !pPlayer )
+		return;
+
+	// don't count stats if cheats on, commentary mode, etc
+	if ( !g_AchievementMgrCS.CheckAchievementsEnabled() )
+		return;
+
+	// Update the accumulated stats
+	m_lifetimeStats.Aggregate(stats);
+	m_matchStats.Aggregate(stats);
+	m_roundStats.Aggregate(stats);
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_stats_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+}
+
+void CCSClientGameStats::ResetAllStats( void )
+{
+	m_lifetimeStats.Reset();
+	m_matchStats.Reset();
+	m_roundStats.Reset();
+
+	// reset the stats on Steam
+	if (steamapicontext && steamapicontext->SteamUserStats())
+	{
+		steamapicontext->SteamUserStats()->ResetAllStats(false);
+	}
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_stats_updated" );
+	if ( event )
+	{
+		gameeventmanager->FireEventClientSide( event );
+	}
+}
+
+void CCSClientGameStats::MsgFunc_MatchStatsUpdate( bf_read &msg )
+{
+	int firstStat = msg.ReadShort();
+
+	for (int iStat = firstStat; iStat < CSSTAT_MAX && msg.GetNumBytesLeft() > 0; iStat++ )
+	{
+		m_directTStatAverages.m_fStat[iStat] = msg.ReadFloat();
+		m_directCTStatAverages.m_fStat[iStat] = msg.ReadFloat();
+		m_directPlayerStatAverages.m_fStat[iStat] = msg.ReadFloat();
+	}
+
+	// sanity check: the message should contain exactly the # of bytes we expect based on the bit field
+	Assert( !msg.IsOverflowed() );
+	Assert( 0 == msg.GetNumBytesLeft() );
+}
+
+void CCSClientGameStats::MsgFunc_PlayerStatsUpdate( bf_read &msg )
+{
+	// Note: if any check fails while decoding this message, bail out and disregard this data to avoid 
+	// potentially polluting player stats 
+
+	StatsCollection_t deltaStats;
+
+	CRC32_t crc;
+	CRC32_Init( &crc );
+
+	const uint32 key = 0x82DA9F4C;	// this key should match the key in cs_gamestats.cpp
+	CRC32_ProcessBuffer( &crc, &key, sizeof(key));
+
+	const byte version = 0x01;
+	CRC32_ProcessBuffer( &crc, &version, sizeof(version));
+
+	if (msg.ReadByte() != version)
+	{
+		Warning("PlayerStatsUpdate message: ignoring unsupported version\n");
+		return;
+	}
+
+	byte iStatsToRead = msg.ReadByte();
+	CRC32_ProcessBuffer( &crc, &iStatsToRead, sizeof(iStatsToRead));
+
+	for ( int i = 0; i < iStatsToRead; ++i)
+	{
+		byte iStat = msg.ReadByte();
+		CRC32_ProcessBuffer( &crc, &iStat, sizeof(iStat));
+
+		if (iStat >= CSSTAT_MAX)
+		{
+			Warning("PlayerStatsUpdate: invalid statId encountered; ignoring stats update\n");
+			return;
+		}
+		short delta = msg.ReadShort();
+		deltaStats[iStat] = delta;
+		CRC32_ProcessBuffer( &crc, &delta, sizeof(delta));
+	}
+
+	CRC32_Final( &crc );
+	CRC32_t readCRC = msg.ReadLong();
+
+	if (readCRC != crc || msg.IsOverflowed() || ( 0 != msg.GetNumBytesLeft() ) )
+	{
+		Warning("PlayerStatsUpdate message from server is corrupt; ignoring\n");
+		return;
+	}
+
+	// do one additional pass for out of band values
+	for ( int iStat = CSSTAT_FIRST; iStat < CSSTAT_MAX; ++iStat )
+	{
+		if (deltaStats[iStat] < 0 || deltaStats[iStat] >= 0x4000)
+		{
+			Warning("PlayerStatsUpdate message from server has out of band values; ignoring\n");
+			return;
+		}
+	}
+
+	// everything looks okay at this point; add these stats for the player's round, match, and lifetime stats
+	UpdateStats(deltaStats);
+}
+
+void CCSClientGameStats::UploadRoundData()
+{
+	// If there's nothing to send, don't bother
+	if ( !m_RoundStatData.Count() )
+		return;
+
+	// Temporary ConVar to disable stats
+	if ( sv_noroundstats.GetBool() )
+	{
+		m_RoundStatData.PurgeAndDeleteElements();
+		return;
+	}
+
+	// Send off all OGS stats at level shutdown
+	KeyValues *pKV = new KeyValues( "basedata" );
+	if ( !pKV )
+		return;
+
+	pKV->SetString( "MapID", MapName() );
+
+	// Add all the vector based stats
+	for ( int k=0 ; k < m_RoundStatData.Count() ; ++k )
+	{
+		m_RoundStatData[ k ] ->nRoundEndReason = m_RoundEndReason;
+		SubmitStat( m_RoundStatData[ k ] );
+	}
+
+	// Perform the actual submission
+	SubmitGameStats( pKV );
+
+	// Clear out the per map stats
+	m_RoundStatData.Purge();
+	pKV->deleteThis();
+
+	// Reset the last round's ending status.
+	m_RoundEndReason = Invalid_Round_End_Reason;
+}
+
+void CCSClientGameStats::ResetMatchStats()
+{
+	m_roundStats.Reset();
+	m_matchStats.Reset();
+	m_matchMaxPlayerCount = 0;
+}
+
+void CCSClientGameStats::UpdateLastMatchStats()
+{
+	// only update that last match if we actually have valid data
+	if ( m_matchStats[CSSTAT_ROUNDS_PLAYED] == 0 )
+		return;
+
+	// check to see if the player materially participate; they could have been spectating or joined just in time for the ending.
+	int s = 0;
+	s += m_matchStats[CSSTAT_ROUNDS_WON];
+	s += m_matchStats[CSSTAT_KILLS];
+	s += m_matchStats[CSSTAT_DEATHS];
+	s += m_matchStats[CSSTAT_MVPS];
+	s += m_matchStats[CSSTAT_DAMAGE];
+	s += m_matchStats[CSSTAT_MONEY_SPENT];
+
+	if ( s == 0 )
+		return;
+
+	m_lifetimeStats[CSSTAT_LASTMATCH_T_ROUNDS_WON]	= m_matchStats[CSSTAT_T_ROUNDS_WON];
+	m_lifetimeStats[CSSTAT_LASTMATCH_CT_ROUNDS_WON]	= m_matchStats[CSSTAT_CT_ROUNDS_WON];
+	m_lifetimeStats[CSSTAT_LASTMATCH_ROUNDS_WON]	= m_matchStats[CSSTAT_ROUNDS_WON];
+	m_lifetimeStats[CSSTAT_LASTMATCH_KILLS]			= m_matchStats[CSSTAT_KILLS];
+	m_lifetimeStats[CSSTAT_LASTMATCH_DEATHS]		= m_matchStats[CSSTAT_DEATHS];
+	m_lifetimeStats[CSSTAT_LASTMATCH_MVPS]			= m_matchStats[CSSTAT_MVPS];
+	m_lifetimeStats[CSSTAT_LASTMATCH_DAMAGE]		= m_matchStats[CSSTAT_DAMAGE];
+	m_lifetimeStats[CSSTAT_LASTMATCH_MONEYSPENT]	= m_matchStats[CSSTAT_MONEY_SPENT];
+	m_lifetimeStats[CSSTAT_LASTMATCH_DOMINATIONS]	= m_matchStats[CSSTAT_DOMINATIONS];
+	m_lifetimeStats[CSSTAT_LASTMATCH_REVENGES]		= m_matchStats[CSSTAT_REVENGES];
+	m_lifetimeStats[CSSTAT_LASTMATCH_MAX_PLAYERS]	= m_matchMaxPlayerCount;
+
+	CalculateMatchFavoriteWeapons();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculate and store the match favorite weapon for each player as only deltaStats for that weapon are stored on Steam
+//-----------------------------------------------------------------------------
+void CCSClientGameStats::CalculateMatchFavoriteWeapons()
+{
+	int maxKills = 0, maxKillId = -1;
+
+	for( int j = CSSTAT_KILLS_DEAGLE; j <= CSSTAT_KILLS_M249; ++j )
+	{
+		if ( m_matchStats[j] > maxKills )
+		{
+			maxKills = m_matchStats[j];
+			maxKillId = j;
+		}
+	}
+	if ( maxKillId == -1 )
+	{
+		m_lifetimeStats[CSSTAT_LASTMATCH_FAVWEAPON_ID] = WEAPON_NONE;
+		m_lifetimeStats[CSSTAT_LASTMATCH_FAVWEAPON_SHOTS] = 0;
+		m_lifetimeStats[CSSTAT_LASTMATCH_FAVWEAPON_HITS] = 0;
+		m_lifetimeStats[CSSTAT_LASTMATCH_FAVWEAPON_KILLS] = 0;
+	}
+	else
+	{
+		int statTableID = -1;
+		for (int j = 0; WeaponName_StatId_Table[j].killStatId != CSSTAT_UNDEFINED; ++j)
+		{
+			if ( WeaponName_StatId_Table[j].killStatId == maxKillId )
+			{
+				statTableID = j;
+				break;
+			}
+		}
+		Assert( statTableID != -1 );
+
+		m_lifetimeStats[CSSTAT_LASTMATCH_FAVWEAPON_ID] = WeaponName_StatId_Table[statTableID].weaponId;
+		m_lifetimeStats[CSSTAT_LASTMATCH_FAVWEAPON_SHOTS] = m_matchStats[WeaponName_StatId_Table[statTableID].shotStatId];
+		m_lifetimeStats[CSSTAT_LASTMATCH_FAVWEAPON_HITS] = m_matchStats[WeaponName_StatId_Table[statTableID].hitStatId];
+		m_lifetimeStats[CSSTAT_LASTMATCH_FAVWEAPON_KILLS] = m_matchStats[WeaponName_StatId_Table[statTableID].killStatId];
+	}
+}
diff --git a/game/client/cstrike/cs_client_gamestats.h b/game/client/cstrike/cs_client_gamestats.h
new file mode 100644
index 00000000..76a2e1d7
--- /dev/null
+++ b/game/client/cstrike/cs_client_gamestats.h
@@ -0,0 +1,163 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_STEAMSTATS_H
+#define CS_STEAMSTATS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steam/steam_api.h"
+#include "GameEventListener.h"
+#include "../game/shared/cstrike/cs_gamestats_shared.h"
+
+struct SRoundData : public BaseStatData 
+{
+	SRoundData( const StatsCollection_t *pRoundData ) 
+	{
+		nRoundTime		= (*pRoundData)[CSSTAT_PLAYTIME];
+		nWasKilled		= (*pRoundData)[CSSTAT_DEATHS];
+		nIsMVP			= (*pRoundData)[CSSTAT_MVPS];
+		nMoneySpent		= (*pRoundData)[CSSTAT_MONEY_SPENT];
+		nStartingMoney	= -1;// We'll get this data separately 
+		nRoundEndReason	= Invalid_Round_End_Reason;// We'll get this data separately 
+		nRevenges		= (*pRoundData)[CSSTAT_REVENGES];
+		nDamageDealt	= (*pRoundData)[CSSTAT_DAMAGE];
+
+		if ( (*pRoundData)[CSSTAT_T_ROUNDS_WON] )
+		{
+			nWinningTeamID = TEAM_TERRORIST;
+			if ( (*pRoundData)[CSSTAT_ROUNDS_WON] )
+			{
+				nTeamID = TEAM_TERRORIST;
+			}
+			else
+			{
+				nTeamID = TEAM_CT;
+			}
+		}
+		else
+		{
+			nWinningTeamID = TEAM_CT;
+			if ( (*pRoundData)[CSSTAT_ROUNDS_WON] )
+			{
+				nTeamID = TEAM_CT;
+			}
+			else
+			{
+				nTeamID = TEAM_TERRORIST;
+			}
+		}
+	}
+
+	uint32	nRoundTime;	
+	int		nTeamID;
+	int		nWinningTeamID;
+	int		nWasKilled;
+	int		nIsMVP;
+	int		nDamageDealt;
+	int		nMoneySpent;
+	int		nStartingMoney;
+	int		nRevenges;
+	int		nRoundEndReason;
+
+	BEGIN_STAT_TABLE( "CSSRoundData" )
+		REGISTER_STAT_NAMED( nRoundTime, "RoundTime" )
+		REGISTER_STAT_NAMED( nTeamID, "TeamID" )
+		REGISTER_STAT_NAMED( nWinningTeamID, "WinningTeamID" )
+		REGISTER_STAT_NAMED( nWasKilled, "WasKilled" )
+		REGISTER_STAT_NAMED( nIsMVP, "IsMvp" )
+		REGISTER_STAT_NAMED( nDamageDealt, "DamageDealt" )
+		REGISTER_STAT_NAMED( nMoneySpent, "MoneySpent" )
+		REGISTER_STAT_NAMED( nStartingMoney, "StartingMoney" )
+		REGISTER_STAT_NAMED( nRevenges, "Revenges" )
+		REGISTER_STAT_NAMED( nRoundEndReason, "RoundEndReason" )
+	END_STAT_TABLE()
+};
+typedef CUtlVector< SRoundData* > VectorRoundData;
+
+struct PlayerStatData_t
+{
+	wchar_t*    pStatDisplayName;			// Localized display name of the stat
+	int         iStatId;					// CSStatType_t enum value of stat
+	int32       iStatValue;                 // Value of the stat
+};
+
+class CCSClientGameStats : public CAutoGameSystem, public CGameEventListener, public IGameStatTracker
+{
+public:
+	CCSClientGameStats();
+	virtual void PostInit();
+	virtual void LevelShutdownPreEntity();
+	virtual void Shutdown();
+	virtual void LevelShutdownPreClearSteamAPIContext();
+
+	int GetStatCount();
+	PlayerStatData_t GetStatByIndex(int index);
+	PlayerStatData_t GetStatById(int id);
+
+	void		ResetAllStats( void );
+	void		ResetMatchStats();
+	void		UploadRoundData( void );
+
+	const StatsCollection_t&	GetLifetimeStats() { return m_lifetimeStats; }
+	const StatsCollection_t&	GetMatchStats() { return m_matchStats; }
+
+	RoundStatsDirectAverage_t* GetDirectCTStatsAverages() { return &m_directCTStatAverages; }
+	RoundStatsDirectAverage_t* GetDirectTStatsAverages() { return &m_directTStatAverages; }
+	RoundStatsDirectAverage_t* GetDirectPlayerStatsAverages() { return &m_directPlayerStatAverages; }
+
+	void		MsgFunc_MatchStatsUpdate( bf_read &msg );
+	void		MsgFunc_PlayerStatsUpdate( bf_read &msg );
+
+	// Steamworks Gamestats 
+	virtual void 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();
+		}
+	}
+
+	virtual StatContainerList_t* GetStatContainerList( void )
+	{
+		return s_StatLists;
+	}
+
+protected:
+	void FireGameEvent( IGameEvent *event );
+
+	void UpdateSteamStats();
+	void RetrieveSteamStats();
+	void UpdateStats( const StatsCollection_t &stats );
+	void CalculateMatchFavoriteWeapons();
+	void UpdateLastMatchStats();
+
+private:
+	StatsCollection_t				m_lifetimeStats;
+	StatsCollection_t				m_matchStats;
+	StatsCollection_t				m_roundStats;
+
+	RoundStatsDirectAverage_t	m_directCTStatAverages;
+	RoundStatsDirectAverage_t	m_directTStatAverages;
+	RoundStatsDirectAverage_t	m_directPlayerStatAverages;
+	int							m_matchMaxPlayerCount;
+	bool						m_bSteamStatsDownload;
+	VectorRoundData				m_RoundStatData;
+
+	int							m_RoundEndReason;
+
+	// A static list of all the stat containers, one for each data structure being tracked
+	static StatContainerList_t * s_StatLists;
+};
+
+extern CCSClientGameStats g_CSClientGameStats;
+
+#endif //CS_STEAMSTATS_H
diff --git a/game/client/cstrike/cs_hud_achievement_announce.cpp b/game/client/cstrike/cs_hud_achievement_announce.cpp
new file mode 100644
index 00000000..7739c78e
--- /dev/null
+++ b/game/client/cstrike/cs_hud_achievement_announce.cpp
@@ -0,0 +1,415 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_hud_achievement_announce.h"
+#include <vgui/IVGui.h>
+#include "vgui_controls/AnimationController.h"
+#include "iclientmode.h"
+#include "c_cs_player.h"
+#include "c_cs_playerresource.h"
+#include <vgui_controls/Label.h>
+#include <vgui/ILocalize.h>
+#include <vgui/ISurface.h>
+#include "fmtstr.h"
+#include "cs_gamerules.h"
+#include "view.h"
+#include "ivieweffects.h"
+#include "viewrender.h"
+#include "usermessages.h"
+#include "hud_macros.h"
+#include "c_baseanimating.h"
+#include "achievementmgr.h"
+#include "filesystem.h"
+
+
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+DECLARE_HUDELEMENT_DEPTH( CCSAchievementAnnouncePanel, 1 );
+
+#define CALLOUT_WIDE		(XRES(100))
+#define CALLOUT_TALL		(XRES(50))
+
+
+namespace Interpolators
+
+{
+    inline float Linear( float t ) { return t; }
+
+    inline float SmoothStep( float t )
+    {
+        t = 3 * t * t - 2.0f * t * t * t;
+        return t;
+    }
+
+    inline float SmoothStep2( float t )
+    {
+        return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
+    }
+
+    inline float SmoothStepStart( float t )
+    {
+        t = 0.5f * t;
+        t = 3 * t * t - 2.0f * t * t * t;
+        t = t* 2.0f;
+        return t;
+    }
+
+    inline float SmoothStepEnd( float t )
+    {
+        t = 0.5f * t + 0.5f;
+        t = 3 * t * t - 2.0f * t * t * t;
+        t = (t - 0.5f) * 2.0f;
+        return t;
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSAchievementAnnouncePanel::CCSAchievementAnnouncePanel( const char *pElementName )
+: EditablePanel( NULL, "AchievementAnnouncePanel" ), CHudElement( pElementName )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+	m_bShouldBeVisible = false;
+	SetScheme( "ClientScheme" );
+    m_currentDisplayedAchievement = CSInvalidAchievement;
+    m_pGlowPanel = NULL;
+
+	RegisterForRenderGroup( "hide_for_scoreboard" );
+
+    //Create the grey popup that has the name, text and icon.
+    m_pAchievementInfoPanel = new CCSAchivementInfoPanel(this, "InfoPanel");
+}
+
+CCSAchievementAnnouncePanel::~CCSAchievementAnnouncePanel()
+{
+    if (m_pAchievementInfoPanel)
+    {
+        delete m_pAchievementInfoPanel;
+    }
+}
+ 
+
+void CCSAchievementAnnouncePanel::Reset()
+{
+	//We don't want to hide the UI here since we want the achievement popup to show through death
+}
+
+void CCSAchievementAnnouncePanel::Init()
+{
+	ListenForGameEvent( "achievement_earned_local" );	
+
+	Hide();
+
+	CHudElement::Init();
+}
+
+void CCSAchievementAnnouncePanel::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+    
+    LoadControlSettings( "Resource/UI/Achievement_Glow.res" );
+
+    //This is the glowy flash that comes up under the popup
+    m_pGlowPanel = dynamic_cast<EditablePanel *>( FindChildByName("GlowPanel") );  
+
+    Hide();   
+}
+
+ConVar cl_show_achievement_popups( "cl_show_achievement_popups", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+
+
+void CCSAchievementAnnouncePanel::FireGameEvent( IGameEvent * event )
+{
+	const char *pEventName = event->GetName();
+
+	if ( cl_show_achievement_popups.GetBool() )
+	{
+		if ( Q_strcmp( "achievement_earned_local", pEventName ) == 0 )
+		{
+			//Add achievement to queue and show the UI (since the UI doesn't "Think()" until it is shown        
+			Show();
+			m_achievementQueue.Insert((eCSAchievementType)event->GetInt("achievement"));        
+		}
+	}
+}
+
+void CCSAchievementAnnouncePanel::Show()
+{	
+	m_bShouldBeVisible = true;
+}
+
+void CCSAchievementAnnouncePanel::Hide()
+{
+	m_bShouldBeVisible = false;
+}
+
+bool CCSAchievementAnnouncePanel::ShouldDraw( void )
+{
+	return (m_bShouldBeVisible && CHudElement::ShouldDraw());
+}
+
+void CCSAchievementAnnouncePanel::Paint( void )
+{
+}
+
+void CCSAchievementAnnouncePanel::OnThink( void )
+{
+	BaseClass::OnThink();	
+
+    if (!m_pAchievementInfoPanel)
+    {
+        return;
+    }
+
+    //if we have an achievement, update it
+    if (m_currentDisplayedAchievement != CSInvalidAchievement)
+    {        
+		//If the match restarts, we need to move the start time for the achievement back.
+		if (m_displayStartTime > gpGlobals->curtime)
+		{	 
+			m_displayStartTime = gpGlobals->curtime;
+		}
+        float timeSinceDisplayStart = gpGlobals->curtime - m_displayStartTime;
+        float glowAlpha;
+        float achievementPanelAlpha; 
+
+        //Update the flash        
+        if (m_pGlowPanel)        
+        {
+            GetGlowAlpha(timeSinceDisplayStart, glowAlpha);
+            m_pGlowPanel->SetAlpha(glowAlpha);            
+        }
+
+        if (GetAchievementPanelAlpha(timeSinceDisplayStart, achievementPanelAlpha))
+        {
+            m_pAchievementInfoPanel->SetAlpha(achievementPanelAlpha);                        
+        }
+        else
+        {
+            //achievement is faded, so we are done
+            m_pAchievementInfoPanel->SetAlpha(0);                        
+            m_currentDisplayedAchievement = CSInvalidAchievement;
+
+            if (m_achievementQueue.Count() == 0)
+            {
+                Hide();
+            }
+        }
+    }    
+    else
+    {
+        //Check if we need to start the next announcement in the queue. We won't update it this frame, but no time has elapsed anyway.
+        if (m_achievementQueue.Count() > 0)
+        {
+            m_currentDisplayedAchievement = m_achievementQueue.RemoveAtHead();
+            m_displayStartTime = gpGlobals->curtime;      
+
+            //=============================================================================
+            // HPE_BEGIN:
+            // [dwenger] Play the achievement earned sound effect
+            //=============================================================================
+
+            vgui::surface()->PlaySound( "UI/achievement_earned.wav" );
+
+            //=============================================================================
+            // HPE_END
+            //=============================================================================
+
+            //Here we get the achievement to be displayed and set that in the popup windows
+            CAchievementMgr *pAchievementMgr = dynamic_cast<CAchievementMgr *>( engine->GetAchievementMgr() );
+            if ( !pAchievementMgr )
+                return;
+            
+            IAchievement *pAchievement = pAchievementMgr->GetAchievementByID( m_currentDisplayedAchievement );
+            if ( pAchievement )
+            {
+                m_pAchievementInfoPanel->SetAchievement(pAchievement);
+            }
+        }
+    }
+}
+
+bool CCSAchievementAnnouncePanel::GetAlphaFromTime(float elapsedTime, float delay, float fadeInTime, float holdTime, float fadeOutTime, float&alpha)
+{
+    //We just pass through each phase, subtracting off the full time if we are already done with that phase
+    //We return whether the control should still be active
+
+    //I. Delay before fading in
+    if (elapsedTime > delay)
+    {
+        elapsedTime -= delay;
+    }
+    else
+    {
+        alpha = 0;
+        return true;
+    }
+
+
+    //II. Fade in time
+    if (elapsedTime > fadeInTime)
+    {
+        elapsedTime -= fadeInTime;
+    }
+    else
+    {
+        alpha = 255.0f * elapsedTime / fadeInTime;
+        return true;
+    }
+
+
+    //III. Hold at full alpha time
+    if (elapsedTime > holdTime)
+    {
+        elapsedTime -= holdTime;
+    }
+    else
+    {
+        alpha = 255.0f;
+        return true;
+    }
+
+    //IV. Fade out time
+    if (elapsedTime > fadeOutTime)
+    {
+        alpha = 0;
+        return false;
+    }
+    else
+    {
+        alpha = 1.0f - (elapsedTime / fadeOutTime);
+        alpha = Interpolators::SmoothStepStart(alpha);
+        alpha *= 255.0f;  
+
+		if (m_achievementQueue.Count() > 0 && alpha < 128.0f)
+		{
+			return false;
+		}
+        return true;
+    }
+}
+
+ConVar glow_delay( "glow_delay", "0", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY);
+ConVar glow_fadeInTime( "glow_fadeInTime", "0.1", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY);
+ConVar glow_holdTime( "glow_holdTime", "0.1", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY);
+ConVar glow_fadeOutTime( "glow_fadeOutTime", "2.5", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY);
+
+bool CCSAchievementAnnouncePanel::GetGlowAlpha (float time, float& alpha)
+{    
+    
+
+    /*
+    float delay = 0.0f;
+    float fadeInTime = 0.3f;
+    float holdTime = 0.1f;
+    float fadeOutTime = 0.4f;
+    */
+
+    //return GetAlphaFromTime(time, delay, fadeInTime, holdTime, fadeOutTime, alpha);
+
+    return GetAlphaFromTime(time, glow_delay.GetFloat(), glow_fadeInTime.GetFloat(), glow_holdTime.GetFloat(), glow_fadeOutTime.GetFloat(), alpha);
+}
+
+
+ConVar popup_delay( "popup_delay", "0", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY);
+ConVar popup_fadeInTime( "popup_fadeInTime", "0.3", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY);
+ConVar popup_holdTime( "popup_holdTime", "3.5", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY);
+ConVar popup_fadeOutTime( "popup_fadeOutTime", "3.0", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY);
+
+bool CCSAchievementAnnouncePanel::GetAchievementPanelAlpha (float time, float& alpha)
+{
+    /*
+    float delay = 0.2f;
+    float fadeInTime = 0.3f;
+    float holdTime = 3.0f;
+    float fadeOutTime = 2.0f;
+    */
+
+    //return GetAlphaFromTime(time, delay, fadeInTime, holdTime, fadeOutTime, alpha);
+
+    return GetAlphaFromTime(time, popup_delay.GetFloat(), popup_fadeInTime.GetFloat(), popup_holdTime.GetFloat(), popup_fadeOutTime.GetFloat(), alpha);
+    
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: creates child panels, passes down name to pick up any settings from res files.
+//-----------------------------------------------------------------------------
+CCSAchivementInfoPanel::CCSAchivementInfoPanel( vgui::Panel *parent, const char* name ) : BaseClass( parent, name )
+{
+    //Create the main components of the display and attach them to the panel
+    m_pAchievementIcon = SETUP_PANEL(new vgui::ScalableImagePanel( this, "Icon" ));
+    m_pAchievementNameLabel = new vgui::Label( this, "Name", "name" );
+    m_pAchievementDescLabel = new vgui::Label( this, "Description", "desc" );     
+}
+
+CCSAchivementInfoPanel::~CCSAchivementInfoPanel()
+{   
+    if (m_pAchievementIcon)
+    {
+        delete m_pAchievementIcon;
+    }
+
+    if (m_pAchievementNameLabel)
+    {
+        delete m_pAchievementNameLabel;
+    }
+
+    if (m_pAchievementDescLabel)
+    {
+        delete m_pAchievementDescLabel;
+    }    
+}
+
+void CCSAchivementInfoPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
+{    
+    LoadControlSettings( "Resource/UI/Achievement_Popup.res" );
+
+    BaseClass::ApplySchemeSettings( pScheme );
+
+    //Override the automatic scheme setting that happen above
+    SetBgColor( pScheme->GetColor( "AchievementsLightGrey", Color(255, 0, 0, 255) ) );
+    m_pAchievementNameLabel->SetFgColor(pScheme->GetColor("SteamLightGreen", Color(255, 255, 255, 255)));
+    m_pAchievementDescLabel->SetFgColor(pScheme->GetColor("White", Color(255, 255, 255, 255)));
+}
+
+void CCSAchivementInfoPanel::SetAchievement(IAchievement* pAchievement)
+{
+    //=============================================================================
+    // HPE_BEGIN:
+    // [dwenger] Get achievement name and description text from the localized file
+    //=============================================================================
+
+    // Set name and description
+    m_pAchievementNameLabel->SetText( ACHIEVEMENT_LOCALIZED_NAME( pAchievement ) );
+    m_pAchievementDescLabel->SetText( ACHIEVEMENT_LOCALIZED_DESC( pAchievement ) );
+
+    //Find, load and show the achievement icon
+    char imagePath[_MAX_PATH];
+    Q_strncpy( imagePath, "achievements\\", sizeof(imagePath) );
+    Q_strncat( imagePath, pAchievement->GetName(), sizeof(imagePath), COPY_ALL_CHARACTERS );    
+    Q_strncat( imagePath, ".vtf", sizeof(imagePath), COPY_ALL_CHARACTERS );
+
+    char checkFile[_MAX_PATH];
+    Q_snprintf( checkFile, sizeof(checkFile), "materials\\vgui\\%s", imagePath );
+    if ( !g_pFullFileSystem->FileExists( checkFile ) )
+    {
+        Q_snprintf( imagePath, sizeof(imagePath), "hud\\icon_locked.vtf" );
+    }
+
+    m_pAchievementIcon->SetImage( imagePath );
+    m_pAchievementIcon->SetVisible( true );
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+}
diff --git a/game/client/cstrike/cs_hud_achievement_announce.h b/game/client/cstrike/cs_hud_achievement_announce.h
new file mode 100644
index 00000000..a03522af
--- /dev/null
+++ b/game/client/cstrike/cs_hud_achievement_announce.h
@@ -0,0 +1,92 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef CS_HUD_ACHIVEMENT_ANNOUNCE_H
+#define CS_HUD_ACHIVEMENT_ANNOUNCE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <KeyValues.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui/ISystem.h>
+#include <vgui_controls/AnimationController.h>
+#include <vgui_controls/EditablePanel.h>
+#include <vgui_controls/ScalableImagePanel.h>
+#include "vgui/ILocalize.h"
+#include "vgui_avatarimage.h"
+#include "hud.h"
+#include "hudelement.h"
+#include "cs_hud_playerhealth.h"
+
+#include "cs_shareddefs.h"
+
+using namespace vgui;
+
+class IAchievement;
+
+
+class CCSAchivementInfoPanel : public vgui::EditablePanel
+{
+    DECLARE_CLASS_SIMPLE( CCSAchivementInfoPanel, vgui::EditablePanel );
+
+public:
+    CCSAchivementInfoPanel( vgui::Panel *parent, const char* name);
+    ~CCSAchivementInfoPanel();
+    virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+    void SetAchievement(IAchievement* pAchievement);    
+
+private:
+    vgui::Label                     *m_pAchievementNameLabel;
+    vgui::Label                     *m_pAchievementDescLabel;
+    vgui::ScalableImagePanel        *m_pAchievementIcon;    
+};
+
+
+
+class CCSAchievementAnnouncePanel: public EditablePanel, public CHudElement
+{
+private:
+	DECLARE_CLASS_SIMPLE( CCSAchievementAnnouncePanel, EditablePanel );
+
+public:
+	CCSAchievementAnnouncePanel( const char *pElementName );
+    ~CCSAchievementAnnouncePanel();
+
+	virtual void Reset();
+	virtual void Init();
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void FireGameEvent( IGameEvent * event );
+
+	void Show();
+	void Hide();
+
+	virtual bool ShouldDraw( void );
+	virtual void Paint( void );
+	void OnThink( void );
+	bool GetAlphaFromTime(float elapsedTime, float delay, float fadeInTime, float holdTime, float fadeOutTime, float&alpha);
+
+	int	HudElementKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
+
+protected:
+    bool GetGlowAlpha (float time, float& alpha);
+    bool GetAchievementPanelAlpha (float time, float& alpha);
+
+private:
+	
+    CUtlQueue<eCSAchievementType>   m_achievementQueue;
+    eCSAchievementType              m_currentDisplayedAchievement;  
+    float                           m_displayStartTime;
+	
+	
+    vgui::EditablePanel		*m_pGlowPanel;
+    CCSAchivementInfoPanel  *m_pAchievementInfoPanel;
+
+	bool					m_bShouldBeVisible;
+};
+
+#endif //CS_HUD_ACHIVEMENT_ANNOUNCE_H
\ No newline at end of file
diff --git a/game/client/cstrike/cs_hud_achievement_tracker.cpp b/game/client/cstrike/cs_hud_achievement_tracker.cpp
new file mode 100644
index 00000000..ce8958a4
--- /dev/null
+++ b/game/client/cstrike/cs_hud_achievement_tracker.cpp
@@ -0,0 +1,68 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#include "cbase.h"
+#include "hud_baseachievement_tracker.h"
+#include "c_cs_player.h"
+#include "iachievementmgr.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// The number of counter-strike HUD achievements to display
+const int cMaxCSHUDAchievments = 4;
+
+
+using namespace vgui;
+
+class CHudAchievementTracker : public CHudBaseAchievementTracker
+{
+    DECLARE_CLASS_SIMPLE( CHudAchievementTracker, CHudBaseAchievementTracker );
+
+public:
+    CHudAchievementTracker( const char *pElementName );
+    virtual void OnThink();
+    virtual void PerformLayout();
+    virtual int  GetMaxAchievementsShown();
+    virtual bool ShouldShowAchievement( IAchievement *pAchievement );
+
+private:
+    CPanelAnimationVarAliasType( int, m_iNormalY, "NormalY", "5", "proportional_int" );
+};
+
+DECLARE_HUDELEMENT( CHudAchievementTracker );
+
+
+CHudAchievementTracker::CHudAchievementTracker( const char *pElementName ) : BaseClass( pElementName )
+{
+	RegisterForRenderGroup( "hide_for_scoreboard" );
+}
+
+void CHudAchievementTracker::OnThink()
+{
+    BaseClass::OnThink();
+}
+
+int CHudAchievementTracker::GetMaxAchievementsShown()
+{
+    return MIN( BaseClass::GetMaxAchievementsShown(), cMaxCSHUDAchievments );
+}
+
+void CHudAchievementTracker::PerformLayout()
+{
+    BaseClass::PerformLayout();
+
+    int x, y;
+    GetPos( x, y );
+    SetPos( x, m_iNormalY );
+}
+
+bool CHudAchievementTracker::ShouldShowAchievement( IAchievement *pAchievement )
+{
+    if ( !BaseClass::ShouldShowAchievement(pAchievement) )
+        return false;
+
+    C_CSPlayer *pPlayer = CCSPlayer::GetLocalCSPlayer();
+    if ( !pPlayer )
+        return false;
+
+    return true;
+}
\ No newline at end of file
diff --git a/game/client/cstrike/cs_hud_ammo.cpp b/game/client/cstrike/cs_hud_ammo.cpp
new file mode 100644
index 00000000..f952948f
--- /dev/null
+++ b/game/client/cstrike/cs_hud_ammo.cpp
@@ -0,0 +1,292 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "hudelement.h"
+#include "hud_macros.h"
+#include "hud_numericdisplay.h"
+#include "iclientmode.h"
+#include "ihudlcd.h"
+#include "vgui/ILocalize.h"
+
+#include <vgui/ISurface.h>
+#include <vgui_controls/AnimationController.h>
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays current ammunition level
+//-----------------------------------------------------------------------------
+class CHudAmmo : public CHudNumericDisplay, public CHudElement
+{
+	DECLARE_CLASS_SIMPLE( CHudAmmo, CHudNumericDisplay );
+
+public:
+	CHudAmmo( const char *pElementName );
+	void Init( void );
+	void VidInit( void );
+
+	void SetAmmo(int ammo, bool playAnimation);
+	void SetAmmo2(int ammo2, bool playAnimation);
+		
+protected:
+	virtual void OnThink();
+	virtual void Paint( void );
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	
+private:
+	CHandle< C_BaseCombatWeapon > m_hCurrentActiveWeapon;
+	int		m_iAmmo;
+	int		m_iAmmo2;
+
+	bool	m_bUsesClips;
+
+	int		m_iAdditiveWhiteID;
+
+	CPanelAnimationVarAliasType( float, digit_xpos, "digit_xpos", "50", "proportional_float" );
+	CPanelAnimationVarAliasType( float, digit_ypos, "digit_ypos", "2", "proportional_float" );
+	CPanelAnimationVarAliasType( float, digit2_xpos, "digit2_xpos", "0", "proportional_float" );
+	CPanelAnimationVarAliasType( float, digit2_ypos, "digit2_ypos", "0", "proportional_float" );
+	CPanelAnimationVarAliasType( float, bar_xpos, "bar_xpos", "0", "proportional_float" );
+	CPanelAnimationVarAliasType( float, bar_ypos, "bar_ypos", "0", "proportional_float" );
+	CPanelAnimationVarAliasType( float, bar_width, "bar_width", "2", "proportional_float" );
+	CPanelAnimationVarAliasType( float, bar_height, "bar_height", "2", "proportional_float" );
+	CPanelAnimationVarAliasType( float, icon_xpos, "icon_xpos", "0", "proportional_float" );
+	CPanelAnimationVarAliasType( float, icon_ypos, "icon_ypos", "0", "proportional_float" );
+
+	CPanelAnimationVar( Color, m_TextColor, "TextColor", "FgColor" );
+	CPanelAnimationVar( vgui::HFont, m_hNumberFont, "NumberFont", "HudNumbers" );
+};
+
+DECLARE_HUDELEMENT( CHudAmmo );
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CHudAmmo::CHudAmmo( const char *pElementName ) : BaseClass(NULL, "HudAmmo"), CHudElement( pElementName )
+{
+	m_iAdditiveWhiteID = vgui::surface()->CreateNewTextureID();
+	vgui::surface()->DrawSetTextureFile( m_iAdditiveWhiteID, "vgui/white_additive" , true, false);
+
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD | HIDEHUD_WEAPONSELECTION );
+
+	hudlcd->SetGlobalStat( "(ammo_primary)", "0" );
+	hudlcd->SetGlobalStat( "(ammo_secondary)", "0" );
+	hudlcd->SetGlobalStat( "(weapon_print_name)", "" );
+	hudlcd->SetGlobalStat( "(weapon_name)", "" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudAmmo::Init( void )
+{
+	m_iAmmo		= -1;
+	m_iAmmo2	= -1;
+}
+
+void CHudAmmo::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudAmmo::VidInit( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: called every frame to get ammo info from the weapon
+//-----------------------------------------------------------------------------
+void CHudAmmo::OnThink()
+{
+	C_BaseCombatWeapon *wpn = GetActiveWeapon();
+
+	hudlcd->SetGlobalStat( "(weapon_print_name)", wpn ? wpn->GetPrintName() : " " );
+	hudlcd->SetGlobalStat( "(weapon_name)", wpn ? wpn->GetName() : " " );
+
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if (!wpn || !player || !wpn->UsesPrimaryAmmo())
+	{
+		hudlcd->SetGlobalStat( "(ammo_primary)", "n/a" );
+		hudlcd->SetGlobalStat( "(ammo_secondary)", "n/a" );
+
+		SetPaintEnabled(false);
+		SetPaintBackgroundEnabled(false);
+		return;
+	}
+	else
+	{
+		SetPaintEnabled(true);
+		SetPaintBackgroundEnabled(true);
+	}
+
+	// get the ammo in our clip
+	int ammo1 = wpn->Clip1();
+	int ammo2;
+	if (ammo1 < 0)
+	{
+		// we don't use clip ammo, just use the total ammo count
+		ammo1 = player->GetAmmoCount(wpn->GetPrimaryAmmoType());
+		ammo2 = 0;
+	}
+	else
+	{
+		// we use clip ammo, so the second ammo is the total ammo
+		ammo2 = player->GetAmmoCount(wpn->GetPrimaryAmmoType());
+	}
+
+	hudlcd->SetGlobalStat( "(ammo_primary)", VarArgs( "%d", ammo1 ) );
+	hudlcd->SetGlobalStat( "(ammo_secondary)", VarArgs( "%d", ammo2 ) );
+
+	if (wpn == m_hCurrentActiveWeapon)
+	{
+		// same weapon, just update counts
+		SetAmmo(ammo1, true);
+		SetAmmo2(ammo2, true);
+	}
+	else
+	{
+		// diferent weapon, change without triggering
+		SetAmmo(ammo1, false);
+		SetAmmo2(ammo2, false);
+
+		// update whether or not we show the total ammo display
+		if (wpn->UsesClipsForAmmo1())
+		{
+			m_bUsesClips = true;
+
+		}
+		else
+		{
+			m_bUsesClips = false;
+		}
+
+		m_hCurrentActiveWeapon = wpn;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates ammo display
+//-----------------------------------------------------------------------------
+void CHudAmmo::SetAmmo(int ammo, bool playAnimation)
+{
+	if (ammo != m_iAmmo)
+	{
+		if (ammo == 0)
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("PrimaryAmmoEmpty");
+		}
+		else if (ammo < m_iAmmo)
+		{
+			// ammo has decreased
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("PrimaryAmmoDecrement");
+		}
+		else
+		{
+			// ammunition has increased
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("PrimaryAmmoIncrement");
+		}
+
+		m_iAmmo = ammo;
+	}
+
+	SetDisplayValue(ammo);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates 2nd ammo display
+//-----------------------------------------------------------------------------
+void CHudAmmo::SetAmmo2(int ammo2, bool playAnimation)
+{
+	if (ammo2 != m_iAmmo2)
+	{
+		if (ammo2 == 0)
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("SecondaryAmmoEmpty");
+		}
+		else if (ammo2 < m_iAmmo2)
+		{
+			// ammo has decreased
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("SecondaryAmmoDecrement");
+		}
+		else
+		{
+			// ammunition has increased
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("SecondaryAmmoIncrement");
+		}
+
+		m_iAmmo2 = ammo2;
+	}
+}
+
+void CHudAmmo::Paint( void )
+{
+	float alpha = 1.0f;
+	Color fgColor = GetFgColor();
+	fgColor[3] *= alpha;
+	SetFgColor( fgColor );
+
+	int x, y;
+
+	if( m_bUsesClips )
+	{
+		x = digit_xpos;
+		y = digit_ypos;
+	}
+	else
+	{
+		x = digit2_xpos;
+		y = digit2_ypos;
+	}
+
+	// Assume constant width font
+	int charWidth = vgui::surface()->GetCharacterWidth( m_hNumberFont, '0' );
+
+	int digits = clamp( log10((double)m_iAmmo)+1, 1, 3 );
+	
+	x += ( 3 - digits ) * charWidth;
+
+	// draw primary ammo
+	vgui::surface()->DrawSetTextColor(GetFgColor());
+	PaintNumbers( m_hNumberFont, x, y, m_iAmmo );
+
+	//draw reserve ammo
+	if( m_bUsesClips )
+	{
+		//draw the divider
+		Color c = GetFgColor();
+		vgui::surface()->DrawSetColor(c);
+		vgui::surface()->DrawSetTexture( m_iAdditiveWhiteID );
+		vgui::surface()->DrawTexturedRect( bar_xpos, bar_ypos, bar_xpos + bar_width, bar_ypos + bar_height );
+
+		digits = clamp( log10((double)m_iAmmo2)+1, 1, 3 );
+		x = digit2_xpos + ( 3 - digits ) * charWidth;
+
+		// draw secondary ammo
+		vgui::surface()->DrawSetTextColor(GetFgColor());
+		PaintNumbers( m_hNumberFont, x, digit2_ypos, m_iAmmo2 );
+	}
+
+	//draw the icon
+	C_BaseCombatWeapon *wpn = GetActiveWeapon();
+	if( wpn )
+	{
+		int ammoType = wpn->GetPrimaryAmmoType();
+
+		CHudTexture *icon = gWR.GetAmmoIconFromWeapon( ammoType );
+
+		if( icon )
+		{
+			float icon_tall = GetTall() - YRES(2);
+			float scale = icon_tall / (float)icon->Height();
+			float icon_wide = ( scale ) * (float)icon->Width();
+
+			icon->DrawSelf( icon_xpos, icon_ypos, icon_wide, icon_tall, GetFgColor() );
+		}
+	}
+}
diff --git a/game/client/cstrike/cs_hud_chat.cpp b/game/client/cstrike/cs_hud_chat.cpp
new file mode 100644
index 00000000..51e95e75
--- /dev/null
+++ b/game/client/cstrike/cs_hud_chat.cpp
@@ -0,0 +1,355 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud_radar.h"
+#include "cs_hud_chat.h"
+#include "c_cs_player.h"
+#include "c_cs_playerresource.h"
+#include "hud_macros.h"
+#include "text_message.h"
+#include "vguicenterprint.h"
+#include "vgui/ILocalize.h"
+#include "engine/IEngineSound.h"
+#include "radio_status.h"
+#include "cstrike/bot/shared_util.h"
+#include "ihudlcd.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+DECLARE_HUDELEMENT( CHudChat );
+
+DECLARE_HUD_MESSAGE( CHudChat, RadioText );
+DECLARE_HUD_MESSAGE( CHudChat, SayText );
+DECLARE_HUD_MESSAGE( CHudChat, SayText2 );
+DECLARE_HUD_MESSAGE( CHudChat, TextMsg );
+DECLARE_HUD_MESSAGE( CHudChat, RawAudio );
+
+
+//=====================
+//CHudChatLine
+//=====================
+
+CHudChatLine::CHudChatLine( vgui::Panel *parent, const char *panelName ) : CBaseHudChatLine( parent, panelName )
+{
+	m_text = NULL;
+}
+
+void CHudChatLine::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+}
+//=====================
+//CHudChatInputLine
+//=====================
+
+void CHudChatInputLine::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+
+	vgui::HFont hFont = pScheme->GetFont( "ChatFont" );
+
+	m_pPrompt->SetFont( hFont );
+	m_pInput->SetFont( hFont );
+
+	m_pInput->SetFgColor( pScheme->GetColor( "Chat.TypingText", pScheme->GetColor( "Panel.FgColor", Color( 255, 255, 255, 255 ) ) ) );
+}
+
+
+
+//=====================
+//CHudChat
+//=====================
+
+CHudChat::CHudChat( const char *pElementName ) : BaseClass( pElementName )
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Add this to the render group that disappears when the scoreboard is up
+	//
+	// [pmf] Removed from render group so that chat still works during intermission
+	// (when the scoreboard is forced to be up). The downside is that chat shows
+	// over the scoreboard during regular play, but this might be less of an issue
+	// if we reduce the need to display it constantly by adding HUD support for
+	// live player counts.
+	//=============================================================================
+//	RegisterForRenderGroup("hide_for_scoreboard");
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+void CHudChat::CreateChatInputLine( void )
+{
+	m_pChatInput = new CHudChatInputLine( this, "ChatInputLine" );
+	m_pChatInput->SetVisible( false );
+}
+
+void CHudChat::CreateChatLines( void )
+{
+#ifndef _XBOX
+	m_ChatLine = new CHudChatLine( this, "ChatLine1" );
+	m_ChatLine->SetVisible( false );		
+
+#endif
+}
+
+void CHudChat::Init( void )
+{
+	BaseClass::Init();
+
+	HOOK_HUD_MESSAGE( CHudChat, RadioText );
+	HOOK_HUD_MESSAGE( CHudChat, SayText );
+	HOOK_HUD_MESSAGE( CHudChat, SayText2 );
+	HOOK_HUD_MESSAGE( CHudChat, TextMsg );
+	HOOK_HUD_MESSAGE( CHudChat, RawAudio );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Overrides base reset to not cancel chat at round restart
+//-----------------------------------------------------------------------------
+void CHudChat::Reset( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reads in a player's Radio text from the server
+//-----------------------------------------------------------------------------
+void CHudChat::MsgFunc_RadioText( bf_read &msg )
+{
+	int msg_dest = msg.ReadByte();
+	NOTE_UNUSED( msg_dest );
+	int client = msg.ReadByte();
+
+	wchar_t szBuf[6][128];
+	wchar_t *msg_text = ReadLocalizedString( msg, szBuf[0], sizeof( szBuf[0] ), false );
+
+	// keep reading strings and using C format strings for subsituting the strings into the localised text string
+	ReadChatTextString ( msg, szBuf[1], sizeof( szBuf[1] ) );		// player name
+	ReadLocalizedString( msg, szBuf[2], sizeof( szBuf[2] ), true );	// location
+	ReadLocalizedString( msg, szBuf[3], sizeof( szBuf[3] ), true );	// radio text
+	ReadLocalizedString( msg, szBuf[4], sizeof( szBuf[4] ), true );	// unused :(
+
+	g_pVGuiLocalize->ConstructString( szBuf[5], sizeof( szBuf[5] ), msg_text, 4, szBuf[1], szBuf[2], szBuf[3], szBuf[4] );
+
+	char ansiString[512];
+	g_pVGuiLocalize->ConvertUnicodeToANSI( ConvertCRtoNL( szBuf[5] ), ansiString, sizeof( ansiString ) );
+	ChatPrintf( client, CHAT_FILTER_TEAMCHANGE, "%s", ansiString );
+
+	CLocalPlayerFilter filter;
+	C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "HudChat.Message" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reads in a player's Chat text from the server
+//-----------------------------------------------------------------------------
+void CHudChat::MsgFunc_SayText2( bf_read &msg )
+{
+	// Got message during connection
+	if ( !g_PR )
+		return;
+
+	int client = msg.ReadByte();
+	bool bWantsToChat = msg.ReadByte();
+
+	wchar_t szBuf[6][256];
+	char untranslated_msg_text[256];
+	wchar_t *msg_text = ReadLocalizedString( msg, szBuf[0], sizeof( szBuf[0] ), false, untranslated_msg_text, sizeof( untranslated_msg_text ) );
+
+	// keep reading strings and using C format strings for subsituting the strings into the localised text string
+	ReadChatTextString ( msg, szBuf[1], sizeof( szBuf[1] ) );		// player name
+	ReadChatTextString ( msg, szBuf[2], sizeof( szBuf[2] ) );		// chat text
+	ReadLocalizedString( msg, szBuf[3], sizeof( szBuf[3] ), true );	// location
+	ReadLocalizedString( msg, szBuf[4], sizeof( szBuf[4] ), true );	// unused :(
+
+	g_pVGuiLocalize->ConstructString( szBuf[5], sizeof( szBuf[5] ), msg_text, 4, szBuf[1], szBuf[2], szBuf[3], szBuf[4] );
+
+	char ansiString[512];
+	g_pVGuiLocalize->ConvertUnicodeToANSI( ConvertCRtoNL( szBuf[5] ), ansiString, sizeof( ansiString ) );
+
+	// flash speaking player dot
+	if ( client > 0 )
+		Radar_FlashPlayer( client );
+
+	if ( bWantsToChat )
+	{
+		int iFilter = CHAT_FILTER_NONE;
+		bool playChatSound = true;
+
+		if ( client > 0 && (g_PR->GetTeam( client ) != g_PR->GetTeam( GetLocalPlayerIndex() )) )
+		{
+			iFilter = CHAT_FILTER_PUBLICCHAT;
+			if ( !( iFilter & GetFilterFlags() ) )
+			{
+				playChatSound = false;
+			}
+		}
+
+		// print raw chat text
+		ChatPrintf( client, iFilter, "%s", ansiString );
+
+		Msg( "%s\n", RemoveColorMarkup(ansiString) );
+
+		if ( playChatSound )
+		{
+			CLocalPlayerFilter filter;
+			C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "HudChat.Message" );
+		}
+	}
+	else
+	{
+		// print raw chat text
+		ChatPrintf( client, GetFilterForString( untranslated_msg_text), "%s", ansiString );
+	}
+}
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CHudChat::GetChatInputOffset( void )
+{
+	if ( m_pChatInput->IsVisible() )
+	{
+		return m_iFontHeight;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reads in an Audio message from the server (wav file to be played
+//          via the player's voice, i.e. for bot chatter)
+//-----------------------------------------------------------------------------
+void CHudChat::MsgFunc_RawAudio( bf_read &msg )
+{
+	char szString[2048];
+	int pitch = msg.ReadByte();
+	int playerIndex = msg.ReadByte();
+	float feedbackDuration = msg.ReadFloat();
+	msg.ReadString( szString, sizeof(szString) );
+
+	EmitSound_t ep;
+	ep.m_nChannel = CHAN_VOICE;
+	ep.m_pSoundName = szString;
+	ep.m_flVolume = 1.0f;
+	ep.m_SoundLevel = SNDLVL_NORM;
+	ep.m_nPitch = pitch;
+
+	CLocalPlayerFilter filter;
+	C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, ep );
+
+	if ( feedbackDuration > 0.0f )
+	{
+		//Flash them on the radar
+		C_CSPlayer *pPlayer = static_cast<C_CSPlayer*>( cl_entitylist->GetEnt(playerIndex) );
+
+		if ( pPlayer )
+		{
+			// Create the flashy above player's head
+			RadioManager()->UpdateVoiceStatus( playerIndex, feedbackDuration );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+Color CHudChat::GetClientColor( int clientIndex )
+{
+	if ( clientIndex == 0 ) // console msg
+	{
+		return g_ColorGreen;
+	}
+	else if( g_PR )
+	{
+		switch ( g_PR->GetTeam( clientIndex ) )
+		{
+		case 2	: return g_ColorRed;
+		case 3	: return g_ColorBlue;
+		default	: return g_ColorGrey;
+		}
+	}
+
+	return g_ColorYellow;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+Color CHudChat::GetTextColorForClient( TextColor colorNum, int clientIndex )
+{
+	Color c;
+	switch ( colorNum )
+	{
+	case COLOR_PLAYERNAME:
+		c = GetClientColor( clientIndex );
+		break;
+
+	case COLOR_LOCATION:
+		c = g_ColorDarkGreen;
+		break;
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [tj] Adding support for achievement coloring. 
+    //      Just doing what all the other games do
+    //=============================================================================
+     
+    case COLOR_ACHIEVEMENT:
+        {
+            vgui::IScheme *pSourceScheme = vgui::scheme()->GetIScheme( vgui::scheme()->GetScheme( "SourceScheme" ) ); 
+            if ( pSourceScheme )
+            {
+                c = pSourceScheme->GetColor( "SteamLightGreen", GetBgColor() );
+            }
+            else
+            {
+                c = GetDefaultTextColor();
+            }
+        }
+        break;
+     
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+    
+
+	default:
+		c = g_ColorYellow;
+	}
+
+	return Color( c[0], c[1], c[2], 255 );
+}
+
+int CHudChat::GetFilterForString( const char *pString )
+{
+	int iFilter = BaseClass::GetFilterForString( pString );
+
+	if ( iFilter == CHAT_FILTER_NONE )
+	{
+		if ( !Q_stricmp( pString, "#CStrike_Name_Change" ) ) 
+		{
+			return CHAT_FILTER_NAMECHANGE;
+		}
+	}
+
+	return iFilter;
+}
+
+void CHudChat::StartMessageMode( int iMessageModeType )
+{
+	BaseClass::StartMessageMode(iMessageModeType);
+
+	vgui::ipanel()->SetTopmostPopup(GetVPanel(), true);
+}
+
+void CHudChat::StopMessageMode( void )
+{
+	vgui::ipanel()->SetTopmostPopup(GetVPanel(), false);
+
+	BaseClass::StopMessageMode();
+}
\ No newline at end of file
diff --git a/game/client/cstrike/cs_hud_chat.h b/game/client/cstrike/cs_hud_chat.h
new file mode 100644
index 00000000..8c94acef
--- /dev/null
+++ b/game/client/cstrike/cs_hud_chat.h
@@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_HUD_CHAT_H
+#define CS_HUD_CHAT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <hud_basechat.h>
+
+//--------------------------------------------------------------------------------------------------------------
+class CHudChatLine : public CBaseHudChatLine
+{
+	DECLARE_CLASS_SIMPLE( CHudChatLine, CBaseHudChatLine );
+
+public:
+	CHudChatLine( vgui::Panel *parent, const char *panelName );
+
+	virtual void	ApplySchemeSettings(vgui::IScheme *pScheme);
+
+private:
+	CHudChatLine( const CHudChatLine & ); // not defined, not accessible
+	
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: The prompt and text entry area for chat messages
+//-----------------------------------------------------------------------------
+class CHudChatInputLine : public CBaseHudChatInputLine
+{
+	DECLARE_CLASS_SIMPLE( CHudChatInputLine, CBaseHudChatInputLine );
+	
+public:
+	CHudChatInputLine( CBaseHudChat *parent, char const *panelName ) : CBaseHudChatInputLine( parent, panelName ) {}
+
+	virtual void	ApplySchemeSettings(vgui::IScheme *pScheme);
+};
+
+class CHudChat : public CBaseHudChat
+{
+	DECLARE_CLASS_SIMPLE( CHudChat, CBaseHudChat );
+
+public:
+	CHudChat( const char *pElementName );
+
+	virtual void	CreateChatInputLine( void );
+	virtual void	CreateChatLines( void );
+
+	virtual void	Init( void );
+	virtual void	Reset( void );
+
+	virtual void	StartMessageMode( int iMessageModeType );
+	virtual void	StopMessageMode( void );
+
+	virtual void	MsgFunc_SayText2( bf_read &msg );
+	virtual void	MsgFunc_RadioText( bf_read &msg );
+	void			MsgFunc_RawAudio( bf_read &msg );
+
+	int				GetChatInputOffset( void );
+
+
+	virtual Color	GetTextColorForClient( TextColor colorNum, int clientIndex );
+	virtual Color	GetClientColor( int clientIndex );
+
+	virtual int GetFilterForString( const char *pString );
+};
+
+#endif	//CS_HUD_CHAT_H
diff --git a/game/client/cstrike/cs_hud_damageindicator.cpp b/game/client/cstrike/cs_hud_damageindicator.cpp
new file mode 100644
index 00000000..60ce0092
--- /dev/null
+++ b/game/client/cstrike/cs_hud_damageindicator.cpp
@@ -0,0 +1,362 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "text_message.h"
+#include "hud_macros.h"
+#include "iclientmode.h"
+#include "view.h"
+#include <KeyValues.h>
+#include <vgui/ISurface.h>
+#include <vgui_controls/Panel.h>
+#include "VGuiMatSurface/IMatSystemSurface.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imesh.h"
+#include "materialsystem/imaterialvar.h"
+#include "IEffects.h"
+#include "hudelement.h"
+// NVNT damage
+#include "haptics/haptic_utils.h"
+using namespace vgui;
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: HDU Damage indication
+//-----------------------------------------------------------------------------
+class CHudDamageIndicator : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudDamageIndicator, vgui::Panel );
+
+public:
+	CHudDamageIndicator( const char *pElementName );
+
+	void	Init( void );
+	void	Reset( void );
+	bool	ShouldDraw( void );
+
+	// Handler for our message
+	void	MsgFunc_Damage( bf_read &msg );
+
+private:
+	void	Paint();
+	void	ApplySchemeSettings(vgui::IScheme *pScheme);
+
+private:
+	void	CalcDamageDirection( const Vector &vecFrom );
+	void	DrawDamageIndicatorFront( float flFade );
+	void	DrawDamageIndicatorRear( float flFade );
+	void	DrawDamageIndicatorLeft( float flFade );
+	void	DrawDamageIndicatorRight( float flFade );
+
+private:
+	float	m_flAttackFront;
+	float	m_flAttackRear;
+	float	m_flAttackLeft;
+	float	m_flAttackRight;
+
+	Color	m_clrIndicator;
+
+	CHudTexture	*icon_up;
+	CHudTexture	*icon_down;
+	CHudTexture	*icon_left;
+	CHudTexture	*icon_right;
+
+	float m_flFadeCompleteTime;	//don't draw past this time
+};
+
+DECLARE_HUDELEMENT( CHudDamageIndicator );
+DECLARE_HUD_MESSAGE( CHudDamageIndicator, Damage );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CHudDamageIndicator::CHudDamageIndicator( const char *pElementName ) : CHudElement( pElementName ), BaseClass(NULL, "HudDamageIndicator")
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetHiddenBits( HIDEHUD_HEALTH );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::Reset( void )
+{
+	m_flAttackFront	= 0.0;
+	m_flAttackRear	= 0.0;
+	m_flAttackRight	= 0.0;
+	m_flAttackLeft	= 0.0;
+
+	m_flFadeCompleteTime = 0.0;
+
+	m_clrIndicator.SetColor( 250, 0, 0, 255 );
+}
+
+void CHudDamageIndicator::Init( void )
+{
+	HOOK_HUD_MESSAGE( CHudDamageIndicator, Damage );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHudDamageIndicator::ShouldDraw( void )
+{
+	if ( !CHudElement::ShouldDraw() )
+		return false;
+
+	if ( ( m_flAttackFront <= 0.0 ) && ( m_flAttackRear <= 0.0 ) && ( m_flAttackLeft <= 0.0 ) && ( m_flAttackRight <= 0.0 ) )
+		return false;
+
+	return true;
+}
+
+void CHudDamageIndicator::DrawDamageIndicatorFront( float flFade )
+{
+	if ( m_flAttackFront > 0.4 )
+	{
+		if ( !icon_up )
+		{
+			icon_up = gHUD.GetIcon( "pain_up" );
+		}
+
+		if ( !icon_up )
+		{
+			return;
+		}
+
+		int	x = ( ScreenWidth() / 2 ) - icon_up->Width() / 2;
+		int	y = ( ScreenHeight() / 2 ) - icon_up->Height() * 3;
+		icon_up->DrawSelf( x, y, m_clrIndicator );
+
+		m_flAttackFront = MAX( 0.0, m_flAttackFront - flFade );
+	}
+	else
+	{
+		m_flAttackFront = 0.0;
+	}
+}
+
+void CHudDamageIndicator::DrawDamageIndicatorRear( float flFade )
+{
+	if ( m_flAttackRear > 0.4 )
+	{
+		if ( !icon_down )
+		{
+			icon_down = gHUD.GetIcon( "pain_down" );
+		}
+
+		if ( !icon_down )
+		{
+			return;
+		}
+
+		int	x = ( ScreenWidth() / 2 ) - icon_down->Width() / 2;
+		int	y = ( ScreenHeight() / 2 ) + icon_down->Height() * 2;
+		icon_down->DrawSelf( x, y, m_clrIndicator );
+
+		m_flAttackRear = MAX( 0.0, m_flAttackRear - flFade );
+	}
+	else
+	{
+		m_flAttackRear = 0.0;
+	}
+}
+
+
+void CHudDamageIndicator::DrawDamageIndicatorLeft( float flFade )
+{
+	if ( m_flAttackLeft > 0.4 )
+	{
+		if ( !icon_left )
+		{
+			icon_left = gHUD.GetIcon( "pain_left" );
+		}
+
+		if ( !icon_left )
+		{
+			return;
+		}
+
+		int	x = ( ScreenWidth() / 2 ) - icon_left->Width() * 3;
+		int	y = ( ScreenHeight() / 2 ) - icon_left->Height() / 2;
+		icon_left->DrawSelf( x, y, m_clrIndicator );
+
+		m_flAttackLeft = MAX( 0.0, m_flAttackLeft - flFade );
+	}
+	else
+	{
+		m_flAttackLeft = 0.0;
+	}
+}
+
+
+void CHudDamageIndicator::DrawDamageIndicatorRight( float flFade )
+{
+	if ( m_flAttackRight > 0.4 )
+	{
+		if ( !icon_right )
+		{
+			icon_right = gHUD.GetIcon( "pain_right" );
+		}
+
+		if ( !icon_right )
+		{
+			return;
+		}
+
+		int	x = ( ScreenWidth() / 2 ) + icon_right->Width() * 2;
+		int	y = ( ScreenHeight() / 2 ) - icon_right->Height() / 2;
+		icon_right->DrawSelf( x, y, m_clrIndicator );
+
+		m_flAttackRight = MAX( 0.0, m_flAttackRight - flFade );
+	}
+	else
+	{
+		m_flAttackRight = 0.0;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Paints the damage display
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::Paint()
+{
+	if( m_flFadeCompleteTime > gpGlobals->curtime )
+	{
+		float flFade = gpGlobals->frametime * 2;
+		// draw damage indicators	
+		DrawDamageIndicatorFront( flFade );
+		DrawDamageIndicatorRear( flFade );
+		DrawDamageIndicatorLeft( flFade );
+		DrawDamageIndicatorRight( flFade );
+	}	
+}
+// NVNT static to pass damage
+static float hap_damage_amount = 0;
+
+//-----------------------------------------------------------------------------
+// Purpose: Message handler for Damage message
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::MsgFunc_Damage( bf_read &msg )
+{
+	int damageTaken	= msg.ReadByte();	
+
+	Vector vecFrom;
+	msg.ReadBitVec3Coord( vecFrom );
+
+	// NVNT pass damage to static holder
+	hap_damage_amount = damageTaken;
+
+	if ( damageTaken > 0 )
+	{
+		m_flFadeCompleteTime = gpGlobals->curtime + 1.0;
+		CalcDamageDirection( vecFrom );
+	}
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Added reads for the added location based parameters to this message
+//=============================================================================	 
+	msg.ReadLong();
+	msg.ReadBitVec3Coord( vecFrom );	 
+//=============================================================================
+// HPE_END
+//=============================================================================
+}
+
+void CHudDamageIndicator::CalcDamageDirection( const Vector &vecFrom )
+{
+	if ( vecFrom == vec3_origin )
+	{
+		m_flAttackFront	= 0.0;
+		m_flAttackRear	= 0.0;
+		m_flAttackRight	= 0.0;
+		m_flAttackLeft	= 0.0;
+
+		return;
+	}
+
+	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pLocalPlayer )
+	{
+		return;
+	}
+
+	Vector vecDelta = ( vecFrom - pLocalPlayer->GetRenderOrigin() );
+
+	if ( vecDelta.Length() <= 50 )
+	{
+		m_flAttackFront	= 1.0;
+		m_flAttackRear	= 1.0;
+		m_flAttackRight	= 1.0;
+		m_flAttackLeft	= 1.0;
+
+		return;
+	}
+
+	VectorNormalize( vecDelta );
+
+	Vector forward;
+	Vector right;
+	Vector up;
+	AngleVectors( MainViewAngles(), &forward, &right, &up );
+
+
+	float flFront	= DotProduct( vecDelta, forward );
+	float flSide	= DotProduct( vecDelta, right );
+	float flUp      = DotProduct( vecDelta, up);
+
+	if ( flFront > 0 )
+	{
+		if ( flFront > 0.3 )
+			m_flAttackFront = MAX( m_flAttackFront, flFront );
+	}
+	else
+	{
+		float f = fabs( flFront );
+		if ( f > 0.3 )
+			m_flAttackRear = MAX( m_flAttackRear, f );
+	}
+
+	if ( flSide > 0 )
+	{
+		if ( flSide > 0.3 )
+			m_flAttackRight = MAX( m_flAttackRight, flSide );
+	}
+	else
+	{
+		float f = fabs( flSide );
+		if ( f > 0.3 )
+			m_flAttackLeft = MAX( m_flAttackLeft, f );
+	}
+
+	// NVNT pass damage. (use hap_damage amount to apply)
+	// do rotation
+	Vector hapDir(-flSide,-flUp,flFront);
+	if ( haptics )
+		haptics->ApplyDamageEffect(hap_damage_amount, 0, hapDir);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: hud scheme settings
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+	SetPaintBackgroundEnabled(false);
+
+	int wide, tall;
+	GetHudSize(wide, tall);
+	SetSize(wide, tall);
+}
diff --git a/game/client/cstrike/cs_hud_freezepanel.cpp b/game/client/cstrike/cs_hud_freezepanel.cpp
new file mode 100644
index 00000000..866be241
--- /dev/null
+++ b/game/client/cstrike/cs_hud_freezepanel.cpp
@@ -0,0 +1,347 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_hud_freezepanel.h"
+#include <vgui/IVGui.h>
+#include "vgui_controls/AnimationController.h"
+#include "iclientmode.h"
+#include "c_cs_player.h"
+#include "c_cs_playerresource.h"
+#include <vgui_controls/Label.h>
+#include <vgui/ILocalize.h>
+#include <vgui/ISurface.h>
+#include "VGUI/bordered_panel.h"
+#include "fmtstr.h"
+#include "cs_gamerules.h"
+#include "view.h"
+#include "ivieweffects.h"
+#include "viewrender.h"
+#include "usermessages.h"
+#include "hud_macros.h"
+#include "c_baseanimating.h"
+#include "backgroundpanel.h"	// rounded border support
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+DECLARE_HUDELEMENT_DEPTH( CCSFreezePanel, 1 );
+// DECLARE_HUD_MESSAGE( CCSFreezePanel, Damage );
+// DECLARE_HUD_MESSAGE( CCSFreezePanel, DroppedEquipment );
+
+#define CALLOUT_WIDE		(XRES(100))
+#define CALLOUT_TALL		(XRES(50))
+
+
+ConVar cl_disablefreezecam(
+	"cl_disablefreezecam",
+	"0",
+	FCVAR_ARCHIVE,
+	"Turn on/off freezecam on client"
+	);
+
+
+Color LerpColors( Color cStart, Color cEnd, float flPercent )
+{
+	float r = (float)((float)(cStart.r()) + (float)(cEnd.r() - cStart.r()) * flPercent);
+	float g = (float)((float)(cStart.g()) + (float)(cEnd.g() - cStart.g()) * flPercent);
+	float b = (float)((float)(cStart.b()) + (float)(cEnd.b() - cStart.b()) * flPercent);
+	float a = (float)((float)(cStart.a()) + (float)(cEnd.a() - cStart.a()) * flPercent);
+	return Color( r, g, b, a );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:  Clips the health image to the appropriate percentage
+//-----------------------------------------------------------------------------
+class HorizontalGauge : public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( HorizontalGauge, vgui::Panel );
+
+	HorizontalGauge( Panel *parent, const char *name ) : 
+		vgui::Panel( parent, name ), 
+		m_fPercent(0.0f)
+	{
+	}
+
+/*
+	void ApplySettings(KeyValues *inResourceData)
+	{
+		BaseClass::ApplySettings(inResourceData);
+
+		Color color0 = inResourceData->GetColor( "color0");
+		Color color1 = inResourceData->GetColor( "color1");
+	}
+*/
+
+	void PaintBackground()
+	{
+		int wide, tall;
+		GetSize(wide, tall);
+
+		surface()->DrawSetColor( Color(0, 0, 0, 128) );
+		surface()->DrawFilledRect(0, 0, wide, tall);
+
+		// do the border explicitly here
+		surface()->DrawSetColor( Color(0,0,0,255));
+		surface()->DrawOutlinedRect(0, 0, wide, tall);
+	}
+
+	virtual void Paint()
+	{
+		int wide, tall;
+		GetSize(wide, tall);
+
+		Color lowHealth(192, 32, 32, 255);
+		Color highHealth(32, 255, 32, 255);
+
+		surface()->DrawSetColor( LerpColors(lowHealth, highHealth, m_fPercent) );
+		surface()->DrawFilledRect(1, 1, (int)((wide - 1) * m_fPercent), tall - 1);
+	}
+		
+	void SetPercent( float fPercent ) { m_fPercent = fPercent; }
+
+private:
+	float m_fPercent;
+};
+
+DECLARE_BUILD_FACTORY( HorizontalGauge );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CCSFreezePanel::CCSFreezePanel( const char *pElementName ) :
+	EditablePanel( NULL, "FreezePanel" ), 
+	CHudElement( pElementName ),
+	m_pBackgroundPanel(NULL),
+	m_pKillerHealth(NULL),
+	m_pAvatar(NULL),
+	m_pDominationIcon(NULL)
+{
+	SetSize( 10, 10 ); // Quiet "parent not sized yet" spew
+	SetParent(g_pClientMode->GetViewport());
+	m_bShouldBeVisible = false;
+	SetScheme( "ClientScheme" );
+	RegisterForRenderGroup( "hide_for_scoreboard" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSFreezePanel::Reset()
+{
+	Hide();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSFreezePanel::Init()
+{
+	CHudElement::Init();
+
+	// listen for events
+	ListenForGameEvent( "show_freezepanel" );
+	ListenForGameEvent( "hide_freezepanel" );
+	ListenForGameEvent( "freezecam_started" );
+	ListenForGameEvent( "player_death" );
+
+	Hide();
+
+	InitLayout();
+
+}
+
+void CCSFreezePanel::InitLayout()
+{
+	LoadControlSettings( "resource/UI/FreezePanel_Basic.res" );
+
+	m_pBackgroundPanel = dynamic_cast<BorderedPanel*>( FindChildByName("FreezePanelBG"));
+	m_pAvatar = dynamic_cast<CAvatarImagePanel*>( m_pBackgroundPanel->FindChildByName("AvatarImage"));
+	m_pKillerHealth	= dynamic_cast<HorizontalGauge*>( m_pBackgroundPanel->FindChildByName("KillerHealth"));
+	m_pDominationIcon = dynamic_cast<ImagePanel*>( m_pBackgroundPanel->FindChildByName("DominationIcon"));
+
+	m_pAvatar->SetDefaultAvatar(scheme()->GetImage( CSTRIKE_DEFAULT_AVATAR, true ));
+	m_pAvatar->SetShouldScaleImage(true);
+	m_pAvatar->SetShouldDrawFriendIcon(false);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Applies scheme settings
+//-----------------------------------------------------------------------------
+void CCSFreezePanel::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSFreezePanel::FireGameEvent( IGameEvent * event )
+{
+	const char *pEventName = event->GetName();
+
+	if ( Q_strcmp( "player_death", pEventName ) == 0 )
+	{
+		// see if the local player died
+		int iPlayerIndexVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+		int iPlayerIndexKiller = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
+		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+		CCSPlayer* pKiller =  ToCSPlayer(ClientEntityList().GetBaseEntity(iPlayerIndexKiller));
+
+		if ( pLocalPlayer && iPlayerIndexVictim == pLocalPlayer->entindex() )
+		{
+			// the local player is dead, see if this is a new nemesis or a revenge
+			if ( event->GetInt( "dominated" ) > 0)
+			{
+				m_pDominationIcon->SetImage("../hud/freeze_nemesis");
+				m_pDominationIcon->SetVisible(true);
+
+				m_pBackgroundPanel->SetDialogVariable( "InfoLabel1", g_pVGuiLocalize->Find("#FreezePanel_NewNemesis1"));
+				m_pBackgroundPanel->SetDialogVariable( "InfoLabel2", g_pVGuiLocalize->Find("#FreezePanel_NewNemesis2"));
+			}
+			// was the killer your pre-existing nemesis?
+			else if ( pKiller != NULL && pKiller->IsPlayerDominated(iPlayerIndexVictim) )
+			{
+				m_pDominationIcon->SetImage("../hud/freeze_nemesis");
+				m_pDominationIcon->SetVisible(true);
+
+				m_pBackgroundPanel->SetDialogVariable( "InfoLabel1", g_pVGuiLocalize->Find("#FreezePanel_OldNemesis1"));
+				m_pBackgroundPanel->SetDialogVariable( "InfoLabel2", g_pVGuiLocalize->Find("#FreezePanel_OldNemesis2"));
+			}
+			else if ( event->GetInt( "revenge" ) > 0 )
+			{
+				m_pDominationIcon->SetImage("../hud/freeze_revenge");
+				m_pDominationIcon->SetVisible(true);
+
+				m_pBackgroundPanel->SetDialogVariable( "InfoLabel1", g_pVGuiLocalize->Find("#FreezePanel_Revenge1"));
+				m_pBackgroundPanel->SetDialogVariable( "InfoLabel2", g_pVGuiLocalize->Find("#FreezePanel_Revenge2"));
+			}
+			else
+			{
+  				m_pDominationIcon->SetVisible(false);
+				m_pBackgroundPanel->SetDialogVariable( "InfoLabel1", g_pVGuiLocalize->Find("#FreezePanel_Killer1"));
+				m_pBackgroundPanel->SetDialogVariable( "InfoLabel2", g_pVGuiLocalize->Find("#FreezePanel_Killer2"));
+			}
+		}
+	}
+	else if ( Q_strcmp( "hide_freezepanel", pEventName ) == 0 )
+	{
+		Hide();
+	}
+	else if ( Q_strcmp( "freezecam_started", pEventName ) == 0 )
+	{
+	}
+	else if ( Q_strcmp( "show_freezepanel", pEventName ) == 0 )
+	{
+		C_CS_PlayerResource *cs_PR = dynamic_cast<C_CS_PlayerResource *>( g_PR );
+		if ( !cs_PR )
+			return;
+
+		Show();
+
+		// Get the entity who killed us
+		int iKillerIndex = event->GetInt( "killer" );
+		CCSPlayer* pKiller =  ToCSPlayer(ClientEntityList().GetBaseEntity(iKillerIndex));
+		m_pAvatar->ClearAvatar();
+
+		if ( pKiller )
+		{
+			int iMaxHealth = pKiller->GetMaxHealth();
+			int iKillerHealth = pKiller->GetHealth();
+			if ( !pKiller->IsAlive() )
+			{
+				iKillerHealth = 0;
+			}
+
+			m_pKillerHealth->SetPercent( (float)iKillerHealth / iMaxHealth );
+
+			char killerName[128];
+			V_snprintf( killerName, sizeof(killerName), "%s", g_PR->GetPlayerName(iKillerIndex) );
+//			V_strupr( killerName );
+
+			m_pBackgroundPanel->SetDialogVariable( "killername", killerName);
+
+			int iKillerIndex = pKiller->entindex();
+			player_info_t pi;
+
+			m_pAvatar->SetDefaultAvatar( GetDefaultAvatarImage( pKiller ) );
+
+			if ( engine->GetPlayerInfo(iKillerIndex, &pi) )
+			{
+				m_pAvatar->SetPlayer( (C_BasePlayer*)pKiller, k_EAvatarSize64x64);
+				m_pAvatar->SetVisible(true);
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CCSFreezePanel::ShouldDraw( void )
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [Forrest] Added sv_disablefreezecam check
+	//=============================================================================
+	static ConVarRef sv_disablefreezecam( "sv_disablefreezecam" );
+	return ( m_bShouldBeVisible && !cl_disablefreezecam.GetBool() && !sv_disablefreezecam.GetBool() && CHudElement::ShouldDraw() );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+void CCSFreezePanel::OnScreenSizeChanged( int nOldWide, int nOldTall )
+{
+	BaseClass::OnScreenSizeChanged(nOldWide, nOldTall);
+
+	InitLayout();
+}
+
+void CCSFreezePanel::SetActive( bool bActive )
+{
+	CHudElement::SetActive( bActive );
+
+	if ( bActive )
+	{
+		// Setup replay key binding in UI
+		const char *pKey = engine->Key_LookupBinding( "save_replay" );
+		if ( pKey == NULL || FStrEq( pKey, "(null)" ) )
+		{
+			pKey = "<NOT BOUND>";
+		}
+
+		char szKey[16];
+		Q_snprintf( szKey, sizeof(szKey), "%s", pKey );
+		wchar_t wKey[16];
+		wchar_t wLabel[256];
+
+		g_pVGuiLocalize->ConvertANSIToUnicode( szKey, wKey, sizeof( wKey ) );
+		g_pVGuiLocalize->ConstructString( wLabel, sizeof( wLabel ), g_pVGuiLocalize->Find("#FreezePanel_SaveReplay" ), 1, wKey );
+
+		m_pBackgroundPanel->SetDialogVariable( "savereplay", wLabel );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSFreezePanel::Show()
+{
+	m_bShouldBeVisible = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSFreezePanel::Hide()
+{
+	m_bShouldBeVisible = false;
+}
diff --git a/game/client/cstrike/cs_hud_freezepanel.h b/game/client/cstrike/cs_hud_freezepanel.h
new file mode 100644
index 00000000..12fed713
--- /dev/null
+++ b/game/client/cstrike/cs_hud_freezepanel.h
@@ -0,0 +1,70 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef CS_HUD_FREEZEPANEL_H
+#define CS_HUD_FREEZEPANEL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <KeyValues.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui/ISystem.h>
+#include <vgui_controls/AnimationController.h>
+#include <vgui_controls/EditablePanel.h>
+#include "vgui/ILocalize.h"
+#include "vgui_avatarimage.h"
+#include "hud.h"
+#include "hudelement.h"
+#include "cs_hud_playerhealth.h"
+
+#include "cs_shareddefs.h"
+
+using namespace vgui;
+
+class HorizontalGauge;
+class BorderedPanel;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CCSFreezePanel : public EditablePanel, public CHudElement
+{
+private:
+	DECLARE_CLASS_SIMPLE( CCSFreezePanel, EditablePanel );
+
+public:
+	CCSFreezePanel( const char *pElementName );
+
+	virtual void Reset();
+	virtual void Init();
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void FireGameEvent( IGameEvent * event );
+	virtual bool ShouldDraw();
+	virtual void OnScreenSizeChanged(int nOldWide, int nOldTall);
+
+	virtual void SetActive( bool bActive );
+
+	void InitLayout();
+	void Show();
+	void Hide();
+
+	int	HudElementKeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
+
+protected:
+
+private:
+	BorderedPanel*			m_pBackgroundPanel;
+	HorizontalGauge*		m_pKillerHealth;
+	CAvatarImagePanel*		m_pAvatar;
+	ImagePanel*				m_pDominationIcon;
+
+	bool					m_bShouldBeVisible;
+};
+
+#endif //CS_HUD_FREEZEPANEL_H
\ No newline at end of file
diff --git a/game/client/cstrike/cs_hud_health.cpp b/game/client/cstrike/cs_hud_health.cpp
new file mode 100644
index 00000000..26faee20
--- /dev/null
+++ b/game/client/cstrike/cs_hud_health.cpp
@@ -0,0 +1,175 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+//
+// Health.cpp
+//
+// implementation of CHudHealth class
+//
+#include "cbase.h"
+#include "hud.h"
+#include "hud_macros.h"
+#include "view.h"
+
+#include "iclientmode.h"
+
+#define PAIN_NAME "sprites/%d_pain.vmt"
+
+#include <KeyValues.h>
+#include <vgui/ISurface.h>
+#include <vgui/ISystem.h>
+#include <vgui_controls/AnimationController.h>
+
+using namespace vgui;
+
+#include "hudelement.h"
+#include "hud_numericdisplay.h"
+#include "cs_gamerules.h"
+
+#include "convar.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Health panel
+//-----------------------------------------------------------------------------
+class CHudHealth : public CHudElement, public CHudNumericDisplay
+{
+	DECLARE_CLASS_SIMPLE( CHudHealth, CHudNumericDisplay );
+
+public:
+	CHudHealth( const char *pElementName );
+	virtual void Init( void );
+	virtual void VidInit( void );
+	virtual void Reset( void );
+	virtual void OnThink();
+
+	virtual void Paint( void );
+	virtual void ApplySchemeSettings( IScheme *scheme );
+
+private:
+	// old variables
+	int		m_iHealth;
+
+	int		m_bitsDamage;
+
+	CHudTexture *m_pHealthIcon;
+
+	CPanelAnimationVarAliasType( float, icon_xpos, "icon_xpos", "0", "proportional_float" );
+	CPanelAnimationVarAliasType( float, icon_ypos, "icon_ypos", "0", "proportional_float" );
+
+//	CPanelAnimationVar( Color, m_LowHealthColor, "LowHealthColor", "255 0 0 255" );
+
+	float icon_tall;
+	float icon_wide;
+
+};
+
+DECLARE_HUDELEMENT( CHudHealth );
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CHudHealth::CHudHealth( const char *pElementName ) : CHudElement( pElementName ), CHudNumericDisplay(NULL, "HudHealth")
+{
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CHudHealth::Init()
+{
+	m_iHealth		= 100;
+	m_bitsDamage	= 0;
+	icon_tall		= 0;
+	icon_wide		= 0;
+	SetIndent(true);
+	SetDisplayValue(m_iHealth);
+}
+
+void CHudHealth::ApplySchemeSettings( IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+
+	if( !m_pHealthIcon )
+	{
+		m_pHealthIcon = gHUD.GetIcon( "health_icon" );
+	}
+
+	if( m_pHealthIcon )
+	{
+
+		icon_tall = GetTall() - YRES(2);
+		float scale = icon_tall / (float)m_pHealthIcon->Height();
+		icon_wide = ( scale ) * (float)m_pHealthIcon->Width();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: reset health to normal color at round restart
+//-----------------------------------------------------------------------------
+void CHudHealth::Reset()
+{
+	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("HealthRestored");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CHudHealth::VidInit()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CHudHealth::OnThink()
+{
+	int realHealth = 0;
+	C_BasePlayer *local = C_BasePlayer::GetLocalPlayer();
+	if ( local )
+	{
+		// Never below zero
+		realHealth = MAX( local->GetHealth(), 0 );
+	}
+
+	// Only update the fade if we've changed health
+	if ( realHealth == m_iHealth )
+	{
+		return;
+	}
+
+	if( realHealth > m_iHealth)
+	{
+		// round restarted, we have 100 again
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("HealthRestored");
+	}
+	else if ( realHealth <= 25 )
+	{
+		// we are badly injured
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("HealthLow");
+	}
+	else if( realHealth < m_iHealth )
+	{
+		// took a hit
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("HealthTookDamage");
+	}
+
+	m_iHealth = realHealth;
+
+	SetDisplayValue(m_iHealth);
+}
+
+void CHudHealth::Paint( void )
+{
+	if( m_pHealthIcon )
+	{
+		m_pHealthIcon->DrawSelf( icon_xpos, icon_ypos, icon_wide, icon_tall, GetFgColor() );
+	}
+
+	//draw the health icon
+	BaseClass::Paint();
+}
\ No newline at end of file
diff --git a/game/client/cstrike/cs_hud_playerhealth.cpp b/game/client/cstrike/cs_hud_playerhealth.cpp
new file mode 100644
index 00000000..f0f21601
--- /dev/null
+++ b/game/client/cstrike/cs_hud_playerhealth.cpp
@@ -0,0 +1,172 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: To display the player's health with the use of one graphic over another.  A cross in this case
+//			Currently this is only used on the freeze cam panel
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_hud_freezepanel.h"
+#include "vgui_controls/AnimationController.h"
+#include "iclientmode.h"
+#include "c_cs_player.h"
+#include "c_cs_playerresource.h"
+#include <vgui_controls/Label.h>
+#include <vgui/ILocalize.h>
+#include <vgui/ISurface.h>
+#include "cs_gamerules.h"
+
+DECLARE_BUILD_FACTORY( CCSHudPlayerHealth );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCSHudPlayerHealth::CCSHudPlayerHealth( Panel *parent, const char *name ) : EditablePanel( parent, name )
+{
+	m_pHealthImage = new CCSHealthPanel( this, "PlayerStatusHealthImage" );	
+	m_pHealthImageBG = new ImagePanel( this, "PlayerStatusHealthImageBG" );
+
+	m_flNextThink = 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSHudPlayerHealth::Reset()
+{
+	//m_flNextThink = gpGlobals->curtime + 0.05f;
+	m_nHealth = -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSHudPlayerHealth::ApplySchemeSettings( IScheme *pScheme )
+{
+	// load control settings...
+	LoadControlSettings( GetResFilename() );
+
+	m_flNextThink = 0.0f;
+
+	BaseClass::ApplySchemeSettings( pScheme );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSHudPlayerHealth::SetHealth( int iNewHealth, int iMaxHealth, int	iMaxBuffedHealth )
+{
+	int nPrevHealth = m_nHealth;
+
+	// set our health
+	m_nHealth = iNewHealth;
+	m_nMaxHealth = iMaxHealth;
+	m_pHealthImage->SetHealth( (float)(m_nHealth) / (float)(m_nMaxHealth) );
+
+	if ( m_pHealthImage )
+	{
+		m_pHealthImage->SetFgColor( Color( 255, 255, 255, 255 ) );
+	}
+
+	if ( m_nHealth <= 0 )
+	{
+		if ( m_pHealthImageBG->IsVisible() )
+		{
+			m_pHealthImageBG->SetVisible( false );
+		}
+	}
+	else
+	{
+		if ( !m_pHealthImageBG->IsVisible() )
+		{
+			m_pHealthImageBG->SetVisible( true );
+		}
+	}
+
+	// set our health display value
+	if ( nPrevHealth != m_nHealth )
+	{
+		if ( m_nHealth > 0 )
+		{
+			SetDialogVariable( "Health", m_nHealth );
+		}
+		else
+		{
+			SetDialogVariable( "Health", "" );
+		}	
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCSHealthPanel::CCSHealthPanel( Panel *parent, const char *name ) : vgui::Panel( parent, name )
+{
+	m_flHealth = 1.0f;
+
+	m_iMaterialIndex = surface()->DrawGetTextureId( "hud/health_color" );
+	if ( m_iMaterialIndex == -1 ) // we didn't find it, so create a new one
+	{
+		m_iMaterialIndex = surface()->CreateNewTextureID();	
+	}
+
+	surface()->DrawSetTextureFile( m_iMaterialIndex, "hud/health_color", true, false );
+
+	m_iDeadMaterialIndex = surface()->DrawGetTextureId( "hud/health_dead" );
+	if ( m_iDeadMaterialIndex == -1 ) // we didn't find it, so create a new one
+	{
+		m_iDeadMaterialIndex = surface()->CreateNewTextureID();	
+	}
+	surface()->DrawSetTextureFile( m_iDeadMaterialIndex, "hud/health_dead", true, false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSHealthPanel::Paint()
+{
+	BaseClass::Paint();
+
+	int x, y, w, h;
+	GetBounds( x, y, w, h );
+
+	Vertex_t vert[4];	
+	float uv1 = 0.0f;
+	float uv2 = 1.0f;
+	int xpos = 0, ypos = 0;
+
+	if ( m_flHealth <= 0 )
+	{
+		// Draw the dead material
+		surface()->DrawSetTexture( m_iDeadMaterialIndex );
+
+		vert[0].Init( Vector2D( xpos, ypos ), Vector2D( uv1, uv1 ) );
+		vert[1].Init( Vector2D( xpos + w, ypos ), Vector2D( uv2, uv1 ) );
+		vert[2].Init( Vector2D( xpos + w, ypos + h ), Vector2D( uv2, uv2 ) );				
+		vert[3].Init( Vector2D( xpos, ypos + h ), Vector2D( uv1, uv2 ) );
+
+		surface()->DrawSetColor( Color(255,255,255,255) );
+	}
+	else
+	{
+		float flDamageY = h * ( 1.0f - m_flHealth );
+
+		// blend in the red "damage" part
+		surface()->DrawSetTexture( m_iMaterialIndex );
+
+		Vector2D uv11( uv1, uv2 - m_flHealth );
+		Vector2D uv21( uv2, uv2 - m_flHealth );
+		Vector2D uv22( uv2, uv2 );
+		Vector2D uv12( uv1, uv2 );
+
+		vert[0].Init( Vector2D( xpos, flDamageY ), uv11 );
+		vert[1].Init( Vector2D( xpos + w, flDamageY ), uv21 );
+		vert[2].Init( Vector2D( xpos + w, ypos + h ), uv22 );				
+		vert[3].Init( Vector2D( xpos, ypos + h ), uv12 );
+
+		surface()->DrawSetColor( GetFgColor() );
+	}
+
+	surface()->DrawTexturedPolygon( 4, vert );
+}
\ No newline at end of file
diff --git a/game/client/cstrike/cs_hud_playerhealth.h b/game/client/cstrike/cs_hud_playerhealth.h
new file mode 100644
index 00000000..6009dc9a
--- /dev/null
+++ b/game/client/cstrike/cs_hud_playerhealth.h
@@ -0,0 +1,77 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: To display the player's health with the use of one graphic over another.  A cross in this case
+//			Currently this is only used on the freeze cam panel
+//
+// $NoKeywords: $
+//=============================================================================//
+
+
+#ifndef CS_HUD_HEALTHPANEL_H
+#define CS_HUD_HEALTHPANEL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <KeyValues.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui/ISystem.h>
+#include <vgui_controls/AnimationController.h>
+#include <vgui_controls/EditablePanel.h>
+#include "vgui/ILocalize.h"
+#include "hud.h"
+#include "hudelement.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:  Clips the health image to the appropriate percentage
+//-----------------------------------------------------------------------------
+class CCSHealthPanel : public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CCSHealthPanel, vgui::Panel );
+
+	CCSHealthPanel( vgui::Panel *parent, const char *name );
+	virtual void Paint();
+	void SetHealth( float flHealth ){ m_flHealth = ( flHealth <= 1.0 ) ? flHealth : 1.0f; }
+
+private:
+
+	float	m_flHealth; // percentage from 0.0 -> 1.0
+	int		m_iMaterialIndex;
+	int		m_iDeadMaterialIndex;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose:  Displays player health data
+//-----------------------------------------------------------------------------
+class CCSHudPlayerHealth : public vgui::EditablePanel
+{
+	DECLARE_CLASS_SIMPLE( CCSHudPlayerHealth, EditablePanel );
+
+public:
+
+	CCSHudPlayerHealth( Panel *parent, const char *name );
+
+	virtual const char *GetResFilename( void ) { return "resource/UI/FreezePanelKillerHealth.res"; }
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void Reset();
+
+	void	SetHealth( int iNewHealth, int iMaxHealth, int iMaxBuffedHealth );
+	void	HideHealthBonusImage( void );
+
+protected:
+	//virtual void OnThink();
+
+protected:
+	float				m_flNextThink;
+
+private:
+	CCSHealthPanel		*m_pHealthImage;
+	vgui::ImagePanel	*m_pHealthImageBG;
+
+	int					m_nHealth;
+	int					m_nMaxHealth;
+};
+
+#endif
\ No newline at end of file
diff --git a/game/client/cstrike/cs_hud_scope.cpp b/game/client/cstrike/cs_hud_scope.cpp
new file mode 100644
index 00000000..13f51ac6
--- /dev/null
+++ b/game/client/cstrike/cs_hud_scope.cpp
@@ -0,0 +1,203 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "hudelement.h"
+#include "hud_macros.h"
+#include "hud_numericdisplay.h"
+#include "iclientmode.h"
+#include "c_cs_player.h"
+#include "VGuiMatSurface/IMatSystemSurface.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imesh.h"
+#include "materialsystem/imaterialvar.h"
+
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <KeyValues.h>
+#include <vgui_controls/AnimationController.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the zoom screen
+//-----------------------------------------------------------------------------
+class CHudScope : public vgui::Panel, public CHudElement
+{
+	DECLARE_CLASS_SIMPLE( CHudScope, vgui::Panel );
+
+public:
+			CHudScope( const char *pElementName );
+	
+	void	Init( void );
+	void	LevelInit( void );
+
+protected:
+	virtual void ApplySchemeSettings(vgui::IScheme *scheme);
+	virtual void Paint( void );
+
+private:
+	CMaterialReference m_ScopeMaterial;	
+	CMaterialReference m_DustOverlayMaterial;
+
+	int m_iScopeArcTexture;
+	int m_iScopeDustTexture;
+};
+
+DECLARE_HUDELEMENT_DEPTH( CHudScope, 70 );
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CHudScope::CHudScope( const char *pElementName ) : CHudElement(pElementName), BaseClass(NULL, "HudScope")
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+	
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: standard hud element init function
+//-----------------------------------------------------------------------------
+void CHudScope::Init( void )
+{
+	m_iScopeArcTexture = vgui::surface()->CreateNewTextureID();
+	vgui::surface()->DrawSetTextureFile(m_iScopeArcTexture, "sprites/scope_arc", true, false);
+
+	m_iScopeDustTexture = vgui::surface()->CreateNewTextureID();
+	vgui::surface()->DrawSetTextureFile(m_iScopeDustTexture, "overlays/scope_lens", true, false);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: standard hud element init function
+//-----------------------------------------------------------------------------
+void CHudScope::LevelInit( void )
+{
+	Init();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: sets scheme colors
+//-----------------------------------------------------------------------------
+void CHudScope::ApplySchemeSettings( vgui::IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings(scheme);
+
+	SetPaintBackgroundEnabled(false);
+	SetPaintBorderEnabled(false);
+
+	int screenWide, screenTall;
+	GetHudSize(screenWide, screenTall);
+	SetBounds(0, 0, screenWide, screenTall);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: draws the zoom effect
+//-----------------------------------------------------------------------------
+void CHudScope::Paint( void )
+{
+	C_CSPlayer *pPlayer = dynamic_cast<C_CSPlayer *>(C_BasePlayer::GetLocalPlayer());
+	
+	if ( pPlayer == NULL )
+		return;
+
+	CWeaponCSBase *pWeapon = pPlayer->GetActiveCSWeapon();
+		
+	if( !pWeapon )
+		return;
+
+	Assert( m_iScopeArcTexture );
+	Assert( m_iScopeDustTexture );
+
+	// see if we're zoomed with a sniper rifle
+	if( pPlayer->GetFOV() != pPlayer->GetDefaultFOV() &&
+		pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_SNIPER_RIFLE )
+	{
+		int screenWide, screenTall;
+		GetHudSize(screenWide, screenTall);
+
+		// calculate the bounds in which we should draw the scope
+		int inset = screenTall / 16;
+		int y1 = inset;
+		int x1 = (screenWide - screenTall) / 2 + inset; 
+		int y2 = screenTall - inset;
+		int x2 = screenWide - x1;
+
+		int x = screenWide / 2;
+		int y = screenTall / 2;
+
+		float uv1 = 0.5f / 256.0f, uv2 = 1.0f - uv1;
+
+		vgui::Vertex_t vert[4];	
+		
+		Vector2D uv11( uv1, uv1 );
+		Vector2D uv12( uv1, uv2 );
+		Vector2D uv21( uv2, uv1 );
+		Vector2D uv22( uv2, uv2 );
+
+		int xMod = ( screenWide / 2 );
+		int yMod = ( screenTall / 2 );
+
+		int iMiddleX = (screenWide / 2 );
+		int iMiddleY = (screenTall / 2 );
+
+		vgui::surface()->DrawSetTexture( m_iScopeDustTexture );
+		vgui::surface()->DrawSetColor( 255, 255, 255, 255 );
+
+		vert[0].Init( Vector2D( iMiddleX + xMod, iMiddleY + yMod ), uv21 );
+		vert[1].Init( Vector2D( iMiddleX - xMod, iMiddleY + yMod ), uv11 );
+		vert[2].Init( Vector2D( iMiddleX - xMod, iMiddleY - yMod ), uv12 );
+		vert[3].Init( Vector2D( iMiddleX + xMod, iMiddleY - yMod ), uv22 );
+		vgui::surface()->DrawTexturedPolygon( 4, vert );
+		
+		vgui::surface()->DrawSetColor(0,0,0,255);
+
+		//Draw the reticle with primitives
+		vgui::surface()->DrawLine( 0, y, screenWide, y );
+		vgui::surface()->DrawLine( x, 0, x, screenTall );
+
+		//Draw the outline
+		vgui::surface()->DrawSetTexture(m_iScopeArcTexture);
+
+		// bottom right
+		vert[0].Init( Vector2D( x, y ), uv11 );
+		vert[1].Init( Vector2D( x2, y ), uv21 );
+		vert[2].Init( Vector2D( x2, y2 ), uv22 );
+		vert[3].Init( Vector2D( x, y2 ), uv12 );
+		vgui::surface()->DrawTexturedPolygon( 4, vert );
+
+		// top right
+		vert[0].Init( Vector2D( x - 1, y1 ), uv12 );
+		vert[1].Init( Vector2D ( x2, y1 ), uv22 );
+		vert[2].Init( Vector2D( x2, y + 1 ), uv21 );
+		vert[3].Init( Vector2D( x - 1, y + 1 ), uv11 );
+		vgui::surface()->DrawTexturedPolygon(4, vert);
+
+		// bottom left
+		vert[0].Init( Vector2D( x1, y ), uv21 );
+		vert[1].Init( Vector2D( x, y ), uv11 );
+		vert[2].Init( Vector2D( x, y2 ), uv12 );
+		vert[3].Init( Vector2D( x1, y2), uv22 );
+		vgui::surface()->DrawTexturedPolygon(4, vert);
+
+		// top left
+		vert[0].Init( Vector2D( x1, y1 ), uv22 );
+		vert[1].Init( Vector2D( x, y1 ), uv12 );
+		vert[2].Init( Vector2D( x, y ), uv11 );
+		vert[3].Init( Vector2D( x1, y ), uv21 );
+		vgui::surface()->DrawTexturedPolygon(4, vert);
+	
+		vgui::surface()->DrawFilledRect(0, 0, screenWide, y1);				// top
+		vgui::surface()->DrawFilledRect(0, y2, screenWide, screenTall);		// bottom
+		vgui::surface()->DrawFilledRect(0, y1, x1, screenTall);				// left
+		vgui::surface()->DrawFilledRect(x2, y1, screenWide, screenTall);	// right
+	}
+}
diff --git a/game/client/cstrike/cs_hud_target_id.cpp b/game/client/cstrike/cs_hud_target_id.cpp
new file mode 100644
index 00000000..8c8c2d87
--- /dev/null
+++ b/game/client/cstrike/cs_hud_target_id.cpp
@@ -0,0 +1,379 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: HUD Target ID element
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "hudelement.h"
+#include "c_cs_player.h"
+#include "c_playerresource.h"
+#include "c_cs_playerresource.h"
+#include "vgui_entitypanel.h"
+#include "iclientmode.h"
+#include "vgui/ILocalize.h"
+
+#include "c_cs_hostage.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define PLAYER_HINT_DISTANCE	150
+#define PLAYER_HINT_DISTANCE_SQ	(PLAYER_HINT_DISTANCE*PLAYER_HINT_DISTANCE)
+
+extern CUtlVector< C_CHostage* > g_Hostages;
+
+static ConVar hud_showtargetpos( "hud_showtargetpos", "0", FCVAR_ARCHIVE, "0: center, 1: upper left, 2 upper right, 3: lower left, 4: lower right" );
+static ConVar hud_showtargetid( "hud_showtargetid", "1", FCVAR_ARCHIVE, "Enables display of target names" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CTargetID : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CTargetID, vgui::Panel );
+
+public:
+	CTargetID( const char *pElementName );
+	void Init( void );
+	virtual void	ApplySchemeSettings( vgui::IScheme *scheme );
+	virtual void	Paint( void );
+	void VidInit( void );
+
+private:
+	Color			GetColorForTargetTeam( int iTeamNumber );
+
+	vgui::HFont		m_hFont;
+	int				m_iLastEntIndex;
+	float			m_flLastChangeTime;
+
+	Color			m_cCTColor;
+	Color			m_cTerroristColor;
+	Color			m_cHostageColor;
+};
+
+DECLARE_HUDELEMENT( CTargetID );
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTargetID::CTargetID( const char *pElementName ) :
+	CHudElement( pElementName ), BaseClass( NULL, "TargetID" )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	m_hFont = g_hFontTrebuchet24;
+	m_flLastChangeTime = 0;
+	m_iLastEntIndex = 0;
+
+	SetHiddenBits( HIDEHUD_MISCSTATUS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Setup
+//-----------------------------------------------------------------------------
+void CTargetID::Init( void )
+{
+};
+
+void CTargetID::ApplySchemeSettings( vgui::IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+
+	m_cTerroristColor = scheme->GetColor( "T_Red", Color( 255, 64, 64, 255 ) );
+	m_cCTColor = scheme->GetColor( "CT_Blue", Color( 255, 64, 64, 255 ) );
+	m_cHostageColor = scheme->GetColor( "Hostage_yellow", Color( 255, 160, 0, 255 ) );
+	m_hFont = scheme->GetFont( "TargetID", true );
+
+	SetPaintBackgroundEnabled( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: clear out string etc between levels
+//-----------------------------------------------------------------------------
+void CTargetID::VidInit()
+{
+	CHudElement::VidInit();
+
+	// set our size to the current viewport size
+	SetSize(g_pClientMode->GetViewport()->GetWide(), g_pClientMode->GetViewport()->GetTall());
+
+	m_flLastChangeTime = 0;
+	m_iLastEntIndex = 0;
+}
+
+Color CTargetID::GetColorForTargetTeam( int iTeamNumber )
+{
+	switch( iTeamNumber )
+	{
+	case TEAM_CT:
+		return m_cCTColor;
+		break;
+
+	case TEAM_TERRORIST:
+		return m_cTerroristColor;
+		break;
+
+	default:
+		return m_cHostageColor;
+		break;
+	}
+} 
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw function for the element
+//-----------------------------------------------------------------------------
+void CTargetID::Paint()
+{
+	if ( hud_showtargetid.GetBool() == false )
+		return;
+
+#define MAX_ID_STRING 256
+	wchar_t sIDString[ MAX_ID_STRING ];
+	sIDString[0] = 0;
+
+	Color c = m_cHostageColor;
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( !pPlayer )
+		return;
+
+	// don't show target IDs when flashed
+	if ( pPlayer->m_flFlashBangTime > (gpGlobals->curtime+0.5) )
+		return;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Don't show target ID's when in freezecam mode
+	//=============================================================================
+	
+	if ( pPlayer->GetObserverMode() == OBS_MODE_FREEZECAM )
+		return;
+	 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	// Get our target's ent index
+	int iEntIndex = pPlayer->GetIDTarget();
+	// Didn't find one?
+	if ( !iEntIndex )
+	{
+		// Check to see if we should clear our ID
+		if ( m_flLastChangeTime && (gpGlobals->curtime > (m_flLastChangeTime + 0.5)) )
+		{
+			m_flLastChangeTime = 0;
+			sIDString[0] = 0;
+			m_iLastEntIndex = 0;
+		}
+		else
+		{
+			// Keep re-using the old one
+			iEntIndex = m_iLastEntIndex;
+		}
+	}
+	else
+	{
+		m_flLastChangeTime = gpGlobals->curtime;
+	}
+
+	// Is this an entindex sent by the server?
+	if ( iEntIndex )
+	{
+		C_BasePlayer *pPlayer = static_cast<C_BasePlayer*>(cl_entitylist->GetEnt( iEntIndex ));
+		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+
+		const char *printFormatString = NULL;
+		wchar_t wszClanTag[ MAX_PLAYER_NAME_LENGTH ];
+		wchar_t wszPlayerName[ MAX_PLAYER_NAME_LENGTH ];
+		wchar_t wszHealthText[ 10 ];
+		bool bShowHealth = false;
+		bool bShowPlayerName = false;
+
+		// Some entities we always want to check, cause the text may change
+		// even while we're looking at it
+		// Is it a player?
+		if ( IsPlayerIndex( iEntIndex ) )
+		{
+			if ( !pPlayer )
+			{
+				// This can happen because the object was destroyed
+				sIDString[0] = 0;
+				m_iLastEntIndex = 0;
+			}
+			else
+			{
+				c = GetColorForTargetTeam( pPlayer->GetTeamNumber() );
+
+				bShowPlayerName = true;
+ 				g_pVGuiLocalize->ConvertANSIToUnicode( pPlayer->GetPlayerName(), wszPlayerName, sizeof(wszPlayerName) );
+
+				C_CS_PlayerResource *cs_PR = dynamic_cast<C_CS_PlayerResource *>( g_PR );
+
+				char szClan[MAX_PLAYER_NAME_LENGTH];
+				if ( cs_PR && Q_strlen( cs_PR->GetClanTag( iEntIndex ) ) > 1 )
+				{
+					Q_snprintf( szClan, sizeof( szClan ), "%s ", cs_PR->GetClanTag( iEntIndex ) );
+				}
+				else
+				{
+					szClan[ 0 ] = 0;
+				}
+				g_pVGuiLocalize->ConvertANSIToUnicode( szClan, wszClanTag, sizeof( wszClanTag ) );
+				
+				if ( pPlayer->InSameTeam(pLocalPlayer) )
+				{
+					printFormatString = "#Cstrike_playerid_sameteam";
+					bShowHealth = true;
+				}
+				else if ( pLocalPlayer->GetTeamNumber() != TEAM_CT && pLocalPlayer->GetTeamNumber() != TEAM_TERRORIST )
+				{
+					printFormatString = "#Cstrike_playerid_noteam";
+					bShowHealth = true;
+				}
+				else
+				{
+					printFormatString = "#Cstrike_playerid_diffteam";
+				}
+
+				if ( bShowHealth )
+				{
+					_snwprintf( wszHealthText, ARRAYSIZE(wszHealthText) - 1, L"%.0f%%",  ((float)pPlayer->GetHealth() / (float)pPlayer->GetMaxHealth() ) * 100 );
+					wszHealthText[ ARRAYSIZE(wszHealthText)-1 ] = '\0';
+				}
+			}
+		}
+		else
+		{
+			C_BaseEntity *pEnt = cl_entitylist->GetEnt( iEntIndex );
+
+			//Hostages!
+
+			//"Hostage : Health 100%"
+
+			/*
+			if( long range )
+			{
+				m_flDisplayHistory |= DHF_HOSTAGE_SEEN_FAR;
+				switch ( pLocalPlayer->GetTeamNumber() )
+				{
+				case TERRORIST:
+					HintMessage( "#Hint_prevent_hostage_rescue", TRUE );
+					break;
+
+				case CT:
+					HintMessage( "#Hint_rescue_the_hostages", TRUE );
+					break;
+				}
+			}
+			else
+			{
+					m_flDisplayHistory |= DHF_HOSTAGE_SEEN_NEAR;
+					m_flDisplayHistory |= DHF_HOSTAGE_SEEN_FAR;		// Don't want the other msg to appear now
+					HintMessage( "#Hint_press_use_so_hostage_will_follow", FALSE );
+			}
+			*/
+
+			C_CHostage *pHostage = NULL;
+
+			for( int i=0;i<g_Hostages.Count();i++ )
+			{
+				// compare entity pointers			
+				if( g_Hostages[i] == pEnt )
+				{
+					pHostage = g_Hostages[i];
+					break;
+				}
+			}
+
+			if( pHostage != NULL )
+			{
+				c = m_cHostageColor;
+				printFormatString = "#Cstrike_playerid_hostage";
+				_snwprintf( wszHealthText, ARRAYSIZE(wszHealthText) - 1, L"%.0f%%",  ((float)pHostage->GetHealth() / (float)pHostage->GetMaxHealth() ) * 100 );
+				wszHealthText[ ARRAYSIZE(wszHealthText)-1 ] = '\0';
+				bShowHealth = true;
+			}
+			else if ( !pEnt || !pEnt->InSameTeam(pLocalPlayer) )
+			{
+				// This can happen because the object was destroyed
+				sIDString[0] = 0;
+				m_iLastEntIndex = 0;
+			}
+			else
+			{
+				// Don't check validity if it's sent by the server
+				c = m_cHostageColor;
+				g_pVGuiLocalize->ConvertANSIToUnicode( pEnt->GetIDString(), sIDString, sizeof(sIDString) );
+				m_iLastEntIndex = iEntIndex;
+			}
+		}
+
+		if ( printFormatString )
+		{
+			if ( bShowPlayerName && bShowHealth )
+			{
+				g_pVGuiLocalize->ConstructString( sIDString, sizeof(sIDString), g_pVGuiLocalize->Find(printFormatString), 3, wszClanTag, wszPlayerName, wszHealthText );
+			}
+			else if ( bShowPlayerName )
+			{
+				g_pVGuiLocalize->ConstructString( sIDString, sizeof(sIDString), g_pVGuiLocalize->Find(printFormatString), 2, wszClanTag, wszPlayerName );
+			}
+			else if ( bShowHealth )
+			{
+				g_pVGuiLocalize->ConstructString( sIDString, sizeof(sIDString), g_pVGuiLocalize->Find(printFormatString), 1, wszHealthText );
+			}
+			else
+			{
+				g_pVGuiLocalize->ConstructString( sIDString, sizeof(sIDString), g_pVGuiLocalize->Find(printFormatString), 0 );
+			}
+		}
+
+		if ( sIDString[0] )
+		{
+			C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+			bool bObserverMode = pPlayer && pPlayer->IsObserver();
+
+			int wide, tall;
+			vgui::surface()->GetTextSize( m_hFont, sIDString, wide, tall );
+
+			int ypos;
+			int xpos;
+
+			switch ( hud_showtargetpos.GetInt() )
+			{
+			case 0: // center
+			default:
+				xpos = (ScreenWidth() - wide) / 2;
+				ypos = YRES(260) - tall / 2;
+				break;
+			case 1: // upper left
+				xpos = XRES(10);
+				ypos = bObserverMode ? YRES(55) : YRES(5);
+				break;
+			case 2: // upper right
+				xpos = XRES(630) - wide;
+				ypos = bObserverMode ? YRES(55) : YRES(5);
+				break;
+			case 3: // lower left
+				xpos = XRES(10);
+				ypos = bObserverMode ? YRES(415) : YRES(445) - tall;
+				break;
+			case 4: // lower right
+				xpos = XRES(630) - wide;
+				ypos = bObserverMode ? YRES(415) : YRES(410) - tall;
+				break;
+			}
+
+			vgui::surface()->DrawSetTextFont( m_hFont );
+			vgui::surface()->DrawSetTextPos( xpos, ypos );
+			vgui::surface()->DrawSetTextColor( c );
+			vgui::surface()->DrawPrintText( sIDString, wcslen(sIDString) );
+		}
+	}
+}
diff --git a/game/client/cstrike/cs_hud_weaponselection.cpp b/game/client/cstrike/cs_hud_weaponselection.cpp
new file mode 100644
index 00000000..bf8f0064
--- /dev/null
+++ b/game/client/cstrike/cs_hud_weaponselection.cpp
@@ -0,0 +1,845 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_selection.h"
+#include "iclientmode.h"
+#include "history_resource.h"
+#include "iinput.h"
+#include "cs_gamerules.h"
+
+#include <KeyValues.h>
+#include <vgui/IScheme.h>
+#include <vgui/ISurface.h>
+#include <vgui/ISystem.h>
+#include <vgui_controls/AnimationController.h>
+#include <vgui_controls/Panel.h>
+
+#include "vgui/ILocalize.h"
+
+#include <string.h>
+
+//-----------------------------------------------------------------------------
+// Purpose: cstrike weapon selection hud element
+//-----------------------------------------------------------------------------
+class CHudWeaponSelection : public CBaseHudWeaponSelection, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudWeaponSelection, vgui::Panel );
+
+public:
+	CHudWeaponSelection(const char *pElementName );
+
+	virtual bool ShouldDraw();
+	virtual void OnWeaponPickup( C_BaseCombatWeapon *pWeapon );
+
+	virtual void CycleToNextWeapon( void );
+	virtual void CycleToPrevWeapon( void );
+	virtual void SwitchToLastWeapon( void );
+
+	virtual C_BaseCombatWeapon *GetWeaponInSlot( int iSlot, int iSlotPos );
+	virtual void SelectWeaponSlot( int iSlot );
+	virtual void SelectWeapon( void );
+
+	virtual C_BaseCombatWeapon	*GetSelectedWeapon( void )
+	{ 
+		return m_hSelectedWeapon;
+	}
+
+	virtual void OpenSelection( void );
+	virtual void HideSelection( void );
+
+	virtual void CancelWeaponSelection( void );
+
+	virtual void LevelInit();
+
+protected:
+	virtual void OnThink();
+	virtual void Paint();
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+
+	virtual bool IsWeaponSelectable()
+	{ 
+		if (IsInSelectionMode())
+			return true;
+
+		return false;
+	}
+
+	virtual bool IsHudMenuTakingInput();
+	virtual bool IsHudMenuPreventingWeaponSelection();
+
+private:
+	C_BaseCombatWeapon *FindNextWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition);
+	C_BaseCombatWeapon *FindPrevWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition);
+
+	virtual	void SetSelectedWeapon( C_BaseCombatWeapon *pWeapon ) 
+	{ 
+		m_hSelectedWeapon = pWeapon;
+	}
+
+	void DrawBox(int x, int y, int wide, int tall, Color color, float normalizedAlpha, int number);
+
+	CPanelAnimationVar( vgui::HFont, m_hNumberFont, "NumberFont", "HudSelectionNumbers" );
+	CPanelAnimationVar( vgui::HFont, m_hTextFont, "TextFont", "HudSelectionText" );
+
+	CPanelAnimationVarAliasType( float, m_flSmallBoxSize, "SmallBoxSize", "32", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flLargeBoxWide, "LargeBoxWide", "108", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flLargeBoxTall, "LargeBoxTall", "72", "proportional_float" );
+
+	CPanelAnimationVarAliasType( float, m_flBoxGap, "BoxGap", "12", "proportional_float" );
+
+	CPanelAnimationVarAliasType( float, m_flSelectionNumberXPos, "SelectionNumberXPos", "4", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flSelectionNumberYPos, "SelectionNumberYPos", "4", "proportional_float" );
+
+	CPanelAnimationVarAliasType( float, m_flIconXPos, "IconXPos", "16", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flIconYPos, "IconYPos", "8", "proportional_float" );
+
+	CPanelAnimationVarAliasType( float, m_flTextYPos, "TextYPos", "54", "proportional_float" );
+
+	CPanelAnimationVar( float, m_flAlphaOverride, "Alpha", "255" );
+	CPanelAnimationVar( float, m_flSelectionAlphaOverride, "SelectionAlpha", "255" );
+
+
+	CPanelAnimationVar( Color, m_TextColor, "TextColor", "SelectionTextFg" );
+	CPanelAnimationVar( Color, m_NumberColor, "NumberColor", "SelectionNumberFg" );
+	CPanelAnimationVar( Color, m_EmptyBoxColor, "EmptyBoxColor", "SelectionEmptyBoxBg" );
+	CPanelAnimationVar( Color, m_BoxColor, "BoxColor", "SelectionBoxBg" );
+	CPanelAnimationVar( Color, m_SelectedBoxColor, "SelectedBoxClor", "SelectionSelectedBoxBg" );
+
+	CPanelAnimationVar( float, m_flWeaponPickupGrowTime, "SelectionGrowTime", "0.1" );
+
+	CPanelAnimationVar( float, m_flTextScan, "TextScan", "1.0" );
+
+	CPanelAnimationVar( int, m_iMaxSlots, "MaxSlots", "6" );
+	CPanelAnimationVar( bool, m_bPlaySelectionSounds, "PlaySelectSounds", "1" );
+};
+
+DECLARE_HUDELEMENT( CHudWeaponSelection );
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CHudWeaponSelection::CHudWeaponSelection( const char *pElementName ) : CBaseHudWeaponSelection(pElementName), BaseClass(NULL, "HudWeaponSelection")
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetHiddenBits( HIDEHUD_WEAPONSELECTION | HIDEHUD_PLAYERDEAD );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: sets up display for showing weapon pickup
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::OnWeaponPickup( C_BaseCombatWeapon *pWeapon )
+{
+	// add to pickup history
+	CHudHistoryResource *pHudHR = GET_HUDELEMENT( CHudHistoryResource );
+	if ( pHudHR )
+	{
+		pHudHR->AddToHistory( pWeapon );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: updates animation status
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::OnThink()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns true if the CHudMenu should take slot1, etc commands
+//-----------------------------------------------------------------------------
+bool CHudWeaponSelection::IsHudMenuTakingInput()
+{
+	return CBaseHudWeaponSelection::IsHudMenuTakingInput();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns true if the weapon selection hud should be hidden because
+//          the CHudMenu is open
+//-----------------------------------------------------------------------------
+bool CHudWeaponSelection::IsHudMenuPreventingWeaponSelection()
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns true if the panel should draw
+//-----------------------------------------------------------------------------
+bool CHudWeaponSelection::ShouldDraw()
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+	{
+		if ( IsInSelectionMode() )
+		{
+			HideSelection();
+		}
+		return false;
+	}
+
+	bool bret = CBaseHudWeaponSelection::ShouldDraw();
+	if ( !bret )
+		return false;
+
+	return ( m_bSelectionVisible ) ? true : false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::LevelInit()
+{
+	CHudElement::LevelInit();
+	
+	m_iMaxSlots = clamp( m_iMaxSlots, 0, MAX_WEAPON_SLOTS );
+}
+
+//-------------------------------------------------------------------------
+// Purpose: draws the selection area
+//-------------------------------------------------------------------------
+void CHudWeaponSelection::Paint()
+{
+	if (!ShouldDraw())
+		return;
+
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	// find and display our current selection
+	C_BaseCombatWeapon *pSelectedWeapon = GetSelectedWeapon();
+	if ( !pSelectedWeapon )
+		return;
+
+	int iActiveSlot = (pSelectedWeapon ? pSelectedWeapon->GetSlot() : -1);
+
+	// interpolate the selected box size between the small box size and the large box size
+	// interpolation has been removed since there is no weapon pickup animation anymore, so it's all at the largest size
+	float percentageDone = 1.0f; //min(1.0f, (gpGlobals->curtime - m_flPickupStartTime) / m_flWeaponPickupGrowTime);
+	int largeBoxWide = m_flSmallBoxSize + ((m_flLargeBoxWide - m_flSmallBoxSize) * percentageDone);
+	int largeBoxTall = m_flSmallBoxSize + ((m_flLargeBoxTall - m_flSmallBoxSize) * percentageDone);
+	Color selectedColor;
+	{for (int i = 0; i < 4; i++)
+	{
+		selectedColor[i] = m_BoxColor[i] + ((m_SelectedBoxColor[i] - m_BoxColor[i]) * percentageDone);
+	}}
+
+	// calculate where to start drawing
+	int width = (m_iMaxSlots - 1) * (m_flSmallBoxSize + m_flBoxGap) + largeBoxWide;
+	int xpos = (GetWide() - width) / 2;
+	int ypos = 0;
+
+	// iterate over all the weapon slots
+	for ( int i = 0; i < m_iMaxSlots; i++ )
+	{
+		if ( i == iActiveSlot )
+		{
+			bool bFirstItem = true;
+			for (int slotpos = 0; slotpos < MAX_WEAPON_POSITIONS; slotpos++)
+			{
+				C_BaseCombatWeapon *pWeapon = GetWeaponInSlot(i, slotpos);
+				if ( !pWeapon )
+					continue;
+
+				// draw selected weapon
+				DrawBox(xpos, ypos, largeBoxWide, largeBoxTall, selectedColor, m_flSelectionAlphaOverride, bFirstItem ? i + 1 : -1);
+
+				// draw icon
+				Color col = GetFgColor();
+				// icons use old system, drawing in screen space
+				if ( pWeapon->GetSpriteActive() )
+				{
+					if (!pWeapon->CanBeSelected())
+					{
+						// unselectable weapon, display as such
+						col = Color(255, 0, 0, col[3]);
+					}
+					else if (pWeapon == pSelectedWeapon)
+					{
+						// currently selected weapon, display brighter
+						col[3] = m_flSelectionAlphaOverride;
+					}
+					pWeapon->GetSpriteActive()->DrawSelf( xpos + m_flIconXPos, ypos + m_flIconYPos, col );
+				}
+
+				// draw text
+				col = m_TextColor;
+				const FileWeaponInfo_t &weaponInfo = pWeapon->GetWpnData();
+
+				if (pWeapon == pSelectedWeapon)
+				{
+					wchar_t text[128];
+					wchar_t *tempString = g_pVGuiLocalize->Find(weaponInfo.szPrintName);
+
+					// setup our localized string
+					if ( tempString )
+					{
+#ifdef WIN32
+						_snwprintf(text, sizeof(text)/sizeof(wchar_t) - 1, L"%s", tempString);
+#else
+						_snwprintf(text, sizeof(text)/sizeof(wchar_t) - 1, L"%S", tempString);
+#endif
+						text[sizeof(text)/sizeof(wchar_t) - 1] = 0;
+					}
+					else
+					{
+						// string wasn't found by g_pVGuiLocalize->Find()
+						g_pVGuiLocalize->ConvertANSIToUnicode(weaponInfo.szPrintName, text, sizeof(text));
+					}
+					
+					surface()->DrawSetTextColor( col );
+					surface()->DrawSetTextFont( m_hTextFont );
+
+					// count the position
+					int slen = 0, charCount = 0, maxslen = 0;
+					{
+						for (wchar_t *pch = text; *pch != 0; pch++)
+						{
+							if (*pch == '\n') 
+							{
+								// newline character, drop to the next line
+								if (slen > maxslen)
+								{
+									maxslen = slen;
+								}
+								slen = 0;
+							}
+							else if (*pch == '\r')
+							{
+								// do nothing
+							}
+							else
+							{
+								slen += surface()->GetCharacterWidth( m_hTextFont, *pch );
+								charCount++;
+							}
+						}
+					}
+					if (slen > maxslen)
+					{
+						maxslen = slen;
+					}
+
+					int tx = xpos + ((largeBoxWide - maxslen) / 2);
+					int ty = ypos + (int)m_flTextYPos;
+					surface()->DrawSetTextPos( tx, ty );
+					// adjust the charCount by the scan amount
+					charCount *= m_flTextScan;
+					for (wchar_t *pch = text; charCount > 0; pch++)
+					{
+						if (*pch == '\n')
+						{
+							// newline character, move to the next line
+							surface()->DrawSetTextPos( xpos + ((largeBoxWide - slen) / 2), ty + (surface()->GetFontTall(m_hTextFont) * 1.1f));
+						}
+						else if (*pch == '\r')
+						{
+							// do nothing
+						}
+						else
+						{
+							surface()->DrawUnicodeChar(*pch);
+							charCount--;
+						}
+					}
+				}
+
+				ypos += (largeBoxTall + m_flBoxGap);
+				bFirstItem = false;
+			}
+
+			xpos += largeBoxWide;
+		}
+		else
+		{
+			// check to see if there is a weapons in this bucket
+			if ( GetFirstPos( i ) )
+			{
+				// draw has weapon in slot
+				DrawBox(xpos, ypos, m_flSmallBoxSize, m_flSmallBoxSize, m_BoxColor, m_flAlphaOverride, i + 1);
+			}
+			else
+			{
+				// draw empty slot
+				DrawBox(xpos, ypos, m_flSmallBoxSize, m_flSmallBoxSize, m_EmptyBoxColor, m_flAlphaOverride, -1);
+			}
+
+			xpos += m_flSmallBoxSize;
+		}
+
+		// reset position
+		ypos = 0;
+		xpos += m_flBoxGap;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: draws a selection box
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::DrawBox(int x, int y, int wide, int tall, Color color, float normalizedAlpha, int number)
+{
+	BaseClass::DrawBox( x, y, wide, tall, color, normalizedAlpha / 255.0f );
+
+	// draw the number
+	if (number >= 0)
+	{
+		Color numberColor = m_NumberColor;
+		numberColor[3] *= normalizedAlpha / 255.0f;
+		surface()->DrawSetTextColor(numberColor);
+		surface()->DrawSetTextFont(m_hNumberFont);
+		wchar_t wch = '0' + number;
+		surface()->DrawSetTextPos(x + m_flSelectionNumberXPos, y + m_flSelectionNumberYPos);
+		surface()->DrawUnicodeChar(wch);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: hud scheme settings
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+	SetPaintBackgroundEnabled(false);
+
+	// set our size
+	int screenWide, screenTall;
+	int x, y;
+	GetPos(x, y);
+	GetHudSize(screenWide, screenTall);
+	SetBounds(0, y, screenWide, screenTall - y);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Opens weapon selection control
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::OpenSelection( void )
+{
+	Assert(!IsInSelectionMode());
+
+	CBaseHudWeaponSelection::OpenSelection();
+	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("OpenWeaponSelectionMenu");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Closes weapon selection control
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::HideSelection( void )
+{
+	CBaseHudWeaponSelection::HideSelection();
+	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("CloseWeaponSelectionMenu");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the next available weapon item in the weapon selection
+//-----------------------------------------------------------------------------
+C_BaseCombatWeapon *CHudWeaponSelection::FindNextWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition)
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return NULL;
+
+	C_BaseCombatWeapon *pNextWeapon = NULL;
+
+	// search all the weapons looking for the closest next
+	int iLowestNextSlot = MAX_WEAPON_SLOTS;
+	int iLowestNextPosition = MAX_WEAPON_POSITIONS;
+	for ( int i = 0; i < MAX_WEAPONS; i++ )
+	{
+		C_BaseCombatWeapon *pWeapon = pPlayer->GetWeapon(i);
+		if ( !pWeapon )
+			continue;
+
+		if ( pWeapon->CanBeSelected() )
+		{
+			int weaponSlot = pWeapon->GetSlot(), weaponPosition = pWeapon->GetPosition();
+
+			// see if this weapon is further ahead in the selection list
+			if ( weaponSlot > iCurrentSlot || (weaponSlot == iCurrentSlot && weaponPosition > iCurrentPosition) )
+			{
+				// see if this weapon is closer than the current lowest
+				if ( weaponSlot < iLowestNextSlot || (weaponSlot == iLowestNextSlot && weaponPosition < iLowestNextPosition) )
+				{
+					iLowestNextSlot = weaponSlot;
+					iLowestNextPosition = weaponPosition;
+					pNextWeapon = pWeapon;
+				}
+			}
+		}
+	}
+
+	return pNextWeapon;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the prior available weapon item in the weapon selection
+//-----------------------------------------------------------------------------
+C_BaseCombatWeapon *CHudWeaponSelection::FindPrevWeaponInWeaponSelection(int iCurrentSlot, int iCurrentPosition)
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return NULL;
+
+	C_BaseCombatWeapon *pPrevWeapon = NULL;
+
+	// search all the weapons looking for the closest next
+	int iLowestPrevSlot = -1;
+	int iLowestPrevPosition = -1;
+	for ( int i = 0; i < MAX_WEAPONS; i++ )
+	{
+		C_BaseCombatWeapon *pWeapon = pPlayer->GetWeapon(i);
+		if ( !pWeapon )
+			continue;
+
+		if ( pWeapon->CanBeSelected() )
+		{
+			int weaponSlot = pWeapon->GetSlot(), weaponPosition = pWeapon->GetPosition();
+
+			// see if this weapon is further ahead in the selection list
+			if ( weaponSlot < iCurrentSlot || (weaponSlot == iCurrentSlot && weaponPosition < iCurrentPosition) )
+			{
+				// see if this weapon is closer than the current lowest
+				if ( weaponSlot > iLowestPrevSlot || (weaponSlot == iLowestPrevSlot && weaponPosition > iLowestPrevPosition) )
+				{
+					iLowestPrevSlot = weaponSlot;
+					iLowestPrevPosition = weaponPosition;
+					pPrevWeapon = pWeapon;
+				}
+			}
+		}
+	}
+
+	return pPrevWeapon;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Moves the selection to the next item in the menu
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::CycleToNextWeapon( void )
+{
+	// Get the local player.
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	C_BaseCombatWeapon *pNextWeapon = NULL;
+	if ( IsInSelectionMode() )
+	{
+		// find the next selection spot
+		C_BaseCombatWeapon *pWeapon = GetSelectedWeapon();
+		if ( !pWeapon )
+			return;
+
+		pNextWeapon = FindNextWeaponInWeaponSelection( pWeapon->GetSlot(), pWeapon->GetPosition() );
+	}
+	else
+	{
+		// open selection at the current place
+		pNextWeapon = pPlayer->GetActiveWeapon();
+		if ( pNextWeapon )
+		{
+			pNextWeapon = FindNextWeaponInWeaponSelection( pNextWeapon->GetSlot(), pNextWeapon->GetPosition() );
+		}
+	}
+
+	if ( !pNextWeapon )
+	{
+		// wrap around back to start
+		pNextWeapon = FindNextWeaponInWeaponSelection(-1, -1);
+	}
+
+	if ( pNextWeapon )
+	{
+		SetSelectedWeapon( pNextWeapon );
+
+		if( hud_fastswitch.GetInt() > 0 )
+		{
+			SelectWeapon();
+		}
+		else if ( !IsInSelectionMode() )
+		{
+			OpenSelection();
+		}
+
+		// Play the "cycle to next weapon" sound
+		if( m_bPlaySelectionSounds )
+			pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Moves the selection to the previous item in the menu
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::CycleToPrevWeapon( void )
+{
+	// Get the local player.
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	if ( pPlayer->IsPlayerDead() )
+		return;
+
+	C_BaseCombatWeapon *pNextWeapon = NULL;
+	if ( IsInSelectionMode() )
+	{
+		// find the next selection spot
+		C_BaseCombatWeapon *pWeapon = GetSelectedWeapon();
+		if ( !pWeapon )
+			return;
+
+		pNextWeapon = FindPrevWeaponInWeaponSelection( pWeapon->GetSlot(), pWeapon->GetPosition() );
+	}
+	else
+	{
+		// open selection at the current place
+		pNextWeapon = pPlayer->GetActiveWeapon();
+		if ( pNextWeapon )
+		{
+			pNextWeapon = FindPrevWeaponInWeaponSelection( pNextWeapon->GetSlot(), pNextWeapon->GetPosition() );
+		}
+	}
+
+	if ( !pNextWeapon )
+	{
+		// wrap around back to end of weapon list
+		pNextWeapon = FindPrevWeaponInWeaponSelection(MAX_WEAPON_SLOTS, MAX_WEAPON_POSITIONS);
+	}
+
+	if ( pNextWeapon )
+	{
+		SetSelectedWeapon( pNextWeapon );
+
+		if( hud_fastswitch.GetInt() > 0 )
+		{
+			SelectWeapon();
+		}
+		else if ( !IsInSelectionMode() )
+		{
+			OpenSelection();
+		}
+
+		// Play the "cycle to next weapon" sound
+		if( m_bPlaySelectionSounds )
+			pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Switches the last weapon the player was using
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::SwitchToLastWeapon( void )
+{
+	// Get the player's last weapon
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+
+	if ( player->IsPlayerDead() )
+		return;
+
+	C_BaseCombatWeapon *lastWeapon = player->GetLastWeapon();
+	C_BaseCombatWeapon *activeWeapon = player->GetActiveWeapon();
+
+	if ( lastWeapon == activeWeapon )
+		lastWeapon = NULL;
+
+	// make sure our last weapon is still with us and valid (has ammo etc)
+	if ( lastWeapon )
+	{
+		int i;
+		for ( i = 0; i < MAX_WEAPONS; i++ )
+		{
+			C_BaseCombatWeapon *weapon = player->GetWeapon(i);
+			
+			if ( !weapon  || !weapon->CanBeSelected() )
+				continue;
+
+			if (weapon == lastWeapon )
+				break;
+		}
+
+		if ( i == MAX_WEAPONS )
+			lastWeapon = NULL; // weapon not found/valid
+	}
+
+	// if we don't have a 'last weapon' choose best weapon
+	if ( !lastWeapon )
+	{
+		lastWeapon = GameRules()->GetNextBestWeapon( player, activeWeapon );
+	}
+
+	::input->MakeWeaponSelection( lastWeapon );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns the weapon in the specified slot
+//-----------------------------------------------------------------------------
+C_BaseCombatWeapon *CHudWeaponSelection::GetWeaponInSlot( int iSlot, int iSlotPos )
+{
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( !player )
+		return NULL;
+
+	if ( player->IsPlayerDead() )
+		return NULL;
+
+	for ( int i = 0; i < MAX_WEAPONS; i++ )
+	{
+		C_BaseCombatWeapon *pWeapon = player->GetWeapon(i);
+		
+		if ( pWeapon == NULL )
+			continue;
+
+		if ( pWeapon->GetSlot() == iSlot && pWeapon->GetPosition() == iSlotPos )
+			return pWeapon;
+	}
+
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Player has chosen to draw the currently selected weapon
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::SelectWeapon( void )
+{
+	if ( !GetSelectedWeapon() )
+	{
+		engine->ClientCmd( "cancelselect\n" );
+		return;
+	}
+
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+
+	C_BaseCombatWeapon *activeWeapon = player->GetActiveWeapon();
+
+	// Don't allow selections of weapons that can't be selected (out of ammo, etc)
+	if ( !GetSelectedWeapon()->CanBeSelected() )
+	{
+		player->EmitSound( "Player.DenyWeaponSelection" );
+	}
+	else
+	{
+		// Only play the "weapon selected" sound if they are selecting
+		// a weapon different than the one that is already active.
+		if (GetSelectedWeapon() != activeWeapon)
+		{
+			// Play the "weapon selected" sound
+			player->EmitSound( "Player.WeaponSelected" );
+		}
+
+		SetWeaponSelected();
+	
+		m_hSelectedWeapon = NULL;
+	
+		engine->ClientCmd( "cancelselect\n" );
+
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Abort selecting a weapon
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::CancelWeaponSelection()
+{
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+
+	// Fastswitches happen in a single frame, so the Weapon Selection HUD Element isn't visible
+	// yet, but it's going to be next frame. We need to ask it if it thinks it's going to draw,
+	// instead of checking it's IsActive flag.
+	if ( ShouldDraw() )
+	{
+		HideSelection();
+
+		m_hSelectedWeapon = NULL;
+	}
+	else
+	{
+		engine->ClientCmd("escape");
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Moves selection to the specified slot
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::SelectWeaponSlot( int iSlot )
+{
+	// iSlot is one higher than it should be, since it's the number key, not the 0-based index into the weapons
+	--iSlot;
+
+	// Get the local player.
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	// Don't try and read past our possible number of slots
+	if ( iSlot > MAX_WEAPON_SLOTS )
+		return;
+	
+	// Make sure the player's allowed to switch weapons
+	if ( pPlayer->IsAllowedToSwitchWeapons() == false )
+		return;
+
+	int slotPos = 0;
+	C_BaseCombatWeapon *pActiveWeapon = GetSelectedWeapon();
+
+	// start later in the list
+	if ( IsInSelectionMode() && pActiveWeapon && pActiveWeapon->GetSlot() == iSlot )
+	{
+		slotPos = pActiveWeapon->GetPosition() + 1;
+	}
+
+	// find the weapon in this slot
+	pActiveWeapon = GetNextActivePos( iSlot, slotPos );
+	if ( !pActiveWeapon )
+	{
+		pActiveWeapon = GetNextActivePos( iSlot, 0 );
+	}
+	
+	if ( pActiveWeapon != NULL )
+	{
+		// Mark the change
+		SetSelectedWeapon( pActiveWeapon );
+
+		bool bMultipleWeaponsInSlot = false;
+
+		for( int i=0;i<MAX_WEAPON_POSITIONS;i++ )
+		{
+			C_BaseCombatWeapon *pSlotWpn = GetWeaponInSlot( pActiveWeapon->GetSlot(), i );
+
+			if( pSlotWpn != NULL && pSlotWpn != pActiveWeapon )
+			{
+				bMultipleWeaponsInSlot = true;
+				break;
+			}
+		}
+
+		// if fast weapon switch is on, then weapons can be selected in a single keypress
+		// but only if there is only one item in the bucket
+		if( hud_fastswitch.GetInt() > 0 && bMultipleWeaponsInSlot == false )
+		{
+			// only one active item in bucket, so change directly to weapon
+			SelectWeapon();
+		}
+		else if ( !IsInSelectionMode() )
+		{
+			// open the weapon selection
+			OpenSelection();
+		}
+	}
+
+	if( m_bPlaySelectionSounds )
+			pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
+}
diff --git a/game/client/cstrike/cs_in_main.cpp b/game/client/cstrike/cs_in_main.cpp
new file mode 100644
index 00000000..29a2b70b
--- /dev/null
+++ b/game/client/cstrike/cs_in_main.cpp
@@ -0,0 +1,23 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: TF2 specific input handling
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "kbutton.h"
+#include "input.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: TF Input interface
+//-----------------------------------------------------------------------------
+class CCSInput : public CInput
+{
+public:
+};
+
+static CCSInput g_Input;
+
+// Expose this interface
+IInput *input = ( IInput * )&g_Input;
+
diff --git a/game/client/cstrike/cs_prediction.cpp b/game/client/cstrike/cs_prediction.cpp
new file mode 100644
index 00000000..32cf88c9
--- /dev/null
+++ b/game/client/cstrike/cs_prediction.cpp
@@ -0,0 +1,55 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "prediction.h"
+#include "c_cs_player.h"
+#include "igamemovement.h"
+
+
+static CMoveData g_MoveData;
+CMoveData *g_pMoveData = &g_MoveData;
+
+
+class CCSPrediction : public CPrediction
+{
+DECLARE_CLASS( CCSPrediction, CPrediction );
+
+public:
+	virtual void	SetupMove( C_BasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
+	virtual void	FinishMove( C_BasePlayer *player, CUserCmd *ucmd, CMoveData *move );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSPrediction::SetupMove( C_BasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, 
+	CMoveData *move )
+{
+	player->AvoidPhysicsProps( ucmd );
+
+	// Call the default SetupMove code.
+	BaseClass::SetupMove( player, ucmd, pHelper, move );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSPrediction::FinishMove( C_BasePlayer *player, CUserCmd *ucmd, CMoveData *move )
+{
+	// Call the default FinishMove code.
+	BaseClass::FinishMove( player, ucmd, move );
+}
+
+
+// Expose interface to engine
+// Expose interface to engine
+static CCSPrediction g_Prediction;
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CCSPrediction, IPrediction, VCLIENT_PREDICTION_INTERFACE_VERSION, g_Prediction );
+
+CPrediction *prediction = &g_Prediction;
+
diff --git a/game/client/cstrike/cs_replay.cpp b/game/client/cstrike/cs_replay.cpp
new file mode 100644
index 00000000..f977e73a
--- /dev/null
+++ b/game/client/cstrike/cs_replay.cpp
@@ -0,0 +1,227 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+//=======================================================================================//
+
+#include "cbase.h"
+
+#if defined( REPLAY_ENABLED )
+
+#include "cs_replay.h"
+#include "c_cs_player.h"
+#include "cs_gamestats_shared.h"
+#include "cs_client_gamestats.h"
+#include "clientmode_shared.h"
+#include "replay/ireplaymoviemanager.h"
+#include "replay/ireplayfactory.h"
+#include "replay/ireplayscreenshotmanager.h"
+#include "replay/screenshot.h"
+#include <time.h>
+
+//----------------------------------------------------------------------------------------
+
+extern IReplayScreenshotManager *g_pReplayScreenshotManager;
+
+//----------------------------------------------------------------------------------------
+
+CCSReplay::CCSReplay()
+{
+}
+
+CCSReplay::~CCSReplay()
+{
+}
+
+void CCSReplay::OnBeginRecording()
+{
+	BaseClass::OnBeginRecording();
+
+	// Setup the newly created replay
+	C_CSPlayer* pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer )
+	{
+		SetPlayerClass( pPlayer->PlayerClass() );
+		SetPlayerTeam( pPlayer->GetTeamNumber() );
+	}
+}
+
+void CCSReplay::OnEndRecording()
+{
+	if ( gameeventmanager )
+	{
+		gameeventmanager->RemoveListener( this );
+	}
+
+	BaseClass::OnEndRecording();
+}
+
+void CCSReplay::OnComplete()
+{
+	BaseClass::OnComplete();
+}
+
+void CCSReplay::Update()
+{
+	BaseClass::Update();
+}
+
+float CCSReplay::GetSentryKillScreenshotDelay()
+{
+	ConVarRef replay_screenshotsentrykilldelay( "replay_screenshotsentrykilldelay" );
+	return replay_screenshotsentrykilldelay.IsValid() ? replay_screenshotsentrykilldelay.GetFloat() : 0.5f;
+}
+
+void CCSReplay::FireGameEvent( IGameEvent *pEvent )
+{
+	C_CSPlayer *pLocalPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( !pLocalPlayer )
+		return;
+
+	CaptureScreenshotParams_t params;
+	V_memset( &params, 0, sizeof( params ) );
+
+	if ( FStrEq( pEvent->GetName(), "player_death" ) )
+	{
+		ConVarRef replay_debug( "replay_debug" );
+		if ( replay_debug.IsValid() && replay_debug.GetBool() )
+		{
+			DevMsg( "%i: CCSReplay::FireGameEvent(): player_death\n", gpGlobals->tickcount );
+		}
+
+		int nKillerID = pEvent->GetInt( "attacker" );
+		int nVictimID = pEvent->GetInt( "userid" );
+		int nDeathFlags = pEvent->GetInt( "death_flags" );
+
+		const char *pWeaponName = pEvent->GetString( "weapon" );
+
+		// Suicide?
+		bool bSuicide = nKillerID == nVictimID;
+
+		// Try to get killer
+		C_CSPlayer *pKiller = ToCSPlayer( USERID2PLAYER( nKillerID ) );
+
+		// Try to get victim
+		C_CSPlayer *pVictim = ToCSPlayer( USERID2PLAYER( nVictimID ) );
+
+		// Inflictor was a sentry gun?
+		bool bSentry = V_strnicmp( pWeaponName, "obj_sentrygun", 13 ) == 0;
+
+		// Is the killer the local player?
+		if ( nKillerID == pLocalPlayer->GetUserID() &&
+			 !bSuicide &&
+			 !bSentry )
+		{
+			// Domination?
+			if ( nDeathFlags & REPLAY_DEATH_DOMINATION )
+			{
+				AddDomination( nVictimID );
+			}
+
+			// Revenge?
+			if ( pEvent->GetInt( "death_flags" ) & REPLAY_DEATH_REVENGE ) 
+			{
+				AddRevenge( nVictimID );
+			}
+
+			// Add victim info to kill list
+			if ( pVictim )
+			{
+				AddKill( pVictim->GetPlayerName(), pVictim->PlayerClass() );
+			}
+		
+			// Take a quick screenshot with some delay
+			ConVarRef replay_screenshotkilldelay( "replay_screenshotkilldelay" );
+			if ( replay_screenshotkilldelay.IsValid() )
+			{
+				params.m_flDelay = GetKillScreenshotDelay();
+				g_pReplayScreenshotManager->CaptureScreenshot( params );
+			}
+		}
+		
+		// Player death?
+		else if ( pKiller &&
+				  nVictimID == pLocalPlayer->GetUserID() )
+		{
+			// Record who killed the player if not a suicide
+			if ( !bSuicide )
+			{
+				RecordPlayerDeath( pKiller->GetPlayerName(), pKiller->PlayerClass() );
+			}
+
+			// Take screenshot - taking a screenshot during feign death is cool, too.
+			ConVarRef replay_deathcammaxverticaloffset( "replay_deathcammaxverticaloffset" );
+			ConVarRef replay_playerdeathscreenshotdelay( "replay_playerdeathscreenshotdelay" );
+			params.m_flDelay = replay_playerdeathscreenshotdelay.IsValid() ? replay_playerdeathscreenshotdelay.GetFloat() : 0.0f;
+			params.m_nEntity = pLocalPlayer->entindex();
+			params.m_posCamera.Init( 0,0, replay_deathcammaxverticaloffset.IsValid() ? replay_deathcammaxverticaloffset.GetFloat() : 150 );
+			params.m_angCamera.Init( 90, 0, 0 );	// Look straight down
+			params.m_bUseCameraAngles = true;
+			params.m_bIgnoreMinTimeBetweenScreenshots = true;
+			g_pReplayScreenshotManager->CaptureScreenshot( params );
+		}
+	}
+}
+
+bool CCSReplay::IsValidClass( int iClass ) const
+{
+	return ( iClass >= CS_CLASS_NONE && iClass < CS_NUM_CLASSES );
+}
+
+bool CCSReplay::IsValidTeam( int iTeam ) const
+{
+	return ( iTeam == TEAM_TERRORIST || iTeam == TEAM_CT );
+}
+
+bool CCSReplay::GetCurrentStats( RoundStats_t &out )
+{
+	out = g_CSClientGameStats.GetLifetimeStats();
+	return true;
+}
+
+const char *CCSReplay::GetStatString( int iStat ) const
+{
+	return CSStatProperty_Table[ iStat ].szSteamName;
+}
+
+const char *CCSReplay::GetPlayerClass( int iClass ) const
+{
+	Assert( iClass >= CS_CLASS_NONE && iClass < CS_NUM_CLASSES );
+	return GetCSClassInfo( iClass )->m_pClassName;
+}
+
+bool CCSReplay::Read( KeyValues *pIn )
+{
+	return BaseClass::Read( pIn );
+}
+
+void CCSReplay::Write( KeyValues *pOut )
+{
+	BaseClass::Write( pOut );
+}
+
+const char *CCSReplay::GetMaterialFriendlyPlayerClass() const
+{
+	return BaseClass::GetMaterialFriendlyPlayerClass();
+}
+
+void CCSReplay::DumpGameSpecificData() const
+{
+	BaseClass::DumpGameSpecificData();
+}
+
+//----------------------------------------------------------------------------------------
+
+class CCSReplayFactory : public IReplayFactory
+{
+public:
+	virtual CReplay *Create()
+	{
+		 return new CCSReplay();
+	}
+};
+
+static CCSReplayFactory s_ReplayManager;
+IReplayFactory *g_pReplayFactory = &s_ReplayManager;
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CCSReplayFactory, IReplayFactory, INTERFACE_VERSION_REPLAY_FACTORY, s_ReplayManager );
+
+#endif
\ No newline at end of file
diff --git a/game/client/cstrike/cs_replay.h b/game/client/cstrike/cs_replay.h
new file mode 100644
index 00000000..12916b7e
--- /dev/null
+++ b/game/client/cstrike/cs_replay.h
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//=======================================================================================//
+
+#if defined( REPLAY_ENABLED )
+
+#ifndef CS_REPLAY_H
+#define CS_REPLAY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//----------------------------------------------------------------------------------------
+
+#include "replay/genericclassbased_replay.h"
+
+//----------------------------------------------------------------------------------------
+
+class CCSReplay : public CGenericClassBasedReplay
+{
+	typedef CGenericClassBasedReplay BaseClass;
+public:
+	CCSReplay();
+	~CCSReplay();
+
+	virtual void OnBeginRecording();
+	virtual void OnEndRecording();
+	virtual void OnComplete();
+	virtual void FireGameEvent( IGameEvent *pEvent );
+
+	virtual bool Read( KeyValues *pIn );
+	virtual void Write( KeyValues *pOut );
+
+	virtual void DumpGameSpecificData() const;
+
+	virtual const char *GetPlayerClass() const { return GetCSClassInfo( m_nPlayerClass )->m_pClassName; }
+	virtual const char *GetPlayerTeam() const { return m_nPlayerTeam == TEAM_TERRORIST ? "terrorists" : "counterterrorists"; }
+	virtual const char *GetMaterialFriendlyPlayerClass() const;
+
+private:
+	virtual void Update();
+	float GetSentryKillScreenshotDelay();
+
+	virtual bool IsValidClass( int nClass ) const;
+	virtual bool IsValidTeam( int iTeam ) const;
+	virtual bool GetCurrentStats( RoundStats_t &out );
+	virtual const char *GetStatString( int iStat ) const;
+	virtual const char *GetPlayerClass( int iClass ) const;
+};
+
+//----------------------------------------------------------------------------------------
+
+inline CCSReplay *ToCSReplay( CReplay *pClientReplay )
+{
+	return static_cast< CCSReplay * >( pClientReplay );
+}
+
+inline const CCSReplay *ToCSReplay( const CReplay *pClientReplay )
+{
+	return static_cast< const CCSReplay * >( pClientReplay );
+}
+
+inline CCSReplay *GetCSReplay( ReplayHandle_t hReplay )
+{
+	return ToCSReplay( g_pClientReplayContext->GetReplay( hReplay ) );
+}
+
+//----------------------------------------------------------------------------------------
+
+#endif	// CS_REPLAY_H
+
+#endif
\ No newline at end of file
diff --git a/game/client/cstrike/cs_view_scene.cpp b/game/client/cstrike/cs_view_scene.cpp
new file mode 100644
index 00000000..9b02442f
--- /dev/null
+++ b/game/client/cstrike/cs_view_scene.cpp
@@ -0,0 +1,325 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Responsible for drawing the scene
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "view.h"
+#include "iviewrender.h"
+#include "view_shared.h"
+#include "ivieweffects.h"
+#include "iinput.h"
+#include "model_types.h"
+#include "clientsideeffects.h"
+#include "particlemgr.h"
+#include "viewrender.h"
+#include "iclientmode.h"
+#include "voice_status.h"
+#include "radio_status.h"
+#include "glow_overlay.h"
+#include "materialsystem/imesh.h"
+#include "materialsystem/itexture.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialvar.h"
+#include "materialsystem/imaterialsystemhardwareconfig.h"
+#include "detailobjectsystem.h"
+#include "tier0/vprof.h"
+#include "engine/IEngineTrace.h"
+#include "engine/ivmodelinfo.h"
+#include "view_scene.h"
+#include "particles_ez.h"
+#include "engine/IStaticPropMgr.h"
+#include "engine/ivdebugoverlay.h"
+#include "cs_view_scene.h"
+#include "c_cs_player.h"
+#include "cs_gamerules.h"
+#include "shake.h"
+#include "clienteffectprecachesystem.h"
+#include <vgui/ISurface.h>
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheCSViewScene )
+CLIENTEFFECT_MATERIAL( "effects/flashbang" )
+CLIENTEFFECT_MATERIAL( "effects/flashbang_white" )
+CLIENTEFFECT_MATERIAL( "effects/nightvision" )
+CLIENTEFFECT_REGISTER_END()
+
+static CCSViewRender g_ViewRender;
+
+CCSViewRender::CCSViewRender()
+{
+	view = ( IViewRender * )&g_ViewRender;
+	m_pFlashTexture = NULL;
+}
+
+struct ConVarFlags
+{
+	const char *name;
+	int flags;
+};
+
+ConVarFlags s_flaggedConVars[] =
+{
+	{ "r_screenfademinsize", FCVAR_CHEAT },
+	{ "r_screenfademaxsize", FCVAR_CHEAT },
+	{ "developer", FCVAR_CHEAT },
+};
+
+void CCSViewRender::Init( void )
+{
+	for ( int i=0; i<ARRAYSIZE( s_flaggedConVars ); ++i )
+	{
+		ConVar *flaggedConVar = cvar->FindVar( s_flaggedConVars[i].name );
+		if ( flaggedConVar )
+		{
+			flaggedConVar->AddFlags( s_flaggedConVars[i].flags );
+		}
+	}
+
+	CViewRender::Init();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the min/max fade distances
+//-----------------------------------------------------------------------------
+void CCSViewRender::GetScreenFadeDistances( float *min, float *max )
+{
+	if ( min )
+	{
+		*min = 0.0f;
+	}
+
+	if ( max )
+	{
+		*max = 0.0f;
+	}
+}
+
+
+void CCSViewRender::PerformNightVisionEffect( const CViewSetup &view )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( !pPlayer )
+		return;
+
+	if (pPlayer->GetObserverMode() == OBS_MODE_IN_EYE)
+	{
+		CBaseEntity *target = pPlayer->GetObserverTarget();
+		if (target && target->IsPlayer())
+		{
+			pPlayer = (C_CSPlayer *)target;
+		}
+	}
+
+	if ( pPlayer && pPlayer->m_flNightVisionAlpha > 0 )
+	{
+		IMaterial *pMaterial = materials->FindMaterial( "effects/nightvision", TEXTURE_GROUP_CLIENT_EFFECTS, true );
+
+		if ( pMaterial )
+		{
+			int iMaxValue = 255;
+			byte overlaycolor[4] = { 0, 255, 0, 255 };
+			
+			if ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 80 )
+			{
+				UpdateScreenEffectTexture( 0, view.x, view.y, view.width, view.height );
+			}
+			else
+			{
+				// In DX7, use the values CS:goldsrc uses.
+				iMaxValue = 225;
+				overlaycolor[0] = overlaycolor[2] = 50 / 2;
+				overlaycolor[1] = 225 / 2;
+			}
+
+			if ( pPlayer->m_bNightVisionOn )
+			{
+				pPlayer->m_flNightVisionAlpha += 15;
+
+				pPlayer->m_flNightVisionAlpha = MIN( pPlayer->m_flNightVisionAlpha, iMaxValue );
+			}
+			else 
+			{
+				pPlayer->m_flNightVisionAlpha -= 40;
+
+				pPlayer->m_flNightVisionAlpha = MAX( pPlayer->m_flNightVisionAlpha, 0 );
+				
+			}
+
+			overlaycolor[3] = pPlayer->m_flNightVisionAlpha;
+	
+			render->ViewDrawFade( overlaycolor, pMaterial );
+
+			// Only one pass in DX7.
+			if ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 80 )
+			{
+				CMatRenderContextPtr pRenderContext( materials );
+				pRenderContext->DrawScreenSpaceQuad( pMaterial );
+				render->ViewDrawFade( overlaycolor, pMaterial );
+				pRenderContext->DrawScreenSpaceQuad( pMaterial );
+			}
+		}
+	}
+}
+
+
+//Adrian - Super Nifty Flashbang Effect(tm)
+// this does the burn in for the flashbang effect.
+void CCSViewRender::PerformFlashbangEffect( const CViewSetup &view )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( pPlayer == NULL )
+		 return;
+
+	if ( pPlayer->m_flFlashBangTime < gpGlobals->curtime )
+		return;
+	
+	IMaterial *pMaterial = materials->FindMaterial( "effects/flashbang", TEXTURE_GROUP_CLIENT_EFFECTS, true );
+
+	if ( !pMaterial )
+		return;
+
+	byte overlaycolor[4] = { 255, 255, 255, 255 };
+	
+	CMatRenderContextPtr pRenderContext( materials );
+	
+	if ( pPlayer->m_flFlashAlpha < pPlayer->m_flFlashMaxAlpha )
+	{
+		pPlayer->m_flFlashAlpha += 45;
+		
+		pPlayer->m_flFlashAlpha = MIN( pPlayer->m_flFlashAlpha, pPlayer->m_flFlashMaxAlpha );
+
+		overlaycolor[0] = overlaycolor[1] = overlaycolor[2] = pPlayer->m_flFlashAlpha;
+
+		m_pFlashTexture = GetFullFrameFrameBufferTexture( 1 );
+
+		bool foundVar;
+
+		IMaterialVar* m_BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false );
+	
+		Rect_t srcRect;
+		srcRect.x = view.x;
+		srcRect.y = view.y;
+		srcRect.width = view.width;
+		srcRect.height = view.height;
+		m_BaseTextureVar->SetTextureValue( m_pFlashTexture );
+		pRenderContext->CopyRenderTargetToTextureEx( m_pFlashTexture, 0, &srcRect, NULL );
+		pRenderContext->SetFrameBufferCopyTexture( m_pFlashTexture );
+
+		render->ViewDrawFade( overlaycolor, pMaterial );
+
+		// just do one pass for dxlevel < 80.
+		if (g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 80)
+		{
+			pRenderContext->DrawScreenSpaceRectangle( pMaterial, view.x, view.y, view.width, view.height,
+				0, 0, m_pFlashTexture->GetActualWidth()-1, m_pFlashTexture->GetActualHeight()-1, 
+				m_pFlashTexture->GetActualWidth(), m_pFlashTexture->GetActualHeight() );
+			render->ViewDrawFade( overlaycolor, pMaterial );
+			pRenderContext->DrawScreenSpaceRectangle( pMaterial, view.x, view.y, view.width, view.height,
+				0, 0, m_pFlashTexture->GetActualWidth()-1, m_pFlashTexture->GetActualHeight()-1, 
+				m_pFlashTexture->GetActualWidth(), m_pFlashTexture->GetActualHeight() );
+		}
+	}
+	else if ( m_pFlashTexture )
+	{
+		float flAlpha = pPlayer->m_flFlashMaxAlpha * (pPlayer->m_flFlashBangTime - gpGlobals->curtime) / pPlayer->m_flFlashDuration;
+
+		flAlpha = clamp( flAlpha, 0, pPlayer->m_flFlashMaxAlpha );
+		
+		overlaycolor[0] = overlaycolor[1] = overlaycolor[2] = flAlpha;
+
+		render->ViewDrawFade( overlaycolor, pMaterial );
+
+		// just do one pass for dxlevel < 80.
+		if (g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 80)
+		{
+			pRenderContext->DrawScreenSpaceRectangle( pMaterial, view.x, view.y, view.width, view.height,
+				0, 0, m_pFlashTexture->GetActualWidth()-1, m_pFlashTexture->GetActualHeight()-1, 
+				m_pFlashTexture->GetActualWidth(), m_pFlashTexture->GetActualHeight() );
+			render->ViewDrawFade( overlaycolor, pMaterial );
+			pRenderContext->DrawScreenSpaceRectangle( pMaterial, view.x, view.y, view.width, view.height,
+				0, 0, m_pFlashTexture->GetActualWidth()-1, m_pFlashTexture->GetActualHeight()-1, 
+				m_pFlashTexture->GetActualWidth(), m_pFlashTexture->GetActualHeight() );
+		}
+	}
+
+	// this does the pure white overlay part of the flashbang effect.
+	pMaterial = materials->FindMaterial( "effects/flashbang_white", TEXTURE_GROUP_CLIENT_EFFECTS, true );
+
+	if ( !pMaterial )
+		return;
+
+	float flAlpha = 255;
+
+	if ( pPlayer->m_flFlashAlpha < pPlayer->m_flFlashMaxAlpha )
+	{
+		 flAlpha = pPlayer->m_flFlashAlpha;
+	}
+	else
+	{
+		float flFlashTimeLeft = pPlayer->m_flFlashBangTime - gpGlobals->curtime;
+		float flAlphaPercentage = 1.0;
+		const float certainBlindnessTimeThresh = 3.0; // yes this is a magic number, necessary to match CS/CZ flashbang effectiveness cause the rendering system is completely different.
+
+		if (flFlashTimeLeft > certainBlindnessTimeThresh)
+		{
+			// if we still have enough time of blindness left, make sure the player can't see anything yet.
+			flAlphaPercentage = 1.0;
+		}
+		else
+		{
+			// blindness effects shorter than 'certainBlindnessTimeThresh' will start off at less than 255 alpha.
+			flAlphaPercentage = flFlashTimeLeft / certainBlindnessTimeThresh;
+
+			if (g_pMaterialSystemHardwareConfig->GetDXSupportLevel() >= 80)
+			{
+				// reduce alpha level quicker with dx 8 support and higher to compensate
+				// for having the burn-in effect.
+				flAlphaPercentage *= flAlphaPercentage;
+			}
+		}
+
+		flAlpha = flAlphaPercentage *= pPlayer->m_flFlashMaxAlpha; // scale a [0..1) value to a [0..MaxAlpha] value for the alpha.
+
+		// make sure the alpha is in the range of [0..MaxAlpha]
+		flAlpha = MAX ( flAlpha, 0 );
+		flAlpha = MIN ( flAlpha, pPlayer->m_flFlashMaxAlpha);
+	}
+
+	overlaycolor[0] = overlaycolor[1] = overlaycolor[2] = flAlpha;
+	render->ViewDrawFade( overlaycolor, pMaterial );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders extra 2D effects in derived classes while the 2D view is on the stack
+//-----------------------------------------------------------------------------
+void CCSViewRender::Render2DEffectsPreHUD( const CViewSetup &view )
+{
+	PerformNightVisionEffect( view );	// this needs to come before the HUD is drawn, or it will wash the HUD out
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders extra 2D effects in derived classes while the 2D view is on the stack
+//-----------------------------------------------------------------------------
+void CCSViewRender::Render2DEffectsPostHUD( const CViewSetup &view )
+{
+	PerformFlashbangEffect( view );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Renders voice feedback and other sprites attached to players
+// Input  : none
+//-----------------------------------------------------------------------------
+void CCSViewRender::RenderPlayerSprites()
+{
+	GetClientVoiceMgr()->SetHeadLabelOffset( 40 );
+
+	CViewRender::RenderPlayerSprites();
+	RadioManager()->DrawHeadLabels();
+}
+
diff --git a/game/client/cstrike/cs_view_scene.h b/game/client/cstrike/cs_view_scene.h
new file mode 100644
index 00000000..7c8c5381
--- /dev/null
+++ b/game/client/cstrike/cs_view_scene.h
@@ -0,0 +1,40 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_VIEW_SCENE_H
+#define CS_VIEW_SCENE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "viewrender.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Implements the interview to view rendering for the client .dll
+//-----------------------------------------------------------------------------
+class CCSViewRender : public CViewRender
+{
+public:
+	CCSViewRender();
+
+	virtual void Init( void );
+
+	virtual void GetScreenFadeDistances( float *min, float *max );
+
+	virtual void Render2DEffectsPreHUD( const CViewSetup &view );
+	virtual void Render2DEffectsPostHUD( const CViewSetup &view );
+	virtual void RenderPlayerSprites( void );
+
+private:
+
+	void PerformFlashbangEffect( const CViewSetup &view );
+	void PerformNightVisionEffect( const CViewSetup &view );
+	
+	ITexture *m_pFlashTexture;
+};
+
+#endif //CS_VIEW_SCENE_H
\ No newline at end of file
diff --git a/game/client/cstrike/fx_cs_blood.cpp b/game/client/cstrike/fx_cs_blood.cpp
new file mode 100644
index 00000000..faf3c4ba
--- /dev/null
+++ b/game/client/cstrike/fx_cs_blood.cpp
@@ -0,0 +1,482 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A blood spray effect to expose successful hits.
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "clienteffectprecachesystem.h"
+#include "fx_sparks.h"
+#include "iefx.h"
+#include "c_te_effect_dispatch.h"
+#include "particles_ez.h"
+#include "decals.h"
+#include "engine/IEngineSound.h"
+#include "fx_quad.h"
+#include "engine/ivdebugoverlay.h"
+#include "shareddefs.h"
+#include "fx_blood.h"
+#include "view.h"
+#include "c_cs_player.h"
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectCSBloodSpray )
+CLIENTEFFECT_MATERIAL( "effects/blood_gore" )
+CLIENTEFFECT_MATERIAL( "effects/blood_drop" )
+CLIENTEFFECT_MATERIAL( "effects/blood_puff" )
+CLIENTEFFECT_REGISTER_END()
+
+
+class CHitEffectRamp
+{
+public:
+	float m_flDamageAmount;
+	
+	float m_flMinAlpha;
+	float m_flMaxAlpha;
+
+	float m_flMinSize;
+	float m_flMaxSize;
+
+	float m_flMinVelocity;
+	float m_flMaxVelocity;
+};
+
+
+void InterpolateRamp( 
+	const CHitEffectRamp &a,
+	const CHitEffectRamp &b,
+	CHitEffectRamp &out,
+	int iDamage )
+{
+	float t = RemapVal( iDamage, a.m_flDamageAmount, b.m_flDamageAmount, 0, 1 );
+
+	out.m_flMinAlpha = FLerp( a.m_flMinAlpha, b.m_flMinAlpha, t );
+	out.m_flMaxAlpha = FLerp( a.m_flMaxAlpha, b.m_flMaxAlpha, t );
+	out.m_flMinAlpha = clamp( out.m_flMinAlpha, 0, 255 );
+	out.m_flMaxAlpha = clamp( out.m_flMaxAlpha, 0, 255 );
+
+	out.m_flMinSize = FLerp( a.m_flMinSize, b.m_flMinSize, t );
+	out.m_flMaxSize = FLerp( a.m_flMaxSize, b.m_flMaxSize, t );
+
+	out.m_flMinVelocity = FLerp( a.m_flMinVelocity, b.m_flMinVelocity, t );
+	out.m_flMaxVelocity = FLerp( a.m_flMaxVelocity, b.m_flMaxVelocity, t );
+}
+
+
+void FX_HitEffectSmoke(
+	CSmartPtr<CBloodSprayEmitter> pEmitter, 
+	int iDamage,
+	const Vector &vEntryPoint,
+	const Vector &vDirection,
+	float flScale)
+{
+	SimpleParticle newParticle;
+	PMaterialHandle hMaterial = ParticleMgr()->GetPMaterial( "effects/blood_gore" );
+
+	// These parameters create a ramp based on how much damage the shot did.
+	CHitEffectRamp ramps[2] =
+	{
+		{ 
+			0, 
+			30,		// min/max alpha
+			70, 
+			0.5,	// min/max size
+			1,
+			0,		// min/max velocity (not used here)
+			0
+		},
+		
+		{ 
+			50, 
+			30,		// min/max alpha 
+			70,
+			1,		// min/max size
+			2,
+			0,		// min/max velocity (not used here)
+			0
+		}
+	};
+
+	CHitEffectRamp interpolatedRamp;
+	InterpolateRamp( 
+		ramps[0], 
+		ramps[1], 
+		interpolatedRamp,
+		iDamage );
+
+	for ( int i=0; i < 2; i++ )
+	{
+		SimpleParticle &newParticle = *pEmitter->AddSimpleParticle( hMaterial, vEntryPoint, 0, 0 );
+
+		newParticle.m_flLifetime = 0.0f;
+		newParticle.m_flDieTime	= 3.0f;
+
+		newParticle.m_uchStartSize	= random->RandomInt( 
+			interpolatedRamp.m_flMinSize, 
+			interpolatedRamp.m_flMaxSize ) * flScale;
+		newParticle.m_uchEndSize	= newParticle.m_uchStartSize * 4;
+		
+		newParticle.m_vecVelocity = Vector( 0, 0, 5 ) + RandomVector( -2, 2 );
+		newParticle.m_uchStartAlpha	= random->RandomInt( 
+			interpolatedRamp.m_flMinSize,
+			interpolatedRamp.m_flMaxSize );
+		newParticle.m_uchEndAlpha	= 0;
+
+		newParticle.m_flRoll			= random->RandomFloat( 0, 360 );
+		newParticle.m_flRollDelta	= random->RandomFloat( -1, 1 );
+
+		newParticle.m_iFlags = SIMPLE_PARTICLE_FLAG_NO_VEL_DECAY;
+
+		float colorRamp = random->RandomFloat( 0.5f, 1.25f );
+
+		newParticle.m_uchColor[0] = MIN( 1.0f, colorRamp ) * 255.0f;
+		newParticle.m_uchColor[1] = MIN( 1.0f, colorRamp ) * 255.0f;
+		newParticle.m_uchColor[2] = MIN( 1.0f, colorRamp ) * 255.0f;
+	}	
+}
+
+
+void FX_HitEffectBloodSpray(
+	CSmartPtr<CBloodSprayEmitter> pEmitter, 
+	int iDamage,
+	const Vector &vEntryPoint, 
+	const Vector &vSprayNormal,
+	const char *pMaterialName,
+	float flLODDistance,
+	float flDistanceScale,
+	float flScale,
+	float flSpeed )
+{
+	PMaterialHandle hMaterial = ParticleMgr()->GetPMaterial( pMaterialName );
+	SimpleParticle *pParticle;
+
+	float color[3] = { 1.0, 0, 0 };
+
+	Vector up( 0, 0, 1 );
+	Vector right = up.Cross( vSprayNormal );
+	VectorNormalize( right );
+
+	// These parameters create a ramp based on how much damage the shot did.
+	CHitEffectRamp ramps[2] =
+	{
+		{ 
+			0, 
+			80,		// min/max alpha
+			128, 
+			flScale/2,// min/max size
+			flScale,
+			10,		// min/max velocity
+			20
+		},
+		
+		{ 
+			50, 
+			80,		// min/max alpha 
+			128,
+			flScale/2,// min/max size
+			flScale,
+			30,		// min/max velocity
+			60
+		}
+	};
+
+	CHitEffectRamp interpolatedRamp;
+	InterpolateRamp( 
+		ramps[0], 
+		ramps[1], 
+		interpolatedRamp,
+		iDamage );
+
+	for ( int i = 0; i < 6; i++ )
+	{
+		// Originate from within a circle '2 * scale' inches in diameter.
+		Vector offset = vEntryPoint + ( flScale * vSprayNormal * 0.5 );
+		offset += right * random->RandomFloat( -1, 1 ) * flScale;
+		offset += up * random->RandomFloat( -1, 1 ) * flScale;
+
+		pParticle = pEmitter->AddSimpleParticle( hMaterial, offset, 0, 0 );
+
+		if ( pParticle != NULL )
+		{
+			pParticle->m_flLifetime = 0.0f;
+			pParticle->m_flDieTime	= random->RandomFloat( 0.7f, 1.3f);
+
+			// All the particles are between red and white. The whiter the particle is, the slower it goes.
+			float whiteness = random->RandomFloat( 0.1, 0.7 );
+			float speedFactor = 1 - whiteness;
+
+			float spread = 0.5f;
+			pParticle->m_vecVelocity.Random( -spread, spread );
+			pParticle->m_vecVelocity += vSprayNormal * random->RandomInt( interpolatedRamp.m_flMinVelocity, interpolatedRamp.m_flMaxVelocity ) * flSpeed * speedFactor;
+
+			float colorRamp = random->RandomFloat( 0.5f, 0.75f ) + flLODDistance;
+			
+			pParticle->m_uchColor[0]	= MIN( 1.0f, color[0] * colorRamp ) * 255.0f;
+			pParticle->m_uchColor[1]	= MIN( 1.0f, whiteness * colorRamp ) * 255.0f;
+			pParticle->m_uchColor[2]	= MIN( 1.0f, whiteness * colorRamp ) * 255.0f;
+			
+			pParticle->m_uchStartSize	= random->RandomFloat( interpolatedRamp.m_flMinSize, interpolatedRamp.m_flMaxSize ) * flDistanceScale;
+			pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 4 * flDistanceScale;
+			
+			pParticle->m_uchStartAlpha	= random->RandomInt( interpolatedRamp.m_flMinAlpha, interpolatedRamp.m_flMaxAlpha );
+			pParticle->m_uchEndAlpha	= 0;
+			
+			pParticle->m_flRoll			= random->RandomInt( 0, 360 );
+			pParticle->m_flRollDelta	= random->RandomFloat( -4.0f, 4.0f );
+		}
+	}
+}
+
+
+void FX_HitEffectBloodSplatter(
+	CSmartPtr<CBloodSprayEmitter> pTrailEmitter, 
+	int iDamage,
+	const Vector &vExitPoint, 
+	const Vector &vSplatterNormal,
+	float flLODDistance )
+{
+	float flScale = 4;
+
+	pTrailEmitter->SetSortOrigin( vExitPoint );
+	PMaterialHandle	hMaterial = ParticleMgr()->GetPMaterial( "effects/blood_drop" );
+
+	Vector up( 0, 0, 1 );
+	Vector right = up.Cross( vSplatterNormal );
+	VectorNormalize( right );
+
+	// These parameters create a ramp based on how much damage the shot did.
+	CHitEffectRamp ramps[2] =
+	{
+		{ 
+			0, 
+			0,		// min/max alpha
+			75, 
+			1.5f,  // min/max size
+			2.0f,
+			25.0f * flScale,		// min/max velocity
+			35.0f * flScale
+		},
+		
+		{ 
+			50, 
+			0,		// min/max alpha 
+			140,
+			1.5f,// min/max size
+			2.0f,
+			65.0f * flScale,		// min/max velocity
+			75.0f * flScale
+		}
+	};
+
+	CHitEffectRamp interpolatedRamp;
+	InterpolateRamp( 
+		ramps[0], 
+		ramps[1], 
+		interpolatedRamp,
+		iDamage );
+
+
+	for ( int i = 0; i < 20; i++ )
+	{
+		// Originate from within a circle 'scale' inches in diameter.
+		Vector offset = vExitPoint;
+		offset += right * random->RandomFloat( -0.15f, 0.15f ) * flScale;
+		offset += up * random->RandomFloat( -0.15f, 0.15f ) * flScale;
+
+		SimpleParticle *tParticle = (SimpleParticle*)pTrailEmitter->AddSimpleParticle( 
+			hMaterial, 
+			vExitPoint,
+			random->RandomFloat( 0.225f, 0.35f ),
+			random->RandomFloat( interpolatedRamp.m_flMinSize, interpolatedRamp.m_flMaxSize )
+			);
+
+		if ( tParticle == NULL )
+			break;
+
+		Vector offDir = vSplatterNormal + RandomVector( -0.05f, 0.05f );
+
+		tParticle->m_vecVelocity = offDir * random->RandomFloat( interpolatedRamp.m_flMinVelocity, interpolatedRamp.m_flMaxVelocity );
+
+		tParticle->m_iFlags = SIMPLE_PARTICLE_FLAG_NO_VEL_DECAY;
+		tParticle->m_uchColor[0]	= 150;
+		tParticle->m_uchColor[1]	= 0;
+		tParticle->m_uchColor[2]	= 0;
+		tParticle->m_uchStartAlpha = interpolatedRamp.m_flMaxAlpha / 2;
+		tParticle->m_uchEndAlpha = 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : origin - 
+//			normal - 
+//			scale - 
+//-----------------------------------------------------------------------------
+void FX_CS_BloodSpray( const Vector &origin, const Vector &normal, float flDamage )
+{
+	if ( UTIL_IsLowViolence() )
+		return;
+
+	static ConVar *violence_hblood = cvar->FindVar( "violence_hblood" );
+	if ( violence_hblood && !violence_hblood->GetBool() )
+		return;
+
+	Vector offset;
+	int i;
+	
+	float r = 64;
+	float g = 0;
+	float b = 4;
+
+	float scale = 0.5 + clamp( flDamage/50.f, 0.0, 1.0 ) ;
+
+	//Find area ambient light color and use it to tint smoke
+	Vector worldLight = WorldGetLightForPoint( origin, true );
+	Vector color = Vector( (float)(worldLight[0] * r) / 255.0f, (float)(worldLight[1] * g) / 255.0f, (float)(worldLight[2] * b) / 255.0f );
+	float colorRamp;
+
+	Vector	offDir;
+
+	CSmartPtr<CBloodSprayEmitter> pSimple = CBloodSprayEmitter::Create( "bloodgore" );
+	if ( !pSimple )
+		return;
+
+	pSimple->SetSortOrigin( origin );
+	pSimple->SetGravity( 0 );
+
+	// Blood impact
+	PMaterialHandle	hMaterial = ParticleMgr()->GetPMaterial( "effects/blood_core" );
+
+	SimpleParticle *pParticle;
+
+	Vector	dir = normal * RandomVector( -0.5f, 0.5f );
+
+	offset = origin + ( 2.0f * normal );
+
+	pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), hMaterial, offset );
+
+	if ( pParticle != NULL )
+	{
+		pParticle->m_flLifetime = 0.0f;
+		pParticle->m_flDieTime	= 0.75f;
+
+		pParticle->m_vecVelocity	= dir * random->RandomFloat( 16.0f, 32.0f );
+		pParticle->m_vecVelocity[2] -= random->RandomFloat( 8.0f, 16.0f );
+
+		colorRamp = random->RandomFloat( 0.75f, 2.0f );
+
+		pParticle->m_uchColor[0]	= MIN( 1.0f, color[0] * colorRamp ) * 255.0f;
+		pParticle->m_uchColor[1]	= MIN( 1.0f, color[1] * colorRamp ) * 255.0f;
+		pParticle->m_uchColor[2]	= MIN( 1.0f, color[2] * colorRamp ) * 255.0f;
+		
+		pParticle->m_uchStartSize	= 8;
+		pParticle->m_uchEndSize		= 32;
+	
+		pParticle->m_uchStartAlpha	= 255;
+		pParticle->m_uchEndAlpha	= 0;
+		
+		pParticle->m_flRoll			= random->RandomInt( 0, 360 );
+		pParticle->m_flRollDelta	= 0;
+	}
+
+	hMaterial = ParticleMgr()->GetPMaterial( "effects/blood_gore" );
+
+	for ( i = 0; i < 4; i++ )
+	{
+		offset = origin + ( 2.0f * normal );
+
+		pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), hMaterial, offset );
+
+		if ( pParticle != NULL )
+		{
+			pParticle->m_flLifetime = 0.0f;
+			pParticle->m_flDieTime	= random->RandomFloat( 0.75f, 1.0f);
+
+			pParticle->m_vecVelocity	= dir * random->RandomFloat( 16.0f, 32.0f )*(i+1);
+			pParticle->m_vecVelocity[2] -= random->RandomFloat( 16.0f, 32.0f )*(i+1);
+
+			colorRamp = random->RandomFloat( 0.75f, 2.0f );
+
+			pParticle->m_uchColor[0]	= MIN( 1.0f, color[0] * colorRamp ) * 255.0f;
+			pParticle->m_uchColor[1]	= MIN( 1.0f, color[1] * colorRamp ) * 255.0f;
+			pParticle->m_uchColor[2]	= MIN( 1.0f, color[2] * colorRamp ) * 255.0f;
+			
+			pParticle->m_uchStartSize	= scale * random->RandomInt( 4, 8 );
+			pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 4;
+		
+			pParticle->m_uchStartAlpha	= 255;
+			pParticle->m_uchEndAlpha	= 0;
+			
+			pParticle->m_flRoll			= random->RandomInt( 0, 360 );
+			pParticle->m_flRollDelta	= 0;
+		}
+	}
+
+	//
+	// Dump out drops
+	//
+	TrailParticle *tParticle;
+
+	CSmartPtr<CTrailParticles> pTrailEmitter = CTrailParticles::Create( "blooddrops" );
+	if ( !pTrailEmitter )
+		return;
+
+	pTrailEmitter->SetSortOrigin( origin );
+
+	// Partial gravity on blood drops
+	pTrailEmitter->SetGravity( 400.0 ); 
+	
+	// Enable simple collisions with nearby surfaces
+	pTrailEmitter->Setup(origin, &normal, 1, 10, 100, 400, 0.2, 0 );
+
+	hMaterial = ParticleMgr()->GetPMaterial( "effects/blood_drop" );
+
+	//
+	// Shorter droplets
+	//
+	for ( i = 0; i < 32; i++ )
+	{
+		// Originate from within a circle 'scale' inches in diameter
+		offset = origin;
+
+		tParticle = (TrailParticle *) pTrailEmitter->AddParticle( sizeof(TrailParticle), hMaterial, offset );
+
+		if ( tParticle == NULL )
+			break;
+
+		tParticle->m_flLifetime	= 0.0f;
+
+		offDir = RandomVector( -1.0f, 1.0f );
+
+		tParticle->m_vecVelocity = offDir * random->RandomFloat( 32.0f, 128.0f );
+
+		tParticle->m_flWidth		= scale * random->RandomFloat( 1.0f, 3.0f );
+		tParticle->m_flLength		= random->RandomFloat( 0.1f, 0.15f );
+		tParticle->m_flDieTime		= random->RandomFloat( 0.5f, 1.0f );
+
+		FloatToColor32( tParticle->m_color, color[0], color[1], color[2], 1.0f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bloodtype - 
+//			r - 
+//			g - 
+//			b - 
+//-----------------------------------------------------------------------------
+void GetBloodColorForTeam( int iTeam, unsigned char &r, unsigned char &g, unsigned char &b )
+{
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Intercepts the blood spray message.
+//-----------------------------------------------------------------------------
+void CSBloodSprayCallback( const CEffectData &data )
+{
+	FX_CS_BloodSpray( data.m_vOrigin, data.m_vNormal, data.m_flMagnitude );
+}
+
+DECLARE_CLIENT_EFFECT( "csblood", CSBloodSprayCallback );
diff --git a/game/client/cstrike/fx_cs_blood.h b/game/client/cstrike/fx_cs_blood.h
new file mode 100644
index 00000000..5f496d6f
--- /dev/null
+++ b/game/client/cstrike/fx_cs_blood.h
@@ -0,0 +1,20 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef FX_CS_BLOOD_H
+#define FX_CS_BLOOD_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+void FX_CS_BloodSpray( 
+	const Vector &origin,
+	const Vector &normal,
+	float flDamage );
+
+
+#endif // FX_CS_BLOOD_H
diff --git a/game/client/cstrike/fx_cs_impacts.cpp b/game/client/cstrike/fx_cs_impacts.cpp
new file mode 100644
index 00000000..c1ae37ff
--- /dev/null
+++ b/game/client/cstrike/fx_cs_impacts.cpp
@@ -0,0 +1,44 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Game-specific impact effect hooks
+//
+//=============================================================================//
+#include "cbase.h"
+#include "fx_impact.h"
+#include "engine/IEngineSound.h"
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle weapon impacts
+//-----------------------------------------------------------------------------
+void ImpactCallback( const CEffectData &data )
+{
+	trace_t tr;
+	Vector vecOrigin, vecStart, vecShotDir;
+	int iMaterial, iDamageType, iHitbox;
+	short nSurfaceProp;
+
+	C_BaseEntity *pEntity = ParseImpactData( data, &vecOrigin, &vecStart, &vecShotDir, nSurfaceProp, iMaterial, iDamageType, iHitbox );
+
+	if ( !pEntity )
+		return;
+
+	// If we hit, perform our custom effects and play the sound
+	if ( Impact( vecOrigin, vecStart, iMaterial, iDamageType, iHitbox, pEntity, tr ) )
+	{
+		// Check for custom effects based on the Decal index
+		PerformCustomEffects( vecOrigin, tr, vecShotDir, iMaterial, 1.0 );
+
+		//Play a ricochet sound some of the time
+		if( random->RandomInt(1,10) <= 3 && (iDamageType == DMG_BULLET) )
+		{
+			CLocalPlayerFilter filter;
+			C_BaseEntity::EmitSound( filter, SOUND_FROM_WORLD, "Bounce.Shrapnel", &vecOrigin );
+		}
+	}
+
+	PlayImpactSound( pEntity, tr, vecOrigin, nSurfaceProp );
+}
+
+DECLARE_CLIENT_EFFECT( "Impact", ImpactCallback );
diff --git a/game/client/cstrike/fx_cs_knifeslash.cpp b/game/client/cstrike/fx_cs_knifeslash.cpp
new file mode 100644
index 00000000..107ee36d
--- /dev/null
+++ b/game/client/cstrike/fx_cs_knifeslash.cpp
@@ -0,0 +1,72 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Game-specific impact effect hooks
+//
+//=============================================================================//
+#include "cbase.h"
+#include "decals.h"
+#include "iefx.h"
+#include "fx_impact.h"
+#include "tempent.h"
+#include "c_te_effect_dispatch.h"
+#include "c_te_legacytempents.h"
+
+void KnifeSlash( const CEffectData &data )
+{
+	trace_t tr;
+	Vector vecOrigin, vecStart, vecShotDir;
+	int iMaterial, iDamageType, iHitbox;
+	short nSurfaceProp;
+
+	C_BaseEntity *pEntity = ParseImpactData( data, &vecOrigin, &vecStart, &vecShotDir, nSurfaceProp, iMaterial, iDamageType, iHitbox );
+
+	if( pEntity == NULL )
+		return;
+
+	int decalNumber = decalsystem->GetDecalIndexForName( GetImpactDecal( pEntity, iMaterial, iDamageType ) );
+	if ( decalNumber == -1 )
+		return;
+
+	// vector perpendicular to the slash direction
+	// so we can align the slash decal to that
+	Vector vecPerp;
+	AngleVectors( data.m_vAngles, NULL, &vecPerp, NULL );
+
+	const ConVar *decals =cvar->FindVar( "r_decals" );
+
+	if ( decals && decals->GetInt() )
+	{
+		if ( (pEntity->entindex() == 0) && (iHitbox != 0) )
+		{
+			// Setup our shot information
+			Vector shotDir = vecOrigin - vecStart;
+			float flLength = VectorNormalize( shotDir );
+			Vector traceExt;
+			VectorMA( vecStart, flLength + 8.0f, shotDir, traceExt );
+
+			// Special case for world entity with hitbox (that's a static prop):
+			// In this case, we've hit a static prop. Decal it!
+			staticpropmgr->AddDecalToStaticProp( vecStart, traceExt, iHitbox - 1, decalNumber, true, tr );
+		}
+		else
+		{
+			effects->DecalShoot( decalNumber,
+						pEntity->entindex(),
+						pEntity->GetModel(),
+						pEntity->GetAbsOrigin(),
+						pEntity->GetAbsAngles(),
+						vecOrigin,
+						&vecPerp,
+						0 );
+		}
+		
+	}
+
+	if( Impact( vecOrigin, vecStart, iMaterial, iDamageType, iHitbox, pEntity, tr, data.m_fFlags ) )
+	{
+		// Check for custom effects based on the Decal index
+		PerformCustomEffects( vecOrigin, tr, vecShotDir, iMaterial, 1.0 );	
+	}
+}
+
+DECLARE_CLIENT_EFFECT( "KnifeSlash",		KnifeSlash );
diff --git a/game/client/cstrike/fx_cs_muzzleflash.cpp b/game/client/cstrike/fx_cs_muzzleflash.cpp
new file mode 100644
index 00000000..9f3223c6
--- /dev/null
+++ b/game/client/cstrike/fx_cs_muzzleflash.cpp
@@ -0,0 +1,139 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "particles_simple.h"
+#include "particles_localspace.h"
+#include "c_te_effect_dispatch.h"
+#include "clienteffectprecachesystem.h"
+
+// Precache our effects
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffect_CS_MuzzleFlash )
+CLIENTEFFECT_MATERIAL( "effects/muzzleflashX" )	//.vmt
+CLIENTEFFECT_MATERIAL( "sprites/muzzleflash4" )	//.vmt
+CLIENTEFFECT_REGISTER_END()
+
+void TE_DynamicLight( IRecipientFilter& filter, float delay,
+	const Vector* org, int r, int g, int b, int exponent, float radius, float time, float decay, int nLightIndex = LIGHT_INDEX_TE_DYNAMIC );
+
+void CS_MuzzleFlashCallback( const CEffectData &data )
+{
+	CSmartPtr<CLocalSpaceEmitter> pEmitter = 
+		CLocalSpaceEmitter::Create( "CS_MuzzleFlash", data.m_hEntity, data.m_nAttachmentIndex, 0 );
+
+	if ( !pEmitter )
+		return;
+
+	// SetBBox() manually on the particle system so it doesn't have to be recalculated more than once.
+	Vector vCenter( 0.0f, 0.0f, 0.0f );
+	C_BaseEntity *pEnt = data.GetEntity();
+	if ( pEnt )
+	{
+		vCenter = pEnt->WorldSpaceCenter();
+	}
+	else
+	{
+		IClientRenderable *pRenderable = data.GetRenderable( );
+		if ( pRenderable )
+		{
+			Vector vecMins, vecMaxs;
+			pRenderable->GetRenderBoundsWorldspace( vecMins, vecMaxs );
+			VectorAdd( vecMins, vecMaxs, vCenter );
+			vCenter *= 0.5f;
+		}
+	}
+
+	Assert( pEmitter );
+	pEmitter->GetBinding().SetBBox( vCenter - Vector( 3, 3, 3 ), vCenter + Vector( 3, 3, 3 ) );
+
+	// haxors - make the clip much shorter so the alpha is not 
+	// changed based on large clip distances
+	pEmitter->SetNearClip( 0, 5 );
+
+	PMaterialHandle hFlashMaterial = pEmitter->GetPMaterial( "sprites/muzzleflash4" );
+
+	for( int i=0;i<3;i++ )
+	{
+		SimpleParticle *pParticle = (SimpleParticle *)pEmitter->AddParticle( sizeof( SimpleParticle ),
+															hFlashMaterial,
+															vec3_origin );
+		if( pParticle )
+		{
+			pParticle->m_flLifetime		= 0.0f;
+			pParticle->m_flDieTime		= 0.08f;
+
+			pParticle->m_vecVelocity = vec3_origin;
+
+			pParticle->m_uchColor[0]	= 255;
+			pParticle->m_uchColor[1]	= 255;
+			pParticle->m_uchColor[2]	= 255;
+
+			pParticle->m_uchStartAlpha	= 80;
+			pParticle->m_uchEndAlpha	= 30;
+
+			pParticle->m_uchStartSize	= ( 3.0 + 3.0*i ) * data.m_flScale;
+
+			pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 0.8;
+			pParticle->m_flRoll			= random->RandomInt( 0, 3 );
+
+			pParticle->m_flRollDelta	= 0.0f;
+		}
+	}
+
+	// dynamic light temporary entity for the muzzle flash
+	CPVSFilter filter(pEmitter->GetSortOrigin());
+	TE_DynamicLight( filter, 0.0, &(pEmitter->GetSortOrigin()), 255, 192, 64, 5, 70, 0.05, 768 );
+}
+
+DECLARE_CLIENT_EFFECT( "CS_MuzzleFlash", CS_MuzzleFlashCallback );
+
+
+// 'X' shaped muzzleflash used by certain weapons
+void CS_MuzzleFlashXCallback( const CEffectData &data )
+{
+	CSmartPtr<CLocalSpaceEmitter> pEmitter = 
+		CLocalSpaceEmitter::Create( "CS_MuzzleFlashX", data.m_hEntity, data.m_nAttachmentIndex, 0 );
+
+	Assert( pEmitter );
+
+	// haxors - make the clip much shorter so the alpha is not 
+	// changed based on large clip distances
+	pEmitter->SetNearClip( 0, 5 );
+
+	PMaterialHandle hFlashMaterial = pEmitter->GetPMaterial( "effects/muzzleflashX" );
+
+	SimpleParticle *pParticle = (SimpleParticle *)pEmitter->AddParticle( sizeof( SimpleParticle ),
+														hFlashMaterial,
+														vec3_origin );
+	if( pParticle )
+	{
+		pParticle->m_flLifetime		= 0.0f;
+		pParticle->m_flDieTime		= 0.08f;
+
+		pParticle->m_vecVelocity = vec3_origin;
+
+		pParticle->m_uchColor[0]	= 255;
+		pParticle->m_uchColor[1]	= 255;
+		pParticle->m_uchColor[2]	= 255;
+
+		pParticle->m_uchStartAlpha	= 130;
+		pParticle->m_uchEndAlpha	= 80;
+
+		pParticle->m_uchStartSize	= 6.0f * data.m_flScale * random->RandomFloat( 0.9, 1.1 );
+
+		pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 0.8;
+
+		pParticle->m_flRoll			= random->RandomFloat( -0.25, 0.25 );
+
+		pParticle->m_flRollDelta	= 0.0f;
+	}
+
+	// dynamic light temporary entity for the muzzle flash
+	CPVSFilter filter(pEmitter->GetSortOrigin());
+	TE_DynamicLight( filter, 0.0, &(pEmitter->GetSortOrigin()), 255, 192, 64, 5, 70, 0.05, 768 );
+}
+
+DECLARE_CLIENT_EFFECT( "CS_MuzzleFlash_X", CS_MuzzleFlashXCallback );
diff --git a/game/client/cstrike/fx_cs_weaponfx.cpp b/game/client/cstrike/fx_cs_weaponfx.cpp
new file mode 100644
index 00000000..4364d648
--- /dev/null
+++ b/game/client/cstrike/fx_cs_weaponfx.cpp
@@ -0,0 +1,61 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Game-specific impact effect hooks
+//
+//=============================================================================//
+#include "cbase.h"
+#include "fx_impact.h"
+#include "tempent.h"
+#include "c_te_effect_dispatch.h"
+#include "c_te_legacytempents.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle weapon effect callbacks
+//-----------------------------------------------------------------------------
+void CStrike_EjectBrass( int shell, const CEffectData &data )
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+
+	if( !pPlayer )
+		return;
+
+	tempents->CSEjectBrass( data.m_vOrigin, data.m_vAngles, data.m_fFlags, shell, pPlayer );
+}
+
+void CStrike_FX_EjectBrass_9mm_Callback( const CEffectData &data )
+{
+	CStrike_EjectBrass( CS_SHELL_9MM, data );
+}
+
+void CStrike_FX_EjectBrass_57_Callback( const CEffectData &data )
+{
+	CStrike_EjectBrass( CS_SHELL_57, data );
+}
+
+void CStrike_FX_EjectBrass_12Gauge_Callback( const CEffectData &data )
+{
+	CStrike_EjectBrass( CS_SHELL_12GAUGE, data );
+}
+
+void CStrike_FX_EjectBrass_556_Callback( const CEffectData &data )
+{
+	CStrike_EjectBrass( CS_SHELL_556, data );
+}
+
+void CStrike_FX_EjectBrass_762Nato_Callback( const CEffectData &data )
+{
+	CStrike_EjectBrass( CS_SHELL_762NATO, data );
+}
+
+void CStrike_FX_EjectBrass_338Mag_Callback( const CEffectData &data )
+{
+	CStrike_EjectBrass( CS_SHELL_338MAG, data );
+}
+
+DECLARE_CLIENT_EFFECT( "EjectBrass_9mm",		CStrike_FX_EjectBrass_9mm_Callback );
+DECLARE_CLIENT_EFFECT( "EjectBrass_12Gauge",	CStrike_FX_EjectBrass_12Gauge_Callback );
+DECLARE_CLIENT_EFFECT( "EjectBrass_57",			CStrike_FX_EjectBrass_57_Callback );
+DECLARE_CLIENT_EFFECT( "EjectBrass_556",		CStrike_FX_EjectBrass_556_Callback );
+DECLARE_CLIENT_EFFECT( "EjectBrass_762Nato",	CStrike_FX_EjectBrass_762Nato_Callback );
+DECLARE_CLIENT_EFFECT( "EjectBrass_338Mag",		CStrike_FX_EjectBrass_338Mag_Callback );
diff --git a/game/client/cstrike/hud_account.cpp b/game/client/cstrike/hud_account.cpp
new file mode 100644
index 00000000..abd9f570
--- /dev/null
+++ b/game/client/cstrike/hud_account.cpp
@@ -0,0 +1,66 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud_base_account.h"
+#include "c_cs_player.h"
+#include "clientmode_csnormal.h"
+
+using namespace vgui;
+
+class CHudAccount : public CHudBaseAccount
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudAccount, CHudBaseAccount );
+
+	CHudAccount( const char *name );
+
+	virtual bool ShouldDraw();
+	virtual int	GetPlayerAccount( void );
+	virtual vgui::AnimationController *GetAnimationController( void );
+};
+
+DECLARE_HUDELEMENT( CHudAccount );
+
+CHudAccount::CHudAccount( const char *pName ) :
+CHudBaseAccount( "HudAccount" )
+{
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+	SetIndent( false ); // don't indent small numbers in the drawing code - we're doing it manually
+}
+
+bool CHudAccount::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer )
+	{
+		return !pPlayer->IsObserver();
+	}
+	else
+	{
+		return false;
+	}
+}
+
+// How much money does the player have
+int	CHudAccount::GetPlayerAccount( void )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if( !pPlayer )
+		return 0;
+
+	return (int)pPlayer->GetAccount();
+}
+
+vgui::AnimationController *CHudAccount::GetAnimationController( void )
+{
+	vgui::AnimationController *pController = g_pClientMode->GetViewportAnimationController();
+
+	Assert( pController );
+
+	return pController;
+}
\ No newline at end of file
diff --git a/game/client/cstrike/hud_armor.cpp b/game/client/cstrike/hud_armor.cpp
new file mode 100644
index 00000000..cbdb1de6
--- /dev/null
+++ b/game/client/cstrike/hud_armor.cpp
@@ -0,0 +1,124 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+ //====== Copyright © 1996-2003, Valve Corporation, All rights reserved. =======
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "cs_gamerules.h"
+#include "hud_numericdisplay.h"
+
+
+class CHudArmor : public CHudElement, public CHudNumericDisplay
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudArmor, CHudNumericDisplay );
+
+	CHudArmor( const char *name );
+
+	virtual bool ShouldDraw();	
+	virtual void Paint();
+	virtual void Init();
+	virtual void ApplySchemeSettings( IScheme *scheme );
+
+private:
+	CHudTexture *m_pArmorIcon;
+	CHudTexture *m_pArmor_HelmetIcon;
+
+	CPanelAnimationVarAliasType( float, icon_xpos, "icon_xpos", "0", "proportional_float" );
+	CPanelAnimationVarAliasType( float, icon_ypos, "icon_ypos", "2", "proportional_float" );
+
+	float icon_wide;
+	float icon_tall;
+};
+
+
+DECLARE_HUDELEMENT( CHudArmor );
+
+
+CHudArmor::CHudArmor( const char *pName ) : CHudNumericDisplay( NULL, "HudArmor" ), CHudElement( pName )
+{
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+}
+
+
+void CHudArmor::Init()
+{
+	SetIndent(true);
+}
+
+void CHudArmor::ApplySchemeSettings( IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+
+	if( !m_pArmorIcon )
+	{
+		m_pArmorIcon = gHUD.GetIcon( "shield_bright" );
+	}
+
+	if( !m_pArmor_HelmetIcon )
+	{
+		m_pArmor_HelmetIcon = gHUD.GetIcon( "shield_kevlar_bright" );
+	}	
+
+	if( m_pArmorIcon )
+	{
+		icon_tall = GetTall() - YRES(2);
+		float scale = icon_tall / (float)m_pArmorIcon->Height();
+		icon_wide = ( scale ) * (float)m_pArmorIcon->Width();
+	}
+}
+
+
+bool CHudArmor::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer )
+	{
+		return !pPlayer->IsObserver();
+	}
+	else
+	{
+		return false;
+	}
+}
+
+
+void CHudArmor::Paint()
+{
+	// Update the time.
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer )
+	{
+		if( pPlayer->HasHelmet() && (int)pPlayer->ArmorValue() > 0 )
+		{
+			if( m_pArmor_HelmetIcon )
+			{
+				m_pArmor_HelmetIcon->DrawSelf( icon_xpos, icon_ypos, icon_wide, icon_tall, GetFgColor() );
+			}
+		}
+		else
+		{
+			if( m_pArmorIcon )
+			{
+				m_pArmorIcon->DrawSelf( icon_xpos, icon_ypos, icon_wide, icon_tall, GetFgColor() );
+			}
+		}
+
+		SetDisplayValue( (int)pPlayer->ArmorValue() );
+		SetShouldDisplayValue( true );
+		BaseClass::Paint();
+	}
+}
+
diff --git a/game/client/cstrike/hud_c4.cpp b/game/client/cstrike/hud_c4.cpp
new file mode 100644
index 00000000..0c39e55f
--- /dev/null
+++ b/game/client/cstrike/hud_c4.cpp
@@ -0,0 +1,128 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "cs_gamerules.h"
+#include "hud_numericdisplay.h"
+
+
+class CHudC4 : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudC4, vgui::Panel );
+
+	CHudC4( const char *name );
+
+	virtual bool ShouldDraw();	
+	virtual void Paint();
+	virtual void Init();
+
+
+private:
+	CPanelAnimationVar( Color, m_clrIcon, "IconColor", "IconColor" );
+	CPanelAnimationVar( Color, m_clrFlash, "FlashColor", "FlashColor" );
+
+	CHudTexture *m_pIcon;
+
+	float m_flNextFlashTime;
+	bool m_bFlash;
+};
+
+
+DECLARE_HUDELEMENT( CHudC4 );
+
+
+CHudC4::CHudC4( const char *pName ) :
+	vgui::Panel( NULL, "HudC4" ), CHudElement( pName )
+{
+	SetParent( g_pClientMode->GetViewport() );
+	m_pIcon = NULL;
+
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Add this to the render group that disappears when the scoreboard is up
+	//=============================================================================
+	RegisterForRenderGroup( "hide_for_scoreboard" );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+
+void CHudC4::Init()
+{
+	m_flNextFlashTime = 0;
+	m_bFlash = false;
+}
+
+
+bool CHudC4::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	// if we are spectating another player first person, check this player
+	if ( pPlayer && (pPlayer->GetObserverMode() == OBS_MODE_IN_EYE) )
+	{
+		pPlayer = ToCSPlayer( pPlayer->GetObserverTarget() );
+	}
+	
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Added base class call
+	//=============================================================================
+	return pPlayer && pPlayer->HasC4() && CHudElement::ShouldDraw();
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+
+void CHudC4::Paint()
+{
+	if ( !m_pIcon )
+	{
+		m_pIcon = gHUD.GetIcon( "c4" );
+	}
+
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( !pPlayer )
+		return;
+
+	if( pPlayer->m_bInBombZone )
+	{
+		if( m_flNextFlashTime < gpGlobals->curtime )
+		{
+			m_bFlash = !m_bFlash;
+			m_flNextFlashTime = gpGlobals->curtime + 0.15;
+		}
+	}
+	else
+	{
+		m_bFlash = false;
+	}
+
+	int x, y, w, h;
+	GetBounds( x, y, w, h );
+
+	if ( m_pIcon )
+	{
+		if( m_bFlash )
+		{
+			m_pIcon->DrawSelf( 0, 0, w, h, m_clrFlash );
+		}
+		else
+		{
+			m_pIcon->DrawSelf( 0, 0, w, h, m_clrIcon );
+		}
+	}
+}
+
diff --git a/game/client/cstrike/hud_deathnotice.cpp b/game/client/cstrike/hud_deathnotice.cpp
new file mode 100644
index 00000000..3ca5d4a2
--- /dev/null
+++ b/game/client/cstrike/hud_deathnotice.cpp
@@ -0,0 +1,485 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Draws CSPort's death notices
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hudelement.h"
+#include "hud_macros.h"
+#include "c_playerresource.h"
+#include "iclientmode.h"
+#include <vgui_controls/Controls.h>
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include <vgui/ILocalize.h>
+#include <KeyValues.h>
+#include "c_baseplayer.h"
+#include "c_team.h"
+
+#include "cs_shareddefs.h"
+#include "clientmode_csnormal.h"
+#include "c_cs_player.h"
+#include "c_cs_playerresource.h"
+
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+const int DOMINATION_DRAW_HEIGHT = 20;
+const int DOMINATION_DRAW_WIDTH = 20;
+
+static ConVar hud_deathnotice_time( "hud_deathnotice_time", "6", 0 );
+
+// Player entries in a death notice
+struct DeathNoticePlayer
+{
+	char		szName[MAX_PLAYER_NAME_LENGTH];
+	char		szClan[MAX_CLAN_TAG_LENGTH];
+	int			iEntIndex;
+	Color		color;
+};
+
+// Contents of each entry in our list of death notices
+struct DeathNoticeItem 
+{
+	DeathNoticePlayer	Killer;
+	DeathNoticePlayer   Victim;
+	CHudTexture *iconDeath;
+	int			iSuicide;
+	float		flDisplayTime;
+	bool		bHeadshot;
+	int			iDominationImageId;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHudDeathNotice : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudDeathNotice, vgui::Panel );
+public:
+	CHudDeathNotice( const char *pElementName );
+
+	void Init( void );
+	void VidInit( void );
+	virtual bool ShouldDraw( void );
+	virtual void Paint( void );
+	virtual void ApplySchemeSettings( vgui::IScheme *scheme );
+
+	void RetireExpiredDeathNotices( void );
+	
+	void FireGameEvent( IGameEvent *event );
+
+protected:
+	int SetupHudImageId( const char* fname );
+
+private:
+
+	CPanelAnimationVarAliasType( float, m_flLineHeight, "LineHeight", "15", "proportional_float" );
+
+	CPanelAnimationVar( float, m_flMaxDeathNotices, "MaxDeathNotices", "4" );
+
+	CPanelAnimationVar( bool, m_bRightJustify, "RightJustify", "1" );
+
+	CPanelAnimationVar( vgui::HFont, m_hTextFont, "TextFont", "HudNumbersTimer" );
+
+	CPanelAnimationVar( Color, m_clrCTText, "CTTextColor", "CTTextColor" );
+	CPanelAnimationVar( Color, m_clrTerroristText, "TerroristTextColor", "TerroristTextColor" );
+
+	// Texture for skull symbol
+	CHudTexture		*m_iconD_skull;  
+	CHudTexture		*m_iconD_headshot;  
+
+	int				m_iNemesisImageId;
+	int				m_iDominatedImageId;
+	int				m_iRevengeImageId;
+
+	Color			m_teamColors[TEAM_MAXCOUNT];
+
+	CUtlVector<DeathNoticeItem> m_DeathNotices;
+};
+
+using namespace vgui;
+
+DECLARE_HUDELEMENT( CHudDeathNotice );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudDeathNotice::CHudDeathNotice( const char *pElementName ) :
+	CHudElement( pElementName ), BaseClass( NULL, "HudDeathNotice" )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	m_iconD_headshot = NULL;
+	m_iconD_skull = NULL;
+
+	SetHiddenBits( HIDEHUD_MISCSTATUS );
+
+	m_iNemesisImageId = SetupHudImageId("hud/freeze_nemesis");
+	m_iDominatedImageId = SetupHudImageId("hud/freeze_dominated");
+	m_iRevengeImageId = SetupHudImageId("hud/freeze_revenge");
+}
+
+
+/**
+ * Helper function to get an image id and set 
+ */
+int CHudDeathNotice::SetupHudImageId( const char* fname )
+{
+	int imageId = surface()->CreateNewTextureID();
+	surface()->DrawSetTextureFile( imageId, fname, true, false );
+	return imageId;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::ApplySchemeSettings( IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+	SetPaintBackgroundEnabled( false );
+
+	// make team color lookups easier
+	memset(m_teamColors, 0, sizeof(m_teamColors));
+	m_teamColors[TEAM_CT] = m_clrCTText;
+	m_teamColors[TEAM_TERRORIST] = m_clrTerroristText;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::Init( void )
+{
+	ListenForGameEvent( "player_death" );	
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::VidInit( void )
+{
+	m_iconD_skull = gHUD.GetIcon( "d_skull_cs" );
+	m_iconD_headshot = gHUD.GetIcon( "d_headshot" );
+	m_DeathNotices.Purge();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw if we've got at least one death notice in the queue
+//-----------------------------------------------------------------------------
+bool CHudDeathNotice::ShouldDraw( void )
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( !pPlayer )
+		return false;
+
+	// don't show death notices when flashed
+	if ( pPlayer->IsAlive() && pPlayer->m_flFlashBangTime >= gpGlobals->curtime )
+	{
+		float flAlpha = pPlayer->m_flFlashMaxAlpha * (pPlayer->m_flFlashBangTime - gpGlobals->curtime) / pPlayer->m_flFlashDuration;
+		if ( flAlpha > 75.0f ) // 0..255
+		{
+			return false;
+		}
+	}
+
+	return ( CHudElement::ShouldDraw() && ( m_DeathNotices.Count() ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::Paint()
+{
+	if ( !m_iconD_headshot || !m_iconD_skull )
+		return;
+
+	int yStart = GetClientModeCSNormal()->GetDeathMessageStartHeight();
+
+	surface()->DrawSetTextFont( m_hTextFont );
+	surface()->DrawSetTextColor( m_clrCTText );
+
+	int dominationDrawWidth = scheme()->GetProportionalScaledValueEx( GetScheme(), DOMINATION_DRAW_WIDTH );
+	int dominationDrawHeight = scheme()->GetProportionalScaledValueEx( GetScheme(), DOMINATION_DRAW_HEIGHT );
+
+	int iconHeadshotWide;
+	int iconHeadshotTall;
+
+	if( m_iconD_headshot->bRenderUsingFont )
+	{
+		iconHeadshotWide = surface()->GetCharacterWidth( m_iconD_headshot->hFont, m_iconD_headshot->cCharacterInFont );
+		iconHeadshotTall = surface()->GetFontTall( m_iconD_headshot->hFont );
+	}
+	else
+	{
+		float scale = ( (float)ScreenHeight() / 480.0f );	//scale based on 640x480
+		iconHeadshotWide = (int)( scale * (float)m_iconD_headshot->Width() );
+		iconHeadshotTall = (int)( scale * (float)m_iconD_headshot->Height() );
+	}
+
+	int iCount = m_DeathNotices.Count();
+	for ( int i = 0; i < iCount; i++ )
+	{
+		CHudTexture *icon = m_DeathNotices[i].iconDeath;
+		if ( !icon )
+			continue;
+
+		wchar_t victim[ 256 ];
+		wchar_t killer[ 256 ];
+		wchar_t victimclan[ 256 ];
+		wchar_t killerclan[ 256 ];
+
+		g_pVGuiLocalize->ConvertANSIToUnicode( m_DeathNotices[i].Victim.szName, victim, sizeof( victim ) );
+		g_pVGuiLocalize->ConvertANSIToUnicode( m_DeathNotices[i].Killer.szName, killer, sizeof( killer ) );
+		g_pVGuiLocalize->ConvertANSIToUnicode( m_DeathNotices[i].Victim.szClan, victimclan, sizeof( victimclan ) );
+		g_pVGuiLocalize->ConvertANSIToUnicode( m_DeathNotices[i].Killer.szClan, killerclan, sizeof( killerclan ) );
+
+		// Get the local position for this notice
+		int victimNameLen = UTIL_ComputeStringWidth( m_hTextFont, victim );
+		int victimClanLen = UTIL_ComputeStringWidth( m_hTextFont, victimclan );
+		int y = yStart + (m_flLineHeight * i);
+
+		int iconWide;
+		int iconTall;
+
+		if( icon->bRenderUsingFont )
+		{
+			iconWide = surface()->GetCharacterWidth( icon->hFont, icon->cCharacterInFont );
+			iconTall = surface()->GetFontTall( icon->hFont );
+		}
+		else
+		{
+			float scale = ( (float)ScreenHeight() / 480.0f );	//scale based on 640x480
+			iconWide = (int)( scale * (float)icon->Width() );
+			iconTall = (int)( scale * (float)icon->Height() );
+		}
+
+		int x = 0;
+		if ( m_bRightJustify )
+		{
+			x =	GetWide();
+			x -= victimNameLen;
+			x -= victimClanLen;
+			x -= iconWide;
+
+			if ( m_DeathNotices[i].bHeadshot )
+				x -= iconHeadshotWide;
+
+			if ( !m_DeathNotices[i].iSuicide )
+			{
+				x -= UTIL_ComputeStringWidth( m_hTextFont, killer );
+				x -= UTIL_ComputeStringWidth( m_hTextFont, killerclan );
+			}
+
+			if (m_DeathNotices[i].iDominationImageId >= 0)
+			{				
+				x -= dominationDrawWidth;
+			}
+		}
+
+		if (m_DeathNotices[i].iDominationImageId >= 0)
+		{			
+			surface()->DrawSetTexture(m_DeathNotices[i].iDominationImageId);
+			surface()->DrawSetColor(m_DeathNotices[i].Killer.color);
+			surface()->DrawTexturedRect( x, y, x + dominationDrawWidth, y + dominationDrawHeight );
+			x += dominationDrawWidth;
+		}
+		
+		// Only draw killers name if it wasn't a suicide
+		if ( !m_DeathNotices[i].iSuicide )
+		{
+			// Draw killer's clan
+			surface()->DrawSetTextColor( m_DeathNotices[i].Killer.color );
+			surface()->DrawSetTextPos( x, y );
+			surface()->DrawSetTextFont( m_hTextFont );
+			surface()->DrawUnicodeString( killerclan );
+			surface()->DrawGetTextPos( x, y );
+
+			// Draw killer's name
+			surface()->DrawSetTextColor( m_DeathNotices[i].Killer.color );
+			surface()->DrawSetTextPos( x, y );
+			surface()->DrawSetTextFont( m_hTextFont );
+			surface()->DrawUnicodeString( killer );
+			surface()->DrawGetTextPos( x, y );
+		}
+
+
+		// Draw death weapon
+		//If we're using a font char, this will ignore iconTall and iconWide
+		Color iconColor( 255, 80, 0, 255 );
+		icon->DrawSelf( x, y, iconWide, iconTall, iconColor );
+		x += iconWide;		
+
+		if( m_DeathNotices[i].bHeadshot )
+		{
+			m_iconD_headshot->DrawSelf( x, y, iconHeadshotWide, iconHeadshotTall, iconColor );
+			x += iconHeadshotWide;
+		}
+
+		// Draw victims clan
+		surface()->DrawSetTextColor( m_DeathNotices[i].Victim.color );
+		surface()->DrawSetTextPos( x, y );
+		surface()->DrawSetTextFont( m_hTextFont );	//reset the font, draw icon can change it
+		surface()->DrawUnicodeString( victimclan );
+		surface()->DrawGetTextPos( x, y );
+
+		// Draw victims name
+		surface()->DrawSetTextColor( m_DeathNotices[i].Victim.color );
+		surface()->DrawSetTextPos( x, y );
+		surface()->DrawSetTextFont( m_hTextFont );	//reset the font, draw icon can change it
+		surface()->DrawUnicodeString( victim );
+	}
+
+	// Now retire any death notices that have expired
+	RetireExpiredDeathNotices();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This message handler may be better off elsewhere
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::RetireExpiredDeathNotices( void )
+{
+	// Loop backwards because we might remove one
+	int iSize = m_DeathNotices.Size();
+	for ( int i = iSize-1; i >= 0; i-- )
+	{
+		if ( m_DeathNotices[i].flDisplayTime < gpGlobals->curtime )
+		{
+			m_DeathNotices.Remove(i);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Server's told us that someone's died
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::FireGameEvent( IGameEvent *event )
+{
+	if (!g_PR)
+		return;
+
+	C_CS_PlayerResource *cs_PR = dynamic_cast<C_CS_PlayerResource *>( g_PR );
+	if ( !cs_PR )
+		return;
+
+	if ( hud_deathnotice_time.GetFloat() == 0 )
+		return;
+
+	// the event should be "player_death"
+	
+	int iKiller = engine->GetPlayerForUserID( event->GetInt("attacker") );
+	int iVictim = engine->GetPlayerForUserID( event->GetInt("userid") );
+	const char *killedwith = event->GetString( "weapon" );
+	bool headshot = event->GetInt( "headshot" ) > 0;
+
+	char fullkilledwith[128];
+	if ( killedwith && *killedwith )
+	{
+		Q_snprintf( fullkilledwith, sizeof(fullkilledwith), "d_%s", killedwith );
+	}
+	else
+	{
+		fullkilledwith[0] = 0;
+	}
+
+	// Do we have too many death messages in the queue?
+	if ( m_DeathNotices.Count() > 0 &&
+		m_DeathNotices.Count() >= (int)m_flMaxDeathNotices )
+	{
+		// Remove the oldest one in the queue, which will always be the first
+		m_DeathNotices.Remove(0);
+	}
+
+	// Get the names of the players
+	const char *killer_name = iKiller > 0 ? g_PR->GetPlayerName( iKiller ) : NULL;
+	const char *victim_name = iVictim > 0 ? g_PR->GetPlayerName( iVictim ) : NULL;
+
+	if ( !killer_name )
+		killer_name = "";
+	if ( !victim_name )
+		victim_name = "";
+
+	// Get the clan tags of the players
+	const char *killer_clan = iKiller > 0 ? cs_PR->GetClanTag( iKiller ) : NULL;
+	const char *victim_clan = iVictim > 0 ? cs_PR->GetClanTag( iVictim ) : NULL;
+
+	if ( !killer_clan )
+		killer_clan = "";
+	if ( !victim_clan )
+		victim_clan = "";
+
+	// Make a new death notice
+	DeathNoticeItem deathMsg;
+	deathMsg.Killer.iEntIndex = iKiller;
+	deathMsg.Victim.iEntIndex = iVictim;
+	deathMsg.Killer.color = iKiller > 0 ? m_teamColors[g_PR->GetTeam(iKiller)] : COLOR_WHITE;
+	deathMsg.Victim.color = iVictim > 0 ? m_teamColors[g_PR->GetTeam(iVictim)] : COLOR_WHITE;
+	Q_snprintf( deathMsg.Killer.szClan, sizeof( deathMsg.Killer.szClan ), "%s ", killer_clan );
+	Q_snprintf( deathMsg.Victim.szClan, sizeof( deathMsg.Victim.szClan ), "%s ", victim_clan );
+	Q_strncpy( deathMsg.Killer.szName, killer_name, MAX_PLAYER_NAME_LENGTH );
+	Q_strncpy( deathMsg.Victim.szName, victim_name, MAX_PLAYER_NAME_LENGTH );
+	deathMsg.flDisplayTime = gpGlobals->curtime + hud_deathnotice_time.GetFloat();
+	deathMsg.iSuicide = ( !iKiller || iKiller == iVictim );
+	deathMsg.bHeadshot = headshot;
+	deathMsg.iDominationImageId = -1;
+
+	CCSPlayer* pKiller = ToCSPlayer(ClientEntityList().GetBaseEntity(iKiller));
+
+	// the local player is dead, see if this is a new nemesis or a revenge
+	if ( event->GetInt( "dominated" ) > 0 || (pKiller != NULL && pKiller->IsPlayerDominated(iVictim)) )
+	{
+		deathMsg.iDominationImageId = m_iDominatedImageId;
+	}
+	else if ( event->GetInt( "revenge" ) > 0 )
+	{
+		deathMsg.iDominationImageId = m_iRevengeImageId;
+	}
+
+	// Try and find the death identifier in the icon list
+	deathMsg.iconDeath = gHUD.GetIcon( fullkilledwith );
+
+	if ( !deathMsg.iconDeath )
+	{
+		// Can't find it, so use the default skull & crossbones icon
+		deathMsg.iconDeath = m_iconD_skull;
+	}
+
+	// Add it to our list of death notices
+	m_DeathNotices.AddToTail( deathMsg );
+
+	char sDeathMsg[512];
+
+	// Record the death notice in the console
+	if ( deathMsg.iSuicide )
+	{
+		if ( !strcmp( fullkilledwith, "d_planted_c4" ) )
+		{
+			Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s was a bit too close to the c4.\n", deathMsg.Victim.szName );
+		}
+		else if ( !strcmp( fullkilledwith, "d_worldspawn" ) )
+		{
+			Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s died.\n", deathMsg.Victim.szName );
+		}
+		else	//d_world
+		{
+			Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s suicided.\n", deathMsg.Victim.szName );
+		}
+	}
+	else
+	{
+		Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s killed %s", deathMsg.Killer.szName, deathMsg.Victim.szName );
+
+		if ( fullkilledwith && *fullkilledwith && (*fullkilledwith > 13 ) )
+		{
+			Q_strncat( sDeathMsg, VarArgs( " with %s.\n", fullkilledwith+2 ), sizeof( sDeathMsg ), COPY_ALL_CHARACTERS );
+		}
+	}
+
+	Msg( "%s", sDeathMsg );
+}
+
+
+
diff --git a/game/client/cstrike/hud_defuser.cpp b/game/client/cstrike/hud_defuser.cpp
new file mode 100644
index 00000000..6245a57d
--- /dev/null
+++ b/game/client/cstrike/hud_defuser.cpp
@@ -0,0 +1,79 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "c_cs_player.h"
+
+class CHudDefuser : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudDefuser, vgui::Panel );
+
+	CHudDefuser( const char *name );
+
+	virtual bool ShouldDraw();	
+	virtual void Paint();
+
+private:
+	CPanelAnimationVar( Color, m_clrIcon, "IconColor", "IconColor" );
+
+	CHudTexture *m_pIcon;
+};
+
+
+DECLARE_HUDELEMENT( CHudDefuser );
+
+
+CHudDefuser::CHudDefuser( const char *pName ) :
+	vgui::Panel( NULL, "HudDefuser" ), CHudElement( pName )
+{
+	SetParent( g_pClientMode->GetViewport() );
+	m_pIcon = NULL;
+
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Add this to the render group that disappears when the scoreboard is up
+	//=============================================================================
+	RegisterForRenderGroup( "hide_for_scoreboard" );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+bool CHudDefuser::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Added base class call
+	//=============================================================================
+	return pPlayer && pPlayer->HasDefuser() && CHudElement::ShouldDraw();
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+void CHudDefuser::Paint()
+{
+	if ( !m_pIcon )
+	{
+		m_pIcon = gHUD.GetIcon( "defuser" );
+	}
+	
+	if ( m_pIcon )
+	{
+		int x, y, w, h;
+		GetBounds( x, y, w, h );
+		
+		m_pIcon->DrawSelf( 0, 0, w, h, m_clrIcon );
+	}
+}
+
diff --git a/game/client/cstrike/hud_flashbang.cpp b/game/client/cstrike/hud_flashbang.cpp
new file mode 100644
index 00000000..3ac3e3c9
--- /dev/null
+++ b/game/client/cstrike/hud_flashbang.cpp
@@ -0,0 +1,57 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "c_cs_player.h"
+#include "materialsystem/imaterialsystemhardwareconfig.h"
+
+class CHudFlashbang : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudFlashbang, vgui::Panel );
+
+	virtual bool ShouldDraw();	
+	virtual void Paint();
+
+	CHudFlashbang( const char *name );
+
+private:
+
+	int m_iAdditiveWhiteID;
+};
+
+
+DECLARE_HUDELEMENT( CHudFlashbang );
+
+
+CHudFlashbang::CHudFlashbang( const char *pName ) :
+	vgui::Panel( NULL, "HudFlashbang" ), CHudElement( pName )
+{
+	SetParent( g_pClientMode->GetViewport() );
+	
+	m_iAdditiveWhiteID = 0;
+
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+}
+
+// the flashbang effect cannot be drawn in the HUD, because this lets the user skip its effect
+// by hitting Escape, or by setting "cl_drawhud 0".
+bool CHudFlashbang::ShouldDraw()
+{
+	return true;
+}
+
+// the flashbang effect cannot be drawn in the HUD, because this lets the user skip its effect
+// by hitting Escape, or by setting "cl_drawhud 0".
+void CHudFlashbang::Paint()
+{
+	return;
+}
+
diff --git a/game/client/cstrike/hud_hostagerescue.cpp b/game/client/cstrike/hud_hostagerescue.cpp
new file mode 100644
index 00000000..64556ece
--- /dev/null
+++ b/game/client/cstrike/hud_hostagerescue.cpp
@@ -0,0 +1,80 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "c_cs_player.h"
+
+class CHudHostageRescueZone : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudHostageRescueZone, vgui::Panel );
+
+	CHudHostageRescueZone( const char *name );
+
+	virtual bool ShouldDraw();	
+	virtual void Paint();
+
+private:
+	CPanelAnimationVar( Color, m_clrIcon, "IconColor", "IconColor" );
+
+	CHudTexture *m_pIcon;
+};
+
+
+DECLARE_HUDELEMENT( CHudHostageRescueZone );
+
+
+CHudHostageRescueZone::CHudHostageRescueZone( const char *pName ) :
+	vgui::Panel( NULL, "HudHostageRescueZone" ), CHudElement( pName )
+{
+	SetParent( g_pClientMode->GetViewport() );
+	m_pIcon = NULL;
+
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Add this to the render group that disappears when the scoreboard is up
+	//=============================================================================
+	RegisterForRenderGroup( "hide_for_scoreboard" );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+bool CHudHostageRescueZone::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Added base class call
+	//=============================================================================
+	return ( pPlayer &&	pPlayer->IsInHostageRescueZone() && CHudElement::ShouldDraw());
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+void CHudHostageRescueZone::Paint()
+{
+	if ( !m_pIcon )
+	{
+		m_pIcon = gHUD.GetIcon( "hostage_rescue" );
+	}
+	
+	if ( m_pIcon )
+	{
+		int x, y, w, h;
+		GetBounds( x, y, w, h );
+
+		m_pIcon->DrawSelf( 0, 0, w, h, m_clrIcon );
+	}
+}
+
diff --git a/game/client/cstrike/hud_progressbar.cpp b/game/client/cstrike/hud_progressbar.cpp
new file mode 100644
index 00000000..b407aead
--- /dev/null
+++ b/game/client/cstrike/hud_progressbar.cpp
@@ -0,0 +1,124 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "c_cs_player.h"
+#include "clientmode_csnormal.h"
+#include "weapon_c4.h"
+
+ConVar cl_c4progressbar( "cl_c4progressbar", "1", 0, "Draw progress bar when defusing the C4" );
+
+class CHudProgressBar : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudProgressBar, vgui::Panel );
+
+	CHudProgressBar( const char *name );
+
+	// vgui overrides
+	virtual void Paint();
+	virtual bool ShouldDraw();
+
+	CPanelAnimationVar( Color, m_clrProgress, "ProgressBarFg", "ProgressBar.FgColor" );
+};
+
+
+DECLARE_HUDELEMENT( CHudProgressBar );
+
+
+CHudProgressBar::CHudProgressBar( const char *name ) :
+	vgui::Panel( NULL, "HudProgressBar" ), CHudElement( name )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetPaintBorderEnabled( false );
+	SetPaintBackgroundEnabled( false );
+	
+	SetHiddenBits( HIDEHUD_PLAYERDEAD | HIDEHUD_WEAPONSELECTION );
+}
+
+void CHudProgressBar::Paint()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
+	{
+		C_BaseEntity *pTarget = pPlayer->GetObserverTarget();
+
+		if( pTarget && pTarget->IsPlayer() )
+		{
+			pPlayer = ToCSPlayer( pTarget );
+
+			if( !pPlayer->IsAlive() )
+				return;
+		}
+		else
+			return;
+	}
+
+	if ( !pPlayer )
+		return;
+
+	int x, y, wide, tall;
+	GetBounds( x, y, wide, tall );
+	
+	tall = 10;
+
+	int xOffset=0;
+	int yOffset=0;
+	
+	Color clr = m_clrProgress;
+
+	clr[3] = 160;
+	vgui::surface()->DrawSetColor( clr );
+	vgui::surface()->DrawOutlinedRect( xOffset, yOffset, xOffset+wide, yOffset+tall );
+
+	if( pPlayer->m_iProgressBarDuration > 0 )
+	{
+		// ProgressBarStartTime is now with respect to m_flSimulationTime rather than local time
+		float percent = (pPlayer->m_flSimulationTime - pPlayer->m_flProgressBarStartTime) / (float)pPlayer->m_iProgressBarDuration;
+		percent = clamp( percent, 0, 1 );
+		
+		clr[3] = 240;
+		vgui::surface()->DrawSetColor( clr );
+		vgui::surface()->DrawFilledRect( xOffset+2, yOffset+2, xOffset+(int)(percent*wide)-2, yOffset+tall-2 );
+	}
+}
+
+
+bool CHudProgressBar::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if( pPlayer && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
+	{
+		C_BaseEntity *pTarget = pPlayer->GetObserverTarget();
+
+		if( pTarget && pTarget->IsPlayer() )
+		{
+			pPlayer = ToCSPlayer( pTarget );
+
+			if( !pPlayer->IsAlive() )
+				return false;
+		}
+		else
+			return false;
+	}
+
+	if( !pPlayer || pPlayer->m_iProgressBarDuration == 0 || pPlayer->m_lifeState == LIFE_DEAD )
+	{
+		return false;
+	}
+
+	return cl_c4progressbar.GetBool();
+}
+
+
+
diff --git a/game/client/cstrike/hud_radar.cpp b/game/client/cstrike/hud_radar.cpp
new file mode 100644
index 00000000..f3368f5d
--- /dev/null
+++ b/game/client/cstrike/hud_radar.cpp
@@ -0,0 +1,522 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "cs_gamerules.h"
+#include "hud_numericdisplay.h"
+#include "voice_status.h"
+#include "c_plantedc4.h"
+#include "weapon_c4.h"
+#include "c_cs_hostage.h"
+#include "c_cs_playerresource.h"
+#include <coordsize.h>
+#include "hud_macros.h"
+#include "vgui/IVGui.h"
+#include "vgui/ILocalize.h"
+#include "mapoverview.h"
+#include "cstrikespectatorgui.h"
+#include "hud_radar.h"
+
+#define RADAR_DOT_NORMAL		0
+#define RADAR_DOT_BOMB			(1<<0)
+#define RADAR_DOT_HOSTAGE		(1<<1)
+#define RADAR_DOT_BOMBCARRIER	(1<<2)
+#define RADAR_DOT_VIP			(1<<3)
+#define RADAR_DOT_LARGE_FLASH	(1<<4)
+#define RADAR_DOT_BOMB_PLANTED	(1<<5)
+#define RADAR_IGNORE_Z			(1<<6)	//always draw this item as if it was at the same Z as the player
+
+extern CUtlVector< CC4* > g_C4s;
+
+ConVar cl_radartype( "cl_radartype", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+ConVar cl_radaralpha( "cl_radaralpha", "200", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, NULL, true, 0, true, 255 );
+ConVar cl_locationalpha( "cl_locationalpha", "150", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, NULL, true, 0, true, 255 );
+
+DECLARE_HUDELEMENT( CHudRadar );
+DECLARE_HUD_MESSAGE( CHudRadar, UpdateRadar );
+
+static CHudRadar *s_Radar = NULL;
+CUtlVector<CPlayerRadarFlash> g_RadarFlashes;
+
+
+CHudRadar::CHudRadar( const char *pName ) :	vgui::Panel( NULL, "HudRadar" ), CHudElement( pName )
+{
+	SetParent( g_pClientMode->GetViewport() );
+
+	m_pBackground = NULL;
+	m_pBackgroundTrans = NULL;
+
+	m_flNextBombFlashTime = 0.0;
+	m_bBombFlash = true;
+
+	m_flNextHostageFlashTime = 0.0;
+	m_bHostageFlash = true;
+	m_bHideRadar = false;
+
+	s_Radar = this;
+
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+
+}
+
+
+CHudRadar::~CHudRadar()
+{
+	s_Radar = NULL;
+}
+
+
+void CHudRadar::Init()
+{
+	HOOK_HUD_MESSAGE( CHudRadar, UpdateRadar );
+}
+
+void CHudRadar::LevelInit()
+{
+	m_flNextBombFlashTime = 0.0;
+	m_bBombFlash = true;
+
+	m_flNextHostageFlashTime = 0.0;
+	m_bHostageFlash = true;
+
+	g_RadarFlashes.RemoveAll();
+
+	// Map Overview handles radar duties now.
+	if( g_pMapOverview )
+		g_pMapOverview->SetMode(CCSMapOverview::MAP_MODE_RADAR);
+}
+
+void CHudRadar::Reset()
+{
+	CHudElement::Reset();
+
+	if( g_pMapOverview )
+		g_pMapOverview->SetMode(CCSMapOverview::MAP_MODE_RADAR);
+}
+
+void CHudRadar::MsgFunc_UpdateRadar(bf_read &msg )
+{
+	int iPlayerEntity = msg.ReadByte();
+
+	//Draw objects on the radar
+	//=============================
+	C_CSPlayer *pLocalPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	if ( !pLocalPlayer )
+		return;
+
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+
+	if ( !pCSPR )
+		return;
+
+	//Players
+	for(int i=1;i<=MAX_PLAYERS;i++)
+	{
+		if( i == pLocalPlayer->entindex() )
+			continue;
+
+		C_CSPlayer *pPlayer =	ToCSPlayer( UTIL_PlayerByIndex(i) );
+
+		if ( pPlayer )
+		{
+			pPlayer->m_bDetected = false;
+		}
+	}
+
+
+	while ( iPlayerEntity > 0 )
+	{
+		int x = msg.ReadSBitLong( COORD_INTEGER_BITS-1 ) * 4;
+		int y = msg.ReadSBitLong( COORD_INTEGER_BITS-1 ) * 4;
+		int z = msg.ReadSBitLong( COORD_INTEGER_BITS-1 ) * 4;
+		int a = msg.ReadSBitLong( 9 );
+
+		C_CSPlayer *pPlayer =	ToCSPlayer( UTIL_PlayerByIndex(iPlayerEntity) );
+
+		Vector origin( x, y, z );
+		QAngle angles( 0, a, 0 );
+
+		if ( g_pMapOverview )
+		{
+			g_pMapOverview->SetPlayerPositions( iPlayerEntity-1, origin, angles );
+		}
+
+		iPlayerEntity = msg.ReadByte(); // read index for next player
+
+		if ( !pPlayer )
+			continue;
+
+		bool bOppositeTeams = (pLocalPlayer->GetTeamNumber() != TEAM_UNASSIGNED && pCSPR->GetTeam( pPlayer->entindex() ) != pLocalPlayer->GetTeamNumber());		
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [tj] This used to do slightly different logic that caused other players
+		//		to twitch while you were observing.
+		//=============================================================================
+		// Don't update players if they are in PVS.
+		if (!pPlayer->IsDormant())
+		{
+			continue;
+		}
+
+		//Don't update players if you are sill alive and they are an enemy.
+		if (bOppositeTeams && !pLocalPlayer->IsObserver())
+		{
+			continue;
+		}
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+		// update origin and angle for players out of my PVS
+		origin = pPlayer->GetAbsOrigin();
+		angles = pPlayer->GetAbsAngles();
+
+		origin.x = x;
+		origin.y = y;
+		angles.y = a;
+
+		pPlayer->SetAbsOrigin( origin );
+		pPlayer->SetAbsAngles( angles );
+		pPlayer->m_bDetected = true;
+	}
+}
+
+
+bool CHudRadar::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Added base class call
+	//=============================================================================
+	return pPlayer && pPlayer->IsAlive() && !m_bHideRadar && CHudElement::ShouldDraw();
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+void CHudRadar::SetVisible(bool state)
+{
+	BaseClass::SetVisible(state);
+
+	if( g_pMapOverview  &&  g_pMapOverview->GetMode() == CCSMapOverview::MAP_MODE_RADAR )
+	{
+		// We are the hud element still, but he is in charge of the new style now.
+		g_pMapOverview->SetVisible( state );		
+	}
+}
+
+void CHudRadar::Paint()
+{
+	// We are the hud element still, but Overview is in charge of the new style now.
+	return;
+}
+
+void CHudRadar::WorldToRadar( const Vector location, const Vector origin, const QAngle angles, float &x, float &y, float &z_delta )
+{
+	float x_diff = location.x - origin.x;
+	float y_diff = location.y - origin.y;
+ 
+	int iRadarRadius = GetWide();		//width of the panel, it resizes now!
+	float fRange = 16 * iRadarRadius;	// radar's range
+
+	float flOffset = atan(y_diff/x_diff);
+	flOffset *= 180;
+	flOffset /= M_PI;
+
+	if ((x_diff < 0) && (y_diff >= 0))
+		flOffset = 180 + flOffset;
+	else if ((x_diff < 0) && (y_diff < 0))
+		flOffset = 180 + flOffset;
+	else if ((x_diff >= 0) && (y_diff < 0))
+		flOffset = 360 + flOffset;
+
+	y_diff = -1*(sqrt((x_diff)*(x_diff) + (y_diff)*(y_diff)));
+	x_diff = 0;
+
+	flOffset = angles.y - flOffset;
+
+	flOffset *= M_PI;
+	flOffset /= 180;		// now theta is in radians
+
+	float xnew_diff = x_diff * cos(flOffset) - y_diff * sin(flOffset);
+	float ynew_diff = x_diff * sin(flOffset) + y_diff * cos(flOffset);
+
+	// The dot is out of the radar's range.. Scale it back so that it appears on the border
+	if ( (-1 * y_diff) > fRange )
+	{
+		float flScale;
+
+		flScale = ( -1 * y_diff) / fRange;
+
+		xnew_diff /= flScale;
+		ynew_diff /= flScale;
+	}
+	xnew_diff /= 32;
+	ynew_diff /= 32;
+
+	//output
+	x = (iRadarRadius/2) + (int)xnew_diff;
+	y = (iRadarRadius/2) + (int)ynew_diff;
+	z_delta = location.z - origin.z;
+}
+
+void CHudRadar::DrawPlayerOnRadar( int iPlayer, C_CSPlayer *pLocalPlayer )
+{
+	float x, y, z_delta;
+	int iBaseDotSize = ScreenWidth() / 256;	
+	int r, g, b, a = 235;
+
+	C_CS_PlayerResource *pCSPR = (C_CS_PlayerResource*)GameResources();
+
+	if ( !pCSPR )
+		return;
+
+	C_CSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iPlayer ) );
+
+	if ( !pPlayer )
+		return;
+
+	bool bOppositeTeams = (pLocalPlayer->GetTeamNumber() != TEAM_UNASSIGNED && pCSPR->GetTeam( iPlayer ) != pLocalPlayer->GetTeamNumber());
+
+	if ( bOppositeTeams && pPlayer->m_bDetected == false )
+		return;
+
+	
+	WorldToRadar( pPlayer->GetAbsOrigin(), pLocalPlayer->GetAbsOrigin(), pLocalPlayer->LocalEyeAngles(), x, y, z_delta );
+
+	if( pCSPR->HasC4( iPlayer ) || pCSPR->IsVIP( iPlayer ) || bOppositeTeams )
+	{
+		r = 250; g = 0; b = 0;
+	}
+	else if ( 0 /*m_bTrackArray[i-1] == true */ )		// Tracked players (friends we want to keep track of on the radar)
+	{
+		iBaseDotSize *= 2;
+		r = 185; g = 20; b = 20;
+	}
+	else
+	{
+		r = 75; g = 75; b = 250;
+	}
+
+	// Handle the radio flashes
+	bool bRadarFlash = false;
+	if ( g_RadarFlashes.Count() > iPlayer )
+		bRadarFlash = g_RadarFlashes[iPlayer].m_bRadarFlash && g_RadarFlashes[iPlayer].m_iNumRadarFlashes > 0;
+
+	if ( bRadarFlash || GetClientVoiceMgr()->IsPlayerSpeaking( iPlayer ) )
+	{
+		r = 230; g = 110; b = 25; a = 245; 
+
+		DrawRadarDot( x, y, z_delta, iBaseDotSize, RADAR_DOT_LARGE_FLASH, r, g, b, a );
+	}
+	else
+	{
+		DrawRadarDot( x, y, z_delta, iBaseDotSize, RADAR_DOT_NORMAL, r, g, b, a );
+	}
+}
+
+
+void CHudRadar::DrawEntityOnRadar( CBaseEntity *pEnt, C_CSPlayer *pLocalPlayer, int flags, int r, int g, int b, int a )
+{
+	float x, y, z_delta;
+	int iBaseDotSize = 4;
+
+	WorldToRadar( pEnt->GetAbsOrigin(), pLocalPlayer->GetAbsOrigin(), pLocalPlayer->LocalEyeAngles(), x, y, z_delta );
+
+	if( flags & RADAR_IGNORE_Z )
+		z_delta = 0;
+
+	DrawRadarDot( x, y, z_delta, iBaseDotSize, flags, r, g, b, a );
+}
+
+void CHudRadar::FillRect( int x, int y, int w, int h )
+{
+	int panel_x, panel_y, panel_w, panel_h;
+	GetBounds( panel_x, panel_y, panel_w, panel_h );
+	vgui::surface()->DrawFilledRect( x, y, x+w, y+h );
+}
+
+void CHudRadar::DrawRadarDot( int x, int y, float z_diff, int iBaseDotSize, int flags, int r, int g, int b, int a )
+{
+	vgui::surface()->DrawSetColor( r, g, b, a );
+
+	if ( flags & RADAR_DOT_LARGE_FLASH )
+	{
+		FillRect( x-1, y-1, iBaseDotSize+1, iBaseDotSize+1 );
+	}
+	else if ( z_diff < -128 ) // below the player
+	{
+		z_diff *= -1;
+
+		if ( z_diff > 3096 )
+		{
+			z_diff = 3096;
+		}
+
+		int iBar = (int)( z_diff / 400 ) + 2;
+
+		// Draw an upside-down T shape to symbolize the dot is below the player.
+
+		iBaseDotSize /= 2;
+
+		//horiz
+		FillRect( x-(2*iBaseDotSize), y, 5*iBaseDotSize, iBaseDotSize );
+
+		//vert
+		FillRect( x, y - iBar*iBaseDotSize, iBaseDotSize, iBar*iBaseDotSize );
+	}
+	else if ( z_diff > 128 ) // above the player
+	{
+		if ( z_diff > 3096 )
+		{
+			z_diff = 3096;
+		}
+
+		int iBar = (int)( z_diff / 400 ) + 2;
+
+		iBaseDotSize /= 2;
+		
+		// Draw a T shape to symbolize the dot is above the player.
+
+		//horiz
+		FillRect( x-(2*iBaseDotSize), y, 5*iBaseDotSize, iBaseDotSize );
+
+		//vert
+		FillRect( x, y, iBaseDotSize, iBar*iBaseDotSize );
+	}
+	else 
+	{
+		if ( flags & RADAR_DOT_HOSTAGE )
+		{
+			FillRect( x-1, y-1, iBaseDotSize+1, iBaseDotSize+1 );
+		}
+		else if ( flags & RADAR_DOT_BOMB )
+		{
+			if ( flags & RADAR_DOT_BOMB_PLANTED )
+			{
+				iBaseDotSize = 2;
+				// draw an X for the planted bomb
+				FillRect( x, y, iBaseDotSize, iBaseDotSize );
+				FillRect( x-2, y-2, iBaseDotSize, iBaseDotSize );
+				FillRect( x-2, y+2, iBaseDotSize, iBaseDotSize );	
+				FillRect( x+2, y-2, iBaseDotSize, iBaseDotSize );
+				FillRect( x+2, y+2, iBaseDotSize, iBaseDotSize );
+			}
+			else
+			{
+				FillRect( x-1, y-1, iBaseDotSize+1, iBaseDotSize+1 );
+			}
+		}
+		else
+		{
+			FillRect( x, y, iBaseDotSize, iBaseDotSize );
+		}
+	}
+}
+
+
+void Radar_FlashPlayer( int iPlayer )
+{
+	if ( g_RadarFlashes.Count() <= iPlayer )
+	{
+		g_RadarFlashes.AddMultipleToTail( iPlayer - g_RadarFlashes.Count() + 1 );
+	}
+
+	CPlayerRadarFlash *pFlash = &g_RadarFlashes[iPlayer];
+	pFlash->m_flNextRadarFlashTime = gpGlobals->curtime;
+	pFlash->m_iNumRadarFlashes = 16;
+	pFlash->m_bRadarFlash = false;
+
+	g_pMapOverview->FlashEntity(iPlayer);
+}
+
+CON_COMMAND( drawradar, "Draws HUD radar" )
+{
+	(GET_HUDELEMENT( CHudRadar ))->DrawRadar();
+}
+
+CON_COMMAND( hideradar, "Hides HUD radar" )
+{
+	(GET_HUDELEMENT( CHudRadar ))->HideRadar();
+}
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+// Location text under radar
+
+DECLARE_HUDELEMENT( CHudLocation );
+
+CHudLocation::CHudLocation( const char *pName ) :	vgui::Label( NULL, "HudLocation", "" ), CHudElement( pName )
+{
+	SetParent( g_pClientMode->GetViewport() );
+}
+
+void CHudLocation::Init()
+{
+	// Make sure we get ticked...
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+}
+
+void CHudLocation::LevelInit()
+{
+}
+
+bool CHudLocation::ShouldDraw()
+{
+	CCSMapOverview *pCSMapOverview = (CCSMapOverview *)GET_HUDELEMENT( CCSMapOverview );
+
+	if( g_pMapOverview && g_pMapOverview->GetMode() == CMapOverview::MAP_MODE_RADAR && pCSMapOverview && pCSMapOverview->ShouldDraw() == true )
+		return true;
+	else if( g_pMapOverview && g_pMapOverview->GetMode() == CMapOverview::MAP_MODE_INSET )	
+		return true;
+
+	return false;
+}
+
+void CHudLocation::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	m_fgColor = Color( 64, 255, 64, 255 );
+	SetFont( pScheme->GetFont( "ChatFont" ) );
+	SetBorder( NULL );
+	SetBgColor( Color( 0, 0, 0, 0 ) );
+	SetFgColor( m_fgColor );
+}
+
+void CHudLocation::OnTick()
+{
+	m_fgColor[3] = cl_locationalpha.GetInt();
+	SetFgColor( m_fgColor );
+
+	const char *pszLocation = "";
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer )
+	{
+		pszLocation = pPlayer->GetLastKnownPlaceName();
+	}
+	SetText( g_pVGuiLocalize->Find( pszLocation ) );
+
+	// We have two different locations based on the Overview mode.
+	// So we just position ourselves below, and center our text in their width.
+	if( g_pMapOverview )
+	{
+		int x = 0, y = 0;
+		int width = 0, height = 0;
+		g_pMapOverview->GetAsPanel()->GetPos( x, y );
+		g_pMapOverview->GetAsPanel()->GetSize( width, height );
+		y += g_pMapOverview->GetAsPanel()->GetTall();
+		SetPos( x, y );
+		SetWide( width );
+	}
+}
diff --git a/game/client/cstrike/hud_radar.h b/game/client/cstrike/hud_radar.h
new file mode 100644
index 00000000..95f7db38
--- /dev/null
+++ b/game/client/cstrike/hud_radar.h
@@ -0,0 +1,93 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HUD_RADAR_H
+#define HUD_RADAR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/Label.h>
+
+class C_CSPlayer;
+void Radar_FlashPlayer( int iPlayer );
+
+class CPlayerRadarFlash
+{
+public:
+	CPlayerRadarFlash()
+	{
+		m_flNextRadarFlashTime = 0.0f;
+		m_iNumRadarFlashes = 0;
+		m_bRadarFlash = false;
+	}
+	float m_flNextRadarFlashTime;	// when to next toggle the flash on the radar
+	int	m_iNumRadarFlashes;			// how many flashes more to do
+	bool m_bRadarFlash;				// flash or do not, there is no try
+};
+
+
+class CHudRadar : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudRadar, vgui::Panel );
+
+	CHudRadar( const char *name );
+	~CHudRadar();
+
+	virtual void Paint();
+	virtual void Init();
+	virtual void LevelInit();
+	virtual bool ShouldDraw();
+	virtual void SetVisible(bool state);
+	virtual void Reset();
+
+	void DrawRadar(void) { m_bHideRadar = false; }
+	void HideRadar(void) { m_bHideRadar = true; }
+	void MsgFunc_UpdateRadar(bf_read &msg );
+
+private:
+
+	void WorldToRadar( const Vector location, const Vector origin, const QAngle angles, float &x, float &y, float &z_delta );
+
+	void DrawPlayerOnRadar( int iPlayer, C_CSPlayer *pLocalPlayer );
+	void DrawEntityOnRadar( CBaseEntity *pEnt, C_CSPlayer *pLocalPlayer, int flags, int r, int g, int b, int a );
+
+	void FillRect( int x, int y, int w, int h );
+	void DrawRadarDot( int x, int y, float z_diff, int iBaseDotSize, int flags, int r, int g, int b, int a );
+
+	CHudTexture *m_pBackground;
+	CHudTexture *m_pBackgroundTrans;
+
+	float m_flNextBombFlashTime;
+	bool m_bBombFlash;
+
+	float m_flNextHostageFlashTime;
+	bool m_bHostageFlash;
+	bool m_bHideRadar;
+};
+
+class CHudLocation : public CHudElement, public vgui::Label
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudLocation, vgui::Panel );
+
+	CHudLocation( const char *name );
+
+	virtual void Init();
+	virtual void LevelInit();
+	virtual bool ShouldDraw();
+
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	virtual void OnTick( void );
+
+private:
+	Color m_fgColor;
+};
+
+#endif // HUD_RADAR_H
diff --git a/game/client/cstrike/hud_roundtimer.cpp b/game/client/cstrike/hud_roundtimer.cpp
new file mode 100644
index 00000000..cdcc564c
--- /dev/null
+++ b/game/client/cstrike/hud_roundtimer.cpp
@@ -0,0 +1,233 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "cs_gamerules.h"
+#include "hud_basetimer.h"
+#include "hud_bitmapnumericdisplay.h"
+#include "c_plantedc4.h"
+
+#include <vgui_controls/AnimationController.h>
+
+class CHudRoundTimer : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudRoundTimer, vgui::Panel );
+
+	CHudRoundTimer( const char *name );
+
+protected:	
+	virtual void Paint();
+	virtual void Think();
+	virtual bool ShouldDraw();
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+
+	void PaintTime(HFont font, int xpos, int ypos, int mins, int secs);
+
+private:
+	float m_flToggleTime;
+	float m_flNextToggle;
+	CHudTexture *m_pTimerIcon;
+	bool m_bFlash;
+
+	int m_iAdditiveWhiteID;
+
+	CPanelAnimationVar( Color, m_FlashColor, "FlashColor", "Panel.FgColor" );
+
+	CPanelAnimationVarAliasType( float, icon_xpos, "icon_xpos", "0", "proportional_float" );
+	CPanelAnimationVarAliasType( float, icon_ypos, "icon_ypos", "0", "proportional_float" );
+
+	CPanelAnimationVar( Color, m_TextColor, "TextColor", "Panel.FgColor" );
+	CPanelAnimationVar( vgui::HFont, m_hNumberFont, "NumberFont", "HudNumbers" );
+	CPanelAnimationVarAliasType( float, digit_xpos, "digit_xpos", "50", "proportional_float" );
+	CPanelAnimationVarAliasType( float, digit_ypos, "digit_ypos", "2", "proportional_float" );
+
+	float icon_tall;
+	float icon_wide;
+};
+
+
+DECLARE_HUDELEMENT( CHudRoundTimer );
+
+
+CHudRoundTimer::CHudRoundTimer( const char *pName ) :
+	BaseClass( NULL, "HudRoundTimer" ), CHudElement( pName )
+{
+	m_iAdditiveWhiteID = vgui::surface()->CreateNewTextureID();
+	vgui::surface()->DrawSetTextureFile( m_iAdditiveWhiteID, "vgui/white_additive" , true, false);
+
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+}
+
+void CHudRoundTimer::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	m_pTimerIcon = gHUD.GetIcon( "timer_icon" );
+
+	if( m_pTimerIcon )
+	{
+		icon_tall = GetTall() - YRES(2);
+		float scale = icon_tall / (float)m_pTimerIcon->Height();
+		icon_wide = ( scale ) * (float)m_pTimerIcon->Width();
+	}
+
+	SetFgColor( m_TextColor );
+
+	BaseClass::ApplySchemeSettings( pScheme );
+}
+
+bool CHudRoundTimer::ShouldDraw()
+{
+	//necessary?
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( pPlayer )
+	{
+		return !pPlayer->IsObserver();
+	}
+
+	return false;
+}
+
+void CHudRoundTimer::Think()
+{
+	C_CSGameRules *pRules = CSGameRules();
+	if ( !pRules )
+		return;
+
+	int timer = (int)ceil( pRules->GetRoundRemainingTime() );
+
+	if ( pRules->IsFreezePeriod() )
+	{
+		// in freeze period countdown to round start time
+		timer = (int)ceil(pRules->GetRoundStartTime()-gpGlobals->curtime);
+	}
+
+	//If the bomb is planted don't draw -- the timer is irrelevant
+	SetVisible(g_PlantedC4s.Count() == 0);
+
+	if(timer > 30)
+	{
+		SetFgColor(m_TextColor);
+		return;
+	}
+	
+	if(timer <= 0)
+	{
+		timer = 0;
+		SetFgColor(m_FlashColor);
+		return;
+	}
+
+	if(gpGlobals->curtime > m_flNextToggle)
+	{
+		if( timer <= 0)
+		{
+			m_bFlash = true;
+		}
+		else if( timer <= 2)
+		{
+			m_flToggleTime = gpGlobals->curtime;
+			m_flNextToggle = gpGlobals->curtime + 0.05;
+			m_bFlash = !m_bFlash;
+		}
+		else if( timer <= 5)
+		{
+			m_flToggleTime = gpGlobals->curtime;
+			m_flNextToggle = gpGlobals->curtime + 0.1;
+			m_bFlash = !m_bFlash;
+		}
+		else if( timer <= 10)
+		{
+			m_flToggleTime = gpGlobals->curtime;
+			m_flNextToggle = gpGlobals->curtime + 0.2;
+			m_bFlash = !m_bFlash;
+		}
+		else if( timer <= 20)
+		{
+			m_flToggleTime = gpGlobals->curtime;
+			m_flNextToggle = gpGlobals->curtime + 0.4;
+			m_bFlash = !m_bFlash;
+		}
+		else if( timer <= 30)
+		{
+			m_flToggleTime = gpGlobals->curtime;
+			m_flNextToggle = gpGlobals->curtime + 0.8;
+			m_bFlash = !m_bFlash;
+		}
+		else
+			m_bFlash = false;
+	}
+
+	Color startValue, endValue;
+	Color interp_color;
+
+	if( m_bFlash )
+	{
+		startValue = m_FlashColor;
+		endValue = m_TextColor;
+	}
+	else
+	{
+		startValue = m_TextColor;
+		endValue = m_FlashColor;
+	}
+
+	float pos = (gpGlobals->curtime - m_flToggleTime) / (m_flNextToggle - m_flToggleTime);
+	pos = clamp( SimpleSpline( pos ), 0, 1 );
+
+	interp_color[0] = ((endValue[0] - startValue[0]) * pos) + startValue[0];
+	interp_color[1] = ((endValue[1] - startValue[1]) * pos) + startValue[1];
+	interp_color[2] = ((endValue[2] - startValue[2]) * pos) + startValue[2];
+	interp_color[3] = ((endValue[3] - startValue[3]) * pos) + startValue[3];
+
+	SetFgColor(interp_color);
+}
+
+void CHudRoundTimer::Paint()
+{
+	// Update the time.
+	C_CSGameRules *pRules = CSGameRules();
+	if ( !pRules )
+		return;
+
+	int timer = (int)ceil( pRules->GetRoundRemainingTime() );
+
+	if ( pRules->IsFreezePeriod() )
+	{
+		// in freeze period countdown to round start time
+		timer = (int)ceil(pRules->GetRoundStartTime()-gpGlobals->curtime);
+	}
+	
+	if(timer < 0) 
+		timer = 0;
+		
+	int minutes = timer / 60;
+	int seconds = timer % 60;
+
+	//Draw Timer icon
+	if( m_pTimerIcon )
+	{
+		m_pTimerIcon->DrawSelf( icon_xpos, icon_ypos, icon_wide, icon_tall, GetFgColor() );
+	}
+
+	PaintTime( m_hNumberFont, digit_xpos, digit_ypos, minutes, seconds );
+}
+
+void CHudRoundTimer::PaintTime(HFont font, int xpos, int ypos, int mins, int secs)
+{
+	surface()->DrawSetTextFont(font);
+	wchar_t unicode[6];
+	V_snwprintf(unicode, ARRAYSIZE(unicode), L"%d:%.2d", mins, secs);
+	
+	surface()->DrawSetTextPos(xpos, ypos);
+	surface()->DrawUnicodeString( unicode );
+}
diff --git a/game/client/cstrike/hud_scenarioicon.cpp b/game/client/cstrike/hud_scenarioicon.cpp
new file mode 100644
index 00000000..379a1f79
--- /dev/null
+++ b/game/client/cstrike/hud_scenarioicon.cpp
@@ -0,0 +1,109 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "c_cs_player.h"
+#include "cs_gamerules.h"
+
+#include "c_cs_hostage.h"
+#include "c_plantedc4.h"
+
+class CHudScenarioIcon : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudScenarioIcon, vgui::Panel );
+
+	CHudScenarioIcon( const char *name );
+
+	virtual bool ShouldDraw();	
+	virtual void Paint();
+
+private:
+	CPanelAnimationVar( Color, m_clrIcon, "IconColor", "IconColor" );	
+
+	CHudTexture *m_pC4Icon;
+	CHudTexture *m_pHostageIcon;
+};
+
+
+DECLARE_HUDELEMENT( CHudScenarioIcon );
+
+
+CHudScenarioIcon::CHudScenarioIcon( const char *pName ) :
+	vgui::Panel( NULL, "HudScenarioIcon" ), CHudElement( pName )
+{
+	SetParent( g_pClientMode->GetViewport() );
+	m_pC4Icon = NULL;
+	m_pHostageIcon = NULL;
+
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+}
+
+bool CHudScenarioIcon::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	return pPlayer && pPlayer->IsAlive();
+}
+
+void CHudScenarioIcon::Paint()
+{
+	// If there is a bomb planted, draw that
+	if( g_PlantedC4s.Count() > 0 )
+	{
+		if ( !m_pC4Icon )
+		{
+			m_pC4Icon = gHUD.GetIcon( "scenario_c4" );
+		}
+
+		if ( m_pC4Icon )
+		{
+			int x, y, w, h;
+			GetBounds( x, y, w, h );
+
+			C_PlantedC4 *pC4 = g_PlantedC4s[0];
+
+			Color c = m_clrIcon;
+
+			c[3] = 80;
+
+			if( pC4->m_flNextGlow - gpGlobals->curtime < 0.1 )
+			{
+				c[3] = 255;
+			}
+
+			if( pC4->IsBombActive() )
+				m_pC4Icon->DrawSelf( 0, 0, h, h, c );	//draw it square!
+		}
+	}
+
+	CCSGameRules *pRules = CSGameRules();
+
+	// If there are hostages, draw how many there are
+	if( pRules && pRules->GetNumHostagesRemaining() )
+	{
+		if ( !m_pHostageIcon )
+		{
+			m_pHostageIcon = gHUD.GetIcon( "scenario_hostage" );
+		}
+
+		if( m_pHostageIcon )
+		{
+			int xpos = 0;
+			int iconWidth = m_pHostageIcon->Width();
+
+			for(int i=0;i<pRules->GetNumHostagesRemaining();i++)
+			{
+				m_pHostageIcon->DrawSelf( xpos, 0, m_clrIcon );
+				xpos += iconWidth;
+			}
+		}
+	}
+}
+
diff --git a/game/client/cstrike/hud_shopping_cart.cpp b/game/client/cstrike/hud_shopping_cart.cpp
new file mode 100644
index 00000000..f35fd120
--- /dev/null
+++ b/game/client/cstrike/hud_shopping_cart.cpp
@@ -0,0 +1,94 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/ISurface.h>
+#include "clientmode_csnormal.h"
+#include "cs_gamerules.h"
+#include "hud_numericdisplay.h"
+#include <vgui_controls/AnimationController.h>
+
+
+class CHudShoppingCart : public CHudElement, public vgui::Panel
+{
+public:
+	DECLARE_CLASS_SIMPLE( CHudShoppingCart, vgui::Panel );
+
+	CHudShoppingCart( const char *name );
+
+	virtual bool ShouldDraw();	
+	virtual void Paint();
+	virtual void Init();
+
+
+private:
+	CPanelAnimationVar( Color, m_clrIcon, "IconColor", "IconColor" );
+
+	CHudTexture *m_pCartIcon;
+	bool		m_bPrevState;
+};
+
+
+DECLARE_HUDELEMENT( CHudShoppingCart );
+
+
+CHudShoppingCart::CHudShoppingCart( const char *pName ) :
+	vgui::Panel( NULL, "HudShoppingCart" ), CHudElement( pName )
+{
+	SetParent( g_pClientMode->GetViewport() );
+	m_pCartIcon = NULL;
+	
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Add this to the render group that disappears when the scoreboard is up
+	//=============================================================================
+	RegisterForRenderGroup( "hide_for_scoreboard" );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+
+void CHudShoppingCart::Init()
+{
+}
+
+
+bool CHudShoppingCart::ShouldDraw()
+{
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Added base class call
+	//=============================================================================
+	return ( pPlayer && pPlayer->IsInBuyZone() && !CSGameRules()->IsBuyTimeElapsed() && CHudElement::ShouldDraw() );
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+
+void CHudShoppingCart::Paint()
+{
+	if ( !m_pCartIcon )
+	{
+		m_pCartIcon = gHUD.GetIcon( "shopping_cart" );
+	}
+	
+	if ( m_pCartIcon )
+	{
+		int x, y, w, h;
+		GetBounds( x, y, w, h );
+
+		m_pCartIcon->DrawSelf( 0, 0, w, h, m_clrIcon );
+	}
+}
+
diff --git a/game/client/cstrike/radio_status.cpp b/game/client/cstrike/radio_status.cpp
new file mode 100644
index 00000000..6c50788e
--- /dev/null
+++ b/game/client/cstrike/radio_status.cpp
@@ -0,0 +1,421 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include <string.h>
+#include <stdio.h>
+#include "voice_status.h"
+#include "radio_status.h"
+#include "c_playerresource.h"
+#include "cliententitylist.h"
+#include "c_baseplayer.h"
+#include "materialsystem/imesh.h"
+#include "view.h"
+#include "materialsystem/imaterial.h"
+#include "tier0/dbg.h"
+#include "cdll_int.h"
+#include "c_cs_player.h"
+#include "menu.h" // for CHudMenu defs
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+using namespace vgui;
+
+// ---------------------------------------------------------------------- //
+// The radio feedback manager for the client.
+// ---------------------------------------------------------------------- //
+static CRadioStatus s_RadioStatus;
+
+//
+//-----------------------------------------------------
+//
+
+// Stuff for the Radio Menus
+static void radio1_f( void );
+static void radio2_f( void );
+static void radio3_f( void );
+
+static ConCommand radio1( "radio1", radio1_f, "Opens a radio menu" );
+static ConCommand radio2( "radio2", radio2_f, "Opens a radio menu" );
+static ConCommand radio3( "radio3", radio3_f, "Opens a radio menu" );
+static int g_whichMenu = 0;
+
+//
+//--------------------------------------------------------------
+//
+// These methods will bring up the radio menus from the client side.
+// They mimic the old server commands of the same name, which used
+// to require a round-trip causing latency and unreliability in 
+// menu responses.  Only 1 message is sent to the server now which
+// includes both the menu name and the selected item.  The server
+// is never informed that the menu has been displayed.
+//
+//--------------------------------------------------------------
+//
+void OpenRadioMenu( int index )
+{
+	// do not show the menu if the player is dead or is an observer
+	C_CSPlayer *pPlayer = C_CSPlayer::GetLocalCSPlayer();
+	if ( !pPlayer )
+		return;
+
+	if ( !pPlayer->IsAlive() || pPlayer->IsObserver() )
+		return;
+
+	CHudMenu *pMenu = (CHudMenu *) gHUD.FindElement( "CHudMenu" );
+	if ( !pMenu )
+		return;
+
+	g_whichMenu = index;
+
+	//
+	// the 0x23f and 0x3ff are masks that describes the keys that
+	// are valid.  This will have to be changed if the menus change.
+	//
+	switch ( index )
+	{
+	case 1:
+		pMenu->ShowMenu( "#RadioA", 0x23f );
+		break;
+	case 2:
+		pMenu->ShowMenu( "#RadioB", 0x23f );
+		break;
+	case 3:
+		pMenu->ShowMenu( "#RadioC", 0x3ff );
+		break;
+	default:
+		g_whichMenu = 0;
+	}
+}
+
+static void radio1_f( void )
+{
+	OpenRadioMenu( 1 );
+}
+
+static void radio2_f( void )
+{
+	OpenRadioMenu( 2 );
+}
+
+static void radio3_f( void )
+{
+	OpenRadioMenu( 3 );
+}
+
+CON_COMMAND_F( menuselect, "menuselect", FCVAR_CLIENTCMD_CAN_EXECUTE )
+{
+	if ( args.ArgC() < 2 )
+		return;
+
+	if( g_whichMenu == 0 )
+	{
+		// if we didn't have a menu open, maybe a plugin did.  send it on to the server.
+		const char *cmd = VarArgs( "menuselect %s", args[1] );
+		engine->ServerCmd( cmd );
+		return;
+	}
+
+	int whichEntry = atoi( args[ 1 ] );
+
+	switch( g_whichMenu )
+	{
+		case 1: //RadioA
+		{
+			switch( whichEntry )
+			{
+			case 1: // coverme
+				engine->ClientCmd( "coverme" );
+				break;
+			case 2: // takepoint
+				engine->ClientCmd( "takepoint" );
+				break;
+			case 3: // holdpos
+				engine->ClientCmd( "holdpos" );
+				break;
+			case 4: // regroup
+				engine->ClientCmd( "regroup" );
+				break;
+			case 5: // followme
+				engine->ClientCmd( "followme" );
+				break;
+			case 6: // takingfire
+				engine->ClientCmd( "takingfire" );
+				break;
+			}
+		}
+		break;
+
+		case 2: //RadioB
+		{
+			switch( whichEntry )
+			{
+			case 1: // go
+				engine->ClientCmd( "go" );
+				break;
+			case 2: // fallback
+				engine->ClientCmd( "fallback" );
+				break;
+			case 3: // sticktog
+				engine->ClientCmd( "sticktog" );
+				break;
+			case 4: // getinpos
+				engine->ClientCmd( "getinpos" );
+				break;
+			case 5: // stormfront
+				engine->ClientCmd( "stormfront" );
+				break;
+			case 6: // report
+				engine->ClientCmd( "report" );
+				break;
+			}
+		}
+		break;
+
+		case 3: //RadioC
+		{
+			switch( whichEntry )
+			{
+			case 1: // roger
+				engine->ClientCmd( "roger" );
+				break;
+			case 2: // enemyspot
+				engine->ClientCmd( "enemyspot" );
+				break;
+			case 3: // needbackup
+				engine->ClientCmd( "needbackup" );
+				break;
+			case 4: // sectorclear
+				engine->ClientCmd( "sectorclear" );
+				break;
+			case 5: // inposition
+				engine->ClientCmd( "inposition" );
+				break;
+			case 6: // reportingin
+				engine->ClientCmd( "reportingin" );
+				break;
+			case 7: // getout
+				engine->ClientCmd( "getout" );
+				break;
+			case 8: // negative
+				engine->ClientCmd( "negative" );
+				break;
+			case 9: // enemydown
+				engine->ClientCmd( "enemydown" );
+				break;
+			}
+		}
+		break;
+
+		default:
+			// if we didn't have a menu open, maybe a plugin did.  send it on to the server.
+			const char *cmd = VarArgs( "menuselect %d", whichEntry );
+			engine->ServerCmd( cmd );
+			break;
+	}
+
+	// reset menu
+	g_whichMenu = 0;
+}
+
+//
+//-----------------------------------------------------
+//
+
+CRadioStatus* RadioManager()
+{
+	return &s_RadioStatus;
+}
+
+
+// ---------------------------------------------------------------------- //
+// CRadioStatus.
+// ---------------------------------------------------------------------- //
+
+CRadioStatus::CRadioStatus()
+{
+	m_pHeadLabelMaterial = NULL;
+	Q_memset(m_radioUntil, 0, sizeof(m_radioUntil));
+	Q_memset(m_voiceUntil, 0, sizeof(m_voiceUntil));
+}
+
+bool CRadioStatus::Init()
+{
+	if ( !m_pHeadLabelMaterial )
+	{
+		m_pHeadLabelMaterial = materials->FindMaterial( "sprites/radio", TEXTURE_GROUP_VGUI );
+	}
+
+	if ( IsErrorMaterial( m_pHeadLabelMaterial ) )
+		return false;
+
+	m_pHeadLabelMaterial->IncrementReferenceCount();
+
+	return true;
+}
+
+void CRadioStatus::Shutdown()
+{
+	if ( m_pHeadLabelMaterial )
+		m_pHeadLabelMaterial->DecrementReferenceCount();
+
+	m_pHeadLabelMaterial = NULL;		
+}
+
+void CRadioStatus::LevelInitPostEntity()
+{
+	ExpireBotVoice( true );
+	Q_memset(m_radioUntil, 0, sizeof(m_radioUntil));
+	Q_memset(m_voiceUntil, 0, sizeof(m_voiceUntil));
+}
+
+void CRadioStatus::LevelShutdownPreEntity()
+{
+	ExpireBotVoice( true );
+	Q_memset(m_radioUntil, 0, sizeof(m_radioUntil));
+	Q_memset(m_voiceUntil, 0, sizeof(m_voiceUntil));
+}
+
+extern float g_flHeadIconSize;
+
+static float s_flHeadOffset = 3;
+static float s_flHeadIconSize = 7;
+
+void CRadioStatus::DrawHeadLabels()
+{
+	ExpireBotVoice();
+
+	if( !m_pHeadLabelMaterial )
+		return;
+
+	for(int i=0; i < VOICE_MAX_PLAYERS; i++)
+	{
+		if ( m_radioUntil[i] < gpGlobals->curtime )
+			continue;
+
+		IClientNetworkable *pClient = cl_entitylist->GetClientEntity( i+1 );
+		
+		// Don't show an icon if the player is not in our PVS.
+		if ( !pClient || pClient->IsDormant() )
+			continue;
+
+		C_BasePlayer *pPlayer = dynamic_cast<C_BasePlayer*>(pClient);
+		if( !pPlayer )
+			continue;
+
+		// Don't show an icon for dead or spectating players (ie: invisible entities).
+		if( pPlayer->IsPlayerDead() )
+			continue;
+
+		// Place it above his head.
+		Vector vOrigin = pPlayer->WorldSpaceCenter();
+		vOrigin.z += GetClientVoiceMgr()->GetHeadLabelOffset() + s_flHeadOffset;
+
+		if ( GetClientVoiceMgr()->IsPlayerSpeaking( i+1 ) )
+		{
+			vOrigin.z += g_flHeadIconSize;
+		}
+		
+		// Align it so it never points up or down.
+		Vector vUp( 0, 0, 1 );
+		Vector vRight = CurrentViewRight();
+		if ( fabs( vRight.z ) > 0.95 )	// don't draw it edge-on
+			continue;
+
+		vRight.z = 0;
+		VectorNormalize( vRight );
+
+
+		float flSize = s_flHeadIconSize;
+
+		CMatRenderContextPtr pRenderContext( materials );
+
+		pRenderContext->Bind( m_pHeadLabelMaterial );
+		IMesh *pMesh = pRenderContext->GetDynamicMesh();
+		CMeshBuilder meshBuilder;
+		meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
+
+		meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+		meshBuilder.TexCoord2f( 0,0,0 );
+		meshBuilder.Position3fv( (vOrigin + (vRight * -flSize) + (vUp * flSize)).Base() );
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+		meshBuilder.TexCoord2f( 0,1,0 );
+		meshBuilder.Position3fv( (vOrigin + (vRight * flSize) + (vUp * flSize)).Base() );
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+		meshBuilder.TexCoord2f( 0,1,1 );
+		meshBuilder.Position3fv( (vOrigin + (vRight * flSize) + (vUp * -flSize)).Base() );
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+		meshBuilder.TexCoord2f( 0,0,1 );
+		meshBuilder.Position3fv( (vOrigin + (vRight * -flSize) + (vUp * -flSize)).Base() );
+		meshBuilder.AdvanceVertex();
+		meshBuilder.End();
+		pMesh->Draw();
+	}
+}
+
+
+void CRadioStatus::UpdateRadioStatus(int entindex, float duration)
+{
+	if(entindex > 0 && entindex <= VOICE_MAX_PLAYERS)
+	{
+		int iClient = entindex - 1;
+		if(iClient < 0)
+			return;
+
+		m_radioUntil[iClient] = gpGlobals->curtime + duration;
+	}
+}
+
+
+void CRadioStatus::UpdateVoiceStatus(int entindex, float duration)
+{
+	if(entindex > 0 && entindex <= VOICE_MAX_PLAYERS)
+	{
+		int iClient = entindex - 1;
+		if(iClient < 0)
+			return;
+
+		m_voiceUntil[iClient] = gpGlobals->curtime + duration;
+		GetClientVoiceMgr()->UpdateSpeakerStatus( entindex, true );
+	}
+}
+
+void CRadioStatus::ExpireBotVoice( bool force )
+{
+	for(int i=0; i < VOICE_MAX_PLAYERS; i++)
+	{
+		if ( m_voiceUntil[i] > 0.0f )
+		{
+			bool expire = force;
+
+			C_CSPlayer *player = static_cast<C_CSPlayer*>( cl_entitylist->GetEnt(i+1) );
+			if ( !player )
+			{
+				// player left the game
+				expire = true;
+			}
+			else if ( m_voiceUntil[i] < gpGlobals->curtime )
+			{
+				// player is done speaking
+				expire = true;
+			}
+
+			if ( expire )
+			{
+				m_voiceUntil[i] = 0.0f;
+				GetClientVoiceMgr()->UpdateSpeakerStatus( i+1, false );
+			}
+		}
+	}
+}
+
diff --git a/game/client/cstrike/radio_status.h b/game/client/cstrike/radio_status.h
new file mode 100644
index 00000000..a820ba85
--- /dev/null
+++ b/game/client/cstrike/radio_status.h
@@ -0,0 +1,51 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef RADIO_STATUS_H
+#define RADIO_STATUS_H
+#pragma once
+
+class IMaterial;
+
+class CRadioStatus : public CAutoGameSystem
+{
+public:
+	CRadioStatus();
+
+	virtual bool Init();
+	virtual void Shutdown();
+
+	virtual void LevelInitPostEntity();
+	virtual void LevelShutdownPreEntity();
+	
+public:
+
+	// Called when a player uses the radio
+	void	UpdateRadioStatus(int entindex, float duration);
+
+	// Called when a player (bot) speaks a wav file
+	void	UpdateVoiceStatus(int entindex, float duration);
+
+	// Call from the HUD_CreateEntities function so it can add sprites above player heads.
+	void	DrawHeadLabels();
+
+private:
+
+
+	float		m_radioUntil[MAX_PLAYERS];	// Who is currently talking. Indexed by client index.
+	IMaterial	*m_pHeadLabelMaterial;		// For labels above players' heads.
+
+	void		ExpireBotVoice( bool force = false );
+	float		m_voiceUntil[MAX_PLAYERS];	// Who is currently talking. Indexed by client index.
+};
+
+
+// Get the (global) voice manager. 
+CRadioStatus* RadioManager();
+
+
+#endif // RADIO_STATUS_H
diff --git a/game/client/cstrike/vgui_c4panel.cpp b/game/client/cstrike/vgui_c4panel.cpp
new file mode 100644
index 00000000..668915d0
--- /dev/null
+++ b/game/client/cstrike/vgui_c4panel.cpp
@@ -0,0 +1,211 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "c_vguiscreen.h"
+#include "vgui_controls/Label.h"
+#include <vgui/IVGui.h>
+#include "c_plantedc4.h"
+#include "ienginevgui.h"
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CC4Panel : public CVGuiScreenPanel
+{
+	DECLARE_CLASS( CC4Panel, CVGuiScreenPanel );
+
+public:
+	CC4Panel( vgui::Panel *parent, const char *panelName );
+	~CC4Panel();
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+
+	virtual void ApplySchemeSettings( IScheme *pScheme );
+
+private:
+	vgui::Label *m_pTimeLabel;
+
+	float m_flNextDigitRandomizeTime;	//next time to grab a new digit while scrolling random digits
+										//in un-decoded digits
+	int m_iLastRandomInt;				//store the random digit between new rand calls
+
+	bool m_bInitLabelColor;
+
+	Color m_cArmed;
+	Color m_cDefused;
+	Color m_cInvisible;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CC4Panel, "c4_panel" );
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CC4Panel::CC4Panel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CC4Panel", vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/C4Panel.res", "ClientScheme" ) ) 
+{
+	SetSize( 10, 10 ); // Quiet "parent not sized yet" spew
+	m_pTimeLabel = new vgui::Label( this, "TimerLabel", "" );
+	
+	m_flNextDigitRandomizeTime = 0;
+	m_iLastRandomInt = 0;
+
+	m_bInitLabelColor = true;
+}
+
+CC4Panel::~CC4Panel()
+{
+}
+
+void CC4Panel::ApplySchemeSettings( IScheme *pScheme )
+{
+	assert( pScheme );
+
+	m_cArmed = pScheme->GetColor( "C4Panel_Armed", GetFgColor() );
+	m_cDefused = pScheme->GetColor( "C4Panel_Defused", GetFgColor() );
+	m_cInvisible = Color( 0, 0, 0, 0 );	
+
+	if( m_bInitLabelColor )
+	{
+		m_pTimeLabel->SetFgColor( m_cArmed );
+		m_bInitLabelColor = false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CC4Panel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	// Make sure we get ticked...
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+//how long to spend decoding each digit
+float flTransitionTimes[] = { 0.9, 0.8, 0.6, 0.45, 0.25, 0.15, 0.0 };
+
+//the defuse code, taken from the view model animation, v_c4.mdl
+char cDefuseCode[] = { '7', '3', '5', '5', '6', '0', '8', '\0' };	
+char cArmedDisplay[] = { '*', '*', '*', '*', '*', '*', '*', '\0' };
+
+//convert an integer into the readable character version of that number
+#define INT_TO_CHAR(i)	( '0' + (i) )
+
+//-----------------------------------------------------------------------------
+// Update the display string
+//-----------------------------------------------------------------------------
+void CC4Panel::OnTick()
+{
+	BaseClass::OnTick();
+
+	SetVisible( true );
+
+	float flProgress = 1.0;
+
+	if ( g_PlantedC4s.Count() > 0 )
+	{
+		C_PlantedC4 *pC4 = g_PlantedC4s[0];
+
+		if( pC4 )
+		{
+			flProgress = pC4->GetDefuseProgress();
+		}
+		else
+			return;
+	}
+
+	m_pTimeLabel->SetFgColor( m_cArmed );
+
+	// If flProgress is less than 0, the bomb has been defused
+	if( flProgress < 0.0 )
+	{
+		//Flash when the bomb has been defused
+		if( flProgress > -0.2 )	//flash for 2 seconds
+		{
+			int x = (int)( flProgress * 100 );
+
+			if( x % 2 == 0 )
+				m_pTimeLabel->SetFgColor( m_cInvisible );
+			else
+				m_pTimeLabel->SetFgColor( m_cDefused );
+		}
+		else
+			m_pTimeLabel->SetFgColor( m_cDefused );
+
+		//Show the full, decoded defuse code
+		m_pTimeLabel->SetText( cDefuseCode );
+	}
+	else if( flProgress < 1.0 )	//defuse in progress
+	{
+		//Initial display
+		char buf[8];
+		Q_strncpy( buf, cArmedDisplay, MIN( sizeof(buf), sizeof(cArmedDisplay) ) );
+
+		int iDigitPos = 0;
+		while( flProgress < flTransitionTimes[iDigitPos] )
+		{
+			//Fill in the previously decoded digits
+			buf[iDigitPos] = cDefuseCode[iDigitPos];
+			iDigitPos++;
+		}
+
+		//Animate the character that we're decoding
+		//Value drawn will be based on how long we've been
+		//decoding this character
+		float flTimeInThisChar = 1.0 - flTransitionTimes[0];
+		
+		if( iDigitPos > 0 )
+			flTimeInThisChar = flTransitionTimes[iDigitPos-1] - flTransitionTimes[iDigitPos];
+
+
+		assert( flTimeInThisChar > 0.0 );
+
+
+		float flPercentDecoding = ( flProgress - flTransitionTimes[iDigitPos] ) / flTimeInThisChar;
+		
+		//Determine when to next change the digit that we're decoding
+		if( m_flNextDigitRandomizeTime < gpGlobals->curtime )
+		{
+			//Get a new random int to draw
+			m_iLastRandomInt = RandomInt( 0, 9 );
+
+			if( flPercentDecoding > 0.7 )
+				m_flNextDigitRandomizeTime = gpGlobals->curtime + 0.05;
+			else if( flPercentDecoding > 0.5 )
+				m_flNextDigitRandomizeTime = gpGlobals->curtime + 0.1;
+			else if( flPercentDecoding > 0.3 )
+				m_flNextDigitRandomizeTime = gpGlobals->curtime + 0.15;
+			else
+				m_flNextDigitRandomizeTime = gpGlobals->curtime + 0.3;
+		}
+
+		//Settle on the real value if we're close
+		if( flPercentDecoding < 0.2 )
+			buf[iDigitPos] = cDefuseCode[iDigitPos];
+		else	//else use a random digit
+			buf[iDigitPos] = INT_TO_CHAR( m_iLastRandomInt );
+
+		
+		m_pTimeLabel->SetFgColor( m_cArmed );
+		m_pTimeLabel->SetText( buf );
+	}
+	else
+	{
+		//Not being defused - draw the armed string
+		m_pTimeLabel->SetFgColor( m_cArmed );
+		m_pTimeLabel->SetText( cArmedDisplay );
+	}	
+}
\ No newline at end of file
diff --git a/game/client/cstrike/vgui_rootpanel_cs.cpp b/game/client/cstrike/vgui_rootpanel_cs.cpp
new file mode 100644
index 00000000..b5856f27
--- /dev/null
+++ b/game/client/cstrike/vgui_rootpanel_cs.cpp
@@ -0,0 +1,41 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "vgui_int.h"
+#include "ienginevgui.h"
+#include "c_csrootpanel.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+C_CSRootPanel *g_pCSRootPanel = NULL;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void VGUI_CreateClientDLLRootPanel( void )
+{
+	g_pCSRootPanel = new C_CSRootPanel( enginevgui->GetPanel( PANEL_CLIENTDLL ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void VGUI_DestroyClientDLLRootPanel( void )
+{
+	delete g_pCSRootPanel;
+	g_pCSRootPanel = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Game specific root panel
+// Output : vgui::Panel
+//-----------------------------------------------------------------------------
+vgui::VPANEL VGui_GetClientDLLRootPanel( void )
+{
+	return g_pCSRootPanel->GetVPanel();
+}
\ No newline at end of file
diff --git a/game/client/cstrike/vgui_viewc4panel.cpp b/game/client/cstrike/vgui_viewc4panel.cpp
new file mode 100644
index 00000000..e5c7b04a
--- /dev/null
+++ b/game/client/cstrike/vgui_viewc4panel.cpp
@@ -0,0 +1,117 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "c_vguiscreen.h"
+#include "vgui_controls/Label.h"
+#include <vgui/IVGui.h>
+#include "weapon_c4.h"
+#include "ienginevgui.h"
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CViewC4Panel : public CVGuiScreenPanel
+{
+	DECLARE_CLASS( CViewC4Panel, CVGuiScreenPanel );
+
+public:
+	CViewC4Panel( vgui::Panel *parent, const char *panelName );
+	~CViewC4Panel();
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+
+	C_BaseCombatWeapon *GetOwningWeapon();
+
+	virtual void ApplySchemeSettings( IScheme *pScheme );
+
+private:
+	vgui::Label *m_pTimeLabel;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CViewC4Panel, "c4_view_panel" );
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CViewC4Panel::CViewC4Panel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CViewC4Panel", vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/C4Panel.res", "ClientScheme" ) ) 
+{
+	SetSize( 10, 10 ); // Quiet "parent not sized yet" spew
+	m_pTimeLabel = new vgui::Label( this, "TimerLabel", "" );
+}
+
+CViewC4Panel::~CViewC4Panel()
+{
+}
+
+void CViewC4Panel::ApplySchemeSettings( IScheme *pScheme )
+{
+	if( pScheme )
+	{
+		m_pTimeLabel->SetFgColor( pScheme->GetColor( "C4Panel_Armed", GetFgColor() ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CViewC4Panel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	// Make sure we get ticked...
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+C_BaseCombatWeapon *CViewC4Panel::GetOwningWeapon()
+{
+	C_BaseEntity *pScreenEnt = GetEntity();
+	if (!pScreenEnt)
+		return NULL;
+
+	C_BaseEntity *pOwner = pScreenEnt->GetOwnerEntity();
+	if (!pOwner)
+		return NULL;
+
+	C_BaseViewModel *pViewModel = dynamic_cast< C_BaseViewModel * >( pOwner );
+	if ( !pViewModel )
+		return NULL;
+
+	return pViewModel->GetOwningWeapon();
+}
+
+
+//-----------------------------------------------------------------------------
+// Update the screen with the latest string from the view model
+//-----------------------------------------------------------------------------
+void CViewC4Panel::OnTick()
+{
+	BaseClass::OnTick();
+
+	SetVisible( true );
+
+	C_BaseEntity *pEnt = GetOwningWeapon();
+
+	C_C4 *pViewC4 = dynamic_cast<C_C4*>( pEnt );
+
+	if( pViewC4 )
+	{
+		char *display = pViewC4->GetScreenText();
+
+		if( display )
+		{
+			m_pTimeLabel->SetText( display );
+		}
+	}		
+}
\ No newline at end of file
diff --git a/game/client/hud_baseachievement_tracker.cpp b/game/client/hud_baseachievement_tracker.cpp
new file mode 100644
index 00000000..4a128b21
--- /dev/null
+++ b/game/client/hud_baseachievement_tracker.cpp
@@ -0,0 +1,608 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Draws achievement progress bars on the HUD
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hudelement.h"
+#include "hud_macros.h"
+#include <game_controls/baseviewport.h>
+#include <vgui_controls/Controls.h>
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/ImagePanel.h>
+#include <vgui_controls/TextImage.h>
+#include "vgui/ILocalize.h"
+#include "hud_baseachievement_tracker.h"
+#include "iachievementmgr.h"
+#include "baseachievement.h"
+#include "iclientmode.h"
+#include "cdll_int.h"
+#include <vgui/ISurface.h>
+#include <vgui_controls/AnimationController.h>
+#include "fmtstr.h"
+#include "engine/IEngineSound.h"
+
+//=============================================================================
+// HPE_BEGIN
+// [dwenger] Necessary for HUD Achievement display
+//=============================================================================
+
+#include "cdll_client_int.h"
+#include "steam/isteamuserstats.h"
+#include "steam/steam_api.h"
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+using namespace vgui;
+
+#define PROGRESS_BAR_NEEDS_UPDATE -1
+#define UNKNOWN_ACHIEVEMENT_ID -1
+
+void TrackerDescriptionChanged( IConVar *var, const char *pOldString, float flOldValue )
+{
+	static int s_iTimesChanged = 0;
+	if ( s_iTimesChanged > 0 )
+	{
+		engine->ClientCmd_Unrestricted( "hud_reloadscheme" );
+	}
+	s_iTimesChanged++;
+}
+ConVar hud_achievement_description("hud_achievement_description", "1", FCVAR_ARCHIVE, "Show full descriptions of achievements on the HUD", TrackerDescriptionChanged );
+#ifdef CSTRIKE_DLL
+ConVar hud_achievement_count("hud_achievement_count", "5", FCVAR_ARCHIVE, "Max number of achievements that can be shown on the HUD" );
+#else
+ConVar hud_achievement_count("hud_achievement_count", "8", FCVAR_ARCHIVE, "Max number of achievements that can be shown on the HUD" );
+#endif
+ConVar hud_achievement_glowtime("hud_achievement_glowtime", "2.5", FCVAR_NONE, "Duration of glow effect around incremented achievements" );
+ConVar hud_achievement_tracker("hud_achievement_tracker", "1", FCVAR_NONE, "Show or hide the achievement tracker" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudBaseAchievementTracker::CHudBaseAchievementTracker( const char *pElementName ) :
+	CHudElement( pElementName ), BaseClass( NULL, "HudAchievementTracker" )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+
+	for ( int i=0; i < GetMaxAchievementsShown(); i++ )
+	{
+		CAchievementTrackerItem *pNewItem = CreateAchievementPanel();
+		pNewItem->SetAchievement( NULL );
+		m_AchievementItem.AddToTail( pNewItem );
+	}
+
+	m_flNextThink = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudBaseAchievementTracker::Reset()
+{
+	m_flNextThink = gpGlobals->curtime + 0.05f;
+}
+
+void CHudBaseAchievementTracker::LevelInit()
+{
+	// clear out tracker items and floating numbers on level change
+	for ( int i = 0; i < GetChildCount(); i++ )
+	{
+		GetChild( i )->SetVisible( false );
+		GetChild( i )->MarkForDeletion();
+	}
+	m_AchievementItem.Purge();
+
+	for ( int i=0; i < GetMaxAchievementsShown(); i++ )
+	{
+		CAchievementTrackerItem *pNewItem = CreateAchievementPanel();
+		pNewItem->SetAchievement( NULL );
+		m_AchievementItem.AddToTail( pNewItem );
+	}
+
+
+	CHudElement::LevelInit();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudBaseAchievementTracker::ApplySchemeSettings( IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHudBaseAchievementTracker::ShouldDraw()
+{
+	if ( engine->IsPlayingDemo() )
+		return false;
+
+	return CHudElement::ShouldDraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudBaseAchievementTracker::OnThink()
+{
+	if ( m_flNextThink < gpGlobals->curtime )
+	{
+		UpdateAchievementItems();
+		m_flNextThink = gpGlobals->curtime + 0.5f;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Max number of achievements shown on the HUD
+//-----------------------------------------------------------------------------
+int CHudBaseAchievementTracker::GetMaxAchievementsShown()
+{
+	return hud_achievement_count.GetInt();
+}
+
+bool CHudBaseAchievementTracker::ShouldShowAchievement( IAchievement *pAchievement )
+{
+	return ( hud_achievement_tracker.GetBool() && pAchievement && pAchievement->ShouldShowOnHUD() && !pAchievement->IsAchieved() );
+}
+
+CAchievementTrackerItem* CHudBaseAchievementTracker::CreateAchievementPanel()
+{
+	return new CAchievementTrackerItem( this, "HudAchievementTrackerItem" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: create panels for each achievement the player wants shown on the HUD and assign achievements to each one
+//-----------------------------------------------------------------------------
+void CHudBaseAchievementTracker::UpdateAchievementItems()
+{
+	IAchievementMgr *pAchievementMgr = engine->GetAchievementMgr();
+	if ( !pAchievementMgr )
+		return;
+
+	int iCount = pAchievementMgr->GetAchievementCount();
+	int iShown = 0;
+	for ( int i = 0; i < iCount; ++i )
+	{		
+		IAchievement* pCur = pAchievementMgr->GetAchievementByIndex( i );
+		if ( !ShouldShowAchievement( pCur ) )
+		{
+			// don't remove achievements that are still glowing (typically a just completed achievement)
+			if ( pCur && m_AchievementItem.Count() > iShown && m_AchievementItem[iShown]->GetAchievementID() == pCur->GetAchievementID() 
+					&& m_AchievementItem[iShown]->GetGlow() > 0 )
+			{
+				iShown++;
+			}
+			continue;
+		}
+
+		if ( m_AchievementItem.Count() < iShown+1 )
+		{
+			CAchievementTrackerItem *pNewItem = CreateAchievementPanel();
+			SETUP_PANEL( pNewItem );
+			m_AchievementItem.AddToTail( pNewItem );
+		}
+
+		m_AchievementItem[iShown]->SetAchievement( pCur );
+		m_AchievementItem[iShown]->SetSlot( iShown );
+		m_AchievementItem[iShown]->SetVisible( true );
+		iShown++;
+
+		if ( iShown >= GetMaxAchievementsShown() )
+			break;
+	}
+
+	// hide any extra panels we may have created from when the list was longer
+	if ( iShown < m_AchievementItem.Count() )
+	{
+		for ( int i = m_AchievementItem.Count() - 1; i >= iShown ; i-- )
+		{
+			m_AchievementItem[i]->SetVisible( false );
+			m_AchievementItem[i]->SetAchievement( NULL );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Layout all child panels vertically
+//-----------------------------------------------------------------------------
+void CHudBaseAchievementTracker::PerformLayout()
+{
+	// make sure all children are laid out first
+	for ( int i=0; i < m_AchievementItem.Count(); i++ )
+	{
+		m_AchievementItem[i]->InvalidateLayout( true );
+	}
+
+	int iCurrentY = 0;
+	int x, y;
+	for ( int i=0; i< m_AchievementItem.Count(); i++ )
+	{
+		m_AchievementItem[i]->GetPos( x, y );
+		m_AchievementItem[i]->SetPos( x, iCurrentY );
+		iCurrentY += m_AchievementItem[i]->GetTall() + m_iItemPadding;
+	}
+}
+
+CAchievementTrackerItem* CHudBaseAchievementTracker::GetAchievementPanel( int i )
+{
+	if ( i < 0 || i >= m_AchievementItem.Count() )
+		return NULL;
+
+	return m_AchievementItem[i];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The child panels
+//-----------------------------------------------------------------------------
+
+CAchievementTrackerItem::CAchievementTrackerItem( vgui::Panel* pParent, const char *pElementName ) :
+	BaseClass( pParent, pElementName )
+{
+	m_pAchievementNameGlow = new vgui::Label( this, "AchievementNameGlow", "" );
+	m_pAchievementName = new vgui::Label( this, "AchievementName", "" );
+	m_pAchievementDesc = new vgui::Label( this, "AchievementDesc", "" );
+	m_pProgressBarBackground = SETUP_PANEL( new ImagePanel( this, "ProgressBarBG" ) );
+	m_pProgressBar = SETUP_PANEL( new ImagePanel( this, "ProgressBar" ) );
+
+	m_iAchievementID = UNKNOWN_ACHIEVEMENT_ID;
+	m_iLastPaintedAchievementID = UNKNOWN_ACHIEVEMENT_ID;
+	m_iAccumulatedIncrement = 0;
+	m_flShowIncrementsTime = 0;
+	m_iLastCount = 0;
+	m_iPadding = 1;
+}
+
+CAchievementTrackerItem::~CAchievementTrackerItem()
+{
+	if ( m_pAchievementName )
+	{
+		m_pAchievementName->MarkForDeletion();
+		m_pAchievementName = NULL;
+	}
+
+	if ( m_pAchievementNameGlow )
+	{
+		m_pAchievementNameGlow->MarkForDeletion();
+		m_pAchievementNameGlow = NULL;
+	}
+
+	if ( m_pAchievementDesc )
+	{
+		m_pAchievementDesc->MarkForDeletion();
+		m_pAchievementDesc = NULL;
+	}
+
+	if ( m_pProgressBarBackground )
+	{
+		m_pProgressBarBackground->MarkForDeletion();
+		m_pProgressBarBackground = NULL;
+	}
+
+	if ( m_pProgressBar )
+	{
+		m_pProgressBar->MarkForDeletion();
+		m_pProgressBar = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CAchievementTrackerItem::ApplySchemeSettings( IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+
+	LoadControlSettings( "resource/UI/HudAchievementTrackerItem.res" );
+	m_pAchievementDesc->SetVisible( hud_achievement_description.GetBool() );
+	m_iLastPaintedAchievementID = UNKNOWN_ACHIEVEMENT_ID;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CAchievementTrackerItem::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	int x, y, w, t;
+
+    //=============================================================================
+    // HPE_BEGIN
+    // [dwenger] Necessary for HUD Achievement display
+    //=============================================================================
+
+    m_pAchievementName->GetContentSize( w, t );     // needed in order to load up font for the name
+    m_pAchievementNameGlow->GetContentSize( w, t ); // needed in order to load up font for the glow
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+    if ( hud_achievement_description.GetBool() )
+	{
+		m_pAchievementDesc->GetContentSize( w, t );
+		m_pAchievementDesc->SetTall( t );
+		m_pAchievementDesc->GetBounds( x, y, w, t );
+	}
+	else
+	{
+		m_pAchievementName->GetBounds( x, y, w, t );
+	}
+
+	if ( m_pProgressBarBackground->IsVisible() )
+	{
+		// put progress bar after description
+		int bx, by;
+		m_pProgressBarBackground->GetPos( bx, by );
+		m_pProgressBarBackground->SetPos( bx, y + t + m_iPadding );
+
+		SetTall( y + t + m_pProgressBarBackground->GetTall() + m_iPadding * 2 );
+	}
+	else
+	{
+		SetTall( y + t + m_iPadding );
+	}
+
+	m_iLastProgressBarCount = m_iLastProgressBarGoal = PROGRESS_BAR_NEEDS_UPDATE;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CAchievementTrackerItem::SetAchievement( IAchievement* pAchievement )
+{
+	if ( !pAchievement )
+	{
+		m_iAchievementID = UNKNOWN_ACHIEVEMENT_ID;
+		m_iLastCount = 0;
+		return;
+
+	}
+	if ( m_iAchievementID != pAchievement->GetAchievementID() )
+	{
+		m_iAchievementID = pAchievement->GetAchievementID();
+		m_iLastCount = pAchievement->GetCount();
+		UpdateAchievementDisplay();
+	}
+}
+
+void CAchievementTrackerItem::OnThink()
+{
+	UpdateAchievementDisplay();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Make sure our labels and progress bar are up to date
+//-----------------------------------------------------------------------------
+void CAchievementTrackerItem::UpdateAchievementDisplay()
+{
+	IAchievementMgr *pAchievementMgr = engine->GetAchievementMgr();
+	if ( !pAchievementMgr )
+		return;
+
+	CBaseAchievement* pAchievement = pAchievementMgr->GetAchievementByID( m_iAchievementID );
+	if ( !pAchievement )
+		return;
+	
+	if ( m_iAchievementID != m_iLastPaintedAchievementID )
+	{
+		// need to update labels
+
+        //=============================================================================
+        // HPE_BEGIN
+        // [dwenger] Necessary for HUD Achievement display
+        //=============================================================================
+
+        m_pAchievementName->SetText( ACHIEVEMENT_LOCALIZED_NAME( pAchievement ) );
+        m_pAchievementNameGlow->SetText( ACHIEVEMENT_LOCALIZED_NAME( pAchievement ) );
+        m_pAchievementDesc->SetText( ACHIEVEMENT_LOCALIZED_DESC( pAchievement ) );
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+		m_pProgressBarBackground->SetVisible( pAchievement->GetGoal() > 1 );
+		m_pProgressBar->SetVisible( pAchievement->GetGoal() > 1 );
+		
+		m_iLastPaintedAchievementID = m_iAchievementID;
+		m_flGlow = 0.0f;
+		m_flGlowTime = 0.0f;
+		m_iAccumulatedIncrement = 0;
+		//InvalidateLayout( true );
+		GetParent()->InvalidateLayout( true );
+	}
+
+	if ( m_iAccumulatedIncrement > 0 && gpGlobals->curtime > m_flShowIncrementsTime )
+	{
+		ShowAccumulatedIncrements();
+	}
+
+	if ( pAchievement->GetCount() != m_iLastProgressBarCount || pAchievement->GetGoal() != m_iLastProgressBarGoal )
+	{
+		// need to update progress bar
+		float flProgress = float ( pAchievement->GetCount() ) / float( pAchievement->GetGoal() );
+		int x, y, w, t;
+		m_pProgressBarBackground->GetBounds( x, y, w, t );
+		m_pProgressBar->SetBounds( x, y, w * flProgress, t );
+
+		m_iLastProgressBarCount = pAchievement->GetCount();
+		m_iLastProgressBarGoal = pAchievement->GetGoal();
+
+		AchievementIncremented( pAchievement->GetCount() );
+	}
+
+	if ( gpGlobals->curtime < m_flGlowTime )
+	{
+		m_flGlow = MIN( 1.0f, m_flGlow + gpGlobals->frametime * 5.0f );
+	}
+	else
+	{
+		m_flGlow = MAX( 0.0f, m_flGlow - gpGlobals->frametime * 5.0f );
+	}
+	m_pAchievementNameGlow->SetAlpha( m_flGlow * 255.0f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Achievement count has gone up, make it flash 
+//-----------------------------------------------------------------------------
+void CAchievementTrackerItem::AchievementIncremented( int iNewCount )
+{
+	int iIncrement = iNewCount - m_iLastCount;
+	m_iLastCount = iNewCount;
+
+	if ( iIncrement <= 0 )
+		return;
+
+	if ( m_iLastProgressBarGoal > 1500 )
+	{
+		// for achievements with very high counts, accumulate increments so we don't have too many +1s on screen
+		//  also don't play sounds as these achievements tend to increment constantly
+
+		if ( m_flShowIncrementsTime < gpGlobals->curtime )
+		{
+			m_flShowIncrementsTime = gpGlobals->curtime + 2.0f;
+		}
+		m_iAccumulatedIncrement += iIncrement;
+	}
+	else
+	{
+		m_flGlowTime = gpGlobals->curtime + hud_achievement_glowtime.GetFloat();
+
+		// create a floating +X to scroll up alongside this achievement
+		if ( m_pProgressBarBackground->IsVisible() )
+		{
+			int px, py;
+			GetPos( px, py );
+			int x, y, w, t;
+			m_pProgressBarBackground->GetBounds( x, y, w, t );
+			x += w;
+			new CFloatingAchievementNumber( iIncrement, px + x, py + y + ( t * 0.5f ), FN_DIR_RIGHT, GetParent() );
+		}
+
+		CLocalPlayerFilter filter;
+		C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "Hud.AchievementIncremented" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Show all the increments we've accumulated 
+//-----------------------------------------------------------------------------
+void CAchievementTrackerItem::ShowAccumulatedIncrements()
+{
+	int px, py;
+	GetPos( px, py );
+	int x, y, w, t;
+	m_pProgressBarBackground->GetBounds( x, y, w, t );
+	x += w;
+	new CFloatingAchievementNumber( m_iAccumulatedIncrement, px + x, py + y + ( t * 0.5f ), FN_DIR_RIGHT, GetParent() );
+
+	m_iAccumulatedIncrement = 0;
+	m_flGlowTime = gpGlobals->curtime + hud_achievement_glowtime.GetFloat();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Floating numbers showing how much achievement progress bars have gone up
+//-----------------------------------------------------------------------------
+
+CFloatingAchievementNumber::CFloatingAchievementNumber( int iProgress, int x, int y, floating_number_directions iDir, vgui::Panel* pParent )
+		: BaseClass( pParent, "FloatingAchievementNumber" )
+{
+	m_iStartX = x;
+	m_iStartY = y;
+	m_iProgress = iProgress;
+	m_fStartTime = gpGlobals->curtime;
+	m_iDirection = iDir;
+
+	char szLabel[64];
+	Q_snprintf( szLabel, sizeof( szLabel ), "+%d", iProgress );
+	m_pNumberLabel = new vgui::Label( this, "FloatingNumberLabel", szLabel );
+}
+
+CFloatingAchievementNumber::~CFloatingAchievementNumber()
+{
+	if ( m_pNumberLabel )
+	{
+		m_pNumberLabel->MarkForDeletion();
+		m_pNumberLabel = NULL;
+	}
+}
+
+void CFloatingAchievementNumber::ApplySchemeSettings( vgui::IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+
+	LoadControlSettings( "resource/UI/HudAchievementFloatingNumber.res" );
+
+	int fontHeight = surface()->GetFontTall( m_pNumberLabel->GetFont() );
+	SetPos( m_iStartX, m_iStartY - ( fontHeight * 0.5f ) );
+	m_pNumberLabel->SetAlpha( 0 );
+	GetAnimationController()->RunAnimationCommand( m_pNumberLabel, "alpha", 255, 0, 0.3, vgui::AnimationController::INTERPOLATOR_LINEAR );
+
+	switch ( m_iDirection )
+	{
+	default:
+	case FN_DIR_UP:
+		vgui::GetAnimationController()->RunAnimationCommand( this, "ypos", m_iStartY - m_iScrollDistance, 0, 2.0f, vgui::AnimationController::INTERPOLATOR_LINEAR );
+		break;
+	case FN_DIR_DOWN:
+		vgui::GetAnimationController()->RunAnimationCommand( this, "ypos", m_iStartY + m_iScrollDistance, 0, 2.0f, vgui::AnimationController::INTERPOLATOR_LINEAR );
+		break;
+	case FN_DIR_LEFT:
+		vgui::GetAnimationController()->RunAnimationCommand( this, "xpos", m_iStartX - m_iScrollDistance, 0, 2.0f, vgui::AnimationController::INTERPOLATOR_LINEAR );
+		break;
+	case FN_DIR_RIGHT:
+		vgui::GetAnimationController()->RunAnimationCommand( this, "xpos", m_iStartX + m_iScrollDistance, 0, 2.0f, vgui::AnimationController::INTERPOLATOR_LINEAR );
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Delete panel when floating number has faded out
+//-----------------------------------------------------------------------------
+void CFloatingAchievementNumber::OnThink()
+{
+	if ( gpGlobals->curtime > m_fStartTime + 1.0f )
+	{
+		if ( m_pNumberLabel->GetAlpha() >=  255 )
+		{
+			m_pNumberLabel->SetAlpha( 254 );
+			GetAnimationController()->RunAnimationCommand( m_pNumberLabel, "alpha", 0, 0.0, 1.0f, vgui::AnimationController::INTERPOLATOR_LINEAR );
+		}
+		else if ( m_pNumberLabel->GetAlpha() <= 0 )
+		{
+			MarkForDeletion();
+			SetVisible( false );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Debug command to make one of the achievement panels flash as though it just went up
+//-----------------------------------------------------------------------------
+class CHudAchievementTracker;
+void cc_TrackerAnim_f( const CCommand &args )
+{
+	CHudBaseAchievementTracker *pTracker = ( CHudBaseAchievementTracker * )GET_HUDELEMENT( CHudAchievementTracker );
+	if ( !pTracker )
+		return;
+
+	CAchievementTrackerItem *pItem = pTracker->GetAchievementPanel( atoi(args[1]) );
+	if ( !pItem )
+		return;
+
+	pItem->AchievementIncremented( pItem->GetLastCount() + RandomInt(1, 1) );
+}
+
+ConCommand cc_TrackerAnim( "TrackerAnim", cc_TrackerAnim_f, "Test animation of the achievement tracker. Parameter is achievement number on HUD to flash", FCVAR_NONE );
diff --git a/game/client/hud_baseachievement_tracker.h b/game/client/hud_baseachievement_tracker.h
new file mode 100644
index 00000000..323ec4a4
--- /dev/null
+++ b/game/client/hud_baseachievement_tracker.h
@@ -0,0 +1,119 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef HUD_ACHIEVEMENT_TRACKER_H
+#define HUD_ACHIEVEMENT_TRACKER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "hudelement.h"
+#include <vgui_controls/EditablePanel.h>
+
+class IAchievement;
+namespace vgui
+{
+	class ImagePanel;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose:  Draws information about one achievement (name, description, progress)
+//-----------------------------------------------------------------------------
+class CAchievementTrackerItem : public vgui::EditablePanel
+{
+	DECLARE_CLASS_SIMPLE( CAchievementTrackerItem, vgui::EditablePanel );
+public:
+	CAchievementTrackerItem( vgui::Panel* pParent, const char *pElementName );
+	virtual ~CAchievementTrackerItem();
+
+	virtual void ApplySchemeSettings( vgui::IScheme *scheme );
+	virtual void SetAchievement( IAchievement* pAchievement );
+	virtual void OnThink();
+	virtual void SetSlot( int i ) { m_iSlot = i; }
+	virtual void PerformLayout();
+	virtual void AchievementIncremented( int iCount );
+	virtual int  GetAchievementID() { return m_iAchievementID; }
+	virtual float GetGlow() { return m_flGlow; }
+	virtual void ShowAccumulatedIncrements();
+	virtual int GetLastCount() { return m_iLastCount; }
+	virtual void UpdateAchievementDisplay();
+
+protected:	
+	vgui::Label *m_pAchievementName;
+	vgui::Label *m_pAchievementNameGlow;
+	vgui::Label *m_pAchievementDesc;
+	vgui::ImagePanel		*m_pProgressBarBackground;
+	vgui::ImagePanel		*m_pProgressBar;
+
+	int m_iAchievementID;
+	int m_iLastPaintedAchievementID;
+	int m_iLastProgressBarGoal, m_iLastProgressBarCount, m_iLastCount;
+	int m_iSlot;
+	float m_flGlowTime;
+	float m_flGlow;
+	float m_flShowIncrementsTime;
+	int m_iAccumulatedIncrement;
+
+	CPanelAnimationVarAliasType( int, m_iPadding, "Padding", "1", "proportional_int" );		// space between description and bar
+};
+
+//---------------------------------------------------------------------------------------------
+// Purpose:  Scrolls a floating number up the screen to indicate achievement progression
+//---------------------------------------------------------------------------------------------
+
+enum floating_number_directions
+{
+	FN_DIR_UP,
+	FN_DIR_DOWN,
+	FN_DIR_LEFT,
+	FN_DIR_RIGHT,
+};
+
+class CFloatingAchievementNumber : public vgui::EditablePanel
+{
+	DECLARE_CLASS_SIMPLE( CFloatingAchievementNumber, vgui::EditablePanel );
+public:
+	CFloatingAchievementNumber( int iProgress, int x, int y, floating_number_directions iDir, vgui::Panel* pParent );
+	virtual ~CFloatingAchievementNumber();
+	
+	virtual void ApplySchemeSettings( vgui::IScheme *scheme );
+	virtual void OnThink();
+
+protected:
+	vgui::Label *m_pNumberLabel;
+	int m_iStartX;
+	int m_iStartY;
+	int m_iProgress;
+	float m_fStartTime;
+	floating_number_directions m_iDirection;
+
+	CPanelAnimationVarAliasType( int, m_iScrollDistance, "ScrollDistance", "40", "proportional_int" );		// how far the floating number will scroll up before disappearing completely
+};
+
+//-----------------------------------------------------------------------------
+// Purpose:  Creates panels to show achievements on the HUD
+//-----------------------------------------------------------------------------
+class CHudBaseAchievementTracker : public CHudElement, public vgui::EditablePanel
+{
+	DECLARE_CLASS_SIMPLE( CHudBaseAchievementTracker, vgui::EditablePanel );
+public:
+	CHudBaseAchievementTracker( const char *pElementName );
+
+	virtual void Reset();
+	virtual void LevelInit();
+	virtual void ApplySchemeSettings( vgui::IScheme *scheme );
+	virtual void OnThink();
+	virtual bool ShouldDraw();
+	virtual void PerformLayout();
+	virtual bool ShouldShowAchievement( IAchievement *pAchievement );
+	virtual void UpdateAchievementItems();
+	virtual int  GetMaxAchievementsShown();
+	virtual CAchievementTrackerItem* GetAchievementPanel( int i );
+	virtual CAchievementTrackerItem* CreateAchievementPanel();
+
+protected:
+	float m_flNextThink;
+	CUtlVector<CAchievementTrackerItem*> m_AchievementItem;
+
+	CPanelAnimationVarAliasType( int, m_iItemPadding, "ItemPadding", "8", "proportional_int" );		// space between each achievement item
+};
+
+#endif	// HUD_ACHIEVEMENT_TRACKER_H
\ No newline at end of file
diff --git a/game/client/in_main.cpp b/game/client/in_main.cpp
index 21eb30a0..ed921270 100644
--- a/game/client/in_main.cpp
+++ b/game/client/in_main.cpp
@@ -18,6 +18,7 @@
 #include "prediction.h"
 #include "bitbuf.h"
 #include "checksum_md5.h"
+#include "touch.h"
 #include "hltvcamera.h"
 #if defined( REPLAY_ENABLED )
 #include "replay/replaycamera.h"
@@ -946,6 +947,7 @@ void CInput::ControllerMove( float frametime, CUserCmd *cmd )
 	}
 
 	JoyStickMove( frametime, cmd);
+	gTouch.Move( frametime, cmd );
 
 	// NVNT if we have a haptic device..
 	if(haptics && haptics->HasDevice())
diff --git a/game/client/touch.cpp b/game/client/touch.cpp
index 0d743e96..a2cbf007 100644
--- a/game/client/touch.cpp
+++ b/game/client/touch.cpp
@@ -199,7 +199,7 @@ CON_COMMAND( touch_show, "show button" )
 	if( args.ArgC() >= 2 )
 		gTouch.ShowButton( args[1] );
 	else
-		Msg( "Usage: touch_show <name>\n" );		
+		Msg( "Usage: touch_show <name>\n" );
 }
 
 CON_COMMAND( touch_hide, "hide button" )
@@ -225,12 +225,12 @@ CON_COMMAND( touch_writeconfig, "save current config" )
 	gTouch.WriteConfig();
 }
 
-/*
+
 CON_COMMAND( touch_loaddefaults, "generate config from defaults" )
 {
-	
+	gTouch.ResetToDefaults();
 }
-
+/*
 CON_COMMAND( touch_roundall, "round all buttons coordinates to grid" )
 {
 	
@@ -255,16 +255,54 @@ CON_COMMAND( touch_fade, "start fade animation for selected buttons" )
 
 CON_COMMAND( touch_toggleselection, "toggle visibility on selected button in editor" )
 {
-	
+
 }*/
 
+void CTouchControls::ResetToDefaults()
+{
+	rgba_t color(255, 255, 255, 155);
+	char buf[MAX_PATH];
+
+	RemoveButtons();
+
+	Q_snprintf(buf, sizeof buf, "cfg/%s", TOUCH_DEFAULT_CFG);
+	if( !filesystem->FileExists(buf) )
+	{
+		AddButton( "look", "", "_look", 0.5, 0, 1, 1, color, 0, 0, 0 );
+		AddButton( "move", "", "_move", 0, 0, 0.5, 1, color, 0, 0, 0 );
+
+		AddButton( "use", "vgui/touch/use", "+use", 0.880000, 0.213333, 1.000000, 0.426667, color );
+		AddButton( "jump", "vgui/touch/jump", "+jump", 0.880000, 0.462222, 1.000000, 0.675556, color );
+		AddButton( "attack", "vgui/touch/shoot", "+attack", 0.760000, 0.583333, 0.880000, 0.796667, color );
+		AddButton( "attack2", "vgui/touch/shoot_alt", "+attack2", 0.760000, 0.320000, 0.880000, 0.533333, color );
+		AddButton( "duck", "vgui/touch/crouch", "+duck", 0.880000, 0.746667, 1.000000, 0.960000, color );
+		AddButton( "tduck", "vgui/touch/tduck", ";+duck", 0.560000, 0.817778, 0.620000, 0.924444, color );
+		AddButton( "zoom", "vgui/touch/zoom", "+zoom", 0.680000, 0.00000, 0.760000, 0.142222, color );
+		AddButton( "speed", "vgui/touch/speed", "+speed", 0.180000, 0.568889, 0.280000, 0.746667, color );
+		AddButton( "loadquick", "vgui/touch/load", "load quick", 0.760000, 0.000000, 0.840000, 0.142222, color );
+		AddButton( "savequick", "vgui/touch/save", "save quick", 0.840000, 0.000000, 0.920000, 0.142222, color );
+		AddButton( "reload", "vgui/touch/reload", "+reload", 0.000000, 0.320000, 0.120000, 0.533333, color );
+		AddButton( "flashlight", "vgui/touch/flash_light_filled", "impulse 100", 0.920000, 0.000000, 1.000000, 0.142222, color );
+		AddButton( "invnext", "vgui/touch/next_weap", "invnext", 0.000000, 0.533333, 0.120000, 0.746667, color );
+		AddButton( "invprev", "vgui/touch/prev_weap", "invprev", 0.000000, 0.071111, 0.120000, 0.284444, color );
+		AddButton( "edit", "vgui/touch/settings", "touch_enableedit", 0.420000, 0.000000, 0.500000, 0.151486, color );
+		AddButton( "menu", "vgui/touch/menu", "gameui_activate", 0.000000, 0.00000, 0.080000, 0.142222, color );
+	}
+	else
+	{
+		Q_snprintf(buf, sizeof buf, "exec %s", TOUCH_DEFAULT_CFG);
+		engine->ClientCmd_Unrestricted(buf);
+	}
+
+	WriteConfig();
+}
+
 void CTouchControls::Init()
 {
 	int w,h;
 	engine->GetScreenSize( w, h );
 	screen_w = w; screen_h = h;
 
-	Msg("grid_x: %f, grid_y: %x\n", GRID_X, GRID_Y);
 	configchanged = false;
 	config_loaded = false;
 	btns.EnsureCapacity( 64 );
@@ -295,7 +333,6 @@ void CTouchControls::Init()
 	AddButton( "duck", "vgui/touch/crouch", "+duck", 0.880000, 0.746667, 1.000000, 0.960000, color );
 	AddButton( "tduck", "vgui/touch/tduck", ";+duck", 0.560000, 0.817778, 0.620000, 0.924444, color );
 	AddButton( "zoom", "vgui/touch/zoom", "+zoom", 0.680000, 0.00000, 0.760000, 0.142222, color );
-//	AddButton( "score", "vgui/touch/map", "+score", 0.680000, 0.00000, 0.760000, 0.142222, color );
 	AddButton( "speed", "vgui/touch/speed", "+speed", 0.180000, 0.568889, 0.280000, 0.746667, color );
 	AddButton( "loadquick", "vgui/touch/load", "load quick", 0.760000, 0.000000, 0.840000, 0.142222, color );
 	AddButton( "savequick", "vgui/touch/save", "save quick", 0.840000, 0.000000, 0.920000, 0.142222, color );
@@ -305,17 +342,16 @@ void CTouchControls::Init()
 	AddButton( "invprev", "vgui/touch/prev_weap", "invprev", 0.000000, 0.071111, 0.120000, 0.284444, color );
 	AddButton( "edit", "vgui/touch/settings", "touch_enableedit", 0.420000, 0.000000, 0.500000, 0.151486, color );
 	AddButton( "menu", "vgui/touch/menu", "gameui_activate", 0.000000, 0.00000, 0.080000, 0.142222, color );
-//	AddButton( "lie", "vgui/touch/lie", "+alt1", 0.580000, 0.568889, 0.680000, 0.746667, color );
 
 	char buf[256];
 	Q_snprintf(buf, sizeof buf, "exec %s\n", touch_config_file.GetString());
 	engine->ClientCmd_Unrestricted(buf);
 
-	Q_snprintf(buf, sizeof buf, "cfg/%s", touch_config_file.GetString());	
+	Q_snprintf(buf, sizeof buf, "cfg/%s", touch_config_file.GetString());
 	if( !filesystem->FileExists(buf) )
 		WriteConfig();
 
-	initialized = true;	
+	initialized = true;
 }
 
 void CTouchControls::Shutdown( )
@@ -383,7 +419,6 @@ void CTouchControls::IN_Look()
 		float def_fov = default_fov.GetFloat();
 		float fov = pl->GetFOV();
 		diff = fov/def_fov;
-		Msg("diff=%f\n", diff);
 	}
 
 	if( !pitch && !yaw )
diff --git a/game/client/touch.h b/game/client/touch.h
index 5fe162c6..2324883d 100644
--- a/game/client/touch.h
+++ b/game/client/touch.h
@@ -161,7 +161,7 @@ public:
 	
 	void AddButton( const char *name, const char *texturefile, const char *command, float x1, float y1, float x2, float y2, rgba_t color = rgba_t(255, 255, 255, 255), int round = 2, float aspect = 1.f, int flags = 0 );
 	void RemoveButton( const char *name );
-	
+	void ResetToDefaults();
 	void HideButton( const char *name );
 	void ShowButton( const char *name );
 	void ListButtons();
diff --git a/game/server/NextBot/Behavior/BehaviorBackUp.h b/game/server/NextBot/Behavior/BehaviorBackUp.h
new file mode 100644
index 00000000..e3a65f02
--- /dev/null
+++ b/game/server/NextBot/Behavior/BehaviorBackUp.h
@@ -0,0 +1,118 @@
+// BehaviorBackUp.h
+// Back up for a short duration
+// Author: Michael Booth, March 2007
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _BEHAVIOR_BACK_UP_H_
+#define _BEHAVIOR_BACK_UP_H_
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Move backwards for a short duration away from a given position.  
+ * Useful to dislodge ourselves if we get stuck while following our path.
+ */
+template < typename Actor >
+class BehaviorBackUp : public Action< Actor >
+{
+public:
+	BehaviorBackUp( const Vector &avoidPos );
+
+	virtual ActionResult< Actor > OnStart( Actor *me, Action< Actor > *priorAction );
+	virtual ActionResult< Actor > Update( Actor *me, float interval );
+
+	virtual EventDesiredResult< Actor > OnStuck( Actor *me );
+
+	virtual const char *GetName( void ) const	{ return "BehaviorBackUp"; }
+
+private:
+	CountdownTimer m_giveUpTimer;
+	CountdownTimer m_backupTimer;
+	CountdownTimer m_jumpTimer;
+	Vector m_way;
+	Vector m_avoidPos;
+};
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor >
+inline BehaviorBackUp< Actor >::BehaviorBackUp( const Vector &avoidPos )
+{
+	m_avoidPos = avoidPos;
+}
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor >
+inline ActionResult< Actor > BehaviorBackUp< Actor >::OnStart( Actor *me, Action< Actor > *priorAction )
+{
+	ILocomotion *mover = me->GetLocomotionInterface();
+
+	// don't back off if we're on a ladder
+	if ( mover && mover->IsUsingLadder() )
+	{
+		return Done();
+	}
+	
+	float backupTime = RandomFloat( 0.3f, 0.5f );
+	
+	m_backupTimer.Start( backupTime );
+	m_jumpTimer.Start( 1.5f * backupTime );
+	m_giveUpTimer.Start( 2.5f * backupTime );
+	
+	m_way = me->GetPosition() - m_avoidPos;
+	m_way.NormalizeInPlace();
+	
+	return Continue();
+}
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor >
+inline ActionResult< Actor > BehaviorBackUp< Actor >::Update( Actor *me, float interval )
+{
+	if ( m_giveUpTimer.IsElapsed() )
+	{
+		return Done();
+	}
+
+// 	if ( m_jumpTimer.HasStarted() && m_jumpTimer.IsElapsed() )
+// 	{
+// 		me->GetLocomotionInterface()->Jump();
+// 		m_jumpTimer.Invalidate();
+// 	}
+
+	ILocomotion *mover = me->GetLocomotionInterface();
+	if ( mover )
+	{
+		Vector goal;
+
+		if ( m_backupTimer.IsElapsed() )
+		{
+			// move towards bad spot
+			goal = m_avoidPos; // me->GetPosition() - 100.0f * m_way;
+		}
+		else
+		{
+			// move away from bad spot
+			goal = me->GetPosition() + 100.0f * m_way;
+		}
+
+		mover->Approach( goal );
+	}
+	
+	return Continue();
+}
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor >
+inline EventDesiredResult< Actor > BehaviorBackUp< Actor >::OnStuck( Actor *me )
+{
+	return TryToSustain( RESULT_IMPORTANT, "Stuck while trying to back up" );
+}
+
+
+
+#endif // _BEHAVIOR_BACK_UP_H_
+
diff --git a/game/server/NextBot/Behavior/BehaviorMoveTo.h b/game/server/NextBot/Behavior/BehaviorMoveTo.h
new file mode 100644
index 00000000..f3b608fb
--- /dev/null
+++ b/game/server/NextBot/Behavior/BehaviorMoveTo.h
@@ -0,0 +1,126 @@
+// BehaviorMoveTo.h
+// Move to a potentially far away position
+// Author: Michael Booth, June 2007
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _BEHAVIOR_MOVE_TO_H_
+#define _BEHAVIOR_MOVE_TO_H_
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Move to a potentially far away position, using path planning.
+ */
+template < typename Actor, typename PathCost >
+class BehaviorMoveTo : public Action< Actor >
+{
+public:
+	BehaviorMoveTo( const Vector &goal, Action< Actor > *successAction = NULL, Action< Actor > *failAction = NULL );
+
+	virtual ActionResult< Actor > OnStart( Actor *me, Action< Actor > *priorAction );
+	virtual ActionResult< Actor > Update( Actor *me, float interval );
+
+	virtual EventDesiredResult< Actor > OnMoveToSuccess( Actor *me, const Path *path );
+	virtual EventDesiredResult< Actor > OnMoveToFailure( Actor *me, const Path *path, MoveToFailureType reason );
+
+	virtual bool ComputePath( Actor *me, const Vector &goal, PathFollower *path );
+
+	virtual const char *GetName( void ) const	{ return "BehaviorMoveTo"; }
+
+private:
+	Vector m_goal;
+	PathFollower m_path;
+	Action< Actor > *m_successAction;
+	Action< Actor > *m_failAction;
+};
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor, typename PathCost >
+inline BehaviorMoveTo< Actor, PathCost >::BehaviorMoveTo( const Vector &goal, Action< Actor > *successAction, Action< Actor > *failAction )
+{
+	m_goal = goal;
+	m_path.Invalidate();
+	m_successAction = successAction;
+	m_failAction = failAction;
+}
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor, typename PathCost >
+inline bool BehaviorMoveTo< Actor, PathCost >::ComputePath( Actor *me, const Vector &goal, PathFollower *path )
+{
+	PathCost cost( me );
+	return path->Compute( me, goal, cost );
+}
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor, typename PathCost >
+inline ActionResult< Actor > BehaviorMoveTo< Actor, PathCost >::OnStart( Actor *me, Action< Actor > *priorAction )
+{
+	if ( !this->ComputePath( me, m_goal, &m_path ) )
+	{
+		if ( m_failAction )
+		{
+			return this->ChangeTo( m_failAction, "No path to goal" );
+		}
+
+		return this->Done( "No path to goal" );
+	}
+
+	return this->Continue();
+}
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor, typename PathCost >
+inline ActionResult< Actor > BehaviorMoveTo< Actor, PathCost >::Update( Actor *me, float interval )
+{
+	// if path became invalid during last tick for any reason, we're done
+	if ( !m_path.IsValid() )
+	{
+		if ( m_failAction )
+		{
+			return this->ChangeTo( m_failAction, "Path is invalid" );
+		}
+
+		return this->Done( "Path is invalid" );
+	}
+
+	// move along path - success/fail event handlers will exit behavior when goal is reached
+	m_path.Update( me );
+
+	return this->Continue();
+}
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor, typename PathCost >
+inline EventDesiredResult< Actor > BehaviorMoveTo< Actor, PathCost >::OnMoveToSuccess( Actor *me, const Path *path )
+{
+	if ( m_successAction )
+	{
+		return this->TryChangeTo( m_successAction, RESULT_CRITICAL, "OnMoveToSuccess" );
+	}
+
+	return this->TryDone( RESULT_CRITICAL, "OnMoveToSuccess" );
+}
+
+
+//----------------------------------------------------------------------------------------------
+template < typename Actor, typename PathCost >
+inline EventDesiredResult< Actor > BehaviorMoveTo< Actor, PathCost >::OnMoveToFailure( Actor *me, const Path *path, MoveToFailureType reason )
+{
+	if ( m_failAction )
+	{
+		return this->TryChangeTo( m_failAction, RESULT_CRITICAL, "OnMoveToFailure" );
+	}
+
+	return this->TryDone( RESULT_CRITICAL, "OnMoveToFailure" );
+}
+
+
+
+#endif // _BEHAVIOR_MOVE_TO_H_
+
diff --git a/game/server/NextBot/NavMeshEntities/func_nav_prerequisite.cpp b/game/server/NextBot/NavMeshEntities/func_nav_prerequisite.cpp
new file mode 100644
index 00000000..5ac954a0
--- /dev/null
+++ b/game/server/NextBot/NavMeshEntities/func_nav_prerequisite.cpp
@@ -0,0 +1,75 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// NextBot paths that go through this entity must fulfill the given prerequisites to pass
+// Michael Booth, August 2009
+
+#include "cbase.h"
+#include "func_nav_prerequisite.h"
+#include "ndebugoverlay.h"
+#include "modelentities.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+LINK_ENTITY_TO_CLASS( func_nav_prerequisite, CFuncNavPrerequisite );
+
+BEGIN_DATADESC( CFuncNavPrerequisite )
+	DEFINE_KEYFIELD( m_task,			FIELD_INTEGER,	"Task" ),
+	DEFINE_KEYFIELD( m_taskEntityName,	FIELD_STRING,	"Entity" ),
+	DEFINE_KEYFIELD( m_taskValue,		FIELD_FLOAT,	"Value" ),
+	DEFINE_KEYFIELD( m_isDisabled,		FIELD_BOOLEAN,	"StartDisabled" ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
+END_DATADESC()
+
+IMPLEMENT_AUTO_LIST( IFuncNavPrerequisiteAutoList );
+
+
+//-----------------------------------------------------------------------------
+CFuncNavPrerequisite::CFuncNavPrerequisite()
+{
+	m_task = TASK_NONE;
+	m_hTaskEntity = NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+void CFuncNavPrerequisite::Spawn( void )
+{
+	AddSpawnFlags( SF_TRIGGER_ALLOW_CLIENTS );
+
+	BaseClass::Spawn();
+	InitTrigger();
+}
+
+
+//-----------------------------------------------------------------------------
+bool CFuncNavPrerequisite::IsTask( TaskType task ) const
+{
+	return task == m_task ? true : false;
+}
+
+
+//-----------------------------------------------------------------------------
+CBaseEntity *CFuncNavPrerequisite::GetTaskEntity( void )
+{
+	if ( m_hTaskEntity == NULL )
+	{
+		m_hTaskEntity = gEntList.FindEntityByName( NULL, m_taskEntityName );
+	}
+	return m_hTaskEntity;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void CFuncNavPrerequisite::InputEnable( inputdata_t &inputdata )
+{
+	m_isDisabled = false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void CFuncNavPrerequisite::InputDisable( inputdata_t &inputdata )
+{
+	m_isDisabled = true;
+}
diff --git a/game/server/NextBot/NavMeshEntities/func_nav_prerequisite.h b/game/server/NextBot/NavMeshEntities/func_nav_prerequisite.h
new file mode 100644
index 00000000..bcc23f6e
--- /dev/null
+++ b/game/server/NextBot/NavMeshEntities/func_nav_prerequisite.h
@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// NextBot paths that go through this entity must fulfill the given prerequisites to pass
+// Michael Booth, August 2009
+
+#ifndef FUNC_NAV_PREREQUISITE_H
+#define FUNC_NAV_PREREQUISITE_H
+
+#include "triggers.h"
+
+/**
+ * NextBot paths that pass through this entity must fulfill the given prerequisites to pass
+ */
+DECLARE_AUTO_LIST( IFuncNavPrerequisiteAutoList );
+
+class CFuncNavPrerequisite : public CBaseTrigger, public IFuncNavPrerequisiteAutoList
+{
+	DECLARE_CLASS( CFuncNavPrerequisite, CBaseTrigger );
+
+public:
+	CFuncNavPrerequisite();
+
+	DECLARE_DATADESC();
+
+	virtual void Spawn( void );
+
+	enum TaskType
+	{
+		TASK_NONE = 0,
+		TASK_DESTROY_ENTITY = 1,
+		TASK_MOVE_TO_ENTITY = 2,
+		TASK_WAIT			= 3,
+	};
+
+	bool IsTask( TaskType type ) const;
+	CBaseEntity *GetTaskEntity( void );
+	float GetTaskValue( void ) const;
+
+	void InputEnable( inputdata_t &inputdata );
+	void InputDisable( inputdata_t &inputdata );
+	bool IsEnabled( void ) const { return !m_isDisabled; }
+
+protected:
+	int m_task;
+	string_t m_taskEntityName;
+	float m_taskValue;
+	bool m_isDisabled;
+	EHANDLE m_hTaskEntity;
+};
+
+inline float CFuncNavPrerequisite::GetTaskValue( void ) const
+{
+	return m_taskValue;
+}
+
+
+#endif // FUNC_NAV_PREREQUISITE_H
diff --git a/game/server/NextBot/NextBot.cpp b/game/server/NextBot/NextBot.cpp
new file mode 100644
index 00000000..0165a033
--- /dev/null
+++ b/game/server/NextBot/NextBot.cpp
@@ -0,0 +1,523 @@
+// NextBotCombatCharacter.cpp
+// Next generation bot system
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "team.h"
+#include "CRagdollMagnet.h"
+
+#include "NextBot.h"
+#include "NextBotLocomotionInterface.h"
+#include "NextBotBodyInterface.h"
+
+#ifdef TERROR
+#include "TerrorGamerules.h"
+#endif
+
+#include "vprof.h"
+#include "datacache/imdlcache.h"
+#include "EntityFlame.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+ConVar NextBotStop( "nb_stop", "0", FCVAR_CHEAT | FCVAR_REPLICATED, "Stop all NextBots" );
+
+
+//--------------------------------------------------------------------------------------------------------
+class CSendBotCommand
+{
+public:
+	CSendBotCommand( const char *command )
+	{
+		m_command = command;
+	}
+
+	bool operator() ( INextBot *bot )
+	{
+		bot->OnCommandString( m_command );
+		return true;
+	}
+
+	const char *m_command;
+};
+
+
+CON_COMMAND_F( nb_command, "Sends a command string to all bots", FCVAR_CHEAT )
+{
+	if ( args.ArgC() <= 1 )
+	{
+		Msg( "Missing command string" );
+		return;
+	}
+
+	CSendBotCommand sendCmd( args.ArgS() );
+	TheNextBots().ForEachBot( sendCmd );
+}
+
+
+
+//-----------------------------------------------------------------------------------------------------
+BEGIN_DATADESC( NextBotCombatCharacter )
+
+	DEFINE_THINKFUNC( DoThink ),
+
+END_DATADESC()
+
+
+//-----------------------------------------------------------------------------------------------------
+IMPLEMENT_SERVERCLASS_ST( NextBotCombatCharacter, DT_NextBot )
+END_SEND_TABLE()
+
+
+//-----------------------------------------------------------------------------------------------------
+NextBotDestroyer::NextBotDestroyer( int team )
+{
+	m_team = team;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+bool NextBotDestroyer::operator() ( INextBot *bot  )
+{
+	if ( m_team == TEAM_ANY || bot->GetEntity()->GetTeamNumber() == m_team )
+	{
+		// players need to be kicked, not deleted
+		if ( bot->GetEntity()->IsPlayer() )
+		{
+			CBasePlayer *player = dynamic_cast< CBasePlayer * >( bot->GetEntity() );
+			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", player->GetUserID() ) );
+		}
+		else
+		{
+			UTIL_Remove( bot->GetEntity() );
+		}
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+CON_COMMAND_F( nb_delete_all, "Delete all non-player NextBot entities.", FCVAR_CHEAT )
+{
+	// Listenserver host or rcon access only!
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	CTeam *team = NULL;
+
+	if ( args.ArgC() == 2 )
+	{
+		const char *teamName = args[1];
+
+		for( int i=0; i < g_Teams.Count(); ++i )
+		{
+			if ( FStrEq( teamName, g_Teams[i]->GetName() ) )
+			{
+				// delete all bots on this team
+				team = g_Teams[i];
+				break;
+			}
+		}
+
+		if ( team == NULL )
+		{
+			Msg( "Invalid team '%s'\n", teamName );
+			return;
+		}
+	}
+
+	// delete all bots on all teams
+	NextBotDestroyer destroyer( team ? team->GetTeamNumber() : TEAM_ANY );
+	TheNextBots().ForEachBot( destroyer );
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+class NextBotApproacher
+{
+public:
+	NextBotApproacher( void )
+	{
+		CBasePlayer *player = UTIL_GetListenServerHost();
+		if ( player )
+		{
+			Vector forward;
+			player->EyeVectors( &forward );
+
+			trace_t result;
+			unsigned int mask = MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE | CONTENTS_GRATE | CONTENTS_WINDOW;
+			UTIL_TraceLine( player->EyePosition(), player->EyePosition() + 999999.9f * forward, mask, player, COLLISION_GROUP_NONE, &result );
+			if ( result.DidHit() )
+			{
+				NDebugOverlay::Cross3D( result.endpos, 5, 0, 255, 0, true, 10.0f );
+				m_isGoalValid = true;
+				m_goal = result.endpos;
+			}
+			else
+			{
+				m_isGoalValid = false;
+			}
+		}
+	}
+
+	bool operator() ( INextBot *bot )
+	{
+		if ( TheNextBots().IsDebugFilterMatch( bot ) )
+		{
+			bot->OnCommandApproach( m_goal );
+		}
+		return true;
+	}
+
+	bool m_isGoalValid;
+	Vector m_goal;
+};
+
+CON_COMMAND_F( nb_move_to_cursor, "Tell all NextBots to move to the cursor position", FCVAR_CHEAT )
+{
+	// Listenserver host or rcon access only!
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	NextBotApproacher approach;
+	TheNextBots().ForEachBot( approach );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------
+bool IgnoreActorsTraceFilterFunction( IHandleEntity *pServerEntity, int contentsMask )
+{
+	CBaseEntity *entity = EntityFromEntityHandle( pServerEntity );
+	return ( entity->MyCombatCharacterPointer() == NULL );	// includes all bots, npcs, players, and TF2 buildings
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------
+bool VisionTraceFilterFunction( IHandleEntity *pServerEntity, int contentsMask )
+{
+	// Honor BlockLOS also to allow seeing through partially-broken doors
+	CBaseEntity *entity = EntityFromEntityHandle( pServerEntity );
+	return ( entity->MyCombatCharacterPointer() == NULL && entity->BlocksLOS() );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------
+
+NextBotCombatCharacter::NextBotCombatCharacter( void )
+
+{
+	m_lastAttacker = NULL;
+	m_didModelChange = false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::Spawn( void )
+{
+	BaseClass::Spawn();
+	
+	// reset bot components
+	Reset();
+
+	SetSolid( SOLID_BBOX );
+	AddSolidFlags( FSOLID_NOT_STANDABLE );
+	
+	SetMoveType( MOVETYPE_CUSTOM );	
+	
+	SetCollisionGroup( COLLISION_GROUP_PLAYER );
+
+	m_iMaxHealth = m_iHealth;
+	m_takedamage = DAMAGE_YES;
+
+	MDLCACHE_CRITICAL_SECTION();
+	InitBoneControllers( ); 
+
+	// set up think callback
+	SetThink( &NextBotCombatCharacter::DoThink );
+	SetNextThink( gpGlobals->curtime );
+
+	m_lastAttacker = NULL;
+}
+
+
+bool NextBotCombatCharacter::IsAreaTraversable( const CNavArea *area ) const
+{
+	if ( !area )
+		return false;
+	ILocomotion *mover = GetLocomotionInterface();
+	if ( mover && !mover->IsAreaTraversable( area ) )
+		return false;
+	return BaseClass::IsAreaTraversable( area );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::DoThink( void )
+{
+	VPROF_BUDGET( "NextBotCombatCharacter::DoThink", "NextBot" );
+
+	SetNextThink( gpGlobals->curtime );
+
+	if ( BeginUpdate() )
+	{
+		// emit model change event	
+		if ( m_didModelChange )
+		{
+			m_didModelChange = false;
+
+			OnModelChanged();
+
+			// propagate model change into NextBot event responders
+			for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+			{
+				sub->OnModelChanged();
+			}	
+		}
+
+		UpdateLastKnownArea();	
+
+		// update bot components
+		if ( !NextBotStop.GetBool() && (GetFlags() & FL_FROZEN) == 0 )
+		{
+			Update();
+		}
+
+		EndUpdate();
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::Touch( CBaseEntity *other )
+{
+	if ( ShouldTouch( other ) )
+	{
+		// propagate touch into NextBot event responders
+		trace_t result;
+		result = GetTouchTrace();
+
+		// OnContact refers to *physical* contact, not triggers or other non-physical entities
+		if ( result.DidHit() || other->MyCombatCharacterPointer() != NULL )
+		{
+			OnContact( other, &result );
+		}
+	}
+	
+	BaseClass::Touch( other );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::SetModel( const char *szModelName )
+{
+	// actually change the model
+	BaseClass::SetModel( szModelName );
+	
+	// need to do a lazy-check because precache system also invokes this
+	m_didModelChange = true;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::Ignite( float flFlameLifetime, bool bNPCOnly, float flSize, bool bCalledByLevelDesigner )
+{
+	BaseClass::Ignite( flFlameLifetime, bNPCOnly, flSize, bCalledByLevelDesigner );
+	
+	// propagate event to components
+	OnIgnite();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::Ignite( float flFlameLifetime, CBaseEntity *pAttacker )
+{
+	if ( IsOnFire() )
+		return;
+
+	// BaseClass::Ignite stuff, plus SetAttacker on the flame, so our attacker gets credit
+	CEntityFlame *pFlame = CEntityFlame::Create( this );
+	if ( pFlame )
+	{
+		pFlame->SetLifetime( flFlameLifetime );
+		AddFlag( FL_ONFIRE );
+
+		SetEffectEntity( pFlame );
+	}
+	m_OnIgnite.FireOutput( this, this );
+
+	// propagate event to components
+	OnIgnite();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+int NextBotCombatCharacter::OnTakeDamage_Alive( const CTakeDamageInfo &info )
+{
+	// track our last attacker
+	if ( info.GetAttacker() && info.GetAttacker()->MyCombatCharacterPointer() )
+	{
+		m_lastAttacker = info.GetAttacker()->MyCombatCharacterPointer();
+	}
+
+	// propagate event to components
+	OnInjured( info );
+	
+	return CBaseCombatCharacter::OnTakeDamage_Alive( info );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+int NextBotCombatCharacter::OnTakeDamage_Dying( const CTakeDamageInfo &info )
+{
+	// track our last attacker	
+	if ( info.GetAttacker()->MyCombatCharacterPointer() )
+	{
+		m_lastAttacker = info.GetAttacker()->MyCombatCharacterPointer();
+	}
+
+	// propagate event to components
+	OnInjured( info );
+
+	return CBaseCombatCharacter::OnTakeDamage_Dying( info );
+}
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Can't use CBaseCombatCharacter's Event_Killed because it will immediately ragdoll us
+ */
+static int g_DeathStartEvent = 0;
+void NextBotCombatCharacter::Event_Killed( const CTakeDamageInfo &info )
+{
+	// track our last attacker
+	if ( info.GetAttacker() && info.GetAttacker()->MyCombatCharacterPointer() )
+	{
+		m_lastAttacker = info.GetAttacker()->MyCombatCharacterPointer();
+	}
+
+	// propagate event to my components
+	OnKilled( info );
+	
+	// Advance life state to dying
+	m_lifeState = LIFE_DYING;
+
+#ifdef TERROR
+	/*
+	 * TODO: Make this game-generic
+	 */
+	// Create the death event just like players do.
+	TerrorGameRules()->DeathNoticeForEntity( this, info );
+
+	// Infected specific event
+	TerrorGameRules()->DeathNoticeForInfected( this, info );
+#endif
+
+	if ( GetOwnerEntity() != NULL )
+	{
+		GetOwnerEntity()->DeathNotice( this );
+	}
+
+	// inform the other bots
+	TheNextBots().OnKilled( this, info );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::PerformCustomPhysics( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity )
+{
+	ILocomotion *mover = GetLocomotionInterface();
+	if ( mover )
+	{
+		// hack to keep ground entity from being NULL'd when Z velocity is positive
+		SetGroundEntity( mover->GetGround() );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+bool NextBotCombatCharacter::BecomeRagdoll( const CTakeDamageInfo &info, const Vector &forceVector )
+{
+	// See if there's a ragdoll magnet that should influence our force.
+	Vector adjustedForceVector = forceVector;
+	CRagdollMagnet *magnet = CRagdollMagnet::FindBestMagnet( this );
+	if ( magnet )
+	{
+		adjustedForceVector += magnet->GetForceVector( this );
+	}
+
+	// clear the deceased's sound channels.(may have been firing or reloading when killed)
+	EmitSound( "BaseCombatCharacter.StopWeaponSounds" );
+
+	return BaseClass::BecomeRagdoll( info, adjustedForceVector );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::HandleAnimEvent( animevent_t *event )
+{
+	// propagate event to components
+	OnAnimationEvent( event );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Propagate event into NextBot event responders
+ */
+void NextBotCombatCharacter::OnNavAreaChanged( CNavArea *enteredArea, CNavArea *leftArea )
+{
+	INextBotEventResponder::OnNavAreaChanged( enteredArea, leftArea );
+
+	BaseClass::OnNavAreaChanged( enteredArea, leftArea );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+Vector NextBotCombatCharacter::EyePosition( void )
+{
+	if ( GetBodyInterface() )
+	{
+		return GetBodyInterface()->GetEyePosition();
+	}
+
+	return BaseClass::EyePosition();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this object can be +used by the bot
+ */
+bool NextBotCombatCharacter::IsUseableEntity( CBaseEntity *entity, unsigned int requiredCaps )
+{
+	if ( entity )
+	{
+		int caps = entity->ObjectCaps();
+		if ( caps & (FCAP_IMPULSE_USE|FCAP_CONTINUOUS_USE|FCAP_ONOFF_USE|FCAP_DIRECTIONAL_USE) )
+		{
+			if ( (caps & requiredCaps) == requiredCaps )
+			{
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotCombatCharacter::UseEntity( CBaseEntity *entity, USE_TYPE useType )
+{
+	if ( IsUseableEntity( entity ) )
+	{
+		variant_t emptyVariant;
+		entity->AcceptInput( "Use", this, this, emptyVariant, useType );
+	}
+}
diff --git a/game/server/NextBot/NextBot.h b/game/server/NextBot/NextBot.h
new file mode 100644
index 00000000..ae89cab1
--- /dev/null
+++ b/game/server/NextBot/NextBot.h
@@ -0,0 +1,104 @@
+// NextBotCombatCharacter.h
+// Next generation bot system
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_H_
+#define _NEXT_BOT_H_
+
+#include "NextBotInterface.h"
+#include "NextBotManager.h"
+
+#ifdef TERROR
+#include "player_lagcompensation.h"
+#endif
+
+class NextBotCombatCharacter;
+struct animevent_t;
+
+extern ConVar NextBotStop;
+
+
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * A Next Bot derived from CBaseCombatCharacter
+ */
+class NextBotCombatCharacter : public CBaseCombatCharacter, public INextBot
+{
+public:
+	DECLARE_CLASS( NextBotCombatCharacter, CBaseCombatCharacter );
+	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+	
+	NextBotCombatCharacter( void );
+	virtual ~NextBotCombatCharacter() { }
+
+	virtual void Spawn( void );
+
+	virtual Vector EyePosition( void );
+
+	virtual INextBot *MyNextBotPointer( void ) { return this; }
+
+	// Event hooks into NextBot system ---------------------------------------
+	virtual int OnTakeDamage_Alive( const CTakeDamageInfo &info );
+	virtual int OnTakeDamage_Dying( const CTakeDamageInfo &info );
+	virtual void Event_Killed( const CTakeDamageInfo &info );
+	virtual void HandleAnimEvent( animevent_t *event );
+	virtual void OnNavAreaChanged( CNavArea *enteredArea, CNavArea *leftArea );	// invoked (by UpdateLastKnownArea) when we enter a new nav area (or it is reset to NULL)
+	virtual void Touch( CBaseEntity *other );
+	virtual void SetModel( const char *szModelName );
+	virtual void Ignite( float flFlameLifetime, bool bNPCOnly = true, float flSize = 0.0f, bool bCalledByLevelDesigner = false );
+	virtual void Ignite( float flFlameLifetime, CBaseEntity *pAttacker );
+	//------------------------------------------------------------------------
+
+	virtual bool IsUseableEntity( CBaseEntity *entity, unsigned int requiredCaps = 0 );
+	void UseEntity( CBaseEntity *entity, USE_TYPE useType = USE_TOGGLE );
+
+	// Implement this if you use MOVETYPE_CUSTOM
+	virtual void PerformCustomPhysics( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity );
+
+	virtual bool BecomeRagdoll( const CTakeDamageInfo &info, const Vector &forceVector );
+	
+	// hook to INextBot update
+	void DoThink( void );
+
+	// expose to public
+	int	GetLastHitGroup( void ) const;								// where on our body were we injured last
+
+	virtual bool IsAreaTraversable( const CNavArea *area ) const;							// return true if we can use the given area 
+
+	virtual CBaseCombatCharacter *GetLastAttacker( void ) const;	// return the character who last attacked me
+
+	// begin INextBot public interface ----------------------------------------------------------------
+	virtual NextBotCombatCharacter *GetEntity( void ) const			{ return const_cast< NextBotCombatCharacter * >( this ); }
+	virtual NextBotCombatCharacter *GetNextBotCombatCharacter( void ) const	{ return const_cast< NextBotCombatCharacter * >( this ); }
+	
+
+private:
+	EHANDLE m_lastAttacker;
+	
+	bool m_didModelChange;
+};
+
+
+inline CBaseCombatCharacter *NextBotCombatCharacter::GetLastAttacker( void ) const
+{
+	return ( m_lastAttacker.Get() == NULL ) ? NULL : m_lastAttacker->MyCombatCharacterPointer();
+}
+
+inline int NextBotCombatCharacter::GetLastHitGroup( void ) const
+{
+	return LastHitGroup();
+}
+
+//-----------------------------------------------------------------------------------------------------
+class NextBotDestroyer
+{
+public:
+	NextBotDestroyer( int team );
+	bool operator() ( INextBot *bot );
+	int m_team;			// the team to delete bots from, or TEAM_ANY for any team
+};
+
+#endif // _NEXT_BOT_H_
diff --git a/game/server/NextBot/NextBotAttentionInterface.cpp b/game/server/NextBot/NextBotAttentionInterface.cpp
new file mode 100644
index 00000000..a7745512
--- /dev/null
+++ b/game/server/NextBot/NextBotAttentionInterface.cpp
@@ -0,0 +1,162 @@
+// NextBotAttentionInterface.cpp
+// Manage what this bot pays attention to
+// Author: Michael Booth, April 2007
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "NextBot.h"
+#include "NextBotAttentionInterface.h"
+#include "NextBotBodyInterface.h"
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Reset to initial state
+ */
+void IAttention::Reset( void )
+{
+	m_body = GetBot()->GetBodyInterface();
+
+	m_attentionSet.RemoveAll();
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Update internal state
+ */
+void IAttention::Update( void )
+{
+}
+
+
+//------------------------------------------------------------------------------------------
+void IAttention::AttendTo( const CBaseCombatCharacter *who, const char *reason )
+{
+	if ( !IsAwareOf( who ) )
+	{
+		PointOfInterest p;
+		p.m_type = PointOfInterest::WHO;
+		p.m_who = who;
+		p.m_duration.Start();
+
+		m_attentionSet.AddToTail( p );
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+void IAttention::AttendTo( const CBaseEntity *what, const char *reason )
+{
+	if ( !IsAwareOf( what ) )
+	{
+		PointOfInterest p;
+		p.m_type = PointOfInterest::WHAT;
+		p.m_what = what;
+		p.m_duration.Start();
+
+		m_attentionSet.AddToTail( p );
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+void IAttention::AttendTo( const Vector &where, IAttention::SignificanceLevel significance, const char *reason )
+{
+	PointOfInterest p;
+	p.m_type = PointOfInterest::WHERE;
+	p.m_where = where;
+	p.m_duration.Start();
+
+	m_attentionSet.AddToTail( p );
+}
+
+
+//------------------------------------------------------------------------------------------
+void IAttention::Disregard( const CBaseCombatCharacter *who, const char *reason )
+{
+	FOR_EACH_VEC( m_attentionSet, it )
+	{
+		if ( m_attentionSet[ it ].m_type == PointOfInterest::WHO )
+		{
+			CBaseCombatCharacter *myWho = m_attentionSet[ it ].m_who;
+
+			if ( !myWho || myWho->entindex() == who->entindex() )
+			{
+				m_attentionSet.Remove( it );
+				return;
+			}
+		}
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+void IAttention::Disregard( const CBaseEntity *what, const char *reason )
+{
+	FOR_EACH_VEC( m_attentionSet, it )
+	{
+		if ( m_attentionSet[ it ].m_type == PointOfInterest::WHAT )
+		{
+			CBaseCombatCharacter *myWhat = m_attentionSet[ it ].m_what;
+
+			if ( !myWhat || myWhat->entindex() == what->entindex() )
+			{
+				m_attentionSet.Remove( it );
+				return;
+			}
+		}
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Return true if given actor is in our attending set
+ */
+bool IAttention::IsAwareOf( const CBaseCombatCharacter *who ) const
+{
+	FOR_EACH_VEC( m_attentionSet, it )
+	{
+		if ( m_attentionSet[ it ].m_type == PointOfInterest::WHO )
+		{
+			CBaseCombatCharacter *myWho = m_attentionSet[ it ].m_who;
+
+			if ( myWho && myWho->entindex() == who->entindex() )
+			{
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Return true if given object is in our attending set
+ */
+bool IAttention::IsAwareOf( const CBaseEntity *what ) const
+{
+	FOR_EACH_VEC( m_attentionSet, it )
+	{
+		if ( m_attentionSet[ it ].m_type == PointOfInterest::WHAT )
+		{
+			CBaseEntity *myWhat = m_attentionSet[ it ].m_what;
+
+			if ( myWhat && myWhat->entindex() == what->entindex() )
+			{
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
\ No newline at end of file
diff --git a/game/server/NextBot/NextBotAttentionInterface.h b/game/server/NextBot/NextBotAttentionInterface.h
new file mode 100644
index 00000000..26bec43c
--- /dev/null
+++ b/game/server/NextBot/NextBotAttentionInterface.h
@@ -0,0 +1,81 @@
+// NextBotAttentionInterface.h
+// Manage what this bot pays attention to
+// Author: Michael Booth, April 2007
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_ATTENTION_INTERFACE_H_
+#define _NEXT_BOT_ATTENTION_INTERFACE_H_
+
+#include "NextBotComponentInterface.h"
+
+class INextBot;
+class IBody;
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for managing what a bot pays attention to.
+ * Vision determines what see see and notice -> Attention determines which of those things we look at -> Low level head/aiming simulation actually moves our head/eyes
+ */
+class IAttention : public INextBotComponent
+{
+public:
+	IAttention( INextBot *bot ) : INextBotComponent( bot ) { }
+	virtual ~IAttention() { }
+
+	virtual void Reset( void )	{ }										// reset to initial state
+	virtual void Update( void ) { }										// update internal state
+
+	enum SignificanceLevel
+	{
+		BORING,					// background noise
+		INTERESTING,			// notably interesting
+		COMPELLING,				// very hard to pay attention to anything else
+		IRRESISTIBLE,			// can't look away
+	};
+
+	// override these to control the significance of entities in a context-specific way
+	virtual int CompareSignificance( const CBaseEntity *a, const CBaseEntity *b ) const;	// returns <0 if a < b, 0 if a==b, or >0 if a>b
+
+	// bring things to our attention
+	virtual void AttendTo( CBaseEntity *what, const char *reason = NULL );
+	virtual void AttendTo( const Vector &where, SignificanceLevel significance, const char *reason = NULL );
+
+	// remove things from our attention
+	virtual void Disregard( CBaseEntity *what, const char *reason = NULL );
+
+	virtual bool IsAwareOf( CBaseEntity *what ) const;								// return true if given object is in our attending set
+	virtual float GetAwareDuration( CBaseEntity *what ) const;						// return how long we've been aware of this entity
+
+	// INextBotEventResponder ------------------------------------------------------------------
+	virtual void OnInjured( const CTakeDamageInfo &info );							// when bot is damaged by something
+	virtual void OnContact( CBaseEntity *other, CGameTrace *result = NULL );		// invoked when bot touches 'other'
+	virtual void OnSight( CBaseEntity *subject );									// when subject initially enters bot's visual awareness
+	virtual void OnLostSight( CBaseEntity *subject );								// when subject leaves enters bot's visual awareness
+	virtual void OnSound( CBaseEntity *source, const CSoundParameters &params );	// when an entity emits a sound
+
+
+private:
+	IBody *m_body;							// to access head aiming
+
+	struct PointOfInterest
+	{
+		enum { ENTITY, POSITION } m_type;
+		CHandle< CBaseEntity > m_entity;
+		Vector m_position;
+
+		IntervalTimer m_duration;			// how long has this PoI been in our attention set
+	};
+
+	CUtlVector< PointOfInterest > m_attentionSet;	// the set of things we are attending to
+
+	
+};
+
+inline int IAttention::CompareSignificance( const CBaseEntity *a, const CBaseEntity *b ) const
+{
+	return 0;
+}
+
+#endif // _NEXT_BOT_ATTENTION_INTERFACE_H_
+
diff --git a/game/server/NextBot/NextBotBehavior.h b/game/server/NextBot/NextBotBehavior.h
new file mode 100644
index 00000000..2f92a841
--- /dev/null
+++ b/game/server/NextBot/NextBotBehavior.h
@@ -0,0 +1,1936 @@
+// NextBotBehaviorEngine.h
+// Behavioral system constructed from Actions
+// Author: Michael Booth, April 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _BEHAVIOR_ENGINE_H_
+#define _BEHAVIOR_ENGINE_H_
+
+#include "fmtstr.h"
+#include "NextBotEventResponderInterface.h"
+#include "NextBotContextualQueryInterface.h"
+#include "NextBotDebug.h"
+#include "tier0/vprof.h"
+
+
+//#define DEBUG_BEHAVIOR_MEMORY
+extern ConVar NextBotDebugHistory;
+
+/**
+ * Notes:
+ *
+ * By using return results to cause transitions, we ensure the atomic-ness
+ * of these transitions. For instance, it is not possible to change to a
+ * new Action and continue execution of code in the current Action.
+ *
+ * Creation and deletion of Actions during transitions allows passing of
+ * type-safe arguments between Actions via constructors.
+ *
+ * Events are propagated to each Action in the hierarchy.  If an
+ * action is suspended for another action, it STILL RECEIVES EVENTS
+ * that are not handled by the events "above it" in the suspend stack.
+ * In other words, the active Action gets the first response, and if it
+ * returns CONTINUE, the Action buried beneath it can process it,
+ * and so on deeper into the stack of suspended Actions.
+ *
+ * About events:
+ * It is not possible to have event handlers instantaneously change 
+ * state upon return due to out-of-order and recurrence issues, not
+ * to mention deleting the state out from under itself.  Therefore,
+ * events return DESIRED results, and the highest priority result
+ * is executed at the next Update().
+ *
+ * About buried Actions causing SUSPEND_FOR results:
+ * If a buried Action reacts to an event by returning a SUSPEND_FOR,
+ * the new interrupting Action is put at the TOP of the stack, burying
+ * whatever Action was there.
+ *
+ */
+
+
+// forward declaration
+template < typename Actor > class Action;
+
+/**
+ * The possible consequences of an Action
+ */
+enum ActionResultType
+{ 
+	CONTINUE,			// continue executing this action next frame - nothing has changed
+	CHANGE_TO,			// change actions next frame
+	SUSPEND_FOR,		// put the current action on hold for the new action
+	DONE,				// this action has finished, resume suspended action
+	SUSTAIN,			// for use with event handlers - a way to say "It's important to keep doing what I'm doing"
+};
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Actions and Event processors return results derived from this class.
+ * Do not assemble this yourself - use the Continue(), ChangeTo(), Done(), and SuspendFor()
+ * methods within Action.
+ */
+template < typename Actor >
+struct IActionResult
+{
+	IActionResult( ActionResultType type = CONTINUE, Action< Actor > *action = NULL, const char *reason = NULL )
+	{
+		m_type = type;
+		m_action = action;
+		m_reason = reason;
+	}
+
+	bool IsDone( void ) const
+	{
+		return ( m_type == DONE );
+	}
+
+	bool IsContinue( void ) const
+	{
+		return ( m_type == CONTINUE );
+	}
+
+	bool IsRequestingChange( void ) const
+	{
+		return ( m_type == CHANGE_TO || m_type == SUSPEND_FOR || m_type == DONE );
+	}
+
+	const char *GetTypeName( void ) const
+	{
+		switch ( m_type )
+		{
+		case CHANGE_TO:		return "CHANGE_TO";
+		case SUSPEND_FOR:	return "SUSPEND_FOR";
+		case DONE:			return "DONE";
+		case SUSTAIN:		return "SUSTAIN";
+
+		default:
+		case CONTINUE:		return "CONTINUE";
+		}
+	}
+
+	ActionResultType m_type;
+	Action< Actor > *m_action;
+	const char *m_reason;
+};
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * When an Action is executed it returns this result.
+ * Do not assemble this yourself - use the Continue(), ChangeTo(), Done(), and SuspendFor()
+ * methods within Action.
+ */
+template < typename Actor >
+struct ActionResult : public IActionResult< Actor >
+{
+	// this is derived from IActionResult to ensure that ActionResult and EventDesiredResult cannot be silently converted
+	ActionResult( ActionResultType type = CONTINUE, Action< Actor > *action = NULL, const char *reason = NULL ) : IActionResult< Actor >( type, action, reason )	{ }
+};
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * When an event is processed, it returns this DESIRED result,
+ * which may or MAY NOT happen, depending on other event results
+ * that occur simultaneously.
+ * Do not assemble this yourself - use the TryContinue(), TryChangeTo(), TryDone(), TrySustain(),
+ * and TrySuspendFor() methods within Action.
+ */
+enum EventResultPriorityType
+{
+	RESULT_NONE,		// no result
+	RESULT_TRY,			// use this result, or toss it out, either is ok
+	RESULT_IMPORTANT,	// try extra-hard to use this result
+	RESULT_CRITICAL		// this result must be used - emit an error if it can't be
+};
+
+template < typename Actor >
+struct EventDesiredResult : public IActionResult< Actor >
+{
+	EventDesiredResult( ActionResultType type = CONTINUE, Action< Actor > *action = NULL, EventResultPriorityType priority = RESULT_TRY, const char *reason = NULL ) : IActionResult< Actor >( type, action, reason )
+	{
+		m_priority = priority;
+	}
+
+	EventResultPriorityType m_priority;
+};
+
+
+//-------------------------------------------------------------------------------------------------------------
+//-------------------------------------------------------------------------------------------------------------
+/**
+ * A Behavior is the root of an Action hierarchy as well as its container/manager.
+ * Instantiate a Behavior with the root Action of your behavioral system, and
+ * call Behavior::Update() to drive it.
+ */
+template < typename Actor >
+class Behavior : public INextBotEventResponder, public IContextualQuery
+{
+public:
+	DECLARE_CLASS( Behavior, INextBotEventResponder );
+
+	Behavior( Action< Actor > *initialAction, const char *name = "" ) : m_name( "%s", name )
+	{
+		m_action = initialAction;
+		m_me = NULL;
+	}
+
+	virtual ~Behavior() 
+	{
+		if ( m_me && m_action )
+		{
+			// allow all currently active Actions to end
+			m_action->InvokeOnEnd( m_me, this, NULL );
+			m_me = NULL;
+		}
+
+		// dig down to the bottom of the action stack and delete 
+		// that, so we don't leak action memory since action 
+		// destructors intentionally don't delete actions
+		// "buried" underneath them.
+		Action< Actor > *bottomAction;
+		for( bottomAction = m_action; bottomAction && bottomAction->m_buriedUnderMe; bottomAction = bottomAction->m_buriedUnderMe )
+			;
+
+		if ( bottomAction )
+		{
+			delete bottomAction;
+		}
+
+		// delete any dead Actions
+		m_deadActionVector.PurgeAndDeleteElements();
+	}
+
+	/**
+	 * Reset this Behavior with the given Action. If this Behavior
+	 * was already running, this will delete all current Actions and
+	 * restart the Behavior with the new one.
+	 */
+	void Reset( Action< Actor > *action )
+	{
+		if ( m_me && m_action )
+		{
+			// allow all currently active Actions to end
+			m_action->InvokeOnEnd( m_me, this, NULL );
+			m_me = NULL;
+		}
+
+		// find "bottom" action (see comment in destructor)
+		Action< Actor > *bottomAction;
+		for( bottomAction = m_action; bottomAction && bottomAction->m_buriedUnderMe; bottomAction = bottomAction->m_buriedUnderMe )
+			;
+
+		if ( bottomAction )
+		{
+			delete bottomAction;
+		}
+
+		// delete any dead Actions
+		m_deadActionVector.PurgeAndDeleteElements();
+
+		m_action = action;
+	}
+
+	/**
+	 * Return true if this Behavior contains no actions
+	 */
+	bool IsEmpty( void ) const
+	{
+		return m_action == NULL;
+	}
+
+	/**
+	 * Execute this Behavior
+	 */
+	void Update( Actor *me, float interval )
+	{
+		if ( me == NULL || IsEmpty() )
+		{
+			return;
+		}
+
+		m_me = me;
+
+		m_action = m_action->ApplyResult( me, this, m_action->InvokeUpdate( me, this, interval ) );
+
+		if ( m_action && me->IsDebugging( NEXTBOT_BEHAVIOR ) )
+		{
+			CFmtStr msg;
+			me->DisplayDebugText( msg.sprintf( "%s: %s", GetName(), m_action->DebugString() ) );
+		}
+
+		// delete any dead Actions
+		m_deadActionVector.PurgeAndDeleteElements();
+	}
+
+	/**
+	 * If this Behavior has not been Update'd in a long time,
+	 * call Resume() to let the system know its internal state may 
+	 * be out of date.
+	 */
+	void Resume( Actor *me )
+	{
+		if ( me == NULL || IsEmpty() )
+		{
+			return;
+		}
+
+		m_action = m_action->ApplyResult( me, this, m_action->OnResume( me, NULL ) );
+
+		if ( m_action && me->IsDebugging( NEXTBOT_BEHAVIOR ) )
+		{
+			CFmtStr msg;
+			me->DisplayDebugText( msg.sprintf( "%s: %s", GetName(), m_action->DebugString() ) );
+		}
+	}
+
+	/**
+	 * Use this method to destroy Actions used by this Behavior.
+	 * We cannot delete Actions in-line since Action updates can potentially
+	 * invoke event responders which will then use potentially deleted
+	 * Action pointers, causing memory corruption.
+	 * Instead, we will collect the dead Actions and delete them at the
+	 * end of Update().
+	 */
+	void DestroyAction( Action< Actor > *dead )
+	{
+		m_deadActionVector.AddToTail( dead );
+	}
+
+	const char *GetName( void ) const
+	{
+		return m_name;
+	}
+
+	// INextBotEventResponder propagation ----------------------------------------------------------------------
+	virtual INextBotEventResponder *FirstContainedResponder( void ) const
+	{
+		return m_action;
+	}
+
+	virtual INextBotEventResponder *NextContainedResponder( INextBotEventResponder *current ) const
+	{
+		return NULL;
+	}
+
+	// IContextualQuery propagation ----------------------------------------------------------------------------
+	virtual QueryResultType ShouldPickUp( const INextBot *me, CBaseEntity *item ) const		// if the desired item was available right now, should we pick it up?
+	{
+		QueryResultType result = ANSWER_UNDEFINED;
+
+		if ( m_action )
+		{
+			// find innermost child action
+			Action< Actor > *action;
+			for( action = m_action; action->m_child; action = action->m_child )
+				;
+
+			// work our way through our containers
+			while( action && result == ANSWER_UNDEFINED )
+			{
+				Action< Actor > *containingAction = action->m_parent;
+
+				// work our way up the stack
+				while( action && result == ANSWER_UNDEFINED )
+				{
+					result = action->ShouldPickUp( me, item );
+					action = action->GetActionBuriedUnderMe();
+				}
+
+				action = containingAction;
+			}
+		}
+
+		return result;
+	}
+
+	virtual QueryResultType ShouldHurry( const INextBot *me ) const					// are we in a hurry?
+	{
+		QueryResultType result = ANSWER_UNDEFINED;
+
+		if ( m_action )
+		{
+			// find innermost child action
+			Action< Actor > *action;
+			for( action = m_action; action->m_child; action = action->m_child )
+				;
+
+			// work our way through our containers
+			while( action && result == ANSWER_UNDEFINED )
+			{
+				Action< Actor > *containingAction = action->m_parent;
+
+				// work our way up the stack
+				while( action && result == ANSWER_UNDEFINED )
+				{
+					result = action->ShouldHurry( me );
+					action = action->GetActionBuriedUnderMe();
+				}
+
+				action = containingAction;
+			}
+		}
+
+		return result;
+	}
+
+	virtual QueryResultType ShouldRetreat( const INextBot *me ) const					// is it time to retreat?
+	{
+		QueryResultType result = ANSWER_UNDEFINED;
+
+		if ( m_action )
+		{
+			// find innermost child action
+			Action< Actor > *action;
+			for( action = m_action; action->m_child; action = action->m_child )
+				;
+
+			// work our way through our containers
+			while( action && result == ANSWER_UNDEFINED )
+			{
+				Action< Actor > *containingAction = action->m_parent;
+
+				// work our way up the stack
+				while( action && result == ANSWER_UNDEFINED )
+				{
+					result = action->ShouldRetreat( me );
+					action = action->GetActionBuriedUnderMe();
+				}
+
+				action = containingAction;
+			}
+		}
+
+		return result;
+	}
+
+	virtual QueryResultType ShouldAttack( const INextBot *me, const CKnownEntity *them ) const	// should we attack "them"?
+	{
+		QueryResultType result = ANSWER_UNDEFINED;
+
+		if ( m_action )
+		{
+			// find innermost child action
+			Action< Actor > *action;
+			for( action = m_action; action->m_child; action = action->m_child )
+				;
+
+			// work our way through our containers
+			while( action && result == ANSWER_UNDEFINED )
+			{
+				Action< Actor > *containingAction = action->m_parent;
+
+				// work our way up the stack
+				while( action && result == ANSWER_UNDEFINED )
+				{
+					result = action->ShouldAttack( me, them );
+					action = action->GetActionBuriedUnderMe();
+				}
+
+				action = containingAction;
+			}
+		}
+
+		return result;
+	}
+
+	virtual QueryResultType IsHindrance( const INextBot *me, CBaseEntity *blocker ) const	// return true if we should wait for 'blocker' that is across our path somewhere up ahead.
+	{
+		QueryResultType result = ANSWER_UNDEFINED;
+
+		if ( m_action )
+		{
+			// find innermost child action
+			Action< Actor > *action;
+			for( action = m_action; action->m_child; action = action->m_child )
+				;
+
+			// work our way through our containers
+			while( action && result == ANSWER_UNDEFINED )
+			{
+				Action< Actor > *containingAction = action->m_parent;
+
+				// work our way up the stack
+				while( action && result == ANSWER_UNDEFINED )
+				{
+					result = action->IsHindrance( me, blocker );
+					action = action->GetActionBuriedUnderMe();
+				}
+
+				action = containingAction;
+			}
+		}
+
+		return result;		
+	}
+
+
+	virtual Vector SelectTargetPoint( const INextBot *me, const CBaseCombatCharacter *subject ) const		// given a subject, return the world space position we should aim at
+	{
+		Vector result = vec3_origin;
+
+		if ( m_action )
+		{
+			// find innermost child action
+			Action< Actor > *action;
+			for( action = m_action; action->m_child; action = action->m_child )
+				;
+
+			// work our way through our containers
+			while( action && result == vec3_origin )
+			{
+				Action< Actor > *containingAction = action->m_parent;
+
+				// work our way up the stack
+				while( action && result == vec3_origin )
+				{
+					result = action->SelectTargetPoint( me, subject );
+					action = action->GetActionBuriedUnderMe();
+				}
+
+				action = containingAction;
+			}
+		}
+
+		return result;		
+	}
+
+
+	/**
+	 * Allow bot to approve of positions game movement tries to put him into.
+	 * This is most useful for bots derived from CBasePlayer that go through
+	 * the player movement system.
+	 */
+	virtual QueryResultType IsPositionAllowed( const INextBot *me, const Vector &pos ) const
+	{
+		QueryResultType result = ANSWER_UNDEFINED;
+
+		if ( m_action )
+		{
+			// find innermost child action
+			Action< Actor > *action;
+			for( action = m_action; action->m_child; action = action->m_child )
+				;
+
+			// work our way through our containers
+			while( action && result == ANSWER_UNDEFINED )
+			{
+				Action< Actor > *containingAction = action->m_parent;
+
+				// work our way up the stack
+				while( action && result == ANSWER_UNDEFINED )
+				{
+					result = action->IsPositionAllowed( me, pos );
+					action = action->GetActionBuriedUnderMe();
+				}
+
+				action = containingAction;
+			}
+		}
+
+		return result;		
+	}
+
+
+
+	virtual const CKnownEntity *SelectMoreDangerousThreat( const INextBot *me, const CBaseCombatCharacter *subject, const CKnownEntity *threat1, const CKnownEntity *threat2 ) const	// return the more dangerous of the two threats, or NULL if we have no opinion
+	{
+		const CKnownEntity *result = NULL;
+
+		if ( m_action )
+		{
+			// find innermost child action
+			Action< Actor > *action;
+			for( action = m_action; action->m_child; action = action->m_child )
+				;
+
+			// work our way through our containers
+			while( action && result == NULL )
+			{
+				Action< Actor > *containingAction = action->m_parent;
+
+				// work our way up the stack
+				while( action && result == NULL )
+				{
+					result = action->SelectMoreDangerousThreat( me, subject, threat1, threat2 );
+					action = action->GetActionBuriedUnderMe();
+				}
+
+				action = containingAction;
+			}
+		}
+
+		return result;		
+	}
+
+
+private:
+	Action< Actor > *m_action;
+
+	#define MAX_NAME_LENGTH 32
+	CFmtStrN< MAX_NAME_LENGTH > m_name;
+
+	Actor *m_me;
+
+	CUtlVector< Action< Actor > * > m_deadActionVector;		// completed Actions pending deletion
+};
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Something an Actor does.
+ * Actions can contain Actions, representing the precise context of the Actor's behavior.
+ * A system of Actions is contained within a Behavior, which acts as the manager
+ * of the Action system.
+ */
+template < typename Actor >
+class Action : public INextBotEventResponder, public IContextualQuery
+{
+public:
+	DECLARE_CLASS( Action, INextBotEventResponder );
+	
+	Action( void );
+	virtual ~Action();
+
+	virtual const char *GetName( void ) const = 0;		// return name of this action
+	virtual bool IsNamed( const char *name ) const;		// return true if given name matches the name of this Action
+	virtual const char *GetFullName( void ) const;		// return a temporary string showing the full lineage of this one action
+	Actor *GetActor( void ) const;						// return the Actor performing this Action (valid just before OnStart() is invoked)
+
+	//-----------------------------------------------------------------------------------------
+	/**
+	 * Try to start the Action. Result is immediately processed, 
+	 * which can cause an immediate transition, another OnStart(), etc.
+	 * An Action can count on each OnStart() being followed (eventually) with an OnEnd().
+	 */
+	virtual ActionResult< Actor >	OnStart( Actor *me, Action< Actor > *priorAction )							{ return Continue(); }
+
+	/**
+	 * Do the work of the Action. It is possible for Update to not be 
+	 * called between a given OnStart/OnEnd pair due to immediate transitions.
+	 */
+	virtual ActionResult< Actor >	Update( Actor *me, float interval )											{ return Continue(); }
+
+	// Invoked when an Action is ended for any reason
+	virtual void					OnEnd( Actor *me, Action< Actor > *nextAction )								{ }
+
+	/*
+	 * When an Action is suspended by a new action.
+	 * Note that only CONTINUE and DONE are valid results.  All other results will
+	 * be considered as a CONTINUE.
+	 */
+	virtual ActionResult< Actor >	OnSuspend( Actor *me, Action< Actor > *interruptingAction )					{ return Continue(); }
+	
+	// When an Action is resumed after being suspended
+	virtual ActionResult< Actor >	OnResume( Actor *me, Action< Actor > *interruptingAction )					{ return Continue(); }
+
+	/**
+	 * To cause a state change, use these methods to create an ActionResult to
+	 * return from OnStart, Update, or OnResume. 
+	 */
+	ActionResult< Actor > Continue( void ) const;
+	ActionResult< Actor > ChangeTo( Action< Actor > *action, const char *reason = NULL ) const;
+	ActionResult< Actor > SuspendFor( Action< Actor > *action, const char *reason = NULL ) const;
+	ActionResult< Actor > Done( const char *reason = NULL ) const;
+
+	// create and return an Action to start as sub-action within this Action when it starts
+	virtual Action< Actor > *InitialContainedAction( Actor *me )	{ return NULL; }
+
+	//-----------------------------------------------------------------------------------------
+	/**
+	 * Override the event handler methods below to respond to events that occur during this Action
+	 * NOTE: These are identical to the events in INextBotEventResponder with the addition
+	 * of an actor argument and a return result. Their translators are located in the private area 
+	 * below.
+	 */
+	virtual EventDesiredResult< Actor > OnLeaveGround( Actor *me, CBaseEntity *ground )							{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnLandOnGround( Actor *me, CBaseEntity *ground )						{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnContact( Actor *me, CBaseEntity *other, CGameTrace *result = NULL )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnMoveToSuccess( Actor *me, const Path *path )							{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnMoveToFailure( Actor *me, const Path *path, MoveToFailureType reason ) { return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnStuck( Actor *me )													{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnUnStuck( Actor *me )													{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnPostureChanged( Actor *me )											{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnAnimationActivityComplete( Actor *me, int activity )					{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnAnimationActivityInterrupted( Actor *me, int activity )				{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnAnimationEvent( Actor *me, animevent_t *event )						{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnIgnite( Actor *me )													{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnInjured( Actor *me, const CTakeDamageInfo &info )						{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnKilled( Actor *me, const CTakeDamageInfo &info )						{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnOtherKilled( Actor *me, CBaseCombatCharacter *victim, const CTakeDamageInfo &info )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnSight( Actor *me, CBaseEntity *subject )								{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnLostSight( Actor *me, CBaseEntity *subject )							{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnSound( Actor *me, CBaseEntity *source, const Vector &pos, KeyValues *keys )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnSpokeConcept( Actor *me, CBaseCombatCharacter *who, AIConcept_t concept, AI_Response *response )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnWeaponFired( Actor *me, CBaseCombatCharacter *whoFired, CBaseCombatWeapon *weapon )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnNavAreaChanged( Actor *me, CNavArea *newArea, CNavArea *oldArea )		{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnModelChanged( Actor *me )												{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnPickUp( Actor *me, CBaseEntity *item, CBaseCombatCharacter *giver )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnDrop( Actor *me, CBaseEntity *item )									{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnActorEmoted( Actor *me, CBaseCombatCharacter *emoter, int emote )			{ return TryContinue(); }
+
+	virtual EventDesiredResult< Actor > OnCommandAttack( Actor *me, CBaseEntity *victim )						{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCommandApproach( Actor *me, const Vector &pos, float range )			{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCommandApproach( Actor *me, CBaseEntity *goal )						{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCommandRetreat( Actor *me, CBaseEntity *threat, float range )			{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCommandPause( Actor *me, float duration )								{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCommandResume( Actor *me )											{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCommandString( Actor *me, const char *command )						{ return TryContinue(); }
+
+	virtual EventDesiredResult< Actor > OnShoved( Actor *me, CBaseEntity *pusher )								{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnBlinded( Actor *me, CBaseEntity *blinder )							{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnTerritoryContested( Actor *me, int territoryID )						{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnTerritoryCaptured( Actor *me, int territoryID )						{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnTerritoryLost( Actor *me, int territoryID )							{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnWin( Actor *me )														{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnLose( Actor *me )														{ return TryContinue(); }
+
+#ifdef DOTA_SERVER_DLL
+	virtual EventDesiredResult< Actor > OnCommandMoveTo( Actor *me, const Vector &pos ) { return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCommandMoveToAggressive( Actor *me, const Vector &pos ) { return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCommandAttack( Actor *me, CBaseEntity *victim, bool bDeny ) { return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCastAbilityNoTarget( Actor *me, CDOTABaseAbility *ability )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCastAbilityOnPosition( Actor *me, CDOTABaseAbility *ability, const Vector &pos )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCastAbilityOnTarget( Actor *me, CDOTABaseAbility *ability, CBaseEntity *target )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnDropItem( Actor *me, const Vector &pos, CBaseEntity *item )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnPickupItem( Actor *me, CBaseEntity *item )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnPickupRune( Actor *me, CBaseEntity *item )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnStop( Actor *me )	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnFriendThreatened( Actor *me, CBaseEntity *friendly, CBaseEntity *threat ) 	{ return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnCancelAttack( Actor *me, CBaseEntity *pTarget ) { return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnDominated( Actor *me ) { return TryContinue(); }
+	virtual EventDesiredResult< Actor > OnWarped( Actor *me, Vector vStartPos ) { return TryContinue(); }
+#endif
+
+	/**
+	 * Event handlers must return one of these.
+	 */
+	EventDesiredResult< Actor > TryContinue( EventResultPriorityType priority = RESULT_TRY ) const;
+	EventDesiredResult< Actor > TryChangeTo( Action< Actor > *action, EventResultPriorityType priority = RESULT_TRY, const char *reason = NULL ) const;
+	EventDesiredResult< Actor > TrySuspendFor( Action< Actor > *action, EventResultPriorityType priority = RESULT_TRY, const char *reason = NULL ) const;
+	EventDesiredResult< Actor > TryDone( EventResultPriorityType priority = RESULT_TRY, const char *reason = NULL ) const;
+	EventDesiredResult< Actor > TryToSustain( EventResultPriorityType priority = RESULT_TRY, const char *reason = NULL ) const;
+
+
+	//-----------------------------------------------------------------------------------------
+	Action< Actor > *GetActiveChildAction( void ) const;
+	Action< Actor > *GetParentAction( void ) const;			// the Action that I'm running inside of
+
+	bool IsSuspended( void ) const;						// return true if we are currently suspended for another Action
+
+	const char *DebugString( void ) const;								// return a temporary string describing the current action stack for debugging
+
+	/**
+	 * Sometimes we want to pass through other NextBots. OnContact() will always
+	 * be invoked, but collision resolution can be skipped if this
+	 * method returns false.
+	 */
+	virtual bool IsAbleToBlockMovementOf( const INextBot *botInMotion ) const	{ return true; }
+
+	// INextBotEventResponder propagation ----------------------------------------------------------------------
+	virtual INextBotEventResponder *FirstContainedResponder( void ) const;
+	virtual INextBotEventResponder *NextContainedResponder( INextBotEventResponder *current ) const;
+
+
+private:
+	
+	/**
+	 * These macros are used below to translate INextBotEventResponder event methods
+	 * into Action event handler methods
+	 */
+	#define PROCESS_EVENT( METHOD )							\
+		{													\
+			if ( !m_isStarted )								\
+				return;										\
+															\
+			Action< Actor > *_action = this;				\
+			EventDesiredResult< Actor > _result;			\
+															\
+			while( _action )								\
+			{												\
+				if ( m_actor && (m_actor->IsDebugging(NEXTBOT_EVENTS) || NextBotDebugHistory.GetBool()))	\
+				{															\
+					m_actor->DebugConColorMsg( NEXTBOT_EVENTS, Color( 100, 100, 100, 255 ), "%3.2f: %s:%s: %s received EVENT %s\n", gpGlobals->curtime, m_actor->GetDebugIdentifier(), m_behavior->GetName(), _action->GetFullName(), #METHOD );	\
+				}											\
+				_result = _action->METHOD( m_actor );	\
+				if ( !_result.IsContinue() )				\
+					break;									\
+				_action = _action->GetActionBuriedUnderMe();		\
+			}												\
+															\
+			if ( _action )									\
+			{												\
+				if ( m_actor && _result.IsRequestingChange() && (m_actor->IsDebugging(NEXTBOT_BEHAVIOR) || NextBotDebugHistory.GetBool()) )	\
+				{																						\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 0, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, m_actor->GetDebugIdentifier(), m_behavior->GetName() ); \
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "%s ", _action->GetFullName() );			\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255,   0, 255 ), "reponded to EVENT %s with ", #METHOD );	\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0,   0, 255 ), "%s %s ", _result.GetTypeName(), _result.m_action ? _result.m_action->GetName() : "" );		\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color(   0, 255,   0, 255 ), "%s\n", _result.m_reason ? _result.m_reason : "" );	\
+				}											\
+															\
+				_action->StorePendingEventResult( _result, #METHOD );	\
+			}												\
+															\
+			INextBotEventResponder::METHOD();			\
+		}
+
+
+	#define PROCESS_EVENT_WITH_1_ARG( METHOD, ARG1 )		\
+		{													\
+			if ( !m_isStarted )								\
+				return;										\
+															\
+			Action< Actor > *_action = this;				\
+			EventDesiredResult< Actor > _result;			\
+															\
+			while( _action )								\
+			{												\
+				if ( m_actor && (m_actor->IsDebugging(NEXTBOT_EVENTS) || NextBotDebugHistory.GetBool()) )	\
+				{															\
+					m_actor->DebugConColorMsg( NEXTBOT_EVENTS, Color( 100, 100, 100, 255 ), "%3.2f: %s:%s: %s received EVENT %s\n", gpGlobals->curtime, m_actor->GetDebugIdentifier(), m_behavior->GetName(), _action->GetFullName(), #METHOD );	\
+				}											\
+				_result = _action->METHOD( m_actor, ARG1 );		\
+				if ( !_result.IsContinue() )				\
+					break;									\
+				_action = _action->GetActionBuriedUnderMe();		\
+			}												\
+															\
+			if ( _action )									\
+			{												\
+				if ( m_actor && (m_actor->IsDebugging(NEXTBOT_BEHAVIOR) || NextBotDebugHistory.GetBool()) && _result.IsRequestingChange() && _action )	\
+				{																		\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 0, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, m_actor->GetDebugIdentifier(), m_behavior->GetName() ); \
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "%s ", _action->GetFullName() );			\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255,   0, 255 ), "reponded to EVENT %s with ", #METHOD );	\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0,   0, 255 ), "%s %s ", _result.GetTypeName(), _result.m_action ? _result.m_action->GetName() : "" );		\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color(   0, 255,   0, 255 ), "%s\n", _result.m_reason ? _result.m_reason : "" );	\
+				}											\
+															\
+				_action->StorePendingEventResult( _result, #METHOD );	\
+			}												\
+															\
+			INextBotEventResponder::METHOD( ARG1 );		\
+		}
+
+
+	#define PROCESS_EVENT_WITH_2_ARGS( METHOD, ARG1, ARG2 )	\
+		{													\
+			if ( !m_isStarted )								\
+				return;										\
+															\
+			Action< Actor > *_action = this;				\
+			EventDesiredResult< Actor > _result;			\
+															\
+			while( _action )								\
+			{												\
+				if ( m_actor && (m_actor->IsDebugging(NEXTBOT_EVENTS) || NextBotDebugHistory.GetBool()) )	\
+				{															\
+					m_actor->DebugConColorMsg( NEXTBOT_EVENTS, Color( 100, 100, 100, 255 ), "%3.2f: %s:%s: %s received EVENT %s\n", gpGlobals->curtime, m_actor->GetDebugIdentifier(), m_behavior->GetName(), _action->GetFullName(), #METHOD );	\
+				}											\
+				_result = _action->METHOD( m_actor, ARG1, ARG2 );		\
+				if ( !_result.IsContinue() )				\
+					break;									\
+				_action = _action->GetActionBuriedUnderMe();				\
+			}												\
+															\
+			if ( _action )									\
+			{												\
+				if ( m_actor && (m_actor->IsDebugging(NEXTBOT_BEHAVIOR) || NextBotDebugHistory.GetBool()) && _result.IsRequestingChange() && _action )	\
+				{																		\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 0, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, m_actor->GetDebugIdentifier(), m_behavior->GetName() ); \
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "%s ", _action->GetFullName() );			\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255,   0, 255 ), "reponded to EVENT %s with ", #METHOD );	\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0,   0, 255 ), "%s %s ", _result.GetTypeName(), _result.m_action ? _result.m_action->GetName() : "" );		\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color(   0, 255,   0, 255 ), "%s\n", _result.m_reason ? _result.m_reason : "" );	\
+				}											\
+															\
+				_action->StorePendingEventResult( _result, #METHOD );	\
+			}												\
+															\
+			INextBotEventResponder::METHOD( ARG1, ARG2 );			\
+		}
+
+
+	#define PROCESS_EVENT_WITH_3_ARGS( METHOD, ARG1, ARG2, ARG3 )	\
+		{													\
+			if ( !m_isStarted )								\
+				return;										\
+															\
+			Action< Actor > *_action = this;				\
+			EventDesiredResult< Actor > _result;			\
+															\
+			while( _action )								\
+			{												\
+				if ( m_actor && (m_actor->IsDebugging(NEXTBOT_EVENTS) || NextBotDebugHistory.GetBool()) )	\
+				{															\
+					m_actor->DebugConColorMsg( NEXTBOT_EVENTS, Color( 100, 100, 100, 255 ), "%3.2f: %s:%s: %s received EVENT %s\n", gpGlobals->curtime, m_actor->GetDebugIdentifier(), m_behavior->GetName(), _action->GetFullName(), #METHOD );	\
+				}											\
+				_result = _action->METHOD( m_actor, ARG1, ARG2, ARG3 );		\
+				if ( !_result.IsContinue() )				\
+					break;									\
+				_action = _action->GetActionBuriedUnderMe();				\
+			}												\
+															\
+			if ( _action )									\
+			{												\
+				if ( m_actor && (m_actor->IsDebugging(NEXTBOT_BEHAVIOR) || NextBotDebugHistory.GetBool()) && _result.IsRequestingChange() && _action )	\
+				{																		\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 0, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, m_actor->GetDebugIdentifier(), m_behavior->GetName() ); \
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "%s ", _action->GetFullName() );			\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255,   0, 255 ), "reponded to EVENT %s with ", #METHOD );	\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0,   0, 255 ), "%s %s ", _result.GetTypeName(), _result.m_action ? _result.m_action->GetName() : "" );		\
+					m_actor->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color(   0, 255,   0, 255 ), "%s\n", _result.m_reason ? _result.m_reason : "" );	\
+				}											\
+															\
+				_action->StorePendingEventResult( _result, #METHOD );	\
+			}												\
+															\
+			INextBotEventResponder::METHOD( ARG1, ARG2, ARG3 );			\
+		}
+
+
+	/**
+	 * Translate incoming events into Action events
+	 * DO NOT OVERRIDE THESE METHODS
+	 */
+	virtual void OnLeaveGround( CBaseEntity *ground )					{ PROCESS_EVENT_WITH_1_ARG( OnLeaveGround, ground ); }
+	virtual void OnLandOnGround( CBaseEntity *ground )					{ PROCESS_EVENT_WITH_1_ARG( OnLandOnGround, ground ); }
+	virtual void OnContact( CBaseEntity *other, CGameTrace *result )	{ PROCESS_EVENT_WITH_2_ARGS( OnContact, other, result ); }
+	virtual void OnMoveToSuccess( const Path *path )					{ PROCESS_EVENT_WITH_1_ARG( OnMoveToSuccess, path ); }
+	virtual void OnMoveToFailure( const Path *path, MoveToFailureType reason )	{ PROCESS_EVENT_WITH_2_ARGS( OnMoveToFailure, path, reason ); }
+	virtual void OnStuck( void )										{ PROCESS_EVENT( OnStuck ); }
+	virtual void OnUnStuck( void )										{ PROCESS_EVENT( OnUnStuck ); }
+	virtual void OnPostureChanged( void )								{ PROCESS_EVENT( OnPostureChanged ); }
+	virtual void OnAnimationActivityComplete( int activity )			{ PROCESS_EVENT_WITH_1_ARG( OnAnimationActivityComplete, activity ); }
+	virtual void OnAnimationActivityInterrupted( int activity )			{ PROCESS_EVENT_WITH_1_ARG( OnAnimationActivityInterrupted, activity ); }
+	virtual void OnAnimationEvent( animevent_t *event )					{ PROCESS_EVENT_WITH_1_ARG( OnAnimationEvent, event ); }
+	virtual void OnIgnite( void )										{ PROCESS_EVENT( OnIgnite ); }
+	virtual void OnInjured( const CTakeDamageInfo &info )				{ PROCESS_EVENT_WITH_1_ARG( OnInjured, info ); }
+	virtual void OnKilled( const CTakeDamageInfo &info )				{ PROCESS_EVENT_WITH_1_ARG( OnKilled, info ); }
+	virtual void OnOtherKilled( CBaseCombatCharacter *victim, const CTakeDamageInfo &info )	{ PROCESS_EVENT_WITH_2_ARGS( OnOtherKilled, victim, info ); }
+	virtual void OnSight( CBaseEntity *subject )						{ PROCESS_EVENT_WITH_1_ARG( OnSight, subject ); }
+	virtual void OnLostSight( CBaseEntity *subject )					{ PROCESS_EVENT_WITH_1_ARG( OnLostSight, subject ); }
+	virtual void OnSound( CBaseEntity *source, const Vector &pos, KeyValues *keys )					{ PROCESS_EVENT_WITH_3_ARGS( OnSound, source, pos, keys ); }
+	virtual void OnSpokeConcept( CBaseCombatCharacter *who, AIConcept_t concept, AI_Response *response )	{ PROCESS_EVENT_WITH_3_ARGS( OnSpokeConcept, who, concept, response ); }
+	virtual void OnWeaponFired( CBaseCombatCharacter *whoFired, CBaseCombatWeapon *weapon )			{ PROCESS_EVENT_WITH_2_ARGS( OnWeaponFired, whoFired, weapon ); }
+	virtual void OnNavAreaChanged( CNavArea *newArea, CNavArea *oldArea )	{ PROCESS_EVENT_WITH_2_ARGS( OnNavAreaChanged, newArea, oldArea ); }
+	virtual void OnModelChanged( void )									{ PROCESS_EVENT( OnModelChanged ); }
+	virtual void OnPickUp( CBaseEntity *item, CBaseCombatCharacter *giver )	{ PROCESS_EVENT_WITH_2_ARGS( OnPickUp, item, giver ); }
+	virtual void OnDrop( CBaseEntity *item )							{ PROCESS_EVENT_WITH_1_ARG( OnDrop, item ); }
+	virtual void OnActorEmoted( CBaseCombatCharacter *emoter, int emote )	{ PROCESS_EVENT_WITH_2_ARGS( OnActorEmoted, emoter, emote ); }
+
+	virtual void OnCommandAttack( CBaseEntity *victim )					{ PROCESS_EVENT_WITH_1_ARG( OnCommandAttack, victim ); }
+	virtual void OnCommandApproach( const Vector &pos, float range )	{ PROCESS_EVENT_WITH_2_ARGS( OnCommandApproach, pos, range ); }
+	virtual void OnCommandApproach( CBaseEntity *goal )					{ PROCESS_EVENT_WITH_1_ARG( OnCommandApproach, goal ); }
+	virtual void OnCommandRetreat( CBaseEntity *threat, float range )	{ PROCESS_EVENT_WITH_2_ARGS( OnCommandRetreat, threat, range ); }
+	virtual void OnCommandPause( float duration )						{ PROCESS_EVENT_WITH_1_ARG( OnCommandPause, duration ); }
+	virtual void OnCommandResume( void )								{ PROCESS_EVENT( OnCommandResume ); }
+	virtual void OnCommandString( const char *command )					{ PROCESS_EVENT_WITH_1_ARG( OnCommandString, command ); }
+
+	virtual void OnShoved( CBaseEntity *pusher )						{ PROCESS_EVENT_WITH_1_ARG( OnShoved, pusher ); }
+	virtual void OnBlinded( CBaseEntity *blinder )						{ PROCESS_EVENT_WITH_1_ARG( OnBlinded, blinder ); }
+	virtual void OnTerritoryContested( int territoryID )				{ PROCESS_EVENT_WITH_1_ARG( OnTerritoryContested, territoryID ); }
+	virtual void OnTerritoryCaptured( int territoryID )					{ PROCESS_EVENT_WITH_1_ARG( OnTerritoryCaptured, territoryID ); }
+	virtual void OnTerritoryLost( int territoryID )						{ PROCESS_EVENT_WITH_1_ARG( OnTerritoryLost, territoryID ); }
+	virtual void OnWin( void )											{ PROCESS_EVENT( OnWin ); }
+	virtual void OnLose( void )											{ PROCESS_EVENT( OnLose ); }
+
+#ifdef DOTA_SERVER_DLL
+	virtual void OnCommandMoveTo( const Vector &pos ) { PROCESS_EVENT_WITH_1_ARG( OnCommandMoveTo, pos ); }
+	virtual void OnCommandMoveToAggressive( const Vector &pos ) { PROCESS_EVENT_WITH_1_ARG( OnCommandMoveToAggressive, pos ); }
+	virtual void OnCommandAttack( CBaseEntity *victim, bool bDeny ) { PROCESS_EVENT_WITH_2_ARGS( OnCommandAttack, victim, bDeny ); }
+	virtual void OnCastAbilityNoTarget( CDOTABaseAbility *ability ) { PROCESS_EVENT_WITH_1_ARG( OnCastAbilityNoTarget, ability ); }
+	virtual void OnCastAbilityOnPosition( CDOTABaseAbility *ability, const Vector &pos ) { PROCESS_EVENT_WITH_2_ARGS( OnCastAbilityOnPosition, ability, pos ); }
+	virtual void OnCastAbilityOnTarget( CDOTABaseAbility *ability, CBaseEntity *target ) { PROCESS_EVENT_WITH_2_ARGS( OnCastAbilityOnTarget, ability, target ); }
+	virtual void OnDropItem( const Vector &pos, CBaseEntity *item ) { PROCESS_EVENT_WITH_2_ARGS( OnDropItem, pos, item ); }
+	virtual void OnPickupItem( CBaseEntity *item ) { PROCESS_EVENT_WITH_1_ARG( OnPickupItem, item ); }
+	virtual void OnPickupRune( CBaseEntity *item ) { PROCESS_EVENT_WITH_1_ARG( OnPickupRune, item ); }
+	virtual void OnStop() { PROCESS_EVENT( OnStop ); }
+	virtual void OnFriendThreatened( CBaseEntity *friendly, CBaseEntity *threat ) { PROCESS_EVENT_WITH_2_ARGS( OnFriendThreatened, friendly, threat ); }
+	virtual void OnCancelAttack( CBaseEntity *pTarget ) { PROCESS_EVENT_WITH_1_ARG( OnCancelAttack, pTarget ); }
+	virtual void OnDominated() { PROCESS_EVENT( OnDominated ); }
+	virtual void OnWarped( Vector vStartPos ) { PROCESS_EVENT_WITH_1_ARG( OnWarped, vStartPos ); }
+#endif
+
+	friend class Behavior< Actor>;							// the containing Behavior class
+	Behavior< Actor > *m_behavior;							// the Behavior this Action is part of
+
+	Action< Actor > *m_parent;								// the Action that contains us
+	Action< Actor > *m_child;								// the ACTIVE Action we contain, top of the stack. Use m_buriedUnderMe, m_coveringMe on the child to traverse to other suspended children
+
+	Action< Actor > *m_buriedUnderMe;						// the Action just "under" us in the stack that we will resume to when we finish
+	Action< Actor > *m_coveringMe;							// the Action just "above" us in the stack that will resume to us when it finishes
+
+	Actor *m_actor;											// only valid after OnStart()
+	mutable EventDesiredResult< Actor > m_eventResult;		// set by event handlers
+	bool m_isStarted;										// Action doesn't start until OnStart() is invoked
+	bool m_isSuspended;										// are we suspended for another Action
+
+	Action< Actor > *GetActionBuriedUnderMe( void ) const	// return Action just "under" us that we will resume to when we finish
+	{
+		return m_buriedUnderMe;
+	}
+
+	Action< Actor > *GetActionCoveringMe( void ) const		// return Action just "above" us that will resume to us when it finishes
+	{
+		return m_coveringMe;
+	}
+
+	/**
+	 * If any Action buried underneath me has either exited
+	 * or is changing to a different Action, we're "out of scope"
+	 */
+	bool IsOutOfScope( void ) const
+	{
+		for( Action< Actor > *under = GetActionBuriedUnderMe(); under; under = under->GetActionBuriedUnderMe() )
+		{
+			if ( under->m_eventResult.m_type == CHANGE_TO ||
+				 under->m_eventResult.m_type == DONE )
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Process any pending events with the stack. This is called
+	 * by the active Action on the top of the stack, and walks
+	 * through any buried Actions checking for pending event results.
+	 */
+	ActionResult< Actor > ProcessPendingEvents( void ) const
+	{
+		// if an event has requested a change, honor it
+		if ( m_eventResult.IsRequestingChange() )
+		{
+			ActionResult< Actor > result( m_eventResult.m_type, m_eventResult.m_action, m_eventResult.m_reason );
+
+			// clear event result in case this change is a suspend and we later resume this action
+			m_eventResult = TryContinue( RESULT_NONE );
+
+			return result;
+		}
+
+		// check for pending event changes buried in the stack
+		Action< Actor > *under = GetActionBuriedUnderMe();
+		while( under )
+		{
+			if ( under->m_eventResult.m_type == SUSPEND_FOR )
+			{
+				// process this pending event in-place and push new Action on the top of the stack
+				ActionResult< Actor > result( under->m_eventResult.m_type, under->m_eventResult.m_action, under->m_eventResult.m_reason );
+
+				// clear event result in case this change is a suspend and we later resume this action
+				under->m_eventResult = TryContinue( RESULT_NONE );
+
+				return result;
+			}
+
+			under = under->GetActionBuriedUnderMe();
+		}
+		
+		return Continue();
+	}
+	
+	// given the result of this Action's work, apply the result to potentially cause a state transition
+	Action< Actor > *		ApplyResult( Actor *me, Behavior< Actor > *behavior, ActionResult< Actor > result );
+
+	/**
+	 * The methods below do the bookkeeping of each event, propagate the activity through the hierarchy,
+	 * and invoke the virtual event for each.
+	 */
+	ActionResult< Actor >	InvokeOnStart( Actor *me, Behavior< Actor > *behavior, Action< Actor > *priorAction, Action< Actor > *buriedUnderMeAction );
+	ActionResult< Actor >	InvokeUpdate( Actor *me, Behavior< Actor > *behavior, float interval );
+	void					InvokeOnEnd( Actor *me, Behavior< Actor > *behavior, Action< Actor > *nextAction );
+	Action< Actor > *		InvokeOnSuspend( Actor *me, Behavior< Actor > *behavior, Action< Actor > *interruptingAction );
+	ActionResult< Actor >	InvokeOnResume( Actor *me, Behavior< Actor > *behavior, Action< Actor > *interruptingAction );
+
+	/**
+	 * Store the given event result, attending to priorities
+	 */
+	void StorePendingEventResult( const EventDesiredResult< Actor > &result, const char *eventName )
+	{
+		if ( result.IsContinue() )
+		{
+			return;
+		}
+
+		if ( result.m_priority >= m_eventResult.m_priority )
+		{
+			if ( m_eventResult.m_priority == RESULT_CRITICAL )
+			{				
+				if ( developer.GetBool() )
+				{
+					DevMsg( "%3.2f: WARNING: %s::%s() RESULT_CRITICAL collision\n", gpGlobals->curtime, GetName(), eventName );
+				}
+			}
+
+			// new result as important or more so - destroy the replaced action
+			if ( m_eventResult.m_action )
+			{
+				delete m_eventResult.m_action;
+			}
+			
+			// We keep the most recently processed event because this allows code to check history/state to
+			// do custom event collision handling. If we keep the first event at this priority and discard
+			// subsequent events (original behavior) there is no way to predict future collision resolutions (MSB).
+			m_eventResult = result;
+		}
+		else
+		{
+			// new result is lower priority than previously stored result - discard it
+			if ( result.m_action )
+			{
+				// destroy the unused action
+				delete result.m_action;
+			}
+		}
+	}
+	
+	char *BuildDecoratedName( char *name, const Action< Actor > *action ) const;	// recursive name outMsg for DebugString()
+
+	void PrintStateToConsole( void ) const;
+};
+
+
+//-------------------------------------------------------------------------------------------
+template < typename Actor >
+Action< Actor >::Action( void )
+{
+	m_parent = NULL;
+	m_child = NULL;
+	m_buriedUnderMe = NULL;
+	m_coveringMe = NULL;
+	m_actor = NULL;
+	m_behavior = NULL;
+
+	m_isStarted = false;
+	m_isSuspended = false;
+	
+	m_eventResult = TryContinue( RESULT_NONE );
+
+#ifdef DEBUG_BEHAVIOR_MEMORY
+	ConColorMsg( Color( 255, 0, 255, 255 ), "%3.2f: NEW %0X\n", gpGlobals->curtime, this );
+#endif
+}
+
+
+//-------------------------------------------------------------------------------------------
+template < typename Actor >
+Action< Actor >::~Action()
+{
+#ifdef DEBUG_BEHAVIOR_MEMORY
+	ConColorMsg( Color( 255, 0, 255, 255 ), "%3.2f: DELETE %0X\n", gpGlobals->curtime, this );
+#endif
+
+	if ( m_parent )
+	{
+		// if I'm my parent's active child, update parent's pointer
+		if ( m_parent->m_child == this )
+		{
+			m_parent->m_child = m_buriedUnderMe;
+		}
+	}
+
+	// delete all my children.
+	// our m_child pointer always points to the topmost
+	// child in the stack, so work our way back thru the
+	// 'buried' children and delete them.
+	Action< Actor > *child, *next = NULL;
+	for( child = m_child; child; child = next )
+	{
+		next = child->m_buriedUnderMe;
+		delete child;
+	}
+
+	if ( m_buriedUnderMe )
+	{
+		// we're going away, so my buried sibling is now on top
+		m_buriedUnderMe->m_coveringMe = NULL;
+	}
+
+	// delete any actions stacked on top of me
+	if ( m_coveringMe )
+	{
+		// recursion will march down the chain
+		delete m_coveringMe;
+	}
+
+	// delete any pending event result
+	if ( m_eventResult.m_action )
+	{
+		delete m_eventResult.m_action;
+	}
+}
+
+
+template < typename Actor >
+bool Action< Actor >::IsNamed( const char *name ) const
+{
+	return FStrEq( GetName(), name );
+}
+
+
+template < typename Actor >
+Actor *Action< Actor >::GetActor( void ) const
+{
+	return m_actor;
+}
+
+template < typename Actor >
+ActionResult< Actor > Action< Actor >::Continue( void ) const
+{
+	return ActionResult< Actor >( CONTINUE, NULL, NULL );
+}
+
+template < typename Actor >
+ActionResult< Actor > Action< Actor >::ChangeTo( Action< Actor > *action, const char *reason ) const
+{
+	return ActionResult< Actor >( CHANGE_TO, action, reason );
+}
+
+template < typename Actor >
+ActionResult< Actor > Action< Actor >::SuspendFor( Action< Actor > *action, const char *reason ) const
+{
+	// clear any pending transitions requested by events, or this SuspendFor will
+	// immediately be out of scope
+	m_eventResult = TryContinue( RESULT_NONE );
+
+	return ActionResult< Actor >( SUSPEND_FOR, action, reason );
+}
+
+template < typename Actor >
+ActionResult< Actor > Action< Actor >::Done( const char *reason ) const
+{
+	return ActionResult< Actor >( DONE, NULL, reason );
+}
+
+
+//-------------------------------------------------------------------------------------------
+template < typename Actor >
+EventDesiredResult< Actor > Action< Actor >::TryContinue( EventResultPriorityType priority ) const
+{
+	return EventDesiredResult< Actor >( CONTINUE, NULL, priority );
+}
+
+template < typename Actor >
+EventDesiredResult< Actor > Action< Actor >::TryChangeTo( Action< Actor > *action, EventResultPriorityType priority, const char *reason ) const
+{
+	return EventDesiredResult< Actor >( CHANGE_TO, action, priority, reason );
+}
+
+template < typename Actor >
+EventDesiredResult< Actor > Action< Actor >::TrySuspendFor( Action< Actor > *action, EventResultPriorityType priority, const char *reason ) const
+{
+	return EventDesiredResult< Actor >( SUSPEND_FOR, action, priority, reason );
+}
+
+template < typename Actor >
+EventDesiredResult< Actor > Action< Actor >::TryDone( EventResultPriorityType priority, const char *reason /*= NULL*/ ) const
+{
+	return EventDesiredResult< Actor >( DONE, NULL, priority, reason );
+}
+
+template < typename Actor >
+EventDesiredResult< Actor > Action< Actor >::TryToSustain( EventResultPriorityType priority, const char *reason /*= NULL*/ ) const
+{
+	return EventDesiredResult< Actor >( SUSTAIN, NULL, priority, reason );
+}
+
+
+//-------------------------------------------------------------------------------------------
+template < typename Actor >
+Action< Actor > *Action< Actor >::GetActiveChildAction( void ) const
+{
+	return m_child;
+}
+
+
+//-------------------------------------------------------------------------------------------
+// the Action that I'm running inside of
+template < typename Actor >
+Action< Actor > *Action< Actor >::GetParentAction( void ) const
+{
+	return m_parent;
+}
+
+
+//-------------------------------------------------------------------------------------------
+/**
+ * Return true if we are currently suspended for another Action
+ */
+template < typename Actor >
+bool Action< Actor >::IsSuspended( void ) const
+{
+	return m_isSuspended;
+}
+
+
+//-------------------------------------------------------------------------------------------
+/**
+ * Start this Action.
+ * The act of calling InvokeOnStart is the edge case that 'enters' a state.
+ */
+template < typename Actor >
+ActionResult< Actor > Action< Actor >::InvokeOnStart( Actor *me, Behavior< Actor > *behavior, Action< Actor > *priorAction, Action< Actor > *buriedUnderMeAction )
+{
+	// debug display
+	if ( (me->IsDebugging(NEXTBOT_BEHAVIOR) || NextBotDebugHistory.GetBool()) )
+	{
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 150, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, me->GetDebugIdentifier(), behavior->GetName() );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color(   0, 255,   0, 255 ), " STARTING " );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), GetName() );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "\n" );
+	}
+
+	// these value must be valid before invoking OnStart, in case an OnSuspend happens 
+	m_isStarted = true;
+	m_actor = me;
+	m_behavior = behavior;
+
+	// maintain parent/child relationship during transitions
+	if ( priorAction )
+	{
+		m_parent = priorAction->m_parent;
+	}
+
+	if ( m_parent )
+	{
+		// child pointer of an Action always points to the ACTIVE child
+		// parent pointers are set when child Actions are instantiated
+		m_parent->m_child = this;
+	}
+
+	// maintain stack pointers
+	m_buriedUnderMe = buriedUnderMeAction;
+	if ( buriedUnderMeAction )
+	{
+		buriedUnderMeAction->m_coveringMe = this;
+	}
+
+	// we are always on top of the stack. if our priorAction was buried, it cleared 
+	// everything covering it when it ended (which happens before we start)
+	m_coveringMe = NULL;
+
+	// start the optional child action
+	m_child = InitialContainedAction( me );
+	if ( m_child )
+	{
+		// define initial parent/child relationship
+		m_child->m_parent = this;
+
+		m_child = m_child->ApplyResult( me, behavior, ChangeTo( m_child, "Starting child Action" ) );
+	}
+
+	// start ourselves
+	ActionResult< Actor > result = OnStart( me, priorAction );
+
+	return result;
+}
+
+
+//-------------------------------------------------------------------------------------------
+template < typename Actor >
+ActionResult< Actor > Action< Actor >::InvokeUpdate( Actor *me, Behavior< Actor > *behavior, float interval )
+{
+	// an explicit "out of scope" check is needed here to prevent any
+	// pending events causing an out of scope action to linger
+	if ( IsOutOfScope() )
+	{
+		// exit self to make this Action active and allow result to take effect on its next Update
+		return Done( "Out of scope" );
+	}
+
+	if ( !m_isStarted )
+	{
+		// this Action has not yet begun - start it
+		return ChangeTo( this, "Starting Action" );
+	}
+
+	// honor any pending event results 
+	ActionResult< Actor > eventResult = ProcessPendingEvents();
+	if ( !eventResult.IsContinue() )
+	{
+		return eventResult;
+	}
+
+	// update our child action first, since it has the most specific behavior
+	if ( m_child )
+	{
+		m_child = m_child->ApplyResult( me, behavior, m_child->InvokeUpdate( me, behavior, interval ) );
+	}
+
+	// update ourselves
+	ActionResult< Actor > result;
+	{
+		VPROF_BUDGET( GetName(), "NextBot" );
+
+		result = Update( me, interval );
+	}
+
+	return result;
+}
+
+
+//-------------------------------------------------------------------------------------------
+/**
+ * This method calls the virtual OnEnd() method for the Action, its children, and Actions
+ * stacked on top of it.
+ * It does NOT delete resources, or disturb pointer relationships, because this Action
+ * needs to remain valid for a short while as an argument to OnStart(), OnSuspend(), etc for
+ * the next Action.
+ * The destructor for the Action frees memory for this Action, its children, etc.
+ */
+template < typename Actor >
+void Action< Actor >::InvokeOnEnd( Actor *me, Behavior< Actor > *behavior, Action< Actor > *nextAction )
+{
+	if ( !m_isStarted )
+	{
+		// we are not started (or never were)
+		return;
+	}
+
+	if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) || NextBotDebugHistory.GetBool() )
+	{
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 150, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, me->GetDebugIdentifier(), behavior->GetName() );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0,   0, 255 ), " ENDING " );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), GetName() );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "\n" );
+	}
+
+	// we are no longer started
+	m_isStarted = false;
+
+	// tell child Action(s) to leave (but don't disturb the list itself)
+	Action< Actor > *child, *next = NULL;
+	for( child = m_child; child; child = next )
+	{
+		next = child->m_buriedUnderMe;
+		child->InvokeOnEnd( me, behavior, nextAction );
+	}
+
+	// leave ourself
+	OnEnd( me, nextAction );
+
+	// leave any Actions stacked on top of me
+	if ( m_coveringMe )
+	{
+		m_coveringMe->InvokeOnEnd( me, behavior, nextAction );
+	}
+}
+
+
+//-------------------------------------------------------------------------------------------
+/**
+ * Just invoke OnSuspend - when the interrupting Action is started it will
+ * update our buried/covered pointers.
+ * OnSuspend may cause this Action to exit.
+ */
+template < typename Actor >
+Action< Actor > * Action< Actor >::InvokeOnSuspend( Actor *me, Behavior< Actor > *behavior, Action< Actor > *interruptingAction )
+{
+	if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) || NextBotDebugHistory.GetBool() )
+	{
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 150, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, me->GetDebugIdentifier(), behavior->GetName() );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0, 255, 255 ), " SUSPENDING " );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), GetName() );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "\n" );
+	}
+
+	// suspend child Action
+	if ( m_child )
+	{
+		m_child = m_child->InvokeOnSuspend( me, behavior, interruptingAction );
+	}
+
+	// suspend ourselves
+	m_isSuspended = true;
+	ActionResult< Actor > result = OnSuspend( me, interruptingAction );
+
+	if ( result.IsDone() )
+	{
+		// we want to be replaced instead of suspended
+		InvokeOnEnd( me, behavior, NULL );
+
+		Action< Actor > * buried = GetActionBuriedUnderMe();
+
+		behavior->DestroyAction( this );
+
+		// new Action on top of the stack
+		return buried;
+	}
+
+	// we are still on top of the stack at this moment
+	return this;
+}
+
+
+//-------------------------------------------------------------------------------------------
+template < typename Actor >
+ActionResult< Actor > Action< Actor >::InvokeOnResume( Actor *me, Behavior< Actor > *behavior, Action< Actor > *interruptingAction )
+{
+	if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) || NextBotDebugHistory.GetBool() )
+	{
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 150, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, me->GetDebugIdentifier(), behavior->GetName() );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0, 255, 255 ), " RESUMING " );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), GetName() );
+		me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "\n" );
+	}
+
+	if ( !m_isSuspended )
+	{
+		// we were never suspended
+		return Continue();
+	}
+
+	if ( m_eventResult.IsRequestingChange() )
+	{
+		// this Action is not actually being Resumed, because a change
+		// is already pending from a prior event
+		return Continue();
+	}
+
+	// resume ourselves
+	m_isSuspended = false;
+	m_coveringMe = NULL;
+
+	if ( m_parent )
+	{
+		// we are once again our parent's active child
+		m_parent->m_child = this;
+	}
+
+	// resume child Action
+	if ( m_child )
+	{
+		m_child = m_child->ApplyResult( me, behavior, m_child->InvokeOnResume( me, behavior, interruptingAction ) );
+	}
+
+	// actually resume ourselves
+	ActionResult< Actor > result = OnResume( me, interruptingAction );
+
+	return result;
+}
+
+
+//-------------------------------------------------------------------------------------------
+/**
+ * Given the result of this Action's work, apply the result to potentially create a new Action
+ */
+template < typename Actor >
+Action< Actor > *Action< Actor >::ApplyResult( Actor *me, Behavior< Actor > *behavior, ActionResult< Actor > result )
+{
+	Action< Actor > *newAction = result.m_action;
+
+	switch( result.m_type )
+	{
+		//-----------------------------------------------------------------------------------------------------
+		// transition to new Action
+		case CHANGE_TO:
+		{
+			if ( newAction == NULL )
+			{
+				DevMsg( "Error: Attempted CHANGE_TO to a NULL Action\n" );
+				AssertMsg( false, "Action: Attempted CHANGE_TO to a NULL Action" );
+				return this;
+			}
+	
+			// debug display
+			if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) || NextBotDebugHistory.GetBool() )
+			{
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 150, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, me->GetDebugIdentifier(), behavior->GetName() );
+				
+				if ( this == newAction )
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0,   0, 255 ), "START " );
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), newAction->GetName() );
+				}
+				else
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), this->GetName() );
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0,   0, 255 ), " CHANGE_TO " );
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), newAction->GetName() );
+				}
+						
+				if ( result.m_reason )
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 150, 255, 150, 255 ), "  (%s)\n", result.m_reason );
+				}
+				else
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "\n" );
+				}
+			}
+
+			// we are done
+			this->InvokeOnEnd( me, behavior, newAction );
+
+			// start the new Action
+			ActionResult< Actor > startResult = newAction->InvokeOnStart( me, behavior, this, this->m_buriedUnderMe );
+
+			// discard ended action
+			if ( this != newAction )
+			{
+				behavior->DestroyAction( this );
+			}
+
+			// debug display
+			if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) )
+			{
+				newAction->PrintStateToConsole();
+			}
+
+			// apply result of starting the Action
+			return newAction->ApplyResult( me, behavior, startResult );
+		}
+		
+		//-----------------------------------------------------------------------------------------------------
+		// temporarily suspend ourselves for the newAction, covering it on the stack
+		case SUSPEND_FOR:
+		{
+			// interrupting Action always goes on the TOP of the stack - find it
+			Action< Actor > *topAction = this;
+			while ( topAction->m_coveringMe )
+			{
+				topAction = topAction->m_coveringMe;
+			}
+
+			// debug display
+			if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) || NextBotDebugHistory.GetBool() )
+			{
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 150, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, me->GetDebugIdentifier(), behavior->GetName() );
+
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), this->GetName() );
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0, 255, 255 ), " caused " );
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), topAction->GetName() );
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255,   0, 255, 255 ), " to SUSPEND_FOR " );
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), newAction->GetName() );
+
+				if ( result.m_reason )
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 150, 255, 150, 255 ), "  (%s)\n", result.m_reason );
+				}
+				else
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "\n" );
+				}
+			}
+			
+			// suspend the Action we just covered up				
+			topAction = topAction->InvokeOnSuspend( me, behavior, newAction );
+
+			// begin the interrupting Action.
+			ActionResult< Actor > startResult = newAction->InvokeOnStart( me, behavior, topAction, topAction );
+
+			// debug display
+			if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) )
+			{
+				newAction->PrintStateToConsole();
+			}
+			
+			return newAction->ApplyResult( me, behavior, startResult );
+		}
+
+		//-----------------------------------------------------------------------------------------------------
+		case DONE:
+		{
+			// resume buried action
+			Action< Actor > *resumedAction = this->m_buriedUnderMe;
+
+			// we are finished
+			this->InvokeOnEnd( me, behavior, resumedAction );
+
+			// debug display
+			if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) || NextBotDebugHistory.GetBool() )
+			{
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 150, 255 ), "%3.2f: %s:%s: ", gpGlobals->curtime, me->GetDebugIdentifier(), behavior->GetName() );
+
+				me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), this->GetName() );
+
+				if ( resumedAction )
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color(   0, 255,   0, 255 ), " DONE, RESUME " );
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), resumedAction->GetName() );
+				}
+				else
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color(   0, 255,   0, 255 ), " DONE." );
+				}
+
+				if ( result.m_reason )
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 150, 255, 150, 255 ), "  (%s)\n", result.m_reason );
+				}
+				else
+				{
+					me->DebugConColorMsg( NEXTBOT_BEHAVIOR, Color( 255, 255, 255, 255 ), "\n" );
+				}
+			}
+
+			if ( resumedAction == NULL )
+			{
+				// all Actions complete
+				behavior->DestroyAction( this );
+				return NULL;
+			}
+
+			// resume uncovered action
+			ActionResult< Actor > resumeResult = resumedAction->InvokeOnResume( me, behavior, this );
+
+			// debug display
+			if ( me->IsDebugging( NEXTBOT_BEHAVIOR ) )
+			{
+				resumedAction->PrintStateToConsole();
+			}
+
+			// discard ended action
+			behavior->DestroyAction( this );
+
+			// apply result of OnResume()
+			return resumedAction->ApplyResult( me, behavior, resumeResult );
+		}
+
+		case CONTINUE:
+		case SUSTAIN:
+		default:
+		{
+			// no change, continue the current action next frame
+			return this;
+		}
+	}
+}
+
+
+//-------------------------------------------------------------------------------------------
+/**
+ * Propagate events to sub actions
+ */
+template < typename Actor >
+INextBotEventResponder *Action< Actor >::FirstContainedResponder( void ) const
+{
+	return GetActiveChildAction();
+}
+
+template < typename Actor >
+INextBotEventResponder *Action< Actor >::NextContainedResponder( INextBotEventResponder *current ) const
+{
+	return NULL;
+}
+
+
+//-------------------------------------------------------------------------------------------
+/**
+ * Return a temporary string describing the current action stack for debugging
+ */
+template < typename Actor >
+const char *Action< Actor >::DebugString( void ) const
+{
+	static char str[ 256 ];
+
+	str[0] = '\000';
+
+	// find root
+	const Action< Actor > *root = this; 
+	while ( root->m_parent )
+	{
+		root = root->m_parent;
+	}
+
+	return BuildDecoratedName( str, root );
+}
+
+
+//-------------------------------------------------------------------------------------------
+template < typename Actor >
+char *Action< Actor >::BuildDecoratedName( char *name, const Action< Actor > *action ) const
+{
+	const int fudge = 256;
+	
+	// add the name of the given action
+	Q_strcat( name, action->GetName(), fudge );
+	
+	// add any contained actions
+	const Action< Actor > *child = action->GetActiveChildAction();
+	if ( child )
+	{
+		Q_strcat( name, "( ", fudge );
+		BuildDecoratedName( name, child );
+		Q_strcat( name, " )", fudge );		
+	}
+	
+	// append buried actions
+	const Action< Actor > *buried = action->GetActionBuriedUnderMe();
+	if ( buried )
+	{
+		Q_strcat( name, "<<", fudge );		
+		BuildDecoratedName( name, buried );		
+	}
+	
+	return name;
+}
+
+
+//-------------------------------------------------------------------------------------------
+/**
+ * Return a temporary string showing the full lineage of this one action
+ */
+template < typename Actor >
+const char *Action< Actor >::GetFullName( void ) const
+{
+	const int fudge = 256;
+	static char str[ fudge ];
+
+	str[0] = '\000';
+	
+	const int maxStack = 64;
+	const char *nameStack[ maxStack ];
+	int stackIndex = 0;
+
+	for( const Action< Actor > *action = this; 
+		 stackIndex < maxStack && action; 
+		 action = action->m_parent )
+	{
+		nameStack[ stackIndex++ ] = action->GetName();
+	}
+	
+	// assemble name
+	for( int i = stackIndex-1; i > 0; --i )
+	{
+		Q_strcat( str, nameStack[ i ], fudge );
+		Q_strcat( str, "/", fudge );
+	}
+
+	Q_strcat( str, nameStack[ 0 ], fudge );
+	
+	/*
+	for( int i = 0; i < stackIndex-1; ++i )
+	{
+		Q_strcat( str, " )", fudge );		
+	}
+	*/
+
+	return str;
+}
+
+
+//-------------------------------------------------------------------------------------------
+template < typename Actor >
+void Action< Actor >::PrintStateToConsole( void ) const
+{
+	// emit the Behavior name
+	//ConColorMsg( Color( 255, 255, 255, 255 ), "%s: ", m_behavior->GetName() );
+
+	// build the state string
+	const char *msg = DebugString();
+	
+	const int colorCount = 6;
+	Color colorTable[ colorCount ];
+	colorTable[ 0 ].SetColor( 255, 150, 150, 255 );
+	colorTable[ 1 ].SetColor( 150, 255, 150, 255 );
+	colorTable[ 2 ].SetColor( 150, 150, 255, 255 );
+	colorTable[ 3 ].SetColor( 255, 255, 150, 255 );
+	colorTable[ 4 ].SetColor(  50, 255, 255, 255 );
+	colorTable[ 5 ].SetColor( 255, 150, 255, 255 );
+	
+	// output the color-coded state string
+	const int maxBufferSize = 256;
+	char buffer[ maxBufferSize ];
+
+	int colorIndex = 0;
+	int buriedLevel = 0;
+	
+	char *outMsg = buffer;
+	for( const char *c = msg; *c != '\000'; ++c )
+	{
+		*outMsg = *c;
+		++outMsg;
+
+		if ( *c == '(' )
+		{
+			*outMsg = '\000';
+			
+			Color color = colorTable[ colorIndex ];
+
+			if ( buriedLevel )
+			{
+				// draw buried labels darkly
+				color.SetColor( color.r() * 0.5, color.g() * 0.5, color.b() * 0.5, 255 );
+				++buriedLevel;
+			}
+			
+			//ConColorMsg( color, "%s", buffer );
+			DevMsg( "%s", buffer );
+			
+			colorIndex = ( colorIndex + 1 ) % colorCount;
+			
+			outMsg = buffer;
+		}
+		else if ( *c == ')' )
+		{
+			// emit the closing paren with next batch
+			--outMsg;
+			*outMsg = '\000';
+
+			Color color = colorTable[ colorIndex ];
+
+			if ( buriedLevel )
+			{
+				// draw buried labels darkly
+				color.SetColor( color.r() * 0.5, color.g() * 0.5, color.b() * 0.5, 255 );
+
+				--buriedLevel;
+			}
+			
+			//ConColorMsg( color, "%s", buffer );
+			DevMsg( "%s", buffer );
+
+			--colorIndex;
+			if ( colorIndex < 0 )
+				colorIndex = colorCount-1;
+
+			outMsg = buffer;
+			
+			*outMsg = ')';
+			++outMsg;
+		}
+		else if ( *c == '<' && buriedLevel == 0 )
+		{
+			// caught a "<<" stack push
+			++c;
+			
+			*outMsg = '<';
+			++outMsg;
+			*outMsg = '\000';
+
+			// output active substring at full brightness
+			//ConColorMsg( colorTable[ colorIndex ], "%s", buffer );
+			DevMsg( "%s", buffer );
+
+			outMsg = buffer;
+			
+			// from here until end of Action, use dim colors
+			buriedLevel = 1;
+		}
+
+	}
+
+	*outMsg = '\000';
+	//ConColorMsg( colorTable[ colorIndex ], "%s", buffer );
+	DevMsg( "%s", buffer );
+
+	//ConColorMsg( colorTable[ colorIndex ], "\n\n" );
+	DevMsg( "\n\n" );
+}
+
+
+
+
+
+#endif // _BEHAVIOR_ENGINE_H_
+
+
+
+
+
diff --git a/game/server/NextBot/NextBotBodyInterface.cpp b/game/server/NextBot/NextBotBodyInterface.cpp
new file mode 100644
index 00000000..143ed4cd
--- /dev/null
+++ b/game/server/NextBot/NextBotBodyInterface.cpp
@@ -0,0 +1,55 @@
+// NextBotBodyInterface.cpp
+// Control and information about the bot's body state (posture, animation state, etc)
+// Author: Michael Booth, April 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "NextBot.h"
+#include "NextBotBodyInterface.h"
+
+
+void IBody::AimHeadTowards( const Vector &lookAtPos, LookAtPriorityType priority, float duration, INextBotReply *replyWhenAimed, const char *reason )
+{
+	if ( replyWhenAimed )
+	{
+		replyWhenAimed->OnFail( GetBot(), INextBotReply::FAILED );
+	}
+}
+
+void IBody::AimHeadTowards( CBaseEntity *subject, LookAtPriorityType priority, float duration, INextBotReply *replyWhenAimed, const char *reason )
+{
+	if ( replyWhenAimed )
+	{
+		replyWhenAimed->OnFail( GetBot(), INextBotReply::FAILED );
+	}
+}
+
+bool IBody::SetPosition( const Vector &pos )
+{
+	GetBot()->GetEntity()->SetAbsOrigin( pos );
+	return true;
+}
+
+const Vector &IBody::GetEyePosition( void ) const
+{
+	static Vector eye;
+
+	eye = GetBot()->GetEntity()->WorldSpaceCenter();
+
+	return eye;
+}
+
+const Vector &IBody::GetViewVector( void ) const
+{
+	static Vector view;
+	
+	AngleVectors( GetBot()->GetEntity()->EyeAngles(), &view );
+
+	return view;
+}
+
+bool IBody::IsHeadAimingOnTarget( void ) const
+{
+	return false;
+}
diff --git a/game/server/NextBot/NextBotBodyInterface.h b/game/server/NextBot/NextBotBodyInterface.h
new file mode 100644
index 00000000..8d8a59ca
--- /dev/null
+++ b/game/server/NextBot/NextBotBodyInterface.h
@@ -0,0 +1,325 @@
+// NextBotBodyInterface.h
+// Control and information about the bot's body state (posture, animation state, etc)
+// Author: Michael Booth, April 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_BODY_INTERFACE_H_
+#define _NEXT_BOT_BODY_INTERFACE_H_
+
+#include "animation.h"
+#include "NextBotComponentInterface.h"
+
+class INextBot;
+struct animevent_t;
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for control and information about the bot's body state (posture, animation state, etc)
+ */
+class IBody : public INextBotComponent
+{
+public:
+	IBody( INextBot *bot ) : INextBotComponent( bot ) { }
+	virtual ~IBody() { }
+
+	virtual void Reset( void ) { INextBotComponent::Reset(); }			// reset to initial state
+	virtual void Update( void ) { }										// update internal state
+
+	/**
+	 * Move the bot to a new position.
+	 * If the body is not currently movable or if it
+	 * is in a motion-controlled animation activity 
+	 * the position will not be changed and false will be returned.
+	 */
+	virtual bool SetPosition( const Vector &pos );
+
+	virtual const Vector &GetEyePosition( void ) const;					// return the eye position of the bot in world coordinates
+	virtual const Vector &GetViewVector( void ) const;					// return the view unit direction vector in world coordinates
+
+	enum LookAtPriorityType
+	{
+		BORING,
+		INTERESTING,				// last known enemy location, dangerous sound location
+		IMPORTANT,					// a danger
+		CRITICAL,					// an active threat to our safety
+		MANDATORY					// nothing can interrupt this look at - two simultaneous look ats with this priority is an error
+	};
+	virtual void AimHeadTowards( const Vector &lookAtPos, 
+								 LookAtPriorityType priority = BORING, 
+								 float duration = 0.0f,
+								 INextBotReply *replyWhenAimed = NULL,
+								 const char *reason = NULL );		// aim the bot's head towards the given goal
+	virtual void AimHeadTowards( CBaseEntity *subject,
+								 LookAtPriorityType priority = BORING, 
+								 float duration = 0.0f,
+								 INextBotReply *replyWhenAimed = NULL,
+								 const char *reason = NULL );		// continually aim the bot's head towards the given subject
+
+	virtual bool IsHeadAimingOnTarget( void ) const;				// return true if the bot's head has achieved its most recent lookat target
+	virtual bool IsHeadSteady( void ) const;						// return true if head is not rapidly turning to look somewhere else
+	virtual float GetHeadSteadyDuration( void ) const;				// return the duration that the bot's head has not been rotating
+	virtual float GetHeadAimSubjectLeadTime( void ) const;			// return how far into the future we should predict our moving subject's position to aim at when tracking subject look-ats
+	virtual float GetHeadAimTrackingInterval( void ) const;			// return how often we should sample our target's position and velocity to update our aim tracking, to allow realistic slop in tracking
+	virtual void ClearPendingAimReply( void ) { }					// clear out currently pending replyWhenAimed callback
+
+	virtual float GetMaxHeadAngularVelocity( void ) const;			// return max turn rate of head in degrees/second
+
+	enum ActivityType 
+	{ 
+		MOTION_CONTROLLED_XY	= 0x0001,	// XY position and orientation of the bot is driven by the animation.
+		MOTION_CONTROLLED_Z		= 0x0002,	// Z position of the bot is driven by the animation.
+		ACTIVITY_UNINTERRUPTIBLE= 0x0004,	// activity can't be changed until animation finishes
+		ACTIVITY_TRANSITORY		= 0x0008,	// a short animation that takes over from the underlying animation momentarily, resuming it upon completion
+		ENTINDEX_PLAYBACK_RATE	= 0x0010,	// played back at different rates based on entindex
+	};
+
+	/**
+	 * Begin an animation activity, return false if we cant do that right now.
+	 */
+	virtual bool StartActivity( Activity act, unsigned int flags = 0 );
+	virtual int SelectAnimationSequence( Activity act ) const;			// given an Activity, select and return a specific animation sequence within it
+
+	virtual Activity GetActivity( void ) const;							// return currently animating activity
+	virtual bool IsActivity( Activity act ) const;						// return true if currently animating activity matches the given one
+	virtual bool HasActivityType( unsigned int flags ) const;			// return true if currently animating activity has any of the given flags
+
+	enum PostureType
+	{
+		STAND,
+		CROUCH,
+		SIT,
+		CRAWL,
+		LIE
+	};
+	virtual void SetDesiredPosture( PostureType posture ) { }			// request a posture change
+	virtual PostureType GetDesiredPosture( void ) const;				// get posture body is trying to assume
+	virtual bool IsDesiredPosture( PostureType posture ) const;			// return true if body is trying to assume this posture
+	virtual bool IsInDesiredPosture( void ) const;						// return true if body's actual posture matches its desired posture
+
+	virtual PostureType GetActualPosture( void ) const;					// return body's current actual posture
+	virtual bool IsActualPosture( PostureType posture ) const;			// return true if body is actually in the given posture
+
+	virtual bool IsPostureMobile( void ) const;							// return true if body's current posture allows it to move around the world
+	virtual bool IsPostureChanging( void ) const;						// return true if body's posture is in the process of changing to new posture
+	
+	
+	/**
+	 * "Arousal" is the level of excitedness/arousal/anxiety of the body.
+	 * Is changes instantaneously to avoid complex interactions with posture transitions.
+	 */
+	enum ArousalType
+	{
+		NEUTRAL,
+		ALERT,
+		INTENSE
+	};
+	virtual void SetArousal( ArousalType arousal ) { }					// arousal level change
+	virtual ArousalType GetArousal( void ) const;						// get arousal level
+	virtual bool IsArousal( ArousalType arousal ) const;				// return true if body is at this arousal level
+
+
+	virtual float GetHullWidth( void ) const;							// width of bot's collision hull in XY plane
+	virtual float GetHullHeight( void ) const;							// height of bot's current collision hull based on posture
+	virtual float GetStandHullHeight( void ) const;						// height of bot's collision hull when standing
+	virtual float GetCrouchHullHeight( void ) const;					// height of bot's collision hull when crouched
+	virtual const Vector &GetHullMins( void ) const;					// return current collision hull minimums based on actual body posture
+	virtual const Vector &GetHullMaxs( void ) const;					// return current collision hull maximums based on actual body posture
+
+	virtual unsigned int GetSolidMask( void ) const;					// return the bot's collision mask (hack until we get a general hull trace abstraction here or in the locomotion interface)
+	virtual unsigned int GetCollisionGroup( void ) const;
+};
+
+
+inline bool IBody::IsHeadSteady( void ) const
+{
+	return true;
+}
+
+inline float IBody::GetHeadSteadyDuration( void ) const
+{
+	return 0.0f;
+}
+
+inline float IBody::GetHeadAimSubjectLeadTime( void ) const
+{
+	return 0.0f;
+}
+
+inline float IBody::GetHeadAimTrackingInterval( void ) const
+{
+	return 0.0f;
+}
+
+inline float IBody::GetMaxHeadAngularVelocity( void ) const
+{
+	return 1000.0f;
+}
+
+inline bool IBody::StartActivity( Activity act, unsigned int flags )
+{
+	return false;
+}
+
+inline int IBody::SelectAnimationSequence( Activity act ) const
+{
+	return 0;
+}
+
+inline Activity IBody::GetActivity( void ) const
+{
+	return ACT_INVALID;
+}
+
+inline bool IBody::IsActivity( Activity act ) const
+{
+	return false;
+}
+
+inline bool IBody::HasActivityType( unsigned int flags ) const
+{
+	return false;
+}
+
+inline IBody::PostureType IBody::GetDesiredPosture( void ) const
+{
+	return IBody::STAND;
+}
+
+inline bool IBody::IsDesiredPosture( PostureType posture ) const
+{
+	return true;
+}
+
+inline bool IBody::IsInDesiredPosture( void ) const
+{
+	return true;
+}
+
+inline IBody::PostureType IBody::GetActualPosture( void ) const
+{
+	return IBody::STAND;
+}
+
+inline bool IBody::IsActualPosture( PostureType posture ) const
+{
+	return true;
+}
+
+inline bool IBody::IsPostureMobile( void ) const
+{
+	return true;
+}
+
+inline bool IBody::IsPostureChanging( void ) const
+{
+	return false;
+}
+
+inline IBody::ArousalType IBody::GetArousal( void ) const
+{
+	return IBody::NEUTRAL;
+}
+
+inline bool IBody::IsArousal( ArousalType arousal ) const
+{
+	return true;
+}
+
+//---------------------------------------------------------------------------------------------------------------------------
+/**
+ * Width of bot's collision hull in XY plane
+ */
+inline float IBody::GetHullWidth( void ) const
+{
+	return 26.0f;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------------
+/**
+ * Height of bot's current collision hull based on posture
+ */
+inline float IBody::GetHullHeight( void ) const
+{
+	switch( GetActualPosture() )
+	{
+	case LIE:
+		return 16.0f;
+
+	case SIT:
+	case CROUCH:
+		return GetCrouchHullHeight();
+
+	case STAND:
+	default:
+		return GetStandHullHeight();
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------------
+/**
+ * Height of bot's collision hull when standing
+ */
+inline float IBody::GetStandHullHeight( void ) const
+{
+	return 68.0f;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------------
+/**
+ * Height of bot's collision hull when crouched
+ */
+inline float IBody::GetCrouchHullHeight( void ) const
+{
+	return 32.0f;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------------
+/**
+ * Return current collision hull minimums based on actual body posture
+ */
+inline const Vector &IBody::GetHullMins( void ) const
+{
+	static Vector hullMins;
+
+	hullMins.x = -GetHullWidth()/2.0f;
+	hullMins.y = hullMins.x;
+	hullMins.z = 0.0f;
+
+	return hullMins;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------------------
+/**
+ * Return current collision hull maximums based on actual body posture
+ */
+inline const Vector &IBody::GetHullMaxs( void ) const
+{
+	static Vector hullMaxs;
+
+	hullMaxs.x = GetHullWidth()/2.0f;
+	hullMaxs.y = hullMaxs.x;
+	hullMaxs.z = GetHullHeight();
+
+	return hullMaxs;
+}
+
+
+inline unsigned int IBody::GetSolidMask( void ) const
+{
+	return MASK_NPCSOLID;
+}
+
+inline unsigned int IBody::GetCollisionGroup( void ) const
+{
+	return COLLISION_GROUP_NONE;
+}
+
+
+
+#endif // _NEXT_BOT_BODY_INTERFACE_H_
diff --git a/game/server/NextBot/NextBotComponentInterface.cpp b/game/server/NextBot/NextBotComponentInterface.cpp
new file mode 100644
index 00000000..0c4c1720
--- /dev/null
+++ b/game/server/NextBot/NextBotComponentInterface.cpp
@@ -0,0 +1,24 @@
+// NextBotComponentInterface.cpp
+// Implentation of system methods for NextBot component interface
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "NextBotInterface.h"
+#include "NextBotComponentInterface.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+INextBotComponent::INextBotComponent( INextBot *bot )
+{
+	m_curInterval = TICK_INTERVAL;
+	m_lastUpdateTime = 0;
+	m_bot = bot;
+	
+	// register this component with the bot
+	bot->RegisterComponent( this );
+}
+
+
diff --git a/game/server/NextBot/NextBotComponentInterface.h b/game/server/NextBot/NextBotComponentInterface.h
new file mode 100644
index 00000000..344d708c
--- /dev/null
+++ b/game/server/NextBot/NextBotComponentInterface.h
@@ -0,0 +1,98 @@
+// NextBotComponentInterface.h
+// Interface for all components
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_COMPONENT_INTERFACE_H_
+#define _NEXT_BOT_COMPONENT_INTERFACE_H_
+
+#include "NextBotEventResponderInterface.h"
+
+class INextBot;
+class Path;
+class CGameTrace;
+class CTakeDamageInfo;
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+/**
+ * Various processes can invoke a "reply" (ie: callback) via instances of this interface
+ */
+class INextBotReply
+{
+public:
+	virtual void OnSuccess( INextBot *bot )  { }						// invoked when process completed successfully
+
+	enum FailureReason
+	{
+		DENIED,
+		INTERRUPTED,
+		FAILED
+	};
+	virtual void OnFail( INextBot *bot, FailureReason reason ) { }		// invoked when process failed
+};
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+/**
+ * Next Bot component interface
+ */
+class INextBotComponent : public INextBotEventResponder
+{
+public:
+	INextBotComponent( INextBot *bot );
+	virtual ~INextBotComponent() { }
+
+	virtual void Reset( void )	{ m_lastUpdateTime = 0; m_curInterval = TICK_INTERVAL; }				// reset to initial state
+	virtual void Update( void ) = 0;									// update internal state
+	virtual void Upkeep( void ) { }										// lightweight update guaranteed to occur every server tick
+
+	inline bool ComputeUpdateInterval();								// return false is no time has elapsed (interval is zero)
+	inline float GetUpdateInterval();
+
+	virtual INextBot *GetBot( void ) const  { return m_bot; }
+	
+private:
+	float m_lastUpdateTime;
+	float m_curInterval;
+
+	friend class INextBot;
+	
+	INextBot *m_bot;
+	INextBotComponent *m_nextComponent;									// simple linked list of components in the bot
+};
+
+
+inline bool INextBotComponent::ComputeUpdateInterval() 
+{ 
+	if ( m_lastUpdateTime ) 
+	{ 
+		float interval = gpGlobals->curtime - m_lastUpdateTime;
+
+		const float minInterval = 0.0001f;
+		if ( interval > minInterval )
+		{
+			m_curInterval = interval;
+			m_lastUpdateTime = gpGlobals->curtime;
+			return true;
+		}
+
+		return false;
+	}
+
+	// First update - assume a reasonable interval.
+	// We need the very first update to do work, for cases
+	// where the bot was just created and we need to propagate
+	// an event to it immediately.
+	m_curInterval = 0.033f;
+	m_lastUpdateTime = gpGlobals->curtime - m_curInterval;
+
+	return true;
+}
+
+inline float INextBotComponent::GetUpdateInterval() 
+{ 
+	return m_curInterval; 
+}
+
+#endif // _NEXT_BOT_COMPONENT_INTERFACE_H_
diff --git a/game/server/NextBot/NextBotContextualQueryInterface.h b/game/server/NextBot/NextBotContextualQueryInterface.h
new file mode 100644
index 00000000..d117bcab
--- /dev/null
+++ b/game/server/NextBot/NextBotContextualQueryInterface.h
@@ -0,0 +1,102 @@
+// NextBotContextualQueryInterface.h
+// Queries within the context of the bot's current behavior state
+// Author: Michael Booth, June 2007
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_CONTEXTUAL_QUERY_H_
+#define _NEXT_BOT_CONTEXTUAL_QUERY_H_
+
+class INextBot;
+class CBaseEntity;
+class CBaseCombatCharacter;
+class Path;
+class CKnownEntity;
+
+/** 
+ * Since behaviors can have several concurrent actions active, we ask
+ * the topmost child action first, and if it defers, its parent, and so
+ * on, until we get a definitive answer.
+ */
+enum QueryResultType
+{
+	ANSWER_NO,
+	ANSWER_YES,
+	ANSWER_UNDEFINED
+};
+
+// Can pass this into IContextualQuery::IsHindrance to see if any hindrance is ever possible
+#define IS_ANY_HINDRANCE_POSSIBLE	( (CBaseEntity*)0xFFFFFFFF )
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for queries that are dependent on the bot's current behavior state
+ */
+class IContextualQuery
+{
+public:
+	virtual ~IContextualQuery() { }
+
+	virtual QueryResultType			ShouldPickUp( const INextBot *me, CBaseEntity *item ) const;		// if the desired item was available right now, should we pick it up?
+	virtual QueryResultType			ShouldHurry( const INextBot *me ) const;							// are we in a hurry?
+	virtual QueryResultType			ShouldRetreat( const INextBot *me ) const;							// is it time to retreat?
+	virtual QueryResultType			ShouldAttack( const INextBot *me, const CKnownEntity *them ) const;	// should we attack "them"?
+	virtual QueryResultType			IsHindrance( const INextBot *me, CBaseEntity *blocker ) const;		// return true if we should wait for 'blocker' that is across our path somewhere up ahead.
+
+	virtual Vector					SelectTargetPoint( const INextBot *me, const CBaseCombatCharacter *subject ) const;		// given a subject, return the world space position we should aim at
+
+	/**
+	 * Allow bot to approve of positions game movement tries to put him into.
+	 * This is most useful for bots derived from CBasePlayer that go through
+	 * the player movement system.
+	 */
+	virtual QueryResultType IsPositionAllowed( const INextBot *me, const Vector &pos ) const;
+
+	virtual const CKnownEntity *	SelectMoreDangerousThreat( const INextBot *me, 
+															   const CBaseCombatCharacter *subject,
+															   const CKnownEntity *threat1, 
+															   const CKnownEntity *threat2 ) const;	// return the more dangerous of the two threats to 'subject', or NULL if we have no opinion
+};
+
+inline QueryResultType IContextualQuery::ShouldPickUp( const INextBot *me, CBaseEntity *item ) const
+{
+	return ANSWER_UNDEFINED;
+}
+
+inline QueryResultType IContextualQuery::ShouldHurry( const INextBot *me ) const
+{
+	return ANSWER_UNDEFINED;
+}
+
+inline QueryResultType IContextualQuery::ShouldRetreat( const INextBot *me ) const
+{
+	return ANSWER_UNDEFINED;
+}
+
+inline QueryResultType IContextualQuery::ShouldAttack( const INextBot *me, const CKnownEntity *them ) const
+{
+	return ANSWER_UNDEFINED;
+}
+
+inline QueryResultType IContextualQuery::IsHindrance( const INextBot *me, CBaseEntity *blocker ) const
+{
+	return ANSWER_UNDEFINED;
+}
+
+inline Vector IContextualQuery::SelectTargetPoint( const INextBot *me, const CBaseCombatCharacter *subject ) const
+{
+	return vec3_origin;
+}
+
+inline QueryResultType IContextualQuery::IsPositionAllowed( const INextBot *me, const Vector &pos ) const
+{
+	return ANSWER_UNDEFINED;
+}
+
+inline const CKnownEntity *IContextualQuery::SelectMoreDangerousThreat( const INextBot *me, const CBaseCombatCharacter *subject, const CKnownEntity *threat1, const CKnownEntity *threat2 ) const
+{
+	return NULL;
+}
+
+
+#endif // _NEXT_BOT_CONTEXTUAL_QUERY_H_
diff --git a/game/server/NextBot/NextBotDebug.h b/game/server/NextBot/NextBotDebug.h
new file mode 100644
index 00000000..88e0ba21
--- /dev/null
+++ b/game/server/NextBot/NextBotDebug.h
@@ -0,0 +1,23 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef NEXTBOT_DEBUG_H
+#define NEXTBOT_DEBUG_H
+//------------------------------------------------------------------------------
+// Debug flags for nextbot
+
+enum NextBotDebugType 
+{
+	NEXTBOT_DEBUG_NONE = 0,
+	NEXTBOT_BEHAVIOR	= 0x0001,
+	NEXTBOT_LOOK_AT		= 0x0002,
+	NEXTBOT_PATH		= 0x0004,
+	NEXTBOT_ANIMATION	= 0x0008,
+	NEXTBOT_LOCOMOTION	= 0x0010,
+	NEXTBOT_VISION		= 0x0020,
+	NEXTBOT_HEARING		= 0x0040,
+	NEXTBOT_EVENTS		= 0x0080,
+	NEXTBOT_ERRORS		= 0x0100,		// when things go wrong, like being stuck
+
+	NEXTBOT_DEBUG_ALL	= 0xFFFF
+};
+
+#endif
diff --git a/game/server/NextBot/NextBotEventResponderInterface.h b/game/server/NextBot/NextBotEventResponderInterface.h
new file mode 100644
index 00000000..9e7ba568
--- /dev/null
+++ b/game/server/NextBot/NextBotEventResponderInterface.h
@@ -0,0 +1,550 @@
+// NextBotEventResponderInterface.h
+// Interface for propagating and responding to events
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_EVENT_RESPONDER_INTERFACE_H_
+#define _NEXT_BOT_EVENT_RESPONDER_INTERFACE_H_
+
+class Path;
+class CTakeDamageInfo;
+class CBaseEntity;
+class CDOTABaseAbility;
+
+struct CSoundParameters;
+struct animevent_t;
+
+#include "ai_speech.h"
+
+
+//--------------------------------------------------------------------------------------------------------------------------
+enum MoveToFailureType
+{
+	FAIL_NO_PATH_EXISTS,
+	FAIL_STUCK,
+	FAIL_FELL_OFF,
+};
+
+//--------------------------------------------------------------------------------------------------------------------------
+/**
+ * Events propagated to/between components.
+ * To add an event, add its signature here and implement its propagation
+ * to derived classes via FirstContainedResponder() and NextContainedResponder().
+ * NOTE: Also add a translator to the Action class in NextBotBehavior.h.
+ */
+class INextBotEventResponder
+{
+public:
+	DECLARE_CLASS_NOBASE( INextBotEventResponder );
+	
+	virtual ~INextBotEventResponder() { }
+	
+	// these methods are used by derived classes to define how events propagate
+	virtual INextBotEventResponder *FirstContainedResponder( void ) const  { return NULL; }
+	virtual INextBotEventResponder *NextContainedResponder( INextBotEventResponder *current ) const { return NULL; }
+	
+	//
+	// Events.  All events must be 'extended' by calling the derived class explicitly to ensure propagation.
+	// Each event must implement its propagation in this interface class.
+	//
+	virtual void OnLeaveGround( CBaseEntity *ground );		// invoked when bot leaves ground for any reason
+	virtual void OnLandOnGround( CBaseEntity *ground );		// invoked when bot lands on the ground after being in the air
+
+	virtual void OnContact( CBaseEntity *other, CGameTrace *result = NULL );	// invoked when bot touches 'other'
+
+	virtual void OnMoveToSuccess( const Path *path );		// invoked when a bot reaches the end of the given Path
+	virtual void OnMoveToFailure( const Path *path, MoveToFailureType reason );	// invoked when a bot fails to reach the end of the given Path
+	virtual void OnStuck( void );							// invoked when bot becomes stuck while trying to move
+	virtual void OnUnStuck( void );							// invoked when a previously stuck bot becomes un-stuck and can again move
+
+	virtual void OnPostureChanged( void );					// when bot has assumed new posture (query IBody for posture)
+
+	virtual void OnAnimationActivityComplete( int activity );	// when animation activity has finished playing
+	virtual void OnAnimationActivityInterrupted( int activity );// when animation activity was replaced by another animation
+	virtual void OnAnimationEvent( animevent_t *event );	// when a QC-file animation event is triggered by the current animation sequence
+
+	virtual void OnIgnite( void );							// when bot starts to burn
+	virtual void OnInjured( const CTakeDamageInfo &info );	// when bot is damaged by something
+	virtual void OnKilled( const CTakeDamageInfo &info );	// when the bot's health reaches zero
+	virtual void OnOtherKilled( CBaseCombatCharacter *victim, const CTakeDamageInfo &info );	// when someone else dies
+
+	virtual void OnSight( CBaseEntity *subject );			// when subject initially enters bot's visual awareness
+	virtual void OnLostSight( CBaseEntity *subject );		// when subject leaves enters bot's visual awareness
+
+	virtual void OnSound( CBaseEntity *source, const Vector &pos, KeyValues *keys );				// when an entity emits a sound. "pos" is world coordinates of sound. "keys" are from sound's GameData
+	virtual void OnSpokeConcept( CBaseCombatCharacter *who, AIConcept_t concept, AI_Response *response );	// when an Actor speaks a concept
+	virtual void OnWeaponFired( CBaseCombatCharacter *whoFired, CBaseCombatWeapon *weapon );		// when someone fires a weapon
+
+	virtual void OnNavAreaChanged( CNavArea *newArea, CNavArea *oldArea );	// when bot enters a new navigation area
+
+	virtual void OnModelChanged( void );					// when the entity's model has been changed	
+
+	virtual void OnPickUp( CBaseEntity *item, CBaseCombatCharacter *giver );	// when something is added to our inventory
+	virtual void OnDrop( CBaseEntity *item );									// when something is removed from our inventory
+	virtual void OnActorEmoted( CBaseCombatCharacter *emoter, int emote );			// when "emoter" does an "emote" (ie: manual voice command, etc)
+
+	virtual void OnCommandAttack( CBaseEntity *victim );	// attack the given entity
+	virtual void OnCommandApproach( const Vector &pos, float range = 0.0f );	// move to within range of the given position
+	virtual void OnCommandApproach( CBaseEntity *goal );	// follow the given leader
+	virtual void OnCommandRetreat( CBaseEntity *threat, float range = 0.0f );	// retreat from the threat at least range units away (0 == infinite)
+	virtual void OnCommandPause( float duration = 0.0f );	// pause for the given duration (0 == forever)
+	virtual void OnCommandResume( void );					// resume after a pause
+
+	virtual void OnCommandString( const char *command );	// for debugging: respond to an arbitrary string representing a generalized command
+
+	virtual void OnShoved( CBaseEntity *pusher );			// 'pusher' has shoved me
+	virtual void OnBlinded( CBaseEntity *blinder );			// 'blinder' has blinded me with a flash of light
+
+	virtual void OnTerritoryContested( int territoryID );	// territory has been invaded and is changing ownership
+	virtual void OnTerritoryCaptured( int territoryID );	// we have captured enemy territory
+	virtual void OnTerritoryLost( int territoryID );		// we have lost territory to the enemy
+
+	virtual void OnWin( void );
+	virtual void OnLose( void );
+
+#ifdef DOTA_SERVER_DLL
+	virtual void OnCommandMoveTo( const Vector &pos );
+	virtual void OnCommandMoveToAggressive( const Vector &pos );
+	virtual void OnCommandAttack( CBaseEntity *victim, bool bDeny );
+	virtual void OnCastAbilityNoTarget( CDOTABaseAbility *ability );
+	virtual void OnCastAbilityOnPosition( CDOTABaseAbility *ability, const Vector &pos );
+	virtual void OnCastAbilityOnTarget( CDOTABaseAbility *ability, CBaseEntity *target );
+	virtual void OnDropItem( const Vector &pos, CBaseEntity *item );
+	virtual void OnPickupItem( CBaseEntity *item );
+	virtual void OnPickupRune( CBaseEntity *item );
+	virtual void OnStop();
+	virtual void OnFriendThreatened( CBaseEntity *friendly, CBaseEntity *threat );
+	virtual void OnCancelAttack( CBaseEntity *pTarget );
+	virtual void OnDominated();
+	virtual void OnWarped( Vector vStartPos );
+#endif
+};
+
+
+inline void INextBotEventResponder::OnLeaveGround( CBaseEntity *ground )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnLeaveGround( ground );
+	}	
+}
+
+inline void INextBotEventResponder::OnLandOnGround( CBaseEntity *ground )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnLandOnGround( ground );
+	}	
+}
+
+inline void INextBotEventResponder::OnContact( CBaseEntity *other, CGameTrace *result )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnContact( other, result );
+	}	
+}
+
+inline void INextBotEventResponder::OnMoveToSuccess( const Path *path )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnMoveToSuccess( path );
+	}	
+}
+
+inline void INextBotEventResponder::OnMoveToFailure( const Path *path, MoveToFailureType reason )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnMoveToFailure( path, reason );
+	}	
+}
+
+inline void INextBotEventResponder::OnStuck( void )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnStuck();
+	}	
+}
+
+inline void INextBotEventResponder::OnUnStuck( void )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnUnStuck();
+	}	
+}
+
+inline void INextBotEventResponder::OnPostureChanged( void )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnPostureChanged();
+	}	
+}
+
+inline void INextBotEventResponder::OnAnimationActivityComplete( int activity )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnAnimationActivityComplete( activity );
+	}	
+}
+
+inline void INextBotEventResponder::OnAnimationActivityInterrupted( int activity )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnAnimationActivityInterrupted( activity );
+	}	
+}
+
+inline void INextBotEventResponder::OnAnimationEvent( animevent_t *event )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnAnimationEvent( event );
+	}	
+}
+
+inline void INextBotEventResponder::OnIgnite( void )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnIgnite();
+	}	
+}
+
+inline void INextBotEventResponder::OnInjured( const CTakeDamageInfo &info )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnInjured( info );
+	}	
+}
+
+inline void INextBotEventResponder::OnKilled( const CTakeDamageInfo &info )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnKilled( info );
+	}	
+}
+
+inline void INextBotEventResponder::OnOtherKilled( CBaseCombatCharacter *victim, const CTakeDamageInfo &info )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnOtherKilled( victim, info );
+	}	
+}
+
+inline void INextBotEventResponder::OnSight( CBaseEntity *subject )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnSight( subject );
+	}	
+}
+
+inline void INextBotEventResponder::OnLostSight( CBaseEntity *subject )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnLostSight( subject );
+	}	
+}
+
+inline void INextBotEventResponder::OnSound( CBaseEntity *source, const Vector &pos, KeyValues *keys )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnSound( source, pos, keys );
+	}	
+}
+
+inline void INextBotEventResponder::OnSpokeConcept( CBaseCombatCharacter *who, AIConcept_t concept, AI_Response *response )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnSpokeConcept( who, concept, response );
+	}	
+}
+
+inline void INextBotEventResponder::OnWeaponFired( CBaseCombatCharacter *whoFired, CBaseCombatWeapon *weapon )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnWeaponFired( whoFired, weapon );
+	}	
+}
+
+inline void INextBotEventResponder::OnNavAreaChanged( CNavArea *newArea, CNavArea *oldArea )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnNavAreaChanged( newArea, oldArea );
+	}	
+}
+
+inline void INextBotEventResponder::OnModelChanged( void )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnModelChanged();
+	}	
+}
+
+inline void INextBotEventResponder::OnPickUp( CBaseEntity *item, CBaseCombatCharacter *giver )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnPickUp( item, giver );
+	}	
+}
+
+inline void INextBotEventResponder::OnDrop( CBaseEntity *item )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnDrop( item );
+	}	
+}
+
+inline void INextBotEventResponder::OnActorEmoted( CBaseCombatCharacter *emoter, int emote )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnActorEmoted( emoter, emote );
+	}	
+}
+
+inline void INextBotEventResponder::OnShoved( CBaseEntity *pusher )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnShoved( pusher );
+	}	
+}
+
+inline void INextBotEventResponder::OnBlinded( CBaseEntity *blinder )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnBlinded( blinder );
+	}	
+}
+
+inline void INextBotEventResponder::OnCommandAttack( CBaseEntity *victim )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandAttack( victim );
+	}	
+}
+
+inline void INextBotEventResponder::OnCommandApproach( const Vector &pos, float range )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandApproach( pos, range );
+	}	
+}
+
+inline void INextBotEventResponder::OnCommandApproach( CBaseEntity *goal )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandApproach( goal );
+	}	
+}
+
+inline void INextBotEventResponder::OnCommandRetreat( CBaseEntity *threat, float range )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandRetreat( threat, range );
+	}	
+}
+
+inline void INextBotEventResponder::OnCommandPause( float duration )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandPause( duration );
+	}	
+}
+
+inline void INextBotEventResponder::OnCommandResume( void )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandResume();
+	}	
+}
+
+inline void INextBotEventResponder::OnCommandString( const char *command )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandString( command );
+	}	
+}
+
+inline void INextBotEventResponder::OnTerritoryContested( int territoryID )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnTerritoryContested( territoryID );
+	}	
+}
+
+inline void INextBotEventResponder::OnTerritoryCaptured( int territoryID )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnTerritoryCaptured( territoryID );
+	}	
+}
+
+inline void INextBotEventResponder::OnTerritoryLost( int territoryID )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnTerritoryLost( territoryID );
+	}	
+}
+
+inline void INextBotEventResponder::OnWin( void )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnWin();
+	}	
+}
+
+inline void INextBotEventResponder::OnLose( void )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnLose();
+	}	
+}
+
+#ifdef DOTA_SERVER_DLL
+inline void INextBotEventResponder::OnCommandMoveTo( const Vector &pos )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandMoveTo( pos );
+	}
+}
+
+inline void INextBotEventResponder::OnCommandMoveToAggressive( const Vector &pos )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandMoveToAggressive( pos );
+	}
+}
+
+inline void INextBotEventResponder::OnCommandAttack( CBaseEntity *victim, bool bDeny )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCommandAttack( victim, bDeny );
+	}	
+}
+
+inline void INextBotEventResponder::OnCastAbilityNoTarget( CDOTABaseAbility *ability )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCastAbilityNoTarget( ability );
+	}	
+}
+
+inline void INextBotEventResponder::OnCastAbilityOnPosition( CDOTABaseAbility *ability, const Vector &pos )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCastAbilityOnPosition( ability, pos );
+	}	
+}
+
+inline void INextBotEventResponder::OnCastAbilityOnTarget( CDOTABaseAbility *ability, CBaseEntity *target )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCastAbilityOnTarget( ability, target );
+	}	
+}
+
+inline void INextBotEventResponder::OnDropItem( const Vector &pos, CBaseEntity *item )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnDropItem( pos, item );
+	}	
+}
+
+inline void INextBotEventResponder::OnPickupItem( CBaseEntity *item )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnPickupItem( item );
+	}	
+}
+
+inline void INextBotEventResponder::OnPickupRune( CBaseEntity *item )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnPickupRune( item );
+	}	
+}
+
+inline void INextBotEventResponder::OnStop()
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnStop();
+	}	
+}
+
+inline void INextBotEventResponder::OnFriendThreatened( CBaseEntity *friendly, CBaseEntity *threat )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnFriendThreatened( friendly, threat );
+	}	
+}
+
+inline void INextBotEventResponder::OnCancelAttack( CBaseEntity *pTarget )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnCancelAttack( pTarget );
+	}	
+}
+
+inline void INextBotEventResponder::OnDominated()
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnDominated();
+	}	
+}
+
+inline void INextBotEventResponder::OnWarped( Vector vStartPos )
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		sub->OnWarped( vStartPos );
+	}	
+}
+#endif
+
+#endif // _NEXT_BOT_EVENT_RESPONDER_INTERFACE_H_
diff --git a/game/server/NextBot/NextBotGroundLocomotion.cpp b/game/server/NextBot/NextBotGroundLocomotion.cpp
new file mode 100644
index 00000000..27f6a52b
--- /dev/null
+++ b/game/server/NextBot/NextBotGroundLocomotion.cpp
@@ -0,0 +1,1442 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// NextBotGroundLocomotion.cpp
+// Basic ground-based movement for NextBotCombatCharacters
+// Author: Michael Booth, February 2009
+// Note: This is a refactoring of ZombieBotLocomotion from L4D
+
+#include "cbase.h"
+
+#include "func_break.h"
+#include "func_breakablesurf.h"
+#include "activitylist.h"
+#include "BasePropDoor.h"
+
+#include "nav.h"
+#include "NextBot.h"
+#include "NextBotGroundLocomotion.h"
+#include "NextBotUtil.h"
+#include "functorutils.h"
+#include "SharedFunctorUtils.h"
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#pragma warning( disable : 4355 )			// warning 'this' used in base member initializer list - we're using it safely
+
+
+//----------------------------------------------------------------------------------------------------------
+NextBotGroundLocomotion::NextBotGroundLocomotion( INextBot *bot ) : ILocomotion( bot )
+{
+	m_nextBot = NULL;
+	m_ladder = NULL;
+	m_desiredLean.x = 0.0f;
+	m_desiredLean.y = 0.0f;
+	m_desiredLean.z = 0.0f;
+	
+	m_bRecomputePostureOnCollision = false;
+	m_ignorePhysicsPropTimer.Invalidate();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+NextBotGroundLocomotion::~NextBotGroundLocomotion()
+{
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Reset locomotor to initial state
+ */
+void NextBotGroundLocomotion::Reset( void )
+{
+	BaseClass::Reset();
+	m_bRecomputePostureOnCollision = false;
+	m_ignorePhysicsPropTimer.Invalidate();
+
+	m_nextBot = static_cast< NextBotCombatCharacter * >( GetBot()->GetEntity() );
+	
+	m_desiredSpeed = 0.0f;
+	m_velocity = vec3_origin;
+	m_acceleration = vec3_origin;
+
+	m_desiredLean.x = 0.0f;
+	m_desiredLean.y = 0.0f;
+	m_desiredLean.z = 0.0f;
+	
+	m_ladder = NULL;
+
+	m_isJumping = false;
+	m_isJumpingAcrossGap = false;
+	m_ground = NULL;
+	m_groundNormal = Vector( 0, 0, 1.0f );
+	m_isClimbingUpToLedge = false;
+	m_isUsingFullFeetTrace = false;
+
+	m_moveVector = Vector( 1, 0, 0 );
+	
+	m_priorPos = m_nextBot->GetPosition();
+	m_lastValidPos = m_nextBot->GetPosition();
+
+	m_inhibitObstacleAvoidanceTimer.Invalidate();
+
+	m_accumApproachVectors = vec3_origin;
+	m_accumApproachWeights = 0.0f;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Move the bot along a ladder
+ */
+bool NextBotGroundLocomotion::TraverseLadder( void )
+{
+	// not climbing a ladder right now
+	return false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Update internal state
+ */
+void NextBotGroundLocomotion::Update( void )
+{
+	VPROF_BUDGET( "NextBotGroundLocomotion::Update", "NextBot" );
+
+	BaseClass::Update();
+
+	const float deltaT = GetUpdateInterval();
+
+	// apply accumulated position changes
+	ApplyAccumulatedApproach();
+
+	// need to do this first thing, because ground constraints, etc, can change it
+	Vector origPos = GetFeet();
+
+	IBody *body = GetBot()->GetBodyInterface();
+
+	if ( TraverseLadder() )
+	{
+		// bot is climbing a ladder
+		return;
+	}
+
+	if ( !body->IsPostureMobile() )
+	{
+		// sitting/lying on the ground - no slip
+		m_acceleration.x = 0.0f;
+		m_acceleration.y = 0.0f;
+		m_velocity.x = 0.0f;
+		m_velocity.y = 0.0f;
+	}
+
+	bool wasOnGround = IsOnGround();
+
+	if ( !body->HasActivityType( IBody::MOTION_CONTROLLED_Z ) )
+	{
+		// fall if in the air
+		if ( !IsOnGround() )
+		{
+			// no ground below us - fall
+			m_acceleration.z -= GetGravity();
+		}
+
+		if ( !IsClimbingOrJumping() || m_velocity.z <= 0.0f )
+		{
+			// keep us on the ground
+			UpdateGroundConstraint();
+		}
+	}
+
+	Vector newPos = GetFeet();
+
+	//
+	// Update position physics
+	//
+	Vector right( m_moveVector.y, -m_moveVector.x, 0.0f );
+
+	if ( IsOnGround() ) // || m_isClimbingUpToLedge )
+	{
+		if ( IsAttemptingToMove() )
+		{
+			float forwardSpeed = DotProduct( m_velocity, m_moveVector );
+			Vector forwardVelocity = forwardSpeed * m_moveVector;
+			Vector sideVelocity = DotProduct( m_velocity, right ) * right;
+
+			Vector frictionAccel = vec3_origin;
+
+			// only apply friction along forward direction if we are sliding backwards
+			if ( forwardSpeed < 0.0f )
+			{
+				frictionAccel = -GetFrictionForward() * forwardVelocity;
+			}
+
+			// always apply lateral friction to counteract sideslip		
+			frictionAccel += -GetFrictionSideways() * sideVelocity;
+
+			m_acceleration.x += frictionAccel.x;
+			m_acceleration.y += frictionAccel.y;
+		}
+		else
+		{
+			// come to a stop if we haven't been told to move
+			m_acceleration = vec3_origin;
+			m_velocity = vec3_origin;
+		}
+	}
+
+	// compute new position, taking into account MOTION_CONTROLLED animations in progress
+	if ( body->HasActivityType( IBody::MOTION_CONTROLLED_XY ) )
+	{
+		m_acceleration.x = 0.0f;
+		m_acceleration.y = 0.0f;
+		m_velocity.x = GetBot()->GetEntity()->GetAbsVelocity().x;
+		m_velocity.y = GetBot()->GetEntity()->GetAbsVelocity().y;
+	}
+	else
+	{
+		// euler integration
+		m_velocity.x += m_acceleration.x * deltaT;
+		m_velocity.y += m_acceleration.y * deltaT;
+
+		// euler integration		
+		newPos.x += m_velocity.x * deltaT;
+		newPos.y += m_velocity.y * deltaT;
+	}
+
+	if ( body->HasActivityType( IBody::MOTION_CONTROLLED_Z ) )
+	{
+		m_acceleration.z = 0.0f;
+		m_velocity.z = GetBot()->GetEntity()->GetAbsVelocity().z;
+	}
+	else
+	{
+		// euler integration
+		m_velocity.z += m_acceleration.z * deltaT;
+
+		// euler integration		
+		newPos.z += m_velocity.z * deltaT;
+	}
+	
+	// move bot to new position, resolving collisions along the way
+	UpdatePosition( newPos );
+
+
+	// set actual velocity based on position change after collision resolution step
+	Vector adjustedVelocity = ( GetFeet() - origPos ) / deltaT;
+
+	if ( !body->HasActivityType( IBody::MOTION_CONTROLLED_XY ) )
+	{
+		m_velocity.x = adjustedVelocity.x;
+		m_velocity.y = adjustedVelocity.y;
+	}
+
+	if ( !body->HasActivityType( IBody::MOTION_CONTROLLED_Z ) )
+	{
+		m_velocity.z = adjustedVelocity.z;
+	}
+
+
+	// collision resolution may create very high instantaneous velocities, limit it
+	Vector2D groundVel = m_velocity.AsVector2D();
+	m_actualSpeed = groundVel.NormalizeInPlace();
+
+	if ( IsOnGround() )
+	{
+		if ( m_actualSpeed > GetRunSpeed() )
+		{
+			m_actualSpeed = GetRunSpeed();
+			m_velocity.x = m_actualSpeed * groundVel.x;
+			m_velocity.y = m_actualSpeed * groundVel.y;
+		}
+
+		// remove downward velocity when landing on the ground
+		if ( !wasOnGround )
+		{
+			m_velocity.z = 0.0f;
+			m_acceleration.z = 0.0f;
+		}
+	}
+	else
+	{
+		// we're falling. if our velocity has become zero for any reason, shove it forward
+		const float epsilon = 1.0f;
+		if ( m_velocity.IsLengthLessThan( epsilon ) )
+		{
+			m_velocity = GetRunSpeed() * GetGroundMotionVector();
+		}
+	}
+
+	// update entity velocity to that of locomotor
+	m_nextBot->SetAbsVelocity( m_velocity );
+
+
+#ifdef LEANING
+	// lean sideways proportional to lateral acceleration
+	QAngle lean = GetDesiredLean();
+	
+	float sideAccel = DotProduct( right, m_acceleration );
+	float slide = sideAccel / GetMaxAcceleration();
+
+	// max lean depends on how fast we're actually moving
+	float maxLeanAngle = NextBotLeanMaxAngle.GetFloat() * m_actualSpeed / GetRunSpeed();
+
+	// actual lean angle is proportional to lateral acceleration (sliding)
+	float desiredSideLean = -maxLeanAngle * slide;
+	
+	lean.y += ( desiredSideLean - lean.y ) * NextBotLeanRate.GetFloat() * deltaT;
+
+	SetDesiredLean( lean );
+#endif // _DEBUG
+
+
+	// reset acceleration accumulation
+	m_acceleration = vec3_origin;
+
+	// debug display
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		// track position over time
+		if ( IsOnGround() )
+		{
+			NDebugOverlay::Cross3D( GetFeet(), 1.0f, 0, 255, 0, true, 15.0f );
+		}
+		else
+		{
+			NDebugOverlay::Cross3D( GetFeet(), 1.0f, 0, 255, 255, true, 15.0f );
+		}
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Move directly towards given position.
+ * We need to do this in-air as well to land jumps.
+ */
+void NextBotGroundLocomotion::Approach( const Vector &rawPos, float goalWeight )
+{
+	BaseClass::Approach( rawPos );
+
+	m_accumApproachVectors += ( rawPos - GetFeet() ) * goalWeight;
+	m_accumApproachWeights += goalWeight;
+	m_bRecomputePostureOnCollision = true;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotGroundLocomotion::ApplyAccumulatedApproach( void )
+{
+	VPROF_BUDGET( "NextBotGroundLocomotion::ApplyAccumulatedApproach", "NextBot" );
+
+	Vector rawPos = GetFeet();
+
+	const float deltaT = GetUpdateInterval();
+
+	if ( deltaT <= 0.0f )
+		return;
+
+	if ( m_accumApproachWeights > 0.0f )
+	{
+		Vector approachDelta = m_accumApproachVectors / m_accumApproachWeights;
+
+		// limit total movement to our max speed
+		float maxMove = GetRunSpeed() * deltaT;
+
+		float desiredMove = approachDelta.NormalizeInPlace();
+		if ( desiredMove > maxMove )
+		{
+			desiredMove = maxMove;
+		}
+
+		rawPos += desiredMove * approachDelta;
+
+		m_accumApproachVectors = vec3_origin;
+		m_accumApproachWeights = 0.0f;
+	}
+
+	// can only move in 2D - geometry moves us up and down
+	Vector pos( rawPos.x, rawPos.y, GetFeet().z );
+		
+	if ( !GetBot()->GetBodyInterface()->IsPostureMobile() )
+	{
+		// body is not in a movable state right now
+		return;
+	}
+
+	Vector currentPos = m_nextBot->GetPosition();
+
+	// compute unit vector to goal position
+	m_moveVector = pos - currentPos;
+	m_moveVector.z = 0.0f;
+	float change = m_moveVector.NormalizeInPlace();
+
+	const float epsilon = 0.001f;
+	if ( change < epsilon )
+	{
+		// no motion
+		m_forwardLean = 0.0f;
+		m_sideLean = 0.0f;
+		return;
+	}
+
+/*	
+	// lean forward/backward based on acceleration
+	float desiredLean = m_acceleration / NextBotLeanForwardAccel.GetFloat();
+
+	QAngle lean = GetDesiredLean();
+
+	lean.x = NextBotLeanMaxAngle.GetFloat() * clamp( desiredLean, -1.0f, 1.0f );	
+
+	SetDesiredLean( lean );
+*/	
+
+	Vector newPos;
+
+	// if we just started a jump, don't snap to the ground - let us get in the air first
+	if ( DidJustJump() || !IsOnGround() )
+	{
+		if ( false && m_isClimbingUpToLedge )	// causes bots to hang in air stuck against edges
+		{
+			// drive towards the approach position in XY to help reach ledge
+			m_moveVector = m_ledgeJumpGoalPos - currentPos;
+			m_moveVector.z = 0.0f;
+			m_moveVector.NormalizeInPlace();
+			
+			m_acceleration += GetMaxAcceleration() * m_moveVector;
+		}
+	}
+	else if ( IsOnGround() )
+	{
+		// on the ground - move towards the approach position
+		m_isClimbingUpToLedge = false;
+		
+		// snap forward movement vector along floor
+		const Vector &groundNormal = GetGroundNormal();
+		
+		Vector left( -m_moveVector.y, m_moveVector.x, 0.0f );
+		m_moveVector = CrossProduct( left, groundNormal );
+		m_moveVector.NormalizeInPlace();
+		
+		// limit maximum forward speed from self-acceleration
+		float forwardSpeed = DotProduct( m_velocity, m_moveVector );
+		
+		float maxSpeed = MIN( m_desiredSpeed, GetSpeedLimit() );
+		
+		if ( forwardSpeed < maxSpeed )
+		{
+			float ratio = ( forwardSpeed <= 0.0f ) ? 0.0f : ( forwardSpeed / maxSpeed );
+			float governor = 1.0f - ( ratio * ratio * ratio * ratio );
+			
+			// accelerate towards goal
+			m_acceleration += governor * GetMaxAcceleration() * m_moveVector;
+		}
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Move the bot to the precise given position immediately, 
+ */
+void NextBotGroundLocomotion::DriveTo( const Vector &pos )
+{
+	BaseClass::DriveTo( pos );
+	m_bRecomputePostureOnCollision = true;
+	UpdatePosition( pos );
+}
+
+
+//--------------------------------------------------------------------------------------------
+/*
+ * Trace filter solely for use with DetectCollision() below.
+ */
+class GroundLocomotionCollisionTraceFilter : public CTraceFilterSimple
+{
+public:
+	GroundLocomotionCollisionTraceFilter( INextBot *me, const IHandleEntity *passentity, int collisionGroup ) : CTraceFilterSimple( passentity, collisionGroup )
+	{
+		m_me = me;
+	}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		if ( CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask ) )
+		{
+			CBaseEntity *entity = EntityFromEntityHandle( pServerEntity );
+
+			// don't collide with ourself
+			if ( entity && m_me->IsSelf( entity ) )
+				return false;
+
+			return m_me->GetLocomotionInterface()->ShouldCollideWith( entity );
+		}
+
+		return false;
+	}
+
+	INextBot *m_me;
+};
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Check for collisions during move and attempt to resolve them
+ */
+bool NextBotGroundLocomotion::DetectCollision( trace_t *pTrace, int &recursionLimit, const Vector &from, const Vector &to, const Vector &vecMins, const Vector &vecMaxs )
+{
+	IBody *body = GetBot()->GetBodyInterface();
+
+	CBaseEntity *ignore = m_ignorePhysicsPropTimer.IsElapsed() ? NULL : m_ignorePhysicsProp;
+	GroundLocomotionCollisionTraceFilter filter( GetBot(), ignore, body->GetCollisionGroup() );
+
+	TraceHull( from, to, vecMins, vecMaxs, body->GetSolidMask(), &filter, pTrace );
+
+	if ( !pTrace->DidHit() )
+		return false;
+
+	//
+	// A collision occurred - resolve it
+	//
+
+	// bust through "flimsy" breakables and keep on going
+	if ( pTrace->DidHitNonWorldEntity() && pTrace->m_pEnt != NULL )
+	{
+		CBaseEntity *other = pTrace->m_pEnt;
+
+		if ( !other->MyCombatCharacterPointer() && IsEntityTraversable( other, IMMEDIATELY ) /*&& IsFlimsy( other )*/ )
+		{
+			if ( recursionLimit <= 0 ) 
+				return true;
+
+			--recursionLimit;
+
+			// break the weak breakable we collided with
+			CTakeDamageInfo damageInfo( GetBot()->GetEntity(), GetBot()->GetEntity(), 100.0f, DMG_CRUSH );
+			CalculateExplosiveDamageForce( &damageInfo, GetMotionVector(), pTrace->endpos );
+			other->TakeDamage( damageInfo );
+
+			// retry trace now that the breakable is out of the way
+			return DetectCollision( pTrace, recursionLimit, from, to, vecMins, vecMaxs );
+		}
+	}
+
+	/// @todo Only invoke OnContact() and Touch() once per collision pair
+	// inform other components of collision
+	if ( GetBot()->ShouldTouch( pTrace->m_pEnt ) )
+	{
+		GetBot()->OnContact( pTrace->m_pEnt, pTrace );
+	}
+
+	INextBot *them = dynamic_cast< INextBot * >( pTrace->m_pEnt );
+	if ( them && them->ShouldTouch( m_nextBot ) )
+	{
+		/// @todo construct mirror of trace
+		them->OnContact( m_nextBot );
+	}
+	else
+	{
+		pTrace->m_pEnt->Touch( GetBot()->GetEntity() );
+	}
+
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+Vector NextBotGroundLocomotion::ResolveCollision( const Vector &from, const Vector &to, int recursionLimit )
+{
+	VPROF_BUDGET( "NextBotGroundLocomotion::ResolveCollision", "NextBotExpensive" );
+
+	IBody *body = GetBot()->GetBodyInterface();
+	if ( body == NULL || recursionLimit < 0 )
+	{
+		Assert( !m_bRecomputePostureOnCollision );
+		return to;
+	}
+
+	// Only bother to recompute posture if we're currently standing or crouching
+	if ( m_bRecomputePostureOnCollision )
+	{
+		if ( !body->IsActualPosture( IBody::STAND ) && !body->IsActualPosture( IBody::CROUCH ) )
+		{
+			m_bRecomputePostureOnCollision = false;
+		}
+	}
+
+	// get bounding limits, ignoring step-upable height
+	bool bPerformCrouchTest = false;
+	Vector mins;
+	Vector maxs;
+	if ( m_isUsingFullFeetTrace )
+	{
+		mins = body->GetHullMins();
+	}
+	else
+	{
+		mins = body->GetHullMins() + Vector( 0, 0, GetStepHeight() );
+	}
+	if ( !m_bRecomputePostureOnCollision )
+	{
+		maxs = body->GetHullMaxs();
+		if ( mins.z >= maxs.z )
+		{
+			// if mins.z is greater than maxs.z, the engine will Assert 
+			// in UTIL_TraceHull, and it won't work as advertised.
+			mins.z = maxs.z - 2.0f;	
+		}
+	}
+	else
+	{
+		const float halfSize = body->GetHullWidth() / 2.0f;
+		maxs.Init( halfSize, halfSize, body->GetStandHullHeight() );
+		bPerformCrouchTest = true;
+	}
+
+	trace_t trace;
+	Vector desiredGoal = to;
+	Vector resolvedGoal;
+	IBody::PostureType nPosture = IBody::STAND;
+	while( true )
+	{
+		bool bCollided = DetectCollision( &trace, recursionLimit, from, desiredGoal, mins, maxs );
+		if ( !bCollided )
+		{
+			resolvedGoal = desiredGoal;
+			break;
+		}
+
+		// If we hit really close to our target, then stop
+		if ( !trace.startsolid && desiredGoal.DistToSqr( trace.endpos ) < 1.0f )
+		{
+			resolvedGoal = trace.endpos;
+			break;
+		}
+
+		// Check for crouch test, if it's necessary
+		// Don't bother about checking for crouch if we hit an actor 
+		// Also don't bother checking for crouch if we hit a plane that pushes us upwards 
+		if ( bPerformCrouchTest )
+		{
+			// Don't do this work twice
+			bPerformCrouchTest = false;
+
+			nPosture = body->GetDesiredPosture();
+
+			if ( !trace.m_pEnt->MyNextBotPointer() && !trace.m_pEnt->IsPlayer() )
+			{
+				// Here, our standing trace hit the world or something non-breakable
+				// If we're not currently crouching, then see if we could travel
+				// the entire distance if we were crouched
+				if ( nPosture != IBody::CROUCH )
+				{
+					trace_t crouchTrace;
+					NextBotTraversableTraceFilter crouchFilter( GetBot(), ILocomotion::IMMEDIATELY );
+					Vector vecCrouchMax( maxs.x, maxs.y, body->GetCrouchHullHeight() );
+					TraceHull( from, desiredGoal, mins, vecCrouchMax, body->GetSolidMask(), &crouchFilter, &crouchTrace );
+					if ( crouchTrace.fraction >= 1.0f && !crouchTrace.startsolid )
+					{
+						nPosture = IBody::CROUCH;
+					}
+				}
+			}
+			else if ( nPosture == IBody::CROUCH )
+			{
+				// Here, our standing trace hit an actor
+
+				// NOTE: This test occurs almost never, based on my tests
+				// Converts from crouch to stand in the case where the player
+				// is currently crouching, *and* his first trace (with the standing hull)
+				// hits an actor *and* if he didn't hit that actor, he could have
+				// moved standing the entire way to his desired endpoint
+				trace_t standTrace;
+				NextBotTraversableTraceFilter standFilter( GetBot(), ILocomotion::IMMEDIATELY );
+				TraceHull( from, desiredGoal, mins, maxs, body->GetSolidMask(), &standFilter, &standTrace );
+				if ( standTrace.fraction >= 1.0f && !standTrace.startsolid )
+				{
+					nPosture = IBody::STAND;
+				}
+			}
+
+			// Our first trace was based on the standing hull.
+			// If we need be crouched, the trace was bogus; we need to do another
+			if ( nPosture == IBody::CROUCH )
+			{
+				maxs.z = body->GetCrouchHullHeight();
+				continue;
+			}
+		}
+
+		if ( trace.startsolid )
+		{
+			// stuck inside solid; don't move
+
+			if ( trace.m_pEnt && !trace.m_pEnt->IsWorld() )
+			{
+				// only ignore physics props that are not doors
+				if ( dynamic_cast< CPhysicsProp * >( trace.m_pEnt ) != NULL && dynamic_cast< CBasePropDoor * >( trace.m_pEnt ) == NULL )
+				{
+					IPhysicsObject *physics = trace.m_pEnt->VPhysicsGetObject();
+					if ( physics && physics->IsMoveable() )
+					{
+						// we've intersected a (likely moving) physics prop - ignore it for awhile so we can move out of it
+						m_ignorePhysicsProp = trace.m_pEnt;
+						m_ignorePhysicsPropTimer.Start( 1.0f );
+					}
+				}
+			}
+
+			// return to last known non-interpenetrating position
+			resolvedGoal = m_lastValidPos;
+
+			break;
+		}
+		
+		if ( --recursionLimit <= 0 )
+		{
+			// reached recursion limit, no more adjusting allowed
+			resolvedGoal = trace.endpos;
+			break;
+		}
+		
+		// never slide downwards/concave to avoid getting stuck in the ground
+		if ( trace.plane.normal.z < 0.0f )
+		{
+			trace.plane.normal.z = 0.0f;
+			trace.plane.normal.NormalizeInPlace();	
+		}
+
+		// slide off of surface we hit
+		Vector fullMove = desiredGoal - from;
+		Vector leftToMove = fullMove * ( 1.0f - trace.fraction );
+
+		// obey climbing slope limit
+		if ( !body->HasActivityType( IBody::MOTION_CONTROLLED_Z ) && 
+			 trace.plane.normal.z < GetTraversableSlopeLimit() && 
+			 fullMove.z > 0.0f )
+		{
+			fullMove.z = 0.0f;
+			trace.plane.normal.z = 0.0f;
+			trace.plane.normal.NormalizeInPlace();
+		}
+
+		float blocked = DotProduct( trace.plane.normal, leftToMove );
+
+		Vector unconstrained = fullMove - blocked * trace.plane.normal;
+
+		if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+		{
+			NDebugOverlay::Line( trace.endpos, 
+								 trace.endpos + 20.0f * trace.plane.normal, 
+								 255, 0, 150, true, 15.0f );
+		}
+
+		// check for collisions along remainder of move
+		// But don't bother if we're not going to deflect much
+		Vector remainingMove = from + unconstrained;
+		if ( remainingMove.DistToSqr( trace.endpos ) < 1.0f )
+		{
+			resolvedGoal = trace.endpos;
+			break;
+		}
+
+		desiredGoal = remainingMove;
+	}
+
+	if ( !trace.startsolid )
+	{
+		m_lastValidPos = resolvedGoal;
+	}
+
+	if ( m_bRecomputePostureOnCollision )
+	{
+		m_bRecomputePostureOnCollision = false;
+
+		if ( !body->IsActualPosture( nPosture ) )
+		{
+			body->SetDesiredPosture( nPosture );
+		}
+	}
+
+	return resolvedGoal;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Collect the closest actors
+ */
+class ClosestActorsScan
+{
+public:
+	ClosestActorsScan( const Vector &spot, int team, float maxRange = 0.0f, CBaseCombatCharacter *ignore = NULL )
+	{
+		m_spot = spot;
+		m_team = team;
+		m_close = NULL;
+		
+		if ( maxRange > 0.0f )
+		{
+			m_closeRangeSq = maxRange * maxRange;
+		}
+		else
+		{
+			m_closeRangeSq = 999999999.9f;
+		}
+		
+		m_ignore = ignore;
+	}
+	
+	bool operator() ( CBaseCombatCharacter *actor )
+	{
+		if (actor == m_ignore)
+			return true;
+			
+		if (actor->IsAlive() && (m_team == TEAM_ANY || actor->GetTeamNumber() == m_team))
+		{
+			Vector to = actor->WorldSpaceCenter() - m_spot;
+			float rangeSq = to.LengthSqr();
+			if (rangeSq < m_closeRangeSq)
+			{
+				m_closeRangeSq = rangeSq;
+				m_close = actor;
+			}
+		}
+		return true;
+	}
+	
+	CBaseCombatCharacter *GetActor( void ) const
+	{
+		return m_close;
+	}
+	
+	bool IsCloserThan( float range )
+	{
+		return (m_closeRangeSq < (range * range));
+	}
+
+	bool IsFartherThan( float range )
+	{
+		return (m_closeRangeSq > (range * range));
+	}
+	
+	Vector m_spot;
+	int m_team;
+	CBaseCombatCharacter *m_close;
+	float m_closeRangeSq;
+	CBaseCombatCharacter *m_ignore;
+};
+
+
+#ifdef SKIPME
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Push away zombies that are interpenetrating
+ */
+Vector NextBotGroundLocomotion::ResolveZombieCollisions( const Vector &pos )
+{
+	Vector adjustedNewPos = pos;
+
+	Infected *me = m_nextBot->MyInfectedPointer();
+	const float hullWidth = me->GetBodyInterface()->GetHullWidth();
+
+	// only avoid if we're actually trying to move somewhere, and are enraged
+	if ( me != NULL && !IsUsingLadder() && !IsClimbingOrJumping() && IsOnGround() && m_nextBot->IsAlive() && IsAttemptingToMove() /*&& GetBot()->GetBodyInterface()->IsArousal( IBody::INTENSE )*/ )
+	{
+		VPROF_BUDGET( "NextBotGroundLocomotion::ResolveZombieCollisions", "NextBot" );
+
+		const CUtlVector< CHandle< Infected > > &neighbors = me->GetNeighbors();
+		Vector avoid = vec3_origin;
+		float avoidWeight = 0.0f;
+
+		FOR_EACH_VEC( neighbors, it )
+		{
+			Infected *them = neighbors[ it ];
+
+			if ( them )
+			{
+				Vector toThem = them->GetAbsOrigin() - me->GetAbsOrigin();
+				toThem.z = 0.0f;
+
+				float range = toThem.NormalizeInPlace();
+
+				if ( range < hullWidth )
+				{
+					// these two infected are in contact
+					me->Touch( them );
+
+					// move out of contact
+					float penetration = hullWidth - range;
+
+					float weight = 1.0f + ( 2.0f * penetration/hullWidth );
+					avoid += -weight * toThem;
+					avoidWeight += weight;
+				}
+			}
+		}
+
+		if ( avoidWeight > 0.0f )
+		{
+			adjustedNewPos += 3.0f * ( avoid / avoidWeight );
+		}
+	}
+
+	return adjustedNewPos;
+}
+#endif // _DEBUG
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Move to newPos, resolving any collisions along the way
+ */
+void NextBotGroundLocomotion::UpdatePosition( const Vector &newPos )
+{
+	VPROF_BUDGET( "NextBotGroundLocomotion::UpdatePosition", "NextBot" );
+
+	if ( NextBotStop.GetBool() || (m_nextBot->GetFlags() & FL_FROZEN) != 0 || newPos == m_nextBot->GetPosition() )
+	{
+		return;
+	}
+
+	// avoid very nearby Actors to simulate "mushy" collisions between actors in contact with each other
+	//Vector adjustedNewPos = ResolveZombieCollisions( newPos );
+	Vector adjustedNewPos = newPos;
+
+	// check for collisions during move and resolve them	
+	const int recursionLimit = 3;
+	Vector safePos = ResolveCollision( m_nextBot->GetPosition(), adjustedNewPos, recursionLimit );
+
+	// set the bot's position
+	if ( GetBot()->GetIntentionInterface()->IsPositionAllowed( GetBot(), safePos ) != ANSWER_NO )
+	{
+		m_nextBot->SetPosition( safePos );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/** 
+ * Prevent bot from sliding through floor, and snap to the ground if we're very near it
+ */
+void NextBotGroundLocomotion::UpdateGroundConstraint( void )
+{
+	VPROF_BUDGET( "NextBotGroundLocomotion::UpdateGroundConstraint", "NextBotExpensive" );
+
+	// if we're up on the upward arc of our jump, don't interfere by snapping to ground
+	// don't do ground constraint if we're climbing a ladder
+	if ( DidJustJump() || IsAscendingOrDescendingLadder() )
+	{
+		m_isUsingFullFeetTrace = false;
+		return;
+	}
+		
+	IBody *body = GetBot()->GetBodyInterface();
+	if ( body == NULL )
+	{
+		return;
+	}
+
+	float halfWidth = body->GetHullWidth()/2.0f;
+	
+	// since we only care about ground collisions, keep hull short to avoid issues with low ceilings
+	/// @TODO: We need to also check actual hull height to avoid interpenetrating the world
+	float hullHeight = GetStepHeight();
+	
+	// always need tolerance even when jumping/falling to make sure we detect ground penetration
+	// must be at least step height to avoid 'falling' down stairs
+	const float stickToGroundTolerance = GetStepHeight() + 0.01f;
+
+	trace_t ground;
+	NextBotTraceFilterIgnoreActors filter( m_nextBot, body->GetCollisionGroup() );
+
+	TraceHull( m_nextBot->GetPosition() + Vector( 0, 0, GetStepHeight() + 0.001f ),
+					m_nextBot->GetPosition() + Vector( 0, 0, -stickToGroundTolerance ), 
+					Vector( -halfWidth, -halfWidth, 0 ), 
+					Vector( halfWidth, halfWidth, hullHeight ), 
+					body->GetSolidMask(), &filter, &ground );
+
+	if ( ground.startsolid )
+	{
+		// we're inside the ground - bad news
+		if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) && !( gpGlobals->framecount % 60 ) )
+		{
+			DevMsg( "%3.2f: Inside ground, ( %.0f, %.0f, %.0f )\n", gpGlobals->curtime, m_nextBot->GetPosition().x, m_nextBot->GetPosition().y, m_nextBot->GetPosition().z );
+		}
+		return;
+	}
+
+	if ( ground.fraction < 1.0f )
+	{
+		// there is ground below us
+		m_groundNormal = ground.plane.normal;
+
+		m_isUsingFullFeetTrace = false;
+		
+		// zero velocity normal to the ground
+		float normalVel = DotProduct( m_groundNormal, m_velocity );
+		m_velocity -= normalVel * m_groundNormal;
+		
+		// check slope limit
+		if ( ground.plane.normal.z < GetTraversableSlopeLimit() )
+		{
+			// too steep to stand here
+
+			// too steep to be ground - treat it like a wall hit
+			if ( ( m_velocity.x * ground.plane.normal.x + m_velocity.y * ground.plane.normal.y ) <= 0.0f )
+			{
+				GetBot()->OnContact( ground.m_pEnt, &ground );			
+			}
+			
+			// we're contacting some kind of ground
+			// zero accelerations normal to the ground
+
+			float normalAccel = DotProduct( m_groundNormal, m_acceleration );
+			m_acceleration -= normalAccel * m_groundNormal;
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+			{
+				DevMsg( "%3.2f: NextBotGroundLocomotion - Too steep to stand here\n", gpGlobals->curtime );
+				NDebugOverlay::Line( GetFeet(), GetFeet() + 20.0f * ground.plane.normal, 255, 150, 0, true, 5.0f );
+			}
+
+			// clear out upward velocity so we don't walk up lightpoles
+			m_velocity.z = MIN( 0, m_velocity.z );
+			m_acceleration.z = MIN( 0, m_acceleration.z );
+
+			return;
+		}
+		
+		// inform other components of collision if we didn't land on the 'world'
+		if ( ground.m_pEnt && !ground.m_pEnt->IsWorld() )
+		{
+			GetBot()->OnContact( ground.m_pEnt, &ground );
+		}
+
+		// snap us to the ground 
+		m_nextBot->SetPosition( ground.endpos );
+
+		if ( !IsOnGround() )
+		{
+			// just landed
+			m_nextBot->SetGroundEntity( ground.m_pEnt );
+			m_ground = ground.m_pEnt;
+
+			// landing stops any jump in progress
+			m_isJumping = false;
+			m_isJumpingAcrossGap = false;
+
+			GetBot()->OnLandOnGround( ground.m_pEnt );
+		}
+	}
+	else
+	{
+		// not on the ground
+		if ( IsOnGround() )
+		{
+			GetBot()->OnLeaveGround( m_nextBot->GetGroundEntity() );
+			if ( !IsClimbingUpToLedge() && !IsJumpingAcrossGap() )
+			{
+				m_isUsingFullFeetTrace = true; // We're in the air and there's space below us, so use the full trace
+				m_acceleration.z -= GetGravity(); // start our gravity now
+			}
+		}		
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/*
+void NextBotGroundLocomotion::StandUp( void )
+{
+	// make sure there is room to stand
+	trace_t result;
+	const float halfSize = GetHullWidth()/3.0f;
+	Vector standHullMin( -halfSize, -halfSize, GetStepHeight() + 0.1f );
+	Vector standHullMax( halfSize, halfSize, GetStandHullHeight() );
+	
+	TraceHull( GetFeet(), GetFeet(), standHullMin, standHullMax, MASK_NPCSOLID, m_nextBot, MASK_DEFAULTPLAYERSOLID, &result );
+
+	if ( result.fraction >= 1.0f && !result.startsolid )
+	{
+		m_isCrouching = false;
+	}
+}
+*/
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Initiate a climb to an adjacent high ledge
+ */
+bool NextBotGroundLocomotion::ClimbUpToLedge( const Vector &landingGoal, const Vector &landingForward, const CBaseEntity *obstacle )
+{
+	return false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Initiate a jump across an empty volume of space to far side
+ */
+void NextBotGroundLocomotion::JumpAcrossGap( const Vector &landingGoal, const Vector &landingForward )
+{
+	// can only jump if we're on the ground
+	if ( !IsOnGround() )
+	{
+		return;
+	}
+
+	IBody *body = GetBot()->GetBodyInterface();
+	if ( !body->StartActivity( ACT_JUMP ) )
+	{
+		// body can't jump right now
+		return;
+	}
+	
+
+	// scale impulse to land on target
+	Vector toGoal = landingGoal - GetFeet();
+	
+	// equation doesn't work if we're jumping upwards
+	float height = toGoal.z;
+	toGoal.z = 0.0f;
+	
+	float range = toGoal.NormalizeInPlace();
+
+	// jump out at 45 degree angle
+	const float cos45 = 0.7071f;
+	
+	// avoid division by zero
+	if ( height > 0.9f * range )
+	{
+		height = 0.9f * range;
+	}
+	
+	// ballistic equation to find initial velocity assuming 45 degree inclination and landing at give range and height
+	float launchVel = ( range / cos45 ) / sqrt( ( 2.0f * ( range - height ) ) / GetGravity() );
+
+	Vector up( 0, 0, 1 );
+	Vector ahead = up + toGoal;	
+	ahead.NormalizeInPlace();
+
+	//m_velocity = cos45 * launchVel * ahead;
+	m_velocity = launchVel * ahead;
+	m_acceleration = vec3_origin;
+			
+	m_isJumping = true;
+	m_isJumpingAcrossGap = true;
+	m_isClimbingUpToLedge = false;
+
+	GetBot()->OnLeaveGround( m_nextBot->GetGroundEntity() );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Initiate a simple undirected jump in the air
+ */
+void NextBotGroundLocomotion::Jump( void )
+{
+	// can only jump if we're on the ground
+	if ( !IsOnGround() )
+	{
+		return;
+	}
+
+	IBody *body = GetBot()->GetBodyInterface();
+	if ( !body->StartActivity( ACT_JUMP ) )
+	{
+		// body can't jump right now
+		return;
+	}
+
+	// jump straight up
+	m_velocity.z = sqrt( 2.0f * GetGravity() * GetMaxJumpHeight() );
+			
+	m_isJumping = true;
+	m_isClimbingUpToLedge = false;
+
+	GetBot()->OnLeaveGround( m_nextBot->GetGroundEntity() );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Set movement speed to running
+ */
+void NextBotGroundLocomotion::Run( void )
+{
+	m_desiredSpeed = GetRunSpeed();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Set movement speed to walking
+ */
+void NextBotGroundLocomotion::Walk( void )
+{
+	m_desiredSpeed = GetWalkSpeed();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Set movement speed to stopeed
+ */
+void NextBotGroundLocomotion::Stop( void )
+{
+	m_desiredSpeed = 0.0f;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Return true if standing on something
+ */
+bool NextBotGroundLocomotion::IsOnGround( void ) const
+{
+	return (m_nextBot->GetGroundEntity() != NULL);
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when bot leaves ground for any reason
+ */
+void NextBotGroundLocomotion::OnLeaveGround( CBaseEntity *ground )
+{
+	m_nextBot->SetGroundEntity( NULL );
+	m_ground = NULL;
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		DevMsg( "%3.2f: NextBotGroundLocomotion::OnLeaveGround\n", gpGlobals->curtime );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/** 
+ * Invoked when bot lands on the ground after being in the air
+ */
+void NextBotGroundLocomotion::OnLandOnGround( CBaseEntity *ground )
+{
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		DevMsg( "%3.2f: NextBotGroundLocomotion::GetBot()->OnLandOnGround\n", gpGlobals->curtime );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Get maximum speed bot can reach, regardless of desired speed
+ */
+float NextBotGroundLocomotion::GetSpeedLimit( void ) const
+{
+	// if we're crouched, move at reduced speed
+	if ( !GetBot()->GetBodyInterface()->IsActualPosture( IBody::STAND ) )
+	{
+		return 0.75f * GetRunSpeed();
+	}
+
+	// no limit
+	return 99999999.9f;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Climb the given ladder to the top and dismount
+ */
+void NextBotGroundLocomotion::ClimbLadder( const CNavLadder *ladder, const CNavArea *dismountGoal )
+{
+	// if we're already climbing this ladder, don't restart
+	if ( m_ladder == ladder && m_isGoingUpLadder )
+	{
+		return;
+	}
+	
+	m_ladder = ladder;
+	m_ladderDismountGoal = dismountGoal;
+	m_isGoingUpLadder = true;
+
+	IBody *body = GetBot()->GetBodyInterface();
+	if ( body )
+	{
+		// line them up to climb in XY
+		Vector mountSpot = m_ladder->m_bottom + m_ladder->GetNormal() * (0.75f * body->GetHullWidth());
+		mountSpot.z = GetBot()->GetPosition().z;
+		
+		UpdatePosition( mountSpot );
+		
+		body->StartActivity( ACT_CLIMB_UP, IBody::MOTION_CONTROLLED_Z );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Descend the given ladder to the bottom and dismount
+ */
+void NextBotGroundLocomotion::DescendLadder( const CNavLadder *ladder, const CNavArea *dismountGoal )
+{
+	// if we're already descending this ladder, don't restart
+	if ( m_ladder == ladder && !m_isGoingUpLadder )
+	{
+		return;
+	}
+
+	m_ladder = ladder;
+	m_ladderDismountGoal = dismountGoal;
+	m_isGoingUpLadder = false;
+
+	IBody *body = GetBot()->GetBodyInterface();
+	if ( body )
+	{
+		// line them up to climb in XY
+		Vector mountSpot = m_ladder->m_top + m_ladder->GetNormal() * (0.75f * body->GetHullWidth());
+		mountSpot.z = GetBot()->GetPosition().z;
+
+		UpdatePosition( mountSpot );
+
+		float ladderYaw = UTIL_VecToYaw( -m_ladder->GetNormal() );
+
+		QAngle angles = m_nextBot->GetLocalAngles();
+		angles.y = ladderYaw;
+		
+		m_nextBot->SetLocalAngles( angles );
+
+		body->StartActivity( ACT_CLIMB_DOWN, IBody::MOTION_CONTROLLED_Z );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+bool NextBotGroundLocomotion::IsUsingLadder( void ) const
+{
+	return ( m_ladder != NULL );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * We are actually on the ladder right now, either climbing up or down
+ */
+bool NextBotGroundLocomotion::IsAscendingOrDescendingLadder( void ) const
+{
+	return IsUsingLadder();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Return position of "feet" - point below centroid of bot at feet level
+ */
+const Vector &NextBotGroundLocomotion::GetFeet( void ) const
+{
+	return m_nextBot->GetPosition();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+const Vector & NextBotGroundLocomotion::GetAcceleration( void ) const
+{
+	return m_acceleration;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotGroundLocomotion::SetAcceleration( const Vector &accel )
+{
+	m_acceleration = accel;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void NextBotGroundLocomotion::SetVelocity( const Vector &vel )
+{
+	m_velocity = vel;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Return current world space velocity
+ */
+const Vector &NextBotGroundLocomotion::GetVelocity( void ) const
+{
+	return m_velocity;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when an bot reaches its MoveTo goal
+ */
+void NextBotGroundLocomotion::OnMoveToSuccess( const Path *path )
+{
+	// stop
+	m_velocity = vec3_origin;
+	m_acceleration = vec3_origin;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when an bot fails to reach a MoveTo goal
+ */
+void NextBotGroundLocomotion::OnMoveToFailure( const Path *path, MoveToFailureType reason )
+{
+	// stop
+	m_velocity = vec3_origin;
+	m_acceleration = vec3_origin;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+bool NextBotGroundLocomotion::DidJustJump( void ) const
+{
+	return IsClimbingOrJumping() && (m_nextBot->GetAbsVelocity().z > 0.0f);
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Rotate body to face towards "target"
+ */
+void NextBotGroundLocomotion::FaceTowards( const Vector &target )
+{
+	const float deltaT = GetUpdateInterval();
+	
+	QAngle angles = m_nextBot->GetLocalAngles();
+	
+	float desiredYaw = UTIL_VecToYaw( target - GetFeet() );
+
+	float angleDiff = UTIL_AngleDiff( desiredYaw, angles.y );
+	
+	float deltaYaw = GetMaxYawRate() * deltaT;
+	
+	if (angleDiff < -deltaYaw)
+	{
+		angles.y -= deltaYaw;
+	}
+	else if (angleDiff > deltaYaw)
+	{
+		angles.y += deltaYaw;
+	}
+	else
+	{
+		angles.y += angleDiff;
+	}
+	
+	m_nextBot->SetLocalAngles( angles );
+}
+
+
+
diff --git a/game/server/NextBot/NextBotGroundLocomotion.h b/game/server/NextBot/NextBotGroundLocomotion.h
new file mode 100644
index 00000000..ecd221a3
--- /dev/null
+++ b/game/server/NextBot/NextBotGroundLocomotion.h
@@ -0,0 +1,274 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// NextBotGroundLocomotion.h
+// Basic ground-based movement for NextBotCombatCharacters
+// Author: Michael Booth, February 2009
+// Note: This is a refactoring of ZombieBotLocomotion from L4D
+
+#ifndef NEXT_BOT_GROUND_LOCOMOTION_H
+#define NEXT_BOT_GROUND_LOCOMOTION_H
+
+#include "NextBotLocomotionInterface.h"
+#include "nav_mesh.h"
+
+
+class NextBotCombatCharacter;
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * Basic ground-based movement for NextBotCombatCharacters.
+ * This locomotor resolves collisions and assumes a ground-based bot under the influence of gravity.
+ */
+class NextBotGroundLocomotion : public ILocomotion
+{
+public:
+	DECLARE_CLASS( NextBotGroundLocomotion, ILocomotion );
+
+	NextBotGroundLocomotion( INextBot *bot );
+	virtual ~NextBotGroundLocomotion();
+	
+	virtual void Reset( void );							// reset locomotor to initial state
+	virtual void Update( void );						// update internal state
+
+	virtual void Approach( const Vector &pos, float goalWeight = 1.0f );	// move directly towards the given position
+	virtual void DriveTo( const Vector &pos );			// Move the bot to the precise given position immediately, 
+
+	virtual bool ClimbUpToLedge( const Vector &landingGoal, const Vector &landingForward, const CBaseEntity *obstacle );	// initiate a jump to an adjacent high ledge, return false if climb can't start
+	virtual void JumpAcrossGap( const Vector &landingGoal, const Vector &landingForward );	// initiate a jump across an empty volume of space to far side
+	virtual void Jump( void );							// initiate a simple undirected jump in the air
+	virtual bool IsClimbingOrJumping( void ) const;		// is jumping in any form
+	virtual bool IsClimbingUpToLedge( void ) const;		// is climbing up to a high ledge
+	virtual bool IsJumpingAcrossGap( void ) const;		// is jumping across a gap to the far side
+
+	virtual void Run( void );							// set desired movement speed to running
+	virtual void Walk( void );							// set desired movement speed to walking
+	virtual void Stop( void );							// set desired movement speed to stopped
+	virtual bool IsRunning( void ) const;
+	virtual void SetDesiredSpeed( float speed );		// set desired speed for locomotor movement
+	virtual float GetDesiredSpeed( void ) const;		// returns the current desired speed
+
+	virtual float GetSpeedLimit( void ) const;			// get maximum speed bot can reach, regardless of desired speed
+
+	virtual bool IsOnGround( void ) const;				// return true if standing on something
+	virtual void OnLeaveGround( CBaseEntity *ground );	// invoked when bot leaves ground for any reason
+	virtual void OnLandOnGround( CBaseEntity *ground );	// invoked when bot lands on the ground after being in the air
+	virtual CBaseEntity *GetGround( void ) const;		// return the current ground entity or NULL if not on the ground
+	virtual const Vector &GetGroundNormal( void ) const;// surface normal of the ground we are in contact with
+
+	virtual void ClimbLadder( const CNavLadder *ladder, const CNavArea *dismountGoal );		// climb the given ladder to the top and dismount
+	virtual void DescendLadder( const CNavLadder *ladder, const CNavArea *dismountGoal );		// descend the given ladder to the bottom and dismount
+	virtual bool IsUsingLadder( void ) const;
+	virtual bool IsAscendingOrDescendingLadder( void ) const;	// we are actually on the ladder right now, either climbing up or down
+
+	virtual void FaceTowards( const Vector &target );	// rotate body to face towards "target"
+
+	virtual void SetDesiredLean( const QAngle &lean );
+	virtual const QAngle &GetDesiredLean( void ) const;
+
+	virtual const Vector &GetFeet( void ) const;		// return position of "feet" - the driving point where the bot contacts the ground
+
+	virtual float GetStepHeight( void ) const;			// if delta Z is greater than this, we have to jump to get up
+	virtual float GetMaxJumpHeight( void ) const;		// return maximum height of a jump
+	virtual float GetDeathDropHeight( void ) const;		// distance at which we will die if we fall
+
+	virtual float GetRunSpeed( void ) const;			// get maximum running speed
+	virtual float GetWalkSpeed( void ) const;			// get maximum walking speed
+
+	virtual float GetMaxAcceleration( void ) const;		// return maximum acceleration of locomotor
+	virtual float GetMaxDeceleration( void ) const;		// return maximum deceleration of locomotor
+
+	virtual const Vector &GetAcceleration( void ) const;	// return current world space acceleration
+	virtual void SetAcceleration( const Vector &accel );	// set world space acceleration
+
+	virtual const Vector &GetVelocity( void ) const;	// return current world space velocity
+	virtual void SetVelocity( const Vector &vel );		// set world space velocity
+
+	virtual void OnMoveToSuccess( const Path *path );		// invoked when an bot reaches its MoveTo goal
+	virtual void OnMoveToFailure( const Path *path, MoveToFailureType reason );	// invoked when an bot fails to reach a MoveTo goal
+
+private:
+	void UpdatePosition( const Vector &newPos );			// move to newPos, resolving any collisions along the way
+	void UpdateGroundConstraint( void );					// keep ground solid
+	Vector ResolveCollisionV0( Vector from, Vector to, int recursionLimit );
+
+	Vector ResolveZombieCollisions( const Vector &pos );	// push away zombies that are interpenetrating
+	Vector ResolveCollision( const Vector &from, const Vector &to, int recursionLimit );	// check for collisions along move
+	bool DetectCollision( trace_t *pTrace, int &nDestructionAllowed, const Vector &from, const Vector &to, const Vector &vecMins, const Vector &vecMaxs );
+	void ApplyAccumulatedApproach( void );
+	bool DidJustJump( void ) const;							// return true if we just started a jump
+	bool TraverseLadder( void );							// return true if we are climbing a ladder
+
+	virtual float GetGravity( void ) const;					// return gravity force acting on bot
+	virtual float GetFrictionForward( void ) const;			// return magnitude of forward friction
+	virtual float GetFrictionSideways( void ) const;		// return magnitude of lateral friction
+	virtual float GetMaxYawRate( void ) const;				// return max rate of yaw rotation
+
+
+private:
+	NextBotCombatCharacter *m_nextBot;
+
+	Vector m_priorPos;										// last update's position
+	Vector m_lastValidPos;									// last valid position (not interpenetrating)
+	
+	Vector m_acceleration;
+	Vector m_velocity;
+	
+	float m_desiredSpeed;									// speed bot wants to be moving
+	float m_actualSpeed;									// actual speed bot is moving
+
+	float m_maxRunSpeed;
+
+	float m_forwardLean;
+	float m_sideLean;
+	QAngle m_desiredLean;
+	
+	bool m_isJumping;										// if true, we have jumped and have not yet hit the ground
+	bool m_isJumpingAcrossGap;								// if true, we have jumped across a gap and have not yet hit the ground
+	EHANDLE m_ground;										// have to manage this ourselves, since MOVETYPE_CUSTOM always NULLs out GetGroundEntity()
+	Vector m_groundNormal;									// surface normal of the ground we are in contact with
+	bool m_isClimbingUpToLedge;									// true if we are jumping up to an adjacent ledge
+	Vector m_ledgeJumpGoalPos;
+	bool m_isUsingFullFeetTrace;							// true if we're in the air and tracing the lowest StepHeight in ResolveCollision
+
+	const CNavLadder *m_ladder;								// ladder we are currently climbing/descending
+	const CNavArea *m_ladderDismountGoal;					// the area we enter when finished with our ladder move
+	bool m_isGoingUpLadder;									// if false, we're going down
+
+	CountdownTimer m_inhibitObstacleAvoidanceTimer;			// when active, turn off path following feelers
+
+	CountdownTimer m_wiggleTimer;							// for wiggling
+	NavRelativeDirType m_wiggleDirection;
+
+	mutable Vector m_eyePos;								// for use with GetEyes(), etc.
+
+	Vector m_moveVector;									// the direction of our motion in XY plane
+	float m_moveYaw;										// global yaw of movement direction
+
+	Vector m_accumApproachVectors;							// weighted sum of Approach() calls since last update
+	float m_accumApproachWeights;
+	bool m_bRecomputePostureOnCollision;
+
+	CountdownTimer m_ignorePhysicsPropTimer;				// if active, don't collide with physics props (because we got stuck in one)
+	EHANDLE m_ignorePhysicsProp;							// which prop to ignore
+};
+
+
+inline float NextBotGroundLocomotion::GetGravity( void ) const
+{
+	return 1000.0f;
+}
+
+inline float NextBotGroundLocomotion::GetFrictionForward( void ) const
+{
+	return 0.0f;
+}
+
+inline float NextBotGroundLocomotion::GetFrictionSideways( void ) const
+{
+	return 3.0f;
+}
+
+inline float NextBotGroundLocomotion::GetMaxYawRate( void ) const
+{
+	return 250.0f;
+}
+
+inline CBaseEntity *NextBotGroundLocomotion::GetGround( void ) const
+{
+	return m_ground;
+}
+
+
+inline const Vector &NextBotGroundLocomotion::GetGroundNormal( void ) const
+{
+	return m_groundNormal;
+}
+
+
+inline void NextBotGroundLocomotion::SetDesiredLean( const QAngle &lean )
+{
+	m_desiredLean = lean;
+}
+
+
+inline const QAngle &NextBotGroundLocomotion::GetDesiredLean( void ) const
+{
+	return m_desiredLean;
+}
+
+
+inline void NextBotGroundLocomotion::SetDesiredSpeed( float speed )
+{
+	m_desiredSpeed = speed;
+}
+
+
+inline float NextBotGroundLocomotion::GetDesiredSpeed( void ) const
+{
+	return m_desiredSpeed;
+}
+
+
+inline bool NextBotGroundLocomotion::IsClimbingOrJumping( void ) const
+{
+	return m_isJumping;
+}
+
+inline bool NextBotGroundLocomotion::IsClimbingUpToLedge( void ) const
+{
+	return m_isClimbingUpToLedge;
+}
+
+inline bool NextBotGroundLocomotion::IsJumpingAcrossGap( void ) const
+{
+	return m_isJumpingAcrossGap;
+}
+
+inline bool NextBotGroundLocomotion::IsRunning( void ) const
+{
+	/// @todo Rethink interface to distinguish actual state vs desired state (do we want to be running, or are we actually at running speed right now)
+	return m_actualSpeed > 0.9f * GetRunSpeed();
+}
+
+
+inline float NextBotGroundLocomotion::GetStepHeight( void ) const
+{
+	return 18.0f;
+}
+
+
+inline float NextBotGroundLocomotion::GetMaxJumpHeight( void ) const
+{
+	return 180.0f; // 120.0f; // 84.0f; // 58.0f;
+}
+
+
+inline float NextBotGroundLocomotion::GetDeathDropHeight( void ) const
+{
+	return 200.0f;
+}
+
+
+inline float NextBotGroundLocomotion::GetRunSpeed( void ) const
+{
+	return 150.0f;
+}
+
+
+inline float NextBotGroundLocomotion::GetWalkSpeed( void ) const
+{
+	return 75.0f;
+}
+
+inline float NextBotGroundLocomotion::GetMaxAcceleration( void ) const
+{
+	return 500.0f;
+}
+
+inline float NextBotGroundLocomotion::GetMaxDeceleration( void ) const
+{
+	return 500.0f;
+}
+
+
+#endif // NEXT_BOT_GROUND_LOCOMOTION_H
+
diff --git a/game/server/NextBot/NextBotHearingInterface.h b/game/server/NextBot/NextBotHearingInterface.h
new file mode 100644
index 00000000..76a802de
--- /dev/null
+++ b/game/server/NextBot/NextBotHearingInterface.h
@@ -0,0 +1,34 @@
+// NextBotHearingInterface.h
+// Interface for auditory queries of a bot
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_HEARING_INTERFACE_H_
+#define _NEXT_BOT_HEARING_INTERFACE_H_
+
+#include "NextBotComponentInterface.h"
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for hearing sounds
+ */
+class IHearing : public INextBotComponent
+{
+public:
+	IHearing( INextBot *bot ) : INextBotComponent( bot ) { }
+	virtual ~IHearing() { }
+
+	virtual void Reset( void );									// reset to initial state
+	virtual void Update( void );								// update internal state
+
+	virtual float GetTimeSinceHeard( int team ) const;			// return time since we heard any member of the given team
+
+	virtual CBaseEntity *GetClosestRecognized( int team = TEAM_ANY ) const;	// return the closest recognized entity
+	virtual int GetRecognizedCount( int team, float rangeLimit = -1.0f ) const;	// return the number of actors on the given team visible to us closer than rangeLimit
+
+	virtual float GetMaxHearingRange( void ) const;				// return maximum distance we can hear
+	virtual float GetMinRecognizeTime( void ) const;			// return HEARING reaction time
+};
+
+
+#endif // _NEXT_BOT_HEARING_INTERFACE_H_
diff --git a/game/server/NextBot/NextBotIntentionInterface.cpp b/game/server/NextBot/NextBotIntentionInterface.cpp
new file mode 100644
index 00000000..b7758969
--- /dev/null
+++ b/game/server/NextBot/NextBotIntentionInterface.cpp
@@ -0,0 +1,91 @@
+// NextBotIntentionInterface.cpp
+// Interface for intentional thinking
+// Author: Michael Booth, November 2007
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "NextBotInterface.h"
+#include "NextBotIntentionInterface.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//------------------------------------------------------------------------------------------------------------------------
+/**
+ * Given a subject, return the world space position we should aim at
+ */
+Vector IIntention::SelectTargetPoint( const INextBot *me, const CBaseCombatCharacter *subject ) const
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
+		if ( query )
+		{
+			// return the response of the first responder that gives a definitive answer
+			Vector result = query->SelectTargetPoint( me, subject );
+			if ( result != vec3_origin )
+			{
+				return result;
+			}
+		}
+	}	
+
+	// no answer, use a reasonable position
+	Vector threatMins, threatMaxs;
+	subject->CollisionProp()->WorldSpaceAABB( &threatMins, &threatMaxs );
+	Vector targetPoint = subject->GetAbsOrigin();
+	targetPoint.z += 0.7f * ( threatMaxs.z - threatMins.z );
+
+	return targetPoint;
+}
+
+
+//------------------------------------------------------------------------------------------------------------------------
+/**
+ * Given two threats, decide which one is more dangerous
+ */
+const CKnownEntity *IIntention::SelectMoreDangerousThreat( const INextBot *me, const CBaseCombatCharacter *subject, const CKnownEntity *threat1, const CKnownEntity *threat2 ) const
+{
+	if ( !threat1 || threat1->IsObsolete() )
+	{
+		if ( threat2 && !threat2->IsObsolete() )
+			return threat2;
+
+		return NULL;
+	}
+	else if ( !threat2 || threat2->IsObsolete() )
+	{
+		return threat1;
+	}
+
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
+		if ( query )
+		{
+			// return the response of the first responder that gives a definitive answer
+			const CKnownEntity *result = query->SelectMoreDangerousThreat( me, subject, threat1, threat2 );
+			if ( result )
+			{
+				return result;
+			}
+		}
+	}
+
+	// no specific decision was made - return closest threat as most dangerous
+	float range1 = ( subject->GetAbsOrigin() - threat1->GetLastKnownPosition() ).LengthSqr();
+	float range2 = ( subject->GetAbsOrigin() - threat2->GetLastKnownPosition() ).LengthSqr();
+
+	if ( range1 < range2 )
+	{
+		return threat1;
+	}
+
+	return threat2;
+}
+
+
+
+
diff --git a/game/server/NextBot/NextBotIntentionInterface.h b/game/server/NextBot/NextBotIntentionInterface.h
new file mode 100644
index 00000000..8ff337b0
--- /dev/null
+++ b/game/server/NextBot/NextBotIntentionInterface.h
@@ -0,0 +1,211 @@
+// NextBotIntentionInterface.h
+// Interface for intentional thinking
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_INTENTION_INTERFACE_H_
+#define _NEXT_BOT_INTENTION_INTERFACE_H_
+
+#include "NextBotComponentInterface.h"
+#include "NextBotContextualQueryInterface.h"
+
+class INextBot;
+
+//
+// Insert this macro in your INextBot-derived class declaration to
+// create a IIntention-derived class that handles the bookkeeping
+// of instantiating a Behavior with an initial Action and updating it.
+//
+#define DECLARE_INTENTION_INTERFACE( Actor )	\
+												\
+	class Actor##Intention : public IIntention	\
+	{											\
+	public:										\
+		Actor##Intention( Actor *me );			\
+		virtual ~Actor##Intention();			\
+		virtual void Reset( void );				\
+		virtual void Update( void );			\
+		virtual INextBotEventResponder *FirstContainedResponder( void ) const  { return m_behavior; }	\
+		virtual INextBotEventResponder *NextContainedResponder( INextBotEventResponder *current ) const { return NULL; }	\
+	private:									\
+		Behavior< Actor > *m_behavior;			\
+	};											\
+												\
+	public: virtual IIntention *GetIntentionInterface( void ) const 	{ return m_intention; }	\
+	private: Actor##Intention *m_intention;		\
+	public:										
+
+
+//
+// Use this macro to create the implementation code for the IIntention-derived class
+// declared above.  Since this requires InitialAction, it must occur after
+// that Action has been declared, so it can be new'd here.
+//
+#define IMPLEMENT_INTENTION_INTERFACE( Actor, InitialAction ) \
+	Actor::Actor##Intention::Actor##Intention( Actor *me ) : IIntention( me )	{ m_behavior = new Behavior< Actor >( new InitialAction ); }	\
+	Actor::Actor##Intention::~Actor##Intention() {	delete m_behavior; }	\
+	void Actor::Actor##Intention::Reset( void ) { delete m_behavior; m_behavior = new Behavior< Actor >( new InitialAction ); }	\
+	void Actor::Actor##Intention::Update( void ) { m_behavior->Update( static_cast< Actor * >( GetBot() ), GetUpdateInterval() ); }
+
+
+//
+// Use this macro in the constructor of your bot to allocate the IIntention-derived class
+//
+#define ALLOCATE_INTENTION_INTERFACE( Actor )	{ m_intention = new Actor##Intention( this ); }
+
+//
+// Use this macro in the destructor of your bot to deallocate the IIntention-derived class
+//
+#define DEALLOCATE_INTENTION_INTERFACE	{ if ( m_intention ) delete m_intention; }
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for intentional thinking.
+ * The assumption is that this is a container for one or more concurrent Behaviors.
+ * The "primary" Behavior is the FirstContainedResponder, and so on.  
+ * IContextualQuery requests are prioritized in contained responder order, such that the first responder
+ * that returns a definitive answer is accepted.  WITHIN a given responder (ie: a Behavior), the deepest child
+ * Behavior in the active stack is asked first, then its parent, and so on, allowing the most specific active
+ * Behavior to override the query responses of its more general parent Behaviors.
+ */
+class IIntention : public INextBotComponent, public IContextualQuery
+{
+public:
+	IIntention( INextBot *bot ) : INextBotComponent( bot ) { }
+	virtual ~IIntention() { }
+
+	virtual void Reset( void )  { INextBotComponent::Reset(); }	// reset to initial state
+	virtual void Update( void ) { }								// update internal state
+
+	// IContextualQuery propagation --------------------------------
+	virtual QueryResultType			ShouldPickUp( const INextBot *me, CBaseEntity *item ) const;		// if the desired item was available right now, should we pick it up?
+	virtual QueryResultType			ShouldHurry( const INextBot *me ) const;							// are we in a hurry?
+	virtual QueryResultType			ShouldRetreat( const INextBot *me ) const;							// is it time to retreat?
+	virtual QueryResultType			ShouldAttack( const INextBot *me, const CKnownEntity *them ) const;	// should we attack "them"?
+	virtual QueryResultType			IsHindrance( const INextBot *me, CBaseEntity *blocker ) const;		// return true if we should wait for 'blocker' that is across our path somewhere up ahead.
+	virtual Vector					SelectTargetPoint( const INextBot *me, const CBaseCombatCharacter *subject ) const;		// given a subject, return the world space position we should aim at
+	virtual QueryResultType			IsPositionAllowed( const INextBot *me, const Vector &pos ) const;	// is the a place we can be?
+	virtual const CKnownEntity *	SelectMoreDangerousThreat( const INextBot *me, 
+															   const CBaseCombatCharacter *subject,		// the subject of the danger
+															   const CKnownEntity *threat1, 
+															   const CKnownEntity *threat2 ) const;	// return the more dangerous of the two threats, or NULL if we have no opinion
+	// NOTE: As further queries are added, update the Behavior class to propagate them
+};
+
+
+inline QueryResultType IIntention::ShouldPickUp( const INextBot *me, CBaseEntity *item ) const
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
+		if ( query )
+		{
+			// return the response of the first responder that gives a definitive answer
+			QueryResultType result = query->ShouldPickUp( me, item );
+			if ( result != ANSWER_UNDEFINED )
+			{
+				return result;
+			}
+		}
+	}	
+	return ANSWER_UNDEFINED;
+}
+
+
+inline QueryResultType IIntention::ShouldHurry( const INextBot *me ) const
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
+		if ( query )
+		{
+			// return the response of the first responder that gives a definitive answer
+			QueryResultType result = query->ShouldHurry( me );
+			if ( result != ANSWER_UNDEFINED )
+			{
+				return result;
+			}
+		}
+	}	
+	return ANSWER_UNDEFINED;
+}
+
+
+inline QueryResultType IIntention::ShouldRetreat( const INextBot *me ) const
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
+		if ( query )
+		{
+			// return the response of the first responder that gives a definitive answer
+			QueryResultType result = query->ShouldRetreat( me );
+			if ( result != ANSWER_UNDEFINED )
+			{
+				return result;
+			}
+		}
+	}	
+	return ANSWER_UNDEFINED;
+}
+
+
+inline QueryResultType IIntention::ShouldAttack( const INextBot *me, const CKnownEntity *them ) const
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
+		if ( query )
+		{
+			// return the response of the first responder that gives a definitive answer
+			QueryResultType result = query->ShouldAttack( me, them );
+			if ( result != ANSWER_UNDEFINED )
+			{
+				return result;
+			}
+		}
+	}	
+	return ANSWER_UNDEFINED;
+}
+
+
+inline QueryResultType IIntention::IsHindrance( const INextBot *me, CBaseEntity *blocker ) const
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
+		if ( query )
+		{
+			// return the response of the first responder that gives a definitive answer
+			QueryResultType result = query->IsHindrance( me, blocker );
+			if ( result != ANSWER_UNDEFINED )
+			{
+				return result;
+			}
+		}
+	}	
+	return ANSWER_UNDEFINED;
+}
+
+
+inline QueryResultType IIntention::IsPositionAllowed( const INextBot *me, const Vector &pos ) const
+{
+	for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
+	{
+		const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
+		if ( query )
+		{
+			// return the response of the first responder that gives a definitive answer
+			QueryResultType result = query->IsPositionAllowed( me, pos );
+			if ( result != ANSWER_UNDEFINED )
+			{
+				return result;
+			}
+		}
+	}	
+	return ANSWER_UNDEFINED;
+}
+
+
+#endif // _NEXT_BOT_INTENTION_INTERFACE_H_
diff --git a/game/server/NextBot/NextBotInterface.cpp b/game/server/NextBot/NextBotInterface.cpp
new file mode 100644
index 00000000..f802e109
--- /dev/null
+++ b/game/server/NextBot/NextBotInterface.cpp
@@ -0,0 +1,537 @@
+// NextBotInterface.cpp
+// Implentation of system methods for NextBot interface
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "props.h"
+#include "fmtstr.h"
+#include "team.h"
+
+#include "NextBotInterface.h"
+#include "NextBotBodyInterface.h"
+#include "NextBotManager.h"
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// development only, off by default for 360
+ConVar NextBotDebugHistory( "nb_debug_history", IsX360() ? "0" : "1", FCVAR_CHEAT, "If true, each bot keeps a history of debug output in memory" );
+
+//----------------------------------------------------------------------------------------------------------------
+INextBot::INextBot( void ) : m_debugHistory( MAX_NEXTBOT_DEBUG_HISTORY, 0 )	// CUtlVector: grow to max length, alloc 0 initially
+{
+	m_tickLastUpdate = -999;
+	m_id = -1;
+	m_componentList = NULL;
+	m_debugDisplayLine = 0;
+
+	m_immobileTimer.Invalidate();
+	m_immobileCheckTimer.Invalidate();
+	m_immobileAnchor = vec3_origin;
+
+	m_currentPath = NULL;
+
+	// register with the manager
+	m_id = TheNextBots().Register( this );
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+INextBot::~INextBot()
+{
+	ResetDebugHistory();
+
+	// tell the manager we're gone
+	TheNextBots().UnRegister( this );
+
+	// delete Intention first, since destruction of Actions may access other components
+	if ( m_baseIntention )
+		delete m_baseIntention;
+
+	if ( m_baseLocomotion )
+		delete m_baseLocomotion;
+
+	if ( m_baseBody )
+		delete m_baseBody;
+
+	if ( m_baseVision )
+		delete m_baseVision;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void INextBot::Reset( void )
+{
+	m_tickLastUpdate = -999;
+	m_debugType = 0;
+	m_debugDisplayLine = 0;
+
+	m_immobileTimer.Invalidate();
+	m_immobileCheckTimer.Invalidate();
+	m_immobileAnchor = vec3_origin;
+
+	for( INextBotComponent *comp = m_componentList; comp; comp = comp->m_nextComponent )
+	{
+		comp->Reset();
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void INextBot::ResetDebugHistory( void )
+{
+	for ( int i=0; i<m_debugHistory.Count(); ++i )
+	{
+		delete m_debugHistory[i];
+	}
+
+	m_debugHistory.RemoveAll();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool INextBot::BeginUpdate()
+{
+	if ( TheNextBots().ShouldUpdate( this ) )
+	{
+		TheNextBots().NotifyBeginUpdate( this );
+		return true;
+	}
+	return false;
+}
+
+//----------------------------------------------------------------------------------------------------------------
+void INextBot::EndUpdate( void )
+{
+	TheNextBots().NotifyEndUpdate( this );
+}
+
+//----------------------------------------------------------------------------------------------------------------
+void INextBot::Update( void )
+{
+	VPROF_BUDGET( "INextBot::Update", "NextBot" );
+
+	m_debugDisplayLine = 0;
+
+	if ( IsDebugging( NEXTBOT_DEBUG_ALL ) )
+	{
+		CFmtStr msg;
+		DisplayDebugText( msg.sprintf( "#%d", GetEntity()->entindex() ) );
+	}
+
+	UpdateImmobileStatus();
+
+	// update all components
+	for( INextBotComponent *comp = m_componentList; comp; comp = comp->m_nextComponent )
+	{
+		if ( comp->ComputeUpdateInterval() )
+		{
+			comp->Update();
+		}
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void INextBot::Upkeep( void )
+{
+	VPROF_BUDGET( "INextBot::Upkeep", "NextBot" );
+
+	// do upkeep for all components
+	for( INextBotComponent *comp = m_componentList; comp; comp = comp->m_nextComponent )
+	{
+		comp->Upkeep();
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool INextBot::SetPosition( const Vector &pos )
+{
+	IBody *body = GetBodyInterface();
+	if (body)
+	{
+		return body->SetPosition( pos );
+	}
+	
+	// fall back to setting raw entity position
+	GetEntity()->SetAbsOrigin( pos );
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+const Vector &INextBot::GetPosition( void ) const
+{
+	return const_cast< INextBot * >( this )->GetEntity()->GetAbsOrigin();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if given actor is our enemy
+ */
+bool INextBot::IsEnemy( const CBaseEntity *them ) const
+{
+	if ( them == NULL )
+		return false;
+		
+	// this is not strictly correct, as spectators are not enemies
+	return const_cast< INextBot * >( this )->GetEntity()->GetTeamNumber() != them->GetTeamNumber();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if given actor is our friend
+ */
+bool INextBot::IsFriend( const CBaseEntity  *them ) const
+{
+	if ( them == NULL )
+		return false;
+		
+	return const_cast< INextBot * >( this )->GetEntity()->GetTeamNumber() == them->GetTeamNumber();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if 'them' is actually me
+ */
+bool INextBot::IsSelf( const CBaseEntity *them ) const
+{
+	if ( them == NULL )
+		return false;
+
+	return const_cast< INextBot * >( this )->GetEntity()->entindex() == them->entindex();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * Components call this to register themselves with the bot that contains them
+ */
+void INextBot::RegisterComponent( INextBotComponent *comp )
+{
+	// add to head of singly linked list
+	comp->m_nextComponent = m_componentList;
+	m_componentList = comp;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool INextBot::IsRangeLessThan( CBaseEntity *subject, float range ) const
+{
+	Vector botPos;
+	CBaseEntity *bot = const_cast< INextBot * >( this )->GetEntity();
+	if ( !bot || !subject )
+		return 0.0f;
+
+	bot->CollisionProp()->CalcNearestPoint( subject->WorldSpaceCenter(), &botPos );
+	float computedRange = subject->CollisionProp()->CalcDistanceFromPoint( botPos );
+	return computedRange < range;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool INextBot::IsRangeLessThan( const Vector &pos, float range ) const
+{
+	Vector to = pos - GetPosition();
+	return to.IsLengthLessThan( range );
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool INextBot::IsRangeGreaterThan( CBaseEntity *subject, float range ) const
+{
+	Vector botPos;
+	CBaseEntity *bot = const_cast< INextBot * >( this )->GetEntity();
+	if ( !bot || !subject )
+		return true;
+
+	bot->CollisionProp()->CalcNearestPoint( subject->WorldSpaceCenter(), &botPos );
+	float computedRange = subject->CollisionProp()->CalcDistanceFromPoint( botPos );
+	return computedRange > range;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool INextBot::IsRangeGreaterThan( const Vector &pos, float range ) const
+{
+	Vector to = pos - GetPosition();
+	return to.IsLengthGreaterThan( range );
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+float INextBot::GetRangeTo( CBaseEntity *subject ) const
+{
+	Vector botPos;
+	CBaseEntity *bot = const_cast< INextBot * >( this )->GetEntity();
+	if ( !bot || !subject )
+		return 0.0f;
+
+	bot->CollisionProp()->CalcNearestPoint( subject->WorldSpaceCenter(), &botPos );
+	float computedRange = subject->CollisionProp()->CalcDistanceFromPoint( botPos );
+	return computedRange;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+float INextBot::GetRangeTo( const Vector &pos ) const
+{
+	Vector to = pos - GetPosition();
+	return to.Length();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+float INextBot::GetRangeSquaredTo( CBaseEntity *subject ) const
+{
+	Vector botPos;
+	CBaseEntity *bot = const_cast< INextBot * >( this )->GetEntity();
+	if ( !bot || !subject )
+		return 0.0f;
+
+	bot->CollisionProp()->CalcNearestPoint( subject->WorldSpaceCenter(), &botPos );
+	float computedRange = subject->CollisionProp()->CalcDistanceFromPoint( botPos );
+	return computedRange * computedRange;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+float INextBot::GetRangeSquaredTo( const Vector &pos ) const
+{
+	Vector to = pos - GetPosition();
+	return to.LengthSqr();	
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool INextBot::IsDebugging( unsigned int type ) const
+{
+	if ( TheNextBots().IsDebugging( type ) )
+	{
+		return TheNextBots().IsDebugFilterMatch( this );
+	}
+
+	return false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * Return the name of this bot for debugging purposes
+ */
+const char *INextBot::GetDebugIdentifier( void ) const
+{
+	const int nameSize = 256;
+	static char name[ nameSize ];
+	
+	Q_snprintf( name, nameSize, "%s(#%d)", const_cast< INextBot * >( this )->GetEntity()->GetClassname(), const_cast< INextBot * >( this )->GetEntity()->entindex() );
+
+	return name;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we match the given debug symbol
+ */
+bool INextBot::IsDebugFilterMatch( const char *name ) const
+{
+	// compare debug identifier
+	if ( !Q_strnicmp( name, GetDebugIdentifier(), Q_strlen( name ) ) )
+	{
+		return true;
+	}
+
+	// compare team name
+	CTeam *team = GetEntity()->GetTeam();
+	if ( team && !Q_strnicmp( name, team->GetName(), Q_strlen( name ) ) )
+	{
+		return true;
+	}
+
+
+	return false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * There are some things we never want to climb on
+ */
+bool INextBot::IsAbleToClimbOnto( const CBaseEntity *object ) const
+{
+	if ( object == NULL || !const_cast<CBaseEntity *>(object)->IsAIWalkable() )
+	{
+		return false;
+	}
+
+	// never climb onto doors
+	if ( FClassnameIs( const_cast< CBaseEntity * >( object ), "prop_door*" ) || FClassnameIs( const_cast< CBaseEntity * >( object ), "func_door*" ) )
+	{
+		return false;
+	}
+
+	// ok to climb on this object
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * Can we break this object
+ */
+bool INextBot::IsAbleToBreak( const CBaseEntity *object ) const
+{
+	if ( object && object->m_takedamage == DAMAGE_YES )
+	{
+		if ( FClassnameIs( const_cast< CBaseEntity * >( object ), "func_breakable" ) && 
+			 object->GetHealth() )
+		{
+			return true;
+		}
+
+		if ( FClassnameIs( const_cast< CBaseEntity * >( object ), "func_breakable_surf" ) )
+		{
+			return true;
+		}
+
+		if ( dynamic_cast< const CBreakableProp * >( object ) != NULL )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+void INextBot::DisplayDebugText( const char *text ) const
+{
+	const_cast< INextBot * >( this )->GetEntity()->EntityText( m_debugDisplayLine++, text, 0.1 );
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void INextBot::DebugConColorMsg( NextBotDebugType debugType, const Color &color, const char *fmt, ... )
+{
+	bool isDataFormatted = false;
+
+	va_list argptr;
+	char data[ MAX_NEXTBOT_DEBUG_LINE_LENGTH ];
+
+	if ( developer.GetBool() && IsDebugging( debugType ) )
+	{
+		va_start(argptr, fmt);
+		Q_vsnprintf(data, sizeof( data ), fmt, argptr);
+		va_end(argptr);
+		isDataFormatted = true;
+
+		ConColorMsg( color, "%s", data );
+	}
+
+	if ( !NextBotDebugHistory.GetBool() )
+	{
+		if ( m_debugHistory.Count() )
+		{
+			ResetDebugHistory();
+		}
+		return;
+	}
+
+	// Don't bother with event data - it's spammy enough to overshadow everything else.
+	if ( debugType == NEXTBOT_EVENTS )
+		return;
+
+	if ( !isDataFormatted )
+	{
+		va_start(argptr, fmt);
+		Q_vsnprintf(data, sizeof( data ), fmt, argptr);
+		va_end(argptr);
+		isDataFormatted = true;
+	}
+
+	int lastLine = m_debugHistory.Count() - 1;
+	if ( lastLine >= 0 )
+	{
+		NextBotDebugLineType *line = m_debugHistory[lastLine];
+		if ( line->debugType == debugType && V_strstr( line->data, "\n" ) == NULL )
+		{
+			// append onto previous line
+			V_strncat( line->data, data, MAX_NEXTBOT_DEBUG_LINE_LENGTH );
+			return;
+		}
+	}
+
+	// Prune out an old line if needed, keeping a pointer to re-use the memory
+	NextBotDebugLineType *line = NULL;
+	if ( m_debugHistory.Count() == MAX_NEXTBOT_DEBUG_HISTORY )
+	{
+		line = m_debugHistory[0];
+		m_debugHistory.Remove( 0 );
+	}
+
+	// Add to debug history
+	if ( !line )
+	{
+		line = new NextBotDebugLineType;
+	}
+	line->debugType = debugType;
+	V_strncpy( line->data, data, MAX_NEXTBOT_DEBUG_LINE_LENGTH );
+	m_debugHistory.AddToTail( line );
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+// build a vector of debug history of the given types
+void INextBot::GetDebugHistory( unsigned int type, CUtlVector< const NextBotDebugLineType * > *lines ) const
+{
+	if ( !lines )
+		return;
+
+	lines->RemoveAll();
+
+	for ( int i=0; i<m_debugHistory.Count(); ++i )
+	{
+		NextBotDebugLineType *line = m_debugHistory[i];
+		if ( line->debugType & type )
+		{
+			lines->AddToTail( line );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void INextBot::UpdateImmobileStatus( void )
+{
+	if ( m_immobileCheckTimer.IsElapsed() )
+	{
+		m_immobileCheckTimer.Start( 1.0f );
+
+		// if we haven't moved farther than this in 1 second, we're immobile
+		if ( ( GetEntity()->GetAbsOrigin() - m_immobileAnchor ).IsLengthGreaterThan( GetImmobileSpeedThreshold() ) )
+		{
+			// moved far enough, not immobile
+			m_immobileAnchor = GetEntity()->GetAbsOrigin();
+			m_immobileTimer.Invalidate();
+		}
+		else
+		{
+			// haven't escaped our anchor - we are immobile
+			if ( !m_immobileTimer.HasStarted() )
+			{
+				m_immobileTimer.Start();
+			}
+		}
+	}
+}
+
diff --git a/game/server/NextBot/NextBotInterface.h b/game/server/NextBot/NextBotInterface.h
new file mode 100644
index 00000000..a2fd67e8
--- /dev/null
+++ b/game/server/NextBot/NextBotInterface.h
@@ -0,0 +1,302 @@
+// NextBotInterface.h
+// Interface for NextBot
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_INTERFACE_H_
+#define _NEXT_BOT_INTERFACE_H_
+
+#include "NextBot/NextBotKnownEntity.h"
+#include "NextBotComponentInterface.h"
+#include "NextBotLocomotionInterface.h"
+#include "NextBotBodyInterface.h"
+#include "NextBotIntentionInterface.h"
+#include "NextBotVisionInterface.h"
+#include "NextBotDebug.h"
+
+class CBaseCombatCharacter;
+class PathFollower;
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * A general purpose filter interface for various bot systems
+ */
+class INextBotFilter
+{
+public:
+	virtual bool IsSelected( const CBaseEntity *candidate ) const = 0;			// return true if this entity passes the filter
+};
+
+
+//----------------------------------------------------------------------------------------------------------------
+class INextBot : public INextBotEventResponder
+{
+public:
+	INextBot( void );
+	virtual ~INextBot();
+
+	int GetBotId() const;
+
+	bool BeginUpdate();
+	void EndUpdate();
+
+	virtual void Reset( void );										// (EXTEND) reset to initial state
+	virtual void Update( void );									// (EXTEND) update internal state
+	virtual void Upkeep( void );									// (EXTEND) lightweight update guaranteed to occur every server tick
+
+	void FlagForUpdate( bool b = true );
+	bool IsFlaggedForUpdate();
+	int GetTickLastUpdate() const;
+	void SetTickLastUpdate( int );
+
+	virtual bool IsRemovedOnReset( void ) const { return true; }	// remove this bot when the NextBot manager calls Reset
+
+	virtual CBaseCombatCharacter *GetEntity( void ) const	= 0;
+	virtual class NextBotCombatCharacter *GetNextBotCombatCharacter( void ) const	{ return NULL; }
+
+#ifdef TERROR
+	virtual class SurvivorBot *MySurvivorBotPointer() const { return NULL; }
+#endif
+
+	// interfaces are never NULL - return base no-op interfaces at a minimum
+	virtual ILocomotion *	GetLocomotionInterface( void ) const;
+	virtual IBody *			GetBodyInterface( void ) const;
+	virtual IIntention *	GetIntentionInterface( void ) const;
+	virtual IVision *		GetVisionInterface( void ) const;
+
+	/**
+	 * Attempt to change the bot's position. Return true if successful.
+	 */
+	virtual bool SetPosition( const Vector &pos );
+	virtual const Vector &GetPosition( void ) const;				// get the global position of the bot
+
+	/**
+	 * Friend/enemy/neutral queries
+	 */
+	virtual bool IsEnemy( const CBaseEntity *them ) const;			// return true if given entity is our enemy
+	virtual bool IsFriend( const CBaseEntity *them ) const;			// return true if given entity is our friend
+	virtual bool IsSelf( const CBaseEntity *them ) const;			// return true if 'them' is actually me
+
+	/**
+	 * Can we climb onto this entity?
+	 */	
+	virtual bool IsAbleToClimbOnto( const CBaseEntity *object ) const;
+
+	/**
+	 * Can we break this entity?
+	 */	
+	virtual bool IsAbleToBreak( const CBaseEntity *object ) const;
+
+	/**
+	 * Sometimes we want to pass through other NextBots. OnContact() will always
+	 * be invoked, but collision resolution can be skipped if this
+	 * method returns false.
+	 */
+	virtual bool IsAbleToBlockMovementOf( const INextBot *botInMotion ) const	{ return true; }
+
+	/**
+	 * Should we ever care about noticing physical contact with this entity?
+	 */
+	virtual bool ShouldTouch( const CBaseEntity *object ) const		{ return true; }
+
+	/**
+	 * This immobile system is used to track the global state of "am I actually moving or not".
+	 * The OnStuck() event is only emitted when following a path, and paths can be recomputed, etc.
+	 */
+	virtual bool IsImmobile( void ) const;					// return true if we haven't moved in awhile
+	virtual float GetImmobileDuration( void ) const;		// how long have we been immobile
+	virtual void ClearImmobileStatus( void );		
+	virtual float GetImmobileSpeedThreshold( void ) const;	// return units/second below which this actor is considered "immobile"
+
+	/**
+	 * Get the last PathFollower we followed. This method gives other interfaces a
+	 * single accessor to the most recent Path being followed by the myriad of 
+	 * different PathFollowers used in the various behaviors the bot may be doing.
+	 */
+	virtual const PathFollower *GetCurrentPath( void ) const;
+	virtual void SetCurrentPath( const PathFollower *path );
+	virtual void NotifyPathDestruction( const PathFollower *path );		// this PathFollower is going away, which may or may not be ours
+
+	// between distance utility methods
+	virtual bool IsRangeLessThan( CBaseEntity *subject, float range ) const;
+	virtual bool IsRangeLessThan( const Vector &pos, float range ) const;
+	virtual bool IsRangeGreaterThan( CBaseEntity *subject, float range ) const;
+	virtual bool IsRangeGreaterThan( const Vector &pos, float range ) const;
+	virtual float GetRangeTo( CBaseEntity *subject ) const;
+	virtual float GetRangeTo( const Vector &pos ) const;
+	virtual float GetRangeSquaredTo( CBaseEntity *subject ) const;
+	virtual float GetRangeSquaredTo( const Vector &pos ) const;
+
+	// event propagation
+	virtual INextBotEventResponder *FirstContainedResponder( void ) const;
+	virtual INextBotEventResponder *NextContainedResponder( INextBotEventResponder *current ) const;
+
+	virtual bool IsDebugging( unsigned int type ) const;		// return true if this bot is debugging any of the given types
+	virtual const char *GetDebugIdentifier( void ) const;		// return the name of this bot for debugging purposes
+	virtual bool IsDebugFilterMatch( const char *name ) const;	// return true if we match the given debug symbol
+	virtual void DisplayDebugText( const char *text ) const;	// show a line of text on the bot in the world
+	void DebugConColorMsg( NextBotDebugType debugType, const Color &color, PRINTF_FORMAT_STRING const char *fmt, ... );
+
+	enum {
+		MAX_NEXTBOT_DEBUG_HISTORY = 100,
+		MAX_NEXTBOT_DEBUG_LINE_LENGTH = 256,
+	};
+	struct NextBotDebugLineType
+	{
+		NextBotDebugType debugType;
+		char data[ MAX_NEXTBOT_DEBUG_LINE_LENGTH ];
+	};
+	void GetDebugHistory( unsigned int type, CUtlVector< const NextBotDebugLineType * > *lines ) const;	// build a vector of debug history of the given types
+	//------------------------------------------------------------------------------
+
+
+private:
+	friend class INextBotComponent;
+	void RegisterComponent( INextBotComponent *comp );		// components call this to register themselves with the bot that contains them
+	INextBotComponent *m_componentList;						// the first component
+
+	const PathFollower *m_currentPath;						// the path we most recently followed
+
+	int m_id;
+	bool m_bFlaggedForUpdate;
+	int m_tickLastUpdate;
+
+	unsigned int m_debugType;
+	mutable int m_debugDisplayLine;
+
+	Vector m_immobileAnchor;
+	CountdownTimer m_immobileCheckTimer;
+	IntervalTimer m_immobileTimer;
+	void UpdateImmobileStatus( void );
+
+	mutable ILocomotion *m_baseLocomotion;
+	mutable IBody		*m_baseBody;
+	mutable IIntention	*m_baseIntention;
+	mutable IVision		*m_baseVision;
+	//mutable IAttention	*m_baseAttention;
+
+	// Debugging info
+	void ResetDebugHistory( void );
+	CUtlVector< NextBotDebugLineType * > m_debugHistory;
+};
+
+
+inline const PathFollower *INextBot::GetCurrentPath( void ) const
+{
+	return m_currentPath;
+}
+
+inline void INextBot::SetCurrentPath( const PathFollower *path )
+{
+	m_currentPath = path;
+}
+
+inline void INextBot::NotifyPathDestruction( const PathFollower *path )
+{
+	if ( m_currentPath == path )
+		m_currentPath = NULL;
+}
+
+
+inline ILocomotion *INextBot::GetLocomotionInterface( void ) const
+{
+	// these base interfaces are lazy-allocated (instead of being fully instanced classes) for two reasons:
+	// 1) so the memory is only used if needed
+	// 2) so the component is registered properly
+	if ( m_baseLocomotion == NULL )
+	{
+		m_baseLocomotion = new ILocomotion( const_cast< INextBot * >( this ) );
+	}
+
+	return m_baseLocomotion;
+}
+
+inline IBody *INextBot::GetBodyInterface( void ) const
+{
+	if ( m_baseBody == NULL )
+	{
+		m_baseBody = new IBody( const_cast< INextBot * >( this ) );
+	}
+
+	return m_baseBody;
+}
+
+inline IIntention *INextBot::GetIntentionInterface( void ) const
+{
+	if ( m_baseIntention == NULL )
+	{
+		m_baseIntention = new IIntention( const_cast< INextBot * >( this ) );
+	}
+
+	return m_baseIntention;
+}
+
+inline IVision *INextBot::GetVisionInterface( void ) const
+{
+	if ( m_baseVision == NULL )
+	{
+		m_baseVision = new IVision( const_cast< INextBot * >( this ) );
+	}
+
+	return m_baseVision;
+}
+
+inline int INextBot::GetBotId() const
+{
+	return m_id;
+}
+
+inline void INextBot::FlagForUpdate( bool b )
+{
+	m_bFlaggedForUpdate = b;
+}
+
+inline bool INextBot::IsFlaggedForUpdate()
+{
+	return m_bFlaggedForUpdate;
+}
+
+inline int INextBot::GetTickLastUpdate() const
+{
+	return m_tickLastUpdate;
+}
+
+inline void INextBot::SetTickLastUpdate( int tick )
+{
+	m_tickLastUpdate = tick;
+}
+
+inline bool INextBot::IsImmobile( void ) const
+{
+	return m_immobileTimer.HasStarted();
+}
+
+inline float INextBot::GetImmobileDuration( void ) const
+{
+	return m_immobileTimer.GetElapsedTime();
+}
+
+inline void INextBot::ClearImmobileStatus( void )
+{
+	m_immobileTimer.Invalidate();
+	m_immobileAnchor = GetEntity()->GetAbsOrigin();
+}
+
+inline float INextBot::GetImmobileSpeedThreshold( void ) const
+{
+	return 30.0f;
+}
+
+inline INextBotEventResponder *INextBot::FirstContainedResponder( void ) const
+{
+	return m_componentList;
+}
+
+
+inline INextBotEventResponder *INextBot::NextContainedResponder( INextBotEventResponder *current ) const
+{
+	return static_cast< INextBotComponent * >( current )->m_nextComponent;
+}
+
+
+#endif // _NEXT_BOT_INTERFACE_H_
diff --git a/game/server/NextBot/NextBotKnownEntity.h b/game/server/NextBot/NextBotKnownEntity.h
new file mode 100644
index 00000000..7a4e9ed1
--- /dev/null
+++ b/game/server/NextBot/NextBotKnownEntity.h
@@ -0,0 +1,175 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// NextBotKnownEntity.h
+// Encapsulation of being aware of an entity
+// Author: Michael Booth, June 2009
+
+#ifndef NEXT_BOT_KNOWN_ENTITY_H
+#define NEXT_BOT_KNOWN_ENTITY_H
+
+//----------------------------------------------------------------------------
+/**
+ * A "known entity" is an entity that we have seen or heard at some point
+ * and which may or may not be immediately visible to us right now but which
+ * we remember the last place we encountered it, and when.
+ *
+ * TODO: Enhance interface to allow for sets of areas where an unseen entity 
+ * could potentially be, knowing his last position and his rate of movement.
+ */
+class CKnownEntity
+{
+public:
+	// constructing assumes we currently know about this entity
+	CKnownEntity( CBaseEntity *who )
+	{
+		m_who = who;
+		m_whenLastSeen = -1.0f;
+		m_whenLastBecameVisible = -1.0f;
+		m_isVisible = false;
+		m_whenBecameKnown = gpGlobals->curtime;
+		m_hasLastKnownPositionBeenSeen = false;
+		UpdatePosition();
+	}
+
+	virtual ~CKnownEntity() { }
+
+	virtual void Destroy( void )
+	{
+		m_who = NULL;
+		m_isVisible = false;
+	}
+
+	virtual void UpdatePosition( void )		// could be seen or heard, but now the entity's position is known
+	{
+		if ( m_who.Get() )
+		{
+			m_lastKnownPostion = m_who->GetAbsOrigin();
+			m_lastKnownArea = m_who->MyCombatCharacterPointer() ? m_who->MyCombatCharacterPointer()->GetLastKnownArea() : NULL;
+			m_whenLastKnown = gpGlobals->curtime;
+		}
+	}
+
+	virtual CBaseEntity *GetEntity( void ) const
+	{
+		return m_who;
+	}
+
+	virtual const Vector &GetLastKnownPosition( void ) const
+	{
+		return m_lastKnownPostion;
+	}
+
+	// Have we had a clear view of the last known position of this entity?
+	// This encapsulates the idea of "I just saw a guy right over *there* a few seconds ago, but I don't know where he is now"
+	virtual bool HasLastKnownPositionBeenSeen( void ) const
+	{
+		return m_hasLastKnownPositionBeenSeen;
+	}
+
+	virtual void MarkLastKnownPositionAsSeen( void )
+	{
+		m_hasLastKnownPositionBeenSeen = true;
+	}
+
+	virtual const CNavArea *GetLastKnownArea( void ) const
+	{
+		return m_lastKnownArea;
+	}
+
+	virtual float GetTimeSinceLastKnown( void ) const
+	{
+		return gpGlobals->curtime - m_whenLastKnown;
+	}
+
+	virtual float GetTimeSinceBecameKnown( void ) const
+	{
+		return gpGlobals->curtime - m_whenBecameKnown;
+	}
+
+	virtual void UpdateVisibilityStatus( bool visible )
+	{
+		if ( visible )
+		{
+			if ( !m_isVisible )
+			{
+				// just became visible
+				m_whenLastBecameVisible = gpGlobals->curtime;
+			}
+
+			m_whenLastSeen = gpGlobals->curtime;
+		}
+
+		m_isVisible = visible;
+	}
+
+	virtual bool IsVisibleInFOVNow( void ) const	// return true if this entity is currently visible and in my field of view
+	{
+		return m_isVisible;
+	}
+
+	virtual bool IsVisibleRecently( void ) const	// return true if this entity is visible or was very recently visible
+	{
+		if ( m_isVisible )
+			return true;
+
+		if ( WasEverVisible() && GetTimeSinceLastSeen() < 3.0f )
+			return true;
+
+		return false;
+	}
+
+	virtual float GetTimeSinceBecameVisible( void ) const
+	{
+		return gpGlobals->curtime - m_whenLastBecameVisible;
+	}
+
+	virtual float GetTimeWhenBecameVisible( void ) const
+	{
+		return m_whenLastBecameVisible;
+	}
+
+	virtual float GetTimeSinceLastSeen( void ) const
+	{
+		return gpGlobals->curtime - m_whenLastSeen;
+	}
+
+	virtual bool WasEverVisible( void ) const
+	{
+		return m_whenLastSeen > 0.0f;
+	}
+
+	// has our knowledge of this entity become obsolete?
+	virtual bool IsObsolete( void ) const
+	{
+		return GetEntity() == NULL || !m_who->IsAlive() || GetTimeSinceLastKnown() > 10.0f;
+	}
+
+	virtual bool operator==( const CKnownEntity &other ) const
+	{
+		if ( GetEntity() == NULL || other.GetEntity() == NULL )
+			return false;
+
+		return ( GetEntity() == other.GetEntity() );
+	}
+
+	virtual bool Is( CBaseEntity *who ) const
+	{
+		if ( GetEntity() == NULL || who == NULL )
+			return false;
+
+		return ( GetEntity() == who );
+	}
+
+private:
+	CHandle< CBaseEntity > m_who;
+	Vector m_lastKnownPostion;
+	bool m_hasLastKnownPositionBeenSeen;
+	CNavArea *m_lastKnownArea;
+	float m_whenLastSeen;
+	float m_whenLastBecameVisible;
+	float m_whenLastKnown;			// last seen or heard, confirming its existance
+	float m_whenBecameKnown;
+	bool m_isVisible;				// flagged by IVision update as visible or not
+};
+
+
+#endif // NEXT_BOT_KNOWN_ENTITY_H
diff --git a/game/server/NextBot/NextBotLocomotionInterface.cpp b/game/server/NextBot/NextBotLocomotionInterface.cpp
new file mode 100644
index 00000000..9acc8652
--- /dev/null
+++ b/game/server/NextBot/NextBotLocomotionInterface.cpp
@@ -0,0 +1,520 @@
+// NextBotLocomotionInterface.cpp
+// Common functionality for all NextBot locomotors
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "BasePropDoor.h"
+
+#include "nav_area.h"
+#include "NextBot.h"
+#include "NextBotUtil.h"
+#include "NextBotLocomotionInterface.h"
+#include "NextBotBodyInterface.h"
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// how far a bot must move to not be considered "stuck"
+#define STUCK_RADIUS 100.0f
+
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Reset to initial state
+ */
+ILocomotion::ILocomotion( INextBot *bot ) : INextBotComponent( bot )
+{
+	Reset();
+}
+
+ILocomotion::~ILocomotion()
+{
+}
+
+void ILocomotion::Reset( void )
+{
+	INextBotComponent::Reset();
+
+	m_motionVector = Vector( 1.0f, 0.0f, 0.0f );
+	m_speed = 0.0f;
+	m_groundMotionVector = m_motionVector;
+	m_groundSpeed = m_speed;
+
+	m_moveRequestTimer.Invalidate();
+
+	m_isStuck = false;
+	m_stuckTimer.Invalidate();
+	m_stuckPos = vec3_origin;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Update internal state
+ */
+void ILocomotion::Update( void )
+{
+	StuckMonitor();
+
+	// maintain motion vector and speed values
+	const Vector &vel = GetVelocity();
+	m_speed = vel.Length();
+	m_groundSpeed = vel.AsVector2D().Length();
+
+	const float velocityThreshold = 10.0f;
+	if ( m_speed > velocityThreshold )
+	{
+		m_motionVector = vel / m_speed;
+	}
+
+	if ( m_groundSpeed > velocityThreshold )
+	{
+		m_groundMotionVector.x = vel.x / m_groundSpeed;
+		m_groundMotionVector.y = vel.y / m_groundSpeed;
+		m_groundMotionVector.z = 0.0f;
+	}
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		// show motion vector
+		NDebugOverlay::HorzArrow( GetFeet(), GetFeet() + 25.0f * m_groundMotionVector, 3.0f, 100, 255, 0, 255, true, 0.1f );
+		NDebugOverlay::HorzArrow( GetFeet(), GetFeet() + 25.0f * m_motionVector, 5.0f, 255, 255, 0, 255, true, 0.1f );
+	}
+}
+
+
+//----------------------------------------------------------------------------
+void ILocomotion::AdjustPosture( const Vector &moveGoal )
+{
+	// This function has no effect if we're not standing or crouching
+	IBody *body = GetBot()->GetBodyInterface();
+	if ( !body->IsActualPosture( IBody::STAND ) && !body->IsActualPosture( IBody::CROUCH ) )
+		return;
+
+	//
+	// Stand or crouch as needed
+	//
+
+	// get bounding limits, ignoring step-upable height
+	const Vector &mins = body->GetHullMins() + Vector( 0, 0, GetStepHeight() );
+
+	const float halfSize = body->GetHullWidth()/2.0f;
+	Vector standMaxs( halfSize, halfSize, body->GetStandHullHeight() );
+
+	trace_t trace;
+	NextBotTraversableTraceFilter filter( GetBot(), ILocomotion::IMMEDIATELY );
+
+	// snap forward movement vector along floor
+	const Vector &groundNormal = GetGroundNormal();
+	const Vector &feet = GetFeet();
+	Vector moveDir = moveGoal - feet;
+	float moveLength = moveDir.NormalizeInPlace();
+	Vector left( -moveDir.y, moveDir.x, 0.0f );
+	Vector goal = feet + moveLength * CrossProduct( left, groundNormal ).Normalized();
+
+	TraceHull( feet, goal, mins, standMaxs, body->GetSolidMask(), &filter, &trace );
+
+	if ( trace.fraction >= 1.0f && !trace.startsolid )
+	{
+		// no collision while standing
+		if ( body->IsActualPosture( IBody::CROUCH ) )
+		{
+			body->SetDesiredPosture( IBody::STAND );
+		}
+		return;
+	}
+
+	if ( body->IsActualPosture( IBody::CROUCH ) )
+		return;
+
+	// crouch hull check
+	Vector crouchMaxs( halfSize, halfSize, body->GetCrouchHullHeight() );
+
+	TraceHull( feet, goal, mins, crouchMaxs, body->GetSolidMask(), &filter, &trace );
+
+	if ( trace.fraction >= 1.0f && !trace.startsolid )
+	{
+		// no collision while crouching
+		body->SetDesiredPosture( IBody::CROUCH );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Move directly towards the given position
+ */
+void ILocomotion::Approach( const Vector &goalPos, float goalWeight )
+{
+	// there is a desire to move
+	m_moveRequestTimer.Start();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Move the bot to the precise given position immediately
+ */
+void ILocomotion::DriveTo( const Vector &pos )
+{
+	// there is a desire to move
+	m_moveRequestTimer.Start();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this locomotor could potentially move along the line given.
+ * If false is returned, fraction of walkable ray is returned in 'fraction'
+ */
+bool ILocomotion::IsPotentiallyTraversable( const Vector &from, const Vector &to, TraverseWhenType when, float *fraction ) const
+{
+	VPROF_BUDGET( "Locomotion::IsPotentiallyTraversable", "NextBotExpensive" );
+
+	// if 'to' is high above us, it's not directly traversable
+	// Adding a bit of fudge room to allow for floating point roundoff errors
+	if ( ( to.z - from.z ) > GetMaxJumpHeight() + 0.1f )
+	{
+		Vector along = to - from;
+		along.NormalizeInPlace();
+		if ( along.z > GetTraversableSlopeLimit() )
+		{
+			if ( fraction )
+			{
+				*fraction = 0.0f;
+			}
+			return false;
+		}
+	}
+
+	trace_t result;
+	NextBotTraversableTraceFilter filter( GetBot(), when );
+
+	// use a small hull since we cannot simulate collision resolution and avoidance along the way
+	const float probeSize = 0.25f * GetBot()->GetBodyInterface()->GetHullWidth(); // Cant be TOO small, or open stairwells/grates/etc will cause problems
+	const float probeZ = GetStepHeight();
+
+	Vector hullMin( -probeSize, -probeSize, probeZ );
+	Vector hullMax( probeSize, probeSize, GetBot()->GetBodyInterface()->GetCrouchHullHeight() );
+	TraceHull( from, to, hullMin, hullMax, GetBot()->GetBodyInterface()->GetSolidMask(), &filter, &result );
+
+/*
+	if ( result.DidHit() )
+	{
+		NDebugOverlay::SweptBox( from, result.endpos, hullMin, hullMax, vec3_angle, 255, 0, 0, 255, 9999.9f );
+		NDebugOverlay::SweptBox( result.endpos, to, hullMin, hullMax, vec3_angle, 255, 255, 0, 255, 9999.9f );
+	}
+	else
+	{
+		NDebugOverlay::SweptBox( from, to, hullMin, hullMax, vec3_angle, 255, 255, 0, 255, 0.1f );
+	}
+*/
+
+	if ( fraction )
+	{
+		*fraction = result.fraction;
+	}
+
+	return ( result.fraction >= 1.0f ) && ( !result.startsolid );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Return true if there is a possible "gap" that will need to be jumped over
+ * If true is returned, fraction of ray before gap is returned in 'fraction'
+ */
+bool ILocomotion::HasPotentialGap( const Vector &from, const Vector &desiredTo, float *fraction ) const
+{
+	VPROF_BUDGET( "Locomotion::HasPotentialGap", "NextBot" );
+
+	// find section of this ray that is actually traversable
+	float traversableFraction;
+	IsPotentiallyTraversable( from, desiredTo, IMMEDIATELY, &traversableFraction );
+
+	// compute end of traversable ray
+	Vector to = from + ( desiredTo - from ) * traversableFraction;
+
+	Vector forward = to - from;
+	float length = forward.NormalizeInPlace();
+
+	IBody *body = GetBot()->GetBodyInterface();
+
+	float step = body->GetHullWidth()/2.0f;
+
+	// scan along the line checking for gaps
+	Vector pos = from;
+	Vector delta = step * forward;
+	for( float t = 0.0f; t < (length + step); t += step )
+	{
+		if ( IsGap( pos, forward ) )
+		{
+			if ( fraction )
+			{
+				*fraction = ( t - step ) / ( length + step );
+			}
+			
+			return true;
+		}
+
+		pos += delta;		
+	}
+
+	if ( fraction )
+	{
+		*fraction = 1.0f;
+	}
+
+	return false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+/**
+ * Return true if there is a "gap" here when moving in the given direction.
+ * A "gap" is a vertical dropoff that is too high to jump back up to.
+ */
+bool ILocomotion::IsGap( const Vector &pos, const Vector &forward ) const
+{
+	VPROF_BUDGET( "Locomotion::IsGap", "NextBotSpiky" );
+
+	IBody *body = GetBot()->GetBodyInterface();
+
+	//float halfWidth = ( body ) ? body->GetHullWidth()/2.0f : 1.0f;
+
+	// can't really jump effectively when crouched anyhow
+	//float hullHeight = ( body ) ? body->GetStandHullHeight() : 1.0f;
+
+	// use a small hull since we cannot simulate collision resolution and avoidance along the way
+	const float halfWidth = 1.0f;
+	const float hullHeight = 1.0f;
+
+	unsigned int mask = ( body ) ? body->GetSolidMask() : MASK_PLAYERSOLID;
+
+	trace_t ground;
+
+	NextBotTraceFilterIgnoreActors filter( GetBot()->GetEntity(), COLLISION_GROUP_NONE );
+
+	TraceHull( pos + Vector( 0, 0, GetStepHeight() ),	// start up a bit to handle rough terrain
+					pos + Vector( 0, 0, -GetMaxJumpHeight() ), 
+					Vector( -halfWidth, -halfWidth, 0 ), Vector( halfWidth, halfWidth, hullHeight ), 
+					mask, &filter, &ground );
+
+// 	int r,g,b;
+// 
+// 	if ( ground.fraction >= 1.0f && !ground.startsolid )
+// 	{
+// 		r = 255, g = 0, b = 0;
+// 	}
+// 	else
+// 	{
+// 		r = 0, g = 255, b = 0;
+// 	}
+// 
+// 	NDebugOverlay::SweptBox( pos,
+// 							 pos + Vector( 0, 0, -GetStepHeight() ),
+// 							 Vector( -halfWidth, -halfWidth, 0 ), Vector( halfWidth, halfWidth, hullHeight ),
+// 							 vec3_angle,
+// 							 r, g, b, 255, 3.0f );
+
+	// if trace hit nothing, there's a gap ahead of us
+	return ( ground.fraction >= 1.0f && !ground.startsolid );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+bool ILocomotion::IsEntityTraversable( CBaseEntity *obstacle, TraverseWhenType when ) const
+{
+	if ( obstacle->IsWorld() )
+		return false;
+
+	// assume bot will open a door in its path
+	if ( FClassnameIs( obstacle, "prop_door*" ) || FClassnameIs( obstacle, "func_door*" ) )
+	{
+		CBasePropDoor *door = dynamic_cast< CBasePropDoor * >( obstacle );
+
+		if ( door && door->IsDoorOpen() )
+		{
+			// open doors are obstacles
+			return false;
+		}
+
+		return true;
+	}
+
+	// if we hit a clip brush, ignore it if it is not BRUSHSOLID_ALWAYS
+	if ( FClassnameIs( obstacle, "func_brush" ) )
+	{
+		CFuncBrush *brush = (CFuncBrush *)obstacle;
+		
+		switch ( brush->m_iSolidity )
+		{
+			case CFuncBrush::BRUSHSOLID_ALWAYS:
+				return false;
+			case CFuncBrush::BRUSHSOLID_NEVER:
+				return true;
+			case CFuncBrush::BRUSHSOLID_TOGGLE:
+				return true;
+		}
+	}
+
+	if ( when == IMMEDIATELY )
+	{
+		// special rules in specific games can immediately break some breakables, etc.
+		return false;
+	}
+
+	// assume bot will EVENTUALLY break breakables in its path
+	return GetBot()->IsAbleToBreak( obstacle );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+bool ILocomotion::IsAreaTraversable( const CNavArea *baseArea ) const
+{ 
+	return !baseArea->IsBlocked( GetBot()->GetEntity()->GetTeamNumber() );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reset stuck status to un-stuck
+ */
+void ILocomotion::ClearStuckStatus( const char *reason )
+{
+	if ( IsStuck() )
+	{
+		m_isStuck = false;
+
+		// tell other components we're no longer stuck
+		GetBot()->OnUnStuck();
+	}
+
+	// always reset stuck monitoring data in case we cleared preemptively are were not yet stuck
+	m_stuckPos = GetFeet();
+	m_stuckTimer.Start();
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		DevMsg( "%3.2f: ClearStuckStatus: %s %s\n", gpGlobals->curtime, GetBot()->GetDebugIdentifier(), reason );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/** 
+ * Stuck check
+ */
+void ILocomotion::StuckMonitor( void )
+{
+	// a timer is needed to smooth over a few frames of inactivity due to state changes, etc.
+	// we only want to detect idle situations when the bot really doesn't "want" to move.
+	const float idleTime = 0.25f;
+	if ( m_moveRequestTimer.IsGreaterThen( idleTime ) )
+	{
+		// we have no desire to move, and therefore cannot emit stuck events
+
+		// prepare our internal state for when the bot starts to move next
+		m_stuckPos = GetFeet();
+		m_stuckTimer.Start();
+
+		return;
+	}
+
+// 	if ( !IsOnGround() )
+// 	{
+// 		// can't be stuck when in-air
+// 		ClearStuckStatus( "Off the ground" );
+// 		return;
+// 	}
+
+// 	if ( IsUsingLadder() )
+// 	{
+// 		// can't be stuck when on a ladder (for now)
+// 		ClearStuckStatus( "On a ladder" );
+// 		return;
+// 	}
+
+	if ( IsStuck() )
+	{
+		// we are/were stuck - have we moved enough to consider ourselves "dislodged"
+		if ( GetBot()->IsRangeGreaterThan( m_stuckPos, STUCK_RADIUS ) )
+		{
+			// we've just become un-stuck
+			ClearStuckStatus( "UN-STUCK" );
+		}
+		else
+		{
+			// still stuck - periodically resend the event
+			if ( m_stillStuckTimer.IsElapsed() )
+			{
+				m_stillStuckTimer.Start( 1.0f );
+
+				if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+				{
+					DevMsg( "%3.2f: %s STILL STUCK\n", gpGlobals->curtime, GetBot()->GetDebugIdentifier() );
+					NDebugOverlay::Circle( m_stuckPos + Vector( 0, 0, 5.0f ), QAngle( -90.0f, 0, 0 ), 5.0f, 255, 0, 0, 255, true, 1.0f );
+				}
+
+				GetBot()->OnStuck();
+			}
+		}
+	}
+	else
+	{
+		// we're not stuck - yet
+
+		if ( /*IsClimbingOrJumping() || */GetBot()->IsRangeGreaterThan( m_stuckPos, STUCK_RADIUS ) )
+		{
+			// we have moved - reset anchor
+			m_stuckPos = GetFeet();
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+			{
+				NDebugOverlay::Cross3D( m_stuckPos, 3.0f, 255, 0, 255, true, 3.0f );
+			}
+
+			m_stuckTimer.Start();
+		}
+		else
+		{
+			// within stuck range of anchor. if we've been here too long, we're stuck
+			if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+			{
+				NDebugOverlay::Line( GetBot()->GetEntity()->WorldSpaceCenter(), m_stuckPos, 255, 0, 255, true, 0.1f );
+			}
+
+			float minMoveSpeed = 0.1f * GetDesiredSpeed() + 0.1f;
+			float escapeTime = STUCK_RADIUS / minMoveSpeed;
+			if ( m_stuckTimer.IsGreaterThen( escapeTime ) )
+			{
+				// we have taken too long - we're stuck
+				m_isStuck = true;
+
+				if ( GetBot()->IsDebugging( NEXTBOT_ERRORS ) )
+				{
+					DevMsg( "%3.2f: %s STUCK at position( %3.2f, %3.2f, %3.2f )\n", gpGlobals->curtime, GetBot()->GetDebugIdentifier(), m_stuckPos.x, m_stuckPos.y, m_stuckPos.z );
+
+					NDebugOverlay::Circle( m_stuckPos + Vector( 0, 0, 15.0f ), QAngle( -90.0f, 0, 0 ), 3.0f, 255, 255, 0, 255, true, 1.0f );
+					NDebugOverlay::Circle( m_stuckPos + Vector( 0, 0, 5.0f ), QAngle( -90.0f, 0, 0 ), 5.0f, 255, 0, 0, 255, true, 9999999.9f );
+				}
+
+				// tell other components we've become stuck
+				GetBot()->OnStuck();
+			}
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+const Vector &ILocomotion::GetFeet( void ) const
+{
+	return GetBot()->GetEntity()->GetAbsOrigin();
+}
+
diff --git a/game/server/NextBot/NextBotLocomotionInterface.h b/game/server/NextBot/NextBotLocomotionInterface.h
new file mode 100644
index 00000000..f3117285
--- /dev/null
+++ b/game/server/NextBot/NextBotLocomotionInterface.h
@@ -0,0 +1,335 @@
+// NextBotLocomotionInterface.h
+// NextBot interface for movement through the environment
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_LOCOMOTION_INTERFACE_H_
+#define _NEXT_BOT_LOCOMOTION_INTERFACE_H_
+
+#include "NextBotComponentInterface.h"
+
+class Path;
+class INextBot;
+class CNavLadder;
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The interface encapsulating *how* a bot moves through the world (walking? flying? etc)
+ */
+class ILocomotion : public INextBotComponent
+{
+public:
+	ILocomotion( INextBot *bot );
+	virtual ~ILocomotion();
+	
+	virtual void Reset( void );								// (EXTEND) reset to initial state
+	virtual void Update( void );							// (EXTEND) update internal state
+	
+	//
+	// The primary locomotive method
+	// Depending on the physics of the bot's motion, it may not actually
+	// reach the given position precisely.
+	// The 'weight' can be used to combine multiple Approach() calls within
+	// a single frame into a single goal (ie: weighted average)
+	//
+	virtual void Approach( const Vector &goalPos, float goalWeight = 1.0f );	// (EXTEND) move directly towards the given position
+
+	//
+	// Move the bot to the precise given position immediately, 
+	// updating internal state as needed
+	// Collision resolution is done to prevent interpenetration, which may prevent
+	// the bot from reaching the given position. If no collisions occur, the
+	// bot will be at the given position when this method returns.
+	//
+	virtual void DriveTo( const Vector &pos );				// (EXTEND) Move the bot to the precise given position immediately, 
+
+	//
+	// Locomotion modifiers
+	//
+	virtual bool ClimbUpToLedge( const Vector &landingGoal, const Vector &landingForward, const CBaseEntity *obstacle ) { return true; }	// initiate a jump to an adjacent high ledge, return false if climb can't start
+	virtual void JumpAcrossGap( const Vector &landingGoal, const Vector &landingForward ) { }	// initiate a jump across an empty volume of space to far side
+	virtual void Jump( void ) { }							// initiate a simple undirected jump in the air
+	virtual bool IsClimbingOrJumping( void ) const;			// is jumping in any form
+	virtual bool IsClimbingUpToLedge( void ) const;			// is climbing up to a high ledge
+	virtual bool IsJumpingAcrossGap( void ) const;			// is jumping across a gap to the far side
+	virtual bool IsScrambling( void ) const;				// is in the middle of a complex action (climbing a ladder, climbing a ledge, jumping, etc) that shouldn't be interrupted
+
+	virtual void Run( void ) { }							// set desired movement speed to running
+	virtual void Walk( void ) { }							// set desired movement speed to walking
+	virtual void Stop( void ) { }							// set desired movement speed to stopped
+	virtual bool IsRunning( void ) const;
+	virtual void SetDesiredSpeed( float speed ) { }			// set desired speed for locomotor movement
+	virtual float GetDesiredSpeed( void ) const;			// returns the current desired speed
+
+	virtual void SetSpeedLimit( float speed ) { }					// set maximum speed bot can reach, regardless of desired speed
+	virtual float GetSpeedLimit( void ) const { return 1000.0f; }	// get maximum speed bot can reach, regardless of desired speed
+
+	virtual bool IsOnGround( void ) const;					// return true if standing on something
+	virtual void OnLeaveGround( CBaseEntity *ground ) { }	// invoked when bot leaves ground for any reason
+	virtual void OnLandOnGround( CBaseEntity *ground ) { }	// invoked when bot lands on the ground after being in the air
+	virtual CBaseEntity *GetGround( void ) const;			// return the current ground entity or NULL if not on the ground
+	virtual const Vector &GetGroundNormal( void ) const;	// surface normal of the ground we are in contact with
+	virtual float GetGroundSpeed( void ) const;				// return current world space speed in XY plane
+	virtual const Vector &GetGroundMotionVector( void ) const;	// return unit vector in XY plane describing our direction of motion - even if we are currently not moving
+
+	virtual void ClimbLadder( const CNavLadder *ladder, const CNavArea *dismountGoal ) { }		// climb the given ladder to the top and dismount
+	virtual void DescendLadder( const CNavLadder *ladder, const CNavArea *dismountGoal ) { }	// descend the given ladder to the bottom and dismount
+	virtual bool IsUsingLadder( void ) const;				// we are moving to get on, ascending/descending, and/or dismounting a ladder
+	virtual bool IsAscendingOrDescendingLadder( void ) const;	// we are actually on the ladder right now, either climbing up or down
+	virtual bool IsAbleToAutoCenterOnLadder( void ) const { return false; }
+
+	virtual void FaceTowards( const Vector &target ) { }	// rotate body to face towards "target"
+
+	virtual void SetDesiredLean( const QAngle &lean ) { }
+	virtual const QAngle &GetDesiredLean( void ) const;
+	
+
+	//
+	// Locomotion information
+	//
+	virtual bool IsAbleToJumpAcrossGaps( void ) const;		// return true if this bot can jump across gaps in its path
+	virtual bool IsAbleToClimb( void ) const;				// return true if this bot can climb arbitrary geometry it encounters
+
+	virtual const Vector &GetFeet( void ) const;			// return position of "feet" - the driving point where the bot contacts the ground
+
+	virtual float GetStepHeight( void ) const;				// if delta Z is greater than this, we have to jump to get up
+	virtual float GetMaxJumpHeight( void ) const;			// return maximum height of a jump
+	virtual float GetDeathDropHeight( void ) const;			// distance at which we will die if we fall
+
+	virtual float GetRunSpeed( void ) const;				// get maximum running speed
+	virtual float GetWalkSpeed( void ) const;				// get maximum walking speed
+
+	virtual float GetMaxAcceleration( void ) const;			// return maximum acceleration of locomotor
+	virtual float GetMaxDeceleration( void ) const;			// return maximum deceleration of locomotor
+
+	virtual const Vector &GetVelocity( void ) const;		// return current world space velocity
+	virtual float GetSpeed( void ) const;					// return current world space speed (magnitude of velocity)
+	virtual const Vector &GetMotionVector( void ) const;	// return unit vector describing our direction of motion - even if we are currently not moving
+
+	virtual bool IsAreaTraversable( const CNavArea *baseArea ) const;	// return true if given area can be used for navigation
+
+	virtual float GetTraversableSlopeLimit( void ) const;	// return Z component of unit normal of steepest traversable slope
+
+	// return true if the given entity can be ignored during locomotion
+	enum TraverseWhenType 
+	{ 
+		IMMEDIATELY,		// the entity will not block our motion - we'll carry right through
+		EVENTUALLY			// the entity will block us until we spend effort to open/destroy it
+	};
+
+	/**
+	 * Return true if this locomotor could potentially move along the line given.
+	 * If false is returned, fraction of walkable ray is returned in 'fraction'
+	 */
+	virtual bool IsPotentiallyTraversable( const Vector &from, const Vector &to, TraverseWhenType when = EVENTUALLY, float *fraction = NULL ) const;
+
+	/**
+	 * Return true if there is a possible "gap" that will need to be jumped over
+	 * If true is returned, fraction of ray before gap is returned in 'fraction'
+	 */
+	virtual bool HasPotentialGap( const Vector &from, const Vector &to, float *fraction = NULL ) const;
+
+	// return true if there is a "gap" here when moving in the given direction
+	virtual bool IsGap( const Vector &pos, const Vector &forward ) const;
+
+	virtual bool IsEntityTraversable( CBaseEntity *obstacle, TraverseWhenType when = EVENTUALLY ) const;
+
+	//
+	// Stuck state.  If the locomotor cannot make progress, it becomes "stuck" and can only leave 
+	// this stuck state by successfully moving and becoming un-stuck.
+	//
+	virtual bool IsStuck( void ) const;				// return true if bot is stuck 
+	virtual float GetStuckDuration( void ) const;	// return how long we've been stuck
+	virtual void ClearStuckStatus( const char *reason = "" );	// reset stuck status to un-stuck
+
+	virtual bool IsAttemptingToMove( void ) const;	// return true if we have tried to Approach() or DriveTo() very recently
+
+	void TraceHull( const Vector& start, const Vector& end, const Vector &mins, const Vector &maxs, unsigned int fMask, ITraceFilter *pFilter, trace_t *pTrace ) const;
+
+	/**
+	 * Should we collide with this entity?
+	 */
+	virtual bool ShouldCollideWith( const CBaseEntity *object ) const	{ return true; }
+
+
+protected:
+	virtual void AdjustPosture( const Vector &moveGoal );
+	virtual void StuckMonitor( void );
+
+private:
+	Vector m_motionVector;
+	Vector m_groundMotionVector;
+	float m_speed;
+	float m_groundSpeed;
+
+	// stuck monitoring
+	bool m_isStuck;									// if true, we are stuck
+	IntervalTimer m_stuckTimer;						// how long we've been stuck
+	CountdownTimer m_stillStuckTimer;				// for resending stuck events
+	Vector m_stuckPos;								// where we got stuck
+	IntervalTimer m_moveRequestTimer;
+};
+
+
+inline bool ILocomotion::IsAbleToJumpAcrossGaps( void ) const
+{
+	return true;
+}
+
+inline bool ILocomotion::IsAbleToClimb( void ) const
+{
+	return true;
+}
+
+inline bool ILocomotion::IsAttemptingToMove( void ) const
+{
+	return m_moveRequestTimer.HasStarted() && m_moveRequestTimer.GetElapsedTime() < 0.25f;
+}
+
+inline bool ILocomotion::IsScrambling( void ) const
+{
+	return !IsOnGround() || IsClimbingOrJumping() || IsAscendingOrDescendingLadder();
+}
+
+inline bool ILocomotion::IsClimbingOrJumping( void ) const
+{
+	return false;
+}
+
+inline bool ILocomotion::IsClimbingUpToLedge( void ) const
+{
+	return false;
+}
+
+inline bool ILocomotion::IsJumpingAcrossGap( void ) const
+{
+	return false;
+}
+
+inline bool ILocomotion::IsRunning( void ) const
+{
+	return false;
+}
+
+inline float ILocomotion::GetDesiredSpeed( void ) const
+{
+	return 0.0f;
+}
+
+inline bool ILocomotion::IsOnGround( void ) const
+{
+	return false;
+}
+
+inline CBaseEntity *ILocomotion::GetGround( void ) const
+{
+	return NULL;
+}
+
+inline const Vector &ILocomotion::GetGroundNormal( void ) const
+{
+	return vec3_origin;
+}
+
+inline float ILocomotion::GetGroundSpeed( void ) const
+{
+	return m_groundSpeed;
+}
+
+inline const Vector & ILocomotion::GetGroundMotionVector( void ) const
+{
+	return m_groundMotionVector;
+}
+
+inline bool ILocomotion::IsUsingLadder( void ) const
+{
+	return false;
+}
+
+inline bool ILocomotion::IsAscendingOrDescendingLadder( void ) const
+{
+	return false;
+}
+
+inline const QAngle &ILocomotion::GetDesiredLean( void ) const
+{
+	return vec3_angle;
+}
+
+inline float ILocomotion::GetStepHeight( void ) const
+{
+	return 0.0f;
+}
+
+inline float ILocomotion::GetMaxJumpHeight( void ) const
+{
+	return 0.0f;
+}
+
+inline float ILocomotion::GetDeathDropHeight( void ) const
+{
+	return 0.0f;
+}
+
+inline float ILocomotion::GetRunSpeed( void ) const
+{
+	return 0.0f;
+}
+
+inline float ILocomotion::GetWalkSpeed( void ) const
+{
+	return 0.0f;
+}
+
+inline float ILocomotion::GetMaxAcceleration( void ) const
+{
+	return 0.0f;
+}
+
+inline float ILocomotion::GetMaxDeceleration( void ) const
+{
+	return 0.0f;
+}
+
+inline const Vector &ILocomotion::GetVelocity( void ) const
+{
+	return vec3_origin;
+}
+
+inline float ILocomotion::GetSpeed( void ) const
+{
+	return m_speed;
+}
+
+inline const Vector & ILocomotion::GetMotionVector( void ) const
+{
+	return m_motionVector;
+}
+
+inline float ILocomotion::GetTraversableSlopeLimit( void ) const	
+{ 
+	return 0.6; 
+}
+
+inline bool ILocomotion::IsStuck( void ) const
+{
+	return m_isStuck;
+}
+
+inline float ILocomotion::GetStuckDuration( void ) const
+{
+	return ( IsStuck() ) ? m_stuckTimer.GetElapsedTime() : 0.0f;
+}
+
+inline void ILocomotion::TraceHull( const Vector& start, const Vector& end, const Vector &mins, const Vector &maxs, unsigned int fMask, ITraceFilter *pFilter, trace_t *pTrace ) const
+{
+//	VPROF_BUDGET( "ILocomotion::TraceHull", "TraceHull" );
+	Ray_t ray;
+	ray.Init( start, end, mins, maxs );
+	enginetrace->TraceRay( ray, fMask, pFilter, pTrace );
+}
+
+
+
+#endif // _NEXT_BOT_LOCOMOTION_INTERFACE_H_
+
diff --git a/game/server/NextBot/NextBotManager.cpp b/game/server/NextBot/NextBotManager.cpp
new file mode 100644
index 00000000..2ce9c6c8
--- /dev/null
+++ b/game/server/NextBot/NextBotManager.cpp
@@ -0,0 +1,892 @@
+// NextBotManager.cpp
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "NextBotManager.h"
+#include "NextBotInterface.h"
+
+#ifdef TERROR
+#include "ZombieBot/Infected/Infected.h"
+#include "ZombieBot/Witch/Witch.h"
+#include "ZombieManager.h"
+#endif
+
+#include "SharedFunctorUtils.h"
+//#include "../../common/blackbox_helper.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+extern ConVar ZombieMobMaxSize;
+
+ConVar nb_update_frequency( "nb_update_frequency", ".1", FCVAR_CHEAT );
+ConVar nb_update_framelimit( "nb_update_framelimit", ( IsDebug() ) ? "30" : "15", FCVAR_CHEAT );
+ConVar nb_update_maxslide( "nb_update_maxslide", "2", FCVAR_CHEAT );
+ConVar nb_update_debug( "nb_update_debug", "0", FCVAR_CHEAT );
+
+//---------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------
+/**
+ * Singleton accessor.
+ * By returning a reference, we guarantee construction of the 
+ * instance before its first use.
+ */
+NextBotManager &TheNextBots( void )
+{
+	if ( NextBotManager::GetInstance() )
+	{
+		return *NextBotManager::GetInstance();
+	}
+	else
+	{
+		static NextBotManager manager;
+		NextBotManager::SetInstance( &manager );
+		return manager;
+	}
+}
+
+NextBotManager* NextBotManager::sInstance = NULL;
+
+//---------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------
+static const char *debugTypeName[] =
+{
+	"BEHAVIOR",
+	"LOOK_AT",
+	"PATH",
+	"ANIMATION",
+	"LOCOMOTION",
+	"VISION",
+	"HEARING",
+	"EVENTS",
+	"ERRORS",
+	NULL
+};
+
+
+static void CC_SetDebug( const CCommand &args )
+{
+	if ( args.ArgC() < 2 )
+	{
+		Msg( "Debugging stopped\n" );
+		TheNextBots().SetDebugTypes( NEXTBOT_DEBUG_NONE );
+		return;
+	}
+
+	int debugType = 0;
+
+	for( int i=1; i<args.ArgC(); ++i )
+	{
+		int type;
+		for( type = 0; debugTypeName[ type ]; ++type )
+		{
+			const char *token = args[i];
+
+			// special token that means "all"
+			if ( token[0] == '*' )
+			{
+				debugType = NEXTBOT_DEBUG_ALL;
+				break;
+			}
+
+			if ( !Q_strnicmp( args[i], debugTypeName[ type ], Q_strlen( args[1] ) ) )
+			{
+				debugType |= ( 1 << type );
+				break;
+			}
+		}
+
+		if ( !debugTypeName[ type ] )
+		{
+			Msg( "Invalid debug type '%s'\n", args[i] );
+		}
+	}
+
+	// enable debugging
+	TheNextBots().SetDebugTypes( ( NextBotDebugType ) debugType );
+}
+static ConCommand SetDebug( "nb_debug", CC_SetDebug, "Debug NextBots.  Categories are: BEHAVIOR, LOOK_AT, PATH, ANIMATION, LOCOMOTION, VISION, HEARING, EVENTS, ERRORS.", FCVAR_CHEAT );
+
+//---------------------------------------------------------------------------------------------
+static void CC_SetDebugFilter( const CCommand &args )
+{
+	if ( args.ArgC() < 2 )
+	{
+		Msg( "Debug filter cleared.\n" );
+		TheNextBots().DebugFilterClear();
+		return;
+	}
+
+	for( int i=1; i<args.ArgC(); ++i )
+	{
+		int index = Q_atoi( args[i] );
+		if ( index > 0 )
+		{
+			TheNextBots().DebugFilterAdd( index );
+		}
+		else
+		{
+			TheNextBots().DebugFilterAdd( args[i] );
+		}
+	}
+}
+static ConCommand SetDebugFilter( "nb_debug_filter", CC_SetDebugFilter, "Add items to the NextBot debug filter. Items can be entindexes or part of the indentifier of one or more bots.", FCVAR_CHEAT );
+
+
+//---------------------------------------------------------------------------------------------
+class Selector
+{
+public:
+	Selector( CBasePlayer *player, bool useLOS )
+	{
+		m_player = player;
+		player->EyeVectors( &m_forward );
+
+		m_pick = NULL;
+		m_pickRange = 99999999999999.9f;
+		m_useLOS = useLOS;
+	}
+
+	bool operator() ( INextBot *bot )
+	{
+		CBaseCombatCharacter *botEntity = bot->GetEntity();
+		if ( botEntity->IsAlive() )
+		{
+			Vector to = botEntity->WorldSpaceCenter() - m_player->EyePosition();
+			float range = to.NormalizeInPlace();
+
+			if ( DotProduct( m_forward, to ) > 0.98f && range < m_pickRange )
+			{
+				if ( !m_useLOS || m_player->IsAbleToSee( botEntity, CBaseCombatCharacter::DISREGARD_FOV ) )
+				{
+					m_pick = bot;
+					m_pickRange = range;
+				}
+			}
+		}
+		return true;
+	}
+
+	CBasePlayer *m_player;
+	Vector m_forward;
+	INextBot *m_pick;
+	float m_pickRange;
+	bool m_useLOS;
+};
+
+static void CC_SelectBot( const CCommand &args )
+{
+	CBasePlayer *player = UTIL_GetListenServerHost();
+	if ( player )
+	{
+		Selector select( player, false );
+		TheNextBots().ForEachBot( select );
+
+		TheNextBots().Select( select.m_pick );				
+
+		if ( select.m_pick )
+		{
+			NDebugOverlay::Circle( select.m_pick->GetLocomotionInterface()->GetFeet() + Vector( 0, 0, 5 ), Vector( 1, 0, 0 ), Vector( 0, -1, 0 ), 25.0f, 0, 255, 0, 255, false, 1.0f );
+		}
+	}	
+}
+static ConCommand SelectBot( "nb_select", CC_SelectBot, "Select the bot you are aiming at for further debug operations.", FCVAR_CHEAT );
+
+
+//---------------------------------------------------------------------------------------------
+static void CC_ForceLookAt( const CCommand &args )
+{
+	CBasePlayer *player = UTIL_GetListenServerHost();
+	INextBot *pick = TheNextBots().GetSelected();
+
+	if ( player && pick )
+	{
+		pick->GetBodyInterface()->AimHeadTowards( player, IBody::CRITICAL, 9999999.9f, NULL, "Aim forced" );
+	}
+}
+static ConCommand ForceLookAt( "nb_force_look_at", CC_ForceLookAt, "Force selected bot to look at the local player's position", FCVAR_CHEAT );
+
+
+//--------------------------------------------------------------------------------------------------------
+void CC_WarpSelectedHere( const CCommand &args )
+{
+	CBasePlayer *me = dynamic_cast< CBasePlayer * >( UTIL_GetCommandClient() ); 
+	INextBot *pick = TheNextBots().GetSelected();
+
+	if ( me == NULL || pick == NULL )
+	{
+		return;
+	}
+
+	Vector forward;
+	me->EyeVectors( &forward );
+
+	trace_t result;
+	UTIL_TraceLine( me->EyePosition(), me->EyePosition() + 999999.9f * forward, MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, me, COLLISION_GROUP_NONE, &result );
+	if ( result.DidHit() )
+	{
+		Vector spot = result.endpos + Vector( 0, 0, 10.0f );
+		pick->GetEntity()->Teleport( &spot, &vec3_angle, &vec3_origin );
+	}
+}
+static ConCommand WarpSelectedHere( "nb_warp_selected_here", CC_WarpSelectedHere, "Teleport the selected bot to your cursor position", FCVAR_CHEAT );
+
+
+//---------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------
+NextBotManager::NextBotManager( void )
+{
+	m_debugType = 0;
+	m_selectedBot = NULL;
+	
+	m_iUpdateTickrate = 0;
+}
+
+//---------------------------------------------------------------------------------------------
+NextBotManager::~NextBotManager()
+{
+}
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Reset to initial state
+ */
+void NextBotManager::Reset( void )
+{
+	// remove the NextBots that should go away during a reset (they will unregister themselves as they go)
+	int i = m_botList.Head();
+	while ( i != m_botList.InvalidIndex() )
+	{
+		int iNext = m_botList.Next( i );
+		if ( m_botList[i]->IsRemovedOnReset() )
+		{
+			UTIL_Remove( m_botList[i]->GetEntity() );
+			//Assert( !m_botList.IsInList( i ) );	// UTIL_Remove() calls UpdateOnRemove, adds EFL_KILLME, but doesn't delete until the end of the frame
+		}
+		i = iNext;
+	}
+
+	m_selectedBot = NULL;
+}
+
+
+//---------------------------------------------------------------------------------------------
+
+inline bool IsDead( INextBot *pBot )
+{
+	CBaseCombatCharacter *pEntity = pBot->GetEntity();
+	if ( pEntity )
+	{
+		if ( pEntity->IsPlayer() && pEntity->m_lifeState == LIFE_DEAD )
+		{
+			return true;
+		}
+			
+		if ( pEntity->IsMarkedForDeletion() )
+		{
+			return true;
+		}
+
+		if ( pEntity->m_pfnThink == &CBaseEntity::SUB_Remove )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+//---------------------------------------------------------------------------------------------
+
+// Debug stats for update balancing
+static int g_nRun;
+static int g_nSlid;
+static int g_nBlockedSlides;
+
+void NextBotManager::Update( void )
+{
+	// do lightweight upkeep every tick
+	for( int u=m_botList.Head(); u != m_botList.InvalidIndex(); u = m_botList.Next( u ) )
+	{
+		m_botList[ u ]->Upkeep();
+	}
+
+	// schedule full updates
+	if ( m_botList.Count() )
+	{
+		static int iCurFrame = -1;
+		if ( iCurFrame != gpGlobals->framecount )
+		{
+			iCurFrame = gpGlobals->framecount;
+			m_SumFrameTime = 0;
+		}
+		else
+		{
+			// Don't run multiple ticks in a frame
+			return;
+		}
+
+		int tickRate = TIME_TO_TICKS( nb_update_frequency.GetFloat() );
+		if ( tickRate < 0 )
+		{
+			tickRate = 0;
+		}
+
+		if ( m_iUpdateTickrate != tickRate )
+		{
+			Msg( "NextBot tickrate changed from %d (%.3fms) to %d (%.3fms)\n", m_iUpdateTickrate, TICKS_TO_TIME( m_iUpdateTickrate ), tickRate, TICKS_TO_TIME( tickRate ) );
+			m_iUpdateTickrate = tickRate;
+		}
+
+		int i = 0;
+		int nScheduled = 0;
+		int nNonResponsive = 0;
+		int nDead = 0;
+		if ( m_iUpdateTickrate > 0 )
+		{
+			INextBot *pBot;
+
+			// Count dead bots, they won't update and balancing calculations should exclude them
+			for( i = m_botList.Head(); i != m_botList.InvalidIndex(); i = m_botList.Next( i ) )
+			{
+				if ( IsDead( m_botList[i] ) )
+				{
+					nDead++;
+				}
+			}
+
+
+			int nTargetToRun = ceilf( (float)( m_botList.Count() - nDead ) / (float)m_iUpdateTickrate );
+			int curtickcount = gpGlobals->tickcount;
+
+			for( i = m_botList.Head(); nTargetToRun && i != m_botList.InvalidIndex(); i = m_botList.Next( i ) )
+			{
+				pBot = m_botList[i];
+				if ( pBot->IsFlaggedForUpdate() )
+				{
+					// Was offered a run last tick but didn't take it, push it back
+					// Leave the flag set so that bot will run right away later, but be ignored
+					// until then
+					nNonResponsive++;
+				}
+				else
+				{
+					if ( curtickcount - pBot->GetTickLastUpdate() < m_iUpdateTickrate )
+					{
+						break;
+					}
+					if ( !IsDead( pBot ) )
+					{
+						pBot->FlagForUpdate();
+						nTargetToRun--;
+						nScheduled++;
+					}
+				}
+			}
+		}
+		else
+		{
+			nScheduled = m_botList.Count();
+		}
+
+		if ( nb_update_debug.GetBool() )
+		{
+			int nIntentionalSliders = 0;
+			if ( m_iUpdateTickrate > 0 )
+			{
+				for( ; i != m_botList.InvalidIndex(); i = m_botList.Next( i ) )
+				{
+					if ( gpGlobals->tickcount - m_botList[i]->GetTickLastUpdate() >= m_iUpdateTickrate )
+					{
+						nIntentionalSliders++;
+					}
+				}
+			}
+
+			Msg( "Frame %8d/tick %8d: %3d run of %3d, %3d sliders, %3d blocked slides, scheduled %3d for next tick, %3d intentional sliders, %d nonresponsive, %d dead\n", gpGlobals->framecount - 1, gpGlobals->tickcount - 1, g_nRun, m_botList.Count() - nDead, g_nSlid, g_nBlockedSlides, nScheduled, nIntentionalSliders, nNonResponsive, nDead );
+			g_nRun = g_nSlid = g_nBlockedSlides = 0;
+		}
+
+	}
+}
+
+//---------------------------------------------------------------------------------------------
+bool NextBotManager::ShouldUpdate( INextBot *bot )
+{
+	if ( m_iUpdateTickrate < 1 )
+	{
+		return true;
+	}
+
+	float frameLimit = nb_update_framelimit.GetFloat();
+	float sumFrameTime = 0;
+	if ( bot->IsFlaggedForUpdate() )
+	{
+		bot->FlagForUpdate( false );
+		sumFrameTime = m_SumFrameTime * 1000.0;
+		if ( frameLimit > 0.0f )
+		{
+			if ( sumFrameTime < frameLimit )
+			{
+				return true;
+			}
+			else if ( nb_update_debug.GetBool() )
+			{
+				Msg( "Frame %8d/tick %8d: frame out of budget (%.2fms > %.2fms)\n", gpGlobals->framecount, gpGlobals->tickcount, sumFrameTime, frameLimit );
+			}
+		}
+	}
+
+	int nTicksSlid = ( gpGlobals->tickcount - bot->GetTickLastUpdate() ) - m_iUpdateTickrate;
+
+	if ( nTicksSlid >= nb_update_maxslide.GetInt() )
+	{
+		if ( frameLimit == 0.0 || sumFrameTime < nb_update_framelimit.GetFloat() * 2.0 )
+		{
+			g_nBlockedSlides++;
+			return true;
+		}
+	}
+
+	if ( nb_update_debug.GetBool() )
+	{
+		if ( nTicksSlid > 0 )
+		{
+			g_nSlid++;
+		}
+	}
+
+	return false;
+}
+
+//---------------------------------------------------------------------------------------------
+void NextBotManager::NotifyBeginUpdate( INextBot *bot )
+{
+	if ( nb_update_debug.GetBool() )
+	{
+		g_nRun++;
+	}
+
+	m_botList.Unlink( bot->GetBotId() );
+	m_botList.LinkToTail( bot->GetBotId() );
+	bot->SetTickLastUpdate( gpGlobals->tickcount );
+
+	m_CurUpdateStartTime = Plat_FloatTime();
+}
+
+//---------------------------------------------------------------------------------------------
+void NextBotManager::NotifyEndUpdate( INextBot *bot )
+{
+	// This might be a good place to detect a particular bot had spiked [3/14/2008 tom]
+	m_SumFrameTime += Plat_FloatTime() - m_CurUpdateStartTime;
+}
+
+//---------------------------------------------------------------------------------------------
+/**
+ * When the server has changed maps
+ */
+void NextBotManager::OnMapLoaded( void )
+{
+	Reset();
+}
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * When the scenario restarts
+ */
+void NextBotManager::OnRoundRestart( void )
+{
+	Reset();
+}
+
+
+//---------------------------------------------------------------------------------------------
+int NextBotManager::Register( INextBot *bot )
+{
+	return m_botList.AddToHead( bot );
+}
+
+
+//---------------------------------------------------------------------------------------------
+void NextBotManager::UnRegister( INextBot *bot )
+{
+	m_botList.Remove( bot->GetBotId() );
+
+	if ( bot == m_selectedBot)
+	{
+		// we can't access virtual methods because this is called from a destructor, so just clear it
+		m_selectedBot = NULL;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void NextBotManager::OnBeginChangeLevel( void )
+{
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+class NextBotKilledNotifyScan
+{
+public:
+	NextBotKilledNotifyScan( CBaseCombatCharacter *victim, const CTakeDamageInfo &info )
+	{
+		m_victim = victim;
+		m_info = info;
+	}
+
+	bool operator() ( INextBot *bot )
+	{
+		if ( bot->GetEntity()->IsAlive() && !bot->IsSelf( m_victim ) )
+		{
+			bot->OnOtherKilled( m_victim, m_info );
+		}
+		return true;
+	}
+
+	CBaseCombatCharacter *m_victim;
+	CTakeDamageInfo m_info;
+};
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * When an actor is killed.  Propagate to all NextBots.
+ */
+void NextBotManager::OnKilled( CBaseCombatCharacter *victim, const CTakeDamageInfo &info )
+{
+	NextBotKilledNotifyScan notify( victim, info );
+	TheNextBots().ForEachBot( notify );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+class NextBotSoundNotifyScan
+{
+public:
+	NextBotSoundNotifyScan( CBaseEntity *source, const Vector &pos, KeyValues *keys ) : m_source( source ), m_pos( pos ), m_keys( keys )
+	{
+	}
+
+	bool operator() ( INextBot *bot )
+	{
+		if ( bot->GetEntity()->IsAlive() && !bot->IsSelf( m_source ) )
+		{
+			bot->OnSound( m_source, m_pos, m_keys );
+		}
+		return true;
+	}
+
+	CBaseEntity *m_source;
+	const Vector &m_pos;
+	KeyValues *m_keys;
+};
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * When an entity emits a sound
+ */
+void NextBotManager::OnSound( CBaseEntity *source, const Vector &pos, KeyValues *keys )
+{
+	NextBotSoundNotifyScan notify( source, pos, keys );
+	TheNextBots().ForEachBot( notify );
+
+	if ( source && IsDebugging( NEXTBOT_HEARING ) )
+	{
+		int r,g,b;
+		switch( source->GetTeamNumber() )
+		{
+			case FIRST_GAME_TEAM:		r = 0;   g = 255; b = 0; break;
+			case (FIRST_GAME_TEAM+1):	r = 255; g = 0;   b = 0; break;
+			default:					r = 255; g = 255; b = 0; break;
+		}
+		NDebugOverlay::Circle( pos, Vector( 1, 0, 0 ), Vector( 0, -1, 0 ), 5.0f, r, g, b, 255, true, 3.0f );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+class NextBotResponseNotifyScan
+{
+public:
+	NextBotResponseNotifyScan( CBaseCombatCharacter *who, AIConcept_t concept, AI_Response *response ) : m_who( who ), m_concept( concept ), m_response( response )
+	{
+	}
+
+	bool operator() ( INextBot *bot )
+	{
+		if ( bot->GetEntity()->IsAlive() )
+		{
+			bot->OnSpokeConcept( m_who, m_concept, m_response );
+		}
+		return true;
+	}
+
+	CBaseCombatCharacter *m_who;
+	AIConcept_t m_concept;
+	AI_Response *m_response;
+};
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * When an Actor speaks a concept
+ */
+void NextBotManager::OnSpokeConcept( CBaseCombatCharacter *who, AIConcept_t concept, AI_Response *response )
+{
+	NextBotResponseNotifyScan notify( who, concept, response );
+	TheNextBots().ForEachBot( notify );
+
+	if ( IsDebugging( NEXTBOT_HEARING ) )
+	{
+		// const char *who = response->GetCriteria()->GetValue( response->GetCriteria()->FindCriterionIndex( "Who" ) );
+
+		// TODO: Need concept.GetStringConcept()
+		DevMsg( "%3.2f: OnSpokeConcept( %s, %s )\n", gpGlobals->curtime, who->GetDebugName(), "concept.GetStringConcept()" );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+class NextBotWeaponFiredNotifyScan
+{
+public:
+	NextBotWeaponFiredNotifyScan( CBaseCombatCharacter *who, CBaseCombatWeapon *weapon ) : m_who( who ), m_weapon( weapon )
+	{
+	}
+
+	bool operator() ( INextBot *bot )
+	{
+		if ( bot->GetEntity()->IsAlive() )
+		{
+			bot->OnWeaponFired( m_who, m_weapon );
+		}
+		return true;
+	}
+
+	CBaseCombatCharacter *m_who;
+	CBaseCombatWeapon *m_weapon;
+};
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * When someone fires a weapon
+ */
+void NextBotManager::OnWeaponFired( CBaseCombatCharacter *whoFired, CBaseCombatWeapon *weapon )
+{
+	NextBotWeaponFiredNotifyScan notify( whoFired, weapon );
+	TheNextBots().ForEachBot( notify );
+
+	if ( IsDebugging( NEXTBOT_EVENTS ) )
+	{
+		DevMsg( "%3.2f: OnWeaponFired( %s, %s )\n", gpGlobals->curtime, whoFired->GetDebugName(), weapon->GetName() );
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Add given entindex to the debug filter
+ */
+void NextBotManager::DebugFilterAdd( int index )
+{
+	DebugFilter filter;
+
+	filter.index = index;
+	filter.name[0] = '\000';
+
+	m_debugFilterList.AddToTail( filter );
+}
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Add given name to the debug filter
+ */
+void NextBotManager::DebugFilterAdd( const char *name )
+{
+	DebugFilter filter;
+
+	filter.index = -1;
+	Q_strncpy( filter.name, name, DebugFilter::MAX_DEBUG_NAME_SIZE );
+
+	m_debugFilterList.AddToTail( filter );
+}
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Remove given entindex from the debug filter
+ */
+void NextBotManager::DebugFilterRemove( int index )
+{
+	for( int i=0; i<m_debugFilterList.Count(); ++i )
+	{
+		if ( m_debugFilterList[i].index == index )
+		{
+			m_debugFilterList.Remove( i );
+			break;
+		}
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Remove given name from the debug filter
+ */
+void NextBotManager::DebugFilterRemove( const char *name )
+{
+	for( int i=0; i<m_debugFilterList.Count(); ++i )
+	{
+		if ( m_debugFilterList[i].name[0] != '\000' &&
+			 !Q_strnicmp( name, m_debugFilterList[i].name, MIN( Q_strlen( name ), sizeof( m_debugFilterList[i].name ) ) ) )
+		{
+			m_debugFilterList.Remove( i );
+			break;
+		}
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Clear the debug filter (remove all entries)
+ */
+void NextBotManager::DebugFilterClear( void )
+{
+	m_debugFilterList.RemoveAll();
+}
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Return true if the given bot matches the debug filter
+ */
+bool NextBotManager::IsDebugFilterMatch( const INextBot *bot ) const
+{
+	// if the filter is empty, all bots match
+	if ( m_debugFilterList.Count() == 0 )
+	{
+		return true;
+	}
+
+	for( int i=0; i<m_debugFilterList.Count(); ++i )
+	{
+		// compare entity index
+		if ( m_debugFilterList[i].index == const_cast< INextBot * >( bot )->GetEntity()->entindex() )
+		{
+			return true;
+		}
+
+		// compare debug filter
+		if ( m_debugFilterList[i].name[0] != '\000' && bot->IsDebugFilterMatch( m_debugFilterList[i].name ) )
+		{
+			return true;
+		}
+
+		// compare special keyword meaning local player is looking at them
+		if ( !Q_strnicmp( m_debugFilterList[i].name, "lookat", Q_strlen( m_debugFilterList[i].name ) ) )
+		{
+			CBasePlayer *watcher = UTIL_GetListenServerHost();
+			if ( watcher )
+			{
+				CBaseEntity *subject = watcher->GetObserverTarget();
+
+				if ( subject && bot->IsSelf( subject ) )
+				{
+					return true;
+				}
+			}
+		}
+
+		// compare special keyword meaning NextBot is selected
+		if ( !Q_strnicmp( m_debugFilterList[i].name, "selected", Q_strlen( m_debugFilterList[i].name ) ) )
+		{
+			INextBot *selected = GetSelected();
+			if ( selected && bot->IsSelf( selected->GetEntity() ) )
+			{
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Get the bot under the given player's crosshair
+ */
+INextBot *NextBotManager::GetBotUnderCrosshair( CBasePlayer *picker )
+{
+	if ( !picker )
+		return NULL;
+
+	const float MaxDot = 0.7f;
+	const float MaxRange = 4000.0f;
+	TargetScan< CBaseCombatCharacter > scan( picker, TEAM_ANY, 1.0f - MaxDot, MaxRange );
+	ForEachCombatCharacter( scan );
+	CBaseCombatCharacter *target = scan.GetTarget();
+	if ( target && target->MyNextBotPointer() )
+		return target->MyNextBotPointer();
+
+	return NULL;
+}
+
+#ifdef NEED_BLACK_BOX
+//---------------------------------------------------------------------------------------------
+CON_COMMAND( nb_dump_debug_history, "Dumps debug history for the bot under the cursor to the blackbox" )
+{
+	if ( !NextBotDebugHistory.GetBool() )
+	{
+		BlackBox_Record( "bot", "nb_debug_history 0" );
+		return;
+	}
+
+	CBasePlayer *player = UTIL_GetCommandClient();
+	if ( !player )
+	{
+		player = UTIL_GetListenServerHost();
+	}
+	INextBot *bot = TheNextBots().GetBotUnderCrosshair( player );
+	if ( !bot )
+	{
+		BlackBox_Record( "bot", "no bot under crosshairs" );
+		return;
+	}
+
+	CUtlVector< const INextBot::NextBotDebugLineType * > lines;
+	bot->GetDebugHistory( (NEXTBOT_DEBUG_ALL & (~NEXTBOT_EVENTS)), &lines );
+
+	for ( int i=0; i<lines.Count(); ++i )
+	{
+		if ( IsPC() )
+		{
+			BlackBox_Record( "bot", "%s", lines[i]->data );
+		}
+	}
+}
+#endif // NEED_BLACK_BOX
+
+
+//---------------------------------------------------------------------------------------------
+void NextBotManager::CollectAllBots( CUtlVector< INextBot * > *botVector )
+{
+	if ( !botVector )
+		return;
+
+	botVector->RemoveAll();
+
+	for( int i=m_botList.Head(); i != m_botList.InvalidIndex(); i = m_botList.Next( i ) )
+	{
+		botVector->AddToTail( m_botList[i] );
+	}
+}
+
diff --git a/game/server/NextBot/NextBotManager.h b/game/server/NextBot/NextBotManager.h
new file mode 100644
index 00000000..197b2ad7
--- /dev/null
+++ b/game/server/NextBot/NextBotManager.h
@@ -0,0 +1,211 @@
+// NextBotManager.h
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_MANAGER_H_
+#define _NEXT_BOT_MANAGER_H_
+
+#include "NextBotInterface.h"
+
+class CTerrorPlayer;
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The NextBotManager manager 
+ */
+class NextBotManager
+{
+public:
+	NextBotManager( void );
+	virtual ~NextBotManager();
+
+	void Reset( void );								// reset to initial state
+	virtual void Update( void );
+
+	bool ShouldUpdate( INextBot *bot );
+	void NotifyBeginUpdate( INextBot *bot );
+	void NotifyEndUpdate( INextBot *bot );
+
+	int GetNextBotCount( void ) const;				// How many nextbots are alive right now?
+
+
+	/**
+	 * Populate given vector with all bots in the system
+	 */
+	void CollectAllBots( CUtlVector< INextBot * > *botVector );
+
+
+	/**
+	 * DEPRECATED: Use CollectAllBots().
+	 * Execute functor for each NextBot in the system.
+	 * If a functor returns false, stop iteration early
+	 * and return false.
+	 */	
+	template < typename Functor >
+	bool ForEachBot( Functor &func )
+	{
+		for( int i=m_botList.Head(); i != m_botList.InvalidIndex(); i = m_botList.Next( i ) )
+		{
+			if ( !func( m_botList[i] ) )
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * DEPRECATED: Use CollectAllBots().
+	 * Execute functor for each NextBot in the system as 
+	 * a CBaseCombatCharacter.
+	 * If a functor returns false, stop iteration early
+	 * and return false.
+	 */	
+	template < typename Functor >
+	bool ForEachCombatCharacter( Functor &func )
+	{
+		for( int i=m_botList.Head(); i != m_botList.InvalidIndex(); i = m_botList.Next( i ) )
+		{
+			if ( !func( m_botList[i]->GetEntity() ) )
+			{
+
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Return closest bot to given point that passes the given filter
+	 */	
+	template < typename Filter >
+	INextBot *GetClosestBot( const Vector &pos, Filter &filter )
+	{
+		INextBot *close = NULL;
+		float closeRangeSq = FLT_MAX;
+
+		for( int i=m_botList.Head(); i != m_botList.InvalidIndex(); i = m_botList.Next( i ) )
+		{
+			float rangeSq = ( m_botList[i]->GetEntity()->GetAbsOrigin() - pos ).LengthSqr();
+			if ( rangeSq < closeRangeSq && filter( m_botList[i] ) )
+			{
+				closeRangeSq = rangeSq;
+				close = m_botList[i];
+			}
+		}
+
+		return close;
+	}
+
+	/**
+	 * Event propagators
+	 */
+	virtual void OnMapLoaded( void );						// when the server has changed maps
+	virtual void OnRoundRestart( void );					// when the scenario restarts
+	virtual void OnBeginChangeLevel( void );				// when the server is about to change maps
+	virtual void OnKilled( CBaseCombatCharacter *victim, const CTakeDamageInfo &info );	// when an actor is killed
+	virtual void OnSound( CBaseEntity *source, const Vector &pos, KeyValues *keys );				// when an entity emits a sound
+	virtual void OnSpokeConcept( CBaseCombatCharacter *who, AIConcept_t concept, AI_Response *response );	// when an Actor speaks a concept
+	virtual void OnWeaponFired( CBaseCombatCharacter *whoFired, CBaseCombatWeapon *weapon );		// when someone fires a weapon
+
+	/**
+	 * Debugging
+	 */
+	bool IsDebugging( unsigned int type ) const;	// return true if debugging system is on for the given type(s)
+	void SetDebugTypes( NextBotDebugType type );	// start displaying debug info of the given type(s)
+
+	void DebugFilterAdd( int index );				// add given entindex to the debug filter
+	void DebugFilterAdd( const char *name );		// add given name to the debug filter
+	void DebugFilterRemove( int index );			// remove given entindex from the debug filter
+	void DebugFilterRemove( const char *name );		// remove given name from the debug filter
+	void DebugFilterClear( void );					// clear the debug filter (remove all entries)
+	bool IsDebugFilterMatch( const INextBot *bot ) const;	// return true if the given bot matches the debug filter
+
+	void Select( INextBot *bot );					// mark bot as selected for further operations
+	void DeselectAll( void );
+	INextBot *GetSelected( void ) const;
+
+	INextBot *GetBotUnderCrosshair( CBasePlayer *picker );	// Get the bot under the given player's crosshair
+
+	//
+	// Put these in a derived class
+	//
+	void OnSurvivorVomitedUpon( CTerrorPlayer *victim );	// when a Survivor has been hit by Boomer Vomit
+
+	static void SetInstance( NextBotManager *pInstance ) { sInstance = pInstance; };
+	static NextBotManager* GetInstance() { return sInstance; }
+
+protected:
+	static NextBotManager* sInstance;
+
+	friend class INextBot;
+
+	int Register( INextBot *bot );
+	void UnRegister( INextBot *bot );
+
+	CUtlLinkedList< INextBot * > m_botList;				// list of all active NextBots
+
+	int m_iUpdateTickrate;
+	double m_CurUpdateStartTime;
+	double m_SumFrameTime;
+
+	unsigned int m_debugType;						// debug flags
+
+	struct DebugFilter
+	{
+		int index;			// entindex
+		enum { MAX_DEBUG_NAME_SIZE = 128 };
+		char name[ MAX_DEBUG_NAME_SIZE ];
+	};
+	CUtlVector< DebugFilter > m_debugFilterList;
+
+	INextBot *m_selectedBot;						// selected bot for further debug operations
+};
+
+inline int NextBotManager::GetNextBotCount( void ) const
+{
+	return m_botList.Count();
+}
+
+inline bool NextBotManager::IsDebugging( unsigned int type ) const
+{
+	if ( type & m_debugType )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+inline void NextBotManager::SetDebugTypes( NextBotDebugType type )
+{
+	m_debugType = (unsigned int)type;
+}
+
+
+inline void NextBotManager::Select( INextBot *bot )
+{
+	m_selectedBot = bot;
+}
+
+inline void NextBotManager::DeselectAll( void )
+{
+	m_selectedBot = NULL;
+}
+
+inline INextBot *NextBotManager::GetSelected( void ) const
+{
+	return m_selectedBot;
+}
+
+
+
+// singleton accessor
+extern NextBotManager &TheNextBots( void );
+
+
+#endif // _NEXT_BOT_MANAGER_H_
+
diff --git a/game/server/NextBot/NextBotUtil.h b/game/server/NextBot/NextBotUtil.h
new file mode 100644
index 00000000..75a4221a
--- /dev/null
+++ b/game/server/NextBot/NextBotUtil.h
@@ -0,0 +1,278 @@
+// NextBotUtil.h
+// Utilities for the NextBot system
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_UTIL_H_
+#define _NEXT_BOT_UTIL_H_
+
+#include "NextBotLocomotionInterface.h"
+#include "nav_area.h"
+#include "nav_mesh.h"
+#include "nav_pathfind.h"
+
+//--------------------------------------------------------------------------------------------
+/**
+ * A simple filter interface for various NextBot queries
+ */
+class INextBotEntityFilter
+{
+public:
+	// return true if the given entity passes this filter
+	virtual bool IsAllowed( CBaseEntity *entity ) const = 0;
+};
+
+
+// trace filter callback functions. needed for use with the querycache/optimization functionality
+bool VisionTraceFilterFunction( IHandleEntity *pServerEntity, int contentsMask );
+bool IgnoreActorsTraceFilterFunction( IHandleEntity *pServerEntity, int contentsMask );
+
+
+//--------------------------------------------------------------------------------------------
+/**
+ * Trace filter that skips all players and NextBots
+ */
+class NextBotTraceFilterIgnoreActors : public CTraceFilterSimple
+{
+public:
+	NextBotTraceFilterIgnoreActors( const IHandleEntity *passentity, int collisionGroup ) : CTraceFilterSimple( passentity, collisionGroup, IgnoreActorsTraceFilterFunction )
+	{
+	}
+};
+
+
+//--------------------------------------------------------------------------------------------
+/**
+ * Trace filter that skips all players, NextBots, and non-LOS blockers
+ */
+class NextBotVisionTraceFilter : public CTraceFilterSimple
+{
+public:
+	NextBotVisionTraceFilter( const IHandleEntity *passentity, int collisionGroup )	: CTraceFilterSimple( passentity, collisionGroup, VisionTraceFilterFunction )
+	{
+	}
+};
+
+
+//--------------------------------------------------------------------------------------------
+/**
+ * Trace filter that skips all NextBots, but includes Players
+ */
+class NextBotTraceFilterIgnoreNextBots : public CTraceFilterSimple
+{
+public:
+	NextBotTraceFilterIgnoreNextBots( const IHandleEntity *passentity, int collisionGroup )
+		: CTraceFilterSimple( passentity, collisionGroup )
+	{
+	}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		if ( CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask ) )
+		{
+			CBaseEntity *entity = EntityFromEntityHandle( pServerEntity );
+#ifdef TERROR
+			CBasePlayer *player = ToBasePlayer( entity );
+			if ( player && player->IsGhost() )
+				return false;
+#endif // TERROR
+
+			return ( entity->MyNextBotPointer() == NULL );
+		}
+		return false;
+	}
+};
+
+
+//--------------------------------------------------------------------------------------------
+/**
+ * Trace filter that obeys INextBot::IsAbleToBlockMovementOf()
+ */
+class NextBotTraceFilter : public CTraceFilterSimple
+{
+public:
+	NextBotTraceFilter( const IHandleEntity *passentity, int collisionGroup )
+		: CTraceFilterSimple( passentity, collisionGroup )
+	{
+		CBaseEntity *entity = const_cast<CBaseEntity *>(EntityFromEntityHandle( passentity ));
+		m_passBot = entity->MyNextBotPointer();
+	}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		if ( CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask ) )
+		{
+			CBaseEntity *entity = EntityFromEntityHandle( pServerEntity );
+#ifdef TERROR
+			CBasePlayer *player = ToBasePlayer( entity );
+			if ( player && player->IsGhost() )
+				return false;
+#endif // TERROR
+
+			// Skip players on the same team - they're not solid to us, and we'll avoid them
+			if ( entity->IsPlayer() && m_passBot && m_passBot->GetEntity() &&
+				m_passBot->GetEntity()->GetTeamNumber() == entity->GetTeamNumber() )
+				return false;
+
+			INextBot *bot = entity->MyNextBotPointer();
+			
+			return ( !bot || bot->IsAbleToBlockMovementOf( m_passBot ) );
+		}
+		return false;
+	}
+	
+	const INextBot *m_passBot;
+};
+
+
+//--------------------------------------------------------------------------------------------
+/**
+ * Trace filter that only hits players and NextBots
+ */
+class NextBotTraceFilterOnlyActors : public CTraceFilterSimple
+{
+public:
+	NextBotTraceFilterOnlyActors( const IHandleEntity *passentity, int collisionGroup )
+		: CTraceFilterSimple( passentity, collisionGroup )
+	{
+	}
+
+	virtual TraceType_t	GetTraceType() const
+	{
+		return TRACE_ENTITIES_ONLY;
+	}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		if ( CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask ) )
+		{
+			CBaseEntity *entity = EntityFromEntityHandle( pServerEntity );
+
+#ifdef TERROR
+			CBasePlayer *player = ToBasePlayer( entity );
+			if ( player && player->IsGhost() )
+				return false;
+#endif // TERROR
+
+			return ( entity->MyNextBotPointer() || entity->IsPlayer() );
+		}
+		return false;
+	}
+};
+
+
+//--------------------------------------------------------------------------------------------
+/**
+ * Trace filter that skips "traversable" entities.  The "when" argument creates
+ * a temporal context for asking if an entity is IMMEDIATELY traversable (like thin
+ * glass that just breaks as we walk through it) or EVENTUALLY traversable (like a
+ * breakable object that will take some time to break through)
+ */
+class NextBotTraversableTraceFilter : public CTraceFilterSimple
+{
+public:
+	NextBotTraversableTraceFilter( INextBot *bot, ILocomotion::TraverseWhenType when = ILocomotion::EVENTUALLY ) : CTraceFilterSimple( bot->GetEntity(), COLLISION_GROUP_NONE )
+	{
+		m_bot = bot;
+		m_when = when;
+	}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		CBaseEntity *entity = EntityFromEntityHandle( pServerEntity );
+
+		if ( m_bot->IsSelf( entity ) )
+		{
+			return false;
+		}
+
+		if ( CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask ) )
+		{
+			return !m_bot->GetLocomotionInterface()->IsEntityTraversable( entity, m_when );
+		}
+
+		return false;
+	}
+
+private:
+	INextBot *m_bot;
+	ILocomotion::TraverseWhenType m_when;
+};
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Given a vector of entities, a nav area, and a max travel distance, return 
+ * the entity that has the shortest travel distance.
+ */
+inline CBaseEntity *SelectClosestEntityByTravelDistance( INextBot *me, const CUtlVector< CBaseEntity * > &candidateEntities, CNavArea *startArea, float travelRange )
+{
+	// collect nearby walkable areas within travelRange
+	CUtlVector< CNavArea * > nearbyAreaVector;
+	CollectSurroundingAreas( &nearbyAreaVector, startArea, travelRange, me->GetLocomotionInterface()->GetStepHeight(), me->GetLocomotionInterface()->GetDeathDropHeight() );
+
+	// find closest entity in the collected area set
+	CBaseEntity *closeEntity = NULL;
+	float closeTravelRange = FLT_MAX;
+
+	for( int i=0; i<candidateEntities.Count(); ++i )
+	{
+		CBaseEntity *candidate = candidateEntities[i];
+
+		CNavArea *area = TheNavMesh->GetNearestNavArea( candidate, GETNAVAREA_CHECK_LOS, 500.0f );
+
+		if ( area && area->IsMarked() && area->GetCostSoFar() < closeTravelRange )
+		{
+			closeEntity = candidate;
+			closeTravelRange = area->GetCostSoFar();
+		}
+	}
+
+	return closeEntity;
+}
+
+
+#ifdef OBSOLETE
+//--------------------------------------------------------------------------------------------
+/**
+ * Trace filter that skips "traversable" entities, but hits other Actors.
+ * Used for obstacle avoidance.
+ */
+class NextBotMovementAvoidanceTraceFilter : public CTraceFilterSimple
+{
+public:
+	NextBotMovementAvoidanceTraceFilter( INextBot *bot ) : CTraceFilterSimple( bot->GetEntity(), COLLISION_GROUP_NONE )
+	{
+		m_bot = bot;
+	}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
+	{
+		CBaseEntity *entity = EntityFromEntityHandle( pServerEntity );
+
+#ifdef TERROR
+		CBasePlayer *player = ToBasePlayer( entity );
+		if ( player && player->IsGhost() )
+			return false;
+#endif // TERROR
+
+		if ( m_bot->IsSelf( entity ) )
+		{
+			return false;
+		}
+
+		if ( CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask ) )
+		{
+			return !m_bot->GetLocomotionInterface()->IsEntityTraversable( entity, ILocomotion::IMMEDIATELY );
+		}
+
+		return false;
+	}
+
+private:
+	INextBot *m_bot;
+};
+#endif
+
+
+#endif // _NEXT_BOT_UTIL_H_
diff --git a/game/server/NextBot/NextBotVisionInterface.cpp b/game/server/NextBot/NextBotVisionInterface.cpp
new file mode 100644
index 00000000..1c9d6612
--- /dev/null
+++ b/game/server/NextBot/NextBotVisionInterface.cpp
@@ -0,0 +1,802 @@
+// NextBotVisionInterface.cpp
+// Implementation of common vision system
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "nav.h"
+#include "functorutils.h"
+
+#include "NextBot.h"
+#include "NextBotVisionInterface.h"
+#include "NextBotBodyInterface.h"
+#include "NextBotUtil.h"
+
+#ifdef TERROR
+#include "querycache.h"
+#endif
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+ConVar nb_blind( "nb_blind", "0", FCVAR_CHEAT, "Disable vision" );
+ConVar nb_debug_known_entities( "nb_debug_known_entities", "0", FCVAR_CHEAT, "Show the 'known entities' for the bot that is the current spectator target" );
+
+
+//------------------------------------------------------------------------------------------
+IVision::IVision( INextBot *bot ) : INextBotComponent( bot )
+{ 
+	Reset();
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Reset to initial state
+ */
+void IVision::Reset( void )
+{
+	INextBotComponent::Reset();
+
+	m_knownEntityVector.RemoveAll();
+	m_lastVisionUpdateTimestamp = 0.0f;
+	m_primaryThreat = NULL;
+
+	m_FOV = GetDefaultFieldOfView();
+	m_cosHalfFOV = cos( 0.5f * m_FOV * M_PI / 180.0f );
+	
+	for( int i=0; i<MAX_TEAMS; ++i )
+	{
+		m_notVisibleTimer[i].Invalidate();
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Ask the current behavior to select the most dangerous threat from
+ * our set of currently known entities
+ * TODO: Find a semantically better place for this to live.
+ */
+const CKnownEntity *IVision::GetPrimaryKnownThreat( bool onlyVisibleThreats ) const
+{
+	if ( m_knownEntityVector.Count() == 0 )
+		return NULL;
+
+	const CKnownEntity *threat = NULL;
+	int i;
+
+	// find the first valid entity
+	for( i=0; i<m_knownEntityVector.Count(); ++i )
+	{
+		const CKnownEntity &firstThreat = m_knownEntityVector[i];
+
+		// check in case status changes between updates
+		if ( IsAwareOf( firstThreat ) && !firstThreat.IsObsolete() && !IsIgnored( firstThreat.GetEntity() ) && GetBot()->IsEnemy( firstThreat.GetEntity() ) )
+		{
+			if ( !onlyVisibleThreats || firstThreat.IsVisibleRecently() )
+			{
+				threat = &firstThreat;
+				break;
+			}
+		}
+	}
+
+	if ( threat == NULL )
+	{
+		m_primaryThreat = NULL;
+		return NULL;
+	}
+
+	for( ++i; i<m_knownEntityVector.Count(); ++i )
+	{
+		const CKnownEntity &newThreat = m_knownEntityVector[i];
+
+		// check in case status changes between updates
+		if ( IsAwareOf( newThreat ) && !newThreat.IsObsolete() && !IsIgnored( newThreat.GetEntity() ) && GetBot()->IsEnemy( newThreat.GetEntity() ) )
+		{
+			if ( !onlyVisibleThreats || newThreat.IsVisibleRecently() )
+			{
+				threat = GetBot()->GetIntentionInterface()->SelectMoreDangerousThreat( GetBot(), GetBot()->GetEntity(), threat, &newThreat );
+			}
+		}
+	}
+
+	// cache off threat
+	m_primaryThreat = threat ? threat->GetEntity() : NULL;
+
+	return threat;
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Return the closest recognized entity
+ */
+const CKnownEntity *IVision::GetClosestKnown( int team ) const
+{
+	const Vector &myPos = GetBot()->GetPosition();
+	
+	const CKnownEntity *close = NULL;
+	float closeRange = 999999999.9f;
+	
+	for( int i=0; i < m_knownEntityVector.Count(); ++i )
+	{
+		const CKnownEntity &known = m_knownEntityVector[i];
+
+		if ( !known.IsObsolete() && IsAwareOf( known ) )
+		{
+			if ( team == TEAM_ANY || known.GetEntity()->GetTeamNumber() == team )
+			{
+				Vector to = known.GetLastKnownPosition() - myPos;
+				float rangeSq = to.LengthSqr();
+				
+				if ( rangeSq < closeRange )
+				{
+					close = &known;
+					closeRange = rangeSq;
+				}
+			}
+		}
+	}
+	
+	return close;
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Return the closest recognized entity that passes the given filter
+ */
+const CKnownEntity *IVision::GetClosestKnown( const INextBotEntityFilter &filter ) const
+{
+	const Vector &myPos = GetBot()->GetPosition();
+
+	const CKnownEntity *close = NULL;
+	float closeRange = 999999999.9f;
+
+	for( int i=0; i < m_knownEntityVector.Count(); ++i )
+	{
+		const CKnownEntity &known = m_knownEntityVector[i];
+
+		if ( !known.IsObsolete() && IsAwareOf( known ) )
+		{
+			if ( filter.IsAllowed( known.GetEntity() ) )
+			{
+				Vector to = known.GetLastKnownPosition() - myPos;
+				float rangeSq = to.LengthSqr();
+
+				if ( rangeSq < closeRange )
+				{
+					close = &known;
+					closeRange = rangeSq;
+				}
+			}
+		}
+	}
+
+	return close;	
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Given an entity, return our known version of it (or NULL if we don't know of it)
+ */
+const CKnownEntity *IVision::GetKnown( const CBaseEntity *entity ) const
+{
+	if ( entity == NULL )
+		return NULL;
+
+	for( int i=0; i < m_knownEntityVector.Count(); ++i )
+	{
+		const CKnownEntity &known = m_knownEntityVector[i];
+
+		if ( known.GetEntity() && known.GetEntity()->entindex() == entity->entindex() && !known.IsObsolete() )
+		{
+			return &known;
+		}
+	}
+
+	return NULL;
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Introduce a known entity into the system. Its position is assumed to be known
+ * and will be updated, and it is assumed to not yet have been seen by us, allowing for learning
+ * of known entities by being told about them, hearing them, etc.
+ */
+void IVision::AddKnownEntity( CBaseEntity *entity )
+{
+	if ( entity == NULL || entity->IsWorld() )
+	{
+		// the world is not an entity we can deal with
+		return;
+	}
+
+	CKnownEntity known( entity );
+
+	// only add it if we don't already know of it
+	if ( m_knownEntityVector.Find( known ) == m_knownEntityVector.InvalidIndex() )
+	{
+		m_knownEntityVector.AddToTail( known );
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+// Remove the given entity from our awareness (whether we know if it or not)
+// Useful if we've moved to where we last saw the entity, but it's not there any longer.
+void IVision::ForgetEntity( CBaseEntity *forgetMe )
+{
+	if ( !forgetMe )
+		return;
+
+	FOR_EACH_VEC( m_knownEntityVector, it )
+	{
+		const CKnownEntity &known = m_knownEntityVector[ it ];
+
+		if ( known.GetEntity() && known.GetEntity()->entindex() == forgetMe->entindex() )
+		{
+			m_knownEntityVector.FastRemove( it );
+			return;
+		}
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+void IVision::ForgetAllKnownEntities( void )
+{
+	m_knownEntityVector.RemoveAll();
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Return the number of entity on the given team known to us closer than rangeLimit
+ */
+int IVision::GetKnownCount( int team, bool onlyVisible, float rangeLimit ) const
+{
+	int count = 0;
+
+	FOR_EACH_VEC( m_knownEntityVector, it )
+	{
+		const CKnownEntity &known = m_knownEntityVector[ it ];
+
+		if ( !known.IsObsolete() && IsAwareOf( known ) )
+		{
+			if ( team == TEAM_ANY || known.GetEntity()->GetTeamNumber() == team )
+			{
+				if ( !onlyVisible || known.IsVisibleRecently() )
+				{
+					if ( rangeLimit < 0.0f || GetBot()->IsRangeLessThan( known.GetLastKnownPosition(), rangeLimit ) )
+					{
+						++count;
+					}
+				}
+			}
+		}
+	}
+
+	return count;
+}
+
+
+//------------------------------------------------------------------------------------------
+class PopulateVisibleVector
+{
+public:
+	PopulateVisibleVector( CUtlVector< CBaseEntity * > *potentiallyVisible )
+	{
+		m_potentiallyVisible = potentiallyVisible;
+	}
+
+	bool operator() ( CBaseEntity *actor )
+	{
+		m_potentiallyVisible->AddToTail( actor );
+		return true;
+	}
+
+	CUtlVector< CBaseEntity * > *m_potentiallyVisible;
+};
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Populate "potentiallyVisible" with the set of all entities we could potentially see. 
+ * Entities in this set will be tested for visibility/recognition in IVision::Update()
+ */
+void IVision::CollectPotentiallyVisibleEntities( CUtlVector< CBaseEntity * > *potentiallyVisible )
+{
+	potentiallyVisible->RemoveAll();
+
+	// by default, only consider players and other bots as potentially visible
+	PopulateVisibleVector populate( potentiallyVisible );
+	ForEachActor( populate );
+}
+
+
+//------------------------------------------------------------------------------------------
+class CollectVisible
+{
+public:
+	CollectVisible( IVision *vision )
+	{
+		m_vision = vision;
+	}
+	
+	bool operator() ( CBaseEntity *entity )
+	{
+		if ( entity &&
+			 !m_vision->IsIgnored( entity ) &&
+			 entity->IsAlive() &&
+			 entity != m_vision->GetBot()->GetEntity() &&
+			 m_vision->IsAbleToSee( entity, IVision::USE_FOV ) )
+		{
+			m_recognized.AddToTail( entity );	
+		}
+			
+		return true;
+	}
+	
+	bool Contains( CBaseEntity *entity ) const
+	{
+		for( int i=0; i < m_recognized.Count(); ++i )
+		{
+			if ( entity->entindex() == m_recognized[ i ]->entindex() )
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	IVision *m_vision;
+	CUtlVector< CBaseEntity * > m_recognized;
+};
+
+
+//------------------------------------------------------------------------------------------
+void IVision::UpdateKnownEntities( void )
+{
+	VPROF_BUDGET( "IVision::UpdateKnownEntities", "NextBot" );
+
+	// construct set of potentially visible objects
+	CUtlVector< CBaseEntity * > potentiallyVisible;
+	CollectPotentiallyVisibleEntities( &potentiallyVisible );
+
+	// collect set of visible and recognized entities at this moment
+	CollectVisible visibleNow( this );
+	FOR_EACH_VEC( potentiallyVisible, pit )
+	{
+		VPROF_BUDGET( "IVision::UpdateKnownEntities( collect visible )", "NextBot" );
+
+		if ( visibleNow( potentiallyVisible[ pit ] ) == false )
+			break;
+	}
+	
+	// update known set with new data
+	{	VPROF_BUDGET( "IVision::UpdateKnownEntities( update status )", "NextBot" );
+
+		int i;
+		for( i=0; i < m_knownEntityVector.Count(); ++i )
+		{
+			CKnownEntity &known = m_knownEntityVector[i];
+
+			// clear out obsolete knowledge
+			if ( known.GetEntity() == NULL || known.IsObsolete() )
+			{
+				m_knownEntityVector.Remove( i );
+				--i;
+				continue;
+			}
+			
+			if ( visibleNow.Contains( known.GetEntity() ) )
+			{
+				// this visible entity was already known (but perhaps not visible until now)
+				known.UpdatePosition();
+				known.UpdateVisibilityStatus( true );
+
+				// has our reaction time just elapsed?
+				if ( gpGlobals->curtime - known.GetTimeWhenBecameVisible() >= GetMinRecognizeTime() &&
+					 m_lastVisionUpdateTimestamp - known.GetTimeWhenBecameVisible() < GetMinRecognizeTime() )
+				{
+					if ( GetBot()->IsDebugging( NEXTBOT_VISION ) )
+					{
+						ConColorMsg( Color( 0, 255, 0, 255 ), "%3.2f: %s caught sight of %s(#%d)\n", 
+										gpGlobals->curtime,
+										GetBot()->GetDebugIdentifier(),
+										known.GetEntity()->GetClassname(),
+										known.GetEntity()->entindex() );
+
+						NDebugOverlay::Line( GetBot()->GetBodyInterface()->GetEyePosition(), known.GetLastKnownPosition(), 255, 255, 0, false, 0.2f );
+					}
+
+					GetBot()->OnSight( known.GetEntity() );
+				}
+		
+				// restart 'not seen' timer
+				m_notVisibleTimer[ known.GetEntity()->GetTeamNumber() ].Start();
+			}
+			else // known entity is not currently visible
+			{
+				if ( known.IsVisibleInFOVNow() )
+				{
+					// previously known and visible entity is now no longer visible
+					known.UpdateVisibilityStatus( false );
+
+					// lost sight of this entity
+					if ( GetBot()->IsDebugging( NEXTBOT_VISION ) )
+					{
+						ConColorMsg( Color( 255, 0, 0, 255 ), "%3.2f: %s Lost sight of %s(#%d)\n", 
+										gpGlobals->curtime,
+										GetBot()->GetDebugIdentifier(),
+										known.GetEntity()->GetClassname(),
+										known.GetEntity()->entindex() );
+					}
+
+					GetBot()->OnLostSight( known.GetEntity() );
+				}
+
+				if ( !known.HasLastKnownPositionBeenSeen() )
+				{
+					// can we see the entity's last know position?
+					if ( IsAbleToSee( known.GetLastKnownPosition(), IVision::USE_FOV ) )
+					{
+						known.MarkLastKnownPositionAsSeen();
+					}
+				}
+			}
+		}
+	}
+		
+	// check for new recognizes that were not in the known set
+	{	VPROF_BUDGET( "IVision::UpdateKnownEntities( new recognizes )", "NextBot" );
+
+		int i, j;
+		for( i=0; i < visibleNow.m_recognized.Count(); ++i )
+		{	
+			for( j=0; j < m_knownEntityVector.Count(); ++j )
+			{
+				if ( visibleNow.m_recognized[i] == m_knownEntityVector[j].GetEntity() )
+				{
+					break;
+				}
+			}
+			
+			if ( j == m_knownEntityVector.Count() )
+			{
+				// recognized a previously unknown entity (emit OnSight() event after reaction time has passed)
+				CKnownEntity known( visibleNow.m_recognized[i] );
+				known.UpdatePosition();
+				known.UpdateVisibilityStatus( true );
+				m_knownEntityVector.AddToTail( known );
+			}
+		}
+	}
+
+	// debugging
+	if ( nb_debug_known_entities.GetBool() )
+	{
+		CBasePlayer *watcher = UTIL_GetListenServerHost();
+		if ( watcher )
+		{
+			CBaseEntity *subject = watcher->GetObserverTarget();
+
+			if ( subject && GetBot()->IsSelf( subject ) )
+			{
+				CUtlVector< CKnownEntity > knownVector;
+				CollectKnownEntities( &knownVector );
+
+				for( int i=0; i < knownVector.Count(); ++i )
+				{
+					CKnownEntity &known = knownVector[i];
+
+					if ( GetBot()->IsFriend( known.GetEntity() ) )
+					{
+						if ( IsAwareOf( known ) )
+						{
+							if ( known.IsVisibleInFOVNow() )
+								NDebugOverlay::HorzArrow( GetBot()->GetEntity()->GetAbsOrigin(), known.GetLastKnownPosition(), 5.0f, 0, 255, 0, 255, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
+							else
+								NDebugOverlay::HorzArrow( GetBot()->GetEntity()->GetAbsOrigin(), known.GetLastKnownPosition(), 2.0f, 0, 100, 0, 255, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
+						}
+						else
+						{
+							NDebugOverlay::HorzArrow( GetBot()->GetEntity()->GetAbsOrigin(), known.GetLastKnownPosition(), 1.0f, 0, 100, 0, 128, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
+						}
+					}
+					else
+					{
+						if ( IsAwareOf( known ) )
+						{
+							if ( known.IsVisibleInFOVNow() )
+								NDebugOverlay::HorzArrow( GetBot()->GetEntity()->GetAbsOrigin(), known.GetLastKnownPosition(), 5.0f, 255, 0, 0, 255, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
+							else
+								NDebugOverlay::HorzArrow( GetBot()->GetEntity()->GetAbsOrigin(), known.GetLastKnownPosition(), 2.0f, 100, 0, 0, 255, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
+						}
+						else
+						{
+							NDebugOverlay::HorzArrow( GetBot()->GetEntity()->GetAbsOrigin(), known.GetLastKnownPosition(), 1.0f, 100, 0, 0, 128, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Update internal state
+ */
+void IVision::Update( void )
+{
+	VPROF_BUDGET( "IVision::Update", "NextBotExpensive" );
+
+/* This adds significantly to bot's reaction times
+	// throttle update rate
+	if ( !m_scanTimer.IsElapsed() )
+	{
+		return;
+	}
+
+	m_scanTimer.Start( 0.5f * GetMinRecognizeTime() );
+*/
+
+	if ( nb_blind.GetBool() )
+	{
+		m_knownEntityVector.RemoveAll();
+		return;
+	}
+
+	UpdateKnownEntities();
+
+	m_lastVisionUpdateTimestamp = gpGlobals->curtime;
+}
+
+
+//------------------------------------------------------------------------------------------
+bool IVision::IsAbleToSee( CBaseEntity *subject, FieldOfViewCheckType checkFOV, Vector *visibleSpot ) const
+{
+	VPROF_BUDGET( "IVision::IsAbleToSee", "NextBotExpensive" );
+
+	if ( GetBot()->IsRangeGreaterThan( subject, GetMaxVisionRange() ) )
+	{
+		return false;
+	}
+
+	
+	if ( GetBot()->GetEntity()->IsHiddenByFog( subject ) )
+	{
+		// lost in the fog
+		return false;
+	}
+
+	if ( checkFOV == USE_FOV && !IsInFieldOfView( subject ) )
+	{
+		return false;
+	}
+
+	CBaseCombatCharacter *combat = subject->MyCombatCharacterPointer();
+	if ( combat )
+	{
+		CNavArea *subjectArea = combat->GetLastKnownArea();
+		CNavArea *myArea = GetBot()->GetEntity()->GetLastKnownArea();
+		if ( myArea && subjectArea )
+		{
+			if ( !myArea->IsPotentiallyVisible( subjectArea ) )
+			{
+				// subject is not potentially visible, skip the expensive raycast
+				return false;
+			}
+		}
+	}
+
+	// do actual line-of-sight trace
+	if ( !IsLineOfSightClearToEntity( subject ) )
+	{
+		return false;
+	}
+
+	return IsVisibleEntityNoticed( subject );
+}
+
+
+//------------------------------------------------------------------------------------------
+bool IVision::IsAbleToSee( const Vector &pos, FieldOfViewCheckType checkFOV ) const
+{
+	VPROF_BUDGET( "IVision::IsAbleToSee", "NextBotExpensive" );
+
+	
+	if ( GetBot()->IsRangeGreaterThan( pos, GetMaxVisionRange() ) )
+	{
+		return false;
+	}
+
+	if ( GetBot()->GetEntity()->IsHiddenByFog( pos ) )
+	{
+		// lost in the fog
+		return false;
+	}
+
+	if ( checkFOV == USE_FOV && !IsInFieldOfView( pos ) )
+	{
+		return false;
+	}
+
+	// do actual line-of-sight trace	
+	return IsLineOfSightClear( pos );
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Angle given in degrees
+ */
+void IVision::SetFieldOfView( float horizAngle )
+{
+	m_FOV = horizAngle;
+	m_cosHalfFOV = cos( 0.5f * m_FOV * M_PI / 180.0f );
+}
+
+
+//------------------------------------------------------------------------------------------
+bool IVision::IsInFieldOfView( const Vector &pos ) const
+{
+#ifdef CHECK_OLD_CODE_AGAINST_NEW
+	bool bCheck = PointWithinViewAngle( GetBot()->GetBodyInterface()->GetEyePosition(), pos, GetBot()->GetBodyInterface()->GetViewVector(), m_cosHalfFOV );
+	Vector to = pos - GetBot()->GetBodyInterface()->GetEyePosition();
+	to.NormalizeInPlace();
+	
+	float cosDiff = DotProduct( GetBot()->GetBodyInterface()->GetViewVector(), to );
+	
+	if ( ( cosDiff > m_cosHalfFOV ) != bCheck )
+	{
+		Assert(0);
+		bool bCheck2 =
+			PointWithinViewAngle( GetBot()->GetBodyInterface()->GetEyePosition(), pos, GetBot()->GetBodyInterface()->GetViewVector(), m_cosHalfFOV );
+
+	}
+
+	return ( cosDiff > m_cosHalfFOV );
+#else
+	return PointWithinViewAngle( GetBot()->GetBodyInterface()->GetEyePosition(), pos, GetBot()->GetBodyInterface()->GetViewVector(), m_cosHalfFOV );
+#endif
+	
+	return true;
+}
+
+
+//------------------------------------------------------------------------------------------
+bool IVision::IsInFieldOfView( CBaseEntity *subject ) const
+{
+	/// @todo check more points
+	if ( IsInFieldOfView( subject->WorldSpaceCenter() ) )
+	{
+		return true;
+	}
+
+	return IsInFieldOfView( subject->EyePosition() );
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Return true if the ray to the given point is unobstructed
+ */
+bool IVision::IsLineOfSightClear( const Vector &pos ) const
+{
+	VPROF_BUDGET( "IVision::IsLineOfSightClear", "NextBot" );
+	VPROF_INCREMENT_COUNTER( "IVision::IsLineOfSightClear", 1 );
+
+	trace_t result;
+	NextBotVisionTraceFilter filter( GetBot()->GetEntity(), COLLISION_GROUP_NONE );
+	
+	UTIL_TraceLine( GetBot()->GetBodyInterface()->GetEyePosition(), pos, MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, &filter, &result );
+	
+	return ( result.fraction >= 1.0f && !result.startsolid );
+}
+
+
+//------------------------------------------------------------------------------------------
+bool IVision::IsLineOfSightClearToEntity( const CBaseEntity *subject, Vector *visibleSpot ) const
+{
+#ifdef TERROR
+	// TODO: Integration querycache & its dependencies
+
+	VPROF_INCREMENT_COUNTER( "IVision::IsLineOfSightClearToEntity", 1 );
+	VPROF_BUDGET( "IVision::IsLineOfSightClearToEntity", "NextBotSpiky" );
+
+	bool bClear = IsLineOfSightBetweenTwoEntitiesClear( GetBot()->GetBodyInterface()->GetEntity(), EOFFSET_MODE_EYEPOSITION,
+														subject, EOFFSET_MODE_WORLDSPACE_CENTER,
+														subject, COLLISION_GROUP_NONE,
+														MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, VisionTraceFilterFunction, 1.0 );
+
+#ifdef USE_NON_CACHE_QUERY
+	trace_t result;
+	NextBotTraceFilterIgnoreActors filter( subject, COLLISION_GROUP_NONE );
+	
+	UTIL_TraceLine( GetBot()->GetBodyInterface()->GetEyePosition(), subject->WorldSpaceCenter(), MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, &filter, &result );
+	Assert( result.DidHit() != bClear );
+	if ( subject->IsPlayer() && ! bClear )
+	{
+		UTIL_TraceLine( GetBot()->GetBodyInterface()->GetEyePosition(), subject->EyePosition(), MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, &filter, &result );
+		bClear = IsLineOfSightBetweenTwoEntitiesClear( GetBot()->GetEntity(),
+													   EOFFSET_MODE_EYEPOSITION,
+													   subject, EOFFSET_MODE_EYEPOSITION,
+													   subject, COLLISION_GROUP_NONE,
+													   MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, 
+													   IgnoreActorsTraceFilterFunction, 1.0 );
+
+		// this WILL assert - the query interface happens at a different time, and has hysteresis.
+		Assert( result.DidHit() != bClear );
+	}
+#endif
+
+	return bClear;
+
+#else
+
+	// TODO: Use plain-old traces until querycache/etc gets integrated
+	VPROF_BUDGET( "IVision::IsLineOfSightClearToEntity", "NextBot" );
+
+	trace_t result;
+	NextBotTraceFilterIgnoreActors filter( subject, COLLISION_GROUP_NONE );
+
+	UTIL_TraceLine( GetBot()->GetBodyInterface()->GetEyePosition(), subject->WorldSpaceCenter(), MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, &filter, &result );
+	if ( result.DidHit() )
+	{
+		UTIL_TraceLine( GetBot()->GetBodyInterface()->GetEyePosition(), subject->EyePosition(), MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, &filter, &result );
+
+		if ( result.DidHit() )
+		{
+			UTIL_TraceLine( GetBot()->GetBodyInterface()->GetEyePosition(), subject->GetAbsOrigin(), MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, &filter, &result );
+		}
+	}
+
+	if ( visibleSpot )
+	{
+		*visibleSpot = result.endpos;
+	}
+
+	return ( result.fraction >= 1.0f && !result.startsolid );
+
+#endif
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Are we looking directly at the given position
+ */
+bool IVision::IsLookingAt( const Vector &pos, float cosTolerance ) const
+{
+	Vector to = pos - GetBot()->GetBodyInterface()->GetEyePosition();
+	to.NormalizeInPlace();
+
+	Vector forward;
+	AngleVectors( GetBot()->GetEntity()->EyeAngles(), &forward );
+
+	return DotProduct( to, forward ) > cosTolerance;
+}
+
+
+//------------------------------------------------------------------------------------------
+/**
+ * Are we looking directly at the given actor
+ */
+bool IVision::IsLookingAt( const CBaseCombatCharacter *actor, float cosTolerance ) const
+{
+	return IsLookingAt( actor->EyePosition(), cosTolerance );
+}
+
+
diff --git a/game/server/NextBot/NextBotVisionInterface.h b/game/server/NextBot/NextBotVisionInterface.h
new file mode 100644
index 00000000..c6361f98
--- /dev/null
+++ b/game/server/NextBot/NextBotVisionInterface.h
@@ -0,0 +1,226 @@
+// NextBotVisionInterface.h
+// Visual information query interface for bots
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_VISION_INTERFACE_H_
+#define _NEXT_BOT_VISION_INTERFACE_H_
+
+#include "NextBotComponentInterface.h"
+#include "NextBotKnownEntity.h"
+
+class IBody;
+class INextBotEntityFilter;
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for HOW the bot sees (near sighted? night vision? etc)
+ */
+class IVision : public INextBotComponent
+{
+public:
+	IVision( INextBot *bot );
+	virtual ~IVision() { }
+
+	virtual void Reset( void );									// reset to initial state
+	virtual void Update( void );								// update internal state
+
+	//-- attention/short term memory interface follows ------------------------------------------
+
+	//
+	// WARNING: Do not keep CKnownEntity pointers returned by these methods, as they can be invalidated/freed 
+	//
+
+	/**
+	 * Iterate each interesting entity we are aware of.
+	 * If functor returns false, stop iterating and return false.
+	 * NOTE: known.GetEntity() is guaranteed to be non-NULL
+	 */
+	class IForEachKnownEntity
+	{
+	public:
+		virtual bool Inspect( const CKnownEntity &known ) = 0;
+	};
+	virtual bool ForEachKnownEntity( IForEachKnownEntity &func );
+
+	virtual void CollectKnownEntities( CUtlVector< CKnownEntity > *knownVector );	// populate given vector with all currently known entities
+
+	virtual const CKnownEntity *GetPrimaryKnownThreat( bool onlyVisibleThreats = false ) const;	// return the biggest threat to ourselves that we are aware of
+	virtual float GetTimeSinceVisible( int team ) const;				// return time since we saw any member of the given team
+
+	virtual const CKnownEntity *GetClosestKnown( int team = TEAM_ANY ) const;	// return the closest known entity
+	virtual int GetKnownCount( int team, bool onlyVisible = false, float rangeLimit = -1.0f ) const;		// return the number of entities on the given team known to us closer than rangeLimit
+
+	virtual const CKnownEntity *GetClosestKnown( const INextBotEntityFilter &filter ) const;	// return the closest known entity that passes the given filter
+
+	virtual const CKnownEntity *GetKnown( const CBaseEntity *entity ) const;		// given an entity, return our known version of it (or NULL if we don't know of it)
+
+	// Introduce a known entity into the system. Its position is assumed to be known
+	// and will be updated, and it is assumed to not yet have been seen by us, allowing for learning
+	// of known entities by being told about them, hearing them, etc.
+	virtual void AddKnownEntity( CBaseEntity *entity );
+
+	virtual void ForgetEntity( CBaseEntity *forgetMe );			// remove the given entity from our awareness (whether we know if it or not)
+	virtual void ForgetAllKnownEntities( void );
+
+	//-- physical vision interface follows ------------------------------------------------------
+
+	/**
+	 * Populate "potentiallyVisible" with the set of all entities we could potentially see. 
+	 * Entities in this set will be tested for visibility/recognition in IVision::Update()
+	 */
+	virtual void CollectPotentiallyVisibleEntities( CUtlVector< CBaseEntity * > *potentiallyVisible );
+
+	virtual float GetMaxVisionRange( void ) const;				// return maximum distance vision can reach
+	virtual float GetMinRecognizeTime( void ) const;			// return VISUAL reaction time
+
+	/**
+	 * IsAbleToSee() returns true if the viewer can ACTUALLY SEE the subject or position,
+	 * taking into account blindness, smoke effects, invisibility, etc.
+	 * If 'visibleSpot' is non-NULL, the highest priority spot on the subject that is visible is returned.
+	 */ 
+	enum FieldOfViewCheckType { USE_FOV, DISREGARD_FOV };
+	virtual bool IsAbleToSee( CBaseEntity *subject, FieldOfViewCheckType checkFOV, Vector *visibleSpot = NULL ) const;
+	virtual bool IsAbleToSee( const Vector &pos, FieldOfViewCheckType checkFOV ) const;
+
+	virtual bool IsIgnored( CBaseEntity *subject ) const;		// return true to completely ignore this entity (may not be in sight when this is called)
+	virtual bool IsVisibleEntityNoticed( CBaseEntity *subject ) const;		// return true if we 'notice' the subject, even though we have LOS to it
+
+	/**
+	 * Check if 'subject' is within the viewer's field of view
+	 */
+	virtual bool IsInFieldOfView( const Vector &pos ) const;
+	virtual bool IsInFieldOfView( CBaseEntity *subject ) const;
+	virtual float GetDefaultFieldOfView( void ) const;			// return default FOV in degrees
+	virtual float GetFieldOfView( void ) const;					// return FOV in degrees
+	virtual void SetFieldOfView( float horizAngle );			// angle given in degrees
+
+	virtual bool IsLineOfSightClear( const Vector &pos ) const;	// return true if the ray to the given point is unobstructed
+
+	/**
+	 * Returns true if the ray between the position and the subject is unobstructed.
+	 * A visible spot on the subject is returned in 'visibleSpot'.
+	 */
+	virtual bool IsLineOfSightClearToEntity( const CBaseEntity *subject, Vector *visibleSpot = NULL ) const;
+
+	/// @todo: Implement LookAt system
+	virtual bool IsLookingAt( const Vector &pos, float cosTolerance = 0.95f ) const;					// are we looking at the given position
+	virtual bool IsLookingAt( const CBaseCombatCharacter *actor, float cosTolerance = 0.95f ) const;	// are we looking at the given actor
+
+private:
+	CountdownTimer m_scanTimer;			// for throttling update rate
+	
+	float m_FOV;						// current FOV in degrees
+	float m_cosHalfFOV;					// the cosine of FOV/2
+	
+	CUtlVector< CKnownEntity > m_knownEntityVector;		// the set of enemies/friends we are aware of
+	void UpdateKnownEntities( void );
+	bool IsAwareOf( const CKnownEntity &known ) const;	// return true if our reaction time has passed for this entity
+	mutable CHandle< CBaseEntity > m_primaryThreat;
+
+	float m_lastVisionUpdateTimestamp;
+	IntervalTimer m_notVisibleTimer[ MAX_TEAMS ];		// for tracking interval since last saw a member of the given team
+};
+
+inline void IVision::CollectKnownEntities( CUtlVector< CKnownEntity > *knownVector )
+{
+	if ( knownVector )
+	{
+		knownVector->RemoveAll();
+
+		for( int i=0; i<m_knownEntityVector.Count(); ++i )
+		{
+			if ( !m_knownEntityVector[i].IsObsolete() )
+			{
+				knownVector->AddToTail( m_knownEntityVector[i] );
+			}
+		}
+	}
+}
+
+inline float IVision::GetDefaultFieldOfView( void ) const
+{
+	return 90.0f;
+}
+
+inline float IVision::GetFieldOfView( void ) const
+{
+	return m_FOV;
+}
+
+
+inline float IVision::GetTimeSinceVisible( int team ) const
+{
+	if ( team == TEAM_ANY )
+	{
+		// return minimum time	
+		float time = 9999999999.9f;
+		for( int i=0; i<MAX_TEAMS; ++i )
+		{
+			if ( m_notVisibleTimer[i].HasStarted() )
+			{
+				if ( time > m_notVisibleTimer[i].GetElapsedTime() )
+				{
+					team = m_notVisibleTimer[i].GetElapsedTime();
+				}
+			}
+		}
+		return time;
+	}
+	
+	if ( team >= 0 && team < MAX_TEAMS )
+	{
+		return m_notVisibleTimer[ team ].GetElapsedTime();
+	}
+	
+	return 0.0f;
+}
+
+
+inline bool IVision::IsAwareOf( const CKnownEntity &known ) const
+{
+	return known.GetTimeSinceBecameKnown() >= GetMinRecognizeTime();
+}
+
+
+inline bool IVision::ForEachKnownEntity( IVision::IForEachKnownEntity &func )
+{
+	for( int i=0; i<m_knownEntityVector.Count(); ++i )
+	{
+		const CKnownEntity &known = m_knownEntityVector[i];
+
+		if ( !known.IsObsolete() && IsAwareOf( known ) )
+		{
+			if ( func.Inspect( known ) == false )
+			{
+				return false;
+			}
+		}
+	}
+	
+	return true;
+}
+
+inline bool IVision::IsVisibleEntityNoticed( CBaseEntity *subject ) const
+{
+	return true;
+}
+
+inline bool IVision::IsIgnored( CBaseEntity *subject ) const
+{
+	return false;
+}
+
+inline float IVision::GetMaxVisionRange( void ) const
+{
+	return 2000.0f;
+}
+
+inline float IVision::GetMinRecognizeTime( void ) const
+{
+	return 0.0f;
+}
+
+
+#endif // _NEXT_BOT_VISION_INTERFACE_H_
diff --git a/game/server/NextBot/Path/NextBotChasePath.cpp b/game/server/NextBot/Path/NextBotChasePath.cpp
new file mode 100644
index 00000000..1674fc30
--- /dev/null
+++ b/game/server/NextBot/Path/NextBotChasePath.cpp
@@ -0,0 +1,166 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================
+
+#include "cbase.h"
+
+#include "NextBotChasePath.h"
+#include "tier1/fmtstr.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Try to cutoff our chase subject
+ */
+Vector ChasePath::PredictSubjectPosition( INextBot *bot, CBaseEntity *subject ) const
+{
+	ILocomotion *mover = bot->GetLocomotionInterface();
+
+	const Vector &subjectPos = subject->GetAbsOrigin();
+
+	Vector to = subjectPos - bot->GetPosition();
+	to.z = 0.0f;
+	float flRangeSq = to.LengthSqr();
+
+	// don't lead if subject is very far away
+	float flLeadRadiusSq = GetLeadRadius();
+	flLeadRadiusSq *= flLeadRadiusSq;
+	if ( flRangeSq > flLeadRadiusSq )
+		return subjectPos;
+
+	// Normalize in place
+	float range = sqrt( flRangeSq );
+	to /= ( range + 0.0001f );	// avoid divide by zero
+
+	// estimate time to reach subject, assuming maximum speed
+	float leadTime = 0.5f + ( range / ( mover->GetRunSpeed() + 0.0001f ) );
+	
+	// estimate amount to lead the subject	
+	Vector lead = leadTime * subject->GetAbsVelocity();
+	lead.z = 0.0f;
+
+	if ( DotProduct( to, lead ) < 0.0f )
+	{
+		// the subject is moving towards us - only pay attention 
+		// to his perpendicular velocity for leading
+		Vector2D to2D = to.AsVector2D();
+		to2D.NormalizeInPlace();
+
+		Vector2D perp( -to2D.y, to2D.x );
+
+		float enemyGroundSpeed = lead.x * perp.x + lead.y * perp.y;
+
+		lead.x = enemyGroundSpeed * perp.x;
+		lead.y = enemyGroundSpeed * perp.y;
+	}
+
+	// compute our desired destination
+	Vector pathTarget = subjectPos + lead;
+
+	// validate this destination
+
+	// don't lead through walls
+	if ( lead.LengthSqr() > 36.0f )
+	{
+		float fraction;
+		if ( !mover->IsPotentiallyTraversable( subjectPos, pathTarget, ILocomotion::IMMEDIATELY, &fraction ) )
+		{
+			// tried to lead through an unwalkable area - clip to walkable space
+			pathTarget = subjectPos + fraction * ( pathTarget - subjectPos );
+		}
+	}
+
+	// don't lead over cliffs
+	CNavArea *leadArea = NULL;
+
+#ifdef NEED_GPGLOBALS_SERVERCOUNT_TO_DO_THIS
+	CBaseCombatCharacter *pBCC = subject->MyCombatCharacterPointer();
+	if ( pBCC && CloseEnough( pathTarget, subjectPos, 3.0 ) )
+	{
+		pathTarget = subjectPos;
+		leadArea = pBCC->GetLastKnownArea(); // can return null?
+	}
+	else
+	{
+		struct CacheEntry_t
+		{
+			CacheEntry_t() : pArea(NULL) {}
+			Vector target;
+			CNavArea *pArea;
+		};
+
+		static int iServer;
+		static CacheEntry_t cache[4];
+		static int iNext;
+		int i;
+
+		bool bFound = false;
+		if ( iServer != gpGlobals->serverCount )
+		{
+			for ( i = 0; i < ARRAYSIZE(cache); i++ )
+			{
+				cache[i].pArea = NULL;
+			}
+			iServer = gpGlobals->serverCount;
+		}
+		else
+		{
+			for ( i = 0; i < ARRAYSIZE(cache); i++ )
+			{
+				if ( cache[i].pArea && CloseEnough( cache[i].target, pathTarget, 2.0 ) )
+				{
+					pathTarget = cache[i].target;
+					leadArea = cache[i].pArea;
+					bFound = true;
+					break;
+				}
+			}
+		}
+
+		if ( !bFound )
+		{
+			leadArea = TheNavMesh->GetNearestNavArea( pathTarget );
+			if ( leadArea )
+			{
+				cache[iNext].target = pathTarget;
+				cache[iNext].pArea = leadArea;
+				iNext = ( iNext + 1 ) % ARRAYSIZE( cache );
+			}
+		}
+	}
+#else
+	leadArea = TheNavMesh->GetNearestNavArea( pathTarget );
+#endif
+
+
+	if ( !leadArea || leadArea->GetZ( pathTarget.x, pathTarget.y ) < pathTarget.z - mover->GetMaxJumpHeight() )
+	{
+		// would fall off a cliff
+		return subjectPos;		
+	}
+	
+	/** This needs more thought - it is preventing bots from using dropdowns
+	if ( mover->HasPotentialGap( subjectPos, pathTarget, &fraction ) )
+	{
+		// tried to lead over a cliff - clip to safe region
+		pathTarget = subjectPos + fraction * ( pathTarget - subjectPos );
+	}
+	*/
+	
+	return pathTarget;
+}
+
+// if the victim is a player, poke them so they know they're being chased
+void DirectChasePath::NotifyVictim( INextBot *me, CBaseEntity *victim )
+{
+	CBaseCombatCharacter *pBCCVictim = ToBaseCombatCharacter( victim );
+	if ( !pBCCVictim )
+		return;
+	
+	pBCCVictim->OnPursuedBy( me );
+}
\ No newline at end of file
diff --git a/game/server/NextBot/Path/NextBotChasePath.h b/game/server/NextBot/Path/NextBotChasePath.h
new file mode 100644
index 00000000..1929648b
--- /dev/null
+++ b/game/server/NextBot/Path/NextBotChasePath.h
@@ -0,0 +1,376 @@
+// NextBotChasePath.h
+// Maintain and follow a "chase path" to a selected Actor
+// Author: Michael Booth, September 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_CHASE_PATH_
+#define _NEXT_BOT_CHASE_PATH_
+
+#include "nav.h"
+#include "NextBotInterface.h"
+#include "NextBotLocomotionInterface.h"
+#include "NextBotChasePath.h"
+#include "NextBotUtil.h"
+#include "NextBotPathFollow.h"
+#include "tier0/vprof.h"
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * A ChasePath extends a PathFollower to periodically recompute a path to a chase
+ * subject, and to move along the path towards that subject.
+ */
+class ChasePath : public PathFollower
+{
+public:
+	enum SubjectChaseType
+	{
+		LEAD_SUBJECT,
+		DONT_LEAD_SUBJECT
+	};
+	ChasePath( SubjectChaseType chaseHow = DONT_LEAD_SUBJECT );
+
+	virtual ~ChasePath() { }
+
+	virtual void Update( INextBot *bot, CBaseEntity *subject, const IPathCost &cost, Vector *pPredictedSubjectPos = NULL );	// update path to chase target and move bot along path
+
+	virtual float GetLeadRadius( void ) const;			// range where movement leading begins - beyond this just head right for the subject
+	virtual float GetMaxPathLength( void ) const;		// return maximum path length
+	virtual Vector PredictSubjectPosition( INextBot *bot, CBaseEntity *subject ) const;	// try to cutoff our chase subject, knowing our relative positions and velocities
+	virtual bool IsRepathNeeded( INextBot *bot, CBaseEntity *subject ) const;			// return true if situation has changed enough to warrant recomputing the current path
+
+	virtual float GetLifetime( void ) const;			// Return duration this path is valid. Path will become invalid at its earliest opportunity once this duration elapses. Zero = infinite lifetime
+
+	virtual void Invalidate( void );					// (EXTEND) cause the path to become invalid
+
+private:
+	void RefreshPath( INextBot *bot, CBaseEntity *subject, const IPathCost &cost, Vector *pPredictedSubjectPos );
+
+	CountdownTimer m_failTimer;							// throttle re-pathing if last path attempt failed
+	CountdownTimer m_throttleTimer;						// require a minimum time between re-paths
+	CountdownTimer m_lifetimeTimer;
+	EHANDLE m_lastPathSubject;							// the subject used to compute the current/last path
+	SubjectChaseType m_chaseHow;
+};
+
+inline ChasePath::ChasePath( SubjectChaseType chaseHow )
+{
+	m_failTimer.Invalidate();
+	m_throttleTimer.Invalidate();
+	m_lifetimeTimer.Invalidate();
+	m_lastPathSubject = NULL;
+	m_chaseHow = chaseHow;
+}
+
+inline float ChasePath::GetLeadRadius( void ) const 
+{ 
+	return 500.0f; // 1000.0f; 
+}
+
+inline float ChasePath::GetMaxPathLength( void ) const
+{
+	// no limit
+	return 0.0f;
+}
+
+inline float ChasePath::GetLifetime( void ) const
+{
+	// infinite duration
+	return 0.0f;
+}
+
+inline void ChasePath::Invalidate( void )
+{
+	// path is gone, repath at earliest opportunity
+	m_throttleTimer.Invalidate();
+	m_lifetimeTimer.Invalidate();
+
+	// extend
+	PathFollower::Invalidate();	
+}
+
+
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Maintain a path to our chase subject and move along that path
+ */
+inline void ChasePath::Update( INextBot *bot, CBaseEntity *subject, const IPathCost &cost, Vector *pPredictedSubjectPos )
+{
+	VPROF_BUDGET( "ChasePath::Update", "NextBot" );
+
+	// maintain the path to the subject
+	RefreshPath( bot, subject, cost, pPredictedSubjectPos );
+
+	// move along the path towards the subject
+	PathFollower::Update( bot );
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Return true if situation has changed enough to warrant recomputing the current path
+ */
+inline bool ChasePath::IsRepathNeeded( INextBot *bot, CBaseEntity *subject ) const
+{
+	// the closer we get, the more accurate our path needs to be
+	Vector to = subject->GetAbsOrigin() - bot->GetPosition();
+
+	const float minTolerance = 0.0f; // 25.0f;
+	const float toleranceRate = 0.33f; // 1.0f; // 0.15f;
+
+	float tolerance = minTolerance + toleranceRate * to.Length();
+
+	return ( subject->GetAbsOrigin() - GetEndPosition() ).IsLengthGreaterThan( tolerance );
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Periodically rebuild the path to our victim
+ */
+inline void ChasePath::RefreshPath( INextBot *bot, CBaseEntity *subject, const IPathCost &cost, Vector *pPredictedSubjectPos )
+{
+	VPROF_BUDGET( "ChasePath::RefreshPath", "NextBot" );
+
+	ILocomotion *mover = bot->GetLocomotionInterface();
+
+	// don't change our path if we're on a ladder
+	if ( IsValid() && mover->IsUsingLadder() )
+	{
+		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+		{
+			DevMsg( "%3.2f: bot(#%d) ChasePath::RefreshPath failed. Bot is on a ladder.\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+		}
+
+		// don't allow repath until a moment AFTER we have left the ladder
+		m_throttleTimer.Start( 1.0f );
+
+		return;
+	}
+
+	if ( subject == NULL )
+	{
+		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+		{
+			DevMsg( "%3.2f: bot(#%d) CasePath::RefreshPath failed. No subject.\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+		}
+		return;
+	}
+
+	if ( !m_failTimer.IsElapsed() )
+	{
+// 		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+// 		{
+// 			DevMsg( "%3.2f: bot(#%d) ChasePath::RefreshPath failed. Fail timer not elapsed.\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+// 		}
+		return;
+	}
+
+	// if our path subject changed, repath immediately
+	if ( subject != m_lastPathSubject )
+	{
+		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+		{
+			DevMsg( "%3.2f: bot(#%d) Chase path subject changed (from %p to %p).\n", gpGlobals->curtime, bot->GetEntity()->entindex(), m_lastPathSubject.Get(), subject );
+		}
+
+		Invalidate();
+
+		// new subject, fresh attempt
+		m_failTimer.Invalidate();
+	}
+
+	if ( IsValid() && !m_throttleTimer.IsElapsed() )
+	{
+		// require a minimum time between repaths, as long as we have a path to follow
+// 		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+// 		{
+// 			DevMsg( "%3.2f: bot(#%d) ChasePath::RefreshPath failed. Rate throttled.\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+// 		}
+		return;
+	}
+
+	if ( IsValid() && m_lifetimeTimer.HasStarted() && m_lifetimeTimer.IsElapsed() )
+	{
+		// this path's lifetime has elapsed
+		Invalidate();
+	}
+	
+	if ( !IsValid() || IsRepathNeeded( bot, subject ) )
+	{
+		// the situation has changed - try a new path
+		bool isPath;
+		Vector pathTarget = subject->GetAbsOrigin();
+
+		if ( m_chaseHow == LEAD_SUBJECT )
+		{
+			pathTarget = pPredictedSubjectPos ? *pPredictedSubjectPos : PredictSubjectPosition( bot, subject );
+			isPath = Compute( bot, pathTarget, cost, GetMaxPathLength() );
+		}
+		else if ( subject->MyCombatCharacterPointer() && subject->MyCombatCharacterPointer()->GetLastKnownArea() )
+		{
+			isPath = Compute( bot, subject->MyCombatCharacterPointer(), cost, GetMaxPathLength() );
+		}
+		else
+		{
+			isPath = Compute( bot, pathTarget, cost, GetMaxPathLength() );
+		}
+
+		if ( isPath )
+		{
+			if ( bot->IsDebugging( NEXTBOT_PATH ) )
+			{
+				//const float size = 20.0f;			
+				//NDebugOverlay::VertArrow( bot->GetPosition() + Vector( 0, 0, size ), bot->GetPosition(), size, 255, RandomInt( 0, 200 ), 255, 255, true, 30.0f );
+
+				DevMsg( "%3.2f: bot(#%d) REPATH\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+			}
+
+			m_lastPathSubject = subject;
+
+			const float minRepathInterval = 0.5f;
+			m_throttleTimer.Start( minRepathInterval );
+
+			// track the lifetime of this new path
+			float lifetime = GetLifetime();
+			if ( lifetime > 0.0f )
+			{
+				m_lifetimeTimer.Start( lifetime );
+			}
+			else
+			{
+				m_lifetimeTimer.Invalidate();
+			}
+		}
+		else
+		{
+			// can't reach subject - throttle retry based on range to subject
+			m_failTimer.Start( 0.005f * ( bot->GetRangeTo( subject ) ) );
+			
+			// allow bot to react to path failure
+			bot->OnMoveToFailure( this, FAIL_NO_PATH_EXISTS );
+
+			if ( bot->IsDebugging( NEXTBOT_PATH ) )
+			{
+				//const float size = 20.0f;	
+				const float dT = 90.0f;		
+				int c = RandomInt( 0, 100 );
+				//NDebugOverlay::VertArrow( bot->GetPosition() + Vector( 0, 0, size ), bot->GetPosition(), size, 255, c, c, 255, true, dT );
+				NDebugOverlay::HorzArrow( bot->GetPosition(), pathTarget, 5.0f, 255, c, c, 255, true, dT );
+
+				DevMsg( "%3.2f: bot(#%d) REPATH FAILED\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+			}
+
+			Invalidate();
+		}
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------------------------------------
+/**
+ * Directly beeline toward victim if we have a clear shot, otherwise pathfind.
+ */
+class DirectChasePath : public ChasePath
+{
+public:
+
+	DirectChasePath( ChasePath::SubjectChaseType chaseHow = ChasePath::DONT_LEAD_SUBJECT ) : ChasePath( chaseHow )
+	{
+
+	}
+
+	//-------------------------------------------------------------------------------------------------------
+	virtual void Update( INextBot *me, CBaseEntity *victim, const IPathCost &pathCost, Vector *pPredictedSubjectPos = NULL )	// update path to chase target and move bot along path
+	{
+		Assert( !pPredictedSubjectPos );
+		bool bComputedPredictedPosition;
+		Vector vecPredictedPosition;
+		if ( !DirectChase( &bComputedPredictedPosition, &vecPredictedPosition, me, victim ) )
+		{
+			// path around obstacles to reach our victim
+			ChasePath::Update( me, victim, pathCost, bComputedPredictedPosition ? &vecPredictedPosition : NULL );
+		}
+		NotifyVictim( me, victim );
+	}
+
+	//-------------------------------------------------------------------------------------------------------
+	bool DirectChase( bool *pPredictedPositionComputed, Vector *pPredictedPos, INextBot *me, CBaseEntity *victim )		// if there is nothing between us and our victim, run directly at them
+	{
+		*pPredictedPositionComputed = false;
+
+		ILocomotion *mover = me->GetLocomotionInterface();
+
+		if ( me->IsImmobile() || mover->IsScrambling() )
+		{
+			return false;
+		}
+
+		if ( IsDiscontinuityAhead( me, CLIMB_UP ) )
+		{
+			return false;
+		}
+
+		if ( IsDiscontinuityAhead( me, JUMP_OVER_GAP ) )
+		{
+			return false;
+		}
+
+		Vector leadVictimPos = PredictSubjectPosition( me, victim );
+
+		// Don't want to have to compute the predicted position twice.
+		*pPredictedPositionComputed = true;
+		*pPredictedPos = leadVictimPos;
+
+		if ( !mover->IsPotentiallyTraversable( mover->GetFeet(), leadVictimPos  ) )
+		{
+			return false;
+		}
+
+		// the way is clear - move directly towards our victim
+		mover->FaceTowards( leadVictimPos );
+		mover->Approach( leadVictimPos );
+
+		me->GetBodyInterface()->AimHeadTowards( victim );
+
+		// old path is no longer useful since we've moved off of it
+		Invalidate();
+
+		return true;
+	}
+
+	//-------------------------------------------------------------------------------------------------------
+	virtual bool IsRepathNeeded( INextBot *bot, CBaseEntity *subject ) const			// return true if situation has changed enough to warrant recomputing the current path
+	{
+		if ( ChasePath::IsRepathNeeded( bot, subject ) )
+		{
+			return true;
+		}
+
+		return bot->GetLocomotionInterface()->IsStuck() && bot->GetLocomotionInterface()->GetStuckDuration() > 2.0f;
+	}
+
+	//-------------------------------------------------------------------------------------------------------
+	/**
+	 * Determine exactly where the path goes between the given two areas
+	 * on the path. Return this point in 'crossPos'.
+	 */
+	virtual void ComputeAreaCrossing( INextBot *bot, const CNavArea *from, const Vector &fromPos, const CNavArea *to, NavDirType dir, Vector *crossPos ) const
+	{
+		Vector center;
+		float halfWidth;
+		from->ComputePortal( to, dir, &center, &halfWidth );
+
+		*crossPos = center;
+	}
+
+	void NotifyVictim( INextBot *me, CBaseEntity *victim );
+};
+
+
+
+
+#endif // _NEXT_BOT_CHASE_PATH_
diff --git a/game/server/NextBot/Path/NextBotPath.cpp b/game/server/NextBot/Path/NextBotPath.cpp
new file mode 100644
index 00000000..4514887c
--- /dev/null
+++ b/game/server/NextBot/Path/NextBotPath.cpp
@@ -0,0 +1,1094 @@
+// NextBotPath.cpp
+// Encapsulate and manipulate a path through the world
+// Author: Michael Booth, February 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "nav_mesh.h"
+#include "fmtstr.h"
+
+#include "NextBotPath.h"
+#include "NextBotInterface.h"
+#include "NextBotLocomotionInterface.h"
+#include "NextBotBodyInterface.h"
+#include "NextBotUtil.h"
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+ConVar NextBotPathDrawIncrement( "nb_path_draw_inc", "100", FCVAR_CHEAT );
+ConVar NextBotPathDrawSegmentCount( "nb_path_draw_segment_count", "100", FCVAR_CHEAT );
+ConVar NextBotPathSegmentInfluenceRadius( "nb_path_segment_influence_radius", "100", FCVAR_CHEAT );
+
+//--------------------------------------------------------------------------------------------------------------
+Path::Path( void )
+{
+	m_segmentCount = 0;
+	
+	m_cursorPos = 0.0f;
+	m_isCursorDataDirty = true;
+	m_cursorData.segmentPrior = NULL;
+	m_ageTimer.Invalidate();
+	m_subject = NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine actual path positions
+ */
+bool Path::ComputePathDetails( INextBot *bot, const Vector &start )
+{
+	VPROF_BUDGET( "Path::ComputePathDetails", "NextBot" );
+
+	if (m_segmentCount == 0)
+		return false;
+		
+	IBody *body = bot->GetBodyInterface();
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	
+	const float stepHeight = ( mover ) ? mover->GetStepHeight() : 18.0f;
+
+	// inflate hull width slightly as a safety margin
+	const float hullWidth = ( body ) ? body->GetHullWidth() + 5.0f : 1.0f;
+
+	// set first path position
+	if ( m_path[0].area->Contains( start ) )
+	{
+		m_path[0].pos = start;
+	}
+	else
+	{
+		// start in first area's center
+		m_path[0].pos = m_path[0].area->GetCenter();
+	}	
+	m_path[0].ladder = NULL;
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+	m_path[0].type = ON_GROUND;
+
+	// set positions along the path
+	for( int i=1; i<m_segmentCount; ++i )
+	{
+		Segment *from = &m_path[ i-1 ];
+		Segment *to = &m_path[ i ];
+		
+		if ( to->how <= GO_WEST )		// walk along the floor to the next area
+		{
+			to->ladder = NULL;
+
+			from->area->ComputePortal( to->area, (NavDirType)to->how, &to->m_portalCenter, &to->m_portalHalfWidth );
+
+			// compute next point
+			ComputeAreaCrossing( bot, from->area, from->pos, to->area, (NavDirType)to->how, &to->pos );
+
+			// we need to walk out of "from" area, so keep Z where we can reach it
+			to->pos.z = from->area->GetZ( to->pos );
+
+			// if this is a "jump down" connection, we must insert an additional point on the path
+			//float expectedHeightDrop = from->area->GetZ( from->pos ) - to->area->GetZ( to->pos );
+
+			// measure the drop distance relative to the actual slope of the ground
+			Vector fromPos = from->pos;
+			fromPos.z = from->area->GetZ( fromPos );
+
+			Vector toPos = to->pos;
+			toPos.z = to->area->GetZ( toPos );
+
+			Vector groundNormal;
+			from->area->ComputeNormal( &groundNormal );
+
+			Vector alongPath = toPos - fromPos;
+
+			float expectedHeightDrop = -DotProduct( alongPath, groundNormal );
+
+			if ( expectedHeightDrop > mover->GetStepHeight() )
+			{
+				// NOTE: We can't know this is a drop-down yet, because of subtle interactions
+				// between nav area links and "portals" and "area crossings"
+
+				// compute direction of path just prior to "jump down"
+				Vector2D dir;
+				DirectionToVector2D( (NavDirType)to->how, &dir );
+
+				// shift top of "jump down" out a bit to "get over the ledge"
+				const float inc = 10.0f; // 0.25f * hullWidth;
+				const float maxPushDist = 2.0f * hullWidth; // 75.0f;
+				float halfWidth = hullWidth/2.0f;
+				float hullHeight = ( body ) ? body->GetCrouchHullHeight() : 1.0f;
+				
+				float pushDist;
+				for( pushDist = 0.0f; pushDist <= maxPushDist; pushDist += inc )
+				{
+					Vector pos = to->pos + Vector( pushDist * dir.x, pushDist * dir.y, 0.0f );
+					Vector lowerPos = Vector( pos.x, pos.y, toPos.z );
+					
+					trace_t result;
+					NextBotTraceFilterIgnoreActors filter( bot->GetEntity(), COLLISION_GROUP_NONE );
+					UTIL_TraceHull( pos, lowerPos,
+									Vector( -halfWidth, -halfWidth, stepHeight ), Vector( halfWidth, halfWidth, hullHeight ), 
+									bot->GetBodyInterface()->GetSolidMask(), &filter, &result );
+					
+					if ( result.fraction >= 1.0f )
+					{
+						// found clearance to drop
+						break;
+					}
+				}
+				
+				Vector startDrop( to->pos.x + pushDist * dir.x, to->pos.y + pushDist * dir.y, to->pos.z );
+				Vector endDrop( startDrop.x, startDrop.y, to->area->GetZ( to->pos ) );
+
+				if ( bot->IsDebugging( NEXTBOT_PATH ) )
+				{
+					NDebugOverlay::Cross3D( startDrop, 5.0f, 255, 0, 255, true, 5.0f );
+					NDebugOverlay::Cross3D( endDrop, 5.0f, 255, 255, 0, true, 5.0f );
+					NDebugOverlay::VertArrow( startDrop, endDrop, 5.0f, 255, 100, 0, 255, true, 5.0f );
+				}
+				
+				// verify that there is actually ground down there in case this is a far jump dropdown
+				float ground;
+				if ( TheNavMesh->GetGroundHeight( endDrop, &ground ) )
+				{
+					if ( startDrop.z > ground + stepHeight )
+					{
+						// if "ground" is lower than the next segment along the path
+						// there is a chasm between - this is not a drop down
+						// NOTE next->pos is not yet valid - this loop is computing it!
+						// const Segment *next = NextSegment( to );
+						// if ( !next || next->area->GetCenter().z < ground + stepHeight )
+						{
+							// this is a "jump down" link
+							to->pos = startDrop;
+							to->type = DROP_DOWN;
+
+							// insert a duplicate node to represent the bottom of the fall
+							if ( m_segmentCount < MAX_PATH_SEGMENTS-1 )
+							{
+								// copy nodes down
+								for( int j=m_segmentCount; j>i; --j )
+									m_path[j] = m_path[j-1];
+
+								// path is one node longer
+								++m_segmentCount;
+
+								// move index ahead into the new node we just duplicated
+								++i;
+
+								m_path[i].pos.x = endDrop.x;
+								m_path[i].pos.y = endDrop.y;
+								m_path[i].pos.z = ground;
+								
+								m_path[i].type = ON_GROUND;
+							}						
+						}
+					}
+				}
+			}
+		}
+		else if ( to->how == GO_LADDER_UP )		// to get to next area, must go up a ladder
+		{
+			// find our ladder
+			const NavLadderConnectVector *ladders = from->area->GetLadders( CNavLadder::LADDER_UP );
+			int it;
+			for( it=0; it<ladders->Count(); ++it )
+			{
+				CNavLadder *ladder = (*ladders)[ it ].ladder;
+				
+				// can't use "behind" area when ascending...
+				if (ladder->m_topForwardArea == to->area ||
+					ladder->m_topLeftArea == to->area ||
+					ladder->m_topRightArea == to->area)
+				{
+					to->ladder = ladder;
+					to->pos = ladder->m_bottom + ladder->GetNormal() * 2.0f * HalfHumanWidth;
+					to->type = LADDER_UP;
+					break;
+				}
+			}
+			
+			if (it == ladders->Count())
+			{
+				//PrintIfWatched( "ERROR: Can't find ladder in path\n" );
+				return false;
+			}
+		}
+		else if ( to->how == GO_LADDER_DOWN )		// to get to next area, must go down a ladder
+		{
+			// find our ladder
+			const NavLadderConnectVector *ladders = from->area->GetLadders( CNavLadder::LADDER_DOWN );
+			int it;
+			for( it=0; it<ladders->Count(); ++it )
+			{
+				CNavLadder *ladder = (*ladders)[ it ].ladder;
+
+				if (ladder->m_bottomArea == to->area)
+				{
+					to->ladder = ladder;
+					to->pos = ladder->m_top;
+					to->pos = ladder->m_top - ladder->GetNormal() * 2.0f * HalfHumanWidth;
+					to->type = LADDER_DOWN;
+					break;
+				}
+			}
+
+			if (it == ladders->Count())
+			{
+				//PrintIfWatched( "ERROR: Can't find ladder in path\n" );
+				return false;
+			}
+		}
+		else if ( to->how == GO_ELEVATOR_UP || to->how == GO_ELEVATOR_DOWN )
+		{
+			to->pos = to->area->GetCenter();
+			to->ladder = NULL;
+		}
+	}
+
+
+	//
+	// Scan for non-adjacent nav areas and add gap-jump-target nodes
+	// and jump-up target nodes for adjacent ledge mantling
+	// @todo Adjacency should be baked into the mesh data
+	//
+	for( int i=0; i<m_segmentCount-1; ++i )
+	{
+		Segment *from = &m_path[ i ];
+		Segment *to = &m_path[ i+1 ];
+		
+		// first segment doesnt have a direction
+		if ( from->how != NUM_TRAVERSE_TYPES && from->how > GO_WEST )
+			continue;
+		
+		if ( to->how > GO_WEST || !to->type == ON_GROUND )
+			continue;
+
+		// if areas are separated, we may need to 'gap jump' between them
+		// add a node to minimize the jump distance
+		Vector closeFrom, closeTo;
+		to->area->GetClosestPointOnArea( from->pos, &closeTo );
+		from->area->GetClosestPointOnArea( closeTo, &closeFrom );
+		
+		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+		{
+			NDebugOverlay::Line( closeFrom, closeTo, 255, 0, 255, true, 5.0f );
+		}
+
+
+		const float separationTolerance = 1.9f * GenerationStepSize;
+		if ( (closeFrom - closeTo).AsVector2D().IsLengthGreaterThan( separationTolerance ) && ( closeTo - closeFrom ).AsVector2D().IsLengthGreaterThan( 0.5f * fabs( closeTo.z - closeFrom.z ) ) )
+		{
+			// areas are disjoint and mostly level - add gap jump target
+
+			// compute landing spot in 'to' area			
+			Vector landingPos;
+			to->area->GetClosestPointOnArea( to->pos, &landingPos );
+
+			// compute launch spot in 'from' area			
+			Vector launchPos;
+			from->area->GetClosestPointOnArea( landingPos, &launchPos );
+
+			Vector forward = landingPos - launchPos;
+			forward.NormalizeInPlace();
+			
+			const float halfWidth = hullWidth/2.0f;
+
+			// adjust path position to landing spot
+			to->pos = landingPos + forward * halfWidth;
+			
+			// insert launch position just before that segment to ensure bot is 
+			// positioned for minimal jump distance
+			Segment newSegment = *from;
+
+			newSegment.pos = launchPos - forward * halfWidth;
+			newSegment.type = JUMP_OVER_GAP;
+
+			InsertSegment( newSegment, i+1 );
+			
+			++i;
+		}
+		else if ( (closeTo.z - closeFrom.z) > stepHeight )
+		{
+			// areas are adjacent, but need a jump-up - add a jump-to target
+			
+			// adjust goal to be at top of ledge
+			//to->pos.z = to->area->GetZ( to->pos.x, to->pos.y );
+			// use center of climb-up destination area to make sure bot moves onto actual ground once they finish their climb
+			to->pos = to->area->GetCenter();
+			
+			// add launch position at base of jump	
+			Segment newSegment = *from;
+			
+			Vector launchPos;
+			from->area->GetClosestPointOnArea( to->pos, &launchPos );
+			
+			newSegment.pos = launchPos;
+			newSegment.type = CLIMB_UP;
+
+			if ( bot->IsDebugging( NEXTBOT_PATH ) )
+			{
+				NDebugOverlay::Cross3D( newSegment.pos, 15.0f, 255, 100, 255, true, 3.0f );
+			}
+
+			InsertSegment( newSegment, i+1 );
+
+			++i;			
+		}
+
+		/** RETHINK THIS.  It doesn't work in general cases, and messes up on doorways
+		else if ( from->type == ON_GROUND && from->how <= GO_WEST )
+		{
+			// if any segment is not directly walkable, add a segment
+			// fixup corners that are being cut too tightly
+			if ( mover && !mover->IsPotentiallyTraversable( from->pos, to->pos ) )
+			{
+				Segment newSegment = *from;
+				
+				if ( bot->IsDebugging( INextBot::PATH ) )
+				{
+					NDebugOverlay::HorzArrow( from->pos, to->pos, 3.0f, 255, 0, 0, 255, true, 3.0f );
+				}
+
+				//newSegment.pos = from->area->GetCenter();
+				
+				Vector2D shift;
+				DirectionToVector2D( OppositeDirection( (NavDirType)to->how ), &shift );
+												
+				newSegment.pos = to->pos;
+				newSegment.pos.x += hullWidth * shift.x;
+				newSegment.pos.y += hullWidth * shift.y;
+				
+				newSegment.type = ON_GROUND;
+
+				if ( bot->IsDebugging( INextBot::PATH ) )
+				{
+					NDebugOverlay::Cross3D( newSegment.pos, 15.0f, 255, 0, 255, true, 3.0f );
+				}
+
+				InsertSegment( newSegment, i+1 );
+				
+				i += 2;
+			}
+		}
+		*/
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Insert new segment at index i
+ */
+void Path::InsertSegment( Segment newSegment, int i )
+{
+	if (m_segmentCount < MAX_PATH_SEGMENTS-1)
+	{
+		// shift segments to make room for new one
+		for( int j=m_segmentCount; j>i; --j )
+			m_path[j] = m_path[j-1];
+
+		// path is one node longer
+		++m_segmentCount;
+
+		m_path[i] = newSegment;
+	}										
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Build trivial path when start and goal are in the same nav area
+ */
+bool Path::BuildTrivialPath( INextBot *bot, const Vector &goal )
+{
+	const Vector &start = bot->GetPosition();
+	
+	m_segmentCount = 0;
+
+	/// @todo Dangerous to use "nearset" nav area - could be far away
+	CNavArea *startArea = TheNavMesh->GetNearestNavArea( start );
+	if (startArea == NULL)
+		return false;
+
+	CNavArea *goalArea = TheNavMesh->GetNearestNavArea( goal );
+	if (goalArea == NULL)
+		return false;
+
+	m_segmentCount = 2;
+
+	m_path[0].area = startArea;
+	m_path[0].pos.x = start.x;
+	m_path[0].pos.y = start.y;
+	m_path[0].pos.z = startArea->GetZ( start );
+	m_path[0].ladder = NULL;
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+	m_path[0].type = ON_GROUND;
+
+	m_path[1].area = goalArea;
+	m_path[1].pos.x = goal.x;
+	m_path[1].pos.y = goal.y;
+	m_path[1].pos.z = goalArea->GetZ( goal );
+	m_path[1].ladder = NULL;
+	m_path[1].how = NUM_TRAVERSE_TYPES;
+	m_path[1].type = ON_GROUND;
+
+	m_path[0].forward = m_path[1].pos - m_path[0].pos;
+	m_path[0].length = m_path[0].forward.NormalizeInPlace();
+	m_path[0].distanceFromStart = 0.0f;
+	m_path[0].curvature = 0.0f;
+	
+	m_path[1].forward = m_path[0].forward;
+	m_path[1].length = 0.0f;
+	m_path[1].distanceFromStart = m_path[0].length;
+	m_path[1].curvature = 0.0f;
+
+	OnPathChanged( bot, COMPLETE_PATH );
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Draw the path for debugging.
+ */
+void Path::Draw( const Path::Segment *start ) const
+{
+	if ( !IsValid() )
+		return;
+
+	CFmtStr msg;
+
+	// limit length of path we draw
+	int count = NextBotPathDrawSegmentCount.GetInt();
+
+	const Segment *s = start ? start : FirstSegment();
+	int i=0;
+	while( s && count-- )
+	{
+		const Segment *next = NextSegment( s );
+		if ( next == NULL )
+		{
+			// end of the path
+			break;
+		}
+
+		Vector to = next->pos - s->pos;
+		float horiz = MAX( abs(to.x), abs(to.y) );
+		float vert = abs( to.z );
+
+		int r,g,b;
+		switch( s->type )
+		{
+			case DROP_DOWN:			r = 255; g =   0; b = 255; break;
+			case CLIMB_UP:			r =   0; g =   0; b = 255; break;
+			case JUMP_OVER_GAP:		r =   0; g = 255; b = 255; break;
+			case LADDER_UP:			r =   0; g = 255; b =   0; break;
+			case LADDER_DOWN:		r =   0; g = 100; b =   0; break;
+			default:				r = 255; g =  77; b =   0; break;		// ON_GROUND
+		}
+
+		if ( s->ladder )
+		{
+			NDebugOverlay::VertArrow( s->ladder->m_bottom, s->ladder->m_top, 5.0f, r, g, b, 255, true, 0.1f );
+		}
+		else
+		{
+			NDebugOverlay::Line( s->pos, next->pos, r, g, b, true, 0.1f );		
+		}
+
+		const float nodeLength = 25.0f;
+		if ( horiz > vert )
+		{
+			NDebugOverlay::HorzArrow( s->pos, s->pos + nodeLength * s->forward, 5.0f, r, g, b, 255, true, 0.1f );
+		}
+		else
+		{
+			NDebugOverlay::VertArrow( s->pos, s->pos + nodeLength * s->forward, 5.0f, r, g, b, 255, true, 0.1f );
+		}
+
+		NDebugOverlay::Text( s->pos, msg.sprintf( "%d", i ), true, 0.1f );
+
+		//NDebugOverlay::Text( s->pos, msg.sprintf( "%d  (%3.2f)", i, s->curvature ), false, 0.1f );
+
+		s = next;
+		++i;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Draw the path for debugging - MODIFIES cursor position
+ */
+void Path::DrawInterpolated( float from, float to )
+{
+	if ( !IsValid() )
+	{
+		return;
+	}
+	
+	float t = from;
+
+	MoveCursor( t );
+	const Data &data = GetCursorData();
+	Vector lastPos = data.pos;	
+
+	do
+	{
+		t += NextBotPathDrawIncrement.GetFloat();
+
+		MoveCursor( t );
+		const Data &data = GetCursorData();
+		
+		float curvePower = 3.0f * data.curvature;
+
+		int r = 255 * ( 1.0f - curvePower );
+		r = clamp( r, 0, 255 );
+		
+		int g = 255 * ( 1.0f + curvePower );
+		g = clamp( g, 0, 255 );
+				
+		NDebugOverlay::Line( lastPos, data.pos, r, g, 0, true, 0.1f );
+
+		/*
+		int i = 0xFF & (int)( data.pos.x + data.pos.y + data.pos.z );
+		i >>= 1;
+		i += 128;
+		
+		NDebugOverlay::Line( data.pos, data.pos + 10.0f * data.forward, 0, i, i, true, 0.1f );
+		*/
+
+		lastPos = data.pos;
+	}
+	while( t < to );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Check line of sight from 'anchor' node on path to subsequent nodes until
+ * we find a node that can't been seen from 'anchor'.
+ */
+int Path::FindNextOccludedNode( INextBot *bot, int anchorIndex )
+{
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	if ( mover == NULL)
+	{
+		return m_segmentCount;
+	}
+	
+	Segment *anchor = &m_path[ anchorIndex ];
+	
+	for( int i=anchorIndex+1; i<m_segmentCount; ++i )
+	{
+		Segment *to = &m_path[i];
+		
+		// if this segment is not on the ground, or is precise, don't skip past it
+		if ( !to->type == ON_GROUND || (to->area->GetAttributes() & NAV_MESH_PRECISE) )
+		{
+			return i;
+		}
+
+		if ( !mover->IsPotentiallyTraversable( anchor->pos, to->pos, ILocomotion::IMMEDIATELY ) )
+		{
+			// cant reach this node directly from anchor node
+			return i;
+		}
+
+		if ( mover->HasPotentialGap( anchor->pos, to->pos ) )
+		{
+			// we would fall into a gap if we took this cutoff
+			return i;
+		}
+	}
+
+	return m_segmentCount;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Smooth out path, removing redundant nodes
+ */
+void Path::Optimize( INextBot *bot )
+{
+	// this is SUPER expensive - especially the IsGap() check
+	return;
+
+	VPROF_BUDGET( "Path::Optimize", "NextBot" );
+
+	if (m_segmentCount < 3)
+		return;
+
+	int anchor = 0;
+
+	while( anchor < m_segmentCount )
+	{
+		int occluded = FindNextOccludedNode( bot, anchor );
+		int nextAnchor = occluded-1;
+
+		if (nextAnchor > anchor)
+		{
+			// remove redundant nodes between anchor and nextAnchor
+			int removeCount = nextAnchor - anchor - 1;
+			if (removeCount > 0)
+			{
+				for( int i=nextAnchor; i<m_segmentCount; ++i )
+				{
+					m_path[i-removeCount] = m_path[i];
+				}
+				m_segmentCount -= removeCount;
+			}
+		}
+
+		++anchor;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute final data for completed path
+ */
+void Path::PostProcess( void )
+{
+	VPROF_BUDGET( "Path::PostProcess", "NextBot" );
+
+	m_ageTimer.Start();
+
+	if (m_segmentCount == 0)
+		return;
+		
+	if (m_segmentCount == 1)
+	{
+		m_path[0].forward = vec3_origin;
+		m_path[0].length = 0.0f;
+		m_path[0].distanceFromStart = 0.0f;
+		m_path[0].curvature = 0.0f;
+		return;
+	}
+	
+	float distanceSoFar = 0.0f;
+	int i;
+	for( i=0; i < m_segmentCount-1; ++i )
+	{
+		Segment *from = &m_path[ i ];
+		Segment *to = &m_path[ i+1 ];
+		
+		from->forward = to->pos - from->pos;
+		from->length = from->forward.NormalizeInPlace();
+		
+		from->distanceFromStart = distanceSoFar;
+
+		distanceSoFar += from->length;
+	}
+	
+		
+	// compute curvature in XY plane
+	Vector2D from, to;
+	for( i=1; i < m_segmentCount-1; ++i )
+	{
+		if (m_path[ i ].type != ON_GROUND)
+		{
+			m_path[ i ].curvature = 0.0f;
+		}
+		else
+		{
+			from = m_path[ i-1 ].forward.AsVector2D();
+			from.NormalizeInPlace();
+			
+			to = m_path[ i ].forward.AsVector2D();
+			to.NormalizeInPlace();	
+		
+			m_path[ i ].curvature = 0.5f * ( 1.0f - from.Dot( to ) );
+			
+			Vector2D right( -from.y, from.x );
+			if ( to.Dot( right ) < 0.0f )
+			{
+				m_path[ i ].curvature = -m_path[ i ].curvature;
+			}
+		}
+	}
+
+	// first segment has no curvature
+	m_path[ 0 ].curvature = 0.0f;
+	
+	// last segment maintains direction
+	m_path[ i ].forward = m_path[ i-1 ].forward;
+	m_path[ i ].length = 0.0f;
+	m_path[ i ].distanceFromStart = distanceSoFar;
+	m_path[ i ].curvature = 0.0f;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return a position on the path at the given distance from the path start
+ */
+const Vector &Path::GetPosition( float distanceFromStart, const Segment *start ) const
+{
+	if (!IsValid())
+	{
+		return vec3_origin;
+	}
+
+	float lengthSoFar;
+	const Segment *segment;
+	
+	if (start)
+	{
+		segment = start;
+		lengthSoFar = start->distanceFromStart;
+	}
+	else
+	{
+		segment = &m_path[0];
+		lengthSoFar = 0.0f;
+	}
+
+	if (segment->distanceFromStart > distanceFromStart)
+	{
+		// clamp to path start
+		return segment->pos;
+	}
+
+	
+	const Segment *next = NextSegment( segment );
+
+	Vector delta;
+	float length;
+
+	while( next )
+	{
+		delta = next->pos - segment->pos;
+		length = segment->length;
+
+		if (lengthSoFar + length >= distanceFromStart)
+		{
+			// desired point is on this segment of the path
+			float overlap = distanceFromStart - lengthSoFar;
+			float t = overlap / length;
+
+			m_pathPos = segment->pos + t * delta;
+			
+			return m_pathPos;
+		}
+
+		lengthSoFar += length;
+		
+		segment = next;
+		next = NextSegment( next );
+	}
+
+	// clamp to path end
+	return segment->pos;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest point on the path to the given position
+ */
+const Vector &Path::GetClosestPosition( const Vector &pos, const Segment *start, float alongLimit ) const
+{
+	const Segment *segment = (start) ? start : &m_path[0];
+	
+	if (segment == NULL)
+	{
+		return pos;
+	}
+	
+	m_closePos = pos;
+	float closeRangeSq = 99999999999.9f;
+
+	float distanceSoFar = 0.0f;	
+	while( alongLimit == 0.0f || distanceSoFar <= alongLimit )
+	{
+		const Segment *nextSegment = NextSegment( segment );
+		
+		if (nextSegment)
+		{
+			Vector close;
+			CalcClosestPointOnLineSegment( pos, segment->pos, nextSegment->pos, close );
+			float rangeSq = (close - pos).LengthSqr();
+			if (rangeSq < closeRangeSq)
+			{	
+				m_closePos = close;
+				closeRangeSq = rangeSq;
+			}
+		}
+		else
+		{
+			// end of the path
+			break;
+		}
+		
+		distanceSoFar += segment->length;
+		segment = nextSegment;
+	}
+	
+	return m_closePos;
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Replace this path with the given path's data
+ */
+void Path::Copy( INextBot *bot, const Path &path )
+{
+	VPROF_BUDGET( "Path::Copy", "NextBot" );
+
+	Invalidate();
+	
+	for( int i = 0; i < path.m_segmentCount; ++i )
+	{
+		m_path[i] = path.m_path[i];
+	}
+	m_segmentCount = path.m_segmentCount;
+
+	OnPathChanged( bot, COMPLETE_PATH );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Set cursor position to closest point on path to given position
+ */
+void Path::MoveCursorToClosestPosition( const Vector &pos, SeekType type, float alongLimit ) const
+{
+	if ( !IsValid() )
+	{
+		return;
+	}
+	
+	if ( type == SEEK_ENTIRE_PATH || type == SEEK_AHEAD )
+	{
+		const Segment *segment;
+		
+		if ( type == SEEK_AHEAD )
+		{
+			// continue search from cursor position onward
+			if ( m_cursorData.segmentPrior )
+			{
+				segment = m_cursorData.segmentPrior;
+			}
+			else
+			{
+				// no prior segment, start from the start
+				segment = &m_path[ 0 ];
+			}
+		}
+		else
+		{
+			// search entire path from the start
+			segment = &m_path[ 0 ];
+		}
+
+		m_cursorData.pos = pos;
+		m_cursorData.segmentPrior = segment;
+		float closeRangeSq = 99999999999.9f;
+
+		float distanceSoFar = 0.0f;	
+		while( alongLimit == 0.0f || distanceSoFar <= alongLimit )
+		{
+			const Segment *nextSegment = NextSegment( segment );
+
+			if ( nextSegment )
+			{
+				Vector close;
+				CalcClosestPointOnLineSegment( pos, segment->pos, nextSegment->pos, close );
+				
+				float rangeSq = ( close - pos ).LengthSqr();
+				if ( rangeSq < closeRangeSq )
+				{	
+					m_cursorData.pos = close;
+					m_cursorData.segmentPrior = segment;
+					
+					closeRangeSq = rangeSq;
+				}
+			}
+			else
+			{
+				// end of the path
+				break;
+			}
+
+			distanceSoFar += segment->length;
+			segment = nextSegment;
+		}
+
+		//
+		// Move cursor to closest point on path
+		//
+		segment = m_cursorData.segmentPrior;
+				
+		float t = ( m_cursorData.pos - segment->pos ).Length() / segment->length;
+
+		m_cursorPos = segment->distanceFromStart + t * segment->length;	
+		m_isCursorDataDirty = true;
+	}
+	else
+	{
+		AssertMsg( false, "SEEK_BEHIND not implemented" );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return path state at the current cursor position
+ */
+const Path::Data &Path::GetCursorData( void ) const
+{
+	if ( IsValid() )
+	{
+		if ( m_isCursorDataDirty )
+		{
+			const float epsilon = 0.0001f;
+			if ( m_cursorPos < epsilon || m_segmentCount < 2 )
+			{
+				// start of path
+				m_cursorData.pos = m_path[0].pos;
+				m_cursorData.forward = m_path[0].forward;
+				m_cursorData.curvature = m_path[0].curvature;
+				m_cursorData.segmentPrior = &m_path[0];
+			}
+			else if ( m_cursorPos > GetLength() - epsilon )
+			{
+				// end of path
+				m_cursorData.pos = m_path[ m_segmentCount-1 ].pos;
+				m_cursorData.forward = m_path[ m_segmentCount-1 ].forward;
+				m_cursorData.curvature = m_path[ m_segmentCount-1 ].curvature;
+				m_cursorData.segmentPrior = &m_path[ m_segmentCount-1 ];
+			}
+			else
+			{
+				// along path
+				float lengthSoFar = 0.0f;
+				const Segment *segment = &m_path[0];
+
+				const Segment *next = NextSegment( segment );
+
+				while( next )
+				{
+					float length = segment->length;
+
+					if ( lengthSoFar + length >= m_cursorPos )
+					{
+						// desired point is on this segment of the path
+						float overlap = m_cursorPos - lengthSoFar;
+						float t = 1.0f;	// 0-length segments are assumed to be complete, to avoid NaNs
+						if ( length > 0.0f )
+						{
+							t = overlap / length;
+						}
+						
+						// interpolate data at this point along the path
+						m_cursorData.pos = segment->pos + t * ( next->pos - segment->pos );
+						m_cursorData.forward = segment->forward + t * ( next->forward - segment->forward );
+						m_cursorData.segmentPrior = segment;
+
+						// curvature fades to zero along midpoint of long straight segments
+						// and is influenced as it nears ends of segment
+						if ( overlap < NextBotPathSegmentInfluenceRadius.GetFloat() )
+						{
+							if ( length - overlap < NextBotPathSegmentInfluenceRadius.GetFloat() )
+							{
+								// near start and end - interpolate
+								float startCurvature = segment->curvature * ( 1.0f - ( overlap / NextBotPathSegmentInfluenceRadius.GetFloat() ) );
+								float endCurvature = next->curvature * ( 1.0f - ( ( length - overlap ) / NextBotPathSegmentInfluenceRadius.GetFloat() ) );
+
+								m_cursorData.curvature = ( startCurvature + endCurvature ) / 2.0f;
+							}
+							else
+							{
+								// near start only
+								m_cursorData.curvature = segment->curvature * ( 1.0f - ( overlap / NextBotPathSegmentInfluenceRadius.GetFloat() ) );
+							}
+						}
+						else if ( length - overlap < NextBotPathSegmentInfluenceRadius.GetFloat() )
+						{
+							// near end only
+							m_cursorData.curvature = next->curvature * ( 1.0f - ( ( length - overlap ) / NextBotPathSegmentInfluenceRadius.GetFloat() ) );
+						}
+
+						
+						break;
+					}
+
+					lengthSoFar += length;
+
+					segment = next;
+					next = NextSegment( next );
+				}
+			}
+			
+			// data is up to date
+			m_isCursorDataDirty = false;
+		}
+	}
+	else
+	{
+		// path is not valid
+		m_cursorData.pos = vec3_origin;
+		m_cursorData.forward = Vector( 1.0f, 0, 0 );
+		m_cursorData.curvature = 0.0f;
+		m_cursorData.segmentPrior = NULL;
+	}
+	
+	return m_cursorData;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine exactly where the path goes between the given two areas
+ * on the path. Return this point in 'crossPos'.
+ */
+void Path::ComputeAreaCrossing( INextBot *bot, const CNavArea *from, const Vector &fromPos, const CNavArea *to, NavDirType dir, Vector *crossPos ) const
+{
+	from->ComputeClosestPointInPortal( to, dir, fromPos, crossPos );
+
+	// move goal position into the goal area a bit to avoid running directly along the edge of an area against a wall, etc
+	// don't do this unless area is against a wall - and what if our hull is wider than the area?
+	// AddDirectionVector( crossPos, dir, bot->GetBodyInterface()->GetHullWidth()/2.0f );
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/game/server/NextBot/Path/NextBotPath.h b/game/server/NextBot/Path/NextBotPath.h
new file mode 100644
index 00000000..6669d926
--- /dev/null
+++ b/game/server/NextBot/Path/NextBotPath.h
@@ -0,0 +1,862 @@
+// NextBotPath.h
+// Encapsulate and manipulate a path through the world
+// Author: Michael Booth, February 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_PATH_H_
+#define _NEXT_BOT_PATH_H_
+
+#include "NextBotInterface.h"
+
+#include "tier0/vprof.h"
+
+#define PATH_NO_LENGTH_LIMIT 0.0f				// non-default argument value for Path::Compute()
+#define PATH_TRUNCATE_INCOMPLETE_PATH false		// non-default argument value for Path::Compute()
+
+class INextBot;
+class CNavArea;
+class CNavLadder;
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for pathfinding costs.
+ * TODO: Replace all template cost functors with this interface, so we can virtualize and derive from them.
+ */
+class IPathCost
+{
+public:
+	virtual float operator()( CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder, const CFuncElevator *elevator, float length ) const = 0;
+};
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for selecting a goal area during "open goal" pathfinding
+ */
+class IPathOpenGoalSelector
+{
+public:
+	// compare "newArea" to "currentGoal" and return the area that is the better goal area
+	virtual CNavArea *operator() ( CNavArea *currentGoal, CNavArea *newArea ) const = 0;
+};
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A Path through the world.
+ * Not only does this encapsulate a path to get from point A to point B,
+ * but also the selecting the decision algorithm for how to build that path.
+ */
+class Path
+{
+public:
+	Path( void );
+	virtual ~Path() { }
+	
+	enum SegmentType
+	{
+		ON_GROUND,
+		DROP_DOWN,
+		CLIMB_UP,
+		JUMP_OVER_GAP,
+		LADDER_UP,
+		LADDER_DOWN,
+		
+		NUM_SEGMENT_TYPES
+	};
+
+	// @todo Allow custom Segment classes for different kinds of paths	
+	struct Segment
+	{
+		CNavArea *area;									// the area along the path
+		NavTraverseType how;							// how to enter this area from the previous one
+		Vector pos;										// our movement goal position at this point in the path
+		const CNavLadder *ladder;						// if "how" refers to a ladder, this is it
+		
+		SegmentType type;								// how to traverse this segment of the path
+		Vector forward;									// unit vector along segment
+		float length;									// length of this segment
+		float distanceFromStart;						// distance of this node from the start of the path
+		float curvature;								// how much the path 'curves' at this point in the XY plane (0 = none, 1 = 180 degree doubleback)
+
+		Vector m_portalCenter;							// position of center of 'portal' between previous area and this area
+		float m_portalHalfWidth;						// half width of 'portal'
+	};
+
+	virtual float GetLength( void ) const;						// return length of path from start to finish
+	virtual const Vector &GetPosition( float distanceFromStart, const Segment *start = NULL ) const;	// return a position on the path at the given distance from the path start
+	virtual const Vector &GetClosestPosition( const Vector &pos, const Segment *start = NULL, float alongLimit = 0.0f ) const;		// return the closest point on the path to the given position
+
+	virtual const Vector &GetStartPosition( void ) const;	// return the position where this path starts
+	virtual const Vector &GetEndPosition( void ) const;		// return the position where this path ends
+	virtual CBaseCombatCharacter *GetSubject( void ) const;	// return the actor this path leads to, or NULL if there is no subject
+
+	virtual const Path::Segment *GetCurrentGoal( void ) const;	// return current goal along the path we are trying to reach
+
+	virtual float GetAge( void ) const;					// return "age" of this path (time since it was built)
+
+	enum SeekType
+	{
+		SEEK_ENTIRE_PATH,			// search the entire path length
+		SEEK_AHEAD,					// search from current cursor position forward toward end of path
+		SEEK_BEHIND					// search from current cursor position backward toward path start
+	};
+	virtual void MoveCursorToClosestPosition( const Vector &pos, SeekType type = SEEK_ENTIRE_PATH, float alongLimit = 0.0f ) const;		// Set cursor position to closest point on path to given position
+	
+	enum MoveCursorType
+	{
+		PATH_ABSOLUTE_DISTANCE,
+		PATH_RELATIVE_DISTANCE
+	};
+	virtual void MoveCursorToStart( void );				// set seek cursor to start of path
+	virtual void MoveCursorToEnd( void );				// set seek cursor to end of path
+	virtual void MoveCursor( float value, MoveCursorType type = PATH_ABSOLUTE_DISTANCE );	// change seek cursor position
+	virtual float GetCursorPosition( void ) const;		// return position of seek cursor (distance along path)
+
+	struct Data
+	{
+		Vector pos;										// the position along the path
+		Vector forward;									// unit vector along path direction
+		float curvature;								// how much the path 'curves' at this point in the XY plane (0 = none, 1 = 180 degree doubleback)
+		const Segment *segmentPrior;					// the segment just before this position
+	};
+	virtual const Data &GetCursorData( void ) const;	// return path state at the current cursor position
+
+	virtual bool IsValid( void ) const;
+	virtual void Invalidate( void );					// make path invalid (clear it)
+
+	virtual void Draw( const Path::Segment *start = NULL ) const;	// draw the path for debugging
+	virtual void DrawInterpolated( float from, float to );	// draw the path for debugging - MODIFIES cursor position
+
+	virtual const Segment *FirstSegment( void ) const;	// return first segment of path
+	virtual const Segment *NextSegment( const Segment *currentSegment ) const;	// return next segment of path, given current one
+	virtual const Segment *PriorSegment( const Segment *currentSegment ) const;	// return previous segment of path, given current one
+	virtual const Segment *LastSegment( void ) const;	// return last segment of path
+
+	enum ResultType
+	{
+		COMPLETE_PATH,
+		PARTIAL_PATH,
+		NO_PATH
+	};
+	virtual void OnPathChanged( INextBot *bot, ResultType result ) { }		// invoked when the path is (re)computed (path is valid at the time of this call)
+
+	virtual void Copy( INextBot *bot, const Path &path );	// Replace this path with the given path's data
+
+
+	//-----------------------------------------------------------------------------------------------------------------
+	/**
+	 * Compute shortest path from bot to given actor via A* algorithm.
+	 * If returns true, path was found to the subject.
+	 * If returns false, path may either be invalid (use IsValid() to check), or valid but 
+	 * doesn't reach all the way to the subject.
+	 */
+	template< typename CostFunctor >
+	bool Compute( INextBot *bot, CBaseCombatCharacter *subject, CostFunctor &costFunc, float maxPathLength = 0.0f, bool includeGoalIfPathFails = true )
+	{
+		VPROF_BUDGET( "Path::Compute(subject)", "NextBot" );
+
+		Invalidate();
+
+		m_subject = subject;
+		
+		const Vector &start = bot->GetPosition();
+		
+		CNavArea *startArea = bot->GetEntity()->GetLastKnownArea();
+		if ( !startArea )
+		{
+			OnPathChanged( bot, NO_PATH );
+			return false;
+		}
+
+		CNavArea *subjectArea = subject->GetLastKnownArea();
+		if ( !subjectArea )
+		{
+			OnPathChanged( bot, NO_PATH );
+			return false;
+		}
+
+		Vector subjectPos = subject->GetAbsOrigin();
+		
+		// if we are already in the subject area, build trivial path
+		if ( startArea == subjectArea )
+		{
+			BuildTrivialPath( bot, subjectPos );
+			return true;
+		}
+
+		//
+		// Compute shortest path to subject
+		//
+		CNavArea *closestArea = NULL;
+		bool pathResult = NavAreaBuildPath( startArea, subjectArea, &subjectPos, costFunc, &closestArea, maxPathLength, bot->GetEntity()->GetTeamNumber() );
+
+		// Failed?
+		if ( closestArea == NULL )
+			return false;
+
+		//
+		// Build actual path by following parent links back from goal area
+		//
+
+		// get count
+		int count = 0;
+		CNavArea *area;
+		for( area = closestArea; area; area = area->GetParent() )
+		{
+			++count;
+
+			if ( area == startArea )
+			{
+				// startArea can be re-evaluated during the pathfind and given a parent...
+				break;
+			}
+			if ( count >= MAX_PATH_SEGMENTS-1 ) // save room for endpoint
+				break;
+		}
+		
+		if ( count == 1 )
+		{
+			BuildTrivialPath( bot, subjectPos );
+			return pathResult;
+		}
+
+		// assemble path
+		m_segmentCount = count;
+		for( area = closestArea; count && area; area = area->GetParent() )
+		{
+			--count;
+			m_path[ count ].area = area;
+			m_path[ count ].how = area->GetParentHow();
+			m_path[ count ].type = ON_GROUND;
+		}
+
+		if ( pathResult || includeGoalIfPathFails )
+		{
+			// append actual subject position
+			m_path[ m_segmentCount ].area = closestArea;
+			m_path[ m_segmentCount ].pos = subjectPos;
+			m_path[ m_segmentCount ].ladder = NULL;
+			m_path[ m_segmentCount ].how = NUM_TRAVERSE_TYPES;
+			m_path[ m_segmentCount ].type = ON_GROUND;
+			++m_segmentCount;
+		}
+				
+		// compute path positions
+		if ( ComputePathDetails( bot, start ) == false )
+		{
+			Invalidate();
+			OnPathChanged( bot, NO_PATH );
+			return false;
+		}
+
+		// remove redundant nodes and clean up path
+		Optimize( bot );
+		
+		PostProcess();
+
+		OnPathChanged( bot, pathResult ? COMPLETE_PATH : PARTIAL_PATH );
+
+		return pathResult;
+	}
+
+
+	//-----------------------------------------------------------------------------------------------------------------
+	/**
+	 * Compute shortest path from bot to 'goal' via A* algorithm.
+	 * If returns true, path was found to the goal position.
+	 * If returns false, path may either be invalid (use IsValid() to check), or valid but 
+	 * doesn't reach all the way to the goal.
+	 */
+	template< typename CostFunctor >
+	bool Compute( INextBot *bot, const Vector &goal, CostFunctor &costFunc, float maxPathLength = 0.0f, bool includeGoalIfPathFails = true )
+	{
+		VPROF_BUDGET( "Path::Compute(goal)", "NextBotSpiky" );
+
+		Invalidate();
+		
+		const Vector &start = bot->GetPosition();
+		
+		CNavArea *startArea = bot->GetEntity()->GetLastKnownArea();
+		if ( !startArea )
+		{
+			OnPathChanged( bot, NO_PATH );
+			return false;
+		}
+
+		// check line-of-sight to the goal position when finding it's nav area
+		const float maxDistanceToArea = 200.0f;
+		CNavArea *goalArea = TheNavMesh->GetNearestNavArea( goal, true, maxDistanceToArea, true );
+
+		// if we are already in the goal area, build trivial path
+		if ( startArea == goalArea )
+		{
+			BuildTrivialPath( bot, goal );
+			return true;
+		}
+
+		// make sure path end position is on the ground
+		Vector pathEndPosition = goal;
+		if ( goalArea )
+		{
+			pathEndPosition.z = goalArea->GetZ( pathEndPosition );
+		}
+		else
+		{
+			TheNavMesh->GetGroundHeight( pathEndPosition, &pathEndPosition.z );
+		}
+
+		//
+		// Compute shortest path to goal
+		//
+		CNavArea *closestArea = NULL;
+		bool pathResult = NavAreaBuildPath( startArea, goalArea, &goal, costFunc, &closestArea, maxPathLength, bot->GetEntity()->GetTeamNumber() );
+
+		// Failed?
+		if ( closestArea == NULL )
+			return false;
+
+		//
+		// Build actual path by following parent links back from goal area
+		//
+
+		// get count
+		int count = 0;
+		CNavArea *area;
+		for( area = closestArea; area; area = area->GetParent() )
+		{
+			++count;
+
+			if ( area == startArea )
+			{
+				// startArea can be re-evaluated during the pathfind and given a parent...
+				break;
+			}
+			if ( count >= MAX_PATH_SEGMENTS-1 ) // save room for endpoint
+				break;
+		}
+		
+		if ( count == 1 )
+		{
+			BuildTrivialPath( bot, goal );
+			return pathResult;
+		}
+
+		// assemble path
+		m_segmentCount = count;
+		for( area = closestArea; count && area; area = area->GetParent() )
+		{
+			--count;
+			m_path[ count ].area = area;
+			m_path[ count ].how = area->GetParentHow();
+			m_path[ count ].type = ON_GROUND;
+		}
+
+		if ( pathResult || includeGoalIfPathFails )
+		{
+			// append actual goal position
+			m_path[ m_segmentCount ].area = closestArea;
+			m_path[ m_segmentCount ].pos = pathEndPosition;
+			m_path[ m_segmentCount ].ladder = NULL;
+			m_path[ m_segmentCount ].how = NUM_TRAVERSE_TYPES;
+			m_path[ m_segmentCount ].type = ON_GROUND;
+			++m_segmentCount;
+		}
+				
+		// compute path positions
+		if ( ComputePathDetails( bot, start ) == false )
+		{
+			Invalidate();
+			OnPathChanged( bot, NO_PATH );
+			return false;
+		}
+
+		// remove redundant nodes and clean up path
+		Optimize( bot );
+		
+		PostProcess();
+
+		OnPathChanged( bot, pathResult ? COMPLETE_PATH : PARTIAL_PATH );
+
+		return pathResult;
+	}
+
+
+	//-----------------------------------------------------------------------------------------------------------------
+	/**
+	 * Build a path from bot's current location to an undetermined goal area
+	 * that minimizes the given cost along the final path and meets the
+	 * goal criteria.
+	 */
+	virtual bool ComputeWithOpenGoal( INextBot *bot, const IPathCost &costFunc, const IPathOpenGoalSelector &goalSelector, float maxSearchRadius = 0.0f )
+	{
+		VPROF_BUDGET( "ComputeWithOpenGoal", "NextBot" );
+
+		int teamID = bot->GetEntity()->GetTeamNumber();
+
+		CNavArea *startArea = bot->GetEntity()->GetLastKnownArea();
+
+		if ( startArea == NULL )
+			return NULL;
+
+		startArea->SetParent( NULL );
+
+		// start search
+		CNavArea::ClearSearchLists();
+
+		float initCost = costFunc( startArea, NULL, NULL, NULL, -1.0f );
+		if ( initCost < 0.0f )
+			return NULL;
+
+		startArea->SetTotalCost( initCost );
+		startArea->AddToOpenList();
+
+		// find our goal as we search
+		CNavArea *goalArea = NULL;
+
+		//
+		// Dijkstra's algorithm (since we don't know our goal).
+		//
+		while( !CNavArea::IsOpenListEmpty() )
+		{
+			// get next area to check
+			CNavArea *area = CNavArea::PopOpenList();
+
+			area->AddToClosedList();
+
+			// don't consider blocked areas
+			if ( area->IsBlocked( teamID ) )
+				continue;
+
+			// build adjacent area array
+			CollectAdjacentAreas( area );
+
+			// search adjacent areas
+			for( int i=0; i<m_adjAreaIndex; ++i )
+			{
+				CNavArea *newArea = m_adjAreaVector[ i ].area;
+
+				// only visit each area once
+				if ( newArea->IsClosed() )
+					continue;
+
+				// don't consider blocked areas
+				if ( newArea->IsBlocked( teamID ) )
+					continue;
+
+				// don't use this area if it is out of range
+				if ( maxSearchRadius > 0.0f && ( newArea->GetCenter() - bot->GetEntity()->GetAbsOrigin() ).IsLengthGreaterThan( maxSearchRadius ) )
+					continue;
+
+				// determine cost of traversing this area
+				float newCost = costFunc( newArea, area, m_adjAreaVector[ i ].ladder, NULL, -1.0f );
+
+				// don't use adjacent area if cost functor says it is a dead-end
+				if ( newCost < 0.0f )
+					continue;
+
+				if ( newArea->IsOpen() && newArea->GetTotalCost() <= newCost )
+				{
+					// we have already visited this area, and it has a better path
+					continue;
+				}
+				else
+				{
+					// whether this area has been visited or not, we now have a better path to it
+					newArea->SetParent( area, m_adjAreaVector[ i ].how );
+					newArea->SetTotalCost( newCost );
+
+					// use 'cost so far' to hold cumulative cost
+					newArea->SetCostSoFar( newCost );
+
+					// tricky bit here - relying on OpenList being sorted by cost
+					if ( newArea->IsOpen() )
+					{
+						// area already on open list, update the list order to keep costs sorted
+						newArea->UpdateOnOpenList();
+					}
+					else
+					{
+						newArea->AddToOpenList();
+					}
+
+					// keep track of best goal so far
+					goalArea = goalSelector( goalArea, newArea );
+				}
+			}
+		}
+
+		if ( goalArea )
+		{
+			// compile the path details into a usable path
+			AssemblePrecomputedPath( bot, goalArea->GetCenter(), goalArea );
+			return true;
+		}	
+
+		// all adjacent areas are likely too far away
+		return false;
+	}
+
+
+	//-----------------------------------------------------------------------------------------------------------------
+	/**
+	 * Given the last area in a path with valid parent pointers, 
+	 * construct the actual path.
+	 */
+	void AssemblePrecomputedPath( INextBot *bot, const Vector &goal, CNavArea *endArea )
+	{
+		VPROF_BUDGET( "AssemblePrecomputedPath", "NextBot" );
+
+		const Vector &start = bot->GetPosition();
+
+		// get count
+		int count = 0;
+		CNavArea *area;
+		for( area = endArea; area; area = area->GetParent() )
+		{
+			++count;
+		}
+
+		// save room for endpoint
+		if ( count > MAX_PATH_SEGMENTS-1 )
+		{
+			count = MAX_PATH_SEGMENTS-1;
+		}
+		else if ( count == 0 )
+		{
+			return;
+		}
+
+		if ( count == 1 )
+		{
+			BuildTrivialPath( bot, goal );
+			return;
+		}
+
+		// assemble path
+		m_segmentCount = count;
+		for( area = endArea; count && area; area = area->GetParent() )
+		{
+			--count;
+			m_path[ count ].area = area;
+			m_path[ count ].how = area->GetParentHow();
+			m_path[ count ].type = ON_GROUND;
+		}
+
+		// append actual goal position
+		m_path[ m_segmentCount ].area = endArea;
+		m_path[ m_segmentCount ].pos = goal;
+		m_path[ m_segmentCount ].ladder = NULL;
+		m_path[ m_segmentCount ].how = NUM_TRAVERSE_TYPES;
+		m_path[ m_segmentCount ].type = ON_GROUND;
+		++m_segmentCount;
+
+		// compute path positions
+		if ( ComputePathDetails( bot, start ) == false )
+		{
+			Invalidate();
+			OnPathChanged( bot, NO_PATH );
+			return;
+		}
+
+		// remove redundant nodes and clean up path
+		Optimize( bot );
+
+		PostProcess();
+
+		OnPathChanged( bot, COMPLETE_PATH );
+	}
+
+	/**
+	 * Utility function for when start and goal are in the same area
+	 */
+	bool BuildTrivialPath( INextBot *bot, const Vector &goal );	
+
+	/**
+	 * Determine exactly where the path goes between the given two areas
+	 * on the path. Return this point in 'crossPos'.
+	 */
+	virtual void ComputeAreaCrossing( INextBot *bot, const CNavArea *from, const Vector &fromPos, const CNavArea *to, NavDirType dir, Vector *crossPos ) const;
+
+
+private:
+	enum { MAX_PATH_SEGMENTS = 256 };
+	Segment m_path[ MAX_PATH_SEGMENTS ];
+	int m_segmentCount;
+
+	bool ComputePathDetails( INextBot *bot, const Vector &start );		// determine actual path positions 
+
+	void Optimize( INextBot *bot );
+	void PostProcess( void );
+	int FindNextOccludedNode( INextBot *bot, int anchor );	// used by Optimize()
+
+	void InsertSegment( Segment newSegment, int i );		// insert new segment at index i
+	
+	mutable Vector m_pathPos;								// used by GetPosition()
+	mutable Vector m_closePos;								// used by GetClosestPosition()
+
+	mutable float m_cursorPos;					// current cursor position (distance along path)
+	mutable Data m_cursorData;					// used by GetCursorData()
+	mutable bool m_isCursorDataDirty;
+
+	IntervalTimer m_ageTimer;					// how old is this path?
+	CHandle< CBaseCombatCharacter > m_subject;	// the subject this path leads to
+
+	/**
+	 * Build a vector of adjacent areas reachable from the given area
+	 */
+	void CollectAdjacentAreas( CNavArea *area )
+	{
+		m_adjAreaIndex = 0;			
+
+		const NavConnectVector &adjNorth = *area->GetAdjacentAreas( NORTH );		
+		FOR_EACH_VEC( adjNorth, it )
+		{
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			m_adjAreaVector[ m_adjAreaIndex ].area = adjNorth[ it ].area;
+			m_adjAreaVector[ m_adjAreaIndex ].how = GO_NORTH;
+			m_adjAreaVector[ m_adjAreaIndex ].ladder = NULL;
+			++m_adjAreaIndex;
+		}
+
+		const NavConnectVector &adjSouth = *area->GetAdjacentAreas( SOUTH );		
+		FOR_EACH_VEC( adjSouth, it )
+		{
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			m_adjAreaVector[ m_adjAreaIndex ].area = adjSouth[ it ].area;
+			m_adjAreaVector[ m_adjAreaIndex ].how = GO_SOUTH;
+			m_adjAreaVector[ m_adjAreaIndex ].ladder = NULL;
+			++m_adjAreaIndex;
+		}
+
+		const NavConnectVector &adjWest = *area->GetAdjacentAreas( WEST );		
+		FOR_EACH_VEC( adjWest, it )
+		{
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			m_adjAreaVector[ m_adjAreaIndex ].area = adjWest[ it ].area;
+			m_adjAreaVector[ m_adjAreaIndex ].how = GO_WEST;
+			m_adjAreaVector[ m_adjAreaIndex ].ladder = NULL;
+			++m_adjAreaIndex;
+		}
+
+		const NavConnectVector &adjEast = *area->GetAdjacentAreas( EAST );	
+		FOR_EACH_VEC( adjEast, it )
+		{
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			m_adjAreaVector[ m_adjAreaIndex ].area = adjEast[ it ].area;
+			m_adjAreaVector[ m_adjAreaIndex ].how = GO_EAST;
+			m_adjAreaVector[ m_adjAreaIndex ].ladder = NULL;
+			++m_adjAreaIndex;
+		}
+
+		const NavLadderConnectVector &adjUpLadder = *area->GetLadders( CNavLadder::LADDER_UP );
+		FOR_EACH_VEC( adjUpLadder, it )
+		{
+			CNavLadder *ladder = adjUpLadder[ it ].ladder;
+
+			if ( ladder->m_topForwardArea && m_adjAreaIndex < MAX_ADJ_AREAS )
+			{
+				m_adjAreaVector[ m_adjAreaIndex ].area = ladder->m_topForwardArea;
+				m_adjAreaVector[ m_adjAreaIndex ].how = GO_LADDER_UP;
+				m_adjAreaVector[ m_adjAreaIndex ].ladder = ladder;
+				++m_adjAreaIndex;
+			}
+
+			if ( ladder->m_topLeftArea && m_adjAreaIndex < MAX_ADJ_AREAS )
+			{
+				m_adjAreaVector[ m_adjAreaIndex ].area = ladder->m_topLeftArea;
+				m_adjAreaVector[ m_adjAreaIndex ].how = GO_LADDER_UP;
+				m_adjAreaVector[ m_adjAreaIndex ].ladder = ladder;
+				++m_adjAreaIndex;
+			}
+
+			if ( ladder->m_topRightArea && m_adjAreaIndex < MAX_ADJ_AREAS )
+			{
+				m_adjAreaVector[ m_adjAreaIndex ].area = ladder->m_topRightArea;
+				m_adjAreaVector[ m_adjAreaIndex ].how = GO_LADDER_UP;
+				m_adjAreaVector[ m_adjAreaIndex ].ladder = ladder;
+				++m_adjAreaIndex;
+			}
+		}
+
+		const NavLadderConnectVector &adjDownLadder = *area->GetLadders( CNavLadder::LADDER_DOWN );
+		FOR_EACH_VEC( adjDownLadder, it )
+		{
+			CNavLadder *ladder = adjDownLadder[ it ].ladder;
+
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			if ( ladder->m_bottomArea )
+			{
+				m_adjAreaVector[ m_adjAreaIndex ].area = ladder->m_bottomArea;
+				m_adjAreaVector[ m_adjAreaIndex ].how = GO_LADDER_DOWN;
+				m_adjAreaVector[ m_adjAreaIndex ].ladder = ladder;
+				++m_adjAreaIndex;
+			}
+		}
+	}
+
+	enum { MAX_ADJ_AREAS = 64 };
+
+	struct AdjInfo
+	{
+		CNavArea *area;
+		CNavLadder *ladder;
+		NavTraverseType how;		
+	};
+
+	AdjInfo m_adjAreaVector[ MAX_ADJ_AREAS ];
+	int m_adjAreaIndex;
+
+};
+
+
+inline float Path::GetLength( void ) const
+{
+	if (m_segmentCount <= 0)
+	{
+		return 0.0f;
+	}
+	
+	return m_path[ m_segmentCount-1 ].distanceFromStart;
+}
+
+inline bool Path::IsValid( void ) const
+{
+	return (m_segmentCount > 0);
+}
+
+inline void Path::Invalidate( void )
+{
+	m_segmentCount = 0;
+
+	m_cursorPos = 0.0f;
+	
+	m_cursorData.pos = vec3_origin;
+	m_cursorData.forward = Vector( 1.0f, 0, 0 );
+	m_cursorData.curvature = 0.0f;
+	m_cursorData.segmentPrior = NULL;
+	
+	m_isCursorDataDirty = true;
+
+	m_subject = NULL;
+}
+
+inline const Path::Segment *Path::FirstSegment( void ) const
+{
+	return (IsValid()) ? &m_path[0] : NULL;
+}
+
+inline const Path::Segment *Path::NextSegment( const Segment *currentSegment ) const
+{
+	if (currentSegment == NULL || !IsValid())
+		return NULL;
+		
+	int i = currentSegment - m_path;
+
+	if (i < 0 || i >= m_segmentCount-1)
+	{
+		return NULL;
+	}
+	
+	return &m_path[ i+1 ];
+}
+
+inline const Path::Segment *Path::PriorSegment( const Segment *currentSegment ) const
+{
+	if (currentSegment == NULL || !IsValid())
+		return NULL;
+		
+	int i = currentSegment - m_path;
+
+	if (i < 1 || i >= m_segmentCount)
+	{
+		return NULL;
+	}
+	
+	return &m_path[ i-1 ];
+}
+
+inline const Path::Segment *Path::LastSegment( void ) const
+{
+	return ( IsValid() ) ? &m_path[ m_segmentCount-1 ] : NULL;
+}
+
+inline const Vector &Path::GetStartPosition( void ) const
+{
+	return ( IsValid() ) ? m_path[ 0 ].pos : vec3_origin;
+}
+
+inline const Vector &Path::GetEndPosition( void ) const
+{
+	return ( IsValid() ) ? m_path[ m_segmentCount-1 ].pos : vec3_origin;
+}
+
+inline CBaseCombatCharacter *Path::GetSubject( void ) const
+{
+	return m_subject;
+}
+
+inline void Path::MoveCursorToStart( void )
+{
+	m_cursorPos = 0.0f;
+	m_isCursorDataDirty = true;
+}
+
+inline void Path::MoveCursorToEnd( void )
+{
+	m_cursorPos = GetLength();
+	m_isCursorDataDirty = true;
+}
+
+inline void Path::MoveCursor( float value, MoveCursorType type )
+{
+	if ( type == PATH_ABSOLUTE_DISTANCE )
+	{
+		m_cursorPos = value;
+	}
+	else	// relative distance
+	{
+		m_cursorPos += value;
+	}
+	
+	if ( m_cursorPos < 0.0f )
+	{
+		m_cursorPos = 0.0f;
+	}
+	else if ( m_cursorPos > GetLength() )
+	{
+		m_cursorPos = GetLength();
+	}
+	
+	m_isCursorDataDirty = true;
+}
+
+inline float Path::GetCursorPosition( void ) const
+{
+	return m_cursorPos;
+}
+
+inline const Path::Segment *Path::GetCurrentGoal( void ) const
+{
+	return NULL;
+}
+
+inline float Path::GetAge( void ) const
+{
+	return m_ageTimer.GetElapsedTime();
+}
+
+
+#endif	// _NEXT_BOT_PATH_H_
+
diff --git a/game/server/NextBot/Path/NextBotPathFollow.cpp b/game/server/NextBot/Path/NextBotPathFollow.cpp
new file mode 100644
index 00000000..58e2e858
--- /dev/null
+++ b/game/server/NextBot/Path/NextBotPathFollow.cpp
@@ -0,0 +1,1923 @@
+// NextBotPathFollow.cpp
+// Path following
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "BasePropDoor.h"
+
+#include "nav_mesh.h"
+#include "NextBot.h"
+#include "NextBotPathFollow.h"
+#include "NextBotUtil.h"
+
+#include "NextBotLocomotionInterface.h"
+#include "NextBotBodyInterface.h"
+#include "NextBotVisionInterface.h"
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+ConVar NextBotSpeedLookAheadRange( "nb_speed_look_ahead_range", "150", FCVAR_CHEAT );
+ConVar NextBotGoalLookAheadRange( "nb_goal_look_ahead_range", "50", FCVAR_CHEAT );
+ConVar NextBotLadderAlignRange( "nb_ladder_align_range", "50", FCVAR_CHEAT );
+
+ConVar NextBotAllowAvoiding( "nb_allow_avoiding", "1", FCVAR_CHEAT );
+ConVar NextBotAllowClimbing( "nb_allow_climbing", "1", FCVAR_CHEAT );
+ConVar NextBotAllowGapJumping( "nb_allow_gap_jumping", "1", FCVAR_CHEAT );
+
+ConVar NextBotDebugClimbing( "nb_debug_climbing", "0", FCVAR_CHEAT );
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Constructor
+ */
+PathFollower::PathFollower( void )
+{
+	m_goal = NULL;
+	m_didAvoidCheck = false;
+
+	m_avoidTimer.Invalidate();
+	m_waitTimer.Invalidate();
+	m_hindrance = NULL;
+
+	m_minLookAheadRange = -1.0f;
+
+	// was 10.0f for L4D - need a better solution here (MSB 5/15/09)
+	m_goalTolerance = 25.0f;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+class CDetachPath
+{
+public:
+	CDetachPath( PathFollower *path )
+	{
+		m_path = path;
+	}
+
+	bool operator() ( INextBot *bot )
+	{
+		bot->NotifyPathDestruction( m_path );
+		return true;
+	}
+
+	PathFollower *m_path;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+PathFollower::~PathFollower()
+{
+	// allow bots to detach pointer to me
+	CDetachPath detach( this );
+	TheNextBots().ForEachBot( detach );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When the path is invalidated, the follower is also reset
+ */
+void PathFollower::Invalidate( void )
+{
+	// extend
+	Path::Invalidate();
+
+	m_goal = NULL;
+
+	m_avoidTimer.Invalidate();
+	m_waitTimer.Invalidate();
+	m_hindrance = NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when the path is (re)computed (path is valid at the time of this call)
+ */
+void PathFollower::OnPathChanged( INextBot *bot, Path::ResultType result )
+{
+	// start from the beginning
+	m_goal = FirstSegment();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Adjust speed based on path curvature
+ */
+void PathFollower::AdjustSpeed( INextBot *bot )
+{
+	ILocomotion *mover = bot->GetLocomotionInterface();
+
+	// if we're coming up on a gap jump, or we're in the air, use maximum speed
+	if ( ( m_goal && m_goal->type == JUMP_OVER_GAP ) || !mover->IsOnGround() )
+	{
+		mover->SetDesiredSpeed( mover->GetRunSpeed() );
+		return;
+	}
+
+	MoveCursorToClosestPosition( bot->GetPosition() );
+	const Path::Data &data = GetCursorData();
+	
+	// speed based on curvature
+	mover->SetDesiredSpeed( mover->GetRunSpeed() + fabs( data.curvature ) * ( mover->GetWalkSpeed() - mover->GetRunSpeed() ) );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if reached current goal along path
+ * NOTE: Ladder goals are handled elsewhere
+ */
+bool PathFollower::IsAtGoal( INextBot *bot ) const
+{
+	VPROF_BUDGET( "PathFollower::IsAtGoal", "NextBot" );
+
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	IBody *body = bot->GetBodyInterface();
+
+	//
+	// m_goal is the node we are moving toward along the path
+	// current is the node just behind us
+	//
+	const Segment *current = PriorSegment( m_goal );
+	Vector toGoal = m_goal->pos - mover->GetFeet();
+
+// 	if ( m_goal->type == JUMP_OVER_GAP && !mover->IsOnGround() )
+// 	{
+// 		// jumping over a gap, don't skip ahead until we land
+// 		return false;
+// 	}
+
+	if ( current == NULL )
+	{
+		// passed goal
+		return true;
+	}
+	else if ( m_goal->type == DROP_DOWN )
+	{
+		// m_goal is the top of the drop-down, and the following segment is the landing point
+		const Segment *landing = NextSegment( m_goal );
+
+		if ( landing == NULL )
+		{
+			// passed goal or corrupt path
+			return true;
+		}		
+		else
+		{
+			// did we reach the ground
+			if ( mover->GetFeet().z - landing->pos.z < mover->GetStepHeight() )
+			{
+				// reached goal
+				return true;
+			}
+		}
+				
+		/// @todo: it is possible to fall into a bad place and get stuck - should move back onto the path
+		
+	}
+	else if ( m_goal->type == CLIMB_UP )
+	{
+		// once jump is started, assume it is successful, since
+		// nav mesh may be substantially off from actual ground height at landing
+		const Segment *landing = NextSegment( m_goal );
+
+		if ( landing == NULL )
+		{
+			// passed goal or corrupt path
+			return true;
+		}		
+		else if ( /*!mover->IsOnGround() && */ mover->GetFeet().z > m_goal->pos.z + mover->GetStepHeight() )
+		{
+			// we're off the ground, presumably climbing - assume we reached the goal
+			return true;
+		}
+		/* This breaks infected climbing up holes in the ceiling - they can get within 2D range of m_goal before finding a ledge to climb up to
+		else if ( mover->IsOnGround() )
+		{
+			// proximity check
+			// Z delta can be anything, since we may be climbing over a tall fence, a physics prop, etc.
+			const float rangeTolerance = 10.0f;
+			if ( toGoal.AsVector2D().IsLengthLessThan( rangeTolerance ) )
+			{
+				// reached goal
+				return true;
+			}
+		}
+		*/
+	}
+	else
+	{
+		const Segment *next = NextSegment( m_goal );
+
+		if ( next )
+		{
+			// because mover may be off the path, check if it crossed the plane of the goal
+			// check against average of current and next forward vectors
+			Vector2D dividingPlane;
+
+			if ( current->ladder )
+			{
+				dividingPlane = m_goal->forward.AsVector2D();
+			}
+			else
+			{
+				dividingPlane = current->forward.AsVector2D() + m_goal->forward.AsVector2D();
+			}
+
+			if ( DotProduct2D( toGoal.AsVector2D(), dividingPlane ) < 0.0001f &&
+				 abs( toGoal.z ) < body->GetStandHullHeight() )
+			{	
+				// only skip higher Z goal if next goal is directly reachable
+				// can't use this for positions below us because we need to be able
+				// to climb over random objects along our path that we can't actually
+				// move *through*
+				if ( toGoal.z < mover->GetStepHeight() && ( mover->IsPotentiallyTraversable( mover->GetFeet(), next->pos ) && !mover->HasPotentialGap( mover->GetFeet(), next->pos ) ) )
+				{
+					// passed goal
+					return true;
+				}
+			}
+		}
+
+		// proximity check
+		// Z delta can be anything, since we may be climbing over a tall fence, a physics prop, etc.
+		if ( toGoal.AsVector2D().IsLengthLessThan( m_goalTolerance ) )
+		{
+			// reached goal
+			return true;
+		}
+	}
+
+	return false;	
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move bot along ladder. Return true if ladder motion is in progress, false if complete.
+ */
+bool PathFollower::LadderUpdate( INextBot *bot )
+{
+	VPROF_BUDGET( "PathFollower::LadderUpdate", "NextBot" );
+
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	IBody *body = bot->GetBodyInterface();
+	
+	if ( mover->IsUsingLadder() )
+	{
+		// wait for locomotor to finish traversing ladder
+		return true;
+	}
+
+	if ( m_goal->ladder == NULL )
+	{
+		// Check if we have somehow ended up on a ladder, if so, and its a tall down-ladder we are expecting, jump the path ahead.
+		// This happens for players, who run off ledges and the gamemovement sticks them onto ladders.  We only care about
+		// tall down-ladders, because up ladders work without this, and short ladders aren't dangerous to miss and drop down
+		// instead of climbing down.
+		if ( bot->GetEntity()->GetMoveType() == MOVETYPE_LADDER )
+		{
+			// 'current' is the segment we are on/just passed over
+			const Segment *current = PriorSegment( m_goal );
+			if ( current == NULL )
+			{
+				return false;
+			}
+
+			// Start with current, the segment we are currently traversing.  Skip the distance check for that segment, because
+			// the pos is (hopefully) behind us.  And if it's a long path segment, it's already outside the climbLookAheadRange,
+			// and thus it would prevent us looking at m_goal and further for imminent planned climbs.
+			// 'current' is the segment we are on/just passed over
+			const float ladderLookAheadRange = 50.0f;
+			for( const Segment *s = current; s; s = NextSegment( s ) )
+			{
+				if ( s != current && ( s->pos - mover->GetFeet() ).AsVector2D().IsLengthGreaterThan( ladderLookAheadRange ) )
+				{
+					break;
+				}
+
+				// Only consider reasonably tall down ladders - if we don't grab onto a short ladder, it hopefully won't be a bad fall.
+				if ( s->ladder != NULL && s->how == GO_LADDER_DOWN && s->ladder->m_length > mover->GetMaxJumpHeight() )
+				{
+					float destinationHeightDelta = s->pos.z - mover->GetFeet().z;
+					if ( fabs(destinationHeightDelta) < mover->GetMaxJumpHeight() )
+					{
+						// Advance the goal, and fall through to the normal codepath.
+						m_goal = s;
+						break;
+					}
+				}
+			}
+		}
+
+		if ( m_goal->ladder == NULL )
+		{
+			// no ladder to use
+			return false;
+		}
+	}
+	
+
+	// start using the ladder
+	const float mountRange = 25.0f;
+
+	if ( m_goal->how == GO_LADDER_UP )
+	{
+		// check if we're off the ladder and at the top
+		if ( !mover->IsUsingLadder() && mover->GetFeet().z > m_goal->ladder->m_top.z - mover->GetStepHeight() )
+		{
+			// we're up
+			m_goal = NextSegment( m_goal );
+			return false;
+		}
+
+		// approach the ladder
+		Vector2D to = ( m_goal->ladder->m_bottom - mover->GetFeet() ).AsVector2D();
+
+		body->AimHeadTowards( m_goal->ladder->m_top - 50.0f * m_goal->ladder->GetNormal() + Vector( 0, 0, body->GetCrouchHullHeight() ), 
+							  IBody::CRITICAL, 
+							  2.0f, 
+							  NULL,
+							  "Mounting upward ladder" );
+
+		float range = to.NormalizeInPlace();
+		if ( range < NextBotLadderAlignRange.GetFloat() )
+		{
+			// getting close - line up
+			Vector2D ladderNormal2D = m_goal->ladder->GetNormal().AsVector2D();
+			float dot = DotProduct2D( ladderNormal2D, to );
+
+			const float cos5 = 0.9f;
+			if ( dot < -cos5 )
+			{
+				// lined up - continue approach
+				mover->Approach( m_goal->ladder->m_bottom );
+
+				if ( range < mountRange )
+				{
+					// go up ladder
+					mover->ClimbLadder( m_goal->ladder, m_goal->area );
+				}				
+			}
+			else
+			{
+				// rotate around ladder and maintain distance from it
+				Vector myPerp( -to.y, to.x, 0.0f );
+				Vector2D ladderPerp2D( -ladderNormal2D.y, ladderNormal2D.x );
+
+				Vector goal = m_goal->ladder->m_bottom;
+				
+				float alignRange = NextBotLadderAlignRange.GetFloat();
+				
+				if ( dot < 0.0f )
+				{
+					// we are on the correct side of the ladder
+					// align range should drop off as we reach alignment
+					alignRange = mountRange + (1.0f + dot) * (alignRange - mountRange);
+				}
+				
+				goal.x -= alignRange * to.x;
+				goal.y -= alignRange * to.y;				
+				
+				if ( DotProduct2D( to, ladderPerp2D ) < 0.0f )
+				{
+					goal += 10.0f * myPerp;
+				}
+				else
+				{
+					goal -= 10.0f * myPerp;
+				}
+				
+				mover->Approach( goal );
+			}
+		}
+		else
+		{
+			// approach the base of the ladder - use normal path following in case there are jumps/climbs on the way to the ladder
+			return false;
+		}
+	}
+	else	// go down ladder
+	{
+		// check if we fell off and are now below the ladder
+		if ( mover->GetFeet().z < m_goal->ladder->m_bottom.z + mover->GetStepHeight() )
+		{
+			// we fell
+			m_goal = NextSegment( m_goal );
+		}
+		else
+		{
+			// approach the ladder
+			Vector mountPoint = m_goal->ladder->m_top + 0.5f * body->GetHullWidth() * m_goal->ladder->GetNormal();
+			Vector2D to = ( mountPoint - mover->GetFeet() ).AsVector2D();
+
+			if ( bot->IsDebugging( NEXTBOT_PATH ) )
+			{
+				const float size = 5.0f;	
+				NDebugOverlay::Sphere( mountPoint, size, 255, 0, 255, true, 0.1f );			
+			}
+
+			body->AimHeadTowards( m_goal->ladder->m_bottom + 50.0f * m_goal->ladder->GetNormal() + Vector( 0, 0, body->GetCrouchHullHeight() ), 
+								  IBody::CRITICAL, 
+								  1.0f, 
+								  NULL,
+								  "Mounting downward ladder" );
+
+			float range = to.NormalizeInPlace();
+
+			// Approach the top of the ladder.  If we're already on the ladder, start descending.
+			if ( range < mountRange || bot->GetEntity()->GetMoveType() == MOVETYPE_LADDER )
+			{
+				// go down ladder
+				mover->DescendLadder( m_goal->ladder, m_goal->area );
+
+				// increment goal segment since locomotor will move us along the ladder
+				m_goal = NextSegment( m_goal );
+			}
+			else
+			{
+				// approach the top of the ladder - use normal path following in case there are jumps/climbs on the way to the ladder
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Check if we have reached our current path goal and
+ * iterate to next goal or finish the path
+ */
+bool PathFollower::CheckProgress( INextBot *bot )
+{
+	ILocomotion *mover = bot->GetLocomotionInterface();
+
+	// skip nearby goal points that are redundant to smooth path following motion
+	const Path::Segment *pSkipToGoal = NULL;
+	if ( m_minLookAheadRange > 0.0f )
+	{
+		pSkipToGoal = m_goal;
+		const Vector &myFeet = mover->GetFeet();
+		while( pSkipToGoal && pSkipToGoal->type == ON_GROUND && mover->IsOnGround() )
+		{
+			if ( ( pSkipToGoal->pos - myFeet ).IsLengthLessThan( m_minLookAheadRange ) )
+			{
+				// goal is too close - step to next segment
+				const Path::Segment *nextSegment = NextSegment( pSkipToGoal );
+
+				if ( !nextSegment || nextSegment->type != ON_GROUND )
+				{
+					// can't skip ahead to next segment - head towards current goal
+					break;
+				}
+
+				if ( nextSegment->pos.z > myFeet.z + mover->GetStepHeight() )
+				{
+					// going uphill or up stairs tends to cause problems if we skip ahead, so don't
+					break;
+				}
+
+#ifdef DOTA_DLL
+				if ( DotProduct( mover->GetMotionVector(), nextSegment->forward ) <= 0.1f )
+				{
+					// don't skip sharp turns
+					break;
+				}
+#endif
+
+				// can we reach the next path segment directly
+				if ( mover->IsPotentiallyTraversable( myFeet, nextSegment->pos ) && !mover->HasPotentialGap( myFeet, nextSegment->pos ) )
+				{
+					pSkipToGoal = nextSegment;
+				}
+				else
+				{
+					// can't directly reach next segment - keep heading towards current goal
+					break;
+				}
+			}
+			else
+			{
+				// goal is farther than min lookahead
+				break;
+			}
+		}
+
+		// didn't find any goal to skip to
+		if ( pSkipToGoal == m_goal )
+		{
+			pSkipToGoal = NULL;
+		}
+	}
+
+	if ( IsAtGoal( bot ) )
+	{
+		// iterate to next segment of the path
+		const Path::Segment *nextSegment = pSkipToGoal ? pSkipToGoal : NextSegment( m_goal );
+
+		if ( nextSegment == NULL )
+		{
+			// must be on ground to complete the path
+			if ( mover->IsOnGround() )
+			{
+				// the end of the path has been reached
+				mover->GetBot()->OnMoveToSuccess( this );
+
+				if ( bot->IsDebugging( NEXTBOT_PATH ) )
+				{
+					DevMsg( "PathFollower: OnMoveToSuccess\n" );
+				}
+
+				// don't invalidate if OnMoveToSuccess just recomputed a new path
+				if ( GetAge() > 0.0f )
+				{
+					Invalidate();
+				}
+
+				return false;
+			}
+		}
+		else
+		{
+			// keep moving
+			m_goal = nextSegment;
+
+			if ( bot->IsDebugging( NEXTBOT_PATH ) && !mover->IsPotentiallyTraversable( mover->GetFeet(), nextSegment->pos ) )
+			{
+				Warning( "PathFollower: path to my goal is blocked by something\n" );
+				NDebugOverlay::Sphere( m_goal->pos, 5.f, 255, 0, 0, true, 3.f );
+			}
+		}
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move mover along path
+ */
+void PathFollower::Update( INextBot *bot )
+{
+	VPROF_BUDGET( "PathFollower::Update", "NextBotSpiky" );
+
+	// track most recent path followed
+	bot->SetCurrentPath( this );
+
+
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	
+	if ( !IsValid() || m_goal == NULL )
+	{
+		return;
+	}
+
+	if ( !m_waitTimer.IsElapsed() )
+	{
+		// still waiting
+		//mover->ClearStuckStatus( "Waiting for blocker to move" );
+		return;
+	}
+
+//	m_didAvoidCheck = false;
+
+
+	if ( LadderUpdate( bot ) )
+	{
+		// we are traversing a ladder
+		return;
+	}
+
+
+	// adjust speed based on path curvature
+	AdjustSpeed( bot );
+
+	if ( CheckProgress( bot ) == false )
+	{
+		// goal reached
+		return;
+	}
+
+	// use the direction towards the goal as 'forward' direction
+	Vector forward = m_goal->pos - mover->GetFeet();
+
+	if ( m_goal->type == CLIMB_UP )
+	{
+		const Segment *next = NextSegment( m_goal );
+		if ( next )
+		{
+			// use landing of climb up as forward to help ledge detection
+			forward = next->pos - mover->GetFeet();
+		}
+	}
+
+	forward.z = 0.0f;
+
+	float goalRange = forward.NormalizeInPlace();
+
+	Vector left( -forward.y, forward.x, 0.0f );
+
+	if ( left.IsZero() )
+	{
+		// if left is zero, forward must also be - path follow failure
+		mover->GetBot()->OnMoveToFailure( this, FAIL_STUCK );
+
+		// don't invalidate if OnMoveToFailure just recomputed a new path
+		if ( GetAge() > 0.0f )
+		{
+			Invalidate();
+		}
+
+		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+		{
+			DevMsg( "PathFollower: OnMoveToFailure( FAIL_STUCK ) because forward and left are ZERO\n" );
+		}
+
+		return;
+	}
+
+	// unit vectors must follow floor slope
+	const Vector &normal = mover->GetGroundNormal();
+
+	// get forward vector along floor
+	forward = CrossProduct( left, normal );
+
+	// correct the sideways vector
+	left = CrossProduct( normal, forward );
+
+	if ( bot->IsDebugging( NEXTBOT_PATH ) )
+	{
+		float axisSize = 25.0f;
+		NDebugOverlay::Line( mover->GetFeet(), mover->GetFeet() + axisSize * forward, 255, 0, 0, true, 0.1f );
+		NDebugOverlay::Line( mover->GetFeet(), mover->GetFeet() + axisSize * normal, 0, 255, 0, true, 0.1f );
+		NDebugOverlay::Line( mover->GetFeet(), mover->GetFeet() + axisSize * left, 0, 0, 255, true, 0.1f );
+	}
+
+	// climb up ledges
+	if ( !Climbing( bot, m_goal, forward, left, goalRange ) )
+	{
+		// a failed climb could mean an invalid path
+		if ( !IsValid() )
+		{
+			return;
+		}
+
+		// jump over gaps
+		JumpOverGaps( bot, m_goal, forward, left, goalRange );
+	}
+
+	// event callbacks from the above climbs and jumps may invalidate the path
+	if ( !IsValid() )
+	{
+		return;
+	}
+	
+	// if our movement goal is high above us, we must have fallen
+	CNavArea *myArea = bot->GetEntity()->GetLastKnownArea();
+	bool isOnStairs = ( myArea && myArea->HasAttributes( NAV_MESH_STAIRS ) );
+
+	// limit too high distance to reasonable value for bots that can climb very high
+	float tooHighDistance = mover->GetMaxJumpHeight();
+
+	if ( !m_goal->ladder && !mover->IsClimbingOrJumping() && !isOnStairs && m_goal->pos.z > mover->GetFeet().z + tooHighDistance )
+	{
+		const float closeRange = 25.0f; // 75.0f;
+		Vector2D to( mover->GetFeet().x - m_goal->pos.x, mover->GetFeet().y - m_goal->pos.y );
+		if ( mover->IsStuck() || to.IsLengthLessThan( closeRange ) )
+		{
+			// the goal is too high to reach
+
+			// check if we can reach the next segment, in case this was a "jump down" situation
+			const Path::Segment *next = NextSegment( m_goal );
+			if ( mover->IsStuck() || !next || ( next->pos.z - mover->GetFeet().z > mover->GetMaxJumpHeight() ) || !mover->IsPotentiallyTraversable( mover->GetFeet(), next->pos ) )
+			{
+				// the next node is too high, too - we really did fall off the path
+				mover->GetBot()->OnMoveToFailure( this, FAIL_FELL_OFF );
+
+				// don't invalidate if OnMoveToFailure just recomputed a new path
+				if ( GetAge() > 0.0f )
+				{
+					Invalidate();
+				}
+
+				if ( bot->IsDebugging( NEXTBOT_PATH ) )
+				{
+					DevMsg( "PathFollower: OnMoveToFailure( FAIL_FELL_OFF )\n" );
+				}
+
+				// reset stuck status since we're (likely) repathing anyways. otherwise, we could be stuck in a loop here and not move
+				mover->ClearStuckStatus( "Fell off path" );
+
+				return;
+			}
+		}
+	}
+
+
+	Vector goalPos = m_goal->pos;
+
+	// avoid small obstacles
+	forward = goalPos - mover->GetFeet();
+	forward.z = 0.0f;
+	float rangeToGoal = forward.NormalizeInPlace();
+
+	left.x = -forward.y;
+	left.y = forward.x;
+	left.z = 0.0f;
+
+	if ( true || m_goal != LastSegment() )	// think more about this - we often need to avoid to reach the final goal pos, too (MSB 5/15/09)
+	{
+		const float nearLedgeRange = 50.0f;
+		if ( rangeToGoal > nearLedgeRange || ( m_goal && m_goal->type != CLIMB_UP ) )
+		{
+			goalPos = Avoid( bot, goalPos, forward, left );
+		}
+	}
+
+	// face towards movement goal
+	if ( mover->IsOnGround() )
+	{	
+		mover->FaceTowards( goalPos );
+	}
+
+	// move bot along path
+	mover->Approach( goalPos );
+
+	// Currently, Approach determines STAND or CROUCH. 
+	// Override this if we're approaching a climb or a jump
+	if ( m_goal && ( m_goal->type == CLIMB_UP || m_goal->type == JUMP_OVER_GAP ) )
+	{
+		bot->GetBodyInterface()->SetDesiredPosture( IBody::STAND );
+	}
+
+	if ( bot->IsDebugging( NEXTBOT_PATH ) )
+	{
+		const Segment *start = GetCurrentGoal();
+		if ( start )
+		{
+			start = PriorSegment( start );
+		}
+
+		Draw( start );
+
+		/*
+		else
+		{
+		DrawInterpolated( 0.0f, GetLength() );
+		}
+		*/
+
+		NDebugOverlay::Cross3D( goalPos, 5.0f, 150, 150, 255, true, 0.1f );
+		NDebugOverlay::Line( bot->GetEntity()->WorldSpaceCenter(), goalPos, 255, 255, 0, true, 0.1f );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * If entity is returned, it is blocking us from continuing along our path
+ */
+CBaseEntity *PathFollower::FindBlocker( INextBot *bot )
+{
+	IIntention *think = bot->GetIntentionInterface();
+
+	// if we don't care about hindrances, don't do the expensive tests
+	if ( think->IsHindrance( bot, IS_ANY_HINDRANCE_POSSIBLE ) != ANSWER_YES )
+		return NULL;
+
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	IBody *body = bot->GetBodyInterface();
+
+	trace_t result;
+	NextBotTraceFilterOnlyActors filter( bot->GetEntity(), COLLISION_GROUP_NONE );
+
+	const float size = body->GetHullWidth()/4.0f;	// keep this small to avoid lockups when groups of bots get close
+	Vector blockerMins( -size, -size, mover->GetStepHeight() );
+	Vector blockerMaxs( size, size, body->GetCrouchHullHeight() );
+
+	Vector from = mover->GetFeet();
+	float range = 0.0f;
+
+	const float maxHindranceRangeAlong = 750.0f;
+
+	// because our path goal may be far ahead of us if the way to there is unobstructed, we
+	// need to start looking from the point of the path we are actually standing on
+	MoveCursorToClosestPosition( mover->GetFeet() );
+
+	for( const Segment *s = GetCursorData().segmentPrior; s && range < maxHindranceRangeAlong; s = NextSegment( s ) )
+	{
+		// trace along direction toward goal a minimum range, in case goal and hindrance are
+		// very close, but goal is closer
+
+		Vector traceForward = s->pos - from;
+		float traceRange = traceForward.NormalizeInPlace();
+
+		const float minTraceRange = 2.0f * body->GetHullWidth();
+		if ( traceRange < minTraceRange )
+		{
+			traceRange = minTraceRange;
+		}
+
+		mover->TraceHull( from, from + traceRange * traceForward, blockerMins, blockerMaxs, body->GetSolidMask(), &filter, &result );
+
+		if ( result.DidHitNonWorldEntity() )
+		{
+			// if blocker is close, they could be behind us - check
+			Vector toBlocker = result.m_pEnt->GetAbsOrigin() - bot->GetLocomotionInterface()->GetFeet();
+
+			Vector alongPath = s->pos - from;
+			alongPath.z = 0.0f;
+
+			if ( DotProduct( toBlocker, alongPath ) > 0.0f )
+			{
+				// ask the bot if this really is a hindrance
+				if ( think->IsHindrance( bot, result.m_pEnt ) == ANSWER_YES )
+				{
+					if ( bot->IsDebugging( NEXTBOT_PATH ) )
+					{
+						NDebugOverlay::Circle( bot->GetLocomotionInterface()->GetFeet(), QAngle( -90.0f, 0, 0 ), 10.0f, 255, 0, 0, 255, true, 1.0f );
+						NDebugOverlay::HorzArrow( bot->GetLocomotionInterface()->GetFeet(), result.m_pEnt->GetAbsOrigin(), 1.0f, 255, 0, 0, 255, true, 1.0f );
+					}
+
+					// we are blocked
+					return result.m_pEnt;
+				}
+			}
+		}
+
+		from = s->pos;
+		range += s->length;
+	}
+
+	return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Do reflex avoidance movements of very nearby obstacles.
+ * Return adjusted goal.
+ */
+Vector PathFollower::Avoid( INextBot *bot, const Vector &goalPos, const Vector &forward, const Vector &left )
+{
+	VPROF_BUDGET( "PathFollower::Avoid", "NextBotExpensive" );
+
+	if ( !NextBotAllowAvoiding.GetBool() )
+	{
+		return goalPos;
+	}
+
+	if ( !m_avoidTimer.IsElapsed() )
+	{
+		return goalPos;
+	}
+	
+	// low frequency check until we actually hit something we need to avoid
+	const float avoidInterval = 0.5f; // 1.0f;
+	m_avoidTimer.Start( avoidInterval );
+
+	ILocomotion *mover = bot->GetLocomotionInterface();
+
+	if ( mover->IsClimbingOrJumping() || !mover->IsOnGround() )
+	{
+		return goalPos;
+	}
+
+	//
+	// Check for potential blockers along our path and wait if we're blocked
+	//
+	m_hindrance = FindBlocker( bot );
+	if ( m_hindrance != NULL )
+	{
+		// wait 
+		m_waitTimer.Start( avoidInterval * RandomFloat( 1.0f, 2.0f ) );
+
+		return mover->GetFeet();
+	}
+
+
+	// if we are in a "precise" area, do not use avoid volumes
+	CNavArea *area = bot->GetEntity()->GetLastKnownArea();
+	if ( area && ( area->GetAttributes() & NAV_MESH_PRECISE ) )
+	{
+		return goalPos;
+	}
+
+	m_didAvoidCheck = true;
+
+	// we want to avoid other players, etc	
+	trace_t result;
+	NextBotTraceFilterOnlyActors filter( bot->GetEntity(), COLLISION_GROUP_NONE );
+
+	IBody *body = bot->GetBodyInterface();
+	unsigned int mask = body->GetSolidMask();
+
+	const float size = body->GetHullWidth()/4.0f;
+	const float offset = size + 2.0f;
+
+	float range = mover->IsRunning() ? 50.0f : 30.0f;
+	range *= bot->GetEntity()->GetModelScale();
+
+	m_hullMin = Vector( -size, -size, mover->GetStepHeight()+0.1f );
+	
+	// only use crouch-high avoid volumes, since we'll just crouch if higher obstacles are near
+	m_hullMax = Vector( size, size, body->GetCrouchHullHeight() );
+	
+	Vector nextStepHullMin( -size, -size, 2.0f * mover->GetStepHeight() + 0.1f );
+
+	// avoid any open doors in our way
+	CBasePropDoor *door = NULL;
+
+	// check left side
+	m_leftFrom = mover->GetFeet() + offset * left;
+	m_leftTo = m_leftFrom + range * forward;
+
+	m_isLeftClear = true;
+	float leftAvoid = 0.0f;
+
+	NextBotTraversableTraceFilter traverseFilter( bot );
+	mover->TraceHull( m_leftFrom, m_leftTo, m_hullMin, m_hullMax, mask, &traverseFilter, &result );
+	if ( result.fraction < 1.0f || result.startsolid )
+	{
+		// if this sensor is starting in a solid, set fraction to emulate being against a wall
+		if ( result.startsolid )
+		{
+			result.fraction = 0.0f;
+		}
+
+		leftAvoid = clamp( 1.0f - result.fraction, 0.0f, 1.0f );
+
+		m_isLeftClear = false;
+
+		// track any doors we need to avoid
+		if ( result.DidHitNonWorldEntity() )
+		{
+			door = dynamic_cast< CBasePropDoor * >( result.m_pEnt );
+		}
+
+		// check for steps
+// 		float firstHit = result.fraction;
+// 		mover->TraceHull( m_leftFrom, m_leftTo, nextStepHullMin, m_hullMax, mask, &filter, &result );
+// 		if ( result.fraction <= firstHit ) //+ mover->GetStepHeight()/2.0f )
+// 		{
+// 			// it's not a step - we hit something
+// 			m_isLeftClear = false;
+// 		}
+	}
+
+	// check right side
+	m_rightFrom = mover->GetFeet() - offset * left;
+	m_rightTo = m_rightFrom + range * forward;
+
+	m_isRightClear = true;
+	float rightAvoid = 0.0f;
+
+	mover->TraceHull( m_rightFrom, m_rightTo, m_hullMin, m_hullMax, mask, &traverseFilter, &result );
+	if ( result.fraction < 1.0f || result.startsolid )
+	{
+		// if this sensor is starting in a solid, set fraction to emulate being against a wall
+		if ( result.startsolid )
+		{
+			result.fraction = 0.0f;
+		}
+
+		rightAvoid = clamp( 1.0f - result.fraction, 0.0f, 1.0f );
+
+		m_isRightClear = false;
+
+		// track any doors we need to avoid
+		if ( !door && result.DidHitNonWorldEntity() )
+		{
+			door = dynamic_cast< CBasePropDoor * >( result.m_pEnt );
+		}
+
+		// check for steps
+// 		float firstHit = result.fraction;
+// 		mover->TraceHull( m_rightFrom, m_rightTo, nextStepHullMin, m_hullMax, mask, &filter, &result );
+// 		if ( result.fraction <= firstHit ) // + mover->GetStepHeight()/2.0f)
+// 		{
+// 			// it's not a step - we hit something
+// 			m_isRightClear = false;
+// 		}
+	}
+
+	Vector adjustedGoal = goalPos;
+
+	// avoid doors directly in our way
+	if ( door && !m_isLeftClear && !m_isRightClear )
+	{
+		Vector forward, right, up;
+		AngleVectors( door->GetAbsAngles(), &forward, &right, &up );
+
+		const float doorWidth = 100.0f;
+		Vector doorEdge = door->GetAbsOrigin() - doorWidth * right;
+
+		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+		{
+			NDebugOverlay::Axis( door->GetAbsOrigin(), door->GetAbsAngles(), 20.0f, true, 10.0f );
+			NDebugOverlay::Line( door->GetAbsOrigin(), doorEdge, 255, 255, 0, true, 10.0f );
+		}
+
+		// move around door
+		adjustedGoal.x = doorEdge.x;
+		adjustedGoal.y = doorEdge.y;
+
+		// do avoid check again next frame
+		m_avoidTimer.Invalidate();
+	}
+	else if ( !m_isLeftClear || !m_isRightClear )
+	{
+		// adjust goal to avoid small obstacle
+		float avoidResult = 0.0f;
+		if ( m_isLeftClear )
+		{
+			avoidResult = -rightAvoid;
+		}
+		else if (m_isRightClear)
+		{
+			avoidResult = leftAvoid;
+		}
+		else
+		{
+			// both left and right are blocked, avoid nearest
+			const float equalTolerance = 0.01f;
+			if ( fabs( rightAvoid - leftAvoid ) < equalTolerance )
+			{
+				// squarely against a wall, etc
+				return adjustedGoal;
+			} 
+			else if ( rightAvoid > leftAvoid )
+			{
+				avoidResult = -rightAvoid;
+			}
+			else
+			{
+				avoidResult = leftAvoid;
+			}
+		}
+		
+		// adjust goal to avoid obstacle
+		Vector avoidDir = 0.5f * forward - left * avoidResult;
+		avoidDir.NormalizeInPlace();
+		
+		adjustedGoal = mover->GetFeet() + 100.0f * avoidDir;
+		
+		// do avoid check again next frame
+		m_avoidTimer.Invalidate();
+	}
+	
+	return adjustedGoal;
+}
+
+
+#ifdef EXPERIMENTAL_LEDGE_FINDER
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Given a hull that defines the area of space that may contain a climbable ledge,
+ * subdivide it until we find the ledge.
+ */
+bool PathFollower::FindClimbLedge( INextBot *bot, Vector startTracePos, Vector ledgeRegionMins, Vector ledgeRegionMaxs )
+{
+	float deltaZ = ledgeRegionMaxs.z - ledgeRegionMins.z;
+
+	if ( deltaZ <= bot->GetLocomotionInterface()->GetStepHeight() )
+	{
+		// reached minimum subdivision limit - stop
+		return false;
+	}
+
+	trace_t result;
+	NextBotTraversableTraceFilter filter( bot, ILocomotion::IMMEDIATELY );
+
+	mover->TraceHull( startTracePos, startTracePos,
+					ledgeRegionMins, ledgeRegionMaxs, 
+					bot->GetBodyInterface()->GetSolidMask(), &filter, &result );
+
+
+	if ( result.DidHit() )
+	{
+		// volume is blocked - split into upper and lower volumes and try again
+		float midZ = ( ledgeRegionMins.z + ledgeRegionMaxs.z ) / 2.0f;
+
+		Vector upperLedgeRegionMins( ledgeRegionMins.x, ledgeRegionMins.y, midZ );
+		Vector upperLedgeRegionMaxs = ledgeRegionMaxs;
+		FindClimbLedge( bot, startTracePos, upperLedgeRegionMins, upperLedgeRegionMaxs );
+
+
+		Vector lowerLedgeRegionMins = ledgeRegionMins;
+		Vector lowerLedgeRegionMaxs( ledgeRegionMaxs.x, ledgeRegionMaxs.y, midZ );
+		FindClimbLedge( bot, startTracePos, lowerLedgeRegionMins, lowerLedgeRegionMaxs );
+	}
+	else
+	{
+		// volume is clear, trace straight down to find ledge and keep lowest one we've found
+		mover->TraceHull( startTracePos,
+						startTracePos + Vector( 0, 0, -100.0f ),
+						ledgeRegionMins, ledgeRegionMaxs, 
+						bot->GetBodyInterface()->GetSolidMask(), &filter, &result );	
+	}
+}
+#endif // _DEBUG
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Climb up ledges
+ */
+bool PathFollower::Climbing( INextBot *bot, const Path::Segment *goal, const Vector &forward, const Vector &right, float goalRange )
+{
+	VPROF_BUDGET( "PathFollower::Climbing", "NextBot" );
+
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	IBody *body = bot->GetBodyInterface();
+	CNavArea *myArea = bot->GetEntity()->GetLastKnownArea();
+
+	if ( !mover->IsAbleToClimb() || !NextBotAllowClimbing.GetBool() )
+	{
+		return false;
+	}
+
+	// use the 2D direction towards our goal
+	Vector climbDirection = forward;
+	climbDirection.z = 0.0f;
+	climbDirection.NormalizeInPlace();
+
+	// we can't have this as large as our hull width, or we'll find ledges ahead of us
+	// that we will fall from when we climb up because our hull wont actually touch at the top.
+	const float ledgeLookAheadRange = body->GetHullWidth() - 1;
+
+	if ( mover->IsClimbingOrJumping() || mover->IsAscendingOrDescendingLadder() || !mover->IsOnGround() )
+	{
+		return false;
+	}
+
+	// can be in any posture when we climb
+
+	if ( m_goal == NULL )
+	{
+		return false;
+	}
+
+	if ( TheNavMesh->IsAuthoritative() )
+	{
+		//
+		// Trust what that nav mesh tells us.
+		// No need for expensive ledge-finding for games with simpler geometry (like TF2)
+		//
+		if ( m_goal->type == CLIMB_UP )
+		{
+			const Segment *afterClimb = NextSegment( m_goal );
+			if ( afterClimb && afterClimb->area )
+			{
+				// find closest point on climb-destination area
+				Vector nearClimbGoal;
+				afterClimb->area->GetClosestPointOnArea( mover->GetFeet(), &nearClimbGoal );
+
+				climbDirection = nearClimbGoal - mover->GetFeet();
+				climbDirection.z = 0.0f;
+				climbDirection.NormalizeInPlace();
+
+				if ( mover->ClimbUpToLedge( nearClimbGoal, climbDirection, NULL ) )
+					return true;
+			}
+		}
+
+		return false;
+	}
+
+
+	// If we're approaching a CLIMB_UP link, save off the height delta for it, and trust the nav *just* enough
+	// to climb up to that ledge and only that ledge.  We keep as large a tolerance as possible, to trust
+	// the nav as little as possible.  There's no valid way to have another CLIMB_UP link within crouch height,
+	// because we can't actually fit in between the two areas, so one climb is invalid.
+	float climbUpLedgeHeightDelta = -1.0f;
+	const float climbUpLedgeTolerance = body->GetCrouchHullHeight();
+
+	if ( m_goal->type == CLIMB_UP )
+	{
+		const Segment *afterClimb = NextSegment( m_goal );
+		if ( afterClimb && afterClimb->area )
+		{
+			// find closest point on climb-destination area
+			Vector nearClimbGoal;
+			afterClimb->area->GetClosestPointOnArea( mover->GetFeet(), &nearClimbGoal );
+
+			climbDirection = nearClimbGoal - mover->GetFeet();
+			climbUpLedgeHeightDelta = climbDirection.z;
+			climbDirection.z = 0.0f;
+			climbDirection.NormalizeInPlace();
+		}
+	}
+
+	// don't try to climb up stairs
+	if ( m_goal->area->HasAttributes( NAV_MESH_STAIRS ) || ( myArea && myArea->HasAttributes( NAV_MESH_STAIRS ) ) )
+	{
+		if ( bot->IsDebugging( NEXTBOT_PATH ) )
+		{
+			NDebugOverlay::Cross3D( mover->GetFeet(), 5.0f, 0, 255, 255, true, 5.0f );
+			DevMsg( "%3.2f: %s ON STAIRS\n", gpGlobals->curtime, bot->GetDebugIdentifier() );
+		}
+		return false;
+	}
+
+	// 'current' is the segment we are on/just passed over
+	const Segment *current = PriorSegment( m_goal );
+	if ( current == NULL )
+	{
+		return false;
+	}
+
+	// If path segment immediately ahead of us is not obstructed, don't try to climb.
+	// This is required to try to avoid accidentally climbing onto valid high ledges when we really want to run UNDER them to our destination.
+	// We need to check "immediate" traversability to pay attention to breakable objects in our way that we should climb over.
+	// We also need to check traversability out to 2 * ledgeLookAheadRange in case our goal is just before a tricky ledge climb and once we pass the goal it will be too late.
+	// When we're in a CLIMB_UP segment, allow us to look for ledges - we know the destination ledge height, and will only grab the correct ledge.
+	Vector toGoal = m_goal->pos - mover->GetFeet();
+	toGoal.NormalizeInPlace();
+
+	if ( toGoal.z < mover->GetTraversableSlopeLimit() &&
+		 !mover->IsStuck() && m_goal->type != CLIMB_UP &&
+		 mover->IsPotentiallyTraversable( mover->GetFeet(), mover->GetFeet() + 2.0f * ledgeLookAheadRange * toGoal, ILocomotion::IMMEDIATELY ) )
+	{
+		return false;
+	}
+
+
+	// can't do this - we have to find the ledge to deal with breakable railings
+#if 0
+	// If our path requires a climb, do the climb.
+	// This solves some issues where there are several possible climbable ledges at a given
+	// location, and we need to know which ledge to climb - just use the preplanned path's choice.
+	const Segment *ledge = NextSegment( m_goal );
+	if ( m_goal->type == CLIMB_UP && ledge )
+	{
+		const float startClimbRange = body->GetHullWidth();
+		if ( ( m_goal->pos - mover->GetFeet() ).IsLengthLessThan( startClimbRange ) )
+		{
+			mover->ClimbUpToLedge( ledge->pos, climbDirection );
+			return true;
+		}
+	}
+#endif 
+
+
+	
+	// Determine if we're approaching a planned climb.
+	// Start with current, the segment we are currently traversing.  Skip the distance check for that segment, because
+	// the pos is (hopefully) behind us.  And if it's a long path segment, it's already outside the climbLookAheadRange,
+	// and thus it would prevent us looking at m_goal and further for imminent planned climbs.
+	const float climbLookAheadRange = 150.0f;
+	bool isPlannedClimbImminent = false;
+	float plannedClimbZ = 0.0f;
+	for( const Segment *s = current; s; s = NextSegment( s ) )
+	{
+		if ( s != current && ( s->pos - mover->GetFeet() ).AsVector2D().IsLengthGreaterThan( climbLookAheadRange ) )
+		{
+			break;
+		}
+
+		if ( s->type == CLIMB_UP )
+		{
+			isPlannedClimbImminent = true;
+
+			const Segment *next = NextSegment( s );
+			if ( next )
+			{
+				plannedClimbZ = next->pos.z;
+			}
+			break;
+		}
+	}
+
+	unsigned int mask = body->GetSolidMask();
+	trace_t result;
+	NextBotTraversableTraceFilter filter( bot, ILocomotion::IMMEDIATELY );
+
+	const float hullWidth = body->GetHullWidth();
+	const float halfSize = hullWidth / 2.0f;
+	const float minHullHeight = body->GetCrouchHullHeight();
+	const float minLedgeHeight = mover->GetStepHeight() + 0.1f;
+
+	Vector skipStepHeightHullMin( -halfSize, -halfSize, minLedgeHeight );
+
+	// need to use minimum actual hull height here to catch porous fences and railings
+	Vector skipStepHeightHullMax( halfSize, halfSize, minHullHeight + 0.1f );
+
+
+	// Find the highest height we can stand at our current location.
+	// Using the full width hull catches on small lips/ledges, so back up and try again.
+	float ceilingFraction;
+
+	// We can't use IsPotentiallyTraversable to test for ledges, because it's smaller Hull can cause the
+	// next trace (trace the ceiling height forward) to start solid.
+	//	mover->IsPotentiallyTraversable( mover->GetFeet(), mover->GetFeet() + Vector( 0, 0, mover->GetMaxJumpHeight() ), ILocomotion::IMMEDIATELY, &ceilingFraction );
+
+	// Instead of IsPotentiallyTraversable, we back up the same distance and use a second upward trace
+	// to see if that one finds a higher ceiling.  If so, we use that ceiling height, and use the
+	// backed-up feet position for the ledge finding traces.
+	Vector feet( mover->GetFeet() );
+	Vector ceiling( feet + Vector( 0, 0, mover->GetMaxJumpHeight() ) );
+	mover->TraceHull( feet, ceiling,
+		skipStepHeightHullMin, skipStepHeightHullMax, mask, &filter, &result );
+	ceilingFraction = result.fraction;
+	bool isBackupTraceUsed = false;
+	if ( ceilingFraction < 1.0f || result.startsolid )
+	{
+		trace_t backupTrace;
+		const float backupDistance = hullWidth * 0.25f;	// The IsPotentiallyTraversable check this replaces uses a 1/4 hull width trace
+		Vector backupFeet( feet - climbDirection * backupDistance );
+		Vector backupCeiling( backupFeet + Vector( 0, 0, mover->GetMaxJumpHeight() ) );
+		mover->TraceHull( backupFeet, backupCeiling,
+			skipStepHeightHullMin, skipStepHeightHullMax, mask, &filter, &backupTrace );
+		if ( !backupTrace.startsolid && backupTrace.fraction > ceilingFraction )
+		{
+			bot->DebugConColorMsg( NEXTBOT_PATH, Color( 255, 255, 255, 255 ), "%s backing up when looking for max ledge height\n", bot->GetDebugIdentifier() );
+			result = backupTrace;
+			ceilingFraction = result.fraction;
+			feet = backupFeet;
+			ceiling = backupCeiling;
+			isBackupTraceUsed = true;
+		}
+	}
+
+	float maxLedgeHeight = ceilingFraction * mover->GetMaxJumpHeight();
+
+	if ( maxLedgeHeight <= mover->GetStepHeight() )
+	{
+		return false; // early out when we can't even climb StepHeight.
+	}
+
+	//
+	// Check for ledge climbs over things in our way.
+	// Even if we have a CLIMB_UP link in our path, we still need
+	// to find the actual ledge by tracing the local geometry.
+	//
+	Vector climbHullMax( halfSize, halfSize, maxLedgeHeight );
+
+	Vector ledgePos = feet;	// to be computed below
+
+	mover->TraceHull( feet, 
+					  feet + climbDirection * ledgeLookAheadRange, 
+					  skipStepHeightHullMin, climbHullMax, mask, &filter, &result );
+
+	if ( bot->IsDebugging( NEXTBOT_PATH ) && NextBotDebugClimbing.GetBool() )
+	{
+		// show ledge-finding hull as we move
+		NDebugOverlay::SweptBox( feet, 
+								 feet + climbDirection * ledgeLookAheadRange, 
+								 skipStepHeightHullMin, climbHullMax, vec3_angle,
+								 255, 100, 0, 255, 0.1f );
+	}
+
+	bool wasPotentialLedgeFound = result.DidHit() && !result.startsolid;
+	// To test climbing up past small lips on walls, we can force the bot to run past the overhang and use the backup trace:
+	// wasPotentialLedgeFound = wasPotentialLedgeFound && (result.fraction == 0 || isBackupTraceUsed);
+	if ( wasPotentialLedgeFound )
+	{
+		VPROF_BUDGET( "PathFollower::Climbing( Search for ledge to climb )", "NextBot" );
+
+		if ( bot->IsDebugging( NEXTBOT_PATH ) && NextBotDebugClimbing.GetBool() )
+		{
+			// show ledge-finding hull that found a ledge candidate 
+			NDebugOverlay::SweptBox( feet, 
+									 feet + climbDirection * ledgeLookAheadRange, 
+									 skipStepHeightHullMin, climbHullMax, vec3_angle,
+									 255, 100, 0, 100, 999.9f );
+
+			// show primary climb direction
+			NDebugOverlay::HorzArrow( feet, feet + 50.0f * climbDirection, 2.0f, 0, 255, 0, 255, true, 9999.9f );
+		}
+
+		// what are we climbing over?
+		CBaseEntity *obstacle = result.m_pEnt;
+
+		if ( !result.DidHitNonWorldEntity() || bot->IsAbleToClimbOnto( obstacle ) )
+		{			
+			if ( bot->IsDebugging( NEXTBOT_PATH ) )
+			{
+				DevMsg( "%3.2f: %s at potential ledge climb\n", gpGlobals->curtime, bot->GetDebugIdentifier() );
+			}
+
+			// the low hull sweep hit an obstacle - note how 'far in' this is
+			float ledgeFrontWallDepth = ledgeLookAheadRange * result.fraction;
+
+			float minLedgeDepth = body->GetHullWidth()/2.0f; // 5.0f;
+			if ( m_goal->type == CLIMB_UP )
+			{
+				// Climbing up to a narrow nav area indicates a narrow ledge.  We need to reduce our minLedgeDepth
+				// here or our path will say we should climb but we'll forever fail to find a wide enough ledge.
+				const Segment *afterClimb = NextSegment( m_goal );
+				if ( afterClimb && afterClimb->area )
+				{
+					Vector depthVector = climbDirection * minLedgeDepth;
+					depthVector.z = 0;
+					if ( fabs( depthVector.x ) > afterClimb->area->GetSizeX() )
+					{
+						depthVector.x = (depthVector.x > 0) ? afterClimb->area->GetSizeX() : -afterClimb->area->GetSizeX();
+					}
+					if ( fabs( depthVector.y ) > afterClimb->area->GetSizeY() )
+					{
+						depthVector.y = (depthVector.y > 0) ? afterClimb->area->GetSizeY() : -afterClimb->area->GetSizeY();
+					}
+
+					float areaDepth = depthVector.NormalizeInPlace();
+					minLedgeDepth = MIN( minLedgeDepth, areaDepth );
+				}
+			}
+
+			//
+			// Find the ledge.  Start at the lowest jump we can make
+			// and step up until we find the actual ledge.  
+			//
+			// The scan is limited to maxLedgeHeight in case our max 
+			// jump/climb height is so tall the highest horizontal hull 
+			// trace could be on the other side of the ceiling above us
+			//
+
+			float ledgeHeight = minLedgeHeight;
+			const float ledgeHeightIncrement = 0.5f * mover->GetStepHeight();
+
+			bool foundWall = false;
+			bool foundLedge = false;
+			
+			// once we have found the ledge's front wall, we must look at least minLedgeDepth farther in to verify it is a ledge
+			// NOTE: This *must* be ledgeLookAheadRange since ledges are compared against the initial trace which was ledgeLookAheadRange deep
+			float ledgeTopLookAheadRange = ledgeLookAheadRange;
+
+			// TODO: we also must look far enough ahead in case the ledge we actually find is "deeper" than the initial wall at the base
+
+			Vector climbHullMin( -halfSize, -halfSize, 0.0f );
+			Vector climbHullMax( halfSize, halfSize, minHullHeight );
+
+			Vector wallPos;
+			float wallDepth = 0.0f;
+
+			bool isLastIteration = false;
+			while( true )
+			{				
+				// trace forward to find the wall in front of us, or the empty space of the ledge above us
+				mover->TraceHull( feet + Vector( 0, 0, ledgeHeight ), 
+								feet + Vector( 0, 0, ledgeHeight ) + climbDirection * ledgeTopLookAheadRange, 
+								climbHullMin, climbHullMax, mask, &filter, &result );
+
+				float traceDepth = ledgeTopLookAheadRange * result.fraction;
+
+				if ( !result.startsolid )
+				{
+					// if trace reached minLedgeDepth farther, this is a potential ledge
+					if ( foundWall )
+					{
+						// TODO: test that potential ledge is flat enough to stand on
+						if ( ( traceDepth - ledgeFrontWallDepth ) > minLedgeDepth )
+						{
+							bool isUsable = true;
+
+							// initialize ledgePos from result of last trace
+							ledgePos = result.endpos;
+
+							// Find the actual ground level on the potential ledge
+							// Only trace back down to the previous ledge height trace. 
+							// The ledge can be no lower, or we would've found it in the last iteration.
+							mover->TraceHull( ledgePos,
+											ledgePos + Vector( 0, 0, -ledgeHeightIncrement ),
+											climbHullMin, climbHullMax, mask, &filter, &result );
+
+							ledgePos = result.endpos;
+
+							// if the whole trace is in solid, we're out of luck, but
+							// if the trace just started solid, 'ledgePos' should still be valid
+							// since the trace left the solid and then hit.
+							// if the trace hit nothing, the potential ledge is actually deeper in
+							const float MinGroundNormal = 0.7f;	// players can't stand on ground steeper than 0.7
+							if ( result.allsolid || !result.DidHit() || result.plane.normal.z < MinGroundNormal )
+							{
+								// not a usable ledge, try again
+								isUsable = false;
+							}
+							else
+							{
+								if ( climbUpLedgeHeightDelta > 0.0f )
+								{
+									// if we're climbing to a specific ledge via a CLIMB_UP link, only climb to that ledge.
+									// Do this only for the world (which includes static props) so we can still opportunistically
+									// climb up onto breakable railings and physics props.
+									if ( result.DidHitWorld() )
+									{
+										float potentialLedgeHeight = result.endpos.z - feet.z;
+										if ( fabs(potentialLedgeHeight - climbUpLedgeHeightDelta) > climbUpLedgeTolerance )
+										{
+											isUsable = false;
+										}
+									}
+								}
+							}
+
+							if ( isUsable )
+							{
+								// back up until we no longer are hitting the ledge to determine the
+								// exact ledge edge position
+								Vector validLedgePos = ledgePos; // save off a valid ledge pos
+								const float edgeTolerance = 4.0f;
+								const float maxBackUp = hullWidth;
+								float backUpSoFar = edgeTolerance;
+								Vector testPos = ledgePos;
+
+								while( backUpSoFar < maxBackUp )
+								{
+									testPos -= edgeTolerance * climbDirection;
+									backUpSoFar += edgeTolerance;
+
+									mover->TraceHull( testPos,
+													testPos + Vector( 0, 0, -ledgeHeightIncrement ),
+													climbHullMin, climbHullMax, mask, &filter, &result );
+
+									
+									if ( bot->IsDebugging( NEXTBOT_PATH ) && NextBotDebugClimbing.GetBool() )
+									{
+										// show edge-finder hulls
+										NDebugOverlay::SweptBox( testPos,
+																 testPos + Vector( 0, 0, -mover->GetStepHeight() ), 
+																 climbHullMin, climbHullMax, vec3_angle, 255, 0, 0, 255, 999.9f );
+									}
+
+									if ( result.DidHit() && result.plane.normal.z >= MinGroundNormal )
+									{
+										// we hit, this is closer to the actual ledge edge
+										ledgePos = result.endpos;
+									}
+									else
+									{
+										// nothing but air or a steep slope below us, we have found the edge
+										break;
+									}
+								}
+
+								// we want ledgePos to be right on the edge itself, so move 
+								// it ahead by half of the hull width
+								ledgePos += climbDirection * halfSize;
+
+								// Make sure this doesn't embed us in the far wall if the ledge is narrow, since we would
+								// have backed up less than halfSize.
+								Vector climbHullMinStep( climbHullMin ); // skip StepHeight for sloped ledges
+								mover->TraceHull( validLedgePos,
+									ledgePos,
+									climbHullMinStep, climbHullMax, mask, &filter, &result );
+
+								ledgePos = result.endpos;
+
+								// Now since ledgePos + StepHeight is valid, trace down to find ground on sloped ledges.
+								mover->TraceHull( ledgePos + Vector( 0, 0, StepHeight ),
+									ledgePos,
+									climbHullMin, climbHullMax, mask, &filter, &result );
+								if ( !result.startsolid )
+								{
+									ledgePos = result.endpos;
+								}
+							}
+
+
+/*** NOTE: While this saves us from climbing into a window below the window we want to get in,
+ *** it also causes us to climb in midair high over crates sitting against walls we need to climb over.
+							if ( isUsable && m_goal->type == CLIMB_UP )
+							{
+								// we can only accept ledges at least as high as our current CLIMB_UP destination
+								// NOTE: Can't use plannedClimbZ here, since that could be 2 or 3 short climbs ahead
+								const Segment *ledge = NextSegment( m_goal );
+
+								if ( !ledge || ledgeHeight < ledge->pos.z - feet.z - mover->GetStepHeight() )
+								{
+									// this ledge is below the CLIMB_UP destination - can't use it
+									isUsable = false;
+								}
+							}
+*/
+
+
+							if ( isUsable )
+							{
+								// found a usable ledge here
+								foundLedge = true;
+								break;
+							}
+						}
+					}
+					else if ( result.DidHit() )
+					{
+						// this iteration hit the wall under the ledge, 
+						// meaning the next iteration that reaches far enough will be our ledge
+
+						// Since we know that our desired route is likely blocked (via the 
+						// IsTraversable check above) - any ledge we hit we must climb.
+
+						// found a valid ledge wall
+						foundWall = true;
+						wallDepth = traceDepth;
+
+						// make sure the subsequent traces are at least minLedgeDepth deeper than
+						// the wall we just found, or all ledge checks will fail
+						float minTraceDepth = traceDepth + minLedgeDepth + 0.1f;
+
+						if ( ledgeTopLookAheadRange < minTraceDepth )
+						{
+							ledgeTopLookAheadRange = minTraceDepth;
+						}
+
+						if ( bot->IsDebugging( NEXTBOT_PATH ) )
+						{
+							DevMsg( "%3.2f: Climbing - found wall.\n", gpGlobals->curtime );
+							if ( NextBotDebugClimbing.GetBool() )
+							{
+								NDebugOverlay::HorzArrow( result.endpos, result.endpos + 20.0f * result.plane.normal, 5.0f, 255, 100, 0, 255, true, 9999.9f );
+							}
+							wallPos = result.endpos;
+						}
+					}
+					else if ( ledgeHeight > body->GetCrouchHullHeight() && !isPlannedClimbImminent )
+					{
+						// we haven't hit anything yet, and we're already above our heads - no obstacle
+						if ( bot->IsDebugging( NEXTBOT_PATH ) )
+						{
+							DevMsg( "%3.2f: Climbing - skipping overhead climb we can walk/crawl under.\n", gpGlobals->curtime );
+						}
+						break;
+					}
+				}
+
+				ledgeHeight += ledgeHeightIncrement;
+
+				if ( ledgeHeight >= maxLedgeHeight )
+				{
+					if ( isLastIteration )
+					{
+						// tested at max height
+						break;
+					}
+
+					// check one more time at max jump height
+					isLastIteration = true;
+					ledgeHeight = maxLedgeHeight;
+				}
+			}
+			
+			if ( foundLedge )
+			{
+				if ( bot->IsDebugging( NEXTBOT_PATH ) )
+				{
+					DevMsg( "%3.2f: STARTING LEDGE CLIMB UP\n", gpGlobals->curtime );
+
+					if ( NextBotDebugClimbing.GetBool() ) 
+					{
+						NDebugOverlay::Cross3D( ledgePos, 10.0f, 0, 255, 0, true, 9999.9f );
+
+						// display approximation of idealized ledge that has been found
+						Vector side( -climbDirection.y, climbDirection.x, 0.0f );
+
+						// this is an approximation, since AABB can hit at any angle
+						Vector base = feet + halfSize * climbDirection;
+
+						Vector wallBottomLeft = base + halfSize * side;
+						Vector wallBottomRight = base - halfSize * side;
+						Vector wallTopLeft = wallBottomLeft + Vector( 0, 0, ledgeHeight );
+						Vector wallTopRight = wallBottomRight + Vector( 0, 0, ledgeHeight );
+
+						NDebugOverlay::Triangle( wallBottomRight, wallBottomLeft, wallTopLeft, 255, 100, 0, 100, true, 9999.9f );
+						NDebugOverlay::Triangle( wallBottomRight, wallTopLeft, wallTopRight, 255, 100, 0, 100, true, 9999.9f );
+
+						Vector ledgeLeft = ledgePos + halfSize * side;
+						Vector ledgeRight = ledgePos - halfSize * side;
+
+						NDebugOverlay::Triangle( wallTopRight, wallTopLeft, ledgeLeft, 0, 100, 255, 100, true, 9999.9f );
+						NDebugOverlay::Triangle( wallTopRight, ledgeLeft, ledgeRight, 0, 100, 255, 100, true, 9999.9f );
+					}
+				}
+
+				if ( !mover->ClimbUpToLedge( ledgePos, climbDirection, obstacle ) )
+				{
+					// climb failed - build a new path in case we're now stuck
+					//Invalidate();
+					return false;
+				}
+
+				return true;
+			}
+			else if ( bot->IsDebugging( NEXTBOT_PATH ) )
+			{
+				DevMsg( "%3.2f: CANT FIND LEDGE TO CLIMB\n", gpGlobals->curtime );
+			}
+		}
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Jump over gaps
+ */
+bool PathFollower::JumpOverGaps( INextBot *bot, const Path::Segment *goal, const Vector &forward, const Vector &right, float goalRange )
+{
+	VPROF_BUDGET( "PathFollower::JumpOverGaps", "NextBot" );
+
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	IBody *body = bot->GetBodyInterface();
+
+	if ( !mover->IsAbleToJumpAcrossGaps() || !NextBotAllowGapJumping.GetBool() )
+	{
+		return false;
+	}
+
+	if ( mover->IsClimbingOrJumping() || mover->IsAscendingOrDescendingLadder() || !mover->IsOnGround() )
+	{
+		return false;
+	}
+	
+	if ( !body->IsActualPosture( IBody::STAND ) )
+	{
+		// can't jump if we're not standing
+		return false;
+	}
+
+	if ( m_goal == NULL )
+	{
+		return false;
+	}
+
+	trace_t result;
+	NextBotTraversableTraceFilter filter( bot, ILocomotion::IMMEDIATELY );
+
+	const float hullWidth = ( body ) ? body->GetHullWidth() : 1.0f;
+
+	// 'current' is the segment we are on/just passed over
+	const Segment *current = PriorSegment( m_goal );
+	if ( current == NULL )
+	{
+		return false;
+	}
+
+	const float minGapJumpRange = 2.0f * hullWidth;
+
+	const Segment *gap = NULL;
+
+	if ( current->type == JUMP_OVER_GAP )
+	{
+		gap = current;
+	}
+	else
+	{
+		float searchRange = goalRange;
+		for( const Segment *s = m_goal; s; s = NextSegment( s ) )
+		{
+			if ( searchRange > minGapJumpRange )
+			{
+				break;
+			}
+
+			if ( s->type == JUMP_OVER_GAP )
+			{
+				gap = s;
+				break;
+			}
+
+			searchRange += s->length;
+		}
+	}
+
+	if ( gap )
+	{
+		VPROF_BUDGET( "PathFollower::GapJumping", "NextBot" );
+
+		float halfWidth = hullWidth/2.0f;
+
+		if ( mover->IsGap( mover->GetFeet() + halfWidth * gap->forward, gap->forward ) )
+		{
+			// there is a gap to jump over
+			const Segment *landing = NextSegment( gap );
+			if ( landing )
+			{
+				mover->JumpAcrossGap( landing->pos, landing->forward );
+
+				// if we're jumping over this gap, make sure our goal is the landing so we aim for it
+				m_goal = landing;
+
+				if ( bot->IsDebugging( NEXTBOT_PATH ) )
+				{
+					NDebugOverlay::Cross3D( m_goal->pos, 5.0f, 0, 255, 255, true, 5.0f );
+					DevMsg( "%3.2f: GAP JUMP\n", gpGlobals->curtime );
+				}
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Draw the path for debugging
+ */
+void PathFollower::Draw( const Path::Segment *start ) const
+{
+	if ( m_goal == NULL )
+		return;
+		
+	// show avoid volumes	
+	if ( m_didAvoidCheck )
+	{
+		QAngle angles( 0, 0, 0 );
+		
+		if (m_isLeftClear)
+			NDebugOverlay::SweptBox( m_leftFrom, m_leftTo, m_hullMin, m_hullMax, angles, 0, 255, 0, 255, 0.1f );
+		else
+			NDebugOverlay::SweptBox( m_leftFrom, m_leftTo, m_hullMin, m_hullMax, angles, 255, 0, 0, 255, 0.1f );
+			
+		if (m_isRightClear)
+			NDebugOverlay::SweptBox( m_rightFrom, m_rightTo, m_hullMin, m_hullMax, angles, 0, 255, 0, 255, 0.1f );
+		else
+			NDebugOverlay::SweptBox( m_rightFrom, m_rightTo, m_hullMin, m_hullMax, angles, 255, 0, 0, 255, 0.1f );
+
+		const_cast< PathFollower * >( this )->m_didAvoidCheck = false;
+	}
+
+	// highlight current goal segment
+	if ( m_goal )
+	{
+		const float size = 5.0f;	
+		NDebugOverlay::Sphere( m_goal->pos, size, 255, 255, 0, true, 0.1f );
+
+		switch( m_goal->how )
+		{
+		case GO_NORTH:
+		case GO_SOUTH:
+			NDebugOverlay::Line( m_goal->m_portalCenter - Vector( m_goal->m_portalHalfWidth, 0, 0 ), m_goal->m_portalCenter + Vector( m_goal->m_portalHalfWidth, 0, 0 ), 255, 0, 255, true, 0.1f );
+			break;
+
+		default:
+			NDebugOverlay::Line( m_goal->m_portalCenter - Vector( 0, m_goal->m_portalHalfWidth, 0 ), m_goal->m_portalCenter + Vector( 0, m_goal->m_portalHalfWidth, 0 ), 255, 0, 255, true, 0.1f );
+			break;
+		}
+
+		// 'current' is the segment we are on/just passed over
+		const Segment *current = PriorSegment( m_goal );
+		if ( current )
+		{
+			NDebugOverlay::Line( current->pos, m_goal->pos, 255, 255, 0, true, 0.1f );
+		}
+	}
+
+	// extend
+	Path::Draw();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if there is a the given discontinuity ahead in the path within the given range (-1 = entire remaining path)
+ */
+bool PathFollower::IsDiscontinuityAhead( INextBot *bot, Path::SegmentType type, float range ) const
+{
+	if ( m_goal )
+	{
+		const Path::Segment *current = PriorSegment( m_goal );
+		if ( current && current->type == type )
+		{
+			// we're on the discontinuity now
+			return true;
+		}
+
+		float rangeSoFar = ( m_goal->pos - bot->GetLocomotionInterface()->GetFeet() ).Length();
+
+		for( const Segment *s = m_goal; s; s = NextSegment( s ) )
+		{
+			if ( rangeSoFar >= range )
+			{
+				break;
+			}
+
+			if ( s->type == type )
+			{
+				return true;
+			}
+
+			rangeSoFar += s->length;
+		}
+	}
+
+	return false;
+}
+
+
diff --git a/game/server/NextBot/Path/NextBotPathFollow.h b/game/server/NextBot/Path/NextBotPathFollow.h
new file mode 100644
index 00000000..edb27b54
--- /dev/null
+++ b/game/server/NextBot/Path/NextBotPathFollow.h
@@ -0,0 +1,106 @@
+// NextBotPathFollow.h
+// Path following
+// Author: Michael Booth, April 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_PATH_FOLLOWER_
+#define _NEXT_BOT_PATH_FOLLOWER_
+
+#include "nav_mesh.h"
+#include "nav_pathfind.h"
+#include "NextBotPath.h"
+
+class INextBot;
+class ILocomotion;
+
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * A PathFollower extends a Path to include mechanisms to move along (follow) it
+ */
+class PathFollower : public Path
+{
+public:
+	PathFollower( void );
+	virtual ~PathFollower();
+
+	virtual void Invalidate( void );				// (EXTEND) cause the path to become invalid
+	virtual void Draw( const Path::Segment *start = NULL ) const;	// (EXTEND) draw the path for debugging
+	virtual void OnPathChanged( INextBot *bot, Path::ResultType result );	// invoked when the path is (re)computed (path is valid at the time of this call)
+
+	virtual void Update( INextBot *bot );			// move bot along path
+
+	virtual const Path::Segment *GetCurrentGoal( void ) const;	// return current goal along the path we are trying to reach
+
+	virtual void SetMinLookAheadDistance( float value );		// minimum range movement goal must be along path
+	
+	virtual CBaseEntity *GetHindrance( void ) const;			// returns entity that is hindering our progress along the path
+
+	virtual bool IsDiscontinuityAhead( INextBot *bot, Path::SegmentType type, float range = -1.0f ) const;	// return true if there is a the given discontinuity ahead in the path within the given range (-1 = entire remaining path)
+
+	void SetGoalTolerance( float range );			// set tolerance within at which we're considered to be at our goal
+
+private:
+	const Path::Segment *m_goal;					// our current goal along the path
+	float m_minLookAheadRange;
+
+	bool CheckProgress( INextBot *bot );
+	bool IsAtGoal( INextBot *bot ) const;			// return true if reached current path goal
+
+	//bool IsOnStairs( INextBot *bot ) const;		// return true if bot is standing on a stairway
+	bool m_isOnStairs;
+
+	CountdownTimer m_avoidTimer;					// do avoid check more often if we recently avoided
+
+	CountdownTimer m_waitTimer;						// for waiting for a blocker to move off our path
+	CHandle< CBaseEntity > m_hindrance;
+	
+	// debug display data for avoid volumes
+	bool m_didAvoidCheck;
+	Vector m_leftFrom;
+	Vector m_leftTo;
+	bool m_isLeftClear;
+	Vector m_rightFrom;
+	Vector m_rightTo;
+	bool m_isRightClear;
+	Vector m_hullMin, m_hullMax;
+
+	void AdjustSpeed( INextBot *bot );				// adjust speed based on path curvature
+
+	Vector Avoid( INextBot *bot, const Vector &goalPos, const Vector &forward, const Vector &left );		// avoidance movements for very nearby obstacles. returns modified goal position
+	bool Climbing( INextBot *bot, const Path::Segment *goal, const Vector &forward, const Vector &left, float goalRange );		// climb up ledges 
+	bool JumpOverGaps( INextBot *bot, const Path::Segment *goal, const Vector &forward, const Vector &left, float goalRange );	// jump over gaps
+
+	bool LadderUpdate( INextBot *bot );				// move bot along ladder
+	CBaseEntity *FindBlocker( INextBot *bot );		// if entity is returned, it is blocking us from continuing along our path
+
+	float m_goalTolerance;
+};
+
+
+inline void PathFollower::SetGoalTolerance( float range )
+{
+	m_goalTolerance = range;
+}
+
+
+inline const Path::Segment *PathFollower::GetCurrentGoal( void ) const
+{
+	return m_goal;
+}
+
+
+inline void PathFollower::SetMinLookAheadDistance( float value )
+{
+	m_minLookAheadRange = value;
+}
+
+inline CBaseEntity *PathFollower::GetHindrance( void ) const
+{
+	return m_hindrance;
+}
+
+
+#endif // _NEXT_BOT_PATH_FOLLOWER_
+
+
diff --git a/game/server/NextBot/Path/NextBotRetreatPath.h b/game/server/NextBot/Path/NextBotRetreatPath.h
new file mode 100644
index 00000000..8d57cb47
--- /dev/null
+++ b/game/server/NextBot/Path/NextBotRetreatPath.h
@@ -0,0 +1,573 @@
+// NextBotRetreatPath.h
+// Maintain and follow a path that leads safely away from the given Actor
+// Author: Michael Booth, February 2007
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_RETREAT_PATH_
+#define _NEXT_BOT_RETREAT_PATH_
+
+#include "nav.h"
+#include "NextBotInterface.h"
+#include "NextBotLocomotionInterface.h"
+#include "NextBotRetreatPath.h"
+#include "NextBotUtil.h"
+#include "NextBotPathFollow.h"
+#include "tier0/vprof.h"
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * A RetreatPath extends a PathFollower to periodically recompute a path 
+ * away from a threat, and to move along the path away from that threat.
+ */
+class RetreatPath : public PathFollower
+{
+public:
+	RetreatPath( void );
+	virtual ~RetreatPath() { }
+
+	void Update( INextBot *bot, CBaseEntity *threat );	// update path away from threat and move bot along path
+
+	virtual float GetMaxPathLength( void ) const;		// return maximum path length
+
+	virtual void Invalidate( void );					// (EXTEND) cause the path to become invalid
+
+private:
+	void RefreshPath( INextBot *bot, CBaseEntity *threat );
+
+	CountdownTimer m_throttleTimer;						// require a minimum time between re-paths
+	EHANDLE m_pathThreat;								// the threat of our existing path
+	Vector m_pathThreatPos;								// where the threat was when the path was built
+};
+
+inline RetreatPath::RetreatPath( void )
+{
+	m_throttleTimer.Invalidate();
+	m_pathThreat = NULL;
+}
+
+inline float RetreatPath::GetMaxPathLength( void ) const
+{
+	return 1000.0f;
+}
+
+inline void RetreatPath::Invalidate( void )
+{
+	// path is gone, repath at earliest opportunity
+	m_throttleTimer.Invalidate();
+	m_pathThreat = NULL;
+
+	// extend
+	PathFollower::Invalidate();	
+}
+
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Maintain a path to our chase threat and move along that path
+ */
+inline void RetreatPath::Update( INextBot *bot, CBaseEntity *threat )
+{
+	VPROF_BUDGET( "RetreatPath::Update", "NextBot" );
+
+	if ( threat == NULL )
+	{
+		return;
+	}
+
+	// if our path threat changed, repath immediately
+	if ( threat != m_pathThreat )
+	{
+		if ( bot->IsDebugging( INextBot::PATH ) )
+		{
+			DevMsg( "%3.2f: bot(#%d) Chase path threat changed (from %X to %X).\n", gpGlobals->curtime, bot->GetEntity()->entindex(), m_pathThreat.Get(), threat );
+		}
+
+		Invalidate();
+	}
+
+	// maintain the path away from the threat
+	RefreshPath( bot, threat );
+
+	// move along the path towards the threat
+	PathFollower::Update( bot );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Build a path away from retreatFromArea up to retreatRange in length.
+ */
+class RetreatPathBuilder
+{
+public:
+	RetreatPathBuilder( INextBot *me, CBaseEntity *threat, float retreatRange = 500.0f )
+	{
+		m_me = me;
+		m_mover = me->GetLocomotionInterface();
+		
+		m_threat = threat;
+		m_retreatRange = retreatRange;
+	}
+
+	CNavArea *ComputePath( void )
+	{
+		VPROF_BUDGET( "NavAreaBuildRetreatPath", "NextBot" );
+		
+		if ( m_mover == NULL )
+			return NULL;
+		
+		CNavArea *startArea = m_me->GetEntity()->GetLastKnownArea();
+
+		if ( startArea == NULL )
+			return NULL;
+
+		CNavArea *retreatFromArea = TheNavMesh->GetNearestNavArea( m_threat->GetAbsOrigin() );
+		if ( retreatFromArea == NULL )
+			return NULL;
+
+		startArea->SetParent( NULL );
+
+		// start search
+		CNavArea::ClearSearchLists();
+
+		float initCost = Cost( startArea, NULL, NULL );
+		if ( initCost < 0.0f )
+			return NULL;
+
+		int teamID = m_me->GetEntity()->GetTeamNumber();
+
+		startArea->SetTotalCost( initCost );
+
+		startArea->AddToOpenList();
+		
+		// keep track of the area farthest away from the threat
+		CNavArea *farthestArea = NULL;
+		float farthestRange = 0.0f;
+
+		//
+		// Dijkstra's algorithm (since we don't know our goal).
+		// Build a path as far away from the retreat area as possible.
+		// Minimize total path length and danger.
+		// Maximize distance to threat of end of path.
+		//
+		while( !CNavArea::IsOpenListEmpty() )
+		{
+			// get next area to check
+			CNavArea *area = CNavArea::PopOpenList();
+
+			area->AddToClosedList();
+
+			// don't consider blocked areas
+			if ( area->IsBlocked( teamID ) )
+				continue;
+
+			// build adjacent area array
+			CollectAdjacentAreas( area );
+			
+			// search adjacent areas
+			for( int i=0; i<m_adjAreaIndex; ++i )
+			{
+				CNavArea *newArea = m_adjAreaVector[ i ].area;
+				
+				// only visit each area once
+				if ( newArea->IsClosed() )
+					continue;
+				
+				// don't consider blocked areas
+				if ( newArea->IsBlocked( teamID ) )
+					continue;
+
+				// don't use this area if it is out of range
+				if ( ( newArea->GetCenter() - m_me->GetEntity()->GetAbsOrigin() ).IsLengthGreaterThan( m_retreatRange ) )
+					continue;
+				
+				// determine cost of traversing this area
+				float newCost = Cost( newArea, area, m_adjAreaVector[ i ].ladder );
+				
+				// don't use adjacent area if cost functor says it is a dead-end
+				if ( newCost < 0.0f )
+					continue;
+					
+				if ( newArea->IsOpen() && newArea->GetTotalCost() <= newCost )
+				{
+					// we have already visited this area, and it has a better path
+					continue;
+				}
+				else
+				{
+					// whether this area has been visited or not, we now have a better path
+					newArea->SetParent( area, m_adjAreaVector[ i ].how );
+					newArea->SetTotalCost( newCost );
+
+					// use 'cost so far' to hold cumulative cost
+					newArea->SetCostSoFar( newCost );
+
+					// tricky bit here - relying on OpenList being sorted by cost
+					if ( newArea->IsOpen() )
+					{
+						// area already on open list, update the list order to keep costs sorted
+						newArea->UpdateOnOpenList();
+					}
+					else
+					{
+						newArea->AddToOpenList();
+					}
+
+					// keep track of area farthest from threat
+					float threatRange = ( newArea->GetCenter() - m_threat->GetAbsOrigin() ).Length();
+					if ( threatRange > farthestRange )
+					{
+						farthestArea = newArea;
+						farthestRange = threatRange;
+					}
+				}
+			}
+		}
+
+		return farthestArea;
+	}
+
+
+	/**
+	 * Build a vector of adjacent areas reachable from the given area
+	 */
+	void CollectAdjacentAreas( CNavArea *area )
+	{
+		m_adjAreaIndex = 0;			
+
+		const NavConnectVector &adjNorth = *area->GetAdjacentAreas( NORTH );		
+		FOR_EACH_VEC( adjNorth, it )
+		{
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			m_adjAreaVector[ m_adjAreaIndex ].area = adjNorth[ it ].area;
+			m_adjAreaVector[ m_adjAreaIndex ].how = GO_NORTH;
+			m_adjAreaVector[ m_adjAreaIndex ].ladder = NULL;
+			++m_adjAreaIndex;
+		}
+
+		const NavConnectVector &adjSouth = *area->GetAdjacentAreas( SOUTH );		
+		FOR_EACH_VEC( adjSouth, it )
+		{
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			m_adjAreaVector[ m_adjAreaIndex ].area = adjSouth[ it ].area;
+			m_adjAreaVector[ m_adjAreaIndex ].how = GO_SOUTH;
+			m_adjAreaVector[ m_adjAreaIndex ].ladder = NULL;
+			++m_adjAreaIndex;
+		}
+
+		const NavConnectVector &adjWest = *area->GetAdjacentAreas( WEST );		
+		FOR_EACH_VEC( adjWest, it )
+		{
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			m_adjAreaVector[ m_adjAreaIndex ].area = adjWest[ it ].area;
+			m_adjAreaVector[ m_adjAreaIndex ].how = GO_WEST;
+			m_adjAreaVector[ m_adjAreaIndex ].ladder = NULL;
+			++m_adjAreaIndex;
+		}
+
+		const NavConnectVector &adjEast = *area->GetAdjacentAreas( EAST );	
+		FOR_EACH_VEC( adjEast, it )
+		{
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			m_adjAreaVector[ m_adjAreaIndex ].area = adjEast[ it ].area;
+			m_adjAreaVector[ m_adjAreaIndex ].how = GO_EAST;
+			m_adjAreaVector[ m_adjAreaIndex ].ladder = NULL;
+			++m_adjAreaIndex;
+		}
+
+		const NavLadderConnectVector &adjUpLadder = *area->GetLadders( CNavLadder::LADDER_UP );
+		FOR_EACH_VEC( adjUpLadder, it )
+		{
+			CNavLadder *ladder = adjUpLadder[ it ].ladder;
+
+			if ( ladder->m_topForwardArea && m_adjAreaIndex < MAX_ADJ_AREAS )
+			{
+				m_adjAreaVector[ m_adjAreaIndex ].area = ladder->m_topForwardArea;
+				m_adjAreaVector[ m_adjAreaIndex ].how = GO_LADDER_UP;
+				m_adjAreaVector[ m_adjAreaIndex ].ladder = ladder;
+				++m_adjAreaIndex;
+			}
+
+			if ( ladder->m_topLeftArea && m_adjAreaIndex < MAX_ADJ_AREAS )
+			{
+				m_adjAreaVector[ m_adjAreaIndex ].area = ladder->m_topLeftArea;
+				m_adjAreaVector[ m_adjAreaIndex ].how = GO_LADDER_UP;
+				m_adjAreaVector[ m_adjAreaIndex ].ladder = ladder;
+				++m_adjAreaIndex;
+			}
+
+			if ( ladder->m_topRightArea && m_adjAreaIndex < MAX_ADJ_AREAS )
+			{
+				m_adjAreaVector[ m_adjAreaIndex ].area = ladder->m_topRightArea;
+				m_adjAreaVector[ m_adjAreaIndex ].how = GO_LADDER_UP;
+				m_adjAreaVector[ m_adjAreaIndex ].ladder = ladder;
+				++m_adjAreaIndex;
+			}
+		}
+
+		const NavLadderConnectVector &adjDownLadder = *area->GetLadders( CNavLadder::LADDER_DOWN );
+		FOR_EACH_VEC( adjDownLadder, it )
+		{
+			CNavLadder *ladder = adjDownLadder[ it ].ladder;
+
+			if ( m_adjAreaIndex >= MAX_ADJ_AREAS )
+				break;
+
+			if ( ladder->m_bottomArea )
+			{
+				m_adjAreaVector[ m_adjAreaIndex ].area = ladder->m_bottomArea;
+				m_adjAreaVector[ m_adjAreaIndex ].how = GO_LADDER_DOWN;
+				m_adjAreaVector[ m_adjAreaIndex ].ladder = ladder;
+				++m_adjAreaIndex;
+			}
+		}
+	}
+	
+	/**
+	 * Cost minimizes path length traveled thus far and "danger" (proximity to threat(s))
+	 */
+	float Cost( CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder )
+	{
+		// check if we can use this area
+		if ( !m_mover->IsAreaTraversable( area ) )
+		{
+			return -1.0f;
+		}
+
+		int teamID = m_me->GetEntity()->GetTeamNumber();
+		if ( area->IsBlocked( teamID ) )
+		{
+			return -1.0f;
+		}
+		
+		const float debugDeltaT = 3.0f;
+
+		float cost;
+
+		const float maxThreatRange = 500.0f;
+		const float dangerDensity = 1000.0f;
+
+		if ( fromArea == NULL )
+		{
+			cost = 0.0f;
+			
+			if ( area->Contains( m_threat->GetAbsOrigin() ) )
+			{
+				// maximum danger - threat is in the area with us
+				cost += 10.0f * dangerDensity;
+				
+				if ( m_me->IsDebugging( INextBot::PATH ) )
+				{
+					area->DrawFilled( 255, 0, 0, 128 );
+				}
+			}
+			else
+			{
+				// danger proportional to range to us
+				float rangeToThreat = ( m_threat->GetAbsOrigin() - m_me->GetEntity()->GetAbsOrigin() ).Length();
+
+				if ( rangeToThreat < maxThreatRange )
+				{
+					cost += dangerDensity * ( 1.0f - ( rangeToThreat / maxThreatRange ) );
+
+					if ( m_me->IsDebugging( INextBot::PATH ) )
+					{
+						NDebugOverlay::Line( m_me->GetEntity()->GetAbsOrigin(), m_threat->GetAbsOrigin(), 255, 0, 0, true, debugDeltaT );
+					}
+				}				
+			}
+		}
+		else
+		{
+			// compute distance traveled along path so far
+			float dist;
+
+			if ( ladder )
+			{
+				const float ladderCostFactor = 100.0f;
+				dist = ladderCostFactor * ladder->m_length;
+			}
+			else
+			{
+				Vector to = area->GetCenter() - fromArea->GetCenter();
+
+				dist = to.Length();
+
+				// check for vertical discontinuities
+				Vector closeFrom, closeTo;
+				area->GetClosestPointOnArea( fromArea->GetCenter(), &closeTo );
+				fromArea->GetClosestPointOnArea( area->GetCenter(), &closeFrom );
+				
+				float deltaZ = closeTo.z - closeFrom.z;
+
+				if ( deltaZ > m_mover->GetMaxJumpHeight() )
+				{
+					// too high to jump
+					return -1.0f;
+				}
+				else if ( -deltaZ > m_mover->GetDeathDropHeight() )
+				{
+					// too far down to drop
+					return -1.0f;
+				}
+
+				// prefer to maintain our level
+				const float climbCost = 10.0f;
+				dist += climbCost * fabs( deltaZ );
+			}
+
+			cost = dist + fromArea->GetTotalCost();
+
+			
+			// Add in danger cost due to threat
+			// Assume straight line between areas and find closest point
+			// to the threat along that line segment. The distance between
+			// the threat and closest point on the line is the danger cost.		
+			
+			// path danger is CUMULATIVE
+			float dangerCost = fromArea->GetCostSoFar();
+			
+			Vector close;
+			float t;
+			CalcClosestPointOnLineSegment( m_threat->GetAbsOrigin(), area->GetCenter(), fromArea->GetCenter(), close, &t );
+			if ( t < 0.0f )
+			{
+				close = area->GetCenter();
+			}
+			else if ( t > 1.0f )
+			{
+				close = fromArea->GetCenter();
+			}
+
+			float rangeToThreat = ( m_threat->GetAbsOrigin() - close ).Length();
+
+			if ( rangeToThreat < maxThreatRange )
+			{
+				float dangerFactor = 1.0f - ( rangeToThreat / maxThreatRange );
+				dangerCost = dangerDensity * dangerFactor;
+
+				if ( m_me->IsDebugging( INextBot::PATH ) )
+				{
+					NDebugOverlay::HorzArrow( fromArea->GetCenter(), area->GetCenter(), 5, 255 * dangerFactor, 0, 0, 255, true, debugDeltaT );
+
+					Vector to = close - m_threat->GetAbsOrigin();
+					to.NormalizeInPlace();
+
+					NDebugOverlay::Line( close, close - 50.0f * to, 255, 0, 0, true, debugDeltaT );
+				}
+			}
+			
+			cost += dangerCost;
+		}
+
+		return cost;
+	}
+	
+private:	
+	INextBot *m_me;
+	ILocomotion *m_mover;
+	
+	CBaseEntity *m_threat;
+	float m_retreatRange;
+
+	enum { MAX_ADJ_AREAS = 64 };
+	
+	struct AdjInfo
+	{
+		CNavArea *area;
+		CNavLadder *ladder;
+		NavTraverseType how;		
+	};
+	
+	AdjInfo m_adjAreaVector[ MAX_ADJ_AREAS ];
+	int m_adjAreaIndex;
+	
+};
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Periodically rebuild the path away from our threat
+ */
+inline void RetreatPath::RefreshPath( INextBot *bot, CBaseEntity *threat )
+{
+	VPROF_BUDGET( "RetreatPath::RefreshPath", "NextBot" );
+
+	if ( threat == NULL )
+	{
+		if ( bot->IsDebugging( INextBot::PATH ) )
+		{
+			DevMsg( "%3.2f: bot(#%d) CasePath::RefreshPath failed. No threat.\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+		}
+		return;
+	}
+
+	// don't change our path if we're on a ladder
+	ILocomotion *mover = bot->GetLocomotionInterface();
+	if ( IsValid() && mover && mover->IsUsingLadder() )
+	{
+		if ( bot->IsDebugging( INextBot::PATH ) )
+		{
+			DevMsg( "%3.2f: bot(#%d) RetreatPath::RefreshPath failed. Bot is on a ladder.\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+		}
+		return;
+	}
+
+	// the closer we get, the more accurate our path needs to be
+	Vector to = threat->GetAbsOrigin() - bot->GetPosition();
+	
+	const float minTolerance = 0.0f;
+	const float toleranceRate = 0.33f;
+	
+	float tolerance = minTolerance + toleranceRate * to.Length();
+
+	if ( !IsValid() || ( threat->GetAbsOrigin() - m_pathThreatPos ).IsLengthGreaterThan( tolerance ) )
+	{
+		if ( !m_throttleTimer.IsElapsed() )
+		{
+			// require a minimum time between repaths, as long as we have a path to follow
+			if ( bot->IsDebugging( INextBot::PATH ) )
+			{
+				DevMsg( "%3.2f: bot(#%d) RetreatPath::RefreshPath failed. Rate throttled.\n", gpGlobals->curtime, bot->GetEntity()->entindex() );
+			}
+			return;
+		}
+
+		// remember our path threat
+		m_pathThreat = threat;
+		m_pathThreatPos = threat->GetAbsOrigin();
+
+		RetreatPathBuilder retreat( bot, threat, GetMaxPathLength() );
+
+		CNavArea *goalArea = retreat.ComputePath();
+
+		if ( goalArea )
+		{
+			AssemblePrecomputedPath( bot, goalArea->GetCenter(), goalArea );
+		}	
+		else
+		{
+			// all adjacent areas are too far away - just move directly away from threat
+			Vector to = threat->GetAbsOrigin() - bot->GetPosition();
+
+			BuildTrivialPath( bot, bot->GetPosition() - to );
+		}
+			
+		const float minRepathInterval = 0.5f;
+		m_throttleTimer.Start( minRepathInterval );
+	}
+}
+
+
+
+#endif // _NEXT_BOT_RETREAT_PATH_
diff --git a/game/server/NextBot/Player/NextBotPlayer.cpp b/game/server/NextBot/Player/NextBotPlayer.cpp
new file mode 100644
index 00000000..a2121f76
--- /dev/null
+++ b/game/server/NextBot/Player/NextBotPlayer.cpp
@@ -0,0 +1,22 @@
+// NextBotPlayer.cpp
+// A CBasePlayer bot based on the NextBot technology
+// Author: Michael Booth, November 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "nav_mesh.h"
+
+#include "NextBot.h"
+#include "NextBotPlayer.h"
+
+#include "in_buttons.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+ConVar NextBotPlayerStop( "nb_player_stop", "0", FCVAR_CHEAT, "Stop all NextBotPlayers from updating" );
+ConVar NextBotPlayerWalk( "nb_player_walk", "0", FCVAR_CHEAT, "Force bots to walk" );
+ConVar NextBotPlayerCrouch( "nb_player_crouch", "0", FCVAR_CHEAT, "Force bots to crouch" );
+ConVar NextBotPlayerMove( "nb_player_move", "1", FCVAR_CHEAT, "Prevents bots from moving" );
+
diff --git a/game/server/NextBot/Player/NextBotPlayer.h b/game/server/NextBot/Player/NextBotPlayer.h
new file mode 100644
index 00000000..2032c727
--- /dev/null
+++ b/game/server/NextBot/Player/NextBotPlayer.h
@@ -0,0 +1,910 @@
+// NextBotPlayer.h
+// A CBasePlayer bot based on the NextBot technology
+// Author: Michael Booth, November 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_PLAYER_H_
+#define _NEXT_BOT_PLAYER_H_
+
+#include "cbase.h"
+#include "gameinterface.h"
+
+#include "NextBot.h"
+#include "Path/NextBotPathFollow.h"
+//#include "NextBotPlayerBody.h"
+#include "NextBotBehavior.h"
+
+#include "in_buttons.h"
+
+extern ConVar NextBotPlayerStop;
+extern ConVar NextBotPlayerWalk;
+extern ConVar NextBotPlayerCrouch;
+extern ConVar NextBotPlayerMove;
+
+
+
+//--------------------------------------------------------------------------------------------------
+/**
+ * Instantiate a NextBot derived from CBasePlayer and spawn it into the environment.
+ * Assumes class T is derived from CBasePlayer, and has the following method that
+ * creates a new entity of type T and returns it:
+ *
+ * static CBasePlayer *T::AllocatePlayerEntity( edict_t *pEdict, const char *playerName )
+ *
+ */
+template < typename T > 
+T * NextBotCreatePlayerBot( const char *name, bool bReportFakeClient = true )
+{
+	/*
+	if ( UTIL_ClientsInGame() >= gpGlobals->maxClients )
+	{
+	Msg( "CreatePlayerBot: Failed - server is full (%d/%d clients).\n", UTIL_ClientsInGame(), gpGlobals->maxClients );
+	return NULL;
+	}
+	*/
+
+	// This is a "back door" for allocating a custom player bot entity when
+	// the engine calls ClientPutInServer (from CreateFakeClient)
+	ClientPutInServerOverride( T::AllocatePlayerEntity );
+
+	// create the bot and spawn it into the environment
+	edict_t *botEdict = engine->CreateFakeClientEx( name, bReportFakeClient );
+
+	// close the "back door"
+	ClientPutInServerOverride( NULL );
+
+	if ( botEdict == NULL )
+	{
+		Msg( "CreatePlayerBot: Unable to create bot %s - CreateFakeClient() returned NULL.\n", name );
+		return NULL;
+	}
+
+	// create an instance of the bot's class and bind it to the edict
+	T *bot = dynamic_cast< T * >( CBaseEntity::Instance( botEdict ) );
+
+	if ( bot == NULL )
+	{
+		Assert( false );
+		Error( "CreatePlayerBot: Could not Instance() from the bot edict.\n" );
+		return NULL;
+	}
+
+	bot->SetPlayerName( name );
+
+	// flag this as a fakeclient (bot)
+	bot->ClearFlags();
+	bot->AddFlag( FL_CLIENT | FL_FAKECLIENT );
+
+	return bot;
+}
+
+
+//--------------------------------------------------------------------------------------------------
+/**
+ * Interface to access player input buttons.
+ * Unless a duration is given, each button is released at the start of the next frame.
+ * The release methods allow releasing a button before its duration has elapsed.
+ */
+class INextBotPlayerInput
+{
+public:
+	virtual void PressFireButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseFireButton( void ) = 0;
+
+	virtual void PressAltFireButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseAltFireButton( void ) = 0;
+
+	virtual void PressMeleeButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseMeleeButton( void ) = 0;
+
+	virtual void PressSpecialFireButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseSpecialFireButton( void ) = 0;
+
+	virtual void PressUseButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseUseButton( void ) = 0;
+
+	virtual void PressReloadButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseReloadButton( void ) = 0;
+	
+	virtual void PressForwardButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseForwardButton( void ) = 0;
+
+	virtual void PressBackwardButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseBackwardButton( void ) = 0;
+
+	virtual void PressLeftButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseLeftButton( void ) = 0;
+
+	virtual void PressRightButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseRightButton( void ) = 0;
+
+	virtual void PressJumpButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseJumpButton( void ) = 0;
+
+	virtual void PressCrouchButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseCrouchButton( void ) = 0;
+
+	virtual void PressWalkButton( float duration = -1.0f ) = 0;
+	virtual void ReleaseWalkButton( void ) = 0;
+
+	virtual void SetButtonScale( float forward, float right ) = 0;
+};
+
+
+//--------------------------------------------------------------------------------------------------
+/**
+ * Drive a CBasePlayer-derived entity via NextBot logic
+ */
+template < typename PlayerType >
+class NextBotPlayer : public PlayerType, public INextBot, public INextBotPlayerInput
+{
+public:
+	DECLARE_CLASS( NextBotPlayer, PlayerType );
+
+	NextBotPlayer( void );
+	virtual ~NextBotPlayer();
+
+	virtual void Spawn( void );
+
+	virtual void SetSpawnPoint( CBaseEntity *spawnPoint );						// define place in environment where bot will (re)spawn
+	virtual CBaseEntity		*EntSelectSpawnPoint( void );
+
+	virtual void PhysicsSimulate( void );
+
+	virtual bool IsNetClient( void ) const { return false; }					// Bots should return FALSE for this, they can't receive NET messages
+	virtual bool IsFakeClient( void ) const { return true; }
+	virtual bool IsBot( void ) const { return true; }
+	virtual INextBot *MyNextBotPointer( void ) { return this; }
+
+	// this is valid because the templatized PlayerType must be derived from CBasePlayer, which is derived from CBaseCombatCharacter
+	virtual CBaseCombatCharacter *GetEntity( void ) const { return ( PlayerType * )this; }	
+
+	virtual bool IsRemovedOnReset( void ) const { return false; }				// remove this bot when the NextBot manager calls Reset
+
+	virtual bool IsDormantWhenDead( void ) const	{ return true; }			// should this player-bot continue to update itself when dead (respawn logic, etc)
+
+	// allocate a bot and bind it to the edict
+	static CBasePlayer *AllocatePlayerEntity( edict_t *edict, const char *playerName );
+
+	//------------------------------------------------------------------------
+	// utility methods
+	float GetDistanceBetween( CBaseEntity *other ) const;						// return distance between us and the given entity
+	bool IsDistanceBetweenLessThan( CBaseEntity *other, float range ) const;	// return true if distance between is less than the given value
+	bool IsDistanceBetweenGreaterThan( CBaseEntity *other, float range ) const;	// return true if distance between is greater than the given value
+
+	float GetDistanceBetween( const Vector &target ) const;						// return distance between us and the given entity
+	bool IsDistanceBetweenLessThan( const Vector &target, float range ) const;	// return true if distance between is less than the given value
+	bool IsDistanceBetweenGreaterThan( const Vector &target, float range ) const;	// return true if distance between is greater than the given value
+
+	//------------------------------------------------------------------------
+	// INextBotPlayerInput
+	virtual void PressFireButton( float duration = -1.0f );
+	virtual void ReleaseFireButton( void );
+
+	virtual void PressAltFireButton( float duration = -1.0f );
+	virtual void ReleaseAltFireButton( void );
+
+	virtual void PressMeleeButton( float duration = -1.0f );
+	virtual void ReleaseMeleeButton( void );
+
+	virtual void PressSpecialFireButton( float duration = -1.0f );
+	virtual void ReleaseSpecialFireButton( void );
+
+	virtual void PressUseButton( float duration = -1.0f );
+	virtual void ReleaseUseButton( void );
+
+	virtual void PressReloadButton( float duration = -1.0f );
+	virtual void ReleaseReloadButton( void );
+
+	virtual void PressForwardButton( float duration = -1.0f );
+	virtual void ReleaseForwardButton( void );
+
+	virtual void PressBackwardButton( float duration = -1.0f );
+	virtual void ReleaseBackwardButton( void );
+
+	virtual void PressLeftButton( float duration = -1.0f );
+	virtual void ReleaseLeftButton( void );
+
+	virtual void PressRightButton( float duration = -1.0f );
+	virtual void ReleaseRightButton( void );
+
+	virtual void PressJumpButton( float duration = -1.0f );
+	virtual void ReleaseJumpButton( void );
+
+	virtual void PressCrouchButton( float duration = -1.0f );
+	virtual void ReleaseCrouchButton( void );
+
+	virtual void PressWalkButton( float duration = -1.0f );
+	virtual void ReleaseWalkButton( void );
+
+	virtual void SetButtonScale( float forward, float right );
+
+	//------------------------------------------------------------------------
+	// Event hooks into NextBot system 
+	virtual int OnTakeDamage_Alive( const CTakeDamageInfo &info );
+	virtual int OnTakeDamage_Dying( const CTakeDamageInfo &info );
+	virtual void Event_Killed( const CTakeDamageInfo &info );
+	virtual void HandleAnimEvent( animevent_t *event );
+	virtual void OnNavAreaChanged( CNavArea *enteredArea, CNavArea *leftArea );	// invoked (by UpdateLastKnownArea) when we enter a new nav area (or it is reset to NULL)
+	virtual void Touch( CBaseEntity *other );
+	virtual void Weapon_Equip( CBaseCombatWeapon *weapon );						// for OnPickUp
+	virtual	void Weapon_Drop( CBaseCombatWeapon *weapon, const Vector *target, const Vector *velocity );	// for OnDrop
+	virtual void OnMainActivityComplete( Activity newActivity, Activity oldActivity );
+	virtual void OnMainActivityInterrupted( Activity newActivity, Activity oldActivity );
+	//------------------------------------------------------------------------
+
+	bool IsAbleToAutoCenterOnLadders( void ) const;
+
+	virtual void AvoidPlayers( CUserCmd *pCmd ) { }								// some game types allow players to pass through each other, this method pushes them apart
+
+public:
+	// begin INextBot ------------------------------------------------------------------------------------------------------------------
+	virtual void Update( void );												// (EXTEND) update internal state
+
+protected:
+	int m_inputButtons;					// this is still needed to guarantee each button press is captured at least once
+	int m_prevInputButtons;
+	CountdownTimer m_fireButtonTimer;
+	CountdownTimer m_meleeButtonTimer;
+	CountdownTimer m_specialFireButtonTimer;
+	CountdownTimer m_useButtonTimer;
+	CountdownTimer m_reloadButtonTimer;
+	CountdownTimer m_forwardButtonTimer;
+	CountdownTimer m_backwardButtonTimer;
+	CountdownTimer m_leftButtonTimer;
+	CountdownTimer m_rightButtonTimer;
+	CountdownTimer m_jumpButtonTimer;
+	CountdownTimer m_crouchButtonTimer;
+	CountdownTimer m_walkButtonTimer;
+	CountdownTimer m_buttonScaleTimer;
+	IntervalTimer m_burningTimer;		// how long since we were last burning
+	float m_forwardScale;
+	float m_rightScale;
+	CHandle< CBaseEntity > m_spawnPointEntity;
+};
+
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::SetSpawnPoint( CBaseEntity *spawnPoint )
+{
+	m_spawnPointEntity = spawnPoint;
+}
+
+template < typename PlayerType >
+inline CBaseEntity *NextBotPlayer< PlayerType >::EntSelectSpawnPoint( void )
+{
+	if ( m_spawnPointEntity != NULL )
+		return m_spawnPointEntity;
+
+	return BaseClass::EntSelectSpawnPoint();
+}
+
+template < typename PlayerType >
+inline float NextBotPlayer< PlayerType >::GetDistanceBetween( CBaseEntity *other ) const
+{
+	return (this->GetAbsOrigin() - other->GetAbsOrigin()).Length();
+}
+
+template < typename PlayerType >
+inline bool NextBotPlayer< PlayerType >::IsDistanceBetweenLessThan( CBaseEntity *other, float range ) const
+{
+	return (this->GetAbsOrigin() - other->GetAbsOrigin()).IsLengthLessThan( range );
+}
+
+template < typename PlayerType >
+inline bool NextBotPlayer< PlayerType >::IsDistanceBetweenGreaterThan( CBaseEntity *other, float range ) const
+{
+	return (this->GetAbsOrigin() - other->GetAbsOrigin()).IsLengthGreaterThan( range );
+}
+
+template < typename PlayerType >
+inline float NextBotPlayer< PlayerType >::GetDistanceBetween( const Vector &target ) const
+{
+	return (this->GetAbsOrigin() - target).Length();
+}
+
+template < typename PlayerType >
+inline bool NextBotPlayer< PlayerType >::IsDistanceBetweenLessThan( const Vector &target, float range ) const
+{
+	return (this->GetAbsOrigin() - target).IsLengthLessThan( range );
+}
+
+template < typename PlayerType >
+inline bool NextBotPlayer< PlayerType >::IsDistanceBetweenGreaterThan( const Vector &target, float range ) const
+{
+	return (this->GetAbsOrigin() - target).IsLengthGreaterThan( range );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressFireButton( float duration )
+{
+	m_inputButtons |= IN_ATTACK;
+	m_fireButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseFireButton( void )
+{
+	m_inputButtons &= ~IN_ATTACK;
+	m_fireButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressAltFireButton( float duration )
+{
+	PressMeleeButton( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseAltFireButton( void )
+{
+	ReleaseMeleeButton();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressMeleeButton( float duration )
+{
+	m_inputButtons |= IN_ATTACK2;
+	m_meleeButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseMeleeButton( void )
+{
+	m_inputButtons &= ~IN_ATTACK2;
+	m_meleeButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressSpecialFireButton( float duration )
+{
+	m_inputButtons |= IN_ATTACK3;
+	m_specialFireButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseSpecialFireButton( void )
+{
+	m_inputButtons &= ~IN_ATTACK3;
+	m_specialFireButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressUseButton( float duration )
+{
+	m_inputButtons |= IN_USE;
+	m_useButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseUseButton( void )
+{
+	m_inputButtons &= ~IN_USE;
+	m_useButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressReloadButton( float duration )
+{
+	m_inputButtons |= IN_RELOAD;
+	m_reloadButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseReloadButton( void )
+{
+	m_inputButtons &= ~IN_RELOAD;
+	m_reloadButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressJumpButton( float duration )
+{
+	m_inputButtons |= IN_JUMP;
+	m_jumpButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseJumpButton( void )
+{
+	m_inputButtons &= ~IN_JUMP;
+	m_jumpButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressCrouchButton( float duration )
+{
+	m_inputButtons |= IN_DUCK;
+	m_crouchButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseCrouchButton( void )
+{
+	m_inputButtons &= ~IN_DUCK;
+	m_crouchButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressWalkButton( float duration )
+{
+	m_inputButtons |= IN_SPEED;
+	m_walkButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseWalkButton( void )
+{
+	m_inputButtons &= ~IN_SPEED;
+	m_walkButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressForwardButton( float duration )
+{
+	m_inputButtons |= IN_FORWARD;
+	m_forwardButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseForwardButton( void )
+{
+	m_inputButtons &= ~IN_FORWARD;
+	m_forwardButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressBackwardButton( float duration )
+{
+	m_inputButtons |= IN_BACK;
+	m_backwardButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseBackwardButton( void )
+{
+	m_inputButtons &= ~IN_BACK;
+	m_backwardButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressLeftButton( float duration )
+{
+	m_inputButtons |= IN_MOVELEFT;
+	m_leftButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseLeftButton( void )
+{
+	m_inputButtons &= ~IN_MOVELEFT;
+	m_leftButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PressRightButton( float duration )
+{
+	m_inputButtons |= IN_MOVERIGHT;
+	m_rightButtonTimer.Start( duration );
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::ReleaseRightButton( void )
+{
+	m_inputButtons &= ~IN_MOVERIGHT;
+	m_rightButtonTimer.Invalidate();
+}
+
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::SetButtonScale( float forward, float right )
+{
+	m_forwardScale = forward;
+	m_rightScale = right;
+	m_buttonScaleTimer.Start( 0.01 );
+}
+
+
+
+//-----------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline NextBotPlayer< PlayerType >::NextBotPlayer( void )
+{
+	m_prevInputButtons = 0;
+	m_inputButtons = 0;
+	m_burningTimer.Invalidate();
+	m_spawnPointEntity = NULL;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline NextBotPlayer< PlayerType >::~NextBotPlayer()
+{
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::Spawn( void )
+{
+	engine->SetFakeClientConVarValue( this->edict(), "cl_autohelp", "0" );
+
+	m_prevInputButtons = m_inputButtons = 0;
+	m_fireButtonTimer.Invalidate();
+	m_meleeButtonTimer.Invalidate();
+	m_specialFireButtonTimer.Invalidate();
+	m_useButtonTimer.Invalidate();
+	m_reloadButtonTimer.Invalidate();
+	m_forwardButtonTimer.Invalidate();
+	m_backwardButtonTimer.Invalidate();
+	m_leftButtonTimer.Invalidate();
+	m_rightButtonTimer.Invalidate();
+	m_jumpButtonTimer.Invalidate();
+	m_crouchButtonTimer.Invalidate();
+	m_walkButtonTimer.Invalidate();
+	m_buttonScaleTimer.Invalidate();
+	m_forwardScale = m_rightScale = 0.04;
+	m_burningTimer.Invalidate();
+
+	// reset first, because Spawn() may access various interfaces
+	INextBot::Reset();
+
+	BaseClass::Spawn();
+}
+
+
+
+//-----------------------------------------------------------------------------------------------------
+inline void _NextBot_BuildUserCommand( CUserCmd *cmd, const QAngle &viewangles, float forwardmove, float sidemove, float upmove, int buttons, byte impulse )
+{
+	Q_memset( cmd, 0, sizeof( CUserCmd ) );
+
+	cmd->command_number = gpGlobals->tickcount;
+	cmd->forwardmove = forwardmove;
+	cmd->sidemove = sidemove;
+	cmd->upmove = upmove;
+	cmd->buttons = buttons;
+	cmd->impulse = impulse;
+
+	VectorCopy( viewangles, cmd->viewangles );
+
+	cmd->random_seed = random->RandomInt( 0, 0x7fffffff );
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::PhysicsSimulate( void )
+{
+	VPROF( "NextBotPlayer::PhysicsSimulate" );
+
+	// Make sure not to simulate this guy twice per frame
+	if ( PlayerType::m_nSimulationTick == gpGlobals->tickcount )
+	{
+		return;
+	}
+
+	if ( engine->IsPaused() )
+	{
+		// We're paused - don't add new commands
+		PlayerType::PhysicsSimulate();
+		return;
+	}
+
+	if ( ( IsDormantWhenDead() && PlayerType::m_lifeState == LIFE_DEAD ) || NextBotStop.GetBool() )
+	{
+		// death animation complete - nothing left to do except let PhysicsSimulate run PreThink etc
+		PlayerType::PhysicsSimulate();
+		return;
+	}
+
+	int inputButtons;
+	//
+	// Update bot behavior
+	//
+	if ( BeginUpdate() )
+	{
+		Update();
+
+		// build button bits
+		if ( !m_fireButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_ATTACK;
+
+		if ( !m_meleeButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_ATTACK2;
+
+		if ( !m_specialFireButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_ATTACK3;
+
+		if ( !m_useButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_USE;
+
+		if ( !m_reloadButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_RELOAD;
+
+		if ( !m_forwardButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_FORWARD;
+
+		if ( !m_backwardButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_BACK;
+
+		if ( !m_leftButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_MOVELEFT;
+
+		if ( !m_rightButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_MOVERIGHT;
+
+		if ( !m_jumpButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_JUMP;
+
+		if ( !m_crouchButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_DUCK;
+
+		if ( !m_walkButtonTimer.IsElapsed() )
+			m_inputButtons |= IN_SPEED;
+
+		m_prevInputButtons = m_inputButtons;
+		inputButtons = m_inputButtons;
+
+		EndUpdate();
+	}
+	else
+	{
+		// HACK: Smooth out body animations
+		GetBodyInterface()->Update();
+
+		// keep buttons pressed between Update() calls (m_prevInputButtons),
+		// and include any button presses that occurred this tick (m_inputButtons).
+		inputButtons = m_prevInputButtons | m_inputButtons;
+	}
+
+	//
+	// Convert NextBot locomotion and posture into
+	// player commands
+	//
+	IBody *body = GetBodyInterface();
+	ILocomotion *mover = GetLocomotionInterface();
+
+	if ( body->IsActualPosture( IBody::CROUCH ) )
+	{
+		inputButtons |= IN_DUCK;
+	}
+
+	float forwardSpeed = 0.0f;
+	float strafeSpeed = 0.0f;
+	float verticalSpeed = ( m_inputButtons & IN_JUMP ) ? mover->GetRunSpeed() : 0.0f;
+
+	if ( inputButtons & IN_FORWARD )
+	{
+		forwardSpeed = mover->GetRunSpeed();		
+	}
+	else if ( inputButtons & IN_BACK )
+	{
+		forwardSpeed = -mover->GetRunSpeed();
+	}
+
+	if ( inputButtons & IN_MOVELEFT )
+	{
+		strafeSpeed = -mover->GetRunSpeed();		
+	}
+	else if ( inputButtons & IN_MOVERIGHT )
+	{
+		strafeSpeed = mover->GetRunSpeed();
+	}
+
+	if ( NextBotPlayerWalk.GetBool() )
+	{
+		inputButtons |= IN_SPEED;
+	}
+
+	if ( NextBotPlayerCrouch.GetBool() )
+	{
+		inputButtons |= IN_DUCK;
+	}
+
+	if ( !m_buttonScaleTimer.IsElapsed() )
+	{
+		forwardSpeed = mover->GetRunSpeed() * m_forwardScale;
+		strafeSpeed = mover->GetRunSpeed() * m_rightScale;
+	}
+
+	if ( !NextBotPlayerMove.GetBool() )
+	{
+		inputButtons &= ~(IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT | IN_JUMP );
+		forwardSpeed = 0.0f;
+		strafeSpeed = 0.0f;
+		verticalSpeed = 0.0f;
+	}
+
+	QAngle angles = this->EyeAngles();
+
+#ifdef TERROR
+	if ( IsStunned() )
+	{
+		inputButtons &= ~(IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT | IN_JUMP | IN_DUCK );
+	}
+
+	// "Look" in the direction we're climbing/stumbling etc.  We can't do anything anyway, and it
+	// keeps motion extraction working.
+	if ( IsRenderYawOverridden() && IsMotionControlledXY( GetMainActivity() ) )
+	{
+		angles[YAW] = GetOverriddenRenderYaw();
+	}
+#endif
+
+	// construct a "command" to move the player
+	CUserCmd userCmd;
+	_NextBot_BuildUserCommand( &userCmd, angles, forwardSpeed, strafeSpeed, verticalSpeed, inputButtons, 0 );
+
+	AvoidPlayers( &userCmd );
+
+	// allocate a new command and add it to the player's list of command to process
+	this->ProcessUsercmds( &userCmd, 1, 1, 0, false );
+
+	m_inputButtons = 0;
+
+	// actually execute player commands and do player physics
+	PlayerType::PhysicsSimulate();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::OnNavAreaChanged( CNavArea *enteredArea, CNavArea *leftArea )
+{
+	// propagate into NextBot responders
+	INextBotEventResponder::OnNavAreaChanged( enteredArea, leftArea );
+
+	BaseClass::OnNavAreaChanged( enteredArea, leftArea );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::Touch( CBaseEntity *other )
+{
+	if ( ShouldTouch( other ) )
+	{
+		// propagate touch into NextBot event responders
+		trace_t result;
+		result = this->GetTouchTrace();
+		OnContact( other, &result );
+	}
+
+	BaseClass::Touch( other );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::Weapon_Equip( CBaseCombatWeapon *weapon )
+{
+#ifdef TERROR
+	// TODO: Reimplement GetDroppingPlayer() into GetLastOwner()
+	OnPickUp( weapon, weapon->GetDroppingPlayer() );
+#else
+	OnPickUp( weapon, NULL );
+#endif
+
+	BaseClass::Weapon_Equip( weapon );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::Weapon_Drop( CBaseCombatWeapon *weapon, const Vector *target, const Vector *velocity )
+{
+	OnDrop( weapon );
+
+	BaseClass::Weapon_Drop( weapon, target, velocity );
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::OnMainActivityComplete( Activity newActivity, Activity oldActivity )
+{
+#ifdef TERROR
+	BaseClass::OnMainActivityComplete( newActivity, oldActivity );
+#endif
+	OnAnimationActivityComplete( oldActivity );
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::OnMainActivityInterrupted( Activity newActivity, Activity oldActivity )
+{
+#ifdef TERROR
+	BaseClass::OnMainActivityInterrupted( newActivity, oldActivity );
+#endif
+	OnAnimationActivityInterrupted( oldActivity );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::Update( void )
+{
+	// don't spend CPU updating if this Survivor is dead
+	if ( ( this->IsAlive() || !IsDormantWhenDead() ) && !NextBotPlayerStop.GetBool() )
+	{
+		INextBot::Update();	
+	}
+}
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline bool NextBotPlayer< PlayerType >::IsAbleToAutoCenterOnLadders( void ) const
+{
+	const ILocomotion *locomotion = GetLocomotionInterface();
+	return locomotion && locomotion->IsAbleToAutoCenterOnLadder();
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline int NextBotPlayer< PlayerType >::OnTakeDamage_Alive( const CTakeDamageInfo &info )
+{
+	if ( info.GetDamageType() & DMG_BURN )
+	{
+		if ( !m_burningTimer.HasStarted() || m_burningTimer.IsGreaterThen( 1.0f ) )
+		{
+			// emit ignite event periodically as long as we are burning
+			OnIgnite();
+			m_burningTimer.Start();
+		}
+	}
+
+	// propagate event to components
+	OnInjured( info );
+
+	return BaseClass::OnTakeDamage_Alive( info );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline int NextBotPlayer< PlayerType >::OnTakeDamage_Dying( const CTakeDamageInfo &info )
+{
+	if ( info.GetDamageType() & DMG_BURN )
+	{
+		if ( !m_burningTimer.HasStarted() || m_burningTimer.IsGreaterThen( 1.0f ) )
+		{
+			// emit ignite event periodically as long as we are burning
+			OnIgnite();
+			m_burningTimer.Start();
+		}
+	}
+
+	// propagate event to components
+	OnInjured( info );
+
+	return BaseClass::OnTakeDamage_Dying( info );
+}
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::Event_Killed( const CTakeDamageInfo &info )
+{
+	// propagate event to my components
+	OnKilled( info );
+
+	BaseClass::Event_Killed( info );
+}
+
+
+
+//----------------------------------------------------------------------------------------------------------
+template < typename PlayerType >
+inline void NextBotPlayer< PlayerType >::HandleAnimEvent( animevent_t *event )
+{
+	// propagate event to components
+	OnAnimationEvent( event );
+
+	BaseClass::HandleAnimEvent( event );
+}
+
+
+#endif // _NEXT_BOT_PLAYER_H_
diff --git a/game/server/NextBot/Player/NextBotPlayerBody.cpp b/game/server/NextBot/Player/NextBotPlayerBody.cpp
new file mode 100644
index 00000000..246b6fa5
--- /dev/null
+++ b/game/server/NextBot/Player/NextBotPlayerBody.cpp
@@ -0,0 +1,881 @@
+// NextBotPlayerBody.cpp
+// Implementation of Body interface for CBasePlayer-derived classes
+// Author: Michael Booth, October 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+
+#include "NextBot.h"
+#include "NextBotPlayerBody.h"
+#include "NextBotPlayer.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+ConVar nb_saccade_time( "nb_saccade_time", "0.1", FCVAR_CHEAT );
+ConVar nb_saccade_speed( "nb_saccade_speed", "1000", FCVAR_CHEAT );
+ConVar nb_head_aim_steady_max_rate( "nb_head_aim_steady_max_rate", "100", FCVAR_CHEAT );
+ConVar nb_head_aim_settle_duration( "nb_head_aim_settle_duration", "0.3", FCVAR_CHEAT );
+ConVar nb_head_aim_resettle_angle( "nb_head_aim_resettle_angle", "100", FCVAR_CHEAT, "After rotating through this angle, the bot pauses to 'recenter' its virtual mouse on its virtual mousepad" );
+ConVar nb_head_aim_resettle_time( "nb_head_aim_resettle_time", "0.3", FCVAR_CHEAT, "How long the bot pauses to 'recenter' its virtual mouse on its virtual mousepad" );
+
+
+//-----------------------------------------------------------------------------------------------
+/** 
+ * A useful reply for IBody::AimHeadTowards.  When the
+ * head is aiming on target, press the fire button.
+ */
+void PressFireButtonReply::OnSuccess( INextBot *bot )
+{
+	INextBotPlayerInput *playerInput = dynamic_cast< INextBotPlayerInput * >( bot->GetEntity() );
+	if ( playerInput )
+	{
+		playerInput->PressFireButton();
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/** 
+ * A useful reply for IBody::AimHeadTowards.  When the
+ * head is aiming on target, press the alternate fire button.
+ */
+void PressAltFireButtonReply::OnSuccess( INextBot *bot )
+{
+	INextBotPlayerInput *playerInput = dynamic_cast< INextBotPlayerInput * >( bot->GetEntity() );
+	if ( playerInput )
+	{
+		playerInput->PressMeleeButton();
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/** 
+ * A useful reply for IBody::AimHeadTowards.  When the
+ * head is aiming on target, press the jump button.
+ */
+void PressJumpButtonReply::OnSuccess( INextBot *bot )
+{
+	INextBotPlayerInput *playerInput = dynamic_cast< INextBotPlayerInput * >( bot->GetEntity() );
+	if ( playerInput )
+	{
+		playerInput->PressJumpButton();
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------------------------
+PlayerBody::PlayerBody( INextBot *bot ) : IBody( bot )
+{
+	m_player = static_cast< CBasePlayer * >( bot->GetEntity() );
+}
+
+
+//-----------------------------------------------------------------------------------------------
+PlayerBody::~PlayerBody()
+{
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * reset to initial state
+ */
+void PlayerBody::Reset( void )
+{
+	m_posture = STAND;
+
+	m_lookAtPos = vec3_origin;
+	m_lookAtSubject = NULL;
+	m_lookAtReplyWhenAimed = NULL;
+	m_lookAtVelocity = vec3_origin;
+	m_lookAtExpireTimer.Invalidate();
+
+	m_lookAtPriority = BORING;
+	m_lookAtExpireTimer.Invalidate();
+	m_lookAtDurationTimer.Invalidate();
+	m_isSightedIn = false;
+	m_hasBeenSightedIn = false;
+	m_headSteadyTimer.Invalidate();
+	m_priorAngles = vec3_angle;
+	m_anchorRepositionTimer.Invalidate();
+	m_anchorForward = vec3_origin;
+}
+
+ConVar bot_mimic( "bot_mimic", "0", 0, "Bot uses usercmd of player by index." );
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Update internal state.
+ * Do this every tick to keep head aims smooth and accurate
+ */
+void PlayerBody::Upkeep( void )
+{
+	// If mimicking the player, don't modify the view angles.
+	static ConVarRef bot_mimic( "bot_mimic" );
+	if ( bot_mimic.IsValid() && bot_mimic.GetBool() )
+		return;
+
+	const float deltaT = gpGlobals->frametime;
+	if ( deltaT < 0.00001f )
+	{
+		return;
+	}
+
+	CBasePlayer *player = ( CBasePlayer * )GetBot()->GetEntity();
+
+	// get current view angles
+	QAngle currentAngles = player->EyeAngles() + player->GetPunchAngle();
+
+	// track when our head is "steady"
+	bool isSteady = true;
+
+	float actualPitchRate = AngleDiff( currentAngles.x, m_priorAngles.x );
+	if ( abs( actualPitchRate ) > nb_head_aim_steady_max_rate.GetFloat() * deltaT )
+	{
+		isSteady = false;
+	}
+	else
+	{
+		float actualYawRate = AngleDiff( currentAngles.y, m_priorAngles.y );
+
+		if ( abs( actualYawRate ) > nb_head_aim_steady_max_rate.GetFloat() * deltaT )
+		{
+			isSteady = false;
+		}
+	}
+
+	if ( isSteady )
+	{
+		if ( !m_headSteadyTimer.HasStarted() )
+		{
+			m_headSteadyTimer.Start();
+		}
+	}
+	else
+	{
+		m_headSteadyTimer.Invalidate();
+	}
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+	{
+		if ( IsHeadSteady() )
+		{
+			const float maxTime = 3.0f;
+			float t = GetHeadSteadyDuration() / maxTime;
+			t = clamp( t, 0.f, 1.0f );
+			NDebugOverlay::Circle( player->EyePosition(), t * 10.0f, 0, 255, 0, 255, true, 2.0f * deltaT );
+		}
+	}
+
+	m_priorAngles = currentAngles;
+
+
+	// if our current look-at has expired, don't change our aim further
+	if ( m_hasBeenSightedIn && m_lookAtExpireTimer.IsElapsed() )
+	{
+		return;
+	}
+
+	// simulate limited range of mouse movements
+	// compute the angle change from "center"
+	const Vector &forward = GetViewVector();
+	float deltaAngle = RAD2DEG( acos( DotProduct( forward, m_anchorForward ) ) );
+	if ( deltaAngle > nb_head_aim_resettle_angle.GetFloat() )
+	{
+		// time to recenter our 'virtual mouse'
+		m_anchorRepositionTimer.Start( RandomFloat( 0.9f, 1.1f ) * nb_head_aim_resettle_time.GetFloat() );
+		m_anchorForward = forward;
+		return;
+	}
+
+	// if we're currently recentering our "virtual mouse", wait
+	if ( m_anchorRepositionTimer.HasStarted() && !m_anchorRepositionTimer.IsElapsed() )
+	{
+		return;
+	}
+	m_anchorRepositionTimer.Invalidate();
+
+
+	// if we have a subject, update lookat point
+	CBaseEntity *subject = m_lookAtSubject;
+	if ( subject )
+	{
+		if ( m_lookAtTrackingTimer.IsElapsed() )
+		{
+			// update subject tracking by periodically estimating linear aim velocity, allowing for "slop" between updates
+			Vector desiredLookAtPos;
+
+			if ( subject->MyCombatCharacterPointer() ) 
+			{
+				desiredLookAtPos = GetBot()->GetIntentionInterface()->SelectTargetPoint( GetBot(), subject->MyCombatCharacterPointer() );
+			}
+			else
+			{
+				desiredLookAtPos = subject->WorldSpaceCenter();
+			}
+
+			desiredLookAtPos += GetHeadAimSubjectLeadTime() * subject->GetAbsVelocity();
+
+			Vector errorVector = desiredLookAtPos - m_lookAtPos;
+			float error = errorVector.NormalizeInPlace();
+
+			float trackingInterval = GetHeadAimTrackingInterval();
+			if ( trackingInterval < deltaT )
+			{
+				trackingInterval = deltaT;
+			}
+
+			float errorVel = error / trackingInterval;
+
+			m_lookAtVelocity = ( errorVel * errorVector ) + subject->GetAbsVelocity();
+
+			m_lookAtTrackingTimer.Start( RandomFloat( 0.8f, 1.2f ) * trackingInterval );
+		}
+
+		m_lookAtPos += deltaT * m_lookAtVelocity;
+	}
+
+
+	// aim view towards last look at point
+	Vector to = m_lookAtPos - GetEyePosition();
+	to.NormalizeInPlace();
+
+	QAngle desiredAngles;
+	VectorAngles( to, desiredAngles );
+
+	QAngle angles;
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+	{
+		NDebugOverlay::Line( GetEyePosition(), GetEyePosition() + 100.0f * forward, 255, 255, 0, false, 2.0f * deltaT );
+
+		float thickness = isSteady ? 2.0f : 3.0f;
+		int r = m_isSightedIn ? 255 : 0;
+		int g = subject ? 255 : 0;
+		NDebugOverlay::HorzArrow( GetEyePosition(), m_lookAtPos, thickness, r, g, 255, 255, false, 2.0f * deltaT );
+	}
+
+	
+	const float onTargetTolerance = 0.98f;
+	float dot = DotProduct( forward, to );
+	if ( dot > onTargetTolerance )
+	{
+		// on target
+		m_isSightedIn = true;
+
+		if ( !m_hasBeenSightedIn )
+		{
+			m_hasBeenSightedIn = true;
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+			{
+				ConColorMsg( Color( 255, 100, 0, 255 ), "%3.2f: %s Look At SIGHTED IN\n",
+								gpGlobals->curtime,
+								m_player->GetPlayerName() );
+			}
+		}
+
+		if ( m_lookAtReplyWhenAimed )
+		{
+			m_lookAtReplyWhenAimed->OnSuccess( GetBot() );
+			m_lookAtReplyWhenAimed = NULL;
+		}
+	}
+	else
+	{
+		// off target
+		m_isSightedIn = false;
+	}
+
+
+	// rotate view at a rate proportional to how far we have to turn
+	// max rate if we need to turn around
+	// want first derivative continuity of rate as our aim hits to avoid pop
+	float approachRate = GetMaxHeadAngularVelocity();
+
+	const float easeOut = 0.7f;
+	if ( dot > easeOut )
+	{
+		float t = RemapVal( dot, easeOut, 1.0f, 1.0f, 0.02f );
+		const float halfPI = 1.57f;
+		approachRate *= sin( halfPI * t );
+	}
+
+	const float easeInTime = 0.25f;
+	if ( m_lookAtDurationTimer.GetElapsedTime() < easeInTime )
+	{
+		approachRate *= m_lookAtDurationTimer.GetElapsedTime() / easeInTime;
+	}
+
+	angles.y = ApproachAngle( desiredAngles.y, currentAngles.y, approachRate * deltaT );
+	angles.x = ApproachAngle( desiredAngles.x, currentAngles.x, 0.5f * approachRate * deltaT );
+	angles.z = 0.0f;
+
+	// back out "punch angle"
+	angles -= player->GetPunchAngle();
+
+	angles.x = AngleNormalize( angles.x );
+	angles.y = AngleNormalize( angles.y );
+
+	player->SnapEyeAngles( angles );
+}
+
+
+//-----------------------------------------------------------------------------------------------
+bool PlayerBody::SetPosition( const Vector &pos )
+{
+	m_player->SetAbsOrigin( pos );	
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return the eye position of the bot in world coordinates
+ */
+const Vector &PlayerBody::GetEyePosition( void ) const
+{
+	m_eyePos = m_player->EyePosition();
+	return m_eyePos;
+}
+
+
+CBaseEntity *PlayerBody::GetEntity( void )
+{
+	return m_player;
+}
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return the view unit direction vector in world coordinates
+ */
+const Vector &PlayerBody::GetViewVector( void ) const
+{
+	m_player->EyeVectors( &m_viewVector );
+	return m_viewVector;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Aim the bot's head towards the given goal
+ */
+void PlayerBody::AimHeadTowards( const Vector &lookAtPos, LookAtPriorityType priority, float duration, INextBotReply *replyWhenAimed, const char *reason )
+{
+	if ( duration <= 0.0f )
+	{
+		duration = 0.1f;
+	}
+
+	// don't spaz our aim around
+	if ( m_lookAtPriority == priority )
+	{
+		if ( !IsHeadSteady() || GetHeadSteadyDuration() < nb_head_aim_settle_duration.GetFloat() )
+		{
+			// we're still finishing a look-at at the same priority
+			if ( replyWhenAimed ) 
+			{
+				replyWhenAimed->OnFail( GetBot(), INextBotReply::DENIED );
+			}
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+			{
+				ConColorMsg( Color( 255, 0, 0, 255 ), "%3.2f: %s Look At '%s' rejected - previous aim not %s\n",
+								gpGlobals->curtime,
+								m_player->GetPlayerName(),
+								reason,
+								IsHeadSteady() ? "settled long enough" : "head-steady" );
+			}
+			return;
+		}
+	}
+
+	// don't short-circuit if "sighted in" to avoid rapid view jitter
+	if ( m_lookAtPriority > priority && !m_lookAtExpireTimer.IsElapsed() )
+	{
+		// higher priority lookat still ongoing 
+		if ( replyWhenAimed ) 
+		{
+			replyWhenAimed->OnFail( GetBot(), INextBotReply::DENIED );
+		}
+
+		if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+		{
+			ConColorMsg( Color( 255, 0, 0, 255 ), "%3.2f: %s Look At '%s' rejected - higher priority aim in progress\n",
+							gpGlobals->curtime,
+							m_player->GetPlayerName(),
+							reason );
+		}
+		return;
+	}
+
+	if ( m_lookAtReplyWhenAimed )
+	{
+		// in-process aim was interrupted
+		m_lookAtReplyWhenAimed->OnFail( GetBot(), INextBotReply::INTERRUPTED );
+	}
+
+	m_lookAtReplyWhenAimed = replyWhenAimed;
+	m_lookAtExpireTimer.Start( duration );
+
+	// if given the same point, just update priority
+	const float epsilon = 1.0f;
+	if ( ( m_lookAtPos - lookAtPos ).IsLengthLessThan( epsilon ) )
+	{
+		m_lookAtPriority = priority;
+		return;
+	}
+
+	// new look-at point
+
+	m_lookAtPos = lookAtPos;
+	m_lookAtSubject = NULL;
+
+	m_lookAtPriority = priority;
+	m_lookAtDurationTimer.Start();
+
+	// do NOT clear this here, or continuous calls to AimHeadTowards will keep IsHeadAimingOnTarget returning false all of the time
+	// m_isSightedIn = false;
+
+	m_hasBeenSightedIn = false;
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+	{
+		NDebugOverlay::Cross3D( lookAtPos, 2.0f, 255, 255, 100, true, 2.0f * duration );
+		
+		const char *priName = "";
+		switch( priority )
+		{
+			case BORING:		priName = "BORING"; break;
+			case INTERESTING:	priName = "INTERESTING"; break;
+			case IMPORTANT:		priName = "IMPORTANT"; break;
+			case CRITICAL:		priName = "CRITICAL"; break;		
+		}
+		
+		ConColorMsg( Color( 255, 100, 0, 255 ), "%3.2f: %s Look At ( %g, %g, %g ) for %3.2f s, Pri = %s, Reason = %s\n",
+						gpGlobals->curtime,
+						m_player->GetPlayerName(),
+						lookAtPos.x, lookAtPos.y, lookAtPos.z,
+						duration,
+						priName,
+						( reason ) ? reason : "" );	
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Aim the bot's head towards the given goal
+ */
+void PlayerBody::AimHeadTowards( CBaseEntity *subject, LookAtPriorityType priority, float duration, INextBotReply *replyWhenAimed, const char *reason )
+{
+	if ( duration <= 0.0f )
+	{
+		duration = 0.1f;
+	}
+
+	if ( subject == NULL )
+	{
+		return;
+	}
+
+	// don't spaz our aim around
+	if ( m_lookAtPriority == priority )
+	{
+		if ( !IsHeadSteady() || GetHeadSteadyDuration() < nb_head_aim_settle_duration.GetFloat() )
+		{
+			// we're still finishing a look-at at the same priority
+			if ( replyWhenAimed ) 
+			{
+				replyWhenAimed->OnFail( GetBot(), INextBotReply::DENIED );
+			}
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+			{
+				ConColorMsg( Color( 255, 0, 0, 255 ), "%3.2f: %s Look At '%s' rejected - previous aim not %s\n",
+								gpGlobals->curtime,
+								m_player->GetPlayerName(),
+								reason,
+								IsHeadSteady() ? "head-steady" : "settled long enough" );
+			}
+			return;
+		}
+	}
+
+	// don't short-circuit if "sighted in" to avoid rapid view jitter
+	if ( m_lookAtPriority > priority && !m_lookAtExpireTimer.IsElapsed() )
+	{
+		// higher priority lookat still ongoing
+		if ( replyWhenAimed ) 
+		{
+			replyWhenAimed->OnFail( GetBot(), INextBotReply::DENIED );
+		}
+
+		if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+		{
+			ConColorMsg( Color( 255, 0, 0, 255 ), "%3.2f: %s Look At '%s' rejected - higher priority aim in progress\n",
+							gpGlobals->curtime,
+							m_player->GetPlayerName(),
+							reason );
+		}
+		return;
+	}
+
+	if ( m_lookAtReplyWhenAimed )
+	{
+		// in-process aim was interrupted
+		m_lookAtReplyWhenAimed->OnFail( GetBot(), INextBotReply::INTERRUPTED );
+	}
+
+	m_lookAtReplyWhenAimed = replyWhenAimed;
+	m_lookAtExpireTimer.Start( duration );
+
+	// if given the same subject, just update priority
+	if ( subject == m_lookAtSubject )
+	{
+		m_lookAtPriority = priority;
+		return;
+	}
+
+	// new subject
+	m_lookAtSubject = subject;
+
+#ifdef REFACTOR_FOR_CLIENT_SIDE_EYE_TRACKING
+	CBasePlayer *pMyPlayer = static_cast< CBasePlayer * >( GetEntity() );
+	if ( subject->IsPlayer() )
+	{
+		// looking at a player, look at their eye position
+		TerrorPlayer *pMyTarget = ToTerrorPlayer( subject );
+		m_lookAtPos = subject->EyePosition();
+		if(pMyPlayer)
+		{
+			pMyPlayer->SetLookatPlayer( pMyTarget );
+		}
+	}
+	else
+	{
+		// not looking at a player
+		m_lookAtPos = subject->WorldSpaceCenter();
+		if(pMyPlayer)
+		{
+			pMyPlayer->SetLookatPlayer( NULL );
+		}
+	}
+#endif
+
+	m_lookAtPriority = priority;
+	m_lookAtDurationTimer.Start();
+
+	// do NOT clear this here, or continuous calls to AimHeadTowards will keep IsHeadAimingOnTarget returning false all of the time
+	// m_isSightedIn = false;
+
+	m_hasBeenSightedIn = false;
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOOK_AT ) )
+	{
+		NDebugOverlay::Cross3D( m_lookAtPos, 2.0f, 100, 100, 100, true, duration );
+		
+		const char *priName = "";
+		switch( priority )
+		{
+			case BORING:		priName = "BORING"; break;
+			case INTERESTING:	priName = "INTERESTING"; break;
+			case IMPORTANT:		priName = "IMPORTANT"; break;
+			case CRITICAL:		priName = "CRITICAL"; break;		
+		}
+		
+		ConColorMsg( Color( 255, 100, 0, 255 ), "%3.2f: %s Look At subject %s for %3.2f s, Pri = %s, Reason = %s\n",
+						gpGlobals->curtime,
+						m_player->GetPlayerName(),
+						subject->GetClassname(),
+						duration,
+						priName,
+						( reason ) ? reason : "" );	
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if head is not rapidly turning to look somewhere else
+ */
+bool PlayerBody::IsHeadSteady( void ) const
+{
+	return m_headSteadyTimer.HasStarted();
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return the duration that the bot's head has been on-target
+ */
+float PlayerBody::GetHeadSteadyDuration( void ) const
+{
+	// return ( IsHeadAimingOnTarget() ) ? m_headSteadyTimer.GetElapsedTime() : 0.0f;
+	return m_headSteadyTimer.HasStarted() ? m_headSteadyTimer.GetElapsedTime() : 0.0f;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+// Clear out currently pending replyWhenAimed callback
+void PlayerBody::ClearPendingAimReply( void )
+{
+	m_lookAtReplyWhenAimed = NULL;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+float PlayerBody::GetMaxHeadAngularVelocity( void ) const
+{
+	return nb_saccade_speed.GetFloat();
+}
+
+
+//-----------------------------------------------------------------------------------------------
+bool PlayerBody::StartActivity( Activity act, unsigned int flags )
+{
+	// player animation state is controlled on the client
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return currently animating activity
+ */
+Activity PlayerBody::GetActivity( void ) const
+{
+	return ACT_INVALID;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if currently animating activity matches the given one
+ */
+bool PlayerBody::IsActivity( Activity act ) const
+{
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if currently animating activity has any of the given flags
+ */
+bool PlayerBody::HasActivityType( unsigned int flags ) const
+{
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Request a posture change
+ */
+void PlayerBody::SetDesiredPosture( PostureType posture )
+{
+	m_posture = posture;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Get posture body is trying to assume
+ */
+IBody::PostureType PlayerBody::GetDesiredPosture( void ) const
+{
+	return m_posture;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if body is trying to assume this posture
+ */
+bool PlayerBody::IsDesiredPosture( PostureType posture ) const
+{
+	return ( posture == m_posture );
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if body's actual posture matches its desired posture
+ */
+bool PlayerBody::IsInDesiredPosture( void ) const
+{
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return body's current actual posture
+ */
+IBody::PostureType PlayerBody::GetActualPosture( void ) const
+{
+	return m_posture;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if body is actually in the given posture
+ */
+bool PlayerBody::IsActualPosture( PostureType posture ) const
+{
+	return ( posture == m_posture );
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if body's current posture allows it to move around the world
+ */
+bool PlayerBody::IsPostureMobile( void ) const
+{
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if body's posture is in the process of changing to new posture
+ */
+bool PlayerBody::IsPostureChanging( void ) const
+{
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Arousal level change
+ */
+void PlayerBody::SetArousal( ArousalType arousal )
+{
+	m_arousal = arousal;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Get arousal level
+ */
+IBody::ArousalType PlayerBody::GetArousal( void ) const
+{
+	return m_arousal;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return true if body is at this arousal level
+ */
+bool PlayerBody::IsArousal( ArousalType arousal ) const
+{
+	return ( arousal == m_arousal );
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Width of bot's collision hull in XY plane
+ */
+float PlayerBody::GetHullWidth( void ) const
+{
+	return VEC_HULL_MAX_SCALED( m_player ).x - VEC_HULL_MIN_SCALED( m_player ).x;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Height of bot's current collision hull based on posture
+ */
+float PlayerBody::GetHullHeight( void ) const
+{
+	if ( m_posture == CROUCH )
+	{
+		return GetCrouchHullHeight();
+	}
+
+	return GetStandHullHeight();
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Height of bot's collision hull when standing
+ */
+float PlayerBody::GetStandHullHeight( void ) const
+{
+	return VEC_HULL_MAX_SCALED( m_player ).z - VEC_HULL_MIN_SCALED( m_player ).z;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Height of bot's collision hull when crouched
+ */
+float PlayerBody::GetCrouchHullHeight( void ) const
+{
+	return VEC_DUCK_HULL_MAX_SCALED( m_player ).z - VEC_DUCK_HULL_MIN_SCALED( m_player ).z;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return current collision hull minimums based on actual body posture
+ */
+const Vector &PlayerBody::GetHullMins( void ) const
+{
+	if ( m_posture == CROUCH )
+	{
+		m_hullMins = VEC_DUCK_HULL_MIN_SCALED( m_player );
+	}
+	else
+	{
+		m_hullMins = VEC_HULL_MIN_SCALED( m_player );
+	}
+	
+	return m_hullMins;
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return current collision hull maximums based on actual body posture
+ */
+const Vector &PlayerBody::GetHullMaxs( void ) const
+{
+	if ( m_posture == CROUCH )
+	{
+		m_hullMaxs = VEC_DUCK_HULL_MAX_SCALED( m_player );
+	}
+	else
+	{
+		m_hullMaxs = VEC_HULL_MAX_SCALED( m_player );
+	}
+
+	return m_hullMaxs;	
+}
+
+
+//-----------------------------------------------------------------------------------------------
+/**
+ * Return the bot's collision mask (hack until we get a general hull trace abstraction here or in the locomotion interface)
+ */
+unsigned int PlayerBody::GetSolidMask( void ) const
+{
+	return ( m_player ) ? m_player->PlayerSolidMask() : MASK_PLAYERSOLID;
+}
+
+
+
+
+
diff --git a/game/server/NextBot/Player/NextBotPlayerBody.h b/game/server/NextBot/Player/NextBotPlayerBody.h
new file mode 100644
index 00000000..eda36431
--- /dev/null
+++ b/game/server/NextBot/Player/NextBotPlayerBody.h
@@ -0,0 +1,153 @@
+// NextBotPlayerBody.h
+// Control and information about the bot's body state (posture, animation state, etc)
+// Author: Michael Booth, October 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_PLAYER_BODY_H_
+#define _NEXT_BOT_PLAYER_BODY_H_
+
+#include "NextBotBodyInterface.h"
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * A useful reply for IBody::AimHeadTowards.  When the
+ * head is aiming on target, press the fire button.
+ */
+class PressFireButtonReply : public INextBotReply
+{
+public:
+	virtual void OnSuccess( INextBot *bot );	// invoked when process completed successfully
+};
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * A useful reply for IBody::AimHeadTowards.  When the
+ * head is aiming on target, press the alt-fire button.
+ */
+class PressAltFireButtonReply : public INextBotReply
+{
+public:
+	virtual void OnSuccess( INextBot *bot );	// invoked when process completed successfully
+};
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * A useful reply for IBody::AimHeadTowards.  When the
+ * head is aiming on target, press the jump button.
+ */
+class PressJumpButtonReply : public INextBotReply
+{
+public:
+	virtual void OnSuccess( INextBot *bot );	// invoked when process completed successfully
+};
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The interface for control and information about the bot's body state (posture, animation state, etc)
+ */
+class PlayerBody : public IBody
+{
+public:
+	PlayerBody( INextBot *bot );
+	virtual ~PlayerBody();
+
+	virtual void Reset( void );										// reset to initial state
+	virtual void Upkeep( void );									// lightweight update guaranteed to occur every server tick
+
+	virtual bool SetPosition( const Vector &pos );
+
+	virtual const Vector &GetEyePosition( void ) const;				// return the eye position of the bot in world coordinates
+	virtual const Vector &GetViewVector( void ) const;				// return the view unit direction vector in world coordinates
+
+	virtual void AimHeadTowards( const Vector &lookAtPos, 
+								 LookAtPriorityType priority = BORING, 
+								 float duration = 0.0f,
+								 INextBotReply *replyWhenAimed = NULL,
+								 const char *reason = NULL );		// aim the bot's head towards the given goal
+
+	virtual void AimHeadTowards( CBaseEntity *subject,
+								 LookAtPriorityType priority = BORING, 
+								 float duration = 0.0f,
+								 INextBotReply *replyWhenAimed = NULL,
+								 const char *reason = NULL );		// continually aim the bot's head towards the given subject
+
+	virtual bool IsHeadAimingOnTarget( void ) const;				// return true if the bot's head has achieved its most recent lookat target
+	virtual bool IsHeadSteady( void ) const;						// return true if head is not rapidly turning to look somewhere else
+	virtual float GetHeadSteadyDuration( void ) const;				// return the duration that the bot's head has been on-target
+	virtual void ClearPendingAimReply( void );						// clear out currently pending replyWhenAimed callback
+
+	virtual float GetMaxHeadAngularVelocity( void ) const;			// return max turn rate of head in degrees/second
+
+	virtual bool StartActivity( Activity act, unsigned int flags );
+	virtual Activity GetActivity( void ) const;						// return currently animating activity
+	virtual bool IsActivity( Activity act ) const;					// return true if currently animating activity matches the given one
+	virtual bool HasActivityType( unsigned int flags ) const;		// return true if currently animating activity has any of the given flags
+
+	virtual void SetDesiredPosture( PostureType posture );			// request a posture change
+	virtual PostureType GetDesiredPosture( void ) const;			// get posture body is trying to assume
+	virtual bool IsDesiredPosture( PostureType posture ) const;		// return true if body is trying to assume this posture
+	virtual bool IsInDesiredPosture( void ) const;					// return true if body's actual posture matches its desired posture
+
+	virtual PostureType GetActualPosture( void ) const;				// return body's current actual posture
+	virtual bool IsActualPosture( PostureType posture ) const;		// return true if body is actually in the given posture
+
+	virtual bool IsPostureMobile( void ) const;						// return true if body's current posture allows it to move around the world
+	virtual bool IsPostureChanging( void ) const;					// return true if body's posture is in the process of changing to new posture
+
+	virtual void SetArousal( ArousalType arousal );					// arousal level change
+	virtual ArousalType GetArousal( void ) const;					// get arousal level
+	virtual bool IsArousal( ArousalType arousal ) const;			// return true if body is at this arousal level
+
+	virtual float GetHullWidth( void ) const;						// width of bot's collision hull in XY plane
+	virtual float GetHullHeight( void ) const;						// height of bot's current collision hull based on posture
+	virtual float GetStandHullHeight( void ) const;					// height of bot's collision hull when standing
+	virtual float GetCrouchHullHeight( void ) const;				// height of bot's collision hull when crouched
+	virtual const Vector &GetHullMins( void ) const;				// return current collision hull minimums based on actual body posture
+	virtual const Vector &GetHullMaxs( void ) const;				// return current collision hull maximums based on actual body posture
+
+	virtual unsigned int GetSolidMask( void ) const;				// return the bot's collision mask (hack until we get a general hull trace abstraction here or in the locomotion interface)
+
+	virtual CBaseEntity *GetEntity( void );					// get the entity
+private:
+	CBasePlayer *m_player;
+	
+	PostureType m_posture;
+	ArousalType m_arousal;
+
+	mutable Vector m_eyePos;			// for use with GetEyePosition() ONLY
+	mutable Vector m_viewVector;		// for use with GetViewVector() ONLY
+	mutable Vector m_hullMins;			// for use with GetHullMins() ONLY
+	mutable Vector m_hullMaxs;			// for use with GetHullMaxs() ONLY
+
+	Vector m_lookAtPos;					// if m_lookAtSubject is non-NULL, it continually overwrites this position with its own
+	EHANDLE m_lookAtSubject;
+	Vector m_lookAtVelocity;			// world velocity of lookat point, for tracking moving subjects
+	CountdownTimer m_lookAtTrackingTimer;	
+
+	LookAtPriorityType m_lookAtPriority;
+	CountdownTimer m_lookAtExpireTimer;		// how long until this lookat expired
+	IntervalTimer m_lookAtDurationTimer;	// how long have we been looking at this target
+	INextBotReply *m_lookAtReplyWhenAimed;
+	bool m_isSightedIn;					// true if we are looking at our last lookat target
+	bool m_hasBeenSightedIn;			// true if we have hit the current lookat target
+
+	IntervalTimer m_headSteadyTimer;
+	QAngle m_priorAngles;				// last update's head angles
+	QAngle m_desiredAngles;
+
+	CountdownTimer m_anchorRepositionTimer;	// the time is takes us to recenter our virtual mouse
+	Vector m_anchorForward;
+};
+
+inline bool PlayerBody::IsHeadAimingOnTarget( void ) const
+{
+	// TODO: Calling this immediately after AimHeadTowards will always return false until next Upkeep() (MSB)
+	return m_isSightedIn;
+}
+
+
+#endif // _NEXT_BOT_PLAYER_BODY_H_
diff --git a/game/server/NextBot/Player/NextBotPlayerLocomotion.cpp b/game/server/NextBot/Player/NextBotPlayerLocomotion.cpp
new file mode 100644
index 00000000..ea30ee7a
--- /dev/null
+++ b/game/server/NextBot/Player/NextBotPlayerLocomotion.cpp
@@ -0,0 +1,826 @@
+// NextBotPlayerLocomotion.cpp
+// Implementation of Locomotion interface for CBasePlayer-derived classes
+// Author: Michael Booth, November 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#include "cbase.h"
+#include "nav_mesh.h"
+#include "in_buttons.h"
+#include "NextBot.h"
+#include "NextBotUtil.h"
+#include "NextBotPlayer.h"
+#include "NextBotPlayerLocomotion.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+ConVar NextBotPlayerMoveDirect( "nb_player_move_direct", "0" );
+
+//-----------------------------------------------------------------------------------------------------
+PlayerLocomotion::PlayerLocomotion( INextBot *bot ) : ILocomotion( bot )
+{
+	m_player = NULL;
+	Reset();
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Reset locomotor to initial state
+ */
+void PlayerLocomotion::Reset( void )
+{
+	m_player = static_cast< CBasePlayer * >( GetBot()->GetEntity() );
+	
+	m_isJumping = false;
+	m_isClimbingUpToLedge = false;
+	m_isJumpingAcrossGap = false;
+	m_hasLeftTheGround = false;
+	m_desiredSpeed = 0.0f;
+
+
+	m_ladderState = NO_LADDER;
+	m_ladderInfo = NULL;
+	m_ladderDismountGoal = NULL;
+	m_ladderTimer.Invalidate();
+
+	m_minSpeedLimit = 0.0f;
+	m_maxSpeedLimit = 9999999.9f;
+
+	BaseClass::Reset();
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+bool PlayerLocomotion::TraverseLadder( void )
+{
+	switch( m_ladderState )
+	{
+	case APPROACHING_ASCENDING_LADDER:
+		m_ladderState = ApproachAscendingLadder();
+		return true;
+
+	case APPROACHING_DESCENDING_LADDER:
+		m_ladderState = ApproachDescendingLadder();
+		return true;
+
+	case ASCENDING_LADDER:
+		m_ladderState = AscendLadder();
+		return true;
+
+	case DESCENDING_LADDER:
+		m_ladderState = DescendLadder();
+		return true;
+
+	case DISMOUNTING_LADDER_TOP:
+		m_ladderState = DismountLadderTop();
+		return true;
+
+	case DISMOUNTING_LADDER_BOTTOM:
+		m_ladderState = DismountLadderBottom();
+		return true;
+
+	case NO_LADDER:
+	default:
+		m_ladderInfo = NULL;
+
+		if ( GetBot()->GetEntity()->GetMoveType() == MOVETYPE_LADDER )
+		{
+			// on ladder and don't want to be
+			GetBot()->GetEntity()->SetMoveType( MOVETYPE_WALK );
+		}
+		return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * We're close, but not yet on, this ladder - approach it
+ */
+PlayerLocomotion::LadderState PlayerLocomotion::ApproachAscendingLadder( void )
+{
+	if ( m_ladderInfo == NULL )
+	{
+		return NO_LADDER;
+	}
+
+	// sanity check - are we already at the end of this ladder?
+	if ( GetFeet().z >= m_ladderInfo->m_top.z - GetStepHeight() )
+	{
+		m_ladderTimer.Start( 2.0f );
+		return DISMOUNTING_LADDER_TOP;
+	}
+
+	// sanity check - are we too far below this ladder to reach it?
+	if ( GetFeet().z <= m_ladderInfo->m_bottom.z - GetMaxJumpHeight() )
+	{
+		return NO_LADDER;
+	}
+
+	FaceTowards( m_ladderInfo->m_bottom );
+
+	// it is important to approach precisely, so use a very large weight to wash out all other Approaches
+	Approach( m_ladderInfo->m_bottom, 9999999.9f );
+
+	if ( GetBot()->GetEntity()->GetMoveType() == MOVETYPE_LADDER )
+	{
+		// we're on the ladder
+		return ASCENDING_LADDER;
+	}
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		NDebugOverlay::EntityText( GetBot()->GetEntity()->entindex(), 0, "Approach ascending ladder", 0.1f, 255, 255, 255, 255 );
+	}
+
+	return APPROACHING_ASCENDING_LADDER;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+PlayerLocomotion::LadderState PlayerLocomotion::ApproachDescendingLadder( void )
+{
+	if ( m_ladderInfo == NULL )
+	{
+		return NO_LADDER;
+	}
+
+	// sanity check - are we already at the end of this ladder?
+	if ( GetFeet().z <= m_ladderInfo->m_bottom.z + GetMaxJumpHeight() )
+	{
+		m_ladderTimer.Start( 2.0f );
+		return DISMOUNTING_LADDER_BOTTOM;
+	}
+
+	Vector mountPoint = m_ladderInfo->m_top + 0.25f * GetBot()->GetBodyInterface()->GetHullWidth() * m_ladderInfo->GetNormal();
+	Vector to = mountPoint - GetFeet();
+	to.z = 0.0f;
+
+	float mountRange = to.NormalizeInPlace();
+	Vector moveGoal;
+
+	const float veryClose = 10.0f;
+	if ( mountRange < veryClose )
+	{
+		// we're right at the ladder - just keep moving forward until we grab it
+		const Vector &forward = GetMotionVector();
+		moveGoal = GetFeet() + 100.0f * forward;
+	}
+	else
+	{
+		if ( DotProduct( to, m_ladderInfo->GetNormal() ) < 0.0f )
+		{
+			// approaching front of downward ladder
+			//     ##
+			// ->+ ##
+			//   | ##
+			//   | ##
+			//   | ##
+			// <-+ ##
+			// ######
+			//
+			moveGoal = m_ladderInfo->m_top - 100.0f * m_ladderInfo->GetNormal();
+		}
+		else
+		{
+			// approaching back of downward ladder
+			//
+			// ->+
+			// ##|
+			// ##|
+			// ##+-->
+			// ######
+			//
+			moveGoal = m_ladderInfo->m_top + 100.0f * m_ladderInfo->GetNormal();
+		}
+	}
+
+	FaceTowards( moveGoal );
+
+	// it is important to approach precisely, so use a very large weight to wash out all other Approaches
+	Approach( moveGoal, 9999999.9f );
+
+	if ( GetBot()->GetEntity()->GetMoveType() == MOVETYPE_LADDER )
+	{
+		// we're on the ladder
+		return DESCENDING_LADDER;
+	}
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		NDebugOverlay::EntityText( GetBot()->GetEntity()->entindex(), 0, "Approach descending ladder", 0.1f, 255, 255, 255, 255 );
+	}
+
+	return APPROACHING_DESCENDING_LADDER;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+PlayerLocomotion::LadderState PlayerLocomotion::AscendLadder( void )
+{
+	if ( m_ladderInfo == NULL )
+	{
+		return NO_LADDER;
+	}
+
+	if ( GetBot()->GetEntity()->GetMoveType() != MOVETYPE_LADDER )
+	{
+		// slipped off ladder
+		m_ladderInfo = NULL;
+		return NO_LADDER;
+	}
+
+	if ( GetFeet().z >= m_ladderInfo->m_top.z )
+	{
+		// reached top of ladder
+		m_ladderTimer.Start( 2.0f );
+		return DISMOUNTING_LADDER_TOP;
+	}
+
+	// climb up this ladder - look up
+	Vector goal = GetFeet() + 100.0f * ( -m_ladderInfo->GetNormal() + Vector( 0, 0, 2 ) );
+
+	GetBot()->GetBodyInterface()->AimHeadTowards( goal, IBody::MANDATORY, 0.1f, NULL, "Ladder" );
+
+	// it is important to approach precisely, so use a very large weight to wash out all other Approaches
+	Approach( goal, 9999999.9f );
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		NDebugOverlay::EntityText( GetBot()->GetEntity()->entindex(), 0, "Ascend", 0.1f, 255, 255, 255, 255 );
+	}
+
+	return ASCENDING_LADDER;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+PlayerLocomotion::LadderState PlayerLocomotion::DescendLadder( void )
+{
+	if ( m_ladderInfo == NULL )
+	{
+		return NO_LADDER;
+	}
+
+	if ( GetBot()->GetEntity()->GetMoveType() != MOVETYPE_LADDER )
+	{
+		// slipped off ladder
+		m_ladderInfo = NULL;
+		return NO_LADDER;
+	}
+
+	if ( GetFeet().z <= m_ladderInfo->m_bottom.z + GetBot()->GetLocomotionInterface()->GetStepHeight() )
+	{
+		// reached bottom of ladder
+		m_ladderTimer.Start( 2.0f );
+		return DISMOUNTING_LADDER_BOTTOM;
+	}
+
+	// climb down this ladder - look down 
+	Vector goal = GetFeet() + 100.0f * ( m_ladderInfo->GetNormal() + Vector( 0, 0, -2 ) );
+
+	GetBot()->GetBodyInterface()->AimHeadTowards( goal, IBody::MANDATORY, 0.1f, NULL, "Ladder" );
+
+	// it is important to approach precisely, so use a very large weight to wash out all other Approaches
+	Approach( goal, 9999999.9f );
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		NDebugOverlay::EntityText( GetBot()->GetEntity()->entindex(), 0, "Descend", 0.1f, 255, 255, 255, 255 );
+	}
+
+	return DESCENDING_LADDER;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+PlayerLocomotion::LadderState PlayerLocomotion::DismountLadderTop( void )
+{
+	if ( m_ladderInfo == NULL || m_ladderTimer.IsElapsed() )
+	{
+		m_ladderInfo = NULL;
+		return NO_LADDER;
+	}
+
+	IBody *body = GetBot()->GetBodyInterface();
+	Vector toGoal = m_ladderDismountGoal->GetCenter() - GetFeet();
+	toGoal.z = 0.0f;
+	float range = toGoal.NormalizeInPlace();
+	toGoal.z = 1.0f;
+	
+	body->AimHeadTowards( body->GetEyePosition() + 100.0f * toGoal, IBody::MANDATORY, 0.1f, NULL, "Ladder dismount" );
+
+	// it is important to approach precisely, so use a very large weight to wash out all other Approaches
+	Approach( GetFeet() + 100.0f * toGoal, 9999999.9f );
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		NDebugOverlay::EntityText( GetBot()->GetEntity()->entindex(), 0, "Dismount top", 0.1f, 255, 255, 255, 255 );
+		NDebugOverlay::HorzArrow( GetFeet(), m_ladderDismountGoal->GetCenter(), 5.0f, 255, 255, 0, 255, true, 0.1f );
+	}
+
+	// test 2D vector here in case nav area is under the geometry a bit
+	const float tolerance = 10.0f;
+	if ( GetBot()->GetEntity()->GetLastKnownArea() == m_ladderDismountGoal && range < tolerance )
+	{
+		// reached dismount goal
+		m_ladderInfo = NULL;
+		return NO_LADDER;
+	}
+
+	return DISMOUNTING_LADDER_TOP;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+PlayerLocomotion::LadderState PlayerLocomotion::DismountLadderBottom( void )
+{
+	if ( m_ladderInfo == NULL || m_ladderTimer.IsElapsed() )
+	{
+		m_ladderInfo = NULL;
+		return NO_LADDER;
+	}
+
+	if ( GetBot()->GetEntity()->GetMoveType() == MOVETYPE_LADDER )
+	{
+		// near the bottom - just let go
+		GetBot()->GetEntity()->SetMoveType( MOVETYPE_WALK );
+		m_ladderInfo = NULL;
+	}
+
+	return NO_LADDER;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Update internal state
+ */
+void PlayerLocomotion::Update( void )
+{
+	if ( TraverseLadder() )
+	{
+		return BaseClass::Update();
+	}
+
+	if ( m_isJumpingAcrossGap || m_isClimbingUpToLedge )
+	{
+		// force a run
+		SetMinimumSpeedLimit( GetRunSpeed() );
+
+		Vector toLanding = m_landingGoal - GetFeet();
+		toLanding.z = 0.0f;
+		toLanding.NormalizeInPlace();
+
+		if ( m_hasLeftTheGround )
+		{
+			// face into the jump/climb
+			GetBot()->GetBodyInterface()->AimHeadTowards( GetBot()->GetEntity()->EyePosition() + 100.0 * toLanding, IBody::MANDATORY, 0.25f, NULL, "Facing impending jump/climb" );
+
+			if ( IsOnGround() )
+			{
+				// back on the ground - jump is complete
+				m_isClimbingUpToLedge = false;
+				m_isJumpingAcrossGap = false;
+				SetMinimumSpeedLimit( 0.0f );
+			}
+		}
+		else
+		{
+			// haven't left the ground yet - just starting the jump
+
+			if ( !IsClimbingOrJumping() )
+			{
+				Jump();
+			}
+
+			Vector vel = GetBot()->GetEntity()->GetAbsVelocity();
+
+			if ( m_isJumpingAcrossGap )
+			{
+				// cheat and max our velocity in case we were stopped at the edge of this gap
+				vel.x = GetRunSpeed() * toLanding.x;
+				vel.y = GetRunSpeed() * toLanding.y;
+				// leave vel.z unchanged
+			}
+
+			GetBot()->GetEntity()->SetAbsVelocity( vel );
+
+			if ( !IsOnGround() )
+			{
+				// jump has begun
+				m_hasLeftTheGround = true;
+			}
+		}
+
+		
+		Approach( m_landingGoal );
+	}
+
+	BaseClass::Update();
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+void PlayerLocomotion::AdjustPosture( const Vector &moveGoal )
+{
+	// This function has no effect if we're not standing or crouching
+	IBody *body = GetBot()->GetBodyInterface();
+	if ( !body->IsActualPosture( IBody::STAND ) && !body->IsActualPosture( IBody::CROUCH ) )
+		return;
+
+	// not all games have auto-crouch, so don't assume it here
+	BaseClass::AdjustPosture( moveGoal );
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Build a user command to move this player towards the goal position
+ */
+void PlayerLocomotion::Approach( const Vector &pos, float goalWeight )
+{
+	VPROF_BUDGET( "PlayerLocomotion::Approach", "NextBot" );
+
+	BaseClass::Approach( pos );
+
+	AdjustPosture( pos );
+
+	if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+	{
+		NDebugOverlay::Line( GetFeet(), pos, 255, 255, 0, true, 0.1f );
+	}
+
+	INextBotPlayerInput *playerButtons = dynamic_cast< INextBotPlayerInput * >( GetBot() );
+
+	if ( !playerButtons )
+	{
+		DevMsg( "PlayerLocomotion::Approach: No INextBotPlayerInput\n " );
+		return;
+	}
+
+	Vector forward3D;
+	m_player->EyeVectors( &forward3D );
+	
+	Vector2D forward( forward3D.x, forward3D.y );
+	forward.NormalizeInPlace();
+		
+	Vector2D right( forward.y, -forward.x );
+
+	// compute unit vector to goal position
+	Vector2D to = ( pos - GetFeet() ).AsVector2D();
+	float goalDistance = to.NormalizeInPlace();
+
+	float ahead = to.Dot( forward );
+	float side = to.Dot( right );
+
+#ifdef NEED_TO_INTEGRATE_MOTION_CONTROLLED_CODE_FROM_L4D_PLAYERS
+	// If we're climbing ledges, we need to stay crouched to prevent player movement code from messing
+	// with our origin.
+	CTerrorPlayer *player = ToTerrorPlayer(m_player);
+	if ( player && player->IsMotionControlledZ( player->GetMainActivity() ) )
+	{
+		playerButtons->PressCrouchButton();
+		return;
+	}
+#endif
+
+	if ( m_player->IsOnLadder() && IsUsingLadder() && ( m_ladderState == ASCENDING_LADDER || m_ladderState == DESCENDING_LADDER ) )
+	{
+		// we are on a ladder and WANT to be on a ladder.
+		playerButtons->PressForwardButton();
+
+		// Stay in center of ladder.  The gamemovement will autocenter us in most cases, but this is needed in case it doesn't.
+		if ( m_ladderInfo )
+		{
+			Vector posOnLadder;
+			CalcClosestPointOnLine( GetFeet(), m_ladderInfo->m_bottom, m_ladderInfo->m_top, posOnLadder );
+
+			Vector alongLadder = m_ladderInfo->m_top - m_ladderInfo->m_bottom;
+			alongLadder.NormalizeInPlace();
+
+			Vector rightLadder = CrossProduct( alongLadder, m_ladderInfo->GetNormal() );
+
+			Vector away = GetFeet() - posOnLadder;
+
+			// we only want error in plane of ladder
+			float error = DotProduct( away, rightLadder );
+			away.NormalizeInPlace();
+
+			const float tolerance = 5.0f + 0.25f * GetBot()->GetBodyInterface()->GetHullWidth();
+			if ( error > tolerance )
+			{
+				if ( DotProduct( away, rightLadder ) > 0.0f )
+				{
+					playerButtons->PressLeftButton();
+				}
+				else
+				{
+					playerButtons->PressRightButton();
+				}
+			}
+		}
+	}
+	else
+	{
+		const float epsilon = 0.25f;
+		if ( NextBotPlayerMoveDirect.GetBool() )
+		{
+			if ( goalDistance > epsilon )
+			{
+				playerButtons->SetButtonScale( ahead, side );
+			}
+		}
+
+		if ( ahead > epsilon )
+		{
+			playerButtons->PressForwardButton();
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+			{
+				NDebugOverlay::HorzArrow( m_player->GetAbsOrigin(), m_player->GetAbsOrigin() + 50.0f * Vector( forward.x, forward.y, 0.0f ), 15.0f, 0, 255, 0, 255, true, 0.1f );
+			}
+		}
+		else if ( ahead < -epsilon )
+		{
+			playerButtons->PressBackwardButton();
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+			{
+				NDebugOverlay::HorzArrow( m_player->GetAbsOrigin(), m_player->GetAbsOrigin() - 50.0f * Vector( forward.x, forward.y, 0.0f ), 15.0f, 255, 0, 0, 255, true, 0.1f );
+			}
+		}
+
+		if ( side <= -epsilon )
+		{
+			playerButtons->PressLeftButton();
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+			{
+				NDebugOverlay::HorzArrow( m_player->GetAbsOrigin(), m_player->GetAbsOrigin() - 50.0f * Vector( right.x, right.y, 0.0f ), 15.0f, 255, 0, 255, 255, true, 0.1f );
+			}
+		}
+		else if ( side >= epsilon )
+		{
+			playerButtons->PressRightButton();
+
+			if ( GetBot()->IsDebugging( NEXTBOT_LOCOMOTION ) )
+			{
+				NDebugOverlay::HorzArrow( m_player->GetAbsOrigin(), m_player->GetAbsOrigin() + 50.0f * Vector( right.x, right.y, 0.0f ), 15.0f, 0, 255, 255, 255, true, 0.1f );
+			}
+		}
+	}
+
+	if ( !IsRunning() )
+	{
+		playerButtons->PressWalkButton();
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * Move the bot to the precise given position immediately, 
+ */
+void PlayerLocomotion::DriveTo( const Vector &pos )
+{
+	BaseClass::DriveTo( pos );
+
+	Approach( pos );
+}
+
+
+//----------------------------------------------------------------------------------------------------
+bool PlayerLocomotion::IsClimbPossible( INextBot *me, const CBaseEntity *obstacle ) const
+{
+	// don't jump unless we have to
+	const PathFollower *path = GetBot()->GetCurrentPath();
+	if ( path )
+	{
+		const float watchForClimbRange = 75.0f;
+		if ( !path->IsDiscontinuityAhead( GetBot(), Path::CLIMB_UP, watchForClimbRange ) )
+		{
+			// we are not planning on climbing
+
+			// always allow climbing over movable obstacles
+			if ( obstacle && !const_cast< CBaseEntity * >( obstacle )->IsWorld() )
+			{
+				IPhysicsObject *physics = obstacle->VPhysicsGetObject();
+				if ( physics && physics->IsMoveable() )
+				{
+					// movable physics object - climb over it
+					return true;
+				}
+			}
+
+			if ( !GetBot()->GetLocomotionInterface()->IsStuck() )
+			{
+				// we're not stuck - don't try to jump up yet
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------------
+bool PlayerLocomotion::ClimbUpToLedge( const Vector &landingGoal, const Vector &landingForward, const CBaseEntity *obstacle )
+{
+	if ( !IsClimbPossible( GetBot(), obstacle ) )
+	{
+		return false;
+	}
+
+	Jump();
+
+	m_isClimbingUpToLedge = true;
+	m_landingGoal = landingGoal;
+	m_hasLeftTheGround = false;
+
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------------
+void PlayerLocomotion::JumpAcrossGap( const Vector &landingGoal, const Vector &landingForward )
+{
+	Jump();
+
+	// face forward
+	GetBot()->GetBodyInterface()->AimHeadTowards( landingGoal, IBody::MANDATORY, 1.0f, NULL, "Looking forward while jumping a gap" );
+
+	m_isJumpingAcrossGap = true;
+	m_landingGoal = landingGoal;
+	m_hasLeftTheGround = false;
+}
+
+
+//----------------------------------------------------------------------------------------------------
+void PlayerLocomotion::Jump( void )
+{
+	m_isJumping = true;
+	m_jumpTimer.Start( 0.5f );
+
+	INextBotPlayerInput *playerButtons = dynamic_cast< INextBotPlayerInput * >( GetBot() );
+	if ( playerButtons )
+	{
+		playerButtons->PressJumpButton();
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------
+bool PlayerLocomotion::IsClimbingOrJumping( void ) const
+{
+	if ( !m_isJumping )
+		return false;
+		
+	if ( m_jumpTimer.IsElapsed() && IsOnGround() )
+	{
+		m_isJumping = false;
+		return false;
+	}
+	
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------------
+bool PlayerLocomotion::IsClimbingUpToLedge( void ) const
+{
+	return m_isClimbingUpToLedge;
+}
+
+
+//----------------------------------------------------------------------------------------------------
+bool PlayerLocomotion::IsJumpingAcrossGap( void ) const
+{
+	return m_isJumpingAcrossGap;
+}
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * Return true if standing on something
+ */
+bool PlayerLocomotion::IsOnGround( void ) const
+{
+	return (m_player->GetGroundEntity() != NULL);
+}
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * Return the current ground entity or NULL if not on the ground
+ */
+CBaseEntity *PlayerLocomotion::GetGround( void ) const
+{
+	return m_player->GetGroundEntity();
+}
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * Surface normal of the ground we are in contact with
+ */
+const Vector &PlayerLocomotion::GetGroundNormal( void ) const
+{
+	static Vector up( 0, 0, 1.0f );
+	return up;
+
+	// TODO: Integrate movehelper_server for this:  return m_player->GetGroundNormal();
+}
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * Climb the given ladder to the top and dismount
+ */
+void PlayerLocomotion::ClimbLadder( const CNavLadder *ladder, const CNavArea *dismountGoal )
+{
+	// look up and push forward
+// 	Vector goal =  GetBot()->GetPosition() + 100.0f * ( Vector( 0, 0, 1.0f ) - ladder->GetNormal() );
+// 	Approach( goal );
+// 	FaceTowards( goal );
+	
+	m_ladderState = APPROACHING_ASCENDING_LADDER;
+	m_ladderInfo = ladder;
+	m_ladderDismountGoal = dismountGoal;
+}
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * Descend the given ladder to the bottom and dismount
+ */
+void PlayerLocomotion::DescendLadder( const CNavLadder *ladder, const CNavArea *dismountGoal )
+{
+	// look down and push forward
+// 	Vector goal =  GetBot()->GetPosition() + 100.0f * ( Vector( 0, 0, -1.0f ) - ladder->GetNormal() );
+// 	Approach( goal );
+// 	FaceTowards( goal );
+
+	m_ladderState = APPROACHING_DESCENDING_LADDER;
+	m_ladderInfo = ladder;
+	m_ladderDismountGoal = dismountGoal;
+}
+
+
+//----------------------------------------------------------------------------------------------------
+bool PlayerLocomotion::IsUsingLadder( void ) const
+{
+	return ( m_ladderState != NO_LADDER );
+}
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * Rotate body to face towards "target"
+ */
+void PlayerLocomotion::FaceTowards( const Vector &target )
+{
+	// player body follows view direction
+	Vector look( target.x, target.y, GetBot()->GetEntity()->EyePosition().z );
+
+	GetBot()->GetBodyInterface()->AimHeadTowards( look, IBody::BORING, 0.1f, NULL, "Body facing" );
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+* Return position of "feet" - point below centroid of bot at feet level
+*/
+const Vector &PlayerLocomotion::GetFeet( void ) const
+{
+	return m_player->GetAbsOrigin();
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Return current world space velocity
+ */
+const Vector &PlayerLocomotion::GetVelocity( void ) const
+{
+	return m_player->GetAbsVelocity();
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+float PlayerLocomotion::GetRunSpeed( void ) const
+{
+	return m_player->MaxSpeed();
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+float PlayerLocomotion::GetWalkSpeed( void ) const
+{
+	return 0.5f * m_player->MaxSpeed();
+}
+
diff --git a/game/server/NextBot/Player/NextBotPlayerLocomotion.h b/game/server/NextBot/Player/NextBotPlayerLocomotion.h
new file mode 100644
index 00000000..5da72601
--- /dev/null
+++ b/game/server/NextBot/Player/NextBotPlayerLocomotion.h
@@ -0,0 +1,223 @@
+// NextBotPlayerLocomotion.h
+// Locomotor for CBasePlayer derived bots
+// Author: Michael Booth, November 2005
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_PLAYER_LOCOMOTION_H_
+#define _NEXT_BOT_PLAYER_LOCOMOTION_H_
+
+#include "NextBot.h"
+#include "NextBotLocomotionInterface.h"
+#include "Path/NextBotPathFollow.h"
+
+class CBasePlayer;
+
+//--------------------------------------------------------------------------------------------------
+/**
+ * Basic player locomotion implementation
+ */
+class PlayerLocomotion : public ILocomotion
+{
+public:
+	DECLARE_CLASS( PlayerLocomotion, ILocomotion );
+
+	PlayerLocomotion( INextBot *bot );
+	virtual ~PlayerLocomotion() { }
+
+	virtual void Reset( void );							// reset to initial state
+	virtual void Update( void );						// update internal state
+
+	virtual void Approach( const Vector &pos, float goalWeight = 1.0f );	// move directly towards the given position
+	virtual void DriveTo( const Vector &pos );			// Move the bot to the precise given position immediately, 
+
+	//
+	// ILocomotion modifiers
+	//
+	virtual bool ClimbUpToLedge( const Vector &landingGoal, const Vector &landingForward, const CBaseEntity *obstacle );	// initiate a jump to an adjacent high ledge, return false if climb can't start
+	virtual void JumpAcrossGap( const Vector &landingGoal, const Vector &landingForward );	// initiate a jump across an empty volume of space to far side
+	virtual void Jump( void );								// initiate a simple undirected jump in the air
+	virtual bool IsClimbingOrJumping( void ) const;					// is jumping in any form
+	virtual bool IsClimbingUpToLedge( void ) const;			// is climbing up to a high ledge
+	virtual bool IsJumpingAcrossGap( void ) const;			// is jumping across a gap to the far side
+
+	virtual void Run( void );								// set desired movement speed to running
+	virtual void Walk( void );								// set desired movement speed to walking
+	virtual void Stop( void );								// set desired movement speed to stopped
+	virtual bool IsRunning( void ) const;
+	virtual void SetDesiredSpeed( float speed );			// set desired speed for locomotor movement
+	virtual float GetDesiredSpeed( void ) const;			// returns the current desired speed
+	virtual void SetMinimumSpeedLimit( float limit );		// speed cannot drop below this 
+	virtual void SetMaximumSpeedLimit( float limit );		// speed cannot rise above this 
+
+	virtual bool IsOnGround( void ) const;					// return true if standing on something
+	virtual CBaseEntity *GetGround( void ) const;			// return the current ground entity or NULL if not on the ground
+	virtual const Vector &GetGroundNormal( void ) const;	// surface normal of the ground we are in contact with
+
+	virtual void ClimbLadder( const CNavLadder *ladder, const CNavArea *dismountGoal );		// climb the given ladder to the top and dismount
+	virtual void DescendLadder( const CNavLadder *ladder, const CNavArea *dismountGoal );		// descend the given ladder to the bottom and dismount
+	virtual bool IsUsingLadder( void ) const;
+	virtual bool IsAscendingOrDescendingLadder( void ) const;	// we are actually on the ladder right now, either climbing up or down
+	virtual bool IsAbleToAutoCenterOnLadder( void ) const;
+
+	virtual void FaceTowards( const Vector &target );		// rotate body to face towards "target"
+
+	virtual void SetDesiredLean( const QAngle &lean )	{ }
+	virtual const QAngle &GetDesiredLean( void ) const	{ static QAngle junk; return junk; }
+
+	//
+	// ILocomotion information
+	//
+	virtual const Vector &GetFeet( void ) const;			// return position of "feet" - point below centroid of bot at feet level
+
+	virtual float GetStepHeight( void ) const;				// if delta Z is greater than this, we have to jump to get up
+	virtual float GetMaxJumpHeight( void ) const;			// return maximum height of a jump
+	virtual float GetDeathDropHeight( void ) const;			// distance at which we will die if we fall
+
+	virtual float GetRunSpeed( void ) const;				// get maximum running speed
+	virtual float GetWalkSpeed( void ) const;				// get maximum walking speed
+
+	virtual float GetMaxAcceleration( void ) const;			// return maximum acceleration of locomotor
+	virtual float GetMaxDeceleration( void ) const;			// return maximum deceleration of locomotor
+
+	virtual const Vector &GetVelocity( void ) const;		// return current world space velocity
+
+protected:
+	virtual void AdjustPosture( const Vector &moveGoal );
+
+private:
+	CBasePlayer *m_player;									// the player we are locomoting	
+
+	mutable bool m_isJumping;
+	CountdownTimer m_jumpTimer;
+
+	bool m_isClimbingUpToLedge;
+	bool m_isJumpingAcrossGap;
+	Vector m_landingGoal;
+	bool m_hasLeftTheGround;
+
+	float m_desiredSpeed;
+	float m_minSpeedLimit;
+	float m_maxSpeedLimit;
+
+	bool TraverseLadder( void );			// when climbing/descending a ladder
+
+	enum LadderState
+	{
+		NO_LADDER,							// not using a ladder
+		APPROACHING_ASCENDING_LADDER,
+		APPROACHING_DESCENDING_LADDER,
+		ASCENDING_LADDER,
+		DESCENDING_LADDER,
+		DISMOUNTING_LADDER_TOP,
+		DISMOUNTING_LADDER_BOTTOM,
+	};
+
+	LadderState m_ladderState;
+	LadderState ApproachAscendingLadder( void );
+	LadderState ApproachDescendingLadder( void );
+	LadderState AscendLadder( void );
+	LadderState DescendLadder( void );
+	LadderState DismountLadderTop( void );
+	LadderState DismountLadderBottom( void );
+	
+	const CNavLadder *m_ladderInfo;
+	const CNavArea *m_ladderDismountGoal;
+	CountdownTimer m_ladderTimer;			// a "give up" timer if things go awry
+
+	bool IsClimbPossible( INextBot *me, const CBaseEntity *obstacle ) const;
+};
+
+
+inline float PlayerLocomotion::GetStepHeight( void ) const
+{
+	return 18.0f;
+}
+
+
+inline float PlayerLocomotion::GetMaxJumpHeight( void ) const
+{
+	return 57.0f;
+}
+
+
+inline float PlayerLocomotion::GetDeathDropHeight( void ) const
+{
+	return 200.0f;
+}
+
+
+inline float PlayerLocomotion::GetMaxAcceleration( void ) const
+{
+	return 100.0f;
+}
+
+inline float PlayerLocomotion::GetMaxDeceleration( void ) const
+{
+	return 200.0f;
+}
+
+inline void PlayerLocomotion::Run( void )
+{
+	m_desiredSpeed = GetRunSpeed();
+}
+
+inline void PlayerLocomotion::Walk( void )
+{
+	m_desiredSpeed = GetWalkSpeed();
+}
+
+inline void PlayerLocomotion::Stop( void )
+{
+	m_desiredSpeed = 0.0f;
+}
+
+inline bool PlayerLocomotion::IsRunning( void ) const
+{
+	return true;
+}
+
+inline void PlayerLocomotion::SetDesiredSpeed( float speed )
+{
+	m_desiredSpeed = speed;
+}
+
+inline float PlayerLocomotion::GetDesiredSpeed( void ) const
+{
+	return clamp( m_desiredSpeed, m_minSpeedLimit, m_maxSpeedLimit );
+}
+
+inline void PlayerLocomotion::SetMinimumSpeedLimit( float limit )
+{
+	m_minSpeedLimit = limit;
+}
+
+inline void PlayerLocomotion::SetMaximumSpeedLimit( float limit )
+{
+	m_maxSpeedLimit = limit;
+}
+
+inline bool PlayerLocomotion::IsAbleToAutoCenterOnLadder( void ) const
+{
+	return IsUsingLadder() && (m_ladderState == ASCENDING_LADDER || m_ladderState == DESCENDING_LADDER);
+}
+
+inline bool PlayerLocomotion::IsAscendingOrDescendingLadder( void ) const
+{
+	switch( m_ladderState )
+	{
+	case ASCENDING_LADDER:
+	case DESCENDING_LADDER:
+	case DISMOUNTING_LADDER_TOP:
+	case DISMOUNTING_LADDER_BOTTOM:
+		return true;
+	default:
+		// Explicitly handle the default so that clang knows not to warn us.
+		// warning: enumeration values 'NO_LADDER', 'APPROACHING_ASCENDING_LADDER', and 'APPROACHING_DESCENDING_LADDER' not handled in switch [-Wswitch-enum]
+		break;
+	}
+
+	return false;
+}
+
+
+#endif // _NEXT_BOT_PLAYER_LOCOMOTION_H_
diff --git a/game/server/NextBot/simple_bot.cpp b/game/server/NextBot/simple_bot.cpp
new file mode 100644
index 00000000..dbae2397
--- /dev/null
+++ b/game/server/NextBot/simple_bot.cpp
@@ -0,0 +1,199 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// simple_bot.cpp
+// A simple bot
+// Michael Booth, February 2009
+
+#include "cbase.h"
+#include "simple_bot.h"
+#include "nav_mesh.h"
+
+
+//-----------------------------------------------------------------------------------------------------
+// Command to add a Simple Bot where your crosshairs are aiming
+//-----------------------------------------------------------------------------------------------------
+CON_COMMAND_F( simple_bot_add, "Add a simple bot.", FCVAR_CHEAT )
+{
+	CBasePlayer *player = UTIL_GetCommandClient();
+	if ( !player )
+	{
+		return;
+	}
+
+	Vector forward;
+	player->EyeVectors( &forward );
+
+	trace_t result;
+	UTIL_TraceLine( player->EyePosition(), player->EyePosition() + 999999.9f * forward, MASK_BLOCKLOS_AND_NPCS|CONTENTS_IGNORE_NODRAW_OPAQUE, player, COLLISION_GROUP_NONE, &result );
+	if ( !result.DidHit() )
+	{
+		return;
+	}
+
+	CSimpleBot *bot = static_cast< CSimpleBot * >( CreateEntityByName( "simple_bot" ) );
+	if ( bot )
+	{
+		Vector forward = player->GetAbsOrigin() - result.endpos;
+		forward.z = 0.0f;
+		forward.NormalizeInPlace();
+
+		QAngle angles;
+		VectorAngles( forward, angles );
+
+		bot->SetAbsAngles( angles );
+		bot->SetAbsOrigin( result.endpos + Vector( 0, 0, 10.0f ) );
+
+		DispatchSpawn( bot );
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+// The Simple Bot
+//-----------------------------------------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS( simple_bot, CSimpleBot );
+
+#ifndef TF_DLL
+PRECACHE_REGISTER( simple_bot );
+#endif
+
+
+//-----------------------------------------------------------------------------------------------------
+CSimpleBot::CSimpleBot()
+{
+	ALLOCATE_INTENTION_INTERFACE( CSimpleBot );
+
+	m_locomotor = new NextBotGroundLocomotion( this );
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+CSimpleBot::~CSimpleBot()
+{
+	DEALLOCATE_INTENTION_INTERFACE;
+
+	if ( m_locomotor )
+		delete m_locomotor;
+}
+
+//-----------------------------------------------------------------------------------------------------
+void CSimpleBot::Precache()
+{
+	BaseClass::Precache();
+
+#ifndef DOTA_DLL
+	PrecacheModel( "models/humans/group01/female_01.mdl" );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+void CSimpleBot::Spawn( void )
+{
+	BaseClass::Spawn();
+
+#ifndef DOTA_DLL
+	SetModel( "models/humans/group01/female_01.mdl" );
+#endif
+}
+
+
+//---------------------------------------------------------------------------------------------
+// The Simple Bot behaviors
+//---------------------------------------------------------------------------------------------
+/**
+ * For use with TheNavMesh->ForAllAreas()
+ * Find the Nth area in the sequence
+ */
+class SelectNthAreaFunctor
+{
+public:
+	SelectNthAreaFunctor( int count )
+	{
+		m_count = count;
+		m_area = NULL;
+	}
+
+	bool operator() ( CNavArea *area )
+	{
+		m_area = area;
+		return ( m_count-- > 0 );
+	}
+
+	int m_count;
+	CNavArea *m_area;
+};
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * This action causes the bot to pick a random nav area in the mesh and move to it, then
+ * pick another, etc.
+ * Actions usually each have their own .cpp/.h file and are organized into folders since there
+ * are often many of them. For this example, we're keeping everything to a single .cpp/.h file.
+ */
+class CSimpleBotRoam : public Action< CSimpleBot >
+{
+public:
+	//----------------------------------------------------------------------------------
+	// OnStart is called once when the Action first becomes active
+	virtual ActionResult< CSimpleBot >	OnStart( CSimpleBot *me, Action< CSimpleBot > *priorAction )
+	{
+		// smooth out the bot's path following by moving toward a point farther down the path
+		m_path.SetMinLookAheadDistance( 300.0f );
+
+		return Continue();
+	}
+
+
+	//----------------------------------------------------------------------------------
+	// Update is called repeatedly (usually once per server frame) while the Action is active
+	virtual ActionResult< CSimpleBot >	Update( CSimpleBot *me, float interval )
+	{
+		if ( m_path.IsValid() && !m_timer.IsElapsed() ) 
+		{
+			// PathFollower::Update() moves the bot along the path using the bot's ILocomotion and IBody interfaces
+			m_path.Update( me );
+		}
+		else
+		{
+			SelectNthAreaFunctor pick( RandomInt( 0, TheNavMesh->GetNavAreaCount() - 1 ) );
+			TheNavMesh->ForAllAreas( pick );
+
+			if ( pick.m_area )
+			{
+				CSimpleBotPathCost cost( me );
+				m_path.Compute( me, pick.m_area->GetCenter(), cost );
+			}
+
+			// follow this path for a random duration (or until we reach the end)
+			m_timer.Start( RandomFloat( 5.0f, 10.0f ) );
+		}
+
+		return Continue();
+	}
+
+
+	//----------------------------------------------------------------------------------
+	// this is an event handler - many more are available (see declaration of Action< Actor > in NextBotBehavior.h)
+	virtual EventDesiredResult< CSimpleBot > OnStuck( CSimpleBot *me )
+	{
+		// we are stuck trying to follow the current path - invalidate it so a new one is chosen
+		m_path.Invalidate();
+
+		return TryContinue();
+	}
+
+
+	virtual const char *GetName( void ) const	{ return "Roam"; }		// return name of this action
+
+private:
+	PathFollower m_path;
+	CountdownTimer m_timer;
+};
+
+
+//---------------------------------------------------------------------------------------------
+/**
+ * Instantiate the bot's Intention interface and start the initial Action (CSimpleBotRoam in this case)
+ */
+IMPLEMENT_INTENTION_INTERFACE( CSimpleBot, CSimpleBotRoam )
diff --git a/game/server/NextBot/simple_bot.h b/game/server/NextBot/simple_bot.h
new file mode 100644
index 00000000..b679b6ce
--- /dev/null
+++ b/game/server/NextBot/simple_bot.h
@@ -0,0 +1,116 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// simple_bot.h
+// A mininal example of a NextBotCombatCharacter (ie: non-player) bot
+// Michael Booth, February 2009
+
+#ifndef SIMPLE_BOT_H
+#define SIMPLE_BOT_H
+
+#include "NextBot.h"
+#include "NextBotBehavior.h"
+#include "NextBotGroundLocomotion.h"
+#include "Path/NextBotPathFollow.h"
+
+
+//----------------------------------------------------------------------------
+/**
+ * A Simple Bot
+ */
+class CSimpleBot : public NextBotCombatCharacter
+{
+public:
+	DECLARE_CLASS( CSimpleBot, NextBotCombatCharacter );
+
+	CSimpleBot();
+	virtual ~CSimpleBot();
+
+	virtual void Precache();
+	virtual void Spawn( void );
+
+	// INextBot
+	DECLARE_INTENTION_INTERFACE( CSimpleBot )
+	virtual NextBotGroundLocomotion	*GetLocomotionInterface( void ) const	{ return m_locomotor; }
+
+private:
+	NextBotGroundLocomotion	*m_locomotor;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Functor used with the A* algorithm of NavAreaBuildPath() to determine the "cost" of moving from one area to another.
+ * "Cost" is generally the weighted distance between the centers of the areas. If you want the bot
+ * to avoid an area/ladder/elevator, increase the cost.  If you want to disallow an area/ladder/elevator, return -1.
+ */
+class CSimpleBotPathCost : public IPathCost
+{
+public:
+	CSimpleBotPathCost( CSimpleBot *me )
+	{
+		m_me = me;
+	}
+
+	// return the cost (weighted distance between) of moving from "fromArea" to "area", or -1 if the move is not allowed
+	virtual float operator()( CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder, const CFuncElevator *elevator, float length ) const
+	{
+		if ( fromArea == NULL )
+		{
+			// first area in path, no cost
+			return 0.0f;
+		}
+		else
+		{
+			if ( !m_me->GetLocomotionInterface()->IsAreaTraversable( area ) )
+			{
+				// our locomotor says we can't move here
+				return -1.0f;
+			}
+
+			// compute distance traveled along path so far
+			float dist;
+
+			if ( ladder )
+			{
+				dist = ladder->m_length;
+			}
+			else if ( length > 0.0 )
+			{
+				// optimization to avoid recomputing length
+				dist = length;
+			}
+			else
+			{
+				dist = ( area->GetCenter() - fromArea->GetCenter() ).Length();
+			}
+
+			float cost = dist + fromArea->GetCostSoFar();
+
+			// check height change
+			float deltaZ = fromArea->ComputeAdjacentConnectionHeightChange( area );
+			if ( deltaZ >= m_me->GetLocomotionInterface()->GetStepHeight() )
+			{
+				if ( deltaZ >= m_me->GetLocomotionInterface()->GetMaxJumpHeight() )
+				{
+					// too high to reach
+					return -1.0f;
+				}
+
+				// jumping is slower than flat ground
+				const float jumpPenalty = 5.0f;
+				cost += jumpPenalty * dist;
+			}
+			else if ( deltaZ < -m_me->GetLocomotionInterface()->GetDeathDropHeight() )
+			{
+				// too far to drop
+				return -1.0f;
+			}
+
+			return cost;
+		}
+	}
+
+	CSimpleBot *m_me;
+};
+
+
+#endif // SIMPLE_BOT_H
diff --git a/game/server/cstrike/bot/cs_bot.cpp b/game/server/cstrike/bot/cs_bot.cpp
new file mode 100644
index 00000000..d3d8235f
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot.cpp
@@ -0,0 +1,1117 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_simple_hostage.h"
+#include "cs_gamerules.h"
+#include "func_breakablesurf.h"
+#include "obstacle_pushaway.h"
+
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+LINK_ENTITY_TO_CLASS( cs_bot, CCSBot );
+
+BEGIN_DATADESC( CCSBot )
+
+END_DATADESC()
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the number of bots following the given player
+ */
+int GetBotFollowCount( CCSPlayer *leader )
+{
+	int count = 0;
+
+	for( int i=1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBaseEntity *entity = UTIL_PlayerByIndex( i );
+
+		if (entity == NULL)
+			continue;
+
+		CBasePlayer *player = static_cast<CBasePlayer *>( entity );
+
+		if (!player->IsBot())
+			continue;
+
+ 		if (!player->IsAlive())
+ 			continue;
+
+		CCSBot *bot = dynamic_cast<CCSBot *>( player );
+		if (bot && bot->GetFollowLeader() == leader)
+			++count;
+	}
+
+	return count;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Change movement speed to walking
+ */
+void CCSBot::Walk( void )
+{
+	if (m_mustRunTimer.IsElapsed())
+	{
+		BaseClass::Walk();
+	}
+	else
+	{
+		// must run
+		Run();
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if jump was started.
+ * This is extended from the base jump to disallow jumping when in a crouch area.
+ */
+bool CCSBot::Jump( bool mustJump )
+{
+	// prevent jumping if we're crouched, unless we're in a crouchjump area - jump wins
+	bool inCrouchJumpArea = (m_lastKnownArea && 
+		(m_lastKnownArea->GetAttributes() & NAV_MESH_CROUCH) &&
+		(m_lastKnownArea->GetAttributes() & NAV_MESH_JUMP));
+
+	if ( !IsUsingLadder() && IsDucked() && !inCrouchJumpArea )
+	{
+		return false;
+	}
+
+	return BaseClass::Jump( mustJump );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when injured by something
+ * NOTE: We dont want to directly call Attack() here, or the bots will have super-human reaction times when injured
+ */
+int CCSBot::OnTakeDamage( const CTakeDamageInfo &info )
+{
+	CBaseEntity *attacker = info.GetInflictor();
+
+	// getting hurt makes us alert
+	BecomeAlert();
+	StopWaiting();
+
+	// if we were attacked by a teammate, rebuke
+	if (attacker->IsPlayer())
+	{
+		CCSPlayer *player = static_cast<CCSPlayer *>( attacker );
+		
+		if (InSameTeam( player ) && !player->IsBot())
+			GetChatter()->FriendlyFire();
+	}
+
+	if (attacker->IsPlayer() && IsEnemy( attacker ))
+	{
+		// Track previous attacker so we don't try to panic multiple times for a shotgun blast
+		CCSPlayer *lastAttacker = m_attacker;
+		float lastAttackedTimestamp = m_attackedTimestamp;
+
+		// keep track of our last attacker
+		m_attacker = reinterpret_cast<CCSPlayer *>( attacker );
+		m_attackedTimestamp = gpGlobals->curtime;
+
+		// no longer safe
+		AdjustSafeTime();
+
+		if ( !IsSurprised() && (m_attacker != lastAttacker || m_attackedTimestamp != lastAttackedTimestamp) )
+		{
+			CCSPlayer *enemy = static_cast<CCSPlayer *>( attacker );
+
+			// being hurt by an enemy we can't see causes panic
+			if (!IsVisible( enemy, CHECK_FOV ))
+			{
+				// if not attacking anything, look around to try to find attacker
+				if (!IsAttacking())
+				{
+					Panic();
+				}
+				else	// we are attacking
+				{
+					if (!IsEnemyVisible())
+					{
+						// can't see our current enemy, panic to acquire new attacker
+						Panic();
+					}
+				}
+			}
+		}
+	}
+
+	// extend
+	return BaseClass::OnTakeDamage( info );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when killed
+ */
+void CCSBot::Event_Killed( const CTakeDamageInfo &info )
+{ 
+//	PrintIfWatched( "Killed( attacker = %s )\n", STRING(pevAttacker->netname) );
+
+	GetChatter()->OnDeath();
+
+	// increase the danger where we died
+	const float deathDanger = 1.0f;
+	const float deathDangerRadius = 500.0f;
+	TheNavMesh->IncreaseDangerNearby( GetTeamNumber(), deathDanger, m_lastKnownArea, GetAbsOrigin(), deathDangerRadius );
+
+	// end voice feedback
+	m_voiceEndTimestamp = 0.0f;
+
+	// extend
+	BaseClass::Event_Killed( info );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if line segment intersects rectagular volume
+ */
+#define HI_X	0x01
+#define LO_X 0x02
+#define HI_Y	0x04
+#define LO_Y 0x08
+#define HI_Z	0x10
+#define LO_Z 0x20
+
+inline bool IsIntersectingBox( const Vector& start, const Vector& end, const Vector& boxMin, const Vector& boxMax )
+{
+	unsigned char startFlags = 0;
+	unsigned char endFlags = 0;
+
+	// classify start point
+	if (start.x < boxMin.x)
+		startFlags |= LO_X;
+	if (start.x > boxMax.x)
+		startFlags |= HI_X;
+
+	if (start.y < boxMin.y)
+		startFlags |= LO_Y;
+	if (start.y > boxMax.y)
+		startFlags |= HI_Y;
+
+	if (start.z < boxMin.z)
+		startFlags |= LO_Z;
+	if (start.z > boxMax.z)
+		startFlags |= HI_Z;
+
+	// classify end point
+	if (end.x < boxMin.x)
+		endFlags |= LO_X;
+	if (end.x > boxMax.x)
+		endFlags |= HI_X;
+
+	if (end.y < boxMin.y)
+		endFlags |= LO_Y;
+	if (end.y > boxMax.y)
+		endFlags |= HI_Y;
+
+	if (end.z < boxMin.z)
+		endFlags |= LO_Z;
+	if (end.z > boxMax.z)
+		endFlags |= HI_Z;
+
+	// trivial reject
+	if (startFlags & endFlags)
+		return false;
+
+	/// @todo Do exact line/box intersection check
+
+	return true;
+}
+
+
+extern void UTIL_DrawBox( Extent *extent, int lifetime, int red, int green, int blue );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When bot is touched by another entity.
+ */
+void CCSBot::Touch( CBaseEntity *other )
+{
+	// EXTEND
+	BaseClass::Touch( other );
+
+	// if we have touched a higher-priority player, make way
+	/// @todo Need to account for reaction time, etc.
+	if (other->IsPlayer())
+	{
+		// if we are defusing a bomb, don't move
+		if (IsDefusingBomb())
+			return;
+
+		// if we are on a ladder, don't move
+		if (IsUsingLadder())
+			return;
+
+		CCSPlayer *player = static_cast<CCSPlayer *>( other );
+
+		// get priority of other player
+		unsigned int otherPri = TheCSBots()->GetPlayerPriority( player );
+
+		// get our priority
+		unsigned int myPri = TheCSBots()->GetPlayerPriority( this );
+
+		// if our priority is better, don't budge
+		if (myPri < otherPri)
+			return;
+
+		// they are higher priority - make way, unless we're already making way for someone more important
+		if (m_avoid != NULL)
+		{
+			unsigned int avoidPri = TheCSBots()->GetPlayerPriority( static_cast<CBasePlayer *>( static_cast<CBaseEntity *>( m_avoid ) ) );
+			if (avoidPri < otherPri)
+			{
+				// ignore 'other' because we're already avoiding someone better
+				return;
+			}
+		}
+
+		m_avoid = other;
+		m_avoidTimestamp = gpGlobals->curtime;
+	}
+
+	// Check for breakables we're actually touching
+	// If we're not stuck or crouched, we don't care
+	if ( !m_isStuck && !IsCrouching() && !IsOnLadder() )
+		return;
+
+	// See if it's breakable
+	if ( IsBreakableEntity( other ) )
+	{
+		// it's breakable - try to shoot it.
+		SetLookAt( "Breakable", other->WorldSpaceCenter(), PRIORITY_HIGH, 0.1f, false, 5.0f, true );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are busy doing something important
+ */
+bool CCSBot::IsBusy( void ) const
+{
+	if (IsAttacking() || 
+		IsBuying() ||
+		IsDefusingBomb() || 
+		GetTask() == PLANT_BOMB ||
+		GetTask() == RESCUE_HOSTAGES ||
+		IsSniping())
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::BotDeathThink( void )
+{
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Try to join the given team
+ */
+void CCSBot::TryToJoinTeam( int team )
+{
+	m_desiredTeam = team;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Assign given player as our current enemy to attack
+ */
+void CCSBot::SetBotEnemy( CCSPlayer *enemy )
+{
+	if (m_enemy != enemy)
+	{
+		m_enemy = enemy; 
+		m_currentEnemyAcquireTimestamp = gpGlobals->curtime;
+
+		PrintIfWatched( "SetBotEnemy: %s\n", (enemy) ? enemy->GetPlayerName() : "(NULL)" );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * If we are not on the navigation mesh (m_currentArea == NULL),
+ * move towards last known area.
+ * Return false if off mesh.
+ */
+bool CCSBot::StayOnNavMesh( void )
+{
+	if (m_currentArea == NULL)
+	{
+		// move back onto the area map
+
+		// if we have no lastKnownArea, we probably started off
+		// of the nav mesh - find the closest nav area and use it
+		CNavArea *goalArea;
+		if (!m_currentArea && !m_lastKnownArea)
+		{
+			goalArea = TheNavMesh->GetNearestNavArea( GetCentroid( this ) );
+			PrintIfWatched( "Started off the nav mesh - moving to closest nav area...\n" );
+		}
+		else
+		{
+			goalArea = m_lastKnownArea;
+			PrintIfWatched( "Getting out of NULL area...\n" );
+		}
+
+		if (goalArea)
+		{
+			Vector pos;
+			goalArea->GetClosestPointOnArea( GetCentroid( this ), &pos );
+
+			// move point into area
+			Vector to = pos - GetCentroid( this );
+			to.NormalizeInPlace();
+
+			const float stepInDist = 5.0f;		// how far to "step into" an area - must be less than min area size
+			pos = pos + (stepInDist * to);
+
+			MoveTowardsPosition( pos );
+		}
+
+		// if we're stuck, try to get un-stuck
+		// do stuck movements last, so they override normal movement
+		if (m_isStuck)
+			Wiggle();
+				
+		return false;
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we will do scenario-related tasks
+ */
+bool CCSBot::IsDoingScenario( void ) const
+{
+	// if we are deferring to humans, and there is a live human on our team, don't do the scenario
+	if (cv_bot_defer_to_human.GetBool())
+	{
+		if (UTIL_HumansOnTeam( GetTeamNumber(), IS_ALIVE ))
+			return false;
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we noticed the bomb on the ground or on the radar (for T's only)
+ */
+bool CCSBot::NoticeLooseBomb( void ) const
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	if (ctrl->GetScenario() != CCSBotManager::SCENARIO_DEFUSE_BOMB)
+		return false;
+
+	CBaseEntity *bomb = ctrl->GetLooseBomb();
+
+	if (bomb)
+	{
+		// T's can always see bomb on their radar
+		return true;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if can see the bomb lying on the ground
+ */
+bool CCSBot::CanSeeLooseBomb( void ) const
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	if (ctrl->GetScenario() != CCSBotManager::SCENARIO_DEFUSE_BOMB)
+		return false;
+
+	CBaseEntity *bomb = ctrl->GetLooseBomb();
+
+	if (bomb)
+	{
+		if (IsVisible( bomb->GetAbsOrigin(), CHECK_FOV ))
+			return true;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if can see the planted bomb 
+ */
+bool CCSBot::CanSeePlantedBomb( void ) const
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	if (ctrl->GetScenario() != CCSBotManager::SCENARIO_DEFUSE_BOMB)
+		return false;
+
+	if (!GetGameState()->IsBombPlanted())
+		return false;
+
+	const Vector *bombPos = GetGameState()->GetBombPosition();
+
+	if (bombPos && IsVisible( *bombPos, CHECK_FOV ))
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return last enemy that hurt us
+ */
+CCSPlayer *CCSBot::GetAttacker( void ) const
+{
+	if (m_attacker && m_attacker->IsAlive())
+		return m_attacker;
+
+	return NULL;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Immediately jump off of our ladder, if we're on one
+ */
+void CCSBot::GetOffLadder( void )
+{
+	if (IsUsingLadder())
+	{
+		Jump( MUST_JUMP );
+		DestroyPath();
+	}
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return time when given spot was last checked
+ */
+float CCSBot::GetHidingSpotCheckTimestamp( HidingSpot *spot ) const
+{
+	for( int i=0; i<m_checkedHidingSpotCount; ++i )
+		if (m_checkedHidingSpot[i].spot->GetID() == spot->GetID())
+			return m_checkedHidingSpot[i].timestamp;
+
+	return -999999.9f;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Set the timestamp of the given spot to now.
+ * If the spot is not in the set, overwrite the least recently checked spot.
+ */
+void CCSBot::SetHidingSpotCheckTimestamp( HidingSpot *spot )
+{
+	int leastRecent = 0;
+	float leastRecentTime = gpGlobals->curtime + 1.0f;
+
+	for( int i=0; i<m_checkedHidingSpotCount; ++i )
+	{
+		// if spot is in the set, just update its timestamp
+		if (m_checkedHidingSpot[i].spot->GetID() == spot->GetID())
+		{
+			m_checkedHidingSpot[i].timestamp = gpGlobals->curtime;
+			return;
+		}
+
+		// keep track of least recent spot
+		if (m_checkedHidingSpot[i].timestamp < leastRecentTime)
+		{
+			leastRecentTime = m_checkedHidingSpot[i].timestamp;
+			leastRecent = i;
+		}
+	}
+
+	// if there is room for more spots, append this one
+	if (m_checkedHidingSpotCount < MAX_CHECKED_SPOTS)
+	{
+		m_checkedHidingSpot[ m_checkedHidingSpotCount ].spot = spot;
+		m_checkedHidingSpot[ m_checkedHidingSpotCount ].timestamp = gpGlobals->curtime;
+		++m_checkedHidingSpotCount;
+	}
+	else
+	{
+		// replace the least recent spot
+		m_checkedHidingSpot[ leastRecent ].spot = spot;
+		m_checkedHidingSpot[ leastRecent ].timestamp = gpGlobals->curtime;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Periodic check of hostage count in case we lost some
+ */
+void CCSBot::UpdateHostageEscortCount( void )
+{
+	const float updateInterval = 1.0f;
+	if (m_hostageEscortCount == 0 || gpGlobals->curtime - m_hostageEscortCountTimestamp < updateInterval)
+		return;
+
+	m_hostageEscortCountTimestamp = gpGlobals->curtime;
+
+	// recount the hostages in case we lost some
+	m_hostageEscortCount = 0;
+
+	for( int i=0; i<g_Hostages.Count(); ++i )
+	{
+		CHostage *hostage = g_Hostages[i];
+
+		// skip dead or rescued hostages
+		if ( !hostage->IsValid() || !hostage->IsAlive() )
+			continue;
+
+		// check if hostage has targeted us, and is following
+		if ( hostage->IsFollowing( this ) )
+			++m_hostageEscortCount;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are outnumbered by enemies
+ */
+bool CCSBot::IsOutnumbered( void ) const
+{
+	return (GetNearbyFriendCount() < GetNearbyEnemyCount()-1) ? true : false;		
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return number of enemies we are outnumbered by
+ */
+int CCSBot::OutnumberedCount( void ) const
+{
+	if (IsOutnumbered())
+		return (GetNearbyEnemyCount()-1) - GetNearbyFriendCount();
+
+	return 0;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest "important" enemy for the given scenario (bomb carrier, VIP, hostage escorter)
+ */
+CCSPlayer *CCSBot::GetImportantEnemy( bool checkVisibility ) const
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+	CCSPlayer *nearEnemy = NULL;
+	float nearDist = 999999999.9f;
+
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CBaseEntity *entity = UTIL_PlayerByIndex( i );
+
+		if (entity == NULL)
+			continue;
+
+//		if (FNullEnt( entity->pev ))
+//			continue;
+
+//		if (FStrEq( STRING( entity->pev->netname ), "" ))
+//			continue;
+
+		// is it a player?
+		if (!entity->IsPlayer())
+			continue;
+
+		CCSPlayer *player = static_cast<CCSPlayer *>( entity );
+
+		// is it alive?
+		if (!player->IsAlive())
+			continue;
+
+		// skip friends
+		if (InSameTeam( player ))
+			continue;
+
+		// is it "important"
+		if (!ctrl->IsImportantPlayer( player ))
+			continue;
+
+		// is it closest?
+		Vector d = GetAbsOrigin() - player->GetAbsOrigin();
+		float distSq = d.x*d.x + d.y*d.y + d.z*d.z;
+		if (distSq < nearDist)
+		{
+			if (checkVisibility && !IsVisible( player, CHECK_FOV ))
+				continue;
+
+			nearEnemy = player;
+			nearDist = distSq;
+		}
+	}
+
+	return nearEnemy;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Sets our current disposition
+ */
+void CCSBot::SetDisposition( DispositionType disposition ) 
+{ 
+	m_disposition = disposition;
+
+	if (m_disposition != IGNORE_ENEMIES)
+		m_ignoreEnemiesTimer.Invalidate();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return our current disposition
+ */
+CCSBot::DispositionType CCSBot::GetDisposition( void ) const
+{
+	if (!m_ignoreEnemiesTimer.IsElapsed())
+		return IGNORE_ENEMIES;
+	
+	return m_disposition;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Ignore enemies for a short durationy
+ */
+void CCSBot::IgnoreEnemies( float duration )
+{
+	m_ignoreEnemiesTimer.Start( duration );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Increase morale one step
+ */
+void CCSBot::IncreaseMorale( void )
+{
+	if (m_morale < EXCELLENT)
+		m_morale = static_cast<MoraleType>( m_morale + 1 );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Decrease morale one step
+ */
+void CCSBot::DecreaseMorale( void )
+{
+	if (m_morale > TERRIBLE)
+		m_morale = static_cast<MoraleType>( m_morale - 1 );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are acting like a rogue (not listening to teammates, not doing scenario goals)
+ * @todo Account for morale
+ */
+bool CCSBot::IsRogue( void ) const
+{ 
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+	if (!ctrl->AllowRogues())
+		return false;
+
+	// periodically re-evaluate our rogue status
+	if (m_rogueTimer.IsElapsed())
+	{
+		m_rogueTimer.Start( RandomFloat( 10.0f, 30.0f ) );
+
+		// our chance of going rogue is inversely proportional to our teamwork attribute
+		const float rogueChance = 100.0f * (1.0f - GetProfile()->GetTeamwork());
+
+		m_isRogue = (RandomFloat( 0, 100 ) < rogueChance);
+	}
+
+	return m_isRogue; 
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are in a hurry 
+ */
+bool CCSBot::IsHurrying( void ) const
+{
+	if (!m_hurryTimer.IsElapsed())
+		return true;
+
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	// if the bomb has been planted, we are in a hurry, CT or T (they could be defusing it!)
+	if (ctrl->GetScenario() == CCSBotManager::SCENARIO_DEFUSE_BOMB && ctrl->IsBombPlanted())
+		return true;
+	
+	// if we are a T and hostages are being rescued, we are in a hurry
+	if (ctrl->GetScenario() == CCSBotManager::SCENARIO_RESCUE_HOSTAGES && 
+		GetTeamNumber() == TEAM_TERRORIST && 
+		GetGameState()->AreAllHostagesBeingRescued())
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if it is the early, "safe", part of the round
+ */
+bool CCSBot::IsSafe( void ) const
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	if (ctrl->GetElapsedRoundTime() < m_safeTime)
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if it is well past the early, "safe", part of the round
+ */
+bool CCSBot::IsWellPastSafe( void ) const
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	if (ctrl->GetElapsedRoundTime() > 2.0f * m_safeTime)
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we were in the safe time last update, but not now
+ */
+bool CCSBot::IsEndOfSafeTime( void ) const
+{
+	return m_wasSafe && !IsSafe();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the amount of "safe time" we have left
+ */
+float CCSBot::GetSafeTimeRemaining( void ) const
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	return m_safeTime - ctrl->GetElapsedRoundTime();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Called when enemy seen to adjust safe time for this round
+ */
+void CCSBot::AdjustSafeTime( void )
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	// if we spotted an enemy sooner than we thought possible, adjust our notion of "safe" time
+	if (ctrl->GetElapsedRoundTime() < m_safeTime)
+	{
+		// since right now is not safe, adjust safe time to be a few seconds ago
+		m_safeTime = ctrl->GetElapsedRoundTime() - 2.0f;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we haven't seen an enemy for "a long time"
+ */
+bool CCSBot::HasNotSeenEnemyForLongTime( void ) const
+{
+	const float longTime = 30.0f;
+	return (GetTimeSinceLastSawEnemy() > longTime);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Pick a random zone and hide near it
+ */
+bool CCSBot::GuardRandomZone( float range )
+{
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheCSBots() );
+
+	const CCSBotManager::Zone *zone = ctrl->GetRandomZone();
+	if (zone)
+	{
+		CNavArea *rescueArea = ctrl->GetRandomAreaInZone( zone );
+		if (rescueArea)
+		{
+			Hide( rescueArea, -1.0f, range );
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+class CollectRetreatSpotsFunctor
+{
+public:
+	CollectRetreatSpotsFunctor( CCSBot *me, float range )
+	{
+		m_me = me;
+		m_count = 0;
+		m_range = range;
+	}
+
+	enum { MAX_SPOTS = 256 };
+
+	bool operator() ( CNavArea *area )
+	{
+		// collect all the hiding spots in this area
+		const HidingSpotVector *pSpots = area->GetHidingSpots();
+
+		FOR_EACH_VEC( (*pSpots), it )
+		{
+			const HidingSpot *spot = (*pSpots)[ it ];
+
+			if (m_count >= MAX_SPOTS)
+				break;
+
+			// make sure hiding spot is in range
+			if (m_range > 0.0f)
+				if ((spot->GetPosition() - GetCentroid( m_me )).IsLengthGreaterThan( m_range ))
+					continue;
+
+			// if a Player is using this hiding spot, don't consider it
+			if (IsSpotOccupied( m_me, spot->GetPosition() ))
+			{
+				// player is in hiding spot
+				/// @todo Check if player is moving or sitting still
+				continue;
+			}
+
+			// don't select spot if an enemy can see it
+			if (UTIL_IsVisibleToTeam( spot->GetPosition() + Vector( 0, 0, HalfHumanHeight ), OtherTeam( m_me->GetTeamNumber() ) ))
+				continue;
+
+			// don't select spot if it is closest to an enemy
+			CBasePlayer *owner = UTIL_GetClosestPlayer( spot->GetPosition() );
+			if (owner && !m_me->InSameTeam( owner ))
+				continue;
+
+			m_spot[ m_count++ ] = &spot->GetPosition();
+		}
+
+		// if we've filled up, stop searching
+		if (m_count == MAX_SPOTS)
+			return false;
+
+		return true;
+	}
+
+	CCSBot *m_me;
+	float m_range;
+
+	const Vector *m_spot[ MAX_SPOTS ];
+	int m_count;
+};
+
+
+/**
+ * Do a breadth-first search to find a good retreat spot.
+ * Don't pick a spot that a Player is currently occupying.
+ */
+const Vector *FindNearbyRetreatSpot( CCSBot *me, float maxRange )
+{
+	CNavArea *area = me->GetLastKnownArea();
+	if (area == NULL)
+		return NULL;
+
+	// collect spots that enemies cannot see
+	CollectRetreatSpotsFunctor collector( me, maxRange );
+	SearchSurroundingAreas( area, GetCentroid( me ), collector, maxRange );
+
+	if (collector.m_count == 0)
+		return NULL;
+
+	// select a hiding spot at random
+	int which = RandomInt( 0, collector.m_count-1 );
+	return collector.m_spot[ which ];
+}
+
+//--------------------------------------------------------------------------------------------------------------
+class FarthestHostage
+{
+public:
+	FarthestHostage( const CCSBot *me )
+	{
+		m_me = me;
+		m_farRange = -1.0f;
+	}
+
+	bool operator() ( CHostage *hostage )
+	{
+		if (hostage->IsFollowing( m_me ))
+		{
+			float range = (hostage->GetAbsOrigin() - m_me->GetAbsOrigin()).Length();
+			if (range > m_farRange)
+			{
+				m_farRange = range;
+			}
+		}
+
+		return true;
+	}
+
+	const CCSBot *m_me;
+	float m_farRange;
+};
+
+/**
+ * Return euclidean distance to farthest escorted hostage.
+ * Return -1 if no hostage is following us.
+ */
+float CCSBot::GetRangeToFarthestEscortedHostage( void ) const
+{
+	FarthestHostage away( this );
+
+	ForEachHostage( away );
+
+	return away.m_farRange;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return string describing current task
+ * NOTE: This MUST be kept in sync with the CCSBot::TaskType enum
+ */
+const char *CCSBot::GetTaskName( void ) const
+{
+	static const char *name[ NUM_TASKS ] = 
+	{
+		"SEEK_AND_DESTROY",
+		"PLANT_BOMB",
+		"FIND_TICKING_BOMB",
+		"DEFUSE_BOMB",
+		"GUARD_TICKING_BOMB",
+		"GUARD_BOMB_DEFUSER",
+		"GUARD_LOOSE_BOMB",
+		"GUARD_BOMB_ZONE",
+		"GUARD_INITIAL_ENCOUNTER",
+		"ESCAPE_FROM_BOMB",
+		"HOLD_POSITION",
+		"FOLLOW",
+		"VIP_ESCAPE",
+		"GUARD_VIP_ESCAPE_ZONE",
+		"COLLECT_HOSTAGES",
+		"RESCUE_HOSTAGES",
+		"GUARD_HOSTAGES",
+		"GUARD_HOSTAGE_RESCUE_ZONE",
+		"MOVE_TO_LAST_KNOWN_ENEMY_POSITION",
+		"MOVE_TO_SNIPER_SPOT",
+		"SNIPING",
+	};
+
+	return name[ (int)GetTask() ];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return string describing current disposition
+ * NOTE: This MUST be kept in sync with the CCSBot::DispositionType enum
+ */
+const char *CCSBot::GetDispositionName( void ) const
+{
+	static const char *name[ NUM_DISPOSITIONS ] = 
+	{
+		"ENGAGE_AND_INVESTIGATE",
+		"OPPORTUNITY_FIRE",
+		"SELF_DEFENSE",
+		"IGNORE_ENEMIES"
+	};
+
+	return name[ (int)GetDisposition() ];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return string describing current morale
+ * NOTE: This MUST be kept in sync with the CCSBot::MoraleType enum
+ */
+const char *CCSBot::GetMoraleName( void ) const
+{
+	static const char *name[ EXCELLENT - TERRIBLE + 1 ] = 
+	{
+		"TERRIBLE",
+		"BAD",
+		"NEGATIVE",
+		"NEUTRAL",
+		"POSITIVE",
+		"GOOD",
+		"EXCELLENT"
+	};
+
+	return name[ (int)GetMorale() + 3 ];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Fill in a CUserCmd with our data
+ */
+void CCSBot::BuildUserCmd( CUserCmd& cmd, const QAngle& viewangles, float forwardmove, float sidemove, float upmove, int buttons, byte impulse )
+{
+	Q_memset( &cmd, 0, sizeof( cmd ) );
+	if ( !RunMimicCommand( cmd ) )
+	{
+		// Don't walk when ducked - it's painfully slow
+		if ( m_Local.m_bDucked || m_Local.m_bDucking )
+		{
+			buttons &= ~IN_SPEED;
+		}
+
+		cmd.command_number = gpGlobals->tickcount;
+		cmd.forwardmove = forwardmove;
+		cmd.sidemove = sidemove;
+		cmd.upmove = upmove;
+		cmd.buttons = buttons;
+		cmd.impulse = impulse;
+
+		VectorCopy( viewangles, cmd.viewangles );
+		cmd.random_seed = random->RandomInt( 0, 0x7fffffff );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
diff --git a/game/server/cstrike/bot/cs_bot.h b/game/server/cstrike/bot/cs_bot.h
new file mode 100644
index 00000000..e9530d5d
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot.h
@@ -0,0 +1,2004 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+//
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+//
+// NOTE: The CS Bot code uses Doxygen-style comments. If you run Doxygen over this code, it will 
+// auto-generate documentation.  Visit www.doxygen.org to download the system for free.
+//
+
+#ifndef _CS_BOT_H_
+#define _CS_BOT_H_
+
+#include "bot/bot.h"
+#include "bot/cs_bot_manager.h"
+#include "bot/cs_bot_chatter.h"
+#include "cs_gamestate.h"
+#include "cs_player.h"
+#include "weapon_csbase.h"
+#include "cs_nav_pathfind.h"
+#include "cs_nav_area.h"
+
+class CBaseDoor;
+class CBasePropDoor;
+class CCSBot;
+class CPushAwayEnumerator;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * For use with player->m_rgpPlayerItems[]
+ */
+enum InventorySlotType
+{
+	PRIMARY_WEAPON_SLOT = 1,
+	PISTOL_SLOT,
+	KNIFE_SLOT,
+	GRENADE_SLOT,
+	C4_SLOT
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * The definition of a bot's behavior state.  One or more finite state machines 
+ * using these states implement a bot's behaviors.
+ */
+class BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot ) { }				///< when state is entered
+	virtual void OnUpdate( CCSBot *bot ) { }			///< state behavior
+	virtual void OnExit( CCSBot *bot ) { }				///< when state exited
+	virtual const char *GetName( void ) const = 0;		///< return state name
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * The state is invoked when a bot has nothing to do, or has finished what it was doing.
+ * A bot never stays in this state - it is the main action selection mechanism.
+ */
+class IdleState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "Idle"; }
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot is actively searching for an enemy.
+ */
+class HuntState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "Hunt"; }
+
+	void ClearHuntArea( void )						{ m_huntArea = NULL; }
+
+private:
+	CNavArea *m_huntArea;										///< "far away" area we are moving to
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot has an enemy and is attempting to kill it
+ */
+class AttackState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "Attack"; }
+	
+	void SetCrouchAndHold( bool crouch )			{ m_crouchAndHold = crouch; }
+
+protected:
+	enum DodgeStateType
+	{
+		STEADY_ON,
+		SLIDE_LEFT,
+		SLIDE_RIGHT,
+		JUMP,
+
+		NUM_ATTACK_STATES
+	};
+	DodgeStateType m_dodgeState;
+	float m_nextDodgeStateTimestamp;
+
+	CountdownTimer m_repathTimer;
+	float m_scopeTimestamp;
+
+	bool m_haveSeenEnemy;										///< false if we haven't yet seen the enemy since we started this attack (told by a friend, etc)
+	bool m_isEnemyHidden;										///< true we if we have lost line-of-sight to our enemy
+	float m_reacquireTimestamp;									///< time when we can fire again, after losing enemy behind cover
+	float m_shieldToggleTimestamp;								///< time to toggle shield deploy state
+	bool m_shieldForceOpen;										///< if true, open up and shoot even if in danger
+
+	float m_pinnedDownTimestamp;								///< time when we'll consider ourselves "pinned down" by the enemy
+
+	bool m_crouchAndHold;
+	bool m_didAmbushCheck;
+	bool m_shouldDodge;
+	bool m_firstDodge;
+
+	bool m_isCoward;											///< if true, we'll retreat if outnumbered during this fight
+	CountdownTimer m_retreatTimer;
+
+	void StopAttacking( CCSBot *bot );
+	void Dodge( CCSBot *bot );									///< do dodge behavior
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot has heard an enemy noise and is moving to find out what it was.
+ */
+class InvestigateNoiseState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "InvestigateNoise"; }
+
+private:
+	void AttendCurrentNoise( CCSBot *bot );						///< move towards currently heard noise
+	Vector m_checkNoisePosition;								///< the position of the noise we're investigating
+	CountdownTimer m_minTimer;									///< minimum time we will investigate our current noise
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot is buying equipment at the start of a round.
+ */
+class BuyState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "Buy"; }
+
+private:
+	bool m_isInitialDelay;
+	int m_prefRetries;											///< for retrying buying preferred weapon at current index
+	int m_prefIndex;											///< where are we in our list of preferred weapons
+
+	int m_retries;
+	bool m_doneBuying;
+	bool m_buyDefuseKit;
+	bool m_buyGrenade;
+	bool m_buyShield;
+	bool m_buyPistol;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot is moving to a potentially far away position in the world.
+ */
+class MoveToState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "MoveTo"; }
+	void SetGoalPosition( const Vector &pos )		{ m_goalPosition = pos; }
+	void SetRouteType( RouteType route )			{ m_routeType = route; }
+
+private:
+	Vector m_goalPosition;										///< goal position of move
+	RouteType m_routeType;										///< the kind of route to build
+	bool m_radioedPlan;
+	bool m_askedForCover;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a Terrorist bot is moving to pick up a dropped bomb.
+ */
+class FetchBombState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual const char *GetName( void ) const	{ return "FetchBomb"; }
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a Terrorist bot is actually planting the bomb.
+ */
+class PlantBombState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const	{ return "PlantBomb"; }
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a CT bot is actually defusing a live bomb.
+ */
+class DefuseBombState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const	{ return "DefuseBomb"; }
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot is hiding in a corner.
+ * NOTE: This state also includes MOVING TO that hiding spot, which may be all the way
+ * across the map!
+ */
+class HideState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const	{ return "Hide"; }
+
+	void SetHidingSpot( const Vector &pos )		{ m_hidingSpot = pos; }
+	const Vector &GetHidingSpot( void ) const	{ return m_hidingSpot; }
+
+	void SetSearchArea( CNavArea *area )		{ m_searchFromArea = area; }
+	void SetSearchRange( float range )			{ m_range = range; }
+	void SetDuration( float time )				{ m_duration = time; }
+	void SetHoldPosition( bool hold )			{ m_isHoldingPosition = hold; }
+
+	bool IsAtSpot( void ) const					{ return m_isAtSpot; }
+
+	float GetHideTime( void ) const
+	{
+		if (IsAtSpot())
+		{
+			return m_duration - m_hideTimer.GetRemainingTime();
+		}
+
+		return 0.0f;
+	}
+
+private:
+	CNavArea *m_searchFromArea;
+	float m_range;
+
+	Vector m_hidingSpot;
+	bool m_isLookingOutward;
+	bool m_isAtSpot;
+	float m_duration;
+	CountdownTimer m_hideTimer;								///< how long to hide
+
+	bool m_isHoldingPosition;
+	float m_holdPositionTime;								///< how long to hold our position after we hear nearby enemy noise
+
+	bool m_heardEnemy;										///< set to true when we first hear an enemy
+	float m_firstHeardEnemyTime;							///< when we first heard the enemy
+
+	int m_retry;											///< counter for retrying hiding spot
+
+	Vector m_leaderAnchorPos;								///< the position of our follow leader when we decided to hide
+
+	bool m_isPaused;										///< if true, we have paused in our retreat for a moment
+	CountdownTimer m_pauseTimer;							///< for stoppping and starting our pauses while we retreat
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot is attempting to flee from a bomb that is about to explode.
+ */
+class EscapeFromBombState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "EscapeFromBomb"; }
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot is following another player.
+ */
+class FollowState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "Follow"; }
+
+	void SetLeader( CCSPlayer *player )				{ m_leader = player; }
+
+private:
+	CHandle< CCSPlayer > m_leader;								///< the player we are following
+	Vector m_lastLeaderPos;										///< where the leader was when we computed our follow path
+	bool m_isStopped;
+	float m_stoppedTimestamp;
+
+	enum LeaderMotionStateType
+	{
+		INVALID,
+		STOPPED,
+		WALKING,
+		RUNNING
+	};
+	LeaderMotionStateType m_leaderMotionState;
+	IntervalTimer m_leaderMotionStateTime;
+
+	bool m_isSneaking;
+	float m_lastSawLeaderTime;
+	CountdownTimer m_repathInterval;
+
+	IntervalTimer m_walkTime;
+	bool m_isAtWalkSpeed;
+
+	float m_waitTime;
+	CountdownTimer m_idleTimer;
+
+	void ComputeLeaderMotionState( float leaderSpeed );
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot is actually using another entity (ie: facing towards it and pressing the use key)
+ */
+class UseEntityState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const			{ return "UseEntity"; }
+
+	void SetEntity( CBaseEntity *entity )				{ m_entity = entity; }
+
+private:
+	EHANDLE m_entity;											///< the entity we will use
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When a bot is opening a door
+ */
+class OpenDoorState : public BotState
+{
+public:
+	virtual void OnEnter( CCSBot *bot );
+	virtual void OnUpdate( CCSBot *bot );
+	virtual void OnExit( CCSBot *bot );
+	virtual const char *GetName( void ) const		{ return "OpenDoor"; }
+
+	void SetDoor( CBaseEntity *door );
+
+	bool IsDone( void ) const						{ return m_isDone; }	///< return true if behavior is done
+
+private:
+	CHandle< CBaseDoor > m_funcDoor;									///< the func_door we are opening
+	CHandle< CBasePropDoor > m_propDoor;								///< the prop_door we are opening
+	bool m_isDone;
+	CountdownTimer m_timeout;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * The Counter-strike Bot
+ */
+class CCSBot : public CBot< CCSPlayer >
+{
+public:
+	DECLARE_CLASS( CCSBot, CBot< CCSPlayer > );
+	DECLARE_DATADESC();
+
+	CCSBot( void );												///< constructor initializes all values to zero
+	virtual ~CCSBot();
+	virtual bool Initialize( const BotProfile *profile, int team );		///< (EXTEND) prepare bot for action
+
+	virtual void Spawn( void );									///< (EXTEND) spawn the bot into the game
+	virtual void Touch( CBaseEntity *other );					///< (EXTEND) when touched by another entity
+
+	virtual void Upkeep( void );								///< lightweight maintenance, invoked frequently
+	virtual void Update( void );								///< heavyweight algorithms, invoked less often
+	virtual void BuildUserCmd( CUserCmd& cmd, const QAngle& viewangles, float forwardmove, float sidemove, float upmove, int buttons, byte impulse );
+	virtual float GetMoveSpeed( void );							///< returns current movement speed (for walk/run)
+
+	virtual void Walk( void );
+	virtual bool Jump( bool mustJump = false );					///< returns true if jump was started
+
+	//- behavior properties ------------------------------------------------------------------------------------------
+	float GetCombatRange( void ) const;
+	bool IsRogue( void ) const;									///< return true if we dont listen to teammates or pursue scenario goals
+	void SetRogue( bool rogue );
+	bool IsHurrying( void ) const;								///< return true if we are in a hurry 
+	void Hurry( float duration );								///< force bot to hurry
+	bool IsSafe( void ) const;									///< return true if we are in a safe region
+	bool IsWellPastSafe( void ) const;							///< return true if it is well past the early, "safe", part of the round
+	bool IsEndOfSafeTime( void ) const;							///< return true if we were in the safe time last update, but not now
+	float GetSafeTimeRemaining( void ) const;					///< return the amount of "safe time" we have left
+	float GetSafeTime( void ) const;							///< return what we think the total "safe time" for this map is
+	virtual void Blind( float holdTime, float fadeTime, float startingAlpha = 255 );	// player blinded by a flashbang
+	bool IsUnhealthy( void ) const;								///< returns true if bot is low on health
+	
+	bool IsAlert( void ) const;									///< return true if bot is in heightened "alert" mode
+	void BecomeAlert( void );									///< bot becomes "alert" for immediately nearby enemies
+
+	bool IsSneaking( void ) const;								///< return true if bot is sneaking
+	void Sneak( float duration );								///< sneak for given duration
+
+	//- behaviors ---------------------------------------------------------------------------------------------------
+	void Idle( void );
+
+	void Hide( CNavArea *searchFromArea = NULL, float duration = -1.0f, float hideRange = 750.0f, bool holdPosition = false );	///< DEPRECATED: Use TryToHide() instead
+	#define USE_NEAREST true
+	bool TryToHide( CNavArea *searchFromArea = NULL, float duration = -1.0f, float hideRange = 750.0f, bool holdPosition = false, bool useNearest = false );	///< try to hide nearby, return false if cannot
+	void Hide( const Vector &hidingSpot, float duration = -1.0f, bool holdPosition = false );	///< move to the given hiding place
+	bool IsHiding( void ) const;								///< returns true if bot is currently hiding
+	bool IsAtHidingSpot( void ) const;							///< return true if we are hiding and at our hiding spot
+	float GetHidingTime( void ) const;							///< return number of seconds we have been at our current hiding spot
+
+	bool MoveToInitialEncounter( void );						///< move to a hiding spot and wait for initial encounter with enemy team (return false if no spots are available)
+
+	bool TryToRetreat( float maxRange = 1000.0f, float duration = -1.0f );	///< retreat to a nearby hiding spot, away from enemies
+
+	void Hunt( void );
+	bool IsHunting( void ) const;								///< returns true if bot is currently hunting
+
+	void Attack( CCSPlayer *victim );
+	void FireWeaponAtEnemy( void );								///< fire our active weapon towards our current enemy
+	void StopAttacking( void );
+	bool IsAttacking( void ) const;								///< returns true if bot is currently engaging a target
+
+	void MoveTo( const Vector &pos, RouteType route = SAFEST_ROUTE );	///< move to potentially distant position
+	bool IsMovingTo( void ) const;								///< return true if we are in the MoveTo state
+
+	void PlantBomb( void );
+
+	void FetchBomb( void );										///< bomb has been dropped - go get it
+	bool NoticeLooseBomb( void ) const;							///< return true if we noticed the bomb on the ground or on radar
+	bool CanSeeLooseBomb( void ) const;							///< return true if we directly see the loose bomb
+
+	void DefuseBomb( void );
+	bool IsDefusingBomb( void ) const;							///< returns true if bot is currently defusing the bomb
+	bool CanSeePlantedBomb( void ) const;						///< return true if we directly see the planted bomb
+
+	void EscapeFromBomb( void );
+	bool IsEscapingFromBomb( void ) const;						///< return true if we are escaping from the bomb
+
+	void RescueHostages( void );								///< begin process of rescuing hostages
+
+	void UseEntity( CBaseEntity *entity );						///< use the entity
+
+	void OpenDoor( CBaseEntity *door );							///< open the door (assumes we are right in front of it)
+	bool IsOpeningDoor( void ) const;							///< return true if we are in the process of opening a door
+
+	void Buy( void );											///< enter the buy state
+	bool IsBuying( void ) const;
+
+	void Panic( void );											///< look around in panic
+	bool IsPanicking( void ) const;								///< return true if bot is panicked
+	void StopPanicking( void );									///< end our panic
+	void UpdatePanicLookAround( void );							///< do panic behavior
+
+	void TryToJoinTeam( int team );								///< try to join the given team
+
+	void Follow( CCSPlayer *player );							///< begin following given Player
+	void ContinueFollowing( void );								///< continue following our leader after finishing what we were doing
+	void StopFollowing( void );									///< stop following
+	bool IsFollowing( void ) const;								///< return true if we are following someone (not necessarily in the follow state)
+	CCSPlayer *GetFollowLeader( void ) const;					///< return the leader we are following
+	float GetFollowDuration( void ) const;						///< return how long we've been following our leader
+	bool CanAutoFollow( void ) const;							///< return true if we can auto-follow
+
+	bool IsNotMoving( float minDuration = 0.0f ) const;			///< return true if we are currently standing still and have been for minDuration
+
+	void AimAtEnemy( void );									///< point our weapon towards our enemy
+	void StopAiming( void );									///< stop aiming at enemy
+	bool IsAimingAtEnemy( void ) const;							///< returns true if we are trying to aim at an enemy
+
+	float GetStateTimestamp( void ) const;						///< get time current state was entered
+
+	bool IsDoingScenario( void ) const;							///< return true if we will do scenario-related tasks
+
+	//- scenario / gamestate -----------------------------------------------------------------------------------------
+	CSGameState *GetGameState( void );							///< return an interface to this bot's gamestate
+	const CSGameState *GetGameState( void ) const;				///< return an interface to this bot's gamestate
+
+	bool IsAtBombsite( void );									///< return true if we are in a bomb planting zone
+	bool GuardRandomZone( float range = 500.0f );				///< pick a random zone and hide near it
+
+	bool IsBusy( void ) const;									///< return true if we are busy doing something important
+
+	//- high-level tasks ---------------------------------------------------------------------------------------------
+	enum TaskType
+	{
+		SEEK_AND_DESTROY,
+		PLANT_BOMB,
+		FIND_TICKING_BOMB,
+		DEFUSE_BOMB,
+		GUARD_TICKING_BOMB,
+		GUARD_BOMB_DEFUSER,
+		GUARD_LOOSE_BOMB,
+		GUARD_BOMB_ZONE,
+		GUARD_INITIAL_ENCOUNTER,
+		ESCAPE_FROM_BOMB,
+		HOLD_POSITION,
+		FOLLOW,
+		VIP_ESCAPE,
+		GUARD_VIP_ESCAPE_ZONE,
+		COLLECT_HOSTAGES,
+		RESCUE_HOSTAGES,
+		GUARD_HOSTAGES,
+		GUARD_HOSTAGE_RESCUE_ZONE,
+		MOVE_TO_LAST_KNOWN_ENEMY_POSITION,
+		MOVE_TO_SNIPER_SPOT,
+		SNIPING,
+
+		NUM_TASKS
+	};
+	void SetTask( TaskType task, CBaseEntity *entity = NULL );	///< set our current "task"
+	TaskType GetTask( void ) const;
+	CBaseEntity *GetTaskEntity( void );
+	const char *GetTaskName( void ) const;						///< return string describing current task
+
+	//- behavior modifiers ------------------------------------------------------------------------------------------
+	enum DispositionType
+	{
+		ENGAGE_AND_INVESTIGATE,								///< engage enemies on sight and investigate enemy noises
+		OPPORTUNITY_FIRE,									///< engage enemies on sight, but only look towards enemy noises, dont investigate
+		SELF_DEFENSE,										///< only engage if fired on, or very close to enemy
+		IGNORE_ENEMIES,										///< ignore all enemies - useful for ducking around corners, running away, etc
+
+		NUM_DISPOSITIONS
+	};
+	void SetDisposition( DispositionType disposition );		///< define how we react to enemies
+	DispositionType GetDisposition( void ) const;
+	const char *GetDispositionName( void ) const;			///< return string describing current disposition
+
+	void IgnoreEnemies( float duration );					///< ignore enemies for a short duration
+
+	enum MoraleType
+	{
+		TERRIBLE = -3,
+		BAD = -2,
+		NEGATIVE = -1,
+		NEUTRAL = 0,
+		POSITIVE = 1,
+		GOOD = 2,
+		EXCELLENT = 3,
+	};
+	MoraleType GetMorale( void ) const;
+	const char *GetMoraleName( void ) const;				///< return string describing current morale
+	void IncreaseMorale( void );
+	void DecreaseMorale( void );
+
+	void Surprise( float duration );						///< become "surprised" - can't attack
+	bool IsSurprised( void ) const;							///< return true if we are "surprised"
+
+
+	//- listening for noises ----------------------------------------------------------------------------------------
+	bool IsNoiseHeard( void ) const;							///< return true if we have heard a noise
+	bool HeardInterestingNoise( void );							///< return true if we heard an enemy noise worth checking in to
+	void InvestigateNoise( void );								///< investigate recent enemy noise
+	bool IsInvestigatingNoise( void ) const;					///< return true if we are investigating a noise
+	const Vector *GetNoisePosition( void ) const;				///< return position of last heard noise, or NULL if none heard
+	CNavArea *GetNoiseArea( void ) const;						///< return area where noise was heard
+	void ForgetNoise( void );									///< clear the last heard noise
+	bool CanSeeNoisePosition( void ) const;						///< return true if we directly see where we think the noise came from
+	float GetNoiseRange( void ) const;							///< return approximate distance to last noise heard
+
+	bool CanHearNearbyEnemyGunfire( float range = -1.0f ) const;///< return true if we hear nearby threatening enemy gunfire within given range (-1 == infinite)
+	PriorityType GetNoisePriority( void ) const;				///< return priority of last heard noise
+
+	//- radio and chatter--------------------------------------------------------------------------------------------
+	void SendRadioMessage( RadioType event );					///< send a radio message
+	void SpeakAudio( const char *voiceFilename, float duration, int pitch );	///< send voice chatter
+	BotChatterInterface *GetChatter( void );					///< return an interface to this bot's chatter system
+	bool RespondToHelpRequest( CCSPlayer *player, Place place, float maxRange = -1.0f );	///< decide if we should move to help the player, return true if we will
+	bool IsUsingVoice() const;									///< new-style "voice" chatter gets voice feedback
+
+
+	//- enemies ------------------------------------------------------------------------------------------------------
+	// BOTPORT: GetEnemy() collides with GetEnemy() in CBaseEntity - need to use different nomenclature
+	void SetBotEnemy( CCSPlayer *enemy );						///< set given player as our current enemy
+	CCSPlayer *GetBotEnemy( void ) const;
+	int GetNearbyEnemyCount( void ) const;						///< return max number of nearby enemies we've seen recently
+	unsigned int GetEnemyPlace( void ) const;					///< return location where we see the majority of our enemies
+	bool CanSeeBomber( void ) const;							///< return true if we can see the bomb carrier
+	CCSPlayer *GetBomber( void ) const;
+
+	int GetNearbyFriendCount( void ) const;						///< return number of nearby teammates
+	CCSPlayer *GetClosestVisibleFriend( void ) const;			///< return the closest friend that we can see
+	CCSPlayer *GetClosestVisibleHumanFriend( void ) const;		///< return the closest human friend that we can see
+
+	bool IsOutnumbered( void ) const;							///< return true if we are outnumbered by enemies
+	int OutnumberedCount( void ) const;							///< return number of enemies we are outnumbered by
+
+	#define ONLY_VISIBLE_ENEMIES true
+	CCSPlayer *GetImportantEnemy( bool checkVisibility = false ) const;	///< return the closest "important" enemy for the given scenario (bomb carrier, VIP, hostage escorter)
+
+	void UpdateReactionQueue( void );							///< update our reaction time queue
+	CCSPlayer *GetRecognizedEnemy( void );						///< return the most dangerous threat we are "conscious" of
+	bool IsRecognizedEnemyReloading( void );					///< return true if the enemy we are "conscious" of is reloading
+	bool IsRecognizedEnemyProtectedByShield( void );			///< return true if the enemy we are "conscious" of is hiding behind a shield
+	float GetRangeToNearestRecognizedEnemy( void );				///< return distance to closest enemy we are "conscious" of
+
+	CCSPlayer *GetAttacker( void ) const;						///< return last enemy that hurt us
+	float GetTimeSinceAttacked( void ) const;					///< return duration since we were last injured by an attacker
+	float GetFirstSawEnemyTimestamp( void ) const;				///< time since we saw any enemies
+	float GetLastSawEnemyTimestamp( void ) const;
+	float GetTimeSinceLastSawEnemy( void ) const;
+	float GetTimeSinceAcquiredCurrentEnemy( void ) const;
+	bool HasNotSeenEnemyForLongTime( void ) const;				///< return true if we haven't seen an enemy for "a long time"
+	const Vector &GetLastKnownEnemyPosition( void ) const;
+	bool IsEnemyVisible( void ) const;							///< is our current enemy visible
+	float GetEnemyDeathTimestamp( void ) const;
+	bool IsFriendInLineOfFire( void );							///< return true if a friend is in our weapon's way
+	bool IsAwareOfEnemyDeath( void ) const;						///< return true if we *noticed* that our enemy died
+	int GetLastVictimID( void ) const;							///< return the ID (entindex) of the last victim we killed, or zero
+
+	bool CanSeeSniper( void ) const;							///< return true if we can see an enemy sniper
+	bool HasSeenSniperRecently( void ) const;					///< return true if we have seen a sniper recently
+
+	float GetTravelDistanceToPlayer( CCSPlayer *player ) const;	///< return shortest path travel distance to this player	
+	bool DidPlayerJustFireWeapon( const CCSPlayer *player ) const;	///< return true if the given player just fired their weapon
+
+	//- navigation --------------------------------------------------------------------------------------------------
+	bool HasPath( void ) const;
+	void DestroyPath( void );
+
+	float GetFeetZ( void ) const;								///< return Z of bottom of feet
+
+	enum PathResult
+	{
+		PROGRESSING,		///< we are moving along the path
+		END_OF_PATH,		///< we reached the end of the path
+		PATH_FAILURE		///< we failed to reach the end of the path
+	};
+	#define NO_SPEED_CHANGE false
+	PathResult UpdatePathMovement( bool allowSpeedChange = true );	///< move along our computed path - if allowSpeedChange is true, bot will walk when near goal to ensure accuracy
+
+	//bool AStarSearch( CNavArea *startArea, CNavArea *goalArea );	///< find shortest path from startArea to goalArea - don't actually buid the path
+	bool ComputePath( const Vector &goal, RouteType route = SAFEST_ROUTE );	///< compute path to goal position
+	bool StayOnNavMesh( void );
+	CNavArea *GetLastKnownArea( void ) const;						///< return the last area we know we were inside of
+	const Vector &GetPathEndpoint( void ) const;					///< return final position of our current path
+	float GetPathDistanceRemaining( void ) const;					///< return estimated distance left to travel along path
+	void ResetStuckMonitor( void );
+	bool IsAreaVisible( const CNavArea *area ) const;				///< is any portion of the area visible to this bot
+	const Vector &GetPathPosition( int index ) const;
+	bool GetSimpleGroundHeightWithFloor( const Vector &pos, float *height, Vector *normal = NULL );	///< find "simple" ground height, treating current nav area as part of the floor
+	void BreakablesCheck( void );
+	void DoorCheck( void );											///< Check for any doors along our path that need opening
+
+	virtual void PushawayTouch( CBaseEntity *pOther );
+
+	Place GetPlace( void ) const;									///< get our current radio chatter place
+
+	bool IsUsingLadder( void ) const;								///< returns true if we are in the process of negotiating a ladder
+	void GetOffLadder( void );										///< immediately jump off of our ladder, if we're on one
+
+	void SetGoalEntity( CBaseEntity *entity );
+	CBaseEntity *GetGoalEntity( void );
+
+	bool IsNearJump( void ) const;									///< return true if nearing a jump in the path
+	float GetApproximateFallDamage( float height ) const;			///< return how much damage will will take from the given fall height
+
+	void ForceRun( float duration );								///< force the bot to run if it moves for the given duration
+	virtual bool IsRunning( void ) const;
+
+	void Wait( float duration );									///< wait where we are for the given duration
+	bool IsWaiting( void ) const;									///< return true if we are waiting
+	void StopWaiting( void );										///< stop waiting
+
+	void Wiggle( void );											///< random movement, for getting un-stuck
+
+	bool IsFriendInTheWay( const Vector &goalPos );					///< return true if a friend is between us and the given position
+	void FeelerReflexAdjustment( Vector *goalPosition );			///< do reflex avoidance movements if our "feelers" are touched
+
+	bool HasVisitedEnemySpawn( void ) const;						///< return true if we have visited enemy spawn at least once
+	bool IsAtEnemySpawn( void ) const;								///< return true if we are at the/an enemy spawn right now
+
+	//- looking around ----------------------------------------------------------------------------------------------
+
+	// BOTPORT: EVIL VILE HACK - why is EyePosition() not const?!?!?
+	const Vector &EyePositionConst( void ) const;
+	
+	void SetLookAngles( float yaw, float pitch );					///< set our desired look angles
+	void UpdateLookAngles( void );									///< move actual view angles towards desired ones
+	void UpdateLookAround( bool updateNow = false );				///< update "looking around" mechanism
+	void InhibitLookAround( float duration );						///< block all "look at" and "looking around" behavior for given duration - just look ahead
+
+	/// @todo Clean up notion of "forward angle" and "look ahead angle"
+	void SetForwardAngle( float angle );							///< define our forward facing
+	void SetLookAheadAngle( float angle );							///< define default look ahead angle
+
+	/// look at the given point in space for the given duration (-1 means forever)
+	void SetLookAt( const char *desc, const Vector &pos, PriorityType pri, float duration = -1.0f, bool clearIfClose = false, float angleTolerance = 5.0f, bool attack = false );
+	void ClearLookAt( void );										///< stop looking at a point in space and just look ahead
+	bool IsLookingAtSpot( PriorityType pri = PRIORITY_LOW ) const;	///< return true if we are looking at spot with equal or higher priority
+	bool IsViewMoving( float angleVelThreshold = 1.0f ) const;		///< returns true if bot's view angles are rotating (not still)
+	bool HasViewBeenSteady( float duration ) const;					///< how long has our view been "steady" (ie: not moving) for given duration
+
+	bool HasLookAtTarget( void ) const;								///< return true if we are in the process of looking at a target
+
+	enum VisiblePartType
+	{
+		NONE		= 0x00,
+		GUT			= 0x01,
+		HEAD		= 0x02,
+		LEFT_SIDE	= 0x04,			///< the left side of the object from our point of view (not their left side)
+		RIGHT_SIDE	= 0x08,			///< the right side of the object from our point of view (not their right side)
+		FEET		= 0x10
+	};
+
+	#define CHECK_FOV true
+	bool IsVisible( const Vector &pos, bool testFOV = false, const CBaseEntity *ignore = NULL ) const;	///< return true if we can see the point
+	bool IsVisible( CCSPlayer *player, bool testFOV = false, unsigned char *visParts = NULL ) const;	///< return true if we can see any part of the player
+
+	bool IsNoticable( const CCSPlayer *player, unsigned char visibleParts ) const;	///< return true if we "notice" given player 
+
+	bool IsEnemyPartVisible( VisiblePartType part ) const;			///< if enemy is visible, return the part we see for our current enemy
+	const Vector &GetPartPosition( CCSPlayer *player, VisiblePartType part ) const;	///< return world space position of given part on player
+
+	float ComputeWeaponSightRange( void );							///< return line-of-sight distance to obstacle along weapon fire ray
+
+	bool IsAnyVisibleEnemyLookingAtMe( bool testFOV = false ) const;///< return true if any enemy I have LOS to is looking directly at me
+
+	bool IsSignificantlyCloser( const CCSPlayer *testPlayer, const CCSPlayer *referencePlayer ) const;	///< return true if testPlayer is significantly closer than referencePlayer
+
+	//- approach points ---------------------------------------------------------------------------------------------
+	void ComputeApproachPoints( void );								///< determine the set of "approach points" representing where the enemy can enter this region
+	void UpdateApproachPoints( void );								///< recompute the approach point set if we have moved far enough to invalidate the current ones
+	void ClearApproachPoints( void );
+	void DrawApproachPoints( void ) const;							///< for debugging
+	float GetHidingSpotCheckTimestamp( HidingSpot *spot ) const;	///< return time when given spot was last checked
+	void SetHidingSpotCheckTimestamp( HidingSpot *spot );			///< set the timestamp of the given spot to now
+
+	const CNavArea *GetInitialEncounterArea( void ) const;			///< return area where we think we will first meet the enemy
+	void SetInitialEncounterArea( const CNavArea *area );
+
+	//- weapon query and equip --------------------------------------------------------------------------------------
+	#define MUST_EQUIP true
+	void EquipBestWeapon( bool mustEquip = false );					///< equip the best weapon we are carrying that has ammo
+	void EquipPistol( void );										///< equip our pistol
+	void EquipKnife( void );										///< equip the knife
+
+	#define DONT_USE_SMOKE_GRENADE true
+	bool EquipGrenade( bool noSmoke = false );						///< equip a grenade, return false if we cant
+
+	bool IsUsingKnife( void ) const;								///< returns true if we have knife equipped
+	bool IsUsingPistol( void ) const;								///< returns true if we have pistol equipped
+	bool IsUsingGrenade( void ) const;								///< returns true if we have grenade equipped
+	bool IsUsingSniperRifle( void ) const;							///< returns true if using a "sniper" rifle
+	bool IsUsing( CSWeaponID weapon ) const;						///< returns true if using the specific weapon
+	bool IsSniper( void ) const;									///< return true if we have a sniper rifle in our inventory
+	bool IsSniping( void ) const;									///< return true if we are actively sniping (moving to sniper spot or settled in)
+	bool IsUsingShotgun( void ) const;								///< returns true if using a shotgun
+	bool IsUsingMachinegun( void ) const;							///< returns true if using the big 'ol machinegun
+	void ThrowGrenade( const Vector &target );						///< begin the process of throwing the grenade
+	bool IsThrowingGrenade( void ) const;							///< return true if we are in the process of throwing a grenade
+	bool HasGrenade( void ) const;									///< return true if we have a grenade in our inventory
+	void AvoidEnemyGrenades( void );								///< react to enemy grenades we see
+	bool IsAvoidingGrenade( void ) const;							///< return true if we are in the act of avoiding a grenade
+	bool DoesActiveWeaponHaveSilencer( void ) const;				///< returns true if we are using a weapon with a removable silencer
+	bool CanActiveWeaponFire( void ) const;							///< returns true if our current weapon can attack
+	CWeaponCSBase *GetActiveCSWeapon( void ) const;					///< get our current Counter-Strike weapon
+
+	void GiveWeapon( const char *weaponAlias );						///< Debug command to give a named weapon
+
+	virtual void PrimaryAttack( void );								///< presses the fire button, unless we're holding a pistol that can't fire yet (so we can just always call PrimaryAttack())
+
+	enum ZoomType { NO_ZOOM, LOW_ZOOM, HIGH_ZOOM };
+	ZoomType GetZoomLevel( void );									///< return the current zoom level of our weapon
+
+	bool AdjustZoom( float range );									///< change our zoom level to be appropriate for the given range
+	bool IsWaitingForZoom( void ) const;							///< return true if we are reacquiring after our zoom
+
+	bool IsPrimaryWeaponEmpty( void ) const;						///< return true if primary weapon doesn't exist or is totally out of ammo
+	bool IsPistolEmpty( void ) const;								///< return true if pistol doesn't exist or is totally out of ammo
+
+	int GetHostageEscortCount( void ) const;						///< return the number of hostages following me
+	void IncreaseHostageEscortCount( void );
+	float GetRangeToFarthestEscortedHostage( void ) const;			///< return euclidean distance to farthest escorted hostage
+	void ResetWaitForHostagePatience( void );
+
+	//------------------------------------------------------------------------------------
+	// Event hooks
+	//
+
+	/// invoked when injured by something (EXTEND) - returns the amount of damage inflicted
+	virtual int OnTakeDamage( const CTakeDamageInfo &info );
+
+	/// invoked when killed (EXTEND)
+	virtual void Event_Killed( const CTakeDamageInfo &info );
+
+	virtual bool BumpWeapon( CBaseCombatWeapon *pWeapon );		///< invoked when in contact with a CWeaponBox
+
+
+	/// invoked when event occurs in the game (some events have NULL entity)
+	void OnPlayerFootstep( IGameEvent *event );
+	void OnPlayerRadio( IGameEvent *event );
+	void OnPlayerDeath( IGameEvent *event );
+	void OnPlayerFallDamage( IGameEvent *event );
+
+	void OnBombPickedUp( IGameEvent *event );
+	void OnBombPlanted( IGameEvent *event );
+	void OnBombBeep( IGameEvent *event );
+	void OnBombDefuseBegin( IGameEvent *event );
+	void OnBombDefused( IGameEvent *event );
+	void OnBombDefuseAbort( IGameEvent *event );
+	void OnBombExploded( IGameEvent *event );
+
+	void OnRoundEnd( IGameEvent *event );
+	void OnRoundStart( IGameEvent *event );
+
+	void OnDoorMoving( IGameEvent *event );
+
+	void OnBreakProp( IGameEvent *event );
+	void OnBreakBreakable( IGameEvent *event );
+
+	void OnHostageFollows( IGameEvent *event );
+	void OnHostageRescuedAll( IGameEvent *event );
+
+	void OnWeaponFire( IGameEvent *event );
+	void OnWeaponFireOnEmpty( IGameEvent *event );
+	void OnWeaponReload( IGameEvent *event );
+	void OnWeaponZoom( IGameEvent *event );
+
+	void OnBulletImpact( IGameEvent *event );
+
+	void OnHEGrenadeDetonate( IGameEvent *event );
+	void OnFlashbangDetonate( IGameEvent *event );
+	void OnSmokeGrenadeDetonate( IGameEvent *event );
+	void OnGrenadeBounce( IGameEvent *event );
+
+	void OnNavBlocked( IGameEvent *event );
+
+	void OnEnteredNavArea( CNavArea *newArea );						///< invoked when bot enters a nav area
+
+private:
+	#define IS_FOOTSTEP true
+	void OnAudibleEvent( IGameEvent *event, CBasePlayer *player, float range, PriorityType priority, bool isHostile, bool isFootstep = false, const Vector *actualOrigin = NULL );	///< Checks if the bot can hear the event
+
+private:
+	friend class CCSBotManager;
+
+	/// @todo Get rid of these
+	friend class AttackState;
+	friend class BuyState;
+
+	// BOTPORT: Remove this vile hack
+	Vector m_eyePosition;
+
+	void ResetValues( void );										///< reset internal data to initial state
+	void BotDeathThink( void );
+
+	char m_name[64];												///< copied from STRING(pev->netname) for debugging
+	void DebugDisplay( void ) const;								///< render bot debug info
+
+	//- behavior properties ------------------------------------------------------------------------------------------
+	float m_combatRange;											///< desired distance between us and them during gunplay
+	mutable bool m_isRogue;											///< if true, the bot is a "rogue" and listens to no-one
+	mutable CountdownTimer m_rogueTimer;
+	MoraleType m_morale;											///< our current morale, based on our win/loss history
+	bool m_diedLastRound;											///< true if we died last round
+	float m_safeTime;												///< duration at the beginning of the round where we feel "safe"
+	bool m_wasSafe;													///< true if we were in the safe time last update
+	void AdjustSafeTime( void );									///< called when enemy seen to adjust safe time for this round
+	NavRelativeDirType m_blindMoveDir;								///< which way to move when we're blind
+	bool m_blindFire;												///< if true, fire weapon while blinded
+	CountdownTimer m_surpriseTimer;									///< when we were surprised
+
+	bool m_isFollowing;												///< true if we are following someone
+	CHandle< CCSPlayer > m_leader;									///< the ID of who we are following
+	float m_followTimestamp;										///< when we started following
+	float m_allowAutoFollowTime;									///< time when we can auto follow
+
+	CountdownTimer m_hurryTimer;									///< if valid, bot is in a hurry
+	CountdownTimer m_alertTimer;									///< if valid, bot is alert
+	CountdownTimer m_sneakTimer;									///< if valid, bot is sneaking
+	CountdownTimer m_panicTimer;									///< if valid, bot is panicking
+
+
+	// instances of each possible behavior state, to avoid dynamic memory allocation during runtime
+	IdleState				m_idleState;
+	HuntState				m_huntState;
+	AttackState				m_attackState;
+	InvestigateNoiseState	m_investigateNoiseState;
+	BuyState				m_buyState;
+	MoveToState				m_moveToState;
+	FetchBombState			m_fetchBombState;
+	PlantBombState			m_plantBombState;
+	DefuseBombState			m_defuseBombState;
+	HideState				m_hideState;
+	EscapeFromBombState		m_escapeFromBombState;
+	FollowState				m_followState;
+	UseEntityState			m_useEntityState;
+	OpenDoorState			m_openDoorState;
+
+	/// @todo Allow multiple simultaneous state machines (look around, etc)	
+	void SetState( BotState *state );								///< set the current behavior state
+	BotState *m_state;												///< current behavior state
+	float m_stateTimestamp;											///< time state was entered
+	bool m_isAttacking;												///< if true, special Attack state is overriding the state machine
+	bool m_isOpeningDoor;											///< if true, special OpenDoor state is overriding the state machine
+
+	TaskType m_task;												///< our current task
+	EHANDLE m_taskEntity;											///< an entity used for our task
+
+	//- navigation ---------------------------------------------------------------------------------------------------
+	Vector m_goalPosition;
+	EHANDLE m_goalEntity;
+	void MoveTowardsPosition( const Vector &pos );					///< move towards position, independant of view angle
+	void MoveAwayFromPosition( const Vector &pos );					///< move away from position, independant of view angle
+	void StrafeAwayFromPosition( const Vector &pos );				///< strafe (sidestep) away from position, independant of view angle
+	void StuckCheck( void );										///< check if we have become stuck
+	CCSNavArea *m_currentArea;										///< the nav area we are standing on
+	CCSNavArea *m_lastKnownArea;										///< the last area we were in
+	EHANDLE m_avoid;												///< higher priority player we need to make way for
+	float m_avoidTimestamp;
+	bool m_isStopping;												///< true if we're trying to stop because we entered a 'stop' nav area
+	bool m_hasVisitedEnemySpawn;									///< true if we have been at the enemy spawn
+	IntervalTimer m_stillTimer;										///< how long we have been not moving
+
+	//- path navigation data ----------------------------------------------------------------------------------------
+	enum { MAX_PATH_LENGTH = 256 };
+	struct ConnectInfo
+	{
+		CNavArea *area;												///< the area along the path
+		NavTraverseType how;										///< how to enter this area from the previous one
+		Vector pos;													///< our movement goal position at this point in the path
+		const CNavLadder *ladder;									///< if "how" refers to a ladder, this is it
+	}
+	m_path[ MAX_PATH_LENGTH ];
+	int m_pathLength;
+	int m_pathIndex;												///< index of next area on path
+	float m_areaEnteredTimestamp;
+	void BuildTrivialPath( const Vector &goal );					///< build trivial path to goal, assuming we are already in the same area
+
+	CountdownTimer m_repathTimer;									///< must have elapsed before bot can pathfind again
+
+	bool ComputePathPositions( void );								///< determine actual path positions bot will move between along the path
+	void SetupLadderMovement( void );
+	void SetPathIndex( int index );									///< set the current index along the path
+	void DrawPath( void );
+	int FindOurPositionOnPath( Vector *close, bool local = false ) const;	///< compute the closest point to our current position on our path
+	int FindPathPoint( float aheadRange, Vector *point, int *prevIndex = NULL );	///< compute a point a fixed distance ahead along our path.
+	bool FindClosestPointOnPath( const Vector &pos, int startIndex, int endIndex, Vector *close ) const;	///< compute closest point on path to given point
+	bool IsStraightLinePathWalkable( const Vector &goal ) const;	///< test for un-jumpable height change, or unrecoverable fall
+	void ComputeLadderAngles( float *yaw, float *pitch );			///< computes ideal yaw/pitch for traversing the current ladder on our path
+
+	mutable CountdownTimer m_avoidFriendTimer;						///< used to throttle how often we check for friends in our path
+	mutable bool m_isFriendInTheWay;								///< true if a friend is blocking our path
+	CountdownTimer m_politeTimer;									///< we'll wait for friend to move until this runs out
+	bool m_isWaitingBehindFriend;									///< true if we are waiting for a friend to move
+
+	#define ONLY_JUMP_DOWN true
+	bool DiscontinuityJump( float ground, bool onlyJumpDown = false, bool mustJump = false ); ///< check if we need to jump due to height change
+
+	enum LadderNavState
+	{
+		APPROACH_ASCENDING_LADDER,									///< prepare to scale a ladder
+		APPROACH_DESCENDING_LADDER,									///< prepare to go down ladder 
+		FACE_ASCENDING_LADDER,
+		FACE_DESCENDING_LADDER,
+		MOUNT_ASCENDING_LADDER,										///< move toward ladder until "on" it
+		MOUNT_DESCENDING_LADDER,									///< move toward ladder until "on" it
+		ASCEND_LADDER,												///< go up the ladder
+		DESCEND_LADDER,												///< go down the ladder
+		DISMOUNT_ASCENDING_LADDER,									///< get off of the ladder
+		DISMOUNT_DESCENDING_LADDER,									///< get off of the ladder
+		MOVE_TO_DESTINATION,										///< dismount ladder and move to destination area
+	}
+	m_pathLadderState;
+	bool m_pathLadderFaceIn;										///< if true, face towards ladder, otherwise face away
+	const CNavLadder *m_pathLadder;									///< the ladder we need to use to reach the next area
+	bool UpdateLadderMovement( void );								///< called by UpdatePathMovement()
+	NavRelativeDirType m_pathLadderDismountDir;						///< which way to dismount
+	float m_pathLadderDismountTimestamp;							///< time when dismount started
+	float m_pathLadderEnd;											///< if ascending, z of top, if descending z of bottom
+	void ComputeLadderEndpoint( bool ascending );
+	float m_pathLadderTimestamp;									///< time when we started using ladder - for timeout check
+
+	CountdownTimer m_mustRunTimer;									///< if nonzero, bot cannot walk
+	CountdownTimer m_waitTimer;										///< if nonzero, we are waiting where we are
+
+	void UpdateTravelDistanceToAllPlayers( void );					///< periodically compute shortest path distance to each player
+	CountdownTimer m_updateTravelDistanceTimer;						///< for throttling travel distance computations
+	float m_playerTravelDistance[ MAX_PLAYERS ];					///< current distance from this bot to each player
+	unsigned char m_travelDistancePhase;							///< a counter for optimizing when to compute travel distance
+
+	//- game scenario mechanisms -------------------------------------------------------------------------------------
+	CSGameState m_gameState;										///< our current knowledge about the state of the scenario
+
+	byte m_hostageEscortCount;										///< the number of hostages we're currently escorting
+	void UpdateHostageEscortCount( void );							///< periodic check of hostage count in case we lost some
+	float m_hostageEscortCountTimestamp;
+
+	int m_desiredTeam;												///< the team we want to be on
+	bool m_hasJoined;												///< true if bot has actually joined the game
+
+	bool m_isWaitingForHostage;
+	CountdownTimer m_inhibitWaitingForHostageTimer;					///< if active, inhibits us waiting for lagging hostages
+	CountdownTimer m_waitForHostageTimer;							///< stops us waiting too long
+
+	//- listening mechanism ------------------------------------------------------------------------------------------
+	Vector m_noisePosition;											///< position we last heard non-friendly noise
+	float m_noiseTravelDistance;									///< the travel distance to the noise
+	float m_noiseTimestamp;											///< when we heard it (can get zeroed)
+	CNavArea *m_noiseArea;											///< the nav area containing the noise
+	PriorityType m_noisePriority;									///< priority of currently heard noise
+	bool UpdateLookAtNoise( void );									///< return true if we decided to look towards the most recent noise source
+	CountdownTimer m_noiseBendTimer;								///< for throttling how often we bend our line of sight to the noise location
+	Vector m_bentNoisePosition;										///< the last computed bent line of sight
+	bool m_bendNoisePositionValid;
+
+	//- "looking around" mechanism -----------------------------------------------------------------------------------
+	float m_lookAroundStateTimestamp;								///< time of next state change
+	float m_lookAheadAngle;											///< our desired forward look angle
+	float m_forwardAngle;											///< our current forward facing direction
+	float m_inhibitLookAroundTimestamp;								///< time when we can look around again
+
+	enum LookAtSpotState
+	{
+		NOT_LOOKING_AT_SPOT,			///< not currently looking at a point in space
+		LOOK_TOWARDS_SPOT,				///< in the process of aiming at m_lookAtSpot
+		LOOK_AT_SPOT,					///< looking at m_lookAtSpot
+		NUM_LOOK_AT_SPOT_STATES
+	}
+	m_lookAtSpotState;
+	Vector m_lookAtSpot;											///< the spot we're currently looking at
+	PriorityType m_lookAtSpotPriority;
+	float m_lookAtSpotDuration;										///< how long we need to look at the spot
+	float m_lookAtSpotTimestamp;									///< when we actually began looking at the spot
+	float m_lookAtSpotAngleTolerance;								///< how exactly we must look at the spot
+	bool m_lookAtSpotClearIfClose;									///< if true, the look at spot is cleared if it gets close to us
+	bool m_lookAtSpotAttack;										///< if true, the look at spot should be attacked
+	const char *m_lookAtDesc;										///< for debugging
+	void UpdateLookAt( void );
+	void UpdatePeripheralVision();									///< update enounter spot timestamps, etc
+	float m_peripheralTimestamp;
+
+	enum { MAX_APPROACH_POINTS = 16 };
+	struct ApproachPoint
+	{
+		Vector m_pos;
+		CNavArea *m_area;
+	};
+
+	ApproachPoint m_approachPoint[ MAX_APPROACH_POINTS ];
+	unsigned char m_approachPointCount;
+	Vector m_approachPointViewPosition;								///< the position used when computing current approachPoint set
+
+	CBaseEntity * FindEntitiesOnPath( float distance, CPushAwayEnumerator *enumerator, bool checkStuck );
+
+	IntervalTimer m_viewSteadyTimer;								///< how long has our view been "steady" (ie: not moving)
+
+	bool BendLineOfSight( const Vector &eye, const Vector &target, Vector *bend, float angleLimit = 135.0f ) const;		///< "bend" our line of sight until we can see the target point. Return bend point, false if cant bend.
+	bool FindApproachPointNearestPath( Vector *pos );				///< find the approach point that is nearest to our current path, ahead of us
+	bool FindGrenadeTossPathTarget( Vector *pos );					///< find spot to throw grenade ahead of us and "around the corner" along our path
+	enum GrenadeTossState
+	{
+		NOT_THROWING,				///< not yet throwing
+		START_THROW,				///< lining up throw
+		THROW_LINED_UP,				///< pause for a moment when on-line
+		FINISH_THROW,				///< throwing
+	};
+	GrenadeTossState m_grenadeTossState;
+	CountdownTimer m_tossGrenadeTimer;								///< timeout timer for grenade tossing
+	const CNavArea *m_initialEncounterArea;							///< area where we think we will initially encounter the enemy
+	void LookForGrenadeTargets( void );								///< look for grenade throw targets and throw our grenade at them
+	void UpdateGrenadeThrow( void );								///< process grenade throwing
+	CountdownTimer m_isAvoidingGrenade;								///< if nonzero we are in the act of avoiding a grenade
+
+
+	SpotEncounter *m_spotEncounter;									///< the spots we will encounter as we move thru our current area
+	float m_spotCheckTimestamp;										///< when to check next encounter spot
+
+	/// @todo Add timestamp for each possible client to hiding spots
+	enum { MAX_CHECKED_SPOTS = 64 };
+	struct HidingSpotCheckInfo
+	{
+		HidingSpot *spot;
+		float timestamp;
+	}
+	m_checkedHidingSpot[ MAX_CHECKED_SPOTS ];
+	int m_checkedHidingSpotCount;
+
+	//- view angle mechanism -----------------------------------------------------------------------------------------
+	float m_lookPitch;												///< our desired look pitch angle
+	float m_lookPitchVel;
+	float m_lookYaw;												///< our desired look yaw angle
+	float m_lookYawVel;
+
+	//- aim angle mechanism -----------------------------------------------------------------------------------------
+	Vector m_aimOffset;												///< current error added to victim's position to get actual aim spot
+	Vector m_aimOffsetGoal;											///< desired aim offset
+	float m_aimOffsetTimestamp;										///< time of next offset adjustment
+	float m_aimSpreadTimestamp;										///< time used to determine max spread as it begins to tighten up
+	void SetAimOffset( float accuracy );							///< set the current aim offset
+	void UpdateAimOffset( void );									///< wiggle aim error based on m_accuracy
+	Vector m_aimSpot;												///< the spot we are currently aiming to fire at
+
+	struct PartInfo
+	{
+		Vector m_headPos;											///< current head position
+		Vector m_gutPos;											///< current gut position
+		Vector m_feetPos;											///< current feet position
+		Vector m_leftSidePos;										///< current left side position
+		Vector m_rightSidePos;										///< current right side position
+		int m_validFrame;											///< frame of last computation (for lazy evaluation)
+	};
+	static PartInfo m_partInfo[ MAX_PLAYERS ];						///< part positions for each player
+	void ComputePartPositions( CCSPlayer *player );					///< compute part positions from bone location
+
+	//- attack state data --------------------------------------------------------------------------------------------
+	DispositionType m_disposition;									///< how we will react to enemies
+	CountdownTimer m_ignoreEnemiesTimer;							///< how long will we ignore enemies
+	mutable CHandle< CCSPlayer > m_enemy;							///< our current enemy
+	bool m_isEnemyVisible;											///< result of last visibility test on enemy
+	unsigned char m_visibleEnemyParts;								///< which parts of the visible enemy do we see
+	Vector m_lastEnemyPosition;										///< last place we saw the enemy
+	float m_lastSawEnemyTimestamp;
+	float m_firstSawEnemyTimestamp;
+	float m_currentEnemyAcquireTimestamp;
+	float m_enemyDeathTimestamp;									///< if m_enemy is dead, this is when he died
+	float m_friendDeathTimestamp;									///< time since we saw a friend die
+	bool m_isLastEnemyDead;											///< true if we killed or saw our last enemy die
+	int m_nearbyEnemyCount;											///< max number of enemies we've seen recently
+	unsigned int m_enemyPlace;										///< the location where we saw most of our enemies
+
+	struct WatchInfo
+	{
+		float timestamp;											///< time we last saw this player, zero if never seen
+		bool isEnemy;
+	}
+	m_watchInfo[ MAX_PLAYERS ];
+	mutable CHandle< CCSPlayer > m_bomber;							///< points to bomber if we can see him
+
+	int m_nearbyFriendCount;										///< number of nearby teammates
+	mutable CHandle< CCSPlayer > m_closestVisibleFriend;			///< the closest friend we can see
+	mutable CHandle< CCSPlayer > m_closestVisibleHumanFriend;		///< the closest human friend we can see
+
+	IntervalTimer m_attentionInterval;								///< time between attention checks
+
+	mutable CHandle< CCSPlayer > m_attacker;						///< last enemy that hurt us (may not be same as m_enemy)
+	float m_attackedTimestamp;										///< when we were hurt by the m_attacker
+
+	int m_lastVictimID;												///< the entindex of the last victim we killed, or zero
+	bool m_isAimingAtEnemy;											///< if true, we are trying to aim at our enemy
+	bool m_isRapidFiring;											///< if true, RunUpkeep() will toggle our primary attack as fast as it can
+	IntervalTimer m_equipTimer;										///< how long have we had our current weapon equipped
+	CountdownTimer m_zoomTimer;										///< for delaying firing immediately after zoom
+	bool DoEquip( CWeaponCSBase *gun );								///< equip the given item
+
+	void ReloadCheck( void );										///< reload our weapon if we must
+	void SilencerCheck( void );										///< use silencer
+
+	float m_fireWeaponTimestamp;
+
+	bool m_isEnemySniperVisible;									///< do we see an enemy sniper right now
+	CountdownTimer m_sawEnemySniperTimer;							///< tracking time since saw enemy sniper
+	
+	//- reaction time system -----------------------------------------------------------------------------------------
+	enum { MAX_ENEMY_QUEUE = 20 };
+	struct ReactionState
+	{
+		// NOTE: player position & orientation is not currently stored separately
+		CHandle<CCSPlayer> player;
+		bool isReloading;
+		bool isProtectedByShield;
+	}
+	m_enemyQueue[ MAX_ENEMY_QUEUE ];								///< round-robin queue for simulating reaction times
+	byte m_enemyQueueIndex;
+	byte m_enemyQueueCount;
+	byte m_enemyQueueAttendIndex;									///< index of the timeframe we are "conscious" of
+
+	CCSPlayer *FindMostDangerousThreat( void );						///< return most dangerous threat in my field of view (feeds into reaction time queue)
+
+
+	//- stuck detection ---------------------------------------------------------------------------------------------
+	bool m_isStuck;
+	float m_stuckTimestamp;											///< time when we got stuck
+	Vector m_stuckSpot;												///< the location where we became stuck
+	NavRelativeDirType m_wiggleDirection;
+	CountdownTimer m_wiggleTimer;
+	CountdownTimer m_stuckJumpTimer;								///< time for next jump when stuck
+
+	enum { MAX_VEL_SAMPLES = 10 };	
+	float m_avgVel[ MAX_VEL_SAMPLES ];
+	int m_avgVelIndex;
+	int m_avgVelCount;
+	Vector m_lastOrigin;
+
+	//- radio --------------------------------------------------------------------------------------------------------
+	RadioType m_lastRadioCommand;									///< last radio command we recieved
+	float m_lastRadioRecievedTimestamp;								///< time we recieved a radio message
+	float m_lastRadioSentTimestamp;									///< time when we send a radio message
+	CHandle< CCSPlayer > m_radioSubject;							///< who issued the radio message
+	Vector m_radioPosition;											///< position referred to in radio message
+	void RespondToRadioCommands( void );
+	bool IsRadioCommand( RadioType event ) const;					///< returns true if the radio message is an order to do something
+
+	/// new-style "voice" chatter gets voice feedback
+	float m_voiceEndTimestamp;
+
+	BotChatterInterface m_chatter;									///< chatter mechanism
+};
+
+
+//
+// Inlines
+//
+
+inline float CCSBot::GetFeetZ( void ) const
+{
+	return GetAbsOrigin().z;
+}
+
+inline const Vector *CCSBot::GetNoisePosition( void ) const
+{
+	if (m_noiseTimestamp > 0.0f)
+		return &m_noisePosition;
+
+	return NULL;
+}
+
+inline bool CCSBot::IsAwareOfEnemyDeath( void ) const
+{
+	if (GetEnemyDeathTimestamp() == 0.0f)
+		return false;
+
+	if (m_enemy == NULL)
+		return true;
+
+	if (!m_enemy->IsAlive() && gpGlobals->curtime - GetEnemyDeathTimestamp() > (1.0f - 0.8f * GetProfile()->GetSkill()))
+		return true;
+
+	return false;
+}
+
+inline void CCSBot::Panic( void )
+{
+	// we are stunned for a moment
+	Surprise( RandomFloat( 0.2f, 0.3f ) );
+
+	const float panicTime = 3.0f;
+	m_panicTimer.Start( panicTime );
+
+	const float panicRetreatRange = 300.0f;
+	TryToRetreat( panicRetreatRange, 0.0f );
+
+	PrintIfWatched( "*** PANIC ***\n" );
+}
+
+inline bool CCSBot::IsPanicking( void ) const
+{
+	return !m_panicTimer.IsElapsed();
+}
+
+inline void CCSBot::StopPanicking( void )
+{
+	m_panicTimer.Invalidate();
+}
+
+inline bool CCSBot::IsNotMoving( float minDuration ) const
+{
+	return (m_stillTimer.HasStarted() && m_stillTimer.GetElapsedTime() >= minDuration);
+}
+
+inline CWeaponCSBase *CCSBot::GetActiveCSWeapon( void ) const
+{
+	return reinterpret_cast<CWeaponCSBase *>( GetActiveWeapon() );
+}
+
+
+inline float CCSBot::GetCombatRange( void ) const
+{ 
+	return m_combatRange; 
+}
+
+inline void CCSBot::SetRogue( bool rogue )
+{ 
+	m_isRogue = rogue;
+}
+
+inline void CCSBot::Hurry( float duration )
+{ 
+	m_hurryTimer.Start( duration ); 
+}
+
+inline float CCSBot::GetSafeTime( void ) const
+{
+	return m_safeTime;
+}
+
+inline bool CCSBot::IsUnhealthy( void ) const
+{
+	return (GetHealth() <= 40);
+}
+
+inline bool CCSBot::IsAlert( void ) const
+{
+	return !m_alertTimer.IsElapsed();
+}
+
+inline void CCSBot::BecomeAlert( void )
+{
+	const float alertCooldownTime = 10.0f;
+	m_alertTimer.Start( alertCooldownTime );
+}
+
+inline bool CCSBot::IsSneaking( void ) const
+{
+	return !m_sneakTimer.IsElapsed();
+}
+
+inline void CCSBot::Sneak( float duration )
+{
+	m_sneakTimer.Start( duration );
+}
+
+inline bool CCSBot::IsFollowing( void ) const
+{ 
+	return m_isFollowing;
+}
+
+inline CCSPlayer *CCSBot::GetFollowLeader( void ) const
+{ 
+	return m_leader;
+}
+
+inline float CCSBot::GetFollowDuration( void ) const
+{
+	return gpGlobals->curtime - m_followTimestamp;
+}
+
+inline bool CCSBot::CanAutoFollow( void ) const
+{ 
+	return (gpGlobals->curtime > m_allowAutoFollowTime);
+}
+
+inline void CCSBot::AimAtEnemy( void )
+{ 
+	m_isAimingAtEnemy = true;
+}
+
+inline void CCSBot::StopAiming( void )
+{ 
+	m_isAimingAtEnemy = false;
+}
+
+inline bool CCSBot::IsAimingAtEnemy( void ) const
+{
+	return m_isAimingAtEnemy;
+}
+
+inline float CCSBot::GetStateTimestamp( void ) const
+{
+	return m_stateTimestamp;
+}
+
+inline CSGameState *CCSBot::GetGameState( void )
+{
+	return &m_gameState;
+}
+
+inline const CSGameState *CCSBot::GetGameState( void ) const
+{
+	return &m_gameState;
+}
+
+inline bool CCSBot::IsAtBombsite( void )
+{
+	return m_bInBombZone;
+}
+
+inline void CCSBot::SetTask( TaskType task, CBaseEntity *entity )
+{
+	m_task = task;
+	m_taskEntity = entity;
+}
+
+inline CCSBot::TaskType CCSBot::GetTask( void ) const
+{
+	return m_task;
+}
+
+inline CBaseEntity *CCSBot::GetTaskEntity( void )
+{
+	return static_cast<CBaseEntity *>( m_taskEntity );
+}
+
+inline CCSBot::MoraleType CCSBot::GetMorale( void ) const
+{
+	return m_morale;
+}
+
+inline void CCSBot::Surprise( float duration )
+{
+	m_surpriseTimer.Start( duration );
+}
+
+inline bool CCSBot::IsSurprised( void ) const
+{
+	return !m_surpriseTimer.IsElapsed();
+}
+
+inline CNavArea *CCSBot::GetNoiseArea( void ) const
+{
+	return m_noiseArea;
+}
+
+inline void CCSBot::ForgetNoise( void )
+{
+	m_noiseTimestamp = 0.0f;
+}
+
+inline float CCSBot::GetNoiseRange( void ) const
+{
+	if (IsNoiseHeard())
+		return m_noiseTravelDistance;
+
+	return 999999999.9f;
+}
+
+inline PriorityType CCSBot::GetNoisePriority( void ) const
+{ 
+	return m_noisePriority;
+}
+
+inline BotChatterInterface *CCSBot::GetChatter( void )
+{
+	return &m_chatter;
+}
+
+inline CCSPlayer *CCSBot::GetBotEnemy( void ) const
+{
+	return m_enemy;
+}
+
+inline int CCSBot::GetNearbyEnemyCount( void ) const
+{ 
+	return MIN( GetEnemiesRemaining(), m_nearbyEnemyCount );
+}
+
+inline unsigned int CCSBot::GetEnemyPlace( void ) const
+{
+	return m_enemyPlace;
+}
+
+inline bool CCSBot::CanSeeBomber( void ) const
+{
+	return (m_bomber == NULL) ? false : true;
+}
+
+inline CCSPlayer *CCSBot::GetBomber( void ) const
+{
+	return m_bomber;
+}
+
+inline int CCSBot::GetNearbyFriendCount( void ) const
+{
+	return MIN( GetFriendsRemaining(), m_nearbyFriendCount );
+}
+
+inline CCSPlayer *CCSBot::GetClosestVisibleFriend( void ) const
+{
+	return m_closestVisibleFriend;
+}
+
+inline CCSPlayer *CCSBot::GetClosestVisibleHumanFriend( void ) const
+{
+	return m_closestVisibleHumanFriend;
+}
+
+inline float CCSBot::GetTimeSinceAttacked( void ) const
+{
+	return gpGlobals->curtime - m_attackedTimestamp;
+}
+
+inline float CCSBot::GetFirstSawEnemyTimestamp( void ) const
+{
+	return m_firstSawEnemyTimestamp;
+}
+
+inline float CCSBot::GetLastSawEnemyTimestamp( void ) const
+{
+	return m_lastSawEnemyTimestamp;
+}
+
+inline float CCSBot::GetTimeSinceLastSawEnemy( void ) const
+{
+	return gpGlobals->curtime - m_lastSawEnemyTimestamp;
+}
+
+inline float CCSBot::GetTimeSinceAcquiredCurrentEnemy( void ) const
+{
+	return gpGlobals->curtime - m_currentEnemyAcquireTimestamp;
+}
+
+inline const Vector &CCSBot::GetLastKnownEnemyPosition( void ) const
+{
+	return m_lastEnemyPosition;
+}
+
+inline bool CCSBot::IsEnemyVisible( void ) const			
+{
+	return m_isEnemyVisible;
+}
+
+inline float CCSBot::GetEnemyDeathTimestamp( void ) const	
+{
+	return m_enemyDeathTimestamp;
+}
+
+inline int CCSBot::GetLastVictimID( void ) const
+{
+	return m_lastVictimID;
+}
+
+inline bool CCSBot::CanSeeSniper( void ) const
+{
+	return m_isEnemySniperVisible;
+}
+
+inline bool CCSBot::HasSeenSniperRecently( void ) const
+{
+	return !m_sawEnemySniperTimer.IsElapsed();
+}
+
+inline float CCSBot::GetTravelDistanceToPlayer( CCSPlayer *player ) const
+{
+	if (player == NULL)
+		return -1.0f;
+
+	if (!player->IsAlive())
+		return -1.0f;
+
+	return m_playerTravelDistance[ player->entindex() % MAX_PLAYERS ];
+}
+
+inline bool CCSBot::HasPath( void ) const
+{
+	return (m_pathLength) ? true : false;
+}
+
+inline void CCSBot::DestroyPath( void )		
+{
+	m_isStopping = false;
+	m_pathLength = 0;
+	m_pathLadder = NULL;
+}
+
+inline CNavArea *CCSBot::GetLastKnownArea( void ) const		
+{
+	return m_lastKnownArea;
+}
+
+inline const Vector &CCSBot::GetPathEndpoint( void ) const		
+{
+	return m_path[ m_pathLength-1 ].pos;
+}
+
+inline const Vector &CCSBot::GetPathPosition( int index ) const
+{
+	return m_path[ index ].pos;
+}
+
+inline bool CCSBot::IsUsingLadder( void ) const	
+{
+	return (m_pathLadder) ? true : false;
+}
+
+inline void CCSBot::SetGoalEntity( CBaseEntity *entity )	
+{
+	m_goalEntity = entity;
+}
+
+inline CBaseEntity *CCSBot::GetGoalEntity( void )
+{
+	return m_goalEntity;
+}
+
+inline void CCSBot::ForceRun( float duration )
+{
+	Run();
+	m_mustRunTimer.Start( duration );
+}
+
+inline void CCSBot::Wait( float duration )			
+{
+	m_waitTimer.Start( duration );
+}
+
+inline bool CCSBot::IsWaiting( void ) const		
+{
+	return !m_waitTimer.IsElapsed();
+}
+
+inline void CCSBot::StopWaiting( void )			
+{
+	m_waitTimer.Invalidate();
+}
+
+inline bool CCSBot::HasVisitedEnemySpawn( void ) const		
+{
+	return m_hasVisitedEnemySpawn;
+}
+
+inline const Vector &CCSBot::EyePositionConst( void ) const		
+{
+	return m_eyePosition;
+}
+	
+inline void CCSBot::SetLookAngles( float yaw, float pitch )
+{
+	m_lookYaw = yaw;
+	m_lookPitch = pitch;
+}
+
+inline void CCSBot::SetForwardAngle( float angle ) 
+{
+	m_forwardAngle = angle;
+}
+
+inline void CCSBot::SetLookAheadAngle( float angle ) 
+{
+	m_lookAheadAngle = angle;
+}
+
+inline void CCSBot::ClearLookAt( void )
+{ 
+	//PrintIfWatched( "ClearLookAt()\n" );
+	m_lookAtSpotState = NOT_LOOKING_AT_SPOT; 
+	m_lookAtDesc = NULL; 
+}
+
+inline bool CCSBot::IsLookingAtSpot( PriorityType pri ) const
+{ 
+	if (m_lookAtSpotState != NOT_LOOKING_AT_SPOT && m_lookAtSpotPriority >= pri)
+		return true;
+
+	return false;
+}
+
+inline bool CCSBot::IsViewMoving( float angleVelThreshold ) const
+{
+	if (m_lookYawVel < angleVelThreshold && m_lookYawVel > -angleVelThreshold &&
+		m_lookPitchVel < angleVelThreshold && m_lookPitchVel > -angleVelThreshold)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+inline bool CCSBot::HasViewBeenSteady( float duration ) const
+{
+	return (m_viewSteadyTimer.GetElapsedTime() > duration);
+}
+
+inline bool CCSBot::HasLookAtTarget( void ) const
+{
+	return (m_lookAtSpotState != NOT_LOOKING_AT_SPOT);
+}
+
+inline bool CCSBot::IsEnemyPartVisible( VisiblePartType part ) const
+{ 
+	VPROF_BUDGET( "CCSBot::IsEnemyPartVisible", VPROF_BUDGETGROUP_NPCS );
+
+	if (!IsEnemyVisible())
+		return false;
+
+	return (m_visibleEnemyParts & part) ? true : false;
+}
+
+inline bool CCSBot::IsSignificantlyCloser( const CCSPlayer *testPlayer, const CCSPlayer *referencePlayer ) const
+{
+	if ( !referencePlayer )
+		return true;
+
+	if ( !testPlayer )
+		return false;
+
+	float testDist = ( GetAbsOrigin() - testPlayer->GetAbsOrigin() ).Length();
+	float referenceDist = ( GetAbsOrigin() - referencePlayer->GetAbsOrigin() ).Length();
+
+	const float significantRangeFraction = 0.7f;
+	if ( testDist < referenceDist * significantRangeFraction )
+		return true;
+
+	return false;
+}
+
+inline void CCSBot::ClearApproachPoints( void )	
+{
+	m_approachPointCount = 0;
+}
+
+inline const CNavArea *CCSBot::GetInitialEncounterArea( void ) const
+{
+	return m_initialEncounterArea;
+}
+
+inline void CCSBot::SetInitialEncounterArea( const CNavArea *area )		
+{
+	m_initialEncounterArea = area;
+}
+
+inline bool CCSBot::IsThrowingGrenade( void ) const		
+{
+	return m_grenadeTossState != NOT_THROWING;
+}
+
+inline bool CCSBot::IsAvoidingGrenade( void ) const
+{
+	return !m_isAvoidingGrenade.IsElapsed();
+}
+
+inline void CCSBot::PrimaryAttack( void )
+{
+	if ( IsUsingPistol() && !CanActiveWeaponFire() )
+		return;
+
+	BaseClass::PrimaryAttack();
+}
+
+inline CCSBot::ZoomType CCSBot::GetZoomLevel( void )
+{
+	if (GetFOV() > 60.0f)
+		return NO_ZOOM;
+	if (GetFOV() > 25.0f)
+		return LOW_ZOOM;
+	return HIGH_ZOOM;
+}
+
+inline bool CCSBot::IsWaitingForZoom( void ) const		
+{
+	return !m_zoomTimer.IsElapsed();
+}
+
+inline int CCSBot::GetHostageEscortCount( void ) const		
+{
+	return m_hostageEscortCount;
+}
+
+inline void CCSBot::IncreaseHostageEscortCount( void )		
+{
+	++m_hostageEscortCount;
+}
+
+inline void CCSBot::ResetWaitForHostagePatience( void )
+{
+	m_isWaitingForHostage = false;
+	m_inhibitWaitingForHostageTimer.Invalidate();
+}
+
+
+inline bool CCSBot::IsUsingVoice() const
+{
+	return m_voiceEndTimestamp > gpGlobals->curtime; 
+}
+
+inline bool CCSBot::IsOpeningDoor( void ) const
+{
+	return m_isOpeningDoor;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if the given weapon is a sniper rifle
+ */
+inline bool IsSniperRifle( CWeaponCSBase *weapon )
+{
+	if (weapon == NULL)
+		return false;
+
+	return weapon->IsKindOf(WEAPONTYPE_SNIPER_RIFLE);
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Functor used with NavAreaBuildPath()
+ */
+class PathCost
+{
+public:
+	PathCost( CCSBot *bot, RouteType route = SAFEST_ROUTE )
+	{
+		m_bot = bot;
+		m_route = route;
+	}
+
+	// HPE_TODO[pmf]: check that these new parameters are okay to be ignored
+	float operator() ( CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder, const CFuncElevator *elevator, float length )
+	{
+		float baseDangerFactor = 100.0f;	// 100
+
+		// respond to the danger modulated by our aggression (even super-aggressives pay SOME attention to danger)
+		float dangerFactor = (1.0f - (0.95f * m_bot->GetProfile()->GetAggression())) * baseDangerFactor;
+
+		if (fromArea == NULL)
+		{
+			if (m_route == FASTEST_ROUTE)
+				return 0.0f;
+
+			// first area in path, cost is just danger
+			return dangerFactor * area->GetDanger( m_bot->GetTeamNumber() );
+		}
+		else if ((fromArea->GetAttributes() & NAV_MESH_JUMP) && (area->GetAttributes() & NAV_MESH_JUMP))
+		{
+			// cannot actually walk in jump areas - disallow moving from jump area to jump area
+			return -1.0f;
+		}
+		if ( area->GetAttributes() & NAV_MESH_NO_HOSTAGES && m_bot->GetHostageEscortCount() )
+		{
+			// if we're leading hostages, don't try to go where they can't
+			return -1.0f;
+		}
+		else
+		{
+			// compute distance from previous area to this area
+			float dist;
+			if (ladder)
+			{
+				// ladders are slow to use
+				const float ladderPenalty = 1.0f; // 3.0f;
+				dist = ladderPenalty * ladder->m_length;
+
+				// if we are currently escorting hostages, avoid ladders (hostages are confused by them)
+				//if (m_bot->GetHostageEscortCount())
+				//	dist *= 100.0f;
+			}
+			else
+			{
+				dist = (area->GetCenter() - fromArea->GetCenter()).Length();
+			}
+
+			// compute distance travelled along path so far
+			float cost = dist + fromArea->GetCostSoFar();
+
+			// zombies ignore all path penalties
+			if (cv_bot_zombie.GetBool())
+				return cost;
+
+			// add cost of "jump down" pain unless we're jumping into water
+			if (!area->IsUnderwater() && area->IsConnected( fromArea, NUM_DIRECTIONS ) == false)
+			{
+				// this is a "jump down" (one way drop) transition - estimate damage we will take to traverse it
+				float fallDistance = -fromArea->ComputeGroundHeightChange( area );
+
+				// if it's a drop-down ladder, estimate height from the bottom of the ladder to the lower area
+				if ( ladder && ladder->m_bottom.z < fromArea->GetCenter().z && ladder->m_bottom.z > area->GetCenter().z )
+				{
+					fallDistance = ladder->m_bottom.z - area->GetCenter().z;
+				}
+
+				float fallDamage = m_bot->GetApproximateFallDamage( fallDistance );
+
+				if (fallDamage > 0.0f)
+				{
+					// if the fall would kill us, don't use it
+					const float deathFallMargin = 10.0f;
+					if (fallDamage + deathFallMargin >= m_bot->GetHealth())
+						return -1.0f;
+
+					// if we need to get there in a hurry, ignore minor pain
+					const float painTolerance = 15.0f * m_bot->GetProfile()->GetAggression() + 10.0f;
+					if (m_route != FASTEST_ROUTE || fallDamage > painTolerance)
+					{
+						// cost is proportional to how much it hurts when we fall
+						// 10 points - not a big deal, 50 points - ouch!
+						cost += 100.0f * fallDamage * fallDamage;
+					}
+				}
+			}
+
+			// if this is a "crouch" or "walk" area, add penalty
+			if (area->GetAttributes() & (NAV_MESH_CROUCH | NAV_MESH_WALK))
+			{
+				// these areas are very slow to move through
+				float penalty = (m_route == FASTEST_ROUTE) ? 20.0f : 5.0f;
+
+				// avoid crouch areas if we are rescuing hostages 
+				if ((area->GetAttributes() & NAV_MESH_CROUCH) && m_bot->GetHostageEscortCount())
+				{
+					penalty *= 3.0f;
+				}
+
+				cost += penalty * dist;
+			}
+
+			// if this is a "jump" area, add penalty
+			if (area->GetAttributes() & NAV_MESH_JUMP)
+			{
+				// jumping can slow you down
+				//const float jumpPenalty = (m_route == FASTEST_ROUTE) ? 100.0f : 0.5f;
+				const float jumpPenalty = 1.0f;
+				cost += jumpPenalty * dist;
+			}
+
+			// if this is an area to avoid, add penalty
+			if (area->GetAttributes() & NAV_MESH_AVOID)
+			{
+				const float avoidPenalty = 20.0f;
+				cost += avoidPenalty * dist;
+			}
+
+			if (m_route == SAFEST_ROUTE)
+			{
+				// add in the danger of this path - danger is per unit length travelled
+				cost += dist * dangerFactor * area->GetDanger( m_bot->GetTeamNumber() );
+			}
+
+			if (!m_bot->IsAttacking())
+			{
+				// add in cost of teammates in the way
+
+				// approximate density of teammates based on area
+				float size = (area->GetSizeX() + area->GetSizeY())/2.0f;
+
+				// degenerate check
+				if (size >= 1.0f)
+				{
+					// cost is proportional to the density of teammates in this area
+					const float costPerFriendPerUnit = 50000.0f;
+					cost += costPerFriendPerUnit * (float)area->GetPlayerCount( m_bot->GetTeamNumber() ) / size;
+				}
+			}
+
+			return cost;
+		}
+	}
+
+private:
+	CCSBot *m_bot;
+	RouteType m_route;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+//
+// Prototypes
+//
+extern int GetBotFollowCount( CCSPlayer *leader );
+extern const Vector *FindNearbyRetreatSpot( CCSBot *me, float maxRange = 250.0f );
+extern const HidingSpot *FindInitialEncounterSpot( CBaseEntity *me, const Vector &searchOrigin, float enemyArriveTime, float maxRange, bool isSniper );
+
+
+#endif	// _CS_BOT_H_
+
diff --git a/game/server/cstrike/bot/cs_bot_chatter.cpp b/game/server/cstrike/bot/cs_bot_chatter.cpp
new file mode 100644
index 00000000..4d8b4dc1
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_chatter.cpp
@@ -0,0 +1,2582 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "cs_player.h"
+#include "shared_util.h"
+#include "engine/IEngineSound.h"
+#include "KeyValues.h"
+
+#include "bot.h"
+#include "bot_util.h"
+#include "cs_bot.h"
+#include "cs_bot_chatter.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+/**
+ * @todo Fix this
+ */
+const Vector *GetRandomSpotAtPlace( Place place )
+{
+	int count = 0;
+
+	FOR_EACH_VEC( TheNavAreas, it )
+	{
+		CNavArea *area = TheNavAreas[ it ];
+
+		if (area->GetPlace() == place)
+			++count;
+	}
+
+	if (count == 0)
+		return NULL;
+
+	int which = RandomInt( 0, count-1 );
+
+	FOR_EACH_VEC( TheNavAreas, rit )
+	{
+		CNavArea *area = TheNavAreas[ rit ];
+
+		if (area->GetPlace() == place && which == 0)
+			return &area->GetCenter();
+	}
+
+	return NULL;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Transmit meme to other bots
+ */
+void BotMeme::Transmit( CCSBot *sender ) const
+{
+	for( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+//		if (FNullEnt( player->pev ))
+//			continue;
+
+//		if (FStrEq( STRING( player->pev->netname ), "" ))
+//			continue;
+
+		// skip self
+		if (sender == player)
+			continue;
+
+		// ignore dead humans
+		if (!player->IsBot() && !player->IsAlive())
+			continue;
+
+		// ignore enemies, since we can't hear them talk
+		if (!player->InSameTeam( sender ))
+			continue;
+
+		// if not a bot, fail the test
+		if (!player->IsBot())
+			continue;
+
+		CCSBot *bot = dynamic_cast<CCSBot *>( player );
+
+		if ( !bot )
+			continue;
+
+		// allow bot to interpret our meme
+		Interpret( sender, bot );		
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate called for help - respond
+ */
+void BotHelpMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	const float maxHelpRange = 3000.0f;		// 2000
+	receiver->RespondToHelpRequest( sender, m_place, maxHelpRange );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate reported information about a bombsite
+ */
+void BotBombsiteStatusMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	// remember this bombsite's status
+	if (m_status == CLEAR)
+		receiver->GetGameState()->ClearBombsite( m_zoneIndex );
+	else
+		receiver->GetGameState()->MarkBombsiteAsPlanted( m_zoneIndex );
+
+	// if we were heading to the just-cleared bombsite, pick another one to search
+	// if our target bombsite wasn't cleared, will will continue going to it, 
+	// because GetNextBombsiteToSearch() will return the same zone (since its not cleared)
+	// if the bomb was planted, we will head to that bombsite
+	if (receiver->GetTask() == CCSBot::FIND_TICKING_BOMB)
+	{
+		receiver->Idle();
+		receiver->GetChatter()->Affirmative();
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate reported information about the bomb
+ */
+void BotBombStatusMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	// update our gamestate based on teammate's report
+	switch( m_state )
+	{
+		case CSGameState::MOVING:
+			receiver->GetGameState()->UpdateBomber( m_pos );
+
+			// if we are hunting and see no enemies, respond
+			if (!receiver->IsRogue() && receiver->IsHunting() && receiver->GetNearbyEnemyCount() == 0)
+				receiver->RespondToHelpRequest( sender, TheNavMesh->GetPlace( m_pos ) );
+
+			break;
+
+		case CSGameState::LOOSE:
+			receiver->GetGameState()->UpdateLooseBomb( m_pos );
+
+			if (receiver->GetTask() == CCSBot::GUARD_BOMB_ZONE)
+			{
+				receiver->Idle();
+				receiver->GetChatter()->Affirmative();		
+			}
+			break;
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate has asked that we follow him
+ */
+void BotFollowMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	if (receiver->IsRogue())
+		return;
+
+	// if we're busy, ignore
+	if (receiver->IsBusy())
+		return;
+
+	// if we are too far away, ignore
+	// compute actual travel distance
+	Vector senderOrigin = GetCentroid( sender );
+	PathCost cost( receiver );
+	float travelDistance = NavAreaTravelDistance( receiver->GetLastKnownArea(), 
+												  TheNavMesh->GetNearestNavArea( senderOrigin ),
+												  cost );
+	if (travelDistance < 0.0f)
+		return;
+
+	const float tooFar = 1000.0f;
+	if (travelDistance > tooFar)
+		return;
+
+	// begin following
+	receiver->Follow( sender );
+
+	// acknowledge
+	receiver->GetChatter()->Say( "CoveringFriend" );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate has asked us to defend a place
+ */
+void BotDefendHereMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	if (receiver->IsRogue())
+		return;
+
+	// if we're busy, ignore
+	if (receiver->IsBusy())
+		return;
+
+	Place place = TheNavMesh->GetPlace( m_pos );
+	if (place != UNDEFINED_PLACE)
+	{
+		// pick a random hiding spot in this place
+		const Vector *spot = FindRandomHidingSpot( receiver, place, receiver->IsSniper() );
+		if (spot)
+		{
+			receiver->SetTask( CCSBot::HOLD_POSITION );
+			receiver->Hide( *spot );
+			return;
+		}
+	}
+
+	// hide nearby
+	receiver->SetTask( CCSBot::HOLD_POSITION );
+	receiver->Hide( TheNavMesh->GetNearestNavArea( m_pos ) );
+
+	// acknowledge
+	receiver->GetChatter()->Say( "Affirmative" );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate has asked where the bomb is planted
+ */
+void BotWhereBombMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	int zone = receiver->GetGameState()->GetPlantedBombsite();
+
+	if (zone != CSGameState::UNKNOWN)
+		receiver->GetChatter()->FoundPlantedBomb( zone );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate has asked us to report in
+ */
+void BotRequestReportMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	receiver->GetChatter()->ReportingIn();
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate told us all the hostages are gone
+ */
+void BotAllHostagesGoneMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	receiver->GetGameState()->AllHostagesGone();
+
+	// acknowledge
+	receiver->GetChatter()->Say( "Affirmative" );
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate told us a CT is talking to a hostage
+ */
+void BotHostageBeingTakenMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	receiver->GetGameState()->HostageWasTaken();
+
+	// if we're busy, ignore
+	if (receiver->IsBusy())
+		return;
+
+	receiver->Idle();
+
+	// acknowledge
+	receiver->GetChatter()->Say( "Affirmative" );
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate heard a noise, so we shouldn't report noises for a while
+ */
+void BotHeardNoiseMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	receiver->GetChatter()->FriendHeardNoise();
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * A teammate warned about snipers, so we shouldn't warn again for awhile
+ */
+void BotWarnSniperMeme::Interpret( CCSBot *sender, CCSBot *receiver ) const
+{
+	receiver->GetChatter()->FriendSpottedSniper();
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+BotSpeakable::BotSpeakable()
+{
+	m_phrase = NULL;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+BotSpeakable::~BotSpeakable()
+{
+	if ( m_phrase )
+	{
+		delete[] m_phrase;
+		m_phrase = NULL;
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------------------
+
+BotPhrase::BotPhrase( bool isPlace )
+{
+	m_name = NULL;
+	m_place = UNDEFINED_PLACE;
+	m_isPlace = isPlace;
+	m_radioEvent = RADIO_INVALID;
+	m_isImportant = false;
+	ClearCriteria();
+	m_numVoiceBanks = 0;
+	InitVoiceBank( 0 );
+}
+
+BotPhrase::~BotPhrase()
+{
+	for( int bank=0; bank<m_voiceBank.Count(); ++bank )
+	{
+		for( int speakable=0; speakable<m_voiceBank[bank]->Count(); ++speakable )
+		{
+			delete (*m_voiceBank[bank])[speakable];
+		}
+		delete m_voiceBank[bank];
+	}
+
+	if ( m_name )
+		delete [] m_name;
+}
+
+void BotPhrase::InitVoiceBank( int bankIndex )
+{
+	while ( m_numVoiceBanks <= bankIndex )
+	{
+		m_count.AddToTail(0);
+		m_index.AddToTail(0);
+		m_voiceBank.AddToTail( new BotSpeakableVector );
+		++m_numVoiceBanks;
+	}
+}
+
+/**
+ * Return a random speakable - avoid repeating
+ */
+char *BotPhrase::GetSpeakable( int bankIndex, float *duration ) const
+{
+	if (bankIndex < 0 || bankIndex >= m_numVoiceBanks || m_count[bankIndex] == 0)
+	{
+		if (duration)
+			*duration = 0.0f;
+
+		return NULL;
+	}
+
+	// find phrase that meets the current criteria
+	int start = m_index[bankIndex];
+	while(true)
+	{
+		BotSpeakableVector *speakables = m_voiceBank[bankIndex];
+		int& index = m_index[bankIndex];
+		const BotSpeakable *speak = (*speakables)[index++];
+
+		if (m_index[bankIndex] >= m_count[bankIndex])
+			m_index[bankIndex] = 0;
+
+		// check place criteria
+		// if this speakable has a place criteria, it must match to be used
+		// speakables with Place of ANY will match any place
+		// speakables with a specific Place will only be used if Place matches
+		// speakables with Place of UNDEFINED only match Place of UNDEFINED
+		if (speak->m_place == ANY_PLACE || speak->m_place == m_placeCriteria)
+		{
+			// check count criteria
+			// if this speakable has a count criteria, it must match to be used
+			// if this speakable does not have a count criteria, we dont care what the count is set to
+			if (speak->m_count == UNDEFINED_COUNT || speak->m_count == MIN( m_countCriteria, COUNT_MANY ))
+			{
+				if (duration)
+					*duration = speak->m_duration;
+
+				return speak->m_phrase;
+			}
+		}
+
+		// check if we exhausted all speakables
+		if (m_index[bankIndex] == start)
+		{
+			if (duration)
+				*duration = 0.0f;
+
+			return NULL;
+		}
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Randomly shuffle the speakable order
+ */
+void BotPhrase::Randomize( void )
+{
+	for ( int bank = 0; bank < m_voiceBank.Count(); ++bank )
+	{
+		BotSpeakableVector *speakables = m_voiceBank[bank];
+		if ( speakables->Count() == 1 )
+			continue;
+
+		// A simple shuffle: for each array index, swap it with a random index
+		for ( int index = 0; index < speakables->Count(); ++index )
+		{
+			int newIndex = RandomInt( 0, speakables->Count()-1 );
+
+			BotSpeakable *speakable = (*speakables)[index];
+			(*speakables)[index] = (*speakables)[newIndex];
+			(*speakables)[newIndex] = speakable;
+		}
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------------------
+
+BotPhraseManager *TheBotPhrases = NULL;
+
+BotPhraseManager::BotPhraseManager( void )
+{
+	m_placeCount = 0;
+}
+
+
+/**
+ * Invoked when map changes
+ */
+void BotPhraseManager::OnMapChange( void )
+{
+	m_placeCount = 0;
+}
+
+/**
+ * Removes everything from memory
+ */
+void BotPhraseManager::Reset( void )
+{
+	int i;
+
+	// free phrase resources
+	for( i=0; i<m_list.Count(); ++i )
+	{
+		delete m_list[i];
+	}
+
+	for( i=0; i<m_placeList.Count(); ++i )
+	{
+		delete m_placeList[i];
+	}
+
+	m_list.RemoveAll();
+	m_placeList.RemoveAll();
+
+	m_painPhrase = NULL;
+	m_agreeWithPlanPhrase = NULL;
+}
+
+
+/**
+ * Invoked when the round resets 
+ */
+void BotPhraseManager::OnRoundRestart( void )
+{
+	// effectively reset all interval timers
+	m_placeCount = 0;
+
+	// shuffle all the speakables
+	int i;
+	for( i=0; i<m_placeList.Count(); ++i )
+		m_placeList[i]->Randomize();
+
+	for( i=0; i<m_list.Count(); ++i )
+		m_list[i]->Randomize();
+}
+
+BotChatterOutputType BotPhraseManager::GetOutputType( int voiceBank ) const
+{
+	if ( voiceBank >= 0 && voiceBank < m_output.Count() )
+	{
+		return m_output[voiceBank];
+	}
+	return BOT_CHATTER_RADIO;
+}
+
+/**
+ * Initialize phrase system from database file
+ */
+bool BotPhraseManager::Initialize( const char *filename, int bankIndex )
+{
+	bool isDefault = (bankIndex == 0);
+
+	FileHandle_t file = filesystem->Open( filename, "r" );
+	if (!file)
+	{
+		CONSOLE_ECHO( "WARNING: Cannot access bot phrase database '%s'\n", filename );
+		return false;
+	}
+
+	// BOTPORT: Redo file reading to avoid loading whole file into memory at once
+	int phraseDataLength = filesystem->Size( filename );
+	char *phraseDataFile = new char[ phraseDataLength ];
+		
+	int dataReadLength = filesystem->Read( phraseDataFile, phraseDataLength, file );	
+
+	filesystem->Close( file );
+
+	if ( dataReadLength > 0 )
+	{
+		// NULL-terminate based on the length read in, since Read() can transform \r\n to \n and
+		// return fewer bytes than we were expecting.
+		phraseDataFile[ dataReadLength - 1 ] = 0;
+	}
+
+	const char *phraseData = phraseDataFile;
+
+
+	const int RadioPathLen = 128; // wav filenames need to be shorter than this to go over the net anyway.
+	char baseDir[RadioPathLen] = "";
+	char compositeFilename[RadioPathLen];
+
+	//
+	// Parse the BotChatter.db into BotPhrase collections
+	//
+	while( true )
+	{
+		phraseData = SharedParse( phraseData );
+		if (!phraseData)
+			break;
+
+		char *token = SharedGetToken();
+
+		if ( !stricmp( token, "Output" ) )
+		{
+			// get name of this output device
+			phraseData = SharedParse( phraseData );
+			if (!phraseData)
+			{
+				CONSOLE_ECHO( "Error parsing '%s' - expected identifier\n", filename );
+				delete [] phraseDataFile;
+				return false;
+			}
+
+			while ( m_output.Count() <= bankIndex )
+			{
+				m_output.AddToTail(BOT_CHATTER_RADIO);
+			}
+
+			char *token = SharedGetToken();
+			if ( !stricmp( token, "Voice" ) )
+			{
+				m_output[bankIndex] = BOT_CHATTER_VOICE;
+			}
+		}
+		else if ( !stricmp( token, "BaseDir" ) )
+		{
+			// get name of this output device
+			phraseData = SharedParse( phraseData );
+			if (!phraseData)
+			{
+				CONSOLE_ECHO( "Error parsing '%s' - expected identifier\n", filename );
+				delete [] phraseDataFile;
+				return false;
+			}
+			char *token = SharedGetToken();
+			Q_strncpy( baseDir, token, RadioPathLen );
+			Q_strncat( baseDir, "\\", RadioPathLen, -1 );
+			baseDir[RadioPathLen-1] = 0;
+		}
+		else if (!stricmp( token, "Place" ) || !stricmp( token, "Chatter" ))
+		{
+			bool isPlace = (stricmp( token, "Place" )) ? false : true;
+
+			// encountered a new phrase collection
+			BotPhrase *phrase = NULL;
+			if ( isDefault )
+			{
+				phrase = new BotPhrase( isPlace );
+			}
+
+			// get name of this phrase
+			phraseData = SharedParse( phraseData );
+			if (!phraseData)
+			{
+				CONSOLE_ECHO( "Error parsing '%s' - expected identifier\n", filename );
+				delete [] phraseDataFile;
+				return false;
+			}
+			if ( isDefault )
+			{
+				phrase->m_name = CloneString( SharedGetToken() );
+
+				phrase->m_place = (isPlace) ? TheNavMesh->NameToPlace( phrase->m_name ) : UNDEFINED_PLACE;
+			}
+			else // look up the existing phrase
+			{
+				if ( isPlace )
+				{
+					phrase = const_cast<BotPhrase *>(GetPlace( SharedGetToken() ));
+				}
+				else
+				{
+					phrase = const_cast<BotPhrase *>(GetPhrase( SharedGetToken() ));
+				}
+
+				if ( !phrase )
+				{
+					CONSOLE_ECHO( "Error parsing '%s' - phrase '%s' is invalid\n", filename, SharedGetToken() );
+					delete [] phraseDataFile;
+					return false;
+				}
+			}
+			phrase->InitVoiceBank( bankIndex );
+
+			PlaceCriteria placeCriteria = ANY_PLACE;
+			CountCriteria countCriteria = UNDEFINED_COUNT;
+			RadioType radioEvent = RADIO_INVALID;
+			bool isImportant = false;
+
+			// read attributes of this phrase
+			while( true )
+			{
+				// get next token
+				phraseData = SharedParse( phraseData );
+				if (!phraseData)
+				{
+					CONSOLE_ECHO( "Error parsing %s - expected 'End'\n", filename );
+					delete [] phraseDataFile;
+					return false;
+				}
+				token = SharedGetToken();
+
+				// check for Place criteria
+				if (!stricmp( token, "Place" ))
+				{
+					phraseData = SharedParse( phraseData );
+					if (!phraseData)
+					{
+						CONSOLE_ECHO( "Error parsing %s - expected Place name\n", filename );
+						delete [] phraseDataFile;
+						return false;
+					}
+					token = SharedGetToken();
+
+					// update place criteria for subsequent speak lines
+					// NOTE: this assumes places must be first in the chatter database
+
+					// check for special identifiers
+					if (!stricmp( "ANY", token ))
+						placeCriteria = ANY_PLACE;
+					else if (!stricmp( "UNDEFINED", token ))
+						placeCriteria = UNDEFINED_PLACE;
+					else
+						placeCriteria = TheNavMesh->NameToPlace( token );
+
+					continue;
+				}
+
+				// check for Count criteria
+				if (!stricmp( token, "Count" ))
+				{
+					phraseData = SharedParse( phraseData );
+					if (!phraseData)
+					{
+						CONSOLE_ECHO( "Error parsing %s - expected Count value\n", filename );
+						delete [] phraseDataFile;
+						return false;
+					}
+					token = SharedGetToken();
+
+					// update count criteria for subsequent speak lines
+					if (!stricmp( token, "Many" ))
+						countCriteria = COUNT_MANY;
+					else 
+						countCriteria = atoi( token );
+
+					continue;
+				}
+
+				// check for radio equivalent
+				if (!stricmp( token, "Radio" ))
+				{
+					phraseData = SharedParse( phraseData );
+					if (!phraseData)
+					{
+						CONSOLE_ECHO( "Error parsing %s - expected radio event\n", filename );
+						delete [] phraseDataFile;
+						return false;
+					}
+					token = SharedGetToken();
+
+					RadioType event = NameToRadioEvent( token );
+					if (event <= RADIO_START_1 || event >= RADIO_END)
+					{
+						CONSOLE_ECHO( "Error parsing %s - invalid radio event '%s'\n", filename, token );
+						delete [] phraseDataFile;
+						return false;
+					}
+
+					radioEvent = event;
+
+					continue;
+				}
+
+				// check for "important" flag
+				if (!stricmp( token, "Important" ))
+				{
+					isImportant = true;
+					continue;
+				}
+
+				// check for End delimiter
+				if (!stricmp( token, "End" ))
+					break;
+
+				// found a phrase - add it to the collection
+				BotSpeakable *speak = new BotSpeakable;
+				if ( baseDir[0] )
+				{
+					Q_snprintf( compositeFilename, RadioPathLen, "%s%s", baseDir, token );
+					speak->m_phrase = CloneString( compositeFilename );
+				}
+				else
+				{
+					speak->m_phrase = CloneString( token );
+				}
+				speak->m_place = placeCriteria;
+				speak->m_count = countCriteria;
+#ifdef POSIX
+				Q_FixSlashes( speak->m_phrase );
+				Q_strlower( speak->m_phrase );
+#endif
+
+				speak->m_duration = enginesound->GetSoundDuration( speak->m_phrase );
+
+				if (speak->m_duration <= 0.0f)
+				{
+					if ( !engine->IsDedicatedServer() )
+					{
+						DevMsg( "Warning: Couldn't get duration of phrase '%s'\n", speak->m_phrase );
+					}
+					speak->m_duration = 1.0f;
+				}
+
+				BotSpeakableVector * speakables = phrase->m_voiceBank[ bankIndex ];
+				speakables->AddToTail( speak );
+
+				++phrase->m_count[ bankIndex ];
+			}
+
+			if ( isDefault )
+			{
+				phrase->m_radioEvent = radioEvent;
+				phrase->m_isImportant = isImportant;
+			}
+
+			// add phrase collection to the appropriate master list
+			if (isPlace)
+				m_placeList.AddToTail( phrase );
+			else
+				m_list.AddToTail( phrase );
+		}
+	}
+
+	delete [] phraseDataFile;
+
+	m_painPhrase = GetPhrase( "Pain" );
+	m_agreeWithPlanPhrase = GetPhrase( "AgreeWithPlan" );
+
+	return true;
+}
+
+BotPhraseManager::~BotPhraseManager()
+{
+	Reset();
+}
+
+/**
+ * Given a name, return the associated phrase collection
+ */
+const BotPhrase *BotPhraseManager::GetPhrase( const char *name ) const
+{
+	for( int i=0; i<m_list.Count(); ++i )
+	{
+		if (!stricmp( m_list[i]->m_name, name ))
+			return m_list[i]; 
+	}
+
+	//CONSOLE_ECHO( "GetPhrase: ERROR - Invalid phrase '%s'\n", name );
+	return NULL;
+}
+
+/**
+ * Given an id, return the associated phrase collection
+ * @todo Store phrases in a vector to make this fast
+ */
+/*
+const BotPhrase *BotPhraseManager::GetPhrase( unsigned int place ) const
+{
+	for( BotPhraseList::const_iterator iter = m_list.begin(); iter != m_list.end(); ++iter )
+	{
+		const BotPhrase *phrase = *iter;
+		if (phrase->m_place == id)
+			return phrase; 
+	}
+
+	CONSOLE_ECHO( "GetPhrase: ERROR - Invalid phrase id #%d\n", id );
+	return NULL;
+}
+*/
+
+/**
+ * Given a name, return the associated Place phrase collection
+ */
+const BotPhrase *BotPhraseManager::GetPlace( const char *name ) const
+{
+	if (name == NULL)
+		return NULL;
+
+	for( int i=0; i<m_placeList.Count(); ++i )
+	{
+		if (!stricmp( m_placeList[i]->m_name, name ))
+			return m_placeList[i];
+	}
+
+	return NULL;
+}
+
+/**
+ * Given a name, return the associated Place phrase collection
+ */
+const BotPhrase *BotPhraseManager::GetPlace( PlaceCriteria place ) const
+{
+	if (place == UNDEFINED_PLACE)
+		return NULL;
+
+	for( int i=0; i<m_placeList.Count(); ++i )
+	{
+		if (m_placeList[i]->m_place == place)
+			return m_placeList[i];
+	}
+
+	return NULL;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------------------
+
+BotStatement::BotStatement( BotChatterInterface *chatter, BotStatementType type, float expireDuration )
+{
+	m_chatter = chatter;
+
+	m_next = NULL;
+	m_prev = NULL;
+	m_timestamp = gpGlobals->curtime;
+	m_speakTimestamp = 0.0f;
+
+	m_type = type;
+	m_subject = UNDEFINED_SUBJECT;
+	m_place = UNDEFINED_PLACE;
+	m_meme = NULL;
+
+	m_startTime = gpGlobals->curtime;
+	m_expireTime = gpGlobals->curtime + expireDuration;
+	m_isSpeaking = false;
+
+	m_nextTime = 0.0f;
+	m_index = -1;
+	m_count = 0;
+
+	m_conditionCount = 0;
+}
+
+BotStatement::~BotStatement() 
+{
+	if (m_meme)
+		delete m_meme; 
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+CCSBot *BotStatement::GetOwner( void ) const
+{ 
+	return m_chatter->GetOwner(); 
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Attach a meme to this statement, to be transmitted to other friendly bots when spoken
+ */
+void BotStatement::AttachMeme( BotMeme *meme )
+{
+	m_meme = meme;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Add a conditions that must be true for the statement to be spoken
+ */
+void BotStatement::AddCondition( ConditionType condition )
+{
+	if (m_conditionCount < MAX_BOT_CONDITIONS)
+		m_condition[ m_conditionCount++ ] = condition;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this statement is "important" and not personality chatter
+ */
+bool BotStatement::IsImportant( void ) const
+{
+	// if a statement contains any important phrases, it is important
+	for( int i=0; i<m_count; ++i )
+	{
+		if (m_statement[i].isPhrase && m_statement[i].phrase->IsImportant())
+			return true;
+
+		// hack for now - phrases with enemy counts are important
+		if (!m_statement[i].isPhrase && m_statement[i].context == BotStatement::CURRENT_ENEMY_COUNT)
+			return true;
+	}
+
+	return false;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Verify all attached conditions 
+ */
+bool BotStatement::IsValid( void ) const
+{
+	for( int i=0; i<m_conditionCount; ++i )
+	{
+		switch( m_condition[i] )
+		{
+			case IS_IN_COMBAT:
+			{
+				if (!GetOwner()->IsAttacking())
+					return false;
+				break;
+			}
+
+/*
+			case RADIO_SILENCE:
+			{
+				if (GetOwner()->GetChatter()->GetRadioSilenceDuration() < 10.0f)
+					return false;
+				break;
+			}
+*/
+
+			case ENEMIES_REMAINING:
+			{
+				if (GetOwner()->GetEnemiesRemaining() == 0)
+					return false;
+				break;
+			}
+		}
+	}
+
+	return true;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this statement is essentially the same as the given one
+ */
+bool BotStatement::IsRedundant( const BotStatement *say ) const
+{
+	// special cases
+	if (GetType() == REPORT_MY_PLAN ||
+			GetType() == REPORT_REQUEST_HELP ||
+			GetType() == REPORT_CRITICAL_EVENT ||
+			GetType() == REPORT_ACKNOWLEDGE)
+		return false;
+
+	// check if topics are different
+	if (say->GetType() != GetType())
+		return false;
+
+	if (!say->HasPlace() && !HasPlace() && !say->HasSubject() && !HasSubject())
+	{
+		// neither has place or subject, so they are the same
+		return true;
+	}
+
+	// check if subject matter is the same
+	if (say->HasPlace() && HasPlace() && say->GetPlace() == GetPlace())
+	{
+		// talking about the same place
+		return true;
+	}
+
+	if (say->HasSubject() && HasSubject() && say->GetSubject() == GetSubject())
+	{
+		// talking about the same player
+		return true;
+	}
+
+	return false;
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this statement is no longer appropriate to say
+ */
+bool BotStatement::IsObsolete( void ) const
+{
+	// if the round is over, the only things we should say are emotes
+	if (GetOwner()->GetGameState()->IsRoundOver())
+	{
+		if (m_type != REPORT_EMOTE)
+			return true;
+	}
+
+	// If we're wanting to say "I lost him" but we've spotted another enemy,
+	// we no longer need to report losing someone.
+	if ( GetOwner()->GetChatter()->SeesAtLeastOneEnemy() && m_type == REPORT_ENEMY_LOST )
+	{
+		return true;
+	}
+
+	// check if statement lifetime has expired
+	return (gpGlobals->curtime > m_expireTime);
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Possibly change what were going to say base on what teammate is saying
+ */
+void BotStatement::Convert( const BotStatement *say )
+{
+	if (GetType() == REPORT_MY_PLAN && say->GetType() == REPORT_MY_PLAN)
+	{
+		const BotPhrase *meToo = TheBotPhrases->GetAgreeWithPlanPhrase();
+
+		// don't reconvert
+		if (m_statement[0].phrase == meToo)
+			return;
+
+		// if our plans are the same, change our statement to "me too"
+		if (m_statement[0].phrase == say->m_statement[0].phrase)
+		{
+			if (m_place == say->m_place)
+			{
+				// same plan at the same place - convert to "me too"
+				m_statement[0].phrase = meToo;
+				m_startTime = gpGlobals->curtime + RandomFloat( 0.5f, 1.0f );
+			}
+			else
+			{
+				// same plan at different place - wait a bit to allow others to respond "me too"
+				m_startTime = gpGlobals->curtime + RandomFloat( 3.0f, 4.0f );
+			}
+		}
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotStatement::AppendPhrase( const BotPhrase *phrase )
+{
+	if (phrase == NULL)
+		return;
+
+	if (m_count < MAX_BOT_PHRASES)
+	{
+		m_statement[ m_count ].isPhrase = true;
+		m_statement[ m_count++ ].phrase = phrase;
+	}
+}
+
+/**
+ * Special phrases that depend on the context
+ */
+void BotStatement::AppendPhrase( ContextType contextPhrase )
+{
+	if (m_count < MAX_BOT_PHRASES)
+	{
+		m_statement[ m_count ].isPhrase = false;
+		m_statement[ m_count++ ].context = contextPhrase;
+	}
+}
+
+/**
+ * Say our statement
+ * m_index refers to the phrase currently being spoken, or -1 if we havent started yet
+ */
+bool BotStatement::Update( void )
+{
+	CCSBot *me = GetOwner();
+
+	// if all of our teammates are dead, the only non-redundant statements are emotes
+	if (me->GetFriendsRemaining() == 0 && GetType() != REPORT_EMOTE)
+		return false;
+
+	if (!m_isSpeaking)
+	{
+		m_isSpeaking = true;
+		m_speakTimestamp = gpGlobals->curtime;
+	}
+
+	// special case - context dependent delay
+	if (m_index >= 0 && m_statement[ m_index ].context == ACCUMULATE_ENEMIES_DELAY)
+	{
+		// report if we see a lot of enemies, or if enough time has passed
+		const float reportTime = 2.0f;		// 1
+		if (me->GetNearbyEnemyCount() > 3 || gpGlobals->curtime - m_speakTimestamp > reportTime)
+		{
+			// enough enemies have accumulated to expire this delay
+			m_nextTime = 0.0f;
+		}
+	}
+
+
+	if (gpGlobals->curtime > m_nextTime)
+	{
+		// check for end of statement
+		if (++m_index == m_count)
+		{
+			// transmit any memes carried in this statement to our teammates
+			if (m_meme)
+				m_meme->Transmit( me );
+
+			return false;
+		}
+
+		// start next part of statement
+		float duration = 0.0f;
+		const BotPhrase *phrase = NULL;
+
+		if (m_statement[ m_index ].isPhrase)
+		{
+			// normal phrase
+			phrase = m_statement[ m_index ].phrase;
+		}
+		else
+		{
+			// context-dependant phrase
+			switch( m_statement[ m_index ].context )
+			{
+				case CURRENT_ENEMY_COUNT:
+				{
+					int enemyCount = me->GetNearbyEnemyCount();
+
+					// if we are outnumbered, ask for help
+					if (enemyCount-1 > me->GetNearbyFriendCount())
+					{
+						phrase = TheBotPhrases->GetPhrase( "Help" );
+						AttachMeme( new BotHelpMeme() );
+					}
+					else if (enemyCount > 1)
+					{
+						phrase = TheBotPhrases->GetPhrase( "EnemySpotted" );
+						phrase->SetCountCriteria( enemyCount );
+					}
+					break;
+				}
+
+				case REMAINING_ENEMY_COUNT:
+				{
+					static const char *speak[] = 
+					{
+						"NoEnemiesLeft", "OneEnemyLeft", "TwoEnemiesLeft", "ThreeEnemiesLeft"
+					};
+
+					int enemyCount = me->GetEnemiesRemaining();
+
+					// dont report if there are lots of enemies left
+					if (enemyCount < 0 || enemyCount > 3)
+					{
+						phrase = NULL;
+					}
+					else
+					{
+						phrase = TheBotPhrases->GetPhrase( speak[ enemyCount ] );
+					}
+					break;
+				}
+
+				case SHORT_DELAY:
+				{
+					m_nextTime = gpGlobals->curtime + RandomFloat( 0.1f, 0.5f );
+					return true;
+				}
+
+				case LONG_DELAY:
+				{
+					m_nextTime = gpGlobals->curtime + RandomFloat( 1.0f, 2.0f );
+					return true;
+				}
+
+				case ACCUMULATE_ENEMIES_DELAY:
+				{
+					// wait until test becomes true
+					m_nextTime = 99999999.9f;
+					return true;
+				}
+			}
+		}
+
+		if (phrase)
+		{
+			// if chatter system is in "standard radio" mode, send the equivalent radio command
+			if (me->GetChatter()->GetVerbosity() == BotChatterInterface::RADIO)
+			{
+				RadioType radioEvent = phrase->GetRadioEquivalent();
+				if (radioEvent == RADIO_INVALID)
+				{
+					// skip directly to the next phrase
+					m_nextTime = 0.0f;
+				}
+				else
+				{
+					// use the standard radio
+					me->GetChatter()->ResetRadioSilenceDuration();
+					me->SendRadioMessage( radioEvent );
+					duration = 2.0f;
+				}
+			}
+			else
+			{
+				// set place criteria
+				phrase->SetPlaceCriteria( m_place );
+
+				const char *filename = phrase->GetSpeakable( me->GetProfile()->GetVoiceBank(), &duration );
+				// CONSOLE_ECHO( "%s: Radio( '%s' )\n", STRING( me->pev->netname ), filename );
+
+				bool sayIt = true;
+
+				if (phrase->IsPlace())
+				{
+					// don't repeat the place if someone just mentioned it not too long ago
+					float timeSince = TheBotPhrases->GetPlaceStatementInterval( phrase->GetPlace() );
+					const float minRepeatTime = 20.0f;		// 30
+					if (timeSince < minRepeatTime)
+					{
+						sayIt = false;
+					}
+					else
+					{
+						TheBotPhrases->ResetPlaceStatementInterval( phrase->GetPlace() );
+					}
+				}
+
+				if (sayIt)
+				{
+					if ( !filename )
+					{
+						RadioType radioEvent = phrase->GetRadioEquivalent();
+						if (radioEvent == RADIO_INVALID)
+						{
+							// skip directly to the next phrase
+							m_nextTime = 0.0f;
+						}
+						else
+						{
+							// use the standard radio
+							me->SendRadioMessage( radioEvent );
+							me->GetChatter()->ResetRadioSilenceDuration();
+							duration = 2.0f;
+						}
+					}
+					/* BOTPORT: Wire up bot voice over IP
+					else if ( g_engfuncs.pfnPlayClientVoice && TheBotPhrases->GetOutputType( me->GetProfile()->GetVoiceBank() ) == BOT_CHATTER_VOICE )
+					{
+						me->GetChatter()->ResetRadioSilenceDuration();
+						g_engfuncs.pfnPlayClientVoice( me->entindex() - 1, filename );
+					}
+					*/
+					else
+					{
+						me->SpeakAudio( filename, duration + 1.0f, me->GetProfile()->GetVoicePitch() );
+					}
+				}
+			}
+
+			const float gap = 0.1f;
+			m_nextTime = gpGlobals->curtime + duration + gap;
+		}
+		else
+		{
+			// skip directly to the next phrase
+			m_nextTime = 0.0f;
+		}
+	}
+	
+	return true;
+}
+
+/**
+ * If this statement refers to a specific place, return that place
+ * Places can be implicit in the statement, or explicitly defined
+ */
+unsigned int BotStatement::GetPlace( void ) const
+{
+	// return any explicitly set place if we have one
+	if (m_place != UNDEFINED_PLACE)
+		return m_place;
+
+	// look for an implicit place in our statement
+	for( int i=0; i<m_count; ++i )
+		if (m_statement[i].isPhrase && m_statement[i].phrase->IsPlace())
+			return m_statement[i].phrase->GetPlace();
+	
+	return 0;
+}
+
+/**
+ * Return true if this statement has an associated count
+ */
+bool BotStatement::HasCount( void ) const
+{
+	for( int i=0; i<m_count; ++i )
+		if (!m_statement[i].isPhrase && m_statement[i].context == CURRENT_ENEMY_COUNT)
+			return true;
+
+	return false;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------------------
+
+CountdownTimer BotChatterInterface::m_encourageTimer;
+IntervalTimer BotChatterInterface::m_radioSilenceInterval[ 2 ];
+
+
+enum PitchHack 
+{ 
+	P_HI, 
+	P_NORMAL, 
+	P_LOW 
+};
+
+static int nextPitch = P_HI;
+
+BotChatterInterface::BotChatterInterface( CCSBot *me )
+{
+	m_me = me;
+	m_statementList = NULL;
+
+	switch( nextPitch )
+	{
+		case P_HI:
+			m_pitch = RandomInt( 105, 110 );
+			break;
+
+		case P_NORMAL:
+			m_pitch = RandomInt( 95, 105 );	
+			break;
+
+		case P_LOW:
+			m_pitch = RandomInt( 85, 95 );
+			break;
+	}
+
+	nextPitch = (nextPitch + 1) % 3;
+
+	Reset();
+}
+
+//---------------------------------------------------------------------------------------------------------------
+BotChatterInterface::~BotChatterInterface()
+{
+	// free pending statements
+	BotStatement *next;
+	for( BotStatement *msg = m_statementList; msg; msg = next )
+	{
+		next = msg->m_next;
+		delete msg;
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Reset to initial state
+ */
+void BotChatterInterface::Reset( void )
+{
+	BotStatement *msg, *nextMsg;
+
+	// removing pending statements - except for those about the round results
+	for( msg = m_statementList; msg; msg = nextMsg )
+	{
+		nextMsg = msg->m_next;
+
+		if (msg->GetType() != REPORT_ROUND_END)
+			RemoveStatement( msg );
+	}
+
+	m_seeAtLeastOneEnemy = false;
+	m_timeWhenSawFirstEnemy = 0.0f;
+	m_reportedEnemies = false;
+	m_requestedBombLocation = false;
+
+	ResetRadioSilenceDuration();
+
+	m_needBackupInterval.Invalidate();
+	m_spottedBomberInterval.Invalidate();
+	m_spottedLooseBombTimer.Invalidate();
+	m_heardNoiseTimer.Invalidate();
+	m_scaredInterval.Invalidate();
+	m_planInterval.Invalidate();
+	m_encourageTimer.Invalidate();
+	m_escortingHostageTimer.Invalidate();
+	m_warnSniperTimer.Invalidate();
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Register a statement for speaking
+ */
+void BotChatterInterface::AddStatement( BotStatement *statement, bool mustAdd )
+{
+	// don't add statements if bot chatter is shut off
+	if (GetVerbosity() == OFF)
+	{
+		delete statement;
+		return;	
+	}
+
+	// if we only want mission-critical radio chatter, ignore non-important phrases
+	if (GetVerbosity() == MINIMAL && !statement->IsImportant())
+	{
+		delete statement;
+		return;
+	}
+
+	// don't add statements if we're dead
+	if (!m_me->IsAlive() && !mustAdd)
+	{
+		delete statement;
+		return;
+	}
+
+	// don't add empty statements
+	if (statement->m_count == 0)
+	{
+		delete statement;
+		return;
+	}
+
+	// don't add statements that are redundant with something we're already waiting to say
+	BotStatement *s;
+	for( s=m_statementList; s; s = s->m_next )
+	{
+		if (statement->IsRedundant( s ))
+		{
+			m_me->PrintIfWatched( "I tried to say something I'm already saying.\n" );
+			delete statement;
+			return;
+		}
+	}
+
+	// keep statements in order of start time
+
+	// check list is empty
+	if (m_statementList == NULL)
+	{
+		statement->m_next = NULL;
+		statement->m_prev = NULL;
+		m_statementList = statement;
+		return;
+	}
+
+	// list has at least one statement on it
+
+	// insert into list in order
+	BotStatement *earlier = NULL;
+	for( s=m_statementList; s; s = s->m_next )
+	{
+		if (s->GetStartTime() > statement->GetStartTime())
+			break;
+
+		earlier = s;
+	}
+
+	// insert just after "earlier"
+	if (earlier)
+	{
+		if (earlier->m_next)
+			earlier->m_next->m_prev = statement;
+
+		statement->m_next = earlier->m_next;
+
+		earlier->m_next = statement;
+		statement->m_prev = earlier;
+	}
+	else
+	{
+		// insert at head
+		statement->m_prev = NULL;
+		statement->m_next = m_statementList;
+		m_statementList->m_prev = statement;
+		m_statementList = statement;
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Remove a statement
+ */
+void BotChatterInterface::RemoveStatement( BotStatement *statement )
+{
+	if (statement->m_next)
+		statement->m_next->m_prev = statement->m_prev;
+
+	if (statement->m_prev)
+		statement->m_prev->m_next = statement->m_next;
+	else
+		m_statementList = statement->m_next;
+
+	delete statement;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Track nearby enemy count and report enemy activity
+ */
+void BotChatterInterface::ReportEnemies( void )
+{
+	if (!m_me->IsAlive())
+		return;
+
+	if (m_me->GetNearbyEnemyCount() == 0)
+	{
+		m_seeAtLeastOneEnemy = false;
+		m_reportedEnemies = false;
+	}
+	else if (!m_seeAtLeastOneEnemy)
+	{
+		m_seeAtLeastOneEnemy = true;
+		m_timeWhenSawFirstEnemy = gpGlobals->curtime;
+	}
+
+	// determine whether we should report enemy activity
+	if (!m_reportedEnemies && m_seeAtLeastOneEnemy)
+	{
+		// request backup if we're outnumbered
+		if (m_me->IsOutnumbered() && NeedBackup())
+		{
+			m_reportedEnemies = true;
+			return;
+		}
+
+		m_me->GetChatter()->EnemySpotted();
+		m_reportedEnemies = true;
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when we die
+ */
+void BotChatterInterface::OnDeath( void )
+{
+	if (IsTalking())
+	{
+		if (m_me->GetChatter()->GetVerbosity() == BotChatterInterface::MINIMAL ||
+				m_me->GetChatter()->GetVerbosity() == BotChatterInterface::NORMAL)
+		{
+			// we've died mid-sentance - emit a gargle of pain
+			const BotPhrase *pain = TheBotPhrases->GetPainPhrase();
+			if (pain)
+			{
+				/*
+				if ( g_engfuncs.pfnPlayClientVoice && TheBotPhrases->GetOutputType( m_me->GetProfile()->GetVoiceBank() ) == BOT_CHATTER_VOICE )
+				{
+					g_engfuncs.pfnPlayClientVoice( m_me->entindex() - 1, pain->GetSpeakable(m_me->GetProfile()->GetVoiceBank()) );
+					m_me->GetChatter()->ResetRadioSilenceDuration();
+				}
+				else
+				*/
+				{
+					m_me->SpeakAudio( pain->GetSpeakable( m_me->GetProfile()->GetVoiceBank() ), 0.0f, m_me->GetProfile()->GetVoicePitch() );
+				}
+			}
+		}
+	}
+
+	// remove all of our statements
+	Reset();
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Process ongoing chatter for this bot
+ */
+void BotChatterInterface::Update( void )
+{
+	// report enemy activity
+	ReportEnemies();
+
+	// ask team to report in if we havent heard anything in awhile
+	if (ShouldSpeak())
+	{
+		const float longTime = 30.0f;
+		if (m_me->GetEnemiesRemaining() > 0 && GetRadioSilenceDuration() > longTime)
+		{
+			ReportIn();
+		}
+	}
+
+	// speak if it is our turn
+	BotStatement *say = GetActiveStatement();
+
+	if (say)
+	{
+		// if our statement is active, speak it
+		if (say->GetOwner() == m_me)
+		{
+			if (say->Update() == false)
+			{
+				// this statement is complete - destroy it
+				RemoveStatement( say );
+			}
+		}
+	}
+
+
+	//
+	// Process active statements.
+	// Removed expired statements, re-order statements according to their relavence and importance
+	// Remove redundant statements (ie: our teammates already said them)
+	//
+	const BotStatement *friendSay = GetActiveStatement();
+	if (friendSay && friendSay->GetOwner() == m_me)
+		friendSay = NULL;
+
+	BotStatement *nextSay;
+	for( say = m_statementList; say; say = nextSay )
+	{
+		nextSay = say->m_next;
+
+		// check statement conditions
+		if (!say->IsValid())
+		{
+			RemoveStatement( say );
+			continue;
+		}
+			
+		// don't interrupt ourselves
+		if (say->IsSpeaking())
+			continue;
+
+		// check for obsolete statements
+		if (say->IsObsolete())
+		{
+			m_me->PrintIfWatched( "Statement obsolete - removing.\n" );
+			RemoveStatement( say );
+			continue;
+		}
+
+		// if a teammate is saying what we were going to say, dont repeat it
+		if (friendSay)
+		{
+			// convert what we're about to say based on what our teammate is currently saying
+			say->Convert( friendSay );
+
+			// don't say things our teammates have just said
+			if (say->IsRedundant( friendSay ))
+			{
+				// thie statement is redundant - destroy it
+				//m_me->PrintIfWatched( "Teammate said what I was going to say - shutting up.\n" );
+				m_me->PrintIfWatched( "Teammate said what I was going to say - shutting up.\n" );
+				RemoveStatement( say );
+			}
+		}
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Returns the statement that is being spoken, or is next to be spoken if no-one is speaking now
+ */
+BotStatement *BotChatterInterface::GetActiveStatement( void )
+{
+	// keep track of statement waiting longest to be spoken - it is next
+	BotStatement *earliest = NULL;
+	float earlyTime = 999999999.9f;
+
+	for( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		// ignore dead humans
+		if (!player->IsBot() && !player->IsAlive())
+			continue;
+
+		// ignore enemies, since we can't hear them talk
+		if (!m_me->InSameTeam( player ))
+			continue;
+
+		CCSBot *bot = dynamic_cast<CCSBot *>(player);
+
+		// if not a bot, fail the test
+		/// @todo Check if human is currently talking
+		if (!bot)
+			continue;
+
+		for( BotStatement *say = bot->GetChatter()->m_statementList; say; say = say->m_next )
+		{
+			// if this statement is currently being spoken, return it		
+			if (say->IsSpeaking())
+				return say;
+
+			// keep track of statement that has been waiting longest to be spoken of anyone on our team
+			if (say->GetStartTime() < earlyTime)
+			{
+				earlyTime = say->GetTimestamp();
+				earliest = say;
+			}
+		}
+	}
+
+	// make sure it is time to start this statement
+	if (earliest && earliest->GetStartTime() > gpGlobals->curtime)
+		return NULL;
+
+	return earliest;
+}
+
+/**
+ * Return true if we speaking makes sense now
+ */
+bool BotChatterInterface::ShouldSpeak( void ) const
+{
+	// don't talk to non-existent friends
+	if (m_me->GetFriendsRemaining() == 0)
+		return false;
+
+	// if everyone is together, no need to tell them what's going on
+	if (m_me->GetNearbyFriendCount() == m_me->GetFriendsRemaining())
+		return false;
+
+	return true;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+float BotChatterInterface::GetRadioSilenceDuration( void )
+{
+	return m_radioSilenceInterval[ m_me->GetTeamNumber() % 2 ].GetElapsedTime();
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::ResetRadioSilenceDuration( void )
+{
+	m_radioSilenceInterval[ m_me->GetTeamNumber() % 2 ].Reset(); 
+}
+
+
+
+//---------------------------------------------------------------------------------------------------------------
+inline const BotPhrase *GetPlacePhrase( CCSBot *me )
+{
+	Place place = me->GetPlace();
+	if (place != UNDEFINED_PLACE)
+		return TheBotPhrases->GetPlace( place );
+
+	return NULL;
+}
+
+
+inline void SayWhere( BotStatement *say, Place place )
+{
+	say->AppendPhrase( TheBotPhrases->GetPlace( place ) );
+}
+
+/**
+ * Report enemy sightings
+ */
+void BotChatterInterface::EnemySpotted( void )
+{
+	// NOTE: This could be a few seconds out of date (enemy is in an adjacent place)
+	Place place = m_me->GetEnemyPlace();
+
+	BotStatement *say = new BotStatement( this, REPORT_VISIBLE_ENEMIES, 10.0f );
+
+	// where are the enemies
+	say->AppendPhrase( TheBotPhrases->GetPlace( place ) );
+
+	// how many are there
+	say->AppendPhrase( BotStatement::ACCUMULATE_ENEMIES_DELAY );
+	say->AppendPhrase( BotStatement::CURRENT_ENEMY_COUNT );
+	say->AddCondition( BotStatement::IS_IN_COMBAT );
+
+	AddStatement( say );
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * If a friend warned of snipers, don't warn again for awhile
+ */
+void BotChatterInterface::FriendSpottedSniper( void )
+{
+	m_warnSniperTimer.Start( 60.0f );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Warn of an enemy sniper
+ */
+void BotChatterInterface::SpottedSniper( void )
+{
+	if (!m_warnSniperTimer.IsElapsed())
+	{
+		return;
+	}
+
+	if (m_me->GetFriendsRemaining() == 0)
+	{
+		// no-one to warn
+		return;
+	}
+
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 10.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "SniperWarning" ) );
+	say->AttachMeme( new BotWarnSniperMeme() );
+
+	AddStatement( say );
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::Clear( Place place )
+{
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 10.0f );
+
+	SayWhere( say, place );
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "Clear" ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Request enemy activity report
+ */
+void BotChatterInterface::ReportIn( void )
+{
+	BotStatement *say = new BotStatement( this, REPORT_REQUEST_INFORMATION, 10.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "RequestReport" ) );
+	say->AddCondition( BotStatement::RADIO_SILENCE );
+	say->AttachMeme( new BotRequestReportMeme() );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * Report our situtation
+ */
+void BotChatterInterface::ReportingIn( void )
+{
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 10.0f );
+
+	// where are we
+	Place place = m_me->GetPlace();
+	SayWhere( say, place );
+
+	// what are we doing
+	switch( m_me->GetTask() )
+	{
+		case CCSBot::PLANT_BOMB:
+		{
+			m_me->GetChatter()->GoingToPlantTheBomb( UNDEFINED_PLACE );
+			break;
+		}
+
+		case CCSBot::DEFUSE_BOMB:
+		{
+			m_me->GetChatter()->Say( "DefusingBomb" );
+			break;
+		}
+
+		case CCSBot::GUARD_LOOSE_BOMB:
+		{
+			if (TheCSBots()->GetLooseBomb())
+			{
+				say->AppendPhrase( TheBotPhrases->GetPhrase( "GuardingLooseBomb" ) );
+				say->AttachMeme( new BotBombStatusMeme( CSGameState::LOOSE, TheCSBots()->GetLooseBomb()->GetAbsOrigin() ) );
+			}
+			break;
+		}
+
+		case CCSBot::GUARD_HOSTAGES:
+		{
+			m_me->GetChatter()->GuardingHostages( UNDEFINED_PLACE, !m_me->IsAtHidingSpot() );
+			break;
+		}
+
+		case CCSBot::GUARD_HOSTAGE_RESCUE_ZONE:
+		{
+			m_me->GetChatter()->GuardingHostageEscapeZone( !m_me->IsAtHidingSpot() );
+			break;
+		}
+
+		case CCSBot::COLLECT_HOSTAGES:
+		{
+			break;
+		}
+
+		case CCSBot::RESCUE_HOSTAGES:
+		{
+			m_me->GetChatter()->EscortingHostages();
+			break;
+		}
+
+		case CCSBot::GUARD_VIP_ESCAPE_ZONE:
+		{
+			break;
+		}
+
+	}
+
+
+	// what do we see
+	if (m_me->IsAttacking())
+	{
+		if (m_me->IsOutnumbered())
+		{
+			// in trouble in a firefight
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "Help" ) );
+			say->AttachMeme( new BotHelpMeme( place ) );
+		}
+		else
+		{
+			// battling enemies
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "InCombat" ) );
+		}
+	}
+	else
+	{
+		// not in combat, start our report a little later
+		say->SetStartTime( gpGlobals->curtime + 2.0f );
+
+		const float recentTime = 10.0f;
+		if (m_me->GetEnemyDeathTimestamp() < recentTime && m_me->GetEnemyDeathTimestamp() >= m_me->GetTimeSinceLastSawEnemy() + 0.5f)
+		{
+			// recently saw an enemy die
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "EnemyDown" ) );
+		}
+		else if (m_me->GetTimeSinceLastSawEnemy() < recentTime)
+		{
+			// recently saw an enemy
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "EnemySpotted" ) );
+		}
+		else
+		{
+			// haven't seen enemies
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "Clear" ) );
+		}
+	}
+	
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+bool BotChatterInterface::NeedBackup( void )
+{
+	const float minRequestInterval = 10.0f;
+	if (m_needBackupInterval.IsLessThen( minRequestInterval ))
+		return false;
+
+	m_needBackupInterval.Reset();
+
+	if (m_me->GetFriendsRemaining() == 0)
+	{
+		// we're all alone...
+		Scared();
+		return true;
+	}
+	else
+	{
+		// ask friends for help
+		BotStatement *say = new BotStatement( this, REPORT_REQUEST_HELP, 10.0f );
+
+		// where are we
+		Place place = m_me->GetPlace();
+		SayWhere( say, place );
+
+		say->AppendPhrase( TheBotPhrases->GetPhrase( "Help" ) );
+		say->AttachMeme( new BotHelpMeme( place ) );
+
+		AddStatement( say );
+	}
+
+	return true;
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::PinnedDown( void )
+{
+	// this is a form of "need backup"
+	const float minRequestInterval = 10.0f;
+	if (m_needBackupInterval.IsLessThen( minRequestInterval ))
+		return;
+
+	m_needBackupInterval.Reset();
+
+	BotStatement *say = new BotStatement( this, REPORT_REQUEST_HELP, 10.0f );
+
+	// where are we
+	Place place = m_me->GetPlace();
+	SayWhere( say, place );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "PinnedDown" ) );
+	say->AttachMeme( new BotHelpMeme( place ) );
+	say->AddCondition( BotStatement::IS_IN_COMBAT );
+
+	AddStatement( say );
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+/**
+ * If a friend said that they heard something, we don't want to say something similar
+ * for a while.
+ */
+void BotChatterInterface::FriendHeardNoise( void )
+{
+	m_heardNoiseTimer.Start( 20.0f );
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::HeardNoise( const Vector &pos )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	if (m_heardNoiseTimer.IsElapsed())
+	{
+		// throttle frequency
+		m_heardNoiseTimer.Start( 20.0f );
+
+		// make rare, since many teammates may try to say this
+		if (RandomFloat( 0, 100 ) < 33)
+		{
+			BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 5.0f );
+
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "HeardNoise" ) );
+			say->SetPlace( TheNavMesh->GetPlace( pos ) );
+			say->AttachMeme( new BotHeardNoiseMeme() );
+
+			AddStatement( say );
+		}
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::KilledMyEnemy( int victimID )
+{
+	// only report if we killed the last enemy in the area
+	if (m_me->GetNearbyEnemyCount() <= 1)
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_ENEMY_ACTION, 3.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "KilledMyEnemy" ) );
+	say->SetSubject( victimID );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::EnemiesRemaining( void )
+{
+	// only report if we killed the last enemy in the area
+	if (m_me->GetNearbyEnemyCount() > 1)
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_ENEMIES_REMAINING, 5.0f );
+	say->AppendPhrase( BotStatement::REMAINING_ENEMY_COUNT );
+	say->SetStartTime( gpGlobals->curtime + RandomFloat( 2.0f, 4.0f ) );
+
+	AddStatement( say );
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::Affirmative( void )
+{
+	BotStatement *say = new BotStatement( this, REPORT_ACKNOWLEDGE, 3.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "Affirmative" ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::Negative( void )
+{
+	BotStatement *say = new BotStatement( this, REPORT_ACKNOWLEDGE, 3.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "Negative" ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::GoingToPlantTheBomb( Place place )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	const float minInterval = 20.0f;
+	if (m_planInterval.IsLessThen( minInterval ))
+		return;
+
+	m_planInterval.Reset();
+
+	BotStatement *say = new BotStatement( this, REPORT_CRITICAL_EVENT, 10.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "GoingToPlantBomb" ) );
+	say->SetPlace( place );
+	say->AttachMeme( new BotFollowMeme() );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::PlantingTheBomb( Place place )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_CRITICAL_EVENT, 10.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "PlantingBomb" ) );
+	say->SetPlace( place );
+
+	Vector myOrigin = GetCentroid( m_me );
+	say->AttachMeme( new BotDefendHereMeme( myOrigin ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::TheyPickedUpTheBomb( void )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	// if we already know the bomb is not loose, this is old news
+	if (!m_me->GetGameState()->IsBombLoose())
+		return;
+
+	// update our gamestate - use our own position for now
+	const Vector &myOrigin = GetCentroid( m_me );
+	m_me->GetGameState()->UpdateBomber( myOrigin );
+
+	// tell our teammates
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 10.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "TheyPickedUpTheBomb" ) );
+
+	say->AttachMeme( new BotBombStatusMeme( CSGameState::MOVING, myOrigin ) ); 
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::SpottedBomber( CBasePlayer *bomber )
+{
+	const Vector &bomberOrigin = GetCentroid( bomber );
+
+	if (m_me->GetGameState()->IsBombMoving())
+	{
+		// if we knew where the bomber was, this is old news
+		const Vector *bomberPos = m_me->GetGameState()->GetBombPosition();
+		const float closeRangeSq = 1000.0f * 1000.0f;
+		if (bomberPos && (bomberOrigin - *bomberPos).LengthSqr() < closeRangeSq)
+			return;
+	}
+
+	// update our gamestate
+	m_me->GetGameState()->UpdateBomber( bomberOrigin );
+
+	// tell our teammates
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 10.0f );
+
+	// where is the bomber
+	Place place = TheNavMesh->GetPlace( bomberOrigin );
+	SayWhere( say, place );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "SpottedBomber" ) );
+
+	say->SetSubject( bomber->entindex() );
+
+	//say->AttachMeme( new BotHelpMeme( place ) );
+	say->AttachMeme( new BotBombStatusMeme( CSGameState::MOVING, bomberOrigin ) ); 
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::SpottedLooseBomb( CBaseEntity *bomb )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	// if we already know the bomb is loose, this is old news
+	if (m_me->GetGameState()->IsBombLoose())
+		return;
+
+	// update our gamestate
+	m_me->GetGameState()->UpdateLooseBomb( bomb->GetAbsOrigin() );
+
+	if (m_spottedLooseBombTimer.IsElapsed())
+	{
+		// throttle frequency 
+		m_spottedLooseBombTimer.Start( 10.0f );
+
+		// tell our teammates
+		BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 10.0f );
+
+		// where is the bomb
+		Place place = TheNavMesh->GetPlace( bomb->GetAbsOrigin() );
+		SayWhere( say, place );
+
+		say->AppendPhrase( TheBotPhrases->GetPhrase( "SpottedLooseBomb" ) );
+
+		if (TheCSBots()->GetLooseBomb())
+			say->AttachMeme( new BotBombStatusMeme( CSGameState::LOOSE, bomb->GetAbsOrigin() ) );
+
+		AddStatement( say );
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::GuardingLooseBomb( CBaseEntity *bomb )
+{
+	// if we already know the bomb is loose, this is old news
+//	if (m_me->GetGameState()->IsBombLoose())
+//		return;
+
+	if (TheCSBots()->IsRoundOver() || !bomb)
+		return;
+
+	const float minInterval = 20.0f;
+	if (m_planInterval.IsLessThen( minInterval ))
+		return;
+
+	m_planInterval.Reset();
+
+	// update our gamestate
+	m_me->GetGameState()->UpdateLooseBomb( bomb->GetAbsOrigin() );
+
+	// tell our teammates
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 10.0f );
+
+	// where is the bomb
+	Place place = TheNavMesh->GetPlace( bomb->GetAbsOrigin() );
+	SayWhere( say, place );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "GuardingLooseBomb" ) );
+
+	if (TheCSBots()->GetLooseBomb())
+		say->AttachMeme( new BotBombStatusMeme( CSGameState::LOOSE, bomb->GetAbsOrigin() ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::RequestBombLocation( void )
+{
+	// only ask once per round
+	if (m_requestedBombLocation)
+		return;
+
+	m_requestedBombLocation = true;
+
+	// tell our teammates
+	BotStatement *say = new BotStatement( this, REPORT_REQUEST_INFORMATION, 10.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "WhereIsTheBomb" ) );
+
+	say->AttachMeme( new BotWhereBombMeme() );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::BombsiteClear( int zoneIndex )
+{
+	const CCSBotManager::Zone *zone = TheCSBots()->GetZone( zoneIndex );
+	if (zone == NULL)
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 10.0f );
+
+	SayWhere( say, TheNavMesh->GetPlace( zone->m_center ) );
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "BombsiteClear" ) );
+
+	say->AttachMeme( new BotBombsiteStatusMeme( zoneIndex, BotBombsiteStatusMeme::CLEAR ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::FoundPlantedBomb( int zoneIndex )
+{
+	const CCSBotManager::Zone *zone = TheCSBots()->GetZone( zoneIndex );
+	if (zone == NULL)
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 3.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "PlantedBombPlace" ) );
+	say->SetPlace( TheNavMesh->GetPlace( zone->m_center ) );
+
+	say->AttachMeme( new BotBombsiteStatusMeme( zoneIndex, BotBombsiteStatusMeme::PLANTED ) );
+
+	AddStatement( say );
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::Scared( void )
+{
+	const float minInterval = 10.0f;
+	if (m_scaredInterval.IsLessThen( minInterval ))
+		return;
+
+	m_scaredInterval.Reset();
+
+	BotStatement *say = new BotStatement( this, REPORT_EMOTE, 1.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "ScaredEmote" ) );
+	say->AddCondition( BotStatement::IS_IN_COMBAT );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::CelebrateWin( void )
+{
+	BotStatement *say = new BotStatement( this, REPORT_EMOTE, 15.0f );
+
+	// wait a bit before speaking
+	say->SetStartTime( gpGlobals->curtime + RandomFloat( 2.0f, 5.0f ) );
+
+	const float quickRound = 45.0f;
+
+	if (m_me->GetFriendsRemaining() == 0)
+	{
+		// we were the last man standing
+		if (TheCSBots()->GetElapsedRoundTime() < quickRound)
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "WonRoundQuickly" ) );
+		else if (RandomFloat( 0.0f, 100.0f ) < 33.3f)
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "LastManStanding" ) );
+	}
+	else
+	{
+		if (TheCSBots()->GetElapsedRoundTime() < quickRound)
+		{
+			if (RandomFloat( 0.0f, 100.0f ) < 33.3f)
+				say->AppendPhrase( TheBotPhrases->GetPhrase( "WonRoundQuickly" ) );
+		}
+		else if (RandomFloat( 0.0f, 100.0f ) < 10.0f)
+		{
+			say->AppendPhrase( TheBotPhrases->GetPhrase( "WonRound" ) );
+		}
+	}
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::AnnouncePlan( const char *phraseName, Place place )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_MY_PLAN, 10.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( phraseName ) );
+	say->SetPlace( place );
+
+	// wait at least a short time after round start
+	say->SetStartTime( TheCSBots()->GetRoundStartTime() + RandomFloat( 2.0, 3.0f ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::GuardingBombsite( Place place )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	const float minInterval = 20.0f;
+	if (m_planInterval.IsLessThen( minInterval ))
+		return;
+
+	m_planInterval.Reset();
+
+	AnnouncePlan( "GoingToDefendBombsite", place );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::GuardingHostages( Place place, bool isPlan )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	const float minInterval = 20.0f;
+	if (m_planInterval.IsLessThen( minInterval ))
+		return;
+
+	m_planInterval.Reset();
+
+	if (isPlan)
+		AnnouncePlan( "GoingToGuardHostages", place );
+	else
+		Say( "GuardingHostages" );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::GuardingHostageEscapeZone( bool isPlan )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	const float minInterval = 20.0f;
+	if (m_planInterval.IsLessThen( minInterval ))
+		return;
+
+	m_planInterval.Reset();
+
+	if (isPlan)
+		AnnouncePlan( "GoingToGuardHostageEscapeZone", UNDEFINED_PLACE );
+	else
+		Say( "GuardingHostageEscapeZone" );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::HostagesBeingTaken( void )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 3.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "HostagesBeingTaken" ) );
+	say->AttachMeme( new BotHostageBeingTakenMeme() );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::HostagesTaken( void )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 3.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "HostagesTaken" ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::TalkingToHostages( void )
+{
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::EscortingHostages( void )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	if (m_escortingHostageTimer.IsElapsed())
+	{
+		// throttle frequency
+		m_escortingHostageTimer.Start( 10.0f );
+
+		BotStatement *say = new BotStatement( this, REPORT_MY_PLAN, 5.0f );
+
+		say->AppendPhrase( TheBotPhrases->GetPhrase( "EscortingHostages" ) );
+
+		AddStatement( say );
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::HostageDown( void )
+{
+	if (TheCSBots()->IsRoundOver())
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_INFORMATION, 3.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "HostageDown" ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::Encourage( const char *phraseName, float repeatInterval, float lifetime )
+{
+	if (m_encourageTimer.IsElapsed())
+	{
+		Say( phraseName, lifetime );
+		m_encourageTimer.Start( repeatInterval );
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::KilledFriend( void )
+{
+	BotStatement *say = new BotStatement( this, REPORT_KILLED_FRIEND, 2.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "KilledFriend" ) );
+
+	// give them time to react
+	say->SetStartTime( gpGlobals->curtime + RandomFloat( 0.5f, 1.0f ) );
+
+	AddStatement( say );
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void BotChatterInterface::FriendlyFire( void )
+{
+	if ( !friendlyfire.GetBool() )
+		return;
+
+	BotStatement *say = new BotStatement( this, REPORT_FRIENDLY_FIRE, 1.0f );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( "FriendlyFire" ) );
+
+	// give them time to react
+	say->SetStartTime( gpGlobals->curtime + RandomFloat( 0.3f, 0.5f ) );
+
+	AddStatement( say );
+}
+
+
diff --git a/game/server/cstrike/bot/cs_bot_chatter.h b/game/server/cstrike/bot/cs_bot_chatter.h
new file mode 100644
index 00000000..47ba8020
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_chatter.h
@@ -0,0 +1,656 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Bot radio chatter system
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#ifndef CS_BOT_CHATTER_H
+#define CS_BOT_CHATTER_H
+
+#pragma warning( disable : 4786 )	// long STL names get truncated in browse info.
+
+#include "nav_mesh.h"
+#include "cs_gamestate.h"
+
+class CCSBot;
+class BotChatterInterface;
+
+#define MAX_PLACES_PER_MAP 64
+
+typedef unsigned int PlaceCriteria;
+
+typedef unsigned int CountCriteria;
+#define UNDEFINED_COUNT 0xFFFF
+#define COUNT_CURRENT_ENEMIES	0xFF		// use the number of enemies we see right when we speak
+#define COUNT_MANY 4						// equal to or greater than this is "many"
+
+#define UNDEFINED_SUBJECT (-1)
+
+/// @todo Make Place a class with member fuctions for this
+const Vector *GetRandomSpotAtPlace( Place place );
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * A meme is a unit information that bots use to 
+ * transmit information to each other via the radio
+ */
+class BotMeme
+{
+public:
+	void Transmit( CCSBot *sender ) const;									///< transmit meme to other bots
+	// It is a best practice to always have a virtual destructor in an interface
+	// class. Otherwise if the derived classes have destructors they will not be
+	// called.
+	virtual ~BotMeme() {}
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const = 0;	///< cause the given bot to act on this meme
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotHelpMeme : public BotMeme
+{
+public:
+	BotHelpMeme( Place place = UNDEFINED_PLACE )
+	{
+		m_place = place;
+	}
+
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+
+private:
+	Place m_place;			///< where the help is needed
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotBombsiteStatusMeme : public BotMeme
+{
+public:
+	enum StatusType { CLEAR, PLANTED };
+
+	BotBombsiteStatusMeme( int zoneIndex, StatusType status )
+	{
+		m_zoneIndex = zoneIndex;
+		m_status = status;
+	}
+
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+
+private:
+	int m_zoneIndex;			///< the bombsite
+	StatusType m_status;		///< whether it is cleared or the bomb is there (planted)
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotBombStatusMeme : public BotMeme
+{
+public:
+	BotBombStatusMeme( CSGameState::BombState state, const Vector &pos )
+	{
+		m_state = state;
+		m_pos = pos;
+	}
+
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+
+private:
+	CSGameState::BombState m_state;
+	Vector m_pos;
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotFollowMeme : public BotMeme
+{
+public:
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotDefendHereMeme : public BotMeme
+{
+public:
+	BotDefendHereMeme( const Vector &pos )
+	{
+		m_pos = pos;
+	}
+
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+
+private:
+	Vector m_pos;
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotWhereBombMeme : public BotMeme
+{
+public:
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotRequestReportMeme : public BotMeme
+{
+public:
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotAllHostagesGoneMeme : public BotMeme
+{
+public:
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotHostageBeingTakenMeme : public BotMeme
+{
+public:
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotHeardNoiseMeme : public BotMeme
+{
+public:
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+};
+
+//----------------------------------------------------------------------------------------------------
+class BotWarnSniperMeme : public BotMeme
+{
+public:
+	virtual void Interpret( CCSBot *sender, CCSBot *receiver ) const;		///< cause the given bot to act on this meme
+};
+
+//----------------------------------------------------------------------------------------------------
+enum BotStatementType
+{
+	REPORT_VISIBLE_ENEMIES,
+	REPORT_ENEMY_ACTION,
+	REPORT_MY_CURRENT_TASK,
+	REPORT_MY_INTENTION,
+	REPORT_CRITICAL_EVENT,
+	REPORT_REQUEST_HELP,
+	REPORT_REQUEST_INFORMATION,
+	REPORT_ROUND_END,
+	REPORT_MY_PLAN,
+	REPORT_INFORMATION,
+	REPORT_EMOTE,
+	REPORT_ACKNOWLEDGE,			///< affirmative or negative
+	REPORT_ENEMIES_REMAINING,
+	REPORT_FRIENDLY_FIRE,
+	REPORT_KILLED_FRIEND,
+	REPORT_ENEMY_LOST,
+
+	NUM_BOT_STATEMENT_TYPES
+};
+
+//----------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------
+/**
+ * BotSpeakables are the smallest unit of bot chatter.
+ * They represent a specific wav file of a phrase, and the criteria for which it is useful
+ */
+class BotSpeakable
+{
+public:
+	BotSpeakable();
+	~BotSpeakable();
+	char *m_phrase;
+	float m_duration;
+	PlaceCriteria m_place;
+	CountCriteria m_count;
+};
+typedef CUtlVector< BotSpeakable * > BotSpeakableVector;
+typedef CUtlVector< BotSpeakableVector * > BotVoiceBankVector;
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * The BotPhrase class is a collection of Speakables associated with a name, ID, and criteria
+ */
+class BotPhrase
+{
+public:
+	char *GetSpeakable( int bankIndex, float *duration = NULL ) const;		///< return a random speakable and its duration in seconds that meets the current criteria
+
+	// NOTE: Criteria must be set just before the GetSpeakable() call, since they are shared among all bots
+	void ClearCriteria( void ) const;
+	void SetPlaceCriteria( PlaceCriteria place ) const;	///< all returned phrases must have this place criteria
+	void SetCountCriteria( CountCriteria count ) const;	///< all returned phrases must have this count criteria
+
+	const char *GetName( void ) const					{ return m_name; }
+	const unsigned int GetPlace( void ) const		{ return m_place; }
+	RadioType GetRadioEquivalent( void ) const	{ return m_radioEvent; }			///< return equivalent "standard radio" event
+	bool IsImportant( void ) const						{ return m_isImportant; }	///< return true if this phrase is part of an important statement
+
+	bool IsPlace( void ) const								{ return m_isPlace; }
+
+	void Randomize( void );									///< randomly shuffle the speakable order
+
+private:
+	friend class BotPhraseManager;
+	BotPhrase( bool isPlace );
+	~BotPhrase();
+
+	char *m_name;
+	Place m_place;
+	bool m_isPlace;											///< true if this is a Place phrase
+	RadioType m_radioEvent;									///< equivalent radio event
+	bool m_isImportant;										///< mission-critical statement
+
+	mutable BotVoiceBankVector m_voiceBank;					///< array of voice banks (arrays of speakables)
+	CUtlVector< int > m_count;								///< number of speakables
+	mutable CUtlVector< int > m_index;						///< index of next speakable to return
+	int m_numVoiceBanks;									///< number of voice banks that have been initialized
+	void InitVoiceBank( int bankIndex );					///< sets up the vector of voice banks for the first bankIndex voice banks
+
+	mutable PlaceCriteria m_placeCriteria;
+	mutable CountCriteria m_countCriteria;
+};
+typedef CUtlVector<BotPhrase *> BotPhraseList;
+
+inline void BotPhrase::ClearCriteria( void ) const
+{
+	m_placeCriteria = ANY_PLACE;
+	m_countCriteria = UNDEFINED_COUNT;
+}
+
+inline void BotPhrase::SetPlaceCriteria( PlaceCriteria place ) const
+{
+	m_placeCriteria = place;
+}
+
+inline void BotPhrase::SetCountCriteria( CountCriteria count ) const
+{
+	m_countCriteria = count;
+}
+
+enum BotChatterOutputType
+{
+	BOT_CHATTER_RADIO,
+	BOT_CHATTER_VOICE
+};
+typedef CUtlVector<BotChatterOutputType> BotOutputList;
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * The BotPhraseManager is a singleton that provides an interface to all BotPhrase collections
+ */
+class BotPhraseManager
+{
+public:
+	BotPhraseManager( void );
+	~BotPhraseManager();
+
+	bool Initialize( const char *filename, int bankIndex );	///< initialize phrase system from database file for a specific voice bank (0 is the default voice bank)
+
+	void OnRoundRestart( void );												///< invoked when round resets
+	void OnMapChange( void );														///< invoked when map changes
+	void Reset( void );
+
+	const BotPhrase *GetPhrase( const char *name ) const;		///< given a name, return the associated phrase collection
+	const BotPhrase *GetPainPhrase( void ) const { return m_painPhrase; }					///< optimization, replaces a static pointer to the phrase
+	const BotPhrase *GetAgreeWithPlanPhrase( void ) const { return m_agreeWithPlanPhrase; }	///< optimization, replaces a static pointer to the phrase
+
+	const BotPhrase *GetPlace( const char *name ) const;		///< given a name, return the associated Place phrase collection
+	const BotPhrase *GetPlace( unsigned int id ) const;			///< given an id, return the associated Place phrase collection
+
+	const BotPhraseList *GetPlaceList( void ) const	{ return &m_placeList; }
+
+	float GetPlaceStatementInterval( Place where ) const;	///< return time last statement of given type was emitted by a teammate for the given place
+	void ResetPlaceStatementInterval( Place where );			///< set time of last statement of given type was emitted by a teammate for the given place
+
+	BotChatterOutputType GetOutputType( int voiceBank ) const;
+
+private:
+	BotPhraseList m_list;																	///< master list of all phrase collections
+	BotPhraseList m_placeList;														///< master list of all Place phrases
+
+	BotOutputList m_output;
+
+	const BotPhrase *m_painPhrase;
+	const BotPhrase *m_agreeWithPlanPhrase;
+
+	struct PlaceTimeInfo
+	{
+		Place placeID;
+		IntervalTimer timer;
+	};
+	mutable PlaceTimeInfo m_placeStatementHistory[ MAX_PLACES_PER_MAP ];
+	mutable int m_placeCount;
+	int FindPlaceIndex( Place where ) const;
+};
+
+inline int BotPhraseManager::FindPlaceIndex( Place where ) const
+{
+	for( int i=0; i<m_placeCount; ++i )
+		if (m_placeStatementHistory[i].placeID == where)
+			return i;
+
+	// no such place - allocate it
+	if (m_placeCount < MAX_PLACES_PER_MAP)
+	{
+		m_placeStatementHistory[ ++m_placeCount ].placeID = where;
+		m_placeStatementHistory[ ++m_placeCount ].timer.Invalidate();
+		return m_placeCount-1;
+	}
+
+	// place directory is full
+	return -1;
+}
+
+/**
+ * Return time last statement of given type was emitted by a teammate for the given place
+ */
+inline float BotPhraseManager::GetPlaceStatementInterval( Place place ) const
+{
+	int index = FindPlaceIndex( place );
+
+	if (index < 0)
+		return 999999.9f;
+
+	if (index >= m_placeCount)
+		return 999999.9f;
+
+	return m_placeStatementHistory[ index ].timer.GetElapsedTime();
+}
+
+/**
+ * Set time of last statement of given type was emitted by a teammate for the given place
+ */
+inline void BotPhraseManager::ResetPlaceStatementInterval( Place place )
+{
+	int index = FindPlaceIndex( place );
+
+	if (index < 0)
+		return;
+
+	if (index >= m_placeCount)
+		return;
+
+	// update entry
+	m_placeStatementHistory[ index ].timer.Reset();
+}
+
+extern BotPhraseManager *TheBotPhrases;
+
+
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * Statements are meaningful collections of phrases
+ */
+class BotStatement
+{
+public:
+	BotStatement( BotChatterInterface *chatter, BotStatementType type, float expireDuration );
+	~BotStatement();
+
+	BotChatterInterface *GetChatter( void ) const	{ return m_chatter; }
+	CCSBot *GetOwner( void ) const;
+
+	BotStatementType GetType( void ) const	{ return m_type; }	///< return the type of statement this is
+	bool IsImportant( void ) const;								///< return true if this statement is "important" and not personality chatter
+
+	bool HasSubject( void ) const	{ return (m_subject == UNDEFINED_SUBJECT) ? false : true; }
+	void SetSubject( int playerID )	{ m_subject = playerID; }	///< who this statement is about
+	int GetSubject( void ) const	{ return m_subject; }		///< who this statement is about
+
+	bool HasPlace( void ) const		{ return (GetPlace()) ? true : false; }
+	Place GetPlace( void ) const;								///< if this statement refers to a specific place, return that place
+	void SetPlace( Place where )	{ m_place = where; }		///< explicitly set place
+
+	bool HasCount( void ) const;								///< return true if this statement has an associated count
+
+	bool IsRedundant( const BotStatement *say ) const;			///< return true if this statement is the same as the given one
+	bool IsObsolete( void ) const;								///< return true if this statement is no longer appropriate to say
+	void Convert( const BotStatement *say );					///< possibly change what were going to say base on what teammate is saying
+	
+	void AppendPhrase( const BotPhrase *phrase );
+
+	void SetStartTime( float timestamp )	{ m_startTime = timestamp; }	///< define the earliest time this statement can be spoken
+	float GetStartTime( void ) const		{ return m_startTime; }
+
+	enum ConditionType
+	{
+		IS_IN_COMBAT,
+		RADIO_SILENCE,
+		ENEMIES_REMAINING,
+
+		NUM_CONDITIONS
+	};
+
+	void AddCondition( ConditionType condition );				///< conditions must be true for the statement to be spoken
+	bool IsValid( void ) const;									///< verify all attached conditions 
+
+	enum ContextType
+	{
+		CURRENT_ENEMY_COUNT,
+		REMAINING_ENEMY_COUNT,
+		SHORT_DELAY,
+		LONG_DELAY,
+		ACCUMULATE_ENEMIES_DELAY
+	};
+	void AppendPhrase( ContextType contextPhrase );				///< special phrases that depend on the context
+
+	bool Update( void );											///< emit statement over time, return false if statement is done
+	bool IsSpeaking( void ) const		{ return m_isSpeaking; }	///< return true if this statement is currently being spoken
+	float GetTimestamp( void ) const	{ return m_timestamp; }		///< get time statement was created (but not necessarily started talking)
+
+	void AttachMeme( BotMeme *meme );							///< attach a meme to this statement, to be transmitted to other friendly bots when spoken
+
+private:
+	friend class BotChatterInterface;
+
+	BotChatterInterface *m_chatter;								///< the chatter system this statement is part of
+
+	BotStatement *m_next, *m_prev;								///< linked list hooks
+
+	BotStatementType m_type;									///< what kind of statement this is
+	int m_subject;												///< who this subject is about
+	Place m_place;												///< explicit place - note some phrases have implicit places as well
+	BotMeme *m_meme;											///< a statement can only have a single meme for now
+
+	float m_timestamp;											///< time when message was created
+	float m_startTime;											///< the earliest time this statement can be spoken
+	float m_expireTime;											///< time when this statement is no longer valid
+	float m_speakTimestamp;										///< time when message began being spoken
+	bool m_isSpeaking;											///< true if this statement is current being spoken
+
+	float m_nextTime;											///< time for next phrase to begin
+
+	enum { MAX_BOT_PHRASES = 4 };
+	struct
+	{
+		bool isPhrase;
+		union
+		{
+			const BotPhrase *phrase;
+			ContextType context;
+		};
+	}
+	m_statement[ MAX_BOT_PHRASES ];
+
+	enum { MAX_BOT_CONDITIONS = 4 };
+	ConditionType m_condition[ MAX_BOT_CONDITIONS ];			///< conditions that must be true for the statement to be said
+	int m_conditionCount;
+
+	int m_index;												///< m_index refers to the phrase currently being spoken, or -1 if we havent started yet
+	int m_count;
+};
+
+//----------------------------------------------------------------------------------------------------
+/**
+ * This class defines the interface to the bot radio chatter system
+ */
+class BotChatterInterface
+{
+public:
+	BotChatterInterface( CCSBot *me );
+	~BotChatterInterface( );
+
+	void Reset( void );											///< reset to initial state
+	void Update( void );										///< process ongoing chatter
+
+	/// invoked when event occurs in the game (some events have NULL entities)
+	void OnDeath( void );										///< invoked when we die
+
+	enum VerbosityType
+	{
+		NORMAL,				///< full chatter
+		MINIMAL,			///< only scenario-critical events
+		RADIO,				///< use the standard radio instead
+		OFF						///< no chatter at all
+	};
+	VerbosityType GetVerbosity( void ) const;					///< return our current level of verbosity
+
+	CCSBot *GetOwner( void ) const							{ return m_me; }
+
+	bool IsTalking( void ) const;								///< return true if we are currently talking
+	float GetRadioSilenceDuration( void );						///< return time since any teammate said anything
+	void ResetRadioSilenceDuration( void );
+
+	enum { MUST_ADD = 1 };
+	void AddStatement( BotStatement *statement, bool mustAdd = false );			///< register a statement for speaking
+	void RemoveStatement( BotStatement *statement );			///< remove a statement
+
+	BotStatement *GetActiveStatement( void );					///< returns the statement that is being spoken, or is next to be spoken if no-one is speaking now
+	BotStatement *GetStatement( void ) const;					///< returns our current statement, or NULL if we aren't speaking
+
+	int GetPitch( void ) const			{ return m_pitch; }
+
+
+	//-- things the bots can say ---------------------------------------------------------------------
+	void Say( const char *phraseName, float lifetime = 3.0f, float delay = 0.0f );
+
+	void AnnouncePlan( const char *phraseName, Place where );
+	void Affirmative( void );
+	void Negative( void );
+
+	void EnemySpotted( void );									///< report enemy sightings
+	void KilledMyEnemy( int victimID );
+	void EnemiesRemaining( void );
+
+	void SpottedSniper( void );
+	void FriendSpottedSniper( void );
+
+	void Clear( Place where );
+
+	void ReportIn( void );										///< ask for current situation
+	void ReportingIn( void );									///< report current situation
+
+	bool NeedBackup( void );
+	void PinnedDown( void );
+	void Scared( void );
+	void HeardNoise( const Vector &pos );
+	void FriendHeardNoise( void );
+
+	void TheyPickedUpTheBomb( void );
+	void GoingToPlantTheBomb( Place where );
+	void BombsiteClear( int zoneIndex );
+	void FoundPlantedBomb( int zoneIndex );
+	void PlantingTheBomb( Place where );
+	void SpottedBomber( CBasePlayer *bomber );
+	void SpottedLooseBomb( CBaseEntity *bomb );
+	void GuardingLooseBomb( CBaseEntity *bomb );
+	void RequestBombLocation( void );
+
+	#define IS_PLAN true
+	void GuardingHostages( Place where, bool isPlan = false );
+	void GuardingHostageEscapeZone( bool isPlan = false );
+	void HostagesBeingTaken( void );
+	void HostagesTaken( void );
+	void TalkingToHostages( void );
+	void EscortingHostages( void );
+	void HostageDown( void );
+	void GuardingBombsite( Place where );
+
+	void CelebrateWin( void );
+
+	void Encourage( const char *phraseName, float repeatInterval = 10.0f, float lifetime = 3.0f );	///< "encourage" the player to do the scenario
+
+	void KilledFriend( void );
+	void FriendlyFire( void );
+
+	bool SeesAtLeastOneEnemy( void ) const { return m_seeAtLeastOneEnemy; }
+
+private:
+	BotStatement *m_statementList;										///< list of all active/pending messages for this bot
+
+	void ReportEnemies( void );											///< track nearby enemy count and generate enemy activity statements
+	bool ShouldSpeak( void ) const;										///< return true if we speaking makes sense now
+
+	CCSBot *m_me;														///< the bot this chatter is for
+
+	bool m_seeAtLeastOneEnemy;
+	float m_timeWhenSawFirstEnemy;
+	bool m_reportedEnemies;
+	bool m_requestedBombLocation;										///< true if we already asked where the bomb has been planted
+
+	int m_pitch;
+
+	static IntervalTimer m_radioSilenceInterval[ 2 ];					///< one timer for each team
+
+	IntervalTimer m_needBackupInterval;
+	IntervalTimer m_spottedBomberInterval;
+	IntervalTimer m_scaredInterval;
+	IntervalTimer m_planInterval;
+	CountdownTimer m_spottedLooseBombTimer;
+	CountdownTimer m_heardNoiseTimer;
+	CountdownTimer m_escortingHostageTimer;
+	CountdownTimer m_warnSniperTimer;
+	static CountdownTimer m_encourageTimer;								///< timer to know when we can "encourage" the human player again - shared by all bots
+};
+
+inline BotChatterInterface::VerbosityType BotChatterInterface::GetVerbosity( void ) const
+{
+	const char *string = cv_bot_chatter.GetString();
+
+	if (string == NULL)
+		return NORMAL;
+
+	if (string[0] == 'm' || string[0] == 'M')
+		return MINIMAL;
+
+	if (string[0] == 'r' || string[0] == 'R')
+		return RADIO;
+
+	if (string[0] == 'o' || string[0] == 'O')
+		return OFF;
+
+	return NORMAL;
+}
+
+
+inline bool BotChatterInterface::IsTalking( void ) const	
+{ 
+	if (m_statementList)
+		return m_statementList->IsSpeaking();
+
+	return false;
+}
+
+inline BotStatement *BotChatterInterface::GetStatement( void ) const
+{
+	return m_statementList;
+}
+
+
+inline void BotChatterInterface::Say( const char *phraseName, float lifetime, float delay )
+{
+	BotStatement *say = new BotStatement( this, REPORT_MY_INTENTION, lifetime );
+
+	say->AppendPhrase( TheBotPhrases->GetPhrase( phraseName ) );
+
+	if (delay > 0.0f)
+		say->SetStartTime( gpGlobals->curtime + delay );
+
+	AddStatement( say );
+}
+
+
+
+
+#endif // CS_BOT_CHATTER_H
diff --git a/game/server/cstrike/bot/cs_bot_event.cpp b/game/server/cstrike/bot/cs_bot_event.cpp
new file mode 100644
index 00000000..24bdae43
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_event.cpp
@@ -0,0 +1,427 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "KeyValues.h"
+
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Checks if the bot can hear the event
+ */
+void CCSBot::OnAudibleEvent( IGameEvent *event, CBasePlayer *player, float range, PriorityType priority, bool isHostile, bool isFootstep, const Vector *actualOrigin )
+{
+	/// @todo Listen to non-player sounds
+	if (player == NULL)
+		return;
+
+	// don't pay attention to noise that friends make
+	if (!IsEnemy( player ))
+		return;
+
+	Vector playerOrigin = GetCentroid( player );
+	Vector myOrigin = GetCentroid( this );
+
+	// If the event occurs far from the triggering player, it may override the origin
+	if ( actualOrigin )
+	{
+		playerOrigin = *actualOrigin;
+	}
+
+	// check if noise is close enough for us to hear
+	const Vector *newNoisePosition = &playerOrigin;
+	float newNoiseDist = (myOrigin - *newNoisePosition).Length();
+	if (newNoiseDist < range)
+	{
+		// we heard the sound
+		if ((IsLocalPlayerWatchingMe() && cv_bot_debug.GetInt() == 3) || cv_bot_debug.GetInt() == 4)
+		{
+			PrintIfWatched( "Heard noise (%s from %s, pri %s, time %3.1f)\n", 
+											(FStrEq( "weapon_fire", event->GetName() )) ? "Weapon fire " : "",
+											(player) ? player->GetPlayerName() : "NULL",
+											(priority == PRIORITY_HIGH) ? "HIGH" : ((priority == PRIORITY_MEDIUM) ? "MEDIUM" : "LOW"),
+											gpGlobals->curtime );
+		}
+
+		// should we pay attention to it
+		// if noise timestamp is zero, there is no prior noise
+		if (m_noiseTimestamp > 0.0f)
+		{
+			// only overwrite recent sound if we are louder (closer), or more important - if old noise was long ago, its faded
+			const float shortTermMemoryTime = 3.0f;
+			if (gpGlobals->curtime - m_noiseTimestamp < shortTermMemoryTime)
+			{
+				// prior noise is more important - ignore new one
+				if (priority < m_noisePriority)
+					return;
+
+				float oldNoiseDist = (myOrigin - m_noisePosition).Length();
+				if (newNoiseDist >= oldNoiseDist)
+					return;
+			}
+		}
+
+		// find the area in which the noise occured
+		/// @todo Better handle when noise occurs off the nav mesh
+		/// @todo Make sure noise area is not through a wall or ceiling from source of noise
+		/// @todo Change GetNavTravelTime to better deal with NULL destination areas
+		CNavArea *noiseArea = TheNavMesh->GetNearestNavArea( *newNoisePosition );
+		if (noiseArea == NULL)
+		{
+			PrintIfWatched( "  *** Noise occurred off the nav mesh - ignoring!\n" );
+			return;
+		}
+
+		m_noiseArea = noiseArea;
+
+		// remember noise priority
+		m_noisePriority = priority;
+
+		// randomize noise position in the area a bit - hearing isn't very accurate
+		// the closer the noise is, the more accurate our placement
+		/// @todo Make sure not to pick a position on the opposite side of ourselves.
+		const float maxErrorRadius = 400.0f;
+		const float maxHearingRange = 2000.0f;
+		float errorRadius = maxErrorRadius * newNoiseDist/maxHearingRange;
+
+		m_noisePosition.x = newNoisePosition->x + RandomFloat( -errorRadius, errorRadius );
+		m_noisePosition.y = newNoisePosition->y + RandomFloat( -errorRadius, errorRadius );
+
+		// note the *travel distance* to the noise
+		m_noiseTravelDistance = GetTravelDistanceToPlayer( (CCSPlayer *)player );
+
+		// make sure noise position remains in the same area
+		m_noiseArea->GetClosestPointOnArea( m_noisePosition, &m_noisePosition );
+
+		// note when we heard the noise
+		m_noiseTimestamp = gpGlobals->curtime;
+
+		// if we hear a nearby enemy, become alert
+		const float nearbyNoiseRange = 1000.0f;
+		if (m_noiseTravelDistance < nearbyNoiseRange && m_noiseTravelDistance > 0.0f)
+		{
+			BecomeAlert();
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnHEGrenadeDetonate( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 99999.0f, PRIORITY_HIGH, true ); // hegrenade_detonate
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnFlashbangDetonate( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 1000.0f, PRIORITY_LOW, true ); // flashbang_detonate
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnSmokeGrenadeDetonate( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 1000.0f, PRIORITY_LOW, true ); // smokegrenade_detonate
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnGrenadeBounce( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 500.0f, PRIORITY_LOW, true ); // grenade_bounce
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBulletImpact( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	// Construct an origin for the sound, since it can be far from the originating player
+	Vector actualOrigin;
+	actualOrigin.x = event->GetFloat( "x", 0.0f );
+	actualOrigin.y = event->GetFloat( "y", 0.0f );
+	actualOrigin.z = event->GetFloat( "z", 0.0f );
+
+	/// @todo Ignoring bullet impact events for now - we dont want bots to look directly at them!
+	//OnAudibleEvent( event, player, 1100.0f, PRIORITY_MEDIUM, true, false, &actualOrigin ); // bullet_impact
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBreakProp( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 1100.0f, PRIORITY_MEDIUM, true ); // break_prop
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBreakBreakable( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 1100.0f, PRIORITY_MEDIUM, true ); // break_glass
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnDoorMoving( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 1100.0f, PRIORITY_MEDIUM, false ); // door_moving
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnHostageFollows( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	// player_follows needs a player
+	if (player == NULL)
+		return;
+
+	// don't pay attention to noise that friends make
+	if (!IsEnemy( player ))
+		return;
+
+	Vector playerOrigin = GetCentroid( player );
+	Vector myOrigin = GetCentroid( this );
+	const float range = 1200.0f;
+
+	// this is here so T's not only act on the noise, but look at it, too
+	if (GetTeamNumber() == TEAM_TERRORIST)
+	{
+		// make sure we can hear the noise
+		if ((playerOrigin - myOrigin).IsLengthGreaterThan( range ))
+			return;
+
+		// tell our teammates that the hostages are being taken
+		GetChatter()->HostagesBeingTaken();
+
+		// only move if we hear them being rescued and can't see any hostages
+		if (GetGameState()->GetNearestVisibleFreeHostage() == NULL)
+		{			
+			// since we are guarding the hostages, presumably we know where they are
+			// if we're close enough to "hear" this event, either go to where the event occured,
+			// or head for an escape zone to head them off
+			if (GetTask() != CCSBot::GUARD_HOSTAGE_RESCUE_ZONE)
+			{
+				//const float headOffChance = 33.3f;
+				if (true) // || RandomFloat( 0, 100 ) < headOffChance)
+				{
+					// head them off at a rescue zone
+					if (GuardRandomZone())
+					{
+						SetTask( CCSBot::GUARD_HOSTAGE_RESCUE_ZONE );
+						SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+						PrintIfWatched( "Trying to beat them to an escape zone!\n" );
+					}
+				}
+				else
+				{
+					SetTask( SEEK_AND_DESTROY );
+					StandUp();
+					Run();
+					MoveTo( playerOrigin, FASTEST_ROUTE );
+				}
+			}
+		}
+	}
+	else
+	{
+		// CT's don't care about this noise
+		return;
+	}
+
+	OnAudibleEvent( event, player, range, PRIORITY_MEDIUM, false ); // hostage_follows
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnRoundEnd( IGameEvent *event )
+{
+	// Morale adjustments happen even for dead players
+	int winner = event->GetInt( "winner" );
+	switch ( winner )
+	{
+	case WINNER_TER:
+		if (GetTeamNumber() == TEAM_CT)
+		{
+			DecreaseMorale();
+		}
+		else
+		{
+			IncreaseMorale();
+		}
+		break;
+
+	case WINNER_CT:
+		if (GetTeamNumber() == TEAM_CT)
+		{
+			IncreaseMorale();
+		}
+		else
+		{
+			DecreaseMorale();
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	m_gameState.OnRoundEnd( event );
+
+	if ( !IsAlive() )
+		return;
+
+	if ( event->GetInt( "winner" ) == WINNER_TER )
+	{
+		if (GetTeamNumber() == TEAM_TERRORIST)
+			GetChatter()->CelebrateWin();
+	}
+	else if ( event->GetInt( "winner" ) == WINNER_CT )
+	{
+		if (GetTeamNumber() == TEAM_CT)
+			GetChatter()->CelebrateWin();
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnRoundStart( IGameEvent *event )
+{
+	m_gameState.OnRoundStart( event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnHostageRescuedAll( IGameEvent *event )
+{
+	m_gameState.OnHostageRescuedAll( event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnNavBlocked( IGameEvent *event )
+{
+	if ( event->GetBool( "blocked" ) )
+	{
+		unsigned int areaID = event->GetInt( "area" );
+		if ( areaID )
+		{
+			// An area was blocked off.  Reset our path if it has this area on it.
+			for( int i=0; i<m_pathLength; ++i )
+			{
+				const ConnectInfo *info = &m_path[ i ];
+				if ( info->area && info->area->GetID() == areaID )
+				{
+					DestroyPath();
+					return;
+				}
+			}
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when bot enters a nav area
+ */
+void CCSBot::OnEnteredNavArea( CNavArea *newArea )
+{
+	// assume that we "clear" an area of enemies when we enter it
+	newArea->SetClearedTimestamp( GetTeamNumber()-1 );
+
+	// if we just entered a 'stop' area, set the flag
+	if ( newArea->GetAttributes() & NAV_MESH_STOP )
+	{
+		m_isStopping = true;
+	}
+
+	/// @todo Flag these areas as spawn areas during load
+	if (IsAtEnemySpawn())
+	{
+		m_hasVisitedEnemySpawn = true;
+	}
+}
diff --git a/game/server/cstrike/bot/cs_bot_event_bomb.cpp b/game/server/cstrike/bot/cs_bot_event_bomb.cpp
new file mode 100644
index 00000000..b1dd75db
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_event_bomb.cpp
@@ -0,0 +1,158 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "KeyValues.h"
+
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBombPickedUp( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	if (GetTeamNumber() == TEAM_CT && player)
+	{
+		// check if we're close enough to hear it
+		const float bombPickupHearRangeSq = 1000.0f * 1000.0f;
+		Vector myOrigin = GetCentroid( this );
+
+		if ((myOrigin - player->GetAbsOrigin()).LengthSqr() < bombPickupHearRangeSq)
+		{
+			GetChatter()->TheyPickedUpTheBomb();
+			GetGameState()->UpdateBomber( player->GetAbsOrigin() );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBombPlanted( IGameEvent *event )
+{
+	m_gameState.OnBombPlanted( event );
+
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	// if we're a TEAM_CT, forget what we're doing and go after the bomb
+	if (GetTeamNumber() == TEAM_CT)
+	{
+		Idle();
+	}
+
+	// if we are following someone, stop following
+	if (IsFollowing())
+	{
+		StopFollowing();
+		Idle();
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBombBeep( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	CBaseEntity *entity = UTIL_EntityByIndex( event->GetInt( "entindex" ) );
+	Vector myOrigin = GetCentroid( this );
+
+	// if we don't know where the bomb is, but heard it beep, we've discovered it
+	if (GetGameState()->IsPlantedBombLocationKnown() == false && entity)
+	{
+		// check if we're close enough to hear it
+		const float bombBeepHearRangeSq = 1500.0f * 1500.0f;
+		if ((myOrigin - entity->GetAbsOrigin()).LengthSqr() < bombBeepHearRangeSq)
+		{
+			// radio the news to our team
+			if (GetTeamNumber() == TEAM_CT && GetGameState()->GetPlantedBombsite() == CSGameState::UNKNOWN)
+			{
+				const CCSBotManager::Zone *zone = TheCSBots()->GetZone( entity->GetAbsOrigin() );
+				if (zone)
+					GetChatter()->FoundPlantedBomb( zone->m_index );
+			}
+
+			// remember where the bomb is
+			GetGameState()->UpdatePlantedBomb( entity->GetAbsOrigin() );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBombDefuseBegin( IGameEvent *event )
+{
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBombDefused( IGameEvent *event )
+{
+	m_gameState.OnBombDefused( event );
+
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	if (GetTeamNumber() == TEAM_CT)
+	{
+		if (TheCSBots()->GetBombTimeLeft() < 2.0f)
+			GetChatter()->Say( "BarelyDefused" );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBombDefuseAbort( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	PrintIfWatched( "BOMB DEFUSE ABORTED\n" );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnBombExploded( IGameEvent *event )
+{
+	m_gameState.OnBombExploded( event );
+}
+
+
+
diff --git a/game/server/cstrike/bot/cs_bot_event_player.cpp b/game/server/cstrike/bot/cs_bot_event_player.cpp
new file mode 100644
index 00000000..d5734ab0
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_event_player.cpp
@@ -0,0 +1,227 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "KeyValues.h"
+
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnPlayerDeath( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	Vector playerOrigin = (player) ? GetCentroid( player ) : Vector( 0, 0, 0 );
+
+	CBasePlayer *other = UTIL_PlayerByUserId( event->GetInt( "attacker" ) );
+	CBasePlayer *victim = player;
+
+	CBasePlayer *killer = (other && other->IsPlayer()) ? static_cast<CBasePlayer *>( other ) : NULL;
+
+	// if the human player died in the single player game, tell the team
+	if (CSGameRules()->IsCareer() && victim && !victim->IsBot() && victim->GetTeamNumber() == GetTeamNumber())
+	{
+		GetChatter()->Say( "CommanderDown", 20.0f );
+	}
+
+	// keep track of the last player we killed
+	if (killer == this)
+	{
+		m_lastVictimID = victim ? victim->entindex() : 0;
+	}
+
+	// react to teammate death
+	if (victim && victim->GetTeamNumber() == GetTeamNumber())
+	{
+		// note time of death
+		m_friendDeathTimestamp = gpGlobals->curtime;
+
+		// chastise friendly fire from humans
+		if (killer && !killer->IsBot() && killer->GetTeamNumber() == GetTeamNumber() && killer != this)
+		{
+			GetChatter()->KilledFriend();
+		}
+
+		if (IsAttacking())
+		{
+			if (GetTimeSinceLastSawEnemy() > 0.4f)
+			{
+				PrintIfWatched( "Rethinking my attack due to teammate death\n" );
+
+				// allow us to sneak past windows, doors, etc
+				IgnoreEnemies( 1.0f );
+
+				// move to last known position of enemy - this could cause us to flank if 
+				// the danger has changed due to our teammate's recent death
+				SetTask( MOVE_TO_LAST_KNOWN_ENEMY_POSITION, GetBotEnemy() );
+				MoveTo( GetLastKnownEnemyPosition() );
+				return;
+			}
+		}
+		else	// not attacking
+		{
+			//
+			// If we just saw a nearby friend die, and we haven't yet acquired an enemy
+			// automatically acquire our dead friend's killer
+			//
+			if (GetDisposition() == ENGAGE_AND_INVESTIGATE || GetDisposition() == OPPORTUNITY_FIRE)
+			{
+				CBasePlayer *other = UTIL_PlayerByUserId( event->GetInt( "attacker" ) );
+
+				// check that attacker is an enemy (for friendly fire, etc)
+				if (other && other->IsPlayer())
+				{
+					CCSPlayer *killer = static_cast<CCSPlayer *>( other );
+					if (killer->GetTeamNumber() != GetTeamNumber())
+					{
+						// check if we saw our friend die - dont check FOV - assume we're aware of our surroundings in combat
+						// snipers stay put
+						if (!IsSniper() && IsVisible( playerOrigin ))
+						{
+							// people are dying - we should hurry
+							Hurry( RandomFloat( 10.0f, 15.0f ) );
+
+							// if we're hiding with only our knife, be a little more cautious
+							const float knifeAmbushChance = 50.0f;
+							if (!IsHiding() || !IsUsingKnife() || RandomFloat( 0, 100 ) < knifeAmbushChance)
+							{
+								PrintIfWatched( "Attacking our friend's killer!\n" );
+								Attack( killer );
+								return;
+							}
+						}
+
+						// if friend was far away and we haven't seen an enemy in awhile, go to where our friend was killed
+						const float longHidingTime = 20.0f;
+						if (IsHunting() || IsInvestigatingNoise() || (IsHiding() && GetTask() != FOLLOW && GetHidingTime() > longHidingTime))
+						{
+							const float someTime = 10.0f;
+							const float farAway = 750.0f;
+							if (GetTimeSinceLastSawEnemy() > someTime && (playerOrigin - GetAbsOrigin()).IsLengthGreaterThan( farAway ))
+							{
+								PrintIfWatched( "Checking out where our friend was killed\n" );
+								MoveTo( playerOrigin, FASTEST_ROUTE );
+								return;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	else  // an enemy was killed
+	{
+		// forget our current noise - it may have come from the now dead enemy
+		ForgetNoise();
+
+		if (killer && killer->GetTeamNumber() == GetTeamNumber())
+		{
+			// only chatter about enemy kills if we see them occur, and they were the last one we see
+			if (GetNearbyEnemyCount() <= 1)
+			{
+				// report if number of enemies left is few and we killed the last one we saw locally
+				GetChatter()->EnemiesRemaining();
+
+				Vector victimOrigin = (victim) ? GetCentroid( victim ) : Vector( 0, 0, 0 );
+				if (IsVisible( victimOrigin, CHECK_FOV ))
+				{						
+					// congratulate teammates on their kills
+					if (killer && killer != this)
+					{
+						float delay = RandomFloat( 2.0f, 3.0f );
+						if (killer->IsBot())
+						{
+							if (RandomFloat( 0.0f, 100.0f ) < 40.0f)
+								GetChatter()->Say( "NiceShot", 3.0f, delay );
+						}
+						else
+						{
+							// humans get the honorific
+							if (CSGameRules()->IsCareer())
+								GetChatter()->Say( "NiceShotCommander", 3.0f, delay );
+							else
+								GetChatter()->Say( "NiceShotSir", 3.0f, delay );
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnPlayerRadio( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CCSPlayer *player = ToCSPlayer( UTIL_PlayerByUserId( event->GetInt( "userid" ) ) );
+	if ( player == this )
+		return;
+
+	//
+	// Process radio events from our team
+	//
+	if (player && player->GetTeamNumber() == GetTeamNumber() )
+	{
+		/// @todo Distinguish between radio commands and responses
+		RadioType radioEvent = (RadioType)event->GetInt( "slot" );
+
+		if (radioEvent != RADIO_INVALID && radioEvent != RADIO_AFFIRMATIVE && radioEvent != RADIO_NEGATIVE && radioEvent != RADIO_REPORTING_IN)
+		{
+			m_lastRadioCommand = radioEvent;
+			m_lastRadioRecievedTimestamp = gpGlobals->curtime;
+			m_radioSubject = player;
+			m_radioPosition = GetCentroid( player );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnPlayerFallDamage( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 1100.0f, PRIORITY_LOW, false ); // player_falldamage
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnPlayerFootstep( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 1100.0f, PRIORITY_LOW, false, IS_FOOTSTEP ); // player_footstep
+}
+
+
diff --git a/game/server/cstrike/bot/cs_bot_event_weapon.cpp b/game/server/cstrike/bot/cs_bot_event_weapon.cpp
new file mode 100644
index 00000000..90f8b9fb
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_event_weapon.cpp
@@ -0,0 +1,167 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "KeyValues.h"
+
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnWeaponFire( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	// for knife fighting - if our victim is attacking or reloading, rush him
+	/// @todo Propagate events into active state
+	if (GetEnemy() == player && IsUsingKnife())
+	{
+		ForceRun( 5.0f );
+	}
+
+	const float ShortRange = 1000.0f;
+	const float NormalRange = 2000.0f;
+
+	float range;
+
+	/// @todo Check weapon type (knives are pretty quiet)
+	/// @todo Use actual volume, account for silencers, etc.
+	CWeaponCSBase *weapon = (CWeaponCSBase *)((player)?player->GetActiveWeapon():NULL);
+
+	if (weapon == NULL)
+		return;
+
+	switch( weapon->GetWeaponID() )
+	{
+		// silent "firing"
+		case WEAPON_HEGRENADE:
+		case WEAPON_SMOKEGRENADE:
+		case WEAPON_FLASHBANG:
+		case WEAPON_SHIELDGUN:
+		case WEAPON_C4:
+			return;
+
+		// quiet
+		case WEAPON_KNIFE:
+		case WEAPON_TMP:
+			range = ShortRange;
+			break;
+
+		// M4A1 - check for silencer
+		case WEAPON_M4A1:
+		{					
+			if (weapon->IsSilenced())
+			{
+				range = ShortRange;
+			}
+			else
+			{
+				range = NormalRange;
+			}
+			break;
+		}
+
+		// USP - check for silencer
+		case WEAPON_USP:
+		{
+			if (weapon->IsSilenced())
+			{
+				range = ShortRange;
+			}
+			else
+			{
+				range = NormalRange;
+			}
+			break;
+		}
+
+		// loud
+		case WEAPON_AWP:
+			range = 99999.0f;
+			break;
+
+		// normal
+		default:
+			range = NormalRange;
+			break;
+	}
+
+	OnAudibleEvent( event, player, range, PRIORITY_HIGH, true ); // weapon_fire
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnWeaponFireOnEmpty( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	// for knife fighting - if our victim is attacking or reloading, rush him
+	/// @todo Propagate events into active state
+	if (GetEnemy() == player && IsUsingKnife())
+	{
+		ForceRun( 5.0f );
+	}
+
+	OnAudibleEvent( event, player, 1100.0f, PRIORITY_LOW, false ); // weapon_fire_on_empty
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnWeaponReload( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	// for knife fighting - if our victim is attacking or reloading, rush him
+	/// @todo Propagate events into active state
+	if (GetEnemy() == player && IsUsingKnife())
+	{
+		ForceRun( 5.0f );
+	}
+
+	OnAudibleEvent( event, player, 1100.0f, PRIORITY_LOW, false ); // weapon_reload
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::OnWeaponZoom( IGameEvent *event )
+{
+	if ( !IsAlive() )
+		return;
+
+	// don't react to our own events
+	CBasePlayer *player = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+	if ( player == this )
+		return;
+
+	OnAudibleEvent( event, player, 1100.0f, PRIORITY_LOW, false ); // weapon_zoom
+}
+
+
+
diff --git a/game/server/cstrike/bot/cs_bot_init.cpp b/game/server/cstrike/bot/cs_bot_init.cpp
new file mode 100644
index 00000000..d6a5c77e
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_init.cpp
@@ -0,0 +1,359 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+#include "cs_shareddefs.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#pragma warning( disable : 4355 )			// warning 'this' used in base member initializer list - we're using it safely
+
+
+//--------------------------------------------------------------------------------------------------------------
+static void PrefixChanged( IConVar *c, const char *oldPrefix, float flOldValue )
+{
+	if ( TheCSBots() && TheCSBots()->IsServerActive() )
+	{
+		for( int i = 1; i <= gpGlobals->maxClients; ++i )
+		{
+			CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+			if ( !player )
+				continue;
+
+			if ( !player->IsBot() || !IsEntityValid( player ) )
+				continue;
+
+			CCSBot *bot = dynamic_cast< CCSBot * >( player );
+
+			if ( !bot )
+				continue;
+
+			// set the bot's name
+			char botName[MAX_PLAYER_NAME_LENGTH];
+			UTIL_ConstructBotNetName( botName, MAX_PLAYER_NAME_LENGTH, bot->GetProfile() );
+
+			engine->SetFakeClientConVarValue( bot->edict(), "name", botName );
+		}
+	}
+}
+
+
+ConVar cv_bot_traceview( "bot_traceview", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "For internal testing purposes." );
+ConVar cv_bot_stop( "bot_stop", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "If nonzero, immediately stops all bot processing." );
+ConVar cv_bot_show_nav( "bot_show_nav", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "For internal testing purposes." );
+ConVar cv_bot_walk( "bot_walk", "0", FCVAR_REPLICATED, "If nonzero, bots can only walk, not run." );
+ConVar cv_bot_difficulty( "bot_difficulty", "1", FCVAR_REPLICATED, "Defines the skill of bots joining the game.  Values are: 0=easy, 1=normal, 2=hard, 3=expert." );
+ConVar cv_bot_debug( "bot_debug", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "For internal testing purposes." );
+ConVar cv_bot_debug_target( "bot_debug_target", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "For internal testing purposes." );
+ConVar cv_bot_quota( "bot_quota", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Determines the total number of bots in the game." );
+ConVar cv_bot_quota_mode( "bot_quota_mode", "normal", FCVAR_REPLICATED, "Determines the type of quota.\nAllowed values: 'normal', 'fill', and 'match'.\nIf 'fill', the server will adjust bots to keep N players in the game, where N is bot_quota.\nIf 'match', the server will maintain a 1:N ratio of humans to bots, where N is bot_quota." );
+ConVar cv_bot_prefix( "bot_prefix", "", FCVAR_REPLICATED, "This string is prefixed to the name of all bots that join the game.\n<difficulty> will be replaced with the bot's difficulty.\n<weaponclass> will be replaced with the bot's desired weapon class.\n<skill> will be replaced with a 0-100 representation of the bot's skill.", PrefixChanged );
+ConVar cv_bot_allow_rogues( "bot_allow_rogues", "1", FCVAR_REPLICATED, "If nonzero, bots may occasionally go 'rogue'. Rogue bots do not obey radio commands, nor pursue scenario goals." );
+ConVar cv_bot_allow_pistols( "bot_allow_pistols", "1", FCVAR_REPLICATED, "If nonzero, bots may use pistols." );
+ConVar cv_bot_allow_shotguns( "bot_allow_shotguns", "1", FCVAR_REPLICATED, "If nonzero, bots may use shotguns." );
+ConVar cv_bot_allow_sub_machine_guns( "bot_allow_sub_machine_guns", "1", FCVAR_REPLICATED, "If nonzero, bots may use sub-machine guns." );
+ConVar cv_bot_allow_rifles( "bot_allow_rifles", "1", FCVAR_REPLICATED, "If nonzero, bots may use rifles." );
+ConVar cv_bot_allow_machine_guns( "bot_allow_machine_guns", "1", FCVAR_REPLICATED, "If nonzero, bots may use the machine gun." );
+ConVar cv_bot_allow_grenades( "bot_allow_grenades", "1", FCVAR_REPLICATED, "If nonzero, bots may use grenades." );
+ConVar cv_bot_allow_snipers( "bot_allow_snipers", "1", FCVAR_REPLICATED, "If nonzero, bots may use sniper rifles." );
+#ifdef CS_SHIELD_ENABLED
+ConVar cv_bot_allow_shield( "bot_allow_shield", "1", FCVAR_REPLICATED );
+#endif // CS_SHIELD_ENABLED
+ConVar cv_bot_join_team( "bot_join_team", "any", FCVAR_REPLICATED, "Determines the team bots will join into. Allowed values: 'any', 'T', or 'CT'." );
+ConVar cv_bot_join_after_player( "bot_join_after_player", "1", FCVAR_REPLICATED, "If nonzero, bots wait until a player joins before entering the game." );
+ConVar cv_bot_auto_vacate( "bot_auto_vacate", "1", FCVAR_REPLICATED, "If nonzero, bots will automatically leave to make room for human players." );
+ConVar cv_bot_zombie( "bot_zombie", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "If nonzero, bots will stay in idle mode and not attack." );
+ConVar cv_bot_defer_to_human( "bot_defer_to_human", "0", FCVAR_REPLICATED, "If nonzero and there is a human on the team, the bots will not do the scenario tasks." );
+ConVar cv_bot_chatter( "bot_chatter", "normal", FCVAR_REPLICATED, "Control how bots talk. Allowed values: 'off', 'radio', 'minimal', or 'normal'." );
+ConVar cv_bot_profile_db( "bot_profile_db", "BotProfile.db", FCVAR_REPLICATED, "The filename from which bot profiles will be read." );
+ConVar cv_bot_dont_shoot( "bot_dont_shoot", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "If nonzero, bots will not fire weapons (for debugging)." );
+ConVar cv_bot_eco_limit( "bot_eco_limit", "2000", FCVAR_REPLICATED, "If nonzero, bots will not buy if their money falls below this amount." );
+ConVar cv_bot_auto_follow( "bot_auto_follow", "0", FCVAR_REPLICATED, "If nonzero, bots with high co-op may automatically follow a nearby human player." );
+ConVar cv_bot_flipout( "bot_flipout", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "If nonzero, bots use no CPU for AI. Instead, they run around randomly." );
+
+
+extern void FinishClientPutInServer( CCSPlayer *pPlayer );
+
+
+//--------------------------------------------------------------------------------------------------------------
+// Engine callback for custom server commands
+void Bot_ServerCommand( void )
+{
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Constructor
+ */
+CCSBot::CCSBot( void ) : m_chatter( this ), m_gameState( this )
+{
+	m_hasJoined = false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Destructor
+ */
+CCSBot::~CCSBot()
+{
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Prepare bot for action
+ */
+bool CCSBot::Initialize( const BotProfile *profile, int team )
+{
+	// extend
+	BaseClass::Initialize( profile, team );
+
+	// CS bot initialization
+	m_diedLastRound = false;
+	m_morale = POSITIVE;			// starting a new round makes everyone a little happy
+
+	m_combatRange = RandomFloat( 325.0f, 425.0f );
+
+	// set initial safe time guess for this map
+	m_safeTime = 15.0f + 5.0f * GetProfile()->GetAggression();
+
+	m_name[0] = '\000';
+
+	ResetValues();
+
+	m_desiredTeam = team;
+
+	if (GetTeamNumber() == 0)
+	{
+		HandleCommand_JoinTeam( m_desiredTeam );
+		int desiredClass = GetProfile()->GetSkin();
+		if ( m_desiredTeam == TEAM_CT && desiredClass )
+		{
+			desiredClass = FIRST_CT_CLASS + desiredClass - 1;
+		}
+		else if ( m_desiredTeam == TEAM_TERRORIST && desiredClass )
+		{
+			desiredClass = FIRST_T_CLASS + desiredClass - 1;
+		}
+		HandleCommand_JoinClass( desiredClass );
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reset internal data to initial state
+ */
+void CCSBot::ResetValues( void )
+{
+	m_chatter.Reset();
+	m_gameState.Reset();
+
+	m_avoid = NULL;
+	m_avoidTimestamp = 0.0f;
+
+	m_hurryTimer.Invalidate();
+	m_alertTimer.Invalidate();
+	m_sneakTimer.Invalidate();
+	m_noiseBendTimer.Invalidate();
+	m_bendNoisePositionValid = false;
+
+	m_isStuck = false;
+	m_stuckTimestamp = 0.0f;
+	m_wiggleTimer.Invalidate();
+	m_stuckJumpTimer.Invalidate();
+
+	m_pathLength = 0;
+	m_pathIndex = 0;
+	m_areaEnteredTimestamp = 0.0f;
+	m_currentArea = NULL;
+	m_lastKnownArea = NULL;
+	m_isStopping = false;
+
+	m_avoidFriendTimer.Invalidate();
+	m_isFriendInTheWay = false;
+	m_isWaitingBehindFriend = false;
+	m_isAvoidingGrenade.Invalidate();
+
+	StopPanicking();
+
+	m_disposition = ENGAGE_AND_INVESTIGATE;
+
+	m_enemy = NULL;
+
+	m_grenadeTossState = NOT_THROWING;
+	m_initialEncounterArea = NULL;
+
+	m_wasSafe = true;
+
+	m_nearbyEnemyCount = 0;
+	m_enemyPlace = 0;
+	m_nearbyFriendCount = 0;
+	m_closestVisibleFriend = NULL;
+	m_closestVisibleHumanFriend = NULL;
+
+	for( int w=0; w<MAX_PLAYERS; ++w )
+	{
+		m_watchInfo[w].timestamp = 0.0f;
+		m_watchInfo[w].isEnemy = false;
+
+		m_playerTravelDistance[ w ] = -1.0f;
+	}
+
+	// randomly offset each bot's timer to spread computation out
+	m_updateTravelDistanceTimer.Start( RandomFloat( 0.0f, 0.9f ) );
+	m_travelDistancePhase = 0;
+
+	m_isEnemyVisible = false;
+	m_visibleEnemyParts = NONE;
+	m_lastSawEnemyTimestamp = -999.9f;
+	m_firstSawEnemyTimestamp = 0.0f;
+	m_currentEnemyAcquireTimestamp = 0.0f;
+	m_isLastEnemyDead = true;
+	m_attacker = NULL;
+	m_attackedTimestamp = 0.0f;
+	m_enemyDeathTimestamp = 0.0f;
+	m_friendDeathTimestamp = 0.0f;
+	m_lastVictimID = 0;
+	m_isAimingAtEnemy = false;
+	m_fireWeaponTimestamp = 0.0f;
+	m_equipTimer.Invalidate();
+	m_zoomTimer.Invalidate();
+
+	m_isFollowing = false;
+	m_leader = NULL;
+	m_followTimestamp = 0.0f;
+	m_allowAutoFollowTime = 0.0f;
+
+	m_enemyQueueIndex = 0;
+	m_enemyQueueCount = 0;
+	m_enemyQueueAttendIndex = 0;
+	m_bomber = NULL;
+
+	m_isEnemySniperVisible = false;
+	m_sawEnemySniperTimer.Invalidate();
+
+	m_lookAroundStateTimestamp = 0.0f;
+	m_inhibitLookAroundTimestamp = 0.0f;
+
+	m_lookPitch = 0.0f;
+	m_lookPitchVel = 0.0f;
+	m_lookYaw = 0.0f;
+	m_lookYawVel = 0.0f;
+
+	m_aimOffsetTimestamp = 0.0f;
+	m_aimSpreadTimestamp = 0.0f;
+	m_lookAtSpotState = NOT_LOOKING_AT_SPOT;
+
+	for( int p=0; p<MAX_PLAYERS; ++p )
+	{
+		m_partInfo[p].m_validFrame = 0;
+	}
+
+	m_spotEncounter = NULL;
+	m_spotCheckTimestamp = 0.0f;
+	m_peripheralTimestamp = 0.0f;
+
+	m_avgVelIndex = 0;
+	m_avgVelCount = 0;
+
+	m_lastOrigin = GetCentroid( this );
+
+	m_lastRadioCommand = RADIO_INVALID;
+	m_lastRadioRecievedTimestamp = 0.0f;
+	m_lastRadioSentTimestamp = 0.0f;
+	m_radioSubject = NULL;
+	m_voiceEndTimestamp = 0.0f;
+
+	m_hostageEscortCount = 0;
+	m_hostageEscortCountTimestamp = 0.0f;
+
+	m_noisePosition = Vector( 0, 0, 0 );
+	m_noiseTimestamp = 0.0f;
+
+	m_stateTimestamp = 0.0f;
+	m_task = SEEK_AND_DESTROY;
+	m_taskEntity = NULL;
+
+	m_approachPointCount = 0;
+	m_approachPointViewPosition.x = 99999999999.9f;
+	m_approachPointViewPosition.y = 0.0f;
+	m_approachPointViewPosition.z = 0.0f;
+
+	m_checkedHidingSpotCount = 0;
+
+	StandUp();
+	Run();
+	m_mustRunTimer.Invalidate();
+	m_waitTimer.Invalidate();
+	m_pathLadder = NULL;
+
+	m_repathTimer.Invalidate();
+
+	m_huntState.ClearHuntArea();
+	m_hasVisitedEnemySpawn = false;
+	m_stillTimer.Invalidate();
+
+	// adjust morale - if we died, our morale decreased, 
+	// but if we live, no adjustement (round win/loss also adjusts morale)
+	if (m_diedLastRound)
+		DecreaseMorale();
+
+	m_diedLastRound = false;
+
+
+	// IsRogue() randomly changes this
+	m_isRogue = false;	
+
+	m_surpriseTimer.Invalidate();
+
+	// even though these are EHANDLEs, they need to be NULL-ed
+	m_goalEntity = NULL;
+	m_avoid = NULL;
+	m_enemy = NULL;
+
+	for ( int i=0; i<MAX_ENEMY_QUEUE; ++i )
+	{
+		m_enemyQueue[i].player = NULL;
+		m_enemyQueue[i].isReloading = false;
+		m_enemyQueue[i].isProtectedByShield = false;
+	}
+
+	// start in idle state
+	m_isOpeningDoor = false;
+	StopAttacking();
+	Idle();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Called when bot is placed in map, and when bots are reset after a round ends.
+ * NOTE: For some reason, this can be called twice when a bot is added.
+ */
+void CCSBot::Spawn( void )
+{
+	// do the normal player spawn process
+	BaseClass::Spawn();
+
+	ResetValues();
+
+	V_strcpy_safe( m_name, GetPlayerName() );
+
+	Buy();
+}
+
diff --git a/game/server/cstrike/bot/cs_bot_listen.cpp b/game/server/cstrike/bot/cs_bot_listen.cpp
new file mode 100644
index 00000000..54e47e24
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_listen.cpp
@@ -0,0 +1,230 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//--------------------------------------------------------------------------------------------------------------
+bool CCSBot::IsNoiseHeard( void ) const
+{
+	if (m_noiseTimestamp <= 0.0f)
+		return false;
+
+	// primitive reaction time simulation - cannot "hear" noise until reaction time has elapsed
+	if (gpGlobals->curtime - m_noiseTimestamp >= GetProfile()->GetReactionTime())
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Listen for enemy noises, and determine if we should react to them.
+ * Returns true if heard a noise and should move to investigate.
+ */
+bool CCSBot::HeardInterestingNoise( void )
+{
+	if (IsBlind())
+		return false;
+
+	// don't investigate noises during safe time
+	if (!IsWellPastSafe())
+		return false;
+
+	// if our disposition is not to investigate, dont investigate
+	if (GetDisposition() != ENGAGE_AND_INVESTIGATE)
+		return false;
+
+	// listen for enemy noises
+	if (IsNoiseHeard())
+	{
+		// if we are hiding, only react to noises very nearby, depending on how aggressive we are
+		if (IsAtHidingSpot() && GetNoiseRange() > 100.0f + 400.0f * GetProfile()->GetAggression())
+			return false;
+		
+		// chance of investigating is inversely proportional to distance
+		const float maxNoiseDist = 3000.0f;
+		float chance = 100.0f * (1.0f - (GetNoiseRange()/maxNoiseDist));
+
+		// modify chance by number of friends remaining
+		// if we have lots of friends, presumably one of them is closer and will check it out
+		if (GetFriendsRemaining() >= 3)
+		{
+			float friendFactor = 5.0f * GetFriendsRemaining();
+			if (friendFactor > 50.0f)
+				friendFactor = 50.0f;
+
+			chance -= friendFactor;
+		}
+
+		if (RandomFloat( 0.0f, 100.0f ) <= chance)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we hear nearby threatening enemy gunfire within given range
+ * -1 == infinite range
+ */
+bool CCSBot::CanHearNearbyEnemyGunfire( float range ) const
+{
+	Vector myOrigin = GetCentroid( this );
+
+	// only attend to noise if it just happened
+	if (gpGlobals->curtime - m_noiseTimestamp > 0.5f)
+		return false;
+
+	// gunfire is high priority
+	if (m_noisePriority < PRIORITY_HIGH)
+		return false;
+
+	// check noise range
+	if (range > 0.0f && (myOrigin - m_noisePosition).IsLengthGreaterThan( range ))
+		return false;
+
+	// if we dont have line of sight, it's not threatening (cant get shot)
+	if (!CanSeeNoisePosition())
+		return false;
+
+	if (IsAttacking() && m_enemy != NULL && GetTimeSinceLastSawEnemy() < 1.0f)
+	{
+		// gunfire is only threatening if it is closer than our current enemy
+		float gunfireDistSq = (m_noisePosition - myOrigin).LengthSqr();
+		float enemyDistSq = (GetCentroid( m_enemy ) - myOrigin).LengthSqr();
+		const float muchCloserSq = 100.0f * 100.0f;
+		if (gunfireDistSq > enemyDistSq - muchCloserSq)
+			return false;
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we directly see where we think the noise came from
+ * NOTE: Dont check FOV, since this is used to determine if we should turn our head to look at the noise
+ * NOTE: Dont use IsVisible(), because smoke shouldnt cause us to not look toward noises
+ */
+bool CCSBot::CanSeeNoisePosition( void ) const
+{
+	trace_t result;
+	CTraceFilterNoNPCsOrPlayer traceFilter( this, COLLISION_GROUP_NONE );
+	UTIL_TraceLine( EyePositionConst(), m_noisePosition + Vector( 0, 0, HalfHumanHeight ), MASK_VISIBLE_AND_NPCS, &traceFilter, &result );
+	if (result.fraction == 1.0f)
+	{
+		// we can see the source of the noise
+		return true;
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we decided to look towards the most recent noise source
+ * Assumes m_noisePosition is valid.
+ */
+bool CCSBot::UpdateLookAtNoise( void )
+{
+	// make sure a noise exists
+	if (!IsNoiseHeard())
+	{
+		return false;
+	}
+
+	Vector spot;
+
+	// if we have clear line of sight to noise position, look directly at it
+	if (CanSeeNoisePosition())
+	{
+		/// @todo adjust noise Z to keep consistent with current height while fighting
+		spot = m_noisePosition + Vector( 0, 0, HalfHumanHeight );
+
+		// since we can see the noise spot, forget about it
+		ForgetNoise();
+	}
+	else
+	{
+		// line of sight is blocked, bend it
+
+		// the bending algorithm is very expensive, throttle how often it is done
+		if (m_noiseBendTimer.IsElapsed())
+		{
+			const float noiseBendLOSInterval = RandomFloat( 0.2f, 0.3f );
+			m_noiseBendTimer.Start( noiseBendLOSInterval );
+
+			// line of sight is blocked, bend it
+			if (BendLineOfSight( EyePosition(), m_noisePosition, &spot ) == false)
+			{
+				m_bendNoisePositionValid = false;
+				return false;
+			}
+
+			m_bentNoisePosition = spot;
+			m_bendNoisePositionValid = true;
+		}
+		else if (m_bendNoisePositionValid)
+		{
+			// use result of prior bend computation
+			spot = m_bentNoisePosition;
+		}
+		else
+		{
+			// prior bend failed
+			return false;
+		}
+	}
+
+	// it's always important to look at enemy noises, because they come from ... enemies!
+	PriorityType pri = PRIORITY_HIGH;
+
+	// look longer if we're hiding
+	if (IsAtHidingSpot())
+	{
+		// if there is only one enemy left, look for a long time
+		if (GetEnemiesRemaining() == 1)
+		{
+			SetLookAt( "Noise", spot, pri, RandomFloat( 5.0f, 15.0f ), true );
+		}
+		else
+		{
+			SetLookAt( "Noise", spot, pri, RandomFloat( 3.0f, 5.0f ), true );
+		}
+	}
+	else
+	{
+		const float closeRange = 500.0f;
+		if (GetNoiseRange() < closeRange)
+		{
+			// look at nearby enemy noises for a longer time
+			SetLookAt( "Noise", spot, pri, RandomFloat( 3.0f, 5.0f ), true );
+		}
+		else
+		{
+			SetLookAt( "Noise", spot, pri, RandomFloat( 1.0f, 2.0f ), true );
+		}
+	}
+
+	return true;
+}
+
diff --git a/game/server/cstrike/bot/cs_bot_manager.cpp b/game/server/cstrike/bot/cs_bot_manager.cpp
new file mode 100644
index 00000000..aec0ef36
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_manager.cpp
@@ -0,0 +1,2390 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#pragma warning( disable : 4530 )					// STL uses exceptions, but we are not compiling with them - ignore warning
+
+#include "cbase.h"
+
+#include "cs_bot.h"
+#include "nav_area.h"
+#include "cs_gamerules.h"
+#include "shared_util.h"
+#include "KeyValues.h"
+#include "tier0/icommandline.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#ifdef _WIN32
+#pragma warning (disable:4701)				// disable warning that variable *may* not be initialized 
+#endif
+
+CBotManager *TheBots = NULL;
+
+bool CCSBotManager::m_isMapDataLoaded = false;
+
+int g_nClientPutInServerOverrides = 0;
+
+
+void DrawOccupyTime( void );
+ConVar bot_show_occupy_time( "bot_show_occupy_time", "0", FCVAR_GAMEDLL | FCVAR_CHEAT, "Show when each nav area can first be reached by each team." );
+
+void DrawBattlefront( void );
+ConVar bot_show_battlefront( "bot_show_battlefront", "0", FCVAR_GAMEDLL | FCVAR_CHEAT, "Show areas where rushing players will initially meet." );
+
+int UTIL_CSSBotsInGame( void );
+
+ConVar bot_join_delay( "bot_join_delay", "0", FCVAR_GAMEDLL, "Prevents bots from joining the server for this many seconds after a map change." );
+
+/**
+ * Determine whether bots can be used or not
+ */
+inline bool AreBotsAllowed()
+{
+	// If they pass in -nobots, don't allow bots.  This is for people who host servers, to
+	// allow them to disallow bots to enforce CPU limits.
+	const char *nobots = CommandLine()->CheckParm( "-nobots" );
+	if ( nobots )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void InstallBotControl( void )
+{
+	if ( TheBots != NULL )
+		delete TheBots;
+
+	TheBots = new CCSBotManager;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void RemoveBotControl( void )
+{
+	if ( TheBots != NULL )
+		delete TheBots;
+
+	TheBots = NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CBasePlayer* ClientPutInServerOverride_Bot( edict_t *pEdict, const char *playername )
+{
+	CBasePlayer *pPlayer = TheBots->AllocateAndBindBotEntity( pEdict );
+	if ( pPlayer )
+	{
+		pPlayer->SetPlayerName( playername );
+	}
+	++g_nClientPutInServerOverrides;
+
+	return pPlayer;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+// Constructor
+CCSBotManager::CCSBotManager()
+{
+	m_zoneCount = 0;
+	SetLooseBomb( NULL );
+	m_serverActive = false;
+
+	m_isBombPlanted = false;
+	m_bombDefuser = NULL;
+	m_roundStartTimestamp = 0.0f;
+
+	m_eventListenersEnabled = true;
+	m_commonEventListeners.AddToTail( &m_PlayerFootstepEvent );
+	m_commonEventListeners.AddToTail( &m_PlayerRadioEvent );
+	m_commonEventListeners.AddToTail( &m_PlayerFallDamageEvent );
+	m_commonEventListeners.AddToTail( &m_BombBeepEvent );
+	m_commonEventListeners.AddToTail( &m_DoorMovingEvent );
+	m_commonEventListeners.AddToTail( &m_BreakPropEvent );
+	m_commonEventListeners.AddToTail( &m_BreakBreakableEvent );
+	m_commonEventListeners.AddToTail( &m_WeaponFireEvent );
+	m_commonEventListeners.AddToTail( &m_WeaponFireOnEmptyEvent );
+	m_commonEventListeners.AddToTail( &m_WeaponReloadEvent );
+	m_commonEventListeners.AddToTail( &m_WeaponZoomEvent );
+	m_commonEventListeners.AddToTail( &m_BulletImpactEvent );
+	m_commonEventListeners.AddToTail( &m_GrenadeBounceEvent );
+	m_commonEventListeners.AddToTail( &m_NavBlockedEvent );
+
+	TheBotPhrases = new BotPhraseManager;
+	TheBotProfiles = new BotProfileManager;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when a new round begins
+ */
+void CCSBotManager::RestartRound( void )
+{
+	// extend
+	CBotManager::RestartRound();
+
+	SetLooseBomb( NULL );
+	m_isBombPlanted = false;
+	m_earliestBombPlantTimestamp = gpGlobals->curtime + RandomFloat( 10.0f, 30.0f ); // 60
+	m_bombDefuser = NULL;
+
+	ResetRadioMessageTimestamps();
+
+	m_lastSeenEnemyTimestamp = -9999.9f;
+
+	m_roundStartTimestamp = gpGlobals->curtime + mp_freezetime.GetFloat();
+
+	// randomly decide if defensive team wants to "rush" as a whole
+	const float defenseRushChance = 33.3f;	// 25.0f;
+	m_isDefenseRushing = (RandomFloat( 0.0f, 100.0f ) <= defenseRushChance) ? true : false;
+
+	TheBotPhrases->OnRoundRestart();
+
+	m_isRoundOver = false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+
+void UTIL_DrawBox( Extent *extent, int lifetime, int red, int green, int blue )
+{
+	int darkRed = red/2;
+	int darkGreen = green/2;
+	int darkBlue = blue/2;
+
+	Vector v[8];
+	v[0].x = extent->lo.x; v[0].y = extent->lo.y; v[0].z = extent->lo.z;
+	v[1].x = extent->hi.x; v[1].y = extent->lo.y; v[1].z = extent->lo.z;
+	v[2].x = extent->hi.x; v[2].y = extent->hi.y; v[2].z = extent->lo.z;
+	v[3].x = extent->lo.x; v[3].y = extent->hi.y; v[3].z = extent->lo.z;
+	v[4].x = extent->lo.x; v[4].y = extent->lo.y; v[4].z = extent->hi.z;
+	v[5].x = extent->hi.x; v[5].y = extent->lo.y; v[5].z = extent->hi.z;
+	v[6].x = extent->hi.x; v[6].y = extent->hi.y; v[6].z = extent->hi.z;
+	v[7].x = extent->lo.x; v[7].y = extent->hi.y; v[7].z = extent->hi.z;
+
+	static int edge[] = 
+	{
+		1, 2, 3, 4, -1,
+		5, 6, 7, 8, -5,
+		1, -5,
+		2, -6,
+		3, -7,
+		4, -8,
+		0
+	};
+
+	Vector from, to;
+	bool restart = true;
+	for( int i=0; edge[i] != 0; ++i )
+	{
+		if (restart)
+		{
+			to = v[ edge[i]-1 ];
+			restart = false;
+			continue;
+		}
+		
+		from = to;
+
+		int index = edge[i];
+		if (index < 0)
+		{
+			restart = true;
+			index = -index;
+		}
+
+		to = v[ index-1 ];
+
+		NDebugOverlay::Line( from, to, darkRed, darkGreen, darkBlue, true, 0.1f );
+		NDebugOverlay::Line( from, to, red, green, blue, false, 0.15f );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::EnableEventListeners( bool enable )
+{
+	if ( m_eventListenersEnabled == enable )
+	{
+		return;
+	}
+
+	m_eventListenersEnabled = enable;
+
+	// enable/disable the most frequent event listeners, to improve performance when no bots are present.
+	for ( int i=0; i<m_commonEventListeners.Count(); ++i )
+	{
+		if ( enable )
+		{
+			gameeventmanager->AddListener( m_commonEventListeners[i], m_commonEventListeners[i]->GetEventName(), true );
+		}
+		else
+		{
+			gameeventmanager->RemoveListener( m_commonEventListeners[i] );
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Called each frame
+ */
+void CCSBotManager::StartFrame( void )
+{
+	if ( !AreBotsAllowed() )
+	{
+		EnableEventListeners( false );
+		return;
+	}
+
+	// EXTEND
+	CBotManager::StartFrame();
+
+	MaintainBotQuota();
+	EnableEventListeners( UTIL_CSSBotsInGame() > 0 );
+
+	// debug zone extent visualization
+	if (cv_bot_debug.GetInt() == 5)
+	{
+		for( int z=0; z<m_zoneCount; ++z )
+		{
+			Zone *zone = &m_zone[z];
+
+			if ( zone->m_isBlocked )
+			{
+				UTIL_DrawBox( &zone->m_extent, 1, 255, 0, 200 );
+			}
+			else
+			{
+				UTIL_DrawBox( &zone->m_extent, 1, 255, 100, 0 );
+			}
+		}
+	}
+
+	if (bot_show_occupy_time.GetBool())
+	{
+		DrawOccupyTime();
+	}
+
+	if (bot_show_battlefront.GetBool())
+	{
+		DrawBattlefront();
+	}
+
+	if ( m_checkTransientAreasTimer.IsElapsed() && !nav_edit.GetBool() )
+	{
+		CUtlVector< CNavArea * >& transientAreas = TheNavMesh->GetTransientAreas();
+		for ( int i=0; i<transientAreas.Count(); ++i )
+		{
+			CNavArea *area = transientAreas[i];
+			if ( area->GetAttributes() & NAV_MESH_TRANSIENT )
+			{
+				area->UpdateBlocked();
+			}
+		}
+
+		m_checkTransientAreasTimer.Start( 2.0f );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if the bot can use this weapon
+ */
+bool CCSBotManager::IsWeaponUseable( const CWeaponCSBase *weapon ) const
+{
+	if (weapon == NULL)
+		return false;
+
+	if (weapon->IsA( WEAPON_C4 ))
+		return true;
+
+	if ((!AllowShotguns() && weapon->IsKindOf( WEAPONTYPE_SHOTGUN )) ||
+		(!AllowMachineGuns() && weapon->IsKindOf( WEAPONTYPE_MACHINEGUN )) || 
+		(!AllowRifles() && weapon->IsKindOf( WEAPONTYPE_RIFLE )) || 
+		(!AllowShotguns() && weapon->IsKindOf( WEAPONTYPE_SHOTGUN )) || 
+		(!AllowSnipers() && weapon->IsKindOf( WEAPONTYPE_SNIPER_RIFLE )) || 
+		(!AllowSubMachineGuns() && weapon->IsKindOf( WEAPONTYPE_SUBMACHINEGUN )) || 
+		(!AllowPistols() && weapon->IsKindOf( WEAPONTYPE_PISTOL )) ||
+		(!AllowGrenades() && weapon->IsKindOf( WEAPONTYPE_GRENADE )))
+	{
+		return false;
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this player is on "defense"
+ */
+bool CCSBotManager::IsOnDefense( const CCSPlayer *player ) const
+{
+	switch (GetScenario())
+	{
+		case SCENARIO_DEFUSE_BOMB:
+			return (player->GetTeamNumber() == TEAM_CT);
+
+		case SCENARIO_RESCUE_HOSTAGES:
+			return (player->GetTeamNumber() == TEAM_TERRORIST);
+
+		case SCENARIO_ESCORT_VIP:
+			return (player->GetTeamNumber() == TEAM_TERRORIST);
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this player is on "offense"
+ */
+bool CCSBotManager::IsOnOffense( const CCSPlayer *player ) const
+{
+	return !IsOnDefense( player );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when a map has just been loaded
+ */
+void CCSBotManager::ServerActivate( void )
+{
+	m_isMapDataLoaded = false;
+
+	// load the database of bot radio chatter
+	TheBotPhrases->Reset();
+	TheBotPhrases->Initialize( "BotChatter.db", 0 );
+
+	TheBotProfiles->Reset();
+	TheBotProfiles->FindVoiceBankIndex( "BotChatter.db" ); // make sure default voice bank is first
+	const char *filename;
+	if ( false ) // g_engfuncs.pfnIsCareerMatch() )
+	{
+		filename = "MissionPacks/BotPackList.db";
+	}
+	else
+	{
+		filename = "BotPackList.db";
+	}
+
+	// read in the list of bot profile DBs
+	FileHandle_t file = filesystem->Open( filename, "r" );
+
+	if ( !file )
+	{
+		TheBotProfiles->Init( "BotProfile.db" );
+	}
+	else
+	{
+		int dataLength = filesystem->Size( filename );
+		char *dataPointer = new char[ dataLength ];
+
+		filesystem->Read( dataPointer, dataLength, file );
+		filesystem->Close( file );
+
+		const char *dataFile = SharedParse( dataPointer );
+		const char *token;
+
+		while ( dataFile )
+		{
+			token = SharedGetToken();
+			char *clone = CloneString( token );
+			TheBotProfiles->Init( clone );
+			delete[] clone;
+			dataFile = SharedParse( dataFile );
+		}
+
+		delete [] dataPointer;
+	}
+
+	// Now that we've parsed all the profiles, we have a list of the voice banks they're using.
+	// Go back and parse the custom voice speakables.
+	const BotProfileManager::VoiceBankList *voiceBanks = TheBotProfiles->GetVoiceBanks();
+	for ( int i=1; i<voiceBanks->Count(); ++i )
+	{
+		TheBotPhrases->Initialize( (*voiceBanks)[i], i );
+	}
+
+	// tell the Navigation Mesh system what CS spawn points are named
+	TheNavMesh->SetPlayerSpawnName( "info_player_terrorist" );
+
+	ExtractScenarioData();
+
+	RestartRound();
+
+	TheBotPhrases->OnMapChange();
+
+	m_serverActive = true;
+}
+
+
+void CCSBotManager::ServerDeactivate( void )
+{
+	m_serverActive = false;
+}
+
+void CCSBotManager::ClientDisconnect( CBaseEntity *entity )
+{
+/*
+	if ( FBitSet( entity->GetFlags(), FL_FAKECLIENT ) )
+	{
+		FREE_PRIVATE( entity );
+	}
+*/
+
+	/*
+	// make sure voice feedback is turned off
+	CBasePlayer *pPlayer = (CBasePlayer *)CBaseEntity::Instance( pEntity );
+	if ( pPlayer && pPlayer->IsBot() )
+	{
+		CCSBot *pBot = static_cast<CCSBot *>(pPlayer);
+		if (pBot)
+		{
+			pBot->EndVoiceFeedback( true );
+		}
+	}
+	*/
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+* Parses out bot name/template/etc params from the current ConCommand
+*/
+void BotArgumentsFromArgv( const CCommand &args, const char **name, CSWeaponType *weaponType, BotDifficultyType *difficulty, int *team = NULL, bool *all = NULL )
+{
+	static char s_name[MAX_PLAYER_NAME_LENGTH];
+
+	s_name[0] = 0;
+	*name = s_name;
+	*difficulty = NUM_DIFFICULTY_LEVELS;
+	if ( team )
+	{
+		*team = TEAM_UNASSIGNED;
+	}
+	if ( all )
+	{
+		*all = false;
+	}
+
+	*weaponType = WEAPONTYPE_UNKNOWN;
+
+	for ( int arg=1; arg<args.ArgC(); ++arg )
+	{
+		bool found = false;
+
+		const char *token = args[arg];
+		if ( all && FStrEq( token, "all" ) )
+		{
+			*all = true;
+			found = true;
+		}
+		else if ( team && FStrEq( token, "t" ) )
+		{
+			*team = TEAM_TERRORIST;
+			found = true;
+		}
+		else if ( team && FStrEq( token, "ct" ) )
+		{
+			*team = TEAM_CT;
+			found = true;
+		}
+
+		for( int i=0; i<NUM_DIFFICULTY_LEVELS && !found; ++i )
+		{
+			if (!stricmp( BotDifficultyName[i], token ))
+			{
+				*difficulty = (BotDifficultyType)i;
+				found = true;
+			}
+		}
+
+		if ( !found )
+		{
+			*weaponType = WeaponClassFromString( token );
+			if ( *weaponType != WEAPONTYPE_UNKNOWN )
+			{
+				found = true;
+			}
+		}
+
+		if ( !found )
+		{
+			Q_strncpy( s_name, token, sizeof( s_name ) );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_add, "bot_add <t|ct> <type> <difficulty> <name> - Adds a bot matching the given criteria.", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	const char *name;
+	BotDifficultyType difficulty;
+	CSWeaponType weaponType;
+	int team;
+	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty, &team );
+	TheCSBots()->BotAddCommand( team, FROM_CONSOLE, name, weaponType, difficulty );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_add_t, "bot_add_t <type> <difficulty> <name> - Adds a terrorist bot matching the given criteria.", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	const char *name;
+	BotDifficultyType difficulty;
+	CSWeaponType weaponType;
+	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty );
+	TheCSBots()->BotAddCommand( TEAM_TERRORIST, FROM_CONSOLE, name, weaponType, difficulty );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_add_ct, "bot_add_ct <type> <difficulty> <name> - Adds a Counter-Terrorist bot matching the given criteria.", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	const char *name;
+	BotDifficultyType difficulty;
+	CSWeaponType weaponType;
+	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty );
+	TheCSBots()->BotAddCommand( TEAM_CT, FROM_CONSOLE, name, weaponType, difficulty );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Collects all bots matching the given criteria (player name, profile template name, difficulty, and team)
+ */
+class CollectBots
+{
+public:
+	CollectBots( const char *name, CSWeaponType weaponType, BotDifficultyType difficulty, int team )
+	{
+		m_name = name;
+		m_difficulty = difficulty;
+		m_team = team;
+		m_weaponType = weaponType;
+	}
+
+	bool operator() ( CBasePlayer *player )
+	{
+		if ( !player->IsBot() )
+		{
+			return true;
+		}
+
+		CCSBot *bot = dynamic_cast< CCSBot * >(player);
+		if ( !bot || !bot->GetProfile() )
+		{
+			return true;
+		}
+
+		if ( m_name && *m_name )
+		{
+			// accept based on name
+			if ( FStrEq( m_name, bot->GetProfile()->GetName() ) )
+			{
+				m_bots.RemoveAll();
+				m_bots.AddToTail( bot );
+				return false;
+			}
+
+			// Reject based on profile template name
+			if ( !bot->GetProfile()->InheritsFrom( m_name ) )
+			{
+				return true;
+			}
+		}
+
+		// reject based on difficulty
+		if ( m_difficulty != NUM_DIFFICULTY_LEVELS )
+		{
+			if ( !bot->GetProfile()->IsDifficulty( m_difficulty ) )
+			{
+				return true;
+			}
+		}
+
+		// reject based on team
+		if ( m_team == TEAM_CT || m_team == TEAM_TERRORIST )
+		{
+			if ( bot->GetTeamNumber() != m_team )
+			{
+				return true;
+			}
+		}
+
+		// reject based on weapon preference
+		if ( m_weaponType != WEAPONTYPE_UNKNOWN )
+		{
+			if ( !bot->GetProfile()->GetWeaponPreferenceCount() )
+			{
+				return true;
+			}
+
+			if ( m_weaponType != WeaponClassFromWeaponID( (CSWeaponID)bot->GetProfile()->GetWeaponPreference( 0 ) ) )
+			{
+				return true;
+			}
+		}
+
+		// A match!
+		m_bots.AddToTail( bot );
+
+		return true;
+	}
+
+	CUtlVector< CCSBot * > m_bots;
+
+private:
+	const char *m_name;
+	CSWeaponType m_weaponType;
+	BotDifficultyType m_difficulty;
+	int m_team;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_kill, "bot_kill <all> <t|ct> <type> <difficulty> <name> - Kills a specific bot, or all bots, matching the given criteria.", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	const char *name;
+	BotDifficultyType difficulty;
+	CSWeaponType weaponType;
+	int team;
+	bool all;
+
+	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty, &team, &all );
+	if ( (!name || !*name) && team == TEAM_UNASSIGNED && difficulty == NUM_DIFFICULTY_LEVELS )
+	{
+		all = true;
+	}
+
+	CollectBots collector( name, weaponType, difficulty, team );
+	ForEachPlayer( collector );
+
+	for ( int i=0; i<collector.m_bots.Count(); ++i )
+	{
+		CCSBot *bot = collector.m_bots[i];
+		if ( !bot->IsAlive() )
+			continue;
+
+		bot->CommitSuicide();
+		
+		if ( !all )
+		{
+			return;
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_kick, "bot_kick <all> <t|ct> <type> <difficulty> <name> - Kicks a specific bot, or all bots, matching the given criteria.", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	const char *name;
+	BotDifficultyType difficulty;
+	CSWeaponType weaponType;
+	int team;
+	bool all;
+
+	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty, &team, &all );
+	if ( (!name || !*name) && team == TEAM_UNASSIGNED && difficulty == NUM_DIFFICULTY_LEVELS )
+	{
+		all = true;
+	}
+
+	CollectBots collector( name, weaponType, difficulty, team );
+	ForEachPlayer( collector );
+
+	for ( int i=0; i<collector.m_bots.Count(); ++i )
+	{
+		CCSBot *bot = collector.m_bots[i];
+		engine->ServerCommand( UTIL_VarArgs( "kick \"%s\"\n", bot->GetPlayerName() ) );
+		if ( !all )
+		{
+			// adjust bot quota so kicked bot is not immediately added back in
+			int newQuota = cv_bot_quota.GetInt() - 1;
+			cv_bot_quota.SetValue( clamp( newQuota, 0, cv_bot_quota.GetInt() ) );
+			return;
+		}
+	}
+
+	// adjust bot quota so kicked bot is not immediately added back in
+	if ( all && (!name || !*name) && team == TEAM_UNASSIGNED && difficulty == NUM_DIFFICULTY_LEVELS )
+	{
+		cv_bot_quota.SetValue( 0 );
+	}
+	else
+	{
+		int newQuota = cv_bot_quota.GetInt() - collector.m_bots.Count();
+		cv_bot_quota.SetValue( clamp( newQuota, 0, cv_bot_quota.GetInt() ) );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_knives_only, "Restricts the bots to only using knives", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	cv_bot_allow_pistols.SetValue( 0 );
+	cv_bot_allow_shotguns.SetValue( 0 );
+	cv_bot_allow_sub_machine_guns.SetValue( 0 );
+	cv_bot_allow_rifles.SetValue( 0 );
+	cv_bot_allow_machine_guns.SetValue( 0 );
+	cv_bot_allow_grenades.SetValue( 0 );
+	cv_bot_allow_snipers.SetValue( 0 );
+#ifdef CS_SHIELD_ENABLED
+	cv_bot_allow_shield.SetValue( 0 );
+#endif // CS_SHIELD_ENABLED
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_pistols_only, "Restricts the bots to only using pistols", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	cv_bot_allow_pistols.SetValue( 1 );
+	cv_bot_allow_shotguns.SetValue( 0 );
+	cv_bot_allow_sub_machine_guns.SetValue( 0 );
+	cv_bot_allow_rifles.SetValue( 0 );
+	cv_bot_allow_machine_guns.SetValue( 0 );
+	cv_bot_allow_grenades.SetValue( 0 );
+	cv_bot_allow_snipers.SetValue( 0 );
+#ifdef CS_SHIELD_ENABLED
+	cv_bot_allow_shield.SetValue( 0 );
+#endif // CS_SHIELD_ENABLED
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_snipers_only, "Restricts the bots to only using sniper rifles", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	cv_bot_allow_pistols.SetValue( 0 );
+	cv_bot_allow_shotguns.SetValue( 0 );
+	cv_bot_allow_sub_machine_guns.SetValue( 0 );
+	cv_bot_allow_rifles.SetValue( 0 );
+	cv_bot_allow_machine_guns.SetValue( 0 );
+	cv_bot_allow_grenades.SetValue( 0 );
+	cv_bot_allow_snipers.SetValue( 1 );
+#ifdef CS_SHIELD_ENABLED
+	cv_bot_allow_shield.SetValue( 0 );
+#endif // CS_SHIELD_ENABLED
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_all_weapons, "Allows the bots to use all weapons", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	cv_bot_allow_pistols.SetValue( 1 );
+	cv_bot_allow_shotguns.SetValue( 1 );
+	cv_bot_allow_sub_machine_guns.SetValue( 1 );
+	cv_bot_allow_rifles.SetValue( 1 );
+	cv_bot_allow_machine_guns.SetValue( 1 );
+	cv_bot_allow_grenades.SetValue( 1 );
+	cv_bot_allow_snipers.SetValue( 1 );
+#ifdef CS_SHIELD_ENABLED
+	cv_bot_allow_shield.SetValue( 1 );
+#endif // CS_SHIELD_ENABLED
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_goto_mark, "Sends a bot to the selected nav area (useful for testing navigation meshes)", FCVAR_GAMEDLL | FCVAR_CHEAT )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	// tell the first bot we find to go to our marked area
+	CNavArea *area = TheNavMesh->GetMarkedArea();
+	if (area)
+	{
+		for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+		{
+			CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+			if (player == NULL)
+				continue;
+	
+			if (player->IsBot())
+			{
+				CCSBot *bot = dynamic_cast<CCSBot *>( player );
+
+				if ( bot )
+				{
+					bot->MoveTo( area->GetCenter(), FASTEST_ROUTE );
+				}
+
+				break;
+			}
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+#if 0
+CON_COMMAND_F( bot_memory_usage, "Reports on the bots' memory usage", FCVAR_GAMEDLL )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	Msg( "Memory usage:\n" );
+
+	Msg( "  %d bytes per bot\n", sizeof(CCSBot) );
+
+	Msg( "  %d Navigation Areas @ %d bytes each = %d bytes\n", 
+					TheNavMesh->GetNavAreaCount(),
+					sizeof( CNavArea ),
+					TheNavMesh->GetNavAreaCount() * sizeof( CNavArea ) );
+
+	Msg( "  %d Hiding Spots @ %d bytes each = %d bytes\n", 
+					TheHidingSpotList.Count(),
+					sizeof( HidingSpot ),
+					TheHidingSpotList.Count() * sizeof( HidingSpot ) );
+
+/*
+	unsigned int encounterMem = 0;
+	FOR_EACH_LL( TheNavAreaList, it )
+	{
+		CNavArea *area = TheNavAreaList[ it ];
+
+		FOR_EACH_LL( area->m_spotEncounterList, it )
+		{
+			SpotEncounter *se = area->m_spotEncounterList[ it ];
+
+			encounterMem += sizeof( SpotEncounter );
+			encounterMem += se->spotList.Count() * sizeof( SpotOrder );
+		}
+	}
+
+	Msg( "  Encounter Spot data = %d bytes\n", encounterMem );
+*/
+}
+#endif
+
+
+bool CCSBotManager::ServerCommand( const char *cmd )
+{
+	return false;
+}
+
+
+bool CCSBotManager::ClientCommand( CBasePlayer *player, const CCommand &args )
+{
+	return false;
+}
+
+
+/**
+ * Process the "bot_add" console command
+ */
+bool CCSBotManager::BotAddCommand( int team, bool isFromConsole, const char *profileName, CSWeaponType weaponType, BotDifficultyType difficulty )
+{
+	if ( !TheNavMesh->IsLoaded() )
+	{
+		// If there isn't a Navigation Mesh in memory, create one
+		if ( !TheNavMesh->IsGenerating() )
+		{
+			if ( !m_isMapDataLoaded )
+			{
+				TheNavMesh->BeginGeneration();
+				m_isMapDataLoaded = true;
+			}
+			return false;
+		}
+	}
+
+	// dont allow bots to join if the Navigation Mesh is being generated
+	if (TheNavMesh->IsGenerating())
+		return false;
+
+	const BotProfile *profile = NULL;
+
+	if ( !isFromConsole )
+	{
+		profileName = NULL;
+		difficulty = GetDifficultyLevel();
+	}
+	else
+	{
+		if ( difficulty == NUM_DIFFICULTY_LEVELS )
+		{
+			difficulty = GetDifficultyLevel();
+		}
+
+		// if team not specified, check bot_join_team cvar for preference
+		if (team == TEAM_UNASSIGNED)
+		{
+			if (!stricmp( cv_bot_join_team.GetString(), "T" ))
+				team = TEAM_TERRORIST;
+			else if (!stricmp( cv_bot_join_team.GetString(), "CT" ))
+				team = TEAM_CT;
+			else
+				team = CSGameRules()->SelectDefaultTeam();
+		}
+	}
+
+	if ( profileName && *profileName )
+	{
+		// in career, ignore humans, since we want to add anyway
+		bool ignoreHumans = CSGameRules()->IsCareer();
+		if (UTIL_IsNameTaken( profileName, ignoreHumans ))
+		{
+			if ( isFromConsole )
+			{
+				Msg( "Error - %s is already in the game.\n", profileName );
+			}
+			return true;
+		}
+
+		// try to add a bot by name
+		profile = TheBotProfiles->GetProfile( profileName, team );
+		if ( !profile )
+		{
+			// try to add a bot by template
+			profile = TheBotProfiles->GetProfileMatchingTemplate( profileName, team, difficulty );
+			if ( !profile )
+			{
+				if ( isFromConsole )
+				{
+					Msg( "Error - no profile for '%s' exists.\n", profileName );
+				}
+				return true;
+			}
+		}
+	}
+	else
+	{
+		// if team not specified, check bot_join_team cvar for preference
+		if (team == TEAM_UNASSIGNED)
+		{
+			if (!stricmp( cv_bot_join_team.GetString(), "T" ))
+				team = TEAM_TERRORIST;
+			else if (!stricmp( cv_bot_join_team.GetString(), "CT" ))
+				team = TEAM_CT;
+			else
+				team = CSGameRules()->SelectDefaultTeam();
+		}
+
+		profile = TheBotProfiles->GetRandomProfile( difficulty, team, weaponType );
+		if (profile == NULL)
+		{
+			if ( isFromConsole )
+			{
+				Msg( "All bot profiles at this difficulty level are in use.\n" );
+			}
+			return true;
+		}
+	}
+
+	if (team == TEAM_UNASSIGNED || team == TEAM_SPECTATOR)
+	{
+		if ( isFromConsole )
+		{
+			Msg( "Could not add bot to the game: The game is full\n" );
+		}
+		return false;
+	}
+
+	if (CSGameRules()->TeamFull( team ))
+	{
+		if ( isFromConsole )
+		{
+			Msg( "Could not add bot to the game: Team is full\n" );
+		}
+		return false;
+	}
+
+	if (CSGameRules()->TeamStacked( team, TEAM_UNASSIGNED ))
+	{
+		if ( isFromConsole )
+		{
+			Msg( "Could not add bot to the game: Team is stacked (to disable this check, set mp_autoteambalance to zero, increase mp_limitteams, and restart the round).\n" );
+		}
+		return false;
+	}
+
+	// create the actual bot
+	CCSBot *bot = CreateBot<CCSBot>( profile, team );
+
+	if (bot == NULL)
+	{
+		if ( isFromConsole )
+		{
+			Msg( "Error: CreateBot() failed.\n" );
+		}
+		return false;
+	}
+
+	if (isFromConsole)
+	{
+		// increase the bot quota to account for manually added bot
+		cv_bot_quota.SetValue( cv_bot_quota.GetInt() + 1 );
+	}
+
+	return true;
+}
+
+int UTIL_CSSBotsInGame()
+{
+	int count = 0;
+
+	for (int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CCSBot *player = dynamic_cast<CCSBot *>(UTIL_PlayerByIndex( i ));
+
+		if ( player == NULL )
+			continue;
+
+		count++;
+	}
+
+	return count;
+}
+
+bool UTIL_CSSKickBotFromTeam( int kickTeam )
+{
+	int i;
+
+	// try to kick a dead bot first
+	for ( i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CCSBot *player = dynamic_cast<CCSBot *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		if (!player->IsAlive() && player->GetTeamNumber() == kickTeam)
+		{
+			// its a bot on the right team - kick it
+			engine->ServerCommand( UTIL_VarArgs( "kick \"%s\"\n", player->GetPlayerName() ) );
+
+			return true;
+		}
+	}
+
+	// no dead bots, kick any bot on the given team
+	for ( i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CCSBot *player = dynamic_cast<CCSBot *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		if (player->GetTeamNumber() == kickTeam)
+		{
+			// its a bot on the right team - kick it
+			engine->ServerCommand( UTIL_VarArgs( "kick \"%s\"\n", player->GetPlayerName() ) );
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Keep a minimum quota of bots in the game
+ */
+void CCSBotManager::MaintainBotQuota( void )
+{
+	if ( !AreBotsAllowed() )
+		return;
+
+	if (TheNavMesh->IsGenerating())
+		return;
+
+	int totalHumansInGame = UTIL_HumansInGame();
+	int humanPlayersInGame = UTIL_HumansInGame( IGNORE_SPECTATORS );
+
+	// don't add bots until local player has been registered, to make sure he's player ID #1
+	if (!engine->IsDedicatedServer() && totalHumansInGame == 0)
+		return;
+
+	// new players can't spawn immediately after the round has been going for some time
+	if ( !CSGameRules() || !TheCSBots() )
+	{
+		return;
+	}
+
+	int desiredBotCount = cv_bot_quota.GetInt();
+	int botsInGame = UTIL_CSSBotsInGame();
+
+	/// isRoundInProgress is true if the round has progressed far enough that new players will join as dead.
+	bool isRoundInProgress = CSGameRules()->m_bFirstConnected &&
+							 !TheCSBots()->IsRoundOver() &&
+							 ( CSGameRules()->GetRoundElapsedTime() >= 20.0f );
+
+	if ( FStrEq( cv_bot_quota_mode.GetString(), "fill" ) )
+	{
+		// If bot_quota_mode is 'fill', we want the number of bots and humans together to equal bot_quota
+		// unless the round is already in progress, in which case we play with what we've been dealt
+		if ( !isRoundInProgress )
+		{
+			desiredBotCount = MAX( 0, desiredBotCount - humanPlayersInGame );
+		}
+		else
+		{
+			desiredBotCount = botsInGame;
+		}
+	}
+	else if ( FStrEq( cv_bot_quota_mode.GetString(), "match" ) )
+	{
+		// If bot_quota_mode is 'match', we want the number of bots to be bot_quota * total humans
+		// unless the round is already in progress, in which case we play with what we've been dealt
+		if ( !isRoundInProgress )
+		{
+			desiredBotCount = (int)MAX( 0, cv_bot_quota.GetFloat() * humanPlayersInGame );
+		}
+		else
+		{
+			desiredBotCount = botsInGame;
+		}
+	}
+
+	// wait for a player to join, if necessary
+	if (cv_bot_join_after_player.GetBool())
+	{
+		if (humanPlayersInGame == 0)
+			desiredBotCount = 0;
+	}
+
+	// wait until the map has been loaded for a bit, to allow players to transition across
+	// the transition without missing the pistol round
+	if ( bot_join_delay.GetInt() > CSGameRules()->GetMapElapsedTime() )
+	{
+		desiredBotCount = 0;
+	}
+
+	// if bots will auto-vacate, we need to keep one slot open to allow players to join
+	if (cv_bot_auto_vacate.GetBool())
+		desiredBotCount = MIN( desiredBotCount, gpGlobals->maxClients - (humanPlayersInGame + 1) );
+	else
+		desiredBotCount = MIN( desiredBotCount, gpGlobals->maxClients - humanPlayersInGame );
+
+	// Try to balance teams, if we are in the first 20 seconds of a round and bots can join either team.
+	if ( botsInGame > 0 && desiredBotCount == botsInGame && CSGameRules()->m_bFirstConnected )
+	{
+		if ( CSGameRules()->GetRoundElapsedTime() < 20.0f ) // new bots can still spawn during this time
+		{
+			if ( mp_autoteambalance.GetBool() )
+			{
+				int numAliveTerrorist;
+				int numAliveCT;
+				int numDeadTerrorist;
+				int numDeadCT;
+				CSGameRules()->InitializePlayerCounts( numAliveTerrorist, numAliveCT, numDeadTerrorist, numDeadCT );
+
+				if ( !FStrEq( cv_bot_join_team.GetString(), "T" ) &&
+					 !FStrEq( cv_bot_join_team.GetString(), "CT" ) )
+				{
+					if ( numAliveTerrorist > CSGameRules()->m_iNumCT + 1 )
+					{
+						if ( UTIL_KickBotFromTeam( TEAM_TERRORIST ) )
+							return;
+					}
+					else if ( numAliveCT > CSGameRules()->m_iNumTerrorist + 1 )
+					{
+						if ( UTIL_KickBotFromTeam( TEAM_CT ) )
+							return;
+					}
+				}
+			}
+		}
+	}
+
+	// add bots if necessary
+	if (desiredBotCount > botsInGame)
+	{
+		// don't try to add a bot if all teams are full
+		if (!CSGameRules()->TeamFull( TEAM_TERRORIST ) || !CSGameRules()->TeamFull( TEAM_CT ))
+			TheCSBots()->BotAddCommand( TEAM_UNASSIGNED );
+	}
+	else if (desiredBotCount < botsInGame)
+	{
+		// kick a bot to maintain quota
+		
+		// first remove any unassigned bots
+		if (UTIL_CSSKickBotFromTeam( TEAM_UNASSIGNED ))
+			return;
+
+		int kickTeam;
+
+		// remove from the team that has more players
+		if (CSGameRules()->m_iNumTerrorist > CSGameRules()->m_iNumCT)
+		{
+			kickTeam = TEAM_TERRORIST;
+		}
+		else if (CSGameRules()->m_iNumTerrorist < CSGameRules()->m_iNumCT)
+		{
+			kickTeam = TEAM_CT;
+		}
+
+		// remove from the team that's winning
+		else if (CSGameRules()->m_iNumTerroristWins > CSGameRules()->m_iNumCTWins)
+		{
+			kickTeam = TEAM_TERRORIST;
+		}
+		else if (CSGameRules()->m_iNumCTWins > CSGameRules()->m_iNumTerroristWins)
+		{
+			kickTeam = TEAM_CT;
+		}
+		else
+		{
+			// teams and scores are equal, pick a team at random
+			kickTeam = (RandomInt( 0, 1 ) == 0) ? TEAM_CT : TEAM_TERRORIST;
+		}
+
+		// attempt to kick a bot from the given team
+		if (UTIL_CSSKickBotFromTeam( kickTeam ))
+			return;
+
+		// if there were no bots on the team, kick a bot from the other team
+		if (kickTeam == TEAM_TERRORIST)
+			UTIL_CSSKickBotFromTeam( TEAM_CT );
+		else
+			UTIL_CSSKickBotFromTeam( TEAM_TERRORIST );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Collect all nav areas that overlap the given zone
+ */
+class CollectOverlappingAreas
+{
+public:
+	CollectOverlappingAreas( CCSBotManager::Zone *zone )
+	{
+		m_zone = zone;
+
+		zone->m_areaCount = 0;
+	}
+
+	bool operator() ( CNavArea *area )
+	{
+		Extent areaExtent;
+		area->GetExtent(&areaExtent);
+
+		if (areaExtent.hi.x >= m_zone->m_extent.lo.x && areaExtent.lo.x <= m_zone->m_extent.hi.x &&
+			areaExtent.hi.y >= m_zone->m_extent.lo.y && areaExtent.lo.y <= m_zone->m_extent.hi.y &&
+			areaExtent.hi.z >= m_zone->m_extent.lo.z && areaExtent.lo.z <= m_zone->m_extent.hi.z)
+		{
+			// area overlaps m_zone
+			m_zone->m_area[ m_zone->m_areaCount++ ] = area;
+			if (m_zone->m_areaCount == CCSBotManager::MAX_ZONE_NAV_AREAS)
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+private:
+	CCSBotManager::Zone *m_zone;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Search the map entities to determine the game scenario and define important zones.
+ */
+void CCSBotManager::ExtractScenarioData( void )
+{
+	if (!TheNavMesh->IsLoaded())
+		return;
+
+	m_zoneCount = 0;
+	m_gameScenario = SCENARIO_DEATHMATCH;
+
+
+	//
+	// Search all entities in the map and set the game type and
+	// store all zones (bomb target, etc).
+	//
+	CBaseEntity *entity;
+	int i;
+	for( i=1; i<gpGlobals->maxEntities; ++i )
+	{
+		entity = CBaseEntity::Instance( engine->PEntityOfEntIndex( i ) );
+
+		if (entity == NULL)
+			continue;
+
+		bool found = false;
+		bool isLegacy = false;
+
+		if (FClassnameIs( entity, "func_bomb_target" ))
+		{
+			m_gameScenario = SCENARIO_DEFUSE_BOMB;
+			found = true;
+			isLegacy = false;
+		}
+		else if (FClassnameIs( entity, "info_bomb_target" ))
+		{
+			m_gameScenario = SCENARIO_DEFUSE_BOMB;
+			found = true;
+			isLegacy = true;
+		}
+		else if (FClassnameIs( entity, "func_hostage_rescue" ))
+		{
+			m_gameScenario = SCENARIO_RESCUE_HOSTAGES;
+			found = true;
+			isLegacy = false;
+		}
+		else if (FClassnameIs( entity, "info_hostage_rescue" ))
+		{
+			m_gameScenario = SCENARIO_RESCUE_HOSTAGES;
+			found = true;
+			isLegacy = true;
+		}
+		else if (FClassnameIs( entity, "hostage_entity" ))
+		{
+			// some very old maps (ie: cs_assault) use info_player_start
+			// as rescue zones, so set the scenario if there are hostages
+			// in the map
+			m_gameScenario = SCENARIO_RESCUE_HOSTAGES;
+		}
+		else if (FClassnameIs( entity, "func_vip_safetyzone" ))
+		{
+			m_gameScenario = SCENARIO_ESCORT_VIP;
+			found = true;
+			isLegacy = false;
+		}
+
+		if (found)
+		{
+			if (m_zoneCount < MAX_ZONES)
+			{
+				Vector absmin, absmax;
+				entity->CollisionProp()->WorldSpaceAABB( &absmin, &absmax );
+
+				m_zone[ m_zoneCount ].m_isBlocked = false;
+				m_zone[ m_zoneCount ].m_center = (isLegacy) ? entity->GetAbsOrigin() : (absmin + absmax)/2.0f;
+				m_zone[ m_zoneCount ].m_isLegacy = isLegacy;
+				m_zone[ m_zoneCount ].m_index = m_zoneCount;
+				m_zone[ m_zoneCount++ ].m_entity = entity;
+			}
+			else
+				Msg( "Warning: Too many zones, some will be ignored.\n" );
+		}
+	}
+
+	//
+	// If there are no zones and the scenario is hostage rescue,
+	// use the info_player_start entities as rescue zones.
+	//
+	if (m_zoneCount == 0 && m_gameScenario == SCENARIO_RESCUE_HOSTAGES)
+	{
+		for( entity = gEntList.FindEntityByClassname( NULL, "info_player_start" );
+			 entity && !FNullEnt( entity->edict() );
+			 entity = gEntList.FindEntityByClassname( entity, "info_player_start" ) )
+		{
+			if (m_zoneCount < MAX_ZONES)
+			{
+				m_zone[ m_zoneCount ].m_isBlocked = false;
+				m_zone[ m_zoneCount ].m_center = entity->GetAbsOrigin();
+				m_zone[ m_zoneCount ].m_isLegacy = true;
+				m_zone[ m_zoneCount ].m_index = m_zoneCount;
+				m_zone[ m_zoneCount++ ].m_entity = entity;
+			}
+			else
+			{
+				Msg( "Warning: Too many zones, some will be ignored.\n" );
+			}
+		}
+	}
+
+	//
+	// Collect nav areas that overlap each zone
+	//
+	for( i=0; i<m_zoneCount; ++i )
+	{
+		Zone *zone = &m_zone[i];
+
+		if (zone->m_isLegacy)
+		{
+			const float legacyRange = 256.0f;
+			zone->m_extent.lo.x = zone->m_center.x - legacyRange;
+			zone->m_extent.lo.y = zone->m_center.y - legacyRange;
+			zone->m_extent.lo.z = zone->m_center.z - legacyRange;
+			zone->m_extent.hi.x = zone->m_center.x + legacyRange;
+			zone->m_extent.hi.y = zone->m_center.y + legacyRange;
+			zone->m_extent.hi.z = zone->m_center.z + legacyRange;
+		}
+		else
+		{
+			Vector absmin, absmax;
+			zone->m_entity->CollisionProp()->WorldSpaceAABB( &absmin, &absmax );
+
+			zone->m_extent.lo = absmin;
+			zone->m_extent.hi = absmax;
+		}
+
+		// ensure Z overlap
+		const float zFudge = 50.0f;
+		zone->m_extent.lo.z -= zFudge;
+		zone->m_extent.hi.z += zFudge;
+
+		// build a list of nav areas that overlap this zone
+		CollectOverlappingAreas collector( zone );
+		TheNavMesh->ForAllAreas( collector );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the zone that contains the given position
+ */
+const CCSBotManager::Zone *CCSBotManager::GetZone( const Vector &pos ) const
+{
+	for( int z=0; z<m_zoneCount; ++z )
+	{
+		if (m_zone[z].m_extent.Contains( pos ))
+		{
+			return &m_zone[z];
+		}
+	}
+
+	return NULL;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest zone to the given position
+ */
+const CCSBotManager::Zone *CCSBotManager::GetClosestZone( const Vector &pos ) const
+{
+	const Zone *close = NULL;
+	float closeRangeSq = 999999999.9f;
+
+	for( int z=0; z<m_zoneCount; ++z )
+	{
+		if ( m_zone[z].m_isBlocked )
+			continue;
+
+		float rangeSq = (m_zone[z].m_center - pos).LengthSqr();
+
+		if (rangeSq < closeRangeSq)
+		{
+			closeRangeSq = rangeSq;
+			close = &m_zone[z];
+		}
+	}
+
+	return close;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return a random position inside the given zone
+ */
+const Vector *CCSBotManager::GetRandomPositionInZone( const Zone *zone ) const
+{
+	static Vector pos;
+
+	if (zone == NULL)
+		return NULL;
+
+	if (zone->m_areaCount == 0)
+		return NULL;
+
+	// pick a random overlapping area
+	CNavArea *area = GetRandomAreaInZone(zone);
+
+	// pick a location inside both the nav area and the zone
+	/// @todo Randomize this
+
+	if (zone->m_isLegacy)
+	{
+		/// @todo It is possible that the radius might not overlap this area at all...
+		area->GetClosestPointOnArea( zone->m_center, &pos );
+	}
+	else
+	{
+		Extent areaExtent;
+		area->GetExtent(&areaExtent);
+		Extent overlap;
+		overlap.lo.x = MAX( areaExtent.lo.x, zone->m_extent.lo.x );
+		overlap.lo.y = MAX( areaExtent.lo.y, zone->m_extent.lo.y );
+		overlap.hi.x = MIN( areaExtent.hi.x, zone->m_extent.hi.x );
+		overlap.hi.y = MIN( areaExtent.hi.y, zone->m_extent.hi.y );
+
+		pos.x = (overlap.lo.x + overlap.hi.x)/2.0f;
+		pos.y = (overlap.lo.y + overlap.hi.y)/2.0f;
+		pos.z = area->GetZ( pos );
+	}
+
+	return &pos;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return a random area inside the given zone
+ */
+CNavArea *CCSBotManager::GetRandomAreaInZone( const Zone *zone ) const
+{
+	int areaCount = zone->m_areaCount;
+	if( areaCount == 0 )
+	{
+		assert( false && "CCSBotManager::GetRandomAreaInZone: No areas for this zone" );
+		return NULL;
+	}
+
+	// Random, but weighted.  Jump areas score zero, since you aren't ever meant to stop on one of those.
+	// Avoid areas score 1 to a normal area's 20 because pathfinding treats Avoid as a 20x penalty.
+	int totalWeight = 0;
+	for( int areaIndex = 0; areaIndex < areaCount; areaIndex++ )
+	{
+		CNavArea *currentArea = zone->m_area[areaIndex];
+		if( currentArea->GetAttributes() & NAV_MESH_JUMP )
+			totalWeight += 0;
+		else if( currentArea->GetAttributes() & NAV_MESH_AVOID )
+			totalWeight += 1;
+		else
+			totalWeight += 20;
+	}
+
+	if( totalWeight == 0 )
+	{
+		assert( false && "CCSBotManager::GetRandomAreaInZone: No real areas for this zone" );
+		return NULL;
+	}
+
+	int randomPick = RandomInt( 1, totalWeight );
+
+	for( int areaIndex = 0; areaIndex < areaCount; areaIndex++ )
+	{
+		CNavArea *currentArea = zone->m_area[areaIndex];
+		if( currentArea->GetAttributes() & NAV_MESH_JUMP )
+			randomPick -= 0;
+		else if( currentArea->GetAttributes() & NAV_MESH_AVOID )
+			randomPick -= 1;
+		else
+			randomPick -= 20;
+
+		if( randomPick <= 0 )
+			return currentArea;
+	}
+
+	// Won't ever get here, but the compiler will cry without it.
+	return zone->m_area[0];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnServerShutdown( IGameEvent *event )
+{
+	if ( !engine->IsDedicatedServer() )
+	{
+		// Since we're a listenserver, save some config info for the next time we start up
+		static const char *botVars[] =
+		{
+			"bot_quota",
+			"bot_difficulty",
+			"bot_chatter",
+			"bot_prefix",
+			"bot_join_team",
+			"bot_defer_to_human",
+#ifdef CS_SHIELD_ENABLED
+			"bot_allow_shield",
+#endif // CS_SHIELD_ENABLED
+			"bot_join_after_player",
+			"bot_allow_rogues",
+			"bot_allow_pistols",
+			"bot_allow_shotguns",
+			"bot_allow_sub_machine_guns",
+			"bot_allow_machine_guns",
+			"bot_allow_rifles",
+			"bot_allow_snipers",
+			"bot_allow_grenades"
+		};
+		
+		KeyValues *data = new KeyValues( "ServerConfig" );
+
+		// load the config data
+		if (data)
+		{
+			data->LoadFromFile( filesystem, "ServerConfig.vdf", "GAME" );
+			for ( int i=0; i<sizeof(botVars)/sizeof(botVars[0]); ++i )
+			{
+				const char *varName = botVars[i];
+				if ( varName )
+				{
+					ConVar *var = cvar->FindVar( varName );
+					if ( var )
+					{
+						data->SetString( varName, var->GetString() );
+					}
+				}
+			}
+			data->SaveToFile( filesystem, "ServerConfig.vdf", "GAME" );
+			data->deleteThis();
+		}
+		return;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnPlayerFootstep( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnPlayerFootstep, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnPlayerRadio( IGameEvent *event )
+{
+	// if it's an Enemy Spotted radio, update our enemy spotted timestamp
+	if ( event->GetInt( "slot" ) == RADIO_ENEMY_SPOTTED )
+	{
+		// to have some idea of when a human Player has seen an enemy
+		SetLastSeenEnemyTimestamp();
+	}
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnPlayerRadio, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnPlayerDeath( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnPlayerDeath, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnPlayerFallDamage( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnPlayerFallDamage, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBombPickedUp( IGameEvent *event )
+{
+	// bomb no longer loose
+	SetLooseBomb( NULL );
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnBombPickedUp, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBombPlanted( IGameEvent *event )
+{
+	m_isBombPlanted = true;
+	m_bombPlantTimestamp = gpGlobals->curtime;
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnBombPlanted, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBombBeep( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnBombBeep, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBombDefuseBegin( IGameEvent *event )
+{
+	m_bombDefuser = static_cast<CCSPlayer *>( UTIL_PlayerByUserId( event->GetInt( "userid" ) ) );
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnBombDefuseBegin, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBombDefused( IGameEvent *event )
+{
+	m_isBombPlanted = false;
+	m_bombDefuser = NULL;
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnBombDefused, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBombDefuseAbort( IGameEvent *event )
+{
+	m_bombDefuser = NULL;
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnBombDefuseAbort, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBombExploded( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnBombExploded, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnRoundEnd( IGameEvent *event )
+{
+	m_isRoundOver = true;
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnRoundEnd, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnRoundStart( IGameEvent *event )
+{
+	RestartRound();
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnRoundStart, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+static CBaseEntity * SelectSpawnSpot( const char *pEntClassName )
+{
+	CBaseEntity* pSpot = NULL;
+
+	// Find the next spawn spot.
+	pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
+
+	if ( pSpot == NULL ) // skip over the null point
+		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
+
+	CBaseEntity *pFirstSpot = pSpot;
+	do 
+	{
+		if ( pSpot )
+		{
+			// check if pSpot is valid
+			if ( pSpot->GetAbsOrigin() == Vector( 0, 0, 0 ) )
+			{
+				pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
+				continue;
+			}
+
+			// if so, go to pSpot
+			return pSpot;
+		}
+		// increment pSpot
+		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
+	} while ( pSpot != pFirstSpot ); // loop if we're not back to the start
+
+	return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Pathfind from each zone to a spawn point to ensure it is valid.  Assumes that every spawn can pathfind to
+ * every other spawn.
+ */
+void CCSBotManager::CheckForBlockedZones( void )
+{
+	CBaseEntity *pSpot = SelectSpawnSpot( "info_player_counterterrorist" );
+	if ( !pSpot )
+		pSpot = SelectSpawnSpot( "info_player_terrorist" );
+
+	if ( !pSpot )
+		return;
+
+	Vector spawnPos = pSpot->GetAbsOrigin();
+	CNavArea *spawnArea = TheNavMesh->GetNearestNavArea( spawnPos );
+	if ( !spawnArea )
+		return;
+
+	ShortestPathCost costFunc;
+
+	for( int i=0; i<m_zoneCount; ++i )
+	{
+		if (m_zone[i].m_areaCount == 0)
+			continue;
+
+		// just use the first overlapping nav area as a reasonable approximation
+		float dist = NavAreaTravelDistance( spawnArea, m_zone[i].m_area[0], costFunc );
+		m_zone[i].m_isBlocked = (dist < 0.0f );
+
+		if ( cv_bot_debug.GetInt() == 5 )
+		{
+			if ( m_zone[i].m_isBlocked )
+				DevMsg( "%.1f: Zone %d, area %d (%.0f %.0f %.0f) is blocked from spawn area %d (%.0f %.0f %.0f)\n",
+					gpGlobals->curtime, i, m_zone[i].m_area[0]->GetID(),
+					m_zone[i].m_area[0]->GetCenter().x, m_zone[i].m_area[0]->GetCenter().y, m_zone[i].m_area[0]->GetCenter().z,
+					spawnArea->GetID(),
+					spawnPos.x, spawnPos.y, spawnPos.z );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnRoundFreezeEnd( IGameEvent *event )
+{
+	bool reenableEvents = m_NavBlockedEvent.IsEnabled();
+
+	m_NavBlockedEvent.Enable( false ); // don't listen to nav_blocked events - there could be several, and we don't have bots pathing
+	CUtlVector< CNavArea * >& transientAreas = TheNavMesh->GetTransientAreas();
+	for ( int i=0; i<transientAreas.Count(); ++i )
+	{
+		CNavArea *area = transientAreas[i];
+		if ( area->GetAttributes() & NAV_MESH_TRANSIENT )
+		{
+			area->UpdateBlocked();
+		}
+	}
+	if ( reenableEvents )
+	{
+		m_NavBlockedEvent.Enable( true );
+	}
+
+	CheckForBlockedZones();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnNavBlocked( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnNavBlocked, event );
+	CheckForBlockedZones();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnDoorMoving( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnDoorMoving, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Check all nav areas inside the breakable's extent to see if players would now fall through
+ */
+class CheckAreasOverlappingBreakable
+{
+public:
+	CheckAreasOverlappingBreakable( CBaseEntity *breakable )
+	{
+		m_breakable = breakable;
+		ICollideable *collideable = breakable->GetCollideable();
+		collideable->WorldSpaceSurroundingBounds( &m_breakableExtent.lo, &m_breakableExtent.hi );
+
+		const float expand = 10.0f;
+		m_breakableExtent.lo += Vector( -expand, -expand, -expand );
+		m_breakableExtent.hi += Vector(  expand,  expand,  expand );
+	}
+
+	bool operator() ( CNavArea *area )
+	{
+		Extent areaExtent;
+		area->GetExtent(&areaExtent);
+
+		if (areaExtent.hi.x >= m_breakableExtent.lo.x && areaExtent.lo.x <= m_breakableExtent.hi.x &&
+			areaExtent.hi.y >= m_breakableExtent.lo.y && areaExtent.lo.y <= m_breakableExtent.hi.y &&
+			areaExtent.hi.z >= m_breakableExtent.lo.z && areaExtent.lo.z <= m_breakableExtent.hi.z)
+		{
+			// area overlaps the breakable
+			area->CheckFloor( m_breakable );
+		}
+
+		return true;
+	}
+
+private:
+	Extent m_breakableExtent;
+	CBaseEntity *m_breakable;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBreakBreakable( IGameEvent *event )
+{
+	CheckAreasOverlappingBreakable collector( UTIL_EntityByIndex( event->GetInt( "entindex" ) ) );
+	TheNavMesh->ForAllAreas( collector );
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnBreakBreakable, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBreakProp( IGameEvent *event )
+{
+	CheckAreasOverlappingBreakable collector( UTIL_EntityByIndex( event->GetInt( "entindex" ) ) );
+	TheNavMesh->ForAllAreas( collector );
+
+	CCSBOTMANAGER_ITERATE_BOTS( OnBreakProp, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnHostageFollows( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnHostageFollows, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnHostageRescuedAll( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnHostageRescuedAll, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnWeaponFire( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnWeaponFire, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnWeaponFireOnEmpty( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnWeaponFireOnEmpty, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnWeaponReload( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnWeaponReload, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnWeaponZoom( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnWeaponZoom, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnBulletImpact( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnBulletImpact, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnHEGrenadeDetonate( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnHEGrenadeDetonate, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnFlashbangDetonate( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnFlashbangDetonate, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnSmokeGrenadeDetonate( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnSmokeGrenadeDetonate, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::OnGrenadeBounce( IGameEvent *event )
+{
+	CCSBOTMANAGER_ITERATE_BOTS( OnGrenadeBounce, event );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Get the time remaining before the planted bomb explodes
+ */
+float CCSBotManager::GetBombTimeLeft( void ) const
+{ 
+	return (mp_c4timer.GetFloat() - (gpGlobals->curtime - m_bombPlantTimestamp));
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBotManager::SetLooseBomb( CBaseEntity *bomb )
+{
+	m_looseBomb = bomb;
+
+	if (bomb)
+	{
+		m_looseBombArea = TheNavMesh->GetNearestNavArea( bomb->GetAbsOrigin() );
+	}
+	else
+	{
+		m_looseBombArea = NULL;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if player is important to scenario (VIP, bomb carrier, etc)
+ */
+bool CCSBotManager::IsImportantPlayer( CCSPlayer *player ) const
+{
+	switch (GetScenario())
+	{
+		case SCENARIO_DEFUSE_BOMB:
+		{
+			if (player->GetTeamNumber() == TEAM_TERRORIST && player->HasC4())
+				return true;
+
+			/// @todo TEAM_CT's defusing the bomb are important
+
+			return false;
+		}
+
+		case SCENARIO_ESCORT_VIP:
+		{
+			if (player->GetTeamNumber() == TEAM_CT && player->IsVIP())
+				return true;
+
+			return false;
+		}
+
+		case SCENARIO_RESCUE_HOSTAGES:
+		{
+			/// @todo TEAM_CT's escorting hostages are important
+			return false;
+		}
+	}
+
+	// everyone is equally important in a deathmatch
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return priority of player (0 = max pri)
+ */
+unsigned int CCSBotManager::GetPlayerPriority( CBasePlayer *player ) const
+{
+	const unsigned int lowestPriority = 0xFFFFFFFF;
+
+	if (!player->IsPlayer())
+		return lowestPriority;
+
+	// human players have highest priority
+	if (!player->IsBot())
+		return 0;
+
+	CCSBot *bot = dynamic_cast<CCSBot *>( player );
+
+	if ( !bot )
+		return 0;
+
+	// bots doing something important for the current scenario have high priority
+	switch (GetScenario())
+	{
+		case SCENARIO_DEFUSE_BOMB:
+		{
+			// the bomb carrier has high priority
+			if (bot->GetTeamNumber() == TEAM_TERRORIST && bot->HasC4())
+				return 1;
+
+			break;
+		}
+
+		case SCENARIO_ESCORT_VIP:
+		{
+			// the VIP has high priority
+			if (bot->GetTeamNumber() == TEAM_CT && bot->m_bIsVIP)
+				return 1;
+
+			break;
+		}
+
+		case SCENARIO_RESCUE_HOSTAGES:
+		{
+			// TEAM_CT's rescuing hostages have high priority
+			if (bot->GetTeamNumber() == TEAM_CT && bot->GetHostageEscortCount())
+				return 1;
+
+			break;
+		}
+	}
+
+	// everyone else is ranked by their unique ID (which cannot be zero)
+	return 1 + bot->GetID();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns a random spawn point for the given team (no arg means use both team spawnpoints)
+ */
+CBaseEntity *CCSBotManager::GetRandomSpawn( int team ) const
+{
+	CUtlVector< CBaseEntity * > spawnSet;
+	CBaseEntity *spot;
+
+	if (team == TEAM_TERRORIST || team == TEAM_MAXCOUNT)
+	{
+		// collect T spawns
+		for( spot = gEntList.FindEntityByClassname( NULL, "info_player_terrorist" );
+			 spot;
+			 spot = gEntList.FindEntityByClassname( spot, "info_player_terrorist" ) )
+		{
+			spawnSet.AddToTail( spot );			
+		}
+	}
+
+	if (team == TEAM_CT || team == TEAM_MAXCOUNT)
+	{
+		// collect CT spawns
+		for( spot = gEntList.FindEntityByClassname( NULL, "info_player_counterterrorist" );
+			 spot;
+			 spot = gEntList.FindEntityByClassname( spot, "info_player_counterterrorist" ) )
+		{
+			spawnSet.AddToTail( spot );			
+		}
+	}
+
+	if (spawnSet.Count() == 0)
+	{
+		return NULL;
+	}
+
+	// select one at random
+	int which = RandomInt( 0, spawnSet.Count()-1 );
+	return spawnSet[ which ];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the last time the given radio message was sent for given team
+ * 'teamID' can be TEAM_CT or TEAM_TERRORIST
+ */
+float CCSBotManager::GetRadioMessageTimestamp( RadioType event, int teamID ) const
+{
+	int i = (teamID == TEAM_TERRORIST) ? 0 : 1;
+
+	if (event > RADIO_START_1 && event < RADIO_END)
+		return m_radioMsgTimestamp[ event - RADIO_START_1 ][ i ];
+
+	return 0.0f;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the interval since the last time this message was sent
+ */
+float CCSBotManager::GetRadioMessageInterval( RadioType event, int teamID ) const
+{
+	int i = (teamID == TEAM_TERRORIST) ? 0 : 1;
+
+	if (event > RADIO_START_1 && event < RADIO_END)
+		return gpGlobals->curtime - m_radioMsgTimestamp[ event - RADIO_START_1 ][ i ];
+
+	return 99999999.9f;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Set the given radio message timestamp.
+ * 'teamID' can be TEAM_CT or TEAM_TERRORIST
+ */
+void CCSBotManager::SetRadioMessageTimestamp( RadioType event, int teamID )
+{
+	int i = (teamID == TEAM_TERRORIST) ? 0 : 1;
+
+	if (event > RADIO_START_1 && event < RADIO_END)
+		m_radioMsgTimestamp[ event - RADIO_START_1 ][ i ] = gpGlobals->curtime;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reset all radio message timestamps
+ */
+void CCSBotManager::ResetRadioMessageTimestamps( void )
+{
+	for( int t=0; t<2; ++t )
+	{
+		for( int m=0; m<(RADIO_END - RADIO_START_1); ++m )
+			m_radioMsgTimestamp[ m ][ t ] = 0.0f;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Display nav areas as they become reachable by each team
+ */
+void DrawOccupyTime( void )
+{
+	FOR_EACH_VEC( TheNavAreas, it )
+	{
+		CNavArea *area = TheNavAreas[ it ];
+
+		int r, g, b;
+		
+		if (TheCSBots()->GetElapsedRoundTime() > area->GetEarliestOccupyTime( TEAM_TERRORIST ))
+		{
+			if (TheCSBots()->GetElapsedRoundTime() > area->GetEarliestOccupyTime( TEAM_CT ))
+			{
+				r = 255; g = 0; b = 255;
+			}
+			else
+			{
+				r = 255; g = 0; b = 0;
+			}
+		}
+		else if (TheCSBots()->GetElapsedRoundTime() > area->GetEarliestOccupyTime( TEAM_CT ))
+		{
+			r = 0; g = 0; b = 255;
+		}
+		else
+		{
+			continue;
+		}
+
+		const Vector &nw = area->GetCorner( NORTH_WEST );
+		const Vector &ne = area->GetCorner( NORTH_EAST );
+		const Vector &sw = area->GetCorner( SOUTH_WEST );
+		const Vector &se = area->GetCorner( SOUTH_EAST );
+
+		NDebugOverlay::Line( nw, ne, r, g, b, true, 0.1f );		
+		NDebugOverlay::Line( nw, sw, r, g, b, true, 0.1f );		
+		NDebugOverlay::Line( se, sw, r, g, b, true, 0.1f );		
+		NDebugOverlay::Line( se, ne, r, g, b, true, 0.1f );		
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Display areas where players will likely have initial battles
+ */
+void DrawBattlefront( void )
+{
+	const float epsilon = 1.0f;
+	int r = 255, g = 50, b = 0;
+	
+	FOR_EACH_VEC( TheNavAreas, it )
+	{
+		CNavArea *area = TheNavAreas[ it ];
+
+		if ( fabs(area->GetEarliestOccupyTime( TEAM_TERRORIST ) - area->GetEarliestOccupyTime( TEAM_CT )) > epsilon )
+		{
+			continue;
+		}
+
+
+		const Vector &nw = area->GetCorner( NORTH_WEST );
+		const Vector &ne = area->GetCorner( NORTH_EAST );
+		const Vector &sw = area->GetCorner( SOUTH_WEST );
+		const Vector &se = area->GetCorner( SOUTH_EAST );
+
+		NDebugOverlay::Line( nw, ne, r, g, b, true, 0.1f );		
+		NDebugOverlay::Line( nw, sw, r, g, b, true, 0.1f );		
+		NDebugOverlay::Line( se, sw, r, g, b, true, 0.1f );		
+		NDebugOverlay::Line( se, ne, r, g, b, true, 0.1f );		
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+static bool CheckAreaAgainstAllZoneAreas(CNavArea *queryArea)
+{
+	// A marked area means they just want to double check this one spot
+	int goalZoneCount = TheCSBots()->GetZoneCount();
+
+	for( int zoneIndex = 0; zoneIndex < goalZoneCount; zoneIndex++ )
+	{
+		const CCSBotManager::Zone *currentZone = TheCSBots()->GetZone(zoneIndex);
+
+		int zoneAreaCount = currentZone->m_areaCount;
+		for( int areaIndex = 0; areaIndex < zoneAreaCount; areaIndex++ )
+		{
+			CNavArea *zoneArea = currentZone->m_area[areaIndex];
+			// We need to be connected to every area in the zone, since we don't know what other code might pick for an area
+			ShortestPathCost cost;
+			if( NavAreaTravelDistance(queryArea, zoneArea, cost) == -1.0f )
+			{
+				Msg( "Area #%d is disconnected from goal area #%d.\n", 
+					queryArea->GetID(), 
+					zoneArea->GetID()
+					);
+				return false;
+			}
+		}
+
+	}
+	return true;
+}
+
+CON_COMMAND_F( nav_check_connectivity, "Checks to be sure every (or just the marked) nav area can get to every goal area for the map (hostages or bomb site).", FCVAR_CHEAT )
+{
+	//Nav command in here since very CS specific.
+
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	if ( TheNavMesh->GetMarkedArea() )
+	{
+		CNavArea *markedArea = TheNavMesh->GetMarkedArea();
+		bool fine = CheckAreaAgainstAllZoneAreas( markedArea );
+		if( fine )
+		{
+			Msg( "Area #%d is connected to all goal areas.\n", markedArea->GetID() );
+		}
+	}
+	else
+	{
+		// Otherwise, loop through every area, and make sure they can all get to the goal.
+		float start = engine->Time();
+		FOR_EACH_VEC( TheNavAreas, nit )
+		{
+			CheckAreaAgainstAllZoneAreas(TheNavAreas[ nit ]);
+		}
+
+		float end = engine->Time();
+		float time = (end - start) * 1000.0f;
+		Msg( "nav_check_connectivity took %2.2f ms\n", time );
+	}
+}
+
+
+
+
diff --git a/game/server/cstrike/bot/cs_bot_manager.h b/game/server/cstrike/bot/cs_bot_manager.h
new file mode 100644
index 00000000..3f1da766
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_manager.h
@@ -0,0 +1,400 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#ifndef CS_CONTROL_H
+#define CS_CONTROL_H
+
+
+#include "bot_manager.h"
+#include "nav_area.h"
+#include "bot_util.h"
+#include "bot_profile.h"
+#include "cs_shareddefs.h"
+#include "cs_player.h"
+
+extern ConVar friendlyfire;
+
+class CBasePlayerWeapon;
+
+/**
+ * Given one team, return the other
+ */
+inline int OtherTeam( int team )
+{
+	return (team == TEAM_TERRORIST) ? TEAM_CT : TEAM_TERRORIST;
+}
+
+class CCSBotManager;
+
+// accessor for CS-specific bots
+inline CCSBotManager *TheCSBots( void )
+{
+	return reinterpret_cast< CCSBotManager * >( TheBots );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+class BotEventInterface : public IGameEventListener2
+{
+public:
+	virtual const char *GetEventName( void ) const = 0;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Macro to set up an OnEventClass() in TheCSBots.
+ */
+#define DECLARE_BOTMANAGER_EVENT_LISTENER( BotManagerSingleton, EventClass, EventName ) \
+	public: \
+	virtual void On##EventClass( IGameEvent *data ); \
+	private: \
+	class EventClass##Event : public BotEventInterface \
+	{ \
+		bool m_enabled; \
+	public: \
+		EventClass##Event( void ) \
+		{ \
+			gameeventmanager->AddListener( this, #EventName, true ); \
+			m_enabled = true; \
+		} \
+		~EventClass##Event( void ) \
+		{ \
+			if ( m_enabled ) gameeventmanager->RemoveListener( this ); \
+		} \
+		virtual const char *GetEventName( void ) const \
+		{ \
+			return #EventName; \
+		} \
+		void Enable( bool enable ) \
+		{ \
+			m_enabled = enable; \
+			if ( enable ) \
+				gameeventmanager->AddListener( this, #EventName, true ); \
+			else \
+				gameeventmanager->RemoveListener( this ); \
+		} \
+		bool IsEnabled( void ) const { return m_enabled; } \
+		void FireGameEvent( IGameEvent *event ) \
+		{ \
+			BotManagerSingleton()->On##EventClass( event ); \
+		} \
+	}; \
+	EventClass##Event m_##EventClass##Event;
+
+
+//--------------------------------------------------------------------------------------------------------------
+#define DECLARE_CSBOTMANAGER_EVENT_LISTENER( EventClass, EventName ) DECLARE_BOTMANAGER_EVENT_LISTENER( TheCSBots, EventClass, EventName )
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Macro to propogate an event from the bot manager to all bots
+ */
+#define CCSBOTMANAGER_ITERATE_BOTS( Callback, arg1 ) \
+	{ \
+		for ( int idx = 1; idx <= gpGlobals->maxClients; ++idx ) \
+		{ \
+			CBasePlayer *player = UTIL_PlayerByIndex( idx ); \
+			if (player == NULL) continue; \
+			if (!player->IsBot()) continue; \
+			CCSBot *bot = dynamic_cast< CCSBot * >(player); \
+			if ( !bot ) continue; \
+			bot->Callback( arg1 ); \
+		} \
+	}
+
+
+//--------------------------------------------------------------------------------------------------------------
+//
+// The manager for Counter-Strike specific bots
+//
+class CCSBotManager : public CBotManager
+{
+public:
+	CCSBotManager();
+
+	virtual CBasePlayer *AllocateBotEntity( void );			///< factory method to allocate the appropriate entity for the bot
+
+	virtual void ClientDisconnect( CBaseEntity *entity );
+	virtual bool ClientCommand( CBasePlayer *player, const CCommand &args );
+
+	virtual void ServerActivate( void );
+	virtual void ServerDeactivate( void );
+	virtual bool ServerCommand( const char *cmd );
+	bool IsServerActive( void ) const { return m_serverActive; }
+
+	virtual void RestartRound( void );						///< (EXTEND) invoked when a new round begins
+	virtual void StartFrame( void );						///< (EXTEND) called each frame
+
+	virtual unsigned int GetPlayerPriority( CBasePlayer *player ) const;	///< return priority of player (0 = max pri)
+	virtual bool IsImportantPlayer( CCSPlayer *player ) const;				///< return true if player is important to scenario (VIP, bomb carrier, etc)
+
+	void ExtractScenarioData( void );							///< search the map entities to determine the game scenario and define important zones
+
+	// difficulty levels -----------------------------------------------------------------------------------------
+	static BotDifficultyType GetDifficultyLevel( void )		
+	{ 
+		if (cv_bot_difficulty.GetFloat() < 0.9f)
+			return BOT_EASY;
+		if (cv_bot_difficulty.GetFloat() < 1.9f)
+			return BOT_NORMAL;
+		if (cv_bot_difficulty.GetFloat() < 2.9f)
+			return BOT_HARD;
+
+		return BOT_EXPERT;
+	}
+
+	// the supported game scenarios ------------------------------------------------------------------------------
+	enum GameScenarioType
+	{
+		SCENARIO_DEATHMATCH,
+		SCENARIO_DEFUSE_BOMB,
+		SCENARIO_RESCUE_HOSTAGES,
+		SCENARIO_ESCORT_VIP
+	};
+	GameScenarioType GetScenario( void ) const		{ return m_gameScenario; }
+
+	// "zones" ---------------------------------------------------------------------------------------------------
+	// depending on the game mode, these are bomb zones, rescue zones, etc.
+
+	enum { MAX_ZONES = 4 };										///< max # of zones in a map
+	enum { MAX_ZONE_NAV_AREAS = 16 };							///< max # of nav areas in a zone
+	struct Zone
+	{
+		CBaseEntity *m_entity;									///< the map entity
+		CNavArea *m_area[ MAX_ZONE_NAV_AREAS ];					///< nav areas that overlap this zone
+		int m_areaCount;
+		Vector m_center;
+		bool m_isLegacy;										///< if true, use pev->origin and 256 unit radius as zone
+		int m_index;
+		bool m_isBlocked;
+		Extent m_extent;
+	};
+
+	const Zone *GetZone( int i ) const				{ return &m_zone[i]; }
+	const Zone *GetZone( const Vector &pos ) const;				///< return the zone that contains the given position
+	const Zone *GetClosestZone( const Vector &pos ) const;		///< return the closest zone to the given position
+	const Zone *GetClosestZone( const CBaseEntity *entity ) const;	///< return the closest zone to the given entity
+	int GetZoneCount( void ) const					{ return m_zoneCount; }
+	void CheckForBlockedZones( void );
+
+
+	const Vector *GetRandomPositionInZone( const Zone *zone ) const;	///< return a random position inside the given zone
+	CNavArea *GetRandomAreaInZone( const Zone *zone ) const;			///< return a random area inside the given zone
+
+	/**
+	 * Return the zone closest to the given position, using the given cost heuristic
+	 */
+	template< typename CostFunctor >
+	const Zone *GetClosestZone( CNavArea *startArea, CostFunctor costFunc, float *travelDistance = NULL ) const
+	{
+		const Zone *closeZone = NULL;
+		float closeDist = 99999999.9f;
+
+		if (startArea == NULL)
+			return NULL;
+
+		for( int i=0; i<m_zoneCount; ++i )
+		{
+			if (m_zone[i].m_areaCount == 0)
+				continue;
+
+			if ( m_zone[i].m_isBlocked )
+				continue;
+
+			// just use the first overlapping nav area as a reasonable approximation
+			float dist = NavAreaTravelDistance( startArea, m_zone[i].m_area[0], costFunc );
+
+			if (dist >= 0.0f && dist < closeDist)
+			{
+				closeZone = &m_zone[i];
+				closeDist = dist;
+			}
+		}
+
+		if (travelDistance)
+			*travelDistance = closeDist;
+
+		return closeZone;
+	}
+
+	/// pick a zone at random and return it
+	const Zone *GetRandomZone( void ) const
+	{
+		if (m_zoneCount == 0)
+			return NULL;
+
+		int i;
+		CUtlVector< const Zone * > unblockedZones;
+		for ( i=0; i<m_zoneCount; ++i )
+		{
+			if ( m_zone[i].m_isBlocked )
+				continue;
+
+			unblockedZones.AddToTail( &(m_zone[i]) );
+		}
+
+		if ( unblockedZones.Count() == 0 )
+			return NULL;
+
+		return unblockedZones[ RandomInt( 0, unblockedZones.Count()-1 ) ];
+	}
+
+
+	/// returns a random spawn point for the given team (no arg means use both team spawnpoints)
+	CBaseEntity *GetRandomSpawn( int team = TEAM_MAXCOUNT ) const;
+
+
+	bool IsBombPlanted( void ) const			{ return m_isBombPlanted; }			///< returns true if bomb has been planted
+	float GetBombPlantTimestamp( void ) const	{ return m_bombPlantTimestamp; }	///< return time bomb was planted
+	bool IsTimeToPlantBomb( void ) const;											///< return true if it's ok to try to plant bomb
+	CCSPlayer *GetBombDefuser( void ) const		{ return m_bombDefuser; }			///< return the player currently defusing the bomb, or NULL
+	float GetBombTimeLeft( void ) const;											///< get the time remaining before the planted bomb explodes
+	CBaseEntity *GetLooseBomb( void )			{ return m_looseBomb; }				///< return the bomb if it is loose on the ground
+	CNavArea *GetLooseBombArea( void ) const	{ return m_looseBombArea; }			///< return area that bomb is in/near
+	void SetLooseBomb( CBaseEntity *bomb );
+
+
+	float GetRadioMessageTimestamp( RadioType event, int teamID ) const;			///< return the last time the given radio message was sent for given team
+	float GetRadioMessageInterval( RadioType event, int teamID ) const;				///< return the interval since the last time this message was sent
+	void SetRadioMessageTimestamp( RadioType event, int teamID );
+	void ResetRadioMessageTimestamps( void );
+
+	float GetLastSeenEnemyTimestamp( void ) const	{ return m_lastSeenEnemyTimestamp; }	///< return the last time anyone has seen an enemy
+	void SetLastSeenEnemyTimestamp( void ) 			{ m_lastSeenEnemyTimestamp = gpGlobals->curtime; }
+
+	float GetRoundStartTime( void ) const			{ return m_roundStartTimestamp; }
+	float GetElapsedRoundTime( void ) const			{ return gpGlobals->curtime - m_roundStartTimestamp; }	///< return the elapsed time since the current round began
+
+	bool AllowRogues( void ) const					{ return cv_bot_allow_rogues.GetBool(); }
+	bool AllowPistols( void ) const					{ return cv_bot_allow_pistols.GetBool(); }
+	bool AllowShotguns( void ) const				{ return cv_bot_allow_shotguns.GetBool(); }
+	bool AllowSubMachineGuns( void ) const			{ return cv_bot_allow_sub_machine_guns.GetBool(); }
+	bool AllowRifles( void ) const					{ return cv_bot_allow_rifles.GetBool(); }
+	bool AllowMachineGuns( void ) const				{ return cv_bot_allow_machine_guns.GetBool(); }
+	bool AllowGrenades( void ) const				{ return cv_bot_allow_grenades.GetBool(); }
+	bool AllowSnipers( void ) const					{ return cv_bot_allow_snipers.GetBool(); }
+#ifdef CS_SHIELD_ENABLED
+	bool AllowTacticalShield( void ) const			{ return cv_bot_allow_shield.GetBool(); }
+#else
+	bool AllowTacticalShield( void ) const			{ return false; }
+#endif // CS_SHIELD_ENABLED
+
+	bool AllowFriendlyFireDamage( void ) const		{ return friendlyfire.GetBool(); }
+
+	bool IsWeaponUseable( const CWeaponCSBase *weapon ) const;	///< return true if the bot can use this weapon
+
+	bool IsDefenseRushing( void ) const				{ return m_isDefenseRushing; }		///< returns true if defense team has "decided" to rush this round
+	bool IsOnDefense( const CCSPlayer *player ) const;		///< return true if this player is on "defense"
+	bool IsOnOffense( const CCSPlayer *player ) const;		///< return true if this player is on "offense"
+
+	bool IsRoundOver( void ) const					{ return m_isRoundOver; }		///< return true if the round has ended
+
+	#define FROM_CONSOLE true
+	bool BotAddCommand( int team, bool isFromConsole = false, const char *profileName = NULL, CSWeaponType weaponType = WEAPONTYPE_UNKNOWN, BotDifficultyType difficulty = NUM_DIFFICULTY_LEVELS );	///< process the "bot_add" console command
+
+private:
+	enum SkillType { LOW, AVERAGE, HIGH, RANDOM };
+
+	void MaintainBotQuota( void );
+
+	static bool m_isMapDataLoaded;							///< true if we've attempted to load map data
+	bool m_serverActive;									///< true between ServerActivate() and ServerDeactivate()
+
+	GameScenarioType m_gameScenario;						///< what kind of game are we playing
+
+	Zone m_zone[ MAX_ZONES ];							
+	int m_zoneCount;
+
+	bool m_isBombPlanted;									///< true if bomb has been planted
+	float m_bombPlantTimestamp;								///< time bomb was planted
+	float m_earliestBombPlantTimestamp;						///< don't allow planting until after this time has elapsed
+	CCSPlayer *m_bombDefuser;								///< the player currently defusing a bomb
+	EHANDLE m_looseBomb;									///< will be non-NULL if bomb is loose on the ground
+	CNavArea *m_looseBombArea;								///< area that bomb is is/near
+
+	bool m_isRoundOver;										///< true if the round has ended
+
+	CountdownTimer m_checkTransientAreasTimer;				///< when elapsed, all transient nav areas should be checked for blockage
+
+	float m_radioMsgTimestamp[ RADIO_END - RADIO_START_1 ][ 2 ];
+
+	float m_lastSeenEnemyTimestamp;
+	float m_roundStartTimestamp;							///< the time when the current round began
+
+	bool m_isDefenseRushing;								///< whether defensive team is rushing this round or not
+
+	// Event Handlers --------------------------------------------------------------------------------------------
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( PlayerFootstep,		player_footstep )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( PlayerRadio,			player_radio )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( PlayerDeath,			player_death )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( PlayerFallDamage,		player_falldamage )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombPickedUp,			bomb_pickup )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombPlanted,			bomb_planted )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombBeep,				bomb_beep )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombDefuseBegin,		bomb_begindefuse )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombDefused,			bomb_defused )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombDefuseAbort,		bomb_abortdefuse )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombExploded,			bomb_exploded )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( RoundEnd,				round_end )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( RoundStart,			round_start )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( RoundFreezeEnd,		round_freeze_end )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( DoorMoving,			door_moving )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BreakProp,				break_prop )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BreakBreakable,		break_breakable )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( HostageFollows,		hostage_follows )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( HostageRescuedAll,		hostage_rescued_all )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( WeaponFire,			weapon_fire )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( WeaponFireOnEmpty,		weapon_fire_on_empty )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( WeaponReload,			weapon_reload )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( WeaponZoom,			weapon_zoom )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BulletImpact,			bullet_impact )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( HEGrenadeDetonate,		hegrenade_detonate )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( FlashbangDetonate,		flashbang_detonate )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( SmokeGrenadeDetonate,	smokegrenade_detonate )
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( GrenadeBounce,			grenade_bounce )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( NavBlocked,			nav_blocked )
+
+	DECLARE_CSBOTMANAGER_EVENT_LISTENER( ServerShutdown,		server_shutdown )
+
+	CUtlVector< BotEventInterface * > m_commonEventListeners;	// These event listeners fire often, and can be disabled for performance gains when no bots are present.
+	bool m_eventListenersEnabled;
+	void EnableEventListeners( bool enable );
+};
+
+inline CBasePlayer *CCSBotManager::AllocateBotEntity( void )
+{
+	return static_cast<CBasePlayer *>( CreateEntityByName( "cs_bot" ) );
+}
+
+inline bool CCSBotManager::IsTimeToPlantBomb( void ) const
+{
+	return (gpGlobals->curtime >= m_earliestBombPlantTimestamp);
+}
+
+inline const CCSBotManager::Zone *CCSBotManager::GetClosestZone( const CBaseEntity *entity ) const
+{
+	if (entity == NULL)
+		return NULL;
+
+	Vector centroid = entity->GetAbsOrigin();
+	centroid.z += HalfHumanHeight;
+	return GetClosestZone( centroid );
+}
+
+#endif
diff --git a/game/server/cstrike/bot/cs_bot_nav.cpp b/game/server/cstrike/bot/cs_bot_nav.cpp
new file mode 100644
index 00000000..8406101d
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_nav.cpp
@@ -0,0 +1,963 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+#include "obstacle_pushaway.h"
+#include "fmtstr.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+const float NearBreakableCheckDist = 20.0f;
+const float FarBreakableCheckDist = 300.0f;
+
+#define DEBUG_BREAKABLES 0
+#define DEBUG_DOORS 0
+
+//--------------------------------------------------------------------------------------------------------------
+#if DEBUG_BREAKABLES
+static void DrawOutlinedQuad( const Vector &p1,
+							const Vector &p2,
+							const Vector &p3,
+							const Vector &p4,
+							int r, int g, int b,
+							float duration )
+{
+	NDebugOverlay::Triangle( p1, p2, p3, r, g, b, 20, false, duration );
+	NDebugOverlay::Triangle( p3, p4, p1, r, g, b, 20, false, duration );
+	NDebugOverlay::Line( p1, p2, r, g, b, false, duration );
+	NDebugOverlay::Line( p2, p3, r, g, b, false, duration );
+	NDebugOverlay::Line( p3, p4, r, g, b, false, duration );
+	NDebugOverlay::Line( p4, p1, r, g, b, false, duration );
+}
+ConVar bot_debug_breakable_duration( "bot_debug_breakable_duration", "30" );
+#endif // DEBUG_BREAKABLES
+
+
+//--------------------------------------------------------------------------------------------------------------
+CBaseEntity * CheckForEntitiesAlongSegment( const Vector &start, const Vector &end, const Vector &mins, const Vector &maxs, CPushAwayEnumerator *enumerator )
+{
+	CBaseEntity *entity = NULL;
+
+	Ray_t ray;
+	ray.Init( start, end, mins, maxs );
+
+	partition->EnumerateElementsAlongRay( PARTITION_ENGINE_SOLID_EDICTS, ray, false, enumerator );
+	if ( enumerator->m_nAlreadyHit > 0 )
+	{
+		entity = enumerator->m_AlreadyHit[0];
+	}
+
+#if DEBUG_BREAKABLES
+	if ( entity )
+	{
+		DrawOutlinedQuad( start + mins, start + maxs, end + maxs, end + mins, 255, 0, 0, bot_debug_breakable_duration.GetFloat() );
+	}
+	else
+	{
+		DrawOutlinedQuad( start + mins, start + maxs, end + maxs, end + mins, 0, 255, 0, 0.1 );
+	}
+#endif // DEBUG_BREAKABLES
+
+	return entity;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Look up to 'distance' units ahead on the bot's path for entities.  Returns the closest one.
+ */
+CBaseEntity * CCSBot::FindEntitiesOnPath( float distance, CPushAwayEnumerator *enumerator, bool checkStuck )
+{
+	Vector goal;
+
+	int pathIndex = FindPathPoint( distance, &goal, NULL );
+	bool isDegeneratePath = ( pathIndex == m_pathLength );
+	if ( isDegeneratePath )
+	{
+		goal = m_goalPosition;
+	}
+	goal.z += HalfHumanHeight;
+
+	Vector mins, maxs;
+	mins = Vector( 0, 0, -HalfHumanWidth );
+	maxs = Vector( 0, 0, HalfHumanHeight );
+
+	if ( distance <= NearBreakableCheckDist && m_isStuck && checkStuck )
+	{
+		mins = Vector( -HalfHumanWidth, -HalfHumanWidth, -HalfHumanWidth );
+		maxs = Vector( HalfHumanWidth, HalfHumanWidth, HalfHumanHeight );
+	}
+
+	CBaseEntity *entity = NULL;
+	if ( isDegeneratePath )
+	{
+		entity = CheckForEntitiesAlongSegment( WorldSpaceCenter(), m_goalPosition + Vector( 0, 0, HalfHumanHeight ), mins, maxs, enumerator );
+#if DEBUG_BREAKABLES
+		if ( entity )
+		{
+			NDebugOverlay::HorzArrow( WorldSpaceCenter(), m_goalPosition, 6, 0, 0, 255, 255, true, bot_debug_breakable_duration.GetFloat() );
+		}
+#endif // DEBUG_BREAKABLES
+	}
+	else
+	{
+		int startIndex = MAX( 0, m_pathIndex );
+		float distanceLeft = distance;
+		// HACK: start with an index one lower than normal, so we can trace from the bot's location to the
+		// start of the path nodes.
+		for( int i=startIndex-1; i<m_pathLength-1; ++i )
+		{
+			Vector start, end;
+			if ( i == startIndex - 1 )
+			{
+				start = GetAbsOrigin();
+				end = m_path[i+1].pos;
+			}
+			else
+			{
+				start = m_path[i].pos;
+				end = m_path[i+1].pos;
+
+				if ( m_path[i+1].how == GO_LADDER_UP )
+				{
+					// Need two checks.  First we'll check along the ladder
+					start = m_path[i].pos;
+					end = m_path[i+1].ladder->m_top;
+				}
+				else if ( m_path[i].how == GO_LADDER_UP )
+				{
+					start = m_path[i].ladder->m_top;
+				}
+				else if ( m_path[i+1].how == GO_LADDER_DOWN )
+				{
+					// Need two checks.  First we'll check along the ladder
+					start = m_path[i].pos;
+					end = m_path[i+1].ladder->m_bottom;
+				}
+				else if ( m_path[i].how == GO_LADDER_DOWN )
+				{
+					start = m_path[i].ladder->m_bottom;
+				}
+			}
+
+			float segmentLength = (start - end).Length();
+			if ( distanceLeft - segmentLength < 0 )
+			{
+				// scale our segment back so we don't look too far
+				Vector direction = end - start;
+				direction.NormalizeInPlace();
+
+				end = start + direction * distanceLeft;
+			}
+			entity = CheckForEntitiesAlongSegment( start + Vector( 0, 0, HalfHumanHeight ), end + Vector( 0, 0, HalfHumanHeight ), mins, maxs, enumerator );
+			if ( entity )
+			{
+#if DEBUG_BREAKABLES
+				NDebugOverlay::HorzArrow( start, end, 4, 0, 255, 0, 255, true, bot_debug_breakable_duration.GetFloat() );
+#endif // DEBUG_BREAKABLES
+				break;
+			}
+
+			if ( m_path[i].ladder && !IsOnLadder() && distance > NearBreakableCheckDist )	// don't try to break breakables on the other end of a ladder
+				break;
+
+			distanceLeft -= segmentLength;
+			if ( distanceLeft < 0 )
+				break;
+
+			if ( i != startIndex - 1 && m_path[i+1].ladder )
+			{
+				// Now we'll check from the ladder out to the endpoint
+				start = ( m_path[i+1].how == GO_LADDER_DOWN ) ? m_path[i+1].ladder->m_bottom : m_path[i+1].ladder->m_top;
+				end = m_path[i+1].pos;
+
+				entity = CheckForEntitiesAlongSegment( start + Vector( 0, 0, HalfHumanHeight ), end + Vector( 0, 0, HalfHumanHeight ), mins, maxs, enumerator );
+				if ( entity )
+				{
+#if DEBUG_BREAKABLES
+					NDebugOverlay::HorzArrow( start, end, 4, 0, 255, 0, 255, true, bot_debug_breakable_duration.GetFloat() );
+#endif // DEBUG_BREAKABLES
+					break;
+				}
+			}
+		}
+	}
+
+	if ( entity && !IsVisible( entity->WorldSpaceCenter(), false, entity ) )
+		return NULL;
+
+	return entity;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::PushawayTouch( CBaseEntity *pOther )
+{
+#if DEBUG_BREAKABLES
+	NDebugOverlay::EntityBounds( pOther, 255, 0, 0, 127, 0.1f );
+#endif // DEBUG_BREAKABLES
+
+	// if we're not stuck or crouched, we don't care
+	if ( !m_isStuck && !IsCrouching() )
+		return;
+
+	// See if it's breakable
+	CBaseEntity *props[1];
+	CBotBreakableEnumerator enumerator( props, ARRAYSIZE( props ) );
+	enumerator.EnumElement( pOther );
+
+	if ( enumerator.m_nAlreadyHit == 1 )
+	{
+		// it's breakable - try to shoot it.
+		SetLookAt( "Breakable", pOther->WorldSpaceCenter(), PRIORITY_HIGH, 0.1f, false, 5.0f, true );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Check for breakable physics props and other breakable entities.  We do this here instead of catching them
+ * in OnTouch() because players don't collide with physics props, so OnTouch() doesn't get called.  Also,
+ * looking ahead like this lets us anticipate when we'll need to break something, and do it before being
+ * stopped by it.
+ */
+void CCSBot::BreakablesCheck( void )
+{
+#if DEBUG_BREAKABLES
+	/*
+	// Debug code to visually mark all breakables near us
+	{
+		Ray_t ray;
+		Vector origin = WorldSpaceCenter();
+		Vector mins( -400, -400, -400 );
+		Vector maxs( 400, 400, 400 );
+		ray.Init( origin, origin, mins, maxs );
+
+		CBaseEntity *props[40];
+		CBotBreakableEnumerator enumerator( props, ARRAYSIZE( props ) );
+		partition->EnumerateElementsAlongRay( PARTITION_ENGINE_SOLID_EDICTS, ray, false, &enumerator );
+		for ( int i=0; i<enumerator.m_nAlreadyHit; ++i )
+		{
+			CBaseEntity *prop = props[i];
+			if ( prop && prop->m_takedamage == DAMAGE_YES )
+			{
+				CFmtStr msg;
+				const char *text = msg.sprintf( "%s, %d health", prop->GetClassname(), prop->m_iHealth );
+				if ( prop->m_iHealth > 200 )
+				{
+					NDebugOverlay::EntityBounds( prop, 255, 0, 0, 10, 0.2f );
+					prop->EntityText( 0, text, 0.2f, 255, 0, 0, 255 );
+				}
+				else
+				{
+					NDebugOverlay::EntityBounds( prop, 0, 255, 0, 10, 0.2f );
+					prop->EntityText( 0, text, 0.2f, 0, 255, 0, 255 );
+				}
+			}
+		}
+	}
+	*/
+#endif // DEBUG_BREAKABLES
+
+	if ( IsAttacking() )
+	{
+		// make sure we aren't running into a breakable trying to knife an enemy
+		if ( IsUsingKnife() && m_enemy != NULL )
+		{
+			CBaseEntity *breakables[1];
+			CBotBreakableEnumerator enumerator( breakables, ARRAYSIZE( breakables ) );
+
+			CBaseEntity *breakable = NULL;
+			Vector mins = Vector( -HalfHumanWidth, -HalfHumanWidth, -HalfHumanWidth );
+			Vector maxs = Vector( HalfHumanWidth, HalfHumanWidth, HalfHumanHeight );
+			breakable = CheckForEntitiesAlongSegment( WorldSpaceCenter(), m_enemy->WorldSpaceCenter(), mins, maxs, &enumerator );
+			if ( breakable )
+			{
+#if DEBUG_BREAKABLES
+				NDebugOverlay::HorzArrow( WorldSpaceCenter(), m_enemy->WorldSpaceCenter(), 6, 0, 0, 255, 255, true, bot_debug_breakable_duration.GetFloat() );
+#endif // DEBUG_BREAKABLES
+
+				// look at it (chances are we'll already be looking at it, since it's between us and our enemy)
+				SetLookAt( "Breakable", breakable->WorldSpaceCenter(), PRIORITY_HIGH, 0.1f, false, 5.0f, true );
+
+				// break it (again, don't wait: we don't have ammo, since we're using the knife, and we're looking mostly at it anyway)
+				PrimaryAttack();
+			}
+		}
+		return;
+	}
+
+	if ( !HasPath() )
+		return;
+
+	bool isNear = true;
+
+	// Check just in front of us on the path
+	CBaseEntity *breakables[4];
+	CBotBreakableEnumerator enumerator( breakables, ARRAYSIZE( breakables ) );
+	CBaseEntity *breakable = FindEntitiesOnPath( NearBreakableCheckDist, &enumerator, true );
+
+	// If we don't have an object right in front of us, check a ways out
+	if ( !breakable )
+	{
+		breakable = FindEntitiesOnPath( FarBreakableCheckDist, &enumerator, false );
+		isNear = false;
+	}
+
+	// Try to shoot a breakable we know about
+	if ( breakable )
+	{
+		// look at it
+		SetLookAt( "Breakable", breakable->WorldSpaceCenter(), PRIORITY_HIGH, 0.1f, false, 5.0f, true );
+	}
+
+	// break it
+	if ( IsLookingAtSpot( PRIORITY_HIGH ) && m_lookAtSpotAttack )
+	{
+		if ( IsUsingGrenade() || ( !isNear && IsUsingKnife() ) )
+		{
+			EquipBestWeapon( MUST_EQUIP );
+		}
+		else if ( GetActiveWeapon() && GetActiveWeapon()->m_flNextPrimaryAttack <= gpGlobals->curtime )
+		{
+			bool shouldShoot = IsLookingAtPosition( m_lookAtSpot, 10.0f );
+
+			if ( !shouldShoot )
+			{
+				CBaseEntity *breakables[1];
+				CBotBreakableEnumerator LOSbreakable( breakables, ARRAYSIZE( breakables ) );
+
+				// compute the unit vector along our view
+				Vector aimDir = GetViewVector();
+
+				// trace the potential bullet's path
+				trace_t result;
+				UTIL_TraceLine( EyePosition(), EyePosition() + FarBreakableCheckDist * aimDir, MASK_PLAYERSOLID, this, COLLISION_GROUP_NONE, &result );
+				if ( result.DidHitNonWorldEntity() )
+				{
+					LOSbreakable.EnumElement( result.m_pEnt );
+					if ( LOSbreakable.m_nAlreadyHit == 1 && LOSbreakable.m_AlreadyHit[0] == breakable )
+					{
+						shouldShoot = true;
+					}
+				}
+			}
+
+			shouldShoot = shouldShoot && !IsFriendInLineOfFire();
+
+			if ( shouldShoot )
+			{
+				PrimaryAttack();
+			}
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Check for doors that need +use to open.
+ */
+void CCSBot::DoorCheck( void )
+{
+	if ( IsAttacking() && !IsUsingKnife() )
+	{
+		// If we're attacking with a gun or nade, don't bother with doors.  If we're trying to
+		// knife someone, we might need to open a door.
+		m_isOpeningDoor = false;
+		return;
+	}
+
+	if ( !HasPath() )
+		return;
+
+	// Find any doors that need a +use to open just in front of us along the path.
+	CBaseEntity *doors[4];
+	CBotDoorEnumerator enumerator( doors, ARRAYSIZE( doors ) );
+	CBaseEntity *door = FindEntitiesOnPath( NearBreakableCheckDist, &enumerator, false );
+
+	if ( door )
+	{
+		if ( !IsLookingAtSpot( PRIORITY_HIGH ) )
+		{
+			if ( !IsOpeningDoor() )
+			{
+				OpenDoor( door );
+			}
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reset the stuck-checker.
+ */
+void CCSBot::ResetStuckMonitor( void )
+{
+	if (m_isStuck)
+	{
+		if (IsLocalPlayerWatchingMe() && cv_bot_debug.GetBool() && UTIL_GetListenServerHost())
+		{
+			CBasePlayer *localPlayer = UTIL_GetListenServerHost();
+			CSingleUserRecipientFilter filter( localPlayer );
+			EmitSound( filter, localPlayer->entindex(), "Bot.StuckSound" );
+		}
+	}
+
+	m_isStuck = false;
+	m_stuckTimestamp = 0.0f;
+	m_stuckJumpTimer.Invalidate();
+	m_avgVelIndex = 0;
+	m_avgVelCount = 0;
+
+	m_areaEnteredTimestamp = gpGlobals->curtime;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Test if we have become stuck
+ */
+void CCSBot::StuckCheck( void )
+{
+	if (m_isStuck)
+	{
+		// we are stuck - see if we have moved far enough to be considered unstuck
+		Vector delta = GetAbsOrigin() - m_stuckSpot;
+
+		const float unstuckRange = 75.0f;
+		if (delta.IsLengthGreaterThan( unstuckRange ))
+		{
+			// we are no longer stuck
+			ResetStuckMonitor();
+			PrintIfWatched( "UN-STUCK\n" );
+		}
+	}
+	else
+	{
+		// check if we are stuck
+
+		// compute average velocity over a short period (for stuck check)
+		Vector vel = GetAbsOrigin() - m_lastOrigin;
+
+		// if we are jumping, ignore Z
+		if (IsJumping())
+			vel.z = 0.0f;
+
+		// cannot be Length2D, or will break ladder movement (they are only Z)
+		float moveDist = vel.Length();
+
+		float deltaT = g_BotUpdateInterval;
+
+		m_avgVel[ m_avgVelIndex++ ] = moveDist/deltaT;
+
+		if (m_avgVelIndex == MAX_VEL_SAMPLES)
+			m_avgVelIndex = 0;
+
+		if (m_avgVelCount < MAX_VEL_SAMPLES)
+		{
+			m_avgVelCount++;
+		}
+		else
+		{
+			// we have enough samples to know if we're stuck
+
+			float avgVel = 0.0f;
+			for( int t=0; t<m_avgVelCount; ++t )
+				avgVel += m_avgVel[t];
+
+			avgVel /= m_avgVelCount;
+
+			// cannot make this velocity too high, or bots will get "stuck" when going down ladders
+			float stuckVel = (IsUsingLadder()) ? 10.0f : 20.0f;
+
+			if (avgVel < stuckVel)
+			{
+				// we are stuck - note when and where we initially become stuck
+				m_stuckTimestamp = gpGlobals->curtime;			
+				m_stuckSpot = GetAbsOrigin();
+				m_stuckJumpTimer.Start( RandomFloat( 0.3f, 0.75f ) );		// 1.0
+
+				PrintIfWatched( "STUCK\n" );
+				if (IsLocalPlayerWatchingMe() && cv_bot_debug.GetInt() > 0.0f && UTIL_GetListenServerHost())
+				{
+					CBasePlayer *localPlayer = UTIL_GetListenServerHost();
+					CSingleUserRecipientFilter filter( localPlayer );
+					EmitSound( filter, localPlayer->entindex(), "Bot.StuckStart" );
+				}
+
+				m_isStuck = true;
+			}
+		}
+	}
+
+	// always need to track this
+	m_lastOrigin = GetAbsOrigin();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Check if we need to jump due to height change
+ */
+bool CCSBot::DiscontinuityJump( float ground, bool onlyJumpDown, bool mustJump )
+{
+	// Don't try to jump if in the air.
+	if( !(GetFlags() & FL_ONGROUND) )
+	{
+		return false;
+	}
+
+	float dz = ground - GetFeetZ();
+
+	if (dz > StepHeight && !onlyJumpDown)
+	{
+		// dont restrict jump time when going up
+		if (Jump( MUST_JUMP ))
+		{
+			return true;
+		}
+	}
+	else if (!IsUsingLadder() && dz < -JumpHeight)
+	{
+		if (Jump( mustJump ))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Find "simple" ground height, treating current nav area as part of the floor
+ */
+bool CCSBot::GetSimpleGroundHeightWithFloor( const Vector &pos, float *height, Vector *normal )
+{
+	if (TheNavMesh->GetSimpleGroundHeight( pos, height, normal ))
+	{
+		// our current nav area also serves as a ground polygon
+		if (m_lastKnownArea && m_lastKnownArea->IsOverlapping( pos ))
+			*height = MAX( (*height), m_lastKnownArea->GetZ( pos ) );
+
+		return true;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Get our current radio chatter place
+ */
+Place CCSBot::GetPlace( void ) const
+{
+	if (m_lastKnownArea)
+		return m_lastKnownArea->GetPlace();
+
+	return UNDEFINED_PLACE;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move towards position, independant of view angle
+ */
+void CCSBot::MoveTowardsPosition( const Vector &pos )
+{
+	Vector myOrigin = GetCentroid( this );
+
+	//
+	// Jump up on ledges
+	// Because we may not be able to get to our goal position and enter the next
+	// area because our extent collides with a nearby vertical ledge, make sure
+	// we look far enough ahead to avoid this situation.
+	// Can't look too far ahead, or bots will try to jump up slopes.
+	//
+	// NOTE: We need to do this frequently to catch edges at the right time
+	// @todo Look ahead *along path* instead of straight line 
+	//
+	if ((m_lastKnownArea == NULL || !(m_lastKnownArea->GetAttributes() & NAV_MESH_NO_JUMP)) &&
+		!IsOnLadder())
+	{
+		float ground;
+		Vector aheadRay( pos.x - myOrigin.x, pos.y - myOrigin.y, 0 );
+		aheadRay.NormalizeInPlace();
+
+		// look far ahead to allow us to smoothly jump over gaps, ledges, etc
+		// only jump if ground is flat at lookahead spot to avoid jumping up slopes
+		bool jumped = false;
+		if (IsRunning())
+		{
+			const float farLookAheadRange = 80.0f;	// 60
+			Vector normal;
+			Vector stepAhead = myOrigin + farLookAheadRange * aheadRay;
+			stepAhead.z += HalfHumanHeight;
+
+			if (GetSimpleGroundHeightWithFloor( stepAhead, &ground, &normal ))
+			{
+				if (normal.z > 0.9f)
+					jumped = DiscontinuityJump( ground, ONLY_JUMP_DOWN );
+			}
+		}
+
+		if (!jumped)
+		{
+			// close up jumping
+			const float lookAheadRange = 30.0f;	// cant be less or will miss jumps over low walls
+			Vector stepAhead = myOrigin + lookAheadRange * aheadRay;
+			stepAhead.z += HalfHumanHeight;
+			if (GetSimpleGroundHeightWithFloor( stepAhead, &ground ))
+			{
+				jumped = DiscontinuityJump( ground );
+			}
+		}
+
+		if (!jumped)
+		{
+			// about to fall gap-jumping
+			const float lookAheadRange = 10.0f;
+			Vector stepAhead = myOrigin + lookAheadRange * aheadRay;
+			stepAhead.z += HalfHumanHeight;
+			if (GetSimpleGroundHeightWithFloor( stepAhead, &ground ))
+			{
+				jumped = DiscontinuityJump( ground, ONLY_JUMP_DOWN, MUST_JUMP );
+			}
+		}
+	}
+
+
+	// compute our current forward and lateral vectors
+	float angle = EyeAngles().y;
+
+	Vector2D dir( BotCOS(angle), BotSIN(angle) );
+	Vector2D lat( -dir.y, dir.x );
+
+	// compute unit vector to goal position
+	Vector2D to( pos.x - myOrigin.x, pos.y - myOrigin.y );
+	to.NormalizeInPlace();
+
+	// move towards the position independant of our view direction
+	float toProj = to.x * dir.x + to.y * dir.y;
+	float latProj = to.x * lat.x + to.y * lat.y;
+
+	const float c = 0.25f;	// 0.5
+	if (toProj > c)
+		MoveForward();
+	else if (toProj < -c)
+		MoveBackward();
+
+	// if we are avoiding someone via strafing, don't override
+	if (m_avoid != NULL)
+		return;
+
+	if (latProj >= c)
+		StrafeLeft();
+	else if (latProj <= -c)
+		StrafeRight();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move away from position, independant of view angle
+ */
+void CCSBot::MoveAwayFromPosition( const Vector &pos )
+{
+	// compute our current forward and lateral vectors
+	float angle = EyeAngles().y;
+
+	Vector2D dir( BotCOS(angle), BotSIN(angle) );
+	Vector2D lat( -dir.y, dir.x );
+
+	// compute unit vector to goal position
+	Vector2D to( pos.x - GetAbsOrigin().x, pos.y - GetAbsOrigin().y );
+	to.NormalizeInPlace();
+
+	// move away from the position independant of our view direction
+	float toProj = to.x * dir.x + to.y * dir.y;
+	float latProj = to.x * lat.x + to.y * lat.y;
+
+	const float c = 0.5f;
+	if (toProj > c)
+		MoveBackward();
+	else if (toProj < -c)
+		MoveForward();
+
+	if (latProj >= c)
+		StrafeRight();
+	else if (latProj <= -c)
+		StrafeLeft();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Strafe (sidestep) away from position, independant of view angle
+ */
+void CCSBot::StrafeAwayFromPosition( const Vector &pos )
+{
+	// compute our current forward and lateral vectors
+	float angle = EyeAngles().y;
+
+	Vector2D dir( BotCOS(angle), BotSIN(angle) );
+	Vector2D lat( -dir.y, dir.x );
+
+	// compute unit vector to goal position
+	Vector2D to( pos.x - GetAbsOrigin().x, pos.y - GetAbsOrigin().y );
+	to.NormalizeInPlace();
+
+	float latProj = to.x * lat.x + to.y * lat.y;
+
+	if (latProj >= 0.0f)
+		StrafeRight();
+	else
+		StrafeLeft();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * For getting un-stuck
+ */
+void CCSBot::Wiggle( void )
+{
+	if (IsCrouching())
+	{
+		return;
+	}
+
+	// for wiggling
+	if (m_wiggleTimer.IsElapsed())
+	{
+		m_wiggleDirection = (NavRelativeDirType)RandomInt( 0, 3 );
+		m_wiggleTimer.Start( RandomFloat( 0.3f, 0.5f ) );		// 0.3, 0.5
+	}
+
+	Vector forward, right;
+	EyeVectors( &forward, &right );
+
+	const float lookAheadRange = (m_lastKnownArea && (m_lastKnownArea->GetAttributes() & NAV_MESH_WALK)) ? 5.0f : 30.0f;
+	float ground;
+
+	switch( m_wiggleDirection )
+	{
+		case LEFT:
+		{
+			// don't move left if we will fall
+			Vector pos = GetAbsOrigin() - (lookAheadRange * right);
+
+			if (GetSimpleGroundHeightWithFloor( pos, &ground ))
+			{
+				if (GetAbsOrigin().z - ground < StepHeight)
+				{
+					StrafeLeft();
+				}
+			}
+			break;
+		}
+
+		case RIGHT:
+		{
+			// don't move right if we will fall
+			Vector pos = GetAbsOrigin() + (lookAheadRange * right);
+
+			if (GetSimpleGroundHeightWithFloor( pos, &ground ))
+			{
+				if (GetAbsOrigin().z - ground < StepHeight)
+				{
+					StrafeRight();
+				}
+			}
+			break;
+		}
+
+		case FORWARD:
+		{
+			// don't move forward if we will fall
+			Vector pos = GetAbsOrigin() + (lookAheadRange * forward);
+
+			if (GetSimpleGroundHeightWithFloor( pos, &ground ))
+			{
+				if (GetAbsOrigin().z - ground < StepHeight)
+				{
+					MoveForward();
+				}
+			}
+			break;
+		}
+
+		case BACKWARD:
+		{
+			// don't move backward if we will fall
+			Vector pos = GetAbsOrigin() - (lookAheadRange * forward);
+
+			if (GetSimpleGroundHeightWithFloor( pos, &ground ))
+			{
+				if (GetAbsOrigin().z - ground < StepHeight)
+				{
+					MoveBackward();
+				}
+			}
+			break;
+		}
+	}
+
+	if (m_stuckJumpTimer.IsElapsed() && m_lastKnownArea && !(m_lastKnownArea->GetAttributes() & NAV_MESH_NO_JUMP))
+	{
+		if (Jump())
+		{
+			m_stuckJumpTimer.Start( RandomFloat( 1.0f, 2.0f ) );
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine approach points from eye position and approach areas of current area
+ */
+void CCSBot::ComputeApproachPoints( void )
+{
+	m_approachPointCount = 0;
+
+	if (m_lastKnownArea == NULL)
+	{
+		return;
+	}
+
+	// assume we're crouching for now
+	Vector eye = GetCentroid( this ); // + pev->view_ofs;	// eye position
+
+	Vector ap;
+	float halfWidth;
+	for( int i=0; i<m_lastKnownArea->GetApproachInfoCount() && m_approachPointCount < MAX_APPROACH_POINTS; ++i )
+	{
+		const CCSNavArea::ApproachInfo *info = m_lastKnownArea->GetApproachInfo( i );
+
+		if (info->here.area == NULL || info->prev.area == NULL)
+		{
+			continue;
+		}
+
+		// compute approach point (approach area is "info->here")
+		if (info->prevToHereHow <= GO_WEST)
+		{
+			info->prev.area->ComputePortal( info->here.area, (NavDirType)info->prevToHereHow, &ap, &halfWidth );
+			ap.z = info->here.area->GetZ( ap );
+		}
+		else
+		{
+			// use the area's center as an approach point
+			ap = info->here.area->GetCenter();
+		}
+
+		// "bend" our line of sight around corners until we can see the approach point
+		Vector bendPoint;
+		if (BendLineOfSight( eye, ap + Vector( 0, 0, HalfHumanHeight ), &bendPoint ))
+		{
+			// put point on the ground
+			if (TheNavMesh->GetGroundHeight( bendPoint, &bendPoint.z ) == false)
+			{
+				bendPoint.z = ap.z;
+			}
+
+			m_approachPoint[ m_approachPointCount ].m_pos = bendPoint;
+			m_approachPoint[ m_approachPointCount ].m_area = info->here.area;
+			++m_approachPointCount;
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::DrawApproachPoints( void ) const
+{
+	for( int i=0; i<m_approachPointCount; ++i )
+	{
+		if (TheCSBots()->GetElapsedRoundTime() >= m_approachPoint[i].m_area->GetEarliestOccupyTime( OtherTeam( GetTeamNumber() ) ))
+			NDebugOverlay::Cross3D( m_approachPoint[i].m_pos, 10.0f, 255, 0, 255, true, 0.1f );
+		else
+			NDebugOverlay::Cross3D( m_approachPoint[i].m_pos, 10.0f, 100, 100, 100, true, 0.1f );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Find the approach point that is nearest to our current path, ahead of us
+ */
+bool CCSBot::FindApproachPointNearestPath( Vector *pos )
+{
+	if (!HasPath())
+		return false;
+
+	// make sure approach points are accurate
+	ComputeApproachPoints();
+
+	if (m_approachPointCount == 0)
+		return false;
+
+	Vector target = Vector( 0, 0, 0 ), close;
+	float targetRangeSq = 0.0f;
+	bool found = false;
+
+	int start = m_pathIndex;
+	int end = m_pathLength;
+
+	//
+	// We dont want the strictly closest point, but the farthest approach point
+	// from us that is near our path
+	//
+	const float nearPathSq = 10000.0f;	// (100)
+
+	for( int i=0; i<m_approachPointCount; ++i )
+	{
+		if (FindClosestPointOnPath( m_approachPoint[i].m_pos, start, end, &close ) == false)
+			continue;
+
+		float rangeSq = (m_approachPoint[i].m_pos - close).LengthSqr();
+		if (rangeSq > nearPathSq)
+			continue;
+
+		if (rangeSq > targetRangeSq)
+		{
+			target = close;
+			targetRangeSq = rangeSq;
+			found = true;
+		}
+	}
+
+	if (found)
+	{
+		*pos = target + Vector( 0, 0, HalfHumanHeight );
+		return true;	
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are at the/an enemy spawn right now
+ */
+bool CCSBot::IsAtEnemySpawn( void ) const
+{
+	CBaseEntity *spot;
+	const char *spawnName = (GetTeamNumber() == TEAM_TERRORIST) ? "info_player_counterterrorist" : "info_player_terrorist";
+
+	// check if we are at any of the enemy's spawn points
+	for( spot = gEntList.FindEntityByClassname( NULL, spawnName ); spot; spot = gEntList.FindEntityByClassname( spot, spawnName ) )
+	{
+		CNavArea *area = TheNavMesh->GetNearestNavArea( spot->WorldSpaceCenter() );
+		if (area && GetLastKnownArea() == area)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
diff --git a/game/server/cstrike/bot/cs_bot_pathfind.cpp b/game/server/cstrike/bot/cs_bot_pathfind.cpp
new file mode 100644
index 00000000..8604f9ba
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_pathfind.cpp
@@ -0,0 +1,2075 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#ifdef _WIN32
+#pragma warning (disable:4701)				// disable warning that variable *may* not be initialized 
+#endif
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Finds a point from which we can approach a descending ladder.  First it tries behind the ladder,
+ * then in front of ladder, based on LOS.  Once we know the direction, we snap to the aproaching nav
+ * area.  Returns true if we're approaching from behind the ladder.
+ */
+static bool FindDescendingLadderApproachPoint( const CNavLadder *ladder, const CNavArea *area, Vector *pos )
+{
+	*pos = ladder->m_top - ladder->GetNormal() * 2.0f * HalfHumanWidth;
+
+	trace_t result;
+	UTIL_TraceLine( ladder->m_top, *pos, MASK_PLAYERSOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &result );
+	if (result.fraction < 1.0f)
+	{
+		*pos = ladder->m_top + ladder->GetNormal() * 2.0f * HalfHumanWidth;
+
+		area->GetClosestPointOnArea( *pos, pos );
+	}
+
+	// Use a cross product to determine which side of the ladder 'pos' is on
+	Vector posToLadder = *pos - ladder->m_top;
+	float dot = posToLadder.Dot( ladder->GetNormal() );
+	return ( dot < 0.0f );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine actual path positions bot will move between along the path
+ */
+bool CCSBot::ComputePathPositions( void )
+{
+	if (m_pathLength == 0)
+		return false;
+
+	// start in first area's center
+	m_path[0].pos = m_path[0].area->GetCenter();
+	m_path[0].ladder = NULL;
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+
+	for( int i=1; i<m_pathLength; ++i )
+	{
+		const ConnectInfo *from = &m_path[ i-1 ];
+		ConnectInfo *to = &m_path[ i ];
+
+		if (to->how <= GO_WEST)		// walk along the floor to the next area
+		{
+			to->ladder = NULL;
+
+			// compute next point, keeping path as straight as possible
+			from->area->ComputeClosestPointInPortal( to->area, (NavDirType)to->how, from->pos, &to->pos );
+
+			// move goal position into the goal area a bit
+			const float stepInDist = 5.0f;		// how far to "step into" an area - must be less than min area size
+			AddDirectionVector( &to->pos, (NavDirType)to->how, stepInDist );
+
+			// we need to walk out of "from" area, so keep Z where we can reach it
+			to->pos.z = from->area->GetZ( to->pos );
+
+			// if this is a "jump down" connection, we must insert an additional point on the path
+			if (to->area->IsConnected( from->area, NUM_DIRECTIONS ) == false)
+			{
+				// this is a "jump down" link
+
+				// compute direction of path just prior to "jump down"
+				Vector2D dir;
+				DirectionToVector2D( (NavDirType)to->how, &dir );
+
+				// shift top of "jump down" out a bit to "get over the ledge"
+				const float pushDist = 75.0f; // 25.0f;
+				to->pos.x += pushDist * dir.x;
+				to->pos.y += pushDist * dir.y;
+
+				// insert a duplicate node to represent the bottom of the fall
+				if (m_pathLength < MAX_PATH_LENGTH-1)
+				{
+					// copy nodes down
+					for( int j=m_pathLength; j>i; --j )
+						m_path[j] = m_path[j-1];
+
+					// path is one node longer
+					++m_pathLength;
+
+					// move index ahead into the new node we just duplicated
+					++i;
+
+					m_path[i].pos.x = to->pos.x;
+					m_path[i].pos.y = to->pos.y;
+
+					// put this one at the bottom of the fall
+					m_path[i].pos.z = to->area->GetZ( m_path[i].pos );
+				}
+			}
+		}
+		else if (to->how == GO_LADDER_UP)		// to get to next area, must go up a ladder
+		{
+			// find our ladder
+			const NavLadderConnectVector *pLadders = from->area->GetLadders( CNavLadder::LADDER_UP );
+			int it;
+			for ( it = 0; it < pLadders->Count(); ++it)
+			{
+				CNavLadder *ladder = (*pLadders)[ it ].ladder;
+
+				// can't use "behind" area when ascending...
+				if (ladder->m_topForwardArea == to->area ||
+					ladder->m_topLeftArea == to->area ||
+					ladder->m_topRightArea == to->area)
+				{
+					to->ladder = ladder;
+					to->pos = ladder->m_bottom + ladder->GetNormal() * 2.0f * HalfHumanWidth;
+					break;
+				}
+			}
+
+			if (it == pLadders->Count())
+			{
+				PrintIfWatched( "ERROR: Can't find ladder in path\n" );
+				return false;
+			}
+		}
+		else if (to->how == GO_LADDER_DOWN)		// to get to next area, must go down a ladder
+		{
+			// find our ladder
+			const NavLadderConnectVector *pLadders = from->area->GetLadders( CNavLadder::LADDER_DOWN );
+			int it;
+			for ( it = 0; it < pLadders->Count(); ++it)
+			{
+				CNavLadder *ladder = (*pLadders)[ it ].ladder;
+
+				if (ladder->m_bottomArea == to->area)
+				{
+					to->ladder = ladder;
+
+					FindDescendingLadderApproachPoint( to->ladder, from->area, &to->pos );
+					break;
+				}
+			}
+
+			if (it == pLadders->Count())
+			{
+				PrintIfWatched( "ERROR: Can't find ladder in path\n" );
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * If next step of path uses a ladder, prepare to traverse it
+ */
+void CCSBot::SetupLadderMovement( void )
+{
+	if (m_pathIndex < 1 || m_pathLength == 0)
+		return;
+
+	const ConnectInfo *to = &m_path[ m_pathIndex ];
+	const ConnectInfo *from = &m_path[ m_pathIndex - 1 ];
+
+	if (to->ladder)
+	{
+		m_spotEncounter = NULL;
+		m_areaEnteredTimestamp = gpGlobals->curtime;
+
+		m_pathLadder = to->ladder;
+		m_pathLadderTimestamp = gpGlobals->curtime;
+
+		QAngle ladderAngles;
+		VectorAngles( m_pathLadder->GetNormal(), ladderAngles );
+
+		// to get to next area, we must traverse a ladder
+		if (to->how == GO_LADDER_UP)
+		{
+			m_pathLadderState = APPROACH_ASCENDING_LADDER;
+			m_pathLadderFaceIn = true;
+			PrintIfWatched( "APPROACH_ASCENDING_LADDER\n" );
+			m_goalPosition = m_pathLadder->m_bottom + m_pathLadder->GetNormal() * 2.0f * HalfHumanWidth;
+			m_lookAheadAngle = AngleNormalizePositive( ladderAngles[ YAW ] + 180.0f );
+		}
+		else
+		{
+			// try to mount ladder "face out" first
+			bool behind = FindDescendingLadderApproachPoint( m_pathLadder, from->area, &m_goalPosition );
+
+			if ( behind )
+			{
+				PrintIfWatched( "APPROACH_DESCENDING_LADDER (face out)\n" );
+				m_pathLadderState = APPROACH_DESCENDING_LADDER;
+				m_pathLadderFaceIn = false;
+				m_lookAheadAngle = ladderAngles[ YAW ];
+			}
+			else
+			{
+				PrintIfWatched( "APPROACH_DESCENDING_LADDER (face in)\n" );
+				m_pathLadderState = APPROACH_DESCENDING_LADDER;
+				m_pathLadderFaceIn = true;
+				m_lookAheadAngle = AngleNormalizePositive( ladderAngles[ YAW ] + 180.0f );
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/// @todo What about ladders whose top AND bottom are messed up?
+void CCSBot::ComputeLadderEndpoint( bool isAscending )
+{
+	trace_t result;
+	Vector from, to;
+
+	if (isAscending)
+	{
+		// find actual top in case m_pathLadder penetrates the ceiling
+		// trace from our chest height at m_pathLadder base
+		from = m_pathLadder->m_bottom + m_pathLadder->GetNormal() * HalfHumanWidth;
+		from.z = GetAbsOrigin().z + HalfHumanHeight;
+		to = m_pathLadder->m_top;
+	}
+	else
+	{
+		// find actual bottom in case m_pathLadder penetrates the floor
+		// trace from our chest height at m_pathLadder top
+		from = m_pathLadder->m_top + m_pathLadder->GetNormal() * HalfHumanWidth;
+		from.z = GetAbsOrigin().z + HalfHumanHeight;
+		to = m_pathLadder->m_bottom;
+	}
+
+	UTIL_TraceLine( from, m_pathLadder->m_bottom, MASK_PLAYERSOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &result );
+
+	if (result.fraction == 1.0f)
+		m_pathLadderEnd = to.z;
+	else
+		m_pathLadderEnd = from.z + result.fraction * (to.z - from.z);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Navigate our current ladder. Return true if we are doing ladder navigation.
+ * @todo Need Push() and Pop() for run/walk context to keep ladder speed contained.
+ */
+bool CCSBot::UpdateLadderMovement( void )
+{
+	if (m_pathLadder == NULL)
+		return false;
+
+	bool giveUp = false;
+
+	// check for timeout
+	const float ladderTimeoutDuration = 10.0f;
+	if (gpGlobals->curtime - m_pathLadderTimestamp > ladderTimeoutDuration && !cv_bot_debug.GetBool())
+	{
+		PrintIfWatched( "Ladder timeout!\n" );
+		giveUp = true;
+	}
+	else if (m_pathLadderState == APPROACH_ASCENDING_LADDER || 
+			 m_pathLadderState == APPROACH_DESCENDING_LADDER || 
+			 m_pathLadderState == ASCEND_LADDER || 
+			 m_pathLadderState == DESCEND_LADDER || 
+			 m_pathLadderState == DISMOUNT_ASCENDING_LADDER ||
+			 m_pathLadderState == MOVE_TO_DESTINATION)
+	{
+		if (m_isStuck)
+		{
+			PrintIfWatched( "Giving up ladder - stuck\n" );
+			giveUp = true;
+		}
+	}
+
+	if (giveUp)
+	{
+		// jump off ladder and give up
+		Jump( MUST_JUMP );
+		Wiggle();
+		ResetStuckMonitor();
+		DestroyPath();
+		Run();
+		return false;
+	}
+	else
+	{
+		ResetStuckMonitor();
+	}
+
+	Vector myOrigin = GetCentroid( this );
+
+	// check if somehow we totally missed the ladder
+	switch( m_pathLadderState )
+	{
+		case MOUNT_ASCENDING_LADDER:
+		case MOUNT_DESCENDING_LADDER:
+		case ASCEND_LADDER:
+		case DESCEND_LADDER:
+		{
+			const float farAway = 200.0f;
+			const Vector &ladderPos = (m_pathLadderState == MOUNT_ASCENDING_LADDER ||
+				m_pathLadderState == ASCEND_LADDER) ? m_pathLadder->m_bottom : m_pathLadder->m_top;
+			if ((ladderPos.AsVector2D() - myOrigin.AsVector2D()).IsLengthGreaterThan( farAway ))
+			{
+				PrintIfWatched( "Missed ladder\n" );
+				Jump( MUST_JUMP );
+				DestroyPath();
+				Run();
+				return false;
+			}
+			break;
+		}
+	}
+
+
+	m_areaEnteredTimestamp = gpGlobals->curtime;
+
+	const float tolerance = 10.0f;
+	const float closeToGoal = 25.0f;
+
+	switch( m_pathLadderState )
+	{
+		case APPROACH_ASCENDING_LADDER:
+		{
+			bool approached = false;
+
+			Vector2D d( myOrigin.x - m_goalPosition.x, myOrigin.y - m_goalPosition.y );
+
+			if (d.x * m_pathLadder->GetNormal().x + d.y * m_pathLadder->GetNormal().y < 0.0f)
+			{
+				Vector2D perp( -m_pathLadder->GetNormal().y, m_pathLadder->GetNormal().x );
+
+				if (fabs(d.x * perp.x + d.y * perp.y) < tolerance && d.Length() < closeToGoal)
+					approached = true;
+			}
+
+			// small radius will just slow them down a little for more accuracy in hitting their spot
+			const float walkRange = 50.0f;
+			if (d.IsLengthLessThan( walkRange ))
+			{
+				Walk();
+				StandUp();
+			}
+
+			if ( d.IsLengthLessThan( 100.0f ) )
+			{
+				if ( !IsOnLadder() && (m_pathLadder->m_bottom.z - GetAbsOrigin().z > JumpCrouchHeight ) )
+				{
+					// find yaw to directly aim at ladder
+					QAngle idealAngle;
+					VectorAngles( GetAbsVelocity(), idealAngle );
+					const float angleTolerance = 15.0f;
+					if (AnglesAreEqual( EyeAngles().y, idealAngle.y, angleTolerance ))
+					{
+						Jump();
+					}
+				}
+			}
+
+			/// @todo Check that we are on the ladder we think we are
+			if (IsOnLadder())
+			{
+				m_pathLadderState = ASCEND_LADDER;
+				PrintIfWatched( "ASCEND_LADDER\n" );
+
+				// find actual top in case m_pathLadder penetrates the ceiling
+				ComputeLadderEndpoint( true );
+			}
+			else if (approached)
+			{
+				// face the m_pathLadder
+				m_pathLadderState = FACE_ASCENDING_LADDER;
+				PrintIfWatched( "FACE_ASCENDING_LADDER\n" );
+			}
+			else
+			{
+				// move toward ladder mount point
+				MoveTowardsPosition( m_goalPosition );
+			}
+			break;
+		}
+
+		case APPROACH_DESCENDING_LADDER:
+		{
+			// fall check
+			if (GetFeetZ() <= m_pathLadder->m_bottom.z + HalfHumanHeight)
+			{
+				PrintIfWatched( "Fell from ladder.\n" );
+
+				m_pathLadderState = MOVE_TO_DESTINATION;
+				m_path[ m_pathIndex ].area->GetClosestPointOnArea( m_pathLadder->m_bottom, &m_goalPosition );
+				m_goalPosition += m_pathLadder->GetNormal() * HalfHumanWidth;
+
+				PrintIfWatched( "MOVE_TO_DESTINATION\n" );
+			}
+			else
+			{
+				bool approached = false;
+
+				Vector2D d( myOrigin.x - m_goalPosition.x, myOrigin.y - m_goalPosition.y );
+
+				if (d.x * m_pathLadder->GetNormal().x + d.y * m_pathLadder->GetNormal().y > 0.0f)
+				{
+					Vector2D perp( -m_pathLadder->GetNormal().y, m_pathLadder->GetNormal().x );
+
+					if (fabs(d.x * perp.x + d.y * perp.y) < tolerance && d.Length() < closeToGoal)
+						approached = true;
+				}
+
+				// if approaching ladder from the side or "ahead", walk
+				if (m_pathLadder->m_topBehindArea != m_lastKnownArea)
+				{
+					const float walkRange = 150.0f;
+					if (!IsCrouching() && d.IsLengthLessThan( walkRange ))
+						Walk();
+				}
+
+				/// @todo Check that we are on the ladder we think we are
+				if (IsOnLadder())
+				{
+					// we slipped onto the ladder - climb it
+					m_pathLadderState = DESCEND_LADDER;
+					Run();
+					PrintIfWatched( "DESCEND_LADDER\n" );
+
+					// find actual bottom in case m_pathLadder penetrates the floor
+					ComputeLadderEndpoint( false );
+				}
+				else if (approached)
+				{
+					// face the ladder
+					m_pathLadderState = FACE_DESCENDING_LADDER;
+					PrintIfWatched( "FACE_DESCENDING_LADDER\n" );
+				}
+				else
+				{
+					// move toward ladder mount point
+					MoveTowardsPosition( m_goalPosition );
+				}
+			}
+			break;
+		}
+
+		case FACE_ASCENDING_LADDER:
+		{
+			// find yaw to directly aim at ladder
+			Vector to = m_pathLadder->GetPosAtHeight(myOrigin.z) - myOrigin;
+
+			QAngle idealAngle;
+			VectorAngles( to, idealAngle );
+
+			if (m_path[ m_pathIndex ].area == m_pathLadder->m_topForwardArea)
+			{
+				m_pathLadderDismountDir = FORWARD;
+			}
+			else if (m_path[ m_pathIndex ].area == m_pathLadder->m_topLeftArea)
+			{
+				m_pathLadderDismountDir = LEFT;
+				idealAngle[ YAW ] = AngleNormalizePositive( idealAngle[ YAW ] + 90.0f );
+			}
+			else if (m_path[ m_pathIndex ].area == m_pathLadder->m_topRightArea)
+			{
+				m_pathLadderDismountDir = RIGHT;
+				idealAngle[ YAW ] = AngleNormalizePositive( idealAngle[ YAW ] - 90.0f );
+			}
+
+			const float angleTolerance = 5.0f;
+			if (AnglesAreEqual( EyeAngles().y, idealAngle.y, angleTolerance ))
+			{
+				// move toward ladder until we become "on" it
+				Run();
+				ResetStuckMonitor();
+				m_pathLadderState = MOUNT_ASCENDING_LADDER;
+				switch (m_pathLadderDismountDir)
+				{
+					case LEFT:		PrintIfWatched( "MOUNT_ASCENDING_LADDER LEFT\n" );		break;
+					case RIGHT:		PrintIfWatched( "MOUNT_ASCENDING_LADDER RIGHT\n" );		break;
+					default:		PrintIfWatched( "MOUNT_ASCENDING_LADDER FORWARD\n" );	break;
+				}
+			}
+			break;
+		}
+
+		case FACE_DESCENDING_LADDER:
+		{
+			// find yaw to directly aim at ladder
+			Vector to = m_pathLadder->GetPosAtHeight(myOrigin.z) - myOrigin;
+
+			QAngle idealAngle;
+			VectorAngles( to, idealAngle );
+
+			const float angleTolerance = 5.0f;
+			if (AnglesAreEqual( EyeAngles().y, idealAngle.y, angleTolerance ))
+			{
+				// move toward ladder until we become "on" it
+				m_pathLadderState = MOUNT_DESCENDING_LADDER;
+				ResetStuckMonitor();
+				PrintIfWatched( "MOUNT_DESCENDING_LADDER\n" );
+			}
+			break;
+		}
+
+		case MOUNT_ASCENDING_LADDER:
+			if (IsOnLadder())
+			{
+				m_pathLadderState = ASCEND_LADDER;
+				PrintIfWatched( "ASCEND_LADDER\n" );
+
+				// find actual top in case m_pathLadder penetrates the ceiling
+				ComputeLadderEndpoint( true );
+			}
+
+			// move toward ladder mount point
+			if ( !IsOnLadder() && (m_pathLadder->m_bottom.z - GetAbsOrigin().z > JumpCrouchHeight ) )
+			{
+				Jump();
+			}
+
+			switch( m_pathLadderDismountDir )
+			{
+				case RIGHT:		StrafeLeft();	break;
+				case LEFT:		StrafeRight();	break;
+				default:		MoveForward();	break;
+			}
+			break;
+
+		case MOUNT_DESCENDING_LADDER:
+			// fall check
+			if (GetFeetZ() <= m_pathLadder->m_bottom.z + HalfHumanHeight)
+			{
+				PrintIfWatched( "Fell from ladder.\n" );
+
+				m_pathLadderState = MOVE_TO_DESTINATION;
+				m_path[ m_pathIndex ].area->GetClosestPointOnArea( m_pathLadder->m_bottom, &m_goalPosition );
+				m_goalPosition += m_pathLadder->GetNormal() * HalfHumanWidth;
+
+				PrintIfWatched( "MOVE_TO_DESTINATION\n" );
+			}
+			else
+			{
+				if (IsOnLadder())
+				{
+					m_pathLadderState = DESCEND_LADDER;
+					PrintIfWatched( "DESCEND_LADDER\n" );
+
+					// find actual bottom in case m_pathLadder penetrates the floor
+					ComputeLadderEndpoint( false );
+				}
+
+				// move toward ladder mount point
+				MoveForward();
+			}
+			break;
+
+		case ASCEND_LADDER:
+			// run, so we can make our dismount jump to the side, if necessary
+			Run();
+
+			// if our destination area requires us to crouch, do it
+			if (m_path[ m_pathIndex ].area->GetAttributes() & NAV_MESH_CROUCH)
+				Crouch();
+
+			// did we reach the top?
+			if (GetFeetZ() >= m_pathLadderEnd)
+			{
+				// we reached the top - dismount
+				m_pathLadderState = DISMOUNT_ASCENDING_LADDER;
+				PrintIfWatched( "DISMOUNT_ASCENDING_LADDER\n" );
+
+				if (m_path[ m_pathIndex ].area == m_pathLadder->m_topForwardArea)
+					m_pathLadderDismountDir = FORWARD;
+				else if (m_path[ m_pathIndex ].area == m_pathLadder->m_topLeftArea)
+					m_pathLadderDismountDir = LEFT;
+				else if (m_path[ m_pathIndex ].area == m_pathLadder->m_topRightArea)
+					m_pathLadderDismountDir = RIGHT;
+
+				m_pathLadderDismountTimestamp = gpGlobals->curtime;
+			}
+			else if (!IsOnLadder())
+			{
+				// we fall off the ladder, repath
+				DestroyPath();
+				return false;
+			}
+
+			// move up ladder
+			switch( m_pathLadderDismountDir )
+			{
+				case RIGHT:		StrafeLeft();	break;
+				case LEFT:		StrafeRight();	break;
+				default:		MoveForward();	break;
+			}
+			break;
+
+		case DESCEND_LADDER:
+		{
+			Run();
+			float destHeight = m_pathLadderEnd;
+			if ( (m_path[ m_pathIndex ].area->GetAttributes() & NAV_MESH_NO_JUMP) == 0 )
+			{
+				destHeight += HalfHumanHeight;
+			}
+			if ( !IsOnLadder() || GetFeetZ() <= destHeight )
+			{
+				// we reached the bottom, or we fell off - dismount
+				m_pathLadderState = MOVE_TO_DESTINATION;
+				m_path[ m_pathIndex ].area->GetClosestPointOnArea( m_pathLadder->m_bottom, &m_goalPosition );
+				m_goalPosition += m_pathLadder->GetNormal() * HalfHumanWidth;
+
+				PrintIfWatched( "MOVE_TO_DESTINATION\n" );
+			}
+
+			// Move down ladder
+			MoveForward();
+
+			break;
+		}
+
+		case DISMOUNT_ASCENDING_LADDER:
+		{
+			if (gpGlobals->curtime - m_pathLadderDismountTimestamp >= 0.4f)
+			{
+				m_pathLadderState = MOVE_TO_DESTINATION;
+				m_path[ m_pathIndex ].area->GetClosestPointOnArea( myOrigin, &m_goalPosition );
+				PrintIfWatched( "MOVE_TO_DESTINATION\n" );
+			}
+
+			// We should already be facing the dismount point
+			MoveForward();
+			break;
+		}
+
+		case MOVE_TO_DESTINATION:
+			if (m_path[ m_pathIndex ].area->Contains( myOrigin ))
+			{
+				// successfully traversed ladder and reached destination area
+				// exit ladder state machine
+				PrintIfWatched( "Ladder traversed.\n" );
+				m_pathLadder = NULL;
+
+				// incrememnt path index to next step beyond this ladder
+				SetPathIndex( m_pathIndex+1 );
+
+				ClearLookAt();
+
+				return false;
+			}
+
+			MoveTowardsPosition( m_goalPosition );
+			break;
+	}
+
+	if ( ( cv_bot_traceview.GetInt() == 1 && IsLocalPlayerWatchingMe() ) || cv_bot_traceview.GetInt() == 10 )
+	{
+		DrawPath();
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute closest point on path to given point
+ * NOTE: This does not do line-of-sight tests, so closest point may be thru the floor, etc
+ */
+bool CCSBot::FindClosestPointOnPath( const Vector &worldPos, int startIndex, int endIndex, Vector *close ) const
+{
+	if (!HasPath() || close == NULL)
+		return false;
+
+	Vector along, toWorldPos;
+	Vector pos;
+	const Vector *from, *to;
+	float length;
+	float closeLength;
+	float closeDistSq = 9999999999.9;
+	float distSq;
+
+	for( int i=startIndex; i<=endIndex; ++i )
+	{
+		from = &m_path[i-1].pos;
+		to = &m_path[i].pos;
+
+		// compute ray along this path segment
+		along = *to - *from;
+
+		// make it a unit vector along the path
+		length = along.NormalizeInPlace();
+
+		// compute vector from start of segment to our point
+		toWorldPos = worldPos - *from;
+
+		// find distance of closest point on ray
+		closeLength = DotProduct( toWorldPos, along );
+
+		// constrain point to be on path segment
+		if (closeLength <= 0.0f)
+			pos = *from;
+		else if (closeLength >= length)
+			pos = *to;
+		else
+			pos = *from + closeLength * along;
+
+		distSq = (pos - worldPos).LengthSqr();
+
+		// keep the closest point so far
+		if (distSq < closeDistSq)
+		{
+			closeDistSq = distSq;
+			*close = pos;
+		}
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest point to our current position on our current path
+ * If "local" is true, only check the portion of the path surrounding m_pathIndex.
+ */
+int CCSBot::FindOurPositionOnPath( Vector *close, bool local ) const
+{
+	if (!HasPath())
+		return -1;
+
+	Vector along, toFeet;
+	Vector feet = GetAbsOrigin();
+	Vector eyes = feet + Vector( 0, 0, HalfHumanHeight );	// in case we're crouching
+	Vector pos;
+	const Vector *from, *to;
+	float length;
+	float closeLength;
+	float closeDistSq = 9999999999.9;
+	int closeIndex = -1;
+	float distSq;
+
+	int start, end;
+
+	if (local)
+	{
+		start = m_pathIndex - 3;
+		if (start < 1)
+			start = 1;
+
+		end = m_pathIndex + 3;
+		if (end > m_pathLength)
+			end = m_pathLength;
+	}
+	else
+	{
+		start = 1;
+		end = m_pathLength;
+	}
+
+	for( int i=start; i<end; ++i )
+	{
+		from = &m_path[i-1].pos;
+		to = &m_path[i].pos;
+
+		// compute ray along this path segment
+		along = *to - *from;
+
+		// make it a unit vector along the path
+		length = along.NormalizeInPlace();
+
+		// compute vector from start of segment to our point
+		toFeet = feet - *from;
+
+		// find distance of closest point on ray
+		closeLength = DotProduct( toFeet, along );
+
+		// constrain point to be on path segment
+		if (closeLength <= 0.0f)
+			pos = *from;
+		else if (closeLength >= length)
+			pos = *to;
+		else
+			pos = *from + closeLength * along;
+
+		distSq = (pos - feet).LengthSqr();
+
+		// keep the closest point so far
+		if (distSq < closeDistSq)
+		{
+			// don't use points we cant see
+			Vector probe = pos + Vector( 0, 0, HalfHumanHeight );
+			if (!IsWalkableTraceLineClear( eyes, probe, WALK_THRU_DOORS | WALK_THRU_BREAKABLES ))
+				continue;
+
+			// don't use points we cant reach
+			if (!IsStraightLinePathWalkable( pos ))
+				continue;
+
+			closeDistSq = distSq;
+			if (close)
+				*close = pos;
+			closeIndex = i-1;
+		}
+	}
+
+	return closeIndex;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Test for un-jumpable height change, or unrecoverable fall
+ */
+bool CCSBot::IsStraightLinePathWalkable( const Vector &goal ) const
+{
+// this is causing hang-up problems when crawling thru ducts/windows that drop off into rooms (they fail the "falling" check)
+return true;
+
+	const float inc = GenerationStepSize;
+
+	Vector feet = GetAbsOrigin();
+	Vector dir = goal - feet;
+	float length = dir.NormalizeInPlace();
+
+	float lastGround;
+	//if (!GetSimpleGroundHeight( &pev->origin, &lastGround ))
+	//	return false;
+	lastGround = feet.z;
+
+
+	float along=0.0f;
+	Vector pos;
+	float ground;
+	bool done = false;
+	while( !done )
+	{
+		along += inc;
+		if (along > length)
+		{
+			along = length;
+			done = true;
+		}
+
+		// compute step along path
+		pos = feet + along * dir;
+
+		pos.z += HalfHumanHeight;
+
+		if (!TheNavMesh->GetSimpleGroundHeight( pos, &ground ))
+			return false;
+
+		// check for falling
+		if (ground - lastGround < -StepHeight)
+			return false;
+
+		// check for unreachable jump
+		// use slightly shorter jump limit, to allow for some fudge room
+		if (ground - lastGround > JumpHeight)
+			return false;
+
+		lastGround = ground;
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute a point a fixed distance ahead along our path.
+ * Returns path index just after point.
+ */
+int CCSBot::FindPathPoint( float aheadRange, Vector *point, int *prevIndex )
+{
+	Vector myOrigin = GetCentroid( this );
+
+	// find path index just past aheadRange
+	int afterIndex;
+
+	// finds the closest point on local area of path, and returns the path index just prior to it
+	Vector close;
+	int startIndex = FindOurPositionOnPath( &close, true );
+
+	if (prevIndex)
+		*prevIndex = startIndex;
+
+	if (startIndex <= 0)
+	{
+		// went off the end of the path
+		// or next point in path is unwalkable (ie: jump-down)
+		// keep same point
+		return m_pathIndex;
+	}
+
+	// if we are crouching, just follow the path exactly
+	if (IsCrouching())
+	{
+		// we want to move to the immediately next point along the path from where we are now
+		int index = startIndex+1;
+		if (index >= m_pathLength)
+			index = m_pathLength-1;
+
+		*point = m_path[ index ].pos;
+
+		// if we are very close to the next point in the path, skip ahead to the next one to avoid wiggling
+		// we must do a 2D check here, in case the goal point is floating in space due to jump down, etc
+		const float closeEpsilon = 20.0f;	// 10
+		while ((*point - close).AsVector2D().IsLengthLessThan( closeEpsilon ))
+		{
+			++index;
+
+			if (index >= m_pathLength)
+			{
+				index = m_pathLength-1;
+				break;
+			}
+
+			*point = m_path[ index ].pos;
+		}
+
+		return index;
+	}
+
+	// make sure we use a node a minimum distance ahead of us, to avoid wiggling 
+	while (startIndex < m_pathLength-1)
+	{
+		Vector pos = m_path[ startIndex+1 ].pos;
+
+		// we must do a 2D check here, in case the goal point is floating in space due to jump down, etc
+		const float closeEpsilon = 20.0f;
+		if ((pos - close).AsVector2D().IsLengthLessThan( closeEpsilon ))
+		{
+			++startIndex;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	// if we hit a ladder, stop, or jump area, must stop (dont use ladder behind us)
+	if (startIndex > m_pathIndex && startIndex < m_pathLength && 
+		(m_path[ startIndex ].ladder || m_path[ startIndex ].area->GetAttributes() & (NAV_MESH_JUMP | NAV_MESH_STOP)))
+	{
+		*point = m_path[ startIndex ].pos;
+		return startIndex;
+	}
+
+	// we need the point just *ahead* of us
+	++startIndex;
+	if (startIndex >= m_pathLength)
+		startIndex = m_pathLength-1;
+
+	// if we hit a ladder, stop, or jump area, must stop
+	if (startIndex < m_pathLength && 
+		(m_path[ startIndex ].ladder || m_path[ startIndex ].area->GetAttributes() & (NAV_MESH_JUMP | NAV_MESH_STOP)))
+	{
+		*point = m_path[ startIndex ].pos;
+		return startIndex;
+	}
+
+	// note direction of path segment we are standing on
+	Vector initDir = m_path[ startIndex ].pos - m_path[ startIndex-1 ].pos;
+	initDir.NormalizeInPlace();
+
+	Vector feet = GetAbsOrigin();
+	Vector eyes = feet + Vector( 0, 0, HalfHumanHeight );
+	float rangeSoFar = 0;
+
+	// this flag is true if our ahead point is visible
+	bool visible = true;
+
+	Vector prevDir = initDir;
+
+	// step along the path until we pass aheadRange
+	bool isCorner = false;
+	int i;
+	for( i=startIndex; i<m_pathLength; ++i )
+	{
+		Vector pos = m_path[i].pos;
+		Vector to = pos - m_path[i-1].pos;
+		Vector dir = to;
+		dir.NormalizeInPlace();
+
+		// don't allow path to double-back from our starting direction (going upstairs, down curved passages, etc)
+		if (DotProduct( dir, initDir ) < 0.0f) // -0.25f
+		{
+			--i;
+			break;
+		}
+
+		// if the path turns a corner, we want to move towards the corner, not into the wall/stairs/etc
+		if (DotProduct( dir, prevDir ) < 0.5f)
+		{
+			isCorner = true;
+			--i;
+			break;
+		}
+		prevDir = dir;
+
+		// don't use points we cant see
+		Vector probe = pos + Vector( 0, 0, HalfHumanHeight );
+		if (!IsWalkableTraceLineClear( eyes, probe, WALK_THRU_BREAKABLES ))
+		{
+			// presumably, the previous point is visible, so we will interpolate
+			visible = false;
+			break;
+		}
+
+		// if we encounter a ladder or jump area, we must stop
+		if (i < m_pathLength && 
+				(m_path[ i ].ladder || m_path[ i ].area->GetAttributes() & NAV_MESH_JUMP))
+			break;
+
+		// Check straight-line path from our current position to this position
+		// Test for un-jumpable height change, or unrecoverable fall
+		if (!IsStraightLinePathWalkable( pos ))
+		{
+			--i;
+			break;
+		}
+
+		Vector along = (i == startIndex) ? (pos - feet) : (pos - m_path[i-1].pos);
+		rangeSoFar += along.Length2D();
+
+		// stop if we have gone farther than aheadRange
+		if (rangeSoFar >= aheadRange)
+			break;
+	}
+
+	if (i < startIndex)
+		afterIndex = startIndex;
+	else if (i < m_pathLength)
+		afterIndex = i;
+	else
+		afterIndex = m_pathLength-1;
+
+
+	// compute point on the path at aheadRange
+	if (afterIndex == 0)
+	{
+		*point = m_path[0].pos;
+	}
+	else
+	{
+		// interpolate point along path segment
+		const Vector *afterPoint = &m_path[ afterIndex ].pos;
+		const Vector *beforePoint = &m_path[ afterIndex-1 ].pos;
+
+		Vector to = *afterPoint - *beforePoint;
+		float length = to.Length2D();
+
+		float t = 1.0f - ((rangeSoFar - aheadRange) / length);
+
+		if (t < 0.0f)
+			t = 0.0f;
+		else if (t > 1.0f)
+			t = 1.0f;
+
+		*point = *beforePoint + t * to;
+
+		// if afterPoint wasn't visible, slide point backwards towards beforePoint until it is
+		if (!visible)
+		{
+			const float sightStepSize = 25.0f;
+			float dt = sightStepSize / length;
+
+			Vector probe = *point + Vector( 0, 0, HalfHumanHeight );
+			while( t > 0.0f && !IsWalkableTraceLineClear( eyes, probe, WALK_THRU_BREAKABLES ) )
+			{
+				t -= dt;
+				*point = *beforePoint + t * to;
+			}
+
+			if (t <= 0.0f)
+				*point = *beforePoint;
+		}
+	}
+
+	// if position found is too close to us, or behind us, force it farther down the path so we don't stop and wiggle
+	if (!isCorner)
+	{
+		const float epsilon = 50.0f;
+		Vector2D toPoint;
+		toPoint.x = point->x - myOrigin.x;
+		toPoint.y = point->y - myOrigin.y;
+		if (DotProduct2D( toPoint, initDir.AsVector2D() ) < 0.0f || toPoint.IsLengthLessThan( epsilon ))
+		{
+			int i;
+			for( i=startIndex; i<m_pathLength; ++i )
+			{
+				toPoint.x = m_path[i].pos.x - myOrigin.x;
+				toPoint.y = m_path[i].pos.y - myOrigin.y;
+				if (m_path[i].ladder || m_path[i].area->GetAttributes() & NAV_MESH_JUMP || toPoint.IsLengthGreaterThan( epsilon ))
+				{
+					*point = m_path[i].pos;
+					startIndex = i;
+					break;
+				}
+			}
+
+			if (i == m_pathLength)
+			{
+				*point = GetPathEndpoint();
+				startIndex = m_pathLength-1;
+			}
+		}
+	}
+
+	// m_pathIndex should always be the next point on the path, even if we're not moving directly towards it
+	return startIndex;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Set the current index along the path
+ */
+void CCSBot::SetPathIndex( int newIndex )
+{
+	m_pathIndex = MIN( newIndex, m_pathLength-1 );
+	m_areaEnteredTimestamp = gpGlobals->curtime;
+
+	if (m_path[ m_pathIndex ].ladder)
+	{
+		SetupLadderMovement();
+	}
+	else
+	{
+		// get our "encounter spots" for this leg of the path
+		if (m_pathIndex < m_pathLength && m_pathIndex >= 2)
+			m_spotEncounter = m_path[ m_pathIndex-1 ].area->GetSpotEncounter( m_path[ m_pathIndex-2 ].area, m_path[ m_pathIndex ].area );
+		else
+			m_spotEncounter = NULL;
+
+		m_pathLadder = NULL;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if nearing a jump in the path
+ */
+bool CCSBot::IsNearJump( void ) const
+{
+	if (m_pathIndex == 0 || m_pathIndex >= m_pathLength)
+		return false;
+
+	for( int i=m_pathIndex-1; i<m_pathIndex; ++i )
+	{
+		if (m_path[ i ].area->GetAttributes() & NAV_MESH_JUMP)
+		{
+			float dz = m_path[ i+1 ].pos.z - m_path[ i ].pos.z;
+
+			if (dz > 0.0f)
+				return true;
+		}
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return approximately how much damage will will take from the given fall height
+ */
+float CCSBot::GetApproximateFallDamage( float height ) const
+{
+	// empirically discovered height values
+	const float slope = 0.2178f;
+	const float intercept = 26.0f;
+
+	float damage = slope * height - intercept;
+
+	if (damage < 0.0f)
+		return 0.0f;
+
+	return damage;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if a friend is between us and the given position
+ */
+bool CCSBot::IsFriendInTheWay( const Vector &goalPos )
+{
+	// do this check less often to ease CPU burden
+	if (!m_avoidFriendTimer.IsElapsed())
+	{
+		return m_isFriendInTheWay;
+	}
+
+	const float avoidFriendInterval = 0.5f;
+	m_avoidFriendTimer.Start( avoidFriendInterval );
+
+	// compute ray along intended path
+	Vector myOrigin = GetCentroid( this );
+	Vector moveDir = goalPos - myOrigin;
+
+	// make it a unit vector 
+	float length = moveDir.NormalizeInPlace();
+
+	m_isFriendInTheWay = false;
+
+	// check if any friends are overlapping this linear path
+	for( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CCSPlayer *player = static_cast<CCSPlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		if (!player->IsAlive())
+			continue;
+
+		if (!player->InSameTeam( this ))
+			continue;
+
+		if (player->entindex() == entindex())
+			continue;
+
+		// compute vector from us to our friend
+		Vector toFriend = player->GetAbsOrigin() - GetAbsOrigin();
+
+		// check if friend is in our "personal space"
+		const float personalSpace = 100.0f;
+		if (toFriend.IsLengthGreaterThan( personalSpace ))
+			continue;
+
+		// find distance of friend along our movement path
+		float friendDistAlong = DotProduct( toFriend, moveDir );
+
+		// if friend is behind us, ignore him
+		if (friendDistAlong <= 0.0f)
+			continue;
+
+		// constrain point to be on path segment
+		Vector pos;
+		if (friendDistAlong >= length)
+			pos = goalPos;
+		else
+			pos = myOrigin + friendDistAlong * moveDir;
+
+		// check if friend overlaps our intended line of movement
+		const float friendRadius = 30.0f;
+		if ((pos - GetCentroid( player )).IsLengthLessThan( friendRadius ))
+		{
+			// friend is in our personal space and overlaps our intended line of movement
+			m_isFriendInTheWay = true;
+			break;
+		}
+	}
+
+	return m_isFriendInTheWay;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Do reflex avoidance movements if our "feelers" are touched
+ */
+void CCSBot::FeelerReflexAdjustment( Vector *goalPosition )
+{
+	// if we are in a "precise" area, do not do feeler adjustments
+	if (m_lastKnownArea && m_lastKnownArea->GetAttributes() & NAV_MESH_PRECISE)
+		return;
+
+	Vector dir( BotCOS( m_forwardAngle ), BotSIN( m_forwardAngle ), 0.0f );
+	Vector lat( -dir.y, dir.x, 0.0f );
+
+	const float feelerOffset = (IsCrouching()) ? 15.0f : 20.0f;
+	const float feelerLengthRun = 50.0f;	// 100 - too long for tight hallways (cs_747)
+	const float feelerLengthWalk = 30.0f;
+	const float feelerHeight = StepHeight + 0.1f;	// if obstacle is lower than StepHeight, we'll walk right over it
+
+	float feelerLength = (IsRunning()) ? feelerLengthRun : feelerLengthWalk;
+
+	feelerLength = (IsCrouching()) ? 20.0f : feelerLength;
+
+	//
+	// Feelers must follow floor slope
+	//
+	float ground;
+	Vector normal;
+	Vector eye = EyePosition();
+	if (GetSimpleGroundHeightWithFloor( eye, &ground, &normal ) == false)
+		return;
+
+	// get forward vector along floor
+	dir = CrossProduct( lat, normal );
+
+	// correct the sideways vector
+	lat = CrossProduct( dir, normal );
+
+
+	Vector feet = GetAbsOrigin();
+	feet.z += feelerHeight;
+
+	Vector from = feet + feelerOffset * lat;
+	Vector to = from + feelerLength * dir;
+
+	bool leftClear = IsWalkableTraceLineClear( from, to, WALK_THRU_DOORS | WALK_THRU_BREAKABLES );
+
+	// avoid ledges, too
+	// use 'from' so it doesn't interfere with legitimate gap jumping (its at our feet)
+	/// @todo Rethink this - it causes lots of wiggling when bots jump down from vents, etc
+/*
+	float ground;
+	if (GetSimpleGroundHeightWithFloor( &from, &ground ))
+	{
+		if (GetFeetZ() - ground > JumpHeight)
+			leftClear = false;
+	}
+*/
+
+	if ( ( cv_bot_traceview.GetInt() == 1 && IsLocalPlayerWatchingMe() ) || cv_bot_traceview.GetInt() == 10 )
+	{
+		if (leftClear)
+			UTIL_DrawBeamPoints( from, to, 1, 0, 255, 0 );
+		else
+			UTIL_DrawBeamPoints( from, to, 1, 255, 0, 0 );
+	}
+
+	from = feet - feelerOffset * lat;
+	to = from + feelerLength * dir;
+
+	bool rightClear = IsWalkableTraceLineClear( from, to, WALK_THRU_DOORS | WALK_THRU_BREAKABLES );
+
+/*
+	// avoid ledges, too
+	if (GetSimpleGroundHeightWithFloor( &from, &ground ))
+	{
+		if (GetFeetZ() - ground > JumpHeight)
+			rightClear = false;
+	}
+*/
+
+	if ( ( cv_bot_traceview.GetInt() == 1 && IsLocalPlayerWatchingMe() ) || cv_bot_traceview.GetInt() == 10 )
+	{
+		if (rightClear)
+			UTIL_DrawBeamPoints( from, to, 1, 0, 255, 0 );
+		else
+			UTIL_DrawBeamPoints( from, to, 1, 255, 0, 0 );
+	}
+
+	const float avoidRange = (IsCrouching()) ? 150.0f : 300.0f;		// 50, 300
+
+	if (!rightClear)
+	{
+		if (leftClear)
+		{
+			// right hit, left clear - veer left
+			*goalPosition = *goalPosition + avoidRange * lat;
+		}
+	}
+	else if (!leftClear)
+	{
+		// right clear, left hit - veer right
+		*goalPosition = *goalPosition - avoidRange * lat;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Allows the current nav area to make us run/walk without messing with our state
+ */
+bool CCSBot::IsRunning( void ) const
+{
+	// if we've forced running, go with it
+	if ( !m_mustRunTimer.IsElapsed() )
+	{
+		return BaseClass::IsRunning();
+	}
+
+	if ( m_lastKnownArea && m_lastKnownArea->GetAttributes() & NAV_MESH_RUN )
+	{
+		return true;
+	}
+
+	if ( m_lastKnownArea && m_lastKnownArea->GetAttributes() & NAV_MESH_WALK )
+	{
+		return false;
+	}
+
+	return BaseClass::IsRunning();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move along the path. Return false if end of path reached.
+ */
+CCSBot::PathResult CCSBot::UpdatePathMovement( bool allowSpeedChange )
+{
+	VPROF_BUDGET( "CCSBot::UpdatePathMovement", VPROF_BUDGETGROUP_NPCS );
+
+	if (m_pathLength == 0)
+		return PATH_FAILURE;
+
+	if (cv_bot_walk.GetBool())
+		Walk();
+
+	//
+	// If we are navigating a ladder, it overrides all other path movement until complete
+	//
+	if (UpdateLadderMovement())
+		return PROGRESSING;
+
+	// ladder failure can destroy the path
+	if (m_pathLength == 0)
+		return PATH_FAILURE;
+
+
+	// we are not supposed to be on a ladder - if we are, jump off
+	if (IsOnLadder())
+		Jump( MUST_JUMP );
+
+
+	assert( m_pathIndex < m_pathLength );
+
+	//
+	// Stop path attribute
+	//
+	if (!IsUsingLadder())
+	{
+		// if the m_isStopping flag is set, clear our movement
+		// if the m_isStopping flag is set and movement is stopped, clear m_isStopping
+		if ( m_lastKnownArea && m_isStopping )
+		{
+			ResetStuckMonitor();
+			ClearMovement();
+
+			if ( GetAbsVelocity().LengthSqr() < 0.1f )
+			{
+				m_isStopping = false;
+			}
+			else
+			{
+				return PROGRESSING;
+			}
+		}
+	}	// end stop logic
+
+
+	//
+	// Check if reached the end of the path
+	//
+	bool nearEndOfPath = false;
+	if (m_pathIndex >= m_pathLength-1)
+	{
+		Vector toEnd = GetPathEndpoint() - GetAbsOrigin();
+		Vector d = toEnd;	// can't use 2D because path end may be below us (jump down)
+
+		const float walkRange = 200.0f;
+
+		// walk as we get close to the goal position to ensure we hit it
+		if (d.IsLengthLessThan( walkRange ))
+		{
+			// don't walk if crouching - too slow
+			if (allowSpeedChange && !IsCrouching())
+				Walk();
+
+			// note if we are near the end of the path
+			const float nearEndRange = 50.0f;
+			if (d.IsLengthLessThan( nearEndRange ))
+				nearEndOfPath = true;
+
+			const float closeEpsilon = 20.0f;
+			if (d.IsLengthLessThan( closeEpsilon ))
+			{
+				// reached goal position - path complete
+				DestroyPath();
+
+				/// @todo We should push and pop walk state here, in case we want to continue walking after reaching goal
+				if (allowSpeedChange)
+					Run();
+
+				return END_OF_PATH;
+			}
+		}
+	}
+
+
+	//
+	// To keep us moving smoothly, we will move towards
+	// a point farther ahead of us down our path.
+	//
+	int prevIndex = 0;	// closest index on path just prior to where we are now
+	const float aheadRange = 300.0f;
+	int newIndex = FindPathPoint( aheadRange, &m_goalPosition, &prevIndex );
+
+	// BOTPORT: Why is prevIndex sometimes -1?
+	if (prevIndex < 0)
+		prevIndex = 0;
+
+	// if goal position is near to us, we must be about to go around a corner - so look ahead!
+	Vector myOrigin = GetCentroid( this );
+	const float nearCornerRange = 100.0f;
+	if (m_pathIndex < m_pathLength-1 && (m_goalPosition - myOrigin).IsLengthLessThan( nearCornerRange ))
+	{
+		if (!IsLookingAtSpot( PRIORITY_HIGH ))
+		{
+			ClearLookAt();
+			InhibitLookAround( 0.5f );
+		}
+	}
+
+	// if we moved to a new node on the path, setup movement
+	if (newIndex > m_pathIndex)
+	{
+		SetPathIndex( newIndex );
+	}
+
+	//
+	// Crouching
+	//
+	if (!IsUsingLadder())
+	{
+		// if we are approaching a crouch area, crouch
+		// if there are no crouch areas coming up, stand
+		const float crouchRange = 50.0f;
+		bool didCrouch = false;
+		for( int i=prevIndex; i<m_pathLength; ++i )
+		{
+			const CNavArea *to = m_path[i].area;
+
+			// if there is a jump area on the way to the crouch area, don't crouch as it messes up the jump
+			// unless we are already higher than the jump area - we must've jumped already but not moved into next area
+			if (to->GetAttributes() & NAV_MESH_JUMP && to->GetCenter().z > GetFeetZ())
+				break;
+
+			Vector close;
+			to->GetClosestPointOnArea( myOrigin, &close );
+
+			if ((close - myOrigin).AsVector2D().IsLengthGreaterThan( crouchRange ))
+				break;
+
+			if (to->GetAttributes() & NAV_MESH_CROUCH)
+			{
+				Crouch();
+				didCrouch = true;
+				ResetStuckMonitor();
+				break;
+			}
+		}
+
+		if (!didCrouch && !IsJumping())
+		{
+			// no crouch areas coming up
+			StandUp();
+		}
+
+	}	// end crouching logic
+
+
+	// compute our forward facing angle
+	m_forwardAngle = UTIL_VecToYaw( m_goalPosition - myOrigin );
+
+	//
+	// Look farther down the path to "lead" our view around corners
+	//
+	Vector toGoal;
+	bool isWaitingForLadder = false;
+
+	// if we are crouching, look towards where we are moving to negotiate tight corners
+	if (IsCrouching())
+	{
+		m_lookAheadAngle = m_forwardAngle;
+	}
+	else
+	{
+		if (m_pathIndex == 0)
+		{
+			toGoal = m_path[1].pos;
+		}
+		else if (m_pathIndex < m_pathLength)
+		{
+			toGoal = m_path[ m_pathIndex ].pos - myOrigin;
+
+			// actually aim our view farther down the path
+			const float lookAheadRange = 500.0f;
+			if (!m_path[ m_pathIndex ].ladder &&
+				!IsNearJump() &&
+				toGoal.AsVector2D().IsLengthLessThan( lookAheadRange ))
+			{
+				float along = toGoal.Length2D();
+				int i;
+				for( i=m_pathIndex+1; i<m_pathLength; ++i )
+				{
+					Vector delta = m_path[i].pos - m_path[i-1].pos;
+					float segmentLength = delta.Length2D();
+
+					if (along + segmentLength >= lookAheadRange)
+					{
+						// interpolate between points to keep look ahead point at fixed distance
+						float t = (lookAheadRange - along) / (segmentLength + along);
+						Vector target;
+
+						if (t <= 0.0f)
+							target = m_path[i-1].pos;
+						else if (t >= 1.0f)
+							target = m_path[i].pos;
+						else
+							target = m_path[i-1].pos + t * delta;
+
+						toGoal = target - myOrigin;
+						break;
+					}
+
+					// if we are coming up to a ladder or a jump, look at it
+					if (m_path[i].ladder ||
+						(m_path[i].area->GetAttributes() & NAV_MESH_JUMP) ||
+						(m_path[i].area->GetAttributes() & NAV_MESH_PRECISE) ||
+						(m_path[i].area->GetAttributes() & NAV_MESH_STOP))
+					{
+						toGoal = m_path[i].pos - myOrigin;
+
+						// if anyone is on the ladder, wait
+						if (m_path[i].ladder && m_path[i].ladder->IsInUse( this ))
+						{
+							isWaitingForLadder = true;
+							ResetStuckMonitor();
+
+							// if we are too close to the ladder, back off a bit
+							const float tooCloseRange = 100.0f;
+							Vector2D delta( m_path[i].ladder->m_top.x - myOrigin.x, 
+											m_path[i].ladder->m_top.y - myOrigin.y );
+							if (delta.IsLengthLessThan( tooCloseRange ))
+							{
+								MoveAwayFromPosition( m_path[i].ladder->m_top );
+							}
+						}
+
+						break;
+					}
+
+					along += segmentLength;
+				}
+
+				if (i == m_pathLength)
+					toGoal = GetPathEndpoint() - myOrigin;
+			}
+		}
+		else
+		{
+			toGoal = GetPathEndpoint() - myOrigin;
+		}
+
+		m_lookAheadAngle = UTIL_VecToYaw( toGoal );
+	}
+
+	// initialize "adjusted" goal to current goal
+	Vector adjustedGoal = m_goalPosition;
+
+	//
+	// Use short "feelers" to veer away from close-range obstacles
+	// Feelers come from our ankles, just above StepHeight, so we avoid short walls, too
+	// Don't use feelers if very near the end of the path, or about to jump
+	//
+	/// @todo Consider having feelers at several heights to deal with overhangs, etc.
+	if (!nearEndOfPath && !IsNearJump() && !IsJumping())
+	{
+		FeelerReflexAdjustment( &adjustedGoal );
+	}
+
+	// draw debug visualization
+	if ( ( cv_bot_traceview.GetInt() == 1 && IsLocalPlayerWatchingMe() ) || cv_bot_traceview.GetInt() == 10 )
+	{
+		DrawPath();
+
+		const Vector *pos = &m_path[ m_pathIndex ].pos;
+		UTIL_DrawBeamPoints( *pos, *pos + Vector( 0, 0, 50 ), 1, 255, 255, 0 );
+
+		UTIL_DrawBeamPoints( adjustedGoal, adjustedGoal + Vector( 0, 0, 50 ), 1, 255, 0, 255 );
+		UTIL_DrawBeamPoints( myOrigin, adjustedGoal + Vector( 0, 0, 50 ), 1, 255, 0, 255 );
+	}
+
+	// dont use adjustedGoal, as it can vary wildly from the feeler adjustment
+	if (!IsAttacking() && IsFriendInTheWay( m_goalPosition ))
+	{
+		if (!m_isWaitingBehindFriend)
+		{
+			m_isWaitingBehindFriend = true;
+
+			const float politeDuration = 5.0f - 3.0f * GetProfile()->GetAggression();
+			m_politeTimer.Start( politeDuration );
+		}
+		else if (m_politeTimer.IsElapsed())
+		{
+			// we have run out of patience
+			m_isWaitingBehindFriend = false;
+			ResetStuckMonitor();
+
+			// repath to avoid clump of friends in the way
+			DestroyPath();
+		}
+	}
+	else if (m_isWaitingBehindFriend)
+	{
+		// we're done waiting for our friend to move
+		m_isWaitingBehindFriend = false;
+		ResetStuckMonitor();
+	}
+
+	//
+	// Move along our path if there are no friends blocking our way,
+	// or we have run out of patience
+	//
+	if (!isWaitingForLadder && (!m_isWaitingBehindFriend || m_politeTimer.IsElapsed()))
+	{
+		//
+		// Move along path
+		//
+		MoveTowardsPosition( adjustedGoal );
+
+		//
+		// Stuck check
+		//
+		if (m_isStuck && !IsJumping())
+		{
+			Wiggle();
+		}
+	}
+
+	// if our goal is high above us, we must have fallen
+	bool didFall = false;
+	if (m_goalPosition.z - GetFeetZ() > JumpCrouchHeight)
+	{
+		const float closeRange = 75.0f;
+		Vector2D to( myOrigin.x - m_goalPosition.x, myOrigin.y - m_goalPosition.y );
+		if (to.IsLengthLessThan( closeRange ))
+		{
+			// we can't reach the goal position
+			// check if we can reach the next node, in case this was a "jump down" situation
+			if (m_pathIndex < m_pathLength-1)
+			{
+				if (m_path[ m_pathIndex+1 ].pos.z - GetFeetZ() > JumpCrouchHeight)
+				{
+					// the next node is too high, too - we really did fall of the path
+					didFall = true;
+
+					for ( int i=m_pathIndex; i<=m_pathIndex+1; ++i )
+					{
+						if ( m_path[i].how == GO_LADDER_UP )
+						{
+							// if we're going up a ladder, and we're within reach of the ladder bottom, we haven't fallen
+							if ( m_path[i].pos.z - GetFeetZ() <= JumpCrouchHeight )
+							{
+								didFall = false;
+								break;
+							}
+						}
+					}
+				}
+			}
+			else
+			{
+				// fell trying to get to the last node in the path
+				didFall = true;
+			}
+		}
+	}
+
+	//
+	// This timeout check is needed if the bot somehow slips way off 
+	// of its path and cannot progress, but also moves around
+	// enough that it never becomes "stuck"
+	//
+	const float giveUpDuration = 4.0f;
+	if (didFall || gpGlobals->curtime - m_areaEnteredTimestamp > giveUpDuration)
+	{
+		if (didFall)
+		{
+			PrintIfWatched( "I fell off!\n" );
+			if (IsLocalPlayerWatchingMe() && cv_bot_debug.GetBool() && UTIL_GetListenServerHost())
+			{
+				CBasePlayer *localPlayer = UTIL_GetListenServerHost();
+				CSingleUserRecipientFilter filter( localPlayer );
+				EmitSound( filter, localPlayer->entindex(), "Bot.FellOff" );
+			}
+		}
+
+		// if we havent made any progress in a long time, give up
+		if (m_pathIndex < m_pathLength-1)
+		{
+			PrintIfWatched( "Giving up trying to get to area #%d\n", m_path[ m_pathIndex ].area->GetID() );
+		}
+		else
+		{
+			PrintIfWatched( "Giving up trying to get to end of path\n" );
+		}
+
+		Run();
+		StandUp();
+		DestroyPath();
+		ClearLookAt();
+
+		// See if we should be on a different nav area
+		CNavArea *area = TheNavMesh->GetNearestNavArea( GetAbsOrigin(), false, 500.0f, true );
+		if (area && area != m_lastNavArea)
+		{
+			if (m_lastNavArea)
+			{
+				m_lastNavArea->DecrementPlayerCount( GetTeamNumber(), entindex() );
+			}
+
+			area->IncrementPlayerCount( GetTeamNumber(), entindex() );
+
+			m_lastNavArea = area;
+			if ( area->GetPlace() != UNDEFINED_PLACE )
+			{
+				const char *placeName = TheNavMesh->PlaceToName( area->GetPlace() );
+				if ( placeName && *placeName )
+				{
+					Q_strncpy( m_szLastPlaceName.GetForModify(), placeName, MAX_PLACE_NAME_LENGTH );
+				}
+			}
+
+			// generate event
+			//KeyValues *event = new KeyValues( "player_entered_area" );
+			//event->SetInt( "userid", GetUserID() );
+			//event->SetInt( "areaid", area->GetID() );
+			//gameeventmanager->FireEvent( event );
+		}
+
+		return PATH_FAILURE;
+	}
+
+	return PROGRESSING;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Build trivial path to goal, assuming we are already in the same area
+ */
+void CCSBot::BuildTrivialPath( const Vector &goal )
+{
+	Vector myOrigin = GetCentroid( this );
+
+	m_pathIndex = 1;
+	m_pathLength = 2;
+
+	m_path[0].area = m_lastKnownArea;
+	m_path[0].pos = myOrigin;
+	m_path[0].pos.z = m_lastKnownArea->GetZ( myOrigin );
+	m_path[0].ladder = NULL;
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+
+	m_path[1].area = m_lastKnownArea;
+	m_path[1].pos = goal;
+	m_path[1].pos.z = m_lastKnownArea->GetZ( goal );
+	m_path[1].ladder = NULL;
+	m_path[1].how = NUM_TRAVERSE_TYPES;
+
+	m_areaEnteredTimestamp = gpGlobals->curtime;
+	m_spotEncounter = NULL;
+	m_pathLadder = NULL;
+
+	m_goalPosition = goal;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute shortest path to goal position via A* algorithm
+ * If 'goalArea' is NULL, path will get as close as it can.
+ */
+bool CCSBot::ComputePath( const Vector &goal, RouteType route )
+{
+	VPROF_BUDGET( "CCSBot::ComputePath", VPROF_BUDGETGROUP_NPCS );
+
+	//
+	// Throttle re-pathing
+	//
+	if (!m_repathTimer.IsElapsed())
+		return false;
+
+	// randomize to distribute CPU load
+	m_repathTimer.Start( RandomFloat( 0.4f, 0.6f ) );
+
+
+	DestroyPath();
+
+	m_pathLadder = NULL;
+
+	CNavArea *goalArea = TheNavMesh->GetNearestNavArea( goal );
+
+	CNavArea *startArea = m_lastKnownArea;
+	if (startArea == NULL)
+		return false;
+
+	// if we fell off a ledge onto an area off the mesh, we will path from the
+	// ledge above our heads, resulting in a path we can't follow.
+	Vector close;
+	startArea->GetClosestPointOnArea( EyePosition(), &close );
+	if (close.z - GetAbsOrigin().z > JumpCrouchHeight)
+	{
+		// we can't reach our last known area - find nearest area to us
+		PrintIfWatched( "Last known area is above my head - resetting to nearest area.\n" );
+		m_lastKnownArea = (CCSNavArea*)TheNavMesh->GetNearestNavArea( GetAbsOrigin(), false, 500.0f, true );
+		if (m_lastKnownArea == NULL)
+		{
+			return false;
+		}
+
+		startArea = m_lastKnownArea;
+	}
+
+	// note final specific position
+	Vector pathEndPosition = goal;
+
+	// make sure path end position is on the ground
+	if (goalArea)
+		pathEndPosition.z = goalArea->GetZ( pathEndPosition );
+	else
+		TheNavMesh->GetGroundHeight( pathEndPosition, &pathEndPosition.z );
+
+	// if we are already in the goal area, build trivial path
+	if (startArea == goalArea)
+	{
+		BuildTrivialPath( pathEndPosition );
+		return true;
+	}
+
+	//
+	// Compute shortest path to goal
+	//
+	CNavArea *closestArea = NULL;
+	PathCost cost( this, route );
+	bool pathToGoalExists = NavAreaBuildPath( startArea, goalArea, &goal, cost, &closestArea );
+
+	CNavArea *effectiveGoalArea = (pathToGoalExists) ? goalArea : closestArea;
+
+	//
+	// Build path by following parent links
+	//
+
+	// get count
+	int count = 0;
+	CNavArea *area;
+	for( area = effectiveGoalArea; area; area = area->GetParent() )
+		++count;
+
+	// save room for endpoint
+	if (count > MAX_PATH_LENGTH-1)
+		count = MAX_PATH_LENGTH-1;
+
+	if (count == 0)
+		return false;
+
+	if (count == 1)
+	{
+		BuildTrivialPath( pathEndPosition );
+		return true;
+	}
+
+	// build path
+	m_pathLength = count;
+	for( area = effectiveGoalArea; count && area; area = area->GetParent() )
+	{
+		--count;
+		m_path[ count ].area = area;
+		m_path[ count ].how = area->GetParentHow();
+	}
+
+	// compute path positions
+	if (ComputePathPositions() == false)
+	{
+		PrintIfWatched( "Error building path\n" );
+		DestroyPath();
+		return false;
+	}
+
+	// append path end position
+	m_path[ m_pathLength ].area = effectiveGoalArea;
+	m_path[ m_pathLength ].pos = pathEndPosition;
+	m_path[ m_pathLength ].ladder = NULL;
+	m_path[ m_pathLength ].how = NUM_TRAVERSE_TYPES;
+	++m_pathLength;
+
+	// do movement setup
+	m_pathIndex = 1;
+	m_areaEnteredTimestamp = gpGlobals->curtime;
+	m_spotEncounter = NULL;
+	m_goalPosition = m_path[1].pos;
+
+	if (m_path[1].ladder)
+		SetupLadderMovement();
+	else
+		m_pathLadder = NULL;
+
+	// find initial encounter area along this path, if we are in the early part of the round
+	if (IsSafe())
+	{
+		int myTeam = GetTeamNumber();
+		int enemyTeam = OtherTeam( myTeam );
+		int i;
+
+		for( i=0; i<m_pathLength; ++i )
+		{
+			if (m_path[i].area->GetEarliestOccupyTime( myTeam ) > m_path[i].area->GetEarliestOccupyTime( enemyTeam ))
+			{
+				break;
+			}
+		}
+
+		if (i < m_pathLength)
+		{
+			SetInitialEncounterArea( m_path[i].area );
+		}
+		else
+		{
+			SetInitialEncounterArea( NULL );
+		}
+	}
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return estimated distance left to travel along path
+ */
+float CCSBot::GetPathDistanceRemaining( void ) const
+{
+	if (!HasPath())
+		return -1.0f;
+
+	int idx = (m_pathIndex < m_pathLength) ? m_pathIndex : m_pathLength-1;
+
+	float dist = 0.0f;
+	Vector prevCenter = m_path[m_pathIndex].area->GetCenter();
+
+	for( int i=idx+1; i<m_pathLength; ++i )
+	{
+		dist += (m_path[i].area->GetCenter() - prevCenter).Length();
+		prevCenter = m_path[i].area->GetCenter();
+	}
+
+	return dist;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Draw a portion of our current path for debugging.
+ */
+void CCSBot::DrawPath( void )
+{
+	if (!HasPath())
+		return;
+
+	for( int i=1; i<m_pathLength; ++i )
+	{
+		UTIL_DrawBeamPoints( m_path[i-1].pos, m_path[i].pos, 2, 255, 75, 0 );
+	}
+
+	Vector close;
+	if (FindOurPositionOnPath( &close, true ) >= 0)
+	{
+		UTIL_DrawBeamPoints( close + Vector( 0, 0, 25 ), close, 1, 0, 255, 0 );
+		UTIL_DrawBeamPoints( close + Vector( 25, 0, 0 ), close + Vector( -25, 0, 0 ), 1, 0, 255, 0 );
+		UTIL_DrawBeamPoints( close + Vector( 0, 25, 0 ), close + Vector( 0, -25, 0 ), 1, 0, 255, 0 );
+	}
+}
+
diff --git a/game/server/cstrike/bot/cs_bot_radio.cpp b/game/server/cstrike/bot/cs_bot_radio.cpp
new file mode 100644
index 00000000..08acb4e0
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_radio.cpp
@@ -0,0 +1,346 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+extern int gmsgBotVoice;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if the radio message is an order to do something
+ * NOTE: "Report in" is not considered a "command" because it doesnt ask the bot to go somewhere, or change its mind
+ */
+bool CCSBot::IsRadioCommand( RadioType event ) const
+{
+	if (event == RADIO_AFFIRMATIVE ||
+		event == RADIO_NEGATIVE ||
+		event == RADIO_ENEMY_SPOTTED ||
+		event == RADIO_SECTOR_CLEAR ||
+		event == RADIO_REPORTING_IN ||
+		event == RADIO_REPORT_IN_TEAM ||
+		event == RADIO_ENEMY_DOWN ||
+		event == RADIO_INVALID )
+		return false;
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Respond to radio commands from HUMAN players
+ */
+void CCSBot::RespondToRadioCommands( void )
+{
+	// bots use the chatter system to respond to each other
+	if (m_radioSubject != NULL && m_radioSubject->IsPlayer())
+	{
+		CCSPlayer *player = m_radioSubject;
+		if (player->IsBot())
+		{
+			m_lastRadioCommand = RADIO_INVALID;
+			return;
+		}
+	}
+	
+	if (m_lastRadioCommand == RADIO_INVALID)
+		return;
+
+	// a human player has issued a radio command
+	GetChatter()->ResetRadioSilenceDuration();
+
+
+	// if we are doing something important, ignore the radio
+	// unless it is a "report in" request - we can do that while we continue to do other things
+	/// @todo Create "uninterruptable" flag
+	if (m_lastRadioCommand != RADIO_REPORT_IN_TEAM)
+	{
+		if (IsBusy())
+		{
+			// consume command
+			m_lastRadioCommand = RADIO_INVALID;
+			return;
+		}
+	}
+
+	// wait for reaction time before responding
+	// delay needs to be long enough for the radio message we're responding to to finish
+	float respondTime = 1.0f + 2.0f * GetProfile()->GetReactionTime();
+	if (IsRogue())
+		respondTime += 2.0f;
+
+	if (gpGlobals->curtime - m_lastRadioRecievedTimestamp < respondTime)
+		return;
+
+	// rogues won't follow commands, unless already following the player
+	if (!IsFollowing() && IsRogue())
+	{
+		if (IsRadioCommand( m_lastRadioCommand ))
+		{
+			GetChatter()->Negative();
+		}
+
+		// consume command
+		m_lastRadioCommand = RADIO_INVALID;
+		return;
+	}
+
+	CCSPlayer *player = m_radioSubject;
+	if (player == NULL)
+		return;
+
+	// respond to command
+	bool canDo = false;
+	const float inhibitAutoFollowDuration = 60.0f;
+	switch( m_lastRadioCommand )
+	{
+		case RADIO_REPORT_IN_TEAM:
+		{
+			GetChatter()->ReportingIn();
+			break;
+		}
+
+		case RADIO_FOLLOW_ME:
+		case RADIO_COVER_ME:
+		case RADIO_STICK_TOGETHER_TEAM:
+		case RADIO_REGROUP_TEAM:
+		{
+			if (!IsFollowing())
+			{
+				Follow( player );
+				player->AllowAutoFollow();
+				canDo = true;
+			}
+			break;
+		}
+
+		case RADIO_ENEMY_SPOTTED:
+		case RADIO_NEED_BACKUP:
+		case RADIO_TAKING_FIRE:
+			if (!IsFollowing())
+			{
+				Follow( player );
+				GetChatter()->Say( "OnMyWay" );
+				player->AllowAutoFollow();
+				canDo = false;
+			}
+			break;
+
+		case RADIO_TEAM_FALL_BACK:
+		{
+			if (TryToRetreat())
+				canDo = true;
+			break;
+		}
+
+		case RADIO_HOLD_THIS_POSITION:
+		{
+			// find the leader's area 
+			SetTask( HOLD_POSITION );
+			StopFollowing();
+			player->InhibitAutoFollow( inhibitAutoFollowDuration );
+			Hide( TheNavMesh->GetNearestNavArea( m_radioPosition ) );
+			canDo = true;
+			break;
+		}
+
+		case RADIO_GO_GO_GO:
+		case RADIO_STORM_THE_FRONT:
+			StopFollowing();
+			Hunt();
+			canDo = true;
+			player->InhibitAutoFollow( inhibitAutoFollowDuration );
+			break;
+
+		case RADIO_GET_OUT_OF_THERE:
+			if (TheCSBots()->IsBombPlanted())
+			{
+				EscapeFromBomb();
+				player->InhibitAutoFollow( inhibitAutoFollowDuration );
+				canDo = true;
+			}
+			break;
+
+		case RADIO_SECTOR_CLEAR:
+		{
+			// if this is a defusal scenario, and the bomb is planted, 
+			// and a human player cleared a bombsite, check it off our list too
+			if (TheCSBots()->GetScenario() == CCSBotManager::SCENARIO_DEFUSE_BOMB)
+			{
+				if (GetTeamNumber() == TEAM_CT && TheCSBots()->IsBombPlanted())
+				{
+					const CCSBotManager::Zone *zone = TheCSBots()->GetClosestZone( player );
+
+					if (zone)
+					{
+						GetGameState()->ClearBombsite( zone->m_index );
+
+						// if we are huting for the planted bomb, re-select bombsite
+						if (GetTask() == FIND_TICKING_BOMB)
+							Idle();
+
+						canDo = true;
+					}
+				}
+			}			
+			break;
+		}
+
+		default:
+			// ignore all other radio commands for now
+			return;
+	}
+
+	if (canDo)
+	{
+		// affirmative
+		GetChatter()->Affirmative();
+
+		// if we agreed to follow a new command, put away our grenade
+		if (IsRadioCommand( m_lastRadioCommand ) && IsUsingGrenade())
+		{
+			EquipBestWeapon();
+		}
+	}
+
+	// consume command
+	m_lastRadioCommand = RADIO_INVALID;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Decide if we should move to help the player, return true if we will
+ */
+bool CCSBot::RespondToHelpRequest( CCSPlayer *them, Place place, float maxRange )
+{
+	if (IsRogue())
+		return false;
+
+	// if we're busy, ignore
+	if (IsBusy())
+		return false;
+
+	Vector themOrigin = GetCentroid( them );
+
+	// if we are too far away, ignore
+	if (maxRange > 0.0f)
+	{
+		// compute actual travel distance
+		PathCost cost(this);
+		float travelDistance = NavAreaTravelDistance( m_lastKnownArea, TheNavMesh->GetNearestNavArea( themOrigin ), cost );
+		if (travelDistance < 0.0f)
+			return false;
+
+		if (travelDistance > maxRange)
+			return false;
+	}
+
+
+	if (place == UNDEFINED_PLACE)
+	{
+		// if we have no "place" identifier, go directly to them
+
+		// if we are already there, ignore
+		float rangeSq = (them->GetAbsOrigin() - GetAbsOrigin()).LengthSqr();
+		const float close = 750.0f * 750.0f;
+		if (rangeSq < close)
+			return true;
+
+		MoveTo( themOrigin, FASTEST_ROUTE );
+	}
+	else
+	{
+		// if we are already there, ignore
+		if (GetPlace() == place)
+			return true;
+
+		// go to where help is needed
+		const Vector *pos = GetRandomSpotAtPlace( place );
+		if (pos)
+		{
+			MoveTo( *pos, FASTEST_ROUTE );
+		}
+		else
+		{
+			MoveTo( themOrigin, FASTEST_ROUTE );
+		}
+	}
+
+	// acknowledge
+	GetChatter()->Say( "OnMyWay" );
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Send a radio message
+ */
+void CCSBot::SendRadioMessage( RadioType event )
+{
+	// make sure this is a radio event
+	if (event <= RADIO_START_1 || event >= RADIO_END)
+		return;
+
+	PrintIfWatched( "%3.1f: SendRadioMessage( %s )\n", gpGlobals->curtime, RadioEventName[ event ] );
+
+	// note the time the message was sent
+	TheCSBots()->SetRadioMessageTimestamp( event, GetTeamNumber() );
+
+	m_lastRadioSentTimestamp = gpGlobals->curtime;
+
+	char slot[2];
+	slot[1] = '\000';
+
+	if (event > RADIO_START_1 && event < RADIO_START_2)
+	{
+		HandleMenu_Radio1( event - RADIO_START_1 );
+	}
+	else if (event > RADIO_START_2 && event < RADIO_START_3)
+	{
+		HandleMenu_Radio2( event - RADIO_START_2 );
+	}
+	else
+	{
+		HandleMenu_Radio3( event - RADIO_START_3 );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Send voice chatter.  Also sends the entindex and duration for voice feedback.
+ */
+void CCSBot::SpeakAudio( const char *voiceFilename, float duration, int pitch )
+{
+	if( !IsAlive() )
+		return;
+
+	if ( IsObserver() )
+		return;
+
+	CRecipientFilter filter;
+	ConstructRadioFilter( filter );
+
+	UserMessageBegin ( filter, "RawAudio" );
+		WRITE_BYTE( pitch );
+		WRITE_BYTE( entindex() );
+		WRITE_FLOAT( duration );
+		WRITE_STRING( voiceFilename );
+	MessageEnd();
+
+	GetChatter()->ResetRadioSilenceDuration();
+
+	m_voiceEndTimestamp = gpGlobals->curtime + duration;
+}
+
diff --git a/game/server/cstrike/bot/cs_bot_statemachine.cpp b/game/server/cstrike/bot/cs_bot_statemachine.cpp
new file mode 100644
index 00000000..8cbf9aa9
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_statemachine.cpp
@@ -0,0 +1,693 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+#include "cs_nav_path.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * This method is the ONLY legal way to change a bot's current state
+ */
+void CCSBot::SetState( BotState *state )
+{
+	PrintIfWatched( "%s: SetState: %s -> %s\n", GetPlayerName(), (m_state) ? m_state->GetName() : "NULL", state->GetName() );
+
+	/*
+	if ( IsDefusingBomb() )
+	{
+		const Vector *bombPos = GetGameState()->GetBombPosition();
+		if ( bombPos != NULL )
+		{
+			if ( TheCSBots()->GetBombDefuser() == this )
+			{
+				if ( TheCSBots()->IsBombPlanted() )
+				{
+					Msg( "Bot %s is switching from defusing the bomb to %s\n",
+						GetPlayerName(), state->GetName() );
+				}
+			}
+		}
+	}
+	*/
+
+	// if we changed state from within the special Attack state, we are no longer attacking
+	if (m_isAttacking)
+		StopAttacking();
+
+	if (m_state)
+		m_state->OnExit( this );
+
+	state->OnEnter( this );
+
+	m_state = state;
+	m_stateTimestamp = gpGlobals->curtime;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::Idle( void )
+{
+	SetTask( SEEK_AND_DESTROY );
+	SetState( &m_idleState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::EscapeFromBomb( void )
+{
+	SetTask( ESCAPE_FROM_BOMB );
+	SetState( &m_escapeFromBombState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::Follow( CCSPlayer *player )
+{
+	if (player == NULL)
+		return;
+
+	// note when we began following
+	if (!m_isFollowing || m_leader != player)
+		m_followTimestamp = gpGlobals->curtime;
+
+	m_isFollowing = true;
+	m_leader = player;
+
+	SetTask( FOLLOW );
+	m_followState.SetLeader( player );
+	SetState( &m_followState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Continue following our leader after finishing what we were doing
+ */
+void CCSBot::ContinueFollowing( void )
+{
+	SetTask( FOLLOW );
+
+	m_followState.SetLeader( m_leader );
+
+	SetState( &m_followState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Stop following
+ */
+void CCSBot::StopFollowing( void )
+{
+	m_isFollowing = false;
+	m_leader = NULL;
+	m_allowAutoFollowTime = gpGlobals->curtime + 10.0f;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Begin process of rescuing hostages
+ */
+void CCSBot::RescueHostages( void )
+{
+	SetTask( RESCUE_HOSTAGES );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Use the entity
+ */
+void CCSBot::UseEntity( CBaseEntity *entity )
+{
+	m_useEntityState.SetEntity( entity );
+	SetState( &m_useEntityState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Open the door.
+ * This assumes the bot is directly in front of the door with no obstructions.
+ * NOTE: This state is special, like Attack, in that it suspends the current behavior and returns to it when done.
+ */
+void CCSBot::OpenDoor( CBaseEntity *door )
+{
+	m_openDoorState.SetDoor( door );
+	m_isOpeningDoor = true;
+	m_openDoorState.OnEnter( this );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * DEPRECATED: Use TryToHide() instead.
+ * Move to a hiding place.
+ * If 'searchFromArea' is non-NULL, hiding spots are looked for from that area first.
+ */
+void CCSBot::Hide( CNavArea *searchFromArea, float duration, float hideRange, bool holdPosition )
+{
+	DestroyPath();
+
+	CNavArea *source;
+	Vector sourcePos;
+	if (searchFromArea)
+	{
+		source = searchFromArea;
+		sourcePos = searchFromArea->GetCenter();
+	}
+	else
+	{
+		source = m_lastKnownArea;
+		sourcePos = GetCentroid( this );
+	}
+
+	if (source == NULL)
+	{
+		PrintIfWatched( "Hide from area is NULL.\n" );
+		Idle();
+		return;
+	}
+
+	m_hideState.SetSearchArea( source );
+	m_hideState.SetSearchRange( hideRange );
+	m_hideState.SetDuration( duration );
+	m_hideState.SetHoldPosition( holdPosition );
+
+	// search around source area for a good hiding spot
+	Vector useSpot;
+
+	const Vector *pos = FindNearbyHidingSpot( this, sourcePos, hideRange, IsSniper() );
+	if (pos == NULL)
+	{
+		PrintIfWatched( "No available hiding spots.\n" );
+		// hide at our current position
+		useSpot = GetCentroid( this );
+	}
+	else
+	{
+		useSpot = *pos;
+	}
+
+	m_hideState.SetHidingSpot( useSpot );
+
+	// build a path to our new hiding spot
+	if (ComputePath( useSpot, FASTEST_ROUTE ) == false)
+	{
+		PrintIfWatched( "Can't pathfind to hiding spot\n" );
+		Idle();
+		return;
+	}
+
+	SetState( &m_hideState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move to the given hiding place
+ */
+void CCSBot::Hide( const Vector &hidingSpot, float duration, bool holdPosition )
+{
+	CNavArea *hideArea = TheNavMesh->GetNearestNavArea( hidingSpot );
+	if (hideArea == NULL)
+	{
+		PrintIfWatched( "Hiding spot off nav mesh\n" );
+		Idle();
+		return;
+	}
+
+	DestroyPath();
+
+	m_hideState.SetSearchArea( hideArea );
+	m_hideState.SetSearchRange( 750.0f );
+	m_hideState.SetDuration( duration );
+	m_hideState.SetHoldPosition( holdPosition );
+	m_hideState.SetHidingSpot( hidingSpot );
+
+	// build a path to our new hiding spot
+	if (ComputePath( hidingSpot, FASTEST_ROUTE ) == false)
+	{
+		PrintIfWatched( "Can't pathfind to hiding spot\n" );
+		Idle();
+		return;
+	}
+
+	SetState( &m_hideState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Try to hide nearby.  Return true if hiding, false if can't hide here.
+ * If 'searchFromArea' is non-NULL, hiding spots are looked for from that area first.
+ */
+bool CCSBot::TryToHide( CNavArea *searchFromArea, float duration, float hideRange, bool holdPosition, bool useNearest )
+{
+	CNavArea *source;
+	Vector sourcePos;
+	if (searchFromArea)
+	{
+		source = searchFromArea;
+		sourcePos = searchFromArea->GetCenter();
+	}
+	else
+	{
+		source = m_lastKnownArea;
+		sourcePos = GetCentroid( this );
+	}
+
+	if (source == NULL)
+	{
+		PrintIfWatched( "Hide from area is NULL.\n" );
+		return false;
+	}
+
+	m_hideState.SetSearchArea( source );
+	m_hideState.SetSearchRange( hideRange );
+	m_hideState.SetDuration( duration );
+	m_hideState.SetHoldPosition( holdPosition );
+
+	// search around source area for a good hiding spot
+	const Vector *pos = FindNearbyHidingSpot( this, sourcePos, hideRange, IsSniper(), useNearest );
+	if (pos == NULL)
+	{
+		PrintIfWatched( "No available hiding spots.\n" );
+		return false;
+	}
+
+	m_hideState.SetHidingSpot( *pos );
+
+	// build a path to our new hiding spot
+	if (ComputePath( *pos, FASTEST_ROUTE ) == false)
+	{
+		PrintIfWatched( "Can't pathfind to hiding spot\n" );
+		return false;
+	}
+
+	SetState( &m_hideState );
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Retreat to a nearby hiding spot, away from enemies
+ */
+bool CCSBot::TryToRetreat( float maxRange, float duration )
+{
+	const Vector *spot = FindNearbyRetreatSpot( this, maxRange );
+	if (spot)
+	{
+		// ignore enemies for a second to give us time to hide
+		// reaching our hiding spot clears our disposition
+		IgnoreEnemies( 10.0f );
+
+		if (duration < 0.0f)
+		{
+			duration = RandomFloat( 3.0f, 15.0f );
+		}
+
+		StandUp();
+		Run();
+		Hide( *spot, duration );
+
+		PrintIfWatched( "Retreating to a safe spot!\n" );
+
+		return true;
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::Hunt( void )
+{
+	SetState( &m_huntState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Attack our the given victim
+ * NOTE: Attacking does not change our task.
+ */
+void CCSBot::Attack( CCSPlayer *victim )
+{
+	if (victim == NULL)
+		return;
+
+	// zombies never attack
+	if (cv_bot_zombie.GetBool())
+		return;
+
+	// cannot attack if we are reloading
+	if (IsReloading())
+		return;
+
+	// change enemy
+	SetBotEnemy( victim );
+
+	//
+	// Do not "re-enter" the attack state if we are already attacking
+	//
+	if (IsAttacking())
+		return;
+
+	// if we're holding a grenade, throw it at the victim
+	if (IsUsingGrenade())
+	{
+		// throw towards their feet
+		ThrowGrenade( victim->GetAbsOrigin() );
+		return;
+	}
+
+
+	// if we are currently hiding, increase our chances of crouching and holding position
+	if (IsAtHidingSpot())
+		m_attackState.SetCrouchAndHold( (RandomFloat( 0.0f, 100.0f ) < 60.0f) ? true : false );
+	else
+		m_attackState.SetCrouchAndHold( false );
+
+	//SetState( &m_attackState );
+	//PrintIfWatched( "ATTACK BEGIN (reaction time = %g (+ update time), surprise time = %g, attack delay = %g)\n", 
+	//				GetProfile()->GetReactionTime(), m_surpriseDelay, GetProfile()->GetAttackDelay() );
+	m_isAttacking = true;
+	m_attackState.OnEnter( this );
+
+
+	Vector victimOrigin = GetCentroid( victim );
+
+	// cheat a bit and give the bot the initial location of its victim
+	m_lastEnemyPosition = victimOrigin;
+	m_lastSawEnemyTimestamp = gpGlobals->curtime;
+	m_aimSpreadTimestamp = gpGlobals->curtime;
+
+	// compute the angle difference between where are looking, and where we need to look
+	Vector toEnemy = victimOrigin - GetCentroid( this );
+
+	QAngle idealAngle;
+	VectorAngles( toEnemy, idealAngle );
+
+	float deltaYaw = (float)fabs(m_lookYaw - idealAngle.y);
+
+	while( deltaYaw > 180.0f )
+		deltaYaw -= 360.0f;
+
+	if (deltaYaw < 0.0f)
+		deltaYaw = -deltaYaw;
+
+	// immediately aim at enemy - accuracy penalty depending on how far we must turn to aim
+	// accuracy is halved if we have to turn 180 degrees
+	float turn = deltaYaw / 180.0f;
+	float accuracy = GetProfile()->GetSkill() / (1.0f + turn);
+
+	SetAimOffset( accuracy );
+
+	// define time when aim offset will automatically be updated
+	// longer time the more we had to turn (surprise)
+	m_aimOffsetTimestamp = gpGlobals->curtime + RandomFloat( 0.25f + turn, 1.5f );
+
+	// forget any look at targets we have
+	ClearLookAt();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Exit the Attack state
+ */
+void CCSBot::StopAttacking( void )
+{
+	PrintIfWatched( "ATTACK END\n" );
+	m_attackState.OnExit( this );
+	m_isAttacking = false;
+
+	// if we are following someone, go to the Idle state after the attack to decide whether we still want to follow
+	if (IsFollowing())
+	{
+		Idle();
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+bool CCSBot::IsAttacking( void ) const
+{
+	return m_isAttacking;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are escaping from the bomb
+ */
+bool CCSBot::IsEscapingFromBomb( void ) const
+{
+	if (m_state == static_cast<const BotState *>( &m_escapeFromBombState ))
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are defusing the bomb
+ */
+bool CCSBot::IsDefusingBomb( void ) const
+{
+	if (m_state == static_cast<const BotState *>( &m_defuseBombState ))
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are hiding
+ */
+bool CCSBot::IsHiding( void ) const
+{
+	if (m_state == static_cast<const BotState *>( &m_hideState ))
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are hiding and at our hiding spot
+ */
+bool CCSBot::IsAtHidingSpot( void ) const
+{
+	if (!IsHiding())
+		return false;
+
+	return m_hideState.IsAtSpot();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return number of seconds we have been at our current hiding spot
+ */
+float CCSBot::GetHidingTime( void ) const
+{
+	if (IsHiding())
+	{
+		return m_hideState.GetHideTime();
+	}
+
+	return 0.0f;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are huting
+ */
+bool CCSBot::IsHunting( void ) const
+{
+	if (m_state == static_cast<const BotState *>( &m_huntState ))
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are in the MoveTo state
+ */
+bool CCSBot::IsMovingTo( void ) const
+{
+	if (m_state == static_cast<const BotState *>( &m_moveToState ))
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are buying
+ */
+bool CCSBot::IsBuying( void ) const
+{
+	if (m_state == static_cast<const BotState *>( &m_buyState ))
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+bool CCSBot::IsInvestigatingNoise( void ) const
+{
+	if (m_state == static_cast<const BotState *>( &m_investigateNoiseState ))
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move to potentially distant position
+ */
+void CCSBot::MoveTo( const Vector &pos, RouteType route )
+{
+	m_moveToState.SetGoalPosition( pos );
+	m_moveToState.SetRouteType( route );
+	SetState( &m_moveToState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::PlantBomb( void )
+{
+	SetState( &m_plantBombState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Bomb has been dropped - go get it
+ */
+void CCSBot::FetchBomb( void )
+{
+	SetState( &m_fetchBombState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::DefuseBomb( void )
+{
+	SetState( &m_defuseBombState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Investigate recent enemy noise
+ */
+void CCSBot::InvestigateNoise( void )
+{
+	SetState( &m_investigateNoiseState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::Buy( void )
+{
+	SetState( &m_buyState );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move to a hiding spot and wait for initial encounter with enemy team.
+ * Return false if can't do this behavior (ie: no hiding spots available).
+ */
+bool CCSBot::MoveToInitialEncounter( void )
+{
+	int myTeam = GetTeamNumber();
+	int enemyTeam = OtherTeam( myTeam );
+
+	// build a path to an enemy spawn point
+	CBaseEntity *enemySpawn = TheCSBots()->GetRandomSpawn( enemyTeam );
+
+	if (enemySpawn == NULL)
+	{
+		PrintIfWatched( "MoveToInitialEncounter: No enemy spawn points?\n" );
+		return false;
+	}
+
+	// build a path from us to the enemy spawn
+	CCSNavPath path;
+	PathCost cost( this, FASTEST_ROUTE );
+	path.Compute( WorldSpaceCenter(), enemySpawn->GetAbsOrigin(), cost );
+
+	if (!path.IsValid())
+	{
+		PrintIfWatched( "MoveToInitialEncounter: Pathfind failed.\n" );
+		return false;
+	}
+
+	// find battlefront area where teams will first meet along this path
+	int i;
+	for( i=0; i<path.GetSegmentCount(); ++i )
+	{
+		if (path[i]->area->GetEarliestOccupyTime( myTeam ) > path[i]->area->GetEarliestOccupyTime( enemyTeam ))
+		{
+			break;
+		}
+	}
+
+	if (i == path.GetSegmentCount())
+	{
+		PrintIfWatched( "MoveToInitialEncounter: Can't find battlefront!\n" );
+		return false;
+	}
+
+	/// @todo Remove this evil side-effect
+	SetInitialEncounterArea( path[i]->area );
+
+	// find a hiding spot on our side of the battlefront that has LOS to it
+	const float maxRange = 1500.0f;
+	const HidingSpot *spot = FindInitialEncounterSpot( this, path[i]->area->GetCenter(), path[i]->area->GetEarliestOccupyTime( enemyTeam ), maxRange, IsSniper() );
+
+	if (spot == NULL)
+	{
+		PrintIfWatched( "MoveToInitialEncounter: Can't find a hiding spot\n" );
+		return false;
+	}
+
+	float timeToWait = path[i]->area->GetEarliestOccupyTime( enemyTeam ) - spot->GetArea()->GetEarliestOccupyTime( myTeam );
+	float minWaitTime = 4.0f * GetProfile()->GetAggression() + 3.0f;
+	if (timeToWait < minWaitTime)
+	{
+		timeToWait = minWaitTime;
+	}
+
+	Hide( spot->GetPosition(), timeToWait );
+
+	return true;
+}
+
diff --git a/game/server/cstrike/bot/cs_bot_update.cpp b/game/server/cstrike/bot/cs_bot_update.cpp
new file mode 100644
index 00000000..d57af0a6
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_update.cpp
@@ -0,0 +1,1211 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "cs_bot.h"
+#include "fmtstr.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------------------------------------
+float CCSBot::GetMoveSpeed( void )
+{
+	return 250.0f;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Lightweight maintenance, invoked frequently
+ */
+void CCSBot::Upkeep( void )
+{
+	VPROF_BUDGET( "CCSBot::Upkeep", VPROF_BUDGETGROUP_NPCS );
+
+	if (TheNavMesh->IsGenerating() || !IsAlive())
+		return;
+	
+	// If bot_flipout is on, then generate some random commands.
+	if ( cv_bot_flipout.GetBool() )
+	{
+		int val = RandomInt( 0, 2 );
+		if ( val == 0 )
+			MoveForward();
+		else if ( val == 1 )
+			MoveBackward();
+		
+		val = RandomInt( 0, 2 );
+		if ( val == 0 )
+			StrafeLeft();
+		else if ( val == 1 )
+			StrafeRight();
+
+		if ( RandomInt( 0, 5 ) == 0 )
+			Jump( true );
+		
+		val = RandomInt( 0, 2 );
+		if ( val == 0 )
+			Crouch();
+		else ( val == 1 );
+			StandUp();
+	
+		return;
+	}
+	
+	// BOTPORT: Remove this nasty hack
+	m_eyePosition = EyePosition();
+
+	Vector myOrigin = GetCentroid( this );
+
+	// aiming must be smooth - update often
+	if (IsAimingAtEnemy())
+	{
+		UpdateAimOffset();
+
+		// aim at enemy, if he's still alive
+		if (m_enemy != NULL && m_enemy->IsAlive())
+		{
+			Vector enemyOrigin = GetCentroid( m_enemy );
+
+			if (m_isEnemyVisible)
+			{
+				//
+				// Enemy is visible - determine which part of him to shoot at
+				//
+				const float sharpshooter = 0.8f;
+				VisiblePartType aimAtPart;
+
+				if (IsUsingMachinegun())
+				{
+					// spray the big machinegun at the enemy's gut
+					aimAtPart = GUT;
+				}
+				else if (IsUsing( WEAPON_AWP ) || IsUsingShotgun())
+				{
+					// these weapons are best aimed at the chest
+					aimAtPart = GUT;
+				}
+				else if (GetProfile()->GetSkill() > 0.5f && IsActiveWeaponRecoilHigh() )
+				{
+					// sprayin' and prayin' - aim at the gut since we're not going to be accurate
+					aimAtPart = GUT;
+				}
+				else if (GetProfile()->GetSkill() < sharpshooter)
+				{
+					// low skill bots don't go for headshots
+					aimAtPart = GUT;
+				}
+				else
+				{
+					// high skill - aim for the head
+					aimAtPart = HEAD;
+				}
+
+				if (IsEnemyPartVisible( aimAtPart ))
+				{
+					m_aimSpot = GetPartPosition( GetBotEnemy(), aimAtPart );
+				}
+				else
+				{
+					// desired part is blocked - aim at whatever part is visible 
+					if (IsEnemyPartVisible( GUT ))
+					{
+						m_aimSpot = GetPartPosition( GetBotEnemy(), GUT );
+					}
+					else if (IsEnemyPartVisible( HEAD ))
+					{
+						m_aimSpot = GetPartPosition( GetBotEnemy(), HEAD );
+					}
+					else if (IsEnemyPartVisible( LEFT_SIDE ))
+					{
+						m_aimSpot = GetPartPosition( GetBotEnemy(), LEFT_SIDE );
+					}
+					else if (IsEnemyPartVisible( RIGHT_SIDE ))
+					{
+						m_aimSpot = GetPartPosition( GetBotEnemy(), RIGHT_SIDE );
+					}
+					else // FEET
+					{
+						m_aimSpot = GetPartPosition( GetBotEnemy(), FEET );
+					}
+				}
+
+				// high skill bots lead the target a little to compensate for update tick latency
+				/*
+				if (false && GetProfile()->GetSkill() > 0.5f)
+				{
+					const float k = 1.0f;
+					m_aimSpot += k * g_flBotCommandInterval * (m_enemy->GetAbsVelocity() - GetAbsVelocity());
+				}
+				*/
+
+			}
+			else
+			{
+				// aim where we last saw enemy - but bend the ray so we dont point directly into walls
+				// if we put this back, make sure you only bend the ray ONCE and keep the bent spot - dont continually recompute
+				//BendLineOfSight( m_eyePosition, m_lastEnemyPosition, &m_aimSpot );
+				m_aimSpot = m_lastEnemyPosition;
+			}
+
+			// add in aim error
+			m_aimSpot.x += m_aimOffset.x;
+			m_aimSpot.y += m_aimOffset.y;
+			m_aimSpot.z += m_aimOffset.z;
+
+			Vector to = m_aimSpot - EyePositionConst();
+
+			QAngle idealAngle;
+			VectorAngles( to, idealAngle );
+
+			// adjust aim angle for recoil, based on bot skill
+			const QAngle &punchAngles = GetPunchAngle();
+			idealAngle -= punchAngles * GetProfile()->GetSkill();
+
+			SetLookAngles( idealAngle.y, idealAngle.x );
+		}
+	}
+	else
+	{
+		if (m_lookAtSpotClearIfClose)
+		{
+			// dont look at spots just in front of our face - it causes erratic view rotation
+			const float tooCloseRange = 100.0f;
+			if ((m_lookAtSpot - myOrigin).IsLengthLessThan( tooCloseRange ))
+				m_lookAtSpotState = NOT_LOOKING_AT_SPOT;
+		}
+
+		switch( m_lookAtSpotState )
+		{
+			case NOT_LOOKING_AT_SPOT:
+			{
+				// look ahead
+				SetLookAngles( m_lookAheadAngle, 0.0f );
+				break;
+			}
+
+			case LOOK_TOWARDS_SPOT:
+			{
+				UpdateLookAt();
+				if (IsLookingAtPosition( m_lookAtSpot, m_lookAtSpotAngleTolerance ))
+				{
+					m_lookAtSpotState = LOOK_AT_SPOT;
+					m_lookAtSpotTimestamp = gpGlobals->curtime;
+				}
+				break;
+			}
+
+			case LOOK_AT_SPOT:
+			{
+				UpdateLookAt();
+
+				if (m_lookAtSpotDuration >= 0.0f && gpGlobals->curtime - m_lookAtSpotTimestamp > m_lookAtSpotDuration)
+				{
+					m_lookAtSpotState = NOT_LOOKING_AT_SPOT;
+					m_lookAtSpotDuration = 0.0f;
+				}
+				break;
+			}
+		}
+
+		// have view "drift" very slowly, so view looks "alive"
+		if (!IsUsingSniperRifle())
+		{
+			float driftAmplitude = 2.0f;
+			if (IsBlind())
+			{
+				driftAmplitude = 5.0f;
+			}
+
+			m_lookYaw += driftAmplitude * BotCOS( 33.0f * gpGlobals->curtime );
+			m_lookPitch += driftAmplitude * BotSIN( 13.0f * gpGlobals->curtime );
+		}
+	}
+
+	// view angles can change quickly
+	UpdateLookAngles();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Heavyweight processing, invoked less often
+ */
+void CCSBot::Update( void )
+{
+	VPROF_BUDGET( "CCSBot::Update", VPROF_BUDGETGROUP_NPCS );
+
+	// If bot_flipout is on, then we only do stuff in Upkeep().
+	if ( cv_bot_flipout.GetBool() )
+		return;
+
+	Vector myOrigin = GetCentroid( this );
+
+	// if we are spectating, get into the game
+	if (GetTeamNumber() == 0)
+	{
+		HandleCommand_JoinTeam( m_desiredTeam );
+		int desiredClass = GetProfile()->GetSkin();
+		if ( m_desiredTeam == TEAM_CT && desiredClass )
+		{
+			desiredClass = FIRST_CT_CLASS + desiredClass - 1;
+		}
+		else if ( m_desiredTeam == TEAM_TERRORIST && desiredClass )
+		{
+			desiredClass = FIRST_T_CLASS + desiredClass - 1;
+		}
+		HandleCommand_JoinClass( desiredClass );
+		return;
+	}
+
+
+	// update our radio chatter
+	// need to allow bots to finish their chatter even if they are dead
+	GetChatter()->Update();
+	
+	// check if we are dead
+	if (!IsAlive())
+	{
+		// remember that we died
+		m_diedLastRound = true;
+
+		BotDeathThink();
+		return;
+	}
+
+	// the bot is alive and in the game at this point
+	m_hasJoined = true;
+
+	//
+	// Debug beam rendering
+	//
+
+	if (cv_bot_debug.GetBool() && IsLocalPlayerWatchingMe())
+	{
+		DebugDisplay();
+	}
+
+	if (cv_bot_stop.GetBool())
+		return;
+
+	// check if we are stuck
+	StuckCheck();
+
+	// Check for physics props and other breakables in our way that we can break
+	BreakablesCheck();
+
+	// Check for useable doors in our way that we need to open
+	DoorCheck();
+
+	// update travel distance to all players (this is an optimization)
+	UpdateTravelDistanceToAllPlayers();
+
+	// if our current 'noise' was heard a long time ago, forget it
+	const float rememberNoiseDuration = 20.0f;
+	if (m_noiseTimestamp > 0.0f && gpGlobals->curtime - m_noiseTimestamp > rememberNoiseDuration)
+	{
+		ForgetNoise();
+	}
+
+	// where are we
+	if (!m_currentArea || !m_currentArea->Contains( myOrigin ))
+	{
+		m_currentArea = (CCSNavArea *)TheNavMesh->GetNavArea( myOrigin );
+	}
+
+	// track the last known area we were in
+	if (m_currentArea && m_currentArea != m_lastKnownArea)
+	{
+		m_lastKnownArea = m_currentArea;
+
+		OnEnteredNavArea( m_currentArea );
+	}
+
+	// keep track of how long we have been motionless
+	const float stillSpeed = 10.0f;
+	if (GetAbsVelocity().IsLengthLessThan( stillSpeed ))
+	{
+		m_stillTimer.Start();
+	}
+	else
+	{
+		m_stillTimer.Invalidate();
+	}
+
+	// if we're blind, retreat!
+	if (IsBlind())
+	{
+		if (m_blindFire)
+		{
+			PrimaryAttack();
+		}
+	}
+
+	UpdatePanicLookAround();
+
+	//
+	// Enemy acquisition and attack initiation
+	//
+
+	// take a snapshot and update our reaction time queue
+	UpdateReactionQueue();
+
+	// "threat" may be the same as our current enemy
+	CCSPlayer *threat = GetRecognizedEnemy();
+	if (threat)
+	{
+		Vector threatOrigin = GetCentroid( threat );
+
+		// adjust our personal "safe" time
+		AdjustSafeTime();
+
+		BecomeAlert();
+
+		const float selfDefenseRange = 500.0f; // 750.0f;
+		const float farAwayRange = 2000.0f;
+
+		//
+		// Decide if we should attack
+		//
+		bool doAttack = false;
+		switch( GetDisposition() )
+		{
+			case IGNORE_ENEMIES:
+			{
+				// never attack
+				doAttack = false;
+				break;
+			}
+
+			case SELF_DEFENSE:
+			{
+				// attack if fired on
+				doAttack = (IsPlayerLookingAtMe( threat, 0.99f ) && DidPlayerJustFireWeapon( threat ));
+
+				// attack if enemy very close
+				if (!doAttack)
+				{
+					doAttack = (myOrigin - threatOrigin).IsLengthLessThan( selfDefenseRange );
+				}
+
+				break;
+			}
+
+			case ENGAGE_AND_INVESTIGATE:
+			case OPPORTUNITY_FIRE:
+			{
+				if ((myOrigin - threatOrigin).IsLengthGreaterThan( farAwayRange ))
+				{
+					// enemy is very far away - wait to take our shot until he is closer
+					// unless we are a sniper or he is shooting at us
+					if (IsSniper())
+					{
+						// snipers love far away targets
+						doAttack = true;
+					}
+					else
+					{
+						// attack if fired on
+						doAttack = (IsPlayerLookingAtMe( threat, 0.99f ) && DidPlayerJustFireWeapon( threat ));					
+					}
+				}
+				else
+				{
+					// normal combat range
+					doAttack = true;
+				}
+
+				break;
+			}
+		}
+
+		// if we aren't attacking but we are being attacked, retaliate
+		if (!doAttack && !IsAttacking() && GetDisposition() != IGNORE_ENEMIES)
+		{
+			const float recentAttackDuration = 1.0f;
+			if (GetTimeSinceAttacked() < recentAttackDuration)
+			{
+				// we may not be attacking our attacker, but at least we're not just taking it
+				// (since m_attacker isn't reaction-time delayed, we can't directly use it)
+				doAttack = true;
+				PrintIfWatched( "Ouch! Retaliating!\n" );
+			}
+		}
+
+		if (doAttack)
+		{
+			if (!IsAttacking() || threat != GetBotEnemy())
+			{
+				if (IsUsingKnife() && IsHiding())
+				{
+					// if hiding with a knife, wait until threat is close
+					const float knifeAttackRange = 250.0f;
+					if ((GetAbsOrigin() - threat->GetAbsOrigin()).IsLengthLessThan( knifeAttackRange ))
+					{
+						Attack( threat );
+					}
+				}
+				else
+				{
+					Attack( threat );
+				}
+			}
+		}
+		else
+		{
+			// dont attack, but keep track of nearby enemies
+			SetBotEnemy( threat );
+			m_isEnemyVisible = true;
+		}
+
+		TheCSBots()->SetLastSeenEnemyTimestamp();
+	}
+
+	//
+	// Validate existing enemy, if any
+	//
+	if (m_enemy != NULL)
+	{
+		if (IsAwareOfEnemyDeath())
+		{
+			// we have noticed that our enemy has died
+			m_enemy = NULL;
+			m_isEnemyVisible = false;
+		}
+		else
+		{
+			// check LOS to current enemy (chest & head), in case he's dead (GetNearestEnemy() only returns live players)
+			// note we're not checking FOV - once we've acquired an enemy (which does check FOV), assume we know roughly where he is
+			if (IsVisible( m_enemy, false, &m_visibleEnemyParts ))
+			{
+				m_isEnemyVisible = true;
+				m_lastSawEnemyTimestamp = gpGlobals->curtime;
+				m_lastEnemyPosition = GetCentroid( m_enemy );
+			}
+			else
+			{
+				m_isEnemyVisible = false;
+			}
+				
+			// check if enemy died
+			if (m_enemy->IsAlive())
+			{
+				m_enemyDeathTimestamp = 0.0f;
+				m_isLastEnemyDead = false;
+			}
+			else if (m_enemyDeathTimestamp == 0.0f)
+			{
+				// note time of death (to allow bots to overshoot for a time)
+				m_enemyDeathTimestamp = gpGlobals->curtime;
+				m_isLastEnemyDead = true;
+			}
+		}
+	}
+	else
+	{
+		m_isEnemyVisible = false;
+	}
+
+
+	// if we have seen an enemy recently, keep an eye on him if we can
+	if (!IsBlind() && !IsLookingAtSpot(PRIORITY_UNINTERRUPTABLE) )
+	{
+		const float seenRecentTime = 3.0f;
+		if (m_enemy != NULL && GetTimeSinceLastSawEnemy() < seenRecentTime)
+		{
+			AimAtEnemy();
+		}
+		else
+		{
+			StopAiming();
+		}
+	}
+	else if( IsAimingAtEnemy() )
+	{
+		StopAiming();
+	}
+
+	//
+	// Hack to fire while retreating
+	/// @todo Encapsulate aiming and firing on enemies separately from current task
+	//
+	if (GetDisposition() == IGNORE_ENEMIES)
+	{
+		FireWeaponAtEnemy();
+	}
+
+	// toss grenades
+	LookForGrenadeTargets();
+
+	// process grenade throw state machine
+	UpdateGrenadeThrow();
+
+	// avoid enemy grenades
+	AvoidEnemyGrenades();
+
+
+	// check if our weapon is totally out of ammo
+	// or if we no longer feel "safe", equip our weapon
+	if (!IsSafe() && !IsUsingGrenade() && IsActiveWeaponOutOfAmmo())
+	{
+		EquipBestWeapon();
+	}
+
+	/// @todo This doesn't work if we are restricted to just knives and sniper rifles because we cant use the rifle at close range
+	if (!IsSafe() && !IsUsingGrenade() && IsUsingKnife() && !IsEscapingFromBomb())
+	{
+		EquipBestWeapon();
+	}
+
+	// if we haven't seen an enemy in awhile, and we switched to our pistol during combat, 
+	// switch back to our primary weapon (if it still has ammo left)
+	const float safeRearmTime = 5.0f;
+	if (!IsReloading() && IsUsingPistol() && !IsPrimaryWeaponEmpty() && GetTimeSinceLastSawEnemy() > safeRearmTime)
+	{
+		EquipBestWeapon();
+	}
+
+	// reload our weapon if we must
+	ReloadCheck();
+
+	// equip silencer
+	SilencerCheck();
+
+	// listen to the radio
+	RespondToRadioCommands();
+
+	// make way
+	const float avoidTime = 0.33f;
+	if (gpGlobals->curtime - m_avoidTimestamp < avoidTime && m_avoid != NULL)
+	{
+		StrafeAwayFromPosition( GetCentroid( m_avoid ) );
+	}
+	else
+	{
+		m_avoid = NULL;
+	}
+
+	// if we're using a sniper rifle and are no longer attacking, stop looking thru scope
+	if (!IsAtHidingSpot() && !IsAttacking() && IsUsingSniperRifle() && IsUsingScope())
+	{
+		SecondaryAttack();
+	}
+
+	if (!IsBlind())
+	{
+		// check encounter spots
+		UpdatePeripheralVision();
+
+		// watch for snipers
+		if (CanSeeSniper() && !HasSeenSniperRecently())
+		{
+			GetChatter()->SpottedSniper();
+
+			const float sniperRecentInterval = 20.0f;
+			m_sawEnemySniperTimer.Start( sniperRecentInterval );
+		}
+
+		//
+		// Update gamestate
+		//
+		if (m_bomber != NULL)
+			GetChatter()->SpottedBomber( GetBomber() );
+
+		if (CanSeeLooseBomb())
+			GetChatter()->SpottedLooseBomb( TheCSBots()->GetLooseBomb() );
+	}
+
+	//
+	// Scenario interrupts
+	//
+	switch (TheCSBots()->GetScenario())
+	{
+		case CCSBotManager::SCENARIO_DEFUSE_BOMB:
+		{
+			// flee if the bomb is ready to blow and we aren't defusing it or attacking and we know where the bomb is
+			// (aggressive players wait until its almost too late)
+			float gonnaBlowTime = 8.0f - (2.0f * GetProfile()->GetAggression());
+
+			// if we have a defuse kit, can wait longer
+			if (m_bHasDefuser)
+				gonnaBlowTime *= 0.66f;
+
+			if (!IsEscapingFromBomb() &&								// we aren't already escaping the bomb
+				TheCSBots()->IsBombPlanted() &&							// is the bomb planted
+				GetGameState()->IsPlantedBombLocationKnown() &&			// we know where the bomb is
+				TheCSBots()->GetBombTimeLeft() < gonnaBlowTime &&		// is the bomb about to explode
+				!IsDefusingBomb() &&									// we aren't defusing the bomb
+				!IsAttacking())											// we aren't in the midst of a firefight
+			{
+				EscapeFromBomb();
+				break;
+			}
+
+			break;
+		}
+
+		case CCSBotManager::SCENARIO_RESCUE_HOSTAGES:
+		{
+			if (GetTeamNumber() == TEAM_CT)
+			{
+				UpdateHostageEscortCount();
+			}
+			else
+			{
+				// Terrorists have imperfect information on status of hostages
+				unsigned char status = GetGameState()->ValidateHostagePositions();
+
+				if (status & CSGameState::HOSTAGES_ALL_GONE)
+				{
+					GetChatter()->HostagesTaken();
+					Idle();
+				}
+				else if (status & CSGameState::HOSTAGE_GONE)
+				{
+					GetGameState()->HostageWasTaken();
+					Idle();
+				}
+			}
+			break;
+		}
+	}
+
+
+	//
+	// Follow nearby humans if our co-op is high and we have nothing else to do
+	// If we were just following someone, don't auto-follow again for a short while to 
+	// give us a chance to do something else.
+	//
+	const float earliestAutoFollowTime = 5.0f;
+	const float minAutoFollowTeamwork = 0.4f;
+	if (cv_bot_auto_follow.GetBool() &&
+		TheCSBots()->GetElapsedRoundTime() > earliestAutoFollowTime &&
+		GetProfile()->GetTeamwork() > minAutoFollowTeamwork && 
+		CanAutoFollow() &&
+		!IsBusy() && 
+		!IsFollowing() && 
+		!IsBlind() && 
+		!GetGameState()->IsAtPlantedBombsite())
+	{
+
+		// chance of following is proportional to teamwork attribute
+		if (GetProfile()->GetTeamwork() > RandomFloat( 0.0f, 1.0f ))
+		{
+			CCSPlayer *leader = GetClosestVisibleHumanFriend();
+			if (leader && leader->IsAutoFollowAllowed())
+			{
+				// count how many bots are already following this player
+				const float maxFollowCount = 2;
+				if (GetBotFollowCount( leader ) < maxFollowCount)
+				{
+					const float autoFollowRange = 300.0f;
+					Vector leaderOrigin = GetCentroid( leader );
+					if ((leaderOrigin - myOrigin).IsLengthLessThan( autoFollowRange ))
+					{
+						CNavArea *leaderArea = TheNavMesh->GetNavArea( leaderOrigin );
+						if (leaderArea)
+						{
+							PathCost cost( this, FASTEST_ROUTE );
+							float travelRange = NavAreaTravelDistance( GetLastKnownArea(), leaderArea, cost );
+							if (travelRange >= 0.0f && travelRange < autoFollowRange)
+							{
+								// follow this human
+								Follow( leader );
+								PrintIfWatched( "Auto-Following %s\n", leader->GetPlayerName() );
+
+								if (CSGameRules()->IsCareer())
+								{
+									GetChatter()->Say( "FollowingCommander", 10.0f );
+								}
+								else
+								{
+									GetChatter()->Say( "FollowingSir", 10.0f );
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			// we decided not to follow, don't re-check for a duration
+			m_allowAutoFollowTime = gpGlobals->curtime + 15.0f + (1.0f - GetProfile()->GetTeamwork()) * 30.0f;
+		}
+	}
+
+	if (IsFollowing())
+	{
+		// if we are following someone, make sure they are still alive
+		CBaseEntity *leader = m_leader;
+		if (leader == NULL || !leader->IsAlive())
+		{
+			StopFollowing();
+		}
+
+		// decide whether to continue following them
+		const float highTeamwork = 0.85f;
+		if (GetProfile()->GetTeamwork() < highTeamwork)
+		{
+			float minFollowDuration = 15.0f;
+			if (GetFollowDuration() > minFollowDuration + 40.0f * GetProfile()->GetTeamwork())
+			{
+				// we are bored of following our leader
+				StopFollowing();
+				PrintIfWatched( "Stopping following - bored\n" );
+			}
+		}
+	}
+
+
+	//
+	// Execute state machine
+	//
+	if (m_isOpeningDoor)
+	{
+		// opening doors takes precedence over attacking because DoorCheck() will stop opening doors if
+		// we don't have a knife out.
+		m_openDoorState.OnUpdate( this );
+
+		if (m_openDoorState.IsDone())
+		{
+			// open door behavior is finished, return to previous behavior context
+			m_openDoorState.OnExit( this );
+			m_isOpeningDoor = false;
+		}
+	}
+	else if (m_isAttacking)
+	{
+		m_attackState.OnUpdate( this );
+	}
+	else
+	{
+		m_state->OnUpdate( this );
+	}
+
+	// do wait behavior
+	if (!IsAttacking() && IsWaiting())
+	{
+		ResetStuckMonitor();
+		ClearMovement();
+	}
+
+	// don't move while reloading unless we see an enemy
+	if (IsReloading() && !m_isEnemyVisible)
+	{
+		ResetStuckMonitor();
+		ClearMovement();
+	}
+
+	// if we get too far ahead of the hostages we are escorting, wait for them
+	if (!IsAttacking() && m_inhibitWaitingForHostageTimer.IsElapsed())
+	{
+		const float waitForHostageRange = 500.0f;
+		if ((GetTask() == COLLECT_HOSTAGES || GetTask() == RESCUE_HOSTAGES) && GetRangeToFarthestEscortedHostage() > waitForHostageRange)
+		{
+			if (!m_isWaitingForHostage)
+			{
+				// just started waiting
+				m_isWaitingForHostage = true;
+				m_waitForHostageTimer.Start( 10.0f );
+			}
+			else
+			{
+				// we've been waiting
+				if (m_waitForHostageTimer.IsElapsed())
+				{
+					// give up waiting for awhile
+					m_isWaitingForHostage = false;
+					m_inhibitWaitingForHostageTimer.Start( 3.0f );
+				}
+				else
+				{
+					// keep waiting
+					ResetStuckMonitor();
+					ClearMovement();
+				}
+			}
+		}
+	}
+
+	// remember our prior safe time status
+	m_wasSafe = IsSafe();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+class DrawTravelTime 
+{
+public:
+	DrawTravelTime( const CCSBot *me )
+	{
+		m_me = me;
+	}
+
+	bool operator() ( CBasePlayer *player )
+	{
+		if (player->IsAlive() && !m_me->InSameTeam( player ))
+		{
+			CFmtStr msg;
+			player->EntityText(	0,
+								msg.sprintf( "%3.0f", m_me->GetTravelDistanceToPlayer( (CCSPlayer *)player ) ),
+								0.1f );
+
+
+			if (m_me->DidPlayerJustFireWeapon( ToCSPlayer( player ) ))
+			{
+				player->EntityText( 1, "BANG!", 0.1f );
+			}
+		}
+
+		return true;
+	}
+
+	const CCSBot *m_me;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Render bot debug info
+ */
+void CCSBot::DebugDisplay( void ) const
+{
+	const float duration = 0.15f;
+	CFmtStr msg;
+	
+	NDebugOverlay::ScreenText( 0.5f, 0.34f, msg.sprintf( "Skill: %d%%", (int)(100.0f * GetProfile()->GetSkill()) ), 255, 255, 255, 150, duration );
+
+	if ( m_pathLadder )
+	{
+		NDebugOverlay::ScreenText( 0.5f, 0.36f, msg.sprintf( "Ladder: %d", m_pathLadder->GetID() ), 255, 255, 255, 150, duration );
+	}
+
+	// show safe time
+	float safeTime = GetSafeTimeRemaining();
+	if (safeTime > 0.0f)
+	{
+		NDebugOverlay::ScreenText( 0.5f, 0.38f, msg.sprintf( "SafeTime: %3.2f", safeTime ), 255, 255, 255, 150, duration );
+	}
+
+	// show if blind
+	if (IsBlind())
+	{
+		NDebugOverlay::ScreenText( 0.5f, 0.38f, msg.sprintf( "<<< BLIND >>>" ), 255, 255, 255, 255, duration );
+	}
+
+	// show if alert
+	if (IsAlert())
+	{
+		NDebugOverlay::ScreenText( 0.5f, 0.38f, msg.sprintf( "ALERT" ), 255, 0, 0, 255, duration );
+	}
+
+	// show if panicked
+	if (IsPanicking())
+	{
+		NDebugOverlay::ScreenText( 0.5f, 0.36f, msg.sprintf( "PANIC" ), 255, 255, 0, 255, duration );
+	}
+
+	// show behavior variables
+	if (m_isAttacking)
+	{
+		NDebugOverlay::ScreenText( 0.5f, 0.4f, msg.sprintf( "ATTACKING: %s", GetBotEnemy()->GetPlayerName() ), 255, 0, 0, 255, duration );
+	}
+	else
+	{
+		NDebugOverlay::ScreenText( 0.5f, 0.4f, msg.sprintf( "State: %s", m_state->GetName() ), 255, 255, 0, 255, duration );
+		NDebugOverlay::ScreenText( 0.5f, 0.42f, msg.sprintf( "Task: %s", GetTaskName() ), 0, 255, 0, 255, duration );
+		NDebugOverlay::ScreenText( 0.5f, 0.44f, msg.sprintf( "Disposition: %s", GetDispositionName() ), 100, 100, 255, 255, duration );
+		NDebugOverlay::ScreenText( 0.5f, 0.46f, msg.sprintf( "Morale: %s", GetMoraleName() ), 0, 200, 200, 255, duration );
+	}
+
+	// show look at status
+	if (m_lookAtSpotState != NOT_LOOKING_AT_SPOT)
+	{
+		const char *string = msg.sprintf( "LookAt: %s (%s)", m_lookAtDesc, (m_lookAtSpotState == LOOK_TOWARDS_SPOT) ? "LOOK_TOWARDS_SPOT" : "LOOK_AT_SPOT" );
+
+		NDebugOverlay::ScreenText( 0.5f, 0.60f, string, 255, 255, 0, 150, duration );
+	}
+
+	NDebugOverlay::ScreenText( 0.5f, 0.62f, msg.sprintf( "Steady view = %s", HasViewBeenSteady( 0.2f ) ? "YES" : "NO" ), 255, 255, 0, 150, duration );
+
+
+	// show friend/foes I know of
+	NDebugOverlay::ScreenText( 0.5f, 0.64f, msg.sprintf( "Nearby friends = %d", m_nearbyFriendCount ), 100, 255, 100, 150, duration );
+	NDebugOverlay::ScreenText( 0.5f, 0.66f, msg.sprintf( "Nearby enemies = %d", m_nearbyEnemyCount ), 255, 100, 100, 150, duration );
+
+	if ( m_lastNavArea )
+	{
+		NDebugOverlay::ScreenText( 0.5f, 0.68f, msg.sprintf( "Nav Area: %d (%s)", m_lastNavArea->GetID(), m_szLastPlaceName.Get() ), 255, 255, 255, 150, duration );
+		/*
+		if ( cv_bot_traceview.GetBool() )
+		{
+			if ( m_currentArea )
+			{
+				NDebugOverlay::Line( GetAbsOrigin(), m_currentArea->GetCenter(), 0, 255, 0, true, 0.1f );
+			}
+			else if ( m_lastKnownArea )
+			{
+				NDebugOverlay::Line( GetAbsOrigin(), m_lastKnownArea->GetCenter(), 255, 0, 0, true, 0.1f );
+			}
+			else if ( m_lastNavArea )
+			{
+				NDebugOverlay::Line( GetAbsOrigin(), m_lastNavArea->GetCenter(), 0, 0, 255, true, 0.1f );
+			}
+		}
+		*/
+	}
+
+	// show debug message history
+	float y = 0.8f;
+	const float lineHeight = 0.02f;
+	const float fadeAge = 7.0f;
+	const float maxAge = 10.0f;
+	for( int i=0; i<TheBots->GetDebugMessageCount(); ++i )
+	{
+		const CBotManager::DebugMessage *msg = TheBots->GetDebugMessage( i );
+
+		if (msg->m_age.GetElapsedTime() < maxAge)
+		{
+			int alpha = 255;
+
+			if (msg->m_age.GetElapsedTime() > fadeAge)
+			{
+				alpha *= (1.0f - (msg->m_age.GetElapsedTime() - fadeAge) / (maxAge - fadeAge));
+			}
+
+			NDebugOverlay::ScreenText( 0.5f, y, msg->m_string, 255, 255, 255, alpha, duration );
+			y += lineHeight;
+		}
+	}
+
+	// show noises
+	const Vector *noisePos = GetNoisePosition();
+	if (noisePos)
+	{
+		const float size = 25.0f;
+		NDebugOverlay::VertArrow( *noisePos + Vector( 0, 0, size ), *noisePos, size/4.0f, 255, 255, 0, 0, true, duration );
+	}
+
+	// show aim spot
+	if (IsAimingAtEnemy())
+	{
+		NDebugOverlay::Cross3D( m_aimSpot, 5.0f, 255, 0, 0, true, duration );
+	}
+
+
+
+	if (IsHiding())
+	{
+		// show approach points
+		DrawApproachPoints();
+	}
+	else
+	{
+		// show encounter spot data
+		if (false && m_spotEncounter)
+		{
+			NDebugOverlay::Line( m_spotEncounter->path.from, m_spotEncounter->path.to, 0, 150, 150, true, 0.1f );
+
+			Vector dir = m_spotEncounter->path.to - m_spotEncounter->path.from;
+			float length = dir.NormalizeInPlace();
+
+			const SpotOrder *order;
+			Vector along;
+
+			FOR_EACH_VEC( m_spotEncounter->spots, it )
+			{
+				order = &m_spotEncounter->spots[ it ];
+
+				// ignore spots the enemy could not have possibly reached yet
+				if (order->spot->GetArea())
+				{
+					if (TheCSBots()->GetElapsedRoundTime() < order->spot->GetArea()->GetEarliestOccupyTime( OtherTeam( GetTeamNumber() ) ))
+					{
+						continue;
+					}
+				}
+
+				along = m_spotEncounter->path.from + order->t * length * dir;
+
+				NDebugOverlay::Line( along, order->spot->GetPosition(), 0, 255, 255, true, 0.1f );
+			}
+		}
+	}
+
+	// show aim targets
+	if (false)
+	{
+		CStudioHdr *pStudioHdr = const_cast< CCSBot *>( this )->GetModelPtr();
+		if ( !pStudioHdr )
+			return;
+
+		mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( const_cast< CCSBot *>( this )->GetHitboxSet() );
+		if ( !set )
+			return;
+
+		Vector position, forward, right, up;
+		QAngle angles;
+		char buffer[16];
+
+		for ( int i = 0; i < set->numhitboxes; i++ )
+		{
+			mstudiobbox_t *pbox = set->pHitbox( i );
+
+			const_cast< CCSBot *>( this )->GetBonePosition( pbox->bone, position, angles );
+		
+			AngleVectors( angles, &forward, &right, &up );
+
+			NDebugOverlay::BoxAngles( position, pbox->bbmin, pbox->bbmax, angles, 255, 0, 0, 0, 0.1f );
+
+			const float size = 5.0f;
+			NDebugOverlay::Line( position, position + size * forward, 255, 255, 0, true, 0.1f );
+			NDebugOverlay::Line( position, position + size * right, 255, 0, 0, true, 0.1f );
+			NDebugOverlay::Line( position, position + size * up, 0, 255, 0, true, 0.1f );
+
+			Q_snprintf( buffer, 16, "%d", i );
+			if (i == 12)
+			{
+				// in local bone space
+				const float headForwardOffset = 4.0f;
+				const float headRightOffset = 2.0f;
+				position += headForwardOffset * forward + headRightOffset * right;
+			}
+			NDebugOverlay::Text( position, buffer, true, 0.1f );
+		}
+	}
+
+
+	/*
+	const QAngle &angles = const_cast< CCSBot *>( this )->GetPunchAngle();
+	NDebugOverlay::ScreenText( 0.3f, 0.66f, msg.sprintf( "Punch angle pitch = %3.2f", angles.x ), 255, 255, 0, 150, duration );
+	*/
+
+	DrawTravelTime drawTravelTime( this );
+	ForEachPlayer( drawTravelTime );
+
+/*
+	// show line of fire
+	if ((cv_bot_traceview.GetInt() == 100 && IsLocalPlayerWatchingMe()) || cv_bot_traceview.GetInt() == 101)
+	{
+		if (!IsFriendInLineOfFire())
+		{
+			Vector vecAiming = GetViewVector();
+			Vector vecSrc	 = EyePositionConst();
+
+			if (GetTeamNumber() == TEAM_TERRORIST)
+				UTIL_DrawBeamPoints( vecSrc, vecSrc + 2000.0f * vecAiming, 1, 255, 0, 0 );
+			else
+				UTIL_DrawBeamPoints( vecSrc, vecSrc + 2000.0f * vecAiming, 1, 0, 50, 255 );
+		}
+	}
+
+	// show path navigation data
+	if (cv_bot_traceview.GetInt() == 1 && IsLocalPlayerWatchingMe())
+	{
+		Vector from = EyePositionConst();
+
+		const float size = 50.0f;
+		//Vector arrow( size * cos( m_forwardAngle * M_PI/180.0f ), size * sin( m_forwardAngle * M_PI/180.0f ), 0.0f );
+		Vector arrow( size * (float)cos( m_lookAheadAngle * M_PI/180.0f ), 
+					  size * (float)sin( m_lookAheadAngle * M_PI/180.0f ), 
+					  0.0f );
+		
+		UTIL_DrawBeamPoints( from, from + arrow, 1, 0, 255, 255 );
+	}
+
+	if (cv_bot_show_nav.GetBool() && m_lastKnownArea)
+	{
+		m_lastKnownArea->DrawConnectedAreas();
+	}
+	*/
+
+
+	if (IsAttacking())
+	{
+		const float crossSize = 2.0f;
+		CCSPlayer *enemy = GetBotEnemy();
+		if (enemy)
+		{
+			NDebugOverlay::Cross3D( GetPartPosition( enemy, GUT ), crossSize, 0, 255, 0, true, 0.1f );
+			NDebugOverlay::Cross3D( GetPartPosition( enemy, HEAD ), crossSize, 0, 255, 0, true, 0.1f );
+			NDebugOverlay::Cross3D( GetPartPosition( enemy, FEET ), crossSize, 0, 255, 0, true, 0.1f );
+			NDebugOverlay::Cross3D( GetPartPosition( enemy, LEFT_SIDE ), crossSize, 0, 255, 0, true, 0.1f );
+			NDebugOverlay::Cross3D( GetPartPosition( enemy, RIGHT_SIDE ), crossSize, 0, 255, 0, true, 0.1f );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Periodically compute shortest path distance to each player.
+ * NOTE: Travel distance is NOT symmetric between players A and B.  Each much be computed separately.
+ */
+void CCSBot::UpdateTravelDistanceToAllPlayers( void )
+{
+	const unsigned char numPhases = 3;
+
+	if (m_updateTravelDistanceTimer.IsElapsed())
+	{
+		ShortestPathCost pathCost;
+
+		for( int i=1; i<=gpGlobals->maxClients; ++i )
+		{
+			CCSPlayer *player = static_cast< CCSPlayer * >( UTIL_PlayerByIndex( i ) );
+
+			if (player == NULL)
+				continue;
+
+			if (FNullEnt( player->edict() ))
+				continue;
+
+			if (!player->IsPlayer())
+				continue;
+			
+			if (!player->IsAlive())
+				continue;
+
+			// skip friends for efficiency
+			if (player->InSameTeam( this ))
+				continue;
+
+			int which = player->entindex() % MAX_PLAYERS;
+
+			// if player is very far away, update every third time (on phase 0)
+			const float veryFarAway = 4000.0f;
+			if (m_playerTravelDistance[ which ] < 0.0f || m_playerTravelDistance[ which ] > veryFarAway)
+			{
+				if (m_travelDistancePhase != 0)
+					continue;
+			}
+			else
+			{
+				// if player is far away, update two out of three times (on phases 1 and 2)
+				const float farAway = 2000.0f;
+				if (m_playerTravelDistance[ which ] > farAway && m_travelDistancePhase == 0)
+					continue;
+			}
+
+			// if player is fairly close, update often
+			m_playerTravelDistance[ which ] = NavAreaTravelDistance( EyePosition(), player->EyePosition(), pathCost );
+		}
+
+		// throttle the computation frequency
+		const float checkInterval = 1.0f;
+		m_updateTravelDistanceTimer.Start( checkInterval );
+
+		// round-robin the phases
+		++m_travelDistancePhase;
+		if (m_travelDistancePhase >= numPhases)
+		{
+			m_travelDistancePhase = 0;
+		}
+	}
+}
diff --git a/game/server/cstrike/bot/cs_bot_vision.cpp b/game/server/cstrike/bot/cs_bot_vision.cpp
new file mode 100644
index 00000000..a7e85003
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_vision.cpp
@@ -0,0 +1,1834 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+#include "datacache/imdlcache.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Used to update view angles to stay on a ladder
+ */
+inline float StayOnLadderLine( CCSBot *me, const CNavLadder *ladder )
+{
+	// determine our facing
+	NavDirType faceDir = AngleToDirection( me->EyeAngles().y );
+
+	const float stiffness = 1.0f;
+
+	// move toward ladder mount point
+	switch( faceDir )
+	{
+		case NORTH:
+			return stiffness * (ladder->m_top.x - me->GetAbsOrigin().x);
+
+		case SOUTH:
+			return -stiffness * (ladder->m_top.x - me->GetAbsOrigin().x);
+
+		case WEST:
+			return -stiffness * (ladder->m_top.y - me->GetAbsOrigin().y);
+
+		case EAST:
+			return stiffness * (ladder->m_top.y - me->GetAbsOrigin().y);
+	}
+
+	return 0.0f;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSBot::ComputeLadderAngles( float *yaw, float *pitch )
+{
+	if ( !yaw || !pitch )
+		return;
+
+	Vector myOrigin = GetCentroid( this );
+
+	// set yaw to aim at ladder
+	Vector to = m_pathLadder->GetPosAtHeight(myOrigin.z) - myOrigin;
+	float idealYaw = UTIL_VecToYaw( to );
+
+	Vector faceDir = (m_pathLadderFaceIn) ? -m_pathLadder->GetNormal() : m_pathLadder->GetNormal();
+	QAngle faceAngles;
+	VectorAngles( faceDir, faceAngles );
+
+	const float lookAlongLadderRange = 50.0f;
+	const float ladderPitchUpApproach = -30.0f;
+	const float ladderPitchUpTraverse = -60.0f;		// -80
+	const float ladderPitchDownApproach = 0.0f;
+	const float ladderPitchDownTraverse = 80.0f;
+
+	// adjust pitch to look up/down ladder as we ascend/descend
+	switch( m_pathLadderState )
+	{
+		case APPROACH_ASCENDING_LADDER:
+		{
+			Vector to = m_goalPosition - myOrigin;
+			*yaw = idealYaw;
+
+			if (to.IsLengthLessThan( lookAlongLadderRange ))
+				*pitch = ladderPitchUpApproach;
+			break;
+		}
+
+		case APPROACH_DESCENDING_LADDER:
+		{
+			Vector to = m_goalPosition - myOrigin;
+			*yaw = idealYaw;
+
+			if (to.IsLengthLessThan( lookAlongLadderRange ))
+				*pitch = ladderPitchDownApproach;
+			break;
+		}
+
+		case FACE_ASCENDING_LADDER:
+			if ( m_pathLadderDismountDir == LEFT )
+			{
+				*yaw = AngleNormalizePositive( idealYaw + 90.0f );
+			}
+			else if ( m_pathLadderDismountDir == RIGHT )
+			{
+				*yaw = AngleNormalizePositive( idealYaw - 90.0f );
+			}
+			else
+			{
+				*yaw = idealYaw;
+			}
+			*pitch = ladderPitchUpApproach;
+			break;
+
+		case FACE_DESCENDING_LADDER:
+			*yaw = idealYaw;
+			*pitch = ladderPitchDownApproach;
+			break;
+
+		case MOUNT_ASCENDING_LADDER:
+		case ASCEND_LADDER:
+			if ( m_pathLadderDismountDir == LEFT )
+			{
+				*yaw = AngleNormalizePositive( idealYaw + 90.0f );
+			}
+			else if ( m_pathLadderDismountDir == RIGHT )
+			{
+				*yaw = AngleNormalizePositive( idealYaw - 90.0f );
+			}
+			else
+			{
+				*yaw = faceAngles[ YAW ] + StayOnLadderLine( this, m_pathLadder );
+			}
+			*pitch = ( m_pathLadderState == ASCEND_LADDER ) ? ladderPitchUpTraverse : ladderPitchUpApproach;
+			break;
+
+		case MOUNT_DESCENDING_LADDER:
+		case DESCEND_LADDER:
+			*yaw = faceAngles[ YAW ] + StayOnLadderLine( this, m_pathLadder );
+			*pitch = ( m_pathLadderState == DESCEND_LADDER ) ? ladderPitchDownTraverse : ladderPitchDownApproach;
+			break;
+
+		case DISMOUNT_ASCENDING_LADDER:
+			if ( m_pathLadderDismountDir == LEFT )
+			{
+				*yaw = AngleNormalizePositive( faceAngles[ YAW ] + 90.0f );
+			}
+			else if ( m_pathLadderDismountDir == RIGHT )
+			{
+				*yaw = AngleNormalizePositive( faceAngles[ YAW ] - 90.0f );
+			}
+			else
+			{
+				*yaw = faceAngles[ YAW ];
+			}
+			break;
+
+		case DISMOUNT_DESCENDING_LADDER:
+			*yaw = faceAngles[ YAW ];
+			break;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move actual view angles towards desired ones.
+ * This is the only place v_angle is altered.
+ * @todo Make stiffness and turn rate constants timestep invariant.
+ */
+void CCSBot::UpdateLookAngles( void )
+{
+	VPROF_BUDGET( "CCSBot::UpdateLookAngles", VPROF_BUDGETGROUP_NPCS );
+
+	const float deltaT = g_BotUpkeepInterval;
+	float maxAccel;
+	float stiffness;
+	float damping;
+
+	// If mimicing the player, don't modify the view angles.
+	if ( bot_mimic.GetInt() )
+		return;
+
+	// springs are stiffer when attacking, so we can track and move between targets better
+	if (IsAttacking())
+	{
+		stiffness = 300.0f;
+		damping = 30.0f;			// 20
+		maxAccel = 3000.0f;	// 4000
+	}
+	else
+	{
+		stiffness = 200.0f;
+		damping = 25.0f;
+		maxAccel = 3000.0f;
+	}
+
+	// these may be overridden by ladder logic
+	float useYaw = m_lookYaw;
+	float usePitch = m_lookPitch;
+
+	//
+	// Ladders require precise movement, therefore we need to look at the 
+	// ladder as we approach and ascend/descend it.
+	// If we are on a ladder, we need to look up or down to traverse it - override pitch in this case.
+	//
+	// If we're trying to break something, though, we actually need to look at it before we can
+	// look at the ladder
+	//
+	if ( IsUsingLadder() && !(IsLookingAtSpot( PRIORITY_HIGH ) && m_lookAtSpotAttack) )
+	{
+		ComputeLadderAngles( &useYaw, &usePitch );
+	}
+
+	// get current view angles
+	QAngle viewAngles = EyeAngles();
+
+	//
+	// Yaw
+	//
+	float angleDiff = AngleNormalize( useYaw - viewAngles.y );
+
+	/*
+	 * m_forwardAngle is unreliable. Need to simulate mouse sliding & centering
+	if (!IsAttacking())
+	{
+		// do not allow rotation through our reverse facing angle - go the "long" way instead
+		float toCurrent = AngleNormalize( pev->v_angle.y - m_forwardAngle );
+		float toDesired = AngleNormalize( useYaw - m_forwardAngle );
+
+		// if angle differences are different signs, they cross the forward facing
+		if (toCurrent * toDesired < 0.0f)
+		{
+			// if the sum of the angles is greater than 180, turn the "long" way around
+			if (abs( toCurrent - toDesired ) >= 180.0f)
+			{
+				if (angleDiff > 0.0f)
+					angleDiff -= 360.0f;
+				else
+					angleDiff += 360.0f;
+			}
+		}
+	}
+	*/
+
+	// if almost at target angle, snap to it
+	const float onTargetTolerance = 1.0f;		// 3
+	if (angleDiff < onTargetTolerance && angleDiff > -onTargetTolerance)
+	{
+		m_lookYawVel = 0.0f;
+		viewAngles.y = useYaw;
+	}
+	else
+	{
+		// simple angular spring/damper
+		float accel = stiffness * angleDiff - damping * m_lookYawVel;
+
+		// limit rate
+		if (accel > maxAccel)
+			accel = maxAccel;
+		else if (accel < -maxAccel)
+			accel = -maxAccel;
+
+		m_lookYawVel += deltaT * accel;
+		viewAngles.y += deltaT * m_lookYawVel;
+
+		// keep track of how long our view remains steady
+		const float steadyYaw = 1000.0f;
+		if (fabs( accel ) > steadyYaw)
+		{
+			m_viewSteadyTimer.Start();
+		}
+	}
+
+	//
+	// Pitch
+	// Actually, this is negative pitch.
+	//
+	angleDiff = usePitch - viewAngles.x;
+
+	angleDiff = AngleNormalize( angleDiff );
+
+
+	if (false && angleDiff < onTargetTolerance && angleDiff > -onTargetTolerance)
+	{
+		m_lookPitchVel = 0.0f;
+		viewAngles.x = usePitch;
+	}
+	else
+	{
+		// simple angular spring/damper
+		// double the stiffness since pitch is only +/- 90 and yaw is +/- 180
+		float accel = 2.0f * stiffness * angleDiff - damping * m_lookPitchVel;
+
+		// limit rate
+		if (accel > maxAccel)
+			accel = maxAccel;
+		else if (accel < -maxAccel)
+			accel = -maxAccel;
+
+		m_lookPitchVel += deltaT * accel;
+		viewAngles.x += deltaT * m_lookPitchVel;
+
+		// keep track of how long our view remains steady
+		const float steadyPitch = 1000.0f;
+		if (fabs( accel ) > steadyPitch)
+		{
+			m_viewSteadyTimer.Start();
+		}
+	}
+
+	//PrintIfWatched( "yawVel = %g, pitchVel = %g\n", m_lookYawVel, m_lookPitchVel );
+
+	// limit range - avoid gimbal lock
+	if (viewAngles.x < -89.0f)
+		viewAngles.x = -89.0f;
+	else if (viewAngles.x > 89.0f)
+		viewAngles.x = 89.0f;
+
+	// update view angles
+	SnapEyeAngles( viewAngles );
+
+	// if our weapon is zooming, our view is not steady
+	if (IsWaitingForZoom())
+	{
+		m_viewSteadyTimer.Start();
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we can see the point
+ */
+bool CCSBot::IsVisible( const Vector &pos, bool testFOV, const CBaseEntity *ignore ) const
+{
+	VPROF_BUDGET( "CCSBot::IsVisible( pos )", VPROF_BUDGETGROUP_NPCS );
+
+	// we can't see anything if we're blind
+	if (IsBlind())
+		return false;
+
+	// is it in my general viewcone?
+	if (testFOV && !(const_cast<CCSBot *>(this)->FInViewCone( pos )))
+		return false;
+
+	// check line of sight against smoke
+	if (TheCSBots()->IsLineBlockedBySmoke( EyePositionConst(), pos ))
+		return false;
+
+	// check line of sight
+	// Must include CONTENTS_MONSTER to pick up all non-brush objects like barrels
+	trace_t result;
+	CTraceFilterNoNPCsOrPlayer traceFilter( ignore, COLLISION_GROUP_NONE );
+	UTIL_TraceLine( EyePositionConst(), pos, MASK_VISIBLE_AND_NPCS, &traceFilter, &result );
+	if (result.fraction != 1.0f)
+		return false;
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we can see any part of the player
+ * Check parts in order of importance. Return the first part seen in "visPart" if it is non-NULL.
+ */
+bool CCSBot::IsVisible( CCSPlayer *player, bool testFOV, unsigned char *visParts ) const
+{
+	VPROF_BUDGET( "CCSBot::IsVisible( player )", VPROF_BUDGETGROUP_NPCS );
+
+	// optimization - assume if center is not in FOV, nothing is
+	// we're using WorldSpaceCenter instead of GUT so we can skip GetPartPosition below - that's
+	// the most expensive part of this, and if we can skip it, so much the better.
+	if (testFOV && !(const_cast<CCSBot *>(this)->FInViewCone( player->WorldSpaceCenter() )))
+	{
+		return false;
+	}
+
+	unsigned char testVisParts = NONE;
+
+	// check gut
+	Vector partPos = GetPartPosition( player, GUT );
+
+	// finish gut check
+	if (IsVisible( partPos, testFOV ))
+	{
+		if (visParts == NULL)
+			return true;
+
+		testVisParts |= GUT;
+	}
+
+
+	// check top of head
+	partPos = GetPartPosition( player, HEAD );
+	if (IsVisible( partPos, testFOV ))
+	{
+		if (visParts == NULL)
+			return true;
+
+		testVisParts |= HEAD;
+	}
+
+	// check feet
+	partPos = GetPartPosition( player, FEET );
+	if (IsVisible( partPos, testFOV ))
+	{
+		if (visParts == NULL)
+			return true;
+
+		testVisParts |= FEET;
+	}
+
+	// check "edges"
+	partPos = GetPartPosition( player, LEFT_SIDE );
+	if (IsVisible( partPos, testFOV ))
+	{
+		if (visParts == NULL)
+			return true;
+
+		testVisParts |= LEFT_SIDE;
+	}
+
+	partPos = GetPartPosition( player, RIGHT_SIDE );
+	if (IsVisible( partPos, testFOV ))
+	{
+		if (visParts == NULL)
+			return true;
+
+		testVisParts |= RIGHT_SIDE;
+	}
+
+	if (visParts)
+		*visParts = testVisParts;
+
+	if (testVisParts)
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Interesting part positions
+ */
+CCSBot::PartInfo CCSBot::m_partInfo[ MAX_PLAYERS ];
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute part positions from bone location.
+ */
+void CCSBot::ComputePartPositions( CCSPlayer *player )
+{
+	const int headBox = 12;
+	const int gutBox = 9;
+	const int leftElbowBox = 14;
+	const int rightElbowBox = 17;
+	//const int hipBox = 0;
+	//const int leftFootBox = 4;
+	//const int rightFootBox = 8;
+	const int maxBoxIndex = rightElbowBox;
+
+	VPROF_BUDGET( "CCSBot::ComputePartPositions", VPROF_BUDGETGROUP_NPCS );
+
+	// which PartInfo corresponds to the given player
+	PartInfo *info = &m_partInfo[ player->entindex() % MAX_PLAYERS ];
+
+	// always compute feet, since it doesn't rely on bones
+	info->m_feetPos = player->GetAbsOrigin();
+	info->m_feetPos.z += 5.0f;
+
+	// get bone positions for interesting points on the player
+	MDLCACHE_CRITICAL_SECTION();
+	CStudioHdr *studioHdr = player->GetModelPtr();
+	if (studioHdr)
+	{
+		mstudiohitboxset_t *set = studioHdr->pHitboxSet( player->GetHitboxSet() );
+		if (set && maxBoxIndex < set->numhitboxes)
+		{
+			QAngle angles;
+			mstudiobbox_t *box;
+
+			// gut
+			box = set->pHitbox( gutBox );
+			player->GetBonePosition( box->bone, info->m_gutPos, angles );	
+
+			// head
+			box = set->pHitbox( headBox );
+			player->GetBonePosition( box->bone, info->m_headPos, angles );
+
+			Vector forward, right;
+			AngleVectors( angles, &forward, &right, NULL );
+
+			// in local bone space
+			const float headForwardOffset = 4.0f;
+			const float headRightOffset = 2.0f;
+			info->m_headPos += headForwardOffset * forward + headRightOffset * right;
+
+			/// @todo Fix this hack - lower the head target because it's a bit too high for the current T model
+			info->m_headPos.z -= 2.0f;
+
+
+			// left side
+			box = set->pHitbox( leftElbowBox );
+			player->GetBonePosition( box->bone, info->m_leftSidePos, angles );	
+
+			// right side
+			box = set->pHitbox( rightElbowBox );
+			player->GetBonePosition( box->bone, info->m_rightSidePos, angles );	
+
+			return;
+		}
+	}
+
+
+	// default values if bones are not available
+	info->m_headPos = GetCentroid( player );
+	info->m_gutPos = info->m_headPos;
+	info->m_leftSidePos = info->m_headPos;
+	info->m_rightSidePos = info->m_headPos;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return world space position of given part on player.
+ * Uses hitboxes to get accurate positions.
+ * @todo Optimize by computing once for each player and storing.
+ */
+const Vector &CCSBot::GetPartPosition( CCSPlayer *player, VisiblePartType part ) const
+{
+	VPROF_BUDGET( "CCSBot::GetPartPosition", VPROF_BUDGETGROUP_NPCS );
+
+	// which PartInfo corresponds to the given player
+	PartInfo *info = &m_partInfo[ player->entindex() % MAX_PLAYERS ];
+
+	if (gpGlobals->framecount > info->m_validFrame)
+	{
+		// update part positions
+		const_cast< CCSBot * >( this )->ComputePartPositions( player );
+		info->m_validFrame = gpGlobals->framecount;
+	}
+
+	// return requested part position
+	switch( part )
+	{
+		default:
+		{
+			AssertMsg( false, "GetPartPosition: Invalid part" );
+			// fall thru to GUT
+		}
+
+		case GUT:
+			return info->m_gutPos;
+
+		case HEAD:
+			return info->m_headPos;
+			
+		case FEET:
+			return info->m_feetPos;
+
+		case LEFT_SIDE:
+			return info->m_leftSidePos;
+			
+		case RIGHT_SIDE:
+			return info->m_rightSidePos;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update desired view angles to point towards m_lookAtSpot
+ */
+void CCSBot::UpdateLookAt( void )
+{
+	Vector to = m_lookAtSpot - EyePositionConst();
+
+	QAngle idealAngle;
+	VectorAngles( to, idealAngle );
+
+	//Vector idealAngle = UTIL_VecToAngles( to );
+	//idealAngle.x = 360.0f - idealAngle.x;
+
+	SetLookAngles( idealAngle.y, idealAngle.x );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Look at the given point in space for the given duration (-1 means forever)
+ */
+void CCSBot::SetLookAt( const char *desc, const Vector &pos, PriorityType pri, float duration, bool clearIfClose, float angleTolerance, bool attack )
+{
+	if (IsBlind())
+		return;
+
+	// if currently looking at a point in space with higher priority, ignore this request
+	if (m_lookAtSpotState != NOT_LOOKING_AT_SPOT && m_lookAtSpotPriority > pri)
+		return;
+
+	// if already looking at this spot, just extend the time
+	const float tolerance = 10.0f;
+	if (m_lookAtSpotState != NOT_LOOKING_AT_SPOT && VectorsAreEqual( pos, m_lookAtSpot, tolerance ))
+	{
+		m_lookAtSpotDuration = duration;
+
+		if (m_lookAtSpotPriority < pri)
+			m_lookAtSpotPriority = pri;
+	}
+	else
+	{
+		// look at new spot
+		m_lookAtSpot = pos; 
+		m_lookAtSpotState = LOOK_TOWARDS_SPOT;
+		m_lookAtSpotDuration = duration;
+		m_lookAtSpotPriority = pri;
+	}
+
+	m_lookAtSpotAngleTolerance = angleTolerance;
+	m_lookAtSpotClearIfClose = clearIfClose;
+	m_lookAtDesc = desc;
+	m_lookAtSpotAttack = attack;
+
+	PrintIfWatched( "%3.1f SetLookAt( %s ), duration = %f\n", gpGlobals->curtime, desc, duration );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Block all "look at" and "look around" behavior for given duration - just look ahead
+ */
+void CCSBot::InhibitLookAround( float duration )
+{
+	m_inhibitLookAroundTimestamp = gpGlobals->curtime + duration;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update enounter spot timestamps, etc
+ */
+void CCSBot::UpdatePeripheralVision()
+{
+	VPROF_BUDGET( "CCSBot::UpdatePeripheralVision", VPROF_BUDGETGROUP_NPCS );
+
+	const float peripheralUpdateInterval = 0.29f;		// if we update at 10Hz, this ensures we test once every three
+	if (gpGlobals->curtime - m_peripheralTimestamp < peripheralUpdateInterval)
+		return;
+
+	m_peripheralTimestamp = gpGlobals->curtime;
+
+	if (m_spotEncounter)
+	{
+		// check LOS to all spots in case we see them with our "peripheral vision"
+		const SpotOrder *spotOrder;
+		Vector pos;
+
+		FOR_EACH_VEC( m_spotEncounter->spots, it )
+		{
+			spotOrder = &m_spotEncounter->spots[ it ];
+
+			const Vector &spotPos = spotOrder->spot->GetPosition();
+
+			pos.x = spotPos.x;
+			pos.y = spotPos.y;
+			pos.z = spotPos.z + HalfHumanHeight;
+
+			if (!IsVisible( pos, CHECK_FOV ))
+				continue;
+
+			// can see hiding spot, remember when we saw it last
+			SetHidingSpotCheckTimestamp( spotOrder->spot );
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update the "looking around" behavior.
+ */
+void CCSBot::UpdateLookAround( bool updateNow )
+{
+	VPROF_BUDGET( "CCSBot::UpdateLookAround", VPROF_BUDGETGROUP_NPCS );
+
+	//
+	// If we recently saw an enemy, look towards where we last saw them
+	// Unless we can hear them moving, in which case look towards the noise
+	//
+	const float closeRange = 500.0f;
+	if (!IsNoiseHeard() || GetNoiseRange() > closeRange)
+	{
+		const float recentThreatTime = 1.0f; // 0.25f;
+		if (!IsLookingAtSpot( PRIORITY_MEDIUM ) && gpGlobals->curtime - m_lastSawEnemyTimestamp < recentThreatTime)
+		{
+			ClearLookAt();
+
+			Vector spot = m_lastEnemyPosition;
+
+			// find enemy position on the ground
+			if (TheNavMesh->GetSimpleGroundHeight( m_lastEnemyPosition, &spot.z ))
+			{
+				spot.z += HalfHumanHeight;
+				SetLookAt( "Last Enemy Position", spot, PRIORITY_MEDIUM, RandomFloat( 2.0f, 3.0f ), true );
+				return;
+			}
+		}
+	}
+
+	//
+	// Look at nearby enemy noises
+	//
+	if (UpdateLookAtNoise())
+		return;
+
+
+	// check if looking around has been inhibited
+	// Moved inhibit to allow high priority enemy lookats to still occur
+	if (gpGlobals->curtime < m_inhibitLookAroundTimestamp)
+		return;
+
+	//
+	// If we are hiding (or otherwise standing still), watch all approach points leading into this region
+	//
+	const float minStillTime = 2.0f;
+	if (IsAtHidingSpot() || IsNotMoving( minStillTime ))
+	{
+		// update approach points
+		const float recomputeApproachPointTolerance = 50.0f;
+		if ((m_approachPointViewPosition - GetAbsOrigin()).IsLengthGreaterThan( recomputeApproachPointTolerance ))
+		{
+			ComputeApproachPoints();
+			m_approachPointViewPosition = GetAbsOrigin();
+		}
+
+		// if we're sniping, zoom in to watch our approach points
+		if (IsUsingSniperRifle())
+		{
+			// low skill bots don't pre-zoom
+			if (GetProfile()->GetSkill() > 0.4f)
+			{
+				if (!IsViewMoving())
+				{
+					float range = ComputeWeaponSightRange();
+					AdjustZoom( range );
+				}
+				else
+				{
+					// zoom out
+					if (GetZoomLevel() != NO_ZOOM)
+						SecondaryAttack();
+				}
+			}
+		}
+
+		if (m_lastKnownArea == NULL)
+			return;
+
+		if (gpGlobals->curtime < m_lookAroundStateTimestamp)
+			return;
+
+		// if we're sniping, switch look-at spots less often
+		if (IsUsingSniperRifle())
+			m_lookAroundStateTimestamp = gpGlobals->curtime + RandomFloat( 5.0f, 10.0f );
+		else
+			m_lookAroundStateTimestamp = gpGlobals->curtime + RandomFloat( 1.0f, 2.0f );	// 0.5, 1.0
+
+
+		#define MAX_APPROACHES 16
+		Vector validSpot[ MAX_APPROACHES ];
+		int validSpotCount = 0;
+
+		Vector *earlySpot = NULL;
+		float earliest = 999999.9f;
+
+		for( int i=0; i<m_approachPointCount; ++i )
+		{
+			float spotTime = m_approachPoint[i].m_area->GetEarliestOccupyTime( OtherTeam( GetTeamNumber() ) );
+
+			// ignore approach areas the enemy could not have possibly reached yet
+			if (TheCSBots()->GetElapsedRoundTime() >= spotTime)
+			{
+				validSpot[ validSpotCount++ ] = m_approachPoint[i].m_pos;
+			}
+			else
+			{
+				// keep track of earliest spot we can see in case we get there very early
+				if (spotTime < earliest)
+				{
+					earlySpot = &m_approachPoint[i].m_pos;
+					earliest = spotTime;
+				}
+			}
+		}
+
+		Vector spot;
+
+		if (validSpotCount)
+		{
+			int which = RandomInt( 0, validSpotCount-1 );
+			spot = validSpot[ which ];
+		}
+		else if (earlySpot)
+		{
+			// all of the spots we can see can't be reached yet by the enemy - look at the earliest spot
+			spot = *earlySpot;
+		}
+		else
+		{
+			return;
+		}
+
+		// don't look at the floor, look roughly at chest level
+		/// @todo If this approach point is very near, this will cause us to aim up in the air if were crouching
+		spot.z += HalfHumanHeight;
+
+		SetLookAt( "Approach Point (Hiding)", spot, PRIORITY_LOW );
+
+		return;
+	}
+
+	//
+	// Glance at "encouter spots" as we move past them
+	//
+	if (m_spotEncounter)
+	{
+		//
+		// Check encounter spots
+		//
+		if (!IsSafe() && !IsLookingAtSpot( PRIORITY_LOW ))
+		{
+			// allow a short time to look where we're going
+			if (gpGlobals->curtime < m_spotCheckTimestamp)
+				return;
+
+			/// @todo Use skill parameter instead of accuracy
+
+			// lower skills have exponentially longer delays
+			float asleep = (1.0f - GetProfile()->GetSkill());
+			asleep *= asleep;
+			asleep *= asleep;
+
+			m_spotCheckTimestamp = gpGlobals->curtime + asleep * RandomFloat( 10.0f, 30.0f );
+
+
+			// figure out how far along the path segment we are
+			Vector delta = m_spotEncounter->path.to - m_spotEncounter->path.from;
+			float length = delta.Length();
+			float adx = (float)fabs(delta.x);
+			float ady = (float)fabs(delta.y);
+			float t;
+			Vector myOrigin = GetCentroid( this );
+
+			if (adx > ady)
+				t = (myOrigin.x - m_spotEncounter->path.from.x) / delta.x;
+			else
+				t = (myOrigin.y - m_spotEncounter->path.from.y) / delta.y;
+
+			// advance parameter a bit so we "lead" our checks
+			const float leadCheckRange = 50.0f;
+			t += leadCheckRange / length;
+
+			if (t < 0.0f)
+				t = 0.0f;
+			else if (t > 1.0f)
+				t = 1.0f;
+
+			// collect the unchecked spots so far
+			#define MAX_DANGER_SPOTS 16
+			HidingSpot *dangerSpot[MAX_DANGER_SPOTS];
+			int dangerSpotCount = 0;
+			int dangerIndex = 0;
+
+			const float checkTime = 10.0f;
+			const SpotOrder *spotOrder;
+			FOR_EACH_VEC( m_spotEncounter->spots, it )
+			{
+				spotOrder = &(m_spotEncounter->spots[ it ]);
+
+				// if we have seen this spot recently, we don't need to look at it
+				if (gpGlobals->curtime - GetHidingSpotCheckTimestamp( spotOrder->spot ) <= checkTime)
+					continue;
+
+				if (spotOrder->t > t)
+					break;
+
+				// ignore spots the enemy could not have possibly reached yet
+				if (spotOrder->spot->GetArea())
+				{
+					if (TheCSBots()->GetElapsedRoundTime() < spotOrder->spot->GetArea()->GetEarliestOccupyTime( OtherTeam( GetTeamNumber() ) ))
+					{
+						continue;
+					}
+				}
+
+				dangerSpot[ dangerIndex++ ] = spotOrder->spot;
+				if (dangerIndex >= MAX_DANGER_SPOTS)
+					dangerIndex = 0;
+				if (dangerSpotCount < MAX_DANGER_SPOTS)
+					++dangerSpotCount;
+			}
+
+			if (dangerSpotCount)
+			{
+				// pick one of the spots at random
+				int which = RandomInt( 0, dangerSpotCount-1 );
+
+				// glance at the spot for minimum time 
+				SetLookAt( "Encounter Spot", dangerSpot[which]->GetPosition() + Vector( 0, 0, HalfHumanHeight ), PRIORITY_LOW, 0.2f, true, 10.0f );
+
+				// immediately mark it as "checked", so we don't check it again
+				// if we get distracted before we check it - that's the way it goes
+				SetHidingSpotCheckTimestamp( dangerSpot[which] );
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * "Bend" our line of sight around corners until we can "see" the point. 
+ */
+bool CCSBot::BendLineOfSight( const Vector &eye, const Vector &target, Vector *bend, float angleLimit ) const
+{
+	VPROF_BUDGET( "CCSBot::BendLineOfSight", VPROF_BUDGETGROUP_NPCS );
+
+	bool doDebug = false;
+	const float debugDuration = 0.04f;
+	if (doDebug && cv_bot_debug.GetBool() && IsLocalPlayerWatchingMe())
+		NDebugOverlay::Line( eye, target, 255, 255, 255, true, debugDuration );
+
+	// if we can directly see the point, use it
+	trace_t result;
+	CTraceFilterNoNPCsOrPlayer traceFilter( this, COLLISION_GROUP_NONE );
+	UTIL_TraceLine( eye, target, MASK_VISIBLE_AND_NPCS, &traceFilter, &result );
+	if (result.fraction == 1.0f && !result.startsolid)
+	{
+		// can directly see point, no bending needed
+		*bend = target;
+		return true;
+	}
+
+	// "bend" our line of sight until we can see the approach point
+	Vector to = target - eye;
+	float startAngle = UTIL_VecToYaw( to );
+	float length = to.Length2D();
+	to.NormalizeInPlace();
+
+	struct Color3
+	{
+		int r, g, b;
+	};
+	const int colorCount = 6;
+	Color3 colorSet[ colorCount ] =
+	{
+		{ 255,   0,   0 },
+		{   0, 255,   0 },
+		{   0,   0, 255 },
+		{ 255, 255,   0 },
+		{   0, 255, 255 },
+		{ 255,   0, 255 },
+	};
+
+	int color = 0;
+
+	// optiming assumption - previous rays cast "shadow" on subsequent rays since they already
+	// enumerated visible space along their length.
+	// We should do a dot product and compute the exact length, but since the angular changes
+	// are incremental, using the direct length should be close enough.
+	float priorVisibleLength[2] = { 0.0f, 0.0f };
+
+	float angleInc = 5.0f; 
+	for( float angle = angleInc; angle <= angleLimit; angle += angleInc )
+	{
+		// check both sides at this angle offset
+		for( int side=0; side<2; ++side )
+		{
+			float actualAngle = (side) ? (startAngle + angle) : (startAngle - angle);
+
+			float dx = cos( 3.141592f * actualAngle / 180.0f );
+			float dy = sin( 3.141592f * actualAngle / 180.0f );
+
+			// compute rotated point ray endpoint
+			Vector rotPoint( eye.x + length * dx, eye.y + length * dy, target.z );
+
+			// check LOS to find length to test along ray
+			UTIL_TraceLine( eye, rotPoint, MASK_VISIBLE_AND_NPCS, &traceFilter, &result );
+
+			// if this ray started in an obstacle, skip it
+			if (result.startsolid)
+			{
+				continue;
+			}
+
+			Vector ray = rotPoint - eye;
+			float rayLength = ray.NormalizeInPlace();
+			float visibleLength = rayLength * result.fraction;
+
+			if (doDebug && cv_bot_debug.GetBool() && IsLocalPlayerWatchingMe())
+			{
+				NDebugOverlay::Line( eye, eye + visibleLength * ray, colorSet[color].r, colorSet[color].g, colorSet[color].b, true, debugDuration );
+			}
+
+			// step along ray, checking if point is visible from ray point
+			const float bendStepSize = 50.0f; 
+
+			// start from point that prior rays couldn't see
+			float startLength = priorVisibleLength[ side ];
+
+			for( float bendLength=startLength; bendLength <= visibleLength; bendLength += bendStepSize )
+			{
+				// compute point along ray
+				Vector bendPoint = eye + bendLength * ray;
+
+				// check if we can see approach point from this bend point
+				UTIL_TraceLine( bendPoint, target, MASK_VISIBLE_AND_NPCS, &traceFilter, &result );
+
+				if (doDebug && cv_bot_debug.GetBool() && IsLocalPlayerWatchingMe())
+				{
+					NDebugOverlay::Line( bendPoint, result.endpos, colorSet[color].r/2, colorSet[color].g/2, colorSet[color].b/2, true, debugDuration );
+				}
+
+				if (result.fraction == 1.0f && !result.startsolid)
+				{
+					// target is visible from this bend point on the ray - use this point on the ray as our point
+
+					// keep "bent" point at correct height along line of sight
+					bendPoint.z = eye.z + bendLength * to.z;
+
+					*bend = bendPoint;
+
+					return true;
+				}	
+			}
+
+			priorVisibleLength[ side ] = visibleLength;
+
+			++color;
+			if (color >= colorCount)
+			{
+				color = 0;
+			}
+		} // side
+	}
+
+	// bending rays didn't help - still can't see the point
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we "notice" given player
+ * @todo Increase chance if player is rotating
+ * @todo Decrease chance as nears edge of FOV
+ */
+bool CCSBot::IsNoticable( const CCSPlayer *player, unsigned char visParts ) const
+{
+	// if this player has just fired his weapon, we notice him
+	if (DidPlayerJustFireWeapon( player ))
+	{
+		return true;
+	}
+
+	float deltaT = m_attentionInterval.GetElapsedTime();
+
+	// all chances are specified in terms of a standard "quantum" of time
+	// in which a normal person would notice something
+	const float noticeQuantum = 0.25f;
+
+	// determine percentage of player that is visible
+	float coverRatio = 0.0f;
+
+	if (visParts & GUT)
+	{
+		const float chance = 40.0f;
+		coverRatio += chance;
+	}
+
+	if (visParts & HEAD)
+	{
+		const float chance = 10.0f;
+		coverRatio += chance;
+	}
+
+	if (visParts & LEFT_SIDE)
+	{
+		const float chance = 20.0f;
+		coverRatio += chance;
+	}
+
+	if (visParts & RIGHT_SIDE)
+	{
+		const float chance = 20.0f;
+		coverRatio += chance;
+	}
+
+	if (visParts & FEET)
+	{
+		const float chance = 10.0f;
+		coverRatio += chance;
+	}
+
+
+	// compute range modifier - farther away players are harder to notice, depeding on what they are doing
+	float range = (player->GetAbsOrigin() - GetAbsOrigin()).Length();
+	const float closeRange = 300.0f;
+	const float farRange = 1000.0f;
+
+	float rangeModifier;
+	if (range < closeRange)
+	{
+		rangeModifier = 0.0f;
+	}
+	else if (range > farRange)
+	{
+		rangeModifier = 1.0f;
+	}
+	else
+	{
+		rangeModifier = (range - closeRange)/(farRange - closeRange);
+	}
+
+
+	// harder to notice when crouched
+	bool isCrouching = (player->GetFlags() & FL_DUCKING);
+
+
+	// moving players are easier to spot
+	float playerSpeedSq = player->GetAbsVelocity().LengthSqr();
+	const float runSpeed = 200.0f;
+	const float walkSpeed = 30.0f;
+	float farChance, closeChance;
+	if (playerSpeedSq > runSpeed * runSpeed)
+	{
+		// running players are always easy to spot (must be standing to run)
+		return true;
+	}
+	else if (playerSpeedSq > walkSpeed * walkSpeed)
+	{
+		// walking players are less noticable far away
+		if (isCrouching)
+		{
+			closeChance = 90.0f;
+			farChance = 60.0f;
+		}
+		else // standing
+		{
+			closeChance = 100.0f;
+			farChance = 75.0f;
+		}
+	}
+	else
+	{
+		// motionless players are hard to notice
+		if (isCrouching)
+		{
+			// crouching and motionless - very tough to notice
+			closeChance = 80.0f;
+			farChance = 5.0f;		// takes about three seconds to notice (50% chance)
+		}
+		else // standing
+		{
+			closeChance = 100.0f;
+			farChance = 10.0f;
+		}
+	}
+
+	// combine posture, speed, and range chances
+	float dispositionChance = closeChance + (farChance - closeChance) * rangeModifier;
+
+	// determine actual chance of noticing player
+	float noticeChance = dispositionChance * coverRatio/100.0f;
+
+	// scale by skill level
+	noticeChance *= (0.5f + 0.5f * GetProfile()->GetSkill());
+
+	// if we are alert, our chance of noticing is much higher
+	if (IsAlert())
+	{
+		const float alertBonus = 50.0f;
+		noticeChance += alertBonus;
+	}
+
+	// scale by time quantum
+	noticeChance *= deltaT / noticeQuantum;
+
+	// there must always be a chance of detecting the enemy
+	const float minChance = 0.1f;
+	if (noticeChance < minChance)
+	{
+		noticeChance = minChance;
+	}
+
+	//PrintIfWatched( "Notice chance = %3.2f\n", noticeChance );
+
+	return (RandomFloat( 0.0f, 100.0f ) < noticeChance);
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return most dangerous threat in my field of view (feeds into reaction time queue).
+ * @todo Account for lighting levels, cover, and distance to see if we notice enemy
+ */
+CCSPlayer *CCSBot::FindMostDangerousThreat( void )
+{
+	VPROF_BUDGET( "CCSBot::FindMostDangerousThreat", VPROF_BUDGETGROUP_NPCS );
+
+	if (IsBlind())
+	{
+		return NULL;
+	}
+
+	enum { MAX_THREATS = 16 };		// maximum number of simulataneously attendable threats	
+	struct CloseInfo
+	{
+		CCSPlayer *enemy;
+		float range;
+	}
+	threat[ MAX_THREATS ];
+	int threatCount = 0;
+
+	int prevIndex = m_enemyQueueIndex - 1;
+	if ( prevIndex < 0 )
+		prevIndex = MAX_ENEMY_QUEUE - 1;
+	CCSPlayer *currentThreat = m_enemyQueue[ prevIndex ].player;
+
+	m_bomber = NULL;
+	m_isEnemySniperVisible = false;
+
+	m_closestVisibleFriend = NULL;
+	float closeFriendRange = 99999999999.9f;
+
+	m_closestVisibleHumanFriend = NULL;
+	float closeHumanFriendRange = 99999999999.9f;
+
+	CCSPlayer *sniperThreat = NULL;
+	float sniperThreatRange = 99999999999.9f;
+	bool sniperThreatIsFacingMe = false;
+
+	const float lookingAtMeTolerance = 0.7071f;
+
+	int i;
+
+	{
+		VPROF_BUDGET( "CCSBot::Collect Threats", VPROF_BUDGETGROUP_NPCS );
+
+		for( i = 1; i <= gpGlobals->maxClients; ++i )
+		{
+			CBaseEntity *entity = UTIL_PlayerByIndex( i );
+
+			if (entity == NULL)
+				continue;
+
+			// is it a player?
+			if (!entity->IsPlayer())
+				continue;
+
+			CCSPlayer *player = static_cast<CCSPlayer *>( entity );
+
+			// ignore self
+			if (player->entindex() == entindex())
+				continue;
+
+			// is it alive?
+			if (!player->IsAlive())
+				continue;
+
+			// is it an enemy?
+			if (player->InSameTeam( this ))
+			{
+				// keep track of nearby friends - use less exact visibility check
+				if (IsVisible( entity->WorldSpaceCenter(), false, this ))
+				{
+					// update watch timestamp
+					int idx = player->entindex();
+					m_watchInfo[idx].timestamp = gpGlobals->curtime;
+					m_watchInfo[idx].isEnemy = false;
+
+					// keep track of our closest friend 
+					Vector to = GetAbsOrigin() - player->GetAbsOrigin();
+					float rangeSq = to.LengthSqr();
+					if (rangeSq < closeFriendRange)
+					{
+						m_closestVisibleFriend = player;
+						closeFriendRange = rangeSq;
+					}
+
+					// keep track of our closest human friend 
+					if (!player->IsBot() && rangeSq < closeHumanFriendRange)
+					{
+						m_closestVisibleHumanFriend = player;
+						closeHumanFriendRange = rangeSq;
+					}
+				}
+
+				continue;
+			}
+
+			// check if this enemy is fully or partially visible
+			unsigned char visParts;
+			if (!IsVisible( player, CHECK_FOV, &visParts ))
+				continue;
+
+			// do we notice this enemy? (always notice current enemy)
+			if (player != currentThreat)
+			{
+				if (!IsNoticable( player, visParts ))
+				{
+					continue;
+				}
+			}
+
+			// update watch timestamp
+			int idx = player->entindex();
+			m_watchInfo[idx].timestamp = gpGlobals->curtime;
+			m_watchInfo[idx].isEnemy = true;
+
+			// note if we see the bomber
+			if (player->HasC4())
+			{
+				m_bomber = player;
+			}
+
+			// keep track of all visible threats
+			Vector d = GetAbsOrigin() - player->GetAbsOrigin();
+			float distSq = d.LengthSqr();
+
+			// track enemy sniper threats
+			if (IsSniperRifle( player->GetActiveCSWeapon() ))
+			{
+				m_isEnemySniperVisible = true;
+
+				// keep track of the most dangerous sniper we see
+				if (sniperThreat)
+				{
+					if (IsPlayerLookingAtMe( player, lookingAtMeTolerance ))
+					{
+						if (sniperThreatIsFacingMe)
+						{
+							// several snipers are facing us - keep closest
+							if (distSq < sniperThreatRange)
+							{
+								sniperThreat = player;
+								sniperThreatRange = distSq;
+								sniperThreatIsFacingMe = true;
+							}
+						}
+						else
+						{
+							// even if this sniper is farther away, keep it because he's aiming at us
+							sniperThreat = player;
+							sniperThreatRange = distSq;
+							sniperThreatIsFacingMe = true;
+						}
+					}
+					else
+					{
+						// this sniper is not looking at us, only consider it if we dont have a sniper facing us
+						if (!sniperThreatIsFacingMe && distSq < sniperThreatRange)
+						{
+							sniperThreat = player;
+							sniperThreatRange = distSq;
+						}
+					}
+				}
+				else
+				{
+					// first sniper we see
+					sniperThreat = player;
+					sniperThreatRange = distSq;
+					sniperThreatIsFacingMe = IsPlayerLookingAtMe( player, lookingAtMeTolerance );
+				}
+			}
+
+
+			{
+				VPROF_BUDGET( "CCSBot::Sort Threats", VPROF_BUDGETGROUP_NPCS );
+
+				// maintain set of visible threats, sorted by increasing distance
+				if (threatCount == 0)
+				{
+					threat[0].enemy = player;
+					threat[0].range = distSq;
+					threatCount = 1;
+				}
+				else
+				{
+					// find insertion point
+					int j;
+					for( j=0; j<threatCount; ++j )
+					{
+						if (distSq < threat[j].range)
+							break;
+					}
+
+					// shift lower half down a notch
+					for( int k=threatCount-1; k>=j; --k )
+						threat[k+1] = threat[k];
+
+					// insert threat into sorted list
+					threat[j].enemy = player;
+					threat[j].range = distSq;
+
+					if (threatCount < MAX_THREATS)
+						++threatCount;
+				}
+			}
+		}
+	}
+
+
+	{
+		VPROF_BUDGET( "CCSBot::Count nearby Friends & Enemies", VPROF_BUDGETGROUP_NPCS );
+
+		// track the maximum enemy and friend counts we've seen recently
+		int prevEnemies = m_nearbyEnemyCount;
+		m_nearbyEnemyCount = 0;
+		m_nearbyFriendCount = 0;
+		for( i=0; i<MAX_PLAYERS; ++i )
+		{
+			if (m_watchInfo[i].timestamp <= 0.0f)
+				continue;
+
+			const float recentTime = 3.0f;
+			if (gpGlobals->curtime - m_watchInfo[i].timestamp < recentTime)
+			{
+				if (m_watchInfo[i].isEnemy)
+					++m_nearbyEnemyCount;
+				else
+					++m_nearbyFriendCount;
+			}
+		}
+
+		// note when we saw this batch of enemies
+		if (prevEnemies == 0 && m_nearbyEnemyCount > 0)
+		{
+			m_firstSawEnemyTimestamp = gpGlobals->curtime;
+		}
+	}
+
+
+	{
+		VPROF_BUDGET( "CCSBot::Track enemy Place", VPROF_BUDGETGROUP_NPCS );
+
+		//
+		// Track the place where we saw most of our enemies
+		//
+		struct PlaceRank
+		{
+			unsigned int place;
+			int count;
+		};
+		static PlaceRank placeRank[ MAX_PLACES_PER_MAP ];
+		int locCount = 0;
+
+		PlaceRank common;
+		common.place = 0;
+		common.count = 0;
+
+		for( i=0; i<threatCount; ++i )
+		{
+			// find the area the player/bot is standing on
+			CNavArea *area;
+			CCSBot *bot = dynamic_cast<CCSBot *>(threat[i].enemy);
+			if (bot && bot->IsBot())
+			{
+				area = bot->GetLastKnownArea();
+			}
+			else
+			{
+				Vector enemyOrigin = GetCentroid( threat[i].enemy );
+				area = TheNavMesh->GetNearestNavArea( enemyOrigin );
+			}
+
+			if (area == NULL)
+				continue;
+
+			unsigned int threatLoc = area->GetPlace();
+			if (!threatLoc)
+				continue;
+
+			// if place is already in set, increment count
+			int j;
+			for( j=0; j<locCount; ++j )
+				if (placeRank[j].place == threatLoc)
+					break;
+
+			if (j == locCount)
+			{
+				// new place
+				if (locCount < MAX_PLACES_PER_MAP)
+				{
+					placeRank[ locCount ].place = threatLoc;
+					placeRank[ locCount ].count = 1;
+
+					if (common.count == 0)
+						common = placeRank[locCount];
+
+					++locCount;
+				}
+			}
+			else
+			{
+				// others are in that place, increment
+				++placeRank[j].count;
+
+				// keep track of the most common place
+				if (placeRank[j].count > common.count)
+					common = placeRank[j];
+			}
+		}
+
+		// remember most common place
+		m_enemyPlace = common.place;
+	}
+
+
+	{
+		VPROF_BUDGET( "CCSBot::Select Threat", VPROF_BUDGETGROUP_NPCS );
+
+		if (threatCount == 0)
+			return NULL;
+
+		// if we can still see our current threat, keep it
+		// unless a new one is much closer
+		bool sawCloserThreat = false;
+		bool sawCurrentThreat = false;
+		int t;
+		for( t=0; t<threatCount; ++t )
+		{
+			if ( threat[t].enemy == currentThreat )
+			{
+				sawCurrentThreat = true;
+			}
+			else if ( threat[t].enemy != currentThreat &&
+				IsSignificantlyCloser( threat[t].enemy, currentThreat ) )
+			{
+				sawCloserThreat = true;
+			}
+		}
+
+		if ( sawCurrentThreat && !sawCloserThreat )
+		{
+			return currentThreat;
+		}
+
+		// if we are a sniper and we see a sniper threat, attack it unless 
+		// there are other close enemies facing me
+		if (IsSniper() && sniperThreat)
+		{
+			const float closeCombatRange = 500.0f;
+
+			for( t=0; t<threatCount; ++t )
+			{
+				if (threat[t].range < closeCombatRange && IsPlayerLookingAtMe( threat[t].enemy, lookingAtMeTolerance ))
+				{
+					return threat[t].enemy;
+				}
+			}
+
+			return sniperThreat;
+		}
+		
+		// otherwise, find the closest threat that is looking at me
+		for( t=0; t<threatCount; ++t )
+		{
+			if (IsPlayerLookingAtMe( threat[t].enemy, lookingAtMeTolerance ))
+			{
+				return threat[t].enemy;
+			}
+		}
+	}
+
+
+	// return closest threat
+	return threat[0].enemy;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update our reaction time queue
+ */
+void CCSBot::UpdateReactionQueue( void )
+{
+	VPROF_BUDGET( "CCSBot::UpdateReactionQueue", VPROF_BUDGETGROUP_NPCS );
+
+	// zombies dont see any threats
+	if (cv_bot_zombie.GetBool())
+		return;
+
+	// find biggest threat at this instant
+	CCSPlayer *threat = FindMostDangerousThreat();
+
+	// reset timer
+	m_attentionInterval.Start();
+
+
+	int now = m_enemyQueueIndex;
+
+	// store a snapshot of its state at the end of the reaction time queue
+	if (threat)
+	{
+		m_enemyQueue[ now ].player = threat;
+		m_enemyQueue[ now ].isReloading = threat->IsReloading();
+		m_enemyQueue[ now ].isProtectedByShield = threat->IsProtectedByShield();
+	}
+	else
+	{
+		m_enemyQueue[ now ].player = NULL;
+		m_enemyQueue[ now ].isReloading = false;
+		m_enemyQueue[ now ].isProtectedByShield = false;
+	}
+
+	// queue is round-robin
+	++m_enemyQueueIndex;
+	if (m_enemyQueueIndex >= MAX_ENEMY_QUEUE)
+		m_enemyQueueIndex = 0;
+	
+	if (m_enemyQueueCount < MAX_ENEMY_QUEUE)
+		++m_enemyQueueCount;
+
+	// clamp reaction time to enemy queue size
+	float reactionTime = GetProfile()->GetReactionTime() - g_BotUpdateInterval;
+	float maxReactionTime = (MAX_ENEMY_QUEUE * g_BotUpdateInterval) - 0.01f;
+	if (reactionTime > maxReactionTime)
+		reactionTime = maxReactionTime;
+
+	// "rewind" time back to our reaction time
+	int reactionTimeSteps = (int)((reactionTime / g_BotUpdateInterval) + 0.5f);
+
+	int i = now - reactionTimeSteps;
+	if (i < 0)
+		i += MAX_ENEMY_QUEUE;
+
+	m_enemyQueueAttendIndex = (unsigned char)i;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the most dangerous threat we are "conscious" of
+ */
+CCSPlayer *CCSBot::GetRecognizedEnemy( void )
+{
+	if (m_enemyQueueAttendIndex >= m_enemyQueueCount || IsBlind())
+	{
+		return NULL;
+	}
+
+	return m_enemyQueue[ m_enemyQueueAttendIndex ].player;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if the enemy we are "conscious" of is reloading
+ */
+bool CCSBot::IsRecognizedEnemyReloading( void )
+{
+	if (m_enemyQueueAttendIndex >= m_enemyQueueCount)
+		return false;
+
+	return m_enemyQueue[ m_enemyQueueAttendIndex ].isReloading;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if the enemy we are "conscious" of is hiding behind a shield
+ */
+bool CCSBot::IsRecognizedEnemyProtectedByShield( void )
+{
+	if (m_enemyQueueAttendIndex >= m_enemyQueueCount)
+		return false;
+
+	return m_enemyQueue[ m_enemyQueueAttendIndex ].isProtectedByShield;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return distance to closest enemy we are "conscious" of
+ */
+float CCSBot::GetRangeToNearestRecognizedEnemy( void )
+{
+	const CCSPlayer *enemy = GetRecognizedEnemy();
+
+	if (enemy)
+		return (GetAbsOrigin() - enemy->GetAbsOrigin()).Length();
+
+	return 99999999.9f;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Blind the bot for the given duration
+ */
+void CCSBot::Blind( float holdTime, float fadeTime, float startingAlpha )
+{
+	PrintIfWatched( "Blinded: holdTime = %3.2f, fadeTime = %3.2f, alpha = %3.2f\n", holdTime, fadeTime, startingAlpha );
+
+	// if we were only blinded a little bit, shake it off
+	const float mildBlindTime = 3.0f;
+	if (holdTime < mildBlindTime)
+	{
+		Wait( 0.75f * holdTime );
+		BecomeAlert();
+		BaseClass::Blind( holdTime, fadeTime, startingAlpha );
+		return;
+	}
+
+
+	// if blinded while in combat - then spray and pray!
+	m_blindFire = IsAttacking();
+
+	// retreat
+	// do this first, so spot selection happens before IsBlind() is set
+	const float hideRange = 400.0f;
+	TryToRetreat( hideRange );
+
+	PrintIfWatched( "I'm blind!\n" );
+
+	if (RandomFloat( 0.0f, 100.0f ) < 33.3f)
+	{
+		GetChatter()->Say( "Blinded", 1.0f );
+	}
+
+	// no longer safe
+	AdjustSafeTime();
+
+	// decide which way to move while blind
+	m_blindMoveDir = static_cast<NavRelativeDirType>( RandomInt( 1, NUM_RELATIVE_DIRECTIONS-1 ) );
+
+	// if we're defusing, don't give up
+	if (IsDefusingBomb())
+	{
+		return;
+	}
+
+	// can't see to aim at enemy
+	StopAiming();
+
+	// dont override "facing away" behavior unless we are going to spray and pray
+	if (m_blindFire)
+	{
+		ClearLookAt();
+
+		// just look straight ahead while blind
+		Vector forward;
+		EyeVectors( &forward );
+		SetLookAt( "Blind", EyePosition() + 10000.0f * forward, PRIORITY_UNINTERRUPTABLE, holdTime + 0.5f * fadeTime );
+	}
+	
+	StopWaiting();
+	BecomeAlert();
+
+	BaseClass::Blind( holdTime, fadeTime, startingAlpha );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+class CheckLookAt
+{
+public:
+	CheckLookAt( const CCSBot *me, bool testFOV )
+	{
+		m_me = me;
+		m_testFOV = testFOV;
+	}
+
+	bool operator() ( CBasePlayer *player )
+	{
+		if (!m_me->IsEnemy( player ))
+			return true;
+
+		if (m_testFOV && !(const_cast< CCSBot * >(m_me)->FInViewCone( player->WorldSpaceCenter() )))
+			return true;
+
+		if (!m_me->IsPlayerLookingAtMe( player ))
+			return true;
+			
+		if (m_me->IsVisible( (CCSPlayer *)player ))
+			return false;
+
+		return true;
+	}
+
+	const CCSBot *m_me;
+	bool m_testFOV;
+};
+
+/**
+ * Return true if any enemy I have LOS to is looking directly at me
+ * @todo Use reaction time pipeline
+ */
+bool CCSBot::IsAnyVisibleEnemyLookingAtMe( bool testFOV ) const
+{
+	CheckLookAt checkLookAt( this, testFOV );
+	return (ForEachPlayer( checkLookAt ) == false) ? true : false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Do panic behavior
+ */
+void CCSBot::UpdatePanicLookAround( void )
+{
+	if (m_panicTimer.IsElapsed())
+	{
+		return;
+	}
+
+	if (IsEnemyVisible())
+	{
+		StopPanicking();
+		return;
+	}
+
+	if (HasLookAtTarget())
+	{
+		// wait until we finish our current look at
+		return;
+	}
+
+	// select a spot somewhere behind us to look at as we search for our attacker
+	const QAngle &eyeAngles = EyeAngles();
+
+	QAngle newAngles;
+	newAngles.x = RandomFloat( -30.0f, 30.0f );
+
+	// Look directly behind at a random offset in a 90 window.
+	float yaw = RandomFloat( 135.0f, 225.0f );
+	newAngles.y = eyeAngles.y + yaw;
+	newAngles.z = 0.0f;
+
+	Vector forward;
+	AngleVectors( newAngles, &forward );
+
+	Vector spot;
+	spot = EyePosition() + 1000.0f * forward;
+
+	SetLookAt( "Panic", spot, PRIORITY_HIGH, 0.0f );
+	PrintIfWatched( "Panic yaw angle = %3.2f\n", newAngles.y );
+}
diff --git a/game/server/cstrike/bot/cs_bot_weapon.cpp b/game/server/cstrike/bot/cs_bot_weapon.cpp
new file mode 100644
index 00000000..4c737f57
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_weapon.cpp
@@ -0,0 +1,1363 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+#include "basecsgrenade_projectile.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Fire our active weapon towards our current enemy
+ * NOTE: Aiming our weapon is handled in RunBotUpkeep()
+ */
+void CCSBot::FireWeaponAtEnemy( void )
+{
+	if (cv_bot_dont_shoot.GetBool())
+	{
+		return;
+	}
+
+	CBasePlayer *enemy = GetBotEnemy();
+	if (enemy == NULL)
+	{
+		return;
+	}
+
+	Vector myOrigin = GetCentroid( this );
+
+	if (IsUsingSniperRifle())
+	{
+		// if we're using a sniper rifle, don't fire until we are standing still, are zoomed in, and not rapidly moving our view
+		if (!IsNotMoving() || IsWaitingForZoom() || !HasViewBeenSteady( GetProfile()->GetReactionTime() ) )
+		{
+			return;
+		}
+	}
+
+	if (gpGlobals->curtime > m_fireWeaponTimestamp &&
+		GetTimeSinceAcquiredCurrentEnemy() >= GetProfile()->GetAttackDelay() &&
+		!IsSurprised())
+	{
+		if (!(IsRecognizedEnemyProtectedByShield() && IsPlayerFacingMe( enemy )) &&	// don't shoot at enemies behind shields
+			!IsReloading() && 
+			!IsActiveWeaponClipEmpty() && 
+			//gpGlobals->curtime > m_reacquireTimestamp &&
+			IsEnemyVisible())
+		{
+			// we have a clear shot - pull trigger if we are aiming at enemy
+			Vector toAimSpot = m_aimSpot - EyePosition();
+			float rangeToEnemy = toAimSpot.NormalizeInPlace();
+
+			if ( IsUsingSniperRifle() )
+			{
+				// check our accuracy versus our target distance
+				float fProjectedSpread = rangeToEnemy * GetActiveCSWeapon()->GetInaccuracy();
+				float fRequiredSpread = IsUsing( WEAPON_AWP ) ? 50.0f : 25.0f;	// AWP will kill with any hit
+				if ( fProjectedSpread > fRequiredSpread )
+					return;
+			}
+
+			// get actual view direction vector
+			Vector aimDir = GetViewVector();
+
+			float onTarget = DotProduct( toAimSpot, aimDir );
+
+			// aim more precisely with a sniper rifle
+			// because rifles' bullets spray, don't have to be very precise
+			const float halfSize = (IsUsingSniperRifle()) ? HalfHumanWidth : 2.0f * HalfHumanWidth;
+
+			// aiming tolerance depends on how close the target is - closer targets subtend larger angles
+			float aimTolerance = (float)cos( atan( halfSize / rangeToEnemy ) );
+
+			if (onTarget > aimTolerance)
+			{
+				bool doAttack;
+
+				// if friendly fire is on, don't fire if a teammate is blocking our line of fire
+				if (TheCSBots()->AllowFriendlyFireDamage())
+				{
+					if (IsFriendInLineOfFire())
+						doAttack = false;
+					else
+						doAttack = true;
+				}
+				else
+				{
+					// fire freely
+					doAttack = true;
+				}
+
+				if (doAttack)
+				{
+					// if we are using a knife, only swing it if we're close
+					if (IsUsingKnife())
+					{
+						const float knifeRange = 75.0f;		// 50
+						if (rangeToEnemy < knifeRange)
+						{
+							// since we've given ourselves away - run!
+							ForceRun( 5.0f );
+
+							// if our prey is facing away, backstab him!
+							if (!IsPlayerFacingMe( enemy ))
+							{
+								SecondaryAttack();
+							}
+							else
+							{
+								// randomly choose primary and secondary attacks with knife
+								const float knifeStabChance = 33.3f;
+								if (RandomFloat( 0, 100 ) < knifeStabChance)
+									SecondaryAttack();
+								else
+									PrimaryAttack();
+							}
+						}
+					}
+					else
+					{
+						PrimaryAttack();
+					}
+				}
+
+				if (IsUsingPistol())
+				{
+					// high-skill bots fire their pistols quickly at close range
+					const float closePistolRange = 360.0f;
+					if (GetProfile()->GetSkill() > 0.75f && rangeToEnemy < closePistolRange)
+					{
+						// fire as fast as possible
+						m_fireWeaponTimestamp = 0.0f; 
+					}
+					else
+					{
+						// fire somewhat quickly
+						m_fireWeaponTimestamp = RandomFloat( 0.15f, 0.4f );
+					}
+				}
+				else	// not using a pistol
+				{
+					const float sprayRange = 400.0f;
+					if (GetProfile()->GetSkill() < 0.5f || rangeToEnemy < sprayRange || IsUsingMachinegun())
+					{
+						// spray 'n pray if enemy is close, or we're not that good, or we're using the big machinegun
+						m_fireWeaponTimestamp = 0.0f;
+					}
+					else
+					{
+						const float distantTargetRange = 800.0f;
+						if (!IsUsingSniperRifle() && rangeToEnemy > distantTargetRange)
+						{
+							// if very far away, fire slowly for better accuracy
+							m_fireWeaponTimestamp = RandomFloat( 0.3f, 0.7f );
+						}
+						else
+						{
+							// fire short bursts for accuracy
+							m_fireWeaponTimestamp = RandomFloat( 0.15f, 0.25f );		// 0.15, 0.5
+						}
+					}
+				}
+
+				// subtract system latency
+				m_fireWeaponTimestamp -= g_BotUpdateInterval;
+
+				m_fireWeaponTimestamp += gpGlobals->curtime;
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Set the current aim offset using given accuracy (1.0 = perfect aim, 0.0f = terrible aim)
+ */
+void CCSBot::SetAimOffset( float accuracy )
+{
+	// if our accuracy is less than perfect, it will improve as we "focus in" while not rotating our view
+	if (accuracy < 1.0f)
+	{
+		// if we moved our view, reset our "focus" mechanism
+		if (IsViewMoving( 100.0f ))
+			m_aimSpreadTimestamp = gpGlobals->curtime;
+
+		// focusTime is the time it takes for a bot to "focus in" for very good aim, from 2 to 5 seconds
+		const float focusTime = MAX( 5.0f * (1.0f - accuracy), 2.0f );
+		float focusInterval = gpGlobals->curtime - m_aimSpreadTimestamp;
+
+		float focusAccuracy = focusInterval / focusTime;
+
+		// limit how much "focus" will help
+		const float maxFocusAccuracy = 0.75f;
+		if (focusAccuracy > maxFocusAccuracy)
+			focusAccuracy = maxFocusAccuracy;
+
+		accuracy = MAX( accuracy, focusAccuracy );
+	}
+
+	//PrintIfWatched( "Accuracy = %4.3f\n", accuracy );
+
+	// aim error increases with distance, such that actual crosshair error stays about the same
+	float range = (m_lastEnemyPosition - EyePosition()).Length();
+	float maxOffset = (GetFOV()/GetDefaultFOV()) * 0.05f * range;		// 0.1
+	float error = maxOffset * (1.0f - accuracy);
+
+	m_aimOffsetGoal.x = RandomFloat( -error, error );
+	m_aimOffsetGoal.y = RandomFloat( -error, error );
+	m_aimOffsetGoal.z = RandomFloat( -error, error );
+
+	// define time when aim offset will automatically be updated
+	m_aimOffsetTimestamp = gpGlobals->curtime + RandomFloat( 0.25f, 1.0f ); // 0.25, 1.5f
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Wiggle aim error based on GetProfile()->GetSkill()
+ */
+void CCSBot::UpdateAimOffset( void )
+{
+	if (gpGlobals->curtime >= m_aimOffsetTimestamp)
+	{
+		SetAimOffset( GetProfile()->GetSkill() );
+	}
+
+	// move current offset towards goal offset
+	Vector d = m_aimOffsetGoal - m_aimOffset;
+	const float stiffness = 0.1f;
+	m_aimOffset.x += stiffness * d.x;
+	m_aimOffset.y += stiffness * d.y;
+	m_aimOffset.z += stiffness * d.z;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Change our zoom level to be appropriate for the given range.
+ * Return true if the zoom level changed.
+ */
+bool CCSBot::AdjustZoom( float range )
+{
+	bool adjustZoom = false;
+
+	if (IsUsingSniperRifle())
+	{
+		const float sniperZoomRange = 150.0f;	// NOTE: This must be less than sniperMinRange in AttackState
+		const float sniperFarZoomRange = 1500.0f;
+
+		// if range is too close, don't zoom
+		if (range <= sniperZoomRange)
+		{
+			// zoom out
+			if (GetZoomLevel() != NO_ZOOM)
+			{
+				adjustZoom = true;
+			}
+		}
+		else if (range < sniperFarZoomRange)
+		{
+			// maintain low zoom
+			if (GetZoomLevel() != LOW_ZOOM)
+			{
+				adjustZoom = true;
+			}
+		}
+		else
+		{
+			// maintain high zoom
+			if (GetZoomLevel() != HIGH_ZOOM)
+			{
+				adjustZoom = true;
+			}
+		}
+	}
+	else
+	{
+		// zoom out
+		if (GetZoomLevel() != NO_ZOOM)
+		{
+			adjustZoom = true;
+		}
+	}
+
+	if (adjustZoom)
+	{
+		SecondaryAttack();
+
+		// pause after zoom to allow "eyes" to refocus
+// 		m_zoomTimer.Start( 0.25f + (1.0f - GetProfile()->GetSkill()) );
+		m_zoomTimer.Start( 0.25f );
+	}
+
+	return adjustZoom;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if using the specific weapon
+ */
+bool CCSBot::IsUsing( CSWeaponID weaponID ) const
+{
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+
+	if (weapon == NULL)
+		return false;
+
+	if (weapon->IsA( weaponID ))
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if we are using a weapon with a removable silencer
+ */
+bool CCSBot::DoesActiveWeaponHaveSilencer( void ) const
+{
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+
+	if (weapon == NULL)
+		return false;
+
+	if (weapon->IsA( WEAPON_M4A1 ) || weapon->IsA( WEAPON_USP ))
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are using a sniper rifle
+ */
+bool CCSBot::IsUsingSniperRifle( void ) const
+{
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+
+	if (weapon && IsSniperRifle( weapon ))
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we have a sniper rifle in our inventory
+ */
+bool CCSBot::IsSniper( void ) const
+{
+	CWeaponCSBase *weapon = static_cast<CWeaponCSBase *>( Weapon_GetSlot( WEAPON_SLOT_RIFLE ) );
+
+	if (weapon && IsSniperRifle( weapon ))
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are actively sniping (moving to sniper spot or settled in)
+ */
+bool CCSBot::IsSniping( void ) const
+{
+	if (GetTask() == MOVE_TO_SNIPER_SPOT || GetTask() == SNIPING)
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are using a shotgun
+ */
+bool CCSBot::IsUsingShotgun( void ) const
+{
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+
+	if (weapon == NULL)
+		return false;
+
+	return weapon->IsKindOf(WEAPONTYPE_SHOTGUN);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if using the big 'ol machinegun
+ */
+bool CCSBot::IsUsingMachinegun( void ) const
+{
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+
+	if (weapon && weapon->IsA( WEAPON_M249 ))
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if primary weapon doesn't exist or is totally out of ammo
+ */
+bool CCSBot::IsPrimaryWeaponEmpty( void ) const
+{
+	CWeaponCSBase *weapon = static_cast<CWeaponCSBase *>( Weapon_GetSlot( WEAPON_SLOT_RIFLE ) );
+
+	if (weapon == NULL)
+		return true;
+
+	// check if gun has any ammo left
+	if (weapon->HasAnyAmmo())
+		return false;
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if pistol doesn't exist or is totally out of ammo
+ */
+bool CCSBot::IsPistolEmpty( void ) const
+{
+	CWeaponCSBase *weapon = static_cast<CWeaponCSBase *>( Weapon_GetSlot( WEAPON_SLOT_PISTOL ) );
+
+	if (weapon == NULL)
+		return true;
+
+	// check if gun has any ammo left
+	if (weapon->HasAnyAmmo())
+		return false;
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Equip the given item
+ */
+bool CCSBot::DoEquip( CWeaponCSBase *weapon )
+{
+	if (weapon == NULL)
+		return false;
+
+	// check if weapon has any ammo left
+	if (!weapon->HasAnyAmmo())
+		return false;
+
+	// equip it
+	SelectItem( weapon->GetClassname() );
+	m_equipTimer.Start();
+
+	return true;
+}
+
+
+// throttle how often equipping is allowed
+const float minEquipInterval = 5.0f;
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Equip the best weapon we are carrying that has ammo
+ */
+void CCSBot::EquipBestWeapon( bool mustEquip )
+{
+	// throttle how often equipping is allowed
+	if (!mustEquip && m_equipTimer.GetElapsedTime() < minEquipInterval)
+		return;
+
+	CCSBotManager *ctrl = static_cast<CCSBotManager *>( TheBots );
+
+	CWeaponCSBase *primary = static_cast<CWeaponCSBase *>( Weapon_GetSlot( WEAPON_SLOT_RIFLE ) );
+	if (primary)
+	{
+		CSWeaponType weaponClass = primary->GetCSWpnData().m_WeaponType;
+
+		if ((ctrl->AllowShotguns() && weaponClass == WEAPONTYPE_SHOTGUN) ||
+			(ctrl->AllowMachineGuns() && weaponClass == WEAPONTYPE_MACHINEGUN) || 
+			(ctrl->AllowRifles() && weaponClass == WEAPONTYPE_RIFLE) || 
+			(ctrl->AllowShotguns() && weaponClass == WEAPONTYPE_SHOTGUN) ||
+			(ctrl->AllowSnipers() && weaponClass == WEAPONTYPE_SNIPER_RIFLE) || 
+			(ctrl->AllowSubMachineGuns() && weaponClass == WEAPONTYPE_SUBMACHINEGUN))
+		{
+			if (DoEquip( primary ))
+				return;
+		}
+	}
+
+	if (ctrl->AllowPistols())
+	{
+		if (DoEquip( static_cast<CWeaponCSBase *>( Weapon_GetSlot( WEAPON_SLOT_PISTOL ) ) ))
+			return;
+	}
+
+	// always have a knife
+	EquipKnife();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Equip our pistol
+ */
+void CCSBot::EquipPistol( void )
+{
+	// throttle how often equipping is allowed
+	if (m_equipTimer.GetElapsedTime() < minEquipInterval)
+		return;
+
+	if (TheCSBots()->AllowPistols() && !IsUsingPistol())
+	{
+		CWeaponCSBase *pistol = static_cast<CWeaponCSBase *>( Weapon_GetSlot( WEAPON_SLOT_PISTOL ) );
+		DoEquip( pistol );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Equip the knife
+ */
+void CCSBot::EquipKnife( void )
+{
+	if (!IsUsingKnife())
+	{
+		SelectItem( "weapon_knife" );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we have a grenade in our inventory
+ */
+bool CCSBot::HasGrenade( void ) const
+{
+	CWeaponCSBase *grenade = static_cast<CWeaponCSBase *>( Weapon_GetSlot( WEAPON_SLOT_GRENADES ) );
+	return (grenade) ? true : false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Equip a grenade, return false if we cant
+ */
+bool CCSBot::EquipGrenade( bool noSmoke )
+{
+	// snipers don't use grenades
+	if (IsSniper())
+		return false;
+
+	if (IsUsingGrenade())
+		return true;
+
+	if (HasGrenade())
+	{
+		CWeaponCSBase *grenade = static_cast<CWeaponCSBase *>( Weapon_GetSlot( WEAPON_SLOT_GRENADES ) );
+
+		if (noSmoke && grenade->IsA( WEAPON_SMOKEGRENADE ))
+			return false;
+
+		SelectItem( grenade->GetClassname() );
+
+		return true;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if we have knife equipped
+ */
+bool CCSBot::IsUsingKnife( void ) const
+{
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+
+	if (weapon && weapon->IsA( WEAPON_KNIFE ))
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if we have pistol equipped
+ */
+bool CCSBot::IsUsingPistol( void ) const
+{
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+
+	if (weapon && weapon->IsPistol())
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if we have a grenade equipped
+ */
+bool CCSBot::IsUsingGrenade( void ) const
+{
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+
+	if (!weapon)
+		return false;
+
+	if (weapon->IsA( WEAPON_FLASHBANG ) ||
+		weapon->IsA( WEAPON_SMOKEGRENADE ) ||
+		weapon->IsA( WEAPON_HEGRENADE ))
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Begin the process of throwing the grenade
+ */
+void CCSBot::ThrowGrenade( const Vector &target )
+{
+	if (IsUsingGrenade() && m_grenadeTossState == NOT_THROWING && !IsOnLadder())
+	{
+		m_grenadeTossState = START_THROW;
+		m_tossGrenadeTimer.Start( 2.0f );
+
+		const float angleTolerance = 3.0f;
+		SetLookAt( "GrenadeThrow", target, PRIORITY_UNINTERRUPTABLE, 4.0f, false, angleTolerance ); 
+
+		Wait( RandomFloat( 2.0f, 4.0f ) );
+
+		if (cv_bot_debug.GetBool() && IsLocalPlayerWatchingMe())
+		{
+			NDebugOverlay::Cross3D( target, 25.0f, 255, 125, 0, true, 3.0f );
+		}
+
+		PrintIfWatched( "%3.2f: Grenade: START_THROW\n", gpGlobals->curtime );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if our weapon can attack
+ */
+bool CCSBot::CanActiveWeaponFire( void ) const
+{
+	return ( GetActiveWeapon() && GetActiveWeapon()->m_flNextPrimaryAttack <= gpGlobals->curtime );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Find spot to throw grenade ahead of us and "around the corner" along our path
+ */
+bool CCSBot::FindGrenadeTossPathTarget( Vector *pos )
+{
+	if (!HasPath())
+		return false;
+
+	// find farthest point we can see on the path
+	int i;
+	for( i=m_pathIndex; i<m_pathLength; ++i )
+	{
+		if (!FVisible( m_path[i].pos + Vector( 0, 0, HalfHumanHeight ) ))
+			break;
+	}
+
+	if (i == m_pathIndex)
+		return false;
+
+	// find exact spot where we lose sight
+	Vector dir = m_path[i].pos - m_path[i-1].pos;
+	float length = dir.NormalizeInPlace();
+
+	const float inc = 25.0f;
+	Vector p;
+	Vector visibleSpot = m_path[i-1].pos;
+	for( float t = 0.0f; t<length; t += inc )
+	{
+		p = m_path[i-1].pos + t * dir;
+		p.z += HalfHumanHeight;
+		if (!FVisible( p ))
+			break;
+
+		visibleSpot = p;
+	}
+
+	// massage the location a bit
+	visibleSpot.z += 10.0f;
+
+	const float bufferRange = 50.0f;
+
+	trace_t result;
+	Vector check;
+
+	// check +X
+	check = visibleSpot + Vector( 999.9f, 0, 0 );
+	UTIL_TraceLine( visibleSpot, check, MASK_PLAYERSOLID, this, COLLISION_GROUP_NONE, &result );
+
+	if (result.fraction < 1.0f)
+	{
+		float range = result.endpos.x - visibleSpot.x;
+		if (range < bufferRange)
+		{
+			visibleSpot.x = result.endpos.x - bufferRange;
+		}
+	}
+
+	// check -X
+	check = visibleSpot + Vector( -999.9f, 0, 0 );
+	UTIL_TraceLine( visibleSpot, check, MASK_PLAYERSOLID, this, COLLISION_GROUP_NONE, &result );
+
+	if (result.fraction < 1.0f)
+	{
+		float range = visibleSpot.x - result.endpos.x;
+		if (range < bufferRange)
+		{
+			visibleSpot.x = result.endpos.x + bufferRange;
+		}
+	}
+
+	// check +Y
+	check = visibleSpot + Vector( 0, 999.9f, 0 );
+	UTIL_TraceLine( visibleSpot, check, MASK_PLAYERSOLID, this, COLLISION_GROUP_NONE, &result );
+
+	if (result.fraction < 1.0f)
+	{
+		float range = result.endpos.y - visibleSpot.y;
+		if (range < bufferRange)
+		{
+			visibleSpot.y = result.endpos.y - bufferRange;
+		}
+	}
+
+	// check -Y
+	check = visibleSpot + Vector( 0, -999.9f, 0 );
+	UTIL_TraceLine( visibleSpot, check, MASK_PLAYERSOLID, this, COLLISION_GROUP_NONE, &result );
+
+	if (result.fraction < 1.0f)
+	{
+		float range = visibleSpot.y - result.endpos.y;
+		if (range < bufferRange)
+		{
+			visibleSpot.y = result.endpos.y + bufferRange;
+		}
+	}
+
+	*pos = visibleSpot;
+	return true;	
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Look for grenade throw targets and throw the grenade
+ */
+void CCSBot::LookForGrenadeTargets( void )
+{
+	if (!IsUsingGrenade() || IsThrowingGrenade())
+	{
+		return;
+	}
+
+	const CNavArea *tossArea = GetInitialEncounterArea();
+	if (tossArea == NULL)
+	{
+		return;
+	}
+
+	int enemyTeam = OtherTeam( GetTeamNumber() );
+
+	// check if we should put our grenade away
+	if (tossArea->GetEarliestOccupyTime( enemyTeam ) > gpGlobals->curtime)
+	{
+		EquipBestWeapon( MUST_EQUIP );
+		return;
+	}
+
+	// throw grenades at initial encounter area
+	Vector tossTarget = Vector( 0, 0, 0 );
+	if (!tossArea->IsVisible( EyePosition(), &tossTarget ))
+	{
+		return;
+	}
+
+
+	CWeaponCSBase *weapon = GetActiveCSWeapon();
+	if (weapon && weapon->IsA( WEAPON_SMOKEGRENADE ))
+	{
+		// don't worry so much about smokes
+		ThrowGrenade( tossTarget );
+		PrintIfWatched( "Throwing smoke grenade!" );
+		SetInitialEncounterArea( NULL );
+		return;
+	}
+	else	// explosive and flashbang grenades
+	{
+		// initial encounter area is visible, wait to throw until timing is right
+
+		const float leadTime = 1.5f;
+		float enemyTime = tossArea->GetEarliestOccupyTime( enemyTeam );
+		if (enemyTime - TheCSBots()->GetElapsedRoundTime() > leadTime)
+		{
+			// don't throw yet
+			return;
+		}
+
+
+		Vector to = tossTarget - EyePosition();
+		float range = to.Length();
+
+		const float slope = 0.2f; // 0.25f;
+		float tossHeight = slope * range;
+
+		trace_t result;
+		CTraceFilterNoNPCsOrPlayer traceFilter( this, COLLISION_GROUP_NONE );
+
+		const float heightInc = tossHeight / 10.0f;
+		Vector target;
+		float safeSpace = tossHeight / 2.0f;
+
+		// Build a box to sweep along the ray when looking for obstacles
+		const Vector& eyePosition = EyePosition();
+		Vector mins = VEC_HULL_MIN;
+		Vector maxs = VEC_HULL_MAX;
+		mins.z = 0;
+		maxs.z = heightInc;
+
+
+		// find low and high bounds of toss window
+		float low = 0.0f;
+		float high = tossHeight + safeSpace;
+		bool gotLow = false;
+		float lastH = 0.0f;
+		for( float h = 0.0f; h < 3.0f * tossHeight; h += heightInc )
+		{
+			target = tossTarget + Vector( 0, 0, h );
+
+			// make sure toss line is clear
+
+			QAngle angles( 0, 0, 0 );
+			Ray_t ray;
+			ray.Init( eyePosition, target, mins, maxs );
+			enginetrace->TraceRay( ray, MASK_VISIBLE_AND_NPCS | CONTENTS_GRATE, &traceFilter, &result );
+			if (result.fraction == 1.0f)
+			{
+				//NDebugOverlay::SweptBox( eyePosition, target, mins, maxs, angles, 0, 0, 255, 40, 10.0f );
+
+				// line is clear
+				if (!gotLow)
+				{
+					low = h;
+					gotLow = true;
+				}
+			}
+			else
+			{
+				//NDebugOverlay::SweptBox( eyePosition, target, mins, maxs, angles, 255, 0, 0, 5, 10.0f );
+
+				// line is blocked
+				if (gotLow)
+				{
+					high = lastH;
+					break;
+				}
+			}
+
+			lastH = h;
+		}
+
+		if (gotLow)
+		{
+			// throw grenade into toss window
+			if (tossHeight < low)
+			{
+				if (low + safeSpace > high)
+				{
+					// narrow window
+					tossHeight = (high + low)/2.0f;
+				}
+				else
+				{
+					tossHeight = low + safeSpace;
+				}
+			}
+			else if (tossHeight > high - safeSpace)
+			{
+				if (high - safeSpace < low)
+				{
+					// narrow window
+					tossHeight = (high + low)/2.0f;
+				}
+				else
+				{
+					tossHeight = high - safeSpace;
+				}
+			}
+
+			ThrowGrenade( tossTarget + Vector( 0, 0, tossHeight ) );
+			SetInitialEncounterArea( NULL );
+			return;
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+class FOVClearOfFriends
+{
+public:
+	FOVClearOfFriends( CCSBot *me )
+	{
+		m_me = me;
+	}
+
+	bool operator() ( CBasePlayer *player )
+	{
+		if (player == m_me || !player->IsAlive())
+			return true;
+
+		if (m_me->InSameTeam( player ))
+		{
+			Vector to = player->EyePosition() - m_me->EyePosition();
+			to.NormalizeInPlace();
+
+			Vector forward;
+			m_me->EyeVectors( &forward );
+
+			if (DotProduct( to, forward ) > 0.95f)
+			{
+				if (m_me->IsVisible( (CCSPlayer *)player ))
+				{
+					// we see a friend in our FOV
+					return false;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	CCSBot *m_me;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Process the grenade throw state machine
+ */
+void CCSBot::UpdateGrenadeThrow( void )
+{
+	switch( m_grenadeTossState )
+	{
+		case START_THROW:
+		{
+			if (m_tossGrenadeTimer.IsElapsed())
+			{
+				// something prevented the throw - give up
+				EquipBestWeapon( MUST_EQUIP );
+				ClearLookAt();
+				m_grenadeTossState = NOT_THROWING;
+				PrintIfWatched( "%3.2f: Grenade: THROW FAILED\n", gpGlobals->curtime );
+				return;
+			}
+
+			if (m_lookAtSpotState == LOOK_AT_SPOT)
+			{
+				// don't throw if there are friends ahead of us
+				FOVClearOfFriends fovClear( this );
+				if (ForEachPlayer( fovClear ))
+				{
+					m_grenadeTossState = FINISH_THROW;
+					m_tossGrenadeTimer.Start( 1.0f );
+					PrintIfWatched( "%3.2f: Grenade: FINISH_THROW\n", gpGlobals->curtime );
+				}
+				else
+				{
+					PrintIfWatched( "%3.2f: Grenade: Friend is in the way...\n", gpGlobals->curtime );
+				}
+			}
+
+			// hold in the trigger and be ready to throw
+			PrimaryAttack();
+
+			break;
+		}
+
+		case FINISH_THROW:
+		{
+			// throw the grenade and hold our aiming line for a moment
+			if (m_tossGrenadeTimer.IsElapsed())
+			{
+				ClearLookAt();
+
+				m_grenadeTossState = NOT_THROWING;
+				PrintIfWatched( "%3.2f: Grenade: THROW COMPLETE\n", gpGlobals->curtime );
+			}
+			break;
+		}
+
+		default:
+		{
+			if (IsUsingGrenade())
+			{
+				// pull the pin
+				PrimaryAttack();
+			}
+			break;
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+class GrenadeResponse
+{
+public:
+	GrenadeResponse( CCSBot *me )
+	{
+		m_me = me;
+	}
+
+	bool operator() ( ActiveGrenade *ag ) const
+	{
+		const float retreatRange = 300.0f;
+		const float hideTime = 1.0f;
+
+		// do we see this grenade
+		if (m_me->IsVisible( ag->GetPosition(), CHECK_FOV, (CBaseEntity *)ag->GetEntity() ))
+		{
+			// we see it
+			if (ag->IsSmoke())
+			{
+				// ignore smokes
+				return true;
+			}
+
+			Vector velDir = ag->GetEntity()->GetAbsVelocity();
+			float grenadeSpeed = velDir.NormalizeInPlace();
+			const float atRestSpeed = 50.0f;
+
+			const float aboutToBlow = 0.5f;
+			if (ag->IsFlashbang() && ag->GetEntity()->m_flDetonateTime - gpGlobals->curtime < aboutToBlow)
+			{
+				// turn away from flashbangs about to explode
+				QAngle eyeAngles = m_me->EyeAngles();
+
+				float yaw = RandomFloat( 100.0f, 135.0f );
+				eyeAngles.y += (RandomFloat( -1.0f, 1.0f ) < 0.0f) ? (-yaw) : yaw;
+
+				Vector forward;
+				AngleVectors( eyeAngles, &forward );
+
+				Vector away = m_me->EyePosition() - 1000.0f * forward;
+				const float duration = 2.0f;
+
+				m_me->ClearLookAt();
+				m_me->SetLookAt( "Avoid Flashbang", away, PRIORITY_UNINTERRUPTABLE, duration );
+
+				m_me->StopAiming();
+
+				return false;
+			}
+
+
+			// flee from grenades if close by or thrown towards us
+			const float throwDangerRange = 750.0f;
+			const float nearDangerRange = 300.0f;
+			Vector to = ag->GetPosition() - m_me->GetAbsOrigin();
+			float range = to.NormalizeInPlace();
+			if (range > throwDangerRange)
+			{
+				return true;
+			}
+
+			if (grenadeSpeed > atRestSpeed)
+			{
+				// grenade is moving
+				if (DotProduct( to, velDir ) >= -0.5f)
+				{
+					// going away from us
+					return true;
+				}
+
+				m_me->PrintIfWatched( "Retreating from a grenade thrown towards me!\n" );
+			}
+			else if (range < nearDangerRange)
+			{
+				// grenade has come to rest near us
+				m_me->PrintIfWatched( "Retreating from a grenade that landed near me!\n" );
+			}
+
+			// retreat!
+			m_me->TryToRetreat( retreatRange, hideTime );
+
+			return false;
+		}
+
+		return true;
+	}
+
+	CCSBot *m_me;
+};
+
+/**
+ * React to enemy grenades we see
+ */
+void CCSBot::AvoidEnemyGrenades( void )
+{
+	// low skill bots dont avoid grenades
+	if (GetProfile()->GetSkill() < 0.5)
+	{
+		return;
+	}
+
+	if (IsAvoidingGrenade())
+	{
+		// already avoiding one
+		return;
+	}
+
+	// low skill bots don't avoid grenades
+	if (GetProfile()->GetSkill() < 0.6f)
+	{
+		return;
+	}
+
+	GrenadeResponse respond( this );	
+	if (TheBots->ForEachGrenade( respond ) == false)
+	{
+		const float avoidTime = 4.0f;
+		m_isAvoidingGrenade.Start( avoidTime );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reload our weapon if we must
+ */
+void CCSBot::ReloadCheck( void )
+{
+	const float safeReloadWaitTime = 3.0f;
+	const float reloadAmmoRatio = 0.6f;
+
+	// don't bother to reload if there are no enemies left
+	if (GetEnemiesRemaining() == 0)
+		return;
+
+	if (IsDefusingBomb() || IsReloading())
+		return;
+
+	if (IsActiveWeaponClipEmpty())
+	{
+		// high-skill players switch to pistol instead of reloading during combat
+		if (GetProfile()->GetSkill() > 0.5f && IsAttacking())
+		{
+			if (!GetActiveCSWeapon()->IsPistol() && !IsPistolEmpty())
+			{
+				// switch to pistol instead of reloading
+				EquipPistol();
+				return;
+			}
+		}
+	}
+	else if (GetTimeSinceLastSawEnemy() > safeReloadWaitTime && GetActiveWeaponAmmoRatio() <= reloadAmmoRatio)
+	{
+		// high-skill players use all their ammo and switch to pistol instead of reloading during combat
+		if (GetProfile()->GetSkill() > 0.5f && IsAttacking())
+			return;
+	}
+	else
+	{
+		// do not need to reload
+		return;
+	}
+
+	// don't reload the AWP until it is totally out of ammo
+	if (IsUsing( WEAPON_AWP ) && !IsActiveWeaponClipEmpty())
+		return;
+
+	Reload();
+
+	// move to cover to reload if there are enemies nearby
+	if (GetNearbyEnemyCount())
+	{
+		// avoid enemies while reloading (above 0.75 skill always hide to reload)
+		const float hideChance = 25.0f + 100.0f * GetProfile()->GetSkill();
+
+		if (!IsHiding() && RandomFloat( 0, 100 ) < hideChance)
+		{
+			const float safeTime = 5.0f;
+			if (GetTimeSinceLastSawEnemy() < safeTime)
+			{
+				PrintIfWatched( "Retreating to a safe spot to reload!\n" );
+				const Vector *spot = FindNearbyRetreatSpot( this, 1000.0f );
+				if (spot)
+				{
+					// ignore enemies for a second to give us time to hide
+					// reaching our hiding spot clears our disposition
+					IgnoreEnemies( 10.0f );
+
+					Run();
+					StandUp();
+					Hide( *spot, 0.0f );
+				}
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Silence/unsilence our weapon if we must
+ */
+void CCSBot::SilencerCheck( void )
+{
+	const float safeSilencerWaitTime = 3.5f; // longer than reload check because reloading should take precedence
+
+	if (IsDefusingBomb() || IsReloading() || IsAttacking())
+		return;
+
+	// M4A1 and USP are the only weapons with removable silencers
+	if (!DoesActiveWeaponHaveSilencer())
+		return;
+
+	if (GetTimeSinceLastSawEnemy() < safeSilencerWaitTime)
+		return;
+
+	// don't touch the silencer if there are enemies nearby
+	if (GetNearbyEnemyCount() == 0)
+	{
+		CWeaponCSBase *weapon = GetActiveCSWeapon();
+		if (weapon == NULL)
+			return;
+
+		bool isSilencerOn = weapon->IsSilenced();
+
+		if ( weapon->m_flNextSecondaryAttack >= gpGlobals->curtime )
+			return;
+
+		// equip silencer if we want to and we don't have a shield.
+		if ( isSilencerOn != (GetProfile()->PrefersSilencer() || GetProfile()->GetSkill() > 0.7f) && !HasShield() )
+		{
+			PrintIfWatched( "%s silencer!\n", (isSilencerOn) ? "Unequipping" : "Equipping" );
+			weapon->SecondaryAttack();
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when in contact with a CBaseCombatWeapon
+ */
+bool CCSBot::BumpWeapon( CBaseCombatWeapon *pWeapon )
+{
+	CWeaponCSBase *droppedGun = dynamic_cast< CWeaponCSBase* >( pWeapon );
+
+	// right now we only care about primary weapons on the ground
+	if ( droppedGun && droppedGun->GetSlot() == WEAPON_SLOT_RIFLE )
+	{
+		CWeaponCSBase *myGun = dynamic_cast< CWeaponCSBase* >( Weapon_GetSlot( WEAPON_SLOT_RIFLE ) );
+
+		// if the gun on the ground is the same one we have, dont bother
+		if ( myGun && droppedGun->GetWeaponID() != myGun->GetWeaponID() )
+		{
+			// if we don't have a weapon preference, give up
+			if ( GetProfile()->HasPrimaryPreference() )
+			{
+				// don't change weapons if we've seen enemies recently
+				const float safeTime = 2.5f;
+				if ( GetTimeSinceLastSawEnemy() >= safeTime )
+				{
+					// we have a primary weapon - drop it if the one on the ground is better
+					for( int i = 0; i < GetProfile()->GetWeaponPreferenceCount(); ++i )
+					{
+						CSWeaponID prefID = GetProfile()->GetWeaponPreference( i );
+
+						if (!IsPrimaryWeapon( prefID ))
+							continue;
+
+						// if the gun we are using is more desirable, give up
+						if ( prefID == myGun->GetWeaponID() )
+							break;
+
+						if ( prefID == droppedGun->GetWeaponID() )
+						{
+							// the gun on the ground is better than the one we have - drop our gun
+							DropRifle();
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return BaseClass::BumpWeapon( droppedGun );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if a friend is in our weapon's way
+ * @todo Check more rays for safety.
+ */
+bool CCSBot::IsFriendInLineOfFire( void )
+{
+	// compute the unit vector along our view
+	Vector aimDir = GetViewVector();
+
+	// trace the bullet's path
+	trace_t result;
+	UTIL_TraceLine( EyePosition(), EyePosition() + 10000.0f * aimDir, MASK_PLAYERSOLID, this, COLLISION_GROUP_NONE, &result );
+
+	if (result.DidHitNonWorldEntity())
+	{
+		CBaseEntity *victim = result.m_pEnt;
+
+		if (victim && victim->IsPlayer() && victim->IsAlive())
+		{
+			CBasePlayer *player = static_cast<CBasePlayer *>( victim );
+
+			if (player->InSameTeam( this ))
+				return true;
+		}
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return line-of-sight distance to obstacle along weapon fire ray
+ * @todo Re-use this computation with IsFriendInLineOfFire()
+ */
+float CCSBot::ComputeWeaponSightRange( void )
+{
+	// compute the unit vector along our view
+	Vector aimDir = GetViewVector();
+
+	// trace the bullet's path
+	trace_t result;
+	UTIL_TraceLine( EyePosition(), EyePosition() + 10000.0f * aimDir, MASK_PLAYERSOLID, this, COLLISION_GROUP_NONE, &result );
+
+	return (EyePosition() - result.endpos).Length();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if the given player just fired their weapon
+ */
+bool CCSBot::DidPlayerJustFireWeapon( const CCSPlayer *player ) const
+{
+	// if this player has just fired his weapon, we notice him
+	CWeaponCSBase *weapon = player->GetActiveCSWeapon();
+	return (weapon && !weapon->IsSilenced() && weapon->m_flNextPrimaryAttack > gpGlobals->curtime);
+}
+
diff --git a/game/server/cstrike/bot/cs_bot_weapon_id.cpp b/game/server/cstrike/bot/cs_bot_weapon_id.cpp
new file mode 100644
index 00000000..21c423e1
--- /dev/null
+++ b/game/server/cstrike/bot/cs_bot_weapon_id.cpp
@@ -0,0 +1,22 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael Booth (mike@turtlerockstudios.com), 2003
+// Author: Matthew D. Campbell (matt@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Temporary solution until we have time to build something more elegant
+// Very nasty - need to keep in sync with the buy aliases
+// NOTE: Array must be NULL terminated
+//
diff --git a/game/server/cstrike/bot/cs_gamestate.cpp b/game/server/cstrike/bot/cs_gamestate.cpp
new file mode 100644
index 00000000..61f537ba
--- /dev/null
+++ b/game/server/cstrike/bot/cs_gamestate.cpp
@@ -0,0 +1,767 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Encapsulation of the current scenario/game state. Allows each bot imperfect knowledge.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "KeyValues.h"
+
+#include "cs_bot.h"
+#include "cs_gamestate.h"
+#include "cs_simple_hostage.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+CSGameState::CSGameState( CCSBot *owner )
+{
+	m_owner = owner;
+	m_isRoundOver = false;
+
+	m_bombState = MOVING;
+	m_lastSawBomber.Invalidate();
+	m_lastSawLooseBomb.Invalidate();
+	m_isPlantedBombPosKnown = false;
+	m_plantedBombsite = UNKNOWN;
+
+	m_bombsiteCount = 0;
+	m_bombsiteSearchIndex = 0;
+
+	for( int i=0; i<MAX_HOSTAGES; ++i )
+	{
+		m_hostage[i].hostage = NULL;
+		m_hostage[i].isValid = false;
+		m_hostage[i].isAlive = false;
+		m_hostage[i].isFree = true;
+		m_hostage[i].knownPos = Vector( 0, 0, 0 );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reset at round start
+ */
+void CSGameState::Reset( void )
+{
+	m_isRoundOver = false;
+
+	// bomb -----------------------------------------------------------------------
+	m_bombState = MOVING;
+	m_lastSawBomber.Invalidate();
+	m_lastSawLooseBomb.Invalidate();
+	m_isPlantedBombPosKnown = false;
+	m_plantedBombsite = UNKNOWN;
+
+	m_bombsiteCount = TheCSBots()->GetZoneCount();
+
+	int i;
+	for( i=0; i<m_bombsiteCount; ++i )
+	{
+		m_isBombsiteClear[i] = false;
+		m_bombsiteSearchOrder[i] = i;
+	}
+
+	// shuffle the bombsite search order
+	// allows T's to plant at random site, and TEAM_CT's to search in a random order
+	// NOTE: VS6 std::random_shuffle() doesn't work well with an array of two elements (most maps)
+	for( i=0; i < m_bombsiteCount; ++i )
+	{
+		int swap = m_bombsiteSearchOrder[i];
+		int rnd = RandomInt( i, m_bombsiteCount-1 );
+		m_bombsiteSearchOrder[i] = m_bombsiteSearchOrder[ rnd ];
+		m_bombsiteSearchOrder[ rnd ] = swap;
+	}
+
+	m_bombsiteSearchIndex = 0;
+
+	// hostage ---------------------------------------------------------------------
+	InitializeHostageInfo();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update game state based on events we have received
+ */
+void CSGameState::OnHostageRescuedAll( IGameEvent *event )
+{
+	m_allHostagesRescued = true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update game state based on events we have received
+ */
+void CSGameState::OnRoundEnd( IGameEvent *event )
+{
+	m_isRoundOver = true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update game state based on events we have received
+ */
+void CSGameState::OnRoundStart( IGameEvent *event )
+{
+	Reset();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update game state based on events we have received
+ */
+void CSGameState::OnBombPlanted( IGameEvent *event )
+{
+	// change state - the event is announced to everyone
+	SetBombState( PLANTED );
+
+	CBasePlayer *plantingPlayer = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+
+	// Terrorists always know where the bomb is
+	if (m_owner->GetTeamNumber() == TEAM_TERRORIST && plantingPlayer)
+	{
+		UpdatePlantedBomb( plantingPlayer->GetAbsOrigin() );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update game state based on events we have received
+ */
+void CSGameState::OnBombDefused( IGameEvent *event )
+{
+	// change state - the event is announced to everyone
+	SetBombState( DEFUSED );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update game state based on events we have received
+ */
+void CSGameState::OnBombExploded( IGameEvent *event )
+{
+	// change state - the event is announced to everyone
+	SetBombState( EXPLODED );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * True if round has been won or lost (but not yet reset)
+ */
+bool CSGameState::IsRoundOver( void ) const
+{
+	return m_isRoundOver;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CSGameState::SetBombState( BombState state )
+{
+	// if state changed, reset "last seen" timestamps
+	if (m_bombState != state)
+	{
+		m_bombState = state;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CSGameState::UpdateLooseBomb( const Vector &pos )
+{
+	m_looseBombPos = pos;
+	m_lastSawLooseBomb.Reset();
+
+	// we saw the loose bomb, update our state
+	SetBombState( LOOSE );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+float CSGameState::TimeSinceLastSawLooseBomb( void ) const
+{
+	return m_lastSawLooseBomb.GetElapsedTime();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+bool CSGameState::IsLooseBombLocationKnown( void ) const
+{
+	if (m_bombState != LOOSE)
+		return false;
+
+	return (m_lastSawLooseBomb.HasStarted()) ? true : false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CSGameState::UpdateBomber( const Vector &pos )
+{
+	m_bomberPos = pos;
+	m_lastSawBomber.Reset();
+
+	// we saw the bomber, update our state
+	SetBombState( MOVING );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+float CSGameState::TimeSinceLastSawBomber( void ) const
+{
+	return m_lastSawBomber.GetElapsedTime();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+bool CSGameState::IsPlantedBombLocationKnown( void ) const
+{
+	if (m_bombState != PLANTED)
+		return false;
+
+	return m_isPlantedBombPosKnown;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the zone index of the planted bombsite, or UNKNOWN
+ */
+int CSGameState::GetPlantedBombsite( void ) const
+{
+	if (m_bombState != PLANTED)
+		return UNKNOWN;
+
+	return m_plantedBombsite;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if we are currently in the bombsite where the bomb is planted
+ */
+bool CSGameState::IsAtPlantedBombsite( void ) const
+{
+	if (m_bombState != PLANTED)
+		return false;
+
+	Vector myOrigin = GetCentroid( m_owner );
+	const CCSBotManager::Zone *zone = TheCSBots()->GetClosestZone( myOrigin );
+
+	if (zone)
+	{
+		return (m_plantedBombsite == zone->m_index);
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the zone index of the next bombsite to search
+ */
+int CSGameState::GetNextBombsiteToSearch( void )
+{
+	if (m_bombsiteCount <= 0)
+		return 0;
+
+	int i;
+
+	// return next non-cleared bombsite index
+	for( i=m_bombsiteSearchIndex; i<m_bombsiteCount; ++i )
+	{
+		int z = m_bombsiteSearchOrder[i];
+		if (!m_isBombsiteClear[z])
+		{
+			m_bombsiteSearchIndex = i;
+			return z;
+		}
+	}
+
+	// all the bombsites are clear, someone must have been mistaken - start search over
+	for( i=0; i<m_bombsiteCount; ++i )
+		m_isBombsiteClear[i] = false;
+	m_bombsiteSearchIndex = 0;
+
+	return GetNextBombsiteToSearch();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns position of bomb in its various states (moving, loose, planted),
+ * or NULL if we don't know where the bomb is
+ */
+const Vector *CSGameState::GetBombPosition( void ) const
+{
+	switch( m_bombState )
+	{
+		case MOVING:
+		{
+			if (!m_lastSawBomber.HasStarted())
+				return NULL;
+
+			return &m_bomberPos;
+		}
+
+		case LOOSE:
+		{
+			if (IsLooseBombLocationKnown())
+				return &m_looseBombPos;
+
+			return NULL;
+		}
+
+		case PLANTED:
+		{
+			if (IsPlantedBombLocationKnown())
+				return &m_plantedBombPos;
+
+			return NULL;
+		}
+	}
+
+	return NULL;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * We see the planted bomb at 'pos'
+ */
+void CSGameState::UpdatePlantedBomb( const Vector &pos )
+{
+	const CCSBotManager::Zone *zone = TheCSBots()->GetClosestZone( pos );
+
+	if (zone == NULL)
+	{
+		CONSOLE_ECHO( "ERROR: Bomb planted outside of a zone!\n" );
+		m_plantedBombsite = UNKNOWN;
+	}
+	else
+	{
+		m_plantedBombsite = zone->m_index;
+	}
+
+	m_plantedBombPos = pos;
+	m_isPlantedBombPosKnown = true;
+	SetBombState( PLANTED );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Someone told us where the bomb is planted
+ */
+void CSGameState::MarkBombsiteAsPlanted( int zoneIndex )
+{
+	m_plantedBombsite = zoneIndex;
+	SetBombState( PLANTED );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Someone told us a bombsite is clear
+ */
+void CSGameState::ClearBombsite( int zoneIndex )
+{
+	if (zoneIndex >= 0 && zoneIndex < m_bombsiteCount)
+		m_isBombsiteClear[ zoneIndex ] = true;	
+}
+
+//--------------------------------------------------------------------------------------------------------------
+bool CSGameState::IsBombsiteClear( int zoneIndex ) const
+{
+	if (zoneIndex >= 0 && zoneIndex < m_bombsiteCount)
+		return m_isBombsiteClear[ zoneIndex ];
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Initialize our knowledge of the number and location of hostages
+ */
+void CSGameState::InitializeHostageInfo( void )
+{
+	m_hostageCount = 0;
+	m_allHostagesRescued = false;
+	m_haveSomeHostagesBeenTaken = false;
+
+	for( int i=0; i<g_Hostages.Count(); ++i )
+	{
+		m_hostage[ m_hostageCount ].hostage = g_Hostages[i];
+		m_hostage[ m_hostageCount ].knownPos = g_Hostages[i]->GetAbsOrigin();
+		m_hostage[ m_hostageCount ].isValid = true;
+		m_hostage[ m_hostageCount ].isAlive = true;
+		m_hostage[ m_hostageCount ].isFree = true;
+		++m_hostageCount;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest free and live hostage
+ * If we are a CT this information is perfect. 
+ * Otherwise, this is based on our individual memory of the game state.
+ * If NULL is returned, we don't think there are any hostages left, or we dont know where they are.
+ * NOTE: a T can remember a hostage who has died.  knowPos will be filled in, but NULL will be
+ *       returned, since CHostages get deleted when they die.
+ */
+CHostage *CSGameState::GetNearestFreeHostage( Vector *knowPos ) const
+{
+	if (m_owner == NULL)
+		return NULL;
+
+	CNavArea *startArea = m_owner->GetLastKnownArea();
+	if (startArea == NULL)
+		return NULL;
+
+	CHostage *close = NULL;
+	Vector closePos( 0, 0, 0 );
+	float closeDistance = 9999999999.9f;
+
+	for( int i=0; i<m_hostageCount; ++i )
+	{
+		CHostage *hostage = m_hostage[i].hostage;
+		Vector hostagePos;
+
+		if (m_owner->GetTeamNumber() == TEAM_CT)
+		{
+			// we know exactly where the hostages are, and if they are alive
+			if (!m_hostage[i].hostage || !m_hostage[i].hostage->IsValid())
+				continue;
+
+			if (m_hostage[i].hostage->IsFollowingSomeone())
+				continue;
+
+			hostagePos = m_hostage[i].hostage->GetAbsOrigin();
+		}
+		else
+		{
+			// use our memory of where we think the hostages are
+			if (m_hostage[i].isValid == false)
+				continue;
+
+			hostagePos = m_hostage[i].knownPos;
+		}
+
+		CNavArea *hostageArea = TheNavMesh->GetNearestNavArea( hostagePos );
+		if (hostageArea)
+		{
+			ShortestPathCost cost;
+			float travelDistance = NavAreaTravelDistance( startArea, hostageArea, cost );
+
+			if (travelDistance >= 0.0f && travelDistance < closeDistance)
+			{
+				closeDistance = travelDistance;
+				closePos = hostagePos; 
+				close = hostage;
+			}
+		}
+	}
+
+	// return where we think the hostage is
+	if (knowPos && close)
+		*knowPos = closePos;
+
+	return close;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the location of a "free" hostage, or NULL if we dont know of any
+ */
+const Vector *CSGameState::GetRandomFreeHostagePosition( void ) const
+{
+	if (m_owner == NULL)
+		return NULL;
+
+	static Vector freePos[ MAX_HOSTAGES ];
+	int freeCount = 0;
+	
+	for( int i=0; i<m_hostageCount; ++i )
+	{
+		const HostageInfo *info = &m_hostage[i];
+
+		if (m_owner->GetTeamNumber() == TEAM_CT)
+		{
+			// we know exactly where the hostages are, and if they are alive
+			if (!info->hostage || !info->hostage->IsAlive())
+				continue;
+
+			// escorted hostages are not "free"
+			if (info->hostage->IsFollowingSomeone())
+				continue;
+
+			freePos[ freeCount++ ] = info->hostage->GetAbsOrigin();
+		}
+		else
+		{
+			// use our memory of where we think the hostages are
+			if (info->isValid == false)
+				continue;
+
+			freePos[ freeCount++ ] = info->knownPos;
+		}
+	}
+
+	if (freeCount)
+	{
+		return &freePos[ RandomInt( 0, freeCount-1 ) ];
+	}
+
+	return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * If we can see any of the positions where we think a hostage is, validate it
+ * Return status of any changes (a hostage died or was moved)
+ */
+unsigned char CSGameState::ValidateHostagePositions( void )
+{
+	// limit how often we validate
+	if (!m_validateInterval.IsElapsed())
+		return NO_CHANGE;
+
+	const float validateInterval = 0.5f;
+	m_validateInterval.Start( validateInterval );
+
+
+	// check the status of hostages
+	unsigned char status = NO_CHANGE;
+
+	int i;
+	int startValidCount = 0;
+	for( i=0; i<m_hostageCount; ++i )
+		if (m_hostage[i].isValid)
+			++startValidCount;
+
+	for( i=0; i<m_hostageCount; ++i )
+	{
+		HostageInfo *info = &m_hostage[i];
+
+		if  (!info->hostage )
+			continue;
+
+		// if we can see a hostage, update our knowledge of it
+		Vector pos = info->hostage->GetAbsOrigin() + Vector( 0, 0, HalfHumanHeight );
+		if (m_owner->IsVisible( pos, CHECK_FOV ))
+		{
+			if (info->hostage->IsAlive())
+			{
+				// live hostage
+
+				// if hostage is being escorted by a CT, we don't "see" it, we see the CT
+				if (info->hostage->IsFollowingSomeone())
+				{
+					info->isValid = false;
+				}
+				else
+				{
+					info->knownPos = info->hostage->GetAbsOrigin();
+					info->isValid = true;
+				}
+			}
+			else
+			{
+				// dead hostage
+
+				// if we thought it was alive, this is news to us
+				if (info->isAlive)
+					status |= HOSTAGE_DIED;
+
+				info->isAlive = false;
+				info->isValid = false;
+			}
+
+			continue;
+		}
+
+		// if we dont know where this hostage is, nothing to validate
+		if (!info->isValid)
+			continue;
+
+		// can't directly see this hostage
+		// check line of sight to where we think this hostage is, to see if we noticed that is has moved
+		pos = info->knownPos + Vector( 0, 0, HalfHumanHeight );
+		if (m_owner->IsVisible( pos, CHECK_FOV ))
+		{
+			// we can see where we thought the hostage was - verify it is still there and alive
+
+			if (!info->hostage->IsValid())
+			{
+				// since we have line of sight to an invalid hostage, it must be dead
+				// discovered that hostage has been killed
+				status |= HOSTAGE_DIED;
+				info->isAlive = false;
+				info->isValid = false;
+				continue;
+			}
+
+			if (info->hostage->IsFollowingSomeone())
+			{
+				// discovered the hostage has been taken
+				status |= HOSTAGE_GONE;
+				info->isValid = false;
+				continue;
+			}
+
+			const float tolerance = 50.0f;
+			if ((info->hostage->GetAbsOrigin() - info->knownPos).IsLengthGreaterThan( tolerance ))
+			{
+				// discovered that hostage has been moved
+				status |= HOSTAGE_GONE;
+				info->isValid = false;
+				continue;
+			}
+		}
+	}
+
+	int endValidCount = 0;
+	for( i=0; i<m_hostageCount; ++i )
+		if (m_hostage[i].isValid)
+			++endValidCount;
+
+	if (endValidCount == 0 && startValidCount > 0)
+	{
+		// we discovered all the hostages are gone
+		status &= ~HOSTAGE_GONE;
+		status |= HOSTAGES_ALL_GONE;
+	}
+
+	return status;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the nearest visible free hostage
+ * Since we can actually see any hostage we return, we know its actual position
+ */
+CHostage *CSGameState::GetNearestVisibleFreeHostage( void ) const
+{
+	CHostage *close = NULL;
+	float closeRangeSq = 999999999.9f;
+	float rangeSq;
+
+	Vector pos;
+	Vector myOrigin = GetCentroid( m_owner );
+
+	for( int i=0; i<m_hostageCount; ++i )
+	{
+		const HostageInfo *info = &m_hostage[i];
+
+		if ( !info->hostage )
+			continue;
+
+		// if the hostage is dead or rescued, its not free
+		if (!info->hostage->IsAlive())
+			continue;
+
+		// if this hostage is following someone, its not free
+		if (info->hostage->IsFollowingSomeone())
+			continue;
+
+		/// @todo Use travel distance here
+		pos = info->hostage->GetAbsOrigin();
+		rangeSq = (pos - myOrigin).LengthSqr();
+
+		if (rangeSq < closeRangeSq)
+		{
+			if (!m_owner->IsVisible( pos ))
+				continue;
+
+			close = info->hostage;
+			closeRangeSq = rangeSq;
+		}
+	}
+
+	return close;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if there are no free hostages
+ */
+bool CSGameState::AreAllHostagesBeingRescued( void ) const
+{
+	// if the hostages have all been rescued, they are not being rescued any longer
+	if (m_allHostagesRescued)
+		return false;
+
+	bool isAllDead = true;
+
+	for( int i=0; i<m_hostageCount; ++i )
+	{
+		const HostageInfo *info = &m_hostage[i];
+
+		if (m_owner->GetTeamNumber() == TEAM_CT)
+		{
+			// CT's have perfect knowledge via their radar
+			if (info->hostage && info->hostage->IsValid())
+			{
+				if (!info->hostage->IsFollowingSomeone())
+					return false;
+
+				isAllDead = false;
+			}
+		}
+		else
+		{
+			if (info->isValid && info->isAlive)
+				return false;
+
+			if (info->isAlive)
+				isAllDead = false;
+		}
+	}	
+
+	// if all of the remaining hostages are dead, they arent being rescued
+	if (isAllDead)
+		return false;
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * All hostages have been rescued or are dead
+ */
+bool CSGameState::AreAllHostagesGone( void ) const
+{
+	if (m_allHostagesRescued)
+		return true;
+
+	// do we know that all the hostages are dead
+	for( int i=0; i<m_hostageCount; ++i )
+	{
+		const HostageInfo *info = &m_hostage[i];
+
+		if (m_owner->GetTeamNumber() == TEAM_CT)
+		{
+			// CT's have perfect knowledge via their radar
+			if (info->hostage && info->hostage->IsAlive())
+				return false;
+		}
+		else
+		{
+			if (info->isValid && info->isAlive)
+				return false;
+		}
+	}	
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Someone told us all the hostages are gone
+ */
+void CSGameState::AllHostagesGone( void )
+{
+	for( int i=0; i<m_hostageCount; ++i )
+		m_hostage[i].isValid = false;
+}
+
diff --git a/game/server/cstrike/bot/cs_gamestate.h b/game/server/cstrike/bot/cs_gamestate.h
new file mode 100644
index 00000000..79bb8d27
--- /dev/null
+++ b/game/server/cstrike/bot/cs_gamestate.h
@@ -0,0 +1,151 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#ifndef _GAME_STATE_H_
+#define _GAME_STATE_H_
+
+
+#include "bot_util.h"
+
+
+class CHostage;
+class CCSBot;
+
+/**
+ * This class represents the game state as known by a particular bot
+ */
+class CSGameState
+{
+public:
+	CSGameState( CCSBot *owner );
+
+	void Reset( void );
+
+	// Event handling
+	void OnHostageRescuedAll( IGameEvent *event );
+	void OnRoundEnd( IGameEvent *event );
+	void OnRoundStart( IGameEvent *event );
+	void OnBombPlanted( IGameEvent *event );
+	void OnBombDefused( IGameEvent *event );
+	void OnBombExploded( IGameEvent *event );
+
+	bool IsRoundOver( void ) const;								///< true if round has been won or lost (but not yet reset)
+
+	// bomb defuse scenario -----------------------------------------------------------------------------
+
+	enum BombState
+	{
+		MOVING,					///< being carried by a Terrorist
+		LOOSE,					///< loose on the ground somewhere
+		PLANTED,				///< planted and ticking
+		DEFUSED,				///< the bomb has been defused
+		EXPLODED				///< the bomb has exploded
+	};
+
+	bool IsBombMoving( void ) const						{ return (m_bombState == MOVING); }
+	bool IsBombLoose( void ) const						{ return (m_bombState == LOOSE); }
+	bool IsBombPlanted( void ) const					{ return (m_bombState == PLANTED); }
+	bool IsBombDefused( void ) const					{ return (m_bombState == DEFUSED); }
+	bool IsBombExploded( void ) const					{ return (m_bombState == EXPLODED); }
+
+	void UpdateLooseBomb( const Vector &pos );					///< we see the loose bomb
+	float TimeSinceLastSawLooseBomb( void ) const;				///< how long has is been since we saw the loose bomb
+	bool IsLooseBombLocationKnown( void ) const;				///< do we know where the loose bomb is
+
+	void UpdateBomber( const Vector &pos );						///< we see the bomber
+	float TimeSinceLastSawBomber( void ) const;					///< how long has is been since we saw the bomber
+
+	void UpdatePlantedBomb( const Vector &pos );				///< we see the planted bomb
+	bool IsPlantedBombLocationKnown( void ) const;				///< do we know where the bomb was planted
+	void MarkBombsiteAsPlanted( int zoneIndex );				///< mark bombsite as the location of the planted bomb
+
+	enum { UNKNOWN = -1 };
+	int GetPlantedBombsite( void ) const;						///< return the zone index of the planted bombsite, or UNKNOWN
+	bool IsAtPlantedBombsite( void ) const;						///< return true if we are currently in the bombsite where the bomb is planted
+
+	int GetNextBombsiteToSearch( void );						///< return the zone index of the next bombsite to search
+	bool IsBombsiteClear( int zoneIndex ) const;				///< return true if given bombsite has been cleared
+	void ClearBombsite( int zoneIndex );						///< mark bombsite as clear
+
+	const Vector *GetBombPosition( void ) const;				///< return where we think the bomb is, or NULL if we don't know
+	
+	// hostage rescue scenario ------------------------------------------------------------------------
+	CHostage *GetNearestFreeHostage( Vector *knowPos = NULL ) const;	///< return the closest free hostage, and where we think it is (knowPos)
+	const Vector *GetRandomFreeHostagePosition( void ) const;
+	bool AreAllHostagesBeingRescued( void ) const;				///< return true if there are no free hostages
+	bool AreAllHostagesGone( void ) const;						///< all hostages have been rescued or are dead
+	void AllHostagesGone( void );								///< someone told us all the hostages are gone
+	bool HaveSomeHostagesBeenTaken( void ) const				///< return true if one or more hostages have been moved by the CT's
+	{
+		return m_haveSomeHostagesBeenTaken;
+	}
+	void HostageWasTaken( void )								///< someone told us a CT is talking to a hostage
+	{
+		m_haveSomeHostagesBeenTaken = true;
+	}
+
+	CHostage *GetNearestVisibleFreeHostage( void ) const;
+
+	enum ValidateStatusType
+	{ 
+		NO_CHANGE = 0x00,
+		HOSTAGE_DIED = 0x01,
+		HOSTAGE_GONE = 0x02,
+		HOSTAGES_ALL_GONE = 0x04
+	};
+	unsigned char ValidateHostagePositions( void );				///< update our knowledge with what we currently see - returns bitflag events
+
+private:
+	CCSBot *m_owner;											///< who owns this gamestate
+
+	bool m_isRoundOver;											///< true if round is over, but no yet reset
+
+	// bomb defuse scenario ---------------------------------------------------------------------------
+	void SetBombState( BombState state );
+	BombState GetBombState( void ) const			{ return m_bombState; }
+
+	BombState m_bombState;										///< what we think the bomb is doing
+
+	IntervalTimer m_lastSawBomber;
+	Vector m_bomberPos;
+
+	IntervalTimer m_lastSawLooseBomb;
+	Vector m_looseBombPos;
+
+	bool m_isBombsiteClear[ CCSBotManager::MAX_ZONES ];			///< corresponds to zone indices in CCSBotManager
+	int m_bombsiteSearchOrder[ CCSBotManager::MAX_ZONES ];		///< randomized order of bombsites to search
+	int m_bombsiteCount;
+	int m_bombsiteSearchIndex;									///< the next step in the search
+
+	int m_plantedBombsite;										///< zone index of the bombsite where the planted bomb is
+	
+	bool m_isPlantedBombPosKnown;								///< if true, we know the exact location of the bomb
+	Vector m_plantedBombPos;
+
+	// hostage rescue scenario ------------------------------------------------------------------------
+	struct HostageInfo
+	{
+		CHandle<CHostage> hostage;
+		Vector knownPos;
+		bool isValid;
+		bool isAlive;
+		bool isFree;		///< not being escorted by a CT
+	}
+	m_hostage[ MAX_HOSTAGES ];
+	int m_hostageCount;											///< number of hostages left in map
+	CountdownTimer m_validateInterval;
+
+	CBaseEntity *GetNearestHostage( void ) const;				///< return the closest live hostage
+	void InitializeHostageInfo( void );							///< initialize our knowledge of the number and location of hostages
+
+	bool m_allHostagesRescued;
+	bool m_haveSomeHostagesBeenTaken;							///< true if a hostage has been moved by a CT (and we've seen it)
+};
+
+#endif // _GAME_STATE_
diff --git a/game/server/cstrike/bot/states/cs_bot_attack.cpp b/game/server/cstrike/bot/states/cs_bot_attack.cpp
new file mode 100644
index 00000000..1f44b6cd
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_attack.cpp
@@ -0,0 +1,710 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Begin attacking
+ */
+void AttackState::OnEnter( CCSBot *me )
+{
+	CBasePlayer *enemy = me->GetBotEnemy();
+
+	// store our posture when the attack began
+	me->PushPostureContext();
+
+	me->DestroyPath();
+
+	// if we are using a knife, try to sneak up on the enemy
+	if (enemy && me->IsUsingKnife() && !me->IsPlayerFacingMe( enemy ))
+		me->Walk();
+	else
+		me->Run();
+
+	me->GetOffLadder();
+	me->ResetStuckMonitor();
+
+	m_repathTimer.Invalidate();
+	m_haveSeenEnemy = me->IsEnemyVisible();
+	m_nextDodgeStateTimestamp = 0.0f;
+	m_firstDodge = true;
+	m_isEnemyHidden = false;
+	m_reacquireTimestamp = 0.0f;
+
+	m_pinnedDownTimestamp = gpGlobals->curtime + RandomFloat( 7.0f, 10.0f );
+
+	m_shieldToggleTimestamp = gpGlobals->curtime + RandomFloat( 2.0f, 10.0f );
+	m_shieldForceOpen = false;
+
+	// if we encountered someone while escaping, grab our weapon and fight!
+	if (me->IsEscapingFromBomb())
+		me->EquipBestWeapon();
+
+	if (me->IsUsingKnife())
+	{
+		// can't crouch and hold with a knife
+		m_crouchAndHold = false;
+		me->StandUp();
+	}
+	else if (me->CanSeeSniper() && !me->IsSniper())
+	{
+		// don't sit still if we see a sniper!
+		m_crouchAndHold = false;
+		me->StandUp();
+	}
+	else
+	{
+		// decide whether to crouch where we are, or run and gun (if we havent already - see CCSBot::Attack())
+		if (!m_crouchAndHold)
+		{
+			if (enemy)
+			{
+				const float crouchFarRange = 750.0f;
+				float crouchChance;
+				
+				// more likely to crouch if using sniper rifle or if enemy is far away
+				if (me->IsUsingSniperRifle())
+					crouchChance = 50.0f;
+				else if ((GetCentroid( me ) - GetCentroid( enemy )).IsLengthGreaterThan( crouchFarRange ))
+					crouchChance = 50.0f;
+				else
+					crouchChance = 20.0f * (1.0f - me->GetProfile()->GetAggression());
+
+				if (RandomFloat( 0.0f, 100.0f ) < crouchChance)
+				{
+					// make sure we can still see if we crouch
+					trace_t result;
+
+					Vector origin = GetCentroid( me );
+					if (!me->IsCrouching())
+					{
+						// we are standing, adjust for lower crouch origin
+						origin.z -= 20.0f;
+					}
+
+					UTIL_TraceLine( origin, enemy->EyePosition(), MASK_PLAYERSOLID, me, COLLISION_GROUP_NONE, &result );
+
+					if (result.fraction == 1.0f)
+					{
+						m_crouchAndHold = true;
+					}
+				}
+			}
+		}
+
+		if (m_crouchAndHold)
+		{
+			me->Crouch();
+			me->PrintIfWatched( "Crouch and hold attack!\n" ); 
+		}
+	}
+
+	m_scopeTimestamp = 0;
+	m_didAmbushCheck = false;
+
+	float skill = me->GetProfile()->GetSkill();
+
+	// tendency to dodge is proportional to skill
+	float dodgeChance = 80.0f * skill;
+
+	// high skill bots always dodge if outnumbered, or they see a sniper
+	if (skill > 0.5f && (me->IsOutnumbered() || me->CanSeeSniper()))
+	{
+		dodgeChance = 100.0f;
+	}
+
+	m_shouldDodge = (RandomFloat( 0, 100 ) <= dodgeChance);
+
+
+	// decide whether we might bail out of this fight
+	m_isCoward = (RandomFloat( 0, 100 ) > 100.0f * me->GetProfile()->GetAggression());
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * When we are done attacking, this is invoked
+ */
+void AttackState::StopAttacking( CCSBot *me )
+{
+	if (me->GetTask() == CCSBot::SNIPING)
+	{
+		// stay in our hiding spot
+		me->Hide( me->GetLastKnownArea(), -1.0f, 50.0f );
+	}
+	else
+	{
+		me->StopAttacking();
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Do dodge behavior
+ */
+void AttackState::Dodge( CCSBot *me )
+{
+	//
+	// Dodge.
+	// If sniping or crouching, stand still.
+	//
+	if (m_shouldDodge && !me->IsUsingSniperRifle() && !m_crouchAndHold)
+	{
+		CBasePlayer *enemy = me->GetBotEnemy();
+		if (enemy == NULL)
+		{
+			return;
+		}
+
+		Vector toEnemy = enemy->GetAbsOrigin() - me->GetAbsOrigin();
+		float range = toEnemy.Length();
+
+		const float hysterisRange = 125.0f;		// (+/-) m_combatRange
+
+		float minRange = me->GetCombatRange() - hysterisRange;
+		float maxRange = me->GetCombatRange() + hysterisRange;
+
+		if (me->IsUsingKnife())
+		{
+			// dodge when far away if armed only with a knife
+			maxRange = 999999.9f;
+		}
+
+		// move towards (or away from) enemy if we are using a knife, behind a corner, or we aren't very skilled
+		if (me->GetProfile()->GetSkill() < 0.66f || !me->IsEnemyVisible())
+		{
+			if (range > maxRange)
+				me->MoveForward();
+			else if (range < minRange)
+				me->MoveBackward();
+		}
+
+		// don't dodge if enemy is facing away
+		const float dodgeRange = 2000.0f;
+		if (!me->CanSeeSniper() && (range > dodgeRange || !me->IsPlayerFacingMe( enemy )))
+		{
+			m_dodgeState = STEADY_ON;
+			m_nextDodgeStateTimestamp = 0.0f;
+		}
+		else if (gpGlobals->curtime >= m_nextDodgeStateTimestamp)
+		{
+			int next;
+
+			// high-skill bots keep moving and don't jump if they see a sniper
+			if (me->GetProfile()->GetSkill() > 0.5f && me->CanSeeSniper())
+			{
+				// juke back and forth
+				if (m_firstDodge)
+				{
+					next = (RandomInt( 0, 100 ) < 50) ? SLIDE_RIGHT : SLIDE_LEFT;
+				}
+				else
+				{
+					next = (m_dodgeState == SLIDE_LEFT) ? SLIDE_RIGHT : SLIDE_LEFT;
+				}
+			}
+			else
+			{
+				// select next dodge state that is different that our current one
+				do
+				{
+					// low-skill bots may jump when first engaging the enemy (if they are moving)
+					const float jumpChance = 33.3f;
+					if (m_firstDodge && me->GetProfile()->GetSkill() < 0.5f && RandomFloat( 0, 100 ) < jumpChance && !me->IsNotMoving())
+						next = RandomInt( 0, NUM_ATTACK_STATES-1 );
+					else
+						next = RandomInt( 0, NUM_ATTACK_STATES-2 );
+				}
+				while( !m_firstDodge && next == m_dodgeState );
+			}
+
+			m_dodgeState = (DodgeStateType)next;
+			m_nextDodgeStateTimestamp = gpGlobals->curtime + RandomFloat( 0.3f, 1.0f );
+			m_firstDodge = false;
+		}
+
+
+		Vector forward, right;
+		me->EyeVectors( &forward, &right );
+
+		const float lookAheadRange = 30.0f;
+		float ground;
+
+		switch( m_dodgeState )
+		{
+			case STEADY_ON:
+			{
+				break;
+			}
+
+			case SLIDE_LEFT:
+			{
+				// don't move left if we will fall
+				Vector pos = me->GetAbsOrigin() - (lookAheadRange * right);
+
+				if (me->GetSimpleGroundHeightWithFloor( pos, &ground ))
+				{
+					if (me->GetAbsOrigin().z - ground < StepHeight)
+					{
+						me->StrafeLeft();
+					}
+				}
+				break;
+			}
+
+			case SLIDE_RIGHT:
+			{
+				// don't move left if we will fall
+				Vector pos = me->GetAbsOrigin() + (lookAheadRange * right);
+
+				if (me->GetSimpleGroundHeightWithFloor( pos, &ground ))
+				{
+					if (me->GetAbsOrigin().z - ground < StepHeight)
+					{
+						me->StrafeRight();
+					}
+				}
+				break;
+			}
+
+			case JUMP:
+			{
+				if (me->m_isEnemyVisible)
+				{
+					me->Jump();
+				}
+				break;
+			}
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Perform attack behavior
+ */
+void AttackState::OnUpdate( CCSBot *me )
+{
+	// can't be stuck while attacking
+	me->ResetStuckMonitor();
+
+	// if we somehow ended up with the C4 or a grenade in our hands, grab our weapon!
+	CWeaponCSBase *weapon = me->GetActiveCSWeapon();
+	if (weapon)
+	{
+		if (weapon->GetWeaponID() == WEAPON_C4 || 
+			weapon->GetWeaponID() == WEAPON_HEGRENADE || 
+			weapon->GetWeaponID() == WEAPON_FLASHBANG ||
+			weapon->GetWeaponID() == WEAPON_SMOKEGRENADE)
+		{
+			me->EquipBestWeapon();
+		}
+	}
+
+	CBasePlayer *enemy = me->GetBotEnemy();
+	if (enemy == NULL)
+	{
+		StopAttacking( me );
+		return;
+	}
+
+	Vector myOrigin = GetCentroid( me );
+	Vector enemyOrigin = GetCentroid( enemy );
+
+	// keep track of whether we have seen our enemy at least once yet
+	if (!m_haveSeenEnemy)
+		m_haveSeenEnemy = me->IsEnemyVisible();
+
+
+	//
+	// Retreat check
+	// Do not retreat if the enemy is too close
+	//
+	if (m_retreatTimer.IsElapsed())
+	{
+		// If we've been fighting this battle for awhile, we're "pinned down" and
+		// need to do something else.
+		// If we are outnumbered, retreat.
+		// If we see a sniper and we aren't a sniper, retreat.
+
+		bool isPinnedDown = (gpGlobals->curtime > m_pinnedDownTimestamp);
+
+		if (isPinnedDown || 
+			(me->CanSeeSniper() && !me->IsSniper()) ||
+			(me->IsOutnumbered() && m_isCoward) || 
+			(me->OutnumberedCount() >= 2 && me->GetProfile()->GetAggression() < 1.0f))
+		{
+			// only retreat if at least one of them is aiming at me
+			if (me->IsAnyVisibleEnemyLookingAtMe( CHECK_FOV ))
+			{
+				// tell our teammates our plight
+				if (isPinnedDown)
+					me->GetChatter()->PinnedDown();
+				else if (!me->CanSeeSniper())
+					me->GetChatter()->Scared();
+
+				m_retreatTimer.Start( RandomFloat( 3.0f, 15.0f ) );
+
+				// try to retreat
+				if (me->TryToRetreat())
+				{
+					// if we are a sniper, equip our pistol so we can fire while retreating
+					/*
+					if (me->IsUsingSniperRifle())
+					{
+						// wait a moment to allow one last shot
+						me->Wait( 0.5f );
+						//me->EquipPistol();
+					}
+					*/
+
+					// request backup if outnumbered
+					if (me->IsOutnumbered())
+					{
+						me->GetChatter()->NeedBackup();
+					}
+				}
+				else	
+				{
+					me->PrintIfWatched( "I want to retreat, but no safe spots nearby!\n" );
+				}
+			}
+		}
+	}
+
+	//
+	// Knife fighting
+	// We need to pathfind right to the enemy to cut him
+	//
+	if (me->IsUsingKnife())
+	{
+		// can't crouch and hold with a knife
+		m_crouchAndHold = false;
+		me->StandUp();
+
+		// if we are using a knife and our prey is looking towards us, run at him
+		if (me->IsPlayerFacingMe( enemy ))
+		{
+			me->ForceRun( 5.0f );
+			me->Hurry( 10.0f );
+		}
+
+		// slash our victim
+		me->FireWeaponAtEnemy();
+
+		// if toe to toe with our enemy, don't dodge, just slash
+		const float slashRange = 70.0f;
+		if ((enemy->GetAbsOrigin() - me->GetAbsOrigin()).IsLengthGreaterThan( slashRange ))
+		{
+			const float repathInterval = 0.5f;
+
+			// if our victim has moved, repath
+			bool repath = false;
+			if (me->HasPath())
+			{
+				const float repathRange = 100.0f;		// 50
+				if ((me->GetPathEndpoint() - enemy->GetAbsOrigin()).IsLengthGreaterThan( repathRange ))
+				{
+					repath = true;
+				}
+			}
+			else
+			{
+				repath = true;
+			}
+
+			if (repath && m_repathTimer.IsElapsed())
+			{
+				Vector enemyPos = enemy->GetAbsOrigin() + Vector( 0, 0, HalfHumanHeight );
+				me->ComputePath( enemyPos, FASTEST_ROUTE );
+				m_repathTimer.Start( repathInterval );
+			}
+
+			// move towards victim
+			if (me->UpdatePathMovement( NO_SPEED_CHANGE ) != CCSBot::PROGRESSING)
+			{
+				me->DestroyPath();
+			}
+		}
+
+		return;
+	}
+
+
+
+	//
+	// Simple shield usage
+	//
+	if (me->HasShield())
+	{
+		if (me->IsEnemyVisible() && !m_shieldForceOpen)
+		{
+			if (!me->IsRecognizedEnemyReloading() && !me->IsReloading() && me->IsPlayerLookingAtMe( enemy ))
+			{
+				// close up - enemy is pointing his gun at us
+				if (!me->IsProtectedByShield())
+					me->SecondaryAttack();
+			}
+			else
+			{
+				// enemy looking away or reloading his weapon - open up and shoot him
+				if (me->IsProtectedByShield())
+					me->SecondaryAttack();
+			}
+		}
+		else
+		{
+			// can't see enemy, open up
+			if (me->IsProtectedByShield())
+				me->SecondaryAttack();
+		}
+
+		if (gpGlobals->curtime > m_shieldToggleTimestamp)
+		{
+			m_shieldToggleTimestamp = gpGlobals->curtime + RandomFloat( 0.5, 2.0f );
+
+			// toggle shield force open
+			m_shieldForceOpen = !m_shieldForceOpen;
+		}
+	}
+
+
+	// check if our weapon range is bad and we should switch to pistol
+	if (me->IsUsingSniperRifle())
+	{
+		// if we have a sniper rifle and our enemy is too close, switch to pistol
+		const float sniperMinRange = 160.0f;	// NOTE: Must be larger than NO_ZOOM range in AdjustZoom()
+		if ((enemyOrigin - myOrigin).IsLengthLessThan( sniperMinRange ))
+			me->EquipPistol();
+	}
+	else if (me->IsUsingShotgun())
+	{
+		// if we have a shotgun equipped and enemy is too far away, switch to pistol
+		const float shotgunMaxRange = 600.0f;
+		if ((enemyOrigin - myOrigin).IsLengthGreaterThan( shotgunMaxRange ))
+			me->EquipPistol();
+	}
+
+	// if we're sniping, look through the scope - need to do this here in case a reload resets our scope
+	if (me->IsUsingSniperRifle())
+	{
+		// for Scouts and AWPs, we need to wait for zoom to resume
+		if (me->m_bResumeZoom)
+		{
+			m_scopeTimestamp = gpGlobals->curtime;
+			return;
+		}
+
+		Vector toAimSpot3D = me->m_aimSpot - myOrigin;
+		float targetRange = toAimSpot3D.Length();
+
+		// dont adjust zoom level if we're already zoomed in - just fire
+		if (me->GetZoomLevel() == CCSBot::NO_ZOOM && me->AdjustZoom( targetRange ))
+			m_scopeTimestamp = gpGlobals->curtime;
+	
+		const float waitScopeTime = 0.3f + me->GetProfile()->GetReactionTime();
+		if (gpGlobals->curtime - m_scopeTimestamp < waitScopeTime)
+		{
+			// force us to wait until zoomed in before firing
+			return;
+		}
+	}
+
+	// see if we "notice" that our prey is dead
+	if (me->IsAwareOfEnemyDeath())
+	{
+		// let team know if we killed the last enemy
+		if (me->GetLastVictimID() == enemy->entindex() && me->GetNearbyEnemyCount() <= 1)
+		{
+			me->GetChatter()->KilledMyEnemy( enemy->entindex() );
+
+			// if there are other enemies left, wait a moment - they usually come in groups
+			if (me->GetEnemiesRemaining())
+			{
+				me->Wait( RandomFloat( 1.0f, 3.0f ) );
+			}
+		}
+
+		StopAttacking( me );
+		return;
+	}
+
+	float notSeenEnemyTime = gpGlobals->curtime - me->GetLastSawEnemyTimestamp();
+
+	// if we haven't seen our enemy for a moment, continue on if we dont want to fight, or decide to ambush if we do
+	if (!me->IsEnemyVisible())
+	{
+		// attend to nearby enemy gunfire
+		if (notSeenEnemyTime > 0.5f && me->CanHearNearbyEnemyGunfire())
+		{
+			// give up the attack, since we didn't want it in the first place
+			StopAttacking( me );
+
+			const Vector *pos = me->GetNoisePosition();
+			if (pos)
+			{
+				me->SetLookAt( "Nearby enemy gunfire", *pos, PRIORITY_HIGH, 0.0f );
+				me->PrintIfWatched( "Checking nearby threatening enemy gunfire!\n" );
+				return;
+			}
+		}
+
+		// check if we have lost track of our enemy during combat
+		if (notSeenEnemyTime > 0.25f)
+		{
+			m_isEnemyHidden = true;
+		}
+					
+
+		if (notSeenEnemyTime > 0.1f)
+		{
+			if (me->GetDisposition() == CCSBot::ENGAGE_AND_INVESTIGATE)
+			{
+				// decide whether we should hide and "ambush" our enemy
+				if (m_haveSeenEnemy && !m_didAmbushCheck)
+				{
+					float hideChance = 33.3f;
+
+					if (RandomFloat( 0.0, 100.0f ) < hideChance)
+					{
+						float ambushTime = RandomFloat( 3.0f, 15.0f );
+
+						// hide in ambush nearby
+						/// @todo look towards where we know enemy is
+						const Vector *spot = FindNearbyRetreatSpot( me, 200.0f );
+						if (spot)
+						{
+							me->IgnoreEnemies( 1.0f );
+
+							me->Run();
+							me->StandUp();
+							me->Hide( *spot, ambushTime, true );
+							return;
+						}
+					}
+
+					// don't check again
+					m_didAmbushCheck = true;
+				}
+			}
+			else
+			{
+				// give up the attack, since we didn't want it in the first place
+				StopAttacking( me );
+				return;
+			}
+		}
+	}
+	else
+	{
+		// we can see the enemy again - reset our ambush check
+		m_didAmbushCheck = false;
+
+		// if the enemy is coming out of hiding, we need time to react
+		if (m_isEnemyHidden)
+		{
+			m_reacquireTimestamp = gpGlobals->curtime + me->GetProfile()->GetReactionTime();
+			m_isEnemyHidden = false;
+		}
+	}
+
+
+	// if we haven't seen our enemy for a long time, chase after them
+	float chaseTime = 2.0f + 2.0f * (1.0f - me->GetProfile()->GetAggression());
+
+	// if we are sniping, be very patient
+	if (me->IsUsingSniperRifle())
+		chaseTime += 3.0f;
+	else if (me->IsCrouching())	// if we are crouching, be a little patient
+		chaseTime += 1.0f;
+
+	// if we can't see the enemy, and have either seen him but currently lost sight of him, 
+	// or haven't yet seen him, chase after him (unless we are a sniper)
+	if (!me->IsEnemyVisible() && (notSeenEnemyTime > chaseTime || !m_haveSeenEnemy))
+	{
+		// snipers don't chase their prey - they wait for their prey to come to them
+		if (me->GetTask() == CCSBot::SNIPING)
+		{
+			StopAttacking( me );
+			return;
+		}
+		else
+		{
+			// move to last known position of enemy
+			me->SetTask( CCSBot::MOVE_TO_LAST_KNOWN_ENEMY_POSITION, enemy );
+			me->MoveTo( me->GetLastKnownEnemyPosition() );
+			return;
+		}
+	}
+
+
+	// if we can't see our enemy at the moment, and were shot by
+	// a different visible enemy, engage them instead
+	const float hurtRecentlyTime = 3.0f;
+	if (!me->IsEnemyVisible() &&
+		me->GetTimeSinceAttacked() < hurtRecentlyTime &&
+		me->GetAttacker() &&
+		me->GetAttacker() != me->GetBotEnemy())
+	{
+		// if we can see them, attack, otherwise panic
+		if (me->IsVisible( me->GetAttacker(), CHECK_FOV ))
+		{
+			me->Attack( me->GetAttacker() );
+			me->PrintIfWatched( "Switching targets to retaliate against new attacker!\n" );
+		}
+		/*
+		 * Rethink this
+		else
+		{
+			me->Panic( me->GetAttacker() );
+			me->PrintIfWatched( "Panicking from crossfire while attacking!\n" );
+		}
+		*/
+
+		return;
+	}
+
+	if (true || gpGlobals->curtime > m_reacquireTimestamp)
+		me->FireWeaponAtEnemy();
+
+
+	// do dodge behavior
+	Dodge( me );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Finish attack
+ */
+void AttackState::OnExit( CCSBot *me )
+{
+	me->PrintIfWatched( "AttackState:OnExit()\n" );
+
+	m_crouchAndHold = false;
+
+	// clear any noises we heard during battle
+	me->ForgetNoise();
+	me->ResetStuckMonitor();
+
+	// resume our original posture
+	me->PopPostureContext();
+
+	// put shield away
+	if (me->IsProtectedByShield())
+		me->SecondaryAttack();
+
+
+	//me->StopAiming();
+}
+
diff --git a/game/server/cstrike/bot/states/cs_bot_buy.cpp b/game/server/cstrike/bot/states/cs_bot_buy.cpp
new file mode 100644
index 00000000..de06e8b8
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_buy.cpp
@@ -0,0 +1,690 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//--------------------------------------------------------------------------------------------------------------
+ConVar bot_loadout( "bot_loadout", "", FCVAR_CHEAT, "bots are given these items at round start" );
+ConVar bot_randombuy( "bot_randombuy", "0", FCVAR_CHEAT, "should bots ignore their prefered weapons and just buy weapons at random?" );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  Debug command to give a named weapon
+ */
+void CCSBot::GiveWeapon( const char *weaponAlias )
+{
+	const char *translatedAlias = GetTranslatedWeaponAlias( weaponAlias );
+
+	char wpnName[128];
+	Q_snprintf( wpnName, sizeof( wpnName ), "weapon_%s", translatedAlias );
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( wpnName );
+	if ( hWpnInfo == GetInvalidWeaponInfoHandle() )
+	{
+		return;
+	}
+
+	CCSWeaponInfo *pWeaponInfo = dynamic_cast< CCSWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+	if ( !pWeaponInfo )
+	{
+		return;
+	}
+
+	if ( !Weapon_OwnsThisType( wpnName ) )
+	{
+		CBaseCombatWeapon *pWeapon = Weapon_GetSlot( pWeaponInfo->iSlot );
+		if ( pWeapon )
+		{
+			if ( pWeaponInfo->iSlot == WEAPON_SLOT_PISTOL )
+			{
+				DropPistol();
+			}
+			else if ( pWeaponInfo->iSlot == WEAPON_SLOT_RIFLE )
+			{
+				DropRifle();
+			}
+		}
+	}
+
+	GiveNamedItem( wpnName );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+static bool HasDefaultPistol( CCSBot *me )
+{
+	CWeaponCSBase *pistol = (CWeaponCSBase *)me->Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+
+	if (pistol == NULL)
+		return false;
+
+	if (me->GetTeamNumber() == TEAM_TERRORIST && pistol->IsA( WEAPON_GLOCK ))
+		return true;
+
+	if (me->GetTeamNumber() == TEAM_CT && pistol->IsA( WEAPON_USP ))
+		return true;
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Buy weapons, armor, etc.
+ */
+void BuyState::OnEnter( CCSBot *me )
+{
+	m_retries = 0;
+	m_prefRetries = 0;
+	m_prefIndex = 0;
+
+	const char *cheatWeaponString = bot_loadout.GetString();
+	if ( cheatWeaponString && *cheatWeaponString )
+	{
+		m_doneBuying = false; // we're going to be given weapons - ignore the eco limit
+	}
+	else
+	{
+		// check if we are saving money for the next round
+		if (me->m_iAccount < cv_bot_eco_limit.GetFloat())
+		{
+			me->PrintIfWatched( "Saving money for next round.\n" );
+			m_doneBuying = true;
+		}
+		else
+		{
+			m_doneBuying = false;
+		}
+	}
+
+	m_isInitialDelay = true;
+
+	// this will force us to stop holding live grenade
+	me->EquipBestWeapon( MUST_EQUIP );
+
+	m_buyDefuseKit = false;
+	m_buyShield = false;
+
+	if (me->GetTeamNumber() == TEAM_CT)
+	{
+		if (TheCSBots()->GetScenario() == CCSBotManager::SCENARIO_DEFUSE_BOMB)
+		{
+			// CT's sometimes buy defuse kits in the bomb scenario (except in career mode, where the player should defuse)
+			if (CSGameRules()->IsCareer() == false)
+			{
+				const float buyDefuseKitChance = 100.0f * (me->GetProfile()->GetSkill() + 0.2f);
+				if (RandomFloat( 0.0f, 100.0f ) < buyDefuseKitChance)
+				{
+					m_buyDefuseKit = true;
+				}
+			}
+		}
+
+		// determine if we want a tactical shield
+		if (!me->HasPrimaryWeapon() && TheCSBots()->AllowTacticalShield())
+		{
+			if (me->m_iAccount > 2500)
+			{
+				if (me->m_iAccount < 4000)
+					m_buyShield = (RandomFloat( 0, 100.0f ) < 33.3f) ? true : false;
+				else
+					m_buyShield = (RandomFloat( 0, 100.0f ) < 10.0f) ? true : false;
+			}
+		}
+	}
+
+	if (TheCSBots()->AllowGrenades())
+	{
+		m_buyGrenade = (RandomFloat( 0.0f, 100.0f ) < 33.3f) ? true : false;
+	}
+	else
+	{
+		m_buyGrenade = false;
+	}
+
+
+	m_buyPistol = false;
+	if (TheCSBots()->AllowPistols())
+	{
+		// check if we have a pistol
+		if (me->Weapon_GetSlot( WEAPON_SLOT_PISTOL ))
+		{
+			// if we have our default pistol, think about buying a different one
+			if (HasDefaultPistol( me ))
+			{
+				// if everything other than pistols is disallowed, buy a pistol
+				if (TheCSBots()->AllowShotguns() == false &&
+					TheCSBots()->AllowSubMachineGuns() == false &&
+					TheCSBots()->AllowRifles() == false &&
+					TheCSBots()->AllowMachineGuns() == false &&
+					TheCSBots()->AllowTacticalShield() == false &&
+					TheCSBots()->AllowSnipers() == false)
+				{
+					m_buyPistol = (RandomFloat( 0, 100 ) < 75.0f);
+				}
+				else if (me->m_iAccount < 1000)
+				{
+					// if we're low on cash, buy a pistol
+					m_buyPistol = (RandomFloat( 0, 100 ) < 75.0f);
+				}
+				else
+				{
+					m_buyPistol = (RandomFloat( 0, 100 ) < 33.3f);
+				}
+			}			
+		}
+		else
+		{
+			// we dont have a pistol - buy one
+			m_buyPistol = true;
+		}
+	}
+}
+
+
+enum WeaponType
+{
+	PISTOL,
+	SHOTGUN,
+	SUB_MACHINE_GUN,
+	RIFLE,
+	MACHINE_GUN,
+	SNIPER_RIFLE,
+	GRENADE,
+
+	NUM_WEAPON_TYPES
+};
+
+struct BuyInfo
+{
+	WeaponType type;
+	bool preferred;			///< more challenging bots prefer these weapons
+	const char *buyAlias;			///< the buy alias for this equipment
+};
+
+#define PRIMARY_WEAPON_BUY_COUNT 13
+#define SECONDARY_WEAPON_BUY_COUNT 3
+
+/**
+ * These tables MUST be kept in sync with the CT and T buy aliases
+ */
+
+static BuyInfo primaryWeaponBuyInfoCT[ PRIMARY_WEAPON_BUY_COUNT ] =
+{
+	{ SHOTGUN,			false, "m3" },			// WEAPON_M3
+	{ SHOTGUN,			false, "xm1014" },		// WEAPON_XM1014
+	{ SUB_MACHINE_GUN,	false, "tmp" },			// WEAPON_TMP
+	{ SUB_MACHINE_GUN,	false, "mp5navy" },			// WEAPON_MP5N
+	{ SUB_MACHINE_GUN,	false, "ump45" },		// WEAPON_UMP45
+	{ SUB_MACHINE_GUN,	false, "p90" },			// WEAPON_P90
+	{ RIFLE,			true,  "famas" },		// WEAPON_FAMAS
+	{ SNIPER_RIFLE,		false, "scout" },		// WEAPON_SCOUT
+	{ RIFLE,			true,  "m4a1" },		// WEAPON_M4A1
+	{ RIFLE,			false, "aug" },			// WEAPON_AUG
+	{ SNIPER_RIFLE,		true,  "sg550" },		// WEAPON_SG550
+	{ SNIPER_RIFLE,		true,  "awp" },			// WEAPON_AWP
+	{ MACHINE_GUN,		false, "m249" }			// WEAPON_M249
+};
+
+static BuyInfo secondaryWeaponBuyInfoCT[ SECONDARY_WEAPON_BUY_COUNT ] =
+{
+//	{ PISTOL,	false,	"glock" },
+//	{ PISTOL,	false,	"usp" },
+	{ PISTOL, true,		"p228" },
+	{ PISTOL, true,		"deagle" },
+	{ PISTOL, true,		"fn57" }
+};
+
+
+static BuyInfo primaryWeaponBuyInfoT[ PRIMARY_WEAPON_BUY_COUNT ] =
+{
+	{ SHOTGUN,			false, "m3" },			// WEAPON_M3
+	{ SHOTGUN,			false, "xm1014" },		// WEAPON_XM1014
+	{ SUB_MACHINE_GUN,	false, "mac10" },		// WEAPON_MAC10
+	{ SUB_MACHINE_GUN,	false, "mp5navy" },			// WEAPON_MP5N
+	{ SUB_MACHINE_GUN,	false, "ump45" },		// WEAPON_UMP45
+	{ SUB_MACHINE_GUN,	false, "p90" },			// WEAPON_P90
+	{ RIFLE,			true,  "galil" },		// WEAPON_GALIL
+	{ RIFLE,			true,  "ak47" },		// WEAPON_AK47
+	{ SNIPER_RIFLE,		false, "scout" },		// WEAPON_SCOUT
+	{ RIFLE,			true,  "sg552" },		// WEAPON_SG552
+	{ SNIPER_RIFLE,		true,  "awp" },			// WEAPON_AWP
+	{ SNIPER_RIFLE,		true,  "g3sg1" },		// WEAPON_G3SG1
+	{ MACHINE_GUN,		false, "m249" }			// WEAPON_M249
+};
+
+static BuyInfo secondaryWeaponBuyInfoT[ SECONDARY_WEAPON_BUY_COUNT ] =
+{
+//	{ PISTOL,	false,	"glock" },
+//	{ PISTOL,	false,	"usp" },
+	{ PISTOL, true,		"p228" },
+	{ PISTOL, true,		"deagle" },
+	{ PISTOL, true,		"elites" }
+};
+
+/**
+ * Given a weapon alias, return the kind of weapon it is
+ */
+inline WeaponType GetWeaponType( const char *alias )
+{
+	int i;
+	
+	for( i=0; i<PRIMARY_WEAPON_BUY_COUNT; ++i )
+	{
+		if (!stricmp( alias, primaryWeaponBuyInfoCT[i].buyAlias ))
+			return primaryWeaponBuyInfoCT[i].type;
+
+		if (!stricmp( alias, primaryWeaponBuyInfoT[i].buyAlias ))
+			return primaryWeaponBuyInfoT[i].type;
+	}
+
+	for( i=0; i<SECONDARY_WEAPON_BUY_COUNT; ++i )
+	{
+		if (!stricmp( alias, secondaryWeaponBuyInfoCT[i].buyAlias ))
+			return secondaryWeaponBuyInfoCT[i].type;
+
+		if (!stricmp( alias, secondaryWeaponBuyInfoT[i].buyAlias ))
+			return secondaryWeaponBuyInfoT[i].type;
+	}
+
+	return NUM_WEAPON_TYPES;
+}
+
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+void BuyState::OnUpdate( CCSBot *me )
+{
+	char cmdBuffer[256];
+
+	// wait for a Navigation Mesh
+	if (!TheNavMesh->IsLoaded())
+		return;
+
+	// apparently we cant buy things in the first few seconds, so wait a bit
+	if (m_isInitialDelay)
+	{
+		const float waitToBuyTime = 0.25f;
+		if (gpGlobals->curtime - me->GetStateTimestamp() < waitToBuyTime)
+			return;
+
+		m_isInitialDelay = false;
+	}
+
+	// if we're done buying and still in the freeze period, wait
+	if (m_doneBuying)
+	{
+		if (CSGameRules()->IsMultiplayer() && CSGameRules()->IsFreezePeriod())
+		{
+			// make sure we're locked and loaded
+			me->EquipBestWeapon( MUST_EQUIP );
+			me->Reload();
+			me->ResetStuckMonitor();
+			return;
+		}
+
+		me->Idle();
+		return;
+	}
+
+	// If we're supposed to buy a specific weapon for debugging, do so and then bail
+	const char *cheatWeaponString = bot_loadout.GetString();
+	if ( cheatWeaponString && *cheatWeaponString )
+	{
+		CUtlVector<char*, CUtlMemory<char*> > loadout;
+		Q_SplitString( cheatWeaponString, " ", loadout );
+		for ( int i=0; i<loadout.Count(); ++i )
+		{
+			const char *item = loadout[i];
+			if ( FStrEq( item, "vest" ) )
+			{
+				me->GiveNamedItem( "item_kevlar" );
+			}
+			else if ( FStrEq( item, "vesthelm" ) )
+			{
+				me->GiveNamedItem( "item_assaultsuit" );
+			}
+			else if ( FStrEq( item, "defuser" ) )
+			{
+				if ( me->GetTeamNumber() == TEAM_CT )
+				{
+					me->GiveDefuser();
+				}
+			}
+			else if ( FStrEq( item, "nvgs" ) )
+			{
+				me->m_bHasNightVision = true;
+			}
+			else if ( FStrEq( item, "primammo" ) )
+			{
+				me->AttemptToBuyAmmo( 0 );
+			}
+			else if ( FStrEq( item, "secammo" ) )
+			{
+				me->AttemptToBuyAmmo( 1 );
+			}
+			else
+			{
+				me->GiveWeapon( item );
+			}
+		}
+		m_doneBuying = true;
+		return;
+	}
+
+
+	if (!me->IsInBuyZone())
+	{
+		m_doneBuying = true;
+		CONSOLE_ECHO( "%s bot spawned outside of a buy zone (%d, %d, %d)\n",
+						(me->GetTeamNumber() == TEAM_CT) ? "CT" : "Terrorist",
+						(int)me->GetAbsOrigin().x,
+						(int)me->GetAbsOrigin().y,
+						(int)me->GetAbsOrigin().z );
+		return;
+	}
+
+	// try to buy some weapons
+	const float buyInterval = 0.02f;
+	if (gpGlobals->curtime - me->GetStateTimestamp() > buyInterval)
+	{
+		me->m_stateTimestamp = gpGlobals->curtime;
+
+		bool isPreferredAllDisallowed = true;
+
+		// try to buy our preferred weapons first
+		if (m_prefIndex < me->GetProfile()->GetWeaponPreferenceCount() && bot_randombuy.GetBool() == false )
+		{
+			// need to retry because sometimes first buy fails??
+			const int maxPrefRetries = 2;
+			if (m_prefRetries >= maxPrefRetries)
+			{
+				// try to buy next preferred weapon
+				++m_prefIndex;
+				m_prefRetries = 0;
+				return;
+			}
+
+			int weaponPreference = me->GetProfile()->GetWeaponPreference( m_prefIndex );
+
+			// don't buy it again if we still have one from last round
+			char weaponPreferenceName[32];
+			Q_snprintf( weaponPreferenceName, sizeof(weaponPreferenceName), "weapon_%s", me->GetProfile()->GetWeaponPreferenceAsString( m_prefIndex ) );
+			if( me->Weapon_OwnsThisType(weaponPreferenceName) )//Prefs and buyalias use the short version, this uses the long
+			{
+				// done with buying preferred weapon
+				m_prefIndex = 9999;
+				return;
+			}
+
+			if (me->HasShield() && weaponPreference == WEAPON_SHIELDGUN)
+			{
+				// done with buying preferred weapon
+				m_prefIndex = 9999;
+				return;
+			}
+
+			const char *buyAlias = NULL;
+
+			if (weaponPreference == WEAPON_SHIELDGUN)
+			{
+				if (TheCSBots()->AllowTacticalShield())
+					buyAlias = "shield";
+			}
+			else
+			{
+				buyAlias = WeaponIDToAlias( weaponPreference );
+				WeaponType type = GetWeaponType( buyAlias );
+				switch( type )
+				{
+					case PISTOL:
+						if (!TheCSBots()->AllowPistols())
+							buyAlias = NULL;
+						break;
+
+					case SHOTGUN:
+						if (!TheCSBots()->AllowShotguns())
+							buyAlias = NULL;
+						break;
+
+					case SUB_MACHINE_GUN:
+						if (!TheCSBots()->AllowSubMachineGuns())
+							buyAlias = NULL;
+						break;
+
+					case RIFLE:
+						if (!TheCSBots()->AllowRifles())
+							buyAlias = NULL;
+						break;
+
+					case MACHINE_GUN:
+						if (!TheCSBots()->AllowMachineGuns())
+							buyAlias = NULL;
+						break;
+
+					case SNIPER_RIFLE:
+						if (!TheCSBots()->AllowSnipers())
+							buyAlias = NULL;
+						break;
+				}
+			}
+
+			if (buyAlias)
+			{
+				Q_snprintf( cmdBuffer, 256, "buy %s\n", buyAlias );
+
+				CCommand args;
+				args.Tokenize( cmdBuffer );
+				me->ClientCommand( args );
+
+				me->PrintIfWatched( "Tried to buy preferred weapon %s.\n", buyAlias );
+				isPreferredAllDisallowed = false;
+			}
+
+			++m_prefRetries;
+
+			// bail out so we dont waste money on other equipment
+			// unless everything we prefer has been disallowed, then buy at random
+			if (isPreferredAllDisallowed == false)
+				return;
+		}
+
+		// if we have no preferred primary weapon (or everything we want is disallowed), buy at random
+		if (!me->HasPrimaryWeapon() && (isPreferredAllDisallowed || !me->GetProfile()->HasPrimaryPreference()))
+		{
+			if (m_buyShield)
+			{
+				// buy a shield
+				CCommand args;
+				args.Tokenize( "buy shield" );
+				me->ClientCommand( args );
+
+				me->PrintIfWatched( "Tried to buy a shield.\n" );
+			}
+			else 
+			{
+				// build list of allowable weapons to buy
+				BuyInfo *masterPrimary = (me->GetTeamNumber() == TEAM_TERRORIST) ? primaryWeaponBuyInfoT : primaryWeaponBuyInfoCT;
+				BuyInfo *stockPrimary[ PRIMARY_WEAPON_BUY_COUNT ];
+				int stockPrimaryCount = 0;
+
+				// dont choose sniper rifles as often
+				const float sniperRifleChance = 50.0f;
+				bool wantSniper = (RandomFloat( 0, 100 ) < sniperRifleChance) ? true : false;
+
+				if ( bot_randombuy.GetBool() )
+				{
+					wantSniper = true;
+				}
+
+				for( int i=0; i<PRIMARY_WEAPON_BUY_COUNT; ++i )
+				{
+					if ((masterPrimary[i].type == SHOTGUN && TheCSBots()->AllowShotguns()) ||
+						(masterPrimary[i].type == SUB_MACHINE_GUN && TheCSBots()->AllowSubMachineGuns()) ||
+						(masterPrimary[i].type == RIFLE && TheCSBots()->AllowRifles()) ||
+						(masterPrimary[i].type == SNIPER_RIFLE && TheCSBots()->AllowSnipers() && wantSniper) ||
+						(masterPrimary[i].type == MACHINE_GUN && TheCSBots()->AllowMachineGuns()))
+					{
+						stockPrimary[ stockPrimaryCount++ ] = &masterPrimary[i];
+					}
+				}
+ 
+				if (stockPrimaryCount)
+				{
+					// buy primary weapon if we don't have one
+					int which;
+
+					// on hard difficulty levels, bots try to buy preferred weapons on the first pass
+					if (m_retries == 0 && TheCSBots()->GetDifficultyLevel() >= BOT_HARD && bot_randombuy.GetBool() == false )
+					{
+						// count up available preferred weapons
+						int prefCount = 0;
+						for( which=0; which<stockPrimaryCount; ++which )
+							if (stockPrimary[which]->preferred)
+								++prefCount;
+
+						if (prefCount)
+						{
+							int whichPref = RandomInt( 0, prefCount-1 );
+							for( which=0; which<stockPrimaryCount; ++which )
+								if (stockPrimary[which]->preferred && whichPref-- == 0)
+									break;
+						}
+						else
+						{
+							// no preferred weapons available, just pick randomly
+							which = RandomInt( 0, stockPrimaryCount-1 );
+						}
+					}
+					else
+					{
+						which = RandomInt( 0, stockPrimaryCount-1 );
+					}
+
+					Q_snprintf( cmdBuffer, 256, "buy %s\n", stockPrimary[ which ]->buyAlias );
+
+					CCommand args;
+					args.Tokenize( cmdBuffer );
+					me->ClientCommand( args );
+
+					me->PrintIfWatched( "Tried to buy %s.\n", stockPrimary[ which ]->buyAlias );
+				}
+			}
+		}
+
+
+		//
+		// If we now have a weapon, or have tried for too long, we're done
+		//
+		if (me->HasPrimaryWeapon() || m_retries++ > 5)
+		{
+			// primary ammo
+			CCommand args;
+			if (me->HasPrimaryWeapon())
+			{
+				args.Tokenize( "buy primammo" );
+				me->ClientCommand( args );
+			}
+
+			// buy armor last, to make sure we bought a weapon first
+			args.Tokenize( "buy vesthelm" );
+			me->ClientCommand( args );
+			args.Tokenize( "buy vest" );
+			me->ClientCommand( args );
+
+			// pistols - if we have no preferred pistol, buy at random
+			if (TheCSBots()->AllowPistols() && !me->GetProfile()->HasPistolPreference())
+			{
+				if (m_buyPistol)
+				{
+					int which = RandomInt( 0, SECONDARY_WEAPON_BUY_COUNT-1 );
+					
+					const char *what = NULL;
+
+					if (me->GetTeamNumber() == TEAM_TERRORIST)
+						what = secondaryWeaponBuyInfoT[ which ].buyAlias;
+					else
+						what = secondaryWeaponBuyInfoCT[ which ].buyAlias;
+
+					Q_snprintf( cmdBuffer, 256, "buy %s\n", what );
+					args.Tokenize( cmdBuffer );
+					me->ClientCommand( args );
+
+
+					// only buy one pistol
+					m_buyPistol = false;
+				}
+
+				// make sure we have enough pistol ammo
+				args.Tokenize( "buy secammo" );
+				me->ClientCommand( args );
+			}
+
+			// buy a grenade if we wish, and we don't already have one
+			if (m_buyGrenade && !me->HasGrenade())
+			{
+				if (UTIL_IsTeamAllBots( me->GetTeamNumber() ))
+				{
+					// only allow Flashbangs if everyone on the team is a bot (dont want to blind our friendly humans)
+					float rnd = RandomFloat( 0, 100 );
+
+					if (rnd < 10)
+					{
+						args.Tokenize( "buy smokegrenade" );
+						me->ClientCommand( args );	// smoke grenade
+					}
+					else if (rnd < 35)
+					{
+						args.Tokenize( "buy flashbang" );
+						me->ClientCommand( args );	// flashbang
+					}
+					else
+					{
+						args.Tokenize( "buy hegrenade" );
+						me->ClientCommand( args );	// he grenade
+					}
+				}
+				else
+				{
+					if (RandomFloat( 0, 100 ) < 10)
+					{
+						args.Tokenize( "buy smokegrenade" );	// smoke grenade
+						me->ClientCommand( args );
+					}
+					else
+					{
+						args.Tokenize( "buy hegrenade" );	// he grenade
+						me->ClientCommand( args );
+					}
+				}
+			}
+
+			if (m_buyDefuseKit)
+			{
+				args.Tokenize( "buy defuser" );
+				me->ClientCommand( args );
+			}
+
+			m_doneBuying = true;
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void BuyState::OnExit( CCSBot *me )
+{
+	me->ResetStuckMonitor();
+	me->EquipBestWeapon();
+}
+
diff --git a/game/server/cstrike/bot/states/cs_bot_defuse_bomb.cpp b/game/server/cstrike/bot/states/cs_bot_defuse_bomb.cpp
new file mode 100644
index 00000000..3614bcb9
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_defuse_bomb.cpp
@@ -0,0 +1,82 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Begin defusing the bomb
+ */
+void DefuseBombState::OnEnter( CCSBot *me )
+{
+	me->Crouch();
+	me->SetDisposition( CCSBot::SELF_DEFENSE );
+	me->GetChatter()->Say( "DefusingBomb" );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Defuse the bomb
+ */
+void DefuseBombState::OnUpdate( CCSBot *me )
+{
+	const Vector *bombPos = me->GetGameState()->GetBombPosition();
+
+	if (bombPos == NULL)
+	{
+		me->PrintIfWatched( "In Defuse state, but don't know where the bomb is!\n" );
+		me->Idle();
+		return;
+	}
+
+	// look at the bomb
+	me->SetLookAt( "Defuse bomb", *bombPos, PRIORITY_HIGH );
+
+	// defuse...
+	me->UseEnvironment();
+
+	if (gpGlobals->curtime - me->GetStateTimestamp() > 1.0f)
+	{
+		// if we missed starting the defuse, give up
+		if (TheCSBots()->GetBombDefuser() == NULL)
+		{
+			me->PrintIfWatched( "Failed to start defuse, giving up\n" );
+			me->Idle();
+			return;
+		}
+		else if (TheCSBots()->GetBombDefuser() != me)
+		{
+			// if someone else got the defuse, give up
+			me->PrintIfWatched( "Someone else started defusing, giving up\n" );
+			me->Idle();
+			return;
+		}
+	}
+
+	// if bomb has been defused, give up
+	if (!TheCSBots()->IsBombPlanted())
+	{
+		me->Idle();
+		return;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void DefuseBombState::OnExit( CCSBot *me )
+{
+	me->StandUp();
+	me->ResetStuckMonitor();
+	me->SetTask( CCSBot::SEEK_AND_DESTROY );
+	me->SetDisposition( CCSBot::ENGAGE_AND_INVESTIGATE );
+	me->ClearLookAt();
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_escape_from_bomb.cpp b/game/server/cstrike/bot/states/cs_bot_escape_from_bomb.cpp
new file mode 100644
index 00000000..9abeb2b2
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_escape_from_bomb.cpp
@@ -0,0 +1,67 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Escape from the bomb.
+ */
+void EscapeFromBombState::OnEnter( CCSBot *me )
+{
+	me->StandUp();
+	me->Run();
+	me->DestroyPath();
+	me->EquipKnife();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Escape from the bomb.
+ */
+void EscapeFromBombState::OnUpdate( CCSBot *me )
+{
+	const Vector *bombPos = me->GetGameState()->GetBombPosition();
+
+	// if we don't know where the bomb is, we shouldn't be in this state
+	if (bombPos == NULL)
+	{
+		me->Idle();
+		return;
+	}
+
+	// grab our knife to move quickly
+	me->EquipKnife();
+
+	// look around
+	me->UpdateLookAround();
+
+	if (me->UpdatePathMovement() != CCSBot::PROGRESSING)
+	{
+		// we have no path, or reached the end of one - create a new path far away from the bomb
+		FarAwayFromPositionFunctor func( *bombPos );
+		CNavArea *goalArea = FindMinimumCostArea( me->GetLastKnownArea(), func );
+
+		// if this fails, we'll try again next time
+		me->ComputePath( goalArea->GetCenter(), FASTEST_ROUTE );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Escape from the bomb.
+ */
+void EscapeFromBombState::OnExit( CCSBot *me )
+{
+	me->EquipBestWeapon();
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_fetch_bomb.cpp b/game/server/cstrike/bot/states/cs_bot_fetch_bomb.cpp
new file mode 100644
index 00000000..6e780198
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_fetch_bomb.cpp
@@ -0,0 +1,69 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move to the bomb on the floor and pick it up
+ */
+void FetchBombState::OnEnter( CCSBot *me )
+{
+	me->DestroyPath();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move to the bomb on the floor and pick it up
+ */
+void FetchBombState::OnUpdate( CCSBot *me )
+{
+	if (me->HasC4())
+	{
+		me->PrintIfWatched( "I picked up the bomb\n" );
+		me->Idle();
+		return;
+	}
+
+
+	CBaseEntity *bomb = TheCSBots()->GetLooseBomb();
+	if (bomb)
+	{
+		if (!me->HasPath())
+		{
+			// build a path to the bomb
+			if (me->ComputePath( bomb->GetAbsOrigin() ) == false)
+			{
+				me->PrintIfWatched( "Fetch bomb pathfind failed\n" );
+
+				// go Hunt instead of Idle to prevent continuous re-pathing to inaccessible bomb
+				me->Hunt();
+				return;
+			}
+		}
+	}
+	else
+	{
+		// someone picked up the bomb
+		me->PrintIfWatched( "Someone else picked up the bomb.\n" );
+		me->Idle();
+		return;
+	}
+
+	// look around
+	me->UpdateLookAround();
+
+	if (me->UpdatePathMovement() != CCSBot::PROGRESSING)
+		me->Idle();
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_follow.cpp b/game/server/cstrike/bot/states/cs_bot_follow.cpp
new file mode 100644
index 00000000..c8d49760
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_follow.cpp
@@ -0,0 +1,366 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Follow our leader
+ */
+void FollowState::OnEnter( CCSBot *me )
+{
+	me->StandUp();
+	me->Run();
+	me->DestroyPath();
+
+	m_isStopped = false;
+	m_stoppedTimestamp = 0.0f;
+
+	// to force immediate repath
+	m_lastLeaderPos.x = -99999999.9f;
+	m_lastLeaderPos.y = -99999999.9f;
+	m_lastLeaderPos.z = -99999999.9f;
+
+	m_lastSawLeaderTime = 0;
+
+	// set re-pathing frequency
+	m_repathInterval.Invalidate();
+
+	m_isSneaking = false;
+
+	m_walkTime.Invalidate();
+	m_isAtWalkSpeed = false;
+
+	m_leaderMotionState = INVALID;
+	m_idleTimer.Start( RandomFloat( 2.0f, 5.0f ) );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine the leader's motion state by tracking his speed
+ */
+void FollowState::ComputeLeaderMotionState( float leaderSpeed )
+{
+	// walk = 130, run = 250
+	const float runWalkThreshold = 140.0f;
+	const float walkStopThreshold = 10.0f; // 120.0f;
+	LeaderMotionStateType prevState = m_leaderMotionState;
+	if (leaderSpeed > runWalkThreshold)
+	{
+		m_leaderMotionState = RUNNING;
+		m_isAtWalkSpeed = false;
+	}
+	else if (leaderSpeed > walkStopThreshold)
+	{
+		// track when began to walk
+		if (!m_isAtWalkSpeed)
+		{
+			m_walkTime.Start();
+			m_isAtWalkSpeed = true;
+		}
+
+		const float minWalkTime = 0.25f;
+		if (m_walkTime.GetElapsedTime() > minWalkTime)
+		{
+			m_leaderMotionState = WALKING;
+		}
+	}
+	else
+	{
+		m_leaderMotionState = STOPPED;
+		m_isAtWalkSpeed = false;
+	}
+
+	// track time spent in this motion state
+	if (prevState != m_leaderMotionState)
+	{
+		m_leaderMotionStateTime.Start();
+		m_waitTime = RandomFloat( 1.0f, 3.0f );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Functor to collect all areas in the forward direction of the given player within a radius
+ */
+class FollowTargetCollector
+{
+public:
+	FollowTargetCollector( CBasePlayer *player )
+	{
+		m_player = player;
+
+		Vector playerVel = player->GetAbsVelocity();
+		m_forward.x = playerVel.x;
+		m_forward.y = playerVel.y;
+		float speed = m_forward.NormalizeInPlace();
+
+		Vector playerOrigin = GetCentroid( player );
+
+		const float walkSpeed = 100.0f;
+		if (speed < walkSpeed)
+		{
+			m_cutoff.x = playerOrigin.x;
+			m_cutoff.y = playerOrigin.y;
+			m_forward.x = 0.0f;
+			m_forward.y = 0.0f;
+		}
+		else
+		{
+			const float k = 1.5f; // 2.0f;
+			float trimSpeed = MIN( speed, 200.0f );
+			m_cutoff.x = playerOrigin.x + k * trimSpeed * m_forward.x;
+			m_cutoff.y = playerOrigin.y + k * trimSpeed * m_forward.y;
+		}
+
+		m_targetAreaCount = 0;
+	}
+
+	enum { MAX_TARGET_AREAS = 128 };
+
+	bool operator() ( CNavArea *area )
+	{
+		if (m_targetAreaCount >= MAX_TARGET_AREAS)
+			return false;
+		
+		// only use two-way connections
+		if (!area->GetParent() || area->IsConnected( area->GetParent(), NUM_DIRECTIONS ))
+		{
+			if (m_forward.IsZero())
+			{
+				m_targetArea[ m_targetAreaCount++ ] = area;
+			}
+			else
+			{
+				// collect areas in the direction of the player's forward motion
+				Vector2D to( area->GetCenter().x - m_cutoff.x, area->GetCenter().y - m_cutoff.y );
+				to.NormalizeInPlace();
+
+				//if (DotProduct( to, m_forward ) > 0.7071f)
+				if ((to.x * m_forward.x + to.y * m_forward.y) > 0.7071f)
+					m_targetArea[ m_targetAreaCount++ ] = area;
+			}
+		}
+
+		return (m_targetAreaCount < MAX_TARGET_AREAS);
+	}
+
+
+	CBasePlayer *m_player;
+	Vector2D m_forward;
+	Vector2D m_cutoff;
+
+	CNavArea *m_targetArea[ MAX_TARGET_AREAS ];
+	int m_targetAreaCount;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Follow our leader
+ * @todo Clean up this nasty mess
+ */
+void FollowState::OnUpdate( CCSBot *me )
+{
+	// if we lost our leader, give up
+	if (m_leader == NULL || !m_leader->IsAlive())
+	{
+		me->Idle();
+		return;
+	}
+
+	// if we are carrying the bomb and at a bombsite, plant
+	if (me->HasC4() && me->IsAtBombsite())
+	{
+		// plant it
+		me->SetTask( CCSBot::PLANT_BOMB );
+		me->PlantBomb();
+
+		// radio to the team
+		me->GetChatter()->PlantingTheBomb( me->GetPlace() );
+
+		return;
+	}
+
+	// look around
+	me->UpdateLookAround();
+
+	// if we are moving, we are not idle
+	if (me->IsNotMoving() == false)
+		m_idleTimer.Start( RandomFloat( 2.0f, 5.0f ) );
+
+	// compute the leader's speed
+	Vector leaderVel = m_leader->GetAbsVelocity();
+	float leaderSpeed = Vector2D( leaderVel.x, leaderVel.y ).Length();
+
+	// determine our leader's movement state
+	ComputeLeaderMotionState( leaderSpeed );
+
+	// track whether we can see the leader
+	bool isLeaderVisible;
+	Vector leaderOrigin = GetCentroid( m_leader );
+	if (me->IsVisible( leaderOrigin ))
+	{
+		m_lastSawLeaderTime = gpGlobals->curtime;
+		isLeaderVisible = true;
+	}
+	else
+	{
+		isLeaderVisible = false;
+	}
+
+
+	// determine whether we should sneak or not
+	const float farAwayRange = 750.0f;
+	Vector myOrigin = GetCentroid( me );
+	if ((leaderOrigin - myOrigin).IsLengthGreaterThan( farAwayRange ))
+	{
+		// far away from leader - run to catch up
+		m_isSneaking = false;
+	}
+	else if (isLeaderVisible)
+	{
+		// if we see leader walking and we are nearby, walk
+		if (m_leaderMotionState == WALKING)
+			m_isSneaking = true;
+
+		// if we are sneaking and our leader starts running, stop sneaking
+		if (m_isSneaking && m_leaderMotionState == RUNNING)
+			m_isSneaking = false;
+	}
+
+	// if we haven't seen the leader for a long time, run
+	const float longTime = 20.0f;
+	if (gpGlobals->curtime - m_lastSawLeaderTime > longTime)
+		m_isSneaking = false;
+
+	if (m_isSneaking)
+		me->Walk();
+	else
+		me->Run();
+
+
+	bool repath = false;
+
+	// if the leader has stopped, hide nearby
+	const float nearLeaderRange = 250.0f;
+	if (!me->HasPath() && m_leaderMotionState == STOPPED && m_leaderMotionStateTime.GetElapsedTime() > m_waitTime)
+	{
+		// throttle how often this check occurs
+		m_waitTime += RandomFloat( 1.0f, 3.0f );
+
+		// the leader has stopped - if we are close to him, take up a hiding spot
+		if ((leaderOrigin - myOrigin).IsLengthLessThan( nearLeaderRange ))
+		{
+			const float hideRange = 250.0f;
+			if (me->TryToHide( NULL, -1.0f, hideRange, false, USE_NEAREST ))
+			{
+				me->ResetStuckMonitor();
+				return;
+			}
+		}
+	}
+
+	// if we have been idle for awhile, move
+	if (m_idleTimer.IsElapsed())
+	{
+		repath = true;
+
+		// always walk when we move such a short distance
+		m_isSneaking = true;
+	}
+
+	// if our leader has moved, repath (don't repath if leading is stopping)
+	if (leaderSpeed > 100.0f && m_leaderMotionState != STOPPED)
+	{
+		repath = true;
+	}
+
+	// move along our path
+	if (me->UpdatePathMovement( NO_SPEED_CHANGE ) != CCSBot::PROGRESSING)
+	{
+		me->DestroyPath();
+	}
+
+	// recompute our path if necessary	
+	if (repath && m_repathInterval.IsElapsed() && !me->IsOnLadder())
+	{
+		// recompute our path to keep us near our leader
+		m_lastLeaderPos = leaderOrigin;
+
+		me->ResetStuckMonitor();
+
+		const float runSpeed = 200.0f;
+
+		const float collectRange = (leaderSpeed > runSpeed) ? 600.0f : 400.0f;		// 400, 200
+		FollowTargetCollector collector( m_leader );
+		SearchSurroundingAreas( TheNavMesh->GetNearestNavArea( m_lastLeaderPos ), m_lastLeaderPos, collector, collectRange );
+
+		if (cv_bot_debug.GetBool())
+		{
+			for( int i=0; i<collector.m_targetAreaCount; ++i )
+				collector.m_targetArea[i]->Draw( /*255, 0, 0, 2*/ );		
+		}
+
+		// move to one of the collected areas
+		if (collector.m_targetAreaCount)
+		{
+			CNavArea *target = NULL;
+			Vector targetPos;
+
+			// if we are idle, pick a random area
+			if (m_idleTimer.IsElapsed())
+			{
+				target = collector.m_targetArea[ RandomInt( 0, collector.m_targetAreaCount-1 ) ];				
+				targetPos = target->GetCenter();
+				me->PrintIfWatched( "%4.1f: Bored. Repathing to a new nearby area\n", gpGlobals->curtime );
+			}
+			else
+			{
+				me->PrintIfWatched( "%4.1f: Repathing to stay with leader.\n", gpGlobals->curtime );
+
+				// find closest area to where we are
+				CNavArea *area;
+				float closeRangeSq = 9999999999.9f;
+				Vector close;
+
+				for( int a=0; a<collector.m_targetAreaCount; ++a )
+				{
+					area = collector.m_targetArea[a];
+
+					area->GetClosestPointOnArea( myOrigin, &close );
+
+					float rangeSq = (myOrigin - close).LengthSqr();
+					if (rangeSq < closeRangeSq)
+					{
+						target = area;
+						targetPos = close;
+						closeRangeSq = rangeSq;
+					}
+				}
+			}
+						
+			if (target == NULL || me->ComputePath( target->GetCenter(), FASTEST_ROUTE ) == false)
+				me->PrintIfWatched( "Pathfind to leader failed.\n" );
+
+			// throttle how often we repath
+			m_repathInterval.Start( 0.5f );
+
+			m_idleTimer.Reset();
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void FollowState::OnExit( CCSBot *me )
+{
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_hide.cpp b/game/server/cstrike/bot/states/cs_bot_hide.cpp
new file mode 100644
index 00000000..9afd1e84
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_hide.cpp
@@ -0,0 +1,549 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_simple_hostage.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Begin moving to a nearby hidey-hole.
+ * NOTE: Do not forget this state may include a very long "move-to" time to get to our hidey spot!
+ */
+void HideState::OnEnter( CCSBot *me )
+{
+	m_isAtSpot = false;
+	m_isLookingOutward = false;
+
+	// if duration is "infinite", set it to a reasonably long time to prevent infinite camping
+	if (m_duration < 0.0f)
+	{
+		m_duration = RandomFloat( 30.0f, 60.0f );
+	}
+
+	// decide whether to "ambush" or not - never set to false so as not to override external setting
+	if (RandomFloat( 0.0f, 100.0f ) < 50.0f)
+	{
+		m_isHoldingPosition = true;
+	}
+
+	// if we are holding position, decide for how long
+	if (m_isHoldingPosition)
+	{
+		m_holdPositionTime = RandomFloat( 3.0f, 10.0f );
+	}
+	else
+	{
+		m_holdPositionTime = 0.0f;
+	}
+
+	m_heardEnemy = false;
+	m_firstHeardEnemyTime = 0.0f;
+	m_retry = 0;
+
+	if (me->IsFollowing())
+	{
+		m_leaderAnchorPos = GetCentroid( me->GetFollowLeader() );
+	}
+
+	// if we are a sniper, we need to periodically pause while we retreat to squeeze off a shot or two
+	if (me->IsSniper())
+	{
+		// start off paused to allow a final shot before retreating
+		m_isPaused = false;
+		m_pauseTimer.Invalidate();
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move to a nearby hidey-hole.
+ * NOTE: Do not forget this state may include a very long "move-to" time to get to our hidey spot!
+ */
+void HideState::OnUpdate( CCSBot *me )
+{
+	Vector myOrigin = GetCentroid( me );
+
+	// wait until finished reloading to leave hide state
+	if (!me->IsReloading())
+	{
+		// if we are momentarily hiding while following someone, check to see if he has moved on
+		if (me->IsFollowing())
+		{
+			CCSPlayer *leader = static_cast<CCSPlayer *>( static_cast<CBaseEntity *>( me->GetFollowLeader() ) );
+			Vector leaderOrigin = GetCentroid( leader );
+
+			// BOTPORT: Determine walk/run velocity thresholds
+			float runThreshold = 200.0f;
+			if (leader->GetAbsVelocity().IsLengthGreaterThan( runThreshold ))
+			{
+				// leader is running, stay with him
+				me->Follow( leader );
+				return;			
+			}
+
+			// if leader has moved, stay with him
+			const float followRange = 250.0f;
+			if ((m_leaderAnchorPos - leaderOrigin).IsLengthGreaterThan( followRange ))
+			{
+				me->Follow( leader );
+				return;
+			}
+		}
+
+		// if we see a nearby buddy in combat, join him
+		/// @todo - Perhaps tie in to TakeDamage(), so it works for human players, too
+
+		//
+		// Scenario logic
+		//
+		switch( TheCSBots()->GetScenario() )
+		{
+			case CCSBotManager::SCENARIO_DEFUSE_BOMB:
+			{
+				if (me->GetTeamNumber() == TEAM_CT)
+				{
+					// if we are just holding position (due to a radio order) and the bomb has just planted, go defuse it
+					if (me->GetTask() == CCSBot::HOLD_POSITION && 
+						TheCSBots()->IsBombPlanted() &&
+						TheCSBots()->GetBombPlantTimestamp() > me->GetStateTimestamp())
+					{
+						me->Idle();
+						return;
+					}
+
+					// if we are guarding the defuser and he dies/gives up, stop hiding (to choose another defuser)
+					if (me->GetTask() == CCSBot::GUARD_BOMB_DEFUSER && TheCSBots()->GetBombDefuser() == NULL)
+					{
+						me->Idle();
+						return;
+					}
+
+					// if we are guarding the loose bomb and it is picked up, stop hiding
+					if (me->GetTask() == CCSBot::GUARD_LOOSE_BOMB && TheCSBots()->GetLooseBomb() == NULL)
+					{
+						me->GetChatter()->TheyPickedUpTheBomb();
+						me->Idle();
+						return;
+					}
+
+					// if we are guarding a bombsite and the bomb is dropped and we hear about it, stop guarding
+					if (me->GetTask() == CCSBot::GUARD_BOMB_ZONE && me->GetGameState()->IsLooseBombLocationKnown())
+					{
+						me->Idle();
+						return;
+					}
+
+					// if we are guarding (bombsite, initial encounter, etc) and the bomb is planted, go defuse it
+					if (me->IsDoingScenario() && me->GetTask() != CCSBot::GUARD_BOMB_DEFUSER && TheCSBots()->IsBombPlanted())
+					{
+						me->Idle();
+						return;
+					}
+
+				}
+				else	// TERRORIST
+				{
+					// if we are near the ticking bomb and someone starts defusing it, attack!
+					if (TheCSBots()->GetBombDefuser())
+					{
+						Vector defuserOrigin = GetCentroid( TheCSBots()->GetBombDefuser() );
+						Vector toDefuser = defuserOrigin - myOrigin;
+
+						const float hearDefuseRange = 2000.0f;
+						if (toDefuser.IsLengthLessThan( hearDefuseRange ))
+						{
+							// if we are nearby, attack, otherwise move to the bomb (which will cause us to attack when we see defuser)
+							if (me->CanSeePlantedBomb())
+							{
+								me->Attack( TheCSBots()->GetBombDefuser() );
+							}
+							else
+							{
+								me->MoveTo( defuserOrigin, FASTEST_ROUTE );
+								me->InhibitLookAround( 10.0f );
+							}
+
+							return;
+						}
+					}
+				}
+				break;
+			}
+
+			//--------------------------------------------------------------------------------------------------
+			case CCSBotManager::SCENARIO_RESCUE_HOSTAGES:
+			{
+				// if we're guarding the hostages and they all die or are taken, do something else
+				if (me->GetTask() == CCSBot::GUARD_HOSTAGES)
+				{
+					if (me->GetGameState()->AreAllHostagesBeingRescued() || me->GetGameState()->AreAllHostagesGone())
+					{
+						me->Idle();
+						return;
+					}
+				}
+				else if (me->GetTask() == CCSBot::GUARD_HOSTAGE_RESCUE_ZONE)
+				{
+					// if we stumble across a hostage, guard it
+					CHostage *hostage = me->GetGameState()->GetNearestVisibleFreeHostage();
+					if (hostage)
+					{
+						// we see a free hostage, guard it
+						Vector hostageOrigin = GetCentroid( hostage );
+						CNavArea *area = TheNavMesh->GetNearestNavArea( hostageOrigin );
+						if (area)
+						{
+							me->SetTask( CCSBot::GUARD_HOSTAGES );
+							me->Hide( area );
+							me->PrintIfWatched( "I'm guarding hostages I found\n" );
+							// don't chatter here - he'll tell us when he's in his hiding spot
+							return;
+						}
+					}
+				}
+			}
+		}
+
+
+		bool isSettledInSniper = (me->IsSniper() && m_isAtSpot) ? true : false;
+
+		// only investigate noises if we are initiating attacks, and we aren't a "settled in" sniper
+		// dont investigate noises if we are reloading
+		if (!me->IsReloading() && 
+			!isSettledInSniper && 
+			me->GetDisposition() == CCSBot::ENGAGE_AND_INVESTIGATE)
+		{
+			// if we are holding position, and have heard the enemy nearby, investigate after our hold time is up
+			if (m_isHoldingPosition && m_heardEnemy && (gpGlobals->curtime - m_firstHeardEnemyTime > m_holdPositionTime))
+			{
+				/// @todo We might need to remember specific location of last enemy noise here
+				me->InvestigateNoise();
+				return;
+			}
+
+			// investigate nearby enemy noises
+			if (me->HeardInterestingNoise())
+			{
+				// if we are holding position, check if enough time has elapsed since we first heard the enemy
+				if (m_isAtSpot && m_isHoldingPosition)
+				{
+					if (!m_heardEnemy)
+					{
+						// first time we heard the enemy
+						m_heardEnemy = true;
+						m_firstHeardEnemyTime = gpGlobals->curtime;
+						me->PrintIfWatched( "Heard enemy, holding position for %f2.1 seconds...\n", m_holdPositionTime );
+					}
+				}
+				else
+				{
+					// not holding position - investigate enemy noise
+					me->InvestigateNoise();
+					return;
+				}
+			}
+		}
+	}	// end reloading check
+
+	// look around
+	me->UpdateLookAround();
+
+	// if we are at our hiding spot, crouch and wait
+	if (m_isAtSpot)
+	{
+		me->ResetStuckMonitor();
+
+		CNavArea *area = TheNavMesh->GetNavArea( m_hidingSpot );
+		if ( !area || !( area->GetAttributes() & NAV_MESH_STAND ) )
+		{
+			me->Crouch();
+		}
+
+		// check if duration has expired
+		if (m_hideTimer.IsElapsed()) 
+		{
+			if (me->GetTask() == CCSBot::GUARD_LOOSE_BOMB)
+			{
+				// if we're guarding the loose bomb, continue to guard it but pick a new spot
+				me->Hide( TheCSBots()->GetLooseBombArea() );
+				return;
+			}
+			else if (me->GetTask() == CCSBot::GUARD_BOMB_ZONE)
+			{
+				// if we're guarding a bombsite, continue to guard it but pick a new spot
+				const CCSBotManager::Zone *zone = TheCSBots()->GetClosestZone( myOrigin );
+				if (zone)
+				{
+					CNavArea *area = TheCSBots()->GetRandomAreaInZone( zone );
+					if (area)
+					{
+						me->Hide( area );
+						return;
+					}
+				}
+			}
+			else if (me->GetTask() == CCSBot::GUARD_HOSTAGE_RESCUE_ZONE)
+			{
+				// if we're guarding a rescue zone, continue to guard this or another rescue zone
+				if (me->GuardRandomZone())
+				{
+					me->SetTask( CCSBot::GUARD_HOSTAGE_RESCUE_ZONE );
+					me->PrintIfWatched( "Continuing to guard hostage rescue zones\n" );
+					me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+					me->GetChatter()->GuardingHostageEscapeZone( IS_PLAN );
+					return;
+				}
+			}
+
+			me->Idle();
+			return;
+		}
+
+/*
+		// if we are watching for an approaching noisy enemy, anticipate and fire before they round the corner
+		/// @todo Need to check if we are looking at an ENEMY_NOISE here
+		const float veryCloseNoise = 250.0f;
+		if (me->IsLookingAtSpot() && me->GetNoiseRange() < veryCloseNoise)
+		{
+			// fire!
+			me->PrimaryAttack();
+			me->PrintIfWatched( "Firing at anticipated enemy coming around the corner!\n" );
+		}
+*/
+
+		// if we have a shield, hide behind it
+		if (me->HasShield() && !me->IsProtectedByShield())
+			me->SecondaryAttack();
+
+		// while sitting at our hiding spot, if we are being attacked but can't see our attacker, move somewhere else
+		const float hurtRecentlyTime = 1.0f;
+		if (!me->IsEnemyVisible() && me->GetTimeSinceAttacked() < hurtRecentlyTime)
+		{
+			me->Idle();
+			return;
+		}
+
+		// encourage the human player
+		if (!me->IsDoingScenario())
+		{
+			if (me->GetTeamNumber() == TEAM_CT)
+			{
+				if (me->GetTask() == CCSBot::GUARD_BOMB_ZONE && 
+					me->IsAtHidingSpot() && 
+					TheCSBots()->IsBombPlanted())
+				{
+					if (me->GetNearbyEnemyCount() == 0)
+					{
+						const float someTime = 30.0f;
+						const float littleTime = 11.0;
+
+						if (TheCSBots()->GetBombTimeLeft() > someTime)
+							me->GetChatter()->Encourage( "BombsiteSecure", RandomFloat( 10.0f, 15.0f ) );
+						else if (TheCSBots()->GetBombTimeLeft() > littleTime)
+							me->GetChatter()->Encourage( "WaitingForHumanToDefuseBomb", RandomFloat( 5.0f, 8.0f ) );
+						else
+							me->GetChatter()->Encourage( "WaitingForHumanToDefuseBombPanic", RandomFloat( 3.0f, 4.0f ) );
+					}
+				}
+
+				if (me->GetTask() == CCSBot::GUARD_HOSTAGES && me->IsAtHidingSpot())
+				{
+					if (me->GetNearbyEnemyCount() == 0)
+					{
+						CHostage *hostage = me->GetGameState()->GetNearestVisibleFreeHostage();
+						if (hostage)
+						{
+							me->GetChatter()->Encourage( "WaitingForHumanToRescueHostages", RandomFloat( 10.0f, 15.0f ) );
+						}
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		// we are moving to our hiding spot
+
+		// snipers periodically pause and fire while retreating
+		if (me->IsSniper() && me->IsEnemyVisible())
+		{
+			if (m_isPaused)
+			{
+				if (m_pauseTimer.IsElapsed())
+				{
+					// get moving
+					m_isPaused = false;
+					m_pauseTimer.Start( RandomFloat( 1.0f, 3.0f ) );
+				}
+				else
+				{
+					me->Wait( 0.2f );
+				}
+			}
+			else
+			{
+				if (m_pauseTimer.IsElapsed())
+				{
+					// pause for a moment
+					m_isPaused = true;
+					m_pauseTimer.Start( RandomFloat( 0.5f, 1.5f ) );
+				}
+			}
+		}
+
+		// if a Player is using this hiding spot, give up
+		float range;
+		CCSPlayer *camper = static_cast<CCSPlayer *>( UTIL_GetClosestPlayer( m_hidingSpot, &range ) );
+
+		const float closeRange = 75.0f;
+		if (camper && camper != me && range < closeRange && me->IsVisible( camper, CHECK_FOV ))
+		{
+			// player is in our hiding spot
+			me->PrintIfWatched( "Someone's in my hiding spot - picking another...\n" );
+
+			const int maxRetries = 3;
+			if (m_retry++ >= maxRetries)
+			{
+				me->PrintIfWatched( "Can't find a free hiding spot, giving up.\n" );
+				me->Idle();
+				return;
+			}
+
+			// pick another hiding spot near where we were planning on hiding
+			me->Hide( TheNavMesh->GetNavArea( m_hidingSpot ) );
+
+			return;
+		}
+
+		Vector toSpot;
+		toSpot.x = m_hidingSpot.x - myOrigin.x;
+		toSpot.y = m_hidingSpot.y - myOrigin.y;
+		toSpot.z = m_hidingSpot.z - me->GetFeetZ(); // use feet location
+		range = toSpot.Length();
+
+		// look outwards as we get close to our hiding spot
+		if (!me->IsEnemyVisible() && !m_isLookingOutward)
+		{
+			const float lookOutwardRange = 200.0f;
+			const float nearSpotRange = 10.0f;
+			if (range < lookOutwardRange && range > nearSpotRange)
+			{
+				m_isLookingOutward = true;
+
+				toSpot.x /= range;
+				toSpot.y /= range;
+				toSpot.z /= range;
+
+				me->SetLookAt( "Face outward", me->EyePosition() - 1000.0f * toSpot, PRIORITY_HIGH, 3.0f );
+			}
+		}
+
+		const float atDist = 20.0f;
+		if (range < atDist)
+		{
+			//-------------------------------------
+			// Just reached our hiding spot
+			//
+			m_isAtSpot = true;
+			m_hideTimer.Start( m_duration );
+
+			// make sure our approach points are valid, since we'll be watching them
+			me->ComputeApproachPoints();
+			me->ClearLookAt();
+
+			// ready our weapon and prepare to attack
+			me->EquipBestWeapon( me->IsUsingGrenade() );
+			me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+
+			// if we are a sniper, update our task
+			if (me->GetTask() == CCSBot::MOVE_TO_SNIPER_SPOT)
+			{
+				me->SetTask( CCSBot::SNIPING );
+			}
+			else if (me->GetTask() == CCSBot::GUARD_INITIAL_ENCOUNTER)
+			{
+				const float campChatterChance = 20.0f;
+				if (RandomFloat( 0, 100 ) < campChatterChance)
+				{
+					me->GetChatter()->Say( "WaitingHere" );
+				}
+			}
+
+			
+			// determine which way to look
+			trace_t result;
+			float outAngle = 0.0f;
+			float outAngleRange = 0.0f;
+			for( float angle = 0.0f; angle < 360.0f; angle += 45.0f )
+			{
+				UTIL_TraceLine( me->EyePosition(), me->EyePosition() + 1000.0f * Vector( BotCOS(angle), BotSIN(angle), 0.0f ), MASK_PLAYERSOLID, me, COLLISION_GROUP_NONE, &result );
+
+				if (result.fraction > outAngleRange)
+				{
+					outAngle = angle;
+					outAngleRange = result.fraction;
+				}
+			}
+
+			me->SetLookAheadAngle( outAngle );
+
+		}
+
+		// move to hiding spot
+		if (me->UpdatePathMovement() != CCSBot::PROGRESSING && !m_isAtSpot)
+		{
+			// we couldn't get to our hiding spot - pick another
+			me->PrintIfWatched( "Can't get to my hiding spot - finding another...\n" );
+
+			// search from hiding spot, since we know it was valid
+			const Vector *pos = FindNearbyHidingSpot( me, m_hidingSpot, m_range, me->IsSniper() );
+			if (pos == NULL)
+			{
+				// no available hiding spots
+				me->PrintIfWatched( "No available hiding spots - hiding where I'm at.\n" );
+
+				// hide where we are
+				m_hidingSpot.x = myOrigin.x;
+				m_hidingSpot.x = myOrigin.y;
+				m_hidingSpot.z = me->GetFeetZ();
+			}
+			else
+			{
+				m_hidingSpot = *pos;
+			}
+
+			// build a path to our new hiding spot
+			if (me->ComputePath( m_hidingSpot, FASTEST_ROUTE ) == false)
+			{
+				me->PrintIfWatched( "Can't pathfind to hiding spot\n" );
+				me->Idle();
+				return;
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void HideState::OnExit( CCSBot *me )
+{
+	m_isHoldingPosition = false;
+
+	me->StandUp();
+	me->ResetStuckMonitor();
+	//me->ClearLookAt();
+	me->ClearApproachPoints();
+
+	// if we have a shield, put it away
+	if (me->HasShield() && me->IsProtectedByShield())
+		me->SecondaryAttack();
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_hunt.cpp b/game/server/cstrike/bot/states/cs_bot_hunt.cpp
new file mode 100644
index 00000000..9ca6c909
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_hunt.cpp
@@ -0,0 +1,234 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_simple_hostage.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Begin the hunt
+ */
+void HuntState::OnEnter( CCSBot *me )
+{
+	// lurking death
+	if (me->IsUsingKnife() && me->IsWellPastSafe() && !me->IsHurrying())
+		me->Walk();
+	else
+		me->Run();
+
+
+	me->StandUp();
+	me->SetDisposition( CCSBot::ENGAGE_AND_INVESTIGATE );
+	me->SetTask( CCSBot::SEEK_AND_DESTROY );
+
+	me->DestroyPath();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Hunt down our enemies
+ */
+void HuntState::OnUpdate( CCSBot *me )
+{
+	// if we've been hunting for a long time, drop into Idle for a moment to
+	// select something else to do
+	const float huntingTooLongTime = 30.0f;
+	if (gpGlobals->curtime - me->GetStateTimestamp() > huntingTooLongTime)
+	{
+		// stop being a rogue and do the scenario, since there must not be many enemies left to hunt
+		me->PrintIfWatched( "Giving up hunting.\n" );
+		me->SetRogue( false );
+		me->Idle();
+		return;
+	}
+
+	// scenario logic
+	if (TheCSBots()->GetScenario() == CCSBotManager::SCENARIO_DEFUSE_BOMB)
+	{
+		if (me->GetTeamNumber() == TEAM_TERRORIST)
+		{
+			// if we have the bomb and it's time to plant, or we happen to be in a bombsite and it seems safe, do it
+			if (me->HasC4())
+			{
+				const float safeTime = 3.0f;
+
+				if (TheCSBots()->IsTimeToPlantBomb() || 
+						(me->IsAtBombsite() && gpGlobals->curtime - me->GetLastSawEnemyTimestamp() > safeTime))
+				{
+					me->Idle();
+					return;
+				}
+			}
+
+			// if we notice the bomb lying on the ground, go get it
+			if (me->NoticeLooseBomb())
+			{
+				me->FetchBomb();
+				return;
+			}
+
+			// if bomb has been planted, and we hear it, move to a hiding spot near the bomb and watch it
+			const Vector *bombPos = me->GetGameState()->GetBombPosition();
+			if (!me->IsRogue() && me->GetGameState()->IsBombPlanted() && bombPos)
+			{
+				me->SetTask( CCSBot::GUARD_TICKING_BOMB );
+				me->Hide( TheNavMesh->GetNavArea( *bombPos ) );
+				return;
+			}
+		}
+		else		// CT
+		{
+			if (!me->IsRogue() && me->CanSeeLooseBomb())
+			{
+				// if we are near the loose bomb and can see it, hide nearby and guard it
+				me->SetTask( CCSBot::GUARD_LOOSE_BOMB );
+				me->Hide( TheCSBots()->GetLooseBombArea() );
+				me->GetChatter()->GuardingLooseBomb( TheCSBots()->GetLooseBomb() );
+				return;
+			}
+			else if (TheCSBots()->IsBombPlanted())
+			{
+				// rogues will defuse a bomb, but not guard the defuser
+				if (!me->IsRogue() || !TheCSBots()->GetBombDefuser())
+				{
+					// search for the planted bomb to defuse
+					me->Idle();
+					return;
+				}
+			}
+		}
+	}
+	else if (TheCSBots()->GetScenario() == CCSBotManager::SCENARIO_RESCUE_HOSTAGES)
+	{
+		if (me->GetTeamNumber() == TEAM_TERRORIST)
+		{
+			if (me->GetGameState()->AreAllHostagesBeingRescued())
+			{
+				// all hostages are being rescued, head them off at the escape zones
+				if (me->GuardRandomZone())
+				{
+					me->SetTask( CCSBot::GUARD_HOSTAGE_RESCUE_ZONE );
+					me->PrintIfWatched( "Trying to beat them to an escape zone!\n" );
+					me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+					me->GetChatter()->GuardingHostageEscapeZone( IS_PLAN );
+					return;
+				}
+			}
+
+			// if safe time is up, and we stumble across a hostage, guard it
+			if (!me->IsRogue() && !me->IsSafe())
+			{
+				CHostage *hostage = me->GetGameState()->GetNearestVisibleFreeHostage();
+				if (hostage)
+				{
+					CNavArea *area = TheNavMesh->GetNearestNavArea( GetCentroid( hostage ) );
+					if (area)
+					{
+						// we see a free hostage, guard it
+						me->SetTask( CCSBot::GUARD_HOSTAGES );
+						me->Hide( area );
+						me->PrintIfWatched( "I'm guarding hostages\n" );
+						me->GetChatter()->GuardingHostages( area->GetPlace(), IS_PLAN );
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	// listen for enemy noises
+	if (me->HeardInterestingNoise())
+	{
+		me->InvestigateNoise();
+		return;
+	}
+		
+	// look around
+	me->UpdateLookAround();
+
+	// if we have reached our destination area, pick a new one
+	// if our path fails, pick a new one
+	if (me->GetLastKnownArea() == m_huntArea || me->UpdatePathMovement() != CCSBot::PROGRESSING)
+	{
+		// pick a new hunt area
+		const float earlyGameTime = 45.0f;
+		if (TheCSBots()->GetElapsedRoundTime() < earlyGameTime && !me->HasVisitedEnemySpawn())
+		{
+			// in the early game, rush the enemy spawn
+			CBaseEntity *enemySpawn = TheCSBots()->GetRandomSpawn( OtherTeam( me->GetTeamNumber() ) );
+
+			//ADRIAN: REVISIT
+			if ( enemySpawn )
+			{
+				m_huntArea = TheNavMesh->GetNavArea( enemySpawn->WorldSpaceCenter() );
+			}
+		}
+		else
+		{
+			m_huntArea = NULL;
+			float oldest = 0.0f;
+
+			int areaCount = 0;
+			const float minSize = 150.0f;
+
+			FOR_EACH_VEC( TheNavAreas, it )
+			{
+				CNavArea *area = TheNavAreas[ it ];
+
+				++areaCount;
+
+				// skip the small areas
+				Extent extent;
+				area->GetExtent(&extent);
+				if (extent.hi.x - extent.lo.x < minSize || extent.hi.y - extent.lo.y < minSize)
+					continue;
+
+				// keep track of the least recently cleared area
+				float age = gpGlobals->curtime - area->GetClearedTimestamp( me->GetTeamNumber()-1 );
+				if (age > oldest)
+				{
+					oldest = age;
+					m_huntArea = area;
+				}
+			}
+
+			// if all the areas were too small, pick one at random
+			int which = RandomInt( 0, areaCount-1 );
+
+			areaCount = 0;
+			FOR_EACH_VEC( TheNavAreas, hit )
+			{
+				m_huntArea = TheNavAreas[ hit ];
+
+				if (which == areaCount)
+					break;
+
+				--which;
+			}
+		}
+
+		if (m_huntArea)
+		{
+			// create a new path to a far away area of the map
+			me->ComputePath( m_huntArea->GetCenter() );
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Done hunting
+ */
+void HuntState::OnExit( CCSBot *me )
+{
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_idle.cpp b/game/server/cstrike/bot/states/cs_bot_idle.cpp
new file mode 100644
index 00000000..64e14d24
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_idle.cpp
@@ -0,0 +1,887 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_simple_hostage.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// range for snipers to select a hiding spot
+const float sniperHideRange = 2000.0f;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * The Idle state.
+ * We never stay in the Idle state - it is a "home base" for the state machine that
+ * does various checks to determine what we should do next.
+ */
+void IdleState::OnEnter( CCSBot *me )
+{
+	me->DestroyPath();
+	me->SetBotEnemy( NULL );
+
+	// lurking death
+	if (me->IsUsingKnife() && me->IsWellPastSafe() && !me->IsHurrying())
+		me->Walk();
+
+	//
+	// Since Idle assigns tasks, we assume that coming back to Idle means our task is complete
+	//
+	me->SetTask( CCSBot::SEEK_AND_DESTROY );
+	me->SetDisposition( CCSBot::ENGAGE_AND_INVESTIGATE );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine what we should do next
+ */
+void IdleState::OnUpdate( CCSBot *me )
+{
+	// all other states assume GetLastKnownArea() is valid, ensure that it is
+	if (me->GetLastKnownArea() == NULL && me->StayOnNavMesh() == false)
+		return;
+
+	// zombies never leave the Idle state
+	if (cv_bot_zombie.GetBool())
+	{
+		me->ResetStuckMonitor();
+		return;
+	}
+
+	// if we are in the early "safe" time, grab a knife or grenade
+	if (me->IsSafe())
+	{
+		// if we have a grenade, use it
+		if (!me->EquipGrenade())
+		{
+			// high-skill bots run with the knife, unless using the Scout (which moves faster)
+			if (me->GetProfile()->GetSkill() > 0.33f && !me->IsUsing( WEAPON_SCOUT ))
+			{
+				me->EquipKnife();
+			}
+		}
+	}
+
+	// if round is over, hunt
+	if (me->GetGameState()->IsRoundOver())
+	{
+		// if we are escorting hostages, try to get to the rescue zone
+		if (me->GetHostageEscortCount())
+		{
+			const CCSBotManager::Zone *zone = TheCSBots()->GetClosestZone( me->GetLastKnownArea(), PathCost( me, FASTEST_ROUTE ) );
+			const Vector *zonePos = TheCSBots()->GetRandomPositionInZone( zone );
+
+			if (zonePos)
+			{
+				me->SetTask( CCSBot::RESCUE_HOSTAGES );
+				me->Run();
+				me->SetDisposition( CCSBot::SELF_DEFENSE );
+				me->MoveTo( *zonePos, FASTEST_ROUTE );
+				me->PrintIfWatched( "Trying to rescue hostages at the end of the round\n" );
+				return;
+			}
+		}
+
+		me->Hunt();
+		return;
+	}
+
+	const float defenseSniperCampChance = 75.0f;
+	const float offenseSniperCampChance = 10.0f;
+
+	// if we were following someone, continue following them
+	if (me->IsFollowing())
+	{
+		me->ContinueFollowing();
+		return;
+	}
+
+	//
+	// Scenario logic
+	//
+	switch (TheCSBots()->GetScenario())
+	{
+		//======================================================================================================
+		case CCSBotManager::SCENARIO_DEFUSE_BOMB:
+		{
+			// if this is a bomb game and we have the bomb, go plant it
+			if (me->GetTeamNumber() == TEAM_TERRORIST)
+			{
+				if (me->GetGameState()->IsBombPlanted())
+				{
+					if (me->GetGameState()->GetPlantedBombsite() != CSGameState::UNKNOWN)
+					{
+						// T's always know where the bomb is - go defend it
+						const CCSBotManager::Zone *zone = TheCSBots()->GetZone( me->GetGameState()->GetPlantedBombsite() );
+						if (zone)
+						{
+							me->SetTask( CCSBot::GUARD_TICKING_BOMB );
+
+							Place place = TheNavMesh->GetPlace( zone->m_center );
+							if (place != UNDEFINED_PLACE)
+							{
+								// pick a random hiding spot in this place
+								const Vector *spot = FindRandomHidingSpot( me, place, me->IsSniper() );
+								if (spot)
+								{
+									me->Hide( *spot );
+									return;
+								}
+							}
+
+							// hide nearby
+							me->Hide( TheNavMesh->GetNearestNavArea( zone->m_center ) );
+							return;
+						}
+					}
+					else
+					{
+						// ask our teammates where the bomb is
+						me->GetChatter()->RequestBombLocation();
+
+						// we dont know where the bomb is - we must search the bombsites
+						int zoneIndex = me->GetGameState()->GetNextBombsiteToSearch();
+
+						// move to bombsite - if we reach it, we'll update its cleared status, causing us to select another
+						const Vector *pos = TheCSBots()->GetRandomPositionInZone( TheCSBots()->GetZone( zoneIndex ) );
+						if (pos)
+						{
+							me->SetTask( CCSBot::FIND_TICKING_BOMB );
+							me->MoveTo( *pos );
+							return;
+						}
+					}
+				}
+				else if (me->HasC4())
+				{
+					// if we're at a bomb site, plant the bomb
+					if (me->IsAtBombsite())
+					{
+						// plant it
+						me->SetTask( CCSBot::PLANT_BOMB );
+						me->PlantBomb();
+
+						// radio to the team
+						me->GetChatter()->PlantingTheBomb( me->GetPlace() );
+
+						return;
+					}
+					else if (TheCSBots()->IsTimeToPlantBomb())
+					{
+						// move to the closest bomb site
+						const CCSBotManager::Zone *zone = TheCSBots()->GetClosestZone( me->GetLastKnownArea(), PathCost( me ) );
+						if (zone)
+						{
+							// pick a random spot within the bomb zone
+							const Vector *pos = TheCSBots()->GetRandomPositionInZone( zone );
+							if (pos)
+							{
+								// move to bombsite
+								me->SetTask( CCSBot::PLANT_BOMB );
+								me->Run();
+								me->MoveTo( *pos );
+
+								return;
+							}
+						}
+					}
+				}
+				else
+				{
+					// at the start of the round, we may decide to defend "initial encounter" areas
+					// where we will first meet the enemy rush
+					if (me->IsSafe())
+					{
+						float defendRushChance = -17.0f * (me->GetMorale() - 2);
+
+						if (me->IsSniper() || RandomFloat( 0.0f, 100.0f ) < defendRushChance)
+						{
+							if (me->MoveToInitialEncounter())
+							{
+								me->PrintIfWatched( "I'm guarding an initial encounter area\n" );
+								me->SetTask( CCSBot::GUARD_INITIAL_ENCOUNTER );
+								me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+								return;
+							}
+						}
+					}
+
+					// small chance of sniper camping on offense, if we aren't carrying the bomb
+					if (me->GetFriendsRemaining() && me->IsSniper() && RandomFloat( 0, 100.0f ) < offenseSniperCampChance)
+					{
+						me->SetTask( CCSBot::MOVE_TO_SNIPER_SPOT );
+						me->Hide( me->GetLastKnownArea(), RandomFloat( 10.0f, 30.0f ), sniperHideRange );
+						me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+						me->PrintIfWatched( "Sniping!\n" );
+						return;
+					}
+
+					// if the bomb is loose (on the ground), go get it
+					if (me->NoticeLooseBomb())
+					{
+						me->FetchBomb();
+						return;
+					}
+
+					// if bomb has been planted, and we hear it, move to a hiding spot near the bomb and guard it
+					if (!me->IsRogue() && me->GetGameState()->IsBombPlanted() && me->GetGameState()->GetBombPosition())
+					{
+						const Vector *bombPos = me->GetGameState()->GetBombPosition();
+
+						if (bombPos)
+						{
+							me->SetTask( CCSBot::GUARD_TICKING_BOMB );
+							me->Hide( TheNavMesh->GetNavArea( *bombPos ) );
+							return;
+						}
+					}
+				}
+			}
+			else	// CT ------------------------------------------------------------------------------------------
+			{
+				if (me->GetGameState()->IsBombPlanted())
+				{
+					// if the bomb has been planted, attempt to defuse it
+					const Vector *bombPos = me->GetGameState()->GetBombPosition();
+					if (bombPos)
+					{
+						// if someone is defusing the bomb, guard them
+						if (TheCSBots()->GetBombDefuser())
+						{
+							if (!me->IsRogue())
+							{
+								me->SetTask( CCSBot::GUARD_BOMB_DEFUSER );
+								me->Hide( TheNavMesh->GetNavArea( *bombPos ) );
+								return;
+							}
+						}
+						else if (me->IsDoingScenario())
+						{
+							// move to the bomb and defuse it
+							me->SetTask( CCSBot::DEFUSE_BOMB );
+							me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+							me->MoveTo( *bombPos );
+							return;
+						}
+						else
+						{
+							// we're not allowed to defuse, guard the bomb zone
+							me->SetTask( CCSBot::GUARD_BOMB_ZONE );
+							me->Hide( TheNavMesh->GetNavArea( *bombPos ) );
+							me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+							return;
+						}
+					}
+					else if (me->GetGameState()->GetPlantedBombsite() != CSGameState::UNKNOWN)
+					{
+						// we know which bombsite, but not exactly where the bomb is, go there
+						const CCSBotManager::Zone *zone = TheCSBots()->GetZone( me->GetGameState()->GetPlantedBombsite() );
+						if (zone)
+						{
+							if (me->IsDoingScenario())
+							{
+								me->SetTask( CCSBot::DEFUSE_BOMB );
+								me->MoveTo( zone->m_center );
+								me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+								return;
+							}
+							else
+							{
+								// we're not allowed to defuse, guard the bomb zone
+								me->SetTask( CCSBot::GUARD_BOMB_ZONE );
+								me->Hide( TheNavMesh->GetNavArea( zone->m_center ) );
+								me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+								return;
+							}
+						}
+					}
+					else
+					{
+						// we dont know where the bomb is - we must search the bombsites
+
+						// find closest un-cleared bombsite
+						const CCSBotManager::Zone *zone = NULL;
+						float travelDistance = 9999999.9f;
+
+						for( int z=0; z<TheCSBots()->GetZoneCount(); ++z )
+						{
+							if (TheCSBots()->GetZone(z)->m_areaCount == 0)
+								continue;
+
+							// don't check bombsites that have been cleared
+							if (me->GetGameState()->IsBombsiteClear( z ))
+								continue;
+
+							// just use the first overlapping nav area as a reasonable approximation
+							ShortestPathCost cost = ShortestPathCost();
+							float dist = NavAreaTravelDistance( me->GetLastKnownArea(), 
+																TheNavMesh->GetNearestNavArea( TheCSBots()->GetZone(z)->m_center ), 
+																cost );
+
+							if (dist >= 0.0f && dist < travelDistance)
+							{
+								zone = TheCSBots()->GetZone(z);
+								travelDistance = dist;
+							}
+						}			
+						
+						
+						if (zone)
+						{
+							const float farAwayRange = 2000.0f;
+							if (travelDistance > farAwayRange)
+							{
+								zone = NULL;
+							}
+						}
+
+						// if closest bombsite is "far away", pick one at random
+						if (zone == NULL)
+						{
+							int zoneIndex = me->GetGameState()->GetNextBombsiteToSearch();
+							zone = TheCSBots()->GetZone( zoneIndex );
+						}
+
+						// move to bombsite - if we reach it, we'll update its cleared status, causing us to select another
+						if (zone)
+						{
+							const Vector *pos = TheCSBots()->GetRandomPositionInZone( zone );
+							if (pos)
+							{
+								me->SetTask( CCSBot::FIND_TICKING_BOMB );
+								me->MoveTo( *pos );
+								return;
+							}
+						}
+					}
+					AssertMsg( 0, "A CT bot doesn't know what to do while the bomb is planted!\n" );
+				}
+
+
+				// if we have a sniper rifle, we like to camp, whether rogue or not
+				if (me->IsSniper() && !me->IsSafe())
+				{
+					if (RandomFloat( 0, 100 ) <= defenseSniperCampChance)
+					{
+						CNavArea *snipingArea = NULL;
+
+						// if the bomb is loose, snipe near it
+						const Vector *bombPos = me->GetGameState()->GetBombPosition();
+						if (me->GetGameState()->IsLooseBombLocationKnown() && bombPos)
+						{
+							snipingArea = TheNavMesh->GetNearestNavArea( *bombPos );
+							me->PrintIfWatched( "Sniping near loose bomb\n" );
+						}
+						else
+						{
+							// snipe bomb zone(s)
+							const CCSBotManager::Zone *zone = TheCSBots()->GetRandomZone();
+							if (zone)
+							{
+								snipingArea = TheCSBots()->GetRandomAreaInZone( zone );
+								me->PrintIfWatched( "Sniping near bombsite\n" );
+							}
+						}
+
+						if (snipingArea)
+						{
+							me->SetTask( CCSBot::MOVE_TO_SNIPER_SPOT );
+							me->Hide( snipingArea, -1.0, sniperHideRange );
+							me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+							return;
+						}
+					}
+				}
+
+				// rogues just hunt, unless they want to snipe
+				// if the whole team has decided to rush, hunt
+				// if we know the bomb is dropped, hunt for enemies and the loose bomb
+				if (me->IsRogue() || TheCSBots()->IsDefenseRushing() || me->GetGameState()->IsLooseBombLocationKnown())
+				{
+					me->Hunt();
+					return;
+				}
+
+				// the lower our morale gets, the more we want to camp the bomb zone(s)
+				// only decide to camp at the start of the round, or if we haven't seen anything for a long time
+				if (me->IsSafe() || me->HasNotSeenEnemyForLongTime())
+				{
+					float guardBombsiteChance = -34.0f * me->GetMorale();
+
+					if (RandomFloat( 0.0f, 100.0f ) < guardBombsiteChance)
+					{
+						float guardRange = 500.0f + 100.0f * (me->GetMorale() + 3);
+
+						// guard bomb zone(s)
+						const CCSBotManager::Zone *zone = TheCSBots()->GetRandomZone();
+						if (zone)
+						{
+							CNavArea *area = TheCSBots()->GetRandomAreaInZone( zone );
+							if (area)
+							{
+								me->PrintIfWatched( "I'm guarding a bombsite\n" );
+								me->GetChatter()->GuardingBombsite( area->GetPlace() );
+								me->SetTask( CCSBot::GUARD_BOMB_ZONE );
+								me->Hide( area, -1.0, guardRange );
+								me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+								return;
+							}
+						}
+					}
+
+					// at the start of the round, we may decide to defend "initial encounter" areas
+					// where we will first meet the enemy rush
+					if (me->IsSafe())
+					{
+						float defendRushChance = -17.0f * (me->GetMorale() - 2);
+
+						if (me->IsSniper() || RandomFloat( 0.0f, 100.0f ) < defendRushChance)
+						{
+							if (me->MoveToInitialEncounter())
+							{
+								me->PrintIfWatched( "I'm guarding an initial encounter area\n" );
+								me->SetTask( CCSBot::GUARD_INITIAL_ENCOUNTER );
+								me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+								return;
+							}
+						}
+					}
+				}
+			}
+
+			break;
+		}
+
+		//======================================================================================================
+		case CCSBotManager::SCENARIO_ESCORT_VIP:
+		{
+			if (me->GetTeamNumber() == TEAM_TERRORIST)
+			{
+				// if we have a sniper rifle, we like to camp, whether rogue or not
+				if (me->IsSniper())
+				{
+					if (RandomFloat( 0, 100 ) <= defenseSniperCampChance)
+					{
+						// snipe escape zone(s)
+						const CCSBotManager::Zone *zone = TheCSBots()->GetRandomZone();
+						if (zone)
+						{
+							CNavArea *area = TheCSBots()->GetRandomAreaInZone( zone );
+							if (area)
+							{
+								me->SetTask( CCSBot::MOVE_TO_SNIPER_SPOT );
+								me->Hide( area, -1.0, sniperHideRange );
+								me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+								me->PrintIfWatched( "Sniping near escape zone\n" );
+								return;
+							}
+						}
+					}
+				}
+
+				// rogues just hunt, unless they want to snipe
+				// if the whole team has decided to rush, hunt
+				if (me->IsRogue() || TheCSBots()->IsDefenseRushing())
+					break;
+
+				// the lower our morale gets, the more we want to camp the escape zone(s)
+				float guardEscapeZoneChance = -34.0f * me->GetMorale();
+
+				if (RandomFloat( 0.0f, 100.0f ) < guardEscapeZoneChance)
+				{
+					// guard escape zone(s)
+					const CCSBotManager::Zone *zone = TheCSBots()->GetRandomZone();
+					if (zone)
+					{
+						CNavArea *area = TheCSBots()->GetRandomAreaInZone( zone );
+						if (area)
+						{
+							// guard the escape zone - stay closer if our morale is low
+							me->SetTask( CCSBot::GUARD_VIP_ESCAPE_ZONE );
+							me->PrintIfWatched( "I'm guarding an escape zone\n" );
+
+							float escapeGuardRange = 750.0f + 250.0f * (me->GetMorale() + 3);
+							me->Hide( area, -1.0, escapeGuardRange );
+
+							me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+							return;
+						}
+					}
+				}
+			}
+			else	// CT
+			{
+				if (me->m_bIsVIP)
+				{
+					// if early in round, pick a random zone, otherwise pick closest zone
+					const float earlyTime = 20.0f;
+					const CCSBotManager::Zone *zone = NULL;
+
+					if (TheCSBots()->GetElapsedRoundTime() < earlyTime)
+					{
+						// pick random zone
+						zone = TheCSBots()->GetRandomZone();
+					}
+					else
+					{
+						// pick closest zone
+						zone = TheCSBots()->GetClosestZone( me->GetLastKnownArea(), PathCost( me ) );
+					}
+
+					if (zone)
+					{
+						// pick a random spot within the escape zone
+						const Vector *pos = TheCSBots()->GetRandomPositionInZone( zone );
+						if (pos)
+						{
+							// move to escape zone
+							me->SetTask( CCSBot::VIP_ESCAPE );
+							me->Run();
+							me->MoveTo( *pos );
+
+							// tell team to follow
+							const float repeatTime = 30.0f;
+							if (me->GetFriendsRemaining() && 
+									TheCSBots()->GetRadioMessageInterval( RADIO_FOLLOW_ME, me->GetTeamNumber() ) > repeatTime)
+								me->SendRadioMessage( RADIO_FOLLOW_ME );
+							return;
+						}
+					}
+				}
+				else
+				{
+					// small chance of sniper camping on offense, if we aren't VIP
+					if (me->GetFriendsRemaining() && me->IsSniper() && RandomFloat( 0, 100.0f ) < offenseSniperCampChance)
+					{
+						me->SetTask( CCSBot::MOVE_TO_SNIPER_SPOT );
+						me->Hide( me->GetLastKnownArea(), RandomFloat( 10.0f, 30.0f ), sniperHideRange );
+						me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+						me->PrintIfWatched( "Sniping!\n" );
+						return;
+					}
+				}
+			}
+			break;
+		}
+
+		//======================================================================================================
+		case CCSBotManager::SCENARIO_RESCUE_HOSTAGES:
+		{
+			if (me->GetTeamNumber() == TEAM_TERRORIST)
+			{
+				bool campHostages;
+
+				// if we are in early game, camp the hostages
+				if (me->IsSafe())
+				{
+					campHostages = true;
+				}
+				else if (me->GetGameState()->HaveSomeHostagesBeenTaken() || me->GetGameState()->AreAllHostagesBeingRescued())
+				{
+					campHostages = false;
+				}
+				else
+				{
+					// later in the game, camp either hostages or escape zone
+					const float campZoneChance = 100.0f * (TheCSBots()->GetElapsedRoundTime() - me->GetSafeTime())/120.0f;
+
+					campHostages = (RandomFloat( 0, 100 ) > campZoneChance) ? true : false; 
+				}
+
+
+				// if we have a sniper rifle, we like to camp, whether rogue or not
+				if (me->IsSniper())
+				{
+					// the at start of the round, snipe the initial rush
+					if (me->IsSafe())
+					{
+						if (me->MoveToInitialEncounter())
+						{
+							me->PrintIfWatched( "I'm sniping an initial encounter area\n" );
+							me->SetTask( CCSBot::GUARD_INITIAL_ENCOUNTER );
+							me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+							return;
+						}
+					}
+
+					if (RandomFloat( 0, 100 ) <= defenseSniperCampChance)
+					{
+						const Vector *hostagePos = me->GetGameState()->GetRandomFreeHostagePosition();
+						if (hostagePos && campHostages)
+						{
+							me->SetTask( CCSBot::MOVE_TO_SNIPER_SPOT );
+							me->PrintIfWatched( "Sniping near hostages\n" );
+							me->Hide( TheNavMesh->GetNearestNavArea( *hostagePos ), -1.0, sniperHideRange );
+							me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+							return;
+						}
+						else
+						{
+							// camp the escape zone(s)
+							if (me->GuardRandomZone( sniperHideRange ))
+							{
+								me->SetTask( CCSBot::MOVE_TO_SNIPER_SPOT );
+								me->PrintIfWatched( "Sniping near a rescue zone\n" );
+								me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+								return;
+							}
+						}
+					}
+				}
+
+				// if safe time is up, and we stumble across a hostage, guard it
+				if (!me->IsSafe() && !me->IsRogue())
+				{
+					CBaseEntity *hostage = me->GetGameState()->GetNearestVisibleFreeHostage();
+					if (hostage)
+					{
+						// we see a free hostage, guard it
+						CNavArea *area = TheNavMesh->GetNearestNavArea( GetCentroid( hostage ) );
+						if (area)
+						{
+							me->SetTask( CCSBot::GUARD_HOSTAGES );
+							me->Hide( area );
+							me->PrintIfWatched( "I'm guarding hostages I found\n" );
+							// don't chatter here - he'll tell us when he's in his hiding spot
+							return;
+						}
+					}
+				}
+
+
+				// decide if we want to hunt, or guard
+				const float huntChance = 70.0f + 25.0f * me->GetMorale();
+
+				// rogues just hunt, unless they want to snipe
+				// if the whole team has decided to rush, hunt
+				if (me->GetFriendsRemaining())
+				{
+					if (me->IsRogue() || TheCSBots()->IsDefenseRushing() || RandomFloat( 0, 100 ) < huntChance)
+					{
+						me->Hunt();
+						return;
+					}
+				}
+
+				// at the start of the round, we may decide to defend "initial encounter" areas
+				// where we will first meet the enemy rush
+				if (me->IsSafe())
+				{
+					float defendRushChance = -17.0f * (me->GetMorale() - 2);
+
+					if (me->IsSniper() || RandomFloat( 0.0f, 100.0f ) < defendRushChance)
+					{
+						if (me->MoveToInitialEncounter())
+						{
+							me->PrintIfWatched( "I'm guarding an initial encounter area\n" );
+							me->SetTask( CCSBot::GUARD_INITIAL_ENCOUNTER );
+							me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+							return;
+						}
+					}
+				}
+
+
+				// decide whether to camp the hostages or the escape zones
+				const Vector *hostagePos = me->GetGameState()->GetRandomFreeHostagePosition();
+				if (hostagePos && campHostages)
+				{
+					CNavArea *area = TheNavMesh->GetNearestNavArea( *hostagePos );
+					if (area)
+					{
+						// guard the hostages - stay closer to hostages if our morale is low
+						me->SetTask( CCSBot::GUARD_HOSTAGES );
+						me->PrintIfWatched( "I'm guarding hostages\n" );
+
+						float hostageGuardRange = 750.0f + 250.0f * (me->GetMorale() + 3);			// 2000
+						me->Hide( area, -1.0, hostageGuardRange );
+						me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+
+						if (RandomFloat( 0, 100 ) < 50)
+							me->GetChatter()->GuardingHostages( area->GetPlace(), IS_PLAN );
+
+						return;
+					}
+				}
+
+				// guard rescue zone(s)
+				if (me->GuardRandomZone())
+				{
+					me->SetTask( CCSBot::GUARD_HOSTAGE_RESCUE_ZONE );
+					me->PrintIfWatched( "I'm guarding a rescue zone\n" );
+					me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+					me->GetChatter()->GuardingHostageEscapeZone( IS_PLAN );
+					return;
+				}
+			}
+			else	// CT ---------------------------------------------------------------------------------
+			{
+				// only decide to do something else if we aren't already rescuing hostages
+				if (!me->GetHostageEscortCount())
+				{
+					// small chance of sniper camping on offense
+					if (me->GetFriendsRemaining() && me->IsSniper() && RandomFloat( 0, 100.0f ) < offenseSniperCampChance)
+					{
+						me->SetTask( CCSBot::MOVE_TO_SNIPER_SPOT );
+						me->Hide( me->GetLastKnownArea(), RandomFloat( 10.0f, 30.0f ), sniperHideRange );
+						me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+						me->PrintIfWatched( "Sniping!\n" );
+						return;
+					}
+
+					if (me->GetFriendsRemaining() && !me->GetHostageEscortCount())
+					{
+						// rogues just hunt, unless all friends are dead
+						// if we have friends left, we might go hunting instead of hostage rescuing
+						const float huntChance = 33.3f;
+						if (me->IsRogue() || RandomFloat( 0.0f, 100.0f ) < huntChance)
+						{
+							me->Hunt();
+							return;
+						}
+					}
+				}
+
+				// at the start of the round, we may decide to defend "initial encounter" areas
+				// where we will first meet the enemy rush
+				if (me->IsSafe())
+				{
+					float defendRushChance = -17.0f * (me->GetMorale() - 2);
+
+					if (me->IsSniper() || RandomFloat( 0.0f, 100.0f ) < defendRushChance)
+					{
+						if (me->MoveToInitialEncounter())
+						{
+							me->PrintIfWatched( "I'm guarding an initial encounter area\n" );
+							me->SetTask( CCSBot::GUARD_INITIAL_ENCOUNTER );
+							me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+							return;
+						}
+					}
+				}
+
+				// look for free hostages - CT's have radar so they know where hostages are at all times
+				CHostage *hostage = me->GetGameState()->GetNearestFreeHostage();
+
+				// if we are not allowed to do the scenario, guard the hostages to clear the area for the human(s)
+				if (!me->IsDoingScenario())
+				{
+					if (hostage)
+					{		
+						CNavArea *area = TheNavMesh->GetNearestNavArea( GetCentroid( hostage ) );
+						if (area)
+						{
+							me->SetTask( CCSBot::GUARD_HOSTAGES );
+							me->Hide( area );
+							me->PrintIfWatched( "I'm securing the hostages for a human to rescue\n" );
+							return;
+						}
+					}
+
+					me->Hunt();
+					return;
+				}
+
+
+				bool fetchHostages = false;
+				bool rescueHostages = false;
+				const CCSBotManager::Zone *zone = NULL;
+				me->SetGoalEntity( NULL );
+
+				// if we are escorting hostages, determine where to take them
+				if (me->GetHostageEscortCount())
+					zone = TheCSBots()->GetClosestZone( me->GetLastKnownArea(), PathCost( me, FASTEST_ROUTE ) );
+
+				// if we are escorting hostages and there are more hostages to rescue, 
+				// determine whether it's faster to rescue the ones we have, or go get the remaining ones
+				if (hostage)
+				{
+					Vector hostageOrigin = GetCentroid( hostage );
+
+					if (zone)
+					{
+						PathCost cost( me, FASTEST_ROUTE );
+						float toZone = NavAreaTravelDistance( me->GetLastKnownArea(), zone->m_area[0], cost  );
+						float toHostage = NavAreaTravelDistance( me->GetLastKnownArea(), TheNavMesh->GetNearestNavArea( GetCentroid( hostage ) ), cost );
+
+						if (toHostage < 0.0f)
+						{
+							rescueHostages = true;
+						}
+						else
+						{
+							if (toZone < toHostage)
+								rescueHostages = true;
+							else
+								fetchHostages = true;
+						}
+					}
+					else
+					{
+						fetchHostages = true;
+					}
+				}
+				else if (zone)
+				{
+					rescueHostages = true;
+				}
+
+
+				if (fetchHostages)
+				{
+					// go get hostages
+					me->SetTask( CCSBot::COLLECT_HOSTAGES );
+					me->Run();
+					me->SetGoalEntity( hostage );
+					me->ResetWaitForHostagePatience();
+
+					// if we already have some hostages, move to the others by the quickest route
+					RouteType route = (me->GetHostageEscortCount()) ? FASTEST_ROUTE : SAFEST_ROUTE;
+					me->MoveTo( GetCentroid( hostage ), route );
+
+					me->PrintIfWatched( "I'm collecting hostages\n" );
+					return;
+				}
+
+				const Vector *zonePos = TheCSBots()->GetRandomPositionInZone( zone );
+				if (rescueHostages && zonePos)
+				{
+					me->SetTask( CCSBot::RESCUE_HOSTAGES );
+					me->Run();
+					me->SetDisposition( CCSBot::SELF_DEFENSE );
+					me->MoveTo( *zonePos, FASTEST_ROUTE );
+					me->PrintIfWatched( "I'm rescuing hostages\n" );
+					me->GetChatter()->EscortingHostages();
+					return;
+				}
+			}
+			break;
+		}
+
+		default:	// deathmatch
+		{
+			// sniping check
+			if (me->GetFriendsRemaining() && me->IsSniper() && RandomFloat( 0, 100.0f ) < offenseSniperCampChance)
+			{
+				me->SetTask( CCSBot::MOVE_TO_SNIPER_SPOT );
+				me->Hide( me->GetLastKnownArea(), RandomFloat( 10.0f, 30.0f ), sniperHideRange );
+				me->SetDisposition( CCSBot::OPPORTUNITY_FIRE );
+				me->PrintIfWatched( "Sniping!\n" );
+				return;
+			}
+			break;
+		}
+	}
+
+	// if we have nothing special to do, go hunting for enemies
+	me->Hunt();
+}
+
diff --git a/game/server/cstrike/bot/states/cs_bot_investigate_noise.cpp b/game/server/cstrike/bot/states/cs_bot_investigate_noise.cpp
new file mode 100644
index 00000000..9aa3dd05
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_investigate_noise.cpp
@@ -0,0 +1,139 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move towards currently heard noise
+ */
+void InvestigateNoiseState::AttendCurrentNoise( CCSBot *me )
+{
+	if (!me->IsNoiseHeard() && me->GetNoisePosition())
+		return;
+
+	// remember where the noise we heard was
+	m_checkNoisePosition = *me->GetNoisePosition();
+
+	// tell our teammates (unless the noise is obvious, like gunfire)
+	if (me->IsWellPastSafe() && me->HasNotSeenEnemyForLongTime() && me->GetNoisePriority() != PRIORITY_HIGH)
+		me->GetChatter()->HeardNoise( *me->GetNoisePosition() );
+
+	// figure out how to get to the noise		
+	me->PrintIfWatched( "Attending to noise...\n" );
+	me->ComputePath( m_checkNoisePosition, FASTEST_ROUTE );
+
+	const float minAttendTime = 3.0f;
+	const float maxAttendTime = 10.0f;
+	m_minTimer.Start( RandomFloat( minAttendTime, maxAttendTime ) );
+
+	// consume the noise
+	me->ForgetNoise();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void InvestigateNoiseState::OnEnter( CCSBot *me )
+{
+	AttendCurrentNoise( me );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * @todo Use TravelDistance instead of distance...
+ */
+void InvestigateNoiseState::OnUpdate( CCSBot *me )
+{
+	Vector myOrigin = GetCentroid( me );
+
+	// keep an ear out for closer noises...
+	if (m_minTimer.IsElapsed())
+	{
+		const float nearbyRange = 500.0f;
+		if (me->HeardInterestingNoise() && me->GetNoiseRange() < nearbyRange)
+		{
+			// new sound is closer
+			AttendCurrentNoise( me );
+		}
+	}
+
+
+	// if the pathfind fails, give up
+	if (!me->HasPath())
+	{
+		me->Idle();
+		return;
+	}
+
+	// look around
+	me->UpdateLookAround();
+
+	// get distance remaining on our path until we reach the source of the noise
+	float range = me->GetPathDistanceRemaining();
+
+	if (me->IsUsingKnife())
+	{
+		if (me->IsHurrying())
+			me->Run();
+		else
+			me->Walk();
+	}
+	else
+	{
+		const float closeToNoiseRange = 1500.0f;
+		if (range < closeToNoiseRange)
+		{
+			// if we dont have many friends left, or we are alone, and we are near noise source, sneak quietly
+			if ((me->GetNearbyFriendCount() == 0 || me->GetFriendsRemaining() <= 2) && !me->IsHurrying())
+			{
+				me->Walk();
+			}
+			else
+			{
+				me->Run();
+			}
+		}
+		else
+		{
+			me->Run();
+		}
+	}
+
+
+	// if we can see the noise position and we're close enough to it and looking at it, 
+	// we don't need to actually move there (it's checked enough)
+	const float closeRange = 500.0f;
+	if (range < closeRange)
+	{
+		if (me->IsVisible( m_checkNoisePosition, CHECK_FOV ))
+		{
+			// can see noise position
+			me->PrintIfWatched( "Noise location is clear.\n" );
+			me->ForgetNoise();
+			me->Idle();
+			return;
+		}
+	}
+
+	// move towards noise
+	if (me->UpdatePathMovement() != CCSBot::PROGRESSING)
+	{
+		me->Idle();
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void InvestigateNoiseState::OnExit( CCSBot *me )
+{
+	// reset to run mode in case we were sneaking about
+	me->Run();
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_move_to.cpp b/game/server/cstrike/bot/states/cs_bot_move_to.cpp
new file mode 100644
index 00000000..eafba407
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_move_to.cpp
@@ -0,0 +1,366 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_simple_hostage.h"
+#include "cs_bot.h"
+#include "cs_gamerules.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move to a potentially far away position.
+ */
+void MoveToState::OnEnter( CCSBot *me )
+{
+	if (me->IsUsingKnife() && me->IsWellPastSafe() && !me->IsHurrying())
+	{
+		me->Walk();
+	}
+	else
+	{
+		me->Run();
+	}
+
+
+	// if we need to find the bomb, get there as quick as we can
+	RouteType route;
+	switch (me->GetTask())
+	{
+		case CCSBot::FIND_TICKING_BOMB:
+		case CCSBot::DEFUSE_BOMB:
+		case CCSBot::MOVE_TO_LAST_KNOWN_ENEMY_POSITION:
+			route = FASTEST_ROUTE;
+			break;
+
+		default:
+			route = SAFEST_ROUTE;
+			break;
+	}
+		
+	// build path to, or nearly to, goal position
+	me->ComputePath( m_goalPosition, route );
+
+	m_radioedPlan = false;
+	m_askedForCover = false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move to a potentially far away position.
+ */
+void MoveToState::OnUpdate( CCSBot *me )
+{
+	Vector myOrigin = GetCentroid( me );
+
+	// assume that we are paying attention and close enough to know our enemy died
+	if (me->GetTask() == CCSBot::MOVE_TO_LAST_KNOWN_ENEMY_POSITION)
+	{
+		/// @todo Account for reaction time so we take some time to realized the enemy is dead
+		CBasePlayer *victim = static_cast<CBasePlayer *>( me->GetTaskEntity() );
+		if (victim == NULL || !victim->IsAlive())
+		{
+			me->PrintIfWatched( "The enemy I was chasing was killed - giving up.\n" );
+			me->Idle();
+			return;
+		}
+	}
+
+	// look around
+	me->UpdateLookAround();
+
+	//
+	// Scenario logic
+	//
+	switch (TheCSBots()->GetScenario())
+	{
+		case CCSBotManager::SCENARIO_DEFUSE_BOMB:
+		{
+			// if the bomb has been planted, find it
+			// NOTE: This task is used by both CT and T's to find the bomb
+			if (me->GetTask() == CCSBot::FIND_TICKING_BOMB)
+			{
+				if (!me->GetGameState()->IsBombPlanted())
+				{
+					// the bomb is not planted - give up this task
+					me->Idle();
+					return;
+				}
+
+				if (me->GetGameState()->GetPlantedBombsite() != CSGameState::UNKNOWN)
+				{
+					// we know where the bomb is planted, stop searching
+					me->Idle();
+					return;
+				}
+
+				// check off bombsites that we explore or happen to stumble into
+				for( int z=0; z<TheCSBots()->GetZoneCount(); ++z )
+				{
+					// don't re-check zones
+					if (me->GetGameState()->IsBombsiteClear( z ))
+						continue;
+
+					if (TheCSBots()->GetZone(z)->m_extent.Contains( myOrigin ))
+					{
+						// note this bombsite is clear
+						me->GetGameState()->ClearBombsite( z );
+
+						if (me->GetTeamNumber() == TEAM_CT)
+						{
+							// tell teammates this bombsite is clear
+							me->GetChatter()->BombsiteClear( z );
+						}
+
+						// find another zone to check
+						me->Idle();
+
+						return;
+					}
+				}
+
+				// move to a bombsite
+				break;
+			}
+
+
+			if (me->GetTeamNumber() == TEAM_CT)
+			{
+				if (me->GetGameState()->IsBombPlanted())
+				{
+					switch( me->GetTask() )
+					{
+						case CCSBot::DEFUSE_BOMB:
+						{	
+							// if we are near the bombsite and there is time left, sneak in (unless all enemies are dead)
+							if (me->GetEnemiesRemaining())
+							{
+								const float plentyOfTime = 15.0f;
+								if (TheCSBots()->GetBombTimeLeft() > plentyOfTime)
+								{
+									// get distance remaining on our path until we reach the bombsite
+									float range = me->GetPathDistanceRemaining();
+
+									const float closeRange = 1500.0f;
+									if (range < closeRange)
+									{
+										me->Walk();
+									}
+									else
+									{
+										me->Run();
+									}
+								}
+							}
+							else
+							{
+								// everyone is dead - run!
+								me->Run();
+							}
+
+							// if we are trying to defuse the bomb, and someone has started defusing, guard them instead
+							if (me->CanSeePlantedBomb() && TheCSBots()->GetBombDefuser())
+							{
+								me->GetChatter()->Say( "CoveringFriend" );
+								me->Idle();
+								return;
+							}
+
+
+							// if we are near the bomb, defuse it (if we are reloading, don't try to defuse until we finish)
+							const Vector *bombPos = me->GetGameState()->GetBombPosition();
+							if (bombPos && !me->IsReloading())
+							{
+								const float defuseRange = 100.0f;		// 50
+								if ((*bombPos - me->EyePosition()).IsLengthLessThan( defuseRange ))
+								{
+									// make sure we can see the bomb
+									if (me->IsVisible( *bombPos ))
+									{
+										me->DefuseBomb();
+										return;
+									}
+								}
+							}
+
+							break;
+						}
+
+						default:
+						{
+							// we need to find the bomb
+							me->Idle();
+							return;
+						}
+					}
+				}
+			}
+			else		// TERRORIST
+			{
+				if (me->GetTask() == CCSBot::PLANT_BOMB )
+				{
+					if (  me->GetFriendsRemaining() )
+					{
+						// if we are about to plant, radio for cover
+						if (!m_askedForCover)
+						{
+							const float nearPlantSite = 50.0f;
+							if (me->IsAtBombsite() && me->GetPathDistanceRemaining() < nearPlantSite)
+							{
+								// radio to the team
+								me->GetChatter()->PlantingTheBomb( me->GetPlace() );
+								m_askedForCover = true;
+							}
+
+							// after we have started to move to the bombsite, tell team we're going to plant, and where
+							// don't do this if we have already radioed that we are starting to plant
+							if (!m_radioedPlan)
+							{
+								const float radioTime = 2.0f;
+								if (gpGlobals->curtime - me->GetStateTimestamp() > radioTime)
+								{
+									// radio to the team if we're more than 10 seconds (2400 units) out
+									const float nearPlantSite = 2400.0f;
+									if ( me->GetPathDistanceRemaining() >= nearPlantSite )
+									{
+										me->GetChatter()->GoingToPlantTheBomb( TheNavMesh->GetPlace( m_goalPosition ) );
+									}
+									m_radioedPlan = true;
+								}
+							}
+						}
+					}
+				}
+			}
+			break;
+		}
+
+		//--------------------------------------------------------------------------------------------------
+		case CCSBotManager::SCENARIO_RESCUE_HOSTAGES:
+		{
+			if (me->GetTask() == CCSBot::COLLECT_HOSTAGES)
+			{
+				//
+				// Since CT's have a radar, they can directly look at the actual hostage state
+				//
+
+				// check if someone else collected our hostage, or the hostage died or was rescued
+				CHostage *hostage = static_cast<CHostage *>( me->GetGoalEntity() );
+				if (hostage == NULL || !hostage->IsValid() || hostage->IsFollowingSomeone())
+				{
+					me->Idle();
+					return;
+				}
+
+				Vector hostageOrigin = GetCentroid( hostage );
+
+				// if our hostage has moved, repath
+				const float repathToleranceSq = 75.0f * 75.0f;
+				float error = (hostageOrigin - m_goalPosition).LengthSqr();
+				if (error > repathToleranceSq)
+				{
+					m_goalPosition = hostageOrigin;
+					me->ComputePath( m_goalPosition, SAFEST_ROUTE );
+				}
+
+				/// @todo Generalize ladder priorities over other tasks
+				if (!me->IsUsingLadder())
+				{
+					Vector pos = hostage->EyePosition();
+					Vector to = pos - me->EyePosition(); // "Use" checks from eye position, so we should too
+
+					// look at the hostage as we approach
+					const float watchHostageRange = 100.0f;
+					if (to.IsLengthLessThan( watchHostageRange ))
+					{
+						me->SetLookAt( "Hostage", pos, PRIORITY_LOW, 0.5f );
+
+						// randomly move just a bit to avoid infinite use loops from bad hostage placement
+						NavRelativeDirType dir = (NavRelativeDirType)RandomInt( 0, 3 );
+						switch( dir )
+						{
+							case LEFT:		me->StrafeLeft(); break;
+							case RIGHT:		me->StrafeRight(); break;
+							case FORWARD:	me->MoveForward(); break;
+							case BACKWARD:	me->MoveBackward(); break;
+						}
+
+						// check if we are close enough to the hostage to talk to him
+						const float useRange = PLAYER_USE_RADIUS - 10.0f; // shave off a fudge factor to make sure we're within range
+						if (to.IsLengthLessThan( useRange ))
+						{
+							me->UseEntity( me->GetGoalEntity() );					
+							return;
+						}
+					}
+				}
+			}
+			else if (me->GetTask() == CCSBot::RESCUE_HOSTAGES)
+			{
+				// periodically check if we lost all our hostages
+				if (me->GetHostageEscortCount() == 0)
+				{
+					// lost our hostages - go get 'em
+					me->Idle();
+					return;
+				}
+			}
+
+			break;
+		}
+	}
+
+
+	if (me->UpdatePathMovement() != CCSBot::PROGRESSING)
+	{
+		// reached destination
+		switch( me->GetTask() )
+		{
+			case CCSBot::PLANT_BOMB:
+				// if we are at bombsite with the bomb, plant it
+				if (me->IsAtBombsite() && me->HasC4())
+				{
+					me->PlantBomb();
+					return;
+				}
+				break;
+		
+			case CCSBot::MOVE_TO_LAST_KNOWN_ENEMY_POSITION:
+			{
+				CBasePlayer *victim = static_cast<CBasePlayer *>( me->GetTaskEntity() );
+				if (victim && victim->IsAlive())
+				{
+					// if we got here and haven't re-acquired the enemy, we lost him
+					BotStatement *say = new BotStatement( me->GetChatter(), REPORT_ENEMY_LOST, 8.0f );
+
+					say->AppendPhrase( TheBotPhrases->GetPhrase( "LostEnemy" ) );
+					say->SetStartTime( gpGlobals->curtime + RandomFloat( 3.0f, 5.0f ) );
+
+					me->GetChatter()->AddStatement( say );
+				}
+				break;
+			}
+		}
+
+		// default behavior when destination is reached
+		me->Idle();
+		return;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void MoveToState::OnExit( CCSBot *me )
+{
+	// reset to run in case we were walking near our goal position
+	me->Run();
+	me->SetDisposition( CCSBot::ENGAGE_AND_INVESTIGATE );
+	//me->StopAiming();
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_open_door.cpp b/game/server/cstrike/bot/states/cs_bot_open_door.cpp
new file mode 100644
index 00000000..a945a6cd
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_open_door.cpp
@@ -0,0 +1,94 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), April 2005
+
+#include "cbase.h"
+#include "cs_bot.h"
+#include "BasePropDoor.h"
+#include "doors.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-------------------------------------------------------------------------------------------------
+/**
+ * Face the door and open it.
+ * NOTE: This state assumes we are standing in range of the door to be opened, with no obstructions.
+ */
+void OpenDoorState::OnEnter( CCSBot *me )
+{
+	m_isDone = false;
+	m_timeout.Start( 1.0f );
+}
+
+
+//-------------------------------------------------------------------------------------------------
+void OpenDoorState::SetDoor( CBaseEntity *door )
+{
+	CBaseDoor *funcDoor = dynamic_cast< CBaseDoor * >(door);
+	if ( funcDoor )
+	{
+		m_funcDoor = funcDoor;
+		return;
+	}
+
+	CBasePropDoor *propDoor = dynamic_cast< CBasePropDoor * >(door);
+	if ( propDoor )
+	{
+		m_propDoor = propDoor;
+		return;
+	}
+}
+
+
+//-------------------------------------------------------------------------------------------------
+void OpenDoorState::OnUpdate( CCSBot *me )
+{
+	me->ResetStuckMonitor();
+
+	// wait for door to swing open before leaving state
+	if (m_timeout.IsElapsed())
+	{
+		m_isDone = true;
+		return;
+	}
+
+	// look at the door
+	Vector pos;
+	bool isDoorMoving = false;
+	if ( m_funcDoor )
+	{
+		pos = m_funcDoor->WorldSpaceCenter();
+		isDoorMoving = m_funcDoor->m_toggle_state == TS_GOING_UP || m_funcDoor->m_toggle_state == TS_GOING_DOWN;
+	}
+	else
+	{
+		pos = m_propDoor->WorldSpaceCenter();
+		isDoorMoving = m_propDoor->IsDoorOpening() || m_propDoor->IsDoorClosing();
+	}
+
+	me->SetLookAt( "Open door", pos, PRIORITY_HIGH );
+
+	// if we are looking at the door, "use" it and exit
+	if (me->IsLookingAtPosition( pos ))
+	{
+		me->UseEnvironment();
+	}
+}
+
+
+//-------------------------------------------------------------------------------------------------
+void OpenDoorState::OnExit( CCSBot *me )
+{
+	me->ClearLookAt();
+	me->ResetStuckMonitor();
+}
+
+
+
diff --git a/game/server/cstrike/bot/states/cs_bot_plant_bomb.cpp b/game/server/cstrike/bot/states/cs_bot_plant_bomb.cpp
new file mode 100644
index 00000000..fe45a3d1
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_plant_bomb.cpp
@@ -0,0 +1,79 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Plant the bomb.
+ */
+void PlantBombState::OnEnter( CCSBot *me )
+{
+	me->Crouch();
+	me->SetDisposition( CCSBot::SELF_DEFENSE );
+
+	// look at the floor
+//	Vector down( myOrigin.x, myOrigin.y, -1000.0f );
+
+	float yaw = me->EyeAngles().y;
+	Vector2D dir( BotCOS(yaw), BotSIN(yaw) );
+	Vector myOrigin = GetCentroid( me );
+
+	Vector down( myOrigin.x + 10.0f * dir.x, myOrigin.y + 10.0f * dir.y, me->GetFeetZ() );
+	me->SetLookAt( "Plant bomb on floor", down, PRIORITY_HIGH );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Plant the bomb.
+ */
+void PlantBombState::OnUpdate( CCSBot *me )
+{
+	CBaseCombatWeapon *gun = me->GetActiveWeapon();
+	bool holdingC4 = false;
+	if (gun)
+	{
+		if (FStrEq( gun->GetClassname(), "weapon_c4" ))
+			holdingC4 = true;
+	}
+
+	// if we aren't holding the C4, grab it, otherwise plant it
+	if (holdingC4)
+		me->PrimaryAttack();
+	else
+		me->SelectItem( "weapon_c4" );
+
+	// if we no longer have the C4, we've successfully planted
+	if (!me->HasC4())
+	{
+		// move to a hiding spot and watch the bomb
+		me->SetTask( CCSBot::GUARD_TICKING_BOMB );
+		me->Hide();
+	}
+
+	// if we time out, it's because we slipped into a non-plantable area
+	const float timeout = 5.0f;
+	if (gpGlobals->curtime - me->GetStateTimestamp() > timeout)
+		me->Idle();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void PlantBombState::OnExit( CCSBot *me )
+{
+	// equip our rifle (in case we were interrupted while holding C4)
+	me->EquipBestWeapon();
+	me->StandUp();
+	me->ResetStuckMonitor();
+	me->SetDisposition( CCSBot::ENGAGE_AND_INVESTIGATE );
+	me->ClearLookAt();
+}
diff --git a/game/server/cstrike/bot/states/cs_bot_use_entity.cpp b/game/server/cstrike/bot/states/cs_bot_use_entity.cpp
new file mode 100644
index 00000000..591b364c
--- /dev/null
+++ b/game/server/cstrike/bot/states/cs_bot_use_entity.cpp
@@ -0,0 +1,63 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_bot.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+/**
+ * Face the entity and "use" it
+ * NOTE: This state assumes we are standing in range of the entity to be used, with no obstructions.
+ */
+void UseEntityState::OnEnter( CCSBot *me )
+{
+}
+
+void UseEntityState::OnUpdate( CCSBot *me )
+{
+	// in the very rare situation where two or more bots "used" a hostage at the same time,
+	// one bot will fail and needs to time out of this state
+	const float useTimeout = 5.0f;
+	if (me->GetStateTimestamp() - gpGlobals->curtime > useTimeout)
+	{
+		me->Idle();
+		return;
+	}
+
+	// look at the entity
+	Vector pos = m_entity->EyePosition();
+	me->SetLookAt( "Use entity", pos, PRIORITY_HIGH );
+
+	// if we are looking at the entity, "use" it and exit
+	if (me->IsLookingAtPosition( pos ))
+	{
+		if (TheCSBots()->GetScenario() == CCSBotManager::SCENARIO_RESCUE_HOSTAGES && 
+			me->GetTeamNumber() == TEAM_CT &&
+			me->GetTask() == CCSBot::COLLECT_HOSTAGES)
+		{
+			// we are collecting a hostage, assume we were successful - the update check will correct us if we weren't
+			me->IncreaseHostageEscortCount();
+		}
+
+		me->UseEnvironment();
+		me->Idle();
+	}
+}
+
+void UseEntityState::OnExit( CCSBot *me )
+{
+	me->ClearLookAt();
+	me->ResetStuckMonitor();
+}
+
+
+
diff --git a/game/server/cstrike/cs_autobuy.cpp b/game/server/cstrike/cs_autobuy.cpp
new file mode 100644
index 00000000..e7ed3362
--- /dev/null
+++ b/game/server/cstrike/cs_autobuy.cpp
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Data for Autobuy and Rebuy 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_autobuy.h"
+
+// Weapon class information for each weapon including the class name and the buy command alias.
+AutoBuyInfoStruct g_autoBuyInfo[] = 
+{
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_RIFLE), "galil", "weapon_galil" }, // galil
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_RIFLE), "ak47", "weapon_ak47" },  // ak47
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SNIPERRIFLE), "scout", "weapon_scout" }, // scout
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_RIFLE), "sg552", "weapon_sg552" }, // sg552
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SNIPERRIFLE), "awp", "weapon_awp" }, // awp
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SNIPERRIFLE), "g3sg1", "weapon_g3sg1" }, // g3sg1
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_RIFLE), "famas", "weapon_famas" }, // famas
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_RIFLE), "m4a1", "weapon_m4a1" }, // m4a1
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_RIFLE), "aug", "weapon_aug" }, // aug
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SNIPERRIFLE), "sg550", "weapon_sg550" }, // sg550
+	{ (AutoBuyClassType)(AUTOBUYCLASS_SECONDARY | AUTOBUYCLASS_PISTOL), "glock", "weapon_glock" }, // glock
+	{ (AutoBuyClassType)(AUTOBUYCLASS_SECONDARY | AUTOBUYCLASS_PISTOL), "usp", "weapon_usp" }, // usp
+	{ (AutoBuyClassType)(AUTOBUYCLASS_SECONDARY | AUTOBUYCLASS_PISTOL), "p228", "weapon_p228" }, // p228
+	{ (AutoBuyClassType)(AUTOBUYCLASS_SECONDARY | AUTOBUYCLASS_PISTOL), "deagle", "weapon_deagle" }, // deagle
+	{ (AutoBuyClassType)(AUTOBUYCLASS_SECONDARY | AUTOBUYCLASS_PISTOL), "elite", "weapon_elite" },	// elites
+	{ (AutoBuyClassType)(AUTOBUYCLASS_SECONDARY | AUTOBUYCLASS_PISTOL), "fn57", "weapon_fiveseven" },	// fn57
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SHOTGUN), "m3", "weapon_m3" }, // m3
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SHOTGUN), "xm1014", "weapon_xm1014" },	// xm1014
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SMG), "mac10", "weapon_mac10" },	// mac10
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SMG), "tmp", "weapon_tmp" },	// tmp
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SMG), "mp5navy", "weapon_mp5navy" },	// mp5navy
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SMG), "ump45", "weapon_ump45" },	// ump45
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SMG), "p90", "weapon_p90" },	// p90
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_MACHINEGUN), "m249", "weapon_m249" },	// m249
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_AMMO), "primammo", "primammo" },	// primammo
+	{ (AutoBuyClassType)(AUTOBUYCLASS_SECONDARY | AUTOBUYCLASS_AMMO), "secammo", "secammo" }, // secmmo
+	{ (AutoBuyClassType)(AUTOBUYCLASS_ARMOR), "vest", "item_kevlar" }, // vest
+	{ (AutoBuyClassType)(AUTOBUYCLASS_ARMOR), "vesthelm", "item_assaultsuit" }, // vesthelm
+	{ (AutoBuyClassType)(AUTOBUYCLASS_GRENADE), "flashbang", "weapon_flashbang" }, // flash
+	{ (AutoBuyClassType)(AUTOBUYCLASS_GRENADE), "hegrenade", "weapon_hegrenade" }, // hegren
+	{ (AutoBuyClassType)(AUTOBUYCLASS_GRENADE), "smokegrenade", "weapon_smokegrenade" }, // sgren
+	{ (AutoBuyClassType)(AUTOBUYCLASS_NIGHTVISION), "nvgs", "nvgs" }, // nvgs
+	{ (AutoBuyClassType)(AUTOBUYCLASS_DEFUSER), "defuser", "defuser" }, // defuser
+	{ (AutoBuyClassType)(AUTOBUYCLASS_PRIMARY | AUTOBUYCLASS_SHIELD), "shield", "shield" }, // shield
+
+	{ (AutoBuyClassType)0, "", "" } // last one, must be at end.
+};
diff --git a/game/server/cstrike/cs_autobuy.h b/game/server/cstrike/cs_autobuy.h
new file mode 100644
index 00000000..9fc8346a
--- /dev/null
+++ b/game/server/cstrike/cs_autobuy.h
@@ -0,0 +1,53 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Headers and defines for Autobuy and Rebuy 
+//
+//=============================================================================//
+
+/**
+ * Weapon classes as used by the AutoBuy
+ * Has to be different that the previous ones because these are bitmasked values as a weapon can be from
+ * more than one class.  This also includes all the classes of equipment that a player can buy.
+ */
+enum AutoBuyClassType
+{
+	AUTOBUYCLASS_PRIMARY = 1,
+	AUTOBUYCLASS_SECONDARY = 2,
+	AUTOBUYCLASS_AMMO = 4,
+	AUTOBUYCLASS_ARMOR = 8,
+	AUTOBUYCLASS_DEFUSER = 16,
+	AUTOBUYCLASS_PISTOL = 32,
+	AUTOBUYCLASS_SMG = 64,
+	AUTOBUYCLASS_RIFLE = 128,
+	AUTOBUYCLASS_SNIPERRIFLE = 256,
+	AUTOBUYCLASS_SHOTGUN = 512,
+	AUTOBUYCLASS_MACHINEGUN = 1024,
+	AUTOBUYCLASS_GRENADE = 2048,
+	AUTOBUYCLASS_NIGHTVISION = 4096,
+	AUTOBUYCLASS_SHIELD = 8192,
+};
+
+struct AutoBuyInfoStruct
+{
+	AutoBuyClassType m_class;
+	const char *m_command;
+	const char *m_classname;
+};
+
+struct RebuyStruct
+{
+	char m_szPrimaryWeapon[64];		//"weapon_" string of the primary weapon
+	char m_szSecondaryWeapon[64];	//"weapon_" string of the secondary weapon
+
+	int m_primaryAmmo;				// number of rounds the player had (not including rounds in the gun)
+	int m_secondaryAmmo;			// number of rounds the player had (not including rounds in the gun)
+	int m_heGrenade;				// number of grenades to buy
+	int m_flashbang;				// number of grenades to buy
+	int m_smokeGrenade;				// number of grenades to buy
+	int m_armor;					// 0, 1, or 2 (0 = none, 1 = vest, 2 = vest + helmet)
+
+	bool m_defuser;					// do we want a defuser
+	bool m_nightVision;				// do we want night vision
+};
+
+extern AutoBuyInfoStruct g_autoBuyInfo[];
diff --git a/game/server/cstrike/cs_bot_temp.cpp b/game/server/cstrike/cs_bot_temp.cpp
new file mode 100644
index 00000000..b1549114
--- /dev/null
+++ b/game/server/cstrike/cs_bot_temp.cpp
@@ -0,0 +1,554 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Basic BOT handling.
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_player.h"
+#include "in_buttons.h"
+#include "movehelper_server.h"
+#include "team.h"
+#include "cs_gamerules.h"
+#include "client.h"
+
+
+void Bot_Think( CCSPlayer *pBot );
+
+ConVar bot_forcefireweapon( "bot_forcefireweapon", "", 0, "Force bots with the specified weapon to fire." );
+ConVar bot_forceattack2( "bot_forceattack2", "0", 0, "When firing, use attack2." );
+ConVar bot_forceattackon( "bot_forceattackon", "0", 0, "When firing, don't tap fire, hold it down." );
+ConVar bot_flipout( "bot_flipout", "0", 0, "When on, all bots fire their guns." );
+ConVar bot_mimic( "bot_mimic", "0", 0, "Bot uses usercmd of player by index." );
+static ConVar bot_mimic_yaw_offset( "bot_mimic_yaw_offset", "0", 0, "Offsets the bot yaw." );
+
+static int BotNumber = 1;
+static int g_iNextBotTeam = -1;
+
+
+typedef struct
+{
+	bool			backwards;
+
+	float			nextturntime;
+	bool			lastturntoright;
+
+	float			nextstrafetime;
+	float			sidemove;
+
+	QAngle			forwardAngle;
+	QAngle			lastAngles;
+
+	int m_WantedTeam;
+	float m_flJoinTeamTime;
+
+	bool m_bTempBot;	// Is this slot a dump temp bot or a real bot?
+} botdata_t;
+
+static botdata_t g_BotData[ MAX_PLAYERS ];
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a new Bot and put it in the game.
+// Output : Pointer to the new Bot, or NULL if there's no free clients.
+//-----------------------------------------------------------------------------
+CBasePlayer *BotPutInServer( bool bFrozen, int iTeam )
+{
+	g_iNextBotTeam = iTeam;
+
+	char botname[ 64 ];
+	Q_snprintf( botname, sizeof( botname ), "Bot%02i", BotNumber );
+
+	edict_t *pEdict = engine->CreateFakeClient( botname );
+
+	if (!pEdict)
+	{
+		Msg( "Failed to create Bot.\n");
+		return NULL;
+	}
+
+	// Allocate a CBasePlayer for the bot, and call spawn
+	//ClientPutInServer( pEdict, botname );
+	//ClientActive( pEdict, false );
+
+	CCSPlayer *pPlayer = ((CCSPlayer *)CBaseEntity::Instance( pEdict ));
+	pPlayer->ClearFlags();
+	pPlayer->AddFlag( FL_CLIENT | FL_FAKECLIENT );
+
+	if ( bFrozen )
+		pPlayer->AddEFlags( EFL_BOT_FROZEN );
+
+	if ( iTeam == -1 )
+		iTeam = ( pPlayer->entindex() & 1 ) ? TEAM_TERRORIST : TEAM_CT;
+
+	botdata_t *pData = &g_BotData[pPlayer->entindex()-1];
+	pData->m_WantedTeam = iTeam;
+	pData->m_flJoinTeamTime = gpGlobals->curtime + 0.3;
+	pData->m_bTempBot = true;
+
+	BotNumber++;
+	return pPlayer;
+}
+
+bool IsTempBot( CBaseEntity *pEnt )
+{
+	if ( !pEnt )
+		return false;
+	
+	if ( !(pEnt->GetFlags() & FL_FAKECLIENT) )
+		return false;
+
+	int i = pEnt->entindex();
+	if ( i >= 1 && i < MAX_PLAYERS )
+		return g_BotData[i-1].m_bTempBot;
+	else
+		return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Run through all the Bots in the game and let them think.
+//-----------------------------------------------------------------------------
+void Bot_RunAll( void )
+{
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( i ) );
+
+		if ( IsTempBot( pPlayer ) )
+		{
+			Bot_Think( pPlayer );
+		}
+	}
+}
+
+bool RunMimicCommand( CUserCmd& cmd )
+{
+	if ( bot_mimic.GetInt() <= 0 )
+		return false;
+
+	if ( bot_mimic.GetInt() > gpGlobals->maxClients )
+		return false;
+
+	
+	CBasePlayer *pPlayer = UTIL_PlayerByIndex( bot_mimic.GetInt() );
+	if ( !pPlayer )
+		return false;
+
+	if ( !pPlayer->GetLastUserCommand() )
+		return false;
+
+	cmd = *pPlayer->GetLastUserCommand();
+	cmd.viewangles[YAW] += bot_mimic_yaw_offset.GetFloat();
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Simulates a single frame of movement for a player
+// Input  : *fakeclient - 
+//			*viewangles - 
+//			forwardmove - 
+//			sidemove - 
+//			upmove - 
+//			buttons - 
+//			impulse - 
+//			msec - 
+// Output : 	virtual void
+//-----------------------------------------------------------------------------
+static void RunPlayerMove( CCSPlayer *fakeclient, const QAngle& viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, float frametime )
+{
+	if ( !fakeclient )
+		return;
+
+	CUserCmd cmd;
+
+	// Store off the globals.. they're gonna get whacked
+	float flOldFrametime = gpGlobals->frametime;
+	float flOldCurtime = gpGlobals->curtime;
+
+	float flTimeBase = gpGlobals->curtime;
+	fakeclient->SetTimeBase( flTimeBase );
+
+	Q_memset( &cmd, 0, sizeof( cmd ) );
+
+	if ( !RunMimicCommand( cmd ) )
+	{
+		VectorCopy( viewangles, cmd.viewangles );
+		cmd.forwardmove = forwardmove;
+		cmd.sidemove = sidemove;
+		cmd.upmove = upmove;
+		cmd.buttons = buttons;
+		cmd.impulse = impulse;
+		cmd.random_seed = random->RandomInt( 0, 0x7fffffff );
+	}
+
+	MoveHelperServer()->SetHost( fakeclient );
+	fakeclient->PlayerRunCommand( &cmd, MoveHelperServer() );
+
+	// save off the last good usercmd
+	fakeclient->SetLastUserCommand( cmd );
+
+	// Clear out any fixangle that has been set
+	fakeclient->pl.fixangle = FIXANGLE_NONE;
+
+	// Restore the globals..
+	gpGlobals->frametime = flOldFrametime;
+	gpGlobals->curtime = flOldCurtime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Run this Bot's AI for one frame.
+//-----------------------------------------------------------------------------
+void Bot_Think( CCSPlayer *pBot )
+{
+	// Make sure we stay being a bot
+	pBot->AddFlag( FL_FAKECLIENT );
+
+	botdata_t *botdata = &g_BotData[ pBot->entindex() - 1 ];
+
+	float forwardmove = 0.0;
+	float sidemove = botdata->sidemove;
+	float upmove = 0.0;
+	unsigned short buttons = 0;
+	byte  impulse = 0;
+	float frametime = gpGlobals->frametime;
+
+	if ( pBot->GetTeamNumber() == TEAM_UNASSIGNED && gpGlobals->curtime > botdata->m_flJoinTeamTime )
+	{
+		pBot->HandleCommand_JoinTeam( botdata->m_WantedTeam );
+	}
+	else if ( pBot->GetTeamNumber() != TEAM_UNASSIGNED && pBot->PlayerClass() == CS_CLASS_NONE )
+	{
+		// If they're on a team but haven't picked a class, choose a random class..
+		pBot->HandleCommand_JoinClass( 0 );
+	}
+	else
+	{
+		QAngle vecViewAngles;
+		vecViewAngles = pBot->GetLocalAngles();
+
+		// Create some random values
+		if ( pBot->IsAlive() && (pBot->GetSolid() == SOLID_BBOX) )
+		{
+			trace_t trace;
+
+			// Stop when shot
+			if ( !pBot->IsEFlagSet(EFL_BOT_FROZEN) )
+			{
+				if ( pBot->m_iHealth == 100 )
+				{
+					forwardmove = 600 * ( botdata->backwards ? -1 : 1 );
+					if ( botdata->sidemove != 0.0f )
+					{
+						forwardmove *= random->RandomFloat( 0.1, 1.0f );
+					}
+				}
+				else
+				{
+					forwardmove = 0;
+				}
+			}
+
+			// Only turn if I haven't been hurt
+			if ( !pBot->IsEFlagSet(EFL_BOT_FROZEN) && pBot->m_iHealth == 100 )
+			{
+				Vector vecEnd;
+				Vector forward;
+
+				QAngle angle;
+				float angledelta = 15.0;
+
+				int maxtries = (int)360.0/angledelta;
+
+				if ( botdata->lastturntoright )
+				{
+					angledelta = -angledelta;
+				}
+
+				angle = pBot->GetLocalAngles();
+
+				Vector vecSrc;
+				while ( --maxtries >= 0 )
+				{
+					AngleVectors( angle, &forward, NULL, NULL );
+
+					vecSrc = pBot->GetLocalOrigin() + Vector( 0, 0, 36 );
+
+					vecEnd = vecSrc + forward * 10;
+
+					UTIL_TraceHull( vecSrc, vecEnd, VEC_HULL_MIN_SCALED( pBot ), VEC_HULL_MAX_SCALED( pBot ), 
+						MASK_PLAYERSOLID, pBot, COLLISION_GROUP_NONE, &trace );
+
+					if ( trace.fraction == 1.0 )
+					{
+						//if ( gpGlobals->curtime < botdata->nextturntime )
+						//{
+						break;
+						//}
+					}
+
+					angle.y += angledelta;
+
+					if ( angle.y > 180 )
+						angle.y -= 360;
+					else if ( angle.y < -180 )
+						angle.y += 360;
+
+					botdata->nextturntime = gpGlobals->curtime + 2.0;
+					botdata->lastturntoright = random->RandomInt( 0, 1 ) == 0 ? true : false;
+
+					botdata->forwardAngle = angle;
+					botdata->lastAngles = angle;
+
+				}
+
+
+				/*
+				if ( gpGlobals->curtime >= botdata->nextstrafetime )
+				{
+					botdata->nextstrafetime = gpGlobals->curtime + 1.0f;
+
+					if ( random->RandomInt( 0, 5 ) == 0 )
+					{
+						botdata->sidemove = -600.0f + 1200.0f * random->RandomFloat( 0, 2 );
+					}
+					else
+					{
+						botdata->sidemove = 0;
+					}
+					sidemove = botdata->sidemove;
+
+					if ( random->RandomInt( 0, 20 ) == 0 )
+					{
+						botdata->backwards = true;
+					}
+					else
+					{
+						botdata->backwards = false;
+					}
+				}
+				*/
+
+				pBot->SetLocalAngles( angle );
+				vecViewAngles = angle;
+			}
+
+			// If bots are being forced to fire a weapon, see if I have it
+			else if ( bot_forcefireweapon.GetString() )
+			{
+				CBaseCombatWeapon *pWeapon = pBot->Weapon_OwnsThisType( bot_forcefireweapon.GetString() );
+				if ( pWeapon )
+				{
+					// Switch to it if we don't have it out
+					CBaseCombatWeapon *pActiveWeapon = pBot->GetActiveWeapon();
+
+					// Switch?
+					if ( pActiveWeapon != pWeapon )
+					{
+						pBot->Weapon_Switch( pWeapon );
+					}
+					else
+					{
+						// Start firing
+						// Some weapons require releases, so randomise firing
+						if ( bot_forceattackon.GetBool() || (RandomFloat(0.0,1.0) > 0.5) )
+						{
+							buttons |= bot_forceattack2.GetBool() ? IN_ATTACK2 : IN_ATTACK;
+						}
+					}
+				}
+			}
+
+			if ( bot_flipout.GetInt() )
+			{
+				if ( bot_forceattackon.GetBool() || (RandomFloat(0.0,1.0) > 0.5) )
+				{
+					buttons |= bot_forceattack2.GetBool() ? IN_ATTACK2 : IN_ATTACK;
+				}
+			}
+		}
+		else
+		{
+			// Wait for Reinforcement wave
+			if ( !pBot->IsAlive() )
+			{
+				// Try hitting my buttons occasionally
+				if ( random->RandomInt( 0, 100 ) > 80 )
+				{
+					// Respawn the bot
+					if ( random->RandomInt( 0, 1 ) == 0 )
+					{
+						buttons |= IN_JUMP;
+					}
+					else
+					{
+						buttons = 0;
+					}
+				}
+			}
+		}
+
+		if ( bot_flipout.GetInt() >= 2 )
+		{
+
+			QAngle angOffset = RandomAngle( -1, 1 );
+
+			botdata->lastAngles += angOffset;
+
+			for ( int i = 0 ; i < 2; i++ )
+			{
+				if ( fabs( botdata->lastAngles[ i ] - botdata->forwardAngle[ i ] ) > 15.0f )
+				{
+					if ( botdata->lastAngles[ i ] > botdata->forwardAngle[ i ] )
+					{
+						botdata->lastAngles[ i ] = botdata->forwardAngle[ i ] + 15;
+					}
+					else
+					{
+						botdata->lastAngles[ i ] = botdata->forwardAngle[ i ] - 15;
+					}
+				}
+			}
+
+			botdata->lastAngles[ 2 ] = 0;
+
+			pBot->SetLocalAngles( botdata->lastAngles );
+		}
+	}
+
+	pBot->SetPunchAngle( QAngle( 0, 0, 0 ) );
+	RunPlayerMove( pBot, pBot->GetLocalAngles(), forwardmove, sidemove, upmove, buttons, impulse, frametime );
+}
+
+
+
+// Handler for the "bot" command.
+CON_COMMAND_F( "bot_old", "Add a bot.", FCVAR_CHEAT )
+{
+	// Disable the CS bots, otherwise they'll interfere with the bot code here.
+	//extern bool g_bEnableCSBots;
+	//g_bEnableCSBots = false;
+
+	CCSPlayer *pPlayer = CCSPlayer::Instance( UTIL_GetCommandClientIndex() );
+
+	// The bot command uses switches like command-line switches.
+	// -count <count> tells how many bots to spawn.
+	// -team <index> selects the bot's team. Default is -1 which chooses randomly.
+	//	Note: if you do -team !, then it 
+	// -class <index> selects the bot's class. Default is -1 which chooses randomly.
+	// -frozen prevents the bots from running around when they spawn in.
+
+	int count = args.FindArgInt( "-count", 1 );
+	count = clamp( count, 1, 16 );
+
+	int iTeam = -1;
+	const char *pVal = args.FindArg( "-team" );
+	if ( pVal )
+	{
+		if ( pVal[0] == '!' )
+		{
+			if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
+				iTeam = TEAM_CT;
+			else
+				iTeam = TEAM_TERRORIST;
+		}
+		else if ( pVal[0] == 't' || pVal[0] == 'T' )
+		{
+			iTeam = TEAM_TERRORIST;
+		}
+		else if ( pVal[0] == 'c' || pVal[0] == 'C' )
+		{
+			iTeam = TEAM_CT;
+		}
+		else
+		{
+			iTeam = atoi( pVal );
+			if ( iTeam == 1 )
+				iTeam = TEAM_TERRORIST;
+			else
+				iTeam = TEAM_CT;
+		}
+	}
+
+	// Look at -frozen.
+	bool bFrozen = !!args.FindArg( "-frozen" );
+		
+	// Ok, spawn all the bots.
+	while ( --count >= 0 )
+	{
+		extern CBasePlayer *BotPutInServer( bool bFrozen, int iTeam );
+		BotPutInServer( bFrozen, iTeam );
+	}
+}
+
+
+// Handle the "PossessBot" command.
+void PossessBot_f( const CCommand &args )
+{
+	CCSPlayer *pPlayer = CCSPlayer::Instance( UTIL_GetCommandClientIndex() );
+	if ( !pPlayer )
+		return;
+
+	// Put the local player in control of this bot.
+	if ( args.ArgC() != 2 )
+	{
+		Warning( "PossessBot <client index>\n" );
+		return;
+	}
+
+	int iBotClient = atoi( args[1] );
+	int iBotEnt = iBotClient + 1;
+	
+	if ( iBotClient < 0 || 
+		iBotClient >= gpGlobals->maxClients || 
+		pPlayer->entindex() == iBotEnt )
+	{
+		Warning( "PossessBot <client index>\n" );
+	}
+	else
+	{
+		edict_t *pPlayerData = pPlayer->edict();
+		edict_t *pBotData = engine->PEntityOfEntIndex( iBotEnt );
+		if ( pBotData && pBotData )
+		{
+			// SWAP EDICTS
+
+			// Backup things we don't want to swap.
+			edict_t oldPlayerData = *pPlayerData;
+			edict_t oldBotData = *pBotData;
+
+			// Swap edicts.
+			edict_t tmp = *pPlayerData;
+			*pPlayerData = *pBotData;
+			*pBotData = tmp;
+
+			// Restore things we didn't want to swap.
+			//pPlayerData->m_EntitiesTouched = oldPlayerData.m_EntitiesTouched;
+			//pBotData->m_EntitiesTouched = oldBotData.m_EntitiesTouched;
+		
+			CBaseEntity *pPlayerBaseEnt = CBaseEntity::Instance( pPlayerData );
+			CBaseEntity *pBotBaseEnt = CBaseEntity::Instance( pBotData );
+
+			// Make the other a bot and make the player not a bot.
+			pPlayerBaseEnt->RemoveFlag( FL_FAKECLIENT );
+			pBotBaseEnt->AddFlag( FL_FAKECLIENT );
+		
+						
+			// Point the CBaseEntities at the right players.
+			pPlayerBaseEnt->NetworkProp()->SetEdict( pPlayerData );
+			pBotBaseEnt->NetworkProp()->SetEdict( pBotData );
+
+			// Freeze the bot.
+			pBotBaseEnt->AddEFlags( EFL_BOT_FROZEN );
+		}
+	}
+}
+
+
+ConCommand cc_PossessBot( "PossessBot", PossessBot_f, "Toggle. Possess a bot.\n\tArguments: <bot client number>", FCVAR_CHEAT );
+
diff --git a/game/server/cstrike/cs_bot_temp.h b/game/server/cstrike/cs_bot_temp.h
new file mode 100644
index 00000000..b7dfdb52
--- /dev/null
+++ b/game/server/cstrike/cs_bot_temp.h
@@ -0,0 +1,17 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef CS_BOT_TEMP_H
+#define CS_BOT_TEMP_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+extern ConVar bot_mimic;
+
+
+#endif // CS_BOT_TEMP_H
diff --git a/game/server/cstrike/cs_client.cpp b/game/server/cstrike/cs_client.cpp
new file mode 100644
index 00000000..b7f025eb
--- /dev/null
+++ b/game/server/cstrike/cs_client.cpp
@@ -0,0 +1,205 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+/*
+
+===== tf_client.cpp ========================================================
+
+  HL2 client/server game specific stuff
+
+*/
+
+#include "cbase.h"
+#include "player.h"
+#include "gamerules.h"
+#include "entitylist.h"
+#include "physics.h"
+#include "game.h"
+#include "ai_network.h"
+#include "ai_node.h"
+#include "ai_hull.h"
+#include "shake.h"
+#include "player_resource.h"
+#include "engine/IEngineSound.h"
+#include "cs_player.h"
+#include "cs_gamerules.h"
+#include "cs_bot.h"
+#include "tier0/vprof.h"
+#include "teamplayroundbased_gamerules.h"
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+extern CBaseEntity *FindPickerEntity( CBasePlayer *pPlayer );
+
+extern bool			g_fGameOver;
+
+
+void FinishClientPutInServer( CCSPlayer *pPlayer )
+{
+	pPlayer->InitialSpawn();
+	pPlayer->Spawn();
+
+	if (!pPlayer->IsBot())
+	{
+		// When the player first joins the server, they
+		pPlayer->m_iNumSpawns = 0;
+		pPlayer->m_takedamage = DAMAGE_NO;
+		pPlayer->pl.deadflag = true;
+		pPlayer->m_lifeState = LIFE_DEAD;
+		pPlayer->AddEffects( EF_NODRAW );
+		pPlayer->ChangeTeam( TEAM_UNASSIGNED );
+		pPlayer->SetThink( NULL );
+		pPlayer->AddAccount( CSGameRules()->GetStartMoney() );
+
+		// Move them to the first intro camera.
+		pPlayer->MoveToNextIntroCamera();
+		pPlayer->SetMoveType( MOVETYPE_NONE );
+	}
+
+
+	char sName[128];
+	Q_strncpy( sName, pPlayer->GetPlayerName(), sizeof( sName ) );
+	
+	// First parse the name and remove any %'s
+	for ( char *pApersand = sName; pApersand != NULL && *pApersand != 0; pApersand++ )
+	{
+		// Replace it with a space
+		if ( *pApersand == '%' )
+				*pApersand = ' ';
+	}
+
+	// notify other clients of player joining the game
+	UTIL_ClientPrintAll( HUD_PRINTNOTIFY, "#Game_connected", sName[0] != 0 ? sName : "<unconnected>" );
+}
+
+/*
+===========
+ClientPutInServer
+
+called each time a player is spawned into the game
+============
+*/
+void ClientPutInServer( edict_t *pEdict, const char *playername )
+{
+	// Allocate a CBaseTFPlayer for pev, and call spawn
+	CCSPlayer *pPlayer = CCSPlayer::CreatePlayer( "player", pEdict );
+
+	pPlayer->SetPlayerName( playername );
+}
+
+
+void ClientActive( edict_t *pEdict, bool bLoadGame )
+{
+	// Can't load games in CS!
+	Assert( !bLoadGame );
+
+	CCSPlayer *pPlayer = ToCSPlayer( CBaseEntity::Instance( pEdict ) );
+	FinishClientPutInServer( pPlayer );
+
+	CSingleUserRecipientFilter user( pPlayer );
+	user.MakeReliable();
+
+	// send the 4 end of match conditions.  long frag limit, long max rounds, long rounds needed won, and long time
+	UserMessageBegin( user, "MatchEndConditions" );
+	WRITE_LONG( fraglimit.GetInt() );
+	WRITE_LONG( mp_maxrounds.GetInt() );
+	WRITE_LONG( mp_winlimit.GetInt() );
+	WRITE_LONG( mp_timelimit.GetInt() );
+	MessageEnd();
+}
+
+
+/*
+===============
+const char *GetGameDescription()
+
+Returns the descriptive name of this .dll.  E.g., Half-Life, or Team Fortress 2
+===============
+*/
+const char *GetGameDescription()
+{
+	if ( g_pGameRules ) // this function may be called before the world has spawned, and the game rules initialized
+		return g_pGameRules->GetGameDescription();
+	else
+		return "Counter-Strike: Source";
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Precache game-specific models & sounds
+//-----------------------------------------------------------------------------
+void ClientGamePrecache( void )
+{
+	// Materials used by the client effects
+	CBaseEntity::PrecacheModel( "sprites/white.vmt" );
+	CBaseEntity::PrecacheModel( "sprites/physbeam.vmt" );
+
+	// Legacy temp ents sounds
+	CBaseEntity::PrecacheScriptSound( "Bounce.PistolShell" );
+	CBaseEntity::PrecacheScriptSound( "Bounce.RifleShell" );
+	CBaseEntity::PrecacheScriptSound( "Bounce.ShotgunShell" );
+
+// Moved to pure_server_minimal.txt
+//	// Flashbang-related files
+//	engine->ForceExactFile( "sprites/white.vmt" );
+//	engine->ForceExactFile( "sprites/white.vtf" );
+//	engine->ForceExactFile( "vgui/white.vmt" );
+//	engine->ForceExactFile( "vgui/white.vtf" );
+//	engine->ForceExactFile( "effects/flashbang.vmt" );
+//	engine->ForceExactFile( "effects/flashbang_white.vmt" );
+//
+//	// Smoke grenade-related files
+//	engine->ForceExactFile( "particle/particle_smokegrenade1.vmt" );
+//	engine->ForceExactFile( "particle/particle_smokegrenade.vtf" );
+//
+//	// Sniper scope
+//	engine->ForceExactFile( "sprites/scope_arc.vmt" );
+//	engine->ForceExactFile( "sprites/scope_arc.vtf" );
+//
+//	// DSP presets - don't want people avoiding the deafening + ear ring
+//	engine->ForceExactFile( "scripts/dsp_presets.txt" );
+}
+
+
+// called by ClientKill and DeadThink
+void respawn( CBaseEntity *pEdict, bool fCopyCorpse )
+{
+	if (gpGlobals->coop || gpGlobals->deathmatch)
+	{
+		if ( fCopyCorpse )
+		{
+			// make a copy of the dead body for appearances sake
+			dynamic_cast< CBasePlayer* >( pEdict )->CreateCorpse();
+		}
+
+		// respawn player
+		pEdict->Spawn();
+	}
+	else
+	{       // restart the entire server
+		engine->ServerCommand("reload\n");
+	}
+}
+
+void GameStartFrame( void )
+{
+	VPROF( "GameStartFrame" );
+
+	if ( g_fGameOver )
+		return;
+
+	gpGlobals->teamplay = teamplay.GetInt() ? true : false;
+}
+
+//=========================================================
+// instantiate the proper game rules object
+//=========================================================
+void InstallGameRules()
+{
+	CreateGameRulesObject( "CCSGameRules" );
+}
diff --git a/game/server/cstrike/cs_client.h b/game/server/cstrike/cs_client.h
new file mode 100644
index 00000000..a56f2c41
--- /dev/null
+++ b/game/server/cstrike/cs_client.h
@@ -0,0 +1,19 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef CS_CLIENT_H
+#define CS_CLIENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+void respawn( CBaseEntity *pEdict, bool fCopyCorpse );
+
+void FinishClientPutInServer( CCSPlayer *pPlayer );
+
+
+#endif // CS_CLIENT_H
diff --git a/game/server/cstrike/cs_eventlog.cpp b/game/server/cstrike/cs_eventlog.cpp
new file mode 100644
index 00000000..095f6f2e
--- /dev/null
+++ b/game/server/cstrike/cs_eventlog.cpp
@@ -0,0 +1,321 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "../EventLog.h"
+#include "team.h"
+#include "cs_gamerules.h"
+#include "KeyValues.h"
+
+#define LOG_DETAIL_ENEMY_ATTACKS		0x01
+#define LOG_DETAIL_TEAMMATE_ATTACKS		0x02
+
+ConVar mp_logdetail( "mp_logdetail", "0", FCVAR_NONE, "Logs attacks.  Values are: 0=off, 1=enemy, 2=teammate, 3=both)", true, 0.0f, true, 3.0f );
+
+class CCSEventLog : public CEventLog
+{
+private:
+	typedef CEventLog BaseClass;
+
+public:
+	bool PrintEvent( IGameEvent *event )	// override virtual function
+	{
+		if ( !PrintCStrikeEvent( event ) ) // allow CS to override logging
+		{
+			return BaseClass::PrintEvent( event );
+		}
+		else
+		{
+			return true;
+		}
+	}
+
+	bool Init()
+	{
+		BaseClass::Init();
+
+		// listen to CS events
+		ListenForGameEvent( "round_end" );
+		ListenForGameEvent( "round_start" );
+		ListenForGameEvent( "bomb_pickup" );
+		ListenForGameEvent( "bomb_begindefuse" );
+		ListenForGameEvent( "bomb_dropped" );
+		ListenForGameEvent( "bomb_defused" );
+		ListenForGameEvent( "bomb_planted" );
+		ListenForGameEvent( "hostage_rescued" );
+		ListenForGameEvent( "hostage_killed" );
+		ListenForGameEvent( "hostage_follows" );
+		ListenForGameEvent( "player_hurt" );
+
+		return true;
+	}
+
+protected:
+
+	bool PrintCStrikeEvent( IGameEvent *event )	// print Mod specific logs
+	{
+		const char *eventName = event->GetName();
+	
+		// messages that don't have a user associated to them
+		if ( !Q_strncmp( eventName, "round_end", Q_strlen("round_end") ) )
+		{
+			const int winner = event->GetInt( "winner" );
+			const int reason = event->GetInt( "reason" );
+			const char *msg = event->GetString( "message" );
+			msg++; // remove the '#' char
+
+			switch( reason )
+			{
+			case Game_Commencing:
+				UTIL_LogPrintf( "World triggered \"Game_Commencing\"\n" );
+				return true;
+				break;
+			}
+
+			CTeam *ct = GetGlobalTeam( TEAM_CT );
+			CTeam *ter = GetGlobalTeam( TEAM_TERRORIST );
+			Assert( ct && ter );
+
+			switch ( winner )
+			{
+			case WINNER_CT:
+				UTIL_LogPrintf( "Team \"%s\" triggered \"%s\" (CT \"%i\") (T \"%i\")\n", ct->GetName(), msg, ct->GetScore(), ter->GetScore() );
+				break;
+			case WINNER_TER:
+				UTIL_LogPrintf( "Team \"%s\" triggered \"%s\" (CT \"%i\") (T \"%i\")\n", ter->GetName(), msg, ct->GetScore(), ter->GetScore() );
+				break;
+			case WINNER_DRAW:
+			default:
+				UTIL_LogPrintf( "World triggered \"%s\" (CT \"%i\") (T \"%i\")\n", msg, ct->GetScore(), ter->GetScore() );
+				break;
+			}	
+
+			UTIL_LogPrintf( "Team \"CT\" scored \"%i\" with \"%i\" players\n", ct->GetScore(), ct->GetNumPlayers() );
+			UTIL_LogPrintf( "Team \"TERRORIST\" scored \"%i\" with \"%i\" players\n", ter->GetScore(), ter->GetNumPlayers() );
+			
+			UTIL_LogPrintf("World triggered \"Round_End\"\n");
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "server_", strlen("server_")) )
+		{
+			return false; // ignore server_ messages
+		}
+		
+		const int userid = event->GetInt( "userid" );
+		CBasePlayer *pPlayer = UTIL_PlayerByUserId( userid );
+		if ( !pPlayer )
+		{
+			return false;
+		}
+
+		if ( FStrEq( eventName, "player_hurt" ) )
+		{
+			const int attackerid = event->GetInt("attacker" );
+			const char *weapon = event->GetString( "weapon" );
+			CBasePlayer *pAttacker = UTIL_PlayerByUserId( attackerid );
+			if ( !pAttacker )
+			{
+				return false;
+			}
+
+			bool isTeamAttack = ( (pPlayer->GetTeamNumber() == pAttacker->GetTeamNumber() ) && (pPlayer != pAttacker) );
+			int detail = mp_logdetail.GetInt();
+			if ( ( isTeamAttack && ( detail & LOG_DETAIL_TEAMMATE_ATTACKS ) ) ||
+				( !isTeamAttack && ( detail & LOG_DETAIL_ENEMY_ATTACKS ) ) )
+			{
+				int hitgroup = event->GetInt( "hitgroup" );
+				const char *hitgroupStr = "GENERIC";
+				switch ( hitgroup )
+				{
+				case HITGROUP_GENERIC:
+					hitgroupStr = "generic";
+					break;
+				case HITGROUP_HEAD:
+					hitgroupStr = "head";
+					break;
+				case HITGROUP_CHEST:
+					hitgroupStr = "chest";
+					break;
+				case HITGROUP_STOMACH:
+					hitgroupStr = "stomach";
+					break;
+				case HITGROUP_LEFTARM:
+					hitgroupStr = "left arm";
+					break;
+				case HITGROUP_RIGHTARM:
+					hitgroupStr = "right arm";
+					break;
+				case HITGROUP_LEFTLEG:
+					hitgroupStr = "left leg";
+					break;
+				case HITGROUP_RIGHTLEG:
+					hitgroupStr = "right leg";
+					break;
+				}
+
+				UTIL_LogPrintf( "\"%s<%i><%s><%s>\" attacked \"%s<%i><%s><%s>\" with \"%s\" (damage \"%d\") (damage_armor \"%d\") (health \"%d\") (armor \"%d\") (hitgroup \"%s\")\n",  
+					pAttacker->GetPlayerName(),
+					attackerid,
+					pAttacker->GetNetworkIDString(),
+					pAttacker->GetTeam()->GetName(),
+					pPlayer->GetPlayerName(),
+					userid,
+					pPlayer->GetNetworkIDString(),
+					pPlayer->GetTeam()->GetName(),
+					weapon,
+					event->GetInt( "dmg_health" ),
+					event->GetInt( "dmg_armor" ),
+					event->GetInt( "health" ),
+					event->GetInt( "armor" ),
+					hitgroupStr );
+			}
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "player_death", Q_strlen("player_death") ) )
+		{
+			const int attackerid = event->GetInt("attacker" );
+			const char *weapon = event->GetString( "weapon" );
+			const bool headShot = (event->GetInt( "headshot" ) == 1);
+			CBasePlayer *pAttacker = UTIL_PlayerByUserId( attackerid );
+
+			if ( pPlayer == pAttacker )  
+			{  
+				UTIL_LogPrintf( "\"%s<%i><%s><%s>\" committed suicide with \"%s\"\n",  
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString(),
+								pPlayer->GetTeam()->GetName(),
+								weapon
+								);
+			}
+			else if ( pAttacker )
+			{
+				UTIL_LogPrintf( "\"%s<%i><%s><%s>\" killed \"%s<%i><%s><%s>\" with \"%s\"%s\n",  
+								pAttacker->GetPlayerName(),
+								attackerid,
+								pAttacker->GetNetworkIDString(),
+								pAttacker->GetTeam()->GetName(),
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString(),
+								pPlayer->GetTeam()->GetName(),
+								weapon,
+								headShot ? " (headshot)":""
+								);								
+			}
+			else
+			{  
+				// killed by the world
+				UTIL_LogPrintf( "\"%s<%i><%s><%s>\" committed suicide with \"world\"\n",
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString(),
+								pPlayer->GetTeam()->GetName()
+								);
+			}
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "round_start", Q_strlen("round_start") ) )
+		{
+			UTIL_LogPrintf("World triggered \"Round_Start\"\n");
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "hostage_follows", Q_strlen("hostage_follows") ) )
+		{
+			UTIL_LogPrintf( "\"%s<%i><%s><CT>\" triggered \"Touched_A_Hostage\"\n",
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString()
+								);
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "hostage_killed", Q_strlen("hostage_killed") ) )
+		{
+			UTIL_LogPrintf( "\"%s<%i><%s><%s>\" triggered \"Killed_A_Hostage\"\n", 
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString(),
+								pPlayer->GetTeam()->GetName()
+								);
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "hostage_rescued", Q_strlen("hostage_rescued") ) )
+		{
+			UTIL_LogPrintf("\"%s<%i><%s><CT>\" triggered \"Rescued_A_Hostage\"\n",
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString()
+								);
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "bomb_planted", Q_strlen("bomb_planted") ) )
+		{
+			UTIL_LogPrintf("\"%s<%i><%s><TERRORIST>\" triggered \"Planted_The_Bomb\"\n", 
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString()
+								);
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "bomb_defused", Q_strlen("bomb_defused") ) )
+		{
+			UTIL_LogPrintf("\"%s<%i><%s><CT>\" triggered \"Defused_The_Bomb\"\n", 
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString()
+								);
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "bomb_dropped", Q_strlen("bomb_dropped") ) )
+		{
+			UTIL_LogPrintf("\"%s<%i><%s><TERRORIST>\" triggered \"Dropped_The_Bomb\"\n", 
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString()
+								);
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "bomb_begindefuse", Q_strlen("bomb_begindefuse") ) )
+		{
+			const bool haskit = (event->GetInt( "haskit" ) == 1);
+			UTIL_LogPrintf("\"%s<%i><%s><CT>\" triggered \"%s\"\n", 
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString(),
+								haskit ? "Begin_Bomb_Defuse_With_Kit" : "Begin_Bomb_Defuse_Without_Kit"
+								);
+			return true;
+		}
+		else if ( !Q_strncmp( eventName, "bomb_pickup", Q_strlen("bomb_pickup") ) )
+		{
+			UTIL_LogPrintf("\"%s<%i><%s><TERRORIST>\" triggered \"Got_The_Bomb\"\n", 
+								pPlayer->GetPlayerName(),
+								userid,
+								pPlayer->GetNetworkIDString()
+								);
+			return true;
+		}	
+		
+// unused events:
+//hostage_hurt
+//bomb_exploded
+
+		return false;
+	}
+
+};
+
+CCSEventLog g_CSEventLog;
+
+//-----------------------------------------------------------------------------
+// Singleton access
+//-----------------------------------------------------------------------------
+IGameSystem* GameLogSystem()
+{
+	return &g_CSEventLog;
+}
+
diff --git a/game/server/cstrike/cs_gameinterface.cpp b/game/server/cstrike/cs_gameinterface.cpp
new file mode 100644
index 00000000..869dc640
--- /dev/null
+++ b/game/server/cstrike/cs_gameinterface.cpp
@@ -0,0 +1,40 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "gameinterface.h"
+#include "mapentities.h"
+#include "cs_gameinterface.h"
+#include "AI_ResponseSystem.h"
+
+// -------------------------------------------------------------------------------------------- //
+// Mod-specific CServerGameClients implementation.
+// -------------------------------------------------------------------------------------------- //
+
+void CServerGameClients::GetPlayerLimits( int& minplayers, int& maxplayers, int &defaultMaxPlayers ) const
+{
+	minplayers = 1;  // allow single player for the test maps (but we default to multi)
+	maxplayers = MAX_PLAYERS;
+	
+	defaultMaxPlayers = 32;	// Default to 32 players unless they change it.
+}
+
+
+// -------------------------------------------------------------------------------------------- //
+// Mod-specific CServerGameDLL implementation.
+// -------------------------------------------------------------------------------------------- //
+
+void CServerGameDLL::LevelInit_ParseAllEntities( const char *pMapEntities )
+{
+	if ( Q_strcmp( STRING(gpGlobals->mapname), "cs_" ) )
+	{
+		// don't precache AI responses (hostages) if it's not a hostage rescure map
+		extern IResponseSystem *g_pResponseSystem;
+		g_pResponseSystem->PrecacheResponses( false );	
+	}
+}
+	
+
diff --git a/game/server/cstrike/cs_gameinterface.h b/game/server/cstrike/cs_gameinterface.h
new file mode 100644
index 00000000..df3d0285
--- /dev/null
+++ b/game/server/cstrike/cs_gameinterface.h
@@ -0,0 +1,14 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef CS_GAMEINTERFACE_H
+#define CS_GAMEINTERFACE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#endif // CS_GAMEINTERFACE_H
diff --git a/game/server/cstrike/cs_gamestats.cpp b/game/server/cstrike/cs_gamestats.cpp
new file mode 100644
index 00000000..afb02a0f
--- /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 );
+		}
+	}
+}
diff --git a/game/server/cstrike/cs_gamestats.h b/game/server/cstrike/cs_gamestats.h
new file mode 100644
index 00000000..4a24efb3
--- /dev/null
+++ b/game/server/cstrike/cs_gamestats.h
@@ -0,0 +1,340 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The CS game stats header
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_GAMESTATS_H
+#define CS_GAMESTATS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cs_blackmarket.h"
+#include "gamestats.h"
+#include "cs_gamestats_shared.h"
+#include "GameEventListener.h"
+#include "steamworks_gamestats.h"
+#include "weapon_csbase.h"
+
+// forward declares
+class CBreakableProp;
+
+#define CS_STATS_BLOB_VERSION 3
+
+const float cDisseminationTimeHigh = 0.25f;		// Time interval for high priority stats sent to the player
+const float cDisseminationTimeLow = 2.5f;	// Time interval for medium priority stats sent to the player
+
+int GetCSLevelIndex( const char *pLevelName );
+
+typedef struct
+{
+	char szGameName[8];
+	byte iVersion;
+	char szMapName[32];
+	char ipAddr[4];
+	short port;
+	int serverid;
+} gamestats_header_t;
+
+typedef struct
+{
+	gamestats_header_t	header;
+	short	iMinutesPlayed;
+
+	short	iTerroristVictories[CS_NUM_LEVELS];
+	short	iCounterTVictories[CS_NUM_LEVELS];
+	short	iBlackMarketPurchases[WEAPON_MAX];
+
+	short	iAutoBuyPurchases;
+	short	iReBuyPurchases;
+	short	iAutoBuyM4A1Purchases;
+	short	iAutoBuyAK47Purchases;
+	short	iAutoBuyFamasPurchases;
+	short	iAutoBuyGalilPurchases;
+	short	iAutoBuyVestHelmPurchases;
+	short	iAutoBuyVestPurchases;
+
+} cs_gamestats_t;
+
+extern short	g_iWeaponPurchases[WEAPON_MAX];
+extern float	g_flGameStatsUpdateTime;
+extern short	g_iTerroristVictories[CS_NUM_LEVELS];
+extern short	g_iCounterTVictories[CS_NUM_LEVELS];
+extern short	g_iWeaponPurchases[WEAPON_MAX];
+
+extern short	g_iAutoBuyPurchases;
+extern short	g_iReBuyPurchases;
+extern short	g_iAutoBuyM4A1Purchases;
+extern short	g_iAutoBuyAK47Purchases;
+extern short	g_iAutoBuyFamasPurchases;
+extern short	g_iAutoBuyGalilPurchases;
+extern short	g_iAutoBuyVestHelmPurchases;
+extern short	g_iAutoBuyVestPurchases;
+
+
+struct sHappyCamperSnipePosition
+{
+	sHappyCamperSnipePosition( int userid, Vector pos ) : m_iUserID(userid), m_vPos(pos) {}
+
+	int		m_iUserID;
+	Vector	m_vPos;
+};
+
+struct SMarketPurchases : public BaseStatData 
+{
+	SMarketPurchases( uint64 ulPlayerID, int iPrice, const char *pName ) : m_nPlayerID(ulPlayerID), ItemCost(iPrice)
+	{
+		if ( pName )
+		{
+			Q_strncpy( ItemID, pName, ARRAYSIZE(ItemID) );
+		}
+		else
+		{
+			Q_strncpy( ItemID, "unknown", ARRAYSIZE(ItemID) );
+		}
+	}
+	uint64	m_nPlayerID;
+	int		ItemCost;
+	char	ItemID[64];
+
+	BEGIN_STAT_TABLE( "CSSMarketPurchase" )
+		REGISTER_STAT( m_nPlayerID )
+		REGISTER_STAT( ItemCost )
+		REGISTER_STAT_STRING( ItemID )
+	END_STAT_TABLE()
+};
+typedef CUtlVector< SMarketPurchases* > VectorMarketPurchaseData;
+
+struct WeaponStats
+{
+	int shots;
+	int hits;
+	int kills;
+	int damage;
+};
+
+struct SCSSWeaponData : public BaseStatData 
+{
+	SCSSWeaponData( const char *pWeaponName, const WeaponStats &wpnData )
+	{
+		if ( pWeaponName )
+		{
+			Q_strncpy( WeaponID, pWeaponName, ARRAYSIZE(WeaponID) );
+		}
+		else
+		{
+			Q_strncpy( WeaponID, "unknown", ARRAYSIZE(WeaponID) );
+		}
+
+		Shots = wpnData.shots;
+		Hits = wpnData.hits;
+		Kills = wpnData.kills;
+		Damage = wpnData.damage;
+	}
+	
+	char	WeaponID[64];
+	int		Shots;
+	int		Hits;
+	int		Kills;
+	int		Damage;
+
+	BEGIN_STAT_TABLE( "CSSWeaponData" )
+		REGISTER_STAT_STRING( WeaponID )
+		REGISTER_STAT( Shots )
+		REGISTER_STAT( Hits )
+		REGISTER_STAT( Kills )
+		REGISTER_STAT( Damage )
+	END_STAT_TABLE()
+};
+typedef CUtlVector< SCSSWeaponData* > CSSWeaponData;
+
+struct SCSSDeathData : public BaseStatData
+{
+	SCSSDeathData( CBasePlayer *pVictim, const CTakeDamageInfo &info )
+	{
+		m_bUseGlobalData = false;
+
+		m_DeathPos = info.GetDamagePosition();
+		m_iVictimTeam = pVictim->GetTeamNumber();
+		
+		CCSPlayer *pCSPlayer = ToCSPlayer( info.GetAttacker() );
+		if ( pCSPlayer )
+		{
+			m_iKillerTeam = pCSPlayer->GetTeamNumber();
+		}
+		else
+		{
+			m_iKillerTeam = -1;
+		}
+
+		const char *pszWeaponName = info.GetInflictor() ? info.GetInflictor()->GetClassname() : "unknown";
+		
+		if ( pszWeaponName )
+		{
+			if ( V_strcmp(pszWeaponName, "player") == 0 )
+			{
+				// get the player's weapon
+				if ( pCSPlayer && pCSPlayer->GetActiveCSWeapon() )
+				{
+					pszWeaponName = pCSPlayer->GetActiveCSWeapon()->GetClassname();
+				}
+			}
+		}
+
+
+		m_uiDeathParam = WEAPON_NONE;
+		if ( (m_uiDeathParam = AliasToWeaponID( pszWeaponName )) == WEAPON_NONE )
+		{
+			m_uiDeathParam = AliasToWeaponID( pszWeaponName );
+		}
+
+		const char *pszMapName = gpGlobals->mapname.ToCStr() ? gpGlobals->mapname.ToCStr() : "unknown";
+		Q_strncpy( m_szMapName, pszMapName, ARRAYSIZE(m_szMapName) );
+	}
+	Vector	m_DeathPos;
+	int		m_iVictimTeam;
+	int		m_iKillerTeam;
+	int		m_iDamageType;
+	uint64	m_uiDeathParam;
+	char	m_szMapName[64];
+	
+	BEGIN_STAT_TABLE( "Deaths" )
+		REGISTER_STAT_NAMED( m_DeathPos.x, "XCoord" )
+		REGISTER_STAT_NAMED( m_DeathPos.y, "YCoord" )
+		REGISTER_STAT_NAMED( m_DeathPos.z, "ZCoord" )
+		REGISTER_STAT_NAMED( m_iVictimTeam, "Team" )
+		REGISTER_STAT_NAMED( m_iKillerTeam, "DeathCause" )
+		REGISTER_STAT_NAMED( m_uiDeathParam, "DeathParam" )
+		REGISTER_STAT_NAMED( m_szMapName, "DeathMap" )
+	END_STAT_TABLE()
+};
+typedef CUtlVector< SCSSDeathData* > CSSDeathData;
+
+//=============================================================================
+//
+// CS Game Stats Class
+//
+class CCSGameStats : public CBaseGameStats, public CGameEventListener, public CAutoGameSystemPerFrame, public IGameStatTracker
+{
+public:
+
+	// Constructor/Destructor.
+	CCSGameStats( void );
+	~CCSGameStats( void );
+
+	virtual void Clear( void );
+	virtual bool Init();
+	virtual void PreClientUpdate();
+	virtual void PostInit();
+	virtual void LevelShutdownPreClearSteamAPIContext();
+
+	void UploadRoundStats( void );
+	// Overridden events
+	virtual void Event_LevelInit( void );
+	virtual void Event_LevelShutdown( float flElapsed );
+	virtual void Event_ShotFired( CBasePlayer *pPlayer, CBaseCombatWeapon* pWeapon );
+	virtual void Event_ShotHit( CBasePlayer *pPlayer, const CTakeDamageInfo &info );
+	virtual void Event_PlayerKilled( CBasePlayer *pPlayer, const CTakeDamageInfo &info );
+	virtual void Event_PlayerKilled_PreWeaponDrop( CBasePlayer *pPlayer, const CTakeDamageInfo &info );
+	void UpdatePlayerRoundStats(int winner);
+	virtual void Event_PlayerConnected( CBasePlayer *pPlayer );
+	virtual void Event_PlayerDisconnected( CBasePlayer *pPlayer );
+	virtual void Event_WindowShattered( CBasePlayer *pPlayer );
+	virtual void Event_PlayerKilledOther( CBasePlayer *pAttacker, CBaseEntity *pVictim, const CTakeDamageInfo &info );
+			
+
+	// CSS specific events
+    void Event_BombPlanted( CCSPlayer *pPlayer );
+    void Event_BombDefused( CCSPlayer *pPlayer );
+	void Event_PlayerDamage( CBasePlayer *pBasePlayer, const CTakeDamageInfo &info );
+	void Event_BombExploded( CCSPlayer *pPlayer );
+	void Event_MoneyEarned( CCSPlayer *pPlayer, int moneyEarned );
+	void Event_MoneySpent( CCSPlayer *pPlayer, int moneySpent, const char *pItemName );
+    void Event_HostageRescued( CCSPlayer *pPlayer );
+    void Event_PlayerSprayedDecal( CCSPlayer*pPlayer );
+	void Event_AllHostagesRescued();
+	void Event_BreakProp( CCSPlayer *pPlayer, CBreakableProp *pProp );
+    void Event_PlayerDonatedWeapon (CCSPlayer* pPlayer);
+    void Event_PlayerDominatedOther( CCSPlayer* pAttacker, CCSPlayer* pVictim);
+    void Event_PlayerRevenge( CCSPlayer* pAttacker );
+    void Event_PlayerAvengedTeammate( CCSPlayer* pAttacker, CCSPlayer* pAvengedPlayer );
+	void Event_MVPEarned( CCSPlayer* pPlayer );	
+	void Event_KnifeUse( CCSPlayer* pPlayer, bool bStab, int iDamage );
+
+	virtual void FireGameEvent( IGameEvent *event );
+
+	void DumpMatchWeaponMetrics();
+
+	const PlayerStats_t&		FindPlayerStats( CBasePlayer *pPlayer ) const;
+	void						ResetPlayerStats( CBasePlayer *pPlayer );
+	void						ResetKillHistory( CBasePlayer *pPlayer );
+	void						ResetRoundStats();
+	void						ResetPlayerClassMatchStats();
+
+	const StatsCollection_t&	GetTeamStats( int iTeamIndex ) const;
+	void						ResetAllTeamStats();
+    void						ResetAllStats();
+	void						ResetWeaponStats();
+ 	void						IncrementTeamStat( int iTeamIndex, int iStatIndex, int iAmount );
+	void                        CalcDominationAndRevenge( CCSPlayer *pAttacker, CCSPlayer *pVictim, int *piDeathFlags );
+    void                        CalculateOverkill( CCSPlayer* pAttacker, CCSPlayer* pVictim );
+	void						PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+
+	void						IncrementStat( CCSPlayer* pPlayer, CSStatType_t statId, int iValue, bool bPlayerOnly = false );
+	// Steamworks Gamestats 
+	virtual void SubmitGameStats( KeyValues *pKV );
+
+	virtual StatContainerList_t* GetStatContainerList( void )
+	{
+		return s_StatLists;
+	}
+
+protected:	
+	void						SetStat( CCSPlayer *pPlayer, CSStatType_t statId, int iValue );
+    void						TrackKillStats( CCSPlayer *pAttacker, CCSPlayer *pVictim );
+    void                        ComputeRollingStatAverages();
+	void                        ComputeDirectStatAverages();
+    void                        SendRollingStatsAveragesToAllPlayers();
+	void                        SendDirectStatsAveragesToAllPlayers();
+	void						SendStatsToPlayer( CCSPlayer * pPlayer, int iMinStatPriority );
+
+private:
+	PlayerStats_t				m_aPlayerStats[MAX_PLAYERS+1];	// List of stats for each player for current life - reset after each death    
+	StatsCollection_t			m_aTeamStats[TEAM_MAXCOUNT - FIRST_GAME_TEAM];
+
+    RoundStatsRollingAverage_t  m_rollingCTStatAverages;	
+    RoundStatsRollingAverage_t  m_rollingTStatAverages;	
+    RoundStatsRollingAverage_t	m_rollingPlayerStatAverages;	
+
+	RoundStatsDirectAverage_t	m_directCTStatAverages;
+	RoundStatsDirectAverage_t	m_directTStatAverages;
+	RoundStatsDirectAverage_t	m_directPlayerStatAverages;
+
+	float						m_fDisseminationTimerLow;		// how long since last medium priority stat update
+	float						m_fDisseminationTimerHigh;		// how long since last high priority stat update
+
+	int							m_numberOfRoundsForDirectAverages;
+	int							m_numberOfTerroristEntriesForDirectAverages;
+	int							m_numberOfCounterTerroristEntriesForDirectAverages;
+
+	CUtlDict< CSStatType_t, short >	m_PropStatTable;
+
+	CUtlLinkedList<sHappyCamperSnipePosition, int>		m_PlayerSnipedPosition;
+	WeaponStats					m_weaponStats[WEAPON_MAX][2];
+	
+	// Steamworks Gamestats
+	VectorMarketPurchaseData	m_MarketPurchases;
+	CSSWeaponData				m_WeaponData;
+	CSSDeathData				m_DeathData;
+
+	// A static list of all the stat containers, one for each data structure being tracked
+	static StatContainerList_t * s_StatLists;
+
+	bool						m_bInRound;
+};
+
+extern CCSGameStats CCS_GameStats;
+
+#endif // CS_GAMESTATS_H
diff --git a/game/server/cstrike/cs_hltvdirector.cpp b/game/server/cstrike/cs_hltvdirector.cpp
new file mode 100644
index 00000000..30f451aa
--- /dev/null
+++ b/game/server/cstrike/cs_hltvdirector.cpp
@@ -0,0 +1,149 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "hltvdirector.h"
+#include "igameevents.h"
+
+class CCSHLTVDirector : public CHLTVDirector
+{
+public:
+	DECLARE_CLASS( CCSHLTVDirector, CHLTVDirector );
+
+	const char** GetModEvents();
+	void SetHLTVServer( IHLTVServer *hltv );
+	void CreateShotFromEvent( CHLTVGameEvent *event );
+
+};
+
+void CCSHLTVDirector::SetHLTVServer( IHLTVServer *hltv )
+{
+	BaseClass::SetHLTVServer( hltv );
+
+	if ( m_pHLTVServer )
+	{
+		// mod specific events the director uses to find interesting shots
+		ListenForGameEvent( "hostage_rescued" );
+		ListenForGameEvent( "hostage_killed" );
+		ListenForGameEvent( "hostage_hurt" );
+		ListenForGameEvent( "hostage_follows" );
+		ListenForGameEvent( "bomb_pickup" );
+		ListenForGameEvent( "bomb_dropped" );
+		ListenForGameEvent( "bomb_exploded" );
+		ListenForGameEvent( "bomb_defused" );
+		ListenForGameEvent( "bomb_planted" );
+		ListenForGameEvent( "vip_escaped" );
+		ListenForGameEvent( "vip_killed" );
+	}
+}
+
+void CCSHLTVDirector::CreateShotFromEvent( CHLTVGameEvent *event )
+{
+	// show event at least for 2 more seconds after it occured
+	const char *name = event->m_Event->GetName();
+	IGameEvent *shot = NULL;
+
+	if ( !Q_strcmp( "hostage_rescued", name ) ||
+		 !Q_strcmp( "hostage_hurt", name ) ||
+		 !Q_strcmp( "hostage_follows", name ) ||
+		 !Q_strcmp( "hostage_killed", name ) )
+	{
+		CBaseEntity *player = UTIL_PlayerByUserId( event->m_Event->GetInt("userid") );
+		
+		if ( !player )
+			return;
+
+		// shot player as primary, hostage as secondary target
+		shot = gameeventmanager->CreateEvent( "hltv_chase", true );
+		shot->SetInt( "target1", player->entindex() );
+		shot->SetInt( "target2", event->m_Event->GetInt("hostage") );
+		shot->SetFloat( "distance", 96.0f );
+		shot->SetInt( "theta", 40 );
+		shot->SetInt( "phi", 20 );
+
+		// shot 2 seconds after event
+		m_nNextShotTick = MIN( m_nNextShotTick, (event->m_Tick+TIME_TO_TICKS(2.0)) );
+		m_iPVSEntity = player->entindex();
+	}
+
+	else if ( !Q_strcmp( "bomb_pickup", name ) ||
+		!Q_strcmp( "bomb_dropped", name ) ||
+		!Q_strcmp( "bomb_planted", name ) ||
+		!Q_strcmp( "bomb_defused", name ) )
+	{
+		CBaseEntity *player = UTIL_PlayerByUserId( event->m_Event->GetInt("userid") );
+
+		if ( !player )
+			return;
+
+		shot = gameeventmanager->CreateEvent( "hltv_chase", true );
+		shot->SetInt( "target1", player->entindex() );
+		shot->SetInt( "target2", 0 );
+		shot->SetFloat( "distance", 64.0f );
+		shot->SetInt( "theta", 200 );
+		shot->SetInt( "phi", 10 );
+
+		// shot 2 seconds after pickup
+		m_nNextShotTick = MIN( m_nNextShotTick, (event->m_Tick+TIME_TO_TICKS(2.0)) );
+		m_iPVSEntity = player->entindex();
+	}
+	else
+	{
+		// let baseclass create a shot
+		BaseClass::CreateShotFromEvent( event );
+
+		return;
+	}
+
+	if ( shot )
+	{
+		m_pHLTVServer->BroadcastEvent( shot );
+		gameeventmanager->FreeEvent( shot );
+		DevMsg("DrcCmd: %s\n", name );
+	}
+}
+
+const char** CCSHLTVDirector::GetModEvents()
+{
+	// game events relayed to spectator clients
+	static const char *s_modevents[] =
+	{
+		"hltv_status",
+		"hltv_chat",
+		"player_connect",
+		"player_disconnect",
+		"player_team",
+		"player_info",
+		"server_cvar",
+		"player_death",
+		"player_chat",
+		"round_start",
+		"round_end",
+		// additional CS:S events:
+		"bomb_planted",	
+		"bomb_defused",
+		"hostage_killed",
+		"hostage_hurt",		
+		NULL
+	};
+
+	return s_modevents;
+}
+
+static CCSHLTVDirector s_HLTVDirector;	// singleton
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CHLTVDirector, IHLTVDirector, INTERFACEVERSION_HLTVDIRECTOR, s_HLTVDirector );
+
+CHLTVDirector* HLTVDirector()
+{
+	return &s_HLTVDirector;
+}
+
+IGameSystem* HLTVDirectorSystem()
+{
+	return &s_HLTVDirector;
+}
\ No newline at end of file
diff --git a/game/server/cstrike/cs_nav.h b/game/server/cstrike/cs_nav.h
new file mode 100644
index 00000000..f37b90d1
--- /dev/null
+++ b/game/server/cstrike/cs_nav.h
@@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav.h
+// Data structures and constants for the Navigation Mesh system
+// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
+
+#ifndef _CS_NAV_H_
+#define _CS_NAV_H_
+
+#include "nav.h"
+
+/**
+ * Below are several constants used by the navigation system.
+ * @todo Move these into TheNavMesh singleton.
+ */
+const float BotRadius = 10.0f;				///< circular extent that contains bot
+
+class CNavArea;
+class CSNavNode;
+
+#if 0
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if given entity can be ignored when moving
+ */
+#define WALK_THRU_DOORS				0x01
+#define WALK_THRU_BREAKABLES		0x02
+#define WALK_THRU_TOGGLE_BRUSHES	0x04
+#define WALK_THRU_EVERYTHING		(WALK_THRU_DOORS | WALK_THRU_BREAKABLES | WALK_THRU_TOGGLE_BRUSHES)
+inline bool IsEntityWalkable( CBaseEntity *entity, unsigned int flags )
+{
+	if (FClassnameIs( entity, "worldspawn" ))
+		return false;
+
+	if (FClassnameIs( entity, "player" ))
+		return false;
+
+	// if we hit a door, assume its walkable because it will open when we touch it
+	if (FClassnameIs( entity, "prop_door*" ) || FClassnameIs( entity, "func_door*" ))
+		return (flags & WALK_THRU_DOORS) ? true : false;
+
+	// if we hit a clip brush, ignore it if it is not BRUSHSOLID_ALWAYS
+	if (FClassnameIs( entity, "func_brush" ))
+	{
+		CFuncBrush *brush = (CFuncBrush *)entity;
+		switch ( brush->m_iSolidity )
+		{
+		case CFuncBrush::BRUSHSOLID_ALWAYS:
+			return false;
+		case CFuncBrush::BRUSHSOLID_NEVER:
+			return true;
+		case CFuncBrush::BRUSHSOLID_TOGGLE:
+			return (flags & WALK_THRU_TOGGLE_BRUSHES) ? true : false;
+		}
+	}
+
+	// if we hit a breakable object, assume its walkable because we will shoot it when we touch it
+	if (FClassnameIs( entity, "func_breakable" ) && entity->GetHealth() && entity->m_takedamage == DAMAGE_YES)
+		return (flags & WALK_THRU_BREAKABLES) ? true : false;
+
+	if (FClassnameIs( entity, "func_breakable_surf" ) && entity->m_takedamage == DAMAGE_YES)
+		return (flags & WALK_THRU_BREAKABLES) ? true : false;
+
+	return false;
+}
+#endif
+
+#endif // _CS_NAV_H_
diff --git a/game/server/cstrike/cs_nav_area.cpp b/game/server/cstrike/cs_nav_area.cpp
new file mode 100644
index 00000000..b1a24647
--- /dev/null
+++ b/game/server/cstrike/cs_nav_area.cpp
@@ -0,0 +1,473 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_area.cpp
+// AI Navigation areas
+// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
+
+#include "cbase.h"
+#include "cs_nav_mesh.h"
+#include "cs_nav_area.h"
+#include "nav_pathfind.h"
+#include "nav_colors.h"
+#include "fmtstr.h"
+#include "props_shared.h"
+#include "func_breakablesurf.h"
+#include "Color.h"
+#include "collisionutils.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include <tier0/memdbgon.h>
+
+#ifdef _WIN32
+#pragma warning (disable:4701)				// disable warning that variable *may* not be initialized 
+#endif
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Constructor used during normal runtime.
+ */
+CCSNavArea::CCSNavArea( void )
+{
+	m_approachCount = 0;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Destructor
+ */
+CCSNavArea::~CCSNavArea()
+{
+}
+
+
+void CCSNavArea::OnServerActivate( void )
+{
+	CNavArea::OnServerActivate();
+
+}
+
+void CCSNavArea::OnRoundRestart( void )
+{
+	CNavArea::OnRoundRestart();
+}
+
+
+void CCSNavArea::Save( CUtlBuffer &fileBuffer, unsigned int version ) const
+{
+	CNavArea::Save( fileBuffer, version );
+
+	//
+	// Save the approach areas for this area
+	//
+
+	// save number of approach areas
+	fileBuffer.PutUnsignedChar(m_approachCount);
+
+	// save approach area info
+	for( int a=0; a<m_approachCount; ++a )
+	{
+		if (m_approach[a].here.area)
+			fileBuffer.PutUnsignedInt(m_approach[a].here.area->GetID());
+		else
+			fileBuffer.PutUnsignedInt(0);
+
+		if (m_approach[a].prev.area)
+			fileBuffer.PutUnsignedInt(m_approach[a].prev.area->GetID());
+		else
+			fileBuffer.PutUnsignedInt(0);
+		fileBuffer.PutUnsignedChar(m_approach[a].prevToHereHow);
+
+		if (m_approach[a].next.area)
+			fileBuffer.PutUnsignedInt(m_approach[a].next.area->GetID());
+		else
+			fileBuffer.PutUnsignedInt(0);
+		fileBuffer.PutUnsignedChar(m_approach[a].hereToNextHow);
+	}
+}
+
+NavErrorType CCSNavArea::Load( CUtlBuffer &fileBuffer, unsigned int version, unsigned int subVersion )
+{
+	if ( version < 15 )
+		return LoadLegacy(fileBuffer, version, subVersion);
+
+	// load base class data
+	NavErrorType error = CNavArea::Load( fileBuffer, version, subVersion );
+
+	switch ( subVersion )
+	{
+	case 1:
+		//
+		// Load number of approach areas
+		//
+		m_approachCount = fileBuffer.GetUnsignedChar();
+
+		// load approach area info (IDs)
+		for( int a = 0; a < m_approachCount; ++a )
+		{
+			m_approach[a].here.id = fileBuffer.GetUnsignedInt();
+
+			m_approach[a].prev.id = fileBuffer.GetUnsignedInt();
+			m_approach[a].prevToHereHow = (NavTraverseType)fileBuffer.GetUnsignedChar();
+
+			m_approach[a].next.id = fileBuffer.GetUnsignedInt();
+			m_approach[a].hereToNextHow = (NavTraverseType)fileBuffer.GetUnsignedChar();
+		}
+
+		if ( !fileBuffer.IsValid() )
+			error = NAV_INVALID_FILE;
+
+		// fall through
+
+	case 0:
+		// legacy version
+		break;
+
+	default:
+		Warning( "Unknown NavArea sub-version number\n" );
+		error = NAV_INVALID_FILE;
+	}
+
+	return error;
+}
+
+
+NavErrorType CCSNavArea::PostLoad( void )
+{
+	NavErrorType error = CNavArea::PostLoad();
+
+	// resolve approach area IDs
+	for ( int a = 0; a < m_approachCount; ++a )
+	{
+		m_approach[a].here.area = TheNavMesh->GetNavAreaByID( m_approach[a].here.id );
+		if (m_approach[a].here.id && m_approach[a].here.area == NULL)
+		{
+			Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing Approach Area (here).\n" );
+			error = NAV_CORRUPT_DATA;
+		}
+
+		m_approach[a].prev.area = TheNavMesh->GetNavAreaByID( m_approach[a].prev.id );
+		if (m_approach[a].prev.id && m_approach[a].prev.area == NULL)
+		{
+			Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing Approach Area (prev).\n" );
+			error = NAV_CORRUPT_DATA;
+		}
+
+		m_approach[a].next.area = TheNavMesh->GetNavAreaByID( m_approach[a].next.id );
+		if (m_approach[a].next.id && m_approach[a].next.area == NULL)
+		{
+			Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing Approach Area (next).\n" );
+			error = NAV_CORRUPT_DATA;
+		}
+	}
+	return error;
+}
+
+
+void CCSNavArea::Draw( void ) const
+{
+	CNavArea::Draw();
+}
+
+void CCSNavArea::CustomAnalysis( bool isIncremental /*= false */ )
+{
+	ComputeApproachAreas();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Load legacy navigation area from the file
+ */
+NavErrorType CCSNavArea::LoadLegacy( CUtlBuffer &fileBuffer, unsigned int version, unsigned int subVersion )
+{
+	// load ID
+	m_id = fileBuffer.GetUnsignedInt();
+
+	// update nextID to avoid collisions
+	if (m_id >= m_nextID)
+		m_nextID = m_id+1;
+
+	// load attribute flags
+	if ( version <= 8 )
+	{
+		m_attributeFlags = fileBuffer.GetUnsignedChar();
+	}
+	else if ( version < 13 )
+	{
+		m_attributeFlags = fileBuffer.GetUnsignedShort();
+	}
+	else
+	{
+		m_attributeFlags = fileBuffer.GetInt();
+	}
+
+	// load extent of area
+	fileBuffer.Get( &m_nwCorner, 3*sizeof(float) );
+	fileBuffer.Get( &m_seCorner, 3*sizeof(float) );
+
+	m_center.x = (m_nwCorner.x + m_seCorner.x)/2.0f;
+	m_center.y = (m_nwCorner.y + m_seCorner.y)/2.0f;
+	m_center.z = (m_nwCorner.z + m_seCorner.z)/2.0f;
+
+	if ( ( m_seCorner.x - m_nwCorner.x ) > 0.0f && ( m_seCorner.y - m_nwCorner.y ) > 0.0f )
+	{
+		m_invDxCorners = 1.0f / ( m_seCorner.x - m_nwCorner.x );
+		m_invDyCorners = 1.0f / ( m_seCorner.y - m_nwCorner.y );
+	}
+	else
+	{
+		m_invDxCorners = m_invDyCorners = 0;
+
+		DevWarning( "Degenerate Navigation Area #%d at setpos %g %g %g\n", 
+			m_id, m_center.x, m_center.y, m_center.z );
+	}
+
+	// load heights of implicit corners
+	m_neZ = fileBuffer.GetFloat();
+	m_swZ = fileBuffer.GetFloat();
+
+	CheckWaterLevel();
+
+	// load connections (IDs) to adjacent areas
+	// in the enum order NORTH, EAST, SOUTH, WEST
+	for( int d=0; d<NUM_DIRECTIONS; d++ )
+	{
+		// load number of connections for this direction
+		unsigned int count = fileBuffer.GetUnsignedInt();
+		Assert( fileBuffer.IsValid() );
+
+		m_connect[d].EnsureCapacity( count );
+		for( unsigned int i=0; i<count; ++i )
+		{
+			NavConnect connect;
+			connect.id = fileBuffer.GetUnsignedInt();
+			Assert( fileBuffer.IsValid() );
+
+			// don't allow self-referential connections
+			if ( connect.id != m_id )
+			{
+				m_connect[d].AddToTail( connect );
+			}
+		}
+	}
+
+	//
+	// Load hiding spots
+	//
+
+	// load number of hiding spots
+	unsigned char hidingSpotCount = fileBuffer.GetUnsignedChar();
+
+	if (version == 1)
+	{
+		// load simple vector array
+		Vector pos;
+		for( int h=0; h<hidingSpotCount; ++h )
+		{
+			fileBuffer.Get( &pos, 3 * sizeof(float) );
+
+			// create new hiding spot and put on master list
+			HidingSpot *spot = TheNavMesh->CreateHidingSpot();
+			spot->SetPosition( pos );
+			spot->SetFlags( HidingSpot::IN_COVER );
+			m_hidingSpots.AddToTail( spot );
+		}
+	}
+	else
+	{
+		// load HidingSpot objects for this area
+		for( int h=0; h<hidingSpotCount; ++h )
+		{
+			// create new hiding spot and put on master list
+			HidingSpot *spot = TheNavMesh->CreateHidingSpot();
+
+			spot->Load( fileBuffer, version );
+			
+			m_hidingSpots.AddToTail( spot );
+		}
+	}
+
+	if ( version < 15 )
+	{
+		//
+		// Load number of approach areas
+		//
+		m_approachCount = fileBuffer.GetUnsignedChar();
+
+		// load approach area info (IDs)
+		for( int a = 0; a < m_approachCount; ++a )
+		{
+			m_approach[a].here.id = fileBuffer.GetUnsignedInt();
+
+			m_approach[a].prev.id = fileBuffer.GetUnsignedInt();
+			m_approach[a].prevToHereHow = (NavTraverseType)fileBuffer.GetUnsignedChar();
+
+			m_approach[a].next.id = fileBuffer.GetUnsignedInt();
+			m_approach[a].hereToNextHow = (NavTraverseType)fileBuffer.GetUnsignedChar();
+		}
+	}
+
+
+	//
+	// Load encounter paths for this area
+	//
+	unsigned int count = fileBuffer.GetUnsignedInt();
+
+	if (version < 3)
+	{
+		// old data, read and discard
+		for( unsigned int e=0; e<count; ++e )
+		{
+			SpotEncounter encounter;
+
+			encounter.from.id = fileBuffer.GetUnsignedInt();
+			encounter.to.id = fileBuffer.GetUnsignedInt();
+
+			fileBuffer.Get( &encounter.path.from.x, 3 * sizeof(float) );
+			fileBuffer.Get( &encounter.path.to.x, 3 * sizeof(float) );
+
+			// read list of spots along this path
+			unsigned char spotCount = fileBuffer.GetUnsignedChar();
+		
+			for( int s=0; s<spotCount; ++s )
+			{
+				fileBuffer.GetFloat();
+				fileBuffer.GetFloat();
+				fileBuffer.GetFloat();
+				fileBuffer.GetFloat();
+			}
+		}
+		return NAV_OK;
+	}
+
+	for( unsigned int e=0; e<count; ++e )
+	{
+		SpotEncounter *encounter = new SpotEncounter;
+
+		encounter->from.id = fileBuffer.GetUnsignedInt();
+
+		unsigned char dir = fileBuffer.GetUnsignedChar();
+		encounter->fromDir = static_cast<NavDirType>( dir );
+
+		encounter->to.id = fileBuffer.GetUnsignedInt();
+
+		dir = fileBuffer.GetUnsignedChar();
+		encounter->toDir = static_cast<NavDirType>( dir );
+
+		// read list of spots along this path
+		unsigned char spotCount = fileBuffer.GetUnsignedChar();
+	
+		SpotOrder order;
+		for( int s=0; s<spotCount; ++s )
+		{
+			order.id = fileBuffer.GetUnsignedInt();
+
+			unsigned char t = fileBuffer.GetUnsignedChar();
+
+			order.t = (float)t/255.0f;
+
+			encounter->spots.AddToTail( order );
+		}
+
+		m_spotEncounters.AddToTail( encounter );
+	}
+
+	if (version < 5)
+		return NAV_OK;
+
+	//
+	// Load Place data
+	//
+	PlaceDirectory::IndexType entry = fileBuffer.GetUnsignedShort();
+
+	// convert entry to actual Place
+	SetPlace( placeDirectory.IndexToPlace( entry ) );
+
+	if ( version < 7 )
+		return NAV_OK;
+
+	// load ladder data
+	for ( int dir=0; dir<CNavLadder::NUM_LADDER_DIRECTIONS; ++dir )
+	{
+		count = fileBuffer.GetUnsignedInt();
+		for( unsigned int i=0; i<count; ++i )
+		{
+			NavLadderConnect connect;
+			connect.id = fileBuffer.GetUnsignedInt();
+
+			bool alreadyConnected = false;
+			FOR_EACH_VEC( m_ladder[dir], j )
+			{
+				if ( m_ladder[dir][j].id == connect.id )
+				{
+					alreadyConnected = true;
+					break;
+				}
+			}
+
+			if ( !alreadyConnected )
+			{
+				m_ladder[dir].AddToTail( connect );
+			}
+		}
+	}
+
+	if ( version < 8 )
+		return NAV_OK;
+
+	// load earliest occupy times
+	for( int i=0; i<MAX_NAV_TEAMS; ++i )
+	{
+		// no spot in the map should take longer than this to reach
+		m_earliestOccupyTime[i] = fileBuffer.GetFloat();
+	}
+
+	if ( version < 11 )
+		return NAV_OK;
+
+	// load light intensity
+	for ( int i=0; i<NUM_CORNERS; ++i )
+	{
+		m_lightIntensity[i] = fileBuffer.GetFloat();
+	}
+
+	if ( version < 16 )
+		return NAV_OK;
+
+	// load visibility information
+	unsigned int visibleAreaCount = fileBuffer.GetUnsignedInt();
+	if ( !IsX360() )
+	{
+		m_potentiallyVisibleAreas.EnsureCapacity( visibleAreaCount );
+	}
+	else
+	{
+/* TODO: Re-enable when latest 360 code gets integrated (MSB 5/5/09)
+		size_t nBytes = visibleAreaCount * sizeof( AreaBindInfo ); 
+		m_potentiallyVisibleAreas.~CAreaBindInfoArray();
+		new ( &m_potentiallyVisibleAreas ) CAreaBindInfoArray( (AreaBindInfo *)engine->AllocLevelStaticData( nBytes ), visibleAreaCount );
+*/
+	}
+
+	for( unsigned int j=0; j<visibleAreaCount; ++j )
+	{
+		AreaBindInfo info;
+		info.id = fileBuffer.GetUnsignedInt();
+		info.attributes = fileBuffer.GetUnsignedChar();
+
+		m_potentiallyVisibleAreas.AddToTail( info );
+	}
+
+	// read area from which we inherit visibility
+	m_inheritVisibilityFrom.id = fileBuffer.GetUnsignedInt();
+
+	return NAV_OK;
+}
+
+
diff --git a/game/server/cstrike/cs_nav_area.h b/game/server/cstrike/cs_nav_area.h
new file mode 100644
index 00000000..e8d913c5
--- /dev/null
+++ b/game/server/cstrike/cs_nav_area.h
@@ -0,0 +1,81 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_area.h
+// Navigation areas
+// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
+
+#ifndef _CS_NAV_AREA_H_
+#define _CS_NAV_AREA_H_
+
+#include "nav_area.h"
+
+//-------------------------------------------------------------------------------------------------------------------
+/**
+ * A CNavArea is a rectangular region defining a walkable area in the environment
+ */
+class CCSNavArea : public CNavArea
+{
+public:
+	DECLARE_CLASS( CCSNavArea, CNavArea );
+
+	CCSNavArea( void );
+	~CCSNavArea();
+
+	virtual void OnServerActivate( void );						// (EXTEND) invoked when map is initially loaded
+	virtual void OnRoundRestart( void );						// (EXTEND) invoked for each area when the round restarts
+
+	virtual void Draw( void ) const;							// draw area for debugging & editing
+
+	virtual void Save( CUtlBuffer &fileBuffer, unsigned int version ) const;	// (EXTEND)
+	virtual NavErrorType Load( CUtlBuffer &fileBuffer, unsigned int version, unsigned int subVersion );		// (EXTEND)
+	virtual NavErrorType PostLoad( void );								// (EXTEND) invoked after all areas have been loaded - for pointer binding, etc
+
+	virtual void CustomAnalysis( bool isIncremental = false );		// for game-specific analysis
+
+	//- approach areas ----------------------------------------------------------------------------------
+	struct ApproachInfo
+	{
+		NavConnect here;										///< the approach area
+		NavConnect prev;										///< the area just before the approach area on the path
+		NavTraverseType prevToHereHow;
+		NavConnect next;										///< the area just after the approach area on the path
+		NavTraverseType hereToNextHow;
+	};
+	const ApproachInfo *GetApproachInfo( int i ) const	{ return &m_approach[i]; }
+	int GetApproachInfoCount( void ) const				{ return m_approachCount; }
+	void ComputeApproachAreas( void );							///< determine the set of "approach areas" - for map learning
+
+	//- player counting --------------------------------------------------------------------------------
+	void ClearPlayerCount( void );								///< set the player count to zero
+
+protected:
+	NavErrorType LoadLegacy( CUtlBuffer &fileBuffer, unsigned int version, unsigned int subVersion );
+
+
+private:
+	//- approach areas ----------------------------------------------------------------------------------
+	enum { MAX_APPROACH_AREAS = 16 };
+	ApproachInfo m_approach[ MAX_APPROACH_AREAS ];
+	unsigned char m_approachCount;
+};
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+//
+// Inlines
+//
+
+inline void CCSNavArea::ClearPlayerCount( void )
+{
+	for( int i=0; i<MAX_NAV_TEAMS; ++i )
+	{
+		m_playerCount[ i ] = 0;
+	}
+}
+
+#endif // _CS_NAV_AREA_H_
diff --git a/game/server/cstrike/cs_nav_edit.cpp b/game/server/cstrike/cs_nav_edit.cpp
new file mode 100644
index 00000000..b49bd230
--- /dev/null
+++ b/game/server/cstrike/cs_nav_edit.cpp
@@ -0,0 +1,69 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_edit.cpp
+// Implementation of Navigation Mesh edit mode
+// Author: Michael Booth, 2003-2004
+
+#include "cbase.h"
+#include "nav_mesh.h"
+#include "cs_nav_pathfind.h"
+#include "cs_nav_node.h"
+#include "nav_colors.h"
+#include "Color.h"
+#include "tier0/vprof.h"
+#include "collisionutils.h"
+
+ConVar nav_show_area_info( "nav_show_area_info", "0.5", FCVAR_GAMEDLL, "Duration in seconds to show nav area ID and attributes while editing" );
+ConVar nav_snap_to_grid( "nav_snap_to_grid", "0", FCVAR_GAMEDLL, "Snap to the nav generation grid when creating new nav areas" );
+ConVar nav_create_place_on_ground( "nav_create_place_on_ground", "0", FCVAR_GAMEDLL, "If true, nav areas will be placed flush with the ground when created by hand." );
+
+#if DEBUG_NAV_NODES
+extern ConVar nav_show_nodes;
+#endif // DEBUG_NAV_NODES
+
+
+//--------------------------------------------------------------------------------------------------------------
+void EditNav_Precache(void *pUser)
+{
+	CBaseEntity::PrecacheScriptSound( "Bot.EditSwitchOn" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_TOGGLE_PLACE_MODE" );
+	CBaseEntity::PrecacheScriptSound( "Bot.EditSwitchOff" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_PLACE_PICK" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_DELETE" );
+	CBaseEntity::PrecacheScriptSound( "EDIT.ToggleAttribute" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_SPLIT.MarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_SPLIT.NoMarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MERGE.Enable" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MERGE.Disable" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MARK.Enable" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MARK.Disable" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MARK_UNNAMED.Enable" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MARK_UNNAMED.NoMarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MARK_UNNAMED.MarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_CONNECT.AllDirections" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_CONNECT.Added" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_DISCONNECT.MarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_DISCONNECT.NoMarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_SPLICE.MarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_SPLICE.NoMarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_SELECT_CORNER.MarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_SELECT_CORNER.NoMarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MOVE_CORNER.MarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_MOVE_CORNER.NoMarkedArea" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_BEGIN_AREA.Creating" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_BEGIN_AREA.NotCreating" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_END_AREA.Creating" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_END_AREA.NotCreating" );
+	CBaseEntity::PrecacheScriptSound( "EDIT_WARP_TO_MARK" );
+}
+
+#ifdef CSTRIKE_DLL
+PRECACHE_REGISTER_FN( EditNav_Precache );
+#endif
+
+
diff --git a/game/server/cstrike/cs_nav_file.cpp b/game/server/cstrike/cs_nav_file.cpp
new file mode 100644
index 00000000..3b7db5d6
--- /dev/null
+++ b/game/server/cstrike/cs_nav_file.cpp
@@ -0,0 +1,1365 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_file.cpp
+// Reading and writing nav files
+// Author: Michael S. Booth (mike@turtlerockstudios.com), January-September 2003
+
+#include "cbase.h"
+#include "nav_mesh.h"
+
+#ifdef CSTRIKE_DLL
+#include "cs_shareddefs.h"
+#include "cs_nav_pathfind.h"
+#endif
+
+#if 0
+//--------------------------------------------------------------------------------------------------------------
+/// The current version of the nav file format
+const int NavCurrentVersion = 9;
+
+//--------------------------------------------------------------------------------------------------------------
+//
+// The 'place directory' is used to save and load places from
+// nav files in a size-efficient manner that also allows for the 
+// order of the place ID's to change without invalidating the
+// nav files.
+//
+// The place directory is stored in the nav file as a list of 
+// place name strings.  Each nav area then contains an index
+// into that directory, or zero if no place has been assigned to 
+// that area.
+//
+class PlaceDirectory
+{
+public:
+
+	typedef unsigned short IndexType;
+
+	void Reset( void )
+	{
+		m_directory.RemoveAll();
+	}
+
+	/// return true if this place is already in the directory
+	bool IsKnown( Place place ) const
+	{
+		return m_directory.HasElement( place );
+	}
+
+	/// return the directory index corresponding to this Place (0 = no entry)
+	IndexType GetIndex( Place place ) const
+	{
+		if (place == UNDEFINED_PLACE)
+			return 0;
+
+		int i = m_directory.Find( place );
+
+		if (i < 0)
+		{
+			Assert( false && "PlaceDirectory::GetIndex failure" );
+			return 0;
+		}
+
+		return (IndexType)(i+1);
+	}
+
+	/// add the place to the directory if not already known
+	void AddPlace( Place place )
+	{
+		if (place == UNDEFINED_PLACE)
+			return;
+
+		Assert( place < 1000 );
+
+		if (IsKnown( place ))
+			return;
+
+		m_directory.AddToTail( place );
+	}
+
+	/// given an index, return the Place
+	Place IndexToPlace( IndexType entry ) const
+	{
+		if (entry == 0)
+			return UNDEFINED_PLACE;
+
+		int i = entry-1;
+
+		if (i >= m_directory.Count())
+		{
+			Assert( false && "PlaceDirectory::IndexToPlace: Invalid entry" );
+			return UNDEFINED_PLACE;
+		}
+
+		return m_directory[ i ];
+	}
+
+	/// store the directory
+	void Save( FileHandle_t file )
+	{
+		// store number of entries in directory
+		IndexType count = (IndexType)m_directory.Count();
+		filesystem->Write( &count, sizeof(IndexType), file );
+
+		// store entries		
+		for( int i=0; i<m_directory.Count(); ++i )
+		{
+			const char *placeName = TheNavMesh->PlaceToName( m_directory[i] );
+
+			// store string length followed by string itself
+			unsigned short len = (unsigned short)(strlen( placeName ) + 1);
+			filesystem->Write( &len, sizeof(unsigned short), file );
+			filesystem->Write( placeName, len, file );
+		}
+	}
+
+	/// load the directory
+	void Load( FileHandle_t file )
+	{
+		// read number of entries
+		IndexType count;
+		filesystem->Read( &count, sizeof(IndexType), file );
+
+		m_directory.RemoveAll();
+
+		// read each entry
+		char placeName[256];
+		unsigned short len;
+		for( int i=0; i<count; ++i )
+		{
+			filesystem->Read( &len, sizeof(unsigned short), file );
+			filesystem->Read( placeName, len, file );
+
+			AddPlace( TheNavMesh->NameToPlace( placeName ) );
+		}
+	}
+
+private:
+	CUtlVector< Place > m_directory;
+};
+
+static PlaceDirectory placeDirectory;
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Replace extension with "bsp"
+ */
+char *GetBspFilename( const char *navFilename )
+{
+	static char bspFilename[256];
+
+	Q_snprintf( bspFilename, sizeof( bspFilename ), "maps\\%s.bsp", STRING( gpGlobals->mapname ) );
+
+	int len = strlen( bspFilename );
+	if (len < 3)
+		return NULL;
+
+	bspFilename[ len-3 ] = 'b';
+	bspFilename[ len-2 ] = 's';
+	bspFilename[ len-1 ] = 'p';
+
+	return bspFilename;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/*
+void CNavArea::Save( FILE *fp ) const
+{
+	fprintf( fp, "v  %f %f %f\n", m_extent.lo.x, m_extent.lo.y, m_extent.lo.z );
+	fprintf( fp, "v  %f %f %f\n", m_extent.hi.x, m_extent.lo.y, m_neZ );
+	fprintf( fp, "v  %f %f %f\n", m_extent.hi.x, m_extent.hi.y, m_extent.hi.z );
+	fprintf( fp, "v  %f %f %f\n", m_extent.lo.x, m_extent.hi.y, m_swZ );
+
+	static int base = 1;
+	fprintf( fp, "\n\ng %04dArea%s%s%s%s\n", m_id, 
+				(GetAttributes() & BOT_NAV_CROUCH) ? "CROUCH" : "",
+				(GetAttributes() & BOT_NAV_JUMP) ? "JUMP" : "",
+				(GetAttributes() & BOT_NAV_PRECISE) ? "PRECISE" : "",
+				(GetAttributes() & BOT_NAV_NO_JUMP) ? "NO_JUMP" : "" );
+	fprintf( fp, "f %d %d %d %d\n\n", base, base+1, base+2, base+3 );
+	base += 4;
+}
+*/
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Save a navigation area to the opened binary stream
+ */
+void CNavArea::Save( FileHandle_t file, unsigned int version ) const
+{
+	// save ID
+	filesystem->Write( &m_id, sizeof(unsigned int), file );
+
+	// save attribute flags
+	filesystem->Write( &m_attributeFlags, sizeof(unsigned short), file );
+
+	// save extent of area
+	filesystem->Write( &m_extent, 6*sizeof(float), file );
+
+	// save heights of implicit corners
+	filesystem->Write( &m_neZ, sizeof(float), file );
+	filesystem->Write( &m_swZ, sizeof(float), file );
+
+	// save connections to adjacent areas
+	// in the enum order NORTH, EAST, SOUTH, WEST
+	for( int d=0; d<NUM_DIRECTIONS; d++ )
+	{
+		// save number of connections for this direction
+		unsigned int count = m_connect[d].Count();
+		filesystem->Write( &count, sizeof(unsigned int), file );
+
+		FOR_EACH_LL( m_connect[d], it )
+		{
+			NavConnect connect = m_connect[d][ it ];
+			filesystem->Write( &connect.area->m_id, sizeof(unsigned int), file );
+		}
+	}
+
+	//
+	// Store hiding spots for this area
+	//
+	unsigned char count;
+	if (m_hidingSpotList.Count() > 255)
+	{
+		count = 255;
+		Warning( "Warning: NavArea #%d: Truncated hiding spot list to 255\n", m_id );
+	}
+	else
+	{
+		count = (unsigned char)m_hidingSpotList.Count();
+	}
+	filesystem->Write( &count, sizeof(unsigned char), file );
+
+	// store HidingSpot objects
+	unsigned int saveCount = 0;
+	FOR_EACH_LL( m_hidingSpotList, hit )
+	{
+		HidingSpot *spot = m_hidingSpotList[ hit ];
+		
+		spot->Save( file, version );
+
+		// overflow check
+		if (++saveCount == count)
+			break;
+	}
+
+	//
+	// Save the approach areas for this area
+	//
+
+	// save number of approach areas
+	filesystem->Write( &m_approachCount, sizeof(unsigned char), file );
+
+	// save approach area info
+	unsigned char type;
+	unsigned int zero = 0;
+	for( int a=0; a<m_approachCount; ++a )
+	{
+		if (m_approach[a].here.area)
+			filesystem->Write( &m_approach[a].here.area->m_id, sizeof(unsigned int), file );
+		else
+			filesystem->Write( &zero, sizeof(unsigned int), file );
+
+		if (m_approach[a].prev.area)
+			filesystem->Write( &m_approach[a].prev.area->m_id, sizeof(unsigned int), file );
+		else
+			filesystem->Write( &zero, sizeof(unsigned int), file );
+		type = (unsigned char)m_approach[a].prevToHereHow;
+		filesystem->Write( &type, sizeof(unsigned char), file );
+
+		if (m_approach[a].next.area)
+			filesystem->Write( &m_approach[a].next.area->m_id, sizeof(unsigned int), file );
+		else
+			filesystem->Write( &zero, sizeof(unsigned int), file );
+		type = (unsigned char)m_approach[a].hereToNextHow;
+		filesystem->Write( &type, sizeof(unsigned char), file );
+	}
+
+	//
+	// Save encounter spots for this area
+	//
+	{
+		// save number of encounter paths for this area
+		unsigned int count = m_spotEncounterList.Count();
+		filesystem->Write( &count, sizeof(unsigned int), file );
+
+		SpotEncounter *e;
+		FOR_EACH_LL( m_spotEncounterList, it )
+		{
+			e = m_spotEncounterList[ it ];
+
+			if (e->from.area)
+				filesystem->Write( &e->from.area->m_id, sizeof(unsigned int), file );
+			else
+				filesystem->Write( &zero, sizeof(unsigned int), file );
+
+			unsigned char dir = (unsigned char)e->fromDir;
+			filesystem->Write( &dir, sizeof(unsigned char), file );
+
+			if (e->to.area)
+				filesystem->Write( &e->to.area->m_id, sizeof(unsigned int), file );
+			else
+				filesystem->Write( &zero, sizeof(unsigned int), file );
+
+			dir = (unsigned char)e->toDir;
+			filesystem->Write( &dir, sizeof(unsigned char), file );
+
+			// write list of spots along this path
+			unsigned char spotCount;
+			if (e->spotList.Count() > 255)
+			{
+				spotCount = 255;
+				Warning( "Warning: NavArea #%d: Truncated encounter spot list to 255\n", m_id );
+			}
+			else
+			{
+				spotCount = (unsigned char)e->spotList.Count();
+			}
+			filesystem->Write( &spotCount, sizeof(unsigned char), file );
+		
+			saveCount = 0;
+			FOR_EACH_LL( e->spotList, sit )
+			{
+				SpotOrder *order = &e->spotList[ sit ];
+
+				// order->spot may be NULL if we've loaded a nav mesh that has been edited but not re-analyzed
+				unsigned int id = (order->spot) ? order->spot->GetID() : 0;
+				filesystem->Write( &id, sizeof(unsigned int), file );
+
+				unsigned char t = (unsigned char)(255 * order->t);
+				filesystem->Write( &t, sizeof(unsigned char), file );
+
+				// overflow check
+				if (++saveCount == spotCount)
+					break;
+			}
+		}
+	}
+
+	// store place dictionary entry
+	PlaceDirectory::IndexType entry = placeDirectory.GetIndex( GetPlace() );
+	filesystem->Write( &entry, sizeof(entry), file );
+
+	// write out ladder info
+	int i;
+	for ( i=0; i<CSNavLadder::NUM_LADDER_DIRECTIONS; ++i )
+	{
+		// save number of encounter paths for this area
+		unsigned int count = m_ladder[i].Count();
+		filesystem->Write( &count, sizeof(unsigned int), file );
+
+		NavLadderConnect ladder;
+		FOR_EACH_LL( m_ladder[i], it )
+		{
+			ladder = m_ladder[i][it];
+
+			unsigned int id = ladder.ladder->GetID();
+			filesystem->Write( &id, sizeof( id ), file );
+		}
+	}
+
+	// save earliest occupy times
+	for( i=0; i<MAX_NAV_TEAMS; ++i )
+	{
+		// no spot in the map should take longer than this to reach
+		filesystem->Write( &m_earliestOccupyTime[i], sizeof(m_earliestOccupyTime[i]), file );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Load a navigation area from the file
+ */
+void CNavArea::Load( FileHandle_t file, unsigned int version )
+{
+	// load ID
+	filesystem->Read( &m_id, sizeof(unsigned int), file );
+
+	// update nextID to avoid collisions
+	if (m_id >= m_nextID)
+		m_nextID = m_id+1;
+
+	// load attribute flags
+	if ( version <= 8 )
+	{
+		unsigned char flags = 0;
+		filesystem->Read( &flags, sizeof(unsigned char), file );
+		m_attributeFlags = flags;
+	}
+	else
+	{
+		filesystem->Read( &m_attributeFlags, sizeof(unsigned short), file );
+	}
+
+	// load extent of area
+	filesystem->Read( &m_extent, 6*sizeof(float), file );
+
+	m_center.x = (m_extent.lo.x + m_extent.hi.x)/2.0f;
+	m_center.y = (m_extent.lo.y + m_extent.hi.y)/2.0f;
+	m_center.z = (m_extent.lo.z + m_extent.hi.z)/2.0f;
+
+	// load heights of implicit corners
+	filesystem->Read( &m_neZ, sizeof(float), file );
+	filesystem->Read( &m_swZ, sizeof(float), file );
+
+	CheckWaterLevel();
+
+	// load connections (IDs) to adjacent areas
+	// in the enum order NORTH, EAST, SOUTH, WEST
+	for( int d=0; d<NUM_DIRECTIONS; d++ )
+	{
+		// load number of connections for this direction
+		unsigned int count;
+		int result = filesystem->Read( &count, sizeof(unsigned int), file );
+		Assert( result == sizeof(unsigned int) );
+
+		for( unsigned int i=0; i<count; ++i )
+		{
+			NavConnect connect;
+			result = filesystem->Read( &connect.id, sizeof(unsigned int), file );
+			Assert( result == sizeof(unsigned int) );
+
+			// don't allow self-referential connections
+			if ( connect.id != m_id )
+			{
+				m_connect[d].AddToTail( connect );
+			}
+		}
+	}
+
+	//
+	// Load hiding spots
+	//
+
+	// load number of hiding spots
+	unsigned char hidingSpotCount;
+	filesystem->Read( &hidingSpotCount, sizeof(unsigned char), file );
+
+	if (version == 1)
+	{
+		// load simple vector array
+		Vector pos;
+		for( int h=0; h<hidingSpotCount; ++h )
+		{
+			filesystem->Read( &pos, 3 * sizeof(float), file );
+
+			// create new hiding spot and put on master list
+			HidingSpot *spot = TheNavMesh->CreateHidingSpot();
+			spot->SetPosition( pos );
+			spot->SetFlags( HidingSpot::IN_COVER );
+			m_hidingSpotList.AddToTail( spot );
+		}
+	}
+	else
+	{
+		// load HidingSpot objects for this area
+		for( int h=0; h<hidingSpotCount; ++h )
+		{
+			// create new hiding spot and put on master list
+			HidingSpot *spot = TheNavMesh->CreateHidingSpot();
+
+			spot->Load( file, version );
+			
+			m_hidingSpotList.AddToTail( spot );
+		}
+	}
+
+	//
+	// Load number of approach areas
+	//
+	filesystem->Read( &m_approachCount, sizeof(unsigned char), file );
+
+	// load approach area info (IDs)
+	unsigned char type;
+	for( int a=0; a<m_approachCount; ++a )
+	{
+		filesystem->Read( &m_approach[a].here.id, sizeof(unsigned int), file );
+
+		filesystem->Read( &m_approach[a].prev.id, sizeof(unsigned int), file );
+		filesystem->Read( &type, sizeof(unsigned char), file );
+		m_approach[a].prevToHereHow = (NavTraverseType)type;
+
+		filesystem->Read( &m_approach[a].next.id, sizeof(unsigned int), file );
+		filesystem->Read( &type, sizeof(unsigned char), file );
+		m_approach[a].hereToNextHow = (NavTraverseType)type;
+	}
+
+
+	//
+	// Load encounter paths for this area
+	//
+	unsigned int count;
+	filesystem->Read( &count, sizeof(unsigned int), file );
+
+	if (version < 3)
+	{
+		// old data, read and discard
+		for( unsigned int e=0; e<count; ++e )
+		{
+			SpotEncounter encounter;
+
+			filesystem->Read( &encounter.from.id, sizeof(unsigned int), file );
+			filesystem->Read( &encounter.to.id, sizeof(unsigned int), file );
+
+			filesystem->Read( &encounter.path.from.x, 3 * sizeof(float), file );
+			filesystem->Read( &encounter.path.to.x, 3 * sizeof(float), file );
+
+			// read list of spots along this path
+			unsigned char spotCount;
+			filesystem->Read( &spotCount, sizeof(unsigned char), file );
+		
+			for( int s=0; s<spotCount; ++s )
+			{
+				Vector pos;
+				filesystem->Read( &pos, 3*sizeof(float), file );
+				filesystem->Read( &pos, sizeof(float), file );
+			}
+		}
+		return;
+	}
+
+	for( unsigned int e=0; e<count; ++e )
+	{
+		SpotEncounter *encounter = new SpotEncounter;
+
+		filesystem->Read( &encounter->from.id, sizeof(unsigned int), file );
+
+		unsigned char dir;
+		filesystem->Read( &dir, sizeof(unsigned char), file );
+		encounter->fromDir = static_cast<NavDirType>( dir );
+
+		filesystem->Read( &encounter->to.id, sizeof(unsigned int), file );
+
+		filesystem->Read( &dir, sizeof(unsigned char), file );
+		encounter->toDir = static_cast<NavDirType>( dir );
+
+		// read list of spots along this path
+		unsigned char spotCount;
+		filesystem->Read( &spotCount, sizeof(unsigned char), file );
+	
+		SpotOrder order;
+		for( int s=0; s<spotCount; ++s )
+		{
+			filesystem->Read( &order.id, sizeof(unsigned int), file );
+
+			unsigned char t;
+			filesystem->Read( &t, sizeof(unsigned char), file );
+
+			order.t = (float)t/255.0f;
+
+			encounter->spotList.AddToTail( order );
+		}
+
+		m_spotEncounterList.AddToTail( encounter );
+	}
+
+	if (version < 5)
+		return;
+
+	//
+	// Load Place data
+	//
+	PlaceDirectory::IndexType entry;
+	filesystem->Read( &entry, sizeof(entry), file );
+
+	// convert entry to actual Place
+	SetPlace( placeDirectory.IndexToPlace( entry ) );
+
+	if ( version < 7 )
+		return;
+
+	// load ladder data
+	for ( int dir=0; dir<CSNavLadder::NUM_LADDER_DIRECTIONS; ++dir )
+	{
+		filesystem->Read( &count, sizeof(unsigned int), file );
+		{
+			for( unsigned int i=0; i<count; ++i )
+			{
+				NavLadderConnect connect;
+				filesystem->Read( &connect.id, sizeof(unsigned int), file );
+
+				bool alreadyConnected = false;
+				FOR_EACH_LL( m_ladder[dir], j )
+				{
+					if ( m_ladder[dir][j].id == connect.id )
+					{
+						alreadyConnected = true;
+						break;
+					}
+				}
+
+				if ( !alreadyConnected )
+				{
+					m_ladder[dir].AddToTail( connect );
+				}
+			}
+		}
+	}
+
+	if ( version < 8 )
+		return;
+
+	// load earliest occupy times
+	for( int i=0; i<MAX_NAV_TEAMS; ++i )
+	{
+		// no spot in the map should take longer than this to reach
+		filesystem->Read( &m_earliestOccupyTime[i], sizeof(m_earliestOccupyTime[i]), file );
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Convert loaded IDs to pointers
+ * Make sure all IDs are converted, even if corrupt data is encountered.
+ */
+NavErrorType CNavArea::PostLoad( void )
+{
+	NavErrorType error = NAV_OK;
+
+	for ( int dir=0; dir < CNavLadder::NUM_LADDER_DIRECTIONS; ++dir )
+	{
+		FOR_EACH_VEC( m_ladder[dir], it )
+		{
+			NavLadderConnect& connect = m_ladder[dir][it];
+
+			unsigned int id = connect.id;
+
+			if ( TheNavMesh->GetLadders().Find( connect.ladder ) == TheNavMesh->GetLadders().InvalidIndex() )
+			{
+				connect.ladder = TheNavMesh->GetLadderByID( id );
+			}
+
+			if (id && connect.ladder == NULL)
+			{
+				Msg( "CNavArea::PostLoad: Corrupt navigation ladder data. Cannot connect Navigation Areas.\n" );
+				error = NAV_CORRUPT_DATA;
+			}
+		}
+	}
+
+	// connect areas together
+	for( int d=0; d<NUM_DIRECTIONS; d++ )
+	{
+		FOR_EACH_VEC( m_connect[d], it )
+		{
+			NavConnect *connect = &m_connect[ d ][ it ];
+
+			unsigned int id = connect->id;
+			connect->area = TheNavMesh->GetNavAreaByID( id );
+			if (id && connect->area == NULL)
+			{
+				Msg( "CNavArea::PostLoad: Corrupt navigation data. Cannot connect Navigation Areas.\n" );
+				error = NAV_CORRUPT_DATA;
+			}
+		}
+	}
+
+	// resolve approach area IDs
+	for( int a=0; a<m_approachCount; ++a )
+	{
+		m_approach[a].here.area = TheNavMesh->GetNavAreaByID( m_approach[a].here.id );
+		if (m_approach[a].here.id && m_approach[a].here.area == NULL)
+		{
+			Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing Approach Area (here).\n" );
+			error = NAV_CORRUPT_DATA;
+		}
+
+		m_approach[a].prev.area = TheNavMesh->GetNavAreaByID( m_approach[a].prev.id );
+		if (m_approach[a].prev.id && m_approach[a].prev.area == NULL)
+		{
+			Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing Approach Area (prev).\n" );
+			error = NAV_CORRUPT_DATA;
+		}
+
+		m_approach[a].next.area = TheNavMesh->GetNavAreaByID( m_approach[a].next.id );
+		if (m_approach[a].next.id && m_approach[a].next.area == NULL)
+		{
+			Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing Approach Area (next).\n" );
+			error = NAV_CORRUPT_DATA;
+		}
+	}
+
+	// resolve spot encounter IDs
+	SpotEncounter *e;
+	FOR_EACH_VEC( m_spotEncounters, it )
+	{
+		e = m_spotEncounters[ it ];
+
+		e->from.area = TheNavMesh->GetNavAreaByID( e->from.id );
+		if (e->from.area == NULL)
+		{
+			Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing \"from\" Navigation Area for Encounter Spot.\n" );
+			error = NAV_CORRUPT_DATA;
+		}
+
+		e->to.area = TheNavMesh->GetNavAreaByID( e->to.id );
+		if (e->to.area == NULL)
+		{
+			Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing \"to\" Navigation Area for Encounter Spot.\n" );
+			error = NAV_CORRUPT_DATA;
+		}
+
+		if (e->from.area && e->to.area)
+		{
+			// compute path
+			float halfWidth;
+			ComputePortal( e->to.area, e->toDir, &e->path.to, &halfWidth );
+			ComputePortal( e->from.area, e->fromDir, &e->path.from, &halfWidth );
+
+			const float eyeHeight = HalfHumanHeight;
+			e->path.from.z = e->from.area->GetZ( e->path.from ) + eyeHeight;
+			e->path.to.z = e->to.area->GetZ( e->path.to ) + eyeHeight;
+		}
+
+		// resolve HidingSpot IDs
+		FOR_EACH_VEC( e->spots, sit )
+		{
+			SpotOrder *order = &e->spots[ sit ];
+
+			order->spot = GetHidingSpotByID( order->id );
+			if (order->spot == NULL)
+			{
+				Msg( "CNavArea::PostLoad: Corrupt navigation data. Missing Hiding Spot\n" );
+				error = NAV_CORRUPT_DATA;
+			}
+		}
+	}
+
+	// build overlap list
+	/// @todo Optimize this
+	FOR_EACH_VEC( TheNavAreas, nit )
+	{
+		CNavArea *area = TheNavAreas[ nit ];
+
+		if (area == this)
+			continue;
+
+		if (IsOverlapping( area ))
+			m_overlappingAreas.AddToTail( area );
+	}
+
+	return error;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine the earliest time this hiding spot can be reached by either team
+ */
+void CNavArea::ComputeEarliestOccupyTimes( void )
+{
+#ifdef CSTRIKE_DLL
+	/// @todo Derive cstrike-specific navigation classes
+
+	for( int i=0; i<MAX_NAV_TEAMS; ++i )
+	{
+		// no spot in the map should take longer than this to reach
+		m_earliestOccupyTime[i] = 120.0f;
+	}
+
+	if (nav_quicksave.GetBool())
+		return;
+
+	// maximum player speed in units/second
+	const float playerSpeed = 240.0f;
+
+	ShortestPathCost cost;
+	CBaseEntity *spot;
+
+	// determine the shortest time it will take a Terrorist to reach this area
+	int team = TEAM_TERRORIST % MAX_NAV_TEAMS;
+	for( spot = gEntList.FindEntityByClassname( NULL, "info_player_terrorist" );
+		 spot;
+		 spot = gEntList.FindEntityByClassname( spot, "info_player_terrorist" ) )
+	{
+		float travelDistance = NavAreaTravelDistance( spot->GetAbsOrigin(), m_center, cost );
+		if (travelDistance < 0.0f)
+			continue;
+
+		float travelTime = travelDistance / playerSpeed;
+		if (travelTime < m_earliestOccupyTime[ team ])
+		{
+			m_earliestOccupyTime[ team ] = travelTime;
+		}
+	}
+
+
+	// determine the shortest time it will take a CT to reach this area
+	team = TEAM_CT % MAX_NAV_TEAMS;
+	for( spot = gEntList.FindEntityByClassname( NULL, "info_player_counterterrorist" );
+		 spot;
+		 spot = gEntList.FindEntityByClassname( spot, "info_player_counterterrorist" ) )
+	{
+		float travelDistance = NavAreaTravelDistance( spot->GetAbsOrigin(), m_center, cost );
+		if (travelDistance < 0.0f)
+			continue;
+
+		float travelTime = travelDistance / playerSpeed;
+		if (travelTime < m_earliestOccupyTime[ team ])
+		{
+			m_earliestOccupyTime[ team ] = travelTime;
+		}
+	}
+
+#else
+	for( int i=0; i<MAX_NAV_TEAMS; ++i )
+	{
+		m_earliestOccupyTime[i] = 0.0f;
+	}
+#endif
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine if this area is a "battlefront" area - where two rushing teams first meet.
+ */
+void CNavMesh::ComputeBattlefrontAreas( void )
+{
+#if 0
+#ifdef CSTRIKE_DLL
+	ShortestPathCost cost;
+	CBaseEntity *tSpawn, *ctSpawn;
+
+	for( tSpawn = gEntList.FindEntityByClassname( NULL, "info_player_terrorist" );
+		 tSpawn;
+		 tSpawn = gEntList.FindEntityByClassname( tSpawn, "info_player_terrorist" ) )
+	{
+		CNavArea *tArea = TheNavMesh->GetNavArea( tSpawn->GetAbsOrigin() );
+		if (tArea == NULL)
+			continue;
+
+		for( ctSpawn = gEntList.FindEntityByClassname( NULL, "info_player_counterterrorist" );
+			 ctSpawn;
+			 ctSpawn = gEntList.FindEntityByClassname( ctSpawn, "info_player_counterterrorist" ) )
+		{
+			CNavArea *ctArea = TheNavMesh->GetNavArea( ctSpawn->GetAbsOrigin() );
+
+			if (ctArea == NULL)
+				continue;
+
+			if (tArea == ctArea)
+			{
+				m_isBattlefront = true;
+				return;
+			}
+
+			// build path between these two spawn points - assume if path fails, it at least got close
+			// (ie: imagine spawn points that you jump down from - can't path to)
+			CNavArea *goalArea = NULL;
+			NavAreaBuildPath( tArea, ctArea, NULL, cost, &goalArea );
+
+			if (goalArea == NULL)
+				continue;
+
+
+/**
+ * @todo Need to enumerate ALL paths between all pairs of spawn points to find all battlefront areas
+ */
+
+			// find the area with the earliest overlapping occupy times
+			CNavArea *battlefront = NULL;
+			float earliestTime = 999999.9f;
+
+			const float epsilon = 1.0f;
+			CNavArea *area;
+			for( area = goalArea; area; area = area->GetParent() )
+			{
+				if (fabs(area->GetEarliestOccupyTime( TEAM_TERRORIST ) - area->GetEarliestOccupyTime( TEAM_CT )) < epsilon)
+				{
+				}
+				
+			}
+		}
+	}
+#endif
+#endif
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the filename for this map's "nav map" file
+ */
+const char *CNavMesh::GetFilename( void ) const
+{
+	// filename is local to game dir for Steam, so we need to prepend game dir for regular file save
+	char gamePath[256];
+	engine->GetGameDir( gamePath, 256 );
+
+	static char filename[256];
+	Q_snprintf( filename, sizeof( filename ), "%s\\maps\\%s.nav", gamePath, STRING( gpGlobals->mapname ) );
+
+	return filename;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/*
+============
+COM_FixSlashes
+
+Changes all '/' characters into '\' characters, in place.
+============
+*/
+inline void COM_FixSlashes( char *pname )
+{
+#ifdef _WIN32
+	while ( *pname ) 
+	{
+		if ( *pname == '/' )
+			*pname = '\\';
+		pname++;
+	}
+#else
+	while ( *pname ) 
+	{
+		if ( *pname == '\\' )
+			*pname = '/';
+		pname++;
+	}
+#endif
+}
+
+static void WarnIfMeshNeedsAnalysis( void )
+{
+	// Quick check to warn about needing to analyze: nav_strip, nav_delete, etc set
+	// every CNavArea's m_approachCount to 0, and delete their m_spotEncounterList.
+	// So, if no area has either, odds are good we need an analyze.
+	{
+		bool hasApproachAreas = false;
+		bool hasSpotEncounters = false;
+
+		FOR_EACH_VEC( TheNavAreas, it )
+		{
+			CNavArea *area = TheNavAreas[ it ];
+			if ( area->GetApproachInfoCount() )
+			{
+				hasApproachAreas = true;
+			}
+
+			if ( area->GetSpotEncounterCount() )
+			{
+				hasSpotEncounters = true;
+			}
+		}
+
+		if ( !hasApproachAreas || !hasSpotEncounters )
+		{
+			Warning( "The nav mesh needs a full nav_analyze\n" );
+		}
+	}
+}
+
+/**
+ * Store Navigation Mesh to a file
+ */
+bool CNavMesh::Save( void ) const
+{
+	WarnIfMeshNeedsAnalysis();
+
+	const char *filename = GetFilename();
+	if (filename == NULL)
+		return false;
+
+	//
+	// Store the NAV file
+	//
+	COM_FixSlashes( const_cast<char *>(filename) );
+
+	// get size of source bsp file for later (before we open the nav file for writing, in
+	// case of failure)
+	char *bspFilename = GetBspFilename( filename );
+	if (bspFilename == NULL)
+	{
+		return false;
+	}
+
+	FileHandle_t file = filesystem->Open( filename, "wb" );
+
+	if (!file)
+	{
+		return false;
+	}
+
+	// store "magic number" to help identify this kind of file
+	unsigned int magic = NAV_MAGIC_NUMBER;
+	filesystem->Write( &magic, sizeof(unsigned int), file );
+
+	// store version number of file
+	// 1 = hiding spots as plain vector array
+	// 2 = hiding spots as HidingSpot objects
+	// 3 = Encounter spots use HidingSpot ID's instead of storing vector again
+	// 4 = Includes size of source bsp file to verify nav data correlation
+	// ---- Beta Release at V4 -----
+	// 5 = Added Place info
+	// ---- Conversion to Src ------
+	// 6 = Added Ladder info
+	// 7 = Areas store ladder ID's so ladders can have one-way connections
+	// 8 = Added earliest occupy times (2 floats) to each area
+	// 9 = Promoted CNavArea's attribute flags to a short
+	unsigned int version = NavCurrentVersion;
+	filesystem->Write( &version, sizeof(unsigned int), file );
+
+	// store the size of source bsp file in the nav file
+	// so we can test if the bsp changed since the nav file was made
+	unsigned int bspSize = filesystem->Size( bspFilename );
+	DevMsg( "Size of bsp file '%s' is %u bytes.\n", bspFilename, bspSize );
+
+	filesystem->Write( &bspSize, sizeof(unsigned int), file );
+
+
+	//
+	// Build a directory of the Places in this map
+	//
+	placeDirectory.Reset();
+
+	FOR_EACH_VEC( TheNavAreas, nit )
+	{
+		CNavArea *area = TheNavAreas[ nit ];
+
+		Place place = area->GetPlace();
+
+		if (place)
+		{
+			placeDirectory.AddPlace( place );
+		}
+	}
+
+	placeDirectory.Save( file );
+
+
+	//
+	// Store navigation areas
+	//
+	{
+		// store number of areas
+		unsigned int count = TheNavAreas.Count();
+		filesystem->Write( &count, sizeof(unsigned int), file );
+
+		// store each area
+		FOR_EACH_VEC( TheNavAreas, it )
+		{
+			CNavArea *area = TheNavAreas[ it ];
+
+			area->Save( file, version );
+		}
+	}
+
+	//
+	// Store ladders
+	//
+	{
+		// store number of ladders
+		unsigned int count = m_ladders.Count();
+		filesystem->Write( &count, sizeof(unsigned int), file );
+
+		// store each ladder
+		FOR_EACH_VEC( m_ladders, it )
+		{
+			CNavLadder *ladder = m_ladders[ it ];
+
+			ladder->Save( file, version );
+		}
+	}
+
+	filesystem->Flush( file );
+	filesystem->Close( file );
+
+	unsigned int navSize = filesystem->Size( filename );
+	DevMsg( "Size of nav file '%s' is %u bytes.\n", filename, navSize );
+
+	return true;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+static NavErrorType CheckNavFile( const char *bspFilename )
+{
+	if ( !bspFilename )
+		return NAV_CANT_ACCESS_FILE;
+
+	char bspPathname[256];
+	char filename[256];
+	Q_strncpy( bspPathname, "maps/", sizeof( bspPathname ) );
+	Q_strncat( bspPathname, bspFilename, sizeof( bspPathname ), COPY_ALL_CHARACTERS );
+	Q_strncpy( filename, bspPathname, sizeof( filename ) );
+	Q_SetExtension( filename, ".nav", sizeof( filename ) );
+
+	bool navIsInBsp = false;
+	FileHandle_t file = filesystem->Open( filename, "rb", "MOD" );	// this ignores .nav files embedded in the .bsp ...
+	if ( !file )
+	{
+		navIsInBsp = true;
+		file = filesystem->Open( filename, "rb", "GAME" );	// ... and this looks for one if it's the only one around.
+	}
+
+	if (!file)
+	{
+		return NAV_CANT_ACCESS_FILE;
+	}
+
+	// check magic number
+	int result;
+	unsigned int magic;
+	result = filesystem->Read( &magic, sizeof(unsigned int), file );
+	if (!result || magic != NAV_MAGIC_NUMBER)
+	{
+		filesystem->Close( file );
+		return NAV_INVALID_FILE;
+	}
+
+	// read file version number
+	unsigned int version;
+	result = filesystem->Read( &version, sizeof(unsigned int), file );
+	if (!result || version > NavCurrentVersion || version < 4)
+	{
+		filesystem->Close( file );
+		return NAV_BAD_FILE_VERSION;
+	}
+
+	// get size of source bsp file and verify that the bsp hasn't changed
+	unsigned int saveBspSize;
+	filesystem->Read( &saveBspSize, sizeof(unsigned int), file );
+
+	// verify size
+	unsigned int bspSize = filesystem->Size( bspPathname );
+
+	if (bspSize != saveBspSize && !navIsInBsp)
+	{
+		return NAV_FILE_OUT_OF_DATE;
+	}
+
+	return NAV_OK;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CommandNavCheckFileConsistency( void )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	FileFindHandle_t findHandle;
+	const char *bspFilename = filesystem->FindFirstEx( "maps/*.bsp", "MOD", &findHandle );
+	while ( bspFilename )
+	{
+		switch ( CheckNavFile( bspFilename ) )
+		{
+		case NAV_CANT_ACCESS_FILE:
+			Warning( "Missing nav file for %s\n", bspFilename );
+			break;
+		case NAV_INVALID_FILE:
+			Warning( "Invalid nav file for %s\n", bspFilename );
+			break;
+		case NAV_BAD_FILE_VERSION:
+			Warning( "Old nav file for %s\n", bspFilename );
+			break;
+		case NAV_FILE_OUT_OF_DATE:
+			Warning( "The nav file for %s is built from an old version of the map\n", bspFilename );
+			break;
+		case NAV_OK:
+			Msg( "The nav file for %s is up-to-date\n", bspFilename );
+			break;
+		}
+
+		bspFilename = filesystem->FindNext( findHandle );
+	}
+	filesystem->FindClose( findHandle );
+}
+static ConCommand nav_check_file_consistency( "nav_check_file_consistency", CommandNavCheckFileConsistency, "Scans the maps directory and reports any missing/out-of-date navigation files.", FCVAR_GAMEDLL | FCVAR_CHEAT );
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Load AI navigation data from a file
+ */
+NavErrorType CNavMesh::Load( void )
+{
+	// free previous navigation mesh data
+	Reset();
+	placeDirectory.Reset();
+
+	CNavArea::m_nextID = 1;
+
+	// nav filename is derived from map filename
+	char filename[256];
+	Q_snprintf( filename, sizeof( filename ), "maps\\%s.nav", STRING( gpGlobals->mapname ) );
+
+	bool navIsInBsp = false;
+	FileHandle_t file = filesystem->Open( filename, "rb", "MOD" );	// this ignores .nav files embedded in the .bsp ...
+	if ( !file )
+	{
+		navIsInBsp = true;
+		file = filesystem->Open( filename, "rb", "GAME" );	// ... and this looks for one if it's the only one around.
+	}
+
+	if (!file)
+	{
+		return NAV_CANT_ACCESS_FILE;
+	}
+
+	// check magic number
+	int result;
+	unsigned int magic;
+	result = filesystem->Read( &magic, sizeof(unsigned int), file );
+	if (!result || magic != NAV_MAGIC_NUMBER)
+	{
+		Msg( "Invalid navigation file '%s'.\n", filename );
+		filesystem->Close( file );
+		return NAV_INVALID_FILE;
+	}
+
+	// read file version number
+	unsigned int version;
+	result = filesystem->Read( &version, sizeof(unsigned int), file );
+	if (!result || version > NavCurrentVersion)
+	{
+		Msg( "Unknown navigation file version.\n" );
+		filesystem->Close( file );
+		return NAV_BAD_FILE_VERSION;
+	}
+
+	if (version >= 4)
+	{
+		// get size of source bsp file and verify that the bsp hasn't changed
+		unsigned int saveBspSize;
+		filesystem->Read( &saveBspSize, sizeof(unsigned int), file );
+
+		// verify size
+		char *bspFilename = GetBspFilename( filename );
+		if ( bspFilename == NULL )
+		{
+			filesystem->Close( file );
+			return NAV_INVALID_FILE;
+		}
+
+		unsigned int bspSize = filesystem->Size( bspFilename );
+
+		if (bspSize != saveBspSize && !navIsInBsp)
+		{
+			if ( engine->IsDedicatedServer() )
+			{
+				// Warning doesn't print to the dedicated server console, so we'll use Msg instead
+				Msg( "The Navigation Mesh was built using a different version of this map.\n" );
+			}
+			else
+			{
+				Warning( "The Navigation Mesh was built using a different version of this map.\n" );
+			}
+			m_isFromCurrentMap = false;
+		}
+	}
+
+	// load Place directory
+	if (version >= 5)
+	{
+		placeDirectory.Load( file );
+	}
+
+	// get number of areas
+	unsigned int count;
+	unsigned int i;
+	result = filesystem->Read( &count, sizeof(unsigned int), file );
+
+	Extent extent;
+	extent.lo.x = 9999999999.9f;
+	extent.lo.y = 9999999999.9f;
+	extent.hi.x = -9999999999.9f;
+	extent.hi.y = -9999999999.9f;
+
+	// load the areas and compute total extent
+	for( i=0; i<count; ++i )
+	{
+		CNavArea *area = new CNavArea;
+		area->Load( file, version );
+		TheNavAreas.AddToTail( area );
+
+		Extent areaExtent;
+		area->GetExtent(&areaExtent);
+
+		// check validity of nav area
+		if (areaExtent.lo.x >= areaExtent.hi.x || areaExtent.lo.y >= areaExtent.hi.y)
+			Warning( "WARNING: Degenerate Navigation Area #%d at ( %g, %g, %g )\n", 
+						area->GetID(), area->m_center.x, area->m_center.y, area->m_center.z );
+
+		if (areaExtent.lo.x < extent.lo.x)
+			extent.lo.x = areaExtent.lo.x;
+		if (areaExtent.lo.y < extent.lo.y)
+			extent.lo.y = areaExtent.lo.y;
+		if (areaExtent.hi.x > extent.hi.x)
+			extent.hi.x = areaExtent.hi.x;
+		if (areaExtent.hi.y > extent.hi.y)
+			extent.hi.y = areaExtent.hi.y;
+	}
+
+	// add the areas to the grid
+	AllocateGrid( extent.lo.x, extent.hi.x, extent.lo.y, extent.hi.y );
+
+	FOR_EACH_VEC( TheNavAreas, it )
+	{
+		AddNavArea( TheNavAreas[ it ] );
+	}
+
+
+	//
+	// Set up all the ladders
+	//
+	if (version >= 6)
+	{
+		result = filesystem->Read( &count, sizeof(unsigned int), file );
+
+		// load the ladders
+		for( i=0; i<count; ++i )
+		{
+			CNavLadder *ladder = new CNavLadder;
+			ladder->Load( file, version );
+			m_ladders.AddToTail( ladder );
+		}
+	}
+	else
+	{
+		BuildLadders();
+	}
+
+	// allow areas to connect to each other, etc
+	FOR_EACH_VEC( TheNavAreas, pit )
+	{
+		CNavArea *area = TheNavAreas[ pit ];
+		area->PostLoad();
+	}
+
+	// allow hiding spots to compute information
+	FOR_EACH_VEC( TheHidingSpots, hit )
+	{
+		HidingSpot *spot = TheHidingSpots[ hit ];
+		spot->PostLoad();
+	}
+
+	if ( version < 8 )
+	{
+		// Old nav meshes need to compute earliest occupy times
+		FOR_EACH_VEC( TheNavAreas, nit )
+		{
+			CNavArea *area = TheNavAreas[ nit ];
+			area->ComputeEarliestOccupyTimes();
+		}
+	}
+
+	ComputeBattlefrontAreas();
+
+	// the Navigation Mesh has been successfully loaded
+	m_isLoaded = true;
+
+	filesystem->Close( file );
+
+	WarnIfMeshNeedsAnalysis();
+
+	return NAV_OK;
+}
+#endif
\ No newline at end of file
diff --git a/game/server/cstrike/cs_nav_generate.cpp b/game/server/cstrike/cs_nav_generate.cpp
new file mode 100644
index 00000000..18e9ffa9
--- /dev/null
+++ b/game/server/cstrike/cs_nav_generate.cpp
@@ -0,0 +1,269 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_generate.cpp
+// Auto-generate a Navigation Mesh by sampling the current map
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "util_shared.h"
+#include "nav_mesh.h"
+#include "cs_nav_area.h"
+#include "cs_nav_node.h"
+#include "cs_nav_pathfind.h"
+#include "viewport_panel_names.h"
+
+enum { MAX_BLOCKED_AREAS = 256 };
+static unsigned int blockedID[ MAX_BLOCKED_AREAS ];
+static int blockedIDCount = 0;
+static float lastMsgTime = 0.0f;
+
+
+//ConVar nav_slope_limit( "nav_slope_limit", "0.7", FCVAR_GAMEDLL, "The ground unit normal's Z component must be greater than this for nav areas to be generated." );
+ConVar nav_restart_after_analysis( "nav_restart_after_analysis", "1", FCVAR_GAMEDLL, "When nav nav_restart_after_analysis finishes, restart the server.  Turning this off can cause crashes, but is useful for incremental generation." );
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Shortest path cost, paying attention to "blocked" areas
+ */
+class ApproachAreaCost
+{
+public:
+	// HPE_TODO[pmf]: check that these new parameters are okay to be ignored
+	float operator() ( CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder, const CFuncElevator *elevator, float length )
+	{
+		// check if this area is "blocked"
+		for( int i=0; i<blockedIDCount; ++i )
+		{
+			if (area->GetID() == blockedID[i])
+			{
+				return -1.0f;
+			}
+		}
+
+		if (fromArea == NULL)
+		{
+			// first area in path, no cost
+			return 0.0f;
+		}
+		else
+		{
+			// compute distance traveled along path so far
+			float dist;
+
+			if (ladder)
+			{
+				dist = ladder->m_length;
+			}
+			else
+			{
+				dist = (area->GetCenter() - fromArea->GetCenter()).Length();
+			}
+
+			float cost = dist + fromArea->GetCostSoFar();
+
+			return cost;
+		}
+	}
+};
+
+/*
+ * Determine the set of "approach areas".
+ * An approach area is an area representing a place where players 
+ * move into/out of our local neighborhood of areas.
+ * @todo Optimize by search from eye outward and modifying pathfinder to treat all links as bi-directional
+ */
+void CCSNavArea::ComputeApproachAreas( void )
+{
+	m_approachCount = 0;
+
+	if (nav_quicksave.GetBool())
+		return;
+
+	// use the center of the nav area as the "view" point
+	Vector eye = m_center;
+	if (TheNavMesh->GetGroundHeight( eye, &eye.z ) == false)
+		return;
+
+	// approximate eye position
+	if (GetAttributes() & NAV_MESH_CROUCH)
+		eye.z += 0.9f * HalfHumanHeight;
+	else
+		eye.z += 0.9f * HumanHeight;
+
+	enum { MAX_PATH_LENGTH = 256 };
+	CNavArea *path[ MAX_PATH_LENGTH ];
+	ApproachAreaCost cost;
+
+	enum SearchType
+	{
+		FROM_EYE,		///< start search from our eyepoint outward to farArea
+		TO_EYE,			///< start search from farArea beack towards our eye
+		SEARCH_FINISHED
+	};
+
+	//
+	// In order to *completely* enumerate all of the approach areas, we
+	// need to search from our eyepoint outward, as well as from outwards
+	// towards our eyepoint
+	//
+	for( int searchType = FROM_EYE; searchType != SEARCH_FINISHED; ++searchType )
+	{
+		//
+		// In order to enumerate all of the approach areas, we need to
+		// run the algorithm many times, once for each "far away" area
+		// and keep the union of the approach area sets
+		//
+		int it;
+		for( it = 0; it < TheNavAreas.Count(); ++it )
+		{
+			CNavArea *farArea = TheNavAreas[ it ];
+
+			blockedIDCount = 0;
+
+			// skip the small areas
+			const float minSize = 200.0f;		// 150
+			Extent extent;
+			farArea->GetExtent(&extent);
+			if (extent.SizeX() < minSize || extent.SizeY() < minSize)
+			{
+				continue;
+			}
+
+			// if we can see 'farArea', try again - the whole point is to go "around the bend", so to speak
+			if (farArea->IsVisible( eye ))
+			{
+				continue;
+			}
+
+			//
+			// Keep building paths to farArea and blocking them off until we
+			// cant path there any more.
+			// As areas are blocked off, all exits will be enumerated.
+			//
+			while( m_approachCount < MAX_APPROACH_AREAS )
+			{
+				CNavArea *from, *to;
+
+				if (searchType == FROM_EYE)
+				{
+					// find another path *to* 'farArea'
+					// we must pathfind from us in order to pick up one-way paths OUT OF our area
+					from = this;
+					to = farArea;
+				}
+				else // TO_EYE
+				{
+					// find another path *from* 'farArea'
+					// we must pathfind to us in order to pick up one-way paths INTO our area
+					from = farArea;
+					to = this;
+				}
+
+				// build the actual path
+				if (NavAreaBuildPath( from, to, NULL, cost ) == false)
+				{
+					break;
+				}
+
+				// find number of areas on path
+				int count = 0;
+				CNavArea *area;
+				for( area = to; area; area = area->GetParent() )
+				{
+					++count;
+				}
+
+				if (count > MAX_PATH_LENGTH)
+				{
+					count = MAX_PATH_LENGTH;
+				}
+
+				// if the path is only two areas long, there can be no approach points
+				if (count <= 2)
+				{
+					break;
+				}
+
+				// build path starting from eye
+				int i = 0;
+
+				if (searchType == FROM_EYE)
+				{
+					for( area = to; i < count && area; area = area->GetParent() )
+					{
+						path[ count-i-1 ] = area;
+						++i;
+					}
+				}
+				else // TO_EYE
+				{
+					for( area = to; i < count && area; area = area->GetParent() )
+					{
+						path[ i++ ] = area;
+					}
+				}
+
+				// traverse path to find first area we cannot see (skip the first area)
+				for( i=1; i<count; ++i )
+				{
+					// if we see this area, continue on
+					if (path[i]->IsVisible( eye ))
+					{
+						continue;
+					}
+
+					// we can't see this area - mark this area as "blocked" and unusable by subsequent approach paths
+					if (blockedIDCount == MAX_BLOCKED_AREAS)
+					{
+						Msg( "Overflow computing approach areas for area #%d.\n", GetID());
+						return;
+					}
+
+					// if the area to be blocked is actually farArea, block the one just prior
+					// (blocking farArea will cause all subsequent pathfinds to fail)
+					int block = (path[i] == farArea) ? i-1 : i;
+
+					// dont block the start area, or all subsequence pathfinds will fail
+					if (block == 0)
+					{
+						continue;
+					}
+
+					blockedID[ blockedIDCount++ ] = path[ block ]->GetID();
+
+					// store new approach area if not already in set
+					int a;
+					for( a=0; a<m_approachCount; ++a )
+					{
+						if (m_approach[a].here.area == path[block-1])
+						{
+							break;
+						}
+					}
+
+					if (a == m_approachCount)
+					{
+						m_approach[ m_approachCount ].prev.area = (block >= 2) ? path[block-2] : NULL;
+
+						m_approach[ m_approachCount ].here.area = path[block-1];
+						m_approach[ m_approachCount ].prevToHereHow = path[block-1]->GetParentHow();
+
+						m_approach[ m_approachCount ].next.area = path[block];
+						m_approach[ m_approachCount ].hereToNextHow = path[block]->GetParentHow();
+
+						++m_approachCount;
+					}
+
+					// we are done with this path
+					break;
+				}
+			}
+		}
+	}
+}
diff --git a/game/server/cstrike/cs_nav_mesh.cpp b/game/server/cstrike/cs_nav_mesh.cpp
new file mode 100644
index 00000000..0a467453
--- /dev/null
+++ b/game/server/cstrike/cs_nav_mesh.cpp
@@ -0,0 +1,127 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// NavMesh.cpp
+// Implementation of Navigation Mesh interface
+// Author: Michael S. Booth, 2003-2004
+
+#include "cbase.h"
+#include "filesystem.h"
+#include "cs_nav_mesh.h"
+#include "cs_nav_node.h"
+#include "cs_nav_area.h"
+#include "fmtstr.h"
+#include "utlbuffer.h"
+#include "tier0/vprof.h"
+
+//--------------------------------------------------------------------------------------------------------------
+CSNavMesh::CSNavMesh( void )
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CSNavMesh::~CSNavMesh()
+{
+}
+
+CNavArea * CSNavMesh::CreateArea( void ) const
+{
+	return new CCSNavArea;
+}
+
+//-------------------------------------------------------------------------
+void CSNavMesh::BeginCustomAnalysis( bool bIncremental )
+{
+
+}
+
+
+//-------------------------------------------------------------------------
+// invoked when custom analysis step is complete
+void CSNavMesh::PostCustomAnalysis( void )
+{
+
+}
+
+
+//-------------------------------------------------------------------------
+void CSNavMesh::EndCustomAnalysis()
+{
+
+}
+
+
+//-------------------------------------------------------------------------
+/**
+ * Returns sub-version number of data format used by derived classes
+ */
+unsigned int CSNavMesh::GetSubVersionNumber( void ) const
+{
+	// 1: initial implementation - added ApproachArea data
+	return 1;
+}
+
+//-------------------------------------------------------------------------
+/** 
+ * Store custom mesh data for derived classes
+ */
+void CSNavMesh::SaveCustomData( CUtlBuffer &fileBuffer ) const
+{
+
+}
+
+//-------------------------------------------------------------------------
+/**
+ * Load custom mesh data for derived classes
+ */
+void CSNavMesh::LoadCustomData( CUtlBuffer &fileBuffer, unsigned int subVersion )
+{
+
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reset the Navigation Mesh to initial values
+ */
+void CSNavMesh::Reset( void )
+{
+	CNavMesh::Reset();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Zero player counts in all areas
+ */
+void CSNavMesh::ClearPlayerCounts( void )
+{
+	FOR_EACH_VEC( TheNavAreas, it )
+	{
+		CCSNavArea *area = (CCSNavArea*)TheNavAreas[ it ];
+		area->ClearPlayerCount();
+	}
+}
+
+void CSNavMesh::Update( void )
+{
+	CNavMesh::Update();
+}
+
+NavErrorType CSNavMesh::Load( void )
+{
+	return CNavMesh::Load();
+}
+
+bool CSNavMesh::Save( void ) const
+{
+	return CNavMesh::Save();
+}
+
+NavErrorType CSNavMesh::PostLoad( unsigned int version )
+{
+	return CNavMesh::PostLoad(version);
+}
\ No newline at end of file
diff --git a/game/server/cstrike/cs_nav_mesh.h b/game/server/cstrike/cs_nav_mesh.h
new file mode 100644
index 00000000..a240a879
--- /dev/null
+++ b/game/server/cstrike/cs_nav_mesh.h
@@ -0,0 +1,68 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// cs_nav_mesh.h
+// The Navigation Mesh interface
+// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
+
+//
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+//
+// NOTE: The Navigation code uses Doxygen-style comments. If you run Doxygen over this code, it will 
+// auto-generate documentation.  Visit www.doxygen.org to download the system for free.
+//
+
+#ifndef _CS_NAV_MESH_H_
+#define _CS_NAV_MESH_H_
+
+#include "filesystem.h"
+
+#include "nav_mesh.h"
+
+#include "cs_nav.h"
+#include "nav_area.h"
+#include "nav_colors.h"
+
+class CNavArea;
+class CCSNavArea;
+class CBaseEntity; 
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * The CSNavMesh is the global interface to the Navigation Mesh.
+ * @todo Make this an abstract base class interface, and derive mod-specific implementations.
+ */
+class CSNavMesh : public CNavMesh
+{
+public:
+	CSNavMesh( void );
+	virtual ~CSNavMesh();
+
+	virtual CNavArea *CreateArea( void ) const;							// CNavArea factory
+
+	virtual unsigned int GetSubVersionNumber( void ) const;									// returns sub-version number of data format used by derived classes
+	virtual void SaveCustomData( CUtlBuffer &fileBuffer ) const;							// store custom mesh data for derived classes
+	virtual void LoadCustomData( CUtlBuffer &fileBuffer, unsigned int subVersion );			// load custom mesh data for derived classes
+
+	virtual void Reset( void );											///< destroy Navigation Mesh data and revert to initial state
+	virtual void Update( void );										///< invoked on each game frame
+
+	virtual NavErrorType Load( void );									// load navigation data from a file
+	virtual NavErrorType PostLoad( unsigned int version );				// (EXTEND) invoked after all areas have been loaded - for pointer binding, etc
+	virtual bool Save( void ) const;									///< store Navigation Mesh to a file
+
+	void ClearPlayerCounts( void );										///< zero player counts in all areas
+
+protected:
+	virtual void BeginCustomAnalysis( bool bIncremental );
+	virtual void PostCustomAnalysis( void );							// invoked when custom analysis step is complete
+	virtual void EndCustomAnalysis();
+
+private:
+};
+
+#endif // _CS_NAV_MESH_H_
diff --git a/game/server/cstrike/cs_nav_node.cpp b/game/server/cstrike/cs_nav_node.cpp
new file mode 100644
index 00000000..93f7b1ff
--- /dev/null
+++ b/game/server/cstrike/cs_nav_node.cpp
@@ -0,0 +1,383 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_node.cpp
+// AI Navigation Nodes
+// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
+
+#include "cbase.h"
+#include "cs_nav_node.h"
+#include "nav_colors.h"
+#include "nav_mesh.h"
+
+NavDirType Opposite[ NUM_DIRECTIONS ] = { SOUTH, WEST, NORTH, EAST };
+
+CSNavNode *CSNavNode::m_list = NULL;
+unsigned int CSNavNode::m_listLength = 0;
+unsigned int CSNavNode::m_nextID = 1;
+
+ConVar nav_show_nodes( "nav_show_nodes", "0" );
+
+
+//--------------------------------------------------------------------------------------------------------------
+class LookAtTarget
+{
+public:
+	LookAtTarget( const Vector &target )
+	{
+		m_target = target;
+	}
+
+	bool operator()( CBasePlayer *player )
+	{
+		QAngle angles;
+		Vector to = m_target - player->GetAbsOrigin();
+		VectorAngles( to, angles );
+
+		player->SetLocalAngles( angles );
+		player->SnapEyeAngles( angles );
+		return true;
+	}
+
+private:
+	Vector m_target;
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Constructor
+ */
+CSNavNode::CSNavNode( const Vector &pos, const Vector &normal, CSNavNode *parent )
+{
+	m_pos = pos;
+	m_normal = normal;
+
+	m_id = m_nextID++;
+
+	int i;
+	for( i=0; i<NUM_DIRECTIONS; ++i )
+	{
+		m_to[ i ] = NULL;
+	}
+
+	for ( i=0; i<NUM_CORNERS; ++i )
+	{
+		m_crouch[ i ] = false;
+	}
+
+	m_visited = 0;
+	m_parent = parent;
+
+	m_next = m_list;
+	m_list = this;
+	m_listLength++;
+
+	m_isCovered = false;
+	m_area = NULL;
+
+	m_attributeFlags = 0;
+
+	if ( nav_show_nodes.GetBool() )
+	{
+		NDebugOverlay::Cross3D( m_pos, 10.0f, 128, 128, 128, true, 10.0f );
+		NDebugOverlay::Cross3D( m_pos, 10.0f, 255, 255, 255, false, 10.0f );
+
+		LookAtTarget lookAt( m_pos );
+		ForEachPlayer( lookAt );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+#if DEBUG_NAV_NODES
+ConVar nav_show_node_id( "nav_show_node_id", "0" );
+ConVar nav_test_node( "nav_test_node", "0" );
+ConVar nav_test_node_crouch( "nav_test_node_crouch", "0" );
+ConVar nav_test_node_crouch_dir( "nav_test_node_crouch_dir", "4" );
+#endif // DEBUG_NAV_NODES
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CSNavNode::Draw( void )
+{
+#if DEBUG_NAV_NODES
+	if ( !nav_show_nodes.GetBool() )
+		return;
+
+	int r = 0, g = 0, b = 0;
+
+	if ( m_isCovered )
+	{
+		if ( GetAttributes() & NAV_MESH_CROUCH )
+		{
+			b = 255;
+		}
+		else
+		{
+			r = 255;
+		}
+	}
+	else
+	{
+		if ( GetAttributes() & NAV_MESH_CROUCH )
+		{
+			b = 255;
+		}
+		g = 255;
+	}
+
+	NDebugOverlay::Cross3D( m_pos, 2, r, g, b, true, 0.1f );
+
+	if ( (!m_isCovered && nav_show_node_id.GetBool()) || (m_isCovered && nav_show_node_id.GetInt() < 0) )
+	{
+		char text[16];
+		Q_snprintf( text, sizeof( text ), "%d", m_id );
+		NDebugOverlay::Text( m_pos, text, true, 0.1f );
+	}
+
+	if ( (unsigned int)(nav_test_node.GetInt()) == m_id )
+	{
+		TheNavMesh->TestArea( this, 1, 1 );
+		nav_test_node.SetValue( 0 );
+	}
+
+	if ( (unsigned int)(nav_test_node_crouch.GetInt()) == m_id )
+	{
+		CheckCrouch();
+		nav_test_node_crouch.SetValue( 0 );
+	}
+
+	if ( GetAttributes() & NAV_MESH_CROUCH )
+	{
+		int i;
+		for( i=0; i<NUM_CORNERS; i++ )
+		{
+			if ( m_crouch[i] )
+			{
+				Vector2D dir;
+				CornerToVector2D( (NavCornerType)i, &dir );
+
+				const float scale = 3.0f;
+				Vector scaled( dir.x * scale, dir.y * scale, 0 );
+
+				NDebugOverlay::HorzArrow( m_pos, m_pos + scaled, 0.5, 0, 0, 255, 255, true, 0.1f );
+			}
+		}
+	}
+
+#endif // DEBUG_NAV_NODES
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CSNavNode::CheckCrouch( void )
+{
+	CTraceFilterWalkableEntities filter( NULL, COLLISION_GROUP_PLAYER_MOVEMENT, WALK_THRU_EVERYTHING );
+	trace_t tr;
+
+	// Trace downward from duck height to find the max floor height for the node's surroundings
+	Vector mins( -HalfHumanWidth, -HalfHumanWidth, 0 );
+	Vector maxs( HalfHumanWidth, HalfHumanWidth, 0 );
+	Vector start( m_pos.x, m_pos.y, m_pos.z + VEC_DUCK_HULL_MAX.z - 0.1f );
+	UTIL_TraceHull(
+		start,
+		m_pos,
+		mins,
+		maxs,
+		MASK_PLAYERSOLID_BRUSHONLY,
+		&filter,
+		&tr );
+
+	Vector groundPos = tr.endpos;
+
+	if ( tr.startsolid && !tr.allsolid )
+	{
+		// Try going down out of the solid and re-check for the floor height
+		start.z -= tr.endpos.z - 0.1f;
+
+		UTIL_TraceHull(
+			start,
+			m_pos,
+			mins,
+			maxs,
+			MASK_PLAYERSOLID_BRUSHONLY,
+			&filter,
+			&tr );
+
+		groundPos = tr.endpos;
+	}
+
+	if ( tr.startsolid )
+	{
+		// we don't even have duck height clear.  try a simple check to find floor height.
+		float x, y;
+
+		// Find the highest floor z - for a player to stand in this area, we need a full
+		// VEC_HULL_MAX.z of clearance above this height at all points.
+		float maxFloorZ = m_pos.z;
+		for( y = -HalfHumanWidth; y <= HalfHumanWidth + 0.1f; y += HalfHumanWidth )
+		{
+			for( x = -HalfHumanWidth; x <= HalfHumanWidth + 0.1f; x += HalfHumanWidth )
+			{
+				float floorZ;
+				if ( TheNavMesh->GetGroundHeight( m_pos, &floorZ ) )
+				{
+					maxFloorZ = MAX( maxFloorZ, floorZ + 0.1f );
+				}
+			}
+		}
+
+		groundPos.Init( m_pos.x, m_pos.y, maxFloorZ );
+	}
+
+	// For each direction, trace upwards from our best ground height to VEC_HULL_MAX.z to see if we have standing room.
+	for ( int i=0; i<NUM_CORNERS; ++i )
+	{
+#if DEBUG_NAV_NODES
+		if ( nav_test_node_crouch_dir.GetInt() != NUM_CORNERS && i != nav_test_node_crouch_dir.GetInt() )
+			continue;
+#endif // DEBUG_NAV_NODES
+
+		NavCornerType corner = (NavCornerType)i;
+		Vector2D cornerVec;
+		CornerToVector2D( corner, &cornerVec );
+
+		Vector actualGroundPos = groundPos; // we might need to adjust this if the tracehull failed above and we fell back to m_pos.z
+
+		// Build a mins/maxs pair for the HumanWidth x HalfHumanWidth box facing the appropriate direction
+		mins.Init();
+		maxs.Init( cornerVec.x * HalfHumanWidth, cornerVec.y * HalfHumanWidth, 0 );
+
+		// now make sure that mins is smaller than maxs
+		for ( int j=0; j<3; ++j )
+		{
+			if ( mins[j] > maxs[j] )
+			{
+				float tmp = mins[j];
+				mins[j] = maxs[j];
+				maxs[j] = tmp;
+			}
+		}
+
+		UTIL_TraceHull(
+			actualGroundPos + Vector( 0, 0, 0.1f ),
+			actualGroundPos + Vector( 0, 0, VEC_HULL_MAX.z - 0.2f ),
+			mins,
+			maxs,
+			MASK_PLAYERSOLID_BRUSHONLY,
+			&filter,
+			&tr );
+		actualGroundPos.z += tr.fractionleftsolid * VEC_HULL_MAX.z;
+		float maxHeight = actualGroundPos.z + VEC_DUCK_HULL_MAX.z;
+		for ( ; tr.startsolid && actualGroundPos.z <= maxHeight; actualGroundPos.z += 1.0f )
+		{
+			// In case we didn't find a good ground pos above, we could start in the ground.  Move us up some.
+			UTIL_TraceHull(
+				actualGroundPos + Vector( 0, 0, 0.1f ),
+				actualGroundPos + Vector( 0, 0, VEC_HULL_MAX.z - 0.2f ),
+				mins,
+				maxs,
+				MASK_PLAYERSOLID_BRUSHONLY,
+				&filter,
+				&tr );
+		}
+		if (tr.startsolid || tr.fraction != 1.0f)
+		{
+			SetAttributes( NAV_MESH_CROUCH );
+			m_crouch[corner] = true;
+		}
+
+#if DEBUG_NAV_NODES
+		if ( nav_show_nodes.GetBool() )
+		{
+			if ( nav_test_node_crouch_dir.GetInt() == i || nav_test_node_crouch_dir.GetInt() == NUM_CORNERS  )
+			{
+				if ( tr.startsolid )
+				{
+					NDebugOverlay::Box( actualGroundPos, mins, maxs+Vector( 0, 0, VEC_HULL_MAX.z), 255, 0, 0, 10, 20.0f );
+				}
+				else if ( m_crouch[corner] )
+				{
+					NDebugOverlay::Box( actualGroundPos, mins, maxs+Vector( 0, 0, VEC_HULL_MAX.z), 0, 0, 255, 10, 20.0f );
+				}
+				else
+				{
+					NDebugOverlay::Box( actualGroundPos, mins, maxs+Vector( 0, 0, VEC_HULL_MAX.z), 0, 255, 0, 10, 10.0f );
+				}
+			}
+		}
+#endif // DEBUG_NAV_NODES
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Create a connection FROM this node TO the given node, in the given direction
+ */
+void CSNavNode::ConnectTo( CSNavNode *node, NavDirType dir )
+{
+	m_to[ dir ] = node;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return node at given position.
+ * @todo Need a hash table to make this lookup fast
+ */
+CSNavNode *CSNavNode::GetNode( const Vector &pos )
+{
+	const float tolerance = 0.45f * GenerationStepSize;			// 1.0f
+
+	for( CSNavNode *node = m_list; node; node = node->m_next )
+	{
+		float dx = fabs( node->m_pos.x - pos.x );
+		float dy = fabs( node->m_pos.y - pos.y );
+		float dz = fabs( node->m_pos.z - pos.z );
+
+		if (dx < tolerance && dy < tolerance && dz < tolerance)
+			return node;
+	}
+
+	return NULL;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this node is bidirectionally linked to 
+ * another node in the given direction
+ */
+BOOL CSNavNode::IsBiLinked( NavDirType dir ) const
+{
+	if (m_to[ dir ] && m_to[ dir ]->m_to[ Opposite[dir] ] == this)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this node is the NW corner of a quad of nodes
+ * that are all bidirectionally linked.
+ */
+BOOL CSNavNode::IsClosedCell( void ) const
+{
+	if (IsBiLinked( SOUTH ) &&
+		IsBiLinked( EAST ) &&
+		m_to[ EAST ]->IsBiLinked( SOUTH ) &&
+		m_to[ SOUTH ]->IsBiLinked( EAST ) &&
+		m_to[ EAST ]->m_to[ SOUTH ] == m_to[ SOUTH ]->m_to[ EAST ])
+	{
+		return true;
+	}
+
+	return false;
+}
+
diff --git a/game/server/cstrike/cs_nav_node.h b/game/server/cstrike/cs_nav_node.h
new file mode 100644
index 00000000..449f97e5
--- /dev/null
+++ b/game/server/cstrike/cs_nav_node.h
@@ -0,0 +1,135 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_node.h
+// Navigation Nodes are used when generating a Navigation Mesh by point sampling the map
+// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
+
+#ifndef _CS_NAV_NODE_H_
+#define _CS_NAV_NODE_H_
+
+#include "cs_nav.h"
+
+// If DEBUG_NAV_NODES is true, nav_show_nodes controls drawing node positions, and
+// nav_show_node_id allows you to show the IDs of nodes that didn't get used to create areas.
+#ifdef _DEBUG
+#define DEBUG_NAV_NODES 1
+#else
+#define DEBUG_NAV_NODES 0
+#endif
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Navigation Nodes.
+ * These Nodes encapsulate world locations, and ways to get from one location to an adjacent one.
+ * Note that these links are not necessarily commutative (falling off of a ledge, for example).
+ */
+class CSNavNode
+{
+public:
+	CSNavNode( const Vector &pos, const Vector &normal, CSNavNode *parent = NULL );
+
+	static CSNavNode *GetNode( const Vector &pos );					///< return navigation node at the position, or NULL if none exists
+
+	CSNavNode *GetConnectedNode( NavDirType dir ) const;				///< get navigation node connected in given direction, or NULL if cant go that way
+	const Vector *GetPosition( void ) const;
+	const Vector *GetNormal( void ) const		{ return &m_normal; }
+	unsigned int GetID( void ) const			{ return m_id; }
+
+	static CSNavNode *GetFirst( void )			{ return m_list; }
+	static unsigned int GetListLength( void )	{ return m_listLength; }
+	CSNavNode *GetNext( void )					{ return m_next; }
+
+	void Draw( void );
+
+	void ConnectTo( CSNavNode *node, NavDirType dir );				///< create a connection FROM this node TO the given node, in the given direction
+	CSNavNode *GetParent( void ) const;
+
+	void MarkAsVisited( NavDirType dir );							///< mark the given direction as having been visited
+	BOOL HasVisited( NavDirType dir );								///< return TRUE if the given direction has already been searched
+	BOOL IsBiLinked( NavDirType dir ) const;						///< node is bidirectionally linked to another node in the given direction
+	BOOL IsClosedCell( void ) const;								///< node is the NW corner of a bi-linked quad of nodes
+
+	void Cover( void )				{ m_isCovered = true; }			///< @todo Should pass in area that is covering
+	BOOL IsCovered( void ) const	{ return m_isCovered; }			///< return true if this node has been covered by an area
+
+	void AssignArea( CNavArea *area );								///< assign the given area to this node
+	CNavArea *GetArea( void ) const;								///< return associated area
+
+	void SetAttributes( unsigned char bits )		{ m_attributeFlags = bits; }
+	unsigned char GetAttributes( void ) const		{ return m_attributeFlags; }
+
+private:
+	friend class CNavMesh;
+
+	void CheckCrouch( void );
+
+	Vector m_pos;													///< position of this node in the world
+	Vector m_normal;												///< surface normal at this location
+	CSNavNode *m_to[ NUM_DIRECTIONS ];								///< links to north, south, east, and west. NULL if no link
+	unsigned int m_id;												///< unique ID of this node
+	unsigned char m_attributeFlags;									///< set of attribute bit flags (see NavAttributeType)
+
+	static CSNavNode *m_list;										///< the master list of all nodes for this map
+	static unsigned int m_listLength;
+	static unsigned int m_nextID;
+	CSNavNode *m_next;												///< next link in master list
+
+	// below are only needed when generating
+	unsigned char m_visited;										///< flags for automatic node generation. If direction bit is clear, that direction hasn't been explored yet.
+	CSNavNode *m_parent;												///< the node prior to this in the search, which we pop back to when this node's search is done (a stack)
+	bool m_isCovered;												///< true when this node is "covered" by a CNavArea
+	CNavArea *m_area;												///< the area this node is contained within
+
+	bool m_crouch[ NUM_CORNERS ];
+};
+
+//--------------------------------------------------------------------------------------------------------------
+//
+// Inlines
+//
+
+inline CSNavNode *CSNavNode::GetConnectedNode( NavDirType dir ) const
+{
+	return m_to[ dir ];
+}
+
+inline const Vector *CSNavNode::GetPosition( void ) const
+{
+	return &m_pos;
+}
+
+inline CSNavNode *CSNavNode::GetParent( void ) const
+{
+	return m_parent;
+}
+
+inline void CSNavNode::MarkAsVisited( NavDirType dir )
+{
+	m_visited |= (1 << dir);
+}
+
+inline BOOL CSNavNode::HasVisited( NavDirType dir )
+{
+	if (m_visited & (1 << dir))
+		return true;
+
+	return false;
+}
+
+inline void CSNavNode::AssignArea( CNavArea *area )
+{
+	m_area = area;
+}
+
+inline CNavArea *CSNavNode::GetArea( void ) const
+{
+	return m_area;
+}
+
+
+#endif // _CS_NAV_NODE_H_
diff --git a/game/server/cstrike/cs_nav_path.cpp b/game/server/cstrike/cs_nav_path.cpp
new file mode 100644
index 00000000..5a1a9ce0
--- /dev/null
+++ b/game/server/cstrike/cs_nav_path.cpp
@@ -0,0 +1,1208 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_path.cpp
+// Encapsulation of a path through space
+// Author: Michael S. Booth (mike@turtlerockstudios.com), November 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "cs_player.h"
+
+#include "nav_mesh.h"
+#include "cs_nav_path.h"
+#include "bot_util.h"
+#include "improv_locomotor.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#ifdef _WIN32
+#pragma warning (disable:4701)				// disable warning that variable *may* not be initialized 
+#endif
+
+
+#define DrawLine( from, to, duration, red, green, blue )		NDebugOverlay::Line( from, to, red, green, blue, true, 0.1f )
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine actual path positions
+ */
+bool CCSNavPath::ComputePathPositions( void )
+{
+	if (m_segmentCount == 0)
+		return false;
+
+	// start in first area's center
+	m_path[0].pos = m_path[0].area->GetCenter();
+	m_path[0].ladder = NULL;
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+
+	for( int i=1; i<m_segmentCount; ++i )
+	{
+		const PathSegment *from = &m_path[ i-1 ];
+		PathSegment *to = &m_path[ i ];
+
+		if (to->how <= GO_WEST)		// walk along the floor to the next area
+		{
+			to->ladder = NULL;
+
+			// compute next point, keeping path as straight as possible
+			from->area->ComputeClosestPointInPortal( to->area, (NavDirType)to->how, from->pos, &to->pos );
+
+			// move goal position into the goal area a bit
+			const float stepInDist = 5.0f;		// how far to "step into" an area - must be less than min area size
+			AddDirectionVector( &to->pos, (NavDirType)to->how, stepInDist );
+
+			// we need to walk out of "from" area, so keep Z where we can reach it
+			to->pos.z = from->area->GetZ( to->pos );
+
+			// if this is a "jump down" connection, we must insert an additional point on the path
+			if (to->area->IsConnected( from->area, NUM_DIRECTIONS ) == false)
+			{
+				// this is a "jump down" link
+
+				// compute direction of path just prior to "jump down"
+				Vector2D dir;
+				DirectionToVector2D( (NavDirType)to->how, &dir );
+
+				// shift top of "jump down" out a bit to "get over the ledge"
+				const float pushDist = 25.0f;
+				to->pos.x += pushDist * dir.x;
+				to->pos.y += pushDist * dir.y;
+
+				// insert a duplicate node to represent the bottom of the fall
+				if (m_segmentCount < MAX_PATH_SEGMENTS-1)
+				{
+					// copy nodes down
+					for( int j=m_segmentCount; j>i; --j )
+						m_path[j] = m_path[j-1];
+
+					// path is one node longer
+					++m_segmentCount;
+
+					// move index ahead into the new node we just duplicated
+					++i;
+
+					m_path[i].pos.x = to->pos.x + pushDist * dir.x;
+					m_path[i].pos.y = to->pos.y + pushDist * dir.y;
+
+					// put this one at the bottom of the fall
+					m_path[i].pos.z = to->area->GetZ( m_path[i].pos );
+				}
+			}
+		}
+		else if (to->how == GO_LADDER_UP)		// to get to next area, must go up a ladder
+		{
+			// find our ladder
+			const NavLadderConnectVector *ladders = from->area->GetLadders( CNavLadder::LADDER_UP );
+			int it;
+			for( it=0; it<ladders->Count(); ++it )
+			{
+				CNavLadder *ladder = (*ladders)[ it ].ladder;
+
+				// can't use "behind" area when ascending...
+				if (ladder->m_topForwardArea == to->area ||
+					ladder->m_topLeftArea == to->area ||
+					ladder->m_topRightArea == to->area)
+				{
+					to->ladder = ladder;
+					to->pos = ladder->m_bottom + ladder->GetNormal() * 2.0f * HalfHumanWidth;
+					break;
+				}
+			}
+
+			if (it == ladders->Count())
+			{
+				//PrintIfWatched( "ERROR: Can't find ladder in path\n" );
+				return false;
+			}
+		}
+		else if (to->how == GO_LADDER_DOWN)		// to get to next area, must go down a ladder
+		{
+			// find our ladder
+			const NavLadderConnectVector *ladders = from->area->GetLadders( CNavLadder::LADDER_DOWN );
+			int it;
+			for( it=0; it<ladders->Count(); ++it )
+			{
+				CNavLadder *ladder = (*ladders)[ it ].ladder;
+
+				if (ladder->m_bottomArea == to->area)
+				{
+					to->ladder = ladder;
+					to->pos = ladder->m_top;
+					to->pos = ladder->m_top - ladder->GetNormal() * 2.0f * HalfHumanWidth;
+					break;
+				}
+			}
+
+			if (it == ladders->Count())
+			{
+				//PrintIfWatched( "ERROR: Can't find ladder in path\n" );
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if position is at the end of the path
+ */
+bool CCSNavPath::IsAtEnd( const Vector &pos ) const
+{
+	if (!IsValid())
+		return false;
+
+	const float epsilon = 20.0f;
+	return (pos - GetEndpoint()).IsLengthLessThan( epsilon );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return length of path from start to finish
+ */
+float CCSNavPath::GetLength( void ) const
+{
+	float length = 0.0f;
+	for( int i=1; i<GetSegmentCount(); ++i )
+	{
+		length += (m_path[i].pos - m_path[i-1].pos).Length();
+	}
+
+	return length;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return point a given distance along the path - if distance is out of path bounds, point is clamped to start/end
+ * @todo Be careful of returning "positions" along one-way drops, ladders, etc.
+ */
+bool CCSNavPath::GetPointAlongPath( float distAlong, Vector *pointOnPath ) const
+{
+	if (!IsValid() || pointOnPath == NULL)
+		return false;
+
+	if (distAlong <= 0.0f)
+	{
+		*pointOnPath = m_path[0].pos;
+		return true;
+	}
+
+	float lengthSoFar = 0.0f;
+	float segmentLength;
+	Vector dir;
+	for( int i=1; i<GetSegmentCount(); ++i )
+	{
+		dir = m_path[i].pos - m_path[i-1].pos;
+		segmentLength = dir.Length();
+
+		if (segmentLength + lengthSoFar >= distAlong)
+		{
+			// desired point is on this segment of the path
+			float delta = distAlong - lengthSoFar;
+			float t = delta / segmentLength;
+
+			*pointOnPath = m_path[i].pos + t * dir;
+
+			return true;
+		}
+
+		lengthSoFar += segmentLength;
+	}
+
+	*pointOnPath = m_path[ GetSegmentCount()-1 ].pos;
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the node index closest to the given distance along the path without going over - returns (-1) if error
+ */
+int CCSNavPath::GetSegmentIndexAlongPath( float distAlong ) const
+{
+	if (!IsValid())
+		return -1;
+
+	if (distAlong <= 0.0f)
+	{
+		return 0;
+	}
+
+	float lengthSoFar = 0.0f;
+	Vector dir;
+	for( int i=1; i<GetSegmentCount(); ++i )
+	{
+		lengthSoFar += (m_path[i].pos - m_path[i-1].pos).Length();
+
+		if (lengthSoFar > distAlong)
+		{
+			return i-1;
+		}
+	}
+
+	return GetSegmentCount()-1;
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute closest point on path to given point
+ * NOTE: This does not do line-of-sight tests, so closest point may be thru the floor, etc
+ */
+bool CCSNavPath::FindClosestPointOnPath( const Vector *worldPos, int startIndex, int endIndex, Vector *close ) const
+{
+	if (!IsValid() || close == NULL)
+		return false;
+
+	Vector along, toWorldPos;
+	Vector pos;
+	const Vector *from, *to;
+	float length;
+	float closeLength;
+	float closeDistSq = 9999999999.9;
+	float distSq;
+
+	for( int i=startIndex; i<=endIndex; ++i )
+	{
+		from = &m_path[i-1].pos;
+		to = &m_path[i].pos;
+
+		// compute ray along this path segment
+		along = *to - *from;
+
+		// make it a unit vector along the path
+		length = along.NormalizeInPlace();
+
+		// compute vector from start of segment to our point
+		toWorldPos = *worldPos - *from;
+
+		// find distance of closest point on ray
+		closeLength = DotProduct( toWorldPos, along );
+
+		// constrain point to be on path segment
+		if (closeLength <= 0.0f)
+			pos = *from;
+		else if (closeLength >= length)
+			pos = *to;
+		else
+			pos = *from + closeLength * along;
+
+		distSq = (pos - *worldPos).LengthSqr();
+
+		// keep the closest point so far
+		if (distSq < closeDistSq)
+		{
+			closeDistSq = distSq;
+			*close = pos;
+		}
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Build trivial path when start and goal are in the same nav area
+ */
+bool CCSNavPath::BuildTrivialPath( const Vector &start, const Vector &goal )
+{
+	m_segmentCount = 0;
+
+	CNavArea *startArea = TheNavMesh->GetNearestNavArea( start );
+	if (startArea == NULL)
+		return false;
+
+	CNavArea *goalArea = TheNavMesh->GetNearestNavArea( goal );
+	if (goalArea == NULL)
+		return false;
+
+	m_segmentCount = 2;
+
+	m_path[0].area = startArea;
+	m_path[0].pos.x = start.x;
+	m_path[0].pos.y = start.y;
+	m_path[0].pos.z = startArea->GetZ( start );
+	m_path[0].ladder = NULL;
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+
+	m_path[1].area = goalArea;
+	m_path[1].pos.x = goal.x;
+	m_path[1].pos.y = goal.y;
+	m_path[1].pos.z = goalArea->GetZ( goal );
+	m_path[1].ladder = NULL;
+	m_path[1].how = NUM_TRAVERSE_TYPES;
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Draw the path for debugging.
+ */
+void CCSNavPath::Draw( const Vector &color )
+{
+	if (!IsValid())
+		return;
+
+	for( int i=1; i<m_segmentCount; ++i )
+	{
+		DrawLine( m_path[i-1].pos + Vector( 0, 0, HalfHumanHeight ), 
+				  m_path[i].pos + Vector( 0, 0, HalfHumanHeight ), 2, 255 * color.x, 255 * color.y, 255 * color.z );
+	}
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Check line of sight from 'anchor' node on path to subsequent nodes until
+ * we find a node that can't been seen from 'anchor'.
+ */
+int CCSNavPath::FindNextOccludedNode( int anchor )
+{
+	for( int i=anchor+1; i<m_segmentCount; ++i )
+	{
+		// don't remove ladder nodes
+		if (m_path[i].ladder)
+			return i;
+
+		if (!IsWalkableTraceLineClear( m_path[ anchor ].pos, m_path[ i ].pos ))
+		{
+			// cant see this node from anchor node
+			return i;
+		}
+
+		Vector anchorPlusHalf =  m_path[ anchor ].pos + Vector( 0, 0, HalfHumanHeight );
+		Vector iPlusHalf =  m_path[ i ].pos +Vector( 0, 0, HalfHumanHeight );
+		if (!IsWalkableTraceLineClear( anchorPlusHalf, iPlusHalf) )
+		{
+			// cant see this node from anchor node
+			return i;
+		}
+
+		Vector anchorPlusFull =  m_path[ anchor ].pos + Vector( 0, 0, HumanHeight );
+		Vector iPlusFull = m_path[ i ].pos + Vector( 0, 0, HumanHeight );
+		if (!IsWalkableTraceLineClear( anchorPlusFull, iPlusFull ))
+		{
+			// cant see this node from anchor node
+			return i;
+		}
+	}
+
+	return m_segmentCount;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Smooth out path, removing redundant nodes
+ */
+void CCSNavPath::Optimize( void )
+{
+// DONT USE THIS: Optimizing the path results in cutting thru obstacles
+return;
+
+	if (m_segmentCount < 3)
+		return;
+
+	int anchor = 0;
+
+	while( anchor < m_segmentCount )
+	{
+		int occluded = FindNextOccludedNode( anchor );
+		int nextAnchor = occluded-1;
+
+		if (nextAnchor > anchor)
+		{
+			// remove redundant nodes between anchor and nextAnchor
+			int removeCount = nextAnchor - anchor - 1;
+			if (removeCount > 0)
+			{
+				for( int i=nextAnchor; i<m_segmentCount; ++i )
+				{
+					m_path[i-removeCount] = m_path[i];
+				}
+				m_segmentCount -= removeCount;
+			}
+		}
+
+		++anchor;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+
+/**
+ * Constructor
+ */
+CNavPathFollower::CNavPathFollower( void )
+{
+	m_improv = NULL;
+	m_path = NULL;
+
+	m_segmentIndex = 0;
+	m_isLadderStarted = false;
+
+	m_isDebug = false;
+}
+
+void CNavPathFollower::Reset( void )
+{
+	m_segmentIndex = 1;
+	m_isLadderStarted = false;
+
+	m_stuckMonitor.Reset();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move improv along path
+ */
+void CNavPathFollower::Update( float deltaT, bool avoidObstacles )
+{
+	if (m_path == NULL || m_path->IsValid() == false)
+		return;
+
+	const CCSNavPath::PathSegment *node = (*m_path)[ m_segmentIndex ];
+
+	if (node == NULL)
+	{
+		m_improv->OnMoveToFailure( m_path->GetEndpoint(), CImprovLocomotor::FAIL_INVALID_PATH );
+		m_path->Invalidate();
+		return;
+	}
+
+	// handle ladders
+	/*
+	if (node->ladder)
+	{
+		const Vector *approachPos = NULL;
+		const Vector *departPos = NULL;
+
+		if (m_segmentIndex)
+			approachPos = &(*m_path)[ m_segmentIndex-1 ]->pos;
+
+		if (m_segmentIndex < m_path->GetSegmentCount()-1)
+			departPos = &(*m_path)[ m_segmentIndex+1 ]->pos;
+
+		if (!m_isLadderStarted)
+		{
+			// set up ladder movement
+			m_improv->StartLadder( node->ladder, node->how, approachPos, departPos );
+			m_isLadderStarted = true;
+		}
+
+		// move improv along ladder
+		if (m_improv->TraverseLadder( node->ladder, node->how, approachPos, departPos, deltaT ))
+		{
+			// completed ladder
+			++m_segmentIndex;
+		}
+		return;
+	}
+	*/
+
+	// reset ladder init flag
+	m_isLadderStarted = false;
+
+	//
+	// Check if we reached the end of the path
+	//
+	const float closeRange = 20.0f;
+	if ((m_improv->GetFeet() - node->pos).IsLengthLessThan( closeRange ))
+	{
+		++m_segmentIndex;
+
+		if (m_segmentIndex >= m_path->GetSegmentCount())
+		{
+			m_improv->OnMoveToSuccess( m_path->GetEndpoint() );
+			m_path->Invalidate();
+			return;
+		}
+	}
+
+
+	m_goal = node->pos;
+
+	const float aheadRange = 300.0f;
+	m_segmentIndex = FindPathPoint( aheadRange, &m_goal, &m_behindIndex );
+	if (m_segmentIndex >= m_path->GetSegmentCount())
+		m_segmentIndex = m_path->GetSegmentCount()-1;
+
+
+	bool isApproachingJumpArea = false;
+
+	//
+	// Crouching
+	//
+	if (!m_improv->IsUsingLadder())
+	{
+		// because hostage crouching is not really supported by the engine,
+		// if we are standing in a crouch area, we must crouch to avoid collisions
+		if (m_improv->GetLastKnownArea() && 
+			m_improv->GetLastKnownArea()->GetAttributes() & NAV_MESH_CROUCH && 
+			!(m_improv->GetLastKnownArea()->GetAttributes() & NAV_MESH_JUMP))
+		{
+			m_improv->Crouch();
+		}
+
+		// if we are approaching a crouch area, crouch
+		// if there are no crouch areas coming up, stand
+		const float crouchRange = 50.0f;
+		bool didCrouch = false;
+		for( int i=m_segmentIndex; i<m_path->GetSegmentCount(); ++i )
+		{
+			const CNavArea *to = (*m_path)[i]->area;
+
+			// if there is a jump area on the way to the crouch area, don't crouch as it messes up the jump
+			if (to->GetAttributes() & NAV_MESH_JUMP)
+			{
+				isApproachingJumpArea = true;
+				break;
+			}
+
+			Vector close;
+			to->GetClosestPointOnArea( m_improv->GetCentroid(), &close );
+
+			if ((close - m_improv->GetFeet()).AsVector2D().IsLengthGreaterThan( crouchRange ))
+				break;
+
+			if (to->GetAttributes() & NAV_MESH_CROUCH)
+			{
+				m_improv->Crouch();
+				didCrouch = true;
+				break;
+			}
+
+		}
+
+		if (!didCrouch && !m_improv->IsJumping())
+		{
+			// no crouch areas coming up
+			m_improv->StandUp();
+		}
+
+	}	// end crouching logic
+
+
+	if (m_isDebug)
+	{
+		m_path->Draw();
+		UTIL_DrawBeamPoints( m_improv->GetCentroid(), m_goal + Vector( 0, 0, StepHeight ), 1, 255, 0, 255 );
+		UTIL_DrawBeamPoints( m_goal + Vector( 0, 0, StepHeight ), m_improv->GetCentroid(), 1, 255, 0, 255 );
+	}
+
+	// check if improv becomes stuck
+	m_stuckMonitor.Update( m_improv );
+
+
+	// if improv has been stuck for too long, give up
+	const float giveUpTime = 2.0f;
+	if (m_stuckMonitor.GetDuration() > giveUpTime)
+	{
+		m_improv->OnMoveToFailure( m_path->GetEndpoint(), CImprovLocomotor::FAIL_STUCK );
+		m_path->Invalidate();
+		return;
+	}
+
+
+	// if our goal is high above us, we must have fallen
+	if (m_goal.z - m_improv->GetFeet().z > JumpCrouchHeight)
+	{
+		const float closeRange = 75.0f;
+		Vector2D to( m_improv->GetFeet().x - m_goal.x, m_improv->GetFeet().y - m_goal.y );
+		if (to.IsLengthLessThan( closeRange ))
+		{
+			// we can't reach the goal position
+			// check if we can reach the next node, in case this was a "jump down" situation
+			const CCSNavPath::PathSegment *nextNode = (*m_path)[ m_behindIndex+1 ];
+			if (m_behindIndex >=0 && nextNode)
+			{
+				if (nextNode->pos.z - m_improv->GetFeet().z > JumpCrouchHeight)
+				{
+					// the next node is too high, too - we really did fall of the path
+					m_improv->OnMoveToFailure( m_path->GetEndpoint(), CImprovLocomotor::FAIL_FELL_OFF );
+					m_path->Invalidate();
+					return;
+				}
+			}
+			else
+			{
+				// fell trying to get to the last node in the path
+				m_improv->OnMoveToFailure( m_path->GetEndpoint(), CImprovLocomotor::FAIL_FELL_OFF );
+				m_path->Invalidate();
+				return;
+			}
+		}
+	}
+
+
+	// avoid small obstacles
+	if (avoidObstacles && !isApproachingJumpArea && !m_improv->IsJumping() && m_segmentIndex < m_path->GetSegmentCount()-1)
+	{
+		FeelerReflexAdjustment( &m_goal );
+
+		// currently, this is only used for hostages, and their collision physics stinks
+		// do more feeler checks to avoid short obstacles
+		/*
+		const float inc = 0.25f;
+		for( float t = 0.5f; t < 1.0f; t += inc )
+		{
+			FeelerReflexAdjustment( &m_goal, t * StepHeight );
+		}
+		*/
+
+	}
+
+	// move improv along path
+	m_improv->TrackPath( m_goal, deltaT );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest point to our current position on our current path
+ * If "local" is true, only check the portion of the path surrounding m_pathIndex.
+ */
+int CNavPathFollower::FindOurPositionOnPath( Vector *close, bool local ) const
+{
+	if (!m_path->IsValid())
+		return -1;
+
+	Vector along, toFeet;
+	Vector feet = m_improv->GetFeet();
+	Vector eyes = m_improv->GetEyes();
+	Vector pos;
+	const Vector *from, *to;
+	float length;
+	float closeLength;
+	float closeDistSq = 9999999999.9;
+	int closeIndex = -1;
+	float distSq;
+
+	int start, end;
+
+	if (local)
+	{
+		start = m_segmentIndex - 3;
+		if (start < 1)
+			start = 1;
+
+		end = m_segmentIndex + 3;
+		if (end > m_path->GetSegmentCount())
+			end = m_path->GetSegmentCount();
+	}
+	else
+	{
+		start = 1;
+		end = m_path->GetSegmentCount();
+	}
+
+	for( int i=start; i<end; ++i )
+	{
+		from = &(*m_path)[i-1]->pos;
+		to = &(*m_path)[i]->pos;
+
+		// compute ray along this path segment
+		along = *to - *from;
+
+		// make it a unit vector along the path
+		length = along.NormalizeInPlace();
+
+		// compute vector from start of segment to our point
+		toFeet = feet - *from;
+
+		// find distance of closest point on ray
+		closeLength = DotProduct( toFeet, along );
+
+		// constrain point to be on path segment
+		if (closeLength <= 0.0f)
+			pos = *from;
+		else if (closeLength >= length)
+			pos = *to;
+		else
+			pos = *from + closeLength * along;
+
+		distSq = (pos - feet).LengthSqr();
+
+		// keep the closest point so far
+		if (distSq < closeDistSq)
+		{
+			// don't use points we cant see
+			Vector probe = pos + Vector( 0, 0, HalfHumanHeight );
+			if (!IsWalkableTraceLineClear( eyes, probe, WALK_THRU_DOORS | WALK_THRU_BREAKABLES ))
+				continue;
+
+			// don't use points we cant reach
+			//if (!IsStraightLinePathWalkable( &pos ))
+			//	continue;
+
+			closeDistSq = distSq;
+			if (close)
+				*close = pos;
+			closeIndex = i-1;
+		}
+	}
+
+	return closeIndex;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute a point a fixed distance ahead along our path.
+ * Returns path index just after point.
+ */
+int CNavPathFollower::FindPathPoint( float aheadRange, Vector *point, int *prevIndex )
+{
+	// find path index just past aheadRange
+	int afterIndex;
+
+	// finds the closest point on local area of path, and returns the path index just prior to it
+	Vector close;
+	int startIndex = FindOurPositionOnPath( &close, true );
+
+	if (prevIndex)
+		*prevIndex = startIndex;
+
+	if (startIndex <= 0)
+	{
+		// went off the end of the path
+		// or next point in path is unwalkable (ie: jump-down)
+		// keep same point
+		return m_segmentIndex;
+	}
+
+	// if we are crouching, just follow the path exactly
+	if (m_improv->IsCrouching())
+	{
+		// we want to move to the immediately next point along the path from where we are now
+		int index = startIndex+1;
+		if (index >= m_path->GetSegmentCount())
+			index = m_path->GetSegmentCount()-1;
+
+		*point = (*m_path)[ index ]->pos;
+
+		// if we are very close to the next point in the path, skip ahead to the next one to avoid wiggling
+		// we must do a 2D check here, in case the goal point is floating in space due to jump down, etc
+		const float closeEpsilon = 20.0f;	// 10
+		while ((*point - close).AsVector2D().IsLengthLessThan( closeEpsilon ))
+		{
+			++index;
+
+			if (index >= m_path->GetSegmentCount())
+			{
+				index = m_path->GetSegmentCount()-1;
+				break;
+			}
+
+			*point = (*m_path)[ index ]->pos;
+		}
+
+		return index;
+	}
+
+	// make sure we use a node a minimum distance ahead of us, to avoid wiggling 
+	while (startIndex < m_path->GetSegmentCount()-1)
+	{
+		Vector pos = (*m_path)[ startIndex+1 ]->pos;
+
+		// we must do a 2D check here, in case the goal point is floating in space due to jump down, etc
+		const float closeEpsilon = 20.0f;
+		if ((pos - close).AsVector2D().IsLengthLessThan( closeEpsilon ))
+		{
+			++startIndex;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	// if we hit a ladder or jump area, must stop (dont use ladder behind us)
+	if (startIndex > m_segmentIndex && startIndex < m_path->GetSegmentCount() && 
+			((*m_path)[ startIndex ]->ladder || (*m_path)[ startIndex ]->area->GetAttributes() & NAV_MESH_JUMP))
+	{
+		*point = (*m_path)[ startIndex ]->pos;
+		return startIndex;
+	}
+
+	// we need the point just *ahead* of us
+	++startIndex;
+	if (startIndex >= m_path->GetSegmentCount())
+		startIndex = m_path->GetSegmentCount()-1;
+
+	// if we hit a ladder or jump area, must stop
+	if (startIndex < m_path->GetSegmentCount() && 
+			((*m_path)[ startIndex ]->ladder || (*m_path)[ startIndex ]->area->GetAttributes() & NAV_MESH_JUMP))
+	{
+		*point = (*m_path)[ startIndex ]->pos;
+		return startIndex;
+	}
+
+	// note direction of path segment we are standing on
+	Vector initDir = (*m_path)[ startIndex ]->pos - (*m_path)[ startIndex-1 ]->pos;
+	initDir.NormalizeInPlace();
+
+	Vector feet = m_improv->GetFeet();
+	Vector eyes = m_improv->GetEyes();
+	float rangeSoFar = 0;
+
+	// this flag is true if our ahead point is visible
+	bool visible = true;
+
+	Vector prevDir = initDir;
+
+	// step along the path until we pass aheadRange
+	bool isCorner = false;
+	int i;
+	for( i=startIndex; i<m_path->GetSegmentCount(); ++i )
+	{
+		Vector pos = (*m_path)[i]->pos;
+		Vector to = pos - (*m_path)[i-1]->pos;
+		Vector dir = to;
+		dir.NormalizeInPlace();
+
+		// don't allow path to double-back from our starting direction (going upstairs, down curved passages, etc)
+		if (DotProduct( dir, initDir ) < 0.0f) // -0.25f
+		{
+			--i;
+			break;
+		}
+
+		// if the path turns a corner, we want to move towards the corner, not into the wall/stairs/etc
+		if (DotProduct( dir, prevDir ) < 0.5f)
+		{
+			isCorner = true;
+			--i;
+			break;
+		}
+		prevDir = dir;
+
+		// don't use points we cant see
+		Vector probe = pos + Vector( 0, 0, HalfHumanHeight );
+		if (!IsWalkableTraceLineClear( eyes, probe, WALK_THRU_BREAKABLES ))
+		{
+			// presumably, the previous point is visible, so we will interpolate
+			visible = false;
+			break;
+		}
+
+		// if we encounter a ladder or jump area, we must stop
+		if (i < m_path->GetSegmentCount() && 
+				((*m_path)[ i ]->ladder || (*m_path)[ i ]->area->GetAttributes() & NAV_MESH_JUMP))
+			break;
+
+		// Check straight-line path from our current position to this position
+		// Test for un-jumpable height change, or unrecoverable fall
+		//if (!IsStraightLinePathWalkable( &pos ))
+		//{
+		//	--i;
+		//	break;
+		//}
+
+		Vector along = (i == startIndex) ? (pos - feet) : (pos - (*m_path)[i-1]->pos);
+		rangeSoFar += along.Length2D();
+
+		// stop if we have gone farther than aheadRange
+		if (rangeSoFar >= aheadRange)
+			break;
+	}
+
+	if (i < startIndex)
+		afterIndex = startIndex;
+	else if (i < m_path->GetSegmentCount())
+		afterIndex = i;
+	else
+		afterIndex = m_path->GetSegmentCount()-1;
+
+
+	// compute point on the path at aheadRange
+	if (afterIndex == 0)
+	{
+		*point = (*m_path)[0]->pos;
+	}
+	else
+	{
+		// interpolate point along path segment
+		const Vector *afterPoint = &(*m_path)[ afterIndex ]->pos;
+		const Vector *beforePoint = &(*m_path)[ afterIndex-1 ]->pos;
+
+		Vector to = *afterPoint - *beforePoint;
+		float length = to.Length2D();
+
+		float t = 1.0f - ((rangeSoFar - aheadRange) / length);
+
+		if (t < 0.0f)
+			t = 0.0f;
+		else if (t > 1.0f)
+			t = 1.0f;
+
+		*point = *beforePoint + t * to;
+
+		// if afterPoint wasn't visible, slide point backwards towards beforePoint until it is
+		if (!visible)
+		{
+			const float sightStepSize = 25.0f;
+			float dt = sightStepSize / length;
+
+			Vector probe = *point + Vector( 0, 0, HalfHumanHeight );
+			while( t > 0.0f && !IsWalkableTraceLineClear( eyes,  probe, WALK_THRU_BREAKABLES ) )
+			{
+				t -= dt;
+				*point = *beforePoint + t * to;
+			}
+
+			if (t <= 0.0f)
+				*point = *beforePoint;
+		}
+	}
+
+	// if position found is too close to us, or behind us, force it farther down the path so we don't stop and wiggle
+	if (!isCorner)
+	{
+		const float epsilon = 50.0f;
+		Vector2D toPoint;
+		Vector2D centroid( m_improv->GetCentroid().x, m_improv->GetCentroid().y );
+		
+		toPoint.x = point->x - centroid.x;
+		toPoint.y = point->y - centroid.y;
+
+		if (DotProduct2D( toPoint, initDir.AsVector2D() ) < 0.0f || toPoint.IsLengthLessThan( epsilon ))
+		{
+			int i;
+			for( i=startIndex; i<m_path->GetSegmentCount(); ++i )
+			{
+				toPoint.x = (*m_path)[i]->pos.x - centroid.x;
+				toPoint.y = (*m_path)[i]->pos.y - centroid.y;
+				if ((*m_path)[i]->ladder || (*m_path)[i]->area->GetAttributes() & NAV_MESH_JUMP || toPoint.IsLengthGreaterThan( epsilon ))
+				{
+					*point = (*m_path)[i]->pos;
+					startIndex = i;
+					break;
+				}
+			}
+
+			if (i == m_path->GetSegmentCount())
+			{
+				*point = m_path->GetEndpoint();
+				startIndex = m_path->GetSegmentCount()-1;
+			}
+		}
+	}
+
+	// m_pathIndex should always be the next point on the path, even if we're not moving directly towards it
+	if (startIndex < m_path->GetSegmentCount())
+		return startIndex;
+
+	return m_path->GetSegmentCount()-1;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Do reflex avoidance movements if our "feelers" are touched
+ * @todo Parameterize feeler spacing
+ */
+void CNavPathFollower::FeelerReflexAdjustment( Vector *goalPosition, float height )
+{
+	// if we are in a "precise" area, do not do feeler adjustments
+	if (m_improv->GetLastKnownArea() && m_improv->GetLastKnownArea()->GetAttributes() & NAV_MESH_PRECISE)
+		return;
+
+	// use the direction towards the goal
+	Vector dir = *goalPosition - m_improv->GetFeet();
+	dir.z = 0.0f;
+	dir.NormalizeInPlace();
+
+	Vector lat( -dir.y, dir.x, 0.0f );
+
+	const float feelerOffset = (m_improv->IsCrouching()) ? 15.0f : 20.0f;	// 15, 20
+	const float feelerLengthRun = 50.0f;	// 100 - too long for tight hallways (cs_747)
+	const float feelerLengthWalk = 30.0f;
+
+	const float feelerHeight = (height > 0.0f) ? height : StepHeight + 0.1f;	// if obstacle is lower than StepHeight, we'll walk right over it
+
+	float feelerLength = (m_improv->IsRunning()) ? feelerLengthRun : feelerLengthWalk;
+
+	feelerLength = (m_improv->IsCrouching()) ? 20.0f : feelerLength;
+
+	//
+	// Feelers must follow floor slope
+	//
+	float ground;
+	Vector normal;
+	if (m_improv->GetSimpleGroundHeightWithFloor( m_improv->GetEyes(), &ground, &normal ) == false)
+		return;
+
+	// get forward vector along floor
+	dir = CrossProduct( lat, normal );
+
+	// correct the sideways vector
+	lat = CrossProduct( dir, normal );
+
+
+	Vector feet = m_improv->GetFeet();
+	feet.z += feelerHeight;
+
+	Vector from = feet + feelerOffset * lat;
+	Vector to = from + feelerLength * dir;
+
+	bool leftClear = IsWalkableTraceLineClear( from, to, WALK_THRU_DOORS | WALK_THRU_BREAKABLES );
+
+	// draw debug beams
+	if (m_isDebug)
+	{
+		if (leftClear)
+			UTIL_DrawBeamPoints( from, to, 1, 0, 255, 0 );
+		else
+			UTIL_DrawBeamPoints( from, to, 1, 255, 0, 0 );
+	}
+
+	from = feet - feelerOffset * lat;
+	to = from + feelerLength * dir;
+
+	bool rightClear = IsWalkableTraceLineClear( from, to, WALK_THRU_DOORS | WALK_THRU_BREAKABLES );
+
+	// draw debug beams
+	if (m_isDebug)
+	{
+		if (rightClear)
+			UTIL_DrawBeamPoints( from, to, 1, 0, 255, 0 );
+		else
+			UTIL_DrawBeamPoints( from, to, 1, 255, 0, 0 );
+	}
+
+
+
+	const float avoidRange = (m_improv->IsCrouching()) ? 150.0f : 300.0f;
+
+	if (!rightClear)
+	{
+		if (leftClear)
+		{
+			// right hit, left clear - veer left
+			*goalPosition = *goalPosition + avoidRange * lat;
+			//*goalPosition = m_improv->GetFeet() + avoidRange * lat;
+
+			//m_improv->StrafeLeft();
+		}
+	}
+	else if (!leftClear)
+	{
+		// right clear, left hit - veer right
+		*goalPosition = *goalPosition - avoidRange * lat;
+		//*goalPosition = m_improv->GetFeet() - avoidRange * lat;
+
+		//m_improv->StrafeRight();
+	}
+
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reset the stuck-checker.
+ */
+CStuckMonitor::CStuckMonitor( void )
+{
+	m_isStuck = false;
+	m_avgVelIndex = 0;
+	m_avgVelCount = 0;
+}
+
+/**
+ * Reset the stuck-checker.
+ */
+void CStuckMonitor::Reset( void )
+{
+	m_isStuck = false;
+	m_avgVelIndex = 0;
+	m_avgVelCount = 0;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Test if the improv has become stuck
+ */
+void CStuckMonitor::Update( CImprovLocomotor *improv )
+{
+	if (m_isStuck)
+	{
+		// improv is stuck - see if it has moved far enough to be considered unstuck
+		const float unstuckRange = 75.0f;
+		if ((improv->GetCentroid() - m_stuckSpot).IsLengthGreaterThan( unstuckRange ))
+		{
+			// no longer stuck
+			Reset();
+			//PrintIfWatched( "UN-STUCK\n" );
+		}
+	}
+	else
+	{
+		// check if improv has become stuck
+
+		// compute average velocity over a short period (for stuck check)
+		Vector vel = improv->GetCentroid() - m_lastCentroid;
+
+		// if we are jumping, ignore Z
+		//if (improv->IsJumping())
+		//	vel.z = 0.0f;
+
+		// ignore Z unless we are on a ladder (which is only Z)
+		if (!improv->IsUsingLadder())
+			vel.z = 0.0f;
+
+		// cannot be Length2D, or will break ladder movement (they are only Z)
+		float moveDist = vel.Length();
+
+		float deltaT = gpGlobals->curtime - m_lastTime;
+		if (deltaT <= 0.0f)
+			return;
+
+		m_lastTime = gpGlobals->curtime;
+
+		// compute current velocity
+		m_avgVel[ m_avgVelIndex++ ] = moveDist/deltaT;
+
+		if (m_avgVelIndex == MAX_VEL_SAMPLES)
+			m_avgVelIndex = 0;
+
+		if (m_avgVelCount < MAX_VEL_SAMPLES)
+		{
+			++m_avgVelCount;
+		}
+		else
+		{
+			// we have enough samples to know if we're stuck
+
+			float avgVel = 0.0f;
+			for( int t=0; t<m_avgVelCount; ++t )
+				avgVel += m_avgVel[t];
+
+			avgVel /= m_avgVelCount;
+
+			// cannot make this velocity too high, or actors will get "stuck" when going down ladders
+			float stuckVel = (improv->IsUsingLadder()) ? 10.0f : 20.0f;
+
+			if (avgVel < stuckVel)
+			{
+				// note when and where we initially become stuck
+				m_stuckTimer.Start();
+				m_stuckSpot = improv->GetCentroid();
+				m_isStuck = true;
+			}
+		}
+	}
+
+	// always need to track this
+	m_lastCentroid = improv->GetCentroid();
+}
+
diff --git a/game/server/cstrike/cs_nav_path.h b/game/server/cstrike/cs_nav_path.h
new file mode 100644
index 00000000..001bc041
--- /dev/null
+++ b/game/server/cstrike/cs_nav_path.h
@@ -0,0 +1,246 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_path.h
+// Navigation Path encapsulation
+// Author: Michael S. Booth (mike@turtlerockstudios.com), November 2003
+
+#ifndef _CS_NAV_PATH_H_
+#define _CS_NAV_PATH_H_
+
+#include "nav_area.h"
+#include "bot_util.h"
+
+class CImprovLocomotor;
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * The CCSNavPath class encapsulates a path through space
+ */
+class CCSNavPath
+{
+public:
+	CCSNavPath( void )
+	{
+		m_segmentCount = 0;
+	}
+
+	struct PathSegment
+	{
+		CNavArea *area;											///< the area along the path
+		NavTraverseType how;									///< how to enter this area from the previous one
+		Vector pos;												///< our movement goal position at this point in the path
+		const CNavLadder *ladder;								///< if "how" refers to a ladder, this is it
+	};
+
+	const PathSegment * operator[] ( int i ) const		{ return (i >= 0 && i < m_segmentCount) ? &m_path[i] : NULL; }
+	const PathSegment *GetSegment( int i ) const		{ return (i >= 0 && i < m_segmentCount) ? &m_path[i] : NULL; }
+	int GetSegmentCount( void ) const					{ return m_segmentCount; }
+	const Vector &GetEndpoint( void ) const				{ return m_path[ m_segmentCount-1 ].pos; }
+	bool IsAtEnd( const Vector &pos ) const;					///< return true if position is at the end of the path
+
+	float GetLength( void ) const;								///< return length of path from start to finish
+	bool GetPointAlongPath( float distAlong, Vector *pointOnPath ) const;	///< return point a given distance along the path - if distance is out of path bounds, point is clamped to start/end
+
+	/// return the node index closest to the given distance along the path without going over - returns (-1) if error
+	int GetSegmentIndexAlongPath( float distAlong ) const;
+
+	bool IsValid( void ) const	{ return (m_segmentCount > 0); }
+	void Invalidate( void )		{ m_segmentCount = 0; }
+
+	void Draw( const Vector &color = Vector( 1.0f, 0.3f, 0 ) );	///< draw the path for debugging
+
+	/// compute closest point on path to given point
+	bool FindClosestPointOnPath( const Vector *worldPos, int startIndex, int endIndex, Vector *close ) const;
+
+	void Optimize( void );
+	
+	/**
+	 * Compute shortest path from 'start' to 'goal' via A* algorithm.
+	 * If returns true, path was build to the goal position.
+	 * If returns false, path may either be invalid (use IsValid() to check), or valid but 
+	 * doesn't reach all the way to the goal.
+	 */
+	template< typename CostFunctor >
+	bool Compute( const Vector &start, const Vector &goal, CostFunctor &costFunc )
+	{
+		Invalidate();
+
+		CNavArea *startArea = TheNavMesh->GetNearestNavArea( start + Vector( 0.0f, 0.0f, 1.0f ) );
+		if (startArea == NULL)
+		{
+			return false;
+		}
+
+		CNavArea *goalArea = TheNavMesh->GetNavArea( goal );
+
+		// if we are already in the goal area, build trivial path
+		if (startArea == goalArea)
+		{
+			BuildTrivialPath( start, goal );
+			return true;
+		}
+
+		// make sure path end position is on the ground
+		Vector pathEndPosition = goal;
+		if (goalArea)
+		{
+			pathEndPosition.z = goalArea->GetZ( pathEndPosition );
+		}
+		else
+		{
+			TheNavMesh->GetGroundHeight( pathEndPosition, &pathEndPosition.z );
+		}
+
+		//
+		// Compute shortest path to goal
+		//
+		CNavArea *closestArea;
+		bool pathResult = NavAreaBuildPath( startArea, goalArea, &goal, costFunc, &closestArea );
+
+		//
+		// Build path by following parent links
+		//
+
+		// get count
+		int count = 0;
+		CNavArea *area;
+		for( area = closestArea; area; area = area->GetParent() )
+		{
+			++count;
+		}
+
+		// save room for endpoint
+		if (count > MAX_PATH_SEGMENTS-1)
+		{
+			count = MAX_PATH_SEGMENTS-1;
+		}
+
+		if (count == 0)
+		{
+			return false;
+		}
+
+		if (count == 1)
+		{
+			BuildTrivialPath( start, goal );
+			return true;
+		}
+
+		// build path
+		m_segmentCount = count;
+		for( area = closestArea; count && area; area = area->GetParent() )
+		{
+			--count;
+			m_path[ count ].area = area;
+			m_path[ count ].how = area->GetParentHow();
+		}
+
+		// compute path positions
+		if (ComputePathPositions() == false)
+		{
+			//PrintIfWatched( "CNavPath::Compute: Error building path\n" );
+			Invalidate();
+			return false;
+		}
+
+		// append path end position
+		m_path[ m_segmentCount ].area = closestArea;
+		m_path[ m_segmentCount ].pos = pathEndPosition;
+		m_path[ m_segmentCount ].ladder = NULL;
+		m_path[ m_segmentCount ].how = NUM_TRAVERSE_TYPES;
+		++m_segmentCount;
+
+		return pathResult;
+	}
+
+private:
+	enum { MAX_PATH_SEGMENTS = 256 };
+	PathSegment m_path[ MAX_PATH_SEGMENTS ];
+	int m_segmentCount;
+
+	bool ComputePathPositions( void );									///< determine actual path positions 
+	bool BuildTrivialPath( const Vector &start, const Vector &goal );	///< utility function for when start and goal are in the same area
+
+	int FindNextOccludedNode( int anchor );								///< used by Optimize()
+};
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Monitor improv movement and determine if it becomes stuck
+ */
+class CStuckMonitor
+{
+public:
+	CStuckMonitor( void );
+
+	void Reset( void );
+	void Update( CImprovLocomotor *improv );
+	bool IsStuck( void ) const		{ return m_isStuck; }
+
+	float GetDuration( void ) const	{ return (m_isStuck) ? m_stuckTimer.GetElapsedTime() : 0.0f; }
+
+private:
+	bool m_isStuck;													///< if true, we are stuck
+	Vector m_stuckSpot;												///< the location where we became stuck
+	IntervalTimer m_stuckTimer;										///< how long we have been stuck
+
+	enum { MAX_VEL_SAMPLES = 5 };
+	float m_avgVel[ MAX_VEL_SAMPLES ];
+	int m_avgVelIndex;
+	int m_avgVelCount;
+	Vector m_lastCentroid;
+	float m_lastTime;
+};
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * The CNavPathFollower class implements path following behavior
+ */
+class CNavPathFollower
+{
+public:
+	CNavPathFollower( void );
+
+	void SetImprov( CImprovLocomotor *improv ) { m_improv = improv; }
+	void SetPath( CCSNavPath *path ) { m_path = path; }
+
+	void Reset( void );
+
+	#define DONT_AVOID_OBSTACLES false
+	void Update( float deltaT, bool avoidObstacles = true );		///< move improv along path
+	void Debug( bool status )		{ m_isDebug = status; }			///< turn debugging on/off
+
+	bool IsStuck( void ) const		{ return m_stuckMonitor.IsStuck(); }	///< return true if improv is stuck 
+	void ResetStuck( void )			{ m_stuckMonitor.Reset(); }
+	float GetStuckDuration( void ) const	{ return m_stuckMonitor.GetDuration(); }	///< return how long we've been stuck
+
+	void FeelerReflexAdjustment( Vector *goalPosition, float height = -1.0f );	///< adjust goal position if "feelers" are touched
+
+private:
+	CImprovLocomotor *m_improv;										///< who is doing the path following
+
+	CCSNavPath *m_path;												///< the path being followed
+
+	int m_segmentIndex;												///< the point on the path the improv is moving towards
+	int m_behindIndex;												///< index of the node on the path just behind us
+	Vector m_goal;													///< last computed follow goal
+
+	bool m_isLadderStarted;
+
+	bool m_isDebug;
+
+	int FindOurPositionOnPath( Vector *close, bool local ) const;	///< return the closest point to our current position on current path
+	int FindPathPoint( float aheadRange, Vector *point, int *prevIndex );	///< compute a point a fixed distance ahead along our path.
+
+	CStuckMonitor m_stuckMonitor;
+};
+
+
+
+#endif	// _CS_NAV_PATH_H_
+
diff --git a/game/server/cstrike/cs_nav_pathfind.h b/game/server/cstrike/cs_nav_pathfind.h
new file mode 100644
index 00000000..042179b5
--- /dev/null
+++ b/game/server/cstrike/cs_nav_pathfind.h
@@ -0,0 +1,65 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_pathfind.h
+// Path-finding mechanisms using the Navigation Mesh
+// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
+
+#ifndef _CS_NAV_PATHFIND_H_
+#define _CS_NAV_PATHFIND_H_
+
+#include "nav_pathfind.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute travel distance along shortest path from startPos to goalPos. 
+ * Return -1 if can't reach endPos from goalPos.
+ */
+template< typename CostFunctor >
+float NavAreaTravelDistance( const Vector &startPos, const Vector &goalPos, CostFunctor &costFunc )
+{
+	CNavArea *startArea = TheNavMesh->GetNearestNavArea( startPos );
+	if (startArea == NULL)
+	{
+		return -1.0f;
+	}
+
+	// compute path between areas using given cost heuristic
+	CNavArea *goalArea = NULL;
+	if (NavAreaBuildPath( startArea, NULL, &goalPos, costFunc, &goalArea ) == false)
+	{
+		return -1.0f;
+	}
+
+	// compute distance along path
+	if (goalArea->GetParent() == NULL)
+	{
+		// both points are in the same area - return euclidean distance
+		return (goalPos - startPos).Length();
+	}
+	else
+	{
+		CNavArea *area;
+		float distance;
+
+		// goalPos is assumed to be inside goalArea (or very close to it) - skip to next area
+		area = goalArea->GetParent();
+		distance = (goalPos - area->GetCenter()).Length();
+
+		for( ; area->GetParent(); area = area->GetParent() )
+		{
+			distance += (area->GetCenter() - area->GetParent()->GetCenter()).Length();
+		}
+
+		// add in distance to startPos
+		distance += (startPos - area->GetCenter()).Length();
+
+		return distance;
+	}
+}
+
+#endif // _CS_NAV_PATHFIND_H_
diff --git a/game/server/cstrike/cs_player.cpp b/game/server/cstrike/cs_player.cpp
new file mode 100644
index 00000000..79ed9c14
--- /dev/null
+++ b/game/server/cstrike/cs_player.cpp
@@ -0,0 +1,8267 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Player for HL1.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_player.h"
+#include "cs_gamerules.h"
+#include "trains.h"
+#include "vcollide_parse.h"
+#include "in_buttons.h"
+#include "igamemovement.h"
+#include "ai_hull.h"
+#include "ndebugoverlay.h"
+#include "weapon_csbase.h"
+#include "decals.h"
+#include "cs_ammodef.h"
+#include "IEffects.h"
+#include "cs_client.h"
+#include "client.h"
+#include "cs_shareddefs.h"
+#include "shake.h"
+#include "team.h"
+#include "weapon_c4.h"
+#include "weapon_parse.h"
+#include "weapon_knife.h"
+#include "movehelper_server.h"
+#include "tier0/vprof.h"
+#include "te_effect_dispatch.h"
+#include "vphysics/player_controller.h"
+#include "weapon_hegrenade.h"
+#include "weapon_flashbang.h"
+#include "weapon_csbasegun.h"
+#include "weapon_smokegrenade.h"
+#include <KeyValues.h>
+#include "engine/IEngineSound.h"
+#include "bot.h"
+#include "studio.h"
+#include <coordsize.h>
+#include "predicted_viewmodel.h"
+#include "props_shared.h"
+#include "tier0/icommandline.h"
+#include "info_camera_link.h"
+#include "hintmessage.h"
+#include "obstacle_pushaway.h"
+#include "movevars_shared.h"
+#include "death_pose.h"
+#include "basecsgrenade_projectile.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include "CRagdollMagnet.h"
+#include "datacache/imdlcache.h"
+#include "npcevent.h"
+#include "cs_gamestats.h"
+#include "gamestats.h"
+#include "holiday_gift.h"
+#include "../../shared/cstrike/cs_achievement_constants.h"
+
+//=============================================================================
+// HPE_BEGIN
+//=============================================================================
+
+// [dwenger] Needed for global hostage list
+#include "cs_simple_hostage.h"
+
+// [dwenger] Needed for weapon type used tracking
+#include "../../shared/cstrike/cs_weapon_parse.h"
+
+#define REPORT_PLAYER_DAMAGE 0
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#pragma optimize( "", off )
+
+#pragma warning( disable : 4355 )
+
+// Minimum interval between rate-limited commands that players can run.
+#define CS_COMMAND_MAX_RATE 0.3
+
+const float CycleLatchInterval = 0.2f;
+
+#define CS_PUSHAWAY_THINK_CONTEXT	"CSPushawayThink"
+
+ConVar cs_ShowStateTransitions( "cs_ShowStateTransitions", "-2", FCVAR_CHEAT, "cs_ShowStateTransitions <ent index or -1 for all>. Show player state transitions." );
+ConVar sv_max_usercmd_future_ticks( "sv_max_usercmd_future_ticks", "8", 0, "Prevents clients from running usercmds too far in the future. Prevents speed hacks." );
+ConVar sv_motd_unload_on_dismissal( "sv_motd_unload_on_dismissal", "0", 0, "If enabled, the MOTD contents will be unloaded when the player closes the MOTD." );
+//=============================================================================
+// HPE_BEGIN:
+// [Forrest] Allow MVP to be turned off for a server
+// [Forrest] Allow freezecam to be turned off for a server
+// [Forrest] Allow win panel to be turned off for a server
+//=============================================================================
+static void SvNoMVPChangeCallback( IConVar *pConVar, const char *pOldValue, float flOldValue )
+{
+	ConVarRef var( pConVar );
+	if ( var.IsValid() && var.GetBool() )
+	{
+		// Clear the MVPs of all players when MVP is turned off.
+		for ( int i = 1; i <= MAX_PLAYERS; i++ )
+		{
+			CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( i ) );
+
+			if ( pPlayer )
+			{
+				pPlayer->SetNumMVPs( 0 );
+			}
+		}
+	}
+}
+ConVar sv_nomvp( "sv_nomvp", "0", 0, "Disable MVP awards.", SvNoMVPChangeCallback );
+ConVar sv_disablefreezecam( "sv_disablefreezecam", "0", FCVAR_REPLICATED, "Turn on/off freezecam on server" );
+ConVar sv_nowinpanel( "sv_nowinpanel", "0", FCVAR_REPLICATED, "Turn on/off win panel on server" );
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+// ConVar bot_mimic( "bot_mimic", "0", FCVAR_CHEAT );
+ConVar bot_freeze( "bot_freeze", "0", FCVAR_CHEAT );
+ConVar bot_crouch( "bot_crouch", "0", FCVAR_CHEAT );
+ConVar bot_mimic_yaw_offset( "bot_mimic_yaw_offset", "180", FCVAR_CHEAT );
+
+ConVar sv_legacy_grenade_damage( "sv_legacy_grenade_damage", "0", FCVAR_REPLICATED, "Enable to replicate grenade damage behavior of the original Counter-Strike Source game." );
+
+extern ConVar mp_autokick;
+extern ConVar mp_holiday_nogifts;
+extern ConVar sv_turbophysics;
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Added in convars for freeze cam time length
+//=============================================================================
+ 
+extern ConVar spec_freeze_time;
+extern ConVar spec_freeze_traveltime;
+ 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+extern ConVar ammo_hegrenade_max;
+extern ConVar ammo_flashbang_max;
+extern ConVar ammo_smokegrenade_max;
+
+
+#define THROWGRENADE_COUNTER_BITS 3
+
+
+EHANDLE g_pLastCTSpawn;
+EHANDLE g_pLastTerroristSpawn;
+
+void TE_RadioIcon( IRecipientFilter& filter, float delay, CBaseEntity *pPlayer );
+
+
+// -------------------------------------------------------------------------------- //
+// Classes
+// -------------------------------------------------------------------------------- //
+
+class CPhysicsPlayerCallback : public IPhysicsPlayerControllerEvent
+{
+public:
+	int ShouldMoveTo( IPhysicsObject *pObject, const Vector &position )
+	{
+		CCSPlayer *pPlayer = (CCSPlayer *)pObject->GetGameData();
+		if ( pPlayer )
+		{
+			if ( pPlayer->TouchedPhysics() )
+			{
+				return 0;
+			}
+		}
+		return 1;
+	}
+};
+
+static CPhysicsPlayerCallback playerCallback;
+
+
+// -------------------------------------------------------------------------------- //
+// Ragdoll entities.
+// -------------------------------------------------------------------------------- //
+
+class CCSRagdoll : public CBaseAnimatingOverlay
+{
+public:
+	DECLARE_CLASS( CCSRagdoll, CBaseAnimatingOverlay );
+	DECLARE_SERVERCLASS();
+
+	// Transmit ragdolls to everyone.
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+
+	void Init( void )
+	{
+		SetSolid( SOLID_BBOX );
+		SetMoveType( MOVETYPE_STEP );
+		SetFriction( 1.0f );
+		SetCollisionBounds( VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX );
+		m_takedamage = DAMAGE_NO;
+		SetCollisionGroup( COLLISION_GROUP_DEBRIS );
+		SetAbsOrigin( m_hPlayer->GetAbsOrigin() );
+		SetAbsVelocity( m_hPlayer->GetAbsVelocity() );
+		AddSolidFlags( FSOLID_NOT_SOLID );
+		ChangeTeam( m_hPlayer->GetTeamNumber() );
+		UseClientSideAnimation();
+	}
+
+public:
+	// In case the client has the player entity, we transmit the player index.
+	// In case the client doesn't have it, we transmit the player's model index, origin, and angles
+	// so they can create a ragdoll in the right place.
+	CNetworkHandle( CBaseEntity, m_hPlayer );	// networked entity handle
+	CNetworkVector( m_vecRagdollVelocity );
+	CNetworkVector( m_vecRagdollOrigin );
+	CNetworkVar(int, m_iDeathPose );
+	CNetworkVar(int, m_iDeathFrame );
+};
+
+LINK_ENTITY_TO_CLASS( cs_ragdoll, CCSRagdoll );
+
+IMPLEMENT_SERVERCLASS_ST_NOBASE( CCSRagdoll, DT_CSRagdoll )
+	SendPropVector	(SENDINFO(m_vecOrigin), -1,  SPROP_COORD|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ),
+	SendPropVector( SENDINFO(m_vecRagdollOrigin), -1,  SPROP_COORD ),
+	SendPropEHandle( SENDINFO( m_hPlayer ) ),
+	SendPropModelIndex( SENDINFO( m_nModelIndex ) ),
+	SendPropInt		( SENDINFO(m_nForceBone), 8, 0 ),
+	SendPropVector	( SENDINFO(m_vecForce), -1, SPROP_NOSCALE ),
+	SendPropVector( SENDINFO( m_vecRagdollVelocity ) ),
+	SendPropInt( SENDINFO( m_iDeathPose ), ANIMATION_SEQUENCE_BITS, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iDeathFrame ), 5 ),
+	SendPropInt( SENDINFO(m_iTeamNum), TEAMNUM_NUM_BITS, 0),
+	SendPropInt( SENDINFO( m_bClientSideAnimation ), 1, SPROP_UNSIGNED ),
+END_SEND_TABLE()
+
+
+// -------------------------------------------------------------------------------- //
+// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
+// -------------------------------------------------------------------------------- //
+
+class CTEPlayerAnimEvent : public CBaseTempEntity
+{
+public:
+	DECLARE_CLASS( CTEPlayerAnimEvent, CBaseTempEntity );
+	DECLARE_SERVERCLASS();
+
+					CTEPlayerAnimEvent( const char *name ) : CBaseTempEntity( name )
+					{
+					}
+
+	CNetworkHandle( CBasePlayer, m_hPlayer );
+	CNetworkVar( int, m_iEvent );
+	CNetworkVar( int, m_nData );
+};
+
+IMPLEMENT_SERVERCLASS_ST_NOBASE( CTEPlayerAnimEvent, DT_TEPlayerAnimEvent )
+	SendPropEHandle( SENDINFO( m_hPlayer ) ),
+	SendPropInt( SENDINFO( m_iEvent ), Q_log2( PLAYERANIMEVENT_COUNT ) + 1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_nData ), 32 )
+END_SEND_TABLE()
+
+static CTEPlayerAnimEvent g_TEPlayerAnimEvent( "PlayerAnimEvent" );
+
+void TE_PlayerAnimEvent( CBasePlayer *pPlayer, PlayerAnimEvent_t event, int nData )
+{
+	CPVSFilter filter( (const Vector&)pPlayer->EyePosition() );
+
+	g_TEPlayerAnimEvent.m_hPlayer = pPlayer;
+	g_TEPlayerAnimEvent.m_iEvent = event;
+	g_TEPlayerAnimEvent.m_nData = nData;
+	g_TEPlayerAnimEvent.Create( filter, 0 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Filters updates to a variable so that only non-local players see
+// the changes.  This is so we can send a low-res origin to non-local players
+// while sending a hi-res one to the local player.
+// Input  : *pVarData -
+//			*pOut -
+//			objectID -
+//-----------------------------------------------------------------------------
+
+void* SendProxy_SendNonLocalDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
+{
+	pRecipients->SetAllRecipients();
+	pRecipients->ClearRecipient( objectID - 1 );
+	return ( void * )pVarData;
+}
+REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendNonLocalDataTable );
+
+
+// -------------------------------------------------------------------------------- //
+// Tables.
+// -------------------------------------------------------------------------------- //
+
+LINK_ENTITY_TO_CLASS( player, CCSPlayer );
+PRECACHE_REGISTER(player);
+
+BEGIN_SEND_TABLE_NOBASE( CCSPlayer, DT_CSLocalPlayerExclusive )
+	SendPropFloat( SENDINFO( m_flStamina ), 14, 0, 0, 1400  ),
+	SendPropInt( SENDINFO( m_iDirection ), 1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iShotsFired ), 8, SPROP_UNSIGNED ),
+	SendPropFloat( SENDINFO( m_flVelocityModifier ), 8, 0, 0, 1  ),
+
+	// send a hi-res origin to the local player for use in prediction
+	SendPropVector	(SENDINFO(m_vecOrigin), -1,  SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ),
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj]Set up the send table for per-client domination data
+	//=============================================================================
+ 
+	SendPropArray3( SENDINFO_ARRAY3( m_bPlayerDominated ), SendPropBool( SENDINFO_ARRAY( m_bPlayerDominated ) ) ),
+	SendPropArray3( SENDINFO_ARRAY3( m_bPlayerDominatingMe ), SendPropBool( SENDINFO_ARRAY( m_bPlayerDominatingMe ) ) ),
+ 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+END_SEND_TABLE()
+
+
+BEGIN_SEND_TABLE_NOBASE( CCSPlayer, DT_CSNonLocalPlayerExclusive )
+	// send a lo-res origin to other players
+	SendPropVector	(SENDINFO(m_vecOrigin), -1,  SPROP_COORD|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_Origin ),
+END_SEND_TABLE()
+
+
+IMPLEMENT_SERVERCLASS_ST( CCSPlayer, DT_CSPlayer )
+	SendPropExclude( "DT_BaseAnimating", "m_flPoseParameter" ),
+	SendPropExclude( "DT_BaseAnimating", "m_flPlaybackRate" ),
+	SendPropExclude( "DT_BaseAnimating", "m_nSequence" ),
+	SendPropExclude( "DT_BaseAnimating", "m_nNewSequenceParity" ),
+	SendPropExclude( "DT_BaseAnimating", "m_nResetEventsParity" ),
+	SendPropExclude( "DT_BaseAnimating", "m_nMuzzleFlashParity" ),
+	SendPropExclude( "DT_BaseEntity", "m_angRotation" ),
+	SendPropExclude( "DT_BaseAnimatingOverlay", "overlay_vars" ),
+
+	// cs_playeranimstate and clientside animation takes care of these on the client
+	SendPropExclude( "DT_ServerAnimationData" , "m_flCycle" ),
+	SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ),
+
+	// We need to send a hi-res origin to the local player to avoid prediction errors sliding along walls
+	SendPropExclude( "DT_BaseEntity", "m_vecOrigin" ),
+
+	// Data that only gets sent to the local player.
+	SendPropDataTable( "cslocaldata", 0, &REFERENCE_SEND_TABLE(DT_CSLocalPlayerExclusive), SendProxy_SendLocalDataTable ),
+	SendPropDataTable( "csnonlocaldata", 0, &REFERENCE_SEND_TABLE(DT_CSNonLocalPlayerExclusive), SendProxy_SendNonLocalDataTable ),
+
+	SendPropInt( SENDINFO( m_iThrowGrenadeCounter ), THROWGRENADE_COUNTER_BITS, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iAddonBits ), NUM_ADDON_BITS, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iPrimaryAddon ), 8, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iSecondaryAddon ), 8, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iPlayerState ), Q_log2( NUM_PLAYER_STATES )+1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iAccount ), 16, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_bInBombZone ), 1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_bInBuyZone ), 1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iClass ), Q_log2( CS_NUM_CLASSES )+1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_ArmorValue ), 8 ),
+	SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 0), 11, SPROP_CHANGES_OFTEN ),
+	SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 1), 11, SPROP_CHANGES_OFTEN ),
+	SendPropBool( SENDINFO( m_bHasDefuser ) ),
+	SendPropBool( SENDINFO( m_bNightVisionOn ) ),	//send as int so we can use a RecvProxy on the client
+	SendPropBool( SENDINFO( m_bHasNightVision ) ),
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [dwenger] Added for fun-fact support
+	//=============================================================================
+
+	//SendPropBool( SENDINFO( m_bPickedUpDefuser ) ),
+	//SendPropBool( SENDINFO( m_bDefusedWithPickedUpKit) ),
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	SendPropBool( SENDINFO( m_bInHostageRescueZone ) ),
+	SendPropBool( SENDINFO( m_bIsDefusing ) ),
+
+	SendPropBool( SENDINFO( m_bResumeZoom ) ),
+	SendPropInt( SENDINFO( m_iLastZoom ), 8, SPROP_UNSIGNED ),
+
+#ifdef CS_SHIELD_ENABLED
+	SendPropBool( SENDINFO( m_bHasShield ) ),
+	SendPropBool( SENDINFO( m_bShieldDrawn ) ),
+#endif
+	SendPropBool( SENDINFO( m_bHasHelmet ) ),
+	SendPropFloat	(SENDINFO(m_flFlashDuration), 0, SPROP_NOSCALE ),
+	SendPropFloat( SENDINFO(m_flFlashMaxAlpha), 0, SPROP_NOSCALE ),
+	SendPropInt( SENDINFO( m_iProgressBarDuration ), 4, SPROP_UNSIGNED ),
+	SendPropFloat( SENDINFO( m_flProgressBarStartTime ), 0, SPROP_NOSCALE ),
+	SendPropEHandle( SENDINFO( m_hRagdoll ) ),
+	SendPropInt( SENDINFO( m_cycleLatch ), 4, SPROP_UNSIGNED ),
+
+
+END_SEND_TABLE()
+
+
+BEGIN_DATADESC( CCSPlayer )
+
+	DEFINE_INPUTFUNC( FIELD_VOID, "OnRescueZoneTouch", RescueZoneTouch ),
+	DEFINE_THINKFUNC( PushawayThink )
+
+END_DATADESC()
+
+
+// has to be included after above macros
+#include "cs_bot.h"
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+
+// -------------------------------------------------------------------------------- //
+
+void cc_CreatePredictionError_f( const CCommand &args )
+{
+	float distance = 32;
+
+	if ( args.ArgC() >= 2 )
+	{
+		distance = atof(args[1]);
+	}
+
+	CBaseEntity *pEnt = CBaseEntity::Instance( 1 );
+	pEnt->SetAbsOrigin( pEnt->GetAbsOrigin() + Vector( distance, 0, 0 ) );
+}
+
+ConCommand cc_CreatePredictionError( "CreatePredictionError", cc_CreatePredictionError_f, "Create a prediction error", FCVAR_CHEAT );
+
+
+// -------------------------------------------------------------------------------- //
+// CCSPlayer implementation.
+// -------------------------------------------------------------------------------- //
+
+CCSPlayer::CCSPlayer()
+{
+	m_PlayerAnimState = CreatePlayerAnimState( this, this, LEGANIM_9WAY, true );
+
+	UseClientSideAnimation();
+
+	m_iLastWeaponFireUsercmd = 0;
+	m_iAddonBits = 0;
+	m_bEscaped = false;
+	m_iAccount = 0;
+
+	m_bIsVIP = false;
+	m_iClass = (int)CS_CLASS_NONE;
+	m_angEyeAngles.Init();
+
+	SetViewOffset( VEC_VIEW_SCALED( this ) );
+
+	m_pCurStateInfo = NULL;	// no state yet
+	m_iThrowGrenadeCounter = 0;
+
+	m_lifeState = LIFE_DEAD; // Start "dead".
+	m_bInBombZone = false;
+	m_bInBuyZone = false;
+	m_bInHostageRescueZone = false;
+	m_flDeathTime = 0.0f;
+	m_iHostagesKilled = 0;
+	iRadioMenu = -1;
+	m_bTeamChanged = false;
+	m_iShotsFired = 0;
+	m_iDirection = 0;
+	m_receivesMoneyNextRound = true;
+	m_bIsBeingGivenItem = false;
+	m_isVIP = false;
+
+	m_bJustKilledTeammate = false;
+	m_bPunishedForTK = false;
+	m_iTeamKills = 0;
+	m_flLastMovement = gpGlobals->curtime;
+	m_iNextTimeCheck = 0;
+
+	m_szNewName[0] = 0;
+	m_szClanTag[0] = 0;
+
+	for ( int i=0; i<NAME_CHANGE_HISTORY_SIZE; i++ )
+	{
+		m_flNameChangeHistory[i] = -NAME_CHANGE_HISTORY_INTERVAL;
+	}
+
+	m_iIgnoreGlobalChat = 0;
+	m_bIgnoreRadio = false;
+
+	m_pHintMessageQueue = new CHintMessageQueue(this);
+	m_iDisplayHistoryBits = 0;
+	m_bShowHints = true;
+	m_flNextMouseoverUpdate = gpGlobals->curtime;
+
+	m_lastDamageHealth = 0;
+	m_lastDamageArmor = 0;
+
+	m_applyDeafnessTime = 0.0f;
+
+	m_cycleLatch = 0;
+	m_cycleLatchTimer.Invalidate();
+
+	m_iShouldHaveCash = 0;
+
+	m_lastNavArea = NULL;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Init achievement variables
+	// [menglish] Init bullet collision variables
+	//=============================================================================
+
+	m_NumEnemiesKilledThisRound = 0;
+	m_NumEnemiesAtRoundStart = 0;
+	m_KillingSpreeStartTime = -1;
+	m_firstKillBlindStartTime = -1;
+	m_killsWhileBlind = 0;
+	m_bSurvivedHeadshotDueToHelmet = false;
+	m_pGooseChaseDistractingPlayer = NULL;
+	m_gooseChaseStep = GC_NONE;
+	m_defuseDefenseStep = DD_NONE;
+	m_lastRoundResult = Invalid_Round_End_Reason;
+	m_bMadeFootstepNoise = false;
+	m_bombPickupTime = -1;
+	m_bMadePurchseThisRound = false;
+	m_roundsWonWithoutPurchase = 0;
+	m_iDeathFlags = 0;
+	m_lastFlashBangAttacker = NULL;
+	m_iMVPs = 0;
+	m_bKilledDefuser = false;
+	m_bKilledRescuer = false;
+	m_maxGrenadeKills = 0;
+	m_grenadeDamageTakenThisRound = 0;
+
+	m_vLastHitLocationObjectSpace = Vector(0,0,0);
+
+	m_wasNotKilledNaturally = false;
+	 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+
+CCSPlayer::~CCSPlayer()
+{
+	delete m_pHintMessageQueue;
+	m_pHintMessageQueue = NULL;
+
+	// delete the records of damage taken and given
+	ResetDamageCounters();
+	m_PlayerAnimState->Release();
+}
+
+
+CCSPlayer *CCSPlayer::CreatePlayer( const char *className, edict_t *ed )
+{
+	CCSPlayer::s_PlayerEdict = ed;
+	return (CCSPlayer*)CreateEntityByName( className );
+}
+
+
+void CCSPlayer::Precache()
+{
+	Vector mins( -13, -13, -10 );
+	Vector maxs( 13, 13, 75 );
+
+	int i;
+	for ( i=0; i<CTPlayerModels.Count(); ++i )
+	{
+		PrecacheModel( CTPlayerModels[i] );
+		engine->ForceModelBounds( CTPlayerModels[i], mins, maxs );
+	}
+	for ( i=0; i<TerroristPlayerModels.Count(); ++i )
+	{
+		PrecacheModel( TerroristPlayerModels[i] );
+		engine->ForceModelBounds( TerroristPlayerModels[i], mins, maxs );
+	}
+
+	// Sigh - have to force identical VMTs for the player models.  I'm just going to hard-code these
+	// strings here, rather than have char***'s or the CUtlVector<CUtlVector<>> equivalent.
+	engine->ForceSimpleMaterial( "materials/models/player/ct_urban/ct_urban.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/ct_urban/ct_urban_glass.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/ct_sas/ct_sas.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/ct_sas/ct_sas_glass.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/ct_gsg9/ct_gsg9.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/ct_gign/ct_gign.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/ct_gign/ct_gign_glass.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/t_phoenix/t_phoenix.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/t_guerilla/t_guerilla.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/t_leet/t_leet.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/t_leet/t_leet_glass.vmt" );
+	engine->ForceSimpleMaterial( "materials/models/player/t_arctic/t_arctic.vmt" );
+
+#ifdef CS_SHIELD_ENABLED
+	PrecacheModel( SHIELD_VIEW_MODEL );
+#endif
+
+	PrecacheScriptSound( "Player.DeathHeadShot" );
+	PrecacheScriptSound( "Player.Death" );
+	PrecacheScriptSound( "Player.DamageHelmet" );
+	PrecacheScriptSound( "Player.DamageHeadShot" );
+	PrecacheScriptSound( "Flesh.BulletImpact" );
+	PrecacheScriptSound( "Player.DamageKevlar" );
+	PrecacheScriptSound( "Player.PickupWeapon" );
+	PrecacheScriptSound( "Player.NightVisionOff" );
+	PrecacheScriptSound( "Player.NightVisionOn" );
+	PrecacheScriptSound( "Player.FlashlightOn" );
+	PrecacheScriptSound( "Player.FlashlightOff" );
+
+	// CS Bot sounds
+	PrecacheScriptSound( "Bot.StuckSound" );
+	PrecacheScriptSound( "Bot.StuckStart" );
+	PrecacheScriptSound( "Bot.FellOff" );
+
+	UTIL_PrecacheOther( "item_kevlar" );
+	UTIL_PrecacheOther( "item_assaultsuit" );
+	UTIL_PrecacheOther( "item_defuser" );
+
+	PrecacheModel ( "sprites/glow01.vmt" );
+	PrecacheModel ( "models/items/cs_gift.mdl" );
+
+	BaseClass::Precache();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Allow pre-frame adjustments on the player
+//-----------------------------------------------------------------------------
+ConVar sv_runcmds( "sv_runcmds", "1" );
+void CCSPlayer::PlayerRunCommand( CUserCmd *ucmd, IMoveHelper *moveHelper )
+{
+	VPROF( "CCSPlayer::PlayerRunCommand" );
+
+	if ( !sv_runcmds.GetInt() )
+		return;
+
+	// don't run commands in the future
+	if ( !IsEngineThreaded() &&
+		( ucmd->tick_count > (gpGlobals->tickcount + sv_max_usercmd_future_ticks.GetInt()) ) )
+	{
+		DevMsg( "Client cmd out of sync (delta %i).\n", ucmd->tick_count - gpGlobals->tickcount );
+		return;
+	}
+
+	// If they use a negative bot_mimic value, then don't process their usercmds, but have
+	// bots process them instead (so they can stay still and have the bot move around).
+	CUserCmd tempCmd;
+	if ( -bot_mimic.GetInt() == entindex() )
+	{
+		tempCmd = *ucmd;
+		ucmd = &tempCmd;
+
+		ucmd->forwardmove = ucmd->sidemove = ucmd->upmove = 0;
+		ucmd->buttons = 0;
+		ucmd->impulse = 0;
+	}
+
+	if ( IsBot() && bot_crouch.GetInt() )
+		ucmd->buttons |= IN_DUCK;
+
+	BaseClass::PlayerRunCommand( ucmd, moveHelper );
+}
+
+
+bool CCSPlayer::RunMimicCommand( CUserCmd& cmd )
+{
+	if ( !IsBot() )
+		return false;
+
+	int iMimic = abs( bot_mimic.GetInt() );
+	if ( iMimic > gpGlobals->maxClients )
+		return false;
+
+	CBasePlayer *pPlayer = UTIL_PlayerByIndex( iMimic );
+	if ( !pPlayer )
+		return false;
+
+	if ( !pPlayer->GetLastUserCommand() )
+		return false;
+
+	cmd = *pPlayer->GetLastUserCommand();
+	cmd.viewangles[YAW] += bot_mimic_yaw_offset.GetFloat();
+
+	pl.fixangle = FIXANGLE_NONE;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Simulates a single frame of movement for a player
+//-----------------------------------------------------------------------------
+void CCSPlayer::RunPlayerMove( const QAngle& viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, float frametime )
+{
+	CUserCmd cmd;
+
+	// Store off the globals.. they're gonna get whacked
+	float flOldFrametime = gpGlobals->frametime;
+	float flOldCurtime = gpGlobals->curtime;
+
+	float flTimeBase = gpGlobals->curtime + gpGlobals->frametime - frametime;
+	this->SetTimeBase( flTimeBase );
+
+	CUserCmd lastUserCmd = *GetLastUserCommand();
+	Q_memset( &cmd, 0, sizeof( cmd ) );
+
+	if ( !RunMimicCommand( cmd ) )
+	{
+		cmd.forwardmove = forwardmove;
+		cmd.sidemove = sidemove;
+		cmd.upmove = upmove;
+		cmd.buttons = buttons;
+		cmd.impulse = impulse;
+
+		VectorCopy( viewangles, cmd.viewangles );
+		cmd.random_seed = random->RandomInt( 0, 0x7fffffff );
+	}
+
+	MoveHelperServer()->SetHost( this );
+	PlayerRunCommand( &cmd, MoveHelperServer() );
+
+	// save off the last good usercmd
+	if ( -bot_mimic.GetInt() == entindex() )
+	{
+		CUserCmd lastCmd = *GetLastUserCommand();
+		lastCmd.command_number = cmd.command_number;
+		lastCmd.tick_count = cmd.tick_count;
+		SetLastUserCommand( lastCmd );
+	}
+	else
+	{
+		SetLastUserCommand( cmd );
+	}
+
+	// Clear out any fixangle that has been set
+	pl.fixangle = FIXANGLE_NONE;
+
+	// Restore the globals..
+	gpGlobals->frametime = flOldFrametime;
+	gpGlobals->curtime = flOldCurtime;
+
+	MoveHelperServer()->SetHost( NULL );
+}
+
+
+void CCSPlayer::InitialSpawn( void )
+{
+	BaseClass::InitialSpawn();
+
+	// we're going to give the bots money here instead of FinishClientPutInServer()
+	// because of the bots' timing for purchasing weapons/items.
+	if ( IsBot() )
+	{
+		m_iAccount = CSGameRules()->GetStartMoney();
+	}
+
+	if ( !engine->IsDedicatedServer() && TheNavMesh->IsOutOfDate() && this == UTIL_GetListenServerHost() )
+	{
+		ClientPrint( this, HUD_PRINTCENTER, "The Navigation Mesh was built using a different version of this map." );
+	}
+
+	State_Enter( STATE_WELCOME );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] We reset the stats at the beginning of the map (including domination tracking)
+	//=============================================================================
+	 
+	CCS_GameStats.ResetPlayerStats(this);
+	RemoveNemesisRelationships();
+	 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	
+}
+
+void CCSPlayer::SetModelFromClass( void )
+{
+	if ( GetTeamNumber() == TEAM_TERRORIST )
+	{
+		int index = m_iClass - FIRST_T_CLASS;
+		if ( index < 0 || index >= TerroristPlayerModels.Count() )
+		{
+			index = RandomInt( 0, TerroristPlayerModels.Count() - 1 );
+			m_iClass = index + FIRST_T_CLASS; // clean up players who selected a higher class than we support yet
+		}
+		SetModel( TerroristPlayerModels[index] );
+	}
+	else if ( GetTeamNumber() == TEAM_CT )
+	{
+		int index = m_iClass - FIRST_CT_CLASS;
+		if ( index < 0 || index >= CTPlayerModels.Count() )
+		{
+			index = RandomInt( 0, CTPlayerModels.Count() - 1 );
+			m_iClass = index + FIRST_CT_CLASS; // clean up players who selected a higher class than we support yet
+		}
+		SetModel( CTPlayerModels[index] );
+	}
+	else
+	{
+		SetModel( CTPlayerModels[0] );
+	}
+}
+
+void CCSPlayer::Spawn()
+{
+	m_RateLimitLastCommandTimes.Purge();
+
+	// Get rid of the progress bar...
+	SetProgressBarTime( 0 );
+
+	CreateViewModel( 1 );
+
+	// Set their player model.
+	SetModelFromClass();
+
+	BaseClass::Spawn();
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [pfreese] Clear the last known nav area (used to be done by CBasePlayer)
+	//=============================================================================
+	
+	m_lastNavArea = NULL;
+	
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	AddFlag(FL_ONGROUND); // set the player on the ground at the start of the round.
+
+	// Override what CBasePlayer set for the view offset.
+	SetViewOffset( VEC_VIEW_SCALED( this ) );
+
+	//
+	// Our player movement speed is set once here. This will override the cl_xxxx
+	// cvars unless they are set to be lower than this.
+	//
+	SetMaxSpeed( CS_PLAYER_SPEED_RUN );
+
+	SetFOV( this, 0 );
+
+	m_bIsDefusing = false;
+
+	//=============================================================================
+	// HPE_BEGIN
+	// [dwenger] Reset hostage-related variables
+	//=============================================================================
+
+	m_bIsRescuing = false;
+	m_bInjuredAHostage = false;
+	m_iNumFollowers = 0;
+	
+	// [tj] Reset this flag if the player is not in observer mode (as happens when a player spawns late)
+	if (m_iPlayerState != STATE_OBSERVER_MODE)
+	{
+		m_wasNotKilledNaturally = false;
+	}
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	m_iShotsFired = 0;
+	m_iDirection = 0;
+
+	if ( m_pHintMessageQueue )
+	{
+		m_pHintMessageQueue->Reset();
+	}
+	m_iDisplayHistoryBits &= ~DHM_ROUND_CLEAR;
+
+	// Special-case here. A bunch of things happen in CBasePlayer::Spawn(), and we really want the
+	// player states to control these things, so give whatever player state we're in a chance
+	// to reinitialize itself.
+	State_Transition( m_iPlayerState );
+
+	ClearFlashbangScreenFade();
+
+	m_flVelocityModifier = 1.0f;
+
+	ResetStamina();
+
+	m_flLastRadarUpdateTime = 0.0f;
+
+	m_iNumSpawns++;
+
+	if ( !engine->IsDedicatedServer() && CSGameRules()->m_iTotalRoundsPlayed < 2 && TheNavMesh->IsOutOfDate() && this == UTIL_GetListenServerHost() )
+	{
+		ClientPrint( this, HUD_PRINTCENTER, "The Navigation Mesh was built using a different version of this map." );
+	}
+
+	m_bTeamChanged	= false;
+	m_iOldTeam = TEAM_UNASSIGNED;
+
+	m_iRadioMessages = 60;
+	m_flRadioTime = gpGlobals->curtime;
+
+	if ( m_hRagdoll )
+	{
+		UTIL_Remove( m_hRagdoll );
+	}
+
+	m_hRagdoll = NULL;
+
+	// did we change our name while we were dead?
+	if ( m_szNewName[0] != 0 )
+	{
+		ChangeName( m_szNewName );
+		m_szNewName[0] = 0;
+	}
+
+	if ( m_bIsVIP )
+	{
+		HintMessage( "#Hint_you_are_the_vip", true, true );
+	}
+
+	m_bIsInAutoBuy = false;
+	m_bIsInRebuy = false;
+	m_bAutoReload = false;
+
+	SetContextThink( &CCSPlayer::PushawayThink, gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, CS_PUSHAWAY_THINK_CONTEXT );
+
+	if ( GetActiveWeapon() && !IsObserver() )
+	{
+		GetActiveWeapon()->Deploy();
+		m_flNextAttack = gpGlobals->curtime; // Allow reloads to finish, since we're playing the deploy anim instead.  This mimics goldsrc behavior, anyway.
+	}
+
+	m_applyDeafnessTime = 0.0f;
+
+	m_cycleLatch = 0;
+	m_cycleLatchTimer.Start( RandomFloat( 0.0f, CycleLatchInterval ) );
+
+	StockPlayerAmmo();
+	}
+
+void CCSPlayer::ShowViewPortPanel( const char * name, bool bShow, KeyValues *data )
+{
+	if ( CSGameRules()->IsLogoMap() )
+		return;
+
+	if ( CommandLine()->FindParm("-makedevshots") )
+		return;
+
+	BaseClass::ShowViewPortPanel( name, bShow, data );
+}
+
+void CCSPlayer::ClearFlashbangScreenFade( void )
+{
+	if( IsBlind() )
+	{
+		color32 clr = { 0, 0, 0, 0 };
+		UTIL_ScreenFade( this, clr, 0.01, 0.0, FFADE_OUT | FFADE_PURGE );
+
+		m_flFlashDuration = 0.0f;
+		m_flFlashMaxAlpha = 255.0f;
+	}
+
+	// clear blind time (after screen fades are canceled)
+	m_blindUntilTime = 0.0f;
+	m_blindStartTime = 0.0f;
+}
+
+void CCSPlayer::GiveDefaultItems()
+{
+	// Always give the player the knife.
+	CBaseCombatWeapon *pistol = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+	if ( pistol )
+	{
+		return;
+	}
+
+	m_bUsingDefaultPistol = true;
+
+	if ( GetTeamNumber() == TEAM_CT )
+	{
+		GiveNamedItem( "weapon_knife" );
+		GiveNamedItem( "weapon_usp" );
+		GiveAmmo( 24, BULLET_PLAYER_45ACP );
+	}
+	else if ( GetTeamNumber() == TEAM_TERRORIST )
+	{
+		GiveNamedItem( "weapon_knife" );
+		GiveNamedItem( "weapon_glock" );
+		GiveAmmo( 40, BULLET_PLAYER_9MM );
+	}
+}
+
+void CCSPlayer::SetClanTag( const char *pTag )
+{
+	if ( pTag )
+	{
+		Q_strncpy( m_szClanTag, pTag, sizeof( m_szClanTag ) );
+	}
+}
+void CCSPlayer::CreateRagdollEntity()
+{
+	// If we already have a ragdoll, don't make another one.
+	CCSRagdoll *pRagdoll = dynamic_cast< CCSRagdoll* >( m_hRagdoll.Get() );
+
+	if ( !pRagdoll )
+	{
+		// create a new one
+		pRagdoll = dynamic_cast< CCSRagdoll* >( CreateEntityByName( "cs_ragdoll" ) );
+	}
+
+	if ( pRagdoll )
+	{
+		pRagdoll->m_hPlayer = this;
+		pRagdoll->m_vecRagdollOrigin = GetAbsOrigin();
+		pRagdoll->m_vecRagdollVelocity = GetAbsVelocity();
+		pRagdoll->m_nModelIndex = m_nModelIndex;
+		pRagdoll->m_nForceBone = m_nForceBone;
+		pRagdoll->m_vecForce = m_vecTotalBulletForce;
+		pRagdoll->m_iDeathPose = m_iDeathPose;
+		pRagdoll->m_iDeathFrame = m_iDeathFrame;
+		pRagdoll->Init();
+	}
+
+	// ragdolls will be removed on round restart automatically
+	m_hRagdoll = pRagdoll;
+}
+
+int CCSPlayer::OnTakeDamage_Alive( const CTakeDamageInfo &info )
+{
+	// set damage type sustained
+	m_bitsDamageType |= info.GetDamageType();
+
+	if ( !CBaseCombatCharacter::OnTakeDamage_Alive( info ) )
+		return 0;
+
+	// don't apply damage forces in CS
+
+	// fire global game event
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_hurt" );
+
+	if ( event )
+	{
+		event->SetInt("userid", GetUserID() );
+		event->SetInt("health", MAX(0, m_iHealth) );
+		event->SetInt("armor", MAX(0, ArmorValue()) );
+
+		event->SetInt( "dmg_health", m_lastDamageHealth );
+		event->SetInt( "dmg_armor", m_lastDamageArmor );
+
+		if ( info.GetDamageType() & DMG_BLAST )
+		{
+			event->SetInt( "hitgroup", HITGROUP_GENERIC );
+		}
+		else
+		{
+			event->SetInt( "hitgroup", m_LastHitGroup );
+		}
+
+		CBaseEntity * attacker = info.GetAttacker();
+		const char *weaponName = "";
+
+		if ( attacker->IsPlayer() )
+		{
+			CBasePlayer *player = ToBasePlayer( attacker );
+			event->SetInt("attacker", player->GetUserID() ); // hurt by other player
+
+			CBaseEntity *pInflictor = info.GetInflictor();
+			if ( pInflictor )
+			{
+				if ( pInflictor == player )
+				{
+					// If the inflictor is the killer,  then it must be their current weapon doing the damage
+					if ( player->GetActiveWeapon() )
+					{
+						weaponName = player->GetActiveWeapon()->GetClassname();
+					}
+				}
+				else
+				{
+					weaponName = STRING( pInflictor->m_iClassname );  // it's just that easy
+				}
+			}
+		}
+		else
+		{
+			event->SetInt("attacker", 0 ); // hurt by "world"
+		}
+
+		if ( strncmp( weaponName, "weapon_", 7 ) == 0 )
+		{
+			weaponName += 7;
+		}
+		else if( strncmp( weaponName, "hegrenade", 9 ) == 0 )	//"hegrenade_projectile"
+		{
+			//=============================================================================
+			// HPE_BEGIN:
+			// [tj] Handle grenade-surviving achievement
+			//=============================================================================
+			if (info.GetAttacker()->GetTeamNumber() != GetTeamNumber())
+			{
+				m_grenadeDamageTakenThisRound += info.GetDamage();
+			}
+			//=============================================================================
+			// HPE_END
+			//=============================================================================
+
+			weaponName = "hegrenade";
+		}
+		else if( strncmp( weaponName, "flashbang", 9 ) == 0 )	//"flashbang_projectile"
+		{
+			weaponName = "flashbang";
+		}
+		else if( strncmp( weaponName, "smokegrenade", 12 ) == 0 )	//"smokegrenade_projectile"
+		{
+			weaponName = "smokegrenade";
+		}
+
+		event->SetString( "weapon", weaponName );
+		event->SetInt( "priority", 5 );
+
+		gameeventmanager->FireEvent( event );
+	}
+
+	return 1;
+}
+
+//=============================================================================
+// HPE_BEGIN:
+// [dwenger] Supports fun-fact
+//=============================================================================
+
+// Returns the % of the enemies this player killed in the round
+int CCSPlayer::GetPercentageOfEnemyTeamKilled()
+{
+	if ( m_NumEnemiesAtRoundStart > 0 )
+	{
+		return (int)( ( (float)m_NumEnemiesKilledThisRound / (float)m_NumEnemiesAtRoundStart ) * 100.0f );
+	}
+
+	return 0;
+}
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+void CCSPlayer::Event_Killed( const CTakeDamageInfo &info )
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [pfreese] Process on-death achievements
+	//=============================================================================
+	
+	ProcessPlayerDeathAchievements(ToCSPlayer(info.GetAttacker()), this, info);
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	SetArmorValue( 0 );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Added a parameter so we know if it was death that caused the drop
+	// [menglish] Keep track of what the player has dropped for the freeze panel callouts
+	//=============================================================================
+	 
+	CBaseEntity* pAttacker = info.GetAttacker();
+	bool friendlyFire = pAttacker && pAttacker->GetTeamNumber() == GetTeamNumber();
+
+	//Only count the drop if it was not friendly fire
+	DropWeapons(true, !friendlyFire);
+	 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	
+
+	// Just in case the progress bar is on screen, kill it.
+	SetProgressBarTime( 0 );
+
+	m_bIsDefusing = false;
+
+	m_bHasNightVision = false;
+	m_bNightVisionOn = false;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [dwenger] Added for fun-fact support
+	//=============================================================================
+
+	m_bPickedUpDefuser = false;
+	m_bDefusedWithPickedUpKit = false;
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	m_bHasHelmet = false;
+
+	m_flFlashDuration = 0.0f;
+
+	FlashlightTurnOff();
+
+	// show killer in death cam mode
+	if( IsValidObserverTarget( info.GetAttacker() ) )
+	{
+		SetObserverTarget( info.GetAttacker() );
+	}
+	else
+	{
+		ResetObserverMode();
+	}
+
+	//update damage info with our accumulated physics force
+	CTakeDamageInfo subinfo = info;
+
+	// HACK[pfreese]: scale impulse up for visual effect
+	const float kImpulseBonusScale = 2.0f;
+	subinfo.SetDamageForce( m_vecTotalBulletForce * kImpulseBonusScale);
+
+	//Adrian: Select a death pose to extrapolate the ragdoll's velocity.
+	SelectDeathPose( info );
+
+	// See if there's a ragdoll magnet that should influence our force.
+	CRagdollMagnet *pMagnet = CRagdollMagnet::FindBestMagnet( this );
+	if( pMagnet )
+	{
+		m_vecTotalBulletForce += pMagnet->GetForceVector( this );
+	}
+
+	// Note: since we're dead, it won't draw us on the client, but we don't set EF_NODRAW
+	// because we still want to transmit to the clients in our PVS.
+	CreateRagdollEntity();
+
+	// Special code to drop holiday gifts for the holiday achievement
+	if ( ( mp_holiday_nogifts.GetBool() == false ) && UTIL_IsHolidayActive( 3 /*kHoliday_Christmas*/ ) )
+	{
+		if ( RandomInt( 0, 100 ) < 20 )
+		{
+			CHolidayGift::Create( WorldSpaceCenter(), GetAbsAngles(), EyeAngles(), GetAbsVelocity(), this );
+		}
+	}
+
+	State_Transition( STATE_DEATH_ANIM );	// Transition into the dying state.
+	BaseClass::Event_Killed( subinfo );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [pfreese] If this kill ended the round, award the MVP to someone on the
+	// winning team.
+	// TODO - move this code somewhere else more MVP related
+	//=============================================================================	 
+
+	bool roundWasAlreadyWon = (CSGameRules()->m_iRoundWinStatus != WINNER_NONE);
+	bool roundIsWonNow = CSGameRules()->CheckWinConditions();
+
+	if ( !roundWasAlreadyWon && roundIsWonNow )
+	{
+		CCSPlayer* pMVP = NULL;
+		int maxKills = 0;
+		int maxDamage = 0;
+
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer* pPlayer = ToCSPlayer( UTIL_PlayerByIndex( i ) );
+			if ( pPlayer )
+			{
+				// only consider players on the winning team
+				if ( pPlayer->GetTeamNumber() != CSGameRules()->m_iRoundWinStatus )
+					continue;
+
+				int nKills = CCS_GameStats.FindPlayerStats( pPlayer ).statsCurrentRound[CSSTAT_KILLS];
+				int nDamage = CCS_GameStats.FindPlayerStats( pPlayer ).statsCurrentRound[CSSTAT_DAMAGE];
+
+				if ( nKills > maxKills || ( nKills == maxKills && nDamage > maxDamage ) )
+				{
+					pMVP = pPlayer;
+					maxKills = nKills;
+					maxDamage = nDamage;
+				}
+			}
+		}
+
+		if ( pMVP )
+		{
+			pMVP->IncrementNumMVPs( CSMVP_ELIMINATION );
+		}
+	}
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	OutputDamageGiven();
+	OutputDamageTaken();
+	ResetDamageCounters();
+
+	if ( m_bPunishedForTK )
+	{
+		m_bPunishedForTK = false;
+		HintMessage( "#Hint_cannot_play_because_tk", true, true );
+	}
+
+	if ( !(m_iDisplayHistoryBits & DHF_SPEC_DUCK) )
+	{
+		m_iDisplayHistoryBits |= DHF_SPEC_DUCK;
+		HintMessage( "#Spec_Duck", true, true );
+	}
+}
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish, tj] Update and check any one-off achievements based on the kill
+//=============================================================================
+
+// Notify that I've killed some other entity. (called from Victim's Event_Killed).
+void CCSPlayer::Event_KilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info )
+{
+	BaseClass::Event_KilledOther(pVictim, info);
+}
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+void CCSPlayer::DeathSound( const CTakeDamageInfo &info )
+{
+	if( m_LastHitGroup == HITGROUP_HEAD )
+	{
+		EmitSound( "Player.DeathHeadShot" );
+	}
+	else
+	{
+		EmitSound( "Player.Death" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CCSPlayer::InitVCollision( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity )
+{
+	BaseClass::InitVCollision( vecAbsOrigin, vecAbsVelocity );
+
+	if ( sv_turbophysics.GetBool() )
+		return;
+
+	// Setup the HL2 specific callback.
+	GetPhysicsController()->SetEventHandler( &playerCallback );
+}
+
+void CCSPlayer::VPhysicsShadowUpdate( IPhysicsObject *pPhysics )
+{
+	if ( !CanMove() )
+		return;
+
+	BaseClass::VPhysicsShadowUpdate( pPhysics );
+}
+
+bool CCSPlayer::HasShield() const
+{
+#ifdef CS_SHIELD_ENABLED
+	return m_bHasShield;
+#else
+	return false;
+#endif
+}
+
+
+bool CCSPlayer::IsShieldDrawn() const
+{
+#ifdef CS_SHIELD_ENABLED
+	return m_bShieldDrawn;
+#else
+	return false;
+#endif
+}
+
+
+void CCSPlayer::CheatImpulseCommands( int iImpulse )
+{
+	switch( iImpulse )
+	{
+		case 101:
+		{
+			if( sv_cheats->GetBool() )
+			{
+				extern int gEvilImpulse101;
+				gEvilImpulse101 = true;
+
+				AddAccount( 16000 );
+
+				GiveAmmo( 250, BULLET_PLAYER_50AE );
+				GiveAmmo( 250, BULLET_PLAYER_762MM );
+				GiveAmmo( 250, BULLET_PLAYER_338MAG );
+				GiveAmmo( 250, BULLET_PLAYER_556MM );
+				GiveAmmo( 250, BULLET_PLAYER_556MM_BOX );
+				GiveAmmo( 250, BULLET_PLAYER_9MM );
+				GiveAmmo( 250, BULLET_PLAYER_BUCKSHOT );
+				GiveAmmo( 250, BULLET_PLAYER_45ACP );
+				GiveAmmo( 250, BULLET_PLAYER_357SIG );
+				GiveAmmo( 250, BULLET_PLAYER_57MM );
+
+				gEvilImpulse101 = false;
+			}
+		}
+		break;
+
+		default:
+		{
+			BaseClass::CheatImpulseCommands( iImpulse );
+		}
+	}
+}
+
+void CCSPlayer::SetupVisibility( CBaseEntity *pViewEntity, unsigned char *pvs, int pvssize )
+{
+	BaseClass::SetupVisibility( pViewEntity, pvs, pvssize );
+
+	int area = pViewEntity ? pViewEntity->NetworkProp()->AreaNum() : NetworkProp()->AreaNum();
+	PointCameraSetupVisibility( this, area, pvs, pvssize );
+}
+
+void CCSPlayer::UpdateAddonBits()
+{
+	int iNewBits = 0;
+
+	int nFlashbang = GetAmmoCount( GetAmmoDef()->Index( AMMO_TYPE_FLASHBANG ) );
+	if ( dynamic_cast< CFlashbang* >( GetActiveWeapon() ) )
+	{
+		--nFlashbang;
+	}
+
+	if ( nFlashbang >= 1 )
+		iNewBits |= ADDON_FLASHBANG_1;
+
+	if ( nFlashbang >= 2 )
+		iNewBits |= ADDON_FLASHBANG_2;
+
+	if ( GetAmmoCount( GetAmmoDef()->Index( AMMO_TYPE_HEGRENADE ) ) &&
+		!dynamic_cast< CHEGrenade* >( GetActiveWeapon() ) )
+	{
+		iNewBits |= ADDON_HE_GRENADE;
+	}
+
+	if ( GetAmmoCount( GetAmmoDef()->Index( AMMO_TYPE_SMOKEGRENADE ) ) &&
+		!dynamic_cast< CSmokeGrenade* >( GetActiveWeapon() ) )
+	{
+		iNewBits |= ADDON_SMOKE_GRENADE;
+	}
+
+	if ( HasC4() && !dynamic_cast< CC4* >( GetActiveWeapon() ) )
+		iNewBits |= ADDON_C4;
+
+	if ( HasDefuser() )
+		iNewBits |= ADDON_DEFUSEKIT;
+
+	CWeaponCSBase *weapon = dynamic_cast< CWeaponCSBase * >(Weapon_GetSlot( WEAPON_SLOT_RIFLE ));
+	if ( weapon && weapon != GetActiveWeapon() )
+	{
+		iNewBits |= ADDON_PRIMARY;
+		m_iPrimaryAddon = weapon->GetWeaponID();
+	}
+	else
+	{
+		m_iPrimaryAddon = WEAPON_NONE;
+	}
+
+	weapon = dynamic_cast< CWeaponCSBase * >(Weapon_GetSlot( WEAPON_SLOT_PISTOL ));
+	if ( weapon && weapon != GetActiveWeapon() )
+	{
+		iNewBits |= ADDON_PISTOL;
+		if ( weapon->GetWeaponID() == WEAPON_ELITE )
+		{
+			iNewBits |= ADDON_PISTOL2;
+		}
+		m_iSecondaryAddon = weapon->GetWeaponID();
+	}
+	else if ( weapon && weapon->GetWeaponID() == WEAPON_ELITE )
+	{
+		// The active weapon is weapon_elite.  Set ADDON_PISTOL2 without ADDON_PISTOL, so we know
+		// to display the empty holster.
+		iNewBits |= ADDON_PISTOL2;
+		m_iSecondaryAddon = weapon->GetWeaponID();
+	}
+	else
+	{
+		m_iSecondaryAddon = WEAPON_NONE;
+	}
+
+	m_iAddonBits = iNewBits;
+}
+
+void CCSPlayer::UpdateRadar()
+{
+	// update once a second
+	if ( (m_flLastRadarUpdateTime + 1.0) > gpGlobals->curtime )
+		return;
+
+	m_flLastRadarUpdateTime = gpGlobals->curtime;
+
+	// update positions of all players outside of my PVS
+	CBitVec< ABSOLUTE_PLAYER_LIMIT > playerbits;
+	engine->Message_DetermineMulticastRecipients( false, EyePosition(), playerbits );
+
+	CSingleUserRecipientFilter user( this );
+	UserMessageBegin( user, "UpdateRadar" );
+
+	for ( int i=0; i < MAX_PLAYERS; i++ )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( i+1 ) );
+
+		if ( !pPlayer )
+			continue; // nothing there
+
+		bool bSameTeam = pPlayer->GetTeamNumber() == GetTeamNumber();
+
+		if ( playerbits.Get(i) && bSameTeam == true )
+			continue; // this player is in my PVS and not in my team, don't update radar pos
+
+		if ( pPlayer == this )
+			continue;
+
+		if ( !pPlayer->IsAlive() || pPlayer->IsObserver() || !pPlayer->IsConnected() )
+			continue; // don't update specattors or dead players
+
+		WRITE_BYTE( i+1 ); // player index as entity
+		WRITE_SBITLONG( pPlayer->GetAbsOrigin().x/4, COORD_INTEGER_BITS-1 );
+		WRITE_SBITLONG( pPlayer->GetAbsOrigin().y/4, COORD_INTEGER_BITS-1 );
+		WRITE_SBITLONG( pPlayer->GetAbsOrigin().z/4, COORD_INTEGER_BITS-1 );
+		WRITE_SBITLONG(  AngleNormalize( pPlayer->GetAbsAngles().y ), 9 );
+	}
+
+	WRITE_BYTE( 0 ); // end marker
+
+	MessageEnd();
+}
+
+void CCSPlayer::UpdateMouseoverHints()
+{
+	if ( IsBlind() || IsObserver() )
+		return;
+
+	Vector forward, up;
+	EyeVectors( &forward, NULL, &up );
+
+	trace_t tr;
+	// Search for objects in a sphere (tests for entities that are not solid, yet still useable)
+	Vector searchStart = EyePosition();
+	Vector searchEnd = searchStart + forward * 2048;
+
+	int useableContents = MASK_NPCSOLID_BRUSHONLY | MASK_VISIBLE_AND_NPCS;
+
+	UTIL_TraceLine( searchStart, searchEnd, useableContents, this, COLLISION_GROUP_NONE, &tr );
+
+	if ( tr.fraction != 1.0f )
+	{
+		if (tr.DidHitNonWorldEntity() && tr.m_pEnt)
+		{
+			CBaseEntity *pObject = tr.m_pEnt;
+			switch ( pObject->Classify() )
+			{
+			case CLASS_PLAYER:
+				{
+					const float grenadeBloat = 1.2f; // Be conservative in estimating what a player can distinguish
+					if ( !TheBots->IsLineBlockedBySmoke( EyePosition(), pObject->EyePosition(), grenadeBloat ) )
+					{
+						if ( g_pGameRules->PlayerRelationship( this, pObject ) == GR_TEAMMATE )
+						{
+							if ( !(m_iDisplayHistoryBits & DHF_FRIEND_SEEN) )
+							{
+								m_iDisplayHistoryBits |= DHF_FRIEND_SEEN;
+								HintMessage( "#Hint_spotted_a_friend", true );
+							}
+						}
+						else
+						{
+							if ( !(m_iDisplayHistoryBits & DHF_ENEMY_SEEN) )
+							{
+								m_iDisplayHistoryBits |= DHF_ENEMY_SEEN;
+								HintMessage( "#Hint_spotted_an_enemy", true );
+							}
+						}
+					}
+				}
+				break;
+			case CLASS_PLAYER_ALLY:
+				switch ( GetTeamNumber() )
+				{
+				case TEAM_CT:
+					if ( !(m_iDisplayHistoryBits & DHF_HOSTAGE_SEEN_FAR) && tr.fraction > 0.1f )
+					{
+						m_iDisplayHistoryBits |= DHF_HOSTAGE_SEEN_FAR;
+						HintMessage( "#Hint_rescue_the_hostages", true );
+					}
+					else if ( !(m_iDisplayHistoryBits & DHF_HOSTAGE_SEEN_NEAR) && tr.fraction <= 0.1f )
+					{
+						m_iDisplayHistoryBits |= DHF_HOSTAGE_SEEN_FAR;
+						m_iDisplayHistoryBits |= DHF_HOSTAGE_SEEN_NEAR;
+						HintMessage( "#Hint_press_use_so_hostage_will_follow", false );
+					}
+					break;
+				case TEAM_TERRORIST:
+					if ( !(m_iDisplayHistoryBits & DHF_HOSTAGE_SEEN_FAR) )
+					{
+						m_iDisplayHistoryBits |= DHF_HOSTAGE_SEEN_FAR;
+						HintMessage( "#Hint_prevent_hostage_rescue", true );
+					}
+					break;
+				}
+				break;
+			}
+		}
+	}
+}
+
+void CCSPlayer::PostThink()
+{
+	BaseClass::PostThink();
+
+	UpdateAddonBits();
+
+	UpdateRadar();
+
+	if ( !(m_iDisplayHistoryBits & DHF_ROUND_STARTED) && CanPlayerBuy(false) )
+	{
+		HintMessage( "#Hint_press_buy_to_purchase", false );
+		m_iDisplayHistoryBits |= DHF_ROUND_STARTED;
+	}
+	if ( m_flNextMouseoverUpdate < gpGlobals->curtime )
+	{
+		m_flNextMouseoverUpdate = gpGlobals->curtime + 0.2f;
+		if ( m_bShowHints )
+		{
+			UpdateMouseoverHints();
+		}
+	}
+	if ( GetActiveWeapon() && !(m_iDisplayHistoryBits & DHF_AMMO_EXHAUSTED) )
+	{
+		CBaseCombatWeapon *pWeapon = GetActiveWeapon();
+		if ( !pWeapon->HasAnyAmmo() && !(pWeapon->GetWpnData().iFlags & ITEM_FLAG_EXHAUSTIBLE) )
+		{
+			m_iDisplayHistoryBits |= DHF_AMMO_EXHAUSTED;
+			HintMessage( "#Hint_out_of_ammo", false );
+		}
+	}
+
+	QAngle angles = GetLocalAngles();
+	angles[PITCH] = 0;
+	SetLocalAngles( angles );
+
+	// Store the eye angles pitch so the client can compute its animation state correctly.
+	m_angEyeAngles = EyeAngles();
+
+	m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );
+
+	// check if we need to apply a deafness DSP effect.
+	if ((m_applyDeafnessTime != 0.0f) && (m_applyDeafnessTime <= gpGlobals->curtime))
+	{
+		ApplyDeafnessEffect();
+	}
+
+	if ( IsPlayerUnderwater() && GetWaterLevel() < 3 )
+	{
+		StopSound( "Player.AmbientUnderWater" );
+		SetPlayerUnderwater( false );
+	}
+
+	if( IsAlive() && m_cycleLatchTimer.IsElapsed() )
+	{
+		m_cycleLatchTimer.Start( CycleLatchInterval );
+
+		// Cycle is a float from 0 to 1.  We don't need to transmit a whole float for that.  Compress it in to a small fixed point
+		m_cycleLatch.GetForModify() = 16 * GetCycle();// 4 point fixed
+	}
+}
+
+
+void CCSPlayer::PushawayThink()
+{
+	// Push physics props out of our way.
+	PerformObstaclePushaway( this );
+	SetNextThink( gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, CS_PUSHAWAY_THINK_CONTEXT );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether or not we can switch to the given weapon.
+// Input  : pWeapon -
+//-----------------------------------------------------------------------------
+bool CCSPlayer::Weapon_CanSwitchTo( CBaseCombatWeapon *pWeapon )
+{
+	if ( !pWeapon->CanDeploy() )
+		return false;
+
+	if ( GetActiveWeapon() )
+	{
+		if ( !GetActiveWeapon()->CanHolster() )
+			return false;
+	}
+
+	return true;
+}
+
+bool CCSPlayer::ShouldDoLargeFlinch( int nHitGroup, CBaseEntity *pAttacker )
+{
+	if ( FBitSet( GetFlags(), FL_DUCKING ) )
+		return FALSE;
+
+	if ( nHitGroup == HITGROUP_LEFTLEG )
+		return FALSE;
+
+	if ( nHitGroup == HITGROUP_RIGHTLEG )
+		return FALSE;
+
+	CCSPlayer *pPlayer = ToCSPlayer( pAttacker );
+
+	if ( pPlayer == NULL || !pPlayer->IsPlayer() )
+		 pPlayer = NULL;
+
+	if ( pPlayer )
+	{
+		CWeaponCSBase *pWeapon = pPlayer->GetActiveCSWeapon();
+
+		if ( pWeapon )
+		{
+			if ( pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_RIFLE ||
+				 pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_SHOTGUN ||
+				 pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_SNIPER_RIFLE )
+				 return true;
+		}
+		else
+			return false;
+	}
+
+	return false;
+}
+
+bool CCSPlayer::IsArmored( int nHitGroup )
+{
+	bool bApplyArmor = false;
+
+	if ( ArmorValue() > 0 )
+	{
+		switch ( nHitGroup )
+		{
+		case HITGROUP_GENERIC:
+		case HITGROUP_CHEST:
+		case HITGROUP_STOMACH:
+		case HITGROUP_LEFTARM:
+		case HITGROUP_RIGHTARM:
+			bApplyArmor = true;
+			break;
+		case HITGROUP_HEAD:
+			if ( m_bHasHelmet )
+			{
+				bApplyArmor = true;
+			}
+			break;
+		default:
+			break;
+		}
+	}
+
+	return bApplyArmor;
+}
+
+void CCSPlayer::Pain( bool bHasArmour )
+{
+	switch (m_LastHitGroup)
+	{
+		case HITGROUP_HEAD:
+			if (m_bHasHelmet)  // He's wearing a helmet
+			{
+				EmitSound( "Player.DamageHelmet" );
+			}
+			else  // He's not wearing a helmet
+			{
+				EmitSound( "Player.DamageHeadShot" );
+			}
+			break;
+		default:
+			if ( bHasArmour == false )
+			{
+				EmitSound( "Flesh.BulletImpact" );
+			}
+			else
+			{
+				EmitSound( "Player.DamageKevlar" );
+			}
+			break;
+	}
+}
+
+int CCSPlayer::OnTakeDamage( const CTakeDamageInfo &inputInfo )
+{
+	CTakeDamageInfo info = inputInfo;
+
+	CBaseEntity *pInflictor = info.GetInflictor();
+
+	if ( !pInflictor )
+		return 0;
+
+	if ( GetMoveType() == MOVETYPE_NOCLIP || GetMoveType() == MOVETYPE_OBSERVER )
+		return 0;
+
+	const float flArmorBonus = 0.5f;
+	float flArmorRatio = 0.5f;
+	float flDamage = info.GetDamage();
+
+	bool bFriendlyFire = CSGameRules()->IsFriendlyFireOn();
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Added properties for goose chase achievement
+	//=============================================================================
+ 
+	CSGameRules()->PlayerTookDamage(this, inputInfo);
+
+	//Check "Goose Chase" achievement
+	CCSPlayer *pAttacker = ToCSPlayer(info.GetAttacker());
+	if (m_bIsDefusing && m_gooseChaseStep == GC_NONE && pAttacker && pAttacker->GetTeamNumber() != GetTeamNumber() )
+	{
+
+		//Count enemies
+		int livingEnemies = 0;
+		CTeam *pAttackerTeam = GetGlobalTeam( pAttacker->GetTeamNumber() );
+		for ( int iPlayer=0; iPlayer < pAttackerTeam->GetNumPlayers(); iPlayer++ )
+		{
+			CCSPlayer *pPlayer = ToCSPlayer( pAttackerTeam->GetPlayer( iPlayer ) );
+			Assert( pPlayer );
+			if ( !pPlayer )
+				continue;
+
+			Assert( pPlayer->GetTeamNumber() == pAttackerTeam->GetTeamNumber() );
+			
+			if ( pPlayer->m_lifeState == LIFE_ALIVE )
+			{
+				livingEnemies++;
+			}
+		}
+
+		//Must be last enemy alive;
+		if (livingEnemies == 1)
+		{
+			m_gooseChaseStep = GC_SHOT_DURING_DEFUSE;
+			m_pGooseChaseDistractingPlayer = pAttacker;
+		}
+	}
+ 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+
+	// warn about team attacks
+	if ( bFriendlyFire && pInflictor->GetTeamNumber() == GetTeamNumber() && pInflictor != this && info.GetAttacker() != this )
+	{
+		CCSPlayer *pCSAttacker = ToCSPlayer( pInflictor );
+		if ( !pCSAttacker )
+			pCSAttacker = ToCSPlayer( info.GetAttacker() );
+
+		if ( pCSAttacker )
+		{
+			if ( !(pCSAttacker->m_iDisplayHistoryBits & DHF_FRIEND_INJURED) )
+			{
+				pCSAttacker->HintMessage( "#Hint_try_not_to_injure_teammates", false );
+				pCSAttacker->m_iDisplayHistoryBits |= DHF_FRIEND_INJURED;
+			}
+
+			if ( (pCSAttacker->m_flLastAttackedTeammate + 0.6f) < gpGlobals->curtime )
+			{
+				pCSAttacker->m_flLastAttackedTeammate = gpGlobals->curtime;
+
+				// tell the rest of this player's team
+				Msg( "%s attacked a teammate\n", pCSAttacker->GetPlayerName() );
+				for ( int i=1; i<=gpGlobals->maxClients; ++i )
+				{
+					CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+					if ( pPlayer && pPlayer->GetTeamNumber() == GetTeamNumber()	)
+					{
+						ClientPrint( pPlayer, HUD_PRINTTALK, "#Game_teammate_attack", pCSAttacker->GetPlayerName() );
+					}
+				}
+			}
+		}
+	}
+
+	if ( bFriendlyFire ||
+		pInflictor->GetTeamNumber() != GetTeamNumber() ||
+		pInflictor == this ||
+		info.GetAttacker() == this )
+	{
+		if ( bFriendlyFire && (info.GetDamageType() & DMG_BLAST) == 0 )
+		{
+			if ( pInflictor->GetTeamNumber() == GetTeamNumber() )
+			{
+				flDamage *= 0.35; // bullets hurt teammates less
+			}
+		}
+
+		if ( ShouldDoLargeFlinch( m_LastHitGroup, info.GetAttacker() ) )
+		{
+			if ( GetAbsVelocity().Length() < 300 )
+			{
+				m_flVelocityModifier = 0.65;
+			}
+		}
+		else
+		{
+			m_flVelocityModifier = 0.5;
+		}
+
+//=============================================================================
+// HPE_BEGIN:
+//=============================================================================
+		// [menglish] Store whether or not the knife did this damage as knives do bullet damage,
+		// so we need to specifically check the weapon here
+		bool bKnifeDamage = false;
+		CCSPlayer *pPlayer = ToCSPlayer( info.GetAttacker() );
+
+		if ( pPlayer )
+		{
+
+			// [paquin. forest] if  this is blast damage, and we haven't opted out with a cvar,
+			// we need to get the armor ratio out of the inflictor
+
+			if ( (info.GetDamageType() & DMG_BLAST) && !sv_legacy_grenade_damage.GetBool() )
+			{
+
+				// [paquin] if we know this is a grenade, use it's armor ratio, otherwise
+				// use the he grenade armor ratio
+
+				CBaseCSGrenadeProjectile *pGrenade = dynamic_cast< CBaseCSGrenadeProjectile * >( pInflictor );
+				CCSWeaponInfo* pWeaponInfo;
+
+				if ( pGrenade && pGrenade->m_pWeaponInfo )
+				{
+					pWeaponInfo = pGrenade->m_pWeaponInfo;
+				}
+				else
+				{
+					pWeaponInfo = GetWeaponInfo( WEAPON_HEGRENADE );
+				}
+
+				if ( pWeaponInfo )
+				{
+					flArmorRatio *= pWeaponInfo->m_flArmorRatio;
+				}
+			}
+			else
+			{
+				CWeaponCSBase *pWeapon = pPlayer->GetActiveCSWeapon();
+
+				if ( pWeapon )
+				{
+					flArmorRatio *= pWeapon->GetCSWpnData().m_flArmorRatio;
+					//Knives do bullet damage, so we need to specifically check the weapon here
+					bKnifeDamage = pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_KNIFE;
+
+					if (  info.GetDamageType() & DMG_BULLET && !bKnifeDamage && pPlayer->GetTeam() != GetTeam() )
+					{
+						CCS_GameStats.Event_ShotHit( pPlayer, info );
+					}
+				}
+			}
+		}
+ 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+		// keep track of amount of damage last sustained
+		m_lastDamageAmount = flDamage;
+
+		// Deal with Armour
+		if ( ArmorValue() && !( info.GetDamageType() & (DMG_FALL | DMG_DROWN)) && IsArmored( m_LastHitGroup ) )
+		{
+			float fDamageToHealth = flDamage * flArmorRatio;
+			float fDamageToArmor = (flDamage - fDamageToHealth) * flArmorBonus;
+
+			int armorValue = ArmorValue();
+
+			// Does this use more armor than we have?
+			if (fDamageToArmor > armorValue )
+			{
+				fDamageToHealth = flDamage - armorValue / flArmorBonus;
+				fDamageToArmor = armorValue;
+				armorValue = 0;
+			}
+			else
+			{
+				if ( fDamageToArmor < 0 )
+					 fDamageToArmor = 1;
+
+				armorValue -= fDamageToArmor;
+			}
+			m_lastDamageArmor = (int)fDamageToArmor;
+			SetArmorValue(armorValue);
+
+			//=============================================================================
+			// HPE_BEGIN:
+			// [tj] Handle headshot-surviving achievement
+			//=============================================================================
+			if (m_LastHitGroup == HITGROUP_HEAD && flDamage > m_iHealth && fDamageToHealth < m_iHealth)
+			{
+				m_bSurvivedHeadshotDueToHelmet = true;
+			}			
+			//=============================================================================
+			// HPE_END			
+			//=============================================================================
+
+			flDamage = fDamageToHealth;
+
+			info.SetDamage( flDamage );
+
+			if ( ArmorValue() <= 0.0)
+				m_bHasHelmet = false;
+
+			if( !(info.GetDamageType() & DMG_FALL) )
+				Pain( true /*has armor*/ );
+		}
+		else
+		{
+			m_lastDamageArmor = 0;
+			if( !(info.GetDamageType() & DMG_FALL) )
+				Pain( false /*no armor*/ );
+		}
+
+		// round damage to integer
+		m_lastDamageHealth = (int)flDamage;
+		info.SetDamage( m_lastDamageHealth );
+
+		if ( info.GetDamage() <= 0 )
+			return 0;
+
+		CSingleUserRecipientFilter user( this );
+		user.MakeReliable();
+		UserMessageBegin( user, "Damage" );
+			WRITE_BYTE( (int)info.GetDamage() );
+			WRITE_VEC3COORD( info.GetInflictor()->WorldSpaceCenter() );
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Send the info about where the player was hit
+//=============================================================================
+			if ( !( info.GetDamageType() & DMG_BULLET ) || bKnifeDamage )
+			{
+				WRITE_LONG( -1 );
+			}
+			else
+			{
+				WRITE_LONG( m_LastHitBox );
+			}
+			WRITE_VEC3COORD( m_vLastHitLocationObjectSpace );
+			 
+//=============================================================================
+// HPE_END
+//=============================================================================
+		MessageEnd();
+
+		// Do special explosion damage effect
+		if ( info.GetDamageType() & DMG_BLAST )
+		{
+			OnDamagedByExplosion( info );
+		}
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Achievement award for kill stealing i.e. killing an enemy who was very damaged from other players
+// [Forrest] Moved this check before RecordDamageTaken so that the damage currently being dealt by this player
+//           won't disqualify them from getting the achievement.
+//=============================================================================
+
+		if(m_iHealth - info.GetDamage() <= 0 && m_iHealth <= AchievementConsts::KillLowDamage_MaxHealthLeft)
+		{
+			bool onlyDamage = true;
+			CCSPlayer *pAttacker = ToCSPlayer(info.GetAttacker());
+			if(pAttacker && pAttacker->GetTeamNumber() != GetTeamNumber())
+			{
+				//Verify that the killer has not done damage to this player beforehand
+				FOR_EACH_LL( m_DamageTakenList, i )
+				{
+					if( Q_strncmp( pAttacker->GetPlayerName(), m_DamageTakenList[i]->GetPlayerName(), MAX_PLAYER_NAME_LENGTH ) == 0 )
+					{
+						onlyDamage = false;
+						break;
+					}
+				}
+				if(onlyDamage)
+				{
+					pAttacker->AwardAchievement(CSKillLowDamage);
+				}
+			}
+		}
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+#if REPORT_PLAYER_DAMAGE
+		// damage output spew
+		char dmgtype[64];
+		CTakeDamageInfo::DebugGetDamageTypeString( info.GetDamageType(), dmgtype, sizeof(dmgtype) );
+
+		if ( info.GetDamageType() & DMG_HEADSHOT )
+			Q_strncat(dmgtype, "HEADSHOT", sizeof(dmgtype));
+
+		char outputString[256];
+		Q_snprintf( outputString, sizeof(outputString), "%f: Player %s incoming %f damage from %s, type %s; applied %d health and %d armor\n", 
+			gpGlobals->curtime, GetPlayerName(),
+			inputInfo.GetDamage(), info.GetInflictor()->GetDebugName(), dmgtype,
+			m_lastDamageHealth, m_lastDamageArmor);
+
+		Msg(outputString);
+#endif
+
+
+		if ( pPlayer )
+		{		
+			// Record for the shooter
+			pPlayer->RecordDamageGiven( GetPlayerName(), info.GetDamage() );
+
+			// And for the victim
+			RecordDamageTaken( pPlayer->GetPlayerName(), info.GetDamage() );
+		}
+		else
+		{
+			RecordDamageTaken( "world", info.GetDamage() );
+		}
+
+		m_vecTotalBulletForce += info.GetDamageForce();
+
+		gamestats->Event_PlayerDamage( this, info );
+
+		return CBaseCombatCharacter::OnTakeDamage( info );
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+
+//MIKETODO: this probably should let the shield model catch the trace attacks.
+bool CCSPlayer::IsHittingShield( const Vector &vecDirection, trace_t *ptr )
+{
+	if ( HasShield() == false )
+		 return false;
+
+	if ( IsShieldDrawn() == false )
+		 return false;
+
+	float		flDot;
+	Vector		vForward;
+	Vector2D	vec2LOS = vecDirection.AsVector2D();
+	AngleVectors( GetLocalAngles(), &vForward );
+
+	Vector2DNormalize( vForward.AsVector2D() );
+	Vector2DNormalize( vec2LOS );
+
+	flDot = DotProduct2D ( vec2LOS , vForward.AsVector2D() );
+
+	if ( flDot < -0.87f )
+		 return true;
+
+	return false;
+}
+
+
+void CCSPlayer::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
+{
+	bool bShouldBleed = true;
+	bool bShouldSpark = false;
+	bool bHitShield = IsHittingShield( vecDir, ptr );
+
+	CBasePlayer *pAttacker = (CBasePlayer*)ToBasePlayer( info.GetAttacker() );
+
+	// show blood for firendly fire only if FF is on
+	if ( pAttacker && ( GetTeamNumber() == pAttacker->GetTeamNumber() ) )
+		 bShouldBleed = CSGameRules()->IsFriendlyFireOn();
+
+	if ( m_takedamage != DAMAGE_YES )
+		return;
+
+	m_LastHitGroup = ptr->hitgroup;
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Used when calculating the position this player was hit at in the bone space
+//=============================================================================
+	m_LastHitBox = ptr->hitbox;
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+	m_nForceBone = ptr->physicsbone;	//Save this bone for ragdoll
+
+	float flDamage = info.GetDamage();
+
+	bool bHeadShot = false;
+
+	if ( bHitShield )
+	{
+		flDamage = 0;
+		bShouldBleed = false;
+		bShouldSpark = true;
+	}
+	else if( info.GetDamageType() & DMG_BLAST )
+	{
+		if ( ArmorValue() > 0 )
+			 bShouldBleed = false;
+
+		if ( bShouldBleed == true )
+		{
+			// punch view if we have no armor
+			QAngle punchAngle = GetPunchAngle();
+			punchAngle.x = flDamage * -0.1;
+
+			if ( punchAngle.x < -4 )
+				punchAngle.x = -4;
+
+			SetPunchAngle( punchAngle );
+		}
+	}
+	else
+	{
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Calculate the position this player was hit at in the bone space
+//=============================================================================
+		 
+		matrix3x4_t boneTransformToWorld, boneTransformToObject;
+		GetBoneTransform(GetHitboxBone(ptr->hitbox), boneTransformToWorld);
+		MatrixInvert(boneTransformToWorld, boneTransformToObject);
+		VectorTransform(ptr->endpos, boneTransformToObject, m_vLastHitLocationObjectSpace);
+		 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+		switch ( ptr->hitgroup )
+		{
+		case HITGROUP_GENERIC:
+			break;
+
+		case HITGROUP_HEAD:
+
+			if ( m_bHasHelmet )
+			{
+//				bShouldBleed = false;
+				bShouldSpark = true;
+			}
+
+			flDamage *= 4;
+
+			if ( !m_bHasHelmet )
+			{
+				QAngle punchAngle = GetPunchAngle();
+				punchAngle.x = flDamage * -0.5;
+
+				if ( punchAngle.x < -12 )
+					punchAngle.x = -12;
+
+				punchAngle.z = flDamage * random->RandomFloat(-1,1);
+
+				if ( punchAngle.z < -9 )
+					punchAngle.z = -9;
+
+				else if ( punchAngle.z > 9 )
+					punchAngle.z = 9;
+
+				SetPunchAngle( punchAngle );
+			}
+
+			bHeadShot = true;
+
+			break;
+
+		case HITGROUP_CHEST:
+
+			flDamage *= 1.0;
+
+			if ( ArmorValue() <= 0 )
+			{
+				QAngle punchAngle = GetPunchAngle();
+				punchAngle.x = flDamage * -0.1;
+
+				if ( punchAngle.x < -4 )
+					punchAngle.x = -4;
+
+				SetPunchAngle( punchAngle );
+			}
+			break;
+
+		case HITGROUP_STOMACH:
+
+			flDamage *= 1.25;
+
+			if ( ArmorValue() <= 0 )
+			{
+				QAngle punchAngle = GetPunchAngle();
+				punchAngle.x = flDamage * -0.1;
+
+				if ( punchAngle.x < -4 )
+					punchAngle.x = -4;
+
+				SetPunchAngle( punchAngle );
+			}
+
+			break;
+
+		case HITGROUP_LEFTARM:
+		case HITGROUP_RIGHTARM:
+			flDamage *= 1.0;
+			break;
+
+		case HITGROUP_LEFTLEG:
+		case HITGROUP_RIGHTLEG:
+			flDamage *= 0.75;
+			break;
+
+		default:
+			break;
+		}
+	}
+
+	// Since this code only runs on the server, make sure it shows the tempents it creates.
+	CDisablePredictionFiltering disabler;
+
+	if ( bShouldBleed )
+	{
+		// This does smaller splotches on the guy and splats blood on the world.
+		TraceBleed( flDamage, vecDir, ptr, info.GetDamageType() );
+
+		CEffectData	data;
+		data.m_vOrigin = ptr->endpos;
+		data.m_vNormal = vecDir * -1;
+		data.m_nEntIndex = ptr->m_pEnt ?  ptr->m_pEnt->entindex() : 0;
+		data.m_flMagnitude = flDamage;
+
+		// reduce blood effect if target has armor
+		if ( ArmorValue() > 0 )
+			data.m_flMagnitude *= 0.5f;
+
+		// reduce blood effect if target is hit in the helmet
+		if ( ptr->hitgroup == HITGROUP_HEAD && bShouldSpark )
+			data.m_flMagnitude *= 0.5;
+
+		DispatchEffect( "csblood", data );
+	}
+	if ( ( ptr->hitgroup == HITGROUP_HEAD || bHitShield ) && bShouldSpark ) // they hit a helmet
+	{
+		// show metal spark effect
+		g_pEffects->Sparks( ptr->endpos, 1, 1, &ptr->plane.normal );
+	}
+
+	if ( !bHitShield )
+	{
+		CTakeDamageInfo subInfo = info;
+
+		subInfo.SetDamage( flDamage );
+
+		if( bHeadShot )
+			subInfo.AddDamageType( DMG_HEADSHOT );
+
+		AddMultiDamage( subInfo, this );
+	}
+}
+
+
+void CCSPlayer::Reset()
+{
+	ResetFragCount();
+	ResetDeathCount();
+	m_iAccount = 0;
+	AddAccount( -16000, false );
+
+	//remove any weapons they bought before the round started
+	RemoveAllItems( true );
+
+	//RemoveShield();
+
+	AddAccount( CSGameRules()->GetStartMoney(), true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays a hint message to the player
+// Input  : *pMessage -
+//			bDisplayIfDead -
+//			bOverrideClientSettings -
+//-----------------------------------------------------------------------------
+void CCSPlayer::HintMessage( const char *pMessage, bool bDisplayIfDead, bool bOverrideClientSettings )
+{
+	if ( ( !bDisplayIfDead && !IsAlive() ) || !IsNetClient() || !m_pHintMessageQueue )
+		return;
+
+	if ( bOverrideClientSettings || m_bShowHints )
+		m_pHintMessageQueue->AddMessage( pMessage );
+}
+
+void CCSPlayer::AddAccount( int amount, bool bTrackChange, bool bItemBought, const char *pItemName )
+{
+	m_iAccount += amount;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Description of reason for change
+	//=============================================================================
+
+	if(amount > 0)
+	{
+		CCS_GameStats.Event_MoneyEarned( this, amount );
+	}
+	else if( amount < 0 && bItemBought)
+	{
+		CCS_GameStats.Event_MoneySpent( this, ABS(amount), pItemName );
+	}
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	if ( m_iAccount < 0 )
+		m_iAccount = 0;
+	else if ( m_iAccount > 16000 )
+		m_iAccount = 16000;
+}
+
+void CCSPlayer::MarkAsNotReceivingMoneyNextRound()
+{
+	m_receivesMoneyNextRound = false;
+}
+
+bool CCSPlayer::DoesPlayerGetRoundStartMoney()
+{
+	return m_receivesMoneyNextRound;
+}
+
+CCSPlayer* CCSPlayer::Instance( int iEnt )
+{
+	return dynamic_cast< CCSPlayer* >( CBaseEntity::Instance( INDEXENT( iEnt ) ) );
+}
+
+
+void CCSPlayer::DropC4()
+{
+}
+
+
+bool CCSPlayer::HasDefuser()
+{
+	return m_bHasDefuser;
+}
+
+void CCSPlayer::RemoveDefuser()
+{
+	m_bHasDefuser = false;
+}
+
+void CCSPlayer::GiveDefuser(bool bPickedUp /* = false */)
+{
+	if ( !m_bHasDefuser )
+	{
+		IGameEvent * event = gameeventmanager->CreateEvent( "item_pickup" );
+		if( event )
+		{
+			event->SetInt( "userid", GetUserID() );
+			event->SetString( "item", "defuser" );
+			gameeventmanager->FireEvent( event );
+		}
+	}
+
+	m_bHasDefuser = true;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [dwenger] Added for fun-fact support
+	//=============================================================================
+
+	m_bPickedUpDefuser = bPickedUp;
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+// player blinded by a flashbang
+void CCSPlayer::Blind( float holdTime, float fadeTime, float startingAlpha )
+{
+	// Don't flash a spectator.
+	color32 clr = {255, 255, 255, 255};
+
+	clr.a = startingAlpha;
+
+	// estimate when we can see again
+	float oldBlindUntilTime = m_blindUntilTime;
+	float oldBlindStartTime = m_blindStartTime;
+	m_blindUntilTime = MAX( m_blindUntilTime, gpGlobals->curtime + holdTime + 0.5f * fadeTime );
+	m_blindStartTime = gpGlobals->curtime;
+
+	// Spectators get a lessened flash.
+	if ( (GetObserverMode() != OBS_MODE_NONE)  &&  (GetObserverMode() != OBS_MODE_IN_EYE) )
+	{
+		if ( !mp_fadetoblack.GetBool() )
+		{
+			clr.a = 150;
+
+			fadeTime = MIN(fadeTime, 0.5f); // make sure the spectator flashbang time is 1/2 second or less.
+			holdTime = MIN(holdTime, fadeTime * 0.5f); // adjust the hold time to match the fade time.
+			UTIL_ScreenFade( this, clr, fadeTime, holdTime, FFADE_IN );
+		}
+	}
+	else
+	{
+		fadeTime /= 1.4;
+
+		if ( gpGlobals->curtime > oldBlindUntilTime )
+		{
+			// The previous flashbang is wearing off, or completely gone
+			m_flFlashDuration = fadeTime;
+			m_flFlashMaxAlpha = startingAlpha;
+		}
+		else
+		{
+			// The previous flashbang is still going strong - only extend the duration
+			float remainingDuration = oldBlindStartTime + m_flFlashDuration - gpGlobals->curtime;
+
+			m_flFlashDuration = MAX( remainingDuration, fadeTime );
+			m_flFlashMaxAlpha = MAX( m_flFlashMaxAlpha, startingAlpha );
+		}
+
+		// allow bots to react
+		IGameEvent * event = gameeventmanager->CreateEvent( "player_blind" );
+		if ( event )
+		{
+			event->SetInt( "userid", GetUserID() );
+			gameeventmanager->FireEvent( event );
+		}
+	}
+}
+
+void CCSPlayer::Deafen( float flDistance )
+{
+	// Spectators don't get deafened
+	if ( (GetObserverMode() == OBS_MODE_NONE)  ||  (GetObserverMode() == OBS_MODE_IN_EYE) )
+	{
+		// dsp presets are defined in hl2/scripts/dsp_presets.txt
+
+		int effect;
+
+		if( flDistance < 600 )
+		{
+			effect = 134;
+		}
+		else if( flDistance < 800 )
+		{
+			effect = 135;
+		}
+		else if( flDistance < 1000 )
+		{
+			effect = 136;
+		}
+		else
+		{
+			// too far for us to get an effect
+			return;
+		}
+
+		CSingleUserRecipientFilter user( this );
+		enginesound->SetPlayerDSP( user, effect, false );
+
+		//TODO: bots can't hear sound for a while?
+	}
+}
+
+void CCSPlayer::GiveShield( void )
+{
+#ifdef CS_SHIELD_ENABLED
+	m_bHasShield = true;
+	m_bShieldDrawn = false;
+
+	if ( HasSecondaryWeapon() )
+	{
+		CBaseCombatWeapon *pWeapon = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+		pWeapon->SetModel( pWeapon->GetViewModel() );
+		pWeapon->Deploy();
+	}
+
+	CBaseViewModel *pVM = GetViewModel( 1 );
+
+	if ( pVM )
+	{
+		ShowViewModel( true );
+		pVM->RemoveEffects( EF_NODRAW );
+		pVM->SetWeaponModel( SHIELD_VIEW_MODEL, GetActiveWeapon() );
+		pVM->SendViewModelMatchingSequence( 1 );
+	}
+#endif
+}
+
+void CCSPlayer::RemoveShield( void )
+{
+#ifdef CS_SHIELD_ENABLED
+	m_bHasShield = false;
+
+	CBaseViewModel *pVM = GetViewModel( 1 );
+
+	if ( pVM )
+	{
+		pVM->AddEffects( EF_NODRAW );
+	}
+#endif
+}
+
+void CCSPlayer::RemoveAllItems( bool removeSuit )
+{
+	if( HasDefuser() )
+	{
+		RemoveDefuser();
+	}
+
+	if ( HasShield() )
+	{
+		RemoveShield();
+	}
+
+	m_bHasNightVision = false;
+	m_bNightVisionOn = false;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [dwenger] Added for fun-fact support
+	//=============================================================================
+
+	m_bPickedUpDefuser = false;
+	m_bDefusedWithPickedUpKit = false;
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	if ( removeSuit )
+	{
+		m_bHasHelmet = false;
+		SetArmorValue( 0 );
+	}
+
+	BaseClass::RemoveAllItems( removeSuit );
+}
+
+void CCSPlayer::ObserverRoundRespawn()
+{
+	ClearFlashbangScreenFade();
+
+	// did we change our name last round?
+	if ( m_szNewName[0] != 0 )
+	{
+		// ... and force the name change now.  After this happens, the gamerules will get
+		// a ClientSettingsChanged callback from the above ClientCommand, but the name
+		// matches what we're setting here, so it will do nothing.
+		ChangeName( m_szNewName );
+		m_szNewName[0] = 0;
+	}
+}
+
+void CCSPlayer::RoundRespawn()
+{
+	//MIKETODO: menus
+	//if ( m_iMenu != Menu_ChooseAppearance )
+	{
+		// Put them back into the game.
+		StopObserverMode();
+		State_Transition( STATE_ACTIVE );
+		respawn( this, false );
+		m_nButtons = 0;
+		SetNextThink( TICK_NEVER_THINK );
+	}
+
+	m_receivesMoneyNextRound = true; // reset this variable so they can receive their cash next round.
+
+	//If they didn't die, this will print out their damage info
+	OutputDamageGiven();
+	OutputDamageTaken();
+	ResetDamageCounters();
+}
+
+void CCSPlayer::CheckTKPunishment( void )
+{
+	// teamkill punishment..
+	if ( (m_bJustKilledTeammate == true) && mp_tkpunish.GetInt() )
+	{
+		m_bJustKilledTeammate = false;
+		m_bPunishedForTK = true;
+		CommitSuicide();
+	}
+}
+
+CWeaponCSBase* CCSPlayer::GetActiveCSWeapon() const
+{
+	return dynamic_cast< CWeaponCSBase* >( GetActiveWeapon() );
+}
+
+void CCSPlayer::PreThink()
+{
+	BaseClass::PreThink();
+	if ( m_bAutoReload )
+	{
+		m_bAutoReload = false;
+		m_nButtons |= IN_RELOAD;
+	}
+
+	if ( m_afButtonLast != m_nButtons )
+		m_flLastMovement = gpGlobals->curtime;
+
+	if ( g_fGameOver )
+		return;
+
+	State_PreThink();
+
+	if ( m_pHintMessageQueue )
+		m_pHintMessageQueue->Update();
+
+	//Reset bullet force accumulator, only lasts one frame
+	m_vecTotalBulletForce = vec3_origin;
+
+	if ( mp_autokick.GetBool() && !IsBot() && !IsHLTV() && !IsAutoKickDisabled() )
+	{
+		if ( m_flLastMovement + CSGameRules()->GetRoundLength()*2 < gpGlobals->curtime )
+		{
+			UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "#Game_idle_kick", GetPlayerName() );
+			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", GetUserID() ) );
+			m_flLastMovement = gpGlobals->curtime;
+		}
+	}
+#ifndef _XBOX
+	// CS would like their players to continue to update their LastArea since it is displayed in the hud voice chat UI
+	// But we won't do the population tracking while dead.
+	CNavArea *area = TheNavMesh->GetNavArea( GetAbsOrigin(), 1000 );
+	if (area && area != m_lastNavArea)
+	{
+		m_lastNavArea = area;
+		if ( area->GetPlace() != UNDEFINED_PLACE )
+		{
+			const char *placeName = TheNavMesh->PlaceToName( area->GetPlace() );
+			if ( placeName && *placeName )
+			{
+				Q_strncpy( m_szLastPlaceName.GetForModify(), placeName, MAX_PLACE_NAME_LENGTH );
+			}
+		}
+	}
+#endif
+}
+
+void CCSPlayer::MoveToNextIntroCamera()
+{
+	m_pIntroCamera = gEntList.FindEntityByClassname( m_pIntroCamera, "point_viewcontrol" );
+
+	// if m_pIntroCamera is NULL we just were at end of list, start searching from start again
+	if(!m_pIntroCamera)
+		m_pIntroCamera = gEntList.FindEntityByClassname(m_pIntroCamera, "point_viewcontrol");
+
+	// find the target
+	CBaseEntity *Target = NULL;
+
+	if( m_pIntroCamera )
+	{
+		Target = gEntList.FindEntityByName( NULL, STRING(m_pIntroCamera->m_target) );
+	}
+
+	// if we still couldn't find a camera, goto T spawn
+	if(!m_pIntroCamera)
+		m_pIntroCamera = gEntList.FindEntityByClassname(m_pIntroCamera, "info_player_terrorist");
+
+	SetViewOffset( vec3_origin );	// no view offset
+	UTIL_SetSize( this, vec3_origin, vec3_origin ); // no bbox
+
+	if( !Target ) //if there are no cameras(or the camera has no target, find a spawn point and black out the screen
+	{
+		if ( m_pIntroCamera.IsValid() )
+			SetAbsOrigin( m_pIntroCamera->GetAbsOrigin() + VEC_VIEW );
+
+		SetAbsAngles( QAngle( 0, 0, 0 ) );
+
+		m_pIntroCamera = NULL;  // never update again
+		return;
+	}
+
+
+	Vector vCamera = Target->GetAbsOrigin() - m_pIntroCamera->GetAbsOrigin();
+	Vector vIntroCamera = m_pIntroCamera->GetAbsOrigin();
+
+	VectorNormalize( vCamera );
+
+	QAngle CamAngles;
+	VectorAngles( vCamera, CamAngles );
+
+	SetAbsOrigin( vIntroCamera );
+	SetAbsAngles( CamAngles );
+	SnapEyeAngles( CamAngles );
+	m_fIntroCamTime = gpGlobals->curtime + 6;
+}
+
+class NotVIP
+{
+public:
+	bool operator()( CBasePlayer *player )
+	{
+		CCSPlayer *csPlayer = static_cast< CCSPlayer * >(player);
+		csPlayer->MakeVIP( false );
+
+		return true;
+	}
+};
+
+// Expose the VIP selection to plugins, since we don't have an official VIP mode.  This
+// allows plugins to access the (limited) VIP functionality already present (scoreboard
+// identification and radar color).
+CON_COMMAND( cs_make_vip, "Marks a player as the VIP" )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	if ( args.ArgC() != 2 )
+	{
+		return;
+	}
+
+	CCSPlayer *player = static_cast< CCSPlayer * >(UTIL_PlayerByIndex( atoi( args[1] ) ));
+	if ( !player )
+	{
+		// Invalid value clears out VIP
+		NotVIP notVIP;
+		ForEachPlayer( notVIP );
+		return;
+	}
+
+	player->MakeVIP( true );
+}
+
+void CCSPlayer::MakeVIP( bool isVIP )
+{
+	if ( isVIP )
+	{
+		NotVIP notVIP;
+		ForEachPlayer( notVIP );
+	}
+	m_isVIP = isVIP;
+}
+
+bool CCSPlayer::IsVIP() const
+{
+	return m_isVIP;
+}
+
+void CCSPlayer::DropShield( void )
+{
+#ifdef CS_SHIELD_ENABLED
+	//Drop an item_defuser
+	Vector vForward, vRight;
+	AngleVectors( GetAbsAngles(), &vForward, &vRight, NULL );
+
+	RemoveShield();
+
+	CBaseAnimating *pShield = (CBaseAnimating *)CBaseEntity::Create( "item_shield", WorldSpaceCenter(), GetLocalAngles() );
+	pShield->ApplyAbsVelocityImpulse( vForward * 200 + vRight * random->RandomFloat( -50, 50 ) );
+
+	CBaseCombatWeapon *pActive = GetActiveWeapon();
+
+	if ( pActive )
+	{
+		pActive->Deploy();
+	}
+#endif
+}
+
+void CCSPlayer::SetShieldDrawnState( bool bState )
+{
+#ifdef CS_SHIELD_ENABLED
+	m_bShieldDrawn = bState;
+#endif
+}
+
+bool CCSPlayer::CSWeaponDrop( CBaseCombatWeapon *pWeapon, bool bDropShield, bool bThrowForward )
+{
+	bool bSuccess = false;
+
+	if ( HasShield() && bDropShield == true )
+	{
+		DropShield();
+		return true;
+	}
+
+	if ( pWeapon )
+	{
+		Vector vForward;
+
+		AngleVectors( EyeAngles(), &vForward, NULL, NULL );
+		//GetVectors( &vForward, NULL, NULL );
+		Vector vTossPos = WorldSpaceCenter();
+
+		if( bThrowForward )
+			vTossPos = vTossPos + vForward * 64;
+
+		Weapon_Drop( pWeapon, &vTossPos, NULL );
+
+		pWeapon->SetSolidFlags( FSOLID_NOT_STANDABLE | FSOLID_TRIGGER | FSOLID_USE_TRIGGER_BOUNDS );
+		pWeapon->SetMoveCollide( MOVECOLLIDE_FLY_BOUNCE );
+
+		CWeaponCSBase *pCSWeapon = dynamic_cast< CWeaponCSBase* >( pWeapon );
+
+		if( pCSWeapon )
+		{
+			pCSWeapon->SetWeaponModelIndex( pCSWeapon->GetCSWpnData().szWorldModel );
+
+			//Find out the index of the ammo type
+			int iAmmoIndex = pCSWeapon->GetPrimaryAmmoType();
+
+			//If it has an ammo type, find out how much the player has
+			if( iAmmoIndex != -1 )
+			{
+				// Check to make sure we don't have other weapons using this ammo type
+				bool bAmmoTypeInUse = false;
+				if ( IsAlive() && GetHealth() > 0 )
+				{
+					for ( int i=0; i<MAX_WEAPONS; ++i )
+					{
+						CBaseCombatWeapon *pOtherWeapon = GetWeapon(i);
+						if ( pOtherWeapon && pOtherWeapon != pWeapon && pOtherWeapon->GetPrimaryAmmoType() == iAmmoIndex )
+						{
+							bAmmoTypeInUse = true;
+							break;
+						}
+					}
+				}
+
+				if ( !bAmmoTypeInUse )
+				{
+					int iAmmoToDrop = GetAmmoCount( iAmmoIndex );
+
+					//Add this much to the dropped weapon
+					pCSWeapon->SetExtraAmmoCount( iAmmoToDrop );
+
+					//Remove all ammo of this type from the player
+					SetAmmoCount( 0, iAmmoIndex );
+				}
+			}
+		}
+
+		//=========================================
+		// Teleport the weapon to the player's hand
+		//=========================================
+		int iBIndex = -1;
+		int iWeaponBoneIndex = -1;
+
+		MDLCACHE_CRITICAL_SECTION();
+		CStudioHdr *hdr = pWeapon->GetModelPtr();
+		// If I have a hand, set the weapon position to my hand bone position.
+		if ( hdr && hdr->numbones() > 0 )
+		{
+			// Assume bone zero is the root
+			for ( iWeaponBoneIndex = 0; iWeaponBoneIndex < hdr->numbones(); ++iWeaponBoneIndex )
+			{
+				iBIndex = LookupBone( hdr->pBone( iWeaponBoneIndex )->pszName() );
+				// Found one!
+				if ( iBIndex != -1 )
+				{
+					break;
+				}
+			}
+
+			if ( iWeaponBoneIndex == hdr->numbones() )
+				 return true;
+
+			if ( iBIndex == -1 )
+			{
+				iBIndex = LookupBone( "ValveBiped.Bip01_R_Hand" );
+			}
+		}
+		else
+		{
+			iBIndex = LookupBone( "ValveBiped.Bip01_R_Hand" );
+		}
+
+		if ( iBIndex != -1)
+		{
+			Vector origin;
+			QAngle angles;
+			matrix3x4_t transform;
+
+			// Get the transform for the weapon bonetoworldspace in the NPC
+			GetBoneTransform( iBIndex, transform );
+
+			// find offset of root bone from origin in local space
+			// Make sure we're detached from hierarchy before doing this!!!
+			pWeapon->StopFollowingEntity();
+			pWeapon->SetAbsOrigin( Vector( 0, 0, 0 ) );
+			pWeapon->SetAbsAngles( QAngle( 0, 0, 0 ) );
+			pWeapon->InvalidateBoneCache();
+			matrix3x4_t rootLocal;
+			pWeapon->GetBoneTransform( iWeaponBoneIndex, rootLocal );
+
+			// invert it
+			matrix3x4_t rootInvLocal;
+			MatrixInvert( rootLocal, rootInvLocal );
+
+			matrix3x4_t weaponMatrix;
+			ConcatTransforms( transform, rootInvLocal, weaponMatrix );
+			MatrixAngles( weaponMatrix, angles, origin );
+
+			pWeapon->Teleport( &origin, &angles, NULL );
+
+			//Have to teleport the physics object as well
+
+			IPhysicsObject *pWeaponPhys = pWeapon->VPhysicsGetObject();
+
+			if( pWeaponPhys )
+			{
+				Vector vPos;
+				QAngle vAngles;
+				pWeaponPhys->GetPosition( &vPos, &vAngles );
+				pWeaponPhys->SetPosition( vPos, angles, true );
+
+				AngularImpulse	angImp(0,0,0);
+				Vector vecAdd = GetAbsVelocity();
+				pWeaponPhys->AddVelocity( &vecAdd, &angImp );
+			}
+		}
+
+		bSuccess = true;
+	}
+
+	return bSuccess;
+}
+
+
+bool CCSPlayer::DropRifle( bool fromDeath )
+{
+	bool bSuccess = false;
+
+	CBaseCombatWeapon *pWeapon = Weapon_GetSlot( WEAPON_SLOT_RIFLE );
+	if ( pWeapon )
+	{
+		bSuccess = CSWeaponDrop( pWeapon, false );
+	}
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Add the dropped weapon to the dropped equipment list
+	//=============================================================================
+	if( fromDeath && bSuccess )
+	{
+		m_hDroppedEquipment[DROPPED_WEAPON] = static_cast<CBaseEntity *>(pWeapon);
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	return bSuccess;
+}
+
+
+bool CCSPlayer::DropPistol( bool fromDeath )
+{
+	bool bSuccess = false;
+
+	CBaseCombatWeapon *pWeapon = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+	if ( pWeapon )
+	{
+		bSuccess = CSWeaponDrop( pWeapon, false );
+		m_bUsingDefaultPistol = false;
+	}
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Add the dropped weapon to the dropped equipment list
+	//=============================================================================
+	if( fromDeath && bSuccess )
+	{
+		m_hDroppedEquipment[DROPPED_WEAPON] = static_cast<CBaseEntity *>(pWeapon);
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	return bSuccess;
+}
+
+bool CCSPlayer::HasPrimaryWeapon( void )
+{
+	bool bSuccess = false;
+
+	CBaseCombatWeapon *pWeapon = Weapon_GetSlot( WEAPON_SLOT_RIFLE );
+
+	if ( pWeapon )
+	{
+		bSuccess = true;
+	}
+
+	return bSuccess;
+}
+
+
+bool CCSPlayer::HasSecondaryWeapon( void )
+{
+	bool bSuccess = false;
+
+	CBaseCombatWeapon *pWeapon = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+	if ( pWeapon )
+	{
+		bSuccess = true;
+	}
+
+	return bSuccess;
+}
+
+bool CCSPlayer::IsInBuyZone()
+{
+	return m_bInBuyZone && !IsVIP();
+}
+
+bool CCSPlayer::CanPlayerBuy( bool display )
+{
+	// is the player in a buy zone?
+	if ( !IsInBuyZone() )
+	{
+		return false;
+	}
+
+	CCSGameRules* mp = CSGameRules();
+
+	// is the player alive?
+	if ( m_lifeState != LIFE_ALIVE )
+	{
+		return false;
+	}
+
+	int buyTime = (int)(mp_buytime.GetFloat() * 60);
+
+	if ( mp->IsBuyTimeElapsed() )
+	{
+		if ( display == true )
+		{
+			char strBuyTime[16];
+			Q_snprintf( strBuyTime, sizeof( strBuyTime ), "%d", buyTime );
+			ClientPrint( this, HUD_PRINTCENTER, "#Cant_buy", strBuyTime );
+		}
+
+		return false;
+	}
+
+	if ( m_bIsVIP )
+	{
+		if ( display == true )
+			ClientPrint( this, HUD_PRINTCENTER, "#VIP_cant_buy" );
+
+		return false;
+	}
+
+	if ( mp->m_bCTCantBuy && ( GetTeamNumber() == TEAM_CT ) )
+	{
+		if ( display == true )
+			ClientPrint( this, HUD_PRINTCENTER, "#CT_cant_buy" );
+
+		return false;
+	}
+
+	if ( mp->m_bTCantBuy && ( GetTeamNumber() == TEAM_TERRORIST ) )
+	{
+		if ( display == true )
+			ClientPrint( this, HUD_PRINTCENTER, "#Terrorist_cant_buy" );
+
+		return false;
+	}
+
+	return true;
+}
+
+
+BuyResult_e CCSPlayer::AttemptToBuyVest( void )
+{
+	int iKevlarPrice = KEVLAR_PRICE;
+
+	if ( CSGameRules()->IsBlackMarket() )
+	{
+		iKevlarPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
+	}
+
+	if ( ArmorValue() >= 100 )
+	{
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Already_Have_Kevlar" );
+		return BUY_ALREADY_HAVE;
+	}
+	else if ( m_iAccount < iKevlarPrice )
+	{
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Not_Enough_Money" );
+		return BUY_CANT_AFFORD;
+	}
+	else
+	{
+		if ( m_bHasHelmet )
+		{
+			if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+				ClientPrint( this, HUD_PRINTCENTER, "#Already_Have_Helmet_Bought_Kevlar" );
+		}
+
+		IGameEvent * event = gameeventmanager->CreateEvent( "item_pickup" );
+		if( event )
+		{
+			event->SetInt( "userid", GetUserID() );
+			event->SetString( "item", "vest" );
+			gameeventmanager->FireEvent( event );
+		}
+
+		GiveNamedItem( "item_kevlar" );
+		AddAccount( -iKevlarPrice, true, true, "item_kevlar" );
+		BlackMarketAddWeapon( "item_kevlar", this );
+		return BUY_BOUGHT;
+	}
+}
+
+
+BuyResult_e CCSPlayer::AttemptToBuyAssaultSuit( void )
+{
+	// WARNING: This price logic also exists in C_CSPlayer::GetCurrentAssaultSuitPrice
+	// and must be kept in sync if changes are made.
+
+	int fullArmor = ArmorValue() >= 100 ? 1 : 0;
+
+	int price = 0, enoughMoney = 0;
+
+	int iHelmetPrice = HELMET_PRICE;
+	int iKevlarPrice = KEVLAR_PRICE;
+	int iAssaultSuitPrice = ASSAULTSUIT_PRICE;
+
+	if ( CSGameRules()->IsBlackMarket() )
+	{
+		iKevlarPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR );
+		iAssaultSuitPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_ASSAULTSUIT );
+
+		iHelmetPrice = iAssaultSuitPrice - iKevlarPrice;
+	}
+
+	if ( fullArmor && m_bHasHelmet )
+	{
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Already_Have_Kevlar_Helmet" );
+		return BUY_ALREADY_HAVE;
+	}
+	else if ( fullArmor && !m_bHasHelmet && m_iAccount >= iHelmetPrice )
+	{
+		enoughMoney = 1;
+		price = iHelmetPrice;
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Already_Have_Kevlar_Bought_Helmet" );
+	}
+	else if ( !fullArmor && m_bHasHelmet && m_iAccount >= iKevlarPrice )
+	{
+		enoughMoney = 1;
+		price = iKevlarPrice;
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Already_Have_Helmet_Bought_Kevlar" );
+	}
+	else if ( m_iAccount >= iAssaultSuitPrice )
+	{
+		enoughMoney = 1;
+		price = iAssaultSuitPrice;
+	}
+
+	// process the result
+	if ( !enoughMoney )
+	{
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Not_Enough_Money" );
+		return BUY_CANT_AFFORD;
+	}
+	else
+	{
+		IGameEvent * event = gameeventmanager->CreateEvent( "item_pickup" );
+		if( event )
+		{
+			event->SetInt( "userid", GetUserID() );
+			event->SetString( "item", "vesthelm" );
+			gameeventmanager->FireEvent( event );
+		}
+
+		GiveNamedItem( "item_assaultsuit" );
+		AddAccount( -price, true, true, "item_assaultsuit" );
+		BlackMarketAddWeapon( "item_assaultsuit", this );
+		return BUY_BOUGHT;
+	}
+}
+
+BuyResult_e CCSPlayer::AttemptToBuyShield( void )
+{
+#ifdef CS_SHIELD_ENABLED
+	if ( HasShield() )		// prevent this guy from buying more than 1 Defuse Kit
+	{
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Already_Have_One" );
+		return BUY_ALREADY_HAVE;
+	}
+	else if ( m_iAccount < SHIELD_PRICE )
+	{
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Not_Enough_Money" );
+		return BUY_CANT_AFFORD;
+	}
+	else
+	{
+		if ( HasSecondaryWeapon() )
+		{
+			CBaseCombatWeapon *pWeapon = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+			CWeaponCSBase *pCSWeapon = dynamic_cast< CWeaponCSBase* >( pWeapon );
+
+			if ( pCSWeapon && pCSWeapon->GetCSWpnData().m_bCanUseWithShield == false )
+				 return;
+		}
+
+		if ( HasPrimaryWeapon() )
+			 DropRifle();
+
+		GiveShield();
+
+		CPASAttenuationFilter filter( this, "Player.PickupWeapon" );
+		EmitSound( filter, entindex(), "Player.PickupWeapon" );
+
+		m_bAnythingBought = true;
+		AddAccount( -SHIELD_PRICE, true, true, "item_shield" );
+		return BUY_BOUGHT;
+	}
+#else
+	ClientPrint( this, HUD_PRINTCENTER, "Tactical shield disabled" );
+	return BUY_NOT_ALLOWED;
+#endif
+}
+
+BuyResult_e CCSPlayer::AttemptToBuyDefuser( void )
+{
+	CCSGameRules *MPRules = CSGameRules();
+
+	if( ( GetTeamNumber() == TEAM_CT ) && MPRules->IsBombDefuseMap() )
+	{
+		if ( HasDefuser() )		// prevent this guy from buying more than 1 Defuse Kit
+		{
+			if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+				ClientPrint( this, HUD_PRINTCENTER, "#Already_Have_One" );
+			return BUY_ALREADY_HAVE;
+		}
+		else if ( m_iAccount < DEFUSEKIT_PRICE )
+		{
+			if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+				ClientPrint( this, HUD_PRINTCENTER, "#Not_Enough_Money" );
+			return BUY_CANT_AFFORD;
+		}
+		else
+		{
+			GiveDefuser();
+
+			CPASAttenuationFilter filter( this, "Player.PickupWeapon" );
+			EmitSound( filter, entindex(), "Player.PickupWeapon" );
+
+			AddAccount( -DEFUSEKIT_PRICE, true, true, "item_defuser" );
+			return BUY_BOUGHT;
+		}
+	}
+
+	return BUY_NOT_ALLOWED;
+}
+
+BuyResult_e CCSPlayer::AttemptToBuyNightVision( void )
+{
+	int iNVGPrice = NVG_PRICE;
+
+	if ( CSGameRules()->IsBlackMarket() )
+	{
+		iNVGPrice = CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_NVG );
+	}
+
+	if ( m_bHasNightVision == TRUE )
+	{
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Already_Have_One" );
+		return BUY_ALREADY_HAVE;
+	}
+	else if ( m_iAccount < iNVGPrice )
+	{
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+			ClientPrint( this, HUD_PRINTCENTER, "#Not_Enough_Money" );
+		return BUY_CANT_AFFORD;
+	}
+	else
+	{
+		IGameEvent * event = gameeventmanager->CreateEvent( "item_pickup" );
+		if( event )
+		{
+			event->SetInt( "userid", GetUserID() );
+			event->SetString( "item", "nvgs" );
+			gameeventmanager->FireEvent( event );
+		}
+
+		GiveNamedItem( "item_nvgs" );
+		AddAccount( -iNVGPrice, true, true );
+		BlackMarketAddWeapon( "nightvision", this );
+
+		if ( !(m_iDisplayHistoryBits & DHF_NIGHTVISION) )
+		{
+			HintMessage( "#Hint_use_nightvision", false );
+			m_iDisplayHistoryBits |= DHF_NIGHTVISION;
+		}
+		return BUY_BOUGHT;
+	}
+}
+
+
+// Handles the special "buy" alias commands we're creating to accommodate the buy
+// scripts players use (now that we've rearranged the buy menus and broken the scripts)
+//=============================================================================
+// HPE_BEGIN:
+//[tj]  This is essentially a shim so I can easily check the return
+//      value without adding new code to all the return points.
+//=============================================================================
+
+BuyResult_e CCSPlayer::HandleCommand_Buy( const char *item )
+{    
+	BuyResult_e result = HandleCommand_Buy_Internal(item);
+	if (result == BUY_BOUGHT)
+	{
+		m_bMadePurchseThisRound = true;
+		CCS_GameStats.IncrementStat(this, CSSTAT_ITEMS_PURCHASED, 1);
+	}
+	return result;
+}
+
+BuyResult_e CCSPlayer::HandleCommand_Buy_Internal( const char* wpnName ) 
+//=============================================================================
+// HPE_END
+//=============================================================================
+{
+	BuyResult_e result = CanPlayerBuy( false ) ? BUY_PLAYER_CANT_BUY : BUY_INVALID_ITEM; // set some defaults
+
+	// translate the new weapon names to the old ones that are actually being used.
+	wpnName = GetTranslatedWeaponAlias(wpnName);
+
+	CCSWeaponInfo *pWeaponInfo = GetWeaponInfo( AliasToWeaponID( wpnName ) );
+	if ( pWeaponInfo == NULL )
+	{
+		if ( Q_stricmp( wpnName, "primammo" ) == 0 )
+		{
+			result = AttemptToBuyAmmo( 0 );
+		}
+		else if ( Q_stricmp( wpnName, "secammo" ) == 0 )
+		{
+			result = AttemptToBuyAmmo( 1 );
+		}
+		else if ( Q_stristr( wpnName, "defuser" )  )
+		{
+			if( CanPlayerBuy( true ) )
+			{
+				result = AttemptToBuyDefuser();
+			}
+		}
+	}
+	else
+	{
+
+		if( !CanPlayerBuy( true ) )
+		{
+			return BUY_PLAYER_CANT_BUY;
+		}
+
+		BuyResult_e equipResult = BUY_INVALID_ITEM;
+
+		if ( Q_stristr( wpnName, "kevlar" ) )
+		{
+			equipResult = AttemptToBuyVest();
+		}
+		else if ( Q_stristr( wpnName, "assaultsuit" ) )
+		{
+			equipResult = AttemptToBuyAssaultSuit();
+		}
+		else if ( Q_stristr( wpnName, "shield" ) )
+		{
+			equipResult = AttemptToBuyShield();
+		}
+		else if ( Q_stristr( wpnName, "nightvision" )  )
+		{
+			equipResult = AttemptToBuyNightVision();
+		}
+
+		if ( equipResult != BUY_INVALID_ITEM )
+		{
+			if ( equipResult == BUY_BOUGHT )
+			{
+				BuildRebuyStruct();
+			}
+			return equipResult; // intentional early return here
+		}
+
+		bool bPurchase = false;
+
+		// MIKETODO: assasination maps have a specific set of weapons that can be used in them.
+		if ( pWeaponInfo->m_iTeam != TEAM_UNASSIGNED && GetTeamNumber() != pWeaponInfo->m_iTeam )
+		{
+			result = BUY_NOT_ALLOWED;
+			if ( pWeaponInfo->m_WrongTeamMsg[0] != 0 )
+			{
+				ClientPrint( this, HUD_PRINTCENTER, "#Alias_Not_Avail", pWeaponInfo->m_WrongTeamMsg );
+			}
+		}
+		else if ( pWeaponInfo->GetWeaponPrice() <= 0 )
+		{
+			// ClientPrint( this, HUD_PRINTCENTER, "#Cant_buy_this_item", pWeaponInfo->m_WrongTeamMsg );
+		}
+		else if( pWeaponInfo->m_WeaponType == WEAPONTYPE_GRENADE )
+		{
+			// make sure the player can afford this item.
+			if ( m_iAccount >= pWeaponInfo->GetWeaponPrice() )
+			{
+				bPurchase = true;
+
+				const char *szWeaponName = NULL;
+				int ammoMax = 0;
+				if ( Q_strstr( pWeaponInfo->szClassName, "flashbang" ) )
+				{
+					szWeaponName = "weapon_flashbang";
+					ammoMax = ammo_flashbang_max.GetInt();
+				}
+				else if ( Q_strstr( pWeaponInfo->szClassName, "hegrenade" ) )
+				{
+					szWeaponName = "weapon_hegrenade";
+					ammoMax = ammo_hegrenade_max.GetInt();
+				}
+				else if ( Q_strstr( pWeaponInfo->szClassName, "smokegrenade" ) )
+				{
+					szWeaponName = "weapon_smokegrenade";
+					ammoMax = ammo_smokegrenade_max.GetInt();
+				}
+
+				if ( szWeaponName != NULL )
+				{
+					CBaseCombatWeapon* pGrenadeWeapon = Weapon_OwnsThisType( szWeaponName );
+					{
+						if ( pGrenadeWeapon != NULL )
+						{
+							int nAmmoType = pGrenadeWeapon->GetPrimaryAmmoType();
+
+							if( nAmmoType != -1 )
+							{
+								if( GetAmmoCount(nAmmoType) >= ammoMax )
+								{
+									result = BUY_ALREADY_HAVE;
+									if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+										ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Carry_Anymore" );
+									bPurchase = false;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		else if ( !Weapon_OwnsThisType( pWeaponInfo->szClassName ) )	//don't buy duplicate weapons
+		{
+			// do they have enough money?
+			if ( m_iAccount >= pWeaponInfo->GetWeaponPrice() )
+			{
+				if ( m_lifeState != LIFE_DEAD )
+				{
+					if ( pWeaponInfo->iSlot == WEAPON_SLOT_PISTOL )
+					{
+						DropPistol();
+					}
+					else if ( pWeaponInfo->iSlot == WEAPON_SLOT_RIFLE )
+					{
+						DropRifle();
+					}
+				}
+
+				bPurchase = true;
+			}
+			else
+			{
+				result = BUY_CANT_AFFORD;
+				if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+					ClientPrint( this, HUD_PRINTCENTER, "#Not_Enough_Money" );
+			}
+		}
+		else
+		{
+			result = BUY_ALREADY_HAVE;
+		}
+
+		if ( HasShield() )
+		{
+			if ( pWeaponInfo->m_bCanUseWithShield == false )
+			{
+				result = BUY_NOT_ALLOWED;
+				bPurchase = false;
+			}
+		}
+
+		if( bPurchase )
+		{
+			result = BUY_BOUGHT;
+
+			if ( bPurchase && pWeaponInfo->iSlot == WEAPON_SLOT_PISTOL )
+				m_bUsingDefaultPistol = false;
+
+			GiveNamedItem( pWeaponInfo->szClassName );
+            AddAccount( -pWeaponInfo->GetWeaponPrice(), true, true, pWeaponInfo->szClassName );
+			BlackMarketAddWeapon( wpnName, this );
+		}
+	}
+
+	if ( result == BUY_BOUGHT )
+	{
+		BuildRebuyStruct();
+	}
+
+	return result;
+}
+
+
+BuyResult_e CCSPlayer::BuyGunAmmo( CBaseCombatWeapon *pWeapon, bool bBlinkMoney )
+{
+	if ( !CanPlayerBuy( false ) )
+	{
+		return BUY_PLAYER_CANT_BUY;
+	}
+
+	// Ensure that the weapon uses ammo
+	int nAmmo = pWeapon->GetPrimaryAmmoType();
+	if ( nAmmo == -1 )
+	{
+		return BUY_ALREADY_HAVE;
+	}
+
+	// Can only buy if the player does not already have full ammo
+	if ( GetAmmoCount( nAmmo ) >= GetAmmoDef()->MaxCarry( nAmmo ) )
+	{
+		return BUY_ALREADY_HAVE;
+	}
+
+	// Purchase the ammo if the player has enough money
+	if ( m_iAccount >= GetCSAmmoDef()->GetCost( nAmmo ) )
+	{
+		GiveAmmo( GetCSAmmoDef()->GetBuySize( nAmmo ), nAmmo, true );
+		AddAccount( -GetCSAmmoDef()->GetCost( nAmmo ), true, true, GetCSAmmoDef()->GetAmmoOfIndex( nAmmo )->pName  );
+		return BUY_BOUGHT;
+	}
+
+	if ( bBlinkMoney )
+	{
+		// Not enough money.. let the player know
+		if( !m_bIsInAutoBuy && !m_bIsInRebuy )
+					ClientPrint( this, HUD_PRINTCENTER, "#Not_Enough_Money" );
+	}
+
+	return BUY_CANT_AFFORD;
+}
+
+
+BuyResult_e CCSPlayer::BuyAmmo( int nSlot, bool bBlinkMoney )
+{
+	if ( !CanPlayerBuy( false ) )
+	{
+		return BUY_PLAYER_CANT_BUY;
+	}
+
+	if ( nSlot < 0 || nSlot > 1 )
+	{
+		return BUY_INVALID_ITEM;
+	}
+
+	// Buy one ammo clip for all weapons in the given slot
+	//
+	//  nSlot == 1 : Primary weapons
+	//  nSlot == 2 : Secondary weapons
+
+	CBaseCombatWeapon *pSlot = Weapon_GetSlot( nSlot );
+	if ( !pSlot )
+		return BUY_INVALID_ITEM;
+
+	//MIKETODO: shield.
+	//if ( player->HasShield() && player->m_rgpPlayerItems[2] )
+	//	 pItem = player->m_rgpPlayerItems[2];
+
+	return BuyGunAmmo( pSlot, bBlinkMoney );
+}
+
+
+BuyResult_e CCSPlayer::AttemptToBuyAmmo( int iAmmoType )
+{
+	Assert( iAmmoType == 0 || iAmmoType == 1 );
+
+	BuyResult_e result = BuyAmmo( iAmmoType, true );
+
+	if ( result == BUY_BOUGHT )
+	{
+		while ( BuyAmmo( iAmmoType, false ) == BUY_BOUGHT )
+		{
+			// empty loop - keep buying
+		}
+
+		return BUY_BOUGHT;
+	}
+
+	return result;
+}
+
+BuyResult_e CCSPlayer::AttemptToBuyAmmoSingle( int iAmmoType )
+{
+	Assert( iAmmoType == 0 || iAmmoType == 1 );
+
+	BuyResult_e result = BuyAmmo( iAmmoType, true );
+
+	if ( result == BUY_BOUGHT )
+	{
+		BuildRebuyStruct();
+	}
+
+	return result;
+}
+
+const char *RadioEventName[ RADIO_NUM_EVENTS+1 ] =
+{
+	"RADIO_INVALID",
+
+	"EVENT_START_RADIO_1",
+
+	"EVENT_RADIO_COVER_ME",
+	"EVENT_RADIO_YOU_TAKE_THE_POINT",
+	"EVENT_RADIO_HOLD_THIS_POSITION",
+	"EVENT_RADIO_REGROUP_TEAM",
+	"EVENT_RADIO_FOLLOW_ME",
+	"EVENT_RADIO_TAKING_FIRE",
+
+	"EVENT_START_RADIO_2",
+
+	"EVENT_RADIO_GO_GO_GO",
+	"EVENT_RADIO_TEAM_FALL_BACK",
+	"EVENT_RADIO_STICK_TOGETHER_TEAM",
+	"EVENT_RADIO_GET_IN_POSITION_AND_WAIT",
+	"EVENT_RADIO_STORM_THE_FRONT",
+	"EVENT_RADIO_REPORT_IN_TEAM",
+
+	"EVENT_START_RADIO_3",
+
+	"EVENT_RADIO_AFFIRMATIVE",
+	"EVENT_RADIO_ENEMY_SPOTTED",
+	"EVENT_RADIO_NEED_BACKUP",
+	"EVENT_RADIO_SECTOR_CLEAR",
+	"EVENT_RADIO_IN_POSITION",
+	"EVENT_RADIO_REPORTING_IN",
+	"EVENT_RADIO_GET_OUT_OF_THERE",
+	"EVENT_RADIO_NEGATIVE",
+	"EVENT_RADIO_ENEMY_DOWN",
+
+	"EVENT_RADIO_END",
+
+	NULL		// must be NULL-terminated
+};
+
+
+/**
+ * Convert name to RadioType
+ */
+RadioType NameToRadioEvent( const char *name )
+{
+	for( int i=0; RadioEventName[i]; ++i )
+		if (!stricmp( RadioEventName[i], name ))
+			return static_cast<RadioType>( i );
+
+	return RADIO_INVALID;
+}
+
+
+void CCSPlayer::HandleMenu_Radio1( int slot )
+{
+	if( m_iRadioMessages < 0 )
+		return;
+
+	if( m_flRadioTime > gpGlobals->curtime )
+		return;
+
+	m_iRadioMessages--;
+	m_flRadioTime = gpGlobals->curtime + 1.5;
+
+	switch ( slot )
+	{
+		case 1 :
+			Radio( "Radio.CoverMe",   "#Cstrike_TitlesTXT_Cover_me" );
+			break;
+
+		case 2 :
+			Radio( "Radio.YouTakeThePoint", "#Cstrike_TitlesTXT_You_take_the_point" );
+			break;
+
+		case 3 :
+			Radio( "Radio.HoldPosition",  "#Cstrike_TitlesTXT_Hold_this_position" );
+			break;
+
+		case 4 :
+			Radio( "Radio.Regroup",   "#Cstrike_TitlesTXT_Regroup_team" );
+			break;
+
+		case 5 :
+			Radio( "Radio.FollowMe",  "#Cstrike_TitlesTXT_Follow_me" );
+			break;
+
+		case 6 :
+			Radio( "Radio.TakingFire", "#Cstrike_TitlesTXT_Taking_fire" );
+			break;
+	}
+
+	// tell bots about radio message
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_radio" );
+	if ( event )
+	{
+		event->SetInt("userid", GetUserID() );
+		event->SetInt("slot", RADIO_START_1 + slot );
+		gameeventmanager->FireEvent( event );
+	}
+}
+
+void CCSPlayer::HandleMenu_Radio2( int slot )
+{
+	if( m_iRadioMessages < 0 )
+		return;
+
+	if( m_flRadioTime > gpGlobals->curtime )
+		return;
+
+	m_iRadioMessages--;
+	m_flRadioTime = gpGlobals->curtime + 1.5;
+
+	switch ( slot )
+	{
+		case 1 :
+			Radio( "Radio.GoGoGo",			"#Cstrike_TitlesTXT_Go_go_go" );
+			break;
+
+		case 2 :
+			Radio( "Radio.TeamFallBack",	"#Cstrike_TitlesTXT_Team_fall_back" );
+			break;
+
+		case 3 :
+			Radio( "Radio.StickTogether",	"#Cstrike_TitlesTXT_Stick_together_team" );
+			break;
+
+		case 4 :
+			Radio( "Radio.GetInPosition",   "#Cstrike_TitlesTXT_Get_in_position_and_wait" );
+			break;
+
+		case 5 :
+			Radio( "Radio.StormFront",		"#Cstrike_TitlesTXT_Storm_the_front" );
+			break;
+
+		case 6 :
+			Radio( "Radio.ReportInTeam",	"#Cstrike_TitlesTXT_Report_in_team" );
+			break;
+	}
+
+	// tell bots about radio message
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_radio" );
+	if ( event )
+	{
+		event->SetInt("userid", GetUserID() );
+		event->SetInt("slot", RADIO_START_2 + slot );
+		gameeventmanager->FireEvent( event );
+	}
+}
+
+void CCSPlayer::HandleMenu_Radio3( int slot )
+{
+	if( m_iRadioMessages < 0 )
+		return;
+
+	if( m_flRadioTime > gpGlobals->curtime )
+		return;
+
+	m_iRadioMessages--;
+	m_flRadioTime = gpGlobals->curtime + 1.5;
+
+	switch ( slot )
+	{
+		case 1 :
+			if ( random->RandomInt( 0,1 ) )
+				Radio( "Radio.Affirmitive",	"#Cstrike_TitlesTXT_Affirmative" );
+			else
+				Radio( "Radio.Roger",		"#Cstrike_TitlesTXT_Roger_that" );
+
+			break;
+
+		case 2 :
+			Radio( "Radio.EnemySpotted",	"#Cstrike_TitlesTXT_Enemy_spotted" );
+			break;
+
+		case 3 :
+			Radio( "Radio.NeedBackup",		"#Cstrike_TitlesTXT_Need_backup" );
+			break;
+
+		case 4 :
+			Radio( "Radio.SectorClear",		"#Cstrike_TitlesTXT_Sector_clear" );
+			break;
+
+		case 5 :
+			Radio( "Radio.InPosition",		"#Cstrike_TitlesTXT_In_position" );
+			break;
+
+		case 6 :
+			Radio( "Radio.ReportingIn",		"#Cstrike_TitlesTXT_Reporting_in" );
+			break;
+
+		case 7 :
+			Radio( "Radio.GetOutOfThere",	"#Cstrike_TitlesTXT_Get_out_of_there" );
+			break;
+
+		case 8 :
+			Radio( "Radio.Negative",		"#Cstrike_TitlesTXT_Negative" );
+			break;
+
+		case 9 :
+			Radio( "Radio.EnemyDown",		"#Cstrike_TitlesTXT_Enemy_down" );
+			break;
+	}
+
+	// tell bots about radio message
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_radio" );
+	if ( event )
+	{
+		event->SetInt("userid", GetUserID() );
+		event->SetInt("slot", RADIO_START_3 + slot );
+		gameeventmanager->FireEvent( event );
+	}
+}
+
+void UTIL_CSRadioMessage( IRecipientFilter& filter, int iClient, int msg_dest, const char *msg_name, const char *param1 = NULL, const char *param2 = NULL, const char *param3 = NULL, const char *param4 = NULL )
+{
+	UserMessageBegin( filter, "RadioText" );
+		WRITE_BYTE( msg_dest );
+		WRITE_BYTE( iClient );
+		WRITE_STRING( msg_name );
+
+		if ( param1 )
+			WRITE_STRING( param1 );
+		else
+			WRITE_STRING( "" );
+
+		if ( param2 )
+			WRITE_STRING( param2 );
+		else
+			WRITE_STRING( "" );
+
+		if ( param3 )
+			WRITE_STRING( param3 );
+		else
+			WRITE_STRING( "" );
+
+		if ( param4 )
+			WRITE_STRING( param4 );
+		else
+			WRITE_STRING( "" );
+
+	MessageEnd();
+}
+
+void CCSPlayer::ConstructRadioFilter( CRecipientFilter& filter )
+{
+	filter.MakeReliable();
+
+	int localTeam = GetTeamNumber();
+
+	int i;
+	for ( i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CCSPlayer *player = static_cast<CCSPlayer *>( UTIL_PlayerByIndex( i ) );
+		if ( !player )
+			continue;
+
+		// Skip players ignoring the radio
+		if ( player->m_bIgnoreRadio )
+			continue;
+
+		if( player->GetTeamNumber() == TEAM_SPECTATOR )
+		{
+			// add spectators
+			if( player->m_iObserverMode == OBS_MODE_IN_EYE || player->m_iObserverMode == OBS_MODE_CHASE )
+			{
+				filter.AddRecipient( player );
+			}
+		}
+		else if( player->GetTeamNumber() == localTeam )
+		{
+			// add teammates
+			filter.AddRecipient( player );
+		}
+	}
+}
+
+void CCSPlayer::Radio( const char *pszRadioSound, const char *pszRadioText )
+{
+	if( !IsAlive() )
+		return;
+
+	if ( IsObserver() )
+		return;
+
+	CRecipientFilter filter;
+	ConstructRadioFilter( filter );
+
+	if( pszRadioText )
+	{
+		const char *pszLocationText = CSGameRules()->GetChatLocation( true, this );
+		if ( pszLocationText && *pszLocationText )
+		{
+			UTIL_CSRadioMessage( filter, entindex(), HUD_PRINTTALK, "#Game_radio_location", GetPlayerName(), pszLocationText, pszRadioText );
+		}
+		else
+		{
+			UTIL_CSRadioMessage( filter, entindex(), HUD_PRINTTALK, "#Game_radio", GetPlayerName(), pszRadioText );
+		}
+	}
+
+	UserMessageBegin ( filter, "SendAudio" );
+		WRITE_STRING( pszRadioSound );
+	MessageEnd();
+
+	//icon over the head for teammates
+	TE_RadioIcon( filter, 0.0, this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Outputs currently connected players to the console
+//-----------------------------------------------------------------------------
+void CCSPlayer::ListPlayers()
+{
+	char buf[64];
+	for ( int i=1; i <= gpGlobals->maxClients; i++ )
+	{
+		CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( UTIL_PlayerByIndex( i ) );
+		if ( pPlayer && !pPlayer->IsDormant() )
+		{
+			if ( pPlayer->IsBot() )
+			{
+				Q_snprintf( buf, sizeof(buf), "B %d : %s", pPlayer->GetUserID(), pPlayer->GetPlayerName() );
+			}
+			else
+			{
+				Q_snprintf( buf, sizeof(buf), "  %d : %s", pPlayer->GetUserID(), pPlayer->GetPlayerName() );
+			}
+			ClientPrint( this, HUD_PRINTCONSOLE, buf );
+		}
+	}
+	ClientPrint( this, HUD_PRINTCONSOLE, "\n" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  : &info -
+//-----------------------------------------------------------------------------
+void CCSPlayer::OnDamagedByExplosion( const CTakeDamageInfo &info )
+{
+	float lastDamage = info.GetDamage();
+
+	//Adrian - This is hacky since we might have been damaged by something else
+	//but since the round is ending, who cares.
+	if ( CSGameRules()->m_bTargetBombed == true )
+		 return;
+
+	float distanceFromPlayer = 9999.0f;
+
+	CBaseEntity *inflictor = info.GetInflictor();
+	if ( inflictor )
+	{
+		Vector delta = GetAbsOrigin() - inflictor->GetAbsOrigin();
+		distanceFromPlayer = delta.Length();
+	}
+
+	bool shock = lastDamage >= 30.0f;
+
+	if ( !shock )
+		return;
+
+	m_applyDeafnessTime = gpGlobals->curtime + 0.3;
+	m_currentDeafnessFilter = 0;
+}
+
+void CCSPlayer::ApplyDeafnessEffect()
+{
+	// what's happening here is that the low-pass filter and the oscillator frequency effects need
+	// to fade in and out slowly.  So we have several filters that we switch between to achieve this
+	// effect.  The first 3rd of the total effect will be the "fade in" of the effect.  Which means going
+	// from filter to filter from the first to the last.  Then we keep on the "last" filter for another
+	// third of the total effect time.  Then the last third of the time we go back from the last filter
+	// to the first.  Clear as mud?
+
+	// glossary:
+	//  filter: an individual filter as defined in dsp_presets.txt
+	//  section: one of the sections for the total effect, fade in, full, fade out are the possible sections
+	//  effect: the total effect of combining all the sections, the whole of what the player hears from start to finish.
+
+	const int firstGrenadeFilterIndex = 137;
+	const int lastGrenadeFilterIndex = 139;
+	const float grenadeEffectLengthInSecs = 4.5f; // time of the total effect
+	const float fadeInSectionTime = 0.1f;
+	const float fadeOutSectionTime = 1.5f;
+
+	const float timeForEachFilterInFadeIn = fadeInSectionTime / (lastGrenadeFilterIndex - firstGrenadeFilterIndex);
+	const float timeForEachFilterInFadeOut = fadeOutSectionTime / (lastGrenadeFilterIndex - firstGrenadeFilterIndex);
+
+	float timeIntoEffect = gpGlobals->curtime - m_applyDeafnessTime;
+
+	if (timeIntoEffect >= grenadeEffectLengthInSecs)
+	{
+		// the effect is done, so reset the deafness variables.
+		m_applyDeafnessTime = 0.0f;
+		m_currentDeafnessFilter = 0;
+		return;
+	}
+
+	int section = 0;
+
+	if (timeIntoEffect < fadeInSectionTime)
+	{
+		section = 0;
+	}
+	else if (timeIntoEffect < (grenadeEffectLengthInSecs - fadeOutSectionTime))
+	{
+		section = 1;
+	}
+	else
+	{
+		section = 2;
+	}
+
+	int filterToUse = 0;
+
+	if (section == 0)
+	{
+		// fade into the effect.
+		int filterIndex = (int)(timeIntoEffect / timeForEachFilterInFadeIn);
+		filterToUse = filterIndex += firstGrenadeFilterIndex;
+	}
+	else if (section == 1)
+	{
+		// in full effect.
+		filterToUse = lastGrenadeFilterIndex;
+	}
+	else if (section == 2)
+	{
+		// fade out of the effect
+		float timeIntoSection = timeIntoEffect - (grenadeEffectLengthInSecs - fadeOutSectionTime);
+		int filterIndex = (int)(timeIntoSection / timeForEachFilterInFadeOut);
+		filterToUse = lastGrenadeFilterIndex - filterIndex - 1;
+	}
+
+	if (filterToUse != m_currentDeafnessFilter)
+	{
+		m_currentDeafnessFilter = filterToUse;
+
+		CSingleUserRecipientFilter user( this );
+		enginesound->SetPlayerDSP( user, m_currentDeafnessFilter, false );
+	}
+}
+
+
+void CCSPlayer::NoteWeaponFired()
+{
+	Assert( m_pCurrentCommand );
+	if( m_pCurrentCommand )
+	{
+		m_iLastWeaponFireUsercmd = m_pCurrentCommand->command_number;
+	}
+}
+
+
+bool CCSPlayer::WantsLagCompensationOnEntity( const CBasePlayer *pPlayer, const CUserCmd *pCmd, const CBitVec<MAX_EDICTS> *pEntityTransmitBits ) const
+{
+	// No need to lag compensate at all if we're not attacking in this command and
+	// we haven't attacked recently.
+	if ( !( pCmd->buttons & IN_ATTACK ) && (pCmd->command_number - m_iLastWeaponFireUsercmd > 5) )
+	{
+		if ( ( pCmd->buttons & IN_ATTACK2 ) == 0 )
+			return false;
+
+		CWeaponCSBase *weapon = GetActiveCSWeapon();
+		if ( !weapon )
+			return false;
+
+		if ( weapon->GetWeaponID() != WEAPON_KNIFE )
+			return false;	// IN_ATTACK2 with WEAPON_KNIFE should do lag compensation
+	}
+
+	return BaseClass::WantsLagCompensationOnEntity( pPlayer, pCmd, pEntityTransmitBits );
+}
+
+// Handles the special "radio" alias commands we're creating to accommodate the scripts players use
+// ** Returns true if we've handled the command **
+bool HandleRadioAliasCommands( CCSPlayer *pPlayer, const char *pszCommand )
+{
+	bool bRetVal = false;
+
+	// don't execute them if we are not alive or are an observer
+	if( !pPlayer->IsAlive() || pPlayer->IsObserver() )
+		return false;
+
+	// Radio1 commands
+	if ( FStrEq( pszCommand, "coverme" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio1( 1 );
+	}
+	else if ( FStrEq( pszCommand, "takepoint" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio1( 2 );
+	}
+	else if ( FStrEq( pszCommand, "holdpos" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio1( 3 );
+	}
+	else if ( FStrEq( pszCommand, "regroup" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio1( 4 );
+	}
+	else if ( FStrEq( pszCommand, "followme" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio1( 5 );
+	}
+	else if ( FStrEq( pszCommand, "takingfire" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio1( 6 );
+	}
+	// Radio2 commands
+	else if ( FStrEq( pszCommand, "go" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio2( 1 );
+	}
+	else if ( FStrEq( pszCommand, "fallback" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio2( 2 );
+	}
+	else if ( FStrEq( pszCommand, "sticktog" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio2( 3 );
+	}
+	else if ( FStrEq( pszCommand, "getinpos" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio2( 4 );
+	}
+	else if ( FStrEq( pszCommand, "stormfront" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio2( 5 );
+	}
+	else if ( FStrEq( pszCommand, "report" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio2( 6 );
+	}
+	// Radio3 commands
+	else if ( FStrEq( pszCommand, "roger" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 1 );
+	}
+	else if ( FStrEq( pszCommand, "enemyspot" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 2 );
+	}
+	else if ( FStrEq( pszCommand, "needbackup" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 3 );
+	}
+	else if ( FStrEq( pszCommand, "sectorclear" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 4 );
+	}
+	else if ( FStrEq( pszCommand, "inposition" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 5 );
+	}
+	else if ( FStrEq( pszCommand, "reportingin" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 6 );
+	}
+	else if ( FStrEq( pszCommand, "getout" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 7 );
+	}
+	else if ( FStrEq( pszCommand, "negative" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 8 );
+	}
+	else if ( FStrEq( pszCommand, "enemydown" ) )
+	{
+		bRetVal = true;
+		pPlayer->HandleMenu_Radio3( 9 );
+	}
+
+	return bRetVal;
+}
+
+bool CCSPlayer::ShouldRunRateLimitedCommand( const CCommand &args )
+{
+	const char *pcmd = args[0];
+
+	int i = m_RateLimitLastCommandTimes.Find( pcmd );
+	if ( i == m_RateLimitLastCommandTimes.InvalidIndex() )
+	{
+		m_RateLimitLastCommandTimes.Insert( pcmd, gpGlobals->curtime );
+		return true;
+	}
+	else if ( (gpGlobals->curtime - m_RateLimitLastCommandTimes[i]) < CS_COMMAND_MAX_RATE )
+	{
+		// Too fast.
+		return false;
+	}
+	else
+	{
+		m_RateLimitLastCommandTimes[i] = gpGlobals->curtime;
+		return true;
+	}
+}
+
+bool CCSPlayer::ClientCommand( const CCommand &args )
+{
+	const char *pcmd = args[0];
+
+	// Bots mimic our client commands.
+/*
+	if ( bot_mimic.GetInt() && !( GetFlags() & FL_FAKECLIENT ) )
+	{
+		for ( int i=1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( UTIL_PlayerByIndex( i ) );
+			if ( pPlayer && pPlayer != this && ( pPlayer->GetFlags() & FL_FAKECLIENT ) )
+			{
+				pPlayer->ClientCommand( pcmd );
+			}
+		}
+	}
+*/
+
+#if defined ( DEBUG )
+
+	if ( FStrEq( pcmd, "bot_cmd" ) )
+	{
+		CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( UTIL_PlayerByIndex( atoi( args[1] ) ) );
+		if ( pPlayer && pPlayer != this && ( pPlayer->GetFlags() & FL_FAKECLIENT ) )
+		{
+			CCommand botArgs( args.ArgC() - 2, &args.ArgV()[2] );
+			pPlayer->ClientCommand( botArgs );
+			pPlayer->RemoveEffects( EF_NODRAW );
+		}
+		return true;
+	}
+
+	if ( FStrEq( pcmd, "blind" ) )
+	{
+		if ( ShouldRunRateLimitedCommand( args ) )
+		{
+			if ( args.ArgC() == 3 )
+			{
+				Blind( atof( args[1] ), atof( args[2] ) );
+			}
+			else
+			{
+				ClientPrint( this, HUD_PRINTCONSOLE, "usage: blind holdtime fadetime\n" );
+			}
+		}
+		return true;
+	}
+
+	if ( FStrEq( pcmd, "deafen" ) )
+	{
+		Deafen( 0.0f );
+		return true;
+	}
+
+	if ( FStrEq( pcmd, "he_deafen" ) )
+	{
+		m_applyDeafnessTime = gpGlobals->curtime + 0.3;
+		m_currentDeafnessFilter = 0;
+		return true;
+	}
+
+	if ( FStrEq( pcmd, "hint_reset" ) )
+	{
+		m_iDisplayHistoryBits = 0;
+		return true;
+	}
+
+	if ( FStrEq( pcmd, "punch" ) )
+	{
+		float flDamage = 100;
+
+		QAngle punchAngle = GetPunchAngle();
+
+		punchAngle.x = flDamage * random->RandomFloat ( -0.15, 0.15 );
+		punchAngle.y = flDamage * random->RandomFloat ( -0.15, 0.15 );
+		punchAngle.z = flDamage * random->RandomFloat ( -0.15, 0.15 );
+
+		clamp( punchAngle.x, -4, punchAngle.x );
+		clamp( punchAngle.y, -5, 5 );
+		clamp( punchAngle.z, -5, 5 );
+
+		// +y == down
+		// +x == left
+		// +z == roll clockwise
+		if ( args.ArgC() == 4 )
+		{
+			punchAngle.x = atof(args[1]);
+			punchAngle.y = atof(args[2]);
+			punchAngle.z = atof(args[3]);
+		}
+
+		SetPunchAngle( punchAngle );
+
+		return true;
+	}
+
+#endif //DEBUG
+
+	if ( FStrEq( pcmd, "jointeam" ) )
+	{
+		if ( args.ArgC() < 2 )
+		{
+			Warning( "Player sent bad jointeam syntax\n" );
+		}
+
+		if ( ShouldRunRateLimitedCommand( args ) )
+		{
+			int iTeam = atoi( args[1] );
+			HandleCommand_JoinTeam( iTeam );
+		}
+		return true;
+	}
+	else if ( FStrEq( pcmd, "spectate" ) )
+	{
+		if ( ShouldRunRateLimitedCommand( args ) )
+		{
+			// instantly join spectators
+			HandleCommand_JoinTeam( TEAM_SPECTATOR );
+		}
+		return true;
+	}
+	else if ( FStrEq( pcmd, "joingame" ) )
+	{
+		// player just closed MOTD dialog
+		if ( m_iPlayerState == STATE_WELCOME )
+		{
+			State_Transition( STATE_PICKINGTEAM );
+		}
+
+		return true;
+	}
+	else if ( FStrEq( pcmd, "joinclass" ) )
+	{
+		if ( args.ArgC() < 2 )
+		{
+			Warning( "Player sent bad joinclass syntax\n" );
+		}
+
+		if ( ShouldRunRateLimitedCommand( args ) )
+		{
+			int iClass = atoi( args[1] );
+			HandleCommand_JoinClass( iClass );
+		}
+		return true;
+	}
+	else if ( FStrEq( pcmd, "drop" ) )
+	{
+		CWeaponCSBase *pWeapon = dynamic_cast< CWeaponCSBase* >( GetActiveWeapon() );
+
+		if( pWeapon )
+		{
+			//=============================================================================
+			// HPE_BEGIN:
+			// [dwenger] Determine value of dropped item.
+			//=============================================================================
+
+			if ( !pWeapon->IsAPriorOwner( this ) )
+			{
+				pWeapon->AddToPriorOwnerList( this );
+
+				CCS_GameStats.IncrementStat(this, CSTAT_ITEMS_DROPPED_VALUE, pWeapon->GetCSWpnData().GetWeaponPrice());
+			}
+
+			//=============================================================================
+			// HPE_END
+			//=============================================================================
+
+			CSWeaponType type = pWeapon->GetCSWpnData().m_WeaponType;
+
+			if( type != WEAPONTYPE_KNIFE && type != WEAPONTYPE_GRENADE )
+			{
+				if (CSGameRules()->GetCanDonateWeapon() && !pWeapon->GetDonated())
+				{
+					pWeapon->SetDonated(true);
+					pWeapon->SetDonor(this);
+				}
+				CSWeaponDrop( pWeapon, true, true );
+
+			}
+		}
+
+		return true;
+	}
+	else if ( FStrEq( pcmd, "buy" ) )
+	{
+		BuyResult_e result = BUY_INVALID_ITEM;
+		if ( args.ArgC() == 2 )
+		{
+			result = HandleCommand_Buy( args[1] );
+		}
+		if ( result == BUY_INVALID_ITEM )
+		{
+			// Print out a message on the console
+			int msg_dest = HUD_PRINTCONSOLE;
+
+			ClientPrint( this, msg_dest, "usage: buy <item>\n" );
+			ClientPrint( this, msg_dest, "  primammo\n" );
+			ClientPrint( this, msg_dest, "  secammo\n" );
+			ClientPrint( this, msg_dest, "  vest\n" );
+			ClientPrint( this, msg_dest, "  vesthelm\n" );
+			ClientPrint( this, msg_dest, "  defuser\n" );
+			//ClientPrint( this, msg_dest, "  shield\n" );
+			ClientPrint( this, msg_dest, "  nvgs\n" );
+			ClientPrint( this, msg_dest, "  flashbang\n" );
+			ClientPrint( this, msg_dest, "  hegrenade\n" );
+			ClientPrint( this, msg_dest, "  smokegrenade\n" );
+			ClientPrint( this, msg_dest, "  galil\n" );
+			ClientPrint( this, msg_dest, "  ak47\n" );
+			ClientPrint( this, msg_dest, "  scout\n" );
+			ClientPrint( this, msg_dest, "  sg552\n" );
+			ClientPrint( this, msg_dest, "  awp\n" );
+			ClientPrint( this, msg_dest, "  g3sg1\n" );
+			ClientPrint( this, msg_dest, "  famas\n" );
+			ClientPrint( this, msg_dest, "  m4a1\n" );
+			ClientPrint( this, msg_dest, "  aug\n" );
+			ClientPrint( this, msg_dest, "  sg550\n" );
+			ClientPrint( this, msg_dest, "  glock\n" );
+			ClientPrint( this, msg_dest, "  usp\n" );
+			ClientPrint( this, msg_dest, "  p228\n" );
+			ClientPrint( this, msg_dest, "  deagle\n" );
+			ClientPrint( this, msg_dest, "  elite\n" );
+			ClientPrint( this, msg_dest, "  fiveseven\n" );
+			ClientPrint( this, msg_dest, "  m3\n" );
+			ClientPrint( this, msg_dest, "  xm1014\n" );
+			ClientPrint( this, msg_dest, "  mac10\n" );
+			ClientPrint( this, msg_dest, "  tmp\n" );
+			ClientPrint( this, msg_dest, "  mp5navy\n" );
+			ClientPrint( this, msg_dest, "  ump45\n" );
+			ClientPrint( this, msg_dest, "  p90\n" );
+			ClientPrint( this, msg_dest, "  m249\n" );
+		}
+
+		return true;
+	}
+	else if ( FStrEq( pcmd, "buyammo1" ) )
+	{
+		AttemptToBuyAmmoSingle(0);
+		return true;
+	}
+	else if ( FStrEq( pcmd, "buyammo2" ) )
+	{
+		AttemptToBuyAmmoSingle(1);
+		return true;
+	}
+	else if ( FStrEq( pcmd, "nightvision" ) )
+	{
+		if ( ShouldRunRateLimitedCommand( args ) )
+		{
+			if( m_bHasNightVision )
+			{
+				if( m_bNightVisionOn )
+				{
+					CPASAttenuationFilter filter( this );
+					EmitSound( filter, entindex(), "Player.NightVisionOff" );
+				}
+				else
+				{
+					CPASAttenuationFilter filter( this );
+					EmitSound( filter, entindex(), "Player.NightVisionOn" );
+				}
+
+				m_bNightVisionOn = !m_bNightVisionOn;
+			}
+		}
+		return true;
+	}
+	else if ( FStrEq( pcmd, "menuselect" ) )
+	{
+		return true;
+	}
+	else if ( HandleRadioAliasCommands( this, pcmd ) )
+	{
+		return true;
+	}
+	else if ( FStrEq( pcmd, "listplayers" ) )
+	{
+		ListPlayers();
+		return true;
+	}
+
+	else if ( FStrEq( pcmd, "ignorerad" ) )
+	{
+		m_bIgnoreRadio = !m_bIgnoreRadio;
+		if ( m_bIgnoreRadio )
+		{
+			ClientPrint( this, HUD_PRINTTALK, "#Ignore_Radio" );
+		}
+		else
+		{
+			ClientPrint( this, HUD_PRINTTALK, "#Accept_Radio" );
+		}
+		return true;
+	}
+	else if ( FStrEq( pcmd, "become_vip" ) )
+	{
+		//MIKETODO: VIP mode
+		/*
+		if ( ( CSGameRules()->m_iMapHasVIPSafetyZone == 1 ) && ( m_iTeam == TEAM_CT ) )
+		{
+			mp->AddToVIPQueue( this );
+		}
+		*/
+		return true;
+	}
+
+	return BaseClass::ClientCommand( args );
+}
+
+
+// returns true if the selection has been handled and the player's menu
+// can be closed...false if the menu should be displayed again
+bool CCSPlayer::HandleCommand_JoinTeam( int team )
+{
+	CCSGameRules *mp = CSGameRules();
+
+	if ( !GetGlobalTeam( team ) )
+	{
+		DevWarning( "HandleCommand_JoinTeam( %d ) - invalid team index.\n", team );
+		return false;
+	}
+
+	// If this player is a VIP, don't allow him to switch teams/appearances unless the following conditions are met :
+	// a) There is another TEAM_CT player who is in the queue to be a VIP
+	// b) This player is dead
+
+	//MIKETODO: handle this when doing VIP mode
+	/*
+	if ( m_bIsVIP == true )
+	{
+		if ( !IsDead() )
+		{
+			ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Switch_From_VIP" );
+			MenuReset();
+			return true;
+		}
+		else if ( mp->IsVIPQueueEmpty() == true )
+		{
+			ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Switch_From_VIP" );
+			MenuReset();
+			return true;
+		}
+	}
+
+	//MIKETODO: VIP mode
+
+	case 3:
+		if ( ( mp->m_iMapHasVIPSafetyZone == 1 ) && ( m_iTeam == TEAM_CT ) )
+		{
+			mp->AddToVIPQueue( player );
+			MenuReset();
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+		break;
+	*/
+
+	// If we already died and changed teams once, deny
+	if( m_bTeamChanged && team != m_iOldTeam && team != TEAM_SPECTATOR )
+	{
+		ClientPrint( this, HUD_PRINTCENTER, "#Only_1_Team_Change" );
+		return true;
+	}
+
+	// check if we're limited in our team selection
+	if ( team == TEAM_UNASSIGNED && !IsBot() )
+	{
+		team = mp->GetHumanTeam(); // returns TEAM_UNASSIGNED if we're unrestricted
+	}
+
+	if ( team == TEAM_UNASSIGNED )
+	{
+		// Attempt to auto-select a team, may set team to T, CT or SPEC
+		team = mp->SelectDefaultTeam( !IsBot() );
+
+		if ( team == TEAM_UNASSIGNED )
+		{
+			// still team unassigned, try to kick a bot if possible
+
+			// kick a bot to allow human to join
+			if (cv_bot_auto_vacate.GetBool() && !IsBot())
+			{
+				team = (random->RandomInt( 0, 1 ) == 0) ? TEAM_TERRORIST : TEAM_CT;
+				if (UTIL_KickBotFromTeam( team ) == false)
+				{
+					// no bots on that team, try the other
+					team = (team == TEAM_CT) ? TEAM_TERRORIST : TEAM_CT;
+					if (UTIL_KickBotFromTeam( team ) == false)
+					{
+						// couldn't kick any bots, fail
+						team = TEAM_UNASSIGNED;
+					}
+				}
+			}
+
+			if (team == TEAM_UNASSIGNED)
+			{
+				ClientPrint( this, HUD_PRINTCENTER, "#All_Teams_Full" );
+				ShowViewPortPanel( PANEL_TEAM );
+				return false;
+			}
+		}
+	}
+
+	if ( team == GetTeamNumber() )
+	{
+		// Let people change class (skin) by re-joining the same team
+		if ( GetTeamNumber() == TEAM_TERRORIST && TerroristPlayerModels.Count() > 1 )
+		{
+			ShowViewPortPanel( PANEL_CLASS_TER );
+		}
+		else if ( GetTeamNumber() == TEAM_CT && CTPlayerModels.Count() > 1 )
+		{
+			ShowViewPortPanel( PANEL_CLASS_CT );
+		}
+		return true;	// we wouldn't change the team
+	}
+
+	if ( mp->TeamFull( team ) )
+	{
+		// attempt to kick a bot to make room for this player
+		bool madeRoom = false;
+		if (cv_bot_auto_vacate.GetBool() && !IsBot())
+		{
+			if (UTIL_KickBotFromTeam( team ))
+				madeRoom = true;
+		}
+
+		if (!madeRoom)
+		{
+			if ( team == TEAM_TERRORIST )
+			{
+				ClientPrint( this, HUD_PRINTCENTER, "#Terrorists_Full" );
+			}
+			else if ( team == TEAM_CT )
+			{
+				ClientPrint( this, HUD_PRINTCENTER, "#CTs_Full" );
+			}
+
+			ShowViewPortPanel( PANEL_TEAM );
+			return false;
+		}
+	}
+
+	// check if humans are restricted to a single team (Tour of Duty, etc)
+	if ( !IsBot() && team != TEAM_SPECTATOR)
+	{
+		int humanTeam = mp->GetHumanTeam();
+		if ( humanTeam != TEAM_UNASSIGNED && humanTeam != team )
+		{
+			if ( humanTeam == TEAM_TERRORIST )
+			{
+				ClientPrint( this, HUD_PRINTCENTER, "#Humans_Join_Team_T" );
+			}
+			else if ( humanTeam == TEAM_CT )
+			{
+				ClientPrint( this, HUD_PRINTCENTER, "#Humans_Join_Team_CT" );
+			}
+
+			ShowViewPortPanel( PANEL_TEAM );
+			return false;
+		}
+	}
+
+	if ( team == TEAM_SPECTATOR )
+	{
+		// Prevent this is the cvar is set
+		if ( !mp_allowspectators.GetInt() && !IsHLTV() )
+		{
+			ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Be_Spectator" );
+			return false;
+		}
+
+		if ( GetTeamNumber() != TEAM_UNASSIGNED && State_Get() == STATE_ACTIVE )
+		{
+			m_fNextSuicideTime = gpGlobals->curtime;	// allow the suicide to work
+
+			CommitSuicide();
+
+			// add 1 to frags to balance out the 1 subtracted for killing yourself
+			IncrementFragCount( 1 );
+		}
+
+		ChangeTeam( TEAM_SPECTATOR );
+		m_iClass = (int)CS_CLASS_NONE;
+
+		if ( !(m_iDisplayHistoryBits & DHF_SPEC_DUCK) )
+		{
+			m_iDisplayHistoryBits |= DHF_SPEC_DUCK;
+			HintMessage( "#Spec_Duck", true, true );
+		}
+
+		// do we have fadetoblack on? (need to fade their screen back in)
+		if ( mp_fadetoblack.GetBool() )
+		{
+			color32_s clr = { 0,0,0,255 };
+			UTIL_ScreenFade( this, clr, 0, 0, FFADE_IN | FFADE_PURGE );
+		}
+
+		return true;
+	}
+
+	// If the code gets this far, the team is not TEAM_UNASSIGNED
+
+
+	if (mp->TeamStacked( team, GetTeamNumber() ))//players are allowed to change to their own team so they can just change their model
+	{
+		// attempt to kick a bot to make room for this player
+		bool madeRoom = false;
+		if (cv_bot_auto_vacate.GetBool() && !IsBot())
+		{
+			if (UTIL_KickBotFromTeam( team ))
+				madeRoom = true;
+		}
+
+		if (!madeRoom)
+		{
+			// The specified team is full
+			ClientPrint(
+				this,
+				HUD_PRINTCENTER,
+				( team == TEAM_TERRORIST ) ?	"#Too_Many_Terrorists" : "#Too_Many_CTs" );
+
+			ShowViewPortPanel( PANEL_TEAM );
+			return false;
+		}
+	}
+
+	// Show the appropriate Choose Appearance menu
+	// This must come before ClientKill() for CheckWinConditions() to function properly
+
+	// Switch their actual team...
+	ChangeTeam( team );
+
+	return true;
+}
+
+
+bool CCSPlayer::HandleCommand_JoinClass( int iClass )
+{
+	if( iClass == CS_CLASS_NONE )
+	{
+		// User choosed random class
+		switch ( GetTeamNumber() )
+		{
+			case TEAM_TERRORIST :	iClass = RandomInt(FIRST_T_CLASS, LAST_T_CLASS);
+									break;
+
+			case TEAM_CT :			iClass = RandomInt(FIRST_CT_CLASS, LAST_CT_CLASS);
+									break;
+
+			default	:				iClass = CS_CLASS_NONE;
+									break;
+		}
+	}
+
+	// clamp to valid classes
+	switch ( GetTeamNumber() )
+	{
+		case TEAM_TERRORIST:
+			iClass = clamp( iClass, FIRST_T_CLASS, LAST_T_CLASS );
+			break;
+		case TEAM_CT:
+			iClass = clamp( iClass, FIRST_CT_CLASS, LAST_CT_CLASS );
+			break;
+		default:
+			iClass = CS_CLASS_NONE;
+	}
+
+	// Reset the player's state
+	if ( State_Get() == STATE_ACTIVE )
+	{
+		CSGameRules()->CheckWinConditions();
+	}
+
+	if ( !IsBot() && State_Get() == STATE_ACTIVE ) // Bots are responsible about only switching classes when they join.
+	{
+		// Kill player if switching classes while alive.
+		// This mimics goldsrc CS 1.6, and prevents a player from hiding, and switching classes to
+		// make the opposing team think there are more enemies than there really are.
+		CommitSuicide();
+	}
+
+	m_iClass = iClass;
+
+	if (State_Get() == STATE_PICKINGCLASS)
+	{
+// 		SetModelFromClass();
+		GetIntoGame();
+	}
+
+	return true;
+}
+
+
+/*
+void CheckStartMoney( void )
+{
+	if ( mp_startmoney.GetInt() > 16000 )
+	{
+		mp_startmoney.SetInt( 16000 );
+	}
+	else if ( mp_startmoney.GetInt() < 800 )
+	{
+		mp_startmoney.SetInt( 800 );
+	}
+}
+*/
+
+void CCSPlayer::GetIntoGame()
+{
+	// Set their model and if they're allowed to spawn right now, put them into the world.
+	//SetPlayerModel( iClass );
+
+	SetFOV( this, 0 );
+	m_flLastMovement = gpGlobals->curtime;
+
+	CCSGameRules *MPRules = CSGameRules();
+
+/*	//MIKETODO: Escape gameplay ?
+	if ( ( MPRules->m_bMapHasEscapeZone == true ) && ( m_iTeam == TEAM_CT ) )
+	{
+		m_iAccount = 0;
+
+		CheckStartMoney();
+		AddAccount( (int)startmoney.value, true );
+	}
+	*/
+
+
+	//****************New Code by SupraFiend************
+	if ( !MPRules->FPlayerCanRespawn( this ) )
+	{
+		// This player is joining in the middle of a round or is an observer. Put them directly into observer mode.
+		//pev->deadflag		= DEAD_RESPAWNABLE;
+		//pev->classname		= MAKE_STRING("player");
+		//pev->flags		   &= ( FL_PROXY | FL_FAKECLIENT );	// clear flags, but keep proxy and bot flags that might already be set
+		//pev->flags		   |= FL_CLIENT | FL_SPECTATOR;
+		//SetThink(PlayerDeathThink);
+		if ( !(m_iDisplayHistoryBits & DHF_SPEC_DUCK) )
+		{
+			m_iDisplayHistoryBits |= DHF_SPEC_DUCK;
+			HintMessage( "#Spec_Duck", true, true );
+		}
+
+		State_Transition( STATE_OBSERVER_MODE );
+
+		m_wasNotKilledNaturally = true;
+
+		MPRules->CheckWinConditions();
+	}
+	else// else spawn them right in
+	{
+		State_Transition( STATE_ACTIVE );
+
+		Spawn();
+
+		MPRules->CheckWinConditions();
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [menglish] Have the rules update anything related to a player spawning in late
+		//=============================================================================
+
+		MPRules->SpawningLatePlayer(this);
+
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+		if( MPRules->m_flRestartRoundTime == 0.0f )
+		{
+			//Bomb target, no bomber and no bomb lying around.
+			if( MPRules->IsBombDefuseMap() && !MPRules->IsThereABomber() && !MPRules->IsThereABomb() )
+				MPRules->GiveC4(); //Checks for terrorists.
+		}
+
+		// If a new terrorist is entering the fray, then up the # of potential escapers.
+		if ( GetTeamNumber() == TEAM_TERRORIST )
+			MPRules->m_iNumEscapers++;
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [menglish] Reset Round Based Achievement Variables
+		//=============================================================================
+
+		ResetRoundBasedAchievementVariables();
+
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+	}
+}
+
+
+int CCSPlayer::PlayerClass() const
+{
+	return m_iClass;
+}
+
+
+
+bool CCSPlayer::SelectSpawnSpot( const char *pEntClassName, CBaseEntity* &pSpot )
+{
+	// Find the next spawn spot.
+	pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
+
+	if ( pSpot == NULL ) // skip over the null point
+		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
+
+	CBaseEntity *pFirstSpot = pSpot;
+	do
+	{
+		if ( pSpot )
+		{
+			// check if pSpot is valid
+			if ( g_pGameRules->IsSpawnPointValid( pSpot, this ) )
+			{
+				if ( pSpot->GetAbsOrigin() == Vector( 0, 0, 0 ) )
+				{
+					pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
+					continue;
+				}
+
+				// if so, go to pSpot
+				return true;
+			}
+		}
+		// increment pSpot
+		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
+	} while ( pSpot != pFirstSpot ); // loop if we're not back to the start
+
+	DevMsg("CCSPlayer::SelectSpawnSpot: couldn't find valid spawn point.\n");
+
+	return true;
+}
+
+
+CBaseEntity* CCSPlayer::EntSelectSpawnPoint()
+{
+	CBaseEntity *pSpot;
+
+	/* MIKETODO: VIP
+		// VIP spawn point *************
+		if ( ( g_pGameRules->IsDeathmatch() ) && ( ((CBasePlayer*)pPlayer)->m_bIsVIP == TRUE) )
+		{
+			//ALERT (at_console,"Looking for a VIP spawn point\n");
+			// Randomize the start spot
+			//for ( int i = RANDOM_LONG(1,5); i > 0; i-- )
+			pSpot = UTIL_FindEntityByClassname( NULL, "info_vip_start" );
+			if ( !FNullEnt( pSpot ) )  // skip over the null point
+				goto ReturnSpot;
+			else
+				goto CTSpawn;
+		}
+
+		//
+		// the counter-terrorist spawns at "info_player_start"
+		else
+	*/
+
+	pSpot = NULL;
+	if ( CSGameRules()->IsLogoMap() )
+	{
+		// This is a logo map. Don't allow movement or logos or menus.
+		SelectSpawnSpot( "info_player_logo", pSpot );
+		LockPlayerInPlace();
+		goto ReturnSpot;
+	}
+	else
+	{
+		if ( GetTeamNumber() == TEAM_CT )
+		{
+			pSpot = g_pLastCTSpawn;
+			if ( SelectSpawnSpot( "info_player_counterterrorist", pSpot ))
+			{
+
+				g_pLastCTSpawn = pSpot;
+				goto ReturnSpot;
+			}
+		}
+
+		/*********************************************************/
+		// The terrorist spawn points
+		else if ( GetTeamNumber() == TEAM_TERRORIST )
+		{
+			pSpot = g_pLastTerroristSpawn;
+
+			if ( SelectSpawnSpot( "info_player_terrorist", pSpot ) )
+			{
+				g_pLastTerroristSpawn = pSpot;
+				goto ReturnSpot;
+			}
+		}
+	}
+
+
+	// If startspot is set, (re)spawn there.
+	if ( !gpGlobals->startspot || !strlen(STRING(gpGlobals->startspot)))
+	{
+		pSpot = gEntList.FindEntityByClassname(NULL, "info_player_terrorist");
+		if ( pSpot )
+			goto ReturnSpot;
+	}
+	else
+	{
+		pSpot = gEntList.FindEntityByTarget( NULL, STRING(gpGlobals->startspot) );
+		if ( pSpot )
+			goto ReturnSpot;
+	}
+
+ReturnSpot:
+	if ( !pSpot )
+	{
+		if( CSGameRules()->IsLogoMap() )
+			Warning( "PutClientInServer: no info_player_logo on level\n" );
+		else
+			Warning( "PutClientInServer: no info_player_start on level\n" );
+
+		return CBaseEntity::Instance( INDEXENT(0) );
+	}
+
+	return pSpot;
+}
+
+
+void CCSPlayer::SetProgressBarTime( int barTime )
+{
+	m_iProgressBarDuration = barTime;
+	m_flProgressBarStartTime = this->m_flSimulationTime;
+}
+
+
+void CCSPlayer::PlayerDeathThink()
+{
+}
+
+
+void CCSPlayer::State_Transition( CSPlayerState newState )
+{
+	State_Leave();
+	State_Enter( newState );
+}
+
+
+void CCSPlayer::State_Enter( CSPlayerState newState )
+{
+	m_iPlayerState = newState;
+	m_pCurStateInfo = State_LookupInfo( newState );
+
+	if ( cs_ShowStateTransitions.GetInt() == -1 || cs_ShowStateTransitions.GetInt() == entindex() )
+	{
+		if ( m_pCurStateInfo )
+			Msg( "ShowStateTransitions: entering '%s'\n", m_pCurStateInfo->m_pStateName );
+		else
+			Msg( "ShowStateTransitions: entering #%d\n", newState );
+	}
+
+	// Initialize the new state.
+	if ( m_pCurStateInfo && m_pCurStateInfo->pfnEnterState )
+		(this->*m_pCurStateInfo->pfnEnterState)();
+}
+
+
+void CCSPlayer::State_Leave()
+{
+	if ( m_pCurStateInfo && m_pCurStateInfo->pfnLeaveState )
+	{
+		(this->*m_pCurStateInfo->pfnLeaveState)();
+	}
+}
+
+
+void CCSPlayer::State_PreThink()
+{
+	if ( m_pCurStateInfo && m_pCurStateInfo->pfnPreThink )
+	{
+		(this->*m_pCurStateInfo->pfnPreThink)();
+	}
+}
+
+
+CCSPlayerStateInfo* CCSPlayer::State_LookupInfo( CSPlayerState state )
+{
+	// This table MUST match the
+	static CCSPlayerStateInfo playerStateInfos[] =
+	{
+		{ STATE_ACTIVE,			"STATE_ACTIVE",			&CCSPlayer::State_Enter_ACTIVE, NULL, &CCSPlayer::State_PreThink_ACTIVE },
+		{ STATE_WELCOME,		"STATE_WELCOME",		&CCSPlayer::State_Enter_WELCOME, NULL, &CCSPlayer::State_PreThink_WELCOME },
+		{ STATE_PICKINGTEAM,	"STATE_PICKINGTEAM",	&CCSPlayer::State_Enter_PICKINGTEAM, NULL,	&CCSPlayer::State_PreThink_OBSERVER_MODE },
+		{ STATE_PICKINGCLASS,	"STATE_PICKINGCLASS",	&CCSPlayer::State_Enter_PICKINGCLASS, NULL,	&CCSPlayer::State_PreThink_OBSERVER_MODE },
+		{ STATE_DEATH_ANIM,		"STATE_DEATH_ANIM",		&CCSPlayer::State_Enter_DEATH_ANIM,	NULL, &CCSPlayer::State_PreThink_DEATH_ANIM },
+		{ STATE_DEATH_WAIT_FOR_KEY,	"STATE_DEATH_WAIT_FOR_KEY",	&CCSPlayer::State_Enter_DEATH_WAIT_FOR_KEY,	NULL, &CCSPlayer::State_PreThink_DEATH_WAIT_FOR_KEY },
+		{ STATE_OBSERVER_MODE,	"STATE_OBSERVER_MODE",	&CCSPlayer::State_Enter_OBSERVER_MODE,	NULL, &CCSPlayer::State_PreThink_OBSERVER_MODE }
+	};
+
+	for ( int i=0; i < ARRAYSIZE( playerStateInfos ); i++ )
+	{
+		if ( playerStateInfos[i].m_iPlayerState == state )
+			return &playerStateInfos[i];
+	}
+
+	return NULL;
+}
+
+
+void CCSPlayer::PhysObjectSleep()
+{
+	IPhysicsObject *pObj = VPhysicsGetObject();
+	if ( pObj )
+		pObj->Sleep();
+}
+
+
+void CCSPlayer::PhysObjectWake()
+{
+	IPhysicsObject *pObj = VPhysicsGetObject();
+	if ( pObj )
+		pObj->Wake();
+}
+
+
+void CCSPlayer::State_Enter_WELCOME()
+{
+	StartObserverMode( OBS_MODE_ROAMING );
+
+	// Important to set MOVETYPE_NONE or our physics object will fall while we're sitting at one of the intro cameras.
+	SetMoveType( MOVETYPE_NONE );
+	AddSolidFlags( FSOLID_NOT_SOLID );
+
+	PhysObjectSleep();
+
+	const ConVar *hostname = cvar->FindVar( "hostname" );
+	const char *title = (hostname) ? hostname->GetString() : "MESSAGE OF THE DAY";
+
+	// Show info panel (if it's not a simple demo map).
+	if ( !CSGameRules()->IsLogoMap() )
+	{
+		if ( CommandLine()->FindParm( "-makereslists" ) ) // don't show the MOTD when making reslists
+		{
+			engine->ClientCommand( edict(), "jointeam 3\n" );
+		}
+		else
+		{
+			KeyValues *data = new KeyValues("data");
+			data->SetString( "title", title );		// info panel title
+			data->SetString( "type", "1" );			// show userdata from stringtable entry
+			data->SetString( "msg",	"motd" );		// use this stringtable entry
+			data->SetInt( "cmd", TEXTWINDOW_CMD_JOINGAME );	// exec this command if panel closed
+			data->SetBool( "unload", sv_motd_unload_on_dismissal.GetBool() );
+
+			ShowViewPortPanel( PANEL_INFO, true, data );
+
+			data->deleteThis();
+		}
+	}
+}
+
+
+void CCSPlayer::State_PreThink_WELCOME()
+{
+	// Verify some state.
+	Assert( IsSolidFlagSet( FSOLID_NOT_SOLID ) );
+	Assert( GetAbsVelocity().Length() == 0 );
+
+	// Update whatever intro camera it's at.
+	if( m_pIntroCamera && (gpGlobals->curtime >= m_fIntroCamTime) )
+	{
+		MoveToNextIntroCamera();
+	}
+}
+
+
+void CCSPlayer::State_Enter_PICKINGTEAM()
+{
+	ShowViewPortPanel( "team" ); // show the team menu
+}
+
+
+void CCSPlayer::State_Enter_DEATH_ANIM()
+{
+	if ( HasWeapons() )
+	{
+		// we drop the guns here because weapons that have an area effect and can kill their user
+		// will sometimes crash coming back from CBasePlayer::Killed() if they kill their owner because the
+		// player class sometimes is freed. It's safer to manipulate the weapons once we know
+		// we aren't calling into any of their code anymore through the player pointer.
+		PackDeadPlayerItems();
+	}
+
+	// Used for a timer.
+	m_flDeathTime = gpGlobals->curtime;
+
+	m_bAbortFreezeCam = false;
+
+	StartObserverMode( OBS_MODE_DEATHCAM );	// go to observer mode
+	RemoveEffects( EF_NODRAW );	// still draw player body
+
+	if ( mp_fadetoblack.GetBool() )
+	{
+		color32_s clr = {0,0,0,255};
+		UTIL_ScreenFade( this, clr, 3, 3, FFADE_OUT | FFADE_STAYOUT );
+		//Don't perform any freezecam stuff if we are fading to black
+		State_Transition( STATE_DEATH_WAIT_FOR_KEY );
+	}
+}
+
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish, pfreese] Added freeze cam logic
+//=============================================================================
+ 
+void CCSPlayer::State_PreThink_DEATH_ANIM()
+{
+	// If the anim is done playing, go to the next state (waiting for a keypress to
+	// either respawn the guy or put him into observer mode).
+	if ( GetFlags() & FL_ONGROUND )
+	{
+		float flForward = GetAbsVelocity().Length() - 20;
+		if (flForward <= 0)
+		{
+			SetAbsVelocity( vec3_origin );
+		}
+		else
+		{
+			Vector vAbsVel = GetAbsVelocity();
+			VectorNormalize( vAbsVel );
+			vAbsVel *= flForward;
+			SetAbsVelocity( vAbsVel );
+		}
+	}
+
+	float fDeathEnd = m_flDeathTime + CS_DEATH_ANIMATION_TIME;
+	float fFreezeEnd = fDeathEnd + spec_freeze_traveltime.GetFloat() + spec_freeze_time.GetFloat();
+
+	// transition to Freezecam mode once the death animation is complete
+	if ( gpGlobals->curtime >= fDeathEnd )
+	{
+		if ( GetObserverTarget() && GetObserverTarget() != this &&
+			!m_bAbortFreezeCam && gpGlobals->curtime < fFreezeEnd && GetObserverMode() != OBS_MODE_FREEZECAM)
+		{
+			StartObserverMode( OBS_MODE_FREEZECAM );
+		}
+		else if(GetObserverMode() == OBS_MODE_FREEZECAM)
+		{
+			if ( m_bAbortFreezeCam && !mp_fadetoblack.GetBool() )
+			{
+				State_Transition( STATE_OBSERVER_MODE );
+			}
+		}
+	}
+
+	// Don't transfer to observer state until the freeze cam is done
+	if ( gpGlobals->curtime < fFreezeEnd )
+		return;
+
+	State_Transition( STATE_OBSERVER_MODE );
+}
+ 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+void CCSPlayer::State_Enter_DEATH_WAIT_FOR_KEY()
+{
+	// Remember when we died, so we can automatically put them into observer mode
+	// if they don't hit a key soon enough.
+
+	m_lifeState = LIFE_DEAD;
+
+	StopAnimation();
+
+	// Don't do this.  The ragdoll system expects to be able to read from this player on 
+	// the next update and will read it at the new origin if this is set.
+	// Since it is more complicated to redesign the ragdoll system to not need that data
+	// it is easier to cause a less obvious bug than popping ragdolls
+	//AddEffects( EF_NOINTERP );
+}
+
+
+void CCSPlayer::State_PreThink_DEATH_WAIT_FOR_KEY()
+{
+	// once we're done animating our death and we're on the ground, we want to set movetype to None so our dead body won't do collisions and stuff anymore
+	// this prevents a bug where the dead body would go to a player's head if he walked over it while the dead player was clicking their button to respawn
+	if ( GetMoveType() != MOVETYPE_NONE && (GetFlags() & FL_ONGROUND) )
+		SetMoveType( MOVETYPE_NONE );
+
+	// if the player has been dead for one second longer than allowed by forcerespawn,
+	// forcerespawn isn't on. Send the player off to an intermission camera until they
+	// choose to respawn.
+
+	bool fAnyButtonDown = (m_nButtons & ~IN_SCORE) != 0;
+	if ( mp_fadetoblack.GetBool() )
+		fAnyButtonDown = false;
+
+	// after a certain amount of time switch to observer mode even if they don't press a key.
+	if (gpGlobals->curtime >= (m_flDeathTime + DEATH_ANIMATION_TIME + 3.0))
+	{
+		fAnyButtonDown = true;
+	}
+
+	if ( fAnyButtonDown )
+	{
+		if ( GetObserverTarget() )
+		{
+			StartReplayMode( 8, 8, GetObserverTarget()->entindex() );
+		}
+
+		State_Transition( STATE_OBSERVER_MODE );
+	}
+}
+
+void CCSPlayer::State_Enter_OBSERVER_MODE()
+{
+	// do we have fadetoblack on? (need to fade their screen back in)
+	if ( mp_fadetoblack.GetBool() && mp_forcecamera.GetInt() != OBS_ALLOW_NONE)
+	{
+		color32_s clr = { 0,0,0,255 };
+		UTIL_ScreenFade( this, clr, 0, 0, FFADE_IN | FFADE_PURGE );
+	}
+
+	int observerMode = m_iObserverLastMode;
+	if ( IsNetClient() )
+	{
+		const char *pIdealMode = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_spec_mode" );
+		if ( pIdealMode )
+		{
+			int nIdealMode = atoi( pIdealMode );
+
+			if ( nIdealMode < OBS_MODE_IN_EYE )
+			{
+				nIdealMode = OBS_MODE_IN_EYE;
+			}
+			else if ( nIdealMode > OBS_MODE_ROAMING )
+			{
+				nIdealMode = OBS_MODE_ROAMING;
+			}
+
+			observerMode = nIdealMode;
+		}
+	}
+
+	StartObserverMode( observerMode );
+
+	PhysObjectSleep();
+}
+
+void CCSPlayer::State_PreThink_OBSERVER_MODE()
+{
+	// Make sure nobody has changed any of our state.
+//	Assert( GetMoveType() == MOVETYPE_FLY );
+	Assert( m_takedamage == DAMAGE_NO );
+	Assert( IsSolidFlagSet( FSOLID_NOT_SOLID ) );
+//	Assert( IsEffectActive( EF_NODRAW ) );
+
+	// Must be dead.
+	Assert( m_lifeState == LIFE_DEAD );
+	Assert( pl.deadflag );
+}
+
+
+void CCSPlayer::State_Enter_PICKINGCLASS()
+{
+	if ( CommandLine()->FindParm( "-makereslists" ) ) // don't show the menu when making reslists
+	{
+		engine->ClientCommand( edict(), "joinclass 0\n" );
+		return;
+	}
+
+	// go to spec mode, if dying keep deathcam
+	if ( GetObserverMode() == OBS_MODE_DEATHCAM )
+	{
+		StartObserverMode( OBS_MODE_DEATHCAM );
+	}
+	else
+	{
+		StartObserverMode( OBS_MODE_FIXED );
+	}
+
+	m_iClass = (int)CS_CLASS_NONE;
+
+	PhysObjectSleep();
+
+	// show the class menu:
+	if ( GetTeamNumber() == TEAM_TERRORIST && TerroristPlayerModels.Count() > 1 )
+	{
+		ShowViewPortPanel( PANEL_CLASS_TER );
+	}
+	else if ( GetTeamNumber() == TEAM_CT && CTPlayerModels.Count() > 1 )
+	{
+		ShowViewPortPanel( PANEL_CLASS_CT );
+	}
+	else
+	{
+		HandleCommand_JoinClass( 0 );
+	}
+}
+
+void CCSPlayer::State_Enter_ACTIVE()
+{
+	SetMoveType( MOVETYPE_WALK );
+	RemoveSolidFlags( FSOLID_NOT_SOLID );
+	m_Local.m_iHideHUD = 0;
+	PhysObjectWake();
+}
+
+
+void CCSPlayer::State_PreThink_ACTIVE()
+{
+	// We only allow noclip here only because noclip is useful for debugging.
+	// It would be nice if the noclip command set some flag so we could tell that they
+	// did it intentionally.
+	if ( IsEFlagSet( EFL_NOCLIP_ACTIVE ) )
+	{
+//		Assert( GetMoveType() == MOVETYPE_NOCLIP );
+	}
+	else
+	{
+//		Assert( GetMoveType() == MOVETYPE_WALK );
+	}
+
+	Assert( !IsSolidFlagSet( FSOLID_NOT_SOLID ) );
+}
+
+
+void CCSPlayer::Weapon_Equip( CBaseCombatWeapon *pWeapon )
+{
+	CWeaponCSBase *pCSWeapon = dynamic_cast< CWeaponCSBase* >( pWeapon );
+	if ( pCSWeapon )
+	{
+		// For rifles, pistols, or the knife, drop our old weapon in this slot.
+		if ( pCSWeapon->GetSlot() == WEAPON_SLOT_RIFLE ||
+			pCSWeapon->GetSlot() == WEAPON_SLOT_PISTOL ||
+			pCSWeapon->GetSlot() == WEAPON_SLOT_KNIFE )
+		{
+			CBaseCombatWeapon *pDropWeapon = Weapon_GetSlot( pCSWeapon->GetSlot() );
+			if ( pDropWeapon )
+			{
+				CSWeaponDrop( pDropWeapon, false, true );
+			}
+		}
+		else if( pCSWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_GRENADE )
+		{
+			//if we already have this weapon, just add the ammo and destroy it
+			if( Weapon_OwnsThisType( pCSWeapon->GetClassname() ) )
+			{
+				Weapon_EquipAmmoOnly( pWeapon );
+				UTIL_Remove( pCSWeapon );
+				return;
+			}
+		}
+
+		pCSWeapon->SetSolidFlags( FSOLID_NOT_SOLID );
+		pCSWeapon->SetOwnerEntity( this );
+	}
+
+	BaseClass::Weapon_Equip( pWeapon );
+}
+
+bool CCSPlayer::Weapon_CanUse( CBaseCombatWeapon *pBaseWeapon )
+{
+	CWeaponCSBase *pWeapon = dynamic_cast< CWeaponCSBase* >( pBaseWeapon );
+
+	if ( pWeapon )
+	{
+		// Don't give weapon_c4 to non-terrorists
+		if( pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_C4 && GetTeamNumber() != TEAM_TERRORIST )
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool CCSPlayer::BumpWeapon( CBaseCombatWeapon *pBaseWeapon )
+{
+	CWeaponCSBase *pWeapon = dynamic_cast< CWeaponCSBase* >( pBaseWeapon );
+	if ( !pWeapon )
+	{
+		Assert( !pWeapon );
+		pBaseWeapon->AddSolidFlags( FSOLID_NOT_SOLID );
+		pBaseWeapon->AddEffects( EF_NODRAW );
+		Weapon_Equip( pBaseWeapon );
+		return true;
+	}
+
+	CBaseCombatCharacter *pOwner = pWeapon->GetOwner();
+
+	// Can I have this weapon type?
+	if ( pOwner || !Weapon_CanUse( pWeapon ) || !g_pGameRules->CanHavePlayerItem( this, pWeapon ) )
+	{
+		extern int gEvilImpulse101;
+		if ( gEvilImpulse101 )
+		{
+			UTIL_Remove( pWeapon );
+		}
+		return false;
+	}
+
+	// Even if we already have a grenade in this slot, we can pickup another one if we don't already
+	// own this type of grenade.
+	bool bPickupGrenade =  ( pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_GRENADE );
+
+
+	/*
+	// ----------------------------------------
+	// If I already have it just take the ammo
+	// ----------------------------------------
+	if ( !bPickupGrenade && Weapon_SlotOccupied( pWeapon ) )
+	{
+		Weapon_EquipAmmoOnly( pWeapon );
+		// Only remove me if I have no ammo left
+		// Can't just check HasAnyAmmo because if I don't use clips, I want to be removed,
+		if ( pWeapon->UsesClipsForAmmo1() && pWeapon->HasPrimaryAmmo() )
+			return false;
+
+		UTIL_Remove( pWeapon );
+		return false;
+	}
+	*/
+
+	if ( HasShield() && pWeapon->GetCSWpnData().m_bCanUseWithShield == false )
+		 return false;
+
+	// Check ammo counts for grenades, and don't try to pick up more grenades than we can carry
+	if ( bPickupGrenade )
+	{
+		CBaseCombatWeapon *pOwnedGrenade = Weapon_OwnsThisType( pWeapon->GetClassname() );
+
+		if( pOwnedGrenade )
+		{
+			int numGrenades = 0;
+			int maxGrenades = 0;
+
+			int ammoIndex = pOwnedGrenade->GetPrimaryAmmoType();
+			if( ammoIndex != -1 )
+			{
+				numGrenades = GetAmmoCount( ammoIndex );
+			}
+			maxGrenades = GetAmmoDef()->MaxCarry(ammoIndex);
+
+			if( numGrenades >= maxGrenades )
+			{
+				return false;
+			}
+		}
+	}
+
+	if( bPickupGrenade || !Weapon_SlotOccupied( pWeapon ) )
+	{
+		pWeapon->CheckRespawn();
+
+		pWeapon->AddSolidFlags( FSOLID_NOT_SOLID );
+		pWeapon->AddEffects( EF_NODRAW );
+
+		CCSPlayer* pDonor = pWeapon->GetDonor();
+		if ( pDonor && pDonor != this && pWeapon->GetCSWpnData().GetWeaponPrice() > m_iAccount )
+		{
+			CCS_GameStats.Event_PlayerDonatedWeapon( pDonor );
+		}
+		pWeapon->SetDonor(NULL);
+
+		Weapon_Equip( pWeapon );
+
+		int iExtraAmmo = pWeapon->GetExtraAmmoCount();
+
+		if( iExtraAmmo && !bPickupGrenade )
+		{
+			//Find out the index of the ammo
+			int iAmmoIndex = pWeapon->GetPrimaryAmmoType();
+
+			if( iAmmoIndex != -1 )
+			{
+				//Remove the extra ammo from the weapon
+				pWeapon->SetExtraAmmoCount(0);
+
+				//Give it to the player
+				SetAmmoCount( iExtraAmmo, iAmmoIndex );
+			}
+		}
+
+		IGameEvent * event = gameeventmanager->CreateEvent( "item_pickup" );
+		if( event )
+		{
+			const char *weaponName = pWeapon->GetClassname();
+			if ( strncmp( weaponName, "weapon_", 7 ) == 0 )
+			{
+				weaponName += 7;
+			}
+			event->SetInt( "userid", GetUserID() );
+			event->SetString( "item", weaponName );
+			gameeventmanager->FireEvent( event );
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+
+void CCSPlayer::ResetStamina( void )
+{
+	m_flStamina = 0.0f;
+}
+
+void CCSPlayer::RescueZoneTouch( inputdata_t &inputdata )
+{
+	m_bInHostageRescueZone = true;
+	if ( GetTeamNumber() == TEAM_CT && !(m_iDisplayHistoryBits & DHF_IN_RESCUE_ZONE) )
+	{
+		HintMessage( "#Hint_hostage_rescue_zone", false );
+		m_iDisplayHistoryBits |= DHF_IN_RESCUE_ZONE;
+	}
+}
+
+//------------------------------------------------------------------------------------------
+CON_COMMAND( timeleft, "prints the time remaining in the match" )
+{
+	CCSPlayer *pPlayer = ToCSPlayer( UTIL_GetCommandClient() );
+	if ( pPlayer && pPlayer->m_iNextTimeCheck >= gpGlobals->curtime )
+	{
+		return; // rate limiting
+	}
+
+	int iTimeRemaining = (int)CSGameRules()->GetMapRemainingTime();
+
+	if ( iTimeRemaining < 0 )
+	{
+		if ( pPlayer )
+		{
+			ClientPrint( pPlayer, HUD_PRINTTALK, "#Game_no_timelimit" );
+		}
+		else
+		{
+			Msg( "* No Time Limit *\n" );
+		}
+	}
+	else if ( iTimeRemaining == 0 )
+	{
+		if ( pPlayer )
+		{
+			ClientPrint( pPlayer, HUD_PRINTTALK, "#Game_last_round" );
+		}
+		else
+		{
+			Msg( "* Last Round *\n" );
+		}
+	}
+	else
+	{
+		int iMinutes, iSeconds;
+		iMinutes = iTimeRemaining / 60;
+		iSeconds = iTimeRemaining % 60;
+
+		char minutes[8];
+		char seconds[8];
+
+		Q_snprintf( minutes, sizeof(minutes), "%d", iMinutes );
+		Q_snprintf( seconds, sizeof(seconds), "%2.2d", iSeconds );
+
+		if ( pPlayer )
+		{
+			ClientPrint( pPlayer, HUD_PRINTTALK, "#Game_timelimit", minutes, seconds );
+		}
+		else
+		{
+			Msg( "Time Remaining:  %s:%s\n", minutes, seconds );
+		}
+	}
+
+	if ( pPlayer )
+	{
+		pPlayer->m_iNextTimeCheck = gpGlobals->curtime + 1;
+	}
+}
+
+//------------------------------------------------------------------------------------------
+/**
+ * Emit given sound that only we can hear
+ */
+void CCSPlayer::EmitPrivateSound( const char *soundName )
+{
+	CSoundParameters params;
+	if (!GetParametersForSound( soundName, params, NULL ))
+		return;
+
+	CSingleUserRecipientFilter filter( this );
+	EmitSound( filter, entindex(), soundName );
+}
+
+
+//=====================
+//Autobuy
+//=====================
+static void AutoBuy( void )
+{
+	CCSPlayer *player = ToCSPlayer( UTIL_GetCommandClient() );
+
+	if ( player )
+		player->AutoBuy();
+}
+static ConCommand autobuy( "autobuy", AutoBuy, "Attempt to purchase items with the order listed in cl_autobuy" );
+
+//==============================================
+//AutoBuy - do the work of deciding what to buy
+//==============================================
+void CCSPlayer::AutoBuy()
+{
+	if ( !IsInBuyZone() )
+	{
+		EmitPrivateSound( "BuyPreset.CantBuy" );
+		return;
+	}
+
+	const char *autobuyString = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_autobuy" );
+	if ( !autobuyString || !*autobuyString )
+	{
+		EmitPrivateSound( "BuyPreset.AlreadyBought" );
+		return;
+	}
+
+	bool boughtPrimary = false, boughtSecondary = false;
+
+	m_bIsInAutoBuy = true;
+	ParseAutoBuyString(autobuyString, boughtPrimary, boughtSecondary);
+	m_bIsInAutoBuy = false;
+
+	m_bAutoReload = true;
+
+	//TODO ?: stripped out all the attempts to buy career weapons.
+	// as we're not porting cs:cz, these were skipped
+}
+
+void CCSPlayer::ParseAutoBuyString(const char *string, bool &boughtPrimary, bool &boughtSecondary)
+{
+	char command[32];
+	int nBuffSize = sizeof(command) - 1; // -1 to leave space for the NULL at the end of the string
+	const char *c = string;
+
+	if (c == NULL)
+	{
+		EmitPrivateSound( "BuyPreset.AlreadyBought" );
+		return;
+	}
+
+	BuyResult_e overallResult = BUY_ALREADY_HAVE;
+
+	// loop through the string of commands, trying each one in turn.
+	while (*c != 0)
+	{
+		int i = 0;
+		// copy the next word into the command buffer.
+		while ((*c != 0) && (*c != ' ') && (i < nBuffSize))
+		{
+			command[i] = *(c);
+			++c;
+			++i;
+		}
+		if (*c == ' ')
+		{
+			++c; // skip the space.
+		}
+
+		command[i] = 0; // terminate the string.
+
+		// clear out any spaces.
+		i = 0;
+		while (command[i] != 0)
+		{
+			if (command[i] == ' ')
+			{
+				command[i] = 0;
+				break;
+			}
+			++i;
+		}
+
+		// make sure we actually have a command.
+		if (strlen(command) == 0)
+		{
+			continue;
+		}
+
+		AutoBuyInfoStruct * commandInfo = GetAutoBuyCommandInfo(command);
+
+		if (ShouldExecuteAutoBuyCommand(commandInfo, boughtPrimary, boughtSecondary))
+		{
+			BuyResult_e result = HandleCommand_Buy( command );
+
+			overallResult = CombineBuyResults( overallResult, result );
+
+			// check to see if we actually bought a primary or secondary weapon this time.
+			PostAutoBuyCommandProcessing(commandInfo, boughtPrimary, boughtSecondary);
+		}
+	}
+
+	if ( overallResult == BUY_CANT_AFFORD )
+	{
+		EmitPrivateSound( "BuyPreset.CantBuy" );
+	}
+	else if ( overallResult == BUY_ALREADY_HAVE )
+	{
+		EmitPrivateSound( "BuyPreset.AlreadyBought" );
+	}
+	else if ( overallResult == BUY_BOUGHT )
+	{
+		g_iAutoBuyPurchases++;
+	}
+}
+
+BuyResult_e CCSPlayer::CombineBuyResults( BuyResult_e prevResult, BuyResult_e newResult )
+{
+	if ( newResult == BUY_BOUGHT )
+	{
+		prevResult = BUY_BOUGHT;
+	}
+	else if ( prevResult != BUY_BOUGHT &&
+		(newResult == BUY_CANT_AFFORD || newResult == BUY_INVALID_ITEM || newResult == BUY_PLAYER_CANT_BUY ) )
+	{
+		prevResult = BUY_CANT_AFFORD;
+	}
+
+	return prevResult;
+}
+
+//==============================================
+//PostAutoBuyCommandProcessing
+//==============================================
+void CCSPlayer::PostAutoBuyCommandProcessing(const AutoBuyInfoStruct *commandInfo, bool &boughtPrimary, bool &boughtSecondary)
+{
+	if (commandInfo == NULL)
+	{
+		return;
+	}
+
+	CBaseCombatWeapon *pPrimary = Weapon_GetSlot( WEAPON_SLOT_RIFLE );
+	CBaseCombatWeapon *pSecondary = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+
+	if ((pPrimary != NULL) && (stricmp(pPrimary->GetClassname(), commandInfo->m_classname) == 0))
+	{
+		// I just bought the gun I was trying to buy.
+		boughtPrimary = true;
+	}
+	else if ((pPrimary == NULL) && ((commandInfo->m_class & AUTOBUYCLASS_SHIELD) == AUTOBUYCLASS_SHIELD) && HasShield())
+	{
+		// the shield is a primary weapon even though it isn't a "real" weapon.
+		boughtPrimary = true;
+	}
+	else if ((pSecondary != NULL) && (stricmp(pSecondary->GetClassname(), commandInfo->m_classname) == 0))
+	{
+		// I just bought the pistol I was trying to buy.
+		boughtSecondary = true;
+	}
+}
+
+bool CCSPlayer::ShouldExecuteAutoBuyCommand(const AutoBuyInfoStruct *commandInfo, bool boughtPrimary, bool boughtSecondary)
+{
+	if (commandInfo == NULL)
+	{
+		return false;
+	}
+
+	if ((boughtPrimary) && ((commandInfo->m_class & AUTOBUYCLASS_PRIMARY) != 0) && ((commandInfo->m_class & AUTOBUYCLASS_AMMO) == 0))
+	{
+		// this is a primary weapon and we already have one.
+		return false;
+	}
+
+	if ((boughtSecondary) && ((commandInfo->m_class & AUTOBUYCLASS_SECONDARY) != 0) && ((commandInfo->m_class & AUTOBUYCLASS_AMMO) == 0))
+	{
+		// this is a secondary weapon and we already have one.
+		return false;
+	}
+
+	if( commandInfo->m_class & AUTOBUYCLASS_ARMOR && ArmorValue() >= 100 )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+AutoBuyInfoStruct *CCSPlayer::GetAutoBuyCommandInfo(const char *command)
+{
+	int i = 0;
+	AutoBuyInfoStruct *ret = NULL;
+	AutoBuyInfoStruct *temp = &(g_autoBuyInfo[i]);
+
+	// loop through all the commands till we find the one that matches.
+	while ((ret == NULL) && (temp->m_class != (AutoBuyClassType)0))
+	{
+		temp = &(g_autoBuyInfo[i]);
+		++i;
+
+		if (stricmp(temp->m_command, command) == 0)
+		{
+			ret = temp;
+		}
+	}
+
+	return ret;
+}
+
+//==============================================
+//PostAutoBuyCommandProcessing
+//- reorders the tokens in autobuyString based on the order of tokens in the priorityString.
+//==============================================
+void CCSPlayer::PrioritizeAutoBuyString(char *autobuyString, const char *priorityString)
+{
+	char newString[256];
+	int newStringPos = 0;
+	char priorityToken[32];
+
+	if ((priorityString == NULL) || (autobuyString == NULL))
+	{
+		return;
+	}
+
+	const char *priorityChar = priorityString;
+
+	while (*priorityChar != 0)
+	{
+		int i = 0;
+
+		// get the next token from the priority string.
+		while ((*priorityChar != 0) && (*priorityChar != ' '))
+		{
+			priorityToken[i] = *priorityChar;
+			++i;
+			++priorityChar;
+		}
+		priorityToken[i] = 0;
+
+		// skip spaces
+		while (*priorityChar == ' ')
+		{
+			++priorityChar;
+		}
+
+		if (strlen(priorityToken) == 0)
+		{
+			continue;
+		}
+
+		// see if the priority token is in the autobuy string.
+		// if  it is, copy that token to the new string and blank out
+		// that token in the autobuy string.
+		char *autoBuyPosition = strstr(autobuyString, priorityToken);
+		if (autoBuyPosition != NULL)
+		{
+			while ((*autoBuyPosition != 0) && (*autoBuyPosition != ' '))
+			{
+				newString[newStringPos] = *autoBuyPosition;
+				*autoBuyPosition = ' ';
+				++newStringPos;
+				++autoBuyPosition;
+			}
+
+			newString[newStringPos++] = ' ';
+		}
+	}
+
+	// now just copy anything left in the autobuyString to the new string in the order it's in already.
+	char *autobuyPosition = autobuyString;
+	while (*autobuyPosition != 0)
+	{
+		// skip spaces
+		while (*autobuyPosition == ' ')
+		{
+			++autobuyPosition;
+		}
+
+		// copy the token over to the new string.
+		while ((*autobuyPosition != 0) && (*autobuyPosition != ' '))
+		{
+			newString[newStringPos] = *autobuyPosition;
+			++newStringPos;
+			++autobuyPosition;
+		}
+
+		// add a space at the end.
+		newString[newStringPos++] = ' ';
+	}
+
+	// terminate the string.  Trailing spaces shouldn't matter.
+	newString[newStringPos] = 0;
+
+	Q_snprintf(autobuyString, sizeof(autobuyString), "%s", newString);
+}
+
+
+//==============================================================
+// ReBuy
+// system for attempting to buy the weapons you had last round
+//==============================================================
+static void Rebuy( void )
+{
+	CCSPlayer *player = ToCSPlayer( UTIL_GetCommandClient() );
+
+	if ( player )
+		player->Rebuy();
+}
+static ConCommand rebuy( "rebuy", Rebuy, "Attempt to repurchase items with the order listed in cl_rebuy" );
+
+void CCSPlayer::BuildRebuyStruct()
+{
+	if (m_bIsInRebuy)
+	{
+		// if we are in the middle of a rebuy, we don't want to update the buy struct.
+		return;
+	}
+
+	CBaseCombatWeapon *primary = Weapon_GetSlot( WEAPON_SLOT_RIFLE );
+	CBaseCombatWeapon *secondary = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+
+	// do the primary weapon/ammo stuff.
+	if (primary == NULL)
+	{
+		// count a shieldgun as a primary.
+		if (HasShield())
+		{
+			//m_rebuyStruct.m_primaryWeapon = WEAPON_SHIELDGUN;
+			Q_strncpy( m_rebuyStruct.m_szPrimaryWeapon, "shield", sizeof(m_rebuyStruct.m_szPrimaryWeapon) );
+			m_rebuyStruct.m_primaryAmmo = 0; // shields don't have ammo.
+		}
+		else
+		{
+
+			m_rebuyStruct.m_szPrimaryWeapon[0] = 0;	// if we don't have a shield and we don't have a primary weapon, we got nuthin.
+			m_rebuyStruct.m_primaryAmmo = 0;		// can't have ammo if we don't have a gun right?
+		}
+	}
+	else
+	{
+		//strip off the "weapon_"
+
+		const char *wpnName = primary->GetClassname();
+
+		Q_strncpy( m_rebuyStruct.m_szPrimaryWeapon, wpnName + 7, sizeof(m_rebuyStruct.m_szPrimaryWeapon) );
+
+		if( primary->GetPrimaryAmmoType() != -1 )
+		{
+			m_rebuyStruct.m_primaryAmmo = GetAmmoCount( primary->GetPrimaryAmmoType() );
+		}
+	}
+
+	// do the secondary weapon/ammo stuff.
+	if (secondary == NULL)
+	{
+		m_rebuyStruct.m_szSecondaryWeapon[0] = 0;
+		m_rebuyStruct.m_secondaryAmmo = 0; // can't have ammo if we don't have a gun right?
+	}
+	else
+	{
+		const char *wpnName = secondary->GetClassname();
+
+		Q_strncpy( m_rebuyStruct.m_szSecondaryWeapon, wpnName + 7, sizeof(m_rebuyStruct.m_szSecondaryWeapon) );
+
+		if( secondary->GetPrimaryAmmoType() != -1 )
+		{
+			m_rebuyStruct.m_secondaryAmmo = GetAmmoCount( secondary->GetPrimaryAmmoType() );
+		}
+	}
+
+	CBaseCombatWeapon *pGrenade;
+
+	//MATTTODO: right now you can't buy more than one grenade. make it so you can
+	//buy more and query the number you have.
+	// HE Grenade
+	pGrenade = Weapon_OwnsThisType( "weapon_hegrenade" );
+	if ( pGrenade && pGrenade->GetPrimaryAmmoType() != -1 )
+	{
+		m_rebuyStruct.m_heGrenade = GetAmmoCount(pGrenade->GetPrimaryAmmoType());
+	}
+	else
+		m_rebuyStruct.m_heGrenade = 0;
+
+
+	// flashbang
+	pGrenade = Weapon_OwnsThisType( "weapon_flashbang" );
+	if ( pGrenade && pGrenade->GetPrimaryAmmoType() != -1 )
+	{
+		m_rebuyStruct.m_flashbang = GetAmmoCount(pGrenade->GetPrimaryAmmoType());
+	}
+	else
+		m_rebuyStruct.m_flashbang = 0;
+
+	// smokegrenade
+	pGrenade = Weapon_OwnsThisType( "weapon_smokegrenade" );
+	if ( pGrenade /*&& pGrenade->GetPrimaryAmmoType() != -1*/ )
+	{
+		m_rebuyStruct.m_smokeGrenade = 1; //GetAmmoCount(pGrenade->GetPrimaryAmmoType());
+	}
+	else
+		m_rebuyStruct.m_smokeGrenade = 0;
+
+	// defuser
+	m_rebuyStruct.m_defuser = HasDefuser();
+
+	// night vision
+	m_rebuyStruct.m_nightVision = m_bHasNightVision.Get();	//cast to avoid strange compiler warning
+
+	// check for armor.
+	m_rebuyStruct.m_armor = ( m_bHasHelmet ? 2 : ( ArmorValue() > 0 ? 1 : 0 ) );
+}
+
+void CCSPlayer::Rebuy( void )
+{
+	if ( !IsInBuyZone() )
+	{
+		EmitPrivateSound( "BuyPreset.CantBuy" );
+		return;
+	}
+
+	const char *rebuyString = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_rebuy" );
+	if ( !rebuyString || !*rebuyString )
+	{
+		EmitPrivateSound( "BuyPreset.AlreadyBought" );
+		return;
+	}
+
+	m_bIsInRebuy = true;
+	BuyResult_e overallResult = BUY_ALREADY_HAVE;
+
+	char token[256];
+	rebuyString = engine->ParseFile( rebuyString, token, sizeof( token ) );
+
+	while (rebuyString != NULL)
+	{
+		BuyResult_e result = BUY_ALREADY_HAVE;
+
+		if (!Q_strncmp(token, "PrimaryWeapon", 14))
+		{
+			result = RebuyPrimaryWeapon();
+		}
+		else if (!Q_strncmp(token, "PrimaryAmmo", 12))
+		{
+			result = RebuyPrimaryAmmo();
+		}
+		else if (!Q_strncmp(token, "SecondaryWeapon", 16))
+		{
+			result = RebuySecondaryWeapon();
+		}
+		else if (!Q_strncmp(token, "SecondaryAmmo", 14))
+		{
+			result = RebuySecondaryAmmo();
+		}
+		else if (!Q_strncmp(token, "HEGrenade", 10))
+		{
+			result = RebuyHEGrenade();
+		}
+		else if (!Q_strncmp(token, "Flashbang", 10))
+		{
+			result = RebuyFlashbang();
+		}
+		else if (!Q_strncmp(token, "SmokeGrenade", 13))
+		{
+			result = RebuySmokeGrenade();
+		}
+		else if (!Q_strncmp(token, "Defuser", 8))
+		{
+			result = RebuyDefuser();
+		}
+		else if (!Q_strncmp(token, "NightVision", 12))
+		{
+			result = RebuyNightVision();
+		}
+		else if (!Q_strncmp(token, "Armor", 6))
+		{
+			result = RebuyArmor();
+		}
+
+		overallResult = CombineBuyResults( overallResult, result );
+
+		rebuyString = engine->ParseFile( rebuyString, token, sizeof( token ) );
+	}
+
+	m_bIsInRebuy = false;
+
+	// after we're done buying, the user is done with their equipment purchasing experience.
+	// so we are effectively out of the buy zone.
+//	if (TheTutor != NULL)
+//	{
+//		TheTutor->OnEvent(EVENT_PLAYER_LEFT_BUY_ZONE);
+//	}
+
+	m_bAutoReload = true;
+
+	if ( overallResult == BUY_CANT_AFFORD )
+	{
+		EmitPrivateSound( "BuyPreset.CantBuy" );
+	}
+	else if ( overallResult == BUY_ALREADY_HAVE )
+	{
+		EmitPrivateSound( "BuyPreset.AlreadyBought" );
+	}
+	else if ( overallResult == BUY_BOUGHT )
+	{
+		g_iReBuyPurchases++;
+	}
+}
+
+BuyResult_e CCSPlayer::RebuyPrimaryWeapon()
+{
+	CBaseCombatWeapon *primary = Weapon_GetSlot( WEAPON_SLOT_RIFLE );
+	if (primary != NULL)
+	{
+		return BUY_ALREADY_HAVE;	// don't drop primary weapons via rebuy - if the player picked up a different weapon, he wants to keep it.
+	}
+
+	if( strlen( m_rebuyStruct.m_szPrimaryWeapon ) > 0 )
+		return HandleCommand_Buy(m_rebuyStruct.m_szPrimaryWeapon);
+
+	return BUY_ALREADY_HAVE;
+}
+
+BuyResult_e CCSPlayer::RebuySecondaryWeapon()
+{
+	CBaseCombatWeapon *pistol = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+	if (pistol != NULL && !m_bUsingDefaultPistol)
+	{
+		return BUY_ALREADY_HAVE;	// don't drop pistols via rebuy if we've bought one other than the default pistol
+	}
+
+	if( strlen( m_rebuyStruct.m_szSecondaryWeapon ) > 0 )
+		return HandleCommand_Buy(m_rebuyStruct.m_szSecondaryWeapon);
+
+	return BUY_ALREADY_HAVE;
+}
+
+BuyResult_e CCSPlayer::RebuyPrimaryAmmo()
+{
+	CBaseCombatWeapon *primary = Weapon_GetSlot( WEAPON_SLOT_RIFLE );
+
+	if (primary == NULL)
+	{
+		return BUY_ALREADY_HAVE;	// can't buy ammo when we don't even have a gun.
+	}
+
+	// Ensure that the weapon uses ammo
+	int nAmmo = primary->GetPrimaryAmmoType();
+	if ( nAmmo == -1 )
+	{
+		return BUY_ALREADY_HAVE;
+	}
+
+	// if we had more ammo before than we have now, buy more.
+	if (m_rebuyStruct.m_primaryAmmo > GetAmmoCount( nAmmo ))
+	{
+		return HandleCommand_Buy("primammo");
+	}
+
+	return BUY_ALREADY_HAVE;
+}
+
+
+BuyResult_e CCSPlayer::RebuySecondaryAmmo()
+{
+	CBaseCombatWeapon *secondary = Weapon_GetSlot( WEAPON_SLOT_PISTOL );
+
+	if (secondary == NULL)
+	{
+		return BUY_ALREADY_HAVE; // can't buy ammo when we don't even have a gun.
+	}
+
+	// Ensure that the weapon uses ammo
+	int nAmmo = secondary->GetPrimaryAmmoType();
+	if ( nAmmo == -1 )
+	{
+		return BUY_ALREADY_HAVE;
+	}
+
+	if (m_rebuyStruct.m_secondaryAmmo > GetAmmoCount( nAmmo ))
+	{
+		return HandleCommand_Buy("secammo");
+	}
+
+	return BUY_ALREADY_HAVE;
+}
+
+BuyResult_e CCSPlayer::RebuyHEGrenade()
+{
+	CBaseCombatWeapon *pGrenade = Weapon_OwnsThisType( "weapon_hegrenade" );
+
+	int numGrenades = 0;
+
+	if( pGrenade )
+	{
+		int nAmmo = pGrenade->GetPrimaryAmmoType();
+		if ( nAmmo == -1 )
+		{
+			return BUY_ALREADY_HAVE;
+		}
+
+		numGrenades = GetAmmoCount( nAmmo );
+	}
+
+	BuyResult_e overallResult = BUY_ALREADY_HAVE;
+	int numToBuy = MAX( 0, m_rebuyStruct.m_heGrenade - numGrenades );
+	for (int i = 0; i < numToBuy; ++i)
+	{
+		BuyResult_e result = HandleCommand_Buy("hegrenade");
+		overallResult = CombineBuyResults( overallResult, result );
+	}
+
+	return overallResult;
+}
+
+BuyResult_e CCSPlayer::RebuyFlashbang()
+{
+	CBaseCombatWeapon *pGrenade = Weapon_OwnsThisType( "weapon_flashbang" );
+
+	int numGrenades = 0;
+
+	if( pGrenade )
+	{
+		int nAmmo = pGrenade->GetPrimaryAmmoType();
+		if ( nAmmo == -1 )
+		{
+			return BUY_ALREADY_HAVE;
+		}
+		numGrenades = GetAmmoCount( nAmmo );
+
+	}
+
+	BuyResult_e overallResult = BUY_ALREADY_HAVE;
+	int numToBuy = MAX( 0, m_rebuyStruct.m_flashbang - numGrenades );
+	for (int i = 0; i < numToBuy; ++i)
+	{
+		BuyResult_e result = HandleCommand_Buy("flashbang");
+		overallResult = CombineBuyResults( overallResult, result );
+	}
+
+	return overallResult;
+}
+
+BuyResult_e CCSPlayer::RebuySmokeGrenade()
+{
+	CBaseCombatWeapon *pGrenade = Weapon_OwnsThisType( "weapon_smokegrenade" );
+
+	int numGrenades = 0;
+
+	if( pGrenade )
+	{
+		int nAmmo = pGrenade->GetPrimaryAmmoType();
+		if ( nAmmo == -1 )
+		{
+			return BUY_ALREADY_HAVE;
+		}
+
+		numGrenades = GetAmmoCount( nAmmo );
+	}
+
+	BuyResult_e overallResult = BUY_ALREADY_HAVE;
+	int numToBuy = MAX( 0, m_rebuyStruct.m_smokeGrenade - numGrenades );
+	for (int i = 0; i < numToBuy; ++i)
+	{
+		BuyResult_e result = HandleCommand_Buy("smokegrenade");
+		overallResult = CombineBuyResults( overallResult, result );
+	}
+
+	return overallResult;
+}
+
+BuyResult_e CCSPlayer::RebuyDefuser()
+{
+	//If we don't have a defuser, and we want one, buy it!
+	if( !HasDefuser() && m_rebuyStruct.m_defuser )
+	{
+		return HandleCommand_Buy("defuser");
+	}
+
+	return BUY_ALREADY_HAVE;
+}
+
+BuyResult_e CCSPlayer::RebuyNightVision()
+{
+	//if we don't have night vision and we want one, buy it!
+	if( !m_bHasNightVision && m_rebuyStruct.m_nightVision )
+	{
+		return HandleCommand_Buy("nvgs");
+	}
+
+	return BUY_ALREADY_HAVE;
+}
+
+BuyResult_e CCSPlayer::RebuyArmor()
+{
+	if (m_rebuyStruct.m_armor > 0 )
+	{
+		int armor = 0;
+
+		if( m_bHasHelmet )
+			armor = 2;
+		else if( ArmorValue() > 0 )
+			armor = 1;
+
+		if( armor < m_rebuyStruct.m_armor )
+		{
+			if (m_rebuyStruct.m_armor == 1)
+			{
+				return HandleCommand_Buy("vest");
+			}
+			else
+			{
+				return HandleCommand_Buy("vesthelm");
+			}
+		}
+
+	}
+
+	return BUY_ALREADY_HAVE;
+}
+
+bool CCSPlayer::IsUseableEntity( CBaseEntity *pEntity, unsigned int requiredCaps )
+{
+	CWeaponCSBase *pCSWepaon = dynamic_cast<CWeaponCSBase*>(pEntity);
+
+	if( pCSWepaon )
+	{
+		// we can't USE dropped weapons
+		return true;
+	}
+
+	CBaseCSGrenadeProjectile *pGrenade = dynamic_cast<CBaseCSGrenadeProjectile*>(pEntity);
+	if ( pGrenade )
+	{
+		// we can't USE thrown grenades
+	}
+
+	return BaseClass::IsUseableEntity( pEntity, requiredCaps );
+}
+
+CBaseEntity *CCSPlayer::FindUseEntity()
+{
+	CBaseEntity *entity = NULL;
+
+	// Check to see if the bomb is close enough to use before attempting to use anything else.
+
+	if ( CSGameRules()->IsBombDefuseMap() && GetTeamNumber() == TEAM_CT )
+	{
+		// This is done separately since there might be something blocking our LOS to it
+		// but we might want to use it anyway if it's close enough.  This should eliminate
+		// the vast majority of bomb placement exploits (places where the bomb can be planted
+		// but can't be "used".  This also mimics goldsrc cstrike behavior.
+		CBaseEntity *bomb = gEntList.FindEntityByClassname( NULL, PLANTED_C4_CLASSNAME );
+		if (bomb != NULL)
+		{
+			Vector bombPos = bomb->GetAbsOrigin();
+			Vector vecLOS = EyePosition() - bombPos;
+
+			if (vecLOS.LengthSqr() < (96*96)) // 64 is the distance in Goldsrc.  However since Goldsrc did distance from the player's origin and we're doing distance from the player's eye, make the radius a bit bigger.
+			{
+				// bomb is close enough, now make sure the player is facing the bomb.
+				Vector forward;
+				AngleVectors(EyeAngles(), &forward, NULL, NULL);
+
+				vecLOS.NormalizeInPlace();
+
+				float flDot = DotProduct(forward, vecLOS);
+				if (flDot < -0.7) // 0.7 taken from Goldsrc, +/- ~45 degrees
+				{
+					entity = bomb;
+				}
+			}
+		}
+	}
+
+	if ( entity == NULL )
+	{
+		entity = BaseClass::FindUseEntity();
+	}
+
+	return entity;
+}
+
+void CCSPlayer::StockPlayerAmmo( CBaseCombatWeapon *pNewWeapon )
+{
+	CWeaponCSBase *pWeapon =  dynamic_cast< CWeaponCSBase * >( pNewWeapon );
+
+	if ( pWeapon )
+	{
+		if ( pWeapon->GetWpnData().iFlags & ITEM_FLAG_EXHAUSTIBLE )
+			return;
+
+		int nAmmo = pWeapon->GetPrimaryAmmoType();
+
+		if ( nAmmo != -1 )
+		{
+			GiveAmmo( 9999, GetAmmoDef()->GetAmmoOfIndex(nAmmo)->pName );
+			pWeapon->m_iClip1 = pWeapon->GetMaxClip1();
+		}
+
+		return;
+	}
+
+	pWeapon = dynamic_cast< CWeaponCSBase * >(Weapon_GetSlot( WEAPON_SLOT_RIFLE ));
+
+	if ( pWeapon )
+	{
+		int nAmmo = pWeapon->GetPrimaryAmmoType();
+
+		if ( nAmmo != -1 )
+		{
+			GiveAmmo( 9999, GetAmmoDef()->GetAmmoOfIndex(nAmmo)->pName );
+			pWeapon->m_iClip1 = pWeapon->GetMaxClip1();
+		}
+	}
+
+	pWeapon = dynamic_cast< CWeaponCSBase * >(Weapon_GetSlot( WEAPON_SLOT_PISTOL ));
+
+	if ( pWeapon )
+	{
+		int nAmmo = pWeapon->GetPrimaryAmmoType();
+
+		if ( nAmmo != -1 )
+		{
+			GiveAmmo( 9999, GetAmmoDef()->GetAmmoOfIndex(nAmmo)->pName );
+			pWeapon->m_iClip1 = pWeapon->GetMaxClip1();
+		}
+	}
+}
+
+CBaseEntity	*CCSPlayer::GiveNamedItem( const char *pszName, int iSubType )
+{
+	EHANDLE pent;
+
+	if ( !pszName || !pszName[0] )
+		return  NULL;
+
+#ifndef CS_SHIELD_ENABLED
+	if ( !Q_stricmp( pszName, "weapon_shield" ) )
+		return NULL;
+#endif
+
+	pent = CreateEntityByName(pszName);
+	if ( pent == NULL )
+	{
+		Msg( "NULL Ent in GiveNamedItem!\n" );
+		return NULL;
+	}
+
+	pent->SetLocalOrigin( GetLocalOrigin() );
+	pent->AddSpawnFlags( SF_NORESPAWN );
+
+	CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon*>( (CBaseEntity*)pent );
+	if ( pWeapon )
+	{
+		if ( iSubType )
+		{
+			pWeapon->SetSubType( iSubType );
+		}
+	}
+
+	DispatchSpawn( pent );
+
+	m_bIsBeingGivenItem = true;
+	if ( pent != NULL && !(pent->IsMarkedForDeletion()) )
+	{
+		pent->Touch( this );
+	}
+	m_bIsBeingGivenItem = false;
+
+	StockPlayerAmmo( pWeapon );
+	return pent;
+}
+
+
+void CCSPlayer::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
+{
+	if ( event == PLAYERANIMEVENT_THROW_GRENADE )
+	{
+		// Grenade throwing has to synchronize exactly with the player's grenade weapon going away,
+		// and events get delayed a bit, so we let CCSPlayerAnimState pickup the change to this
+		// variable.
+		m_iThrowGrenadeCounter = (m_iThrowGrenadeCounter+1) % (1<<THROWGRENADE_COUNTER_BITS);
+	}
+	else
+	{
+		m_PlayerAnimState->DoAnimationEvent( event, nData );
+		TE_PlayerAnimEvent( this, event, nData );	// Send to any clients who can see this guy.
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+int CCSPlayer::FlashlightIsOn( void )
+{
+	return IsEffectActive( EF_DIMLIGHT );
+}
+
+extern ConVar flashlight;
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CCSPlayer::FlashlightTurnOn( void )
+{
+	if( flashlight.GetInt() > 0 && IsAlive() )
+	{
+		AddEffects( EF_DIMLIGHT );
+		EmitSound( "Player.FlashlightOn" );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CCSPlayer::FlashlightTurnOff( void )
+{
+	RemoveEffects( EF_DIMLIGHT );
+
+	if( IsAlive() )
+	{
+		EmitSound( "Player.FlashlightOff" );
+	}
+}
+
+
+//Drop the appropriate weapons:
+// Defuser if we have one
+// C4 if we have one
+// The best weapon we have, first check primary,
+// then secondary and drop the best one
+
+//=============================================================================
+// HPE_BEGIN:
+// [tj] Added a parameter so we know if it was death that caused the drop
+// [menglish] Clear all previously dropped equipment and add the c4 to the dropped equipment
+//=============================================================================
+ 
+void CCSPlayer::DropWeapons( bool fromDeath, bool friendlyFire )
+{
+	for ( int i = 0; i < DROPPED_COUNT; ++i )
+	{
+		m_hDroppedEquipment[i] = NULL;
+	}
+
+	CBaseCombatWeapon *pC4 = Weapon_OwnsThisType( "weapon_c4" );
+	if ( pC4 )
+	{
+		CSWeaponDrop( pC4, false, true );
+		if( fromDeath )
+		{
+			if( friendlyFire )
+			{
+				(static_cast<CC4*> (pC4))->SetDroppedFromDeath(true);
+			}
+			m_hDroppedEquipment[DROPPED_C4] = static_cast<CBaseEntity *>(pC4);
+		}
+	}
+
+	//NOTE: Function continues beyond comment block. This is just the part I touched.
+ 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+	if( HasDefuser() )
+	{
+		//Drop an item_defuser
+		Vector vForward, vRight;
+		AngleVectors( GetAbsAngles(), &vForward, &vRight, NULL );
+
+		CBaseAnimating *pDefuser = (CBaseAnimating *)CBaseEntity::Create( "item_defuser", WorldSpaceCenter(), GetLocalAngles(), this );
+		pDefuser->ApplyAbsVelocityImpulse( vForward * 200 + vRight * random->RandomFloat( -50, 50 ) );
+
+		RemoveDefuser();
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [menglish] Add the newly created defuser to the dropped equipment list
+		//=============================================================================
+		 
+		if(fromDeath)
+		{
+			m_hDroppedEquipment[DROPPED_DEFUSE] = static_cast<CBaseEntity *>(pDefuser);
+		}
+		 
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+	}
+
+	if( HasShield() )
+	{
+		DropShield();
+	}
+	else
+	{
+		//drop the best weapon we have
+		if( !DropRifle( true ) )
+			DropPistol( true );
+	}
+
+	// drop any live grenades so they explode
+	CBaseCSGrenade *pGrenade = dynamic_cast< CBaseCSGrenade * >(Weapon_OwnsThisType("weapon_hegrenade"));
+	if ( pGrenade && ( pGrenade->IsPinPulled() || pGrenade->IsBeingThrown() ) )
+	{
+		pGrenade->DropGrenade();
+		pGrenade->DecrementAmmo( this );
+	}
+	else
+	{
+		pGrenade = dynamic_cast< CBaseCSGrenade * >(Weapon_OwnsThisType("weapon_flashbang"));
+		if ( pGrenade && ( pGrenade->IsPinPulled() || pGrenade->IsBeingThrown() ) )
+		{
+			pGrenade->DropGrenade();
+			pGrenade->DecrementAmmo( this );
+		}
+		else
+		{
+			pGrenade = dynamic_cast< CBaseCSGrenade * >(Weapon_OwnsThisType("weapon_smokegrenade"));
+			if ( pGrenade && ( pGrenade->IsPinPulled() || pGrenade->IsBeingThrown() ) )
+			{
+				pGrenade->DropGrenade();
+				pGrenade->DecrementAmmo( this );
+			}
+		}
+	}
+
+	// drop the "best" grenade remaining
+	CBaseCombatWeapon *pWeapon = Weapon_OwnsThisType("weapon_hegrenade");
+	bool grenadeDrop = false;
+	if ( pWeapon && pWeapon->HasAmmo() )
+	{
+		grenadeDrop = CSWeaponDrop(pWeapon, false);
+	}
+	else
+	{
+		pWeapon = Weapon_OwnsThisType("weapon_flashbang");
+		if ( pWeapon && pWeapon->HasAmmo() )
+		{
+			grenadeDrop = CSWeaponDrop(pWeapon, false);
+		}
+		else
+		{
+			pWeapon = Weapon_OwnsThisType("weapon_smokegrenade");
+			if ( pWeapon && pWeapon->HasAmmo() )
+			{
+				grenadeDrop = CSWeaponDrop(pWeapon, false);
+			}
+		}
+	}
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Add whichever, if any, grenade was dropped
+	//=============================================================================
+
+	if( pWeapon && grenadeDrop )
+	{
+		m_hDroppedEquipment[DROPPED_GRENADE] = static_cast<CBaseEntity *>(pWeapon);
+	}
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Put the player in the specified team
+//-----------------------------------------------------------------------------
+void CCSPlayer::ChangeTeam( int iTeamNum )
+{
+	if ( !GetGlobalTeam( iTeamNum ) )
+	{
+		Warning( "CCSPlayer::ChangeTeam( %d ) - invalid team index.\n", iTeamNum );
+		return;
+	}
+
+	int iOldTeam = GetTeamNumber();
+
+	// if this is our current team, just abort
+	if ( iTeamNum == iOldTeam )
+		return;
+
+	//=============================================================================
+	// HPE_BEGIN:	
+	//=============================================================================
+	 
+	// [tj] Added a parameter so we know if it was death that caused the drop
+	// Drop Our best weapon
+	DropWeapons(false, false);
+
+	// [tj] Clear out dominations
+	RemoveNemesisRelationships();
+	 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	
+
+	// Always allow a change to spectator, and don't count it as one of our team changes.
+	// We now store the old team, so if a player changes once to one team, then to spectator,
+	// they won't be able to change back to their old old team, but will still be able to join
+	// the team they initially changed to.
+	if( iTeamNum != TEAM_SPECTATOR )
+	{
+		m_bTeamChanged = true;
+	}
+	else
+	{
+		m_iOldTeam = iOldTeam;
+	}
+
+	// do the team change:
+	BaseClass::ChangeTeam( iTeamNum );
+
+	//reset class
+	m_iClass = (int)CS_CLASS_NONE;
+
+	// update client state
+
+	if ( iTeamNum == TEAM_UNASSIGNED )
+	{
+		State_Transition( STATE_OBSERVER_MODE );
+	}
+	else if ( iTeamNum == TEAM_SPECTATOR )
+	{
+		//=============================================================================
+		// HPE_BEGIN:
+		// [tj] Removed these lines so players keep their money when switching to spectator.
+		//=============================================================================		
+		//Reset money
+		//m_iAccount = 0;		
+		//=============================================================================
+		// HPE_END
+		//=============================================================================		
+		RemoveAllItems( true );
+
+		State_Transition( STATE_OBSERVER_MODE );
+	}
+	else // active player
+	{
+		if ( iOldTeam == TEAM_SPECTATOR )
+		{
+			// If they're switching from being a spectator to ingame player
+			//=============================================================================
+			// HPE_BEGIN:
+			// [tj] Changed this so players either retain their existing money or, 
+			//		if they have less than the default, give them the default.
+			//=============================================================================
+			int startMoney = CSGameRules()->GetStartMoney();
+			if (startMoney > m_iAccount)
+			{
+				m_iAccount = startMoney;
+			} 			
+			//=============================================================================
+			// HPE_END
+			//============================================================================= 
+		}
+
+		// bots get to this state on TEAM_UNASSIGNED, yet they are marked alive.  Don't kill them.
+		else if ( iOldTeam != TEAM_UNASSIGNED  && !IsDead() )
+		{
+			// Kill player if switching teams while alive
+			CommitSuicide();
+		}
+
+		// Put up the class selection menu.
+		State_Transition( STATE_PICKINGCLASS );
+	}
+
+	// Initialize the player counts now that a player has switched teams
+	int NumDeadCT, NumDeadTerrorist, NumAliveTerrorist, NumAliveCT;
+	CSGameRules()->InitializePlayerCounts( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Put the player in the specified team without penalty
+//-----------------------------------------------------------------------------
+void CCSPlayer::SwitchTeam( int iTeamNum )
+{
+	if ( !GetGlobalTeam( iTeamNum ) || (iTeamNum != TEAM_CT && iTeamNum != TEAM_TERRORIST) )
+	{
+		Warning( "CCSPlayer::SwitchTeam( %d ) - invalid team index.\n", iTeamNum );
+		return;
+	}
+
+	int iOldTeam = GetTeamNumber();
+
+	// if this is our current team, just abort
+	if ( iTeamNum == iOldTeam )
+		return;
+
+	// Always allow a change to spectator, and don't count it as one of our team changes.
+	// We now store the old team, so if a player changes once to one team, then to spectator,
+	// they won't be able to change back to their old old team, but will still be able to join
+	// the team they initially changed to.
+	m_bTeamChanged = true;
+
+	// do the team change:
+	BaseClass::ChangeTeam( iTeamNum );
+
+	if( HasDefuser() )
+	{
+		RemoveDefuser();
+	}
+
+	//reset class
+	switch ( m_iClass )
+	{
+	// Terrorist -> CT
+	case CS_CLASS_PHOENIX_CONNNECTION:
+		m_iClass = (int)CS_CLASS_SEAL_TEAM_6;
+		break;
+	case CS_CLASS_L337_KREW:
+		m_iClass = (int)CS_CLASS_GSG_9;
+		break;
+	case CS_CLASS_ARCTIC_AVENGERS:
+		m_iClass = (int)CS_CLASS_SAS;
+		break;
+	case CS_CLASS_GUERILLA_WARFARE:
+		m_iClass = (int)CS_CLASS_GIGN;
+		break;
+
+	// CT -> Terrorist
+	case CS_CLASS_SEAL_TEAM_6:
+		m_iClass = (int)CS_CLASS_PHOENIX_CONNNECTION;
+		break;
+	case CS_CLASS_GSG_9:
+		m_iClass = (int)CS_CLASS_L337_KREW;
+		break;
+	case CS_CLASS_SAS:
+		m_iClass = (int)CS_CLASS_ARCTIC_AVENGERS;
+		break;
+	case CS_CLASS_GIGN:
+		m_iClass = (int)CS_CLASS_GUERILLA_WARFARE;
+		break;
+
+	case CS_CLASS_NONE:
+	default:
+		break;
+	}
+
+	// Initialize the player counts now that a player has switched teams
+	int NumDeadCT, NumDeadTerrorist, NumAliveTerrorist, NumAliveCT;
+	CSGameRules()->InitializePlayerCounts( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT );
+}
+
+void CCSPlayer::ModifyOrAppendPlayerCriteria( AI_CriteriaSet& set )
+{
+	// this is for giving player info to the hostage response system
+	// and is as yet unused.
+	// Eventually we could give the hostage a few tidbits about this player,
+	// eg their health, what weapons they have, and the hostage could
+	// comment accordingly.
+
+	//do not append any player data to the Criteria!
+
+	//we don't know which player we should be caring about
+}
+
+static unsigned int s_BulletGroupCounter = 0;
+
+void CCSPlayer::StartNewBulletGroup()
+{
+	s_BulletGroupCounter++;
+}
+
+//=======================================================
+// Remember this amount of damage that we dealt for stats
+//=======================================================
+void CCSPlayer::RecordDamageGiven( const char *szDamageTaker, int iDamageGiven )
+{
+	FOR_EACH_LL( m_DamageGivenList, i )
+	{
+		if( Q_strncmp( szDamageTaker, m_DamageGivenList[i]->GetPlayerName(), MAX_PLAYER_NAME_LENGTH ) == 0 )
+		{
+			m_DamageGivenList[i]->AddDamage( iDamageGiven, s_BulletGroupCounter );
+			return;
+		}
+	}
+
+	CDamageRecord *record = new CDamageRecord( szDamageTaker, iDamageGiven, s_BulletGroupCounter );
+	int k = m_DamageGivenList.AddToTail();
+	m_DamageGivenList[k] = record;
+}
+
+//=======================================================
+// Remember this amount of damage that we took for stats
+//=======================================================
+void CCSPlayer::RecordDamageTaken( const char *szDamageDealer, int iDamageTaken )
+{
+	FOR_EACH_LL( m_DamageTakenList, i )
+	{
+		if( Q_strncmp( szDamageDealer, m_DamageTakenList[i]->GetPlayerName(), MAX_PLAYER_NAME_LENGTH ) == 0 )
+		{
+			m_DamageTakenList[i]->AddDamage( iDamageTaken, s_BulletGroupCounter );
+			return;
+		}
+	}
+
+	CDamageRecord *record = new CDamageRecord( szDamageDealer, iDamageTaken, s_BulletGroupCounter );
+	int k = m_DamageTakenList.AddToTail();
+	m_DamageTakenList[k] = record;
+}
+
+//=======================================================
+// Reset our damage given and taken counters
+//=======================================================
+void CCSPlayer::ResetDamageCounters()
+{
+	m_DamageGivenList.PurgeAndDeleteElements();
+	m_DamageTakenList.PurgeAndDeleteElements();
+}
+
+//=======================================================
+// Output the damage that we dealt to other players
+//=======================================================
+void CCSPlayer::OutputDamageTaken( void )
+{
+	bool bPrintHeader = true;
+	CDamageRecord *pRecord;
+	char buf[64];
+	int msg_dest = HUD_PRINTCONSOLE;
+
+	FOR_EACH_LL( m_DamageTakenList, i )
+	{
+		if( bPrintHeader )
+		{
+			ClientPrint( this, msg_dest, "Player: %s1 - Damage Taken\n", GetPlayerName() );
+			ClientPrint( this, msg_dest, "-------------------------\n" );
+			bPrintHeader = false;
+		}
+		pRecord = m_DamageTakenList[i];
+
+		if( pRecord )
+		{
+			if (pRecord->GetNumHits() == 1)
+			{
+				Q_snprintf( buf, sizeof(buf), "%d in %d hit", pRecord->GetDamage(), pRecord->GetNumHits() );
+			}
+			else
+			{
+				Q_snprintf( buf, sizeof(buf), "%d in %d hits", pRecord->GetDamage(), pRecord->GetNumHits() );
+			}
+			ClientPrint( this, msg_dest, "Damage Taken from \"%s1\" - %s2\n", pRecord->GetPlayerName(), buf );
+		}
+	}
+}
+
+//=======================================================
+// Output the damage that we took from other players
+//=======================================================
+void CCSPlayer::OutputDamageGiven( void )
+{
+	bool bPrintHeader = true;
+	CDamageRecord *pRecord;
+	char buf[64];
+	int msg_dest = HUD_PRINTCONSOLE;
+
+	FOR_EACH_LL( m_DamageGivenList, i )
+	{
+		if( bPrintHeader )
+		{
+			ClientPrint( this, msg_dest, "Player: %s1 - Damage Given\n", GetPlayerName() );
+			ClientPrint( this, msg_dest, "-------------------------\n" );
+			bPrintHeader = false;
+		}
+
+		pRecord = m_DamageGivenList[i];
+
+		if( pRecord )
+		{
+			if (pRecord->GetNumHits() == 1)
+			{
+				Q_snprintf( buf, sizeof(buf), "%d in %d hit", pRecord->GetDamage(), pRecord->GetNumHits() );
+			}
+			else
+			{
+				Q_snprintf( buf, sizeof(buf), "%d in %d hits", pRecord->GetDamage(), pRecord->GetNumHits() );
+			}
+			ClientPrint( this, msg_dest, "Damage Given to \"%s1\" - %s2\n", pRecord->GetPlayerName(), buf );
+		}
+	}
+}
+
+void CCSPlayer::CreateViewModel( int index /*=0*/ )
+{
+	Assert( index >= 0 && index < MAX_VIEWMODELS );
+
+	if ( GetViewModel( index ) )
+		return;
+
+	CPredictedViewModel *vm = ( CPredictedViewModel * )CreateEntityByName( "predicted_viewmodel" );
+	if ( vm )
+	{
+		vm->SetAbsOrigin( GetAbsOrigin() );
+		vm->SetOwner( this );
+		vm->SetIndex( index );
+		DispatchSpawn( vm );
+		vm->FollowEntity( this, false );
+		m_hViewModel.Set( index, vm );
+	}
+}
+
+bool CCSPlayer::HasC4() const
+{
+	return ( Weapon_OwnsThisType( "weapon_c4" ) != NULL );
+}
+
+int CCSPlayer::GetNextObserverSearchStartPoint( bool bReverse )
+{
+	// If we are currently watching someone who is dead, they must have died while we were watching (since
+	// a dead guy is not a valid pick to start watching).  He was given his killer as an observer target
+	// when he died, so let's start by trying to observe his killer.  If we fail, we'll use the normal way.
+	// And this is just the start point anyway, but we want to start the search here in case it is okay.
+	if( m_hObserverTarget && !m_hObserverTarget->IsAlive() )
+	{
+		CCSPlayer *targetPlayer = ToCSPlayer(m_hObserverTarget);
+		if( targetPlayer && targetPlayer->GetObserverTarget() )
+			return targetPlayer->GetObserverTarget()->entindex();
+	}
+
+	return BaseClass::GetNextObserverSearchStartPoint( bReverse );
+}
+
+void CCSPlayer::PlayStepSound( Vector &vecOrigin, surfacedata_t *psurface, float fvol, bool force )
+{
+	BaseClass::PlayStepSound( vecOrigin, psurface, fvol, force );
+
+	if ( !sv_footsteps.GetFloat() )
+		return;
+
+	if ( !psurface )
+		return;
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_footstep" );
+	if ( event )
+	{
+		event->SetInt("userid", GetUserID() );
+		gameeventmanager->FireEvent( event );
+	}
+
+	m_bMadeFootstepNoise = true;
+}
+
+
+void CCSPlayer::SelectDeathPose( const CTakeDamageInfo &info )
+{
+	MDLCACHE_CRITICAL_SECTION();
+	if ( !GetModelPtr() )
+		return;
+
+	Activity aActivity = ACT_INVALID;
+	int iDeathFrame = 0;
+
+	SelectDeathPoseActivityAndFrame( this, info, m_LastHitGroup, aActivity, iDeathFrame );
+	if ( aActivity == ACT_INVALID )
+	{
+		SetDeathPose( ACT_INVALID );
+		SetDeathPoseFrame( 0 );
+		return;
+	}
+
+	SetDeathPose( SelectWeightedSequence( aActivity ) );
+	SetDeathPoseFrame( iDeathFrame );
+}
+
+
+void CCSPlayer::HandleAnimEvent( animevent_t *pEvent )
+{
+	if ( pEvent->event == 4001 || pEvent->event == 4002 )
+	{
+		// Ignore these for now - soon we will be playing footstep sounds based on these events
+		// that mark footfalls in the anims.
+	}
+	else
+	{
+		BaseClass::HandleAnimEvent( pEvent );
+	}
+}
+
+
+bool CCSPlayer::CanChangeName( void )
+{
+	if ( IsBot() )
+		return true;
+
+	// enforce the minimum interval
+	if ( (m_flNameChangeHistory[0] + MIN_NAME_CHANGE_INTERVAL) >= gpGlobals->curtime )
+	{
+		return false;
+	}
+
+	// enforce that we dont do more than NAME_CHANGE_HISTORY_SIZE
+	// changes within NAME_CHANGE_HISTORY_INTERVAL
+	if ( (m_flNameChangeHistory[NAME_CHANGE_HISTORY_SIZE-1] + NAME_CHANGE_HISTORY_INTERVAL) >= gpGlobals->curtime )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+void CCSPlayer::ChangeName( const char *pszNewName )
+{
+	// make sure name is not too long
+	char trimmedName[MAX_PLAYER_NAME_LENGTH];
+	Q_strncpy( trimmedName, pszNewName, sizeof( trimmedName ) );
+
+	const char *pszOldName = GetPlayerName();
+
+	// send colored message to everyone
+	CReliableBroadcastRecipientFilter filter;
+	UTIL_SayText2Filter( filter, this, false, "#Cstrike_Name_Change", pszOldName, trimmedName );
+
+	// broadcast event
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_changename" );
+	if ( event )
+	{
+		event->SetInt( "userid", GetUserID() );
+		event->SetString( "oldname", pszOldName );
+		event->SetString( "newname", trimmedName );
+		gameeventmanager->FireEvent( event );
+	}
+
+	// change shared player name
+	SetPlayerName( trimmedName );
+
+	// tell engine to use new name
+	engine->ClientCommand( edict(), "name \"%s\"", trimmedName );
+
+	// remember time of name change
+	for ( int i=NAME_CHANGE_HISTORY_SIZE-1; i>0; i-- )
+	{
+		m_flNameChangeHistory[i] = m_flNameChangeHistory[i-1];
+	}
+
+	m_flNameChangeHistory[0] = gpGlobals->curtime; // last change
+}
+
+bool CCSPlayer::StartReplayMode( float fDelay, float fDuration, int iEntity )
+{
+	if ( !BaseClass::StartReplayMode( fDelay, fDuration, iEntity ) )
+		return false;
+
+	CSingleUserRecipientFilter filter( this );
+	filter.MakeReliable();
+
+	UserMessageBegin( filter, "KillCam" );
+		WRITE_BYTE( OBS_MODE_IN_EYE );
+
+		if ( m_hObserverTarget.Get() )
+		{
+			WRITE_BYTE( m_hObserverTarget.Get()->entindex() );	// first target
+			WRITE_BYTE( entindex() );	//second target
+		}
+		else
+		{
+			WRITE_BYTE( entindex() );	// first target
+			WRITE_BYTE( 0 );	//second target
+		}
+	MessageEnd();
+
+	ClientPrint( this, HUD_PRINTCENTER, "Kill Cam Replay" );
+
+	return true;
+}
+
+void CCSPlayer::StopReplayMode()
+{
+	BaseClass::StopReplayMode();
+
+	CSingleUserRecipientFilter filter( this );
+	filter.MakeReliable();
+
+	UserMessageBegin( filter, "KillCam" );
+		WRITE_BYTE( OBS_MODE_NONE );
+		WRITE_BYTE( 0 );
+		WRITE_BYTE( 0 );
+	MessageEnd();
+}
+
+void CCSPlayer::PlayUseDenySound()
+{
+	// Don't do a sound here because it can mute your footsteps giving you an advantage.
+	// The CS:S content for this sound is silent anyways.
+	//EmitSound( "Player.UseDeny" );
+}
+
+//=============================================================================
+// HPE_BEGIN:
+//=============================================================================
+
+// [menglish, tj] This is where we reset all the per-round information for achievements for this player
+void CCSPlayer::ResetRoundBasedAchievementVariables()
+{
+	m_KillingSpreeStartTime = -1;
+
+	int numCTPlayers = 0, numTPlayers = 0;
+	for (int i = 0; i < g_Teams.Count(); i++ )
+	{
+		if(g_Teams[i])
+		{
+			if ( g_Teams[i]->GetTeamNumber() == TEAM_CT )
+				numCTPlayers = g_Teams[i]->GetNumPlayers();
+			else if(g_Teams[i]->GetTeamNumber() == TEAM_TERRORIST)
+				numTPlayers = g_Teams[i]->GetNumPlayers();
+		}
+	}
+	m_NumEnemiesKilledThisRound = 0;
+	if(GetTeamNumber() == TEAM_CT)
+		m_NumEnemiesAtRoundStart = numTPlayers;
+	else if(GetTeamNumber() == TEAM_TERRORIST)
+		m_NumEnemiesAtRoundStart = numCTPlayers;
+
+
+	//Clear the previous owner field for currently held weapons
+	CWeaponCSBase* pWeapon = dynamic_cast< CWeaponCSBase * >(Weapon_GetSlot( WEAPON_SLOT_RIFLE ));
+	if ( pWeapon )
+	{
+		pWeapon->SetPreviousOwner(NULL);
+	}
+	pWeapon = dynamic_cast< CWeaponCSBase * >(Weapon_GetSlot( WEAPON_SLOT_PISTOL));
+	if ( pWeapon )
+	{
+		pWeapon->SetPreviousOwner(NULL);
+	}
+
+	//Clear list of weapons used to get kills
+	m_killWeapons.RemoveAll();
+
+	//Clear sliding window of kill times
+	m_killTimes.RemoveAll();
+
+	//clear round kills
+	m_enemyPlayersKilledThisRound.RemoveAll();
+
+	m_killsWhileBlind = 0;
+
+	m_bSurvivedHeadshotDueToHelmet = false;
+
+	m_gooseChaseStep = GC_NONE;
+	m_defuseDefenseStep = DD_NONE;
+	m_pGooseChaseDistractingPlayer = NULL;
+
+	m_bMadeFootstepNoise = false;
+
+	m_bombPickupTime = -1;
+
+	m_bMadePurchseThisRound = false;
+
+	m_bKilledDefuser = false;
+	m_bKilledRescuer = false;
+	m_maxGrenadeKills = 0;
+	m_grenadeDamageTakenThisRound = 0;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [dwenger] Needed for fun-fact implementation
+	//=============================================================================
+
+	WieldingKnifeAndKilledByGun(false);
+
+	m_WeaponTypesUsed.RemoveAll();
+
+	m_bPickedUpDefuser = false;
+	m_bDefusedWithPickedUpKit = false;
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+}
+
+
+/**
+ *	static public CCSPlayer::GetCSWeaponIDCausingDamage()
+ *
+ *		Helper function to get the ID of the weapon used to kill a player.
+ *		This is slightly non-trivial because the grenade because a separate
+ *		entity when thrown.
+ *
+ *  Parameters:
+ * 		info -
+ *			
+ *	Returns:
+ *		int -
+ */
+CSWeaponID CCSPlayer::GetWeaponIdCausingDamange( const CTakeDamageInfo &info )
+{
+	CBaseEntity *pInflictor = info.GetInflictor();
+	CCSPlayer *pAttacker = ToCSPlayer(info.GetAttacker());
+	if (pAttacker == pInflictor)
+	{
+		CWeaponCSBase* pAttackerWeapon = dynamic_cast< CWeaponCSBase * >(pAttacker->GetActiveWeapon());
+		if (!pAttackerWeapon)
+			return WEAPON_NONE;
+
+		return pAttackerWeapon->GetWeaponID();
+	}
+	else if (pInflictor && V_strcmp(pInflictor->GetClassname(), "hegrenade_projectile") == 0)
+	{
+		return WEAPON_HEGRENADE;
+	}
+	return WEAPON_NONE;
+}
+
+
+//=============================================================================
+// HPE_BEGIN:
+// [dwenger] adding tracking for weapon used fun fact
+//=============================================================================
+void CCSPlayer::PlayerUsedFirearm( CBaseCombatWeapon* pBaseWeapon )
+{
+	if ( pBaseWeapon )
+	{
+		CWeaponCSBase* pWeapon = dynamic_cast< CWeaponCSBase* >( pBaseWeapon );
+
+		if ( pWeapon )
+		{
+			CSWeaponType weaponType = pWeapon->GetCSWpnData().m_WeaponType;
+			CSWeaponID weaponID = pWeapon->GetWeaponID();
+
+			if ( weaponType != WEAPONTYPE_KNIFE && weaponType != WEAPONTYPE_C4 && weaponType != WEAPONTYPE_GRENADE )
+			{
+				if ( m_WeaponTypesUsed.Find( weaponID ) == -1 )
+				{
+					// Add this weapon to the list of weapons used by the player
+					m_WeaponTypesUsed.AddToTail( weaponID );
+				}
+			}
+		}
+	}
+}
+
+
+/**
+ *	public CCSPlayer::ProcessPlayerDeathAchievements()
+ *
+ *		Do Achievement processing whenever a player is killed
+ *
+ *  Parameters:
+ * 		pAttacker -
+ * 		pVictim -
+ * 		info -
+ */
+void CCSPlayer::ProcessPlayerDeathAchievements( CCSPlayer *pAttacker, CCSPlayer *pVictim, const CTakeDamageInfo &info )
+{
+	Assert(pVictim != NULL);
+	CBaseEntity *pInflictor = info.GetInflictor();	
+  
+	// all these achievements require a valid attacker on a different team
+	if ( pAttacker != NULL && pVictim != NULL && pVictim->GetTeamNumber() != pAttacker->GetTeamNumber() )
+	{
+		// get the weapon used - some of the achievements will need this data
+		CWeaponCSBase* pAttackerWeapon = dynamic_cast< CWeaponCSBase * >(pAttacker->GetActiveWeapon());
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [dwenger] Fun-fact processing
+		//=============================================================================
+
+		CWeaponCSBase* pVictimWeapon = dynamic_cast< CWeaponCSBase* >(pVictim->GetActiveWeapon());
+
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+		CSWeaponID attackerWeaponId = GetWeaponIdCausingDamange(info);
+
+		if (pVictim->m_bIsDefusing)
+		{
+			pAttacker->AwardAchievement(CSKilledDefuser);			
+			pAttacker->m_bKilledDefuser = true;
+
+			if (attackerWeaponId == WEAPON_HEGRENADE)
+			{
+				pAttacker->AwardAchievement(CSKilledDefuserWithGrenade);
+			}
+		}
+
+		// [pfreese] Achievement check for attacker killing player while reloading
+		if (pVictim->IsReloading())
+		{
+			pAttacker->AwardAchievement(CSKillEnemyReloading);
+		}
+
+		if (pVictim->IsRescuing())
+		{
+			// Ensure the killer did not injure any hostages
+			if ( !pAttacker->InjuredAHostage() && pVictim->GetNumFollowers() == g_Hostages.Count() )
+			{
+				pAttacker->AwardAchievement(CSKilledRescuer);
+				pAttacker->m_bKilledRescuer = true;
+			}
+		}
+
+		// [menglish] Achievement check for doing 95% or more damage to a player and having another player kill them
+		FOR_EACH_LL( pVictim->m_DamageTakenList, i )
+		{
+			if( pVictim->m_DamageTakenList[i]->GetDamage() >= pVictim->GetMaxHealth() - AchievementConsts::DamageNoKill_MaxHealthLeftOnKill &&
+				Q_strncmp( pAttacker->GetPlayerName(), pVictim->m_DamageTakenList[i]->GetPlayerName(), MAX_PLAYER_NAME_LENGTH ) != 0 )
+			{
+				//Now find the player who did that amount of damage
+				for ( int j = 1; j <= MAX_PLAYERS; j++ )
+				{
+					CBasePlayer *pPlayerIter = UTIL_PlayerByIndex( j );
+
+					if ( pPlayerIter && Q_strncmp( pPlayerIter->GetPlayerName(), pVictim->m_DamageTakenList[i]->GetPlayerName(), MAX_PLAYER_NAME_LENGTH ) == 0  &&
+						pPlayerIter->GetTeamNumber() != pVictim->GetTeamNumber() )
+					{
+						ToCSPlayer(pPlayerIter)->AwardAchievement(CSDamageNoKill);
+						break;
+					}
+				}
+			}
+		}
+
+		pAttacker->m_NumEnemiesKilledThisRound++;
+
+		//store a list of kill times for spree tracking
+		pAttacker->m_killTimes.AddToTail(gpGlobals->curtime);
+
+		//Add the victim to the list of players killed this round
+		pAttacker->m_enemyPlayersKilledThisRound.AddToTail(pVictim);
+
+		//Calculate Avenging for all players the victim has killed
+		for ( int avengedIndex = 0; avengedIndex < pVictim->m_enemyPlayersKilledThisRound.Count(); avengedIndex++ )        
+		{
+			CCSPlayer* avengedPlayer = pVictim->m_enemyPlayersKilledThisRound[avengedIndex];
+
+			if (avengedPlayer)
+			{
+				//Make sure you are avenging someone on your own team (This is the expected flow. Just here to avoid edge cases like team-switching).
+				if (pAttacker->GetTeamNumber() == avengedPlayer->GetTeamNumber())
+				{
+					CCS_GameStats.Event_PlayerAvengedTeammate(pAttacker, pVictim->m_enemyPlayersKilledThisRound[avengedIndex]);
+				}
+			}
+		}
+
+
+
+		//remove elements older than a certain time
+		while (pAttacker->m_killTimes.Count() > 0 && pAttacker->m_killTimes[0] + AchievementConsts::KillingSpree_WindowTime < gpGlobals->curtime)
+		{
+			pAttacker->m_killTimes.Remove(0);
+		}
+
+		//If we killed enough players in the time window, award the achievement
+		if (pAttacker->m_killTimes.Count() >= AchievementConsts::KillingSpree_Kills)
+		{
+			pAttacker->m_KillingSpreeStartTime = gpGlobals->curtime;
+			pAttacker->AwardAchievement(CSKillingSpree);
+		}
+
+		// Did the attacker just kill someone on a killing spree?
+		if (pVictim->m_KillingSpreeStartTime >= 0 && pVictim->m_KillingSpreeStartTime - gpGlobals->curtime <= AchievementConsts::KillingSpreeEnder_TimeWindow)
+		{
+			pAttacker->AwardAchievement(CSKillingSpreeEnder);
+		}
+
+		//Check the "killed someone with their own weapon" achievement
+		if (pAttackerWeapon && pAttackerWeapon->GetPreviousOwner() == pVictim)
+		{
+			pAttacker->AwardAchievement(CSKillEnemyWithFormerGun);
+		}
+
+		//If this player has killed the entire team award him the achievement
+		if (pAttacker->m_NumEnemiesKilledThisRound == pAttacker->m_NumEnemiesAtRoundStart && pAttacker->m_NumEnemiesKilledThisRound >= AchievementConsts::KillEnemyTeam_MinKills)
+		{
+			pAttacker->AwardAchievement(CSKillEnemyTeam);
+		}
+
+		//If this is a posthumous kill award the achievement
+		if (!pAttacker->IsAlive() && attackerWeaponId == WEAPON_HEGRENADE)
+		{
+			CCS_GameStats.IncrementStat(pAttacker, CSSTAT_GRENADE_POSTHUMOUSKILLS, 1);
+			ToCSPlayer(pAttacker)->AwardAchievement(CSPosthumousGrenadeKill);
+		}
+
+		if (pAttacker->GetActiveWeapon() && pAttacker->GetActiveWeapon()->Clip1() == 0 && pAttackerWeapon && pAttackerWeapon->GetCSWpnData().m_WeaponType != WEAPONTYPE_SNIPER_RIFLE)
+		{
+			if (pInflictor == pAttacker)
+			{
+				pAttacker->AwardAchievement(CSKillEnemyLastBullet);
+				CCS_GameStats.IncrementStat(pAttacker, CSSTAT_KILLS_WITH_LAST_ROUND, 1);
+			}
+		}
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [dwenger] Fun-fact processing
+		//=============================================================================
+
+		if (pVictimWeapon && pVictimWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_KNIFE && pAttackerWeapon &&
+			pAttackerWeapon->GetCSWpnData().m_WeaponType != WEAPONTYPE_KNIFE && pAttackerWeapon->GetCSWpnData().m_WeaponType != WEAPONTYPE_C4 && pAttackerWeapon->GetCSWpnData().m_WeaponType != WEAPONTYPE_GRENADE)
+		{
+			// Victim was wielding knife when killed by a gun
+			pVictim->WieldingKnifeAndKilledByGun(true);
+		}
+
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+		//see if this is a unique weapon		
+		if (attackerWeaponId != WEAPON_NONE)
+		{
+			if (pAttacker->m_killWeapons.Find(attackerWeaponId) == -1)
+			{
+				pAttacker->m_killWeapons.AddToTail(attackerWeaponId);
+				if (pAttacker->m_killWeapons.Count() >= AchievementConsts::KillsWithMultipleGuns_MinWeapons)
+				{
+					pAttacker->AwardAchievement(CSKillsWithMultipleGuns);					
+				}
+			}
+		}
+
+		//Check for kills while blind
+		if (pAttacker->IsBlindForAchievement())
+		{
+			//if this is from a different blinding, restart the kill counter and set the time
+			if (pAttacker->m_blindStartTime != pAttacker->m_firstKillBlindStartTime)
+			{
+				pAttacker->m_killsWhileBlind = 0;
+				pAttacker->m_firstKillBlindStartTime = pAttacker->m_blindStartTime;
+			}
+
+			++pAttacker->m_killsWhileBlind;
+			if (pAttacker->m_killsWhileBlind >= AchievementConsts::KillEnemiesWhileBlind_Kills)
+			{
+				pAttacker->AwardAchievement(CSKillEnemiesWhileBlind);
+			}
+
+			if (pAttacker->m_killsWhileBlind >= AchievementConsts::KillEnemiesWhileBlindHard_Kills)
+			{
+				pAttacker->AwardAchievement(CSKillEnemiesWhileBlindHard);
+			}
+		}
+
+		//Check sniper killing achievements
+		bool victimZoomed = ( pVictim->GetFOV() != pVictim->GetDefaultFOV() );
+		bool attackerZoomed = ( pAttacker->GetFOV() != pAttacker->GetDefaultFOV() );
+		bool attackerUsedSniperRifle = pAttackerWeapon && pAttackerWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_SNIPER_RIFLE && pInflictor == pAttacker;
+		if (victimZoomed && attackerUsedSniperRifle)
+		{
+			pAttacker->AwardAchievement(CSKillSniperWithSniper);
+		}
+
+		if (attackerWeaponId == WEAPON_KNIFE && victimZoomed)
+		{
+			pAttacker->AwardAchievement(CSKillSniperWithKnife);
+		}
+		if (attackerUsedSniperRifle && !attackerZoomed)
+		{
+			pAttacker->AwardAchievement(CSHipShot);
+		}
+
+		//Kill a player at low health
+		if (pAttacker->IsAlive() && pAttacker->GetHealth() <= AchievementConsts::KillWhenAtLowHealth_MaxHealth)
+		{
+			pAttacker->AwardAchievement(CSKillWhenAtLowHealth);
+		}
+
+		//Kill a player with a knife during the pistol round
+		if (CSGameRules()->IsPistolRound())
+		{
+			if (attackerWeaponId == WEAPON_KNIFE)
+			{
+				pAttacker->AwardAchievement(CSPistolRoundKnifeKill);
+			}
+		}
+
+		//[tj] Check for dual elites fight
+		CWeaponCSBase* victimWeapon = pVictim->GetActiveCSWeapon();
+
+		if (victimWeapon)
+		{
+			CSWeaponID victimWeaponID = victimWeapon->GetWeaponID();
+
+			if (attackerWeaponId == WEAPON_ELITE && victimWeaponID == WEAPON_ELITE)
+			{
+				pAttacker->AwardAchievement(CSWinDualDuel);
+			}
+		}
+
+		//[tj] See if the attacker or defender are in the air [sbodenbender] dont include ladders
+		bool attackerInAir = pAttacker->GetMoveType() != MOVETYPE_LADDER && pAttacker->GetNearestSurfaceBelow(AchievementConsts::KillInAir_MinimumHeight) == NULL;
+		bool victimInAir = pVictim->GetMoveType() != MOVETYPE_LADDER && pVictim->GetNearestSurfaceBelow(AchievementConsts::KillInAir_MinimumHeight) == NULL;
+
+		if (attackerInAir)
+		{
+			pAttacker->AwardAchievement(CSKillWhileInAir);
+		}
+		if (victimInAir)
+		{
+			pAttacker->AwardAchievement(CSKillEnemyInAir);
+		}
+		if (attackerInAir && victimInAir)
+		{
+			pAttacker->AwardAchievement(CSKillerAndEnemyInAir);
+		}
+
+		//[tj] advance to the next stage of the defuse defense achievement
+		if (pAttacker->m_defuseDefenseStep == DD_STARTED_DEFUSE)
+		{
+			pAttacker->m_defuseDefenseStep = DD_KILLED_TERRORIST;            
+		}
+
+		if (pVictim->HasC4() && pVictim->GetBombPickuptime() + AchievementConsts::KillBombPickup_MaxTime > gpGlobals->curtime)
+		{
+			pAttacker->AwardAchievement(CSKillBombPickup);
+		}
+		
+	}
+
+
+	//If you kill a friendly player while blind (from an enemy player), give the guy that blinded you an achievement    
+	if ( pAttacker != NULL && pVictim != NULL && pVictim->GetTeamNumber() == pAttacker->GetTeamNumber() && pAttacker->IsBlind())
+	{
+		CCSPlayer* flashbangAttacker = pAttacker->GetLastFlashbangAttacker();
+		if (flashbangAttacker && pAttacker->GetTeamNumber() != flashbangAttacker->GetTeamNumber())
+		{
+			flashbangAttacker->AwardAchievement(CSCauseFriendlyFireWithFlashbang);
+		}
+	}
+
+	// do a scan to determine count of players still alive
+	int livePlayerCount = 0;
+	int teamCount[TEAM_MAXCOUNT];
+	int teamIgnoreCount[TEAM_MAXCOUNT];
+	memset(teamCount, 0, sizeof(teamCount));
+	memset(teamIgnoreCount, 0, sizeof(teamIgnoreCount));
+	CCSPlayer *pAlivePlayer = NULL;
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CCSPlayer* pPlayer = (CCSPlayer*)UTIL_PlayerByIndex( i );
+		if (pPlayer)
+		{
+			int teamNum = pPlayer->GetTeamNumber();
+			if ( teamNum >= 0 )
+			{
+				++teamCount[teamNum];
+				if (pPlayer->WasNotKilledNaturally())
+				{
+					teamIgnoreCount[teamNum]++;
+				}
+			}
+			if (pPlayer->IsAlive() && pPlayer != pVictim)
+			{
+				++livePlayerCount;
+				pAlivePlayer = pPlayer;
+			}
+		}
+	}
+
+	// Achievement check for being the last player alive in a match
+	if (pAlivePlayer)
+	{		
+		int alivePlayerTeam = pAlivePlayer->GetTeamNumber();
+		int alivePlayerOpposingTeam = alivePlayerTeam == TEAM_CT ? TEAM_TERRORIST : TEAM_CT;
+		if (livePlayerCount == 1 
+			&& CSGameRules()->m_iRoundWinStatus == WINNER_NONE
+			&& teamCount[alivePlayerTeam] - teamIgnoreCount[alivePlayerTeam] >= AchievementConsts::LastPlayerAlive_MinPlayersOnTeam
+			&& teamCount[alivePlayerOpposingTeam] - teamIgnoreCount[alivePlayerOpposingTeam] >= AchievementConsts::DefaultMinOpponentsForAchievement
+			&& ( !(pAlivePlayer->m_iDisplayHistoryBits & DHF_FRIEND_KILLED) ))
+		{
+			pAlivePlayer->AwardAchievement(CSLastPlayerAlive);
+		}
+	}
+
+	// [tj] Added hook into player killed stat that happens before weapon drop
+	CCS_GameStats.Event_PlayerKilled_PreWeaponDrop(pVictim, info);
+}
+
+//[tj]  traces up to maxTrace units down and returns any standable object it hits
+//      (doesn't check slope for standability)
+CBaseEntity* CCSPlayer::GetNearestSurfaceBelow(float maxTrace)
+{
+	trace_t trace;
+	Ray_t ray;
+
+	Vector traceStart = this->GetAbsOrigin();
+	Vector traceEnd = traceStart;
+	traceEnd.z -= maxTrace;
+
+	Vector minExtent = this->m_Local.m_bDucked  ? VEC_DUCK_HULL_MIN_SCALED( this ) : VEC_HULL_MIN_SCALED( this );
+	Vector maxExtent = this->m_Local.m_bDucked  ? VEC_DUCK_HULL_MAX_SCALED( this ) : VEC_HULL_MAX_SCALED( this );
+
+	ray.Init( traceStart, traceEnd, minExtent, maxExtent );
+	UTIL_TraceRay( ray, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
+
+	return trace.m_pEnt;
+}
+
+// [tj] Added a way to react to the round ending before we reset.
+//      It is important to note that this happens before the bomb explodes, so a player may die
+//      after this from a bomb explosion or a late kill after a defuse/detonation/rescue.
+void CCSPlayer::OnRoundEnd(int winningTeam, int reason)
+{    
+	if (winningTeam == WINNER_CT || winningTeam == WINNER_TER)
+	{
+		int losingTeamId = (winningTeam == TEAM_CT) ? TEAM_TERRORIST : TEAM_CT;
+		
+		CTeam* losingTeam = GetGlobalTeam(losingTeamId);
+
+		int losingTeamPlayers = 0;
+
+		if (losingTeam)
+		{
+			losingTeamPlayers = losingTeam->GetNumPlayers();
+			
+			int ignoreCount = 0;
+			for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+			{
+				CCSPlayer* pPlayer = (CCSPlayer*)UTIL_PlayerByIndex( i );
+				if (pPlayer)
+				{
+					int teamNum = pPlayer->GetTeamNumber();
+					if ( teamNum == losingTeamId )
+					{					
+						if (pPlayer->WasNotKilledNaturally())
+						{
+							ignoreCount++;
+						}
+					}
+					
+				}
+			}
+
+			losingTeamPlayers -= ignoreCount;
+		}
+
+		//Check fast round win achievement
+		if (    IsAlive() && 
+				gpGlobals->curtime - CSGameRules()->GetRoundStartTime() < AchievementConsts::FastRoundWin_Time &&
+				GetTeamNumber() == winningTeam &&
+				losingTeamPlayers >= AchievementConsts::DefaultMinOpponentsForAchievement)
+		{
+			AwardAchievement(CSFastRoundWin);
+		}
+
+		//Check goosechase achievement
+		if (IsAlive() && reason == Target_Bombed && m_gooseChaseStep == GC_STOPPED_AFTER_GETTING_SHOT && m_pGooseChaseDistractingPlayer)
+		{
+			m_pGooseChaseDistractingPlayer->AwardAchievement(CSGooseChase);
+		}
+
+		//Check Defuse Defense achievement
+		if (IsAlive() && reason == Bomb_Defused && m_defuseDefenseStep == DD_KILLED_TERRORIST)
+		{
+			AwardAchievement(CSDefuseDefense);
+		}
+
+		//Check silent win
+		if (m_NumEnemiesKilledThisRound > 0 && GetTeamNumber() == winningTeam && !m_bMadeFootstepNoise)
+		{
+			AwardAchievement(CSSilentWin);
+		}
+
+		//Process && Check "win rounds without buying" achievement
+		if (GetTeamNumber() == winningTeam && !m_bMadePurchseThisRound)
+		{
+			m_roundsWonWithoutPurchase++;
+			if (m_roundsWonWithoutPurchase > AchievementConsts::WinRoundsWithoutBuying_Rounds)
+			{
+				AwardAchievement(CSWinRoundsWithoutBuying);
+			}
+		}
+		else
+		{
+			m_roundsWonWithoutPurchase = 0;
+		}
+	}
+
+	m_lastRoundResult = reason;
+}
+
+void CCSPlayer::OnPreResetRound()
+{
+	//Check headshot survival achievement
+	if (IsAlive() && m_bSurvivedHeadshotDueToHelmet)
+	{
+		AwardAchievement(CSSurvivedHeadshotDueToHelmet);
+	}
+
+	if (IsAlive() && m_grenadeDamageTakenThisRound > AchievementConsts::SurviveGrenade_MinDamage)
+	{
+		AwardAchievement(CSSurviveGrenade);
+	}
+
+
+	//Check achievement for surviving attacks from multiple players.
+	if (IsAlive())
+	{
+		int numberOfEnemyDamagers = GetNumEnemyDamagers();
+
+		if (numberOfEnemyDamagers >= AchievementConsts::SurviveManyAttacks_NumberDamagingPlayers)
+		{
+			AwardAchievement(CSSurviveManyAttacks);
+		}
+	}
+}
+
+void CCSPlayer::OnCanceledDefuse()
+{
+	if (m_gooseChaseStep == GC_SHOT_DURING_DEFUSE)
+	{
+		m_gooseChaseStep = GC_STOPPED_AFTER_GETTING_SHOT;
+	}
+}
+
+
+void CCSPlayer::OnStartedDefuse()
+{
+	if (m_defuseDefenseStep == DD_NONE)
+	{
+		m_defuseDefenseStep = DD_STARTED_DEFUSE;
+	}
+}
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSPlayer::AttemptToExitFreezeCam( void )
+{
+	float fEndFreezeTravel = m_flDeathTime + CS_DEATH_ANIMATION_TIME + spec_freeze_traveltime.GetFloat();
+	if ( gpGlobals->curtime < fEndFreezeTravel )
+		return;
+
+	m_bAbortFreezeCam = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets whether this player is dominating the specified other player
+//-----------------------------------------------------------------------------
+void CCSPlayer::SetPlayerDominated( CCSPlayer *pPlayer, bool bDominated )
+{
+	int iPlayerIndex = pPlayer->entindex();
+	m_bPlayerDominated.Set( iPlayerIndex, bDominated );
+	pPlayer->SetPlayerDominatingMe( this, bDominated );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets whether this player is being dominated by the other player
+//-----------------------------------------------------------------------------
+void CCSPlayer::SetPlayerDominatingMe( CCSPlayer *pPlayer, bool bDominated )
+{
+	int iPlayerIndex = pPlayer->entindex();
+	m_bPlayerDominatingMe.Set( iPlayerIndex, bDominated );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether this player is dominating the specified other player
+//-----------------------------------------------------------------------------
+bool CCSPlayer::IsPlayerDominated( int iPlayerIndex )
+{
+	return m_bPlayerDominated.Get( iPlayerIndex );
+}
+
+bool CCSPlayer::IsPlayerDominatingMe( int iPlayerIndex )
+{
+	return m_bPlayerDominatingMe.Get( iPlayerIndex );
+}
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] MVP functions
+//=============================================================================
+ 
+void CCSPlayer::IncrementNumMVPs( CSMvpReason_t mvpReason )
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [Forrest] Allow MVP to be turned off for a server
+	//=============================================================================
+	if ( sv_nomvp.GetBool() )
+	{
+		Msg( "Round MVP disabled: sv_nomvp is set.\n" );
+		return;
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	m_iMVPs++;
+	CCS_GameStats.Event_MVPEarned( this );
+	IGameEvent *mvpEvent = gameeventmanager->CreateEvent( "round_mvp" );
+
+	if ( mvpEvent )
+	{
+		mvpEvent->SetInt( "userid", GetUserID() );
+		mvpEvent->SetInt( "reason", mvpReason );
+		gameeventmanager->FireEvent( mvpEvent );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the number of rounds this player has caused to be won for their team
+//-----------------------------------------------------------------------------
+void CCSPlayer::SetNumMVPs( int iNumMVP )
+{
+	m_iMVPs = iNumMVP;
+}
+//-----------------------------------------------------------------------------
+// Purpose: Returns the number of rounds this player has caused to be won for their team
+//-----------------------------------------------------------------------------
+int CCSPlayer::GetNumMVPs()
+{
+	return m_iMVPs;
+}
+ 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Purpose: Removes all nemesis relationships between this player and others
+//-----------------------------------------------------------------------------
+void CCSPlayer::RemoveNemesisRelationships()
+{
+	for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
+	{
+		CCSPlayer *pTemp = ToCSPlayer( UTIL_PlayerByIndex( i ) );
+		if ( pTemp && pTemp != this )
+		{        
+			// set this player to be not dominating anyone else
+			SetPlayerDominated( pTemp, false );
+
+			// set no one else to be dominating this player		
+			pTemp->SetPlayerDominated( this, false );
+		}
+	}	
+}
+
+void CCSPlayer::CheckMaxGrenadeKills(int grenadeKills)
+{
+	if (grenadeKills > m_maxGrenadeKills)
+	{
+		m_maxGrenadeKills = grenadeKills;
+	}
+}
+
+void CCSPlayer::CommitSuicide( bool bExplode /*= false*/, bool bForce /*= false*/ )
+{
+	m_wasNotKilledNaturally = true;
+	BaseClass::CommitSuicide(bExplode, bForce);
+}
+
+void CCSPlayer::CommitSuicide( const Vector &vecForce, bool bExplode /*= false*/, bool bForce /*= false*/ )
+{
+	m_wasNotKilledNaturally = true;
+	BaseClass::CommitSuicide(vecForce, bExplode, bForce);
+}
+
+int CCSPlayer::GetNumEnemyDamagers()
+{
+	int numberOfEnemyDamagers = 0;
+	FOR_EACH_LL( m_DamageTakenList, i )
+	{
+		for ( int j = 1; j <= MAX_PLAYERS; j++ )
+		{
+			CBasePlayer *pPlayer = UTIL_PlayerByIndex( j );
+
+			if ( pPlayer && V_strncmp( pPlayer->GetPlayerName(), m_DamageTakenList[i]->GetPlayerName(), MAX_PLAYER_NAME_LENGTH ) == 0  &&
+				pPlayer->GetTeamNumber() != GetTeamNumber() )
+			{
+				numberOfEnemyDamagers++;
+			}
+		}
+	}
+	return numberOfEnemyDamagers;
+}
+
+
+int CCSPlayer::GetNumEnemiesDamaged()
+{
+	int numberOfEnemiesDamaged = 0;
+	FOR_EACH_LL( m_DamageGivenList, i )
+	{
+		for ( int j = 1; j <= MAX_PLAYERS; j++ )
+		{
+			CBasePlayer *pPlayer = UTIL_PlayerByIndex( j );
+
+			if ( pPlayer && V_strncmp( pPlayer->GetPlayerName(), m_DamageGivenList[i]->GetPlayerName(), MAX_PLAYER_NAME_LENGTH ) == 0  &&
+				pPlayer->GetTeamNumber() != GetTeamNumber() )
+			{
+				numberOfEnemiesDamaged++;
+			}
+		}
+	}
+	return numberOfEnemiesDamaged;
+}
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+void UTIL_AwardMoneyToTeam( int iAmount, int iTeam, CBaseEntity *pIgnore )
+{
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+
+		if ( !pPlayer )
+			continue;
+
+		if ( pPlayer->GetTeamNumber() != iTeam )
+			continue;
+
+		if ( pPlayer == pIgnore )
+			continue;
+
+		pPlayer->AddAccount( iAmount );
+	}
+}
+
diff --git a/game/server/cstrike/cs_player.h b/game/server/cstrike/cs_player.h
new file mode 100644
index 00000000..9abf96a6
--- /dev/null
+++ b/game/server/cstrike/cs_player.h
@@ -0,0 +1,1116 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Player for HL1.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_PLAYER_H
+#define CS_PLAYER_H
+#pragma once
+
+
+#include "basemultiplayerplayer.h"
+#include "server_class.h"
+#include "cs_playeranimstate.h"
+#include "cs_shareddefs.h"
+#include "cs_autobuy.h"
+#include "utldict.h"
+
+
+
+class CWeaponCSBase;
+class CMenu;
+class CHintMessageQueue;
+class CNavArea;
+
+#include "cs_weapon_parse.h"
+
+
+void UTIL_AwardMoneyToTeam( int iAmount, int iTeam, CBaseEntity *pIgnore );
+
+#define MENU_STRING_BUFFER_SIZE	1024
+#define MENU_MSG_TEXTCHUNK_SIZE	50
+
+enum
+{
+	MIN_NAME_CHANGE_INTERVAL = 10,			// minimum number of seconds between name changes
+	NAME_CHANGE_HISTORY_SIZE = 5,			// number of times a player can change names in NAME_CHANGE_HISTORY_INTERVAL
+	NAME_CHANGE_HISTORY_INTERVAL = 600,	// no more than NAME_CHANGE_HISTORY_SIZE name changes can be made in this many seconds
+};
+
+extern ConVar bot_mimic;
+
+
+// Function table for each player state.
+class CCSPlayerStateInfo
+{
+public:
+	CSPlayerState m_iPlayerState;
+	const char *m_pStateName;
+	
+	void (CCSPlayer::*pfnEnterState)();	// Init and deinit the state.
+	void (CCSPlayer::*pfnLeaveState)();
+
+	void (CCSPlayer::*pfnPreThink)();	// Do a PreThink() in this state.
+};
+
+
+//=======================================
+//Record of either damage taken or given.
+//Contains the player name that we hurt or that hurt us,
+//and the total damage
+//=======================================
+class CDamageRecord
+{
+public:
+	CDamageRecord( const char *name, int iDamage, int iCounter )
+	{
+		Q_strncpy( m_szPlayerName, name, sizeof(m_szPlayerName) );
+		m_iDamage = iDamage;
+		m_iNumHits = 1;
+		m_iLastBulletUpdate = iCounter;
+	}
+
+	void AddDamage( int iDamage, int iCounter )
+	{
+		m_iDamage += iDamage;
+
+		if ( m_iLastBulletUpdate != iCounter )
+			m_iNumHits++;
+
+		m_iLastBulletUpdate = iCounter;
+	}
+
+	char *GetPlayerName( void ) { return m_szPlayerName; }
+	int GetDamage( void ) { return m_iDamage; }
+	int GetNumHits( void ) { return m_iNumHits; }
+
+private:
+	char m_szPlayerName[MAX_PLAYER_NAME_LENGTH];
+	int m_iDamage;		//how much damage was done
+	int m_iNumHits;		//how many hits
+	int	m_iLastBulletUpdate; // update counter
+};
+
+// Message display history (CCSPlayer::m_iDisplayHistoryBits)
+// These bits are set when hint messages are displayed, and cleared at
+// different times, according to the DHM_xxx bitmasks that follow
+
+#define DHF_ROUND_STARTED		( 1 << 1 )
+#define DHF_HOSTAGE_SEEN_FAR	( 1 << 2 )
+#define DHF_HOSTAGE_SEEN_NEAR	( 1 << 3 )
+#define DHF_HOSTAGE_USED		( 1 << 4 )
+#define DHF_HOSTAGE_INJURED		( 1 << 5 )
+#define DHF_HOSTAGE_KILLED		( 1 << 6 )
+#define DHF_FRIEND_SEEN			( 1 << 7 )
+#define DHF_ENEMY_SEEN			( 1 << 8 )
+#define DHF_FRIEND_INJURED		( 1 << 9 )
+#define DHF_FRIEND_KILLED		( 1 << 10 )
+#define DHF_ENEMY_KILLED		( 1 << 11 )
+#define DHF_BOMB_RETRIEVED		( 1 << 12 )
+#define DHF_AMMO_EXHAUSTED		( 1 << 15 )
+#define DHF_IN_TARGET_ZONE		( 1 << 16 )
+#define DHF_IN_RESCUE_ZONE		( 1 << 17 )
+#define DHF_IN_ESCAPE_ZONE		( 1 << 18 ) // unimplemented
+#define DHF_IN_VIPSAFETY_ZONE	( 1 << 19 ) // unimplemented
+#define	DHF_NIGHTVISION			( 1 << 20 )
+#define	DHF_HOSTAGE_CTMOVE		( 1 << 21 )
+#define	DHF_SPEC_DUCK			( 1 << 22 )
+
+// DHF_xxx bits to clear when the round restarts
+
+#define DHM_ROUND_CLEAR ( \
+	DHF_ROUND_STARTED | \
+	DHF_HOSTAGE_KILLED | \
+	DHF_FRIEND_KILLED | \
+	DHF_BOMB_RETRIEVED )
+
+
+// DHF_xxx bits to clear when the player is restored
+
+#define DHM_CONNECT_CLEAR ( \
+	DHF_HOSTAGE_SEEN_FAR | \
+	DHF_HOSTAGE_SEEN_NEAR | \
+	DHF_HOSTAGE_USED | \
+	DHF_HOSTAGE_INJURED | \
+	DHF_FRIEND_SEEN | \
+	DHF_ENEMY_SEEN | \
+	DHF_FRIEND_INJURED | \
+	DHF_ENEMY_KILLED | \
+	DHF_AMMO_EXHAUSTED | \
+	DHF_IN_TARGET_ZONE | \
+	DHF_IN_RESCUE_ZONE | \
+	DHF_IN_ESCAPE_ZONE | \
+	DHF_IN_VIPSAFETY_ZONE | \
+	DHF_HOSTAGE_CTMOVE | \
+	DHF_SPEC_DUCK )
+
+// radio messages (these must be kept in sync with actual radio) -------------------------------------
+enum RadioType
+{
+	RADIO_INVALID = 0,
+
+	RADIO_START_1,							///< radio messages between this and RADIO_START_2 and part of Radio1()
+
+	RADIO_COVER_ME,
+	RADIO_YOU_TAKE_THE_POINT,
+	RADIO_HOLD_THIS_POSITION,
+	RADIO_REGROUP_TEAM,
+	RADIO_FOLLOW_ME,
+	RADIO_TAKING_FIRE,
+
+	RADIO_START_2,							///< radio messages between this and RADIO_START_3 are part of Radio2()
+
+	RADIO_GO_GO_GO,
+	RADIO_TEAM_FALL_BACK,
+	RADIO_STICK_TOGETHER_TEAM,
+	RADIO_GET_IN_POSITION_AND_WAIT,
+	RADIO_STORM_THE_FRONT,
+	RADIO_REPORT_IN_TEAM,
+
+	RADIO_START_3,							///< radio messages above this are part of Radio3()
+
+	RADIO_AFFIRMATIVE,
+	RADIO_ENEMY_SPOTTED,
+	RADIO_NEED_BACKUP,
+	RADIO_SECTOR_CLEAR,
+	RADIO_IN_POSITION,
+	RADIO_REPORTING_IN,
+	RADIO_GET_OUT_OF_THERE,
+	RADIO_NEGATIVE,
+	RADIO_ENEMY_DOWN,
+
+	RADIO_END,
+
+	RADIO_NUM_EVENTS
+};
+
+extern const char *RadioEventName[ RADIO_NUM_EVENTS+1 ];
+
+/**
+ * Convert name to RadioType
+ */
+extern RadioType NameToRadioEvent( const char *name );
+
+enum BuyResult_e
+{
+	BUY_BOUGHT,
+	BUY_ALREADY_HAVE,
+	BUY_CANT_AFFORD,
+	BUY_PLAYER_CANT_BUY,	// not in the buy zone, is the VIP, is past the timelimit, etc
+	BUY_NOT_ALLOWED,		// weapon is restricted by VIP mode, team, etc
+	BUY_INVALID_ITEM,
+};
+
+//=============================================================================
+// HPE_BEGIN:
+//=============================================================================
+
+// [tj] The phases for the "Goose Chase" achievement
+enum GooseChaseAchievementStep
+{
+    GC_NONE,    
+    GC_SHOT_DURING_DEFUSE,
+    GC_STOPPED_AFTER_GETTING_SHOT
+};
+
+// [tj] The phases for the "Defuse Defense" achievement
+enum DefuseDefenseAchivementStep
+{
+    DD_NONE,
+    DD_STARTED_DEFUSE,
+    DD_KILLED_TERRORIST       
+};
+ 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+//=============================================================================
+// >> CounterStrike player
+//=============================================================================
+class CCSPlayer : public CBaseMultiplayerPlayer, public ICSPlayerAnimStateHelpers
+{
+public:
+	DECLARE_CLASS( CCSPlayer, CBaseMultiplayerPlayer );
+	DECLARE_SERVERCLASS();
+	DECLARE_PREDICTABLE();
+	DECLARE_DATADESC();
+
+	CCSPlayer();
+	~CCSPlayer();
+
+	static CCSPlayer *CreatePlayer( const char *className, edict_t *ed );
+	static CCSPlayer* Instance( int iEnt );
+
+	virtual void		Precache();
+	virtual void		Spawn();
+	virtual void		InitialSpawn( void );
+	
+	virtual void		CheatImpulseCommands( int iImpulse );
+	virtual void		PlayerRunCommand( CUserCmd *ucmd, IMoveHelper *moveHelper );
+	virtual void		PostThink();
+
+	virtual int			OnTakeDamage( const CTakeDamageInfo &inputInfo );
+	virtual int			OnTakeDamage_Alive( const CTakeDamageInfo &info );
+
+	virtual void		Event_Killed( const CTakeDamageInfo &info );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] We have a custom implementation so we can check for achievements.
+	//=============================================================================
+	
+	virtual void		Event_KilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info );
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	virtual void		TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
+
+	virtual CBaseEntity	*GiveNamedItem( const char *pszName, int iSubType = 0 );
+	virtual bool		IsBeingGivenItem() const { return m_bIsBeingGivenItem; }
+	
+	virtual CBaseEntity *FindUseEntity( void );
+	virtual bool		IsUseableEntity( CBaseEntity *pEntity, unsigned int requiredCaps );
+	
+	virtual void		CreateViewModel( int viewmodelindex = 0 );
+	virtual void		ShowViewPortPanel( const char * name, bool bShow = true, KeyValues *data = NULL );
+
+	// This passes the event to the client's and server's CPlayerAnimState.
+	void DoAnimationEvent( PlayerAnimEvent_t event, int nData = 0 );
+
+	// from CBasePlayer
+	virtual void		SetupVisibility( CBaseEntity *pViewEntity, unsigned char *pvs, int pvssize );
+
+	virtual int 		GetNextObserverSearchStartPoint( bool bReverse );
+// In shared code.
+public:
+
+	// ICSPlayerAnimState overrides.
+	virtual CWeaponCSBase* CSAnim_GetActiveWeapon();
+	virtual bool CSAnim_CanMove();
+
+	virtual float GetPlayerMaxSpeed();
+
+	void FireBullet( 
+		Vector vecSrc, 
+		const QAngle &shootAngles, 
+		float flDistance, 
+		int iPenetration, 
+		int iBulletType, 
+		int iDamage, 
+		float flRangeModifier, 
+		CBaseEntity *pevAttacker,
+		bool bDoEffects,
+		float xSpread, float ySpread );
+
+	void KickBack(
+		float up_base,
+		float lateral_base,
+		float up_modifier,
+		float lateral_modifier,
+		float up_max,
+		float lateral_max,
+		int direction_change );
+
+	void GetBulletTypeParameters( 
+		int iBulletType, 
+		float &fPenetrationPower, 
+		float &flPenetrationDistance );
+
+	// Returns true if the player is allowed to move.
+	bool CanMove() const;
+
+	void OnJump( float fImpulse );
+	void OnLand( float fVelocity );
+
+	bool HasC4() const;	// Is this player carrying a C4 bomb?
+	bool IsVIP() const;
+
+	int GetClass( void ) const;
+
+	void MakeVIP( bool isVIP );
+
+	virtual void SetAnimation( PLAYER_ANIM playerAnim );
+	ICSPlayerAnimState *GetPlayerAnimState() { return m_PlayerAnimState; }
+
+	virtual bool StartReplayMode( float fDelay, float fDuration, int iEntity );
+	virtual void StopReplayMode();
+	virtual void PlayUseDenySound();
+
+
+public:
+
+	// Simulates a single frame of movement for a player
+	void RunPlayerMove( const QAngle& viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, float frametime );
+	virtual void HandleAnimEvent( animevent_t *pEvent );
+
+	virtual void UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity  );
+	virtual void PlayStepSound( Vector &vecOrigin, surfacedata_t *psurface, float fvol, bool force );
+	
+	// from cbasecombatcharacter
+	void InitVCollision( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity );
+	void VPhysicsShadowUpdate( IPhysicsObject *pPhysics );
+	
+	bool HasShield() const;
+	bool IsShieldDrawn() const;
+	void GiveShield( void );
+	void RemoveShield( void );
+	bool IsProtectedByShield( void ) const;		// returns true if player has a shield and is currently hidden behind it
+
+	bool HasPrimaryWeapon( void );
+	bool HasSecondaryWeapon( void );
+
+	bool IsReloading( void ) const;				// returns true if current weapon is reloading
+
+	void GiveDefaultItems();
+	void RemoveAllItems( bool removeSuit );	//overridden to remove the defuser
+
+	// Reset account, get rid of shield, etc..
+	void Reset();
+
+	void RoundRespawn( void );
+	void ObserverRoundRespawn( void );
+	void CheckTKPunishment( void );
+
+	// Add money to this player's account.
+	void AddAccount( int amount, bool bTrackChange=true, bool bItemBought=false, const char *pItemName = NULL );
+
+	void HintMessage( const char *pMessage, bool bDisplayIfDead, bool bOverrideClientSettings = false ); // Displays a hint message to the player
+	CHintMessageQueue *m_pHintMessageQueue;
+	unsigned int m_iDisplayHistoryBits;
+	bool m_bShowHints;
+	float m_flLastAttackedTeammate;
+	float m_flNextMouseoverUpdate;
+	void UpdateMouseoverHints();
+
+	// mark this player as not receiving money at the start of the next round.
+	void MarkAsNotReceivingMoneyNextRound();
+	bool DoesPlayerGetRoundStartMoney(); // self-explanitory :)
+
+	void DropC4();	// Get rid of the C4 bomb.
+	
+	bool HasDefuser();		// Is this player carrying a bomb defuser?
+	void GiveDefuser(bool bPickedUp = false);		// give the player a defuser
+	void RemoveDefuser();	// remove defuser from the player and remove the model attachment
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [dwenger] Added for fun-fact support
+    //=============================================================================
+
+    bool PickedUpDefuser() { return m_bPickedUpDefuser; }
+    void SetDefusedWithPickedUpKit(bool bDefusedWithPickedUpKit) { m_bDefusedWithPickedUpKit = bDefusedWithPickedUpKit; }
+    bool GetDefusedWithPickedUpKit() { return m_bDefusedWithPickedUpKit; }
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+
+	//=============================================================================
+	// HPE_BEGIN
+	// [sbodenbender] Need a different test for player blindness for the achievements
+	//=============================================================================
+
+	bool IsBlindForAchievement();	// more stringent than IsBlind; more accurately represents when the player can see again
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	bool IsBlind( void ) const;		// return true if this player is blind (from a flashbang)
+	virtual void Blind( float holdTime, float fadeTime, float startingAlpha = 255 );	// player blinded by a flashbang
+	float m_blindUntilTime;
+	float m_blindStartTime;
+
+	void Deafen( float flDistance );		//make the player deaf / apply dsp preset to muffle sound
+
+	void ApplyDeafnessEffect();				// apply the deafness effect for a nearby explosion.
+
+	bool IsAutoFollowAllowed( void ) const;		// return true if this player will allow bots to auto follow
+	void InhibitAutoFollow( float duration );	// prevent bots from auto-following for given duration
+	void AllowAutoFollow( void );				// allow bots to auto-follow immediately
+	float m_allowAutoFollowTime;				// bots can auto-follow after this time
+
+	// Have this guy speak a message into his radio.
+	void Radio( const char *szRadioSound, const char *szRadioText = NULL );
+	void ConstructRadioFilter( CRecipientFilter& filter );
+
+	void EmitPrivateSound( const char *soundName );		///< emit given sound that only we can hear
+
+	CWeaponCSBase* GetActiveCSWeapon() const;
+
+	void PreThink();
+
+	// This is the think function for the player when they first join the server and have to select a team
+	void JoiningThink();
+
+	virtual bool ClientCommand( const CCommand &args );
+
+	bool HandleCommand_JoinClass( int iClass );
+	bool HandleCommand_JoinTeam( int iTeam );
+
+	BuyResult_e HandleCommand_Buy( const char *item );
+
+    BuyResult_e HandleCommand_Buy_Internal( const char * item );
+
+	void HandleMenu_Radio1( int slot );
+	void HandleMenu_Radio2( int slot );
+	void HandleMenu_Radio3( int slot );
+
+	float m_flRadioTime;	
+	int m_iRadioMessages;
+	int iRadioMenu;
+
+	void ListPlayers();
+
+	bool m_bIgnoreRadio;
+
+	// Returns one of the CS_CLASS_ enums.
+	int PlayerClass() const;
+
+	void MoveToNextIntroCamera();
+
+	// Used to be GETINTOGAME state.
+	void GetIntoGame();
+
+	CBaseEntity* EntSelectSpawnPoint();
+	
+	void SetProgressBarTime( int barTime );
+	virtual void PlayerDeathThink();
+
+	void Weapon_Equip( CBaseCombatWeapon *pWeapon );
+	virtual bool BumpWeapon( CBaseCombatWeapon *pWeapon );
+	virtual bool Weapon_CanUse( CBaseCombatWeapon *pWeapon );
+
+	void ClearFlashbangScreenFade ( void );
+	bool ShouldDoLargeFlinch( int nHitGroup, CBaseEntity *pAttacker );
+
+	void ResetStamina( void );
+	bool IsArmored( int nHitGroup );
+	void Pain( bool HasArmour );
+	
+	void DeathSound( const CTakeDamageInfo &info );
+	
+	bool Weapon_CanSwitchTo( CBaseCombatWeapon *pWeapon );
+
+	void ChangeTeam( int iTeamNum );
+	void SwitchTeam( int iTeamNum );	// Changes teams without penalty - used for auto team balancing
+
+	void ModifyOrAppendPlayerCriteria( AI_CriteriaSet& set );
+
+	virtual void OnDamagedByExplosion( const CTakeDamageInfo &info );
+
+	// Called whenever this player fires a shot.
+	void NoteWeaponFired();
+	virtual bool WantsLagCompensationOnEntity( const CBasePlayer *pPlayer, const CUserCmd *pCmd, const CBitVec<MAX_EDICTS> *pEntityTransmitBits ) const;
+
+// ------------------------------------------------------------------------------------------------ //
+// Player state management.
+// ------------------------------------------------------------------------------------------------ //
+public:
+
+	void State_Transition( CSPlayerState newState );	// Cleanup the previous state and enter a new state.
+	CSPlayerState State_Get() const;				// Get the current state.
+
+
+private:
+	void State_Enter( CSPlayerState newState );		// Initialize the new state.
+	void State_Leave();								// Cleanup the previous state.
+	void State_PreThink();							// Update the current state.
+	
+	// Find the state info for the specified state.
+	static CCSPlayerStateInfo* State_LookupInfo( CSPlayerState state );
+
+	// This tells us which state the player is currently in (joining, observer, dying, etc).
+	// Each state has a well-defined set of parameters that go with it (ie: observer is movetype_noclip, nonsolid,
+	// invisible, etc).
+	CNetworkVar( CSPlayerState, m_iPlayerState );
+
+	CCSPlayerStateInfo *m_pCurStateInfo;			// This can be NULL if no state info is defined for m_iPlayerState.
+
+	// tells us whether or not this player gets money at the start of the next round.
+	bool m_receivesMoneyNextRound;
+
+
+	// Specific state handler functions.
+	void State_Enter_WELCOME();
+	void State_PreThink_WELCOME();
+
+	void State_Enter_PICKINGTEAM();
+	void State_Enter_PICKINGCLASS();
+
+	void State_Enter_ACTIVE();
+	void State_PreThink_ACTIVE();
+
+	void State_Enter_OBSERVER_MODE();
+	void State_PreThink_OBSERVER_MODE();
+
+	void State_Enter_DEATH_WAIT_FOR_KEY();
+	void State_PreThink_DEATH_WAIT_FOR_KEY();
+
+	void State_Enter_DEATH_ANIM();
+	void State_PreThink_DEATH_ANIM();
+
+	int FlashlightIsOn( void );
+	void FlashlightTurnOn( void );
+	void FlashlightTurnOff( void );
+
+	void UpdateAddonBits();
+	void UpdateRadar();
+
+public:
+
+	void				SetDeathPose( const int &iDeathPose ) { m_iDeathPose = iDeathPose; }
+	void				SetDeathPoseFrame( const int &iDeathPoseFrame ) { m_iDeathFrame = iDeathPoseFrame; }
+	
+	void				SelectDeathPose( const CTakeDamageInfo &info );
+
+private:
+	int	m_iDeathPose;
+	int	m_iDeathFrame;
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Freeze cam function and variable declarations
+//=============================================================================
+	 
+	bool m_bAbortFreezeCam;
+
+protected:
+	void AttemptToExitFreezeCam( void );
+	 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+public:
+
+	// Predicted variables.
+	CNetworkVar( bool, m_bResumeZoom );
+	CNetworkVar( int , m_iLastZoom ); // after firing a shot, set the FOV to 90, and after showing the animation, bring the FOV back to last zoom level.
+	CNetworkVar( bool, m_bIsDefusing );			// tracks whether this player is currently defusing a bomb
+	int m_LastHitGroup;			// the last body region that took damage
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Adding two variables, keeping track of damage to the player
+	//=============================================================================
+	 
+	int m_LastHitBox;			// the last body hitbox that took damage
+	Vector m_vLastHitLocationObjectSpace; //position where last hit occured in space of the bone associated with the hitbox
+	EHANDLE		m_hDroppedEquipment[DROPPED_COUNT];
+
+	// [tj] overriding the base suicides to trash CS specific stuff
+	virtual void CommitSuicide( bool bExplode = false, bool bForce = false );
+	virtual void CommitSuicide( const Vector &vecForce, bool bExplode = false, bool bForce = false );
+
+    void WieldingKnifeAndKilledByGun( bool bState ) { m_bWieldingKnifeAndKilledByGun = bState; }
+    bool WasWieldingKnifeAndKilledByGun() { return m_bWieldingKnifeAndKilledByGun; }
+
+    // [dwenger] adding tracking for weapon used fun fact
+    void PlayerUsedFirearm( CBaseCombatWeapon* pBaseWeapon );
+    int GetNumFirearmsUsed() { return m_WeaponTypesUsed.Count(); }
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	CNetworkVar( bool, m_bHasHelmet );				// Does the player have helmet armor
+	bool m_bEscaped;			// Has this terrorist escaped yet?
+
+	// Other variables.
+	bool m_bIsVIP;				// Are we the VIP?
+	int m_iNumSpawns;			// Number of times player has spawned this round
+	int m_iOldTeam;				// Keep what team they were last on so we can allow joining spec and switching back to their real team
+	bool m_bTeamChanged;		// Just allow one team change per round
+	CNetworkVar( int, m_iAccount );	// How much cash this player has.
+	int m_iShouldHaveCash;
+	
+	bool m_bJustKilledTeammate;
+	bool m_bPunishedForTK;
+	int m_iTeamKills;
+	float m_flLastMovement;
+	int m_iNextTimeCheck;		// Next time the player can execute a "timeleft" command
+
+	float m_flNameChangeHistory[NAME_CHANGE_HISTORY_SIZE]; // index 0 = most recent change
+
+	bool CanChangeName( void );	// Checks if the player can change his name
+	void ChangeName( const char *pszNewName );
+
+	void SetClanTag( const char *pTag );
+	const char *GetClanTag( void ) const;
+
+
+	CNetworkVar( bool, m_bHasDefuser );			    // Does this player have a defuser kit?
+	CNetworkVar( bool, m_bHasNightVision );		    // Does this player have night vision?
+	CNetworkVar( bool, m_bNightVisionOn );		    // Is the NightVision turned on ?
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [dwenger] Added for fun-fact support
+    //=============================================================================
+
+    //CNetworkVar( bool, m_bPickedUpDefuser );        // Did player pick up the defuser kit as opposed to buying it?
+    //CNetworkVar( bool, m_bDefusedWithPickedUpKit);  // Did player defuse the bomb with a picked-up defuse kit?
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+	float m_flLastRadarUpdateTime;
+
+	// last known navigation area of player - NULL if unknown
+	CNavArea *m_lastNavArea;
+
+	// Backup copy of the menu text so the player can change this and the menu knows when to update.
+	char	m_MenuStringBuffer[MENU_STRING_BUFFER_SIZE];
+
+	// When the player joins, it cycles their view between trigger_camera entities.
+	// This is the current camera, and the time that we'll switch to the next one.
+	EHANDLE m_pIntroCamera;
+	float m_fIntroCamTime;
+
+	// Set to true each frame while in a bomb zone.
+	// Reset after prediction (in PostThink).
+	CNetworkVar( bool, m_bInBombZone );
+	CNetworkVar( bool, m_bInBuyZone );
+	int m_iBombSiteIndex;
+
+	bool IsInBuyZone();
+	bool CanPlayerBuy( bool display );
+
+	CNetworkVar( bool, m_bInHostageRescueZone );
+	void RescueZoneTouch( inputdata_t &inputdata );
+
+	CNetworkVar( float, m_flStamina );
+	CNetworkVar( int, m_iDirection );	// The current lateral kicking direction; 1 = right,  0 = left
+	CNetworkVar( int, m_iShotsFired );	// number of shots fired recently
+
+	// Make sure to register changes for armor.
+	IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_ArmorValue );
+
+	CNetworkVar( float, m_flVelocityModifier );
+
+	int	m_iHostagesKilled;
+
+	void SetShieldDrawnState( bool bState );
+	void DropShield( void );
+	
+	char m_szNewName [MAX_PLAYER_NAME_LENGTH]; // not empty if player requested a namechange
+	char m_szClanTag[MAX_CLAN_TAG_LENGTH];
+
+	Vector m_vecTotalBulletForce;	//Accumulator for bullet force in a single frame
+	
+	CNetworkVar( float, m_flFlashDuration );
+	CNetworkVar( float, m_flFlashMaxAlpha );
+	
+	CNetworkVar( float, m_flProgressBarStartTime );
+	CNetworkVar( int, m_iProgressBarDuration );
+	CNetworkVar( int, m_iThrowGrenadeCounter );	// used to trigger grenade throw animations.
+	
+	// Tracks our ragdoll entity.
+	CNetworkHandle( CBaseEntity, m_hRagdoll );	// networked entity handle 
+
+	// Bots and hostages auto-duck during jumps
+	bool m_duckUntilOnGround;
+
+	Vector m_lastStandingPos; // used by the gamemovement code for finding ladders
+
+	void SurpressLadderChecks( const Vector& pos, const Vector& normal );
+	bool CanGrabLadder( const Vector& pos, const Vector& normal );
+
+	CNetworkVar( bool, m_bDetected );
+
+private:
+	CountdownTimer m_ladderSurpressionTimer;
+	Vector m_lastLadderNormal;
+	Vector m_lastLadderPos;
+
+protected:
+
+	void CreateRagdollEntity();
+
+	bool IsHittingShield( const Vector &vecDirection, trace_t *ptr );
+
+	void PhysObjectSleep();
+	void PhysObjectWake();
+
+	bool RunMimicCommand( CUserCmd& cmd );
+
+	bool SelectSpawnSpot( const char *pEntClassName, CBaseEntity* &pSpot );
+
+	void SetModelFromClass( void );
+	CNetworkVar( int, m_iClass ); // One of the CS_CLASS_ enums.
+
+	bool CSWeaponDrop( CBaseCombatWeapon *pWeapon, bool bDropShield = true, bool bThrow = false );
+	bool DropRifle( bool fromDeath = false );
+	bool DropPistol( bool fromDeath = false );
+	
+    //=============================================================================
+    // HPE_BEGIN:
+    // [tj] Added a parameter so we know if it was death that caused the drop
+	// [menglish] New parameter to always know if this is from death and not just an enemy death
+    //=============================================================================
+     
+    void DropWeapons( bool fromDeath, bool friendlyFire );
+     
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+    
+
+	virtual int SpawnArmorValue( void ) const { return ArmorValue(); }
+
+	BuyResult_e AttemptToBuyAmmo( int iAmmoType );
+	BuyResult_e AttemptToBuyAmmoSingle( int iAmmoType );
+	BuyResult_e AttemptToBuyVest( void );
+	BuyResult_e AttemptToBuyAssaultSuit( void );
+	BuyResult_e AttemptToBuyDefuser( void );
+	BuyResult_e AttemptToBuyNightVision( void );
+	BuyResult_e AttemptToBuyShield( void );
+	
+	BuyResult_e BuyAmmo( int nSlot, bool bBlinkMoney );
+	BuyResult_e BuyGunAmmo( CBaseCombatWeapon *pWeapon, bool bBlinkMoney );
+
+	void PushawayThink();
+
+private:
+
+	ICSPlayerAnimState *m_PlayerAnimState;
+
+	// Aiming heuristics code
+	float						m_flIdleTime;		//Amount of time we've been motionless
+	float						m_flMoveTime;		//Amount of time we've been in motion
+	float						m_flLastDamageTime;	//Last time we took damage
+	float						m_flTargetFindTime;
+
+	int							m_lastDamageHealth;		// Last damage given to our health
+	int							m_lastDamageArmor;		// Last damage given to our armor
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [dwenger] Added for fun-fact support
+    //=============================================================================
+
+    bool                        m_bPickedUpDefuser;         // Did player pick up the defuser kit as opposed to buying it?
+    bool                        m_bDefusedWithPickedUpKit;  // Did player defuse the bomb with a picked-up defuse kit?
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+
+	// Last usercmd we shot a bullet on.
+	int m_iLastWeaponFireUsercmd;
+
+	// Copyed from EyeAngles() so we can send it to the client.
+	CNetworkQAngle( m_angEyeAngles );
+
+	bool m_bVCollisionInitted;
+
+// AutoBuy functions.
+public:
+	void			AutoBuy(); // this should take into account what the player can afford and should buy the best equipment for them.
+
+	bool			IsInAutoBuy( void ) { return m_bIsInAutoBuy; }
+	bool			IsInReBuy( void ) { return m_bIsInRebuy; }
+
+private:
+	bool			ShouldExecuteAutoBuyCommand(const AutoBuyInfoStruct *commandInfo, bool boughtPrimary, bool boughtSecondary);
+	void			PostAutoBuyCommandProcessing(const AutoBuyInfoStruct *commandInfo, bool &boughtPrimary, bool &boughtSecondary);
+	void			ParseAutoBuyString(const char *string, bool &boughtPrimary, bool &boughtSecondary);
+	AutoBuyInfoStruct *GetAutoBuyCommandInfo(const char *command);
+	void			PrioritizeAutoBuyString(char *autobuyString, const char *priorityString); // reorders the tokens in autobuyString based on the order of tokens in the priorityString.
+	BuyResult_e	CombineBuyResults( BuyResult_e prevResult, BuyResult_e newResult );
+
+	bool			m_bIsInAutoBuy;
+	bool			m_bAutoReload;
+
+//ReBuy functions
+
+public:
+	void			Rebuy();
+private:
+	void			BuildRebuyStruct();
+
+	BuyResult_e	RebuyPrimaryWeapon();
+	BuyResult_e	RebuyPrimaryAmmo();
+	BuyResult_e	RebuySecondaryWeapon();
+	BuyResult_e	RebuySecondaryAmmo();
+	BuyResult_e	RebuyHEGrenade();
+	BuyResult_e	RebuyFlashbang();
+	BuyResult_e	RebuySmokeGrenade();
+	BuyResult_e	RebuyDefuser();
+	BuyResult_e	RebuyNightVision();
+	BuyResult_e	RebuyArmor();
+
+	bool			m_bIsInRebuy;
+	RebuyStruct		m_rebuyStruct;
+	bool			m_bUsingDefaultPistol;
+
+	bool			m_bIsBeingGivenItem;
+
+#ifdef CS_SHIELD_ENABLED
+	CNetworkVar( bool, m_bHasShield );
+	CNetworkVar( bool, m_bShieldDrawn );
+#endif
+	
+	// This is a combination of the ADDON_ flags in cs_shareddefs.h.
+	CNetworkVar( int, m_iAddonBits );
+
+	// Clients don't know about holstered weapons, so we need to tell them the weapon type here
+	CNetworkVar( int, m_iPrimaryAddon );
+	CNetworkVar( int, m_iSecondaryAddon );
+
+//Damage record functions
+public:
+
+	static void	StartNewBulletGroup();	// global function
+
+	void RecordDamageTaken( const char *szDamageDealer, int iDamageTaken );
+	void RecordDamageGiven( const char *szDamageTaker, int iDamageGiven );
+
+	void ResetDamageCounters();	//Reset all lists
+
+	void OutputDamageTaken( void );
+	void OutputDamageGiven( void );
+
+	void StockPlayerAmmo( CBaseCombatWeapon *pNewWeapon = NULL );
+
+	CUtlLinkedList< CDamageRecord *, int >& GetDamageGivenList() {return m_DamageGivenList;}
+	CUtlLinkedList< CDamageRecord *, int >& GetDamageTakenList() {return m_DamageTakenList;}
+
+private:
+	//A list of damage given
+	CUtlLinkedList< CDamageRecord *, int >	m_DamageGivenList;
+
+	//A list of damage taken
+	CUtlLinkedList< CDamageRecord *, int >	m_DamageTakenList;
+
+protected:
+	float m_applyDeafnessTime;
+	int m_currentDeafnessFilter;
+
+	bool m_isVIP;
+
+// Command rate limiting.
+private:
+
+	bool ShouldRunRateLimitedCommand( const CCommand &args );
+
+	// This lets us rate limit the commands the players can execute so they don't overflow things like reliable buffers.
+	CUtlDict<float,int>	m_RateLimitLastCommandTimes;
+
+	CNetworkVar(int, m_cycleLatch);	// Every so often, we are going to transmit our cycle to the client to correct divergence caused by PVS changes
+	CountdownTimer m_cycleLatchTimer;
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish, tj] Achievement-based addition to CS player class.
+//=============================================================================
+ 
+public:
+	void ResetRoundBasedAchievementVariables();
+	void OnRoundEnd(int winningTeam, int reason);
+    void OnPreResetRound();
+
+	int GetNumEnemyDamagers();
+	int GetNumEnemiesDamaged();
+	CBaseEntity* GetNearestSurfaceBelow(float maxTrace);
+
+    // Returns the % of the enemies this player killed in the round
+    int GetPercentageOfEnemyTeamKilled();
+
+	//List of times of recent kills to check for sprees
+	CUtlVector<float>			m_killTimes; 
+
+    //List of all players killed this round
+    CUtlVector<CHandle<CCSPlayer> >      m_enemyPlayersKilledThisRound;
+
+	//List of weapons we have used to kill players with this round
+	CUtlVector<int>				m_killWeapons; 
+
+	int m_NumEnemiesKilledThisRound;
+	int m_NumEnemiesAtRoundStart;
+	int m_KillingSpreeStartTime;
+
+	float m_firstKillBlindStartTime; //This is the start time of the blind effect during which we got our most recent kill.
+	int m_killsWhileBlind;
+ 
+    bool m_bIsRescuing;         // tracks whether this player is currently rescuing a hostage
+    bool m_bInjuredAHostage;    // tracks whether this player injured a hostage
+    int  m_iNumFollowers;       // Number of hostages following this player
+	bool m_bSurvivedHeadshotDueToHelmet;
+
+    void IncrementNumFollowers() { m_iNumFollowers++; }
+    void DecrementNumFollowers() { m_iNumFollowers--; if (m_iNumFollowers < 0) m_iNumFollowers = 0; }
+    int GetNumFollowers() { return m_iNumFollowers; }
+    void SetIsRescuing(bool in_bRescuing) { m_bIsRescuing = in_bRescuing; }
+    bool IsRescuing() { return m_bIsRescuing; }
+    void SetInjuredAHostage(bool in_bInjured) { m_bInjuredAHostage = in_bInjured; }
+    bool InjuredAHostage() { return m_bInjuredAHostage; }
+    float GetBombPickuptime() { return m_bombPickupTime; }
+    void SetBombPickupTime(float time) { m_bombPickupTime = time; }
+    CCSPlayer* GetLastFlashbangAttacker() { return m_lastFlashBangAttacker; }
+    void SetLastFlashbangAttacker(CCSPlayer* attacker) { m_lastFlashBangAttacker = attacker; }
+
+	static CSWeaponID GetWeaponIdCausingDamange( const CTakeDamageInfo &info );
+	static void ProcessPlayerDeathAchievements( CCSPlayer *pAttacker, CCSPlayer *pVictim, const CTakeDamageInfo &info );
+
+    void                        OnCanceledDefuse();
+    void                        OnStartedDefuse();
+    GooseChaseAchievementStep   m_gooseChaseStep;
+    DefuseDefenseAchivementStep m_defuseDefenseStep;
+    CHandle<CCSPlayer>          m_pGooseChaseDistractingPlayer;
+
+    int                         m_lastRoundResult; //save the reason for the last round ending.
+
+    bool                        m_bMadeFootstepNoise;
+
+    float                       m_bombPickupTime;
+
+    bool                        m_bMadePurchseThisRound;
+
+    int                         m_roundsWonWithoutPurchase;
+
+	bool						m_bKilledDefuser;
+	bool						m_bKilledRescuer;
+	int							m_maxGrenadeKills;
+
+	int							m_grenadeDamageTakenThisRound;
+
+	bool						GetKilledDefuser() { return m_bKilledDefuser; } 
+	bool						GetKilledRescuer() { return m_bKilledRescuer; } 
+	int							GetMaxGrenadeKills() { return m_maxGrenadeKills; }
+
+	void						CheckMaxGrenadeKills(int grenadeKills);
+
+    CHandle<CCSPlayer>                  m_lastFlashBangAttacker;
+
+    void	SetPlayerDominated( CCSPlayer *pPlayer, bool bDominated );    
+    void	SetPlayerDominatingMe( CCSPlayer *pPlayer, bool bDominated );
+    bool	IsPlayerDominated( int iPlayerIndex );
+    bool	IsPlayerDominatingMe( int iPlayerIndex );
+
+	bool	m_wasNotKilledNaturally; //Set if the player is dead from a kill command or late login
+
+	bool	WasNotKilledNaturally() { return m_wasNotKilledNaturally; }
+
+	//=============================================================================
+	// [menglish] MVP functions
+	//=============================================================================
+	 
+	void	SetNumMVPs( int iNumMVP );
+	void	IncrementNumMVPs( CSMvpReason_t mvpReason );
+	int		GetNumMVPs();
+	 
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+    void    RemoveNemesisRelationships();
+	void	SetDeathFlags( int iDeathFlags ) { m_iDeathFlags = iDeathFlags; }
+	int		GetDeathFlags() { return m_iDeathFlags; }
+
+private:
+    CNetworkArray( bool, m_bPlayerDominated, MAX_PLAYERS+1 );		// array of state per other player whether player is dominating other players
+    CNetworkArray( bool, m_bPlayerDominatingMe, MAX_PLAYERS+1 );	// array of state per other player whether other players are dominating this player
+
+	//=============================================================================
+	// HPE_BEGIN:
+	//=============================================================================
+
+    // [menglish] number of rounds this player has caused to be won for their team
+	int m_iMVPs;
+
+    // [dwenger] adding tracking for fun fact
+    bool m_bWieldingKnifeAndKilledByGun;
+
+    // [dwenger] adding tracking for which weapons this player has used in a round
+    CUtlVector<CSWeaponID> m_WeaponTypesUsed; 
+
+    //=============================================================================
+	// HPE_END
+	//=============================================================================
+	int m_iDeathFlags; // Flags holding revenge and domination info about a death
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+};
+
+
+inline CSPlayerState CCSPlayer::State_Get() const
+{
+	return m_iPlayerState;
+}
+
+inline CCSPlayer *ToCSPlayer( CBaseEntity *pEntity )
+{
+	if ( !pEntity || !pEntity->IsPlayer() )
+		return NULL;
+
+	return dynamic_cast<CCSPlayer*>( pEntity );
+}
+
+inline bool CCSPlayer::IsReloading( void ) const
+{
+	CBaseCombatWeapon *gun = GetActiveWeapon();
+	if (gun == NULL)
+		return false;
+
+	return gun->m_bInReload;
+}
+
+inline bool CCSPlayer::IsProtectedByShield( void ) const
+{ 
+	return HasShield() && IsShieldDrawn();
+}
+
+inline bool CCSPlayer::IsBlind( void ) const
+{ 
+	return gpGlobals->curtime < m_blindUntilTime;
+}
+
+//=============================================================================
+// HPE_BEGIN
+// [sbodenbender] Need a different test for player blindness for the achievements
+//=============================================================================
+inline bool CCSPlayer::IsBlindForAchievement()
+{
+	return (m_blindStartTime + m_flFlashDuration) > gpGlobals->curtime;
+}
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+inline bool CCSPlayer::IsAutoFollowAllowed( void ) const		
+{ 
+	return (gpGlobals->curtime > m_allowAutoFollowTime); 
+}
+
+inline void CCSPlayer::InhibitAutoFollow( float duration )	
+{ 
+	m_allowAutoFollowTime = gpGlobals->curtime + duration; 
+}
+
+inline void CCSPlayer::AllowAutoFollow( void )	
+{ 
+	m_allowAutoFollowTime = 0.0f; 
+}
+
+inline int CCSPlayer::GetClass( void ) const
+{
+	return m_iClass;
+}
+
+inline const char *CCSPlayer::GetClanTag( void ) const
+{
+	return m_szClanTag;
+}
+
+#endif	//CS_PLAYER_H
diff --git a/game/server/cstrike/cs_player_resource.cpp b/game/server/cstrike/cs_player_resource.cpp
new file mode 100644
index 00000000..ec13230f
--- /dev/null
+++ b/game/server/cstrike/cs_player_resource.cpp
@@ -0,0 +1,343 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: CS's custom CPlayerResource
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "cs_player.h"
+#include "player_resource.h"
+#include "cs_simple_hostage.h"
+#include "cs_player_resource.h"
+#include "weapon_c4.h"
+#include <coordsize.h>
+#include "cs_bot_manager.h"
+#include "cs_gamerules.h"
+
+// Datatable
+IMPLEMENT_SERVERCLASS_ST(CCSPlayerResource, DT_CSPlayerResource)
+	SendPropInt( SENDINFO( m_iPlayerC4 ), 8, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iPlayerVIP ), 8, SPROP_UNSIGNED ),
+	SendPropVector( SENDINFO(m_vecC4), -1, SPROP_COORD),
+	SendPropArray3( SENDINFO_ARRAY3(m_bHostageAlive), SendPropInt( SENDINFO_ARRAY(m_bHostageAlive), 1, SPROP_UNSIGNED ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_isHostageFollowingSomeone), SendPropInt( SENDINFO_ARRAY(m_isHostageFollowingSomeone), 1, SPROP_UNSIGNED ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_iHostageEntityIDs), SendPropInt( SENDINFO_ARRAY(m_iHostageEntityIDs), -1, SPROP_UNSIGNED ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_iHostageY), SendPropInt( SENDINFO_ARRAY(m_iHostageY), COORD_INTEGER_BITS+1, 0 ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_iHostageX), SendPropInt( SENDINFO_ARRAY(m_iHostageX), COORD_INTEGER_BITS+1, 0 ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_iHostageZ), SendPropInt( SENDINFO_ARRAY(m_iHostageZ), COORD_INTEGER_BITS+1, 0 ) ),
+	SendPropVector( SENDINFO(m_bombsiteCenterA), -1, SPROP_COORD),
+	SendPropVector( SENDINFO(m_bombsiteCenterB), -1, SPROP_COORD),
+	SendPropArray3( SENDINFO_ARRAY3(m_hostageRescueX), SendPropInt( SENDINFO_ARRAY(m_hostageRescueX), COORD_INTEGER_BITS+1, 0 ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_hostageRescueY), SendPropInt( SENDINFO_ARRAY(m_hostageRescueY), COORD_INTEGER_BITS+1, 0 ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_hostageRescueZ), SendPropInt( SENDINFO_ARRAY(m_hostageRescueZ), COORD_INTEGER_BITS+1, 0 ) ),
+	SendPropBool( SENDINFO( m_bBombSpotted ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_bPlayerSpotted), SendPropInt( SENDINFO_ARRAY(m_bPlayerSpotted), 1, SPROP_UNSIGNED ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_iMVPs), SendPropInt( SENDINFO_ARRAY(m_iMVPs), COORD_INTEGER_BITS+1, SPROP_UNSIGNED ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_bHasDefuser), SendPropInt( SENDINFO_ARRAY(m_bHasDefuser), 1, SPROP_UNSIGNED ) ),
+	SendPropArray3( SENDINFO_ARRAY3(m_szClan), SendPropStringT( SENDINFO_ARRAY(m_szClan) ) ),
+END_SEND_TABLE()
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+BEGIN_DATADESC( CCSPlayerResource )
+	// DEFINE_ARRAY( m_iPing, FIELD_INTEGER, MAX_PLAYERS+1 ),
+	// DEFINE_ARRAY( m_iPacketloss, FIELD_INTEGER, MAX_PLAYERS+1 ),
+END_DATADESC()
+
+LINK_ENTITY_TO_CLASS( cs_player_manager, CCSPlayerResource );
+
+CCSPlayerResource::CCSPlayerResource( void )
+{
+	
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+class Spotter
+{
+public:
+	Spotter( CBaseEntity *entity, const Vector &target, int spottingTeam )
+	{
+		m_targetEntity = entity;
+		m_target = target;
+		m_team = spottingTeam;
+		m_spotted = false;
+	}
+
+	bool operator()( CBasePlayer *player )
+	{
+		if ( !player->IsAlive() || player->GetTeamNumber() != m_team )
+			return true;
+
+		CCSPlayer *csPlayer = ToCSPlayer( player );
+		if ( !csPlayer )
+			return true;
+
+		if ( csPlayer->IsBlind() )
+			return true;
+
+		Vector eye, forward;
+		player->EyePositionAndVectors( &eye, &forward, NULL, NULL );
+		Vector path( m_target - eye );
+		float distance = path.Length();
+		path.NormalizeInPlace();
+		float dot = DotProduct( forward, path );
+		if( (dot > 0.995f ) 
+			|| (dot > 0.98f && distance < 900) 
+			|| (dot > 0.8f && distance < 250) 
+			)
+		{
+			trace_t tr;
+			CTraceFilterSkipTwoEntities filter( player, m_targetEntity, COLLISION_GROUP_DEBRIS );
+			UTIL_TraceLine( eye, m_target,
+				(CONTENTS_OPAQUE|CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_DEBRIS), &filter, &tr );
+
+			if( tr.fraction == 1.0f )
+			{
+				if ( TheCSBots()->IsLineBlockedBySmoke( eye, m_target ) )
+				{
+					return true;
+				}
+
+				m_spotted = true;
+				return false; // spotted already, so no reason to check for other players spotting the same thing.
+			}
+		}
+
+		return true;
+	}
+
+	bool Spotted( void ) const
+	{
+		return m_spotted;
+	}
+
+private:
+	CBaseEntity *m_targetEntity;
+	Vector m_target;
+	int m_team;
+	bool m_spotted;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSPlayerResource::UpdatePlayerData( void )
+{
+	int i;
+
+	m_iPlayerC4 = 0;
+	m_iPlayerVIP = 0;
+
+	for ( i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CCSPlayer *pPlayer = (CCSPlayer*)UTIL_PlayerByIndex( i );
+		
+		if ( pPlayer && pPlayer->IsConnected() )
+		{
+			if ( pPlayer->IsVIP() )
+			{
+				// we should only have one VIP
+				Assert( m_iPlayerVIP == 0 );
+				m_iPlayerVIP = i;
+			}
+
+			if ( pPlayer->HasC4() )
+			{
+				// we should only have one bomb
+				m_iPlayerC4 = i;
+			}
+
+			m_szClan.Set(i, AllocPooledString( pPlayer->GetClanTag() ) );
+
+			m_iMVPs.Set(i, pPlayer->GetNumMVPs());
+
+			m_bHasDefuser.Set(i, pPlayer->HasDefuser());
+
+		}
+		else
+		{
+			m_szClan.Set( i, MAKE_STRING( "" ) );
+			m_iMVPs.Set( i, 0 );
+		}
+	}
+
+	CBaseEntity *c4 = NULL;
+	if ( m_iPlayerC4 == 0 )
+	{
+		// no player has C4, update C4 position
+		if ( g_C4s.Count() > 0 )
+		{
+			c4 = g_C4s[0];
+			m_vecC4 = c4->GetAbsOrigin();
+		}
+		else
+		{
+			m_vecC4.Init();
+		}
+	}
+
+	int numHostages = g_Hostages.Count();
+
+	for ( i = 0; i < MAX_HOSTAGES; i++ )
+	{
+		if ( i >= numHostages )
+		{
+//			engine->Con_NPrintf( i, "Dead" );
+			m_bHostageAlive.Set( i, false );
+			m_isHostageFollowingSomeone.Set( i, false );
+			continue;
+		}
+
+		CHostage* pHostage = g_Hostages[i];
+
+		m_bHostageAlive.Set( i, pHostage->IsRescuable() );
+
+		if ( pHostage->IsValid() )
+		{
+			m_iHostageX.Set( i, (int) pHostage->GetAbsOrigin().x );	
+			m_iHostageY.Set( i, (int) pHostage->GetAbsOrigin().y );	
+			m_iHostageZ.Set( i, (int) pHostage->GetAbsOrigin().z );	
+			m_iHostageEntityIDs.Set( i, pHostage->entindex() );
+			m_isHostageFollowingSomeone.Set( i, pHostage->IsFollowingSomeone() );
+//			engine->Con_NPrintf( i, "ID:%d Pos:(%.0f,%.0f,%.0f)", pHostage->entindex(), pHostage->GetAbsOrigin().x, pHostage->GetAbsOrigin().y, pHostage->GetAbsOrigin().z );
+		}
+		else
+		{
+//			engine->Con_NPrintf( i, "Invalid" );
+		}
+	}
+
+	if( !m_foundGoalPositions )
+	{
+		// We only need to update these once a map, but we need the client to know about them.
+		CBaseEntity* ent = NULL;
+		while ( ( ent = gEntList.FindEntityByClassname( ent, "func_bomb_target" ) ) != NULL )
+		{
+			const Vector &pos = ent->WorldSpaceCenter();
+			CNavArea *area = TheNavMesh->GetNearestNavArea( pos, true, 10000.0f, false, false );
+			const char *placeName = (area) ? TheNavMesh->PlaceToName( area->GetPlace() ) : NULL;
+			if ( placeName == NULL )
+			{
+				// The bomb site has no area or place name, so just choose A then B
+				if ( m_bombsiteCenterA.Get().IsZero() )
+				{
+					m_bombsiteCenterA = pos;
+				}
+				else
+				{
+					m_bombsiteCenterB = pos;
+				}
+			}
+			else
+			{
+				// The bomb site has a place name, so choose accordingly
+				if( FStrEq( placeName, "BombsiteA" ) )
+				{
+					m_bombsiteCenterA = pos;
+				}
+				else
+				{
+					m_bombsiteCenterB = pos;
+				}
+			}
+			m_foundGoalPositions = true;
+		}
+
+		int hostageRescue = 0;
+		while ( (( ent = gEntList.FindEntityByClassname( ent, "func_hostage_rescue" ) ) != NULL)  &&  (hostageRescue < MAX_HOSTAGE_RESCUES) )
+		{
+			const Vector &pos = ent->WorldSpaceCenter();
+			m_hostageRescueX.Set( hostageRescue, (int) pos.x );	
+			m_hostageRescueY.Set( hostageRescue, (int) pos.y );	
+			m_hostageRescueZ.Set( hostageRescue, (int) pos.z );	
+
+			hostageRescue++;
+			m_foundGoalPositions = true;
+		}
+	}
+
+	bool bombSpotted = false;
+	if ( c4 )
+	{
+		Spotter spotter( c4, m_vecC4, TEAM_CT );
+		ForEachPlayer( spotter );
+		if ( spotter.Spotted() )
+		{
+			bombSpotted = true;
+		}
+	}
+
+	for ( int i=0; i < MAX_PLAYERS+1; i++ )
+	{
+		CCSPlayer *target = ToCSPlayer( UTIL_PlayerByIndex( i ) );
+
+		if ( !target || !target->IsAlive() )
+		{
+			m_bPlayerSpotted.Set( i, 0 );
+			continue;
+		}
+
+		Spotter spotter( target, target->EyePosition(), (target->GetTeamNumber()==TEAM_CT) ? TEAM_TERRORIST : TEAM_CT );
+		ForEachPlayer( spotter );
+		if ( spotter.Spotted() )
+		{
+			if ( target->HasC4() )
+			{
+				bombSpotted = true;
+			}
+			m_bPlayerSpotted.Set( i, 1 );
+		}
+		else
+		{
+			m_bPlayerSpotted.Set( i, 0 );
+		}
+	}
+
+	if ( bombSpotted )
+	{
+		m_bBombSpotted = true;
+	}
+	else
+	{
+		m_bBombSpotted = false;
+	}
+
+	BaseClass::UpdatePlayerData();
+}
+
+void CCSPlayerResource::Spawn( void )
+{
+	m_vecC4.Init();
+	m_iPlayerC4 = 0;
+	m_iPlayerVIP = 0;
+	m_bombsiteCenterA.Init();
+	m_bombsiteCenterB.Init();
+	m_foundGoalPositions = false;
+
+	for ( int i=0; i < MAX_HOSTAGES; i++ )
+	{
+		m_bHostageAlive.Set( i, 0 );
+		m_isHostageFollowingSomeone.Set( i, 0 );
+		m_iHostageEntityIDs.Set(i, 0);
+	}
+
+	for ( int i=0; i < MAX_HOSTAGE_RESCUES; i++ )
+	{
+		m_hostageRescueX.Set( i, 0 );
+		m_hostageRescueY.Set( i, 0 );
+		m_hostageRescueZ.Set( i, 0 );
+	}
+
+	m_bBombSpotted = false;
+	for ( int i=0; i < MAX_PLAYERS+1; i++ )
+	{
+		m_bPlayerSpotted.Set( i, 0 );
+		m_szClan.Set( i, MAKE_STRING( "" ) );
+		m_iMVPs.Set( i, 0 );
+		m_bHasDefuser.Set(i, false);
+	}
+
+	BaseClass::Spawn();
+}
diff --git a/game/server/cstrike/cs_player_resource.h b/game/server/cstrike/cs_player_resource.h
new file mode 100644
index 00000000..d59cabc8
--- /dev/null
+++ b/game/server/cstrike/cs_player_resource.h
@@ -0,0 +1,55 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: CS's custom CPlayerResource
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_PLAYER_RESOURCE_H
+#define CS_PLAYER_RESOURCE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CCSPlayerResource : public CPlayerResource
+{
+	DECLARE_CLASS( CCSPlayerResource, CPlayerResource );
+	
+public:
+	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+	CCSPlayerResource();
+
+	virtual void UpdatePlayerData( void );
+	virtual void Spawn( void );
+protected:
+
+	CNetworkVar( int, m_iPlayerC4 );  // entity index of C4 carrier or 0
+	CNetworkVar( int, m_iPlayerVIP ); // entity index of VIP player or 0
+	CNetworkVector( m_vecC4 );  // position of C4
+	CNetworkArray( bool, m_bHostageAlive, MAX_HOSTAGES );
+	CNetworkArray( bool, m_isHostageFollowingSomeone, MAX_HOSTAGES );
+	CNetworkArray( int, m_iHostageEntityIDs, MAX_HOSTAGES );
+	CNetworkArray( int, m_iHostageX, MAX_HOSTAGES );
+	CNetworkArray( int, m_iHostageY, MAX_HOSTAGES );
+	CNetworkArray( int, m_iHostageZ, MAX_HOSTAGES );
+	CNetworkVector( m_bombsiteCenterA );// Location of bombsite A
+	CNetworkVector( m_bombsiteCenterB );// Location of bombsite B
+	CNetworkArray( int, m_hostageRescueX, MAX_HOSTAGE_RESCUES );// Locations of all hostage rescue spots
+	CNetworkArray( int, m_hostageRescueY, MAX_HOSTAGE_RESCUES );
+	CNetworkArray( int, m_hostageRescueZ, MAX_HOSTAGE_RESCUES );
+
+	CNetworkVar( bool, m_bBombSpotted );
+	CNetworkArray( bool, m_bPlayerSpotted, MAX_PLAYERS+1 );
+
+	CNetworkArray( string_t, m_szClan, MAX_PLAYERS+1 );
+
+	CNetworkArray( int, m_iMVPs, MAX_PLAYERS + 1 );
+	CNetworkArray( bool, m_bHasDefuser, MAX_PLAYERS + 1);
+
+private:
+	bool m_foundGoalPositions;
+};
+
+#endif // CS_PLAYER_RESOURCE_H
diff --git a/game/server/cstrike/cs_playermove.cpp b/game/server/cstrike/cs_playermove.cpp
new file mode 100644
index 00000000..a8f4eee9
--- /dev/null
+++ b/game/server/cstrike/cs_playermove.cpp
@@ -0,0 +1,98 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "player_command.h"
+#include "igamemovement.h"
+#include "in_buttons.h"
+#include "ipredictionsystem.h"
+#include "iservervehicle.h"
+#include "cs_player.h"
+
+
+static CMoveData g_MoveData;
+CMoveData *g_pMoveData = &g_MoveData;
+
+IPredictionSystem *IPredictionSystem::g_pPredictionSystems = NULL;
+
+
+//-----------------------------------------------------------------------------
+// Sets up the move data for TF2
+//-----------------------------------------------------------------------------
+class CCSPlayerMove : public CPlayerMove
+{
+DECLARE_CLASS( CCSPlayerMove, CPlayerMove );
+
+public:
+	virtual void	StartCommand( CBasePlayer *player, CUserCmd *cmd );
+	virtual void	SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
+	virtual void	FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move );
+};
+
+// PlayerMove Interface
+static CCSPlayerMove g_PlayerMove;
+
+//-----------------------------------------------------------------------------
+// Singleton accessor
+//-----------------------------------------------------------------------------
+CPlayerMove *PlayerMove()
+{
+	return &g_PlayerMove;
+}
+
+//-----------------------------------------------------------------------------
+// Main setup, finish
+//-----------------------------------------------------------------------------
+
+void CCSPlayerMove::StartCommand( CBasePlayer *player, CUserCmd *cmd )
+{
+	CCSPlayer *pPlayer = ToCSPlayer( player );
+
+	// Reset this.. it gets reset each frame that we're in a bomb zone.
+	pPlayer->m_bInBombZone = false;
+	pPlayer->m_bInBuyZone = false;
+	pPlayer->m_bInHostageRescueZone = false;
+
+	BaseClass::StartCommand( player, cmd );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This is called pre player movement and copies all the data necessary
+//          from the player for movement. (Server-side, the client-side version
+//          of this code can be found in prediction.cpp.)
+//-----------------------------------------------------------------------------
+void CCSPlayerMove::SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
+{
+	player->AvoidPhysicsProps( ucmd );
+
+	BaseClass::SetupMove( player, ucmd, pHelper, move );
+
+	IServerVehicle *pVehicle = player->GetVehicle();
+	if (pVehicle && gpGlobals->frametime != 0)
+	{
+		pVehicle->SetupMove( player, ucmd, pHelper, move ); 
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: This is called post player movement to copy back all data that
+//          movement could have modified and that is necessary for future
+//          movement. (Server-side, the client-side version of this code can 
+//          be found in prediction.cpp.)
+//-----------------------------------------------------------------------------
+void CCSPlayerMove::FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move )
+{
+	// Call the default FinishMove code.
+	BaseClass::FinishMove( player, ucmd, move );
+
+	IServerVehicle *pVehicle = player->GetVehicle();
+	if (pVehicle && gpGlobals->frametime != 0)
+	{
+		pVehicle->FinishMove( player, ucmd, move );
+	}
+}
diff --git a/game/server/cstrike/cs_team.cpp b/game/server/cstrike/cs_team.cpp
new file mode 100644
index 00000000..61360ea3
--- /dev/null
+++ b/game/server/cstrike/cs_team.cpp
@@ -0,0 +1,101 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Team management class. Contains all the details for a specific team
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "cs_team.h"
+#include "entitylist.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+// Datatable
+IMPLEMENT_SERVERCLASS_ST(CCSTeam, DT_CSTeam)
+END_SEND_TABLE()
+
+LINK_ENTITY_TO_CLASS( cs_team_manager, CCSTeam );
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a pointer to the specified TF team manager
+//-----------------------------------------------------------------------------
+CCSTeam *GetGlobalTFTeam( int iIndex )
+{
+	return (CCSTeam*)GetGlobalTeam( iIndex );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Needed because this is an entity, but should never be used
+//-----------------------------------------------------------------------------
+void CCSTeam::Init( const char *pName, int iNumber )
+{
+	BaseClass::Init( pName, iNumber );
+
+	// Only detect changes every half-second.
+	NetworkProp()->SetUpdateInterval( 0.75f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCSTeam::~CCSTeam( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSTeam::Precache( void )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called every frame
+//-----------------------------------------------------------------------------
+void CCSTeam::Think( void )
+{
+}
+
+
+//------------------------------------------------------------------------------------------------------------------
+// PLAYERS
+//-----------------------------------------------------------------------------
+// Purpose: Add the specified player to this team. Remove them from their current team, if any.
+//-----------------------------------------------------------------------------
+void CCSTeam::AddPlayer( CBasePlayer *pPlayer )
+{
+	BaseClass::AddPlayer( pPlayer );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Clean up the player's objects when they leave
+//-----------------------------------------------------------------------------
+void CCSTeam::RemovePlayer( CBasePlayer *pPlayer )
+{
+	BaseClass::RemovePlayer( pPlayer );
+}
+
+//------------------------------------------------------------------------------------------------------------------
+// UTILITY FUNCS
+//-----------------------------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCSTeam* CCSTeam::GetEnemyTeam()
+{
+	// Look for nearby enemy objects we can capture.
+	int iMyTeam = GetTeamNumber();
+	if( iMyTeam == 0 )
+		return NULL;
+
+	int iEnemyTeam = !(iMyTeam - 1) + 1;
+	return (CCSTeam*)GetGlobalTeam( iEnemyTeam );
+}
+
+
diff --git a/game/server/cstrike/cs_team.h b/game/server/cstrike/cs_team.h
new file mode 100644
index 00000000..683ee9bb
--- /dev/null
+++ b/game/server/cstrike/cs_team.h
@@ -0,0 +1,60 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Team management class. Contains all the details for a specific team
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_TEAM_H
+#define CS_TEAM_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "utlvector.h"
+#include "team.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Team Manager
+//-----------------------------------------------------------------------------
+class CCSTeam : public CTeam
+{
+	DECLARE_CLASS( CCSTeam, CTeam );
+public:
+	virtual ~CCSTeam( void );
+
+	DECLARE_SERVERCLASS();
+
+	// Initialization
+	virtual void Init( const char *pName, int iNumber );
+	
+	virtual void Precache( void );
+	virtual void Think( void );
+
+	//-----------------------------------------------------------------------------
+	// Players
+	//-----------------------------------------------------------------------------
+	virtual void AddPlayer( CBasePlayer *pPlayer );
+	virtual void RemovePlayer( CBasePlayer *pPlayer );
+
+	//-----------------------------------------------------------------------------
+	// Utility funcs
+	//-----------------------------------------------------------------------------
+	CCSTeam*		GetEnemyTeam();
+
+private:
+
+	// Used to distribute resources to a team
+	float	m_flNextResourceTime;
+
+	int		m_iLastUpdateSentAt;
+};
+
+
+extern CCSTeam *GetGlobalTFTeam( int iIndex );
+
+
+#endif // TF_TEAM_H
diff --git a/game/server/cstrike/cs_vehicle_jeep.cpp b/game/server/cstrike/cs_vehicle_jeep.cpp
new file mode 100644
index 00000000..11a378f4
--- /dev/null
+++ b/game/server/cstrike/cs_vehicle_jeep.cpp
@@ -0,0 +1,1566 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "vehicle_base.h"
+#include "engine/IEngineSound.h"
+#include "in_buttons.h"
+#include "ammodef.h"
+#include "IEffects.h"
+#include "beam_shared.h"
+#include "soundenvelope.h"
+#include "decals.h"
+#include "soundent.h"
+#include "te_effect_dispatch.h"
+#include "ndebugoverlay.h"
+#include "movevars_shared.h"
+#include "bone_setup.h"
+#include "ai_basenpc.h"
+#include "ai_hint.h"
+#include "globalstate.h"
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define	VEHICLE_HITBOX_DRIVER		1
+#define LOCK_SPEED					10
+#define JEEP_GUN_YAW				"vehicle_weapon_yaw"
+#define JEEP_GUN_PITCH				"vehicle_weapon_pitch"
+#define JEEP_GUN_SPIN				"gun_spin"
+#define	JEEP_GUN_SPIN_RATE			20
+
+#define CANNON_MAX_UP_PITCH			20
+#define CANNON_MAX_DOWN_PITCH		20
+#define CANNON_MAX_LEFT_YAW			90
+#define CANNON_MAX_RIGHT_YAW		90
+
+#define OVERTURNED_EXIT_WAITTIME	2.0f
+
+#define JEEP_AMMOCRATE_HITGROUP		5
+#define JEEP_WHEEL_COUNT			4
+
+#define	JEEP_AMMO_CRATE_CLOSE_DELAY	2.0f
+
+#define JEEP_DELTA_LENGTH_MAX	12.0f			// 1 foot
+#define JEEP_FRAMETIME_MIN		1e-6
+
+ConVar	hud_jeephint_numentries( "hud_jeephint_numentries", "10", FCVAR_NONE );
+ConVar	g_jeepexitspeed( "g_jeepexitspeed", "100", FCVAR_CHEAT );
+
+//=============================================================================
+//
+// Jeep water data.
+//
+struct JeepWaterData_t
+{
+	bool		m_bWheelInWater[JEEP_WHEEL_COUNT];
+	bool		m_bWheelWasInWater[JEEP_WHEEL_COUNT];
+	Vector		m_vecWheelContactPoints[JEEP_WHEEL_COUNT];
+	float		m_flNextRippleTime[JEEP_WHEEL_COUNT];
+	bool		m_bBodyInWater;
+	bool		m_bBodyWasInWater;
+
+	DECLARE_SIMPLE_DATADESC();
+};
+
+BEGIN_SIMPLE_DATADESC( JeepWaterData_t )
+	DEFINE_ARRAY( m_bWheelInWater,			FIELD_BOOLEAN,	JEEP_WHEEL_COUNT ),
+	DEFINE_ARRAY( m_bWheelWasInWater,			FIELD_BOOLEAN,	JEEP_WHEEL_COUNT ),
+	DEFINE_ARRAY( m_vecWheelContactPoints,	FIELD_VECTOR,	JEEP_WHEEL_COUNT ),
+	DEFINE_ARRAY( m_flNextRippleTime,			FIELD_TIME,		JEEP_WHEEL_COUNT ),
+	DEFINE_FIELD( m_bBodyInWater,				FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bBodyWasInWater,			FIELD_BOOLEAN ),
+END_DATADESC()	
+
+//-----------------------------------------------------------------------------
+// Purpose: Four wheel physics vehicle server vehicle with weaponry
+//-----------------------------------------------------------------------------
+class CJeepFourWheelServerVehicle : public CFourWheelServerVehicle
+{
+	typedef CFourWheelServerVehicle BaseClass;
+// IServerVehicle
+public:
+	bool		NPC_HasPrimaryWeapon( void ) { return true; }
+	void		NPC_AimPrimaryWeapon( Vector vecTarget );
+	int			GetExitAnimToUse( Vector &vecEyeExitEndpoint, bool &bAllPointsBlocked );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CPropJeep : public CPropVehicleDriveable
+{
+	DECLARE_CLASS( CPropJeep, CPropVehicleDriveable );
+
+public:
+
+	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+	CPropJeep( void );
+
+	// CPropVehicle
+	virtual void	OnRestore( void );
+	virtual void	ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData );
+	virtual void	DriveVehicle( float flFrameTime, CUserCmd *ucmd, int iButtonsDown, int iButtonsReleased );
+	virtual void	SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
+	virtual void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	virtual void	DampenEyePosition( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles );
+	virtual bool	AllowBlockedExit( CBasePlayer *pPlayer, int nRole ) { return false; }
+	virtual bool	CanExitVehicle( CBaseEntity *pEntity );
+	virtual bool	IsVehicleBodyInWater() { return m_WaterData.m_bBodyInWater; }
+
+	// CBaseEntity
+	void			Think(void);
+	void			Precache( void );
+	void			Spawn( void ); 
+
+	virtual void	CreateServerVehicle( void );
+	virtual Vector	BodyTarget( const Vector &posSrc, bool bNoisy = true );
+	virtual void	TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
+	virtual int		OnTakeDamage( const CTakeDamageInfo &info );
+	virtual void	EnterVehicle( CBasePlayer *pPlayer );
+	virtual void	ExitVehicle( int nRole );
+
+	void			AimGunAt( Vector *endPos, float flInterval );
+	bool			TauCannonHasBeenCutOff( void ) { return m_bGunHasBeenCutOff; }
+
+	// NPC Driving
+	bool			NPC_HasPrimaryWeapon( void ) { return true; }
+	void			NPC_AimPrimaryWeapon( Vector vecTarget );
+
+	const char		*GetTracerType( void ) { return "AR2Tracer"; }
+	void			DoImpactEffect( trace_t &tr, int nDamageType );
+
+	bool HeadlightIsOn( void ) { return m_bHeadlightIsOn; }
+	void HeadlightTurnOn( void ) { m_bHeadlightIsOn = true; }
+	void HeadlightTurnOff( void ) { m_bHeadlightIsOn = false; }
+
+private:
+
+	void		FireCannon( void );
+	void		ChargeCannon( void );
+	void		FireChargedCannon( void );
+
+	void		DrawBeam( const Vector &startPos, const Vector &endPos, float width );
+	void		StopChargeSound( void );
+	void		GetCannonAim( Vector *resultDir );
+
+	void		InitWaterData( void );
+	void		HandleWater( void );
+	bool		CheckWater( void );
+	void		CheckWaterLevel( void );
+	void		CreateSplash( const Vector &vecPosition );
+	void		CreateRipple( const Vector &vecPosition );
+
+	void		UpdateSteeringAngle( void );
+	void		CreateDangerSounds( void );
+
+	void		ComputePDControllerCoefficients( float *pCoefficientsOut, float flFrequency, float flDampening, float flDeltaTime );
+	void		DampenForwardMotion( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles, float flFrameTime );
+	void		DampenUpMotion( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles, float flFrameTime );
+
+	void		InputStartRemoveTauCannon( inputdata_t &inputdata );
+	void		InputFinishRemoveTauCannon( inputdata_t &inputdata );
+
+private:
+
+	bool			m_bGunHasBeenCutOff;
+	float			m_flDangerSoundTime;
+	int				m_nBulletType;
+	bool			m_bCannonCharging;
+	float			m_flCannonTime;
+	float			m_flCannonChargeStartTime;
+	Vector			m_vecGunOrigin;
+	CSoundPatch		*m_sndCannonCharge;
+	int				m_nSpinPos;
+	float			m_aimYaw;
+	float			m_aimPitch;
+	float			m_throttleDisableTime;
+	float			m_flAmmoCrateCloseTime;
+
+	// handbrake after the fact to keep vehicles from rolling
+	float			m_flHandbrakeTime;
+	bool			m_bInitialHandbrake;
+	
+	float			m_flOverturnedTime;
+
+	Vector			m_vecLastEyePos;
+	Vector			m_vecLastEyeTarget;
+	Vector			m_vecEyeSpeed;
+	Vector			m_vecTargetSpeed;
+
+	JeepWaterData_t	m_WaterData;
+
+	int				m_iNumberOfEntries;
+	int				m_nAmmoType;
+
+	// Seagull perching
+	float			m_flPlayerExitedTime;	// Time at which the player last left this vehicle
+	float			m_flLastSawPlayerAt;	// Time at which we last saw the player
+	EHANDLE			m_hLastPlayerInVehicle;
+	bool			m_bHasPoop;
+
+	CNetworkVar( bool, m_bHeadlightIsOn );
+};
+
+BEGIN_DATADESC( CPropJeep )
+	DEFINE_FIELD( m_bGunHasBeenCutOff, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_flDangerSoundTime, FIELD_TIME ),
+	DEFINE_FIELD( m_nBulletType, FIELD_INTEGER ),
+	DEFINE_FIELD( m_bCannonCharging, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_flCannonTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flCannonChargeStartTime, FIELD_TIME ),
+	DEFINE_FIELD( m_vecGunOrigin, FIELD_POSITION_VECTOR ),
+	DEFINE_SOUNDPATCH( m_sndCannonCharge ),
+	DEFINE_FIELD( m_nSpinPos, FIELD_INTEGER ),
+	DEFINE_FIELD( m_aimYaw, FIELD_FLOAT ),
+	DEFINE_FIELD( m_aimPitch, FIELD_FLOAT ),
+	DEFINE_FIELD( m_throttleDisableTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flHandbrakeTime, FIELD_TIME ),
+	DEFINE_FIELD( m_bInitialHandbrake, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_flOverturnedTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flAmmoCrateCloseTime, FIELD_FLOAT ),
+	DEFINE_FIELD( m_vecLastEyePos, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecLastEyeTarget, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecEyeSpeed, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_vecTargetSpeed, FIELD_POSITION_VECTOR ),
+	DEFINE_FIELD( m_bHeadlightIsOn, FIELD_BOOLEAN ),
+	DEFINE_EMBEDDED( m_WaterData ),
+
+	DEFINE_FIELD( m_iNumberOfEntries, FIELD_INTEGER ),
+	DEFINE_FIELD( m_nAmmoType, FIELD_INTEGER ),
+
+	DEFINE_FIELD( m_flPlayerExitedTime, FIELD_TIME ),
+	DEFINE_FIELD( m_flLastSawPlayerAt, FIELD_TIME ),
+	DEFINE_FIELD( m_hLastPlayerInVehicle, FIELD_EHANDLE ),
+	DEFINE_FIELD( m_bHasPoop, FIELD_BOOLEAN ),
+
+	DEFINE_INPUTFUNC( FIELD_VOID, "StartRemoveTauCannon", InputStartRemoveTauCannon ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "FinishRemoveTauCannon", InputFinishRemoveTauCannon ),
+
+END_DATADESC()
+
+IMPLEMENT_SERVERCLASS_ST( CPropJeep, DT_PropJeep )
+	SendPropBool( SENDINFO( m_bHeadlightIsOn ) ),
+END_SEND_TABLE();
+
+//LINK_ENTITY_TO_CLASS( prop_vehicle_jeep, CPropJeep );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CPropJeep::CPropJeep( void )
+{
+	m_bHasGun = true;
+	m_bGunHasBeenCutOff = false;
+	m_bCannonCharging = false;
+	m_flCannonChargeStartTime = 0;
+	m_flCannonTime = 0;
+	m_nBulletType = -1;
+	m_flOverturnedTime = 0.0f;
+	m_iNumberOfEntries = 0;
+
+	m_vecEyeSpeed.Init();
+
+	InitWaterData();
+
+	m_bUnableToFire = true;
+	m_flAmmoCrateCloseTime = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::CreateServerVehicle( void )
+{
+	// Create our armed server vehicle
+	m_pServerVehicle = new CJeepFourWheelServerVehicle();
+	m_pServerVehicle->SetVehicle( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::Precache( void )
+{
+	UTIL_PrecacheOther( "npc_seagull" );
+
+	PrecacheScriptSound( "PropJeep.AmmoClose" );
+	PrecacheScriptSound( "PropJeep.FireCannon" );
+	PrecacheScriptSound( "PropJeep.FireChargedCannon" );
+	PrecacheScriptSound( "PropJeep.AmmoOpen" );
+
+	PrecacheScriptSound( "Jeep.GaussCharge" );
+
+//	PrecacheModel( GAUSS_BEAM_SPRITE );
+
+	BaseClass::Precache();
+}
+
+//------------------------------------------------
+// Spawn
+//------------------------------------------------
+void CPropJeep::Spawn( void )
+{
+	// Setup vehicle as a real-wheels car.
+	SetVehicleType( VEHICLE_TYPE_CAR_WHEELS );
+
+	BaseClass::Spawn();
+	m_flHandbrakeTime = gpGlobals->curtime + 0.1;
+	m_bInitialHandbrake = false;
+
+	m_VehiclePhysics.SetHasBrakePedal( false );
+
+	m_flMinimumSpeedToEnterExit = LOCK_SPEED;
+
+	m_nBulletType = GetAmmoDef()->Index("GaussEnergy");
+
+	if ( m_bHasGun )
+	{
+		SetBodygroup( 1, true );
+	}
+	else
+	{
+		SetBodygroup( 1, false );
+	}
+
+	// Initialize pose parameters
+	SetPoseParameter( JEEP_GUN_YAW, 0 );
+	SetPoseParameter( JEEP_GUN_PITCH, 0 );
+	m_nSpinPos = 0;
+	SetPoseParameter( JEEP_GUN_SPIN, m_nSpinPos );
+	m_aimYaw = 0;
+	m_aimPitch = 0;
+
+	AddSolidFlags( FSOLID_NOT_STANDABLE );
+
+	CAmmoDef *pAmmoDef = GetAmmoDef();
+	m_nAmmoType = pAmmoDef->Index("GaussEnergy");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &tr - 
+//			nDamageType - 
+//-----------------------------------------------------------------------------
+void CPropJeep::DoImpactEffect( trace_t &tr, int nDamageType )
+{
+	//Draw our beam
+	DrawBeam( tr.startpos, tr.endpos, 2.4 );
+
+	if ( (tr.surface.flags & SURF_SKY) == false )
+	{
+		CPVSFilter filter( tr.endpos );
+		te->GaussExplosion( filter, 0.0f, tr.endpos, tr.plane.normal, 0 );
+
+		UTIL_ImpactTrace( &tr, m_nBulletType );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
+{
+	CTakeDamageInfo info = inputInfo;
+	if ( ptr->hitbox != VEHICLE_HITBOX_DRIVER )
+	{
+		if ( inputInfo.GetDamageType() & DMG_BULLET )
+		{
+			info.ScaleDamage( 0.0001 );
+		}
+	}
+
+	BaseClass::TraceAttack( info, vecDir, ptr, pAccumulator );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CPropJeep::OnTakeDamage( const CTakeDamageInfo &inputInfo )
+{
+	//Do scaled up physics damage to the car
+	CTakeDamageInfo info = inputInfo;
+	info.ScaleDamage( 25 );
+	
+	// HACKHACK: Scale up grenades until we get a better explosion/pressure damage system
+	if ( inputInfo.GetDamageType() & DMG_BLAST )
+	{
+		info.SetDamageForce( inputInfo.GetDamageForce() * 10 );
+	}
+	VPhysicsTakeDamage( info );
+
+	// reset the damage
+	info.SetDamage( inputInfo.GetDamage() );
+
+	// small amounts of shock damage disrupt the car, but aren't transferred to the player
+	if ( info.GetDamageType() == DMG_SHOCK )
+	{
+		if ( info.GetDamage() <= 10 )
+		{
+			// take 10% damage and make the engine stall
+			info.ScaleDamage( 0.1 );
+			m_throttleDisableTime = gpGlobals->curtime + 2;
+		}
+	}
+
+	//Check to do damage to driver
+	if ( GetDriver() )
+	{
+		//Take no damage from physics damages
+		if ( info.GetDamageType() & DMG_CRUSH )
+			return 0;
+
+		// Take the damage (strip out the DMG_BLAST)
+		info.SetDamageType( info.GetDamageType() & (~DMG_BLAST) );
+		GetDriver()->TakeDamage( info );
+	}
+
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+Vector CPropJeep::BodyTarget( const Vector &posSrc, bool bNoisy )
+{
+	Vector	shotPos;
+	matrix3x4_t	matrix;
+
+	int eyeAttachmentIndex = LookupAttachment("vehicle_driver_eyes");
+	GetAttachment( eyeAttachmentIndex, matrix );
+	MatrixGetColumn( matrix, 3, shotPos );
+
+	if ( bNoisy )
+	{
+		shotPos[0] += random->RandomFloat( -8.0f, 8.0f );
+		shotPos[1] += random->RandomFloat( -8.0f, 8.0f );
+		shotPos[2] += random->RandomFloat( -8.0f, 8.0f );
+	}
+
+	return shotPos;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Aim Gun at a target
+//-----------------------------------------------------------------------------
+void CPropJeep::AimGunAt( Vector *endPos, float flInterval )
+{
+	Vector	aimPos = *endPos;
+
+	// See if the gun should be allowed to aim
+	if ( IsOverturned() || m_bEngineLocked )
+	{
+		SetPoseParameter( JEEP_GUN_YAW, 0 );
+		SetPoseParameter( JEEP_GUN_PITCH, 0 );
+		SetPoseParameter( JEEP_GUN_SPIN, 0 );
+		return;
+
+		// Make the gun go limp and look "down"
+		Vector	v_forward, v_up;
+		AngleVectors( GetLocalAngles(), NULL, &v_forward, &v_up );
+		aimPos = WorldSpaceCenter() + ( v_forward * -32.0f ) - Vector( 0, 0, 128.0f );
+	}
+
+	matrix3x4_t gunMatrix;
+	GetAttachment( LookupAttachment("gun_ref"), gunMatrix );
+
+	// transform the enemy into gun space
+	Vector localEnemyPosition;
+	VectorITransform( aimPos, gunMatrix, localEnemyPosition );
+
+	// do a look at in gun space (essentially a delta-lookat)
+	QAngle localEnemyAngles;
+	VectorAngles( localEnemyPosition, localEnemyAngles );
+	
+	// convert to +/- 180 degrees
+	localEnemyAngles.x = UTIL_AngleDiff( localEnemyAngles.x, 0 );	
+	localEnemyAngles.y = UTIL_AngleDiff( localEnemyAngles.y, 0 );
+
+	float targetYaw = m_aimYaw + localEnemyAngles.y;
+	float targetPitch = m_aimPitch + localEnemyAngles.x;
+	
+	// Constrain our angles
+	float newTargetYaw	= clamp( targetYaw, -CANNON_MAX_LEFT_YAW, CANNON_MAX_RIGHT_YAW );
+	float newTargetPitch = clamp( targetPitch, -CANNON_MAX_DOWN_PITCH, CANNON_MAX_UP_PITCH );
+
+	// If the angles have been clamped, we're looking outside of our valid range
+	if ( fabs(newTargetYaw-targetYaw) > 1e-4 || fabs(newTargetPitch-targetPitch) > 1e-4 )
+	{
+		m_bUnableToFire = true;
+	}
+
+	targetYaw = newTargetYaw;
+	targetPitch = newTargetPitch;
+
+	// Exponentially approach the target
+	float yawSpeed = 8;
+	float pitchSpeed = 8;
+
+	m_aimYaw = UTIL_Approach( targetYaw, m_aimYaw, yawSpeed );
+	m_aimPitch = UTIL_Approach( targetPitch, m_aimPitch, pitchSpeed );
+
+	SetPoseParameter( JEEP_GUN_YAW, -m_aimYaw);
+	SetPoseParameter( JEEP_GUN_PITCH, -m_aimPitch );
+
+	InvalidateBoneCache();
+
+	// read back to avoid drift when hitting limits
+	// as long as the velocity is less than the delta between the limit and 180, this is fine.
+	m_aimPitch = -GetPoseParameter( JEEP_GUN_PITCH );
+	m_aimYaw = -GetPoseParameter( JEEP_GUN_YAW );
+
+	// Now draw crosshair for actual aiming point
+	Vector	vecMuzzle, vecMuzzleDir;
+	QAngle	vecMuzzleAng;
+
+	GetAttachment( "Muzzle", vecMuzzle, vecMuzzleAng );
+	AngleVectors( vecMuzzleAng, &vecMuzzleDir );
+
+	trace_t	tr;
+	UTIL_TraceLine( vecMuzzle, vecMuzzle + (vecMuzzleDir * MAX_TRACE_LENGTH), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+
+		// see if we hit something, if so, adjust endPos to hit location
+	if ( tr.fraction < 1.0 )
+	{
+		m_vecGunCrosshair = vecMuzzle + ( vecMuzzleDir * MAX_TRACE_LENGTH * tr.fraction );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::InitWaterData( void )
+{
+	m_WaterData.m_bBodyInWater = false;
+	m_WaterData.m_bBodyWasInWater = false;
+
+	for ( int iWheel = 0; iWheel < JEEP_WHEEL_COUNT; ++iWheel )
+	{
+		m_WaterData.m_bWheelInWater[iWheel] = false;
+		m_WaterData.m_bWheelWasInWater[iWheel] = false;
+		m_WaterData.m_vecWheelContactPoints[iWheel].Init();
+		m_WaterData.m_flNextRippleTime[iWheel] = 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::HandleWater( void )
+{
+	// Only check the wheels and engine in water if we have a driver (player).
+	if ( !GetDriver() )
+		return;
+
+	// Check to see if we are in water.
+	if ( CheckWater() )
+	{
+		for ( int iWheel = 0; iWheel < JEEP_WHEEL_COUNT; ++iWheel )
+		{
+			// Create an entry/exit splash!
+			if ( m_WaterData.m_bWheelInWater[iWheel] != m_WaterData.m_bWheelWasInWater[iWheel] )
+			{
+				CreateSplash( m_WaterData.m_vecWheelContactPoints[iWheel] );
+				CreateRipple( m_WaterData.m_vecWheelContactPoints[iWheel] );
+			}
+			
+			// Create ripples.
+			if ( m_WaterData.m_bWheelInWater[iWheel] && m_WaterData.m_bWheelWasInWater[iWheel] )
+			{
+				if ( m_WaterData.m_flNextRippleTime[iWheel] < gpGlobals->curtime )
+				{
+					// Stagger ripple times
+					m_WaterData.m_flNextRippleTime[iWheel] = gpGlobals->curtime + RandomFloat( 0.1, 0.3 );
+					CreateRipple( m_WaterData.m_vecWheelContactPoints[iWheel] );
+				}
+			}
+		}
+	}
+
+	// Save of data from last think.
+	for ( int iWheel = 0; iWheel < JEEP_WHEEL_COUNT; ++iWheel )
+	{
+		m_WaterData.m_bWheelWasInWater[iWheel] = m_WaterData.m_bWheelInWater[iWheel];
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CPropJeep::CheckWater( void )
+{
+	bool bInWater = false;
+
+	// Check all four wheels.
+	for ( int iWheel = 0; iWheel < JEEP_WHEEL_COUNT; ++iWheel )
+	{
+		// Get the current wheel and get its contact point.
+		IPhysicsObject *pWheel = m_VehiclePhysics.GetWheel( iWheel );
+		if ( !pWheel )
+			continue;
+
+		// Check to see if we hit water.
+		if ( pWheel->GetContactPoint( &m_WaterData.m_vecWheelContactPoints[iWheel], NULL ) )
+		{
+			m_WaterData.m_bWheelInWater[iWheel] = ( UTIL_PointContents( m_WaterData.m_vecWheelContactPoints[iWheel] ) & MASK_WATER ) ? true : false;
+			if ( m_WaterData.m_bWheelInWater[iWheel] )
+			{
+				bInWater = true;
+			}
+		}
+	}
+
+	// Check the body and the BONNET.
+	int iEngine = LookupAttachment( "vehicle_engine" );
+	Vector vecEnginePoint;
+	QAngle vecEngineAngles;
+	GetAttachment( iEngine, vecEnginePoint, vecEngineAngles );
+
+	m_WaterData.m_bBodyInWater = ( UTIL_PointContents( vecEnginePoint ) & MASK_WATER ) ? true : false;
+	if ( m_WaterData.m_bBodyInWater )
+	{
+		if ( m_bHasPoop )
+		{
+			RemoveAllDecals();
+			m_bHasPoop = false;
+		}
+
+		if ( !m_VehiclePhysics.IsEngineDisabled() )
+		{
+			m_VehiclePhysics.SetDisableEngine( true );
+		}
+	}
+	else
+	{
+		if ( m_VehiclePhysics.IsEngineDisabled() )
+		{
+			m_VehiclePhysics.SetDisableEngine( false );
+		}
+	}
+
+	if ( bInWater )
+	{
+		// Check the player's water level.
+		CheckWaterLevel();
+	}
+
+	return bInWater;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::CheckWaterLevel( void )
+{
+	CBaseEntity *pEntity = GetDriver();
+	if ( pEntity && pEntity->IsPlayer() )
+	{
+		CBasePlayer *pPlayer = static_cast<CBasePlayer*>( pEntity );
+		
+		Vector vecAttachPoint;
+		QAngle vecAttachAngles;
+		
+		// Check eyes. (vehicle_driver_eyes point)
+		int iAttachment = LookupAttachment( "vehicle_driver_eyes" );
+		GetAttachment( iAttachment, vecAttachPoint, vecAttachAngles );
+
+		// Add the jeep's Z view offset
+		Vector vecUp;
+		AngleVectors( vecAttachAngles, NULL, NULL, &vecUp );
+		vecUp.z = clamp( vecUp.z, 0.0f, vecUp.z );
+		vecAttachPoint.z += r_JeepViewZHeight.GetFloat() * vecUp.z;
+
+		bool bEyes = ( UTIL_PointContents( vecAttachPoint ) & MASK_WATER ) ? true : false;
+		if ( bEyes )
+		{
+			pPlayer->SetWaterLevel( WL_Eyes );
+			return;
+		}
+
+		// Check waist.  (vehicle_engine point -- see parent function).
+		if ( m_WaterData.m_bBodyInWater )
+		{
+			pPlayer->SetWaterLevel( WL_Waist );
+			return;
+		}
+
+		// Check feet. (vehicle_feet_passenger0 point)
+		iAttachment = LookupAttachment( "vehicle_feet_passenger0" );
+		GetAttachment( iAttachment, vecAttachPoint, vecAttachAngles );
+		bool bFeet = ( UTIL_PointContents( vecAttachPoint ) & MASK_WATER ) ? true : false;
+		if ( bFeet )
+		{
+			pPlayer->SetWaterLevel( WL_Feet );
+			return;
+		}
+
+		// Not in water.
+		pPlayer->SetWaterLevel( WL_NotInWater );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::CreateSplash( const Vector &vecPosition )
+{
+	// Splash data.
+	CEffectData	data;
+	data.m_fFlags = 0;
+	data.m_vOrigin = vecPosition;
+	data.m_vNormal.Init( 0.0f, 0.0f, 1.0f );
+	VectorAngles( data.m_vNormal, data.m_vAngles );
+	data.m_flScale = 10.0f + random->RandomFloat( 0, 2 );
+
+	// Create the splash..
+	DispatchEffect( "watersplash", data );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::CreateRipple( const Vector &vecPosition )
+{
+	// Ripple data.
+	CEffectData	data;
+	data.m_fFlags = 0;
+	data.m_vOrigin = vecPosition;
+	data.m_vNormal.Init( 0.0f, 0.0f, 1.0f );
+	VectorAngles( data.m_vNormal, data.m_vAngles );
+	data.m_flScale = 10.0f + random->RandomFloat( 0, 2 );
+	if ( GetWaterType() & CONTENTS_SLIME )
+	{
+		data.m_fFlags |= FX_WATER_IN_SLIME;
+	}
+
+	// Create the ripple.
+	DispatchEffect( "waterripple", data );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::Think(void)
+{
+	BaseClass::Think();
+
+/*
+	CBasePlayer	*pPlayer = UTIL_GetLocalPlayer();
+
+	if ( m_bEngineLocked )
+	{
+		m_bUnableToFire = true;
+		
+		if ( pPlayer != NULL )
+		{
+			pPlayer->m_Local.m_iHideHUD |= HIDEHUD_VEHICLE_CROSSHAIR;
+		}
+	}
+	else
+	{
+		// Start this as false and update it again each frame
+		m_bUnableToFire = false;
+
+		if ( pPlayer != NULL )
+		{
+			pPlayer->m_Local.m_iHideHUD &= ~HIDEHUD_VEHICLE_CROSSHAIR;
+		}
+	}
+*/
+
+	// Water!?
+	HandleWater();
+
+	SetSimulationTime( gpGlobals->curtime );
+	
+	SetNextThink( gpGlobals->curtime );
+	SetAnimatedEveryTick( true );
+
+    if ( !m_bInitialHandbrake )	// after initial timer expires, set the handbrake
+	{
+		m_bInitialHandbrake = true;
+		m_VehiclePhysics.SetHandbrake( true );
+		m_VehiclePhysics.Think();
+	}
+
+	// Check overturned status.
+	if ( !IsOverturned() )
+	{
+		m_flOverturnedTime = 0.0f;
+	}
+	else
+	{
+		m_flOverturnedTime += gpGlobals->frametime;
+	}
+
+	// spin gun if charging cannon
+	//FIXME: Don't bother for E3
+	if ( m_bCannonCharging )
+	{
+		m_nSpinPos += JEEP_GUN_SPIN_RATE;
+		SetPoseParameter( JEEP_GUN_SPIN, m_nSpinPos );
+	}
+
+	// Aim gun based on the player view direction.
+	if ( m_hPlayer && !m_bExitAnimOn && !m_bEnterAnimOn )
+	{
+		Vector vecEyeDir, vecEyePos;
+		m_hPlayer->EyePositionAndVectors( &vecEyePos, &vecEyeDir, NULL, NULL );
+
+		// Trace out from the player's eye point.
+		Vector	vecEndPos = vecEyePos + ( vecEyeDir * MAX_TRACE_LENGTH );
+		trace_t	trace;
+		UTIL_TraceLine( vecEyePos, vecEndPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &trace );
+
+		// See if we hit something, if so, adjust end position to hit location.
+		if ( trace.fraction < 1.0 )
+		{
+   			vecEndPos = vecEyePos + ( vecEyeDir * MAX_TRACE_LENGTH * trace.fraction );
+		}
+
+		//m_vecLookCrosshair = vecEndPos;
+		AimGunAt( &vecEndPos, 0.1f );
+	}
+
+	StudioFrameAdvance();
+
+	// If the enter or exit animation has finished, tell the server vehicle
+	if ( IsSequenceFinished() && (m_bExitAnimOn || m_bEnterAnimOn) )
+	{
+		if ( m_bEnterAnimOn )
+		{
+			m_VehiclePhysics.ReleaseHandbrake();
+			StartEngine();
+
+			// HACKHACK: This forces the jeep to play a sound when it gets entered underwater
+			if ( m_VehiclePhysics.IsEngineDisabled() )
+			{
+				CBaseServerVehicle *pServerVehicle = dynamic_cast<CBaseServerVehicle *>(GetServerVehicle());
+				if ( pServerVehicle )
+				{
+					pServerVehicle->SoundStartDisabled();
+				}
+			}
+
+			// The first few time we get into the jeep, print the jeep help
+			if ( m_iNumberOfEntries < hud_jeephint_numentries.GetInt() )
+			{
+				UTIL_HudHintText( m_hPlayer, "#Valve_Hint_JeepKeys" );
+				m_iNumberOfEntries++;
+			}
+		}
+		
+		// If we're exiting and have had the tau cannon removed, we don't want to reset the animation
+		GetServerVehicle()->HandleEntryExitFinish( m_bExitAnimOn, !(m_bExitAnimOn && TauCannonHasBeenCutOff()) );
+	}
+
+	// See if the ammo crate needs to close
+	if ( ( m_flAmmoCrateCloseTime < gpGlobals->curtime ) && ( GetSequence() == LookupSequence( "ammo_open" ) ) )
+	{
+		m_flAnimTime = gpGlobals->curtime;
+		m_flPlaybackRate = 0.0;
+		SetCycle( 0 );
+		ResetSequence( LookupSequence( "ammo_close" ) );
+	}
+	else if ( ( GetSequence() == LookupSequence( "ammo_close" ) ) && IsSequenceFinished() )
+	{
+		m_flAnimTime = gpGlobals->curtime;
+		m_flPlaybackRate = 0.0;
+		SetCycle( 0 );
+		ResetSequence( LookupSequence( "idle" ) );
+
+		CPASAttenuationFilter sndFilter( this, "PropJeep.AmmoClose" );
+		EmitSound( sndFilter, entindex(), "PropJeep.AmmoClose" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &startPos - 
+//			&endPos - 
+//			width - 
+//			useMuzzle - 
+//-----------------------------------------------------------------------------
+void CPropJeep::DrawBeam( const Vector &startPos, const Vector &endPos, float width )
+{
+	/*
+	//Tracer down the middle
+	UTIL_Tracer( startPos, endPos, 0, TRACER_DONT_USE_ATTACHMENT, 6500, false, "GaussTracer" );
+
+	//Draw the main beam shaft
+	CBeam *pBeam = CBeam::BeamCreate( GAUSS_BEAM_SPRITE, 0.5 );
+	
+	pBeam->SetStartPos( startPos );
+	pBeam->PointEntInit( endPos, this );
+	pBeam->SetEndAttachment( LookupAttachment("Muzzle") );
+	pBeam->SetWidth( width );
+	pBeam->SetEndWidth( 0.05f );
+	pBeam->SetBrightness( 255 );
+	pBeam->SetColor( 255, 185+random->RandomInt( -16, 16 ), 40 );
+	pBeam->RelinkBeam();
+	pBeam->LiveForTime( 0.1f );
+
+	//Draw electric bolts along shaft
+	pBeam = CBeam::BeamCreate( GAUSS_BEAM_SPRITE, 3.0f );
+	
+	pBeam->SetStartPos( startPos );
+	pBeam->PointEntInit( endPos, this );
+	pBeam->SetEndAttachment( LookupAttachment("Muzzle") );
+
+	pBeam->SetBrightness( random->RandomInt( 64, 255 ) );
+	pBeam->SetColor( 255, 255, 150+random->RandomInt( 0, 64 ) );
+	pBeam->RelinkBeam();
+	pBeam->LiveForTime( 0.1f );
+	pBeam->SetNoise( 1.6f );
+	pBeam->SetEndWidth( 0.1f ); */
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::FireCannon( void )
+{
+	//Don't fire again if it's been too soon
+	if ( m_flCannonTime > gpGlobals->curtime )
+		return;
+
+	if ( m_bUnableToFire )
+		return;
+
+	m_flCannonTime = gpGlobals->curtime + 0.2f;
+	m_bCannonCharging = false;
+
+	//Find the direction the gun is pointing in
+	Vector aimDir;
+	GetCannonAim( &aimDir );
+
+	FireBulletsInfo_t	info( 1, m_vecGunOrigin, aimDir, VECTOR_CONE_1DEGREES, MAX_TRACE_LENGTH, m_nAmmoType );
+
+	info.m_nFlags = FIRE_BULLETS_ALLOW_WATER_SURFACE_IMPACTS;
+	info.m_pAttacker = m_hPlayer;
+
+	FireBullets( info );
+
+	// Register a muzzleflash for the AI
+	if ( m_hPlayer )
+	{
+		m_hPlayer->SetMuzzleFlashTime( gpGlobals->curtime + 0.5 );
+	}
+
+	CPASAttenuationFilter sndFilter( this, "PropJeep.FireCannon" );
+	EmitSound( sndFilter, entindex(), "PropJeep.FireCannon" );
+	
+	// make cylinders of gun spin a bit
+	m_nSpinPos += JEEP_GUN_SPIN_RATE;
+	//SetPoseParameter( JEEP_GUN_SPIN, m_nSpinPos );	//FIXME: Don't bother with this for E3, won't look right
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::FireChargedCannon( void )
+{
+/*	bool penetrated = false;
+
+	m_bCannonCharging	= false;
+	m_flCannonTime		= gpGlobals->curtime + 0.5f;
+
+	StopChargeSound();
+
+	CPASAttenuationFilter sndFilter( this, "PropJeep.FireChargedCannon" );
+	EmitSound( sndFilter, entindex(), "PropJeep.FireChargedCannon" );
+
+	//Find the direction the gun is pointing in
+	Vector aimDir;
+	GetCannonAim( &aimDir );
+
+	Vector endPos = m_vecGunOrigin + ( aimDir * MAX_TRACE_LENGTH );
+	
+	//Shoot a shot straight out
+	trace_t	tr;
+	UTIL_TraceLine( m_vecGunOrigin, endPos, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+	
+	ClearMultiDamage();
+
+	//Find how much damage to do
+	float flChargeAmount = ( gpGlobals->curtime - m_flCannonChargeStartTime ) / MAX_GAUSS_CHARGE_TIME;
+
+	//Clamp this
+	if ( flChargeAmount > 1.0f )
+	{
+		flChargeAmount = 1.0f;
+	}
+
+	//Determine the damage amount
+	//FIXME: Use ConVars!
+	float flDamage = 15 + ( ( 250 - 15 ) * flChargeAmount );
+
+	CBaseEntity *pHit = tr.m_pEnt;
+	
+	//Look for wall penetration
+	if ( tr.DidHitWorld() && !(tr.surface.flags & SURF_SKY) )
+	{
+		//Try wall penetration
+		UTIL_ImpactTrace( &tr, m_nBulletType, "ImpactJeep" );
+		UTIL_DecalTrace( &tr, "RedGlowFade" );
+
+		CPVSFilter filter( tr.endpos );
+		te->GaussExplosion( filter, 0.0f, tr.endpos, tr.plane.normal, 0 );
+		
+		Vector	testPos = tr.endpos + ( aimDir * 48.0f );
+
+		UTIL_TraceLine( testPos, tr.endpos, MASK_SHOT, GetDriver(), COLLISION_GROUP_NONE, &tr );
+			
+		if ( tr.allsolid == false )
+		{
+			UTIL_DecalTrace( &tr, "RedGlowFade" );
+
+			penetrated = true;
+		}
+	}
+	else if ( pHit != NULL )
+	{
+		CTakeDamageInfo dmgInfo( this, GetDriver(), flDamage, DMG_SHOCK );
+		CalculateBulletDamageForce( &dmgInfo, GetAmmoDef()->Index("GaussEnergy"), aimDir, tr.endpos, 1.0f + flChargeAmount * 4.0f );
+
+		//Do direct damage to anything in our path
+		pHit->DispatchTraceAttack( dmgInfo, aimDir, &tr );
+	}
+
+	ApplyMultiDamage();
+
+	//Kick up an effect
+	if ( !(tr.surface.flags & SURF_SKY) )
+	{
+  		UTIL_ImpactTrace( &tr, m_nBulletType, "ImpactJeep" );
+
+		//Do a gauss explosion
+		CPVSFilter filter( tr.endpos );
+		te->GaussExplosion( filter, 0.0f, tr.endpos, tr.plane.normal, 0 );
+	}
+
+	//Show the effect
+	DrawBeam( m_vecGunOrigin, tr.endpos, 9.6 );
+
+	// Register a muzzleflash for the AI
+	if ( m_hPlayer )
+	{
+		m_hPlayer->SetMuzzleFlashTime( gpGlobals->curtime + 0.5f );
+	}
+
+	//Rock the car
+	IPhysicsObject *pObj = VPhysicsGetObject();
+
+	if ( pObj != NULL )
+	{
+		Vector	shoveDir = aimDir * -( flDamage * 500.0f );
+
+		pObj->ApplyForceOffset( shoveDir, m_vecGunOrigin );
+	}
+
+	//Do radius damage if we didn't penetrate the wall
+	if ( penetrated == true )
+	{
+		RadiusDamage( CTakeDamageInfo( this, this, flDamage, DMG_SHOCK ), tr.endpos, 200.0f, CLASS_NONE, NULL );
+	} */
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::ChargeCannon( void )
+{
+	//Don't fire again if it's been too soon
+	if ( m_flCannonTime > gpGlobals->curtime )
+		return;
+
+	//See if we're starting a charge
+	if ( m_bCannonCharging == false )
+	{
+		m_flCannonChargeStartTime = gpGlobals->curtime;
+		m_bCannonCharging = true;
+
+		//Start charging sound
+		CPASAttenuationFilter filter( this );
+		m_sndCannonCharge = (CSoundEnvelopeController::GetController()).SoundCreate( filter, entindex(), CHAN_STATIC, "Jeep.GaussCharge", ATTN_NORM );
+
+		assert(m_sndCannonCharge!=NULL);
+		if ( m_sndCannonCharge != NULL )
+		{
+			(CSoundEnvelopeController::GetController()).Play( m_sndCannonCharge, 1.0f, 50 );
+			(CSoundEnvelopeController::GetController()).SoundChangePitch( m_sndCannonCharge, 250, 3.0f );
+		}
+
+		return;
+	}
+
+	//TODO: Add muzzle effect?
+
+	//TODO: Check for overcharge and have the weapon simply fire or instead "decharge"?
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::StopChargeSound( void )
+{
+	if ( m_sndCannonCharge != NULL )
+	{
+		(CSoundEnvelopeController::GetController()).SoundFadeOut( m_sndCannonCharge, 0.1f );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds the true aiming position of the gun (looks at what player 
+//			is looking at and adjusts)
+// Input  : &resultDir - direction to be calculated
+//-----------------------------------------------------------------------------
+void CPropJeep::GetCannonAim( Vector *resultDir )
+{
+	Vector	muzzleOrigin;
+	QAngle	muzzleAngles;
+
+	GetAttachment( LookupAttachment("gun_ref"), muzzleOrigin, muzzleAngles );
+
+	AngleVectors( muzzleAngles, resultDir );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: If the player uses the jeep while at the back, he gets ammo from the crate instead
+//-----------------------------------------------------------------------------
+void CPropJeep::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( pActivator );
+	
+	if ( pPlayer == NULL)
+		return;
+
+	// Find out if the player's looking at our ammocrate hitbox 
+	Vector vecForward;
+	pPlayer->EyeVectors( &vecForward, NULL, NULL );
+
+	trace_t tr;
+	Vector vecStart = pPlayer->EyePosition();
+	UTIL_TraceLine( vecStart, vecStart + vecForward * 1024, MASK_SOLID | CONTENTS_DEBRIS | CONTENTS_HITBOX, pPlayer, COLLISION_GROUP_NONE, &tr );
+	
+	if ( tr.m_pEnt == this && tr.hitgroup == JEEP_AMMOCRATE_HITGROUP )
+	{
+		// Player's using the crate.
+		// Fill up his SMG ammo.
+		pPlayer->GiveAmmo( 300, "SMG1");
+		
+		if ( ( GetSequence() != LookupSequence( "ammo_open" ) ) && ( GetSequence() != LookupSequence( "ammo_close" ) ) )
+		{
+			// Open the crate
+			m_flAnimTime = gpGlobals->curtime;
+			m_flPlaybackRate = 0.0;
+			SetCycle( 0 );
+			ResetSequence( LookupSequence( "ammo_open" ) );
+			
+			CPASAttenuationFilter sndFilter( this, "PropJeep.AmmoOpen" );
+			EmitSound( sndFilter, entindex(), "PropJeep.AmmoOpen" );
+		}
+
+		m_flAmmoCrateCloseTime = gpGlobals->curtime + JEEP_AMMO_CRATE_CLOSE_DELAY;
+		return;
+	}
+
+	// Fall back and get in the vehicle instead
+	BaseClass::Use( pActivator, pCaller, useType, value );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CPropJeep::CanExitVehicle( CBaseEntity *pEntity )
+{
+	return ( !m_bEnterAnimOn && !m_bExitAnimOn && !m_bLocked && (m_nSpeed <= g_jeepexitspeed.GetFloat() ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::DampenEyePosition( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles )
+{
+	// Get the frametime. (Check to see if enough time has passed to warrent dampening).
+	float flFrameTime = gpGlobals->frametime;
+	if ( flFrameTime < JEEP_FRAMETIME_MIN )
+	{
+		vecVehicleEyePos = m_vecLastEyePos;
+		DampenUpMotion( vecVehicleEyePos, vecVehicleEyeAngles, 0.0f );
+		return;
+	}
+
+	// Keep static the sideways motion.
+
+	// Dampen forward/backward motion.
+	DampenForwardMotion( vecVehicleEyePos, vecVehicleEyeAngles, flFrameTime );
+
+	// Blend up/down motion.
+	DampenUpMotion( vecVehicleEyePos, vecVehicleEyeAngles, flFrameTime );
+}
+
+//-----------------------------------------------------------------------------
+// Use the controller as follows:
+// speed += ( pCoefficientsOut[0] * ( targetPos - currentPos ) + pCoefficientsOut[1] * ( targetSpeed - currentSpeed ) ) * flDeltaTime;
+//-----------------------------------------------------------------------------
+void CPropJeep::ComputePDControllerCoefficients( float *pCoefficientsOut,
+												  float flFrequency, float flDampening,
+												  float flDeltaTime )
+{
+	float flKs = 9.0f * flFrequency * flFrequency;
+	float flKd = 4.5f * flFrequency * flDampening;
+
+	float flScale = 1.0f / ( 1.0f + flKd * flDeltaTime + flKs * flDeltaTime * flDeltaTime );
+
+	pCoefficientsOut[0] = flKs * flScale;
+	pCoefficientsOut[1] = ( flKd + flKs * flDeltaTime ) * flScale;
+}
+ 
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CPropJeep::DampenForwardMotion( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles, float flFrameTime )
+{
+	// Get forward vector.
+	Vector vecForward;
+	AngleVectors( vecVehicleEyeAngles, &vecForward);
+
+	// Simulate the eye position forward based on the data from last frame
+	// (assumes no acceleration - it will get that from the "spring").
+	Vector vecCurrentEyePos = m_vecLastEyePos + m_vecEyeSpeed * flFrameTime;
+
+	// Calculate target speed based on the current vehicle eye position and the last vehicle eye position and frametime.
+	Vector vecVehicleEyeSpeed = ( vecVehicleEyePos - m_vecLastEyeTarget ) / flFrameTime;
+	m_vecLastEyeTarget = vecVehicleEyePos;	
+
+	// Calculate the speed and position deltas.
+	Vector vecDeltaSpeed = vecVehicleEyeSpeed - m_vecEyeSpeed;
+	Vector vecDeltaPos = vecVehicleEyePos - vecCurrentEyePos;
+
+	// Clamp.
+	if ( vecDeltaPos.Length() > JEEP_DELTA_LENGTH_MAX )
+	{
+		float flSign = vecForward.Dot( vecVehicleEyeSpeed ) >= 0.0f ? -1.0f : 1.0f;
+		vecVehicleEyePos += flSign * ( vecForward * JEEP_DELTA_LENGTH_MAX );
+		m_vecLastEyePos = vecVehicleEyePos;
+		m_vecEyeSpeed = vecVehicleEyeSpeed;
+		return;
+	}
+
+	// Generate an updated (dampening) speed for use in next frames position extrapolation.
+	float flCoefficients[2];
+	ComputePDControllerCoefficients( flCoefficients, r_JeepViewDampenFreq.GetFloat(), r_JeepViewDampenDamp.GetFloat(), flFrameTime );
+	m_vecEyeSpeed += ( ( flCoefficients[0] * vecDeltaPos + flCoefficients[1] * vecDeltaSpeed ) * flFrameTime );
+
+	// Save off data for next frame.
+	m_vecLastEyePos = vecCurrentEyePos;
+
+	// Move eye forward/backward.
+	Vector vecForwardOffset = vecForward * ( vecForward.Dot( vecDeltaPos ) );
+	vecVehicleEyePos -= vecForwardOffset;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CPropJeep::DampenUpMotion( Vector &vecVehicleEyePos, QAngle &vecVehicleEyeAngles, float flFrameTime )
+{
+	// Get up vector.
+	Vector vecUp;
+	AngleVectors( vecVehicleEyeAngles, NULL, NULL, &vecUp );
+	vecUp.z = clamp( vecUp.z, 0.0f, vecUp.z );
+	vecVehicleEyePos.z += r_JeepViewZHeight.GetFloat() * vecUp.z;
+
+	// NOTE: Should probably use some damped equation here.
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
+{
+	// If we are overturned and hit any key - leave the vehicle (IN_USE is already handled!).
+	if ( m_flOverturnedTime > OVERTURNED_EXIT_WAITTIME )
+	{
+		if ( (ucmd->buttons & (IN_FORWARD|IN_BACK|IN_MOVELEFT|IN_MOVERIGHT|IN_SPEED|IN_JUMP|IN_ATTACK|IN_ATTACK2) ) && !m_bExitAnimOn )
+		{
+			// Can't exit yet? We're probably still moving. Swallow the keys.
+			if ( !CanExitVehicle(player) )
+				return;
+
+			if ( !GetServerVehicle()->HandlePassengerExit( m_hPlayer ) && ( m_hPlayer != NULL ) )
+			{
+				m_hPlayer->PlayUseDenySound();
+			}
+			return;
+		}
+	}
+
+	// If the throttle is disabled or we're upside-down, don't allow throttling (including turbo)
+	CUserCmd tmp;
+	if ( ( m_throttleDisableTime > gpGlobals->curtime ) || ( IsOverturned() ) )
+	{
+		m_bUnableToFire = true;
+		
+		tmp = (*ucmd);
+		tmp.buttons &= ~(IN_FORWARD|IN_BACK|IN_SPEED);
+		ucmd = &tmp;
+	}
+	
+	BaseClass::SetupMove( player, ucmd, pHelper, move );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::DriveVehicle( float flFrameTime, CUserCmd *ucmd, int iButtonsDown, int iButtonsReleased )
+{
+	int iButtons = ucmd->buttons;
+
+	//Adrian: No headlights on Superfly.
+/*	if ( ucmd->impulse == 100 )
+	{
+		if (HeadlightIsOn())
+		{
+			HeadlightTurnOff();
+		}
+        else 
+		{
+			HeadlightTurnOn();
+		}
+	}*/
+		
+	// If we're holding down an attack button, update our state
+	if ( IsOverturned() == false )
+	{
+		if ( iButtons & IN_ATTACK )
+		{
+			if ( m_bCannonCharging )
+			{
+				FireChargedCannon();
+			}
+			else
+			{
+				FireCannon();
+			}
+		}
+		else if ( iButtons & IN_ATTACK2 )
+		{
+			ChargeCannon();
+		}
+	}
+
+	// If we've released our secondary button, fire off our cannon
+	if ( ( iButtonsReleased & IN_ATTACK2 ) && ( m_bCannonCharging ) )
+	{
+		FireChargedCannon();
+	}
+
+	BaseClass::DriveVehicle( flFrameTime, ucmd, iButtonsDown, iButtonsReleased );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pPlayer - 
+//			*pMoveData - 
+//-----------------------------------------------------------------------------
+void CPropJeep::ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData )
+{
+	BaseClass::ProcessMovement( pPlayer, pMoveData );
+
+	// Create dangers sounds in front of the vehicle.
+	CreateDangerSounds();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create danger sounds in front of the vehicle.
+//-----------------------------------------------------------------------------
+void CPropJeep::CreateDangerSounds( void )
+{
+	QAngle dummy;
+	GetAttachment( "Muzzle", m_vecGunOrigin, dummy );
+
+	if ( m_flDangerSoundTime > gpGlobals->curtime )
+		return;
+
+	QAngle vehicleAngles = GetLocalAngles();
+	Vector vecStart = GetAbsOrigin();
+	Vector vecDir, vecRight;
+
+	GetVectors( &vecDir, &vecRight, NULL );
+
+	const float soundDuration = 0.25;
+	float speed = m_VehiclePhysics.GetHLSpeed();
+	// Make danger sounds ahead of the jeep
+	if ( fabs(speed) > 120 )
+	{
+		Vector	vecSpot;
+
+		float steering = m_VehiclePhysics.GetSteering();
+		if ( steering != 0 )
+		{
+			if ( speed > 0 )
+			{
+				vecDir += vecRight * steering * 0.5;
+			}
+			else
+			{
+				vecDir -= vecRight * steering * 0.5;
+			}
+			VectorNormalize(vecDir);
+		}
+		const float radius = speed * 0.4;
+		// 0.3 seconds ahead of the jeep
+		vecSpot = vecStart + vecDir * (speed * 0.3f);
+		CSoundEnt::InsertSound( SOUND_DANGER, vecSpot, radius, soundDuration, this, 0 );
+		CSoundEnt::InsertSound( SOUND_PHYSICS_DANGER, vecSpot, radius, soundDuration, this, 1 );
+		//NDebugOverlay::Box(vecSpot, Vector(-radius,-radius,-radius),Vector(radius,radius,radius), 255, 0, 255, 0, soundDuration);
+
+#if 0
+		trace_t	tr;
+		// put sounds a bit to left and right but slightly closer to Jeep to make a "cone" of sound 
+		// in front of it
+		vecSpot = vecStart + vecDir * (speed * 0.5f) - vecRight * speed * 0.5;
+		UTIL_TraceLine( vecStart, vecSpot, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+		CSoundEnt::InsertSound( SOUND_DANGER, vecSpot, 400, soundDuration, this, 1 );
+
+		vecSpot = vecStart + vecDir * (speed * 0.5f) + vecRight * speed * 0.5;
+		UTIL_TraceLine( vecStart, vecSpot, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+		CSoundEnt::InsertSound( SOUND_DANGER, vecSpot, 400, soundDuration, this, 2);
+#endif
+	}
+
+	m_flDangerSoundTime = gpGlobals->curtime + 0.1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::EnterVehicle( CBasePlayer *pPlayer )
+{
+	if ( !pPlayer )
+		return;
+
+	CheckWater();
+	BaseClass::EnterVehicle( pPlayer );
+
+	// Start looking for seagulls to land
+	m_hLastPlayerInVehicle = m_hPlayer;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::ExitVehicle( int nRole )
+{
+	HeadlightTurnOff();
+
+	BaseClass::ExitVehicle( nRole );
+
+	//If the player has exited, stop charging
+	StopChargeSound();
+	m_bCannonCharging = false;
+
+	// Remember when we last saw the player
+	m_flPlayerExitedTime = gpGlobals->curtime;
+	m_flLastSawPlayerAt = gpGlobals->curtime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::InputStartRemoveTauCannon( inputdata_t &inputdata )
+{
+	// Start the gun removal animation
+	m_flAnimTime = gpGlobals->curtime;
+	m_flPlaybackRate = 0.0;
+	SetCycle( 0 );
+	ResetSequence( LookupSequence( "tau_levitate" ) );
+
+	m_bGunHasBeenCutOff = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::InputFinishRemoveTauCannon( inputdata_t &inputdata )
+{
+	// Remove & hide the gun
+	SetBodygroup( 1, false );
+	m_bHasGun = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPropJeep::OnRestore( void )
+{
+	IServerVehicle *pServerVehicle = GetServerVehicle();
+	if ( pServerVehicle != NULL )
+	{
+		// Restore the passenger information we're holding on to
+		pServerVehicle->RestorePassengerInfo();
+	}
+}
+
+//========================================================================================================================================
+// JEEP FOUR WHEEL PHYSICS VEHICLE SERVER VEHICLE
+//========================================================================================================================================
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CJeepFourWheelServerVehicle::NPC_AimPrimaryWeapon( Vector vecTarget )
+{
+	((CPropJeep*)m_pVehicle)->AimGunAt( &vecTarget, 0.1f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &vecEyeExitEndpoint - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CJeepFourWheelServerVehicle::GetExitAnimToUse( Vector &vecEyeExitEndpoint, bool &bAllPointsBlocked )
+{
+	bAllPointsBlocked = false;
+
+	if ( !m_bParsedAnimations )
+	{
+		// Load the entry/exit animations from the vehicle
+		ParseEntryExitAnims();
+		m_bParsedAnimations = true;
+	}
+
+	CBaseAnimating *pAnimating = dynamic_cast<CBaseAnimating *>(m_pVehicle);
+	// If we don't have the gun anymore, we want to get out using the "gun-less" animation
+	if ( pAnimating && ((CPropJeep*)m_pVehicle)->TauCannonHasBeenCutOff() )
+	{
+		// HACK: We know the tau-cannon removed exit anim uses the first upright anim's exit details
+		trace_t tr;
+
+		// Convert our offset points to worldspace ones
+		Vector vehicleExitOrigin = m_ExitAnimations[0].vecExitPointLocal;
+		QAngle vehicleExitAngles = m_ExitAnimations[0].vecExitAnglesLocal;
+		UTIL_ParentToWorldSpace( pAnimating, vehicleExitOrigin, vehicleExitAngles );
+
+		// Ensure the endpoint is clear by dropping a point down from above
+		vehicleExitOrigin -= VEC_VIEW;
+		Vector vecMove = Vector(0,0,64);
+		Vector vecStart = vehicleExitOrigin + vecMove;
+		Vector vecEnd = vehicleExitOrigin - vecMove;
+  		UTIL_TraceHull( vecStart, vecEnd, VEC_HULL_MIN, VEC_HULL_MAX, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
+
+		Assert( !tr.startsolid && tr.fraction < 1.0 );
+		m_vecCurrentExitEndPoint = vecStart + ((vecEnd - vecStart) * tr.fraction);
+		vecEyeExitEndpoint = m_vecCurrentExitEndPoint + VEC_VIEW;
+		m_iCurrentExitAnim = 0;
+		return pAnimating->LookupSequence( "exit_tauremoved" );
+	}
+
+	return BaseClass::GetExitAnimToUse( vecEyeExitEndpoint, bAllPointsBlocked );
+}
diff --git a/game/server/cstrike/func_bomb_target.cpp b/game/server/cstrike/func_bomb_target.cpp
new file mode 100644
index 00000000..a85d646d
--- /dev/null
+++ b/game/server/cstrike/func_bomb_target.cpp
@@ -0,0 +1,84 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Bomb target area
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_player.h"
+#include "func_bomb_target.h"
+#include "cs_gamerules.h"
+
+LINK_ENTITY_TO_CLASS( func_bomb_target, CBombTarget );
+
+BEGIN_DATADESC( CBombTarget )
+	DEFINE_FUNCTION( BombTargetTouch ),
+	DEFINE_FUNCTION( BombTargetUse ),			//needed?
+
+	// Inputs
+	DEFINE_INPUTFUNC( FIELD_VOID, "BombExplode", OnBombExplode ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "BombPlanted", OnBombPlanted ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "BombDefused", OnBombDefused ),
+
+	// Outputs
+	DEFINE_OUTPUT( m_OnBombExplode,	"BombExplode" ),
+	DEFINE_OUTPUT( m_OnBombPlanted,	"BombPlanted" ),
+	DEFINE_OUTPUT( m_OnBombDefused,	"BombDefused" ),
+	DEFINE_KEYFIELD( m_bIsHeistBombTarget, FIELD_BOOLEAN, "heistbomb" ),
+	DEFINE_KEYFIELD( m_szMountTarget, FIELD_STRING, "bomb_mount_target" ),
+
+END_DATADESC()
+
+CBombTarget::CBombTarget( void )
+{
+	m_bIsHeistBombTarget = false;
+	m_szMountTarget = NULL_STRING;
+}
+
+void CBombTarget::Spawn()
+{
+	InitTrigger();
+	SetTouch( &CBombTarget::BombTargetTouch );
+	SetUse( &CBombTarget::BombTargetUse );
+}
+
+void CBombTarget::BombTargetTouch( CBaseEntity* pOther )
+{
+	CCSPlayer *p = dynamic_cast< CCSPlayer* >( pOther );
+	if ( p )
+	{
+		if ( p->HasC4() && CSGameRules()->m_bBombPlanted == false )
+		{
+			p->m_bInBombZone = true;
+			p->m_iBombSiteIndex = entindex();
+			if ( !(p->m_iDisplayHistoryBits & DHF_IN_TARGET_ZONE) )
+			{
+				p->HintMessage( "#Hint_you_are_in_targetzone", false );
+				p->m_iDisplayHistoryBits |= DHF_IN_TARGET_ZONE;
+			}
+		}
+	}
+}
+
+void CBombTarget::BombTargetUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	//SUB_UseTargets( NULL, USE_TOGGLE, 0 );
+	DevMsg( 2, "BombTargetUse does nothing\n" );
+}
+
+// Relay to our outputs
+void CBombTarget::OnBombExplode( inputdata_t &inputdata )
+{
+	m_OnBombExplode.FireOutput(this, this);
+}
+
+// Relay to our outputs
+void CBombTarget::OnBombPlanted( inputdata_t &inputdata )
+{
+	m_OnBombPlanted.FireOutput(this, this);
+}
+// Relay to our outputs
+void CBombTarget::OnBombDefused( inputdata_t &inputdata )
+{
+	m_OnBombDefused.FireOutput(this, this);
+}
\ No newline at end of file
diff --git a/game/server/cstrike/func_bomb_target.h b/game/server/cstrike/func_bomb_target.h
new file mode 100644
index 00000000..090b81dd
--- /dev/null
+++ b/game/server/cstrike/func_bomb_target.h
@@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Bomb Target Area ent
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "triggers.h"
+
+class CBombTarget : public CBaseTrigger
+{
+public:
+	DECLARE_CLASS( CBombTarget, CBaseTrigger );
+	DECLARE_DATADESC();
+
+	CBombTarget();
+
+	void Spawn();
+	void EXPORT BombTargetTouch( CBaseEntity* pOther );
+	void EXPORT BombTargetUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+	void OnBombExplode( inputdata_t &inputdata );
+	void OnBombPlanted( inputdata_t &inputdata );
+	void OnBombDefused( inputdata_t &inputdata );
+
+	bool	IsHeistBombTarget( void ) { return m_bIsHeistBombTarget; }
+	const char *GetBombMountTarget( void ){ return STRING( m_szMountTarget ); }
+
+private:
+	COutputEvent m_OnBombExplode;	//Fired when the bomb explodes
+	COutputEvent m_OnBombPlanted;	//Fired when the bomb is planted
+	COutputEvent m_OnBombDefused;	//Fired when the bomb is defused
+
+	bool		m_bIsHeistBombTarget;
+	string_t	m_szMountTarget;
+};
\ No newline at end of file
diff --git a/game/server/cstrike/func_buy_zone.cpp b/game/server/cstrike/func_buy_zone.cpp
new file mode 100644
index 00000000..a982fe4a
--- /dev/null
+++ b/game/server/cstrike/func_buy_zone.cpp
@@ -0,0 +1,77 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "triggers.h"
+#include "cs_player.h"
+
+
+//======================================
+// Bomb target area
+//
+//
+
+class CBuyZone : public CBaseTrigger
+{
+public:
+	DECLARE_CLASS( CBuyZone, CBaseTrigger );
+	DECLARE_DATADESC();
+
+	CBuyZone();
+	void Spawn();
+	void EXPORT BuyZoneTouch( CBaseEntity* pOther );
+
+public:
+	int m_LegacyTeamNum;
+};
+
+
+LINK_ENTITY_TO_CLASS( func_buyzone, CBuyZone );
+
+BEGIN_DATADESC( CBuyZone )
+	DEFINE_FUNCTION( BuyZoneTouch ),
+	
+	// This is here to support maps that haven't updated to using "teamnum" yet.
+	DEFINE_INPUT( m_LegacyTeamNum, FIELD_INTEGER, "team" )
+END_DATADESC()
+
+
+CBuyZone::CBuyZone()
+{
+	m_LegacyTeamNum = -1;
+}
+
+
+void CBuyZone::Spawn()
+{
+	InitTrigger();
+	SetTouch( &CBuyZone::BuyZoneTouch );
+
+	// Support for legacy-style teamnums.
+	if ( m_LegacyTeamNum == 1 )
+	{
+		ChangeTeam( TEAM_TERRORIST );
+	}
+	else if ( m_LegacyTeamNum == 2 )
+	{
+		ChangeTeam( TEAM_CT );
+	}
+}
+
+	
+void CBuyZone::BuyZoneTouch( CBaseEntity* pOther )
+{
+	CCSPlayer *p = dynamic_cast< CCSPlayer* >( pOther );
+	if ( p )
+	{
+		// compare player team with buy zone team number
+		if ( p->GetTeamNumber() == GetTeamNumber() )
+		{
+			p->m_bInBuyZone = true;
+		}
+	}
+}
+
diff --git a/game/server/cstrike/func_hostage_rescue.cpp b/game/server/cstrike/func_hostage_rescue.cpp
new file mode 100644
index 00000000..5a5166f5
--- /dev/null
+++ b/game/server/cstrike/func_hostage_rescue.cpp
@@ -0,0 +1,45 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "triggers.h"
+
+class CHostageRescueZone : public CBaseTrigger
+{
+public:
+	DECLARE_CLASS( CHostageRescueZone, CBaseTrigger );
+	DECLARE_DATADESC();
+
+	void CHostageRescue();
+	void Spawn();
+
+	void HostageRescueTouch( CBaseEntity* pOther );
+};
+
+
+LINK_ENTITY_TO_CLASS( func_hostage_rescue, CHostageRescueZone );
+
+
+BEGIN_DATADESC( CHostageRescueZone )
+
+	//Functions
+	DEFINE_FUNCTION( HostageRescueTouch ),
+
+END_DATADESC()
+
+
+void CHostageRescueZone::Spawn()
+{
+	InitTrigger();
+	SetTouch( &CHostageRescueZone::HostageRescueTouch );
+}
+
+void CHostageRescueZone::HostageRescueTouch( CBaseEntity *pOther )
+{
+	variant_t emptyVariant;
+	pOther->AcceptInput( "OnRescueZoneTouch", NULL, NULL, emptyVariant, 0 );
+}
+
diff --git a/game/server/cstrike/funfact_cs.cpp b/game/server/cstrike/funfact_cs.cpp
new file mode 100644
index 00000000..e8803599
--- /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);
diff --git a/game/server/cstrike/funfact_cs.h b/game/server/cstrike/funfact_cs.h
new file mode 100644
index 00000000..bed7bec7
--- /dev/null
+++ b/game/server/cstrike/funfact_cs.h
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef INCLUDED_funfact_cs
+#define INCLUDED_funfact_cs
+#pragma once
+
+#include "cs_player.h"
+
+struct FunFact
+{
+	FunFact() :
+		id(-1),
+		szLocalizationToken(NULL),
+		iPlayer(0),
+		iData1(0),
+		iData2(0),
+		iData3(0),
+		fMagnitude(0.0f)
+		{}
+	int id;
+	const char* szLocalizationToken;
+	int iPlayer;
+	int iData1;
+	int iData2;
+	int iData3;
+	float fMagnitude;
+};
+
+typedef CUtlVector<FunFact> FunFactVector;
+
+class FunFactEvaluator
+{
+	DECLARE_CLASS_NOBASE( FunFactEvaluator );
+public:
+	FunFactEvaluator( int id, const char* szLocalizationToken, float fCoolness ) :
+		m_id(id),
+		m_pLocalizationToken(szLocalizationToken),
+		m_fCoolness(fCoolness)
+	{}
+
+	virtual ~FunFactEvaluator() {}
+
+	int GetId() const { return m_id; }
+	const char* GetLocalizationToken() const { return m_pLocalizationToken; }
+	float GetCoolness() const { return m_fCoolness; }
+
+	virtual bool Evaluate( FunFactVector& results ) const = 0;
+
+private:
+	int  m_id;
+	const char* m_pLocalizationToken;
+	float m_fCoolness;
+};
+
+
+typedef FunFactEvaluator* (*funfactCreateFunc) (void);
+class CFunFactHelper
+{
+public:
+	CFunFactHelper ( funfactCreateFunc createFunc )
+	{
+		m_pfnCreate = createFunc;
+		m_pNext = s_pFirst;
+		s_pFirst = this;
+	}
+	funfactCreateFunc m_pfnCreate;
+	CFunFactHelper *m_pNext;
+	static CFunFactHelper *s_pFirst;
+};
+
+#endif // INCLUDED_funfact_cs
+
diff --git a/game/server/cstrike/funfactmgr_cs.cpp b/game/server/cstrike/funfactmgr_cs.cpp
new file mode 100644
index 00000000..4454e08d
--- /dev/null
+++ b/game/server/cstrike/funfactmgr_cs.cpp
@@ -0,0 +1,204 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#include "cbase.h"
+#include "usermessages.h"
+#include "funfactmgr_cs.h"
+
+const float kCooldownRatePlayer		= 0.4f;
+const float kCooldownRateFunFact	= 0.2f;
+
+const float kWeightPlayerCooldown	= 0.8f;
+const float kWeightFunFactCooldown	= 1.0f;
+const float kWeightCoolness			= 2.0f;
+const float kWeightRarity			= 1.0f;
+
+#define DEBUG_FUNFACT_SCORING 0
+
+//-----------------------------------------------------------------------------
+// Purpose: constructor
+//-----------------------------------------------------------------------------
+CCSFunFactMgr::CCSFunFactMgr() : 
+	CAutoGameSystemPerFrame( "CCSFunFactMgr" ),
+	m_funFactDatabase(0, 100, DefLessFunc(int) )
+{
+	for ( int i = 0; i < MAX_PLAYERS; ++i )
+	{
+		m_playerCooldown[i] = 0.0f;
+	}
+}
+
+CCSFunFactMgr::~CCSFunFactMgr()
+{
+	Shutdown();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Initializes the fun fact manager
+//-----------------------------------------------------------------------------
+bool CCSFunFactMgr::Init()
+{
+	ListenForGameEvent( "player_connect" );
+
+	CFunFactHelper *pFunFactHelper = CFunFactHelper::s_pFirst;
+
+	// create database of all fun fact evaluators (and initial usage metrics)
+	while ( pFunFactHelper )
+	{
+		FunFactDatabaseEntry entry;
+		entry.fCooldown = 0.0f;
+		entry.iOccurrences = 0;
+		entry.pEvaluator = pFunFactHelper->m_pfnCreate();
+		m_funFactDatabase.Insert(entry.pEvaluator->GetId(), entry);
+
+		pFunFactHelper = pFunFactHelper->m_pNext;
+	}
+
+	for (int i = 0; i < ARRAYSIZE(m_playerCooldown); ++i)
+	{
+		m_playerCooldown[i] = 0.0f;
+	}
+
+	m_numRounds = 0;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Shuts down the fun fact manager
+//-----------------------------------------------------------------------------
+void CCSFunFactMgr::Shutdown()
+{
+	FOR_EACH_MAP( m_funFactDatabase, iter )
+	{
+		delete m_funFactDatabase[iter].pEvaluator;
+	}
+	m_funFactDatabase.RemoveAll();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Per frame processing
+//-----------------------------------------------------------------------------
+void CCSFunFactMgr::Update( float frametime )
+{
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Listens for game events.  Clears out map based stats and player based stats when necessary
+//-----------------------------------------------------------------------------
+void CCSFunFactMgr::FireGameEvent( IGameEvent *event )
+{
+	const char *eventname = event->GetName();
+
+	if ( Q_strcmp( "player_connect", eventname ) == 0 )
+	{
+		int index = event->GetInt("index");// player slot (entity index-1)
+		ASSERT( index >= 0 && index < MAX_PLAYERS );
+		if( index >= 0 && index < MAX_PLAYERS )
+		{
+			m_playerCooldown[index] = 0.0f;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds the best fun fact to display and returns all necessary information through the parameters
+//-----------------------------------------------------------------------------
+bool CCSFunFactMgr::GetRoundEndFunFact( int iWinningTeam, int iRoundResult, FunFact& funfact )
+{
+	FunFactVector validFunFacts;
+
+	// Generate a vector of all valid fun facts for this round
+	FOR_EACH_MAP( m_funFactDatabase, i )
+	{
+		FunFact funFact;
+		if ( m_funFactDatabase[i].pEvaluator->Evaluate(validFunFacts) )
+		{
+			m_funFactDatabase[i].iOccurrences++;
+		}
+	}
+
+	m_numRounds++;
+
+	if (validFunFacts.Size() == 0)
+		return false;
+
+	// pick the fun fact with the highest score
+	float fBestScore = -FLT_MAX;
+	int iFunFactIndex = -1;
+
+#if DEBUG_FUNFACT_SCORING
+	Msg("Scoring fun facts:\n");
+#endif
+
+	FOR_EACH_VEC(validFunFacts, i)
+	{
+		float fScore = ScoreFunFact(validFunFacts[i]);
+
+#if DEBUG_FUNFACT_SCORING
+		char szPlayerName[64];
+		const FunFact& funfact = validFunFacts[i];
+		if (funfact.iPlayer > 0)
+			V_strncpy(szPlayerName, ToCSPlayer(UTIL_PlayerByIndex(funfact.iPlayer))->GetPlayerName(), sizeof(szPlayerName));
+		else
+			V_strcpy(szPlayerName, "");
+
+		Msg("(%5.4f) %s, %s, %i, %i, %i\n", fScore, funfact.szLocalizationToken, szPlayerName, funfact.iData1, funfact.iData2, funfact.iData3);
+#endif
+
+		if (fScore > fBestScore)
+		{
+			fBestScore = fScore;
+			iFunFactIndex = i;
+		}
+	}
+
+	if (iFunFactIndex < 0)
+		return false;
+	
+	funfact = validFunFacts[iFunFactIndex];
+
+	// decay player cooldowns
+	for (int i = 0; i < MAX_PLAYERS; ++i )
+	{
+		m_playerCooldown[i] *= (1.0f - kCooldownRatePlayer);
+	}
+
+	// decay funfact cooldowns
+	FOR_EACH_MAP(m_funFactDatabase, i)
+	{
+		m_funFactDatabase[i].fCooldown *= (1.0f - kCooldownRateFunFact);
+	}
+
+	// set player cooldown for player in funfact
+	if ( funfact.iPlayer )
+	{
+		m_playerCooldown[funfact.iPlayer - 1] = 1.0f;
+	}
+
+	// set funfact cooldown for current funfact
+	m_funFactDatabase[m_funFactDatabase.Find(funfact.id)].fCooldown = 1.0f;
+
+	return true;
+}
+
+float CCSFunFactMgr::ScoreFunFact( const FunFact& funfact )
+{
+	float fScore = 0.0f;
+	const FunFactDatabaseEntry& dbEntry = m_funFactDatabase[m_funFactDatabase.Find(funfact.id)];
+
+	// add the coolness score for the funfact
+	fScore += kWeightCoolness * dbEntry.pEvaluator->GetCoolness() * (1.0f + funfact.fMagnitude);
+
+	// subtract the cooldown for the funfact
+	fScore -= kWeightFunFactCooldown * dbEntry.fCooldown;
+	
+	// subtract the cooldown for the player
+	if ( funfact.iPlayer ) {
+		fScore -= kWeightPlayerCooldown * m_playerCooldown[funfact.iPlayer - 1];
+	}
+
+	// add the rarity bonus
+	fScore += kWeightRarity * powf((1.0f - (float)dbEntry.iOccurrences / m_numRounds), 2.0f);
+
+	return fScore;
+}
diff --git a/game/server/cstrike/funfactmgr_cs.h b/game/server/cstrike/funfactmgr_cs.h
new file mode 100644
index 00000000..aac715cd
--- /dev/null
+++ b/game/server/cstrike/funfactmgr_cs.h
@@ -0,0 +1,45 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#ifndef FUNFACTMGR_H
+#define FUNFACTMGR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "GameEventListener.h"
+#include "funfact_cs.h"
+#include "utlmap.h"
+
+class FunFactEvaluator;
+
+class CCSFunFactMgr : public CAutoGameSystemPerFrame, public CGameEventListener
+{
+public:
+	CCSFunFactMgr();
+	~CCSFunFactMgr();
+
+	virtual bool Init();
+	virtual void Shutdown();
+	virtual void Update( float frametime );
+
+	bool GetRoundEndFunFact( int iWinningTeam, int iRoundResult, FunFact& funfact );
+
+protected:
+	float ScoreFunFact( const FunFact& funfact );
+	void FireGameEvent( IGameEvent *event );
+
+private:
+
+	float m_playerCooldown[MAX_PLAYERS];	// Weights for all players.  Updated every round
+
+	struct FunFactDatabaseEntry
+	{
+		const FunFactEvaluator* pEvaluator;
+		int iOccurrences;
+		float fCooldown;
+	};
+	CUtlMap<int, FunFactDatabaseEntry> m_funFactDatabase;
+	int m_numRounds;
+};
+
+#endif
+
diff --git a/game/server/cstrike/holiday_gift.cpp b/game/server/cstrike/holiday_gift.cpp
new file mode 100644
index 00000000..afb2f0a6
--- /dev/null
+++ b/game/server/cstrike/holiday_gift.cpp
@@ -0,0 +1,128 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "smokegrenade_projectile.h"
+#include "sendproxy.h"
+#include "holiday_gift.h"
+#include "cs_player.h"
+#include "KeyValues.h"
+#include "bot_manager.h"
+#include "weapon_csbase.h"
+
+#define CHRISTMAS_MODEL "models/items/cs_gift.mdl"
+												  
+LINK_ENTITY_TO_CLASS( holiday_gift, CHolidayGift );
+PRECACHE_WEAPON_REGISTER( holiday_gift );
+
+//-----------------------------------------------------------------------------
+CHolidayGift* CHolidayGift::Create( const Vector &position, const QAngle &angles, const QAngle &eyeAngles, const Vector &velocity, CBaseCombatCharacter *pOwner )
+{
+	CHolidayGift *pGift = (CHolidayGift*)CBaseEntity::Create( "holiday_gift", position, angles, pOwner );
+	
+	if ( pGift )
+	{
+		pGift->AddSpawnFlags( SF_NORESPAWN );
+
+		Vector vecRight, vecUp;
+		AngleVectors( eyeAngles, NULL, &vecRight, &vecUp );
+
+		// Calculate the initial impulse on the gift.
+		Vector vecImpulse( 0.0f, 0.0f, 0.0f );
+		vecImpulse += vecUp * random->RandomFloat( 0, 0.25 );
+		vecImpulse += vecRight * random->RandomFloat( -0.25, 0.25 );
+		VectorNormalize( vecImpulse );
+		vecImpulse *= random->RandomFloat( 100.0, 150.0 );
+		vecImpulse += velocity;
+
+		// Cap the impulse.
+		float flSpeed = vecImpulse.Length();
+		if ( flSpeed > 300.0 )
+		{
+			VectorScale( vecImpulse, 300.0 / flSpeed, vecImpulse );
+		}
+
+		pGift->SetMoveType( MOVETYPE_FLYGRAVITY );
+		pGift->SetAbsVelocity( vecImpulse * 2.f + Vector(0,0,200) );
+		pGift->SetAbsAngles( QAngle(0,0,0) );
+		pGift->UseClientSideAnimation();
+		pGift->ResetSequence( pGift->LookupSequence("idle") );
+
+		pGift->EmitSound( "Christmas.GiftDrop" );
+
+		pGift->ActivateWhenAtRest();
+	}
+
+	return pGift;
+}
+
+//-----------------------------------------------------------------------------
+void CHolidayGift::Precache()
+{
+	BaseClass::Precache();
+
+	PrecacheModel( CHRISTMAS_MODEL );
+	PrecacheScriptSound( "Christmas.GiftDrop" );
+	PrecacheScriptSound( "Christmas.GiftPickup" );
+}
+
+//-----------------------------------------------------------------------------
+void CHolidayGift::Spawn( void )
+{ 
+	BaseClass::Spawn();
+
+	SetModel( CHRISTMAS_MODEL );
+
+	// Die in 30 seconds
+	SetContextThink( &CBaseEntity::SUB_Remove, gpGlobals->curtime + 30, "DIE_THINK" );
+	SetContextThink( &CHolidayGift::DropSoundThink, gpGlobals->curtime + 0.2f, "SOUND_THINK" );
+}
+
+//-----------------------------------------------------------------------------
+void CHolidayGift::DropSoundThink( void )
+{
+	EmitSound( "Christmas.GiftDrop" );
+}
+
+//-----------------------------------------------------------------------------
+bool CHolidayGift::MyTouch( CBasePlayer *pPlayer )
+{
+	if( !pPlayer )
+		return false;
+
+	if( !pPlayer->IsAlive() )
+		return false;
+
+	if ( pPlayer->IsBot() )
+		return false;
+
+	if ( ( pPlayer->GetTeamNumber() != TEAM_CT ) && ( pPlayer->GetTeamNumber() != TEAM_TERRORIST ) )
+		return false;
+
+	// Send a message for the achievement tracking.
+	IGameEvent *event = gameeventmanager->CreateEvent( "christmas_gift_grab" );
+	if ( event )
+	{
+		event->SetInt( "userid", pPlayer->GetUserID() );
+		gameeventmanager->FireEvent( event );
+	}
+	pPlayer->EmitSound( "Christmas.GiftPickup" );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+void CHolidayGift::ItemTouch( CBaseEntity *pOther )
+{
+	if ( pOther->IsWorld() )
+	{
+		Vector absVel = GetAbsVelocity();
+		SetAbsVelocity( Vector( 0,0,absVel.z ) );
+		return;
+	}
+
+	BaseClass::ItemTouch( pOther );
+}
diff --git a/game/server/cstrike/holiday_gift.h b/game/server/cstrike/holiday_gift.h
new file mode 100644
index 00000000..f5987bd4
--- /dev/null
+++ b/game/server/cstrike/holiday_gift.h
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HOLIDAY_GIFT_H
+#define HOLIDAY_GIFT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "items.h"
+
+
+class CHolidayGift: public CItem
+{
+public:
+	DECLARE_CLASS( CHolidayGift, CItem );
+
+public:
+	
+	virtual void Precache();
+	virtual void Spawn( void );
+	virtual bool MyTouch( CBasePlayer *pBasePlayer );
+	virtual void ItemTouch( CBaseEntity *pOther );
+	void DropSoundThink( void );
+
+public:
+
+	static CHolidayGift* Create( const Vector &position, const QAngle &angles, const QAngle &eyeAngles, const Vector &velocity, CBaseCombatCharacter *pOwner );
+};
+
+
+#endif // HOLIDAY_GIFT_H
diff --git a/game/server/cstrike/hostage/cs_simple_hostage.cpp b/game/server/cstrike/hostage/cs_simple_hostage.cpp
new file mode 100644
index 00000000..aacab391
--- /dev/null
+++ b/game/server/cstrike/hostage/cs_simple_hostage.cpp
@@ -0,0 +1,1345 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+// cs_simple_hostage.cpp
+// Simple CS1.6 level hostage
+// Author: Michael S. Booth and Matt Boone, July 2004
+
+#include "cbase.h"
+#include "cs_simple_hostage.h"
+#include "cs_player.h"
+#include "cs_gamerules.h"
+#include "game.h"
+#include "bot.h"
+#include <KeyValues.h>
+#include "obstacle_pushaway.h"
+#include "props_shared.h"
+
+//=============================================================================
+// HPE_BEGIN
+//=============================================================================
+// [dwenger] Necessary for stats tracking
+#include "cs_gamestats.h"
+
+//[tj] Necessary for fast rescue achievement
+#include "cs_achievement_constants.h"
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define HOSTAGE_THINK_INTERVAL	0.1f
+
+#define DrawLine( from, to, duration, red, green, blue )		NDebugOverlay::Line( from, to, red, green, blue, true, 0.1f )
+#define HOSTAGE_PUSHAWAY_THINK_CONTEXT	"HostagePushawayThink"
+
+#define HOSTAGE_BBOX_VEC_MIN	Vector( -13, -13, 0 )
+#define HOSTAGE_BBOX_VEC_MAX	Vector( 13, 13, 72 )
+
+
+ConVar mp_hostagepenalty( "mp_hostagepenalty", "13", FCVAR_NOTIFY, "Terrorist are kicked for killing too much hostages" );
+ConVar hostage_debug( "hostage_debug", "0", FCVAR_CHEAT, "Show hostage AI debug information" );
+
+extern ConVar sv_pushaway_force;
+extern ConVar sv_pushaway_min_player_speed;
+extern ConVar sv_pushaway_max_force;
+
+// We need hostage-specific pushaway cvars because the hostage doesn't have the same friction etc as players
+ConVar sv_pushaway_hostage_force( "sv_pushaway_hostage_force", "20000", FCVAR_REPLICATED | FCVAR_CHEAT, "How hard the hostage is pushed away from physics objects (falls off with inverse square of distance)." );
+ConVar sv_pushaway_max_hostage_force( "sv_pushaway_max_hostage_force", "1000", FCVAR_REPLICATED | FCVAR_CHEAT, "Maximum of how hard the hostage is pushed away from physics objects." );
+
+const int NumHostageModels = 4;
+static const char *HostageModel[NumHostageModels] = 
+{
+	"models/Characters/Hostage_01.mdl",
+	"models/Characters/Hostage_02.mdl",
+	"models/Characters/hostage_03.mdl",
+	"models/Characters/hostage_04.mdl",
+};
+
+Vector DropToGround( CBaseEntity *pMainEnt, const Vector &vPos, const Vector &vMins, const Vector &vMaxs );
+
+//-----------------------------------------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS( hostage_entity, CHostage );
+
+
+//-----------------------------------------------------------------------------------------------------
+BEGIN_DATADESC( CHostage )
+
+	DEFINE_INPUTFUNC( FIELD_VOID, "OnRescueZoneTouch", HostageRescueZoneTouch ),
+
+	DEFINE_USEFUNC( HostageUse ), 
+	DEFINE_THINKFUNC( HostageThink ),
+
+END_DATADESC()
+
+
+//-----------------------------------------------------------------------------------------------------
+IMPLEMENT_SERVERCLASS_ST( CHostage, DT_CHostage )
+	SendPropExclude( "DT_BaseAnimating", "m_flPoseParameter" ),
+	SendPropExclude( "DT_BaseAnimating", "m_flPlaybackRate" ),	
+	SendPropExclude( "DT_BaseAnimating", "m_nSequence" ),
+	SendPropExclude( "DT_BaseAnimating", "m_nNewSequenceParity" ),
+	SendPropExclude( "DT_BaseAnimating", "m_nResetEventsParity" ),
+	SendPropExclude( "DT_BaseAnimatingOverlay", "overlay_vars" ),
+	
+	// cs_playeranimstate and clientside animation takes care of these on the client
+	SendPropExclude( "DT_ServerAnimationData" , "m_flCycle" ),	
+	SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ),
+
+	SendPropBool( SENDINFO(m_isRescued) ),
+	SendPropInt( SENDINFO(m_iHealth), 10 ),
+	SendPropInt( SENDINFO(m_iMaxHealth), 10 ),
+	SendPropInt( SENDINFO(m_lifeState), 3, SPROP_UNSIGNED ),
+
+	SendPropEHandle( SENDINFO(m_leader) ),
+
+END_SEND_TABLE()
+
+
+//-----------------------------------------------------------------------------------------------------
+CUtlVector< CHostage * > g_Hostages;
+static CountdownTimer announceTimer;		// used to stop "hostage rescued" announcements from stepping on each other
+
+
+//-----------------------------------------------------------------------------------------------------
+CHostage::CHostage()
+{
+	g_Hostages.AddToTail( this );
+	m_PlayerAnimState = CreateHostageAnimState( this, this, LEGANIM_8WAY, false );
+	UseClientSideAnimation();
+	SetBloodColor( BLOOD_COLOR_RED );
+}
+
+//-----------------------------------------------------------------------------------------------------
+CHostage::~CHostage()
+{
+	g_Hostages.FindAndRemove( this );
+	m_PlayerAnimState->Release();
+}
+
+CWeaponCSBase* CHostage::CSAnim_GetActiveWeapon()
+{
+	return NULL;
+}
+
+bool CHostage::CSAnim_CanMove()
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------------------------------
+void CHostage::Spawn( void )
+{
+	Precache();
+
+	// round-robin through the hostage models
+	static int index = 0;
+	int whichModel = index % NumHostageModels;
+	++index;
+
+	SetModel( HostageModel[ whichModel ] );
+
+
+	SetHullType( HULL_HUMAN );
+
+	SetSolid( SOLID_BBOX );
+	AddSolidFlags( FSOLID_NOT_STANDABLE );
+	SetMoveType( MOVETYPE_STEP );
+	SetCollisionGroup( COLLISION_GROUP_PLAYER );
+
+	SetGravity( 1.0 );
+
+	m_iHealth = 100;	
+	m_iMaxHealth = m_iHealth;
+	m_takedamage = DAMAGE_YES;
+
+	InitBoneControllers( ); 
+
+	// we must set this, because its zero by default thus putting their eyes in their feet
+	SetViewOffset( Vector( 0, 0, 60 ) );
+
+
+	// set up think callback
+	SetNextThink( gpGlobals->curtime + HOSTAGE_THINK_INTERVAL );
+	SetThink( &CHostage::HostageThink );
+
+	SetContextThink( &CHostage::PushawayThink, gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, HOSTAGE_PUSHAWAY_THINK_CONTEXT );
+
+	SetUse( &CHostage::HostageUse );
+
+	m_leader = NULL;
+	m_reuseTimer.Invalidate();
+	m_hasBeenUsed = false;
+
+	m_isRescued = false;
+
+	m_vel = Vector( 0, 0, 0 );
+	m_accel = Vector( 0, 0, 0 );
+
+	m_path.Invalidate();
+	m_repathTimer.Invalidate();
+
+	m_pathFollower.Reset();
+	m_pathFollower.SetPath( &m_path );
+	m_pathFollower.SetImprov( this );
+
+	m_lastKnownArea = NULL;
+
+	// Need to make sure the hostages are on the ground when they spawn
+	Vector GroundPos = DropToGround( this, GetAbsOrigin(), HOSTAGE_BBOX_VEC_MIN, HOSTAGE_BBOX_VEC_MAX );
+	SetAbsOrigin( GroundPos );
+
+	if (TheNavMesh)
+	{
+		Vector pos = GetAbsOrigin();
+		m_lastKnownArea = TheNavMesh->GetNearestNavArea( pos );
+	}
+
+	m_isCrouching = false;
+	m_isRunning = true;
+	m_jumpTimer.Invalidate();
+	m_inhibitObstacleAvoidanceTimer.Invalidate();
+
+	m_isWaitingForLeader = false;
+	
+	m_isAdjusted = false;
+
+	m_lastLeaderID = 0;
+
+	announceTimer.Invalidate();
+	m_disappearTime = 0.0f;
+}
+
+//-----------------------------------------------------------------------------------------------------
+void CHostage::Precache()
+{
+	for ( int i=0; i<NumHostageModels; ++i )
+	{
+		PrecacheModel( HostageModel[i] );
+	}
+
+	PrecacheScriptSound( "Hostage.StartFollowCT" );
+	PrecacheScriptSound( "Hostage.StopFollowCT" );
+	PrecacheScriptSound( "Hostage.Pain" );
+
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------------------------------
+int CHostage::OnTakeDamage_Alive( const CTakeDamageInfo &info )
+{
+	float actualDamage = info.GetDamage();
+
+	// say something
+	EmitSound( "Hostage.Pain" );
+
+	CCSPlayer *player = ToCSPlayer( info.GetAttacker() );
+
+	if (player)
+	{
+        //=============================================================================
+        // HPE_BEGIN
+        // [dwenger] Track which player injured the hostage
+        //=============================================================================
+
+        player->SetInjuredAHostage(true);
+		CSGameRules()->HostageInjured();
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+
+		if ( !( player->m_iDisplayHistoryBits & DHF_HOSTAGE_INJURED ) )
+		{
+			player->HintMessage( "#Hint_careful_around_hostages", FALSE );
+			player->m_iDisplayHistoryBits |= DHF_HOSTAGE_INJURED;
+		}
+
+		IGameEvent *event = gameeventmanager->CreateEvent( "hostage_hurt" );
+		if ( event )
+		{
+			event->SetInt( "userid", player->GetUserID() );
+			event->SetInt( "hostage", entindex() );
+			event->SetInt( "priority", 5 );
+
+			gameeventmanager->FireEvent( event );
+		}
+
+		player->AddAccount( -((int)actualDamage * 20)  );
+	}
+
+	return BaseClass::OnTakeDamage_Alive( info );
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Modify damage the hostage takes by hitgroup
+ */
+float CHostage::GetModifiedDamage( float flDamage, int nHitGroup )
+{
+	switch ( nHitGroup )
+	{
+	case HITGROUP_GENERIC:	flDamage *=	1.75;	break;
+	case HITGROUP_HEAD:		flDamage *=	2.5;	break;
+	case HITGROUP_CHEST:	flDamage *=	1.5;	break;
+	case HITGROUP_STOMACH:	flDamage *=	1.75;	break;
+	case HITGROUP_LEFTARM:	flDamage *=	0.75;	break;
+	case HITGROUP_RIGHTARM:	flDamage *=	0.75;	break;
+	case HITGROUP_LEFTLEG:	flDamage *=	0.6;	break;
+	case HITGROUP_RIGHTLEG:	flDamage *=	0.6;	break;
+	default:				flDamage *=	1.5;	break;
+	} 
+
+	return flDamage;
+}
+
+//-----------------------------------------------------------------------------------------------------
+void CHostage::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
+{
+	CTakeDamageInfo scaledInfo = info;
+	scaledInfo.SetDamage( GetModifiedDamage( info.GetDamage(), ptr->hitgroup ) );
+	BaseClass::TraceAttack( scaledInfo, vecDir, ptr, pAccumulator );
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Check for hostage-killer abuse
+ */
+void CHostage::CheckForHostageAbuse( CCSPlayer *player )
+{
+	int hostageKillLimit = mp_hostagepenalty.GetInt();
+
+	if (hostageKillLimit > 0)
+	{
+		player->m_iHostagesKilled++;
+
+		if ( player->m_iHostagesKilled == hostageKillLimit - 1 )
+		{
+			player->HintMessage( "#Hint_removed_for_next_hostage_killed", TRUE );
+		}
+		else if ( player->m_iHostagesKilled >= hostageKillLimit )
+		{
+			Msg( "Kicking client \"%s\" for killing too many hostages\n", player->GetPlayerName() );
+			engine->ServerCommand( UTIL_VarArgs( "kickid %d \"For killing too many hostages\"\n", player->GetUserID() ) );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Hostage was killed
+ */
+void CHostage::Event_Killed( const CTakeDamageInfo &info )
+{
+	// tell the game logic that we've died
+	CSGameRules()->CheckWinConditions();
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Let the game know that a hostage has been killed
+	//=============================================================================
+	CSGameRules()->HostageKilled();
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	CCSPlayer *attacker = ToCSPlayer( info.GetAttacker() );
+
+	if (attacker)
+	{
+		if ( !( attacker->m_iDisplayHistoryBits & DHF_HOSTAGE_KILLED ) )
+		{
+			attacker->HintMessage( "#Hint_lost_money", FALSE );
+			attacker->m_iDisplayHistoryBits |= DHF_HOSTAGE_KILLED;
+		}
+
+		// monetary penalty for killing the hostage
+		attacker->AddAccount( -( 500 + ((int)info.GetDamage() * 20) ) );
+
+		// check for hostage-killer abuse
+		if (attacker->GetTeamNumber() == TEAM_TERRORIST)
+		{
+			CheckForHostageAbuse( attacker );
+		}
+	}
+
+	m_lastLeaderID = 0;
+
+	SetUse( NULL );	
+	BaseClass::Event_Killed( info );
+
+	IGameEvent *event = gameeventmanager->CreateEvent("hostage_killed");
+	if ( event )
+	{
+		event->SetInt( "userid", (attacker)?attacker->GetUserID():0 );
+		event->SetInt( "hostage", entindex() );
+		event->SetInt( "priority", 6 );
+		gameeventmanager->FireEvent( event );
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Invoked when a Hostage touches a Rescue Zone
+ */
+void CHostage::HostageRescueZoneTouch( inputdata_t &inputdata )
+{
+	if (!m_isRescued)
+	{
+		m_isRescued = true;
+		m_lastLeaderID = 0;
+
+		SetSolid( SOLID_NONE );
+		SetSolidFlags( 0 );
+
+		// start fading out
+		m_disappearTime = gpGlobals->curtime + 3.0f;
+
+		SetUse( NULL );
+		m_takedamage = DAMAGE_NO;
+
+		// give rescuer a cash bonus
+		CCSPlayer *player = GetLeader();
+		if (player)
+		{
+			const int rescuerCashBonus = 1000;
+			player->AddAccount( rescuerCashBonus );
+		}
+		
+		Idle();
+
+		// tell the bots someone has rescued a hostage
+		IGameEvent *event = gameeventmanager->CreateEvent( "hostage_rescued" );
+		if ( event )
+		{
+			event->SetInt( "userid", player ? player->GetUserID() : (-1) );
+			event->SetInt( "hostage", entindex() );
+			event->SetInt( "site", 0 ); // TODO add site index
+			event->SetInt( "priority", 9 );
+			gameeventmanager->FireEvent( event );
+		}
+
+		// update game rules
+		CSGameRules()->m_iHostagesRescued++;
+
+        //=============================================================================
+        // HPE_BEGIN
+        // [dwenger] Hostage rescue achievement processing
+        //=============================================================================
+
+        // Track last rescuer
+        if ( CSGameRules()->m_pLastRescuer == NULL )
+        {
+            // No rescuer yet, so assign one & set rescuer count to 1
+            CSGameRules()->m_pLastRescuer = player;
+            CSGameRules()->m_iNumRescuers = 1;
+        }
+        else
+        {
+            if ( CSGameRules()->m_pLastRescuer != player )
+            {
+                // Rescuer changed
+                CSGameRules()->m_pLastRescuer = player;
+                CSGameRules()->m_iNumRescuers++;
+            }
+        }
+
+		bool roundIsAlreadyOver = (CSGameRules()->m_iRoundWinStatus != WINNER_NONE);
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+		if (CSGameRules()->CheckWinConditions() == false)
+		{
+			// this hostage didn't win the round, so announce its rescue to everyone
+			if (announceTimer.IsElapsed())
+			{
+				CSGameRules()->BroadcastSound( "Event.HostageRescued" );
+			}
+
+			// avoid having the announcer talk over himself
+			announceTimer.Start( 2.0f );
+		}
+        //=============================================================================
+        // HPE_BEGIN
+        // [dwenger] Awarding of hostage rescue achievement
+        //=============================================================================
+
+        else
+        {
+            //Check hostage rescue achievements
+            if ( CSGameRules()->m_iNumRescuers == 1 && !CSGameRules()->WasHostageKilled())
+            {
+				//check for unrescued hostages
+				bool allHostagesRescued = true;				
+				CHostage* hostage = NULL;
+				int iNumHostages = g_Hostages.Count();				
+
+				for ( int i = 0 ; i < iNumHostages; i++ )
+				{
+					hostage = g_Hostages[i];
+
+					if ( hostage->m_iHealth > 0 && !hostage->IsRescued() )
+					{
+						allHostagesRescued = false;
+						break;
+					}
+				}
+
+				if (allHostagesRescued)
+				{
+					player->AwardAchievement(CSRescueAllHostagesInARound);
+
+					//[tj] fast version                
+					if (gpGlobals->curtime - CSGameRules()->GetRoundStartTime() < AchievementConsts::FastHostageRescue_Time)
+					{
+						if ( player )
+						{
+							player->AwardAchievement(CSFastHostageRescue);
+						}
+					}
+				}
+            }
+			//=============================================================================
+			// HPE_BEGIN:
+			// [menglish] If this rescue ended the round give an mvp to the rescuer
+			//=============================================================================
+
+            if ( player && !roundIsAlreadyOver)
+            {
+			    player->IncrementNumMVPs( CSMVP_HOSTAGERESCUE );
+            }
+
+			//=============================================================================
+			// HPE_END
+			//=============================================================================
+        }
+
+        if ( player )
+        {
+            CCS_GameStats.Event_HostageRescued( player );
+        }
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * In contact with "other"
+ */
+void CHostage::Touch( CBaseEntity *other )
+{
+	BaseClass::Touch( other );
+
+	// allow players and other hostages to push me around
+	if ( ( other->IsPlayer() && other->GetTeamNumber() == TEAM_CT ) || FClassnameIs( other, "hostage_entity" ) )
+	{
+		// only push in 2D
+		Vector to = GetAbsOrigin() - other->GetAbsOrigin();
+		to.z = 0.0f;
+		to.NormalizeInPlace();
+		
+		const float pushForce = 500.0f;
+		ApplyForce( pushForce * to );
+	}
+	else if ( m_inhibitDoorTimer.IsElapsed() &&
+		( other->ClassMatches( "func_door*" ) || other->ClassMatches( "prop_door*" ) ) )
+	{
+		m_inhibitDoorTimer.Start( 3.0f );
+		other->Use( this, this, USE_TOGGLE, 0.0f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/** 
+ * Hostage is stuck - attempt to wiggle out
+ */
+void CHostage::Wiggle( void )
+{
+	if (m_wiggleTimer.IsElapsed())
+	{
+		m_wiggleDirection = (NavRelativeDirType)RandomInt( 0, 3 );
+		m_wiggleTimer.Start( RandomFloat( 0.3f, 0.5f ) );
+	}
+
+	Vector dir, lat;
+	AngleVectors( GetAbsAngles(), &dir, &lat, NULL );
+
+	const float speed = 500.0f;
+
+	switch( m_wiggleDirection )
+	{
+		case LEFT:
+			ApplyForce( speed * lat );
+			break;
+
+		case RIGHT:
+			ApplyForce( -speed * lat );
+			break;
+
+		case FORWARD:
+			ApplyForce( speed * dir );
+			break;
+
+		case BACKWARD:
+			ApplyForce( -speed * dir );
+			break;
+	}
+
+	const float minStuckJumpTime = 0.25f;
+	if (m_pathFollower.GetStuckDuration() > minStuckJumpTime)
+	{
+		Jump();
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Do following behavior
+ */
+void CHostage::UpdateFollowing( float deltaT )
+{
+	if ( !IsFollowingSomeone() && m_lastLeaderID != 0 )
+	{
+		// emit hostage_stops_following event
+		IGameEvent *event = gameeventmanager->CreateEvent( "hostage_stops_following" );
+		if ( event )
+		{
+			event->SetInt( "userid", m_lastLeaderID );
+			event->SetInt( "hostage", entindex() );
+			event->SetInt( "priority", 6 );
+			gameeventmanager->FireEvent( event );
+		}
+
+		m_lastLeaderID = 0;
+	}
+
+	// if we have a leader, follow him
+	CCSPlayer *leader = GetLeader();
+	if (leader)
+	{
+		// if leader is dead, stop following him
+		if (!leader->IsAlive())
+		{
+			Idle();
+			return;
+		}
+
+		// if leader has moved, repath
+		if (m_path.IsValid())
+		{
+			Vector pathError = leader->GetAbsOrigin() - m_path.GetEndpoint();
+			
+			const float repathRange = 100.0f;
+			if (pathError.IsLengthGreaterThan( repathRange ))
+			{
+				m_path.Invalidate();
+			}
+		}
+
+
+		// build a path to our leader
+		if (!m_path.IsValid() && m_repathTimer.IsElapsed())
+		{
+			const float repathInterval = 0.5f;
+			m_repathTimer.Start( repathInterval );
+
+			Vector from = GetAbsOrigin();
+			Vector to = leader->GetAbsOrigin();
+			HostagePathCost pathCost;
+
+			m_path.Compute( from, to, pathCost );
+			m_pathFollower.Reset();
+		}
+
+
+		// if our rescuer is too far away, give up
+		const float giveUpRange = 2000.0f;
+		const float maxPathLength = 4000.0f;
+		Vector toLeader = leader->GetAbsOrigin() - GetAbsOrigin();
+		if (toLeader.IsLengthGreaterThan( giveUpRange ) || (m_path.IsValid() && m_path.GetLength() > maxPathLength))
+		{
+			if ( hostage_debug.GetInt() < 2 )
+			{
+				Idle();
+			}
+			return;
+		}
+
+		
+		// don't crowd the leader
+		if (m_isWaitingForLeader)
+		{
+			// we are close to our leader and waiting for him to move
+			const float waitRange = 150.0f;
+			if (toLeader.IsLengthGreaterThan( waitRange ))
+			{
+				// leader has moved away - follow him
+				m_isWaitingForLeader = false;
+			}
+
+			// face the leader
+			//FaceTowards( leader->GetAbsOrigin(), deltaT );
+		}
+		else
+		{
+			// we are far from our leader, and need to check if we're close enough to wait
+			const float nearRange = 125.0f;
+
+			if (toLeader.IsLengthLessThan( nearRange ))
+			{
+				// we are close to the leader - wait for him to move
+				m_isWaitingForLeader = true;
+			}
+		}
+
+		if (!m_isWaitingForLeader)
+		{
+			// move along path towards the leader
+			m_pathFollower.Update( deltaT, m_inhibitObstacleAvoidanceTimer.IsElapsed() );
+
+			if (hostage_debug.GetBool())
+			{
+				m_pathFollower.Debug( true );
+			}
+
+			if (m_pathFollower.IsStuck())
+			{
+				Wiggle();
+			}
+
+			if (hostage_debug.GetBool())
+			{
+				m_path.Draw();
+			}
+		}
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------------------------------
+void CHostage::AvoidPhysicsProps( void )
+{
+	if ( m_lifeState == LIFE_DEAD )
+		return;
+
+	CBaseEntity *props[512];
+	int nEnts = GetPushawayEnts( this, props, ARRAYSIZE( props ), 0.0f, PARTITION_ENGINE_SOLID_EDICTS );
+
+	for ( int i=0; i < nEnts; i++ )
+	{
+		// Don't respond to this entity on the client unless it has PHYSICS_MULTIPLAYER_FULL set.
+		IMultiplayerPhysics *pInterface = dynamic_cast<IMultiplayerPhysics*>( props[i] );
+		if ( pInterface && pInterface->GetMultiplayerPhysicsMode() != PHYSICS_MULTIPLAYER_SOLID )
+			continue;
+
+		const float minMass = 10.0f; // minimum mass that can push a player back
+		const float maxMass = 30.0f; // cap at a decently large value
+		float mass = maxMass;
+		if ( pInterface )
+		{
+			mass = pInterface->GetMass();
+		}
+		mass = MIN( mass, maxMass );
+		mass -= minMass;
+		mass = MAX( mass, 0 );
+		mass /= (maxMass-minMass); // bring into a 0..1 range
+
+		// Push away from the collision point. The closer our center is to the collision point,
+		// the harder we push away.
+		Vector vPushAway = (WorldSpaceCenter() - props[i]->WorldSpaceCenter());
+		float flDist = VectorNormalize( vPushAway );
+		flDist = MAX( flDist, 1 );
+
+		float flForce = sv_pushaway_hostage_force.GetFloat() / flDist * mass;
+		flForce = MIN( flForce, sv_pushaway_max_hostage_force.GetFloat() );
+		vPushAway *= flForce;
+
+		ApplyForce( vPushAway );
+	}
+
+	//
+	// Handle step and ledge "step-up" movement here, before m_accel is zero'd
+	//
+	if ( !m_accel.IsZero() )
+	{
+		trace_t trace;
+		Vector start = GetAbsOrigin();
+		Vector forward = m_accel;
+		forward.NormalizeInPlace();
+		UTIL_TraceEntity( this, start, start + forward, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER, &trace );
+		if ( !trace.startsolid && trace.fraction < 1.0f && trace.plane.normal.z < 0.7f )
+		{
+			float groundFraction = trace.fraction;
+			start.z += StepHeight;
+			UTIL_TraceEntity( this, start, start + forward, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER, &trace );
+			if ( !trace.startsolid && trace.fraction > groundFraction )
+			{
+				SetAbsOrigin( start );
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Push physics objects away from the hostage
+ */
+void CHostage::PushawayThink( void )
+{
+	PerformObstaclePushaway( this );
+	SetNextThink( gpGlobals->curtime + PUSHAWAY_THINK_INTERVAL, HOSTAGE_PUSHAWAY_THINK_CONTEXT );
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * @TODO imitate player movement:
+ * MoveHelperServer()->SetHost( this );
+ * this->PlayerRunCommand( &cmd, MoveHelperServer() );
+ */
+void CHostage::PhysicsSimulate( void )
+{
+	BaseClass::PhysicsSimulate();
+
+	SetAbsVelocity( m_vel );
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Update Hostage behaviors
+ */
+void CHostage::HostageThink( void )
+{
+	if (!m_isAdjusted)
+	{
+		m_isAdjusted = true;
+
+		// HACK - figure out why the default bbox is 6 units too low
+		SetCollisionBounds( HOSTAGE_BBOX_VEC_MIN, HOSTAGE_BBOX_VEC_MAX );
+	}
+
+	const float deltaT = HOSTAGE_THINK_INTERVAL;
+	SetNextThink( gpGlobals->curtime + deltaT );
+
+	// keep track of which Navigation Area we are in (or were in, if we're "off the mesh" right now)
+	CNavArea *area = TheNavMesh->GetNavArea( GetAbsOrigin() );
+	if (area != NULL && area != m_lastKnownArea)
+	{
+		// entered a new nav area
+		m_lastKnownArea = area;
+	}
+
+	// do leader-following behavior, if necessary
+	UpdateFollowing( deltaT );
+
+	AvoidPhysicsProps();
+
+	// update hostage velocity in the XY plane
+	const float damping = 2.0f;
+	m_vel += deltaT * (m_accel - damping * m_vel);
+
+	// leave Z component untouched
+	m_vel.z = GetAbsVelocity().z;
+
+	if ( m_accel.IsZero() && m_vel.AsVector2D().IsZero( 1.0f ) )
+	{
+		m_vel.x = 0.0f;
+		m_vel.y = 0.0f;
+	}
+
+	m_accel = Vector( 0, 0, 0 );
+
+	// set animation to idle for now
+	StudioFrameAdvance();
+
+	int sequence = SelectWeightedSequence( ACT_IDLE );
+	if (GetSequence() != sequence)
+	{
+		SetSequence( sequence );
+	}
+
+	m_PlayerAnimState->Update( GetAbsAngles()[YAW], GetAbsAngles()[PITCH] );
+
+
+	if ( m_disappearTime && m_disappearTime < gpGlobals->curtime )
+	{
+		// finished fading - remove us completely
+		AddEffects( EF_NODRAW );
+
+		SetSolid( SOLID_NONE );
+		SetSolidFlags( 0 );
+		m_disappearTime = 0.0f;
+	}
+}
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsFollowingSomeone( void )
+{
+	return (m_leader.m_Value != NULL);
+}
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsFollowing( const CBaseEntity *entity )
+{
+	return (m_leader.m_Value == entity);
+}
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsValid( void ) const
+{
+	return (m_iHealth > 0 && !IsRescued());
+}
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsRescuable( void ) const
+{
+	return (m_iHealth > 0 && !IsRescued());
+}
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsRescued( void ) const
+{
+	return m_isRescued;
+}
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsOnGround( void ) const
+{
+	return (GetFlags() & FL_ONGROUND);
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Return true if hostage can see position
+ */
+bool CHostage::IsVisible( const Vector &pos, bool testFOV ) const
+{
+	trace_t result;
+	UTIL_TraceLine( EyePosition(), pos, CONTENTS_SOLID, this, COLLISION_GROUP_NONE, &result );
+	return (result.fraction >= 1.0f);
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Give bonus to CT's for talking to a hostage
+ */
+void CHostage::GiveCTUseBonus( CCSPlayer *rescuer )
+{
+	// money to team
+	const int teamBonus = 100;
+	CSGameRules()->m_iAccountCT += teamBonus;
+
+	// money to rescuer
+	const int rescuerBonus = 150;
+	rescuer->AddAccount( rescuerBonus );
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Stand idle
+ */
+void CHostage::Idle( void )
+{
+	m_leader = NULL;
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Begin following "leader"
+ */
+void CHostage::Follow( CCSPlayer *leader )
+{
+    //=============================================================================
+    // HPE_BEGIN
+    // [dwenger] Set variable to track whether player is currently rescuing hostages
+    //=============================================================================
+
+    if ( leader )
+    {
+        leader->IncrementNumFollowers();
+        leader->SetIsRescuing(true);
+    }
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+	m_leader = leader;
+	m_isWaitingForLeader = false;
+	m_lastLeaderID = (leader) ? leader->GetUserID() : 0;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Return our leader, or NULL
+ */
+CCSPlayer *CHostage::GetLeader( void ) const
+{
+	return ToCSPlayer( m_leader.m_Value );
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Invoked when a Hostage is "used" by a player
+ */
+void CHostage::HostageUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	Vector to = pActivator->GetAbsOrigin() - GetAbsOrigin();
+
+	// limit use range
+	float useRange = 1000.0f;
+	if (to.IsLengthGreaterThan( useRange ))
+	{
+		return;
+	}
+
+	// TODO: check line of sight to hostage
+
+
+	CCSPlayer *user = ToCSPlayer( pActivator );
+	if (user == NULL)
+	{
+		return;
+	}
+
+	// only members of the CT team can use hostages (no T's or spectators)
+	if (!hostage_debug.GetBool() && user->GetTeamNumber() != TEAM_CT)
+	{
+		if ( user->GetTeamNumber() == TEAM_TERRORIST )
+		{
+			if ( !(user->m_iDisplayHistoryBits & DHF_HOSTAGE_CTMOVE) )
+			{
+				user->m_iDisplayHistoryBits |= DHF_HOSTAGE_CTMOVE;
+				user->HintMessage( "#Only_CT_Can_Move_Hostages", false, true );
+			}
+		}
+
+		return;
+	}
+
+	CCSPlayer *leader = GetLeader();
+	if( leader && !leader->IsAlive() )
+	{
+		Idle();
+		leader = NULL;
+	}
+
+	// throttle how often leader can change
+	if (!m_reuseTimer.IsElapsed())
+	{
+		return;
+	}
+
+	// give money bonus to first CT touching this hostage
+	if (!m_hasBeenUsed)
+	{
+		m_hasBeenUsed = true;
+
+		GiveCTUseBonus( user );
+
+		CSGameRules()->HostageTouched();
+	}
+
+	// if we are already following the player who used us, stop following
+	if (IsFollowing( user ))
+	{
+		Idle();
+
+		// say something
+		EmitSound( "Hostage.StopFollowCT" );
+	}
+	else
+	{
+		// if we're already following a CT, ignore new uses
+		if (IsFollowingSomeone())
+		{
+			return;
+		}
+
+		// start following
+		Follow( user );
+
+		// say something
+		EmitSound( "Hostage.StartFollowCT" );
+
+		// emit hostage_follows event
+		IGameEvent *event = gameeventmanager->CreateEvent( "hostage_follows" );
+		if ( event )
+		{
+			event->SetInt( "userid", user->GetUserID() );
+			event->SetInt( "hostage", entindex() );
+			event->SetInt( "priority", 6 );
+			gameeventmanager->FireEvent( event );
+		}
+
+		if ( !(user->m_iDisplayHistoryBits & DHF_HOSTAGE_USED) )
+		{
+			user->m_iDisplayHistoryBits |= DHF_HOSTAGE_USED;
+			user->HintMessage( "#Hint_lead_hostage_to_rescue_point", false );
+		}
+	}
+
+	m_reuseTimer.Start( 1.0f );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Rotate body to face towards "target"
+ */
+void CHostage::FaceTowards( const Vector &target, float deltaT )
+{
+	Vector to = target - GetFeet();
+	to.z = 0.0f;
+
+	QAngle desiredAngles;
+	VectorAngles( to, desiredAngles );
+
+	QAngle angles = GetAbsAngles();
+
+	const float turnSpeed = 250.0f;	
+	angles.y = ApproachAngle( desiredAngles.y, angles.y, turnSpeed * deltaT );
+
+	SetAbsAngles( angles );
+}
+
+//-----------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------------------------------
+
+const Vector &CHostage::GetCentroid( void ) const
+{
+	static Vector centroid;
+	
+	centroid = GetFeet();
+	centroid.z += HalfHumanHeight;
+
+	return centroid;
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Return position of "feet" - point below centroid of improv at feet level
+ */
+const Vector &CHostage::GetFeet( void ) const
+{
+	static Vector feet;
+	
+	feet = GetAbsOrigin();
+
+	return feet;
+}
+
+//-----------------------------------------------------------------------------------------------------
+const Vector &CHostage::GetEyes( void ) const
+{
+	static Vector eyes;
+	
+	eyes = EyePosition();
+
+	return eyes;
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Return direction of movement
+ */
+float CHostage::GetMoveAngle( void ) const
+{
+	return GetAbsAngles().y;
+}
+
+//-----------------------------------------------------------------------------------------------------
+CNavArea *CHostage::GetLastKnownArea( void ) const
+{
+	return m_lastKnownArea;
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Find "simple" ground height, treating current nav area as part of the floo
+ */
+bool CHostage::GetSimpleGroundHeightWithFloor( const Vector &pos, float *height, Vector *normal )
+{
+	if (TheNavMesh->GetSimpleGroundHeight( pos, height, normal ))
+	{
+		// our current nav area also serves as a ground polygon
+		if (m_lastKnownArea && m_lastKnownArea->IsOverlapping( pos ))
+		{
+			*height = MAX( (*height), m_lastKnownArea->GetZ( pos ) );
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------------------------------
+void CHostage::Crouch( void )
+{
+	m_isCrouching = true;
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * un-crouch
+ */
+void CHostage::StandUp( void )
+{
+	m_isCrouching = false;
+}
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsCrouching( void ) const
+{
+	return m_isCrouching;
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Initiate a jump
+ */
+void CHostage::Jump( void )
+{
+	if (m_jumpTimer.IsElapsed() && IsOnGround())
+	{
+		const float minJumpInterval = 0.5f;
+		m_jumpTimer.Start( minJumpInterval );
+
+		Vector vel = GetAbsVelocity();
+		vel.z += 200.0f;
+		SetAbsVelocity( vel );
+	}
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsJumping( void ) const
+{
+	return !m_jumpTimer.IsElapsed();
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Set movement speed to running
+ */
+void CHostage::Run( void )
+{
+	m_isRunning = true;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Set movement speed to walking
+ */
+void CHostage::Walk( void )
+{
+	m_isRunning = false;
+}
+
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsRunning( void ) const
+{
+	return m_isRunning;
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Invoked when a ladder is encountered while following a path
+ */
+void CHostage::StartLadder( const CNavLadder *ladder, NavTraverseType how, const Vector &approachPos, const Vector &departPos )
+{
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Traverse given ladder
+ */
+bool CHostage::TraverseLadder( const CNavLadder *ladder, NavTraverseType how, const Vector &approachPos, const Vector &departPos, float deltaT )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------------------------------
+bool CHostage::IsUsingLadder( void ) const
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Move Hostage directly toward "pathGoal", causing Hostage to track the current path.
+ */
+void CHostage::TrackPath( const Vector &pathGoal, float deltaT )
+{
+	// face in the direction of our motion
+	FaceTowards( GetAbsOrigin() + 10.0f * m_vel, deltaT );
+
+	if (GetFlags() & FL_ONGROUND)
+	{
+		// on the ground - move towards pathGoal
+		Vector to = pathGoal - GetFeet();
+		to.z = 0.0f;
+		to.NormalizeInPlace();
+
+		const float speed = 1000.0f;
+		ApplyForce( speed * to );
+	}
+	else
+	{
+		// in the air - continue forward motion
+		Vector to;
+		QAngle angles = GetAbsAngles();
+		AngleVectors( angles, &to );
+
+		const float airSpeed = 350.0f;
+		ApplyForce( airSpeed * to );
+	}
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Invoked when an improv reaches its MoveTo goal
+ */
+void CHostage::OnMoveToSuccess( const Vector &goal )
+{
+}
+
+//-----------------------------------------------------------------------------------------------------
+/**
+ * Invoked when an improv fails to reach a MoveTo goal
+ */
+void CHostage::OnMoveToFailure( const Vector &goal, MoveToFailureType reason )
+{
+}
+
+
+unsigned int CHostage::PhysicsSolidMaskForEntity() const
+{
+	return MASK_PLAYERSOLID;
+}
+
diff --git a/game/server/cstrike/hostage/cs_simple_hostage.h b/game/server/cstrike/hostage/cs_simple_hostage.h
new file mode 100644
index 00000000..cdc65443
--- /dev/null
+++ b/game/server/cstrike/hostage/cs_simple_hostage.h
@@ -0,0 +1,256 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// cs_simple_hostage.h
+// Simple CS1.6 level hostage
+// Author: Michael S. Booth, July 2004
+
+#ifndef _CS_SIMPLE_HOSTAGE_H_
+#define _CS_SIMPLE_HOSTAGE_H_
+
+#include "nav_mesh.h"
+#include "cs_nav_path.h"
+#include "cs_nav_pathfind.h"
+#include "improv_locomotor.h"
+#include "cs_playeranimstate.h"
+
+class CCSPlayer;
+
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * A Counter-Strike Hostage
+ */
+class CHostage : public CBaseCombatCharacter, public CImprovLocomotor, public ICSPlayerAnimStateHelpers
+{
+public:
+	DECLARE_CLASS( CHostage, CBaseCombatCharacter );
+	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+	CHostage( void );
+	virtual ~CHostage();
+
+
+public:
+	virtual void Spawn( void );
+	virtual void Precache();
+	int ObjectCaps( void ) { return (BaseClass::ObjectCaps() | FCAP_IMPULSE_USE); }	// make hostage "useable"
+
+	virtual void PhysicsSimulate( void );
+
+	virtual int OnTakeDamage_Alive( const CTakeDamageInfo &info );
+	virtual void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
+
+	virtual void Event_Killed( const CTakeDamageInfo &info );
+	virtual void Touch( CBaseEntity *other );				// in contact with "other"
+	
+	void HostageRescueZoneTouch( inputdata_t &inputdata );	// invoked when hostage touches a rescue zone
+
+	void HostageThink( void );								// periodic update to initiate behaviors
+
+	void GiveCTUseBonus( CCSPlayer *rescuer );				// give bonus to CT's for talking to a hostage
+	void CheckForHostageAbuse( CCSPlayer *player );			// check for hostage-killer abuse
+
+	// queries
+	bool IsFollowingSomeone( void );
+	bool IsFollowing( const CBaseEntity *entity );
+	bool IsValid( void ) const;
+	bool IsRescuable( void ) const;
+	bool IsRescued( void ) const;
+	bool IsOnGround( void ) const;
+
+	bool IsVisible( const Vector &pos, bool testFOV = false ) const;	// return true if hostage can see position
+
+	// hostage states
+	void Idle( void );										// stand idle
+	void Follow( CCSPlayer *leader );						// begin following "leader"
+	CCSPlayer *GetLeader( void ) const;						// return our leader, or NULL
+
+	void FaceTowards( const Vector &target, float deltaT );	// rotate body to face towards "target"
+	void ApplyForce( const Vector &force )		{ m_accel += force; }	// apply a force to the hostage
+
+	unsigned int PhysicsSolidMaskForEntity() const;
+	Class_T Classify ( void ) { return CLASS_PLAYER_ALLY; }
+
+public:
+	// begin CImprovLocomotor -----------------------------------------------------------------------------------------------------------------
+	virtual const Vector &GetCentroid( void ) const;
+	virtual const Vector &GetFeet( void ) const;			// return position of "feet" - point below centroid of improv at feet level
+	virtual const Vector &GetEyes( void ) const;
+	virtual float GetMoveAngle( void ) const;				// return direction of movement
+
+	virtual CNavArea *GetLastKnownArea( void ) const;
+	virtual bool GetSimpleGroundHeightWithFloor( const Vector &pos, float *height, Vector *normal = NULL );	// find "simple" ground height, treating current nav area as part of the floor
+
+	virtual void Crouch( void );
+	virtual void StandUp( void );							// "un-crouch"
+	virtual bool IsCrouching( void ) const;
+
+	virtual void Jump( void );								// initiate a jump
+	virtual bool IsJumping( void ) const;
+
+	virtual void Run( void );								// set movement speed to running
+	virtual void Walk( void );								// set movement speed to walking
+	virtual bool IsRunning( void ) const;
+
+	virtual void StartLadder( const CNavLadder *ladder, NavTraverseType how, const Vector &approachPos, const Vector &departPos );	// invoked when a ladder is encountered while following a path
+	virtual bool TraverseLadder( const CNavLadder *ladder, NavTraverseType how, const Vector &approachPos, const Vector &departPos, float deltaT );	// traverse given ladder
+	virtual bool IsUsingLadder( void ) const;
+
+	virtual void TrackPath( const Vector &pathGoal, float deltaT );		// move along path by following "pathGoal"
+	virtual void OnMoveToSuccess( const Vector &goal );					// invoked when an improv reaches its MoveTo goal
+	virtual void OnMoveToFailure( const Vector &goal, MoveToFailureType reason );	// invoked when an improv fails to reach a MoveTo goal
+	// end CImprovLocomotor -------------------------------------------------------------------------------------------------------------------
+
+// ICSPlayerAnimState overrides.
+public:
+	virtual CWeaponCSBase* CSAnim_GetActiveWeapon();
+	virtual bool CSAnim_CanMove();
+
+
+
+protected:
+	virtual void HostageUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+private:
+	float GetModifiedDamage( float flDamage, int nHitGroup );
+
+	ICSPlayerAnimState *m_PlayerAnimState;
+
+	IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_iMaxHealth );
+	IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_iHealth );
+	IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_lifeState );
+	CNetworkVar( bool, m_isRescued );						// true if the hostage has been rescued
+
+	CNetworkVar( EHANDLE, m_leader );						// the player we are following
+	void UpdateFollowing( float deltaT );					// do following behavior
+
+	int m_lastLeaderID;
+
+	CountdownTimer m_reuseTimer;							// to throttle how often hostage can be used
+	bool m_hasBeenUsed;										// flag to give first rescuer bonus money
+
+	Vector m_vel;
+	Vector m_accel;
+
+	bool m_isRunning;										// true if hostage move speed is to run (walk if false)
+	bool m_isCrouching;										// true if hostage is crouching
+	CountdownTimer m_jumpTimer;								// if zero, we can jump
+
+	bool m_isWaitingForLeader;								// true if we are waiting for our rescuer to move
+
+	CCSNavPath m_path;										// current path to follow
+	CountdownTimer m_repathTimer;							// throttle pathfinder
+
+	CountdownTimer m_inhibitDoorTimer;
+
+	CNavPathFollower m_pathFollower;						// path tracking mechanism
+	CountdownTimer m_inhibitObstacleAvoidanceTimer;			// when active, turn off path following feelers
+
+	CNavArea *m_lastKnownArea;								// last area we were in
+
+	void Wiggle( void );									// attempt to wiggle-out of begin stuck
+	CountdownTimer m_wiggleTimer;							// for wiggling
+	NavRelativeDirType m_wiggleDirection;
+
+	bool m_isAdjusted;										// hack for adjusting bounding box
+	float m_disappearTime;									// has finished fading, remove me
+
+	void PushawayThink( void );								// pushes physics objects away from the hostage
+	void AvoidPhysicsProps( void );							// guides the hostage away from physics props
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Functor used with NavAreaBuildPath() for building Hostage paths.
+ * Once we hook up crouching and ladders, this can be removed and ShortestPathCost() can be used instead.
+ */
+class HostagePathCost
+{
+public:
+
+	// HPE_TODO[pmf]: check that these new parameters are okay to be ignored
+	float operator() ( CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder, const CFuncElevator *elevator, float length )
+	{
+		if (fromArea == NULL)
+		{
+			// first area in path, no cost
+			return 0.0f;
+		}
+		else
+		{
+			// if this area isn't available to hostages, skip it
+			if ( area->GetAttributes() & NAV_MESH_NO_HOSTAGES )
+			{
+				return -1.0f;
+			}
+
+			// compute distance travelled along path so far
+			float dist;
+
+			if (ladder)
+			{
+				// can't traverse ladders
+				return -1.0f;
+			}
+			else
+			{
+				dist = (area->GetCenter() - fromArea->GetCenter()).Length();
+			}
+
+			float cost = dist + fromArea->GetCostSoFar();
+
+			if (area->GetAttributes() & NAV_MESH_CROUCH) //  && !(area->GetAttributes() & NAV_MESH_JUMP))
+			{
+				// can't traverse areas that require crouching
+				return -1.0f;
+			}
+
+			// if this is a "jump" area, add penalty
+			if (area->GetAttributes() & NAV_MESH_JUMP)
+			{
+				const float jumpPenalty = 5.0f;
+				cost += jumpPenalty * dist;
+			}
+
+			return cost;
+		}
+	}
+};
+
+
+//--------------------------------------------------------------------------------------------------------------
+// All the hostage entities.
+extern CUtlVector< CHostage * > g_Hostages;
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Iterate over all active hostages in the game, invoking functor on each.
+ * If functor returns false, stop iteration and return false.
+ */
+template < typename Functor >
+bool ForEachHostage( Functor &func )
+{
+	for( int i=0; i<g_Hostages.Count(); ++i )
+	{
+		CHostage *hostage = g_Hostages[i];
+
+		if ( hostage == NULL || !hostage->IsValid() )
+			continue;
+
+		if ( func( hostage ) == false )
+			return false;
+	}
+
+	return true;
+}
+
+
+#endif // _CS_SIMPLE_HOSTAGE_H_
diff --git a/game/server/cstrike/info_view_parameters.cpp b/game/server/cstrike/info_view_parameters.cpp
new file mode 100644
index 00000000..d4579fe3
--- /dev/null
+++ b/game/server/cstrike/info_view_parameters.cpp
@@ -0,0 +1,18 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+#include "info_view_parameters.h"
+
+
+BEGIN_DATADESC( CInfoViewParameters )
+	DEFINE_KEYFIELD( m_nViewMode, FIELD_INTEGER, "ViewMode" )
+END_DATADESC()
+
+
+LINK_ENTITY_TO_CLASS( info_view_parameters, CInfoViewParameters );
+
+
diff --git a/game/server/cstrike/info_view_parameters.h b/game/server/cstrike/info_view_parameters.h
new file mode 100644
index 00000000..0e1d38fa
--- /dev/null
+++ b/game/server/cstrike/info_view_parameters.h
@@ -0,0 +1,24 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef INFO_VIEW_PARAMETERS_H
+#define INFO_VIEW_PARAMETERS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+class CInfoViewParameters : public CBaseEntity
+{
+public:
+	DECLARE_CLASS( CInfoViewParameters, CBaseEntity );
+	DECLARE_DATADESC();
+
+	int m_nViewMode;
+};
+
+
+#endif // INFO_VIEW_PARAMETERS_H
diff --git a/game/server/cstrike/item_ammo.cpp b/game/server/cstrike/item_ammo.cpp
new file mode 100644
index 00000000..7b09cc50
--- /dev/null
+++ b/game/server/cstrike/item_ammo.cpp
@@ -0,0 +1,147 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "items.h"
+#include "cs_player.h"
+#include "weapon_csbase.h"
+#include "cs_ammodef.h"
+
+
+//-----------------------------------------------------------------------------
+class CItemAmmo : public CItem
+{
+public:
+	DECLARE_CLASS( CItemAmmo, CItem );
+
+	bool MyTouch( CBasePlayer *pBasePlayer )
+	{
+		CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( pBasePlayer );
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return false;
+		}
+
+		int ammoIndex = GetCSAmmoDef()->Index( GetAmmoName() );
+		if ( ammoIndex < 0 )
+		{
+			Assert( false );
+			return false;
+		}
+
+		pPlayer->GiveAmmo( GetCSAmmoDef()->GetBuySize( ammoIndex ), ammoIndex );
+
+		return true;
+	}
+
+	virtual const char * GetAmmoName( void ) const { return NULL; }
+};
+
+//-----------------------------------------------------------------------------
+class CItemAmmo50AE : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo50AE, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_50AE; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_50ae, CItemAmmo50AE );
+
+//-----------------------------------------------------------------------------
+class CItemAmmo762MM : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo762MM, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_762MM; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_762mm, CItemAmmo762MM );
+
+//-----------------------------------------------------------------------------
+class CItemAmmo556MM : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo556MM, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_556MM; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_556mm, CItemAmmo556MM );
+
+//-----------------------------------------------------------------------------
+class CItemAmmo556MM_BOX : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo556MM_BOX, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_556MM_BOX; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_556mm_box, CItemAmmo556MM_BOX );
+
+//-----------------------------------------------------------------------------
+class CItemAmmo338MAG : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo338MAG, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_338MAG; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_338mag, CItemAmmo338MAG );
+
+//-----------------------------------------------------------------------------
+class CItemAmmo9MM : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo9MM, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_9MM; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_9mm, CItemAmmo9MM );
+
+//-----------------------------------------------------------------------------
+class CItemAmmoBuckshot : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmoBuckshot, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_BUCKSHOT; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_buckshot, CItemAmmoBuckshot );
+
+//-----------------------------------------------------------------------------
+class CItemAmmo45ACP : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo45ACP, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_45ACP; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_45acp, CItemAmmo45ACP );
+
+//-----------------------------------------------------------------------------
+class CItemAmmo357SIG : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo357SIG, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_357SIG; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_357sig, CItemAmmo357SIG );
+
+//-----------------------------------------------------------------------------
+class CItemAmmo57MM : public CItemAmmo
+{
+public:
+	DECLARE_CLASS( CItemAmmo57MM, CItemAmmo );
+	virtual const char * GetAmmoName( void ) const { return BULLET_PLAYER_57MM; }
+};
+
+LINK_ENTITY_TO_CLASS( ammo_57mm, CItemAmmo57MM );
+
+//-----------------------------------------------------------------------------
+
diff --git a/game/server/cstrike/item_assaultsuit.cpp b/game/server/cstrike/item_assaultsuit.cpp
new file mode 100644
index 00000000..da36de58
--- /dev/null
+++ b/game/server/cstrike/item_assaultsuit.cpp
@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "items.h"
+#include "cs_player.h"
+
+
+class CItemAssaultSuit : public CItem
+{
+	void Spawn( void )
+	{ 
+		Precache( );
+		CItem::Spawn( );
+	}
+	
+	void Precache( void )
+	{
+		PrecacheScriptSound( "BaseCombatCharacter.ItemPickup2" );
+	}
+	
+	bool MyTouch( CBasePlayer *pBasePlayer )
+	{
+		CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( pBasePlayer );
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return false;
+		}
+
+		pPlayer->m_bHasHelmet = true;
+		pPlayer->SetArmorValue( 100 );
+
+		if ( pPlayer->IsDead() == false )
+		{
+			CPASAttenuationFilter filter( pBasePlayer );
+			EmitSound( filter, entindex(), "BaseCombatCharacter.ItemPickup2" );
+
+			CSingleUserRecipientFilter user( pPlayer );
+			UserMessageBegin( user, "ItemPickup" );
+			WRITE_STRING( "item_assaultsuit" );
+			MessageEnd();
+		}
+
+		return true;		
+	}
+};
+
+LINK_ENTITY_TO_CLASS( item_assaultsuit, CItemAssaultSuit );
+
+
diff --git a/game/server/cstrike/item_defuser.cpp b/game/server/cstrike/item_defuser.cpp
new file mode 100644
index 00000000..b6f3343a
--- /dev/null
+++ b/game/server/cstrike/item_defuser.cpp
@@ -0,0 +1,107 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Defuser kit that drops from counter-strike CTS 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "items.h"
+#include "cs_player.h"
+
+class CItemDefuser : public CItem
+{
+public:
+	DECLARE_CLASS( CItemDefuser, CItem );
+	
+	void	Spawn( void );
+	void	Precache( void );
+	void	DefuserTouch( CBaseEntity *pOther );
+	void	ActivateThink( void );
+	
+	DECLARE_DATADESC();
+};
+
+LINK_ENTITY_TO_CLASS( item_defuser, CItemDefuser );
+PRECACHE_REGISTER(item_defuser);
+
+
+BEGIN_DATADESC( CItemDefuser )
+
+	//Functions
+	DEFINE_THINKFUNC( ActivateThink ),
+	DEFINE_ENTITYFUNC( DefuserTouch ),
+
+END_DATADESC()
+
+
+void CItemDefuser::Spawn( void )
+{ 
+	Precache( );
+	SetModel( "models/weapons/w_defuser.mdl" );
+	BaseClass::Spawn();
+
+	SetNextThink( gpGlobals->curtime + 0.5f );
+	SetThink( &CItemDefuser::ActivateThink );
+
+	SetTouch( NULL );
+}
+	
+void CItemDefuser::Precache( void )
+{
+	PrecacheModel( "models/weapons/w_defuser.mdl" );
+
+	PrecacheScriptSound( "BaseCombatCharacter.ItemPickup2" );
+}
+
+void CItemDefuser::ActivateThink( void )
+{
+	//since we can't stop the item from being touched while its in the air,
+	//activate 1 second after being dropped
+
+	SetTouch( &CItemDefuser::DefuserTouch );
+	SetThink( NULL );
+}
+	
+void CItemDefuser::DefuserTouch( CBaseEntity *pOther )
+{
+	if ( !pOther->IsPlayer() )
+	{
+		return;
+	}
+
+	//if( GetFlags() & FL_ONGROUND )
+	{
+		CCSPlayer *pPlayer = (CCSPlayer *)pOther;
+
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return;
+		}
+
+		if( pPlayer->GetTeamNumber() == TEAM_CT && !pPlayer->HasDefuser() )
+		{
+            //=============================================================================
+            // HPE_BEGIN:
+            // [dwenger] Added for fun-fact support
+            //=============================================================================
+
+			pPlayer->GiveDefuser( true );
+
+            //=============================================================================
+            // HPE_END
+            //=============================================================================
+
+			if ( pPlayer->IsDead() == false )
+			{
+				CPASAttenuationFilter filter( pPlayer );
+				EmitSound( filter, entindex(), "BaseCombatCharacter.ItemPickup2" );
+			}
+
+			UTIL_Remove( this );
+			return;
+		}	
+	}
+}
+
+
diff --git a/game/server/cstrike/item_kevlar.cpp b/game/server/cstrike/item_kevlar.cpp
new file mode 100644
index 00000000..bbb12e62
--- /dev/null
+++ b/game/server/cstrike/item_kevlar.cpp
@@ -0,0 +1,59 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "items.h"
+#include "cs_player.h"
+
+
+class CItemKevlar : public CItem
+{
+public:
+
+	DECLARE_CLASS( CItemKevlar, CItem );
+
+	void Spawn( void )
+	{ 
+		Precache( );
+		BaseClass::Spawn( );
+	}
+	
+	void Precache( void )
+	{
+		PrecacheScriptSound( "BaseCombatCharacter.ItemPickup2" );
+	}
+	
+	bool MyTouch( CBasePlayer *pBasePlayer )
+	{
+		CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( pBasePlayer );
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return false;
+		}
+		
+		pPlayer->SetArmorValue( 100 );
+
+		if ( pPlayer->IsDead() == false )
+		{
+			CPASAttenuationFilter filter( pBasePlayer );
+			EmitSound( filter, entindex(), "BaseCombatCharacter.ItemPickup2" );
+
+			CSingleUserRecipientFilter user( pPlayer );
+			UserMessageBegin( user, "ItemPickup" );
+			WRITE_STRING( "item_kevlar" );
+			MessageEnd();
+		}
+
+		return true;
+	}
+};
+
+LINK_ENTITY_TO_CLASS( item_kevlar, CItemKevlar );
+
+
diff --git a/game/server/cstrike/item_nvgs.cpp b/game/server/cstrike/item_nvgs.cpp
new file mode 100644
index 00000000..b013280f
--- /dev/null
+++ b/game/server/cstrike/item_nvgs.cpp
@@ -0,0 +1,59 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "items.h"
+#include "cs_player.h"
+
+
+class CItemNvgs : public CItem
+{
+public:
+
+	DECLARE_CLASS( CItemNvgs, CItem );
+
+	void Spawn( void )
+	{ 
+		Precache( );
+		BaseClass::Spawn( );
+	}
+	
+	void Precache( void )
+	{
+		PrecacheScriptSound( "BaseCombatCharacter.ItemPickup2" );
+	}
+	
+	bool MyTouch( CBasePlayer *pBasePlayer )
+	{
+		CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( pBasePlayer );
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return false;
+		}
+
+		pPlayer->m_bHasNightVision = true;
+
+		if ( pPlayer->IsDead() == false )
+		{
+			CPASAttenuationFilter filter( pPlayer );
+			EmitSound( filter, entindex(), "BaseCombatCharacter.ItemPickup2" );
+
+			CSingleUserRecipientFilter user( pPlayer );
+			UserMessageBegin( user, "ItemPickup" );
+			WRITE_STRING( "item_nvgs" );
+			MessageEnd();
+		}
+
+		return true;
+	}
+};
+
+LINK_ENTITY_TO_CLASS( item_nvgs, CItemNvgs );
+
+
diff --git a/game/server/cstrike/mapinfo.cpp b/game/server/cstrike/mapinfo.cpp
new file mode 100644
index 00000000..bb2a20ac
--- /dev/null
+++ b/game/server/cstrike/mapinfo.cpp
@@ -0,0 +1,76 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "mapinfo.h"
+#include "cs_gamerules.h"
+
+LINK_ENTITY_TO_CLASS( info_map_parameters, CMapInfo );
+
+BEGIN_DATADESC( CMapInfo )
+
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "FireWinCondition", InputFireWinCondition ),
+
+END_DATADESC()
+
+CMapInfo *g_pMapInfo = NULL;
+
+
+CMapInfo::CMapInfo()
+{
+	m_flBombRadius = 500.0f;
+	m_iBuyingStatus = 0;
+
+	if ( g_pMapInfo )
+	{
+		// Should only be one of these.
+		Warning( "Warning: Multiple info_map_parameters entities in map!\n" );
+	}
+	else
+	{
+		g_pMapInfo = this;
+	}
+}
+
+
+CMapInfo::~CMapInfo()
+{
+	if ( g_pMapInfo == this )
+		g_pMapInfo = NULL;
+}
+ 
+
+bool CMapInfo::KeyValue( const char *szKeyName, const char *szValue )
+{
+	if (FStrEq(szKeyName, "buying"))
+	{
+		m_iBuyingStatus = atoi(szValue);
+		return true;
+	}
+	else if (FStrEq(szKeyName, "bombradius"))
+	{
+		m_flBombRadius = (float)(atoi(szValue));
+		if (m_flBombRadius > 2048)
+			m_flBombRadius = 2048;
+		
+		return true;
+	}
+	
+	return BaseClass::KeyValue( szKeyName, szValue );
+}
+
+
+void CMapInfo::Spawn( void )
+{ 
+	SetMoveType( MOVETYPE_NONE );
+	SetSolid( SOLID_NONE );
+	AddEffects( EF_NODRAW );
+}
+
+void CMapInfo::InputFireWinCondition(inputdata_t &inputdata )
+{
+	CSGameRules()->TerminateRound( 5, inputdata.value.Int() );
+}
diff --git a/game/server/cstrike/mapinfo.h b/game/server/cstrike/mapinfo.h
new file mode 100644
index 00000000..bd3cb5d3
--- /dev/null
+++ b/game/server/cstrike/mapinfo.h
@@ -0,0 +1,42 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef MAPINFO_H
+#define MAPINFO_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "baseentity.h"
+
+
+class CMapInfo : public CPointEntity
+{
+public :
+
+	DECLARE_DATADESC();
+	DECLARE_CLASS( CMapInfo, CPointEntity );
+	
+	CMapInfo();
+	virtual ~CMapInfo();
+
+	bool KeyValue( const char *szKeyName, const char *szValue );
+	void Spawn();
+
+	void InputFireWinCondition( inputdata_t &inputdata );
+
+public:
+	int m_iBuyingStatus;
+	float m_flBombRadius;
+};
+
+
+// The info_map_parameters entity in this map (only one is allowed for).
+extern CMapInfo *g_pMapInfo;
+
+
+#endif // MAPINFO_H
diff --git a/game/server/cstrike/point_surroundtest.cpp b/game/server/cstrike/point_surroundtest.cpp
new file mode 100644
index 00000000..87038274
--- /dev/null
+++ b/game/server/cstrike/point_surroundtest.cpp
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "mapinfo.h"
+
+
+class CSurroundTest : public CPointEntity
+{
+public:
+	DECLARE_CLASS( CSurroundTest, CPointEntity );
+
+	void	FireCorrectOutput( inputdata_t &inputdata );
+	void	Spawn( void );
+
+private:
+	
+	COutputEvent m_On2Speakers;
+	COutputEvent m_On4Speakers;
+	COutputEvent m_On51Speakers;
+
+	DECLARE_DATADESC();
+};
+
+LINK_ENTITY_TO_CLASS( point_surroundtest, CSurroundTest );
+
+BEGIN_DATADESC( CSurroundTest )
+	DEFINE_INPUTFUNC( FIELD_VOID, "FireCorrectOutput", FireCorrectOutput ),
+	DEFINE_OUTPUT( m_On2Speakers, "On2Speakers" ),
+	DEFINE_OUTPUT( m_On4Speakers, "On4Speakers" ),
+	DEFINE_OUTPUT( m_On51Speakers, "On51Speakers" ),
+END_DATADESC()
+
+enum
+{
+	SND_SURROUND_HEADPHONES = 0,
+	SND_SURROUND_2SPEAKERS = 2,
+	SND_SURROUND_4SPEAKERS = 4,
+	SND_SURROUND_51SPEAKERS, 
+};
+
+void CSurroundTest::FireCorrectOutput( inputdata_t &inputdata )
+{
+	ConVar const *pSurroundCVar = cvar->FindVar( "snd_surround_speakers" );
+
+	if ( pSurroundCVar )
+	{
+		int iSetting = pSurroundCVar->GetInt();
+		
+		if ( iSetting == SND_SURROUND_HEADPHONES || iSetting == SND_SURROUND_2SPEAKERS )
+		{
+			m_On2Speakers.FireOutput( this, this );
+		}
+		else if ( iSetting == SND_SURROUND_4SPEAKERS )
+		{
+			m_On4Speakers.FireOutput( this, this );
+		}
+		else if ( iSetting == SND_SURROUND_51SPEAKERS )
+		{
+			m_On51Speakers.FireOutput( this, this );
+		}
+	}
+}
+
+void CSurroundTest::Spawn( void )
+{
+	BaseClass::Spawn();
+}
\ No newline at end of file
diff --git a/game/server/cstrike/smokegrenade_projectile.cpp b/game/server/cstrike/smokegrenade_projectile.cpp
new file mode 100644
index 00000000..82d8d7ce
--- /dev/null
+++ b/game/server/cstrike/smokegrenade_projectile.cpp
@@ -0,0 +1,189 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "smokegrenade_projectile.h"
+#include "sendproxy.h"
+#include "particle_smokegrenade.h"
+#include "cs_player.h"
+#include "KeyValues.h"
+#include "bot_manager.h"
+#include "weapon_csbase.h"
+
+#define GRENADE_MODEL "models/Weapons/w_eq_smokegrenade_thrown.mdl"
+
+
+LINK_ENTITY_TO_CLASS( smokegrenade_projectile, CSmokeGrenadeProjectile );
+PRECACHE_WEAPON_REGISTER( smokegrenade_projectile );
+
+BEGIN_DATADESC( CSmokeGrenadeProjectile )
+	DEFINE_THINKFUNC( Think_Detonate ),
+	DEFINE_THINKFUNC( Think_Fade ),
+	DEFINE_THINKFUNC( Think_Remove )
+END_DATADESC()
+
+
+CSmokeGrenadeProjectile* CSmokeGrenadeProjectile::Create( 
+	const Vector &position, 
+	const QAngle &angles, 
+	const Vector &velocity, 
+	const AngularImpulse &angVelocity, 
+	CBaseCombatCharacter *pOwner )
+{
+	CSmokeGrenadeProjectile *pGrenade = (CSmokeGrenadeProjectile*)CBaseEntity::Create( "smokegrenade_projectile", position, angles, pOwner );
+	
+	// Set the timer for 1 second less than requested. We're going to issue a SOUND_DANGER
+	// one second before detonation.
+	pGrenade->SetTimer( 1.5 );
+	pGrenade->SetAbsVelocity( velocity );
+	pGrenade->SetupInitialTransmittedGrenadeVelocity( velocity );
+	pGrenade->SetThrower( pOwner );
+	pGrenade->SetGravity( 0.55 );
+	pGrenade->SetFriction( 0.7 );
+	pGrenade->m_flDamage = 100;
+	pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+	pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );	
+	pGrenade->SetTouch( &CBaseGrenade::BounceTouch );
+
+	pGrenade->SetGravity( BaseClass::GetGrenadeGravity() );
+	pGrenade->SetFriction( BaseClass::GetGrenadeFriction() );
+	pGrenade->SetElasticity( BaseClass::GetGrenadeElasticity() );
+	pGrenade->m_bDidSmokeEffect = false;
+
+	pGrenade->m_pWeaponInfo = GetWeaponInfo( WEAPON_SMOKEGRENADE );
+
+	return pGrenade;
+}
+
+
+void CSmokeGrenadeProjectile::SetTimer( float timer )
+{
+	SetThink( &CSmokeGrenadeProjectile::Think_Detonate );
+	SetNextThink( gpGlobals->curtime + timer );
+
+	TheBots->SetGrenadeRadius( this, 0.0f );
+}
+
+void CSmokeGrenadeProjectile::Think_Detonate()
+{
+	if ( GetAbsVelocity().Length() > 0.1 )
+	{
+		// Still moving. Don't detonate yet.
+		SetNextThink( gpGlobals->curtime + 0.2 );
+		return;
+	}
+
+	TheBots->SetGrenadeRadius( this, SmokeGrenadeRadius );
+
+	// Ok, we've stopped rolling or whatever. Now detonate.
+	ParticleSmokeGrenade *pGren = (ParticleSmokeGrenade*)CBaseEntity::Create( PARTICLESMOKEGRENADE_ENTITYNAME, GetAbsOrigin(), QAngle(0,0,0), NULL );
+	if ( pGren )
+	{
+		pGren->FillVolume();
+		pGren->SetFadeTime( 15, 20 );
+		pGren->SetAbsOrigin( GetAbsOrigin() );
+
+		//tell the hostages about the smoke!
+		CBaseEntity *pEntity = NULL;
+		variant_t var;	//send the location of the smoke?
+		var.SetVector3D( GetAbsOrigin() );
+		while ( ( pEntity = gEntList.FindEntityByClassname( pEntity, "hostage_entity" ) ) != NULL)
+		{
+			//send to hostages that have a resonable chance of being in it while its still smoking
+			if( (GetAbsOrigin() - pEntity->GetAbsOrigin()).Length() < 1000 )
+				pEntity->AcceptInput( "smokegrenade", this, this, var, 0 );
+		}
+
+		// tell the bots a smoke grenade has exploded
+		CCSPlayer *player = ToCSPlayer(GetThrower());
+		if ( player )
+		{
+			IGameEvent * event = gameeventmanager->CreateEvent( "smokegrenade_detonate" );
+			if ( event )
+			{
+				event->SetInt( "userid", player->GetUserID() );
+				event->SetFloat( "x", GetAbsOrigin().x );
+				event->SetFloat( "y", GetAbsOrigin().y );
+				event->SetFloat( "z", GetAbsOrigin().z );
+				gameeventmanager->FireEvent( event );
+			}
+		}
+	}
+
+	m_hSmokeEffect = pGren;
+	m_bDidSmokeEffect = true;
+
+	EmitSound( "BaseSmokeEffect.Sound" );
+
+	m_nRenderMode = kRenderTransColor;
+	SetNextThink( gpGlobals->curtime + 5 );
+	SetThink( &CSmokeGrenadeProjectile::Think_Fade );
+}
+
+
+// Fade the projectile out over time before making it disappear
+void CSmokeGrenadeProjectile::Think_Fade()
+{
+	SetNextThink( gpGlobals->curtime );
+
+	color32 c = GetRenderColor();
+	c.a -= 1;
+	SetRenderColor( c.r, c.b, c.g, c.a );
+
+	if ( !c.a )
+	{
+		TheBots->RemoveGrenade( this );
+
+		SetModelName( NULL_STRING );//invisible
+		SetNextThink( gpGlobals->curtime + 20 );
+		SetThink( &CSmokeGrenadeProjectile::Think_Remove );	// Spit out smoke for 10 seconds.
+		SetSolid( SOLID_NONE );
+	}
+}
+
+
+void CSmokeGrenadeProjectile::Think_Remove()
+{
+	if ( m_hSmokeEffect.Get() )
+		UTIL_Remove( m_hSmokeEffect );
+
+	TheBots->RemoveGrenade( this );
+
+	SetModelName( NULL_STRING );//invisible
+	SetSolid( SOLID_NONE );
+	SetMoveType( MOVETYPE_NONE );
+}
+
+//Implement this so we never call the base class,
+//but this should never be called either.
+void CSmokeGrenadeProjectile::Detonate( void )
+{
+	Assert(!"Smoke grenade handles its own detonation");
+}
+
+
+void CSmokeGrenadeProjectile::Spawn()
+{
+	SetModel( GRENADE_MODEL );
+	BaseClass::Spawn();
+}
+
+
+void CSmokeGrenadeProjectile::Precache()
+{
+	PrecacheModel( GRENADE_MODEL );
+	PrecacheScriptSound( "BaseSmokeEffect.Sound" );
+	PrecacheScriptSound( "SmokeGrenade.Bounce" );
+	BaseClass::Precache();
+}
+
+void CSmokeGrenadeProjectile::BounceSound( void )
+{
+	if ( !m_bDidSmokeEffect )
+	{
+		EmitSound( "SmokeGrenade.Bounce" );
+	}
+}
diff --git a/game/server/cstrike/smokegrenade_projectile.h b/game/server/cstrike/smokegrenade_projectile.h
new file mode 100644
index 00000000..ea6ab1c5
--- /dev/null
+++ b/game/server/cstrike/smokegrenade_projectile.h
@@ -0,0 +1,53 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HEGRENADE_PROJECTILE_H
+#define HEGRENADE_PROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "basecsgrenade_projectile.h"
+
+
+class CSmokeGrenadeProjectile : public CBaseCSGrenadeProjectile
+{
+public:
+	DECLARE_CLASS( CSmokeGrenadeProjectile, CBaseCSGrenadeProjectile );
+	DECLARE_DATADESC();
+
+// Overrides.
+public:
+	
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void Detonate();
+	virtual void BounceSound( void );
+
+	void Think_Detonate();
+	void Think_Fade();
+	void Think_Remove();
+
+
+// Grenade stuff.
+public:
+
+	static CSmokeGrenadeProjectile* Create( 
+		const Vector &position, 
+		const QAngle &angles, 
+		const Vector &velocity, 
+		const AngularImpulse &angVelocity, 
+		CBaseCombatCharacter *pOwner );
+
+	void SetTimer( float timer );
+
+	EHANDLE m_hSmokeEffect;
+	bool m_bDidSmokeEffect;
+};
+
+
+#endif // HEGRENADE_PROJECTILE_H
diff --git a/game/server/cstrike/te_radioicon.cpp b/game/server/cstrike/te_radioicon.cpp
new file mode 100644
index 00000000..771ce9f5
--- /dev/null
+++ b/game/server/cstrike/te_radioicon.cpp
@@ -0,0 +1,77 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetempentity.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Dispatches blood stream tempentity
+//-----------------------------------------------------------------------------
+class CTERadioIcon : public CBaseTempEntity
+{
+public:
+	DECLARE_CLASS( CTERadioIcon, CBaseTempEntity );
+
+					CTERadioIcon( const char *name );
+	virtual			~CTERadioIcon( void );
+
+	void Precache( void );
+	
+	DECLARE_SERVERCLASS();
+
+public:
+
+	CNetworkVar( int, m_iAttachToClient );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+CTERadioIcon::CTERadioIcon( const char *name ) :
+	CBaseTempEntity( name )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTERadioIcon::~CTERadioIcon( void )
+{
+}
+
+void CTERadioIcon::Precache( void )
+{
+	CBaseEntity::PrecacheModel("sprites/radio.vmt");
+}
+
+IMPLEMENT_SERVERCLASS_ST(CTERadioIcon, DT_TERadioIcon)
+	SendPropInt( SENDINFO(m_iAttachToClient), 8, SPROP_UNSIGNED ),
+END_SEND_TABLE()
+
+
+// Singleton to fire StickyBolt objects
+static CTERadioIcon g_TERadioIcon( "RadioIcon" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : filter - 
+//			delay - 
+//			pPlayer - 
+//-----------------------------------------------------------------------------
+void TE_RadioIcon( IRecipientFilter& filter, float delay, CBaseEntity *pPlayer )
+{
+	g_TERadioIcon.m_iAttachToClient = pPlayer->entindex();
+	
+	// Send it over the wire
+	g_TERadioIcon.Create( filter, delay );
+}
diff --git a/game/server/cstrike/te_shotgun_shot.cpp b/game/server/cstrike/te_shotgun_shot.cpp
new file mode 100644
index 00000000..d730f188
--- /dev/null
+++ b/game/server/cstrike/te_shotgun_shot.cpp
@@ -0,0 +1,161 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetempentity.h"
+#include "fx_cs_shared.h"
+
+
+#define NUM_BULLET_SEED_BITS 8
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Display's a blood sprite
+//-----------------------------------------------------------------------------
+class CTEFireBullets : public CBaseTempEntity
+{
+public:
+	DECLARE_CLASS( CTEFireBullets, CBaseTempEntity );
+	DECLARE_SERVERCLASS();
+
+					CTEFireBullets( const char *name );
+	virtual			~CTEFireBullets( void );
+
+public:
+	CNetworkVar( int, m_iPlayer );
+	CNetworkVector( m_vecOrigin );
+	CNetworkQAngle( m_vecAngles );
+	CNetworkVar( int, m_iWeaponID );
+	CNetworkVar( int, m_iMode );
+	CNetworkVar( int, m_iSeed );
+	CNetworkVar( float, m_fInaccuracy );
+	CNetworkVar( float, m_fSpread );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+CTEFireBullets::CTEFireBullets( const char *name ) :
+	CBaseTempEntity( name )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTEFireBullets::~CTEFireBullets( void )
+{
+}
+
+IMPLEMENT_SERVERCLASS_ST_NOBASE(CTEFireBullets, DT_TEFireBullets)
+	SendPropVector( SENDINFO(m_vecOrigin), -1, SPROP_COORD ),
+	SendPropAngle( SENDINFO_VECTORELEM( m_vecAngles, 0 ), 13, 0 ),
+	SendPropAngle( SENDINFO_VECTORELEM( m_vecAngles, 1 ), 13, 0 ),
+	SendPropInt( SENDINFO( m_iWeaponID ), 5, SPROP_UNSIGNED ), // max 31 weapons
+	SendPropInt( SENDINFO( m_iMode ), 1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iSeed ), NUM_BULLET_SEED_BITS, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iPlayer ), 6, SPROP_UNSIGNED ), 	// max 64 players, see MAX_PLAYERS
+	SendPropFloat( SENDINFO( m_fInaccuracy ), 10, 0, 0, 1 ),	
+	SendPropFloat( SENDINFO( m_fSpread ), 8, 0, 0, 0.1f ),	
+END_SEND_TABLE()
+
+
+// Singleton
+static CTEFireBullets g_TEFireBullets( "Shotgun Shot" );
+
+
+void TE_FireBullets( 
+	int	iPlayerIndex,
+	const Vector &vOrigin,
+	const QAngle &vAngles,
+	int	iWeaponID,
+	int	iMode,
+	int iSeed,
+	float fInaccuracy,
+	float fSpread
+	)
+{
+	CPASFilter filter( vOrigin );
+	filter.UsePredictionRules();
+
+	g_TEFireBullets.m_iPlayer = iPlayerIndex-1;
+	g_TEFireBullets.m_vecOrigin = vOrigin;
+	g_TEFireBullets.m_vecAngles = vAngles;
+	g_TEFireBullets.m_iSeed = iSeed;
+	g_TEFireBullets.m_fInaccuracy = fInaccuracy;
+	g_TEFireBullets.m_fSpread = fSpread;
+	g_TEFireBullets.m_iMode = iMode;
+	g_TEFireBullets.m_iWeaponID = iWeaponID;
+
+	Assert( iSeed < (1 << NUM_BULLET_SEED_BITS) );
+	
+	g_TEFireBullets.Create( filter, 0 );
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays a bomb plant animation
+//-----------------------------------------------------------------------------
+class CTEPlantBomb : public CBaseTempEntity
+{
+public:
+	DECLARE_CLASS( CTEPlantBomb, CBaseTempEntity );
+	DECLARE_SERVERCLASS();
+
+					CTEPlantBomb( const char *name );
+	virtual			~CTEPlantBomb( void );
+
+public:
+	CNetworkVar( int, m_iPlayer );
+	CNetworkVector( m_vecOrigin );
+	CNetworkVar( PlantBombOption_t, m_option );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+CTEPlantBomb::CTEPlantBomb( const char *name ) :
+	CBaseTempEntity( name )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTEPlantBomb::~CTEPlantBomb( void )
+{
+}
+
+IMPLEMENT_SERVERCLASS_ST_NOBASE(CTEPlantBomb, DT_TEPlantBomb)
+	SendPropVector( SENDINFO(m_vecOrigin), -1, SPROP_COORD ),
+	SendPropInt( SENDINFO( m_iPlayer ), 6, SPROP_UNSIGNED ), 	// max 64 players, see MAX_PLAYERS
+	SendPropInt( SENDINFO( m_option ), 1, SPROP_UNSIGNED ),
+END_SEND_TABLE()
+
+
+// Singleton
+static CTEPlantBomb g_TEPlantBomb( "Bomb Plant" );
+
+
+void TE_PlantBomb( int iPlayerIndex, const Vector &vOrigin, PlantBombOption_t option )
+{
+	CPASFilter filter( vOrigin );
+	filter.UsePredictionRules();
+
+	g_TEPlantBomb.m_iPlayer = iPlayerIndex-1;
+	g_TEPlantBomb.m_option = option;
+	g_TEPlantBomb.Create( filter, 0 );
+}
diff --git a/game/server/cstrike/te_shotgun_shot.h b/game/server/cstrike/te_shotgun_shot.h
new file mode 100644
index 00000000..8d72e9cb
--- /dev/null
+++ b/game/server/cstrike/te_shotgun_shot.h
@@ -0,0 +1,28 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef TE_SHOTGUN_SHOT_H
+#define TE_SHOTGUN_SHOT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+void TE_FireBullets( 
+	int	iPlayerIndex,
+	const Vector &vOrigin,
+	const QAngle &vAngles,
+	int	iWeaponID,
+	int	iMode,
+	int iSeed,
+	float fInaccuracy,
+	float fSpread
+	);
+
+void TE_PlantBomb( int iPlayerIndex, const Vector &vOrigin, PlantBombOption_t option );
+
+
+#endif // TE_SHOTGUN_SHOT_H
diff --git a/game/server/server_cstrike.vpc b/game/server/server_cstrike.vpc
new file mode 100644
index 00000000..1a842c23
--- /dev/null
+++ b/game/server/server_cstrike.vpc
@@ -0,0 +1,319 @@
+//-----------------------------------------------------------------------------
+//	SERVER_CSTRIKE.VPC
+//
+//	Project Script
+//-----------------------------------------------------------------------------
+
+$Macro SRCDIR		"..\.."
+$Macro GAMENAME 	"cstrike"
+
+$Include "$SRCDIR\game\server\server_base.vpc"
+$Include "$SRCDIR\game\server\nav_mesh.vpc"
+
+$Configuration
+{
+	$Compiler
+	{
+		$AdditionalIncludeDirectories	"$BASE;$SRCDIR\game\shared\cstrike\control,$SRCDIR\game\shared\cstrike,.\cstrike,.\cstrike\bot,.\cstrike\bot\states,$SRCDIR\game\shared\cstrike\bot,.\cstrike\hostage,.\cstrike\control"
+		$PreprocessorDefinitions		"$BASE;BOTS;CSTRIKE_DLL;NEXT_BOT"
+	}
+
+	$Linker
+	{
+		$AdditionalDependencies			"$BASE ws2_32.lib" [$WIN32]
+	}
+}
+
+$Project "Server (CStrike)"
+{
+	$Folder	"Source Files"
+	{
+		-$File	"AI_ConCommands.cpp"
+		$File	"hl2\Func_Monitor.cpp"
+		$File	"h_cycler.cpp"
+		$File	"h_cycler.h"
+		$File	"$SRCDIR\game\shared\predicted_viewmodel.cpp"
+		$File	"$SRCDIR\game\shared\predicted_viewmodel.h"
+		$File	"$SRCDIR\game\shared\hl2\survival_gamerules.cpp"
+		$File	"team_objectiveresource.cpp"
+		$File	"team_objectiveresource.h"
+		$File	"team_spawnpoint.cpp"
+		$File	"team_spawnpoint.h"
+		$File	"$SRCDIR\game\shared\teamplayroundbased_gamerules.cpp"
+
+		$Folder	"CounterStrike DLL"
+		{
+			$File	"$SRCDIR\game\shared\cstrike\cs_achievement_constants.h"
+			$File	"$SRCDIR\game\shared\cstrike\achievements_cs.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\achievements_cs.h"
+			$File	"$SRCDIR\game\shared\cstrike\basecsgrenade_projectile.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\basecsgrenade_projectile.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_ammodef.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_ammodef.h"
+			$File	"cstrike\cs_autobuy.cpp"
+			$File	"cstrike\cs_autobuy.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_blackmarket.cpp"
+			$File	"cstrike\cs_client.cpp"
+			$File	"cstrike\cs_client.h"
+			$File	"cstrike\cs_eventlog.cpp"
+			$File	"cstrike\cs_gameinterface.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamemovement.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamerules.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamerules.h"
+			$File	"cstrike\cs_gamestats.cpp"
+			$File	"cstrike\cs_gamestats.h"			
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamestats_shared.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_gamestats_shared.h"
+			$File	"$SRCDIR\game\shared\steamworks_gamestats.cpp"
+			$File	"$SRCDIR\game\shared\steamworks_gamestats.h"			
+			$File	"cstrike\cs_hltvdirector.cpp"
+			$File	"cstrike\cs_player.cpp"
+			$File	"cstrike\cs_player.h"
+			$File	"cstrike\cs_player_resource.cpp"
+			$File	"cstrike\cs_player_resource.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_player_shared.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_playeranimstate.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_playeranimstate.h"
+			$File	"cstrike\cs_playermove.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_shareddefs.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_shareddefs.h"
+			$File	"cstrike\cs_team.cpp"
+			$File	"cstrike\cs_team.h"
+			$File	"$SRCDIR\game\shared\cstrike\cs_usermessages.cpp"
+			$File	"cstrike\cs_vehicle_jeep.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_weapon_parse.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\cs_weapon_parse.h"
+			$File	"$SRCDIR\game\shared\cstrike\flashbang_projectile.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\flashbang_projectile.h"
+			$File	"cstrike\func_bomb_target.cpp"
+			$File	"cstrike\func_bomb_target.h"
+			$File	"cstrike\func_buy_zone.cpp"
+			$File	"cstrike\func_hostage_rescue.cpp"
+			$File	"cstrike\funfact_cs.cpp"
+			$File	"cstrike\funfact_cs.h"
+			$File	"cstrike\funfactmgr_cs.cpp"
+			$File	"cstrike\funfactmgr_cs.h"
+			$File	"$SRCDIR\game\shared\cstrike\fx_cs_shared.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\fx_cs_shared.h"
+			$File	"$SRCDIR\game\shared\cstrike\hegrenade_projectile.cpp"
+			$File	"$SRCDIR\game\shared\cstrike\hegrenade_projectile.h"
+			$File	"cstrike\info_view_parameters.cpp"
+			$File	"cstrike\item_ammo.cpp"
+			$File	"cstrike\item_assaultsuit.cpp"
+			$File	"cstrike\item_defuser.cpp"
+			$File	"cstrike\item_kevlar.cpp"
+			$File	"cstrike\item_nvgs.cpp"
+			$File	"cstrike\mapinfo.cpp"
+			$File	"cstrike\mapinfo.h"
+			$File	"cstrike\point_surroundtest.cpp"
+			$File	"cstrike\smokegrenade_projectile.cpp"
+			$File	"cstrike\smokegrenade_projectile.h"
+			$File	"cstrike\te_radioicon.cpp"
+			$File	"cstrike\te_shotgun_shot.cpp"
+			$File	"cstrike\te_shotgun_shot.h"
+			$File	"cstrike\holiday_gift.cpp"
+			$File	"cstrike\holiday_gift.h"
+			
+			$File	"$SRCDIR\game\shared\cstrike\cs_urlretrieveprices.cpp"
+			{
+				$Configuration
+				{
+					$Compiler
+					{
+						$Create/UsePrecompiledHeader	"Not Using Precompiled Headers"
+					}
+				}
+			}
+
+			$File	"$SRCDIR\game\shared\cstrike\cs_urlretrieveprices.h"
+			
+			$Folder	"Weapon"
+			{
+				$File	"$SRCDIR\game\shared\cstrike\weapon_ak47.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_aug.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_awp.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_basecsgrenade.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_basecsgrenade.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_c4.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_c4.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_csbase.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_csbase.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_csbasegun.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_csbasegun.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_deagle.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_elite.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_famas.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_fiveseven.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_flashbang.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_flashbang.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_g3sg1.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_galil.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_glock.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_hegrenade.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_hegrenade.h"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_knife.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_m249.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_m3.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_m4a1.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_mac10.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_mp5navy.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_p228.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_p90.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_scout.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_sg550.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_sg552.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_smokegrenade.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_tmp.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_ump45.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_usp.cpp"
+				$File	"$SRCDIR\game\shared\cstrike\weapon_xm1014.cpp"
+			}
+			
+			$Folder	"Bot"
+			{
+				$File	"cstrike\bot\cs_bot.cpp"
+				$File	"cstrike\bot\cs_bot.h"
+				$File	"cstrike\bot\cs_bot_chatter.cpp"
+				$File	"cstrike\bot\cs_bot_chatter.h"
+				$File	"cstrike\bot\cs_bot_event.cpp"
+				$File	"cstrike\bot\cs_bot_event_bomb.cpp"
+				$File	"cstrike\bot\cs_bot_event_player.cpp"
+				$File	"cstrike\bot\cs_bot_event_weapon.cpp"
+				$File	"cstrike\bot\cs_bot_init.cpp"
+				$File	"cstrike\bot\cs_bot_listen.cpp"
+				$File	"cstrike\bot\cs_bot_manager.cpp"
+				$File	"cstrike\bot\cs_bot_manager.h"
+				$File	"cstrike\bot\cs_bot_nav.cpp"
+				$File	"cstrike\bot\cs_bot_pathfind.cpp"
+				$File	"cstrike\bot\cs_bot_radio.cpp"
+				$File	"cstrike\bot\cs_bot_statemachine.cpp"
+				$File	"cstrike\bot\cs_bot_update.cpp"
+				$File	"cstrike\bot\cs_bot_vision.cpp"
+				$File	"cstrike\bot\cs_bot_weapon.cpp"
+				$File	"cstrike\bot\cs_bot_weapon_id.cpp"
+				$File	"cstrike\bot\cs_gamestate.cpp"
+				$File	"cstrike\bot\cs_gamestate.h"
+
+				$Folder	"States"
+				{
+					$File	"cstrike\bot\states\cs_bot_attack.cpp"
+					$File	"cstrike\bot\states\cs_bot_buy.cpp"
+					$File	"cstrike\bot\states\cs_bot_defuse_bomb.cpp"
+					$File	"cstrike\bot\states\cs_bot_escape_from_bomb.cpp"
+					$File	"cstrike\bot\states\cs_bot_fetch_bomb.cpp"
+					$File	"cstrike\bot\states\cs_bot_follow.cpp"
+					$File	"cstrike\bot\states\cs_bot_hide.cpp"
+					$File	"cstrike\bot\states\cs_bot_hunt.cpp"
+					$File	"cstrike\bot\states\cs_bot_idle.cpp"
+					$File	"cstrike\bot\states\cs_bot_investigate_noise.cpp"
+					$File	"cstrike\bot\states\cs_bot_move_to.cpp"
+					$File	"cstrike\bot\states\cs_bot_open_door.cpp"
+					$File	"cstrike\bot\states\cs_bot_plant_bomb.cpp"
+					$File	"cstrike\bot\states\cs_bot_use_entity.cpp"
+				}
+
+				$Folder	"Shared"
+				{
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot.cpp"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot.h"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot_constants.h"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot_hide.cpp"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot_manager.cpp"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot_manager.h"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot_profile.cpp"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot_profile.h"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot_util.cpp"
+					$File	"$SRCDIR\game\shared\cstrike\bot\bot_util.h"
+					$File	"$SRCDIR\game\shared\cstrike\bot\shared_util.cpp"
+					$File	"$SRCDIR\game\shared\cstrike\bot\shared_util.h"
+				}
+			}
+
+			$Folder	"Hostage"
+			{
+				$File	"cstrike\hostage\cs_simple_hostage.cpp"
+				$File	"cstrike\hostage\cs_simple_hostage.h"
+			}
+			
+			$Folder	"Navigation Mesh"
+			{
+				$File	"cstrike\cs_nav.h"
+				$File	"cstrike\cs_nav_area.cpp"
+				$File	"cstrike\cs_nav_area.h"
+				$File	"cstrike\cs_nav_generate.cpp"
+				$File	"cstrike\cs_nav_mesh.cpp"
+				$File	"cstrike\cs_nav_mesh.h"
+				$File	"cstrike\cs_nav_pathfind.h"
+				$File	"cstrike\cs_nav_path.cpp"
+				$File	"cstrike\cs_nav_path.h"
+			}
+		}
+
+		$Folder "NextBot"
+		{
+			$File	"NextBot\NextBot.cpp"
+			$File	"NextBot\NextBot.h"
+			$File	"NextBot\NextBotBehavior.h"
+			$File	"NextBot\NextBotManager.cpp"
+			$File	"NextBot\NextBotManager.h"
+			$File	"NextBot\NextBotUtil.h"
+			$File	"NextBot\NextBotKnownEntity.h"
+			$File	"NextBot\NextBotGroundLocomotion.cpp"
+			$File	"NextBot\NextBotGroundLocomotion.h"
+			$File	"NextBot\simple_bot.cpp"
+			$File	"NextBot\simple_bot.h"
+
+			$Folder "NextBotInterfaces"
+			{
+				$File	"NextBot\NextBotBodyInterface.cpp"
+				$File	"NextBot\NextBotBodyInterface.h"
+				$File	"NextBot\NextBotComponentInterface.cpp"
+				$File	"NextBot\NextBotComponentInterface.h"
+				$File	"NextBot\NextBotEventResponderInterface.h"
+				$File	"NextBot\NextBotHearingInterface.h"
+				$File	"NextBot\NextBotIntentionInterface.cpp"
+				$File	"NextBot\NextBotIntentionInterface.h"
+				$File	"NextBot\NextBotInterface.cpp"
+				$File	"NextBot\NextBotInterface.h"
+				$File	"NextBot\NextBotLocomotionInterface.cpp"
+				$File	"NextBot\NextBotLocomotionInterface.h"
+				$File	"NextBot\NextBotVisionInterface.cpp"
+				$File	"NextBot\NextBotVisionInterface.h"
+				$File	"NextBot\NextBotContextualQueryInterface.h"
+			}
+
+			$Folder "NextBotPath"
+			{
+				$File	"NextBot\Path\NextBotChasePath.cpp"
+				$File	"NextBot\Path\NextBotChasePath.h"
+				$File	"NextBot\Path\NextBotRetreatPath.h"
+				$File	"NextBot\Path\NextBotPath.cpp"
+				$File	"NextBot\Path\NextBotPath.h"
+				$File	"NextBot\Path\NextBotPathFollow.cpp"
+				$File	"NextBot\Path\NextBotPathFollow.h"
+			}
+			
+			$Folder "NextBotPlayer"
+			{
+				$File	"NextBot\Player\NextBotPlayerBody.cpp"
+				$File	"NextBot\Player\NextBotPlayerBody.h"
+				$File	"NextBot\Player\NextBotPlayerLocomotion.cpp"
+				$File	"NextBot\Player\NextBotPlayerLocomotion.h"
+				$File	"NextBot\Player\NextBotPlayer.cpp"
+				$File	"NextBot\Player\NextBotPlayer.h"
+			}
+
+			$Folder "NextBotCommonBehaviors"
+			{
+				$File	"NextBot\Behavior\BehaviorBackUp.h"
+				$File	"NextBot\Behavior\BehaviorMoveTo.h"
+			}
+
+			$Folder "NextBotNavMeshEntities"
+			{
+				$File	"NextBot\NavMeshEntities\func_nav_prerequisite.cpp"
+				$File	"NextBot\NavMeshEntities\func_nav_prerequisite.h"
+			}
+		}
+	}
+}
diff --git a/game/shared/cstrike/achievements_cs.cpp b/game/shared/cstrike/achievements_cs.cpp
new file mode 100644
index 00000000..7bfbe378
--- /dev/null
+++ b/game/shared/cstrike/achievements_cs.cpp
@@ -0,0 +1,727 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+#include <time.h>
+
+#ifdef CLIENT_DLL
+
+#include "achievementmgr.h"
+#include "baseachievement.h"
+#include "cs_achievement_constants.h"
+#include "c_cs_team.h"
+#include "c_cs_player.h"
+#include "c_cs_playerresource.h"
+#include "cs_gamerules.h"
+#include "achievements_cs.h"
+#include "cs_gamestats_shared.h"
+#include "cs_client_gamestats.h"
+
+
+// [dwenger] Necessary for stats display
+#include "cs_achievements_and_stats_interface.h"
+
+// [dwenger] Necessary for sorting achievements by award time
+#include <vgui/ISystem.h>
+#include "vgui_controls/Controls.h"
+
+
+ConVar achievements_easymode( "achievement_easymode", "0", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY,
+						 "Enables all stat-based achievements to be earned at 10% of goals" );
+
+// global achievement mgr for CS
+CAchievementMgr g_AchievementMgrCS;		
+
+// [dwenger] Necessary for achievement / stats panel
+CSAchievementsAndStatsInterface g_AchievementsAndStatsInterfaceCS;
+
+
+CCSBaseAchievement::CCSBaseAchievement()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines the timestamp when the achievement is awarded
+//-----------------------------------------------------------------------------
+void CCSBaseAchievement::OnAchieved()
+{
+// 	__time32_t unlockTime;
+// 	_time32(&unlockTime);
+// 	SetUnlockTime(unlockTime);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the time values when the achievement was awarded.
+//-----------------------------------------------------------------------------
+bool CCSBaseAchievement::GetAwardTime( int& year, int& month, int& day, int& hour, int& minute, int& second )
+{
+	time_t t = GetUnlockTime();
+
+	if ( t != 0 )
+	{
+		struct tm structuredTime;
+
+		Plat_localtime(&t, &structuredTime);
+
+		year = structuredTime.tm_year + 1900;
+		month = structuredTime.tm_mon + 1;	// 0..11
+		day = structuredTime.tm_mday;
+		hour = structuredTime.tm_hour;
+		minute = structuredTime.tm_min;
+		second = structuredTime.tm_sec;
+
+		return true;
+	} 
+
+	return false;
+}
+
+void CCSBaseAchievement::GetSettings( KeyValues* pNodeOut )
+{
+	BaseClass::GetSettings(pNodeOut);
+
+	pNodeOut->SetInt("unlockTime", GetUnlockTime());
+}
+
+void CCSBaseAchievement::ApplySettings( /* const */ KeyValues* pNodeIn )
+{
+	BaseClass::ApplySettings(pNodeIn);
+
+	SetUnlockTime(pNodeIn->GetInt("unlockTime"));
+}
+
+
+/**
+* Meta Achievement base class methods
+*/
+CAchievement_Meta::CAchievement_Meta() :
+	m_CallbackUserAchievement( this, &CAchievement_Meta::Steam_OnUserAchievementStored )
+{
+}
+
+void CAchievement_Meta::Init()
+{
+	SetFlags( ACH_SAVE_GLOBAL );
+	SetGoal( 1 );
+}
+
+void CAchievement_Meta::Steam_OnUserAchievementStored( UserAchievementStored_t *pUserAchievementStored )
+{
+	if ( IsAchieved() )
+		return;
+
+	int iAchieved = 0;
+
+	FOR_EACH_VEC(m_requirements, i)
+	{
+		IAchievement* pAchievement = (IAchievement*)m_pAchievementMgr->GetAchievementByID(m_requirements[i]);
+		Assert ( pAchievement );
+
+		if ( pAchievement->IsAchieved() )
+			iAchieved++;
+		else
+			break;
+	}
+
+	if ( iAchieved == m_requirements.Count() )
+	{
+		AwardAchievement();
+	}
+}
+
+void CAchievement_Meta::AddRequirement( int nAchievementId )
+{
+	m_requirements.AddToTail(nAchievementId);
+}
+
+#if 0
+bool CheckWinNoEnemyCaps( IGameEvent *event, int iRole );
+
+// Grace period that we allow a player to start after level init and still consider them to be participating for the full round.  This is fairly generous
+// because it can in some cases take a client several minutes to connect with respect to when the server considers the game underway
+#define CS_FULL_ROUND_GRACE_PERIOD	( 4 * 60.0f )
+
+bool IsLocalCSPlayerClass( int iClass );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBaseAchievementFullRound::Init() 
+{
+	m_iFlags |= ACH_FILTER_FULL_ROUND_ONLY;		
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBaseAchievementFullRound::ListenForEvents()
+{
+	ListenForGameEvent( "teamplay_round_win" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSBaseAchievementFullRound::FireGameEvent_Internal( IGameEvent *event )
+{
+	if ( 0 == Q_strcmp( event->GetName(), "teamplay_round_win" ) )
+	{
+		C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+		if ( pLocalPlayer )
+		{
+			// is the player currently on a game team?
+			int iTeam = pLocalPlayer->GetTeamNumber();
+			if ( iTeam >= FIRST_GAME_TEAM ) 
+			{
+				float flRoundTime = event->GetFloat( "round_time", 0 );
+				if ( flRoundTime > 0 )
+				{
+					Event_OnRoundComplete( flRoundTime, event );
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CCSBaseAchievementFullRound::PlayerWasInEntireRound( float flRoundTime )
+{
+	float flTeamplayStartTime = m_pAchievementMgr->GetTeamplayStartTime();
+	if ( flTeamplayStartTime > 0 ) 
+	{	
+		// has the player been present and on a game team since the start of this round (minus a grace period)?
+		if ( flTeamplayStartTime < ( gpGlobals->curtime - flRoundTime ) + CS_FULL_ROUND_GRACE_PERIOD )
+			return true;
+	}
+	return false;
+}
+#endif
+
+//Base class for all achievements to kill x players with a given weapon
+class CAchievement_StatGoal: public CCSBaseAchievement
+{
+public:
+	void SetStatId(CSStatType_t stat)
+	{
+		m_StatId = stat;
+	}
+private:
+	virtual void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );		
+	}	
+
+	void OnPlayerStatsUpdate()
+	{
+		// when stats are updated by server, use most recent stat value
+		const StatsCollection_t& roundStats = g_CSClientGameStats.GetLifetimeStats();
+
+		int iOldCount = GetCount();
+		SetCount(roundStats[m_StatId]);
+		if ( GetCount() != iOldCount )
+		{
+			m_pAchievementMgr->SetDirty(true);
+		}
+
+		int iGoal = GetGoal();
+		if (!IsAchieved() && iGoal > 0 )
+		{
+			if (achievements_easymode.GetBool())
+			{
+				iGoal /= 10;
+				if ( iGoal == 0 )
+					iGoal = 1;
+			}
+
+			if ( GetCount() >= iGoal )
+			{
+				AwardAchievement();
+			}
+		}
+	}
+	CSStatType_t m_StatId;
+};
+
+#define DECLARE_ACHIEVEMENT_STATGOAL( achievementID, achievementName, iPointValue, iStatId, iGoal ) \
+	static CBaseAchievement *Create_##achievementID( void )			\
+{																		\
+	CAchievement_StatGoal *pAchievement = new CAchievement_StatGoal();	\
+	pAchievement->SetAchievementID( achievementID );					\
+	pAchievement->SetName( achievementName );							\
+	pAchievement->SetPointValue( iPointValue );							\
+	pAchievement->SetHideUntilAchieved( false );						\
+	pAchievement->SetStatId(iStatId);									\
+	pAchievement->SetGoal( iGoal );										\
+	return pAchievement;												\
+};																		\
+static CBaseAchievementHelper g_##achievementID##_Helper( Create_##achievementID );			
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsLow,		    "KILL_ENEMY_LOW",			10,	CSSTAT_KILLS,					25); //25
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsMed,		    "KILL_ENEMY_MED",			10,	CSSTAT_KILLS,					500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsHigh,		    "KILL_ENEMY_HIGH",			10,	CSSTAT_KILLS,					10000); //10000
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinRoundsLow,			"WIN_ROUNDS_LOW",			10,	CSSTAT_ROUNDS_WON,				10); //10
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinRoundsMed,            "WIN_ROUNDS_MED",			10,	CSSTAT_ROUNDS_WON,				200); //200
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinRoundsHigh,		    "WIN_ROUNDS_HIGH",			10,	CSSTAT_ROUNDS_WON,				5000); //5000
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinPistolRoundsLow,	    "WIN_PISTOLROUNDS_LOW",		10,	CSSTAT_PISTOLROUNDS_WON,		5); //5
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinPistolRoundsMed,	    "WIN_PISTOLROUNDS_MED",		10,	CSSTAT_PISTOLROUNDS_WON,		25); //25
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinPistolRoundsHigh,	    "WIN_PISTOLROUNDS_HIGH",	10,	CSSTAT_PISTOLROUNDS_WON,		250); //250
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSMoneyEarnedLow,		    "EARN_MONEY_LOW",			10,	CSSTAT_MONEY_EARNED,			125000);    //125000
+DECLARE_ACHIEVEMENT_STATGOAL(CSMoneyEarnedMed,		    "EARN_MONEY_MED",			10,	CSSTAT_MONEY_EARNED,			2500000);   //2500000
+DECLARE_ACHIEVEMENT_STATGOAL(CSMoneyEarnedHigh,		    "EARN_MONEY_HIGH",			10,	CSSTAT_MONEY_EARNED,			50000000);  //50000000
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSGiveDamageLow,		    "GIVE_DAMAGE_LOW",			10,	CSSTAT_DAMAGE,					2500); //2500
+DECLARE_ACHIEVEMENT_STATGOAL(CSGiveDamageMed,		    "GIVE_DAMAGE_MED",			10,	CSSTAT_DAMAGE,					50000); //50000
+DECLARE_ACHIEVEMENT_STATGOAL(CSGiveDamageHigh,		    "GIVE_DAMAGE_HIGH",			10,	CSSTAT_DAMAGE,					1000000); //1000000
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsDeagle,		"KILL_ENEMY_DEAGLE",		5,	CSSTAT_KILLS_DEAGLE,			200); //200
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsUSP,		    "KILL_ENEMY_USP",			5,	CSSTAT_KILLS_USP,				200); //200
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsGlock,		    "KILL_ENEMY_GLOCK",			5,	CSSTAT_KILLS_GLOCK,				200); //200
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsP228,		    "KILL_ENEMY_P228",			5,	CSSTAT_KILLS_P228,				200); //200
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsElite,		    "KILL_ENEMY_ELITE",			5,	CSSTAT_KILLS_ELITE,				100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsFiveSeven,	    "KILL_ENEMY_FIVESEVEN",		5,	CSSTAT_KILLS_FIVESEVEN,			100); //100
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsAWP,		    "KILL_ENEMY_AWP",			5,	CSSTAT_KILLS_AWP,				1000); //1000
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsAK47,		    "KILL_ENEMY_AK47",			5,	CSSTAT_KILLS_AK47,				1000); //1000
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsM4A1,		    "KILL_ENEMY_M4A1",			5,	CSSTAT_KILLS_M4A1,				1000); //1000
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsAUG,		    "KILL_ENEMY_AUG",			5,	CSSTAT_KILLS_AUG,				500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsSG552,		    "KILL_ENEMY_SG552",         5,	CSSTAT_KILLS_SG552,				500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsSG550,		    "KILL_ENEMY_SG550",			5,	CSSTAT_KILLS_SG550,				500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsGALIL,		    "KILL_ENEMY_GALIL",			5,	CSSTAT_KILLS_GALIL,				500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsFAMAS,		    "KILL_ENEMY_FAMAS",			5,	CSSTAT_KILLS_FAMAS,				500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsScout,		    "KILL_ENEMY_SCOUT",			5,	CSSTAT_KILLS_SCOUT,				1000); //1000
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsG3SG1,		    "KILL_ENEMY_G3SG1",			5,	CSSTAT_KILLS_G3SG1,				500); //500
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsP90,		    "KILL_ENEMY_P90",			5,	CSSTAT_KILLS_P90,				1000); //1000
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsMP5NAVY,	    "KILL_ENEMY_MP5NAVY",		5,	CSSTAT_KILLS_MP5NAVY,			1000); //1000
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsTMP,		    "KILL_ENEMY_TMP",			5,	CSSTAT_KILLS_TMP,				500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsMAC10,		    "KILL_ENEMY_MAC10",			5,	CSSTAT_KILLS_MAC10,				500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsUMP45,		    "KILL_ENEMY_UMP45",			5,	CSSTAT_KILLS_UMP45,				1000); //1000
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsM3,			"KILL_ENEMY_M3",			5,	CSSTAT_KILLS_M3,				200); //200
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsXM1014,		"KILL_ENEMY_XM1014",		5,	CSSTAT_KILLS_XM1014,			200); //200
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsM249,		    "KILL_ENEMY_M249",			5,	CSSTAT_KILLS_M249,				500); //500
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsKnife,		    "KILL_ENEMY_KNIFE",			5,	CSSTAT_KILLS_KNIFE,				100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSEnemyKillsHEGrenade,	    "KILL_ENEMY_HEGRENADE",		5,	CSSTAT_KILLS_HEGRENADE,			500); //500
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSHeadshots,				"HEADSHOTS",				5,	CSSTAT_KILLS_HEADSHOT,			250); //250
+DECLARE_ACHIEVEMENT_STATGOAL(CSKillsEnemyWeapon,		"KILLS_ENEMY_WEAPON",		5,	CSSTAT_KILLS_ENEMY_WEAPON,		100); //100
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSKillEnemyBlinded,		"KILL_ENEMY_BLINDED",		5,	CSSTAT_KILLS_ENEMY_BLINDED,		25); //25
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSDefuseBombsLow,          "BOMB_DEFUSE_LOW",			5,	CSSTAT_NUM_BOMBS_DEFUSED,		100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSPlantBombsLow,		    "BOMB_PLANT_LOW",			5,	CSSTAT_NUM_BOMBS_PLANTED,		100); //100
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSRescueHostagesLow,	    "RESCUE_HOSTAGES_LOW",		5,	CSSTAT_NUM_HOSTAGES_RESCUED,	100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSRescueHostagesMid,	    "RESCUE_HOSTAGES_MED",		5,	CSSTAT_NUM_HOSTAGES_RESCUED,	500); //500
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinKnifeFightsLow,       "WIN_KNIFE_FIGHTS_LOW",		5,  CSSTAT_KILLS_KNIFE_FIGHT,       1); //1
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinKnifeFightsHigh,      "WIN_KNIFE_FIGHTS_HIGH",	5,  CSSTAT_KILLS_KNIFE_FIGHT,       100); //100
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSDecalSprays,             "DECAL_SPRAYS",				5,	CSSTAT_DECAL_SPRAYS,            100); //100
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSNightvisionDamage,       "NIGHTVISION_DAMAGE",       5,	CSSTAT_NIGHTVISION_DAMAGE,      5000); //5000
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSKillSnipers,             "KILL_SNIPERS",				5,	CSSTAT_KILLS_AGAINST_ZOOMED_SNIPER, 100); //100
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapCS_ASSAULT,        "WIN_MAP_CS_ASSAULT",       5,  CSSTAT_MAP_WINS_CS_ASSAULT,     100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapCS_COMPOUND,       "WIN_MAP_CS_COMPOUND",      5,  CSSTAT_MAP_WINS_CS_COMPOUND,    100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapCS_HAVANA,         "WIN_MAP_CS_HAVANA",        5,  CSSTAT_MAP_WINS_CS_HAVANA,      100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapCS_ITALY,          "WIN_MAP_CS_ITALY",         5,  CSSTAT_MAP_WINS_CS_ITALY,       100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapCS_MILITIA,        "WIN_MAP_CS_MILITIA",       5,  CSSTAT_MAP_WINS_CS_MILITIA,     100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapCS_OFFICE,         "WIN_MAP_CS_OFFICE",        5,  CSSTAT_MAP_WINS_CS_OFFICE,      100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_AZTEC,          "WIN_MAP_DE_AZTEC",         5,  CSSTAT_MAP_WINS_DE_AZTEC,       100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_CBBLE,          "WIN_MAP_DE_CBBLE",         5,  CSSTAT_MAP_WINS_DE_CBBLE,       100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_CHATEAU,        "WIN_MAP_DE_CHATEAU",       5,  CSSTAT_MAP_WINS_DE_CHATEAU,     100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_DUST2,          "WIN_MAP_DE_DUST2",         5,  CSSTAT_MAP_WINS_DE_DUST2,       100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_DUST,           "WIN_MAP_DE_DUST",          5,  CSSTAT_MAP_WINS_DE_DUST,        100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_INFERNO,        "WIN_MAP_DE_INFERNO",       5,  CSSTAT_MAP_WINS_DE_INFERNO,     100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_NUKE,           "WIN_MAP_DE_NUKE",          5,  CSSTAT_MAP_WINS_DE_NUKE,        100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_PIRANESI,       "WIN_MAP_DE_PIRANESI",      5,  CSSTAT_MAP_WINS_DE_PIRANESI,    100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_PORT,           "WIN_MAP_DE_PORT",          5,  CSSTAT_MAP_WINS_DE_PORT,        100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_PRODIGY,        "WIN_MAP_DE_PRODIGY",       5,  CSSTAT_MAP_WINS_DE_PRODIGY,     100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_TIDES,          "WIN_MAP_DE_TIDES",         5,  CSSTAT_MAP_WINS_DE_TIDES,       100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSWinMapDE_TRAIN,          "WIN_MAP_DE_TRAIN",         5,  CSSTAT_MAP_WINS_DE_TRAIN,       100); //100
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSDonateWeapons,           "DONATE_WEAPONS",           5,  CSSTAT_WEAPONS_DONATED,         100); //100
+
+DECLARE_ACHIEVEMENT_STATGOAL(CSDominationsLow,          "DOMINATIONS_LOW",          5,  CSSTAT_DOMINATIONS,             1); //1
+DECLARE_ACHIEVEMENT_STATGOAL(CSDominationsHigh,         "DOMINATIONS_HIGH",         5,  CSSTAT_DOMINATIONS,             10); //10
+DECLARE_ACHIEVEMENT_STATGOAL(CSDominationOverkillsLow,  "DOMINATION_OVERKILLS_LOW", 5,  CSSTAT_DOMINATION_OVERKILLS,    1); //1
+DECLARE_ACHIEVEMENT_STATGOAL(CSDominationOverkillsHigh, "DOMINATION_OVERKILLS_HIGH",5,  CSSTAT_DOMINATION_OVERKILLS,    100); //100
+DECLARE_ACHIEVEMENT_STATGOAL(CSRevengesLow,             "REVENGES_LOW",             5,  CSSTAT_REVENGES,                1); //1
+DECLARE_ACHIEVEMENT_STATGOAL(CSRevengesHigh,            "REVENGES_HIGH",            5,  CSSTAT_REVENGES,                20); //20
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Generic server awarded achievement
+//-----------------------------------------------------------------------------
+class CAchievementCS_ServerAwarded : public CCSBaseAchievement
+{
+	virtual void Init() 
+	{
+		SetGoal(1);
+		SetFlags( ACH_SAVE_GLOBAL );
+	}
+
+	// server fires an event for this achievement, no other code within achievement necessary
+};
+
+#define DECLARE_ACHIEVEMENT_SERVERAWARDED(achievementID, achievementName, iPointValue) \
+	static CBaseAchievement *Create_##achievementID( void )			\
+{																		\
+	CAchievementCS_ServerAwarded *pAchievement = new CAchievementCS_ServerAwarded( );					\
+	pAchievement->SetAchievementID( achievementID );					\
+	pAchievement->SetName( achievementName );							\
+	pAchievement->SetPointValue( iPointValue );							\
+	return pAchievement;												\
+};																		\
+static CBaseAchievementHelper g_##achievementID##_Helper( Create_##achievementID );
+
+
+
+// server triggered achievements
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSBombDefuseCloseCall, "BOMB_DEFUSE_CLOSE_CALL", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSDefuseAndNeededKit, "BOMB_DEFUSE_NEEDED_KIT", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKilledDefuser, "KILL_BOMB_DEFUSER", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSWinBombPlant, "WIN_BOMB_PLANT", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSWinBombDefuse, "WIN_BOMB_DEFUSE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSPlantBombWithin25Seconds, "BOMB_PLANT_IN_25_SECONDS", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSRescueAllHostagesInARound, "RESCUE_ALL_HOSTAGES", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillEnemyWithFormerGun, "KILL_WITH_OWN_GUN", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillingSpree, "KILLING_SPREE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillTwoWithOneShot, "KILL_TWO_WITH_ONE_SHOT", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillEnemyReloading, "KILL_ENEMY_RELOADING", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillsWithMultipleGuns, "KILLS_WITH_MULTIPLE_GUNS", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSPosthumousGrenadeKill, "DEAD_GRENADE_KILL", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillEnemyTeam, "KILL_ENEMY_TEAM", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSLastPlayerAlive, "LAST_PLAYER_ALIVE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillEnemyLastBullet, "KILL_ENEMY_LAST_BULLET", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillingSpreeEnder, "KILLING_SPREE_ENDER", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillEnemiesWhileBlind, "KILL_ENEMIES_WHILE_BLIND", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillEnemiesWhileBlindHard, "KILL_ENEMIES_WHILE_BLIND_HARD", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSDamageNoKill, "DAMAGE_NO_KILL", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillLowDamage, "KILL_LOW_DAMAGE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKilledRescuer, "KILL_HOSTAGE_RESCUER", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSSurviveGrenade, "SURVIVE_GRENADE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKilledDefuserWithGrenade, "KILLED_DEFUSER_WITH_GRENADE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSSurvivedHeadshotDueToHelmet, "SURVIVED_HEADSHOT_DUE_TO_HELMET", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillSniperWithSniper, "KILL_SNIPER_WITH_SNIPER", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillSniperWithKnife, "KILL_SNIPER_WITH_KNIFE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSHipShot, "HIP_SHOT", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillWhenAtLowHealth, "KILL_WHEN_AT_LOW_HEALTH", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSGrenadeMultikill, "GRENADE_MULTIKILL", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSBombMultikill, "BOMB_MULTIKILL", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSPistolRoundKnifeKill, "PISTOL_ROUND_KNIFE_KILL", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSFastRoundWin, "FAST_ROUND_WIN", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSSurviveManyAttacks, "SURVIVE_MANY_ATTACKS", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSGooseChase, "GOOSE_CHASE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSWinBombPlantAfterRecovery, "WIN_BOMB_PLANT_AFTER_RECOVERY", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSLosslessExtermination, "LOSSLESS_EXTERMINATION", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSFlawlessVictory, "FLAWLESS_VICTORY", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSWinDualDuel, "WIN_DUAL_DUEL", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSFastHostageRescue, "FAST_HOSTAGE_RESCUE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSBreakWindows, "BREAK_WINDOWS", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSBreakProps, "BREAK_PROPS", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSUnstoppableForce, "UNSTOPPABLE_FORCE", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSImmovableObject, "IMMOVABLE_OBJECT", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSHeadshotsInRound, "HEADSHOTS_IN_ROUND", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillWhileInAir, "KILL_WHILE_IN_AIR", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillEnemyInAir, "KILL_ENEMY_IN_AIR", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillerAndEnemyInAir, "KILLER_AND_ENEMY_IN_AIR", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSSilentWin, "SILENT_WIN", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSBloodlessVictory, "BLOODLESS_VICTORY", 5);
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSWinRoundsWithoutBuying, "WIN_ROUNDS_WITHOUT_BUYING", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSDefuseDefense, "DEFUSE_DEFENSE", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSKillBombPickup, "KILL_BOMB_PICKUP", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSSameUniform, "SAME_UNIFORM", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSConcurrentDominations, "CONCURRENT_DOMINATIONS", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSDominationOverkillsMatch, "DOMINATION_OVERKILLS_MATCH", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSExtendedDomination, "EXTENDED_DOMINATION", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSCauseFriendlyFireWithFlashbang, "CAUSE_FRIENDLY_FIRE_WITH_FLASHBANG", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSWinClanMatch, "WIN_CLAN_MATCH", 5)
+DECLARE_ACHIEVEMENT_SERVERAWARDED(CSSnipeTwoFromSameSpot, "SNIPE_TWO_FROM_SAME_SPOT", 5 )
+
+
+
+
+//-----------------------------------------------------------------------------
+// Meta Achievements
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Purpose: Get all the pistol achievements
+//-----------------------------------------------------------------------------
+class CAchievementCS_PistolMaster : public CAchievement_Meta
+{
+	DECLARE_CLASS( CAchievementCS_PistolMaster, CAchievement_Meta );
+	virtual void Init() 
+	{
+		BaseClass::Init();
+		AddRequirement(CSEnemyKillsDeagle);
+		AddRequirement(CSEnemyKillsUSP);
+		AddRequirement(CSEnemyKillsGlock);
+		AddRequirement(CSEnemyKillsP228);
+		AddRequirement(CSEnemyKillsElite);
+		AddRequirement(CSEnemyKillsFiveSeven);
+	}
+};
+DECLARE_ACHIEVEMENT(CAchievementCS_PistolMaster, CSMetaPistol, "META_PISTOL", 10);
+
+//-----------------------------------------------------------------------------
+// Purpose: Get all the rifle achievements
+//-----------------------------------------------------------------------------
+class CAchievementCS_RifleMaster : public CAchievement_Meta
+{
+	DECLARE_CLASS( CAchievementCS_RifleMaster, CAchievement_Meta );
+	virtual void Init() 
+	{
+		BaseClass::Init();
+		AddRequirement(CSEnemyKillsAWP);
+		AddRequirement(CSEnemyKillsAK47);
+		AddRequirement(CSEnemyKillsM4A1);
+		AddRequirement(CSEnemyKillsAUG);
+		AddRequirement(CSEnemyKillsSG552);
+		AddRequirement(CSEnemyKillsSG550);
+		AddRequirement(CSEnemyKillsGALIL);
+		AddRequirement(CSEnemyKillsFAMAS);
+		AddRequirement(CSEnemyKillsScout);
+		AddRequirement(CSEnemyKillsG3SG1);
+	}
+};
+DECLARE_ACHIEVEMENT(CAchievementCS_RifleMaster, CSMetaRifle, "META_RIFLE", 10);
+
+//-----------------------------------------------------------------------------
+// Purpose: Get all the SMG achievements
+//-----------------------------------------------------------------------------
+class CAchievementCS_SubMachineGunMaster : public CAchievement_Meta
+{
+	DECLARE_CLASS( CAchievementCS_SubMachineGunMaster, CAchievement_Meta );
+	virtual void Init() 
+	{
+		BaseClass::Init();
+		AddRequirement(CSEnemyKillsP90);
+		AddRequirement(CSEnemyKillsMP5NAVY);
+		AddRequirement(CSEnemyKillsTMP);
+		AddRequirement(CSEnemyKillsMAC10);
+		AddRequirement(CSEnemyKillsUMP45);
+	}
+};
+DECLARE_ACHIEVEMENT(CAchievementCS_SubMachineGunMaster, CSMetaSMG, "META_SMG", 10);
+
+//-----------------------------------------------------------------------------
+// Purpose: Get all the Shotgun achievements
+//-----------------------------------------------------------------------------
+class CAchievementCS_ShotgunMaster : public CAchievement_Meta
+{
+	DECLARE_CLASS( CAchievementCS_ShotgunMaster, CAchievement_Meta );
+	virtual void Init() 
+	{
+		BaseClass::Init();
+		AddRequirement(CSEnemyKillsM3);
+		AddRequirement(CSEnemyKillsXM1014);
+	}
+};
+DECLARE_ACHIEVEMENT(CAchievementCS_ShotgunMaster, CSMetaShotgun, "META_SHOTGUN", 10);
+
+//-----------------------------------------------------------------------------
+// Purpose: Get every weapon achievement
+//-----------------------------------------------------------------------------
+class CAchievementCS_WeaponMaster : public CAchievement_Meta
+{
+	DECLARE_CLASS( CAchievementCS_WeaponMaster, CAchievement_Meta );
+	virtual void Init() 
+	{
+		BaseClass::Init();
+		AddRequirement(CSMetaPistol);	
+		AddRequirement(CSMetaRifle);
+		AddRequirement(CSMetaSMG);
+		AddRequirement(CSMetaShotgun);
+		AddRequirement(CSEnemyKillsM249);
+		AddRequirement(CSEnemyKillsKnife);
+		AddRequirement(CSEnemyKillsHEGrenade);
+	}
+};
+DECLARE_ACHIEVEMENT(CAchievementCS_WeaponMaster, CSMetaWeaponMaster, "META_WEAPONMASTER", 50);
+
+
+
+class CAchievementCS_KillWithAllWeapons : public CCSBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 1 );
+	}
+
+	void OnPlayerStatsUpdate()
+	{
+		const StatsCollection_t& roundStats = g_CSClientGameStats.GetLifetimeStats();
+
+		//Loop through all weapons we care about and make sure we got a kill with each.
+		for (int i = 0; WeaponName_StatId_Table[i].killStatId != CSSTAT_UNDEFINED; ++i)
+		{
+			CSStatType_t statId = WeaponName_StatId_Table[i].killStatId;
+
+			if ( roundStats[statId] == 0)
+			{
+				return;
+			}
+		}
+
+		//If we haven't bailed yet, award the achievement.		
+		IncrementCount();
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementCS_KillWithAllWeapons, CSKillWithEveryWeapon, "KILL_WITH_EVERY_WEAPON", 5 );
+
+class CAchievementCS_FriendsSameUniform : public CCSBaseAchievement
+{
+    void Init()
+    {
+        SetFlags(ACH_SAVE_GLOBAL);
+        SetGoal(1);
+    }
+
+    void ListenForEvents()
+    {
+        ListenForGameEvent( "round_start" );
+    }
+
+    void FireGameEvent_Internal( IGameEvent *event )
+    {
+        if ( Q_strcmp( event->GetName(), "round_start" ) == 0 )
+        {
+            int localPlayerIndex = GetLocalPlayerIndex();
+            C_CSPlayer* pLocalPlayer = ToCSPlayer(UTIL_PlayerByIndex(localPlayerIndex));
+
+            // Initialize all to 1, since the local player doesn't get counted as we loop.
+            int numPlayersOnTeam = 1;
+            int numFriendsOnTeam = 1;
+            int numMatchingFriendsOnTeam = 1;
+
+            if (pLocalPlayer)
+            {    
+                int localPlayerClass = pLocalPlayer->PlayerClass();
+                int localPlayerTeam = pLocalPlayer->GetTeamNumber();
+                for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+                {
+                    if ( i != localPlayerIndex)
+                    {
+                        CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+
+                        if (pPlayer)
+                        {
+                            if (pPlayer->GetTeamNumber() == localPlayerTeam)
+                            {
+                                ++numPlayersOnTeam;
+                                if (pLocalPlayer->HasPlayerAsFriend(pPlayer) )
+                                {
+                                    ++numFriendsOnTeam;
+                                    if ( pPlayer->PlayerClass() == localPlayerClass )
+                                        ++numMatchingFriendsOnTeam;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (numMatchingFriendsOnTeam >= AchievementConsts::FriendsSameUniform_MinPlayers )
+                {
+                    AwardAchievement();
+                }
+            }
+        }
+    }
+};
+DECLARE_ACHIEVEMENT( CAchievementCS_FriendsSameUniform, CSFriendsSameUniform, "FRIENDS_SAME_UNIFORM", 5 );
+
+
+
+class CAchievementCS_AvengeFriend : public CCSBaseAchievement
+{
+    void Init()
+    {
+        SetFlags(ACH_SAVE_GLOBAL);
+        SetGoal(1);
+    }
+
+    void ListenForEvents()
+    {
+        ListenForGameEvent( "player_avenged_teammate" );
+    }
+
+    void FireGameEvent_Internal( IGameEvent *event )
+    {
+        if ( Q_strcmp( event->GetName(), "player_avenged_teammate" ) == 0 )
+        {
+            int localPlayerIndex = GetLocalPlayerIndex();
+            C_CSPlayer* pLocalPlayer = ToCSPlayer(UTIL_PlayerByIndex(localPlayerIndex));
+
+            //for debugging
+            //int eventId = event->GetInt( "avenger_id" );
+            //int localUserId = pLocalPlayer->GetUserID();
+
+            if (pLocalPlayer && pLocalPlayer->GetUserID() == event->GetInt( "avenger_id" ))
+            {
+                int avengedPlayerIndex = engine->GetPlayerForUserID( event->GetInt( "avenged_player_id" ) );
+
+                if ( avengedPlayerIndex > 0 )
+                {
+                    C_CSPlayer* pAvengedPlayer = ToCSPlayer(UTIL_PlayerByIndex(avengedPlayerIndex));                        
+                    if (pAvengedPlayer && pLocalPlayer->HasPlayerAsFriend(pAvengedPlayer))
+                    {
+                        AwardAchievement();
+                    }
+                }             
+            }
+        }
+    }
+};
+DECLARE_ACHIEVEMENT( CAchievementCS_AvengeFriend, CSAvengeFriend, "AVENGE_FRIEND", 5 );
+
+
+
+class CAchievementCS_CollectHolidayGifts : public CCSBaseAchievement
+{
+	void Init() 
+	{
+		SetFlags( ACH_SAVE_GLOBAL );
+		SetGoal( 3 );
+		SetStoreProgressInSteam( true );
+	}
+
+	virtual void ListenForEvents()
+	{
+		ListenForGameEvent( "christmas_gift_grab" );
+	}
+
+	void FireGameEvent_Internal( IGameEvent *event )
+	{
+		if ( !UTIL_IsHolidayActive( 3 /*kHoliday_Christmas*/ ) )
+			return;
+
+		if ( Q_strcmp( event->GetName(), "christmas_gift_grab" ) == 0 )
+		{
+			int iPlayer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+			CBaseEntity *pPlayer = UTIL_PlayerByIndex( iPlayer );
+
+			if ( pPlayer && pPlayer == C_CSPlayer::GetLocalCSPlayer() )
+			{
+				IncrementCount();
+			}
+		}
+	}
+};
+DECLARE_ACHIEVEMENT( CAchievementCS_CollectHolidayGifts, CSCollectHolidayGifts, "COLLECT_GIFTS", 5 );
+
+#endif // CLIENT_DLL
+
diff --git a/game/shared/cstrike/achievements_cs.h b/game/shared/cstrike/achievements_cs.h
new file mode 100644
index 00000000..817a73e6
--- /dev/null
+++ b/game/shared/cstrike/achievements_cs.h
@@ -0,0 +1,75 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+
+#include "cbase.h"
+
+#ifdef CLIENT_DLL
+
+bool CheckWinNoEnemyCaps( IGameEvent *event, int iRole );
+bool IsLocalCSPlayerClass( int iClass );
+bool GameRulesAllowsAchievements( void );
+
+//----------------------------------------------------------------------------------------------------------------
+// Base class for all CS achievements
+class CCSBaseAchievement : public CBaseAchievement
+{
+    DECLARE_CLASS( CCSBaseAchievement, CBaseAchievement );
+public:
+
+    CCSBaseAchievement();
+
+	virtual void GetSettings( KeyValues* pNodeOut );				// serialize
+	virtual void ApplySettings( /* const */ KeyValues* pNodeIn );	// unserialize
+
+    // [dwenger] Necessary for sorting achievements by award time
+	virtual void OnAchieved();
+    bool GetAwardTime( int& year, int& month, int& day, int& hour, int& minute, int& second );
+
+	int64 GetSortKey() const { return GetUnlockTime(); }
+};
+
+
+//----------------------------------------------------------------------------------------------------------------
+// Helper class for achievements that check that the player was playing on a game team for the full round
+class CCSBaseAchievementFullRound : public CCSBaseAchievement
+{
+	DECLARE_CLASS( CCSBaseAchievementFullRound, CCSBaseAchievement );
+public:
+	virtual void Init() ;
+	virtual void ListenForEvents();
+	void FireGameEvent_Internal( IGameEvent *event );
+	bool PlayerWasInEntireRound( float flRoundTime );
+
+	virtual void Event_OnRoundComplete( float flRoundTime, IGameEvent *event ) = 0 ;
+};
+
+
+//----------------------------------------------------------------------------------------------------------------
+// Helper class for achievements based on other achievements
+class CAchievement_Meta : public CCSBaseAchievement
+{
+	DECLARE_CLASS( CAchievement_Meta, CCSBaseAchievement );
+public:
+	CAchievement_Meta();
+	virtual void Init();
+
+#if !defined(NO_STEAM)
+	STEAM_CALLBACK( CAchievement_Meta, Steam_OnUserAchievementStored, UserAchievementStored_t, m_CallbackUserAchievement );
+#endif
+
+protected:
+	void AddRequirement( int nAchievementId );
+
+private:
+	CUtlVector<int> m_requirements;
+};
+
+
+
+extern CAchievementMgr g_AchievementMgrCS;	// global achievement mgr for CS
+
+#endif // CLIENT_DLL
\ No newline at end of file
diff --git a/game/shared/cstrike/basecsgrenade_projectile.cpp b/game/shared/cstrike/basecsgrenade_projectile.cpp
new file mode 100644
index 00000000..5d6641b8
--- /dev/null
+++ b/game/shared/cstrike/basecsgrenade_projectile.cpp
@@ -0,0 +1,346 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "basecsgrenade_projectile.h"
+
+float GetCurrentGravity( void );
+
+
+#ifdef CLIENT_DLL
+
+	#include "c_cs_player.h"
+
+#else
+
+	#include "bot_manager.h"
+	#include "cs_player.h"
+	#include "soundent.h"
+	#include "te_effect_dispatch.h"
+	#include "KeyValues.h"
+
+	BEGIN_DATADESC( CBaseCSGrenadeProjectile )
+		DEFINE_THINKFUNC( DangerSoundThink ),
+	END_DATADESC()
+
+#endif
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseCSGrenadeProjectile, DT_BaseCSGrenadeProjectile )
+
+BEGIN_NETWORK_TABLE( CBaseCSGrenadeProjectile, DT_BaseCSGrenadeProjectile )
+	#ifdef CLIENT_DLL
+		RecvPropVector( RECVINFO( m_vInitialVelocity ) )
+	#else
+		SendPropVector( SENDINFO( m_vInitialVelocity ), 
+			20,		// nbits
+			0,		// flags
+			-3000,	// low value
+			3000	// high value
+			)
+	#endif
+END_NETWORK_TABLE()
+
+
+#ifdef CLIENT_DLL
+
+
+	void CBaseCSGrenadeProjectile::PostDataUpdate( DataUpdateType_t type )
+	{
+		BaseClass::PostDataUpdate( type );
+
+		if ( type == DATA_UPDATE_CREATED )
+		{
+			// Now stick our initial velocity into the interpolation history 
+			CInterpolatedVar< Vector > &interpolator = GetOriginInterpolator();
+			
+			interpolator.ClearHistory();
+			float changeTime = GetLastChangeTime( LATCH_SIMULATION_VAR );
+
+			// Add a sample 1 second back.
+			Vector vCurOrigin = GetLocalOrigin() - m_vInitialVelocity;
+			interpolator.AddToHead( changeTime - 1.0, &vCurOrigin, false );
+
+			// Add the current sample.
+			vCurOrigin = GetLocalOrigin();
+			interpolator.AddToHead( changeTime, &vCurOrigin, false );
+		}
+	}
+
+	int CBaseCSGrenadeProjectile::DrawModel( int flags )
+	{
+		// During the first half-second of our life, don't draw ourselves if he's
+		// still playing his throw animation.
+		// (better yet, we could draw ourselves in his hand).
+		if ( GetThrower() != C_BasePlayer::GetLocalPlayer() )
+		{
+			if ( gpGlobals->curtime - m_flSpawnTime < 0.5 )
+			{
+				C_CSPlayer *pPlayer = dynamic_cast<C_CSPlayer*>( GetThrower() );
+				if ( pPlayer && pPlayer->m_PlayerAnimState->IsThrowingGrenade() )
+				{
+					return 0;
+				}
+			}
+		}
+
+		return BaseClass::DrawModel( flags );
+	}
+
+	void CBaseCSGrenadeProjectile::Spawn()
+	{
+		m_flSpawnTime = gpGlobals->curtime;
+		BaseClass::Spawn();
+	}
+
+#else
+
+	void CBaseCSGrenadeProjectile::PostConstructor( const char *className )
+	{
+		BaseClass::PostConstructor( className );
+		TheBots->AddGrenade( this );
+	}
+
+	CBaseCSGrenadeProjectile::~CBaseCSGrenadeProjectile()
+	{
+		TheBots->RemoveGrenade( this );
+	}
+
+	void CBaseCSGrenadeProjectile::Spawn( void )
+	{
+		BaseClass::Spawn();
+
+		SetSolidFlags( FSOLID_NOT_STANDABLE );
+		SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );
+		SetSolid( SOLID_BBOX );	// So it will collide with physics props!
+
+		// smaller, cube bounding box so we rest on the ground
+		SetSize( Vector ( -2, -2, -2 ), Vector ( 2, 2, 2 ) );
+	}
+
+	void CBaseCSGrenadeProjectile::DangerSoundThink( void )
+	{
+		if (!IsInWorld())
+		{
+			Remove( );
+			return;
+		}
+
+		if( gpGlobals->curtime > m_flDetonateTime )
+		{
+			Detonate();
+			return;
+		}
+
+		CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin() + GetAbsVelocity() * 0.5, GetAbsVelocity().Length( ), 0.2 );
+
+		SetNextThink( gpGlobals->curtime + 0.2 );
+
+		if (GetWaterLevel() != 0)
+		{
+			SetAbsVelocity( GetAbsVelocity() * 0.5 );
+		}
+	}
+
+	//Sets the time at which the grenade will explode
+	void CBaseCSGrenadeProjectile::SetDetonateTimerLength( float timer )
+	{
+		m_flDetonateTime = gpGlobals->curtime + timer;
+	}
+
+	void CBaseCSGrenadeProjectile::ResolveFlyCollisionCustom( trace_t &trace, Vector &vecVelocity )
+	{
+		//Assume all surfaces have the same elasticity
+		float flSurfaceElasticity = 1.0;
+
+		//Don't bounce off of players with perfect elasticity
+		if( trace.m_pEnt && trace.m_pEnt->IsPlayer() )
+		{
+			flSurfaceElasticity = 0.3;
+		}
+
+		// if its breakable glass and we kill it, don't bounce.
+		// give some damage to the glass, and if it breaks, pass 
+		// through it.
+		bool breakthrough = false;
+
+		if( trace.m_pEnt && FClassnameIs( trace.m_pEnt, "func_breakable" ) )
+		{
+			breakthrough = true;
+		}
+
+		if( trace.m_pEnt && FClassnameIs( trace.m_pEnt, "func_breakable_surf" ) )
+		{
+			breakthrough = true;
+		}
+
+		if (breakthrough)
+		{
+			CTakeDamageInfo info( this, this, 10, DMG_CLUB );
+			trace.m_pEnt->DispatchTraceAttack( info, GetAbsVelocity(), &trace );
+
+			ApplyMultiDamage();
+
+			if( trace.m_pEnt->m_iHealth <= 0 )
+			{
+				// slow our flight a little bit
+				Vector vel = GetAbsVelocity();
+
+				vel *= 0.4;
+
+				SetAbsVelocity( vel );
+				return;
+			}
+		}
+		
+		float flTotalElasticity = GetElasticity() * flSurfaceElasticity;
+		flTotalElasticity = clamp( flTotalElasticity, 0.0f, 0.9f );
+
+		// NOTE: A backoff of 2.0f is a reflection
+		Vector vecAbsVelocity;
+		PhysicsClipVelocity( GetAbsVelocity(), trace.plane.normal, vecAbsVelocity, 2.0f );
+		vecAbsVelocity *= flTotalElasticity;
+
+		// Get the total velocity (player + conveyors, etc.)
+		VectorAdd( vecAbsVelocity, GetBaseVelocity(), vecVelocity );
+		float flSpeedSqr = DotProduct( vecVelocity, vecVelocity );
+
+		// Stop if on ground.
+		if ( trace.plane.normal.z > 0.7f )			// Floor
+		{
+			// Verify that we have an entity.
+			CBaseEntity *pEntity = trace.m_pEnt;
+			Assert( pEntity );
+
+			SetAbsVelocity( vecAbsVelocity );
+
+			if ( flSpeedSqr < ( 30 * 30 ) )
+			{
+				if ( pEntity->IsStandable() )
+				{
+					SetGroundEntity( pEntity );
+				}
+
+				// Reset velocities.
+				SetAbsVelocity( vec3_origin );
+				SetLocalAngularVelocity( vec3_angle );
+
+				//align to the ground so we're not standing on end
+				QAngle angle;
+				VectorAngles( trace.plane.normal, angle );
+
+				// rotate randomly in yaw
+				angle[1] = random->RandomFloat( 0, 360 );
+
+				// TODO: rotate around trace.plane.normal
+				
+				SetAbsAngles( angle );			
+			}
+			else
+			{
+				Vector vecDelta = GetBaseVelocity() - vecAbsVelocity;	
+				Vector vecBaseDir = GetBaseVelocity();
+				VectorNormalize( vecBaseDir );
+				float flScale = vecDelta.Dot( vecBaseDir );
+
+				VectorScale( vecAbsVelocity, ( 1.0f - trace.fraction ) * gpGlobals->frametime, vecVelocity ); 
+				VectorMA( vecVelocity, ( 1.0f - trace.fraction ) * gpGlobals->frametime, GetBaseVelocity() * flScale, vecVelocity );
+				PhysicsPushEntity( vecVelocity, &trace );
+			}
+		}
+		else
+		{
+			// If we get *too* slow, we'll stick without ever coming to rest because
+			// we'll get pushed down by gravity faster than we can escape from the wall.
+			if ( flSpeedSqr < ( 30 * 30 ) )
+			{
+				// Reset velocities.
+				SetAbsVelocity( vec3_origin );
+				SetLocalAngularVelocity( vec3_angle );
+			}
+			else
+			{
+				SetAbsVelocity( vecAbsVelocity );
+			}
+		}
+		
+		BounceSound();
+
+		// tell the bots a grenade has bounced
+		CCSPlayer *player = ToCSPlayer(GetThrower());
+		if ( player )
+		{
+			IGameEvent * event = gameeventmanager->CreateEvent( "grenade_bounce" );
+			if ( event )
+			{
+				event->SetInt( "userid", player->GetUserID() );
+				event->SetFloat( "x", GetAbsOrigin().x );
+				event->SetFloat( "y", GetAbsOrigin().y );
+				event->SetFloat( "z", GetAbsOrigin().z );
+				gameeventmanager->FireEvent( event );
+			}
+		}
+	}
+
+	void CBaseCSGrenadeProjectile::SetupInitialTransmittedGrenadeVelocity( const Vector &velocity )
+	{
+		m_vInitialVelocity = velocity;
+	}
+
+	#define	MAX_WATER_SURFACE_DISTANCE	512
+
+	void CBaseCSGrenadeProjectile::Splash()
+	{
+		Vector centerPoint = GetAbsOrigin();
+		Vector normal( 0, 0, 1 );
+
+		// Find our water surface by tracing up till we're out of the water
+		trace_t tr;
+		Vector vecTrace( 0, 0, MAX_WATER_SURFACE_DISTANCE );
+		UTIL_TraceLine( centerPoint, centerPoint + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr );
+
+		// If we didn't start in water, we're above it
+		if ( tr.startsolid == false )
+		{
+			// Look downward to find the surface
+			vecTrace.Init( 0, 0, -MAX_WATER_SURFACE_DISTANCE );
+			UTIL_TraceLine( centerPoint, centerPoint + vecTrace, MASK_WATER, NULL, COLLISION_GROUP_NONE, &tr );
+
+			// If we hit it, setup the explosion
+			if ( tr.fraction < 1.0f )
+			{
+				centerPoint = tr.endpos;
+			}
+			else
+			{
+				//NOTENOTE: We somehow got into a splash without being near water?
+				Assert( 0 );
+			}
+		}
+		else if ( tr.fractionleftsolid )
+		{
+			// Otherwise we came out of the water at this point
+			centerPoint = centerPoint + (vecTrace * tr.fractionleftsolid);
+		}
+		else
+		{
+			// Use default values, we're really deep
+		}
+
+		CEffectData	data;
+ 		data.m_vOrigin = centerPoint;
+		data.m_vNormal = normal;
+		data.m_flScale = random->RandomFloat( 1.0f, 2.0f );
+
+		if ( GetWaterType() & CONTENTS_SLIME )
+		{
+			data.m_fFlags |= FX_WATER_IN_SLIME;
+		}
+
+		DispatchEffect( "gunshotsplash", data );
+	}
+
+#endif // !CLIENT_DLL
diff --git a/game/shared/cstrike/basecsgrenade_projectile.h b/game/shared/cstrike/basecsgrenade_projectile.h
new file mode 100644
index 00000000..56ebd47f
--- /dev/null
+++ b/game/shared/cstrike/basecsgrenade_projectile.h
@@ -0,0 +1,88 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef BASECSGRENADE_PROJECTILE_H
+#define BASECSGRENADE_PROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "basegrenade_shared.h"
+
+
+#ifdef CLIENT_DLL
+	#define CBaseCSGrenadeProjectile C_BaseCSGrenadeProjectile
+#else
+	class CCSWeaponInfo;
+#endif
+
+
+class CBaseCSGrenadeProjectile : public CBaseGrenade
+{
+public:
+	DECLARE_CLASS( CBaseCSGrenadeProjectile, CBaseGrenade );
+	DECLARE_NETWORKCLASS(); 
+
+	virtual void Spawn();
+
+
+public:
+
+	// This gets sent to the client and placed in the client's interpolation history
+	// so the projectile starts out moving right off the bat.
+	CNetworkVector( m_vInitialVelocity );
+
+
+#ifdef CLIENT_DLL
+	CBaseCSGrenadeProjectile() {}
+	CBaseCSGrenadeProjectile( const CBaseCSGrenadeProjectile& ) {}
+	virtual int DrawModel( int flags );
+	virtual void PostDataUpdate( DataUpdateType_t type );
+	
+	float m_flSpawnTime;
+#else
+	DECLARE_DATADESC();
+
+	virtual void PostConstructor( const char *className );
+	virtual ~CBaseCSGrenadeProjectile();
+
+	//Constants for all CS Grenades
+	static inline float GetGrenadeGravity() { return 0.4f; }
+	static inline const float GetGrenadeFriction() { return 0.2f; }
+	static inline const float GetGrenadeElasticity() { return 0.45f; }
+
+	//Think function to emit danger sounds for the AI
+	void DangerSoundThink( void );
+	
+	virtual float GetShakeAmplitude( void ) { return 0.0f; }
+	virtual void Splash();
+
+	// Specify what velocity we want the grenade to have on the client immediately.
+	// Without this, the entity wouldn't have an interpolation history initially, so it would
+	// sit still until it had gotten a few updates from the server.
+	void SetupInitialTransmittedGrenadeVelocity( const Vector &velocity );
+
+    // [jpaquin] give grenade projectiles a link back to the type
+	// of weapon they are
+	CCSWeaponInfo *m_pWeaponInfo;
+
+protected:
+
+	//Set the time to detonate ( now + timer )
+	void SetDetonateTimerLength( float timer );
+
+private:	
+	
+	//Custom collision to allow for constant elasticity on hit surfaces
+	virtual void ResolveFlyCollisionCustom( trace_t &trace, Vector &vecVelocity );
+	
+	float m_flDetonateTime;
+#endif
+};
+
+
+#endif // BASECSGRENADE_PROJECTILE_H
diff --git a/game/shared/cstrike/bot/bot.cpp b/game/shared/cstrike/bot/bot.cpp
new file mode 100644
index 00000000..4b17ddf5
--- /dev/null
+++ b/game/shared/cstrike/bot/bot.cpp
@@ -0,0 +1,109 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), Leon Hartwig, 2003
+
+#include "cbase.h"
+#include "basegrenade_shared.h"
+
+#include "bot.h"
+#include "bot_util.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+/// @todo Remove this nasty hack - CreateFakeClient() calls CBot::Spawn, which needs the profile and team
+const BotProfile *g_botInitProfile = NULL;
+int g_botInitTeam = 0;
+
+//
+// NOTE: Because CBot had to be templatized, the code was moved into bot.h
+//
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+
+ActiveGrenade::ActiveGrenade( CBaseGrenade *grenadeEntity )
+{
+	m_entity = grenadeEntity;
+	m_detonationPosition = grenadeEntity->GetAbsOrigin();
+	m_dieTimestamp = 0.0f;
+	m_radius = HEGrenadeRadius;
+
+	m_isSmoke = FStrEq( grenadeEntity->GetClassname(), "smokegrenade_projectile" );
+	if ( m_isSmoke )
+	{
+		m_radius = SmokeGrenadeRadius;
+	}
+
+	m_isFlashbang = FStrEq( grenadeEntity->GetClassname(), "flashbang_projectile" );
+	if ( m_isFlashbang )
+	{
+		m_radius = FlashbangGrenadeRadius;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Called when the grenade in the world goes away
+ */
+void ActiveGrenade::OnEntityGone( void )
+{
+	if (m_isSmoke)
+	{
+		// smoke lingers after grenade is gone
+		const float smokeLingerTime = 4.0f;
+		m_dieTimestamp = gpGlobals->curtime + smokeLingerTime;
+	}
+
+	m_entity = NULL;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void ActiveGrenade::Update( void )
+{
+	if (m_entity != NULL)
+	{
+		m_detonationPosition = m_entity->GetAbsOrigin();
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this grenade is valid
+ */
+bool ActiveGrenade::IsValid( void ) const
+{
+	if ( m_isSmoke )
+	{
+		if ( m_entity == NULL && gpGlobals->curtime > m_dieTimestamp )
+		{
+			return false;
+		}
+	}
+	else
+	{
+		if ( m_entity == NULL )
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+const Vector &ActiveGrenade::GetPosition( void ) const
+{
+	// smoke grenades can vanish before the smoke itself does - refer to the detonation position
+	if (m_entity == NULL)
+		return GetDetonationPosition();
+
+	return m_entity->GetAbsOrigin();
+}
+
diff --git a/game/shared/cstrike/bot/bot.h b/game/shared/cstrike/bot/bot.h
new file mode 100644
index 00000000..3067c2cf
--- /dev/null
+++ b/game/shared/cstrike/bot/bot.h
@@ -0,0 +1,1053 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+//
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+//
+// NOTE: The CS Bot code uses Doxygen-style comments. If you run Doxygen over this code, it will 
+// auto-generate documentation.  Visit www.doxygen.org to download the system for free.
+//
+
+#ifndef BOT_H
+#define BOT_H
+
+#include "cbase.h"
+#include "in_buttons.h"
+#include "movehelper_server.h"
+#include "mathlib/mathlib.h"
+
+#include "bot_manager.h"
+#include "bot_util.h"
+#include "bot_constants.h"
+#include "nav_mesh.h"
+#include "gameinterface.h"
+#include "weapon_csbase.h"
+#include "shared_util.h"
+#include "util.h"
+#include "shareddefs.h"
+
+#include "tier0/vprof.h"
+
+class BotProfile;
+
+
+extern bool AreBotsAllowed();
+
+
+//--------------------------------------------------------------------------------------------------------
+// BOTPORT: Convert everything to assume "origin" means "feet"
+
+//
+// Utility function to get "centroid" or center of player or player equivalent
+//
+inline Vector GetCentroid( const CBaseEntity *player )
+{
+	Vector centroid = player->GetAbsOrigin();
+
+	const Vector &mins = player->WorldAlignMins();
+	const Vector &maxs = player->WorldAlignMaxs();
+
+	centroid.z += (maxs.z - mins.z)/2.0f;
+
+	//centroid.z += HalfHumanHeight;
+
+	return centroid;
+}
+
+
+CBasePlayer* ClientPutInServerOverride_Bot( edict_t *pEdict, const char *playername );
+
+/// @todo Remove this nasty hack - CreateFakeClient() calls CBot::Spawn, which needs the profile
+extern const BotProfile *g_botInitProfile;
+extern int g_botInitTeam;
+extern int g_nClientPutInServerOverrides;
+
+//--------------------------------------------------------------------------------------------------------
+template < class T > T * CreateBot( const BotProfile *profile, int team )
+{
+	if ( !AreBotsAllowed() )
+		return NULL;
+
+	if ( UTIL_ClientsInGame() >= gpGlobals->maxClients )
+	{
+		CONSOLE_ECHO( "Unable to create bot: Server is full (%d/%d clients).\n", UTIL_ClientsInGame(), gpGlobals->maxClients );
+		return NULL;
+	}
+
+	// set the bot's name
+	char botName[64];
+	UTIL_ConstructBotNetName( botName, 64, profile );
+
+	// This is a backdoor we use so when the engine calls ClientPutInServer (from CreateFakeClient), 
+	// expecting the game to make an entity for the fake client, we can make our special bot class
+	// instead of a CCSPlayer.
+	g_nClientPutInServerOverrides = 0;
+	ClientPutInServerOverride( ClientPutInServerOverride_Bot );
+	
+	// get an edict for the bot
+	// NOTE: This will ultimately invoke CBot::Spawn(), so set the profile now
+	g_botInitProfile = profile;
+	g_botInitTeam = team;
+	edict_t *botEdict = engine->CreateFakeClient( botName );
+
+	ClientPutInServerOverride( NULL );
+	Assert( g_nClientPutInServerOverrides == 1 );
+
+
+	if ( botEdict == NULL )
+	{
+		CONSOLE_ECHO( "Unable to create bot: CreateFakeClient() returned null.\n" );
+		return NULL;
+	}
+
+
+	// create an instance of the bot's class and bind it to the edict
+	T *bot = dynamic_cast< T * >( CBaseEntity::Instance( botEdict ) );
+
+	if ( bot == NULL )
+	{
+		Assert( false );
+		Error( "Could not allocate and bind entity to bot edict.\n" );
+		return NULL;
+	}
+
+	bot->ClearFlags();
+	bot->AddFlag( FL_CLIENT | FL_FAKECLIENT );
+
+	return bot;
+}
+
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * The base bot class from which bots for specific games are derived
+ * A template is needed here because the CBot class must be derived from CBasePlayer, 
+ * but also may need to be derived from a more specific player class, such as CCSPlayer
+ */
+template < class PlayerType >
+class CBot : public PlayerType
+{
+public:
+	DECLARE_CLASS( CBot, PlayerType );
+
+	CBot( void );												///< constructor initializes all values to zero
+	virtual ~CBot();
+	virtual bool Initialize( const BotProfile *profile, int team );		///< (EXTEND) prepare bot for action
+
+	unsigned int GetID( void ) const		{ return m_id; }	///< return bot's unique ID
+
+	virtual bool IsBot( void ) const { return true; }	
+	virtual bool IsNetClient( void ) const { return false; }	// Bots should return FALSE for this, they can't receive NET messages
+
+	virtual void Spawn( void );									///< (EXTEND) spawn the bot into the game
+
+	virtual void Upkeep( void ) = 0;							///< lightweight maintenance, invoked frequently
+	virtual void Update( void ) = 0;							///< heavyweight algorithms, invoked less often
+
+
+	virtual void Run( void );
+	virtual void Walk( void );
+	virtual bool IsRunning( void ) const		{ return m_isRunning; }
+	
+	virtual void Crouch( void );
+	virtual void StandUp( void );
+	bool IsCrouching( void ) const	{ return m_isCrouching; }
+
+	void PushPostureContext( void );							///< push the current posture context onto the top of the stack
+	void PopPostureContext( void );								///< restore the posture context to the next context on the stack
+
+	virtual void MoveForward( void );
+	virtual void MoveBackward( void );
+	virtual void StrafeLeft( void );
+	virtual void StrafeRight( void );
+
+	#define MUST_JUMP true
+	virtual bool Jump( bool mustJump = false );					///< returns true if jump was started
+	bool IsJumping( void );										///< returns true if we are in the midst of a jump
+	float GetJumpTimestamp( void ) const	{ return m_jumpTimestamp; }	///< return time last jump began
+
+	virtual void ClearMovement( void );						///< zero any MoveForward(), Jump(), etc
+
+	const Vector &GetViewVector( void );						///< return the actual view direction
+
+
+	//------------------------------------------------------------------------------------
+	// Weapon interface
+	//
+	virtual void UseEnvironment( void );
+	virtual void PrimaryAttack( void );
+	virtual void ClearPrimaryAttack( void );
+	virtual void TogglePrimaryAttack( void );
+	virtual void SecondaryAttack( void );
+	virtual void Reload( void );
+
+	float GetActiveWeaponAmmoRatio( void ) const;				///< returns ratio of ammo left to max ammo (1 = full clip, 0 = empty)
+	bool IsActiveWeaponClipEmpty( void ) const;					///< return true if active weapon has any empty clip
+	bool IsActiveWeaponOutOfAmmo( void ) const;					///< return true if active weapon has no ammo at all
+	bool IsActiveWeaponRecoilHigh( void ) const;				///< return true if active weapon's bullet spray has become large and inaccurate
+	bool IsUsingScope( void );									///< return true if looking thru weapon's scope
+
+
+	//------------------------------------------------------------------------------------
+	// Event hooks
+	//
+
+	/// invoked when injured by something (EXTEND) - returns the amount of damage inflicted
+	virtual int OnTakeDamage( const CTakeDamageInfo &info )
+	{
+		return PlayerType::OnTakeDamage( info );
+	}
+
+	/// invoked when killed (EXTEND)
+	virtual void Event_Killed( const CTakeDamageInfo &info )
+	{ 
+		PlayerType::Event_Killed( info );
+	}
+
+	bool IsEnemy( CBaseEntity *ent ) const;						///< returns TRUE if given entity is our enemy
+	int GetEnemiesRemaining( void ) const;						///< return number of enemies left alive
+	int GetFriendsRemaining( void ) const;						///< return number of friends left alive
+
+	bool IsPlayerFacingMe( CBasePlayer *enemy ) const;			///< return true if player is facing towards us
+	bool IsPlayerLookingAtMe( CBasePlayer *enemy, float cosTolerance = 0.9f ) const;		///< returns true if other player is pointing right at us
+	bool IsLookingAtPosition( const Vector &pos, float angleTolerance = 20.0f ) const;	///< returns true if looking (roughly) at given position
+
+	bool IsLocalPlayerWatchingMe( void ) const;					///< return true if local player is observing this bot
+
+	void PrintIfWatched( PRINTF_FORMAT_STRING const char *format, ... ) const;				///< output message to console if we are being watched by the local player
+
+	virtual void UpdatePlayer( void );							///< update player physics, movement, weapon firing commands, etc
+	virtual void BuildUserCmd( CUserCmd& cmd, const QAngle& viewangles, float forwardmove, float sidemove, float upmove, int buttons, byte impulse );
+	virtual void SetModel( const char *modelName );
+
+	int Save( CSave &save )	const						{ return 0; }
+	int Restore( CRestore &restore ) const	{ return 0; }
+	virtual void Think( void ) { }
+
+	const BotProfile *GetProfile( void ) const		{ return m_profile; }	///< return our personality profile
+
+	virtual bool ClientCommand( const CCommand &args );			///< Do a "client command" - useful for invoking menu choices, etc.
+	virtual int Cmd_Argc( void );								///< Returns the number of tokens in the command string
+	virtual char *Cmd_Argv( int argc );							///< Retrieves a specified token
+
+private:
+	CUtlVector< char * > m_args;
+
+protected:
+	const BotProfile *m_profile;								///< the "personality" profile of this bot
+
+private:
+	friend class CBotManager;
+
+	unsigned int m_id;											///< unique bot ID
+
+	CUserCmd m_userCmd;
+	bool m_isRunning;											///< run/walk mode
+	bool m_isCrouching;											///< true if crouching (ducking)
+	float m_forwardSpeed;
+	float m_strafeSpeed;
+	float m_verticalSpeed;
+	int m_buttonFlags;											///< bitfield of movement buttons
+
+	float m_jumpTimestamp;										///< time when we last began a jump
+
+	Vector m_viewForward;										///< forward view direction (only valid when GetViewVector() is used)
+
+	/// the PostureContext represents the current settings of walking and crouching
+	struct PostureContext
+	{
+		bool isRunning;
+		bool isCrouching;
+	};
+	enum { MAX_POSTURE_STACK = 8 };
+	PostureContext m_postureStack[ MAX_POSTURE_STACK ];
+	int m_postureStackIndex;									///< index of top of stack
+
+	void ResetCommand( void );
+	//byte ThrottledMsec( void ) const;
+
+protected:
+	virtual float GetMoveSpeed( void );									///< returns current movement speed (for walk/run)
+};
+
+
+//-----------------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------------------------------------
+//
+// Inlines
+//
+
+//--------------------------------------------------------------------------------------------------------------
+template < class T >
+inline void CBot<T>::SetModel( const char *modelName )
+{
+	BaseClass::SetModel( modelName );
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline float CBot<T>::GetMoveSpeed( void )
+{
+	return this->MaxSpeed();
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline void CBot<T>::Run( void )
+{
+	m_isRunning = true;
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline void CBot<T>::Walk( void )
+{
+	m_isRunning = false;
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline bool CBot<T>::IsActiveWeaponRecoilHigh( void ) const
+{
+	const QAngle &angles = const_cast< CBot<T> * >( this )->GetPunchAngle();
+	const float highRecoil = -1.5f;
+	return (angles.x < highRecoil);
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline void CBot<T>::PushPostureContext( void )
+{
+	if (m_postureStackIndex == MAX_POSTURE_STACK)
+	{
+		PrintIfWatched( "PushPostureContext() overflow error!\n" );
+		return;
+	}
+
+	m_postureStack[ m_postureStackIndex ].isRunning = m_isRunning;
+	m_postureStack[ m_postureStackIndex ].isCrouching = m_isCrouching;
+	++m_postureStackIndex;
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline void CBot<T>::PopPostureContext( void )
+{
+	if (m_postureStackIndex == 0)
+	{
+		PrintIfWatched( "PopPostureContext() underflow error!\n" );
+		m_isRunning = true;
+		m_isCrouching = false;
+		return;
+	}
+
+	--m_postureStackIndex;
+	m_isRunning = m_postureStack[ m_postureStackIndex ].isRunning;
+	m_isCrouching = m_postureStack[ m_postureStackIndex ].isCrouching;
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline bool CBot<T>::IsPlayerFacingMe( CBasePlayer *other ) const
+{
+	Vector toOther = other->GetAbsOrigin() - this->GetAbsOrigin();
+
+	Vector otherForward;
+	AngleVectors( other->EyeAngles() + other->GetPunchAngle(), &otherForward );
+
+	if (DotProduct( otherForward, toOther ) < 0.0f)
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline bool CBot<T>::IsPlayerLookingAtMe( CBasePlayer *other, float cosTolerance ) const
+{
+	Vector toOther = other->GetAbsOrigin() - this->GetAbsOrigin();
+	toOther.NormalizeInPlace();
+
+	Vector otherForward;
+	AngleVectors( other->EyeAngles() + other->GetPunchAngle(), &otherForward );
+
+	// other player must be pointing nearly right at us to be "looking at" us
+	if (DotProduct( otherForward, toOther ) < -cosTolerance)
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline const Vector &CBot<T>::GetViewVector( void )
+{
+	AngleVectors( this->EyeAngles() + this->GetPunchAngle(), &m_viewForward );
+	return m_viewForward;
+}
+
+//-----------------------------------------------------------------------------------------------------------
+template < class T >
+inline bool CBot<T>::IsLookingAtPosition( const Vector &pos, float angleTolerance ) const
+{
+	// forced to do this since many methods in CBaseEntity are not const, but should be
+	CBot< T > *me = const_cast< CBot< T > * >( this );
+
+	Vector to = pos - me->EyePosition();
+
+	QAngle idealAngles;
+	VectorAngles( to, idealAngles );
+
+	QAngle viewAngles = me->EyeAngles();
+
+	float deltaYaw = AngleNormalize( idealAngles.y - viewAngles.y );
+	float deltaPitch = AngleNormalize( idealAngles.x - viewAngles.x );
+
+	if (fabs( deltaYaw ) < angleTolerance && abs( deltaPitch ) < angleTolerance)
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline CBot< PlayerType >::CBot( void )
+{
+	// the profile will be attached after this instance is constructed
+	m_profile = NULL;
+
+	// assign this bot a unique ID
+	static unsigned int nextID = 1;
+
+	// wraparound (highly unlikely)
+	if (nextID == 0)
+		++nextID;
+
+	m_id = nextID;
+	++nextID;
+
+	m_postureStackIndex = 0;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline CBot< PlayerType >::~CBot( void )
+{
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Prepare bot for action
+ */
+template < class PlayerType >
+inline bool CBot< PlayerType >::Initialize( const BotProfile *profile, int team )
+{
+	m_profile = profile;
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::Spawn( void )
+{
+	// initialize the bot (thus setting its profile)
+	if (m_profile == NULL)
+		Initialize( g_botInitProfile, g_botInitTeam );
+
+	// let the base class set some things up
+	PlayerType::Spawn();
+
+	// Make sure everyone knows we are a bot
+	this->AddFlag( FL_CLIENT | FL_FAKECLIENT );
+
+	// Bots use their own thinking mechanism
+	this->SetThink( NULL );
+
+	m_isRunning = true;
+	m_isCrouching = false;
+	m_postureStackIndex = 0;
+
+	m_jumpTimestamp = 0.0f;
+
+	// Command interface variable initialization
+	ResetCommand();
+}
+
+
+/*
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::BotThink( void )
+{
+float g_flBotFullThinkInterval	= 1.0 / 15.0;	// full AI at lower frequency (was 10 in GoldSrc)
+	
+	
+	Upkeep();
+
+	if (gpGlobals->curtime >= m_flNextFullBotThink)
+	{
+		m_flNextFullBotThink = gpGlobals->curtime + g_flBotFullThinkInterval;
+
+		ResetCommand();
+		Update();
+	}
+
+	UpdatePlayer();
+}
+*/
+
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::MoveForward( void )
+{
+	m_forwardSpeed = GetMoveSpeed();
+	SETBITS( m_buttonFlags, IN_FORWARD );
+
+	// make mutually exclusive
+	CLEARBITS( m_buttonFlags, IN_BACK );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::MoveBackward( void )
+{
+	m_forwardSpeed = -GetMoveSpeed();
+	SETBITS( m_buttonFlags, IN_BACK );
+
+	// make mutually exclusive
+	CLEARBITS( m_buttonFlags, IN_FORWARD );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::StrafeLeft( void )
+{
+	m_strafeSpeed = -GetMoveSpeed();
+	SETBITS( m_buttonFlags, IN_MOVELEFT );
+
+	// make mutually exclusive
+	CLEARBITS( m_buttonFlags, IN_MOVERIGHT );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::StrafeRight( void )
+{
+	m_strafeSpeed = GetMoveSpeed();
+	SETBITS( m_buttonFlags, IN_MOVERIGHT );
+
+	// make mutually exclusive
+	CLEARBITS( m_buttonFlags, IN_MOVELEFT );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline bool CBot< PlayerType >::Jump( bool mustJump )
+{
+	if (IsJumping() || IsCrouching())
+		return false;
+
+	if (!mustJump)
+	{
+		const float minJumpInterval = 0.9f; // 1.5f;
+		if (gpGlobals->curtime - m_jumpTimestamp < minJumpInterval)
+			return false;
+	}
+
+	// still need sanity check for jumping frequency
+	const float sanityInterval = 0.3f;
+	if (gpGlobals->curtime - m_jumpTimestamp < sanityInterval)
+		return false;
+
+	// jump
+	SETBITS( m_buttonFlags, IN_JUMP );
+	m_jumpTimestamp = gpGlobals->curtime;
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Zero any MoveForward(), Jump(), etc
+ */
+template < class PlayerType >
+void CBot< PlayerType >::ClearMovement( void )
+{
+	m_forwardSpeed = 0.0;
+	m_strafeSpeed = 0.0;
+	m_verticalSpeed	= 100.0; // stay at the top of water, so we don't drown.  TODO: swim logic
+	m_buttonFlags &= ~(IN_FORWARD | IN_BACK | IN_LEFT | IN_RIGHT | IN_JUMP);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if we are in the midst of a jump
+ */
+template < class PlayerType >
+inline bool CBot< PlayerType >::IsJumping( void )
+{
+	// if long time after last jump, we can't be jumping
+	if (gpGlobals->curtime - m_jumpTimestamp > 3.0f)
+		return false;
+
+	// if we just jumped, we're still jumping
+	if (gpGlobals->curtime - m_jumpTimestamp < 0.9f) // 1.0f
+		return true;
+
+	// a little after our jump, we're jumping until we hit the ground
+	if (FBitSet( this->GetFlags(), FL_ONGROUND ))
+		return false;
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::Crouch( void )
+{
+	m_isCrouching = true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::StandUp( void )
+{
+	m_isCrouching = false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::UseEnvironment( void )
+{
+	SETBITS( m_buttonFlags, IN_USE );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::PrimaryAttack( void )
+{
+	SETBITS( m_buttonFlags, IN_ATTACK );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::ClearPrimaryAttack( void )
+{
+	CLEARBITS( m_buttonFlags, IN_ATTACK );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::TogglePrimaryAttack( void )
+{
+	if (FBitSet( m_buttonFlags, IN_ATTACK ))
+	{
+		CLEARBITS( m_buttonFlags, IN_ATTACK );
+	}
+	else
+	{
+		SETBITS( m_buttonFlags, IN_ATTACK );
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::SecondaryAttack( void )
+{
+	SETBITS( m_buttonFlags, IN_ATTACK2 );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::Reload( void )
+{
+	SETBITS( m_buttonFlags, IN_RELOAD );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns ratio of ammo left to max ammo (1 = full clip, 0 = empty)
+ */
+template < class PlayerType >
+inline float CBot< PlayerType >::GetActiveWeaponAmmoRatio( void ) const
+{
+	CWeaponCSBase *weapon = this->GetActiveCSWeapon();
+
+	if (weapon == NULL)
+		return 0.0f;
+
+	// weapons with no ammo are always full
+	if (weapon->Clip1() < 0)
+		return 1.0f;
+
+	return (float)weapon->Clip1() / (float)weapon->GetMaxClip1();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if active weapon has an empty clip
+ */
+template < class PlayerType >
+inline bool CBot< PlayerType >::IsActiveWeaponClipEmpty( void ) const
+{
+	CWeaponCSBase *gun = this->GetActiveCSWeapon();
+
+	if (gun && gun->Clip1() == 0)
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if active weapon has no ammo at all
+ */
+template < class PlayerType >
+inline bool CBot< PlayerType >::IsActiveWeaponOutOfAmmo( void ) const
+{
+	CWeaponCSBase *weapon = this->GetActiveCSWeapon();
+
+	if (weapon == NULL)
+		return true;
+
+	return !weapon->HasAnyAmmo();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if looking thru weapon's scope
+ */
+template < class PlayerType >
+inline bool CBot< PlayerType >::IsUsingScope( void )
+{
+	// if our field of view is less than 90, we're looking thru a scope (maybe only true for CS...)
+	if (this->GetFOV() < this->GetDefaultFOV())
+		return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Fill in a CUserCmd with our data
+ */
+template < class PlayerType >
+inline void CBot< PlayerType >::BuildUserCmd( CUserCmd& cmd, const QAngle& viewangles, float forwardmove, float sidemove, float upmove, int buttons, byte impulse )
+{
+	Q_memset( &cmd, 0, sizeof( cmd ) );
+	cmd.command_number = gpGlobals->tickcount;
+	cmd.forwardmove = forwardmove;
+	cmd.sidemove = sidemove;
+	cmd.upmove = upmove;
+	cmd.buttons = buttons;
+	cmd.impulse = impulse;
+
+	VectorCopy( viewangles, cmd.viewangles );
+	cmd.random_seed = random->RandomInt( 0, 0x7fffffff );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Update player physics, movement, weapon firing commands, etc
+ */
+template < class PlayerType >
+inline void CBot< PlayerType >::UpdatePlayer( void )
+{
+	if (m_isCrouching)
+	{
+		SETBITS( m_buttonFlags, IN_DUCK );
+	}
+	else if (!m_isRunning)
+	{
+		SETBITS( m_buttonFlags, IN_SPEED );
+	}
+
+	if ( this->IsEFlagSet(EFL_BOT_FROZEN) )
+	{
+		m_buttonFlags = 0; // Freeze.
+		m_forwardSpeed = 0;
+		m_strafeSpeed = 0;
+		m_verticalSpeed = 0;
+	}
+
+	// Fill in a CUserCmd with our data
+	this->BuildUserCmd( m_userCmd, this->EyeAngles(), m_forwardSpeed, m_strafeSpeed, m_verticalSpeed, m_buttonFlags, 0 );
+
+	// Save off the CUserCmd to execute later
+	this->ProcessUsercmds( &m_userCmd, 1, 1, 0, false );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+template < class PlayerType >
+inline void CBot< PlayerType >::ResetCommand( void )
+{
+	m_forwardSpeed = 0.0;
+	m_strafeSpeed = 0.0;
+	m_verticalSpeed	= 100.0; // stay at the top of water, so we don't drown.  TODO: swim logic
+	m_buttonFlags = 0;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/*
+template < class PlayerType >
+inline byte CBot< PlayerType >::ThrottledMsec( void ) const
+{
+	int iNewMsec;
+
+	// Estimate Msec to use for this command based on time passed from the previous command
+	iNewMsec = (int)( (gpGlobals->curtime - m_flPreviousCommandTime) * 1000 );
+	if (iNewMsec > 255)		// Doh, bots are going to be slower than they should if this happens.
+		iNewMsec = 255;		// Upgrade that CPU or use less bots!
+
+	return (byte)iNewMsec;
+}
+*/
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Do a "client command" - useful for invoking menu choices, etc.
+ */
+template < class PlayerType >
+inline bool CBot< PlayerType >::ClientCommand( const CCommand &args )
+{
+	// Remove old args
+	int i;
+	for ( i=0; i<m_args.Count(); ++i )
+	{
+		delete[] m_args[i];
+	}
+	m_args.RemoveAll();
+
+	// parse individual args
+	const char *cmd = args.GetCommandString();
+	while (1)
+	{
+		// skip whitespace up to a /n
+		while (*cmd && *cmd <= ' ' && *cmd != '\n')
+		{
+			cmd++;
+		}
+		
+		if (*cmd == '\n')
+		{	// a newline seperates commands in the buffer
+			cmd++;
+			break;
+		}
+
+		if (!*cmd)
+			break;
+	
+		cmd = SharedParse (cmd);
+		if (!cmd)
+			break;
+
+		m_args.AddToTail( CloneString( SharedGetToken() ) );
+	}
+
+	// and pass to the base class
+	return PlayerType::ClientCommand( args );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns the number of tokens in the command string
+ */
+template < class PlayerType >
+inline int CBot< PlayerType >::Cmd_Argc()
+{
+	return m_args.Count();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Retrieves a specified token
+ */
+template < class PlayerType >
+inline char * CBot< PlayerType >::Cmd_Argv( int argc )
+{
+	if ( argc < 0 || argc >= m_args.Count() )
+		return NULL;
+	return m_args[argc];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Returns TRUE if given entity is our enemy
+ */
+template < class PlayerType >
+inline bool CBot< PlayerType >::IsEnemy( CBaseEntity *ent ) const
+{
+	// only Players (real and AI) can be enemies
+	if (!ent->IsPlayer())
+		return false;
+
+	// corpses are no threat
+	if (!ent->IsAlive())
+		return false;	
+
+	CBasePlayer *player = static_cast<CBasePlayer *>( ent );
+
+	// if they are on our team, they are our friends
+	if (player->GetTeamNumber() == this->GetTeamNumber())
+		return false;
+
+	// yep, we hate 'em
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return number of enemies left alive
+ */
+template < class PlayerType >
+inline int CBot< PlayerType >::GetEnemiesRemaining( void ) const
+{
+	int count = 0;
+
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBaseEntity *player = UTIL_PlayerByIndex( i );
+
+		if (player == NULL)
+			continue;
+
+		if (!IsEnemy( player ))
+			continue;
+
+		if (!player->IsAlive())
+			continue;
+
+		count++;
+	}
+
+	return count;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return number of friends left alive
+ */
+template < class PlayerType >
+inline int CBot< PlayerType >::GetFriendsRemaining( void ) const
+{
+	int count = 0;
+
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBaseEntity *player = UTIL_PlayerByIndex( i );
+
+		if (player == NULL)
+			continue;
+
+		if (IsEnemy( player ))
+			continue;
+
+		if (!player->IsAlive())
+			continue;
+
+		if (player == static_cast<CBaseEntity *>( const_cast<CBot *>( this ) ))
+			continue;
+
+		count++;
+	}
+
+	return count;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if the local player is currently in observer mode watching this bot.
+ */
+template < class PlayerType >
+inline bool CBot< PlayerType >::IsLocalPlayerWatchingMe( void ) const
+{
+	if ( engine->IsDedicatedServer() )
+		return false;
+
+	CBasePlayer *player = UTIL_GetListenServerHost();
+	if ( player == NULL )
+		return false;
+
+	if ( cv_bot_debug_target.GetInt() > 0 )
+	{
+		return this->entindex() == cv_bot_debug_target.GetInt();
+	}
+
+	if ( player->IsObserver() || !player->IsAlive() )
+	{
+		if ( const_cast< CBot< PlayerType > * >(this) == player->GetObserverTarget() )
+		{
+			switch( player->GetObserverMode() )
+			{
+				case OBS_MODE_IN_EYE:
+				case OBS_MODE_CHASE:
+					return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Output message to console if we are being watched by the local player
+ */
+template < class PlayerType >
+inline void CBot< PlayerType >::PrintIfWatched( PRINTF_FORMAT_STRING const char *format, ... ) const
+{
+	if (cv_bot_debug.GetInt() == 0)
+	{
+		return;
+	}
+
+	if ((IsLocalPlayerWatchingMe() && (cv_bot_debug.GetInt() == 1 || cv_bot_debug.GetInt() == 3)) ||
+		(cv_bot_debug.GetInt() == 2 || cv_bot_debug.GetInt() == 4))
+	{
+		va_list varg;
+		char buffer[ CBotManager::MAX_DBG_MSG_SIZE ];
+		const char *name = const_cast< CBot< PlayerType > * >( this )->GetPlayerName();
+
+		va_start( varg, format );
+		vsprintf( buffer, format, varg );
+		va_end( varg );
+
+		// prefix the console message with the bot's name (this can be NULL if bot was just added)
+		ClientPrint( UTIL_GetListenServerHost(),
+			HUD_PRINTCONSOLE,
+			UTIL_VarArgs( "%s: %s",
+			(name) ? name : "(NULL netname)", buffer ) );
+
+		TheBots->AddDebugMessage( buffer );
+	}
+}
+
+//-----------------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------------------------------------
+
+extern void InstallBotControl( void );
+extern void RemoveBotControl( void );
+extern void Bot_ServerCommand( void );
+extern void Bot_RegisterCvars( void );
+
+extern bool IsSpotOccupied( CBaseEntity *me, const Vector &pos );	// if a player is at the given spot, return true
+extern const Vector *FindNearbyHidingSpot( CBaseEntity *me, const Vector &pos, float maxRange = 1000.0f, bool isSniper = false, bool useNearest = false );
+extern const Vector *FindRandomHidingSpot( CBaseEntity *me, Place place, bool isSniper = false );
+extern const Vector *FindNearbyRetreatSpot( CBaseEntity *me, const Vector &start, float maxRange = 1000.0f, int avoidTeam = 0 );
+
+
+#endif // BOT_H
diff --git a/game/shared/cstrike/bot/bot_constants.h b/game/shared/cstrike/bot/bot_constants.h
new file mode 100644
index 00000000..94f50909
--- /dev/null
+++ b/game/shared/cstrike/bot/bot_constants.h
@@ -0,0 +1,40 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Matthew D. Campbell (matt@turtlerockstudios.com), 2003
+
+#ifndef BOT_CONSTANTS_H
+#define BOT_CONSTANTS_H
+
+/// version number is MAJOR.MINOR
+#define BOT_VERSION_MAJOR			1
+#define BOT_VERSION_MINOR			50
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Difficulty levels
+ */
+enum BotDifficultyType
+{
+	BOT_EASY = 0,
+	BOT_NORMAL = 1,
+	BOT_HARD = 2,
+	BOT_EXPERT = 3,
+
+	NUM_DIFFICULTY_LEVELS
+};
+
+#ifdef DEFINE_DIFFICULTY_NAMES
+	const char *BotDifficultyName[] = 
+	{
+		"EASY", "NORMAL", "HARD", "EXPERT", NULL
+	};
+#else
+	extern const char *BotDifficultyName[];
+#endif
+
+#endif // BOT_CONSTANTS_H
diff --git a/game/shared/cstrike/bot/bot_hide.cpp b/game/shared/cstrike/bot/bot_hide.cpp
new file mode 100644
index 00000000..9a2b02c0
--- /dev/null
+++ b/game/shared/cstrike/bot/bot_hide.cpp
@@ -0,0 +1,490 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// bot_hide.cpp
+// Mechanisms for using Hiding Spots in the Navigation Mesh
+// Author: Michael Booth, 2003-2004
+
+#include "cbase.h"
+#include "bot.h"
+#include "cs_nav_pathfind.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * If a player is at the given spot, return true
+ */
+bool IsSpotOccupied( CBaseEntity *me, const Vector &pos )
+{
+	const float closeRange = 75.0f;		// 50
+
+	// is there a player in this spot
+	float range;
+	CBasePlayer *player = UTIL_GetClosestPlayer( pos, &range );
+
+	if (player != me)
+	{
+		if (player && range < closeRange)
+			return true;
+	}
+
+	// is there is a hostage in this spot
+	// BOTPORT: Implement hostage manager
+	/*
+	if (g_pHostages)
+	{
+		CHostage *hostage = g_pHostages->GetClosestHostage( *pos, &range );
+		if (hostage && hostage != me && range < closeRange)
+			return true;
+	}
+	*/
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+class CollectHidingSpotsFunctor
+{
+public:
+	CollectHidingSpotsFunctor( CBaseEntity *me, const Vector &origin, float range, int flags, Place place = UNDEFINED_PLACE ) : m_origin( origin )
+	{
+		m_me = me;
+		m_count = 0;
+		m_range = range;
+		m_flags = (unsigned char)flags;
+		m_place = place;
+		m_totalWeight = 0;
+	}
+
+	enum { MAX_SPOTS = 256 };
+
+	bool operator() ( CNavArea *area )
+	{
+		// if a place is specified, only consider hiding spots from areas in that place
+		if (m_place != UNDEFINED_PLACE && area->GetPlace() != m_place)
+			return true;
+
+		// collect all the hiding spots in this area
+		const HidingSpotVector *pSpots = area->GetHidingSpots();
+		
+		FOR_EACH_VEC( (*pSpots), it )
+		{
+			const HidingSpot *spot = (*pSpots)[ it ];
+
+			// if we've filled up, stop searching
+			if (m_count == MAX_SPOTS)
+			{
+				return false;
+			}
+
+			// make sure hiding spot is in range
+			if (m_range > 0.0f)
+			{
+				if ((spot->GetPosition() - m_origin).IsLengthGreaterThan( m_range ))
+				{
+					continue;
+				}
+			}
+
+			// if a Player is using this hiding spot, don't consider it
+			if (IsSpotOccupied( m_me, spot->GetPosition() ))
+			{
+				// player is in hiding spot
+				/// @todo Check if player is moving or sitting still
+				continue;
+			}
+
+			if (spot->GetArea() && (spot->GetArea()->GetAttributes() & NAV_MESH_DONT_HIDE))
+			{
+				// the area has been marked as DONT_HIDE since the last analysis, so let's ignore it
+				continue;
+			}
+
+			// only collect hiding spots with matching flags
+			if (m_flags & spot->GetFlags())
+			{
+				m_hidingSpot[ m_count ] = &spot->GetPosition();
+				m_hidingSpotWeight[ m_count ] = m_totalWeight;
+
+				// if it's an 'avoid' area, give it a low weight
+				if ( spot->GetArea() && ( spot->GetArea()->GetAttributes() & NAV_MESH_AVOID ) )
+				{
+					m_totalWeight += 1;
+				}
+				else
+				{
+					m_totalWeight += 2;
+				}
+
+				++m_count;
+			}
+		}
+
+		return (m_count < MAX_SPOTS);
+	}
+
+	/**
+	 * Remove the spot at index "i"
+	 */
+	void RemoveSpot( int i )
+	{
+		if (m_count == 0)
+			return;
+
+		for( int j=i+1; j<m_count; ++j )
+			m_hidingSpot[j-1] = m_hidingSpot[j];
+
+		--m_count;
+	}
+
+
+	int GetRandomHidingSpot( void )
+	{
+		int weight = RandomInt( 0, m_totalWeight-1 );
+		for ( int i=0; i<m_count-1; ++i )
+		{
+			// if the next spot's starting weight is over the target weight, this spot is the one
+			if ( m_hidingSpotWeight[i+1] >= weight )
+			{
+				return i;
+			}
+		}
+
+		// if we didn't find any, it's the last one
+		return m_count - 1;
+	}
+
+	CBaseEntity *m_me;
+	const Vector &m_origin;
+	float m_range;
+
+	const Vector *m_hidingSpot[ MAX_SPOTS ];
+	int m_hidingSpotWeight[ MAX_SPOTS ];
+	int m_totalWeight;
+	int m_count;
+
+	unsigned char m_flags;
+
+	Place m_place;
+};
+
+/**
+ * Do a breadth-first search to find a nearby hiding spot and return it.
+ * Don't pick a hiding spot that a Player is currently occupying.
+ * @todo Clean up this mess
+ */
+const Vector *FindNearbyHidingSpot( CBaseEntity *me, const Vector &pos, float maxRange, bool isSniper, bool useNearest )
+{
+	CNavArea *startArea = TheNavMesh->GetNearestNavArea( pos );
+	if (startArea == NULL)
+		return NULL;
+
+	// collect set of nearby hiding spots
+	if (isSniper)
+	{
+		CollectHidingSpotsFunctor collector( me, pos, maxRange, HidingSpot::IDEAL_SNIPER_SPOT );
+		SearchSurroundingAreas( startArea, pos, collector, maxRange );
+
+		if (collector.m_count)
+		{
+			int which = collector.GetRandomHidingSpot();
+			return collector.m_hidingSpot[ which ];
+		}
+		else
+		{
+			// no ideal sniping spots, look for "good" sniping spots
+			CollectHidingSpotsFunctor collector( me, pos, maxRange, HidingSpot::GOOD_SNIPER_SPOT );
+			SearchSurroundingAreas( startArea, pos, collector, maxRange );
+
+			if (collector.m_count)
+			{
+				int which = collector.GetRandomHidingSpot();
+				return collector.m_hidingSpot[ which ];
+			}
+
+			// no sniping spots at all.. fall through and pick a normal hiding spot
+		}
+	}
+
+	// collect hiding spots with decent "cover"
+	CollectHidingSpotsFunctor collector( me, pos, maxRange, HidingSpot::IN_COVER );
+	SearchSurroundingAreas( startArea, pos, collector, maxRange );
+
+	if (collector.m_count == 0)
+	{
+		// no hiding spots at all - if we're not a sniper, try to find a sniper spot to use instead
+		if (!isSniper)
+		{
+			return FindNearbyHidingSpot( me, pos, maxRange, true, useNearest );
+		}
+
+		return NULL;
+	}
+
+	if (useNearest)
+	{
+		// return closest hiding spot
+		const Vector *closest = NULL;
+		float closeRangeSq = 9999999999.9f;
+		for( int i=0; i<collector.m_count; ++i )
+		{
+			float rangeSq = (*collector.m_hidingSpot[i] - pos).LengthSqr();
+			if (rangeSq < closeRangeSq)
+			{
+				closeRangeSq = rangeSq;
+				closest = collector.m_hidingSpot[i];
+			}
+		}
+
+		return closest;
+	}
+
+	// select a hiding spot at random
+	int which = collector.GetRandomHidingSpot();
+	return collector.m_hidingSpot[ which ];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Select a random hiding spot among the nav areas that are tagged with the given place
+ */
+const Vector *FindRandomHidingSpot( CBaseEntity *me, Place place, bool isSniper )
+{
+	// collect set of nearby hiding spots
+	if (isSniper)
+	{
+		CollectHidingSpotsFunctor collector( me, me->GetAbsOrigin(), -1.0f, HidingSpot::IDEAL_SNIPER_SPOT, place );
+		TheNavMesh->ForAllAreas( collector );
+
+		if (collector.m_count)
+		{
+			int which = RandomInt( 0, collector.m_count-1 );
+			return collector.m_hidingSpot[ which ];
+		}
+		else
+		{
+			// no ideal sniping spots, look for "good" sniping spots
+			CollectHidingSpotsFunctor collector( me, me->GetAbsOrigin(), -1.0f, HidingSpot::GOOD_SNIPER_SPOT, place );
+			TheNavMesh->ForAllAreas( collector );
+
+			if (collector.m_count)
+			{
+				int which = RandomInt( 0, collector.m_count-1 );
+				return collector.m_hidingSpot[ which ];
+			}
+
+			// no sniping spots at all.. fall through and pick a normal hiding spot
+		}
+	}
+
+	// collect hiding spots with decent "cover"
+	CollectHidingSpotsFunctor collector( me, me->GetAbsOrigin(), -1.0f, HidingSpot::IN_COVER, place );
+	TheNavMesh->ForAllAreas( collector );
+
+	if (collector.m_count == 0)
+		return NULL;
+
+	// select a hiding spot at random
+	int which = RandomInt( 0, collector.m_count-1 );
+	return collector.m_hidingSpot[ which ];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------------
+/**
+ * Select a nearby retreat spot.
+ * Don't pick a hiding spot that a Player is currently occupying.
+ * If "avoidTeam" is nonzero, avoid getting close to members of that team.
+ */
+const Vector *FindNearbyRetreatSpot( CBaseEntity *me, const Vector &start, float maxRange, int avoidTeam )
+{
+	CNavArea *startArea = TheNavMesh->GetNearestNavArea( start );
+	if (startArea == NULL)
+		return NULL;
+
+	// collect hiding spots with decent "cover"
+	CollectHidingSpotsFunctor collector( me, start, maxRange, HidingSpot::IN_COVER );
+	SearchSurroundingAreas( startArea, start, collector, maxRange );
+
+	if (collector.m_count == 0)
+		return NULL;
+
+	// find the closest unoccupied hiding spot that crosses the least lines of fire and has the best cover
+	for( int i=0; i<collector.m_count; ++i )
+	{
+		// check if we would have to cross a line of fire to reach this hiding spot
+		if (IsCrossingLineOfFire( start, *collector.m_hidingSpot[i], me ))
+		{
+			collector.RemoveSpot( i );
+
+			// back up a step, so iteration won't skip a spot
+			--i;
+
+			continue;
+		}
+
+		// check if there is someone on the avoidTeam near this hiding spot
+		if (avoidTeam)
+		{
+			float range;
+			if (UTIL_GetClosestPlayer( *collector.m_hidingSpot[i], avoidTeam, &range ))
+			{
+				const float dangerRange = 150.0f;
+				if (range < dangerRange)
+				{
+					// there is an avoidable player too near this spot - remove it
+					collector.RemoveSpot( i );
+
+					// back up a step, so iteration won't skip a spot
+					--i;
+
+					continue;
+				}
+			}
+		}
+	}
+
+	if (collector.m_count <= 0)
+		return NULL;
+
+	// all remaining spots are ok - pick one at random
+	int which = RandomInt( 0, collector.m_count-1 );
+	return collector.m_hidingSpot[ which ];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------------
+/**
+ * Functor to collect all hiding spots in range that we can reach before the enemy arrives.
+ * NOTE: This only works for the initial rush.
+ */
+class CollectArriveFirstSpotsFunctor
+{
+public:
+	CollectArriveFirstSpotsFunctor( CBaseEntity *me, const Vector &searchOrigin, float enemyArriveTime, float range, int flags ) : m_searchOrigin( searchOrigin )
+	{
+		m_me = me;
+		m_count = 0;
+		m_range = range;
+		m_flags = (unsigned char)flags;
+		m_enemyArriveTime = enemyArriveTime;
+	}
+
+	enum { MAX_SPOTS = 256 };
+
+	bool operator() ( CNavArea *area )
+	{
+		// collect all the hiding spots in this area
+		const HidingSpotVector *pSpots = area->GetHidingSpots();
+		
+		FOR_EACH_VEC( (*pSpots), it )
+		{
+			const HidingSpot *spot = (*pSpots)[ it ];
+
+			// make sure hiding spot is in range
+			if (m_range > 0.0f)
+			{
+				if ((spot->GetPosition() - m_searchOrigin).IsLengthGreaterThan( m_range ))
+				{
+					continue;
+				}
+			}
+
+			// if a Player is using this hiding spot, don't consider it
+			if (IsSpotOccupied( m_me, spot->GetPosition() ))
+			{
+				// player is in hiding spot
+				/// @todo Check if player is moving or sitting still
+				continue;
+			}
+
+			// only collect hiding spots with matching flags
+			if (!(m_flags & spot->GetFlags()))
+			{
+				continue;
+			}
+
+			// only collect this hiding spot if we can reach it before the enemy arrives
+			// NOTE: This assumes the area is fairly small and the difference of moving to the corner vs the center is small
+			const float settleTime = 1.0f;
+			if (spot->GetArea()->GetEarliestOccupyTime( m_me->GetTeamNumber() ) + settleTime < m_enemyArriveTime)
+			{
+				m_hidingSpot[ m_count++ ] = spot;
+			}
+		}
+
+		// if we've filled up, stop searching
+		if (m_count == MAX_SPOTS)
+			return false;
+
+		return true;
+	}
+
+	CBaseEntity *m_me;
+	const Vector &m_searchOrigin;
+
+	float m_range;
+	float m_enemyArriveTime;
+	unsigned char m_flags;
+
+	const HidingSpot *m_hidingSpot[ MAX_SPOTS ];
+	int m_count;
+};
+
+
+/**
+ * Select a hiding spot that we can reach before the enemy arrives.
+ * NOTE: This only works for the initial rush.
+ */
+const HidingSpot *FindInitialEncounterSpot( CBaseEntity *me, const Vector &searchOrigin, float enemyArriveTime, float maxRange, bool isSniper )
+{
+	CNavArea *startArea = TheNavMesh->GetNearestNavArea( searchOrigin );
+	if (startArea == NULL)
+		return NULL;
+
+	// collect set of nearby hiding spots
+	if (isSniper)
+	{
+		CollectArriveFirstSpotsFunctor collector( me, searchOrigin, enemyArriveTime, maxRange, HidingSpot::IDEAL_SNIPER_SPOT );
+		SearchSurroundingAreas( startArea, searchOrigin, collector, maxRange );
+
+		if (collector.m_count)
+		{
+			int which = RandomInt( 0, collector.m_count-1 );
+			return collector.m_hidingSpot[ which ];
+		}
+		else
+		{
+			// no ideal sniping spots, look for "good" sniping spots
+			CollectArriveFirstSpotsFunctor collector( me, searchOrigin, enemyArriveTime, maxRange, HidingSpot::GOOD_SNIPER_SPOT );
+			SearchSurroundingAreas( startArea, searchOrigin, collector, maxRange );
+
+			if (collector.m_count)
+			{
+				int which = RandomInt( 0, collector.m_count-1 );
+				return collector.m_hidingSpot[ which ];
+			}
+
+			// no sniping spots at all.. fall through and pick a normal hiding spot
+		}
+	}
+
+	// collect hiding spots with decent "cover"
+	CollectArriveFirstSpotsFunctor collector( me, searchOrigin, enemyArriveTime, maxRange, HidingSpot::IN_COVER | HidingSpot::EXPOSED );
+	SearchSurroundingAreas( startArea, searchOrigin, collector, maxRange );
+
+	if (collector.m_count == 0)
+		return NULL;
+
+	// select a hiding spot at random
+	int which = RandomInt( 0, collector.m_count-1 );
+	return collector.m_hidingSpot[ which ];
+}
+
diff --git a/game/shared/cstrike/bot/bot_manager.cpp b/game/shared/cstrike/bot/bot_manager.cpp
new file mode 100644
index 00000000..ce158231
--- /dev/null
+++ b/game/shared/cstrike/bot/bot_manager.cpp
@@ -0,0 +1,402 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+
+#include "bot.h"
+#include "bot_manager.h"
+#include "nav_area.h"
+#include "bot_util.h"
+#include "basegrenade_shared.h"
+
+#include "cs_bot.h"
+
+#include "tier0/vprof.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+float g_BotUpkeepInterval = 0.0f;
+float g_BotUpdateInterval = 0.0f;
+
+
+//--------------------------------------------------------------------------------------------------------------
+CBotManager::CBotManager()
+{
+	InitBotTrig();
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+CBotManager::~CBotManager()
+{
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked when the round is restarting
+ */
+void CBotManager::RestartRound( void )
+{
+	DestroyAllGrenades();
+	ClearDebugMessages();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Invoked at the start of each frame
+ */
+void CBotManager::StartFrame( void )
+{
+	VPROF_BUDGET( "CBotManager::StartFrame", VPROF_BUDGETGROUP_NPCS );
+
+	ValidateActiveGrenades();
+
+	// debug smoke grenade visualization
+	if (cv_bot_debug.GetInt() == 5)
+	{
+		Vector edge, lastEdge;
+
+		FOR_EACH_LL( m_activeGrenadeList, it )
+		{
+			ActiveGrenade *ag = m_activeGrenadeList[ it ];
+
+			const Vector &pos = ag->GetDetonationPosition();
+
+			UTIL_DrawBeamPoints( pos, pos + Vector( 0, 0, 50 ), 1, 255, 100, 0 );
+
+			lastEdge = Vector( ag->GetRadius() + pos.x, pos.y, pos.z );
+			float angle;
+			for( angle=0.0f; angle <= 180.0f; angle += 22.5f )
+			{
+				edge.x = ag->GetRadius() * BotCOS( angle ) + pos.x;
+				edge.y = pos.y;
+				edge.z = ag->GetRadius() * BotSIN( angle ) + pos.z;
+
+				UTIL_DrawBeamPoints( edge, lastEdge, 1, 255, 50, 0 );
+
+				lastEdge = edge;
+			}
+
+			lastEdge = Vector( pos.x, ag->GetRadius() + pos.y, pos.z );
+			for( angle=0.0f; angle <= 180.0f; angle += 22.5f )
+			{
+				edge.x = pos.x;
+				edge.y = ag->GetRadius() * BotCOS( angle ) + pos.y;
+				edge.z = ag->GetRadius() * BotSIN( angle ) + pos.z;
+
+				UTIL_DrawBeamPoints( edge, lastEdge, 1, 255, 50, 0 );
+
+				lastEdge = edge;
+			}
+		}
+	}
+
+	// set frame duration
+	g_BotUpkeepInterval = m_frameTimer.GetElapsedTime();
+	m_frameTimer.Start();
+
+	g_BotUpdateInterval = (g_BotUpdateSkipCount+1) * g_BotUpkeepInterval;
+
+	//
+	// Process each active bot
+	//
+	for( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (!player)
+			continue;
+
+		// Hack for now so the temp bot code works. The temp bots are very useful for debugging
+		// because they can be setup to mimic the player's usercmds.
+		if (player->IsBot() && IsEntityValid( player ) )
+		{
+			// EVIL: Messes up vtables
+			//CBot< CBasePlayer > *bot = static_cast< CBot< CBasePlayer > * >( player );
+			CCSBot *bot = dynamic_cast< CCSBot * >( player );
+
+			if ( bot )
+			{
+				bot->Upkeep();
+
+				if (((gpGlobals->tickcount + bot->entindex()) % g_BotUpdateSkipCount) == 0)
+				{
+					bot->ResetCommand();
+					bot->Update();
+				}
+
+				bot->UpdatePlayer();
+			}
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Add an active grenade to the bot's awareness
+ */
+void CBotManager::AddGrenade( CBaseGrenade *grenade )
+{
+	ActiveGrenade *ag = new ActiveGrenade( grenade );
+	m_activeGrenadeList.AddToTail( ag );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * The grenade entity in the world is going away
+ */
+void CBotManager::RemoveGrenade( CBaseGrenade *grenade )
+{
+	FOR_EACH_LL( m_activeGrenadeList, it )
+	{
+		ActiveGrenade *ag = m_activeGrenadeList[ it ];
+
+		if (ag->IsEntity( grenade ))
+		{
+			ag->OnEntityGone();
+			return;
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * The grenade entity has changed its radius
+ */
+void CBotManager::SetGrenadeRadius( CBaseGrenade *grenade, float radius )
+{
+	FOR_EACH_LL( m_activeGrenadeList, it )
+	{
+		ActiveGrenade *ag = m_activeGrenadeList[ it ];
+
+		if (ag->IsEntity( grenade ))
+		{
+			ag->SetRadius( radius );
+			return;
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Destroy any invalid active grenades
+ */
+void CBotManager::ValidateActiveGrenades( void )
+{
+	int it = m_activeGrenadeList.Head();
+
+	while( it != m_activeGrenadeList.InvalidIndex() )
+	{
+		ActiveGrenade *ag = m_activeGrenadeList[ it ];
+
+		int current = it;
+		it = m_activeGrenadeList.Next( it );
+
+		// lazy validation
+		if (!ag->IsValid())
+		{
+			m_activeGrenadeList.Remove( current );
+			delete ag;
+			continue;
+		}
+		else
+		{
+			ag->Update();
+		}
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+void CBotManager::DestroyAllGrenades( void )
+{
+	m_activeGrenadeList.PurgeAndDeleteElements();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if position is inside a smoke cloud
+ */
+bool CBotManager::IsInsideSmokeCloud( const Vector *pos )
+{
+	int it = m_activeGrenadeList.Head();
+
+	while( it != m_activeGrenadeList.InvalidIndex() )
+	{
+		ActiveGrenade *ag = m_activeGrenadeList[ it ];
+
+		int current = it;
+		it = m_activeGrenadeList.Next( it );
+
+		// lazy validation
+		if (!ag->IsValid())
+		{
+			m_activeGrenadeList.Remove( current );
+			delete ag;
+			continue;
+		}
+
+		if (ag->IsSmoke())
+		{
+			const Vector &smokeOrigin = ag->GetDetonationPosition();
+
+			if ((smokeOrigin - *pos).IsLengthLessThan( ag->GetRadius() ))
+				return true;			
+		}
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if line intersects smoke volume
+ * Determine the length of the line of sight covered by each smoke cloud, 
+ * and sum them (overlap is additive for obstruction).
+ * If the overlap exceeds the threshold, the bot can't see through.
+ */
+bool CBotManager::IsLineBlockedBySmoke( const Vector &from, const Vector &to, float grenadeBloat )
+{
+	VPROF_BUDGET( "CBotManager::IsLineBlockedBySmoke", VPROF_BUDGETGROUP_NPCS );
+
+	float totalSmokedLength = 0.0f;	// distance along line of sight covered by smoke
+
+	// compute unit vector and length of line of sight segment
+	Vector sightDir = to - from;
+	float sightLength = sightDir.NormalizeInPlace();
+
+	FOR_EACH_LL( m_activeGrenadeList, it )
+	{
+		ActiveGrenade *ag = m_activeGrenadeList[ it ];
+		const float smokeRadiusSq = ag->GetRadius() * ag->GetRadius() * grenadeBloat * grenadeBloat;
+
+		if (ag->IsSmoke())
+		{
+			const Vector &smokeOrigin = ag->GetDetonationPosition();
+
+			Vector toGrenade = smokeOrigin - from;
+
+			float alongDist = DotProduct( toGrenade, sightDir );
+
+			// compute closest point to grenade along line of sight ray
+			Vector close;
+
+			// constrain closest point to line segment
+			if (alongDist < 0.0f)
+				close = from;
+			else if (alongDist >= sightLength)
+				close = to;
+			else
+				close = from + sightDir * alongDist;
+
+			// if closest point is within smoke radius, the line overlaps the smoke cloud
+			Vector toClose = close - smokeOrigin;
+			float lengthSq = toClose.LengthSqr();
+
+			if (lengthSq < smokeRadiusSq)
+			{
+				// some portion of the ray intersects the cloud
+
+				float fromSq = toGrenade.LengthSqr();
+				float toSq = (smokeOrigin - to).LengthSqr();
+
+				if (fromSq < smokeRadiusSq)
+				{
+					if (toSq < smokeRadiusSq)
+					{
+						// both 'from' and 'to' lie within the cloud
+						// entire length is smoked
+						totalSmokedLength += (to - from).Length();
+					}
+					else
+					{
+						// 'from' is inside the cloud, 'to' is outside
+						// compute half of total smoked length as if ray crosses entire cloud chord
+						float halfSmokedLength = (float)sqrt( smokeRadiusSq - lengthSq );
+
+						if (alongDist > 0.0f)
+						{
+							// ray goes thru 'close'
+							totalSmokedLength += halfSmokedLength + (close - from).Length();						
+						}
+						else
+						{
+							// ray starts after 'close'
+							totalSmokedLength += halfSmokedLength - (close - from).Length();						
+						}
+
+					}
+				}
+				else if (toSq < smokeRadiusSq)
+				{
+					// 'from' is outside the cloud, 'to' is inside
+					// compute half of total smoked length as if ray crosses entire cloud chord
+					float halfSmokedLength = (float)sqrt( smokeRadiusSq - lengthSq );
+
+					Vector v = to - smokeOrigin;
+					if (DotProduct( v, sightDir ) > 0.0f)
+					{
+						// ray goes thru 'close'
+						totalSmokedLength += halfSmokedLength + (close - to).Length();					
+					}
+					else
+					{
+						// ray ends before 'close'
+						totalSmokedLength += halfSmokedLength - (close - to).Length();
+					}
+				}
+				else
+				{			
+					// 'from' and 'to' lie outside of the cloud - the line of sight completely crosses it
+					// determine the length of the chord that crosses the cloud
+					float smokedLength = 2.0f * (float)sqrt( smokeRadiusSq - lengthSq );
+
+					totalSmokedLength += smokedLength;
+				}
+			}
+		}
+	}
+
+	// define how much smoke a bot can see thru
+	const float maxSmokedLength = 0.7f * SmokeGrenadeRadius;
+
+	// return true if the total length of smoke-covered line-of-sight is too much
+	return (totalSmokedLength > maxSmokedLength);
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CBotManager::ClearDebugMessages( void )
+{
+	m_debugMessageCount = 0;
+	m_currentDebugMessage = -1;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Add a new debug message to the message history
+ */
+void CBotManager::AddDebugMessage( const char *msg )
+{
+	if (++m_currentDebugMessage >= MAX_DBG_MSGS)
+	{
+		m_currentDebugMessage = 0;
+	}
+
+	if (m_debugMessageCount < MAX_DBG_MSGS)
+	{
+		++m_debugMessageCount;
+	}
+
+	Q_strncpy( m_debugMessage[ m_currentDebugMessage ].m_string, msg, MAX_DBG_MSG_SIZE );
+	m_debugMessage[ m_currentDebugMessage ].m_age.Start();
+}
diff --git a/game/shared/cstrike/bot/bot_manager.h b/game/shared/cstrike/bot/bot_manager.h
new file mode 100644
index 00000000..b7d2bd14
--- /dev/null
+++ b/game/shared/cstrike/bot/bot_manager.h
@@ -0,0 +1,195 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#ifndef BASE_CONTROL_H
+#define BASE_CONTROL_H
+
+#pragma warning( disable : 4530 )					// STL uses exceptions, but we are not compiling with them - ignore warning
+
+extern float g_BotUpkeepInterval;					///< duration between bot upkeeps
+extern float g_BotUpdateInterval;					///< duration between bot updates
+const int g_BotUpdateSkipCount = 2;					///< number of upkeep periods to skip update
+
+class CNavArea;
+
+/// TODO: move CS-specific defines into CSBot files
+enum
+{
+	SmokeGrenadeRadius = 155,
+	FlashbangGrenadeRadius = 115,
+	HEGrenadeRadius = 115,
+};
+
+//--------------------------------------------------------------------------------------------------------------
+class CBaseGrenade;
+
+/**
+ * An ActiveGrenade is a representation of a grenade in the world
+ * NOTE: Currently only used for smoke grenade line-of-sight testing
+ * @todo Use system allow bots to avoid HE and Flashbangs
+ */
+class ActiveGrenade
+{
+public:
+	ActiveGrenade( CBaseGrenade *grenadeEntity );
+
+	void OnEntityGone( void );								///< called when the grenade in the world goes away
+	void Update( void );									///< called every frame
+	bool IsValid( void ) const	;							///< return true if this grenade is valid
+	
+	bool IsEntity( CBaseGrenade *grenade ) const		{ return (grenade == m_entity) ? true : false; }
+	CBaseGrenade *GetEntity( void ) const				{ return m_entity; }
+
+	const Vector &GetDetonationPosition( void ) const	{ return m_detonationPosition; }
+	const Vector &GetPosition( void ) const;
+	bool IsSmoke( void ) const							{ return m_isSmoke; }
+	bool IsFlashbang( void ) const						{ return m_isFlashbang; }
+	CBaseGrenade *GetGrenade( void ) { return m_entity; }
+	float GetRadius( void ) const { return m_radius; }
+	void SetRadius( float radius ) { m_radius = radius; }
+
+private:
+	CBaseGrenade *m_entity;									///< the entity
+	Vector m_detonationPosition;							///< the location where the grenade detonated (smoke)
+	float m_dieTimestamp;									///< time this should go away after m_entity is NULL
+	bool m_isSmoke;											///< true if this is a smoke grenade
+	bool m_isFlashbang;										///< true if this is a flashbang grenade
+	float m_radius;
+};
+
+typedef CUtlLinkedList<ActiveGrenade *> ActiveGrenadeList;
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * This class manages all active bots, propagating events to them and updating them.
+ */
+class CBotManager
+{
+public:
+	CBotManager();
+	virtual ~CBotManager();
+
+	CBasePlayer *AllocateAndBindBotEntity( edict_t *ed );			///< allocate the appropriate entity for the bot and bind it to the given edict
+	virtual CBasePlayer *AllocateBotEntity( void ) = 0;				///< factory method to allocate the appropriate entity for the bot 
+
+	virtual void ClientDisconnect( CBaseEntity *entity ) = 0;
+	virtual bool ClientCommand( CBasePlayer *player, const CCommand &args ) = 0;
+
+	virtual void ServerActivate( void ) = 0;
+	virtual void ServerDeactivate( void ) = 0;
+	virtual bool ServerCommand( const char * pcmd ) = 0;
+
+	virtual void RestartRound( void );							///< (EXTEND) invoked when a new round begins
+	virtual void StartFrame( void );							///< (EXTEND) called each frame
+
+	virtual unsigned int GetPlayerPriority( CBasePlayer *player ) const = 0;	///< return priority of player (0 = max pri)
+	
+
+	void AddGrenade( CBaseGrenade *grenade );					///< add an active grenade to the bot's awareness
+	void RemoveGrenade( CBaseGrenade *grenade );				///< the grenade entity in the world is going away
+	void SetGrenadeRadius( CBaseGrenade *grenade, float radius );	///< the radius of the grenade entity (or associated smoke cloud)
+	void ValidateActiveGrenades( void );						///< destroy any invalid active grenades
+	void DestroyAllGrenades( void );
+	bool IsLineBlockedBySmoke( const Vector &from, const Vector &to, float grenadeBloat = 1.0f );	///< return true if line intersects smoke volume, with grenade radius increased by the grenadeBloat factor
+	bool IsInsideSmokeCloud( const Vector *pos );				///< return true if position is inside a smoke cloud
+
+	//
+	// Invoke functor on all active grenades.
+	// If any functor call return false, return false.  Otherwise, return true.
+	//
+	template < typename T >
+	bool ForEachGrenade( T &func )
+	{
+		int it = m_activeGrenadeList.Head();
+
+		while( it != m_activeGrenadeList.InvalidIndex() )
+		{
+			ActiveGrenade *ag = m_activeGrenadeList[ it ];
+
+			int current = it;
+			it = m_activeGrenadeList.Next( it );
+
+			// lazy validation
+			if (!ag->IsValid())
+			{
+				m_activeGrenadeList.Remove( current );
+				delete ag;
+				continue;
+			}
+			else
+			{
+				if (func( ag ) == false)
+				{
+					return false;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	enum { MAX_DBG_MSG_SIZE = 1024 };
+	struct DebugMessage
+	{
+		char m_string[ MAX_DBG_MSG_SIZE ];
+		IntervalTimer m_age;
+	};
+
+	// debug message history -------------------------------------------------------------------------------
+	int GetDebugMessageCount( void ) const;						///< get number of debug messages in history
+	const DebugMessage *GetDebugMessage( int which = 0 ) const;	///< return the debug message emitted by the bot (0 = most recent)
+	void ClearDebugMessages( void );
+	void AddDebugMessage( const char *msg );
+
+
+private:
+	ActiveGrenadeList m_activeGrenadeList;///< the list of active grenades the bots are aware of
+
+	enum { MAX_DBG_MSGS = 6 };
+	DebugMessage m_debugMessage[ MAX_DBG_MSGS ];				///< debug message history
+	int m_debugMessageCount;
+	int m_currentDebugMessage;
+
+	IntervalTimer m_frameTimer;									///< for measuring each frame's duration
+};
+
+
+inline CBasePlayer *CBotManager::AllocateAndBindBotEntity( edict_t *ed )
+{
+	CBasePlayer::s_PlayerEdict = ed;
+	return AllocateBotEntity();
+}
+
+inline int CBotManager::GetDebugMessageCount( void ) const
+{
+	return m_debugMessageCount;
+}
+
+inline const CBotManager::DebugMessage *CBotManager::GetDebugMessage( int which ) const
+{
+	if (which >= m_debugMessageCount)
+		return NULL;
+
+	int i = m_currentDebugMessage - which;
+	if (i < 0)
+		i += MAX_DBG_MSGS;
+
+	return &m_debugMessage[ i ];
+}
+
+
+
+
+
+// global singleton to create and control bots
+extern CBotManager *TheBots;
+
+
+#endif
diff --git a/game/shared/cstrike/bot/bot_profile.cpp b/game/shared/cstrike/bot/bot_profile.cpp
new file mode 100644
index 00000000..13da6b09
--- /dev/null
+++ b/game/shared/cstrike/bot/bot_profile.cpp
@@ -0,0 +1,704 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+
+#pragma warning( disable : 4530 )					// STL uses exceptions, but we are not compiling with them - ignore warning
+
+#define DEFINE_DIFFICULTY_NAMES
+#include "bot_profile.h"
+#include "shared_util.h"
+
+#include "bot.h"
+#include "bot_util.h"
+#include "cs_bot.h"		// BOTPORT: Remove this CS dependency
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+BotProfileManager *TheBotProfiles = NULL;
+
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Generates a filename-decorated skin name
+ */
+static const char * GetDecoratedSkinName( const char *name, const char *filename )
+{
+	const int BufLen = _MAX_PATH + 64;
+	static char buf[BufLen];
+	Q_snprintf( buf, sizeof( buf ), "%s/%s", filename, name );
+	return buf;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+const char* BotProfile::GetWeaponPreferenceAsString( int i ) const
+{
+	if ( i < 0 || i >= m_weaponPreferenceCount )
+		return NULL;
+
+	return WeaponIDToAlias( m_weaponPreference[ i ] );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this profile has a primary weapon preference
+ */
+bool BotProfile::HasPrimaryPreference( void ) const
+{
+	for( int i=0; i<m_weaponPreferenceCount; ++i )
+	{
+		if (IsPrimaryWeapon( m_weaponPreference[i] ))
+			return true;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this profile has a pistol weapon preference
+ */
+bool BotProfile::HasPistolPreference( void ) const
+{
+	for( int i=0; i<m_weaponPreferenceCount; ++i )
+		if (IsSecondaryWeapon( m_weaponPreference[i] ))
+			return true;
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if this profile is valid for the specified team
+ */
+bool BotProfile::IsValidForTeam( int team ) const
+{
+	return ( team == TEAM_UNASSIGNED || m_teams == TEAM_UNASSIGNED || team == m_teams );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+* Return true if this profile inherits from the specified template
+*/
+bool BotProfile::InheritsFrom( const char *name ) const
+{
+	if ( WildcardMatch( name, GetName() ) )
+		return true;
+
+	for ( int i=0; i<m_templates.Count(); ++i )
+	{
+		const BotProfile *queryTemplate = m_templates[i];
+		if ( queryTemplate->InheritsFrom( name ) )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Constructor
+ */
+BotProfileManager::BotProfileManager( void )
+{
+	m_nextSkin = 0;
+	for (int i=0; i<NumCustomSkins; ++i)
+	{
+		m_skins[i] = NULL;
+		m_skinFilenames[i] = NULL;
+		m_skinModelnames[i] = NULL;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Load the bot profile database
+ */
+void BotProfileManager::Init( const char *filename, unsigned int *checksum )
+{
+	FileHandle_t file = filesystem->Open( filename, "r" );
+
+	if (!file)
+	{
+		if ( true ) // UTIL_IsGame( "czero" ) )
+		{
+			CONSOLE_ECHO( "WARNING: Cannot access bot profile database '%s'\n", filename );
+		}
+		return;
+	}
+
+	int dataLength = filesystem->Size( filename );
+	char *dataPointer = new char[ dataLength ];
+	int dataReadLength = filesystem->Read( dataPointer, dataLength, file );
+	filesystem->Close( file );
+	if ( dataReadLength > 0 )
+	{
+		// NULL-terminate based on the length read in, since Read() can transform \r\n to \n and
+		// return fewer bytes than we were expecting.
+		dataPointer[ dataReadLength - 1 ] = 0;
+	}
+
+	const char *dataFile = dataPointer;
+
+	// compute simple checksum
+	if (checksum)
+	{
+		*checksum = 0; // ComputeSimpleChecksum( (const unsigned char *)dataPointer, dataLength );
+	}
+
+	BotProfile defaultProfile;
+
+	//
+	// Parse the BotProfile.db into BotProfile instances
+	//
+	while( true )
+	{
+		dataFile = SharedParse( dataFile );
+		if (!dataFile)
+			break;
+
+		char *token = SharedGetToken();
+
+		bool isDefault = (!stricmp( token, "Default" ));
+		bool isTemplate = (!stricmp( token, "Template" ));
+		bool isCustomSkin = (!stricmp( token, "Skin" ));
+
+		if ( isCustomSkin )
+		{
+			const int BufLen = 64;
+			char skinName[BufLen];
+
+			// get skin name
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected skin name\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+			token = SharedGetToken();
+			Q_snprintf( skinName, sizeof( skinName ), "%s", token );
+
+			// get attribute name
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected 'Model'\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+			token = SharedGetToken();
+			if (stricmp( "Model", token ))
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected 'Model'\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+
+			// eat '='
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected '='\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+			token = SharedGetToken();
+			if (strcmp( "=", token ))
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected '='\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+
+			// get attribute value
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected attribute value\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+			token = SharedGetToken();
+
+			const char *decoratedName = GetDecoratedSkinName( skinName, filename );
+			bool skinExists = GetCustomSkinIndex( decoratedName ) > 0;
+			if ( m_nextSkin < NumCustomSkins && !skinExists )
+			{
+				// decorate the name
+				m_skins[ m_nextSkin ] = CloneString( decoratedName );
+
+				// construct the model filename
+				m_skinModelnames[ m_nextSkin ] = CloneString( token );
+				m_skinFilenames[ m_nextSkin ] = new char[ strlen(token)*2 + strlen("models/player//.mdl") + 1 ];
+				Q_snprintf( m_skinFilenames[ m_nextSkin ], sizeof( m_skinFilenames[ m_nextSkin ] ), "models/player/%s/%s.mdl", token, token );
+				++m_nextSkin;
+			}
+
+			// eat 'End'
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected 'End'\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+			token = SharedGetToken();
+			if (strcmp( "End", token ))
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected 'End'\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+
+			continue; // it's just a custom skin - no need to do inheritance on a bot profile, etc.
+		}
+
+		// encountered a new profile
+		BotProfile *profile;
+
+		if (isDefault)
+		{
+			profile = &defaultProfile;
+		}
+		else
+		{
+			profile = new BotProfile;
+
+			// always inherit from Default
+			*profile = defaultProfile;
+		}
+
+		// do inheritance in order of appearance
+		if (!isTemplate && !isDefault)
+		{
+			const BotProfile *inherit = NULL;
+
+			// template names are separated by "+"
+			while(true)
+			{
+				char *c = strchr( token, '+' );
+				if (c)
+					*c = '\000';
+
+				// find the given template name
+				FOR_EACH_LL( m_templateList, it )
+				{
+					BotProfile *profile = m_templateList[ it ];
+					if (!stricmp( profile->GetName(), token ))
+					{
+						inherit = profile;
+						break;
+					}
+				}
+
+				if (inherit == NULL)
+				{
+					CONSOLE_ECHO( "Error parsing '%s' - invalid template reference '%s'\n", filename, token );
+					delete [] dataPointer;
+					return;
+				}
+
+				// inherit the data
+				profile->Inherit( inherit, &defaultProfile );
+
+				if (c == NULL)
+					break;
+				
+				token = c+1;
+			}
+		}
+
+
+		// get name of this profile
+		if (!isDefault)
+		{
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing '%s' - expected name\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+			profile->m_name = CloneString( SharedGetToken() );
+
+			/**
+			 * HACK HACK
+			 * Until we have a generalized means of storing bot preferences, we're going to hardcode the bot's
+			 * preference towards silencers based on his name.
+			 */
+			if ( profile->m_name[0] % 2 )
+			{
+				profile->m_prefersSilencer = true;
+			}
+		}
+
+		// read attributes for this profile
+		bool isFirstWeaponPref = true;
+		while( true )
+		{
+			// get next token
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected 'End'\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+			token = SharedGetToken();
+
+			// check for End delimiter
+			if (!stricmp( token, "End" ))
+				break;
+
+			// found attribute name - keep it
+			char attributeName[64];
+			strcpy( attributeName, token );
+
+			// eat '='
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected '='\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+
+			token = SharedGetToken();
+			if (strcmp( "=", token ))
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected '='\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+
+			// get attribute value
+			dataFile = SharedParse( dataFile );
+			if (!dataFile)
+			{
+				CONSOLE_ECHO( "Error parsing %s - expected attribute value\n", filename );
+				delete [] dataPointer;
+				return;
+			}
+			token = SharedGetToken();
+
+			// store value in appropriate attribute
+			if (!stricmp( "Aggression", attributeName ))
+			{
+				profile->m_aggression = (float)atof(token) / 100.0f;
+			}
+			else if (!stricmp( "Skill", attributeName ))
+			{
+				profile->m_skill = (float)atof(token) / 100.0f;
+			}
+			else if (!stricmp( "Skin", attributeName ))
+			{
+				profile->m_skin = atoi(token);
+				if ( profile->m_skin == 0 )
+				{
+					// atoi() failed - try to look up a custom skin by name
+					profile->m_skin = GetCustomSkinIndex( token, filename );
+				}
+			}
+			else if (!stricmp( "Teamwork", attributeName ))
+			{
+				profile->m_teamwork = (float)atof(token) / 100.0f;
+			}
+			else if (!stricmp( "Cost", attributeName ))
+			{
+				profile->m_cost = atoi(token);
+			}
+			else if (!stricmp( "VoicePitch", attributeName ))
+			{
+				profile->m_voicePitch = atoi(token);
+			}
+			else if (!stricmp( "VoiceBank", attributeName ))
+			{
+				profile->m_voiceBank = FindVoiceBankIndex( token );
+			}
+			else if (!stricmp( "WeaponPreference", attributeName ))
+			{
+				// weapon preferences override parent prefs
+				if (isFirstWeaponPref)
+				{
+					isFirstWeaponPref = false;
+					profile->m_weaponPreferenceCount = 0;
+				}
+
+				if (!stricmp( token, "none" ))
+				{
+					profile->m_weaponPreferenceCount = 0;
+				}
+				else
+				{
+					if (profile->m_weaponPreferenceCount < BotProfile::MAX_WEAPON_PREFS)
+					{
+						profile->m_weaponPreference[ profile->m_weaponPreferenceCount++ ] = AliasToWeaponID( token );
+					}
+				}
+			}
+			else if (!stricmp( "ReactionTime", attributeName ))
+			{
+				profile->m_reactionTime = (float)atof(token);
+
+#ifndef GAMEUI_EXPORTS
+				// subtract off latency due to "think" update rate.
+				// In GameUI, we don't really care.
+				//profile->m_reactionTime -= g_BotUpdateInterval;
+#endif
+
+			}
+			else if (!stricmp( "AttackDelay", attributeName ))
+			{
+				profile->m_attackDelay = (float)atof(token);
+			}
+			else if (!stricmp( "Difficulty", attributeName ))
+			{
+				// override inheritance
+				profile->m_difficultyFlags = 0;
+
+				// parse bit flags
+				while(true)
+				{
+					char *c = strchr( token, '+' );
+					if (c)
+						*c = '\000';
+
+					for( int i=0; i<NUM_DIFFICULTY_LEVELS; ++i )
+						if (!stricmp( BotDifficultyName[i], token ))
+							profile->m_difficultyFlags |= (1 << i);
+
+					if (c == NULL)
+						break;
+					
+					token = c+1;
+				}
+			}
+			else if (!stricmp( "Team", attributeName ))
+			{
+				if ( !stricmp( token, "T" ) )
+				{
+					profile->m_teams = TEAM_TERRORIST;
+				}
+				else if ( !stricmp( token, "CT" ) )
+				{
+					profile->m_teams = TEAM_CT;
+				}
+				else
+				{
+					profile->m_teams = TEAM_UNASSIGNED;
+				}
+			}
+			else
+			{
+				CONSOLE_ECHO( "Error parsing %s - unknown attribute '%s'\n", filename, attributeName );
+			}
+		}
+
+		if (!isDefault)
+		{
+			if (isTemplate)
+			{
+				// add to template list
+				m_templateList.AddToTail( profile );
+			}
+			else
+			{
+				// add profile to the master list
+				m_profileList.AddToTail( profile );
+			}
+		}
+	}
+
+	delete [] dataPointer;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+BotProfileManager::~BotProfileManager( void )
+{
+	Reset();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Free all bot profiles
+ */
+void BotProfileManager::Reset( void )
+{
+	m_profileList.PurgeAndDeleteElements();
+	m_templateList.PurgeAndDeleteElements();
+
+	int i;
+
+	for (i=0; i<NumCustomSkins; ++i)
+	{
+		if ( m_skins[i] )
+		{
+			delete[] m_skins[i];
+			m_skins[i] = NULL;
+		}
+		if ( m_skinFilenames[i] )
+		{
+			delete[] m_skinFilenames[i];
+			m_skinFilenames[i] = NULL;
+		}
+		if ( m_skinModelnames[i] )
+		{
+			delete[] m_skinModelnames[i];
+			m_skinModelnames[i] = NULL;
+		}
+	}
+
+	for ( i=0; i<m_voiceBanks.Count(); ++i )
+	{
+		delete[] m_voiceBanks[i];
+	}
+	m_voiceBanks.RemoveAll();
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Returns custom skin name at a particular index
+ */
+const char * BotProfileManager::GetCustomSkin( int index )
+{
+	if ( index < FirstCustomSkin || index > LastCustomSkin )
+	{
+		return NULL;
+	}
+
+	return m_skins[ index - FirstCustomSkin ];
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Returns custom skin filename at a particular index
+ */
+const char * BotProfileManager::GetCustomSkinFname( int index )
+{
+	if ( index < FirstCustomSkin || index > LastCustomSkin )
+	{
+		return NULL;
+	}
+
+	return m_skinFilenames[ index - FirstCustomSkin ];
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Returns custom skin modelname at a particular index
+ */
+const char * BotProfileManager::GetCustomSkinModelname( int index )
+{
+	if ( index < FirstCustomSkin || index > LastCustomSkin )
+	{
+		return NULL;
+	}
+
+	return m_skinModelnames[ index - FirstCustomSkin ];
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Looks up a custom skin index by filename-decorated name (will decorate the name if filename is given)
+ */
+int BotProfileManager::GetCustomSkinIndex( const char *name, const char *filename )
+{
+	const char * skinName = name;
+	if ( filename )
+	{
+		skinName = GetDecoratedSkinName( name, filename );
+	}
+
+	for (int i=0; i<NumCustomSkins; ++i)
+	{
+		if ( m_skins[i] )
+		{
+			if ( !stricmp( skinName, m_skins[i] ) )
+			{
+				return FirstCustomSkin + i;
+			}
+		}
+	}
+	return 0;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * return index of the (custom) bot phrase db, inserting it if needed
+ */
+int BotProfileManager::FindVoiceBankIndex( const char *filename )
+{
+	int index = 0;
+
+	for ( int i=0; i<m_voiceBanks.Count(); ++i )
+	{
+		if ( !stricmp( filename, m_voiceBanks[i] ) )
+		{
+			return index;
+		}
+	}
+
+	m_voiceBanks.AddToTail( CloneString( filename ) );
+	return index;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return random unused profile that matches the given difficulty level
+ */
+const BotProfile *BotProfileManager::GetRandomProfile( BotDifficultyType difficulty, int team, CSWeaponType weaponType ) const
+{
+	// count up valid profiles
+	CUtlVector< const BotProfile * > profiles;
+	FOR_EACH_LL( m_profileList, it )
+	{
+		const BotProfile *profile = m_profileList[ it ];
+
+		// Match difficulty
+		if ( !profile->IsDifficulty( difficulty ) )
+			continue;
+
+		// Prevent duplicate names
+		if ( UTIL_IsNameTaken( profile->GetName() ) )
+			continue;
+
+		// Match team choice
+		if ( !profile->IsValidForTeam( team ) )
+			continue;
+
+		// Match desired weapon
+		if ( weaponType != WEAPONTYPE_UNKNOWN )
+		{
+			if ( !profile->GetWeaponPreferenceCount() )
+				continue;
+
+			if ( weaponType != WeaponClassFromWeaponID( (CSWeaponID)profile->GetWeaponPreference( 0 ) ) )
+				continue;
+		}
+
+		profiles.AddToTail( profile );
+	}
+
+	if ( !profiles.Count() )
+		return NULL;
+
+	// select one at random
+	int which = RandomInt( 0, profiles.Count()-1 );
+	return profiles[which];
+}
+
diff --git a/game/shared/cstrike/bot/bot_profile.h b/game/shared/cstrike/bot/bot_profile.h
new file mode 100644
index 00000000..172380a3
--- /dev/null
+++ b/game/shared/cstrike/bot/bot_profile.h
@@ -0,0 +1,251 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#ifndef _BOT_PROFILE_H_
+#define _BOT_PROFILE_H_
+
+#pragma warning( disable : 4786 )	// long STL names get truncated in browse info.
+
+#include "bot_constants.h"
+#include "bot_util.h"
+#include "cs_weapon_parse.h"
+
+enum
+{
+	FirstCustomSkin = 100,
+	NumCustomSkins = 100,
+	LastCustomSkin = FirstCustomSkin + NumCustomSkins - 1,
+};
+
+	
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * A BotProfile describes the "personality" of a given bot
+ */
+class BotProfile
+{
+public:
+	BotProfile( void )
+	{
+		m_name = NULL;
+		m_aggression = 0.0f;
+		m_skill = 0.0f;	
+		m_teamwork = 0.0f;
+		m_weaponPreferenceCount = 0;
+		m_cost = 0;
+		m_skin = 0;	
+		m_difficultyFlags = 0;
+		m_voicePitch = 100;
+		m_reactionTime = 0.3f;
+		m_attackDelay = 0.0f;
+		m_teams = TEAM_UNASSIGNED;
+		m_voiceBank = 0;
+		m_prefersSilencer = false;
+	}
+
+	~BotProfile( void )
+	{
+		if ( m_name )
+			delete [] m_name;
+	}
+
+	const char *GetName( void ) const					{ return m_name; }		///< return bot's name
+	float GetAggression( void ) const					{ return m_aggression; }
+	float GetSkill( void ) const						{ return m_skill; }
+	float GetTeamwork( void ) const						{ return m_teamwork; }
+
+	CSWeaponID GetWeaponPreference( int i ) const		{ return m_weaponPreference[ i ]; }
+	const char *GetWeaponPreferenceAsString( int i ) const;
+	int GetWeaponPreferenceCount( void ) const			{ return m_weaponPreferenceCount; }
+	bool HasPrimaryPreference( void ) const;			///< return true if this profile has a primary weapon preference
+	bool HasPistolPreference( void ) const;				///< return true if this profile has a pistol weapon preference
+
+	int GetCost( void ) const							{ return m_cost; }
+	int GetSkin( void ) const							{ return m_skin; }
+	bool IsDifficulty( BotDifficultyType diff ) const;	///< return true if this profile can be used for the given difficulty level
+	int GetVoicePitch( void ) const						{ return m_voicePitch; }
+	float GetReactionTime( void ) const					{ return m_reactionTime; }
+	float GetAttackDelay( void ) const					{ return m_attackDelay; }
+	int GetVoiceBank() const							{ return m_voiceBank; }
+
+	bool IsValidForTeam( int team ) const;
+
+	bool PrefersSilencer() const						{ return m_prefersSilencer; }
+
+	bool InheritsFrom( const char *name ) const;
+
+private:	
+	friend class BotProfileManager;						///< for loading profiles
+
+	void Inherit( const BotProfile *parent, const BotProfile *baseline );	///< copy values from parent if they differ from baseline
+
+	char *m_name;										///< the bot's name
+	float m_aggression;									///< percentage: 0 = coward, 1 = berserker
+	float m_skill;										///< percentage: 0 = terrible, 1 = expert
+	float m_teamwork;									///< percentage: 0 = rogue, 1 = complete obeyance to team, lots of comm
+
+	enum { MAX_WEAPON_PREFS = 16 };
+	CSWeaponID m_weaponPreference[ MAX_WEAPON_PREFS ];	///< which weapons this bot likes to use, in order of priority
+	int m_weaponPreferenceCount;
+
+	int m_cost;											///< reputation point cost for career mode
+	int m_skin;											///< "skin" index
+	unsigned char m_difficultyFlags;					///< bits set correspond to difficulty levels this is valid for
+	int m_voicePitch;									///< the pitch shift for bot chatter (100 = normal)
+	float m_reactionTime;								//< our reaction time in seconds
+	float m_attackDelay;								///< time in seconds from when we notice an enemy to when we open fire
+	int m_teams;										///< teams for which this profile is valid
+
+	bool m_prefersSilencer;								///< does the bot prefer to use silencers?
+
+	int m_voiceBank;									///< Index of the BotChatter.db voice bank this profile uses (0 is the default)
+
+	CUtlVector< const BotProfile * > m_templates;		///< List of templates we inherit from
+};
+typedef CUtlLinkedList<BotProfile *> BotProfileList;
+
+
+inline bool BotProfile::IsDifficulty( BotDifficultyType diff ) const
+{
+	return (m_difficultyFlags & (1 << diff)) ? true : false;
+}
+
+/**
+ * Copy in data from parent if it differs from the baseline
+ */
+inline void BotProfile::Inherit( const BotProfile *parent, const BotProfile *baseline )
+{
+	if (parent->m_aggression != baseline->m_aggression)
+		m_aggression = parent->m_aggression;
+
+	if (parent->m_skill != baseline->m_skill)
+		m_skill = parent->m_skill;
+
+	if (parent->m_teamwork != baseline->m_teamwork)
+		m_teamwork = parent->m_teamwork;
+
+	if (parent->m_weaponPreferenceCount != baseline->m_weaponPreferenceCount)
+	{
+		m_weaponPreferenceCount = parent->m_weaponPreferenceCount;
+		for( int i=0; i<parent->m_weaponPreferenceCount; ++i )
+			m_weaponPreference[i] = parent->m_weaponPreference[i];
+	}
+
+	if (parent->m_cost != baseline->m_cost)
+		m_cost = parent->m_cost;
+
+	if (parent->m_skin != baseline->m_skin)
+		m_skin = parent->m_skin;
+
+	if (parent->m_difficultyFlags != baseline->m_difficultyFlags)
+		m_difficultyFlags = parent->m_difficultyFlags;
+
+	if (parent->m_voicePitch != baseline->m_voicePitch)
+		m_voicePitch = parent->m_voicePitch;
+
+	if (parent->m_reactionTime != baseline->m_reactionTime)
+		m_reactionTime = parent->m_reactionTime;
+
+	if (parent->m_attackDelay != baseline->m_attackDelay)
+		m_attackDelay = parent->m_attackDelay;
+
+	if (parent->m_teams != baseline->m_teams)
+		m_teams = parent->m_teams;
+
+	if (parent->m_voiceBank != baseline->m_voiceBank)
+		m_voiceBank = parent->m_voiceBank;
+
+	m_templates.AddToTail( parent );
+}
+
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * The BotProfileManager defines the interface to accessing BotProfiles
+ */
+class BotProfileManager
+{
+public:
+	BotProfileManager( void );
+	~BotProfileManager( void );
+
+	void Init( const char *filename, unsigned int *checksum = NULL );
+	void Reset( void );
+
+	/// given a name, return a profile
+	const BotProfile *GetProfile( const char *name, int team ) const
+	{
+		FOR_EACH_LL( m_profileList, it )
+		{
+			BotProfile *profile = m_profileList[ it ];
+	
+			if ( !stricmp( name, profile->GetName() ) && profile->IsValidForTeam( team ) )
+				return profile;
+		}
+
+		return NULL;
+	}
+
+	/// given a template name and difficulty, return a profile
+	const BotProfile *GetProfileMatchingTemplate( const char *profileName, int team, BotDifficultyType difficulty ) const
+	{
+		FOR_EACH_LL( m_profileList, it )
+		{
+			BotProfile *profile = m_profileList[ it ];
+
+			if ( !profile->InheritsFrom( profileName ) )
+				continue;
+
+			if ( !profile->IsValidForTeam( team ) )
+				continue;
+
+			if ( !profile->IsDifficulty( difficulty ) )
+				continue;
+
+			if ( UTIL_IsNameTaken( profile->GetName() ) )
+				continue;
+
+			return profile;
+		}
+
+		return NULL;
+	}
+
+	const BotProfileList *GetProfileList( void ) const		{ return &m_profileList; }		///< return list of all profiles
+
+	const BotProfile *GetRandomProfile( BotDifficultyType difficulty, int team, CSWeaponType weaponType ) const;			///< return random unused profile that matches the given difficulty level
+
+	const char * GetCustomSkin( int index );				///< Returns custom skin name at a particular index
+	const char * GetCustomSkinModelname( int index );		///< Returns custom skin modelname at a particular index
+	const char * GetCustomSkinFname( int index );			///< Returns custom skin filename at a particular index
+	int GetCustomSkinIndex( const char *name, const char *filename = NULL );	///< Looks up a custom skin index by name
+
+	typedef CUtlVector<char *> VoiceBankList;
+	const VoiceBankList *GetVoiceBanks( void ) const		{ return &m_voiceBanks; }
+	int FindVoiceBankIndex( const char *filename );		///< return index of the (custom) bot phrase db, inserting it if needed
+
+protected:
+	BotProfileList m_profileList;							///< the list of all bot profiles
+	BotProfileList m_templateList;							///< the list of all bot templates
+
+	VoiceBankList m_voiceBanks;
+
+	char *m_skins[ NumCustomSkins ];						///< Custom skin names
+	char *m_skinModelnames[ NumCustomSkins ];				///< Custom skin modelnames
+	char *m_skinFilenames[ NumCustomSkins ];				///< Custom skin filenames
+	int m_nextSkin;											///< Next custom skin to allocate
+};
+
+/// the global singleton for accessing BotProfiles
+extern BotProfileManager *TheBotProfiles;
+
+
+#endif // _BOT_PROFILE_H_
diff --git a/game/shared/cstrike/bot/bot_util.cpp b/game/shared/cstrike/bot/bot_util.cpp
new file mode 100644
index 00000000..bd10ff24
--- /dev/null
+++ b/game/shared/cstrike/bot/bot_util.cpp
@@ -0,0 +1,604 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Michael S. Booth (mike@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+#include "cs_shareddefs.h"
+#include "engine/IEngineSound.h"
+#include "KeyValues.h"
+
+#include "bot.h"
+#include "bot_util.h"
+#include "bot_profile.h"
+
+#include "cs_bot.h"
+#include <ctype.h>
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static int s_iBeamSprite = 0;
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if given name is already in use by another player
+ */
+bool UTIL_IsNameTaken( const char *name, bool ignoreHumans )
+{
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		if (player->IsPlayer() && player->IsBot())
+		{
+			// bots can have prefixes so we need to check the name
+			// against the profile name instead.
+			CCSBot *bot = dynamic_cast<CCSBot *>(player);
+			if ( bot && bot->GetProfile()->GetName() && FStrEq(name, bot->GetProfile()->GetName()))
+			{
+				return true;
+			}
+		}
+		else
+		{
+			if (!ignoreHumans)
+			{
+				if (FStrEq( name, player->GetPlayerName() ))
+					return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+int UTIL_ClientsInGame( void )
+{
+	int count = 0;
+
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBaseEntity *player = UTIL_PlayerByIndex( i );
+
+		if (player == NULL)
+			continue;
+
+		count++;
+	}
+
+	return count;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the number of non-bots on the given team
+ */
+int UTIL_HumansOnTeam( int teamID, bool isAlive )
+{
+	int count = 0;
+
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBaseEntity *entity = UTIL_PlayerByIndex( i );
+
+		if ( entity == NULL )
+			continue;
+
+		CBasePlayer *player = static_cast<CBasePlayer *>( entity );
+
+		if (player->IsBot())
+			continue;
+
+		if (player->GetTeamNumber() != teamID)
+			continue;
+
+		if (isAlive && !player->IsAlive())
+			continue;
+
+		count++;
+	}
+
+	return count;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+int UTIL_BotsInGame( void )
+{
+	int count = 0;
+
+	for (int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>(UTIL_PlayerByIndex( i ));
+
+		if ( player == NULL )
+			continue;
+
+		if ( !player->IsBot() )
+			continue;
+
+		count++;
+	}
+
+	return count;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Kick a bot from the given team. If no bot exists on the team, return false.
+ */
+bool UTIL_KickBotFromTeam( int kickTeam )
+{
+	int i;
+
+	// try to kick a dead bot first
+	for ( i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		if (!player->IsBot())
+			continue;	
+
+		if (!player->IsAlive() && player->GetTeamNumber() == kickTeam)
+		{
+			// its a bot on the right team - kick it
+			engine->ServerCommand( UTIL_VarArgs( "kick \"%s\"\n", player->GetPlayerName() ) );
+
+			return true;
+		}
+	}
+
+	// no dead bots, kick any bot on the given team
+	for ( i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		if (!player->IsBot())
+			continue;	
+
+		if (player->GetTeamNumber() == kickTeam)
+		{
+			// its a bot on the right team - kick it
+			engine->ServerCommand( UTIL_VarArgs( "kick \"%s\"\n", player->GetPlayerName() ) );
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if all of the members of the given team are bots
+ */
+bool UTIL_IsTeamAllBots( int team )
+{
+	int botCount = 0;
+
+	for( int i=1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		// skip players on other teams
+		if (player->GetTeamNumber() != team)
+			continue;
+
+		// if not a bot, fail the test
+		if (!player->IsBot())
+			return false;
+
+		// is a bot on given team
+		++botCount;
+	}
+
+	// if team is empty, there are no bots
+	return (botCount) ? true : false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest active player to the given position.
+ * If 'distance' is non-NULL, the distance to the closest player is returned in it.
+ */
+extern CBasePlayer *UTIL_GetClosestPlayer( const Vector &pos, float *distance )
+{
+	CBasePlayer *closePlayer = NULL;
+	float closeDistSq = 999999999999.9f;
+
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (!IsEntityValid( player ))
+			continue;
+
+		if (!player->IsAlive())
+			continue;
+
+		Vector playerOrigin = GetCentroid( player );
+		float distSq = (playerOrigin - pos).LengthSqr();
+		if (distSq < closeDistSq)
+		{
+			closeDistSq = distSq;
+			closePlayer = static_cast<CBasePlayer *>( player );
+		}
+	}
+	
+	if (distance)
+		*distance = (float)sqrt( closeDistSq );
+
+	return closePlayer;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest active player on the given team to the given position.
+ * If 'distance' is non-NULL, the distance to the closest player is returned in it.
+ */
+extern CBasePlayer *UTIL_GetClosestPlayer( const Vector &pos, int team, float *distance )
+{
+	CBasePlayer *closePlayer = NULL;
+	float closeDistSq = 999999999999.9f;
+
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (!IsEntityValid( player ))
+			continue;
+
+		if (!player->IsAlive())
+			continue;
+
+		if (player->GetTeamNumber() != team)
+			continue;
+
+		Vector playerOrigin = GetCentroid( player );
+		float distSq = (playerOrigin - pos).LengthSqr();
+		if (distSq < closeDistSq)
+		{
+			closeDistSq = distSq;
+			closePlayer = static_cast<CBasePlayer *>( player );
+		}
+	}
+	
+	if (distance)
+		*distance = (float)sqrt( closeDistSq );
+
+	return closePlayer;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+// Takes the bot pointer and constructs the net name using the current bot name prefix.
+void UTIL_ConstructBotNetName( char *name, int nameLength, const BotProfile *profile )
+{
+	if (profile == NULL)
+	{
+		name[0] = 0;
+		return;
+	}
+
+	// if there is no bot prefix just use the profile name.
+	if ((cv_bot_prefix.GetString() == NULL) || (strlen(cv_bot_prefix.GetString()) == 0))
+	{
+		Q_strncpy( name, profile->GetName(), nameLength );
+		return;
+	}
+
+	// find the highest difficulty
+	const char *diffStr = BotDifficultyName[0];
+	for ( int i=BOT_EXPERT; i>0; --i )
+	{
+		if ( profile->IsDifficulty( (BotDifficultyType)i ) )
+		{
+			diffStr = BotDifficultyName[i];
+			break;
+		}
+	}
+
+	const char *weaponStr = NULL;
+	if ( profile->GetWeaponPreferenceCount() )
+	{
+		weaponStr = profile->GetWeaponPreferenceAsString( 0 );
+
+		const char *translatedAlias = GetTranslatedWeaponAlias( weaponStr );
+
+		char wpnName[128];
+		Q_snprintf( wpnName, sizeof( wpnName ), "weapon_%s", translatedAlias );
+		WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( wpnName );
+		if ( hWpnInfo != GetInvalidWeaponInfoHandle() )
+		{
+			CCSWeaponInfo *pWeaponInfo = dynamic_cast< CCSWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+			if ( pWeaponInfo )
+			{
+				CSWeaponType weaponType = pWeaponInfo->m_WeaponType;
+				weaponStr = WeaponClassAsString( weaponType );
+			}
+		}
+	}
+	if ( !weaponStr )
+	{
+		weaponStr = "";
+	}
+
+	char skillStr[16];
+	Q_snprintf( skillStr, sizeof( skillStr ), "%.0f", profile->GetSkill()*100 );
+
+	char temp[MAX_PLAYER_NAME_LENGTH*2];
+	char prefix[MAX_PLAYER_NAME_LENGTH*2];
+	Q_strncpy( temp, cv_bot_prefix.GetString(), sizeof( temp ) );
+	Q_StrSubst( temp, "<difficulty>", diffStr, prefix, sizeof( prefix ) );
+	Q_StrSubst( prefix, "<weaponclass>", weaponStr, temp, sizeof( temp ) );
+	Q_StrSubst( temp, "<skill>", skillStr, prefix, sizeof( prefix ) );
+	Q_snprintf( name, nameLength, "%s %s", prefix, profile->GetName() );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if anyone on the given team can see the given spot
+ */
+bool UTIL_IsVisibleToTeam( const Vector &spot, int team )
+{
+	for( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if (player == NULL)
+			continue;
+
+		if (!player->IsAlive())
+			continue;
+
+		if (player->GetTeamNumber() != team)
+			continue;
+
+		trace_t result;
+		UTIL_TraceLine( player->EyePosition(), spot, CONTENTS_SOLID, player, COLLISION_GROUP_NONE, &result );
+
+		if (result.fraction == 1.0f)
+			return true;
+	}
+
+	return false;
+}
+
+
+//------------------------------------------------------------------------------------------------------------
+void UTIL_DrawBeamFromEnt( int i, Vector vecEnd, int iLifetime, byte bRed, byte bGreen, byte bBlue )
+{
+/* BOTPORT: What is the replacement for MESSAGE_BEGIN?
+	MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecEnd );   // vecEnd = origin???
+					WRITE_BYTE( TE_BEAMENTPOINT );
+					WRITE_SHORT( i );
+					WRITE_COORD( vecEnd.x );
+					WRITE_COORD( vecEnd.y );
+					WRITE_COORD( vecEnd.z );
+					WRITE_SHORT( s_iBeamSprite );
+					WRITE_BYTE( 0 );		 // startframe
+					WRITE_BYTE( 0 );		 // framerate
+					WRITE_BYTE( iLifetime ); // life
+					WRITE_BYTE( 10 );		 // width
+					WRITE_BYTE( 0 );		 // noise
+					WRITE_BYTE( bRed );		 // r, g, b
+					WRITE_BYTE( bGreen );		 // r, g, b
+					WRITE_BYTE( bBlue );    // r, g, b
+					WRITE_BYTE( 255 );	 // brightness
+					WRITE_BYTE( 0 );		 // speed
+					MESSAGE_END();
+					*/
+}
+
+
+//------------------------------------------------------------------------------------------------------------
+void UTIL_DrawBeamPoints( Vector vecStart, Vector vecEnd, int iLifetime, byte bRed, byte bGreen, byte bBlue )
+{
+	NDebugOverlay::Line( vecStart, vecEnd, bRed, bGreen, bBlue, true, 0.1f );
+
+	/*
+	MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecStart );
+					WRITE_BYTE( TE_BEAMPOINTS );
+					WRITE_COORD( vecStart.x );
+					WRITE_COORD( vecStart.y );
+					WRITE_COORD( vecStart.z );
+					WRITE_COORD( vecEnd.x );
+					WRITE_COORD( vecEnd.y );
+					WRITE_COORD( vecEnd.z );
+					WRITE_SHORT( s_iBeamSprite );
+					WRITE_BYTE( 0 );		 // startframe
+					WRITE_BYTE( 0 );		 // framerate
+					WRITE_BYTE( iLifetime ); // life
+					WRITE_BYTE( 10 );		 // width
+					WRITE_BYTE( 0 );		 // noise
+					WRITE_BYTE( bRed );		 // r, g, b
+					WRITE_BYTE( bGreen );		 // r, g, b
+					WRITE_BYTE( bBlue );    // r, g, b
+					WRITE_BYTE( 255 );	 // brightness
+					WRITE_BYTE( 0 );		 // speed
+					MESSAGE_END();
+					*/
+}
+
+
+//------------------------------------------------------------------------------------------------------------
+void CONSOLE_ECHO( const char * pszMsg, ... )
+{
+	va_list     argptr;
+	static char szStr[1024];
+
+	va_start( argptr, pszMsg );
+	vsprintf( szStr, pszMsg, argptr );
+	va_end( argptr );
+
+	Msg( "%s", szStr );
+}
+
+
+//------------------------------------------------------------------------------------------------------------
+void BotPrecache( void )
+{
+	s_iBeamSprite = CBaseEntity::PrecacheModel( "sprites/smoke.spr" );
+}
+
+//------------------------------------------------------------------------------------------------------------
+#define COS_TABLE_SIZE 256
+static float cosTable[ COS_TABLE_SIZE ];
+
+void InitBotTrig( void )
+{
+	for( int i=0; i<COS_TABLE_SIZE; ++i )
+	{
+		float angle = (float)(2.0f * M_PI * i / (float)(COS_TABLE_SIZE-1));
+		cosTable[i] = (float)cos( angle ); 
+	}
+}
+
+float BotCOS( float angle )
+{
+	angle = AngleNormalizePositive( angle );
+	int i = (int)( angle * (COS_TABLE_SIZE-1) / 360.0f );
+	return cosTable[i];
+}
+
+float BotSIN( float angle )
+{
+	angle = AngleNormalizePositive( angle - 90 );
+	int i = (int)( angle * (COS_TABLE_SIZE-1) / 360.0f );
+	return cosTable[i];
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Send a "hint" message to all players, dead or alive.
+ */
+void HintMessageToAllPlayers( const char *message )
+{
+	hudtextparms_t textParms;
+
+	textParms.x = -1.0f;
+	textParms.y = -1.0f;
+	textParms.fadeinTime = 1.0f;
+	textParms.fadeoutTime = 5.0f;
+	textParms.holdTime = 5.0f;
+	textParms.fxTime = 0.0f;
+	textParms.r1 = 100;
+	textParms.g1 = 255;
+	textParms.b1 = 100;
+	textParms.r2 = 255;
+	textParms.g2 = 255;
+	textParms.b2 = 255;
+	textParms.effect = 0;
+	textParms.channel = 0;
+
+	UTIL_HudMessageAll( textParms, message );
+}
+
+//--------------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if moving from "start" to "finish" will cross a player's line of fire.
+ * The path from "start" to "finish" is assumed to be a straight line.
+ * "start" and "finish" are assumed to be points on the ground.
+ */
+bool IsCrossingLineOfFire( const Vector &start, const Vector &finish, CBaseEntity *ignore, int ignoreTeam  )
+{
+	for ( int p=1; p <= gpGlobals->maxClients; ++p )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( p ) );
+
+		if (!IsEntityValid( player ))
+			continue;
+
+		if (player == ignore)
+			continue;
+
+		if (!player->IsAlive())
+			continue;
+
+		if (ignoreTeam && player->GetTeamNumber() == ignoreTeam)
+			continue;
+
+		// compute player's unit aiming vector 
+		Vector viewForward;
+		AngleVectors( player->EyeAngles() + player->GetPunchAngle(), &viewForward );
+
+		const float longRange = 5000.0f;
+		Vector playerOrigin = GetCentroid( player );
+		Vector playerTarget = playerOrigin + longRange * viewForward;
+
+		Vector result( 0, 0, 0 );
+		if (IsIntersecting2D( start, finish, playerOrigin, playerTarget, &result ))
+		{
+			// simple check to see if intersection lies in the Z range of the path
+			float loZ, hiZ;
+
+			if (start.z < finish.z)
+			{
+				loZ = start.z;
+				hiZ = finish.z;
+			}
+			else
+			{
+				loZ = finish.z;
+				hiZ = start.z;
+			}
+
+			if (result.z >= loZ && result.z <= hiZ + HumanHeight)
+				return true;
+		}
+	}
+
+	return false;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+* Performs a simple case-insensitive string comparison, honoring trailing * wildcards
+*/
+bool WildcardMatch( const char *query, const char *test )
+{
+	if ( !query || !test )
+		return false;
+
+	while ( *test && *query )
+	{
+		char nameChar = *test;
+		char queryChar = *query;
+		if ( tolower(nameChar) != tolower(queryChar) ) // case-insensitive
+			break;
+		++test;
+		++query;
+	}
+
+	if ( *query == 0 && *test == 0 )
+		return true;
+
+	// Support trailing *
+	if ( *query == '*' )
+		return true;
+
+	return false;
+}
+
+
+
diff --git a/game/shared/cstrike/bot/bot_util.h b/game/shared/cstrike/bot/bot_util.h
new file mode 100644
index 00000000..572b1db4
--- /dev/null
+++ b/game/shared/cstrike/bot/bot_util.h
@@ -0,0 +1,167 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef BOT_UTIL_H
+#define BOT_UTIL_H
+
+
+#include "convar.h"
+#include "util.h"
+
+//--------------------------------------------------------------------------------------------------------------
+enum PriorityType
+{
+	PRIORITY_LOW, PRIORITY_MEDIUM, PRIORITY_HIGH, PRIORITY_UNINTERRUPTABLE
+};
+
+
+extern ConVar cv_bot_traceview;
+extern ConVar cv_bot_stop;
+extern ConVar cv_bot_show_nav;
+extern ConVar cv_bot_walk;
+extern ConVar cv_bot_difficulty;
+extern ConVar cv_bot_debug;
+extern ConVar cv_bot_debug_target;
+extern ConVar cv_bot_quota;
+extern ConVar cv_bot_quota_mode;
+extern ConVar cv_bot_prefix;
+extern ConVar cv_bot_allow_rogues;
+extern ConVar cv_bot_allow_pistols;
+extern ConVar cv_bot_allow_shotguns;
+extern ConVar cv_bot_allow_sub_machine_guns;
+extern ConVar cv_bot_allow_rifles;
+extern ConVar cv_bot_allow_machine_guns;
+extern ConVar cv_bot_allow_grenades;
+extern ConVar cv_bot_allow_snipers;
+extern ConVar cv_bot_allow_shield;
+extern ConVar cv_bot_join_team;
+extern ConVar cv_bot_join_after_player;
+extern ConVar cv_bot_auto_vacate;
+extern ConVar cv_bot_zombie;
+extern ConVar cv_bot_defer_to_human;
+extern ConVar cv_bot_chatter;
+extern ConVar cv_bot_profile_db;
+extern ConVar cv_bot_dont_shoot;
+extern ConVar cv_bot_eco_limit;
+extern ConVar cv_bot_auto_follow;
+extern ConVar cv_bot_flipout;
+
+#define RAD_TO_DEG( deg ) ((deg) * 180.0 / M_PI)
+#define DEG_TO_RAD( rad ) ((rad) * M_PI / 180.0)
+
+#define SIGN( num )	      (((num) < 0) ? -1 : 1)
+#define ABS( num )        (SIGN(num) * (num))
+
+
+#define CREATE_FAKE_CLIENT		( *g_engfuncs.pfnCreateFakeClient )
+#define GET_USERINFO			( *g_engfuncs.pfnGetInfoKeyBuffer )
+#define SET_KEY_VALUE			( *g_engfuncs.pfnSetKeyValue )
+#define SET_CLIENT_KEY_VALUE	( *g_engfuncs.pfnSetClientKeyValue )
+
+class BotProfile;
+
+extern void   BotPrecache( void );
+extern int		UTIL_ClientsInGame( void );
+
+extern bool UTIL_IsNameTaken( const char *name, bool ignoreHumans = false );		///< return true if given name is already in use by another player
+
+#define IS_ALIVE true
+extern int UTIL_HumansOnTeam( int teamID, bool isAlive = false );
+
+extern int		UTIL_BotsInGame( void );
+extern bool		UTIL_IsTeamAllBots( int team );
+extern void		UTIL_DrawBeamFromEnt( int iIndex, Vector vecEnd, int iLifetime, byte bRed, byte bGreen, byte bBlue );
+extern void		UTIL_DrawBeamPoints( Vector vecStart, Vector vecEnd, int iLifetime, byte bRed, byte bGreen, byte bBlue );
+extern CBasePlayer *UTIL_GetClosestPlayer( const Vector &pos, float *distance = NULL );
+extern CBasePlayer *UTIL_GetClosestPlayer( const Vector &pos, int team, float *distance = NULL );
+extern bool UTIL_KickBotFromTeam( int kickTeam ); ///< kick a bot from the given team. If no bot exists on the team, return false.
+
+extern bool UTIL_IsVisibleToTeam( const Vector &spot, int team ); ///< return true if anyone on the given team can see the given spot
+
+/// return true if moving from "start" to "finish" will cross a player's line of fire.
+extern bool IsCrossingLineOfFire( const Vector &start, const Vector &finish, CBaseEntity *ignore = NULL, int ignoreTeam = 0 );
+
+extern void UTIL_ConstructBotNetName(char *name, int nameLength, const BotProfile *bot);	///< constructs a complete name including prefix
+
+/**
+ * Echos text to the console, and prints it on the client's screen.  This is NOT tied to the developer cvar.
+ * If you are adding debugging output in cstrike, use UTIL_DPrintf() (debug.h) instead.
+ */
+extern void CONSOLE_ECHO( PRINTF_FORMAT_STRING const char * pszMsg, ... );
+
+extern void InitBotTrig( void );
+extern float BotCOS( float angle );
+extern float BotSIN( float angle );
+
+extern void HintMessageToAllPlayers( const char *message );
+
+bool WildcardMatch( const char *query, const char *test );	///< Performs a simple case-insensitive string comparison, honoring trailing * wildcards
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if the given entity is valid
+ */
+inline bool IsEntityValid( CBaseEntity *entity )
+{
+	if (entity == NULL)
+		return false;
+
+	if (FNullEnt( entity->edict() ))
+		return false;
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Given two line segments: startA to endA, and startB to endB, return true if they intesect
+ * and put the intersection point in "result".
+ * Note that this computes the intersection of the 2D (x,y) projection of the line segments.
+ */
+inline bool IsIntersecting2D( const Vector &startA, const Vector &endA, 
+															const Vector &startB, const Vector &endB, 
+															Vector *result = NULL )
+{
+	float denom = (endA.x - startA.x) * (endB.y - startB.y) - (endA.y - startA.y) * (endB.x - startB.x);
+	if (denom == 0.0f)
+	{
+		// parallel
+		return false;
+	}
+
+	float numS = (startA.y - startB.y) * (endB.x - startB.x) - (startA.x - startB.x) * (endB.y - startB.y);
+	if (numS == 0.0f)
+	{
+		// coincident
+		return true;
+	}
+
+	float numT = (startA.y - startB.y) * (endA.x - startA.x) - (startA.x - startB.x) * (endA.y - startA.y);
+
+	float s = numS / denom;
+	if (s < 0.0f || s > 1.0f)
+	{
+		// intersection is not within line segment of startA to endA
+		return false;
+	}
+
+	float t = numT / denom;
+	if (t < 0.0f || t > 1.0f)
+	{
+		// intersection is not within line segment of startB to endB
+		return false;
+	}
+
+	// compute intesection point
+	if (result)
+		*result = startA + s * (endA - startA);
+
+	return true;
+}
+
+
+#endif
diff --git a/game/shared/cstrike/bot/improv_locomotor.h b/game/shared/cstrike/bot/improv_locomotor.h
new file mode 100644
index 00000000..17054614
--- /dev/null
+++ b/game/shared/cstrike/bot/improv_locomotor.h
@@ -0,0 +1,57 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// improv_locomotor.h
+// Interface for moving Improvs along computed paths
+// Author: Michael Booth, July 2004
+
+#ifndef _IMPROV_LOCOMOTOR_H_
+#define _IMPROV_LOCOMOTOR_H_
+
+// TODO: Remove duplicate methods from CImprov, and update CImprov to use this class
+
+/**
+ * A locomotor owns the movement of an Improv
+ */
+class CImprovLocomotor
+{
+public:
+	virtual const Vector &GetCentroid( void ) const = 0;
+	virtual const Vector &GetFeet( void ) const = 0;					///< return position of "feet" - point below centroid of improv at feet level
+	virtual const Vector &GetEyes( void ) const = 0;
+	virtual float GetMoveAngle( void ) const = 0;						///< return direction of movement
+
+	virtual CNavArea *GetLastKnownArea( void ) const = 0;
+	virtual bool GetSimpleGroundHeightWithFloor( const Vector &pos, float *height, Vector *normal = NULL ) = 0;	///< find "simple" ground height, treating current nav area as part of the floor
+
+	virtual void Crouch( void ) = 0;
+	virtual void StandUp( void ) = 0;									///< "un-crouch"
+	virtual bool IsCrouching( void ) const = 0;
+
+	virtual void Jump( void ) = 0;										///< initiate a jump
+	virtual bool IsJumping( void ) const = 0;
+
+	virtual void Run( void ) = 0;										///< set movement speed to running
+	virtual void Walk( void ) = 0;										///< set movement speed to walking
+	virtual bool IsRunning( void ) const = 0;
+
+	virtual void StartLadder( const CNavLadder *ladder, NavTraverseType how, const Vector &approachPos, const Vector &departPos ) = 0;	///< invoked when a ladder is encountered while following a path
+	virtual bool TraverseLadder( const CNavLadder *ladder, NavTraverseType how, const Vector &approachPos, const Vector &departPos, float deltaT ) = 0;	///< traverse given ladder
+	virtual bool IsUsingLadder( void ) const = 0;
+
+	enum MoveToFailureType
+	{
+		FAIL_INVALID_PATH,
+		FAIL_STUCK,
+		FAIL_FELL_OFF,
+	};
+	virtual void TrackPath( const Vector &pathGoal, float deltaT ) = 0;	///< move along path by following "pathGoal"
+	virtual void OnMoveToSuccess( const Vector &goal ) { }				///< invoked when an improv reaches its MoveTo goal
+	virtual void OnMoveToFailure( const Vector &goal, MoveToFailureType reason ) { }	///< invoked when an improv fails to reach a MoveTo goal
+};
+
+#endif // _IMPROV_LOCOMOTOR_H_
diff --git a/game/shared/cstrike/bot/nav_path.cpp b/game/shared/cstrike/bot/nav_path.cpp
new file mode 100644
index 00000000..92285bc6
--- /dev/null
+++ b/game/shared/cstrike/bot/nav_path.cpp
@@ -0,0 +1,1208 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_path.cpp
+// Encapsulation of a path through space
+// Author: Michael S. Booth (mike@turtlerockstudios.com), November 2003
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "cs_player.h"
+
+#include "nav_mesh.h"
+#include "nav_path.h"
+#include "bot_util.h"
+#include "improv_locomotor.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#ifdef _WIN32
+#pragma warning (disable:4701)				// disable warning that variable *may* not be initialized 
+#endif
+
+
+#define DrawLine( from, to, duration, red, green, blue )		NDebugOverlay::Line( from, to, red, green, blue, true, 0.1f )
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Determine actual path positions
+ */
+bool CNavPath::ComputePathPositions( void )
+{
+	if (m_segmentCount == 0)
+		return false;
+
+	// start in first area's center
+	m_path[0].pos = m_path[0].area->GetCenter();
+	m_path[0].ladder = NULL;
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+
+	for( int i=1; i<m_segmentCount; ++i )
+	{
+		const PathSegment *from = &m_path[ i-1 ];
+		PathSegment *to = &m_path[ i ];
+
+		if (to->how <= GO_WEST)		// walk along the floor to the next area
+		{
+			to->ladder = NULL;
+
+			// compute next point, keeping path as straight as possible
+			from->area->ComputeClosestPointInPortal( to->area, (NavDirType)to->how, from->pos, &to->pos );
+
+			// move goal position into the goal area a bit
+			const float stepInDist = 5.0f;		// how far to "step into" an area - must be less than min area size
+			AddDirectionVector( &to->pos, (NavDirType)to->how, stepInDist );
+
+			// we need to walk out of "from" area, so keep Z where we can reach it
+			to->pos.z = from->area->GetZ( to->pos );
+
+			// if this is a "jump down" connection, we must insert an additional point on the path
+			if (to->area->IsConnected( from->area, NUM_DIRECTIONS ) == false)
+			{
+				// this is a "jump down" link
+
+				// compute direction of path just prior to "jump down"
+				Vector2D dir;
+				DirectionToVector2D( (NavDirType)to->how, &dir );
+
+				// shift top of "jump down" out a bit to "get over the ledge"
+				const float pushDist = 25.0f;
+				to->pos.x += pushDist * dir.x;
+				to->pos.y += pushDist * dir.y;
+
+				// insert a duplicate node to represent the bottom of the fall
+				if (m_segmentCount < MAX_PATH_SEGMENTS-1)
+				{
+					// copy nodes down
+					for( int j=m_segmentCount; j>i; --j )
+						m_path[j] = m_path[j-1];
+
+					// path is one node longer
+					++m_segmentCount;
+
+					// move index ahead into the new node we just duplicated
+					++i;
+
+					m_path[i].pos.x = to->pos.x + pushDist * dir.x;
+					m_path[i].pos.y = to->pos.y + pushDist * dir.y;
+
+					// put this one at the bottom of the fall
+					m_path[i].pos.z = to->area->GetZ( m_path[i].pos );
+				}
+			}
+		}
+		else if (to->how == GO_LADDER_UP)		// to get to next area, must go up a ladder
+		{
+			// find our ladder
+			const NavLadderConnectList *list = from->area->GetLadderList( CSNavLadder::LADDER_UP );
+			int it;
+			for( it = list->Head(); it != list->InvalidIndex(); it = list->Next(it))
+			{
+				CSNavLadder *ladder = (*list)[ it ].ladder;
+
+				// can't use "behind" area when ascending...
+				if (ladder->m_topForwardArea == to->area ||
+					ladder->m_topLeftArea == to->area ||
+					ladder->m_topRightArea == to->area)
+				{
+					to->ladder = ladder;
+					to->pos = ladder->m_bottom + ladder->GetNormal() * 2.0f * HalfHumanWidth;
+					break;
+				}
+			}
+
+			if (it == list->InvalidIndex())
+			{
+				//PrintIfWatched( "ERROR: Can't find ladder in path\n" );
+				return false;
+			}
+		}
+		else if (to->how == GO_LADDER_DOWN)		// to get to next area, must go down a ladder
+		{
+			// find our ladder
+			const NavLadderConnectList *list = from->area->GetLadderList( CSNavLadder::LADDER_DOWN );
+			int it;
+			for( it = list->Head(); it != list->InvalidIndex(); it = list->Next(it))
+			{
+				CSNavLadder *ladder = (*list)[ it ].ladder;
+
+				if (ladder->m_bottomArea == to->area)
+				{
+					to->ladder = ladder;
+					to->pos = ladder->m_top;
+					to->pos = ladder->m_top - ladder->GetNormal() * 2.0f * HalfHumanWidth;
+					break;
+				}
+			}
+
+			if (it == list->InvalidIndex())
+			{
+				//PrintIfWatched( "ERROR: Can't find ladder in path\n" );
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return true if position is at the end of the path
+ */
+bool CNavPath::IsAtEnd( const Vector &pos ) const
+{
+	if (!IsValid())
+		return false;
+
+	const float epsilon = 20.0f;
+	return (pos - GetEndpoint()).IsLengthLessThan( epsilon );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return length of path from start to finish
+ */
+float CNavPath::GetLength( void ) const
+{
+	float length = 0.0f;
+	for( int i=1; i<GetSegmentCount(); ++i )
+	{
+		length += (m_path[i].pos - m_path[i-1].pos).Length();
+	}
+
+	return length;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return point a given distance along the path - if distance is out of path bounds, point is clamped to start/end
+ * @todo Be careful of returning "positions" along one-way drops, ladders, etc.
+ */
+bool CNavPath::GetPointAlongPath( float distAlong, Vector *pointOnPath ) const
+{
+	if (!IsValid() || pointOnPath == NULL)
+		return false;
+
+	if (distAlong <= 0.0f)
+	{
+		*pointOnPath = m_path[0].pos;
+		return true;
+	}
+
+	float lengthSoFar = 0.0f;
+	float segmentLength;
+	Vector dir;
+	for( int i=1; i<GetSegmentCount(); ++i )
+	{
+		dir = m_path[i].pos - m_path[i-1].pos;
+		segmentLength = dir.Length();
+
+		if (segmentLength + lengthSoFar >= distAlong)
+		{
+			// desired point is on this segment of the path
+			float delta = distAlong - lengthSoFar;
+			float t = delta / segmentLength;
+
+			*pointOnPath = m_path[i].pos + t * dir;
+
+			return true;
+		}
+
+		lengthSoFar += segmentLength;
+	}
+
+	*pointOnPath = m_path[ GetSegmentCount()-1 ].pos;
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the node index closest to the given distance along the path without going over - returns (-1) if error
+ */
+int CNavPath::GetSegmentIndexAlongPath( float distAlong ) const
+{
+	if (!IsValid())
+		return -1;
+
+	if (distAlong <= 0.0f)
+	{
+		return 0;
+	}
+
+	float lengthSoFar = 0.0f;
+	Vector dir;
+	for( int i=1; i<GetSegmentCount(); ++i )
+	{
+		lengthSoFar += (m_path[i].pos - m_path[i-1].pos).Length();
+
+		if (lengthSoFar > distAlong)
+		{
+			return i-1;
+		}
+	}
+
+	return GetSegmentCount()-1;
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute closest point on path to given point
+ * NOTE: This does not do line-of-sight tests, so closest point may be thru the floor, etc
+ */
+bool CNavPath::FindClosestPointOnPath( const Vector *worldPos, int startIndex, int endIndex, Vector *close ) const
+{
+	if (!IsValid() || close == NULL)
+		return false;
+
+	Vector along, toWorldPos;
+	Vector pos;
+	const Vector *from, *to;
+	float length;
+	float closeLength;
+	float closeDistSq = 9999999999.9;
+	float distSq;
+
+	for( int i=startIndex; i<=endIndex; ++i )
+	{
+		from = &m_path[i-1].pos;
+		to = &m_path[i].pos;
+
+		// compute ray along this path segment
+		along = *to - *from;
+
+		// make it a unit vector along the path
+		length = along.NormalizeInPlace();
+
+		// compute vector from start of segment to our point
+		toWorldPos = *worldPos - *from;
+
+		// find distance of closest point on ray
+		closeLength = DotProduct( toWorldPos, along );
+
+		// constrain point to be on path segment
+		if (closeLength <= 0.0f)
+			pos = *from;
+		else if (closeLength >= length)
+			pos = *to;
+		else
+			pos = *from + closeLength * along;
+
+		distSq = (pos - *worldPos).LengthSqr();
+
+		// keep the closest point so far
+		if (distSq < closeDistSq)
+		{
+			closeDistSq = distSq;
+			*close = pos;
+		}
+	}
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Build trivial path when start and goal are in the same nav area
+ */
+bool CNavPath::BuildTrivialPath( const Vector &start, const Vector &goal )
+{
+	m_segmentCount = 0;
+
+	CNavArea *startArea = TheNavMesh->GetNearestNavArea( start );
+	if (startArea == NULL)
+		return false;
+
+	CNavArea *goalArea = TheNavMesh->GetNearestNavArea( goal );
+	if (goalArea == NULL)
+		return false;
+
+	m_segmentCount = 2;
+
+	m_path[0].area = startArea;
+	m_path[0].pos.x = start.x;
+	m_path[0].pos.y = start.y;
+	m_path[0].pos.z = startArea->GetZ( start );
+	m_path[0].ladder = NULL;
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+
+	m_path[1].area = goalArea;
+	m_path[1].pos.x = goal.x;
+	m_path[1].pos.y = goal.y;
+	m_path[1].pos.z = goalArea->GetZ( goal );
+	m_path[1].ladder = NULL;
+	m_path[1].how = NUM_TRAVERSE_TYPES;
+
+	return true;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Draw the path for debugging.
+ */
+void CNavPath::Draw( const Vector &color )
+{
+	if (!IsValid())
+		return;
+
+	for( int i=1; i<m_segmentCount; ++i )
+	{
+		DrawLine( m_path[i-1].pos + Vector( 0, 0, HalfHumanHeight ), 
+				  m_path[i].pos + Vector( 0, 0, HalfHumanHeight ), 2, 255 * color.x, 255 * color.y, 255 * color.z );
+	}
+}
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Check line of sight from 'anchor' node on path to subsequent nodes until
+ * we find a node that can't been seen from 'anchor'.
+ */
+int CNavPath::FindNextOccludedNode( int anchor )
+{
+	for( int i=anchor+1; i<m_segmentCount; ++i )
+	{
+		// don't remove ladder nodes
+		if (m_path[i].ladder)
+			return i;
+
+		if (!IsWalkableTraceLineClear( m_path[ anchor ].pos, m_path[ i ].pos ))
+		{
+			// cant see this node from anchor node
+			return i;
+		}
+
+		Vector anchorPlusHalf =  m_path[ anchor ].pos + Vector( 0, 0, HalfHumanHeight );
+		Vector iPlusHalf =  m_path[ i ].pos +Vector( 0, 0, HalfHumanHeight );
+		if (!IsWalkableTraceLineClear( anchorPlusHalf, iPlusHalf) )
+		{
+			// cant see this node from anchor node
+			return i;
+		}
+
+		Vector anchorPlusFull =  m_path[ anchor ].pos + Vector( 0, 0, HumanHeight );
+		Vector iPlusFull = m_path[ i ].pos + Vector( 0, 0, HumanHeight );
+		if (!IsWalkableTraceLineClear( anchorPlusFull, iPlusFull ))
+		{
+			// cant see this node from anchor node
+			return i;
+		}
+	}
+
+	return m_segmentCount;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Smooth out path, removing redundant nodes
+ */
+void CNavPath::Optimize( void )
+{
+// DONT USE THIS: Optimizing the path results in cutting thru obstacles
+return;
+
+	if (m_segmentCount < 3)
+		return;
+
+	int anchor = 0;
+
+	while( anchor < m_segmentCount )
+	{
+		int occluded = FindNextOccludedNode( anchor );
+		int nextAnchor = occluded-1;
+
+		if (nextAnchor > anchor)
+		{
+			// remove redundant nodes between anchor and nextAnchor
+			int removeCount = nextAnchor - anchor - 1;
+			if (removeCount > 0)
+			{
+				for( int i=nextAnchor; i<m_segmentCount; ++i )
+				{
+					m_path[i-removeCount] = m_path[i];
+				}
+				m_segmentCount -= removeCount;
+			}
+		}
+
+		++anchor;
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------
+
+/**
+ * Constructor
+ */
+CNavPathFollower::CNavPathFollower( void )
+{
+	m_improv = NULL;
+	m_path = NULL;
+
+	m_segmentIndex = 0;
+	m_isLadderStarted = false;
+
+	m_isDebug = false;
+}
+
+void CNavPathFollower::Reset( void )
+{
+	m_segmentIndex = 1;
+	m_isLadderStarted = false;
+
+	m_stuckMonitor.Reset();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Move improv along path
+ */
+void CNavPathFollower::Update( float deltaT, bool avoidObstacles )
+{
+	if (m_path == NULL || m_path->IsValid() == false)
+		return;
+
+	const CNavPath::PathSegment *node = (*m_path)[ m_segmentIndex ];
+
+	if (node == NULL)
+	{
+		m_improv->OnMoveToFailure( m_path->GetEndpoint(), CImprovLocomotor::FAIL_INVALID_PATH );
+		m_path->Invalidate();
+		return;
+	}
+
+	// handle ladders
+	/*
+	if (node->ladder)
+	{
+		const Vector *approachPos = NULL;
+		const Vector *departPos = NULL;
+
+		if (m_segmentIndex)
+			approachPos = &(*m_path)[ m_segmentIndex-1 ]->pos;
+
+		if (m_segmentIndex < m_path->GetSegmentCount()-1)
+			departPos = &(*m_path)[ m_segmentIndex+1 ]->pos;
+
+		if (!m_isLadderStarted)
+		{
+			// set up ladder movement
+			m_improv->StartLadder( node->ladder, node->how, approachPos, departPos );
+			m_isLadderStarted = true;
+		}
+
+		// move improv along ladder
+		if (m_improv->TraverseLadder( node->ladder, node->how, approachPos, departPos, deltaT ))
+		{
+			// completed ladder
+			++m_segmentIndex;
+		}
+		return;
+	}
+	*/
+
+	// reset ladder init flag
+	m_isLadderStarted = false;
+
+	//
+	// Check if we reached the end of the path
+	//
+	const float closeRange = 20.0f;
+	if ((m_improv->GetFeet() - node->pos).IsLengthLessThan( closeRange ))
+	{
+		++m_segmentIndex;
+
+		if (m_segmentIndex >= m_path->GetSegmentCount())
+		{
+			m_improv->OnMoveToSuccess( m_path->GetEndpoint() );
+			m_path->Invalidate();
+			return;
+		}
+	}
+
+
+	m_goal = node->pos;
+
+	const float aheadRange = 300.0f;
+	m_segmentIndex = FindPathPoint( aheadRange, &m_goal, &m_behindIndex );
+	if (m_segmentIndex >= m_path->GetSegmentCount())
+		m_segmentIndex = m_path->GetSegmentCount()-1;
+
+
+	bool isApproachingJumpArea = false;
+
+	//
+	// Crouching
+	//
+	if (!m_improv->IsUsingLadder())
+	{
+		// because hostage crouching is not really supported by the engine,
+		// if we are standing in a crouch area, we must crouch to avoid collisions
+		if (m_improv->GetLastKnownArea() && 
+			m_improv->GetLastKnownArea()->GetAttributes() & NAV_MESH_CROUCH && 
+			!(m_improv->GetLastKnownArea()->GetAttributes() & NAV_MESH_JUMP))
+		{
+			m_improv->Crouch();
+		}
+
+		// if we are approaching a crouch area, crouch
+		// if there are no crouch areas coming up, stand
+		const float crouchRange = 50.0f;
+		bool didCrouch = false;
+		for( int i=m_segmentIndex; i<m_path->GetSegmentCount(); ++i )
+		{
+			const CNavArea *to = (*m_path)[i]->area;
+
+			// if there is a jump area on the way to the crouch area, don't crouch as it messes up the jump
+			if (to->GetAttributes() & NAV_MESH_JUMP)
+			{
+				isApproachingJumpArea = true;
+				break;
+			}
+
+			Vector close;
+			to->GetClosestPointOnArea( m_improv->GetCentroid(), &close );
+
+			if ((close - m_improv->GetFeet()).AsVector2D().IsLengthGreaterThan( crouchRange ))
+				break;
+
+			if (to->GetAttributes() & NAV_MESH_CROUCH)
+			{
+				m_improv->Crouch();
+				didCrouch = true;
+				break;
+			}
+
+		}
+
+		if (!didCrouch && !m_improv->IsJumping())
+		{
+			// no crouch areas coming up
+			m_improv->StandUp();
+		}
+
+	}	// end crouching logic
+
+
+	if (m_isDebug)
+	{
+		m_path->Draw();
+		UTIL_DrawBeamPoints( m_improv->GetCentroid(), m_goal + Vector( 0, 0, StepHeight ), 1, 255, 0, 255 );
+		UTIL_DrawBeamPoints( m_goal + Vector( 0, 0, StepHeight ), m_improv->GetCentroid(), 1, 255, 0, 255 );
+	}
+
+	// check if improv becomes stuck
+	m_stuckMonitor.Update( m_improv );
+
+
+	// if improv has been stuck for too long, give up
+	const float giveUpTime = 2.0f;
+	if (m_stuckMonitor.GetDuration() > giveUpTime)
+	{
+		m_improv->OnMoveToFailure( m_path->GetEndpoint(), CImprovLocomotor::FAIL_STUCK );
+		m_path->Invalidate();
+		return;
+	}
+
+
+	// if our goal is high above us, we must have fallen
+	if (m_goal.z - m_improv->GetFeet().z > JumpCrouchHeight)
+	{
+		const float closeRange = 75.0f;
+		Vector2D to( m_improv->GetFeet().x - m_goal.x, m_improv->GetFeet().y - m_goal.y );
+		if (to.IsLengthLessThan( closeRange ))
+		{
+			// we can't reach the goal position
+			// check if we can reach the next node, in case this was a "jump down" situation
+			const CNavPath::PathSegment *nextNode = (*m_path)[ m_behindIndex+1 ];
+			if (m_behindIndex >=0 && nextNode)
+			{
+				if (nextNode->pos.z - m_improv->GetFeet().z > JumpCrouchHeight)
+				{
+					// the next node is too high, too - we really did fall of the path
+					m_improv->OnMoveToFailure( m_path->GetEndpoint(), CImprovLocomotor::FAIL_FELL_OFF );
+					m_path->Invalidate();
+					return;
+				}
+			}
+			else
+			{
+				// fell trying to get to the last node in the path
+				m_improv->OnMoveToFailure( m_path->GetEndpoint(), CImprovLocomotor::FAIL_FELL_OFF );
+				m_path->Invalidate();
+				return;
+			}
+		}
+	}
+
+
+	// avoid small obstacles
+	if (avoidObstacles && !isApproachingJumpArea && !m_improv->IsJumping() && m_segmentIndex < m_path->GetSegmentCount()-1)
+	{
+		FeelerReflexAdjustment( &m_goal );
+
+		// currently, this is only used for hostages, and their collision physics stinks
+		// do more feeler checks to avoid short obstacles
+		/*
+		const float inc = 0.25f;
+		for( float t = 0.5f; t < 1.0f; t += inc )
+		{
+			FeelerReflexAdjustment( &m_goal, t * StepHeight );
+		}
+		*/
+
+	}
+
+	// move improv along path
+	m_improv->TrackPath( m_goal, deltaT );
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Return the closest point to our current position on our current path
+ * If "local" is true, only check the portion of the path surrounding m_pathIndex.
+ */
+int CNavPathFollower::FindOurPositionOnPath( Vector *close, bool local ) const
+{
+	if (!m_path->IsValid())
+		return -1;
+
+	Vector along, toFeet;
+	Vector feet = m_improv->GetFeet();
+	Vector eyes = m_improv->GetEyes();
+	Vector pos;
+	const Vector *from, *to;
+	float length;
+	float closeLength;
+	float closeDistSq = 9999999999.9;
+	int closeIndex = -1;
+	float distSq;
+
+	int start, end;
+
+	if (local)
+	{
+		start = m_segmentIndex - 3;
+		if (start < 1)
+			start = 1;
+
+		end = m_segmentIndex + 3;
+		if (end > m_path->GetSegmentCount())
+			end = m_path->GetSegmentCount();
+	}
+	else
+	{
+		start = 1;
+		end = m_path->GetSegmentCount();
+	}
+
+	for( int i=start; i<end; ++i )
+	{
+		from = &(*m_path)[i-1]->pos;
+		to = &(*m_path)[i]->pos;
+
+		// compute ray along this path segment
+		along = *to - *from;
+
+		// make it a unit vector along the path
+		length = along.NormalizeInPlace();
+
+		// compute vector from start of segment to our point
+		toFeet = feet - *from;
+
+		// find distance of closest point on ray
+		closeLength = DotProduct( toFeet, along );
+
+		// constrain point to be on path segment
+		if (closeLength <= 0.0f)
+			pos = *from;
+		else if (closeLength >= length)
+			pos = *to;
+		else
+			pos = *from + closeLength * along;
+
+		distSq = (pos - feet).LengthSqr();
+
+		// keep the closest point so far
+		if (distSq < closeDistSq)
+		{
+			// don't use points we cant see
+			Vector probe = pos + Vector( 0, 0, HalfHumanHeight );
+			if (!IsWalkableTraceLineClear( eyes, probe, WALK_THRU_DOORS | WALK_THRU_BREAKABLES ))
+				continue;
+
+			// don't use points we cant reach
+			//if (!IsStraightLinePathWalkable( &pos ))
+			//	continue;
+
+			closeDistSq = distSq;
+			if (close)
+				*close = pos;
+			closeIndex = i-1;
+		}
+	}
+
+	return closeIndex;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Compute a point a fixed distance ahead along our path.
+ * Returns path index just after point.
+ */
+int CNavPathFollower::FindPathPoint( float aheadRange, Vector *point, int *prevIndex )
+{
+	// find path index just past aheadRange
+	int afterIndex;
+
+	// finds the closest point on local area of path, and returns the path index just prior to it
+	Vector close;
+	int startIndex = FindOurPositionOnPath( &close, true );
+
+	if (prevIndex)
+		*prevIndex = startIndex;
+
+	if (startIndex <= 0)
+	{
+		// went off the end of the path
+		// or next point in path is unwalkable (ie: jump-down)
+		// keep same point
+		return m_segmentIndex;
+	}
+
+	// if we are crouching, just follow the path exactly
+	if (m_improv->IsCrouching())
+	{
+		// we want to move to the immediately next point along the path from where we are now
+		int index = startIndex+1;
+		if (index >= m_path->GetSegmentCount())
+			index = m_path->GetSegmentCount()-1;
+
+		*point = (*m_path)[ index ]->pos;
+
+		// if we are very close to the next point in the path, skip ahead to the next one to avoid wiggling
+		// we must do a 2D check here, in case the goal point is floating in space due to jump down, etc
+		const float closeEpsilon = 20.0f;	// 10
+		while ((*point - close).AsVector2D().IsLengthLessThan( closeEpsilon ))
+		{
+			++index;
+
+			if (index >= m_path->GetSegmentCount())
+			{
+				index = m_path->GetSegmentCount()-1;
+				break;
+			}
+
+			*point = (*m_path)[ index ]->pos;
+		}
+
+		return index;
+	}
+
+	// make sure we use a node a minimum distance ahead of us, to avoid wiggling 
+	while (startIndex < m_path->GetSegmentCount()-1)
+	{
+		Vector pos = (*m_path)[ startIndex+1 ]->pos;
+
+		// we must do a 2D check here, in case the goal point is floating in space due to jump down, etc
+		const float closeEpsilon = 20.0f;
+		if ((pos - close).AsVector2D().IsLengthLessThan( closeEpsilon ))
+		{
+			++startIndex;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	// if we hit a ladder or jump area, must stop (dont use ladder behind us)
+	if (startIndex > m_segmentIndex && startIndex < m_path->GetSegmentCount() && 
+			((*m_path)[ startIndex ]->ladder || (*m_path)[ startIndex ]->area->GetAttributes() & NAV_MESH_JUMP))
+	{
+		*point = (*m_path)[ startIndex ]->pos;
+		return startIndex;
+	}
+
+	// we need the point just *ahead* of us
+	++startIndex;
+	if (startIndex >= m_path->GetSegmentCount())
+		startIndex = m_path->GetSegmentCount()-1;
+
+	// if we hit a ladder or jump area, must stop
+	if (startIndex < m_path->GetSegmentCount() && 
+			((*m_path)[ startIndex ]->ladder || (*m_path)[ startIndex ]->area->GetAttributes() & NAV_MESH_JUMP))
+	{
+		*point = (*m_path)[ startIndex ]->pos;
+		return startIndex;
+	}
+
+	// note direction of path segment we are standing on
+	Vector initDir = (*m_path)[ startIndex ]->pos - (*m_path)[ startIndex-1 ]->pos;
+	initDir.NormalizeInPlace();
+
+	Vector feet = m_improv->GetFeet();
+	Vector eyes = m_improv->GetEyes();
+	float rangeSoFar = 0;
+
+	// this flag is true if our ahead point is visible
+	bool visible = true;
+
+	Vector prevDir = initDir;
+
+	// step along the path until we pass aheadRange
+	bool isCorner = false;
+	int i;
+	for( i=startIndex; i<m_path->GetSegmentCount(); ++i )
+	{
+		Vector pos = (*m_path)[i]->pos;
+		Vector to = pos - (*m_path)[i-1]->pos;
+		Vector dir = to;
+		dir.NormalizeInPlace();
+
+		// don't allow path to double-back from our starting direction (going upstairs, down curved passages, etc)
+		if (DotProduct( dir, initDir ) < 0.0f) // -0.25f
+		{
+			--i;
+			break;
+		}
+
+		// if the path turns a corner, we want to move towards the corner, not into the wall/stairs/etc
+		if (DotProduct( dir, prevDir ) < 0.5f)
+		{
+			isCorner = true;
+			--i;
+			break;
+		}
+		prevDir = dir;
+
+		// don't use points we cant see
+		Vector probe = pos + Vector( 0, 0, HalfHumanHeight );
+		if (!IsWalkableTraceLineClear( eyes, probe, WALK_THRU_BREAKABLES ))
+		{
+			// presumably, the previous point is visible, so we will interpolate
+			visible = false;
+			break;
+		}
+
+		// if we encounter a ladder or jump area, we must stop
+		if (i < m_path->GetSegmentCount() && 
+				((*m_path)[ i ]->ladder || (*m_path)[ i ]->area->GetAttributes() & NAV_MESH_JUMP))
+			break;
+
+		// Check straight-line path from our current position to this position
+		// Test for un-jumpable height change, or unrecoverable fall
+		//if (!IsStraightLinePathWalkable( &pos ))
+		//{
+		//	--i;
+		//	break;
+		//}
+
+		Vector along = (i == startIndex) ? (pos - feet) : (pos - (*m_path)[i-1]->pos);
+		rangeSoFar += along.Length2D();
+
+		// stop if we have gone farther than aheadRange
+		if (rangeSoFar >= aheadRange)
+			break;
+	}
+
+	if (i < startIndex)
+		afterIndex = startIndex;
+	else if (i < m_path->GetSegmentCount())
+		afterIndex = i;
+	else
+		afterIndex = m_path->GetSegmentCount()-1;
+
+
+	// compute point on the path at aheadRange
+	if (afterIndex == 0)
+	{
+		*point = (*m_path)[0]->pos;
+	}
+	else
+	{
+		// interpolate point along path segment
+		const Vector *afterPoint = &(*m_path)[ afterIndex ]->pos;
+		const Vector *beforePoint = &(*m_path)[ afterIndex-1 ]->pos;
+
+		Vector to = *afterPoint - *beforePoint;
+		float length = to.Length2D();
+
+		float t = 1.0f - ((rangeSoFar - aheadRange) / length);
+
+		if (t < 0.0f)
+			t = 0.0f;
+		else if (t > 1.0f)
+			t = 1.0f;
+
+		*point = *beforePoint + t * to;
+
+		// if afterPoint wasn't visible, slide point backwards towards beforePoint until it is
+		if (!visible)
+		{
+			const float sightStepSize = 25.0f;
+			float dt = sightStepSize / length;
+
+			Vector probe = *point + Vector( 0, 0, HalfHumanHeight );
+			while( t > 0.0f && !IsWalkableTraceLineClear( eyes,  probe, WALK_THRU_BREAKABLES ) )
+			{
+				t -= dt;
+				*point = *beforePoint + t * to;
+			}
+
+			if (t <= 0.0f)
+				*point = *beforePoint;
+		}
+	}
+
+	// if position found is too close to us, or behind us, force it farther down the path so we don't stop and wiggle
+	if (!isCorner)
+	{
+		const float epsilon = 50.0f;
+		Vector2D toPoint;
+		Vector2D centroid( m_improv->GetCentroid().x, m_improv->GetCentroid().y );
+		
+		toPoint.x = point->x - centroid.x;
+		toPoint.y = point->y - centroid.y;
+
+		if (DotProduct2D( toPoint, initDir.AsVector2D() ) < 0.0f || toPoint.IsLengthLessThan( epsilon ))
+		{
+			int i;
+			for( i=startIndex; i<m_path->GetSegmentCount(); ++i )
+			{
+				toPoint.x = (*m_path)[i]->pos.x - centroid.x;
+				toPoint.y = (*m_path)[i]->pos.y - centroid.y;
+				if ((*m_path)[i]->ladder || (*m_path)[i]->area->GetAttributes() & NAV_MESH_JUMP || toPoint.IsLengthGreaterThan( epsilon ))
+				{
+					*point = (*m_path)[i]->pos;
+					startIndex = i;
+					break;
+				}
+			}
+
+			if (i == m_path->GetSegmentCount())
+			{
+				*point = m_path->GetEndpoint();
+				startIndex = m_path->GetSegmentCount()-1;
+			}
+		}
+	}
+
+	// m_pathIndex should always be the next point on the path, even if we're not moving directly towards it
+	if (startIndex < m_path->GetSegmentCount())
+		return startIndex;
+
+	return m_path->GetSegmentCount()-1;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Do reflex avoidance movements if our "feelers" are touched
+ * @todo Parameterize feeler spacing
+ */
+void CNavPathFollower::FeelerReflexAdjustment( Vector *goalPosition, float height )
+{
+	// if we are in a "precise" area, do not do feeler adjustments
+	if (m_improv->GetLastKnownArea() && m_improv->GetLastKnownArea()->GetAttributes() & NAV_MESH_PRECISE)
+		return;
+
+	// use the direction towards the goal
+	Vector dir = *goalPosition - m_improv->GetFeet();
+	dir.z = 0.0f;
+	dir.NormalizeInPlace();
+
+	Vector lat( -dir.y, dir.x, 0.0f );
+
+	const float feelerOffset = (m_improv->IsCrouching()) ? 15.0f : 20.0f;	// 15, 20
+	const float feelerLengthRun = 50.0f;	// 100 - too long for tight hallways (cs_747)
+	const float feelerLengthWalk = 30.0f;
+
+	const float feelerHeight = (height > 0.0f) ? height : StepHeight + 0.1f;	// if obstacle is lower than StepHeight, we'll walk right over it
+
+	float feelerLength = (m_improv->IsRunning()) ? feelerLengthRun : feelerLengthWalk;
+
+	feelerLength = (m_improv->IsCrouching()) ? 20.0f : feelerLength;
+
+	//
+	// Feelers must follow floor slope
+	//
+	float ground;
+	Vector normal;
+	if (m_improv->GetSimpleGroundHeightWithFloor( m_improv->GetEyes(), &ground, &normal ) == false)
+		return;
+
+	// get forward vector along floor
+	dir = CrossProduct( lat, normal );
+
+	// correct the sideways vector
+	lat = CrossProduct( dir, normal );
+
+
+	Vector feet = m_improv->GetFeet();
+	feet.z += feelerHeight;
+
+	Vector from = feet + feelerOffset * lat;
+	Vector to = from + feelerLength * dir;
+
+	bool leftClear = IsWalkableTraceLineClear( from, to, WALK_THRU_DOORS | WALK_THRU_BREAKABLES );
+
+	// draw debug beams
+	if (m_isDebug)
+	{
+		if (leftClear)
+			UTIL_DrawBeamPoints( from, to, 1, 0, 255, 0 );
+		else
+			UTIL_DrawBeamPoints( from, to, 1, 255, 0, 0 );
+	}
+
+	from = feet - feelerOffset * lat;
+	to = from + feelerLength * dir;
+
+	bool rightClear = IsWalkableTraceLineClear( from, to, WALK_THRU_DOORS | WALK_THRU_BREAKABLES );
+
+	// draw debug beams
+	if (m_isDebug)
+	{
+		if (rightClear)
+			UTIL_DrawBeamPoints( from, to, 1, 0, 255, 0 );
+		else
+			UTIL_DrawBeamPoints( from, to, 1, 255, 0, 0 );
+	}
+
+
+
+	const float avoidRange = (m_improv->IsCrouching()) ? 150.0f : 300.0f;
+
+	if (!rightClear)
+	{
+		if (leftClear)
+		{
+			// right hit, left clear - veer left
+			*goalPosition = *goalPosition + avoidRange * lat;
+			//*goalPosition = m_improv->GetFeet() + avoidRange * lat;
+
+			//m_improv->StrafeLeft();
+		}
+	}
+	else if (!leftClear)
+	{
+		// right clear, left hit - veer right
+		*goalPosition = *goalPosition - avoidRange * lat;
+		//*goalPosition = m_improv->GetFeet() - avoidRange * lat;
+
+		//m_improv->StrafeRight();
+	}
+
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Reset the stuck-checker.
+ */
+CStuckMonitor::CStuckMonitor( void )
+{
+	m_isStuck = false;
+	m_avgVelIndex = 0;
+	m_avgVelCount = 0;
+}
+
+/**
+ * Reset the stuck-checker.
+ */
+void CStuckMonitor::Reset( void )
+{
+	m_isStuck = false;
+	m_avgVelIndex = 0;
+	m_avgVelCount = 0;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Test if the improv has become stuck
+ */
+void CStuckMonitor::Update( CImprovLocomotor *improv )
+{
+	if (m_isStuck)
+	{
+		// improv is stuck - see if it has moved far enough to be considered unstuck
+		const float unstuckRange = 75.0f;
+		if ((improv->GetCentroid() - m_stuckSpot).IsLengthGreaterThan( unstuckRange ))
+		{
+			// no longer stuck
+			Reset();
+			//PrintIfWatched( "UN-STUCK\n" );
+		}
+	}
+	else
+	{
+		// check if improv has become stuck
+
+		// compute average velocity over a short period (for stuck check)
+		Vector vel = improv->GetCentroid() - m_lastCentroid;
+
+		// if we are jumping, ignore Z
+		//if (improv->IsJumping())
+		//	vel.z = 0.0f;
+
+		// ignore Z unless we are on a ladder (which is only Z)
+		if (!improv->IsUsingLadder())
+			vel.z = 0.0f;
+
+		// cannot be Length2D, or will break ladder movement (they are only Z)
+		float moveDist = vel.Length();
+
+		float deltaT = gpGlobals->curtime - m_lastTime;
+		if (deltaT <= 0.0f)
+			return;
+
+		m_lastTime = gpGlobals->curtime;
+
+		// compute current velocity
+		m_avgVel[ m_avgVelIndex++ ] = moveDist/deltaT;
+
+		if (m_avgVelIndex == MAX_VEL_SAMPLES)
+			m_avgVelIndex = 0;
+
+		if (m_avgVelCount < MAX_VEL_SAMPLES)
+		{
+			++m_avgVelCount;
+		}
+		else
+		{
+			// we have enough samples to know if we're stuck
+
+			float avgVel = 0.0f;
+			for( int t=0; t<m_avgVelCount; ++t )
+				avgVel += m_avgVel[t];
+
+			avgVel /= m_avgVelCount;
+
+			// cannot make this velocity too high, or actors will get "stuck" when going down ladders
+			float stuckVel = (improv->IsUsingLadder()) ? 10.0f : 20.0f;
+
+			if (avgVel < stuckVel)
+			{
+				// note when and where we initially become stuck
+				m_stuckTimer.Start();
+				m_stuckSpot = improv->GetCentroid();
+				m_isStuck = true;
+			}
+		}
+	}
+
+	// always need to track this
+	m_lastCentroid = improv->GetCentroid();
+}
+
diff --git a/game/shared/cstrike/bot/nav_path.h b/game/shared/cstrike/bot/nav_path.h
new file mode 100644
index 00000000..2542b841
--- /dev/null
+++ b/game/shared/cstrike/bot/nav_path.h
@@ -0,0 +1,246 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+// nav_path.h
+// Navigation Path encapsulation
+// Author: Michael S. Booth (mike@turtlerockstudios.com), November 2003
+
+#ifndef _NAV_PATH_H_
+#define _NAV_PATH_H_
+
+#include "cs_nav_area.h"
+#include "bot_util.h"
+
+class CImprovLocomotor;
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * The CNavPath class encapsulates a path through space
+ */
+class CNavPath
+{
+public:
+	CNavPath( void )
+	{
+		m_segmentCount = 0;
+	}
+
+	struct PathSegment
+	{
+		CNavArea *area;											///< the area along the path
+		NavTraverseType how;									///< how to enter this area from the previous one
+		Vector pos;												///< our movement goal position at this point in the path
+		const CNavLadder *ladder;								///< if "how" refers to a ladder, this is it
+	};
+
+	const PathSegment * operator[] ( int i ) const		{ return (i >= 0 && i < m_segmentCount) ? &m_path[i] : NULL; }
+	const PathSegment *GetSegment( int i ) const		{ return (i >= 0 && i < m_segmentCount) ? &m_path[i] : NULL; }
+	int GetSegmentCount( void ) const					{ return m_segmentCount; }
+	const Vector &GetEndpoint( void ) const				{ return m_path[ m_segmentCount-1 ].pos; }
+	bool IsAtEnd( const Vector &pos ) const;					///< return true if position is at the end of the path
+
+	float GetLength( void ) const;								///< return length of path from start to finish
+	bool GetPointAlongPath( float distAlong, Vector *pointOnPath ) const;	///< return point a given distance along the path - if distance is out of path bounds, point is clamped to start/end
+
+	/// return the node index closest to the given distance along the path without going over - returns (-1) if error
+	int GetSegmentIndexAlongPath( float distAlong ) const;
+
+	bool IsValid( void ) const	{ return (m_segmentCount > 0); }
+	void Invalidate( void )		{ m_segmentCount = 0; }
+
+	void Draw( const Vector &color = Vector( 1.0f, 0.3f, 0 ) );	///< draw the path for debugging
+
+	/// compute closest point on path to given point
+	bool FindClosestPointOnPath( const Vector *worldPos, int startIndex, int endIndex, Vector *close ) const;
+
+	void Optimize( void );
+	
+	/**
+	 * Compute shortest path from 'start' to 'goal' via A* algorithm.
+	 * If returns true, path was build to the goal position.
+	 * If returns false, path may either be invalid (use IsValid() to check), or valid but 
+	 * doesn't reach all the way to the goal.
+	 */
+	template< typename CostFunctor >
+	bool Compute( const Vector &start, const Vector &goal, CostFunctor &costFunc )
+	{
+		Invalidate();
+
+		CNavArea *startArea = TheNavMesh->GetNearestNavArea( start + Vector( 0.0f, 0.0f, 1.0f ) );
+		if (startArea == NULL)
+		{
+			return false;
+		}
+
+		CNavArea *goalArea = TheNavMesh->GetNavArea( goal );
+
+		// if we are already in the goal area, build trivial path
+		if (startArea == goalArea)
+		{
+			BuildTrivialPath( start, goal );
+			return true;
+		}
+
+		// make sure path end position is on the ground
+		Vector pathEndPosition = goal;
+		if (goalArea)
+		{
+			pathEndPosition.z = goalArea->GetZ( pathEndPosition );
+		}
+		else
+		{
+			TheNavMesh->GetGroundHeight( pathEndPosition, &pathEndPosition.z );
+		}
+
+		//
+		// Compute shortest path to goal
+		//
+		CNavArea *closestArea;
+		bool pathResult = NavAreaBuildPath( startArea, goalArea, &goal, costFunc, &closestArea );
+
+		//
+		// Build path by following parent links
+		//
+
+		// get count
+		int count = 0;
+		CNavArea *area;
+		for( area = closestArea; area; area = area->GetParent() )
+		{
+			++count;
+		}
+
+		// save room for endpoint
+		if (count > MAX_PATH_SEGMENTS-1)
+		{
+			count = MAX_PATH_SEGMENTS-1;
+		}
+
+		if (count == 0)
+		{
+			return false;
+		}
+
+		if (count == 1)
+		{
+			BuildTrivialPath( start, goal );
+			return true;
+		}
+
+		// build path
+		m_segmentCount = count;
+		for( area = closestArea; count && area; area = area->GetParent() )
+		{
+			--count;
+			m_path[ count ].area = area;
+			m_path[ count ].how = area->GetParentHow();
+		}
+
+		// compute path positions
+		if (ComputePathPositions() == false)
+		{
+			//PrintIfWatched( "CNavPath::Compute: Error building path\n" );
+			Invalidate();
+			return false;
+		}
+
+		// append path end position
+		m_path[ m_segmentCount ].area = closestArea;
+		m_path[ m_segmentCount ].pos = pathEndPosition;
+		m_path[ m_segmentCount ].ladder = NULL;
+		m_path[ m_segmentCount ].how = NUM_TRAVERSE_TYPES;
+		++m_segmentCount;
+
+		return pathResult;
+	}
+
+private:
+	enum { MAX_PATH_SEGMENTS = 256 };
+	PathSegment m_path[ MAX_PATH_SEGMENTS ];
+	int m_segmentCount;
+
+	bool ComputePathPositions( void );									///< determine actual path positions 
+	bool BuildTrivialPath( const Vector &start, const Vector &goal );	///< utility function for when start and goal are in the same area
+
+	int FindNextOccludedNode( int anchor );								///< used by Optimize()
+};
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Monitor improv movement and determine if it becomes stuck
+ */
+class CStuckMonitor
+{
+public:
+	CStuckMonitor( void );
+
+	void Reset( void );
+	void Update( CImprovLocomotor *improv );
+	bool IsStuck( void ) const		{ return m_isStuck; }
+
+	float GetDuration( void ) const	{ return (m_isStuck) ? m_stuckTimer.GetElapsedTime() : 0.0f; }
+
+private:
+	bool m_isStuck;													///< if true, we are stuck
+	Vector m_stuckSpot;												///< the location where we became stuck
+	IntervalTimer m_stuckTimer;										///< how long we have been stuck
+
+	enum { MAX_VEL_SAMPLES = 5 };
+	float m_avgVel[ MAX_VEL_SAMPLES ];
+	int m_avgVelIndex;
+	int m_avgVelCount;
+	Vector m_lastCentroid;
+	float m_lastTime;
+};
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * The CNavPathFollower class implements path following behavior
+ */
+class CNavPathFollower
+{
+public:
+	CNavPathFollower( void );
+
+	void SetImprov( CImprovLocomotor *improv ) { m_improv = improv; }
+	void SetPath( CNavPath *path ) { m_path = path; }
+
+	void Reset( void );
+
+	#define DONT_AVOID_OBSTACLES false
+	void Update( float deltaT, bool avoidObstacles = true );		///< move improv along path
+	void Debug( bool status )		{ m_isDebug = status; }			///< turn debugging on/off
+
+	bool IsStuck( void ) const		{ return m_stuckMonitor.IsStuck(); }	///< return true if improv is stuck 
+	void ResetStuck( void )			{ m_stuckMonitor.Reset(); }
+	float GetStuckDuration( void ) const	{ return m_stuckMonitor.GetDuration(); }	///< return how long we've been stuck
+
+	void FeelerReflexAdjustment( Vector *goalPosition, float height = -1.0f );	///< adjust goal position if "feelers" are touched
+
+private:
+	CImprovLocomotor *m_improv;										///< who is doing the path following
+
+	CNavPath *m_path;												///< the path being followed
+
+	int m_segmentIndex;												///< the point on the path the improv is moving towards
+	int m_behindIndex;												///< index of the node on the path just behind us
+	Vector m_goal;													///< last computed follow goal
+
+	bool m_isLadderStarted;
+
+	bool m_isDebug;
+
+	int FindOurPositionOnPath( Vector *close, bool local ) const;	///< return the closest point to our current position on current path
+	int FindPathPoint( float aheadRange, Vector *point, int *prevIndex );	///< compute a point a fixed distance ahead along our path.
+
+	CStuckMonitor m_stuckMonitor;
+};
+
+
+
+#endif	// _NAV_PATH_H_
+
diff --git a/game/shared/cstrike/bot/shared_util.cpp b/game/shared/cstrike/bot/shared_util.cpp
new file mode 100644
index 00000000..4d66845a
--- /dev/null
+++ b/game/shared/cstrike/bot/shared_util.cpp
@@ -0,0 +1,207 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: dll-agnostic routines (no dll dependencies here)
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Matthew D. Campbell (matt@turtlerockstudios.com), 2003
+
+#include "cbase.h"
+
+#include <ctype.h>
+#include "shared_util.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static char s_shared_token[ 1500 ];
+static char s_shared_quote = '\"';
+
+//--------------------------------------------------------------------------------------------------------------
+char * SharedVarArgs(const char *format, ...)
+{
+	va_list argptr;
+	const int BufLen = 1024;
+	const int NumBuffers = 4;
+	static char string[NumBuffers][BufLen];
+	static int curstring = 0;
+	
+	curstring = ( curstring + 1 ) % NumBuffers;
+
+	va_start (argptr, format);
+	V_vsprintf_safe( string[curstring], format, argptr );
+	va_end (argptr);
+
+	return string[curstring];  
+}
+
+//--------------------------------------------------------------------------------------------------------------
+char * BufPrintf(char *buf, int& len, const char *fmt, ...)
+{
+	if (len <= 0)
+		return NULL;
+
+	va_list argptr;
+
+	va_start(argptr, fmt);
+	_vsnprintf(buf, len, fmt, argptr);
+	buf[ len - 1 ] = 0;
+	va_end(argptr);
+
+	len -= strlen(buf);
+	return buf + strlen(buf);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+wchar_t * BufWPrintf(wchar_t *buf, int& len, const wchar_t *fmt, ...)
+{
+	if (len <= 0)
+		return NULL;
+
+	va_list argptr;
+
+	va_start(argptr, fmt);
+#ifdef WIN32
+	_vsnwprintf(buf, len, fmt, argptr);
+#else
+	vswprintf( buf, len, fmt, argptr );
+#endif
+	buf[ len - 1 ] = 0;
+	va_end(argptr);
+
+	len -= wcslen(buf);
+	return buf + wcslen(buf);
+}
+
+//--------------------------------------------------------------------------------------------------------------
+const wchar_t * NumAsWString( int val )
+{
+	const int BufLen = 16;
+	static wchar_t buf[BufLen];
+	int len = BufLen;
+	BufWPrintf( buf, len, L"%d", val );
+	return buf;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+const char * NumAsString( int val )
+{
+	const int BufLen = 16;
+	static char buf[BufLen];
+	int len = BufLen;
+	BufPrintf( buf, len, "%d", val );
+	return buf;
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Returns the token parsed by SharedParse()
+ */
+char *SharedGetToken( void )
+{
+	return s_shared_token;
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Returns the token parsed by SharedParse()
+ */
+void SharedSetQuoteChar( char c )
+{
+	s_shared_quote = c;
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Parse a token out of a string
+ */
+const char *SharedParse( const char *data )
+{
+	int             c;
+	int             len;
+	
+	len = 0;
+	s_shared_token[0] = 0;
+	
+	if (!data)
+		return NULL;
+		
+// skip whitespace
+skipwhite:
+	while ( (c = *data) <= ' ')
+	{
+		if (c == 0)
+			return NULL;                    // end of file;
+		data++;
+	}
+	
+// skip // comments
+	if (c=='/' && data[1] == '/')
+	{
+		while (*data && *data != '\n')
+			data++;
+		goto skipwhite;
+	}
+	
+
+// handle quoted strings specially
+	if (c == s_shared_quote)
+	{
+		data++;
+		while (1)
+		{
+			c = *data++;
+			if (c==s_shared_quote || !c)
+			{
+				s_shared_token[len] = 0;
+				return data;
+			}
+			s_shared_token[len] = c;
+			len++;
+		}
+	}
+
+// parse single characters
+	if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c == ',' )
+	{
+		s_shared_token[len] = c;
+		len++;
+		s_shared_token[len] = 0;
+		return data+1;
+	}
+
+// parse a regular word
+	do
+	{
+		s_shared_token[len] = c;
+		data++;
+		len++;
+		c = *data;
+	if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c == ',' )
+			break;
+	} while (c>32);
+	
+	s_shared_token[len] = 0;
+	return data;
+}
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if additional data is waiting to be processed on this line
+ */
+bool SharedTokenWaiting( const char *buffer )
+{
+	const char *p;
+
+	p = buffer;
+	while ( *p && *p!='\n')
+	{
+		if ( !isspace( *p ) || isalnum( *p ) )
+			return true;
+
+		p++;
+	}
+
+	return false;
+}
diff --git a/game/shared/cstrike/bot/shared_util.h b/game/shared/cstrike/bot/shared_util.h
new file mode 100644
index 00000000..664dcd74
--- /dev/null
+++ b/game/shared/cstrike/bot/shared_util.h
@@ -0,0 +1,83 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: dll-agnostic routines (no dll dependencies here)
+//
+// $NoKeywords: $
+//=============================================================================//
+
+// Author: Matthew D. Campbell (matt@turtlerockstudios.com), 2003
+
+#ifndef SHARED_UTIL_H
+#define SHARED_UTIL_H
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Returns the token parsed by SharedParse()
+ */
+char *SharedGetToken( void );
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Sets the character used to delimit quoted strings.  Default is '\"'.  Be sure to set it back when done.
+ */
+void SharedSetQuoteChar( char c );
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Parse a token out of a string
+ */
+const char *SharedParse( const char *data );
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Returns true if additional data is waiting to be processed on this line
+ */
+bool SharedTokenWaiting( const char *buffer );
+
+//--------------------------------------------------------------------------------------------------------
+/**
+ * Simple utility function to allocate memory and duplicate a string
+ */
+inline char *CloneString( const char *str )
+{
+	char *cloneStr = new char [ strlen(str)+1 ];
+	strcpy( cloneStr, str );
+	return cloneStr;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  snprintf-alike that allows multiple prints into a buffer
+ */
+char * BufPrintf(char *buf, int& len, PRINTF_FORMAT_STRING const char *fmt, ...);
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  wide char version of BufPrintf
+ */
+wchar_t * BufWPrintf(wchar_t *buf, int& len, PRINTF_FORMAT_STRING const wchar_t *fmt, ...);
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  convenience function that prints an int into a static wchar_t*
+ */
+const wchar_t * NumAsWString( int val );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  convenience function that prints an int into a static char*
+ */
+const char * NumAsString( int val );
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ *  convenience function that composes a string into a static char*
+ */
+char * SharedVarArgs(PRINTF_FORMAT_STRING const char *format, ...);
+
+#include "tier0/memdbgoff.h"
+
+#endif // SHARED_UTIL_H
diff --git a/game/shared/cstrike/cs_achievement_constants.h b/game/shared/cstrike/cs_achievement_constants.h
new file mode 100644
index 00000000..35d21a31
--- /dev/null
+++ b/game/shared/cstrike/cs_achievement_constants.h
@@ -0,0 +1,54 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//-------------------------------------------------------------
+// File:		cs_achievement_constants.h
+// Desc: 		Declare contants used by achievements (mostly) in one location for simpler tweaking
+// Author: 		Peter Freese <peter@hiddenpath.com>
+// Date: 		2009/03/11
+// Copyright:	© 2009 Hidden Path Entertainment
+//-------------------------------------------------------------
+
+#ifndef CS_ACHIEVEMENT_CONSTANTS_H
+#define CS_ACHIEVEMENT_CONSTANTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+namespace AchievementConsts
+{
+	const int	DefaultMinOpponentsForAchievement			= 5;
+	const int	KillingSpree_Kills							= 5;
+	const float KillingSpree_WindowTime						= 15.0f;
+	const float KillingSpreeEnder_TimeWindow				= 5.0f;
+	const int	KillEnemyTeam_MinKills						= 5;
+	const int	LastPlayerAlive_MinPlayersOnTeam			= 5;
+	const int	KillsWithMultipleGuns_MinWeapons			= 5;
+	const float	BombDefuseCloseCall_MaxTimeRemaining		= 1.0f;
+	const int	KillLowDamage_MaxHealthLeft					= 5;
+    const int   DamageNoKill_MaxHealthLeftOnKill            = 5;
+	const float	BombDefuseNeededKit_MaxTime					= 5.0f;
+	const float	FastBombPlant_Time							= 25.0f;
+	const int	KillEnemiesWhileBlind_Kills					= 1;
+    const int   KillEnemiesWhileBlindHard_Kills				= 2;
+	const int	SurviveGrenade_MinDamage                    = 80;
+	const int	KillWhenAtLowHealth_MaxHealth               = 1;
+	const int	GrenadeMultiKill_MinKills					= 3;
+	const int	BombMultiKill_MinKills						= 5;
+	const float	FastRoundWin_Time							= 30.0f;	
+	const int	UnstoppableForce_Kills						= 10;
+	const int	BreakPropsInRound_Props						= 15;
+	const int	HeadshotsInRound_Kills						= 5;	
+	const int	BreakWindowsInOfficeRound_Windows			= 14;
+	const float	FastHostageRescue_Time						= 90.0f;
+	const int	SurviveManyAttacks_NumberDamagingPlayers	= 5;
+    const float KillInAir_MinimumHeight                     = 100.0f; //100-120 is probably best. Also used for killing while in the air
+    const float KillBombPickup_MaxTime                      = 3.0f;
+    const int   WinRoundsWithoutBuying_Rounds               = 10;
+    const int   ConcurrentDominations_MinDominations        = 3;
+    const int   ExtendedDomination_AdditionalKills			= 4;
+    const int   SameUniform_MinPlayers                      = 5;
+    const int   FriendsSameUniform_MinPlayers               = 4;
+	const float KillEnemyNearBomb_MaxDistance				= 480.0f;
+	const int   GrenadeDamage_MinDamage						= 200;
+}
+
+#endif // CS_ACHIEVEMENT_CONSTANTS_H
diff --git a/game/shared/cstrike/cs_achievementdefs.h b/game/shared/cstrike/cs_achievementdefs.h
new file mode 100644
index 00000000..77615def
--- /dev/null
+++ b/game/shared/cstrike/cs_achievementdefs.h
@@ -0,0 +1,210 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Shared CS definitions.
+//
+//=============================================================================//
+
+#ifndef CS_ACHIEVEMENTDEFS_H
+#define CS_ACHIEVEMENTDEFS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+
+//=============================================================================
+// Achievement ID Definitions
+//=============================================================================
+
+
+typedef enum
+{
+    CSInvalidAchievement = -1,
+
+    // Bomb-related Achievements
+    CSBombAchievementsStart = 1000,        // First bomb-related achievement
+
+	CSWinBombPlant,
+	CSWinBombDefuse,
+	CSDefuseAndNeededKit,
+    CSBombDefuseCloseCall,
+    CSKilledDefuser,
+    CSPlantBombWithin25Seconds,
+	CSKillBombPickup,
+    CSBombMultikill,
+    CSGooseChase,
+    CSWinBombPlantAfterRecovery,
+    CSDefuseDefense,
+	CSPlantBombsLow,
+	CSDefuseBombsLow,
+
+    CSBombAchievementsEnd,                  // Must be after last bomb-related achievement
+
+
+    // Hostage-related Achievements
+    CSHostageAchievementsStart = 2000,      // First hostage-related achievement
+
+    CSRescueAllHostagesInARound,
+	CSKilledRescuer,
+	CSFastHostageRescue,
+    CSRescueHostagesLow,
+    CSRescueHostagesMid,
+
+    CSHostageAchievmentEnd,                 // Must be after last hostage-related achievement
+
+    // General Kill Achievements
+    CSKillAchievementsStart = 3000,         // First kill-related achievement
+
+    CSEnemyKillsLow,
+    CSEnemyKillsMed,
+    CSEnemyKillsHigh,
+	CSSurvivedHeadshotDueToHelmet,
+    CSKillEnemyReloading,
+    CSKillingSpree,
+    CSKillsWithMultipleGuns,
+    CSHeadshots,
+	CSAvengeFriend,
+	CSSurviveGrenade,
+	CSDominationsLow,
+	CSDominationsHigh,
+	CSRevengesLow,
+	CSRevengesHigh,
+	CSDominationOverkillsLow,
+	CSDominationOverkillsHigh,
+	CSDominationOverkillsMatch,
+	CSExtendedDomination,
+	CSConcurrentDominations,
+    CSKillEnemyBlinded,
+    CSKillEnemiesWhileBlind,
+    CSKillEnemiesWhileBlindHard,
+    CSKillsEnemyWeapon,
+    CSKillWithEveryWeapon,
+    CSWinKnifeFightsLow,
+    CSWinKnifeFightsHigh,
+    CSKilledDefuserWithGrenade,
+    CSKillSniperWithSniper,
+    CSKillSniperWithKnife,
+    CSHipShot,
+    CSKillSnipers,
+    CSKillWhenAtLowHealth,
+	CSPistolRoundKnifeKill,
+	CSWinDualDuel,
+    CSGrenadeMultikill,
+    CSKillWhileInAir,
+    CSKillEnemyInAir,
+    CSKillerAndEnemyInAir,
+	CSKillEnemyWithFormerGun,
+	CSKillTwoWithOneShot,
+	CSSnipeTwoFromSameSpot,
+
+    CSKillAchievementEnd,                   // Must be after last kill-related achievement
+
+    // Weapon-related Achievements
+    CSWeaponAchievementsStart = 4000,       // First weapon-related achievement
+
+    CSEnemyKillsDeagle,
+    CSEnemyKillsUSP,
+    CSEnemyKillsGlock,
+    CSEnemyKillsP228,
+    CSEnemyKillsElite,
+    CSEnemyKillsFiveSeven,
+    CSEnemyKillsAWP,
+    CSEnemyKillsAK47,
+    CSEnemyKillsM4A1,
+    CSEnemyKillsAUG,
+    CSEnemyKillsSG552,
+    CSEnemyKillsSG550,
+    CSEnemyKillsGALIL,
+    CSEnemyKillsFAMAS,
+    CSEnemyKillsScout,
+    CSEnemyKillsG3SG1,
+    CSEnemyKillsP90,
+    CSEnemyKillsMP5NAVY,
+    CSEnemyKillsTMP,
+    CSEnemyKillsMAC10,
+    CSEnemyKillsUMP45,
+    CSEnemyKillsM3,
+    CSEnemyKillsXM1014,
+    CSEnemyKillsM249,
+    CSEnemyKillsKnife,
+    CSEnemyKillsHEGrenade,
+    CSMetaPistol,
+    CSMetaRifle,
+    CSMetaSMG,
+    CSMetaShotgun,
+    CSMetaWeaponMaster,
+
+    CSWeaponAchievementsEnd,                // Must be after last weapon-related achievement
+
+    // General Achievements
+    CSGeneralAchievementsStart = 5000,      // First general achievement
+
+    CSWinRoundsLow,
+    CSWinRoundsMed,
+    CSWinRoundsHigh,
+	CSMoneyEarnedLow,
+	CSMoneyEarnedMed,
+	CSMoneyEarnedHigh,
+    CSGiveDamageLow,
+    CSGiveDamageMed,
+    CSGiveDamageHigh,
+    CSPosthumousGrenadeKill,
+    CSKillEnemyTeam,
+    CSLastPlayerAlive,
+    CSKillEnemyLastBullet,
+    CSKillingSpreeEnder,
+    CSDamageNoKill,
+    CSKillLowDamage,
+    CSSurviveManyAttacks,
+    CSLosslessExtermination,
+    CSFlawlessVictory,
+    CSDecalSprays,
+    CSBreakWindows,
+    CSBreakProps,
+    CSUnstoppableForce,
+    CSImmovableObject,
+    CSHeadshotsInRound,
+    CSWinPistolRoundsLow,
+    CSWinPistolRoundsMed,
+    CSWinPistolRoundsHigh,
+    CSFastRoundWin,
+    CSNightvisionDamage,
+    CSSilentWin,
+    CSBloodlessVictory,
+    CSDonateWeapons,
+    CSWinRoundsWithoutBuying,
+    CSSameUniform,
+    CSFriendsSameUniform,
+    CSCauseFriendlyFireWithFlashbang,
+	CSWinClanMatch,
+	CSCollectHolidayGifts,
+
+    CSGeneralAchievementsEnd,               // Must be after last general achievement
+
+    CSWinMapAchievementsStart = 6000,
+
+    CSWinMapCS_ASSAULT,
+    CSWinMapCS_COMPOUND,
+    CSWinMapCS_HAVANA,  
+    CSWinMapCS_ITALY,
+    CSWinMapCS_MILITIA,
+    CSWinMapCS_OFFICE,
+    CSWinMapDE_AZTEC,
+    CSWinMapDE_CBBLE,
+    CSWinMapDE_CHATEAU,
+    CSWinMapDE_DUST,
+    CSWinMapDE_DUST2,
+    CSWinMapDE_INFERNO,
+    CSWinMapDE_NUKE,
+    CSWinMapDE_PIRANESI,
+    CSWinMapDE_PORT,
+    CSWinMapDE_PRODIGY,
+    CSWinMapDE_TIDES,
+    CSWinMapDE_TRAIN,
+
+    CSWinMapAchievementsEnd                 //Must be after last map-based achievement
+
+} eCSAchievementType;
+
+
+#endif // CS_ACHIEVEMENTDEFS_H
diff --git a/game/shared/cstrike/cs_ammodef.cpp b/game/shared/cstrike/cs_ammodef.cpp
new file mode 100644
index 00000000..1b444d19
--- /dev/null
+++ b/game/shared/cstrike/cs_ammodef.cpp
@@ -0,0 +1,57 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_ammodef.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+void CCSAmmoDef::AddAmmoCost( char const* name, int cost, int buySize )
+{
+	int index = Index( name );
+	if ( index < 1 || index >= m_nAmmoIndex )
+		return;
+
+	m_csAmmo[index].buySize = buySize;
+	m_csAmmo[index].cost = cost;
+}
+
+
+//-----------------------------------------------------------------------------
+int CCSAmmoDef::GetBuySize( int index ) const
+{
+	if ( index < 1 || index >= m_nAmmoIndex )
+		return 0;
+
+	return m_csAmmo[index].buySize;
+}
+
+
+//-----------------------------------------------------------------------------
+int CCSAmmoDef::GetCost( int index ) const
+{
+	if ( index < 1 || index >= m_nAmmoIndex )
+		return 0;
+
+	return m_csAmmo[index].cost;
+}
+
+
+//-----------------------------------------------------------------------------
+CCSAmmoDef::CCSAmmoDef(void)
+{
+	memset( m_csAmmo, 0, sizeof( m_csAmmo ) );
+}
+
+
+//-----------------------------------------------------------------------------
+CCSAmmoDef::~CCSAmmoDef( void )
+{
+}
+
+//-----------------------------------------------------------------------------
diff --git a/game/shared/cstrike/cs_ammodef.h b/game/shared/cstrike/cs_ammodef.h
new file mode 100644
index 00000000..0175bcd0
--- /dev/null
+++ b/game/shared/cstrike/cs_ammodef.h
@@ -0,0 +1,55 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Holds defintion for game ammo types
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_AMMODEF_H
+#define CS_AMMODEF_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "ammodef.h"
+#include "cs_blackmarket.h"
+
+class ConVar;
+
+struct CSAmmoCost
+{
+	int	buySize;
+	int	cost;
+};
+
+//=============================================================================
+//	>> CCSAmmoDef
+//=============================================================================
+class CCSAmmoDef : public CAmmoDef
+{
+
+public:
+
+	void AddAmmoCost( char const* name, int cost, int buySize );
+
+	CCSAmmoDef(void);
+	~CCSAmmoDef( void );
+
+	int GetBuySize( int nAmmoIndex ) const;
+	int GetCost( int nAmmoIndex ) const;
+
+private:
+	CSAmmoCost	m_csAmmo[MAX_AMMO_TYPES];
+};
+
+
+// Get the global ammodef object. This is usually implemented in each mod's game rules file somewhere,
+// so the mod can setup custom ammo types.
+CCSAmmoDef* GetCSAmmoDef();
+
+
+#endif // CS_AMMODEF_H
+ 
\ No newline at end of file
diff --git a/game/shared/cstrike/cs_blackmarket.cpp b/game/shared/cstrike/cs_blackmarket.cpp
new file mode 100644
index 00000000..f68e9882
--- /dev/null
+++ b/game/shared/cstrike/cs_blackmarket.cpp
@@ -0,0 +1,147 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "cs_blackmarket.h"
+#include "weapon_csbase.h"
+#include "filesystem.h"
+#include <KeyValues.h>
+#include "cs_gamestats.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+extern int g_iRoundCount;
+
+#ifndef CLIENT_DLL
+inline void CBlackMarketElement::NetworkStateChanged()
+{
+}
+
+
+inline void CBlackMarketElement::NetworkStateChanged( void *pVar )
+{
+}
+
+blackmarket_items_t blackmarket_items[] =
+{
+	{ "kevlar",	KEVLAR_PRICE },
+	{ "assaultsuit",	ASSAULTSUIT_PRICE },
+	{ "nightvision", NVG_PRICE },
+};
+
+
+CUtlVector<CBlackMarketElement> g_BlackMarket_WeaponsBought;
+
+void TrackAutoBuyPurchases( const char *pWeaponName, CCSPlayer *pBuyer )
+{
+	if ( pBuyer->IsInAutoBuy() == false )
+		return;
+
+	if ( pBuyer->IsInAutoBuy() == true )
+	{
+		if ( Q_stristr( pWeaponName, "m4a1" ) )
+		{
+			g_iAutoBuyM4A1Purchases++;
+		}
+		else if ( Q_stristr( pWeaponName, "ak47" ) )
+		{
+			g_iAutoBuyAK47Purchases++;
+		}
+		else if ( Q_stristr( pWeaponName, "famas" ) )
+		{
+			g_iAutoBuyFamasPurchases++;
+		}
+		else if ( Q_stristr( pWeaponName, "galil" ) )
+		{
+			g_iAutoBuyGalilPurchases++;
+		}
+		else if ( Q_stristr( pWeaponName, "assault" ) )
+		{
+			g_iAutoBuyVestHelmPurchases++;
+		}
+		else if ( Q_stristr( pWeaponName, "kevlar" ) )
+		{
+			g_iAutoBuyVestPurchases++;
+		}
+	}
+}
+
+void BlackMarketAddWeapon( const char *pWeaponName, CCSPlayer *pBuyer )
+{
+	//Ignore bot purchases.
+	if ( pBuyer && pBuyer->IsBot() )
+		return;
+
+	CSWeaponID iWeaponID = AliasToWeaponID( pWeaponName );
+
+	TrackAutoBuyPurchases( pWeaponName, pBuyer );
+
+	if ( g_BlackMarket_WeaponsBought.Count() > 0 )
+	{
+		for ( int i = 0; i < g_BlackMarket_WeaponsBought.Count(); i++ )
+		{
+			if ( g_BlackMarket_WeaponsBought[i].m_iWeaponID == iWeaponID )
+			{
+				g_BlackMarket_WeaponsBought[i].m_iTimesBought++;
+				g_iWeaponPurchases[g_BlackMarket_WeaponsBought[i].m_iWeaponID]++;
+				return;
+			}
+		}
+	}
+
+	CBlackMarketElement newweapon;
+
+	newweapon.m_iWeaponID = iWeaponID;
+	newweapon.m_iTimesBought = 1;
+	newweapon.m_iPrice = 0;
+	g_iWeaponPurchases[newweapon.m_iWeaponID] = 1;
+
+	g_BlackMarket_WeaponsBought.AddToTail( newweapon );
+}
+
+int GetPistolCount( void )
+{
+	int iNumPistol = 0;
+
+	for ( int j = 1; j < WEAPON_MAX; j++ )
+	{
+		CCSWeaponInfo *pWeaponInfo = GetWeaponInfo( (CSWeaponID)j );
+
+		if ( pWeaponInfo )
+		{
+			if ( pWeaponInfo->m_WeaponType == WEAPONTYPE_PISTOL )
+			{
+				iNumPistol++;
+			}
+		}
+	}
+
+	return iNumPistol;
+}
+
+int GetRifleCount( void )
+{
+	int iNumRifle = 0;
+
+	for ( int j = 1; j < WEAPON_MAX; j++ )
+	{
+		CCSWeaponInfo *pWeaponInfo = GetWeaponInfo( (CSWeaponID)j );
+
+		if ( pWeaponInfo )
+		{
+			if ( pWeaponInfo->m_WeaponType != WEAPONTYPE_PISTOL )
+			{
+				iNumRifle++;
+			}
+		}
+	}
+
+	return iNumRifle + ARRAYSIZE( blackmarket_items );
+}
+
+#endif
\ No newline at end of file
diff --git a/game/shared/cstrike/cs_blackmarket.h b/game/shared/cstrike/cs_blackmarket.h
new file mode 100644
index 00000000..e31b8885
--- /dev/null
+++ b/game/shared/cstrike/cs_blackmarket.h
@@ -0,0 +1,89 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Holds defintion for game ammo types
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_BLACKMARKET_H
+#define CS_BLACKMARKET_H
+
+#include "cs_weapon_parse.h"
+
+#ifdef CLIENT_DLL
+#include "c_cs_player.h"
+#else
+#include "cs_player.h"
+#endif
+
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+struct blackmarket_items_t
+{
+	const char		*pClassname;
+	int				iDefaultPrice;
+};
+
+extern blackmarket_items_t blackmarket_items[];
+
+void BlackMarketAddWeapon( const char *pWeaponName, CCSPlayer *pBuyer );
+
+
+enum
+{
+	KEVLAR_PRICE = 650,
+	HELMET_PRICE = 350,
+	ASSAULTSUIT_PRICE = 1000,
+	DEFUSEKIT_PRICE = 200,
+	NVG_PRICE = 1250,
+	SHIELD_PRICE = 2200
+};
+
+#ifndef CLIENT_DLL
+class CBlackMarketElement
+{
+public:
+
+	DECLARE_CLASS_NOBASE( CBlackMarketElement );
+
+	// For CNetworkVars.
+	void NetworkStateChanged();
+	void NetworkStateChanged( void *pVar );
+
+	CBlackMarketElement()
+	{
+		m_iPrice = 0;
+		m_iTimesBought = 0;
+		m_iWeaponID = 0;
+	}
+
+	CNetworkVar( int, m_iPrice );
+	CNetworkVar( int, m_iWeaponID );
+
+	int  m_iTimesBought;
+};
+
+
+#else
+
+class C_BlackMarketElement
+{
+public:
+
+	// This allows the datatables to access private members.
+	ALLOW_DATATABLES_PRIVATE_ACCESS();
+
+	int		m_iWeaponID;
+	int		m_iPrice;
+};
+
+#define CBlackMarketElement C_BlackMarketElement
+#endif
+
+#endif // CS_BLACKMARKET_H
+ 
\ No newline at end of file
diff --git a/game/shared/cstrike/cs_gamemovement.cpp b/game/shared/cstrike/cs_gamemovement.cpp
new file mode 100644
index 00000000..fa5c52a4
--- /dev/null
+++ b/game/shared/cstrike/cs_gamemovement.cpp
@@ -0,0 +1,1144 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "gamemovement.h"
+#include "cs_gamerules.h"
+#include "in_buttons.h"
+#include "movevars_shared.h"
+#include "weapon_csbase.h"
+
+#ifdef CLIENT_DLL
+	#include "c_cs_player.h"
+#else
+	#include "cs_player.h"
+	#include "KeyValues.h"
+#endif
+
+#define STAMINA_MAX				100.0
+#define STAMINA_COST_JUMP		25.0
+#define STAMINA_COST_FALL		20.0
+#define STAMINA_RECOVER_RATE	19.0
+
+extern bool g_bMovementOptimizations;
+
+ConVar sv_timebetweenducks( "sv_timebetweenducks", "0", FCVAR_REPLICATED, "Minimum time before recognizing consecutive duck key", true, 0.0, true, 2.0 );
+ConVar sv_enableboost( "sv_enableboost", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Allow boost exploits");
+
+
+class CCSGameMovement : public CGameMovement
+{
+public:
+	DECLARE_CLASS( CCSGameMovement, CGameMovement );
+
+	CCSGameMovement();
+
+	virtual void ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove );
+	virtual bool CanAccelerate();
+	virtual bool CheckJumpButton( void );
+	virtual void PreventBunnyJumping( void );
+	virtual void ReduceTimers( void );
+	virtual void WalkMove( void );
+	virtual void AirMove( void );
+	virtual bool LadderMove( void );
+	virtual void DecayPunchAngle( void );
+	virtual void CheckParameters( void );
+
+	// allow overridden versions to respond to jumping
+	virtual void	OnJump( float fImpulse );
+	virtual void	OnLand( float fVelocity );
+
+	// Ducking
+	virtual void Duck( void );
+	virtual void FinishUnDuck( void );
+	virtual void FinishDuck( void );
+	virtual bool CanUnduck();
+	virtual void HandleDuckingSpeedCrop();
+
+
+	virtual bool OnLadder( trace_t &trace );
+	virtual float LadderDistance( void ) const
+	{
+		if ( player->GetMoveType() == MOVETYPE_LADDER )
+			return 10.0f;
+		return 2.0f;
+	}
+
+	virtual unsigned int LadderMask( void ) const
+	{
+		return MASK_PLAYERSOLID & ( ~CONTENTS_PLAYERCLIP );
+	}
+
+	virtual float ClimbSpeed( void ) const;
+	virtual float LadderLateralMultiplier( void ) const;
+
+	virtual void  TryTouchGround( const Vector& start, const Vector& end, const Vector& mins, const Vector& maxs, unsigned int fMask, int collisionGroup, trace_t& pm );
+
+
+protected:
+	virtual void PlayerMove();
+
+	void CheckForLadders( bool wasOnGround );
+	virtual unsigned int PlayerSolidMask( bool brushOnly = false );	///< returns the solid mask for the given player, so bots can have a more-restrictive set
+
+	float m_fTimeLastUnducked;
+
+public:
+	CCSPlayer *m_pCSPlayer;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: used by the TryTouchGround function to exclude non-standables from 
+// consideration
+//-----------------------------------------------------------------------------
+
+bool CheckForStandable( IHandleEntity *pHandleEntity, int contentsMask )
+{
+	CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
+
+	if ( !pEntity )
+		return false;
+
+	return ( pEntity->IsPlayer() && pEntity->GetGroundEntity() != NULL ) || pEntity->IsStandable();
+}
+
+
+// Expose our interface.
+static CCSGameMovement g_GameMovement;
+IGameMovement *g_pGameMovement = ( IGameMovement * )&g_GameMovement;
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CGameMovement, IGameMovement,INTERFACENAME_GAMEMOVEMENT, g_GameMovement );
+
+
+// ---------------------------------------------------------------------------------------- //
+// CCSGameMovement.
+// ---------------------------------------------------------------------------------------- //
+
+CCSGameMovement::CCSGameMovement()
+{
+	m_fTimeLastUnducked = 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Allow bots etc to use slightly different solid masks
+//-----------------------------------------------------------------------------
+unsigned int CCSGameMovement::PlayerSolidMask( bool brushOnly )
+{
+	bool isBot = !player || player->IsBot();
+
+	if ( brushOnly )
+	{
+		if ( isBot )
+		{
+			return MASK_PLAYERSOLID_BRUSHONLY | CONTENTS_MONSTERCLIP;
+		}
+		else
+		{
+			return MASK_PLAYERSOLID_BRUSHONLY;
+		}
+	}
+	else
+	{
+		if ( isBot )
+		{
+			return MASK_PLAYERSOLID | CONTENTS_MONSTERCLIP;
+		}
+		else
+		{
+			return MASK_PLAYERSOLID;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCSGameMovement::CheckParameters( void )
+{
+	QAngle	v_angle;
+
+	// maintaining auto-duck during jumps
+	if ( m_pCSPlayer->m_duckUntilOnGround )
+	{
+		if ( !player->GetGroundEntity() )
+		{
+			if ( mv->m_nButtons & IN_DUCK )
+			{
+				m_pCSPlayer->m_duckUntilOnGround = false; // player hit +duck, so cancel our auto duck
+			}
+			else
+			{
+				mv->m_nButtons |= IN_DUCK;
+			}
+		}
+	}
+
+	// it would be nice to put this into the player->GetPlayerMaxSpeed() method, but
+	// this flag is only stored in the move!
+	if ( mv->m_nButtons & IN_SPEED )
+	{
+		mv->m_flMaxSpeed *= CS_PLAYER_SPEED_WALK_MODIFIER;
+	}
+
+	if ( player->GetMoveType() != MOVETYPE_ISOMETRIC &&
+		 player->GetMoveType() != MOVETYPE_NOCLIP &&
+		 player->GetMoveType() != MOVETYPE_OBSERVER	)
+	{
+		float spd;
+
+		spd = ( mv->m_flForwardMove * mv->m_flForwardMove ) +
+			  ( mv->m_flSideMove * mv->m_flSideMove ) +
+			  ( mv->m_flUpMove * mv->m_flUpMove );
+
+
+		// Slow down by the speed factor
+		float flSpeedFactor = 1.0f;
+		if (player->m_pSurfaceData)
+		{
+			flSpeedFactor = player->m_pSurfaceData->game.maxSpeedFactor;
+		}
+
+		// If we have a constraint, slow down because of that too.
+		float flConstraintSpeedFactor = ComputeConstraintSpeedFactor();
+		if (flConstraintSpeedFactor < flSpeedFactor)
+			flSpeedFactor = flConstraintSpeedFactor;
+
+		// Take the player's velocity modifier into account
+		if ( FBitSet( m_pCSPlayer->GetFlags(), FL_ONGROUND ) )
+		{
+			flSpeedFactor *= m_pCSPlayer->m_flVelocityModifier;
+		}
+
+
+		mv->m_flMaxSpeed *= flSpeedFactor;
+
+		if ( g_bMovementOptimizations )
+		{
+			// Same thing but only do the sqrt if we have to.
+			if ( ( spd != 0.0 ) && ( spd > mv->m_flMaxSpeed*mv->m_flMaxSpeed ) )
+			{
+				float fRatio = mv->m_flMaxSpeed / sqrt( spd );
+				mv->m_flForwardMove *= fRatio;
+				mv->m_flSideMove    *= fRatio;
+				mv->m_flUpMove      *= fRatio;
+			}
+		}
+		else
+		{
+			spd = sqrt( spd );
+			if ( ( spd != 0.0 ) && ( spd > mv->m_flMaxSpeed ) )
+			{
+				float fRatio = mv->m_flMaxSpeed / spd;
+				mv->m_flForwardMove *= fRatio;
+				mv->m_flSideMove    *= fRatio;
+				mv->m_flUpMove      *= fRatio;
+			}
+		}
+	}
+
+
+	if ( player->GetFlags() & FL_FROZEN ||
+		 player->GetFlags() & FL_ONTRAIN || 
+		 IsDead() )
+	{
+		mv->m_flForwardMove = 0;
+		mv->m_flSideMove    = 0;
+		mv->m_flUpMove      = 0;
+	}
+
+	DecayPunchAngle();
+
+	// Take angles from command.
+	if ( !IsDead() )
+	{
+		v_angle = mv->m_vecAngles;
+		v_angle = v_angle + player->m_Local.m_vecPunchAngle;
+
+		// Now adjust roll angle
+		if ( player->GetMoveType() != MOVETYPE_ISOMETRIC  &&
+			 player->GetMoveType() != MOVETYPE_NOCLIP )
+		{
+			mv->m_vecAngles[ROLL]  = CalcRoll( v_angle, mv->m_vecVelocity, sv_rollangle.GetFloat(), sv_rollspeed.GetFloat() );
+		}
+		else
+		{
+			mv->m_vecAngles[ROLL] = 0.0; // v_angle[ ROLL ];
+		}
+		mv->m_vecAngles[PITCH] = v_angle[PITCH];
+		mv->m_vecAngles[YAW]   = v_angle[YAW];
+	}
+	else
+	{
+		mv->m_vecAngles = mv->m_vecOldAngles;
+	}
+
+	// Set dead player view_offset
+	if ( IsDead() )
+	{
+		player->SetViewOffset( VEC_DEAD_VIEWHEIGHT );
+	}
+
+	// Adjust client view angles to match values used on server.
+	if ( mv->m_vecAngles[YAW] > 180.0f )
+	{
+		mv->m_vecAngles[YAW] -= 360.0f;
+	}
+
+	// If we're standing on a player, then force them off.
+	if ( !player->IsObserver()  && ( player->GetMoveType() != MOVETYPE_LADDER ) )
+	{
+		int nLevels = 0;
+		CBaseEntity *pCurGround = player->GetGroundEntity();
+		while ( pCurGround && pCurGround->IsPlayer() && nLevels < 1000 )
+		{
+			pCurGround = pCurGround->GetGroundEntity();
+			++nLevels;
+		}
+		if ( nLevels == 1000 )
+			Warning( "BUG: CCSGameMovement::CheckParameters - too many stacking levels.\n" );
+
+		// If they're stacked too many levels deep, slide them off.
+		if ( nLevels > 1 )
+		{
+			mv->m_flForwardMove = mv->m_flMaxSpeed * 3;
+			mv->m_flSideMove = 0;
+			mv->m_nButtons = 0;
+			mv->m_nImpulseCommand = 0;
+		}
+	}
+}
+
+
+void CCSGameMovement::ProcessMovement( CBasePlayer *pBasePlayer, CMoveData *pMove )
+{
+	m_pCSPlayer = ToCSPlayer( pBasePlayer );
+	Assert( m_pCSPlayer );
+
+	BaseClass::ProcessMovement( pBasePlayer, pMove );
+}
+
+
+bool CCSGameMovement::CanAccelerate()
+{
+	// Only allow the player to accelerate when in certain states.
+	CSPlayerState curState = m_pCSPlayer->State_Get();
+	if ( curState == STATE_ACTIVE )
+	{
+		return player->GetWaterJumpTime() == 0;
+	}
+	else if ( player->IsObserver() )
+	{
+		return true;
+	}
+	else
+	{	
+		return false;
+	}
+}
+
+
+void CCSGameMovement::PlayerMove()
+{
+	if ( !m_pCSPlayer->CanMove() )
+	{
+		mv->m_flForwardMove = 0;
+		mv->m_flSideMove = 0;
+		mv->m_flUpMove = 0;
+		mv->m_nButtons &= ~(IN_JUMP | IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT);
+	}
+
+	BaseClass::PlayerMove();
+
+	if ( FBitSet( m_pCSPlayer->GetFlags(), FL_ONGROUND ) )
+	{
+		if ( m_pCSPlayer->m_flVelocityModifier < 1.0 )
+		{
+			m_pCSPlayer->m_flVelocityModifier += gpGlobals->frametime / 3.0f;
+		}
+
+		if ( m_pCSPlayer->m_flVelocityModifier > 1.0 )
+			 m_pCSPlayer->m_flVelocityModifier = 1.0;
+	}
+
+#if !defined(CLIENT_DLL)
+	if ( m_pCSPlayer->IsAlive() )
+	{
+		// Check if our eye height is too close to the ceiling and lower it.
+		// This is needed because we have taller models with the old collision bounds.
+
+		const float eyeClearance = 12.0f; // eye pos must be this far below the ceiling
+
+		Vector offset = player->GetViewOffset();
+
+		Vector vHullMin = GetPlayerMins( player->m_Local.m_bDucked );
+		vHullMin.z = 0.0f;
+		Vector vHullMax = GetPlayerMaxs( player->m_Local.m_bDucked ); 
+
+		Vector start = player->GetAbsOrigin();
+		start.z += vHullMax.z;
+		Vector end = start;
+		end.z += eyeClearance - vHullMax.z; 
+		end.z += player->m_Local.m_bDucked ? VEC_DUCK_VIEW_SCALED( player ).z : VEC_VIEW_SCALED( player ).z;
+
+		vHullMax.z = 0.0f;
+
+		Vector fudge( 1, 1, 0 );
+		vHullMin += fudge;
+		vHullMax -= fudge;
+
+		trace_t trace;
+		Ray_t ray;
+		ray.Init( start, end, vHullMin, vHullMax );
+		UTIL_TraceRay( ray, PlayerSolidMask(), mv->m_nPlayerHandle.Get(), COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
+
+		if ( trace.fraction < 1.0f )
+		{
+			float est = start.z + trace.fraction * (end.z - start.z) - player->GetAbsOrigin().z - eyeClearance;
+			if ( ( player->GetFlags() & FL_DUCKING ) == 0 && !player->m_Local.m_bDucking && !player->m_Local.m_bDucked )
+			{
+				offset.z = est;
+			}
+			else
+			{
+				offset.z = MIN( est, offset.z );
+			}
+			player->SetViewOffset( offset );
+		}
+		else
+		{
+			if ( ( player->GetFlags() & FL_DUCKING ) == 0 && !player->m_Local.m_bDucking && !player->m_Local.m_bDucked )
+			{
+
+				player->SetViewOffset( VEC_VIEW_SCALED( player ) );
+			}
+			else if ( m_pCSPlayer->m_duckUntilOnGround )
+			{
+				// Duck Hull, but we're in the air.  Calculate where the view would be.
+				Vector hullSizeNormal = VEC_HULL_MAX_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
+				Vector hullSizeCrouch = VEC_DUCK_HULL_MAX_SCALED( player ) - VEC_DUCK_HULL_MIN_SCALED( player );
+
+				// We've got the duck hull, pulled up to the top of where the player should be
+				Vector lowerClearance = hullSizeNormal - hullSizeCrouch;
+				Vector duckEyeHeight = GetPlayerViewOffset( false ) - lowerClearance;
+				player->SetViewOffset( duckEyeHeight );
+			}
+			else if( player->m_Local.m_bDucked && !player->m_Local.m_bDucking )
+			{
+				player->SetViewOffset( VEC_DUCK_VIEW );
+			}
+		}
+	}
+#endif	
+}
+
+
+void CCSGameMovement::WalkMove( void )
+{
+	if ( m_pCSPlayer->m_flStamina > 0 )
+	{
+		float flRatio;
+
+		flRatio = ( STAMINA_MAX - ( ( m_pCSPlayer->m_flStamina / 1000.0 ) * STAMINA_RECOVER_RATE ) ) / STAMINA_MAX;
+		
+		// This Goldsrc code was run with variable timesteps and it had framerate dependencies.
+		// People looking at Goldsrc for reference are usually 
+		// (these days) measuring the stoppage at 60fps or greater, so we need
+		// to account for the fact that Goldsrc was applying more stopping power
+		// since it applied the slowdown across more frames.
+		float flReferenceFrametime = 1.0f / 70.0f;
+		float flFrametimeRatio = gpGlobals->frametime / flReferenceFrametime;
+
+		flRatio = pow( flRatio, flFrametimeRatio );
+
+		mv->m_vecVelocity.x *= flRatio;
+		mv->m_vecVelocity.y *= flRatio;
+	}
+
+	BaseClass::WalkMove();
+
+	CheckForLadders( player->GetGroundEntity() != NULL );
+}
+
+
+//-------------------------------------------------------------------------------------------------------------------------------
+void CCSGameMovement::AirMove( void )
+{
+	BaseClass::AirMove();
+
+	CheckForLadders( false );
+}
+
+
+//-------------------------------------------------------------------------------------------------------------------------------
+bool CCSGameMovement::OnLadder( trace_t &trace )
+{
+	if ( trace.plane.normal.z == 1.0f )
+		return false;
+
+	return BaseClass::OnLadder( trace );
+}
+
+
+//-------------------------------------------------------------------------------------------------------------------------------
+bool CCSGameMovement::LadderMove( void )
+{
+	bool isOnLadder = BaseClass::LadderMove();
+	if ( isOnLadder && m_pCSPlayer )
+	{
+		m_pCSPlayer->SurpressLadderChecks( mv->GetAbsOrigin(), m_pCSPlayer->m_vecLadderNormal );
+	}
+
+	return isOnLadder;
+}
+
+
+//-------------------------------------------------------------------------------------------------------------------------------
+/**
+ * In CS, crouching up ladders goes slowly and doesn't make a sound.
+ */
+float CCSGameMovement::ClimbSpeed( void ) const
+{
+	if ( mv->m_nButtons & IN_DUCK )
+	{
+		return BaseClass::ClimbSpeed() * CS_PLAYER_SPEED_CLIMB_MODIFIER;
+	}
+	else
+	{
+		return BaseClass::ClimbSpeed();
+	}
+}
+
+
+//-------------------------------------------------------------------------------------------------------------------------------
+/**
+* In CS, strafing on ladders goes slowly.
+*/
+float CCSGameMovement::LadderLateralMultiplier( void ) const
+{
+	if ( mv->m_nButtons & IN_DUCK )
+	{
+		return 1.0f;
+	}
+	else
+	{
+		return 0.5f;
+	}
+}
+
+
+//-------------------------------------------------------------------------------------------------------------------------------
+/**
+ * Looks behind and beneath the player in the air, in case he skips out over the top of a ladder.  If the
+ * trace hits a ladder, the player is snapped to the ladder.
+ */
+void CCSGameMovement::CheckForLadders( bool wasOnGround )
+{
+	if ( !wasOnGround )
+	{
+		// If we're higher than the last place we were on the ground, bail - obviously we're not dropping
+		// past a ladder we might want to grab.
+		if ( mv->GetAbsOrigin().z > m_pCSPlayer->m_lastStandingPos.z )
+			return;
+
+		Vector dir = -m_pCSPlayer->m_lastStandingPos + mv->GetAbsOrigin();
+		if ( !dir.x && !dir.y )
+		{
+			// If we're dropping straight down, we don't know which way to look for a ladder.  Oh well.
+			return;
+		}
+
+		dir.z = 0.0f;
+		float dist = dir.NormalizeInPlace();
+		if ( dist > 64.0f )
+		{
+			// Don't grab ladders too far behind us.
+			return;
+		}
+
+		trace_t trace;
+
+		TracePlayerBBox(
+			mv->GetAbsOrigin(),
+			m_pCSPlayer->m_lastStandingPos - dir*(5+dist),
+			(PlayerSolidMask() & (~CONTENTS_PLAYERCLIP)), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+		if ( trace.fraction != 1.0f && OnLadder( trace ) && trace.plane.normal.z != 1.0f )
+		{
+			if ( m_pCSPlayer->CanGrabLadder( trace.endpos, trace.plane.normal ) )
+			{
+				player->SetMoveType( MOVETYPE_LADDER );
+				player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
+
+				player->SetLadderNormal( trace.plane.normal );
+				mv->m_vecVelocity.Init();
+
+				// The ladder check ignored playerclips, to fix a bug exposed by de_train, where a clipbrush is
+				// flush with a ladder.  This causes the above tracehull to fail unless we ignore playerclips.
+				// However, we have to check for playerclips before we snap to that pos, so we don't warp a
+				// player into a clipbrush.
+				TracePlayerBBox(
+					mv->GetAbsOrigin(),
+					m_pCSPlayer->m_lastStandingPos - dir*(5+dist),
+					PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+				mv->SetAbsOrigin( trace.endpos );
+			}
+		}
+	}
+	else
+	{
+		m_pCSPlayer->m_lastStandingPos = mv->GetAbsOrigin();
+	}
+}
+
+
+void CCSGameMovement::ReduceTimers( void )
+{
+	float frame_msec = 1000.0f * gpGlobals->frametime;
+
+	if ( m_pCSPlayer->m_flStamina > 0 )
+	{
+		m_pCSPlayer->m_flStamina -= frame_msec;
+
+		if ( m_pCSPlayer->m_flStamina < 0 )
+		{
+			m_pCSPlayer->m_flStamina = 0;
+		}
+	}
+
+	BaseClass::ReduceTimers();
+}
+
+ConVar sv_enablebunnyhopping( "sv_enablebunnyhopping", "0", FCVAR_REPLICATED | FCVAR_NOTIFY );
+
+// Only allow bunny jumping up to 1.1x server / player maxspeed setting
+#define BUNNYJUMP_MAX_SPEED_FACTOR 1.1f
+
+// taken from TF2 but changed BUNNYJUMP_MAX_SPEED_FACTOR from 1.1 to 1.0
+void CCSGameMovement::PreventBunnyJumping()
+{
+	// Speed at which bunny jumping is limited
+	float maxscaledspeed = BUNNYJUMP_MAX_SPEED_FACTOR * player->m_flMaxspeed;
+	if ( maxscaledspeed <= 0.0f )
+		return;
+
+	// Current player speed
+	float spd = mv->m_vecVelocity.Length();
+
+	if ( spd <= maxscaledspeed )
+		return;
+
+	// Apply this cropping fraction to velocity
+	float fraction = ( maxscaledspeed / spd );
+
+	mv->m_vecVelocity *= fraction;
+
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CCSGameMovement::CheckJumpButton( void )
+{
+	if (m_pCSPlayer->pl.deadflag)
+	{
+		mv->m_nOldButtons |= IN_JUMP ;	// don't jump again until released
+		return false;
+	}
+
+	// See if we are waterjumping.  If so, decrement count and return.
+	if (m_pCSPlayer->m_flWaterJumpTime)
+	{
+		m_pCSPlayer->m_flWaterJumpTime -= gpGlobals->frametime;
+		if (m_pCSPlayer->m_flWaterJumpTime < 0)
+			m_pCSPlayer->m_flWaterJumpTime = 0;
+		
+		return false;
+	}
+
+	// If we are in the water most of the way...
+	if ( m_pCSPlayer->GetWaterLevel() >= 2 )
+	{	
+		// swimming, not jumping
+		SetGroundEntity( NULL );
+
+		if(m_pCSPlayer->GetWaterType() == CONTENTS_WATER)    // We move up a certain amount
+			mv->m_vecVelocity[2] = 100;
+		else if (m_pCSPlayer->GetWaterType() == CONTENTS_SLIME)
+			mv->m_vecVelocity[2] = 80;
+		
+		// play swiming sound
+		if ( m_pCSPlayer->m_flSwimSoundTime <= 0 )
+		{
+			// Don't play sound again for 1 second
+			m_pCSPlayer->m_flSwimSoundTime = 1000;
+			PlaySwimSound();
+		}
+
+		return false;
+	}
+
+	// No more effect
+ 	if (m_pCSPlayer->GetGroundEntity() == NULL)
+	{
+		mv->m_nOldButtons |= IN_JUMP;
+		return false;		// in air, so no effect
+	}
+
+	if ( mv->m_nOldButtons & IN_JUMP )
+		return false;		// don't pogo stick
+
+	if ( !sv_enablebunnyhopping.GetBool() )
+	{
+		PreventBunnyJumping();
+	}
+
+	// In the air now.
+	SetGroundEntity( NULL );
+	
+	m_pCSPlayer->PlayStepSound( (Vector &)mv->GetAbsOrigin(), player->m_pSurfaceData, 1.0, true );
+	
+	//MoveHelper()->PlayerSetAnimation( PLAYER_JUMP );
+	m_pCSPlayer->DoAnimationEvent( PLAYERANIMEVENT_JUMP );
+
+	float flGroundFactor = 1.0f;
+	if (player->m_pSurfaceData)
+	{
+		flGroundFactor = player->m_pSurfaceData->game.jumpFactor; 
+	}
+
+	// if we weren't ducking, bots and hostages do a crouchjump programatically
+	if ( (!player || player->IsBot()) && !(mv->m_nButtons & IN_DUCK) )
+	{
+		m_pCSPlayer->m_duckUntilOnGround = true;
+		FinishDuck();
+	}
+
+	// Acclerate upward
+	// If we are ducking...
+	float startz = mv->m_vecVelocity[2];
+	if ( m_pCSPlayer->m_duckUntilOnGround || (  m_pCSPlayer->m_Local.m_bDucking ) || (  m_pCSPlayer->GetFlags() & FL_DUCKING ) )
+	{
+		// d = 0.5 * g * t^2		- distance traveled with linear accel
+		// t = sqrt(2.0 * 45 / g)	- how long to fall 45 units
+		// v = g * t				- velocity at the end (just invert it to jump up that high)
+		// v = g * sqrt(2.0 * 45 / g )
+		// v^2 = g * g * 2.0 * 45 / g
+		// v = sqrt( g * 2.0 * 45 )
+		
+		mv->m_vecVelocity[2] = flGroundFactor * sqrt(2 * 800 * 57.0);  // 2 * gravity * height
+	}
+	else
+	{
+		mv->m_vecVelocity[2] += flGroundFactor * sqrt(2 * 800 * 57.0);  // 2 * gravity * height
+	}
+
+	if ( m_pCSPlayer->m_flStamina > 0 )
+	{
+		float flRatio;
+
+		flRatio = ( STAMINA_MAX - ( ( m_pCSPlayer->m_flStamina  / 1000.0 ) * STAMINA_RECOVER_RATE ) ) / STAMINA_MAX;
+
+		mv->m_vecVelocity[2] *= flRatio;
+	}
+
+	m_pCSPlayer->m_flStamina = ( STAMINA_COST_JUMP / STAMINA_RECOVER_RATE ) * 1000.0;
+	
+	FinishGravity();
+
+	mv->m_outWishVel.z += mv->m_vecVelocity[2] - startz;
+	mv->m_outStepHeight += 0.1f;
+
+	OnJump(mv->m_outWishVel.z);
+
+#ifndef CLIENT_DLL
+	// allow bots to react
+	IGameEvent * event = gameeventmanager->CreateEvent( "player_jump" );
+	if ( event )
+	{
+		event->SetInt( "userid", m_pCSPlayer->GetUserID() );
+		gameeventmanager->FireEvent( event );
+	}
+#endif
+
+	// Flag that we jumped.
+	mv->m_nOldButtons |= IN_JUMP;	// don't jump again until released
+	return true;
+}
+
+
+void CCSGameMovement::DecayPunchAngle( void )
+{
+	float	len;
+
+	Vector vPunchAngle;
+
+	vPunchAngle.x = m_pCSPlayer->m_Local.m_vecPunchAngle->x;
+	vPunchAngle.y = m_pCSPlayer->m_Local.m_vecPunchAngle->y;
+	vPunchAngle.z = m_pCSPlayer->m_Local.m_vecPunchAngle->z;
+	
+	len = VectorNormalize ( vPunchAngle );
+	len -= (10.0 + len * 0.5) * gpGlobals->frametime;
+	len = MAX( len, 0.0 );
+	VectorScale ( vPunchAngle, len, vPunchAngle );
+
+	m_pCSPlayer->m_Local.m_vecPunchAngle.Set( 0, vPunchAngle.x );
+	m_pCSPlayer->m_Local.m_vecPunchAngle.Set( 1, vPunchAngle.y );
+	m_pCSPlayer->m_Local.m_vecPunchAngle.Set( 2, vPunchAngle.z );
+}
+
+
+void CCSGameMovement::HandleDuckingSpeedCrop()
+{
+	//=============================================================================
+	// HPE_BEGIN:
+	// [Forrest] 
+	//=============================================================================
+	// Movement speed in free look camera mode is unaffected by ducking state.
+	if ( player->GetObserverMode() == OBS_MODE_ROAMING )
+		return;
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	if ( !( m_iSpeedCropped & SPEED_CROPPED_DUCK ) )
+	{
+		if ( ( mv->m_nButtons & IN_DUCK ) || ( player->m_Local.m_bDucking ) || ( player->GetFlags() & FL_DUCKING ) )
+		{
+			mv->m_flForwardMove	*= CS_PLAYER_SPEED_DUCK_MODIFIER;
+			mv->m_flSideMove	*= CS_PLAYER_SPEED_DUCK_MODIFIER;
+			mv->m_flUpMove		*= CS_PLAYER_SPEED_DUCK_MODIFIER;
+			m_iSpeedCropped		|= SPEED_CROPPED_DUCK;
+		}
+	}
+}
+
+bool CCSGameMovement::CanUnduck()
+{
+	trace_t trace;
+	Vector newOrigin;
+
+	VectorCopy( mv->GetAbsOrigin(), newOrigin );
+
+	if ( player->GetGroundEntity() != NULL )
+	{
+		newOrigin += VEC_DUCK_HULL_MIN_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
+	}
+	else
+	{
+		// If in air an letting go of croush, make sure we can offset origin to make
+		//  up for uncrouching
+ 		Vector hullSizeNormal = VEC_HULL_MAX_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
+		Vector hullSizeCrouch = VEC_DUCK_HULL_MAX_SCALED( player ) - VEC_DUCK_HULL_MIN_SCALED( player );
+		
+		newOrigin += -0.5f * ( hullSizeNormal - hullSizeCrouch );
+	}
+
+	UTIL_TraceHull( mv->GetAbsOrigin(), newOrigin, VEC_HULL_MIN_SCALED( player ), VEC_HULL_MAX_SCALED( player ), PlayerSolidMask(), player, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
+
+	if ( trace.startsolid || ( trace.fraction != 1.0f ) )
+		return false;	
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop ducking
+//-----------------------------------------------------------------------------
+void CCSGameMovement::FinishUnDuck( void )
+{
+	trace_t trace;
+	Vector newOrigin;
+
+	VectorCopy( mv->GetAbsOrigin(), newOrigin );
+
+	if ( player->GetGroundEntity() != NULL )
+	{
+		newOrigin += VEC_DUCK_HULL_MIN_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
+	}
+	else
+	{
+		// If in air an letting go of croush, make sure we can offset origin to make
+		//  up for uncrouching
+ 		Vector hullSizeNormal = VEC_HULL_MAX_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
+		Vector hullSizeCrouch = VEC_DUCK_HULL_MAX_SCALED( player ) - VEC_DUCK_HULL_MIN_SCALED( player );
+
+		Vector viewDelta = -0.5f * ( hullSizeNormal - hullSizeCrouch );
+
+		VectorAdd( newOrigin, viewDelta, newOrigin );
+	}
+
+	player->m_Local.m_bDucked = false;
+	player->RemoveFlag( FL_DUCKING );
+	player->m_Local.m_bDucking  = false;
+	player->SetViewOffset( GetPlayerViewOffset( false ) );
+	player->m_Local.m_flDucktime = 0;
+	
+	mv->SetAbsOrigin( newOrigin );
+
+	// Recategorize position since ducking can change origin
+	CategorizePosition();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finish ducking
+//-----------------------------------------------------------------------------
+void CCSGameMovement::FinishDuck( void )
+{
+	
+	Vector hullSizeNormal = VEC_HULL_MAX_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
+	Vector hullSizeCrouch = VEC_DUCK_HULL_MAX_SCALED( player ) - VEC_DUCK_HULL_MIN_SCALED( player );
+
+	Vector viewDelta = 0.5f * ( hullSizeNormal - hullSizeCrouch );
+
+	player->SetViewOffset( GetPlayerViewOffset( true ) );
+	player->AddFlag( FL_DUCKING );
+	player->m_Local.m_bDucking = false;
+
+	if ( !player->m_Local.m_bDucked )
+	{
+	
+		Vector org = mv->GetAbsOrigin();
+
+		if ( player->GetGroundEntity() != NULL )
+		{
+			org -= VEC_DUCK_HULL_MIN_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
+		}
+		else
+		{
+			org += viewDelta;
+		}
+		mv->SetAbsOrigin( org );
+
+		player->m_Local.m_bDucked = true;
+	}
+
+	// See if we are stuck?
+	FixPlayerCrouchStuck( true );
+
+	// Recategorize position since ducking can change origin
+	CategorizePosition();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: See if duck button is pressed and do the appropriate things
+//-----------------------------------------------------------------------------
+void CCSGameMovement::Duck( void )
+{
+
+	// Fix taken from zblock for rapid crouch/stand not showing stand on other clients
+
+	if ( player->GetFlags() & FL_ONGROUND )
+	{
+		// if prevent crouch
+		if ( !( mv->m_nButtons & IN_DUCK ) && ( mv->m_nOldButtons & IN_DUCK ) )
+		{
+			// Player has released crouch and moving to standing
+			m_fTimeLastUnducked = gpGlobals->curtime;
+		}
+		else if ( ( mv->m_nButtons & IN_DUCK ) && !( mv->m_nOldButtons & IN_DUCK ) )
+		{
+			// Crouch from standing
+			if ( ( player->GetFlags() & FL_DUCKING )
+				&& ( m_fTimeLastUnducked > (gpGlobals->curtime - sv_timebetweenducks.GetFloat() ) ) )
+			{
+				// if the server thinks the player is still crouched
+				// AND the time the player started to stand (from being ducked) was less than 300ms ago
+				// prevent the player from ducking again
+				mv->m_nButtons &= ~IN_DUCK;
+			}
+		}
+	}
+
+	int buttonsChanged	= ( mv->m_nOldButtons ^ mv->m_nButtons );	// These buttons have changed this frame
+	int buttonsPressed	=  buttonsChanged & mv->m_nButtons;			// The changed ones still down are "pressed"
+	int buttonsReleased	=  buttonsChanged & mv->m_nOldButtons;		// The changed ones which were previously down are "released"
+
+	// Check to see if we are in the air.
+	bool bInAir = player->GetGroundEntity() == NULL && player->GetMoveType() != MOVETYPE_LADDER;
+
+	if ( mv->m_nButtons & IN_DUCK )
+	{
+		mv->m_nOldButtons |= IN_DUCK;
+	}
+	else
+	{
+		mv->m_nOldButtons &= ~IN_DUCK;
+	}
+
+	if ( IsDead() )
+	{
+		// Unduck
+		if ( player->GetFlags() & FL_DUCKING )
+		{
+			FinishUnDuck();
+		}
+		return;
+	}
+
+	HandleDuckingSpeedCrop();
+
+	if ( m_pCSPlayer->m_duckUntilOnGround )
+	{
+		if ( !bInAir )
+		{
+			m_pCSPlayer->m_duckUntilOnGround = false;
+			if ( CanUnduck() )
+			{
+				FinishUnDuck();
+			}
+			return;
+		}
+		else
+		{
+			if ( mv->m_vecVelocity.z > 0.0f )
+				return;
+
+			// Check if we can un-duck.  We want to unduck if we have space for the standing hull, and
+			// if it is less than 2 inches off the ground.
+			trace_t trace;
+			Vector newOrigin;
+			Vector groundCheck;
+
+			VectorCopy( mv->GetAbsOrigin(), newOrigin );
+			Vector hullSizeNormal = VEC_HULL_MAX_SCALED( player ) - VEC_HULL_MIN_SCALED( player );
+			Vector hullSizeCrouch = VEC_DUCK_HULL_MAX_SCALED( player ) - VEC_DUCK_HULL_MIN_SCALED( player );
+			newOrigin -= ( hullSizeNormal - hullSizeCrouch );
+			groundCheck = newOrigin;
+			groundCheck.z -= player->GetStepSize();
+
+			UTIL_TraceHull( newOrigin, groundCheck, VEC_HULL_MIN_SCALED( player ), VEC_HULL_MAX_SCALED( player ), PlayerSolidMask(), player, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
+
+			if ( trace.startsolid || trace.fraction == 1.0f )
+				return; // Can't even stand up, or there's no ground underneath us
+
+			m_pCSPlayer->m_duckUntilOnGround = false;
+			if ( CanUnduck() )
+			{
+				FinishUnDuck();
+			}
+			return;
+		}
+	}
+
+	// Holding duck, in process of ducking or fully ducked?
+	if ( ( mv->m_nButtons & IN_DUCK ) || ( player->m_Local.m_bDucking ) || ( player->GetFlags() & FL_DUCKING ) )
+	{
+		if ( mv->m_nButtons & IN_DUCK )
+		{
+			bool alreadyDucked = ( player->GetFlags() & FL_DUCKING ) ? true : false;
+
+			if ( (buttonsPressed & IN_DUCK ) && !( player->GetFlags() & FL_DUCKING ) )
+			{
+				// Use 1 second so super long jump will work
+				player->m_Local.m_flDucktime = 1000;
+				player->m_Local.m_bDucking    = true;
+			}
+
+			float duckmilliseconds = MAX( 0.0f, 1000.0f - (float)player->m_Local.m_flDucktime );
+			float duckseconds = duckmilliseconds / 1000.0f;
+
+			//time = MAX( 0.0, ( 1.0 - (float)player->m_Local.m_flDucktime / 1000.0 ) );
+			
+			if ( player->m_Local.m_bDucking )
+			{
+				if ( !( player->GetFlags() & FL_ANIMDUCKING ) )
+					player->AddFlag( FL_ANIMDUCKING );
+
+				// Finish ducking immediately if duck time is over or not on ground
+				if ( ( duckseconds > TIME_TO_DUCK ) || 
+					( player->GetGroundEntity() == NULL ) ||
+					alreadyDucked)
+				{
+					FinishDuck();
+				}
+				else
+				{
+					// Calc parametric time
+					float duckFraction = SimpleSpline( duckseconds / TIME_TO_DUCK );
+					SetDuckedEyeOffset( duckFraction );
+				}
+			}
+		}
+		else
+		{
+			// Try to unduck unless automovement is not allowed
+			// NOTE: When not onground, you can always unduck
+			if ( player->m_Local.m_bAllowAutoMovement || player->GetGroundEntity() == NULL )
+			{
+				if ( (buttonsReleased & IN_DUCK ) && ( player->GetFlags() & FL_DUCKING ) )
+				{
+					// Use 1 second so super long jump will work
+					player->m_Local.m_flDucktime = 1000;
+					player->m_Local.m_bDucking    = true;  // or unducking
+				}
+
+				float duckmilliseconds = MAX( 0.0f, 1000.0f - (float)player->m_Local.m_flDucktime );
+				float duckseconds = duckmilliseconds / 1000.0f;
+
+				if ( CanUnduck() )
+				{
+					if ( player->m_Local.m_bDucking || 
+						 player->m_Local.m_bDucked ) // or unducking
+					{
+						if ( player->GetFlags() & FL_ANIMDUCKING )
+							player->RemoveFlag( FL_ANIMDUCKING );
+
+						// Finish ducking immediately if duck time is over or not on ground
+						if ( ( duckseconds > TIME_TO_UNDUCK ) ||
+							 ( player->GetGroundEntity() == NULL ) )
+						{
+							FinishUnDuck();
+						}
+						else
+						{
+							// Calc parametric time
+							float duckFraction = SimpleSpline( 1.0f - ( duckseconds / TIME_TO_UNDUCK ) );
+							SetDuckedEyeOffset( duckFraction );
+						}
+					}
+				}
+				else
+				{
+					// Still under something where we can't unduck, so make sure we reset this timer so
+					//  that we'll unduck once we exit the tunnel, etc.
+					player->m_Local.m_flDucktime	= 1000;
+				}
+			}
+		}
+	}
+}
+
+
+void CCSGameMovement::OnJump( float fImpulse )
+{
+	m_pCSPlayer->OnJump( fImpulse );
+}	
+
+void CCSGameMovement::OnLand( float fVelocity )
+{
+	m_pCSPlayer->OnLand( fVelocity );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Essentially the same as TracePlayerBBox, but adds a callback to 
+// exclude entities that are not standable (except for other players)
+//-----------------------------------------------------------------------------
+void  CCSGameMovement::TryTouchGround( const Vector& start, const Vector& end, const Vector& mins, const Vector& maxs, unsigned int fMask, int collisionGroup, trace_t& pm )
+{
+	VPROF( "CCSGameMovement::TryTouchGround" );
+
+	Ray_t ray;
+	ray.Init( start, end, mins, maxs );
+
+	ShouldHitFunc_t pStandingTestCallback = sv_enableboost.GetBool() ? NULL : CheckForStandable;
+
+	UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &pm,  pStandingTestCallback );
+
+}
diff --git a/game/shared/cstrike/cs_gamerules.cpp b/game/shared/cstrike/cs_gamerules.cpp
new file mode 100644
index 00000000..c688140b
--- /dev/null
+++ b/game/shared/cstrike/cs_gamerules.cpp
@@ -0,0 +1,5859 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The TF Game rules 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_gamerules.h"
+#include "cs_ammodef.h"
+#include "weapon_csbase.h"
+#include "cs_shareddefs.h"
+#include "KeyValues.h"
+#include "cs_achievement_constants.h"
+#include "fmtstr.h"
+
+#ifdef CLIENT_DLL
+
+	#include "networkstringtable_clientdll.h"
+	#include "utlvector.h"
+
+#else
+	
+	#include "bot.h"
+	#include "utldict.h"
+	#include "cs_player.h"
+	#include "cs_team.h"
+	#include "cs_gamerules.h"
+	#include "voice_gamemgr.h"
+	#include "igamesystem.h"
+	#include "weapon_c4.h"
+	#include "mapinfo.h"
+	#include "shake.h"
+	#include "mapentities.h"
+	#include "game.h"
+	#include "cs_simple_hostage.h"
+	#include "cs_gameinterface.h"
+	#include "player_resource.h"
+	#include "info_view_parameters.h"
+	#include "cs_bot_manager.h"
+	#include "cs_bot.h"
+	#include "eventqueue.h"
+	#include "fmtstr.h"
+	#include "teamplayroundbased_gamerules.h"
+	#include "gameweaponmanager.h"
+
+	#include "cs_gamestats.h"
+	#include "cs_urlretrieveprices.h"
+	#include "networkstringtable_gamedll.h"
+	#include "player_resource.h"
+	#include "cs_player_resource.h"
+	
+#if defined( REPLAY_ENABLED )	
+	#include "replay/ireplaysystem.h"
+	#include "replay/iserverreplaycontext.h"
+	#include "replay/ireplaysessionrecorder.h"
+#endif // REPLAY_ENABLED
+
+#endif
+
+
+#include "cs_blackmarket.h"
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+#ifndef CLIENT_DLL
+
+
+#define CS_GAME_STATS_UPDATE 79200 //22 hours
+#define CS_GAME_STATS_UPDATE_PERIOD 7200 // 2 hours
+
+extern IUploadGameStats *gamestatsuploader;
+
+#if defined( REPLAY_ENABLED )
+extern IReplaySystem *g_pReplay;
+#endif // REPLAY_ENABLED
+
+#endif
+
+
+/**
+ * Player hull & eye position for standing, ducking, etc.  This version has a taller
+ * player height, but goldsrc-compatible collision bounds.
+ */
+static CViewVectors g_CSViewVectors(
+	Vector( 0, 0, 64 ),		// eye position
+
+	Vector(-16, -16, 0 ),	// hull min
+	Vector( 16,  16, 62 ),	// hull max
+
+	Vector(-16, -16, 0 ),	// duck hull min
+	Vector( 16,  16, 45 ),	// duck hull max
+	Vector( 0, 0, 47 ),		// duck view
+
+	Vector(-10, -10, -10 ),	// observer hull min
+	Vector( 10,  10,  10 ),	// observer hull max
+
+	Vector( 0, 0, 14 )		// dead view height
+);
+
+
+#ifndef CLIENT_DLL
+LINK_ENTITY_TO_CLASS(info_player_terrorist, CPointEntity);
+LINK_ENTITY_TO_CLASS(info_player_counterterrorist,CPointEntity);
+LINK_ENTITY_TO_CLASS(info_player_logo,CPointEntity);
+#endif
+
+REGISTER_GAMERULES_CLASS( CCSGameRules );
+
+
+BEGIN_NETWORK_TABLE_NOBASE( CCSGameRules, DT_CSGameRules )
+	#ifdef CLIENT_DLL
+		RecvPropBool( RECVINFO( m_bFreezePeriod ) ),
+		RecvPropInt( RECVINFO( m_iRoundTime ) ),
+		RecvPropFloat( RECVINFO( m_fRoundStartTime ) ),
+		RecvPropFloat( RECVINFO( m_flGameStartTime ) ),
+		RecvPropInt( RECVINFO( m_iHostagesRemaining ) ),
+		RecvPropBool( RECVINFO( m_bMapHasBombTarget ) ),
+		RecvPropBool( RECVINFO( m_bMapHasRescueZone ) ),
+		RecvPropBool( RECVINFO( m_bLogoMap ) ),
+		RecvPropBool( RECVINFO( m_bBlackMarket ) )
+	#else
+		SendPropBool( SENDINFO( m_bFreezePeriod ) ),
+		SendPropInt( SENDINFO( m_iRoundTime ), 16 ),
+		SendPropFloat( SENDINFO( m_fRoundStartTime ), 32, SPROP_NOSCALE ),
+		SendPropFloat( SENDINFO( m_flGameStartTime ), 32, SPROP_NOSCALE ),
+		SendPropInt( SENDINFO( m_iHostagesRemaining ), 4 ),
+		SendPropBool( SENDINFO( m_bMapHasBombTarget ) ),
+		SendPropBool( SENDINFO( m_bMapHasRescueZone ) ),
+		SendPropBool( SENDINFO( m_bLogoMap ) ),
+		SendPropBool( SENDINFO( m_bBlackMarket ) )
+	#endif
+END_NETWORK_TABLE()
+
+
+LINK_ENTITY_TO_CLASS( cs_gamerules, CCSGameRulesProxy );
+IMPLEMENT_NETWORKCLASS_ALIASED( CSGameRulesProxy, DT_CSGameRulesProxy )
+
+
+#ifdef CLIENT_DLL
+	void RecvProxy_CSGameRules( const RecvProp *pProp, void **pOut, void *pData, int objectID )
+	{
+		CCSGameRules *pRules = CSGameRules();
+		Assert( pRules );
+		*pOut = pRules;
+	}
+
+	BEGIN_RECV_TABLE( CCSGameRulesProxy, DT_CSGameRulesProxy )
+		RecvPropDataTable( "cs_gamerules_data", 0, 0, &REFERENCE_RECV_TABLE( DT_CSGameRules ), RecvProxy_CSGameRules )
+	END_RECV_TABLE()
+#else
+	void* SendProxy_CSGameRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
+	{
+		CCSGameRules *pRules = CSGameRules();
+		Assert( pRules );
+		return pRules;
+	}
+
+	BEGIN_SEND_TABLE( CCSGameRulesProxy, DT_CSGameRulesProxy )
+		SendPropDataTable( "cs_gamerules_data", 0, &REFERENCE_SEND_TABLE( DT_CSGameRules ), SendProxy_CSGameRules )
+	END_SEND_TABLE()
+#endif
+
+
+
+ConVar ammo_50AE_max( "ammo_50AE_max", "35", FCVAR_REPLICATED );
+ConVar ammo_762mm_max( "ammo_762mm_max", "90", FCVAR_REPLICATED );
+ConVar ammo_556mm_max( "ammo_556mm_max", "90", FCVAR_REPLICATED );
+ConVar ammo_556mm_box_max( "ammo_556mm_box_max", "200", FCVAR_REPLICATED );
+ConVar ammo_338mag_max( "ammo_338mag_max", "30", FCVAR_REPLICATED );
+ConVar ammo_9mm_max( "ammo_9mm_max", "120", FCVAR_REPLICATED );
+ConVar ammo_buckshot_max( "ammo_buckshot_max", "32", FCVAR_REPLICATED );
+ConVar ammo_45acp_max( "ammo_45acp_max", "100", FCVAR_REPLICATED );
+ConVar ammo_357sig_max( "ammo_357sig_max", "52", FCVAR_REPLICATED );
+ConVar ammo_57mm_max( "ammo_57mm_max", "100", FCVAR_REPLICATED );
+ConVar ammo_hegrenade_max( "ammo_hegrenade_max", "1", FCVAR_REPLICATED );
+ConVar ammo_flashbang_max( "ammo_flashbang_max", "2", FCVAR_REPLICATED );
+ConVar ammo_smokegrenade_max( "ammo_smokegrenade_max", "1", FCVAR_REPLICATED );
+
+//ConVar mp_dynamicpricing( "mp_dynamicpricing", "0", FCVAR_REPLICATED, "Enables or Disables the dynamic weapon prices" );
+
+
+extern ConVar sv_stopspeed;
+
+ConVar mp_buytime( 
+	"mp_buytime", 
+	"1.5",
+	FCVAR_REPLICATED,
+	"How many minutes after round start players can buy items for.",
+	true, 0.25,
+	false, 0 );
+
+ConVar mp_playerid(
+	"mp_playerid",
+	"0",
+	FCVAR_REPLICATED,
+	"Controls what information player see in the status bar: 0 all names; 1 team names; 2 no names",
+	true, 0,
+	true, 2 );
+
+ConVar mp_playerid_delay(
+	"mp_playerid_delay",
+	"0.5",
+	FCVAR_REPLICATED,
+	"Number of seconds to delay showing information in the status bar",
+	true, 0,
+	true, 1 );
+
+ConVar mp_playerid_hold(
+	"mp_playerid_hold",
+	"0.25",
+	FCVAR_REPLICATED,
+	"Number of seconds to keep showing old information in the status bar",
+	true, 0,
+	true, 1 );
+
+ConVar mp_round_restart_delay(
+	"mp_round_restart_delay",
+	"5.0",
+	FCVAR_REPLICATED,
+	"Number of seconds to delay before restarting a round after a win",
+	true, 0.0f,
+	true, 10.0f );
+
+ConVar sv_allowminmodels(
+	"sv_allowminmodels",
+	"1",
+	FCVAR_REPLICATED | FCVAR_NOTIFY,
+	"Allow or disallow the use of cl_minmodels on this server." );
+
+#ifdef CLIENT_DLL
+
+ConVar cl_autowepswitch(
+	"cl_autowepswitch",
+	"1",
+	FCVAR_ARCHIVE | FCVAR_USERINFO,
+	"Automatically switch to picked up weapons (if more powerful)" );
+
+ConVar cl_autohelp(
+	"cl_autohelp",
+	"1",
+	FCVAR_ARCHIVE | FCVAR_USERINFO,
+	"Auto-help" );
+
+#else
+
+	// longest the intermission can last, in seconds
+	#define MAX_INTERMISSION_TIME 120
+
+	// Falling damage stuff.
+	#define CS_PLAYER_FATAL_FALL_SPEED		1100	// approx 60 feet
+	#define CS_PLAYER_MAX_SAFE_FALL_SPEED	580		// approx 20 feet
+	#define CS_DAMAGE_FOR_FALL_SPEED		((float)100 / ( CS_PLAYER_FATAL_FALL_SPEED - CS_PLAYER_MAX_SAFE_FALL_SPEED )) // damage per unit per second.
+
+	// These entities are preserved each round restart. The rest are removed and recreated.
+	static const char *s_PreserveEnts[] =
+	{
+		"ai_network",
+		"ai_hint",
+		"cs_gamerules",
+		"cs_team_manager",
+		"cs_player_manager",
+		"env_soundscape",
+		"env_soundscape_proxy",
+		"env_soundscape_triggerable",
+		"env_sun",
+		"env_wind",
+		"env_fog_controller",
+		"func_brush",
+		"func_wall",
+		"func_buyzone",
+		"func_illusionary",
+		"func_hostage_rescue",
+		"func_bomb_target",
+		"infodecal",
+		"info_projecteddecal",
+		"info_node",
+		"info_target",
+		"info_node_hint",
+		"info_player_counterterrorist",
+		"info_player_terrorist",
+		"info_map_parameters",
+		"keyframe_rope",
+		"move_rope",
+		"info_ladder",
+		"player",
+		"point_viewcontrol",
+		"scene_manager",
+		"shadow_control",
+		"sky_camera",
+		"soundent",
+		"trigger_soundscape",
+		"viewmodel",
+		"predicted_viewmodel",
+		"worldspawn",
+		"point_devshot_camera",
+		"", // END Marker
+	};
+
+
+	// --------------------------------------------------------------------------------------------------- //
+	// Voice helper
+	// --------------------------------------------------------------------------------------------------- //
+
+	class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
+	{
+	public:
+		virtual bool		CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker, bool &bProximity )
+		{
+			// Dead players can only be heard by other dead team mates
+			if ( pTalker->IsAlive() == false )
+			{
+				if ( pListener->IsAlive() == false )
+					return ( pListener->InSameTeam( pTalker ) );
+
+				return false;
+			}
+
+			return ( pListener->InSameTeam( pTalker ) );
+		}
+	};
+	CVoiceGameMgrHelper g_VoiceGameMgrHelper;
+	IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;
+
+
+
+	// --------------------------------------------------------------------------------------------------- //
+	// Globals.
+	// --------------------------------------------------------------------------------------------------- //
+
+	// NOTE: the indices here must match TEAM_TERRORIST, TEAM_CT, TEAM_SPECTATOR, etc.
+	const char *sTeamNames[] =
+	{
+		"Unassigned",
+		"Spectator",
+		"TERRORIST",
+		"CT"
+	};
+
+	extern ConVar mp_maxrounds;
+
+	ConVar mp_startmoney( 
+		"mp_startmoney", 
+		"800", 
+		FCVAR_REPLICATED | FCVAR_NOTIFY,
+		"amount of money each player gets when they reset",
+		true, 800,
+		true, 16000 );	
+
+	ConVar mp_roundtime( 
+		"mp_roundtime",
+		"2.5",
+		FCVAR_REPLICATED | FCVAR_NOTIFY,
+		"How many minutes each round takes.",
+		true, 1,	// min value
+		true, 9		// max value
+		);
+
+	ConVar mp_freezetime( 
+		"mp_freezetime",
+		"6",
+		FCVAR_REPLICATED | FCVAR_NOTIFY,
+		"how many seconds to keep players frozen when the round starts",
+		true, 0,	// min value
+		true, 60	// max value
+		);
+
+	ConVar mp_c4timer( 
+		"mp_c4timer", 
+		"45", 
+		FCVAR_REPLICATED | FCVAR_NOTIFY,
+		"how long from when the C4 is armed until it blows",
+		true, 10,	// min value
+		true, 90	// max value
+		);
+
+	ConVar mp_limitteams( 
+		"mp_limitteams", 
+		"2", 
+		FCVAR_REPLICATED | FCVAR_NOTIFY,
+		"Max # of players 1 team can have over another (0 disables check)",
+		true, 0,	// min value
+		true, 30	// max value
+		);
+
+	ConVar mp_tkpunish( 
+		"mp_tkpunish", 
+		"0", 
+		FCVAR_REPLICATED,
+		"Will a TK'er be punished in the next round?  {0=no,  1=yes}" );
+
+	ConVar mp_autokick(
+		"mp_autokick",
+		"1",
+		FCVAR_REPLICATED,
+		"Kick idle/team-killing players" );
+
+	ConVar mp_spawnprotectiontime(
+		"mp_spawnprotectiontime",
+		"5",
+		FCVAR_REPLICATED,
+		"Kick players who team-kill within this many seconds of a round restart." );
+
+	ConVar mp_humanteam( 
+		"mp_humanteam", 
+		"any", 
+		FCVAR_REPLICATED,
+		"Restricts human players to a single team {any, CT, T}" );
+
+	ConVar mp_ignore_round_win_conditions(
+		"mp_ignore_round_win_conditions",
+		"0",
+		FCVAR_REPLICATED,
+		"Ignore conditions which would end the current round");
+
+	ConCommand EndRound( "endround", &CCSGameRules::EndRound, "End the current round.", FCVAR_CHEAT );
+
+
+	// --------------------------------------------------------------------------------------------------- //
+	// Global helper functions.
+	// --------------------------------------------------------------------------------------------------- //
+
+	void InitBodyQue(void)
+	{
+		// FIXME: Make this work
+	}
+
+
+	Vector DropToGround( 
+		CBaseEntity *pMainEnt, 
+		const Vector &vPos, 
+		const Vector &vMins, 
+		const Vector &vMaxs )
+	{
+		trace_t trace;
+		UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace );
+		return trace.endpos;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: This function can be used to find a valid placement location for an entity.
+	//			Given an origin to start looking from and a minimum radius to place the entity at,
+	//			it will sweep out a circle around vOrigin and try to find a valid spot (on the ground)
+	//			where mins and maxs will fit.
+	// Input  : *pMainEnt - Entity to place
+	//			&vOrigin - Point to search around
+	//			fRadius - Radius to search within
+	//			nTries - Number of tries to attempt
+	//			&mins - mins of the Entity
+	//			&maxs - maxs of the Entity
+	//			&outPos - Return point
+	// Output : Returns true and fills in outPos if it found a spot.
+	//-----------------------------------------------------------------------------
+	bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround )
+	{
+		// This function moves the box out in each dimension in each step trying to find empty space like this:
+		//
+		//											  X  
+		//							   X			  X  
+		// Step 1:   X     Step 2:    XXX   Step 3: XXXXX
+		//							   X 			  X  
+		//											  X  
+		//
+			 
+		Vector mins, maxs;
+		pMainEnt->CollisionProp()->WorldSpaceAABB( &mins, &maxs );
+		mins -= pMainEnt->GetAbsOrigin();
+		maxs -= pMainEnt->GetAbsOrigin();
+
+		// Put some padding on their bbox.
+		float flPadSize = 5;
+		Vector vTestMins = mins - Vector( flPadSize, flPadSize, flPadSize );
+		Vector vTestMaxs = maxs + Vector( flPadSize, flPadSize, flPadSize );
+
+		// First test the starting origin.
+		if ( UTIL_IsSpaceEmpty( pMainEnt, vOrigin + vTestMins, vOrigin + vTestMaxs ) )
+		{
+			if ( bDropToGround )
+			{
+				outPos = DropToGround( pMainEnt, vOrigin, vTestMins, vTestMaxs );
+			}
+			else
+			{
+				outPos = vOrigin;
+			}
+			return true;
+		}
+
+		Vector vDims = vTestMaxs - vTestMins;
+
+		// Keep branching out until we get too far.
+		int iCurIteration = 0;
+		int nMaxIterations = 15;
+		
+		int offset = 0;
+		do
+		{
+			for ( int iDim=0; iDim < 3; iDim++ )
+			{
+				float flCurOffset = offset * vDims[iDim];
+
+				for ( int iSign=0; iSign < 2; iSign++ )
+				{
+					Vector vBase = vOrigin;
+					vBase[iDim] += (iSign*2-1) * flCurOffset;
+				
+					if ( UTIL_IsSpaceEmpty( pMainEnt, vBase + vTestMins, vBase + vTestMaxs ) )
+					{
+						// Ensure that there is a clear line of sight from the spawnpoint entity to the actual spawn point.
+						// (Useful for keeping things from spawning behind walls near a spawn point)
+						trace_t tr;
+						UTIL_TraceLine( vOrigin, vBase, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &tr );
+
+						if ( tr.fraction != 1.0 )
+						{
+							continue;
+						}
+						
+						if ( bDropToGround )
+							outPos = DropToGround( pMainEnt, vBase, vTestMins, vTestMaxs );
+						else
+							outPos = vBase;
+
+						return true;
+					}
+				}
+			}
+
+			++offset;
+		} while ( iCurIteration++ < nMaxIterations );
+
+	//	Warning( "EntityPlacementTest for ent %d:%s failed!\n", pMainEnt->entindex(), pMainEnt->GetClassname() );
+		return false;
+	}
+
+	int UTIL_HumansInGame( bool ignoreSpectators )
+	{
+		int iCount = 0;
+
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *entity = CCSPlayer::Instance( i );
+
+			if ( entity && !FNullEnt( entity->edict() ) )
+			{
+				if ( FStrEq( entity->GetPlayerName(), "" ) )
+					continue;
+
+				if ( FBitSet( entity->GetFlags(), FL_FAKECLIENT ) )
+					continue;
+
+				if ( ignoreSpectators && entity->GetTeamNumber() != TEAM_TERRORIST && entity->GetTeamNumber() != TEAM_CT )
+					continue;
+
+				if ( ignoreSpectators && entity->State_Get() == STATE_PICKINGCLASS )
+					continue;
+
+				iCount++;
+			}
+		}
+
+		return iCount;
+	}
+
+	// --------------------------------------------------------------------------------------------------- //
+	// CCSGameRules implementation.
+	// --------------------------------------------------------------------------------------------------- //
+
+	CCSGameRules::CCSGameRules()
+	{
+		m_iRoundTime = 0;
+		m_iRoundWinStatus = WINNER_NONE;
+		m_iFreezeTime = 0;
+
+		m_fRoundStartTime = 0;
+		m_bAllowWeaponSwitch = true;
+		m_bFreezePeriod = true;
+		m_iNumTerrorist = m_iNumCT = 0;	// number of players per team
+		m_flRestartRoundTime = 0.1f; // restart first round as soon as possible
+		m_iNumSpawnableTerrorist = m_iNumSpawnableCT = 0;
+		m_bFirstConnected = false;
+		m_bCompleteReset = false;
+		m_iAccountTerrorist = m_iAccountCT = 0;
+		m_iNumCTWins = 0;
+		m_iNumTerroristWins = 0;
+		m_iNumConsecutiveCTLoses = 0;
+		m_iNumConsecutiveTerroristLoses = 0;
+		m_bTargetBombed = false;
+		m_bBombDefused = false;
+		m_iTotalRoundsPlayed = -1;
+		m_iUnBalancedRounds = 0;
+		m_flGameStartTime = 0;
+		m_iHostagesRemaining = 0;
+		m_bLevelInitialized = false;
+		m_bLogoMap = false;
+		m_tmNextPeriodicThink = 0;
+
+		m_bMapHasBombTarget = false;
+		m_bMapHasRescueZone = false;
+
+		m_iSpawnPointCount_Terrorist = 0;
+		m_iSpawnPointCount_CT = 0;
+
+		m_bTCantBuy = false;
+		m_bCTCantBuy = false;
+		m_bMapHasBuyZone = false;
+
+		m_iLoserBonus = 0;
+
+		m_iHostagesRescued = 0;
+		m_iHostagesTouched = 0;
+		m_flNextHostageAnnouncement = 0.0f;
+
+        //=============================================================================
+        // HPE_BEGIN
+        // [dwenger] Reset rescue-related achievement values
+        //=============================================================================
+
+		// [tj] reset flawless and lossless round related flags
+		m_bNoTerroristsKilled = true;
+		m_bNoCTsKilled = true;
+		m_bNoTerroristsDamaged = true;
+		m_bNoCTsDamaged = true;
+		m_pFirstKill = NULL;
+		m_firstKillTime = 0;
+
+		// [menglish] Reset fun fact values
+		m_pFirstBlood = NULL;
+		m_firstBloodTime = 0;
+
+        m_bCanDonateWeapons = true;
+
+		// [dwenger] Reset rescue-related achievement values
+        m_pLastRescuer = NULL;
+        m_iNumRescuers = 0;
+
+		m_hostageWasInjured = false;
+		m_hostageWasKilled = false;
+
+		m_pFunFactManager = new CCSFunFactMgr();
+		m_pFunFactManager->Init();
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+		m_iHaveEscaped = 0;
+		m_bMapHasEscapeZone = false;
+		m_iNumEscapers = 0;
+		m_iNumEscapeRounds = 0;
+
+		m_iMapHasVIPSafetyZone = 0;
+		m_pVIP = NULL;
+		m_iConsecutiveVIP = 0;
+
+		m_bMapHasBombZone = false;
+		m_bBombDropped = false;
+		m_bBombPlanted = false;
+		m_pLastBombGuy = NULL;
+
+		m_bAllowWeaponSwitch = true;
+
+		m_flNextHostageAnnouncement = gpGlobals->curtime;	// asap.
+
+		ReadMultiplayCvars();
+
+		m_pPrices = NULL;
+		m_bBlackMarket = false;
+		m_bDontUploadStats = false;
+
+		// Create the team managers
+		for ( int i = 0; i < ARRAYSIZE( sTeamNames ); i++ )
+		{
+			CTeam *pTeam = static_cast<CTeam*>(CreateEntityByName( "cs_team_manager" ));
+			pTeam->Init( sTeamNames[i], i );
+
+			g_Teams.AddToTail( pTeam );
+		}
+
+		if ( filesystem->FileExists( UTIL_VarArgs( "maps/cfg/%s.cfg", STRING(gpGlobals->mapname) ) ) )
+		{
+			// Execute a map specific cfg file - as in Day of Defeat
+			// Map names cannot contain quotes or control characters so this is safe but silly that we have to do it.
+			engine->ServerCommand( UTIL_VarArgs( "exec \"%s.cfg\" */maps\n", STRING(gpGlobals->mapname) ) );
+			engine->ServerExecute();
+		}
+
+#ifndef CLIENT_DLL
+		// stats
+
+		if ( g_flGameStatsUpdateTime == 0.0f )
+		{
+			memset( g_iWeaponPurchases, 0, sizeof( g_iWeaponPurchases) );
+			memset( g_iTerroristVictories, 0, sizeof( g_iTerroristVictories) );
+			memset( g_iCounterTVictories, 0, sizeof( g_iTerroristVictories) );
+			g_flGameStatsUpdateTime = CS_GAME_STATS_UPDATE; //Next update is between 22 and 24 hours.
+		}
+#endif
+	}
+
+	void CCSGameRules::AddPricesToTable( weeklyprice_t prices )
+	{
+		int iIndex = m_StringTableBlackMarket->FindStringIndex( "blackmarket_prices" );
+
+		if ( iIndex == INVALID_STRING_INDEX )
+		{
+			m_StringTableBlackMarket->AddString( CBaseEntity::IsServer(), "blackmarket_prices", sizeof( weeklyprice_t), &prices );
+		}
+		else
+		{
+			m_StringTableBlackMarket->SetStringUserData( iIndex, sizeof( weeklyprice_t), &prices );
+		}
+
+		SetBlackMarketPrices( false );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	CCSGameRules::~CCSGameRules()
+	{
+		// Note, don't delete each team since they are in the gEntList and will 
+		// automatically be deleted from there, instead.
+		g_Teams.Purge();
+		if( m_pFunFactManager )
+		{
+			delete m_pFunFactManager;
+		}
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	void CCSGameRules::UpdateClientData( CBasePlayer *player )
+	{
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: TF2 Specific Client Commands
+	// Input  :
+	// Output :
+	//-----------------------------------------------------------------------------
+	bool CCSGameRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( pEdict );
+
+		if ( FStrEq( args[0], "changeteam" ) )
+		{
+			return true;
+		}
+		else if ( FStrEq( args[0], "nextmap" ) )
+		{
+			if ( pPlayer->m_iNextTimeCheck < gpGlobals->curtime )
+			{
+				char szNextMap[32];
+
+				if ( nextlevel.GetString() && *nextlevel.GetString() )
+				{
+					Q_strncpy( szNextMap, nextlevel.GetString(), sizeof( szNextMap ) );
+				}
+				else
+				{
+					GetNextLevelName( szNextMap, sizeof( szNextMap ) );
+				}
+
+				ClientPrint( pPlayer, HUD_PRINTTALK, "#game_nextmap", szNextMap);
+
+				pPlayer->m_iNextTimeCheck = gpGlobals->curtime + 1;
+			}
+			return true;
+		}
+		else if( pPlayer->ClientCommand( args ) )
+		{
+			return true;
+		}
+		else if( BaseClass::ClientCommand( pEdict, args ) )
+		{
+			return true;
+		}
+		else if ( TheBots->ServerCommand( args.GetCommandString() ) )
+		{
+			return true;
+		}
+		else
+		{
+			return TheBots->ClientCommand( pPlayer, args );
+		}
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Player has just spawned. Equip them.
+	//-----------------------------------------------------------------------------
+	void CCSGameRules::ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues )
+	{
+		CCSPlayer *pPlayer = dynamic_cast< CCSPlayer * >( CBaseEntity::Instance( pEntity ) );
+		if ( pPlayer )
+		{
+			char const *pszCommand = pKeyValues->GetName();
+			if ( pszCommand && pszCommand[0] )
+			{
+				if ( FStrEq( pszCommand, "ClanTagChanged" ) )
+				{
+					pPlayer->SetClanTag( pKeyValues->GetString( "tag", "" ) );
+
+					const char *teamName = "UNKNOWN";
+					if ( pPlayer->GetTeam() )
+					{
+						teamName = pPlayer->GetTeam()->GetName();
+					}
+					UTIL_LogPrintf("\"%s<%i><%s><%s>\" triggered \"clantag\" (value \"%s\")\n", 
+						pPlayer->GetPlayerName(),
+						pPlayer->GetUserID(),
+						pPlayer->GetNetworkIDString(),
+						teamName,
+						pKeyValues->GetString( "tag", "unknown" ) );
+				}
+			}
+		}
+
+		BaseClass::ClientCommandKeyValues( pEntity, pKeyValues );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Player has just spawned. Equip them.
+	//-----------------------------------------------------------------------------
+	void CCSGameRules::PlayerSpawn( CBasePlayer *pBasePlayer )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( pBasePlayer );
+		if ( !pPlayer )
+			Error( "PlayerSpawn" );
+
+		if ( pPlayer->State_Get() != STATE_ACTIVE )
+			return;
+
+		pPlayer->EquipSuit();
+		
+		bool addDefault = true;
+
+		CBaseEntity	*pWeaponEntity = NULL;
+		while ( ( pWeaponEntity = gEntList.FindEntityByClassname( pWeaponEntity, "game_player_equip" )) != NULL )
+		{
+			if ( addDefault )
+			{
+				// remove all our weapons and armor before touching the first game_player_equip
+				pPlayer->RemoveAllItems( true );
+			}
+			pWeaponEntity->Touch( pPlayer );
+			addDefault = false;
+		}
+
+
+		if ( addDefault || pPlayer->m_bIsVIP )
+			pPlayer->GiveDefaultItems();
+	}
+
+	void CCSGameRules::BroadcastSound( const char *sound, int team )
+	{
+		CBroadcastRecipientFilter filter;
+		filter.MakeReliable();
+
+		if( team != -1 )
+		{
+			filter.RemoveAllRecipients();
+			filter.AddRecipientsByTeam( GetGlobalTeam(team) );
+		}
+
+		UserMessageBegin ( filter, "SendAudio" );
+			WRITE_STRING( sound );
+		MessageEnd();
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Player has just spawned. Equip them.
+	//-----------------------------------------------------------------------------
+
+	// return a multiplier that should adjust the damage done by a blast at position vecSrc to something at the position
+	// vecEnd.  This will take into account the density of an entity that blocks the line of sight from one position to
+	// the other.
+	//
+	// this algorithm was taken from the HL2 version of RadiusDamage.
+	float CCSGameRules::GetExplosionDamageAdjustment(Vector & vecSrc, Vector & vecEnd, CBaseEntity *pEntityToIgnore)
+	{
+		float retval = 0.0;
+		trace_t tr;
+
+		UTIL_TraceLine(vecSrc, vecEnd, MASK_SHOT, pEntityToIgnore, COLLISION_GROUP_NONE, &tr);
+		if (tr.fraction == 1.0)
+		{
+			retval = 1.0;
+		}
+		else if (!(tr.DidHitWorld()) && (tr.m_pEnt != NULL) && (tr.m_pEnt != pEntityToIgnore) && (tr.m_pEnt->GetOwnerEntity() != pEntityToIgnore))
+		{
+			// if we didn't hit world geometry perhaps there's still damage to be done here.
+
+			CBaseEntity *blockingEntity = tr.m_pEnt;
+
+			// check to see if this part of the player is visible if entities are ignored.
+			UTIL_TraceLine(vecSrc, vecEnd, CONTENTS_SOLID, NULL, COLLISION_GROUP_NONE, &tr);
+
+			if (tr.fraction == 1.0)
+			{
+				if ((blockingEntity != NULL) && (blockingEntity->VPhysicsGetObject() != NULL))
+				{
+					int nMaterialIndex = blockingEntity->VPhysicsGetObject()->GetMaterialIndex();
+
+					float flDensity;
+					float flThickness;
+					float flFriction;
+					float flElasticity;
+
+					physprops->GetPhysicsProperties( nMaterialIndex, &flDensity,
+						&flThickness, &flFriction, &flElasticity );
+
+					const float DENSITY_ABSORB_ALL_DAMAGE = 3000.0;
+					float scale = flDensity / DENSITY_ABSORB_ALL_DAMAGE;
+					if ((scale >= 0.0) && (scale < 1.0))
+					{
+						retval = 1.0 - scale;
+					}
+					else if (scale < 0.0)
+					{
+						// should never happen, but just in case.
+						retval = 1.0;
+					}
+				}
+				else
+				{
+					retval = 0.75; // we're blocked by something that isn't an entity with a physics module or world geometry, just cut damage in half for now.
+				}
+			}
+		}
+
+		return retval;
+	}
+
+	// returns the percentage of the player that is visible from the given point in the world.
+	// return value is between 0 and 1.
+	float CCSGameRules::GetAmountOfEntityVisible(Vector & vecSrc, CBaseEntity *entity)
+	{
+		float retval = 0.0;
+
+		const float damagePercentageChest = 0.40;
+		const float damagePercentageHead = 0.20;
+		const float damagePercentageFeet = 0.20;
+		const float damagePercentageRightSide = 0.10;
+		const float damagePercentageLeftSide = 0.10;
+
+		if (!(entity->IsPlayer()))
+		{
+			// the entity is not a player, so the damage is all or nothing.
+			Vector vecTarget;
+			vecTarget = entity->BodyTarget(vecSrc, false);
+
+			return GetExplosionDamageAdjustment(vecSrc, vecTarget, entity);
+		}
+
+		CCSPlayer *player = (CCSPlayer *)entity;
+
+		// check what parts of the player we can see from this point and modify the return value accordingly.
+		float chestHeightFromFeet;
+
+		float armDistanceFromChest = HalfHumanWidth;
+
+		// calculate positions of various points on the target player's body
+		Vector vecFeet = player->GetAbsOrigin();
+
+		Vector vecChest = player->BodyTarget(vecSrc, false);
+		chestHeightFromFeet = vecChest.z - vecFeet.z;  // compute the distance from the chest to the feet. (this accounts for ducking and the like)
+
+		Vector vecHead = player->GetAbsOrigin();
+		vecHead.z += HumanHeight;
+
+		Vector vecRightFacing;
+		AngleVectors(player->GetAbsAngles(), NULL, &vecRightFacing, NULL);
+
+		vecRightFacing.NormalizeInPlace();
+		vecRightFacing = vecRightFacing * armDistanceFromChest;
+
+		Vector vecLeftSide = player->GetAbsOrigin();
+		vecLeftSide.x -= vecRightFacing.x;
+		vecLeftSide.y -= vecRightFacing.y;
+		vecLeftSide.z += chestHeightFromFeet;
+
+		Vector vecRightSide = player->GetAbsOrigin();
+		vecRightSide.x += vecRightFacing.x;
+		vecRightSide.y += vecRightFacing.y;
+		vecRightSide.z += chestHeightFromFeet;
+
+		// check chest
+		float damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecChest, entity);
+		retval += (damagePercentageChest * damageAdjustment);
+
+		// check top of head
+		damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecHead, entity);
+		retval += (damagePercentageHead * damageAdjustment);
+
+		// check feet
+		damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecFeet, entity);
+		retval += (damagePercentageFeet * damageAdjustment);
+
+		// check left "edge"
+		damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecLeftSide, entity);
+		retval += (damagePercentageLeftSide * damageAdjustment);
+
+		// check right "edge"
+		damageAdjustment = GetExplosionDamageAdjustment(vecSrc, vecRightSide, entity);
+		retval += (damagePercentageRightSide * damageAdjustment);
+
+		return retval;
+	}
+
+	void CCSGameRules::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, CBaseEntity * pEntityIgnore )
+	{
+		RadiusDamage( info, vecSrcIn, flRadius, iClassIgnore, false );
+	}
+
+	// Add the ability to ignore the world trace
+	void CCSGameRules::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, bool bIgnoreWorld )
+	{
+		CBaseEntity *pEntity = NULL;
+		trace_t		tr;
+		float		falloff, damagePercentage;
+		Vector		vecSpot;
+		Vector		vecToTarget;
+		Vector		vecEndPos;
+
+        //=============================================================================
+        // HPE_BEGIN:        
+        //=============================================================================
+         
+		// [tj] The number of enemy players this explosion killed
+        int numberOfEnemyPlayersKilledByThisExplosion = 0;
+		
+		// [tj] who we award the achievement to if enough players are killed
+		CCSPlayer* pCSExplosionAttacker = ToCSPlayer(info.GetAttacker());
+
+		// [tj] used to determine which achievement to award for sufficient kills
+		CBaseEntity* pInflictor = info.GetInflictor();
+		bool isGrenade = pInflictor && V_strcmp(pInflictor->GetClassname(), "hegrenade_projectile") == 0;
+		bool isBomb = pInflictor && V_strcmp(pInflictor->GetClassname(), "planted_c4") == 0;
+         
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+        
+
+		vecEndPos.Init();
+
+		Vector vecSrc = vecSrcIn;
+
+		damagePercentage = 1.0;
+
+		if ( flRadius )
+			falloff = info.GetDamage() / flRadius;
+		else
+			falloff = 1.0;
+
+		int bInWater = (UTIL_PointContents ( vecSrc ) & MASK_WATER) ? true : false;
+		
+		vecSrc.z += 1;// in case grenade is lying on the ground
+
+		// iterate on all entities in the vicinity.
+		for ( CEntitySphereQuery sphere( vecSrc, flRadius ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
+		{
+			//=============================================================================
+			// HPE_BEGIN:
+			// [tj] We have to save whether or not the player is killed so we don't give credit 
+			//		for pre-dead players.
+			//=============================================================================
+			bool wasAliveBeforeExplosion = false;
+			CCSPlayer* pCSExplosionVictim = ToCSPlayer(pEntity);
+			if (pCSExplosionVictim)
+			{
+				wasAliveBeforeExplosion = pCSExplosionVictim->IsAlive();
+			}
+			//=============================================================================
+			// HPE_END
+			//=============================================================================
+			if ( pEntity->m_takedamage != DAMAGE_NO )
+			{
+				// UNDONE: this should check a damage mask, not an ignore
+				if ( iClassIgnore != CLASS_NONE && pEntity->Classify() == iClassIgnore )
+				{// houndeyes don't hurt other houndeyes with their attack
+					continue;
+				}
+
+				// blasts don't travel into or out of water
+				if ( !bIgnoreWorld )
+				{
+					if (bInWater && pEntity->GetWaterLevel() == 0)
+						continue;
+					if (!bInWater && pEntity->GetWaterLevel() == 3)
+						continue;
+				}
+
+				// radius damage can only be blocked by the world
+				vecSpot = pEntity->BodyTarget( vecSrc );
+
+				bool bHit = false;
+
+				if( bIgnoreWorld )
+				{
+					vecEndPos = vecSpot;
+					bHit = true;
+				}
+				else
+				{
+					// get the percentage of the target entity that is visible from the
+					// explosion position.
+					damagePercentage = GetAmountOfEntityVisible(vecSrc, pEntity);
+					if (damagePercentage > 0.0)
+					{
+						vecEndPos = vecSpot;
+
+						bHit = true;
+					}
+				}
+
+				if ( bHit )
+				{
+					// the explosion can 'see' this entity, so hurt them!
+					//vecToTarget = ( vecSrc - vecEndPos );
+					vecToTarget = ( vecEndPos - vecSrc );
+
+					// use a Gaussian function to describe the damage falloff over distance, with flRadius equal to 3 * sigma
+					// this results in the following values:
+					// 
+					// Range Fraction  Damage
+					//		0.0			100%
+					// 		0.1			96%
+					// 		0.2			84%
+					// 		0.3			67%
+					// 		0.4			49%
+					// 		0.5			32%
+					// 		0.6			20%
+					// 		0.7			11%
+					// 		0.8			 6%
+					// 		0.9			 3%
+					// 		1.0			 1%
+
+					float fDist = vecToTarget.Length();
+					float fSigma = flRadius / 3.0f; // flRadius specifies 3rd standard deviation (0.0111 damage at this range)
+					float fGaussianFalloff = exp(-fDist * fDist / (2.0f * fSigma * fSigma));
+					float flAdjustedDamage = info.GetDamage() * fGaussianFalloff * damagePercentage;
+				
+					if ( flAdjustedDamage > 0 )
+					{
+						CTakeDamageInfo adjustedInfo = info;
+						adjustedInfo.SetDamage( flAdjustedDamage );
+
+						Vector dir = vecToTarget;
+						VectorNormalize( dir );
+
+						// If we don't have a damage force, manufacture one
+						if ( adjustedInfo.GetDamagePosition() == vec3_origin || adjustedInfo.GetDamageForce() == vec3_origin )
+						{
+							CalculateExplosiveDamageForce( &adjustedInfo, dir, vecSrc, 1.5	/* explosion scale! */ );
+						}
+						else
+						{
+							// Assume the force passed in is the maximum force. Decay it based on falloff.
+							float flForce = adjustedInfo.GetDamageForce().Length() * falloff;
+							adjustedInfo.SetDamageForce( dir * flForce );
+							adjustedInfo.SetDamagePosition( vecSrc );
+						}
+
+						Vector vecTarget;
+						vecTarget = pEntity->BodyTarget(vecSrc, false);
+
+						UTIL_TraceLine(vecSrc, vecTarget, MASK_SHOT, NULL, COLLISION_GROUP_NONE, &tr);
+
+						// blasts always hit chest
+						tr.hitgroup = HITGROUP_GENERIC;
+
+						if (tr.fraction != 1.0)
+						{
+							// this has to be done to make breakable glass work.
+							ClearMultiDamage( );
+							pEntity->DispatchTraceAttack( adjustedInfo, dir, &tr );
+							ApplyMultiDamage();
+						}
+						else
+						{
+							pEntity->TakeDamage( adjustedInfo );
+						}
+			
+						// Now hit all triggers along the way that respond to damage... 
+						pEntity->TraceAttackToTriggers( adjustedInfo, vecSrc, vecEndPos, dir );
+						//=============================================================================
+						// HPE_BEGIN:
+						// [sbodenbender] Increment grenade damage stat
+						//=============================================================================
+						if (pCSExplosionVictim && pCSExplosionAttacker && isGrenade)
+						{
+							CCS_GameStats.IncrementStat(pCSExplosionAttacker, CSSTAT_GRENADE_DAMAGE, static_cast<int>(adjustedInfo.GetDamage()));
+						}
+						//=============================================================================
+						// HPE_END
+						//=============================================================================
+					}
+				}
+			}
+            
+            //=============================================================================
+            // HPE_BEGIN:
+            // [tj] Count up victims of area of effect damage for achievement purposes
+            //=============================================================================
+             
+            if (pCSExplosionVictim)
+			{
+				//If the bomb is exploding, set the attacker to the planter (we can't put this in the CTakeDamageInfo, since
+				//players aren't supposed to get credit for bomb kills)
+				if (isBomb)
+				{
+					CPlantedC4* bomb = static_cast<CPlantedC4*> (pInflictor);
+					if (bomb)
+					{
+						pCSExplosionAttacker = bomb->GetPlanter();
+					}
+				}
+
+				//Count check to make sure we killed an enemy player
+				if(	pCSExplosionAttacker &&                  
+					!pCSExplosionVictim->IsAlive() && 
+					wasAliveBeforeExplosion &&
+					pCSExplosionVictim->GetTeamNumber() != pCSExplosionAttacker->GetTeamNumber())               
+				{
+					numberOfEnemyPlayersKilledByThisExplosion++;
+				}
+			}             
+            //=============================================================================
+            // HPE_END
+            //=============================================================================
+            
+		}
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [tj] //Depending on which type of explosion it was, award the appropriate achievement.
+		//=============================================================================
+		
+		if (pCSExplosionAttacker && isGrenade && numberOfEnemyPlayersKilledByThisExplosion >= AchievementConsts::GrenadeMultiKill_MinKills)
+		{
+			pCSExplosionAttacker->AwardAchievement(CSGrenadeMultikill);    
+			pCSExplosionAttacker->CheckMaxGrenadeKills(numberOfEnemyPlayersKilledByThisExplosion);
+
+		}
+		if (pCSExplosionAttacker && isBomb && numberOfEnemyPlayersKilledByThisExplosion >= AchievementConsts::BombMultiKill_MinKills)
+		{
+			pCSExplosionAttacker->AwardAchievement(CSBombMultikill);            
+		}
+
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : *pVictim - 
+	//			*pKiller - 
+	//			*pInflictor - 
+	//-----------------------------------------------------------------------------
+	void CCSGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
+	{
+		// Work out what killed the player, and send a message to all clients about it
+		const char *killer_weapon_name = "world";		// by default, the player is killed by the world
+		int killer_ID = 0;
+
+		// Find the killer & the scorer
+		CBaseEntity *pInflictor = info.GetInflictor();
+		CBaseEntity *pKiller = info.GetAttacker();
+		CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor );
+		CCSPlayer *pCSVictim = (CCSPlayer*)(pVictim);
+
+		bool bHeadshot = false;
+
+		if ( pScorer )	// Is the killer a client?
+		{
+			killer_ID = pScorer->GetUserID();
+		
+			if( info.GetDamageType() & DMG_HEADSHOT )
+			{
+				//to enable drawing the headshot icon as well as the weapon icon, 
+				bHeadshot = true;
+			}
+			
+			if ( pInflictor )
+			{
+				if ( pInflictor == pScorer )
+				{
+					// If the inflictor is the killer,  then it must be their current weapon doing the damage
+					if ( pScorer->GetActiveWeapon() )
+					{
+						killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname(); //GetDeathNoticeName();
+					}
+				}
+				else
+				{
+					killer_weapon_name = STRING( pInflictor->m_iClassname );  // it's just that easy
+				}
+			}
+		}
+		else
+		{
+			killer_weapon_name = STRING( pInflictor->m_iClassname );
+		}
+
+		// strip the NPC_* or weapon_* from the inflictor's classname
+		if ( strncmp( killer_weapon_name, "weapon_", 7 ) == 0 )
+		{
+			killer_weapon_name += 7;
+		}
+		else if ( strncmp( killer_weapon_name, "NPC_", 8 ) == 0 )
+		{
+			killer_weapon_name += 8;
+		}
+		else if ( strncmp( killer_weapon_name, "func_", 5 ) == 0 )
+		{
+			killer_weapon_name += 5;
+		}
+		else if( strncmp( killer_weapon_name, "hegrenade", 9 ) == 0 )	//"hegrenade_projectile"	
+		{
+			killer_weapon_name = "hegrenade";
+		}
+		else if( strncmp( killer_weapon_name, "flashbang", 9 ) == 0 )	//"flashbang_projectile"
+		{
+			killer_weapon_name = "flashbang";
+		}
+
+		IGameEvent * event = gameeventmanager->CreateEvent( "player_death" );
+
+		if ( event )
+		{
+			event->SetInt("userid", pVictim->GetUserID() );
+			event->SetInt("attacker", killer_ID );
+			event->SetString("weapon", killer_weapon_name );
+			event->SetInt("headshot", bHeadshot ? 1 : 0 );
+			event->SetInt("priority", bHeadshot ? 8 : 7 );	// HLTV event priority, not transmitted
+			if ( pCSVictim->GetDeathFlags() & CS_DEATH_DOMINATION )
+			{
+				event->SetInt( "dominated", 1 );
+			}
+			else if ( pCSVictim->GetDeathFlags() & CS_DEATH_REVENGE )
+			{
+				event->SetInt( "revenge", 1 );
+			}
+			
+			gameeventmanager->FireEvent( event );
+		}
+	}
+
+	//=========================================================
+	//=========================================================
+	void CCSGameRules::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info )
+	{
+		CBaseEntity *pInflictor = info.GetInflictor();
+		CBaseEntity *pKiller = info.GetAttacker();
+		CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor );
+		CCSPlayer *pCSVictim = (CCSPlayer *)pVictim;
+		CCSPlayer *pCSScorer = (CCSPlayer *)pScorer;
+
+		CCS_GameStats.PlayerKilled( pVictim, info );
+		//=============================================================================
+		// HPE_BEGIN:        
+		// [tj] Flag the round as non-lossless for the appropriate team.
+		// [menglish] Set the death flags depending on a nemesis system
+		//=============================================================================
+
+		if (pVictim->GetTeamNumber() == TEAM_TERRORIST)
+		{
+			m_bNoTerroristsKilled = false;
+			m_bNoTerroristsDamaged = false;            
+		}
+		if (pVictim->GetTeamNumber() == TEAM_CT)
+		{
+			m_bNoCTsKilled = false;
+			m_bNoCTsDamaged = false;
+		}
+
+        m_bCanDonateWeapons = false;
+
+		if ( m_pFirstKill == NULL && pCSScorer != pVictim )
+		{
+			m_pFirstKill = pCSScorer;
+			m_firstKillTime = gpGlobals->curtime - m_fRoundStartTime;
+		}
+
+		// determine if this kill affected a nemesis relationship
+		int iDeathFlags = 0;
+		if ( pScorer )
+		{	
+            CCS_GameStats.CalculateOverkill( pCSScorer, pCSVictim);
+			CCS_GameStats.CalcDominationAndRevenge( pCSScorer, pCSVictim, &iDeathFlags );            
+		}
+		pCSVictim->SetDeathFlags( iDeathFlags );	
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+		// If we're killed by the C4, we do a subset of BaseClass::PlayerKilled()
+		// Specifically, we shouldn't lose any points or show death notices, to match goldsrc
+		if ( Q_strcmp(pKiller->GetClassname(), "planted_c4" ) == 0 )
+		{
+			// dvsents2: uncomment when removing all FireTargets
+			// variant_t value;
+			// g_EventQueue.AddEvent( "game_playerdie", "Use", value, 0, pVictim, pVictim );
+			FireTargets( "game_playerdie", pVictim, pVictim, USE_TOGGLE, 0 );
+		}
+		else
+		{
+			BaseClass::PlayerKilled( pVictim, info );
+		}
+
+		// check for team-killing, and give monetary rewards/penalties
+		// Find the killer & the scorer
+		if ( !pScorer )
+			return;
+
+		if ( IPointsForKill( pScorer, pVictim ) < 0 )
+		{
+			// team-killer!
+			pCSScorer->AddAccount( -3300 );
+			++pCSScorer->m_iTeamKills;
+			pCSScorer->m_bJustKilledTeammate = true;
+
+			ClientPrint( pCSScorer, HUD_PRINTCENTER, "#Killed_Teammate" );
+			if ( mp_autokick.GetBool() )
+			{
+				char strTeamKills[64];
+				Q_snprintf( strTeamKills, sizeof( strTeamKills ), "%d", pCSScorer->m_iTeamKills );
+				ClientPrint( pCSScorer, HUD_PRINTCONSOLE, "#Game_teammate_kills", strTeamKills ); // this includes a " of 3" in it
+
+				if ( pCSScorer->m_iTeamKills >= 3 )
+				{
+					ClientPrint( pCSScorer, HUD_PRINTCONSOLE, "#Banned_For_Killing_Teammates" );
+					engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pCSScorer->GetUserID() ) );
+				}
+				else if ( mp_spawnprotectiontime.GetInt() > 0 && GetRoundElapsedTime() < mp_spawnprotectiontime.GetInt() )
+				{
+					ClientPrint( pCSScorer, HUD_PRINTCONSOLE, "#Banned_For_Killing_Teammates" );
+					engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pCSScorer->GetUserID() ) );
+				}
+			}
+
+			if ( !(pCSScorer->m_iDisplayHistoryBits & DHF_FRIEND_KILLED) )
+			{
+				pCSScorer->m_iDisplayHistoryBits |= DHF_FRIEND_KILLED;
+				pCSScorer->HintMessage( "#Hint_careful_around_teammates", false );
+			}
+		}
+		else
+		{
+			//=============================================================================
+			// HPE_BEGIN:
+			// [tj] Added a check to make sure we don't get money for suicides.
+			//=============================================================================
+			if (pCSScorer != pCSVictim)
+			{
+			//=============================================================================
+			// HPE_END
+			//=============================================================================
+				if ( pCSVictim->IsVIP() )
+				{
+					pCSScorer->HintMessage( "#Hint_reward_for_killing_vip", true );
+					pCSScorer->AddAccount( 2500 );
+				}
+				else			
+				{
+					pCSScorer->AddAccount( 300 );
+				}
+			}
+
+			if ( !(pCSScorer->m_iDisplayHistoryBits & DHF_ENEMY_KILLED) )
+			{
+				pCSScorer->m_iDisplayHistoryBits |= DHF_ENEMY_KILLED;
+				pCSScorer->HintMessage( "#Hint_win_round_by_killing_enemy", false );
+			}
+		}
+	}
+
+
+	void CCSGameRules::InitDefaultAIRelationships()
+	{
+		//  Allocate memory for default relationships
+		CBaseCombatCharacter::AllocateDefaultRelationships();
+
+		// --------------------------------------------------------------
+		// First initialize table so we can report missing relationships
+		// --------------------------------------------------------------
+		int i, j;
+		for (i=0;i<NUM_AI_CLASSES;i++)
+		{
+			for (j=0;j<NUM_AI_CLASSES;j++)
+			{
+				// By default all relationships are neutral of priority zero
+				CBaseCombatCharacter::SetDefaultRelationship( (Class_T)i, (Class_T)j, D_NU, 0 );
+			}
+		}
+	}
+
+	//------------------------------------------------------------------------------
+	// Purpose : Return classify text for classify type
+	//------------------------------------------------------------------------------
+	const char *CCSGameRules::AIClassText(int classType)
+	{
+		switch (classType)
+		{
+			case CLASS_NONE:			return "CLASS_NONE";
+			case CLASS_PLAYER:			return "CLASS_PLAYER";
+			default:					return "MISSING CLASS in ClassifyText()";
+		}
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: When gaining new technologies in TF, prevent auto switching if we
+	//  receive a weapon during the switch
+	// Input  : *pPlayer - 
+	//			*pWeapon - 
+	// Output : Returns true on success, false on failure.
+	//-----------------------------------------------------------------------------
+	bool CCSGameRules::FShouldSwitchWeapon( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon )
+	{
+		bool bIsBeingGivenItem = false;
+		CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+		if ( pCSPlayer && pCSPlayer->IsBeingGivenItem() )
+			bIsBeingGivenItem = true;
+
+		if ( pPlayer->GetActiveWeapon() && pPlayer->IsNetClient() && !bIsBeingGivenItem )
+		{
+			// Player has an active item, so let's check cl_autowepswitch.
+			const char *cl_autowepswitch = engine->GetClientConVarValue( engine->IndexOfEdict( pPlayer->edict() ), "cl_autowepswitch" );
+			if ( cl_autowepswitch && atoi( cl_autowepswitch ) <= 0 )
+			{
+				return false;
+			}
+		}
+
+		if ( pPlayer->IsBot() && !bIsBeingGivenItem )
+		{
+			return false;
+		}
+
+		if ( !GetAllowWeaponSwitch() )
+		{
+			return false;
+		}
+
+		return BaseClass::FShouldSwitchWeapon( pPlayer, pWeapon );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : allow - 
+	//-----------------------------------------------------------------------------
+	void CCSGameRules::SetAllowWeaponSwitch( bool allow )
+	{
+		m_bAllowWeaponSwitch = allow;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Output : Returns true on success, false on failure.
+	//-----------------------------------------------------------------------------
+	bool CCSGameRules::GetAllowWeaponSwitch()
+	{
+		return m_bAllowWeaponSwitch;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : *pPlayer - 
+	// Output : const char
+	//-----------------------------------------------------------------------------
+	const char *CCSGameRules::SetDefaultPlayerTeam( CBasePlayer *pPlayer )
+	{
+		Assert( pPlayer );
+		return BaseClass::SetDefaultPlayerTeam( pPlayer );
+	}
+
+
+	void CCSGameRules::LevelInitPreEntity()
+	{
+		BaseClass::LevelInitPreEntity();
+
+		// TODO for CZ-style hostages: TheHostageChatter->Precache();
+	}
+
+
+	void CCSGameRules::LevelInitPostEntity()
+	{
+		BaseClass::LevelInitPostEntity();
+
+		m_bLevelInitialized = false; // re-count CT and T start spots now that they exist
+
+		// Figure out from the entities in the map what kind of map this is (bomb run, prison escape, etc).
+		CheckMapConditions();
+	}
+	
+	INetworkStringTable *g_StringTableBlackMarket = NULL;
+
+	void CCSGameRules::CreateCustomNetworkStringTables( void )
+	{
+		m_StringTableBlackMarket = g_StringTableBlackMarket;
+
+		if ( 0 )//mp_dynamicpricing.GetBool() )
+		{
+			m_bBlackMarket = BlackMarket_DownloadPrices();
+
+			if ( m_bBlackMarket == false )
+			{
+				Msg( "ERROR: mp_dynamicpricing set to 1 but couldn't download the price list!\n" );
+			}
+		}
+		else
+		{
+			m_bBlackMarket = false;
+			SetBlackMarketPrices( true );
+		}
+	}
+
+	float CCSGameRules::FlPlayerFallDamage( CBasePlayer *pPlayer )
+	{
+		float fFallVelocity = pPlayer->m_Local.m_flFallVelocity - CS_PLAYER_MAX_SAFE_FALL_SPEED;
+		float fallDamage = fFallVelocity * CS_DAMAGE_FOR_FALL_SPEED * 1.25;
+
+		if ( fallDamage > 0.0f )
+		{
+			// let the bots know
+			IGameEvent * event = gameeventmanager->CreateEvent( "player_falldamage" );
+			if ( event )
+			{
+				event->SetInt( "userid", pPlayer->GetUserID() );
+				event->SetFloat( "damage", fallDamage );
+				event->SetInt( "priority", 4 );	// HLTV event priority, not transmitted
+				
+				gameeventmanager->FireEvent( event );
+			}
+		}
+
+		return fallDamage;
+	} 
+
+	
+	void CCSGameRules::ClientDisconnected( edict_t *pClient )
+	{
+		BaseClass::ClientDisconnected( pClient );
+
+        //=============================================================================
+        // HPE_BEGIN:
+        // [tj] Clear domination data when a player disconnects
+        //=============================================================================
+         
+        CCSPlayer *pPlayer = ToCSPlayer( GetContainingEntity( pClient ) );
+        if ( pPlayer )
+        {
+            pPlayer->RemoveNemesisRelationships();
+        }
+         
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+        
+
+		CheckWinConditions();
+	}
+
+
+	// Called when game rules are destroyed by CWorld
+	void CCSGameRules::LevelShutdown()
+	{
+		int iLevelIndex = GetCSLevelIndex( STRING( gpGlobals->mapname ) );
+
+		if ( iLevelIndex != -1 )
+		{
+			g_iTerroristVictories[iLevelIndex] += m_iNumTerroristWins;
+			g_iCounterTVictories[iLevelIndex] += m_iNumCTWins;
+		}
+
+		BaseClass::LevelShutdown();
+	}
+
+	
+	//---------------------------------------------------------------------------------------------------
+	/**
+	 * Check if the scenario has been won/lost.
+	 * Return true if the scenario is over, false if the scenario is still in progress
+	 */
+	bool CCSGameRules::CheckWinConditions( void )
+	{
+		if ( mp_ignore_round_win_conditions.GetBool() )
+		{
+			return false;
+		}
+
+		// If a winner has already been determined.. then get the heck out of here
+		if (m_iRoundWinStatus != WINNER_NONE)
+		{
+			// still check if we lost players to where we need to do a full reset next round...
+			int NumDeadCT, NumDeadTerrorist, NumAliveTerrorist, NumAliveCT;
+			InitializePlayerCounts( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT );
+
+			bool bNeededPlayers = false;
+			NeededPlayersCheck( bNeededPlayers );
+
+			return true;
+		}
+
+		// Initialize the player counts..
+		int NumDeadCT, NumDeadTerrorist, NumAliveTerrorist, NumAliveCT;
+		InitializePlayerCounts( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT );
+
+
+		/***************************** OTHER PLAYER's CHECK *********************************************************/
+		bool bNeededPlayers = false;
+		if ( NeededPlayersCheck( bNeededPlayers ) )
+			return false;
+
+		/****************************** ASSASINATION/VIP SCENARIO CHECK *******************************************************/
+		if ( VIPRoundEndCheck( bNeededPlayers ) )
+			return true;
+
+		/****************************** PRISON ESCAPE CHECK *******************************************************/
+		if ( PrisonRoundEndCheck() )
+			return true;
+
+
+		/****************************** BOMB CHECK ********************************************************/
+		if ( BombRoundEndCheck( bNeededPlayers ) )
+			return true;
+
+
+		/***************************** TEAM EXTERMINATION CHECK!! *********************************************************/
+		// CounterTerrorists won by virture of elimination
+		if ( TeamExterminationCheck( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT, bNeededPlayers ) )
+			return true;
+
+		
+		/******************************** HOSTAGE RESCUE CHECK ******************************************************/
+		if ( HostageRescueRoundEndCheck( bNeededPlayers ) )
+			return true;
+
+		// scenario not won - still in progress
+		return false;
+	}
+
+
+	bool CCSGameRules::NeededPlayersCheck( bool &bNeededPlayers )
+	{
+		// We needed players to start scoring
+		// Do we have them now?
+		if( !m_iNumSpawnableTerrorist || !m_iNumSpawnableCT )
+		{
+			Msg( "Game will not start until both teams have players.\n" );
+			UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "#Game_scoring" );
+			bNeededPlayers = true;
+
+			m_bFirstConnected = false;
+		}
+
+		if ( !m_bFirstConnected && m_iNumSpawnableTerrorist && m_iNumSpawnableCT )
+		{
+			// Start the round immediately when the first person joins
+			// UTIL_LogPrintf( "World triggered \"Game_Commencing\"\n" );
+
+			m_bFreezePeriod  = false; //Make sure we are not on the FreezePeriod.
+			m_bCompleteReset = true;
+
+			TerminateRound( 3.0f, Game_Commencing );
+			m_bFirstConnected = true;
+			return true;
+		}
+
+		return false;
+	}
+
+
+	void CCSGameRules::InitializePlayerCounts(
+		int &NumAliveTerrorist,
+		int &NumAliveCT,
+		int &NumDeadTerrorist,
+		int &NumDeadCT
+		)
+	{
+		NumAliveTerrorist = NumAliveCT = NumDeadCT = NumDeadTerrorist = 0;
+		m_iNumTerrorist = m_iNumCT = m_iNumSpawnableTerrorist = m_iNumSpawnableCT = 0;
+		m_iHaveEscaped = 0;
+
+		// Count how many dead players there are on each team.
+		for ( int iTeam=0; iTeam < GetNumberOfTeams(); iTeam++ )
+		{
+			CTeam *pTeam = GetGlobalTeam( iTeam );
+
+			for ( int iPlayer=0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
+			{
+				CCSPlayer *pPlayer = ToCSPlayer( pTeam->GetPlayer( iPlayer ) );
+				Assert( pPlayer );
+				if ( !pPlayer )
+					continue;
+
+				Assert( pPlayer->GetTeamNumber() == pTeam->GetTeamNumber() );
+
+				switch ( pTeam->GetTeamNumber() )
+				{
+				case TEAM_CT:
+					m_iNumCT++;
+
+					if ( pPlayer->State_Get() != STATE_PICKINGCLASS )
+						m_iNumSpawnableCT++;
+
+					if ( pPlayer->m_lifeState != LIFE_ALIVE )
+						NumDeadCT++;
+					else
+						NumAliveCT++;
+
+					break;
+
+				case TEAM_TERRORIST:
+					m_iNumTerrorist++;
+
+					if ( pPlayer->State_Get() != STATE_PICKINGCLASS )
+						m_iNumSpawnableTerrorist++;
+
+					if ( pPlayer->m_lifeState != LIFE_ALIVE )
+						NumDeadTerrorist++;
+					else
+						NumAliveTerrorist++;
+
+					// Check to see if this guy escaped.
+					if ( pPlayer->m_bEscaped == true )
+						m_iHaveEscaped++;
+
+					break;
+				}
+			}
+		}
+	}
+
+	bool CCSGameRules::HostageRescueRoundEndCheck( bool bNeededPlayers )
+	{
+		// Check to see if 50% of the hostages have been rescued.
+		CHostage* hostage = NULL;
+
+		int iNumHostages = g_Hostages.Count();
+		int iNumLeftToRescue = 0;
+		int i;
+
+		for ( i=0; i<iNumHostages; i++ )
+		{
+			hostage = g_Hostages[i];
+
+			if ( hostage->m_iHealth > 0 && !hostage->IsRescued() ) // We've found a live hostage. don't end the round
+				iNumLeftToRescue++;
+		}
+
+		m_iHostagesRemaining = iNumLeftToRescue;
+
+		if ( (iNumLeftToRescue == 0) && (iNumHostages > 0) )
+		{
+			if ( m_iHostagesRescued >= (iNumHostages * 0.5)	)
+			{
+				m_iAccountCT += 2500;
+
+				if ( !bNeededPlayers )
+				{
+					m_iNumCTWins ++;
+					// Update the clients team score
+					UpdateTeamScores();
+				}
+				CCS_GameStats.Event_AllHostagesRescued();
+				// tell the bots all the hostages have been rescued
+				IGameEvent * event = gameeventmanager->CreateEvent( "hostage_rescued_all" );
+				if ( event )
+				{
+					gameeventmanager->FireEvent( event );
+				}
+
+				TerminateRound( mp_round_restart_delay.GetFloat(), All_Hostages_Rescued );
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+
+	bool CCSGameRules::PrisonRoundEndCheck()
+	{
+		//MIKETODO: get this working when working on prison escape
+		/*
+		if (m_bMapHasEscapeZone == true)
+		{
+			float flEscapeRatio;
+
+			flEscapeRatio = (float) m_iHaveEscaped / (float) m_iNumEscapers;
+
+			if (flEscapeRatio >= m_flRequiredEscapeRatio)
+			{
+				BroadcastSound( "Event.TERWin" );
+				m_iAccountTerrorist += 3150;
+
+				if ( !bNeededPlayers )
+				{
+					m_iNumTerroristWins ++;
+					// Update the clients team score
+					UpdateTeamScores();
+				}
+				EndRoundMessage( "#Terrorists_Escaped", Terrorists_Escaped );
+				TerminateRound( mp_round_restart_delay.GetFloat(), WINNER_TER );
+				return;
+			}
+			else if ( NumAliveTerrorist == 0 && flEscapeRatio < m_flRequiredEscapeRatio)
+			{
+				BroadcastSound( "Event.CTWin" );
+				m_iAccountCT += (1 - flEscapeRatio) * 3500; // CTs are rewarded based on how many terrorists have escaped...
+				
+				if ( !bNeededPlayers )
+				{
+					m_iNumCTWins++;
+					// Update the clients team score
+					UpdateTeamScores();
+				}
+				EndRoundMessage( "#CTs_PreventEscape", CTs_PreventEscape );
+				TerminateRound( mp_round_restart_delay.GetFloat(), WINNER_CT );
+				return;
+			}
+
+			else if ( NumAliveTerrorist == 0 && NumDeadTerrorist != 0 && m_iNumSpawnableCT > 0 )
+			{
+				BroadcastSound( "Event.CTWin" );
+				m_iAccountCT += (1 - flEscapeRatio) * 3250; // CTs are rewarded based on how many terrorists have escaped...
+				
+				if ( !bNeededPlayers )
+				{
+					m_iNumCTWins++;
+					// Update the clients team score
+					UpdateTeamScores();
+				}
+				EndRoundMessage( "#Escaping_Terrorists_Neutralized", Escaping_Terrorists_Neutralized );
+				TerminateRound( mp_round_restart_delay.GetFloat(), WINNER_CT );
+				return;
+			}
+			// else return;    
+		}
+		*/
+
+		return false;
+	}
+
+
+	bool CCSGameRules::VIPRoundEndCheck( bool bNeededPlayers )
+	{
+		if (m_iMapHasVIPSafetyZone != 1)
+			return false;
+
+		if (m_pVIP == NULL)
+			return false;
+
+		if (m_pVIP->m_bEscaped == true)
+		{
+			m_iAccountCT += 3500;
+
+			if ( !bNeededPlayers )
+			{
+				m_iNumCTWins ++;
+				// Update the clients team score
+				UpdateTeamScores();
+			}
+
+			//MIKETODO: get this working when working on VIP scenarios
+			/*
+			MessageBegin( MSG_SPEC, SVC_DIRECTOR );
+				WRITE_BYTE ( 9 );	// command length in bytes
+				WRITE_BYTE ( DRC_CMD_EVENT );	// VIP rescued
+				WRITE_SHORT( ENTINDEX(m_pVIP->edict()) );	// index number of primary entity
+				WRITE_SHORT( 0 );	// index number of secondary entity
+				WRITE_LONG( 15 | DRC_FLAG_FINAL);   // eventflags (priority and flags)
+			MessageEnd();
+			*/
+
+			// tell the bots the VIP got out
+			IGameEvent * event = gameeventmanager->CreateEvent( "vip_escaped" );
+			if ( event )
+			{
+				event->SetInt( "userid", m_pVIP->GetUserID() );
+				event->SetInt( "priority", 9 );
+				gameeventmanager->FireEvent( event );
+			}
+
+			//=============================================================================
+			// HPE_BEGIN:
+			// [menglish] If the VIP has escaped award him an MVP
+			//=============================================================================
+			 
+			m_pVIP->IncrementNumMVPs( CSMVP_UNDEFINED );
+			 
+			//=============================================================================
+			// HPE_END
+			//=============================================================================
+
+			TerminateRound( mp_round_restart_delay.GetFloat(), VIP_Escaped );
+			return true;
+		}
+		else if ( m_pVIP->m_lifeState == LIFE_DEAD )   // The VIP is dead
+		{
+			m_iAccountTerrorist += 3250;
+
+			if ( !bNeededPlayers )
+			{
+				m_iNumTerroristWins ++;
+				// Update the clients team score
+				UpdateTeamScores();
+			}
+
+			// tell the bots the VIP was killed
+			IGameEvent * event = gameeventmanager->CreateEvent( "vip_killed" );
+			if ( event )
+			{
+				event->SetInt( "userid", m_pVIP->GetUserID() );
+				event->SetInt( "priority", 9 );
+				gameeventmanager->FireEvent( event );
+			}
+
+			TerminateRound( mp_round_restart_delay.GetFloat(), VIP_Assassinated );
+			return true;
+		}
+
+		return false;
+	}
+
+
+	bool CCSGameRules::BombRoundEndCheck( bool bNeededPlayers )
+	{
+		// Check to see if the bomb target was hit or the bomb defused.. if so, then let's end the round!
+		if ( ( m_bTargetBombed == true ) && ( m_bMapHasBombTarget == true ) )
+		{
+			m_iAccountTerrorist += 3500;
+
+			if ( !bNeededPlayers )
+			{
+				m_iNumTerroristWins ++;
+				// Update the clients team score
+				UpdateTeamScores();
+			}
+
+			TerminateRound( mp_round_restart_delay.GetFloat(), Target_Bombed );
+			return true;
+		}
+		else
+		if ( ( m_bBombDefused == true ) && ( m_bMapHasBombTarget == true ) )
+		{
+			m_iAccountCT += 3250;
+
+			m_iAccountTerrorist += 800; // give the T's a little bonus for planting the bomb even though it was defused.
+
+			if ( !bNeededPlayers )
+			{
+				m_iNumCTWins++;
+				// Update the clients team score
+				UpdateTeamScores();
+			}
+
+			TerminateRound( mp_round_restart_delay.GetFloat(), Bomb_Defused );
+			return true;
+		}
+
+		return false;
+	}
+
+
+	bool CCSGameRules::TeamExterminationCheck(
+		int NumAliveTerrorist,
+		int NumAliveCT,
+		int NumDeadTerrorist,
+		int NumDeadCT,
+		bool bNeededPlayers
+	)
+	{
+		if ( ( m_iNumCT > 0 && m_iNumSpawnableCT > 0 ) && ( m_iNumTerrorist > 0 && m_iNumSpawnableTerrorist > 0 ) )
+		{
+			if ( NumAliveTerrorist == 0 && NumDeadTerrorist != 0 && m_iNumSpawnableCT > 0 )
+			{
+				bool nowin = false;
+					
+				for ( int iGrenade=0; iGrenade < g_PlantedC4s.Count(); iGrenade++ )
+				{
+					CPlantedC4 *pC4 = g_PlantedC4s[iGrenade];
+
+					if ( pC4->IsBombActive() )
+						nowin = true;
+				}
+
+				if ( !nowin )
+				{
+					if ( m_bMapHasBombTarget )
+						m_iAccountCT += 3250;
+					else
+						m_iAccountCT += 3000;
+
+					if ( !bNeededPlayers )
+					{
+						m_iNumCTWins++;
+						// Update the clients team score
+						UpdateTeamScores();
+					}
+
+					TerminateRound( mp_round_restart_delay.GetFloat(), CTs_Win );
+					return true;
+				}
+			}
+		
+			// Terrorists WON
+			if ( NumAliveCT == 0 && NumDeadCT != 0 && m_iNumSpawnableTerrorist > 0 )
+			{
+				if ( m_bMapHasBombTarget )
+					m_iAccountTerrorist += 3250;
+				else
+					m_iAccountTerrorist += 3000;
+
+				if ( !bNeededPlayers )
+				{
+					m_iNumTerroristWins++;
+					// Update the clients team score
+					UpdateTeamScores();
+				}
+
+				TerminateRound( mp_round_restart_delay.GetFloat(), Terrorists_Win );
+				return true;
+			}
+		}
+		else if ( NumAliveCT == 0 && NumAliveTerrorist == 0 )
+		{
+			TerminateRound( mp_round_restart_delay.GetFloat(), Round_Draw );
+			return true;
+		}
+
+		return false;
+	}
+
+
+	void CCSGameRules::PickNextVIP()
+	{
+		// MIKETODO: work on this when getting VIP maps running.
+		/*
+		if (IsVIPQueueEmpty() != true)
+		{
+			// Remove the current VIP from his VIP status and make him a regular CT.
+			if (m_pVIP != NULL)
+				ResetCurrentVIP();
+
+			for (int i = 0; i <= 4; i++)
+			{
+				if (VIPQueue[i] != NULL)
+				{
+					m_pVIP = VIPQueue[i];
+					m_pVIP->MakeVIP();
+
+					VIPQueue[i] = NULL;		// remove this player from the VIP queue
+					StackVIPQueue();		// and re-organize the queue
+					m_iConsecutiveVIP = 0;
+					return;
+				}
+			}
+		}
+		else if (m_iConsecutiveVIP >= 3)	// If it's been the same VIP for 3 rounds already.. then randomly pick a new one
+		{
+			m_iLastPick++;
+
+			if (m_iLastPick > m_iNumCT)
+				m_iLastPick = 1;
+
+			int iCount = 1;
+
+			CBaseEntity* pPlayer = NULL;
+			CBasePlayer* player = NULL;
+			CBasePlayer* pLastPlayer = NULL;
+
+			pPlayer = UTIL_FindEntityByClassname ( pPlayer, "player" );
+			while (		(pPlayer != NULL) && (!FNullEnt(pPlayer->edict()))	)
+			{
+				if (	!(pPlayer->pev->flags & FL_DORMANT)	)
+				{
+					player = GetClassPtr((CBasePlayer *)pPlayer->pev);
+					
+					if (	(player->m_iTeam == CT) && (iCount == m_iLastPick)	)
+					{
+						if (	(player == m_pVIP) && (pLastPlayer != NULL)	)
+							player = pLastPlayer;
+
+						// Remove the current VIP from his VIP status and make him a regular CT.
+						if (m_pVIP != NULL)
+							ResetCurrentVIP();
+
+						player->MakeVIP();
+						m_iConsecutiveVIP = 0;
+
+						return;
+					}
+					else if ( player->m_iTeam == CT )
+						iCount++;
+
+					if ( player->m_iTeam != SPECTATOR )
+						pLastPlayer = player;
+				}
+				pPlayer = UTIL_FindEntityByClassname ( pPlayer, "player" );
+			}
+		}
+		else if (m_pVIP == NULL)  // There is no VIP and there is no one waiting to be the VIP.. therefore just pick the first CT player we can find.
+		{
+			CBaseEntity* pPlayer = NULL;
+			CBasePlayer* player = NULL;
+
+			pPlayer = UTIL_FindEntityByClassname ( pPlayer, "player" );
+			while (		(pPlayer != NULL) && (!FNullEnt(pPlayer->edict()))	)
+			{
+				if ( pPlayer->pev->flags != FL_DORMANT	)
+				{
+					player = GetClassPtr((CBasePlayer *)pPlayer->pev);
+		
+					if ( player->m_iTeam == CT )
+					{
+						player->MakeVIP();
+						m_iConsecutiveVIP = 0;
+						return;
+					}
+				}
+				pPlayer = UTIL_FindEntityByClassname ( pPlayer, "player" );
+			}
+		}
+		*/
+	}
+
+
+	void CCSGameRules::ReadMultiplayCvars()
+	{
+		m_iRoundTime = (int)(mp_roundtime.GetFloat() * 60);
+		m_iFreezeTime = mp_freezetime.GetInt();
+	}
+
+
+	void CCSGameRules::RestartRound()
+	{
+#if defined( REPLAY_ENABLED )
+		if ( g_pReplay )
+		{
+			// Write replay and stop recording if appropriate
+			if ( g_pReplay->IsRecording() )
+			{
+				g_pReplay->SV_EndRecordingSession();
+			}
+			
+			int nActivePlayerCount = m_iNumTerrorist + m_iNumCT;
+			if ( nActivePlayerCount && g_pReplay->SV_ShouldBeginRecording( false ) )
+			{
+				// Tell the replay manager that it should begin recording the new round as soon as possible
+				g_pReplay->SV_GetContext()->GetSessionRecorder()->StartRecording();
+			}
+		}
+#endif
+		//=============================================================================
+		// HPE_BEGIN:
+		// [tj] Notify players that the round is about to be reset
+		//=============================================================================
+        for ( int clientIndex = 1; clientIndex <= gpGlobals->maxClients; clientIndex++ )
+		{
+			CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( clientIndex );
+			if(pPlayer)
+			{
+				pPlayer->OnPreResetRound();
+			}
+		}
+
+		//=============================================================================
+		// HPE_END
+		//=============================================================================    
+
+		if ( !IsFinite( gpGlobals->curtime ) )
+		{
+			Warning( "NaN curtime in RestartRound\n" );
+			gpGlobals->curtime = 0.0f;
+		}
+
+		int i;
+
+		m_iTotalRoundsPlayed++;
+		
+		//ClearBodyQue();
+
+		// Hardlock the player accelaration to 5.0
+		//CVAR_SET_FLOAT( "sv_accelerate", 5.0 );
+		//CVAR_SET_FLOAT( "sv_friction", 4.0 );
+		//CVAR_SET_FLOAT( "sv_stopspeed", 75 );
+
+		sv_stopspeed.SetValue( 75.0f );
+
+		// Tabulate the number of players on each team.
+		int NumDeadCT, NumDeadTerrorist, NumAliveTerrorist, NumAliveCT;
+		InitializePlayerCounts( NumAliveTerrorist, NumAliveCT, NumDeadTerrorist, NumDeadCT );
+		
+		m_bBombDropped = false;
+		m_bBombPlanted = false;
+		
+		if ( GetHumanTeam() != TEAM_UNASSIGNED )
+		{
+			MoveHumansToHumanTeam();
+		}
+
+		/*************** AUTO-BALANCE CODE *************/
+		if ( mp_autoteambalance.GetInt() != 0 &&
+			(m_iUnBalancedRounds >= 1) )
+		{
+			if ( GetHumanTeam() == TEAM_UNASSIGNED )
+			{
+				BalanceTeams();
+			}
+		}
+
+		if ( ((m_iNumSpawnableCT - m_iNumSpawnableTerrorist) >= 2) ||
+			((m_iNumSpawnableTerrorist - m_iNumSpawnableCT) >= 2)	)
+		{
+			m_iUnBalancedRounds++;
+		}
+		else
+		{
+			m_iUnBalancedRounds = 0;
+		}
+
+		// Warn the players of an impending auto-balance next round...
+		if ( mp_autoteambalance.GetInt() != 0 &&
+			(m_iUnBalancedRounds == 1)	)
+		{
+			if ( GetHumanTeam() == TEAM_UNASSIGNED )
+			{
+				UTIL_ClientPrintAll( HUD_PRINTCENTER,"#Auto_Team_Balance_Next_Round");
+			}
+		}
+
+		/*************** AUTO-BALANCE CODE *************/
+
+		if ( m_bCompleteReset )
+		{
+			// bounds check
+			if ( mp_timelimit.GetInt() < 0 )
+			{
+				mp_timelimit.SetValue( 0 );
+			}
+			m_flGameStartTime = gpGlobals->curtime;
+			if ( !IsFinite( m_flGameStartTime.Get() ) )
+			{
+				Warning( "Trying to set a NaN game start time\n" );
+				m_flGameStartTime.GetForModify() = 0.0f;
+			}
+
+			// Reset total # of rounds played
+			m_iTotalRoundsPlayed = 0;
+
+			// Reset score info
+			m_iNumTerroristWins				= 0;
+			m_iNumCTWins					= 0;
+			m_iNumConsecutiveTerroristLoses	= 0;
+			m_iNumConsecutiveCTLoses		= 0;
+
+
+			// Reset team scores
+			UpdateTeamScores();
+
+
+			// Reset the player stats
+			for ( i = 1; i <= gpGlobals->maxClients; i++ )
+			{
+				CCSPlayer *pPlayer = CCSPlayer::Instance( i );
+
+				if ( pPlayer && !FNullEnt( pPlayer->edict() ) )
+					pPlayer->Reset();
+			}
+		}
+
+		m_bFreezePeriod = true;
+
+		ReadMultiplayCvars();
+
+		// Check to see if there's a mapping info paramater entity
+		if ( g_pMapInfo )
+		{
+			switch ( g_pMapInfo->m_iBuyingStatus )
+			{
+				case 0: 
+					m_bCTCantBuy = false; 
+					m_bTCantBuy = false; 
+					Msg( "EVERYONE CAN BUY!\n" );
+					break;
+				
+				case 1: 
+					m_bCTCantBuy = false; 
+					m_bTCantBuy = true; 
+					Msg( "Only CT's can buy!!\n" );
+					break;
+
+				case 2: 
+					m_bCTCantBuy = true; 
+					m_bTCantBuy = false; 
+					Msg( "Only T's can buy!!\n" );
+					break;
+				
+				case 3: 
+					m_bCTCantBuy = true; 
+					m_bTCantBuy = true; 
+					Msg( "No one can buy!!\n" );
+					break;
+
+				default: 
+					m_bCTCantBuy = false; 
+					m_bTCantBuy = false; 
+					break;
+			}
+		}
+		else
+		{
+			// by default everyone can buy
+			m_bCTCantBuy = false; 
+			m_bTCantBuy = false; 
+		}
+		
+		
+		// Check to see if this map has a bomb target in it
+
+		if ( gEntList.FindEntityByClassname( NULL, "func_bomb_target" ) )
+		{
+			m_bMapHasBombTarget		= true;
+			m_bMapHasBombZone		= true;
+		}
+		else if ( gEntList.FindEntityByClassname( NULL, "info_bomb_target" ) )
+		{
+			m_bMapHasBombTarget		= true;
+			m_bMapHasBombZone		= false;
+		}
+		else
+		{
+			m_bMapHasBombTarget		= false;
+			m_bMapHasBombZone		= false;
+		}
+
+		// Check to see if this map has hostage rescue zones
+
+		if ( gEntList.FindEntityByClassname( NULL, "func_hostage_rescue" ) )
+			m_bMapHasRescueZone = true;
+		else
+			m_bMapHasRescueZone = false;
+
+
+		// See if the map has func_buyzone entities
+		// Used by CBasePlayer::HandleSignals() to support maps without these entities
+		
+		if ( gEntList.FindEntityByClassname( NULL, "func_buyzone" ) )
+			m_bMapHasBuyZone = true;
+		else
+			m_bMapHasBuyZone = false;
+
+
+		// GOOSEMAN : See if this map has func_escapezone entities
+		if ( gEntList.FindEntityByClassname( NULL, "func_escapezone" ) )
+		{
+			m_bMapHasEscapeZone = true;
+			m_iHaveEscaped = 0;
+			m_iNumEscapers = 0; // Will increase this later when we count how many Ts are starting
+			if (m_iNumEscapeRounds >= 3)
+			{
+				SwapAllPlayers();
+				m_iNumEscapeRounds = 0;
+			}
+
+			m_iNumEscapeRounds++;  // Increment the number of rounds played... After 8 rounds, the players will do a whole sale switch..
+		}
+		else
+			m_bMapHasEscapeZone = false;
+
+		// Check to see if this map has VIP safety zones
+		if ( gEntList.FindEntityByClassname( NULL, "func_vip_safetyzone" ) )
+		{
+			PickNextVIP();
+			m_iConsecutiveVIP++;
+			m_iMapHasVIPSafetyZone = 1;
+		}
+		else
+			m_iMapHasVIPSafetyZone = 2;
+
+		// Update accounts based on number of hostages remaining.. 
+		int iRescuedHostageBonus = 0;
+
+		for ( int iHostage=0; iHostage < g_Hostages.Count(); iHostage++ )
+		{
+			CHostage *pHostage = g_Hostages[iHostage];
+
+			if( pHostage->IsRescuable() )	//Alive and not rescued
+			{
+				iRescuedHostageBonus += 150;
+			}
+			
+			if ( iRescuedHostageBonus >= 2000 )
+				break;
+		}
+
+		//*******Catch up code by SupraFiend. Scale up the loser bonus when teams fall into losing streaks
+		if (m_iRoundWinStatus == WINNER_TER) // terrorists won
+		{
+			//check to see if they just broke a losing streak
+			if(m_iNumConsecutiveTerroristLoses > 1)
+				m_iLoserBonus = 1500;//this is the default losing bonus
+
+			m_iNumConsecutiveTerroristLoses = 0;//starting fresh
+			m_iNumConsecutiveCTLoses++;//increment the number of wins the CTs have had
+		}
+		else if (m_iRoundWinStatus == WINNER_CT) // CT Won
+		{
+			//check to see if they just broke a losing streak
+			if(m_iNumConsecutiveCTLoses > 1)
+				m_iLoserBonus = 1500;//this is the default losing bonus
+
+			m_iNumConsecutiveCTLoses = 0;//starting fresh
+			m_iNumConsecutiveTerroristLoses++;//increment the number of wins the Terrorists have had
+		}
+
+		//check if the losing team is in a losing streak & that the loser bonus hasen't maxed out.
+		if((m_iNumConsecutiveTerroristLoses > 1) && (m_iLoserBonus < 3000))
+			m_iLoserBonus += 500;//help out the team in the losing streak
+		else
+		if((m_iNumConsecutiveCTLoses > 1) && (m_iLoserBonus < 3000))
+			m_iLoserBonus += 500;//help out the team in the losing streak
+
+		// assign the wining and losing bonuses
+		if (m_iRoundWinStatus == WINNER_TER) // terrorists won
+		{
+			m_iAccountTerrorist += iRescuedHostageBonus;
+			m_iAccountCT += m_iLoserBonus;
+		}
+		else if (m_iRoundWinStatus == WINNER_CT) // CT Won
+		{
+			m_iAccountCT += iRescuedHostageBonus;
+			if (m_bMapHasEscapeZone == false)	// only give them the bonus if this isn't an escape map
+				m_iAccountTerrorist += m_iLoserBonus;
+		}
+		
+
+		//Update CT account based on number of hostages rescued
+		m_iAccountCT += m_iHostagesRescued * 750;
+
+
+		// Update individual players accounts and respawn players
+
+		//**********new code by SupraFiend
+		//##########code changed by MartinO 
+		//the round time stamp must be set before players are spawned
+		m_fRoundStartTime = gpGlobals->curtime + m_iFreezeTime;
+
+		if ( !IsFinite( m_fRoundStartTime.Get() ) )
+		{
+			Warning( "Trying to set a NaN round start time\n" );
+			m_fRoundStartTime.GetForModify() = 0.0f;
+		}
+		
+		//Adrian - No cash for anyone at first rounds! ( well, only the default. )
+		if ( m_bCompleteReset )
+		{
+			m_iAccountTerrorist = m_iAccountCT = 0; //No extra cash!.
+
+			//We are starting fresh. So it's like no one has ever won or lost.
+			m_iNumTerroristWins				= 0; 
+			m_iNumCTWins					= 0;
+			m_iNumConsecutiveTerroristLoses	= 0;
+			m_iNumConsecutiveCTLoses		= 0;
+			m_iLoserBonus					= 1400;
+		}
+
+		for ( i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+
+			if ( !pPlayer )
+				continue;
+
+			pPlayer->m_iNumSpawns	= 0;
+			pPlayer->m_bTeamChanged	= false;
+				
+			if ( pPlayer->GetTeamNumber() == TEAM_CT )
+			{
+				if (pPlayer->DoesPlayerGetRoundStartMoney())
+				{
+					pPlayer->AddAccount( m_iAccountCT );
+				}
+			}
+			else if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
+			{
+				m_iNumEscapers++;	// Add another potential escaper to the mix!
+				if (pPlayer->DoesPlayerGetRoundStartMoney())
+				{
+					pPlayer->AddAccount( m_iAccountTerrorist );
+				}
+			}
+
+			// tricky, make players non solid while moving to their spawn points
+			if ( (pPlayer->GetTeamNumber() == TEAM_CT) || (pPlayer->GetTeamNumber() == TEAM_TERRORIST) )
+			{
+				pPlayer->AddSolidFlags( FSOLID_NOT_SOLID );
+			}
+		}
+        
+        //=============================================================================
+        // HPE_BEGIN:
+        // [tj] Keep track of number of players per side and if they have the same uniform
+        //=============================================================================
+ 
+        int terroristUniform = -1;
+        bool allTerroristsWearingSameUniform = true;
+        int numberOfTerrorists = 0;
+        int ctUniform = -1;
+        bool allCtsWearingSameUniform = true;
+        int numberOfCts = 0;
+ 
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+		// know respawn all players
+		for ( i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+
+			if ( !pPlayer )
+				continue;
+
+			if ( pPlayer->GetTeamNumber() == TEAM_CT && pPlayer->PlayerClass() >= FIRST_CT_CLASS && pPlayer->PlayerClass() <= LAST_CT_CLASS )
+			{
+                //=============================================================================
+                // HPE_BEGIN:
+                // [tj] Increment CT count and check CT uniforms.
+                //=============================================================================
+                 
+                numberOfCts++;
+                if (ctUniform == -1)
+                {
+                    ctUniform = pPlayer->PlayerClass();
+                }
+                else if (pPlayer->PlayerClass() != ctUniform)
+                {
+                    allCtsWearingSameUniform = false;
+                }
+                 
+                //=============================================================================
+                // HPE_END
+                //=============================================================================
+                
+				pPlayer->RoundRespawn();
+			}
+
+			if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST && pPlayer->PlayerClass() >= FIRST_T_CLASS && pPlayer->PlayerClass() <= LAST_T_CLASS )
+			{
+                //=============================================================================
+                // HPE_BEGIN:
+                // [tj] Increment terrorist count and check terrorist uniforms
+                //=============================================================================
+                 
+                numberOfTerrorists++;
+                if (terroristUniform == -1)
+                {
+                    terroristUniform = pPlayer->PlayerClass();
+                }
+                else if (pPlayer->PlayerClass() != terroristUniform)
+                {
+                    allTerroristsWearingSameUniform = false;
+                }
+                 
+                //=============================================================================
+                // HPE_END
+                //=============================================================================
+                
+				pPlayer->RoundRespawn();
+			}
+			else
+			{
+				pPlayer->ObserverRoundRespawn();
+			}
+
+			if ( pPlayer->m_iAccount > pPlayer->m_iShouldHaveCash )
+			{
+				m_bDontUploadStats = true;
+			}
+		}
+
+        //=============================================================================
+        // HPE_BEGIN:
+        //=============================================================================
+
+        // [tj] Award same uniform achievement for qualifying teams
+        for ( i = 1; i <= gpGlobals->maxClients; i++ )
+        {
+            CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+
+            if ( !pPlayer )
+                continue;
+
+            if ( pPlayer->GetTeamNumber() == TEAM_CT && allCtsWearingSameUniform && numberOfCts >= AchievementConsts::SameUniform_MinPlayers)
+            {
+                pPlayer->AwardAchievement(CSSameUniform);
+            }
+
+            if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST && allTerroristsWearingSameUniform && numberOfTerrorists >= AchievementConsts::SameUniform_MinPlayers)
+            {
+                pPlayer->AwardAchievement(CSSameUniform);
+            }
+        }
+
+		// [menglish] reset per-round achievement variables for each player
+		for ( i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+			if( pPlayer )
+			{
+				pPlayer->ResetRoundBasedAchievementVariables();
+			}
+		}
+
+		// [pfreese] Reset all round or match stats, depending on type of restart
+		if ( m_bCompleteReset )
+		{
+			CCS_GameStats.ResetAllStats();
+			CCS_GameStats.ResetPlayerClassMatchStats();
+		}
+		else
+		{
+			CCS_GameStats.ResetRoundStats();
+		}
+
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+		// Respawn entities (glass, doors, etc..)
+		CleanUpMap();
+
+		// now run a tkpunish check, after the map has been cleaned up
+		for ( i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+
+			if ( !pPlayer )
+				continue;
+
+			if ( pPlayer->GetTeamNumber() == TEAM_CT && pPlayer->PlayerClass() >= FIRST_CT_CLASS && pPlayer->PlayerClass() <= LAST_CT_CLASS )
+			{
+				pPlayer->CheckTKPunishment();
+			}
+			if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST && pPlayer->PlayerClass() >= FIRST_T_CLASS && pPlayer->PlayerClass() <= LAST_T_CLASS )
+			{
+				pPlayer->CheckTKPunishment();
+			}
+		}
+
+		// Give C4 to the terrorists
+		if (m_bMapHasBombTarget == true	)
+			GiveC4();
+
+		// Reset game variables
+		m_flIntermissionEndTime = 0;
+		m_flRestartRoundTime = 0.0;
+		m_iAccountTerrorist = m_iAccountCT = 0;
+		m_iHostagesRescued = 0;
+		m_iHostagesTouched = 0;
+
+        //=============================================================================
+        // HPE_BEGIN
+        // [dwenger] Reset rescue-related achievement values
+        //=============================================================================
+
+		// [tj] reset flawless and lossless round related flags
+		m_bNoTerroristsKilled = true;
+		m_bNoCTsKilled = true;
+		m_bNoTerroristsDamaged = true;
+		m_bNoCTsDamaged = true;
+		m_pFirstKill = NULL;
+		m_pFirstBlood = NULL;
+
+        m_bCanDonateWeapons = true;
+
+		// [dwenger] Reset rescue-related achievement values
+        m_iHostagesRemaining = 0;
+        m_pLastRescuer = NULL;
+
+		m_hostageWasInjured = false;
+		m_hostageWasKilled = false;
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+        m_iNumRescuers = 0;
+		m_iRoundWinStatus = WINNER_NONE;
+		m_bTargetBombed = m_bBombDefused = false;
+		m_bCompleteReset = false;
+		m_flNextHostageAnnouncement = gpGlobals->curtime;
+
+		m_iHostagesRemaining = g_Hostages.Count();
+
+		// fire global game event
+		IGameEvent * event = gameeventmanager->CreateEvent( "round_start" );
+		if ( event )
+		{
+			event->SetInt("timelimit", m_iRoundTime );
+			event->SetInt("fraglimit", 0 );
+			event->SetInt( "priority", 6 ); // HLTV event priority, not transmitted
+		
+			if ( m_bMapHasRescueZone )
+			{
+				event->SetString("objective","HOSTAGE RESCUE");
+			}
+			else if ( m_bMapHasEscapeZone )
+			{
+				event->SetString("objective","PRISON ESCAPE");
+			}
+			else if ( m_iMapHasVIPSafetyZone == 1 )
+			{
+				event->SetString("objective","VIP RESCUE");
+			}
+			else if ( m_bMapHasBombTarget || m_bMapHasBombZone )
+			{
+				event->SetString("objective","BOMB TARGET");
+			}
+			else
+			{
+				event->SetString("objective","DEATHMATCH");
+			}
+
+			gameeventmanager->FireEvent( event );
+		}
+	
+		UploadGameStats();
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [pfreese] I commented out this call to CreateWeaponManager, as the 
+		// CGameWeaponManager object doesn't appear to be actually used by the CSS
+		// code, and in any case, the weapon manager does not support wildcards in 
+		// entity names (as seemingly indicated) below. When the manager fails to 
+		// create its factory, it removes itself in any case.
+		//=============================================================================
+
+		// CreateWeaponManager( "weapon_*", gpGlobals->maxClients * 2 );
+		
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+	}
+
+	void CCSGameRules::GiveC4()
+	{
+		enum {
+			ALL_TERRORISTS = 0,
+			HUMAN_TERRORISTS,
+		};
+		int iTerrorists[2][ABSOLUTE_PLAYER_LIMIT];
+		int numAliveTs[2] = { 0, 0 };
+		int lastBombGuyIndex[2] = { -1, -1 };
+
+		//Create an array of the indeces of bomb carrier candidates
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( i ) );
+
+			if( pPlayer && pPlayer->IsAlive() && pPlayer->GetTeamNumber() == TEAM_TERRORIST && numAliveTs[ALL_TERRORISTS] < ABSOLUTE_PLAYER_LIMIT  )
+			{
+				if ( pPlayer == m_pLastBombGuy )
+				{
+					lastBombGuyIndex[ALL_TERRORISTS] = numAliveTs[ALL_TERRORISTS];
+					lastBombGuyIndex[HUMAN_TERRORISTS] = numAliveTs[HUMAN_TERRORISTS];
+				}
+
+				iTerrorists[ALL_TERRORISTS][numAliveTs[ALL_TERRORISTS]] = i;
+				numAliveTs[ALL_TERRORISTS]++;
+				if ( !pPlayer->IsBot() )
+				{
+					iTerrorists[HUMAN_TERRORISTS][numAliveTs[HUMAN_TERRORISTS]] = i;
+					numAliveTs[HUMAN_TERRORISTS]++;
+				}
+			}
+		}
+
+		int which = cv_bot_defer_to_human.GetBool();
+		if ( numAliveTs[HUMAN_TERRORISTS] == 0 )
+		{
+			which = ALL_TERRORISTS;
+		}
+
+		//pick one of the candidates randomly
+		if( numAliveTs[which] > 0 )
+		{
+			int index = random->RandomInt(0,numAliveTs[which]-1);
+			if ( lastBombGuyIndex[which] >= 0 )
+			{
+				// give the C4 sequentially
+				index = (lastBombGuyIndex[which] + 1) % numAliveTs[which];
+			}
+			CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iTerrorists[which][index] ) );
+
+			Assert( pPlayer && pPlayer->GetTeamNumber() == TEAM_TERRORIST && pPlayer->IsAlive() );
+
+			pPlayer->GiveNamedItem( WEAPON_C4_CLASSNAME );
+			m_pLastBombGuy = pPlayer;
+
+			//pPlayer->SetBombIcon();
+			//pPlayer->pev->body = 1;
+			
+			pPlayer->m_iDisplayHistoryBits |= DHF_BOMB_RETRIEVED;
+			pPlayer->HintMessage( "#Hint_you_have_the_bomb", false, true );
+
+			// Log this information
+			//UTIL_LogPrintf("\"%s<%i><%s><TERRORIST>\" triggered \"Spawned_With_The_Bomb\"\n", 
+			//	STRING( pPlayer->GetPlayerName() ),
+			//	GETPLAYERUSERID( pPlayer->edict() ),
+			//	GETPLAYERAUTHID( pPlayer->edict() ) );
+		}
+
+		m_bBombDropped = false;
+	}
+
+	void CCSGameRules::Think()
+	{
+		CGameRules::Think();
+
+		for ( int i = 0; i < GetNumberOfTeams(); i++ )
+		{
+			GetGlobalTeam( i )->Think();
+		}
+
+		///// Check game rules /////
+		if ( CheckGameOver() )
+		{
+			return;
+		}
+
+		// have we hit the max rounds?
+		if ( CheckMaxRounds() )
+		{
+			return;
+		}
+
+		// did somebaody hit the fraglimit ?
+		if ( CheckFragLimit() )
+		{
+			return;
+		}
+
+		if ( CheckWinLimit() )
+		{
+			return;
+		}
+
+		
+		// Check for the end of the round.
+		if ( IsFreezePeriod() )
+		{
+			CheckFreezePeriodExpired();
+		}
+		else 
+		{
+			CheckRoundTimeExpired();
+		}
+
+		CheckLevelInitialized();
+		
+		if ( m_flRestartRoundTime > 0.0f && m_flRestartRoundTime <= gpGlobals->curtime )
+		{
+			bool botSpeaking = false;
+			for ( int i=1; i <= gpGlobals->maxClients; ++i )
+			{
+				CBasePlayer *player = UTIL_PlayerByIndex( i );
+				if (player == NULL)
+					continue;
+
+				if (!player->IsBot())
+					continue;
+				
+				CCSBot *bot = dynamic_cast< CCSBot * >(player);
+				if ( !bot )
+					continue;
+
+				if ( bot->IsUsingVoice() )
+				{
+					if ( gpGlobals->curtime > m_flRestartRoundTime + 10.0f )
+					{
+						Msg( "Ignoring speaking bot %s at round end\n", bot->GetPlayerName() );
+					}
+					else
+					{
+						botSpeaking = true;
+						break;
+					}
+				}
+			}
+
+			if ( !botSpeaking )
+			{
+				RestartRound();
+			}
+		}
+		
+		if ( gpGlobals->curtime > m_tmNextPeriodicThink )
+		{
+			CheckRestartRound();
+			m_tmNextPeriodicThink = gpGlobals->curtime + 1.0;
+		}
+	}
+
+
+	// The bots do their processing after physics simulation etc so their visibility checks don't recompute
+	// bone positions multiple times a frame.
+	void CCSGameRules::EndGameFrame( void )
+	{
+		TheBots->StartFrame();
+
+		BaseClass::EndGameFrame();
+	}
+
+	bool CCSGameRules::CheckGameOver()
+	{
+		if ( g_fGameOver )   // someone else quit the game already
+		{
+			//=============================================================================
+			// HPE_BEGIN:
+			// [Forrest] Calling ChangeLevel multiple times was causing IncrementMapCycleIndex
+			// to skip over maps in the list.  Avoid this using a technique from CTeamplayRoundBasedRules::Think.
+			//=============================================================================
+			// check to see if we should change levels now
+			if ( m_flIntermissionEndTime && ( m_flIntermissionEndTime < gpGlobals->curtime ) )
+			{
+				ChangeLevel(); // intermission is over
+
+				// Don't run this code again
+				m_flIntermissionEndTime = 0.f;
+			}
+			//=============================================================================
+			// HPE_END
+			//=============================================================================
+
+			return true;
+		}
+
+		return false;
+	}
+
+	bool CCSGameRules::CheckFragLimit()
+	{
+		if ( fraglimit.GetInt() <= 0 )
+			return false;
+
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+
+			if ( pPlayer && pPlayer->FragCount() >= fraglimit.GetInt() )
+			{
+				const char *teamName = "UNKNOWN";
+				if ( pPlayer->GetTeam() )
+				{
+					teamName = pPlayer->GetTeam()->GetName();
+				}
+				UTIL_LogPrintf("\"%s<%i><%s><%s>\" triggered \"Intermission_Kill_Limit\"\n", 
+					pPlayer->GetPlayerName(),
+					pPlayer->GetUserID(),
+					pPlayer->GetNetworkIDString(),
+					teamName
+					);
+				GoToIntermission();
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	bool CCSGameRules::CheckMaxRounds()
+	{
+		if ( mp_maxrounds.GetInt() != 0 )
+		{
+			if ( m_iTotalRoundsPlayed >= mp_maxrounds.GetInt() )
+			{
+				UTIL_LogPrintf("World triggered \"Intermission_Round_Limit\"\n");
+				GoToIntermission();
+				return true;
+			}
+		}
+		
+		return false;
+	}
+
+
+	bool CCSGameRules::CheckWinLimit()
+	{
+		// has one team won the specified number of rounds?
+		if ( mp_winlimit.GetInt() != 0 )
+		{
+			if ( m_iNumCTWins >= mp_winlimit.GetInt() )
+			{
+				UTIL_LogPrintf("Team \"CT\" triggered \"Intermission_Win_Limit\"\n");
+				GoToIntermission();
+				return true;
+			}
+			if ( m_iNumTerroristWins >= mp_winlimit.GetInt() )
+			{
+				UTIL_LogPrintf("Team \"TERRORIST\" triggered \"Intermission_Win_Limit\"\n");
+				GoToIntermission();
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+
+	void CCSGameRules::CheckFreezePeriodExpired()
+	{
+		float startTime = m_fRoundStartTime;
+		if ( !IsFinite( startTime ) )
+		{
+			Warning( "Infinite round start time!\n" );
+			m_fRoundStartTime.GetForModify() = gpGlobals->curtime;
+		}
+
+		if ( IsFinite( startTime ) && gpGlobals->curtime < startTime )
+		{
+			return; // not time yet to start round
+		}
+
+		// Log this information
+		UTIL_LogPrintf("World triggered \"Round_Start\"\n");
+
+		char CT_sentence[40];
+		char T_sentence[40];
+		
+		switch ( random->RandomInt( 0, 3 ) )
+		{
+		case 0:
+			Q_strncpy(CT_sentence,"radio.moveout", sizeof( CT_sentence ) ); 
+			Q_strncpy(T_sentence ,"radio.moveout", sizeof( T_sentence ) ); 
+			break;
+
+		case 1:
+			Q_strncpy(CT_sentence, "radio.letsgo", sizeof( CT_sentence ) ); 
+			Q_strncpy(T_sentence , "radio.letsgo", sizeof( T_sentence ) ); 
+			break;
+
+		case 2:
+			Q_strncpy(CT_sentence , "radio.locknload", sizeof( CT_sentence ) );
+			Q_strncpy(T_sentence , "radio.locknload", sizeof( T_sentence ) );
+			break;
+
+		default:
+			Q_strncpy(CT_sentence , "radio.go", sizeof( CT_sentence ) );
+			Q_strncpy(T_sentence , "radio.go", sizeof( T_sentence ) );
+			break;
+		}
+
+		// More specific radio commands for the new scenarios : Prison & Assasination
+		if (m_bMapHasEscapeZone == TRUE)
+		{
+			Q_strncpy(CT_sentence , "radio.elim", sizeof( CT_sentence ) );
+			Q_strncpy(T_sentence , "radio.getout", sizeof( T_sentence ) );
+		}
+		else if (m_iMapHasVIPSafetyZone == 1)
+		{
+			Q_strncpy(CT_sentence , "radio.vip", sizeof( CT_sentence ) );
+			Q_strncpy(T_sentence , "radio.locknload", sizeof( T_sentence ) );
+		}
+
+		// Freeze period expired: kill the flag
+		m_bFreezePeriod = false;
+
+		IGameEvent * event = gameeventmanager->CreateEvent( "round_freeze_end" );
+		if ( event )
+		{
+			gameeventmanager->FireEvent( event );
+		}
+
+		// Update the timers for all clients and play a sound
+		bool bCTPlayed = false;
+		bool bTPlayed = false;
+
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = CCSPlayer::Instance( i );
+			if ( pPlayer && !FNullEnt( pPlayer->edict() ) )
+			{
+				if ( pPlayer->State_Get() == STATE_ACTIVE )
+				{
+					if ( (pPlayer->GetTeamNumber() == TEAM_CT) && !bCTPlayed )
+					{
+						pPlayer->Radio( CT_sentence );
+						bCTPlayed = true;
+					}
+					else if ( (pPlayer->GetTeamNumber() == TEAM_TERRORIST) && !bTPlayed )
+					{
+						pPlayer->Radio( T_sentence );
+						bTPlayed = true;
+					}
+
+				}
+				
+				//pPlayer->SyncRoundTimer();
+			}
+		}
+	}
+
+
+	void CCSGameRules::CheckRoundTimeExpired()
+	{
+		if ( mp_ignore_round_win_conditions.GetBool() )
+			return;
+
+		if ( GetRoundRemainingTime() > 0 || m_iRoundWinStatus != WINNER_NONE ) 
+			return; //We haven't completed other objectives, so go for this!.
+
+		if( !m_bFirstConnected )
+			return;
+
+		// New code to get rid of round draws!!
+
+		if ( m_bMapHasBombTarget )
+		{
+			//If the bomb is planted, don't let the round timer end the round.
+			//keep going until the bomb explodes or is defused
+			if( !m_bBombPlanted )
+			{
+				m_iAccountCT += 3250;
+				
+				m_iNumCTWins++;
+				TerminateRound( mp_round_restart_delay.GetFloat(), Target_Saved );
+				UpdateTeamScores();
+				MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(TEAM_TERRORIST);
+			}
+		}
+		else if ( m_bMapHasRescueZone )
+		{
+			m_iAccountTerrorist += 3250; 
+			
+			m_iNumTerroristWins++;
+			TerminateRound( mp_round_restart_delay.GetFloat(), Hostages_Not_Rescued );
+			UpdateTeamScores();
+			MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(TEAM_CT);
+		}
+		else if ( m_bMapHasEscapeZone )
+		{
+			m_iNumCTWins++;
+			TerminateRound( mp_round_restart_delay.GetFloat(), Terrorists_Not_Escaped );
+			UpdateTeamScores();
+		}
+		else if ( m_iMapHasVIPSafetyZone == 1 )
+		{
+			m_iAccountTerrorist += 3250;
+			m_iNumTerroristWins++;
+
+			TerminateRound( mp_round_restart_delay.GetFloat(), VIP_Not_Escaped );
+			UpdateTeamScores();
+		}
+
+#if defined( REPLAY_ENABLED )
+		if ( g_pReplay )
+		{
+			// Write replay and stop recording if appropriate
+			g_pReplay->SV_EndRecordingSession();
+		}
+#endif
+	}
+
+	void CCSGameRules::GoToIntermission( void )
+	{
+		Msg( "Going to intermission...\n" );
+
+		IGameEvent *winEvent = gameeventmanager->CreateEvent( "cs_win_panel_match" );
+
+		if( winEvent )
+		{
+			for ( int teamIndex = TEAM_TERRORIST; teamIndex <= TEAM_CT; teamIndex++ )
+			{
+				CTeam *team = GetGlobalTeam( teamIndex );
+				if ( team )
+				{
+					float kills = CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_KILLS];
+					float deaths = CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_DEATHS];
+					// choose dialog variables to set depending on team
+					switch ( teamIndex )
+					{
+					case TEAM_TERRORIST:
+						winEvent->SetInt( "t_score", team->GetScore() );
+						if(deaths == 0)
+						{
+							winEvent->SetFloat( "t_kd", kills );
+						}
+						else
+						{
+							winEvent->SetFloat( "t_kd", kills / deaths );
+						}										
+						winEvent->SetInt( "t_objectives_done", CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_OBJECTIVES_COMPLETED] );
+						winEvent->SetInt( "t_money_earned", CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_MONEY_EARNED] );
+						break;
+					case TEAM_CT:
+						winEvent->SetInt( "ct_score", team->GetScore() );
+						if(deaths == 0)
+						{
+							winEvent->SetFloat( "ct_kd", kills );
+						}
+						else
+						{
+							winEvent->SetFloat( "ct_kd", kills / deaths );
+						}
+						winEvent->SetInt( "ct_objectives_done", CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_OBJECTIVES_COMPLETED] );
+						winEvent->SetInt( "ct_money_earned", CCS_GameStats.GetTeamStats(teamIndex)[CSSTAT_MONEY_EARNED] );
+						break;
+					default:
+						Assert( false );
+						break;
+					}
+				}
+			}
+
+			gameeventmanager->FireEvent( winEvent );
+		}
+
+		BaseClass::GoToIntermission();
+
+		// set all players to FL_FROZEN
+		for ( int i = 1; i <= MAX_PLAYERS; i++ )
+		{
+			CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
+
+			if ( pPlayer )
+			{
+				pPlayer->AddFlag( FL_FROZEN );
+			}
+		}
+
+		// freeze players while in intermission
+		m_bFreezePeriod = true;
+	}
+
+	int PlayerScoreInfoSort( const playerscore_t *p1, const playerscore_t *p2 )
+	{
+		// check frags
+		if ( p1->iScore > p2->iScore )
+			return -1;
+		if ( p2->iScore > p1->iScore )
+			return 1;
+
+		// check index
+		if ( p1->iPlayerIndex < p2->iPlayerIndex )
+			return -1;
+
+		return 1;
+	}
+
+#if defined (_DEBUG)
+	void TestRoundWinpanel( void )
+	{
+		IGameEvent *event = gameeventmanager->CreateEvent( "round_end" );
+		event->SetInt( "winner", TEAM_TERRORIST );
+
+		if ( event )
+		{
+			gameeventmanager->FireEvent( event );
+		}
+
+
+		IGameEvent *event2 = gameeventmanager->CreateEvent( "player_death" );
+		if ( event2 )
+		{
+			CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex(1) );
+			
+			// pCappingPlayers is a null terminated list of player indeces
+			event2->SetInt("userid", pPlayer->GetUserID() );
+			event2->SetInt("attacker", pPlayer->GetUserID() );
+			event2->SetString("weapon", "Bare Hands" );
+			event2->SetInt("headshot", 1 );
+			event2->SetInt( "revenge", 1 );
+
+			gameeventmanager->FireEvent( event2 );
+		}
+
+		IGameEvent *winEvent = gameeventmanager->CreateEvent( "cs_win_panel_round" );
+
+		if ( winEvent )
+		{
+			if ( 1 )
+			{
+				if ( 0 /*team == m_iTimerWinTeam */)
+				{
+					// timer expired, defenders win
+					// show total time that was defended
+					winEvent->SetBool( "show_timer_defend", true );
+					winEvent->SetInt( "timer_time", 0 /*m_pRoundTimer->GetTimerMaxLength() */);
+				}
+				else
+				{
+					// attackers win
+					// show time it took for them to win
+					winEvent->SetBool( "show_timer_attack", true );
+
+					int iTimeElapsed = 90; //m_pRoundTimer->GetTimerMaxLength() - (int)m_pRoundTimer->GetTimeRemaining();
+					winEvent->SetInt( "timer_time", iTimeElapsed );
+				}
+			}
+			else
+			{
+				winEvent->SetBool( "show_timer_attack", false );
+				winEvent->SetBool( "show_timer_defend", false );
+			}
+
+			int iLastEvent = Terrorists_Win;
+
+			winEvent->SetInt( "final_event", iLastEvent );
+
+			// Set the fun fact data in the event
+			winEvent->SetString( "funfact_token", "#funfact_first_blood" );
+			winEvent->SetInt( "funfact_player", 1 );
+			winEvent->SetInt( "funfact_data1", 20 );
+			winEvent->SetInt( "funfact_data2", 31 );
+			winEvent->SetInt( "funfact_data3", 45 );
+
+			gameeventmanager->FireEvent( winEvent );
+		}
+	}
+	ConCommand test_round_winpanel( "test_round_winpanel", TestRoundWinpanel, "", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT );
+
+	void TestMatchWinpanel( void )
+	{
+		IGameEvent *event = gameeventmanager->CreateEvent( "round_end" );
+		event->SetInt( "winner", TEAM_TERRORIST );
+
+		if ( event )
+		{
+			gameeventmanager->FireEvent( event );
+		}
+
+		IGameEvent *winEvent = gameeventmanager->CreateEvent( "cs_win_panel_match" );
+
+		if ( winEvent )
+		{
+			winEvent->SetInt( "t_score", 4 );
+			winEvent->SetInt( "ct_score", 1 );
+
+			winEvent->SetFloat( "t_kd", 1.8f );
+			winEvent->SetFloat( "ct_kd", 0.4f );
+
+			winEvent->SetInt( "t_objectives_done", 5 );
+			winEvent->SetInt( "ct_objectives_done", 2 );
+
+			winEvent->SetInt( "t_money_earned", 30000 );
+			winEvent->SetInt( "ct_money_earned", 19999 );
+
+			gameeventmanager->FireEvent( winEvent );
+		}
+	}
+	ConCommand test_match_winpanel( "test_match_winpanel", TestMatchWinpanel, "", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT );
+
+	void TestFreezePanel( void )
+	{
+		IGameEvent *event = gameeventmanager->CreateEvent( "freezecam_started" );
+		if ( event )
+		{
+			gameeventmanager->FireEvent( event );
+		}
+
+		IGameEvent *winEvent = gameeventmanager->CreateEvent( "show_freezepanel" );
+
+		if ( winEvent )
+		{
+			winEvent->SetInt( "killer", 1 );
+			gameeventmanager->FireEvent( winEvent );
+		}
+	}
+	ConCommand test_freezepanel( "test_freezepanel", TestFreezePanel, "", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT );
+#endif // _DEBUG
+
+	static void PrintToConsole( CBasePlayer *player, const char *text )
+	{
+		if ( player )
+		{
+			ClientPrint( player, HUD_PRINTCONSOLE, text );
+		}
+		else
+		{
+			Msg( "%s", text );
+		}
+	}
+
+	void CCSGameRules::DumpTimers( void ) const
+	{
+		extern ConVar bot_join_delay;
+		CBasePlayer *player = UTIL_GetCommandClient();
+		CFmtStr str;
+
+		PrintToConsole( player, str.sprintf( "Timers and related info at %f:\n", gpGlobals->curtime ) );
+		PrintToConsole( player, str.sprintf( "m_bCompleteReset: %d\n", m_bCompleteReset ) );
+		PrintToConsole( player, str.sprintf( "m_iTotalRoundsPlayed: %d\n", m_iTotalRoundsPlayed ) );
+		PrintToConsole( player, str.sprintf( "m_iRoundTime: %d\n", m_iRoundTime.Get() ) );
+		PrintToConsole( player, str.sprintf( "m_iRoundWinStatus: %d\n", m_iRoundWinStatus ) );
+
+		PrintToConsole( player, str.sprintf( "first connected: %d\n", m_bFirstConnected ) );
+		PrintToConsole( player, str.sprintf( "intermission end time: %f\n", m_flIntermissionEndTime ) );
+		PrintToConsole( player, str.sprintf( "freeze period: %d\n", m_bFreezePeriod.Get() ) );
+		PrintToConsole( player, str.sprintf( "round restart time: %f\n", m_flRestartRoundTime ) );
+		PrintToConsole( player, str.sprintf( "game start time: %f\n", m_flGameStartTime.Get() ) );
+		PrintToConsole( player, str.sprintf( "m_fRoundStartTime: %f\n", m_fRoundStartTime.Get() ) );
+		PrintToConsole( player, str.sprintf( "freeze time: %d\n", m_iFreezeTime ) );
+		PrintToConsole( player, str.sprintf( "next think: %f\n", m_tmNextPeriodicThink ) );
+
+		PrintToConsole( player, str.sprintf( "fraglimit: %d\n", fraglimit.GetInt() ) );
+		PrintToConsole( player, str.sprintf( "mp_maxrounds: %d\n", mp_maxrounds.GetInt() ) );
+		PrintToConsole( player, str.sprintf( "mp_winlimit: %d\n", mp_winlimit.GetInt() ) );
+		PrintToConsole( player, str.sprintf( "bot_quota: %d\n", cv_bot_quota.GetInt() ) );
+		PrintToConsole( player, str.sprintf( "bot_quota_mode: %s\n", cv_bot_quota_mode.GetString() ) );
+		PrintToConsole( player, str.sprintf( "bot_join_after_player: %d\n", cv_bot_join_after_player.GetInt() ) );
+		PrintToConsole( player, str.sprintf( "bot_join_delay: %d\n", bot_join_delay.GetInt() ) );
+		PrintToConsole( player, str.sprintf( "nextlevel: %s\n", nextlevel.GetString() ) );
+
+		int humansInGame = UTIL_HumansInGame( true );
+		int botsInGame = UTIL_BotsInGame();
+		PrintToConsole( player, str.sprintf( "%d humans and %d bots in game\n", humansInGame, botsInGame ) );
+
+		PrintToConsole( player, str.sprintf( "num CTs (spawnable): %d (%d)\n", m_iNumCT, m_iNumSpawnableCT ) );
+		PrintToConsole( player, str.sprintf( "num Ts (spawnable): %d (%d)\n", m_iNumTerrorist, m_iNumSpawnableTerrorist ) );
+
+		if ( g_fGameOver )
+		{
+			PrintToConsole( player, str.sprintf( "Game is over!\n" ) );
+		}
+		PrintToConsole( player, str.sprintf( "\n" ) );
+	}
+
+	CON_COMMAND( mp_dump_timers, "Prints round timers to the console for debugging" )
+	{
+		if ( !UTIL_IsCommandIssuedByServerAdmin() )
+			return;
+
+		if ( CSGameRules() )
+		{
+			CSGameRules()->DumpTimers();
+		}
+	}
+
+
+	// living players on the given team need to be marked as not receiving any money
+	// next round.
+	void CCSGameRules::MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(int team)
+	{
+		int playerNum;
+		for (playerNum = 1; playerNum <= gpGlobals->maxClients; ++playerNum)
+		{
+			CCSPlayer *player = (CCSPlayer *)UTIL_PlayerByIndex(playerNum);
+			if (player == NULL)
+			{
+				continue;
+			}
+
+			if ((player->GetTeamNumber() == team) && (player->IsAlive()))
+			{
+				player->MarkAsNotReceivingMoneyNextRound();
+			}
+		}
+	}
+
+
+	void CCSGameRules::CheckLevelInitialized( void )
+	{
+		if ( !m_bLevelInitialized )
+		{
+			// Count the number of spawn points for each team
+			// This determines the maximum number of players allowed on each
+
+			CBaseEntity* ent = NULL; 
+			
+			m_iSpawnPointCount_Terrorist	= 0;
+			m_iSpawnPointCount_CT			= 0;
+
+			while ( ( ent = gEntList.FindEntityByClassname( ent, "info_player_terrorist" ) ) != NULL )
+			{
+				if ( IsSpawnPointValid( ent, NULL ) )
+				{
+					m_iSpawnPointCount_Terrorist++;
+				}
+				else
+				{
+					Warning("Invalid terrorist spawnpoint at (%.1f,%.1f,%.1f)\n",
+						ent->GetAbsOrigin()[0],ent->GetAbsOrigin()[2],ent->GetAbsOrigin()[2] );
+				}
+			}
+
+			while ( ( ent = gEntList.FindEntityByClassname( ent, "info_player_counterterrorist" ) ) != NULL )
+			{
+				if ( IsSpawnPointValid( ent, NULL ) ) 
+				{
+					m_iSpawnPointCount_CT++;
+				}
+				else
+				{
+					Warning("Invalid counterterrorist spawnpoint at (%.1f,%.1f,%.1f)\n",
+						ent->GetAbsOrigin()[0],ent->GetAbsOrigin()[2],ent->GetAbsOrigin()[2] );
+				}
+			}
+
+			// Is this a logo map?
+			if ( gEntList.FindEntityByClassname( NULL, "info_player_logo" ) )
+				m_bLogoMap = true;
+
+			m_bLevelInitialized = true;
+		}
+	}
+
+	void CCSGameRules::ShowSpawnPoints( void )
+	{
+		CBaseEntity* ent = NULL;
+		
+		while ( ( ent = gEntList.FindEntityByClassname( ent, "info_player_terrorist" ) ) != NULL )
+		{
+			if ( IsSpawnPointValid( ent, NULL ) )
+			{
+				NDebugOverlay::Box( ent->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 0, 255, 0, 200, 600 );
+			}
+			else
+			{
+				NDebugOverlay::Box( ent->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 255, 0, 0, 200, 600);
+			}
+		}
+
+		while ( ( ent = gEntList.FindEntityByClassname( ent, "info_player_counterterrorist" ) ) != NULL )
+		{
+			if ( IsSpawnPointValid( ent, NULL ) ) 
+			{
+				NDebugOverlay::Box( ent->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 0, 255, 0, 200, 600 );
+			}
+			else
+			{
+				NDebugOverlay::Box( ent->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 255, 0, 0, 200, 600 );
+			}
+		}
+	}
+
+	void CCSGameRules::CheckRestartRound( void )
+	{
+		// Restart the game if specified by the server
+		int iRestartDelay = mp_restartgame.GetInt();
+
+		if ( iRestartDelay > 0 )
+		{
+			if ( iRestartDelay > 60 )
+				iRestartDelay = 60;
+
+			// log the restart
+			UTIL_LogPrintf( "World triggered \"Restart_Round_(%i_%s)\"\n", iRestartDelay, iRestartDelay == 1 ? "second" : "seconds" );
+
+			UTIL_LogPrintf( "Team \"CT\" scored \"%i\" with \"%i\" players\n", m_iNumCTWins, m_iNumCT );
+			UTIL_LogPrintf( "Team \"TERRORIST\" scored \"%i\" with \"%i\" players\n", m_iNumTerroristWins, m_iNumTerrorist );
+
+			// let the players know
+			char strRestartDelay[64];
+			Q_snprintf( strRestartDelay, sizeof( strRestartDelay ), "%d", iRestartDelay );
+			UTIL_ClientPrintAll( HUD_PRINTCENTER, "#Game_will_restart_in", strRestartDelay, iRestartDelay == 1 ? "SECOND" : "SECONDS" );
+			UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "#Game_will_restart_in", strRestartDelay, iRestartDelay == 1 ? "SECOND" : "SECONDS" );
+
+			m_flRestartRoundTime = gpGlobals->curtime + iRestartDelay;
+			m_bCompleteReset = true;
+			mp_restartgame.SetValue( 0 );
+		}
+	}
+
+
+	class SetHumanTeamFunctor
+	{
+	public:
+		SetHumanTeamFunctor( int targetTeam )
+		{
+			m_targetTeam = targetTeam;
+			m_sourceTeam = ( m_targetTeam == TEAM_CT ) ? TEAM_TERRORIST : TEAM_CT;
+
+			m_traitors.MakeReliable();
+			m_loyalists.MakeReliable();
+			m_loyalists.AddAllPlayers();
+		}
+
+		bool operator()( CBasePlayer *basePlayer )
+		{
+			CCSPlayer *player = ToCSPlayer( basePlayer );
+			if ( !player )
+				return true;
+
+			if ( player->IsBot() )
+				return true;
+
+			if ( player->GetTeamNumber() != m_sourceTeam )
+				return true;
+
+			if ( player->State_Get() == STATE_PICKINGCLASS )
+				return true;
+
+			if ( CSGameRules()->TeamFull( m_targetTeam ) )
+				return false;
+
+			if ( CSGameRules()->TeamStacked( m_targetTeam, m_sourceTeam ) )
+				return false;
+
+			player->SwitchTeam( m_targetTeam );
+			m_traitors.AddRecipient( player );
+			m_loyalists.RemoveRecipient( player );
+
+			return true;
+		}
+
+		void SendNotice( void )
+		{
+			if ( m_traitors.GetRecipientCount() > 0 )
+			{
+				UTIL_ClientPrintFilter( m_traitors, HUD_PRINTCENTER, "#Player_Balanced" );
+				UTIL_ClientPrintFilter( m_loyalists, HUD_PRINTCENTER, "#Teams_Balanced" );
+			}
+		}
+
+	private:
+		int m_targetTeam;
+		int m_sourceTeam;
+
+		CRecipientFilter m_traitors;
+		CRecipientFilter m_loyalists;
+	};
+
+
+	void CCSGameRules::MoveHumansToHumanTeam( void )
+	{
+		int targetTeam = GetHumanTeam();
+		if ( targetTeam != TEAM_TERRORIST && targetTeam != TEAM_CT )
+			return;
+
+		SetHumanTeamFunctor setTeam( targetTeam );
+		ForEachPlayer( setTeam );
+
+		setTeam.SendNotice();
+	}
+
+
+	void CCSGameRules::BalanceTeams( void )
+	{
+		int iTeamToSwap = TEAM_UNASSIGNED;
+		int iNumToSwap;
+
+		if (m_iMapHasVIPSafetyZone == 1) // The ratio for teams is different for Assasination maps
+		{
+			int iDesiredNumCT, iDesiredNumTerrorist;
+			
+			if ( (m_iNumCT + m_iNumTerrorist)%2 != 0)	// uneven number of players
+				iDesiredNumCT			= (int)((m_iNumCT + m_iNumTerrorist) * 0.55) + 1;
+			else
+				iDesiredNumCT			= (int)((m_iNumCT + m_iNumTerrorist)/2);
+			iDesiredNumTerrorist	= (m_iNumCT + m_iNumTerrorist) - iDesiredNumCT;
+
+			if ( m_iNumCT < iDesiredNumCT )
+			{
+				iTeamToSwap = TEAM_TERRORIST;
+				iNumToSwap = iDesiredNumCT - m_iNumCT;
+			}
+			else if ( m_iNumTerrorist < iDesiredNumTerrorist )
+			{
+				iTeamToSwap = TEAM_CT;
+				iNumToSwap = iDesiredNumTerrorist - m_iNumTerrorist;
+			}
+			else
+				return;
+		}
+		else
+		{
+			if (m_iNumCT > m_iNumTerrorist)
+			{
+				iTeamToSwap = TEAM_CT;
+				iNumToSwap = (m_iNumCT - m_iNumTerrorist)/2;
+				
+			}
+			else if (m_iNumTerrorist > m_iNumCT)
+			{
+				iTeamToSwap = TEAM_TERRORIST;
+				iNumToSwap = (m_iNumTerrorist - m_iNumCT)/2;
+			}
+			else
+			{
+				return;	// Teams are even.. Get out of here.
+			}
+		}
+
+		if (iNumToSwap > 3) // Don't swap more than 3 players at a time.. This is a naive method of avoiding infinite loops.
+			iNumToSwap = 3;
+
+		int iTragetTeam = TEAM_UNASSIGNED;
+
+		if ( iTeamToSwap == TEAM_CT )
+		{
+			iTragetTeam = TEAM_TERRORIST;
+		}
+		else if ( iTeamToSwap == TEAM_TERRORIST )
+		{
+			iTragetTeam = TEAM_CT;
+		}
+		else
+		{
+			// no valid team to swap
+			return;
+		}
+
+		CRecipientFilter traitors;
+		CRecipientFilter loyalists;
+
+		traitors.MakeReliable();
+		loyalists.MakeReliable();
+		loyalists.AddAllPlayers();
+
+		for (int i = 0; i < iNumToSwap; i++)
+		{
+			// last person to join the server
+			int iHighestUserID = -1;
+			CCSPlayer *pPlayerToSwap = NULL;
+
+			// check if target team is full, exit if so
+			if ( TeamFull(iTragetTeam) )
+				break;
+
+			// search for player with highest UserID = most recently joined to switch over
+			for ( int j = 1; j <= gpGlobals->maxClients; j++ )
+			{
+				CCSPlayer *pPlayer = (CCSPlayer *)UTIL_PlayerByIndex( j );
+
+				if ( !pPlayer )
+					continue;
+
+				CCSBot *bot = dynamic_cast< CCSBot * >(pPlayer);
+				if ( bot )
+					continue; // don't swap bots - the bot system will handle that
+
+				if ( pPlayer &&
+					 ( m_pVIP != pPlayer ) && 
+					 ( pPlayer->GetTeamNumber() == iTeamToSwap ) && 
+					 ( engine->GetPlayerUserId( pPlayer->edict() ) > iHighestUserID ) &&
+					 ( pPlayer->State_Get() != STATE_PICKINGCLASS ) )
+					{
+						iHighestUserID = engine->GetPlayerUserId( pPlayer->edict() );
+						pPlayerToSwap = pPlayer;
+					}
+			}
+
+			if ( pPlayerToSwap != NULL )
+			{
+				traitors.AddRecipient( pPlayerToSwap );
+				loyalists.RemoveRecipient( pPlayerToSwap );
+				pPlayerToSwap->SwitchTeam( iTragetTeam );
+			}
+		}
+
+		if ( traitors.GetRecipientCount() > 0 )
+		{
+			UTIL_ClientPrintFilter( traitors, HUD_PRINTCENTER, "#Player_Balanced" );
+			UTIL_ClientPrintFilter( loyalists, HUD_PRINTCENTER, "#Teams_Balanced" );
+		}
+	}
+
+
+	bool CCSGameRules::TeamFull( int team_id )
+	{
+		CheckLevelInitialized();
+
+		switch ( team_id )
+		{
+		case TEAM_TERRORIST:
+			return m_iNumTerrorist >= m_iSpawnPointCount_Terrorist;
+
+		case TEAM_CT:
+			return m_iNumCT >= m_iSpawnPointCount_CT;
+		}
+
+		return false;
+	}
+	
+	int CCSGameRules::GetHumanTeam()
+	{
+		if ( FStrEq( "CT", mp_humanteam.GetString() ) )
+		{
+			return TEAM_CT;
+		}
+		else if ( FStrEq( "T", mp_humanteam.GetString() ) )
+		{
+			return TEAM_TERRORIST;
+		}
+		
+		return TEAM_UNASSIGNED;
+	}
+
+	int CCSGameRules::SelectDefaultTeam( bool ignoreBots /*= false*/ )
+	{
+		if ( ignoreBots && ( FStrEq( cv_bot_join_team.GetString(), "T" ) || FStrEq( cv_bot_join_team.GetString(), "CT" ) ) )
+		{
+			ignoreBots = false;	// don't ignore bots when they can't switch teams
+		}
+
+		if ( ignoreBots && !mp_autoteambalance.GetBool() )
+		{
+			ignoreBots = false;	// don't ignore bots when they can't switch teams
+		}
+
+		int team = TEAM_UNASSIGNED;
+		int numTerrorists = m_iNumTerrorist;
+		int numCTs = m_iNumCT;
+		if ( ignoreBots )
+		{
+			numTerrorists = UTIL_HumansOnTeam( TEAM_TERRORIST );
+			numCTs = UTIL_HumansOnTeam( TEAM_CT );
+		}
+
+		// Choose the team that's lacking players
+		if ( numTerrorists < numCTs )
+		{
+			team = TEAM_TERRORIST;
+		}
+		else if ( numTerrorists > numCTs )
+		{
+			team = TEAM_CT;
+		}
+		// Choose the team that's losing
+		else if ( m_iNumTerroristWins < m_iNumCTWins )
+		{
+			team = TEAM_TERRORIST;
+		}
+		else if ( m_iNumCTWins < m_iNumTerroristWins )
+		{
+			team = TEAM_CT;
+		}
+		else
+		{
+			// Teams and scores are equal, pick a random team
+			if ( random->RandomInt( 0, 1 ) == 0 )
+			{
+				team = TEAM_CT;
+			}
+			else
+			{
+				team = TEAM_TERRORIST;
+			}
+		}
+
+		if ( TeamFull( team ) )
+		{
+			// Pick the opposite team
+			if ( team == TEAM_TERRORIST )
+			{
+				team = TEAM_CT;
+			}
+			else
+			{
+				team = TEAM_TERRORIST;
+			}
+
+			// No choices left
+			if ( TeamFull( team ) )
+				return TEAM_UNASSIGNED;
+		}
+
+		return team;
+	}
+
+	//checks to see if the desired team is stacked, returns true if it is
+	bool CCSGameRules::TeamStacked( int newTeam_id, int curTeam_id  )
+	{
+		//players are allowed to change to their own team
+		if(newTeam_id == curTeam_id)
+			return false;
+
+		// if mp_limitteams is 0, don't check
+		if ( mp_limitteams.GetInt() == 0 )
+			return false;
+
+		switch ( newTeam_id )
+		{
+		case TEAM_TERRORIST:
+			if(curTeam_id != TEAM_UNASSIGNED && curTeam_id != TEAM_SPECTATOR)
+			{
+				if((m_iNumTerrorist + 1) > (m_iNumCT + mp_limitteams.GetInt() - 1))
+					return true;
+				else
+					return false;
+			}
+			else
+			{
+				if((m_iNumTerrorist + 1) > (m_iNumCT + mp_limitteams.GetInt()))
+					return true;
+				else
+					return false;
+			}
+			break;
+		case TEAM_CT:
+			if(curTeam_id != TEAM_UNASSIGNED && curTeam_id != TEAM_SPECTATOR)
+			{
+				if((m_iNumCT + 1) > (m_iNumTerrorist + mp_limitteams.GetInt() - 1))
+					return true;
+				else
+					return false;
+			}
+			else
+			{
+				if((m_iNumCT + 1) > (m_iNumTerrorist + mp_limitteams.GetInt()))
+					return true;
+				else
+					return false;
+			}
+			break;
+		}
+
+		return false;
+	}
+
+
+	//=========================================================
+	//=========================================================
+	bool CCSGameRules::FPlayerCanRespawn( CBasePlayer *pBasePlayer )
+	{
+		CCSPlayer *pPlayer = ToCSPlayer( pBasePlayer );
+		if ( !pPlayer )
+			Error( "FPlayerCanRespawn: pPlayer=0" );
+
+		// Player cannot respawn twice in a round
+		if ( pPlayer->m_iNumSpawns > 0 && m_bFirstConnected )
+			return false;
+
+		// If they're dead after the map has ended, and it's about to start the next round,
+		// wait for the round restart to respawn them.
+		if ( gpGlobals->curtime < m_flRestartRoundTime )
+			return false;
+
+		// Only valid team members can spawn
+		if ( pPlayer->GetTeamNumber() != TEAM_CT && pPlayer->GetTeamNumber() != TEAM_TERRORIST )
+			return false;
+
+		// Only players with a valid class can spawn
+		if ( pPlayer->GetClass() == CS_CLASS_NONE )
+			return false;
+
+		// Player cannot respawn until next round if more than 20 seconds in
+
+		// Tabulate the number of players on each team.
+		m_iNumCT = GetGlobalTeam( TEAM_CT )->GetNumPlayers();
+		m_iNumTerrorist = GetGlobalTeam( TEAM_TERRORIST )->GetNumPlayers();
+
+		if ( m_iNumTerrorist > 0 && m_iNumCT > 0 )
+		{
+			if ( gpGlobals->curtime > (m_fRoundStartTime + 20) )
+			{
+				//If this player just connected and fadetoblack is on, then maybe
+				//the server admin doesn't want him peeking around.
+				color32_s clr = {0,0,0,255};
+				if ( mp_fadetoblack.GetBool() )
+				{
+					UTIL_ScreenFade( pPlayer, clr, 3, 3, FFADE_OUT | FFADE_STAYOUT );
+				}
+
+				return false;
+			}
+		}
+
+		// Player cannot respawn while in the Choose Appearance menu
+		//if ( pPlayer->m_iMenu == Menu_ChooseAppearance )
+		//	return false;
+
+		return true;
+	}
+
+	void CCSGameRules::TerminateRound(float tmDelay, int iReason )
+	{
+		variant_t emptyVariant;
+		int iWinnerTeam = WINNER_NONE;
+		const char *text = "UNKNOWN";
+				
+		// UTIL_ClientPrintAll( HUD_PRINTCENTER, sentence );
+
+		switch ( iReason )
+		{
+// Terror wins:
+			case Target_Bombed:	
+				text = "#Target_Bombed";
+				iWinnerTeam = WINNER_TER;
+				break;
+
+			case VIP_Assassinated:
+				text = "#VIP_Assassinated";
+				iWinnerTeam = WINNER_TER;
+				break;
+
+			case Terrorists_Escaped:
+				text = "#Terrorists_Escaped";
+				iWinnerTeam = WINNER_TER;
+				break;
+
+			case Terrorists_Win:
+				text = "#Terrorists_Win";
+				iWinnerTeam = WINNER_TER;
+				break;
+
+			case Hostages_Not_Rescued:
+				text = "#Hostages_Not_Rescued";
+				iWinnerTeam = WINNER_TER;
+				break;
+
+			case VIP_Not_Escaped:
+				text = "#VIP_Not_Escaped";
+				iWinnerTeam = WINNER_TER;
+				break;
+// CT wins:
+			case VIP_Escaped:
+				text = "#VIP_Escaped";
+				iWinnerTeam = WINNER_CT;
+				break;
+
+			case CTs_PreventEscape:
+				text = "#CTs_PreventEscape";
+				iWinnerTeam = WINNER_CT;
+				break;
+
+			case Escaping_Terrorists_Neutralized:
+				text = "#Escaping_Terrorists_Neutralized";
+				iWinnerTeam = WINNER_CT;
+				break;
+
+			case Bomb_Defused:
+				text = "#Bomb_Defused";
+				iWinnerTeam = WINNER_CT;
+				break;
+
+			case CTs_Win:
+				text = "#CTs_Win";
+				iWinnerTeam = WINNER_CT;
+				break;
+
+			case All_Hostages_Rescued:
+				text = "#All_Hostages_Rescued";
+				iWinnerTeam = WINNER_CT;
+				break;
+
+			case Target_Saved:
+				text = "#Target_Saved";
+				iWinnerTeam = WINNER_CT;
+				break;
+
+			case Terrorists_Not_Escaped:
+				text = "#Terrorists_Not_Escaped";
+				iWinnerTeam = WINNER_CT;
+				break;
+// no winners:
+			case Game_Commencing:
+				text = "#Game_Commencing";
+				iWinnerTeam = WINNER_DRAW;
+				break;
+
+			case Round_Draw:
+				text = "#Round_Draw";
+				iWinnerTeam = WINNER_DRAW;
+				break;
+
+			default:
+				DevMsg("TerminateRound: unknown round end ID %i\n", iReason );
+				break;
+		}
+
+		m_iRoundWinStatus = iWinnerTeam;
+		m_flRestartRoundTime = gpGlobals->curtime + tmDelay;
+
+		if ( iWinnerTeam == WINNER_CT )
+		{
+			for( int i=0;i<g_Hostages.Count();i++ )
+				g_Hostages[i]->AcceptInput( "CTsWin", NULL, NULL, emptyVariant, 0 );
+		}
+
+		else if ( iWinnerTeam == WINNER_TER )
+		{
+			for( int i=0;i<g_Hostages.Count();i++ )
+				g_Hostages[i]->AcceptInput( "TerroristsWin", NULL, NULL, emptyVariant, 0 );
+		}
+		else
+		{
+			Assert( iWinnerTeam == WINNER_NONE || iWinnerTeam == WINNER_DRAW );
+		}
+
+		//=============================================================================
+		// HPE_BEGIN:		
+		//=============================================================================
+
+		// [tj] Check for any non-player-specific achievements.
+		ProcessEndOfRoundAchievements(iWinnerTeam, iReason);
+
+		if( iReason != Game_Commencing )
+		{
+			// [pfreese] Setup and send win panel event (primarily funfact data)
+
+			FunFact funfact;
+			funfact.szLocalizationToken = "";
+			funfact.iPlayer = 0;
+			funfact.iData1 = 0;
+			funfact.iData2 = 0;
+			funfact.iData3 = 0;
+
+			m_pFunFactManager->GetRoundEndFunFact( iWinnerTeam, iReason, funfact);
+
+			//Send all the info needed for the win panel
+			IGameEvent *winEvent = gameeventmanager->CreateEvent( "cs_win_panel_round" );
+
+			if ( winEvent )
+			{
+				// determine what categories to send
+				if ( GetRoundRemainingTime() <= 0 )
+				{
+					// timer expired, defenders win
+					// show total time that was defended
+					winEvent->SetBool( "show_timer_defend", true );
+					winEvent->SetInt( "timer_time", m_iRoundTime );
+				}
+				else
+				{
+					// attackers win
+					// show time it took for them to win
+					winEvent->SetBool( "show_timer_attack", true );
+
+					int iTimeElapsed = m_iRoundTime - GetRoundRemainingTime();
+					winEvent->SetInt( "timer_time", iTimeElapsed );
+				}
+
+				winEvent->SetInt( "final_event", iReason );
+
+				// Set the fun fact data in the event
+				winEvent->SetString( "funfact_token", funfact.szLocalizationToken);
+				winEvent->SetInt( "funfact_player", funfact.iPlayer );
+				winEvent->SetInt( "funfact_data1", funfact.iData1 );
+				winEvent->SetInt( "funfact_data2", funfact.iData2 );
+				winEvent->SetInt( "funfact_data3", funfact.iData3 );
+				gameeventmanager->FireEvent( winEvent );
+			}
+		}
+
+		// [tj] Inform players that the round is over
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+			if(pPlayer)
+			{
+				pPlayer->OnRoundEnd(iWinnerTeam, iReason);
+			}
+		}
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+		IGameEvent * event = gameeventmanager->CreateEvent( "round_end" );
+		if ( event )
+		{
+			event->SetInt( "winner", iWinnerTeam );
+			event->SetInt( "reason", iReason );
+			event->SetString( "message", text );
+			event->SetInt( "priority", 6 ); // HLTV event priority, not transmitted
+			gameeventmanager->FireEvent( event );
+		}
+
+		if ( GetMapRemainingTime() == 0.0f  )
+		{
+			UTIL_LogPrintf("World triggered \"Intermission_Time_Limit\"\n");
+			GoToIntermission();
+		}
+	}
+
+	//=============================================================================
+	// HPE_BEGIN:	
+	//=============================================================================
+
+	// Helper to determine if all players on a team are playing for the same clan
+	static bool IsClanTeam( CTeam *pTeam )
+	{
+		uint32 iTeamClan = 0;
+		for ( int iPlayer = 0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
+		{
+			CBasePlayer *pPlayer = pTeam->GetPlayer( iPlayer );
+			if ( !pPlayer )
+				return false;
+
+			const char *pClanID = engine->GetClientConVarValue( pPlayer->entindex(), "cl_clanid" );
+			uint32 iPlayerClan = atoi( pClanID );
+			if ( iPlayer == 0 )
+			{
+				// Initialize the team clan
+				iTeamClan = iPlayerClan;
+			}
+			else
+			{
+				if ( iPlayerClan != iTeamClan || iPlayerClan == 0 )
+					return false;
+			}
+		}
+		return iTeamClan != 0;
+	}
+
+	// [tj] This is where we check non-player-specific that occur at the end of the round
+	void CCSGameRules::ProcessEndOfRoundAchievements(int iWinnerTeam, int iReason)
+	{
+		if (iWinnerTeam == WINNER_CT || iWinnerTeam == WINNER_TER)
+		{
+			int losingTeamId = (iWinnerTeam == TEAM_CT) ? TEAM_TERRORIST : TEAM_CT;
+			CTeam* losingTeam = GetGlobalTeam(losingTeamId);
+
+			
+			//Check for players we should ignore when checking team size.
+			int ignoreCount = 0;
+			
+			for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+			{
+				CCSPlayer* pPlayer = (CCSPlayer*)UTIL_PlayerByIndex( i );
+				if (pPlayer)
+				{
+					int teamNum = pPlayer->GetTeamNumber();
+					if ( teamNum == losingTeamId )
+					{
+						if (pPlayer->WasNotKilledNaturally())
+						{
+							ignoreCount++;
+						}
+					}
+				}
+			}
+
+
+			// [tj] Check extermination with no losses achievement
+			if ( ( ( iReason == CTs_Win && m_bNoCTsKilled ) || ( iReason == Terrorists_Win && m_bNoTerroristsKilled ) ) 
+				&& losingTeam && losingTeam->GetNumPlayers() - ignoreCount >= AchievementConsts::DefaultMinOpponentsForAchievement)
+			{
+				CTeam *pTeam = GetGlobalTeam( iWinnerTeam );
+
+				for ( int iPlayer=0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
+				{
+					CCSPlayer *pPlayer = ToCSPlayer( pTeam->GetPlayer( iPlayer ) );
+					Assert( pPlayer );
+					if ( !pPlayer )
+						continue;
+
+					pPlayer->AwardAchievement(CSLosslessExtermination);
+				}
+			}
+
+			// [tj] Check flawless victory achievement - currently requiring extermination
+			if (((iReason == CTs_Win && m_bNoCTsDamaged) || (iReason == Terrorists_Win && m_bNoTerroristsDamaged))
+				&& losingTeam && losingTeam->GetNumPlayers() - ignoreCount >= AchievementConsts::DefaultMinOpponentsForAchievement)
+			{
+				CTeam *pTeam = GetGlobalTeam( iWinnerTeam );
+
+				for ( int iPlayer=0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
+				{
+					CCSPlayer *pPlayer = ToCSPlayer( pTeam->GetPlayer( iPlayer ) );
+					Assert( pPlayer );
+					if ( !pPlayer )
+						continue;
+
+					pPlayer->AwardAchievement(CSFlawlessVictory);
+				}
+			}
+
+			// [tj] Check bloodless victory achievement
+			if (((iWinnerTeam == TEAM_TERRORIST && m_bNoCTsKilled) || (iWinnerTeam == Terrorists_Win && m_bNoTerroristsKilled))
+				&& losingTeam && losingTeam->GetNumPlayers() >= AchievementConsts::DefaultMinOpponentsForAchievement)
+			{
+				CTeam *pTeam = GetGlobalTeam( iWinnerTeam );
+
+				for ( int iPlayer=0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
+				{
+					CCSPlayer *pPlayer = ToCSPlayer( pTeam->GetPlayer( iPlayer ) );
+					Assert( pPlayer );
+					if ( !pPlayer )
+						continue;
+
+					pPlayer->AwardAchievement(CSBloodlessVictory);
+				}
+			}
+
+			// Check the clan match achievement
+			CTeam *pWinningTeam = GetGlobalTeam( iWinnerTeam );
+			if ( pWinningTeam && pWinningTeam->GetNumPlayers() >= AchievementConsts::DefaultMinOpponentsForAchievement &&
+				 losingTeam && losingTeam->GetNumPlayers() - ignoreCount >= AchievementConsts::DefaultMinOpponentsForAchievement &&
+				 IsClanTeam( pWinningTeam ) && IsClanTeam( losingTeam ) )
+			{
+				for ( int iPlayer=0; iPlayer < pWinningTeam->GetNumPlayers(); iPlayer++ )
+				{
+					CCSPlayer *pPlayer = ToCSPlayer( pWinningTeam->GetPlayer( iPlayer ) );
+					if ( !pPlayer )
+						continue;
+
+					pPlayer->AwardAchievement( CSWinClanMatch );
+				}
+			}
+		}
+	}
+
+	//[tj] Counts the number of players in each category in the struct (dead, alive, etc...)
+	void CCSGameRules::GetPlayerCounts(TeamPlayerCounts teamCounts[TEAM_MAXCOUNT])
+	{
+		memset(teamCounts, 0, sizeof(TeamPlayerCounts) * TEAM_MAXCOUNT);
+
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer* pPlayer = (CCSPlayer*)UTIL_PlayerByIndex( i );
+			if (pPlayer)
+			{
+				int iTeam = pPlayer->GetTeamNumber();
+
+				if (iTeam >= 0 && iTeam < TEAM_MAXCOUNT)
+				{
+					++teamCounts[iTeam].totalPlayers;
+					if (pPlayer->IsAlive())
+					{
+						++teamCounts[iTeam].totalAlivePlayers;
+					}
+					else
+					{
+						++teamCounts[iTeam].totalDeadPlayers;
+
+						//If the player has joined a team bit isn't in the game yet
+						if (pPlayer->State_Get() == STATE_PICKINGCLASS)
+						{
+							++teamCounts[iTeam].unenteredPlayers;
+						}
+						else if (pPlayer->WasNotKilledNaturally())
+						{
+							++teamCounts[iTeam].suicidedPlayers;
+						}
+						else
+						{
+							++teamCounts[iTeam].killedPlayers;
+						}						
+					}
+				}
+			}
+		}
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	void CCSGameRules::UpdateTeamScores()
+	{
+		CTeam *pTerrorists = GetGlobalTeam( TEAM_TERRORIST );
+		CTeam *pCTs = GetGlobalTeam( TEAM_CT );
+
+		Assert( pTerrorists && pCTs );
+
+		if( pTerrorists )
+			pTerrorists->SetScore( m_iNumTerroristWins );
+
+		if( pCTs )
+			pCTs->SetScore( m_iNumCTWins );
+	}
+
+
+	void CCSGameRules::CheckMapConditions()
+	{
+		// Check to see if this map has a bomb target in it
+		if ( gEntList.FindEntityByClassname( NULL, "func_bomb_target" ) )
+		{
+			m_bMapHasBombTarget		= true;
+			m_bMapHasBombZone		= true;
+		}
+		else if ( gEntList.FindEntityByClassname( NULL, "info_bomb_target" ) )
+		{
+			m_bMapHasBombTarget		= true;
+			m_bMapHasBombZone		= false;
+		}
+		else
+		{
+			m_bMapHasBombTarget		= false;
+			m_bMapHasBombZone		= false;
+		}
+
+		// See if the map has func_buyzone entities
+		// Used by CBasePlayer::HandleSignals() to support maps without these entities
+		if ( gEntList.FindEntityByClassname( NULL, "func_buyzone" ) )
+		{
+			m_bMapHasBuyZone = true;
+		}
+		else
+		{
+			m_bMapHasBuyZone = false;
+		}
+
+		// Check to see if this map has hostage rescue zones
+		if ( gEntList.FindEntityByClassname( NULL, "func_hostage_rescue" ) )
+		{
+			m_bMapHasRescueZone = true;
+		}
+		else
+		{
+			m_bMapHasRescueZone = false;
+		}
+
+		// GOOSEMAN : See if this map has func_escapezone entities
+		if ( gEntList.FindEntityByClassname( NULL, "func_escapezone" ) )
+		{
+			m_bMapHasEscapeZone = true;
+		}
+		else
+		{
+			m_bMapHasEscapeZone = false;
+		}
+
+		// Check to see if this map has VIP safety zones
+		if ( gEntList.FindEntityByClassname( NULL, "func_vip_safetyzone" ) )
+		{
+			m_iMapHasVIPSafetyZone = 1;
+		}
+		else
+		{
+			m_iMapHasVIPSafetyZone = 2;
+		}
+	}
+
+
+	void CCSGameRules::SwapAllPlayers()
+	{
+		// MOTODO we have to make sure that enought spaning points exits
+		Assert ( 0 );
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			/* CCSPlayer *pPlayer = CCSPlayer::Instance( i );
+			if ( pPlayer && !FNullEnt( pPlayer->edict() ) )
+				pPlayer->SwitchTeam(); */
+		}
+
+		// Swap Team victories
+		int iTemp;
+
+		iTemp = m_iNumCTWins;
+		m_iNumCTWins = m_iNumTerroristWins;
+		m_iNumTerroristWins = iTemp;
+		
+		// Update the clients team score
+		UpdateTeamScores();
+	}
+
+
+	bool CS_FindInList( const char **pStrings, const char *pToFind )
+	{
+		return FindInList( pStrings, pToFind );
+	}
+
+	void CCSGameRules::CleanUpMap()
+	{
+		if (IsLogoMap())
+			return;
+
+		// Recreate all the map entities from the map data (preserving their indices),
+		// then remove everything else except the players.
+
+		// Get rid of all entities except players.
+		CBaseEntity *pCur = gEntList.FirstEnt();
+		while ( pCur )
+		{
+			CWeaponCSBase *pWeapon = dynamic_cast< CWeaponCSBase* >( pCur );
+			// Weapons with owners don't want to be removed..
+			if ( pWeapon )
+			{
+                //=============================================================================
+                // HPE_BEGIN:
+                // [dwenger] Handle round restart processing for the weapon.
+                //=============================================================================
+
+                pWeapon->OnRoundRestart();
+
+                //=============================================================================
+                // HPE_END
+                //=============================================================================
+
+                if ( pWeapon->ShouldRemoveOnRoundRestart() )
+				{
+					UTIL_Remove( pCur );
+				}
+			}
+			// remove entities that has to be restored on roundrestart (breakables etc)
+			else if ( !CS_FindInList( s_PreserveEnts, pCur->GetClassname() ) )
+			{
+				UTIL_Remove( pCur );
+			}
+			
+			pCur = gEntList.NextEnt( pCur );
+		}
+		
+		// Really remove the entities so we can have access to their slots below.
+		gEntList.CleanupDeleteList();
+
+		// Cancel all queued events, in case a func_bomb_target fired some delayed outputs that
+		// could kill respawning CTs
+		g_EventQueue.Clear();
+
+		// Now reload the map entities.
+		class CCSMapEntityFilter : public IMapEntityFilter
+		{
+		public:
+			virtual bool ShouldCreateEntity( const char *pClassname )
+			{
+				// Don't recreate the preserved entities.
+				if ( !CS_FindInList( s_PreserveEnts, pClassname ) )
+				{
+					return true;
+				}
+				else
+				{
+					// Increment our iterator since it's not going to call CreateNextEntity for this ent.
+					if ( m_iIterator != g_MapEntityRefs.InvalidIndex() )
+						m_iIterator = g_MapEntityRefs.Next( m_iIterator );
+				
+					return false;
+				}
+			}
+
+
+			virtual CBaseEntity* CreateNextEntity( const char *pClassname )
+			{
+				if ( m_iIterator == g_MapEntityRefs.InvalidIndex() )
+				{
+					// This shouldn't be possible. When we loaded the map, it should have used 
+					// CCSMapLoadEntityFilter, which should have built the g_MapEntityRefs list
+					// with the same list of entities we're referring to here.
+					Assert( false );
+					return NULL;
+				}
+				else
+				{
+					CMapEntityRef &ref = g_MapEntityRefs[m_iIterator];
+					m_iIterator = g_MapEntityRefs.Next( m_iIterator );	// Seek to the next entity.
+
+					if ( ref.m_iEdict == -1 || engine->PEntityOfEntIndex( ref.m_iEdict ) )
+					{
+						// Doh! The entity was delete and its slot was reused.
+						// Just use any old edict slot. This case sucks because we lose the baseline.
+						return CreateEntityByName( pClassname );
+					}
+					else
+					{
+						// Cool, the slot where this entity was is free again (most likely, the entity was 
+						// freed above). Now create an entity with this specific index.
+						return CreateEntityByName( pClassname, ref.m_iEdict );
+					}
+				}
+			}
+
+		public:
+			int m_iIterator; // Iterator into g_MapEntityRefs.
+		};
+		CCSMapEntityFilter filter;
+		filter.m_iIterator = g_MapEntityRefs.Head();
+
+		// DO NOT CALL SPAWN ON info_node ENTITIES!
+
+		MapEntity_ParseAllEntities( engine->GetMapEntitiesString(), &filter, true );
+	}
+
+
+	bool CCSGameRules::IsThereABomber()
+	{
+		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+		{
+			CCSPlayer *pPlayer = CCSPlayer::Instance( i );
+
+			if ( pPlayer && !FNullEnt( pPlayer->edict() ) )
+			{
+				if ( pPlayer->GetTeamNumber() == TEAM_CT )
+					continue;
+
+				if ( pPlayer->HasC4() )
+					 return true; //There you are.
+			}
+		}
+
+		//Didn't find a bomber.
+		return false;
+	}
+
+
+	void CCSGameRules::EndRound()
+	{
+		// fake a round end
+		CSGameRules()->TerminateRound( 0.0f, Round_Draw );
+	}
+
+	CBaseEntity *CCSGameRules::GetPlayerSpawnSpot( CBasePlayer *pPlayer )
+	{
+		// gat valid spwan point
+		CBaseEntity *pSpawnSpot = pPlayer->EntSelectSpawnPoint();
+
+		// drop down to ground
+		Vector GroundPos = DropToGround( pPlayer, pSpawnSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX );
+
+		// Move the player to the place it said.
+		pPlayer->Teleport( &pSpawnSpot->GetAbsOrigin(), &pSpawnSpot->GetLocalAngles(), &vec3_origin );
+		pPlayer->m_Local.m_vecPunchAngle = vec3_angle;
+		
+		return pSpawnSpot;
+	}
+	
+	// checks if the spot is clear of players
+	bool CCSGameRules::IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer )
+	{
+		if ( !pSpot->IsTriggered( pPlayer ) )
+		{
+			return false;
+		}
+
+		Vector mins = GetViewVectors()->m_vHullMin;
+		Vector maxs = GetViewVectors()->m_vHullMax;
+
+		Vector vTestMins = pSpot->GetAbsOrigin() + mins;
+		Vector vTestMaxs = pSpot->GetAbsOrigin() + maxs;
+		
+		// First test the starting origin.
+		return UTIL_IsSpaceEmpty( pPlayer, vTestMins, vTestMaxs );
+	}
+
+
+	bool CCSGameRules::IsThereABomb()
+	{
+		bool bBombFound = false;
+
+		/* are there any bombs, either laying around, or in someone's inventory? */
+		if( gEntList.FindEntityByClassname( NULL, WEAPON_C4_CLASSNAME ) != 0 )
+		{
+			bBombFound = true;
+		}
+		/* what about planted bombs!? */
+		else if( gEntList.FindEntityByClassname( NULL, PLANTED_C4_CLASSNAME ) != 0 )
+		{
+			bBombFound = true;
+		}
+		
+		return bBombFound;
+	}
+
+	void CCSGameRules::HostageTouched()
+	{
+		if( gpGlobals->curtime > m_flNextHostageAnnouncement && m_iRoundWinStatus == WINNER_NONE )
+		{
+			//BroadcastSound( "Event.HostageTouched" );
+			m_flNextHostageAnnouncement = gpGlobals->curtime + 60.0;
+		}		
+	}
+
+	void CCSGameRules::CreateStandardEntities()
+	{
+		// Create the player resource
+		g_pPlayerResource = (CPlayerResource*)CBaseEntity::Create( "cs_player_manager", vec3_origin, vec3_angle );
+	
+		// Create the entity that will send our data to the client.
+#ifdef DBGFLAG_ASSERT
+		CBaseEntity *pEnt = 
+#endif
+			CBaseEntity::Create( "cs_gamerules", vec3_origin, vec3_angle );
+		Assert( pEnt );
+	}
+
+#define MY_USHRT_MAX	0xffff
+#define MY_UCHAR_MAX	0xff
+
+bool DataHasChanged( void )
+{
+	for ( int i = 0; i < CS_NUM_LEVELS; i++ )
+	{
+		if ( g_iTerroristVictories[i] != 0 || g_iCounterTVictories[i] != 0 )
+			return true;
+	}
+
+	for ( int i = 0; i < WEAPON_MAX; i++ )
+	{
+		if ( g_iWeaponPurchases[i] != 0 )
+			return true;
+	}
+
+	return false;
+}
+
+void CCSGameRules::UploadGameStats( void )
+{
+	g_flGameStatsUpdateTime -= gpGlobals->curtime;
+
+	if ( g_flGameStatsUpdateTime > 0 )
+		return;
+
+	if ( IsBlackMarket() == false )
+		return;
+
+	if ( m_bDontUploadStats == true )
+		return;
+
+	if ( DataHasChanged() == true )
+	{
+		cs_gamestats_t stats;
+		memset( &stats, 0, sizeof(stats) );
+
+		// Header
+		stats.header.iVersion = CS_STATS_BLOB_VERSION;
+		Q_strncpy( stats.header.szGameName, "cstrike", sizeof(stats.header.szGameName) );
+		Q_strncpy( stats.header.szMapName, STRING( gpGlobals->mapname ), sizeof( stats.header.szMapName ) );
+
+		ConVar *hostip = cvar->FindVar( "hostip" );
+		if ( hostip )
+		{
+			int ip = hostip->GetInt();
+			stats.header.ipAddr[0] = ip >> 24;
+			stats.header.ipAddr[1] = ( ip >> 16 ) & MY_UCHAR_MAX;
+			stats.header.ipAddr[2] = ( ip >> 8 ) & MY_UCHAR_MAX;
+			stats.header.ipAddr[3] = ( ip ) & MY_UCHAR_MAX;
+		}			
+
+		ConVar *hostport = cvar->FindVar( "hostip" );
+		if ( hostport )
+		{
+			stats.header.port = hostport->GetInt();
+		}			
+
+		stats.header.serverid = 0;
+
+		stats.iMinutesPlayed = clamp( (short)( gpGlobals->curtime / 60 ), 0, MY_USHRT_MAX ); 
+
+		memcpy( stats.iTerroristVictories, g_iTerroristVictories, sizeof( g_iTerroristVictories) );
+		memcpy( stats.iCounterTVictories, g_iCounterTVictories, sizeof( g_iCounterTVictories) );
+		memcpy( stats.iBlackMarketPurchases, g_iWeaponPurchases, sizeof( g_iWeaponPurchases) );
+
+		stats.iAutoBuyPurchases = g_iAutoBuyPurchases;
+		stats.iReBuyPurchases = g_iReBuyPurchases;
+
+		stats.iAutoBuyM4A1Purchases = g_iAutoBuyM4A1Purchases;
+		stats.iAutoBuyAK47Purchases = g_iAutoBuyAK47Purchases;
+		stats.iAutoBuyFamasPurchases = g_iAutoBuyFamasPurchases;
+		stats.iAutoBuyGalilPurchases = g_iAutoBuyGalilPurchases;
+		stats.iAutoBuyVestHelmPurchases = g_iAutoBuyVestHelmPurchases;
+		stats.iAutoBuyVestPurchases = g_iAutoBuyVestPurchases;
+
+		const void *pvBlobData = ( const void * )( &stats );
+		unsigned int uBlobSize = sizeof( stats );
+
+		if ( gamestatsuploader )
+		{
+			gamestatsuploader->UploadGameStats( 
+				STRING( gpGlobals->mapname ),
+				CS_STATS_BLOB_VERSION,
+				uBlobSize,
+				pvBlobData );
+		}
+
+
+		memset( g_iWeaponPurchases, 0, sizeof( g_iWeaponPurchases) );
+		memset( g_iTerroristVictories, 0, sizeof( g_iTerroristVictories) );
+		memset( g_iCounterTVictories, 0, sizeof( g_iTerroristVictories) );
+
+		g_iAutoBuyPurchases = 0;
+		g_iReBuyPurchases = 0;
+
+		g_iAutoBuyM4A1Purchases = 0;
+		g_iAutoBuyAK47Purchases = 0;
+		g_iAutoBuyFamasPurchases = 0;
+		g_iAutoBuyGalilPurchases = 0;
+		g_iAutoBuyVestHelmPurchases = 0;
+		g_iAutoBuyVestPurchases = 0;
+	}
+
+	g_flGameStatsUpdateTime = CS_GAME_STATS_UPDATE; //Next update is between 22 and 24 hours.
+}
+#endif	// CLIENT_DLL
+
+CBaseCombatWeapon *CCSGameRules::GetNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon )
+{
+	CBaseCombatWeapon *bestWeapon = NULL;
+
+	// search all the weapons looking for the closest next
+	for ( int i = 0; i < MAX_WEAPONS; i++ )
+	{
+		CBaseCombatWeapon *weapon = pPlayer->GetWeapon(i);
+		if ( !weapon )
+			continue;
+
+		if ( !weapon->CanBeSelected() || weapon == pCurrentWeapon )
+			continue;
+
+#ifndef CLIENT_DLL
+		CCSPlayer *csPlayer = ToCSPlayer(pPlayer);
+		CWeaponCSBase *csWeapon = static_cast< CWeaponCSBase * >(weapon);
+		if ( csPlayer && csPlayer->IsBot() && !TheCSBots()->IsWeaponUseable( csWeapon ) )
+			continue;
+#endif // CLIENT_DLL
+
+		if ( bestWeapon )
+		{
+			if ( weapon->GetSlot() < bestWeapon->GetSlot() )
+			{
+				bestWeapon = weapon;
+			}
+			else if ( weapon->GetSlot() == bestWeapon->GetSlot() && weapon->GetPosition() < bestWeapon->GetPosition() )
+			{
+				bestWeapon = weapon;
+			}
+		}
+		else
+		{
+			bestWeapon = weapon;
+		}
+	}
+
+	return bestWeapon;
+}
+
+float CCSGameRules::GetMapRemainingTime()
+{
+#ifdef GAME_DLL
+	if ( nextlevel.GetString() && *nextlevel.GetString() )
+	{
+		return 0;
+	}
+#endif
+
+	// if timelimit is disabled, return -1
+	if ( mp_timelimit.GetInt() <= 0 )
+		return -1;
+
+	// timelimit is in minutes
+	float flTimeLeft =  ( m_flGameStartTime + mp_timelimit.GetInt() * 60 ) - gpGlobals->curtime;
+
+	// never return a negative value
+	if ( flTimeLeft < 0 )
+		flTimeLeft = 0;
+
+	return flTimeLeft;
+}
+
+float CCSGameRules::GetMapElapsedTime( void )
+{
+	return gpGlobals->curtime;
+}
+
+float CCSGameRules::GetRoundRemainingTime()
+{
+	return (float) (m_fRoundStartTime + m_iRoundTime) - gpGlobals->curtime; 
+}
+
+float CCSGameRules::GetRoundStartTime()
+{
+	return m_fRoundStartTime;
+}
+
+
+float CCSGameRules::GetRoundElapsedTime()
+{
+	return gpGlobals->curtime - m_fRoundStartTime;
+}
+
+
+bool CCSGameRules::ShouldCollide( int collisionGroup0, int collisionGroup1 )
+{
+	if ( collisionGroup0 > collisionGroup1 )
+	{
+		// swap so that lowest is always first
+		::V_swap(collisionGroup0,collisionGroup1);
+	}
+	
+	//Don't stand on COLLISION_GROUP_WEAPONs
+	if( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT &&
+		collisionGroup1 == COLLISION_GROUP_WEAPON )
+	{
+		return false;
+	}
+
+	// TODO: make a CS-SPECIFIC COLLISION GROUP FOR PHYSICS PROPS THAT USE THIS COLLISION BEHAVIOR.
+
+	
+	if ( (collisionGroup0 == COLLISION_GROUP_PLAYER || collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT) &&
+		collisionGroup1 == COLLISION_GROUP_PUSHAWAY )
+	{
+		return false;
+	}
+
+	if ( collisionGroup0 == COLLISION_GROUP_DEBRIS && collisionGroup1 == COLLISION_GROUP_PUSHAWAY )
+	{
+		// let debris and multiplayer objects collide
+		return true;
+	}
+
+	return BaseClass::ShouldCollide( collisionGroup0, collisionGroup1 ); 
+}
+
+
+bool CCSGameRules::IsFreezePeriod()
+{
+	return m_bFreezePeriod;
+}
+
+
+bool CCSGameRules::IsVIPMap() const
+{
+	//MIKETODO: VIP mode
+	return false;
+}
+
+
+bool CCSGameRules::IsBombDefuseMap() const
+{
+	return m_bMapHasBombTarget;
+}
+
+bool CCSGameRules::IsHostageRescueMap() const
+{
+	return m_bMapHasRescueZone;
+}
+
+bool CCSGameRules::IsLogoMap() const
+{
+	return m_bLogoMap;
+}
+
+float CCSGameRules::GetBuyTimeLength() const
+{
+	return ( mp_buytime.GetFloat() * 60 );
+}
+
+bool CCSGameRules::IsBuyTimeElapsed()
+{
+	return ( GetRoundElapsedTime() > GetBuyTimeLength() );
+}
+
+int CCSGameRules::DefaultFOV()
+{
+	return 90;
+}
+
+const CViewVectors* CCSGameRules::GetViewVectors() const
+{
+	return &g_CSViewVectors;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Init CS ammo definitions
+//-----------------------------------------------------------------------------
+
+// shared ammo definition
+// JAY: Trying to make a more physical bullet response
+#define BULLET_MASS_GRAINS_TO_LB(grains)	(0.002285*(grains)/16.0f)
+#define BULLET_MASS_GRAINS_TO_KG(grains)	lbs2kg(BULLET_MASS_GRAINS_TO_LB(grains))
+
+// exaggerate all of the forces, but use real numbers to keep them consistent
+#define BULLET_IMPULSE_EXAGGERATION			1	
+
+// convert a velocity in ft/sec and a mass in grains to an impulse in kg in/s
+#define BULLET_IMPULSE(grains, ftpersec)	((ftpersec)*12*BULLET_MASS_GRAINS_TO_KG(grains)*BULLET_IMPULSE_EXAGGERATION)
+
+
+static CCSAmmoDef ammoDef;
+CCSAmmoDef* GetCSAmmoDef()
+{
+	GetAmmoDef(); // to initialize the ammo info
+	return &ammoDef;
+}
+
+CAmmoDef* GetAmmoDef()
+{
+	static bool bInitted = false;
+
+	if ( !bInitted )
+	{
+		bInitted = true;
+		
+		ammoDef.AddAmmoType( BULLET_PLAYER_50AE,		DMG_BULLET, TRACER_LINE, 0, 0, "ammo_50AE_max",		2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_762MM,		DMG_BULLET, TRACER_LINE, 0, 0, "ammo_762mm_max",	2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_556MM,		DMG_BULLET, TRACER_LINE, 0, 0, "ammo_556mm_max",	2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_556MM_BOX,	DMG_BULLET, TRACER_LINE, 0, 0, "ammo_556mm_box_max",2400 * BULLET_IMPULSE_EXAGGERATION, 0, 10, 14 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_338MAG,		DMG_BULLET, TRACER_LINE, 0, 0, "ammo_338mag_max",	2800 * BULLET_IMPULSE_EXAGGERATION, 0, 12, 16 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_9MM,			DMG_BULLET, TRACER_LINE, 0, 0, "ammo_9mm_max",		2000 * BULLET_IMPULSE_EXAGGERATION, 0, 5, 10 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_BUCKSHOT,	DMG_BULLET, TRACER_LINE, 0, 0, "ammo_buckshot_max", 600 * BULLET_IMPULSE_EXAGGERATION,  0, 3, 6 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_45ACP,		DMG_BULLET, TRACER_LINE, 0, 0, "ammo_45acp_max",	2100 * BULLET_IMPULSE_EXAGGERATION, 0, 6, 10 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_357SIG,		DMG_BULLET, TRACER_LINE, 0, 0, "ammo_357sig_max",	2000 * BULLET_IMPULSE_EXAGGERATION, 0, 4, 8 );
+		ammoDef.AddAmmoType( BULLET_PLAYER_57MM,		DMG_BULLET, TRACER_LINE, 0, 0, "ammo_57mm_max",		2000 * BULLET_IMPULSE_EXAGGERATION, 0, 4, 8 );
+		ammoDef.AddAmmoType( AMMO_TYPE_HEGRENADE,		DMG_BLAST,	TRACER_LINE, 0, 0, "ammo_hegrenade_max", 1, 0 );
+		ammoDef.AddAmmoType( AMMO_TYPE_FLASHBANG,		0,			TRACER_LINE, 0,	0, "ammo_flashbang_max", 1, 0 );
+		ammoDef.AddAmmoType( AMMO_TYPE_SMOKEGRENADE,	0,			TRACER_LINE, 0, 0, "ammo_smokegrenade_max", 1, 0 );
+
+		//Adrian: I set all the prices to 0 just so the rest of the buy code works
+		//This should be revisited.
+		ammoDef.AddAmmoCost( BULLET_PLAYER_50AE, 0, 7 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_762MM, 0, 30 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_556MM, 0, 30 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_556MM_BOX, 0, 30 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_338MAG, 0, 10 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_9MM, 0, 30 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_BUCKSHOT, 0, 8 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_45ACP, 0, 25 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_357SIG, 0, 13 );
+		ammoDef.AddAmmoCost( BULLET_PLAYER_57MM, 0, 50 );
+	}
+
+	return &ammoDef;
+}
+
+#ifndef CLIENT_DLL
+const char *CCSGameRules::GetChatPrefix( bool bTeamOnly, CBasePlayer *pPlayer )
+{
+	const char *pszPrefix = NULL;
+
+	if ( !pPlayer )  // dedicated server output
+	{
+		pszPrefix = "";
+	}
+	else
+	{
+		// team only
+		if ( bTeamOnly == TRUE )
+		{
+			if ( pPlayer->GetTeamNumber() == TEAM_CT )
+			{
+				if ( pPlayer->m_lifeState == LIFE_ALIVE )
+				{
+					pszPrefix = "(Counter-Terrorist)";
+				}
+				else 
+				{
+					pszPrefix = "*DEAD*(Counter-Terrorist)";
+				}
+			}
+			else if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
+			{
+				if ( pPlayer->m_lifeState == LIFE_ALIVE )
+				{
+					pszPrefix = "(Terrorist)";
+				}
+				else
+				{
+					pszPrefix = "*DEAD*(Terrorist)";
+				}
+			}
+			else if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
+			{
+				pszPrefix = "(Spectator)";
+			}
+		}
+		// everyone
+		else
+		{
+			if ( pPlayer->m_lifeState == LIFE_ALIVE )
+			{
+				pszPrefix = "";
+			}
+			else
+			{
+				if ( pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
+				{
+					pszPrefix = "*DEAD*";	
+				}
+				else
+				{
+					pszPrefix = "*SPEC*";
+				}
+			}
+		}
+	}
+
+	return pszPrefix;
+}
+
+const char *CCSGameRules::GetChatLocation( bool bTeamOnly, CBasePlayer *pPlayer )
+{
+	if ( !pPlayer )  // dedicated server output
+	{
+		return NULL;
+	}
+
+	// only teammates see locations
+	if ( !bTeamOnly )
+		return NULL;
+
+	// only living players have locations
+	if ( pPlayer->GetTeamNumber() != TEAM_CT && pPlayer->GetTeamNumber() != TEAM_TERRORIST )
+		return NULL;
+
+	if ( !pPlayer->IsAlive() )
+		return NULL;
+
+	return pPlayer->GetLastKnownPlaceName();
+}
+
+const char *CCSGameRules::GetChatFormat( bool bTeamOnly, CBasePlayer *pPlayer )
+{
+	if ( !pPlayer )  // dedicated server output
+	{
+		return NULL;
+	}
+
+	const char *pszFormat = NULL;
+
+	// team only
+	if ( bTeamOnly == TRUE )
+	{
+		if ( pPlayer->GetTeamNumber() == TEAM_CT )
+		{
+			if ( pPlayer->m_lifeState == LIFE_ALIVE )
+			{
+				const char *chatLocation = GetChatLocation( bTeamOnly, pPlayer );
+				if ( chatLocation && *chatLocation )
+				{
+					pszFormat = "Cstrike_Chat_CT_Loc";
+				}
+				else
+				{
+					pszFormat = "Cstrike_Chat_CT";
+				}
+			}
+			else 
+			{
+				pszFormat = "Cstrike_Chat_CT_Dead";
+			}
+		}
+		else if ( pPlayer->GetTeamNumber() == TEAM_TERRORIST )
+		{
+			if ( pPlayer->m_lifeState == LIFE_ALIVE )
+			{
+				const char *chatLocation = GetChatLocation( bTeamOnly, pPlayer );
+				if ( chatLocation && *chatLocation )
+				{
+					pszFormat = "Cstrike_Chat_T_Loc";
+				}
+				else
+				{
+					pszFormat = "Cstrike_Chat_T";
+				}
+			}
+			else
+			{
+				pszFormat = "Cstrike_Chat_T_Dead";
+			}
+		}
+		else if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
+		{
+			pszFormat = "Cstrike_Chat_Spec";
+		}
+	}
+	// everyone
+	else
+	{
+		if ( pPlayer->m_lifeState == LIFE_ALIVE )
+		{
+			pszFormat = "Cstrike_Chat_All";
+		}
+		else
+		{
+			if ( pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
+			{
+				pszFormat = "Cstrike_Chat_AllDead";	
+			}
+			else
+			{
+				pszFormat = "Cstrike_Chat_AllSpec";
+			}
+		}
+	}
+
+	return pszFormat;
+}
+
+void CCSGameRules::ClientSettingsChanged( CBasePlayer *pPlayer )
+{
+	const char *pszNewName = engine->GetClientConVarValue( pPlayer->entindex(), "name" );
+	const char *pszOldName = pPlayer->GetPlayerName();
+	CCSPlayer *pCSPlayer = (CCSPlayer*)pPlayer;		
+	if ( pszOldName[0] != 0 && Q_strncmp( pszOldName, pszNewName, MAX_PLAYER_NAME_LENGTH-1 ) )		
+	{
+		pCSPlayer->ChangeName( pszNewName );		
+	}
+
+	pCSPlayer->m_bShowHints = true;
+	if ( pCSPlayer->IsNetClient() )
+	{
+		const char *pShowHints = engine->GetClientConVarValue( engine->IndexOfEdict( pCSPlayer->edict() ), "cl_autohelp" );
+		if ( pShowHints && atoi( pShowHints ) <= 0 )
+		{
+			pCSPlayer->m_bShowHints = false;
+		}
+	}
+}
+
+bool CCSGameRules::FAllowNPCs( void )
+{
+	return false;
+}
+
+bool CCSGameRules::IsFriendlyFireOn( void )
+{
+	return friendlyfire.GetBool();
+}
+
+
+CON_COMMAND( map_showspawnpoints, "Shows player spawn points (red=invalid)" )
+{
+	CSGameRules()->ShowSpawnPoints();
+}
+
+void DrawSphere( const Vector& pos, float radius, int r, int g, int b, float lifetime )
+{
+	Vector edge, lastEdge;
+	NDebugOverlay::Line( pos, pos + Vector( 0, 0, 50 ), r, g, b, true, lifetime );
+
+	lastEdge = Vector( radius + pos.x, pos.y, pos.z );
+	float angle;
+	for( angle=0.0f; angle <= 360.0f; angle += 22.5f )
+	{
+		edge.x = radius * BotCOS( angle ) + pos.x;
+		edge.y = pos.y;
+		edge.z = radius * BotSIN( angle ) + pos.z;
+
+		NDebugOverlay::Line( edge, lastEdge, r, g, b, true, lifetime );
+
+		lastEdge = edge;
+	}
+
+	lastEdge = Vector( pos.x, radius + pos.y, pos.z );
+	for( angle=0.0f; angle <= 360.0f; angle += 22.5f )
+	{
+		edge.x = pos.x;
+		edge.y = radius * BotCOS( angle ) + pos.y;
+		edge.z = radius * BotSIN( angle ) + pos.z;
+
+		NDebugOverlay::Line( edge, lastEdge, r, g, b, true, lifetime );
+
+		lastEdge = edge;
+	}
+
+	lastEdge = Vector( pos.x, radius + pos.y, pos.z );
+	for( angle=0.0f; angle <= 360.0f; angle += 22.5f )
+	{
+		edge.x = radius * BotCOS( angle ) + pos.x;
+		edge.y = radius * BotSIN( angle ) + pos.y;
+		edge.z = pos.z;
+
+		NDebugOverlay::Line( edge, lastEdge, r, g, b, true, lifetime );
+
+		lastEdge = edge;
+	}
+}
+
+CON_COMMAND_F( map_showbombradius, "Shows bomb radius from the center of each bomb site and planted bomb.", FCVAR_CHEAT )
+{
+	float flBombDamage = 500.0f;
+	if ( g_pMapInfo )
+		flBombDamage = g_pMapInfo->m_flBombRadius;
+	float flBombRadius = flBombDamage * 3.5f;
+	Msg( "Bomb Damage is %.0f, Radius is %.0f\n", flBombDamage, flBombRadius );
+
+	CBaseEntity* ent = NULL;
+	while ( ( ent = gEntList.FindEntityByClassname( ent, "func_bomb_target" ) ) != NULL )
+	{
+		const Vector &pos = ent->WorldSpaceCenter();
+		DrawSphere( pos, flBombRadius, 255, 255, 0, 10 );
+	}
+
+	ent = NULL;
+	while ( ( ent = gEntList.FindEntityByClassname( ent, "planted_c4" ) ) != NULL )
+	{
+		const Vector &pos = ent->WorldSpaceCenter();
+		DrawSphere( pos, flBombRadius, 255, 0, 0, 10 );
+	}
+}
+
+CON_COMMAND_F( map_setbombradius, "Sets the bomb radius for the map.", FCVAR_CHEAT )
+{
+	if ( args.ArgC() != 2 )
+		return;
+
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	if ( !g_pMapInfo )
+		CBaseEntity::Create( "info_map_parameters", vec3_origin, vec3_angle );
+
+	if ( !g_pMapInfo )
+		return;
+
+	g_pMapInfo->m_flBombRadius = atof( args[1] );
+	map_showbombradius( args );
+}
+
+void CreateBlackMarketString( void )
+{
+	g_StringTableBlackMarket = networkstringtable->CreateStringTable( "BlackMarketTable" , 1 );
+}
+
+int CCSGameRules::GetStartMoney( void )
+{
+	if ( IsBlackMarket() )
+	{
+		return atoi( mp_startmoney.GetDefault() );
+	}
+
+	return mp_startmoney.GetInt();
+}
+
+
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] Set up anything for all players that changes based on new players spawning mid-game
+//				Find and return fun fact data
+//=============================================================================
+ 
+//-----------------------------------------------------------------------------
+// Purpose: Called when a player joins the game after it's started yet can still spawn in
+//-----------------------------------------------------------------------------
+void CCSGameRules::SpawningLatePlayer( CCSPlayer* pLatePlayer )
+{
+	//Reset the round kills number of enemies for the opposite team
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CCSPlayer *pPlayer = (CCSPlayer*) UTIL_PlayerByIndex( i );
+		if(pPlayer)
+		{
+			if(pPlayer->GetTeamNumber() == pLatePlayer->GetTeamNumber())
+			{
+				continue;
+			}
+			pPlayer->m_NumEnemiesAtRoundStart++;
+		}
+	}
+}
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+//=============================================================================
+// HPE_BEGIN:
+// [pfreese] Test for "pistol" round, defined as the default starting round
+// when players cannot purchase anything primary weapons
+//=============================================================================
+
+bool CCSGameRules::IsPistolRound()
+{
+	return m_iTotalRoundsPlayed == 0 && GetStartMoney() <= 800;
+}
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+//=============================================================================
+// HPE_BEGIN:
+// [tj] So game rules can react to damage taken
+// [menglish]
+//=============================================================================
+
+void CCSGameRules::PlayerTookDamage(CCSPlayer* player, const CTakeDamageInfo &damageInfo)
+{
+	CBaseEntity *pInflictor = damageInfo.GetInflictor();
+	CBaseEntity *pAttacker = damageInfo.GetAttacker();
+	CCSPlayer *pCSScorer = (CCSPlayer *)(GetDeathScorer( pAttacker, pInflictor ));
+
+	if ( player && pCSScorer )
+	{
+		if (player->GetTeamNumber() == TEAM_CT)
+		{
+			m_bNoCTsDamaged = false;
+		}
+
+		if (player->GetTeamNumber() == TEAM_TERRORIST)
+		{
+			m_bNoTerroristsDamaged = false;
+		}
+		// set the first blood if this is the first and the victim is on a different team then the player
+		if ( m_pFirstBlood == NULL && pCSScorer != player && pCSScorer->GetTeamNumber() != player ->GetTeamNumber() )
+		{
+			m_pFirstBlood = pCSScorer;
+			m_firstBloodTime = gpGlobals->curtime - m_fRoundStartTime;
+		}
+	}
+}
+
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+#endif
+
+bool CCSGameRules::IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer )
+{
+#ifdef GAME_DLL
+	if( pPlayer )
+	{
+		int iPlayerTeam = pPlayer->GetTeamNumber();
+		if( ( iPlayerTeam == TEAM_CT ) || ( iPlayerTeam == TEAM_TERRORIST ) )
+			return false;
+	}
+#else
+	int iLocalPlayerTeam = GetLocalPlayerTeam();
+	if( ( iLocalPlayerTeam == TEAM_CT ) || ( iLocalPlayerTeam == TEAM_TERRORIST ) )
+			return false;
+#endif
+
+	return true;
+}
+
+#ifdef GAME_DLL
+
+struct convar_tags_t
+{
+	const char *pszConVar;
+	const char *pszTag;
+};
+
+// The list of convars that automatically turn on tags when they're changed.
+// Convars in this list need to have the FCVAR_NOTIFY flag set on them, so the
+// tags are recalculated and uploaded to the master server when the convar is changed.
+convar_tags_t convars_to_check_for_tags[] =
+{
+	{ "mp_friendlyfire", "friendlyfire" },
+	{ "bot_quota", "bots" },
+	{ "sv_nostats", "nostats" },
+	{ "mp_startmoney", "startmoney" },
+	{ "sv_allowminmodels", "nominmodels" },
+	{ "sv_enablebunnyhopping", "bunnyhopping" },
+	{ "sv_competitive_minspec", "compspec" },
+	{ "mp_holiday_nogifts", "nogifts" },
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Engine asks for the list of convars that should tag the server
+//-----------------------------------------------------------------------------
+void CCSGameRules::GetTaggedConVarList( KeyValues *pCvarTagList )
+{
+	BaseClass::GetTaggedConVarList( pCvarTagList );
+
+	for ( int i = 0; i < ARRAYSIZE(convars_to_check_for_tags); i++ )
+	{
+		KeyValues *pKV = new KeyValues( "tag" );
+		pKV->SetString( "convar", convars_to_check_for_tags[i].pszConVar );
+		pKV->SetString( "tag", convars_to_check_for_tags[i].pszTag );
+
+		pCvarTagList->AddSubKey( pKV );
+	}
+}
+
+#endif
+
+
+int CCSGameRules::GetBlackMarketPriceForWeapon( int iWeaponID )
+{
+	if ( m_pPrices == NULL )
+	{
+		GetBlackMarketPriceList();
+	}
+
+	if ( m_pPrices )
+		return m_pPrices->iCurrentPrice[iWeaponID];
+	else
+		return 0;
+}
+
+int CCSGameRules::GetBlackMarketPreviousPriceForWeapon( int iWeaponID )
+{
+	if ( m_pPrices == NULL )
+	{
+		GetBlackMarketPriceList();
+	}
+
+	if ( m_pPrices )
+		return m_pPrices->iPreviousPrice[iWeaponID];
+	else
+		return 0;
+}
+
+const weeklyprice_t *CCSGameRules::GetBlackMarketPriceList( void )
+{
+	if ( m_StringTableBlackMarket == NULL )
+	{
+		m_StringTableBlackMarket = networkstringtable->FindTable( CS_GAMERULES_BLACKMARKET_TABLE_NAME);
+	}
+
+	if ( m_pPrices == NULL )
+	{
+		int iSize = 0;
+		INetworkStringTable *pTable = m_StringTableBlackMarket;
+		if ( pTable && pTable->GetNumStrings() > 0 )
+		{
+			m_pPrices = (const weeklyprice_t *)pTable->GetStringUserData( 0, &iSize );
+		}
+	}
+
+	if ( m_pPrices )
+	{
+		PrepareEquipmentInfo();
+	}
+	
+	return m_pPrices;
+}
+
+void CCSGameRules::SetBlackMarketPrices( bool bSetDefaults )
+{
+	for ( int i = 1; i < WEAPON_MAX; i++ )
+	{
+		if ( i == WEAPON_SHIELDGUN )
+			continue;
+
+		CCSWeaponInfo *info = GetWeaponInfo( (CSWeaponID)i );
+
+		if ( info == NULL )
+			continue;
+
+		if ( bSetDefaults == false )
+		{
+			info->SetWeaponPrice( GetBlackMarketPriceForWeapon( i ) );
+			info->SetPreviousPrice( GetBlackMarketPreviousPriceForWeapon( i ) );
+		}
+		else
+		{
+			info->SetWeaponPrice( info->GetDefaultPrice() );
+		}
+	}
+}
+
+#ifdef CLIENT_DLL
+
+CCSGameRules::CCSGameRules()
+{
+	CSGameRules()->m_StringTableBlackMarket = NULL;
+	m_pPrices = NULL;
+	m_bBlackMarket = false;
+}
+
+void TestTable( void )
+{
+	CSGameRules()->m_StringTableBlackMarket = networkstringtable->FindTable( CS_GAMERULES_BLACKMARKET_TABLE_NAME);
+
+	if ( CSGameRules()->m_StringTableBlackMarket == NULL )
+		return;
+
+	int iIndex = CSGameRules()->m_StringTableBlackMarket->FindStringIndex( "blackmarket_prices" );
+	int iSize = 0;
+
+	const weeklyprice_t *pPrices = NULL;
+	
+	pPrices = (const weeklyprice_t *)(CSGameRules()->m_StringTableBlackMarket)->GetStringUserData( iIndex, &iSize );
+}
+
+#ifdef DEBUG
+ConCommand cs_testtable( "cs_testtable", TestTable );
+#endif
+
+//-----------------------------------------------------------------------------
+// Enforce certain values on the specified convar.
+//-----------------------------------------------------------------------------
+void EnforceCompetitiveCVar( const char *szCvarName, float fMinValue, float fMaxValue = FLT_MAX, int iArgs = 0, ... )
+{
+	// Doing this check first because OK values might be outside the min/max range
+	ConVarRef competitiveConvar(szCvarName);
+	float fValue = competitiveConvar.GetFloat();
+	va_list vl;
+	va_start(vl, iArgs);
+	for( int i=0; i< iArgs; ++i )
+	{
+		if( (int)fValue == (int)va_arg(vl,double) )
+			return;
+	}
+	va_end(vl);
+
+	if( fValue < fMinValue || fValue > fMaxValue )
+	{
+		float fNewValue = MAX( MIN( fValue, fMaxValue ), fMinValue );
+		competitiveConvar.SetValue( fNewValue );
+		DevMsg( "Convar %s enforced by server (see sv_competitive_minspec.) Set to %2f.\n", szCvarName, fNewValue );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// An interface used by ENABLE_COMPETITIVE_CONVAR macro that lets the classes
+// defined in the macro to be stored and acted on.
+//-----------------------------------------------------------------------------
+class ICompetitiveConvar
+{
+public:
+	// It is a best practice to always have a virtual destructor in an interface
+	// class. Otherwise if the derived classes have destructors they will not be
+	// called.
+	virtual ~ICompetitiveConvar() {}
+	virtual void BackupConvar() = 0;
+	virtual void EnforceRestrictions() = 0;
+	virtual void RestoreOriginalValue() = 0;
+	virtual void InstallChangeCallback() = 0;
+};
+
+//-----------------------------------------------------------------------------
+// A manager for all enforced competitive convars.
+//-----------------------------------------------------------------------------
+class CCompetitiveCvarManager : public CAutoGameSystem
+{
+public:
+	typedef CUtlVector<ICompetitiveConvar*> CompetitiveConvarList_t;
+	static void AddConvarToList( ICompetitiveConvar* pCVar )
+	{
+		GetConvarList()->AddToTail( pCVar );
+	}
+
+	static void BackupAllConvars()
+	{
+		FOR_EACH_VEC( *GetConvarList(), i )
+		{
+			(*GetConvarList())[i]->BackupConvar();
+		}
+	}
+
+	static void EnforceRestrictionsOnAllConvars()
+	{
+		FOR_EACH_VEC( *GetConvarList(), i )
+		{
+			(*GetConvarList())[i]->EnforceRestrictions();
+		}
+	}
+
+	static void RestoreAllOriginalValues()
+	{
+		FOR_EACH_VEC( *GetConvarList(), i )
+		{
+			(*GetConvarList())[i]->RestoreOriginalValue();
+		}
+	}
+
+	static CompetitiveConvarList_t* GetConvarList()
+	{
+		if( !s_pCompetitiveConvars )
+		{
+			s_pCompetitiveConvars = new CompetitiveConvarList_t();
+		}
+		return s_pCompetitiveConvars;
+	}
+
+	static KeyValues* GetConVarBackupKV()
+	{
+		if( !s_pConVarBackups )
+		{
+			s_pConVarBackups = new KeyValues("ConVarBackups");
+		}
+		return s_pConVarBackups;
+	}
+
+	virtual bool Init() 
+	{ 
+		FOR_EACH_VEC( *GetConvarList(), i )
+		{
+			(*GetConvarList())[i]->InstallChangeCallback();
+		}
+		return true;
+	}
+
+	virtual void Shutdown()
+	{
+		FOR_EACH_VEC( *GetConvarList(), i )
+		{
+			delete (*GetConvarList())[i];
+		}
+		delete s_pCompetitiveConvars; 
+		s_pCompetitiveConvars = null;
+		s_pConVarBackups->deleteThis(); 
+		s_pConVarBackups = null;
+	}
+private:
+	static CompetitiveConvarList_t* s_pCompetitiveConvars;
+	static KeyValues* s_pConVarBackups;
+};
+static CCompetitiveCvarManager *s_pCompetitiveCvarManager = new CCompetitiveCvarManager();
+CCompetitiveCvarManager::CompetitiveConvarList_t* CCompetitiveCvarManager::s_pCompetitiveConvars = null;
+KeyValues* CCompetitiveCvarManager::s_pConVarBackups = null;
+
+//-----------------------------------------------------------------------------
+// Macro to define restrictions on convars with "sv_competitive_minspec 1"
+// Usage: ENABLE_COMPETITIVE_CONVAR( convarName, minValue, maxValue, optionalValues, opVal1, opVal2, ...
+//-----------------------------------------------------------------------------
+#define ENABLE_COMPETITIVE_CONVAR( convarName, ... ) \
+class CCompetitiveMinspecConvar##convarName : public ICompetitiveConvar { \
+public: \
+	CCompetitiveMinspecConvar##convarName(){ CCompetitiveCvarManager::AddConvarToList(this);} \
+	static void on_changed_##convarName( IConVar *var, const char *pOldValue, float flOldValue ){ \
+		if( sv_competitive_minspec.GetBool() ) { \
+			EnforceCompetitiveCVar( #convarName , __VA_ARGS__  ); }\
+		else {\
+			CCompetitiveCvarManager::GetConVarBackupKV()->SetFloat( #convarName, ConVarRef( #convarName ).GetFloat() ); } } \
+	virtual void BackupConvar() { CCompetitiveCvarManager::GetConVarBackupKV()->SetFloat( #convarName, ConVarRef( #convarName ).GetFloat() ); } \
+	virtual void EnforceRestrictions() { EnforceCompetitiveCVar( #convarName , __VA_ARGS__  ); } \
+	virtual void RestoreOriginalValue() { ConVarRef(#convarName).SetValue(CCompetitiveCvarManager::GetConVarBackupKV()->GetFloat( #convarName ) ); } \
+	virtual void InstallChangeCallback() { static_cast<ConVar*>(ConVarRef( #convarName ).GetLinkedConVar())->InstallChangeCallback( CCompetitiveMinspecConvar##convarName::on_changed_##convarName); } \
+}; \
+static CCompetitiveMinspecConvar##convarName *s_pCompetitiveConvar##convarName = new CCompetitiveMinspecConvar##convarName();
+
+//-----------------------------------------------------------------------------
+// Callback function for sv_competitive_minspec convar value change.
+//-----------------------------------------------------------------------------
+void sv_competitive_minspec_changed_f( IConVar *var, const char *pOldValue, float flOldValue )
+{
+	ConVar *pCvar = static_cast<ConVar*>(var);
+
+	if( pCvar->GetBool() == true && (bool)flOldValue == false )
+	{
+		// Backup the values of each cvar and enforce new ones
+		CCompetitiveCvarManager::BackupAllConvars();
+		CCompetitiveCvarManager::EnforceRestrictionsOnAllConvars();
+	}
+	else if( pCvar->GetBool() == false && (bool)flOldValue == true )
+	{
+		// If sv_competitive_minspec is disabled, restore old client values
+		CCompetitiveCvarManager::RestoreAllOriginalValues();
+	}
+}
+#endif
+
+static ConVar sv_competitive_minspec( "sv_competitive_minspec",
+									 "0",
+									 FCVAR_REPLICATED | FCVAR_NOTIFY,
+									 "Enable to force certain client convars to minimum/maximum values to help prevent competitive advantages:\n \
+	r_drawdetailprops = 1\n \
+	r_staticprop_lod = minimum -1 maximum 3\n \
+	fps_max minimum 59 (0 works too)\n \
+	cl_detailfade minimum 400\n \
+	cl_detaildist minimum 1200\n \
+	cl_interp_ratio = minimum 1 maximum 2\n \
+	cl_interp = minimum 0 maximum 0.031\n \
+	"
+#ifdef CLIENT_DLL
+									 ,sv_competitive_minspec_changed_f
+#endif
+									 );
+
+#ifdef CLIENT_DLL
+
+ENABLE_COMPETITIVE_CONVAR( r_drawdetailprops, true, true ); // force r_drawdetailprops on
+ENABLE_COMPETITIVE_CONVAR( r_staticprop_lod, -1, 3 );		// force r_staticprop_lod from -1 to 3
+ENABLE_COMPETITIVE_CONVAR( fps_max, 59, FLT_MAX, 1, 0 );	// force fps_max above 59. One additional value (0) works
+ENABLE_COMPETITIVE_CONVAR( cl_detailfade, 400 );			// force cl_detailfade above 400.
+ENABLE_COMPETITIVE_CONVAR( cl_detaildist, 1200 );			// force cl_detaildist above 1200.
+ENABLE_COMPETITIVE_CONVAR( cl_interp_ratio, 1, 2 );			// force cl_interp_ratio from 1 to 2
+ENABLE_COMPETITIVE_CONVAR( cl_interp, 0, 0.031 );		// force cl_interp from 0.0152 to 0.031
+
+// Stubs for replay client code
+const char *GetMapDisplayName( const char *pMapName )
+{
+	return pMapName;
+}
+
+bool IsTakingAFreezecamScreenshot()
+{
+	return false;
+}
+
+#endif
diff --git a/game/shared/cstrike/cs_gamerules.h b/game/shared/cstrike/cs_gamerules.h
new file mode 100644
index 00000000..02bda1b4
--- /dev/null
+++ b/game/shared/cstrike/cs_gamerules.h
@@ -0,0 +1,537 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The TF Game rules object
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CS_GAMERULES_H
+#define CS_GAMERULES_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "teamplay_gamerules.h"
+#include "convar.h"
+#include "cs_shareddefs.h"
+#include "gamevars_shared.h"
+
+#ifdef CLIENT_DLL
+	#include "c_cs_player.h"
+	#include "networkstringtable_clientdll.h"
+#else
+	#include "cs_player.h"
+	#include "funfactmgr_cs.h"
+#endif
+
+#include "cs_urlretrieveprices.h"
+
+//extern ConVar mp_dynamicpricing;
+
+#define CS_GAMERULES_BLACKMARKET_TABLE_NAME "BlackMarketTable"
+
+#define	WINNER_NONE		0
+#define WINNER_DRAW		1
+#define WINNER_TER		TEAM_TERRORIST
+#define WINNER_CT		TEAM_CT
+
+//=============================================================================
+// HPE_BEGIN:
+// [tj] Forward declaration so we can track bot suicides in the game rules.
+//=============================================================================
+
+class CCSBot;
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+extern ConVar mp_startmoney;
+extern ConVar mp_tkpunish;
+extern ConVar mp_c4timer;
+extern ConVar mp_buytime;
+extern ConVar mp_freezetime;
+extern ConVar mp_playerid;
+
+#ifndef CLIENT_DLL
+	extern ConVar mp_autoteambalance;
+#endif // !CLIENT_DLL
+
+
+#ifdef CLIENT_DLL
+	#define CCSGameRules C_CSGameRules
+	#define CCSGameRulesProxy C_CSGameRulesProxy
+#endif
+
+#ifndef CLIENT_DLL
+	struct playerscore_t
+	{
+		int iPlayerIndex;
+		int iScore;
+	};
+#endif
+
+
+class CCSGameRulesProxy : public CGameRulesProxy
+{
+public:
+	DECLARE_CLASS( CCSGameRulesProxy, CGameRulesProxy );
+	DECLARE_NETWORKCLASS();
+};
+
+
+class CCSGameRules : public CTeamplayRules
+{
+public:
+	DECLARE_CLASS( CCSGameRules, CTeamplayRules );
+
+	// Stuff that is shared between client and server.
+	bool IsFreezePeriod();
+
+	virtual bool ShouldCollide( int collisionGroup0, int collisionGroup1 );
+
+	float GetMapRemainingTime();	// time till end of map, -1 if timelimit is disabled
+	float GetMapElapsedTime();	// How much time has elapsed since the map started.
+	float GetRoundRemainingTime();	// time till end of round
+	float GetRoundStartTime();		// When this round started.
+	float GetRoundElapsedTime();	// How much time has elapsed since the round started.
+	float GetBuyTimeLength() const;
+	int GetRoundLength() const { return m_iRoundTime; }
+	int   SelectDefaultTeam( bool ignoreBots = false );
+	int   GetHumanTeam();			// TEAM_UNASSIGNED if no restrictions
+
+	bool IsVIPMap() const;
+	bool IsBombDefuseMap() const;
+	bool IsHostageRescueMap() const;
+	bool IsIntermission() const;
+	bool IsLogoMap() const;
+	bool IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer );
+
+	bool IsBuyTimeElapsed();
+
+	virtual int	DefaultFOV();
+
+	// Get the view vectors for this mod.
+	virtual const CViewVectors* GetViewVectors() const;
+
+	void UploadGameStats( void );
+	int  GetStartMoney( void );
+
+	virtual bool IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer );
+
+private:
+
+	float GetExplosionDamageAdjustment(Vector & vecSrc, Vector & vecEnd, CBaseEntity *pEntityToIgnore); // returns multiplier between 0.0 and 1.0 that is the percentage of any damage done from vecSrc to vecEnd that actually makes it.
+	float GetAmountOfEntityVisible(Vector & src, CBaseEntity *player); // returns a value from 0 to 1 that is the percentage of player visible from src.
+
+	CNetworkVar( bool, m_bFreezePeriod );	 // TRUE at beginning of round, set to FALSE when the period expires
+	CNetworkVar( int, m_iRoundTime );		 // (From mp_roundtime) - How many seconds long this round is.
+	CNetworkVar( float, m_fRoundStartTime ); // time round has started
+	CNetworkVar( float, m_flGameStartTime );
+	CNetworkVar( int, m_iHostagesRemaining );
+	CNetworkVar( bool, m_bMapHasBombTarget );
+	CNetworkVar( bool, m_bMapHasRescueZone );
+	CNetworkVar( bool, m_bLogoMap );		 // If there's an info_player_logo entity, then it's a logo map.
+	CNetworkVar( bool, m_bBlackMarket );
+
+	bool		m_bDontUploadStats;
+
+public:
+
+	bool IsBlackMarket( void ) { return m_bBlackMarket; }
+	int GetNumHostagesRemaining( void ) { return m_iHostagesRemaining; }
+
+	virtual CBaseCombatWeapon *GetNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon );
+
+	virtual const unsigned char *GetEncryptionKey( void ) { return (unsigned char *)"d7NSuLq2"; } // both the client and server need this key
+
+#ifdef CLIENT_DLL
+
+	DECLARE_CLIENTCLASS_NOBASE(); // This makes datatables able to access our private vars.
+	CCSGameRules();
+
+#else
+
+	DECLARE_SERVERCLASS_NOBASE(); // This makes datatables able to access our private vars.
+
+	CCSGameRules();
+	virtual ~CCSGameRules();
+
+	void DumpTimers( void ) const;	// debugging to help track down a stuck server (rare?)
+
+	CBaseEntity *GetPlayerSpawnSpot( CBasePlayer *pPlayer );
+
+	static void EndRound();
+
+	virtual void PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+	virtual void Think();
+
+	// Called at the end of GameFrame (i.e. after all game logic has run this frame)
+	virtual void EndGameFrame( void );
+
+	// Called when game rules are destroyed by CWorld
+	virtual void LevelShutdown( void );
+
+	virtual bool ClientCommand( CBaseEntity *pEdict, const CCommand &args );
+	virtual void PlayerSpawn( CBasePlayer *pPlayer );
+			void ShowSpawnPoints();
+
+	virtual void ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Set up anything for all players that changes based on new players spawning mid-game
+	//				Find and return fun fact data
+	// [pfreese] Tracking of "pistol" round
+	//=============================================================================
+	virtual void SpawningLatePlayer(CCSPlayer* pLatePlayer);
+
+	bool IsPistolRound();
+
+	void HostageKilled() { m_hostageWasKilled = true; }
+	void HostageInjured() { m_hostageWasInjured = true; }
+
+	bool WasHostageKilled() { return m_hostageWasKilled; }
+	bool WasHostageInjured() { return m_hostageWasInjured; }
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [tj] So game rules can react to damage taken
+    //=============================================================================
+
+    void PlayerTookDamage(CCSPlayer* player, const CTakeDamageInfo &damageInfo);
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+
+	virtual bool PlayTextureSounds( void ) { return true; }
+	// Let the game rules specify if fall death should fade screen to black
+	virtual bool  FlPlayerFallDeathDoesScreenFade( CBasePlayer *pl ) { return FALSE; }
+
+	virtual void  RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, CBaseEntity *pEntityIgnore );
+	void RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, bool bIgnoreWorld );
+
+	virtual void UpdateClientData( CBasePlayer *pl );
+
+	// Death notices
+	virtual void		DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+
+	virtual void			InitDefaultAIRelationships( void );
+
+	virtual const char *GetGameDescription( void ) { return "Counter-Strike: Source"; }  // this is the game name that gets seen in the server browser
+	virtual const char *AIClassText(int classType);
+
+	virtual bool FShouldSwitchWeapon( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon );
+
+	virtual const char *SetDefaultPlayerTeam( CBasePlayer *pPlayer );
+
+	// Called before entities are created
+	virtual void LevelInitPreEntity();
+
+	// Called after the map has finished loading.
+	virtual void LevelInitPostEntity();
+
+	virtual float FlPlayerFallDamage( CBasePlayer *pPlayer );
+
+	virtual void ClientDisconnected( edict_t *pClient );
+
+	// Recreate all the map entities from the map data (preserving their indices),
+	// then remove everything else except the players.
+	// Also get rid of all world decals.
+	void CleanUpMap();
+
+	void CheckFreezePeriodExpired();
+	void CheckRoundTimeExpired();
+
+	// check if the scenario has been won/lost
+	// return true if the scenario is over, false if the scenario is still in progress
+	bool CheckWinConditions( void );
+
+	void TerminateRound( float tmDelay, int reason );
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] A place to check achievements that occur at the end of the round
+	//=============================================================================
+	void ProcessEndOfRoundAchievements(int iWinnerTeam, int iReason);
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+	void RestartRound( void );
+	void BalanceTeams( void );
+	void MoveHumansToHumanTeam( void );
+	bool TeamFull( int team_id );
+	bool TeamStacked( int newTeam_id, int curTeam_id  );
+	bool FPlayerCanRespawn( CBasePlayer *pPlayer );
+	void UpdateTeamScores();
+	void CheckMapConditions();
+	void MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(int team);
+
+	// Check various conditions to end the map.
+	bool CheckGameOver();
+	bool CheckMaxRounds();
+	bool CheckWinLimit();
+	bool CheckFragLimit();
+
+	void CheckLevelInitialized();
+	void CheckRestartRound();
+
+
+	// Checks if it still needs players to start a round, or if it has enough players to start rounds.
+	// Starts a round and returns true if there are enough players.
+	bool NeededPlayersCheck( bool &bNeededPlayers );
+
+	// Setup counts for m_iNumTerrorist, m_iNumCT, m_iNumSpawnableTerrorist, m_iNumSpawnableCT, etc.
+	void InitializePlayerCounts(
+		int &NumAliveTerrorist,
+		int &NumAliveCT,
+		int &NumDeadTerrorist,
+		int &NumDeadCT
+		);
+
+	// Check to see if the round is over for the various game types. Terminates the round
+	// and returns true if the round should end.
+	bool PrisonRoundEndCheck();
+	bool BombRoundEndCheck( bool bNeededPlayers );
+	bool HostageRescueRoundEndCheck( bool bNeededPlayers );
+
+	// Check to see if the teams exterminated each other. Ends the round and returns true if so.
+	bool TeamExterminationCheck(
+		int NumAliveTerrorist,
+		int NumAliveCT,
+		int NumDeadTerrorist,
+		int NumDeadCT,
+		bool bNeededPlayers
+		);
+
+	void ReadMultiplayCvars();
+	void SwapAllPlayers();
+
+	void BroadcastSound( const char *sound, int team = -1 );
+
+
+	// VIP FUNCTIONS
+	bool VIPRoundEndCheck( bool bNeededPlayers );
+	void PickNextVIP();
+
+
+	// BOMB MAP FUNCTIONS
+	void GiveC4();
+	bool IsThereABomber();
+	bool IsThereABomb();
+
+	// HOSTAGE MAP FUNCTIONS
+	void HostageTouched();
+
+
+	// Sets up g_pPlayerResource.
+	virtual void CreateStandardEntities();
+	virtual const char *GetChatPrefix( bool bTeamOnly, CBasePlayer *pPlayer );
+	virtual const char *GetChatLocation( bool bTeamOnly, CBasePlayer *pPlayer );
+	virtual const char *GetChatFormat( bool bTeamOnly, CBasePlayer *pPlayer );
+	void ClientSettingsChanged( CBasePlayer *pPlayer );
+
+	bool IsCareer( void ) const		{ return false; }		// returns true if this is a CZ "career" game
+
+	virtual bool FAllowNPCs( void );
+
+protected:
+	virtual void GoToIntermission( void );
+
+public:
+
+	bool IsFriendlyFireOn();
+
+	virtual void	SetAllowWeaponSwitch( bool allow );
+	virtual bool	GetAllowWeaponSwitch( void );
+
+	// VARIABLES FOR ALL TYPES OF MAPS
+	bool m_bLevelInitialized;
+	int m_iRoundWinStatus;		// 1 == CT's won last round, 2 == Terrorists did, 3 == Draw, no winner
+	int m_iTotalRoundsPlayed;
+	int m_iUnBalancedRounds;	// keeps track of the # of consecutive rounds that have gone by where one team outnumbers the other team by more than 2
+
+	// GAME TIMES
+	int m_iFreezeTime;		// (From mp_freezetime) - How many seconds long the intro round (when players are frozen) is.
+	float m_flRestartRoundTime;	// the global time when the round is supposed to end, if this is not 0
+
+	int m_iNumTerrorist;		// The number of terrorists on the team (this is generated at the end of a round)
+	int m_iNumCT;				// The number of CTs on the team (this is generated at the end of a round)
+	int m_iNumSpawnableTerrorist;
+	int m_iNumSpawnableCT;
+
+	bool m_bFirstConnected;
+	bool m_bCompleteReset;		// Set to TRUE to have the scores reset next time round restarts
+
+	int m_iAccountTerrorist;
+	int m_iAccountCT;
+
+	short m_iNumCTWins;
+	short m_iNumTerroristWins;
+
+	int m_iNumConsecutiveCTLoses;		//SupraFiend: the number of rounds the CTs have lost in a row.
+	int m_iNumConsecutiveTerroristLoses;//SupraFiend: the number of rounds the Terrorists have lost in a row.
+
+	int m_iSpawnPointCount_Terrorist;		// Number of Terrorist spawn points
+	int m_iSpawnPointCount_CT;				// Number of CT spawn points
+
+	bool m_bTCantBuy;			// Who can and can't buy.
+	bool m_bCTCantBuy;
+	bool m_bMapHasBuyZone;
+
+	int m_iLoserBonus;			// SupraFiend: the amount of money the losing team gets. This scales up as they lose more rounds in a row
+	float m_tmNextPeriodicThink;
+
+
+	// HOSTAGE RESCUE VARIABLES
+	int		m_iHostagesRescued;
+	int		m_iHostagesTouched;
+	float	m_flNextHostageAnnouncement;
+
+    //=============================================================================
+    // HPE_BEGIN
+    //=============================================================================
+
+    // [tj] Accessor for weapons donation ability
+    bool GetCanDonateWeapon() { return m_bCanDonateWeapons; }
+
+    // [tj] flawless and lossless round related flags
+    bool m_bNoTerroristsKilled;
+    bool m_bNoCTsKilled;
+    bool m_bNoTerroristsDamaged;
+    bool m_bNoCTsDamaged;
+
+    // [tj] Find out if dropped weapons count as donations
+    bool m_bCanDonateWeapons;
+
+	// [tj] Keep track of first kill
+	CHandle<CCSPlayer> m_pFirstKill;
+	float m_firstKillTime;
+
+	// [menglish] Keep track of first blood
+	CHandle<CCSPlayer> m_pFirstBlood;
+	float m_firstBloodTime;
+
+
+    // [dwenger] Rescue-related achievement values
+    CHandle<CCSPlayer> m_pLastRescuer;
+    int     m_iNumRescuers;
+
+	bool m_hostageWasInjured;
+	bool m_hostageWasKilled;
+
+	// [menglish] Fun Fact Manager
+	CCSFunFactMgr *m_pFunFactManager;
+
+	// [tj] To avoid rewriting the same piece of code, we can get all the information
+	//		we want from one call that fills in an array of structures.
+	struct TeamPlayerCounts
+	{
+		int totalPlayers;
+		int totalAlivePlayers;
+		int totalDeadPlayers; //sum of killedPlayers + suicidedPlayers + unenteredPlayers
+		int killedPlayers;
+		int suicidedPlayers;
+		int unenteredPlayers;
+	};
+
+	void GetPlayerCounts(TeamPlayerCounts teamCounts[TEAM_MAXCOUNT]);
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+
+	// PRISON ESCAPE VARIABLES
+	int		m_iHaveEscaped;
+	bool	m_bMapHasEscapeZone;
+	int		m_iNumEscapers;
+	int		m_iNumEscapeRounds;		// keeps track of the # of consecutive rounds of escape played.. Teams will be swapped after 8 rounds
+
+
+	// VIP VARIABLES
+	int		m_iMapHasVIPSafetyZone;	// 0 = uninitialized;   1 = has VIP safety zone;   2 = DOES not have VIP safetyzone
+	CHandle<CCSPlayer> m_pVIP;
+	int		m_iConsecutiveVIP;
+
+
+	// BOMB MAP VARIABLES
+	bool	m_bTargetBombed;	// whether or not the bomb has been bombed
+	bool	m_bBombDefused;	// whether or not the bomb has been defused
+	bool	m_bMapHasBombZone;
+	bool	m_bBombDropped;
+	bool	m_bBombPlanted;
+	EHANDLE m_pLastBombGuy;
+
+private:
+
+	// Don't allow switching weapons while gaining new technologies
+	bool			m_bAllowWeaponSwitch;
+
+public:
+
+
+
+	void AddPricesToTable( weeklyprice_t prices );
+	virtual void CreateCustomNetworkStringTables( void );
+
+#endif
+
+
+#ifdef GAME_DLL
+public:
+	virtual void	GetTaggedConVarList( KeyValues *pCvarTagList );
+#endif
+
+public:
+	const weeklyprice_t *GetBlackMarketPriceList( void );
+
+	int GetBlackMarketPriceForWeapon( int iWeaponID );
+	int GetBlackMarketPreviousPriceForWeapon( int iWeaponID );
+
+	void SetBlackMarketPrices( bool bSetDefaults );
+
+	// Black market
+	INetworkStringTable *m_StringTableBlackMarket;
+	const weeklyprice_t *m_pPrices;
+};
+
+//-----------------------------------------------------------------------------
+// Gets us at the team fortress game rules
+//-----------------------------------------------------------------------------
+
+inline CCSGameRules* CSGameRules()
+{
+	return static_cast<CCSGameRules*>(g_pGameRules);
+}
+
+#define IGNORE_SPECTATORS true
+int UTIL_HumansInGame( bool ignoreSpectators = false );
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Useful utility functions
+//-----------------------------------------------------------------------------
+#ifdef CLIENT_DLL
+
+#else
+
+	class CTFTeam;
+	CTFTeam *GetOpposingTeam( CTeam *pTeam );
+	bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround );
+
+#endif
+
+#endif // TF_GAMERULES_H
diff --git a/game/shared/cstrike/cs_gamestats_shared.cpp b/game/shared/cstrike/cs_gamestats_shared.cpp
new file mode 100644
index 00000000..cd250c8e
--- /dev/null
+++ b/game/shared/cstrike/cs_gamestats_shared.cpp
@@ -0,0 +1,410 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "fmtstr.h"
+#ifdef GAME_DLL
+#include "gamestats.h"
+#endif
+#include "cs_gamestats_shared.h"
+
+ConVar sv_noroundstats( "sv_noroundstats", "1", FCVAR_REPLICATED, "A temporary variable that can be used for disabling upload of round stats." );
+
+const MapName_MapStatId MapName_StatId_Table[] =
+{
+	{"cs_assault",  CSSTAT_MAP_WINS_CS_ASSAULT,		CSSTAT_MAP_ROUNDS_CS_ASSAULT },
+	{"cs_compound", CSSTAT_MAP_WINS_CS_COMPOUND,	CSSTAT_MAP_ROUNDS_CS_COMPOUND },
+	{"cs_havana",   CSSTAT_MAP_WINS_CS_HAVANA,		CSSTAT_MAP_ROUNDS_CS_HAVANA },
+	{"cs_italy",    CSSTAT_MAP_WINS_CS_ITALY,		CSSTAT_MAP_ROUNDS_CS_ITALY },
+	{"cs_militia",  CSSTAT_MAP_WINS_CS_MILITIA,		CSSTAT_MAP_ROUNDS_CS_MILITIA },
+	{"cs_office",   CSSTAT_MAP_WINS_CS_OFFICE,		CSSTAT_MAP_ROUNDS_CS_OFFICE },
+	{"de_aztec",    CSSTAT_MAP_WINS_DE_AZTEC,		CSSTAT_MAP_ROUNDS_DE_AZTEC },
+	{"de_cbble",    CSSTAT_MAP_WINS_DE_CBBLE,		CSSTAT_MAP_ROUNDS_DE_CBBLE },
+	{"de_chateau",  CSSTAT_MAP_WINS_DE_CHATEAU,		CSSTAT_MAP_ROUNDS_DE_CHATEAU },
+	{"de_dust2",    CSSTAT_MAP_WINS_DE_DUST2,		CSSTAT_MAP_ROUNDS_DE_DUST2 },
+	{"de_dust",     CSSTAT_MAP_WINS_DE_DUST,		CSSTAT_MAP_ROUNDS_DE_DUST },
+	{"de_inferno",  CSSTAT_MAP_WINS_DE_INFERNO,		CSSTAT_MAP_ROUNDS_DE_INFERNO },
+	{"de_nuke",     CSSTAT_MAP_WINS_DE_NUKE,		CSSTAT_MAP_ROUNDS_DE_NUKE },
+	{"de_piranesi", CSSTAT_MAP_WINS_DE_PIRANESI,	CSSTAT_MAP_ROUNDS_DE_PIRANESI },
+	{"de_port",     CSSTAT_MAP_WINS_DE_PORT,		CSSTAT_MAP_ROUNDS_DE_PORT },
+	{"de_prodigy",  CSSTAT_MAP_WINS_DE_PRODIGY,		CSSTAT_MAP_ROUNDS_DE_PRODIGY },
+	{"de_tides",    CSSTAT_MAP_WINS_DE_TIDES,		CSSTAT_MAP_ROUNDS_DE_TIDES },
+	{"de_train",    CSSTAT_MAP_WINS_DE_TRAIN,		CSSTAT_MAP_ROUNDS_DE_TRAIN },
+	{"",			CSSTAT_UNDEFINED,				CSSTAT_UNDEFINED },
+};
+
+const WeaponName_StatId WeaponName_StatId_Table[] =
+{
+	{ WEAPON_DEAGLE,		CSSTAT_KILLS_DEAGLE,	CSSTAT_SHOTS_DEAGLE,	CSSTAT_HITS_DEAGLE, 	CSSTAT_DAMAGE_DEAGLE 	},
+	{ WEAPON_USP,			CSSTAT_KILLS_USP,		CSSTAT_SHOTS_USP,		CSSTAT_HITS_USP,		CSSTAT_DAMAGE_USP		},
+	{ WEAPON_GLOCK,			CSSTAT_KILLS_GLOCK,		CSSTAT_SHOTS_GLOCK,		CSSTAT_HITS_GLOCK,		CSSTAT_DAMAGE_GLOCK		},
+	{ WEAPON_P228,			CSSTAT_KILLS_P228,		CSSTAT_SHOTS_P228,		CSSTAT_HITS_P228,		CSSTAT_DAMAGE_P228		},
+	{ WEAPON_ELITE,			CSSTAT_KILLS_ELITE,		CSSTAT_SHOTS_ELITE,		CSSTAT_HITS_ELITE,		CSSTAT_DAMAGE_ELITE		},
+	{ WEAPON_FIVESEVEN,		CSSTAT_KILLS_FIVESEVEN, CSSTAT_SHOTS_FIVESEVEN, CSSTAT_HITS_FIVESEVEN,	CSSTAT_DAMAGE_FIVESEVEN	},
+	{ WEAPON_AWP,			CSSTAT_KILLS_AWP,		CSSTAT_SHOTS_AWP,		CSSTAT_HITS_AWP,		CSSTAT_DAMAGE_AWP		},
+	{ WEAPON_AK47,			CSSTAT_KILLS_AK47,		CSSTAT_SHOTS_AK47,		CSSTAT_HITS_AK47,		CSSTAT_DAMAGE_AK47		},
+	{ WEAPON_M4A1,			CSSTAT_KILLS_M4A1,		CSSTAT_SHOTS_M4A1,		CSSTAT_HITS_M4A1,		CSSTAT_DAMAGE_M4A1		},
+	{ WEAPON_AUG,			CSSTAT_KILLS_AUG,		CSSTAT_SHOTS_AUG,		CSSTAT_HITS_AUG,		CSSTAT_DAMAGE_AUG		},
+	{ WEAPON_SG552,			CSSTAT_KILLS_SG552,		CSSTAT_SHOTS_SG552,		CSSTAT_HITS_SG552, 		CSSTAT_DAMAGE_SG552 	},
+	{ WEAPON_SG550,			CSSTAT_KILLS_SG550,		CSSTAT_SHOTS_SG550,		CSSTAT_HITS_SG550, 		CSSTAT_DAMAGE_SG550 	},
+	{ WEAPON_GALIL,			CSSTAT_KILLS_GALIL,		CSSTAT_SHOTS_GALIL,		CSSTAT_HITS_GALIL, 		CSSTAT_DAMAGE_GALIL 	},
+	{ WEAPON_FAMAS,			CSSTAT_KILLS_FAMAS,		CSSTAT_SHOTS_FAMAS,		CSSTAT_HITS_FAMAS, 		CSSTAT_DAMAGE_FAMAS 	},
+	{ WEAPON_SCOUT,			CSSTAT_KILLS_SCOUT,		CSSTAT_SHOTS_SCOUT,		CSSTAT_HITS_SCOUT, 		CSSTAT_DAMAGE_SCOUT 	},
+	{ WEAPON_G3SG1,			CSSTAT_KILLS_G3SG1,		CSSTAT_SHOTS_G3SG1,		CSSTAT_HITS_G3SG1, 		CSSTAT_DAMAGE_G3SG1 	},
+	{ WEAPON_P90,			CSSTAT_KILLS_P90,		CSSTAT_SHOTS_P90,		CSSTAT_HITS_P90,		CSSTAT_DAMAGE_P90		},
+	{ WEAPON_MP5NAVY,		CSSTAT_KILLS_MP5NAVY,	CSSTAT_SHOTS_MP5NAVY,	CSSTAT_HITS_MP5NAVY,	CSSTAT_DAMAGE_MP5NAVY	},
+	{ WEAPON_TMP,			CSSTAT_KILLS_TMP,		CSSTAT_SHOTS_TMP,		CSSTAT_HITS_TMP,		CSSTAT_DAMAGE_TMP		},
+	{ WEAPON_MAC10,			CSSTAT_KILLS_MAC10,		CSSTAT_SHOTS_MAC10,		CSSTAT_HITS_MAC10,		CSSTAT_DAMAGE_MAC10		},
+	{ WEAPON_UMP45,			CSSTAT_KILLS_UMP45,		CSSTAT_SHOTS_UMP45,		CSSTAT_HITS_UMP45,		CSSTAT_DAMAGE_UMP45		},
+	{ WEAPON_M3,			CSSTAT_KILLS_M3,		CSSTAT_SHOTS_M3,		CSSTAT_HITS_M3,			CSSTAT_DAMAGE_M3		},
+	{ WEAPON_XM1014,		CSSTAT_KILLS_XM1014,	CSSTAT_SHOTS_XM1014,	CSSTAT_HITS_XM1014,		CSSTAT_DAMAGE_XM1014	},
+	{ WEAPON_M249,			CSSTAT_KILLS_M249,		CSSTAT_SHOTS_M249,		CSSTAT_HITS_M249,		CSSTAT_DAMAGE_M249		},
+	{ WEAPON_KNIFE,			CSSTAT_KILLS_KNIFE,		CSSTAT_SHOTS_KNIFE,		CSSTAT_HITS_KNIFE,		CSSTAT_DAMAGE_KNIFE 	},
+	{ WEAPON_HEGRENADE,	CSSTAT_KILLS_HEGRENADE, CSSTAT_SHOTS_HEGRENADE,	CSSTAT_HITS_HEGRENADE,	CSSTAT_DAMAGE_HEGRENADE 	},
+
+	{ WEAPON_NONE,						CSSTAT_UNDEFINED,		CSSTAT_UNDEFINED,		CSSTAT_UNDEFINED,		CSSTAT_UNDEFINED },	// This is a sentinel value so we can loop through all the stats
+};
+
+CSStatProperty CSStatProperty_Table[] =
+{
+//		StatId									Steam Name							Localization Token						Client Update Priority
+	{	CSSTAT_SHOTS_HIT,						"i_NumShotsHit",					"#GAMEUI_Stat_NumHits",					CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_FIRED,						"i_NumShotsFired",					"#GAMEUI_Stat_NumShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_KILLS,							"i_Number_Of_Kills",				"#GAMEUI_Stat_NumKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_DEATHS,							"i_Number_Of_Deaths",				"#GAMEUI_Stat_NumDeaths",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_DAMAGE,							"i_Damage_Done",					"#GAMEUI_Stat_DamageDone",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_NUM_BOMBS_PLANTED,				"i_Number_Of_PlantedBombs",			"#GAMEUI_Stat_NumPlantedBombs",			CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_NUM_BOMBS_DEFUSED,				"i_Number_Of_DefusedBombs",			"#GAMEUI_Stat_NumDefusedBombs",			CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_PLAYTIME,						"i_Time_Played",					"#GAMEUI_Stat_TimePlayed",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_ROUNDS_WON,						"total_wins",						"#GAMEUI_Stat_TotalWins",				CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_T_ROUNDS_WON,					NULL,								NULL,									CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_CT_ROUNDS_WON,					NULL,								NULL,									CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_ROUNDS_PLAYED,					"i_Total_Rounds",					"#GAMEUI_Stat_TotalRounds",				CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_PISTOLROUNDS_WON,				"total_wins_pistolround",			"#GAMEUI_Stat_PistolRoundWins",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MONEY_EARNED,					"i_Money_Earned",					"#GAMEUI_Stat_MoneyEarned",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_OBJECTIVES_COMPLETED,			NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_BOMBS_DEFUSED_WITHKIT,			NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+
+	{	CSSTAT_KILLS_DEAGLE,					"total_kills_deagle",				"#GAMEUI_Stat_DeagleKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_USP,						"total_kills_usp",					"#GAMEUI_Stat_USPKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_GLOCK,						"total_kills_glock",				"#GAMEUI_Stat_GlockKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_P228,						"total_kills_p228",					"#GAMEUI_Stat_P228Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_ELITE,						"total_kills_elite",				"#GAMEUI_Stat_EliteKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_FIVESEVEN,					"total_kills_fiveseven",			"#GAMEUI_Stat_FiveSevenKills",			CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_AWP,						"total_kills_awp",					"#GAMEUI_Stat_AWPKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_AK47,						"total_kills_ak47",					"#GAMEUI_Stat_AK47Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_M4A1,						"total_kills_m4a1",					"#GAMEUI_Stat_M4A1Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_AUG,						"total_kills_aug",					"#GAMEUI_Stat_AUGKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_SG552,						"total_kills_sg552",				"#GAMEUI_Stat_SG552Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_SG550,						"total_kills_sg550",				"#GAMEUI_Stat_SG550Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_GALIL,						"total_kills_galil",				"#GAMEUI_Stat_GALILKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_FAMAS,						"total_kills_famas",				"#GAMEUI_Stat_FAMASKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_SCOUT,						"total_kills_scout",				"#GAMEUI_Stat_ScoutKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_G3SG1,						"total_kills_g3sg1",				"#GAMEUI_Stat_G3SG1Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_P90,						"total_kills_p90",					"#GAMEUI_Stat_P90Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_MP5NAVY,					"total_kills_mp5navy",				"#GAMEUI_Stat_MP5NavyKills",			CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_TMP,						"total_kills_tmp",					"#GAMEUI_Stat_TMPKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_MAC10,						"total_kills_mac10",				"#GAMEUI_Stat_MAC10Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_UMP45,						"total_kills_ump45",				"#GAMEUI_Stat_UMP45Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_M3,						"total_kills_m3",					"#GAMEUI_Stat_M3Kills",					CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_XM1014,					"total_kills_xm1014",				"#GAMEUI_Stat_XM1014Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_M249,						"total_kills_m249",					"#GAMEUI_Stat_M249Kills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_KNIFE,						"total_kills_knife",				"#GAMEUI_Stat_KnifeKills",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_HEGRENADE,					"total_kills_hegrenade",			"#GAMEUI_Stat_HEGrenadeKills",			CSSTAT_PRIORITY_HIGH,			},
+
+	{	CSSTAT_SHOTS_DEAGLE,					"total_shots_deagle",				"#GAMEUI_Stat_DeagleShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_USP,						"total_shots_usp",					"#GAMEUI_Stat_USPShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_GLOCK,						"total_shots_glock",				"#GAMEUI_Stat_GlockShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_P228,						"total_shots_p228",					"#GAMEUI_Stat_P228Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_ELITE,						"total_shots_elite",				"#GAMEUI_Stat_EliteShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_FIVESEVEN,					"total_shots_fiveseven",			"#GAMEUI_Stat_FiveSevenShots",			CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_AWP,						"total_shots_awp",					"#GAMEUI_Stat_AWPShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_AK47,						"total_shots_ak47",					"#GAMEUI_Stat_AK47Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_M4A1,						"total_shots_m4a1",					"#GAMEUI_Stat_M4A1Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_AUG,						"total_shots_aug",					"#GAMEUI_Stat_AUGShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_SG552,						"total_shots_sg552",				"#GAMEUI_Stat_SG552Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_SG550,						"total_shots_sg550",				"#GAMEUI_Stat_SG550Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_GALIL,						"total_shots_galil",				"#GAMEUI_Stat_GALILShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_FAMAS,						"total_shots_famas",				"#GAMEUI_Stat_FAMASShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_SCOUT,						"total_shots_scout",				"#GAMEUI_Stat_ScoutShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_G3SG1,						"total_shots_g3sg1",				"#GAMEUI_Stat_G3SG1Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_P90,						"total_shots_p90",					"#GAMEUI_Stat_P90Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_MP5NAVY,					"total_shots_mp5navy",				"#GAMEUI_Stat_MP5NavyShots",			CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_TMP,						"total_shots_tmp",					"#GAMEUI_Stat_TMPShots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_MAC10,						"total_shots_mac10",				"#GAMEUI_Stat_MAC10Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_UMP45,						"total_shots_ump45",				"#GAMEUI_Stat_UMP45Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_M3,						"total_shots_m3",					"#GAMEUI_Stat_M3Shots",					CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_XM1014,					"total_shots_xm1014",				"#GAMEUI_Stat_XM1014Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_M249,						"total_shots_m249",					"#GAMEUI_Stat_M249Shots",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_SHOTS_KNIFE,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_SHOTS_HEGRENADE,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},	
+
+	{	CSSTAT_HITS_DEAGLE,						"total_hits_deagle",				"#GAMEUI_Stat_DeagleHits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_USP,						"total_hits_usp",					"#GAMEUI_Stat_USPHits",					CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_GLOCK,						"total_hits_glock",					"#GAMEUI_Stat_GlockHits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_P228,						"total_hits_p228",					"#GAMEUI_Stat_P228Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_ELITE,						"total_hits_elite",					"#GAMEUI_Stat_EliteHits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_FIVESEVEN,					"total_hits_fiveseven",				"#GAMEUI_Stat_FiveSevenHits",			CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_AWP,						"total_hits_awp",					"#GAMEUI_Stat_AWPHits",					CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_AK47,						"total_hits_ak47",					"#GAMEUI_Stat_AK47Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_M4A1,						"total_hits_m4a1",					"#GAMEUI_Stat_M4A1Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_AUG,						"total_hits_aug",					"#GAMEUI_Stat_AUGHits",					CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_SG552,						"total_hits_sg552",					"#GAMEUI_Stat_SG552Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_SG550,						"total_hits_sg550",					"#GAMEUI_Stat_SG550Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_GALIL,						"total_hits_galil",					"#GAMEUI_Stat_GALILHits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_FAMAS,						"total_hits_famas",					"#GAMEUI_Stat_FAMASHits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_SCOUT,						"total_hits_scout",					"#GAMEUI_Stat_ScoutHits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_G3SG1,						"total_hits_g3sg1",					"#GAMEUI_Stat_G3SG1Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_P90,						"total_hits_p90",					"#GAMEUI_Stat_P90Hits",					CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_MP5NAVY,					"total_hits_mp5navy",				"#GAMEUI_Stat_MP5NavyHits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_TMP,						"total_hits_tmp",					"#GAMEUI_Stat_TMPHits",					CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_MAC10,						"total_hits_mac10",					"#GAMEUI_Stat_MAC10Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_UMP45,						"total_hits_ump45",					"#GAMEUI_Stat_UMP45Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_M3,							"total_hits_m3",					"#GAMEUI_Stat_M3Hits",					CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_XM1014,						"total_hits_xm1014",				"#GAMEUI_Stat_XM1014Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_M249,						"total_hits_m249",					"#GAMEUI_Stat_M249Hits",				CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_HITS_KNIFE,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_HITS_HEGRENADE,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},	
+
+	{	CSSTAT_DAMAGE_DEAGLE,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_USP,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_GLOCK,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_P228,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_ELITE,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_FIVESEVEN,				NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_AWP,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_AK47,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_M4A1,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_AUG,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_SG552,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_SG550,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_GALIL,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_FAMAS,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_SCOUT,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_G3SG1,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_P90,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_MP5NAVY,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_TMP,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_MAC10,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_UMP45,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_M3,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_XM1014,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_M249,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_KNIFE,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_DAMAGE_HEGRENADE,				NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},	
+
+	{	CSSTAT_KILLS_HEADSHOT,					"total_kills_headshot",				"#GAMEUI_Stat_HeadshotKills",			CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_ENEMY_BLINDED,				"total_kills_enemy_blinded",		"#GAMEUI_Stat_BlindedEnemyKills",		CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_WHILE_BLINDED,				NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_KILLS_WITH_LAST_ROUND,			NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_KILLS_ENEMY_WEAPON,				"total_kills_enemy_weapon",			"#GAMEUI_Stat_EnemyWeaponKills",		CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_KNIFE_FIGHT,				"total_kills_knife_fight",			"#GAMEUI_Stat_KnifeFightKills",			CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_KILLS_WHILE_DEFENDING_BOMB,		NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+
+	{	CSSTAT_DECAL_SPRAYS,					"total_decal_sprays",				"#GAMEUI_Stat_DecalSprays",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_TOTAL_JUMPS,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_NIGHTVISION_DAMAGE,				"total_nightvision_damage",			"#GAMEUI_Stat_NightvisionDamage",		CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_KILLS_WHILE_LAST_PLAYER_ALIVE,	NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_KILLS_ENEMY_WOUNDED,				NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_FALL_DAMAGE,						NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+
+	{	CSSTAT_NUM_HOSTAGES_RESCUED,			"i_Number_Of_RescuedHostages",		"#GAMEUI_Stat_NumRescuedHostages",		CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_NUM_BROKEN_WINDOWS,				"i_Number_Of_BrokenWindows",		"#GAMEUI_Stat_NumBrokenWindows",		CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_PROPSBROKEN_ALL,					NULL,								NULL,									CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_PROPSBROKEN_MELON,				NULL,								NULL,									CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_PROPSBROKEN_OFFICEELECTRONICS,	NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_PROPSBROKEN_OFFICERADIO,			NULL,								NULL,									CSSTAT_PRIORITY_LOW,			},
+	{	CSSTAT_PROPSBROKEN_OFFICEJUNK,			NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_PROPSBROKEN_ITALY_MELON,			NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+
+	{	CSSTAT_KILLS_AGAINST_ZOOMED_SNIPER,		"total_kills_against_zoomed_sniper","#GAMEUI_Stat_ZoomedSniperKills",		CSSTAT_PRIORITY_HIGH,			},
+
+	{	CSSTAT_WEAPONS_DONATED,					"total_weapons_donated",			"#GAMEUI_Stat_WeaponsDonated",			CSSTAT_PRIORITY_HIGH,			},
+
+	{	CSSTAT_ITEMS_PURCHASED,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_MONEY_SPENT,						NULL,								NULL,									CSSTAT_PRIORITY_LOW,			},
+
+	{	CSSTAT_DOMINATIONS,						"total_dominations",				"#GAMEUI_Stat_Dominations",				CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_DOMINATION_OVERKILLS,			"total_domination_overkills",		"#GAMEUI_Stat_DominationOverkills",		CSSTAT_PRIORITY_HIGH,			},
+	{	CSSTAT_REVENGES,						"total_revenges",					"#GAMEUI_Stat_Revenges",				CSSTAT_PRIORITY_HIGH,			},
+
+	{	CSSTAT_MVPS,							"total_mvps",						"#GAMEUI_Stat_MVPs",					CSSTAT_PRIORITY_HIGH,			},
+
+	{	CSSTAT_GRENADE_DAMAGE,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_GRENADE_POSTHUMOUSKILLS,			NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+	{	CSSTAT_GRENADES_THROWN,					NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+    {	CSTAT_ITEMS_DROPPED_VALUE,              NULL,								NULL,									CSSTAT_PRIORITY_NEVER,			},
+
+	{	CSSTAT_MAP_WINS_CS_ASSAULT,				"total_wins_map_cs_assault",		"#GAMEUI_Stat_WinsMapCSAssault",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_CS_COMPOUND,			"total_wins_map_cs_compound",		"#GAMEUI_Stat_WinsMapCSCompound",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_CS_HAVANA,				"total_wins_map_cs_havana",			"#GAMEUI_Stat_WinsMapCSHavana",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_CS_ITALY,				"total_wins_map_cs_italy",			"#GAMEUI_Stat_WinsMapCSItaly",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_CS_MILITIA,				"total_wins_map_cs_militia",		"#GAMEUI_Stat_WinsMapCSMilitia",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_CS_OFFICE,				"total_wins_map_cs_office",			"#GAMEUI_Stat_WinsMapCSOffice",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_AZTEC,				"total_wins_map_de_aztec",			"#GAMEUI_Stat_WinsMapDEAztec",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_CBBLE,				"total_wins_map_de_cbble",			"#GAMEUI_Stat_WinsMapDECbble",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_CHATEAU,				"total_wins_map_de_chateau",		"#GAMEUI_Stat_WinsMapDEChateau",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_DUST2,				"total_wins_map_de_dust2",			"#GAMEUI_Stat_WinsMapDEDust2",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_DUST,				"total_wins_map_de_dust",			"#GAMEUI_Stat_WinsMapDEDust",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_INFERNO,				"total_wins_map_de_inferno",		"#GAMEUI_Stat_WinsMapDEInferno",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_NUKE,				"total_wins_map_de_nuke",			"#GAMEUI_Stat_WinsMapDENuke",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_PIRANESI,			"total_wins_map_de_piranesi",		"#GAMEUI_Stat_WinsMapDEPiranesi",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_PORT,				"total_wins_map_de_port",			"#GAMEUI_Stat_WinsMapDEPort",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_PRODIGY,				"total_wins_map_de_prodigy",		"#GAMEUI_Stat_WinsMapDEProdigy",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_TIDES,				"total_wins_map_de_tides",			"#GAMEUI_Stat_WinsMapDETides",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_WINS_DE_TRAIN,				"total_wins_map_de_train",			"#GAMEUI_Stat_WinsMapDETrain",			CSSTAT_PRIORITY_ENDROUND,		},
+
+	{	CSSTAT_MAP_ROUNDS_CS_ASSAULT,			"total_rounds_map_cs_assault",		"#GAMEUI_Stat_RoundsMapCSAssault",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_CS_COMPOUND,			"total_rounds_map_cs_compound",		"#GAMEUI_Stat_RoundsMapCSCompound",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_CS_HAVANA,			"total_rounds_map_cs_havana",		"#GAMEUI_Stat_RoundsMapCSHavana",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_CS_ITALY,				"total_rounds_map_cs_italy",		"#GAMEUI_Stat_RoundsMapCSItaly",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_CS_MILITIA,			"total_rounds_map_cs_militia",		"#GAMEUI_Stat_RoundsMapCSMilitia",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_CS_OFFICE,			"total_rounds_map_cs_office",		"#GAMEUI_Stat_RoundsMapCSOffice",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_AZTEC,				"total_rounds_map_de_aztec",		"#GAMEUI_Stat_RoundsMapDEAztec",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_CBBLE,				"total_rounds_map_de_cbble",		"#GAMEUI_Stat_RoundsMapDECbble",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_CHATEAU,			"total_rounds_map_de_chateau",		"#GAMEUI_Stat_RoundsMapDEChateau",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_DUST2,				"total_rounds_map_de_dust2",		"#GAMEUI_Stat_RoundsMapDEDust2",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_DUST,				"total_rounds_map_de_dust",			"#GAMEUI_Stat_RoundsMapDEDust",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_INFERNO,			"total_rounds_map_de_inferno",		"#GAMEUI_Stat_RoundsMapDEInferno",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_NUKE,				"total_rounds_map_de_nuke",			"#GAMEUI_Stat_RoundsMapDENuke",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_PIRANESI,			"total_rounds_map_de_piranesi",		"#GAMEUI_Stat_RoundsMapDEPiranesi",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_PORT,				"total_rounds_map_de_port",			"#GAMEUI_Stat_RoundsMapDEPort",			CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_PRODIGY,			"total_rounds_map_de_prodigy",		"#GAMEUI_Stat_RoundsMapDEProdigy",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_TIDES,				"total_rounds_map_de_tides",		"#GAMEUI_Stat_RoundsMapDETides",		CSSTAT_PRIORITY_ENDROUND,		},
+	{	CSSTAT_MAP_ROUNDS_DE_TRAIN,				"total_rounds_map_de_train",		"#GAMEUI_Stat_RoundsMapDETrain",		CSSTAT_PRIORITY_ENDROUND,		},
+
+	// only client tracks these
+	{	CSSTAT_LASTMATCH_T_ROUNDS_WON,			"last_match_t_wins",				"#GameUI_Stat_LastMatch_TWins",			CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_CT_ROUNDS_WON,			"last_match_ct_wins",				"#GameUI_Stat_LastMatch_CTWins",		CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_ROUNDS_WON,			"last_match_wins",					"#GameUI_Stat_LastMatch_RoundsWon",		CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_KILLS,					"last_match_kills",					"#GameUI_Stat_LastMatch_Kills",			CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_DEATHS,				"last_match_deaths",				"#GameUI_Stat_LastMatch_Deaths",		CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_MVPS,					"last_match_mvps",					"#GameUI_Stat_LastMatch_MVPS",			CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_DAMAGE,				"last_match_damage",				"#GameUI_Stat_LastMatch_Damage",		CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_MONEYSPENT,			"last_match_money_spent",			"#GameUI_Stat_LastMatch_MoneySpent",	CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_DOMINATIONS,			"last_match_dominations",			"#GameUI_Stat_LastMatch_Dominations",	CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_REVENGES,				"last_match_revenges",				"#GameUI_Stat_LastMatch_Revenges",		CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_MAX_PLAYERS,			"last_match_max_players",			"#GameUI_Stat_LastMatch_MaxPlayers",	CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_FAVWEAPON_ID,			"last_match_favweapon_id",			"#GameUI_Stat_LastMatch_FavWeapon",		CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_FAVWEAPON_SHOTS,		"last_match_favweapon_shots",		"#GameUI_Stat_LastMatch_FavWeaponShots",CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_FAVWEAPON_HITS,		"last_match_favweapon_hits",		"#GameUI_Stat_LastMatch_FavWeaponHits",	CSSTAT_PRIORITY_NEVER },
+	{	CSSTAT_LASTMATCH_FAVWEAPON_KILLS,		"last_match_favweapon_kills",		"#GameUI_Stat_LastMatch_FavWeaponKills",CSSTAT_PRIORITY_NEVER },
+
+	{	CSSTAT_UNDEFINED	},	// sentinel
+};
+
+const WeaponName_StatId& GetWeaponTableEntryFromWeaponId( CSWeaponID id )
+{
+	int i;
+
+	//yes this for loop has no statement block. All we are doing is incrementing i to the appropriate point.
+	for (i = 0 ; WeaponName_StatId_Table[i].weaponId != WEAPON_NONE ; ++i)
+	{
+		if (WeaponName_StatId_Table[i].weaponId == id )
+		{
+			break;
+		}
+	}
+	return WeaponName_StatId_Table[i];
+}
+
+void StatsCollection_t::Aggregate( const StatsCollection_t& other )
+{
+	for ( int i = 0; i < CSSTAT_MAX; ++i )
+	{
+		m_iValue[i] += other[i];
+	}
+}
+
+//=============================================================================
+//
+// Helper functions for creating key values
+//
+void AddDataToKV( KeyValues* pKV, const char* name, int data )
+{
+	pKV->SetInt( name, data );
+}
+void AddDataToKV( KeyValues* pKV, const char* name, uint64 data )
+{
+	pKV->SetUint64( name, data );
+}
+void AddDataToKV( KeyValues* pKV, const char* name, float data )
+{
+	pKV->SetFloat( name, data );
+}
+void AddDataToKV( KeyValues* pKV, const char* name, bool data )
+{
+	pKV->SetInt( name, data ? true : false );
+}
+void AddDataToKV( KeyValues* pKV, const char* name, const char* data )
+{
+	pKV->SetString( name, data );
+}
+void AddDataToKV( KeyValues* pKV, const char* name, const Color& data )
+{
+	pKV->SetColor( name, data );
+}
+void AddDataToKV( KeyValues* pKV, const char* name, short data )
+{
+	pKV->SetInt( name, data );
+}
+void AddDataToKV( KeyValues* pKV, const char* name, unsigned data )
+{
+	pKV->SetInt( name, data );
+}
+void AddPositionDataToKV( KeyValues* pKV, const char* name, const Vector &data )
+{
+	// Append the data name to the member
+	pKV->SetFloat( CFmtStr("%s%s", name, "_X"), data.x );
+	pKV->SetFloat( CFmtStr("%s%s", name, "_Y"), data.y );
+	pKV->SetFloat( CFmtStr("%s%s", name, "_Z"), data.z );
+}
+
+//=============================================================================//
+
+//=============================================================================
+//
+// Helper functions for creating key values from arrays
+//
+void AddArrayDataToKV( KeyValues* pKV, const char* name, const short *data, unsigned size )
+{
+	for( unsigned i=0; i<size; ++i )
+		pKV->SetInt( CFmtStr("%s_%d", name, i) , data[i] );
+}
+void AddArrayDataToKV( KeyValues* pKV, const char* name, const byte *data, unsigned size )
+{
+	for( unsigned i=0; i<size; ++i )
+		pKV->SetInt( CFmtStr("%s_%d", name, i), data[i] );
+}
+void AddArrayDataToKV( KeyValues* pKV, const char* name, const unsigned *data, unsigned size )
+{
+	for( unsigned i=0; i<size; ++i )
+		pKV->SetInt( CFmtStr("%s_%d", name, i), data[i] );
+}
+void AddStringDataToKV( KeyValues* pKV, const char* name, const char*data )
+{
+	if( name == NULL )
+		return;
+
+	pKV->SetString( name, data );
+}
+//=============================================================================//
+
+
+void IGameStatTracker::PrintGamestatMemoryUsage( void )
+{
+	StatContainerList_t* pStatList = GetStatContainerList();
+	if( !pStatList )
+		return;
+
+	int iListSize = pStatList->Count();
+
+	// For every stat list being tracked, print out its memory usage
+	for( int i=0; i < iListSize; ++i )
+	{
+		pStatList->operator []( i )->PrintMemoryUsage();
+	}
+}
diff --git a/game/shared/cstrike/cs_gamestats_shared.h b/game/shared/cstrike/cs_gamestats_shared.h
new file mode 100644
index 00000000..dc58a778
--- /dev/null
+++ b/game/shared/cstrike/cs_gamestats_shared.h
@@ -0,0 +1,824 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================
+#ifndef CS_GAMESTATS_SHARED_H
+#define CS_GAMESTATS_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+#include "cbase.h"
+// #include "tier1/utlvector.h"
+// #include "tier1/utldict.h"
+#include "shareddefs.h"
+#include "cs_shareddefs.h"
+#include "cs_weapon_parse.h"
+#include "fmtstr.h"
+
+
+#define CS_NUM_LEVELS 18
+
+//=============================================================================
+// Helper class for simple manipulation of bit arrays.
+// Used for server->client packets containing delta stats
+//=============================================================================
+
+template <int BitLength>
+class BitArray
+{
+	enum { ByteLength = (BitLength + 7) / 8 };
+public:
+	BitArray() { ClearAll(); }
+
+	void SetBit(int n) { m_bytes[n / 8] |= 1 << (n & 7); }
+	void ClearBit(int n) { m_bytes[n / 8] &= (~(1 << (n & 7))); }
+	bool IsBitSet(int n) const { return (m_bytes[n / 8] & (1 << (n & 7))) != 0;}
+
+	void ClearAll() { V_memset(m_bytes, 0, sizeof(m_bytes)); }
+	int NumBits() { return BitLength; }
+	int NumBytes() { return ByteLength; }
+
+	byte* RawPointer() { return m_bytes; }
+
+private:
+	byte m_bytes[ByteLength];
+};
+
+
+//=============================================================================
+//
+// CS Game Stats Enums
+//
+// WARNING! ANY CHANGE TO THE ORDERING OR NUMBER OF STATS WILL REQUIRE 
+// SYNCHRONOUS UPDATE OF CLIENT AND SERVER DLLS. If you change these enums
+// (including adding new stats) without forcing an update of both the client 
+// and server, stats will become corrupted on the game client and these 
+// corrupted values will be uploaded to steam, which is very very bad.
+//
+// If you add new stats, if will be safest to add them at the end of the enum
+// (although this will still require a server update); make sure you also add
+// the stats to the CSStatProperty_Table in cs_gamestats_shared.cpp at the
+// appropriate location.
+
+enum CSStatType_t
+{
+	CSSTAT_UNDEFINED = -1,
+	CSSTAT_SHOTS_HIT,
+	CSSTAT_SHOTS_FIRED,
+	CSSTAT_KILLS,
+	CSSTAT_DEATHS,
+	CSSTAT_DAMAGE,
+    CSSTAT_NUM_BOMBS_PLANTED,
+    CSSTAT_NUM_BOMBS_DEFUSED,
+	CSSTAT_PLAYTIME,
+	CSSTAT_ROUNDS_WON,
+	CSSTAT_T_ROUNDS_WON,
+	CSSTAT_CT_ROUNDS_WON,
+	CSSTAT_ROUNDS_PLAYED,
+	CSSTAT_PISTOLROUNDS_WON,
+	CSSTAT_MONEY_EARNED,
+	CSSTAT_OBJECTIVES_COMPLETED,
+	CSSTAT_BOMBS_DEFUSED_WITHKIT,
+
+	CSSTAT_KILLS_DEAGLE,
+	CSSTAT_KILLS_USP,
+	CSSTAT_KILLS_GLOCK,
+	CSSTAT_KILLS_P228,
+	CSSTAT_KILLS_ELITE,
+	CSSTAT_KILLS_FIVESEVEN,
+	CSSTAT_KILLS_AWP,
+	CSSTAT_KILLS_AK47,
+	CSSTAT_KILLS_M4A1,
+	CSSTAT_KILLS_AUG,
+	CSSTAT_KILLS_SG552,
+	CSSTAT_KILLS_SG550,
+	CSSTAT_KILLS_GALIL,
+	CSSTAT_KILLS_FAMAS,
+	CSSTAT_KILLS_SCOUT,
+	CSSTAT_KILLS_G3SG1,
+	CSSTAT_KILLS_P90,
+	CSSTAT_KILLS_MP5NAVY,
+	CSSTAT_KILLS_TMP,
+	CSSTAT_KILLS_MAC10,
+	CSSTAT_KILLS_UMP45,
+	CSSTAT_KILLS_M3,
+	CSSTAT_KILLS_XM1014,
+	CSSTAT_KILLS_M249,
+	CSSTAT_KILLS_KNIFE,
+	CSSTAT_KILLS_HEGRENADE,
+
+	CSSTAT_SHOTS_DEAGLE,
+	CSSTAT_SHOTS_USP,
+	CSSTAT_SHOTS_GLOCK,
+	CSSTAT_SHOTS_P228,
+	CSSTAT_SHOTS_ELITE,
+	CSSTAT_SHOTS_FIVESEVEN,
+	CSSTAT_SHOTS_AWP,
+	CSSTAT_SHOTS_AK47,
+	CSSTAT_SHOTS_M4A1,
+	CSSTAT_SHOTS_AUG,
+	CSSTAT_SHOTS_SG552,
+	CSSTAT_SHOTS_SG550,
+	CSSTAT_SHOTS_GALIL,
+	CSSTAT_SHOTS_FAMAS,
+	CSSTAT_SHOTS_SCOUT,
+	CSSTAT_SHOTS_G3SG1,
+	CSSTAT_SHOTS_P90,
+	CSSTAT_SHOTS_MP5NAVY,
+	CSSTAT_SHOTS_TMP,
+	CSSTAT_SHOTS_MAC10,
+	CSSTAT_SHOTS_UMP45,
+	CSSTAT_SHOTS_M3,
+	CSSTAT_SHOTS_XM1014,
+	CSSTAT_SHOTS_M249,
+	CSSTAT_SHOTS_KNIFE,
+	CSSTAT_SHOTS_HEGRENADE,
+
+	CSSTAT_HITS_DEAGLE,
+	CSSTAT_HITS_USP,
+	CSSTAT_HITS_GLOCK,
+	CSSTAT_HITS_P228,
+	CSSTAT_HITS_ELITE,
+	CSSTAT_HITS_FIVESEVEN,
+	CSSTAT_HITS_AWP,
+	CSSTAT_HITS_AK47,
+	CSSTAT_HITS_M4A1,
+	CSSTAT_HITS_AUG,
+	CSSTAT_HITS_SG552,
+	CSSTAT_HITS_SG550,
+	CSSTAT_HITS_GALIL,
+	CSSTAT_HITS_FAMAS,
+	CSSTAT_HITS_SCOUT,
+	CSSTAT_HITS_G3SG1,
+	CSSTAT_HITS_P90,
+	CSSTAT_HITS_MP5NAVY,
+	CSSTAT_HITS_TMP,
+	CSSTAT_HITS_MAC10,
+	CSSTAT_HITS_UMP45,
+	CSSTAT_HITS_M3,
+	CSSTAT_HITS_XM1014,
+	CSSTAT_HITS_M249,
+	CSSTAT_HITS_KNIFE,
+	CSSTAT_HITS_HEGRENADE,
+
+	CSSTAT_DAMAGE_DEAGLE,
+	CSSTAT_DAMAGE_USP,
+	CSSTAT_DAMAGE_GLOCK,
+	CSSTAT_DAMAGE_P228,
+	CSSTAT_DAMAGE_ELITE,
+	CSSTAT_DAMAGE_FIVESEVEN,
+	CSSTAT_DAMAGE_AWP,
+	CSSTAT_DAMAGE_AK47,
+	CSSTAT_DAMAGE_M4A1,
+	CSSTAT_DAMAGE_AUG,
+	CSSTAT_DAMAGE_SG552,
+	CSSTAT_DAMAGE_SG550,
+	CSSTAT_DAMAGE_GALIL,
+	CSSTAT_DAMAGE_FAMAS,
+	CSSTAT_DAMAGE_SCOUT,
+	CSSTAT_DAMAGE_G3SG1,
+	CSSTAT_DAMAGE_P90,
+	CSSTAT_DAMAGE_MP5NAVY,
+	CSSTAT_DAMAGE_TMP,
+	CSSTAT_DAMAGE_MAC10,
+	CSSTAT_DAMAGE_UMP45,
+	CSSTAT_DAMAGE_M3,
+	CSSTAT_DAMAGE_XM1014,
+	CSSTAT_DAMAGE_M249,
+	CSSTAT_DAMAGE_KNIFE,
+	CSSTAT_DAMAGE_HEGRENADE,	
+
+	CSSTAT_KILLS_HEADSHOT,
+	CSSTAT_KILLS_ENEMY_BLINDED,
+	CSSTAT_KILLS_WHILE_BLINDED,
+	CSSTAT_KILLS_WITH_LAST_ROUND,
+	CSSTAT_KILLS_ENEMY_WEAPON,
+	CSSTAT_KILLS_KNIFE_FIGHT,
+	CSSTAT_KILLS_WHILE_DEFENDING_BOMB,
+
+	CSSTAT_DECAL_SPRAYS,
+	CSSTAT_TOTAL_JUMPS,
+	CSSTAT_NIGHTVISION_DAMAGE,
+	CSSTAT_KILLS_WHILE_LAST_PLAYER_ALIVE,
+	CSSTAT_KILLS_ENEMY_WOUNDED,
+	CSSTAT_FALL_DAMAGE,
+
+	CSSTAT_NUM_HOSTAGES_RESCUED,
+
+	CSSTAT_NUM_BROKEN_WINDOWS,
+	CSSTAT_PROPSBROKEN_ALL,
+	CSSTAT_PROPSBROKEN_MELON,
+	CSSTAT_PROPSBROKEN_OFFICEELECTRONICS,
+	CSSTAT_PROPSBROKEN_OFFICERADIO,
+	CSSTAT_PROPSBROKEN_OFFICEJUNK,
+	CSSTAT_PROPSBROKEN_ITALY_MELON,
+
+	CSSTAT_KILLS_AGAINST_ZOOMED_SNIPER,
+
+	CSSTAT_WEAPONS_DONATED,
+
+	CSSTAT_ITEMS_PURCHASED,
+	CSSTAT_MONEY_SPENT,
+
+	CSSTAT_DOMINATIONS,
+	CSSTAT_DOMINATION_OVERKILLS,
+	CSSTAT_REVENGES,
+
+	CSSTAT_MVPS,
+
+	CSSTAT_GRENADE_DAMAGE,
+	CSSTAT_GRENADE_POSTHUMOUSKILLS,
+	CSSTAT_GRENADES_THROWN,
+
+    CSTAT_ITEMS_DROPPED_VALUE,
+
+	//Map win stats
+	CSSTAT_MAP_WINS_CS_ASSAULT,
+	CSSTAT_MAP_WINS_CS_COMPOUND,
+	CSSTAT_MAP_WINS_CS_HAVANA,
+	CSSTAT_MAP_WINS_CS_ITALY,
+	CSSTAT_MAP_WINS_CS_MILITIA,
+	CSSTAT_MAP_WINS_CS_OFFICE,
+	CSSTAT_MAP_WINS_DE_AZTEC,
+	CSSTAT_MAP_WINS_DE_CBBLE,
+	CSSTAT_MAP_WINS_DE_CHATEAU,
+	CSSTAT_MAP_WINS_DE_DUST2,
+	CSSTAT_MAP_WINS_DE_DUST,
+	CSSTAT_MAP_WINS_DE_INFERNO,
+	CSSTAT_MAP_WINS_DE_NUKE,
+	CSSTAT_MAP_WINS_DE_PIRANESI,
+	CSSTAT_MAP_WINS_DE_PORT,
+	CSSTAT_MAP_WINS_DE_PRODIGY,
+	CSSTAT_MAP_WINS_DE_TIDES,
+	CSSTAT_MAP_WINS_DE_TRAIN,
+
+	CSSTAT_MAP_ROUNDS_CS_ASSAULT,
+	CSSTAT_MAP_ROUNDS_CS_COMPOUND,
+	CSSTAT_MAP_ROUNDS_CS_HAVANA,
+	CSSTAT_MAP_ROUNDS_CS_ITALY,
+	CSSTAT_MAP_ROUNDS_CS_MILITIA,
+	CSSTAT_MAP_ROUNDS_CS_OFFICE,
+	CSSTAT_MAP_ROUNDS_DE_AZTEC,
+	CSSTAT_MAP_ROUNDS_DE_CBBLE,
+	CSSTAT_MAP_ROUNDS_DE_CHATEAU,
+	CSSTAT_MAP_ROUNDS_DE_DUST2,
+	CSSTAT_MAP_ROUNDS_DE_DUST,
+	CSSTAT_MAP_ROUNDS_DE_INFERNO,
+	CSSTAT_MAP_ROUNDS_DE_NUKE,
+	CSSTAT_MAP_ROUNDS_DE_PIRANESI,
+	CSSTAT_MAP_ROUNDS_DE_PORT,
+	CSSTAT_MAP_ROUNDS_DE_PRODIGY,
+	CSSTAT_MAP_ROUNDS_DE_TIDES,
+	CSSTAT_MAP_ROUNDS_DE_TRAIN,
+
+	CSSTAT_LASTMATCH_T_ROUNDS_WON,
+	CSSTAT_LASTMATCH_CT_ROUNDS_WON,
+	CSSTAT_LASTMATCH_ROUNDS_WON,
+	CSSTAT_LASTMATCH_KILLS,
+	CSSTAT_LASTMATCH_DEATHS,
+	CSSTAT_LASTMATCH_MVPS,
+	CSSTAT_LASTMATCH_DAMAGE,
+	CSSTAT_LASTMATCH_MONEYSPENT,
+	CSSTAT_LASTMATCH_DOMINATIONS,
+	CSSTAT_LASTMATCH_REVENGES,
+	CSSTAT_LASTMATCH_MAX_PLAYERS,
+	CSSTAT_LASTMATCH_FAVWEAPON_ID,
+	CSSTAT_LASTMATCH_FAVWEAPON_SHOTS,
+	CSSTAT_LASTMATCH_FAVWEAPON_HITS,
+	CSSTAT_LASTMATCH_FAVWEAPON_KILLS,
+
+	CSSTAT_MAX	//Must be last entry.
+};
+
+
+#define CSSTAT_FIRST (CSSTAT_UNDEFINED+1)
+#define CSSTAT_LAST (CSSTAT_MAX-1)
+
+//
+// CS Game Stats Flags
+//
+#define CSSTAT_PRIORITY_MASK		0x000F
+#define CSSTAT_PRIORITY_NEVER		0x0000		// not sent to client
+#define CSSTAT_PRIORITY_ENDROUND	0x0001		// sent at end of round
+#define CSSTAT_PRIORITY_LOW			0x0002		// sent every 2500ms
+#define CSSTAT_PRIORITY_HIGH		0x0003		// sent every 250ms
+
+struct CSStatProperty
+{
+	int statId;							// verify that table ordering is correct
+	const char*	szSteamName;			// name of the stat on steam
+	const char*	szLocalizationToken;   // localization token for the stat
+	uint flags;							// priority flags for sending to client
+};
+
+extern CSStatProperty CSStatProperty_Table[];
+
+
+//=============================================================================
+//
+// CS Player Round Stats
+//
+struct StatsCollection_t
+{
+	StatsCollection_t() { Reset(); }
+
+	inline int Get( int i ) const
+	{
+		AssertMsg( i >= CSSTAT_FIRST && i < CSSTAT_MAX, "Stat index out of range!" );
+		if ( i >= 0 )
+			return m_iValue[ i ];
+		return 0;
+	}
+
+	inline void Set( int i, int nValue )
+	{
+		AssertMsg( i >= CSSTAT_FIRST && i < CSSTAT_MAX, "Stat index out of range!" );
+		if ( i >= 0 )
+			m_iValue[ i ] = nValue;
+	}
+
+	void Reset()
+	{
+		for ( int i = 0; i < ARRAYSIZE( m_iValue ); i++ )
+		{
+			m_iValue[i] = 0;
+		}
+	}
+
+	int operator[] ( int index ) const
+	{
+		Assert(index >= 0 && index < ARRAYSIZE(m_iValue));
+		return m_iValue[index];
+	}
+
+	int& operator[] ( int index )
+	{
+		Assert(index >= 0 && index < ARRAYSIZE(m_iValue));
+		return m_iValue[index];
+	}
+
+	void Aggregate( const StatsCollection_t& other );
+
+private:
+	int m_iValue[CSSTAT_MAX];
+};
+
+
+//=============================================================================
+// HPE_BEGIN:
+// [tj] A couple variations on the RoundStats structure to handle extra operations
+//		for averaging and accumulating
+//=============================================================================
+struct RoundStatsDirectAverage_t
+{
+	float m_fStat[CSSTAT_MAX];
+
+
+	RoundStatsDirectAverage_t()
+	{
+		Reset();
+	}
+
+	void Reset()
+	{
+		for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+		{
+			m_fStat[i] = 0;
+		}
+	}
+
+	RoundStatsDirectAverage_t& operator +=( const StatsCollection_t &other )
+	{
+		for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+		{
+			m_fStat[i] += other[i];
+		}
+		return *this;
+	}
+
+	RoundStatsDirectAverage_t& operator /=( const float &divisor)
+	{
+		if (divisor > 0)
+		{
+			for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+			{
+				m_fStat[i] /= divisor;
+			}
+		}
+		return *this;
+	}
+
+	RoundStatsDirectAverage_t& operator *=( const float &divisor)
+	{
+		for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+		{
+			m_fStat[i] *= divisor;
+		}
+		return *this;
+	}
+};
+
+
+struct RoundStatsRollingAverage_t
+{
+    float m_fStat[CSSTAT_MAX];
+    int m_numberOfDataSets;
+
+    RoundStatsRollingAverage_t()
+    {
+        Reset();
+    }
+
+    void Reset()
+    {
+        for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+        {
+            m_fStat[i] = 0;
+        }
+        m_numberOfDataSets = 0;
+    }
+
+    RoundStatsRollingAverage_t& operator +=( const RoundStatsRollingAverage_t &other )
+    {
+        for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+        {
+            m_fStat[i] += other.m_fStat[i];
+        }
+        return *this;
+    }
+
+    RoundStatsRollingAverage_t& operator +=( const StatsCollection_t &other )
+    {
+        for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+        {
+            m_fStat[i] += other[i];
+        }
+        return *this;
+    }
+
+    RoundStatsRollingAverage_t& operator /=( const float &divisor)
+    {
+        if (divisor > 0)
+        {
+            for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+            {
+                m_fStat[i] /= divisor;
+            }
+        }
+        return *this;
+    }
+
+    void RollDataSetIntoAverage ( const RoundStatsRollingAverage_t &other )
+    {
+        for ( int i = 0; i < ARRAYSIZE( m_fStat ); i++ )
+        {
+            m_fStat[i] *= m_numberOfDataSets;
+            m_fStat[i] += other.m_fStat[i];
+            m_fStat[i] /= (m_numberOfDataSets + 1);
+        }
+        m_numberOfDataSets++;
+    }
+};
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+enum CSGameStatsVersions_t
+{
+	CS_GAMESTATS_FILE_VERSION = 006,
+	CS_GAMESTATS_MAGIC = 0xDEADBEEF
+};
+
+struct CS_Gamestats_Version_t
+{
+	int m_iMagic;			// always CS_GAMESTATS_MAGIC
+	int m_iVersion;
+};
+
+
+struct KillStats_t
+{
+	KillStats_t() { Reset(); }
+
+	void Reset()
+	{
+		Q_memset( iNumKilled, 0, sizeof( iNumKilled ) );
+		Q_memset( iNumKilledBy, 0, sizeof( iNumKilledBy ) );
+		Q_memset( iNumKilledByUnanswered, 0, sizeof( iNumKilledByUnanswered ) );
+	}
+
+	int iNumKilled[MAX_PLAYERS+1];					// how many times this player has killed each other player
+	int iNumKilledBy[MAX_PLAYERS+1];				// how many times this player has been killed by each other player
+	int iNumKilledByUnanswered[MAX_PLAYERS+1];		// how many unanswered kills this player has been dealt by each other player
+};
+
+//=============================================================================
+//
+// CS Player Stats
+//
+struct PlayerStats_t
+{
+	PlayerStats_t()
+	{
+		Reset();
+	}
+
+	void Reset()
+	{
+		statsDelta.Reset();
+		statsCurrentRound.Reset();
+		statsCurrentMatch.Reset();
+		statsKills.Reset();
+	}
+
+	PlayerStats_t( const PlayerStats_t &other )
+	{
+		statsDelta			= other.statsDelta;
+		statsCurrentRound	= other.statsCurrentRound;
+		statsCurrentMatch	= other.statsCurrentMatch;
+	}
+
+	StatsCollection_t	statsDelta;
+	StatsCollection_t	statsCurrentRound;
+	StatsCollection_t	statsCurrentMatch;
+ 	KillStats_t		statsKills;
+};
+
+
+struct WeaponName_StatId
+{
+	CSWeaponID   weaponId;
+	CSStatType_t killStatId;
+	CSStatType_t shotStatId;
+	CSStatType_t hitStatId;
+	CSStatType_t damageStatId;
+};
+
+struct MapName_MapStatId
+{
+	const char* szMapName;
+	CSStatType_t statWinsId;
+	CSStatType_t statRoundsId;
+};
+
+extern const MapName_MapStatId MapName_StatId_Table[];
+
+//A mapping from weapon names to weapon stat IDs
+extern const WeaponName_StatId WeaponName_StatId_Table[];
+
+//Used to look up the appropriate entry by the ID of the actual weapon
+const WeaponName_StatId& GetWeaponTableEntryFromWeaponId(CSWeaponID id);
+
+#include "steamworks_gamestats.h"
+
+//=============================================================================
+//
+// Helper functions for creating key values
+//
+void AddDataToKV( KeyValues* pKV, const char* name, int data );
+void AddDataToKV( KeyValues* pKV, const char* name, uint64 data );
+void AddDataToKV( KeyValues* pKV, const char* name, float data );
+void AddDataToKV( KeyValues* pKV, const char* name, bool data );
+void AddDataToKV( KeyValues* pKV, const char* name, const char* data );
+void AddDataToKV( KeyValues* pKV, const char* name, const Color& data );
+void AddDataToKV( KeyValues* pKV, const char* name, short data );
+void AddDataToKV( KeyValues* pKV, const char* name, unsigned data );
+void AddDataToKV( KeyValues* pKV, const char* name, const Vector& data );
+void AddPositionDataToKV( KeyValues* pKV, const char* name, const Vector &data );
+//=============================================================================
+
+//=============================================================================
+//
+// Helper functions for creating key values from arrays
+//
+void AddArrayDataToKV( KeyValues* pKV, const char* name, const short *data, unsigned size );
+void AddArrayDataToKV( KeyValues* pKV, const char* name, const byte *data, unsigned size );
+void AddArrayDataToKV( KeyValues* pKV, const char* name, const unsigned *data, unsigned size );
+void AddStringDataToKV( KeyValues* pKV, const char* name, const char *data );
+
+//=============================================================================
+
+// Macros to ease the creation of SendData method for stats structs/classes
+#define BEGIN_STAT_TABLE( tableName ) \
+	static const char* GetStatTableName( void ) { return tableName; } \
+	void BuildGamestatDataTable( KeyValues* pKV ) \
+{ \
+	pKV->SetName( GetStatTableName() ); 
+
+#define REGISTER_STAT( varName ) \
+	AddDataToKV(pKV, #varName, varName);
+
+#define REGISTER_STAT_NAMED( varName, dbName ) \
+	AddDataToKV(pKV, dbName, varName);
+
+#define REGISTER_STAT_POSITION( varName ) \
+	AddPositionDataToKV(pKV, #varName, varName);
+
+#define REGISTER_STAT_POSITION_NAMED( varName, dbName ) \
+	AddPositionDataToKV(pKV, dbName, varName);
+
+#define REGISTER_STAT_ARRAY( varName ) \
+	AddArrayDataToKV( pKV, #varName, varName, ARRAYSIZE( varName ) );
+
+#define REGISTER_STAT_ARRAY_NAMED( varName, dbName ) \
+	AddArrayDataToKV( pKV, dbName, varName, ARRAYSIZE( varName ) );
+
+#define REGISTER_STAT_STRING( varName ) \
+	AddStringDataToKV( pKV, #varName, varName );
+
+#define REGISTER_STAT_STRING_NAMED( varName, dbName ) \
+	AddStringDataToKV( pKV, dbName, varName );
+
+#define AUTO_STAT_TABLE_KEY() \
+	pKV->SetInt( "TimeSubmitted", GetUniqueIDForStatTable( *this ) );
+
+#define END_STAT_TABLE() \
+	pKV->SetUint64( ::BaseStatData::m_bUseGlobalData ? "TimeSubmitted" : "SessionTime", ::BaseStatData::TimeSubmitted ); \
+	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKV ); \
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Templatized class for getting unique ID's for stat tables that need
+//			to be submitted multiple times per-session.
+//-----------------------------------------------------------------------------
+
+template < typename T >
+class UniqueStatID_t
+{
+public:
+	static unsigned GetNext( void )
+	{
+		return ++s_nLastID;
+	}
+
+	static void Reset( void )
+	{
+		s_nLastID = 0;
+	}
+
+private:
+	static unsigned s_nLastID;
+};
+
+template < typename T >
+unsigned UniqueStatID_t< T >::s_nLastID = 0;
+
+template < typename T >
+unsigned GetUniqueIDForStatTable( const T &table )
+{
+	return UniqueStatID_t< T >::GetNext();
+}
+
+
+//=============================================================================
+//
+// An interface for tracking gamestats.
+//
+class IGameStatTracker
+{
+public:
+
+	//-----------------------------------------------------------------------------
+	// Templatized methods to track a per-mission stat.
+	// The stat is copied, then deleted after it's sent to the SQL server.
+	//-----------------------------------------------------------------------------
+	template < typename T >
+	void SubmitStat( T& stat )
+	{
+		// Make a copy of the stat. All of the stat lists require pointers,
+		// so we need to protect against a stat allocated on the stack
+		T* pT = new T();
+		if( !pT )
+			return;
+
+		*pT = stat;
+		SubmitStat( pT );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Templatized methods to track a per-mission stat (by pointer)
+	// The stat is deleted after it's sent to the SQL server
+	//-----------------------------------------------------------------------------
+	template < typename T >
+	void SubmitStat( T* pStat )
+	{
+		// Get the static stat table for this type and add the stat to it
+		GetStatTable<T>()->AddToTail( pStat );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Add all stats to an existing key value file for submit.
+	//-----------------------------------------------------------------------------
+	virtual void SubmitGameStats( KeyValues *pKV ) = 0;
+
+	//-----------------------------------------------------------------------------
+	// Prints the memory usage of all of the stats being tracked
+	//-----------------------------------------------------------------------------
+	void PrintGamestatMemoryUsage( void );
+
+protected:
+	//=============================================================================
+	//
+	// Used as a base interface to store a list of all templatized stat containers
+	//
+	class IStatContainer
+	{
+	public:
+		virtual void SendData( KeyValues *pKV ) = 0;
+		virtual void Clear( void ) = 0;
+		virtual void PrintMemoryUsage( void ) = 0;
+	};
+
+	// Defines a list of stat containers.
+	typedef CUtlVector< IStatContainer* > StatContainerList_t;
+
+	//-----------------------------------------------------------------------------
+	// Used to get a list of all stats containers being tracked by the deriving class
+	//-----------------------------------------------------------------------------
+	virtual StatContainerList_t* GetStatContainerList( void ) = 0;
+
+private:
+
+	//=============================================================================
+	//
+	// Templatized list of stats submitted
+	//
+	template < typename T >
+	class CGameStatList : public IStatContainer, public CUtlVector< T* >
+	{
+	public:
+		//-----------------------------------------------------------------------------
+		// Get data ready to send to the SQL server
+		//-----------------------------------------------------------------------------
+		virtual void SendData( KeyValues *pKV )
+		{
+			//ASSERT( pKV != NULL );
+
+			// Duplicate the master KeyValue for each stat instance
+			for( int i=0; i < this->m_Size; ++i )
+			{
+				// Make a copy of the master key value and build the stat table
+				KeyValues *pKVCopy = this->operator [](i)->m_bUseGlobalData ? pKV->MakeCopy() : new KeyValues( "" );
+				this->operator [](i)->BuildGamestatDataTable( pKVCopy );
+			}
+
+			// Reset unique ID counter for the stat type
+			UniqueStatID_t< T >::Reset();
+		}
+
+		//-----------------------------------------------------------------------------
+		// Clear and delete every stat in this list
+		//-----------------------------------------------------------------------------
+		virtual void Clear( void )
+		{
+			this->PurgeAndDeleteElements();
+		}
+
+		//-----------------------------------------------------------------------------
+		// Print out details about this lists memory usage
+		//-----------------------------------------------------------------------------
+		virtual void PrintMemoryUsage( void )
+		{
+			if( this->m_Size == 0 )
+				return;
+
+			// Compute the memory used as the size of type times the list count
+			unsigned uMemoryUsed = this->m_Size * ( sizeof( T ) );
+
+			Msg( "	%d\tbytes used by %s table\n", uMemoryUsed, T::GetStatTableName() );
+		}
+	};
+
+	//-----------------------------------------------------------------------------
+	// Templatized method to get a single instance of a stat list per data type.
+	//-----------------------------------------------------------------------------
+	template < typename T >
+	CGameStatList< T >* GetStatTable( void )
+	{
+		static CGameStatList< T > *s_vecOfType = 0;
+		if( s_vecOfType == 0 )
+		{
+			s_vecOfType = new CGameStatList< T >();
+			GetStatContainerList()->AddToTail( s_vecOfType );
+		}
+		return s_vecOfType;
+	}
+
+};
+
+struct BaseStatData
+{
+	BaseStatData( bool bUseGlobalData = true ) : m_bUseGlobalData( bUseGlobalData )
+	{
+		TimeSubmitted = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
+	}
+
+	bool	m_bUseGlobalData;
+	uint64	TimeSubmitted;
+
+};
+
+extern ConVar sv_noroundstats;
+
+#endif // CS_GAMESTATS_SHARED_H
diff --git a/game/shared/cstrike/cs_player_shared.cpp b/game/shared/cstrike/cs_player_shared.cpp
new file mode 100644
index 00000000..e0f3d91d
--- /dev/null
+++ b/game/shared/cstrike/cs_player_shared.cpp
@@ -0,0 +1,943 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "decals.h"
+#include "cs_gamerules.h"
+#include "weapon_c4.h"
+#include "in_buttons.h"
+#include "datacache/imdlcache.h"
+
+#ifdef CLIENT_DLL
+	#include "c_cs_player.h"
+#else
+	#include "cs_player.h"
+	#include "soundent.h"
+	#include "bot/cs_bot.h"
+	#include "KeyValues.h"
+	#include "triggers.h"
+	#include "cs_gamestats.h"
+#endif
+
+#include "cs_playeranimstate.h"
+#include "basecombatweapon_shared.h"
+#include "util_shared.h"
+#include "takedamageinfo.h"
+#include "effect_dispatch_data.h"
+#include "engine/ivdebugoverlay.h"
+#include "obstacle_pushaway.h"
+#include "props_shared.h"
+
+ConVar sv_showimpacts("sv_showimpacts", "0", FCVAR_REPLICATED, "Shows client (red) and server (blue) bullet impact point (1=both, 2=client-only, 3=server-only)" );
+ConVar sv_showplayerhitboxes( "sv_showplayerhitboxes", "0", FCVAR_REPLICATED, "Show lag compensated hitboxes for the specified player index whenever a player fires." );
+
+#define	CS_MASK_SHOOT (MASK_SOLID|CONTENTS_DEBRIS)
+
+void DispatchEffect( const char *pName, const CEffectData &data );
+
+
+#ifdef _DEBUG
+
+	// This is some extra code to collect weapon accuracy stats:
+
+	struct bulletdata_s
+	{
+		float	timedelta;	// time delta since first shot of this round
+		float	derivation;	// derivation for first shoot view angle
+		int		count;
+	};
+
+	#define STATS_MAX_BULLETS	50
+
+	static bulletdata_s s_bullet_stats[STATS_MAX_BULLETS];
+
+	Vector	s_firstImpact = Vector(0,0,0);
+	float	s_firstTime = 0;
+	float	s_LastTime = 0;
+	int		s_bulletCount = 0;
+
+	void ResetBulletStats()
+	{
+		s_firstTime = 0;
+		s_LastTime = 0;
+		s_bulletCount = 0;
+		s_firstImpact = Vector(0,0,0);
+		Q_memset( s_bullet_stats, 0, sizeof(s_bullet_stats) );
+	}
+
+	void PrintBulletStats()
+	{
+		for (int i=0; i<STATS_MAX_BULLETS; i++ )
+		{
+			if (s_bullet_stats[i].count == 0)
+				break;
+
+			Msg("%3i;%3i;%.4f;%.4f\n", i, s_bullet_stats[i].count,
+				s_bullet_stats[i].timedelta, s_bullet_stats[i].derivation );
+		}
+	}
+
+	void AddBulletStat( float time, float dist, Vector &impact )
+	{
+		if ( time > s_LastTime + 2.0f )
+		{
+			// time delta since last shoot is bigger than 2 seconds, start new row
+			s_LastTime = s_firstTime = time;
+			s_bulletCount = 0;
+			s_firstImpact = impact;
+
+		}
+		else
+		{
+			s_LastTime = time;
+			s_bulletCount++;
+		}
+
+		if ( s_bulletCount >= STATS_MAX_BULLETS )
+			s_bulletCount = STATS_MAX_BULLETS -1;
+
+		if ( dist < 1 )
+			dist = 1;
+
+		int i = s_bulletCount;
+
+		float offset = VectorLength( s_firstImpact - impact );
+
+		float timedelta = time - s_firstTime;
+		float derivation = offset / dist;
+
+		float weight = (float)s_bullet_stats[i].count/(float)(s_bullet_stats[i].count+1);
+
+		s_bullet_stats[i].timedelta *= weight;
+		s_bullet_stats[i].timedelta += (1.0f-weight) * timedelta;
+
+		s_bullet_stats[i].derivation *= weight;
+		s_bullet_stats[i].derivation += (1.0f-weight) * derivation;
+
+		s_bullet_stats[i].count++;
+	}
+
+	CON_COMMAND( stats_bullets_reset, "Reset bullet stats")
+	{
+		ResetBulletStats();
+	}
+
+	CON_COMMAND( stats_bullets_print, "Print bullet stats")
+	{
+		PrintBulletStats();
+	}
+
+#endif
+
+float CCSPlayer::GetPlayerMaxSpeed()
+{
+	if ( GetMoveType() == MOVETYPE_NONE )
+	{
+		return CS_PLAYER_SPEED_STOPPED;
+	}
+
+	if ( IsObserver() )
+	{
+		// Player gets speed bonus in observer mode
+		return CS_PLAYER_SPEED_OBSERVER;
+	}
+
+	bool bValidMoveState = ( State_Get() == STATE_ACTIVE || State_Get() == STATE_OBSERVER_MODE );
+	if ( !bValidMoveState || m_bIsDefusing || CSGameRules()->IsFreezePeriod() )
+	{
+		// Player should not move during the freeze period
+		return CS_PLAYER_SPEED_STOPPED;
+	}
+
+	float speed = BaseClass::GetPlayerMaxSpeed();
+
+	if ( IsVIP() == true )  // VIP is slow due to the armour he's wearing
+	{
+		speed = MIN(speed, CS_PLAYER_SPEED_VIP);
+	}
+	else
+	{
+
+		CWeaponCSBase *pWeapon = dynamic_cast<CWeaponCSBase*>( GetActiveWeapon() );
+
+		if ( pWeapon )
+		{
+			if ( HasShield() && IsShieldDrawn() )
+			{
+				speed = MIN(speed, CS_PLAYER_SPEED_SHIELD);
+			}
+			else
+			{
+				speed = MIN(speed, pWeapon->GetMaxSpeed());
+			}
+		}
+	}
+
+	return speed;
+}
+
+
+void CCSPlayer::GetBulletTypeParameters(
+	int iBulletType,
+	float &fPenetrationPower,
+	float &flPenetrationDistance )
+{
+	//MIKETODO: make ammo types come from a script file.
+	if ( IsAmmoType( iBulletType, BULLET_PLAYER_50AE ) )
+	{
+		fPenetrationPower = 30;
+		flPenetrationDistance = 1000.0;
+	}
+	else if ( IsAmmoType( iBulletType, BULLET_PLAYER_762MM ) )
+	{
+		fPenetrationPower = 39;
+		flPenetrationDistance = 5000.0;
+	}
+	else if ( IsAmmoType( iBulletType, BULLET_PLAYER_556MM ) ||
+			  IsAmmoType( iBulletType, BULLET_PLAYER_556MM_BOX ) )
+	{
+		fPenetrationPower = 35;
+		flPenetrationDistance = 4000.0;
+	}
+	else if ( IsAmmoType( iBulletType, BULLET_PLAYER_338MAG ) )
+	{
+		fPenetrationPower = 45;
+		flPenetrationDistance = 8000.0;
+	}
+	else if ( IsAmmoType( iBulletType, BULLET_PLAYER_9MM ) )
+	{
+		fPenetrationPower = 21;
+		flPenetrationDistance = 800.0;
+	}
+	else if ( IsAmmoType( iBulletType, BULLET_PLAYER_BUCKSHOT ) )
+	{
+		fPenetrationPower = 0;
+		flPenetrationDistance = 0.0;
+	}
+	else if ( IsAmmoType( iBulletType, BULLET_PLAYER_45ACP ) )
+	{
+		fPenetrationPower = 15;
+		flPenetrationDistance = 500.0;
+	}
+	else if ( IsAmmoType( iBulletType, BULLET_PLAYER_357SIG ) )
+	{
+		fPenetrationPower = 25;
+		flPenetrationDistance = 800.0;
+	}
+	else if ( IsAmmoType( iBulletType, BULLET_PLAYER_57MM ) )
+	{
+		fPenetrationPower = 30;
+		flPenetrationDistance = 2000.0;
+	}
+	else
+	{
+		// What kind of ammo is this?
+		Assert( false );
+		fPenetrationPower = 0;
+		flPenetrationDistance = 0.0;
+	}
+}
+
+static void GetMaterialParameters( int iMaterial, float &flPenetrationModifier, float &flDamageModifier )
+{
+	switch ( iMaterial )
+	{
+		case CHAR_TEX_METAL :
+			flPenetrationModifier = 0.5;  // If we hit metal, reduce the thickness of the brush we can't penetrate
+			flDamageModifier = 0.3;
+			break;
+		case CHAR_TEX_DIRT :
+			flPenetrationModifier = 0.5;
+			flDamageModifier = 0.3;
+			break;
+		case CHAR_TEX_CONCRETE :
+			flPenetrationModifier = 0.4;
+			flDamageModifier = 0.25;
+			break;
+		case CHAR_TEX_GRATE	:
+			flPenetrationModifier = 1.0;
+			flDamageModifier = 0.99;
+			break;
+		case CHAR_TEX_VENT :
+			flPenetrationModifier = 0.5;
+			flDamageModifier = 0.45;
+			break;
+		case CHAR_TEX_TILE :
+			flPenetrationModifier = 0.65;
+			flDamageModifier = 0.3;
+			break;
+		case CHAR_TEX_COMPUTER :
+			flPenetrationModifier = 0.4;
+			flDamageModifier = 0.45;
+			break;
+		case CHAR_TEX_WOOD :
+			flPenetrationModifier = 1.0;
+			flDamageModifier = 0.6;
+			break;
+		default :
+			flPenetrationModifier = 1.0;
+			flDamageModifier = 0.5;
+			break;
+	}
+
+	Assert( flPenetrationModifier > 0 );
+	Assert( flDamageModifier < 1.0f ); // Less than 1.0f for avoiding infinite loops
+}
+
+
+static bool TraceToExit(Vector &start, Vector &dir, Vector &end, float flStepSize, float flMaxDistance )
+{
+	float flDistance = 0;
+	Vector last = start;
+
+	while ( flDistance <= flMaxDistance )
+	{
+		flDistance += flStepSize;
+
+		end = start + flDistance *dir;
+
+		if ( (UTIL_PointContents ( end ) & MASK_SOLID) == 0 )
+		{
+			// found first free point
+			return true;
+		}
+	}
+
+	return false;
+}
+
+inline void UTIL_TraceLineIgnoreTwoEntities( const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask,
+					 const IHandleEntity *ignore, const IHandleEntity *ignore2, int collisionGroup, trace_t *ptr )
+{
+	Ray_t ray;
+	ray.Init( vecAbsStart, vecAbsEnd );
+	CTraceFilterSkipTwoEntities traceFilter( ignore, ignore2, collisionGroup );
+	enginetrace->TraceRay( ray, mask, &traceFilter, ptr );
+	if( r_visualizetraces.GetBool() )
+	{
+		DebugDrawLine( ptr->startpos, ptr->endpos, 255, 0, 0, true, -1.0f );
+	}
+}
+
+void CCSPlayer::FireBullet(
+	Vector vecSrc,	// shooting postion
+	const QAngle &shootAngles,  //shooting angle
+	float flDistance, // max distance
+	int iPenetration, // how many obstacles can be penetrated
+	int iBulletType, // ammo type
+	int iDamage, // base damage
+	float flRangeModifier, // damage range modifier
+	CBaseEntity *pevAttacker, // shooter
+	bool bDoEffects,
+	float xSpread, float ySpread
+	)
+{
+	float fCurrentDamage = iDamage;   // damage of the bullet at it's current trajectory
+	float flCurrentDistance = 0.0;  //distance that the bullet has traveled so far
+
+	Vector vecDirShooting, vecRight, vecUp;
+	AngleVectors( shootAngles, &vecDirShooting, &vecRight, &vecUp );
+
+	// MIKETODO: put all the ammo parameters into a script file and allow for CS-specific params.
+	float flPenetrationPower = 0;		// thickness of a wall that this bullet can penetrate
+	float flPenetrationDistance = 0;	// distance at which the bullet is capable of penetrating a wall
+	float flDamageModifier = 0.5;		// default modification of bullets power after they go through a wall.
+	float flPenetrationModifier = 1.f;
+
+	GetBulletTypeParameters( iBulletType, flPenetrationPower, flPenetrationDistance );
+
+
+	if ( !pevAttacker )
+		pevAttacker = this;  // the default attacker is ourselves
+
+	// add the spray
+	Vector vecDir = vecDirShooting + xSpread * vecRight + ySpread * vecUp;
+
+	VectorNormalize( vecDir );
+
+	//Adrian: visualize server/client player positions
+	//This is used to show where the lag compesator thinks the player should be at.
+#if 0
+	for ( int k = 1; k <= gpGlobals->maxClients; k++ )
+	{
+		CBasePlayer *clientClass = (CBasePlayer *)CBaseEntity::Instance( k );
+
+		if ( clientClass == NULL )
+			 continue;
+
+		if ( k == entindex() )
+			 continue;
+
+#ifdef CLIENT_DLL
+		debugoverlay->AddBoxOverlay( clientClass->GetAbsOrigin(), clientClass->WorldAlignMins(), clientClass->WorldAlignMaxs(), QAngle( 0, 0, 0), 255,0,0,127, 4 );
+#else
+		NDebugOverlay::Box( clientClass->GetAbsOrigin(), clientClass->WorldAlignMins(), clientClass->WorldAlignMaxs(), 0,0,255,127, 4 );
+#endif
+
+	}
+
+#endif
+
+
+//=============================================================================
+// HPE_BEGIN:
+//=============================================================================
+
+#ifndef CLIENT_DLL
+	// [pfreese] Track number player entities killed with this bullet
+	int iPenetrationKills = 0;
+
+	// [menglish] Increment the shots fired for this player
+	CCS_GameStats.Event_ShotFired( this, GetActiveWeapon() );
+#endif
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+	bool bFirstHit = true;
+
+	CBasePlayer *lastPlayerHit = NULL;
+
+	if( sv_showplayerhitboxes.GetInt() > 0 )
+	{
+		CBasePlayer *lagPlayer = UTIL_PlayerByIndex( sv_showplayerhitboxes.GetInt() );
+		if( lagPlayer )
+		{
+#ifdef CLIENT_DLL
+			lagPlayer->DrawClientHitboxes(4, true);
+#else
+			lagPlayer->DrawServerHitboxes(4, true);
+#endif
+		}
+	}
+
+	MDLCACHE_CRITICAL_SECTION();
+	while ( fCurrentDamage > 0 )
+	{
+		Vector vecEnd = vecSrc + vecDir * flDistance;
+
+		trace_t tr; // main enter bullet trace
+
+		UTIL_TraceLineIgnoreTwoEntities( vecSrc, vecEnd, CS_MASK_SHOOT|CONTENTS_HITBOX, this, lastPlayerHit, COLLISION_GROUP_NONE, &tr );
+		{
+			CTraceFilterSkipTwoEntities filter( this, lastPlayerHit, COLLISION_GROUP_NONE );
+
+			// Check for player hitboxes extending outside their collision bounds
+			const float rayExtension = 40.0f;
+			UTIL_ClipTraceToPlayers( vecSrc, vecEnd + vecDir * rayExtension, CS_MASK_SHOOT|CONTENTS_HITBOX, &filter, &tr );
+		}
+
+		lastPlayerHit = ToBasePlayer(tr.m_pEnt);
+
+		if ( tr.fraction == 1.0f )
+			break; // we didn't hit anything, stop tracing shoot
+
+#ifdef _DEBUG
+		if ( bFirstHit )
+			AddBulletStat( gpGlobals->realtime, VectorLength( vecSrc-tr.endpos), tr.endpos );
+#endif
+
+		bFirstHit = false;
+
+#ifndef CLIENT_DLL
+		//
+		// Propogate a bullet impact event
+		// @todo Add this for shotgun pellets (which dont go thru here)
+		//
+		IGameEvent * event = gameeventmanager->CreateEvent( "bullet_impact" );
+		if ( event )
+		{
+			event->SetInt( "userid", GetUserID() );
+			event->SetFloat( "x", tr.endpos.x );
+			event->SetFloat( "y", tr.endpos.y );
+			event->SetFloat( "z", tr.endpos.z );
+			gameeventmanager->FireEvent( event );
+		}
+#endif
+
+		/************* MATERIAL DETECTION ***********/
+		surfacedata_t *pSurfaceData = physprops->GetSurfaceData( tr.surface.surfaceProps );
+		int iEnterMaterial = pSurfaceData->game.material;
+
+		GetMaterialParameters( iEnterMaterial, flPenetrationModifier, flDamageModifier );
+
+		bool hitGrate = tr.contents & CONTENTS_GRATE;
+
+		// since some railings in de_inferno are CONTENTS_GRATE but CHAR_TEX_CONCRETE, we'll trust the
+		// CONTENTS_GRATE and use a high damage modifier.
+		if ( hitGrate )
+		{
+			// If we're a concrete grate (TOOLS/TOOLSINVISIBLE texture) allow more penetrating power.
+			flPenetrationModifier = 1.0f;
+			flDamageModifier = 0.99f;
+		}
+
+#ifdef CLIENT_DLL
+		if ( sv_showimpacts.GetInt() == 1 || sv_showimpacts.GetInt() == 2 )
+		{
+			// draw red client impact markers
+			debugoverlay->AddBoxOverlay( tr.endpos, Vector(-2,-2,-2), Vector(2,2,2), QAngle( 0, 0, 0), 255,0,0,127, 4 );
+
+			if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
+			{
+				C_BasePlayer *player = ToBasePlayer( tr.m_pEnt );
+				player->DrawClientHitboxes( 4, true );
+			}
+		}
+#else
+		if ( sv_showimpacts.GetInt() == 1 || sv_showimpacts.GetInt() == 3 )
+		{
+			// draw blue server impact markers
+			NDebugOverlay::Box( tr.endpos, Vector(-2,-2,-2), Vector(2,2,2), 0,0,255,127, 4 );
+
+			if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
+			{
+				CBasePlayer *player = ToBasePlayer( tr.m_pEnt );
+				player->DrawServerHitboxes( 4, true );
+			}
+		}
+#endif
+
+		//calculate the damage based on the distance the bullet travelled.
+		flCurrentDistance += tr.fraction * flDistance;
+		fCurrentDamage *= pow (flRangeModifier, (flCurrentDistance / 500));
+
+		// check if we reach penetration distance, no more penetrations after that
+		if (flCurrentDistance > flPenetrationDistance && iPenetration > 0)
+			iPenetration = 0;
+
+#ifndef CLIENT_DLL
+		// This just keeps track of sounds for AIs (it doesn't play anything).
+		CSoundEnt::InsertSound( SOUND_BULLET_IMPACT, tr.endpos, 400, 0.2f, this );
+#endif
+
+		int iDamageType = DMG_BULLET | DMG_NEVERGIB;
+
+		if( bDoEffects )
+		{
+			// See if the bullet ended up underwater + started out of the water
+			if ( enginetrace->GetPointContents( tr.endpos ) & (CONTENTS_WATER|CONTENTS_SLIME) )
+			{
+				trace_t waterTrace;
+				UTIL_TraceLine( vecSrc, tr.endpos, (MASK_SHOT|CONTENTS_WATER|CONTENTS_SLIME), this, COLLISION_GROUP_NONE, &waterTrace );
+
+				if( waterTrace.allsolid != 1 )
+				{
+					CEffectData	data;
+ 					data.m_vOrigin = waterTrace.endpos;
+					data.m_vNormal = waterTrace.plane.normal;
+					data.m_flScale = random->RandomFloat( 8, 12 );
+
+					if ( waterTrace.contents & CONTENTS_SLIME )
+					{
+						data.m_fFlags |= FX_WATER_IN_SLIME;
+					}
+
+					DispatchEffect( "gunshotsplash", data );
+				}
+			}
+			else
+			{
+				//Do Regular hit effects
+
+				// Don't decal nodraw surfaces
+				if ( !( tr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) ) )
+				{
+					CBaseEntity *pEntity = tr.m_pEnt;
+					if ( !( !friendlyfire.GetBool() && pEntity && pEntity->GetTeamNumber() == GetTeamNumber() ) )
+					{
+						UTIL_ImpactTrace( &tr, iDamageType );
+					}
+				}
+			}
+		} // bDoEffects
+
+		// add damage to entity that we hit
+
+#ifndef CLIENT_DLL
+		ClearMultiDamage();
+
+		//=============================================================================
+		// HPE_BEGIN:
+		// [pfreese] Check if enemy players were killed by this bullet, and if so,
+		// add them to the iPenetrationKills count
+		//=============================================================================
+		
+		CBaseEntity *pEntity = tr.m_pEnt;
+
+		CTakeDamageInfo info( pevAttacker, pevAttacker, fCurrentDamage, iDamageType );
+		CalculateBulletDamageForce( &info, iBulletType, vecDir, tr.endpos );
+		pEntity->DispatchTraceAttack( info, vecDir, &tr );
+
+		bool bWasAlive = pEntity->IsAlive();
+
+		TraceAttackToTriggers( info, tr.startpos, tr.endpos, vecDir );
+
+		ApplyMultiDamage();
+
+		if (bWasAlive && !pEntity->IsAlive() && pEntity->IsPlayer() && pEntity->GetTeamNumber() != GetTeamNumber())
+		{
+			++iPenetrationKills;
+		}
+		
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+
+#endif
+
+		// check if bullet can penetrate another entity
+		if ( iPenetration == 0 && !hitGrate )
+			break; // no, stop
+
+		// If we hit a grate with iPenetration == 0, stop on the next thing we hit
+		if ( iPenetration < 0 )
+			break;
+
+		Vector penetrationEnd;
+
+		// try to penetrate object, maximum penetration is 128 inch
+		if ( !TraceToExit( tr.endpos, vecDir, penetrationEnd, 24, 128 ) )
+			break;
+
+		// find exact penetration exit
+		trace_t exitTr;
+		UTIL_TraceLine( penetrationEnd, tr.endpos, CS_MASK_SHOOT|CONTENTS_HITBOX, NULL, &exitTr );
+
+		if( exitTr.m_pEnt != tr.m_pEnt && exitTr.m_pEnt != NULL )
+		{
+			// something was blocking, trace again
+			UTIL_TraceLine( penetrationEnd, tr.endpos, CS_MASK_SHOOT|CONTENTS_HITBOX, exitTr.m_pEnt, COLLISION_GROUP_NONE, &exitTr );
+		}
+
+		// get material at exit point
+		pSurfaceData = physprops->GetSurfaceData( exitTr.surface.surfaceProps );
+		int iExitMaterial = pSurfaceData->game.material;
+
+		hitGrate = hitGrate && ( exitTr.contents & CONTENTS_GRATE );
+
+		// if enter & exit point is wood or metal we assume this is
+		// a hollow crate or barrel and give a penetration bonus
+		if ( iEnterMaterial == iExitMaterial )
+		{
+			if( iExitMaterial == CHAR_TEX_WOOD ||
+				iExitMaterial == CHAR_TEX_METAL )
+			{
+				flPenetrationModifier *= 2;
+			}
+		}
+
+		float flTraceDistance = VectorLength( exitTr.endpos - tr.endpos );
+
+		// check if bullet has enough power to penetrate this distance for this material
+		if ( flTraceDistance > ( flPenetrationPower * flPenetrationModifier ) )
+			break; // bullet hasn't enough power to penetrate this distance
+
+		// penetration was successful
+
+		// bullet did penetrate object, exit Decal
+		if ( bDoEffects )
+		{
+			UTIL_ImpactTrace( &exitTr, iDamageType );
+		}
+
+		//setup new start end parameters for successive trace
+
+		flPenetrationPower -= flTraceDistance / flPenetrationModifier;
+		flCurrentDistance += flTraceDistance;
+
+		// NDebugOverlay::Box( exitTr.endpos, Vector(-2,-2,-2), Vector(2,2,2), 0,255,0,127, 8 );
+
+		vecSrc = exitTr.endpos;
+		flDistance = (flDistance - flCurrentDistance) * 0.5;
+
+		// reduce damage power each time we hit something other than a grate
+		fCurrentDamage *= flDamageModifier;
+
+		// reduce penetration counter
+		iPenetration--;
+	}
+
+#ifndef CLIENT_DLL
+	//=============================================================================
+	// HPE_BEGIN:
+	// [pfreese] If we killed at least two enemies with a single bullet, award the
+	// TWO_WITH_ONE_SHOT achievement
+	//=============================================================================
+	
+	if (iPenetrationKills >= 2)
+	{
+		AwardAchievement(CSKillTwoWithOneShot);
+	}
+	
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+#endif
+}
+
+
+void CCSPlayer::UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity  )
+{
+	float speedSqr = vecVelocity.AsVector2D().LengthSqr();
+
+	// the fastest walk is 135 ( scout ), see CCSGameMovement::CheckParameters()
+	if ( speedSqr < 150.0 * 150.0 ) 
+		return; // player is not running, no footsteps
+
+	BaseClass::UpdateStepSound( psurface, vecOrigin, vecVelocity  );
+}
+
+
+// GOOSEMAN : Kick the view..
+void CCSPlayer::KickBack( float up_base, float lateral_base, float up_modifier, float lateral_modifier, float up_max, float lateral_max, int direction_change )
+{
+	float flKickUp;
+	float flKickLateral;
+
+	if (m_iShotsFired == 1) // This is the first round fired
+	{
+		flKickUp = up_base;
+		flKickLateral = lateral_base;
+	}
+	else
+	{
+		flKickUp = up_base + m_iShotsFired*up_modifier;
+		flKickLateral = lateral_base + m_iShotsFired*lateral_modifier;
+	}
+
+
+	QAngle angle = GetPunchAngle();
+
+	angle.x -= flKickUp;
+	if ( angle.x < -1 * up_max )
+		angle.x = -1 * up_max;
+
+	if ( m_iDirection == 1 )
+	{
+		angle.y += flKickLateral;
+		if (angle.y > lateral_max)
+			angle.y = lateral_max;
+	}
+	else
+	{
+		angle.y -= flKickLateral;
+		if ( angle.y < -1 * lateral_max )
+			angle.y = -1 * lateral_max;
+	}
+
+	if ( !SharedRandomInt( "KickBack", 0, direction_change ) )
+		m_iDirection = 1 - m_iDirection;
+
+	SetPunchAngle( angle );
+}
+
+
+bool CCSPlayer::CanMove() const
+{
+	// When we're in intro camera mode, it's important to return false here
+	// so our physics object doesn't fall out of the world.
+	if ( GetMoveType() == MOVETYPE_NONE )
+		return false;
+
+	if ( IsObserver() )
+		return true; // observers can move all the time
+
+	bool bValidMoveState = (State_Get() == STATE_ACTIVE || State_Get() == STATE_OBSERVER_MODE);
+
+	if ( m_bIsDefusing || !bValidMoveState || CSGameRules()->IsFreezePeriod() )
+	{
+		return false;
+	}
+	else
+	{
+		// Can't move while planting C4.
+		CC4 *pC4 = dynamic_cast< CC4* >( GetActiveWeapon() );
+		if ( pC4 && pC4->m_bStartedArming )
+			return false;
+
+		return true;
+	}
+}
+
+
+void CCSPlayer::OnJump( float fImpulse )
+{
+	CWeaponCSBase* pActiveWeapon = GetActiveCSWeapon();
+	if ( pActiveWeapon != NULL )
+		pActiveWeapon->OnJump(fImpulse);
+}
+
+
+void CCSPlayer::OnLand( float fVelocity )
+{
+	CWeaponCSBase* pActiveWeapon = GetActiveCSWeapon();
+	if ( pActiveWeapon != NULL )
+		pActiveWeapon->OnLand(fVelocity);
+}
+
+
+//-------------------------------------------------------------------------------------------------------------------------------
+/**
+* Track the last time we were on a ladder, along with the ladder's normal and where we
+* were grabbing it, so we don't reach behind us and grab it again as we are trying to
+* dismount.
+*/
+void CCSPlayer::SurpressLadderChecks( const Vector& pos, const Vector& normal )
+{
+	m_ladderSurpressionTimer.Start( 1.0f );
+	m_lastLadderPos = pos;
+	m_lastLadderNormal = normal;
+}
+
+
+//-------------------------------------------------------------------------------------------------------------------------------
+/**
+* Prevent us from re-grabbing the same ladder we were just on:
+*  - if the timer is elapsed, let us grab again
+*  - if the normal is different, let us grab
+*  - if the 2D pos is very different, let us grab, since it's probably a different ladder
+*/
+bool CCSPlayer::CanGrabLadder( const Vector& pos, const Vector& normal )
+{
+	if ( m_ladderSurpressionTimer.GetRemainingTime() <= 0.0f )
+	{
+		return true;
+	}
+
+	const float MaxDist = 64.0f;
+	if ( pos.AsVector2D().DistToSqr( m_lastLadderPos.AsVector2D() ) < MaxDist * MaxDist )
+	{
+		return false;
+	}
+
+	if ( normal != m_lastLadderNormal )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+void CCSPlayer::SetAnimation( PLAYER_ANIM playerAnim )
+{
+	// In CS, its CPlayerAnimState object manages ALL the animation state.
+	return;
+}
+
+
+CWeaponCSBase* CCSPlayer::CSAnim_GetActiveWeapon()
+{
+	return GetActiveCSWeapon();
+}
+
+
+bool CCSPlayer::CSAnim_CanMove()
+{
+	return CanMove();
+}
+
+//--------------------------------------------------------------------------------------------------------------
+
+#define MATERIAL_NAME_LENGTH 16
+
+#ifdef GAME_DLL
+
+class CFootstepControl : public CBaseTrigger
+{
+public:
+	DECLARE_CLASS( CFootstepControl, CBaseTrigger );
+	DECLARE_DATADESC();
+	DECLARE_SERVERCLASS();
+
+	virtual int UpdateTransmitState( void );
+	virtual void Spawn( void );
+
+	CNetworkVar( string_t, m_source );
+	CNetworkVar( string_t, m_destination );
+};
+
+LINK_ENTITY_TO_CLASS( func_footstep_control, CFootstepControl );
+
+
+BEGIN_DATADESC( CFootstepControl )
+	DEFINE_KEYFIELD( m_source, FIELD_STRING, "Source" ),
+	DEFINE_KEYFIELD( m_destination, FIELD_STRING, "Destination" ),
+END_DATADESC()
+
+IMPLEMENT_SERVERCLASS_ST( CFootstepControl, DT_FootstepControl )
+	SendPropStringT( SENDINFO(m_source) ),
+	SendPropStringT( SENDINFO(m_destination) ),
+END_SEND_TABLE()
+
+int CFootstepControl::UpdateTransmitState( void )
+{
+	return SetTransmitState( FL_EDICT_ALWAYS );
+}
+
+void CFootstepControl::Spawn( void )
+{
+	InitTrigger();
+}
+
+#else
+
+//--------------------------------------------------------------------------------------------------------------
+
+class C_FootstepControl : public C_BaseEntity
+{
+public:
+	DECLARE_CLASS( C_FootstepControl, C_BaseEntity );
+	DECLARE_CLIENTCLASS();
+
+	C_FootstepControl( void );
+	~C_FootstepControl();
+
+	char m_source[MATERIAL_NAME_LENGTH];
+	char m_destination[MATERIAL_NAME_LENGTH];
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_FootstepControl, DT_FootstepControl, CFootstepControl)
+	RecvPropString( RECVINFO(m_source) ),
+	RecvPropString( RECVINFO(m_destination) ),
+END_RECV_TABLE()
+
+CUtlVector< C_FootstepControl * > s_footstepControllers;
+
+C_FootstepControl::C_FootstepControl( void )
+{
+	s_footstepControllers.AddToTail( this );
+}
+
+C_FootstepControl::~C_FootstepControl()
+{
+	s_footstepControllers.FindAndRemove( this );
+}
+
+surfacedata_t * CCSPlayer::GetFootstepSurface( const Vector &origin, const char *surfaceName )
+{
+	for ( int i=0; i<s_footstepControllers.Count(); ++i )
+	{
+		C_FootstepControl *control = s_footstepControllers[i];
+
+		if ( FStrEq( control->m_source, surfaceName ) )
+		{
+			if ( control->CollisionProp()->IsPointInBounds( origin ) )
+			{
+				return physprops->GetSurfaceData( physprops->GetSurfaceIndex( control->m_destination ) );
+			}
+		}
+	}
+
+	return physprops->GetSurfaceData( physprops->GetSurfaceIndex( surfaceName ) );
+}
+
+#endif
+
+
diff --git a/game/shared/cstrike/cs_playeranimstate.cpp b/game/shared/cstrike/cs_playeranimstate.cpp
new file mode 100644
index 00000000..19c3a184
--- /dev/null
+++ b/game/shared/cstrike/cs_playeranimstate.cpp
@@ -0,0 +1,1057 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_playeranimstate.h"
+#include "base_playeranimstate.h"
+#include "tier0/vprof.h"
+#include "animation.h"
+#include "weapon_csbase.h"
+#include "studio.h"
+#include "apparent_velocity_helper.h"
+#include "utldict.h"
+#include "weapon_basecsgrenade.h"
+#include "datacache/imdlcache.h"
+
+#ifdef CLIENT_DLL
+	#include "c_cs_player.h"
+	#include "bone_setup.h"
+	#include "interpolatedvar.h"
+	#include "c_cs_hostage.h"
+#else
+	#include "cs_player.h"
+	#include "cs_simple_hostage.h"
+	#include "cs_gamestats.h"
+#endif
+
+#define ANIM_TOPSPEED_WALK			100
+#define ANIM_TOPSPEED_RUN			250
+#define ANIM_TOPSPEED_RUN_CROUCH	85
+
+#define DEFAULT_IDLE_NAME "idle_upper_"
+#define DEFAULT_CROUCH_IDLE_NAME "crouch_idle_upper_"
+#define DEFAULT_CROUCH_WALK_NAME "crouch_walk_upper_"
+#define DEFAULT_WALK_NAME "walk_upper_"
+#define DEFAULT_RUN_NAME "run_upper_"
+
+#define DEFAULT_FIRE_IDLE_NAME "idle_shoot_"
+#define DEFAULT_FIRE_CROUCH_NAME "crouch_idle_shoot_"
+#define DEFAULT_FIRE_CROUCH_WALK_NAME "crouch_walk_shoot_"
+#define DEFAULT_FIRE_WALK_NAME "walk_shoot_"
+#define DEFAULT_FIRE_RUN_NAME "run_shoot_"
+
+
+#define FIRESEQUENCE_LAYER		(AIMSEQUENCE_LAYER+NUM_AIMSEQUENCE_LAYERS+1)
+#define RELOADSEQUENCE_LAYER	(FIRESEQUENCE_LAYER + 1)
+#define GRENADESEQUENCE_LAYER	(RELOADSEQUENCE_LAYER + 1)
+#define NUM_LAYERS_WANTED		(GRENADESEQUENCE_LAYER + 1)
+
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CCSPlayerAnimState declaration.
+// ------------------------------------------------------------------------------------------------ //
+
+class CCSPlayerAnimState : public CBasePlayerAnimState, public ICSPlayerAnimState
+{
+public:
+	DECLARE_CLASS( CCSPlayerAnimState, CBasePlayerAnimState );
+	friend ICSPlayerAnimState* CreatePlayerAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences );
+
+	CCSPlayerAnimState();
+
+	virtual void DoAnimationEvent( PlayerAnimEvent_t event, int nData );
+	virtual bool IsThrowingGrenade();
+	virtual int CalcAimLayerSequence( float *flCycle, float *flAimSequenceWeight, bool bForceIdle );
+	virtual void ClearAnimationState();
+	virtual bool CanThePlayerMove();
+	virtual float GetCurrentMaxGroundSpeed();
+	virtual Activity CalcMainActivity();
+	virtual void DebugShowAnimState( int iStartLine );
+	virtual void ComputeSequences( CStudioHdr *pStudioHdr );
+	virtual void ClearAnimationLayers();
+	virtual int SelectWeightedSequence( Activity activity );
+
+	void InitCS( CBaseAnimatingOverlay *pPlayer, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences );
+	
+protected:
+
+	int CalcFireLayerSequence(PlayerAnimEvent_t event);
+	void ComputeFireSequence( CStudioHdr *pStudioHdr );
+
+	void ComputeReloadSequence( CStudioHdr *pStudioHdr );
+	int CalcReloadLayerSequence( PlayerAnimEvent_t event );
+
+	bool IsOuterGrenadePrimed();
+	void ComputeGrenadeSequence( CStudioHdr *pStudioHdr );
+	int CalcGrenadePrimeSequence();
+	int CalcGrenadeThrowSequence();
+	int GetOuterGrenadeThrowCounter();
+
+	const char* GetWeaponSuffix();
+	bool HandleJumping();
+
+	void UpdateLayerSequenceGeneric( CStudioHdr *pStudioHdr, int iLayer, bool &bEnabled, float &flCurCycle, int &iSequence, bool bWaitAtEnd );
+
+	virtual int CalcSequenceIndex( const char *pBaseName, ... );
+
+private:
+
+	// Current state variables.
+	bool m_bJumping;			// Set on a jump event.
+	float m_flJumpStartTime;
+	bool m_bFirstJumpFrame;
+
+	// Aim sequence plays reload while this is on.
+	bool m_bReloading;
+	float m_flReloadCycle;
+	int m_iReloadSequence;
+	float m_flReloadHoldEndTime;	// Intermediate shotgun reloads get held a fraction of a second
+
+	// This is set to true if ANY animation is being played in the fire layer.
+	bool m_bFiring;						// If this is on, then it'll continue the fire animation in the fire layer
+										// until it completes.
+	int m_iFireSequence;				// (For any sequences in the fire layer, including grenade throw).
+	float m_flFireCycle;
+	PlayerAnimEvent_t m_delayedFire;	// if we fire while reloading, delay the fire by one frame so we can cancel the reload first
+
+	// These control grenade animations.
+	bool m_bThrowingGrenade;
+	bool m_bPrimingGrenade;
+	float m_flGrenadeCycle;
+	int m_iGrenadeSequence;
+	int m_iLastThrowGrenadeCounter;	// used to detect when the guy threw the grenade.
+
+	CCSPlayer *m_pPlayer;
+
+	ICSPlayerAnimStateHelpers *m_pHelpers;
+
+	void CheckCachedSequenceValidity( void );
+
+	int m_sequenceCache[ ACT_CROUCHIDLE+1 ];	// Cache the first N sequences, since we don't have weights.
+	int m_cachedModelIndex;						// Model index for which the sequence cache is valid.
+
+	CUtlDict<int,int> m_namedSequence;			// Dictionary of sequences computed with CalcSequenceIndex.  This is because LookupSequence is a performance hit - CS:S player models have 750+ sequences!
+};
+
+
+ICSPlayerAnimState* CreatePlayerAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences )
+{
+	CCSPlayerAnimState *pRet = new CCSPlayerAnimState;
+	pRet->InitCS( pEntity, pHelpers, legAnimType, bUseAimSequences );
+	return pRet;
+}
+
+
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Hostage animation mechanism
+ */
+class CCSHostageAnimState : public CCSPlayerAnimState
+{
+public:
+	DECLARE_CLASS( CCSHostageAnimState, CCSPlayerAnimState );
+
+	CCSHostageAnimState();
+
+	virtual Activity CalcMainActivity();
+
+	// No need to cache sequences, and we *do* have multiple sequences per activity
+	virtual int SelectWeightedSequence( Activity activity ) { return GetOuter()->SelectWeightedSequence( activity ); }
+};
+
+
+//----------------------------------------------------------------------------------------------
+ICSPlayerAnimState* CreateHostageAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences )
+{
+	CCSHostageAnimState *anim = new CCSHostageAnimState;
+	anim->InitCS( pEntity, pHelpers, legAnimType, bUseAimSequences );
+	return anim;
+}
+
+
+//----------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------
+CCSHostageAnimState::CCSHostageAnimState()
+{
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Set hostage animation state
+ */
+Activity CCSHostageAnimState::CalcMainActivity()
+{
+	float flOuterSpeed = GetOuterXYSpeed();
+
+	if ( HandleJumping() )
+	{
+		return ACT_HOP;
+	}
+	else
+	{
+		Assert( dynamic_cast<CHostage*>( m_pOuter ) );
+		CHostage *me = (CHostage*)m_pOuter;
+
+		// if we have no leader, hang out
+		Activity idealActivity = me->GetLeader() ? ACT_IDLE : ACT_BUSY_QUEUE;
+
+		if ( m_pOuter->GetFlags() & FL_DUCKING )
+		{
+			if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
+				idealActivity = ACT_RUN_CROUCH;
+			else
+				idealActivity = ACT_COVER_LOW;
+		}
+		else
+		{
+			if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
+			{
+				if ( flOuterSpeed > ARBITRARY_RUN_SPEED )
+					idealActivity = ACT_RUN;
+				else
+					idealActivity = ACT_WALK;
+			}
+		}
+
+		return idealActivity;
+	}
+}
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CCSPlayerAnimState implementation.
+// ------------------------------------------------------------------------------------------------ //
+
+CCSPlayerAnimState::CCSPlayerAnimState()
+{
+	m_pOuter = NULL;
+
+	m_bJumping = false;
+	m_flJumpStartTime = 0.0f;
+	m_bFirstJumpFrame = false;
+
+	m_bReloading = false;
+	m_flReloadCycle = 0.0f;
+	m_iReloadSequence = -1;
+	m_flReloadHoldEndTime = 0.0f;
+
+	m_bFiring = false;
+	m_iFireSequence = -1;
+	m_flFireCycle = 0.0f;
+	m_delayedFire = PLAYERANIMEVENT_COUNT;
+
+	m_bThrowingGrenade = false;
+	m_bPrimingGrenade = false;
+	m_flGrenadeCycle = 0.0f;
+	m_iGrenadeSequence = -1;
+	m_iLastThrowGrenadeCounter = 0;
+	m_cachedModelIndex = -1;
+
+	m_pPlayer = NULL;
+
+	m_pHelpers = NULL;
+}
+
+
+void CCSPlayerAnimState::InitCS( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences )
+{
+	CModAnimConfig config;
+	config.m_flMaxBodyYawDegrees = 90;
+	config.m_LegAnimType = legAnimType;
+	config.m_bUseAimSequences = bUseAimSequences;
+
+	m_pPlayer = ToCSPlayer( pEntity );
+
+	m_pHelpers = pHelpers;
+
+	BaseClass::Init( pEntity, config );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+void CCSPlayerAnimState::CheckCachedSequenceValidity( void )
+{
+	if ( m_cachedModelIndex != GetOuter()->GetModelIndex() )
+	{
+		m_namedSequence.RemoveAll();
+
+		m_cachedModelIndex = GetOuter()->GetModelIndex();
+		for ( int i=0; i<=ACT_CROUCHIDLE; ++i )
+		{
+			m_sequenceCache[i] = -1;
+		}
+
+		// precache the sequences we'll be using for movement
+		if ( m_cachedModelIndex > 0 )
+		{
+			m_sequenceCache[ACT_HOP - 1] = GetOuter()->SelectWeightedSequence( ACT_HOP );
+			m_sequenceCache[ACT_IDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_IDLE );
+			m_sequenceCache[ACT_RUN_CROUCH - 1] = GetOuter()->SelectWeightedSequence( ACT_RUN_CROUCH );
+			m_sequenceCache[ACT_CROUCHIDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_CROUCHIDLE );
+			m_sequenceCache[ACT_RUN - 1] = GetOuter()->SelectWeightedSequence( ACT_RUN );
+			m_sequenceCache[ACT_WALK - 1] = GetOuter()->SelectWeightedSequence( ACT_WALK );
+			m_sequenceCache[ACT_IDLE - 1] = GetOuter()->SelectWeightedSequence( ACT_IDLE );
+		}
+	}
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Cache the sequence numbers for the first ACT_HOP activities, since the CS player doesn't have multiple
+ * sequences per activity.
+ */
+int CCSPlayerAnimState::SelectWeightedSequence( Activity activity )
+{
+	VPROF( "CCSPlayerAnimState::ComputeMainSequence" );
+
+	if ( activity > ACT_CROUCHIDLE || activity < 1 )
+	{
+		return GetOuter()->SelectWeightedSequence( activity );
+	}
+
+	CheckCachedSequenceValidity();
+
+	int sequence = m_sequenceCache[ activity - 1 ];
+	if ( sequence < 0 )
+	{
+		// just in case, look up the sequence if we didn't precache it above
+		sequence = m_sequenceCache[ activity - 1 ] = GetOuter()->SelectWeightedSequence( activity );
+	}
+
+#if defined(CLIENT_DLL) && defined(_DEBUG)
+	int realSequence = GetOuter()->SelectWeightedSequence( activity );
+	Assert( realSequence == sequence );
+#endif
+
+	return sequence;
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Try to look up named sequences in a CUtlDict cache before falling back to the normal LookupSequence.  It's
+ * best to avoid the normal LookupSequence when your models have 750+ sequences...
+ */
+int CCSPlayerAnimState::CalcSequenceIndex( const char *pBaseName, ... )
+{
+	VPROF( "CCSPlayerAnimState::CalcSequenceIndex" );
+
+	CheckCachedSequenceValidity();
+
+	char szFullName[512];
+	va_list marker;
+	va_start( marker, pBaseName );
+	Q_vsnprintf( szFullName, sizeof( szFullName ), pBaseName, marker );
+	va_end( marker );
+
+	int iSequence = m_namedSequence.Find( szFullName );
+	if ( iSequence == m_namedSequence.InvalidIndex() )
+	{
+		iSequence = GetOuter()->LookupSequence( szFullName );
+		m_namedSequence.Insert( szFullName, iSequence );
+	}
+	else
+	{
+		iSequence = m_namedSequence[iSequence];
+	}
+
+#if defined(CLIENT_DLL) && defined(_DEBUG)
+	int realSequence = GetOuter()->LookupSequence( szFullName );
+	Assert( realSequence == iSequence );
+#endif
+	
+	// Show warnings if we can't find anything here.
+	if ( iSequence == -1 )
+	{
+		static CUtlDict<int,int> dict;
+		if ( dict.Find( szFullName ) == -1 )
+		{
+			dict.Insert( szFullName, 0 );
+			Warning( "CalcSequenceIndex: can't find '%s'.\n", szFullName );
+		}
+
+		iSequence = 0;
+	}
+
+	return iSequence;
+}
+
+
+void CCSPlayerAnimState::ClearAnimationState()
+{
+	m_bJumping = false;
+	m_bFiring = false;
+	m_bReloading = false;
+	m_flReloadHoldEndTime = 0.0f;
+	m_bThrowingGrenade = m_bPrimingGrenade = false;
+	m_iLastThrowGrenadeCounter = GetOuterGrenadeThrowCounter();
+	
+	BaseClass::ClearAnimationState();
+}
+
+
+void CCSPlayerAnimState::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
+{
+	Assert( event != PLAYERANIMEVENT_THROW_GRENADE );
+
+	MDLCACHE_CRITICAL_SECTION();
+	switch ( event )
+	{
+	case PLAYERANIMEVENT_FIRE_GUN_PRIMARY:
+	case PLAYERANIMEVENT_FIRE_GUN_SECONDARY:
+		// Regardless of what we're doing in the fire layer, restart it.
+		m_flFireCycle = 0;
+		m_iFireSequence = CalcFireLayerSequence( event );
+		m_bFiring = m_iFireSequence != -1;
+
+		// If we are interrupting a (shotgun) reload, cancel the reload, and fire next frame.
+		if ( m_bFiring && m_bReloading )
+		{
+			m_bReloading = false;
+			m_iReloadSequence = -1;
+
+			m_delayedFire = event;
+			m_bFiring = false;
+			m_iFireSequence = -1;
+
+			CAnimationLayer *pLayer = m_pOuter->GetAnimOverlay( RELOADSEQUENCE_LAYER );
+			if ( pLayer )
+			{
+				pLayer->m_flWeight = 0.0f;
+				pLayer->m_nOrder = 15;
+			}
+		}
+
+#ifdef CLIENT_DLL
+		if ( m_bFiring && !m_bReloading )
+		{
+			if ( m_pPlayer )
+			{
+				m_pPlayer->ProcessMuzzleFlashEvent();
+			}
+		}
+#endif
+		break;
+
+	case PLAYERANIMEVENT_JUMP:
+		// Play the jump animation.
+		m_bJumping = true;
+		m_bFirstJumpFrame = true;
+		m_flJumpStartTime = gpGlobals->curtime;
+		break;
+
+	case PLAYERANIMEVENT_RELOAD:
+		{
+			// ignore normal reload events for shotguns - they get sent to trigger sounds etc only
+			CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+			if ( pWeapon && pWeapon->GetCSWpnData().m_WeaponType != WEAPONTYPE_SHOTGUN )
+			{
+				m_iReloadSequence = CalcReloadLayerSequence( event );
+				if ( m_iReloadSequence != -1 )
+				{
+					m_bReloading = true;
+					m_flReloadCycle = 0;
+				}
+				else
+				{
+					m_bReloading = false;
+				}
+			}
+		}
+		break;
+
+	case PLAYERANIMEVENT_RELOAD_START:
+	case PLAYERANIMEVENT_RELOAD_LOOP:
+		// Set the hold time for _start and _loop anims, then fall through to the _end case
+		m_flReloadHoldEndTime = gpGlobals->curtime + 0.75f;
+
+	case PLAYERANIMEVENT_RELOAD_END:
+		{
+			// ignore shotgun reload events for non-shotguns
+			CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+			if ( pWeapon && pWeapon->GetCSWpnData().m_WeaponType != WEAPONTYPE_SHOTGUN )
+			{
+				m_flReloadHoldEndTime = 0.0f;  // clear this out in case we set it in _START or _LOOP above
+			}
+			else
+			{
+				m_iReloadSequence = CalcReloadLayerSequence( event );
+				if ( m_iReloadSequence != -1 )
+				{
+					m_bReloading = true;
+					m_flReloadCycle = 0;
+				}
+				else
+				{
+					m_bReloading = false;
+				}
+			}
+		}
+		break;
+
+	case PLAYERANIMEVENT_CLEAR_FIRING:
+		{
+			m_iFireSequence = -1;
+		}
+		break;
+
+	default:
+		Assert( !"CCSPlayerAnimState::DoAnimationEvent" );
+	}
+}
+
+
+float g_flThrowGrenadeFraction = 0.25;
+bool CCSPlayerAnimState::IsThrowingGrenade()
+{
+	if ( m_bThrowingGrenade )
+	{
+		// An animation event would be more appropriate here.
+		return m_flGrenadeCycle < g_flThrowGrenadeFraction;
+	}
+	else
+	{
+		bool bThrowPending = (m_iLastThrowGrenadeCounter != GetOuterGrenadeThrowCounter());
+		return bThrowPending || IsOuterGrenadePrimed();
+	}
+}
+
+
+int CCSPlayerAnimState::CalcReloadLayerSequence( PlayerAnimEvent_t event )
+{
+	if ( m_delayedFire != PLAYERANIMEVENT_COUNT )
+		return -1;
+
+	const char *weaponSuffix = GetWeaponSuffix();
+	if ( !weaponSuffix )
+		return -1;
+
+	CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+	if ( !pWeapon )
+		return -1;
+
+	const char *prefix = "";
+	switch ( GetCurrentMainSequenceActivity() )
+	{
+		case ACT_PLAYER_RUN_FIRE:
+		case ACT_RUN:
+			prefix = "run";
+			break;
+
+		case ACT_PLAYER_WALK_FIRE:
+		case ACT_WALK:
+			prefix = "walk";
+			break;
+
+		case ACT_PLAYER_CROUCH_FIRE:
+		case ACT_CROUCHIDLE:
+			prefix = "crouch_idle";
+			break;
+
+		case ACT_PLAYER_CROUCH_WALK_FIRE:
+		case ACT_RUN_CROUCH:
+			prefix = "crouch_walk";
+			break;
+
+		default:
+		case ACT_PLAYER_IDLE_FIRE:
+			prefix = "idle";
+			break;
+	}
+
+	const char *reloadSuffix = "";
+	switch ( event )
+	{
+	case PLAYERANIMEVENT_RELOAD_START:
+		reloadSuffix = "_start";
+		break;
+
+	case PLAYERANIMEVENT_RELOAD_LOOP:
+		reloadSuffix = "_loop";
+		break;
+
+	case PLAYERANIMEVENT_RELOAD_END:
+		reloadSuffix = "_end";
+		break;
+	}
+
+	// First, look for <prefix>_reload_<weapon name><_start|_loop|_end>.
+	char szName[512];
+	Q_snprintf( szName, sizeof( szName ), "%s_reload_%s%s", prefix, weaponSuffix, reloadSuffix );
+	int iReloadSequence = m_pOuter->LookupSequence( szName );
+	if ( iReloadSequence != -1 )
+		return iReloadSequence;
+
+	// Next, look for reload_<weapon name><_start|_loop|_end>.
+	Q_snprintf( szName, sizeof( szName ), "reload_%s%s", weaponSuffix, reloadSuffix );
+	iReloadSequence = m_pOuter->LookupSequence( szName );
+	if ( iReloadSequence != -1 )
+		return iReloadSequence;
+
+	// Ok, look for generic categories.. pistol, shotgun, rifle, etc.
+	if ( pWeapon->GetCSWpnData().m_WeaponType == WEAPONTYPE_PISTOL )
+	{
+		Q_snprintf( szName, sizeof( szName ), "reload_pistol" );
+		iReloadSequence = m_pOuter->LookupSequence( szName );
+		if ( iReloadSequence != -1 )
+			return iReloadSequence;
+	}
+			
+	// Fall back to reload_m4.
+	iReloadSequence = CalcSequenceIndex( "reload_m4" );
+	if ( iReloadSequence > 0 )
+		return iReloadSequence;
+
+	return -1;
+}
+
+	void CCSPlayerAnimState::UpdateLayerSequenceGeneric( CStudioHdr *pStudioHdr, int iLayer, bool &bEnabled, float &flCurCycle, int &iSequence, bool bWaitAtEnd )
+{
+	if ( !bEnabled || iSequence < 0 )
+		return;
+
+		// Increment the fire sequence's cycle.
+		flCurCycle += m_pOuter->GetSequenceCycleRate( pStudioHdr, iSequence ) * gpGlobals->frametime;
+		if ( flCurCycle > 1 )
+		{
+			if ( bWaitAtEnd )
+			{
+				flCurCycle = 1;
+			}
+			else
+			{
+				// Not firing anymore.
+				bEnabled = false;
+				iSequence = 0;
+				return;
+			}
+		}
+
+	// Now dump the state into its animation layer.
+	CAnimationLayer *pLayer = m_pOuter->GetAnimOverlay( iLayer );
+
+	pLayer->m_flCycle = flCurCycle;
+	pLayer->m_nSequence = iSequence;
+
+	pLayer->m_flPlaybackRate = 1.0f;
+	pLayer->m_flWeight = 1.0f;
+	pLayer->m_nOrder = iLayer;
+#ifndef CLIENT_DLL
+	pLayer->m_fFlags |= ANIM_LAYER_ACTIVE; 
+#endif
+}
+
+bool CCSPlayerAnimState::IsOuterGrenadePrimed()
+{
+	CBaseCombatCharacter *pChar = m_pOuter->MyCombatCharacterPointer();
+	if ( pChar )
+	{
+		CBaseCSGrenade *pGren = dynamic_cast<CBaseCSGrenade*>( pChar->GetActiveWeapon() );
+		return pGren && pGren->IsPinPulled();
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+
+void CCSPlayerAnimState::ComputeGrenadeSequence( CStudioHdr *pStudioHdr )
+{
+	VPROF( "CCSPlayerAnimState::ComputeGrenadeSequence" );
+
+	if ( m_bThrowingGrenade )
+	{
+		UpdateLayerSequenceGeneric( pStudioHdr, GRENADESEQUENCE_LAYER, m_bThrowingGrenade, m_flGrenadeCycle, m_iGrenadeSequence, false );
+	}
+	else
+	{
+		if ( m_pPlayer )
+		{
+			CBaseCombatWeapon *pWeapon = m_pPlayer->GetActiveWeapon();
+			CBaseCSGrenade *pGren = dynamic_cast<CBaseCSGrenade*>( pWeapon );
+			if ( !pGren )
+			{
+				// The player no longer has a grenade equipped. Bail.
+				m_iLastThrowGrenadeCounter = GetOuterGrenadeThrowCounter();
+				return;
+			}
+		}
+
+		// Priming the grenade isn't an event.. we just watch the player for it.
+		// Also play the prime animation first if he wants to throw the grenade.
+		bool bThrowPending = (m_iLastThrowGrenadeCounter != GetOuterGrenadeThrowCounter());
+		if ( IsOuterGrenadePrimed() || bThrowPending )
+		{
+			if ( !m_bPrimingGrenade )
+			{
+				// If this guy just popped into our PVS, and he's got his grenade primed, then
+				// let's assume that it's all the way primed rather than playing the prime
+				// animation from the start.
+				if ( TimeSinceLastAnimationStateClear() < 0.4f )
+				{
+					m_flGrenadeCycle = 1;
+				}
+				else
+				{
+					m_flGrenadeCycle = 0;
+				}
+					
+				m_iGrenadeSequence = CalcGrenadePrimeSequence();
+				m_bPrimingGrenade = true;
+			}
+
+			UpdateLayerSequenceGeneric( pStudioHdr, GRENADESEQUENCE_LAYER, m_bPrimingGrenade, m_flGrenadeCycle, m_iGrenadeSequence, true );
+			
+			// If we're waiting to throw and we're done playing the prime animation...
+			if ( bThrowPending && m_flGrenadeCycle == 1 )
+			{
+				m_iLastThrowGrenadeCounter = GetOuterGrenadeThrowCounter();
+
+				// Now play the throw animation.
+				m_iGrenadeSequence = CalcGrenadeThrowSequence();
+				if ( m_iGrenadeSequence != -1 )
+				{
+					// Configure to start playing 
+					m_bThrowingGrenade = true;
+					m_bPrimingGrenade = false;
+					m_flGrenadeCycle = 0;
+				}
+			}
+		}
+		else
+		{
+			m_bPrimingGrenade = false;
+		}
+	}
+}
+
+
+int CCSPlayerAnimState::CalcGrenadePrimeSequence()
+{
+	return CalcSequenceIndex( "idle_shoot_gren1" );
+}
+
+
+int CCSPlayerAnimState::CalcGrenadeThrowSequence()
+{
+	return CalcSequenceIndex( "idle_shoot_gren2" );
+}
+
+
+int CCSPlayerAnimState::GetOuterGrenadeThrowCounter()
+{
+	if ( m_pPlayer )
+		return m_pPlayer->m_iThrowGrenadeCounter;
+	else
+		return 0;
+}
+
+
+void CCSPlayerAnimState::ComputeReloadSequence( CStudioHdr *pStudioHdr )
+{
+	VPROF( "CCSPlayerAnimState::ComputeReloadSequence" );
+	bool hold = m_flReloadHoldEndTime > gpGlobals->curtime;
+	UpdateLayerSequenceGeneric( pStudioHdr, RELOADSEQUENCE_LAYER, m_bReloading, m_flReloadCycle, m_iReloadSequence, hold );
+	if ( !m_bReloading )
+	{
+		m_flReloadHoldEndTime = 0.0f;
+	}
+}
+
+
+int CCSPlayerAnimState::CalcAimLayerSequence( float *flCycle, float *flAimSequenceWeight, bool bForceIdle )
+{
+	VPROF( "CCSPlayerAnimState::CalcAimLayerSequence" );
+
+	const char *pSuffix = GetWeaponSuffix();
+	if ( !pSuffix )
+		return 0;
+
+	if ( bForceIdle )
+	{
+		switch ( GetCurrentMainSequenceActivity() )
+		{
+			case ACT_CROUCHIDLE:
+			case ACT_RUN_CROUCH:
+				return CalcSequenceIndex( "%s%s", DEFAULT_CROUCH_IDLE_NAME, pSuffix );
+
+			default:
+				return CalcSequenceIndex( "%s%s", DEFAULT_IDLE_NAME, pSuffix );
+		}
+	}
+	else
+	{
+		switch ( GetCurrentMainSequenceActivity() )
+		{
+			case ACT_RUN:
+				return CalcSequenceIndex( "%s%s", DEFAULT_RUN_NAME, pSuffix );
+
+			case ACT_WALK:
+			case ACT_RUNTOIDLE:
+			case ACT_IDLETORUN:
+				return CalcSequenceIndex( "%s%s", DEFAULT_WALK_NAME, pSuffix );
+
+			case ACT_CROUCHIDLE:
+				return CalcSequenceIndex( "%s%s", DEFAULT_CROUCH_IDLE_NAME, pSuffix );
+
+			case ACT_RUN_CROUCH:
+				return CalcSequenceIndex( "%s%s", DEFAULT_CROUCH_WALK_NAME, pSuffix );
+
+			case ACT_IDLE:
+			default:
+				return CalcSequenceIndex( "%s%s", DEFAULT_IDLE_NAME, pSuffix );
+		}
+	}
+}
+
+
+const char* CCSPlayerAnimState::GetWeaponSuffix()
+{
+	VPROF( "CCSPlayerAnimState::GetWeaponSuffix" );
+
+	// Figure out the weapon suffix.
+	CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+	if ( !pWeapon )
+		return 0;
+
+	const char *pSuffix = pWeapon->GetCSWpnData().m_szAnimExtension;
+
+#ifdef CS_SHIELD_ENABLED
+	if ( m_pOuter->HasShield() == true )
+	{
+		if ( m_pOuter->IsShieldDrawn() == true )
+			pSuffix = "shield";
+		else 
+			pSuffix = "shield_undeployed";
+	}
+#endif
+
+	return pSuffix;
+}
+
+
+int CCSPlayerAnimState::CalcFireLayerSequence(PlayerAnimEvent_t event)
+{
+	// Figure out the weapon suffix.
+	CWeaponCSBase *pWeapon = m_pHelpers->CSAnim_GetActiveWeapon();
+	if ( !pWeapon )
+		return -1;
+
+	const char *pSuffix = GetWeaponSuffix();
+	if ( !pSuffix )
+		return -1;
+
+	char tempsuffix[32];
+	if ( pWeapon->GetWeaponID() == WEAPON_ELITE )
+	{
+		bool bPrimary = (event == PLAYERANIMEVENT_FIRE_GUN_PRIMARY);
+		Q_snprintf( tempsuffix, sizeof(tempsuffix), "%s_%c", pSuffix, bPrimary?'r':'l' );
+		pSuffix = tempsuffix;
+	}
+
+	// Grenades handle their fire events separately
+	if ( event == PLAYERANIMEVENT_THROW_GRENADE ||
+		pWeapon->GetWeaponID() == WEAPON_HEGRENADE ||
+		pWeapon->GetWeaponID() == WEAPON_SMOKEGRENADE ||
+		pWeapon->GetWeaponID() == WEAPON_FLASHBANG )
+	{
+		return -1;
+	}
+
+	switch ( GetCurrentMainSequenceActivity() )
+	{
+		case ACT_PLAYER_RUN_FIRE:
+		case ACT_RUN:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_RUN_NAME, pSuffix );
+
+		case ACT_PLAYER_WALK_FIRE:
+		case ACT_WALK:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_WALK_NAME, pSuffix );
+
+		case ACT_PLAYER_CROUCH_FIRE:
+		case ACT_CROUCHIDLE:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_CROUCH_NAME, pSuffix );
+
+		case ACT_PLAYER_CROUCH_WALK_FIRE:
+		case ACT_RUN_CROUCH:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_CROUCH_WALK_NAME, pSuffix );
+
+		default:
+		case ACT_PLAYER_IDLE_FIRE:
+			return CalcSequenceIndex( "%s%s", DEFAULT_FIRE_IDLE_NAME, pSuffix );
+	}
+}
+
+
+bool CCSPlayerAnimState::CanThePlayerMove()
+{
+	return m_pHelpers->CSAnim_CanMove();
+}
+
+
+float CCSPlayerAnimState::GetCurrentMaxGroundSpeed()
+{
+	Activity currentActivity = 	m_pOuter->GetSequenceActivity( m_pOuter->GetSequence() );
+	if ( currentActivity == ACT_WALK || currentActivity == ACT_IDLE )
+		return ANIM_TOPSPEED_WALK;
+	else if ( currentActivity == ACT_RUN )
+	{
+		if ( m_pPlayer )
+		{
+			CBaseCombatWeapon *activeWeapon = m_pPlayer->GetActiveWeapon();
+			if ( activeWeapon )
+			{
+				CWeaponCSBase *csWeapon = dynamic_cast< CWeaponCSBase * >( activeWeapon );
+				if ( csWeapon )
+				{
+					return csWeapon->GetMaxSpeed();
+				}
+			}
+		}
+		return ANIM_TOPSPEED_RUN;
+	}
+	else if ( currentActivity == ACT_RUN_CROUCH )
+		return ANIM_TOPSPEED_RUN_CROUCH;
+	else
+		return 0;
+}
+
+
+bool CCSPlayerAnimState::HandleJumping()
+{
+	if ( m_bJumping )
+	{
+		if ( m_bFirstJumpFrame )
+		{
+
+#if !defined(CLIENT_DLL)
+            //=============================================================================
+            // HPE_BEGIN:
+            // [dwenger] Needed for fun-fact implementation
+            //=============================================================================
+
+			CCS_GameStats.IncrementStat(m_pPlayer, CSSTAT_TOTAL_JUMPS, 1);
+
+            //=============================================================================
+            // HPE_END
+            //=============================================================================
+#endif
+
+			m_bFirstJumpFrame = false;
+			RestartMainSequence();	// Reset the animation.
+		}
+
+		// Don't check if he's on the ground for a sec.. sometimes the client still has the
+		// on-ground flag set right when the message comes in.
+		if ( gpGlobals->curtime - m_flJumpStartTime > 0.2f )
+		{
+			if ( m_pOuter->GetFlags() & FL_ONGROUND )
+			{
+				m_bJumping = false;
+				RestartMainSequence();	// Reset the animation.
+			}
+		}
+	}
+
+	// Are we still jumping? If so, keep playing the jump animation.
+	return m_bJumping;
+}
+
+
+Activity CCSPlayerAnimState::CalcMainActivity()
+{
+	float flOuterSpeed = GetOuterXYSpeed();
+
+	if ( HandleJumping() )
+	{
+		return ACT_HOP;
+	}
+	else
+	{
+		Activity idealActivity = ACT_IDLE;
+
+		if ( m_pOuter->GetFlags() & FL_ANIMDUCKING )
+		{
+			if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
+				idealActivity = ACT_RUN_CROUCH;
+			else
+				idealActivity = ACT_CROUCHIDLE;
+		}
+		else
+		{
+			if ( flOuterSpeed > MOVING_MINIMUM_SPEED )
+			{
+				if ( flOuterSpeed > ARBITRARY_RUN_SPEED )
+					idealActivity = ACT_RUN;
+				else
+					idealActivity = ACT_WALK;
+			}
+			else
+			{
+				idealActivity = ACT_IDLE;
+			}
+		}
+
+		return idealActivity;
+	}
+}
+
+
+void CCSPlayerAnimState::DebugShowAnimState( int iStartLine )
+{
+	engine->Con_NPrintf( iStartLine++, "fire  : %s, cycle: %.2f\n", m_bFiring ? GetSequenceName( m_pOuter->GetModelPtr(), m_iFireSequence ) : "[not firing]", m_flFireCycle );
+	engine->Con_NPrintf( iStartLine++, "reload: %s, cycle: %.2f\n", m_bReloading ? GetSequenceName( m_pOuter->GetModelPtr(), m_iReloadSequence ) : "[not reloading]", m_flReloadCycle );
+	BaseClass::DebugShowAnimState( iStartLine );
+}
+
+
+void CCSPlayerAnimState::ComputeSequences( CStudioHdr *pStudioHdr )
+{
+	BaseClass::ComputeSequences( pStudioHdr );
+
+	VPROF( "CCSPlayerAnimState::ComputeSequences" );
+
+	ComputeFireSequence( pStudioHdr );
+	ComputeReloadSequence( pStudioHdr );
+	ComputeGrenadeSequence( pStudioHdr );
+}
+
+
+void CCSPlayerAnimState::ClearAnimationLayers()
+{
+	if ( !m_pOuter )
+		return;
+
+	m_pOuter->SetNumAnimOverlays( NUM_LAYERS_WANTED );
+	for ( int i=0; i < m_pOuter->GetNumAnimOverlays(); i++ )
+	{
+		// Client obeys Order of CBaseAnimatingOverlay::MAX_OVERLAYS (15), but server trusts only the ANIM_LAYER_ACTIVE flag.
+		m_pOuter->GetAnimOverlay( i )->SetOrder( CBaseAnimatingOverlay::MAX_OVERLAYS );
+#ifndef CLIENT_DLL
+		m_pOuter->GetAnimOverlay( i )->m_fFlags = 0;
+#endif
+	}
+}
+
+
+void CCSPlayerAnimState::ComputeFireSequence( CStudioHdr *pStudioHdr )
+{
+	VPROF( "CCSPlayerAnimState::ComputeFireSequence" );
+
+	if ( m_delayedFire != PLAYERANIMEVENT_COUNT )
+	{
+		DoAnimationEvent( m_delayedFire, 0 );
+		m_delayedFire = PLAYERANIMEVENT_COUNT;
+	}
+
+	UpdateLayerSequenceGeneric( pStudioHdr, FIRESEQUENCE_LAYER, m_bFiring, m_flFireCycle, m_iFireSequence, false );
+}
diff --git a/game/shared/cstrike/cs_playeranimstate.h b/game/shared/cstrike/cs_playeranimstate.h
new file mode 100644
index 00000000..aad335c4
--- /dev/null
+++ b/game/shared/cstrike/cs_playeranimstate.h
@@ -0,0 +1,82 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef TF_PLAYERANIMSTATE_H
+#define TF_PLAYERANIMSTATE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "convar.h"
+#include "iplayeranimstate.h"
+#include "base_playeranimstate.h"
+
+#ifdef CLIENT_DLL
+	class C_BaseAnimatingOverlay;
+	class C_WeaponCSBase;
+	// Avoid redef warnings
+	#undef CBaseAnimatingOverlay
+	#define CBaseAnimatingOverlay C_BaseAnimatingOverlay
+	#define CWeaponCSBase C_WeaponCSBase
+	#define CCSPlayer C_CSPlayer
+#else
+	class CBaseAnimatingOverlay;
+	class CWeaponCSBase; 
+	class CCSPlayer;
+#endif
+
+
+// When moving this fast, he plays run anim.
+#define ARBITRARY_RUN_SPEED		175.0f
+
+
+enum PlayerAnimEvent_t
+{
+	PLAYERANIMEVENT_FIRE_GUN_PRIMARY=0,
+	PLAYERANIMEVENT_FIRE_GUN_SECONDARY,
+	PLAYERANIMEVENT_THROW_GRENADE,
+	PLAYERANIMEVENT_JUMP,
+	PLAYERANIMEVENT_RELOAD,
+	PLAYERANIMEVENT_RELOAD_START,	///< w_model partial reload for shotguns
+	PLAYERANIMEVENT_RELOAD_LOOP,	///< w_model partial reload for shotguns
+	PLAYERANIMEVENT_RELOAD_END,		///< w_model partial reload for shotguns
+	PLAYERANIMEVENT_CLEAR_FIRING,	///< clear animations on the firing layer
+	
+	PLAYERANIMEVENT_COUNT
+};
+
+
+class ICSPlayerAnimState : virtual public IPlayerAnimState
+{
+public:
+	// This is called by both the client and the server in the same way to trigger events for
+	// players firing, jumping, throwing grenades, etc.
+	virtual void DoAnimationEvent( PlayerAnimEvent_t event, int nData = 0 ) = 0;
+	
+	// Returns true if we're playing the grenade prime or throw animation.
+	virtual bool IsThrowingGrenade() = 0;
+};
+
+
+// This abstracts the differences between CS players and hostages.
+class ICSPlayerAnimStateHelpers
+{
+public:
+	virtual CWeaponCSBase* CSAnim_GetActiveWeapon() = 0;
+	virtual bool CSAnim_CanMove() = 0;
+};
+
+
+ICSPlayerAnimState* CreatePlayerAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences );
+ICSPlayerAnimState* CreateHostageAnimState( CBaseAnimatingOverlay *pEntity, ICSPlayerAnimStateHelpers *pHelpers, LegAnimType_t legAnimType, bool bUseAimSequences );
+
+// If this is set, then the game code needs to make sure to send player animation events
+// to the local player if he's the one being watched.
+extern ConVar cl_showanimstate;
+
+
+#endif // TF_PLAYERANIMSTATE_H
diff --git a/game/shared/cstrike/cs_shareddefs.cpp b/game/shared/cstrike/cs_shareddefs.cpp
new file mode 100644
index 00000000..89b8ae35
--- /dev/null
+++ b/game/shared/cstrike/cs_shareddefs.cpp
@@ -0,0 +1,67 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "cs_shareddefs.h"
+
+const float CS_PLAYER_SPEED_RUN		 = 260.0f;
+const float CS_PLAYER_SPEED_VIP		 = 227.0f;
+const float CS_PLAYER_SPEED_WALK	 = 100.0f;
+const float CS_PLAYER_SPEED_SHIELD	 = 160.0f;
+const float CS_PLAYER_SPEED_STOPPED	 =   1.0f;
+const float CS_PLAYER_SPEED_OBSERVER = 900.0f;
+
+const float CS_PLAYER_SPEED_DUCK_MODIFIER	= 0.34f;
+const float CS_PLAYER_SPEED_WALK_MODIFIER	= 0.52f;
+const float CS_PLAYER_SPEED_CLIMB_MODIFIER	= 0.34f;
+
+
+CCSClassInfo g_ClassInfos[] =
+{
+	{ "None" },
+
+	{ "Phoenix Connection" },
+	{ "L337 KREW" },
+	{ "Arctic Avengers" },
+	{ "Guerilla Warfare" },
+
+	{ "Seal Team 6" },
+	{ "GSG-9" },
+	{ "SAS" },
+	{ "GIGN" }
+};
+
+const CCSClassInfo* GetCSClassInfo( int i )
+{
+	Assert( i >= 0 && i < ARRAYSIZE( g_ClassInfos ) );
+	return &g_ClassInfos[i];
+}
+
+const char *pszWinPanelCategoryHeaders[] =
+{
+	"",
+	"#winpanel_topdamage",
+	"#winpanel_topheadshots",
+	"#winpanel_kills"
+};
+
+// Construct some arrays of player model strings, so we can statically initialize CUtlVectors for general usage
+const char *CTPlayerModelStrings[] =
+{
+	"models/player/ct_urban.mdl",
+	"models/player/ct_gsg9.mdl",
+	"models/player/ct_sas.mdl",
+	"models/player/ct_gign.mdl",
+};
+const char *TerroristPlayerModelStrings[] =
+{
+	"models/player/t_phoenix.mdl",
+	"models/player/t_leet.mdl",
+	"models/player/t_arctic.mdl",
+	"models/player/t_guerilla.mdl",
+};
+CUtlVectorInitialized< const char * > CTPlayerModels( CTPlayerModelStrings, ARRAYSIZE( CTPlayerModelStrings ) );
+CUtlVectorInitialized< const char * > TerroristPlayerModels( TerroristPlayerModelStrings, ARRAYSIZE( TerroristPlayerModelStrings ) );
diff --git a/game/shared/cstrike/cs_shareddefs.h b/game/shared/cstrike/cs_shareddefs.h
new file mode 100644
index 00000000..3e414318
--- /dev/null
+++ b/game/shared/cstrike/cs_shareddefs.h
@@ -0,0 +1,261 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Shared CS definitions.
+//
+//=============================================================================//
+
+#ifndef CS_SHAREDDEFS_H
+#define CS_SHAREDDEFS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+/*======================*/
+//      Menu stuff      //
+/*======================*/
+
+#include <game/client/iviewport.h>
+
+//=============================================================================
+// HPE_BEGIN:
+// Including Achievement ID Definitions
+//=============================================================================
+
+#include "cs_achievementdefs.h"
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+// CS-specific viewport panels
+#define PANEL_CLASS_CT				"class_ct"
+#define PANEL_CLASS_TER				"class_ter"
+
+// Buy sub menus
+#define MENU_PISTOL					"menu_pistol"
+#define MENU_SHOTGUN				"menu_shotgun"
+#define MENU_RIFLE					"menu_rifle"
+#define MENU_SMG					"menu_smg"
+#define MENU_MACHINEGUN				"menu_mg"
+#define MENU_EQUIPMENT				"menu_equip"
+
+
+#define MAX_HOSTAGES				12
+#define MAX_HOSTAGE_RESCUES			4
+
+
+
+ 
+#define CSTRIKE_DEFAULT_AVATAR "avatar_default_64"
+#define CSTRIKE_DEFAULT_T_AVATAR "avatar_default-t_64"
+#define CSTRIKE_DEFAULT_CT_AVATAR "avatar_default_64"
+
+extern const float CS_PLAYER_SPEED_RUN;
+extern const float CS_PLAYER_SPEED_VIP;
+extern const float CS_PLAYER_SPEED_WALK;
+extern const float CS_PLAYER_SPEED_SHIELD;
+extern const float CS_PLAYER_SPEED_STOPPED;
+extern const float CS_PLAYER_SPEED_OBSERVER;
+
+extern const float CS_PLAYER_SPEED_DUCK_MODIFIER;
+extern const float CS_PLAYER_SPEED_WALK_MODIFIER;
+extern const float CS_PLAYER_SPEED_CLIMB_MODIFIER;
+
+
+template< class T >
+class CUtlVectorInitialized : public CUtlVector< T >
+{
+public:
+	CUtlVectorInitialized( T* pMemory, int numElements ) : CUtlVector< T >( pMemory, numElements )
+	{
+		this->SetSize( numElements );
+	}
+};
+
+extern CUtlVectorInitialized< const char * > CTPlayerModels;
+extern CUtlVectorInitialized< const char * > TerroristPlayerModels;
+
+
+// These go in CCSPlayer::m_iAddonBits and get sent to the client so it can create
+// grenade models hanging off players.
+#define ADDON_FLASHBANG_1		0x001
+#define ADDON_FLASHBANG_2		0x002
+#define ADDON_HE_GRENADE		0x004
+#define ADDON_SMOKE_GRENADE		0x008
+#define ADDON_C4				0x010
+#define ADDON_DEFUSEKIT			0x020
+#define ADDON_PRIMARY			0x040
+#define ADDON_PISTOL			0x080
+#define ADDON_PISTOL2			0x100
+#define NUM_ADDON_BITS			9
+
+
+// Indices of each weapon slot.
+#define WEAPON_SLOT_RIFLE		0	// (primary slot)
+#define WEAPON_SLOT_PISTOL		1	// (secondary slot)
+#define WEAPON_SLOT_KNIFE		2
+#define WEAPON_SLOT_GRENADES	3
+#define WEAPON_SLOT_C4			4
+
+#define WEAPON_SLOT_FIRST		0
+#define WEAPON_SLOT_LAST		4
+
+
+// CS Team IDs.
+#define TEAM_TERRORIST			2
+#define	TEAM_CT					3
+#define TEAM_MAXCOUNT			4	// update this if we ever add teams (unlikely)
+
+#define MAX_CLAN_TAG_LENGTH		16	// max for new tags is actually 12, this allows some backward compat.
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] CS specific death animation time now that freeze cam is implemented
+//			in order to linger on the players body less 
+// [tj] The number of times you must kill a given player to be dominating them
+// [menglish] Flags to use upon player death
+//=============================================================================
+
+// [menglish] CS specific death animation time now that freeze cam is implemented
+//			in order to linger on the players body less 
+#define CS_DEATH_ANIMATION_TIME			0.8
+ 
+// [tj] The number of times you must kill a given player to be dominating them
+// Should always be more than 1
+#define CS_KILLS_FOR_DOMINATION         4
+
+#define CS_DEATH_DOMINATION				0x0001	// killer is dominating victim
+#define CS_DEATH_REVENGE				0x0002	// killer got revenge on victim
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+//--------------
+// CSPort Specific damage flags
+//--------------
+#define DMG_HEADSHOT		(DMG_LASTGENERICFLAG<<1)
+
+
+// The various states the player can be in during the join game process.
+enum CSPlayerState
+{
+	// Happily running around in the game.
+	// You can't move though if CSGameRules()->IsFreezePeriod() returns true.
+	// This state can jump to a bunch of other states like STATE_PICKINGCLASS or STATE_DEATH_ANIM.
+	STATE_ACTIVE=0,
+
+	// This is the state you're in when you first enter the server.
+	// It's switching between intro cameras every few seconds, and there's a level info
+	// screen up.
+	STATE_WELCOME,			// Show the level intro screen.
+
+	// During these states, you can either be a new player waiting to join, or
+	// you can be a live player in the game who wants to change teams.
+	// Either way, you can't move while choosing team or class (or while any menu is up).
+	STATE_PICKINGTEAM,			// Choosing team.
+	STATE_PICKINGCLASS,			// Choosing class.
+
+	STATE_DEATH_ANIM,			// Playing death anim, waiting for that to finish.
+	STATE_DEATH_WAIT_FOR_KEY,	// Done playing death anim. Waiting for keypress to go into observer mode.
+	STATE_OBSERVER_MODE,		// Noclipping around, watching players, etc.
+	NUM_PLAYER_STATES
+};
+
+
+enum e_RoundEndReason
+{
+    Invalid_Round_End_Reason = -1,
+    Target_Bombed,
+    VIP_Escaped,						
+    VIP_Assassinated,
+    Terrorists_Escaped,
+    CTs_PreventEscape,
+    Escaping_Terrorists_Neutralized,
+    Bomb_Defused,
+    CTs_Win,
+    Terrorists_Win,
+    Round_Draw,
+    All_Hostages_Rescued,
+    Target_Saved,
+    Hostages_Not_Rescued,
+    Terrorists_Not_Escaped,
+    VIP_Not_Escaped,
+    Game_Commencing,
+    RoundEndReason_Count    
+};
+
+#define PUSHAWAY_THINK_INTERVAL		(1.0f / 20.0f)
+
+enum
+{
+	CS_CLASS_NONE=0,
+
+	// Terrorist classes (keep in sync with FIRST_T_CLASS/LAST_T_CLASS).
+	CS_CLASS_PHOENIX_CONNNECTION,
+	CS_CLASS_L337_KREW,
+	CS_CLASS_ARCTIC_AVENGERS,
+	CS_CLASS_GUERILLA_WARFARE,
+
+	// CT classes (keep in sync with FIRST_CT_CLASS/LAST_CT_CLASS).
+	CS_CLASS_SEAL_TEAM_6,
+	CS_CLASS_GSG_9,
+	CS_CLASS_SAS,
+	CS_CLASS_GIGN,
+
+	CS_NUM_CLASSES
+};
+
+//=============================================================================
+// HPE_BEGIN:
+// [menglish] List of equipment dropped by players with freeze panel callouts
+//============================================================================= 
+enum
+{
+	DROPPED_C4,
+	DROPPED_DEFUSE,
+	DROPPED_WEAPON,
+	DROPPED_GRENADE, // This could be an HE greande, flashbang, or smoke
+	DROPPED_COUNT
+}; 
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+//=============================================================================
+//
+// MVP reasons
+//
+enum CSMvpReason_t
+{
+	CSMVP_UNDEFINED = 0,
+	CSMVP_ELIMINATION,
+	CSMVP_BOMBPLANT,
+	CSMVP_BOMBDEFUSE,
+	CSMVP_HOSTAGERESCUE,
+};
+
+
+// Keep these in sync with CSClasses.
+#define FIRST_T_CLASS	CS_CLASS_PHOENIX_CONNNECTION
+#define LAST_T_CLASS	CS_CLASS_GUERILLA_WARFARE
+
+#define FIRST_CT_CLASS	CS_CLASS_SEAL_TEAM_6
+#define LAST_CT_CLASS	CS_CLASS_GIGN
+
+#define CS_MUZZLEFLASH_NONE -1
+#define CS_MUZZLEFLASH_NORM	0
+#define CS_MUZZLEFLASH_X	1
+
+class CCSClassInfo
+{
+public:
+	const char		*m_pClassName;
+};
+
+const CCSClassInfo* GetCSClassInfo( int i );
+
+extern const char *pszWinPanelCategoryHeaders[];
+
+#endif // CS_SHAREDDEFS_H
diff --git a/game/shared/cstrike/cs_urlretrieveprices.cpp b/game/shared/cstrike/cs_urlretrieveprices.cpp
new file mode 100644
index 00000000..c094263a
--- /dev/null
+++ b/game/shared/cstrike/cs_urlretrieveprices.cpp
@@ -0,0 +1,237 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+//#include "stdafx.h"
+#ifdef _WIN32
+#include "winlite.h"
+#include "winsock.h"
+#elif POSIX
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR -1
+#define SOCKET int
+#define LPSOCKADDR struct sockaddr *
+#define SOCKADDR_IN struct sockaddr_in
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#define closesocket close
+#endif
+#include "tier1/strtools.h"
+#include "KeyValues.h"
+#include "utlbuffer.h"
+#include "tier1/checksum_crc.h"
+#include "tier1/convar.h"
+#include "cbase.h"
+#include "cs_gamestats.h"
+#include "cs_gamerules.h"
+#include "cs_urlretrieveprices.h"
+
+#if _DEBUG
+#define WEEKLY_PRICE_URL "http://gamestats/weeklyprices.dat"
+#else
+#define WEEKLY_PRICE_URL "http://www.steampowered.com/stats/csmarket/weeklyprices.dat"
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Purpose: request a URL from connection
+//-----------------------------------------------------------------------------
+bool SendHTTPRequest( const char *pchRequestURL, SOCKET socketHTML )
+{
+	char szHeader[ MED_BUFFER_SIZE ];
+	char szHostName[ SMALL_BUFFER_SIZE ];
+	::gethostname( szHostName, sizeof(szHostName) );
+
+	Q_snprintf( szHeader, sizeof(szHeader), "GET %s HTTP/1.0\r\n" \
+		"Accept: */*\r\n" \
+		"Accept-Language: en-us\r\n" \
+		"User-Agent: Steam/3.0\r\n" \
+		"Host: %s\r\n" \
+		"\r\n",
+		pchRequestURL, szHostName );
+
+	return ::send( socketHTML, szHeader, Q_strlen(szHeader) + 1, 0 ) != SOCKET_ERROR ;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Given a previous HTTP request parse the response into a key values buffer
+//-----------------------------------------------------------------------------
+bool ParseHTTPResponse( SOCKET socketHTML, uint32 *unPageHash = NULL )
+{
+	char szHeaderBuf[ MED_BUFFER_SIZE ];
+	char szBodyBuf[ MED_BUFFER_SIZE ];
+
+	int dwRet = 0;
+	bool bFinishedHeaderRead = false;
+	int iRecvPosition = 0;
+	int cCharsInLine = 0;
+
+	// scan for the end of the header
+	while ( !bFinishedHeaderRead && iRecvPosition < sizeof(szHeaderBuf) )
+	{
+		dwRet = ::recv( socketHTML, &szHeaderBuf[ iRecvPosition ] , 1, 0);
+		if ( dwRet < 0 )
+		{
+			bFinishedHeaderRead = true;
+		}
+
+		switch( szHeaderBuf[ iRecvPosition ] )
+		{
+		case '\r':
+			break;
+		case '\n':
+			if ( cCharsInLine == 0 )
+				bFinishedHeaderRead = true;
+
+			cCharsInLine = 0;
+			break;
+		default:
+			cCharsInLine++;
+			break;
+		}
+
+		iRecvPosition++;
+	}
+
+	CUtlBuffer buf;
+	buf.SetBufferType( false, false );
+	while( 1 )
+	{
+		dwRet = ::recv( socketHTML, szBodyBuf, sizeof(szBodyBuf)-1, 0);
+		if ( dwRet <= 0 )
+			break;
+
+		buf.Put( szBodyBuf, sizeof(szBodyBuf)-1 );
+	}
+
+	weeklyprice_t weeklyprice;
+	Q_memset( &weeklyprice, 0, sizeof( weeklyprice_t) );
+
+	buf.Get( &weeklyprice, sizeof( weeklyprice_t ) );
+
+	if ( weeklyprice.iVersion != PRICE_BLOB_VERSION )
+	{
+		Msg( "Incorrect price blob version! Update your server!\n" );
+		return false;
+	}
+
+	CSGameRules()->AddPricesToTable( weeklyprice );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Given http url crack it into an address and the request part
+//-----------------------------------------------------------------------------
+bool ProcessURL( const char *pchURL, void *pSockAddrIn, char *pchRequest, int cchRequest ) 
+{
+	char rgchHost[ MAX_DNS_NAME ];
+	char rgchRequest[ MED_BUFFER_SIZE ];
+	uint16 iPort;
+
+	if ( Q_strnicmp( pchURL, "http://", 7 ) != 0 )
+	{
+		Assert( !"http protocol only supported" );
+		return false;
+	}
+
+	const char *pchColon = strchr( pchURL + 7, ':' );
+	if ( pchColon )
+	{
+		Q_strncpy( rgchHost, pchURL + 7, pchColon - ( pchURL + 7 ) + 1 );
+		const char *pchForwardSlash = strchr( pchColon + 1, '/' );
+		if ( !pchForwardSlash )
+			return false;
+		Q_strncpy( rgchRequest, pchColon + 1, pchForwardSlash - ( pchColon + 1 ) + 1 );
+		iPort = atoi( rgchRequest );
+		Q_strncpy( rgchRequest, pchForwardSlash, ( pchURL + Q_strlen(pchURL) ) - pchForwardSlash + 1  );
+	}
+	else
+	{
+		const char *pchForwardSlash = strchr( pchURL + 7, '/' );
+		if ( !pchForwardSlash )
+			return false;
+
+		Q_strncpy( rgchHost, pchURL + 7, pchForwardSlash - ( pchURL + 7 ) + 1 );
+		iPort = 80;
+		Q_strncpy( rgchRequest, pchForwardSlash, ( pchURL + Q_strlen(pchURL) ) - pchForwardSlash + 1 );
+	}
+
+	struct hostent *hp = NULL;
+	if ( inet_addr( rgchHost ) == INADDR_NONE )
+	{
+		hp = gethostbyname( rgchHost );
+	}
+	else
+	{
+		uint32 addr = inet_addr( rgchHost );
+		hp = gethostbyaddr( ( char* )&addr, sizeof( addr ), AF_INET );
+	}
+
+	if(  hp == NULL )
+	{
+		return false;
+	}
+
+	sockaddr_in &sockAddrIn = *((sockaddr_in *)pSockAddrIn);
+	sockAddrIn.sin_addr.s_addr = *( ( unsigned long* )hp->h_addr );
+	sockAddrIn.sin_family = AF_INET;
+	sockAddrIn.sin_port = htons( iPort );
+
+	Q_strncpy( pchRequest, rgchRequest, cchRequest );
+	return true;
+}
+
+//networkstringtable
+
+bool BlackMarket_DownloadPrices( void )
+{
+	char szRequest[ MED_BUFFER_SIZE ];
+	sockaddr_in server;
+	bool bConnected = false;
+
+	if ( ProcessURL( WEEKLY_PRICE_URL, &server, szRequest, sizeof(szRequest) ) )
+	{
+		SOCKET socketHTML = ::socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
+		if ( socketHTML != INVALID_SOCKET)
+		{
+			int iRet = ::connect( socketHTML, (LPSOCKADDR)&server, sizeof(SOCKADDR_IN) );
+
+			if ( !iRet )
+			{
+				bConnected = true;
+				if ( SendHTTPRequest( szRequest, socketHTML ) )
+				{
+					uint32 unHash = 0;
+					bool bRet = ParseHTTPResponse( socketHTML, &unHash );
+
+					closesocket( socketHTML );
+
+					return bRet;
+				}
+				else
+				{
+					return false;
+				}
+			}
+			else
+			{
+				closesocket( socketHTML );
+				return false;
+			}
+		}
+	}
+	else
+	{
+		return false;
+	}
+
+	return true;
+}
diff --git a/game/shared/cstrike/cs_urlretrieveprices.h b/game/shared/cstrike/cs_urlretrieveprices.h
new file mode 100644
index 00000000..e81ce452
--- /dev/null
+++ b/game/shared/cstrike/cs_urlretrieveprices.h
@@ -0,0 +1,29 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef URLRETRIEVETHREAD_H
+#define URLRETRIEVETHREAD_H
+
+#include "KeyValues.h"
+#include "cs_weapon_parse.h"
+
+bool BlackMarket_DownloadPrices( void );
+
+#define MED_BUFFER_SIZE 1024
+#define SMALL_BUFFER_SIZE 255
+#define MAX_DNS_NAME 255
+
+#define PRICE_BLOB_VERSION 1
+#define PRICE_BLOB_NAME "weeklyprices.dat"
+
+struct weeklyprice_t
+{
+	short iVersion;
+	short iPreviousPrice[WEAPON_MAX];
+	short iCurrentPrice[WEAPON_MAX];
+};
+
+#endif // URLRETRIEVETHREAD_H
diff --git a/game/shared/cstrike/cs_usermessages.cpp b/game/shared/cstrike/cs_usermessages.cpp
new file mode 100644
index 00000000..0c03b6d8
--- /dev/null
+++ b/game/shared/cstrike/cs_usermessages.cpp
@@ -0,0 +1,80 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "usermessages.h"
+#include "shake.h"
+#include "voice_gamemgr.h"
+
+// NVNT include to register in haptic user messages
+#include "haptics/haptic_msgs.h"
+
+void RegisterUserMessages()
+{
+	usermessages->Register( "Geiger", 1 );		// geiger info data
+	usermessages->Register( "Train", 1 );		// train control data
+	usermessages->Register( "HudText", -1 );
+	usermessages->Register( "SayText", -1 );
+	usermessages->Register( "SayText2", -1 );
+	usermessages->Register( "TextMsg", -1 );
+	usermessages->Register( "HudMsg", -1 );
+	usermessages->Register( "ResetHUD", 1 );	// called every respawn
+	usermessages->Register( "GameTitle", 0 );	// show game title
+	usermessages->Register( "ItemPickup", -1 );	// for item history on screen
+	usermessages->Register( "ShowMenu", -1 );	// show hud menu
+	usermessages->Register( "Shake", 13 );		// shake view
+	usermessages->Register( "Fade", 10 );	// fade HUD in/out
+	usermessages->Register( "VGUIMenu", -1 );	// Show VGUI menu
+	usermessages->Register( "Rumble", 3 );	// Send a rumble to a controller
+	usermessages->Register( "CloseCaption", -1 ); // Show a caption (by string id number)(duration in 10th of a second)
+
+	usermessages->Register( "SendAudio", -1 );	// play radio command
+	usermessages->Register( "RawAudio", -1 );	// play a .wav as a radio command
+
+	usermessages->Register( "VoiceMask", VOICE_MAX_PLAYERS_DW*4 * 2 + 1 );
+	usermessages->Register( "RequestState", 0 );
+
+	usermessages->Register( "BarTime", -1 );	// For the C4 progress bar.
+	usermessages->Register( "Damage", -1 );		// for HUD damage indicators
+	usermessages->Register( "RadioText", -1 );		// for radio text display
+	usermessages->Register( "HintText", -1 );	// Displays hint text display
+	usermessages->Register( "KeyHintText", -1 );	// Displays hint text display
+	
+	usermessages->Register( "ReloadEffect", 2 );			// a player reloading..
+	usermessages->Register( "PlayerAnimEvent", -1 );	// jumping, firing, reload, etc.
+
+	usermessages->Register( "AmmoDenied", 2 );
+	usermessages->Register( "UpdateRadar", -1 );
+	usermessages->Register( "KillCam", -1 );
+	usermessages->Register( "MarkAchievement", -1 );
+
+	// Voting
+	usermessages->Register( "CallVoteFailed", -1 );
+	usermessages->Register( "VoteStart", -1 );
+	usermessages->Register( "VotePass", -1 );
+	usermessages->Register( "VoteFailed", 2 );
+	usermessages->Register( "VoteSetup", -1 );  // Initiates client-side voting UI
+
+	// NVNT register haptic user messages
+	RegisterHapticMessages();
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [menglish] Registering PlayerStatsUpdate for Stats implementation
+	// [dwenger] AchievementEvent: Necessary for server-side achievement awarding
+    // [tj]      Added support for absolute current match statistics updates   
+	//=============================================================================
+	 
+	usermessages->Register( "PlayerStatsUpdate_DEPRECATED", -1 ); // Protocol changed, this message replaced below
+    usermessages->Register( "AchievementEvent", -1 );
+	usermessages->Register( "MatchEndConditions", -1 ); //The end conditions for the match.  long frag limit, long max rounds, long rounds needed won, and long time
+    usermessages->Register( "MatchStatsUpdate", -1 ); 
+	usermessages->Register( "PlayerStatsUpdate", -1 ); //Processes stats update
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+}
diff --git a/game/shared/cstrike/cs_weapon_parse.cpp b/game/shared/cstrike/cs_weapon_parse.cpp
new file mode 100644
index 00000000..d23ea72e
--- /dev/null
+++ b/game/shared/cstrike/cs_weapon_parse.cpp
@@ -0,0 +1,455 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include <KeyValues.h>
+#include "cs_weapon_parse.h"
+#include "cs_shareddefs.h"
+#include "weapon_csbase.h"
+#include "icvar.h"
+#include "cs_gamerules.h"
+#include "cs_blackmarket.h"
+
+
+//--------------------------------------------------------------------------------------------------------
+struct WeaponTypeInfo
+{
+	CSWeaponType type;
+	const char * name;
+};
+
+
+//--------------------------------------------------------------------------------------------------------
+WeaponTypeInfo s_weaponTypeInfo[] =
+{
+	{ WEAPONTYPE_KNIFE,			"Knife" },
+	{ WEAPONTYPE_PISTOL,		"Pistol" },
+	{ WEAPONTYPE_SUBMACHINEGUN,	"Submachine Gun" },	// First match is printable
+	{ WEAPONTYPE_SUBMACHINEGUN,	"submachinegun" },
+	{ WEAPONTYPE_SUBMACHINEGUN,	"smg" },
+	{ WEAPONTYPE_RIFLE,			"Rifle" },
+	{ WEAPONTYPE_SHOTGUN,		"Shotgun" },
+	{ WEAPONTYPE_SNIPER_RIFLE,	"Sniper Rifle" },	// First match is printable
+	{ WEAPONTYPE_SNIPER_RIFLE,	"SniperRifle" },
+	{ WEAPONTYPE_MACHINEGUN,	"Machine Gun" },		// First match is printable
+	{ WEAPONTYPE_MACHINEGUN,	"machinegun" },
+	{ WEAPONTYPE_MACHINEGUN,	"mg" },
+	{ WEAPONTYPE_C4,			"C4" },
+	{ WEAPONTYPE_GRENADE,		"Grenade" },
+};
+
+
+struct WeaponNameInfo
+{
+	CSWeaponID id;
+	const char *name;
+};
+
+WeaponNameInfo s_weaponNameInfo[] =
+{
+	{ WEAPON_P228,				"weapon_p228" },
+	{ WEAPON_GLOCK,				"weapon_glock" },
+	{ WEAPON_SCOUT,				"weapon_scout" },
+	{ WEAPON_HEGRENADE,			"weapon_hegrenade" },
+	{ WEAPON_XM1014,			"weapon_xm1014" },
+	{ WEAPON_C4,				"weapon_c4" },
+	{ WEAPON_MAC10,				"weapon_mac10" },
+	{ WEAPON_AUG,				"weapon_aug" },
+	{ WEAPON_SMOKEGRENADE,		"weapon_smokegrenade" },
+	{ WEAPON_ELITE,				"weapon_elite" },
+	{ WEAPON_FIVESEVEN,			"weapon_fiveseven" },
+	{ WEAPON_UMP45,				"weapon_ump45" },
+	{ WEAPON_SG550,				"weapon_sg550" },
+
+	{ WEAPON_GALIL,				"weapon_galil" },
+	{ WEAPON_FAMAS,				"weapon_famas" },
+	{ WEAPON_USP,				"weapon_usp" },
+	{ WEAPON_AWP,				"weapon_awp" },
+	{ WEAPON_MP5NAVY,			"weapon_mp5navy" },
+	{ WEAPON_M249,				"weapon_m249" },
+	{ WEAPON_M3,				"weapon_m3" },
+	{ WEAPON_M4A1,				"weapon_m4a1" },
+	{ WEAPON_TMP,				"weapon_tmp" },
+	{ WEAPON_G3SG1,				"weapon_g3sg1" },
+	{ WEAPON_FLASHBANG,			"weapon_flashbang" },
+	{ WEAPON_DEAGLE,			"weapon_deagle" },
+	{ WEAPON_SG552,				"weapon_sg552" },
+	{ WEAPON_AK47,				"weapon_ak47" },
+	{ WEAPON_KNIFE,				"weapon_knife" },
+	{ WEAPON_P90,				"weapon_p90" },
+
+	// not sure any of these are needed
+	{ WEAPON_SHIELDGUN,			"weapon_shieldgun" },
+	{ WEAPON_KEVLAR,			"weapon_kevlar" },
+	{ WEAPON_ASSAULTSUIT,		"weapon_assaultsuit" },
+	{ WEAPON_NVG,				"weapon_nvg" },
+
+	{ WEAPON_NONE,				"weapon_none" },
+};
+
+
+
+//--------------------------------------------------------------------------------------------------------------
+
+
+CCSWeaponInfo g_EquipmentInfo[MAX_EQUIPMENT];
+
+void PrepareEquipmentInfo( void )
+{
+	memset( g_EquipmentInfo, 0, ARRAYSIZE( g_EquipmentInfo ) );
+
+	g_EquipmentInfo[2].SetWeaponPrice( CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_KEVLAR ) );
+	g_EquipmentInfo[2].SetDefaultPrice( KEVLAR_PRICE );
+	g_EquipmentInfo[2].SetPreviousPrice( CSGameRules()->GetBlackMarketPreviousPriceForWeapon( WEAPON_KEVLAR ) );
+	g_EquipmentInfo[2].m_iTeam = TEAM_UNASSIGNED;
+	Q_strcpy( g_EquipmentInfo[2].szClassName, "weapon_vest" );
+
+#ifdef CLIENT_DLL
+	g_EquipmentInfo[2].iconActive = new CHudTexture;
+	g_EquipmentInfo[2].iconActive->cCharacterInFont = 't';
+#endif
+
+	g_EquipmentInfo[1].SetWeaponPrice( CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_ASSAULTSUIT ) );
+	g_EquipmentInfo[1].SetDefaultPrice( ASSAULTSUIT_PRICE );
+	g_EquipmentInfo[1].SetPreviousPrice( CSGameRules()->GetBlackMarketPreviousPriceForWeapon( WEAPON_ASSAULTSUIT ) );
+	g_EquipmentInfo[1].m_iTeam = TEAM_UNASSIGNED;
+	Q_strcpy( g_EquipmentInfo[1].szClassName, "weapon_vesthelm" );
+
+#ifdef CLIENT_DLL
+	g_EquipmentInfo[1].iconActive = new CHudTexture;
+	g_EquipmentInfo[1].iconActive->cCharacterInFont = 'u';
+#endif
+
+	g_EquipmentInfo[0].SetWeaponPrice( CSGameRules()->GetBlackMarketPriceForWeapon( WEAPON_NVG ) );
+	g_EquipmentInfo[0].SetPreviousPrice( CSGameRules()->GetBlackMarketPreviousPriceForWeapon( WEAPON_NVG ) );
+	g_EquipmentInfo[0].SetDefaultPrice( NVG_PRICE );
+	g_EquipmentInfo[0].m_iTeam = TEAM_UNASSIGNED;
+	Q_strcpy( g_EquipmentInfo[0].szClassName, "weapon_nvgs" );
+
+#ifdef CLIENT_DLL
+	g_EquipmentInfo[0].iconActive = new CHudTexture;
+	g_EquipmentInfo[0].iconActive->cCharacterInFont = 's';
+#endif
+
+}
+
+//--------------------------------------------------------------------------------------------------------------
+CCSWeaponInfo * GetWeaponInfo( CSWeaponID weaponID )
+{
+	if ( weaponID == WEAPON_NONE )
+		return NULL;
+
+	if ( weaponID >= WEAPON_KEVLAR )
+	{
+		int iIndex = (WEAPON_MAX - weaponID) - 1;
+
+		return &g_EquipmentInfo[iIndex];
+
+	}
+
+	const char *weaponName = WeaponIdAsString(weaponID);
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( weaponName );
+	if ( hWpnInfo == GetInvalidWeaponInfoHandle() )
+	{
+		return NULL;
+	}
+
+	CCSWeaponInfo *pWeaponInfo = dynamic_cast< CCSWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+
+	return pWeaponInfo;
+}
+
+//--------------------------------------------------------------------------------------------------------
+const char* WeaponClassAsString( CSWeaponType weaponType )
+{
+	for ( int i = 0; i < ARRAYSIZE(s_weaponTypeInfo); ++i )
+	{
+		if ( s_weaponTypeInfo[i].type == weaponType )
+		{
+			return s_weaponTypeInfo[i].name;
+		}
+	}
+
+	return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromString( const char* weaponType )
+{
+	for ( int i = 0; i < ARRAYSIZE(s_weaponTypeInfo); ++i )
+	{
+		if ( !Q_stricmp( s_weaponTypeInfo[i].name, weaponType ) )
+		{
+			return s_weaponTypeInfo[i].type;
+		}
+	}
+
+	return WEAPONTYPE_UNKNOWN;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromWeaponID( CSWeaponID weaponID )
+{
+	const char *weaponStr = WeaponIDToAlias( weaponID );
+	const char *translatedAlias = GetTranslatedWeaponAlias( weaponStr );
+
+	char wpnName[128];
+	Q_snprintf( wpnName, sizeof( wpnName ), "weapon_%s", translatedAlias );
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( wpnName );
+	if ( hWpnInfo != GetInvalidWeaponInfoHandle() )
+	{
+		CCSWeaponInfo *pWeaponInfo = dynamic_cast< CCSWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+		if ( pWeaponInfo )
+		{
+			return pWeaponInfo->m_WeaponType;
+		}
+	}
+
+	return WEAPONTYPE_UNKNOWN;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+const char * WeaponIdAsString( CSWeaponID weaponID )
+{
+	for ( int i = 0; i < ARRAYSIZE(s_weaponNameInfo); ++i )
+	{
+		if (s_weaponNameInfo[i].id == weaponID )
+			return s_weaponNameInfo[i].name;
+	}
+
+	return NULL;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponID WeaponIdFromString( const char *szWeaponName )
+{
+	for ( int i = 0; i < ARRAYSIZE(s_weaponNameInfo); ++i )
+	{
+		if ( Q_stricmp(s_weaponNameInfo[i].name, szWeaponName) == 0 )
+			return s_weaponNameInfo[i].id;
+	}
+
+	return WEAPON_NONE;
+}
+
+
+//--------------------------------------------------------------------------------------------------------
+void ParseVector( KeyValues *keyValues, const char *keyName, Vector& vec )
+{
+	vec.x = vec.y = vec.z = 0.0f;
+
+	if ( !keyValues || !keyName )
+		return;
+
+	const char *vecString = keyValues->GetString( keyName, "0 0 0" );
+	if ( vecString && *vecString )
+	{
+		float x = 0.0f, y = 0.0f, z = 0.0f;
+		if ( 3 == sscanf( vecString, "%f %f %f", &x, &y, &z ) )
+		{
+			vec.x = x;
+			vec.y = y;
+			vec.z = z;
+		}
+	}
+}
+
+
+FileWeaponInfo_t* CreateWeaponInfo()
+{
+	return new CCSWeaponInfo;
+}
+
+
+CCSWeaponInfo::CCSWeaponInfo()
+{
+	m_flMaxSpeed = 1; // This should always be set in the script.
+	m_szAddonModel[0] = 0;
+}
+
+int	CCSWeaponInfo::GetWeaponPrice( void ) const
+{
+	return m_iWeaponPrice;
+}
+
+int	CCSWeaponInfo::GetDefaultPrice( void )
+{
+	return m_iDefaultPrice;
+}
+
+int	CCSWeaponInfo::GetPrevousPrice( void )
+{
+	return m_iPreviousPrice;
+}
+
+
+void CCSWeaponInfo::Parse( KeyValues *pKeyValuesData, const char *szWeaponName )
+{
+	BaseClass::Parse( pKeyValuesData, szWeaponName );
+
+	m_flMaxSpeed = (float)pKeyValuesData->GetInt( "MaxPlayerSpeed", 1 );
+
+	m_iDefaultPrice = m_iWeaponPrice = pKeyValuesData->GetInt( "WeaponPrice", -1 );
+	if ( m_iWeaponPrice == -1 )
+	{
+		// This weapon should have the price in its script.
+		Assert( false );
+	}
+
+	if ( CSGameRules()->IsBlackMarket() )
+	{
+		CSWeaponID iWeaponID = AliasToWeaponID( GetTranslatedWeaponAlias ( szWeaponName ) );
+
+		m_iDefaultPrice = m_iWeaponPrice;
+		m_iPreviousPrice = CSGameRules()->GetBlackMarketPreviousPriceForWeapon( iWeaponID );
+		m_iWeaponPrice = CSGameRules()->GetBlackMarketPriceForWeapon( iWeaponID );
+	}
+		
+	m_flArmorRatio				= pKeyValuesData->GetFloat( "WeaponArmorRatio", 1 );
+	m_iCrosshairMinDistance		= pKeyValuesData->GetInt( "CrosshairMinDistance", 4 );
+	m_iCrosshairDeltaDistance	= pKeyValuesData->GetInt( "CrosshairDeltaDistance", 3 );
+	m_bCanUseWithShield			= !!pKeyValuesData->GetInt( "CanEquipWithShield", false );
+	m_flMuzzleScale				= pKeyValuesData->GetFloat( "MuzzleFlashScale", 1 );
+
+	const char *pMuzzleFlashStyle = pKeyValuesData->GetString( "MuzzleFlashStyle", "CS_MUZZLEFLASH_NORM" );
+	
+	if( pMuzzleFlashStyle )
+	{
+		if ( Q_stricmp( pMuzzleFlashStyle, "CS_MUZZLEFLASH_X" ) == 0 )
+		{
+			m_iMuzzleFlashStyle = CS_MUZZLEFLASH_X;
+		}
+		else if ( Q_stricmp( pMuzzleFlashStyle, "CS_MUZZLEFLASH_NONE" ) == 0 )
+		{
+			m_iMuzzleFlashStyle = CS_MUZZLEFLASH_NONE;
+		}
+		else
+		{
+			m_iMuzzleFlashStyle = CS_MUZZLEFLASH_NORM;
+		}
+	}
+	else
+	{
+		Assert( false );
+	}
+
+	m_iPenetration		= pKeyValuesData->GetInt( "Penetration", 1 );
+	m_iDamage			= pKeyValuesData->GetInt( "Damage", 42 ); // Douglas Adams 1952 - 2001
+	m_flRange			= pKeyValuesData->GetFloat( "Range", 8192.0f );
+	m_flRangeModifier	= pKeyValuesData->GetFloat( "RangeModifier", 0.98f );
+	m_iBullets			= pKeyValuesData->GetInt( "Bullets", 1 );
+	m_flCycleTime		= pKeyValuesData->GetFloat( "CycleTime", 0.15 );
+	m_bAccuracyQuadratic= pKeyValuesData->GetInt( "AccuracyQuadratic", 0 );
+	m_flAccuracyDivisor	= pKeyValuesData->GetFloat( "AccuracyDivisor", -1 ); // -1 = off
+	m_flAccuracyOffset	= pKeyValuesData->GetFloat( "AccuracyOffset", 0 );
+	m_flMaxInaccuracy	= pKeyValuesData->GetFloat( "MaxInaccuracy", 0 );
+
+	// new accuracy model parameters
+	m_fSpread[0]				= pKeyValuesData->GetFloat("Spread", 0.0f);
+	m_fInaccuracyCrouch[0]		= pKeyValuesData->GetFloat("InaccuracyCrouch", 0.0f);
+	m_fInaccuracyStand[0]		= pKeyValuesData->GetFloat("InaccuracyStand", 0.0f);
+	m_fInaccuracyJump[0]		= pKeyValuesData->GetFloat("InaccuracyJump", 0.0f);
+	m_fInaccuracyLand[0]		= pKeyValuesData->GetFloat("InaccuracyLand", 0.0f);
+	m_fInaccuracyLadder[0]		= pKeyValuesData->GetFloat("InaccuracyLadder", 0.0f);
+	m_fInaccuracyImpulseFire[0]	= pKeyValuesData->GetFloat("InaccuracyFire", 0.0f);
+	m_fInaccuracyMove[0]		= pKeyValuesData->GetFloat("InaccuracyMove", 0.0f);
+
+	m_fSpread[1]				= pKeyValuesData->GetFloat("SpreadAlt", 0.0f);
+	m_fInaccuracyCrouch[1]		= pKeyValuesData->GetFloat("InaccuracyCrouchAlt", 0.0f);
+	m_fInaccuracyStand[1]		= pKeyValuesData->GetFloat("InaccuracyStandAlt", 0.0f);
+	m_fInaccuracyJump[1]		= pKeyValuesData->GetFloat("InaccuracyJumpAlt", 0.0f);
+	m_fInaccuracyLand[1]		= pKeyValuesData->GetFloat("InaccuracyLandAlt", 0.0f);
+	m_fInaccuracyLadder[1]		= pKeyValuesData->GetFloat("InaccuracyLadderAlt", 0.0f);
+	m_fInaccuracyImpulseFire[1]	= pKeyValuesData->GetFloat("InaccuracyFireAlt", 0.0f);
+	m_fInaccuracyMove[1]		= pKeyValuesData->GetFloat("InaccuracyMoveAlt", 0.0f);
+
+	m_fInaccuracyReload			= pKeyValuesData->GetFloat("InaccuracyReload", 0.0f);
+	m_fInaccuracyAltSwitch		= pKeyValuesData->GetFloat("InaccuracyAltSwitch", 0.0f);
+
+	m_fRecoveryTimeCrouch		= pKeyValuesData->GetFloat("RecoveryTimeCrouch", 1.0f);
+	m_fRecoveryTimeStand		= pKeyValuesData->GetFloat("RecoveryTimeStand", 1.0f);
+
+	m_flTimeToIdleAfterFire	= pKeyValuesData->GetFloat( "TimeToIdle", 2 );
+	m_flIdleInterval	= pKeyValuesData->GetFloat( "IdleInterval", 20 );
+
+	// Figure out what team can have this weapon.
+	m_iTeam = TEAM_UNASSIGNED;
+	const char *pTeam = pKeyValuesData->GetString( "Team", NULL );
+	if ( pTeam )
+	{
+		if ( Q_stricmp( pTeam, "CT" ) == 0 )
+		{
+			m_iTeam = TEAM_CT;
+		}
+		else if ( Q_stricmp( pTeam, "TERRORIST" ) == 0 )
+		{
+			m_iTeam = TEAM_TERRORIST;
+		}
+		else if ( Q_stricmp( pTeam, "ANY" ) == 0 )
+		{
+			m_iTeam = TEAM_UNASSIGNED;
+		}
+		else
+		{
+			Assert( false );
+		}
+	}
+	else
+	{
+		Assert( false );
+	}
+
+	
+	const char *pWrongTeamMsg = pKeyValuesData->GetString( "WrongTeamMsg", "" );
+	Q_strncpy( m_WrongTeamMsg, pWrongTeamMsg, sizeof( m_WrongTeamMsg ) );
+
+	const char *pShieldViewModel = pKeyValuesData->GetString( "shieldviewmodel", "" );
+	Q_strncpy( m_szShieldViewModel, pShieldViewModel, sizeof( m_szShieldViewModel ) );
+	
+	const char *pAnimEx = pKeyValuesData->GetString( "PlayerAnimationExtension", "m4" );
+	Q_strncpy( m_szAnimExtension, pAnimEx, sizeof( m_szAnimExtension ) );
+
+	// Default is 2000.
+	m_flBotAudibleRange = pKeyValuesData->GetFloat( "BotAudibleRange", 2000.0f );
+	
+	const char *pTypeString = pKeyValuesData->GetString( "WeaponType", "" );
+	m_WeaponType = WeaponClassFromString(pTypeString);
+
+	m_bFullAuto = pKeyValuesData->GetBool("FullAuto");
+
+	// Read the addon model.
+	Q_strncpy( m_szAddonModel, pKeyValuesData->GetString( "AddonModel" ), sizeof( m_szAddonModel ) );
+
+	// Read the dropped model.
+	Q_strncpy( m_szDroppedModel, pKeyValuesData->GetString( "DroppedModel" ), sizeof( m_szDroppedModel ) );
+
+	// Read the silencer model.
+	Q_strncpy( m_szSilencerModel, pKeyValuesData->GetString( "SilencerModel" ), sizeof( m_szSilencerModel ) );
+
+#ifndef CLIENT_DLL
+	// Enforce consistency for the weapon here, since that way we don't need to save off the model bounds
+	// for all time.
+	// Moved to pure_server_minimal.txt
+//	engine->ForceExactFile( UTIL_VarArgs("scripts/%s.ctx", szWeaponName ) );
+
+	// Model bounds are rounded to the nearest integer, then extended by 1
+	engine->ForceModelBounds( szWorldModel, Vector( -15, -12, -18 ), Vector( 44, 16, 19 ) );
+	if ( m_szAddonModel[0] )
+	{
+		engine->ForceModelBounds( m_szAddonModel, Vector( -5, -5, -6 ), Vector( 13, 5, 7 ) );
+	}
+	if ( m_szSilencerModel[0] )
+	{
+		engine->ForceModelBounds( m_szSilencerModel, Vector( -15, -12, -18 ), Vector( 44, 16, 19 ) );
+	}
+#endif // !CLIENT_DLL
+}
+
+
diff --git a/game/shared/cstrike/cs_weapon_parse.h b/game/shared/cstrike/cs_weapon_parse.h
new file mode 100644
index 00000000..33bf0e46
--- /dev/null
+++ b/game/shared/cstrike/cs_weapon_parse.h
@@ -0,0 +1,192 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef CS_WEAPON_PARSE_H
+#define CS_WEAPON_PARSE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_parse.h"
+#include "networkvar.h"
+
+
+//--------------------------------------------------------------------------------------------------------
+enum CSWeaponType
+{
+	WEAPONTYPE_KNIFE=0,	
+	WEAPONTYPE_PISTOL,
+	WEAPONTYPE_SUBMACHINEGUN,
+	WEAPONTYPE_RIFLE,
+	WEAPONTYPE_SHOTGUN,
+	WEAPONTYPE_SNIPER_RIFLE,
+	WEAPONTYPE_MACHINEGUN,
+	WEAPONTYPE_C4,
+	WEAPONTYPE_GRENADE,
+	WEAPONTYPE_UNKNOWN
+
+};
+
+
+//--------------------------------------------------------------------------------------------------------
+enum CSWeaponID
+{
+	WEAPON_NONE = 0,
+
+	WEAPON_P228,
+	WEAPON_GLOCK,
+	WEAPON_SCOUT,
+	WEAPON_HEGRENADE,
+	WEAPON_XM1014,
+	WEAPON_C4,
+	WEAPON_MAC10,
+	WEAPON_AUG,
+	WEAPON_SMOKEGRENADE,
+	WEAPON_ELITE,
+	WEAPON_FIVESEVEN,
+	WEAPON_UMP45,
+	WEAPON_SG550,
+
+	WEAPON_GALIL,
+	WEAPON_FAMAS,
+	WEAPON_USP,
+	WEAPON_AWP,
+	WEAPON_MP5NAVY,
+	WEAPON_M249,
+	WEAPON_M3,
+	WEAPON_M4A1,
+	WEAPON_TMP,
+	WEAPON_G3SG1,
+	WEAPON_FLASHBANG,
+	WEAPON_DEAGLE,
+	WEAPON_SG552,
+	WEAPON_AK47,
+	WEAPON_KNIFE,
+	WEAPON_P90,
+
+	WEAPON_SHIELDGUN,	// BOTPORT: Is this still needed?
+
+	WEAPON_KEVLAR,
+	WEAPON_ASSAULTSUIT,
+	WEAPON_NVG,
+
+	WEAPON_MAX,		// number of weapons weapon index
+};
+
+#define MAX_EQUIPMENT (WEAPON_MAX - WEAPON_KEVLAR)
+
+void PrepareEquipmentInfo( void );
+
+//--------------------------------------------------------------------------------------------------------
+const char * WeaponClassAsString( CSWeaponType weaponType );
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromString( const char* weaponType );
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponType WeaponClassFromWeaponID( CSWeaponID weaponID );
+
+//--------------------------------------------------------------------------------------------------------
+const char * WeaponIdAsString( CSWeaponID weaponID );
+
+//--------------------------------------------------------------------------------------------------------
+CSWeaponID WeaponIdFromString( const char *szWeaponName );
+
+
+//--------------------------------------------------------------------------------------------------------
+class CCSWeaponInfo : public FileWeaponInfo_t
+{
+public:
+	DECLARE_CLASS_GAMEROOT( CCSWeaponInfo, FileWeaponInfo_t );
+	
+	CCSWeaponInfo();
+	
+	virtual void Parse( ::KeyValues *pKeyValuesData, const char *szWeaponName );
+
+	int GetRealWeaponPrice( void ) { return m_iWeaponPrice; }
+
+
+public:
+
+	float m_flMaxSpeed;			// How fast the player can run while this is his primary weapon.
+
+	CSWeaponType m_WeaponType;
+
+	bool	m_bFullAuto;		// is this a fully automatic weapon?
+
+	int m_iTeam;				// Which team can have this weapon. TEAM_UNASSIGNED if both can have it.
+	float m_flBotAudibleRange;	// How far away a bot can hear this weapon.
+	float m_flArmorRatio;
+
+	int	  m_iCrosshairMinDistance;
+	int	  m_iCrosshairDeltaDistance;
+	
+	bool  m_bCanUseWithShield;
+	
+	char m_WrongTeamMsg[32];	// Reference to a string describing the error if someone tries to buy
+								// this weapon but they're on the wrong team to have it.
+								// Zero-length if no specific message for this weapon.
+
+	char m_szAnimExtension[16];
+	char m_szShieldViewModel[64];
+
+	char m_szAddonModel[MAX_WEAPON_STRING];		// If this is set, it is used as the addon model. Otherwise, szWorldModel is used.
+	char m_szDroppedModel[MAX_WEAPON_STRING];	// Alternate dropped model, if different from the szWorldModel the player holds
+	char m_szSilencerModel[MAX_WEAPON_STRING];	// Alternate model with silencer attached
+
+	int	  m_iMuzzleFlashStyle;
+	float m_flMuzzleScale;
+	
+	// Parameters for FX_FireBullets:
+	int		m_iPenetration;
+	int		m_iDamage;
+	float	m_flRange;
+	float	m_flRangeModifier;
+	int		m_iBullets;
+	float	m_flCycleTime;
+
+	// Variables that control how fast the weapon's accuracy changes as it is fired.
+	bool	m_bAccuracyQuadratic;
+	float	m_flAccuracyDivisor;
+	float	m_flAccuracyOffset;
+	float	m_flMaxInaccuracy;
+
+	// variables for new accuracy model
+	float m_fSpread[2];
+	float m_fInaccuracyCrouch[2];
+	float m_fInaccuracyStand[2];
+	float m_fInaccuracyJump[2];
+	float m_fInaccuracyLand[2];
+	float m_fInaccuracyLadder[2];
+	float m_fInaccuracyImpulseFire[2];
+	float m_fInaccuracyMove[2];
+	float m_fRecoveryTimeStand;
+	float m_fRecoveryTimeCrouch;
+	float m_fInaccuracyReload;
+	float m_fInaccuracyAltSwitch;
+
+	// Delay until the next idle animation after shooting.
+	float	m_flTimeToIdleAfterFire;
+	float	m_flIdleInterval;
+   
+	int		GetWeaponPrice( void ) const;
+	int		GetDefaultPrice( void );
+	int		GetPrevousPrice( void );
+	void	SetWeaponPrice( int iPrice ) { m_iWeaponPrice = iPrice; }
+	void	SetDefaultPrice( int iPrice ) { m_iDefaultPrice = iPrice; }
+	void	SetPreviousPrice( int iPrice ) { m_iPreviousPrice = iPrice; }
+    
+private:
+
+	int m_iWeaponPrice;
+	int m_iDefaultPrice;
+	int m_iPreviousPrice;
+
+};
+
+
+#endif // CS_WEAPON_PARSE_H
diff --git a/game/shared/cstrike/flashbang_projectile.cpp b/game/shared/cstrike/flashbang_projectile.cpp
new file mode 100644
index 00000000..aeb9830e
--- /dev/null
+++ b/game/shared/cstrike/flashbang_projectile.cpp
@@ -0,0 +1,316 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "flashbang_projectile.h"
+#include "shake.h"
+#include "engine/IEngineSound.h"
+#include "cs_player.h"
+#include "dlight.h"
+#include "KeyValues.h"
+#include "weapon_csbase.h"
+#include "collisionutils.h"
+#include "particle_smokegrenade.h"
+#include "smoke_fog_overlay_shared.h"
+
+#define GRENADE_MODEL "models/Weapons/w_eq_flashbang_thrown.mdl"
+
+
+LINK_ENTITY_TO_CLASS( flashbang_projectile, CFlashbangProjectile );
+PRECACHE_WEAPON_REGISTER( flashbang_projectile );
+
+float PercentageOfFlashForPlayer(CBaseEntity *player, Vector flashPos, CBaseEntity *pevInflictor)
+{
+	float retval = 0.0f;
+
+	trace_t tr;
+
+	Vector pos = player->EyePosition();
+	Vector vecRight, vecUp, vecForward;
+	AngleVectors( player->EyeAngles(), &vecForward );
+
+	QAngle tempAngle;
+	VectorAngles(player->EyePosition() - flashPos, tempAngle);
+	AngleVectors(tempAngle, NULL, &vecRight, &vecUp);
+
+	vecRight.NormalizeInPlace();
+	vecUp.NormalizeInPlace();
+
+	UTIL_TraceLine( flashPos, pos,
+		(CONTENTS_SOLID|CONTENTS_MOVEABLE|CONTENTS_DEBRIS|CONTENTS_MONSTER),
+		pevInflictor, COLLISION_GROUP_NONE, &tr );
+
+	if ((tr.fraction == 1.0) || (tr.m_pEnt == player))
+	{
+		retval = 1.0;
+	}
+	else
+	{
+		return 0.0;
+	}
+
+	CBaseEntity *pSGren;
+
+	for( pSGren = gEntList.FindEntityByClassname( NULL, "env_particlesmokegrenade" );
+		pSGren;
+		pSGren = gEntList.FindEntityByClassname( pSGren, "env_particlesmokegrenade" ) )
+	{
+		ParticleSmokeGrenade *pPSG =( ParticleSmokeGrenade* ) pSGren;
+
+		if ( gpGlobals->curtime > pPSG->m_flSpawnTime + pPSG->m_FadeStartTime )		// ignore the smoke grenade if it's fading.
+			continue;
+
+		float flHit1, flHit2;
+
+		float flInnerRadius = SMOKEGRENADE_PARTICLERADIUS;
+//		float flOutterRadius = flInnerRadius + ( 0.5 * SMOKEPARTICLE_SIZE );
+
+		Vector vPos = pSGren->GetAbsOrigin();
+
+		/*debugoverlay->AddBoxOverlay( pSGren->GetAbsOrigin(), Vector( flInnerRadius, flInnerRadius, flInnerRadius ),
+			Vector( -flInnerRadius, -flInnerRadius, -flInnerRadius ), QAngle( 0, 0, 0 ), 0, 255, 0, 30, 10 );
+		debugoverlay->AddBoxOverlay( pSGren->GetAbsOrigin(), Vector( flOutterRadius, flOutterRadius, flOutterRadius ),
+			Vector( -flOutterRadius, -flOutterRadius, -flOutterRadius ), QAngle( 0, 0, 0 ), 255, 0, 0, 30, 10 ); */
+
+		if ( IntersectInfiniteRayWithSphere( pos, vecForward, vPos, flInnerRadius, &flHit1, &flHit2 ) )
+		{
+			retval *= 0.8;
+		}
+/*		else if ( IntersectInfiniteRayWithSphere( pos, vecForward, vPos, flOutterRadius, &flHit1, &flHit2 ) )
+		{
+			retval *= 0.9;
+		}
+*/
+	}
+
+	return retval;
+
+}
+
+// --------------------------------------------------------------------------------------------------- //
+//
+// RadiusDamage - this entity is exploding, or otherwise needs to inflict damage upon entities within a certain range.
+// 
+// only damage ents that can clearly be seen by the explosion!
+// --------------------------------------------------------------------------------------------------- //
+
+void RadiusFlash( 
+	Vector vecSrc, 
+	CBaseEntity *pevInflictor, 
+	CBaseEntity *pevAttacker, 
+	float flDamage, 
+	int iClassIgnore, 
+	int bitsDamageType )
+{
+	vecSrc.z += 1;// in case grenade is lying on the ground
+
+	if ( !pevAttacker )
+		pevAttacker = pevInflictor;
+	
+	trace_t		tr;
+	float		flAdjustedDamage;
+	variant_t	var;
+	Vector		vecEyePos;
+	float		fadeTime, fadeHold;
+	Vector		vForward;
+	Vector		vecLOS;
+	float		flDot;
+	
+	CBaseEntity		*pEntity = NULL;
+	static float	flRadius = 1500;
+	float			falloff = flDamage / flRadius;
+
+	bool bInWater = (UTIL_PointContents( vecSrc ) == CONTENTS_WATER);
+
+	// iterate on all entities in the vicinity.
+	while ((pEntity = gEntList.FindEntityInSphere( pEntity, vecSrc, flRadius )) != NULL)
+	{	
+		bool bPlayer = pEntity->IsPlayer();
+		bool bHostage = ( Q_stricmp( pEntity->GetClassname(), "hostage_entity" ) == 0 );
+		
+		if( !bPlayer && !bHostage )
+			continue;
+
+		vecEyePos = pEntity->EyePosition();
+
+		// blasts don't travel into or out of water
+		if ( bInWater && pEntity->GetWaterLevel() == 0)
+			continue;
+		if (!bInWater && pEntity->GetWaterLevel() == 3)
+			continue;
+
+		float percentageOfFlash = PercentageOfFlashForPlayer(pEntity, vecSrc, pevInflictor);
+
+		if ( percentageOfFlash > 0.0 )
+		{
+			// decrease damage for an ent that's farther from the grenade
+			flAdjustedDamage = flDamage - ( vecSrc - pEntity->EyePosition() ).Length() * falloff;
+		
+			if ( flAdjustedDamage > 0 )
+			{
+				// See if we were facing the flash
+				AngleVectors( pEntity->EyeAngles(), &vForward );
+
+				vecLOS = ( vecSrc - vecEyePos );
+
+				float flDistance = vecLOS.Length();
+
+				// Normalize both vectors so the dotproduct is in the range -1.0 <= x <= 1.0 
+				vecLOS.NormalizeInPlace();
+					
+				flDot = DotProduct (vecLOS, vForward);
+
+				float startingAlpha = 255;
+	
+				// if target is facing the bomb, the effect lasts longer
+				if( flDot >= 0.5 )
+				{
+					// looking at the flashbang
+					fadeTime = flAdjustedDamage * 2.5f;
+					fadeHold = flAdjustedDamage * 1.25f;
+				}
+				else if( flDot >= -0.5 )
+				{
+					// looking to the side
+					fadeTime = flAdjustedDamage * 1.75f;
+					fadeHold = flAdjustedDamage * 0.8f;
+				}
+				else
+				{
+					// facing away
+					fadeTime = flAdjustedDamage * 1.0f;
+					fadeHold = flAdjustedDamage * 0.75f;
+					startingAlpha = 200;
+				}
+
+				fadeTime *= percentageOfFlash;
+				fadeHold *= percentageOfFlash;
+
+				if ( bPlayer )
+				{
+    				// blind players and bots
+					CCSPlayer *player = static_cast< CCSPlayer * >( pEntity );
+
+                    //=============================================================================
+                    // HPE_BEGIN:
+                    // [tj] Store who was responsible for the most recent flashbang blinding.
+                    //=============================================================================
+                     
+                    CCSPlayer *attacker = ToCSPlayer (pevAttacker);
+                    if (attacker && player)
+                    {
+                        player->SetLastFlashbangAttacker(attacker);
+                    }
+                     
+                    //=============================================================================
+                    // HPE_END
+                    //=============================================================================
+                    
+
+                                         
+					player->Blind( fadeHold, fadeTime, startingAlpha );
+
+					// deafen players and bots
+					player->Deafen( flDistance );
+				}
+				else if ( bHostage )
+				{
+					variant_t val;					
+					val.SetFloat( fadeTime );
+					pEntity->AcceptInput( "flashbang", pevInflictor, pevAttacker, val, 0 );
+				}
+			}	
+		}
+	}
+
+	CPVSFilter filter(vecSrc);
+	te->DynamicLight( filter, 0.0, &vecSrc, 255, 255, 255, 2, 400, 0.1, 768 );
+}
+
+// --------------------------------------------------------------------------------------------------- //
+// CFlashbangProjectile implementation.
+// --------------------------------------------------------------------------------------------------- //
+
+CFlashbangProjectile* CFlashbangProjectile::Create( 
+	const Vector &position, 
+	const QAngle &angles, 
+	const Vector &velocity, 
+	const AngularImpulse &angVelocity, 
+	CBaseCombatCharacter *pOwner )
+{
+	CFlashbangProjectile *pGrenade = (CFlashbangProjectile*)CBaseEntity::Create( "flashbang_projectile", position, angles, pOwner );
+	
+	// Set the timer for 1 second less than requested. We're going to issue a SOUND_DANGER
+	// one second before detonation.
+	pGrenade->SetAbsVelocity( velocity );
+	pGrenade->SetupInitialTransmittedGrenadeVelocity( velocity );
+	pGrenade->SetThrower( pOwner );
+	pGrenade->m_flDamage = 100;
+	pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+
+	pGrenade->SetTouch( &CBaseGrenade::BounceTouch );
+
+	pGrenade->SetThink( &CBaseCSGrenadeProjectile::DangerSoundThink );
+	pGrenade->SetNextThink( gpGlobals->curtime );
+
+	pGrenade->SetDetonateTimerLength( 1.5 );
+
+	pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );
+
+	pGrenade->SetGravity( BaseClass::GetGrenadeGravity() );
+	pGrenade->SetFriction( BaseClass::GetGrenadeFriction() );
+	pGrenade->SetElasticity( BaseClass::GetGrenadeElasticity() );
+
+	pGrenade->m_pWeaponInfo = GetWeaponInfo( WEAPON_FLASHBANG );
+
+
+	return pGrenade;
+}
+
+void CFlashbangProjectile::Spawn()
+{
+	SetModel( GRENADE_MODEL );
+	BaseClass::Spawn();
+}
+
+void CFlashbangProjectile::Precache()
+{
+	PrecacheModel( GRENADE_MODEL );
+
+	PrecacheScriptSound( "Flashbang.Explode" );
+	PrecacheScriptSound( "Flashbang.Bounce" );
+
+	BaseClass::Precache();
+}
+
+void CFlashbangProjectile::Detonate()
+{
+	RadiusFlash ( GetAbsOrigin(), this, GetThrower(), 4, CLASS_NONE, DMG_BLAST );
+	EmitSound( "Flashbang.Explode" );	
+
+	// tell the bots a flashbang grenade has exploded
+	CCSPlayer *player = ToCSPlayer(GetThrower());
+	if ( player )
+	{
+		IGameEvent * event = gameeventmanager->CreateEvent( "flashbang_detonate" );
+		if ( event )
+		{
+			event->SetInt( "userid", player->GetUserID() );
+			event->SetFloat( "x", GetAbsOrigin().x );
+			event->SetFloat( "y", GetAbsOrigin().y );
+			event->SetFloat( "z", GetAbsOrigin().z );
+			gameeventmanager->FireEvent( event );
+		}
+	}
+
+	UTIL_Remove( this );
+}
+
+//TODO: Let physics handle the sound!
+void CFlashbangProjectile::BounceSound( void )
+{
+	EmitSound( "Flashbang.Bounce" );
+}
diff --git a/game/shared/cstrike/flashbang_projectile.h b/game/shared/cstrike/flashbang_projectile.h
new file mode 100644
index 00000000..454ab1a2
--- /dev/null
+++ b/game/shared/cstrike/flashbang_projectile.h
@@ -0,0 +1,39 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HEGRENADE_PROJECTILE_H
+#define HEGRENADE_PROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "basecsgrenade_projectile.h"
+
+
+class CFlashbangProjectile : public CBaseCSGrenadeProjectile
+{
+public:
+	DECLARE_CLASS( CFlashbangProjectile, CBaseCSGrenadeProjectile );
+
+// Overrides.
+public:
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void BounceSound( void );
+	virtual void Detonate();
+
+// Grenade stuff.
+	static CFlashbangProjectile* Create( 
+		const Vector &position, 
+		const QAngle &angles, 
+		const Vector &velocity, 
+		const AngularImpulse &angVelocity, 
+		CBaseCombatCharacter *pOwner );	
+};
+
+
+#endif // HEGRENADE_PROJECTILE_H
diff --git a/game/shared/cstrike/fx_cs_shared.cpp b/game/shared/cstrike/fx_cs_shared.cpp
new file mode 100644
index 00000000..446d2b55
--- /dev/null
+++ b/game/shared/cstrike/fx_cs_shared.cpp
@@ -0,0 +1,345 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "fx_cs_shared.h"
+#include "weapon_csbase.h"
+
+#ifndef CLIENT_DLL
+	#include "ilagcompensationmanager.h"
+#endif
+
+ConVar weapon_accuracy_logging( "weapon_accuracy_logging", "0", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY | FCVAR_ARCHIVE );
+
+#ifdef CLIENT_DLL
+
+#include "fx_impact.h"
+
+	// this is a cheap ripoff from CBaseCombatWeapon::WeaponSound():
+	void FX_WeaponSound(
+		int iPlayerIndex,
+		WeaponSound_t sound_type,
+		const Vector &vOrigin,
+		CCSWeaponInfo *pWeaponInfo, float flSoundTime )
+	{
+
+		// If we have some sounds from the weapon classname.txt file, play a random one of them
+		const char *shootsound = pWeaponInfo->aShootSounds[ sound_type ]; 
+		if ( !shootsound || !shootsound[0] )
+			return;
+
+		CBroadcastRecipientFilter filter; // this is client side only
+		if ( !te->CanPredict() )
+			return;
+				
+		CBaseEntity::EmitSound( filter, iPlayerIndex, shootsound, &vOrigin, flSoundTime ); 
+	}
+
+	class CGroupedSound
+	{
+	public:
+		string_t m_SoundName;
+		Vector m_vPos;
+	};
+
+	CUtlVector<CGroupedSound> g_GroupedSounds;
+
+	
+	// Called by the ImpactSound function.
+	void ShotgunImpactSoundGroup( const char *pSoundName, const Vector &vEndPos )
+	{
+		int i;
+		// Don't play the sound if it's too close to another impact sound.
+		for ( i=0; i < g_GroupedSounds.Count(); i++ )
+		{
+			CGroupedSound *pSound = &g_GroupedSounds[i];
+
+			if ( vEndPos.DistToSqr( pSound->m_vPos ) < 300*300 )
+			{
+				if ( Q_stricmp( pSound->m_SoundName, pSoundName ) == 0 )
+					return;
+			}
+		}
+
+		// Ok, play the sound and add it to the list.
+		CLocalPlayerFilter filter;
+		C_BaseEntity::EmitSound( filter, NULL, pSoundName, &vEndPos );
+
+		i = g_GroupedSounds.AddToTail();
+		g_GroupedSounds[i].m_SoundName = pSoundName;
+		g_GroupedSounds[i].m_vPos = vEndPos;
+	}
+
+
+	void StartGroupingSounds()
+	{
+		Assert( g_GroupedSounds.Count() == 0 );
+		SetImpactSoundRoute( ShotgunImpactSoundGroup );
+	}
+
+
+	void EndGroupingSounds()
+	{
+		g_GroupedSounds.Purge();
+		SetImpactSoundRoute( NULL );
+	}
+
+#else
+
+	#include "te_shotgun_shot.h"
+
+	// Server doesn't play sounds anyway.
+	void StartGroupingSounds() {}
+	void EndGroupingSounds() {}
+	void FX_WeaponSound ( int iPlayerIndex,
+		WeaponSound_t sound_type,
+		const Vector &vOrigin,
+		CCSWeaponInfo *pWeaponInfo, float flSoundTime ) {};
+
+#endif
+
+
+// This runs on both the client and the server.
+// On the server, it only does the damage calculations.
+// On the client, it does all the effects.
+void FX_FireBullets( 
+	int	iPlayerIndex,
+	const Vector &vOrigin,
+	const QAngle &vAngles,
+	int	iWeaponID,
+	int	iMode,
+	int iSeed,
+	float fInaccuracy,
+	float fSpread,
+	float flSoundTime
+	)
+{
+	bool bDoEffects = true;
+
+#ifdef CLIENT_DLL
+	C_CSPlayer *pPlayer = ToCSPlayer( ClientEntityList().GetBaseEntity( iPlayerIndex ) );
+#else
+	CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iPlayerIndex) );
+#endif
+
+	const char * weaponAlias =	WeaponIDToAlias( iWeaponID );
+
+	if ( !weaponAlias )
+	{
+		DevMsg("FX_FireBullets: weapon alias for ID %i not found\n", iWeaponID );
+		return;
+	}
+
+#if !defined(CLIENT_DLL)
+	if ( weapon_accuracy_logging.GetBool() )
+	{
+		char szFlags[256];
+
+		V_strcpy(szFlags, " ");
+
+// #if defined(CLIENT_DLL)
+// 		V_strcat(szFlags, "CLIENT ", sizeof(szFlags));
+// #else
+// 		V_strcat(szFlags, "SERVER ", sizeof(szFlags));
+// #endif
+// 
+		if ( pPlayer->GetMoveType() == MOVETYPE_LADDER )
+			V_strcat(szFlags, "LADDER ", sizeof(szFlags));
+
+		if ( FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			V_strcat(szFlags, "GROUND ", sizeof(szFlags));
+
+		if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING) )
+			V_strcat(szFlags, "DUCKING ", sizeof(szFlags));
+
+		float fVelocity = pPlayer->GetAbsVelocity().Length2D();
+
+		Msg("FireBullets @ %10f [ %s ]: inaccuracy=%f  spread=%f  max dispersion=%f  mode=%2i  vel=%10f  seed=%3i  %s\n", 
+			gpGlobals->curtime, weaponAlias, fInaccuracy, fSpread, fInaccuracy + fSpread, iMode, fVelocity, iSeed, szFlags);
+	}
+#endif
+
+	char wpnName[128];
+	Q_snprintf( wpnName, sizeof( wpnName ), "weapon_%s", weaponAlias );
+	WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( wpnName );
+
+	if ( hWpnInfo == GetInvalidWeaponInfoHandle() )
+	{
+		DevMsg("FX_FireBullets: LookupWeaponInfoSlot failed for weapon %s\n", wpnName );
+		return;
+	}
+
+	CCSWeaponInfo *pWeaponInfo = static_cast< CCSWeaponInfo* >( GetFileWeaponInfoFromHandle( hWpnInfo ) );
+
+	// Do the firing animation event.
+	if ( pPlayer && !pPlayer->IsDormant() )
+	{
+		if ( iMode == Primary_Mode )
+			pPlayer->GetPlayerAnimState()->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN_PRIMARY );
+		else
+			pPlayer->GetPlayerAnimState()->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN_SECONDARY );
+	}
+
+#ifndef CLIENT_DLL
+	// if this is server code, send the effect over to client as temp entity
+	// Dispatch one message for all the bullet impacts and sounds.
+	TE_FireBullets( 
+		iPlayerIndex,
+		vOrigin, 
+		vAngles, 
+		iWeaponID,
+		iMode,
+		iSeed,
+		fInaccuracy,
+		fSpread
+		);
+
+
+	// Let the player remember the usercmd he fired a weapon on. Assists in making decisions about lag compensation.
+	pPlayer->NoteWeaponFired();
+
+	bDoEffects = false; // no effects on server
+#endif
+
+	iSeed++;
+
+	int		iDamage = pWeaponInfo->m_iDamage;
+	float	flRange = pWeaponInfo->m_flRange;
+	int		iPenetration = pWeaponInfo->m_iPenetration;
+	float	flRangeModifier = pWeaponInfo->m_flRangeModifier;
+	int		iAmmoType = pWeaponInfo->iAmmoType;
+
+	WeaponSound_t sound_type = SINGLE;
+
+	// CS HACK, tweak some weapon values based on primary/secondary mode
+
+	if ( iWeaponID == WEAPON_GLOCK )
+	{
+		if ( iMode == Secondary_Mode )
+		{
+			iDamage = 18;	// reduced power for burst shots
+			flRangeModifier = 0.9f;
+		}
+	}
+	else if ( iWeaponID == WEAPON_M4A1 )
+	{
+		if ( iMode == Secondary_Mode )
+		{
+			flRangeModifier = 0.95f; // slower bullets in silenced mode
+			sound_type = SPECIAL1;
+		}
+	}
+	else if ( iWeaponID == WEAPON_USP )
+	{
+		if ( iMode == Secondary_Mode )
+		{
+			iDamage = 30; // reduced damage in silenced mode
+			sound_type = SPECIAL1;
+		}
+	}
+
+	if ( bDoEffects)
+	{
+		FX_WeaponSound( iPlayerIndex, sound_type, vOrigin, pWeaponInfo, flSoundTime );
+	}
+
+
+	// Fire bullets, calculate impacts & effects
+
+	if ( !pPlayer )
+		return;
+	
+	StartGroupingSounds();
+
+#ifdef GAME_DLL
+	pPlayer->StartNewBulletGroup();
+#endif
+
+#if !defined (CLIENT_DLL)
+	// Move other players back to history positions based on local player's lag
+	lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
+#endif
+
+	RandomSeed( iSeed );	// init random system with this seed
+
+	// Get accuracy displacement
+	float fTheta0 = RandomFloat(0.0f, 2.0f * M_PI);
+	float fRadius0 = RandomFloat(0.0f, fInaccuracy);
+	float x0 = fRadius0 * cosf(fTheta0);
+	float y0 = fRadius0 * sinf(fTheta0);
+
+	const int kMaxBullets = 16;
+	float x1[kMaxBullets], y1[kMaxBullets];
+	Assert(pWeaponInfo->m_iBullets <= kMaxBullets);
+
+	// the RNG can be desynchronized by FireBullet(), so pre-generate all spread offsets
+	for ( int iBullet=0; iBullet < pWeaponInfo->m_iBullets; iBullet++ )
+	{
+		float fTheta1 = RandomFloat(0.0f, 2.0f * M_PI);
+		float fRadius1 = RandomFloat(0.0f, fSpread);
+		x1[iBullet] = fRadius1 * cosf(fTheta1);
+		y1[iBullet] = fRadius1 * sinf(fTheta1);
+	}
+
+	for ( int iBullet=0; iBullet < pWeaponInfo->m_iBullets; iBullet++ )
+	{
+		pPlayer->FireBullet(
+			vOrigin,
+			vAngles,
+			flRange,
+			iPenetration,
+			iAmmoType,
+			iDamage,
+			flRangeModifier,
+			pPlayer,
+			bDoEffects,
+			x0 + x1[iBullet], y0 + y1[iBullet] );
+	}
+
+#if !defined (CLIENT_DLL)
+	lagcompensation->FinishLagCompensation( pPlayer );
+#endif
+
+	EndGroupingSounds();
+}
+
+// This runs on both the client and the server.
+// On the server, it dispatches a TE_PlantBomb to visible clients.
+// On the client, it plays the planting animation.
+void FX_PlantBomb( int iPlayerIndex, const Vector &vOrigin, PlantBombOption_t option )
+{
+#ifdef CLIENT_DLL
+	C_CSPlayer *pPlayer = ToCSPlayer( ClientEntityList().GetBaseEntity( iPlayerIndex ) );
+#else
+	CCSPlayer *pPlayer = ToCSPlayer( UTIL_PlayerByIndex( iPlayerIndex) );
+#endif
+
+	// Do the firing animation event.
+	if ( pPlayer && !pPlayer->IsDormant() )
+	{
+		switch ( option )
+		{
+		case PLANTBOMB_PLANT:
+			{
+				pPlayer->GetPlayerAnimState()->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN_PRIMARY );
+			}
+			break;
+
+		case PLANTBOMB_ABORT:
+			{
+				pPlayer->GetPlayerAnimState()->DoAnimationEvent( PLAYERANIMEVENT_CLEAR_FIRING );
+			}
+			break;
+		}
+	}
+
+#ifndef CLIENT_DLL
+	// if this is server code, send the effect over to client as temp entity
+	// Dispatch one message for all the bullet impacts and sounds.
+	TE_PlantBomb( iPlayerIndex, vOrigin, option );
+#endif
+}
+
diff --git a/game/shared/cstrike/fx_cs_shared.h b/game/shared/cstrike/fx_cs_shared.h
new file mode 100644
index 00000000..19008e88
--- /dev/null
+++ b/game/shared/cstrike/fx_cs_shared.h
@@ -0,0 +1,47 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef FX_CS_SHARED_H
+#define FX_CS_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#ifdef CLIENT_DLL
+	#include "c_cs_player.h"
+#else
+	#include "cs_player.h"
+#endif
+
+
+// This runs on both the client and the server.
+// On the server, it only does the damage calculations.
+// On the client, it does all the effects.
+void FX_FireBullets( 
+	int	iPlayer,
+	const Vector &vOrigin,
+	const QAngle &vAngles,
+	int	iWeaponID,
+	int	iMode,
+	int iSeed,
+	float fInaccuracy,
+	float fSpread,
+	float flSoundTime = 0.0f
+	);
+
+// This runs on both the client and the server.
+// On the server, it dispatches a TE_PlantBomb to visible clients.
+// On the client, it plays the planting animation.
+enum PlantBombOption_t
+{
+	PLANTBOMB_PLANT, // play the planting animation
+	PLANTBOMB_ABORT, // abort the planting animation
+	// NOTE: If you add additional items to this enum then m_option in CTEPlantBomb will need to have its SendPropInt setting changed to have more than one bit.
+};
+void FX_PlantBomb( int iPlayer, const Vector &vOrigin, PlantBombOption_t option );
+
+#endif // FX_CS_SHARED_H
diff --git a/game/shared/cstrike/hegrenade_projectile.cpp b/game/shared/cstrike/hegrenade_projectile.cpp
new file mode 100644
index 00000000..bd802390
--- /dev/null
+++ b/game/shared/cstrike/hegrenade_projectile.cpp
@@ -0,0 +1,94 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hegrenade_projectile.h"
+#include "soundent.h"
+#include "cs_player.h"
+#include "KeyValues.h"
+#include "weapon_csbase.h"
+
+#define GRENADE_MODEL "models/Weapons/w_eq_fraggrenade_thrown.mdl"
+
+
+LINK_ENTITY_TO_CLASS( hegrenade_projectile, CHEGrenadeProjectile );
+PRECACHE_WEAPON_REGISTER( hegrenade_projectile );
+
+CHEGrenadeProjectile* CHEGrenadeProjectile::Create( 
+	const Vector &position, 
+	const QAngle &angles, 
+	const Vector &velocity, 
+	const AngularImpulse &angVelocity, 
+	CBaseCombatCharacter *pOwner, 
+	float timer )
+{
+	CHEGrenadeProjectile *pGrenade = (CHEGrenadeProjectile*)CBaseEntity::Create( "hegrenade_projectile", position, angles, pOwner );
+	
+	// Set the timer for 1 second less than requested. We're going to issue a SOUND_DANGER
+	// one second before detonation.
+
+	pGrenade->SetDetonateTimerLength( 1.5 );
+	pGrenade->SetAbsVelocity( velocity );
+	pGrenade->SetupInitialTransmittedGrenadeVelocity( velocity );
+	pGrenade->SetThrower( pOwner ); 
+
+	pGrenade->SetGravity( BaseClass::GetGrenadeGravity() );
+	pGrenade->SetFriction( BaseClass::GetGrenadeFriction() );
+	pGrenade->SetElasticity( BaseClass::GetGrenadeElasticity() );
+
+	pGrenade->m_flDamage = 100;
+	pGrenade->m_DmgRadius = pGrenade->m_flDamage * 3.5f;
+	pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+	pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );	
+
+	// make NPCs afaid of it while in the air
+	pGrenade->SetThink( &CHEGrenadeProjectile::DangerSoundThink );
+	pGrenade->SetNextThink( gpGlobals->curtime );
+
+	pGrenade->m_pWeaponInfo = GetWeaponInfo( WEAPON_HEGRENADE );
+
+	return pGrenade;
+}
+
+void CHEGrenadeProjectile::Spawn()
+{
+	SetModel( GRENADE_MODEL );
+	BaseClass::Spawn();
+}
+
+void CHEGrenadeProjectile::Precache()
+{
+	PrecacheModel( GRENADE_MODEL );
+
+	PrecacheScriptSound( "HEGrenade.Bounce" );
+
+	BaseClass::Precache();
+}
+
+void CHEGrenadeProjectile::BounceSound( void )
+{
+	EmitSound( "HEGrenade.Bounce" );
+}
+
+void CHEGrenadeProjectile::Detonate()
+{
+	BaseClass::Detonate();
+
+	// tell the bots an HE grenade has exploded
+	CCSPlayer *player = ToCSPlayer(GetThrower());
+	if ( player )
+	{
+		IGameEvent * event = gameeventmanager->CreateEvent( "hegrenade_detonate" );
+		if ( event )
+		{
+			event->SetInt( "userid", player->GetUserID() );
+			event->SetFloat( "x", GetAbsOrigin().x );
+			event->SetFloat( "y", GetAbsOrigin().y );
+			event->SetFloat( "z", GetAbsOrigin().z );
+			gameeventmanager->FireEvent( event );
+		}
+	}
+}
diff --git a/game/shared/cstrike/hegrenade_projectile.h b/game/shared/cstrike/hegrenade_projectile.h
new file mode 100644
index 00000000..50df2433
--- /dev/null
+++ b/game/shared/cstrike/hegrenade_projectile.h
@@ -0,0 +1,46 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HEGRENADE_PROJECTILE_H
+#define HEGRENADE_PROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basecsgrenade_projectile.h"
+
+class CHEGrenadeProjectile : public CBaseCSGrenadeProjectile
+{
+public:
+	DECLARE_CLASS( CHEGrenadeProjectile, CBaseCSGrenadeProjectile );
+
+
+// Overrides.
+public:
+	virtual void Spawn();
+	virtual void Precache();
+	virtual void BounceSound( void );
+	virtual void Detonate();
+
+// Grenade stuff.
+public:
+
+	static CHEGrenadeProjectile* Create( 
+		const Vector &position, 
+		const QAngle &angles, 
+		const Vector &velocity, 
+		const AngularImpulse &angVelocity, 
+		CBaseCombatCharacter *pOwner, 
+		float timer );
+
+	void SetTimer( float timer );
+
+private:
+	float m_flDetonateTime;
+};
+
+
+#endif // HEGRENADE_PROJECTILE_H
diff --git a/game/shared/cstrike/weapon_ak47.cpp b/game/shared/cstrike/weapon_ak47.cpp
new file mode 100644
index 00000000..79b54b6b
--- /dev/null
+++ b/game/shared/cstrike/weapon_ak47.cpp
@@ -0,0 +1,103 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CAK47 C_AK47
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CAK47 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CAK47, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CAK47();
+
+	virtual void PrimaryAttack();
+
+	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_AK47; }
+
+private:
+	CAK47( const CAK47 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( AK47, DT_WeaponAK47 )
+
+BEGIN_NETWORK_TABLE( CAK47, DT_WeaponAK47 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CAK47 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_ak47, CAK47 );
+PRECACHE_WEAPON_REGISTER( weapon_ak47 );
+
+// ---------------------------------------------------------------------------- //
+// CAK47 implementation.
+// ---------------------------------------------------------------------------- //
+
+CAK47::CAK47()
+{
+}
+
+
+float CAK47::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.04f + 0.4f * m_flAccuracy;
+		else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+			return 0.04f + 0.07f * m_flAccuracy;
+		else
+			return 0.0275f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+
+void CAK47::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, Primary_Mode ) )
+		return;
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if (pPlayer->GetAbsVelocity().Length2D() > 5 )
+		pPlayer->KickBack ( 1.5, 0.45, 0.225, 0.05, 6.5, 2.5, 7 );
+	else if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack ( 2, 1.0, 0.5, 0.35, 9, 6, 5 );
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack ( 0.9, 0.35, 0.15, 0.025, 5.5, 1.5, 9 );
+	else
+		pPlayer->KickBack ( 1, 0.375, 0.175, 0.0375, 5.75, 1.75, 8 );
+}
diff --git a/game/shared/cstrike/weapon_aug.cpp b/game/shared/cstrike/weapon_aug.cpp
new file mode 100644
index 00000000..319a9fcc
--- /dev/null
+++ b/game/shared/cstrike/weapon_aug.cpp
@@ -0,0 +1,160 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponAug C_WeaponAug
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponAug : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponAug, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponAug();
+
+	virtual void SecondaryAttack();
+	virtual void PrimaryAttack();
+
+ 	virtual float GetInaccuracy() const;
+	virtual bool Reload();
+	virtual bool Deploy();
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_AUG; }
+
+#ifdef CLIENT_DLL
+	virtual bool	HideViewModelWhenZoomed( void ) { return false; }
+#endif
+
+private:
+
+	void AUGFire( float flSpread, bool bZoomed );
+	
+	CWeaponAug( const CWeaponAug & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponAug, DT_WeaponAug )
+
+BEGIN_NETWORK_TABLE( CWeaponAug, DT_WeaponAug )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponAug )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_aug, CWeaponAug );
+PRECACHE_WEAPON_REGISTER( weapon_aug );
+
+
+
+CWeaponAug::CWeaponAug()
+{
+}
+
+void CWeaponAug::SecondaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( pPlayer->GetFOV() == pPlayer->GetDefaultFOV() )
+	{
+		pPlayer->SetFOV( pPlayer, 55, 0.2f );
+		m_weaponMode = Secondary_Mode;
+	}
+	else if ( pPlayer->GetFOV() == 55 )
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), 0.15f );
+		m_weaponMode = Primary_Mode;
+	}
+	else 
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV() );
+		m_weaponMode = Primary_Mode;
+	}
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+}
+
+
+float CWeaponAug::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.035f + 0.4f * m_flAccuracy;
+	
+		else if ( pPlayer->GetAbsVelocity().Length2D() > 140 )
+			return 0.035f + 0.07f * m_flAccuracy;
+		else
+			return 0.02f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponAug::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	bool bZoomed = pPlayer->GetFOV() < pPlayer->GetDefaultFOV();
+
+	float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+	if ( bZoomed )
+		flCycleTime = 0.135f;
+
+	if ( !CSBaseGunFire( flCycleTime, m_weaponMode ) )
+		return;
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( pPlayer->GetAbsVelocity().Length2D() > 5 )
+		 pPlayer->KickBack ( 1, 0.45, 0.275, 0.05, 4, 2.5, 7 );
+	
+	else if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack ( 1.25, 0.45, 0.22, 0.18, 5.5, 4, 5 );
+	
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack ( 0.575, 0.325, 0.2, 0.011, 3.25, 2, 8 );
+	
+	else
+		pPlayer->KickBack ( 0.625, 0.375, 0.25, 0.0125, 3.5, 2.25, 8 );
+}
+
+
+bool CWeaponAug::Reload()
+{
+	m_weaponMode = Primary_Mode;
+	return BaseClass::Reload();
+}
+
+bool CWeaponAug::Deploy()
+{
+	m_weaponMode = Primary_Mode;
+	return BaseClass::Deploy();
+}
diff --git a/game/shared/cstrike/weapon_awp.cpp b/game/shared/cstrike/weapon_awp.cpp
new file mode 100644
index 00000000..bcd41132
--- /dev/null
+++ b/game/shared/cstrike/weapon_awp.cpp
@@ -0,0 +1,306 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponAWP C_WeaponAWP
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+	#include "KeyValues.h"
+
+#endif
+
+#define SNIPER_ZOOM_CONTEXT		"SniperRifleThink"
+
+const int cAWPMidZoomFOV = 40;
+const int cAWPMaxZoomFOV = 10;
+
+#ifdef AWP_UNZOOM
+	ConVar sv_awpunzoomdelay( 
+			"sv_awpunzoomdelay",
+			"1.0",
+			0,
+			"how many seconds to zoom the zoom up after firing",
+			true, 0,	// min value
+			false, 0	// max value
+			);
+#endif
+
+
+class CWeaponAWP : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponAWP, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+#ifndef CLIENT_DLL
+	DECLARE_DATADESC();
+#endif
+	
+	CWeaponAWP();
+
+	virtual void Spawn();
+
+	virtual void PrimaryAttack();
+	virtual void SecondaryAttack();
+
+ 	virtual float GetInaccuracy() const;
+	virtual float GetMaxSpeed() const;
+	virtual bool IsAwp() const;
+	virtual bool Reload();
+	virtual bool Deploy();
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_AWP; }
+
+private:
+
+#ifdef AWP_UNZOOM
+	void				UnzoomThink( void );
+#endif
+
+	CWeaponAWP( const CWeaponAWP & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponAWP, DT_WeaponAWP )
+
+BEGIN_NETWORK_TABLE( CWeaponAWP, DT_WeaponAWP )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponAWP )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_awp, CWeaponAWP );
+PRECACHE_WEAPON_REGISTER( weapon_awp );
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CWeaponAWP )
+#ifdef AWP_UNZOOM
+		DEFINE_THINKFUNC( UnzoomThink ),
+#endif
+	END_DATADESC()
+
+#endif
+
+CWeaponAWP::CWeaponAWP()
+{
+}
+
+void CWeaponAWP::Spawn()
+{
+	Precache();
+
+	BaseClass::Spawn();
+}
+
+
+void CWeaponAWP::SecondaryAttack()
+{
+	const float kZoomTime = 0.10f;
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if ( pPlayer == NULL )
+	{
+		Assert( pPlayer != NULL );
+		return;
+	}
+
+	if ( pPlayer->GetFOV() == pPlayer->GetDefaultFOV() )
+	{
+			pPlayer->SetFOV( pPlayer, cAWPMidZoomFOV, kZoomTime );
+			m_weaponMode = Secondary_Mode;
+			m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyAltSwitch;
+	}
+	else if ( pPlayer->GetFOV() == cAWPMidZoomFOV )
+	{
+			pPlayer->SetFOV( pPlayer, cAWPMaxZoomFOV, kZoomTime );
+			m_weaponMode = Secondary_Mode;
+	}
+	else
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), kZoomTime );
+		m_weaponMode = Primary_Mode;
+	}
+
+
+#ifndef CLIENT_DLL
+	// If this isn't guarded, the sound will be emitted twice, once by the server and once by the client.
+	// Let the server play it since if only the client plays it, it's liable to get played twice cause of
+	// a prediction error. joy.	
+	
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Playing this from the player so that we don't try to play the sound outside the level.
+	//=============================================================================
+	if ( GetPlayerOwner() )
+	{
+		GetPlayerOwner()->EmitSound( "Default.Zoom" );
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	// let the bots hear the rifle zoom
+	IGameEvent * event = gameeventmanager->CreateEvent( "weapon_zoom" );
+	if ( event )
+	{
+		event->SetInt( "userid", pPlayer->GetUserID() );
+		gameeventmanager->FireEvent( event );
+	}
+#endif
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.3f;
+	m_zoomFullyActiveTime = gpGlobals->curtime + 0.15; // The worst zoom time from above.  
+
+}
+
+float CWeaponAWP::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		float fSpread = 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			fSpread = 0.85f;
+	
+		else if ( pPlayer->GetAbsVelocity().Length2D() > 140 )
+			fSpread = 0.25f;
+	
+		else if ( pPlayer->GetAbsVelocity().Length2D() > 10 )
+			fSpread = 0.10f;
+	
+		else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+			fSpread = 0.0f;
+	
+		else
+			fSpread = 0.001f;
+	
+		// If we are not zoomed in, or we have very recently zoomed and are still transitioning, the bullet diverts more.
+		if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV() || (gpGlobals->curtime < m_zoomFullyActiveTime))
+		{
+			fSpread += 0.08f;
+		}
+	
+		return fSpread;
+	}
+	else
+	{
+		return BaseClass::GetInaccuracy();
+	}
+}
+
+void CWeaponAWP::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, m_weaponMode ) )
+		return;
+
+	if ( m_weaponMode == Secondary_Mode )
+	{	
+		float	midFOVdistance = fabs( pPlayer->GetFOV() - (float)cAWPMidZoomFOV );
+		float	farFOVdistance = fabs( pPlayer->GetFOV() - (float)cAWPMaxZoomFOV );
+		if ( midFOVdistance < farFOVdistance )
+		{
+			pPlayer->m_iLastZoom = cAWPMidZoomFOV;
+		}
+		else
+		{
+			pPlayer->m_iLastZoom = cAWPMaxZoomFOV;
+		}
+		
+		#ifdef AWP_UNZOOM
+			SetContextThink( &CWeaponAWP::UnzoomThink, gpGlobals->curtime + sv_awpunzoomdelay.GetFloat(), SNIPER_ZOOM_CONTEXT );
+		#else
+			pPlayer->m_bResumeZoom = true;
+			pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), 0.1f );
+			m_weaponMode = Primary_Mode;
+		#endif
+	}
+
+	QAngle angle = pPlayer->GetPunchAngle();
+	angle.x -= 2;
+	pPlayer->SetPunchAngle( angle );
+}
+
+#ifdef AWP_UNZOOM
+void CWeaponAWP::UnzoomThink( void )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if (pPlayer == NULL)
+	{
+		Assert(pPlayer != NULL);
+		return;
+	}
+
+	pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), 0.1f );
+}
+#endif
+
+
+float CWeaponAWP::GetMaxSpeed() const
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if (pPlayer == NULL)
+	{
+		Assert(pPlayer != NULL);
+		return BaseClass::GetMaxSpeed();
+	}
+
+	if ( pPlayer->GetFOV() == pPlayer->GetDefaultFOV() )
+	{
+		return BaseClass::GetMaxSpeed();
+	}
+	else
+	{
+		// Slower speed when zoomed in.
+		return 150;
+	}
+}
+
+
+bool CWeaponAWP::IsAwp() const
+{
+	return true;
+}
+
+
+bool CWeaponAWP::Reload()
+{
+	m_weaponMode = Primary_Mode;
+	return BaseClass::Reload();
+}
+
+bool CWeaponAWP::Deploy()
+{
+	// don't allow weapon switching to shortcut cycle time (quickswitch exploit)
+	float fOldNextPrimaryAttack	= m_flNextPrimaryAttack;
+	float fOldNextSecondaryAttack = m_flNextSecondaryAttack;
+
+	if ( !BaseClass::Deploy() )
+		return false;
+
+	m_weaponMode = Primary_Mode;
+	m_flNextPrimaryAttack	= MAX( m_flNextPrimaryAttack, fOldNextPrimaryAttack );
+	m_flNextSecondaryAttack	= MAX( m_flNextSecondaryAttack, fOldNextSecondaryAttack );
+	return true;
+}
diff --git a/game/shared/cstrike/weapon_basecsgrenade.cpp b/game/shared/cstrike/weapon_basecsgrenade.cpp
new file mode 100644
index 00000000..618a96b0
--- /dev/null
+++ b/game/shared/cstrike/weapon_basecsgrenade.cpp
@@ -0,0 +1,438 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "gamerules.h"
+#include "npcevent.h"
+#include "engine/IEngineSound.h"
+#include "weapon_basecsgrenade.h"
+#include "in_buttons.h"	
+#include "datacache/imdlcache.h"
+
+
+
+#ifdef CLIENT_DLL
+
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+	#include "items.h"
+	#include "../../server/cstrike/cs_gamestats.h"
+
+#endif
+
+
+#define GRENADE_TIMER	1.5f //Seconds
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseCSGrenade, DT_BaseCSGrenade )
+
+BEGIN_NETWORK_TABLE(CBaseCSGrenade, DT_BaseCSGrenade)
+
+#ifndef CLIENT_DLL
+	SendPropBool( SENDINFO(m_bRedraw) ),
+	SendPropBool( SENDINFO(m_bPinPulled) ),
+	SendPropFloat( SENDINFO(m_fThrowTime), 0, SPROP_NOSCALE ),
+#else
+	RecvPropBool( RECVINFO(m_bRedraw) ),
+	RecvPropBool( RECVINFO(m_bPinPulled) ),
+	RecvPropFloat( RECVINFO(m_fThrowTime) ),
+#endif
+
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CBaseCSGrenade )
+	DEFINE_PRED_FIELD( m_bRedraw, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bRedraw, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_basecsgrenade, CBaseCSGrenade );
+
+#ifndef CLIENT_DLL
+ConVar sv_ignoregrenaderadio( "sv_ignoregrenaderadio", "0", 0, "Turn off Fire in the hole messages" );
+#endif
+
+CBaseCSGrenade::CBaseCSGrenade()
+{
+	m_bRedraw = false;
+	m_bPinPulled = false;
+	m_fThrowTime = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::Precache()
+{
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseCSGrenade::Deploy()
+{
+	m_bRedraw = false;
+	m_bPinPulled = false;
+	m_fThrowTime = 0;
+
+#ifndef CLIENT_DLL
+	// if we're officially out of grenades, ditch this weapon
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if( pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
+	{
+		pPlayer->Weapon_Drop( this, NULL, NULL );
+		UTIL_Remove(this);
+		return false;
+	}
+#endif
+
+	return BaseClass::Deploy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseCSGrenade::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	m_bRedraw = false;
+	m_bPinPulled = false; // when this is holstered make sure the pin isn’t pulled.
+	m_fThrowTime = 0;
+
+#ifndef CLIENT_DLL
+	// If they attempt to switch weapons before the throw animation is done, 
+	// allow it, but kill the weapon if we have to.
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if( pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
+	{
+		CBaseCombatCharacter *pOwner = (CBaseCombatCharacter *)pPlayer;
+		pOwner->Weapon_Drop( this );
+		UTIL_Remove(this);
+	}
+#endif
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::PrimaryAttack()
+{
+	if ( m_bRedraw || m_bPinPulled || m_fThrowTime > 0.0f )
+		return;
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer || pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
+		return;
+
+	// The pull pin animation has to finish, then we wait until they aren't holding the primary
+	// attack button, then throw the grenade.
+	SendWeaponAnim( ACT_VM_PULLPIN );
+	m_bPinPulled = true;
+
+	// Don't let weapon idle interfere in the middle of a throw!
+	MDLCACHE_CRITICAL_SECTION();
+	SetWeaponIdleTime( gpGlobals->curtime + SequenceDuration() );
+
+	m_flNextPrimaryAttack	= gpGlobals->curtime + SequenceDuration();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::SecondaryAttack()
+{
+	if ( m_bRedraw )
+		return;
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	
+	if ( pPlayer == NULL )
+		return;
+
+	//See if we're ducking
+	if ( pPlayer->GetFlags() & FL_DUCKING )
+	{
+		//Send the weapon animation
+		SendWeaponAnim( ACT_VM_SECONDARYATTACK );
+	}
+	else
+	{
+		//Send the weapon animation
+		SendWeaponAnim( ACT_VM_HAULBACK );
+	}
+
+	// Don't let weapon idle interfere in the middle of a throw!
+	SetWeaponIdleTime( gpGlobals->curtime + SequenceDuration() );
+
+	m_flNextSecondaryAttack	= gpGlobals->curtime + SequenceDuration();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseCSGrenade::Reload()
+{
+	if ( ( m_bRedraw ) && ( m_flNextPrimaryAttack <= gpGlobals->curtime ) && ( m_flNextSecondaryAttack <= gpGlobals->curtime ) )
+	{
+		//Redraw the weapon
+		SendWeaponAnim( ACT_VM_DRAW );
+
+		//Update our times
+		m_flNextPrimaryAttack	= gpGlobals->curtime + SequenceDuration();
+		m_flNextSecondaryAttack	= gpGlobals->curtime + SequenceDuration();
+
+		SetWeaponIdleTime( gpGlobals->curtime + SequenceDuration() );
+		
+		//Mark this as done
+	//	m_bRedraw = false;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseCSGrenade::ItemPostFrame()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	CBaseViewModel *vm = pPlayer->GetViewModel( m_nViewModelIndex );
+	if ( !vm )
+		return;
+
+	// If they let go of the fire button, they want to throw the grenade.
+	if ( m_bPinPulled && !(pPlayer->m_nButtons & IN_ATTACK) ) 
+	{
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_THROW_GRENADE );
+
+		StartGrenadeThrow();
+		
+		MDLCACHE_CRITICAL_SECTION();
+		m_bPinPulled = false;
+		SendWeaponAnim( ACT_VM_THROW );	
+		SetWeaponIdleTime( gpGlobals->curtime + SequenceDuration() );
+
+		m_flNextPrimaryAttack	= gpGlobals->curtime + SequenceDuration(); // we're still throwing, so reset our next primary attack
+
+#ifndef CLIENT_DLL
+		IGameEvent * event = gameeventmanager->CreateEvent( "weapon_fire" );
+		if( event )
+		{
+			const char *weaponName = STRING( m_iClassname );
+			if ( strncmp( weaponName, "weapon_", 7 ) == 0 )
+			{
+				weaponName += 7;
+			}
+
+			event->SetInt( "userid", pPlayer->GetUserID() );
+			event->SetString( "weapon", weaponName );
+			gameeventmanager->FireEvent( event );
+		}
+#endif
+	}
+	else if ((m_fThrowTime > 0) && (m_fThrowTime < gpGlobals->curtime))
+	{
+		// only decrement our ammo when we actually create the projectile
+		DecrementAmmo( pPlayer );
+
+		ThrowGrenade();
+	}
+	else if( m_bRedraw )
+	{
+		// Has the throw animation finished playing
+		if( m_flTimeWeaponIdle < gpGlobals->curtime )
+		{
+#ifdef GAME_DLL
+			// if we're officially out of grenades, ditch this weapon
+			if( pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
+			{
+				pPlayer->Weapon_Drop( this, NULL, NULL );
+				UTIL_Remove(this);
+			}
+			else
+			{
+				pPlayer->SwitchToNextBestWeapon( this );
+			}
+#endif
+			return;	//don't animate this grenade any more!
+		}	
+	}
+	else if( !m_bRedraw )
+	{
+		BaseClass::ItemPostFrame();
+	}
+}
+
+
+
+#ifdef CLIENT_DLL
+
+	void CBaseCSGrenade::DecrementAmmo( CBaseCombatCharacter *pOwner )
+	{
+	}
+
+	void CBaseCSGrenade::DropGrenade()
+	{
+		m_bRedraw = true;
+		m_fThrowTime = 0.0f;
+	}
+
+	void CBaseCSGrenade::ThrowGrenade()
+	{
+		m_bRedraw = true;
+		m_fThrowTime = 0.0f;
+	}
+
+	void CBaseCSGrenade::StartGrenadeThrow()
+	{
+		m_fThrowTime = gpGlobals->curtime + 0.1f;
+	}
+
+#else
+
+	BEGIN_DATADESC( CBaseCSGrenade )
+		DEFINE_FIELD( m_bRedraw, FIELD_BOOLEAN ),
+	END_DATADESC()
+
+	int CBaseCSGrenade::CapabilitiesGet()
+	{
+		return bits_CAP_WEAPON_RANGE_ATTACK1; 
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : *pOwner - 
+	//-----------------------------------------------------------------------------
+	void CBaseCSGrenade::DecrementAmmo( CBaseCombatCharacter *pOwner )
+	{
+		pOwner->RemoveAmmo( 1, m_iPrimaryAmmoType );
+	}
+
+	void CBaseCSGrenade::StartGrenadeThrow()
+	{
+		m_fThrowTime = gpGlobals->curtime + 0.1f;
+	}
+
+	void CBaseCSGrenade::ThrowGrenade()
+	{
+		CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return;
+		}
+
+		QAngle angThrow = pPlayer->LocalEyeAngles();
+
+		Vector vForward, vRight, vUp;
+
+		if ( angThrow.x < 0 )
+		{
+			angThrow.x += 360; // make sure we have a positive angle from LocalEyeAngles()
+		}
+
+		if ( angThrow.x < 90 )
+			angThrow.x = -10 + angThrow.x * ((90 + 10) / 90.0);
+		else
+		{
+			angThrow.x = 360.0f - angThrow.x;
+			angThrow.x = -10 + angThrow.x * -((90 - 10) / 90.0);
+		}
+
+		float flVel = (90 - angThrow.x) * 6;
+
+		if (flVel > 750)
+			flVel = 750;
+
+		AngleVectors( angThrow, &vForward, &vRight, &vUp );
+
+		Vector vecSrc = pPlayer->GetAbsOrigin() + pPlayer->GetViewOffset();
+
+		// We want to throw the grenade from 16 units out.  But that can cause problems if we're facing
+		// a thin wall.  Do a hull trace to be safe.
+		trace_t trace;
+		Vector mins( -2, -2, -2 );
+		Vector maxs(  2,  2,  2 );
+		UTIL_TraceHull( vecSrc, vecSrc + vForward * 16, mins, maxs, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &trace );
+		vecSrc = trace.endpos;
+
+		Vector vecThrow = vForward * flVel + pPlayer->GetAbsVelocity();
+
+		EmitGrenade( vecSrc, vec3_angle, vecThrow, AngularImpulse(600,random->RandomInt(-1200,1200),0), pPlayer );
+
+		m_bRedraw = true;
+		m_fThrowTime = 0.0f;
+
+		CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+
+		if( pCSPlayer )
+		{
+			if ( !sv_ignoregrenaderadio.GetBool() )
+			{
+				pCSPlayer->Radio( "Radio.FireInTheHole",   "#Cstrike_TitlesTXT_Fire_in_the_hole" );
+			}
+			CCS_GameStats.IncrementStat(pCSPlayer, CSSTAT_GRENADES_THROWN, 1);
+		}
+	}
+
+	void CBaseCSGrenade::DropGrenade()
+	{
+		CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+		if ( !pPlayer )
+		{
+			Assert( false );
+			return;
+		}
+
+		Vector vForward;
+		pPlayer->EyeVectors( &vForward );
+		Vector vecSrc = pPlayer->GetAbsOrigin() + pPlayer->GetViewOffset() + vForward * 16; 
+
+		Vector vecVel = pPlayer->GetAbsVelocity();
+
+		EmitGrenade( vecSrc, vec3_angle, vecVel, AngularImpulse(600,random->RandomInt(-1200,1200),0), pPlayer );
+
+		CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+
+		if( pCSPlayer )
+		{
+			CCS_GameStats.IncrementStat(pCSPlayer, CSSTAT_GRENADES_THROWN, 1);
+		}
+
+		m_bRedraw = true;
+		m_fThrowTime = 0.0f;
+	}
+
+	void CBaseCSGrenade::EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer )
+	{
+		Assert( 0 && "CBaseCSGrenade::EmitGrenade should not be called. Make sure to implement this in your subclass!\n" );
+	}
+
+	bool CBaseCSGrenade::AllowsAutoSwitchFrom( void ) const
+	{
+		return !m_bPinPulled;
+	}
+
+#endif
+
diff --git a/game/shared/cstrike/weapon_basecsgrenade.h b/game/shared/cstrike/weapon_basecsgrenade.h
new file mode 100644
index 00000000..334e8ab3
--- /dev/null
+++ b/game/shared/cstrike/weapon_basecsgrenade.h
@@ -0,0 +1,82 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_BASECSGRENADE_H
+#define WEAPON_BASECSGRENADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_csbase.h"
+
+
+#ifdef CLIENT_DLL
+	
+	#define CBaseCSGrenade C_BaseCSGrenade
+
+#endif
+
+
+class CBaseCSGrenade : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CBaseCSGrenade, CWeaponCSBase );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CBaseCSGrenade();
+
+	virtual void	Precache();
+
+	bool			Deploy();
+	bool			Holster( CBaseCombatWeapon *pSwitchingTo );
+
+	void			PrimaryAttack();
+	void			SecondaryAttack();
+
+// 	virtual float GetSpread() const;
+
+	bool			Reload();
+
+	virtual void	ItemPostFrame();
+	
+	void			DecrementAmmo( CBaseCombatCharacter *pOwner );
+	virtual void	StartGrenadeThrow();
+	virtual void	ThrowGrenade();
+	virtual void	DropGrenade();
+
+	bool IsPinPulled() const;
+	bool IsBeingThrown() const { return m_fThrowTime > 0; }
+
+#ifndef CLIENT_DLL
+	DECLARE_DATADESC();
+
+	virtual bool AllowsAutoSwitchFrom( void ) const;
+
+	int		CapabilitiesGet();
+	
+	// Each derived grenade class implements this.
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer );
+#endif
+
+protected:
+	CNetworkVar( bool, m_bRedraw );	// Draw the weapon again after throwing a grenade
+	CNetworkVar( bool, m_bPinPulled );	// Set to true when the pin has been pulled but the grenade hasn't been thrown yet.
+	CNetworkVar( float, m_fThrowTime ); // the time at which the grenade will be thrown.  If this value is 0 then the time hasn't been set yet.
+
+private:
+	CBaseCSGrenade( const CBaseCSGrenade & ) {}
+};
+
+
+inline bool CBaseCSGrenade::IsPinPulled() const
+{
+	return m_bPinPulled;
+}
+
+
+#endif // WEAPON_BASECSGRENADE_H
diff --git a/game/shared/cstrike/weapon_c4.cpp b/game/shared/cstrike/weapon_c4.cpp
new file mode 100644
index 00000000..e75d6a3c
--- /dev/null
+++ b/game/shared/cstrike/weapon_c4.cpp
@@ -0,0 +1,1353 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_c4.h"
+#include "in_buttons.h"
+#include "cs_gamerules.h"
+#include "decals.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include "KeyValues.h"
+#include "fx_cs_shared.h"
+#include "obstacle_pushaway.h"
+
+#if defined( CLIENT_DLL )
+	#include "c_cs_player.h"
+#else
+	#include "cs_player.h"
+	#include "explode.h"
+	#include "mapinfo.h"
+	#include "team.h"
+	#include "func_bomb_target.h"
+	#include "vguiscreen.h"
+	#include "bot.h"
+	#include "cs_player.h"
+	#include <KeyValues.h>
+
+//=============================================================================
+// HPE_BEGIN
+// [dwenger] Necessary for stats tracking
+//=============================================================================
+#include "cs_gamestats.h"
+#include "cs_achievement_constants.h"
+//=============================================================================
+// HPE_END
+//=============================================================================
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+#define BLINK_INTERVAL 2.0
+#define PLANTED_C4_MODEL "models/weapons/w_c4_planted.mdl"
+#define HEIST_MODE_C4_TIME 25
+
+int g_sModelIndexC4Glow = -1;
+
+#define WEAPON_C4_ARM_TIME	3.0
+
+
+#ifdef CLIENT_DLL
+
+#else
+
+
+	LINK_ENTITY_TO_CLASS( planted_c4, CPlantedC4 );
+	PRECACHE_REGISTER( planted_c4 );
+
+	BEGIN_DATADESC( CPlantedC4 )
+		DEFINE_FUNCTION( C4Think )
+	END_DATADESC()
+	
+
+	IMPLEMENT_SERVERCLASS_ST( CPlantedC4, DT_PlantedC4 )
+		SendPropBool( SENDINFO(m_bBombTicking) ),
+		SendPropFloat( SENDINFO(m_flC4Blow), 0, SPROP_NOSCALE ),
+		SendPropFloat( SENDINFO(m_flTimerLength), 0, SPROP_NOSCALE ),
+		SendPropFloat( SENDINFO(m_flDefuseLength), 0, SPROP_NOSCALE ),
+		SendPropFloat( SENDINFO(m_flDefuseCountDown), 0, SPROP_NOSCALE ),
+	END_SEND_TABLE()
+
+	
+BEGIN_PREDICTION_DATA( CPlantedC4 )
+END_PREDICTION_DATA()
+
+
+
+	CUtlVector< CPlantedC4* > g_PlantedC4s;
+
+
+	CPlantedC4::CPlantedC4()
+	{
+		g_PlantedC4s.AddToTail( this );
+        //=============================================================================
+        // HPE_BEGIN:        
+        //=============================================================================
+         
+        // [tj] No planter initially
+        m_pPlanter = NULL;
+
+        // [tj] Assume this is the original owner
+        m_bPlantedAfterPickup = false;
+         
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+        
+	}
+
+	CPlantedC4::~CPlantedC4()
+	{
+		g_PlantedC4s.FindAndRemove( this );
+
+		int i;
+		// Kill the control panels
+		for ( i = m_hScreens.Count(); --i >= 0; )
+		{
+			DestroyVGuiScreen( m_hScreens[i].Get() );
+		}
+		m_hScreens.RemoveAll();
+	}
+
+	int CPlantedC4::UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_FULLCHECK );
+	}
+
+	int CPlantedC4::ShouldTransmit( const CCheckTransmitInfo *pInfo )
+	{
+		// Terrorists always need this object for the radar
+		// Everybody needs it for hiding the round timer and showing the planted C4 scenario icon
+		return FL_EDICT_ALWAYS;
+	}
+
+	void CPlantedC4::Precache()
+	{
+		g_sModelIndexC4Glow = PrecacheModel( "sprites/ledglow.vmt" );
+		PrecacheModel( PLANTED_C4_MODEL );
+		PrecacheVGuiScreen( "c4_panel" );
+
+		engine->ForceModelBounds( PLANTED_C4_MODEL, Vector( -7, -13, -3 ), Vector( 9, 12, 11 ) );
+
+		PrecacheParticleSystem( "bomb_explosion_huge" );
+	}
+
+	void CPlantedC4::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName )
+	{
+		pPanelName = "c4_panel";
+	}
+
+	void CPlantedC4::GetControlPanelClassName( int nPanelIndex, const char *&pPanelName )
+	{
+		pPanelName = "vgui_screen";
+	}
+
+	//-----------------------------------------------------------------------------
+	// This is called by the base object when it's time to spawn the control panels
+	//-----------------------------------------------------------------------------
+	void CPlantedC4::SpawnControlPanels()
+	{
+		char buf[64];
+
+		// FIXME: Deal with dynamically resizing control panels?
+
+		// If we're attached to an entity, spawn control panels on it instead of use
+		CBaseAnimating *pEntityToSpawnOn = this;
+		const char *pOrgLL = "controlpanel%d_ll";
+		const char *pOrgUR = "controlpanel%d_ur";
+		const char *pAttachmentNameLL = pOrgLL;
+		const char *pAttachmentNameUR = pOrgUR;
+
+		Assert( pEntityToSpawnOn );
+
+		// Lookup the attachment point...
+		int nPanel;
+		for ( nPanel = 0; true; ++nPanel )
+		{
+			Q_snprintf( buf, sizeof( buf ), pAttachmentNameLL, nPanel );
+			int nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
+			if (nLLAttachmentIndex <= 0)
+			{
+				// Try and use my panels then
+				pEntityToSpawnOn = this;
+				Q_snprintf( buf, sizeof( buf ), pOrgLL, nPanel );
+				nLLAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
+				if (nLLAttachmentIndex <= 0)
+					return;
+			}
+
+			Q_snprintf( buf, sizeof( buf ), pAttachmentNameUR, nPanel );
+			int nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
+			if (nURAttachmentIndex <= 0)
+			{
+				// Try and use my panels then
+				Q_snprintf( buf, sizeof( buf ), pOrgUR, nPanel );
+				nURAttachmentIndex = pEntityToSpawnOn->LookupAttachment(buf);
+				if (nURAttachmentIndex <= 0)
+					return;
+			}
+
+			const char *pScreenName;
+			GetControlPanelInfo( nPanel, pScreenName );
+			if (!pScreenName)
+				continue;
+
+			const char *pScreenClassname;
+			GetControlPanelClassName( nPanel, pScreenClassname );
+			if ( !pScreenClassname )
+				continue;
+
+			// Compute the screen size from the attachment points...
+			matrix3x4_t	panelToWorld;
+			pEntityToSpawnOn->GetAttachment( nLLAttachmentIndex, panelToWorld );
+
+			matrix3x4_t	worldToPanel;
+			MatrixInvert( panelToWorld, worldToPanel );
+
+			// Now get the lower right position + transform into panel space
+			Vector lr, lrlocal;
+			pEntityToSpawnOn->GetAttachment( nURAttachmentIndex, panelToWorld );
+			MatrixGetColumn( panelToWorld, 3, lr );
+			VectorTransform( lr, worldToPanel, lrlocal );
+
+			float flWidth = lrlocal.x;
+			float flHeight = lrlocal.y;
+
+			CVGuiScreen *pScreen = CreateVGuiScreen( pScreenClassname, pScreenName, pEntityToSpawnOn, this, nLLAttachmentIndex );
+			pScreen->ChangeTeam( GetTeamNumber() );
+			pScreen->SetActualSize( flWidth, flHeight );
+			pScreen->SetActive( true );
+			pScreen->MakeVisibleOnlyToTeammates( false );
+			int nScreen = m_hScreens.AddToTail( );
+			m_hScreens[nScreen].Set( pScreen );			
+		}
+	}
+
+	void CPlantedC4::SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways )
+	{
+		// Are we already marked for transmission?
+		if ( pInfo->m_pTransmitEdict->Get( entindex() ) )
+			return;
+
+		BaseClass::SetTransmit( pInfo, bAlways );
+
+		// Force our screens to be sent too.
+		for ( int i=0; i < m_hScreens.Count(); i++ )
+		{
+			CVGuiScreen *pScreen = m_hScreens[i].Get();
+			pScreen->SetTransmit( pInfo, bAlways );
+		}
+	}
+
+	CPlantedC4* CPlantedC4::ShootSatchelCharge( CCSPlayer *pevOwner, Vector vecStart, QAngle vecAngles )
+	{
+		CPlantedC4 *pGrenade = dynamic_cast< CPlantedC4* >( CreateEntityByName( "planted_c4" ) );
+		if ( pGrenade )
+		{
+			vecAngles[0] = 0;
+			vecAngles[2] = 0;
+			pGrenade->Init( pevOwner, vecStart, vecAngles );
+			return pGrenade;
+		}
+		else
+		{
+			Warning( "Can't create planted_c4 entity!\n" );
+			return NULL;
+		}
+	}
+
+
+	void CPlantedC4::Init( CCSPlayer *pevOwner, Vector vecStart, QAngle vecAngles )
+	{
+		SetMoveType( MOVETYPE_NONE );
+		SetSolid( SOLID_NONE );
+
+		SetModel( PLANTED_C4_MODEL );	// Change this to c4 model
+
+		SetCollisionBounds( Vector( 0, 0, 0 ), Vector( 8, 8, 8 ) );
+
+		SetAbsOrigin( vecStart );
+		SetAbsAngles( vecAngles );
+		SetOwnerEntity( pevOwner );
+        
+        //=============================================================================
+        // HPE_BEGIN:
+        // [tj] Set the planter when the bomb is planted.
+        //=============================================================================
+         
+        SetPlanter( pevOwner );
+         
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+        
+		
+		// Detonate in "time" seconds
+		SetThink( &CPlantedC4::C4Think );
+
+		SetNextThink( gpGlobals->curtime + 0.1f );
+		
+		m_flTimerLength = mp_c4timer.GetInt();
+
+		m_flC4Blow = gpGlobals->curtime + m_flTimerLength;
+		m_flNextDefuse = 0;
+
+		m_bStartDefuse = false;
+		m_bBombTicking = true;
+		SetFriction( 0.9 );
+
+		m_flDefuseLength = 0.0f;
+		
+		SpawnControlPanels();
+	}
+
+	void CPlantedC4::C4Think()
+	{
+		if (!IsInWorld())
+		{
+			UTIL_Remove( this );
+			return;
+		}
+
+		//Bomb is dead, don't think anymore
+		if( !m_bBombTicking )
+		{
+			SetThink( NULL );
+			return;
+		}
+				
+
+		SetNextThink( gpGlobals->curtime + 0.12 );
+
+#ifndef CLIENT_DLL
+		// let the bots hear the bomb beeping
+		// BOTPORT: Emit beep events at same time as client effects
+		IGameEvent * event = gameeventmanager->CreateEvent( "bomb_beep" );
+		if( event )
+		{
+			event->SetInt( "entindex", entindex() );
+			gameeventmanager->FireEvent( event );
+		}
+#endif
+		
+		// IF the timer has expired ! blow this bomb up!
+		if (m_flC4Blow <= gpGlobals->curtime)
+		{
+			// give the defuser credit for defusing the bomb
+			CCSPlayer* pBombOwner = ToCSPlayer(GetOwnerEntity());
+			if ( pBombOwner )
+			{
+                if (CSGameRules()->m_iRoundWinStatus == WINNER_NONE)
+				    pBombOwner->IncrementFragCount( 3 );
+			}
+
+			CSGameRules()->m_bBombDropped = false;
+
+			trace_t tr;
+			Vector vecSpot = GetAbsOrigin();
+			vecSpot[2] += 8;
+
+			UTIL_TraceLine( vecSpot, vecSpot + Vector ( 0, 0, -40 ), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
+
+			Explode( &tr, DMG_BLAST );
+
+			CSGameRules()->m_bBombPlanted = false;
+
+			CCS_GameStats.Event_BombExploded(pBombOwner);
+
+			IGameEvent * event = gameeventmanager->CreateEvent( "bomb_exploded" );
+			if( event )
+			{
+				event->SetInt( "userid", pBombOwner?pBombOwner->GetUserID():-1 );
+				event->SetInt( "site", m_iBombSiteIndex );
+				event->SetInt( "priority", 9 );
+				gameeventmanager->FireEvent( event );
+			}
+
+			// skip additional processing once the bomb has exploded
+			return;
+		}
+
+		//if the defusing process has started
+		if ((m_bStartDefuse == true) && (m_pBombDefuser != NULL))
+		{
+			//if the defusing process has not ended yet
+			if ( m_flDefuseCountDown > gpGlobals->curtime)
+			{
+				int iOnGround = FBitSet( m_pBombDefuser->GetFlags(), FL_ONGROUND );
+
+				//if the bomb defuser has stopped defusing the bomb
+				if( m_flNextDefuse < gpGlobals->curtime || !iOnGround )
+				{
+					if ( !iOnGround && m_pBombDefuser->IsAlive() )
+						ClientPrint( m_pBombDefuser, HUD_PRINTCENTER, "#C4_Defuse_Must_Be_On_Ground");
+
+					// release the player from being frozen
+					m_pBombDefuser->m_bIsDefusing = false;
+
+#ifndef CLIENT_DLL
+					// tell the bots someone has aborted defusing
+					IGameEvent * event = gameeventmanager->CreateEvent( "bomb_abortdefuse" );
+					if( event )
+					{
+						event->SetInt("userid", m_pBombDefuser->GetUserID() );
+						event->SetInt( "priority", 6 );
+						gameeventmanager->FireEvent( event );
+					}
+#endif
+
+					//cancel the progress bar
+					m_pBombDefuser->SetProgressBarTime( 0 );
+                    m_pBombDefuser->OnCanceledDefuse();
+					m_pBombDefuser = NULL;
+					m_bStartDefuse = false;
+					m_flDefuseCountDown = 0;
+					m_flDefuseLength = 0;	//force it to show completely defused
+				}
+
+				return;
+			}
+
+			//if the defuse process has ended, kill the c4
+			if ( !m_pBombDefuser->IsDead() )
+			{
+                //=============================================================================
+                // HPE_BEGIN
+                // [dwenger] Stats update for bomb defusing
+                //=============================================================================
+                CCS_GameStats.Event_BombDefused( m_pBombDefuser );
+                //=============================================================================
+                // HPE_END
+                //=============================================================================
+
+				IGameEvent * event = gameeventmanager->CreateEvent( "bomb_defused" );
+				if( event )
+				{
+					event->SetInt("userid", m_pBombDefuser->GetUserID() );
+					event->SetInt("site", m_iBombSiteIndex );
+					event->SetInt( "priority", 9 );
+					gameeventmanager->FireEvent( event );
+
+                    //=============================================================================
+                    // HPE_BEGIN
+                    // [dwenger] Server-side processing for defusing bombs
+                    //=============================================================================
+                    m_pBombDefuser->AwardAchievement(CSWinBombDefuse);
+
+                    float   timeToDetonation = (m_flC4Blow - gpGlobals->curtime);
+
+					if ((timeToDetonation > 0.0f) && (timeToDetonation <= AchievementConsts::BombDefuseCloseCall_MaxTimeRemaining))
+                    {
+                        // Give achievement for defusing with < 1 second before detonation
+                        m_pBombDefuser->AwardAchievement(CSBombDefuseCloseCall);
+                    }
+
+                    if ((timeToDetonation > 0.0f) && (m_pBombDefuser->HasDefuser()) && (timeToDetonation < AchievementConsts::BombDefuseNeededKit_MaxTime))
+                    {
+                        // Give achievement for defusing with a defuse kit when not having the kit would have taken too long
+                        m_pBombDefuser->AwardAchievement(CSDefuseAndNeededKit);
+                    }
+
+                    // [dwenger] Added for fun-fact support
+                    if ( m_pBombDefuser->PickedUpDefuser() )
+                    {
+                        // Defuser kit was picked up, so set the fun fact
+                        m_pBombDefuser->SetDefusedWithPickedUpKit(true);
+                    }
+
+                    //=============================================================================
+                    // HPE_END
+                    //=============================================================================
+				}
+
+			
+				Vector soundPosition = m_pBombDefuser->GetAbsOrigin() + Vector( 0, 0, 5 );
+				CPASAttenuationFilter filter( soundPosition );
+
+				EmitSound( filter, entindex(), "c4.disarmfinish" );
+								
+				// The bomb has just been disarmed.. Check to see if the round should end now
+				m_bBombTicking = false;
+
+				// release the player from being frozen
+				m_pBombDefuser->m_bIsDefusing = false;
+
+				CSGameRules()->m_bBombDefused = true;
+				//=============================================================================
+				// HPE_BEGIN:
+				// [menglish] Give the bomb defuser an mvp if they ended the round
+				//=============================================================================				 
+				bool roundWasAlreadyWon = (CSGameRules()->m_iRoundWinStatus != WINNER_NONE);
+
+				if(CSGameRules()->CheckWinConditions() && !roundWasAlreadyWon)
+				{
+					m_pBombDefuser->IncrementNumMVPs( CSMVP_BOMBDEFUSE );
+				}				 
+				//=============================================================================
+				// HPE_END
+				//=============================================================================
+
+				// give the defuser credit for defusing the bomb
+				m_pBombDefuser->IncrementFragCount( 3 );
+
+				CSGameRules()->m_bBombDropped = false;
+				CSGameRules()->m_bBombPlanted = false;
+				
+				// Clear their progress bar.
+				m_pBombDefuser->SetProgressBarTime( 0 );
+
+				m_pBombDefuser = NULL;
+				m_bStartDefuse = false;
+
+				m_flDefuseLength = 10;
+
+				return;
+			}
+
+			//if it gets here then the previouse defuser has taken off or been killed
+
+#ifndef CLIENT_DLL
+			// tell the bots someone has aborted defusing
+			IGameEvent * event = gameeventmanager->CreateEvent( "bomb_abortdefuse" );
+			if ( event )
+			{
+				event->SetInt("userid", m_pBombDefuser->GetUserID() );
+				event->SetInt( "priority", 6 );
+				gameeventmanager->FireEvent( event );
+			}
+#endif
+
+			// release the player from being frozen
+			m_pBombDefuser->m_bIsDefusing = false;
+			m_bStartDefuse = false;
+			m_pBombDefuser = NULL;
+		}
+	}
+
+	// Regular explosions
+	void CPlantedC4::Explode( trace_t *pTrace, int bitsDamageType )
+	{
+		// Check to see if the round is over after the bomb went off...
+		CSGameRules()->m_bTargetBombed = true;
+		m_bBombTicking = false;
+		//=============================================================================
+		// HPE_BEGIN:
+		// [tj] Saving off this value so we can see if the detonation is what caused the round to end.
+		//=============================================================================
+		bool roundWasAlreadyWon = (CSGameRules()->m_iRoundWinStatus != WINNER_NONE);
+		//=============================================================================
+		// HPE_END
+		//=============================================================================		
+
+		bool bWin = CSGameRules()->CheckWinConditions();
+
+        //=============================================================================
+        // HPE_BEGIN
+        //=============================================================================		
+
+        // [dwenger] Server-side processing for winning round by planting a bomb
+        if (bWin)
+        {
+            CCSPlayer *pBombOwner = ToCSPlayer( GetOwnerEntity() );
+            if ( pBombOwner )
+            {
+                pBombOwner->AwardAchievement(CSWinBombPlant);
+
+                //[tj]more specific achievement for planting the bomb after recovering it.
+                if (m_bPlantedAfterPickup)
+                {
+                    pBombOwner->AwardAchievement(CSWinBombPlantAfterRecovery);
+                }
+				// [menglish] awarding mvp to bomb planter
+				if (!roundWasAlreadyWon)
+				{
+					pBombOwner->IncrementNumMVPs( CSMVP_BOMBPLANT );
+				}
+            }
+        }
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+		// Do the Damage
+		float flBombRadius = 500;
+		if ( g_pMapInfo )
+			flBombRadius = g_pMapInfo->m_flBombRadius;
+
+		// Output to the bomb target ent
+		CBaseEntity *pTarget = NULL;
+		variant_t emptyVariant;
+		while ((pTarget = gEntList.FindEntityByClassname( pTarget, "func_bomb_target" )) != NULL)
+		{
+			//Adrian - But only to the one we want!
+			if ( pTarget->entindex() != m_iBombSiteIndex )
+				 continue;
+			
+			pTarget->AcceptInput( "BombExplode", this, this, emptyVariant, 0 );
+				break;
+		}	
+
+		// Pull out of the wall a bit
+		if ( pTrace->fraction != 1.0 )
+		{
+			SetAbsOrigin( pTrace->endpos + (pTrace->plane.normal * 0.6) );
+		}
+
+		{
+			Vector pos = GetAbsOrigin() + Vector( 0,0,8 );
+
+			// add an explosion TE so it affects clientside physics
+			CPASFilter filter( pos );
+			te->Explosion( filter, 0.0,
+				&pos, 
+				g_sModelIndexFireball,
+				50.0, 
+				25,
+				TE_EXPLFLAG_NONE,
+				flBombRadius * 3.5,
+				200 );
+		}
+
+		// Sound! for everyone
+		CBroadcastRecipientFilter filter;
+		EmitSound( filter, entindex(), "c4.explode" );
+
+
+		// Decal!
+		UTIL_DecalTrace( pTrace, "Scorch" );
+
+		
+		// Shake!
+		UTIL_ScreenShake( pTrace->endpos, 25.0, 150.0, 1.0, 3000, SHAKE_START );
+
+
+		SetOwnerEntity( NULL ); // can't traceline attack owner if this is set
+
+		CSGameRules()->RadiusDamage( 
+			CTakeDamageInfo( this, GetOwnerEntity(), flBombRadius, bitsDamageType ),
+			GetAbsOrigin(),
+			flBombRadius * 3.5,	//Matt - don't ask me, this is how CS does it.
+			CLASS_NONE,
+			true );	// IGNORE THE WORLD!!
+
+		// send director message, that something important happed here
+		/*
+		MESSAGE_BEGIN( MSG_SPEC, SVC_DIRECTOR );
+			WRITE_BYTE ( 9 );	// command length in bytes
+			WRITE_BYTE ( DRC_CMD_EVENT );	// bomb explode
+			WRITE_SHORT( ENTINDEX(this->edict()) );	// index number of primary entity
+			WRITE_SHORT( 0 );	// index number of secondary entity
+			WRITE_LONG( 15 | DRC_FLAG_FINAL );   // eventflags (priority and flags)
+		MESSAGE_END();
+		*/
+	}
+
+	
+	// For CTs to defuse the c4
+	void CPlantedC4::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+	{
+		//Can't defuse if its already defused or if it has blown up
+		if( !m_bBombTicking )
+		{
+			SetUse( NULL );
+			return;
+		}
+
+		CCSPlayer *player = dynamic_cast< CCSPlayer* >( pActivator );
+
+		if ( !player || player->GetTeamNumber() != TEAM_CT )
+		 	return;
+
+		if ( m_bStartDefuse )
+		{
+			if ( player != m_pBombDefuser )
+			{
+				if ( player->m_iNextTimeCheck < gpGlobals->curtime )
+				{
+					ClientPrint( player, HUD_PRINTCENTER, "#Bomb_Already_Being_Defused" );
+					player->m_iNextTimeCheck = gpGlobals->curtime + 1;
+				}
+				return;
+			}
+
+			m_flNextDefuse = gpGlobals->curtime + 0.5;
+		}
+		else
+		{
+			// freeze the player in place while defusing
+
+			IGameEvent * event = gameeventmanager->CreateEvent("bomb_begindefuse" );
+			if( event )
+			{
+				event->SetInt( "userid", player->GetUserID() );
+				if ( player->HasDefuser() )
+				{
+					event->SetInt( "haskit", 1 );
+					// TODO show messages on clients on event 
+					ClientPrint( player, HUD_PRINTCENTER, "#Defusing_Bomb_With_Defuse_Kit" );
+				}
+				else
+				{
+					event->SetInt( "haskit", 0 );
+					// TODO show messages on clients on event 
+					ClientPrint( player, HUD_PRINTCENTER, "#Defusing_Bomb_Without_Defuse_Kit" );
+				}
+				event->SetInt( "priority", 8 );
+                gameeventmanager->FireEvent( event );
+			}
+
+			Vector soundPosition = player->GetAbsOrigin() + Vector( 0, 0, 5 );
+			CPASAttenuationFilter filter( soundPosition );
+
+			EmitSound( filter, entindex(), "c4.disarmstart" );
+
+			m_flDefuseLength = player->HasDefuser() ? 5 : 10;
+
+
+			m_flNextDefuse = gpGlobals->curtime + 0.5;
+			m_pBombDefuser = player;
+			m_bStartDefuse = TRUE;
+			player->m_bIsDefusing = true;
+			
+			m_flDefuseCountDown = gpGlobals->curtime + m_flDefuseLength;
+
+			//start the progress bar
+			player->SetProgressBarTime( m_flDefuseLength );
+
+
+            player->OnStartedDefuse();
+		}
+	}
+
+
+#endif
+
+
+
+// -------------------------------------------------------------------------------- //
+// Tables.
+// -------------------------------------------------------------------------------- //
+
+IMPLEMENT_NETWORKCLASS_ALIASED( C4, DT_WeaponC4 )
+
+BEGIN_NETWORK_TABLE( CC4, DT_WeaponC4 )
+	#ifdef CLIENT_DLL
+		RecvPropBool( RECVINFO( m_bStartedArming ) ),
+		RecvPropBool( RECVINFO( m_bBombPlacedAnimation ) ),
+		RecvPropFloat( RECVINFO( m_fArmedTime ) )
+	#else
+		SendPropBool( SENDINFO( m_bStartedArming ) ),
+		SendPropBool( SENDINFO( m_bBombPlacedAnimation ) ),
+		SendPropFloat( SENDINFO( m_fArmedTime ), 0, SPROP_NOSCALE )
+	#endif
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CC4 )
+	DEFINE_PRED_FIELD( m_bStartedArming, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bBombPlacedAnimation, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_fArmedTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE )
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_c4, CC4 );
+PRECACHE_WEAPON_REGISTER( weapon_c4 );
+
+
+
+// -------------------------------------------------------------------------------- //
+// Globals.
+// -------------------------------------------------------------------------------- //
+
+CUtlVector< CC4* > g_C4s;
+
+
+
+// -------------------------------------------------------------------------------- //
+// CC4 implementation.
+// -------------------------------------------------------------------------------- //
+
+CC4::CC4()
+{
+	g_C4s.AddToTail( this );
+    m_bDroppedFromDeath = false;
+
+#if defined( CLIENT_DLL )
+	m_szScreenText[0] = '\0';
+#endif
+
+}
+
+
+CC4::~CC4()
+{
+	g_C4s.FindAndRemove( this );
+}
+
+void CC4::Spawn()
+{
+	BaseClass::Spawn();
+
+	//Don't allow players to shoot the C4 around
+	SetCollisionGroup( COLLISION_GROUP_DEBRIS );
+
+	//Don't be damaged / moved by explosions
+	m_takedamage = DAMAGE_NO;
+
+	m_bBombPlanted = false;
+}
+
+void CC4::ItemPostFrame()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// Disable all the firing code.. the C4 grenade is all custom.
+	if ( pPlayer->m_nButtons & IN_ATTACK )
+	{
+		PrimaryAttack();
+	}
+	else
+	{
+		WeaponIdle();
+	}
+}
+
+#if defined( CLIENT_DLL )
+
+	bool CC4::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
+	{
+		if( event == 7001 )
+		{
+			//set the screen text to the string in 'options'
+			Q_strncpy( m_szScreenText, options, 16 );
+
+			return true;
+		}
+		return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
+	}
+
+	char *CC4::GetScreenText( void )
+	{
+		if( m_bStartedArming )
+			return m_szScreenText;
+		else
+			return "";
+	}
+
+#endif //CLIENT_DLL
+
+#ifdef GAME_DLL
+	
+		
+	unsigned int CC4::PhysicsSolidMaskForEntity( void ) const
+	{
+		return BaseClass::PhysicsSolidMaskForEntity() | CONTENTS_PLAYERCLIP;
+	}
+
+	void CC4::Precache()
+	{
+		PrecacheVGuiScreen( "c4_view_panel" );
+		
+		PrecacheScriptSound( "c4.disarmfinish" );
+		PrecacheScriptSound( "c4.explode" );
+		PrecacheScriptSound( "c4.disarmstart" );
+		PrecacheScriptSound( "c4.plant" );
+		PrecacheScriptSound( "C4.PlantSound" );
+
+		BaseClass::Precache();
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Gets info about the control panels
+	//-----------------------------------------------------------------------------
+	void CC4::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName )
+	{
+		pPanelName = "c4_view_panel";
+	}
+
+	bool CC4::Holster( CBaseCombatWeapon *pSwitchingTo )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( pPlayer )
+			pPlayer->SetProgressBarTime( 0 );
+
+		if ( m_bStartedArming )
+		{
+			AbortBombPlant();
+		}
+		
+		return BaseClass::Holster( pSwitchingTo );
+	}
+
+
+	bool CC4::ShouldRemoveOnRoundRestart()
+	{
+		// Doesn't matter if we have an owner or not.. always remove the C4 when the round restarts.
+		// The gamerules will give another C4 to some lucky player.
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( pPlayer && pPlayer->GetActiveWeapon() == this )
+			engine->ClientCommand( pPlayer->edict(), "lastinv reset\n" );
+		return true;
+	}
+
+#endif
+
+
+void CC4::PrimaryAttack()
+{
+	bool	bArmingTimeSatisfied = false;
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	int onGround = FBitSet( pPlayer->GetFlags(), FL_ONGROUND );
+	CBaseEntity *groundEntity = (onGround) ? pPlayer->GetGroundEntity() : NULL;
+	if ( groundEntity )
+	{
+		// Don't let us stand on players, breakables, or pushaway physics objects to plant
+		if ( groundEntity->IsPlayer() ||
+			IsPushableEntity( groundEntity ) ||
+#ifndef CLIENT_DLL
+			IsBreakableEntity( groundEntity ) ||
+#endif // !CLIENT_DLL
+			IsPushAwayEntity( groundEntity ) )
+		{
+			onGround = false;
+		}
+	}
+
+	if( m_bStartedArming == false && m_bBombPlanted == false )
+	{
+		if( pPlayer->m_bInBombZone && onGround )
+		{
+			m_bStartedArming = true;
+			m_fArmedTime = gpGlobals->curtime + WEAPON_C4_ARM_TIME;
+			m_bBombPlacedAnimation = false;
+
+
+#if !defined( CLIENT_DLL )			
+			// init the beep flags
+			int i;
+			for( i=0;i<NUM_BEEPS;i++ )
+				m_bPlayedArmingBeeps[i] = false;
+
+			// freeze the player in place while planting
+
+			// player "arming bomb" animation
+			pPlayer->SetAnimation( PLAYER_ATTACK1 );
+	
+			pPlayer->SetNextAttack( gpGlobals->curtime );
+
+			IGameEvent * event = gameeventmanager->CreateEvent( "bomb_beginplant" );
+			if( event )
+			{
+				event->SetInt("userid", pPlayer->GetUserID() );
+				event->SetInt("site", pPlayer->m_iBombSiteIndex );
+				event->SetInt( "priority", 8 );
+				gameeventmanager->FireEvent( event );
+			}
+#endif
+
+			SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+			FX_PlantBomb( pPlayer->entindex(), pPlayer->Weapon_ShootPosition(), PLANTBOMB_PLANT );
+		}
+		else
+		{
+			if ( !pPlayer->m_bInBombZone )
+			{
+				ClientPrint( pPlayer, HUD_PRINTCENTER, "#C4_Plant_At_Bomb_Spot");
+			}
+			else
+			{
+				ClientPrint( pPlayer, HUD_PRINTCENTER, "#C4_Plant_Must_Be_On_Ground");
+			}
+
+			m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+			return;
+		}
+	}
+	else
+	{
+		if ( !onGround || !pPlayer->m_bInBombZone )
+		{
+			if( !pPlayer->m_bInBombZone )
+			{
+				ClientPrint( pPlayer, HUD_PRINTCENTER, "#C4_Arming_Cancelled" );
+			}
+			else
+			{
+				ClientPrint( pPlayer, HUD_PRINTCENTER, "#C4_Plant_Must_Be_On_Ground" );
+			}
+
+			AbortBombPlant();
+
+			if(m_bBombPlacedAnimation == true) //this means the placement animation is canceled
+			{
+				SendWeaponAnim( ACT_VM_DRAW );
+			}
+			else
+			{
+				SendWeaponAnim( ACT_VM_IDLE );
+			}
+			
+			return;
+		}
+		else
+		{
+#ifndef CLIENT_DLL
+			PlayArmingBeeps();
+#endif
+
+			if( gpGlobals->curtime >= m_fArmedTime ) //the c4 is ready to be armed
+			{
+				//check to make sure the player is still in the bomb target area
+				bArmingTimeSatisfied = true;
+			}
+			else if( ( gpGlobals->curtime >= (m_fArmedTime - 0.75) ) && ( !m_bBombPlacedAnimation ) )
+			{
+				//call the c4 Placement animation 
+				m_bBombPlacedAnimation = true;
+
+				SendWeaponAnim( ACT_VM_SECONDARYATTACK );
+				
+#if !defined( CLIENT_DLL )
+				// player "place" animation
+				//pPlayer->SetAnimation( PLAYER_HOLDBOMB );
+#endif
+			}
+		}
+	}
+
+	if ( bArmingTimeSatisfied && m_bStartedArming )
+	{
+		m_bStartedArming = false;
+		m_fArmedTime = 0;
+		
+		if( pPlayer->m_bInBombZone )
+		{
+#if !defined( CLIENT_DLL )
+			CPlantedC4 *pC4 = CPlantedC4::ShootSatchelCharge( pPlayer, pPlayer->GetAbsOrigin(), pPlayer->GetAbsAngles() );
+
+			if ( pC4 )
+			{
+				pC4->SetBombSiteIndex( pPlayer->m_iBombSiteIndex );
+
+				trace_t tr;
+				UTIL_TraceEntity( pC4, GetAbsOrigin(), GetAbsOrigin() + Vector(0,0,-200), MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
+				pC4->SetAbsOrigin( tr.endpos );
+
+				CBombTarget *pBombTarget = (CBombTarget*)UTIL_EntityByIndex( pPlayer->m_iBombSiteIndex );
+				
+				if ( pBombTarget )
+				{
+					CBaseEntity *pAttachPoint = gEntList.FindEntityByName( NULL, pBombTarget->GetBombMountTarget() );
+
+					if ( pAttachPoint )
+					{
+						pC4->SetAbsOrigin( pAttachPoint->GetAbsOrigin() );
+						pC4->SetAbsAngles( pAttachPoint->GetAbsAngles() );
+						pC4->SetParent( pAttachPoint );
+					}
+
+					variant_t emptyVariant;
+					pBombTarget->AcceptInput( "BombPlanted", pC4, pC4, emptyVariant, 0 );
+				}
+
+				// [tj] If the bomb is planted by someone that picked it up after the 
+				//      original owner was killed, pass that along to the planted bomb
+				pC4->SetPlantedAfterPickup( m_bDroppedFromDeath );
+			}
+
+            //=============================================================================
+            // HPE_BEGIN
+            // [dwenger] Stats update for bomb planting
+            //=============================================================================
+
+            // Determine how elapsed time from start of round until the bomb was planted
+            float   plantingTime = gpGlobals->curtime - CSGameRules()->GetRoundStartTime();
+
+            // Award achievement to bomb planter if time <= 25 seconds
+            if ((plantingTime > 0.0f) && (plantingTime <= AchievementConsts::FastBombPlant_Time))
+            {
+                pPlayer->AwardAchievement(CSPlantBombWithin25Seconds);
+            }
+
+            CCS_GameStats.Event_BombPlanted( pPlayer );
+
+            //=============================================================================
+            // HPE_END
+            //=============================================================================
+
+			IGameEvent * event = gameeventmanager->CreateEvent( "bomb_planted" );
+			if( event )
+			{
+				event->SetInt("userid", pPlayer->GetUserID() );
+				event->SetInt("site", pPlayer->m_iBombSiteIndex );
+				event->SetInt("posx", pPlayer->GetAbsOrigin().x );
+				event->SetInt("posy", pPlayer->GetAbsOrigin().y );
+				event->SetInt( "priority", 8 );
+				gameeventmanager->FireEvent( event );
+			}
+
+			// Fire a beep event also so the bots have a chance to hear the bomb
+			event = gameeventmanager->CreateEvent( "bomb_beep" );
+
+			if ( event )
+			{
+				event->SetInt( "entindex", entindex() );
+				gameeventmanager->FireEvent( event );
+			}
+
+			pPlayer->SetProgressBarTime( 0 );
+
+			CSGameRules()->m_bBombDropped = false;
+			CSGameRules()->m_bBombPlanted = true;
+
+			// Play the plant sound.
+			Vector plantPosition = pPlayer->GetAbsOrigin() + Vector( 0, 0, 5 );
+			CPASAttenuationFilter filter( plantPosition );
+			EmitSound( filter, entindex(), "c4.plant" );
+
+			// No more c4!
+			pPlayer->Weapon_Drop( this, NULL, NULL );
+			UTIL_Remove( this );
+#endif
+
+			//don't allow the planting to start over again next frame.
+			m_bBombPlanted = true;
+
+			return;
+		}
+		else
+		{
+			ClientPrint( pPlayer, HUD_PRINTCENTER, "#C4_Activated_At_Bomb_Spot" );
+
+#if !defined( CLIENT_DLL )
+			//pPlayer->SetAnimation( PLAYER_HOLDBOMB );
+
+			IGameEvent * event = gameeventmanager->CreateEvent( "bomb_abortplant" );
+			if( event )
+			{
+				event->SetInt("userid", pPlayer->GetUserID() );
+				event->SetInt("site", pPlayer->m_iBombSiteIndex );
+				event->SetInt( "priority", 8 );
+				gameeventmanager->FireEvent( event );
+			}
+#endif
+
+			m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+			return;
+		}
+	}
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + 0.3;
+	SetWeaponIdleTime( gpGlobals->curtime + SharedRandomFloat("C4IdleTime", 10, 15 ) );
+}
+
+void CC4::WeaponIdle()
+{
+	// if the player releases the attack button cancel the arming sequence
+	if ( m_bStartedArming )
+	{
+		AbortBombPlant();
+
+		CCSPlayer *pPlayer = GetPlayerOwner();
+
+		// TODO: make this use SendWeaponAnim and activities when the C4 has the activities hooked up.
+		if ( pPlayer )
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+			pPlayer->SetNextAttack( gpGlobals->curtime );
+		}
+
+		if(m_bBombPlacedAnimation == true) //this means the placement animation is canceled
+			SendWeaponAnim( ACT_VM_DRAW );
+		else
+			SendWeaponAnim( ACT_VM_IDLE );
+	}
+}
+
+void CC4::UpdateShieldState( void )
+{
+	//ADRIANTODO
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+	
+	if ( pPlayer->HasShield() )
+	{
+		pPlayer->SetShieldDrawnState( false );
+
+		CBaseViewModel *pVM = pPlayer->GetViewModel( 1 );
+
+		if ( pVM )
+		{
+			pVM->AddEffects( EF_NODRAW );
+		}
+			//pPlayer->SetHitBoxSet( 3 );
+	}
+	else
+		BaseClass::UpdateShieldState();
+}
+
+
+int m_iBeepFrames[NUM_BEEPS] = { 27, 37, 45, 51, 57, 63, 67 };
+int iNumArmingAnimFrames = 83;
+
+void CC4::PlayArmingBeeps( void )
+{
+	float flStartTime = m_fArmedTime - WEAPON_C4_ARM_TIME;
+
+	float flProgress = ( gpGlobals->curtime - flStartTime ) / ( WEAPON_C4_ARM_TIME - 0.75 );
+
+	int currentFrame = (int)( (float)iNumArmingAnimFrames * flProgress );
+
+	int i;
+	for( i=0;i<NUM_BEEPS;i++ )
+	{
+		if( currentFrame <= m_iBeepFrames[i] )
+		{
+			break;
+		}
+		else if( !m_bPlayedArmingBeeps[i] )
+		{
+			m_bPlayedArmingBeeps[i] = true;
+
+			CCSPlayer *owner = GetPlayerOwner();
+			Vector soundPosition = owner->GetAbsOrigin() + Vector( 0, 0, 5 );
+			CPASAttenuationFilter filter( soundPosition );
+
+			filter.RemoveRecipient( owner );
+
+			// remove anyone that is first person spec'ing the planter
+			int i;
+			CBasePlayer *pPlayer;
+			for( i=1;i<=gpGlobals->maxClients;i++ )
+			{
+				pPlayer = UTIL_PlayerByIndex( i );
+
+				if ( !pPlayer )
+					continue;
+
+				if( pPlayer->GetObserverMode() == OBS_MODE_IN_EYE && pPlayer->GetObserverTarget() == GetOwner() )
+				{
+					filter.RemoveRecipient( pPlayer );
+				}
+			}
+
+			EmitSound(filter, entindex(), "c4.click");
+			
+			break;
+		}
+	}
+}
+
+float CC4::GetMaxSpeed() const
+{
+	if ( m_bStartedArming )
+		return CS_PLAYER_SPEED_STOPPED;
+	else
+		return BaseClass::GetMaxSpeed();
+}
+
+
+void CC4::OnPickedUp( CBaseCombatCharacter *pNewOwner )
+{
+	BaseClass::OnPickedUp( pNewOwner );
+
+#if !defined( CLIENT_DLL )
+	CCSPlayer *pPlayer = dynamic_cast<CCSPlayer *>( pNewOwner );
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "bomb_pickup" );
+	if ( event )
+	{
+		event->SetInt( "userid", pPlayer->GetUserID() );
+		event->SetInt( "priority", 6 );
+		gameeventmanager->FireEvent( event );
+	}
+
+	if ( pPlayer->m_bShowHints && !(pPlayer->m_iDisplayHistoryBits & DHF_BOMB_RETRIEVED) )
+	{
+		pPlayer->m_iDisplayHistoryBits |= DHF_BOMB_RETRIEVED;
+		pPlayer->HintMessage( "#Hint_you_have_the_bomb", false );
+	}
+	else
+	{
+		ClientPrint( pPlayer, HUD_PRINTCENTER, "#Got_bomb" );
+	}
+
+    pPlayer->SetBombPickupTime(gpGlobals->curtime);
+#endif
+}
+
+// HACK - Ask Mike Booth...
+#ifndef CLIENT_DLL
+	#include "cs_bot.h"
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+void CC4::Drop( const Vector &vecVelocity )
+{
+#if !defined( CLIENT_DLL )
+	if ( !CSGameRules()->m_bBombPlanted ) // its not dropped if its planted
+	{
+		// tell the bots about the dropped bomb
+		TheCSBots()->SetLooseBomb( this );
+
+		CBasePlayer *pPlayer = dynamic_cast<CBasePlayer *>(GetOwnerEntity());
+		Assert( pPlayer );
+		if ( pPlayer )
+		{
+			IGameEvent * event = gameeventmanager->CreateEvent("bomb_dropped" );
+			if ( event )
+			{
+				event->SetInt( "userid", pPlayer->GetUserID() );
+				event->SetInt( "priority", 6 );
+				gameeventmanager->FireEvent( event );
+			}
+		}
+	}
+#endif
+
+	if ( m_bStartedArming )
+		AbortBombPlant();  // stop arming sequence
+
+	BaseClass::Drop( vecVelocity );
+}
+
+void CC4::AbortBombPlant()
+{
+	m_bStartedArming = false; 
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+#if !defined( CLIENT_DLL )
+	m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+
+	pPlayer->SetProgressBarTime( 0 );
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "bomb_abortplant" );
+	if( event )
+	{
+		event->SetInt("userid", pPlayer->GetUserID() );
+		event->SetInt("site", pPlayer->m_iBombSiteIndex );
+		event->SetInt( "priority", 8 );
+		gameeventmanager->FireEvent( event );
+	}
+
+#endif 
+
+	FX_PlantBomb( pPlayer->entindex(), pPlayer->Weapon_ShootPosition(), PLANTBOMB_ABORT );
+}
\ No newline at end of file
diff --git a/game/shared/cstrike/weapon_c4.h b/game/shared/cstrike/weapon_c4.h
new file mode 100644
index 00000000..7aa50a7f
--- /dev/null
+++ b/game/shared/cstrike/weapon_c4.h
@@ -0,0 +1,221 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_C4_H
+#define WEAPON_C4_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_csbase.h"
+#include "utlvector.h"
+
+#define NUM_BEEPS 7
+
+#if defined( CLIENT_DLL )
+
+	#define CC4 C_C4
+
+#else
+
+	// ------------------------------------------------------------------------------------------ //
+	// CPlantedC4 class.
+	// ------------------------------------------------------------------------------------------ //
+
+	class CPlantedC4 : public CBaseAnimating
+	{
+	public:
+		DECLARE_CLASS( CPlantedC4, CBaseAnimating );
+		DECLARE_DATADESC();
+		DECLARE_SERVERCLASS();
+
+		DECLARE_PREDICTABLE();
+
+		CPlantedC4();
+		virtual ~CPlantedC4();
+
+		virtual int  UpdateTransmitState();
+		virtual void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways );
+		virtual int  ShouldTransmit( const CCheckTransmitInfo *pInfo );
+		
+		static CPlantedC4* ShootSatchelCharge( CCSPlayer *pevOwner, Vector vecStart, QAngle vecAngles );
+		virtual void Precache();
+		
+		// Set these flags so CTs can use the C4 to disarm it.
+		virtual int	ObjectCaps() { return BaseClass::ObjectCaps() | (FCAP_CONTINUOUS_USE | FCAP_USE_IN_RADIUS); }
+
+		void SetBombSiteIndex( int iIndex ){ m_iBombSiteIndex = iIndex;	}
+
+		inline bool IsBombActive( void ) { return m_bBombTicking; }
+
+        //=============================================================================
+        // HPE_BEGIN:
+        // [tj] Accessors related to planting of the bomb
+        //=============================================================================
+ 
+        CCSPlayer*  GetPlanter() { return m_pPlanter; }
+        void        SetPlanter(CCSPlayer* player) { m_pPlanter = player; }
+        
+        void SetPlantedAfterPickup (bool plantedAfterPickup) { m_bPlantedAfterPickup = plantedAfterPickup; }
+ 
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+		
+	public:
+
+		CNetworkVar( bool, m_bBombTicking );
+		CNetworkVar( float, m_flC4Blow );
+
+	private:
+
+		void Init( CCSPlayer *pevOwner, Vector vecStart, QAngle vecAngles );
+		void C4Think();
+		
+		// This becomes the think function when the timer has expired and it is about to explode.
+		void DetonateThink();
+		void Explode( trace_t *pTrace, int bitsDamageType );
+
+		void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+		// Replicate timer length to the client for effects
+		CNetworkVar( float, m_flTimerLength );
+
+		// Info for defusing.
+		CHandle<CCSPlayer> m_pBombDefuser;
+		float			m_flNextDefuse;
+		bool			m_bStartDefuse;
+		int				m_iBombSiteIndex;
+
+		CNetworkVar( float, m_flDefuseLength );		//How long does the defuse take? Depends on if a defuser was used
+		CNetworkVar( float, m_flDefuseCountDown );	//What time does the defuse complete?
+
+		// Control panel
+		void GetControlPanelInfo( int nPanelIndex, const char *&pPanelName );
+		void GetControlPanelClassName( int nPanelIndex, const char *&pPanelName );
+		void SpawnControlPanels();
+
+		typedef CHandle<CVGuiScreen>	ScreenHandle_t;
+		CUtlVector<ScreenHandle_t>	m_hScreens;
+
+		int m_iProgressBarTime;
+
+        //=============================================================================
+        // HPE_BEGIN:        
+        //=============================================================================
+         
+        // [tj] We need to store who planted the bomb so we can track who deserves credits for the kills
+        CHandle<CCSPlayer>  m_pPlanter;
+
+        // [tj] We need to know if this was planted by a player who recovered the bomb
+        bool m_bPlantedAfterPickup;
+         
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+        
+	};
+
+	extern CUtlVector< CPlantedC4* > g_PlantedC4s;
+
+#endif
+
+#define WEAPON_C4_CLASSNAME "weapon_c4"
+#define PLANTED_C4_CLASSNAME "planted_c4"
+
+class CC4 : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CC4, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CC4();
+	virtual ~CC4();
+	
+	virtual void Spawn();
+
+	bool IsPistol() const;
+	void ItemPostFrame();
+	virtual void PrimaryAttack();
+	virtual void WeaponIdle();
+	virtual void UpdateShieldState( void );
+	virtual float GetMaxSpeed() const;
+
+// 	virtual float GetSpread() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_C4; }
+
+	#ifdef CLIENT_DLL
+
+		virtual bool OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+		char *GetScreenText( void );
+		char m_szScreenText[32];
+		
+	#else
+		
+		virtual void Precache();
+		virtual void GetControlPanelInfo( int nPanelIndex, const char *&pPanelName );
+		virtual unsigned int PhysicsSolidMaskForEntity( void ) const;
+
+		virtual bool Holster( CBaseCombatWeapon *pSwitchingTo );
+		virtual bool ShouldRemoveOnRoundRestart();
+
+        //=============================================================================
+        // HPE_BEGIN:
+        // [tj] Simple Setter
+        //=============================================================================
+         
+        void SetDroppedFromDeath(bool droppedFromDeath) { m_bDroppedFromDeath = droppedFromDeath; }
+         
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+        
+	
+	#endif
+
+	void AbortBombPlant();
+
+	void PlayArmingBeeps( void );
+	virtual void	OnPickedUp( CBaseCombatCharacter *pNewOwner );
+	virtual void	Drop( const Vector &vecVelocity );
+
+	CNetworkVar( bool, m_bStartedArming );
+	CNetworkVar( float, m_fArmedTime );
+	CNetworkVar( bool, m_bBombPlacedAnimation );
+
+	virtual bool IsRemoveable( void ) { return false; }
+
+private:	
+	bool m_bPlayedArmingBeeps[NUM_BEEPS];
+	bool m_bBombPlanted;
+    
+    //=============================================================================
+    // HPE_BEGIN:
+    // [tj] we want to store if this bomb was dropped because the original owner was killed
+    //=============================================================================
+     
+    bool m_bDroppedFromDeath;
+     
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+    
+
+private:
+	
+	CC4( const CC4 & );
+};
+
+
+// All the currently-active C4 grenades.
+extern CUtlVector< CC4* > g_C4s;
+
+
+#endif // WEAPON_C4_H
diff --git a/game/shared/cstrike/weapon_csbase.cpp b/game/shared/cstrike/weapon_csbase.cpp
new file mode 100644
index 00000000..8063b919
--- /dev/null
+++ b/game/shared/cstrike/weapon_csbase.cpp
@@ -0,0 +1,1917 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Laser Rifle & Shield combo
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "in_buttons.h"
+#include "takedamageinfo.h"
+#include "weapon_csbase.h"
+#include "ammodef.h"
+#include "cs_gamerules.h"
+
+#define ALLOW_WEAPON_SPREAD_DISPLAY	0
+
+#if defined( CLIENT_DLL )
+
+	#include "vgui/ISurface.h"
+	#include "vgui_controls/Controls.h"
+	#include "c_cs_player.h"
+	#include "hud_crosshair.h"
+	#include "c_te_effect_dispatch.h"
+	#include "c_te_legacytempents.h"
+
+	extern IVModelInfoClient* modelinfo;
+
+#else
+
+	#include "cs_player.h"
+	#include "te_effect_dispatch.h"
+	#include "KeyValues.h"
+	#include "cs_ammodef.h"
+
+	extern IVModelInfo* modelinfo;
+
+#endif
+
+
+ConVar weapon_accuracy_model( "weapon_accuracy_model", "2", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY | FCVAR_ARCHIVE );
+
+
+// ----------------------------------------------------------------------------- //
+// Global functions.
+// ----------------------------------------------------------------------------- //
+
+
+
+struct WeaponAliasTranslationInfoStruct
+{
+	const char* alias;
+	const char* translatedAlias;
+};
+
+static const WeaponAliasTranslationInfoStruct s_WeaponAliasTranslationInfo[] =
+{
+	{ "cv47", "ak47" },
+	{ "defender", "galil" },
+	{ "krieg552", "sg552" },
+	{ "magnum", "awp" },
+	{ "d3au1", "g3sg1" },
+	{ "clarion", "famas" },
+	{ "bullpup", "aug" },
+	{ "krieg550", "sg550" },
+	{ "9x19mm", "glock" },
+	{ "km45", "usp" },
+	{ "228compact", "p228" },
+	{ "nighthawk", "deagle" },
+	{ "elites", "elite" },
+	{ "fn57", "fiveseven" },
+	{ "12gauge", "m3" },
+	{ "autoshotgun", "xm1014" },
+	{ "mp", "tmp" },
+	{ "smg", "mp5navy" },
+	{ "mp5", "mp5navy" },
+	{ "c90", "p90" },
+	{ "vest", "kevlar" },
+	{ "vesthelm", "assaultsuit" },
+	{ "smokegrenade", "sgren" },
+	{ "smokegrenade", "sgren" },
+	{ "nvgs", "nightvision" },
+
+	{ "", "" } // this needs to be last
+};
+
+
+struct WeaponAliasInfo
+{
+	CSWeaponID id;
+	const char* alias;
+};
+
+WeaponAliasInfo s_weaponAliasInfo[] =
+{
+	{ WEAPON_P228,				"p228" },
+	{ WEAPON_GLOCK,				"glock" },
+	{ WEAPON_SCOUT,				"scout" },
+	{ WEAPON_XM1014,			"xm1014" },
+	{ WEAPON_MAC10,				"mac10" },
+	{ WEAPON_AUG,				"aug" },
+	{ WEAPON_ELITE,				"elite" },
+	{ WEAPON_FIVESEVEN,			"fiveseven" },
+	{ WEAPON_UMP45,				"ump45" },
+	{ WEAPON_SG550,				"sg550" },
+	{ WEAPON_GALIL,				"galil" },
+	{ WEAPON_FAMAS,				"famas" },
+	{ WEAPON_USP,				"usp" },
+	{ WEAPON_AWP,				"awp" },
+	{ WEAPON_MP5NAVY,			"mp5navy" },
+	{ WEAPON_M249,				"m249" },
+	{ WEAPON_M3,				"m3" },
+	{ WEAPON_M4A1,				"m4a1" },
+	{ WEAPON_TMP,				"tmp" },
+	{ WEAPON_G3SG1,				"g3sg1" },
+	{ WEAPON_DEAGLE,			"deagle" },
+	{ WEAPON_SG552,				"sg552" },
+	{ WEAPON_AK47,				"ak47" },
+	{ WEAPON_P90,				"p90" },
+
+	{ WEAPON_KNIFE,				"knife" },
+	{ WEAPON_C4,				"c4" },
+	{ WEAPON_FLASHBANG,			"flashbang" },
+	{ WEAPON_SMOKEGRENADE,		"smokegrenade" },
+	{ WEAPON_SMOKEGRENADE,		"sgren" },
+	{ WEAPON_HEGRENADE,			"hegrenade" },
+	{ WEAPON_HEGRENADE,			"hegren" },
+
+	// not sure any of these are needed
+	{ WEAPON_SHIELDGUN,			"shield" },
+	{ WEAPON_SHIELDGUN,			"shieldgun" },
+	{ WEAPON_KEVLAR,			"kevlar" },
+	{ WEAPON_ASSAULTSUIT,		"assaultsuit" },
+	{ WEAPON_NVG,				"nightvision" },
+	{ WEAPON_NVG,				"nvg" },
+
+	{ WEAPON_NONE,				"none" },
+};
+
+
+bool IsAmmoType( int iAmmoType, const char *pAmmoName )
+{
+	return GetAmmoDef()->Index( pAmmoName ) == iAmmoType;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given an alias, return the translated alias.
+//
+const char * GetTranslatedWeaponAlias( const char *szAlias )
+{
+	for ( int i = 0; i < ARRAYSIZE(s_WeaponAliasTranslationInfo); ++i )
+	{
+		if ( Q_stricmp(s_WeaponAliasTranslationInfo[i].alias, szAlias) == 0 )
+		{
+			return s_WeaponAliasTranslationInfo[i].translatedAlias;
+		}
+	}
+
+	return szAlias;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given a translated alias, return the alias.
+//
+const char * GetWeaponAliasFromTranslated(const char *translatedAlias)
+{
+	int i = 0;
+	const WeaponAliasTranslationInfoStruct *info = &(s_WeaponAliasTranslationInfo[i]);
+
+	while (info->alias[0] != 0)
+	{
+		if (Q_stricmp(translatedAlias, info->translatedAlias) == 0)
+		{
+			return info->alias;
+		}
+		info = &(s_WeaponAliasTranslationInfo[++i]);
+	}
+
+	return translatedAlias;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given an alias, return the associated weapon ID
+//
+CSWeaponID AliasToWeaponID( const char *szAlias )
+{
+	if ( szAlias )
+	{
+		for ( int i=0; i < ARRAYSIZE(s_weaponAliasInfo); ++i)
+		{
+			if ( Q_stricmp( s_weaponAliasInfo[i].alias, szAlias) == 0 )
+				return s_weaponAliasInfo[i].id;
+		}
+	}
+
+	return WEAPON_NONE;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Given a weapon ID, return its alias
+//
+const char *WeaponIDToAlias( int id )
+{
+	for ( int i=0; i < ARRAYSIZE(s_weaponAliasInfo); ++i)
+	{
+		if ( s_weaponAliasInfo[i].id == id )
+			return s_weaponAliasInfo[i].alias;
+	}
+
+	return NULL;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Return true if given weapon ID is a primary weapon
+//
+bool IsPrimaryWeapon( CSWeaponID id )
+{
+	const CCSWeaponInfo* pWeaponInfo = GetWeaponInfo( id );
+	if ( pWeaponInfo )
+	{
+		return pWeaponInfo->iSlot == WEAPON_SLOT_RIFLE;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------
+//
+// Return true if given weapon ID is a secondary weapon
+//
+bool IsSecondaryWeapon( CSWeaponID id )
+{
+	const CCSWeaponInfo* pWeaponInfo = GetWeaponInfo( id );
+	if ( pWeaponInfo )
+		return pWeaponInfo->iSlot == WEAPON_SLOT_PISTOL;
+
+	return false;
+}
+
+#ifdef CLIENT_DLL
+int GetShellForAmmoType( const char *ammoname )
+{
+	if ( !Q_strcmp( BULLET_PLAYER_762MM, ammoname ) )
+		return CS_SHELL_762NATO;
+
+	if ( !Q_strcmp( BULLET_PLAYER_556MM, ammoname ) )
+		return CS_SHELL_556;
+
+	if ( !Q_strcmp( BULLET_PLAYER_338MAG, ammoname ) )
+		return CS_SHELL_338MAG;
+
+	if ( !Q_strcmp( BULLET_PLAYER_BUCKSHOT, ammoname ) )
+		return CS_SHELL_12GAUGE;
+
+	if ( !Q_strcmp( BULLET_PLAYER_57MM, ammoname ) )
+		return CS_SHELL_57;
+
+	// default 9 mm
+	return CS_SHELL_9MM;
+}
+#endif
+
+
+// ----------------------------------------------------------------------------- //
+// CWeaponCSBase tables.
+// ----------------------------------------------------------------------------- //
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCSBase, DT_WeaponCSBase )
+
+BEGIN_NETWORK_TABLE( CWeaponCSBase, DT_WeaponCSBase )
+#if !defined( CLIENT_DLL )
+SendPropInt( SENDINFO( m_weaponMode ), 1, SPROP_UNSIGNED ),
+SendPropFloat(SENDINFO(m_fAccuracyPenalty) ),
+// world weapon models have no aminations
+SendPropExclude( "DT_AnimTimeMustBeFirst", "m_flAnimTime" ),
+SendPropExclude( "DT_BaseAnimating", "m_nSequence" ),
+//	SendPropExclude( "DT_LocalActiveWeaponData", "m_flTimeWeaponIdle" ),
+#else
+RecvPropInt( RECVINFO( m_weaponMode ) ),
+RecvPropFloat( RECVINFO(m_fAccuracyPenalty)),
+#endif
+END_NETWORK_TABLE()
+
+#if defined(CLIENT_DLL)
+BEGIN_PREDICTION_DATA( CWeaponCSBase )
+	DEFINE_PRED_FIELD( m_flTimeWeaponIdle, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_flNextPrimaryAttack, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_flNextSecondaryAttack, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_bDelayFire, FIELD_BOOLEAN, 0 ),
+	DEFINE_PRED_FIELD( m_flAccuracy, FIELD_FLOAT, 0 ),
+	DEFINE_PRED_FIELD( m_weaponMode, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD_TOL( m_fAccuracyPenalty, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.00005f ),
+END_PREDICTION_DATA()
+#endif
+
+
+LINK_ENTITY_TO_CLASS( weapon_cs_base, CWeaponCSBase );
+
+
+#ifdef GAME_DLL
+
+	BEGIN_DATADESC( CWeaponCSBase )
+
+		//DEFINE_FUNCTION( DefaultTouch ),
+		DEFINE_THINKFUNC( FallThink )
+
+	END_DATADESC()
+
+#endif
+
+#if defined( CLIENT_DLL )
+	ConVar cl_crosshaircolor( "cl_crosshaircolor", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Set crosshair color: 0=green, 1=red, 2=blue, 3=yellow, 4=cyan, 5=custom" );
+	ConVar cl_dynamiccrosshair( "cl_dynamiccrosshair", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Enables dynamic crosshair; 0=off, 1=normal behavior (based on actual weapon accuracy), 2=legacy simulated dynamic behavior, 3=legacy simulated static behavior" );
+	ConVar cl_crosshairspreadscale( "cl_crosshairspreadscale", "0.3", FCVAR_CLIENTDLL | FCVAR_ARCHIVE);
+	ConVar cl_scalecrosshair( "cl_scalecrosshair", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Enable crosshair scaling (deprecated)" );
+	ConVar cl_crosshairscale( "cl_crosshairscale", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Crosshair scaling factor (deprecated)" );
+	ConVar cl_crosshairalpha( "cl_crosshairalpha", "200", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+	ConVar cl_crosshairusealpha( "cl_crosshairusealpha", "1", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+	ConVar cl_crosshairsize( "cl_crosshairsize", "5", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+	ConVar cl_crosshairthickness( "cl_crosshairthickness", "0.5", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+	ConVar cl_crosshairdot( "cl_crosshairdot", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+	ConVar cl_crosshaircolor_r( "cl_crosshaircolor_r", "50", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+	ConVar cl_crosshaircolor_g( "cl_crosshaircolor_g", "250", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+	ConVar cl_crosshaircolor_b( "cl_crosshaircolor_b", "50", FCVAR_CLIENTDLL | FCVAR_ARCHIVE );
+
+#if ALLOW_WEAPON_SPREAD_DISPLAY
+	ConVar weapon_debug_spread_show( "weapon_debug_spread_show", "0", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY, "Enables display of weapon accuracy; 1: show accuracy box, 2: show box with recoil offset" );
+	ConVar weapon_debug_spread_gap( "weapon_debug_spread_gap", "0.67", FCVAR_CLIENTDLL | FCVAR_DEVELOPMENTONLY );
+#endif
+
+	// [paquin] make sure crosshair scales independent of frame rate
+	// unless legacy cvar is set
+	ConVar cl_legacy_crosshair_recoil( "cl_legacy_crosshair_recoil", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Enable legacy framerate dependent crosshair recoil");
+
+	// use old scaling behavior
+	ConVar cl_legacy_crosshair_scale( "cl_legacy_crosshair_scale", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Enable legacy crosshair scaling");
+
+void DrawCrosshairRect( int x0, int y0, int x1, int y1, bool bAdditive )
+{
+	if ( bAdditive )
+	{
+		vgui::surface()->DrawTexturedRect( x0, y0, x1, y1 );
+	}
+	else
+	{
+		// Alpha-blended crosshair
+		vgui::surface()->DrawFilledRect( x0, y0, x1, y1 );
+	}
+}
+
+#endif
+
+// must be included after the above macros
+#ifndef CLIENT_DLL
+	#include "cs_bot.h"
+#endif
+
+
+// ----------------------------------------------------------------------------- //
+// CWeaponCSBase implementation.
+// ----------------------------------------------------------------------------- //
+CWeaponCSBase::CWeaponCSBase()
+{
+	SetPredictionEligible( true );
+	m_bDelayFire = true;
+	m_nextPrevOwnerTouchTime = 0.0;
+	m_prevOwner = NULL;
+	AddSolidFlags( FSOLID_TRIGGER ); // Nothing collides with these but it gets touches.
+
+#ifdef CLIENT_DLL
+	m_iCrosshairTextureID = 0;
+#else
+	m_iDefaultExtraAmmo = 0;
+#endif
+
+	m_fAccuracyPenalty = 0.0f;
+
+	m_weaponMode = Primary_Mode;
+}
+
+
+#ifndef CLIENT_DLL
+bool CWeaponCSBase::KeyValue( const char *szKeyName, const char *szValue )
+{
+	if ( !BaseClass::KeyValue( szKeyName, szValue ) )
+	{
+		if ( FStrEq( szKeyName, "ammo" ) )
+		{
+			int bullets = atoi( szValue );
+			if ( bullets < 0 )
+				return false;
+
+			m_iDefaultExtraAmmo = bullets;
+
+			return true;
+		}
+	}
+
+	return false;
+}
+#endif
+
+
+bool CWeaponCSBase::IsPredicted() const
+{
+	return true;
+}
+
+
+bool CWeaponCSBase::IsPistol() const
+{
+	return GetCSWpnData().m_WeaponType == WEAPONTYPE_PISTOL;
+}
+
+
+bool CWeaponCSBase::IsFullAuto() const
+{
+	return GetCSWpnData().m_bFullAuto;
+}
+
+
+bool CWeaponCSBase::PlayEmptySound()
+{
+	//MIKETODO: certain weapons should override this to make it empty:
+	//	C4
+	//	Flashbang
+	//	HE Grenade
+	//	Smoke grenade
+
+	CPASAttenuationFilter filter( this );
+	filter.UsePredictionRules();
+
+	if ( IsPistol() )
+	{
+		EmitSound( filter, entindex(), "Default.ClipEmpty_Pistol" );
+	}
+	else
+	{
+		EmitSound( filter, entindex(), "Default.ClipEmpty_Rifle" );
+	}
+
+	return 0;
+}
+
+CCSPlayer* CWeaponCSBase::GetPlayerOwner() const
+{
+	return dynamic_cast< CCSPlayer* >( GetOwner() );
+}
+
+//=============================================================================
+// HPE_BEGIN:
+//=============================================================================
+
+//[dwenger] Accessors for the prior owner list
+void CWeaponCSBase::AddToPriorOwnerList(CCSPlayer* pPlayer)
+{
+    if ( !IsAPriorOwner( pPlayer ) )
+    {
+        // Add player to prior owner list
+        m_PriorOwners.AddToTail( pPlayer );
+    }
+}
+
+bool CWeaponCSBase::IsAPriorOwner(CCSPlayer* pPlayer)
+{
+    return (m_PriorOwners.Find( pPlayer ) != -1);
+}
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+void CWeaponCSBase::SecondaryAttack( void )
+{
+#ifndef CLIENT_DLL
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer )
+		return;
+
+	if ( pPlayer->HasShield() == false )
+		 BaseClass::SecondaryAttack();
+	else
+	{
+		pPlayer->SetShieldDrawnState( !pPlayer->IsShieldDrawn() );
+
+		if ( pPlayer->IsShieldDrawn() )
+			 SendWeaponAnim( ACT_SHIELD_UP );
+		else
+			 SendWeaponAnim( ACT_SHIELD_DOWN );
+
+		m_flNextSecondaryAttack = gpGlobals->curtime + 0.4;
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.4;
+	}
+#endif
+}
+
+bool CWeaponCSBase::SendWeaponAnim( int iActivity )
+{
+#ifdef CS_SHIELD_ENABLED
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if ( pPlayer && pPlayer->HasShield() )
+	{
+		CBaseViewModel *vm = pPlayer->GetViewModel( 1 );
+
+		if ( vm == NULL )
+			return false;
+
+		vm->SetWeaponModel( SHIELD_VIEW_MODEL, this );
+
+		int	idealSequence = vm->SelectWeightedSequence( (Activity)iActivity );
+
+		if ( idealSequence >= 0 )
+		{
+			vm->SendViewModelMatchingSequence( idealSequence );
+		}
+	}
+#endif
+
+	return BaseClass::SendWeaponAnim( iActivity );
+}
+
+
+void CWeaponCSBase::ItemPostFrame()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer )
+		return;
+
+	UpdateAccuracyPenalty();
+
+	UpdateShieldState();
+
+	if ((m_bInReload) && (pPlayer->m_flNextAttack <= gpGlobals->curtime))
+	{
+		// complete the reload.
+		int j = MIN( GetMaxClip1() - m_iClip1, pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) );
+
+		// Add them to the clip
+		m_iClip1 += j;
+		pPlayer->RemoveAmmo( j, m_iPrimaryAmmoType );
+
+		m_bInReload = false;
+	}
+
+	if ((pPlayer->m_nButtons & IN_ATTACK2) && (m_flNextSecondaryAttack <= gpGlobals->curtime))
+	{
+		if ( pPlayer->HasShield() )
+			CWeaponCSBase::SecondaryAttack();
+		else
+			SecondaryAttack();
+
+		pPlayer->m_nButtons &= ~IN_ATTACK2;
+	}
+	else if ((pPlayer->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime ))
+	{
+		if ( CSGameRules()->IsFreezePeriod() )	// Can't shoot during the freeze period
+			return;
+
+		if ( pPlayer->m_bIsDefusing )
+			return;
+
+		if ( pPlayer->State_Get() != STATE_ACTIVE )
+			return;
+
+		if ( pPlayer->IsShieldDrawn() ) 
+			return;
+
+		// we have to reset the FireOnEmpty flag before we can fire on an empty clip
+		if ( m_iClip1 == 0 && !m_bFireOnEmpty )
+			return;
+
+		// don't repeat fire if this is not a full auto weapon 
+		if ( pPlayer->m_iShotsFired > 0 && !IsFullAuto() )
+			return;
+
+#if !defined(CLIENT_DLL)
+		// allow the bots to react to the gunfire
+		if ( GetCSWpnData().m_WeaponType != WEAPONTYPE_GRENADE )
+		{
+			IGameEvent * event = gameeventmanager->CreateEvent( (HasAmmo()) ? "weapon_fire" : "weapon_fire_on_empty" );
+			if( event )
+			{
+				const char *weaponName = STRING( m_iClassname );
+				if ( strncmp( weaponName, "weapon_", 7 ) == 0 )
+				{
+					weaponName += 7;
+				}
+
+				event->SetInt( "userid", pPlayer->GetUserID() );
+				event->SetString( "weapon", weaponName );
+				gameeventmanager->FireEvent( event );
+			}
+		}
+#endif
+		PrimaryAttack();
+	}
+	else if ( pPlayer->m_nButtons & IN_RELOAD && GetMaxClip1() != WEAPON_NOCLIP && !m_bInReload && m_flNextPrimaryAttack < gpGlobals->curtime)
+	{
+		// reload when reload is pressed, or if no buttons are down and weapon is empty.
+
+		//MIKETODO: add code for shields...
+		//if ( !FBitSet( m_iWeaponState, WPNSTATE_SHIELD_DRAWN ) )
+
+		if ( !pPlayer->IsShieldDrawn() )
+		{
+			 if ( Reload() )
+			 {
+#ifndef CLIENT_DLL
+				 // allow the bots to react to the reload
+				 IGameEvent * event = gameeventmanager->CreateEvent( "weapon_reload" );
+				 if( event )
+				 {
+					 event->SetInt( "userid", pPlayer->GetUserID() );
+					 gameeventmanager->FireEvent( event );
+				 }
+#endif
+			 }
+		}
+	}
+	else if ( !(pPlayer->m_nButtons & (IN_ATTACK|IN_ATTACK2) ) )
+	{
+		if ( weapon_accuracy_model.GetInt() == 2 )
+		{
+			// Fire button not down -- reset the shots fired count
+			if ( pPlayer->m_iShotsFired > 0 && ( !IsFullAuto() || m_iClip1 == 0 ) )
+			{
+				pPlayer->m_iShotsFired = 0;
+			}
+		}
+
+		// The following code prevents the player from tapping the firebutton repeatedly
+		// to simulate full auto and retaining the single shot accuracy of single fire
+		if ( m_bDelayFire )
+		{
+			m_bDelayFire = false;
+
+			if (pPlayer->m_iShotsFired > 15)
+				pPlayer->m_iShotsFired = 15;
+
+			m_flDecreaseShotsFired = gpGlobals->curtime + 0.4;
+		}
+
+		m_bFireOnEmpty = true;
+
+		// if it's a pistol then set the shots fired to 0 after the player releases a button
+		if ( IsPistol() )
+		{
+			pPlayer->m_iShotsFired = 0;
+		}
+		else
+		{
+			if ( (pPlayer->m_iShotsFired > 0) && (m_flDecreaseShotsFired < gpGlobals->curtime)	)
+			{
+				m_flDecreaseShotsFired = gpGlobals->curtime + 0.0225;
+				pPlayer->m_iShotsFired--;
+			}
+		}
+
+		if ( (!IsUseable() && m_flNextPrimaryAttack < gpGlobals->curtime) )
+		{
+			// Intentionally blank -- used to switch weapons here
+		}
+		else
+		{
+			// weapon is useable. Reload if empty and weapon has waited as long as it has to after firing
+			if ( m_iClip1 == 0 && !(GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD) && m_flNextPrimaryAttack < gpGlobals->curtime )
+			{
+				Reload();
+				return;
+			}
+		}
+
+		WeaponIdle( );
+		return;
+	}
+}
+
+
+void CWeaponCSBase::ItemBusyFrame()
+{
+	UpdateAccuracyPenalty();
+
+	BaseClass::ItemBusyFrame();
+}
+
+
+float CWeaponCSBase::GetInaccuracy() const
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return 0.0f;
+
+	const CCSWeaponInfo& weaponInfo = GetCSWpnData();
+
+	float fMaxSpeed = GetMaxSpeed();
+	if ( fMaxSpeed == 0.0f )
+		fMaxSpeed = GetCSWpnData().m_flMaxSpeed;
+
+	return m_fAccuracyPenalty + 
+		RemapValClamped(pPlayer->GetAbsVelocity().Length2D(), 
+		fMaxSpeed * CS_PLAYER_SPEED_DUCK_MODIFIER, 
+		fMaxSpeed * 0.95f,							// max out at 95% of run speed to avoid jitter near max speed
+		0.0f, weaponInfo.m_fInaccuracyMove[m_weaponMode]);
+}
+
+
+float CWeaponCSBase::GetSpread() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+		return 0.0f;
+
+	return GetCSWpnData().m_fSpread[m_weaponMode];
+}
+
+
+float CWeaponCSBase::GetMaxSpeed() const
+{
+	// The weapon should have set this in its constructor.
+	float flRet = GetCSWpnData().m_flMaxSpeed;
+	Assert( flRet > 1 );
+	return flRet;
+}
+
+const CCSWeaponInfo &CWeaponCSBase::GetCSWpnData() const
+{
+	const FileWeaponInfo_t *pWeaponInfo = &GetWpnData();
+	const CCSWeaponInfo *pCSInfo;
+
+	#ifdef _DEBUG
+		pCSInfo = dynamic_cast< const CCSWeaponInfo* >( pWeaponInfo );
+		Assert( pCSInfo );
+	#else
+		pCSInfo = static_cast< const CCSWeaponInfo* >( pWeaponInfo );
+	#endif
+
+	return *pCSInfo;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const char *CWeaponCSBase::GetViewModel( int /*viewmodelindex = 0 -- this is ignored in the base class here*/ ) const
+{
+	CCSPlayer *pOwner = GetPlayerOwner();
+
+	if ( pOwner == NULL )
+		 return BaseClass::GetViewModel();
+
+	if ( pOwner->HasShield() && GetCSWpnData().m_bCanUseWithShield )
+		 return GetCSWpnData().m_szShieldViewModel;
+	else
+		 return GetWpnData().szViewModel;
+
+	return BaseClass::GetViewModel();
+
+}
+
+void CWeaponCSBase::Precache( void )
+{
+	BaseClass::Precache();
+
+#ifdef CS_SHIELD_ENABLED
+	if ( GetCSWpnData().m_bCanUseWithShield )
+	{
+		 PrecacheModel( GetCSWpnData().m_szShieldViewModel );
+	}
+#endif
+
+	PrecacheScriptSound( "Default.ClipEmpty_Pistol" );
+	PrecacheScriptSound( "Default.ClipEmpty_Rifle" );
+
+	PrecacheScriptSound( "Default.Zoom" );
+}
+
+Activity CWeaponCSBase::GetDeployActivity( void )
+{
+	return ACT_VM_DRAW;
+}
+
+bool CWeaponCSBase::DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt )
+{
+	// Msg( "deploy %s at %f\n", GetClassname(), gpGlobals->curtime );
+	CCSPlayer *pOwner = GetPlayerOwner();
+	if ( !pOwner )
+	{
+		return false;
+	}
+
+	pOwner->SetAnimationExtension( szAnimExt );
+
+	SetViewModel();
+	SendWeaponAnim( GetDeployActivity() );
+
+	pOwner->SetNextAttack( gpGlobals->curtime + SequenceDuration() );
+	m_flNextPrimaryAttack	= gpGlobals->curtime;
+	m_flNextSecondaryAttack	= gpGlobals->curtime;
+
+	SetWeaponVisible( true );
+	pOwner->SetShieldDrawnState( false );
+
+	if ( pOwner->HasShield() == true )
+		 SetWeaponModelIndex( SHIELD_WORLD_MODEL);
+	else
+		 SetWeaponModelIndex( szWeaponModel );
+
+	return true;
+}
+
+void CWeaponCSBase::UpdateShieldState( void )
+{
+	//empty by default.
+	CCSPlayer *pOwner = GetPlayerOwner();
+
+	if ( pOwner == NULL )
+		 return;
+
+	//ADRIANTODO
+	//Make the hitbox set switches here!!!
+	if ( pOwner->HasShield() == false )
+	{
+
+		pOwner->SetShieldDrawnState( false );
+		//pOwner->SetHitBoxSet( 0 );
+		return;
+	}
+	else
+	{
+		//pOwner->SetHitBoxSet( 1 );
+	}
+}
+
+void CWeaponCSBase::SetWeaponModelIndex( const char *pName )
+{
+ 	 m_iWorldModelIndex = modelinfo->GetModelIndex( pName );
+}
+
+bool CWeaponCSBase::CanBeSelected( void )
+{
+	if ( !VisibleInWeaponSelection() )
+		return false;
+
+	return true;
+}
+
+bool CWeaponCSBase::CanDeploy( void )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if ( pPlayer->HasShield() && GetCSWpnData().m_bCanUseWithShield == false )
+		 return false;
+
+	return BaseClass::CanDeploy();
+}
+
+float CWeaponCSBase::CalculateNextAttackTime( float fCycleTime )
+{
+	float fCurAttack = m_flNextPrimaryAttack;
+	float fDeltaAttack = gpGlobals->curtime - fCurAttack;
+	if ( fDeltaAttack < 0 || fDeltaAttack > gpGlobals->interval_per_tick )
+	{
+		fCurAttack = gpGlobals->curtime;
+	}
+	m_flNextSecondaryAttack = m_flNextPrimaryAttack = fCurAttack + fCycleTime;
+
+	return fCurAttack;
+}
+
+bool CWeaponCSBase::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if ( pPlayer )
+		pPlayer->SetFOV( pPlayer, 0 ); // reset the default FOV.
+
+	if ( pPlayer )
+		pPlayer->SetShieldDrawnState( false );
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+bool CWeaponCSBase::Deploy()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+#ifdef CLIENT_DLL
+	m_iAlpha =  80;
+	if ( pPlayer )
+	{
+		pPlayer->m_iLastZoom = 0;
+		pPlayer->SetFOV( pPlayer, 0 );
+	}
+#else
+
+	m_flDecreaseShotsFired = gpGlobals->curtime;
+
+
+	if ( pPlayer )
+	{
+		pPlayer->m_iShotsFired = 0;
+		pPlayer->m_bResumeZoom = false;
+		pPlayer->m_iLastZoom = 0;
+		pPlayer->SetFOV( pPlayer, 0 );
+	}
+#endif
+
+	m_fAccuracyPenalty = 0.0f;
+
+	return BaseClass::Deploy();
+}
+
+#ifndef CLIENT_DLL
+bool CWeaponCSBase::IsRemoveable()
+{
+	if ( BaseClass::IsRemoveable() == true )
+	{
+		if ( m_nextPrevOwnerTouchTime > gpGlobals->curtime )
+		{
+			return false;
+		}
+	}
+
+	return BaseClass::IsRemoveable();
+}
+#endif
+
+void CWeaponCSBase::Drop(const Vector &vecVelocity)
+{
+
+#ifdef CLIENT_DLL
+	BaseClass::Drop(vecVelocity);
+	return;
+#else
+
+	// Once somebody drops a gun, it's fair game for removal when/if
+	// a game_weapon_manager does a cleanup on surplus weapons in the
+	// world.
+	SetRemoveable( true );
+
+	StopAnimation();
+	StopFollowingEntity( );
+	SetMoveType( MOVETYPE_FLYGRAVITY );
+	// clear follow stuff, setup for collision
+	SetGravity(1.0);
+	m_iState = WEAPON_NOT_CARRIED;
+	RemoveEffects( EF_NODRAW );
+	FallInit();
+	SetGroundEntity( NULL );
+
+	m_bInReload = false; // stop reloading
+
+	SetThink( NULL );
+	m_nextPrevOwnerTouchTime = gpGlobals->curtime + 0.8f;
+	m_prevOwner = GetPlayerOwner();
+
+	SetTouch(&CWeaponCSBase::DefaultTouch);
+
+	IPhysicsObject *pObj = VPhysicsGetObject();
+	if ( pObj != NULL )
+	{
+		AngularImpulse	angImp( 200, 200, 200 );
+		pObj->AddVelocity( &vecVelocity, &angImp );
+	}
+	else
+	{
+		SetAbsVelocity( vecVelocity );
+	}
+
+	SetNextThink( gpGlobals->curtime );
+
+	SetOwnerEntity( NULL );
+	SetOwner( NULL );
+#endif
+}
+
+// whats going on here is that if the player drops this weapon, they shouldn't take it back themselves
+// for a little while.  But if they throw it at someone else, the other player should get it immediately.
+void CWeaponCSBase::DefaultTouch(CBaseEntity *pOther)
+{
+	if ((m_prevOwner != NULL) && (pOther == m_prevOwner) && (gpGlobals->curtime < m_nextPrevOwnerTouchTime))
+	{
+		return;
+	}
+
+	BaseClass::DefaultTouch(pOther);
+}
+
+#if defined( CLIENT_DLL )
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Draw the weapon's crosshair
+	//-----------------------------------------------------------------------------
+	void CWeaponCSBase::DrawCrosshair()
+	{
+		if ( !crosshair.GetInt() )
+			return;
+
+		CHudCrosshair *pCrosshair = GET_HUDELEMENT( CHudCrosshair );
+
+		if ( !pCrosshair )
+			return;
+
+		// clear crosshair
+		pCrosshair->SetCrosshair( 0, Color( 255, 255, 255, 255 ) );
+
+		CCSPlayer* pPlayer = (CCSPlayer*)C_BasePlayer::GetLocalPlayer();
+
+		if ( !pPlayer )
+			return;
+
+		// localplayer must be owner if not in Spec mode
+		Assert( (pPlayer == GetPlayerOwner()) || ( pPlayer->GetObserverMode()==OBS_MODE_IN_EYE) );
+
+		// Draw the targeting zone around the pCrosshair
+		if ( pPlayer->IsInVGuiInputMode() )
+			return;
+
+		int	r, g, b;
+		switch ( cl_crosshaircolor.GetInt() )
+		{
+		case 0 :	r = 50;		g = 250;	b = 50;		break;
+		case 1 :	r = 250;	g = 50;		b = 50;		break;
+		case 2 :	r = 50;		g = 50;		b = 250;	break;
+		case 3 :	r = 250;	g = 250;	b = 50;		break;
+		case 4 :	r = 50;		g = 250;	b = 250;	break;
+		case 5 :
+			r = cl_crosshaircolor_r.GetInt();
+			g = cl_crosshaircolor_g.GetInt();
+			b = cl_crosshaircolor_b.GetInt();
+			break;
+		default :	r = 50;		g = 250;	b = 50;		break;
+		}
+
+		// if user is using nightvision, make the crosshair red.
+		if (pPlayer->m_bNightVisionOn)
+		{
+			r = 250;
+			g = 50;
+			b = 50;
+		}
+
+		int alpha = clamp( cl_crosshairalpha.GetInt(), 0, 255 );
+		vgui::surface()->DrawSetColor( r, g, b, alpha );
+
+		if ( !m_iCrosshairTextureID )
+		{
+			CHudTexture *pTexture = gHUD.GetIcon( "whiteAdditive" );
+			if ( pTexture )
+			{
+				m_iCrosshairTextureID = pTexture->textureId;
+			}
+		}
+
+		bool bAdditive = !cl_crosshairusealpha.GetBool() && !pPlayer->m_bNightVisionOn;
+		if ( bAdditive )
+		{
+			vgui::surface()->DrawSetColor( r, g, b, 200 );
+			vgui::surface()->DrawSetTexture( m_iCrosshairTextureID );
+		}
+
+		if ( pPlayer->HasShield() && pPlayer->IsShieldDrawn() == true )
+			 return;
+
+		// no crosshair for sniper rifles
+		bool bCrosshairVisible = crosshair.GetBool() && GetCSWpnData().m_WeaponType != WEAPONTYPE_SNIPER_RIFLE;
+
+		if ( !bCrosshairVisible 
+#if ALLOW_WEAPON_SPREAD_DISPLAY
+			&& !weapon_debug_spread_show.GetBool()
+#endif
+			)
+			 return;
+
+		float fHalfFov = DEG2RAD(pPlayer->GetFOV()) * 0.5f;
+
+		int iCrosshairDistance;
+		int iBarSize = RoundFloatToInt(YRES(cl_crosshairsize.GetFloat()));
+		int iBarThickness = MAX( 1, RoundFloatToInt(YRES(cl_crosshairthickness.GetFloat())));
+
+		switch ( cl_dynamiccrosshair.GetInt() )
+		{
+		case 0:
+		default:
+			{
+				// static crosshair
+				float fSpread = (GetCSWpnData().m_fSpread[m_weaponMode] + GetCSWpnData().m_fInaccuracyStand[m_weaponMode]) * 320.0f / tanf(fHalfFov);
+				iCrosshairDistance = MAX( 0, RoundFloatToInt( YRES( fSpread * cl_crosshairspreadscale.GetFloat() ) ) );
+			}
+			break;
+
+		case 1:
+			{
+				float fSpread = (GetInaccuracy() + GetSpread()) * 320.0f / tanf(fHalfFov);
+				iCrosshairDistance = MAX( 0, RoundFloatToInt( YRES( fSpread * cl_crosshairspreadscale.GetFloat() ) ) );
+			}
+			break;
+
+		case 2:
+		case 3:
+			{
+				float fCrosshairDistanceGoal = GetCSWpnData().m_iCrosshairMinDistance; // The minimum distance the crosshair can achieve...
+
+				// legacy dynamic crosshair
+				if ( cl_dynamiccrosshair.GetInt() == 2 )
+				{
+					if ( !( pPlayer->GetFlags() & FL_ONGROUND ) )
+						fCrosshairDistanceGoal *= 2.0f;
+					else if ( pPlayer->GetFlags() & FL_DUCKING )
+						fCrosshairDistanceGoal *= 0.5f;
+					else if ( pPlayer->GetAbsVelocity().Length() > 100 )
+						fCrosshairDistanceGoal *= 1.5f;
+				}
+
+				// [jpaquin] changed to only bump up the crosshair size if the player is still shooting or is spectating someone else
+				int iDeltaDistance = GetCSWpnData().m_iCrosshairDeltaDistance; // Amount by which the crosshair expands when shooting (per frame)
+				if ( pPlayer->m_iShotsFired > m_iAmmoLastCheck && (pPlayer->m_nButtons & (IN_ATTACK|IN_ATTACK2)) )
+					fCrosshairDistanceGoal += iDeltaDistance;
+
+				m_iAmmoLastCheck = pPlayer->m_iShotsFired;
+
+				if ( m_flCrosshairDistance > fCrosshairDistanceGoal )
+				{
+					// [jpaquin] if we're not in legacy crosshair mode, use an exponential decay function so
+					// that the crosshair shrinks at the same rate regardless of the frame rate
+					if ( !cl_legacy_crosshair_recoil.GetBool() )
+					{
+						// .44888 on the next line makes the decay very close to what old method produces at 100fps.
+						m_flCrosshairDistance = Lerp(expf(-gpGlobals->frametime / 0.44888f), fCrosshairDistanceGoal, m_flCrosshairDistance);
+					}
+					else
+					{
+						m_flCrosshairDistance -= 0.1f + m_flCrosshairDistance * 0.013;
+					}
+				}
+
+				// clamp max crosshair expansion
+				m_flCrosshairDistance = clamp(m_flCrosshairDistance, fCrosshairDistanceGoal, 25.0f);
+
+				if ( cl_legacy_crosshair_scale.GetBool() )
+				{
+					//scale bar size to the resolution
+					int crosshairScale = cl_crosshairscale.GetInt();
+					if ( crosshairScale < 1 )
+					{
+						if ( ScreenHeight() <= 600 )
+						{
+							crosshairScale = 600;
+						}
+						else if ( ScreenHeight() <= 768 )
+						{
+							crosshairScale = 768;
+						}
+						else
+						{
+							crosshairScale = 1200;
+						}
+					}
+
+					float scale;
+					if( cl_scalecrosshair.GetBool() == false )
+					{
+						scale = 1.0f;
+					}
+					else
+					{
+						scale = (float)ScreenHeight() / (float)crosshairScale;
+					}
+
+					// calculate the inner distance of the crosshair in current screen units
+					iCrosshairDistance = (int)ceil( m_flCrosshairDistance * scale );
+
+					iBarSize = XRES(5); //  + (iCrosshairDistance - fCrosshairDistanceGoal) / 2;
+					iBarSize = MAX( 1, (int)( (float)iBarSize * scale ) );
+					iBarThickness = MAX( 1, (int)floor( scale + 0.5f ) );
+				}
+				else
+				{
+					iCrosshairDistance = RoundFloatToInt(m_flCrosshairDistance * ScreenHeight() / 1200.0f);
+				}
+			}
+			break;
+		}
+
+		int iCenterX = ScreenWidth() / 2;
+		int iCenterY = ScreenHeight() / 2;
+
+		if ( bCrosshairVisible )
+		{
+			// draw horizontal crosshair lines
+			int iInnerLeft	= iCenterX - iCrosshairDistance - iBarThickness / 2;
+			int iInnerRight	= iInnerLeft + 2 * iCrosshairDistance + iBarThickness;
+			int iOuterLeft	= iInnerLeft - iBarSize;
+			int iOuterRight	= iInnerRight + iBarSize;
+			int y0 = iCenterY - iBarThickness / 2;
+			int y1 = y0 + iBarThickness;
+			DrawCrosshairRect( iOuterLeft, y0, iInnerLeft, y1, bAdditive );
+			DrawCrosshairRect( iInnerRight, y0, iOuterRight, y1, bAdditive );
+
+			// draw vertical crosshair lines
+			int iInnerTop		= iCenterY - iCrosshairDistance - iBarThickness / 2;
+			int iInnerBottom	= iInnerTop + 2 * iCrosshairDistance + iBarThickness;
+			int iOuterTop		= iInnerTop - iBarSize;
+			int iOuterBottom	= iInnerBottom + iBarSize;
+			int x0 = iCenterX - iBarThickness / 2;
+			int x1 = x0 + iBarThickness;
+			DrawCrosshairRect( x0, iOuterTop, x1, iInnerTop, bAdditive );
+			DrawCrosshairRect( x0, iInnerBottom, x1, iOuterBottom, bAdditive );
+
+			// draw dot
+			if ( cl_crosshairdot.GetBool() )
+			{
+				int x0 = iCenterX - iBarThickness / 2;
+				int x1 = x0 + iBarThickness;
+				int y0 = iCenterY - iBarThickness / 2;
+				int y1 = y0 + iBarThickness;
+				DrawCrosshairRect( x0, y0, x1, y1, bAdditive );
+			}
+		}
+
+#if ALLOW_WEAPON_SPREAD_DISPLAY
+		// show accuracy brackets
+		if ( weapon_debug_spread_show.GetInt() == 1 || weapon_debug_spread_show.GetInt() == 2 )
+		{
+			if ( weapon_debug_spread_show.GetInt() == 2 )
+			{
+				const QAngle& punchAngles = pPlayer->GetPunchAngle();
+				Vector vecDirShooting;
+				AngleVectors( punchAngles, &vecDirShooting );
+
+				float iOffsetX = RoundFloatToInt(YRES(vecDirShooting.y * 320.0f / tanf(fHalfFov)));
+				float iOffsetY = RoundFloatToInt(YRES(vecDirShooting.z * 320.0f / tanf(fHalfFov)));
+
+				iCenterX -= iOffsetX;
+				iCenterY -= iOffsetY;
+			}
+
+			// colors
+			r = 250;
+			g = 250;
+			b = 50;
+			vgui::surface()->DrawSetColor( r, g, b, alpha );
+
+			int iBarThickness = MAX( 1, RoundFloatToInt(YRES(cl_crosshairthickness.GetFloat())));
+
+			float fSpreadDistance = (GetInaccuracy() + GetSpread()) * 320.0f / tanf(fHalfFov);
+			int iSpreadDistance = RoundFloatToInt(YRES(fSpreadDistance));
+
+			// draw vertical spread lines
+			int iInnerLeft	= iCenterX - iSpreadDistance;
+			int iInnerRight	= iCenterX + iSpreadDistance;
+			int iOuterLeft	= iInnerLeft - iBarThickness;
+			int iOuterRight	= iInnerRight + iBarThickness;
+			int iInnerTop		= iCenterY - iSpreadDistance;
+			int iInnerBottom	= iCenterY + iSpreadDistance;
+			int iOuterTop		= iInnerTop - iBarThickness;
+			int iOuterBottom	= iInnerBottom + iBarThickness;
+
+			int iGap = RoundFloatToInt(weapon_debug_spread_gap.GetFloat() * iSpreadDistance);
+
+			// draw horizontal lines
+			DrawCrosshairRect( iOuterLeft, iOuterTop, iCenterX - iGap, iInnerTop, bAdditive );
+			DrawCrosshairRect( iCenterX + iGap, iOuterTop, iOuterRight, iInnerTop, bAdditive );
+			DrawCrosshairRect( iOuterLeft, iInnerBottom, iCenterX - iGap, iOuterBottom, bAdditive );
+			DrawCrosshairRect( iCenterX + iGap, iInnerBottom, iOuterRight, iOuterBottom, bAdditive );
+
+			// draw vertical lines
+			DrawCrosshairRect( iOuterLeft, iOuterTop, iInnerLeft, iCenterY - iGap, bAdditive );
+			DrawCrosshairRect( iOuterLeft, iCenterY + iGap, iInnerLeft, iOuterBottom, bAdditive );
+			DrawCrosshairRect( iInnerRight, iOuterTop, iOuterRight, iCenterY - iGap, bAdditive );
+			DrawCrosshairRect( iInnerRight, iCenterY + iGap, iOuterRight, iOuterBottom, bAdditive );
+		}
+#endif
+	}
+
+	void CWeaponCSBase::OnDataChanged( DataUpdateType_t type )
+	{
+		BaseClass::OnDataChanged( type );
+
+		if ( GetPredictable() && !ShouldPredict() )
+			ShutdownPredictable();
+	}
+
+
+	bool CWeaponCSBase::ShouldPredict()
+	{
+		if ( GetOwner() && GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	void CWeaponCSBase::ProcessMuzzleFlashEvent()
+	{
+		// This is handled from the player's animstate, so it can match up to the beginning of the fire animation
+	}
+
+
+	bool CWeaponCSBase::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
+	{
+		if( event == 5001 )
+		{
+			C_CSPlayer *pPlayer = ToCSPlayer( GetOwner() );
+			if( pPlayer && pPlayer->GetFOV() < pPlayer->GetDefaultFOV() && HideViewModelWhenZoomed() )
+				return true;
+
+			CEffectData data;
+			data.m_fFlags = 0;
+			data.m_hEntity = pViewModel->GetRefEHandle();
+			data.m_nAttachmentIndex = 1;
+			data.m_flScale = GetCSWpnData().m_flMuzzleScale;
+
+			switch( GetMuzzleFlashStyle() )
+			{
+			case CS_MUZZLEFLASH_NONE:
+				break;
+
+			case CS_MUZZLEFLASH_X:
+				{
+					DispatchEffect( "CS_MuzzleFlash_X", data );
+				}
+				break;
+
+			case CS_MUZZLEFLASH_NORM:
+			default:
+				{
+					DispatchEffect( "CS_MuzzleFlash", data );
+				}
+				break;
+			}
+
+			return true;
+		}
+
+		return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
+	}
+
+	int CWeaponCSBase::GetMuzzleFlashStyle( void )
+	{
+		return GetCSWpnData().m_iMuzzleFlashStyle;
+	}
+
+	int CWeaponCSBase::GetMuzzleAttachment( void )
+	{
+		return LookupAttachment( "muzzle_flash" );
+	}
+
+#else
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Get the accuracy derived from weapon and player, and return it
+	//-----------------------------------------------------------------------------
+	const Vector& CWeaponCSBase::GetBulletSpread()
+	{
+		static Vector cone = VECTOR_CONE_8DEGREES;
+		return cone;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Match the anim speed to the weapon speed while crouching
+	//-----------------------------------------------------------------------------
+	float CWeaponCSBase::GetDefaultAnimSpeed()
+	{
+		return 1.0;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Draw the laser rifle effect
+	//-----------------------------------------------------------------------------
+	void CWeaponCSBase::BulletWasFired( const Vector &vecStart, const Vector &vecEnd )
+	{
+	}
+
+
+	bool CWeaponCSBase::ShouldRemoveOnRoundRestart()
+	{
+		if ( GetPlayerOwner() )
+			return false;
+		else
+			return true;
+	}
+
+
+    //=============================================================================
+    // HPE_BEGIN:
+    // [dwenger] Handle round restart processing for the weapon.
+    //=============================================================================
+
+    void CWeaponCSBase::OnRoundRestart()
+    {
+        // Clear out the list of prior owners
+        m_PriorOwners.RemoveAll();
+    }
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+
+	//=========================================================
+	// Materialize - make a CWeaponCSBase visible and tangible
+	//=========================================================
+	void CWeaponCSBase::Materialize()
+	{
+		if ( IsEffectActive( EF_NODRAW ) )
+		{
+			// changing from invisible state to visible.
+			RemoveEffects( EF_NODRAW );
+			DoMuzzleFlash();
+		}
+
+		AddSolidFlags( FSOLID_TRIGGER );
+
+		//SetTouch( &CWeaponCSBase::DefaultTouch );
+
+		SetThink( NULL );
+
+	}
+
+	//=========================================================
+	// AttemptToMaterialize - the item is trying to rematerialize,
+	// should it do so now or wait longer?
+	//=========================================================
+	void CWeaponCSBase::AttemptToMaterialize()
+	{
+		float time = g_pGameRules->FlWeaponTryRespawn( this );
+
+		if ( time == 0 )
+		{
+			Materialize();
+			return;
+		}
+
+		SetNextThink( gpGlobals->curtime + time );
+	}
+
+	//=========================================================
+	// CheckRespawn - a player is taking this weapon, should
+	// it respawn?
+	//=========================================================
+	void CWeaponCSBase::CheckRespawn()
+	{
+		//GOOSEMAN : Do not respawn weapons!
+		return;
+	}
+
+
+	//=========================================================
+	// Respawn- this item is already in the world, but it is
+	// invisible and intangible. Make it visible and tangible.
+	//=========================================================
+	CBaseEntity* CWeaponCSBase::Respawn()
+	{
+		// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
+		// will decide when to make the weapon visible and touchable.
+		CBaseEntity *pNewWeapon = CBaseEntity::Create( GetClassname(), g_pGameRules->VecWeaponRespawnSpot( this ), GetAbsAngles(), GetOwner() );
+
+		if ( pNewWeapon )
+		{
+			pNewWeapon->AddEffects( EF_NODRAW );// invisible for now
+			pNewWeapon->SetTouch( NULL );// no touch
+			pNewWeapon->SetThink( &CWeaponCSBase::AttemptToMaterialize );
+
+			UTIL_DropToFloor( this, MASK_SOLID );
+
+			// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
+			// but when it should respawn is based on conditions belonging to the weapon that was taken.
+			pNewWeapon->SetNextThink( gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime( this ) );
+		}
+		else
+		{
+			Msg( "Respawn failed to create %s!\n", GetClassname() );
+		}
+
+		return pNewWeapon;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose:
+	//-----------------------------------------------------------------------------
+	void CWeaponCSBase::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+	{
+		CBasePlayer *pPlayer = ToBasePlayer( pActivator );
+		
+		if ( pPlayer )
+		{
+			m_OnPlayerUse.FireOutput( pActivator, pCaller );
+		}
+	}
+
+	bool CWeaponCSBase::Reload()
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return false;
+
+		pPlayer->m_iShotsFired = 0;
+
+		bool retval = BaseClass::Reload();
+
+		return retval;
+	}
+
+	void CWeaponCSBase::Spawn()
+	{
+		BaseClass::Spawn();
+
+		// Override the bloat that our base class sets as it's a little bit bigger than we want.
+		// If it's too big, you drop a weapon and its box is so big that you're still touching it
+		// when it falls and you pick it up again right away.
+		CollisionProp()->UseTriggerBounds( true, 30 );
+
+		// Set this here to allow players to shoot dropped weapons
+		SetCollisionGroup( COLLISION_GROUP_WEAPON );
+
+		SetExtraAmmoCount( m_iDefaultExtraAmmo );	//Start with no additional ammo
+
+		m_nextPrevOwnerTouchTime = 0.0;
+		m_prevOwner = NULL;
+
+        //=============================================================================
+        // HPE_BEGIN:
+        //=============================================================================
+
+        // [tj] initialize donor of this weapon
+        m_donor = NULL;
+        m_donated = false;
+
+		m_weaponMode = Primary_Mode;
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+	}
+
+	bool CWeaponCSBase::DefaultReload( int iClipSize1, int iClipSize2, int iActivity )
+	{
+		if ( BaseClass::DefaultReload( iClipSize1, iClipSize2, iActivity ) )
+		{
+			SendReloadEvents();
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	void CWeaponCSBase::SendReloadEvents()
+	{
+		CCSPlayer *pPlayer = dynamic_cast< CCSPlayer* >( GetOwner() );
+		if ( !pPlayer )
+			return;
+
+		// Send a message to any clients that have this entity to play the reload.
+		CPASFilter filter( pPlayer->GetAbsOrigin() );
+		filter.RemoveRecipient( pPlayer );
+
+		UserMessageBegin( filter, "ReloadEffect" );
+			WRITE_SHORT( pPlayer->entindex() );
+		MessageEnd();
+
+		// Make the player play his reload animation.
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD );
+	}
+
+#endif
+
+
+bool CWeaponCSBase::DefaultPistolReload()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if (pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0)
+		return true;
+
+	if ( !DefaultReload( GetCSWpnData().iDefaultClip1, 0, ACT_VM_RELOAD ) )
+		return false;
+
+	pPlayer->m_iShotsFired = 0;
+
+	return true;
+}
+
+bool CWeaponCSBase::IsUseable()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if ( Clip1() <= 0 )
+	{
+		if ( pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0 && GetMaxClip1() != -1 )
+		{
+			// clip is empty (or nonexistant) and the player has no more ammo of this type.
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+#if defined( CLIENT_DLL )
+
+	float	g_lateralBob = 0;
+	float	g_verticalBob = 0;
+
+	static ConVar	cl_bobcycle( "cl_bobcycle","0.8", FCVAR_CHEAT );
+	static ConVar	cl_bob( "cl_bob","0.002", FCVAR_CHEAT );
+	static ConVar	cl_bobup( "cl_bobup","0.5", FCVAR_CHEAT );
+
+	//-----------------------------------------------------------------------------
+	// Purpose:
+	// Output : float
+	//-----------------------------------------------------------------------------
+	float CWeaponCSBase::CalcViewmodelBob( void )
+	{
+		static	float bobtime;
+		static	float lastbobtime;
+		static  float lastspeed;
+		float	cycle;
+
+		CBasePlayer *player = ToBasePlayer( GetOwner() );
+		//Assert( player );
+
+		//NOTENOTE: For now, let this cycle continue when in the air, because it snaps badly without it
+
+		if ( ( !gpGlobals->frametime ) ||
+			 ( player == NULL ) ||
+			 ( cl_bobcycle.GetFloat() <= 0.0f ) ||
+			 ( cl_bobup.GetFloat() <= 0.0f ) ||
+			 ( cl_bobup.GetFloat() >= 1.0f ) )
+		{
+			//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
+			return 0.0f;// just use old value
+		}
+
+		//Find the speed of the player
+		float speed = player->GetLocalVelocity().Length2D();
+		float flmaxSpeedDelta = MAX( 0, (gpGlobals->curtime - lastbobtime) * 320.0f );
+
+		// don't allow too big speed changes
+		speed = clamp( speed, lastspeed-flmaxSpeedDelta, lastspeed+flmaxSpeedDelta );
+		speed = clamp( speed, -320, 320 );
+
+		lastspeed = speed;
+
+		//FIXME: This maximum speed value must come from the server.
+		//		 MaxSpeed() is not sufficient for dealing with sprinting - jdw
+
+
+
+		float bob_offset = RemapVal( speed, 0, 320, 0.0f, 1.0f );
+
+		bobtime += ( gpGlobals->curtime - lastbobtime ) * bob_offset;
+		lastbobtime = gpGlobals->curtime;
+
+		//Calculate the vertical bob
+		cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat())*cl_bobcycle.GetFloat();
+		cycle /= cl_bobcycle.GetFloat();
+
+		if ( cycle < cl_bobup.GetFloat() )
+		{
+			cycle = M_PI * cycle / cl_bobup.GetFloat();
+		}
+		else
+		{
+			cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
+		}
+
+		g_verticalBob = speed*0.005f;
+		g_verticalBob = g_verticalBob*0.3 + g_verticalBob*0.7*sin(cycle);
+
+		g_verticalBob = clamp( g_verticalBob, -7.0f, 4.0f );
+
+		//Calculate the lateral bob
+		cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat()*2)*cl_bobcycle.GetFloat()*2;
+		cycle /= cl_bobcycle.GetFloat()*2;
+
+		if ( cycle < cl_bobup.GetFloat() )
+		{
+			cycle = M_PI * cycle / cl_bobup.GetFloat();
+		}
+		else
+		{
+			cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
+		}
+
+		g_lateralBob = speed*0.005f;
+		g_lateralBob = g_lateralBob*0.3 + g_lateralBob*0.7*sin(cycle);
+		g_lateralBob = clamp( g_lateralBob, -7.0f, 4.0f );
+
+		//NOTENOTE: We don't use this return value in our case (need to restructure the calculation function setup!)
+		return 0.0f;
+
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose:
+	// Input  : &origin -
+	//			&angles -
+	//			viewmodelindex -
+	//-----------------------------------------------------------------------------
+	void CWeaponCSBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
+	{
+		Vector	forward, right;
+		AngleVectors( angles, &forward, &right, NULL );
+
+		CalcViewmodelBob();
+
+		// Apply bob, but scaled down to 40%
+		VectorMA( origin, g_verticalBob * 0.4f, forward, origin );
+
+		// Z bob a bit more
+		origin[2] += g_verticalBob * 0.1f;
+
+		// bob the angles
+		angles[ ROLL ]	+= g_verticalBob * 0.5f;
+		angles[ PITCH ]	-= g_verticalBob * 0.4f;
+
+		angles[ YAW ]	-= g_lateralBob  * 0.3f;
+
+	//	VectorMA( origin, g_lateralBob * 0.2f, right, origin );
+	}
+
+#else
+
+	void CWeaponCSBase::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
+	{
+
+	}
+
+	float CWeaponCSBase::CalcViewmodelBob( void )
+	{
+		return 0.0f;
+	}
+
+#endif
+
+#ifndef CLIENT_DLL
+bool CWeaponCSBase::PhysicsSplash( const Vector &centerPoint, const Vector &normal, float rawSpeed, float scaledSpeed )
+{
+	if ( rawSpeed > 20 )
+	{
+
+		float size = 4.0f;
+		if ( !IsPistol() )
+			size += 2.0f;
+
+		// adjust splash size based on speed
+		size += RemapValClamped( rawSpeed, 0, 400, 0, 3 );
+
+		CEffectData	data;
+ 		data.m_vOrigin = centerPoint;
+		data.m_vNormal = normal;
+		data.m_flScale = random->RandomFloat( size, size + 1.0f );
+
+		if ( GetWaterType() & CONTENTS_SLIME )
+		{
+			data.m_fFlags |= FX_WATER_IN_SLIME;
+		}
+
+		DispatchEffect( "gunshotsplash", data );
+
+		return true;
+	}
+
+	return false;
+}
+#endif // !CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Purpose:
+// Input  : *pPicker -
+//-----------------------------------------------------------------------------
+void CWeaponCSBase::OnPickedUp( CBaseCombatCharacter *pNewOwner )
+{
+#if !defined( CLIENT_DLL )
+	RemoveEffects( EF_ITEM_BLINK );
+
+	if( pNewOwner->IsPlayer() && pNewOwner->IsAlive() )
+	{
+		m_OnPlayerPickup.FireOutput(pNewOwner, this);
+
+		// Play the pickup sound for 1st-person observers
+		CRecipientFilter filter;
+		for ( int i=0; i<gpGlobals->maxClients; ++i )
+		{
+			CBasePlayer *player = UTIL_PlayerByIndex(i);
+			if ( player && !player->IsAlive() && player->GetObserverMode() == OBS_MODE_IN_EYE )
+			{
+				filter.AddRecipient( player );
+			}
+		}
+		if ( filter.GetRecipientCount() )
+		{
+			CBaseEntity::EmitSound( filter, pNewOwner->entindex(), "Player.PickupWeapon" );
+		}
+
+		// Robin: We don't want to delete weapons the player has picked up, so
+		// clear the name of the weapon. This prevents wildcards that are meant
+		// to find NPCs finding weapons dropped by the NPCs as well.
+		SetName( NULL_STRING );
+	}
+
+	// Someone picked me up, so make it so that I can't be removed.
+	SetRemoveable( false );
+#endif
+}
+
+
+void CWeaponCSBase::UpdateAccuracyPenalty()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	const CCSWeaponInfo& weaponInfo = GetCSWpnData();
+
+	float fNewPenalty = 0.0f;
+
+	// on ladder?
+	if ( pPlayer->GetMoveType() == MOVETYPE_LADDER )
+	{
+		fNewPenalty += weaponInfo.m_fInaccuracyStand[m_weaponMode] + weaponInfo.m_fInaccuracyLadder[m_weaponMode];
+	}
+	// in the air?
+// 	else if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+// 	{
+// 		fNewPenalty += weaponInfo.m_fInaccuracyStand[m_weaponMode] + weaponInfo.m_fInaccuracyJump[m_weaponMode];
+// 	}
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING) )
+	{
+		fNewPenalty += weaponInfo.m_fInaccuracyCrouch[m_weaponMode];
+	}
+	else
+	{
+		fNewPenalty += weaponInfo.m_fInaccuracyStand[m_weaponMode];
+	}
+
+	if ( m_bInReload )
+	{
+ 		fNewPenalty += weaponInfo.m_fInaccuracyReload;
+	}
+
+	if ( fNewPenalty > m_fAccuracyPenalty )
+	{
+		m_fAccuracyPenalty = fNewPenalty;
+	}
+	else
+	{
+		float fDecayFactor;
+
+		if ( pPlayer->GetMoveType() == MOVETYPE_LADDER )
+		{
+			fDecayFactor = logf(10.0f) / weaponInfo.m_fRecoveryTimeStand;
+		}
+		else if ( !FBitSet(pPlayer->GetFlags(), FL_ONGROUND) )	// in air
+		{
+			// enforce a large recovery speed penalty (300%) for players in the air; this helps to provide
+			// comparable in-air accuracy to the old weapon model
+			fDecayFactor = logf(10.0f) / (weaponInfo.m_fRecoveryTimeCrouch * 3.0f);
+		}
+		else if ( FBitSet(pPlayer->GetFlags(), FL_DUCKING) )
+		{
+			fDecayFactor = logf(10.0f) / weaponInfo.m_fRecoveryTimeCrouch;
+		}
+		else
+		{
+			fDecayFactor = logf(10.0f) / weaponInfo.m_fRecoveryTimeStand;
+		}
+		m_fAccuracyPenalty = Lerp(expf(TICK_INTERVAL * -fDecayFactor), fNewPenalty, (float)m_fAccuracyPenalty);
+	}
+}
+
+
+const float kJumpVelocity = sqrtf(2.0f * 800.0f * 57.0f);	// see CCSGameMovement::CheckJumpButton()
+
+void CWeaponCSBase::OnJump( float fImpulse )
+{
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyJump[m_weaponMode] * fImpulse / kJumpVelocity;
+}
+
+void CWeaponCSBase::OnLand( float fVelocity )
+{
+	float fPenalty = GetCSWpnData().m_fInaccuracyLand[m_weaponMode] * fVelocity / kJumpVelocity;
+	m_fAccuracyPenalty += fPenalty;
+
+/*
+	// this bit of code is only if we want to punch the player view on all landings
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	QAngle angle = pPlayer->GetPunchAngle();
+	float fVKick = RAD2DEG(asinf(fPenalty)) * 0.4f;
+	float fHKick = SharedRandomFloat("LandPunchAngleYaw", -1.0f, +1.0f) * fVKick * 0.1f;
+
+	angle.x += fVKick;	// pitch
+	angle.y += fHKick;	// yaw
+	pPlayer->SetPunchAngle( angle );
+*/
+}
diff --git a/game/shared/cstrike/weapon_csbase.h b/game/shared/cstrike/weapon_csbase.h
new file mode 100644
index 00000000..9a81b612
--- /dev/null
+++ b/game/shared/cstrike/weapon_csbase.h
@@ -0,0 +1,289 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_CSBASE_H
+#define WEAPON_CSBASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "cs_playeranimstate.h"
+#include "cs_weapon_parse.h"
+
+
+#if defined( CLIENT_DLL )
+	#define CWeaponCSBase C_WeaponCSBase
+#endif
+
+extern CSWeaponID AliasToWeaponID( const char *alias );
+extern const char *WeaponIDToAlias( int id );
+extern const char *GetTranslatedWeaponAlias( const char *alias);
+extern const char * GetWeaponAliasFromTranslated(const char *translatedAlias);
+extern bool	IsPrimaryWeapon( CSWeaponID id );
+extern bool IsSecondaryWeapon( CSWeaponID  id );
+extern int GetShellForAmmoType( const char *ammoname );
+
+#define SHIELD_VIEW_MODEL "models/weapons/v_shield.mdl"
+#define SHIELD_WORLD_MODEL "models/weapons/w_shield.mdl"
+
+class CCSPlayer;
+
+// These are the names of the ammo types that go in the CAmmoDefs and that the 
+// weapon script files reference.
+#define BULLET_PLAYER_50AE		"BULLET_PLAYER_50AE"
+#define BULLET_PLAYER_762MM		"BULLET_PLAYER_762MM"
+#define BULLET_PLAYER_556MM		"BULLET_PLAYER_556MM"
+#define BULLET_PLAYER_556MM_BOX	"BULLET_PLAYER_556MM_BOX"
+#define BULLET_PLAYER_338MAG	"BULLET_PLAYER_338MAG"
+#define BULLET_PLAYER_9MM		"BULLET_PLAYER_9MM"
+#define BULLET_PLAYER_BUCKSHOT	"BULLET_PLAYER_BUCKSHOT"
+#define BULLET_PLAYER_45ACP		"BULLET_PLAYER_45ACP"
+#define BULLET_PLAYER_357SIG	"BULLET_PLAYER_357SIG"
+#define BULLET_PLAYER_57MM		"BULLET_PLAYER_57MM"
+#define AMMO_TYPE_HEGRENADE		"AMMO_TYPE_HEGRENADE"
+#define AMMO_TYPE_FLASHBANG		"AMMO_TYPE_FLASHBANG"
+#define AMMO_TYPE_SMOKEGRENADE	"AMMO_TYPE_SMOKEGRENADE"
+
+#define CROSSHAIR_CONTRACT_PIXELS_PER_SECOND	7.0f
+
+// Given an ammo type (like from a weapon's GetPrimaryAmmoType()), this compares it
+// against the ammo name you specify.
+// MIKETODO: this should use indexing instead of searching and strcmp()'ing all the time.
+bool IsAmmoType( int iAmmoType, const char *pAmmoName );
+
+enum CSWeaponMode
+{
+	Primary_Mode = 0,
+	Secondary_Mode,
+	WeaponMode_MAX
+};
+
+#if defined( CLIENT_DLL )
+
+	//--------------------------------------------------------------------------------------------------------------
+	/**
+	*  Returns the client's ID_* value for the currently owned weapon, or ID_NONE if no weapon is owned
+	*/
+	CSWeaponID GetClientWeaponID( bool primary );
+
+#endif
+
+	//--------------------------------------------------------------------------------------------------------------
+	CCSWeaponInfo * GetWeaponInfo( CSWeaponID weaponID );
+
+
+class CWeaponCSBase : public CBaseCombatWeapon
+{
+public:
+	DECLARE_CLASS( CWeaponCSBase, CBaseCombatWeapon );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponCSBase();
+
+	#ifdef GAME_DLL
+		DECLARE_DATADESC();
+
+		virtual void CheckRespawn();
+		virtual CBaseEntity* Respawn();
+		
+		virtual const Vector& GetBulletSpread();
+		virtual float	GetDefaultAnimSpeed();
+
+		virtual void	BulletWasFired( const Vector &vecStart, const Vector &vecEnd );
+		virtual bool	ShouldRemoveOnRoundRestart();
+
+        //=============================================================================
+        // HPE_BEGIN:
+        // [dwenger] Handle round restart processing for the weapon.
+        //=============================================================================
+
+        virtual void    OnRoundRestart();
+
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+
+        virtual bool	DefaultReload( int iClipSize1, int iClipSize2, int iActivity );
+
+		void SendReloadEvents();
+
+		void Materialize();
+		void AttemptToMaterialize();
+		virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+		virtual bool IsRemoveable();
+		
+	#endif
+
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void	AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles );
+	virtual	float	CalcViewmodelBob( void );
+	// All predicted weapons need to implement and return true
+	virtual bool	IsPredicted() const;
+
+	// Pistols reset m_iShotsFired to 0 when the attack button is released.
+	bool			IsPistol() const;
+
+	virtual bool IsFullAuto() const;
+
+	CCSPlayer* GetPlayerOwner() const;
+
+	virtual float GetMaxSpeed() const;	// What's the player's max speed while holding this weapon.
+
+	// Get CS-specific weapon data.
+	CCSWeaponInfo const	&GetCSWpnData() const;
+
+	// Get specific CS weapon ID (ie: WEAPON_AK47, etc)
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_NONE; }
+
+	// return true if this weapon is an instance of the given weapon type (ie: "IsA" WEAPON_GLOCK)
+	bool IsA( CSWeaponID id ) const						{ return GetWeaponID() == id; }
+
+	// return true if this weapon is a kinf of the given weapon type (ie: "IsKindOf" WEAPONTYPE_RIFLE )
+	bool IsKindOf( CSWeaponType type ) const			{ return GetCSWpnData().m_WeaponType == type; }
+
+	// return true if this weapon has a silencer equipped
+	virtual bool IsSilenced( void ) const				{ return false; }
+
+	virtual void SetWeaponModelIndex( const char *pName );
+	virtual void OnPickedUp( CBaseCombatCharacter *pNewOwner );
+
+	virtual void OnJump( float fImpulse );
+	virtual void OnLand( float fVelocity );
+
+public:
+	#if defined( CLIENT_DLL )
+
+		virtual void	ProcessMuzzleFlashEvent();
+		virtual bool	OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+		virtual bool	ShouldPredict();
+		virtual void	DrawCrosshair();
+		virtual void	OnDataChanged( DataUpdateType_t type );
+
+		virtual int		GetMuzzleAttachment( void );
+		virtual bool	HideViewModelWhenZoomed( void ) { return true; }
+
+		float			m_flCrosshairDistance;
+		int				m_iAmmoLastCheck;
+		int				m_iAlpha;
+		int				m_iScopeTextureID;
+		int				m_iCrosshairTextureID; // for white additive texture
+
+		virtual int GetMuzzleFlashStyle( void );
+
+	#else
+
+		virtual bool	Reload();
+		virtual void	Spawn();
+		virtual bool	KeyValue( const char *szKeyName, const char *szValue );
+
+		virtual bool PhysicsSplash( const Vector &centerPoint, const Vector &normal, float rawSpeed, float scaledSpeed );
+
+	#endif
+
+	bool IsUseable();
+	virtual bool	CanDeploy( void );
+	virtual void	UpdateShieldState( void );
+	virtual bool	SendWeaponAnim( int iActivity );
+	virtual void	SecondaryAttack( void );
+	virtual void	Precache( void );
+	virtual bool	CanBeSelected( void );
+	virtual Activity GetDeployActivity( void );
+	virtual bool	DefaultDeploy( char *szViewModel, char *szWeaponModel, int iActivity, char *szAnimExt );
+	virtual void 	DefaultTouch( CBaseEntity *pOther );	// default weapon touch
+	virtual bool	DefaultPistolReload();
+
+	virtual bool	Deploy();
+	virtual void	Drop( const Vector &vecVelocity );
+	bool PlayEmptySound();
+	virtual void	ItemPostFrame();
+	virtual void	ItemBusyFrame();
+	virtual const char		*GetViewModel( int viewmodelindex = 0 ) const;
+
+
+	bool	m_bDelayFire;			// This variable is used to delay the time between subsequent button pressing.
+	float	m_flAccuracy;
+
+	//=============================================================================
+	// HPE_BEGIN:
+	// [pfreese] new accuracy model
+	//=============================================================================
+
+	CNetworkVar( CSWeaponMode, m_weaponMode);
+
+	virtual float GetInaccuracy() const;
+	virtual float GetSpread() const;
+
+	virtual void UpdateAccuracyPenalty();
+
+	CNetworkVar( float, m_fAccuracyPenalty );
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	
+	void SetExtraAmmoCount( int count ) { m_iExtraPrimaryAmmo = count; }
+	int GetExtraAmmoCount( void ) { return m_iExtraPrimaryAmmo; }
+
+	//=============================================================================
+	// HPE_BEGIN:	
+	//=============================================================================
+
+    // [tj] Accessors for the previous owner of the gun
+	void SetPreviousOwner(CCSPlayer* player) { m_prevOwner = player; }
+	CCSPlayer* GetPreviousOwner() { return m_prevOwner; }
+
+    // [tj] Accessors for the donor system
+    void SetDonor(CCSPlayer* player) { m_donor = player; }
+    CCSPlayer* GetDonor() { return m_donor; }
+    void SetDonated(bool donated) { m_donated = true;}
+    bool GetDonated() { return m_donated; }
+
+    //[dwenger] Accessors for the prior owner list
+    void AddToPriorOwnerList(CCSPlayer* pPlayer);
+    bool IsAPriorOwner(CCSPlayer* pPlayer);
+
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+
+protected:
+
+	float	CalculateNextAttackTime( float flCycleTime );
+
+private:
+
+	float	m_flDecreaseShotsFired;
+
+	CWeaponCSBase( const CWeaponCSBase & );
+
+	int		m_iExtraPrimaryAmmo;
+
+	float	m_nextPrevOwnerTouchTime;
+	CCSPlayer *m_prevOwner;
+
+	int m_iDefaultExtraAmmo;
+
+    //=============================================================================
+    // HPE_BEGIN:
+    //=============================================================================
+
+    // [dwenger] track all prior owners of this weapon
+    CUtlVector< CCSPlayer* >    m_PriorOwners;
+
+    // [tj] To keep track of people who drop weapons for teammates during the buy round
+    CHandle<CCSPlayer> m_donor;
+    bool m_donated;
+
+    //=============================================================================
+    // HPE_END
+    //=============================================================================
+};
+
+extern ConVar weapon_accuracy_model;
+
+#endif // WEAPON_CSBASE_H
diff --git a/game/shared/cstrike/weapon_csbasegun.cpp b/game/shared/cstrike/weapon_csbasegun.cpp
new file mode 100644
index 00000000..6ce0f3d9
--- /dev/null
+++ b/game/shared/cstrike/weapon_csbasegun.cpp
@@ -0,0 +1,218 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+#include "fx_cs_shared.h"
+
+#ifdef CLIENT_DLL
+	#include "c_cs_player.h"
+#else
+	#include "cs_player.h"
+#endif
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCSBaseGun, DT_WeaponCSBaseGun )
+
+BEGIN_NETWORK_TABLE( CWeaponCSBaseGun, DT_WeaponCSBaseGun )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCSBaseGun )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_csbase_gun, CWeaponCSBaseGun );
+
+
+
+CWeaponCSBaseGun::CWeaponCSBaseGun()
+{
+}
+
+void CWeaponCSBaseGun::Spawn()
+{
+	m_flAccuracy = 0.2;
+	m_bDelayFire = false;
+	m_zoomFullyActiveTime = -1.0f;
+
+	BaseClass::Spawn();
+}
+
+
+bool CWeaponCSBaseGun::Deploy()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	m_flAccuracy = 0.2;
+	pPlayer->m_iShotsFired = 0;
+	m_bDelayFire = false;
+	m_zoomFullyActiveTime = -1.0f;
+
+	return BaseClass::Deploy();
+}
+
+void CWeaponCSBaseGun::ItemPostFrame()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer )
+		return;
+
+	//GOOSEMAN : Return zoom level back to previous zoom level before we fired a shot. This is used only for the AWP.
+	// And Scout.
+	if ( (m_flNextPrimaryAttack <= gpGlobals->curtime) && (pPlayer->m_bResumeZoom == TRUE) )
+	{
+		pPlayer->m_bResumeZoom = false;
+		
+		if ( m_iClip1 != 0 || ( GetWeaponFlags() & ITEM_FLAG_NOAUTORELOAD ) )
+		{
+			m_weaponMode = Secondary_Mode;
+			pPlayer->SetFOV( pPlayer, pPlayer->m_iLastZoom, 0.05f );
+			m_zoomFullyActiveTime = gpGlobals->curtime + 0.05f;// Make sure we think that we are zooming on the server so we don't get instant acc bonus
+		}
+	}
+
+	BaseClass::ItemPostFrame();
+}
+
+
+void CWeaponCSBaseGun::PrimaryAttack()
+{
+	// Derived classes should implement this and call CSBaseGunFire.
+	Assert( false );
+}
+
+bool CWeaponCSBaseGun::CSBaseGunFire( float flCycleTime, CSWeaponMode weaponMode )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	const CCSWeaponInfo &pCSInfo = GetCSWpnData();
+
+	m_bDelayFire = true;
+
+	if ( m_iClip1 > 0 )
+	{
+		pPlayer->m_iShotsFired++;
+	
+		// These modifications feed back into flSpread eventually.
+		if ( pCSInfo.m_flAccuracyDivisor != -1 )
+		{
+			int iShotsFired = pPlayer->m_iShotsFired;
+
+			if ( pCSInfo.m_bAccuracyQuadratic )
+				iShotsFired = iShotsFired * iShotsFired;
+			else
+				iShotsFired = iShotsFired * iShotsFired * iShotsFired;
+
+			m_flAccuracy = ( iShotsFired / pCSInfo.m_flAccuracyDivisor ) + pCSInfo.m_flAccuracyOffset;
+			
+			if ( m_flAccuracy > pCSInfo.m_flMaxInaccuracy )
+				m_flAccuracy = pCSInfo.m_flMaxInaccuracy;
+		}
+	}
+	else
+	{
+		m_flAccuracy = 0;
+
+		if ( m_bFireOnEmpty )
+		{
+			PlayEmptySound();
+
+			// NOTE[pmf]: we don't want to actually play the dry fire animations, as most seem to depict the weapon actually firing.
+			// SendWeaponAnim( ACT_VM_DRYFIRE );
+
+			m_bFireOnEmpty = false;
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.1f;
+		}
+
+		return false;
+	}
+
+	float flCurAttack = CalculateNextAttackTime( flCycleTime );
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	m_iClip1--;
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		weaponMode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		GetInaccuracy(),
+		GetSpread(), 
+		flCurAttack );
+
+	DoFireEffects();
+
+	SetWeaponIdleTime( gpGlobals->curtime + GetCSWpnData().m_flTimeToIdleAfterFire );
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[weaponMode];
+
+	return true;
+}
+
+
+void CWeaponCSBaseGun::DoFireEffects()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	
+	if ( pPlayer )
+		 pPlayer->DoMuzzleFlash();
+}
+
+
+bool CWeaponCSBaseGun::Reload()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if (pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0)
+		return false;
+
+	pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), 0.0f );
+
+	int iResult = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
+	if ( !iResult )
+		return false;
+
+	pPlayer->SetAnimation( PLAYER_RELOAD );
+
+	if ((iResult) && (pPlayer->GetFOV() != pPlayer->GetDefaultFOV()))
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV() );
+	}
+
+	m_flAccuracy = 0.2;
+	pPlayer->m_iShotsFired = 0;
+	m_bDelayFire = false;
+
+	pPlayer->SetShieldDrawnState( false );
+	return true;
+}
+
+void CWeaponCSBaseGun::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	// only idle if the slid isn't back
+	if ( m_iClip1 != 0 )
+	{
+		SetWeaponIdleTime( gpGlobals->curtime + GetCSWpnData().m_flIdleInterval );
+		SendWeaponAnim( ACT_VM_IDLE );
+	}
+}
diff --git a/game/shared/cstrike/weapon_csbasegun.h b/game/shared/cstrike/weapon_csbasegun.h
new file mode 100644
index 00000000..67813401
--- /dev/null
+++ b/game/shared/cstrike/weapon_csbasegun.h
@@ -0,0 +1,58 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_CSBASE_GUN_H
+#define WEAPON_CSBASE_GUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_csbase.h"
+
+
+// This is the base class for pistols and rifles.
+#if defined( CLIENT_DLL )
+
+	#define CWeaponCSBaseGun C_WeaponCSBaseGun
+
+#else
+#endif
+
+
+class CWeaponCSBaseGun : public CWeaponCSBase
+{
+public:
+	
+	DECLARE_CLASS( CWeaponCSBaseGun, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponCSBaseGun();
+
+	virtual void PrimaryAttack();
+	virtual void Spawn();
+	virtual bool Deploy();
+	virtual bool Reload();
+	virtual void WeaponIdle();
+
+	// Derived classes call this to fire a bullet.
+	bool CSBaseGunFire( float flCycleTime, CSWeaponMode weaponMode );
+
+	// Usually plays the shot sound. Guns with silencers can play different sounds.
+	virtual void DoFireEffects();
+	virtual void ItemPostFrame();
+
+protected: 
+	float m_zoomFullyActiveTime;
+
+private:
+
+	CWeaponCSBaseGun( const CWeaponCSBaseGun & );
+};
+
+
+#endif // WEAPON_CSBASE_GUN_H
diff --git a/game/shared/cstrike/weapon_deagle.cpp b/game/shared/cstrike/weapon_deagle.cpp
new file mode 100644
index 00000000..1d0d95c6
--- /dev/null
+++ b/game/shared/cstrike/weapon_deagle.cpp
@@ -0,0 +1,235 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h" 
+#include "decals.h" 
+#include "cbase.h" 
+#include "shake.h" 
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CDEagle C_DEagle
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+
+#define DEAGLE_WEIGHT   7
+#define DEAGLE_MAX_CLIP 7
+
+enum deagle_e {
+	DEAGLE_IDLE1 = 0,
+	DEAGLE_SHOOT1,
+	DEAGLE_SHOOT2,
+	DEAGLE_SHOOT_EMPTY,
+	DEAGLE_RELOAD,	
+	DEAGLE_DRAW,
+};
+
+
+
+class CDEagle : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CDEagle, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CDEagle();
+
+	void Spawn();
+
+	void PrimaryAttack();
+	virtual bool Deploy();
+	bool Reload();
+	void WeaponIdle();
+	void MakeBeam ();
+	void BeamUpdate ();
+	virtual bool UseDecrement() {return true;};
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_DEAGLE; }
+
+public:
+	float m_flLastFire;
+
+private:
+	CDEagle( const CDEagle & );
+};
+
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( DEagle, DT_WeaponDEagle )
+
+BEGIN_NETWORK_TABLE( CDEagle, DT_WeaponDEagle )
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CDEagle )
+	DEFINE_FIELD( m_flLastFire, FIELD_FLOAT ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_deagle, CDEagle );
+PRECACHE_WEAPON_REGISTER( weapon_deagle );
+
+
+
+CDEagle::CDEagle()
+{
+	m_flLastFire = gpGlobals->curtime;
+}
+
+
+void CDEagle::Spawn()
+{
+	BaseClass::Spawn();
+	m_flAccuracy = 0.9;
+}
+
+
+bool CDEagle::Deploy()
+{
+	m_flAccuracy = 0.9;
+	return BaseClass::Deploy();
+}
+
+float CDEagle::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 1.5f * (1 - m_flAccuracy);
+
+		else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+			return 0.25f * (1 - m_flAccuracy);
+
+		else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+			return 0.115f * (1 - m_flAccuracy);
+
+		else
+			return 0.13f * (1 - m_flAccuracy);
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CDEagle::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+		
+	// Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+	m_flAccuracy -= (0.35)*(0.4 - ( gpGlobals->curtime - m_flLastFire ) );
+
+	if (m_flAccuracy > 0.9)
+		m_flAccuracy = 0.9;
+	else if (m_flAccuracy < 0.55)
+		m_flAccuracy = 0.55;
+
+	m_flLastFire = gpGlobals->curtime;
+
+	if (m_iClip1 <= 0)
+	{
+		if ( m_bFireOnEmpty )
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.1f;
+			m_bFireOnEmpty = false;
+		}
+
+		return;
+	}
+
+	pPlayer->m_iShotsFired++;
+
+	m_iClip1--;
+
+	pPlayer->DoMuzzleFlash();
+
+	if( m_iClip1 > 0 )
+		SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	else
+		SendWeaponAnim( ACT_VM_DRYFIRE );
+
+	//SetPlayerShieldAnim();
+	
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	//pPlayer->m_iWeaponVolume = BIG_EXPLOSION_VOLUME;
+	//pPlayer->m_iWeaponFlash = BRIGHT_GUN_FLASH;
+
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		Primary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		GetInaccuracy(),
+		GetSpread());
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetCSWpnData().m_flCycleTime;
+
+	if ( !m_iClip1 && pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0 )
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+
+	SetWeaponIdleTime( gpGlobals->curtime + 1.8 );
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[Primary_Mode];
+
+	QAngle punchAngle = pPlayer->GetPunchAngle();
+	punchAngle.x -= 2;
+	pPlayer->SetPunchAngle( punchAngle );
+
+	//ResetPlayerShieldAnim();
+}
+
+
+bool CDEagle::Reload()
+{
+	if ( !DefaultPistolReload() )
+		return false;
+
+	m_flAccuracy = 0.9;
+	return true;
+}
+
+void CDEagle::WeaponIdle()
+{
+	if ( m_flTimeWeaponIdle > gpGlobals->curtime )
+		return;
+
+	SetWeaponIdleTime( gpGlobals->curtime + 20 );
+
+	if (m_iClip1 != 0)
+	{
+		SendWeaponAnim( ACT_VM_IDLE );
+	}
+
+	//if ( FBitSet(m_iWeaponState, WPNSTATE_SHIELD_DRAWN) )
+	//	 SendWeaponAnim( SHIELDGUN_DRAWN_IDLE, UseDecrement() ? 1:0 );
+}
+
diff --git a/game/shared/cstrike/weapon_elite.cpp b/game/shared/cstrike/weapon_elite.cpp
new file mode 100644
index 00000000..b77b87eb
--- /dev/null
+++ b/game/shared/cstrike/weapon_elite.cpp
@@ -0,0 +1,317 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponElite C_WeaponElite
+	#include "c_cs_player.h"
+	#include "c_te_effect_dispatch.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponElite : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CWeaponElite, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponElite();
+
+	virtual void Spawn();
+	virtual void Precache();
+
+	virtual void PrimaryAttack();
+	virtual bool Deploy();
+
+	virtual bool Reload();
+
+	virtual void WeaponIdle();
+
+ 	virtual float GetInaccuracy() const;
+	
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_ELITE; }
+
+#ifdef CLIENT_DLL
+	virtual int		GetMuzzleAttachment( void );
+	virtual bool OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+#endif
+
+	virtual const char		*GetWorldModel( void ) const;
+	virtual int				GetWorldModelIndex( void );
+
+protected:
+	bool FiringLeft() const;
+
+private:
+	
+	CWeaponElite( const CWeaponElite & );
+	float		m_flLastFire;
+
+	int m_droppedModelIndex;
+	bool m_inPrecache;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponElite, DT_WeaponElite )
+
+BEGIN_NETWORK_TABLE( CWeaponElite, DT_WeaponElite )
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CWeaponElite )
+	DEFINE_FIELD( m_flLastFire, FIELD_FLOAT ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_elite, CWeaponElite );
+PRECACHE_WEAPON_REGISTER( weapon_elite );
+
+CWeaponElite::CWeaponElite()
+{
+	m_flLastFire = gpGlobals->curtime;
+	m_inPrecache = false;
+}
+
+
+void CWeaponElite::Spawn( )
+{
+	m_flAccuracy = 0.88;
+	BaseClass::Spawn();
+}
+
+
+void CWeaponElite::Precache()
+{
+	m_inPrecache = true;
+	BaseClass::Precache();
+
+	PrecacheModel( "models/weapons/w_eq_eholster_elite.mdl" );
+	PrecacheModel( "models/weapons/w_eq_eholster.mdl" );
+	PrecacheModel( "models/weapons/w_pist_elite_single.mdl" );
+	m_droppedModelIndex = CBaseEntity::PrecacheModel( GetCSWpnData().m_szDroppedModel );
+	m_inPrecache = false;
+}
+
+bool CWeaponElite::Deploy( )
+{
+	m_flAccuracy = 0.88;
+	return BaseClass::Deploy();
+}
+
+int CWeaponElite::GetWorldModelIndex( void )
+{
+	if ( GetOwner() || m_inPrecache )
+	{
+		return m_iWorldModelIndex;
+	}
+	else
+	{
+		return m_droppedModelIndex;
+	}
+}
+
+const char * CWeaponElite::GetWorldModel( void ) const
+{
+	if ( GetOwner() || m_inPrecache )
+	{
+		return BaseClass::GetWorldModel();
+	}
+	else
+	{
+		return GetCSWpnData().m_szDroppedModel;
+	}
+}
+
+
+bool CWeaponElite::FiringLeft() const
+{
+	// fire left-hand gun with even number of bullets left
+	return (m_iClip1 & 1) == 0;
+}
+
+
+
+float CWeaponElite::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 1.3f * (1 - m_flAccuracy);
+
+		else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+			return 0.175f * (1 - m_flAccuracy);
+
+		else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+			return 0.08f * (1 - m_flAccuracy);
+
+		else
+			return 0.1f * (1 - m_flAccuracy);
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponElite::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+	m_flAccuracy -= (0.275)*(0.325 - (gpGlobals->curtime - m_flLastFire));
+
+	if (m_flAccuracy > 0.88)
+		m_flAccuracy = 0.88;
+	else if (m_flAccuracy < 0.55)
+		m_flAccuracy = 0.55;
+
+	m_flLastFire = gpGlobals->curtime;
+
+	if (m_iClip1 <= 0)
+	{
+		if ( m_bFireOnEmpty )
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.1f;
+			m_bFireOnEmpty = false;
+		}
+
+		return;
+	}
+
+	pPlayer->m_iShotsFired++;
+
+	m_iClip1--;
+
+	pPlayer->DoMuzzleFlash();
+
+	//SetPlayerShieldAnim();
+	
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		FiringLeft() ? Secondary_Mode : Primary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		GetInaccuracy(),
+		GetSpread());
+		
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + GetCSWpnData().m_flCycleTime;
+	
+	if (!m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0)
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+
+	SetWeaponIdleTime( gpGlobals->curtime + 2.5 );
+
+	if ( FiringLeft() )
+	{
+		if ( m_iClip1 > 0 )
+			SendWeaponAnim( ACT_VM_SECONDARYATTACK );
+		else
+			SendWeaponAnim( ACT_VM_DRYFIRE );
+	}
+	else
+	{
+		if ( m_iClip1 > 1 )
+			SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+		else
+			SendWeaponAnim( ACT_VM_DRYFIRE_LEFT );
+	}
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[Primary_Mode];
+
+	QAngle punchAngle = pPlayer->GetPunchAngle();
+	punchAngle.x -= 2;
+	pPlayer->SetPunchAngle( punchAngle );
+
+	//ResetPlayerShieldAnim();
+}
+
+
+bool CWeaponElite::Reload()
+{
+	if ( !DefaultPistolReload() )
+		return false;
+
+	m_flAccuracy = 0.88;
+	return true;
+}
+
+void CWeaponElite::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+/*
+	// switching to the idle with the slide back on the right pistol causes animation pops transitioning
+	// from/to the depot/holster animations. The pop transition to the reload is less noticeable, so 
+	// we'll live with that one
+
+	if ( m_iClip1 == 1 )
+	{
+		SendWeaponAnim( ACT_VM_IDLE_EMPTY_LEFT );
+	}
+*/
+
+	// only idle if either slide isn't back
+	if ( m_iClip1 >= 2 )
+	{
+			SendWeaponAnim( ACT_VM_IDLE );
+	}
+}
+
+#ifdef CLIENT_DLL
+
+    bool CWeaponElite::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
+	{
+		if( event == 5001 )
+		{
+			C_CSPlayer *pPlayer = ToCSPlayer( GetOwner() );
+			if( pPlayer && pPlayer->GetFOV() < pPlayer->GetDefaultFOV() && HideViewModelWhenZoomed() )
+				return true;
+			
+			CEffectData data;
+			data.m_fFlags = 0;
+			data.m_hEntity = pViewModel->GetRefEHandle();
+			data.m_nAttachmentIndex = FiringLeft() ? 1 : 2; // toggle muzzle flash
+			data.m_flScale = GetCSWpnData().m_flMuzzleScale;
+		
+			DispatchEffect( "CS_MuzzleFlash", data );
+
+			return true;
+		}
+
+		return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
+	}
+
+	int CWeaponElite::GetMuzzleAttachment( void )
+	{
+		return LookupAttachment( FiringLeft() ? "muzzle_flash_l" : "muzzle_flash_r" );	
+	}
+
+#endif
\ No newline at end of file
diff --git a/game/shared/cstrike/weapon_famas.cpp b/game/shared/cstrike/weapon_famas.cpp
new file mode 100644
index 00000000..1f22cad3
--- /dev/null
+++ b/game/shared/cstrike/weapon_famas.cpp
@@ -0,0 +1,243 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+#include "fx_cs_shared.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponFamas C_WeaponFamas
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponFamas : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponFamas, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponFamas();
+
+	virtual void PrimaryAttack();
+	virtual void SecondaryAttack();
+	virtual bool Deploy();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual void ItemPostFrame();
+
+	void FamasFire( float flSpread, bool bFireBurst );
+	void FireRemaining();
+	
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_FAMAS; }
+
+private:
+	
+	CWeaponFamas( const CWeaponFamas & );
+	CNetworkVar( bool, m_bBurstMode );
+	CNetworkVar( int, m_iBurstShotsRemaining );	
+	float	m_fNextBurstShot;			// time to shoot the next bullet in burst fire mode
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponFamas, DT_WeaponFamas )
+
+BEGIN_NETWORK_TABLE( CWeaponFamas, DT_WeaponFamas )
+	#ifdef CLIENT_DLL
+		RecvPropBool( RECVINFO( m_bBurstMode ) ),
+		RecvPropInt( RECVINFO( m_iBurstShotsRemaining ) ),
+	#else
+		SendPropBool( SENDINFO( m_bBurstMode ) ),
+		SendPropInt( SENDINFO( m_iBurstShotsRemaining ) ),
+	#endif
+END_NETWORK_TABLE()
+
+#if defined(CLIENT_DLL)
+BEGIN_PREDICTION_DATA( CWeaponFamas )
+DEFINE_PRED_FIELD( m_iBurstShotsRemaining, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+DEFINE_PRED_FIELD( m_fNextBurstShot, FIELD_FLOAT, 0 ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_famas, CWeaponFamas );
+PRECACHE_WEAPON_REGISTER( weapon_famas );
+
+
+const float kFamasBurstCycleTime = 0.075f;
+
+
+CWeaponFamas::CWeaponFamas()
+{
+	m_bBurstMode = false;
+}
+
+
+bool CWeaponFamas::Deploy( )
+{
+	m_iBurstShotsRemaining = 0;
+	m_fNextBurstShot = 0.0f;
+	m_flAccuracy = 0.9f;
+
+	return BaseClass::Deploy();
+}
+
+
+// Secondary attack could be three-round burst mode
+void CWeaponFamas::SecondaryAttack()
+{	
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( m_bBurstMode )
+	{
+		ClientPrint( pPlayer, HUD_PRINTCENTER, "#Switch_To_FullAuto" );
+		m_bBurstMode = false;
+		m_weaponMode = Primary_Mode;
+	}
+	else
+	{
+		ClientPrint( pPlayer, HUD_PRINTCENTER, "#Switch_To_BurstFire" );
+		m_bBurstMode = true;
+		m_weaponMode = Secondary_Mode;
+	}
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+}
+
+float CWeaponFamas::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		float fAutoPenalty = m_bBurstMode ? 0.0f : 0.01f;
+
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )	// if player is in air
+			return 0.03f + 0.3f * m_flAccuracy + fAutoPenalty;
+	
+		else if ( pPlayer->GetAbsVelocity().Length2D() > 140 )	// if player is moving
+			return 0.03f + 0.07f * m_flAccuracy + fAutoPenalty;
+		/* new code */
+		else
+			return 0.02f * m_flAccuracy + fAutoPenalty;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+
+void CWeaponFamas::ItemPostFrame()
+{
+	if ( m_iBurstShotsRemaining > 0 && gpGlobals->curtime >= m_fNextBurstShot )
+		FireRemaining();
+
+	BaseClass::ItemPostFrame();
+}
+
+
+
+// GOOSEMAN : FireRemaining used by Glock18
+void CWeaponFamas::FireRemaining()
+{
+	m_iClip1--;
+
+	if (m_iClip1 < 0)
+	{
+		m_iClip1 = 0;
+		m_iBurstShotsRemaining = 0;
+		m_fNextBurstShot = 0.0f;
+		return;
+	}
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		Error( "!pPlayer" );
+
+	// Famas burst mode
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		Secondary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		GetInaccuracy(),
+		GetSpread(),
+		m_fNextBurstShot);
+	
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	pPlayer->DoMuzzleFlash();
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	pPlayer->m_iShotsFired++;
+
+	--m_iBurstShotsRemaining;
+	if ( m_iBurstShotsRemaining > 0 )
+		m_fNextBurstShot += kFamasBurstCycleTime;
+	else
+		m_fNextBurstShot = 0.0f;
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[Secondary_Mode];
+}
+
+
+void CWeaponFamas::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// don't fire underwater
+	if (pPlayer->GetWaterLevel() == 3)
+	{
+		PlayEmptySound( );
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
+		return;
+	}
+
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+	// change a few things if we're in burst mode
+	if ( m_bBurstMode )
+	{
+		flCycleTime = 0.55f;
+		m_iBurstShotsRemaining = 2;
+		m_fNextBurstShot = gpGlobals->curtime + kFamasBurstCycleTime;
+	}
+
+	if ( !CSBaseGunFire( flCycleTime, m_weaponMode ) )
+		return;
+	
+	if ( pPlayer->GetAbsVelocity().Length2D() > 5 )
+		pPlayer->KickBack ( 1, 0.45, 0.275, 0.05, 4, 2.5, 7 );
+	
+	else if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack ( 1.25, 0.45, 0.22, 0.18, 5.5, 4, 5 );
+	
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack ( 0.575, 0.325, 0.2, 0.011, 3.25, 2, 8 );
+	
+	else
+		pPlayer->KickBack ( 0.625, 0.375, 0.25, 0.0125, 3.5, 2.25, 8 );
+}
+
+
diff --git a/game/shared/cstrike/weapon_fiveseven.cpp b/game/shared/cstrike/weapon_fiveseven.cpp
new file mode 100644
index 00000000..9b941919
--- /dev/null
+++ b/game/shared/cstrike/weapon_fiveseven.cpp
@@ -0,0 +1,202 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponFiveSeven C_WeaponFiveSeven
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponFiveSeven : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CWeaponFiveSeven, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponFiveSeven();
+
+	virtual void Spawn();
+
+	virtual void PrimaryAttack();
+	virtual void SecondaryAttack();
+	virtual bool Deploy();
+
+	virtual bool Reload();
+
+	virtual void WeaponIdle();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_FIVESEVEN; }
+
+private:
+	
+	CWeaponFiveSeven( const CWeaponFiveSeven & );
+	
+	float m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponFiveSeven, DT_WeaponFiveSeven )
+
+BEGIN_NETWORK_TABLE( CWeaponFiveSeven, DT_WeaponFiveSeven )
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CWeaponFiveSeven )
+	DEFINE_FIELD( m_flLastFire, FIELD_FLOAT ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_fiveseven, CWeaponFiveSeven );
+PRECACHE_WEAPON_REGISTER( weapon_fiveseven );
+
+
+
+CWeaponFiveSeven::CWeaponFiveSeven()
+{
+	m_flLastFire = gpGlobals->curtime;
+}
+
+
+void CWeaponFiveSeven::Spawn( )
+{
+	BaseClass::Spawn();
+
+	m_flAccuracy = 0.92;
+}
+
+bool CWeaponFiveSeven::Deploy()
+{
+	m_flAccuracy = 0.92;
+	return BaseClass::Deploy();
+}
+
+
+float CWeaponFiveSeven::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 1.5f * (1 - m_flAccuracy);
+		else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+			return 0.255f * (1 - m_flAccuracy);
+		else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+			return 0.075f * (1 - m_flAccuracy);
+		else
+			return 0.15f * (1 - m_flAccuracy);
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponFiveSeven::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+	m_flAccuracy -= (0.25)*(0.275 - (gpGlobals->curtime - m_flLastFire));
+
+	if (m_flAccuracy > 0.92)
+		m_flAccuracy = 0.92;
+	else if (m_flAccuracy < 0.725)
+		m_flAccuracy = 0.725;
+
+	m_flLastFire = gpGlobals->curtime;
+
+	if (m_iClip1 <= 0)
+	{
+		if ( m_bFireOnEmpty )
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.1f;
+			m_bFireOnEmpty = false;
+		}
+
+		return;
+	}
+
+	pPlayer->m_iShotsFired++;
+
+	m_iClip1--;
+	pPlayer->DoMuzzleFlash();
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		Primary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		GetInaccuracy(),
+		GetSpread()); 
+
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + GetCSWpnData().m_flCycleTime;
+
+	if (!m_iClip1 && pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0)
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+
+	SetWeaponIdleTime( gpGlobals->curtime + 2 );
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[Primary_Mode];
+
+	QAngle angle = pPlayer->GetPunchAngle();
+	angle.x -= 2;
+	pPlayer->SetPunchAngle( angle );
+}
+
+
+void CWeaponFiveSeven::SecondaryAttack() 
+{
+}
+
+
+bool CWeaponFiveSeven::Reload()
+{
+	if ( !DefaultPistolReload() )
+		return false;
+
+	m_flAccuracy = 0.92;
+	return true;
+}
+
+void CWeaponFiveSeven::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	// only idle if the slid isn't back
+	if (m_iClip1 != 0)
+	{	
+		SetWeaponIdleTime( gpGlobals->curtime + 4 );
+		SendWeaponAnim( ACT_VM_IDLE );
+	}
+}
diff --git a/game/shared/cstrike/weapon_flashbang.cpp b/game/shared/cstrike/weapon_flashbang.cpp
new file mode 100644
index 00000000..4ce1fa9c
--- /dev/null
+++ b/game/shared/cstrike/weapon_flashbang.cpp
@@ -0,0 +1,60 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "gamerules.h"
+#include "npcevent.h"
+#include "engine/IEngineSound.h"
+#include "weapon_flashbang.h"
+
+
+#ifdef CLIENT_DLL
+
+
+#else
+
+	#include "cs_player.h"
+	#include "items.h"
+	#include "flashbang_projectile.h"
+
+#endif
+
+
+#define GRENADE_TIMER	3.0f //Seconds
+
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( Flashbang, DT_Flashbang )
+
+BEGIN_NETWORK_TABLE(CFlashbang, DT_Flashbang)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CFlashbang )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_flashbang, CFlashbang );
+PRECACHE_WEAPON_REGISTER( weapon_flashbang );
+
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CFlashbang )
+	END_DATADESC()
+
+	void CFlashbang::EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer )
+	{
+		CFlashbangProjectile::Create( 
+			vecSrc,
+			vecAngles,
+			vecVel,
+			angImpulse,
+			pPlayer );
+	}
+
+#endif
+
+
diff --git a/game/shared/cstrike/weapon_flashbang.h b/game/shared/cstrike/weapon_flashbang.h
new file mode 100644
index 00000000..6f44aaef
--- /dev/null
+++ b/game/shared/cstrike/weapon_flashbang.h
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_FLASHBANG_H
+#define WEAPON_FLASHBANG_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_basecsgrenade.h"
+
+
+#ifdef CLIENT_DLL
+	#define CFlashbang C_Flashbang
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Fragmentation grenades
+//-----------------------------------------------------------------------------
+class CFlashbang : public CBaseCSGrenade
+{
+public:
+	DECLARE_CLASS( CFlashbang, CBaseCSGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CFlashbang() {}
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_FLASHBANG; }
+
+
+#ifdef CLIENT_DLL
+
+#else
+	DECLARE_DATADESC();
+
+		virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer );
+#endif
+
+	CFlashbang( const CFlashbang & ) {}
+};
+
+
+#endif // WEAPON_FLASHBANG_H
diff --git a/game/shared/cstrike/weapon_g3sg1.cpp b/game/shared/cstrike/weapon_g3sg1.cpp
new file mode 100644
index 00000000..25aeca5b
--- /dev/null
+++ b/game/shared/cstrike/weapon_g3sg1.cpp
@@ -0,0 +1,213 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponG3SG1 C_WeaponG3SG1
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+	#include "KeyValues.h"
+
+#endif
+
+
+class CWeaponG3SG1 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponG3SG1, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponG3SG1();
+
+	virtual void Spawn();
+	virtual void SecondaryAttack();
+	virtual void PrimaryAttack();
+	virtual bool Reload();
+	virtual bool Deploy();
+
+ 	virtual float GetInaccuracy() const;
+	virtual float GetMaxSpeed();
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_G3SG1; }
+
+private:
+	CWeaponG3SG1( const CWeaponG3SG1 & );
+
+	float m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponG3SG1, DT_WeaponG3SG1 )
+
+BEGIN_NETWORK_TABLE( CWeaponG3SG1, DT_WeaponG3SG1 )
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CWeaponG3SG1 )
+	DEFINE_FIELD( m_flLastFire, FIELD_FLOAT ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_g3sg1, CWeaponG3SG1 );
+PRECACHE_WEAPON_REGISTER( weapon_g3sg1 );
+
+
+
+CWeaponG3SG1::CWeaponG3SG1()
+{
+	m_flLastFire = gpGlobals->curtime;
+}
+
+void CWeaponG3SG1::Spawn()
+{
+	BaseClass::Spawn();
+	m_flAccuracy = 0.98;
+}
+
+
+void CWeaponG3SG1::SecondaryAttack()
+{
+	const float kZoomTime = 0.10f;
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( pPlayer->GetFOV() == pPlayer->GetDefaultFOV() )
+	{
+		pPlayer->SetFOV( pPlayer, 40, kZoomTime );
+		m_weaponMode = Secondary_Mode;
+		m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyAltSwitch;
+	}
+	else if (pPlayer->GetFOV() == 40)
+	{
+		pPlayer->SetFOV( pPlayer, 15, kZoomTime );
+		m_weaponMode = Secondary_Mode;
+	}
+	else if (pPlayer->GetFOV() == 15)
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), kZoomTime );
+		m_weaponMode = Primary_Mode;
+	}
+
+#ifndef CLIENT_DLL
+	// If this isn't guarded, the sound will be emitted twice, once by the server and once by the client.
+	// Let the server play it since if only the client plays it, it's liable to get played twice cause of
+	// a prediction error. joy.
+	
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Playing this from the player so that we don't try to play the sound outside the level.
+	//=============================================================================
+	if ( GetPlayerOwner() )
+	{
+		GetPlayerOwner()->EmitSound( "Default.Zoom" ); // zoom sound
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	// let the bots hear the rifle zoom
+	IGameEvent * event = gameeventmanager->CreateEvent( "weapon_zoom" );
+	if( event )
+	{
+		event->SetInt( "userid", pPlayer->GetUserID() );
+		gameeventmanager->FireEvent( event );
+	}
+#endif
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.3f;   
+	m_zoomFullyActiveTime = gpGlobals->curtime + 0.3; // The worst zoom time from above.  
+}
+
+float CWeaponG3SG1::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		float fSpread = 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			fSpread = 0.45f * (1.0f - m_flAccuracy);
+		else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+			fSpread = 0.15f;
+		else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+			fSpread = 0.035f * (1.0f - m_flAccuracy);
+		else
+			fSpread = 0.055f * (1.0f - m_flAccuracy);
+	
+		// If we are not zoomed in, or we have very recently zoomed and are still transitioning, the bullet diverts more.
+		if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV() || (gpGlobals->curtime < m_zoomFullyActiveTime))
+			fSpread += 0.025;
+	
+		return fSpread;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponG3SG1::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+	
+	// Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+	m_flAccuracy = 0.55 + (0.3) * (gpGlobals->curtime - m_flLastFire);	
+
+	if (m_flAccuracy > 0.98)
+		m_flAccuracy = 0.98;
+
+	m_flLastFire = gpGlobals->curtime;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, m_weaponMode ) )
+		return;
+
+	// Adjust the punch angle.
+	QAngle angle = pPlayer->GetPunchAngle();
+	angle.x -= SharedRandomFloat("G3SG1PunchAngleX", 0.75, 1.75 ) + ( angle.x / 4 );
+	angle.y += SharedRandomFloat("G3SG1PunchAngleY", -0.75, 0.75 );
+	pPlayer->SetPunchAngle( angle );
+}
+
+
+bool CWeaponG3SG1::Reload()
+{
+	bool ret = BaseClass::Reload();
+	
+	m_flAccuracy = 0.98;
+	m_weaponMode = Primary_Mode;
+	
+	return ret;
+}
+
+bool CWeaponG3SG1::Deploy()
+{
+	bool ret = BaseClass::Deploy();
+	
+	m_flAccuracy = 0.98;
+	m_weaponMode = Primary_Mode;
+	
+	return ret;
+}
+
+float CWeaponG3SG1::GetMaxSpeed()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( pPlayer && pPlayer->GetFOV() == pPlayer->GetDefaultFOV() )
+		return BaseClass::GetMaxSpeed();
+	else
+		return 150; // zoomed in
+}
diff --git a/game/shared/cstrike/weapon_galil.cpp b/game/shared/cstrike/weapon_galil.cpp
new file mode 100644
index 00000000..961d75a3
--- /dev/null
+++ b/game/shared/cstrike/weapon_galil.cpp
@@ -0,0 +1,114 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponGalil C_WeaponGalil
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponGalil : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponGalil, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponGalil();
+
+	virtual void PrimaryAttack();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_GALIL; }
+
+private:
+
+	CWeaponGalil( const CWeaponGalil & );
+
+	void GalilFire( float flSpread );
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGalil, DT_WeaponGalil )
+
+BEGIN_NETWORK_TABLE( CWeaponGalil, DT_WeaponGalil )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponGalil )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_galil, CWeaponGalil );
+PRECACHE_WEAPON_REGISTER( weapon_galil );
+
+
+
+CWeaponGalil::CWeaponGalil()
+{
+}
+
+float CWeaponGalil::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.04f + 0.3f * m_flAccuracy;
+		else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+			return 0.04f + 0.07f * m_flAccuracy;
+		else
+			return 0.0375f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponGalil::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// don't fire underwater
+	if (pPlayer->GetWaterLevel() == 3)
+	{
+		PlayEmptySound( );
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
+		return;
+	}
+	
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, Primary_Mode ) )
+		return;
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if (pPlayer->GetAbsVelocity().Length2D() > 5)
+		pPlayer->KickBack (1.0, 0.45, 0.28, 0.045, 3.75, 3, 7);
+	else if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack (1.2, 0.5, 0.23, 0.15, 5.5, 3.5, 6);
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack (0.6, 0.3, 0.2, 0.0125, 3.25, 2, 7);
+	else
+		pPlayer->KickBack (0.65, 0.35, 0.25, 0.015, 3.5, 2.25, 7);
+}
+
+
diff --git a/game/shared/cstrike/weapon_glock.cpp b/game/shared/cstrike/weapon_glock.cpp
new file mode 100644
index 00000000..a094a4c6
--- /dev/null
+++ b/game/shared/cstrike/weapon_glock.cpp
@@ -0,0 +1,369 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponGlock C_WeaponGlock
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponGlock : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CWeaponGlock, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponGlock();
+
+	virtual void Spawn();
+
+	virtual void PrimaryAttack();
+	virtual void SecondaryAttack();
+	virtual bool Deploy();
+
+	virtual void ItemPostFrame();
+
+	void GlockFire( float fSpread, bool bFireBurst );
+	void FireRemaining( float fSpread );
+	
+	virtual bool Reload();
+
+	virtual void WeaponIdle();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_GLOCK; }
+
+private:
+	
+	CWeaponGlock( const CWeaponGlock & );
+
+	CNetworkVar( bool, m_bBurstMode );
+	CNetworkVar( int, m_iBurstShotsRemaining );	// used to keep track of the shots fired during the Glock18 burst fire mode.
+	float	m_fNextBurstShot;					// time to shoot the next bullet in burst fire mode
+	float	m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGlock, DT_WeaponGlock )
+
+BEGIN_NETWORK_TABLE( CWeaponGlock, DT_WeaponGlock )
+	#ifdef CLIENT_DLL
+		RecvPropBool( RECVINFO( m_bBurstMode ) ),
+		RecvPropInt( RECVINFO( m_iBurstShotsRemaining ) ),
+	#else
+		SendPropBool( SENDINFO( m_bBurstMode ) ),
+		SendPropInt( SENDINFO( m_iBurstShotsRemaining ) ),
+	#endif
+END_NETWORK_TABLE()
+
+#if defined(CLIENT_DLL)
+BEGIN_PREDICTION_DATA( CWeaponGlock )
+	DEFINE_FIELD( m_flLastFire, FIELD_FLOAT ),
+	DEFINE_PRED_FIELD( m_iBurstShotsRemaining, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+ 	DEFINE_PRED_FIELD( m_fNextBurstShot, FIELD_FLOAT, 0 ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_glock, CWeaponGlock );
+PRECACHE_WEAPON_REGISTER( weapon_glock );
+
+const float kGlockBurstCycleTime = 0.06f;
+
+CWeaponGlock::CWeaponGlock()
+{
+	m_bBurstMode = false;
+	m_flLastFire = gpGlobals->curtime;
+	m_iBurstShotsRemaining = 0;
+	m_fNextBurstShot = 0.0f;
+}
+
+
+void CWeaponGlock::Spawn( )
+{
+	BaseClass::Spawn();
+
+	m_bBurstMode = false;
+	m_iBurstShotsRemaining = 0;
+	m_fNextBurstShot = 0.0f;
+	m_flAccuracy = 0.9f;
+}
+
+bool CWeaponGlock::Deploy( )
+{
+	m_iBurstShotsRemaining = 0;
+	m_fNextBurstShot = 0.0f;
+	m_flAccuracy = 0.9f;
+
+	return BaseClass::Deploy();
+}
+
+void CWeaponGlock::SecondaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( m_bBurstMode )
+	{
+		ClientPrint( pPlayer, HUD_PRINTCENTER, "#Switch_To_SemiAuto" );
+		m_bBurstMode = false;
+		m_weaponMode = Primary_Mode;
+	}
+	else
+	{
+		ClientPrint( pPlayer, HUD_PRINTCENTER, "#Switch_To_BurstFire" );
+		m_bBurstMode = true;
+		m_weaponMode = Secondary_Mode;
+	}
+	
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+}
+
+float CWeaponGlock::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( m_bBurstMode )
+		{
+			if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+				return 1.2f * (1 - m_flAccuracy);
+
+			else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+				return 0.185f * (1 - m_flAccuracy);
+
+			else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+				return 0.095f * (1 - m_flAccuracy);
+
+			else
+				return 0.3f * (1 - m_flAccuracy);
+		}
+		else
+		{
+			if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+				return 1.0f * (1 - m_flAccuracy);
+
+			else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+				return 0.165f * (1 - m_flAccuracy);
+
+			else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+				return 0.075f * (1 - m_flAccuracy);
+
+			else
+				return 0.1f * (1 - m_flAccuracy);
+		}
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+
+void CWeaponGlock::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	float flCycleTime = m_bBurstMode ? 0.5f : GetCSWpnData().m_flCycleTime;
+
+	// Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+	m_flAccuracy -= (0.275)*(0.325 - (gpGlobals->curtime - m_flLastFire));
+
+	if (m_flAccuracy > 0.9)
+		m_flAccuracy = 0.9;
+	else if (m_flAccuracy < 0.6)
+		m_flAccuracy = 0.6;
+
+	m_flLastFire = gpGlobals->curtime;
+
+	if (m_iClip1 <= 0)
+	{
+		if ( m_bFireOnEmpty )
+
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.1f;
+			m_bFireOnEmpty = false;
+		}
+
+		return;
+	}
+
+	pPlayer->m_iShotsFired++;
+
+	m_iClip1--;
+
+	pPlayer->DoMuzzleFlash();
+
+	//SetPlayerShieldAnim();
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	// non-silenced
+	//pPlayer->m_iWeaponVolume = NORMAL_GUN_VOLUME;
+	//pPlayer->m_iWeaponFlash = NORMAL_GUN_FLASH;
+
+	FX_FireBullets( 
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(), 
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(), 
+		GetWeaponID(),
+		Primary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+		GetInaccuracy(),
+		GetSpread(),
+		gpGlobals->curtime);
+
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + flCycleTime;
+
+	if (!m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0)
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+
+	SetWeaponIdleTime( gpGlobals->curtime + 2.5f );
+
+	if ( m_bBurstMode )
+	{
+		// Fire off the next two rounds
+		m_fNextBurstShot = gpGlobals->curtime + kGlockBurstCycleTime;
+		m_iBurstShotsRemaining = 2;
+
+		SendWeaponAnim( ACT_VM_SECONDARYATTACK );
+	}
+	else
+	{
+		SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	}
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[m_weaponMode];
+
+	//ResetPlayerShieldAnim();
+}
+
+
+// GOOSEMAN : FireRemaining used by Glock18
+
+void CWeaponGlock::FireRemaining( float fSpread )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		Error( "!pPlayer" );
+
+	if ( m_iBurstShotsRemaining == 0 )
+		return;
+
+	if (m_iClip1 <= 0)
+	{
+		m_iClip1 = 0;
+		m_iBurstShotsRemaining = 0;
+		m_fNextBurstShot = 0.0f;
+		return;
+	}
+	--m_iClip1;
+
+	// TODO FIXME damage = 18, rangemode 0.9
+
+	float fInaccuracy = GetInaccuracy();
+	if ( weapon_accuracy_model.GetInt() == 1 )
+		fInaccuracy = 0.05;
+	
+	FX_FireBullets( 
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(), 
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(), 
+		GetWeaponID(),
+		Secondary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+		fInaccuracy,
+		GetSpread(),
+		m_fNextBurstShot);
+	
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+	pPlayer->m_iShotsFired++;
+
+	--m_iBurstShotsRemaining;
+
+	if ( m_iBurstShotsRemaining > 0 )
+		m_fNextBurstShot += kGlockBurstCycleTime;
+	else
+		m_fNextBurstShot = 0.0;
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[Secondary_Mode];
+}
+
+
+void CWeaponGlock::ItemPostFrame()
+{
+	while ( m_iBurstShotsRemaining > 0 && gpGlobals->curtime >= m_fNextBurstShot )
+	{
+		if ( weapon_accuracy_model.GetInt() == 1 )
+			FireRemaining(0.05f);
+		else
+			FireRemaining(GetSpread());
+	}
+
+	BaseClass::ItemPostFrame();
+}
+
+
+bool CWeaponGlock::Reload()
+{
+	if ( m_iBurstShotsRemaining != 0 )
+		return true;
+
+	if ( !DefaultPistolReload() )
+		return false;
+
+	m_flAccuracy = 0.9;
+	return true;
+}
+
+void CWeaponGlock::WeaponIdle()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	if ( pPlayer->HasShield() )
+	{
+		SetWeaponIdleTime( gpGlobals->curtime + 20 );
+				
+		//MIKETODO: shields
+		//if ( FBitSet(m_iWeaponState, WPNSTATE_SHIELD_DRAWN) )
+		//	 SendWeaponAnim( GLOCK18_SHIELD_IDLE, UseDecrement() ? 1:0 );
+	}
+	else
+	{
+		// only idle if the slid isn't back
+		if (m_iClip1 != 0)
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+		}
+	}
+}
diff --git a/game/shared/cstrike/weapon_hegrenade.cpp b/game/shared/cstrike/weapon_hegrenade.cpp
new file mode 100644
index 00000000..e8303d09
--- /dev/null
+++ b/game/shared/cstrike/weapon_hegrenade.cpp
@@ -0,0 +1,67 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "gamerules.h"
+#include "npcevent.h"
+#include "engine/IEngineSound.h"
+#include "weapon_hegrenade.h"
+
+
+#ifdef CLIENT_DLL
+	
+#else
+
+	#include "cs_player.h"
+	#include "items.h"
+	#include "hegrenade_projectile.h"
+
+#endif
+
+
+#define GRENADE_TIMER	3.0f //Seconds
+
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( HEGrenade, DT_HEGrenade )
+
+BEGIN_NETWORK_TABLE(CHEGrenade, DT_HEGrenade)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CHEGrenade )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_hegrenade, CHEGrenade );
+PRECACHE_WEAPON_REGISTER( weapon_hegrenade );
+
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CHEGrenade )
+	END_DATADESC()
+
+	void CHEGrenade::EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer )
+	{
+		//=============================================================================
+		// HPE_BEGIN:
+		// [Forrest] Start a new bullet group so that damage dealt by the grenade will be counted as a separate hit from damage previously dealt.
+		//=============================================================================
+#ifdef GAME_DLL
+		CCSPlayer *pCSPlayer = ToCSPlayer( pPlayer );
+		if ( pCSPlayer )
+		{
+			pCSPlayer->StartNewBulletGroup();
+		}
+#endif
+		//=============================================================================
+		// HPE_END
+		//=============================================================================
+		CHEGrenadeProjectile::Create( vecSrc, vecAngles, vecVel, angImpulse, pPlayer, GRENADE_TIMER );
+	}
+	
+#endif
+
diff --git a/game/shared/cstrike/weapon_hegrenade.h b/game/shared/cstrike/weapon_hegrenade.h
new file mode 100644
index 00000000..20e2d990
--- /dev/null
+++ b/game/shared/cstrike/weapon_hegrenade.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_HEGRENADE_H
+#define WEAPON_HEGRENADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_basecsgrenade.h"
+
+
+#ifdef CLIENT_DLL
+	
+	#define CHEGrenade C_HEGrenade
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Fragmentation grenades
+//-----------------------------------------------------------------------------
+class CHEGrenade : public CBaseCSGrenade
+{
+public:
+	DECLARE_CLASS( CHEGrenade, CBaseCSGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CHEGrenade() {}
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_HEGRENADE; }
+
+#ifdef CLIENT_DLL
+
+#else
+	DECLARE_DATADESC();
+
+	virtual void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer );
+	
+#endif
+
+	CHEGrenade( const CHEGrenade & ) {}
+};
+
+
+#endif // WEAPON_HEGRENADE_H
diff --git a/game/shared/cstrike/weapon_knife.cpp b/game/shared/cstrike/weapon_knife.cpp
new file mode 100644
index 00000000..9bc549b9
--- /dev/null
+++ b/game/shared/cstrike/weapon_knife.cpp
@@ -0,0 +1,517 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_knife.h"
+#include "cs_gamerules.h"
+
+#if defined( CLIENT_DLL )
+	#include "c_cs_player.h"
+#else
+	#include "cs_player.h"
+	#include "ilagcompensationmanager.h"
+	#include "cs_gamestats.h"
+#endif
+
+
+#define	KNIFE_BODYHIT_VOLUME 128
+#define	KNIFE_WALLHIT_VOLUME 512
+
+
+Vector head_hull_mins( -16, -16, -18 );
+Vector head_hull_maxs( 16, 16, 18 );
+
+#ifndef CLIENT_DLL
+	//-----------------------------------------------------------------------------
+	// Purpose: Only send to local player if this weapon is the active weapon
+	// Input  : *pStruct - 
+	//			*pVarData - 
+	//			*pRecipients - 
+	//			objectID - 
+	// Output : void*
+	//-----------------------------------------------------------------------------
+	void* SendProxy_SendActiveLocalKnifeDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
+	{
+		// Get the weapon entity
+		CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pVarData;
+		if ( pWeapon )
+		{
+			// Only send this chunk of data to the player carrying this weapon
+			CBasePlayer *pPlayer = ToBasePlayer( pWeapon->GetOwner() );
+			if ( pPlayer /*&& pPlayer->GetActiveWeapon() == pWeapon*/ )
+			{
+				pRecipients->SetOnly( pPlayer->GetClientIndex() );
+				return (void*)pVarData;
+			}
+		}
+		
+		return NULL;
+	}
+	REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendActiveLocalKnifeDataTable );
+#endif
+
+// ----------------------------------------------------------------------------- //
+// CKnife tables.
+// ----------------------------------------------------------------------------- //
+
+IMPLEMENT_NETWORKCLASS_ALIASED( Knife, DT_WeaponKnife )
+
+BEGIN_NETWORK_TABLE_NOBASE( CKnife, DT_LocalActiveWeaponKnifeData )
+	#if !defined( CLIENT_DLL )
+		SendPropTime( SENDINFO( m_flSmackTime ) ),
+	#else
+		RecvPropTime( RECVINFO( m_flSmackTime ) ),
+	#endif
+END_NETWORK_TABLE()
+
+
+BEGIN_NETWORK_TABLE( CKnife, DT_WeaponKnife )
+	#if !defined( CLIENT_DLL )
+		SendPropDataTable("LocalActiveWeaponKnifeData", 0, &REFERENCE_SEND_TABLE(DT_LocalActiveWeaponKnifeData), SendProxy_SendActiveLocalKnifeDataTable ),
+	#else
+		RecvPropDataTable("LocalActiveWeaponKnifeData", 0, 0, &REFERENCE_RECV_TABLE(DT_LocalActiveWeaponKnifeData)),
+	#endif
+END_NETWORK_TABLE()
+
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CKnife )
+	DEFINE_PRED_FIELD( m_flSmackTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+#endif
+
+
+LINK_ENTITY_TO_CLASS( weapon_knife, CKnife );
+PRECACHE_WEAPON_REGISTER( weapon_knife );
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CKnife )
+		DEFINE_THINKFUNC( Smack )
+	END_DATADESC()
+
+#endif
+
+// ----------------------------------------------------------------------------- //
+// CKnife implementation.
+// ----------------------------------------------------------------------------- //
+
+CKnife::CKnife()
+{
+}
+
+
+bool CKnife::HasPrimaryAmmo()
+{
+	return true;
+}
+
+
+bool CKnife::CanBeSelected()
+{
+	return true;
+}
+
+void CKnife::Precache()
+{
+	BaseClass::Precache();
+
+	PrecacheScriptSound( "Weapon_Knife.Deploy" );
+	PrecacheScriptSound( "Weapon_Knife.Slash" );
+	PrecacheScriptSound( "Weapon_Knife.Stab" );
+	PrecacheScriptSound( "Weapon_Knife.Hit" );
+}
+
+void CKnife::Spawn()
+{
+	Precache();
+
+	m_iClip1 = -1;
+	BaseClass::Spawn();
+}
+
+
+bool CKnife::Deploy()
+{
+	CPASAttenuationFilter filter( this );
+	filter.UsePredictionRules();
+	EmitSound( filter, entindex(), "Weapon_Knife.Deploy" );
+
+	return BaseClass::Deploy();
+}
+
+void CKnife::Holster( int skiplocal )
+{
+	if ( GetPlayerOwner() )
+	{
+		GetPlayerOwner()->m_flNextAttack = gpGlobals->curtime + 0.5;
+	}
+}
+
+void CKnife::WeaponAnimation ( int iAnimation )
+{
+	/*
+	int flag;
+	#if defined( CLIENT_WEAPONS )
+		flag = FEV_NOTHOST;
+	#else
+		flag = 0;
+	#endif
+
+	PLAYBACK_EVENT_FULL( flag, pPlayer->edict(), m_usKnife,
+		0.0, (float *)&g_vecZero, (float *)&g_vecZero, 
+		0.0,
+		0.0,
+		iAnimation, 2, 3, 4 );
+	*/
+}
+
+void FindHullIntersection( const Vector &vecSrc, trace_t &tr, const Vector &mins, const Vector &maxs, CBaseEntity *pEntity )
+{
+	int			i, j, k;
+	float		distance;
+	Vector minmaxs[2] = {mins, maxs};
+	trace_t tmpTrace;
+	Vector		vecHullEnd = tr.endpos;
+	Vector		vecEnd;
+
+	distance = 1e6f;
+
+	vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
+	UTIL_TraceLine( vecSrc, vecHullEnd, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tmpTrace );
+	if ( tmpTrace.fraction < 1.0 )
+	{
+		tr = tmpTrace;
+		return;
+	}
+
+	for ( i = 0; i < 2; i++ )
+	{
+		for ( j = 0; j < 2; j++ )
+		{
+			for ( k = 0; k < 2; k++ )
+			{
+				vecEnd.x = vecHullEnd.x + minmaxs[i][0];
+				vecEnd.y = vecHullEnd.y + minmaxs[j][1];
+				vecEnd.z = vecHullEnd.z + minmaxs[k][2];
+
+				UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, pEntity, COLLISION_GROUP_NONE, &tmpTrace );
+				if ( tmpTrace.fraction < 1.0 )
+				{
+					float thisDistance = (tmpTrace.endpos - vecSrc).Length();
+					if ( thisDistance < distance )
+					{
+						tr = tmpTrace;
+						distance = thisDistance;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+void CKnife::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( pPlayer )
+	{
+#if !defined (CLIENT_DLL)
+		// Move other players back to history positions based on local player's lag
+		lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
+#endif
+		SwingOrStab( false );
+#if !defined (CLIENT_DLL)
+		lagcompensation->FinishLagCompensation( pPlayer );
+#endif
+	}
+}
+
+void CKnife::SecondaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( pPlayer && !pPlayer->m_bIsDefusing && !CSGameRules()->IsFreezePeriod() )
+	{
+#if !defined (CLIENT_DLL)
+		// Move other players back to history positions based on local player's lag
+		lagcompensation->StartLagCompensation( pPlayer, pPlayer->GetCurrentCommand() );
+#endif
+		SwingOrStab( true );
+#if !defined (CLIENT_DLL)
+		lagcompensation->FinishLagCompensation( pPlayer );
+#endif
+	}
+}
+
+#include "effect_dispatch_data.h"
+
+void CKnife::Smack( void )
+{
+	if ( !GetPlayerOwner() )
+		return;
+
+	m_trHit.m_pEnt = m_pTraceHitEnt;
+
+	if ( !m_trHit.m_pEnt || (m_trHit.surface.flags & SURF_SKY) )
+		return;
+
+	if ( m_trHit.fraction == 1.0 )
+		return;
+
+	if ( m_trHit.m_pEnt )
+	{
+		CPASAttenuationFilter filter( this );
+		filter.UsePredictionRules();
+
+		if( m_trHit.m_pEnt->IsPlayer()  )
+		{
+			EmitSound( filter, entindex(), m_bStab?"Weapon_Knife.Stab":"Weapon_Knife.Hit" );
+		}
+		else
+		{
+			EmitSound( filter, entindex(), "Weapon_Knife.HitWall" );
+		}
+	}
+
+	CEffectData data;
+	data.m_vOrigin = m_trHit.endpos;
+	data.m_vStart = m_trHit.startpos;
+	data.m_nSurfaceProp = m_trHit.surface.surfaceProps;
+	data.m_nDamageType = DMG_SLASH;
+	data.m_nHitBox = m_trHit.hitbox;
+#ifdef CLIENT_DLL
+	data.m_hEntity = m_trHit.m_pEnt->GetRefEHandle();
+#else
+	data.m_nEntIndex = m_trHit.m_pEnt->entindex();
+#endif
+
+	CPASFilter filter( data.m_vOrigin );
+	
+#ifndef CLIENT_DLL
+	filter.RemoveRecipient( GetPlayerOwner() );
+#endif
+
+	data.m_vAngles = GetPlayerOwner()->GetAbsAngles();
+	data.m_fFlags = 0x1;	//IMPACT_NODECAL;
+	te->DispatchEffect( filter, 0.0, data.m_vOrigin, "KnifeSlash", data );
+}
+
+void CKnife::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( pPlayer->IsShieldDrawn() )
+		 return;
+
+	SetWeaponIdleTime( gpGlobals->curtime + 20 );
+
+	// only idle if the slid isn't back
+	SendWeaponAnim( ACT_VM_IDLE );
+}
+
+//=============================================================================
+// HPE_BEGIN:
+// [tj] Hacky cheat code to control knife damage
+//=============================================================================
+#ifndef CLIENT_DLL
+	ConVar KnifeDamageScale("knife_damage_scale", "100", FCVAR_DEVELOPMENTONLY);
+#endif
+
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+bool CKnife::SwingOrStab( bool bStab )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	float fRange = bStab ? 32 : 48; // knife range
+	
+	Vector vForward; AngleVectors( pPlayer->EyeAngles(), &vForward );
+	Vector vecSrc	= pPlayer->Weapon_ShootPosition();
+	Vector vecEnd	= vecSrc + vForward * fRange;
+
+	trace_t tr;
+	UTIL_TraceLine( vecSrc, vecEnd, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
+
+	//check for hitting glass - TODO - fix this hackiness, doesn't always line up with what FindHullIntersection returns
+#ifndef CLIENT_DLL
+	CTakeDamageInfo glassDamage( pPlayer, pPlayer, 42.0f, DMG_BULLET | DMG_NEVERGIB );
+	TraceAttackToTriggers( glassDamage, tr.startpos, tr.endpos, vForward );
+#endif
+
+	if ( tr.fraction >= 1.0 )
+	{
+		UTIL_TraceHull( vecSrc, vecEnd, head_hull_mins, head_hull_maxs, MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
+		if ( tr.fraction < 1.0 )
+		{
+			// Calculate the point of intersection of the line (or hull) and the object we hit
+			// This is and approximation of the "best" intersection
+			CBaseEntity *pHit = tr.m_pEnt;
+			if ( !pHit || pHit->IsBSPModel() )
+				FindHullIntersection( vecSrc, tr, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, pPlayer );
+			vecEnd = tr.endpos;	// This is the point on the actual surface (the hull could have hit space)
+		}
+	}
+
+	bool bDidHit = tr.fraction < 1.0f;
+
+#ifndef CLIENT_DLL
+	bool bFirstSwing = (m_flNextPrimaryAttack + 0.4) < gpGlobals->curtime;
+#endif
+
+	float fPrimDelay, fSecDelay;
+
+	if ( bStab )
+	{
+		SendWeaponAnim( bDidHit ? ACT_VM_HITCENTER : ACT_VM_MISSCENTER );
+
+		fPrimDelay = fSecDelay = bDidHit ? 1.1f : 1.0f;
+
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN_PRIMARY );
+	}
+	else // swing
+	{
+		SendWeaponAnim( bDidHit ? ACT_VM_HITCENTER : ACT_VM_MISSCENTER );
+
+		fPrimDelay = bDidHit ? 0.5f : 0.4f;
+		fSecDelay = bDidHit ? 0.5f : 0.5f;
+
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_FIRE_GUN_SECONDARY );
+	}
+
+	if ( pPlayer->HasShield() )
+	{
+		fPrimDelay += 0.7f; // 0.7 seconds slower if we carry a shield
+		fSecDelay += 0.7f;
+	}
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + fPrimDelay;
+	m_flNextSecondaryAttack = gpGlobals->curtime + fSecDelay;
+	SetWeaponIdleTime( gpGlobals->curtime + 2 );
+	
+	if ( !bDidHit )
+	{
+		// play wiff or swish sound
+		CPASAttenuationFilter filter( this );
+		filter.UsePredictionRules();
+		EmitSound( filter, entindex(), "Weapon_Knife.Slash" );
+	}
+
+#ifndef CLIENT_DLL
+
+	float flDamage = 0.0f;
+	if ( bDidHit )
+	{
+		// play thwack, smack, or dong sound
+
+		CBaseEntity *pEntity = tr.m_pEnt;
+				
+		// player "shoot" animation
+		pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+		ClearMultiDamage();
+		
+		flDamage = 42.0f;
+
+		if ( bStab )
+		{
+			flDamage = 65.0f;
+
+			if ( pEntity && pEntity->IsPlayer() )
+			{
+				Vector vTragetForward;
+
+				AngleVectors( pEntity->GetAbsAngles(), &vTragetForward );
+				
+				Vector2D vecLOS = (pEntity->GetAbsOrigin() - pPlayer->GetAbsOrigin()).AsVector2D();
+				Vector2DNormalize( vecLOS );
+
+				float flDot = vecLOS.Dot( vTragetForward.AsVector2D() );
+
+				//Triple the damage if we are stabbing them in the back.
+				if ( flDot > 0.80f )
+					 flDamage *= 3;
+			}
+		}
+		else
+		{
+			if ( bFirstSwing )
+			{
+				// first swing does full damage
+				flDamage = 20;
+			}
+			else
+			{
+				// subsequent swings do less	
+				flDamage = 15;
+			}
+		}
+
+        //=============================================================================
+        // HPE_BEGIN:
+        // [tj] Hacky cheat to lower knife damage for testing
+        //=============================================================================
+         
+        flDamage *= (KnifeDamageScale.GetInt() / 100.0f);
+         
+        //=============================================================================
+        // HPE_END
+        //=============================================================================
+        
+
+		CTakeDamageInfo info( pPlayer, pPlayer, flDamage, DMG_BULLET | DMG_NEVERGIB );
+
+		CalculateMeleeDamageForce( &info, vForward, tr.endpos, 1.0f/flDamage );
+		pEntity->DispatchTraceAttack( info, vForward, &tr ); 
+		ApplyMultiDamage();
+	}
+
+	CCS_GameStats.Event_KnifeUse( pPlayer, bStab, flDamage );
+
+#endif
+
+	if ( bDidHit )
+	{
+		// delay the decal a bit
+		m_trHit = tr;
+		
+		// Store the ent in an EHANDLE, just in case it goes away by the time we get into our think function.
+		m_pTraceHitEnt = tr.m_pEnt; 
+
+		m_bStab = bStab;	//store this so we know what hit sound to play
+
+		m_flSmackTime = gpGlobals->curtime + (bStab?0.2f:0.1f);
+	}
+
+	return bDidHit;
+}
+
+void CKnife::ItemPostFrame( void )
+{
+	if( m_flSmackTime > 0 && gpGlobals->curtime > m_flSmackTime )
+	{
+		Smack();
+		m_flSmackTime = -1;
+	}
+
+	BaseClass::ItemPostFrame();
+}
+
+bool CKnife::CanDrop()
+{
+	return false;
+}
+
+
diff --git a/game/shared/cstrike/weapon_knife.h b/game/shared/cstrike/weapon_knife.h
new file mode 100644
index 00000000..f7bf851e
--- /dev/null
+++ b/game/shared/cstrike/weapon_knife.h
@@ -0,0 +1,81 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef WEAPON_KNIFE_H
+#define WEAPON_KNIFE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_csbase.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CKnife C_Knife
+
+#endif
+
+
+// ----------------------------------------------------------------------------- //
+// CKnife class definition.
+// ----------------------------------------------------------------------------- //
+
+class CKnife : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CKnife, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	#ifndef CLIENT_DLL
+		DECLARE_DATADESC();
+	#endif
+
+	
+	CKnife();
+
+	// We say yes to this so the weapon system lets us switch to it.
+	virtual bool HasPrimaryAmmo();
+	virtual bool CanBeSelected();
+	
+	virtual void Precache();
+
+	void Spawn();
+	void Smack();
+	//void Smack( trace_t *pTr, float delay );
+	bool SwingOrStab( bool bStab );
+	void PrimaryAttack();
+	void SecondaryAttack();
+	void WeaponAnimation( int iAnimation );
+
+	virtual void ItemPostFrame( void );
+
+// 	virtual float GetSpread() const;
+
+	bool Deploy();
+	void Holster( int skiplocal = 0 );
+	bool CanDrop();
+
+	void WeaponIdle();
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_KNIFE; }
+
+public:
+	
+	trace_t m_trHit;
+	EHANDLE m_pTraceHitEnt;
+
+	CNetworkVar( float, m_flSmackTime );
+	bool	m_bStab;
+
+private:
+	CKnife( const CKnife & ) {}
+};
+
+
+#endif // WEAPON_KNIFE_H
diff --git a/game/shared/cstrike/weapon_m249.cpp b/game/shared/cstrike/weapon_m249.cpp
new file mode 100644
index 00000000..90ee8032
--- /dev/null
+++ b/game/shared/cstrike/weapon_m249.cpp
@@ -0,0 +1,105 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponM249 C_WeaponM249
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponM249 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponM249, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponM249();
+
+	virtual void PrimaryAttack();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_M249; }
+
+
+private:
+	CWeaponM249( const CWeaponM249 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponM249, DT_WeaponM249 )
+
+BEGIN_NETWORK_TABLE( CWeaponM249, DT_WeaponM249 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponM249 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_m249, CWeaponM249 );
+PRECACHE_WEAPON_REGISTER( weapon_m249 );
+
+
+
+CWeaponM249::CWeaponM249()
+{
+}
+
+float CWeaponM249::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.045f + 0.5f * m_flAccuracy;
+		else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+			return 0.045f + 0.095f * m_flAccuracy;
+		else
+			return 0.03f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponM249::PrimaryAttack( void )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, Primary_Mode ) )
+		return;
+	
+	pPlayer = GetPlayerOwner();
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	if ( !pPlayer )
+		return;
+
+	if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack (1.8, 0.65, 0.45, 0.125, 5, 3.5, 8);
+	
+	else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+		pPlayer->KickBack (1.1, 0.5, 0.3, 0.06, 4, 3, 8);
+	
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack (0.75, 0.325, 0.25, 0.025, 3.5, 2.5, 9);
+	
+	else
+		pPlayer->KickBack (0.8, 0.35, 0.3, 0.03, 3.75, 3, 9);
+}
diff --git a/game/shared/cstrike/weapon_m3.cpp b/game/shared/cstrike/weapon_m3.cpp
new file mode 100644
index 00000000..d31cc16e
--- /dev/null
+++ b/game/shared/cstrike/weapon_m3.cpp
@@ -0,0 +1,293 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponM3 C_WeaponM3
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+	#include "te_shotgun_shot.h"
+
+#endif
+
+
+class CWeaponM3 : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CWeaponM3, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponM3();
+
+	virtual void PrimaryAttack();
+	virtual bool Reload();
+	virtual void WeaponIdle();
+
+ 	virtual float GetInaccuracy() const;
+	virtual float GetSpread() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_M3; }
+
+private:
+
+	CWeaponM3( const CWeaponM3 & );
+
+	float m_flPumpTime;
+	CNetworkVar( int, m_reloadState );
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponM3, DT_WeaponM3 )
+
+BEGIN_NETWORK_TABLE( CWeaponM3, DT_WeaponM3 )
+#ifdef CLIENT_DLL
+	RecvPropInt( RECVINFO( m_reloadState ) )
+#else
+	SendPropInt( SENDINFO( m_reloadState ), 2, SPROP_UNSIGNED )
+#endif
+END_NETWORK_TABLE()
+
+#if defined(CLIENT_DLL)
+BEGIN_PREDICTION_DATA( CWeaponM3 )
+DEFINE_PRED_FIELD( m_reloadState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_m3, CWeaponM3 );
+PRECACHE_WEAPON_REGISTER( weapon_m3 );
+
+
+
+CWeaponM3::CWeaponM3()
+{
+	m_flPumpTime = 0;
+	m_reloadState = 0;
+}
+
+float CWeaponM3::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		return 0.0f;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+float CWeaponM3::GetSpread() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+		return 0.0675f;
+
+	return GetCSWpnData().m_fSpread[Primary_Mode];
+}
+
+void CWeaponM3::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+	// don't fire underwater
+	if (pPlayer->GetWaterLevel() == 3)
+	{
+		PlayEmptySound( );
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
+		return;
+	}
+
+	// Out of ammo?
+	if ( m_iClip1 <= 0 )
+	{
+		Reload();
+		if ( m_iClip1 == 0 )
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+		}
+
+		return;
+	}
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	m_iClip1--;
+	pPlayer->DoMuzzleFlash();
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	// Dispatch the FX right away with full accuracy.
+	float flCurAttack = CalculateNextAttackTime( flCycleTime );
+	FX_FireBullets( 
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(), 
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(), 
+		GetWeaponID(),
+		Primary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+		GetInaccuracy(),
+		GetSpread(),
+		flCurAttack );
+
+	if (!m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0)
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+
+	if (m_iClip1 != 0)
+		m_flPumpTime = gpGlobals->curtime + 0.5;
+
+	if (m_iClip1 != 0)
+		SetWeaponIdleTime( gpGlobals->curtime + 2.5 );
+	else
+		SetWeaponIdleTime( gpGlobals->curtime + 0.875 );
+	m_reloadState = 0;
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[Primary_Mode];
+
+	// Update punch angles.
+	QAngle angle = pPlayer->GetPunchAngle();
+
+	if ( pPlayer->GetFlags() & FL_ONGROUND )
+	{
+		angle.x -= SharedRandomInt( "M3PunchAngleGround", 4, 6 );
+	}
+	else
+	{
+		angle.x -= SharedRandomInt( "M3PunchAngleAir", 8, 11 );
+	}
+
+	pPlayer->SetPunchAngle( angle );
+}
+
+
+bool CWeaponM3::Reload()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if (pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 || m_iClip1 == GetMaxClip1())
+		return true;
+
+	// don't reload until recoil is done
+	if (m_flNextPrimaryAttack > gpGlobals->curtime)
+		return true;
+		
+	// check to see if we're ready to reload
+	if (m_reloadState == 0)
+	{
+		pPlayer->SetAnimation( PLAYER_RELOAD );
+
+		SendWeaponAnim( ACT_SHOTGUN_RELOAD_START );
+		m_reloadState = 1;
+		pPlayer->m_flNextAttack = gpGlobals->curtime + 0.5;
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+		m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+		SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
+
+#ifdef GAME_DLL
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_START );
+#endif
+
+		return true;
+	}
+	else if (m_reloadState == 1)
+	{
+		if (m_flTimeWeaponIdle > gpGlobals->curtime)
+			return true;
+		// was waiting for gun to move to side
+		m_reloadState = 2;
+
+		SendWeaponAnim( ACT_VM_RELOAD );
+		SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
+#ifdef GAME_DLL
+		if ( m_iClip1 == 7 )
+		{
+			pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_END );
+		}
+		else
+		{
+			pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_LOOP );
+		}
+#endif
+	}
+	else
+	{
+		// Add them to the clip
+		m_iClip1 += 1;
+		
+#ifdef GAME_DLL
+		SendReloadEvents();
+#endif
+		
+		CCSPlayer *pPlayer = GetPlayerOwner();
+
+		if ( pPlayer )
+			 pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+
+		m_reloadState = 1;
+	}
+
+	return true;
+}
+
+
+void CWeaponM3::WeaponIdle()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if (m_flPumpTime && m_flPumpTime < gpGlobals->curtime)
+	{
+		// play pumping sound
+		m_flPumpTime = 0;
+	}
+
+	if (m_flTimeWeaponIdle < gpGlobals->curtime)
+	{
+		if (m_iClip1 == 0 && m_reloadState == 0 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ))
+		{
+			Reload( );
+		}
+		else if (m_reloadState != 0)
+		{
+			if (m_iClip1 != 8 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ))
+			{
+				Reload( );
+			}
+			else
+			{
+				// reload debounce has timed out
+				//MIKETODO: shotgun anims
+				SendWeaponAnim( ACT_SHOTGUN_RELOAD_FINISH );
+				
+				// play cocking sound
+				m_reloadState = 0;
+				SetWeaponIdleTime( gpGlobals->curtime + 1.5 );
+			}
+		}
+		else
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+		}
+	}
+}
diff --git a/game/shared/cstrike/weapon_m4a1.cpp b/game/shared/cstrike/weapon_m4a1.cpp
new file mode 100644
index 00000000..e6ad1aaf
--- /dev/null
+++ b/game/shared/cstrike/weapon_m4a1.cpp
@@ -0,0 +1,351 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponM4A1 C_WeaponM4A1
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponM4A1 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponM4A1, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+	
+	CWeaponM4A1();
+
+	virtual void Spawn();
+	virtual void Precache();
+
+	virtual void SecondaryAttack();
+	virtual void PrimaryAttack();
+	virtual bool Deploy();
+	virtual bool Reload();
+	virtual void WeaponIdle();
+	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void Drop( const Vector &vecVelocity );
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_M4A1; }
+
+	// return true if this weapon has a silencer equipped
+	virtual bool IsSilenced( void ) const				{ return m_bSilencerOn; }
+
+	virtual Activity GetDeployActivity( void );
+
+#ifdef CLIENT_DLL
+	virtual int GetMuzzleFlashStyle( void );
+#endif
+
+	virtual const char		*GetWorldModel( void ) const;
+	virtual int				GetWorldModelIndex( void );
+
+private:
+
+	CWeaponM4A1( const CWeaponM4A1 & );
+
+	void DoFireEffects();
+
+	CNetworkVar( bool, m_bSilencerOn );
+	CNetworkVar( float, m_flDoneSwitchingSilencer );	// soonest time switching the silencer will be complete
+
+	int m_silencedModelIndex;
+	bool m_inPrecache;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponM4A1, DT_WeaponM4A1 )
+
+BEGIN_NETWORK_TABLE( CWeaponM4A1, DT_WeaponM4A1 )
+	#ifdef CLIENT_DLL
+		RecvPropBool( RECVINFO( m_bSilencerOn ) ),
+		RecvPropTime( RECVINFO( m_flDoneSwitchingSilencer ) ),
+	#else
+		SendPropBool( SENDINFO( m_bSilencerOn ) ),
+		SendPropTime( SENDINFO( m_flDoneSwitchingSilencer ) ),
+	#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponM4A1 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_m4a1, CWeaponM4A1 );
+PRECACHE_WEAPON_REGISTER( weapon_m4a1 );
+
+
+
+CWeaponM4A1::CWeaponM4A1()
+{
+	m_bSilencerOn = false;
+	m_flDoneSwitchingSilencer = 0.0f;
+	m_inPrecache = false;
+}
+
+
+void CWeaponM4A1::Spawn( )
+{
+	BaseClass::Spawn();
+
+	m_bSilencerOn = false;
+	m_weaponMode = Primary_Mode;
+	m_flDoneSwitchingSilencer = 0.0f;
+	m_bDelayFire = true;
+}
+
+
+void CWeaponM4A1::Precache()
+{
+	m_inPrecache = true;
+	BaseClass::Precache();
+
+	m_silencedModelIndex = CBaseEntity::PrecacheModel( GetCSWpnData().m_szSilencerModel );
+	m_inPrecache = false;
+}
+
+
+int CWeaponM4A1::GetWorldModelIndex( void )
+{
+	if ( !m_bSilencerOn || m_inPrecache )
+	{
+		return m_iWorldModelIndex;
+	}
+	else
+	{
+		return m_silencedModelIndex;
+	}
+}
+
+
+const char * CWeaponM4A1::GetWorldModel( void ) const
+{
+	if ( !m_bSilencerOn || m_inPrecache )
+	{
+		return BaseClass::GetWorldModel();
+	}
+	else
+	{
+		return GetCSWpnData().m_szSilencerModel;
+	}
+}
+
+
+bool CWeaponM4A1::Deploy()
+{
+	bool ret = BaseClass::Deploy();
+
+	m_flDoneSwitchingSilencer = 0.0f;
+	m_bDelayFire = true;
+
+	return ret;
+}
+
+Activity CWeaponM4A1::GetDeployActivity( void )
+{
+	if( IsSilenced() )
+	{
+		return ACT_VM_DRAW_SILENCED;
+	}
+	else
+	{
+		return ACT_VM_DRAW;
+	}
+}
+
+bool CWeaponM4A1::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	if ( gpGlobals->curtime < m_flDoneSwitchingSilencer )
+	{
+		// still switching the silencer.  Cancel the switch.
+		m_bSilencerOn = !m_bSilencerOn;
+		m_weaponMode = m_bSilencerOn ? Secondary_Mode : Primary_Mode;
+		SetWeaponModelIndex( GetWorldModel() );
+	}
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+void CWeaponM4A1::Drop( const Vector &vecVelocity )
+{
+	if ( gpGlobals->curtime < m_flDoneSwitchingSilencer )
+	{
+		// still switching the silencer.  Cancel the switch.
+		m_bSilencerOn = !m_bSilencerOn;
+		m_weaponMode = m_bSilencerOn ? Secondary_Mode : Primary_Mode;
+		SetWeaponModelIndex( GetWorldModel() );
+	}
+
+	BaseClass::Drop( vecVelocity );
+}
+
+void CWeaponM4A1::SecondaryAttack()
+{
+	if ( m_bSilencerOn )
+	{
+		m_bSilencerOn = false;
+		m_weaponMode = Primary_Mode;
+		SendWeaponAnim( ACT_VM_DETACH_SILENCER );
+	}
+	else
+	{
+		m_bSilencerOn = true;
+		m_weaponMode = Secondary_Mode;
+		SendWeaponAnim( ACT_VM_ATTACH_SILENCER );
+	}
+	m_flDoneSwitchingSilencer = gpGlobals->curtime + 2;
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 2;
+	m_flNextPrimaryAttack = gpGlobals->curtime + 2;
+	SetWeaponIdleTime( gpGlobals->curtime + 2 );
+
+	SetWeaponModelIndex( GetWorldModel() );
+}
+
+float CWeaponM4A1::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		{
+			return 0.035f + 0.4f * m_flAccuracy;
+		}
+		else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+		{
+			return 0.035f + 0.07f * m_flAccuracy;
+		}
+		else
+		{
+			if ( m_bSilencerOn )
+				return 0.025f * m_flAccuracy;
+			else
+				return 0.02f * m_flAccuracy;
+		}
+	}
+	else
+	{
+		return BaseClass::GetInaccuracy();
+	}
+}
+
+
+void CWeaponM4A1::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, m_weaponMode ) )
+		return;
+
+	if ( m_bSilencerOn )
+		 SendWeaponAnim( ACT_VM_PRIMARYATTACK_SILENCED );
+
+	pPlayer = GetPlayerOwner();
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	if ( !pPlayer )
+		return;
+
+	if (pPlayer->GetAbsVelocity().Length2D() > 5)
+		pPlayer->KickBack (1.0, 0.45, 0.28, 0.045, 3.75, 3, 7);
+	else if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack (1.2, 0.5, 0.23, 0.15, 5.5, 3.5, 6);
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack (0.6, 0.3, 0.2, 0.0125, 3.25, 2, 7);
+	else
+		pPlayer->KickBack (0.65, 0.35, 0.25, 0.015, 3.5, 2.25, 7);
+}
+
+
+void CWeaponM4A1::DoFireEffects()
+{
+	if ( !m_bSilencerOn )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( pPlayer )
+		{
+			pPlayer->DoMuzzleFlash();
+		}
+	}
+}
+
+bool CWeaponM4A1::Reload()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if (pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0)
+		return false;
+
+	int iResult = 0;
+	
+	if ( m_bSilencerOn )
+		 iResult = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD_SILENCED );
+	else
+		 iResult = DefaultReload( GetMaxClip1(), GetMaxClip2(), ACT_VM_RELOAD );
+
+	if ( !iResult )
+		return false;
+
+	pPlayer->SetAnimation( PLAYER_RELOAD );
+
+	if ((iResult) && (pPlayer->GetFOV() != pPlayer->GetDefaultFOV()))
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV() );
+	}
+
+	m_flAccuracy = 0.2;
+	pPlayer->m_iShotsFired = 0;
+	m_bDelayFire = false;
+	return true;
+}
+
+
+void CWeaponM4A1::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	// only idle if the slid isn't back
+	if ( m_iClip1 != 0 )
+	{
+		SetWeaponIdleTime( gpGlobals->curtime + GetCSWpnData().m_flIdleInterval );
+		if ( m_bSilencerOn )
+			SendWeaponAnim( ACT_VM_IDLE_SILENCED );
+		else
+			SendWeaponAnim( ACT_VM_IDLE );
+	}
+}
+
+
+#ifdef CLIENT_DLL
+int CWeaponM4A1::GetMuzzleFlashStyle( void )
+{
+	if( m_bSilencerOn )
+	{
+		return CS_MUZZLEFLASH_NONE;
+	}
+	else
+	{
+		return CS_MUZZLEFLASH_X;
+	}
+}
+#endif
diff --git a/game/shared/cstrike/weapon_mac10.cpp b/game/shared/cstrike/weapon_mac10.cpp
new file mode 100644
index 00000000..e3979fd0
--- /dev/null
+++ b/game/shared/cstrike/weapon_mac10.cpp
@@ -0,0 +1,130 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponMAC10 C_WeaponMAC10
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponMAC10 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponMAC10, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponMAC10();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack();
+	virtual bool Deploy();
+	virtual bool Reload();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_MAC10; }
+
+
+private:
+	CWeaponMAC10( const CWeaponMAC10 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMAC10, DT_WeaponMAC10 )
+
+BEGIN_NETWORK_TABLE( CWeaponMAC10, DT_WeaponMAC10 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponMAC10 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_mac10, CWeaponMAC10 );
+PRECACHE_WEAPON_REGISTER( weapon_mac10 );
+
+
+
+CWeaponMAC10::CWeaponMAC10()
+{
+}
+
+
+void CWeaponMAC10::Spawn( )
+{
+	BaseClass::Spawn();
+
+	m_flAccuracy = 0.15;
+}
+
+
+bool CWeaponMAC10::Deploy()
+{
+	bool ret = BaseClass::Deploy();
+	
+	m_flAccuracy = 0.15;
+
+	return ret;
+}
+
+bool CWeaponMAC10::Reload()
+{
+	bool ret = BaseClass::Reload();
+	
+	m_flAccuracy = 0.15;
+
+	return ret;
+}
+
+
+float CWeaponMAC10::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.375f * m_flAccuracy;
+		else
+			return 0.03f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponMAC10::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, Primary_Mode ) )
+		return;
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )	// jumping
+		pPlayer->KickBack (1.3, 0.55, 0.4, 0.05, 4.75, 3.75, 5);
+	else if (pPlayer->GetAbsVelocity().Length2D() > 5)				// running
+		pPlayer->KickBack (0.9, 0.45, 0.25, 0.035, 3.5, 2.75, 7);
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )	// ducking
+		pPlayer->KickBack (0.75, 0.4, 0.175, 0.03, 2.75, 2.5, 10);
+	else														// standing
+		pPlayer->KickBack (0.775, 0.425, 0.2, 0.03, 3, 2.75, 9);
+}
diff --git a/game/shared/cstrike/weapon_mp5navy.cpp b/game/shared/cstrike/weapon_mp5navy.cpp
new file mode 100644
index 00000000..15445502
--- /dev/null
+++ b/game/shared/cstrike/weapon_mp5navy.cpp
@@ -0,0 +1,129 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponMP5Navy C_WeaponMP5Navy
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponMP5Navy : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponMP5Navy, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponMP5Navy();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack();
+	virtual bool Deploy();
+	virtual bool Reload();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_MP5NAVY; }
+
+
+private:
+	CWeaponMP5Navy( const CWeaponMP5Navy & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMP5Navy, DT_WeaponMP5Navy )
+
+BEGIN_NETWORK_TABLE( CWeaponMP5Navy, DT_WeaponMP5Navy )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponMP5Navy )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_mp5navy, CWeaponMP5Navy );
+PRECACHE_WEAPON_REGISTER( weapon_mp5navy );
+
+
+
+CWeaponMP5Navy::CWeaponMP5Navy()
+{
+}
+
+void CWeaponMP5Navy::Spawn()
+{
+	BaseClass::Spawn();
+
+	m_flAccuracy = 0.0;
+}
+
+
+bool CWeaponMP5Navy::Deploy( )
+{
+	bool ret = BaseClass::Deploy();
+
+	m_flAccuracy = 0.0;
+
+	return ret;
+}
+
+bool CWeaponMP5Navy::Reload( )
+{
+	bool ret = BaseClass::Reload();
+
+	m_flAccuracy = 0.0;
+
+	return ret;
+}
+
+float CWeaponMP5Navy::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.2f * m_flAccuracy;
+		else
+			return 0.04f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponMP5Navy::PrimaryAttack( void )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, Primary_Mode ) )
+		return;
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// Kick the gun based on the state of the player.
+	if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack (0.9, 0.475, 0.35, 0.0425, 5, 3, 6);	
+	else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+		pPlayer->KickBack (0.5, 0.275, 0.2, 0.03, 3, 2, 10);
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack (0.225, 0.15, 0.1, 0.015, 2, 1, 10);
+	else
+		pPlayer->KickBack (0.25, 0.175, 0.125, 0.02, 2.25, 1.25, 10);
+}
diff --git a/game/shared/cstrike/weapon_p228.cpp b/game/shared/cstrike/weapon_p228.cpp
new file mode 100644
index 00000000..04bec848
--- /dev/null
+++ b/game/shared/cstrike/weapon_p228.cpp
@@ -0,0 +1,204 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponP228 C_WeaponP228
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponP228 : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CWeaponP228, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponP228();
+
+	virtual void Spawn();
+
+	virtual void PrimaryAttack();
+	virtual bool Deploy();
+
+	virtual bool Reload();
+	virtual void WeaponIdle();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_P228; }
+
+private:
+	
+	CWeaponP228( const CWeaponP228 & );
+
+	float m_flLastFire;
+};
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CWeaponP228 )
+	DEFINE_FIELD( m_flLastFire, FIELD_FLOAT ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_p228, CWeaponP228 );
+PRECACHE_WEAPON_REGISTER( weapon_p228 );
+
+
+
+CWeaponP228::CWeaponP228()
+{
+	m_flLastFire = gpGlobals->curtime;
+}
+
+
+void CWeaponP228::Spawn( )
+{
+	m_flAccuracy = 0.9;
+	
+	BaseClass::Spawn();
+}
+
+
+bool CWeaponP228::Deploy( )
+{
+	m_flAccuracy = 0.9;
+
+	return BaseClass::Deploy();
+}
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponP228, DT_WeaponP228 )
+
+BEGIN_NETWORK_TABLE( CWeaponP228, DT_WeaponP228 )
+END_NETWORK_TABLE()
+
+
+float CWeaponP228::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 1.5f * (1 - m_flAccuracy);
+		else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+			return 0.255f * (1 - m_flAccuracy);
+		else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+			return 0.075f * (1 - m_flAccuracy);
+		else
+			return 0.15f * (1 - m_flAccuracy);
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+
+void CWeaponP228::PrimaryAttack( void )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+	m_flAccuracy -= (0.3)*(0.325 - (gpGlobals->curtime - m_flLastFire));
+
+	if (m_flAccuracy > 0.9)
+		m_flAccuracy = 0.9;
+	else if (m_flAccuracy < 0.6)
+		m_flAccuracy = 0.6;
+
+	m_flLastFire = gpGlobals->curtime;
+	
+	if (m_iClip1 <= 0)
+	{
+		if ( m_bFireOnEmpty )
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.1f;
+			m_bFireOnEmpty = false;
+		}
+
+		return;
+	}
+
+	pPlayer->m_iShotsFired++;
+
+	m_iClip1--;
+	
+	 pPlayer->DoMuzzleFlash();
+	//SetPlayerShieldAnim();
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+		
+	// Aiming
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		Primary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		GetInaccuracy(),
+		GetSpread());
+	
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + GetCSWpnData().m_flCycleTime;
+
+	if (!m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0)
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+
+	SetWeaponIdleTime( gpGlobals->curtime + 2 );
+
+	//ResetPlayerShieldAnim();
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[Primary_Mode];
+
+	QAngle angle = pPlayer->GetPunchAngle();
+	angle.x -= 2;
+	pPlayer->SetPunchAngle( angle );
+}
+
+
+bool CWeaponP228::Reload()
+{
+	if ( !DefaultPistolReload() )
+		return false;
+
+	m_flAccuracy = 0.9;
+	return true;
+}
+
+void CWeaponP228::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	// only idle if the slid isn't back
+	if (m_iClip1 != 0)
+	{	
+		SetWeaponIdleTime( gpGlobals->curtime + 3.0 ) ;
+		SendWeaponAnim( ACT_VM_IDLE );
+	}
+}
diff --git a/game/shared/cstrike/weapon_p90.cpp b/game/shared/cstrike/weapon_p90.cpp
new file mode 100644
index 00000000..80ac9733
--- /dev/null
+++ b/game/shared/cstrike/weapon_p90.cpp
@@ -0,0 +1,97 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponP90 C_WeaponP90
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponP90 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponP90, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponP90();
+
+	virtual void PrimaryAttack();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_P90; }
+
+
+private:
+	CWeaponP90( const CWeaponP90 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponP90, DT_WeaponP90 )
+
+BEGIN_NETWORK_TABLE( CWeaponP90, DT_WeaponP90 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponP90 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_p90, CWeaponP90 );
+PRECACHE_WEAPON_REGISTER( weapon_p90 );
+
+
+
+CWeaponP90::CWeaponP90()
+{
+}
+
+float CWeaponP90::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.3f * m_flAccuracy;
+		else if (pPlayer->GetAbsVelocity().Length2D() > 170)
+			return 0.115f * m_flAccuracy;
+		else
+			return 0.045f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponP90::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+	
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, Primary_Mode ) )
+		return;
+
+	// Kick the gun based on the state of the player.
+	if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack (0.9, 0.45, 0.35, 0.04, 5.25, 3.5, 4);
+	else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+		pPlayer->KickBack (0.45, 0.3, 0.2, 0.0275, 4, 2.25, 7);
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack (0.275, 0.2, 0.125, 0.02, 3, 1, 9);
+	else
+		pPlayer->KickBack (0.3, 0.225, 0.125, 0.02, 3.25, 1.25, 8);
+}
diff --git a/game/shared/cstrike/weapon_scout.cpp b/game/shared/cstrike/weapon_scout.cpp
new file mode 100644
index 00000000..8722e48f
--- /dev/null
+++ b/game/shared/cstrike/weapon_scout.cpp
@@ -0,0 +1,220 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponScout C_WeaponScout
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+	#include "KeyValues.h"
+
+#endif
+
+const int cScoutMidZoomFOV = 40;
+const int cScoutMaxZoomFOV = 15;
+
+
+class CWeaponScout : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponScout, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponScout();
+
+	virtual void PrimaryAttack();
+	virtual void SecondaryAttack();
+
+ 	virtual float GetInaccuracy() const;
+	virtual float GetMaxSpeed() const;
+	virtual bool Reload();
+	virtual bool Deploy();
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_SCOUT; }
+
+
+private:
+	
+	CWeaponScout( const CWeaponScout & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponScout, DT_WeaponScout )
+
+BEGIN_NETWORK_TABLE( CWeaponScout, DT_WeaponScout )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponScout )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_scout, CWeaponScout );
+PRECACHE_WEAPON_REGISTER( weapon_scout );
+
+
+
+CWeaponScout::CWeaponScout()
+{
+}
+
+void CWeaponScout::SecondaryAttack()
+{
+	const float kZoomTime = 0.10f;
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if (pPlayer == NULL)
+	{
+		Assert(pPlayer != NULL);
+		return;
+	}
+
+	if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+	{
+		pPlayer->SetFOV( pPlayer, cScoutMidZoomFOV, kZoomTime );
+		m_weaponMode = Secondary_Mode;
+		m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyAltSwitch;
+	}
+	else if (pPlayer->GetFOV() == cScoutMidZoomFOV)
+	{
+		pPlayer->SetFOV( pPlayer, cScoutMaxZoomFOV, kZoomTime );
+		m_weaponMode = Secondary_Mode;
+	}
+	else if (pPlayer->GetFOV() == cScoutMaxZoomFOV)
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), kZoomTime );
+		m_weaponMode = Primary_Mode;
+	}
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.3f;   
+	m_zoomFullyActiveTime = gpGlobals->curtime + 0.15; // The worst zoom time from above.  
+
+#ifndef CLIENT_DLL
+	// If this isn't guarded, the sound will be emitted twice, once by the server and once by the client.
+	// Let the server play it since if only the client plays it, it's liable to get played twice cause of
+	// a prediction error. joy.	
+	
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Playing this from the player so that we don't try to play the sound outside the level.
+	//=============================================================================
+	if ( GetPlayerOwner() )
+	{
+		GetPlayerOwner()->EmitSound( "Default.Zoom" ); // zoom sound
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	// let the bots hear the rifle zoom
+	IGameEvent * event = gameeventmanager->CreateEvent( "weapon_zoom" );
+	if( event )
+	{
+		event->SetInt( "userid", pPlayer->GetUserID() );
+		gameeventmanager->FireEvent( event );
+	}
+#endif
+}
+
+float CWeaponScout::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if (pPlayer == NULL)
+			return 0.0f;
+	
+		float fSpread = 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			fSpread = 0.2f;
+		else if (pPlayer->GetAbsVelocity().Length2D() > 170)
+			fSpread = 0.075f;
+		else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+			fSpread = 0.0f;
+		else
+			fSpread = 0.007f;
+	
+		// If we are not zoomed in, or we have very recently zoomed and are still transitioning, the bullet diverts more.
+		if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV() || (gpGlobals->curtime < m_zoomFullyActiveTime))
+		{
+			fSpread += 0.025;
+		}
+	
+		return fSpread;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponScout::PrimaryAttack( void )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if (pPlayer == NULL)
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, m_weaponMode ) )
+		return;
+
+	if ( m_weaponMode == Secondary_Mode )
+	{	
+		float	midFOVdistance = fabs( pPlayer->GetFOV() - (float)cScoutMidZoomFOV );
+		float	farFOVdistance = fabs( pPlayer->GetFOV() - (float)cScoutMaxZoomFOV );
+
+		if ( midFOVdistance < farFOVdistance )
+		{
+			pPlayer->m_iLastZoom = cScoutMidZoomFOV;
+		}
+		else
+		{
+			pPlayer->m_iLastZoom = cScoutMaxZoomFOV;
+		}
+		
+// 		#ifndef CLIENT_DLL
+			pPlayer->m_bResumeZoom = true;
+			pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), 0.05f );
+			m_weaponMode = Primary_Mode;
+// 		#endif
+	}
+
+	QAngle angle = pPlayer->GetPunchAngle();
+	angle.x -= 2;
+	pPlayer->SetPunchAngle( angle );
+}
+
+
+float CWeaponScout::GetMaxSpeed() const
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if (pPlayer == NULL)
+	{
+		Assert(pPlayer != NULL);
+		return BaseClass::GetMaxSpeed();
+	}
+
+	if ( pPlayer->GetFOV() == pPlayer->GetDefaultFOV() )
+		return BaseClass::GetMaxSpeed();
+	else
+		return 220;	// zoomed in.
+}
+
+
+bool CWeaponScout::Reload()
+{
+	m_weaponMode = Primary_Mode;
+	return BaseClass::Reload();
+
+}
+
+bool CWeaponScout::Deploy()
+{
+	m_weaponMode = Primary_Mode;
+	return BaseClass::Deploy();
+}
diff --git a/game/shared/cstrike/weapon_sg550.cpp b/game/shared/cstrike/weapon_sg550.cpp
new file mode 100644
index 00000000..fc741837
--- /dev/null
+++ b/game/shared/cstrike/weapon_sg550.cpp
@@ -0,0 +1,214 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponSG550 C_WeaponSG550
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+	#include "KeyValues.h"
+
+#endif
+
+
+class CWeaponSG550 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponSG550, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponSG550();
+
+	virtual void Spawn();
+	virtual void SecondaryAttack();
+	virtual void PrimaryAttack();
+	virtual bool Reload();
+	virtual bool Deploy();
+
+ 	virtual float GetInaccuracy() const;
+	virtual float GetMaxSpeed() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_SG550; }
+
+
+private:
+	CWeaponSG550( const CWeaponSG550 & );
+
+	float m_flLastFire;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponSG550, DT_WeaponSG550 )
+
+BEGIN_NETWORK_TABLE( CWeaponSG550, DT_WeaponSG550 )
+END_NETWORK_TABLE()
+
+#if defined CLIENT_DLL
+BEGIN_PREDICTION_DATA( CWeaponSG550 )
+	DEFINE_FIELD( m_flLastFire, FIELD_FLOAT ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_sg550, CWeaponSG550 );
+PRECACHE_WEAPON_REGISTER( weapon_sg550 );
+
+
+
+CWeaponSG550::CWeaponSG550()
+{
+	m_flLastFire = gpGlobals->curtime;
+}
+
+void CWeaponSG550::Spawn()
+{
+	BaseClass::Spawn();
+	m_flAccuracy = 0.98;
+}
+
+
+void CWeaponSG550::SecondaryAttack()
+{
+	const float kZoomTime = 0.10f;
+
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+	{
+		pPlayer->SetFOV( pPlayer, 40, kZoomTime );
+		m_weaponMode = Secondary_Mode;
+		m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyAltSwitch;
+	}
+	else if (pPlayer->GetFOV() == 40)
+	{
+		pPlayer->SetFOV( pPlayer, 15, kZoomTime );
+		m_weaponMode = Secondary_Mode;
+	}
+	else if (pPlayer->GetFOV() == 15)
+	{
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV(), kZoomTime );
+		m_weaponMode = Primary_Mode;
+	}
+
+
+#ifndef CLIENT_DLL
+	// If this isn't guarded, the sound will be emitted twice, once by the server and once by the client.
+	// Let the server play it since if only the client plays it, it's liable to get played twice cause of
+	// a prediction error. joy.	
+	
+	//=============================================================================
+	// HPE_BEGIN:
+	// [tj] Playing this from the player so that we don't try to play the sound outside the level.
+	//=============================================================================
+	if ( GetPlayerOwner() )
+	{
+		GetPlayerOwner()->EmitSound( "Default.Zoom" ); // zoom sound.
+	}
+	//=============================================================================
+	// HPE_END
+	//=============================================================================
+	// let the bots hear the rifle zoom
+	IGameEvent * event = gameeventmanager->CreateEvent( "weapon_zoom" );
+	if( event )
+	{
+		event->SetInt( "userid", pPlayer->GetUserID() );
+		gameeventmanager->FireEvent( event );
+	}
+#endif
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.3f;
+	m_zoomFullyActiveTime = gpGlobals->curtime + 0.3; // The worst zoom time from above.  
+}
+
+float CWeaponSG550::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		float fSpread = 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			fSpread = 0.45f * (1 - m_flAccuracy);
+		else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+			fSpread = 0.15f;
+		else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+			fSpread = 0.04f * (1 - m_flAccuracy);
+		else
+			fSpread = 0.05f * (1 - m_flAccuracy);
+	
+		// If we are not zoomed in, or we have very recently zoomed and are still transitioning, the bullet diverts more.
+		if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV() || (gpGlobals->curtime < m_zoomFullyActiveTime))
+			fSpread += 0.025;
+	
+		return fSpread;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponSG550::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+	m_flAccuracy = 0.65 + (0.35) * (gpGlobals->curtime - m_flLastFire);	
+
+	if (m_flAccuracy > 0.98)
+		m_flAccuracy = 0.98;
+
+	m_flLastFire = gpGlobals->curtime;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, m_weaponMode ) )
+		return;
+
+	QAngle angle = pPlayer->GetPunchAngle();
+	angle.x -= SharedRandomFloat("SG550PunchAngleX", 0.75, 1.25 ) + ( angle.x / 4 );
+	angle.y += SharedRandomFloat("SG550PunchAngleY", -0.75, 0.75 );
+	pPlayer->SetPunchAngle( angle );
+}
+
+bool CWeaponSG550::Reload()
+{
+	bool ret = BaseClass::Reload();
+	
+	m_flAccuracy = 0.98;
+	m_weaponMode = Primary_Mode;
+	
+	return ret;
+}
+
+bool CWeaponSG550::Deploy()
+{
+	bool ret = BaseClass::Deploy();
+	
+	m_flAccuracy = 0.98;
+	m_weaponMode = Primary_Mode;
+	
+	return ret;
+}
+
+float CWeaponSG550::GetMaxSpeed() const
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer || pPlayer->GetFOV() == 90 )
+		return BaseClass::GetMaxSpeed();
+	else
+		return 150; // zoomed in
+}
diff --git a/game/shared/cstrike/weapon_sg552.cpp b/game/shared/cstrike/weapon_sg552.cpp
new file mode 100644
index 00000000..ab84095a
--- /dev/null
+++ b/game/shared/cstrike/weapon_sg552.cpp
@@ -0,0 +1,170 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponSG552 C_WeaponSG552
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponSG552 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponSG552, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponSG552();
+
+	virtual void SecondaryAttack();
+	virtual void PrimaryAttack();
+
+ 	virtual float GetInaccuracy() const;
+	virtual float GetMaxSpeed() const;
+	virtual bool Reload();
+	virtual bool Deploy();
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_SG552; }
+
+#ifdef CLIENT_DLL
+	virtual bool	HideViewModelWhenZoomed( void ) { return false; }
+#endif
+
+private:
+
+	CWeaponSG552( const CWeaponSG552 & );
+
+	void SG552Fire( float flSpread, bool bZoomed );
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponSG552, DT_WeaponSG552 )
+
+BEGIN_NETWORK_TABLE( CWeaponSG552, DT_WeaponSG552 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponSG552 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_sg552, CWeaponSG552 );
+PRECACHE_WEAPON_REGISTER( weapon_sg552 );
+
+
+
+CWeaponSG552::CWeaponSG552()
+{
+}
+
+
+void CWeaponSG552::SecondaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if (pPlayer->GetFOV() == pPlayer->GetDefaultFOV())
+	{
+		pPlayer->SetFOV( pPlayer, 55, 0.2f );
+		m_weaponMode = Secondary_Mode;
+	}
+	else if (pPlayer->GetFOV() == 55)
+	{
+		pPlayer->SetFOV( pPlayer, 0, 0.15f );
+		m_weaponMode = Secondary_Mode;
+	}
+	else 
+	{
+		//FIXME: This seems wrong
+		pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV() );
+		m_weaponMode = Primary_Mode;
+	}
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.3;
+}
+
+float CWeaponSG552::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.035f + 0.45f * m_flAccuracy;
+		else if (pPlayer->GetAbsVelocity().Length2D() > 140)
+			return 0.035f + 0.075f * m_flAccuracy;
+		else
+			return 0.02f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponSG552::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	bool bZoomed = pPlayer->GetFOV() < pPlayer->GetDefaultFOV();
+
+	float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+	if ( bZoomed )
+		flCycleTime = 0.135f;
+
+	if ( !CSBaseGunFire( flCycleTime, m_weaponMode ) )
+		return;
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if (pPlayer->GetAbsVelocity().Length2D() > 5)
+		pPlayer->KickBack (1, 0.45, 0.28, 0.04, 4.25, 2.5, 7);
+	else if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack (1.25, 0.45, 0.22, 0.18, 6, 4, 5);
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack (0.6, 0.35, 0.2, 0.0125, 3.7, 2, 10);
+	else
+		pPlayer->KickBack (0.625, 0.375, 0.25, 0.0125, 4, 2.25, 9);
+}
+
+
+float CWeaponSG552::GetMaxSpeed() const
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+
+	if ( !pPlayer || pPlayer->GetFOV() == pPlayer->GetDefaultFOV() )
+		return BaseClass::GetMaxSpeed();
+	else
+		return 200; // zoomed in.
+}	
+
+
+bool CWeaponSG552::Reload()
+{
+	m_weaponMode = Primary_Mode;
+	return BaseClass::Reload();
+}
+
+bool CWeaponSG552::Deploy()
+{
+	m_weaponMode = Primary_Mode;
+	return BaseClass::Deploy();
+}
diff --git a/game/shared/cstrike/weapon_smokegrenade.cpp b/game/shared/cstrike/weapon_smokegrenade.cpp
new file mode 100644
index 00000000..1703fbfc
--- /dev/null
+++ b/game/shared/cstrike/weapon_smokegrenade.cpp
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "gamerules.h"
+#include "npcevent.h"
+#include "engine/IEngineSound.h"
+#include "weapon_smokegrenade.h"
+
+
+#ifdef CLIENT_DLL
+	
+#else
+
+	#include "cs_player.h"
+	#include "items.h"
+	#include "smokegrenade_projectile.h"
+
+#endif
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( SmokeGrenade, DT_SmokeGrenade )
+
+BEGIN_NETWORK_TABLE(CSmokeGrenade, DT_SmokeGrenade)
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CSmokeGrenade )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_smokegrenade, CSmokeGrenade );
+PRECACHE_WEAPON_REGISTER( weapon_smokegrenade );
+
+
+#ifndef CLIENT_DLL
+
+	BEGIN_DATADESC( CSmokeGrenade )
+	END_DATADESC()
+
+	void CSmokeGrenade::EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer )
+	{
+		CSmokeGrenadeProjectile::Create( vecSrc, vecAngles, vecVel, angImpulse, pPlayer );
+	}
+
+#endif
+
diff --git a/game/shared/cstrike/weapon_smokegrenade.h b/game/shared/cstrike/weapon_smokegrenade.h
new file mode 100644
index 00000000..8d654cf0
--- /dev/null
+++ b/game/shared/cstrike/weapon_smokegrenade.h
@@ -0,0 +1,52 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_SMOKEGRENADE_H
+#define WEAPON_SMOKEGRENADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "weapon_basecsgrenade.h"
+
+
+#ifdef CLIENT_DLL
+	
+	#define CSmokeGrenade C_SmokeGrenade
+
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Smoke grenades
+//-----------------------------------------------------------------------------
+class CSmokeGrenade : public CBaseCSGrenade
+{
+public:
+	DECLARE_CLASS( CSmokeGrenade, CBaseCSGrenade );
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CSmokeGrenade() {}
+
+	virtual CSWeaponID GetWeaponID( void ) const { return WEAPON_SMOKEGRENADE; }
+
+#ifdef CLIENT_DLL
+
+#else
+	DECLARE_DATADESC();
+
+	void EmitGrenade( Vector vecSrc, QAngle vecAngles, Vector vecVel, AngularImpulse angImpulse, CBasePlayer *pPlayer );
+
+#endif
+
+	CSmokeGrenade( const CSmokeGrenade & ) {}
+};
+
+
+#endif // WEAPON_SMOKEGRENADE_H
diff --git a/game/shared/cstrike/weapon_tmp.cpp b/game/shared/cstrike/weapon_tmp.cpp
new file mode 100644
index 00000000..b750d84e
--- /dev/null
+++ b/game/shared/cstrike/weapon_tmp.cpp
@@ -0,0 +1,106 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponTMP C_WeaponTMP
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponTMP : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponTMP, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponTMP();
+
+	virtual void PrimaryAttack();
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_TMP; }
+	virtual bool IsSilenced( void ) const				{ return true; }
+
+ 	virtual float GetInaccuracy() const;
+
+private:
+
+	CWeaponTMP( const CWeaponTMP & );
+
+	void DoFireEffects( void );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponTMP, DT_WeaponTMP )
+
+BEGIN_NETWORK_TABLE( CWeaponTMP, DT_WeaponTMP )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponTMP )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_tmp, CWeaponTMP );
+PRECACHE_WEAPON_REGISTER( weapon_tmp );
+
+
+CWeaponTMP::CWeaponTMP()
+{
+}
+
+
+float CWeaponTMP::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.25f * m_flAccuracy;
+		else
+			return 0.03f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponTMP::PrimaryAttack( void )
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, Primary_Mode ) )
+		return;
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack (1.1, 0.5, 0.35, 0.045, 4.5, 3.5, 6);
+	else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+		pPlayer->KickBack (0.8, 0.4, 0.2, 0.03, 3, 2.5, 7);
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack (0.7, 0.35, 0.125, 0.025, 2.5, 2, 10);
+	else
+		pPlayer->KickBack (0.725, 0.375, 0.15, 0.025, 2.75, 2.25, 9);
+}
+
+void CWeaponTMP::DoFireEffects( void )
+{
+	// TMP is silenced, so do nothing
+}
diff --git a/game/shared/cstrike/weapon_ump45.cpp b/game/shared/cstrike/weapon_ump45.cpp
new file mode 100644
index 00000000..8bcc3e00
--- /dev/null
+++ b/game/shared/cstrike/weapon_ump45.cpp
@@ -0,0 +1,132 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbasegun.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponUMP45 C_WeaponUMP45
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponUMP45 : public CWeaponCSBaseGun
+{
+public:
+	DECLARE_CLASS( CWeaponUMP45, CWeaponCSBaseGun );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponUMP45();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack();
+	virtual bool Deploy();
+	virtual bool Reload();
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_UMP45; }
+
+
+private:
+
+	CWeaponUMP45( const CWeaponUMP45 & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponUMP45, DT_WeaponUMP45 )
+
+BEGIN_NETWORK_TABLE( CWeaponUMP45, DT_WeaponUMP45 )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponUMP45 )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_ump45, CWeaponUMP45 );
+PRECACHE_WEAPON_REGISTER( weapon_ump45 );
+
+
+
+CWeaponUMP45::CWeaponUMP45()
+{
+}
+
+
+void CWeaponUMP45::Spawn()
+{
+	BaseClass::Spawn();
+
+	m_flAccuracy = 0.0;
+}
+
+
+bool CWeaponUMP45::Deploy()
+{
+	bool ret = BaseClass::Deploy();
+
+	m_flAccuracy = 0.0;
+
+	return ret;
+}
+
+bool CWeaponUMP45::Reload()
+{
+	bool ret = BaseClass::Reload();
+
+	m_flAccuracy = 0.0;
+
+	return ret;
+}
+
+float CWeaponUMP45::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+	
+		if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+			return 0.24f * m_flAccuracy;
+		else
+			return 0.04f * m_flAccuracy;
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+void CWeaponUMP45::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !CSBaseGunFire( GetCSWpnData().m_flCycleTime, Primary_Mode ) )
+		return;
+
+	// CSBaseGunFire can kill us, forcing us to drop our weapon, if we shoot something that explodes
+	pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	// Kick the gun based on the state of the player.
+	if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+		pPlayer->KickBack (0.125, 0.65, 0.55, 0.0475, 5.5, 4, 10);
+	else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+		pPlayer->KickBack (0.55, 0.3, 0.225, 0.03, 3.5, 2.5, 10);
+	else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+		pPlayer->KickBack (0.25, 0.175, 0.125, 0.02, 2.25, 1.25, 10);
+	else
+		pPlayer->KickBack (0.275, 0.2, 0.15, 0.0225, 2.5, 1.5, 10);
+}
+
diff --git a/game/shared/cstrike/weapon_usp.cpp b/game/shared/cstrike/weapon_usp.cpp
new file mode 100644
index 00000000..6a99f025
--- /dev/null
+++ b/game/shared/cstrike/weapon_usp.cpp
@@ -0,0 +1,395 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponUSP C_WeaponUSP
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+
+#endif
+
+
+class CWeaponUSP : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CWeaponUSP, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponUSP();
+
+	virtual void Spawn();
+	virtual void Precache();
+
+	virtual void PrimaryAttack();
+	virtual void SecondaryAttack();
+	virtual bool Deploy();
+	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void Drop( const Vector &vecVelocity );
+
+ 	virtual float GetInaccuracy() const;
+
+	virtual bool Reload();
+	virtual void WeaponIdle();
+
+	// We overload this so we can translate all weapon activities to silenced versions.
+	virtual bool SendWeaponAnim( int iActivity );
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_USP; }
+
+	// return true if this weapon has a silencer equipped
+	virtual bool IsSilenced( void ) const				{ return m_bSilencerOn; }
+
+	virtual Activity GetDeployActivity( void );
+
+#ifdef CLIENT_DLL
+	virtual int GetMuzzleFlashStyle( void );
+#endif
+
+	virtual const char		*GetWorldModel( void ) const;
+	virtual int				GetWorldModelIndex( void );
+
+private:
+	CWeaponUSP( const CWeaponUSP & );
+
+	CNetworkVar( bool, m_bSilencerOn );
+	CNetworkVar( float, m_flDoneSwitchingSilencer );	// soonest time switching the silencer will be complete
+	float m_flLastFire;
+
+	int m_silencedModelIndex;
+	bool m_inPrecache;
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponUSP, DT_WeaponUSP )
+
+BEGIN_NETWORK_TABLE( CWeaponUSP, DT_WeaponUSP )
+#ifdef CLIENT_DLL
+	RecvPropBool( RECVINFO( m_bSilencerOn ) ),
+	RecvPropTime( RECVINFO( m_flDoneSwitchingSilencer ) ),
+#else
+	SendPropBool( SENDINFO( m_bSilencerOn ) ),
+	SendPropTime( SENDINFO( m_flDoneSwitchingSilencer ) ),
+#endif
+END_NETWORK_TABLE()
+
+#ifdef CLIENT_DLL
+BEGIN_PREDICTION_DATA( CWeaponUSP )
+	DEFINE_PRED_FIELD( m_bSilencerOn, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_FIELD( m_flLastFire, FIELD_FLOAT ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_usp, CWeaponUSP );
+PRECACHE_WEAPON_REGISTER( weapon_usp );
+
+
+Activity g_SilencedTranslations[][2] =
+{
+	{ ACT_VM_RELOAD, ACT_VM_RELOAD_SILENCED },
+	{ ACT_VM_PRIMARYATTACK, ACT_VM_PRIMARYATTACK_SILENCED },
+	{ ACT_VM_DRAW, ACT_VM_DRAW_SILENCED },
+};
+
+
+
+CWeaponUSP::CWeaponUSP()
+{
+	m_flLastFire = gpGlobals->curtime;
+	m_bSilencerOn = false;
+	m_flDoneSwitchingSilencer = 0.0f;
+	m_inPrecache = false;
+}
+
+
+void CWeaponUSP::Spawn()
+{
+	//m_iDefaultAmmo = 12;
+	m_flAccuracy = 0.92;
+	m_bSilencerOn = false;
+	m_weaponMode = Primary_Mode;
+	m_flDoneSwitchingSilencer = 0.0f;
+
+	//FallInit();// get ready to fall down.
+	BaseClass::Spawn();
+}
+
+
+void CWeaponUSP::Precache()
+{
+	m_inPrecache = true;
+	BaseClass::Precache();
+
+	m_silencedModelIndex = CBaseEntity::PrecacheModel( GetCSWpnData().m_szSilencerModel );
+	m_inPrecache = false;
+}
+
+
+int CWeaponUSP::GetWorldModelIndex( void )
+{
+	if ( !m_bSilencerOn || m_inPrecache )
+	{
+		return m_iWorldModelIndex;
+	}
+	else
+	{
+		return m_silencedModelIndex;
+	}
+}
+
+
+const char * CWeaponUSP::GetWorldModel( void ) const
+{
+	if ( !m_bSilencerOn || m_inPrecache )
+	{
+		return BaseClass::GetWorldModel();
+	}
+	else
+	{
+		return GetCSWpnData().m_szSilencerModel;
+	}
+}
+
+
+bool CWeaponUSP::Deploy()
+{
+	m_flAccuracy = 0.92;
+	m_flDoneSwitchingSilencer = 0.0f;
+
+	return BaseClass::Deploy();
+}
+
+bool CWeaponUSP::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	if ( gpGlobals->curtime < m_flDoneSwitchingSilencer )
+	{
+		// still switching the silencer.  Cancel the switch.
+		m_bSilencerOn = !m_bSilencerOn;
+		m_weaponMode = m_bSilencerOn ? Secondary_Mode : Primary_Mode;
+		SetWeaponModelIndex( GetWorldModel() );
+	}
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+void CWeaponUSP::Drop( const Vector &vecVelocity )
+{
+	if ( gpGlobals->curtime < m_flDoneSwitchingSilencer )
+	{
+		// still switching the silencer.  Cancel the switch.
+		m_bSilencerOn = !m_bSilencerOn;
+		m_weaponMode = m_bSilencerOn ? Secondary_Mode : Primary_Mode;
+		SetWeaponModelIndex( GetWorldModel() );
+	}
+
+	BaseClass::Drop( vecVelocity );
+}
+
+Activity CWeaponUSP::GetDeployActivity( void )
+{
+	if( IsSilenced() )
+	{
+		return ACT_VM_DRAW_SILENCED;
+	}
+	else
+	{
+		return ACT_VM_DRAW;
+	}
+}
+
+void CWeaponUSP::SecondaryAttack()
+{
+	if ( m_bSilencerOn )
+	{
+		SendWeaponAnim( ACT_VM_DETACH_SILENCER );
+	}
+	else
+	{
+		SendWeaponAnim( ACT_VM_ATTACH_SILENCER );
+	}
+	m_bSilencerOn = !m_bSilencerOn;
+	m_weaponMode = m_bSilencerOn ? Secondary_Mode : Primary_Mode;
+	m_flDoneSwitchingSilencer = gpGlobals->curtime + 3;
+
+	m_flNextSecondaryAttack = gpGlobals->curtime + 3;
+	m_flNextPrimaryAttack = gpGlobals->curtime + 3;
+	SetWeaponIdleTime( gpGlobals->curtime + 3 );
+
+	SetWeaponModelIndex( GetWorldModel() );
+}
+
+
+float CWeaponUSP::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+	{
+		CCSPlayer *pPlayer = GetPlayerOwner();
+		if ( !pPlayer )
+			return 0.0f;
+
+		if ( m_bSilencerOn )
+		{
+			if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+				return 1.3f * (1 - m_flAccuracy);
+			else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+				return 0.25f * (1 - m_flAccuracy);
+			else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+				return 0.125f * (1 - m_flAccuracy);
+			else
+				return 0.15f * (1 - m_flAccuracy);
+		}
+		else
+		{
+			if ( !FBitSet( pPlayer->GetFlags(), FL_ONGROUND ) )
+				return 1.2f * (1 - m_flAccuracy );
+			else if (pPlayer->GetAbsVelocity().Length2D() > 5)
+				return 0.225f * (1 - m_flAccuracy);
+			else if ( FBitSet( pPlayer->GetFlags(), FL_DUCKING ) )
+				return 0.08f * (1 - m_flAccuracy);
+			else
+				return 0.1f * (1 - m_flAccuracy);
+		}
+	}
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+
+void CWeaponUSP::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	float flCycleTime =  GetCSWpnData().m_flCycleTime;
+
+	// Mark the time of this shot and determine the accuracy modifier based on the last shot fired...
+	m_flAccuracy -= (0.275)*(0.3 - (gpGlobals->curtime - m_flLastFire));
+
+	if (m_flAccuracy > 0.92)
+		m_flAccuracy = 0.92;
+	else if (m_flAccuracy < 0.6)
+		m_flAccuracy = 0.6;
+
+	m_flLastFire = gpGlobals->curtime;
+
+	if (m_iClip1 <= 0)
+	{
+		if ( m_bFireOnEmpty )
+		{
+			PlayEmptySound();
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.2;
+			m_bFireOnEmpty = false;
+		}
+
+		return;
+	}
+
+	pPlayer->m_iShotsFired++;
+
+	m_flNextPrimaryAttack = m_flNextSecondaryAttack = gpGlobals->curtime + flCycleTime;
+
+	m_iClip1--;
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	
+	if ( !m_bSilencerOn )
+	{
+		pPlayer->DoMuzzleFlash();
+	}
+	
+	FX_FireBullets(
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(),
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(),
+		GetWeaponID(),
+		m_weaponMode,
+		CBaseEntity::GetPredictionRandomSeed() & 255,
+		GetInaccuracy(),
+		GetSpread());
+
+	if (!m_iClip1 && pPlayer->GetAmmoCount( GetPrimaryAmmoType() ) <= 0)
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+ 
+	SetWeaponIdleTime( gpGlobals->curtime + 2 );
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[m_weaponMode];
+
+	QAngle angle = pPlayer->GetPunchAngle();
+	angle.x -= 2;
+	pPlayer->SetPunchAngle( angle );
+}
+
+
+bool CWeaponUSP::Reload()
+{
+	if ( !DefaultPistolReload() )
+		return false;
+	
+	m_flAccuracy = 0.92;
+	return true;
+}
+
+void CWeaponUSP::WeaponIdle()
+{
+	if (m_flTimeWeaponIdle > gpGlobals->curtime)
+		return;
+
+	// only idle if the slid isn't back
+	if (m_iClip1 != 0)
+	{
+		SetWeaponIdleTime( gpGlobals->curtime + 6.0 );
+	}
+}
+
+bool CWeaponUSP::SendWeaponAnim( int iActivity )
+{
+	// Translate the activity?
+	if ( m_bSilencerOn )
+	{
+		for ( int i=0; i < ARRAYSIZE( g_SilencedTranslations ); i++ )
+		{
+			if ( g_SilencedTranslations[i][0] == iActivity )
+			{
+				iActivity = g_SilencedTranslations[i][1];
+				break;
+			}
+		}
+	}
+	
+	return BaseClass::SendWeaponAnim( iActivity );
+}
+
+
+#ifdef CLIENT_DLL
+int CWeaponUSP::GetMuzzleFlashStyle( void )
+{
+	if( m_bSilencerOn )
+	{
+		return CS_MUZZLEFLASH_NONE;
+	}
+	else
+	{
+		return CS_MUZZLEFLASH_NORM;
+	}
+}
+#endif
diff --git a/game/shared/cstrike/weapon_xm1014.cpp b/game/shared/cstrike/weapon_xm1014.cpp
new file mode 100644
index 00000000..4cead324
--- /dev/null
+++ b/game/shared/cstrike/weapon_xm1014.cpp
@@ -0,0 +1,304 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_csbase.h"
+#include "fx_cs_shared.h"
+
+
+#if defined( CLIENT_DLL )
+
+	#define CWeaponXM1014 C_WeaponXM1014
+	#include "c_cs_player.h"
+
+#else
+
+	#include "cs_player.h"
+	#include "te_shotgun_shot.h"
+
+#endif
+
+
+class CWeaponXM1014 : public CWeaponCSBase
+{
+public:
+	DECLARE_CLASS( CWeaponXM1014, CWeaponCSBase );
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+	
+	CWeaponXM1014();
+
+	virtual void Spawn();
+	virtual void PrimaryAttack();
+	virtual bool Reload();
+	virtual void WeaponIdle();
+
+ 	virtual float GetInaccuracy() const;
+	virtual float GetSpread() const;
+
+	virtual CSWeaponID GetWeaponID( void ) const		{ return WEAPON_XM1014; }
+
+private:
+
+	CWeaponXM1014( const CWeaponXM1014 & );
+
+	float m_flPumpTime;
+	CNetworkVar( int, m_reloadState );	// special reload state for shotgun
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponXM1014, DT_WeaponXM1014 )
+
+BEGIN_NETWORK_TABLE( CWeaponXM1014, DT_WeaponXM1014 )
+#ifdef CLIENT_DLL
+	RecvPropInt( RECVINFO( m_reloadState ) )
+#else
+	SendPropInt( SENDINFO( m_reloadState ), 2, SPROP_UNSIGNED )
+#endif
+END_NETWORK_TABLE()
+
+#if defined(CLIENT_DLL)
+BEGIN_PREDICTION_DATA( CWeaponXM1014 )
+	DEFINE_PRED_FIELD( m_reloadState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_xm1014, CWeaponXM1014 );
+PRECACHE_WEAPON_REGISTER( weapon_xm1014 );
+
+
+CWeaponXM1014::CWeaponXM1014()
+{
+	m_flPumpTime = 0;
+	m_reloadState = 0;
+}
+
+void CWeaponXM1014::Spawn()
+{
+	//m_iDefaultAmmo = M3_DEFAULT_GIVE;
+	//FallInit();// get ready to fall
+	BaseClass::Spawn();
+}
+
+float CWeaponXM1014::GetInaccuracy() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+		return 0.0f;
+	else
+		return BaseClass::GetInaccuracy();
+}
+
+float CWeaponXM1014::GetSpread() const
+{
+	if ( weapon_accuracy_model.GetInt() == 1 )
+		return 0.0725f;
+
+	return GetCSWpnData().m_fSpread[Primary_Mode];
+}
+
+void CWeaponXM1014::PrimaryAttack()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	float flCycleTime = GetCSWpnData().m_flCycleTime;
+
+	// don't fire underwater
+	if (pPlayer->GetWaterLevel() == 3)
+	{
+		PlayEmptySound( );
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.15;
+		return;
+	}
+
+	if (m_iClip1 <= 0)
+	{
+		Reload();
+		
+		if (m_iClip1 == 0)
+		{
+			PlayEmptySound( );
+			m_flNextPrimaryAttack = gpGlobals->curtime + 0.25;
+		}
+
+		return;
+	}
+
+	 SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	 
+	//pPlayer->m_iWeaponVolume = LOUD_GUN_VOLUME;
+	//pPlayer->m_iWeaponFlash = BRIGHT_GUN_FLASH;
+
+	m_iClip1--;
+	pPlayer->DoMuzzleFlash();
+
+	// player "shoot" animation
+	pPlayer->SetAnimation( PLAYER_ATTACK1 );
+
+	// Dispatch the FX right away with full accuracy.
+	float flCurAttack = CalculateNextAttackTime( flCycleTime );
+	FX_FireBullets( 
+		pPlayer->entindex(),
+		pPlayer->Weapon_ShootPosition(), 
+		pPlayer->EyeAngles() + 2.0f * pPlayer->GetPunchAngle(), 
+		GetWeaponID(),
+		Primary_Mode,
+		CBaseEntity::GetPredictionRandomSeed() & 255, // wrap it for network traffic so it's the same between client and server
+		GetInaccuracy(),
+		GetSpread(), // flSpread
+		flCurAttack );
+
+	if (!m_iClip1 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0)
+	{
+		// HEV suit - indicate out of ammo condition
+		pPlayer->SetSuitUpdate("!HEV_AMO0", false, 0);
+	}
+
+	if (m_iClip1 != 0)
+		m_flPumpTime = gpGlobals->curtime + 0.5;
+
+	if (m_iClip1 != 0)
+		SetWeaponIdleTime( gpGlobals->curtime + 2.5 );
+	else
+		SetWeaponIdleTime( gpGlobals->curtime + 0.25 );
+	m_reloadState = 0;
+
+	// update accuracy
+	m_fAccuracyPenalty += GetCSWpnData().m_fInaccuracyImpulseFire[Primary_Mode];
+
+	// Update punch angles.
+	QAngle angle = pPlayer->GetPunchAngle();
+
+	if ( pPlayer->GetFlags() & FL_ONGROUND )
+	{
+		angle.x -= SharedRandomInt( "XM1014PunchAngleGround", 3, 5 );
+	}
+	else
+	{
+		angle.x -= SharedRandomInt( "XM1014PunchAngleAir", 7, 10 );
+	}
+
+	pPlayer->SetPunchAngle( angle );
+}
+
+
+bool CWeaponXM1014::Reload()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return false;
+
+	if (pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 || m_iClip1 == GetMaxClip1())
+		return true;
+
+	// don't reload until recoil is done
+	if (m_flNextPrimaryAttack > gpGlobals->curtime)
+		return true;
+	
+	//MIKETODO: shotgun reloading (wait until we get content)
+	
+	// check to see if we're ready to reload
+	if (m_reloadState == 0)
+	{
+		pPlayer->SetAnimation( PLAYER_RELOAD );
+
+		SendWeaponAnim( ACT_SHOTGUN_RELOAD_START );
+		m_reloadState = 1;
+		pPlayer->m_flNextAttack = gpGlobals->curtime + 0.5;
+		SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+		m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+
+#ifdef GAME_DLL
+		pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_START );
+#endif
+
+		return true;
+	}
+	else if (m_reloadState == 1)
+	{
+		if (m_flTimeWeaponIdle > gpGlobals->curtime)
+			return true;
+		// was waiting for gun to move to side
+		m_reloadState = 2;
+
+		SendWeaponAnim( ACT_VM_RELOAD );
+		SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
+#ifdef GAME_DLL
+		if ( m_iClip1 == 6 )
+		{
+			pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_END );
+		}
+		else
+		{
+			pPlayer->DoAnimationEvent( PLAYERANIMEVENT_RELOAD_LOOP );
+		}
+#endif
+	}
+	else
+	{
+		// Add them to the clip
+		m_iClip1 += 1;
+		
+#ifdef GAME_DLL
+		SendReloadEvents();
+#endif
+		
+		CCSPlayer *pPlayer = GetPlayerOwner();
+
+		if ( pPlayer )
+			 pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+
+		m_reloadState = 1;
+	}
+	
+
+	return true;
+}
+
+
+void CWeaponXM1014::WeaponIdle()
+{
+	CCSPlayer *pPlayer = GetPlayerOwner();
+	if ( !pPlayer )
+		return;
+
+	if (m_flPumpTime && m_flPumpTime < gpGlobals->curtime)
+	{
+		// play pumping sound
+		m_flPumpTime = 0;
+	}
+
+	if (m_flTimeWeaponIdle < gpGlobals->curtime)
+	{
+		if (m_iClip1 == 0 && m_reloadState == 0 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ))
+		{
+			Reload( );
+		}
+		else if (m_reloadState != 0)
+		{
+			if (m_iClip1 != 7 && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ))
+			{
+				Reload( );
+			}
+			else
+			{
+				// reload debounce has timed out
+				//MIKETODO: shotgun anims
+				SendWeaponAnim( ACT_SHOTGUN_RELOAD_FINISH );
+				
+				// play cocking sound
+				m_reloadState = 0;
+				SetWeaponIdleTime( gpGlobals->curtime + 1.5 );
+			}
+		}
+		else
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+		}
+	}
+}
diff --git a/game/shared/steamworks_gamestats.cpp b/game/shared/steamworks_gamestats.cpp
new file mode 100644
index 00000000..995b96cd
--- /dev/null
+++ b/game/shared/steamworks_gamestats.cpp
@@ -0,0 +1,1154 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Uploads KeyValue stats to the new SteamWorks gamestats system.
+//
+//=============================================================================
+
+#include "cbase.h"
+#include "cdll_int.h"
+#include "tier2/tier2.h"
+#include <time.h>
+
+#ifdef	GAME_DLL
+#include "gameinterface.h"
+#elif	CLIENT_DLL
+#include "c_playerresource.h"
+#endif
+
+#include "steam/isteamutils.h"
+
+#include "steamworks_gamestats.h"
+#include "achievementmgr.h"
+#include "icommandline.h"
+
+// NOTE: This has to be the last file included!
+#include "tier0/memdbgon.h"
+
+#if defined(CLIENT_DLL) || defined(CSTRIKE_DLL)
+ConVar	steamworks_sessionid_client( "steamworks_sessionid_client", "0", FCVAR_HIDDEN, "The client session ID for the new steamworks gamestats." );
+#endif
+
+// This is used to replicate our server id to the client so that client data can be associated with the server's.
+ConVar	steamworks_sessionid_server( "steamworks_sessionid_server", "0", FCVAR_REPLICATED | FCVAR_HIDDEN, "The server session ID for the new steamworks gamestats." );
+
+// This is used to show when the steam works is uploading stats
+#define steamworks_show_uploads 0
+
+// This is a stop gap to disable the steam works game stats from ever initializing in the event that we need it
+#if defined(CSTRIKE_DLL)
+	#define steamworks_stats_disable 1
+#else
+	#define steamworks_stats_disable 0
+#endif
+
+// This is used to control when the stats get uploaded. If we wait until the end of the session, we miss out on all the stats if the server crashes. If we upload as we go, then we will have the data
+#define steamworks_immediate_upload 1
+
+// If set to zero all cvars will be tracked.
+#define steamworks_track_cvar 0
+
+// If set to non zero only cvars that are don't have default values will be tracked, but only if steamworks_track_cvar is also not zero.
+#define steamworks_track_cvar_diff_only 1
+
+// Methods that clients connect to servers.  note that positive numbers are reserved
+// for quickplay sessions
+enum
+{
+	k_ClientJoinMethod_Unknown = -1,
+	k_ClientJoinMethod_ListenServer = -2,
+	k_ClientJoinMethod_ServerBrowser_UNKNOWN = -3, // server browser, unknown tab
+	k_ClientJoinMethod_Steam = -4,
+	k_ClientJoinMethod_Matchmaking = -5,
+	k_ClientJoinMethod_Coaching = -6,
+	k_ClientJoinMethod_Redirect = -7,
+	k_ClientJoinMethod_ServerBrowserInternet = -10,
+	k_ClientJoinMethod_ServerBrowserFriends = -11,
+	k_ClientJoinMethod_ServerBrowserFavorites = -12,
+	k_ClientJoinMethod_ServerBrowserHistory = -13,
+	k_ClientJoinMethod_ServerBrowserLAN = -14,
+	k_ClientJoinMethod_ServerBrowserSpectator = -15
+};
+
+static CSteamWorksGameStatsUploader g_SteamWorksGameStats;
+
+extern ConVar developer;
+
+#if defined(CLIENT_DLL) || defined(CSTRIKE_DLL)
+void Show_Steam_Stats_Session_ID( void )
+{
+	DevMsg( "Client session ID (%s).\n", steamworks_sessionid_client.GetString() );
+	DevMsg( "Server session ID (%s).\n", steamworks_sessionid_server.GetString() );
+}
+static ConCommand ShowSteamStatsSessionID( "ShowSteamStatsSessionID", Show_Steam_Stats_Session_ID, "Prints out the game stats session ID's (developer convar must be set to non-zero).", FCVAR_DEVELOPMENTONLY );
+#endif
+
+#ifdef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: Clients store the server's session IDs so we can associate client rows with server rows.
+//-----------------------------------------------------------------------------
+void ServerSessionIDChangeCallback( IConVar *pConVar, const char *pOldString, float flOldValue )
+{
+	ConVarRef var( pConVar );
+	if ( var.IsValid() )
+	{
+		// Treat the variable as a string, since the sessionID is 64 bit and the convar int interface is only 32 bit.
+		const char* pVarString = var.GetString();
+		uint64 newServerSessionID = Q_atoi64( pVarString );
+		g_SteamWorksGameStats.SetServerSessionID( newServerSessionID );
+	}
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the time since the epoch
+//-----------------------------------------------------------------------------
+time_t CSteamWorksGameStatsUploader::GetTimeSinceEpoch( void )
+{
+	if ( steamapicontext && steamapicontext->SteamUtils() )
+		return steamapicontext->SteamUtils()->GetServerRealTime();
+	else
+	{
+		// Default to system time.
+		time_t aclock;
+		time( &aclock );
+		return aclock;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a reference to the global object
+//-----------------------------------------------------------------------------
+CSteamWorksGameStatsUploader& GetSteamWorksSGameStatsUploader()
+{
+	return g_SteamWorksGameStats;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor. Sets up the steam callbacks accordingly depending on client/server dll 
+//-----------------------------------------------------------------------------
+CSteamWorksGameStatsUploader::CSteamWorksGameStatsUploader() : CAutoGameSystemPerFrame( "CSteamWorksGameStatsUploader" )
+#if !defined(NO_STEAM) && defined(GAME_DLL) 
+,		m_CallbackSteamSessionInfoIssued( this, &CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoIssued )
+,		m_CallbackSteamSessionInfoClosed( this, &CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoClosed )
+#endif
+{
+
+#if !defined(NO_STEAM) && defined(CLIENT_DLL)
+	m_CallbackSteamSessionInfoIssued.Register( this, &CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoIssued );
+	m_CallbackSteamSessionInfoClosed.Register( this, &CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoClosed );
+#endif
+
+	Reset();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks to see if Cvar diff tracking is enabled and if so uploads the diffs
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::UploadCvars()
+{
+	if ( steamworks_track_cvar )
+	{
+		bool bOnlyDiffCvars = steamworks_track_cvar_diff_only;
+
+		// Get all the Cvar Differences...
+		const ConCommandBase *var = g_pCVar->GetCommands();
+
+		// Loop through vars and print out findings
+		for ( ; var; var=var->GetNext() )
+		{
+			if ( var->IsCommand() )
+				continue;
+
+			if ( var->IsFlagSet(FCVAR_DEVELOPMENTONLY) || var->IsFlagSet(FCVAR_NEVER_AS_STRING) )
+				continue;
+
+			const char* pDefValue = ((ConVar*)var)->GetDefault();
+			const char* pValue = ((ConVar*)var)->GetString();
+			if ( bOnlyDiffCvars && !Q_stricmp( pDefValue, pValue ) )
+				continue;
+
+			KeyValues *pKV = new KeyValues( "Cvars" );
+			pKV->SetUint64( "TimeSubmitted", GetTimeSinceEpoch() );
+			pKV->SetString( "CvarID", var->GetName() );
+			pKV->SetString( "CvarDefValue", pDefValue );
+			pKV->SetString( "CvarValue", pValue );
+
+			ParseKeyValuesAndSendStats( pKV, false );
+			pKV->deleteThis();
+		}
+
+		static const char* csCLcvars[] =
+		{
+			"-threads",
+			"-high",
+			"-heap",
+			"-dxlevel"
+		};
+	
+		for ( int hh=0; hh <ARRAYSIZE(csCLcvars) ; ++hh )
+		{
+			const char *pszParamValue = CommandLine()->ParmValue( csCLcvars[hh] );
+			if ( pszParamValue )
+			{
+				KeyValues *pKV = new KeyValues( "Cvars" );
+				pKV->SetUint64( "TimeSubmitted", GetTimeSinceEpoch() );
+				pKV->SetString( "CvarID", csCLcvars[hh] );
+				pKV->SetString( "CvarDefValue", "commandline" );
+				pKV->SetString( "CvarValue", pszParamValue );
+
+				ParseKeyValuesAndSendStats( pKV, false );
+				pKV->deleteThis();
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reset uploader state.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::Reset()
+{
+	ClearSessionID();
+
+#ifdef	CLIENT_DLL
+	steamworks_sessionid_client.SetValue( 0 );
+	ClearServerSessionID();
+#endif
+
+	m_ServiceTicking = false;
+	m_LastServiceTick = 0;
+	m_SessionIDRequestUnsent = false;
+	m_SessionIDRequestPending = false;
+	m_UploadedStats = false;
+	m_bCollectingAny = false;
+	m_bCollectingDetails = false;
+	m_UserID = 0;
+	m_iAppID = 0;
+	m_iServerIP = 0;
+	m_nClientJoinMethod = k_ClientJoinMethod_Unknown;
+	memset( m_pzServerIP, 0, ARRAYSIZE(m_pzServerIP) );
+	memset( m_pzMapStart, 0, ARRAYSIZE(m_pzMapStart) );
+	memset( m_pzHostName, 0, ARRAYSIZE(m_pzHostName) );
+	m_StartTime = 0;
+	m_EndTime = 0;
+	m_HumanCntInGame = 0;
+	m_FriendCntInGame = 0;
+
+	m_ActiveSession.Reset();
+	m_iServerConnectCount = 0;
+
+	for ( int i=0; i<m_StatsToSend.Count(); ++i )
+	{
+		m_StatsToSend[i]->deleteThis();
+	}
+
+	m_StatsToSend.RemoveAll();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Init function from CAutoGameSystemPerFrame and must return true.
+//-----------------------------------------------------------------------------
+bool CSteamWorksGameStatsUploader::Init()
+{
+//	ListenForGameEvent( "hostname_changed" );
+	ListenForGameEvent( "server_spawn" );
+
+#ifdef CLIENT_DLL
+	ListenForGameEvent( "client_disconnect" );
+	ListenForGameEvent( "client_beginconnect" );
+	steamworks_sessionid_server.InstallChangeCallback( ServerSessionIDChangeCallback );
+#endif
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Event handler for gathering basic info as well as ending sessions.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::FireGameEvent( IGameEvent *event )
+{
+	if ( !event )
+	{
+		return;
+	}
+
+	const char *pEventName = event->GetName();
+	if ( FStrEq( "hostname_changed", pEventName ) )
+	{
+		const char *pzHostname = event->GetString( "hostname" );
+		if ( pzHostname )
+		{
+			V_strncpy( m_pzHostName, pzHostname, sizeof( m_pzHostName ) );
+		}
+		else
+		{
+			V_strncpy( m_pzHostName, "No Host Name", sizeof( m_pzHostName ) );
+		}
+	}
+	else if ( FStrEq( "server_spawn", pEventName ) )
+	{
+
+#if 0		// the next three disabled if()'s are in the latest l4d2 branch, I'm not sure if they should be brought over
+		if ( !m_pzServerIP[0] )
+#endif
+		{
+			const char *pzAddress = event->GetString( "address" );
+			if ( pzAddress )
+			{
+				V_snprintf( m_pzServerIP, ARRAYSIZE(m_pzServerIP), "%s:%d", pzAddress, event->GetInt( "port" ) );
+				ServerAddressToInt();
+			}
+			else
+			{
+				V_strncpy( m_pzServerIP, "No Server Address", sizeof( m_pzServerIP ) );
+				m_iServerIP = 0;
+			}
+		}
+
+#if 0
+		if ( !m_pzHostName[0] )
+#endif
+		{
+			const char *pzHostname = event->GetString( "hostname" );
+			if ( pzHostname )
+			{
+				V_strncpy( m_pzHostName, pzHostname, sizeof( m_pzHostName ) );
+			}
+			else
+			{
+				V_strncpy( m_pzHostName, "No Host Name", sizeof( m_pzHostName ) );
+			}
+		}
+
+#if 0
+		if ( !m_pzMapStart[0] )
+#endif
+		{
+			const char *pzMapName = event->GetString( "mapname" );
+			if ( pzMapName )
+			{
+				V_strncpy( m_pzMapStart, pzMapName, sizeof( m_pzMapStart ) );
+			}
+			else
+			{
+				V_strncpy( m_pzMapStart, "No Map Name", sizeof( m_pzMapStart ) );
+			}
+		}
+
+		m_bPassword = event->GetBool( "password" );
+	}
+#ifdef CLIENT_DLL
+	// Started attempting connection to gameserver
+	else if ( FStrEq( "client_beginconnect", pEventName ) )
+	{
+		const char *pszSource = event->GetString( "source", "" );
+		m_nClientJoinMethod = k_ClientJoinMethod_Unknown;
+		if ( pszSource[0] != '\0' )
+		{
+			if ( FStrEq( "listenserver", pszSource ) )                 m_nClientJoinMethod = k_ClientJoinMethod_ListenServer;
+			else if ( FStrEq( "serverbrowser", pszSource ) )           m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowser_UNKNOWN;
+			else if ( FStrEq( "serverbrowser_internet", pszSource ) )  m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserInternet;
+			else if ( FStrEq( "serverbrowser_friends", pszSource ) )   m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserFriends;
+			else if ( FStrEq( "serverbrowser_favorites", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserFavorites;
+			else if ( FStrEq( "serverbrowser_history", pszSource ) )   m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserHistory;
+			else if ( FStrEq( "serverbrowser_lan", pszSource ) )       m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserLAN;
+			else if ( FStrEq( "serverbrowser_spectator", pszSource ) ) m_nClientJoinMethod = k_ClientJoinMethod_ServerBrowserSpectator;
+			else if ( FStrEq( "steam", pszSource ) )                   m_nClientJoinMethod = k_ClientJoinMethod_Steam;
+			else if ( FStrEq( "matchmaking", pszSource ) )             m_nClientJoinMethod = k_ClientJoinMethod_Matchmaking;
+			else if ( FStrEq( "coaching", pszSource ) )                m_nClientJoinMethod = k_ClientJoinMethod_Coaching;
+			else if ( FStrEq( "redirect", pszSource ) )                m_nClientJoinMethod = k_ClientJoinMethod_Redirect;
+			else if ( sscanf( pszSource, "quickplay_%d", &m_nClientJoinMethod ) == 1 )
+				Assert( m_nClientJoinMethod > 0 );
+			else
+				Warning("Unrecognized client_beginconnect event 'source' argument: '%s'\n", pszSource );
+		}
+	}
+	else if ( FStrEq( "client_disconnect", pEventName ) )
+	{
+		ClientDisconnect();
+	}
+#endif
+}
+
+#ifdef CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Purpose:	Sets the server session ID but ONLY if it's not 0. We are using this to avoid a race 
+// 			condition where a server sends their session stats before a client does, thereby,
+//			resetting the client's server session ID to 0.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::SetServerSessionID( uint64 serverSessionID )
+{
+	if ( !serverSessionID )
+		return;
+
+	if ( serverSessionID != m_ActiveSession.m_ServerSessionID )
+	{
+		m_ActiveSession.m_ServerSessionID = serverSessionID;
+		m_ActiveSession.m_ConnectTime = GetTimeSinceEpoch();
+		m_ActiveSession.m_DisconnectTime = 0;
+
+		m_iServerConnectCount++;
+	}
+
+	m_ServerSessionID = serverSessionID;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:	Writes the disconnect time to the current server session entry.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::ClientDisconnect()
+{
+
+	// Save client join method, reset it to make sure it gets set properly
+	// next time and we don't just reuse the current method
+	int nClientJoinMethod = m_nClientJoinMethod;
+	m_nClientJoinMethod = k_ClientJoinMethod_Unknown;
+
+	if ( m_ActiveSession.m_ServerSessionID == 0 )
+		return;
+
+	m_SteamWorksInterface = GetInterface();
+	if ( !m_SteamWorksInterface )
+		return;
+
+	if ( !IsCollectingAnyData() )
+		return;
+
+	uint64 ulRowID = 0;
+	m_SteamWorksInterface->AddNewRow( &ulRowID,	m_SessionID, "ClientSessionLookup" );
+	WriteInt64ToTable(	m_SessionID,							ulRowID,	"SessionID" );
+	WriteInt64ToTable(	m_ActiveSession.m_ServerSessionID,		ulRowID,	"ServerSessionID" );
+	WriteIntToTable(	m_ActiveSession.m_ConnectTime,			ulRowID,	"ConnectTime" );
+	WriteIntToTable(	GetTimeSinceEpoch(),					ulRowID,	"DisconnectTime" );
+	WriteIntToTable(	nClientJoinMethod,						ulRowID,	"ClientJoinMethod" );
+	m_SteamWorksInterface->CommitRow( ulRowID );
+
+	m_ActiveSession.Reset();
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when the level shuts down.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::LevelShutdown()
+{
+#ifdef CLIENT_DLL
+	ClearServerSessionID();
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Requests a session ID from steam.
+//-----------------------------------------------------------------------------
+EResult	CSteamWorksGameStatsUploader::RequestSessionID()
+{
+	// If we have disabled steam works game stats, don't request ids.
+	if ( steamworks_stats_disable )
+	{
+		DevMsg( "Steamworks Stats: No stats collection because steamworks_stats_disable is set to 1.\n" );
+		return k_EResultAccessDenied;
+	}
+
+	if ( developer.GetInt() == 1 )
+	{
+//		DevMsg( "Steamworks Stats: No stats collection because developer is set to 1.\n" );
+//		return k_EResultAccessDenied;
+	}
+
+	// Do not continue if we already have a session id.
+	// We must end a session before we can begin a new one.
+	if ( m_SessionID )
+	{
+		return k_EResultOK;
+	}
+
+	// Do not continue if we are waiting a server response for this session request.
+	if ( m_SessionIDRequestPending )
+	{
+		return k_EResultPending;
+	}
+
+	// If a request is unsent, it will be sent as soon as the steam API is available.
+	m_SessionIDRequestUnsent = true;
+
+	// Turn on polling.
+	m_ServiceTicking = true;
+
+	// If we can't use Steam at the moment, we need to wait.
+	if ( !AccessToSteamAPI() )
+	{
+		return k_EResultNoConnection;
+	}
+
+	m_SteamWorksInterface = GetInterface();
+	if ( m_SteamWorksInterface )
+	{
+		int accountType = k_EGameStatsAccountType_Steam;
+#ifdef GAME_DLL
+		if ( engine->IsDedicatedServer() )
+		{
+			accountType = k_EGameStatsAccountType_SteamGameServer;
+		}
+#endif
+
+#ifdef CLIENT_DLL
+		DevMsg( "Steamworks Stats: Requesting CLIENT session id.\n" );
+#else
+		DevMsg( "Steamworks Stats: Requesting SERVER session id.\n" );
+#endif
+
+		m_SessionIDRequestUnsent = false;
+		m_SessionIDRequestPending = true;
+
+		// This initiates a callback that will get us our session ID.
+		// Callback: Steam_OnSteamSessionInfoIssued
+		m_SteamWorksInterface->GetNewSession( accountType, m_UserID, m_iAppID, GetTimeSinceEpoch() );
+	}
+
+	return k_EResultOK;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Clears our session id and session id convar.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::ClearSessionID()
+{
+	m_SessionID = 0;
+	steamworks_sessionid_server.SetValue( 0 );
+}
+
+#ifndef	NO_STEAM
+
+//-----------------------------------------------------------------------------
+// Purpose: The steam callback used to get our session IDs.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoIssued( GameStatsSessionIssued_t *pGameStatsSessionInfo )
+{
+	if ( !m_SessionIDRequestPending )
+	{
+		// There is no request outstanding.
+		return;
+	}
+
+	m_SessionIDRequestPending = false;
+
+	if ( !pGameStatsSessionInfo )
+	{
+		// Empty callback!
+		ClearSessionID();
+		return;
+	}
+
+	if ( pGameStatsSessionInfo->m_eResult != k_EResultOK )
+	{
+#ifdef CLIENT_DLL
+		DevMsg( "Steamworks Stats: CLIENT session id not available.\n" );
+#else
+		DevMsg( "Steamworks Stats: SERVER session id not available.\n" );
+#endif
+		m_SessionIDRequestUnsent = true; // Queue to re-request a session ID.
+		ClearSessionID();
+		return;
+	}
+
+#ifdef CLIENT_DLL
+	DevMsg( "Steamworks Stats: Received CLIENT session id: %llu\n", pGameStatsSessionInfo->m_ulSessionID );
+#else
+	DevMsg( "Steamworks Stats: Received SERVER session id: %llu\n", pGameStatsSessionInfo->m_ulSessionID );
+#endif
+
+	m_StartTime = GetTimeSinceEpoch();
+
+	m_SessionID = pGameStatsSessionInfo->m_ulSessionID;
+	m_bCollectingAny = pGameStatsSessionInfo->m_bCollectingAny;
+	m_bCollectingDetails = pGameStatsSessionInfo->m_bCollectingDetails;
+
+	char sessionIDString[ 32 ];
+	Q_snprintf( sessionIDString, sizeof( sessionIDString ), "%llu", m_SessionID );
+
+#ifdef CLIENT_DLL
+	steamworks_sessionid_client.SetValue( sessionIDString );
+	m_FriendCntInGame = GetFriendCountInGame();
+	m_HumanCntInGame = GetHumanCountInGame();
+#else
+	steamworks_sessionid_server.SetValue( sessionIDString );
+#endif
+
+	UploadCvars();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The steam callback to notify us that we've submitted stats.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::Steam_OnSteamSessionInfoClosed( GameStatsSessionClosed_t *pGameStatsSessionInfo )
+{
+	if ( !m_UploadedStats )
+		return;
+
+	m_UploadedStats = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Per frame think. Used to periodically check if we have queued operations.
+// For example: we may request a session id before steam is ready.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::FrameUpdatePostEntityThink()
+{
+	if ( !m_ServiceTicking )
+		return;
+
+	if ( gpGlobals->realtime - m_LastServiceTick < 3 )
+		return;
+	m_LastServiceTick = gpGlobals->realtime;
+
+	if ( !AccessToSteamAPI() )
+		return;
+
+	// Try to resend our request.
+	if ( m_SessionIDRequestUnsent )
+	{
+		RequestSessionID();
+		return;
+	}
+
+	// If we had nothing to resend, stop ticking.
+	m_ServiceTicking = false;
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Opens a session: requests the session id, etc.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::StartSession()
+{
+	RequestSessionID();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Completes a session for the given type.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::EndSession()
+{
+	m_EndTime = GetTimeSinceEpoch();
+
+	if ( !m_SessionID )
+	{
+		// No session to end.
+		return;
+	}
+
+	m_SteamWorksInterface = GetInterface();
+	if ( m_SteamWorksInterface )
+	{
+#ifdef CLIENT_DLL
+		DevMsg( "Steamworks Stats: Ending CLIENT session id: %llu\n", m_SessionID );
+#else
+		DevMsg( "Steamworks Stats: Ending SERVER session id: %llu\n", m_SessionID );
+#endif
+
+		// Flush any stats that haven't been sent yet.
+		FlushStats();
+
+		// Always need some data in the session row or we'll crash steam.
+		WriteSessionRow();
+		m_SteamWorksInterface->EndSession( m_SessionID, m_EndTime, 0 );
+		Reset();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Flush any unsent rows.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::FlushStats()
+{
+	for ( int i=0; i<m_StatsToSend.Count(); ++i )
+	{
+		ParseKeyValuesAndSendStats( m_StatsToSend[i] );
+		m_StatsToSend[i]->deleteThis();
+	}
+
+	m_StatsToSend.RemoveAll();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Uploads any end of session rows.
+//-----------------------------------------------------------------------------
+void CSteamWorksGameStatsUploader::WriteSessionRow()
+{
+	m_SteamWorksInterface = GetInterface();
+	if ( !m_SteamWorksInterface )
+		return;
+
+	// The Session row is common to both client and server sessions.
+	// It enables keying to other tables.
+	
+	// Don't send SessionID. It's provided by steam. Same with the account's id and type.
+//	m_SteamWorksInterface->AddSessionAttributeInt64( m_SessionID, "SessionID", m_SessionID );
+
+#ifdef CLIENT_DLL
+//	m_SteamWorksInterface->AddSessionAttributeInt64( m_SessionID, "ServerSessionID", m_ServerSessionID );
+#endif
+
+	m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "AppID", m_iAppID );
+	m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "StartTime", m_StartTime );		
+	m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "EndTime", m_EndTime );
+
+#ifndef CLIENT_DLL
+	m_SteamWorksInterface->AddSessionAttributeString( m_SessionID, "ServerIP", m_pzServerIP );
+	m_SteamWorksInterface->AddSessionAttributeString( m_SessionID, "ServerName", m_pzHostName );
+	m_SteamWorksInterface->AddSessionAttributeString( m_SessionID, "StartMap", m_pzMapStart );
+#endif
+
+#ifdef CLIENT_DLL
+	// TODO CAB: Need to get these added into the clientsessionlookup table
+	m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "PlayersInGame", m_HumanCntInGame );
+	m_SteamWorksInterface->AddSessionAttributeInt( m_SessionID, "FriendsInGame", m_FriendCntInGame );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// DATA ACCESS UTILITIES
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Purpose: Verifies that we have a valid interface and will attempt to obtain a new one if we don't.
+//-----------------------------------------------------------------------------
+bool CSteamWorksGameStatsUploader::VerifyInterface( void )
+{
+	if ( !m_SteamWorksInterface )
+	{
+		m_SteamWorksInterface = GetInterface();
+		if ( !m_SteamWorksInterface )
+		{
+			return false; 
+		}
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Wrapper function to write an int32 to a table given the row name
+//-----------------------------------------------------------------------------
+EResult CSteamWorksGameStatsUploader::WriteIntToTable( const int value, uint64 iTableID, const char *pzRow )
+{
+	if ( !VerifyInterface() )
+		return k_EResultNoConnection;
+
+	return m_SteamWorksInterface->AddRowAttributeInt( iTableID, pzRow, value );	
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Wrapper function to write an int64 to a table given the row name
+//-----------------------------------------------------------------------------
+EResult CSteamWorksGameStatsUploader::WriteInt64ToTable( const uint64 value, uint64 iTableID, const char *pzRow )
+{
+	if ( !VerifyInterface() )
+		return k_EResultNoConnection;
+
+	return m_SteamWorksInterface->AddRowAttributeInt64( iTableID, pzRow, value );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Wrapper function to write an float to a table given the row name
+//-----------------------------------------------------------------------------
+EResult CSteamWorksGameStatsUploader::WriteFloatToTable( const float value, uint64 iTableID, const char *pzRow )
+{
+	if ( !VerifyInterface() )
+		return k_EResultNoConnection;
+
+	return m_SteamWorksInterface->AddRowAttributeFloat( iTableID, pzRow, value );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Wrapper function to write an string to a table given the row name
+//-----------------------------------------------------------------------------
+EResult CSteamWorksGameStatsUploader::WriteStringToTable( const char *value, uint64 iTableID, const char *pzRow )
+{
+	if ( !VerifyInterface() )
+		return k_EResultNoConnection;
+
+	return m_SteamWorksInterface->AddRowAtributeString( iTableID, pzRow, value );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Wrapper function to search a KeyValues for a value with the given keyName and add the result to the 
+// row. If the key isn't present, return ResultNoMatch to indicate such. 
+//-----------------------------------------------------------------------------
+EResult	CSteamWorksGameStatsUploader::WriteOptionalFloatToTable( KeyValues *pKV, const char* keyName, uint64 iTableID, const char *pzRow )
+{
+	if ( !VerifyInterface() )
+		return k_EResultNoConnection;
+
+	KeyValues* key = pKV->FindKey( keyName );
+	if ( !key )
+		return k_EResultNoMatch;
+
+	float value = key->GetFloat();
+
+	return m_SteamWorksInterface->AddRowAttributeFloat( iTableID, pzRow, value );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Wrapper function to search a KeyValues for a value with the given keyName and add the result to the 
+// row. If the key isn't present, return ResultNoMatch to indicate such. 
+//-----------------------------------------------------------------------------
+EResult	CSteamWorksGameStatsUploader::WriteOptionalIntToTable( KeyValues *pKV, const char* keyName, uint64 iTableID, const char *pzRow )
+{
+	if ( !VerifyInterface() )
+		return k_EResultNoConnection;
+
+	KeyValues* key = pKV->FindKey( keyName );
+	if ( !key )
+		return k_EResultNoMatch;
+
+	int value = key->GetInt();
+
+	return m_SteamWorksInterface->AddRowAttributeInt( iTableID, pzRow, value );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// STEAM ACCESS UTILITIES
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Purpose: Determines if the system can connect to steam
+//-----------------------------------------------------------------------------
+bool CSteamWorksGameStatsUploader::AccessToSteamAPI( void )
+{
+#ifdef	GAME_DLL
+	return ( steamgameserverapicontext && steamgameserverapicontext->SteamGameServer() && g_pSteamClientGameServer && steamgameserverapicontext->SteamGameServerUtils() );
+#elif	CLIENT_DLL
+	return ( steamapicontext && steamapicontext->SteamUser() && steamapicontext->SteamUser()->BLoggedOn() && steamapicontext->SteamFriends() && steamapicontext->SteamMatchmaking() );
+#endif
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: There's no guarantee that your interface pointer will persist across level transitions,
+//			so this function will update your interface.
+//-----------------------------------------------------------------------------
+ISteamGameStats* CSteamWorksGameStatsUploader::GetInterface( void )
+{
+	HSteamUser hSteamUser = 0;
+	HSteamPipe hSteamPipe = 0;
+
+#ifdef	GAME_DLL
+	if ( steamgameserverapicontext && steamgameserverapicontext->SteamGameServer() && steamgameserverapicontext->SteamGameServerUtils() )
+	{
+		m_UserID = steamgameserverapicontext->SteamGameServer()->GetSteamID().ConvertToUint64();
+		m_iAppID = steamgameserverapicontext->SteamGameServerUtils()->GetAppID();
+		hSteamUser = SteamGameServer_GetHSteamUser();
+		hSteamPipe = SteamGameServer_GetHSteamPipe();
+	}
+
+	// Now let's get the interface for dedicated servers
+	if ( g_pSteamClientGameServer && engine && (/*engine->IsDedicatedServerForXbox() ||*/ engine->IsDedicatedServer()) )
+	{
+		return (ISteamGameStats*)g_pSteamClientGameServer->GetISteamGenericInterface( hSteamUser, hSteamPipe, STEAMGAMESTATS_INTERFACE_VERSION );
+	}	
+#elif	CLIENT_DLL
+	if ( steamapicontext && steamapicontext->SteamUser() && steamapicontext->SteamUtils() )
+	{
+		m_UserID = steamapicontext->SteamUser()->GetSteamID().ConvertToUint64();
+		m_iAppID = steamapicontext->SteamUtils()->GetAppID();
+		hSteamUser = steamapicontext->SteamUser()->GetHSteamUser();
+		hSteamPipe = GetHSteamPipe();
+	}
+#endif
+
+	// Listen server have access to SteamClient
+	if ( SteamClient() )
+	{
+		return (ISteamGameStats*)SteamClient()->GetISteamGenericInterface( hSteamUser, hSteamPipe, STEAMGAMESTATS_INTERFACE_VERSION );
+	}
+	// If we haven't returned already, then we can't get access to the interface
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates a table from the KeyValue file. Do NOT send nested KeyValue objects into this function!
+//-----------------------------------------------------------------------------
+EResult CSteamWorksGameStatsUploader::AddStatsForUpload( KeyValues *pKV, bool bSendImmediately )
+{
+	// If the stat system is disabled, then don't accept the keyvalue
+	if ( steamworks_stats_disable )
+	{
+		if ( pKV )
+		{
+			pKV->deleteThis();
+		}
+
+		return k_EResultNoConnection;
+	}
+
+	if ( pKV )
+	{
+		// Do we want to immediately upload the stats?
+		if ( bSendImmediately && steamworks_immediate_upload )
+		{
+			ParseKeyValuesAndSendStats( pKV );
+			pKV->deleteThis();
+		}
+		else
+		{
+			m_StatsToSend.AddToTail( pKV );
+		}
+		return k_EResultOK;
+	}
+
+	return k_EResultFail;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Parses all the keyvalue files we've been sent and creates tables from them and uploads them
+//-----------------------------------------------------------------------------
+double g_rowCommitTime = 0.0f;
+double g_rowWriteTime = 0.0f;
+EResult CSteamWorksGameStatsUploader::ParseKeyValuesAndSendStats( KeyValues *pKV, bool bIncludeClientsServerSessionID )
+{
+	if ( !pKV )
+	{
+		return k_EResultFail;
+	}
+
+	if ( !IsCollectingAnyData() )
+	{
+		return k_EResultFail;
+	}
+
+	// Refresh the interface in case steam has unloaded
+	m_SteamWorksInterface = GetInterface();
+
+	if ( !m_SteamWorksInterface )
+	{
+		DevMsg( "WARNING: Attempted to send a steamworks gamestats row when the steamworks interface was not available!" );
+		return k_EResultNoConnection;
+	}
+
+	const char *pzTable = pKV->GetName();
+/*
+	if ( steamworks_show_uploads )
+	{
+#ifdef	CLIENT_DLL
+//		DevMsg( "Client submitting row (%s).\n", pzTable );
+#elif	GAME_DLL
+//		DevMsg( "Server submitting row (%s).\n", pzTable );
+#endif
+	}
+*/
+	uint64 iTableID = 0;
+	m_SteamWorksInterface->AddNewRow( &iTableID, m_SessionID, pzTable );
+
+	if ( !iTableID )
+	{
+		return k_EResultFail;
+	}
+
+	WriteInt64ToTable( m_SessionID, iTableID, "SessionID" );
+#ifdef	CLIENT_DLL
+	if ( bIncludeClientsServerSessionID )
+	{
+		WriteInt64ToTable( m_ServerSessionID, iTableID, "ServerSessionID" );
+	}
+#endif
+
+	// Now we need to loop over all the keys in pKV and add the name and value
+	for ( KeyValues *pData = pKV->GetFirstSubKey() ; pData != NULL ; pData = pData->GetNextKey() )
+	{
+		const char *name = pData->GetName();
+
+		CFastTimer writeTimer;
+		writeTimer.Start();
+		switch ( pData->GetDataType() )
+		{
+		case KeyValues::TYPE_STRING:	WriteStringToTable( pKV->GetString( name ), iTableID, name );
+			break;
+		case KeyValues::TYPE_INT:		WriteIntToTable( pKV->GetInt( name ), iTableID, name );
+			break;
+		case KeyValues::TYPE_FLOAT:		WriteFloatToTable( pKV->GetFloat( name ), iTableID, name );
+			break;
+		case KeyValues::TYPE_UINT64:	WriteInt64ToTable( pKV->GetUint64( name ), iTableID, name );
+			break;
+		};
+
+		writeTimer.End();
+		g_rowWriteTime += writeTimer.GetDuration().GetMillisecondsF();
+	}
+
+	CFastTimer commitTimer;
+	commitTimer.Start();
+	EResult res = m_SteamWorksInterface->CommitRow( iTableID );
+	commitTimer.End();
+	g_rowCommitTime += commitTimer.GetDuration().GetMillisecondsF();
+
+	if ( res != k_EResultOK )
+	{
+		AssertMsg( false, "Failed To Submit table %s", pzTable );
+	}
+	return res;
+}
+
+#ifdef	CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: Reports client's perf data at the end of a client session.
+//---------------------------------`--------------------------------------------
+void CSteamWorksGameStatsUploader::AddClientPerfData( KeyValues *pKV )
+{
+	m_SteamWorksInterface = GetInterface();
+	if ( !m_SteamWorksInterface )
+		return;
+
+	if ( !IsCollectingAnyData() )
+		return;
+
+	RTime32 currentTime = GetTimeSinceEpoch();
+
+	uint64 uSessionID = m_SessionID;
+	uint64 ulRowID = 0;
+
+	m_SteamWorksInterface->AddNewRow( &ulRowID, uSessionID, "TF2ClientPerfData" );
+
+	if ( !ulRowID )
+		return;
+
+	WriteInt64ToTable(	m_SessionID,						ulRowID,	"SessionID" );
+//	WriteInt64ToTable(	m_ServerSessionID,					ulRowID,	"ServerSessionID" );
+	WriteIntToTable(	currentTime,						ulRowID,	"TimeSubmitted" );
+	WriteStringToTable( pKV->GetString( "Map/mapname" ),	ulRowID,	"MapID");
+	WriteIntToTable(	pKV->GetInt( "appid" ),				ulRowID,	"AppID");
+	WriteFloatToTable(	pKV->GetFloat( "Map/perfdata/AvgFPS" ), ulRowID, "AvgFPS");
+	WriteFloatToTable(	pKV->GetFloat( "map/perfdata/MinFPS" ), ulRowID, "MinFPS");
+	WriteFloatToTable(	pKV->GetFloat( "Map/perfdata/MaxFPS" ), ulRowID, "MaxFPS");
+	WriteFloatToTable(	pKV->GetFloat( "Map/perfdata/StdDevFPS" ), ulRowID, "StdDevFPS");
+
+	WriteStringToTable( pKV->GetString( "CPUID" ),			ulRowID,	"CPUID");
+	WriteFloatToTable(	pKV->GetFloat( "CPUGhz" ),			ulRowID,	"CPUGhz");
+	WriteInt64ToTable( pKV->GetUint64( "CPUModel" ),		ulRowID, "CPUModel" );
+	WriteInt64ToTable( pKV->GetUint64( "CPUFeatures0" ),	ulRowID, "CPUFeatures0" );
+	WriteInt64ToTable( pKV->GetUint64( "CPUFeatures1" ),	ulRowID, "CPUFeatures1" );
+	WriteInt64ToTable( pKV->GetUint64( "CPUFeatures2" ),	ulRowID, "CPUFeatures2" );
+
+	WriteIntToTable(	pKV->GetInt( "NumCores" ),			ulRowID,	"NumCores");
+	WriteStringToTable( pKV->GetString( "GPUDrv" ),			ulRowID,	"GPUDrv");
+	WriteIntToTable(	pKV->GetInt( "GPUVendor" ),			ulRowID,	"GPUVendor");
+	WriteIntToTable(	pKV->GetInt( "GPUDeviceID" ),		ulRowID,	"GPUDeviceID");
+	WriteIntToTable(	pKV->GetInt( "GPUDriverVersion" ),	ulRowID,	"GPUDriverVersion");
+	WriteIntToTable(	pKV->GetInt( "DxLvl" ),				ulRowID,	"DxLvl");
+	WriteIntToTable(	pKV->GetBool( "Map/Windowed" ),		ulRowID,	"Windowed");
+//	WriteIntToTable(	pKV->GetBool( "Map/WindowedNoBorder" ), ulRowID, "WindowedNoBorder");
+	WriteIntToTable(	pKV->GetInt( "width" ),				ulRowID,	"Width");
+	WriteIntToTable(	pKV->GetInt( "height" ),			ulRowID,	"Height");
+	WriteIntToTable(	pKV->GetInt( "Map/UsedVoice" ),		ulRowID,	"Usedvoiced");
+	WriteStringToTable( pKV->GetString( "Map/Language" ),	ulRowID,	"Language");
+	WriteFloatToTable(	pKV->GetFloat( "Map/perfdata/AvgServerPing" ),	ulRowID, "AvgServerPing");
+	WriteIntToTable(	pKV->GetInt( "Map/Caption" ),		ulRowID,	"IsCaptioned");
+	WriteIntToTable(	pKV->GetInt( "IsPC" ),				ulRowID,	"IsPC");
+	WriteIntToTable(	pKV->GetBool( "Windowed" ),			ulRowID,	"Windowed");
+	WriteIntToTable(	pKV->GetInt( "Map/Cheats" ),		ulRowID,	"Cheats");
+	WriteIntToTable(	pKV->GetInt( "Map/MapTime" ),		ulRowID,	"MapTime");
+	WriteIntToTable(	pKV->GetInt( "MaxDxLevel" ),		ulRowID,	"MaxDxLvl" );
+
+	WriteIntToTable( pKV->GetBool( "Map/SteamControllerActive" ), ulRowID, "UsingController" );
+	
+	// Loading time information
+
+	// If a player exits a map and then exits the game, LoadTimeMap will not be in the key list the second time
+	// (when we are sending for app shutdown), so only write it if it's here.
+	WriteOptionalFloatToTable( pKV,  "Map/LoadTimeMap",			ulRowID,	"SessionLoadTime");
+
+	// Main menu load time is only added once, even if we play many games in a row. This prevents a stats bias for
+	// people who replay over and over again.
+	WriteOptionalFloatToTable( pKV,  "Map/LoadTimeMainMenu",	ulRowID,	"MainmenuLoadTime");
+
+	m_SteamWorksInterface->CommitRow( ulRowID );
+}
+#endif
+
+//-------------------------------------------------------------------------------------------------
+/**
+*	Purpose:	Calculates the number of humans in the game
+*/
+int CSteamWorksGameStatsUploader::GetHumanCountInGame()
+{
+	int iHumansInGame = 0;
+	// TODO: Need to add server/client code to count the number of connected humans.
+	return iHumansInGame;
+}
+
+#ifdef	CLIENT_DLL
+//-------------------------------------------------------------------------------------------------
+/**
+*	Purpose:	Calculates the number of friends in the game
+*/
+int CSteamWorksGameStatsUploader::GetFriendCountInGame()
+{
+	// Get the number of steam friends in game
+	int friendsInOurGame = 0;
+
+
+	// Do we have access to the steam API?
+	if ( AccessToSteamAPI() )
+	{
+		CSteamID m_SteamID = steamapicontext->SteamUser()->GetSteamID();
+		// Let's get our game info so we can use that to test if our friends are connected to the same game as us
+		FriendGameInfo_t myGameInfo;
+		steamapicontext->SteamFriends()->GetFriendGamePlayed( m_SteamID, &myGameInfo );
+		CSteamID myLobby = steamapicontext->SteamMatchmaking()->GetLobbyOwner( myGameInfo.m_steamIDLobby );
+
+		// This returns the number of friends that are playing a game
+		int activeFriendCnt = steamapicontext->SteamFriends()->GetFriendCount( k_EFriendFlagImmediate );
+
+		// Check each active friend's lobby ID to see if they are in our game
+		for ( int h=0; h< activeFriendCnt ; ++h )
+		{
+			FriendGameInfo_t friendInfo;
+			CSteamID friendID = steamapicontext->SteamFriends()->GetFriendByIndex( h, k_EFriendFlagImmediate );
+
+			if ( steamapicontext->SteamFriends()->GetFriendGamePlayed( friendID, &friendInfo ) )
+			{
+				// Does our friend have a valid lobby ID?
+				if ( friendInfo.m_gameID.IsValid() )
+				{
+					// Get our friend's lobby info
+					CSteamID friendLobby = steamapicontext->SteamMatchmaking()->GetLobbyOwner( friendInfo.m_steamIDLobby );
+
+					// Double check the validity of the friend lobby ID then check to see if they are in our game
+					if ( friendLobby.IsValid() && myLobby == friendLobby )
+					{
+						++friendsInOurGame;
+					}
+				}
+			}
+		}
+	}
+
+	return friendsInOurGame;
+}
+#endif
+
+void CSteamWorksGameStatsUploader::ServerAddressToInt()
+{
+	CUtlStringList IPs;
+	V_SplitString( m_pzServerIP, ".", IPs );
+
+	if ( IPs.Count() < 4 )
+	{
+		// Not an actual IP.
+		m_iServerIP = 0;
+		return;
+	}
+
+	byte ip[4];
+	m_iServerIP = 0;
+	for ( int i=0; i<IPs.Count() && i<4; ++i )
+	{
+		ip[i] = (byte) Q_atoi( IPs[i] );
+	}
+	m_iServerIP = (ip[0]<<24) + (ip[1]<<16) + (ip[2]<<8) + ip[3];
+}
+
diff --git a/game/shared/steamworks_gamestats.h b/game/shared/steamworks_gamestats.h
new file mode 100644
index 00000000..a1c3d61c
--- /dev/null
+++ b/game/shared/steamworks_gamestats.h
@@ -0,0 +1,193 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Uploads gamestats via the SteamWorks API. 
+//
+//=============================================================================//
+
+#ifndef STEAMWORKS_GAMESTATS_H
+#define STEAMWORKS_GAMESTATS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "igamesystem.h"
+#include "GameEventListener.h"
+#include "steam/steam_api.h"
+#include "utlvector.h"
+
+#ifndef	_X360
+#include "steam/isteamgamestats.h"
+#endif
+
+// Container to hold all the KeyValue stats to send only if the convar "steamworks_immediate_upload" is set to 0.
+// Otherwise, the stats are uploaded as they are received.
+typedef CUtlVector< KeyValues* > KeyValueStatList;
+
+struct ClientServerSession_t
+{
+	uint64				m_ServerSessionID;
+	RTime32				m_ConnectTime;
+	RTime32				m_DisconnectTime;
+
+	void Reset()
+	{
+		m_ServerSessionID = 0;
+		m_ConnectTime = 0;
+		m_DisconnectTime = 0;
+	}
+};
+
+//used to drive most of the game stat event handlers as well as track basic stats under the hood of CBaseGameStats
+class CSteamWorksGameStatsUploader : public CAutoGameSystemPerFrame, public CGameEventListener
+{
+public:
+
+#ifdef	CLIENT_DLL
+	// Called before rendering
+	virtual void PreRender() {}
+
+	// Gets called each frame
+	virtual void Update( float frametime ) {}
+
+	// Called after rendering
+	virtual void PostRender() {}
+
+	void AddClientPerfData( KeyValues *pKV );
+	void SetServerSessionID( uint64 serverID );
+	int	GetFriendCountInGame();
+
+#ifndef	NO_STEAM
+	STEAM_CALLBACK_MANUAL( CSteamWorksGameStatsUploader, Steam_OnSteamSessionInfoIssued, GameStatsSessionIssued_t, m_CallbackSteamSessionInfoIssued );
+	STEAM_CALLBACK_MANUAL( CSteamWorksGameStatsUploader, Steam_OnSteamSessionInfoClosed, GameStatsSessionClosed_t, m_CallbackSteamSessionInfoClosed );	
+#endif
+
+#endif
+
+#ifdef GAME_DLL
+#ifndef	NO_STEAM
+	STEAM_GAMESERVER_CALLBACK( CSteamWorksGameStatsUploader, Steam_OnSteamSessionInfoIssued, GameStatsSessionIssued_t, m_CallbackSteamSessionInfoIssued );
+	STEAM_GAMESERVER_CALLBACK( CSteamWorksGameStatsUploader, Steam_OnSteamSessionInfoClosed, GameStatsSessionClosed_t, m_CallbackSteamSessionInfoClosed );	
+#endif
+#endif
+
+	// Called each frame before entities think
+	virtual void FrameUpdatePreEntityThink() {}
+	// called after entities think
+	virtual void FrameUpdatePostEntityThink();
+	virtual void PreClientUpdate() {}
+
+	void StartSession();
+	void EndSession();
+
+	void WriteSessionRow();
+
+#ifdef GAME_DLL
+	void WriteHostsRow();
+#endif
+
+#ifdef CLIENT_DLL
+	void ClientDisconnect();
+	void ClearServerSessionID() { m_ServerSessionID = 0 ;}
+	int  GetNumServerConnects() { return m_iServerConnectCount; }		
+#endif
+
+	bool IsCollectingDetails() { return m_bCollectingDetails; }
+	bool IsCollectingAnyData() { return m_bCollectingAny; }
+
+	CSteamWorksGameStatsUploader();
+
+	// Init, shutdown
+	// return true on success. false to abort DLL init!
+	virtual bool Init();
+	virtual void PostInit() {}
+	virtual void Shutdown() {}
+
+	// Level init, shutdown
+	virtual void LevelInitPreEntity() {}
+	virtual void LevelInitPostEntity() {}
+	virtual void LevelShutdown();
+
+	virtual void OnSave() {}
+	virtual void OnRestore() {}
+	virtual void SafeRemoveIfDesired() {}
+
+	virtual bool IsPerFrame() { return true; }
+
+	virtual void FireGameEvent( IGameEvent *event );
+	EResult		AddStatsForUpload( KeyValues *pKV, bool bSendImmediately=true );
+	time_t		GetTimeSinceEpoch();
+	void		FlushStats();
+
+	uint32 GetServerIP() { return m_iServerIP; }
+	const char* GetHostName() { return m_pzHostName; }
+	bool IsPassworded() { return m_bPassword; }
+	RTime32 GetStartTime() { return m_StartTime; }
+	RTime32 GetEndTime() { return m_EndTime; }
+
+#ifdef	CLIENT_DLL
+	uint64 GetServerSessionID() { return m_ServerSessionID; }
+#endif
+
+	uint64		GetSessionID() { return m_SessionID; }
+	void		ClearSessionID();
+
+private:
+	void		UploadCvars();
+	void		Reset();
+	bool		VerifyInterface();
+	int			GetHumanCountInGame();
+
+	EResult		RequestSessionID();
+
+	bool		AccessToSteamAPI();
+	EResult		WriteIntToTable( const int value, uint64 iTableID, const char *pzRow );
+	EResult		WriteInt64ToTable( const uint64 value, uint64 iTableID, const char *pzRow );
+	EResult		WriteFloatToTable( const float value, uint64 iTableID, const char *pzRow );
+	EResult		WriteStringToTable( const char *pzValue, uint64 iTableID, const char *pzRow );
+	EResult		WriteOptionalFloatToTable( KeyValues *pKV, const char* keyName, uint64 iTableID, const char *pzRow);
+	EResult		WriteOptionalIntToTable( KeyValues *pKV, const char* keyName, uint64 iTableID, const char *pzRow );
+
+	ISteamGameStats* GetInterface( void );	
+	EResult		ParseKeyValuesAndSendStats( KeyValues *pKV, bool bIncludeClientsServerSessionID = true );
+	void		ServerAddressToInt();
+
+	ISteamGameStats*	m_SteamWorksInterface;
+
+	uint64				m_UserID;
+	uint32				m_iAppID;
+	uint32				m_iServerIP;
+	int					m_nClientJoinMethod;
+	char				m_pzServerIP[MAX_PATH];
+	char				m_pzMapStart[MAX_PATH];
+	char				m_pzHostName[MAX_PATH];
+	RTime32				m_StartTime;
+	RTime32				m_EndTime;
+	int					m_HumanCntInGame;
+	int					m_FriendCntInGame;
+	bool				m_bPassword;
+
+	// Session IDs
+	uint64				m_SessionID;
+	bool				m_SessionIDRequestUnsent;
+	bool				m_SessionIDRequestPending;
+	bool				m_bCollectingAny;
+	bool				m_bCollectingDetails;
+
+#ifdef	CLIENT_DLL
+	uint64				m_ServerSessionID;
+#endif
+
+	bool				m_ServiceTicking;
+	float				m_LastServiceTick;
+
+	bool				m_UploadedStats;
+
+	KeyValueStatList	m_StatsToSend;
+
+	ClientServerSession_t m_ActiveSession;
+	int					m_iServerConnectCount;
+};
+
+CSteamWorksGameStatsUploader& GetSteamWorksSGameStatsUploader();
+
+#endif // STEAMWORKS_GAMESTATS_H
diff --git a/lib/android/armeabi-v7a/libandroid_support.a b/lib/android/armeabi-v7a/libandroid_support.a
index 9f833a4d..5b0e07e5 100644
Binary files a/lib/android/armeabi-v7a/libandroid_support.a and b/lib/android/armeabi-v7a/libandroid_support.a differ
diff --git a/lib/android/armeabi-v7a/libopus.a b/lib/android/armeabi-v7a/libopus.a
new file mode 100644
index 00000000..f81ee9bc
Binary files /dev/null and b/lib/android/armeabi-v7a/libopus.a differ