1HEADmaster

252 files changed, 45841 insertions, 0 deletions

diff --git a/game/client/tf2/ObjectBuildAlphaProxy.cpp b/game/client/tf2/ObjectBuildAlphaProxy.cpp
new file mode 100644
index 0000000..a25add8
--- /dev/null
+++ b/game/client/tf2/ObjectBuildAlphaProxy.cpp
@@ -0,0 +1,117 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "proxyentity.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialvar.h"
+#include "c_baseobject.h"
+#include <KeyValues.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CObjectBuildAlphaProxy : public CEntityMaterialProxy
+{
+public:
+	CObjectBuildAlphaProxy();
+	virtual ~CObjectBuildAlphaProxy();
+	virtual bool Init( IMaterial *pMaterial, KeyValues* pKeyValues );
+	virtual void OnBind( C_BaseEntity *pC_BaseEntity );
+
+private:
+	IMaterialVar* m_pAlphaVar;
+
+	float		buildstart;
+	float		buildend;
+};
+
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+
+CObjectBuildAlphaProxy::CObjectBuildAlphaProxy()
+{
+	m_pAlphaVar = 0;
+}
+
+CObjectBuildAlphaProxy::~CObjectBuildAlphaProxy()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Init baby...
+//-----------------------------------------------------------------------------
+bool CObjectBuildAlphaProxy::Init( IMaterial *pMaterial, KeyValues* pKeyValues )
+{
+
+	bool foundVar;
+	m_pAlphaVar = pMaterial->FindVar( "$alpha", &foundVar, false );
+	if( !foundVar )
+	{
+		m_pAlphaVar = 0;
+	}
+
+	buildstart = pKeyValues->GetFloat( "buildstart", 1.0f );
+	buildend = pKeyValues->GetFloat( "buildfinish", 1.0f );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Set the appropriate texture...
+//-----------------------------------------------------------------------------
+void CObjectBuildAlphaProxy::OnBind( C_BaseEntity *pEntity )
+{
+	if( !m_pAlphaVar )
+		return;
+	
+	// It needs to be a TF2 C_BaseObject to have this proxy applied
+	C_BaseObject *pObject = dynamic_cast< C_BaseObject * >( pEntity );
+	if ( !pObject )
+		return;
+
+	float build_amount = pObject->GetCycle(); //pObject->GetPercentageConstructed();
+	float frac;
+
+	if ( build_amount <= buildstart )
+	{
+		frac = 0.0f;
+	}
+	else if ( build_amount >= buildend )
+	{
+		frac = 1.0f;
+	}
+	else
+	{
+		// Avoid div by zero
+		if ( buildend == buildstart )
+		{
+			frac = 1.0f;
+		}
+		else
+		{
+			frac = ( build_amount - buildstart ) / ( buildend - buildstart );
+			frac = clamp( frac, 0.0f, 1.0f );
+		}
+	}
+
+	if ( !pObject->IsBuilding() )
+	{
+		frac = 1.0f;
+	}
+
+	m_pAlphaVar->SetFloatValue( frac );
+}
+
+EXPOSE_INTERFACE( CObjectBuildAlphaProxy, IMaterialProxy, "TFObjectBuildAlpha" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
diff --git a/game/client/tf2/ObjectControlPanel.cpp b/game/client/tf2/ObjectControlPanel.cpp
new file mode 100644
index 0000000..eef89b0
--- /dev/null
+++ b/game/client/tf2/ObjectControlPanel.cpp
@@ -0,0 +1,355 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Controls.h>
+#include <vgui_controls/Label.h>
+#include "vgui_bitmapbutton.h"
+#include <vgui/ISurface.h>
+#include <vgui/IVGui.h>
+#include "C_BaseTFPlayer.h"
+#include "clientmode_tfbase.h"
+#include <vgui/IScheme.h>
+#include <vgui_controls/Slider.h>
+#include "vgui_rotation_slider.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+#define DISMANTLE_WAIT_TIME 5.0
+
+
+//-----------------------------------------------------------------------------
+// Standard VGUI panel for objects 
+//-----------------------------------------------------------------------------
+DECLARE_VGUI_SCREEN_FACTORY( CObjectControlPanel, "object_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CObjectControlPanel::CObjectControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, panelName, g_hVGuiObjectScheme ) 
+{
+	// Make some high-level panels to group stuff we want to activate/deactivate
+	m_pActivePanel = new CCommandChainingPanel( this, "ActivePanel" );
+	m_pDeterioratingPanel = new CCommandChainingPanel( this, "DeterioratingPanel" );
+	m_pDismantlingPanel = new CCommandChainingPanel( this, "DismantlingPanel" );
+
+	SetCursor( vgui::dc_none ); // don't draw a VGUI cursor for this panel, and for its children
+
+	// Make sure these are behind everything
+	m_pActivePanel->SetZPos( -1 );
+	m_pDeterioratingPanel->SetZPos( -1 );
+	m_pDismantlingPanel->SetZPos( -1 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CObjectControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	// Grab ahold of certain well-known controls
+	m_pHealthLabel = new vgui::Label( this, "HealthReadout", "" );
+	m_pOwnerLabel = new vgui::Label( this, "OwnerReadout", "" );
+	m_pDismantleButton = new CBitmapButton( this, "DismantleButton", "Dismantle" );
+	m_pAssumeControlButton = new CBitmapButton( GetDeterioratingPanel(), "AssumeControl", "" );
+	m_pDismantleTimeLabel = new vgui::Label( GetDismantlingPanel(), "DismantleTime", "" );
+
+	m_flDismantleTime = -1;
+
+	// Make sure we get ticked...
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	SetCursor( vgui::dc_none ); // don't draw a VGUI cursor for this panel, and for its children
+
+	// Make the bounds of the sub-panels match
+	int x, y, w, h;
+	GetBounds( x, y, w, h );
+	m_pActivePanel->SetBounds( x, y, w, h );
+	m_pDeterioratingPanel->SetBounds( x, y, w, h );
+	m_pDismantlingPanel->SetBounds( x, y, w, h );
+
+	// Make em all invisible
+	m_pActivePanel->SetVisible( false );
+	m_pDeterioratingPanel->SetVisible( false );
+	m_pDismantlingPanel->SetVisible( false );
+	m_pCurrentPanel = m_pActivePanel;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the object it's attached to 
+//-----------------------------------------------------------------------------
+C_BaseObject *CObjectControlPanel::GetOwningObject() const
+{
+	C_BaseEntity *pScreenEnt = GetEntity();
+	if (!pScreenEnt)
+		return NULL;
+
+	C_BaseEntity *pObj = pScreenEnt->GetOwnerEntity();
+	if (!pObj)
+		return NULL;
+
+	Assert( dynamic_cast<C_BaseObject*>(pObj) );
+	return static_cast<C_BaseObject*>(pObj);
+}
+
+
+//-----------------------------------------------------------------------------
+// Ticks the panel when its in its various states
+//-----------------------------------------------------------------------------
+
+void CObjectControlPanel::OnTickDeteriorating( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer )
+{
+	char buf[256];
+	if ( pLocalPlayer && ClassCanBuild( pLocalPlayer->PlayerClass(), pObj->GetType() ) )
+	{
+		int nCost = CalculateObjectCost( pObj->GetType(), pLocalPlayer->GetNumObjects( pObj->GetType() ), pLocalPlayer->GetTeamNumber() );
+		Q_snprintf( buf, sizeof( buf ), "Buy for %d", nCost );
+		m_pAssumeControlButton->SetText( buf );
+		m_pAssumeControlButton->SetVisible( true );
+
+		bool bHasEnoughResources = pLocalPlayer->GetBankResources() >= nCost;
+		m_pAssumeControlButton->SetEnabled( bHasEnoughResources ); 
+	}
+	else
+	{
+		m_pAssumeControlButton->SetVisible( false );
+	}
+
+	ShowDismantleButton( false );
+}
+
+void CObjectControlPanel::OnTickActive( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer )
+{
+	ShowDismantleButton( !(pObj->GetFlags() & OF_CANNOT_BE_DISMANTLED) && pObj->GetOwner() == pLocalPlayer );
+}
+
+void CObjectControlPanel::OnTickDismantling( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer )
+{
+	ShowDismantleButton( false );
+	if ( !m_bDismantled && (gpGlobals->curtime >= m_flDismantleTime))
+	{
+		Dismantle();
+		m_bDismantled = true;
+	}
+
+	int nSec = (int)(m_flDismantleTime - gpGlobals->curtime + 0.5f);
+	if (nSec < 0)
+		nSec = 0;
+
+	char buf[256];
+	int nLen = Q_snprintf( buf, sizeof( buf ), "%d second", nSec );
+	if (nSec != 1)
+	{
+		buf[nLen] = 's';
+		++nLen;
+		buf[nLen] = 0;
+	}
+
+	m_pDismantleTimeLabel->SetText( buf );
+}
+
+
+vgui::Panel* CObjectControlPanel::TickCurrentPanel()
+{
+	C_BaseTFPlayer *pLocalPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	C_BaseObject *pObj = GetOwningObject();
+
+	if (IsDismantling())
+	{
+		m_pCurrentPanel = GetDismantlingPanel();
+
+		OnTickDismantling(pObj, pLocalPlayer);
+	}
+	else if (pObj->IsDeteriorating())
+	{
+		m_pCurrentPanel = GetDeterioratingPanel();
+
+		OnTickDeteriorating(pObj, pLocalPlayer);
+	}
+	else
+	{
+		m_pCurrentPanel = GetActivePanel();
+
+		OnTickActive(pObj, pLocalPlayer);
+	}
+	
+	return m_pCurrentPanel;
+}
+
+
+void CObjectControlPanel::ShowDismantleButton( bool bShow )
+{
+	m_pDismantleButton->SetVisible( bShow );
+}
+
+
+void CObjectControlPanel::ShowOwnerLabel( bool bShow )
+{
+	m_pOwnerLabel->SetVisible( bShow );
+}
+
+
+void CObjectControlPanel::ShowHealthLabel( bool bShow )
+{
+	m_pHealthLabel->SetVisible( bShow );
+}
+
+
+void CObjectControlPanel::SendToServerObject( const char *pMsg )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( pMsg );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CObjectControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	char buf[256];
+	Q_snprintf( buf, sizeof( buf ), "Health: %d%%", (int)(pObj->HealthFraction() * 100.0f) );
+	m_pHealthLabel->SetText( buf );
+
+	C_BaseTFPlayer *pPlayer = pObj->GetOwner();
+	if (pPlayer)
+	{
+		Q_snprintf( buf, sizeof( buf ), "Owner: %s", pPlayer->GetPlayerName() );
+	}
+	else
+	{
+		Q_snprintf( buf, sizeof( buf ), "No Owner" );
+	}
+
+	m_pOwnerLabel->SetText( buf );
+
+	// Update the current subpanel
+	m_pCurrentPanel->SetVisible( false );
+	
+	m_pCurrentPanel = TickCurrentPanel();
+
+	m_pCurrentPanel->SetVisible( true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Dismantles the object 
+//-----------------------------------------------------------------------------
+void CObjectControlPanel::Dismantle()
+{
+	SendToServerObject( "dismantle" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Starts/stops dismantling
+//-----------------------------------------------------------------------------
+void CObjectControlPanel::StartDismantling()
+{
+	m_flDismantleTime = gpGlobals->curtime + DISMANTLE_WAIT_TIME;
+	m_bDismantled = false;
+}
+
+void CObjectControlPanel::StopDismantling()
+{
+	m_flDismantleTime = -1.0f;
+}
+
+bool CObjectControlPanel::IsDismantling() const
+{
+	return m_flDismantleTime >= 0.0f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Assumes control of the object 
+//-----------------------------------------------------------------------------
+void CObjectControlPanel::AssumeControl()
+{
+	SendToServerObject( "takecontrol" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CObjectControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Dismantle", 10))
+	{
+		StartDismantling();
+		return;
+	}
+
+	if (!Q_strnicmp(command, "CancelDismantle", 20))
+	{
+		StopDismantling();
+		return;
+	}
+
+	if (!Q_strnicmp(command, "AssumeControl", 15))
+	{
+		AssumeControl();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CRotatingObjectControlPanel, "rotating_object_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// This is a panel for an object that has rotational controls 
+//-----------------------------------------------------------------------------
+CRotatingObjectControlPanel::CRotatingObjectControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, panelName ) 
+{
+}
+
+bool CRotatingObjectControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	// Grab ahold of certain well-known controls
+	m_pRotationSlider = new CRotationSlider( GetActivePanel(), "RotationSlider" );
+	m_pRotationLabel = new vgui::Label( GetActivePanel(), "RotationLabel", "Rotation Control" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	m_pRotationSlider->SetControlledObject( GetOwningObject() );
+
+	return true;
+}
+
+void CRotatingObjectControlPanel::OnTickActive( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer )
+{
+	BaseClass::OnTickActive( pObj, pLocalPlayer );
+	bool bEnable = (pObj->GetOwner() == pLocalPlayer);
+	m_pRotationSlider->SetVisible( bEnable );
+	m_pRotationLabel->SetVisible( bEnable );
+}
+
diff --git a/game/client/tf2/ObjectControlPanel.h b/game/client/tf2/ObjectControlPanel.h
new file mode 100644
index 0000000..c1de4ec
--- /dev/null
+++ b/game/client/tf2/ObjectControlPanel.h
@@ -0,0 +1,135 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Clients CBaseObject
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef OBJECTCONTROLPANEL_H
+#define OBJECTCONTROLPANEL_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_vguiscreen.h"
+
+namespace vgui
+{
+	class Panel;
+	class Label;
+	class Button;
+}
+
+class C_BaseObject;
+class CRotationSlider;
+class C_BaseTFPlayer;
+
+//-----------------------------------------------------------------------------
+// Base class for all vgui screens on objects: 
+//-----------------------------------------------------------------------------
+class CObjectControlPanel : public CVGuiScreenPanel
+{
+	DECLARE_CLASS( CObjectControlPanel, CVGuiScreenPanel );
+
+public:
+	CObjectControlPanel( vgui::Panel *parent, const char *panelName );
+
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnCommand( const char *command );
+	virtual void OnTick();
+
+protected:
+	// Method to add controls to particular panels
+	vgui::Panel *GetActivePanel() { return m_pActivePanel; }
+	vgui::Panel *GetDeterioratingPanel() { return m_pDeterioratingPanel; }
+	vgui::Panel *GetDismantlingPanel() { return m_pDismantlingPanel; }
+
+	// Override these to deal with various controls in various modes
+	virtual void OnTickDeteriorating( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer );
+	virtual void OnTickActive( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer );
+	virtual void OnTickDismantling( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer );
+
+	C_BaseObject *GetOwningObject() const;
+
+	// This should update the current panel and return that panel.
+	virtual vgui::Panel* TickCurrentPanel();
+
+	// The dismantle button has its own logic about whether or not to hide itself.
+	// Use this to make it go away.
+	void ShowDismantleButton( bool bShow );
+	void ShowOwnerLabel( bool bShow );
+	void ShowHealthLabel( bool bShow );
+
+	// Send a message to the owner.
+	void SendToServerObject( const char *pMsg );
+
+private:
+	// Operations performed through the controls 
+	void AssumeControl();
+	void Dismantle();
+	void StartDismantling();
+	void StopDismantling();
+	bool IsDismantling() const;
+
+	vgui::EditablePanel	*m_pActivePanel;
+	vgui::EditablePanel	*m_pDeterioratingPanel;
+	vgui::EditablePanel	*m_pDismantlingPanel;
+
+	vgui::Label *m_pHealthLabel;
+	vgui::Label *m_pOwnerLabel;
+	vgui::Button *m_pDismantleButton;
+	vgui::Button *m_pAssumeControlButton;
+	vgui::Label *m_pDismantleTimeLabel;
+
+	vgui::Panel *m_pCurrentPanel;
+
+	bool	m_bDismantled;
+	float	m_flDismantleTime;
+};
+
+
+// This is used for child panels. It forwards the messages to the parent panel.
+class CCommandChainingPanel : public vgui::EditablePanel
+{
+	typedef vgui::EditablePanel BaseClass;
+
+public:
+	CCommandChainingPanel( vgui::Panel *parent, const char *panelName ) :
+		BaseClass( parent, panelName ) 
+	{
+		SetPaintBackgroundEnabled( false );
+	}
+
+	void OnCommand( const char *command )
+	{
+		BaseClass::OnCommand( command );
+		if (GetParent())
+		{
+			GetParent()->OnCommand(command);
+		}
+	}
+};
+
+
+//-----------------------------------------------------------------------------
+// This is a panel for an object that has rotational controls 
+//-----------------------------------------------------------------------------
+class CRotatingObjectControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CRotatingObjectControlPanel, CObjectControlPanel );
+
+public:
+	CRotatingObjectControlPanel( vgui::Panel *parent, const char *panelName );
+
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+
+protected:
+	virtual void OnTickActive( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer );
+
+private:
+	CRotationSlider *m_pRotationSlider;
+	vgui::Label *m_pRotationLabel;
+};
+
+#endif // OBJECTCONTROLPANEL_H
diff --git a/game/client/tf2/ProxyTFPlayer.cpp b/game/client/tf2/ProxyTFPlayer.cpp
new file mode 100644
index 0000000..9d14a34
--- /dev/null
+++ b/game/client/tf2/ProxyTFPlayer.cpp
@@ -0,0 +1,198 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialsystem.h"
+#include <KeyValues.h>
+#include "materialsystem/imaterialvar.h"
+#include "C_BaseTFPlayer.h"
+#include "functionproxy.h"
+#include "C_PlayerResource.h"
+
+
+//-----------------------------------------------------------------------------
+// Returns the player health (from 0 to 1)
+//-----------------------------------------------------------------------------
+class CPlayerHealthProxy : public CResultProxy
+{
+public:
+	bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	void OnBind( void *pEnt );
+
+private:
+	CFloatInput	m_Factor;
+};
+
+bool CPlayerHealthProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if (!CResultProxy::Init( pMaterial, pKeyValues ))
+		return false;
+
+	if (!m_Factor.Init( pMaterial, pKeyValues, "scale", 1 ))
+		return false;
+
+	return true;
+}
+
+void CPlayerHealthProxy::OnBind( void *pArg )
+{
+	// NOTE: Player health max is not available on the server...
+	C_BaseEntity *pEntity = BindArgToEntity( pArg );
+	C_BaseTFPlayer* pPlayer = dynamic_cast<C_BaseTFPlayer*>(pEntity);
+	if (!pPlayer)
+		return;
+
+	Assert( m_pResult );
+	SetFloatResult( pPlayer->HealthFraction() * m_Factor.GetFloat() );
+
+	/*
+	// Should we draw their health?
+	// If he's not on our team we can't see it unless we're a command with "targetinginfo".
+	if ( GetLocalTeam() != GetTeam() && !(local->HasNamedTechnology("targetinginfo") && IsLocalPlayerClass(TFCLASS_COMMANDO) ))
+		return drawn;
+	// Don't draw health bars above myself
+	if ( local == this )
+		return drawn;
+	// Don't draw health bars over dead/dying player
+	if ( GetHealth() <= 0 )
+		return drawn;
+
+	return drawn;
+	*/
+}
+
+EXPOSE_INTERFACE( CPlayerHealthProxy, IMaterialProxy, "PlayerHealth" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// A function that returns the time since last being damaged
+//-----------------------------------------------------------------------------
+class CPlayerDamageTimeProxy : public CResultProxy
+{
+public:
+	bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	void OnBind( void *pEnt );
+
+private:
+	CFloatInput	m_Factor;
+};
+
+bool CPlayerDamageTimeProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if (!CResultProxy::Init( pMaterial, pKeyValues ))
+		return false;
+
+	if (!m_Factor.Init( pMaterial, pKeyValues, "scale", 1.0f ))
+		return false;
+
+	return true;
+}
+
+void CPlayerDamageTimeProxy::OnBind( void *pArg )
+{
+	C_BaseEntity *pEntity = BindArgToEntity( pArg );
+
+	// NOTE: Player health max is not available on the server...
+	C_BaseTFPlayer* pPlayer = dynamic_cast<C_BaseTFPlayer*>(pEntity);
+	if (!pPlayer)
+	{
+		SetFloatResult( 10000 * m_Factor.GetFloat() );
+		return;
+	}
+
+	Assert( m_pResult );
+	float dt = gpGlobals->curtime - pPlayer->GetLastDamageTime();
+	SetFloatResult( dt * m_Factor.GetFloat() );
+}
+
+EXPOSE_INTERFACE( CPlayerDamageTimeProxy, IMaterialProxy, "PlayerDamageTime" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// A function that returns the time since last being healed
+//-----------------------------------------------------------------------------
+class CPlayerHealTimeProxy : public CResultProxy
+{
+public:
+	bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	void OnBind( void *pEnt );
+
+private:
+	CFloatInput	m_Factor;
+};
+
+bool CPlayerHealTimeProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if (!CResultProxy::Init( pMaterial, pKeyValues ))
+		return false;
+
+	if (!m_Factor.Init( pMaterial, pKeyValues, "scale", 1.0f ))
+		return false;
+
+	return true;
+}
+
+void CPlayerHealTimeProxy::OnBind( void *pArg  )
+{
+	// NOTE: Player health max is not available on the server...
+	C_BaseEntity *pEntity = BindArgToEntity( pArg );
+	C_BaseTFPlayer* pPlayer = dynamic_cast<C_BaseTFPlayer*>(pEntity);
+	if (!pPlayer)
+		return;
+
+	Assert( m_pResult );
+	float dt = gpGlobals->curtime - pPlayer->GetLastGainHealthTime();
+	SetFloatResult( dt * m_Factor.GetFloat() );
+}
+
+EXPOSE_INTERFACE( CPlayerHealTimeProxy, IMaterialProxy, "PlayerHealTime" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// Returns the player score
+//-----------------------------------------------------------------------------
+class CPlayerScoreProxy : public CResultProxy
+{
+public:
+	bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	void OnBind( void *pEntity );
+
+private:
+	CFloatInput	m_Factor;
+};
+
+bool CPlayerScoreProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if (!CResultProxy::Init( pMaterial, pKeyValues ))
+		return false;
+
+	if (!m_Factor.Init( pMaterial, pKeyValues, "scale", 1 ))
+		return false;
+
+	return true;
+}
+
+void CPlayerScoreProxy::OnBind( void *pArg )
+{
+	// Find the view angle between the player and this entity....
+	C_BaseEntity *pEntity = BindArgToEntity( pArg );
+	C_BaseTFPlayer* pPlayer = dynamic_cast<C_BaseTFPlayer*>(pEntity);
+	if (!pPlayer)
+		return;
+
+	if ( !g_PR )
+		return;
+
+	int score = g_PR->GetPlayerScore(pPlayer->index);
+
+	Assert( m_pResult );
+	SetFloatResult( score * m_Factor.GetFloat() );
+}
+
+EXPOSE_INTERFACE( CPlayerScoreProxy, IMaterialProxy, "PlayerScore" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
diff --git a/game/client/tf2/RespawnWaveVGuiScreen.cpp b/game/client/tf2/RespawnWaveVGuiScreen.cpp
new file mode 100644
index 0000000..e9ba442
--- /dev/null
+++ b/game/client/tf2/RespawnWaveVGuiScreen.cpp
@@ -0,0 +1,101 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_vguiscreen.h"
+#include "clientmode_tfbase.h"
+#include <vgui/IVGui.h>
+#include <vgui_controls/Controls.h>
+#include <vgui_controls/Label.h>
+#include "c_info_act.h"
+
+
+//-----------------------------------------------------------------------------
+// Base class for all vgui screens on objects: 
+//-----------------------------------------------------------------------------
+class CRespawnWaveVGuiScreen : public CVGuiScreenPanel
+{
+	DECLARE_CLASS( CRespawnWaveVGuiScreen, CVGuiScreenPanel );
+
+public:
+	CRespawnWaveVGuiScreen( vgui::Panel *parent, const char *panelName );
+
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+
+private:
+	vgui::Label *m_pTime1RemainingLabel;
+	vgui::Label *m_pTime2RemainingLabel;
+};
+
+
+//-----------------------------------------------------------------------------
+// Standard VGUI panel for objects 
+//-----------------------------------------------------------------------------
+DECLARE_VGUI_SCREEN_FACTORY( CRespawnWaveVGuiScreen, "respawn_wave_screen" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CRespawnWaveVGuiScreen::CRespawnWaveVGuiScreen( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, panelName, g_hVGuiObjectScheme ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CRespawnWaveVGuiScreen::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	// Load all of the controls in
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	// Make sure we get ticked...
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	// Grab ahold of certain well-known controls
+	// NOTE: it is valid for these controls to not exist!
+	m_pTime1RemainingLabel = dynamic_cast<vgui::Label*>(FindChildByName( "RespawnTime1Remaining" ));
+	m_pTime2RemainingLabel = dynamic_cast<vgui::Label*>(FindChildByName( "RespawnTime2Remaining" ));
+	
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CRespawnWaveVGuiScreen::OnTick()
+{
+	BaseClass::OnTick();
+
+	if (!GetEntity())
+		return;
+
+	int nTime1Remaining = 0;
+	int nTime2Remaining = 0;
+	if (g_hCurrentAct.Get())
+	{
+		nTime1Remaining = g_hCurrentAct->RespawnTimeRemaining( GetEntity()->GetTeamNumber(), 1 ); 
+		nTime2Remaining = g_hCurrentAct->RespawnTimeRemaining( GetEntity()->GetTeamNumber(), 2 ); 
+	}
+
+	char buf[32];
+	if (m_pTime1RemainingLabel)
+	{
+		Q_snprintf( buf, sizeof( buf ), "%d", nTime1Remaining );
+		m_pTime1RemainingLabel->SetText( buf );
+	}
+	if (m_pTime2RemainingLabel)
+	{
+		Q_snprintf( buf, sizeof( buf ), "%d", nTime2Remaining );
+		m_pTime2RemainingLabel->SetText( buf );
+	}
+}
+
diff --git a/game/client/tf2/VGuiScreenVehicleBay.cpp b/game/client/tf2/VGuiScreenVehicleBay.cpp
new file mode 100644
index 0000000..cf8cce9
--- /dev/null
+++ b/game/client/tf2/VGuiScreenVehicleBay.cpp
@@ -0,0 +1,148 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_vguiscreen.h"
+#include "clientmode_tfbase.h"
+#include <vgui/IVGui.h>
+#include <vgui_controls/Controls.h>
+#include <vgui_controls/Label.h>
+#include "vgui_bitmapbutton.h"
+#include "c_info_act.h"
+#include "tf_shareddefs.h"
+#include "c_basetfplayer.h"
+
+int g_ValidVehicles[] =
+{
+	OBJ_WAGON,
+	OBJ_BATTERING_RAM,
+	OBJ_VEHICLE_TANK,
+	OBJ_VEHICLE_TELEPORT_STATION,
+	OBJ_WALKER_STRIDER,
+	OBJ_WALKER_MINI_STRIDER
+
+	// If you add a new vehicle here, you have to add a button for it to the screen_vehicle_bay.res file.
+	// The button's name must be VehicleButton%d, where %d is it's index into this array.
+	// Then add the build%d command to OnCommand at the bottom of this file.
+};
+
+#define NUM_VEHICLES	ARRAYSIZE(g_ValidVehicles)
+
+//-----------------------------------------------------------------------------
+// Vgui screen handling vehicle selection in vehicle bays
+//-----------------------------------------------------------------------------
+class CVehicleBayVGuiScreen : public CVGuiScreenPanel
+{
+	DECLARE_CLASS( CVehicleBayVGuiScreen, CVGuiScreenPanel );
+
+public:
+	CVehicleBayVGuiScreen( vgui::Panel *parent, const char *panelName );
+
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+private:
+	vgui::Button *m_pVehicleButtons[ NUM_VEHICLES ];
+};
+
+
+//-----------------------------------------------------------------------------
+// Standard VGUI panel for objects 
+//-----------------------------------------------------------------------------
+DECLARE_VGUI_SCREEN_FACTORY( CVehicleBayVGuiScreen, "vehicle_bay_screen" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CVehicleBayVGuiScreen::CVehicleBayVGuiScreen( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, panelName, g_hVGuiObjectScheme ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CVehicleBayVGuiScreen::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	// Create our vehicle buttons
+	for ( int i = 0; i < NUM_VEHICLES; i++ )
+	{
+		char ch[128];
+		Q_snprintf( ch, sizeof(ch), "VehicleButton%d", i );
+		m_pVehicleButtons[i] = new CBitmapButton( this, ch, "Name" );
+	}
+
+	// Load all of the controls in
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	// Make sure we get ticked...
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CVehicleBayVGuiScreen::OnTick()
+{
+	BaseClass::OnTick();
+
+	if (!GetEntity())
+		return;
+
+	C_BaseTFPlayer *pLocalPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pLocalPlayer )
+		return;
+
+	int nBankResources = pLocalPlayer ? pLocalPlayer->GetBankResources() : 0;
+
+	// Set the vehicles costs
+	for ( int i = 0; i < NUM_VEHICLES; i++ )
+	{
+		if ( !m_pVehicleButtons[i] )
+			continue;
+
+		char buf[128];
+		int iCost = CalculateObjectCost( g_ValidVehicles[i], pLocalPlayer->GetNumObjects( g_ValidVehicles[i] ), pLocalPlayer->GetTeamNumber() );
+		Q_snprintf( buf, sizeof( buf ), "%s : %d", GetObjectInfo( g_ValidVehicles[i] )->m_pStatusName, iCost );
+		m_pVehicleButtons[i]->SetText( buf );
+		// Can't build if the game hasn't started
+		if ( CurrentActIsAWaitingAct() )
+		{
+			m_pVehicleButtons[i]->SetEnabled( false );
+		}
+		else
+		{
+			m_pVehicleButtons[i]->SetEnabled( nBankResources >= iCost );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CVehicleBayVGuiScreen::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "build", 5))
+	{
+		int iButton;
+		int nCount = sscanf( command, "build%d", &iButton );
+		if (nCount == 1)
+		{
+			char szbuf[64];
+			Q_snprintf( szbuf, sizeof( szbuf ), "buildvehicle %d %d", GetEntity()->entindex(), g_ValidVehicles[iButton] );
+  			engine->ClientCmd(szbuf);
+			return;
+		}
+	}
+
+	BaseClass::OnCommand(command);
+}
diff --git a/game/client/tf2/c_basecombatcharacter_tf2.cpp b/game/client/tf2/c_basecombatcharacter_tf2.cpp
new file mode 100644
index 0000000..87df975
--- /dev/null
+++ b/game/client/tf2/c_basecombatcharacter_tf2.cpp
@@ -0,0 +1,284 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: TF2 Specific C_BaseCombatCharacter code.
+//
+//=============================================================================//
+#include "cbase.h"
+#include "c_basecombatcharacter.h"
+#include "tf_shareddefs.h"
+#include "particles_simple.h"
+#include "functionproxy.h"
+#include "IEffects.h"
+#include "weapon_combatshield.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::Release( void )
+{
+	RemoveAllPowerups();
+
+	BaseClass::Release();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::SetDormant( bool bDormant )
+{
+	// If we're going dormant, stop all our powerup sounds
+	if ( bDormant )
+	{
+		RemoveAllPowerups();
+	}
+	else
+	{
+		// Restart any powerups on him
+		for ( int i = 0; i < MAX_POWERUPS; i++ )
+		{
+			if ( m_iPowerups & (1 << i) )
+			{
+				PowerupStart( i, false );
+			}
+		}
+	}
+
+	BaseClass::SetDormant( bDormant );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : updateType - 
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::OnPreDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnPreDataChanged( updateType );
+
+	m_iPrevPowerups = m_iPowerups;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+
+	// Power state changed?
+	if ( m_iPowerups != m_iPrevPowerups )
+	{
+		for ( int i = 0; i < MAX_POWERUPS; i++ )
+		{
+			bool bPoweredNow = ( m_iPowerups & (1 << i) );
+			bool bPoweredThen = ( m_iPrevPowerups & (1 << i) );
+
+			if ( !bPoweredThen && bPoweredNow )
+			{
+				PowerupStart( i, true );
+			}
+			else if ( bPoweredThen && !bPoweredNow )
+			{
+				PowerupEnd( i );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Powerup has just started
+//			If bInitial is set, the server's just told us this powerup has come on.
+//			If it's false, the entity had it on when it left PVS, and now it's re-entered
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::PowerupStart( int iPowerup, bool bInitial )
+{
+	Assert( iPowerup >= 0 && iPowerup < MAX_POWERUPS );
+
+	switch( iPowerup )
+	{
+	case POWERUP_BOOST:
+		break;
+
+	case POWERUP_EMP:
+		{
+			// Play the EMP sound
+			if ( !bInitial )
+			{
+				EmitSound( "BaseCombatCharacter.EMPPulse" );
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Powerup has just finished
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::PowerupEnd( int iPowerup )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::RemoveAllPowerups( void )
+{
+	// Stop any powerups we have
+	if ( m_iPowerups )
+	{
+		for ( int i = 0; i < MAX_POWERUPS; i++ )
+		{
+			if ( m_iPowerups & (1 << i) )
+			{
+				PowerupEnd( i );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::ClientThink( void )
+{
+	BaseClass::ClientThink();
+
+	if ( !IsDormant() )
+	{
+		if ( HasPowerup(POWERUP_EMP) )
+		{
+			AddEMPEffect( WorldAlignSize().Length() * 0.15 );
+		}
+
+		if ( HasPowerup(POWERUP_BOOST) )
+		{
+			AddBuffEffect( WorldAlignSize().Length() * 0.15 );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw an effect to show this entity has been EMPed
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::AddEMPEffect( float flSize )
+{
+	// Don't draw on the local player
+	if ( this == C_BasePlayer::GetLocalPlayer() )
+		return;
+
+	CSmartPtr<CSimpleEmitter>	pEmitter;
+	PMaterialHandle				hParticleMaterial;
+	TimedEvent					pParticleEvent;
+
+	pParticleEvent.Init( 300 );
+	pEmitter = CSimpleEmitter::Create( "ObjectEMPEffect" );
+	hParticleMaterial = pEmitter->GetPMaterial( "sprites/chargeball" );
+
+	// Add particles
+	float flCur = gpGlobals->frametime;
+	Vector vCenter = WorldSpaceCenter( );
+
+	while ( pParticleEvent.NextEvent( flCur ) )
+	{
+		Vector vPos;
+		Vector vOffset = RandomVector( -1, 1 );
+		VectorNormalize( vOffset );
+		vPos = vCenter + (vOffset * RandomFloat( 0, flSize ));
+		
+		pEmitter->SetSortOrigin( vPos );
+		SimpleParticle *pParticle = pEmitter->AddSimpleParticle( hParticleMaterial, vPos );
+		if ( pParticle )
+		{
+			// Move the points along the path.
+			pParticle->m_vecVelocity.Init();
+			pParticle->m_flRoll = 0;
+			pParticle->m_flRollDelta = 0;
+			pParticle->m_flDieTime = 0.4f;
+			pParticle->m_flLifetime = 0;
+			pParticle->m_uchColor[0] = 255; 
+			pParticle->m_uchColor[1] = 255;
+			pParticle->m_uchColor[2] = 255;
+			pParticle->m_uchStartAlpha = 32;
+			pParticle->m_uchEndAlpha = 0;
+			pParticle->m_uchStartSize = 4;
+			pParticle->m_uchEndSize = 2;
+			pParticle->m_iFlags = 0;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw an effect to show this entity is being buffed
+//-----------------------------------------------------------------------------
+void C_BaseCombatCharacter::AddBuffEffect( float flSize )
+{
+	// Don't draw on the local player
+	if ( this == C_BasePlayer::GetLocalPlayer() )
+		return;
+
+	CSmartPtr<CSimpleEmitter>	pEmitter;
+	PMaterialHandle				hParticleMaterial;
+	TimedEvent					pParticleEvent;
+
+	pParticleEvent.Init( 300 );
+	pEmitter = CSimpleEmitter::Create( "ObjectBuffEffect" );
+	hParticleMaterial = pEmitter->GetPMaterial( "sprites/chargeball" );
+
+	// Add particles
+	float flCur = gpGlobals->frametime;
+	Vector vCenter = WorldSpaceCenter( );
+
+	while ( pParticleEvent.NextEvent( flCur ) )
+	{
+		Vector vPos;
+		Vector vOffset = RandomVector( -1, 1 );
+		VectorNormalize( vOffset );
+		vPos = vCenter + (vOffset * RandomFloat( 0, flSize ));
+		
+		SimpleParticle *pParticle = pEmitter->AddSimpleParticle( hParticleMaterial, vPos );
+		if ( pParticle )
+		{
+			// Move the points along the path.
+			pParticle->m_vecVelocity.Init();
+			pParticle->m_flRoll = 0;
+			pParticle->m_flRollDelta = 0;
+			pParticle->m_flDieTime = 0.4f;
+			pParticle->m_flLifetime = 0;
+			pParticle->m_uchColor[1] = 255; pParticle->m_uchColor[0] = pParticle->m_uchColor[2] = 0;
+			pParticle->m_uchStartAlpha = 128;
+			pParticle->m_uchEndAlpha = 0;
+			pParticle->m_uchStartSize = 3;
+			pParticle->m_uchEndSize = 1;
+			pParticle->m_iFlags = 0;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns shield if owned.
+//-----------------------------------------------------------------------------
+C_WeaponCombatShield *C_BaseCombatCharacter::GetShield( void )
+{
+	C_BaseCombatWeapon *pWeapon;
+	if ( GetTeamNumber() == TEAM_ALIENS )
+	{
+		pWeapon = Weapon_OwnsThisType( "weapon_combat_shield_alien" );	
+	}
+	else
+	{
+		pWeapon = Weapon_OwnsThisType( "weapon_combat_shield" );	
+	}
+
+	if ( !pWeapon )
+		return NULL;
+
+	return ( CWeaponCombatShield* )pWeapon;
+}
diff --git a/game/client/tf2/c_basefourwheelvehicle.cpp b/game/client/tf2/c_basefourwheelvehicle.cpp
new file mode 100644
index 0000000..88b98e3
--- /dev/null
+++ b/game/client/tf2/c_basefourwheelvehicle.cpp
@@ -0,0 +1,89 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "C_BaseFourWheelVehicle.h"
+
+IMPLEMENT_CLIENTCLASS_DT(C_BaseTFFourWheelVehicle, DT_BaseTFFourWheelVehicle, CBaseTFFourWheelVehicle)
+	RecvPropFloat( RECVINFO( m_flDeployFinishTime ) ),
+	RecvPropInt( RECVINFO( m_eDeployMode ) ),
+	RecvPropInt( RECVINFO( m_bBoostUpgrade ) ),
+	RecvPropInt( RECVINFO( m_nBoostTimeLeft ) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_BaseTFFourWheelVehicle::C_BaseTFFourWheelVehicle()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+float C_BaseTFFourWheelVehicle::GetDeployFinishTime() const
+{
+	return m_flDeployFinishTime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+VehicleModeDeploy_e C_BaseTFFourWheelVehicle::GetVehicleModeDeploy() const
+{
+	return m_eDeployMode;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFFourWheelVehicle::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		// Start thinking (Baseclass stops it)
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Restricts the view within a range of the center...
+//-----------------------------------------------------------------------------
+void C_BaseTFFourWheelVehicle::RestrictView( int nRole, float flMinYaw, float flMaxYaw, QAngle &vecViewAngles )
+{
+	Assert( nRole >= 0 );
+	Vector vehicleEyeOrigin;
+	QAngle vehicleEyeAngles;
+	GetRoleViewPosition( nRole, &vehicleEyeOrigin, &vehicleEyeAngles ); 
+
+	// Confine the view to the appropriate yaw range...
+	float flCenterYaw = vehicleEyeAngles[YAW];
+
+	// View angles are dealt with in absolute terms here...
+	float flAngleDiff = AngleDiff( vecViewAngles[YAW], flCenterYaw );
+
+	// Here, we must clamp to the cone...
+	if (flAngleDiff < flMinYaw)
+		vecViewAngles[YAW] = anglemod(flCenterYaw + flMinYaw);
+	else if (flAngleDiff > flMaxYaw)
+		vecViewAngles[YAW] = anglemod(flCenterYaw + flMaxYaw);
+}
+
+
+//-----------------------------------------------------------------------------
+// Clamps the view angles while driving the vehicle 
+//-----------------------------------------------------------------------------
+void C_BaseTFFourWheelVehicle::UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd )
+{
+	int nRole = GetPassengerRole( pLocalPlayer );
+	if ( nRole != VEHICLE_ROLE_DRIVER )
+	{
+		RestrictView( nRole, -90, 90, pCmd->viewangles );
+	}
+}
+
diff --git a/game/client/tf2/c_basefourwheelvehicle.h b/game/client/tf2/c_basefourwheelvehicle.h
new file mode 100644
index 0000000..5ccbcaf
--- /dev/null
+++ b/game/client/tf2/c_basefourwheelvehicle.h
@@ -0,0 +1,51 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_BASE_FOUR_WHEEL_VEHICLE_H
+#define C_BASE_FOUR_WHEEL_VEHICLE_H
+
+#include "basetfvehicle.h"
+
+class C_BasePlayer;
+	    
+class C_BaseTFFourWheelVehicle : public C_BaseTFVehicle
+{
+	DECLARE_CLASS( C_BaseTFFourWheelVehicle, C_BaseTFVehicle );
+	DECLARE_CLIENTCLASS();
+
+public:
+
+	C_BaseTFFourWheelVehicle();
+
+	float				GetDeployFinishTime() const;
+	VehicleModeDeploy_e GetVehicleModeDeploy() const;
+
+	// TF2 vehicles are animated by the server
+	virtual bool IsSelfAnimating() { return false; };
+
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+
+// IClientVehicle overrides.
+public:
+	virtual void UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd );
+
+protected:
+	// Restricts the view within a range of the center...
+	void RestrictView( int nRole, float flMinYaw, float flMaxYaw, QAngle &vecViewAngles );
+
+private:
+
+	C_BaseTFFourWheelVehicle( const C_BaseTFFourWheelVehicle & ); // not defined, not accessible
+
+private:
+
+	// Used to draw deploy timer on vgui screens.
+	float					m_flDeployFinishTime;
+	VehicleModeDeploy_e		m_eDeployMode;
+};
+
+#endif // C_BASE_FOUR_WHEEL_VEHICLE_H
\ No newline at end of file
diff --git a/game/client/tf2/c_baseobject.cpp b/game/client/tf2/c_baseobject.cpp
new file mode 100644
index 0000000..491dba9
--- /dev/null
+++ b/game/client/tf2/c_baseobject.cpp
@@ -0,0 +1,921 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Clients CBaseObject
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_baseobject.h"
+#include "c_basetfplayer.h"
+#include "hud.h"
+#include "c_tfteam.h"
+#include "engine/IEngineSound.h"
+#include "particles_simple.h"
+#include "functionproxy.h"
+#include "IEffects.h"
+#include "c_hint_events.h"
+#include "model_types.h"
+#include "particlemgr.h"
+#include "particle_collision.h"
+#include "env_objecteffects.h"
+#include "basetfvehicle.h"
+#include "c_weapon_builder.h"
+#include "ivrenderview.h"
+#include "ObjectControlPanel.h"
+#include "engine/ivmodelinfo.h"
+#include "c_te_effect_dispatch.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define MAX_VISIBLE_BUILDPOINT_DISTANCE		(400 * 400)
+
+// Remove aliasing of name due to shared code
+#undef CBaseObject
+
+IMPLEMENT_CLIENTCLASS_DT(C_BaseObject, DT_BaseObject, CBaseObject)
+	RecvPropInt(RECVINFO(m_iHealth)),
+	RecvPropInt(RECVINFO(m_iMaxHealth)),
+	RecvPropInt(RECVINFO(m_bHasSapper)),
+	RecvPropInt(RECVINFO(m_iObjectType)),
+	RecvPropInt(RECVINFO(m_bBuilding)),
+	RecvPropInt(RECVINFO(m_bPlacing)),
+	RecvPropFloat(RECVINFO(m_flPercentageConstructed)),
+	RecvPropInt(RECVINFO(m_fObjectFlags)),
+	RecvPropInt(RECVINFO(m_bDeteriorating)),
+	RecvPropEHandle(RECVINFO(m_hBuiltOnEntity)),
+	RecvPropInt(RECVINFO( m_takedamage ) ),
+	RecvPropInt( RECVINFO( m_bDisabled ) ),
+	RecvPropEHandle( RECVINFO( m_hBuilder ) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_BaseObject::C_BaseObject(  )
+{
+	m_flDamageFlash = 0;
+	m_YawPreviewState = YAW_PREVIEW_OFF;
+	m_bBuilding = false;
+	m_bPlacing = false;
+	m_flPercentageConstructed = 0;
+	m_flNextEffect = 0;
+	m_bOldSapper = m_bHasSapper = false;
+	m_fObjectFlags = 0;
+	m_bDeteriorating = false;
+	m_ThermalMaterial.Init("player/thermal/thermal",TEXTURE_GROUP_CLIENT_EFFECTS);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_BaseObject::~C_BaseObject( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::PreDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PreDataUpdate( updateType );
+
+	m_iOldHealth = m_iHealth;
+ 	m_bOldSapper = m_bHasSapper;
+	m_hOldOwner = GetOwner();
+	m_bWasActive = ShouldBeActive();
+	m_bWasBuilding = m_bBuilding;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::OnDataChanged( DataUpdateType_t updateType )
+{
+	if (updateType == DATA_UPDATE_CREATED)
+	{
+		if ( !IS_MINIMAP_PANEL_DEFINED( ) && !(m_fObjectFlags & OF_SUPPRESS_APPEAR_ON_MINIMAP) )
+		{
+			CONSTRUCT_MINIMAP_PANEL( "minimap_object", MINIMAP_OBJECTS );
+		}
+
+		CreateBuildPoints();
+	}
+
+	BaseClass::OnDataChanged( updateType );
+
+	// Did we just finish building?
+	if ( m_bWasBuilding && !m_bBuilding )
+	{
+		FinishedBuilding();
+	}
+
+	// Did we just go active?
+	bool bShouldBeActive = ShouldBeActive();
+	if ( !m_bWasActive && bShouldBeActive )
+	{
+		OnGoActive();
+	}
+	else if ( m_bWasActive && !bShouldBeActive )
+	{
+		OnGoInactive();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	//ENTITY_PANEL_ACTIVATE( "analyzed_object", !bDormant );
+}
+
+#define TF_OBJ_BODYGROUPTURNON			1
+#define TF_OBJ_BODYGROUPTURNOFF			0
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : origin - 
+//			angles - 
+//			event - 
+//			*options - 
+//-----------------------------------------------------------------------------
+void C_BaseObject::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
+{
+	switch ( event )
+	{
+	default:
+		{
+			BaseClass::FireEvent( origin, angles, event, options );
+		}
+		break;
+	case TF_OBJ_PLAYBUILDSOUND:
+		{
+			EmitSound( options );
+		}
+		break;
+	case TF_OBJ_ENABLEBODYGROUP:
+		{
+			int index = FindBodygroupByName( options );
+			if ( index >= 0 )
+			{
+				SetBodygroup( index, TF_OBJ_BODYGROUPTURNON );
+			}
+		}
+		break;
+	case TF_OBJ_DISABLEBODYGROUP:
+		{
+			int index = FindBodygroupByName( options );
+			if ( index >= 0 )
+			{
+				SetBodygroup( index, TF_OBJ_BODYGROUPTURNOFF );
+			}
+		}
+		break;
+	case TF_OBJ_ENABLEALLBODYGROUPS:
+	case TF_OBJ_DISABLEALLBODYGROUPS:
+		{
+			// Start at 1, because body 0 is the main .mdl body...
+			// Is this the way we want to do this?
+			int count = GetNumBodyGroups();
+			for ( int i = 1; i < count; i++ )
+			{
+				int subpartcount = GetBodygroupCount( i );
+				if ( subpartcount == 2 )
+				{
+					SetBodygroup( i, 
+						( event == TF_OBJ_ENABLEALLBODYGROUPS ) ?
+						TF_OBJ_BODYGROUPTURNON : TF_OBJ_BODYGROUPTURNOFF );
+				}
+				else
+				{
+					DevMsg( "TF_OBJ_ENABLE/DISABLEBODY GROUP:  %s has a group with %i subparts, should be exactly 2\n",
+						GetClassname(), subpartcount );
+				}
+			}
+		}
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseObject::OffsetObjectOrigin( Vector& origin )
+{
+	if ( !m_bBuilding )
+		return false;
+	
+	if ( inv_demo.GetBool() )
+		return false;
+
+	Vector vecWorldMins, vecWorldMaxs;
+	CollisionProp()->WorldSpaceAABB( &vecWorldMins, &vecWorldMaxs );
+	float flSize = vecWorldMaxs.z - vecWorldMins.z;
+	origin.z -= (flSize * (1 - m_flPercentageConstructed));
+
+	// If we're building, fake sliding the object out of the ground
+	return true;
+}
+
+
+const char* C_BaseObject::GetStatusName() const
+{
+	return GetObjectInfo( GetType() )->m_pStatusName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_BaseObject::DrawModel( int flags )
+{
+	Vector vRealOrigin = GetLocalOrigin();
+	Vector vOrigin = vRealOrigin;
+	bool needOriginReset = OffsetObjectOrigin( vOrigin );
+	if ( needOriginReset )
+	{
+		SetLocalOrigin( vOrigin );
+		InvalidateBoneCache();
+	}
+
+	int drawn;
+	C_BaseTFPlayer *pLocal = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pLocal && pLocal->IsUsingThermalVision() )
+	{
+		modelrender->ForcedMaterialOverride( m_ThermalMaterial );
+		drawn = BaseClass::DrawModel(flags);
+		modelrender->ForcedMaterialOverride( NULL );
+	}
+	else
+	{
+		// If we're a brush-built, map-defined object chain up to baseentity draw
+		if ( modelinfo->GetModelType( GetModel() ) == mod_brush )
+		{
+			drawn = CBaseEntity::DrawModel(flags);
+		}
+		else
+		{
+			drawn = BaseClass::DrawModel(flags);
+		}
+	}
+
+	// Restore faked origin
+	if ( needOriginReset )
+	{
+		SetLocalOrigin( vRealOrigin );
+	}
+
+	// If we were drawn, draw building effects if we're building, or damage effects if we're damaged
+	if ( drawn && (m_flNextEffect < gpGlobals->curtime) )
+	{
+		// Haxory LOD
+		C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+		if ( (GetAbsOrigin() - pPlayer->GetAbsOrigin()).LengthSqr() < lod_effect_distance.GetFloat() )
+		{
+			if ( IsBuilding() )
+			{
+				DrawBuildEffects();
+			}
+			if ( !m_bPlacing && !m_bBuilding )
+			{
+				if ( !HasPowerup( POWERUP_EMP ) )
+				{
+					DrawRunningEffects();
+				}
+
+				if ( GetHealth() < GetMaxHealth() )
+				{
+					DrawDamageEffects();
+				}
+			}
+		}
+	}
+
+	HighlightBuildPoints( flags );
+
+	return drawn;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::HighlightBuildPoints( int flags )
+{
+	C_BaseTFPlayer *pLocal = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pLocal )
+		return;
+
+	if ( !GetNumBuildPoints() || !InLocalTeam() )
+		return;
+
+	C_WeaponBuilder *pBuilderWpn = dynamic_cast< C_WeaponBuilder * >( pLocal->GetActiveWeaponForSelection() );
+	if ( !pBuilderWpn )
+		return;
+	if ( !pBuilderWpn->IsPlacingObject() )
+		return;
+	C_BaseObject *pPlacementObj = pBuilderWpn->GetPlacementModel();
+	if ( !pPlacementObj || pPlacementObj == this )
+		return;
+
+	// Near enough?
+	if ( (GetAbsOrigin() - pLocal->GetAbsOrigin()).LengthSqr() < MAX_VISIBLE_BUILDPOINT_DISTANCE )
+	{
+		bool bRestoreModel = false;
+		Vector vecPrevAbsOrigin = pPlacementObj->GetAbsOrigin();
+		QAngle vecPrevAbsAngles = pPlacementObj->GetAbsAngles();
+
+		Vector orgColor;
+		render->GetColorModulation( orgColor.Base() );
+		float orgBlend = render->GetBlend();
+
+		// Any empty buildpoints?
+		for ( int i = 0; i < GetNumBuildPoints(); i++ )
+		{
+			// Can this object build on this point?
+			if ( CanBuildObjectOnBuildPoint( i, pPlacementObj->GetType() ) )
+			{
+				Vector vecBPOrigin;
+				QAngle vecBPAngles;
+				if ( GetBuildPoint(i, vecBPOrigin, vecBPAngles) )
+				{
+					pPlacementObj->InvalidateBoneCaches();
+
+					Vector color( 0, 255, 0 );
+					render->SetColorModulation(	color.Base() );
+					float frac = fmod( gpGlobals->curtime, 3 );
+					frac *= 2 * M_PI;
+					frac = cos( frac );
+					render->SetBlend( (175 + (int)( frac * 75.0f )) / 255.0 );
+
+					// HACK: Fixup angles on the HL2 model we're using
+					if ( !strcmp( modelinfo->GetModelName( pPlacementObj->GetModel() ), "models/items/HealthKit.mdl" ) )
+					{
+						vecBPAngles.x += 90;
+					}
+
+					// FIXME: This truly sucks! The bone cache should use
+					// render location for this computation instead of directly accessing AbsAngles
+					// Necessary for bone cache computations to work
+					pPlacementObj->SetAbsOrigin( vecBPOrigin );
+					pPlacementObj->SetAbsAngles( vecBPAngles );
+
+
+					modelrender->DrawModel( 
+						flags, 
+						pPlacementObj,
+						pPlacementObj->GetModelInstance(),
+						pPlacementObj->index, 
+						pPlacementObj->GetModel(),
+						vecBPOrigin,
+						vecBPAngles,
+						pPlacementObj->m_nSkin,
+						pPlacementObj->m_nBody,
+						pPlacementObj->m_nHitboxSet
+						);
+
+					bRestoreModel = true;
+				}
+			}
+		}
+
+		if ( bRestoreModel )
+		{
+			pPlacementObj->SetAbsOrigin(vecPrevAbsOrigin);
+			pPlacementObj->SetAbsAngles(vecPrevAbsAngles);
+			pPlacementObj->InvalidateBoneCaches();
+
+			render->SetColorModulation( orgColor.Base() );
+			render->SetBlend( orgBlend );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Exit points for mounted vehicles....
+//-----------------------------------------------------------------------------
+void C_BaseObject::GetExitPoint( CBaseEntity *pPlayer, int nBuildPoint, Vector *pAbsPosition, QAngle *pAbsAngles )
+{
+	Assert(0);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Overridden to allow for brush-built map defined objects
+//-----------------------------------------------------------------------------
+bool C_BaseObject::IsIdentityBrush( void )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Builder preview...
+//-----------------------------------------------------------------------------
+void C_BaseObject::ActivateYawPreview( bool enable )
+{
+	m_YawPreviewState = enable ? YAW_PREVIEW_ON : YAW_PREVIEW_WAITING_FOR_UPDATE;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::PreviewYaw( float yaw )
+{
+	m_fYawPreview = yaw;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseObject::IsPreviewingYaw() const
+{
+	return m_YawPreviewState != YAW_PREVIEW_OFF;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This is called to get the initial builder yaw...
+//-----------------------------------------------------------------------------
+float C_BaseObject::GetInitialBuilderYaw()
+{
+	return GetAbsAngles().y;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::PostDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PostDataUpdate( updateType );
+
+	bool bNewEntity = (updateType == DATA_UPDATE_CREATED);
+	if ( bNewEntity )
+	{
+		m_flAttackTime = -1000;
+	}
+
+	// Determine if we're under attack
+	if ( !bNewEntity )
+	{
+		if ( m_iHealth < m_iOldHealth )
+		{
+			// Deteriorating objects don't play sounds
+			if ( !IsDeteriorating() )
+			{
+				m_flAttackTime = gpGlobals->curtime;
+			}
+		}
+		else if ( m_iHealth > m_iOldHealth && m_iHealth == m_iMaxHealth )
+		{
+			// If we were just fully healed, remove all decals
+			RemoveAllDecals();
+		}
+	}
+
+	if ( m_bHasSapper ) 
+	{
+		// Play a specific sound for a sapper...
+		if ( m_bOldSapper != m_bHasSapper )
+		{
+			// Don't create these for dragonsteeth
+			if ( InLocalTeam() && GetType() != OBJ_DRAGONSTEETH )
+			{
+				// Play a sound.
+				CLocalPlayerFilter filter;
+				EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "BaseObject.SapperDestroyingTeamBuilding" );
+
+				MinimapCreateTempTrace( "minimap_under_attack", MINIMAP_PERSONAL_ORDERS, GetAbsOrigin() );
+			}
+		}
+	}
+
+	// Notify the hint system of the object being built.
+	if ( bNewEntity && GetOwner() && ( GetOwner() == C_BasePlayer::GetLocalPlayer() ) )
+	{
+		C_HintEvent_ObjectBuiltByLocalPlayer event( this );
+		GlobalHintEvent( &event );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::Release( void )
+{
+	// Remove any reticles on this entity
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer )
+	{
+		pPlayer->Remove_Target( this );
+	}
+
+	BaseClass::Release();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseObject::IsUnderAttack( )
+{
+	// It's under attack for the 3 seconds after the last attack time
+	return (gpGlobals->curtime - m_flAttackTime) < 5.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Ownership: 
+//-----------------------------------------------------------------------------
+C_BaseTFPlayer *C_BaseObject::GetOwner()
+{
+	return m_hBuilder;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseObject::IsOwnedByLocalPlayer() const
+{
+	if ( !m_hBuilder )
+		return false;
+
+	return ( m_hBuilder == C_BaseTFPlayer::GetLocalPlayer() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add entity to visibile entities list
+//-----------------------------------------------------------------------------
+void C_BaseObject::AddEntity( void )
+{
+	// If set to invisible, skip. Do this before resetting the entity pointer so it has 
+	// valid data to decide whether it's visible.
+	if ( !ShouldDraw() )
+	{
+		return;
+	}
+
+	// Update the entity position
+	UpdatePosition();
+
+	// Yaw preview
+	if (m_YawPreviewState != YAW_PREVIEW_OFF)
+	{
+		// This piece of code makes it so we keep using the preview
+		// until we get a network update which matches the update value
+		if (m_YawPreviewState == YAW_PREVIEW_WAITING_FOR_UPDATE)
+		{
+			if (fmod( fabs(GetLocalAngles().y - m_fYawPreview), 360.0f) < 1.0f)
+			{
+				m_YawPreviewState = YAW_PREVIEW_OFF;
+			}
+		}
+
+		if (GetLocalOrigin().y != m_fYawPreview)
+		{
+			SetLocalAnglesDim( Y_INDEX, m_fYawPreview );
+			InvalidateBoneCache();
+		}
+	}
+
+	// Create flashlight effects, etc.
+	CreateLightEffects();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::Select( void )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	pPlayer->SetSelectedObject( this );
+}
+
+//-----------------------------------------------------------------------------
+// Sends client commands back to the server: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::SendClientCommand( const char *pCmd )
+{
+	char szbuf[128];
+	Q_snprintf( szbuf, sizeof( szbuf ), "objcmd %d %s", entindex(), pCmd );
+  	engine->ClientCmd(szbuf);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a text description for the object target
+//-----------------------------------------------------------------------------
+const char *C_BaseObject::GetTargetDescription( void ) const
+{
+	return GetStatusName();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a text description for the object target (more verbose)
+//-----------------------------------------------------------------------------
+char *C_BaseObject::GetIDString( void )
+{
+	m_szIDString[0] = 0;
+	RecalculateIDString();
+	return m_szIDString;
+}
+
+
+//-----------------------------------------------------------------------------
+// It's a valid ID target when it's building 
+//-----------------------------------------------------------------------------
+bool C_BaseObject::IsValidIDTarget( void )
+{
+	return InSameTeam( C_BaseTFPlayer::GetLocalPlayer() ) && m_bBuilding;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseObject::RecalculateIDString( void )
+{
+	// Subclasses may have filled this out with a string
+	if ( !m_szIDString[0] )
+	{
+		Q_strncpy( m_szIDString, GetTargetDescription(), sizeof(m_szIDString) );
+	}
+
+	// Have I taken damage?
+	if ( m_iHealth < m_iMaxHealth )
+	{
+		char szHealth[ MAX_ID_STRING ];
+		if ( IsDeteriorating() )
+		{
+			Q_snprintf( szHealth, sizeof(szHealth), "\nBUILDER LOST, DETERIORATING... %.0f percent", ceil(((float)m_iHealth / (float)m_iMaxHealth) * 100) );
+		}
+		else if ( m_bBuilding )
+		{
+			Q_snprintf( szHealth, sizeof(szHealth), "\nConstruction at %.0f percent\nHealth at %.0f percent", (m_flPercentageConstructed * 100), ceil(((float)m_iHealth / (float)m_iMaxHealth) * 100) );
+		}
+		else
+		{
+			Q_snprintf( szHealth, sizeof(szHealth), "\nHealth at %.0f percent", ceil(((float)m_iHealth / (float)m_iMaxHealth) * 100) );
+		}
+		Q_strncat( m_szIDString, szHealth, sizeof(m_szIDString), COPY_ALL_CHARACTERS );
+	}
+
+	if ( m_bHasSapper )
+	{
+		Q_strncat( m_szIDString, "\nUse it to remove the attached enemy object", sizeof(m_szIDString), COPY_ALL_CHARACTERS );
+	}
+
+	// If it's deteriorating, and I can buy it, tell me
+	C_BaseTFPlayer *pLocalPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( IsDeteriorating() && pLocalPlayer && ClassCanBuild( pLocalPlayer->PlayerClass(), GetType() ) )
+	{
+		char szBuy[ MAX_ID_STRING ];
+		int iCost = CalculateObjectCost( GetType(), pLocalPlayer->GetNumObjects( GetType() ), pLocalPlayer->GetTeamNumber() );
+		Q_snprintf( szBuy, sizeof(szBuy), "\nBUY THIS OBJECT FOR %d RESOURCES", iCost );
+		Q_strncat( m_szIDString, szBuy, sizeof(m_szIDString), COPY_ALL_CHARACTERS );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Effects created when the object's running
+//-----------------------------------------------------------------------------
+void C_BaseObject::DrawRunningEffects( void )
+{
+	if ( !GetMaxHealth() )
+		return;
+
+	// Get the overall damage percentage
+	float flDamaged = 1.0 - ((float)GetHealth() / (float)GetMaxHealth());
+
+	// Damage attachment points
+	int iSmokeAttachment, iSparkAttachment;
+	Vector vecSmoke, vecSpark, vecSmokeDir, dir;
+	QAngle angSmoke, angSpark;
+
+	// Look for damage points
+	iSmokeAttachment = LookupRandomAttachment( "r_smoke" );
+
+	// Get the points
+	if ( GetAttachment( iSmokeAttachment, vecSmoke, angSmoke ) )
+	{
+		AngleVectors( angSmoke, &vecSmokeDir);
+	
+		float r, g, b;
+		r = g = b = random->RandomFloat( 16, 92 );
+
+		// Smoke
+		CSmartPtr<CObjectSmokeParticles> pSmokeEmitter = CObjectSmokeParticles::Create( "DrawRunningEffects 1" );
+		pSmokeEmitter->SetSortOrigin( vecSmoke );
+		ObjectSmokeParticle *pParticle = (ObjectSmokeParticle *) pSmokeEmitter->AddParticle( sizeof(ObjectSmokeParticle), g_Mat_DustPuff[1], vecSmoke );
+		if ( pParticle )
+		{
+			pParticle->m_flLifetime	= 0.0f;
+			pParticle->m_flDieTime	= random->RandomFloat( 2.0f, 3.0f );
+			pParticle->m_uchStartSize = random->RandomFloat( 2, 3 );
+			pParticle->m_uchEndSize = random->RandomFloat( 5, 10 );
+			dir[0] = vecSmokeDir[0] + random->RandomFloat( -0.1f, 0.1f );
+			dir[1] = vecSmokeDir[1] + random->RandomFloat( -0.1f, 0.1f );
+			dir[2] = vecSmokeDir[2] + random->RandomFloat( -0.1f, 0.1f );
+			pParticle->m_vecVelocity = dir * random->RandomFloat( 30.0f, 40.0f );
+			pParticle->m_uchStartAlpha	= random->RandomFloat( 128,255 );
+			pParticle->m_uchEndAlpha	= 0;
+			pParticle->m_flRoll			= random->RandomFloat( 180, 360 );
+			pParticle->m_flRollDelta	= random->RandomFloat( -1, 1 );
+			pParticle->m_uchColor[0] = r;
+			pParticle->m_uchColor[1] = g;
+			pParticle->m_uchColor[2] = b;
+			pParticle->m_vecAcceleration = Vector(0,0,10);
+		}
+	}
+
+	// Sparks
+	for ( float flSparks = flDamaged - 0.3; flSparks > 0; flSparks -= 0.3 )
+	{
+		// Get random spark attachment point
+		iSparkAttachment = LookupRandomAttachment( "r_spark" );
+		if ( GetAttachment( iSparkAttachment, vecSpark, angSpark ) )
+		{
+			g_pEffects->Sparks( vecSpark );
+		}
+	}
+
+	m_flNextEffect = gpGlobals->curtime + random->RandomFloat( 0.05, 0.1 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Effects created while the object's building itself
+//-----------------------------------------------------------------------------
+void C_BaseObject::DrawBuildEffects( void )
+{
+	m_flNextEffect = gpGlobals->curtime + 10;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Effects created when the object's damaged
+//-----------------------------------------------------------------------------
+void C_BaseObject::DrawDamageEffects( void )
+{
+	if ( !GetMaxHealth() )
+		return;
+
+	// Get the overall damage percentage
+	float flDamaged = 1.0 - ((float)GetHealth() / (float)GetMaxHealth());
+
+	// Damage attachment points
+	int iSmokeAttachment, iFireAttachment, iSparkAttachment;
+	Vector vecSmoke, vecFire, vecSpark, vecSmokeDir, dir;
+	QAngle angSmoke, angFire, angSpark;
+
+	// HACK: Calculate a random origin
+	// This can go away when we require all objects to have damage attachment points
+	Vector vecOrigin;
+	CollisionProp()->RandomPointInBounds( vec3_origin, Vector( 1, 1, 1 ), &vecOrigin );
+
+	// Look for damage points
+	iSmokeAttachment = LookupRandomAttachment( "d_smoke" );
+	iFireAttachment = LookupRandomAttachment( "d_fire" );
+
+	// Get the points, and if we can't find 'em, use the random origin
+	if ( GetAttachment( iSmokeAttachment, vecSmoke, angSmoke ) )
+	{
+		AngleVectors( angSmoke, &vecSmokeDir );
+	}
+	else
+	{
+		vecSmoke = vecOrigin;
+		vecSmokeDir = Vector(0,0,1);
+	}
+	if ( !GetAttachment( iFireAttachment, vecFire, angFire ) )
+	{
+		vecFire = vecOrigin;
+		angFire = QAngle(0,0,0);
+	}
+	
+	float r, g, b;
+	r = g = b = random->RandomFloat( 16, 92 );
+
+	// Smoke
+	CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "DrawDamageEffects 1" );
+	pSmokeEmitter->SetSortOrigin( vecSmoke );
+	SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], vecSmoke );
+	if ( pParticle )
+	{
+		pParticle->m_flLifetime	= 0.0f;
+		pParticle->m_flDieTime	= random->RandomFloat( 2.0f, 3.0f );
+		pParticle->m_uchStartSize = MAX( 1, 20 * flDamaged );
+		pParticle->m_uchEndSize = MAX( 10, 80 * flDamaged );
+		dir[0] = vecSmokeDir[0] + random->RandomFloat( -0.2f, 0.2f );
+		dir[1] = vecSmokeDir[1] + random->RandomFloat( -0.2f, 0.2f );
+		dir[2] = vecSmokeDir[2] + random->RandomFloat( -0.2f, 0.2f );
+		pParticle->m_vecVelocity = dir * random->RandomFloat( 60.0f, 80.0f );
+		pParticle->m_uchStartAlpha	= 255;
+		pParticle->m_uchEndAlpha	= 0;
+		pParticle->m_flRoll			= random->RandomFloat( 180, 360 );
+		pParticle->m_flRollDelta	= random->RandomFloat( -1, 1 );
+		pParticle->m_uchColor[0] = r;
+		pParticle->m_uchColor[1] = g;
+		pParticle->m_uchColor[2] = b;
+	}
+
+	// If we're really hurt, start burning
+	if ( flDamaged > 0.25 )
+	{
+		CSmartPtr<CObjectFireParticles> pFireEmitter = CObjectFireParticles::Create( "DrawDamageEffects 1" );
+		pFireEmitter->SetSortOrigin( vecFire );
+		PMaterialHandle	hSphereMaterial = pFireEmitter->GetPMaterial( "sprites/floorflame" );
+		ObjectFireParticle *pParticle = (ObjectFireParticle *) pFireEmitter->AddParticle( sizeof(ObjectFireParticle), hSphereMaterial, vecFire );
+		if ( pParticle )
+		{
+			pParticle->m_hParent = this;
+			pParticle->m_iAttachmentPoint = iFireAttachment;
+
+			pParticle->m_flLifetime	= 0.0f;
+			pParticle->m_flDieTime	= 1.0;
+			pParticle->m_uchStartSize = MAX( 5, 30 * (flDamaged - 0.25) );
+			pParticle->m_uchEndSize = pParticle->m_uchStartSize;
+			pParticle->m_vecVelocity = Vector(0,0,1);
+			pParticle->m_uchStartAlpha = 255;
+			pParticle->m_uchEndAlpha = 255;
+			pParticle->m_flRoll	= 0;
+			pParticle->m_flRollDelta = 0;
+		}
+	}
+
+	// Sparks
+	for ( float flSparks = flDamaged - 0.3; flSparks > 0; flSparks -= 0.3 )
+	{
+		// Get random spark attachment point
+		iSparkAttachment = LookupRandomAttachment( "d_spark" );
+		if ( !GetAttachment( iSparkAttachment, vecSpark, angSpark ) )
+		{
+			vecSpark = vecOrigin;
+			angSpark = QAngle(0,0,0);
+		}
+
+		g_pEffects->Sparks( vecSpark );
+	}
+
+	m_flNextEffect = gpGlobals->curtime + random->RandomFloat( 0.2, 0.5 );
+}
+
+//============================================================================================================
+// POWER PROXY
+//============================================================================================================
+class CObjectPowerProxy : public CResultProxy
+{
+public:
+	bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	void OnBind( void *pC_BaseEntity );
+
+private:
+	CFloatInput	m_Factor;
+};
+
+bool CObjectPowerProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if (!CResultProxy::Init( pMaterial, pKeyValues ))
+		return false;
+
+	if (!m_Factor.Init( pMaterial, pKeyValues, "scale", 1 ))
+		return false;
+
+	return true;
+}
+
+void CObjectPowerProxy::OnBind( void *pRenderable )
+{
+	// Find the view angle between the player and this entity....
+	IClientRenderable *pRend = (IClientRenderable *)pRenderable;
+	C_BaseEntity *pEntity = pRend->GetIClientUnknown()->GetBaseEntity();
+	C_BaseObject *pObject = dynamic_cast<C_BaseObject*>(pEntity);
+	if (!pObject)
+		return;
+
+	int iPowered = pObject->IsPowered();
+
+	SetFloatResult( iPowered * m_Factor.GetFloat() );
+}
+
+EXPOSE_INTERFACE( CObjectPowerProxy, IMaterialProxy, "ObjectPower" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CBasicControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CBasicControlPanel, CObjectControlPanel );
+
+public:
+	CBasicControlPanel( vgui::Panel *parent, const char *panelName );
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CBasicControlPanel, "basic_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CBasicControlPanel::CBasicControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CBasicControlPanel" ) 
+{
+}
diff --git a/game/client/tf2/c_baseobject.h b/game/client/tf2/c_baseobject.h
new file mode 100644
index 0000000..a26ade8
--- /dev/null
+++ b/game/client/tf2/c_baseobject.h
@@ -0,0 +1,223 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Clients CBaseObject
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_BASEOBJECT_H
+#define C_BASEOBJECT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "baseobject_shared.h"
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/Label.h>
+#include "vgui_healthbar.h"
+#include "commanderoverlay.h"
+#include "hud_minimap.h"
+#include "particlemgr.h"
+#include "particle_prototype.h"
+#include "particle_util.h"
+#include "c_basecombatcharacter.h"
+#include "ihasbuildpoints.h"
+
+class C_BaseTFPlayer;
+
+// Max Length of ID Strings
+#define MAX_ID_STRING		256
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_BaseObject : public C_BaseCombatCharacter, public IHasBuildPoints
+{
+	DECLARE_CLASS( C_BaseObject, C_BaseCombatCharacter );
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+	DECLARE_MINIMAP_PANEL();
+
+	C_BaseObject();
+	~C_BaseObject( void );
+
+	virtual bool	IsBaseObject( void ) const { return true; }
+	virtual bool	IsAnUpgrade(void ) const { return false; }
+	virtual bool	IsAVehicle( void ) const { return false; }
+
+	virtual void	SetType( int iObjectType );
+
+	virtual void	AddEntity();
+	virtual void	Select( void );
+
+	void			SetActivity( Activity act );
+	Activity		GetActivity( ) const;
+	void			SetObjectSequence( int sequence );
+	virtual void	OnActivityChanged( Activity act );
+
+	virtual void	PreDataUpdate( DataUpdateType_t updateType );
+	virtual void	PostDataUpdate( DataUpdateType_t updateType );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	Release( void );
+
+	virtual int		GetHealth() const { return m_iHealth; }
+	void			SetHealth( int health ) { m_iHealth = health; }
+	virtual int		GetMaxHealth() const { return m_iMaxHealth; }
+	int				GetObjectFlags( void ) { return m_fObjectFlags; }
+	void			SetObjectFlags( int flags ) { m_fObjectFlags = flags; }
+
+	// Derive to customize an object's attached version
+	virtual	void	SetupAttachedVersion( void ) { return; }
+	virtual void	SetupUnattachedVersion( void ) { return; }
+	virtual void	OnLostPower( void ) { return; };
+
+	virtual const char	*GetTargetDescription( void ) const;
+	virtual char	*GetIDString( void );
+	virtual bool	IsValidIDTarget( void );
+
+	void			AttemptToGoActive( void );
+	virtual bool	ShouldBeActive( void );
+	virtual void	OnGoActive( void );
+	virtual void	OnGoInactive( void );
+
+	virtual void	SetDormant( bool bDormant );
+
+	void			SendClientCommand( const char *pCmd );
+
+	virtual void FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options );
+
+	// Builder preview...
+	void			ActivateYawPreview( bool enable );
+	void			PreviewYaw( float yaw );
+	bool			IsPreviewingYaw() const;
+
+	// This is called to get the initial builder yaw...
+	virtual float	GetInitialBuilderYaw();
+	
+	virtual void	RecalculateIDString( void );
+
+	int GetType() const { return m_iObjectType; }
+	bool IsOwnedByLocalPlayer() const;
+	C_BaseTFPlayer *GetOwner();
+
+	// Are we under attack?
+	bool			IsUnderAttack( );
+
+	virtual int		DrawModel( int flags );
+	virtual bool	IsIdentityBrush( void );
+
+	// Effects
+	void			DrawRunningEffects( void );
+	void			DrawBuildEffects( void );
+	void			DrawDamageEffects( void );
+
+	// Deterioration
+	bool			IsDeteriorating( void ) { return m_bDeteriorating; };
+
+	float			GetPercentageConstructed( void ) { return m_flPercentageConstructed; }
+
+	bool			IsPlacing( void ) const { return m_bPlacing; }
+	bool			IsBuilding( void ) const { return m_bBuilding; }
+
+	virtual void	FinishedBuilding( void ) { return; }
+
+	virtual bool	OffsetObjectOrigin( Vector& origin );
+
+	virtual const char* GetStatusName() const;
+
+	// Object Previews
+	void			HighlightBuildPoints( int flags );
+
+public:
+	// Client/Server shared build point code
+	void				CreateBuildPoints( void );
+	void				AddAndParseBuildPoint( int iAttachmentNumber, KeyValues *pkvBuildPoint );
+	virtual int			AddBuildPoint( int iAttachmentNum );
+	virtual void		AddValidObjectToBuildPoint( int iPoint, int iObjectType );
+	virtual CBaseObject *GetBuildPointObject( int iPoint );
+	bool				IsBuiltOnAttachment( void ) { return (m_hBuiltOnEntity != NULL); }
+	void				AttachObjectToObject( CBaseEntity *pEntity, int iPoint, Vector &vecOrigin );
+	CBaseObject			*GetParentObject( void );
+	void				SetBuildPointPassenger( int iPoint, int iPassenger );
+	int					GetBuildPointPassenger( int iPoint ) const;
+
+	// Build points
+	CUtlVector<BuildPoint_t>	m_BuildPoints;
+
+	// Power
+	bool				IsPowered( void );
+	virtual bool		CanPowerupEver( int iPowerup );
+	virtual bool		CanPowerupNow( int iPowerup );
+
+	bool				IsDisabled( void ) { return m_bDisabled; }
+
+	virtual float		GetSapperAttachTime( void );
+
+// IHasBuildPoints
+public:
+	virtual int			GetNumBuildPoints( void ) const;
+	virtual bool		GetBuildPoint( int iPoint, Vector &vecOrigin, QAngle &vecAngles );
+	virtual int			GetBuildPointAttachmentIndex( int iPoint ) const;
+	virtual bool		CanBuildObjectOnBuildPoint( int iPoint, int iObjectType );
+	virtual void		SetObjectOnBuildPoint( int iPoint, CBaseObject *pObject );
+	virtual float		GetMaxSnapDistance( int iBuildPoint );
+	virtual bool		ShouldCheckForMovement( void ) { return true; }
+	virtual int			GetNumObjectsOnMe( void );
+	virtual CBaseEntity	*GetFirstObjectOnMe( void );
+	virtual CBaseObject *GetObjectOfTypeOnMe( int iObjectType );
+	virtual void		RemoveAllObjects( void );
+	virtual int			FindObjectOnBuildPoint( CBaseObject *pObject );
+ 	virtual void		GetExitPoint( CBaseEntity *pPlayer, int iPoint, Vector *pAbsOrigin, QAngle *pAbsAngles );
+
+	virtual bool TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr );
+
+protected:
+	char			m_szIDString[ MAX_ID_STRING ];
+
+private:
+	enum
+	{
+		YAW_PREVIEW_OFF	= 0,
+		YAW_PREVIEW_ON,
+		YAW_PREVIEW_WAITING_FOR_UPDATE
+	};
+
+	Activity		m_Activity;
+
+	int				m_fObjectFlags;
+	float			m_fYawPreview;
+	char			m_YawPreviewState;
+	CHandle< C_BaseTFPlayer >	m_hOldOwner;
+	CHandle< C_BaseTFPlayer > m_hBuilder;
+	bool			m_bWasActive;
+	int				m_iOldHealth;
+	bool			m_bHasSapper;
+	bool			m_bOldSapper;
+	int				m_iObjectType;
+	int				m_iHealth;
+	int				m_iMaxHealth;
+	bool			m_bWasBuilding;
+	bool			m_bBuilding;
+	bool			m_bPlacing;
+	bool			m_bDeteriorating;
+	bool			m_bDisabled;
+	float			m_flPercentageConstructed;
+	EHANDLE			m_hBuiltOnEntity;
+
+	CHealthBarPanel	*m_pHealthBar;
+	vgui::Label		*m_pNameLabel;
+	float			m_flDamageFlash;		// Used to flash the panel when the object takes damage
+	int				m_iFlashes;
+
+	float				m_flAttackTime;
+	CMaterialReference	m_ThermalMaterial;
+
+	// Effects
+	float			m_flNextEffect;
+
+private:
+	C_BaseObject( const C_BaseObject & ); // not defined, not accessible
+};
+
+#endif // C_BASEOBJECT_H
diff --git a/game/client/tf2/c_basetfplayer.cpp b/game/client/tf2/c_basetfplayer.cpp
new file mode 100644
index 0000000..a85c2ed
--- /dev/null
+++ b/game/client/tf2/c_basetfplayer.cpp
@@ -0,0 +1,2705 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_basetfplayer.h"
+#include "beamdraw.h"
+#include <stdarg.h>
+#include "ivmodemanager.h"
+#include "shake.h"
+#include "ivieweffects.h"
+#include "c_tfteam.h"
+#include "view.h"
+#include "UserCmd.h"
+#include "ivrenderview.h"
+#include "model_types.h"
+#include "view_shared.h"
+#include "hud_orders.h"
+#include "weapon_twohandedcontainer.h"
+#include "particles_simple.h"
+#include "playerandobjectenumerator.h"
+#include "iclientvehicle.h"
+#include "input.h"
+#include "basetfvehicle.h"
+#include "c_vehicle_teleport_station.h"
+#include "weapon_combatshield.h"
+#include "hud_vehicle_role.h"
+#include "hud_technologytreedoc.h"
+#include "iclientmode.h"
+#include "weapon_selection.h"
+#include "clienteffectprecachesystem.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+// Don't alias here
+#if defined( CBaseTFPlayer )
+#undef CBaseTFPlayer	
+#endif
+
+void CAM_ToThirdPerson(void);
+void CAM_ToFirstPerson(void);
+void FX_ReconParticle( const Vector &vecOrigin, bool bBlue );
+
+static ConVar tf2_showstate( "tf2_showstate", "0", 0, "Print state name\n" );
+extern ConVar mannedgun_usethirdperson;
+ConVar damageboost_modeloffset( "damageboost_modeloffset", "1" );
+ConVar damageboost_modelphasespeed_min( "damageboost_modelphasespeed_min", "99" );
+ConVar damageboost_modelphasespeed_max( "damageboost_modelphasespeed_max", "170" );
+
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheBaseTFPlayer )
+CLIENTEFFECT_MATERIAL( "sprites/physbeam" )
+CLIENTEFFECT_MATERIAL( "player/infiltratorcamo/infiltratorcamo" )
+CLIENTEFFECT_REGISTER_END()
+
+
+class CPersonalShieldEffect
+{
+public:
+
+	static CPersonalShieldEffect* Create( C_BaseTFPlayer *pEnt, const Vector &vOffsetFromEnt, const Vector &vIncomingDirection, int iDamage );
+
+				~CPersonalShieldEffect();
+
+	// Returns false if the effect is done and should be deleted.
+	bool		Update( float dt );
+	
+	void		Render();	// Draw the effect.
+
+private:
+
+				CPersonalShieldEffect();
+
+private:
+
+	CHandle<C_BaseTFPlayer> m_hEnt;
+	Vector		m_vOffsetFromEnt;
+	Vector		m_vIncomingDirection;
+	float		m_flDamage;
+
+	enum
+	{
+		NUM_TRACERS	= 10
+	};
+
+	Vector		m_vTracerEndPoints[NUM_TRACERS];	// These are relative to the model's origin.
+	float		m_flLifetimeRemaining;
+	float		m_flTotalLifetime;
+};
+
+
+CPersonalShieldEffect* CPersonalShieldEffect::Create( 
+	C_BaseTFPlayer *pEnt, 
+	const Vector &vOffsetFromEnt,
+	const Vector &vIncomingDirection, 
+	int iDamage )
+{
+	CPersonalShieldEffect *pRet = new CPersonalShieldEffect;
+	if ( pRet )
+	{
+		pRet->m_hEnt = pEnt;
+		pRet->m_vOffsetFromEnt = vOffsetFromEnt;
+		pRet->m_flDamage = iDamage;
+
+		Vector vNormal = vIncomingDirection;
+		VectorNormalize( vNormal );
+		
+		for ( int i=0; i < CPersonalShieldEffect::NUM_TRACERS; i++ )
+		{
+			pRet->m_vTracerEndPoints[i] = pRet->m_vOffsetFromEnt;
+			
+			Vector vOffset = RandomVector( -1, 1 );
+			
+			// Make it tangent to a sphere enclosing the player.
+			float flDot = vNormal.Dot( vOffset );
+			vOffset -= vNormal * flDot;
+
+			VectorNormalize( vOffset );
+			vOffset *= 10;
+
+			pRet->m_vTracerEndPoints[i] += vOffset;
+		}
+
+		pRet->m_flLifetimeRemaining = pRet->m_flTotalLifetime = 0.15;
+		pRet->m_vIncomingDirection = vIncomingDirection;
+	}
+	return pRet;
+}
+
+CPersonalShieldEffect::CPersonalShieldEffect()
+{
+}
+
+
+CPersonalShieldEffect::~CPersonalShieldEffect()
+{
+}
+
+
+bool CPersonalShieldEffect::Update( float dt )
+{
+	if ( !m_hEnt.Get() )
+		return false;
+
+	m_flLifetimeRemaining -= dt;
+	if ( m_flLifetimeRemaining >= 0 )
+	{
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+
+void CPersonalShieldEffect::Render()
+{
+	if ( !m_hEnt.Get() )
+		return;
+
+	Vector vCenter = m_hEnt->WorldSpaceCenter( );
+
+	const Vector vBasePos = vCenter + m_vOffsetFromEnt;
+	IMaterial *pMat = materials->FindMaterial( "sprites/physbeam", TEXTURE_GROUP_CLIENT_EFFECTS );
+
+	CBeamSeg seg;
+
+	// Get redder as their health goes down.
+	float flColor = (float)m_hEnt->GetHealth() / m_hEnt->GetMaxHealth();
+	flColor = clamp(flColor, 0, 1);
+	seg.m_vColor.Init( 0.5 + 0.5*flColor, flColor, flColor );
+
+	seg.m_flAlpha = 1;
+	seg.m_flTexCoord = 0;
+	seg.m_flWidth = 2;
+
+	for ( int i=0; i < CPersonalShieldEffect::NUM_TRACERS; i++ )
+	{
+		const Vector vEndPos = vCenter + m_vTracerEndPoints[i];
+
+		static int nSegs = 5;
+
+		CBeamSegDraw beamDraw;
+		beamDraw.Start( nSegs, pMat );
+		
+		for ( int iSeg=0; iSeg < nSegs; iSeg++ )
+		{
+			float t = (float)iSeg / (nSegs-1);
+			VectorLerp( vBasePos, vEndPos, t, seg.m_vPos );
+			
+			// Add a random offset.
+			seg.m_vPos += RandomVector( -3, 3 );
+			seg.m_flTexCoord += 0.1f;
+			
+			beamDraw.NextSeg( &seg );
+		}
+		
+		beamDraw.End();
+	}
+
+/*
+	Vector vEggBounds[2];
+	m_hEnt->GetBounds( vEggBounds[0], vEggBounds[1] );
+	vEggBounds[0] += m_hEnt->GetAbsOrigin();
+	vEggBounds[1] += m_hEnt->GetAbsOrigin();
+	Vector vEggCenter = (vEggBounds[0] + vEggBounds[1]) * 0.5f;
+	Vector vEggDims = (vEggBounds[1] - vEggBounds[0]) * 0.5f;
+
+	Vector vUp( 0, 0, 1 );
+	Vector vForward = m_vIncomingDirection;
+	vForward.z = 0;
+	VectorNormalize( vForward );
+	Vector vRight = vUp.Cross( vForward );
+
+	// Now draw an eggshell around the player showing their health.
+	seg.m_vColor.Init( 1, flColor, flColor );
+	seg.m_flAlpha = 0.3f;
+	seg.m_flWidth = 1;
+
+	static int nSamples = 30;
+	CBeamSegDraw beamDraw;
+	beamDraw.Start( nSamples, pMat );
+
+	for ( int iSeg=0; iSeg < nSamples; iSeg++ )
+	{
+		float t = (float)iSeg / (nSamples-1);
+		float angle = M_PI * 2.0f * t;
+		seg.m_vPos = vEggCenter + vUp*vEggDims.z*sin( angle ) + vRight*vEggDims.x*cos( angle );
+		beamDraw.NextSeg( &seg );
+	}
+
+	beamDraw.End();
+*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Helper for animation state machine
+// Input  : clear - 
+//			destination - 
+//			*pFormat - 
+//			... - 
+//-----------------------------------------------------------------------------
+void StatusPrintf( bool clear, int destination, char *pFormat, ... )
+{
+	if ( destination != 4 && destination != 5 )
+		return;
+	char data[ 2048 ];
+	va_list argptr;
+
+	va_start( argptr, pFormat );
+	Q_vsnprintf( data, sizeof( data ), pFormat, argptr );
+	va_end( argptr );
+
+	char *out = data;
+	if ( destination == 5 )
+		out += 2;
+
+	if ( destination == 5 )
+	{
+		char slot[3];
+		Q_strncpy( slot, data, 3 );
+
+		slot[2] = 0;
+
+		int s = atoi( slot );
+		s &= 31;
+
+		engine->Con_NPrintf( s, "%s", out );
+	}
+	else
+	{
+		Msg( "%s", out );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: RecvProxy that converts the Player's object UtlVector to entindexes
+//-----------------------------------------------------------------------------
+void RecvProxy_PlayerObjectList( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	CTFPlayerLocalData *pLocalData = (CTFPlayerLocalData*)pStruct;
+	CBaseHandle *pHandle = (CBaseHandle*)(&(pLocalData->m_aObjects[pData->m_iElement])); 
+	RecvProxy_IntToEHandle( pData, pStruct, pHandle );
+}
+
+
+void RecvProxyArrayLength_PlayerObjects( void *pStruct, int objectID, int currentArrayLength )
+{
+	CTFPlayerLocalData *pLocalData = (CTFPlayerLocalData*)pStruct;
+	
+	if ( pLocalData->m_aObjects.Count() != currentArrayLength )
+	{
+		pLocalData->m_aObjects.SetSize( currentArrayLength );
+	}
+}
+
+BEGIN_RECV_TABLE_NOBASE( CTFPlayerLocalData, DT_TFLocal )
+	RecvPropInt( RECVINFO(m_nInTacticalView) ),
+	RecvPropInt( RECVINFO( m_bKnockedDown )),
+	RecvPropVector( RECVINFO( m_vecKnockDownDir )),
+	RecvPropInt( RECVINFO( m_bThermalVision )),
+	RecvPropInt( RECVINFO( m_iIDEntIndex )),
+	RecvPropArray( RecvPropInt( RECVINFO(m_iResourceAmmo[0])), m_iResourceAmmo),	
+	RecvPropInt( RECVINFO(m_iBankResources) ),
+	RecvPropArray2( 
+		RecvProxyArrayLength_PlayerObjects,
+		RecvPropInt( "player_object_array_element", 0, SIZEOF_IGNORE, 0, RecvProxy_PlayerObjectList ), 
+		MAX_OBJECTS_PER_PLAYER, 
+		0, 
+		"player_object_array"	),
+	RecvPropInt( RECVINFO( m_bAttachingSapper ) ),
+	RecvPropFloat( RECVINFO( m_flSapperAttachmentFrac ) ),
+	RecvPropInt( RECVINFO( m_bForceMapOverview ) ),
+END_RECV_TABLE()
+
+IMPLEMENT_CLIENTCLASS_DT(C_BaseTFPlayer, DT_BaseTFPlayer, CBaseTFPlayer)
+	RecvPropDataTable(RECVINFO_DT(m_TFLocal),0, &REFERENCE_RECV_TABLE(DT_TFLocal), DataTableRecvProxy_StaticDataTable),
+
+	// Class Data Tables
+	RecvPropInt( RECVINFO(m_iPlayerClass)),
+	RecvPropDataTable( RECVINFO_DT( m_PlayerClasses ), 0, &REFERENCE_RECV_TABLE( DT_AllPlayerClasses ), DataTableRecvProxy_StaticDataTable ),
+
+	RecvPropEHandle( RECVINFO( m_hSelectedMCV ) ),
+	RecvPropInt( RECVINFO(m_iCurrentZoneState ) ),
+	RecvPropInt( RECVINFO(m_iMaxHealth ) ),
+	RecvPropInt( RECVINFO(m_TFPlayerFlags) ),
+	RecvPropInt( RECVINFO( m_bUnderAttack )),
+	RecvPropInt( RECVINFO( m_bIsBlocking )),
+
+	// Sniper - will get moved to a class data table
+	RecvPropVector( RECVINFO(m_vecDeployedAngles) ),
+	RecvPropInt( RECVINFO( m_bDeployed )),
+	RecvPropInt( RECVINFO( m_bDeploying )),
+	RecvPropInt( RECVINFO( m_bUnDeploying )),
+
+	// Infiltrator - will get moved to a class data table
+	RecvPropFloat( RECVINFO( m_flCamouflageAmount )),
+	RecvPropEHandle(RECVINFO(m_hSpawnPoint)),
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( CTFPlayerLocalData )
+
+	DEFINE_PRED_FIELD( m_nInTacticalView, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bKnockedDown, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_vecKnockDownDir, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bThermalVision, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+//	DEFINE_PRED_FIELD( m_iIDEntIndex, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_iBankResources, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_ARRAY( m_iResourceAmmo, FIELD_INTEGER, RESOURCE_TYPES, FTYPEDESC_INSENDTABLE ),
+	//DEFINE_PRED_ARRAY( m_aObjects, FIELD_EHANDLE, MAX_OBJECTS_PER_PLAYER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bAttachingSapper, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flSapperAttachmentFrac, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bForceMapOverview, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+
+// TODO: consolidate all these includes and the DEFINE_PRED... for each class type
+// into tf_shareddefs.h.
+#include "c_tf_class_commando.h"
+#include "c_tf_class_defender.h"
+#include "c_tf_class_escort.h"
+#include "c_tf_class_infiltrator.h"
+#include "c_tf_class_medic.h"
+#include "c_tf_class_recon.h"
+#include "c_tf_class_sniper.h"
+#include "c_tf_class_support.h"
+#include "c_tf_class_sapper.h"
+#include "c_tf_class_pyro.h"
+
+
+BEGIN_PREDICTION_DATA( C_BaseTFPlayer )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_TFLocal, CTFPlayerLocalData ),
+	
+	DEFINE_PRED_FIELD( m_flCycle, FIELD_FLOAT, FTYPEDESC_INSENDTABLE | FTYPEDESC_PRIVATE | FTYPEDESC_OVERRIDE ),
+	DEFINE_PRED_FIELD( m_flPlaybackRate, FIELD_FLOAT, FTYPEDESC_INSENDTABLE | FTYPEDESC_PRIVATE | FTYPEDESC_OVERRIDE ),
+
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_COMMANDO], C_PlayerClassCommando ),
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_DEFENDER], C_PlayerClassDefender ),
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_ESCORT], C_PlayerClassEscort ),
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_INFILTRATOR], C_PlayerClassInfiltrator ),
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_MEDIC], C_PlayerClassMedic ),
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_RECON], C_PlayerClassRecon ),
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_SNIPER], C_PlayerClassSniper ),
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_SUPPORT], C_PlayerClassSupport ),
+	DEFINE_PRED_TYPEDESCRIPTION_PTR( m_PlayerClasses.m_pClasses[TFCLASS_SAPPER], C_PlayerClassSapper ),
+
+	DEFINE_PRED_FIELD( m_iPlayerClass, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flCamouflageAmount, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_hSpawnPoint, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_iMaxHealth, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bDeployed, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bDeploying, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bUnDeploying, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_vecDeployedAngles, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_iCurrentZoneState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_TFPlayerFlags, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bUnderAttack, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+
+	DEFINE_PRED_FIELD( m_vecConstraintCenter, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flConstraintRadius, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flConstraintWidth, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flConstraintSpeedFactor, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+
+	DEFINE_FIELD( m_vecPosDelta, FIELD_VECTOR ),
+	DEFINE_ARRAY( m_aMomentum, FIELD_FLOAT, C_BaseTFPlayer::MOMENTUM_MAXSIZE ),
+	DEFINE_FIELD( m_iMomentumHead, FIELD_INTEGER ),
+	//DEFINE_FIELD( m_iSelectedTarget, FIELD_INTEGER ),
+	//DEFINE_FIELD( m_iPersonalTarget, FIELD_INTEGER ),
+	//DEFINE_FIELD( m_iLastHealth, FIELD_INTEGER ),
+	//DEFINE_FIELD( m_nOldTacticalView, FIELD_INTEGER ),
+	//DEFINE_FIELD( m_nOldPlayerClass, FIELD_INTEGER ),
+	//DEFINE_FIELD( m_bOldThermalVision, FIELD_BOOLEAN ),
+	//DEFINE_FIELD( m_bOldKnockDownState, FIELD_BOOLEAN ),
+	//DEFINE_FIELD( m_flStartKnockdown, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flEndKnockdown, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_vecOriginalViewAngles, FIELD_VECTOR ),
+	//DEFINE_FIELD( m_vecCurrentKnockdownAngles, FIELD_VECTOR ),
+	//DEFINE_FIELD( m_vecKnockDownGoalAngles, FIELD_VECTOR ),
+	//DEFINE_FIELD( m_bKnockdownOverrideAngles, FIELD_BOOLEAN ),
+	//DEFINE_FIELD( m_flKnockdownViewheightAdjust, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flLastMoveTime, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_vecLastOrigin, FIELD_VECTOR ),
+	//DEFINE_FIELD( m_flLastDamageTime, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flLastGainHealthTime, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flDampeningAmount, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flGoalDampeningAmount, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flDampeningStayoutTime, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flMovementCamoSuppression, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flGoalMovementCamoSuppressionAmount, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flMovementCamoSuppressionStayoutTime, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_flNextAdrenalinEffect, FIELD_FLOAT ),
+	//DEFINE_FIELD( m_bFadingIn, FIELD_BOOLEAN ),
+	//DEFINE_FIELD( m_iIDEntIndex, FIELD_INTEGER ),
+	//DEFINE_ARRAY( m_BoostModelAngles, FIELD_FLOAT, 3 ),
+
+	// DEFINE_PRED_TYPEDESCRIPTION( m_RideVehicle, CRideVehicle ),
+	// DEFINE_FIELD( m_aTargetReticles, CUtlVector < CTargetReticle * > ),
+	// DEFINE_FIELD( m_aSpyCameras, CUtlVector < C_SpyCamera * > ),
+	// DEFINE_FIELD( m_ParticleEffect, CParticleEffectBinding ),
+	// DEFINE_FIELD( m_ParticleTimer, TimedEvent ),
+	// DEFINE_FIELD( m_MaterialHandle, PMaterialHandle ),
+	// DEFINE_FIELD( m_pParticleMgr, CParticleMgr ),
+	// DEFINE_FIELD( m_pThermalMaterial, IMaterial ),
+	// DEFINE_FIELD( m_pCamoEffectMaterial, IMaterial ),
+	// DEFINE_FIELD( m_BoostMaterial, CMaterialReference ),
+	// DEFINE_FIELD( m_EMPMaterial, CMaterialReference ),
+	// DEFINE_FIELD( m_PersonalShieldEffects, CUtlLinkedList < CPersonalShieldEffect* , int > ),
+	// DEFINE_FIELD( m_hSelectedOrder, CHandle < C_Order > ),
+	// DEFINE_FIELD( m_hPersonalOrder, FIELD_EHANDLE ),
+	// DEFINE_FIELD( m_hSelectedObject, CHandle < C_BaseObject > ),
+
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( player, C_BaseTFPlayer );
+
+ConVar cl_TargetInfoFadeDist("cl_TargetInfoFadeDist", "800", 0, "Distance at which TF player targetting info fades out.");
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the local player is the specified class
+//-----------------------------------------------------------------------------
+bool IsLocalPlayerClass( int iClass )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer )
+	{
+		return ( pPlayer->PlayerClass() == iClass );
+	}
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the local player's class
+//-----------------------------------------------------------------------------
+int GetLocalPlayerClass( void )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer )
+	{
+		return pPlayer->PlayerClass();
+	}
+	return TFCLASS_UNDECIDED;
+}
+
+//-----------------------------------------------------------------------------
+// returns true if the local player is in tactical view
+//-----------------------------------------------------------------------------
+bool IsLocalPlayerInTactical( void )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if (!pPlayer)
+		return false;
+
+	return !!pPlayer->m_TFLocal.m_nInTacticalView;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_BaseTFPlayer::C_BaseTFPlayer() :
+	m_PlayerClasses( this ), m_PlayerAnimState( this )
+{
+	Clear();
+}
+
+void C_BaseTFPlayer::Clear()
+{
+	m_iPlayerClass = TFCLASS_UNDECIDED;
+	m_iCurrentZoneState = 0;
+	m_TFPlayerFlags = 0;
+	m_hSelectedOrder = NULL;
+	m_hPersonalOrder = NULL;
+	m_hSelectedObject = NULL;
+	m_iSelectedTarget = 0;
+	m_iPersonalTarget = 0;
+	m_iIDEntIndex = 0;
+	m_bStoreRagdollInfo	= true;
+	m_flNextUseCheck = 0;
+	m_pSapperAttachmentStatus = NULL;
+	
+	int i;
+	for ( i=0; i < ARRAYSIZE( m_BoostModelAngles ); i++ )
+	{
+		m_BoostModelAngles[i] = RandomFloat( 0, 360 );
+	}
+
+
+	for ( i = 0; i < MOMENTUM_MAXSIZE; i++ )
+	{
+		m_aMomentum[ i ] = 1.0f;
+	}
+}
+
+
+bool C_BaseTFPlayer::IsHidden() const
+{
+	return (m_TFPlayerFlags & TF_PLAYER_HIDDEN) != 0;
+}
+
+
+bool C_BaseTFPlayer::IsDamageBoosted() const
+{
+	return (m_TFPlayerFlags & TF_PLAYER_DAMAGE_BOOST) != 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_BaseTFPlayer::~C_BaseTFPlayer()
+{
+	int iSize = m_aTargetReticles.Size();
+	for (int i = iSize-1; i >= 0; i-- )
+	{
+		delete m_aTargetReticles[i];
+	}
+	m_aTargetReticles.Purge();
+
+	if ( m_pThermalMaterial )
+	{
+		m_pThermalMaterial->DecrementReferenceCount();
+	}
+	if ( m_pCamoEffectMaterial )
+	{
+		m_pCamoEffectMaterial->DecrementReferenceCount();
+	}
+
+	m_PersonalShieldEffects.PurgeAndDeleteElements();
+
+	if ( m_pSapperAttachmentStatus )
+	{
+		delete m_pSapperAttachmentStatus;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Add, remove object from the panel 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	ENTITY_PANEL_ACTIVATE( "player", !bDormant );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::HasNamedTechnology( const char *name )
+{
+	CTechnologyTree *pTree = GetTechnologyTreeDoc().GetTechnologyTree();
+	if ( !pTree )
+		return false;
+
+	CBaseTechnology *pItem = pTree->GetTechnology(name);
+	// If the tech doesn't exist, everyone has it by default
+	if ( !pItem )
+		return true;
+
+	return pItem->GetActive();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::ShouldDraw()
+{
+	if ( IsHidden() )
+		return false;
+
+	C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
+	if ( local && local->IsUsingThermalVision() )
+		return true;
+
+	// Draw the local player if he's the driver of a vehicle.
+	// We can safely return true here because vehicles will hide drivers that shouldn't be visible.
+	if ( mannedgun_usethirdperson.GetInt() && IsVehicleMounted() && IsLocalPlayer() )
+	{
+		IClientVehicle *pVehicle = GetVehicle();
+		int nRole = pVehicle->GetPassengerRole( this );
+		if ( nRole == VEHICLE_ROLE_DRIVER )
+			return !IsEffectActive(EF_NODRAW);
+	}
+
+	return BaseClass::ShouldDraw();
+}
+
+
+//-----------------------------------------------------------------------------
+// Should this object cast shadows?
+//-----------------------------------------------------------------------------
+ShadowType_t C_BaseTFPlayer::ShadowCastType()
+{
+	// FIXME: This check can be removed once we've dealt with the interpolation problem
+	C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
+	if (local == this)
+		return SHADOWS_NONE;
+
+	if (IsCamouflaged())
+		return SHADOWS_NONE;
+
+	return SHADOWS_RENDER_TO_TEXTURE_DYNAMIC;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called once per frame for the local player only.
+//  Called after rendering ( called in PostRender() ) the 3d objects ( i.e., other players ) 
+//  but before vgui paints 2d overlays so that we can update the positions of all world 
+//  targets before rendering
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::UpdateTargetReticles( void )
+{
+	// Update all the target reticles
+	for ( int i = 0; i < m_aTargetReticles.Size(); i++ )
+	{
+		m_aTargetReticles[i]->Update();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called to update hud elements contained in the player
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::ClientThink( void )
+{
+	BaseClass::ClientThink();
+
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+
+	CheckKnockdownState();
+	CheckMovementCamoSuppression();
+	CheckCamoDampening();
+	CheckLastMovement();
+	CheckAdrenalin();
+	UpdateIDTarget();
+
+	// update personal shield effects.
+	int iNext;
+	for ( int i=m_PersonalShieldEffects.Head(); i != m_PersonalShieldEffects.InvalidIndex(); i = iNext )
+	{
+		iNext = m_PersonalShieldEffects.Next( i );
+		CPersonalShieldEffect *pEffect = m_PersonalShieldEffects[i];
+
+		if ( !pEffect->Update( gpGlobals->frametime ) )
+		{
+			delete pEffect;
+			m_PersonalShieldEffects.Remove( i );
+		}
+	}
+
+	// Let the classes think as well.
+	if ( GetPlayerClass() )
+	{
+		GetPlayerClass()->ClassThink();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Store off old movetype ( commander or not )
+// Input  : bnewentity - 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::OnPreDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnPreDataChanged( updateType );
+
+	m_nOldTacticalView = m_TFLocal.m_nInTacticalView;
+
+	m_iLastHealth = GetHealth();
+	m_bOldKnockDownState = m_TFLocal.m_bKnockedDown; 
+
+	m_bOldThermalVision = m_TFLocal.m_bThermalVision;
+
+	m_nOldPlayerClass = m_iPlayerClass;
+
+	// Chain.
+	if ( GetPlayerClass() )
+	{
+		GetPlayerClass()->ClassPreDataUpdate();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Switch to/from commander mode if necessary
+// Input  : bnewentity - 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::OnDataChanged( DataUpdateType_t updateType )
+{
+	bool bnewentity = (updateType == DATA_UPDATE_CREATED);
+	if ( bnewentity )
+	{
+		// Do the minimap panel thing here because we don't
+		// want predicted players to have traces
+		CONSTRUCT_MINIMAP_PANEL( "minimap_player", MINIMAP_PLAYERS );
+
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+		m_BoostMaterial.Init( "player/damageboost/thermal", TEXTURE_GROUP_CLIENT_EFFECTS );
+		m_EMPMaterial.Init( "player/empeffect", TEXTURE_GROUP_CLIENT_EFFECTS );
+	}
+
+	BaseClass::OnDataChanged( updateType );
+
+	// Only care about this stuff for the local player
+	if ( IsLocalPlayer() )
+	{
+		// Check to see if we switched into/out of the commander mode.
+		if ( m_TFLocal.m_nInTacticalView != m_nOldTacticalView )
+		{
+			// Is this the local player
+			C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+			if ( player == this )
+			{
+				// Tell mode switcher that server changed our mode
+				modemanager->SwitchMode( m_TFLocal.m_nInTacticalView ? true : false, false );
+			}
+		}
+
+		// Knockdown
+		if ( m_bOldKnockDownState != m_TFLocal.m_bKnockedDown )
+		{
+			if ( IsKnockedDown() )
+			{
+				m_flStartKnockdown = gpGlobals->curtime;
+				m_vecOriginalViewAngles = GetAbsAngles();
+				
+				m_vecKnockDownGoalAngles = m_TFLocal.m_vecKnockDownDir;
+			}
+			else
+			{
+				m_flEndKnockdown = gpGlobals->curtime;
+			}
+		}
+
+		// Thermal Vision
+		if ( m_bOldThermalVision != m_TFLocal.m_bThermalVision )
+		{
+			if ( m_TFLocal.m_bThermalVision )
+			{
+				ScreenFade_t sf;
+				memset( &sf, 0, sizeof( sf ) );
+				sf.a = 128;
+				sf.r = 0;
+				sf.g = 0;
+				sf.b = 255;
+				sf.duration = 0;	// not used
+				sf.holdTime = (float)(1<<SCREENFADE_FRACBITS) * 30.0f;
+				sf.fadeFlags = FFADE_STAYOUT;
+				vieweffects->Fade( sf );
+			}
+			else
+			{
+				vieweffects->ClearPermanentFades();
+			}		
+		}
+
+		if ( m_nOldPlayerClass != m_iPlayerClass )
+		{
+			engine->ClientCmd( "cancelselect\n" );
+		}
+	}
+
+	if ( bnewentity )
+	{
+		m_iLastHealth = GetHealth();
+		m_flLastDamageTime = -10000;
+		m_flLastGainHealthTime = -10000;
+	}
+
+	if (m_iLastHealth != GetHealth())
+	{
+		if (m_iLastHealth > GetHealth())
+		{
+			if (GetHealth() < GetMaxHealth())
+			{
+				m_flLastDamageTime = gpGlobals->curtime;
+
+				C_TFTeam *pTeam = static_cast<C_TFTeam*>(GetTeam());
+				if (pTeam && !IsLocalPlayer() && m_bUnderAttack )
+					pTeam->NotifyBaseUnderAttack( GetAbsOrigin(), false );
+			}
+		}
+		else
+		{
+			m_flLastGainHealthTime = gpGlobals->curtime;
+
+			// If we were just fully healed, remove all decals
+			if ( GetHealth() >= GetMaxHealth() )
+			{
+				RemoveAllDecals();
+			}
+		}
+	}
+
+	// Snap to 100 % since we round down
+	if ( m_flCamouflageAmount > 99.0f )
+	{
+		m_flCamouflageAmount = 100.0f;
+	}
+
+	// Chain.
+	if ( GetPlayerClass() )
+	{
+		GetPlayerClass()->ClassOnDataChanged();
+	}
+} 
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::PreDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PreDataUpdate( updateType );
+
+	m_bOldAttachingSapper = m_TFLocal.m_bAttachingSapper;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::PostDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PostDataUpdate( updateType );
+
+	// Only care about this stuff for the local player
+	if ( IsLocalPlayer() )
+	{
+		// Sapper attachment
+		if ( m_bOldAttachingSapper != m_TFLocal.m_bAttachingSapper || m_TFLocal.m_bAttachingSapper )
+		{
+			if ( !m_pSapperAttachmentStatus )
+			{
+				// Create the attachment status
+				m_pSapperAttachmentStatus = new CHealthBarPanel();
+				vgui::Panel *pParent = g_pClientMode->GetViewport();
+				m_pSapperAttachmentStatus->SetParent( pParent );
+				m_pSapperAttachmentStatus->SetAutoDelete( false );
+				m_pSapperAttachmentStatus->SetPos( XRES(320) - XRES(40), YRES(250) );
+				m_pSapperAttachmentStatus->SetSize( XRES(80), YRES(8) );
+				m_pSapperAttachmentStatus->SetGoodColor( 240, 180, 63, 192 );
+				m_pSapperAttachmentStatus->SetBadColor( 0, 0, 0, 192 );
+			}
+
+			m_pSapperAttachmentStatus->SetVisible( m_TFLocal.m_bAttachingSapper );
+			if ( m_TFLocal.m_bAttachingSapper )
+			{
+				m_pSapperAttachmentStatus->SetHealth( m_TFLocal.m_flSapperAttachmentFrac );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::ReceiveMessage( int classID, bf_read &msg )
+{
+	if ( classID != GetClientClass()->m_ClassID )
+	{
+		// message is for subclass
+		BaseClass::ReceiveMessage( classID, msg );
+		return;
+	}
+
+	int messageType = msg.ReadByte();
+	switch( messageType )
+	{
+	case BASEENTITY_MSG_REMOVE_DECALS:
+		{
+			RemoveAllDecals();
+		}
+		break;
+	case PLAYER_MSG_PERSONAL_SHIELD:
+		{
+			Vector vOffsetFromEnt;
+			msg.ReadBitVec3Coord( vOffsetFromEnt );
+
+			// Show a personal shield effect.
+			Vector vIncomingDirection;
+			msg.ReadBitVec3Normal( vIncomingDirection );
+
+			short iDamage = msg.ReadShort();
+
+			// Show the effect.
+			CPersonalShieldEffect *pEffect = CPersonalShieldEffect::Create( this, vOffsetFromEnt, vIncomingDirection, iDamage );
+			if ( pEffect )
+				m_PersonalShieldEffects.AddToTail( pEffect );
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Free this entity
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::Release( void )
+{
+	// Remove any reticles on this entity
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer )
+	{
+		pPlayer->Remove_Target( this );
+	}
+
+	BaseClass::Release();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::ItemPostFrame( void )
+{
+	if ( m_flNextUseCheck < gpGlobals->curtime )		
+	{
+		m_flNextUseCheck = gpGlobals->curtime + 0.3;
+
+		CVehicleRoleHudElement *pElement = GET_HUDELEMENT( CVehicleRoleHudElement );
+		Assert( pElement );
+		pElement->ShowVehicleRole( -1 );
+
+		// See if there's an entity we can +use
+		if ( IsAlive() && !GetVehicle() && ( gpGlobals->curtime > m_flNextAttack ) )
+		{
+			CBaseEntity *pUseEntity = FindUseEntity();
+			if ( pUseEntity )
+			{
+				// Vehicles need to show we're going to get in them
+				C_BaseTFVehicle *pVehicle = dynamic_cast<C_BaseTFVehicle*>( pUseEntity );
+				if ( pVehicle && InSameTeam(pVehicle) && !pVehicle->IsPlacing() && !pVehicle->IsBuilding() && pVehicle->GetMaxPassengerCount() >= 2 )
+				{
+					pElement->ShowVehicleRole( pVehicle->LocateEntryPoint( this ) );
+				}
+			}
+		}
+	}
+
+	// Don't process items while in a vehicle.
+	if ( IsInAVehicle() )
+	{
+		IClientVehicle *pVehicle = GetVehicle();
+		Assert( pVehicle );
+
+		// NOTE: We *have* to do this before ItemPostFrame because ItemPostFrame
+		// may dump us out of the vehicle
+		int nRole = pVehicle->GetPassengerRole( this );
+		bool bUsingStandardWeapons = pVehicle->IsPassengerUsingStandardWeapons( nRole );
+
+		pVehicle->ItemPostFrame( this );
+
+		// Fall through and check weapons, etc. if we're using them 
+		if (!bUsingStandardWeapons || !IsInAVehicle())
+			return;
+	}
+
+	// If we're attaching a sapper, handle player use only
+	if ( m_TFLocal.m_bAttachingSapper )
+	{
+		PlayerUse();
+		return;
+	}
+
+	BaseClass::ItemPostFrame();
+
+#if 0
+	if ( GetPlayerClass()  )
+	{
+		GetPlayerClass()->ItemPostFrame();	// Let the player class handle it.
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if I'm in a vehicle that's mounted on another vehicle
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsVehicleMounted() const
+{
+	CBaseTFVehicle *pVehicle = dynamic_cast< CBaseTFVehicle* >( GetMoveParent() );
+	if ( pVehicle )
+		return dynamic_cast< CBaseTFVehicle* >( pVehicle->GetMoveParent() ) != NULL;
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_BaseTFPlayer::DrawModel( int flags )
+{
+	int drawn = 0;
+
+	if ( !m_bReadyToDraw )
+		return 0;
+
+	QAngle saveAngles(0,0,0);
+	Vector saveLocalOrigin(0,0,0);
+	bool angleschanged = false;
+	bool originchanged = false;
+
+	// If we're in a vehicle, use the vehicle's angles for the local player
+	if ( IsInAVehicle() && !IsInAVehicle() )
+	{
+		IClientVehicle *pVehicle = GetVehicle();
+		int nRole = pVehicle->GetPassengerRole( this );
+		if ( nRole == VEHICLE_ROLE_DRIVER )
+		{
+			C_BaseTFVehicle *pVehicleEntity = (CBaseTFVehicle*)pVehicle->GetVehicleEnt();
+			angleschanged = true;
+			SetLocalAngles( pVehicleEntity->GetPassengerAngles( saveAngles, VEHICLE_ROLE_DRIVER ) );
+
+			// HACK: Stomp the origin
+			originchanged = true;
+			SetLocalOrigin( vec3_origin );
+		}
+	}
+	else
+	{
+		angleschanged = true;
+		SetLocalAngles( m_PlayerAnimState.GetRenderAngles() );
+	}
+
+	drawn = BaseClass::DrawModel(flags);
+
+	if ( angleschanged )
+	{
+		SetLocalAngles( saveAngles );
+	}
+	if ( originchanged )
+	{
+		SetLocalOrigin( saveLocalOrigin );
+	}
+
+	// Draw all personal shield effects.
+	FOR_EACH_LL( m_PersonalShieldEffects, i )
+	{
+		m_PersonalShieldEffects[i]->Render();
+	}
+
+	return drawn;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_BaseTFPlayer::GetClass( void )
+{
+	if ( !GetPlayerClass() )
+		return TFCLASS_UNDECIDED;
+
+	return m_iPlayerClass;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::OverrideView( CViewSetup *pSetup )
+{
+	if ( CheckKnockdownAngleOverride() )
+	{
+		float adj = GetKnockdownViewheightAdjust();
+
+		pSetup->origin.z -= adj;
+
+		return;
+	}
+
+	BaseClass::OverrideView( pSetup );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::ShouldDrawViewModel()
+{
+	if ( CheckKnockdownAngleOverride() )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Hack to search up the hierarchy looking for bones whose ultimate parent is 1 ( i.e., the pelvis ) since
+//  these are the lower body bones
+//-----------------------------------------------------------------------------
+bool ParentIsPelvis( mstudiobone_t *bones, int start, int pelvis, int spine )
+{
+	int current = start;
+
+	while ( bones[ current ].parent )
+	{
+		// Root?
+		if ( bones[ current ].parent <= 0 )
+		{
+			return false;
+		}
+
+		if ( bones[ current ].parent == pelvis )
+			return true;
+
+		if ( bones[ current ].parent == spine )
+			return false;
+
+		current = bones[ current ].parent;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Hack to find the bone indices of the pelvis and the spine so we can 
+//   more quickly determine if a bones parent is the pelvis so we can merge bones correctly
+//-----------------------------------------------------------------------------
+static void FindPelvisAndSpine( int numbones, mstudiobone_t *bones, int *pelvis, int *spine )
+{
+	*pelvis = *spine = -1;
+
+	mstudiobone_t *bone = bones;
+	for ( int i = 0; i < numbones; i++, bone++ )
+	{
+		if ( !stricmp( bone->pszName(), "Bip01 Pelvis" ) )
+		{
+			*pelvis = i;
+		}
+		else if ( !stricmp( bone->pszName(), "Bip01 Spine" ) )
+		{
+			*spine = i;
+		}
+
+		if ( *spine >= 0 && *pelvis >= 0 )
+			break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Another hack, the TFC 1.5 v. 2 models expect controllers at the midpoint
+// Input  : controllers[MAXSTUDIOBONECTRLS] - 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS])
+{
+	// Set controllers to a their zero value.
+	for(int i=0; i < MAXSTUDIOBONECTRLS; i++)
+	{
+		controllers[i] = 0.5;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a text description for the object target
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::GetTargetDescription( char *pDest, int bufferSize )
+{
+	const char *pStr = GetPlayerName();
+	if ( pStr )
+	{
+		Q_strncpy( pDest, pStr, bufferSize );
+	}
+	else
+	{
+		pDest[0] = 0;
+	}
+}
+
+//=====================================================================================================
+// ORDERS
+//=====================================================================================================
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Player has received a new personal order
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::SetPersonalOrder( C_Order *pOrder )
+{
+	// Do we have an order already?
+	RemoveOrderTarget();
+
+	m_hPersonalOrder = pOrder;
+	m_iPersonalTarget = pOrder->GetTarget();
+
+	// Add a new target to our list
+	if ( pOrder->ShouldDrawReticle() )
+	{
+		int iTargetIndex = pOrder->GetTarget();
+		if ( iTargetIndex )
+		{
+			C_BaseEntity *pTarget = cl_entitylist->GetBaseEntity( iTargetIndex );
+			if ( pTarget )
+			{
+				char desc[512];
+				pOrder->GetTargetDescription( desc, sizeof( desc ) );
+				Add_Target( pTarget, desc );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove the target reticle for the specified order
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::RemoveOrderTarget()
+{
+	if ( m_iPersonalTarget )
+	{
+		C_BaseEntity *pTarget = cl_entitylist->GetBaseEntity( m_iPersonalTarget );
+		if ( pTarget )
+		{
+			Remove_Target( pTarget );
+		}
+
+		m_iPersonalTarget = 0;
+	}
+}
+
+//====================================================================================================
+// RESOURCES
+//====================================================================================================
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_BaseTFPlayer::GetBankResources( void )
+{
+	return m_TFLocal.m_iBankResources;
+}
+
+
+//====================================================================================================
+// OBJECTS
+//====================================================================================================
+// Purpose: Player has selected an Object
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::SetSelectedObject( C_BaseObject *pObject )
+{
+	// Do we have an order already?
+	if ( m_hSelectedObject )
+	{
+		Remove_Target( m_hSelectedObject );
+
+		// If we selected our existing one, we just wanted to deselect
+		if ( pObject == m_hSelectedObject )
+		{
+			m_hSelectedObject = NULL;
+			return;
+		}
+	}
+
+	m_hSelectedObject = pObject;
+
+	// Add a new target to our list
+	if ( pObject )
+	{
+		Add_Target( pObject, pObject->GetTargetDescription() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the currently selected object
+//-----------------------------------------------------------------------------
+C_BaseObject *C_BaseTFPlayer::GetSelectedObject( void )
+{
+	return m_hSelectedObject;
+}
+
+//====================================================================================================
+// TARGET RETICLES
+//====================================================================================================
+// Purpose: Add a new entity to the list of targets
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::Add_Target( C_BaseEntity *pTarget, const char *sName )
+{
+	CTargetReticle *pTargetReticle = new CTargetReticle();
+	pTargetReticle->Init( pTarget, sName );
+
+	m_aTargetReticles.AddToTail( pTargetReticle );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove an entity from the list of targets
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::Remove_Target( C_BaseEntity *pTarget )
+{
+	for (int i = 0; i < m_aTargetReticles.Size(); i++ )
+	{
+		CTargetReticle *pTargetReticle = m_aTargetReticles[i];
+		if ( pTargetReticle->GetTarget() == pTarget )
+		{
+			Remove_Target( pTargetReticle );
+			return;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove a specific reticle from our list
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::Remove_Target( CTargetReticle *pTargetReticle )
+{
+	m_aTargetReticles.FindAndRemove( pTargetReticle );
+	delete pTargetReticle;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsUsingThermalVision( void ) const
+{
+	return m_TFLocal.m_bThermalVision;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_BaseTFPlayer::GetIDTarget( void ) const
+{
+	return m_iIDEntIndex;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsKnockedDown( void ) const
+{
+	return m_TFLocal.m_bKnockedDown;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : ang - 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::SetKnockdownAngles( const QAngle& ang )
+{
+	m_bKnockdownOverrideAngles = true;
+	QAngle fixedAngles = ang;
+	NormalizeAngles( fixedAngles );
+	m_vecCurrentKnockdownAngles = fixedAngles;
+	engine->SetViewAngles( fixedAngles );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : outAngles - 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::GetKnockdownAngles( QAngle& outAngles )
+{
+	outAngles = m_vecCurrentKnockdownAngles;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::CheckKnockdownState( void )
+{
+	m_bKnockdownOverrideAngles = false;
+
+	if ( m_flStartKnockdown == 0.0f && 
+		 m_flEndKnockdown == 0.0f &&
+		 !IsKnockedDown() )
+	{
+		m_flKnockdownViewheightAdjust = 0.0f;
+		return;
+	}
+
+	float frac = 0.0f;
+	float dt;
+	if ( IsKnockedDown() )
+	{
+		if ( m_flStartKnockdown != 0.0f )
+		{
+			
+			dt = gpGlobals->curtime - m_flStartKnockdown;
+			if ( dt >= 0.0f && dt < KNOCKDOWN_BLEND_IN )
+			{
+				frac = ( dt / KNOCKDOWN_BLEND_IN );
+				frac = MAX( 0.0f, frac );
+				frac = MIN( 1.0f, frac );
+			}
+			else if ( dt >= KNOCKDOWN_BLEND_IN)
+			{
+				m_flStartKnockdown = 0.0f;
+				frac = 1.0f;
+			}
+		}
+		else
+		{
+			frac = 1.0f;
+		}
+	}
+	else
+	{
+		if ( m_flEndKnockdown != 0.0f )
+		{
+			frac = 0.0f;
+			dt = gpGlobals->curtime - m_flEndKnockdown;
+			if ( dt >= 0 && dt < KNOCKDOWN_BLEND_OUT )
+			{
+				frac = ( dt / KNOCKDOWN_BLEND_OUT );
+				frac = 1.0f - frac;
+			}
+			else if ( dt >= KNOCKDOWN_BLEND_OUT )
+			{
+				m_flEndKnockdown = 0.0f;
+			}
+			else
+			{
+				frac = 1.0f;
+			}
+		}
+	}
+
+	if ( frac == 0.0f )
+	{
+		SetKnockdownAngles( m_vecOriginalViewAngles );
+	}
+	else if ( frac == 1.0f )
+	{
+		SetKnockdownAngles( m_vecKnockDownGoalAngles );
+	}
+	else
+	{
+		QAngle current;
+		InterpolateAngles( m_vecOriginalViewAngles, m_vecKnockDownGoalAngles, current, frac );
+		SetKnockdownAngles( current );
+	}
+
+	Vector eyeZOffset;
+	VectorSubtract( EyePosition(), GetAbsOrigin(), eyeZOffset );
+	float zsize = eyeZOffset.z;
+
+	m_flKnockdownViewheightAdjust = frac * ( zsize - 12 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::CheckKnockdownAngleOverride( void ) const
+{
+	return m_bKnockdownOverrideAngles;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float C_BaseTFPlayer::GetKnockdownViewheightAdjust( void ) const
+{
+	return m_flKnockdownViewheightAdjust;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Player has changed to a new team
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::TeamChange( int iNewTeam )
+{
+	BaseClass::TeamChange( iNewTeam );
+
+	// Did we change team? or did we just join our first team?
+	if ( iNewTeam != GetTeamNumber() )
+	{
+		// Tell the tech tree to reload itself
+		GetTechnologyTreeDoc().ReloadTechTree();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: // Override so infiltrator's disguised as other team will work
+// Output : int
+//-----------------------------------------------------------------------------
+int C_BaseTFPlayer::GetRenderTeamNumber( void )
+{
+	return GetTeamNumber();
+}
+
+
+// 50 % per second
+#define CAMO_DAMPENING_CHANGERATE			300.0f
+#define CAMO_MOVESUPPRESSION_CHANGERATE		100.0f
+#define CAMO_DAMPENINGVELOCITY_CUTOFF		50.0f
+#define CAMO_DAMPENINGVELOCITY_MAX			400.0f
+#define CAMO_DAMPENINGAVEL_CUTOFF			1.0f
+#define CAMO_DAMPENINGAVEL_MAX				5.0f
+#define CAMO_STAYOUT_TIME					1.0f
+#define CAMO_MOVEMENT_PENALTYTIME			1.0f
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsCamouflaged( void )
+{
+	return ( m_flCamouflageAmount > 0.0f ) ? true : false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float C_BaseTFPlayer::GetCamouflageAmount( void )
+{
+	return m_flCamouflageAmount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 0 to 1, where 1 means hardly visible and 0 means pretty noticeable
+// Output : float
+//-----------------------------------------------------------------------------
+
+#define DISTANCE_CAMO_EFFECT_AMOUNT 0.1f
+#define LOCAL_MOTION_CAMO_EFFECT_AMOUNT 0.3f
+#define MOVEMENT_CAMO_EFFECT_AMOUNT 0.2f
+
+float C_BaseTFPlayer::ComputeCamoEffectAmount( void )
+{
+	if ( !IsCamouflaged() )
+		return 1.0f;
+
+	// Start with the amount from the server....
+	float effect_amount = m_flCamouflageAmount / 100.0f;
+
+	// If this player has moved recently, camo will not be as effective for him
+	effect_amount -= MOVEMENT_CAMO_EFFECT_AMOUNT * GetMovementCamoSuppression() / 100.0f;
+	if (effect_amount < 0)
+		effect_amount = 0;
+
+	// Determine distance to render origin
+	Vector delta = GetAbsOrigin() - CurrentViewOrigin();
+	float distance = delta.Length();
+
+	// At the max distance, make it n% less likely to see the camoed dude...
+	// At min distance, we're no less likely to see the dude
+	if ( distance >= CAMO_INNER_RADIUS )
+		effect_amount *= 1 + DISTANCE_CAMO_EFFECT_AMOUNT;
+	else
+	{
+		float frac = distance / CAMO_INNER_RADIUS;
+		effect_amount *= 1 - frac + (1 + DISTANCE_CAMO_EFFECT_AMOUNT) * frac;
+	}
+
+	// Local viewer movements make it n% less likely to see the camoed dude...
+	// No movement means we're no less likely to see the dude
+	// Dampening is based on the local viewer's movements
+	float dampening = 0.0f;
+	C_BaseTFPlayer *local = GetLocalPlayer();
+	if ( local )
+	{
+		dampening = local->GetDampeningAmount() / 100.0f;
+	}
+
+	// Now apply suppression (i.e., less visible) based on camera and viewer movement
+	effect_amount *= 1 + LOCAL_MOTION_CAMO_EFFECT_AMOUNT * dampening;
+
+	// Clamp to valid range
+	effect_amount = MAX( 0.0f, effect_amount );
+	effect_amount = MIN( 0.99f, effect_amount );
+
+	return effect_amount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_BaseTFPlayer::ComputeCamoAlpha( void )
+{
+	Assert( IsCamouflaged() );
+
+	// Determine distance to render origin
+	Vector delta = GetAbsOrigin() - CurrentViewOrigin();
+	float distance = delta.Length();
+
+	int baseline = 0;
+
+	// Too far, just blend out completely
+	if ( distance >= CAMO_OUTER_RADIUS )
+	{
+		baseline = 0;
+	}
+	else if ( distance >= CAMO_INNER_RADIUS )
+	{
+		float frac = ( distance - CAMO_INNER_RADIUS ) / ( CAMO_OUTER_RADIUS - CAMO_INNER_RADIUS );
+		frac = 1 - frac;
+		baseline = (int)( (float)( 255 - CAMO_INNER_ALPHA ) * frac );
+	}
+	else if ( distance >= CAMO_INVIS_RADIUS )
+	{
+		// We'll also render with the special effect
+		float frac = ( distance - CAMO_INVIS_RADIUS ) / ( CAMO_INNER_RADIUS - CAMO_INVIS_RADIUS );
+		baseline = (int)( (float)( CAMO_INNER_ALPHA ) * frac );
+	}
+	else
+	{
+		// NOTE:  return 1 or else the renderer will skip drawing and we won't be
+		//  able to draw the up close effect
+		baseline = 1;
+	}
+	
+	// Suppress everything based on server ramp
+	return baseline + (int)( (float)( 255 - baseline ) * ( m_flCamouflageAmount / 100.0f ) );
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::ComputeFxBlend( void )
+{
+	if ( !IsCamouflaged() )
+	{
+		BaseClass::ComputeFxBlend();
+		return;
+	}
+
+	m_nRenderFXBlend = ComputeCamoAlpha();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsTransparent( void )
+{
+	if ( IsCamouflaged() )
+	{
+		return true;
+	}
+
+	return BaseClass::IsTransparent();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::ViewModel_IsTransparent( void )
+{
+	if ( IsCamouflaged() )
+	{
+		return true;
+	}
+
+	return BaseClass::ViewModel_IsTransparent();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the player's viewmodel should match the player's model data
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsOverridingViewmodel( void )
+{
+	// Don't override medic weapons since we have effects for them
+	if ( PlayerClass() == TFCLASS_MEDIC )
+		return BaseClass::IsOverridingViewmodel();
+
+	if ( IsDamageBoosted() || IsCamouflaged() || HasPowerup(POWERUP_EMP) )
+		return true;
+
+	return BaseClass::IsOverridingViewmodel();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw my viewmodel in some special way
+//-----------------------------------------------------------------------------
+int	C_BaseTFPlayer::DrawOverriddenViewmodel( C_BaseViewModel *pViewmodel, int flags )
+{
+	int ret = 0;
+
+	if ( IsCamouflaged() && ( ComputeCamoEffectAmount() != 1.0f ) )
+	{
+		if ( GetCamoMaterial() )
+		{
+			modelrender->ForcedMaterialOverride( GetCamoMaterial() );
+			ret = pViewmodel->DrawOverriddenViewmodel( flags );
+			modelrender->ForcedMaterialOverride( NULL );
+		}
+	}
+
+	if ( IsDamageBoosted() || HasPowerup(POWERUP_EMP) )
+	{
+
+		// First draw the model once normally.
+		pViewmodel->DrawOverriddenViewmodel( flags );
+
+		// NOTE: for the demo we do a different "BOOST" effect.  What do we want to do here?
+		if ( !inv_demo.GetInt() )
+		{
+			if ( IsDamageBoosted()  && 
+				pViewmodel->ViewModelIndex() != 0 )
+			{
+				return ret;
+			}
+
+			// Now overlay some shimmering ones.
+			render->SetBlend( 0.3 );
+
+			if ( IsDamageBoosted() )
+			{
+				// Radeon 9700 having a problem with this guy:
+				modelrender->ForcedMaterialOverride( m_BoostMaterial );
+			}
+			else
+			{
+				modelrender->ForcedMaterialOverride( m_EMPMaterial );
+			}
+
+			Vector vStart = pViewmodel->GetAbsOrigin();
+
+			float flOffset = damageboost_modeloffset.GetFloat();
+			for ( int i=0; i < 3; i++ )
+			{
+				// Place the model at a slight offset.
+				vStart[i] += flOffset * sin( m_BoostModelAngles[i] );
+				pViewmodel->SetLocalOrigin( vStart );
+				m_BoostModelAngles[i] += RandomFloat( damageboost_modelphasespeed_min.GetFloat(), damageboost_modelphasespeed_max.GetFloat() ) * gpGlobals->frametime;
+
+				// Invalidate the bones because they've been setup with our original position and cached,
+				// and we want to render it in a new spot with different bone transforms.
+				pViewmodel->InvalidateBoneCache();
+				ret = pViewmodel->DrawOverriddenViewmodel( flags );
+			}
+
+			// Reset the position and bone info.
+			pViewmodel->SetLocalOrigin( vStart );
+			pViewmodel->InvalidateBoneCache();
+
+			modelrender->ForcedMaterialOverride( NULL );
+			render->SetBlend( 1 );
+		}
+	}
+
+	return ret;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Players under adrenalin animate faster
+//-----------------------------------------------------------------------------
+float C_BaseTFPlayer::GetDefaultAnimSpeed( void )
+{
+	if ( HasPowerup( POWERUP_RUSH ) )
+		return ADRENALIN_ANIM_SPEED;
+
+	// Weapons may modify animation times
+	if ( GetActiveWeapon() )
+		return GetActiveWeapon()->GetDefaultAnimSpeed();
+
+	return 1.0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This is used to penalize the local viewer for moving around or rotating 
+//  the camera, it causes camo'd guys who are close to fade out their "white" effect
+//  for a bit of time
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::CheckCameraMovement( void )
+{
+	float dt = gpGlobals->frametime;
+
+	float vel = GetAbsVelocity().Length();
+	float avel = fabs( GetLocalAngles().y - GetPrevLocalAngles().y );
+	if ( dt > 0.0f )
+	{
+		avel *= 1.0f / dt;
+	}
+
+	float frac1 = 0.0f;
+	if ( vel > CAMO_DAMPENINGVELOCITY_CUTOFF )
+	{
+		frac1 = ( vel - CAMO_DAMPENINGVELOCITY_CUTOFF ) / ( CAMO_DAMPENINGVELOCITY_MAX - CAMO_DAMPENINGVELOCITY_CUTOFF );
+		frac1 = MIN( 0.0f, frac1 );
+		frac1 = MAX( 1.0f, frac1 );
+
+		frac1 *= 50.0f;
+
+		m_flDampeningStayoutTime = gpGlobals->curtime + CAMO_STAYOUT_TIME;
+
+	}
+
+	float frac2 = 0.0f;
+	if ( avel > CAMO_DAMPENINGAVEL_CUTOFF )
+	{
+		frac2 = ( avel - CAMO_DAMPENINGAVEL_CUTOFF ) / ( CAMO_DAMPENINGAVEL_MAX - CAMO_DAMPENINGAVEL_CUTOFF );
+		frac2 = MIN( 0.0f, frac2 );
+		frac2 = MAX( 1.0f, frac2 );
+
+		frac2 *= 50.0f;
+
+		m_flDampeningStayoutTime = gpGlobals->curtime + CAMO_STAYOUT_TIME;
+
+	}
+
+	// Pick the greater
+	float amount = MAX( frac1, frac2 );
+
+	SetCamoDampening( amount );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Decay suppression camo amount
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::CheckCamoDampening( void )
+{
+	CheckCameraMovement();
+
+	if ( m_flGoalDampeningAmount == m_flDampeningAmount )
+		return;
+
+	// Camouflage
+	float dt = gpGlobals->frametime;
+	float changeamount = ( dt * CAMO_DAMPENING_CHANGERATE );
+
+	// Move but don't overshoot
+	if ( m_flGoalDampeningAmount > m_flDampeningAmount )
+	{
+		m_flDampeningAmount += changeamount;
+		m_flDampeningAmount = MIN( m_flDampeningAmount, m_flGoalDampeningAmount );
+	}
+	else
+	{
+		if ( gpGlobals->curtime < m_flDampeningStayoutTime )
+			return;
+
+		m_flDampeningAmount -= changeamount;
+		m_flDampeningAmount = MAX( m_flDampeningAmount, m_flGoalDampeningAmount );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Force amount, decay happens in CheckCamoDampening
+// Input  : amount - 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::SetCamoDampening( float amount )
+{
+	m_flGoalDampeningAmount = amount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: For camera movement by local player
+// Output : float
+//-----------------------------------------------------------------------------
+float C_BaseTFPlayer::GetDampeningAmount( void )
+{
+	return m_flDampeningAmount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This is used so that if you are watching a camo'd guy who is moving
+//  he becomes more visible for a bit of time, before fading back out.
+// Input  : amount - 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::SetMovementCamoSuppression( float amount )
+{
+	m_flGoalMovementCamoSuppressionAmount = amount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This is used so that if you are watching a camo'd guy who is moving
+//  he becomes more visible for a bit of time, before fading back out.
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::CheckMovementCamoSuppression( void )
+{
+	// FIXME: Don't bother with suppression during deployment...
+	if ( m_bDeployed )
+	{
+		m_flMovementCamoSuppression	= 0;
+		return;
+	}
+
+	float flSuppression = 0;
+
+	// Rotation blends them in a bit too
+	float avel = fabs( GetLocalAngles().y - GetPrevLocalAngles().y ) + fabs( GetLocalAngles().x - GetPrevLocalAngles().x );
+	if ( avel > CAMO_DAMPENINGAVEL_CUTOFF )
+	{
+		float frac2 = ( avel - CAMO_DAMPENINGAVEL_CUTOFF ) / ( CAMO_DAMPENINGAVEL_MAX - CAMO_DAMPENINGAVEL_CUTOFF );
+		frac2 = MIN( 0.0f, frac2 );
+		frac2 = MAX( 1.0f, frac2 );
+		flSuppression = 50.0f * frac2;
+	}
+
+	// Add in velocity blend
+	float vel = GetAbsVelocity().Length();
+	if ( vel > CAMO_DAMPENINGVELOCITY_CUTOFF )
+	{
+		float frac = ( vel- CAMO_DAMPENINGVELOCITY_CUTOFF ) / ( CAMO_DAMPENINGVELOCITY_MAX - CAMO_DAMPENINGVELOCITY_CUTOFF );
+		frac = MIN( 1.0f, frac );
+		flSuppression = MIN( 100.f, flSuppression + (100.0f * frac) );
+	}
+
+	// Set the camo aount
+	SetMovementCamoSuppression( flSuppression );
+	if ( flSuppression )
+	{
+		m_flMovementCamoSuppressionStayoutTime = gpGlobals->curtime + CAMO_MOVEMENT_PENALTYTIME;
+	}
+
+	if ( m_flGoalMovementCamoSuppressionAmount == m_flMovementCamoSuppression )
+		return;
+
+	// Camouflage
+	float dt = gpGlobals->frametime;
+	float changeamount = ( dt * CAMO_MOVESUPPRESSION_CHANGERATE );
+
+	// Move but don't overshoot
+	if ( m_flGoalMovementCamoSuppressionAmount > m_flMovementCamoSuppression )
+	{
+		m_flMovementCamoSuppression += changeamount;
+		m_flMovementCamoSuppression = MIN( m_flMovementCamoSuppression, m_flGoalMovementCamoSuppressionAmount );
+	}
+	else
+	{
+		if ( gpGlobals->curtime < m_flMovementCamoSuppressionStayoutTime )
+			return;
+
+		m_flMovementCamoSuppression -= changeamount;
+		m_flMovementCamoSuppression = MAX( m_flMovementCamoSuppression, m_flGoalMovementCamoSuppressionAmount );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the material used for this player's camo
+//-----------------------------------------------------------------------------
+IMaterial *C_BaseTFPlayer::GetCamoMaterial( void )
+{
+	if ( !m_pCamoEffectMaterial )
+	{
+		m_pCamoEffectMaterial = materials->FindMaterial("player/infiltratorcamo/infiltratorcamo", TEXTURE_GROUP_CLIENT_EFFECTS);
+		if ( m_pCamoEffectMaterial )
+		{
+			m_pCamoEffectMaterial->IncrementReferenceCount();
+		}
+	}
+
+	return m_pCamoEffectMaterial;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Percentage suppression of camo effect up close based on velocity
+// Output : float
+//-----------------------------------------------------------------------------
+float C_BaseTFPlayer::GetMovementCamoSuppression( void )
+{
+	return m_flMovementCamoSuppression;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::CheckLastMovement( void )
+{
+	if ( GetAbsOrigin() != m_vecLastOrigin )
+	{
+		m_vecLastOrigin = GetAbsOrigin();
+		m_flLastMoveTime = gpGlobals->curtime;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float C_BaseTFPlayer::GetLastMoveTime( void )
+{
+	return m_flLastMoveTime;
+}
+
+float C_BaseTFPlayer::GetLastDamageTime( void ) const
+{
+	return m_flLastDamageTime;
+}
+
+float C_BaseTFPlayer::GetLastGainHealthTime( void ) const
+{
+	return m_flLastGainHealthTime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float C_BaseTFPlayer::GetOverlayAlpha( void )
+{
+	float alpha = 1.0f;
+
+	C_BaseTFPlayer *local = GetLocalPlayer();
+	if ( local && local != this )
+	{
+		if ( local && GetTeamNumber() != local->GetTeamNumber() )
+		{
+			if ( IsCamouflaged() )
+			{
+				float frac = ( GetCamouflageAmount() / 100.0f );
+				alpha *= ( 1.0f - frac );
+			}
+
+			// Only applies to sniper right now
+			if ( m_iPlayerClass == TFCLASS_SNIPER )
+			{
+				float dt = gpGlobals->curtime - GetLastMoveTime();
+				if ( dt > SNIPER_STATIONARY_FADESTART )
+				{
+					if ( dt > SNIPER_STATIONARY_FADEFINISH )
+					{
+						alpha = 0.0;
+					}
+					else
+					{
+						float frac = ( dt - SNIPER_STATIONARY_FADESTART ) / ( SNIPER_STATIONARY_FADEFINISH - SNIPER_STATIONARY_FADESTART );
+						alpha *= ( 1.0f - frac );
+					}
+				}
+			}
+		}
+	}
+
+	alpha = MIN( 1.0f, alpha );
+	alpha = MAX( 0.0f, alpha );
+
+	return alpha;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsDeployed( void )
+{
+	return m_bDeployed;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsDeploying( void )
+{
+	return m_bDeploying;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsUnDeploying( void )
+{
+	return m_bUnDeploying;
+}
+			    
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the player's allowed to switch weapons in his current state
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsAllowedToSwitchWeapons( void )
+{
+	// Can't switch while deployed
+	if ( IsDeployed() || IsDeploying() || IsUnDeploying() )
+		return false;
+
+	if ( IsInAVehicle() && GetVehicle() )
+	{
+		IClientVehicle *pVehicle = GetVehicle();
+		int nRole = pVehicle->GetPassengerRole( this );
+		if (!pVehicle->IsPassengerUsingStandardWeapons(nRole))
+		{
+			return false;
+		}
+	}
+
+	// See if the weapon will allow us to switch
+	if ( GetActiveWeapon() && GetActiveWeapon()->IsAllowedToSwitch() == false )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the number of objects of the specified type that this player has
+//-----------------------------------------------------------------------------
+int C_BaseTFPlayer::GetNumObjects( int iObjectType )
+{
+	int iCount = 0;
+	for (int i = 0; i < GetObjectCount(); i++)
+	{
+		if ( !GetObject(i) )
+			continue;
+
+		if ( GetObject(i)->GetType() == iObjectType )
+		{
+			iCount++;
+		}
+	}
+
+	return iCount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	C_BaseTFPlayer::GetObjectCount( void )
+{
+	return m_TFLocal.m_aObjects.Count();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_BaseObject *C_BaseTFPlayer::GetObject( int index )
+{
+	return m_TFLocal.m_aObjects[index].Get();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::AddEntity( void )
+{
+	BaseClass::AddEntity();
+
+	// Zero out model pitch, blending takes care of all of it.
+	SetLocalAnglesDim( X_INDEX, 0 );
+
+	m_PlayerAnimState.Update();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: See if it's time to start another adrenalin effect
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::CheckAdrenalin( void )
+{
+	if ( m_flNextAdrenalinEffect && gpGlobals->curtime > m_flNextAdrenalinEffect )
+	{
+		ScreenFade_t sf;
+		memset( &sf, 0, sizeof( sf ) );
+		sf.a = 128;
+		sf.r = 0;
+		sf.g = 128;
+		sf.b = 0;
+		// One second
+		sf.duration = (unsigned short)((float)(1<<SCREENFADE_FRACBITS) * 1.0f );
+		if ( m_bFadingIn )
+		{
+			sf.fadeFlags = FFADE_IN;
+		}
+		else
+		{
+			sf.fadeFlags = FFADE_OUT;
+		}
+		vieweffects->Fade( sf );
+
+		m_bFadingIn = !m_bFadingIn;
+		m_flNextAdrenalinEffect = gpGlobals->curtime + 1.0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update this client's target entity
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::UpdateIDTarget( void )
+{
+	if ( !IsLocalPlayer() )
+		return;
+
+	// If the server's forcing us to a specific ID target, use it instead
+	if ( m_TFLocal.m_iIDEntIndex )
+	{
+		m_iIDEntIndex = m_TFLocal.m_iIDEntIndex;
+		return;
+	}
+
+	// Clear old target and find a new one
+	m_iIDEntIndex = 0;
+
+	trace_t tr;
+	Vector vecStart, vecEnd;
+	VectorMA( MainViewOrigin(), 1500, MainViewForward(), vecEnd );
+	VectorMA( MainViewOrigin(), 48,   MainViewForward(), vecStart );
+	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
+	if ( tr.DidHitNonWorldEntity() )
+	{
+		C_BaseEntity *pEntity = tr.m_pEnt;
+		IClientVehicle *vehicle = GetVehicle();
+		C_BaseEntity *pVehicleEntity = vehicle ? vehicle->GetVehicleEnt() : NULL;
+
+		if ( pEntity && (pEntity != this) && (pEntity != pVehicleEntity) )
+		{
+			// Make sure it's not an object
+			if ( !dynamic_cast<C_BaseObject*>( pEntity ) )
+			{
+				m_iIDEntIndex = pEntity->entindex();
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the weapon to have open the weapon selection on, based upon our currently active weapon
+//			If the currently active weapon is a two handed weapon, returns it's primary weapon.
+//-----------------------------------------------------------------------------
+C_BaseCombatWeapon *C_BaseTFPlayer::GetActiveWeaponForSelection( void )
+{
+	C_WeaponTwoHandedContainer *pTwoHandedWeapon = dynamic_cast<C_WeaponTwoHandedContainer*>( GetActiveWeapon() );
+	if ( pTwoHandedWeapon )
+		return pTwoHandedWeapon->m_hLeftWeapon;
+
+	return BaseClass::GetActiveWeaponForSelection();
+}
+
+//-----------------------------------------------------------------------------
+// HACK: Until we get a recon model, trail recon particles
+//-----------------------------------------------------------------------------
+void FX_ReconParticle( const Vector &vecOrigin, bool bBlue )
+{
+	CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "reconparticle" );
+	pSimple->SetSortOrigin( vecOrigin );
+	pSimple->SetNearClip( 32, 64 );
+
+	SimpleParticle	*pParticle;
+
+	Vector	offset;
+
+	for ( int i = 0; i < 1; i++ )
+	{
+		pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[0], vecOrigin );
+
+		if ( pParticle != NULL )
+		{			
+			pParticle->m_flLifetime		= 0.0f;
+			pParticle->m_flDieTime		= random->RandomFloat( 1.0f, 1.5f );
+			
+			pParticle->m_vecVelocity	= vec3_origin;
+
+			int	color = random->RandomInt( 128, 192 );
+
+			if ( bBlue )
+			{
+				pParticle->m_uchColor[0]	= color;
+				pParticle->m_uchColor[1]	= color;
+				pParticle->m_uchColor[2]	= 255;
+			}
+			else
+			{
+				pParticle->m_uchColor[0]	= 255;
+				pParticle->m_uchColor[1]	= color;
+				pParticle->m_uchColor[2]	= color;
+			}
+			pParticle->m_uchStartAlpha	= random->RandomInt( 192, 255 );
+			pParticle->m_uchEndAlpha	= 0;
+			pParticle->m_uchStartSize	= random->RandomInt( 12, 16 );
+			pParticle->m_uchEndSize		= 0;
+			pParticle->m_flRoll			= random->RandomInt( 0, 360 );
+			pParticle->m_flRollDelta	= random->RandomFloat( -1.0f, 1.0f );
+		}
+	}
+}
+
+// Prediction stuff
+void C_BaseTFPlayer::PreThink( void )
+{
+	BaseClass::PreThink();
+
+	// Chain pre-think to player class.
+	if ( GetPlayerClass() )
+	{
+		GetPlayerClass()->PreClassThink();
+	}
+}
+
+void C_BaseTFPlayer::PostThink( void )
+{
+	BaseClass::PostThink();
+
+	// Chain post-think to player class.
+	if ( GetPlayerClass() )
+	{
+		GetPlayerClass()->PostClassThink();
+	}
+}
+
+C_PlayerClass *C_BaseTFPlayer::GetPlayerClass( void )
+{
+	return m_PlayerClasses.GetPlayerClass( PlayerClass() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::SetVehicleRole( int nRole )
+{
+	if ( IsInAVehicle() )
+	{
+		C_BaseTFVehicle *pVehicle = ( C_BaseTFVehicle* )GetVehicle();
+		if ( pVehicle )
+		{
+			if ( nRole >= pVehicle->GetMaxPassengerCount() )
+				return;
+		}
+	}
+
+	char szCmd[64];
+	Q_snprintf( szCmd, sizeof( szCmd ), "vehicleRole %i\n", nRole );
+	engine->ServerCmd( szCmd );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::CanGetInVehicle( void )
+{
+	if ( GetPlayerClass() )
+	{
+		return GetPlayerClass()->CanGetInVehicle();
+	}
+
+	return true;
+}
+
+
+// How fast to avoid collisions with center of other object, in units per second
+#define AVOID_SPEED 1000.0f
+extern ConVar cl_forwardspeed;
+extern ConVar cl_backspeed;
+extern ConVar cl_sidespeed;
+
+static ConVar tf2_solidplayers( "tf2_solidplayers", "1", 0, "Treat players and objects as solid." );
+
+//-----------------------------------------------------------------------------
+// Client-side obstacle avoidance
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::PerformClientSideObstacleAvoidance( float flFrameTime, CUserCmd *pCmd )
+{
+	if ( !tf2_solidplayers.GetBool() )
+	{
+		return;
+	}
+
+	// Don't avoid if noclipping or in movetype none
+	switch ( GetMoveType() )
+	{
+	case MOVETYPE_NOCLIP:
+	case MOVETYPE_NONE:
+		return;
+	default:
+		break;
+	}
+
+	// Try to steer away from any objects/players we might interpenetrate
+	Vector size = WorldAlignSize();
+
+	float radius = 0.5f * sqrt( size.x * size.x + size.y * size.y );
+	float curspeed = GetAbsVelocity().Length2D();
+
+	// int slot = 1;
+
+	//engine->Con_NPrintf( slot++, "speed %f\n", curspeed );
+	//engine->Con_NPrintf( slot++, "radius %f\n", radius );
+
+	// If running, use a larger radius
+	if ( curspeed > 100.0f )
+	{
+		float factor = ( 1.0f + ( curspeed - 100.0f ) / 100.0f );
+
+		// engine->Con_NPrintf( slot++, "scaleup (%f) to radius %f\n", factor, radius * factor );
+
+		radius = radius * factor;
+	}
+
+	CPlayerAndObjectEnumerator avoid( radius );
+	partition->EnumerateElementsInSphere( PARTITION_CLIENT_SOLID_EDICTS, GetAbsOrigin(), radius, false, &avoid );
+
+	// Okay, decide how to avoid if there's anything close by
+	int c = avoid.GetObjectCount();
+	if ( c <= 0 )
+		return;
+
+	Vector currentdir;
+	Vector rightdir;
+	AngleVectors( pCmd->viewangles, &currentdir, &rightdir, NULL );
+	
+	bool istryingtomove = false;
+	bool ismovingforward = false;
+	if ( fabs( pCmd->forwardmove ) > 0.0f || 
+		 fabs( pCmd->sidemove ) > 0.0f )
+	{
+		istryingtomove = true;
+		if ( pCmd->forwardmove > 1.0f )
+		{
+			ismovingforward = true;
+		}
+	}
+
+	//engine->Con_NPrintf( slot++, "moving %s forward %s\n", istryingtomove ? "true" : "false", ismovingforward ? "true" : "false"  );
+
+	float adjustforwardmove = 0.0f;
+	float adjustsidemove	= 0.0f;
+
+	int i;
+	for ( i = 0; i < c; i++ )
+	{
+		C_BaseEntity *obj = avoid.GetObject( i );
+		if( !obj )
+			continue;
+
+		float flHit1, flHit2;
+
+		// Figure out a 2D radius for the object
+		Vector vecWorldMins, vecWorldMaxs;
+		obj->CollisionProp()->WorldSpaceAABB( &vecWorldMins, &vecWorldMaxs );
+		Vector objSize = vecWorldMaxs - vecWorldMins;
+
+		float objectradius = /*0.5f **/ 1.0 * sqrt( objSize.x * objSize.x + objSize.y * objSize.y );
+
+		if ( !IntersectInfiniteRayWithSphere(
+				GetAbsOrigin(),
+				currentdir,
+				obj->GetAbsOrigin(),
+				objectradius,
+				&flHit1,
+				&flHit2 ) )
+			continue;
+
+		float force = 0.0f;
+
+		float forward = 0.0f, side = 0.0f;
+
+		Vector vecToObject = obj->GetAbsOrigin() - GetAbsOrigin();
+		Vector cross = vecToObject.Cross( currentdir );
+
+		//engine->Con_NPrintf( slot++, "object side %s\n", sign > 0.0f ? "right" : "left" );
+
+		if ( 0 && istryingtomove )
+		{
+/*
+			// Okay, line hits sphere in two points
+			// Determine how close line is to center of sphere and move sideways to avoid if we are 
+			//  actually trying to move forward
+			Vector deltaHit = vHit2 - vHit1;
+			float leg1 = ( deltaHit.Length() ) / 2.0f;
+
+			float distfromcenter = sqrt( leg1 * leg1 + objectradius * objectradius );
+
+			force = distfromcenter / radius;
+			force = clamp( force, 0.0f, 1.0f );
+			force = 1.0f - force;
+
+			if ( force <= 0.5f )
+				continue;
+
+			side = force * AVOID_SPEED;
+
+			// Move to right or left of object
+			side *= sign;
+*/
+		}
+		else
+		{
+			Vector deltaObject = vecToObject;
+			float dist = deltaObject.Length2D();
+
+			force = dist / radius;
+			force = clamp( force, 0.0f, 1.0f );
+			force = 1.0f - force;
+
+			//engine->Con_NPrintf( slot++, "dist %f/radius %f == %f\n", dist, radius, force );
+
+			if ( force <= 0.3f )
+				continue;
+
+			force = sqrt( force );
+
+			//engine->Con_NPrintf( slot++, "sqrt(force) == %f\n", force );
+
+			Vector moveDir = -vecToObject;
+			VectorNormalize( moveDir );
+
+			float fwd = currentdir.Dot( moveDir );
+			float rt = rightdir.Dot( moveDir );
+
+			//engine->Con_NPrintf( slot++, "fwd %f right %f\n", fwd, rt );
+
+			float sidescale = 2.0f;
+			float forwardscale = 1.0f;
+
+			if ( istryingtomove )
+			{
+				// If running, then do a lot more sideways veer since we're not going to do anything to
+				//  forward velocity
+				sidescale = 4.0f;
+				forwardscale = 2.0f;
+			}
+
+			forward = forwardscale * fwd * force * AVOID_SPEED;
+			side = sidescale * rt * force * AVOID_SPEED;
+
+			//engine->Con_NPrintf( slot++, "forward %f side %f\n", forward, side );
+		}
+
+		adjustforwardmove	+= forward;
+		adjustsidemove		+= side;
+	}
+
+	pCmd->forwardmove	+= adjustforwardmove;
+	pCmd->sidemove		+= adjustsidemove;
+
+	if ( pCmd->forwardmove > 0.0f )
+	{
+		pCmd->forwardmove = clamp( pCmd->forwardmove, -cl_forwardspeed.GetFloat(), cl_forwardspeed.GetFloat() );
+	}
+	else
+	{
+		pCmd->forwardmove = clamp( pCmd->forwardmove, -cl_backspeed.GetFloat(), cl_backspeed.GetFloat() );
+	}
+	pCmd->sidemove = clamp( pCmd->sidemove, -cl_sidespeed.GetFloat(), cl_sidespeed.GetFloat() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Input handling
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::CreateMove( float flInputSampleTime, CUserCmd *pCmd )
+{
+	BaseClass::CreateMove( flInputSampleTime, pCmd );
+
+	// If the frozen flag is set, prevent view movement (server prevents the rest of the movement)
+	if ( GetFlags() & FL_FROZEN )
+	{
+		return;
+	}
+
+	if (!IsInVGuiInputMode() && !IsInAVehicle())
+	{
+		PerformClientSideObstacleAvoidance( TICK_INTERVAL, pCmd );
+	}
+}
+
+
+C_BaseAnimating* C_BaseTFPlayer::GetRenderedWeaponModel()
+{
+	// Attach to either their weapon model or their view model.
+	if ( C_BasePlayer::ShouldDrawLocalPlayer() || !IsLocalPlayer() )
+	{
+		// Hook it to their external weapon model.
+		C_BaseCombatWeapon *pWeapon = GetActiveWeapon();
+		if ( !pWeapon )
+			return NULL;
+
+		// If this a two-handed container (shield + weapon), return the left weapon.
+		C_WeaponTwoHandedContainer *pContainer = dynamic_cast< C_WeaponTwoHandedContainer* >( pWeapon );
+		if ( pContainer )
+		{
+			return pContainer->GetLeftWeapon();
+		}
+		else
+		{
+			return pWeapon;
+		}
+	}
+	else
+	{
+		return GetViewModel();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::SetIDEnt( C_BaseEntity *pEntity )
+{
+	if ( pEntity )
+		m_TFLocal.m_iIDEntIndex = pEntity->entindex();
+	else
+		m_TFLocal.m_iIDEntIndex = 0;
+}
+
+
+C_VehicleTeleportStation* C_BaseTFPlayer::GetSelectedMCV() const
+{
+	return dynamic_cast< C_VehicleTeleportStation* >( m_hSelectedMCV.Get() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this object can be +used by the player
+//-----------------------------------------------------------------------------
+bool C_BaseTFPlayer::IsUseableEntity( CBaseEntity *pEntity )
+{
+	// I can use vehicles
+	return dynamic_cast<C_BaseTFVehicle*>( pEntity );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Powerup has just started
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::PowerupStart( int iPowerup, bool bInitial )
+{
+	Assert( iPowerup >= 0 && iPowerup < MAX_POWERUPS );
+
+	switch( iPowerup )
+	{
+	case POWERUP_RUSH:
+		{
+			// Play the rage start
+			if ( bInitial )
+			{
+				EmitSound( "BaseTFPlayer.Rage" );
+			}
+
+			// Start the looping breathing
+			CPASAttenuationFilter filter( this, "BaseTFPlayer.HeavyBreathing" );
+			EmitSound( filter, entindex(), "BaseTFPlayer.HeavyBreathing" );
+
+			if ( IsLocalPlayer() )
+			{
+				// Start the visual effects
+				if ( !m_flNextAdrenalinEffect )
+				{
+					m_flNextAdrenalinEffect = gpGlobals->curtime;
+					m_bFadingIn = false;
+				}
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	BaseClass::PowerupStart( iPowerup, bInitial );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Powerup has just finished
+//-----------------------------------------------------------------------------
+void C_BaseTFPlayer::PowerupEnd( int iPowerup )
+{
+	Assert( iPowerup >= 0 && iPowerup < MAX_POWERUPS );
+
+	switch( iPowerup )
+	{
+	case POWERUP_RUSH:
+		{
+			// Stop the looping breathing
+			StopSound( "BaseTFPlayer.HeavyBreathing" );
+
+			if ( IsLocalPlayer() )
+			{
+				// Stop the visual effects
+				if ( m_flNextAdrenalinEffect )
+				{
+					vieweffects->ClearAllFades();
+				}
+
+				m_flNextAdrenalinEffect = 0;
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	BaseClass::PowerupEnd( iPowerup );
+}
diff --git a/game/client/tf2/c_basetfplayer.h b/game/client/tf2/c_basetfplayer.h
new file mode 100644
index 0000000..b2fc64c
--- /dev/null
+++ b/game/client/tf2/c_basetfplayer.h
@@ -0,0 +1,386 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#if !defined( C_BASETFPLAYER_H )
+#define C_BASETFPLAYER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_vehicleshared.h"
+#include "c_baseplayer.h"
+#include "CommanderOverlay.h"
+#include "hud_minimap.h"
+#include "hud_targetreticle.h"
+#include "c_tfplayerlocaldata.h"
+#include "particlemgr.h"
+#include "particle_prototype.h"
+#include "particle_util.h"
+#include "tf_playeranimstate.h"
+
+class C_VehicleTeleportStation;
+class CViewSetup;
+class IMaterial;
+class C_Order;
+class C_BaseObject;
+class C_PlayerClass;
+class CPersonalShieldEffect;
+class CBasePredictedWeapon;
+class C_BaseViewModel;
+class CUserCmd;
+class C_WeaponCombatShield;
+
+//-----------------------------------------------------------------------------
+// Purpose: Client Side TF Player entity
+//-----------------------------------------------------------------------------
+class C_BaseTFPlayer : public C_BasePlayer
+{
+public:
+	DECLARE_CLASS( C_BaseTFPlayer, C_BasePlayer );
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+	DECLARE_MINIMAP_PANEL();
+	DECLARE_PREDICTABLE();
+
+					C_BaseTFPlayer();
+	virtual			~C_BaseTFPlayer();
+
+private:
+	void			Clear();	// Clear all elements.
+
+public:
+	bool			IsHidden() const;
+	bool			IsDamageBoosted() const;
+
+	bool			HasNamedTechnology( const char *name );
+
+	float			LastAttackTime() const { return m_flLastAttackTime; }
+	void			SetLastAttackTime( float flTime ) { m_flLastAttackTime = flTime; }
+
+	// Return this client's C_BaseTFPlayer pointer
+	static C_BaseTFPlayer* GetLocalPlayer( void )
+	{
+		return ( static_cast< C_BaseTFPlayer * >( C_BasePlayer::GetLocalPlayer() ) );
+	}
+
+	virtual void		ClientThink( void );
+	virtual void		OnPreDataChanged( DataUpdateType_t updateType );
+	virtual void		OnDataChanged( DataUpdateType_t updateType );
+	virtual void		PreDataUpdate( DataUpdateType_t updateType );
+	virtual void		PostDataUpdate( DataUpdateType_t updateType );
+	virtual void		ReceiveMessage( int classID, bf_read &msg );
+	virtual void		Release( void );
+
+	virtual void		ItemPostFrame( void );
+
+	virtual bool		ShouldDraw();
+	virtual int			DrawModel( int flags );
+
+	virtual void		SetDormant( bool bDormant );
+
+	virtual void		GetBoneControllers(float controllers[MAXSTUDIOBONES]);
+
+	virtual int			GetRenderTeamNumber( void );
+	virtual void		ComputeFxBlend( void );
+	virtual bool		IsTransparent( void );
+
+	// Called by the view model if its rendering is being overridden.
+	virtual bool		ViewModel_IsTransparent( void );
+
+	virtual bool		IsOverridingViewmodel( void );
+	virtual int			DrawOverriddenViewmodel( C_BaseViewModel *pViewmodel, int flags );
+	virtual void		CreateMove( float flInputSampleTime, CUserCmd *pCmd );
+	virtual float		GetDefaultAnimSpeed( void );
+
+	int					GetClass( void );
+
+	// Called when not in tactical mode. Allows view to be overriden for things like driving a tank.
+	void				OverrideView( CViewSetup *pSetup );
+
+	// Called when not in tactical mode. Allows view model drawing to be disabled for things like driving a tank.
+	bool				ShouldDrawViewModel();
+
+	void				GetTargetDescription( char *pDest, int bufferSize );
+
+	// Orders
+	void				SetPersonalOrder( C_Order *pOrder );
+	void				RemoveOrderTarget();
+
+	// Resources
+	int					GetBankResources( void );
+
+	// Objects
+	void				SetSelectedObject( C_BaseObject *pObject );
+	C_BaseObject		*GetSelectedObject( void );
+	int					GetNumObjects( int iObjectType );
+	int					GetObjectCount( void );
+	C_BaseObject		*GetObject( int index );
+
+	// Targets
+	void				Add_Target( C_BaseEntity *pTarget, const char *sName );
+	void				Remove_Target( C_BaseEntity *pTarget );
+	void				Remove_Target( CTargetReticle *pTargetReticle );
+
+	void				UpdateTargetReticles( void );
+
+	bool				IsUsingThermalVision( void ) const;
+
+	// Weapon handling
+	virtual bool				IsAllowedToSwitchWeapons( void );
+	virtual bool				Weapon_ShouldSetLast( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon );
+	virtual bool				Weapon_ShouldSelectItem( CBaseCombatWeapon *pWeapon );
+	virtual	C_BaseCombatWeapon	*GetActiveWeaponForSelection( void );
+	virtual C_BaseCombatWeapon  *GetLastWeaponBeforeObject( void ) { return m_hLastWeaponBeforeObject; }
+
+	virtual C_BaseAnimating* GetRenderedWeaponModel();
+
+	// ID Target
+	void				SetIDEnt( C_BaseEntity *pEntity );
+	int					GetIDTarget( void ) const;
+	void				UpdateIDTarget( void );
+
+	bool				IsKnockedDown( void ) const;
+	void				CheckKnockdownState( void );
+	bool				CheckKnockdownAngleOverride( void ) const;
+	void				SetKnockdownAngles( const QAngle& ang );
+	void				GetKnockdownAngles( QAngle& outAngles );
+	float				GetKnockdownViewheightAdjust( void ) const;
+
+	// Team handling
+	virtual void		TeamChange( int iNewTeam );
+
+	// Camouflage effect
+	virtual bool		IsCamouflaged( void );
+	virtual float		GetCamouflageAmount( void );
+	virtual float		ComputeCamoEffectAmount( void );	// 0 - visible, 1 = invisible
+	virtual int			ComputeCamoAlpha( void );
+	virtual void		CheckCamoDampening( void );
+	virtual void		SetCamoDampening( float amount );
+	virtual float		GetDampeningAmount( void );
+	virtual void		CheckCameraMovement( void );
+
+	IMaterial			*GetCamoMaterial( void );
+	virtual float		GetMovementCamoSuppression( void );
+	virtual void		CheckMovementCamoSuppression( void );
+	virtual void		SetMovementCamoSuppression( float amount );
+
+	// Adrenalin
+	void				CheckAdrenalin( void );
+
+	void				CheckLastMovement( void );
+	float				GetLastMoveTime( void );
+	float				GetOverlayAlpha( void );
+
+	float				GetLastDamageTime( void ) const;
+	float				GetLastGainHealthTime( void ) const;
+	
+	// Powerups
+	virtual void		PowerupStart( int iPowerup, bool bInitial );
+	virtual void		PowerupEnd( int iPowerup );
+
+	// Sniper
+	bool				IsDeployed( void );
+	bool				IsDeploying( void );
+	bool				IsUnDeploying( void );
+
+	virtual void		AddEntity( void );
+
+	// Vertification
+	inline bool HasClass( void ) { return GetPlayerClass() != NULL; }
+
+	bool	IsClass( TFClass iClass );
+
+
+	virtual int	GetMaxHealth() const { return m_iMaxHealth; }
+
+	bool ClassProxyUpdate( int nClassID );
+
+	// Should this object cast shadows?
+	virtual ShadowType_t		ShadowCastType();
+
+	// Prediction stuff
+	virtual void				PreThink( void );
+	virtual void				PostThink( void );
+
+	// Combat prototyping
+	bool		IsBlocking( void ) const { return m_bIsBlocking; }
+	bool		IsParrying( void ) const { return m_bIsParrying; }
+	void		SetBlocking( bool bBlocking ) { m_bIsBlocking = bBlocking; }
+	void		SetParrying( bool bParrying ) { m_bIsParrying = bParrying; }
+
+	// Vehicles
+	void				SetVehicleRole( int nRole );
+	bool				CanGetInVehicle( void );
+	
+	// Returns true if we're in a vehicle and it's mounted on another vehicle
+	// (ie: are we in a manned gun that's mounted on a tank).
+	bool IsVehicleMounted() const;
+
+	virtual bool		IsUseableEntity( CBaseEntity *pEntity );
+
+// Shared Client / Server code
+public:
+	bool					IsHittingShield( const Vector &vecVelocity, float *flDamage );
+	C_WeaponCombatShield	*GetCombatShield( void );
+	virtual void			PainSound( void );
+
+public:
+	// Data for only the local player
+	CTFPlayerLocalData		m_TFLocal;
+
+	// Accessors...
+	const QAngle& DeployedAngles() const	{ return m_vecDeployedAngles; }
+	int ZoneState() const					{ return m_iCurrentZoneState; }
+	float CamouflageAmount() const			{ return m_flCamouflageAmount; }
+	int	PlayerClass() const					{ return m_iPlayerClass; }
+	C_PlayerClass *GetPlayerClass();
+	C_Order *PersonalOrder()				{ return m_hPersonalOrder; }
+	C_BaseEntity *SpawnPoint()				{ return m_hSpawnPoint.Get(); }
+
+	C_VehicleTeleportStation* GetSelectedMCV() const;
+
+	// Object sapper placement handling
+	//float							m_flSapperAttachmentFinishTime;
+	//float							m_flSapperAttachmentStartTime;
+	//CHandle< CGrenadeObjectSapper >	m_hSapper;
+	//CHandle< CBaseObject >			m_hSappedObject;
+	CHealthBarPanel					*m_pSapperAttachmentStatus;
+
+private:
+	C_BaseTFPlayer( const C_BaseTFPlayer & );
+
+	// Client-side obstacle avoidance
+	void PerformClientSideObstacleAvoidance( float flFrameTime, CUserCmd *pCmd );
+
+	float		m_flLastAttackTime;
+
+	EHANDLE m_hSelectedMCV;
+
+	// Weapon used before switching to an object placement
+	CHandle<C_BaseCombatWeapon>	m_hLastWeaponBeforeObject;
+
+	float		m_flCamouflageAmount;
+
+	// Movement.
+	Vector		m_vecPosDelta;
+
+	enum { MOMENTUM_MAXSIZE = 10 };
+	float		m_aMomentum[MOMENTUM_MAXSIZE];
+	int			m_iMomentumHead;
+
+	// Player Class
+	int							m_iPlayerClass;
+	C_AllPlayerClasses			m_PlayerClasses;
+
+	// Spawn location...
+	EHANDLE				m_hSpawnPoint;
+	
+	// Orders
+	CHandle< C_Order >	m_hSelectedOrder;
+	CHandle< C_Order >	m_hPersonalOrder;
+	int					m_iSelectedTarget;
+	int					m_iPersonalTarget;
+	CUtlVector< CTargetReticle * > m_aTargetReticles;	// A list of entities to show target reticles for
+
+	// Objects
+	CHandle< C_BaseObject > m_hSelectedObject;
+
+	int					m_iLastHealth;
+
+	bool				m_bIsBlocking;
+	bool				m_bIsParrying;
+
+	bool				m_bUnderAttack;
+	int					m_iMaxHealth;
+	bool				m_bDeployed;
+	bool				m_bDeploying;
+	bool				m_bUnDeploying;
+	QAngle				m_vecDeployedAngles;
+	int					m_iCurrentZoneState;
+	int					m_TFPlayerFlags;
+
+	int					m_nOldTacticalView;
+	int					m_nOldPlayerClass;
+
+	float				m_flNextUseCheck;
+
+	bool				m_bOldThermalVision;
+	bool				m_bOldAttachingSapper;
+
+	bool				m_bOldKnockDownState;
+	float				m_flStartKnockdown;
+	float				m_flEndKnockdown;
+	QAngle				m_vecOriginalViewAngles;
+	QAngle				m_vecCurrentKnockdownAngles;
+	QAngle				m_vecKnockDownGoalAngles;
+	bool				m_bKnockdownOverrideAngles;
+	float				m_flKnockdownViewheightAdjust;
+
+	CPlayerAnimState	m_PlayerAnimState;
+
+	// For sniper hiding
+	float				m_flLastMoveTime;
+	Vector				m_vecLastOrigin;
+
+	// For material proxies
+	float				m_flLastDamageTime;
+	float				m_flLastGainHealthTime;
+
+	IMaterial			*m_pThermalMaterial;
+	IMaterial			*m_pCamoEffectMaterial;
+
+	// Camouflage
+	float				m_flDampeningAmount;
+	float				m_flGoalDampeningAmount;
+	float				m_flDampeningStayoutTime;
+
+	// Suppression of camo based on movement
+	float				m_flMovementCamoSuppression;
+	float				m_flGoalMovementCamoSuppressionAmount;
+	float				m_flMovementCamoSuppressionStayoutTime;
+
+	// Adrenalin
+	float				m_flNextAdrenalinEffect;
+	bool				m_bFadingIn;
+
+	// ID Target
+	int					m_iIDEntIndex;
+
+	CMaterialReference	m_BoostMaterial;
+	CMaterialReference	m_EMPMaterial;
+	float				m_BoostModelAngles[3];
+
+	// Personal shield effects.
+	CUtlLinkedList<CPersonalShieldEffect*, int>	m_PersonalShieldEffects;
+		
+	CHandle< C_WeaponCombatShield > m_hWeaponCombatShield;
+
+	// No one should call this
+	C_BaseTFPlayer& operator=( const C_BaseTFPlayer& src );
+
+	friend void RecvProxy_PlayerClass( const CRecvProxyData *pData, void *pStruct, void *pOut );
+
+
+	friend class CTFPrediction;
+};
+
+int GetLocalPlayerClass( void );
+bool IsLocalPlayerClass( int iClass );
+bool IsLocalPlayerInTactical( );
+inline C_BaseTFPlayer *ToBaseTFPlayer( C_BaseEntity *pEntity )
+{
+	if ( !pEntity || !pEntity->IsPlayer() )
+		return NULL;
+
+#if _DEBUG
+	return dynamic_cast<C_BaseTFPlayer *>( pEntity );
+#else
+	return static_cast<C_BaseTFPlayer *>( pEntity );
+#endif
+}
+
+#endif // C_BASETFPLAYER_H
diff --git a/game/client/tf2/c_controlzone.cpp b/game/client/tf2/c_controlzone.cpp
new file mode 100644
index 0000000..be220b4
--- /dev/null
+++ b/game/client/tf2/c_controlzone.cpp
@@ -0,0 +1,67 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_controlzone.h"
+#include "mapdata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ControlZone::C_ControlZone()
+{
+	m_nZoneNumber = 0;
+
+	m_pShowTriggers = cvar->FindVar("showtriggers");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ControlZone::~C_ControlZone()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Are we using showtriggers?
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_ControlZone::ShouldDraw()
+{
+	if ( !m_pShowTriggers )
+		return false;
+
+	return m_pShowTriggers->GetInt() != 0 ? true : false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update global map state based on data received
+// Input  : bnewentity - 
+//-----------------------------------------------------------------------------
+void C_ControlZone::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	CMapZones *zone;
+	if ( m_nZoneNumber < 1 ||
+		 m_nZoneNumber > MAX_ZONES )
+		 return;
+
+	zone = &MapData().m_Zones[ m_nZoneNumber -1 ];
+	zone->m_nControllingTeam = GetTeamNumber();
+}
+
+IMPLEMENT_CLIENTCLASS_DT(C_ControlZone, DT_ControlZone, CControlZone)
+	RecvPropInt( RECVINFO(m_nZoneNumber )),
+END_RECV_TABLE()
+
+
diff --git a/game/client/tf2/c_controlzone.h b/game/client/tf2/c_controlzone.h
new file mode 100644
index 0000000..8d0af26
--- /dev/null
+++ b/game/client/tf2/c_controlzone.h
@@ -0,0 +1,39 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#if !defined( C_CONTROLZONE_H )
+#define C_CONTROLZONE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class ConVar;
+//-----------------------------------------------------------------------------
+// Purpose: Client side rep of control zone entity ( trigger, so not usually visible )
+//-----------------------------------------------------------------------------
+class C_ControlZone : public C_BaseEntity
+{
+public:
+	DECLARE_CLASS( C_ControlZone, C_BaseEntity );
+	DECLARE_CLIENTCLASS();
+
+					C_ControlZone();
+	virtual			~C_ControlZone();
+
+	virtual	bool	ShouldDraw();
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+
+public:
+	int				m_nZoneNumber;
+
+private:
+	const ConVar	*m_pShowTriggers;
+};
+
+#endif // C_CONTROLZONE_H
\ No newline at end of file
diff --git a/game/client/tf2/c_demo_entities.cpp b/game/client/tf2/c_demo_entities.cpp
new file mode 100644
index 0000000..e186ebb
--- /dev/null
+++ b/game/client/tf2/c_demo_entities.cpp
@@ -0,0 +1,35 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_demo_entities.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_Cycler_TF2Commando, DT_Cycler_TF2Commando, CCycler_TF2Commando)
+	RecvPropInt( RECVINFO(m_bShieldActive) ),
+	RecvPropFloat( RECVINFO(m_flShieldRaiseTime) ),
+	RecvPropFloat( RECVINFO(m_flShieldLowerTime) ),
+END_RECV_TABLE()
+
+C_Cycler_TF2Commando::C_Cycler_TF2Commando()
+{
+}
+
+float C_Cycler_TF2Commando::GetShieldRaiseTime() const
+{
+	return m_bShieldActive ? gpGlobals->curtime - m_flShieldRaiseTime : 0.0f;
+}
+
+float C_Cycler_TF2Commando::GetShieldLowerTime() const
+{
+	return !m_bShieldActive ? gpGlobals->curtime - m_flShieldLowerTime : 0.0f;
+}
+
+bool C_Cycler_TF2Commando::IsShieldActive() const
+{
+	return m_bShieldActive;
+}
+
diff --git a/game/client/tf2/c_demo_entities.h b/game/client/tf2/c_demo_entities.h
new file mode 100644
index 0000000..3966aad
--- /dev/null
+++ b/game/client/tf2/c_demo_entities.h
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_DEMO_ENTITIES_H
+#define C_DEMO_ENTITIES_H
+
+#include "c_ai_basenpc.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_Cycler_TF2Commando : public C_AI_BaseNPC
+{
+	DECLARE_CLASS( C_Cycler_TF2Commando, C_AI_BaseNPC );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_Cycler_TF2Commando();
+
+	float	GetShieldRaiseTime() const;
+	float	GetShieldLowerTime() const;
+	bool	IsShieldActive() const;
+
+private:
+	C_Cycler_TF2Commando( const C_Cycler_TF2Commando& );
+
+	bool	m_bShieldActive;
+	float	m_flShieldRaiseTime;
+	float	m_flShieldLowerTime;
+};
+
+#endif // C_DEMO_ENTITIES_H
diff --git a/game/client/tf2/c_effect_shootingstar.cpp b/game/client/tf2/c_effect_shootingstar.cpp
new file mode 100644
index 0000000..98a4ecc
--- /dev/null
+++ b/game/client/tf2/c_effect_shootingstar.cpp
@@ -0,0 +1,179 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's Meteor
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_effect_shootingstar.h"
+#include "clienteffectprecachesystem.h"
+
+//=============================================================================
+//
+// Shooting Star Spawner Functionality
+//
+
+IMPLEMENT_CLIENTCLASS_DT( C_ShootingStarSpawner, DT_ShootingStarSpawner, CShootingStarSpawner )
+	RecvPropFloat( RECVINFO( m_flSpawnInterval ) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ShootingStarSpawner::C_ShootingStarSpawner( void )
+{
+	SetNextClientThink( gpGlobals->curtime + m_flSpawnInterval );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ShootingStarSpawner::ClientThink( void )
+{
+	// Spawn a number of shooting stars.
+	SpawnShootingStars();
+
+	// Randomly generate a next think time.
+	SetNextClientThink( gpGlobals->curtime + random->RandomFloat( 0.25, m_flSpawnInterval ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ShootingStarSpawner::SpawnShootingStars( void )
+{
+	C_ShootingStar *pShootingStar = new C_ShootingStar;
+	if ( pShootingStar )
+	{
+		// In Space.
+		pShootingStar->SetFriction( 1.0f );
+		pShootingStar->SetGravity( 0.0f );
+
+		// Randomize the velocity. -- This isn't right, but works for the test!
+		Vector vecVelocity;
+		vecVelocity.x = ( GetAbsAngles().x ) * random->RandomFloat( 1.0f, 10.0f );
+		vecVelocity.y = ( GetAbsAngles().y ) * random->RandomFloat( 1.0f, 10.0f );
+		vecVelocity.z = ( GetAbsAngles().z ) * random->RandomFloat( 1.0f, 10.0f );
+
+		pShootingStar->Init( GetAbsOrigin(), vecVelocity, random->RandomFloat( 10.0f, 100.0f ), random->RandomFloat( 10.0f, 30.0f ) );
+	}
+}
+
+//=============================================================================
+//
+// Shooting Star Functionality
+//
+
+//Precahce the effects
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectShootingStars )
+CLIENTEFFECT_MATERIAL( "effects/redflare" )
+CLIENTEFFECT_REGISTER_END()
+
+//-----------------------------------------------------------------------------
+// Constructor
+//-----------------------------------------------------------------------------
+C_ShootingStar::C_ShootingStar( void ) : CSimpleEmitter( "ShootingStar" )
+{
+	m_flScale = 1.0f;
+	SetDynamicallyAllocated( false );
+}
+
+
+//-----------------------------------------------------------------------------
+// Destructor 
+//-----------------------------------------------------------------------------
+C_ShootingStar::~C_ShootingStar( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Destructor 
+//-----------------------------------------------------------------------------
+void C_ShootingStar::Init( const Vector vecOrigin, const Vector vecVelocity, int nSize,
+						   float flLifeTime )
+{
+	// Set the sort origin.
+	SetSortOrigin( vecOrigin );
+
+	// Create the initial particle and set the data.
+	SimpleParticle *pParticle = ( SimpleParticle* )AddParticle( sizeof( SimpleParticle ), GetPMaterial( "effects/redflare" ), vecOrigin );
+	if ( pParticle )
+	{
+		pParticle->m_vecVelocity = vecVelocity;
+
+		pParticle->m_uchColor[0] = pParticle->m_uchColor[1] = pParticle->m_uchColor[2] = 255;
+
+		pParticle->m_flRoll = random->RandomInt( 0, 360 );
+		pParticle->m_flRollDelta = random->RandomFloat( 1.0f, 4.0f );
+
+		pParticle->m_flLifetime = 0.0f;
+		pParticle->m_flDieTime = flLifeTime;
+
+		pParticle->m_uchStartAlpha = 255;
+		pParticle->m_uchEndAlpha = 0;
+		pParticle->m_uchStartSize = nSize;
+		pParticle->m_uchEndSize = ( nSize / 3 );
+	}
+
+	int iParticle = m_aParticles.AddToTail(); 
+	m_aParticles[iParticle] = pParticle;
+}
+
+//-----------------------------------------------------------------------------
+// Destructor 
+//-----------------------------------------------------------------------------
+void C_ShootingStar::Destroy( void )
+{
+	// Destroy shooting star particles.
+	int nParticleCount = m_aParticles.Count();
+	for ( int iParticle = ( nParticleCount - 1 ); iParticle >= 0; iParticle-- )
+	{
+		SimpleParticle *pParticle = m_aParticles[iParticle];
+		m_aParticles.Remove( iParticle );
+		CSimpleEmitter::NotifyDestroyParticle( pParticle );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_ShootingStar::SetSortOrigin( const Vector &vSortOrigin )
+{
+	CSimpleEmitter::SetSortOrigin( vSortOrigin );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : timeDelta - 
+//-----------------------------------------------------------------------------
+void C_ShootingStar::Update( float timeDelta )
+{
+	// Parent update.
+	CSimpleEmitter::Update( timeDelta );
+
+	// Don't update if the console is down.
+	if ( timeDelta <= 0.0f )
+		return;
+
+	// Are we still alive? Get the tail of the shooting star (last valid index)
+	// and test.
+	int nParticleCount = m_aParticles.Count();
+	if ( nParticleCount <= 0 )
+		return;
+
+	SimpleParticle *pParticle = m_aParticles[nParticleCount-1];
+	if ( pParticle->m_flLifetime >= pParticle->m_flDieTime )
+	{
+		Destroy();
+		return;
+	}
+
+	// Update the particles lifetime.
+	pParticle->m_flLifetime += timeDelta;	
+
+	// Update the particle position.
+	pParticle->m_Pos += ( pParticle->m_vecVelocity * timeDelta );
+
+	SetLocalOrigin( pParticle->m_Pos );
+	SetSortOrigin( GetAbsOrigin() );
+}
diff --git a/game/client/tf2/c_effect_shootingstar.h b/game/client/tf2/c_effect_shootingstar.h
new file mode 100644
index 0000000..a0f5671
--- /dev/null
+++ b/game/client/tf2/c_effect_shootingstar.h
@@ -0,0 +1,72 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's Meteor
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_EFFECT_SHOOTINGSTAR_H
+#define C_EFFECT_SHOOTINGSTAR_H
+#pragma once
+
+#include "c_baseanimating.h"
+#include "particles_simple.h"
+
+class C_ShootingStar;
+
+//=============================================================================
+//
+// Client-side shooting star spawner.
+//
+class C_ShootingStarSpawner : public C_BaseEntity
+{
+	DECLARE_CLASS( C_ShootingStarSpawner, C_BaseEntity );
+
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_ShootingStarSpawner();
+
+	void ClientThink( void );
+	void SpawnShootingStars( void );
+
+public:
+
+	float						m_flSpawnInterval;		// How often do I spawn meteors?
+};
+
+
+//=============================================================================
+//
+// Shooting Star Effect
+//
+class C_ShootingStar : public C_BaseAnimating, CSimpleEmitter
+{
+	DECLARE_CLASS( C_ShootingStar, C_BaseAnimating );
+
+public:
+
+	C_ShootingStar( );
+	~C_ShootingStar( void );
+
+	void	Init( const Vector vecOrigin, const Vector vecVelocity, int nSize, float flLifeTime );
+	void	Destroy( void );
+
+	void	Update( float timeDelta );
+
+public:
+
+	float	m_flScale;
+
+private:
+
+	void SetSortOrigin( const Vector &vSortOrigin );
+
+private:
+	C_ShootingStar( const C_ShootingStar & );
+
+	CUtlVector<SimpleParticle*>		m_aParticles;
+};
+
+#endif // C_EFFECT_SHOOTINGSTAR_H
\ No newline at end of file
diff --git a/game/client/tf2/c_entity_burn_effect.cpp b/game/client/tf2/c_entity_burn_effect.cpp
new file mode 100644
index 0000000..08c4f89
--- /dev/null
+++ b/game/client/tf2/c_entity_burn_effect.cpp
@@ -0,0 +1,85 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_entity_burn_effect.h"
+
+
+#define NUM_BURN_PARTICLES_PER_SEC	50
+
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_EntityBurnEffect, DT_EntityBurnEffect, CEntityBurnEffect )
+	RecvPropInt( RECVINFO( m_hBurningEntity ) )
+END_RECV_TABLE()
+
+
+
+C_EntityBurnEffect::C_EntityBurnEffect()
+{
+	m_pEmitter = CSimpleEmitter::Create( "Entity burn effect" );
+	if ( m_pEmitter.IsValid() )
+	{
+		m_hFireMaterial = m_pEmitter->GetPMaterial( "particle/fire" );
+	}
+	else
+	{
+		m_hFireMaterial = INVALID_MATERIAL_HANDLE;
+	}
+	m_Timer.Init( NUM_BURN_PARTICLES_PER_SEC );
+}
+
+
+void C_EntityBurnEffect::OnDataChanged( DataUpdateType_t updateType )
+{
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+}
+
+
+void C_EntityBurnEffect::ClientThink()
+{
+	if ( !m_pEmitter.IsValid() || IsDormant() )
+		return;
+
+	// Add some burning particles to our target entity.
+	C_BaseEntity *pEnt = ClientEntityList().GetBaseEntity( m_hBurningEntity );
+	if ( !pEnt )
+		return;
+
+	float dt = gpGlobals->frametime;
+	while ( m_Timer.NextEvent( dt ) )
+	{
+		Vector vDims = (pEnt->WorldAlignMaxs() - pEnt->WorldAlignMins()) * 0.5f;
+		Vector vCenter = pEnt->GetAbsOrigin() + pEnt->WorldAlignMins() + vDims;
+		Vector vPos = vCenter + vDims * RandomVector( -0.7, 0.7 );
+
+		float flLifetime = 1;
+		float flRadius = 3;
+		unsigned char uchColor[4] = { 255, 100, 0, 100 };
+
+		SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hFireMaterial, vPos, flLifetime, flRadius );
+		if ( pParticle )
+		{
+			pParticle->m_uchColor[0] = uchColor[0];
+			pParticle->m_uchColor[1] = uchColor[1];
+			pParticle->m_uchColor[2] = uchColor[2];
+
+			pParticle->m_uchEndAlpha = 0;
+			pParticle->m_uchStartAlpha = uchColor[3];
+
+			pParticle->m_vecVelocity.x = RandomFloat( -2, 2 );
+			pParticle->m_vecVelocity.y = RandomFloat( -2, 2 );
+			pParticle->m_vecVelocity.z = RandomFloat( 3, 29 );
+
+			// Pick up some velocity from the burning guy running around.
+			pParticle->m_vecVelocity += pEnt->GetAbsVelocity() * 0.6;
+		}
+	}
+}
+
diff --git a/game/client/tf2/c_entity_burn_effect.h b/game/client/tf2/c_entity_burn_effect.h
new file mode 100644
index 0000000..9a5d7d3
--- /dev/null
+++ b/game/client/tf2/c_entity_burn_effect.h
@@ -0,0 +1,44 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ENTITY_BURN_EFFECT_H
+#define C_ENTITY_BURN_EFFECT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_baseentity.h"
+#include "particle_util.h"
+#include "particles_simple.h"
+
+class C_EntityBurnEffect : public C_BaseEntity
+{
+public:
+
+	DECLARE_CLASS( C_EntityBurnEffect, C_BaseEntity );
+	DECLARE_CLIENTCLASS();
+
+					C_EntityBurnEffect();
+
+
+// Overrides.
+public:
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink();
+
+
+private:
+	int		m_hBurningEntity;	// todo: this should be an ehandle but base networkables aren't setup for ehandles yet.
+	
+	TimedEvent					m_Timer;
+	CSmartPtr<CSimpleEmitter>	m_pEmitter;
+	PMaterialHandle				m_hFireMaterial;
+};
+
+
+#endif // C_ENTITY_BURN_EFFECT_H
diff --git a/game/client/tf2/c_env_meteor.cpp b/game/client/tf2/c_env_meteor.cpp
new file mode 100644
index 0000000..e2ccf53
--- /dev/null
+++ b/game/client/tf2/c_env_meteor.cpp
@@ -0,0 +1,651 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "C_Env_Meteor.h"
+#include "fx_explosion.h"
+#include "tempentity.h"
+#include "c_tracer.h"
+
+//=============================================================================
+//
+// Meteor Factory Functions
+//
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_MeteorFactory::CreateMeteor( int nID, int iType,
+								   const Vector &vecPosition, const Vector &vecDirection, 
+		                           float flSpeed, float flStartTime, float flDamageRadius,
+								   const Vector &vecTriggerMins, const Vector &vecTriggerMaxs )
+{
+	C_EnvMeteor::Create( nID, iType, vecPosition, vecDirection, flSpeed, flStartTime, flDamageRadius,
+		                 vecTriggerMins, vecTriggerMaxs );
+}
+
+
+//=============================================================================
+//
+// Meteor Spawner Functions
+//
+
+void RecvProxy_MeteorTargetPositions( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	CEnvMeteorSpawnerShared *pSpawner = ( CEnvMeteorSpawnerShared* )pStruct;
+	pSpawner->m_aTargets[pData->m_iElement].m_vecPosition.x = pData->m_Value.m_Vector[0];
+	pSpawner->m_aTargets[pData->m_iElement].m_vecPosition.y = pData->m_Value.m_Vector[1];
+	pSpawner->m_aTargets[pData->m_iElement].m_vecPosition.z = pData->m_Value.m_Vector[2];
+}
+
+void RecvProxy_MeteorTargetRadii( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	CEnvMeteorSpawnerShared *pSpawner = ( CEnvMeteorSpawnerShared* )pStruct;
+	pSpawner->m_aTargets[pData->m_iElement].m_flRadius = pData->m_Value.m_Float;
+}
+
+void RecvProxyArrayLength_MeteorTargets( void *pStruct, int objectID, int currentArrayLength )
+{
+	CEnvMeteorSpawnerShared *pSpawner = ( CEnvMeteorSpawnerShared* )pStruct;
+	if ( pSpawner->m_aTargets.Count() < currentArrayLength )
+	{
+		pSpawner->m_aTargets.SetSize( currentArrayLength );
+	}
+}
+
+
+BEGIN_RECV_TABLE_NOBASE( CEnvMeteorSpawnerShared, DT_EnvMeteorSpawnerShared )
+	// Setup (read from) Worldcraft.
+	RecvPropInt		( RECVINFO( m_iMeteorType ) ),
+	RecvPropInt     ( RECVINFO( m_bSkybox ) ),
+	RecvPropFloat	( RECVINFO( m_flMinSpawnTime ) ),	
+	RecvPropFloat	( RECVINFO( m_flMaxSpawnTime ) ),
+	RecvPropInt     ( RECVINFO( m_nMinSpawnCount ) ),
+	RecvPropInt     ( RECVINFO( m_nMaxSpawnCount ) ),
+	RecvPropFloat	( RECVINFO( m_flMinSpeed ) ),	
+	RecvPropFloat	( RECVINFO( m_flMaxSpeed ) ),
+	
+	// Setup through Init.
+	RecvPropFloat	( RECVINFO( m_flStartTime ) ),
+	RecvPropInt		( RECVINFO( m_nRandomSeed ) ),
+	RecvPropVector	( RECVINFO( m_vecMinBounds ) ),
+	RecvPropVector  ( RECVINFO( m_vecMaxBounds ) ),
+	RecvPropVector  ( RECVINFO( m_vecTriggerMins ) ),
+	RecvPropVector  ( RECVINFO( m_vecTriggerMaxs ) ),
+
+	// Target List
+	RecvPropArray2( RecvProxyArrayLength_MeteorTargets,
+		            RecvPropVector( "meteortargetposition_array_element", 0, 0, 0, RecvProxy_MeteorTargetPositions ), 
+		            16, 0, "meteortargetposition_array" ),
+
+	RecvPropArray2( RecvProxyArrayLength_MeteorTargets,
+		            RecvPropFloat( "meteortargetradius_array_element", 0, 0, 0, RecvProxy_MeteorTargetRadii ), 
+		            16, 0, "meteortargetradius_array" )
+END_RECV_TABLE()
+
+// This table encodes the CBaseEntity data.
+IMPLEMENT_CLIENTCLASS_DT( C_EnvMeteorSpawner, DT_EnvMeteorSpawner, CEnvMeteorSpawner )
+	RecvPropDataTable	( RECVINFO_DT( m_SpawnerShared ), 0, &REFERENCE_RECV_TABLE( DT_EnvMeteorSpawnerShared ) ),
+	RecvPropInt			( RECVINFO( m_fDisabled ) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+C_EnvMeteorSpawner::C_EnvMeteorSpawner()
+{
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorSpawner::OnDataChanged( DataUpdateType_t updateType )
+{
+	// Initialize the client side spawner.
+	m_SpawnerShared.Init( &m_Factory, m_SpawnerShared.m_nRandomSeed, m_SpawnerShared.m_flStartTime, 
+						  m_SpawnerShared.m_vecMinBounds, m_SpawnerShared.m_vecMaxBounds,
+						  m_SpawnerShared.m_vecTriggerMins, m_SpawnerShared.m_vecTriggerMaxs );
+
+	// Set the next think to be the next spawn interval.
+	if ( !m_fDisabled )
+	{
+		SetNextClientThink( m_SpawnerShared.m_flNextSpawnTime );
+	}
+}
+
+#if 0
+// Will probably be used later!!
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorSpawner::ReceiveMessage( int classID,  bf_read &msg )
+{
+	if ( classID != GetClientClass()->m_ClassID )
+	{
+		// message is for subclass
+		BaseClass::ReceiveMessage( classID, msg );
+		return;
+	}
+
+	m_SpawnerShared.m_flStartTime = msg.ReadLong();
+	m_SpawnerShared.m_flNextSpawnTime = msg.ReadLong();
+	SetNextClientThink( m_SpawnerShared.m_flNextSpawnTime );
+}
+#endif
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorSpawner::ClientThink( void )
+{
+	SetNextClientThink( m_SpawnerShared.MeteorThink( gpGlobals->curtime ) );
+}
+
+//=============================================================================
+//
+// Meteor Tail Functions
+//
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+C_EnvMeteorHead::C_EnvMeteorHead()
+{
+	m_vecPos.Init();
+	m_vecPrevPos.Init();
+
+	m_flParticleScale = 1.0f;
+
+	m_pSmokeEmitter = NULL;
+	m_flSmokeSpawnInterval = 0.0f;
+	m_hSmokeMaterial = INVALID_MATERIAL_HANDLE;
+	m_flSmokeLifetime = 2.5f;
+	m_bEmitSmoke = true;
+
+	m_hFlareMaterial = INVALID_MATERIAL_HANDLE;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+C_EnvMeteorHead::~C_EnvMeteorHead()
+{
+	Destroy();
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorHead::Start( const Vector &vecOrigin, const Vector &vecDirection )
+{
+	// Emitters.
+	m_pSmokeEmitter = CSimpleEmitter::Create( "MeteorTrail" );
+//	m_pFireEmitter = CSimpleEmitter::Create( "MeteorFire" );
+	if ( !m_pSmokeEmitter /*|| !m_pFireEmitter*/ )
+		return;
+
+	// Smoke
+	m_pSmokeEmitter->SetSortOrigin( vecOrigin );
+	m_hSmokeMaterial = m_pSmokeEmitter->GetPMaterial( "particle/SmokeStack" );
+	Assert( m_hSmokeMaterial != INVALID_MATERIAL_HANDLE );
+
+	// Fire
+//	m_pFireEmitter->SetSortOrigin( vecOrigin );
+//	m_hFireMaterial = m_pFireEmitter->GetPMaterial( "particle/particle_fire" );
+//	Assert( m_hFireMaterial != INVALID_MATERIAL_HANDLE );
+
+	// Flare
+//	m_hFlareMaterial = m_ParticleEffect.FindOrAddMaterial( "effects/redflare" );
+
+	VectorCopy( vecDirection, m_vecDirection );
+	VectorCopy( vecOrigin, m_vecPos );
+
+	m_bInitThink = true;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorHead::Destroy( void )
+{
+	m_pSmokeEmitter = NULL;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorHead::MeteorHeadThink( const Vector &vecOrigin, float flTime )
+{
+	if ( m_bInitThink )
+	{
+		VectorCopy( vecOrigin, m_vecPrevPos );
+		m_bInitThink = false;
+	}
+
+	// Update the position of the emitters.
+	VectorCopy( vecOrigin, m_vecPos );
+
+	// Update Smoke
+	if ( m_pSmokeEmitter.IsValid() && m_bEmitSmoke )
+	{
+		m_pSmokeEmitter->SetSortOrigin( m_vecPos );
+
+		// Get distance covered
+		Vector vecDelta;
+		VectorSubtract( m_vecPos, m_vecPrevPos, vecDelta );
+		float flLength = vecDelta.Length();
+
+		int nParticleCount = flLength / 35.0f;
+		if ( nParticleCount < 1 )
+		{
+			nParticleCount = 1;
+		}
+
+		flLength /= nParticleCount;
+
+		Vector vecPos;
+		for( int iParticle = 0; iParticle < nParticleCount; ++iParticle )
+		{
+			vecPos = m_vecPrevPos + ( m_vecDirection * ( flLength * iParticle ) );
+
+			// Add some noise to the position.
+			Vector vecPosOffset;
+			vecPosOffset.Random( -m_flSmokeSpawnRadius, m_flSmokeSpawnRadius );
+			VectorAdd( vecPosOffset, vecPos, vecPosOffset );
+		
+
+			SimpleParticle *pParticle = ( SimpleParticle* )m_pSmokeEmitter->AddParticle( sizeof( SimpleParticle ),
+				                                                                         m_hSmokeMaterial,
+				                                                                         vecPosOffset );
+			if ( pParticle )
+			{
+				pParticle->m_flLifetime	= 0.0f;
+				pParticle->m_flDieTime = m_flSmokeLifetime;
+				
+				// Add just a little movement.
+				pParticle->m_vecVelocity.Random( -5.0f, 5.0f );
+				
+				pParticle->m_uchColor[0] = 255.0f;
+				pParticle->m_uchColor[1] = 255.0f;
+				pParticle->m_uchColor[2] = 255.0f;
+				
+
+				pParticle->m_uchStartSize = 70 * m_flParticleScale;
+				pParticle->m_uchEndSize = 25 * m_flParticleScale;
+				
+				float flAlpha = random->RandomFloat( 0.5f, 1.0f );
+				pParticle->m_uchStartAlpha = flAlpha * 255; 
+				pParticle->m_uchEndAlpha = 0;
+				
+				pParticle->m_flRoll	= random->RandomInt( 0, 360 );
+				pParticle->m_flRollDelta = random->RandomFloat( -1.0f, 1.0f );
+			}
+		}
+	}
+
+	// Update Fire
+//	if ( m_pFireEmitter && m_bEmitFire )
+//	{
+//	}
+
+	// Flare
+
+	// Save off position.
+	VectorCopy( m_vecPos, m_vecPrevPos );
+}
+
+//=============================================================================
+//
+// Meteor Tail Functions
+//
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+C_EnvMeteorTail::C_EnvMeteorTail()
+{
+	m_TailMaterialHandle = INVALID_MATERIAL_HANDLE;
+
+	m_pParticleMgr = NULL;
+	m_pParticle = NULL;
+
+	m_flFadeTime = 0.5f;
+	m_flWidth = 3.0f;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+C_EnvMeteorTail::~C_EnvMeteorTail()
+{
+	Destroy();
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorTail::Start( const Vector &vecOrigin, const Vector &vecDirection,
+							 float flSpeed )
+{
+	// Set the particle manager.
+	m_pParticleMgr = ParticleMgr();
+	m_pParticleMgr->AddEffect( &m_ParticleEffect, this );
+	m_TailMaterialHandle = m_ParticleEffect.FindOrAddMaterial( "particle/guidedplasmaprojectile" );
+	m_pParticle = m_ParticleEffect.AddParticle( sizeof( StandardParticle_t ), m_TailMaterialHandle );
+	if ( m_pParticle )
+	{
+		m_pParticle->m_Pos = vecOrigin;
+	}
+
+	VectorCopy( vecDirection, m_vecDirection );
+	m_flSpeed = flSpeed;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorTail::Destroy( void )
+{
+	if ( m_pParticleMgr ) 
+	{ 
+		m_pParticleMgr->RemoveEffect( &m_ParticleEffect );
+		m_pParticleMgr = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteorTail::DrawFragment( ParticleDraw* pDraw, 
+								    const Vector &vecStart, const Vector &vecDelta, 
+									const Vector4D &vecStartColor, const Vector4D &vecEndColor, 
+									float flStartV, float flEndV )
+{
+	if( !pDraw->GetMeshBuilder() )
+		return;
+	
+	// Clip the fragment.
+	Vector vecVerts[4];
+	if ( !Tracer_ComputeVerts( vecStart, vecDelta, m_flWidth, vecVerts ) )
+		return;
+
+	// NOTE: Gotta get the winding right so it's not backface culled
+	// (we need to turn of backface culling for these bad boys)
+	CMeshBuilder* pMeshBuilder = pDraw->GetMeshBuilder();
+
+	pMeshBuilder->Position3f( vecVerts[0].x, vecVerts[0].y, vecVerts[0].z );
+	pMeshBuilder->TexCoord2f( 0, 0.0f, flStartV );
+	pMeshBuilder->Color4fv( vecStartColor.Base() );
+	pMeshBuilder->AdvanceVertex();
+
+	pMeshBuilder->Position3f( vecVerts[1].x, vecVerts[1].y, vecVerts[1].z );
+	pMeshBuilder->TexCoord2f( 0, 1.0f, flStartV );
+	pMeshBuilder->Color4fv( vecStartColor.Base() );
+	pMeshBuilder->AdvanceVertex();
+
+	pMeshBuilder->Position3f( vecVerts[3].x, vecVerts[3].y, vecVerts[3].z );
+	pMeshBuilder->TexCoord2f( 0, 1.0f, flEndV );
+	pMeshBuilder->Color4fv( vecEndColor.Base() );
+	pMeshBuilder->AdvanceVertex();
+
+	pMeshBuilder->Position3f( vecVerts[2].x, vecVerts[2].y, vecVerts[2].z );
+	pMeshBuilder->TexCoord2f( 0, 0.0f, flEndV );
+	pMeshBuilder->Color4fv( vecEndColor.Base() );
+	pMeshBuilder->AdvanceVertex();
+}
+
+void C_EnvMeteorTail::SimulateParticles( CParticleSimulateIterator *pIterator )
+{
+	Particle *pParticle = (Particle*)pIterator->GetFirst();
+	while ( pParticle )
+	{
+		// Update the particle position.
+		pParticle->m_Pos = GetLocalOrigin();
+
+		pParticle = (Particle*)pIterator->GetNext();
+	}
+}
+
+
+void C_EnvMeteorTail::RenderParticles( CParticleRenderIterator *pIterator )
+{
+	const Particle *pParticle = (const Particle *)pIterator->GetFirst();
+	while ( pParticle )
+	{
+		// Now draw the tail fragments...
+		Vector4D vecStartColor( 1.0f, 1.0f, 1.0f, 1.0f );
+		Vector4D vecEndColor( 1.0f, 1.0f, 1.0f, 0.0f );
+		Vector vecDelta, vecStartPos, vecEndPos;
+
+		// Calculate the tail.
+		Vector vecTailEnd;
+		vecTailEnd = GetLocalOrigin() + ( m_vecDirection * -m_flSpeed );
+
+		// Transform particles into camera space.
+ 		TransformParticle( m_pParticleMgr->GetModelView(), GetLocalOrigin(), vecStartPos );
+ 		TransformParticle( m_pParticleMgr->GetModelView(), vecTailEnd, vecEndPos );
+		float sortKey = vecStartPos.z;
+
+		// Draw the tail fragment.
+		VectorSubtract( vecStartPos, vecEndPos, vecDelta );
+		DrawFragment( pIterator->GetParticleDraw(), vecEndPos, vecDelta, vecEndColor, vecStartColor,  
+					  1.0f - vecEndColor[3], 1.0f - vecStartColor[3] ); 
+
+		pParticle = (const Particle *)pIterator->GetNext( sortKey );
+	}
+}
+
+
+//=============================================================================
+//
+// Meteor Functions
+//
+
+static g_MeteorCounter = 0;
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+C_EnvMeteor::C_EnvMeteor()
+{
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+C_EnvMeteor::~C_EnvMeteor()
+{
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteor::ClientThink( void )
+{
+	// Get the current time.
+	float flTime = gpGlobals->curtime;
+
+	// Update the meteor.
+	if ( m_Meteor.IsInSkybox( flTime ) )
+	{
+		if ( m_Meteor.m_nLocation == METEOR_LOCATION_WORLD )
+		{
+			WorldToSkyboxThink( flTime );
+		}
+		else
+		{
+			SkyboxThink( flTime );
+		}
+	}
+	else
+	{
+		if ( m_Meteor.m_nLocation == METEOR_LOCATION_SKYBOX )
+		{
+			SkyboxToWorldThink( flTime );
+		}
+		else
+		{
+			WorldThink( flTime );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteor::SkyboxThink( float flTime )
+{
+	float flDeltaTime = flTime - m_Meteor.m_flStartTime;
+	if ( flDeltaTime > METEOR_MAX_LIFETIME )
+	{
+		Destroy( this );
+		return;
+	}
+
+	// Check to see if the object is passive or not - act accordingly!
+	if ( !m_Meteor.IsPassive( flTime ) )
+	{
+		// Update meteor position.
+		Vector origin;
+		m_Meteor.GetPositionAtTime( flTime, origin );
+		SetLocalOrigin( origin );
+
+		// Update the position of the tail effect.
+		m_TailEffect.SetLocalOrigin( GetLocalOrigin() );
+		m_HeadEffect.MeteorHeadThink( GetLocalOrigin(), flTime );
+	}
+
+	// Add the entity to the active list - update!
+	AddEntity();
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteor::WorldToSkyboxThink( float flTime )
+{
+	// Move the meteor from the world into the skybox.
+	m_Meteor.ConvertFromWorldToSkybox();
+
+	// Destroy the head effect.  Recreate it.
+	m_HeadEffect.Destroy();	
+	m_HeadEffect.Start( m_Meteor.m_vecStartPosition, m_vecTravelDir );
+	m_HeadEffect.SetSmokeEmission( true );
+	m_HeadEffect.SetParticleScale( 1.0f / 16.0f );	
+	m_HeadEffect.m_bInitThink = true;
+
+	// Update to world model.
+	SetModel( "models/props/common/meteorites/meteor05.mdl" );
+
+	// Update the meteor position (move into the skybox!)
+	SetLocalOrigin( m_Meteor.m_vecStartPosition );
+	
+	// Update (think).
+	SkyboxThink( flTime );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteor::SkyboxToWorldThink( float flTime )
+{
+	// Move the meteor from the skybox into the world.
+	m_Meteor.ConvertFromSkyboxToWorld();
+	
+	// Destroy the head effect.  Recreate it.
+	m_HeadEffect.Destroy();	
+	m_HeadEffect.Start( m_Meteor.m_vecStartPosition, m_vecTravelDir );
+	m_HeadEffect.SetSmokeEmission( true );
+	m_HeadEffect.SetParticleScale( 1.0f );
+	m_HeadEffect.m_bInitThink = true;
+	
+	// Update to world model.
+	SetModel( "models/props/common/meteorites/meteor04.mdl" );
+
+	SetLocalOrigin( m_Meteor.m_vecStartPosition );
+
+	// Update (think).
+	WorldThink( flTime );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteor::WorldThink( float flTime )
+{
+	// Update meteor position.
+	Vector vecEndPosition;
+	m_Meteor.GetPositionAtTime( flTime, vecEndPosition );
+
+	// m_Meteor must return the end position in world space for the trace to work.
+	Assert( GetMoveParent() == NULL );
+
+//	Msg( "Client: Time = %lf, Position: %4.2f %4.2f %4.2f\n", flTime, vecEndPosition.x, vecEndPosition.y, vecEndPosition.z );
+
+	// Check to see if we struck the world.  If so, cause an explosion.
+	trace_t trace;
+
+	Vector vecMin, vecMax;
+	GetRenderBounds( vecMin, vecMax );
+
+	// NOTE: This code works only if we aren't in hierarchy!!!
+	Assert( !GetMoveParent() );
+
+	CTraceFilterWorldOnly traceFilter;
+	UTIL_TraceHull( GetAbsOrigin(), vecEndPosition, vecMin, vecMax,
+		              MASK_SOLID_BRUSHONLY, &traceFilter, &trace ); 
+	
+	// Collision.
+	if ( ( trace.fraction < 1.0f ) && !( trace.surface.flags & SURF_SKY ) )
+	{
+		// Move up to the end.
+		Vector vecEnd = GetAbsOrigin() + ( ( vecEndPosition - GetAbsOrigin() ) * trace.fraction );
+		
+		// Create an explosion effect!
+		BaseExplosionEffect().Create( vecEnd, 10, 32, TE_EXPLFLAG_NONE );
+
+		// Debugging Info!!!!
+//		debugoverlay->AddBoxOverlay( vecEnd, Vector( -10, -10, -10 ), Vector( 10, 10, 10 ), QAngle( 0.0f, 0.0f, 0.0f ), 255, 0, 0, 0, 100 );
+
+		Destroy( this );
+		return;
+	}
+	else
+	{
+		// Move to the end.
+		SetLocalOrigin( vecEndPosition );
+	}
+
+	m_TailEffect.SetLocalOrigin( GetLocalOrigin() );
+	m_HeadEffect.MeteorHeadThink( GetLocalOrigin(), flTime );
+
+	// Add the entity to the active list - update!
+	AddEntity();
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+C_EnvMeteor *C_EnvMeteor::Create( int nID, int iMeteorType, const Vector &vecOrigin,
+								  const Vector &vecDirection, float flSpeed, float flStartTime,
+								  float flDamageRadius,
+								  const Vector &vecTriggerMins, const Vector &vecTriggerMaxs )
+{
+	C_EnvMeteor *pMeteor = new C_EnvMeteor;
+	if ( pMeteor )
+	{
+		pMeteor->m_Meteor.Init( nID, flStartTime, METEOR_PASSIVE_TIME, vecOrigin, vecDirection, flSpeed, flDamageRadius,
+			                    vecTriggerMins, vecTriggerMaxs );
+
+		// Initialize the meteor.
+		pMeteor->InitializeAsClientEntity( "models/props/common/meteorites/meteor05.mdl", RENDER_GROUP_OPAQUE_ENTITY );
+
+		// Handle forward simulation.
+		if ( ( pMeteor->m_Meteor.m_flStartTime + METEOR_MAX_LIFETIME ) < gpGlobals->curtime )
+		{
+			Destroy( pMeteor );
+		}
+
+		// Meteor Head and Tail
+		pMeteor->SetTravelDirection( vecDirection );
+
+		pMeteor->m_HeadEffect.SetSmokeEmission( true );
+		pMeteor->m_HeadEffect.Start( vecOrigin, vecDirection );
+		pMeteor->m_HeadEffect.SetParticleScale( 1.0f / 16.0f );
+
+		pMeteor->m_TailEffect.Start( vecOrigin, vecDirection, flSpeed );
+
+		pMeteor->SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+
+	return pMeteor;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void C_EnvMeteor::Destroy( C_EnvMeteor *pMeteor )
+{
+	Assert( pMeteor->GetClientHandle() != INVALID_CLIENTENTITY_HANDLE );
+	ClientThinkList()->AddToDeleteList( pMeteor->GetClientHandle() );
+}
diff --git a/game/client/tf2/c_env_meteor.h b/game/client/tf2/c_env_meteor.h
new file mode 100644
index 0000000..77e4d52
--- /dev/null
+++ b/game/client/tf2/c_env_meteor.h
@@ -0,0 +1,189 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ENV_METEOR_H
+#define C_ENV_METEOR_H
+#pragma once
+
+#include "utlvector.h"
+#include "env_meteor_shared.h"
+#include "baseparticleentity.h"
+#include "c_effect_shootingstar.h"
+
+//=============================================================================
+//
+// Client-side Meteor Factory Class
+//
+class C_MeteorFactory : public IMeteorFactory
+{
+public:
+
+	void CreateMeteor( int nID, int iType, const Vector &vecPosition, 
+		               const Vector &vecDirection, float flSpeed, float flStartTime,
+					   float flDamageRadius,
+					   const Vector &vecTriggerMins, const Vector &vecTriggerMaxs );
+};
+
+//=============================================================================
+//
+// Meteor Spawner Class
+//
+class C_EnvMeteorSpawner : public C_BaseEntity
+{
+public:
+
+	DECLARE_CLASS( C_EnvMeteorSpawner, C_BaseEntity );
+
+	DECLARE_CLIENTCLASS();
+
+	C_EnvMeteorSpawner();
+
+	// Will more than likely be used for meteor input(s) later!
+//	void ReceiveMessage( const char *msgname, int length, void *data );   
+
+	//-------------------------------------------------------------------------
+	// Networking
+	//-------------------------------------------------------------------------
+	void	OnDataChanged( DataUpdateType_t updateType );
+
+	//-------------------------------------------------------------------------
+	// Think
+	//-------------------------------------------------------------------------
+	void	ClientThink( void );
+
+private:
+
+	C_MeteorFactory				m_Factory;
+	CEnvMeteorSpawnerShared		m_SpawnerShared;
+	bool						m_fDisabled;
+};
+
+
+//=============================================================================
+//
+// Meteor Tail Class - Effect
+//
+class C_EnvMeteorHead
+{
+public:
+
+	C_EnvMeteorHead();
+	~C_EnvMeteorHead();
+
+	void	Start( const Vector &vecOrigin, const Vector &vecDirection );
+	void    Destroy( void );
+
+	void	MeteorHeadThink( const Vector &vecOrigin, float flTime );
+
+	void	SetSmokeEmission( bool bEmit ) { m_bEmitSmoke = bEmit; }
+	bool	EmitSmoke( void ) { return m_bEmitSmoke; }
+
+	void	SetParticleScale( float flScale ) { m_flParticleScale = flScale; }
+
+	bool				m_bInitThink;
+
+private:
+
+	Vector				m_vecPos;
+	Vector				m_vecPrevPos;
+	Vector				m_vecDirection;
+
+	float				m_flParticleScale;
+
+	CSmartPtr<CSimpleEmitter>	m_pSmokeEmitter;
+	float				m_flSmokeSpawnInterval;
+	float				m_flSmokeSpawnRadius;
+	PMaterialHandle		m_hSmokeMaterial;
+	float				m_flSmokeLifetime;			// How long do the particles live?
+	bool				m_bEmitSmoke;
+
+	PMaterialHandle		m_hFlareMaterial;
+};
+
+//=============================================================================
+//
+// Meteor Tail Class - Effect
+//
+class C_EnvMeteorTail : public C_BaseParticleEntity
+{
+public:
+
+	DECLARE_CLASS( C_EnvMeteorTail, C_BaseParticleEntity );
+
+	C_EnvMeteorTail();
+	~C_EnvMeteorTail();
+
+	void	Start( const Vector &vecOrigin, const Vector &vecDirection, float flSpeed );
+	void	Destroy( void );
+	virtual void RenderParticles( CParticleRenderIterator *pIterator );
+	virtual void SimulateParticles( CParticleSimulateIterator *pIterator );
+
+//protected:
+
+	void	DrawFragment( ParticleDraw* pDraw, const Vector &vecStart, const Vector &vecDelta, 
+						  const Vector4D &vecStartColor, const Vector4D &vecEndColor, 
+						  float flStartV, float flEndV );
+
+	CParticleMgr		*m_pParticleMgr;
+	Particle			*m_pParticle;
+
+	PMaterialHandle		m_TailMaterialHandle;
+
+	// Properties.
+	float				m_flFadeTime;
+	float				m_flWidth;
+	float				m_flSpeed;
+	Vector				m_vecDirection;
+
+private:
+	C_EnvMeteorTail( const C_EnvMeteorTail & );
+};
+
+//=============================================================================
+//
+// Meteor Class (Client-side only!)
+//
+class C_EnvMeteor :  public C_BaseAnimating
+{
+public:
+
+	DECLARE_CLASS( C_EnvMeteor, C_BaseAnimating );
+
+	//-------------------------------------------------------------------------
+	// Initialization/Destruction
+	//-------------------------------------------------------------------------
+	C_EnvMeteor();
+	~C_EnvMeteor();
+	static C_EnvMeteor	   *Create( int nID, int iMeteorType, const Vector &vecOrigin, 
+		                            const Vector &vecDirection, float flSpeed, float flStartTime,
+									float flDamageRadius,
+								    const Vector &vecTriggerMins, const Vector &vecTriggerMaxs );
+	static void				Destroy( C_EnvMeteor *pMeteor );
+	
+	//-------------------------------------------------------------------------
+	// Think
+	//-------------------------------------------------------------------------
+	void					ClientThink( void );
+	void					SkyboxThink( float flTime );
+	void					WorldThink( float flTime );
+	void					WorldToSkyboxThink( float flTime );
+	void					SkyboxToWorldThink( float flTime );
+
+	void					SetTravelDirection( const Vector &vecDir ) { m_vecTravelDir = vecDir; }
+
+private:
+	C_EnvMeteor( const C_EnvMeteor & );
+
+	CEnvMeteorShared			m_Meteor;
+
+	// Effects
+	Vector						m_vecTravelDir;
+	C_EnvMeteorHead				m_HeadEffect;
+	C_EnvMeteorTail				m_TailEffect;
+};
+
+#endif // C_ENV_METEOR_H
diff --git a/game/client/tf2/c_func_construction_yard.cpp b/game/client/tf2/c_func_construction_yard.cpp
new file mode 100644
index 0000000..200f8fd
--- /dev/null
+++ b/game/client/tf2/c_func_construction_yard.cpp
@@ -0,0 +1,42 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A place where vehicles can be built
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: A place where vehicles can be built
+//-----------------------------------------------------------------------------
+class C_FuncConstructionYard : public C_BaseEntity
+{
+	DECLARE_CLASS( C_FuncConstructionYard, C_BaseEntity );
+public:
+	DECLARE_CLIENTCLASS();
+//	DECLARE_MINIMAP_PANEL();
+
+	C_FuncConstructionYard();
+	const char	*GetTargetDescription( void ) const;
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_FuncConstructionYard, DT_FuncConstructionYard, CFuncConstructionYard)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_FuncConstructionYard::C_FuncConstructionYard()
+{
+//	CONSTRUCT_MINIMAP_PANEL( "minimap_construction_yard", MINIMAP_RESOURCE_ZONES );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const char *C_FuncConstructionYard::GetTargetDescription( void ) const
+{
+	return "Construction Yard";
+}
+
diff --git a/game/client/tf2/c_func_resource.cpp b/game/client/tf2/c_func_resource.cpp
new file mode 100644
index 0000000..ac9dc5b
--- /dev/null
+++ b/game/client/tf2/c_func_resource.cpp
@@ -0,0 +1,263 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CResourceZone.
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "engine/IEngineSound.h"
+#include "c_func_resource.h"
+#include "techtree.h"
+#include "fx.h"
+#include "fx_sparks.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// Chunk movement
+#define	CHUNK_FLECK_MIN_SPEED		25.0f
+#define	CHUNK_FLECK_MAX_SPEED		100.0f
+#define	CHUNK_FLECK_GRAVITY			800.0f
+#define	CHUNK_FLECK_DAMPEN			0.3f
+#define	CHUNK_FLECK_ANGULAR_SPRAY	0.8f
+
+IMPLEMENT_CLIENTCLASS_DT(C_ResourceZone, DT_ResourceZone, CResourceZone)
+	RecvPropFloat(RECVINFO(m_flClientResources)),
+	RecvPropInt(RECVINFO(m_nResourcesLeft)),
+END_RECV_TABLE()
+
+LINK_ENTITY_TO_CLASS( trigger_resourcezone, C_ResourceZone );
+BEGIN_PREDICTION_DATA( C_ResourceZone )
+END_PREDICTION_DATA();
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ResourceZone::C_ResourceZone()
+{
+	CONSTRUCT_MINIMAP_PANEL( "minimap_resource_zone", MINIMAP_RESOURCE_ZONES );
+}
+
+//-----------------------------------------------------------------------------
+// Add, remove object from the panel 
+//-----------------------------------------------------------------------------
+void C_ResourceZone::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	ENTITY_PANEL_ACTIVATE( "resourcezone", (!bDormant && m_flClientResources > 0) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ResourceZone::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		SetNextClientThink( gpGlobals->curtime + 1.0 );
+	}
+
+	// If I've just dried up, remove me from the minimap
+	if ( m_flClientResources <= 0 )
+	{
+		ENTITY_PANEL_ACTIVATE( "resourcezone", false );
+		DESTRUCT_MINIMAP_PANEL();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const char *C_ResourceZone::GetTargetDescription( void ) const
+{
+	return "Resource Zone";
+}
+
+
+//==========================================================================================================
+// Resource Spawner
+//==========================================================================================================
+IMPLEMENT_CLIENTCLASS_DT(C_ResourceSpawner, DT_ResourceSpawner, CResourceSpawner)
+	RecvPropInt(RECVINFO(m_bActive)),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ResourceSpawner::C_ResourceSpawner( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ResourceSpawner::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		SetNextClientThink( gpGlobals->curtime + random->RandomFloat( 2.0, 4.0 ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Receive a spawn message from the server
+//-----------------------------------------------------------------------------
+void C_ResourceSpawner::ReceiveMessage( int classID, bf_read &msg )
+{
+	if ( classID != GetClientClass()->m_ClassID )
+	{
+		// message is for subclass
+		BaseClass::ReceiveMessage( classID, msg );
+		return;
+	}
+
+	// Make some particles
+	SpawnEffect( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ResourceSpawner::ClientThink( void )
+{
+	SetNextClientThink( gpGlobals->curtime + random->RandomFloat( 2.0, 10.0 ) );
+
+	// Don't do random puffs if I'm not active
+	if ( !m_bActive )
+		return;
+
+	// Occasionally spurt as if I was making a chunk
+	if ( random->RandomInt(0, 20) == 5 )
+	{
+		SpawnEffect( true );
+	}
+	else
+	{
+		SpawnEffect( false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Particle effects created when we spawn a chunk
+//-----------------------------------------------------------------------------
+void C_ResourceSpawner::SpawnEffect( bool bSpawningChunk )
+{
+	Vector normal = Vector(0,0,1);
+	Vector offset = GetAbsOrigin() + (normal * 16);
+	Vector dir;
+
+	float r = sResourceColor.r;
+	float g = sResourceColor.g;
+	float b = sResourceColor.b;
+
+	// Play a random puff sound
+	if ( bSpawningChunk )
+	{
+		EmitSound( "ResourceSpawner.BigPuff" );
+	}
+	else
+	{
+		EmitSound( "ResourceSpawner.Puff" );
+	}
+
+	// Chunks o'dirt
+	CSmartPtr<CFleckParticles> fleckEmitter = CFleckParticles::Create( "SpawnEffect 1", offset, Vector(5,5,5) );
+	if ( !fleckEmitter )
+		return;
+
+	// Setup our collision information
+	fleckEmitter->m_ParticleCollision.Setup( offset, &normal, CHUNK_FLECK_ANGULAR_SPRAY, CHUNK_FLECK_MIN_SPEED, CHUNK_FLECK_MAX_SPEED, CHUNK_FLECK_GRAVITY, CHUNK_FLECK_DAMPEN );
+
+	int	numFlecks;
+	if ( bSpawningChunk )
+		numFlecks = random->RandomInt( 48, 64 );
+	else
+		numFlecks = random->RandomInt( 1, 3 );
+
+	// Dump out flecks
+	int i;
+	for ( i = 0; i < numFlecks; i++ )
+	{
+		FleckParticle *pParticle = (FleckParticle *) fleckEmitter->AddParticle( sizeof(FleckParticle), g_Mat_Fleck_Cement[random->RandomInt(0,1)], offset );
+
+		if ( pParticle == NULL )
+			break;
+
+		pParticle->m_flLifetime		= 0.0f;
+		pParticle->m_flDieTime		= random->RandomFloat(3.0f,5.0f);
+
+		if ( bSpawningChunk )
+		{
+			pParticle->m_uchSize		= random->RandomInt( 4, 8 );
+			dir[0] = normal[0] + random->RandomFloat( -CHUNK_FLECK_ANGULAR_SPRAY, CHUNK_FLECK_ANGULAR_SPRAY );
+			dir[1] = normal[1] + random->RandomFloat( -CHUNK_FLECK_ANGULAR_SPRAY, CHUNK_FLECK_ANGULAR_SPRAY );
+			dir[2] = normal[2] + random->RandomFloat( -CHUNK_FLECK_ANGULAR_SPRAY, CHUNK_FLECK_ANGULAR_SPRAY );
+			pParticle->m_vecVelocity	= dir * ( random->RandomFloat( CHUNK_FLECK_MIN_SPEED, CHUNK_FLECK_MAX_SPEED ) * ( 9 - pParticle->m_uchSize ) );
+		}
+		else
+		{
+			pParticle->m_uchSize		= random->RandomInt( 2, 4 );
+			dir[0] = normal[0] + (random->RandomFloat( -CHUNK_FLECK_ANGULAR_SPRAY, CHUNK_FLECK_ANGULAR_SPRAY ) * 0.5);
+			dir[1] = normal[1] + (random->RandomFloat( -CHUNK_FLECK_ANGULAR_SPRAY, CHUNK_FLECK_ANGULAR_SPRAY ) * 0.5);
+			dir[2] = normal[2] + (random->RandomFloat( -CHUNK_FLECK_ANGULAR_SPRAY, CHUNK_FLECK_ANGULAR_SPRAY ) * 0.5);
+			pParticle->m_vecVelocity	= dir * ( random->RandomFloat( CHUNK_FLECK_MIN_SPEED, CHUNK_FLECK_MAX_SPEED ) * 3);
+		}
+
+		pParticle->m_flRoll		= random->RandomFloat( 0, 360 );
+		pParticle->m_flRollDelta	= random->RandomFloat( 0, 360 );
+
+		pParticle->m_uchColor[0] = r;
+		pParticle->m_uchColor[1] = g;
+		pParticle->m_uchColor[2] = b;
+	}
+
+
+	// Create a couple of big, floating smoke clouds
+	if ( bSpawningChunk || random->RandomInt(0,10) == 0 )
+	{
+		CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "SpawnEffect 2" );
+		pSmokeEmitter->SetSortOrigin( offset );
+		int iSmokeClouds = 2;
+		if ( !bSpawningChunk )
+			iSmokeClouds = 1;
+		for ( i = 0; i < iSmokeClouds; i++ )
+		{
+			SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], offset );
+			if ( pParticle == NULL )
+				break;
+
+			pParticle->m_flLifetime	= 0.0f;
+			pParticle->m_flDieTime	= random->RandomFloat( 2.0f, 3.0f );
+
+			if ( bSpawningChunk )
+			{
+				pParticle->m_uchStartSize	= 32;
+				pParticle->m_uchEndSize		= 128;
+			}
+			else
+			{
+				pParticle->m_uchStartSize	= 16;
+				pParticle->m_uchEndSize		= 64;
+			}
+
+			dir[0] = normal[0] + random->RandomFloat( -0.4f, 0.4f );
+			dir[1] = normal[1] + random->RandomFloat( -0.4f, 0.4f );
+			dir[2] = normal[2] + random->RandomFloat( 0, 0.6f );
+			pParticle->m_vecVelocity = dir * random->RandomFloat( 2.0f, 24.0f )*(i+1);
+			pParticle->m_uchStartAlpha	= 160;
+			pParticle->m_uchEndAlpha	= 0;
+			pParticle->m_flRoll			= random->RandomFloat( 180, 360 );
+			pParticle->m_flRollDelta	= random->RandomFloat( -1, 1 );
+
+			pParticle->m_uchColor[0] = r;
+			pParticle->m_uchColor[1] = g;
+			pParticle->m_uchColor[2] = b;
+		}
+	}
+}
diff --git a/game/client/tf2/c_func_resource.h b/game/client/tf2/c_func_resource.h
new file mode 100644
index 0000000..fd22b28
--- /dev/null
+++ b/game/client/tf2/c_func_resource.h
@@ -0,0 +1,57 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CObjectSentrygun
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_FUNC_RESOURCE_H
+#define C_FUNC_RESOURCE_H
+
+#include "commanderoverlay.h"
+#include "hud_minimap.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: A resource zone
+//-----------------------------------------------------------------------------
+class C_ResourceZone : public C_BaseEntity
+{
+	DECLARE_CLASS( C_ResourceZone, C_BaseEntity );
+public:
+	DECLARE_PREDICTABLE();
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+	DECLARE_MINIMAP_PANEL();
+
+	C_ResourceZone();
+	virtual void	SetDormant( bool bDormant );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	const char	*GetTargetDescription( void ) const;
+
+public:
+	float	m_flClientResources;	// Amount of resources left
+	int		m_nResourcesLeft;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: A resource chunk spawning point in a resource zone
+//-----------------------------------------------------------------------------
+class C_ResourceSpawner : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_ResourceSpawner, C_BaseAnimating );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ResourceSpawner();
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+	virtual void ReceiveMessage( int classID,  bf_read &msg );
+	virtual void SpawnEffect( bool bSpawningChunk );
+	virtual void ClientThink( void );
+
+public:
+	bool	m_bActive;
+};
+
+#endif // C_FUNC_RESOURCE_H
+
diff --git a/game/client/tf2/c_gasoline_blob.cpp b/game/client/tf2/c_gasoline_blob.cpp
new file mode 100644
index 0000000..800ee89
--- /dev/null
+++ b/game/client/tf2/c_gasoline_blob.cpp
@@ -0,0 +1,350 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_gasoline_blob.h"
+#include "gasoline_shared.h"
+#include "engine/IEngineSound.h"
+#include "clienteffectprecachesystem.h"
+
+static CUtlLinkedList<C_GasolineBlob*, int> g_GasolineBlobs;
+
+// If multiple blobs are within this distance to each other, then only one will
+// play a sound.
+#define BLOB_SOUND_RELATED_DISTANCE	600
+
+
+#define PUDDLE_START_SIZE	35
+#define PUDDLE_END_SIZE		65
+#define PUDDLE_GROW_TIME	0.5
+
+#define PUDDLE_FADE_TIME	1.0
+
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheGasolineBlob )
+CLIENTEFFECT_MATERIAL( "decals/puddle" )
+CLIENTEFFECT_REGISTER_END()
+
+// ------------------------------------------------------------------------------------------------ //
+// CGasolineEmitter.
+// ------------------------------------------------------------------------------------------------ //
+
+CSmartPtr<CGasolineEmitter> CGasolineEmitter::Create( C_GasolineBlob *pBlob )
+{
+	CGasolineEmitter *pEmitter = new CGasolineEmitter;
+	
+	pEmitter->m_pBlob = pBlob;
+
+	pEmitter->m_hFireMaterial = pEmitter->GetPMaterial( "particle/fire" );
+	pEmitter->m_hUnlitMaterial = pEmitter->GetPMaterial( "sprites/env_particles" );
+	
+	pEmitter->m_Timer.Init( 40 );
+
+	return pEmitter;
+}
+
+
+void CGasolineEmitter::UpdateFire( float frametime )
+{
+	float flLifetime = gpGlobals->curtime - m_pBlob->m_flCreateTime;
+
+	float litPercent = 1;
+	if ( m_pBlob->IsLit() )
+	{
+		litPercent = 1 - (flLifetime / m_pBlob->m_flMaxLifetime);
+		if ( litPercent <= 0 )
+			return;
+	}
+	else
+	{
+		return;
+	}
+
+	// Don't show a burn effect for a blob that hasn't hit anything yet.
+	// If you do, it tends to make the flamethrower effect look weird.
+	if ( !m_pBlob->IsStopped() )
+		return;
+
+	// Make a coordinate system in which to spawn the particles. It 
+	Vector vUp, vRight;
+	vUp.Init();
+	vRight.Init();
+	if ( m_pBlob->IsStopped() )
+	{
+		QAngle angles;
+		VectorAngles( m_pBlob->GetSurfaceNormal(), angles );
+		AngleVectors( angles, NULL, &vRight, &vUp );
+	}
+	
+	PMaterialHandle hMaterial = m_hFireMaterial;
+	float flParticleLifetime = 1;
+	float flRadius = 7;
+	unsigned char uchColor[4] = { 255, 128, 0, 128 };
+	float flMaxZVel = 29;
+
+
+	float curDelta = frametime;
+	while ( m_Timer.NextEvent( curDelta ) )
+	{
+		// Based on how close we are to expiring, show less particles.
+		if ( RandomFloat( 0, 1 ) > litPercent )
+			continue;
+
+		Vector vPos = m_pBlob->GetAbsOrigin();
+		if ( m_pBlob->IsStopped() )
+		{
+			float flAngle = RandomFloat( 0, M_PI * 2 );
+			float flDist = RandomFloat( 0, GASOLINE_BLOB_RADIUS );
+			vPos += vRight * (cos( flAngle ) * flDist);
+			vPos += vUp * ( sin( flAngle ) * flDist );
+		}
+		else
+		{
+			vPos += RandomVector( -GASOLINE_BLOB_RADIUS, GASOLINE_BLOB_RADIUS );
+		}
+		
+		SimpleParticle *pParticle = AddSimpleParticle( hMaterial, vPos, flParticleLifetime, flRadius );
+		if ( pParticle )
+		{
+			pParticle->m_uchColor[0] = uchColor[0];
+			pParticle->m_uchColor[1] = uchColor[1];
+			pParticle->m_uchColor[2] = uchColor[2];
+
+			pParticle->m_uchEndAlpha = 0;
+			pParticle->m_uchStartAlpha = uchColor[3];
+
+			pParticle->m_vecVelocity.x = RandomFloat( -2, 2 );
+			pParticle->m_vecVelocity.y = RandomFloat( -2, 2 );
+			pParticle->m_vecVelocity.z = RandomFloat( 3, flMaxZVel );
+		}
+	}
+}
+
+
+// ------------------------------------------------------------------------------------------------ //
+// C_GasolineBlob.
+// ------------------------------------------------------------------------------------------------ //
+
+IMPLEMENT_CLIENTCLASS_DT_NOBASE( C_GasolineBlob, DT_GasolineBlob, CGasolineBlob )
+	RecvPropInt( RECVINFO( m_BlobFlags ) ),
+	RecvPropVector( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
+	RecvPropInt( RECVINFO_NAME(m_hNetworkMoveParent, moveparent), 0, RecvProxy_IntToMoveParent ),
+	RecvPropFloat( RECVINFO( m_flLitStartTime ) ),
+	RecvPropFloat( RECVINFO( m_flCreateTime ) ),
+	RecvPropFloat( RECVINFO( m_flMaxLifetime ) ),
+	RecvPropInt( RECVINFO( m_iTeamNum ) ),
+	RecvPropVector( RECVINFO( m_vSurfaceNormal ) )
+END_RECV_TABLE()
+
+
+C_GasolineBlob::C_GasolineBlob()
+{
+	m_pEmitter = CGasolineEmitter::Create( this );
+	m_vSurfaceNormal.Init();
+	m_flLitStartTime = 0;
+	m_bSoundOn = false;
+	g_GasolineBlobs.AddToTail( this );
+	m_flPuddleSize = PUDDLE_START_SIZE;
+	m_flPuddleFade = 1;
+}
+
+
+C_GasolineBlob::~C_GasolineBlob()
+{
+	g_GasolineBlobs.FindAndRemove( this );
+	StopSound();
+
+	// If a bunch of nearby blobs weren't playing a sound because we were, have them start their sound now.
+	FOR_EACH_LL( g_GasolineBlobs, i )
+	{
+		C_GasolineBlob *pBlob = g_GasolineBlobs[i];
+
+		if ( pBlob->IsSoundRelatedTo( this ) )
+			pBlob->CheckStartSound();
+	}
+}
+
+
+bool C_GasolineBlob::IsLit() const
+{
+	return (m_BlobFlags & BLOBFLAG_LIT) != 0;
+}
+
+
+bool C_GasolineBlob::IsStopped() const
+{
+	return (m_BlobFlags & BLOBFLAG_STOPPED) != 0;
+}
+
+
+const Vector& C_GasolineBlob::GetSurfaceNormal() const
+{
+	return m_vSurfaceNormal;
+}
+
+
+float C_GasolineBlob::GetLitStartTime() const
+{
+	return m_flLitStartTime;
+}
+
+
+void C_GasolineBlob::OnDataChanged( DataUpdateType_t type )
+{
+	BaseClass::OnDataChanged( type );
+	
+	if ( type == DATA_UPDATE_CREATED )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+
+	CheckStartSound();
+}
+
+
+void C_GasolineBlob::ClientThink()
+{
+	if ( m_pEmitter.IsValid() )
+		m_pEmitter->UpdateFire( gpGlobals->frametime );
+
+	// Grow the puddle a little.
+	if ( IsStopped() )
+	{
+		if ( IsLit() )
+		{
+			// Fade out after we get lit.
+			m_flPuddleFade -= gpGlobals->frametime / PUDDLE_FADE_TIME;
+			m_flPuddleFade = MAX( m_flPuddleFade, 0 );
+		}
+		else
+		{
+			// Grow the puddle until it's at its max size.
+			m_flPuddleSize += gpGlobals->frametime * ( PUDDLE_END_SIZE - PUDDLE_START_SIZE ) / PUDDLE_GROW_TIME;
+			m_flPuddleSize = MIN( m_flPuddleSize, PUDDLE_END_SIZE );
+		}
+	}
+}
+
+
+bool C_GasolineBlob::ShouldDraw()
+{
+	return IsStopped() && (m_flPuddleFade > 0);
+}
+
+
+int C_GasolineBlob::DrawModel( int flags )
+{
+	// Generate a basis.
+	QAngle angles;
+	VectorAngles( m_vSurfaceNormal, angles );
+
+	Vector vRight, vUp;
+	AngleVectors( angles, NULL, &vRight, &vUp );
+
+	
+	float flAlpha = m_flPuddleFade * RemapVal( m_flPuddleSize, PUDDLE_START_SIZE, PUDDLE_END_SIZE, 0, 1 );
+	if ( flAlpha <= 0 )
+		return 0;
+
+
+	// Draw the puddle.
+	IMaterial *pMat = materials->FindMaterial( "decals/puddle", TEXTURE_GROUP_DECAL );
+	IMesh *pMesh = materials->GetDynamicMesh( true, NULL, NULL, pMat );
+	CMeshBuilder mb;
+	mb.Begin( pMesh, MATERIAL_QUADS, 1 );
+		
+		Vector v;
+		
+		v = GetAbsOrigin() + m_vSurfaceNormal + vRight*m_flPuddleSize - vUp*m_flPuddleSize;
+		mb.Position3f( v.x, v.y, v.z );
+		mb.Color4f( 1, 1, 1, flAlpha );
+		mb.Normal3f( VectorExpand( m_vSurfaceNormal ) );
+		mb.TexCoord2f( 0, 1, 0 );
+		mb.AdvanceVertex();
+
+		v = GetAbsOrigin() + m_vSurfaceNormal + vRight*m_flPuddleSize + vUp*m_flPuddleSize;
+		mb.Position3f( v.x, v.y, v.z );
+		mb.Color4f( 1, 1, 1, flAlpha );
+		mb.Normal3f( VectorExpand( m_vSurfaceNormal ) );
+		mb.TexCoord2f( 0, 1, 1 );
+		mb.AdvanceVertex();
+
+		v = GetAbsOrigin() + m_vSurfaceNormal - vRight*m_flPuddleSize + vUp*m_flPuddleSize;
+		mb.Position3f( v.x, v.y, v.z );
+		mb.Color4f( 1, 1, 1, flAlpha );
+		mb.Normal3f( VectorExpand( m_vSurfaceNormal ) );
+		mb.TexCoord2f( 0, 0, 1 );
+		mb.AdvanceVertex();
+
+		v = GetAbsOrigin() + m_vSurfaceNormal - vRight*m_flPuddleSize - vUp*m_flPuddleSize;
+		mb.Position3f( v.x, v.y, v.z );
+		mb.Color4f( 1, 1, 1, flAlpha );
+		mb.Normal3f( VectorExpand( m_vSurfaceNormal ) );
+		mb.TexCoord2f( 0, 0, 0 );
+		mb.AdvanceVertex();
+
+	mb.End( false, true );		
+
+	return 0;
+}
+
+
+bool C_GasolineBlob::IsSoundRelatedTo( const C_GasolineBlob *pBlob ) const
+{
+	return pBlob->GetAbsOrigin().DistTo( GetAbsOrigin() ) < BLOB_SOUND_RELATED_DISTANCE;
+}
+
+
+bool C_GasolineBlob::IsPlayingBurningSound() const
+{
+	return m_bSoundOn;
+}
+
+
+void C_GasolineBlob::CheckStartSound()
+{
+	if ( IsPlayingBurningSound() || (m_BlobFlags & BLOBFLAG_STOPPED) == 0 || !IsLit() )
+		return;
+
+
+	// First, make sure no nearby blob is playing the sound.
+	FOR_EACH_LL( g_GasolineBlobs, i )
+	{
+		C_GasolineBlob *pBlob = g_GasolineBlobs[i];
+		
+		if ( pBlob != this && pBlob->IsSoundRelatedTo( this ) )
+		{
+			// If it's already playing a sound, then don't start our sound.
+			if ( pBlob->IsPlayingBurningSound() )
+				return;
+		}
+	}		
+
+	
+	StartSound();
+}
+
+
+void C_GasolineBlob::StartSound()
+{
+	if ( !m_bSoundOn )
+	{
+		EmitSound( "GasolineBlob.FlameSound" );
+
+		m_bSoundOn = true;
+	}
+}
+
+
+void C_GasolineBlob::StopSound()
+{
+	if ( m_bSoundOn )
+	{
+		BaseClass::StopSound( "GasolineBlob.FlameSound" );
+		m_bSoundOn = false;
+	}
+}
+
diff --git a/game/client/tf2/c_gasoline_blob.h b/game/client/tf2/c_gasoline_blob.h
new file mode 100644
index 0000000..101dfca
--- /dev/null
+++ b/game/client/tf2/c_gasoline_blob.h
@@ -0,0 +1,107 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_GASOLINE_BLOB_H
+#define C_GASOLINE_BLOB_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_baseentity.h"
+#include "particles_simple.h"
+#include "particle_util.h"
+
+
+class C_GasolineBlob;
+
+class CGasolineEmitter : public CSimpleEmitter
+{
+public:
+
+	static CSmartPtr<CGasolineEmitter>	Create( C_GasolineBlob *pBlob );
+
+	void				UpdateFire( float frametime );
+
+
+private:
+
+						CGasolineEmitter() : CSimpleEmitter( "Gasoline" ){}
+						CGasolineEmitter( const CGasolineEmitter & );
+
+	
+	C_GasolineBlob		*m_pBlob;
+
+	PMaterialHandle		m_hFireMaterial;
+	PMaterialHandle		m_hUnlitMaterial;
+	TimedEvent			m_Timer;
+};
+
+
+class C_GasolineBlob : public C_BaseEntity
+{
+friend class CGasolineEmitter;
+
+public:
+	DECLARE_CLASS( C_GasolineBlob, C_BaseEntity );
+	DECLARE_CLIENTCLASS();
+
+
+					C_GasolineBlob();
+	virtual			~C_GasolineBlob();
+
+	bool			IsLit() const;
+	bool			IsStopped() const;
+	const Vector&	GetSurfaceNormal() const;
+	float			GetLitStartTime() const;
+
+
+// Overrides.
+public:
+
+	virtual void	OnDataChanged( DataUpdateType_t type );
+	virtual void	ClientThink();
+	virtual int		DrawModel( int flags );
+	virtual bool	ShouldDraw();
+
+
+private:
+
+	// Returns true if the two blobs relate their sound, meaning one blob won't play
+	// its sound if the other one is playing it.
+	bool			IsSoundRelatedTo( const C_GasolineBlob *pBlob ) const;
+
+	bool			IsPlayingBurningSound() const;
+
+	// Starts the burning sound if no other flames are playing the sound nearby.
+	void			CheckStartSound();
+
+	// Make the burning sound.
+	void			StartSound();
+	void			StopSound();
+
+
+private:
+
+	bool			m_bSoundOn;
+	float			m_flPuddleSize;
+	float			m_flPuddleFade;
+
+	CSmartPtr<CGasolineEmitter>	m_pEmitter;
+
+	float			m_flLitStartTime;
+
+	float			m_flCreateTime;
+	float			m_flMaxLifetime;
+
+	Vector			m_vSurfaceNormal;
+
+	int				m_BlobFlags;		// Combination of BLOBFLAG_ defines.
+};
+
+
+#endif // C_GASOLINE_BLOB_H
diff --git a/game/client/tf2/c_grenade_antipersonnel.cpp b/game/client/tf2/c_grenade_antipersonnel.cpp
new file mode 100644
index 0000000..ee4d60e
--- /dev/null
+++ b/game/client/tf2/c_grenade_antipersonnel.cpp
@@ -0,0 +1,84 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "grenade_base_empable.h"
+#include "particles_simple.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Client side entity for the antipersonnel grenades
+//-----------------------------------------------------------------------------
+class C_GrenadeAntiPersonnel : public C_BaseEMPableGrenade
+{
+	DECLARE_CLASS( C_GrenadeAntiPersonnel, C_BaseEMPableGrenade );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_GrenadeAntiPersonnel();
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink( void );
+
+public:
+	C_GrenadeAntiPersonnel( const C_GrenadeAntiPersonnel & );
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_GrenadeAntiPersonnel, DT_GrenadeAntiPersonnel, CGrenadeAntiPersonnel)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_GrenadeAntiPersonnel::C_GrenadeAntiPersonnel( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_GrenadeAntiPersonnel::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Only think when sapping
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Spawn effects if I'm sapping
+//-----------------------------------------------------------------------------
+void C_GrenadeAntiPersonnel::ClientThink( void )
+{
+	// Fire smoke puffs out the side
+	CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "AntipersonnelGrenade::Effect" );
+	pSmokeEmitter->SetSortOrigin( GetAbsOrigin() );
+	int iSmokeClouds = random->RandomInt(1,2);
+	for ( int i = 0; i < iSmokeClouds; i++ )
+	{
+		SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], GetAbsOrigin() );
+		if ( pParticle == NULL )
+			return;
+
+		pParticle->m_flLifetime	= 0.0f;
+		pParticle->m_flDieTime	= random->RandomFloat( 0.1f, 0.3f );
+
+		pParticle->m_uchStartSize	= random->RandomFloat(2,5);
+		pParticle->m_uchEndSize		= pParticle->m_uchStartSize + 2;
+
+		pParticle->m_vecVelocity = vec3_origin;
+		pParticle->m_uchStartAlpha = 255;
+		pParticle->m_uchEndAlpha = 64;
+		pParticle->m_flRoll	= random->RandomFloat( 180, 360 );
+		pParticle->m_flRollDelta = random->RandomFloat( -1, 1 );
+
+		pParticle->m_uchColor[0] = 50;
+		pParticle->m_uchColor[1] = 250;
+		pParticle->m_uchColor[2] = 50;
+	}
+}
+
+
diff --git a/game/client/tf2/c_grenade_limpetmine.cpp b/game/client/tf2/c_grenade_limpetmine.cpp
new file mode 100644
index 0000000..2f9754e
--- /dev/null
+++ b/game/client/tf2/c_grenade_limpetmine.cpp
@@ -0,0 +1,109 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basegrenade_shared.h"
+#include "minimap_trace.h"
+#include "particles_simple.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Client side entity for the ferry target items
+//-----------------------------------------------------------------------------
+class C_LimpetMine : public C_BaseGrenade
+{
+	DECLARE_CLASS( C_LimpetMine, C_BaseGrenade );
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_MINIMAP_PANEL();
+
+	C_LimpetMine();
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink( void );
+
+public:
+	C_LimpetMine( const C_LimpetMine & );
+
+private:
+	bool	m_bLive;
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_LimpetMine, DT_LimpetMine, CLimpetMine)
+	RecvPropInt(RECVINFO(m_bLive)),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_LimpetMine::C_LimpetMine( void )
+{
+	CONSTRUCT_MINIMAP_PANEL( "minimap_limpet", MINIMAP_OBJECTS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_LimpetMine::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Only think when live
+	if ( m_bLive )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+	else
+	{
+		SetNextClientThink( CLIENT_THINK_NEVER );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Spawn effects if I'm live
+//-----------------------------------------------------------------------------
+void C_LimpetMine::ClientThink( void )
+{
+	if ( !InLocalTeam() )
+		return;
+
+	Vector up;
+	GetVectors( NULL, NULL, &up );
+	up *= 8.0f;
+	Vector vecOrg = GetAbsOrigin() + up;
+
+	// Make a single sprite
+	CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "C_LimpetMine::Effect" );
+	pSmokeEmitter->SetSortOrigin( vecOrg );
+	PMaterialHandle	hSphereMaterial = g_Mat_DustPuff[0];
+	SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), hSphereMaterial, vecOrg );
+	if ( pParticle == NULL )
+		return;
+
+	pParticle->m_flLifetime	= 0.0f;
+	pParticle->m_flDieTime	= 0.1f;
+	pParticle->m_uchStartSize	= RandomInt(4,6);
+	pParticle->m_uchEndSize		= pParticle->m_uchStartSize;
+	pParticle->m_vecVelocity = vec3_origin;
+	pParticle->m_uchStartAlpha = 255;
+	pParticle->m_uchEndAlpha = 255;
+	pParticle->m_flRoll	= random->RandomFloat( 180, 360 );
+	pParticle->m_flRollDelta = random->RandomFloat( -1, 1 );
+
+	if ( InLocalTeam() )
+	{
+		pParticle->m_uchColor[0] = 0;
+		pParticle->m_uchColor[1] = 255;
+		pParticle->m_uchColor[2] = 0;
+	}
+	else
+	{
+		pParticle->m_uchColor[0] = 255;
+		pParticle->m_uchColor[1] = 50;
+		pParticle->m_uchColor[2] = 50;
+	}
+}
+
+
diff --git a/game/client/tf2/c_grenade_objectsapper.cpp b/game/client/tf2/c_grenade_objectsapper.cpp
new file mode 100644
index 0000000..5b40dae
--- /dev/null
+++ b/game/client/tf2/c_grenade_objectsapper.cpp
@@ -0,0 +1,82 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "basegrenade_shared.h"
+#include "IEffects.h"
+#include "c_baseplayer.h"
+
+extern ConVar	lod_effect_distance;
+
+//-----------------------------------------------------------------------------
+// Purpose: Client side entity for the ferry target items
+//-----------------------------------------------------------------------------
+class C_GrenadeObjectSapper : public C_BaseGrenade
+{
+	DECLARE_CLASS( C_GrenadeObjectSapper, C_BaseGrenade );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_GrenadeObjectSapper();
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink( void );
+
+public:
+	C_GrenadeObjectSapper( const C_GrenadeObjectSapper & );
+
+	bool		m_bSapping;
+	float		m_flNextEffectTime;
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_GrenadeObjectSapper, DT_GrenadeObjectSapper, CGrenadeObjectSapper)
+	RecvPropInt(RECVINFO(m_bSapping)),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_GrenadeObjectSapper::C_GrenadeObjectSapper( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_GrenadeObjectSapper::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Only think when sapping
+	if ( m_bSapping )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+		m_flNextEffectTime = gpGlobals->curtime;
+	}
+	else
+	{
+		SetNextClientThink( CLIENT_THINK_NEVER );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Spawn effects if I'm sapping
+//-----------------------------------------------------------------------------
+void C_GrenadeObjectSapper::ClientThink( void )
+{
+	if ( m_flNextEffectTime < gpGlobals->curtime )
+	{
+		// Haxory LOD
+		C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+		if ( (GetAbsOrigin() - pPlayer->GetAbsOrigin()).LengthSqr() < lod_effect_distance.GetFloat() )
+		{
+			g_pEffects->Sparks( GetAbsOrigin() );
+		}
+
+		m_flNextEffectTime = gpGlobals->curtime + 0.3;
+	}
+}
diff --git a/game/client/tf2/c_grenade_rocket.cpp b/game/client/tf2/c_grenade_rocket.cpp
new file mode 100644
index 0000000..3db4497
--- /dev/null
+++ b/game/client/tf2/c_grenade_rocket.cpp
@@ -0,0 +1,83 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "particles_simple.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Client side entity for the antipersonnel grenades
+//-----------------------------------------------------------------------------
+class C_GrenadeRocket : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_GrenadeRocket, C_BaseAnimating );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_GrenadeRocket();
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink( void );
+
+public:
+	C_GrenadeRocket( const C_GrenadeRocket & );
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_GrenadeRocket, DT_GrenadeRocket, CGrenadeRocket)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_GrenadeRocket::C_GrenadeRocket( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_GrenadeRocket::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Only think when sapping
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Spawn effects if I'm sapping
+//-----------------------------------------------------------------------------
+void C_GrenadeRocket::ClientThink( void )
+{
+	// Fire smoke puffs out the side
+	CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "C_GrenadeRocket::Effect" );
+	pSmokeEmitter->SetSortOrigin( GetAbsOrigin() );
+	int iSmokeClouds = random->RandomInt(1,2);
+	for ( int i = 0; i < iSmokeClouds; i++ )
+	{
+		SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], GetAbsOrigin() );
+		if ( pParticle == NULL )
+			return;
+
+		pParticle->m_flLifetime	= 0.0f;
+		pParticle->m_flDieTime	= random->RandomFloat( 0.1f, 0.3f );
+
+		pParticle->m_uchStartSize	= 10;
+		pParticle->m_uchEndSize		= pParticle->m_uchStartSize + 2;
+
+		pParticle->m_vecVelocity = GetAbsVelocity();
+		pParticle->m_uchStartAlpha = 255;
+		pParticle->m_uchEndAlpha = 64;
+		pParticle->m_flRoll	= random->RandomFloat( 180, 360 );
+		pParticle->m_flRollDelta = random->RandomFloat( -1, 1 );
+
+		pParticle->m_uchColor[0] = 50;
+		pParticle->m_uchColor[1] = 250;
+		pParticle->m_uchColor[2] = 50;
+	}
+}
+
+
diff --git a/game/client/tf2/c_harpoon.cpp b/game/client/tf2/c_harpoon.cpp
new file mode 100644
index 0000000..1ea93e6
--- /dev/null
+++ b/game/client/tf2/c_harpoon.cpp
@@ -0,0 +1,95 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "particles_simple.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Client side entity for the harpoon
+//-----------------------------------------------------------------------------
+class C_Harpoon : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_Harpoon, C_BaseAnimating );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_Harpoon();
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pOrigin, QAngle *pAngles );
+
+public:
+	C_Harpoon( const C_Harpoon & );
+
+private:
+	// Impaling
+	Vector		m_vecOffset;
+	QAngle		m_angOffset;
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_Harpoon, DT_Harpoon, CHarpoon)
+	RecvPropVector( RECVINFO(m_vecOffset) ),
+	RecvPropVector( RECVINFO(m_angOffset) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_Harpoon::C_Harpoon( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_Harpoon::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the attachment render origin + origin
+//-----------------------------------------------------------------------------
+void C_Harpoon::GetAimEntOrigin( IClientEntity *pAttachedTo, Vector *pOrigin, QAngle *pAngles )
+{
+	C_BaseAnimating *pEnt = dynamic_cast< C_BaseAnimating * >( pAttachedTo->GetBaseEntity() );
+	if (!pEnt)
+		return;
+
+	float controllers[MAXSTUDIOBONES];
+	pEnt->GetBoneControllers(controllers);
+
+	float headcontroller = controllers[ 0 ];
+
+	// Compute angles as well, since parent uses bone controller for rotation
+
+	// Convert 0 - 1 to angles
+	float renderYaw = -180.0f + 360.0f * headcontroller;
+
+	matrix3x4_t matrix;
+
+	// Convert roll/pitch only to matrix
+	AngleMatrix( pEnt->GetAbsAngles(), matrix );
+
+	// Convert desired yaw to vector
+	QAngle anglesRotated( 0, renderYaw, 0 );
+	Vector forward;
+	AngleVectors( anglesRotated, &forward );
+
+	Vector rotatedForward;
+
+	// Rotate desired yaw vector by roll/pitch matrix
+	VectorRotate( forward, matrix, rotatedForward );
+
+	// Convert rotated vector back to orientation
+	VectorAngles( rotatedForward, *pAngles );
+	//*pAngles -= m_angOffset;
+	
+	// HACK: Until we have a proper bone solution, hack the origin for all moving objects
+	*pOrigin = pEnt->WorldSpaceCenter( );
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_hint_events.cpp b/game/client/tf2/c_hint_events.cpp
new file mode 100644
index 0000000..71b29e4
--- /dev/null
+++ b/game/client/tf2/c_hint_events.cpp
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_hint_events.h"
+#include "c_tf_hints.h"
+#include "c_tf_hintmanager.h"
+#include <KeyValues.h>
+#include "c_baseobject.h"
+
+
+void GlobalHintEvent( C_HintEvent_Base *pEvent )
+{
+	// Call the static registered functions for each hint type.
+	for ( int i=0; i < GetNumHintDatas(); i++ )
+	{
+		CHintData *pData = GetHintData( i );
+		if ( pData && pData->m_pEventFn )
+			pData->m_pEventFn( pData, pEvent );
+	}
+}
+
+
+void HintEventFn_BuildObject( CHintData *pData, C_HintEvent_Base *pEvent )
+{
+	if ( pEvent->GetType() == HINTEVENT_OBJECT_BUILT_BY_LOCAL_PLAYER )
+	{
+		C_BaseObject *pObj = ((C_HintEvent_ObjectBuiltByLocalPlayer*)pEvent)->m_pObject;
+		
+		if ( pObj->GetType() == pData->m_ObjectType )
+		{
+			// Ok, they just built the object that any hints of this type are referring to, so disable 
+			// all further hints of this type.
+			KeyValues *pkvStats = GetHintDisplayStats();
+			if ( pkvStats )
+			{
+				KeyValues *pkvStatSection = pkvStats->FindKey( pData->name, true );
+				if ( pkvStatSection )
+				{
+					pkvStatSection->SetString( "times_shown", VarArgs( "%i", 100 ) );
+				}
+			}
+		}
+	}
+}
+
diff --git a/game/client/tf2/c_hint_events.h b/game/client/tf2/c_hint_events.h
new file mode 100644
index 0000000..89dc0db
--- /dev/null
+++ b/game/client/tf2/c_hint_events.h
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_HINT_EVENTS_H
+#define C_HINT_EVENTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+class CHintData;
+
+
+typedef enum
+{
+	HINTEVENT_OBJECT_BUILT_BY_LOCAL_PLAYER=0	// C_HintEvent_ObjectBuiltByLocalPlayer
+} HintEventType;
+
+
+// All hint events derive from this.
+class C_HintEvent_Base
+{
+public:
+	// Find out what kind of event this is.
+	virtual HintEventType	GetType() = 0;
+};
+
+
+// Fire a global hint event. It goes to all hint types so they can determine if 
+// they want to react.
+void GlobalHintEvent( C_HintEvent_Base *pEvent );
+
+
+// Hint callbacks for each type of hint.
+void HintEventFn_BuildObject( CHintData *pData, C_HintEvent_Base *pEvent );
+
+
+
+// This notifies the hint system that an object has been built by the local player so
+// it can disable all further hints referring to objects of this type.
+class C_BaseObject;
+
+class C_HintEvent_ObjectBuiltByLocalPlayer : public C_HintEvent_Base
+{
+public:
+							C_HintEvent_ObjectBuiltByLocalPlayer( C_BaseObject *pObj )
+							{
+								m_pObject = pObj;
+							}
+	
+	virtual HintEventType	GetType()	{ return HINTEVENT_OBJECT_BUILT_BY_LOCAL_PLAYER; }
+
+public:
+	C_BaseObject			*m_pObject;	// The object just built.
+};
+
+
+#endif // C_HINT_EVENTS_H
diff --git a/game/client/tf2/c_info_act.cpp b/game/client/tf2/c_info_act.cpp
new file mode 100644
index 0000000..71941dc
--- /dev/null
+++ b/game/client/tf2/c_info_act.cpp
@@ -0,0 +1,196 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+#include "cbase.h"
+#include "tf_shareddefs.h"
+#include "c_info_act.h"
+#include "hud_timer.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// We may get act begin messages for acts we haven't yet received entities for (usually during connection)
+// We store the current act in this, and if an act arrives matching it, we start that act.
+static int		g_iCurrentActNumber = -1;
+static float	g_flActStartTime;
+
+CHandle<C_InfoAct>	g_hCurrentAct;
+
+IMPLEMENT_CLIENTCLASS_DT(C_InfoAct, DT_InfoAct, CInfoAct)
+	RecvPropInt( RECVINFO(m_iActNumber) ),
+	RecvPropInt( RECVINFO(m_spawnflags) ),
+	RecvPropFloat( RECVINFO(m_flActTimeLimit) ),
+	RecvPropInt(RECVINFO(m_nRespawn1Team1Time) ),
+	RecvPropInt(RECVINFO(m_nRespawn1Team2Time) ),
+	RecvPropInt(RECVINFO(m_nRespawn2Team1Time) ),
+	RecvPropInt(RECVINFO(m_nRespawn2Team2Time) ),
+	RecvPropInt(RECVINFO(m_nRespawnTeam1Delay) ),
+	RecvPropInt(RECVINFO(m_nRespawnTeam2Delay) ),
+END_RECV_TABLE()
+
+typedef CHandle<C_InfoAct>	ActHandle_t;
+CUtlVector< ActHandle_t >	g_hActs;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_InfoAct::C_InfoAct()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_InfoAct::~C_InfoAct()
+{
+	ActHandle_t hAct;
+	hAct = this;
+	g_hActs.FindAndRemove( hAct );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_InfoAct::OnPreDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnPreDataChanged( updateType );
+	m_flPreviousTimeLimit = m_flActTimeLimit;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_InfoAct::OnDataChanged( DataUpdateType_t updateType )
+{
+	ActHandle_t hAct;
+	hAct = this;
+	if ( g_hActs.Find( hAct ) == g_hActs.InvalidIndex() )
+	{
+		g_hActs.AddToTail( hAct );
+
+		// Is this act the one that's supposed to be going?
+		if ( GetActNumber() == g_iCurrentActNumber )
+		{
+			StartAct( g_flActStartTime );
+			return;
+		}
+	}
+
+	// Timer changed?
+	if ( g_hCurrentAct == this )
+	{
+		if ( m_flPreviousTimeLimit != m_flActTimeLimit )
+		{
+			CHudTimer *timer = GET_HUDELEMENT( CHudTimer );
+			if ( timer )
+			{
+				timer->SetFixedTimer( m_flStartTime, m_flActTimeLimit );
+			}
+		}
+	}
+
+	BaseClass::OnDataChanged( updateType );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_InfoAct::StartAct( float flStartTime )
+{
+	g_hCurrentAct = this;
+	m_flStartTime = flStartTime;
+
+	CHudTimer *timer = GET_HUDELEMENT( CHudTimer );
+	if ( timer )
+	{
+		timer->SetFixedTimer( m_flStartTime, m_flActTimeLimit );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_InfoAct::IsAWaitingAct( void )
+{ 
+	return (m_spawnflags & SF_ACT_WAITINGFORGAMESTART) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// PReturns the respawn time remaining
+//-----------------------------------------------------------------------------
+float C_InfoAct::RespawnTimeRemaining( int nTeam, int nTimer ) const
+{
+	if ((g_hCurrentAct != this) || (nTeam == 0))
+		return 0;
+
+	int nTimerTime;
+	float flTimeDelta = gpGlobals->curtime - m_flStartTime;
+	if (flTimeDelta <= 0)
+		return 0;
+
+	if (nTeam == 1)
+	{
+		nTimerTime = (nTimer == 1) ? m_nRespawn1Team1Time : m_nRespawn2Team1Time;
+		flTimeDelta -= m_nRespawnTeam1Delay;
+	}
+	else
+	{
+		nTimerTime = (nTimer == 1) ? m_nRespawn1Team2Time : m_nRespawn2Team2Time;
+		flTimeDelta -= m_nRespawnTeam2Delay;
+	}
+
+	if (nTimerTime <= 0)
+		return 0.0f;
+
+	// This case takes care of the initial spawn delay time...
+	if (flTimeDelta < 0)
+	{
+		return nTimerTime - flTimeDelta;
+	}
+
+	int nFactor = flTimeDelta / nTimerTime;
+	return nTimerTime - (flTimeDelta - nFactor * nTimerTime);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Server's told us to start an act
+//-----------------------------------------------------------------------------
+void StartAct( int iActNumber, float flStartTime )
+{
+	g_iCurrentActNumber = iActNumber;
+	g_flActStartTime = flStartTime;
+
+	// Find the act
+	for ( int i = 0; i < g_hActs.Size(); i++ )
+	{
+		if ( g_hActs[i] && g_hActs[i]->GetActNumber() == iActNumber )
+		{
+			g_hActs[i]->StartAct( flStartTime );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int GetCurrentActNumber( void )
+{
+	if ( g_hCurrentAct )
+		return g_hCurrentAct->GetActNumber();
+	return ACT_NONE_SPECIFIED;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the current act (if any) is a waiting act.
+//-----------------------------------------------------------------------------
+bool CurrentActIsAWaitingAct( void )
+{
+	if ( g_hCurrentAct )
+		return g_hCurrentAct->IsAWaitingAct();
+
+	return false;
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_info_act.h b/game/client/tf2/c_info_act.h
new file mode 100644
index 0000000..ad97248
--- /dev/null
+++ b/game/client/tf2/c_info_act.h
@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_INFO_ACT_H
+#define C_INFO_ACT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define ACT_NONE_SPECIFIED		-1
+
+//-----------------------------------------------------------------------------
+// Purpose: Map entity that defines an act
+//-----------------------------------------------------------------------------
+class C_InfoAct : public C_BaseEntity
+{
+	DECLARE_CLASS( C_InfoAct, C_BaseEntity );
+public:
+	C_InfoAct();
+	~C_InfoAct();
+
+	DECLARE_CLIENTCLASS();
+
+	virtual void	OnPreDataChanged( DataUpdateType_t updateType );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+
+	void	StartAct( float flStartTime );
+
+	int		GetActNumber( void ) { return m_iActNumber; }
+	bool	IsAWaitingAct( void );
+
+	float	RespawnTimeRemaining( int nTeam, int nTimer ) const;
+
+private:
+	int		m_iActNumber;
+	int		m_spawnflags;
+	float	m_flActTimeLimit;
+	int		m_nRespawn1Team1Time;
+	int		m_nRespawn1Team2Time;
+	int		m_nRespawn2Team1Time;
+	int		m_nRespawn2Team2Time;
+	int		m_nRespawnTeam1Delay;
+	int		m_nRespawnTeam2Delay;
+	float	m_flStartTime;
+	float	m_flPreviousTimeLimit;
+};
+
+extern CHandle<C_InfoAct>	g_hCurrentAct;
+void StartAct( int iActNumber, float flStartTime );
+int	 GetCurrentActNumber( void );
+bool CurrentActIsAWaitingAct( void );
+
+#endif // C_INFO_ACT_H
diff --git a/game/client/tf2/c_info_customtech.cpp b/game/client/tf2/c_info_customtech.cpp
new file mode 100644
index 0000000..d5ae027
--- /dev/null
+++ b/game/client/tf2/c_info_customtech.cpp
@@ -0,0 +1,51 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud_technologytreedoc.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_InfoCustomTechnology : public C_BaseEntity
+{
+	DECLARE_CLASS( C_InfoCustomTechnology, C_BaseEntity );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_InfoCustomTechnology( void );
+	virtual void SetDormant( bool bDormant );
+
+public:
+	// Sent via datatable
+	char		m_szTechTreeFile[128];
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_InfoCustomTechnology, DT_InfoCustomTechnology, CInfoCustomTechnology)
+	RecvPropString(RECVINFO(m_szTechTreeFile)),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_InfoCustomTechnology::C_InfoCustomTechnology( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Whenever we enter the PVS, add ourselves to the tech tree. This will
+//			only happen when the player joins a new team.
+//-----------------------------------------------------------------------------
+void C_InfoCustomTechnology::SetDormant( bool bDormant )
+{
+	if ( IsDormant() && !bDormant )
+	{
+		// Tell the techtree to add the file to it's list of technologies
+		GetTechnologyTreeDoc().AddTechnologyFile( m_szTechTreeFile );
+	}
+
+	BaseClass::SetDormant( bDormant );
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_maker_bughole.cpp b/game/client/tf2/c_maker_bughole.cpp
new file mode 100644
index 0000000..a789e05
--- /dev/null
+++ b/game/client/tf2/c_maker_bughole.cpp
@@ -0,0 +1,109 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "c_ai_basenpc.h"
+#include "IEffects.h"
+#include "particles_simple.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Client side entity for the NPC Bug hole
+//-----------------------------------------------------------------------------
+class C_Maker_Bughole : public C_BaseEntity
+{
+	DECLARE_CLASS( C_Maker_Bughole, C_BaseEntity );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_Maker_Bughole();
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink( void );
+	void			SpawnEffect( void );
+
+public:
+	C_Maker_Bughole( const C_Maker_Bughole & );
+
+	float		m_flNextEffectTime;
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_Maker_Bughole, DT_Maker_Bughole, CMaker_Bughole)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_Maker_Bughole::C_Maker_Bughole( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_Maker_Bughole::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+		m_flNextEffectTime = gpGlobals->curtime;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Spawn effects if I'm sapping
+//-----------------------------------------------------------------------------
+void C_Maker_Bughole::ClientThink( void )
+{
+	if ( m_flNextEffectTime < gpGlobals->curtime )
+	{
+		SpawnEffect();
+		m_flNextEffectTime = gpGlobals->curtime + random->RandomFloat( 0.5, 1.0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Particle effects created when we spawn a chunk
+//-----------------------------------------------------------------------------
+void C_Maker_Bughole::SpawnEffect( void )
+{
+	Vector normal = Vector(0,0,-1);
+	Vector offset = GetAbsOrigin() + (normal * 16);
+	Vector dir;
+
+	// Create a couple of big, floating smoke clouds
+	CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "C_Maker_Bughole::SpawnEffect" );
+	pSmokeEmitter->SetSortOrigin( offset );
+	int iSmokeClouds = random->RandomInt(2,5);
+	for ( int i = 0; i < iSmokeClouds; i++ )
+	{
+		SimpleParticle *pParticle = (SimpleParticle *) pSmokeEmitter->AddParticle( sizeof(SimpleParticle), g_Mat_DustPuff[1], offset );
+		if ( pParticle == NULL )
+			return;
+
+		pParticle->m_flLifetime	= 0.0f;
+		pParticle->m_flDieTime	= random->RandomFloat( 2.0f, 3.0f );
+
+		pParticle->m_uchStartSize	= 8;
+		pParticle->m_uchEndSize		= 48;
+
+		dir[0] = normal[0] + random->RandomFloat( -0.4f, 0.4f );
+		dir[1] = normal[1] + random->RandomFloat( -0.4f, 0.4f );
+		dir[2] = normal[2] + random->RandomFloat( 0, 0.6f );
+		pParticle->m_vecVelocity = dir * random->RandomFloat( 8.0f, 20.0f )*(i+1);
+		pParticle->m_uchStartAlpha	= 255;
+		pParticle->m_uchEndAlpha	= 0;
+		pParticle->m_flRoll			= random->RandomFloat( 180, 360 );
+		pParticle->m_flRollDelta	= random->RandomFloat( -1, 1 );
+
+		float flColor = random->RandomFloat( 0,64 );
+		pParticle->m_uchColor[0] = 100 + flColor;
+		pParticle->m_uchColor[1] = 50 + flColor;
+		pParticle->m_uchColor[2] = flColor;
+	}
+}
diff --git a/game/client/tf2/c_obj_barbed_wire.cpp b/game/client/tf2/c_obj_barbed_wire.cpp
new file mode 100644
index 0000000..fdf74bd
--- /dev/null
+++ b/game/client/tf2/c_obj_barbed_wire.cpp
@@ -0,0 +1,110 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_obj_barbed_wire.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjectBarbedWire, DT_ObjectBarbedWire, CObjectBarbedWire )
+	RecvPropEHandle( RECVINFO( m_hConnectedTo ) )
+END_RECV_TABLE()
+
+
+ConVar obj_barbed_wire_hang_dist( "obj_barbed_wire_hang_dist", "20" );
+
+
+C_ObjectBarbedWire::C_ObjectBarbedWire()
+{
+	m_vLastConnectedOrigin.Init( -999999999, -999999999, -999999999 );
+	m_vLastOrigin = m_vLastConnectedOrigin;
+}
+
+
+C_ObjectBarbedWire::~C_ObjectBarbedWire()
+{
+	// Get rid of our rope if necessary.
+	if ( m_hRope )
+	{
+		m_hRope->Release();
+	}
+}
+
+
+void C_ObjectBarbedWire::OnDataChanged( DataUpdateType_t type )
+{
+	if ( m_hConnectedTo != m_hLastConnectedTo )
+	{
+		m_hLastConnectedTo = m_hConnectedTo;
+
+		// Get rid of any old rope we had.
+		int iAttachment = LookupAttachment( "wire_attachment" );
+		
+		// Create or delete our rope?
+		if ( m_hConnectedTo )
+		{
+			if ( !m_hRope )
+			{
+
+				m_hRope = C_RopeKeyframe::Create(
+					this,
+					m_hConnectedTo,
+					iAttachment,
+					iAttachment,
+					3,
+					"sprites/physbeam"
+					);
+			}
+		}
+		else
+		{
+			if ( m_hRope )
+			{
+				m_hRope->Release();
+				m_hRope = NULL;
+			}
+		}
+
+		// Update rope parameters.
+		if ( m_hRope )
+		{
+			int r, g, b, a;
+			CMapTeamColors *team = &MapData().m_TeamColors[ GetTeamNumber() ];
+			team->m_clrTeam.GetColor( r, g, b, a );
+			m_hRope->SetColorMod( Vector( r / 255.0f, g / 255.0f, b / 255.0f ) );
+
+			m_hRope->SetEndEntity( m_hConnectedTo );
+			m_hRope->SetRopeFlags( ROPE_SIMULATE | ROPE_BARBED );
+		}
+	}
+
+	BaseClass::OnDataChanged( type );
+}
+
+
+void C_ObjectBarbedWire::Spawn()
+{
+}
+
+
+void C_ObjectBarbedWire::ClientThink()
+{
+	if ( m_hConnectedTo && m_hRope )
+	{
+		if ( m_vLastOrigin != GetAbsOrigin() || m_vLastConnectedOrigin != m_hConnectedTo->GetAbsOrigin() )
+		{
+			m_hRope->SetupHangDistance( obj_barbed_wire_hang_dist.GetFloat() );
+			
+			m_vLastOrigin = GetAbsOrigin();
+			m_vLastConnectedOrigin = m_hConnectedTo->GetAbsOrigin();
+		}
+	}
+	
+	SetNextClientThink( gpGlobals->curtime + 0.1f );
+}
+
+
+
+
diff --git a/game/client/tf2/c_obj_barbed_wire.h b/game/client/tf2/c_obj_barbed_wire.h
new file mode 100644
index 0000000..b242640
--- /dev/null
+++ b/game/client/tf2/c_obj_barbed_wire.h
@@ -0,0 +1,46 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_OBJ_BARBED_WIRE_H
+#define C_OBJ_BARBED_WIRE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_baseobject.h"
+#include "c_rope.h"
+
+
+class C_ObjectBarbedWire : public C_BaseObject
+{
+public:
+	DECLARE_CLASS( C_ObjectBarbedWire, C_BaseObject );
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectBarbedWire();
+	~C_ObjectBarbedWire();
+
+	virtual void OnDataChanged( DataUpdateType_t type );
+
+	virtual void Spawn();
+	virtual void ClientThink();
+
+
+private:
+	C_ObjectBarbedWire( C_ObjectBarbedWire& ) {}
+
+	CHandle<C_ObjectBarbedWire> m_hConnectedTo;
+	CHandle<C_ObjectBarbedWire> m_hLastConnectedTo;
+	CHandle<C_RopeKeyframe> m_hRope;
+
+	// Used to determine when to recalculate the hang distance.
+	Vector m_vLastOrigin;
+	Vector m_vLastConnectedOrigin;
+};
+
+
+#endif // C_OBJ_BARBED_WIRE_H
diff --git a/game/client/tf2/c_obj_base_manned_gun.cpp b/game/client/tf2/c_obj_base_manned_gun.cpp
new file mode 100644
index 0000000..b7d7582
--- /dev/null
+++ b/game/client/tf2/c_obj_base_manned_gun.cpp
@@ -0,0 +1,122 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_obj_base_manned_gun.h"
+#include "hudelement.h"
+#include "tf_movedata.h"
+#include "bone_setup.h"
+#include "hud_ammo.h"
+#include "vgui_bitmapbutton.h"
+
+extern ConVar mannedgun_usethirdperson;
+
+//=================================================================================================
+// Control Screen
+//=================================================================================================
+
+DECLARE_VGUI_SCREEN_FACTORY( CMannedPlasmagunControlPanel, "manned_plasmagun_control_panel" );
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CMannedPlasmagunControlPanel::CMannedPlasmagunControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CMannedPlasmagunControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CMannedPlasmagunControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pMannedLabel = new vgui::Label( this, "MannedReadout", "" );
+	m_pOccupyButton = new CBitmapButton( this, "OccupyButton", "Occupy" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CMannedPlasmagunControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_ObjectBaseMannedGun*>(pObj) );
+	C_ObjectBaseMannedGun *pGun = static_cast<C_ObjectBaseMannedGun*>(pObj);
+
+	char buf[256];
+	// Update the currently manned player label
+	if ( pGun->GetDriverPlayer() )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Manned by %s", pGun->GetDriverPlayer()->GetPlayerName() );
+		m_pMannedLabel->SetText( buf );
+		m_pMannedLabel->SetVisible( true );
+	}
+	else
+	{
+		m_pMannedLabel->SetVisible( false );
+	}
+
+	// Update the get in button
+	if ( pGun->GetDriverPlayer() )
+	{
+		// Owners can boot other players to get in
+		if ( pGun->GetOwner() == C_BaseTFPlayer::GetLocalPlayer() && C_BaseTFPlayer::GetLocalPlayer() != pGun->GetDriverPlayer() )
+		{
+			Q_snprintf( buf, sizeof( buf ), "Get In (Ejecting %s)", pGun->GetDriverPlayer()->GetPlayerName() );
+			m_pMannedLabel->SetText( buf );
+			m_pOccupyButton->SetEnabled( true );
+		}
+		else
+		{
+			// Disable the button
+			m_pOccupyButton->SetEnabled( false );
+		}
+	}
+	else
+	{
+		m_pOccupyButton->SetText( "Get In" );
+		m_pOccupyButton->SetEnabled( true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Occupy button
+//-----------------------------------------------------------------------------
+void CMannedPlasmagunControlPanel::GetInGun( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "toggle_use" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CMannedPlasmagunControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Occupy", 7))
+	{
+		GetInGun();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_obj_base_manned_gun.h b/game/client/tf2/c_obj_base_manned_gun.h
new file mode 100644
index 0000000..94b2c74
--- /dev/null
+++ b/game/client/tf2/c_obj_base_manned_gun.h
@@ -0,0 +1,39 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_OBJ_BASE_MANNED_GUN_H
+#define C_OBJ_BASE_MANNED_GUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfvehicle.h"
+#include "tf_obj_manned_plasmagun_shared.h"
+#include "ObjectControlPanel.h"
+#include "tf_obj_base_manned_gun.h"
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CMannedPlasmagunControlPanel : public CRotatingObjectControlPanel
+{
+	DECLARE_CLASS( CMannedPlasmagunControlPanel, CRotatingObjectControlPanel );
+
+public:
+	CMannedPlasmagunControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+	void GetInGun( void );
+
+private:
+	vgui::Label		*m_pMannedLabel;
+	vgui::Button	*m_pOccupyButton;
+};
+
+#endif // C_OBJ_BASE_MANNED_GUN_H
diff --git a/game/client/tf2/c_obj_buff_station.cpp b/game/client/tf2/c_obj_buff_station.cpp
new file mode 100644
index 0000000..350862a
--- /dev/null
+++ b/game/client/tf2/c_obj_buff_station.cpp
@@ -0,0 +1,272 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The client-side version of the portable power generator
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_baseobject.h"
+#include "tf_shareddefs.h"
+#include "C_BaseTFPlayer.h"
+#include "ObjectControlPanel.h"
+#include "vgui_bitmapbutton.h"
+	    
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//=============================================================================
+//
+// Portable Power Generator Class
+//
+class C_ObjectBuffStation : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectBuffStation, C_BaseObject );
+
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectBuffStation( void );
+
+	virtual void	Release( void );
+	virtual void	OnPreDataChanged( DataUpdateType_t updateType );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+
+	// Since we have material proxies to show building amount, don't offset origin
+	virtual bool	OffsetObjectOrigin( Vector& origin )
+	{
+		return false;
+	}
+
+	int PlayerSocketsLeft() const { return ( BUFF_STATION_MAX_PLAYERS - m_nPlayerCount ); }
+	int ObjectSocketsLeft() const { return ( BUFF_STATION_MAX_OBJECTS - m_nObjectCount ); }
+
+	// Check if the local player is attached
+	bool IsLocalPlayerAttached( void );
+
+private:
+	typedef CHandle<C_BaseTFPlayer> CPlayerHandle;
+	int				m_nPlayerCount;					
+	CPlayerHandle	m_hPlayers[BUFF_STATION_MAX_PLAYERS];
+	CPlayerHandle	m_hOldPlayers[BUFF_STATION_MAX_PLAYERS];
+
+	typedef CHandle<C_BaseObject> CObjectHandle;
+	int				m_nObjectCount;
+	CObjectHandle	m_hObjects[BUFF_STATION_MAX_OBJECTS];
+
+private:
+	C_ObjectBuffStation( const C_ObjectBuffStation & ); // not defined, not accessible
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjectBuffStation, DT_ObjectBuffStation, CObjectBuffStation )
+	RecvPropInt( RECVINFO( m_nPlayerCount ) ),
+	RecvPropArray( RecvPropEHandle( RECVINFO( m_hPlayers[0]) ), m_hPlayers ),
+	RecvPropInt( RECVINFO( m_nObjectCount ) ),
+	RecvPropArray( RecvPropEHandle( RECVINFO( m_hObjects[0]) ), m_hObjects ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectBuffStation::C_ObjectBuffStation( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check if the local player is attached
+//-----------------------------------------------------------------------------
+bool C_ObjectBuffStation::IsLocalPlayerAttached( void )
+{
+	C_BaseTFPlayer *pLocalPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	for ( int iPlayer = 0; iPlayer < m_nPlayerCount; ++iPlayer )
+	{
+		if ( m_hPlayers[iPlayer].Get() == pLocalPlayer )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectBuffStation::Release( void )
+{
+	// Remove any sounds for players attached
+	for ( int i = 0; i < BUFF_STATION_MAX_PLAYERS; i++ )
+	{
+		if ( m_hPlayers[i] )
+		{
+			// Stop the startup, in case it's still going
+			StopSound( m_hPlayers[i]->entindex(), "ObjectPortablePowerGenerator.Startup" );
+
+			// Start the shutdown sound
+			CPASAttenuationFilter filter( m_hPlayers[i], "ObjectPortablePowerGenerator.Shutdown" );
+			EmitSound( filter, m_hPlayers[i]->entindex(), "ObjectPortablePowerGenerator.Shutdown" );
+		}
+	}
+
+	BaseClass::Release();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectBuffStation::OnPreDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnPreDataChanged( updateType );
+
+	for ( int i = 0; i < BUFF_STATION_MAX_PLAYERS; i++ )
+	{
+		m_hOldPlayers[i] = m_hPlayers[i];
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectBuffStation::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Did a player connect / disconnect?
+	for ( int i = 0; i < BUFF_STATION_MAX_PLAYERS; i++ )
+	{
+		// Something's changed
+		if ( m_hOldPlayers[i] != m_hPlayers[i] )
+		{
+			// Disconnected?
+			if ( m_hOldPlayers[i] )
+			{
+				// Stop the startup, in case it's still going
+				StopSound( m_hOldPlayers[i]->entindex(), "ObjectPortablePowerGenerator.Startup" );
+
+				// Start the shutdown sound
+				CPASAttenuationFilter filter( m_hOldPlayers[i], "ObjectPortablePowerGenerator.Shutdown" );
+				EmitSound( filter, m_hOldPlayers[i]->entindex(), "ObjectPortablePowerGenerator.Shutdown" );
+			}
+
+			if ( m_hPlayers[i] )
+			{
+				// Start "buff" sound.
+				CPASAttenuationFilter filter( m_hPlayers[i], "ObjectPortablePowerGenerator.Startup" );
+				EmitSound( filter, m_hPlayers[i]->entindex(), "ObjectPortablePowerGenerator.Startup" );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CBuffStationControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CBuffStationControlPanel, CObjectControlPanel );
+
+public:
+
+	CBuffStationControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+	void ConnectToStation( void );
+
+private:
+	vgui::Label		*m_pSocketsLabel;
+	vgui::Button	*m_pConnectButton;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CBuffStationControlPanel, "buffstation_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CBuffStationControlPanel::CBuffStationControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CBuffStationControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CBuffStationControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pSocketsLabel = new vgui::Label( this, "SocketReadout", "" );
+	m_pConnectButton = new CBitmapButton( this, "ConnectButton", "Connect" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CBuffStationControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_ObjectBuffStation*>(pObj) );
+	C_ObjectBuffStation *pStation = static_cast<C_ObjectBuffStation*>(pObj);
+
+	char buf[256];
+	int nSocketsLeft = pStation->PlayerSocketsLeft();
+	if (nSocketsLeft > 0)
+	{
+		Q_snprintf( buf, sizeof( buf ), "%d sockets left", pStation->PlayerSocketsLeft() );
+	}
+	else
+	{
+		Q_strncpy( buf, "No sockets left", sizeof( buf ) );
+	}
+
+	m_pSocketsLabel->SetText( buf );
+
+	// Make sure the connect/disconnect button is correct
+	if ( pStation->IsLocalPlayerAttached() )
+	{
+		m_pConnectButton->SetText( "Disconnect from Station" );
+	}
+	else
+	{
+		m_pConnectButton->SetText( "Connect To Station" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Connect/Disconnect button
+//-----------------------------------------------------------------------------
+void CBuffStationControlPanel::ConnectToStation( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "toggle_connect" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CBuffStationControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Connect", 7))
+	{
+		ConnectToStation();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_obj_bunker.cpp b/game/client/tf2/c_obj_bunker.cpp
new file mode 100644
index 0000000..bc590a1
--- /dev/null
+++ b/game/client/tf2/c_obj_bunker.cpp
@@ -0,0 +1,70 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "commanderoverlay.h"
+#include "c_baseobject.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectBunker : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectBunker, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectBunker();
+
+private:
+	C_ObjectBunker( const C_ObjectBunker & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectBunker, DT_ObjectBunker, CObjectBunker)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectBunker::C_ObjectBunker()
+{
+}
+
+
+//=============================================================================
+// Bunker Ladder
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectBunkerLadder : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_ObjectBunkerLadder, C_BaseAnimating );
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectBunkerLadder();
+
+private:
+	C_ObjectBunkerLadder( const C_ObjectBunkerLadder& ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjectBunkerLadder, DT_ObjectBunkerLadder, CObjectBunkerLadder )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_ObjectBunkerLadder::C_ObjectBunkerLadder()
+{
+}
+
diff --git a/game/client/tf2/c_obj_dragonsteeth.cpp b/game/client/tf2/c_obj_dragonsteeth.cpp
new file mode 100644
index 0000000..3f690bf
--- /dev/null
+++ b/game/client/tf2/c_obj_dragonsteeth.cpp
@@ -0,0 +1,44 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "commanderoverlay.h"
+#include "c_baseobject.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectDragonsTeeth : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectDragonsTeeth, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectDragonsTeeth();
+
+	// Since we have material proxies to show building amount, don't offset origin
+	virtual bool	OffsetObjectOrigin( Vector& origin )
+	{
+		return false;
+	}
+
+private:
+	C_ObjectDragonsTeeth( const C_ObjectDragonsTeeth & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectDragonsTeeth, DT_ObjectDragonsTeeth, CObjectDragonsTeeth)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectDragonsTeeth::C_ObjectDragonsTeeth()
+{
+}
diff --git a/game/client/tf2/c_obj_empgenerator.cpp b/game/client/tf2/c_obj_empgenerator.cpp
new file mode 100644
index 0000000..2782bc4
--- /dev/null
+++ b/game/client/tf2/c_obj_empgenerator.cpp
@@ -0,0 +1,99 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "c_baseobject.h"
+#include "particles_simple.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectEMPGenerator : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectEMPGenerator, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectEMPGenerator();
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink( void );
+
+private:
+	CSmartPtr<CSimpleEmitter>	m_pEmitter;
+	PMaterialHandle				m_hParticleMaterial;
+	TimedEvent					m_ParticleEvent;
+
+private:
+	C_ObjectEMPGenerator( const C_ObjectEMPGenerator & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectEMPGenerator, DT_ObjectEMPGenerator, CObjectEMPGenerator)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectEMPGenerator::C_ObjectEMPGenerator()
+{
+	m_ParticleEvent.Init( 300 ); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectEMPGenerator::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		m_pEmitter = CSimpleEmitter::Create( "C_ObjectEMPGenerator" );
+		m_hParticleMaterial = m_pEmitter->GetPMaterial( "sprites/chargeball" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectEMPGenerator::ClientThink( void )
+{
+	// Add particles at the target.
+	float flCur = gpGlobals->frametime;
+	while ( m_ParticleEvent.NextEvent( flCur ) )
+	{
+		Vector vPos = WorldSpaceCenter( );
+		Vector vOffset = RandomVector( -1, 1 );
+		VectorNormalize( vOffset );
+		vPos += vOffset * RandomFloat( 0, 50 );
+		
+		SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
+		if ( pParticle )
+		{
+			// Move the points along the path.
+			pParticle->m_vecVelocity.Init();
+			pParticle->m_flRoll = 0;
+			pParticle->m_flRollDelta = 0;
+			pParticle->m_flDieTime = 0.4f;
+			pParticle->m_flLifetime = 0;
+			pParticle->m_uchColor[0] = 255; 
+			pParticle->m_uchColor[1] = 255;
+			pParticle->m_uchColor[2] = 255;
+			pParticle->m_uchStartAlpha = 32;
+			pParticle->m_uchEndAlpha = 0;
+			pParticle->m_uchStartSize = 6;
+			pParticle->m_uchEndSize = 4;
+			pParticle->m_iFlags = 0;
+		}
+	}
+}
+
+
+
+
+
diff --git a/game/client/tf2/c_obj_explosives.cpp b/game/client/tf2/c_obj_explosives.cpp
new file mode 100644
index 0000000..ed32caf
--- /dev/null
+++ b/game/client/tf2/c_obj_explosives.cpp
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "commanderoverlay.h"
+#include "tf_obj_baseupgrade_shared.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectExplosives : public C_BaseObjectUpgrade
+{
+	DECLARE_CLASS( C_ObjectExplosives, C_BaseObjectUpgrade );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectExplosives();
+
+private:
+	C_ObjectExplosives( const C_ObjectExplosives & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectExplosives, DT_ObjectExplosives, CObjectExplosives)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectExplosives::C_ObjectExplosives()
+{
+}
+
diff --git a/game/client/tf2/c_obj_manned_missilelauncher.cpp b/game/client/tf2/c_obj_manned_missilelauncher.cpp
new file mode 100644
index 0000000..d1f67ad
--- /dev/null
+++ b/game/client/tf2/c_obj_manned_missilelauncher.cpp
@@ -0,0 +1,28 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_obj_base_manned_gun.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectMannedMissileLauncher : public C_ObjectBaseMannedGun
+{
+	DECLARE_CLASS( C_ObjectMannedMissileLauncher, C_ObjectBaseMannedGun );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectMannedMissileLauncher() {}
+
+private:
+	C_ObjectMannedMissileLauncher( const C_ObjectMannedMissileLauncher & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectMannedMissileLauncher, DT_ObjectMannedMissileLauncher, CObjectMannedMissileLauncher)
+END_RECV_TABLE()
+
diff --git a/game/client/tf2/c_obj_manned_plasmagun.cpp b/game/client/tf2/c_obj_manned_plasmagun.cpp
new file mode 100644
index 0000000..0603671
--- /dev/null
+++ b/game/client/tf2/c_obj_manned_plasmagun.cpp
@@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_obj_base_manned_gun.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectMannedPlasmagun : public C_ObjectBaseMannedGun
+{
+	DECLARE_CLASS( C_ObjectMannedPlasmagun, C_ObjectBaseMannedGun );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectMannedPlasmagun() {}
+
+private:
+	C_ObjectMannedPlasmagun( const C_ObjectMannedPlasmagun & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectMannedPlasmagun, DT_ObjectMannedPlasmagun, CObjectMannedPlasmagun)
+END_RECV_TABLE()
+
diff --git a/game/client/tf2/c_obj_manned_shield.cpp b/game/client/tf2/c_obj_manned_shield.cpp
new file mode 100644
index 0000000..61dd995
--- /dev/null
+++ b/game/client/tf2/c_obj_manned_shield.cpp
@@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_obj_base_manned_gun.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectMannedShield : public C_ObjectBaseMannedGun
+{
+	DECLARE_CLASS( C_ObjectMannedShield, C_ObjectBaseMannedGun );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectMannedShield() {}
+
+private:
+	C_ObjectMannedShield( const C_ObjectMannedShield & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjectMannedShield, DT_ObjectMannedShield, CObjectMannedShield )
+END_RECV_TABLE()
diff --git a/game/client/tf2/c_obj_mapdefined.cpp b/game/client/tf2/c_obj_mapdefined.cpp
new file mode 100644
index 0000000..8cd5ce9
--- /dev/null
+++ b/game/client/tf2/c_obj_mapdefined.cpp
@@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "tf_shareddefs.h"
+#include "c_obj_mapdefined.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectMapDefined, DT_ObjectMapDefined, CObjectMapDefined)
+	RecvPropString( RECVINFO(m_szCustomName) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectMapDefined::C_ObjectMapDefined()
+{
+	memset( m_szCustomName, 0, sizeof(m_szCustomName) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a text description for the object target
+//-----------------------------------------------------------------------------
+const char *C_ObjectMapDefined::GetTargetDescription( void ) const
+{
+	if ( m_szCustomName && m_szCustomName[0] )
+		return m_szCustomName;
+
+	return BaseClass::GetTargetDescription();
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_obj_mapdefined.h b/game/client/tf2/c_obj_mapdefined.h
new file mode 100644
index 0000000..610f1d9
--- /dev/null
+++ b/game/client/tf2/c_obj_mapdefined.h
@@ -0,0 +1,35 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_OBJ_MAPDEFINED_H
+#define C_OBJ_MAPDEFINED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_baseobject.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectMapDefined : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectMapDefined, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectMapDefined();
+
+	virtual const char	*GetTargetDescription( void ) const;
+
+private:
+	C_ObjectMapDefined( const C_ObjectMapDefined & ); // not defined, not accessible
+
+	char	m_szCustomName[ MAX_OBJ_CUSTOMNAME_SIZE ];
+};
+
+#endif // C_OBJ_MAPDEFINED_H
diff --git a/game/client/tf2/c_obj_mcv_selection_panel.cpp b/game/client/tf2/c_obj_mcv_selection_panel.cpp
new file mode 100644
index 0000000..1e57f0b
--- /dev/null
+++ b/game/client/tf2/c_obj_mcv_selection_panel.cpp
@@ -0,0 +1,279 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_baseobject.h"
+#include "ObjectControlPanel.h"
+#include "hud_minimap.h"
+#include "vgui_bitmapimage.h"
+#include "c_vehicle_teleport_station.h"
+#include <vgui/MouseCode.h>
+
+
+class C_ObjMCVSelectionPanel;
+CUtlLinkedList<C_ObjMCVSelectionPanel*,int> g_SelectionPanels;
+
+
+// ------------------------------------------------------------------------------------------------ //
+// C_ObjMCVSelectionPanel
+// ------------------------------------------------------------------------------------------------ //
+
+class C_ObjMCVSelectionPanel : public C_BaseObject
+{
+public:
+	
+	DECLARE_CLASS( C_ObjMCVSelectionPanel, C_BaseObject );
+	DECLARE_CLIENTCLASS();
+
+	C_ObjMCVSelectionPanel();
+	~C_ObjMCVSelectionPanel();
+
+	typedef CHandle<C_VehicleTeleportStation> VehicleTeleportStationHandle;
+	CUtlVector<VehicleTeleportStationHandle> m_DeployedTeleportStations;
+	
+
+private:
+	static C_ObjMCVSelectionPanel *s_pSelectionPanel;
+
+	friend void RecvProxy_TeleportStationCount( void *pStruct, int objectID, int currentArrayLength );
+	friend void RecvProxy_TeleportStationElement( const CRecvProxyData *pData, void *pStruct, void *pOut );
+
+	C_ObjMCVSelectionPanel( const C_ObjMCVSelectionPanel & );
+};
+
+
+void RecvProxy_TeleportStationCount( void *pStruct, int objectID, int currentArrayLength )
+{
+	C_ObjMCVSelectionPanel *pPanel = (C_ObjMCVSelectionPanel*)pStruct;
+	if ( pPanel->m_DeployedTeleportStations.Count() != currentArrayLength )
+	{
+		pPanel->m_DeployedTeleportStations.SetSize( currentArrayLength );
+	}
+}
+
+
+void RecvProxy_TeleportStationElement( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	C_ObjMCVSelectionPanel *pPanel = (C_ObjMCVSelectionPanel*)pStruct;
+
+	Assert( pData->m_iElement < pPanel->m_DeployedTeleportStations.Count() );
+	
+	RecvProxy_IntToEHandle( pData, pStruct, &pPanel->m_DeployedTeleportStations[pData->m_iElement] );
+}
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjMCVSelectionPanel, DT_MCVSelectionPanel, CObjMCVSelectionPanel )
+	RecvPropVirtualArray( 
+		RecvProxy_TeleportStationCount,
+		32,
+		RecvPropEHandle( "teleport_station_element", 0, 0, RecvProxy_TeleportStationElement ),
+		"teleport_stations" )
+END_RECV_TABLE()
+
+
+C_ObjMCVSelectionPanel::C_ObjMCVSelectionPanel()
+{
+	g_SelectionPanels.AddToTail( this );
+}
+
+C_ObjMCVSelectionPanel::~C_ObjMCVSelectionPanel()
+{
+	g_SelectionPanels.FindAndRemove( this );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// CMCVMinimapPanel
+//-----------------------------------------------------------------------------
+
+class CMCVMinimapPanel : public CMinimapPanel
+{
+public:
+
+	DECLARE_CLASS( CMCVMinimapPanel, CMinimapPanel );
+
+	CMCVMinimapPanel( vgui::Panel *pParent, const char *pElementName );
+	virtual ~CMCVMinimapPanel();
+
+	virtual void Paint();
+	virtual void OnMousePressed( vgui::MouseCode code );
+	virtual void OnCursorMoved( int x, int y );
+
+
+private:
+	BitmapImage m_MCVImage;
+	BitmapImage m_SelectedMCVImage;
+	int m_LastX, m_LastY;		   
+};
+
+
+CMCVMinimapPanel::CMCVMinimapPanel( vgui::Panel *pParent, const char *pElementName )
+	: CMinimapPanel( pElementName )
+{
+	SetParent( pParent );
+	m_MCVImage.Init( GetVPanel(), "hud/minimap/icon_mcv_unselected" );
+	m_SelectedMCVImage.Init( GetVPanel(), "hud/minimap/icon_mcv_selected" );
+	m_LastX = m_LastY = 0;
+}
+
+
+CMCVMinimapPanel::~CMCVMinimapPanel()
+{
+}
+
+
+void CMCVMinimapPanel::Paint()
+{
+	// Draw the minimap.
+	BaseClass::Paint();
+
+	// Now draw the MCVs.
+	if ( g_SelectionPanels.Count() > 0 )
+	{
+		C_ObjMCVSelectionPanel *pPanel = g_SelectionPanels[ g_SelectionPanels.Head() ];
+		C_BaseEntity *pSelectedMCV = C_BaseTFPlayer::GetLocalPlayer()->GetSelectedMCV();
+
+		for ( int i=0; i < pPanel->m_DeployedTeleportStations.Count(); i++ )
+		{
+			C_VehicleTeleportStation *pStation = pPanel->m_DeployedTeleportStations[i];
+			if ( pStation )
+			{
+				float x, y;
+				if ( WorldToMinimap( MINIMAP_CLAMP, pStation->GetAbsOrigin(), x, y ) )
+				{
+					int size = 20;
+					
+					if ( pStation == pSelectedMCV )
+						m_SelectedMCVImage.DoPaint( x-size/2, y-size/2, size, size );
+					else
+						m_MCVImage.DoPaint( x-size/2, y-size/2, size, size );
+				}				
+			}
+		}
+	}
+}
+
+
+
+void CMCVMinimapPanel::OnMousePressed( vgui::MouseCode code )
+{
+	BaseClass::OnMousePressed( code );
+
+	if ( code != vgui::MOUSE_LEFT )
+		return;
+	
+	// Now draw the MCVs.
+	if ( g_SelectionPanels.Count() > 0 )
+	{
+		C_ObjMCVSelectionPanel *pPanel = g_SelectionPanels[ g_SelectionPanels.Head() ];
+		
+		// Find the closest MCV to their mouse press.
+		int iClosest = -1;
+		float flClosest = 1e24;
+		Vector2D curMousePos( m_LastX, m_LastY );
+
+		for ( int i=0; i < pPanel->m_DeployedTeleportStations.Count(); i++ )
+		{
+			C_VehicleTeleportStation *pStation = pPanel->m_DeployedTeleportStations[i];
+			if ( pStation )
+			{
+				Vector2D mcvPos;
+				if ( WorldToMinimap( MINIMAP_CLAMP, pStation->GetAbsOrigin(), mcvPos.x, mcvPos.y ) )
+				{
+					float flTestDist = mcvPos.DistTo( curMousePos );
+					if ( flTestDist < flClosest )
+					{
+						flClosest = flTestDist;
+						iClosest = i;
+					}
+				}
+			}
+		}
+
+		if ( iClosest != -1 && flClosest < 10 )
+		{
+			C_VehicleTeleportStation *pClosest = pPanel->m_DeployedTeleportStations[iClosest];
+
+			char str[512];
+			Q_snprintf( str, sizeof( str ), "SelectMCV %d", pClosest->entindex() );
+			pPanel->SendClientCommand( str );
+		}
+	}				
+}
+
+
+void CMCVMinimapPanel::OnCursorMoved( int x, int y )
+{
+	BaseClass::OnCursorMoved( x, y );
+
+	m_LastX = x;
+	m_LastY = y;
+}
+
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CMCVSelectionPanel
+// ------------------------------------------------------------------------------------------------ //
+
+class CMCVSelectionPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CMCVSelectionPanel, CObjectControlPanel );
+
+
+public:
+	
+	CMCVSelectionPanel( vgui::Panel *parent, const char *panelName );
+	virtual ~CMCVSelectionPanel();
+	
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnCommand( const char *command );
+
+
+private:
+
+	CMCVMinimapPanel *m_pMinimapPanel;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CMCVSelectionPanel, "mcv_selection_panel" );
+
+
+CMCVSelectionPanel::CMCVSelectionPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CMCVSelectionPanel" )
+{
+	m_pMinimapPanel = new CMCVMinimapPanel( this, "MinimapPanel" );
+	m_pMinimapPanel->SetZPos( 10 );
+	m_pMinimapPanel->Init( NULL );
+}
+
+
+CMCVSelectionPanel::~CMCVSelectionPanel()
+{
+	delete m_pMinimapPanel;
+}
+
+ 
+bool CMCVSelectionPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	if ( !BaseClass::Init( pKeyValues, pInitData ) )
+		return false;
+	
+	m_pMinimapPanel->LevelInit( engine->GetLevelName() );
+	m_pMinimapPanel->SetVisible( true );
+
+	return true;
+}
+
+
+void CMCVSelectionPanel::OnCommand( const char *command )
+{
+	BaseClass::OnCommand( command );
+}
+
+
+
diff --git a/game/client/tf2/c_obj_mortar.cpp b/game/client/tf2/c_obj_mortar.cpp
new file mode 100644
index 0000000..ea4e79b
--- /dev/null
+++ b/game/client/tf2/c_obj_mortar.cpp
@@ -0,0 +1,389 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client version of CObjectMortar
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "CommanderOverlay.h"
+#include "c_baseobject.h"
+#include "tf_shareddefs.h"
+#include "c_basetfplayer.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+#include "vgui_rotation_slider.h"
+#include <vgui/ISurface.h>
+#include "vgui_basepanel.h"
+#include "vgui_bitmapimage.h"
+#include "iusesmortarpanel.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectMortar : public C_BaseObject, public IUsesMortarPanel
+{
+	DECLARE_CLASS( C_ObjectMortar, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+
+	C_ObjectMortar();
+
+	virtual void SetDormant( bool bDormant );
+	virtual void Select( void );
+	virtual void RecalculateIDString( void );
+	
+	void		 FireMortar( void );
+
+// IUsesMortarPanel
+public:
+	// Get the data from this mortar needed by the panel
+	virtual void	GetMortarData( float *flClientMortarYaw, bool *bAllowedToFire, float *flPower, float *flFiringPower, float *flFiringAccuracy, int *iFiringState );
+	virtual void	SendYawCommand( void );
+	virtual void	ForceClientYawCountdown( float flTime );
+	virtual void	ClickFire( void );
+
+public:
+	int		m_iRoundType;
+	int		m_iMortarRounds[ MA_LASTAMMOTYPE ];
+
+	// Mortar firing info.
+	int		m_iFiringState; // One of the MORTAR_ defines.
+	bool	m_bMortarReloading;
+	float	m_flPower;
+	bool	m_bAllowedToFire;
+	
+	// Parameters for the next shot.
+	float m_flFiringPower;
+	float m_flFiringAccuracy;
+
+	float m_flMortarYaw;	// What direction the mortar is aimed in.
+	float m_flMortarPitch;
+	
+	// This is what is used on the client to draw the ground line and orient the mortar.
+	// It is usually copied right over from m_flClientMortarYaw (which comes from the server),
+	// but this is also used when rotating the mortar so you can see the line move smoothly.
+	float m_flClientMortarYaw;
+
+	// This is set to about 1/4 seconds when you rotate the mortar line so you use the client's
+	// (smooth, non-lagged) yaw changes instead of the server's.
+	float m_flForceClientYawCountdown;
+
+private:
+	C_ObjectMortar( const C_ObjectMortar & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectMortar, DT_ObjectMortar, CObjectMortar)
+	RecvPropInt( RECVINFO(m_iRoundType) ),
+	RecvPropArray( RecvPropInt( RECVINFO(m_iMortarRounds[0]) ),	m_iMortarRounds )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectMortar::C_ObjectMortar( void )
+{
+	memset( m_iMortarRounds, 0, sizeof( m_iMortarRounds ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectMortar::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	ENTITY_PANEL_ACTIVATE( "mortar", !bDormant );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Cycle ammo types on the mortar
+//-----------------------------------------------------------------------------
+void C_ObjectMortar::Select( void )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer == NULL )
+		return;
+
+	int iOldType = m_iRoundType++;
+
+	// Cycle to the next ammo type
+	while ( m_iRoundType != iOldType )
+	{
+		// Hit the end of the round types?
+		if ( m_iRoundType == MA_LASTAMMOTYPE )
+		{
+			m_iRoundType = MA_SHELL;
+			break;
+		}
+
+		// Does this round type need a technology?
+		if ( MortarAmmoTechs[ m_iRoundType ] && MortarAmmoTechs[ m_iRoundType ][0] )
+		{
+			// Does the player have the technology?
+			if ( pPlayer->HasNamedTechnology( MortarAmmoTechs[ m_iRoundType ] ) )
+			{
+				// Do we have ammo?
+				if ( m_iMortarRounds[ m_iRoundType ] > 0 )
+					break;
+			}
+		}
+
+		// Go to the next round type
+		m_iRoundType++;
+	}
+
+	engine->ClientCmd( VarArgs("mortarround %d", m_iRoundType) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectMortar::RecalculateIDString( void )
+{
+	// Only owners get full data
+	if ( IsOwnedByLocalPlayer() )
+	{
+		if ( m_iRoundType >= 0 )
+		{
+			// -1 means we have infinite rounds of this type
+			if ( m_iMortarRounds[ m_iRoundType ] == -1 )
+			{
+				Q_snprintf( m_szIDString, sizeof(m_szIDString), "%s  -  %s", GetTargetDescription(), MortarAmmoNames[ m_iRoundType ] );
+			}
+			else 
+			{
+				Q_snprintf( m_szIDString, sizeof(m_szIDString), "%s  -  %d %s", GetTargetDescription(), m_iMortarRounds[ m_iRoundType ], MortarAmmoNames[ m_iRoundType ] );
+			}
+			Q_strncat( m_szIDString, "\nUse it to change ammo types.", sizeof(m_szIDString), COPY_ALL_CHARACTERS );
+		}
+	}
+
+	BaseClass::RecalculateIDString();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectMortar::ClickFire( void )
+{
+	switch( m_iFiringState )
+	{
+	case MORTAR_IDLE:
+		m_iFiringState = MORTAR_CHARGING_POWER;
+		break;
+	
+	case MORTAR_CHARGING_POWER:
+		m_flFiringPower = m_flPower;
+		m_iFiringState = MORTAR_CHARGING_ACCURACY;
+		break;
+	
+	case MORTAR_CHARGING_ACCURACY:
+		m_flFiringAccuracy = m_flPower;
+		m_iFiringState = MORTAR_IDLE;
+
+		FireMortar();
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectMortar::GetMortarData( float *flClientMortarYaw, bool *bAllowedToFire, float *flPower, float *flFiringPower, float *flFiringAccuracy, int *iFiringState )
+{
+	*flClientMortarYaw = m_flClientMortarYaw;
+	*bAllowedToFire = m_bAllowedToFire;
+	*flPower = m_flPower;
+	*flFiringPower = m_flFiringPower;
+	*flFiringAccuracy = m_flFiringAccuracy;
+	*iFiringState = m_iFiringState;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectMortar::SendYawCommand( void )
+{
+	char szbuf[48];
+	Q_snprintf( szbuf, sizeof( szbuf ), "MortarYaw %0.2f\n", m_flClientMortarYaw );
+	SendClientCommand( szbuf );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectMortar::ForceClientYawCountdown( float flTime )
+{
+	m_flForceClientYawCountdown = flTime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CMortarControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CMortarControlPanel, CObjectControlPanel );
+public:
+	CMortarControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual ~CMortarControlPanel();
+	
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnCommand( const char *command );
+	C_ObjectMortar* GetMortar() const;
+
+protected:
+	virtual vgui::Panel* TickCurrentPanel();
+
+private:
+	CMortarMinimapPanel *m_pMinimapPanel;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CMortarControlPanel, "mortar_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CMortarControlPanel::CMortarControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CMortarControlPanel" ) 
+{
+	m_pMinimapPanel = new CMortarMinimapPanel( this, "MinimapPanel" );
+	m_pMinimapPanel->Init( NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CMortarControlPanel::~CMortarControlPanel()
+{
+	delete m_pMinimapPanel;
+}
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CMortarControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	// Make sure all named panels are created up above because BaseClass::Init initializes them
+	// all from their keyvalues.
+	if ( !BaseClass::Init( pKeyValues, pInitData ) )
+		return false;
+
+	// Init subpanels.
+	int x, y, w, h;
+	GetBounds( x, y, w, h );
+
+	m_pMinimapPanel->LevelInit( engine->GetLevelName() );
+	m_pMinimapPanel->SetVisible( true );
+	m_pMinimapPanel->InitMortarMinimap( GetMortar() );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectMortar* CMortarControlPanel::GetMortar() const
+{
+	return dynamic_cast< C_ObjectMortar* >( GetOwningObject() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectMortar::FireMortar( void )
+{
+	char cmd[512];
+	Q_snprintf( cmd, sizeof( cmd ), "FireMortar %.2f %.2f", m_flFiringPower, m_flFiringAccuracy );
+	SendClientCommand( cmd );
+}
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+vgui::Panel* CMortarControlPanel::TickCurrentPanel()
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return BaseClass::TickCurrentPanel();;
+
+	ShowOwnerLabel( true );
+	ShowHealthLabel( true );
+
+	C_ObjectMortar *pMortar = GetMortar();
+	if ( !pMortar )
+		return BaseClass::TickCurrentPanel();;
+
+	ShowOwnerLabel( false );
+	ShowHealthLabel( false );
+
+	m_pMinimapPanel->Repaint();
+
+	float flAccuracySpeed = (1.0 / MORTAR_CHARGE_ACCURACY_RATE);
+
+	// Handle power charging
+	switch( pMortar->m_iFiringState )
+	{
+	case MORTAR_IDLE:
+		pMortar->m_flPower = 0;
+		break;
+
+	case MORTAR_CHARGING_POWER:
+		pMortar->m_flPower = MIN( pMortar->m_flPower + ( (1.0 / MORTAR_CHARGE_POWER_RATE) * gpGlobals->frametime), 1 );
+		pMortar->m_flFiringPower = 0;
+		pMortar->m_flFiringAccuracy = 0;
+		if ( pMortar->m_flPower >= 1.0 )
+		{
+			// Hit Max, start going down
+			pMortar->m_flFiringPower = pMortar->m_flPower;
+			pMortar->m_iFiringState = MORTAR_CHARGING_ACCURACY;
+		}
+		break;
+
+	case MORTAR_CHARGING_ACCURACY:
+		// Calculate accuracy speed
+		if ( pMortar->m_flFiringPower > 0.5 )
+		{
+			// Shots over halfway suffer an increased speed to the accuracy power, making accurate shots harder
+			float flAdjustedPower = (pMortar->m_flFiringPower - 0.5) * 3.0;
+			flAccuracySpeed += (pMortar->m_flFiringPower * flAdjustedPower);
+		}
+
+		pMortar->m_flPower = MAX( pMortar->m_flPower - ( flAccuracySpeed * gpGlobals->frametime), -0.25f);
+		if ( pMortar->m_flPower <= -0.25 )
+		{
+			// Hit Min, fire mortar
+			pMortar->m_flFiringAccuracy = pMortar->m_flPower;
+			pMortar->m_iFiringState = MORTAR_IDLE;
+
+			pMortar->FireMortar();
+		}
+		break;
+	
+	default:
+		break;
+	}
+
+	return BaseClass::TickCurrentPanel();
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CMortarControlPanel::OnCommand( const char *command )
+{
+	C_ObjectMortar *pMortar = GetMortar();
+	if ( !pMortar )
+		return;
+
+	if ( !Q_stricmp( command, "FireMortar" ) )
+	{
+		pMortar->ClickFire();
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_obj_powerpack.cpp b/game/client/tf2/c_obj_powerpack.cpp
new file mode 100644
index 0000000..edbfcfd
--- /dev/null
+++ b/game/client/tf2/c_obj_powerpack.cpp
@@ -0,0 +1,340 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_baseobject.h"
+#include "ObjectControlPanel.h"
+#include "tf_shareddefs.h"
+#include "tempent.h"
+#include "c_te_legacytempents.h"
+#include "iviewrender_beams.h"
+#include "beamdraw.h"
+#include "view.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#define NUM_POWERPACK_GLOWS		6
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectPowerPack : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectPowerPack, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectPowerPack();
+	~C_ObjectPowerPack();
+	int SocketsLeft() const { return (MAX_OBJECTS_PER_PACK - m_iObjectsAttached); }
+
+	// Since we have material proxies to show building amount, don't offset origin
+	virtual bool	OffsetObjectOrigin( Vector& origin )
+	{
+		return false;
+	}
+
+	virtual void	OnGoActive( void );
+	virtual void	OnGoInactive( void );
+	void			RemoveGlows( void );
+	virtual void	ClientThink( void );
+	virtual int		DrawModel( int flags );
+
+private:
+	int					m_iObjectsAttached;
+	int					m_iGlowModelIndex;
+	C_LocalTempEntity	*m_pGlowSprites[ NUM_POWERPACK_GLOWS ];
+
+	// Jacob's laddder
+	Beam_t				*m_pJacobsLadderBeam;
+	float				m_flJacobsLeftPoint;
+	float				m_flJacobsRightPoint;
+	Vector				m_vecJacobsStart;
+	Vector				m_vecJacobsEnd;
+	CMaterialReference	m_hJacobsPointMaterial;
+
+private:
+	C_ObjectPowerPack( const C_ObjectPowerPack & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectPowerPack, DT_ObjectPowerPack, CObjectPowerPack)
+	RecvPropInt( RECVINFO(m_iObjectsAttached) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectPowerPack::C_ObjectPowerPack()
+{
+	for ( int i = 0; i < NUM_POWERPACK_GLOWS; i++ )
+	{
+		m_pGlowSprites[i] = NULL;
+	}
+
+	m_iGlowModelIndex = PrecacheModel( "effects/human_object_glow.vmt" ); 
+	m_pJacobsLadderBeam = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectPowerPack::~C_ObjectPowerPack( void )
+{
+	RemoveGlows();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: We've just gone active
+//-----------------------------------------------------------------------------
+void C_ObjectPowerPack::OnGoActive( void )
+{
+	// Turn on our glows
+	for ( int i = 0; i < NUM_POWERPACK_GLOWS; i++ )
+	{
+		// Find the attachment point
+		int iAttachment = LookupAttachment( VarArgs("glow_%d",(i+1)) );
+		Vector vecOrigin;
+		QAngle vecAngles;
+		if ( GetAttachment( iAttachment, vecOrigin, vecAngles ) )
+		{
+			Vector vecForward;
+			AngleVectors( vecAngles, &vecForward );
+			m_pGlowSprites[i] = tempents->TempSprite( vecOrigin, vec3_origin, 0.35, m_iGlowModelIndex, kRenderTransAdd, 0, 0.5, 1, FTENT_PERSIST | FTENT_NEVERDIE | FTENT_BEOCCLUDED, vecForward );
+		}
+	}
+
+	m_flJacobsLeftPoint = 0;
+	m_flJacobsRightPoint = 0;
+	m_hJacobsPointMaterial.Init( "sprites/blueflare2", TEXTURE_GROUP_CLIENT_EFFECTS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: We've just gone inactive
+//-----------------------------------------------------------------------------
+void C_ObjectPowerPack::OnGoInactive( void )
+{
+	// Turn off our glows
+	RemoveGlows();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectPowerPack::RemoveGlows( void )
+{
+	for ( int i = 0; i < NUM_POWERPACK_GLOWS; i++ )
+	{
+		if ( m_pGlowSprites[i] )
+		{
+			m_pGlowSprites[i]->die = 0;
+			m_pGlowSprites[i] = NULL;
+		}
+	}
+
+	// Stop the jacob's ladder
+	if ( m_pJacobsLadderBeam )
+	{
+		m_pJacobsLadderBeam->flags &= ~FBEAM_FOREVER;
+		m_pJacobsLadderBeam->die = gpGlobals->curtime;
+		m_pJacobsLadderBeam = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectPowerPack::ClientThink( void )
+{
+	// Create the jacob's ladder
+	if ( !m_pJacobsLadderBeam )
+	{
+		BeamInfo_t beamInfo;
+		beamInfo.m_vecStart.Init();
+		beamInfo.m_vecEnd.Init();
+		beamInfo.m_pszModelName = "sprites/physbeam.vmt";
+		beamInfo.m_flHaloScale = 0.0f;
+		beamInfo.m_flLife = 0.0f;
+		beamInfo.m_flWidth = 8.0f;
+		beamInfo.m_flEndWidth = 4.0f;
+		beamInfo.m_flFadeLength = 0.0f;
+		beamInfo.m_flAmplitude = 20.0f;
+		beamInfo.m_flBrightness = 255.0f;
+		beamInfo.m_flSpeed = 0.0f;
+		beamInfo.m_nStartFrame = 0;
+		beamInfo.m_flFrameRate = 0.0f;
+		beamInfo.m_flRed = 206.0f;
+		beamInfo.m_flGreen = 181.0f;
+		beamInfo.m_flBlue = 127.0f;
+		beamInfo.m_nSegments = 5;
+		beamInfo.m_bRenderable = true;
+		m_pJacobsLadderBeam = beams->CreateBeamPoints( beamInfo );
+	}
+
+	// Update the position of the jacob's ladder
+	BeamInfo_t beamInfo;
+	QAngle vecAngle;
+	int iAttachment;
+
+	// Setup a color reflecting the amount of power being used
+	color32 color;
+	color.r = 206;
+	color.g = 182;
+	color.b = 127;
+	color.a = 255;
+
+	// Tesla Effect
+	Vector vecRightTop, vecRightBottom;
+	Vector vecLeftTop, vecLeftBottom;
+	iAttachment = LookupAttachment( "Tesla_ll" );
+	GetAttachment( iAttachment, vecLeftBottom, vecAngle );
+	iAttachment = LookupAttachment( "Tesla_ul" );
+	GetAttachment( iAttachment, vecLeftTop, vecAngle );
+	iAttachment = LookupAttachment( "Tesla_lr" );
+	GetAttachment( iAttachment, vecRightBottom, vecAngle );
+	iAttachment = LookupAttachment( "Tesla_ur" );
+	GetAttachment( iAttachment, vecRightTop, vecAngle );
+
+	float flSpeed = 0.02;
+
+	m_flJacobsLeftPoint += random->RandomFloat( flSpeed * 0.25, flSpeed * 2);
+	m_flJacobsRightPoint += random->RandomFloat( flSpeed * 0.25, flSpeed * 2);
+
+	// If they've both hit the end, break the ladder
+	if ( m_flJacobsLeftPoint >= 1.0f && m_flJacobsRightPoint >= 1.0f )
+	{
+		// Snap!
+		m_flJacobsLeftPoint = 0.0f; 
+		m_flJacobsRightPoint = 0.0f; 
+	}
+	else if ( m_flJacobsLeftPoint > 1.0f ) 
+	{ 
+		// Only the left point's made it
+		m_flJacobsLeftPoint = 1.0f; 
+	}
+	else if ( m_flJacobsRightPoint > 1.0f ) 
+	{ 
+		// Only the right point's made it
+		m_flJacobsRightPoint = 1.0f; 
+	}
+
+	Vector vecLeft = vecLeftTop - vecLeftBottom;
+	Vector vecRight = vecRightTop - vecRightBottom;
+	m_vecJacobsStart = vecLeftBottom + ( m_flJacobsLeftPoint * vecLeft );
+	m_vecJacobsEnd = vecRightBottom + ( m_flJacobsRightPoint * vecRight );
+
+	beamInfo.m_vecStart = m_vecJacobsStart;
+	beamInfo.m_vecEnd = m_vecJacobsEnd;
+	beamInfo.m_flRed = color.r;
+	beamInfo.m_flGreen = color.g;
+	beamInfo.m_flBlue = color.b;
+	beams->UpdateBeamInfo( m_pJacobsLadderBeam, beamInfo );	
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_ObjectPowerPack::DrawModel( int flags )
+{
+	if ( BaseClass::DrawModel( flags ) )
+	{
+		if ( ShouldBeActive() )
+		{
+			// Get the distance to the view
+			float flDistance = (GetAbsOrigin() - MainViewOrigin()).LengthSqr();
+			if ( flDistance < (1024 * 1024) )
+			{
+				// Draw a sprite at the tips.
+				color32 color;
+				color.r = 255;
+				color.g = 255;
+				color.b = 255;
+				color.a = 255;
+				float flSize = 25.0f;
+				materials->Bind( m_hJacobsPointMaterial, this );
+				DrawSprite( m_vecJacobsStart, flSize, flSize, color );
+				DrawSprite( m_vecJacobsEnd, flSize, flSize, color );
+			}
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CPowerPackControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CPowerPackControlPanel, CObjectControlPanel );
+
+public:
+	CPowerPackControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+
+private:
+	vgui::Label *m_pSocketsLabel;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CPowerPackControlPanel, "powerpack_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CPowerPackControlPanel::CPowerPackControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CPowerPackControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CPowerPackControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pSocketsLabel = new vgui::Label( GetActivePanel(), "SocketReadout", "" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CPowerPackControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_ObjectPowerPack*>(pObj) );
+	C_ObjectPowerPack *pPowerPack = static_cast<C_ObjectPowerPack*>(pObj);
+
+	char buf[256];
+	int nSocketsLeft = pPowerPack->SocketsLeft();
+	if (nSocketsLeft > 0)
+	{
+		Q_snprintf( buf, sizeof( buf ), "%d sockets left", pPowerPack->SocketsLeft() );
+	}
+	else
+	{
+		Q_strncpy( buf, "No sockets left", sizeof( buf ) );
+	}
+
+	m_pSocketsLabel->SetText( buf );
+}
+
+
diff --git a/game/client/tf2/c_obj_rallyflag.cpp b/game/client/tf2/c_obj_rallyflag.cpp
new file mode 100644
index 0000000..76a1ee5
--- /dev/null
+++ b/game/client/tf2/c_obj_rallyflag.cpp
@@ -0,0 +1,35 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "c_baseobject.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectRallyFlag : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectRallyFlag, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectRallyFlag();
+
+private:
+	C_ObjectRallyFlag( const C_ObjectRallyFlag & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectRallyFlag, DT_ObjectRallyFlag, CObjectRallyFlag)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectRallyFlag::C_ObjectRallyFlag()
+{
+}
+
diff --git a/game/client/tf2/c_obj_resourcepump.cpp b/game/client/tf2/c_obj_resourcepump.cpp
new file mode 100644
index 0000000..13858ce
--- /dev/null
+++ b/game/client/tf2/c_obj_resourcepump.cpp
@@ -0,0 +1,164 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "c_obj_resourcepump.h"
+#include "commanderoverlay.h"
+#include "vgui_healthbar.h"
+#include "ObjectControlPanel.h"
+#include "tf_shareddefs.h"
+#include "vgui_bitmapbutton.h"
+#include "C_Func_Resource.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+BEGIN_RECV_TABLE_NOBASE( C_ObjectResourcePump, DT_ResourcePumpTeamOnlyVars )
+	RecvPropInt( RECVINFO(m_iPumpLevel) ),
+	RecvPropEHandle( RECVINFO(m_hResourceZone) ),
+END_RECV_TABLE()
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectResourcePump, DT_ResourcePump, CObjectResourcePump)
+	RecvPropDataTable( "teamonly", 0, 0, &REFERENCE_RECV_TABLE( DT_ResourcePumpTeamOnlyVars ) )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectResourcePump::C_ObjectResourcePump()
+{
+	m_iPumpLevel = 1;
+	m_pResourceBar = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectResourcePump::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	ENTITY_PANEL_ACTIVATE( "resource_pump", !bDormant );
+}
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CResourcePumpControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CResourcePumpControlPanel, CObjectControlPanel );
+
+public:
+	CResourcePumpControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+	void		 Upgrade( void );
+
+private:
+	vgui::Button *m_pUpgradeButton;
+	vgui::Label *m_pResourcesLabel;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CResourcePumpControlPanel, "resourcepump_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CResourcePumpControlPanel::CResourcePumpControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CResourcePumpControlPanel" ) 
+{
+}
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CResourcePumpControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pUpgradeButton = new CBitmapButton( this, "UpgradeButton", "Upgrade" );
+	m_pResourcesLabel = new vgui::Label( this, "ResourcesLabel", "Resources: 0" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	// ROBIN: Removed upgrading for now
+	m_pUpgradeButton->SetVisible( false );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CResourcePumpControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+	
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_ObjectResourcePump*>(pObj) );
+	C_ObjectResourcePump *pPump = static_cast<C_ObjectResourcePump*>(pObj);
+
+	char buf[256];
+	int iPumpLevel = pPump->GetLevel();
+	int iCost = CalculateObjectUpgrade( OBJ_RESOURCEPUMP, iPumpLevel );
+	if ( iCost )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Upgrade to Level %d\nCost: %d", iPumpLevel+1, iCost );
+	}
+	else
+	{
+		Q_snprintf( buf, sizeof( buf ), "Level %d", iPumpLevel );
+	}
+
+	m_pUpgradeButton->SetText( buf );
+
+	C_ResourceZone *pResourceZone = pPump->GetResourceZone();
+	if (pResourceZone)
+	{
+		Q_snprintf( buf, sizeof( buf ), "Resources: %d", pResourceZone->m_nResourcesLeft );
+		m_pResourcesLabel->SetText( buf );
+	}
+	else
+	{
+		m_pResourcesLabel->SetText( "Resources: 0" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Dismantles the object 
+//-----------------------------------------------------------------------------
+void CResourcePumpControlPanel::Upgrade( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "upgrade" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CResourcePumpControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Upgrade", 7))
+	{
+		Upgrade();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_obj_resourcepump.h b/game/client/tf2/c_obj_resourcepump.h
new file mode 100644
index 0000000..3cab0e9
--- /dev/null
+++ b/game/client/tf2/c_obj_resourcepump.h
@@ -0,0 +1,44 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_OBJ_RESOURCEPUMP_H
+#define C_OBJ_RESOURCEPUMP_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "CommanderOverlay.h"
+#include "c_baseobject.h"
+
+class C_ResourceZone;
+
+class C_ObjectResourcePump : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectResourcePump, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+
+	C_ObjectResourcePump();
+
+	virtual void	SetDormant( bool bDormant );
+	int				GetLevel( void ) { return m_iPumpLevel; }
+
+	C_ResourceZone*	GetResourceZone() { return m_hResourceZone.Get(); }
+
+private:
+	CHealthBarPanel	*m_pResourceBar;
+	int				m_iPumpLevel;
+	CHandle<C_ResourceZone>	m_hResourceZone;
+
+private:
+	C_ObjectResourcePump( const C_ObjectResourcePump & ); // not defined, not accessible
+};
+
+
+
+#endif // C_OBJ_RESOURCEPUMP_H
diff --git a/game/client/tf2/c_obj_respawn_station.cpp b/game/client/tf2/c_obj_respawn_station.cpp
new file mode 100644
index 0000000..65af05f
--- /dev/null
+++ b/game/client/tf2/c_obj_respawn_station.cpp
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CObjectSentrygun
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "CommanderOverlay.h"
+#include "c_baseobject.h"
+#include "vgui_healthbar.h"
+#include "c_obj_respawn_station.h"
+#include "C_BaseTFPlayer.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectRespawnStation, DT_ObjectRespawnStation, CObjectRespawnStation)
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectRespawnStation::C_ObjectRespawnStation( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectRespawnStation::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	ENTITY_PANEL_ACTIVATE( "respawn_station", !bDormant );
+}
+
diff --git a/game/client/tf2/c_obj_respawn_station.h b/game/client/tf2/c_obj_respawn_station.h
new file mode 100644
index 0000000..8b766f1
--- /dev/null
+++ b/game/client/tf2/c_obj_respawn_station.h
@@ -0,0 +1,39 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_OBJ_RESPAWN_STATION_H
+#define C_OBJ_RESPAWN_STATION_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Respawn Station object
+//-----------------------------------------------------------------------------
+class C_ObjectRespawnStation : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectRespawnStation, C_BaseObject );
+
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+
+	C_ObjectRespawnStation();
+
+	// Status
+	virtual void SetDormant( bool bDormant );
+
+protected:
+	// A special panel to indicate which one's the respawn station
+	CPanelRegistration m_SelectedRespawnPanel;
+
+private:
+	C_ObjectRespawnStation( const C_ObjectRespawnStation & ); // not defined, not accessible
+};
+
+
+#endif // C_OBJ_RESPAWN_STATION_H
diff --git a/game/client/tf2/c_obj_resupply.cpp b/game/client/tf2/c_obj_resupply.cpp
new file mode 100644
index 0000000..c0134dd
--- /dev/null
+++ b/game/client/tf2/c_obj_resupply.cpp
@@ -0,0 +1,151 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CObjectSentrygun
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_baseobject.h"
+#include "c_basetfplayer.h"
+#include "ObjectControlPanel.h"
+#include "vgui_bitmapbutton.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Resupply Station object
+//-----------------------------------------------------------------------------
+class C_ObjectResupply : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectResupply, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectResupply();
+
+private:
+	C_ObjectResupply( const C_ObjectResupply & ); // not defined, not accessible
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectResupply, DT_ObjectResupply, CObjectResupply)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectResupply::C_ObjectResupply()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CResupplyControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CResupplyControlPanel, CObjectControlPanel );
+
+public:
+	CResupplyControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnCommand( const char *command );
+
+protected:
+	virtual void OnTickActive( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer );
+
+private:
+	void Buy( ResupplyBuyType_t type );
+
+	vgui::Button *m_pBuyAmmoButton;
+	vgui::Button *m_pBuyGrenadesButton;
+	vgui::Button *m_pBuyHealthButton;
+	vgui::Button *m_pBuyAllButton;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CResupplyControlPanel, "resupply_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CResupplyControlPanel::CResupplyControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CResupplyControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CResupplyControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	// Grab ahold of certain well-known controls
+	m_pBuyAmmoButton = new CBitmapButton( GetActivePanel(), "BuyAmmoButton", "" );
+	m_pBuyGrenadesButton = new CBitmapButton( GetActivePanel(), "BuyGrenadesButton", "" );
+	m_pBuyHealthButton = new CBitmapButton( GetActivePanel(), "BuyHealthButton", "" );
+	m_pBuyAllButton = new CBitmapButton( GetActivePanel(), "BuyAllButton", "" );
+
+	return BaseClass::Init( pKeyValues, pInitData );
+}
+
+
+//-----------------------------------------------------------------------------
+// Deactivates buttons we can't afford
+//-----------------------------------------------------------------------------
+void CResupplyControlPanel::OnTickActive( C_BaseObject *pObj, C_BaseTFPlayer *pLocalPlayer )
+{
+	BaseClass::OnTickActive( pObj, pLocalPlayer );
+
+	int nBankResources = pLocalPlayer ? pLocalPlayer->GetBankResources() : 0;
+	m_pBuyAmmoButton->SetEnabled( nBankResources >= RESUPPLY_AMMO_COST );
+	m_pBuyGrenadesButton->SetEnabled( nBankResources >= RESUPPLY_GRENADES_COST );
+	m_pBuyHealthButton->SetEnabled( nBankResources >= RESUPPLY_HEALTH_COST );
+	m_pBuyAllButton->SetEnabled( nBankResources >= RESUPPLY_ALL_COST );
+}
+
+
+//-----------------------------------------------------------------------------
+// Buys stuff
+//-----------------------------------------------------------------------------
+void CResupplyControlPanel::Buy( ResupplyBuyType_t type )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		char szbuf[48];
+		Q_snprintf( szbuf, sizeof( szbuf ), "buy %d", type );
+		pObj->SendClientCommand( szbuf );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CResupplyControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "BuyAmmo", 8))
+	{
+		Buy(RESUPPLY_BUY_AMMO);
+	}
+	else if (!Q_strnicmp(command, "BuyHealth", 10))
+	{
+		Buy(RESUPPLY_BUY_HEALTH);
+	}
+	else if (!Q_strnicmp(command, "BuyGrenades", 12))
+	{
+		Buy(RESUPPLY_BUY_GRENADES);
+	}
+	else if (!Q_strnicmp(command, "BuyAll", 7))
+	{
+		Buy(RESUPPLY_BUY_ALL);
+	}
+	else
+	{
+		BaseClass::OnCommand(command);
+	}
+}
diff --git a/game/client/tf2/c_obj_sandbag_bunker.cpp b/game/client/tf2/c_obj_sandbag_bunker.cpp
new file mode 100644
index 0000000..4ae7a92
--- /dev/null
+++ b/game/client/tf2/c_obj_sandbag_bunker.cpp
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "commanderoverlay.h"
+#include "c_baseobject.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectSandbagBunker : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectSandbagBunker, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectSandbagBunker();
+
+private:
+	C_ObjectSandbagBunker( const C_ObjectSandbagBunker & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectSandbagBunker, DT_ObjectSandbagBunker, CObjectSandbagBunker)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectSandbagBunker::C_ObjectSandbagBunker()
+{
+}
diff --git a/game/client/tf2/c_obj_selfheal.cpp b/game/client/tf2/c_obj_selfheal.cpp
new file mode 100644
index 0000000..5fec4e9
--- /dev/null
+++ b/game/client/tf2/c_obj_selfheal.cpp
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "commanderoverlay.h"
+#include "tf_obj_baseupgrade_shared.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectSelfHeal : public C_BaseObjectUpgrade
+{
+	DECLARE_CLASS( C_ObjectSelfHeal, C_BaseObjectUpgrade );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectSelfHeal();
+
+private:
+	C_ObjectSelfHeal( const C_ObjectSelfHeal & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectSelfHeal, DT_ObjectSelfHeal, CObjectSelfHeal)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectSelfHeal::C_ObjectSelfHeal()
+{
+}
+
diff --git a/game/client/tf2/c_obj_sentrygun.h b/game/client/tf2/c_obj_sentrygun.h
new file mode 100644
index 0000000..c66fd81
--- /dev/null
+++ b/game/client/tf2/c_obj_sentrygun.h
@@ -0,0 +1,106 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_OBJ_SENTRYGUN_H
+#define C_OBJ_SENTRYGUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Base Sentrygun
+//-----------------------------------------------------------------------------
+class C_ObjectSentrygun : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectSentrygun, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+
+	C_ObjectSentrygun();
+	virtual void	GetBoneControllers(float controllers[MAXSTUDIOBONES]);
+	virtual int		DrawModel( int flags );
+	virtual void	SetDormant( bool bDormant );
+	virtual void	PreDataUpdate( DataUpdateType_t updateType );
+	virtual void	PostDataUpdate( DataUpdateType_t updateType );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual float	GetInitialBuilderYaw();
+	int				GetAmmoLeft( void ) { return m_iAmmo; }
+	virtual void	FinishedBuilding( void );
+
+	virtual void	ClientThink( void );
+
+private:
+	bool	IsTurtled( void ) { return m_bTurtled; }
+
+	// Turret Functions
+	bool	MoveTurret( void );
+
+	// Recompute sentrygun orientation...
+	void RecomputeOrientation();
+
+public:
+
+	int				m_iRightBound;
+	int				m_iLeftBound;
+	bool			m_bTurningRight;
+
+	// Movement
+	int				m_iBaseTurnRate;
+	float			m_fTurnRate;
+	QAngle			m_vecCurAngles;
+	QAngle			m_vecGoalAngles;
+	Vector			m_vecCurDishAngles;
+
+	float			m_fBoneXRotator;
+	float			m_fBoneYRotator;
+	int				m_iAmmo;
+
+	// Turtling
+	bool			m_bTurtled;
+	bool			m_bLastTurtled;
+	float			m_flStartedTurtlingAt;
+	float			m_flStartedUnTurtlingAt;
+
+	int				m_nAnimationParity;
+ 	int				m_nLastAnimationParity;
+
+	// Networked from server
+	EHANDLE			m_hEnemy;
+
+
+	QAngle			m_angPrevLocalAngles;
+	int				m_nOrientationParity;
+	int				m_nPrevOrientationParity;
+
+private:
+	C_ObjectSentrygun( const C_ObjectSentrygun & ); // not defined, not accessible
+};
+
+class C_ObjectSentrygunPlasma : public C_ObjectSentrygun
+{
+	DECLARE_CLASS( C_ObjectSentrygunPlasma, C_ObjectSentrygun );
+public:
+	C_ObjectSentrygunPlasma();
+	DECLARE_CLIENTCLASS();
+
+private:
+	C_ObjectSentrygunPlasma( const C_ObjectSentrygunPlasma & ); // not defined, not accessible
+};
+
+class C_ObjectSentrygunRocketlauncher : public C_ObjectSentrygun
+{
+	DECLARE_CLASS( C_ObjectSentrygunRocketlauncher, C_ObjectSentrygun );
+public:
+	C_ObjectSentrygunRocketlauncher();
+	DECLARE_CLIENTCLASS();
+
+private:
+	C_ObjectSentrygunRocketlauncher( const C_ObjectSentrygunRocketlauncher & ); // not defined, not accessible
+};
+
+#endif // C_OBJ_SENTRYGUN_H
diff --git a/game/client/tf2/c_obj_shieldwall.cpp b/game/client/tf2/c_obj_shieldwall.cpp
new file mode 100644
index 0000000..b094502
--- /dev/null
+++ b/game/client/tf2/c_obj_shieldwall.cpp
@@ -0,0 +1,111 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CObjectSentrygun
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "CommanderOverlay.h"
+#include "c_baseobject.h"
+#include "vgui_healthbar.h"
+#include "ObjectControlPanel.h"
+#include "c_shield.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Resupply Station object
+//-----------------------------------------------------------------------------
+class C_ObjectShieldWallBase : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectShieldWallBase, C_BaseObject );
+
+public:
+	C_ObjectShieldWallBase() {}
+
+public:
+	CHandle<C_Shield>	m_hDeployedShield;
+
+private:
+	C_ObjectShieldWallBase( const C_ObjectShieldWallBase & ); // not defined, not accessible
+};
+
+
+//-----------------------------------------------------------------------------
+//
+// Projected shield wall
+//
+//-----------------------------------------------------------------------------
+class C_ObjectShieldWall : public C_ObjectShieldWallBase
+{
+	DECLARE_CLASS( C_ObjectShieldWall, C_ObjectShieldWallBase );
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+
+	C_ObjectShieldWall( void );
+
+	virtual void SetDormant( bool bDormant );
+	virtual void RecalculateIDString( void );
+
+private:
+	C_ObjectShieldWall( const C_ObjectShieldWall & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectShieldWall, DT_ObjectShieldWall, CObjectShieldWall)
+	RecvPropEHandle(RECVINFO(m_hDeployedShield)),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectShieldWall::C_ObjectShieldWall( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectShieldWall::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	ENTITY_PANEL_ACTIVATE( "shield_wall", !bDormant );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectShieldWall::RecalculateIDString( void )
+{
+	if ( m_hDeployedShield )
+	{
+		// Report shield strength
+		Q_snprintf( m_szIDString, sizeof(m_szIDString), "Shield Strength: %.0f percent", m_hDeployedShield->GetPowerLevel() * 100 );
+	}
+
+	BaseClass::RecalculateIDString();
+}
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CShieldWallControlPanel : public CRotatingObjectControlPanel
+{
+	DECLARE_CLASS( CShieldWallControlPanel, CRotatingObjectControlPanel );
+
+public:
+	CShieldWallControlPanel( vgui::Panel *parent, const char *panelName );
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CShieldWallControlPanel, "shieldwall_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CShieldWallControlPanel::CShieldWallControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CShieldWallControlPanel" ) 
+{
+}
+
+
diff --git a/game/client/tf2/c_obj_tower.cpp b/game/client/tf2/c_obj_tower.cpp
new file mode 100644
index 0000000..14a0473
--- /dev/null
+++ b/game/client/tf2/c_obj_tower.cpp
@@ -0,0 +1,69 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "commanderoverlay.h"
+#include "c_baseobject.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectTower : public C_BaseObject
+{
+	DECLARE_CLASS( C_ObjectTower, C_BaseObject );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectTower();
+
+private:
+	C_ObjectTower( const C_ObjectTower & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectTower, DT_ObjectTower, CObjectTower)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectTower::C_ObjectTower()
+{
+}
+
+//=============================================================================
+// Tower Ladder
+//=============================================================================
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectTowerLadder : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_ObjectTowerLadder, C_BaseAnimating );
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectTowerLadder();
+
+private:
+	C_ObjectTowerLadder( const C_ObjectTowerLadder& ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjectTowerLadder, DT_ObjectTowerLadder, CObjectTowerLadder )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_ObjectTowerLadder::C_ObjectTowerLadder()
+{
+}
+
diff --git a/game/client/tf2/c_obj_tunnel.cpp b/game/client/tf2/c_obj_tunnel.cpp
new file mode 100644
index 0000000..7794571
--- /dev/null
+++ b/game/client/tf2/c_obj_tunnel.cpp
@@ -0,0 +1,143 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "c_obj_mapdefined.h"
+#include "minimap_trace.h"
+#include <KeyValues.h>
+#include "VGuiMatSurface/IMatSystemSurface.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectTunnel : public C_ObjectMapDefined
+{
+	DECLARE_CLASS( C_ObjectTunnel, C_ObjectMapDefined );
+public:
+	DECLARE_PREDICTABLE();
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectTunnel();
+
+private:
+	C_ObjectTunnel( const C_ObjectTunnel& src );
+};
+
+LINK_ENTITY_TO_CLASS( obj_tunnel, C_ObjectTunnel );
+BEGIN_PREDICTION_DATA( C_ObjectTunnel )
+END_PREDICTION_DATA();
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectTunnel, DT_ObjectTunnel, CObjectTunnel)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectTunnel::C_ObjectTunnel()
+{
+	CONSTRUCT_MINIMAP_PANEL( "obj_tunnel", MINIMAP_OBJECTS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CMinimapObjectTunnelPanel : public CMinimapTraceTeamBitmapPanel
+{
+	DECLARE_CLASS( CMinimapObjectTunnelPanel, CMinimapTraceTeamBitmapPanel );
+
+public:
+	CMinimapObjectTunnelPanel( vgui::Panel *parent, const char *panelName ) 
+	 : BaseClass( parent, "CMinimapObjectTunnelPanel" )
+	{
+	}
+
+	virtual bool Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData );
+	virtual void Paint();
+
+private:
+	enum
+	{
+		STATE_ENABLED = 0,
+		STATE_DISABLED,
+
+		NUM_STATES
+	};
+
+	CTeamBitmapImage m_TeamImage[ NUM_STATES ];
+};
+
+//-----------------------------------------------------------------------------
+//
+// A standard minimap renderable that displays a bitmap that changes when team changes
+//
+//-----------------------------------------------------------------------------
+DECLARE_MINIMAP_FACTORY( CMinimapObjectTunnelPanel, "minimap_obj_tunnel_panel" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pKeyValues - 
+//			pInitData - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CMinimapObjectTunnelPanel::Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData )
+{
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	// Load viewcone material
+	KeyValues *enabled = pKeyValues->FindKey( "EnabledImage" );
+	if ( enabled )
+	{
+		if ( !m_TeamImage[ STATE_ENABLED ].Init( this, enabled, pInitData->m_pEntity ) )
+			return false;
+	}
+
+	KeyValues *disabled = pKeyValues->FindKey( "DisabledImage" );
+	if ( disabled )
+	{
+		if ( !m_TeamImage[ STATE_DISABLED ].Init( this, disabled, pInitData->m_pEntity ) )
+			return false;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMinimapObjectTunnelPanel::Paint()
+{
+	// Draw the view cone
+	C_BaseEntity *pEntity = GetEntity();
+	Assert( pEntity );
+
+	if ( gHUD.IsHidden( HIDEHUD_MISCSTATUS ) )
+		return;
+
+	if ( !pEntity->IsBaseObject() )
+		return;
+
+	C_BaseObject *obj = static_cast< C_BaseObject * >( pEntity );
+	Assert( obj );
+
+	bool enabled = !obj->IsDisabled();
+	int image = enabled ? STATE_ENABLED : STATE_DISABLED;
+
+	if (!m_bClipToMap)
+	{
+		g_pMatSystemSurface->DisableClipping( true );
+	}
+	m_TeamImage[ image ].SetAlpha( ComputePanelAlpha() );
+	m_TeamImage[ image ].Paint();
+	g_pMatSystemSurface->DisableClipping( false );
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_obj_vehicleboost.cpp b/game/client/tf2/c_obj_vehicleboost.cpp
new file mode 100644
index 0000000..652015b
--- /dev/null
+++ b/game/client/tf2/c_obj_vehicleboost.cpp
@@ -0,0 +1,40 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud.h"
+#include "commanderoverlay.h"
+#include "tf_obj_baseupgrade_shared.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectVehicleBoost : public C_BaseObjectUpgrade
+{
+
+	DECLARE_CLASS( C_ObjectVehicleBoost, C_BaseObjectUpgrade );
+
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectVehicleBoost();
+
+private:
+
+	C_ObjectVehicleBoost( const C_ObjectVehicleBoost& ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjectVehicleBoost, DT_ObjectVehicleBoost, CObjectVehicleBoost )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectVehicleBoost::C_ObjectVehicleBoost()
+{
+}
+
diff --git a/game/client/tf2/c_objectsentrygun.cpp b/game/client/tf2/c_objectsentrygun.cpp
new file mode 100644
index 0000000..9d47a76
--- /dev/null
+++ b/game/client/tf2/c_objectsentrygun.cpp
@@ -0,0 +1,558 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CObjectSentrygun
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "bone_setup.h"
+#include "CommanderOverlay.h"
+#include "c_baseobject.h"
+#include "C_Obj_SentryGun.h"
+#include "tf_shareddefs.h"
+#include "c_basetfplayer.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Button.h>
+
+inline float UTIL_AngleMod(float a)
+{
+	return anglemod(a);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Base Sentrygun
+//-----------------------------------------------------------------------------
+BEGIN_RECV_TABLE_NOBASE(C_ObjectSentrygun, DT_SentrygunTeamOnlyVars)
+	RecvPropInt(RECVINFO( m_iAmmo )),
+END_RECV_TABLE()
+
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectSentrygun, DT_ObjectSentrygun, CObjectSentrygun)
+	RecvPropInt( RECVINFO( m_iBaseTurnRate ) ),
+	RecvPropEHandle(RECVINFO(m_hEnemy)),
+	RecvPropDataTable( "teamonly", 0, 0, &REFERENCE_RECV_TABLE( DT_SentrygunTeamOnlyVars )),
+	RecvPropInt(RECVINFO(m_bTurtled)),
+ 	RecvPropInt( RECVINFO( m_nAnimationParity ) ),
+	RecvPropInt( RECVINFO( m_nOrientationParity ) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_ObjectSentrygun::C_ObjectSentrygun()
+{
+	m_fBoneXRotator = 0;
+	m_fBoneYRotator = 0;
+	m_iAmmo = 0;
+	m_bTurtled = false;
+	m_flStartedTurtlingAt = 0;
+	m_flStartedUnTurtlingAt = 0;
+
+	SetViewOffset( Vector(0,0,22) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectSentrygun::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+	ENTITY_PANEL_ACTIVATE( "sentrygun", !bDormant );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_ObjectSentrygun::DrawModel( int flags )
+{
+	float flRealOriginZ = GetLocalOrigin().z;
+
+	// If we're turtling, slide the model into the ground
+	if ( m_bTurtled )
+	{
+		// How far down are we?
+		float flTime = MIN( gpGlobals->curtime - m_flStartedTurtlingAt, SENTRY_TURTLE_TIME );
+		float flPercent = 1 - (SENTRY_TURTLE_TIME - flTime) / SENTRY_TURTLE_TIME;
+
+		// FIXME: This is totally wrong!!!
+		Vector vNewOrigin = GetLocalOrigin();
+		vNewOrigin.z -= (CollisionProp()->OBBSize().z * flPercent);
+		SetLocalOrigin( vNewOrigin );
+		InvalidateBoneCache();
+	}
+	else if ( !m_bTurtled )
+	{
+		if ( m_flStartedUnTurtlingAt )
+		{
+			float flTime = MIN( gpGlobals->curtime - m_flStartedUnTurtlingAt, SENTRY_TURTLE_TIME );
+			float flPercent = (SENTRY_TURTLE_TIME - flTime) / SENTRY_TURTLE_TIME;
+			
+		// FIXME: This is totally wrong!!!
+			Vector vNewOrigin = GetLocalOrigin();
+			vNewOrigin.z -= (CollisionProp()->OBBSize().z * flPercent);
+			SetLocalOrigin( vNewOrigin );
+			InvalidateBoneCache();
+
+			// Fully unturtled?
+			if ( flTime >= SENTRY_TURTLE_TIME )
+			{
+				m_flStartedUnTurtlingAt = 0;
+			}
+		}
+	}
+
+	int drawn = BaseClass::DrawModel( flags );
+	SetLocalOriginDim( Z_INDEX, flRealOriginZ );
+
+	return drawn;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectSentrygun::PreDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PreDataUpdate( updateType );
+
+	m_bLastTurtled = m_bTurtled;
+	m_nLastAnimationParity = m_nAnimationParity;
+	m_angPrevLocalAngles = GetLocalAngles();
+	m_nPrevOrientationParity = 	m_nOrientationParity;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectSentrygun::PostDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PostDataUpdate( updateType );
+
+	if ( m_bLastTurtled != m_bTurtled )
+	{
+		if ( m_bTurtled )
+		{
+			m_flStartedTurtlingAt = gpGlobals->curtime;
+			m_flStartedUnTurtlingAt = 0;
+		}
+		else
+		{
+			m_flStartedUnTurtlingAt = gpGlobals->curtime;
+			m_flStartedTurtlingAt = 0;
+		}
+	}
+
+	if ( m_nLastAnimationParity != m_nAnimationParity )
+ 	{
+ 		SetCycle( 0.0f );
+ 	}
+
+	bool changed = false;
+	QAngle angleDiff;
+	angleDiff = ( GetAbsAngles() - m_angPrevLocalAngles );
+	for (int i = 0;i < 3; i++ )
+	{
+		angleDiff[i] = UTIL_AngleMod( angleDiff[ i ] );
+	}
+
+	if ( angleDiff.Length() > 0.1f )
+	{
+		changed = true;
+	}
+	if ( updateType == DATA_UPDATE_CREATED || changed )
+	{
+		// Orient it
+		m_vecCurAngles.y = UTIL_AngleMod( GetLocalAngles().y );
+		RecomputeOrientation();
+	}
+	else if ( m_nPrevOrientationParity != m_nOrientationParity )
+	{
+		if ( changed )
+		{
+			RecomputeOrientation();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectSentrygun::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		// Start thinking (Baseclass stops it)
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectSentrygun::FinishedBuilding( void )
+{
+	BaseClass::FinishedBuilding();
+
+	EmitSound( "ObjectSentrygun.Activate" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectSentrygun::GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS])
+{
+	studiohdr_t *pModel = modelinfo->GetStudiomodel( GetModel() );
+
+	// When yaw preview is on,
+	if (!IsPreviewingYaw())
+	{
+		Studio_SetController(pModel, 0, m_fBoneXRotator, controllers[0]);
+	}
+	else
+	{
+		// Bone rotation == 0 here to make it exactly match the preview
+		Studio_SetController(pModel, 0, 0, controllers[0]);
+	}
+
+	Studio_SetController(pModel, 1, m_fBoneYRotator, controllers[1]);
+	Studio_SetController(pModel, 2, m_fBoneYRotator, controllers[2]);
+	Studio_SetController(pModel, 3, m_fBoneYRotator, controllers[3]);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This is called to get the initial builder yaw...
+//-----------------------------------------------------------------------------
+float C_ObjectSentrygun::GetInitialBuilderYaw()
+{
+	// Take the current rotation into account
+	return GetAbsAngles().y + m_fBoneXRotator;
+}
+
+//-----------------------------------------------------------------------------
+// Called when a rotation happens
+//-----------------------------------------------------------------------------
+void C_ObjectSentrygun::RecomputeOrientation( )
+{
+	m_iRightBound = UTIL_AngleMod( m_vecCurAngles.y - 50);
+	m_iLeftBound = UTIL_AngleMod( m_vecCurAngles.y + 50);
+	if ( m_iRightBound > m_iLeftBound )
+	{
+		m_iRightBound = m_iLeftBound;
+		m_iLeftBound = UTIL_AngleMod( m_vecCurAngles.y - 50);
+	}
+
+	// Start it rotating
+	m_vecGoalAngles.y = m_iRightBound;;
+	m_vecGoalAngles.x = m_vecCurAngles.x = 0;
+
+	m_fBoneXRotator = 0.0f;
+	m_fBoneYRotator = 0.0f;
+
+	m_bTurningRight = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle movement of the turret
+//-----------------------------------------------------------------------------
+bool C_ObjectSentrygun::MoveTurret(void)
+{
+	bool bMoved = 0;
+
+	float turnrate = (float)(m_iBaseTurnRate) * 10.0f;
+	turnrate *= gpGlobals->frametime;
+
+	// any x movement?
+	if ( m_vecCurAngles.x != m_vecGoalAngles.x )
+	{
+		float flDir = m_vecGoalAngles.x > m_vecCurAngles.x ? 1 : -1 ;
+
+		m_vecCurAngles.x += 0.1 * (turnrate * 5) * flDir;
+
+		// if we started below the goal, and now we're past, peg to goal
+		if (flDir == 1)
+		{
+			if (m_vecCurAngles.x > m_vecGoalAngles.x)
+				m_vecCurAngles.x = m_vecGoalAngles.x;
+		} 
+		else
+		{
+			if (m_vecCurAngles.x < m_vecGoalAngles.x)
+				m_vecCurAngles.x = m_vecGoalAngles.x;
+		}
+
+		m_fBoneYRotator = m_vecCurAngles.x;
+
+		bMoved = 1;
+	}
+
+	if ( m_vecCurAngles.y != m_vecGoalAngles.y )
+	{
+		float flDir = m_vecGoalAngles.y > m_vecCurAngles.y ? 1 : -1 ;
+		float flDist = fabs(m_vecGoalAngles.y - m_vecCurAngles.y);
+		bool bReversed = false;
+		
+		if (flDist > 180)
+		{
+			flDist = 360 - flDist;
+			flDir = -flDir;
+			bReversed = true;
+		}
+
+		if (m_hEnemy == NULL )
+		{
+			if (flDist > 30)
+			{
+				if (m_fTurnRate < turnrate * 20)
+				{
+					m_fTurnRate += turnrate;
+				}
+			}
+			else
+			{
+				// Slow down
+				if ( m_fTurnRate > (turnrate * 5) )
+					m_fTurnRate -= turnrate;
+			}
+		}
+		else
+		{
+			// When tracking enemies, move faster and don't slow
+			if (flDist > 30)
+			{
+				if (m_fTurnRate < turnrate * 30)
+				{
+					m_fTurnRate += turnrate * 3;
+				}
+			}
+		}
+
+		m_vecCurAngles.y += 0.1 * m_fTurnRate * flDir;
+
+		// if we passed over the goal, peg right to it now
+		if (flDir == -1)
+		{
+			if ( (bReversed == false && m_vecGoalAngles.y > m_vecCurAngles.y) || (bReversed == true && m_vecGoalAngles.y < m_vecCurAngles.y) )
+				m_vecCurAngles.y = m_vecGoalAngles.y;
+		} 
+		else
+		{
+			if ( (bReversed == false && m_vecGoalAngles.y < m_vecCurAngles.y) || (bReversed == true && m_vecGoalAngles.y > m_vecCurAngles.y) )
+				m_vecCurAngles.y = m_vecGoalAngles.y;
+		}
+
+		if (m_vecCurAngles.y < 0)
+			m_vecCurAngles.y += 360;
+		else if (m_vecCurAngles.y >= 360)
+			m_vecCurAngles.y -= 360;
+
+		if (flDist < (0.05 * turnrate))
+			m_vecCurAngles.y = m_vecGoalAngles.y;
+
+		m_fBoneXRotator = m_vecCurAngles.y - UTIL_AngleMod( GetAbsAngles().y );
+
+		bMoved = 1;
+	}
+
+	if ( !bMoved || !m_fTurnRate )
+		m_fTurnRate = turnrate;
+
+	if ( bMoved )
+	{
+		NetworkStateChanged();
+	}
+
+	return bMoved;
+}
+
+void C_ObjectSentrygun::ClientThink( void )
+{
+	// Turtling sentryguns don't think
+	if ( IsTurtled() )
+		return;
+
+	if ( IsPlacing() || IsBuilding() )
+		return;
+
+
+	if ( m_hEnemy != NULL )
+	{
+		// Figure out where we're firing at
+		Vector vecMid = EyePosition();
+		Vector vecFireTarget = m_hEnemy->WorldSpaceCenter(); //  + vecMid; // BodyTarget( vecMid );
+		Vector vecDirToEnemy = vecFireTarget - vecMid;
+		QAngle angToTarget;
+		VectorAngles(vecDirToEnemy, angToTarget);
+		
+		angToTarget.y = UTIL_AngleMod( angToTarget.y );
+		if (angToTarget.x < -180)
+			angToTarget.x += 360;
+		if (angToTarget.x > 180)
+			angToTarget.x -= 360;
+
+		// now all numbers should be in [1...360]
+		// pin to turret limitations to [-50...50]
+		if (angToTarget.x > 50)
+			angToTarget.x = 50;
+		else if (angToTarget.x < -50)
+			angToTarget.x = -50;
+
+		m_vecGoalAngles.y = angToTarget.y;
+		m_vecGoalAngles.x = angToTarget.x;
+
+		MoveTurret();
+		return;
+	}
+
+	// Rotate
+	if ( !MoveTurret() )
+	{
+		// Play a sound occasionally
+		if ( random->RandomFloat(0, 1) < 0.02 )
+		{
+			EmitSound( "ObjectSentrygun.Idle" );
+		}
+
+		// Switch rotation direction
+		if (m_bTurningRight)
+		{
+			m_bTurningRight = false;
+			m_vecGoalAngles.y = m_iLeftBound;
+		}
+		else
+		{
+			m_bTurningRight = true;
+			m_vecGoalAngles.y = m_iRightBound;
+		}
+
+		// Randomly look up and down a bit
+		if ( random->RandomFloat(0, 1) < 0.3 )
+		{
+			m_vecGoalAngles.x = (int)random->RandomFloat(-10,10);
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CSentrygunControlPanel : public CRotatingObjectControlPanel
+{
+	DECLARE_CLASS( CSentrygunControlPanel, CRotatingObjectControlPanel );
+
+public:
+	CSentrygunControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+	void		 AddAmmo( void );
+
+private:
+	vgui::Label		*m_pAmmoLabel;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CSentrygunControlPanel, "sentrygun_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CSentrygunControlPanel::CSentrygunControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CSentrygunControlPanel" ) 
+{
+}
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CSentrygunControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pAmmoLabel = new vgui::Label( this, "AmmoReadout", "" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CSentrygunControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+	
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_ObjectSentrygun*>(pObj) );
+	C_ObjectSentrygun *pSentrygun = static_cast<C_ObjectSentrygun*>(pObj);
+
+	char buf[256];
+	int iAmmo = pSentrygun->GetAmmoLeft();
+	if (iAmmo > 0)
+	{
+		Q_snprintf( buf, sizeof( buf ), "%d rounds left", iAmmo );
+	}
+	else
+	{
+		Q_snprintf( buf, sizeof( buf ), "OUT OF AMMO" );
+	}
+	m_pAmmoLabel->SetText( buf );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle ammo input to the sentrygun
+//-----------------------------------------------------------------------------
+void CSentrygunControlPanel::AddAmmo( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "addammo" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CSentrygunControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "AddAmmo", 7))
+	{
+		AddAmmo();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
+
+
+//======================================================================================================
+// SENTRYGUN TYPES
+//======================================================================================================
+// Purpose: Plasma sentrygun
+//-----------------------------------------------------------------------------
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectSentrygunPlasma, DT_ObjectSentrygunPlasma, CObjectSentrygunPlasma)
+END_RECV_TABLE()
+
+C_ObjectSentrygunPlasma::C_ObjectSentrygunPlasma()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Rocket launcher sentrygun
+//-----------------------------------------------------------------------------
+IMPLEMENT_CLIENTCLASS_DT(C_ObjectSentrygunRocketlauncher, DT_ObjectSentrygunRocketlauncher, CObjectSentrygunRocketlauncher)
+END_RECV_TABLE()
+
+C_ObjectSentrygunRocketlauncher::C_ObjectSentrygunRocketlauncher()
+{
+}
+
+
diff --git a/game/client/tf2/c_order.cpp b/game/client/tf2/c_order.cpp
new file mode 100644
index 0000000..4309e63
--- /dev/null
+++ b/game/client/tf2/c_order.cpp
@@ -0,0 +1,462 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client Side COrder class
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud_orders.h"
+#include "c_order.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+#include "minimap_trace.h"
+#include "VGuiMatSurface/IMatSystemSurface.h"
+#include "c_func_resource.h"
+#include "tf_shareddefs.h"
+#include "c_baseobject.h"
+#include "tf_hints.h"
+#include "hud.h"
+#include "c_basetfplayer.h"
+#include "c_tf_hintmanager.h"
+#include "clientmode_tfnormal.h"
+
+#define NEW_ORDER_ANIM_DURATION		1.0f
+#define NEW_ORDERS_RIGHT			XRES(640-8)
+#define NEW_ORDERS_LEFT				XRES(8)
+#define NEW_ORDERS_WIDTH			(ORDERS_RIGHT - NEW_ORDERS_LEFT)	//(NEW_ORDERS_RIGHT - ORDERS_LEFT)
+
+
+class COrderLabel : public vgui::Label
+{
+public:
+							COrderLabel( vgui::Panel *pParent, const char *pPanelName, const char *pText )
+								: vgui::Label( pParent, pPanelName, pText )
+							{
+							}
+
+	virtual void	OnThink()
+	{
+		BaseClass::OnThink();
+
+		// Resize?
+		int x, y, w, h;
+		if( m_flAnimCounter < NEW_ORDER_ANIM_DURATION )
+		{
+			int wantedWidth, dummy;
+			GetContentSize( wantedWidth, dummy );
+			wantedWidth += 10;
+			
+			float flPercent = m_flAnimCounter / NEW_ORDER_ANIM_DURATION;
+			int newWidth = (int)(NEW_ORDERS_WIDTH + (wantedWidth - NEW_ORDERS_WIDTH) * flPercent);
+		
+			GetBounds( x, y, w, h );
+			
+			m_flAnimCounter += gpGlobals->frametime;
+			if( m_flAnimCounter >= NEW_ORDER_ANIM_DURATION )
+			{
+				SetBounds( ORDERS_RIGHT - wantedWidth, y, wantedWidth, h );
+			}
+			else
+			{
+				SetBounds( ORDERS_RIGHT - newWidth, y, newWidth, h );
+			}
+		}
+	}
+
+	virtual void	PaintBackground()
+	{
+		// BaseClass::PaintBackground();
+
+		// Draw our background.
+		int x, y, w, h;
+		GetBounds( x, y, w, h );
+
+		vgui::surface()->DrawSetColor( Color( 0, 0, 0, 160 ) );
+		vgui::surface()->DrawFilledRect( 0, 0, w, h );
+
+		vgui::surface()->DrawSetColor( Color( 63, 63, 63, 255 ) );
+		vgui::surface()->DrawOutlinedRect( 0, 0, w, h );
+	}
+
+public:
+	float	m_flAnimCounter;
+};
+
+
+class CMinimapOrderPanel : public CMinimapTraceBitmapPanel
+{
+	DECLARE_CLASS( CMinimapOrderPanel, CMinimapTraceBitmapPanel );
+
+public:
+	CMinimapOrderPanel( vgui::Panel *parent, const char *panelName ) 
+		: BaseClass( parent, "CMinimapOrderPanel" )
+	{
+	}
+	virtual bool Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void Paint( );
+
+private:
+	C_Order *m_pOrder;
+};
+
+
+DECLARE_MINIMAP_FACTORY( CMinimapOrderPanel, "minimap_order_panel" );
+
+bool CMinimapOrderPanel::Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData )
+{
+	m_pOrder = dynamic_cast<C_Order*>(pInitData->m_pEntity);
+	if (!m_pOrder)
+		return false;
+
+	if (!BaseClass::Init( pKeyValues, pInitData ))
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// called when we're ticked...
+//-----------------------------------------------------------------------------
+void CMinimapOrderPanel::OnTick()
+{
+	// NOTE: Do *not* chain down the the base OnTick; it's going to do 
+	// a totally different computation that will conflict with ours
+	Assert( m_pOrder );
+	if( m_pOrder->GetTarget() <= 0 )
+	{
+		SetVisible(false);
+		return;
+	}
+
+	C_BaseEntity *pTarget = ClientEntityList().GetEnt( m_pOrder->GetTarget() );
+	if( !pTarget )
+	{
+		SetVisible(false);
+		return;
+	}
+
+	SetEntity( pTarget );
+
+	// Now that we're attached to the correct target, compute position!
+	BaseClass::OnTick();
+}
+
+
+void CMinimapOrderPanel::Paint( )
+{
+	Assert( m_pOrder );
+
+	if( m_pOrder->GetTarget() <= 0 )
+		return;
+
+	C_BaseEntity *pTarget = ClientEntityList().GetEnt( m_pOrder->GetTarget() );
+	if( !pTarget )
+		return;
+
+	g_pMatSystemSurface->DisableClipping( true );
+	
+	static float flStrobeDuration = 0.5;
+	float flShade = sin( gpGlobals->curtime * M_PI / flStrobeDuration ) * 0.5f + 0.5f;
+
+	Color color(255*flShade, 0, 0, 255); 
+	m_Image.SetColor( color );
+	m_Image.Paint();
+
+	g_pMatSystemSurface->DisableClipping( false );
+}
+
+
+
+enum GetTargetDescriptionType_t
+{
+	GETDESC_RESOURCEZONE=0,
+	GETDESC_OBJECT
+};
+
+char* GetTargetDescription( int entindex, GetTargetDescriptionType_t type )
+{
+	static char szDesc[128];
+	szDesc[0]=0;
+
+	// Order target
+	if ( entindex )
+	{
+		C_BaseEntity *pEnt = cl_entitylist->GetEnt( entindex );
+		if ( pEnt )
+		{
+			if( type == GETDESC_RESOURCEZONE )
+			{
+				C_ResourceZone *pZone = dynamic_cast<C_ResourceZone*>(pEnt);
+				if ( pZone )
+					Q_strncpy( szDesc, pZone->GetTargetDescription(), sizeof( szDesc ) );
+			}
+			else if( type == GETDESC_OBJECT )
+			{
+				C_BaseObject *pObj = dynamic_cast<C_BaseObject*>( pEnt );
+				if( pObj )
+					Q_strncpy( szDesc, pObj->GetTargetDescription(), sizeof( szDesc ) );
+			}
+		}
+	}
+
+	return szDesc;
+}
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_Order, DT_Order, COrder)
+	RecvPropInt( RECVINFO(m_iPriority) ),
+	RecvPropInt( RECVINFO(m_iOrderType) ),
+	RecvPropInt( RECVINFO(m_iTargetEntIndex) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_Order::C_Order( void )
+{
+	m_nHintID = TF_HINT_UNDEFINED;
+
+	m_pNameLabel = NULL;
+	
+	CONSTRUCT_MINIMAP_PANEL( "minimap_order", MINIMAP_PERSONAL_ORDERS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_Order::~C_Order( void )
+{
+	RemoveOrder();
+
+	if( C_BaseTFPlayer::GetLocalPlayer() )
+		C_BaseTFPlayer::GetLocalPlayer()->RemoveOrderTarget();
+	
+
+	if ( m_nHintID != TF_HINT_UNDEFINED )
+	{
+		DestroyGlobalHint( m_nHintID );
+	}
+}
+
+void C_Order::ClientThink( void )
+{
+	BaseClass::ClientThink();
+
+	if ( m_nHintID != TF_HINT_UNDEFINED )
+	{
+		switch ( m_iOrderType )
+		{
+		case ORDER_REPAIR:
+			m_nHintID = TF_HINT_REPAIROBJECT;
+			break;
+		default:
+			break;
+		}
+	}
+
+	if ( m_nHintID != TF_HINT_UNDEFINED )
+	{
+		CreateGlobalHint_Panel( m_pNameLabel, m_nHintID, NULL, index );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_Order::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	pPlayer->SetPersonalOrder( this );
+
+	// Update us if we've changed
+	if( updateType == DATA_UPDATE_CREATED )
+	{
+		CreateStatus( GetClientModeNormal()->GetViewport() );
+	}
+	else
+	{
+		GetHudOrderList()->RecalculateOrderList();
+		UpdateStatus();
+	}
+	
+	if( m_iTargetEntIndex > 0 )
+	{
+		C_BaseEntity *pTarget = ClientEntityList().GetEnt( m_iTargetEntIndex );
+		m_OverlayPanel.Activate( pTarget, "personal_order", true );
+	}
+
+	if ( (updateType == DATA_UPDATE_CREATED) && ( m_nHintID != TF_HINT_UNDEFINED ) )
+	{
+		// Wait for animation to fly all the way in
+		SetNextClientThink( gpGlobals->curtime + NEW_ORDER_ANIM_DURATION + 0.25f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Clean up a removed order
+//-----------------------------------------------------------------------------
+void C_Order::RemoveOrder( void )
+{
+	m_OverlayPanel.RemoveOverlay();
+
+	DestroyStatus();
+
+	if ( m_pNameLabel )
+	{
+		delete m_pNameLabel;
+		m_pNameLabel = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a text description of this order
+//-----------------------------------------------------------------------------
+void C_Order::GetDescription( char *pDest, int bufferSize )
+{
+	char targetDesc[512];
+	GetTargetDescription( targetDesc, sizeof( targetDesc ) );
+
+	switch ( m_iOrderType )
+	{
+		case ORDER_ATTACK:
+			Q_snprintf( pDest, bufferSize, "Attack %s", targetDesc );
+			break;
+
+		case ORDER_DEFEND:
+			Q_snprintf( pDest, bufferSize, "Defend %s", targetDesc );
+			break;
+
+		case ORDER_CAPTURE:
+			Q_snprintf( pDest, bufferSize, "Capture %s", targetDesc );
+			break;
+
+		default:
+			Q_snprintf( pDest, bufferSize, "INVALID" );
+			break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a text description for the target of this order
+//-----------------------------------------------------------------------------
+void C_Order::GetTargetDescription( char *pDest, int bufferSize )
+{
+	pDest[0] = 0;
+
+	if ( !m_iTargetEntIndex )
+		return;
+
+	C_BaseEntity *pEnt = cl_entitylist->GetEnt( m_iTargetEntIndex );
+	if ( !pEnt )
+		return;
+
+	C_ResourceZone *pZone = dynamic_cast<C_ResourceZone*>(pEnt);
+	if ( pZone )
+	{
+		Q_strncpy( pDest, pZone->GetTargetDescription(), bufferSize );
+	}
+	else
+	{
+		C_BaseObject *pObj = dynamic_cast<C_BaseObject*>( pEnt );
+		if( pObj )
+			Q_strncpy( pDest, pObj->GetTargetDescription(), bufferSize );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Create all elements needed in a status panel for this order
+//-----------------------------------------------------------------------------
+void C_Order::CreateStatus( vgui::Panel *pParent )
+{
+	// If we already have our elements, we're just moving. 
+	if ( m_pNameLabel )
+	{
+		m_pNameLabel->SetParent( pParent );
+	}
+	else
+	{
+		m_pNameLabel = new COrderLabel( pParent, "NameLabel", "Temp" );
+		m_pNameLabel->SetBounds( ORDERS_LEFT, ORDERS_TOP, NEW_ORDERS_WIDTH, ORDERS_ELEMENT_HEIGHT );
+		m_pNameLabel->SetAutoDelete( false );
+		m_pNameLabel->SetPaintBackgroundEnabled( true );
+		m_pNameLabel->SetFgColor( Color( 0, 0, 0, 255 ) );
+		m_pNameLabel->SetContentAlignment( vgui::Label::a_east );
+		m_pNameLabel->SetTextInset( -2, 0 );
+	}
+
+	UpdateStatus();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destroy all elements in the status panel for this order
+//-----------------------------------------------------------------------------
+void C_Order::DestroyStatus( void )
+{
+	if ( m_pNameLabel )
+	{
+		delete m_pNameLabel;
+		m_pNameLabel = NULL;
+	}
+} 
+
+//-----------------------------------------------------------------------------
+// Purpose: Update all elements in the status panel for this order
+//-----------------------------------------------------------------------------
+void C_Order::UpdateStatus( void )
+{
+	if ( m_pNameLabel )
+	{
+		char desc[512];
+		GetDescription( desc, sizeof( desc ) );
+		
+		m_pNameLabel->SetText( desc );
+		m_pNameLabel->m_flAnimCounter = 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this order wants a target reticle created around it's target
+//-----------------------------------------------------------------------------
+bool C_Order::ShouldDrawReticle( void )
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_Order::GetPriority( void )
+{
+	return m_iPriority;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_Order::GetType( void )
+{
+	return m_iOrderType;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_Order::GetTarget( void )
+{
+	return m_iTargetEntIndex;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this order is a personal one for this player
+//-----------------------------------------------------------------------------
+bool C_Order::IsPersonalOrder( void )
+{
+	return (GetPriority() == 0);
+}
+
diff --git a/game/client/tf2/c_order.h b/game/client/tf2/c_order.h
new file mode 100644
index 0000000..b1623c8
--- /dev/null
+++ b/game/client/tf2/c_order.h
@@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client Side COrder class
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_H
+#define C_ORDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Panel.h>
+#include "CommanderOverlay.h"
+#include "hud_minimap.h"
+
+class COrderLabel;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Datatable container class for orders
+//-----------------------------------------------------------------------------
+class C_Order : public C_BaseEntity
+{
+	DECLARE_CLASS( C_Order, C_BaseEntity );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_Order( void );
+	~C_Order( void );
+
+	virtual void	ClientThink( void );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	RemoveOrder( void );
+	virtual void	GetDescription( char *pDest, int bufferSize );
+	virtual void	GetTargetDescription( char *pDest, int bufferSize );
+
+	// Status drawing
+	virtual void	CreateStatus( vgui::Panel *pParent );
+	virtual void	DestroyStatus( void );
+	virtual void	UpdateStatus( void );
+	virtual bool	ShouldDrawReticle( void );
+
+	// Data access
+	int				GetPriority( void );
+	int				GetTarget( void );
+	int				GetType( void );
+	bool			IsPersonalOrder( void );
+
+protected:
+	// Received via datatable
+	int				m_iPriority;
+	int				m_iOrderType;
+	int				m_iTargetEntIndex;
+
+	// Used in status drawing
+	COrderLabel		*m_pNameLabel;
+
+	// Animating panel to show the new order.
+	float			m_flNewOrderHighlightTimer;
+
+	// Hook up the overlay on the tactical map.
+	DECLARE_ENTITY_PANEL();
+	DECLARE_MINIMAP_PANEL();
+
+protected:
+	int				m_nHintID;
+};
+
+
+#endif // C_ORDER_H
diff --git a/game/client/tf2/c_order_assist.cpp b/game/client/tf2/c_order_assist.cpp
new file mode 100644
index 0000000..ab18247
--- /dev/null
+++ b/game/client/tf2/c_order_assist.cpp
@@ -0,0 +1,22 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_assist.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderAssist, DT_OrderAssist, COrderAssist )
+END_RECV_TABLE()
+
+
+void C_OrderAssist::GetDescription( char *pDest, int bufferSize )
+{
+	char targetDesc[512];
+	GetTargetDescription( targetDesc, sizeof( targetDesc ) );
+
+	Q_snprintf( pDest, bufferSize, "Assist %s", targetDesc );
+}
+
diff --git a/game/client/tf2/c_order_assist.h b/game/client/tf2/c_order_assist.h
new file mode 100644
index 0000000..4457c3e
--- /dev/null
+++ b/game/client/tf2/c_order_assist.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_ASSIST_H
+#define C_ORDER_ASSIST_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order_player.h"
+
+
+class C_OrderAssist : public C_OrderPlayer
+{
+public:
+	DECLARE_CLASS( C_OrderAssist, C_OrderPlayer );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_ASSIST_H
diff --git a/game/client/tf2/c_order_buildsentrygun.cpp b/game/client/tf2/c_order_buildsentrygun.cpp
new file mode 100644
index 0000000..0a536d8
--- /dev/null
+++ b/game/client/tf2/c_order_buildsentrygun.cpp
@@ -0,0 +1,26 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_buildsentrygun.h"
+#include "tf_hints.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderBuildSentryGun, DT_OrderBuildSentryGun, COrderBuildSentryGun )
+END_RECV_TABLE()
+
+
+C_OrderBuildSentryGun::C_OrderBuildSentryGun()
+{
+	m_nHintID = TF_HINT_BUILDSENTRYGUN_PLASMA;
+}
+
+
+void C_OrderBuildSentryGun::GetDescription( char *pDest, int bufferSize )
+{
+	Q_strncpy( pDest, "Build Sentry Gun To Protect Object", bufferSize );
+}
+
diff --git a/game/client/tf2/c_order_buildsentrygun.h b/game/client/tf2/c_order_buildsentrygun.h
new file mode 100644
index 0000000..04c7ffa
--- /dev/null
+++ b/game/client/tf2/c_order_buildsentrygun.h
@@ -0,0 +1,34 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_BUILDSENTRYGUN_H
+#define C_ORDER_BUILDSENTRYGUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order.h"
+
+
+class C_OrderBuildSentryGun : public C_Order
+{
+public:
+	DECLARE_CLASS( C_OrderBuildSentryGun, C_Order );
+	DECLARE_CLIENTCLASS();
+
+					C_OrderBuildSentryGun();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_BUILDSENTRYGUN_H
diff --git a/game/client/tf2/c_order_buildshieldwall.cpp b/game/client/tf2/c_order_buildshieldwall.cpp
new file mode 100644
index 0000000..1139917
--- /dev/null
+++ b/game/client/tf2/c_order_buildshieldwall.cpp
@@ -0,0 +1,19 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_buildshieldwall.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderBuildShieldWall, DT_OrderBuildShieldWall, COrderBuildShieldWall )
+END_RECV_TABLE()
+
+
+void C_OrderBuildShieldWall::GetDescription( char *pDest, int bufferSize )
+{
+	Q_strncpy( pDest, "Build Shield Wall To Protect Object", bufferSize );
+}
+
diff --git a/game/client/tf2/c_order_buildshieldwall.h b/game/client/tf2/c_order_buildshieldwall.h
new file mode 100644
index 0000000..b22f3b9
--- /dev/null
+++ b/game/client/tf2/c_order_buildshieldwall.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_BUILDSHIELDWALL_H
+#define C_ORDER_BUILDSHIELDWALL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order.h"
+
+
+class C_OrderBuildShieldWall : public C_Order
+{
+public:
+	DECLARE_CLASS( C_OrderBuildShieldWall, C_Order );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_BUILDSHIELDWALL_H
diff --git a/game/client/tf2/c_order_heal.cpp b/game/client/tf2/c_order_heal.cpp
new file mode 100644
index 0000000..555fb47
--- /dev/null
+++ b/game/client/tf2/c_order_heal.cpp
@@ -0,0 +1,22 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_heal.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderHeal, DT_OrderHeal, COrderHeal )
+END_RECV_TABLE()
+
+
+void C_OrderHeal::GetDescription( char *pDest, int bufferSize )
+{
+	char targetDesc[512];
+	GetTargetDescription( targetDesc, sizeof( targetDesc ) );
+
+	Q_snprintf( pDest, bufferSize, "Heal %s", targetDesc );
+}
+
diff --git a/game/client/tf2/c_order_heal.h b/game/client/tf2/c_order_heal.h
new file mode 100644
index 0000000..a1addc6
--- /dev/null
+++ b/game/client/tf2/c_order_heal.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_HEAL_H
+#define C_ORDER_HEAL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order_player.h"
+
+
+class C_OrderHeal : public C_OrderPlayer
+{
+public:
+	DECLARE_CLASS( C_OrderHeal, C_OrderPlayer );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_HEAL_H
diff --git a/game/client/tf2/c_order_killmortarguy.cpp b/game/client/tf2/c_order_killmortarguy.cpp
new file mode 100644
index 0000000..682a2f2
--- /dev/null
+++ b/game/client/tf2/c_order_killmortarguy.cpp
@@ -0,0 +1,22 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_killmortarguy.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderKillMortarGuy, DT_OrderKillMortarGuy, COrderKillMortarGuy )
+END_RECV_TABLE()
+
+
+void C_OrderKillMortarGuy::GetDescription( char *pDest, int bufferSize )
+{
+	char targetDesc[512];
+	GetTargetDescription( targetDesc, sizeof( targetDesc ) );
+
+	Q_snprintf( pDest, bufferSize, "Kill Mortar Guy: %s", targetDesc );
+}
+
diff --git a/game/client/tf2/c_order_killmortarguy.h b/game/client/tf2/c_order_killmortarguy.h
new file mode 100644
index 0000000..c3932ce
--- /dev/null
+++ b/game/client/tf2/c_order_killmortarguy.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_KILLMORTARGUY_H
+#define C_ORDER_KILLMORTARGUY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order_player.h"
+
+
+class C_OrderKillMortarGuy : public C_OrderPlayer
+{
+public:
+	DECLARE_CLASS( C_OrderKillMortarGuy, C_OrderPlayer );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_KILLMORTARGUY_H
diff --git a/game/client/tf2/c_order_mortar_attack.cpp b/game/client/tf2/c_order_mortar_attack.cpp
new file mode 100644
index 0000000..67795a7
--- /dev/null
+++ b/game/client/tf2/c_order_mortar_attack.cpp
@@ -0,0 +1,22 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_mortar_attack.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderMortarAttack, DT_OrderMortarAttack, COrderMortarAttack )
+END_RECV_TABLE()
+
+
+void C_OrderMortarAttack::GetDescription( char *pDest, int bufferSize )
+{
+	char targetDesc[512];
+	GetTargetDescription( targetDesc, sizeof( targetDesc ) );
+
+	Q_snprintf( pDest, bufferSize, "Attack %s with mortar", targetDesc );
+}
+
diff --git a/game/client/tf2/c_order_mortar_attack.h b/game/client/tf2/c_order_mortar_attack.h
new file mode 100644
index 0000000..9502d6a
--- /dev/null
+++ b/game/client/tf2/c_order_mortar_attack.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_MORTAR_ATTACK_H
+#define C_ORDER_MORTAR_ATTACK_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order.h"
+
+
+class C_OrderMortarAttack : public C_Order
+{
+public:
+	DECLARE_CLASS( C_OrderMortarAttack, C_Order );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_MORTAR_ATTACK_H
diff --git a/game/client/tf2/c_order_player.cpp b/game/client/tf2/c_order_player.cpp
new file mode 100644
index 0000000..180c390
--- /dev/null
+++ b/game/client/tf2/c_order_player.cpp
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_player.h"
+#include "cliententitylist.h"
+#include "c_basetfplayer.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderPlayer, DT_OrderPlayer, COrderPlayer )
+END_RECV_TABLE()
+
+
+void C_OrderPlayer::GetTargetDescription( char *pDest, int bufferSize )
+{
+	pDest[0] = 0;
+	
+	// Order target
+	if ( !m_iTargetEntIndex )
+		return;
+
+	C_BaseEntity *pEnt = cl_entitylist->GetEnt(m_iTargetEntIndex);
+	if ( !pEnt )
+		return;
+
+	C_BaseTFPlayer *pPlayer = dynamic_cast<C_BaseTFPlayer*>(pEnt);
+	if ( pPlayer )
+	{
+		pPlayer->GetTargetDescription( pDest, bufferSize );
+	}
+}
+
+
+
+
diff --git a/game/client/tf2/c_order_player.h b/game/client/tf2/c_order_player.h
new file mode 100644
index 0000000..54b8961
--- /dev/null
+++ b/game/client/tf2/c_order_player.h
@@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_PLAYER_H
+#define C_ORDER_PLAYER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order.h"
+
+
+// Orders that point at players.
+class C_OrderPlayer : public C_Order
+{
+public:
+	DECLARE_CLASS( C_OrderPlayer, C_Order );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetTargetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_PLAYER_H
diff --git a/game/client/tf2/c_order_repair.cpp b/game/client/tf2/c_order_repair.cpp
new file mode 100644
index 0000000..3ad2af7
--- /dev/null
+++ b/game/client/tf2/c_order_repair.cpp
@@ -0,0 +1,19 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_repair.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderRepair, DT_OrderRepair, COrderRepair )
+END_RECV_TABLE()
+
+
+void C_OrderRepair::GetDescription( char *pDest, int bufferSize )
+{
+	Q_strncpy( pDest, "Repair Structure", bufferSize );
+}
+
diff --git a/game/client/tf2/c_order_repair.h b/game/client/tf2/c_order_repair.h
new file mode 100644
index 0000000..ffb9d8c
--- /dev/null
+++ b/game/client/tf2/c_order_repair.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_REPAIR_H
+#define C_ORDER_REPAIR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order.h"
+
+
+class C_OrderRepair : public C_Order
+{
+public:
+	DECLARE_CLASS( C_OrderRepair, C_Order );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_REPAIR_H
diff --git a/game/client/tf2/c_order_resourcepump.cpp b/game/client/tf2/c_order_resourcepump.cpp
new file mode 100644
index 0000000..5e2e90d
--- /dev/null
+++ b/game/client/tf2/c_order_resourcepump.cpp
@@ -0,0 +1,27 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_order_resourcepump.h"
+#include "tf_hints.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderResourcePump, DT_OrderResourcePump, COrderResourcePump )
+END_RECV_TABLE()
+
+
+C_OrderResourcePump::C_OrderResourcePump()
+{
+	m_nHintID = TF_HINT_BUILDRESOURCEPUMP;
+}
+
+
+void C_OrderResourcePump::GetDescription( char *pDest, int bufferSize )
+{
+	Q_strncpy( pDest, "Build Resource Pump", bufferSize );
+}
+
diff --git a/game/client/tf2/c_order_resourcepump.h b/game/client/tf2/c_order_resourcepump.h
new file mode 100644
index 0000000..11a24d8
--- /dev/null
+++ b/game/client/tf2/c_order_resourcepump.h
@@ -0,0 +1,34 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_RESOURCEPUMP_H
+#define C_ORDER_RESOURCEPUMP_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order.h"
+
+
+class C_OrderResourcePump : public C_Order
+{
+public:
+	DECLARE_CLASS( C_OrderResourcePump, C_Order );
+	DECLARE_CLIENTCLASS();
+
+					C_OrderResourcePump();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_RESOURCEPUMP_H
diff --git a/game/client/tf2/c_order_respawnstation.cpp b/game/client/tf2/c_order_respawnstation.cpp
new file mode 100644
index 0000000..757f218
--- /dev/null
+++ b/game/client/tf2/c_order_respawnstation.cpp
@@ -0,0 +1,19 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_respawnstation.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderRespawnStation, DT_OrderRespawnStation, COrderRespawnStation )
+END_RECV_TABLE()
+
+
+void C_OrderRespawnStation::GetDescription( char *pDest, int bufferSize )
+{
+	Q_strncpy( pDest, "Build Respawn Station Near Object", bufferSize );
+}
+
diff --git a/game/client/tf2/c_order_respawnstation.h b/game/client/tf2/c_order_respawnstation.h
new file mode 100644
index 0000000..f28e72c
--- /dev/null
+++ b/game/client/tf2/c_order_respawnstation.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_RESPAWNSTATION_H
+#define C_ORDER_RESPAWNSTATION_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order_player.h"
+
+
+class C_OrderRespawnStation : public C_Order
+{
+public:
+	DECLARE_CLASS( C_OrderRespawnStation, C_Order );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_RESPAWNSTATION_H
diff --git a/game/client/tf2/c_order_resupply.cpp b/game/client/tf2/c_order_resupply.cpp
new file mode 100644
index 0000000..ca71b93
--- /dev/null
+++ b/game/client/tf2/c_order_resupply.cpp
@@ -0,0 +1,19 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_order_resupply.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_OrderResupply, DT_OrderResupply, COrderResupply )
+END_RECV_TABLE()
+
+
+void C_OrderResupply::GetDescription( char *pDest, int bufferSize )
+{
+	Q_strncpy( pDest, "Build Resupply Station Near Object", bufferSize );
+}
+
diff --git a/game/client/tf2/c_order_resupply.h b/game/client/tf2/c_order_resupply.h
new file mode 100644
index 0000000..0db297a
--- /dev/null
+++ b/game/client/tf2/c_order_resupply.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_ORDER_RESUPPLY_H
+#define C_ORDER_RESUPPLY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_order.h"
+
+
+class C_OrderResupply : public C_Order
+{
+public:
+	DECLARE_CLASS( C_OrderResupply, C_Order );
+	DECLARE_CLIENTCLASS();
+
+
+// C_Order overrides.
+public:
+
+	virtual void	GetDescription( char *pDest, int bufferSize );
+};
+
+
+#endif // C_ORDER_RESUPPLY_H
diff --git a/game/client/tf2/c_ragdoll_shadow.cpp b/game/client/tf2/c_ragdoll_shadow.cpp
new file mode 100644
index 0000000..efb705b
--- /dev/null
+++ b/game/client/tf2/c_ragdoll_shadow.cpp
@@ -0,0 +1,246 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "model_types.h"
+#include "vcollide.h"
+#include "vcollide_parse.h"
+#include "solidsetdefaults.h"
+#include "c_basetfplayer.h"
+#include "bone_setup.h"
+#include "engine/ivmodelinfo.h"
+
+CPhysCollide *PhysCreateBbox( const Vector &mins, const Vector &maxs );
+extern CSolidSetDefaults g_SolidSetup;
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_RagdollShadow : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_RagdollShadow, C_BaseAnimating );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_RagdollShadow( void );
+	~C_RagdollShadow( void );
+
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+
+	virtual void ClientThink( void );
+	virtual int DrawModel( int flags );
+
+public:
+	IPhysicsObject *VPhysicsInitShadow( bool allowPhysicsMovement, bool allowPhysicsRotation );
+	void			VPhysicsSetObject( IPhysicsObject *pPhysics );
+	void			VPhysicsDestroyObject( void );
+
+	int			m_nPlayer;
+	EHANDLE		m_hPlayer;
+
+	IPhysicsObject	*m_pPhysicsObject;
+	IPhysicsSpring		*m_pSpring;
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_RagdollShadow, DT_RagdollShadow, CRagdollShadow )
+	RecvPropInt( RECVINFO( m_nPlayer ) ),
+END_RECV_TABLE()
+
+C_RagdollShadow::C_RagdollShadow( void )
+{
+	m_nPlayer = -1;
+	m_hPlayer = NULL;
+
+	m_pPhysicsObject = NULL;
+	m_pSpring = NULL;
+}
+
+C_RagdollShadow::~C_RagdollShadow( void )
+{
+	VPhysicsDestroyObject();
+
+	delete m_pSpring;
+}
+
+void C_RagdollShadow::VPhysicsDestroyObject( void )
+{
+	if ( m_pPhysicsObject )
+	{
+		physenv->DestroyObject( m_pPhysicsObject );
+		m_pPhysicsObject = NULL;
+	}
+}
+
+// Create a physics thingy based on an existing collision model
+IPhysicsObject *PhysModelCreateCustom( C_BaseEntity *pEntity, const CPhysCollide *pModel, const Vector &origin, const QAngle &angles, const char *props )
+{
+	solid_t solid;
+	solid.params = g_PhysDefaultObjectParams;
+	solid.params.mass = 85.0f;
+	solid.params.inertia = 1e24f;
+	int surfaceProp = -1;
+	if ( props && props[0] )
+	{
+		surfaceProp = physprops->GetSurfaceIndex( props );
+	}
+	solid.params.pGameData = static_cast<void *>(pEntity);
+	IPhysicsObject *pObject = physenv->CreatePolyObject( pModel, surfaceProp, origin, angles, &solid.params );
+	return pObject;
+}
+
+IPhysicsObject *PhysModelCreateRagdoll( C_BaseEntity *pEntity, int modelIndex, const Vector &origin, const QAngle &angles )
+{
+	vcollide_t *pCollide = modelinfo->GetVCollide( modelIndex );
+	if ( !pCollide )
+		return NULL;
+
+	solid_t solid;
+	memset( &solid, 0, sizeof(solid) );
+	solid.params = g_PhysDefaultObjectParams;
+
+	IVPhysicsKeyParser *pParse = physcollision->VPhysicsKeyParserCreate( pCollide->pKeyValues );
+	while ( !pParse->Finished() )
+	{
+		const char *pBlock = pParse->GetCurrentBlockName();
+		if ( !strcmpi( pBlock, "solid" ) )
+		{
+			pParse->ParseSolid( &solid, &g_SolidSetup );
+			break;
+		}
+		else
+		{
+			pParse->SkipBlock();
+		}
+	}
+	physcollision->VPhysicsKeyParserDestroy( pParse );
+
+	// collisions are off by default
+	solid.params.enableCollisions = true;
+
+	int surfaceProp = -1;
+	if ( solid.surfaceprop[0] )
+	{
+		surfaceProp = physprops->GetSurfaceIndex( solid.surfaceprop );
+	}
+	solid.params.pGameData = static_cast<void *>(pEntity);
+	solid.params.pName = "ragdoll_player";
+	IPhysicsObject *pObject = physenv->CreatePolyObject( pCollide->solids[0], surfaceProp, origin, angles, &solid.params );
+	//PhysCheckAdd( pObject, STRING(pEntity->m_iClassname) );
+	return pObject;
+}
+
+void C_RagdollShadow::VPhysicsSetObject( IPhysicsObject *pPhysics )
+{
+	if ( m_pPhysicsObject && pPhysics )
+	{
+		Warning( "C_RagdollShadow::Overwriting physics object!\n" );
+	}
+	m_pPhysicsObject = pPhysics;
+}
+
+
+// This creates a vphysics object with a shadow controller that follows the AI
+IPhysicsObject *C_RagdollShadow::VPhysicsInitShadow( bool allowPhysicsMovement, bool allowPhysicsRotation )
+{
+	CStudioHdr *hdr = GetModelPtr();
+	if ( !hdr )
+	{
+		return NULL;
+	}
+
+	// If this entity already has a physics object, then it should have been deleted prior to making this call.
+	Assert(!m_pPhysicsObject);
+
+	// make sure m_vecOrigin / m_vecAngles are correct
+	const Vector &origin = GetAbsOrigin();
+	QAngle angles = GetAbsAngles();
+	IPhysicsObject *pPhysicsObject = NULL;
+
+	if ( GetSolid() == SOLID_BBOX )
+	{
+		const char *pSurfaceProps = "flesh";
+		if ( GetModelIndex() && modelinfo->GetModelType( GetModel() ) == mod_studio )
+		{
+			pSurfaceProps = Studio_GetDefaultSurfaceProps( hdr );
+		}
+		angles = vec3_angle;
+		CPhysCollide *pCollide = PhysCreateBbox( WorldAlignMins(), WorldAlignMaxs() );
+		if ( !pCollide )
+			return NULL;
+		pPhysicsObject = PhysModelCreateCustom( this, pCollide, origin, angles, pSurfaceProps );
+	}
+	else
+	{
+		pPhysicsObject = PhysModelCreateRagdoll( this, GetModelIndex(), origin, angles );
+	}
+	VPhysicsSetObject( pPhysicsObject );
+	pPhysicsObject->SetShadow( 1e4, 1e4, allowPhysicsMovement, allowPhysicsRotation );
+	pPhysicsObject->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, 0 );
+//	PhysAddShadow( this );
+	return pPhysicsObject;
+}	
+
+void C_RagdollShadow::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Has to happen *after* the client handle is set
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+
+	bool bnewentity = (updateType == DATA_UPDATE_CREATED);
+	if ( bnewentity && ( m_nPlayer != 0 ) )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+
+		Assert( !m_pPhysicsObject );
+
+		C_BaseEntity *pl = static_cast< C_BaseEntity * >( cl_entitylist->GetEnt( m_nPlayer ) );
+		if ( pl )
+		{
+			m_hPlayer = pl;
+		}
+
+		m_pPhysicsObject = VPhysicsInitShadow( true, false );
+	}
+
+	if ( m_pPhysicsObject )
+	{
+		// Create the spring if we don't have one yet
+		if ( !m_pSpring )
+		{
+			C_BaseTFPlayer *pl = static_cast< C_BaseTFPlayer * >( (C_BaseEntity *)m_hPlayer );
+			if ( pl && pl->VPhysicsGetObject() )
+			{
+				springparams_t spring;
+				spring.constant = 15000;
+				spring.damping = 1.0;
+				spring.naturalLength = 0.0f;
+				spring.relativeDamping = 100.0f;
+				VectorCopy( vec3_origin, spring.startPosition );
+				VectorCopy( vec3_origin, spring.endPosition );
+				spring.useLocalPositions = true;
+
+				m_pSpring = physenv->CreateSpring( m_pPhysicsObject, pl->VPhysicsGetObject(), &spring );
+
+				PhysDisableObjectCollisions( m_pPhysicsObject, pl->VPhysicsGetObject() );
+			}
+		}
+
+		m_pPhysicsObject->UpdateShadow( GetAbsOrigin(), GetAbsAngles(), false, 0 );
+	}
+
+}
+
+void C_RagdollShadow::ClientThink( void )
+{
+	BaseClass::ClientThink();
+}
+
+int C_RagdollShadow::DrawModel( int flags )
+{
+//	int drawn = BaseClass::DrawModel( flags );
+//	return drawn;
+	return 0;
+}
diff --git a/game/client/tf2/c_resource_chunk.cpp b/game/client/tf2/c_resource_chunk.cpp
new file mode 100644
index 0000000..ab4acf8
--- /dev/null
+++ b/game/client/tf2/c_resource_chunk.cpp
@@ -0,0 +1,22 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "particles_simple.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ResourceChunk : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_ResourceChunk, C_BaseAnimating );
+public:
+	DECLARE_CLIENTCLASS();
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_ResourceChunk, DT_ResourceChunk, CResourceChunk )
+END_RECV_TABLE()
+
diff --git a/game/client/tf2/c_shield.cpp b/game/client/tf2/c_shield.cpp
new file mode 100644
index 0000000..b404a92
--- /dev/null
+++ b/game/client/tf2/c_shield.cpp
@@ -0,0 +1,837 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's sheild entity
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "C_Shield.h"
+#include "clienteffectprecachesystem.h"
+#include "clientmode.h"
+#include "materialsystem/imesh.h"
+#include "mapdata.h"
+#include "ivrenderview.h"
+#include "tf_shareddefs.h"
+#include "collisionutils.h"
+#include "functionproxy.h"
+
+// Precache the effects
+CLIENTEFFECT_REGISTER_BEGIN( Shield )
+CLIENTEFFECT_MATERIAL( "shadertest/wireframevertexcolor" )
+CLIENTEFFECT_MATERIAL( "effects/shield/shield" )
+CLIENTEFFECT_MATERIAL( "effects/shieldhit" )
+CLIENTEFFECT_MATERIAL( "effects/shieldpass" )
+CLIENTEFFECT_MATERIAL( "effects/shieldpass2" )
+CLIENTEFFECT_REGISTER_END()
+
+//-----------------------------------------------------------------------------
+// Stores a list of all active shields
+//-----------------------------------------------------------------------------
+CUtlVector< C_Shield* >	C_Shield::s_Shields;
+
+
+//-----------------------------------------------------------------------------
+// Various important constants: 
+//-----------------------------------------------------------------------------
+
+#define SHIELD_DAMAGE_CHANGE_FIRST_PASS_TIME		0.3f
+#define SHIELD_DAMAGE_CHANGE_TRANSITION_TIME		0.5f
+#define SHIELD_DAMAGE_CHANGE_TRANSITION_START_TIME	(SHIELD_DAMAGE_CHANGE_TIME -  SHIELD_DAMAGE_CHANGE_TRANSITION_TIME)
+#define SHIELD_DAMAGE_CHANGE_TOTAL_TIME	(SHIELD_DAMAGE_CHANGE_TRANSITION_START_TIME + SHIELD_DAMAGE_CHANGE_TRANSITION_TIME)
+#define SHIELD_TRANSITION_MAX_BLEND_AMT				0.2f
+
+
+//-----------------------------------------------------------------------------
+// Data table
+//-----------------------------------------------------------------------------
+//EXTERN_RECV_TABLE(DT_BaseEntity);
+
+IMPLEMENT_CLIENTCLASS_DT(C_Shield, DT_Shield, CShield)
+	RecvPropInt( RECVINFO(m_nOwningPlayerIndex) ),
+	RecvPropFloat( RECVINFO(m_flPowerLevel) ),
+	RecvPropInt( RECVINFO(m_bIsEMPed) ),
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Shield color for the various protection types
+//-----------------------------------------------------------------------------
+static unsigned char s_ImpactDecalColor[3] = {   0,   0, 255 };
+
+
+// ----------------------------------------------------------------------------
+// Functions.
+// ----------------------------------------------------------------------------
+C_Shield::C_Shield()
+{
+	m_pWireframe.Init( "shadertest/wireframevertexcolor", TEXTURE_GROUP_OTHER );
+	m_pShield.Init( "effects/shield/shield", TEXTURE_GROUP_CLIENT_EFFECTS );
+	m_pHitDecal.Init( "effects/shieldhit", TEXTURE_GROUP_CLIENT_EFFECTS );
+	m_pPassDecal.Init( "effects/shieldpass", TEXTURE_GROUP_CLIENT_EFFECTS );
+	m_pPassDecal2.Init( "effects/shieldpass2", TEXTURE_GROUP_CLIENT_EFFECTS );
+	m_FadeValue = 1.0f;
+	m_CurveValue = 1.0f;
+	m_bCollisionsActive = true;
+
+	s_Shields.AddToTail(this);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_Shield::~C_Shield()
+{
+	int i = s_Shields.Find(this);
+	if ( i >= 0 )
+	{
+		s_Shields.FastRemove(i);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Inherited classes should call this in their constructor to indicate size...
+//-----------------------------------------------------------------------------
+void C_Shield::InitShield( int w, int h, int subdivisions )
+{
+	m_SplinePatch.Init( w, h, 2 );
+
+	m_SubdivisionCount = subdivisions;
+	Assert( m_SubdivisionCount > 1 );
+	m_InvSubdivisionCount = 1.0f / (m_SubdivisionCount - 1);
+}
+
+//-----------------------------------------------------------------------------
+// This is called after a network update 
+//-----------------------------------------------------------------------------
+void C_Shield::OnDataChanged( DataUpdateType_t updateType )
+{
+	if (updateType == DATA_UPDATE_CREATED)
+	{
+		m_StartTime = engine->GetLastTimeStamp();
+	}
+	
+	BaseClass::OnDataChanged( updateType );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : collisionGroup - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_Shield::ShouldCollide( int collisionGroup, int contentsMask ) const
+{
+	return m_bCollisionsActive && ((collisionGroup == TFCOLLISION_GROUP_WEAPON) || (collisionGroup == TFCOLLISION_GROUP_GRENADE));
+}
+
+//-----------------------------------------------------------------------------
+// Should I draw?
+//-----------------------------------------------------------------------------
+bool C_Shield::ShouldDraw()
+{
+	// Let the client mode (like commander mode) reject drawing entities.
+	if (g_pClientMode && !g_pClientMode->ShouldDrawEntity(this) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Activates/deactivates a shield for collision purposes
+//-----------------------------------------------------------------------------
+void C_Shield::ActivateCollisions( bool activate )
+{
+	m_bCollisionsActive = activate;
+}
+
+//-----------------------------------------------------------------------------
+// Activates all shields 
+//-----------------------------------------------------------------------------
+void C_Shield::ActivateShields( bool activate, int team )
+{
+	for (int i = s_Shields.Count(); --i >= 0; )
+	{
+		// Activate all shields on the same team
+		if ( (team == -1) || (team == s_Shields[i]->GetTeamNumber()) )
+		{
+			s_Shields[i]->ActivateCollisions( activate );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Helper method for collision testing
+//-----------------------------------------------------------------------------
+#pragma warning ( disable : 4701 )
+
+bool C_Shield::TestCollision( const Ray_t& ray, unsigned int mask, trace_t& trace )
+{
+	// Can't block anything if we're EMPed, or we've got no power left to block
+	if ( m_bIsEMPed )
+		return false;
+	if ( m_flPowerLevel <= 0 )
+		return false;
+
+	// Here, we're gonna test for collision.
+	// If we don't stop this kind of bullet, we'll generate an effect here
+	// but we won't change the trace to indicate a collision.
+
+	// It's just polygon soup...
+	int hitgroup;
+	bool firstTri;
+	int v1[2], v2[2], v3[2];
+	float ihit, jhit;
+	float mint = FLT_MAX;
+	float t;
+
+	int h = Height();
+	int w = Width();
+
+	for (int i = 0; i < h - 1; ++i)
+	{
+		for (int j = 0; j < w - 1; ++j)
+		{
+			// Don't test if this panel ain't active...
+			if (!IsPanelActive( j, i ))
+				continue;
+
+			// NOTE: Structure order of points so that our barycentric
+			// axes for each triangle are along the (u,v) directions of the mesh
+			// The barycentric coords we'll need below 
+
+			// Two triangles per quad...
+			t = IntersectRayWithTriangle( ray,
+				GetPoint( j, i + 1 ),
+				GetPoint( j + 1, i + 1 ),
+				GetPoint( j, i ), true );
+			if ((t >= 0.0f) && (t < mint))
+			{
+				mint = t;
+				v1[0] = j;		v1[1] = i + 1;
+				v2[0] = j + 1;	v2[1] = i + 1;
+				v3[0] = j;		v3[1] = i;
+				ihit = i; jhit = j;
+				firstTri = true;
+			}
+			
+			t = IntersectRayWithTriangle( ray,
+				GetPoint( j + 1, i ),
+				GetPoint( j, i ),
+				GetPoint( j + 1, i + 1 ), true );
+			if ((t >= 0.0f) && (t < mint))
+			{
+				mint = t;
+				v1[0] = j + 1;	v1[1] = i;
+				v2[0] = j;		v2[1] = i;
+				v3[0] = j + 1;	v3[1] = i + 1;
+				ihit = i; jhit = j;
+				firstTri = false;
+			}
+		}
+	}
+
+	if (mint == FLT_MAX)
+		return false;
+
+	// Stuff the barycentric coordinates of the triangle hit into the hit group 
+	// For the first triangle, the first edge goes along u, the second edge goes
+	// along -v. For the second triangle, the first edge goes along -u,
+	// the second edge goes along v.
+	const Vector& v1vec = GetPoint(v1[0], v1[1]);
+	const Vector& v2vec = GetPoint(v2[0], v2[1]);
+	const Vector& v3vec = GetPoint(v3[0], v3[1]);
+	float u, v;
+	bool ok = ComputeIntersectionBarycentricCoordinates( ray, 
+		v1vec, v2vec, v3vec, u, v );
+	Assert( ok );
+	if ( !ok )
+	{
+		return false;
+	}
+
+	if (firstTri)
+		v = 1.0 - v;
+	else
+		u = 1.0 - u;
+	v += ihit; u += jhit;
+	v /= (h - 1);
+	u /= (w - 1);
+
+	// Compress (u,v) into 1 dot 15, v in top bits
+	hitgroup = (((int)(v * (1 << 15))) << 16) + (int)(u * (1 << 15));
+
+	Vector normal;
+	float intercept;
+	ComputeTrianglePlane( v1vec, v2vec, v3vec, normal, intercept ); 
+
+	UTIL_SetTrace( trace, ray, this, mint, hitgroup, CONTENTS_SOLID, normal, intercept );
+	return true;
+}
+
+#pragma warning ( default : 4701 )
+
+//-----------------------------------------------------------------------------
+// Called when we hit something that we deflect...
+//-----------------------------------------------------------------------------
+void C_Shield::RegisterDeflection(const Vector& vecDir, int bitsDamageType, trace_t *ptr)
+{
+	Vector normalDir;
+	VectorCopy( vecDir, normalDir );
+	VectorNormalize( normalDir );
+
+	CreateShieldDeflection( ptr->hitgroup, normalDir, false );
+}
+
+//-----------------------------------------------------------------------------
+// This is required to get all the decals to animate correctly
+//-----------------------------------------------------------------------------
+void C_Shield::SetCurrentDecal( int idx )
+{
+	m_CurrentDecal = idx;
+}
+
+//-----------------------------------------------------------------------------
+// returns the address of a variable that stores the material animation frame
+//-----------------------------------------------------------------------------
+float C_Shield::GetTextureAnimationStartTime()
+{
+	if( m_CurrentDecal == -1 )
+		return m_StartTime;
+	return m_Decals[m_CurrentDecal].m_StartTime;
+}
+
+//-----------------------------------------------------------------------------
+// Indicates that a texture animation has wrapped
+//-----------------------------------------------------------------------------
+void C_Shield::TextureAnimationWrapped()
+{
+	if( m_CurrentDecal != -1 )
+	{
+		m_Decals[m_CurrentDecal].m_StartTime = -1.0f;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Indicates a collision occurred: 
+//-----------------------------------------------------------------------------
+void C_Shield::ReceiveMessage( int classID,  bf_read &msg )
+{
+	if ( classID != GetClientClass()->m_ClassID )
+	{
+		// message is for subclass
+		BaseClass::ReceiveMessage( classID, msg );
+		return;
+	}
+
+	int hitgroup;
+	Vector dir;
+	unsigned char partialBlock;
+
+	hitgroup = msg.ReadLong( );
+	msg.ReadBitVec3Normal( dir );
+	partialBlock = msg.ReadByte( );
+
+	CreateShieldDeflection( hitgroup, dir, partialBlock );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_Shield::CreateShieldDeflection( int hitgroup, const Vector &dir, bool partialBlock )
+{
+	float hitU = (float)(hitgroup & 0xFFFF) / (float)(1 << 15);
+	float hitV = (float)(hitgroup >> 16) / (float)(1 << 15);
+
+	Ripple_t ripple;
+	ripple.m_RippleU = hitU;
+	ripple.m_RippleV = hitV;
+	ripple.m_Amplitude = partialBlock ? 4 : 30;
+	ripple.m_Radius = 0.08f;
+	ripple.m_StartTime = engine->GetLastTimeStamp();
+	ripple.m_Direction = dir;
+	m_Ripples.AddToTail(ripple);
+
+	Decal_t decal;
+	decal.m_RippleU = hitU;
+	decal.m_RippleV = hitV;
+	decal.m_Radius = partialBlock ? 0.03f : 0.08f;
+	decal.m_StartTime = engine->GetLastTimeStamp();
+	m_Decals.AddToTail(decal);
+}
+
+
+//-----------------------------------------------------------------------------
+// Draws the control points in wireframe
+//-----------------------------------------------------------------------------
+void C_Shield::DrawWireframeModel( Vector const** ppPositions )
+{
+	IMesh* pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_pWireframe );
+
+	int numLines = (Height() - 1) * Width() + Height() * (Width() - 1);
+
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_LINES, numLines );
+
+	Vector const* tmp;
+	for (int i = 0; i < Height(); ++i)
+	{
+		for (int j = 0; j < Width(); ++j)
+		{
+			if ( i > 0 )
+			{
+				tmp = ppPositions[j + Width() * i];
+				meshBuilder.Position3fv( tmp->Base() );
+				meshBuilder.Color4ub( 255, 255, 255, 128 );
+				meshBuilder.AdvanceVertex();
+
+				tmp = ppPositions[j + Width() * (i-1)];
+				meshBuilder.Position3fv( tmp->Base() );
+				meshBuilder.Color4ub( 255, 255, 255, 128 );
+				meshBuilder.AdvanceVertex();
+			}
+
+			if (j > 0)
+			{
+				tmp = ppPositions[j + Width() * i];
+				meshBuilder.Position3fv( tmp->Base() );
+				meshBuilder.Color4ub( 255, 255, 255, 128 );
+				meshBuilder.AdvanceVertex();
+
+				tmp = ppPositions[j - 1 + Width() * i];
+				meshBuilder.Position3fv( tmp->Base() );
+				meshBuilder.Color4ub( 255, 255, 255, 128 );
+				meshBuilder.AdvanceVertex();
+			}
+		}
+	}
+
+	meshBuilder.End();
+	pMesh->Draw();
+}
+
+//-----------------------------------------------------------------------------
+// Draws the base shield
+//-----------------------------------------------------------------------------
+#define TRANSITION_REGION_WIDTH 0.5f
+
+extern ConVar mat_wireframe;
+
+void C_Shield::DrawShieldPoints(Vector* pt, Vector* normal, float* opacity)
+{
+	SetCurrentDecal( -1 );
+
+	if (mat_wireframe.GetInt() == 0)
+		materials->Bind( m_pShield, (IClientRenderable*)this );
+	else
+		materials->Bind( m_pWireframe, (IClientRenderable*)this );
+	IMesh* pMesh = materials->GetDynamicMesh( true, NULL, NULL );
+
+	int numTriangles = (m_SubdivisionCount - 1) * (m_SubdivisionCount - 1) * 2;
+
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, numTriangles );
+
+	float du = 1.0f * m_InvSubdivisionCount;
+	float dv = du;
+
+	unsigned char color[3];
+	color[0] = 255; 
+	color[1] = 255; 
+	color[2] = 255; 
+
+	for ( int i = 0; i < m_SubdivisionCount - 1; ++i)
+	{
+		float v = i * dv;
+
+		for (int j = 0; j < m_SubdivisionCount - 1; ++j)
+		{
+			int idx = i * m_SubdivisionCount + j;
+			float u = j * du;
+
+			meshBuilder.Position3fv( pt[idx].Base() );
+			meshBuilder.Color4ub( color[0], color[1], color[2], opacity[idx] );
+			meshBuilder.Normal3fv( normal[idx].Base() );
+			meshBuilder.TexCoord2f( 0, u, v );
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.Position3fv( pt[idx + m_SubdivisionCount].Base() );
+			meshBuilder.Color4ub( color[0], color[1], color[2], opacity[idx+m_SubdivisionCount] );
+			meshBuilder.Normal3fv( normal[idx + m_SubdivisionCount].Base() );
+			meshBuilder.TexCoord2f( 0, u, v + dv );
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.Position3fv( pt[idx + 1].Base() );
+			meshBuilder.Color4ub( color[0], color[1], color[2], opacity[idx+1] );
+			meshBuilder.Normal3fv( normal[idx+1].Base() );
+			meshBuilder.TexCoord2f( 0, u + du, v );
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.Position3fv( pt[idx + 1].Base() );
+			meshBuilder.Color4ub( color[0], color[1], color[2], opacity[idx+1] );
+			meshBuilder.Normal3fv( normal[idx+1].Base() );
+			meshBuilder.TexCoord2f( 0, u + du, v );
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.Position3fv( pt[idx + m_SubdivisionCount].Base() );
+			meshBuilder.Color4ub( color[0], color[1], color[2], opacity[idx+m_SubdivisionCount] );
+			meshBuilder.Normal3fv( normal[idx + m_SubdivisionCount].Base() );
+			meshBuilder.TexCoord2f( 0, u, v + dv );
+			meshBuilder.AdvanceVertex();
+
+			meshBuilder.Position3fv( pt[idx + m_SubdivisionCount + 1].Base() );
+			meshBuilder.Color4ub( color[0], color[1], color[2], opacity[idx+m_SubdivisionCount+1] );
+			meshBuilder.Normal3fv( normal[idx + m_SubdivisionCount + 1].Base() );
+			meshBuilder.TexCoord2f( 0, u + du, v + dv );
+			meshBuilder.AdvanceVertex();
+		}
+	}
+
+	meshBuilder.End();
+	pMesh->Draw();
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Draws shield decals
+//-----------------------------------------------------------------------------
+void C_Shield::DrawShieldDecals( Vector* pt, bool hitDecals )
+{
+	if (m_Decals.Size() == 0)
+		return;
+
+	// Compute ripples:
+	for ( int r = m_Decals.Size(); --r >= 0; )
+	{
+		// At the moment, nothing passes!
+		bool passDecal = false;
+		if ((!hitDecals) && (passDecal == hitDecals))
+			continue;
+
+		SetCurrentDecal( r );
+
+		// We have to force a flush here because we're changing the proxy state
+		if (!hitDecals)
+			materials->Bind( m_pPassDecal, (IClientRenderable*)this );
+		else
+			materials->Bind( passDecal ? m_pPassDecal2 : m_pHitDecal, (IClientRenderable*)this );
+
+		float dtime = gpGlobals->curtime - m_Decals[r].m_StartTime;
+		float decay = exp( -( 2 * dtime) );
+
+		// Retire the animation if it wraps
+		// This gets set by TextureAnimatedWrapped above
+		if ((m_Decals[r].m_StartTime < 0.0f) || (decay < 1e-3))
+		{
+			m_Decals.Remove(r);
+			continue;
+		}
+
+		IMesh* pMesh = materials->GetDynamicMesh();
+
+		// Figure out the quads we must mod2x....
+		float u0 = m_Decals[r].m_RippleU - m_Decals[r].m_Radius;
+		float u1 = m_Decals[r].m_RippleU + m_Decals[r].m_Radius;
+		float v0 = m_Decals[r].m_RippleV - m_Decals[r].m_Radius;
+		float v1 = m_Decals[r].m_RippleV + m_Decals[r].m_Radius;
+		float du = u1 - u0;
+		float dv = v1 - v0;
+
+		int i0 = Floor2Int( v0 * (m_SubdivisionCount - 1) );
+		int i1 = Ceil2Int( v1 * (m_SubdivisionCount - 1) );
+		int j0 = Floor2Int( u0 * (m_SubdivisionCount - 1) );
+		int j1 = Ceil2Int( u1 * (m_SubdivisionCount - 1) );
+		if (i0 < 0)
+			i0 = 0;
+		if (i1 >= m_SubdivisionCount)
+			i1 = m_SubdivisionCount - 1;
+		if (j0 < 0)
+			j0 = 0;
+		if (j1 >= m_SubdivisionCount)
+			j1 = m_SubdivisionCount - 1;
+
+		int numTriangles = (i1 - i0) * (j1 - j0) * 2;
+
+		CMeshBuilder meshBuilder;
+		meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, numTriangles );
+
+		float decalDu = m_InvSubdivisionCount / du;
+		float decalDv = m_InvSubdivisionCount / dv;
+
+		unsigned char color[3];
+		color[0] = s_ImpactDecalColor[0] * decay;
+		color[1] = s_ImpactDecalColor[1] * decay;
+		color[2] = s_ImpactDecalColor[2] * decay;
+
+		for ( int i = i0; i < i1; ++i)
+		{
+			float t = (float)i * m_InvSubdivisionCount;
+			for (int j = j0; j < j1; ++j)
+			{
+				float s = (float)j * m_InvSubdivisionCount;
+				int idx = i * m_SubdivisionCount + j;
+
+				// Compute (u,v) into the decal
+				float decalU = (s - u0) / du;
+				float decalV = (t - v0) / dv;
+
+				meshBuilder.Position3fv( pt[idx].Base() );
+				meshBuilder.Color3ubv( color );
+				meshBuilder.TexCoord2f( 0, decalU, decalV );
+				meshBuilder.AdvanceVertex();
+
+				meshBuilder.Position3fv( pt[idx + m_SubdivisionCount].Base() );
+				meshBuilder.Color3ubv( color );
+				meshBuilder.TexCoord2f( 0, decalU, decalV + decalDv );
+				meshBuilder.AdvanceVertex();
+
+				meshBuilder.Position3fv( pt[idx + 1].Base() );
+				meshBuilder.Color3ubv( color );
+				meshBuilder.TexCoord2f( 0, decalU + decalDu, decalV );
+				meshBuilder.AdvanceVertex();
+
+				meshBuilder.Position3fv( pt[idx + 1].Base() );
+				meshBuilder.Color3ubv( color );
+				meshBuilder.TexCoord2f( 0, decalU + decalDu, decalV );
+				meshBuilder.AdvanceVertex();
+
+				meshBuilder.Position3fv( pt[idx + m_SubdivisionCount].Base() );
+				meshBuilder.Color3ubv( color );
+				meshBuilder.TexCoord2f( 0, decalU, decalV + decalDv );
+				meshBuilder.AdvanceVertex();
+
+				meshBuilder.Position3fv( pt[idx + m_SubdivisionCount + 1].Base() );
+				meshBuilder.Color3ubv( color );
+				meshBuilder.TexCoord2f( 0, decalU + decalDu, decalV + decalDv );
+				meshBuilder.AdvanceVertex();
+			}
+		}
+
+		meshBuilder.End();
+		pMesh->Draw();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes a single point
+//-----------------------------------------------------------------------------
+void C_Shield::ComputePoint( float s, float t, Vector& pt, Vector& normal, float& opacity )
+{
+	// Precache some computations for the point on the spline at (s, t).
+	m_SplinePatch.SetupPatchQuery( s, t );
+
+	// Get the position + normal
+	m_SplinePatch.GetPointAndNormal( pt, normal );
+
+	// From here on down is all futzing with opacity
+
+	// Check neighbors for activity...
+	bool active = IsPanelActive(m_SplinePatch.m_is, m_SplinePatch.m_it);
+	if (m_SplinePatch.m_fs == 0.0f)
+		active = active || IsPanelActive(m_SplinePatch.m_is - 1, m_SplinePatch.m_it);
+	if (m_SplinePatch.m_ft == 0.0f)
+		active = active || IsPanelActive(m_SplinePatch.m_is, m_SplinePatch.m_it - 1);
+
+	if (!active)
+	{
+		// If the panel's not active, it's transparent.
+		opacity = 0.0f;
+	}
+	else
+	{
+		if ((s == 0.0f) || (t == 0.0f) ||
+			(s == (Width() - 1.0f)) || (t == (Height() - 1.0f)) )
+		{
+			// If it's on the edge, it's max opacity
+			opacity = 192.0f;
+		}
+		else
+		{
+			// Channel zero is the opacity data
+			opacity = m_SplinePatch.GetChannel( 0 );
+
+			// Make the shield translucent if the owner is the local player...
+			// Also don't mess with the edges..
+			if (m_ShieldOwnedByLocalPlayer)
+			{
+				// Channel 1 is the opacity blend
+				float blendFactor = m_SplinePatch.GetChannel( 1 );
+				blendFactor = clamp( blendFactor, 0.0f, 1.0f );
+
+				float blendValue = 1.0f; 
+				Vector delta;
+				VectorSubtract( pt, GetAbsOrigin(), delta );
+				float dist = VectorLength( delta );
+				if (dist != 0.0f)
+				{
+					delta *= 1.0f / dist;
+					float dot = DotProduct( m_ViewDir, delta );
+					float angle = acos(	dot );
+					float fov = M_PI * render->GetFieldOfView() / 180.0f;
+					if (angle < fov * .2f)
+						blendValue = 0.1f;
+					else if (angle < fov * 0.4f)
+					{
+						// Want a cos falloff between .2 and .4
+						// 0.1 at .2 and 1.0 at .4
+						angle -= fov * 0.2f;
+						blendValue = 1.0f - 0.9f * 0.5f * (cos ( M_PI * angle / (fov * 0.2f) ) + 1.0f);
+					}
+				}
+
+				// Interpolate between 1 and the blend value based on the blend factor...
+				opacity *= (1.0f - blendFactor) + blendFactor * blendValue;
+			}
+
+			opacity = clamp( opacity, 0.0f, 192.0f );
+		}
+	}
+	opacity *= m_FadeValue;
+}
+
+
+//-----------------------------------------------------------------------------
+// Compute the shield points using catmull-rom
+//-----------------------------------------------------------------------------
+void C_Shield::ComputeShieldPoints( Vector* pt, Vector* normal, float* opacity )
+{
+	int i;
+	for ( i = 0; i < m_SubdivisionCount; ++i)
+	{
+		float t = (Height() - 1) * (float)i * m_InvSubdivisionCount;
+		for (int j = 0; j < m_SubdivisionCount; ++j)
+		{
+			float s = (Width() - 1) * (float)j * m_InvSubdivisionCount;
+			int idx = i * m_SubdivisionCount + j;
+
+			ComputePoint( s, t, pt[idx], normal[idx], opacity[idx] );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Compute the shield ripples from being hit
+//-----------------------------------------------------------------------------
+void C_Shield::RippleShieldPoints( Vector* pt, float* opacity )
+{
+	// Compute ripples:
+	for ( int r = m_Ripples.Size(); --r >= 0; )
+	{
+		float dtime = gpGlobals->curtime - m_Ripples[r].m_StartTime;
+		float decay = exp( -( 2 * dtime) );
+		float amplitude = m_Ripples[r].m_Amplitude * decay;
+
+		for ( int i = 0; i < m_SubdivisionCount; ++i)
+		{
+			float t = i * m_InvSubdivisionCount;
+			for (int j = 0; j < m_SubdivisionCount; ++j)
+			{
+				float s = j * m_InvSubdivisionCount;
+				int idx = i * m_SubdivisionCount + j;
+
+				float ds = s - m_Ripples[r].m_RippleU;
+				float dt = t - m_Ripples[r].m_RippleV;
+				float dr = sqrt( ds * ds + dt * dt );
+				if (dr < m_Ripples[r].m_Radius)
+				{
+					// need to apply ripple
+					float diff = amplitude * cos( 0.5f * M_PI * dr / m_Ripples[r].m_Radius );
+					VectorMA( pt[idx], diff, m_Ripples[r].m_Direction, pt[idx] );
+
+					// Compute opacity at this point...
+					float impactopacity = 192.0f * decay * dr / m_Ripples[r].m_Radius;
+					if (impactopacity > opacity[idx])
+						opacity[idx] = impactopacity;
+				}
+			}
+		}
+
+		if (amplitude < 0.1)
+			m_Ripples.Remove(r);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Main draw entry point
+//-----------------------------------------------------------------------------
+int	C_Shield::DrawModel( int flags )
+{
+	if ( !m_bReadyToDraw )
+		return 0;
+
+	if (m_FadeValue == 0.0f)
+		return 1;
+
+	// If I have no power, don't draw
+	if ( m_flPowerLevel <= 0 )
+		return 1;
+
+	// Make it curvy or not!!
+	m_SplinePatch.SetLinearBlend( m_CurveValue );
+
+	// Set up the patch with all the data it's going to need
+	int count = Width() * Height();
+ 	Vector const** pControlPoints = (Vector const**)stackalloc(count * sizeof(Vector*));
+	float* pControlOpacity = (float*)stackalloc(count * sizeof(float));
+	float* pControlBlend = (float*)stackalloc(count * sizeof(float));
+
+	GetShieldData( pControlPoints, pControlOpacity, pControlBlend );
+	m_SplinePatch.SetControlPositions( pControlPoints );
+	m_SplinePatch.SetChannelData( 0, pControlOpacity );
+	m_SplinePatch.SetChannelData( 1, pControlBlend );
+
+//	DrawWireframeModel( pControlPoints );
+
+	// Allocate space for temporary data
+	int numSubdivisions = m_SubdivisionCount * m_SubdivisionCount;
+	Vector* pt = (Vector*)stackalloc(numSubdivisions * sizeof(Vector));
+	Vector* normal = (Vector*)stackalloc(numSubdivisions * sizeof(Vector));
+	float* opacity = (float*)stackalloc(numSubdivisions * sizeof(float));
+
+	// Do something a little special if this shield is owned by the local player
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	m_ShieldOwnedByLocalPlayer = (player->entindex() == m_nOwningPlayerIndex);
+	if (m_ShieldOwnedByLocalPlayer)
+	{
+		QAngle viewAngles;
+		engine->GetViewAngles(viewAngles);
+		AngleVectors( viewAngles, &m_ViewDir );
+	}
+
+	ComputeShieldPoints( pt, normal, opacity );
+	RippleShieldPoints( pt, opacity );
+
+	// Commented out because it causes things to not be drawn behind it
+//	DrawShieldDecals( pt, false );
+
+    DrawShieldPoints( pt, normal, opacity );
+	DrawShieldDecals( pt, true );
+
+	return 1;
+}
+
+
+
+//============================================================================================================
+// SHIELD POWERLEVEL PROXY
+//============================================================================================================
+class CShieldPowerLevelProxy : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity );
+};
+
+void CShieldPowerLevelProxy::OnBind( void *pRenderable )
+{
+	IClientRenderable *pRend = (IClientRenderable *)pRenderable;
+	C_BaseEntity *pEntity = pRend->GetIClientUnknown()->GetBaseEntity();
+	C_Shield *pShield = dynamic_cast<C_Shield*>(pEntity);
+	if (!pShield)
+		return;
+
+	SetFloatResult( pShield->GetPowerLevel() );
+}
+
+EXPOSE_INTERFACE( CShieldPowerLevelProxy, IMaterialProxy, "ShieldPowerLevel" IMATERIAL_PROXY_INTERFACE_VERSION );
diff --git a/game/client/tf2/c_shield.h b/game/client/tf2/c_shield.h
new file mode 100644
index 0000000..2b92cb1
--- /dev/null
+++ b/game/client/tf2/c_shield.h
@@ -0,0 +1,199 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's sheild entity
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_SHIELD_H
+#define C_SHIELD_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "SplinePatch.h"
+
+//-----------------------------------------------------------------------------
+// Shield: 
+//-----------------------------------------------------------------------------
+class C_Shield : public C_BaseEntity
+{
+public:
+	DECLARE_CLASS( C_Shield, C_BaseEntity );
+	DECLARE_CLIENTCLASS();
+
+	// constructor, destructor
+	C_Shield();
+	~C_Shield();
+
+	// Inherited classes should call this in their constructor to indicate size...
+	void InitShield( int w, int h, int subdivisions );
+
+	void OnDataChanged( DataUpdateType_t updateType );
+	int	DrawModel( int flags );
+	void ReceiveMessage( int classID,  bf_read &msg );
+
+	void CreateShieldDeflection( int hitgroup, const Vector &dir, bool partialBlock );
+
+	virtual bool ShouldDraw();
+	virtual bool IsTransparent() { return true; }
+	virtual void SetAlwaysOrient( bool bOrient ) {}
+	virtual bool IsAlwaysOrienting( ) { return false; }
+	virtual void SetCenterAngles( const QAngle & ) {}
+	virtual void SetAttachmentIndex( int nAttachmentIndex ) {}
+
+	// returns the address of a variable that stores the material animation frame
+	float	GetTextureAnimationStartTime();
+
+	// Indicates that a texture animation has wrapped
+	void	TextureAnimationWrapped();
+
+	virtual bool	ShouldCollide( int collisionGroup, int contentsMask ) const;
+
+	// Collision detection
+	// Activates/deactivates a shield for collision purposes
+	void ActivateCollisions( bool activate );
+
+	// Deactivates all shields of players on a particular team
+	// If you don't specify a team, it'll affect all shields
+	static void ActivateShields( bool activate, int team = -1 );
+	virtual const Vector& GetPoint( int x, int y ) { return vec3_origin; }
+
+	// For collision testing
+	bool TestCollision( const Ray_t& ray, unsigned int mask, trace_t& trace );
+
+	// Called when we hit something that we deflect...
+	void RegisterDeflection(const Vector& vecDir, int bitsDamageType, trace_t *ptr);
+
+	float	GetPowerLevel( void ) { return m_flPowerLevel; }
+
+	bool	IsEMPed() const;
+	void	SetEMPed( bool bIsEmped ); 
+
+protected:
+	//
+	// Inheriting classes must implement these methods!!!
+	//
+
+	// Return true if the panel is active 
+	virtual bool IsPanelActive( int x, int y )		{ assert(0); return false; }
+
+	// Gets at the control point data; who knows how it was made?
+	virtual void GetShieldData( Vector const** ppVerts, float* pOpacity, float* pBlend )	{ assert(0); }
+
+private:
+	void	DrawWireframeModel( Vector const** pPositions );
+	void	ComputePoint( float s, float t, Vector& pt, Vector& normal, float& opacity );
+	void	ComputeShieldPoints( Vector* pt, Vector* normal, float* opacity );
+	void	RippleShieldPoints( Vector* pt, float* opacity );
+	void	DrawShieldPoints(Vector* pt, Vector* normal, float* opacity);
+	void	DrawShieldDecals(Vector* pt, bool hitDecals );
+	void	SetCurrentDecal( int idx );
+
+	int		Width() const;
+	int		Height() const;
+
+protected:
+	// Used to fade out the shield
+	float m_FadeValue;
+	
+	// Used to make the shield more or less curvy
+	float m_CurveValue;
+
+private:
+	// no copy constructor
+	C_Shield( const C_Shield& );
+
+	// Data needs to ripple the shield control points
+	struct Ripple_t
+	{
+		float m_RippleU;
+		float m_RippleV;
+		float m_Amplitude;
+		float m_Radius;
+		float m_StartTime;
+		Vector m_Direction;
+	};
+
+	struct Decal_t
+	{
+		float	m_RippleU;
+		float	m_RippleV;
+		float	m_Radius;
+		float	m_StartTime;
+	};
+
+	// Owner entity
+	int		m_nOwningPlayerIndex;
+
+	// number of subdivisions
+	int		m_SubdivisionCount;
+	float	m_InvSubdivisionCount;
+
+	// Shield powerlevel 
+	float	m_flPowerLevel;
+
+	// Texture animation
+	float	m_StartTime;
+
+	bool	m_bCollisionsActive;
+	bool	m_bIsEMPed;
+
+	// Used to do spline queries
+	CSplinePatch	m_SplinePatch;
+
+	// List of all ripples + decals
+	int	m_CurrentDecal;
+	CUtlVector<	Ripple_t > m_Ripples;
+	CUtlVector<	Decal_t > m_Decals;
+
+	// All the various materials we use
+	CMaterialReference m_pWireframe;
+	CMaterialReference m_pShield;
+	CMaterialReference m_pHitDecal;
+	CMaterialReference m_pPassDecal;
+	CMaterialReference m_pPassDecal2;
+
+	// A little state used only during rendering, but I didn't want
+	// to pass these as arguments to a bunch of functions
+	bool m_ShieldOwnedByLocalPlayer;
+	Vector m_ViewDir;
+
+	// List of all active shields
+	static CUtlVector< C_Shield* >	s_Shields;
+};
+
+
+//-----------------------------------------------------------------------------
+// Inline methods
+//-----------------------------------------------------------------------------
+inline int C_Shield::Width() const	
+{ 
+	return m_SplinePatch.Width(); 
+}
+
+inline int C_Shield::Height() const	
+{ 
+	return m_SplinePatch.Height(); 
+}
+
+inline bool C_Shield::IsEMPed() const 
+{ 
+	return m_bIsEMPed; 
+}
+
+inline void C_Shield::SetEMPed( bool bIsEmped ) 
+{ 
+	m_bIsEMPed = bIsEmped; 
+}
+
+
+//-----------------------------------------------------------------------------
+// Class factory methods to create the various versions of the shield
+//-----------------------------------------------------------------------------
+C_Shield* CreateMobileShield( C_BaseEntity *owner, float flFrontDistance = 0 );
+
+#endif // C_SHIELD_H
\ No newline at end of file
diff --git a/game/client/tf2/c_shield_flat.cpp b/game/client/tf2/c_shield_flat.cpp
new file mode 100644
index 0000000..0d8316c
--- /dev/null
+++ b/game/client/tf2/c_shield_flat.cpp
@@ -0,0 +1,350 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's sheild entity
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "C_Shield.h"
+#include "tf_shieldshared.h"
+#include "c_basetfplayer.h"
+
+enum
+{
+	NUM_SUBDIVISIONS = 21,
+};
+
+#define EMP_WAVE_AMPLITUDE 6.0f
+#define EMP_GROW_WIDTH_DELAY 0.2f
+#define EMP_GROW_TIME 0.6f
+#define EMP_GROW_ATTEN 0.5f
+#define EMP_MIN_WIDTH 5.0f
+
+//-----------------------------------------------------------------------------
+// Flat version of the shield 
+//-----------------------------------------------------------------------------
+
+class C_ShieldFlat : public C_Shield
+{
+public:
+	DECLARE_CLASS( C_ShieldFlat, C_Shield );
+	DECLARE_CLIENTCLASS();
+
+	C_ShieldFlat();
+	~C_ShieldFlat();
+
+	virtual void GetBounds( Vector& mins, Vector& maxs );
+
+	virtual void AddEntity( );
+
+	virtual void SetDormant( bool bDormant );
+
+	// Return true if the panel is active 
+	virtual bool IsPanelActive( int x, int y );
+
+	// Gets at the control point data; who knows how it was made?
+	virtual void GetShieldData( Vector const** ppVerts, float* pOpacity, float* pBlend );
+	virtual const Vector& GetPoint( int x, int y );
+
+	// Draws the model
+	virtual int	DrawModel( int flags );
+
+public:
+	// networked data
+	unsigned char	m_ShieldState;
+	float			m_Width;
+	float			m_Height;
+
+	float			m_DeathFade;
+	float			m_EMPFade;
+
+private:
+	void	ShieldMoved( void );
+
+private:
+	C_ShieldFlat( const C_ShieldFlat& );
+	void ComputeEMPFade();
+	void ComputeDeathFade();
+	void ComputeSize( float& w, float& h );
+	void PreRender( );
+
+	Vector			m_pPositions[4];
+	Vector			m_Forward;
+	float			m_EnterPVSTime;
+
+	QAngle	m_LastAngles;
+	Vector	m_LastPosition;
+	Vector	m_Pos[4];
+};
+
+
+//-----------------------------------------------------------------------------
+// Data table
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CLIENTCLASS_DT(C_ShieldFlat, DT_Shield_Flat, CShieldFlat)
+
+	RecvPropInt( RECVINFO(m_ShieldState) ),
+	RecvPropFloat( RECVINFO(m_Width) ),
+	RecvPropFloat( RECVINFO(m_Height) ),
+
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+
+C_ShieldFlat::C_ShieldFlat()
+{
+	m_DeathFade = 1.0f;
+	m_EMPFade = 1.0f;
+
+	InitShield( 2, 2, 6 );
+}
+
+C_ShieldFlat::~C_ShieldFlat()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Leaving/entering the PVS on the server.
+//-----------------------------------------------------------------------------
+
+void C_ShieldFlat::SetDormant( bool bDormant )
+{
+	if (!bDormant)
+	{
+		if (m_ShieldState & SHIELD_FLAT_EMP)
+		{
+			m_EMPFade = 0.0f;
+		}
+		else
+		{
+			m_EMPFade = 1.0f;
+		}
+
+		m_EnterPVSTime = 0.0f;
+		if (m_ShieldState & SHIELD_FLAT_INACTIVE)
+		{
+			m_DeathFade = 0.0f;
+		}
+		else
+		{
+			m_EnterPVSTime = gpGlobals->curtime;
+			m_DeathFade = 1.0f;
+		}
+	}
+
+	BaseClass::SetDormant(bDormant);
+}
+
+//-----------------------------------------------------------------------------
+// Figures the EMP fade factor
+//-----------------------------------------------------------------------------
+
+void C_ShieldFlat::ComputeEMPFade()
+{
+	if (m_ShieldState & SHIELD_FLAT_EMP)
+	{
+		// Decay fade if we've been EMPed or if we're inactive
+		if (m_EMPFade > 0.0f)
+		{
+			m_EMPFade -= gpGlobals->frametime / SHIELD_EMP_FADE_TIME;
+			if (m_EMPFade < 0.0f)
+			{
+				m_EMPFade = 0.0f;
+			}
+			else
+			{
+				Vector dir;
+
+				// Futz with the control points if we've been EMPed
+				for (int i = 0; i < 4; ++i)
+				{
+					float dist = -EMP_WAVE_AMPLITUDE * sin( i * M_PI * 0.5f + gpGlobals->curtime * M_PI / SHIELD_EMP_WOBBLE_TIME );
+					VectorMA( m_pPositions[i], dist, m_Forward, m_pPositions[i] );
+				}
+			}
+		}
+	}
+	else
+	{
+		// Fade back in, no longer EMPed
+		if (m_EMPFade < 1.0f)
+		{
+			m_EMPFade += gpGlobals->frametime / SHIELD_EMP_FADE_TIME;
+			if (m_EMPFade >= 1.0f)
+			{
+				m_EMPFade = 1.0f;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Figures the networked fade factor
+//-----------------------------------------------------------------------------
+
+void C_ShieldFlat::ComputeDeathFade()
+{
+	if (m_ShieldState & SHIELD_FLAT_INACTIVE)
+	{
+		// Fade out when we become inactive
+		if (m_DeathFade > 0.0f)
+		{
+			m_DeathFade -= gpGlobals->frametime / SHIELD_FLAT_SHUTDOWN_TIME;
+			if (m_DeathFade < 0.0f)
+			{
+				m_DeathFade = 0.0f;
+			}
+		}
+	}
+	else
+	{
+		// Active? We should be visible
+		m_DeathFade = 1.0f;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// A little pre-render processing
+//-----------------------------------------------------------------------------
+
+void C_ShieldFlat::ComputeSize( float& w, float& h )
+{
+	w = m_Width;
+	h = m_Height;
+
+	float dt = gpGlobals->curtime - m_EnterPVSTime;
+	if (dt > EMP_GROW_TIME)
+	{
+		return;
+	}
+
+	if (dt < 0)
+		dt = 0.0f;
+
+	// Attenuate it up
+	w *= 1.0f - pow ( EMP_GROW_ATTEN, 10 * (dt / EMP_GROW_TIME ));
+
+	if (w < EMP_MIN_WIDTH)
+		w = EMP_MIN_WIDTH;
+}
+
+//-----------------------------------------------------------------------------
+// A little pre-render processing
+//-----------------------------------------------------------------------------
+
+void C_ShieldFlat::PreRender( )
+{
+	// Compute the shield positions...
+	Vector right, up;
+	AngleVectors( GetRenderAngles(), &m_Forward, &right, &up );
+
+	float w, h;
+	ComputeSize( w, h );
+
+	VectorMA( GetRenderOrigin(), -w * 0.5, right, m_pPositions[0] );
+	VectorMA( m_pPositions[0], -h * 0.5, up, m_pPositions[0] );
+	VectorMA( m_pPositions[0], w, right, m_pPositions[1] );
+	VectorMA( m_pPositions[0], h, up, m_pPositions[2] );
+	VectorMA( m_pPositions[2], w, right, m_pPositions[3] );
+
+	ComputeEMPFade();
+	ComputeDeathFade();
+
+	m_FadeValue = m_DeathFade * m_EMPFade;
+}
+
+void C_ShieldFlat::AddEntity( )
+{
+	BaseClass::AddEntity( );
+	PreRender();
+}
+
+//-----------------------------------------------------------------------------
+// Bounds computation
+//-----------------------------------------------------------------------------
+
+void C_ShieldFlat::GetBounds( Vector& mins, Vector& maxs )
+{
+	mins.Init( -1.0/16.0f, -m_Width * 0.5f, -m_Height * 0.5f );
+	maxs.Init(  1.0/16.0f,  m_Width * 0.5f,  m_Height * 0.5f );
+}
+
+//-----------------------------------------------------------------------------
+// Return true if the panel is active 
+//-----------------------------------------------------------------------------
+
+bool C_ShieldFlat::IsPanelActive( int x, int y )
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Gets at the control point data; who knows how it was made?
+//-----------------------------------------------------------------------------
+
+void C_ShieldFlat::GetShieldData( Vector const** ppVerts, float* pOpacity, float* pBlend )
+{
+	for ( int i = 0; i < 4; ++i )
+	{
+		ppVerts[i] = &m_pPositions[i];
+		pOpacity[i] = 32.0f;
+		pBlend[i] = 0.0f;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Shield points
+//-----------------------------------------------------------------------------
+const Vector& C_ShieldFlat::GetPoint( int x, int y ) 
+{
+	if ((m_LastAngles != GetAbsAngles()) || (m_LastPosition != GetAbsOrigin() ))
+	{
+		ShieldMoved();
+	}
+
+	int i = (x >= 1);
+	i += (y >= 1) * 2;
+	return m_Pos[i];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Computes the shield bounding box
+//-----------------------------------------------------------------------------
+void C_ShieldFlat::ShieldMoved( void )
+{
+	Vector forward, right, up;
+	AngleVectors( GetAbsAngles(), &forward, &right, &up );
+
+	VectorMA( GetAbsOrigin(), -m_Width * 0.5, right, m_Pos[0] );
+	VectorMA( m_Pos[0], -m_Height * 0.5, up, m_Pos[0] );
+	VectorMA( m_Pos[0], m_Width, right, m_Pos[1] );
+	VectorMA( m_Pos[0], m_Height, up, m_Pos[2] );
+	VectorMA( m_Pos[2], m_Width, right, m_Pos[3] );
+
+	m_LastAngles = GetAbsAngles();
+	m_LastPosition = GetAbsOrigin();
+}
+
+//-----------------------------------------------------------------------------
+// Suppress rendering if the player owns it
+//-----------------------------------------------------------------------------
+
+int	C_ShieldFlat::DrawModel( int flags )
+{
+	if ( !m_bReadyToDraw )
+		return 0;
+
+	// Don't draw it if the owner is the local player
+//	if ( m_OwnerEntity == C_BasePlayer::GetLocalPlayer()->index )
+//		return 0;
+
+	return BaseClass::DrawModel( flags );
+}
+
diff --git a/game/client/tf2/c_shield_mobile.cpp b/game/client/tf2/c_shield_mobile.cpp
new file mode 100644
index 0000000..1de8592
--- /dev/null
+++ b/game/client/tf2/c_shield_mobile.cpp
@@ -0,0 +1,274 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's sheild entity
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "C_Shield.h"
+#include "tf_shieldshared.h"
+
+enum
+{
+	NUM_SUBDIVISIONS = 21,
+};
+
+#define EMP_WAVE_AMPLITUDE 8.0f
+
+//-----------------------------------------------------------------------------
+// Mobile version of the shield 
+//-----------------------------------------------------------------------------
+
+class C_ShieldMobile;
+class C_ShieldMobileActiveVertList : public IActiveVertList
+{
+public:
+	void			Init( C_ShieldMobile *pShield, unsigned char *pVertList );
+
+// IActiveVertList overrides.
+public:
+
+	virtual int		GetActiveVertState( int iVert );
+	virtual void	SetActiveVertState( int iVert, int bOn );
+
+private:
+	C_ShieldMobile	*m_pShield;
+	unsigned char	*m_pVertsActive;
+};
+
+
+class C_ShieldMobile : public C_Shield
+{
+	DECLARE_CLASS( C_ShieldMobile, C_Shield );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_ShieldMobile();
+	~C_ShieldMobile();
+
+	void OnDataChanged( DataUpdateType_t updateType );
+	virtual void GetBounds( Vector& mins, Vector& maxs );
+
+	virtual void AddEntity( );
+
+	// Return true if the panel is active 
+	virtual bool IsPanelActive( int x, int y );
+
+	// Gets at the control point data; who knows how it was made?
+	virtual void GetShieldData( Vector const** ppVerts, float* pOpacity, float* pBlend );
+	virtual const Vector& GetPoint( int x, int y ) { return m_ShieldEffect.GetPoint( x, y ); }
+
+	virtual void SetThetaPhi( float flTheta, float flPhi ) { m_ShieldEffect.SetThetaPhi(flTheta,flPhi); }
+
+public:
+	// networked data
+	unsigned char	m_pVertsActive[SHIELD_VERTEX_BYTES];
+	unsigned char	m_ShieldState;
+
+private:
+	C_ShieldMobile( const C_ShieldMobile& );
+
+	// Is a particular panel an edge?
+	bool IsVertexValid( float s, float t ) const;
+	void PreRender( );
+
+private:
+	CShieldEffect					m_ShieldEffect;
+	C_ShieldMobileActiveVertList	m_VertList;
+	float m_flTheta;
+	float m_flPhi;
+};
+
+
+//-----------------------------------------------------------------------------
+// C_ShieldMobileActiveVertList functions
+//-----------------------------------------------------------------------------
+
+void C_ShieldMobileActiveVertList::Init( C_ShieldMobile *pShield, unsigned char *pVertList )
+{
+	m_pShield = pShield;
+	m_pVertsActive = pVertList;
+}
+
+
+int C_ShieldMobileActiveVertList::GetActiveVertState( int iVert )
+{
+	return m_pVertsActive[iVert>>3] & (1 << (iVert & 7));
+}
+
+
+void C_ShieldMobileActiveVertList::SetActiveVertState( int iVert, int bOn )
+{
+	if ( bOn )
+		m_pVertsActive[iVert>>3] |= (1 << (iVert & 7));
+	else
+		m_pVertsActive[iVert>>3] &= ~(1 << (iVert & 7));
+}
+
+
+//-----------------------------------------------------------------------------
+// Data table
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_CLIENTCLASS_DT(C_ShieldMobile, DT_Shield_Mobile, CShieldMobile)
+
+	RecvPropInt( RECVINFO(m_ShieldState) ),
+	RecvPropArray( 
+		RecvPropInt( RECVINFO(m_pVertsActive[0])), 
+		m_pVertsActive 
+	),
+	RecvPropFloat( RECVINFO(m_flTheta) ),
+	RecvPropFloat( RECVINFO(m_flPhi) ),
+
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Various raycasting routines
+//-----------------------------------------------------------------------------
+
+
+void ShieldTraceLine(const Vector &vecStart, const Vector &vecEnd, 
+					 unsigned int mask, int collisionGroup, trace_t *ptr)
+{
+	UTIL_TraceLine(vecStart, vecEnd, mask, NULL, collisionGroup, ptr );
+}
+
+void ShieldTraceHull(const Vector &vecStart, const Vector &vecEnd, 
+					 const Vector &hullMin, const Vector &hullMax, 
+					 unsigned int mask, int collisionGroup, trace_t *ptr)
+{
+	CTraceFilterWorldOnly traceFilter;
+	enginetrace->TraceHull( vecStart, vecEnd, hullMin, hullMax, mask, &traceFilter, ptr );
+}
+
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+
+C_ShieldMobile::C_ShieldMobile() : m_ShieldEffect(ShieldTraceLine, ShieldTraceHull)
+{
+	m_VertList.Init( this, m_pVertsActive );
+	m_ShieldEffect.SetActiveVertexList( &m_VertList );
+	m_ShieldEffect.Spawn(vec3_origin, vec3_angle);
+	InitShield( SHIELD_NUM_HORIZONTAL_POINTS, SHIELD_NUM_VERTICAL_POINTS, NUM_SUBDIVISIONS );
+}
+
+C_ShieldMobile::~C_ShieldMobile()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Get this after the data changes
+//-----------------------------------------------------------------------------
+
+void C_ShieldMobile::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	m_ShieldEffect.SetCurrentPosition( GetAbsOrigin() );
+	m_ShieldEffect.SetCurrentAngles( GetAbsAngles() );
+	m_ShieldEffect.SetThetaPhi( m_flTheta, m_flPhi );
+
+	// No need to simulate, just compute active panels from network data
+	m_ShieldEffect.ComputeControlPoints();
+	m_ShieldEffect.ComputePanelActivity();
+}
+
+//-----------------------------------------------------------------------------
+// A little pre-render processing
+//-----------------------------------------------------------------------------
+
+void C_ShieldMobile::PreRender( )
+{
+	if (m_ShieldState & SHIELD_MOBILE_EMP)
+	{
+		// Decay fade if we've been EMPed or if we're inactive
+		if (m_FadeValue > 0.0f)
+		{
+			m_FadeValue -= gpGlobals->frametime / SHIELD_EMP_FADE_TIME;
+			if (m_FadeValue < 0.0f)
+			{
+				m_FadeValue = 0.0f;
+
+				// Reset the shield to un-wobbled state
+				m_ShieldEffect.ComputeControlPoints();
+			}
+			else
+			{
+				Vector dir;
+				AngleVectors( m_ShieldEffect.GetCurrentAngles(), & dir );
+
+				// Futz with the control points if we've been EMPed
+				for (int i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i)
+				{
+					// Get the direction for the point
+					float factor = -EMP_WAVE_AMPLITUDE * sin( i * M_PI * 0.5f + gpGlobals->curtime * M_PI / SHIELD_EMP_WOBBLE_TIME );
+					m_ShieldEffect.GetPoint(i) += dir * factor;
+				}
+			}
+		}
+	}
+	else
+	{
+		// Fade back in, no longer EMPed
+		if (m_FadeValue < 1.0f)
+		{
+			m_FadeValue += gpGlobals->frametime / SHIELD_EMP_FADE_TIME;
+			if (m_FadeValue >= 1.0f)
+			{
+				m_FadeValue = 1.0f;
+			}
+		}
+	}
+}
+
+void C_ShieldMobile::AddEntity( )
+{
+	BaseClass::AddEntity( );
+	PreRender();
+}
+
+//-----------------------------------------------------------------------------
+// Bounds computation
+//-----------------------------------------------------------------------------
+
+void C_ShieldMobile::GetBounds( Vector& mins, Vector& maxs )
+{
+	m_ShieldEffect.ComputeBounds( mins, maxs );
+}
+
+//-----------------------------------------------------------------------------
+// Return true if the panel is active 
+//-----------------------------------------------------------------------------
+
+bool C_ShieldMobile::IsPanelActive( int x, int y )
+{
+	return m_ShieldEffect.IsPanelActive(x, y);
+}
+
+//-----------------------------------------------------------------------------
+// Gets at the control point data; who knows how it was made?
+//-----------------------------------------------------------------------------
+
+void C_ShieldMobile::GetShieldData( Vector const** ppVerts, float* pOpacity, float* pBlend )
+{
+	for ( int i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i )
+	{
+		ppVerts[i] = &m_ShieldEffect.GetControlPoint(i);
+
+		if ( m_pVertsActive[i >> 3] & (1 << (i & 0x7)) )
+		{
+			pOpacity[i] = m_ShieldEffect.ComputeOpacity( *ppVerts[i], GetAbsOrigin() );
+			pBlend[i] = 1.0f;
+		}
+		else
+		{
+			pOpacity[i] = 192.0f;
+			pBlend[i] = 0.0f;
+		}
+	}
+}
+
diff --git a/game/client/tf2/c_tf2rootpanel.cpp b/game/client/tf2/c_tf2rootpanel.cpp
new file mode 100644
index 0000000..7e01f6f
--- /dev/null
+++ b/game/client/tf2/c_tf2rootpanel.cpp
@@ -0,0 +1,194 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_tf2rootpanel.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/IVGui.h>
+#include "paneleffect.h"
+#include "itfhintitem.h"
+#include "clientmode_commander.h"
+#include "commanderoverlaypanel.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//-----------------------------------------------------------------------------
+C_TF2RootPanel::C_TF2RootPanel( vgui::VPANEL parent )
+	: BaseClass( NULL, "TF2 Root Panel" )
+{
+	SetParent( parent );
+	SetPaintEnabled( false );
+	SetPaintBorderEnabled( false );
+	SetPaintBackgroundEnabled( false );
+
+	// This panel does post child painting
+	SetPostChildPaintEnabled( true );
+
+	// Make it screen sized
+	SetBounds( 0, 0, ScreenWidth(), ScreenHeight() );
+
+	// Ask for OnTick messages
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TF2RootPanel::~C_TF2RootPanel( void )
+{
+	ClearAllEffects();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TF2RootPanel::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_TF2RootPanel::RenderPanelEffects( void )
+{
+	for ( int i = 0; i < m_Effects.Size(); i++ )
+	{
+		CPanelEffect *e = m_Effects[ i ];
+		Assert( e );
+		ITFHintItem *owner = e->GetOwner();
+		if ( owner && !owner->ShouldRenderPanelEffects() )
+			continue;
+		if ( e->GetVisible() )
+		{
+			e->doPaint( this );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add effect to list
+// Input  : *effect - 
+//-----------------------------------------------------------------------------
+EFFECT_HANDLE C_TF2RootPanel::AddEffect( CPanelEffect *effect )
+{
+	Assert( effect );
+
+	m_Effects.AddToTail( effect );
+
+	return effect->GetHandle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove effect from list
+// Input  : *effect - 
+//-----------------------------------------------------------------------------
+void C_TF2RootPanel::RemoveEffect( EFFECT_HANDLE handle )
+{
+	for ( int i = m_Effects.Size() - 1; i >= 0; i-- )
+	{
+		CPanelEffect *e = m_Effects[ i ];
+		if ( e->GetHandle() == handle )
+		{
+			m_Effects.Remove( i );
+			delete e;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find effect by handle
+// Input  : handle - 
+// Output : CPanelEffect
+//-----------------------------------------------------------------------------
+CPanelEffect *C_TF2RootPanel::FindEffect( EFFECT_HANDLE handle )
+{
+	for ( int i = 0; i < m_Effects.Size(); i++ )
+	{
+		CPanelEffect *e = m_Effects[ i ];
+		if ( e->GetHandle() == handle )
+		{
+			return e;
+		}
+	}
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Delete all effects
+//-----------------------------------------------------------------------------
+void C_TF2RootPanel::ClearAllEffects( void )
+{
+	while ( m_Effects.Size() > 0 )
+	{
+		CPanelEffect *e = m_Effects[ 0 ];
+		m_Effects.Remove( 0 );
+		delete e;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TF2RootPanel::OnTick( void )
+{
+	// Go backards
+	for ( int i = m_Effects.Size() - 1; i >= 0; i-- )
+	{
+		CPanelEffect *e = m_Effects[ i ];
+		Assert( e );
+
+		// Allow panel to think
+		e->Think();
+
+		// See if panel should disappear
+		if ( e->ShouldRemove() )
+		{
+			m_Effects.Remove( i );
+			delete e;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reset effects on level load/shutdown
+//-----------------------------------------------------------------------------
+void C_TF2RootPanel::LevelInit( void )
+{
+	ClearAllEffects();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TF2RootPanel::LevelShutdown( void )
+{
+	ClearAllEffects();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Delete any panel effects owned by owner
+// Input  : *owner - 
+//-----------------------------------------------------------------------------
+void C_TF2RootPanel::DestroyPanelEffects( ITFHintItem *owner )
+{
+	for ( int i = m_Effects.Size() - 1; i >= 0; i-- )
+	{
+		CPanelEffect *e = m_Effects[ i ];
+		if ( e->GetOwner() == owner )
+		{
+			m_Effects.Remove( i );
+			delete e;
+		}
+	}
+}
+
diff --git a/game/client/tf2/c_tf2rootpanel.h b/game/client/tf2/c_tf2rootpanel.h
new file mode 100644
index 0000000..264475e
--- /dev/null
+++ b/game/client/tf2/c_tf2rootpanel.h
@@ -0,0 +1,63 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF2ROOTPANEL_H
+#define C_TF2ROOTPANEL_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_TF2RootPanel : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+public:
+						C_TF2RootPanel( vgui::VPANEL parent );
+	virtual				~C_TF2RootPanel( void );
+
+	// Draw Panel effects here
+	virtual void		PostChildPaint();
+
+	// Clear list of Panel Effects
+	virtual void		LevelInit( void );
+	virtual void		LevelShutdown( void );
+
+	// Panel Effect handlers
+	EFFECT_HANDLE		AddEffect( CPanelEffect *effect );
+	void				RemoveEffect( EFFECT_HANDLE handle );
+	CPanelEffect		*FindEffect( EFFECT_HANDLE handle );
+	void				DestroyPanelEffects( ITFHintItem *owner );
+	void				ClearAllEffects( 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_TF2RootPanel *g_pTF2RootPanel;
+
+#endif // C_TF2ROOTPANEL_H
diff --git a/game/client/tf2/c_tf_basecombatweapon.cpp b/game/client/tf2/c_tf_basecombatweapon.cpp
new file mode 100644
index 0000000..6408570
--- /dev/null
+++ b/game/client/tf2/c_tf_basecombatweapon.cpp
@@ -0,0 +1,310 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CBaseTFCombatWeapon
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_basecombatweapon.h"
+#include "hud.h"
+#include "iclientmode.h"
+#include "tf_hints.h"
+#include "itfhintitem.h"
+#include "c_tf_basehint.h"
+#include "hud_technologytreedoc.h"  
+#include "c_tf_hintmanager.h"
+#include "hud_ammo.h"
+#include "c_weapon__stubs.h"
+#include "c_tf_class_sapper.h"
+#include <vgui/ISurface.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+STUB_WEAPON_CLASS_IMPLEMENT( foo_tf_machine_gun, C_TFMachineGun );
+
+IMPLEMENT_CLIENTCLASS_DT( C_TFMachineGun, DT_TFMachineGun, CTFMachineGun )
+END_RECV_TABLE()
+
+// Share crosshair stuff among all weapons
+bool C_BaseTFCombatWeapon::m_bCrosshairInitialized = false;
+vgui::Label	*C_BaseTFCombatWeapon::m_pCrosshairAmmo = NULL;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_BaseTFCombatWeapon::DrawModel( int flags )
+{
+	int iDrawn = 0;
+
+	// If my carrier is camouflaged, apply the camo to me too
+	if ( IsBeingCarried() )
+	{
+		C_BaseTFPlayer *pPlayer = (C_BaseTFPlayer *)GetOwner();
+		if ( pPlayer )
+		{
+			if ( pPlayer->IsCamouflaged())
+			{
+				if ( pPlayer->GetCamoMaterial() && ( pPlayer->ComputeCamoEffectAmount() != 1.0f ) )
+				{
+					modelrender->ForcedMaterialOverride( pPlayer->GetCamoMaterial() );
+					iDrawn = BaseClass::DrawModel(flags);
+					modelrender->ForcedMaterialOverride( NULL );
+				}
+				return iDrawn;
+			}
+		}
+	}
+
+	return BaseClass::DrawModel(flags);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_BaseTFCombatWeapon::GetFxBlend( void )
+{
+	if ( !IsCamouflaged() )
+		return BaseClass::GetFxBlend();
+
+	return ((C_BaseTFPlayer *)GetOwner())->GetFxBlend();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_BaseTFCombatWeapon::IsTransparent( void )
+{
+	if ( IsCamouflaged() )
+		return true;
+
+	return BaseClass::IsTransparent();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : static void
+//-----------------------------------------------------------------------------
+void C_BaseTFCombatWeapon::CreateCrosshairPanels( void )
+{
+	m_pCrosshairAmmo	= new vgui::Label( (vgui::Panel *)NULL, "crosshairammo", "100" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFCombatWeapon::DestroyCrosshairPanels( void )
+{
+	delete m_pCrosshairAmmo;
+	m_pCrosshairAmmo = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_BaseTFCombatWeapon::InitializeCrosshairPanels( void )
+{
+	// Init the crosshair labels if they haven't been
+	if ( m_bCrosshairInitialized )
+		return;
+
+	m_bCrosshairInitialized = true;
+
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	m_pCrosshairAmmo->SetContentAlignment( vgui::Label::a_northeast );
+	m_pCrosshairAmmo->SetFgColor( Color( 255, 170, 0, 255 ) );
+	m_pCrosshairAmmo->SetPaintBackgroundEnabled( false );
+	m_pCrosshairAmmo->SetPos( CROSSHAIR_AMMO_LEFT, CROSSHAIR_AMMO_TOP );
+	m_pCrosshairAmmo->SetSize( CROSSHAIR_HEALTH_OFFSET / 2, m_pCrosshairAmmo->GetTall() );
+	m_pCrosshairAmmo->SetParent( pParent );
+	m_pCrosshairAmmo->SetAutoDelete( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the ammo counts
+//-----------------------------------------------------------------------------
+void C_BaseTFCombatWeapon::DrawAmmo()
+{
+	// Get the local player
+	C_BaseTFPlayer *player = C_BaseTFPlayer::GetLocalPlayer();
+	if ( player == NULL )
+		return;
+
+	GetHudAmmo()->SetPrimaryAmmo( 
+		m_iPrimaryAmmoType, 
+		GetPrimaryAmmo(), 
+		Clip1(), 
+		GetMaxClip1() );
+	GetHudAmmo()->SetSecondaryAmmo( 
+		m_iSecondaryAmmoType, 
+		GetSecondaryAmmo(), 
+		Clip2(), 
+		GetMaxClip2() );
+
+	// ROBIN: Disabled mini ammo count for now
+	/*
+	InitializeCrosshairPanels();
+	DrawMiniAmmo();
+	*/
+
+	// HACK: Draw technician's drain level
+	if ( IsLocalPlayerClass( TFCLASS_SAPPER ) )
+	{
+		C_PlayerClassSapper *pSapper = (C_PlayerClassSapper *)player->GetPlayerClass();
+
+		int r, g, b, a;
+		int x, y;
+
+		// Get the drained energy
+		float flPowerLevel = pSapper->m_flDrainedEnergy;
+		float flInverseFactor = 1.0 - flPowerLevel;
+		
+		gHUD.m_clrNormal.GetColor( r, g, b, a );
+
+		int iWidth = XRES(12);
+		int iHeight = YRES(64);
+
+		x = XRES(64);
+		y = ( ScreenHeight() - YRES(2) - iHeight );
+
+		// draw the exhausted portion of the bar.
+		vgui::surface()->DrawSetColor( Color( r, g * flPowerLevel, b * flPowerLevel, 100 ) );
+		vgui::surface()->DrawFilledRect( x, y, x + iWidth, y + iHeight * flInverseFactor );
+
+		// draw the powerered portion of the bar
+		vgui::surface()->DrawSetColor( Color( r, g * flPowerLevel, b * flPowerLevel, 190 ) );
+		vgui::surface()->DrawFilledRect( x, y + iHeight * flInverseFactor, x + iWidth, y + iHeight * flInverseFactor + iHeight * flPowerLevel );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the mini ammo/health counts around the health
+//-----------------------------------------------------------------------------
+void C_BaseTFCombatWeapon::DrawMiniAmmo()
+{
+	// Get the local player
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( pPlayer == NULL )
+		return;
+
+	// Draw the ammo to the right of the crosshair
+	if ( m_iClip1 >= 0 )
+		m_pCrosshairAmmo->SetText( VarArgs("%.3d", m_iClip1 < 999 ? m_iClip1 : 999) );
+	else
+		m_pCrosshairAmmo->SetText( VarArgs("%.3d", GetPrimaryAmmo() < 999 ? GetPrimaryAmmo() : 999) );
+
+	// BUG: This shouldn't need to be reset, since it's set in the section above, on initialization
+	m_pCrosshairAmmo->SetSize( CROSSHAIR_HEALTH_OFFSET / 2, m_pCrosshairAmmo->GetTall() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if a weapon-pickup icon should be displayed when this weapon is received
+//-----------------------------------------------------------------------------
+bool C_BaseTFCombatWeapon::ShouldDrawPickup( void )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *C_BaseTFCombatWeapon::GetPrintName( void )
+{
+	return GetWpnData().szPrintName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_BaseTFCombatWeapon::ShouldShowUsageHint( void )
+{
+	return GetWpnData().bShowUsageHint;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bnewentity - 
+//-----------------------------------------------------------------------------
+void C_BaseTFCombatWeapon::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType != DATA_UPDATE_CREATED )
+		return;
+
+	if ( !ShouldShowUsageHint() )
+		return;
+
+	// See if the weapon is given as an associated weapon of a technology that
+	//  is of level 1 or greater
+	CTechnologyTree *tree = GetTechnologyTreeDoc().GetTechnologyTree();
+	if ( !tree )
+		return;
+
+	bool done = false;
+	for ( int i = 0; !done && ( i < tree->GetNumberTechnologies() ); i++ )
+	{
+		CBaseTechnology *t = tree->GetTechnology( i );
+		Assert( t );
+		if ( !t )
+			continue;
+
+		// Must be associated with a tech >= level 1
+		if ( t->GetLevel() < 1 )
+			continue;
+
+		for ( int j = 0; j < t->GetNumWeaponAssociations(); j++ )
+		{
+			const char *associated_weapon = t->GetAssociatedWeapon( j );
+			if ( !associated_weapon )
+				continue;
+
+			if ( !GetName() )
+				continue;
+
+			// Is this tech associating the weapon
+			if ( stricmp( GetName(), associated_weapon ) )
+				continue;
+
+			if ( t->GetHintsGiven( TF_HINT_WEAPONRECEIVED ) )
+				continue;
+
+			t->SetHintsGiven( TF_HINT_WEAPONRECEIVED, true );
+
+			// Fill in hint data for this weapon
+			// Only show a max of 3 or 4 weapon received hints at a time
+			C_TFBaseHint *hint = CreateGlobalHint( TF_HINT_WEAPONRECEIVED, GetPrintName(), -1, 3 );
+			if ( hint )
+			{
+				ITFHintItem *item = hint->GetHintItem( 0 );
+				if ( item )
+				{
+					item->SetKeyValue( "weapon", GetPrintName() );
+					item->SetKeyValue( "weapontype", GetName() );
+				}
+			}
+
+			done = true;
+			break;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	C_BaseTFCombatWeapon ::GetSecondaryAmmo( void )
+{
+	// Get the local player
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( pPlayer == NULL )
+		return 0;
+
+	return pPlayer->GetAmmoCount( m_iSecondaryAmmoType );
+}
diff --git a/game/client/tf2/c_tf_basecombatweapon.h b/game/client/tf2/c_tf_basecombatweapon.h
new file mode 100644
index 0000000..9ed6f52
--- /dev/null
+++ b/game/client/tf2/c_tf_basecombatweapon.h
@@ -0,0 +1,47 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Clients TF Base combat weapon
+//
+// $NoKeywords: $
+//=============================================================================//
+#ifndef C_TF_BASECOMBATWEAPON_H
+#define C_TF_BASECOMBATWEAPON_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_baseanimating.h"
+
+class CViewSetup;
+class C_BaseTFPlayer;
+
+// Crosshair info positions
+#define CROSSHAIR_HEALTH_TOP		YRES(266)
+#define CROSSHAIR_HEALTH_OFFSET		XRES(80)
+#define CROSSHAIR_HEALTH_LEFT		((ScreenWidth() - CROSSHAIR_HEALTH_OFFSET) / 2)
+#define CROSSHAIR_AMMO_TOP			CROSSHAIR_HEALTH_TOP
+#define CROSSHAIR_AMMO_LEFT			(ScreenWidth() / 2)
+
+namespace vgui
+{
+	class Label;
+};
+
+#include "basetfcombatweapon_shared.h"
+
+class C_TFMachineGun : public C_BaseTFCombatWeapon
+{
+private:
+	DECLARE_CLASS( C_TFMachineGun, C_BaseTFCombatWeapon );
+
+public:
+	C_TFMachineGun() {}
+
+	DECLARE_CLIENTCLASS();
+	DECLARE_PREDICTABLE();
+
+private:
+	C_TFMachineGun( const C_TFMachineGun & );
+};
+
+#endif // C_TF_BASECOMBATWEAPON_H
diff --git a/game/client/tf2/c_tf_basehint.cpp b/game/client/tf2/c_tf_basehint.cpp
new file mode 100644
index 0000000..61c16c1
--- /dev/null
+++ b/game/client/tf2/c_tf_basehint.cpp
@@ -0,0 +1,691 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_basehint.h"
+#include "tf_hints.h"
+#include "itfhintitem.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/IVGui.h>
+#include <vgui/Cursor.h>
+#include <vgui_controls/Label.h>
+#include <vgui/ISurface.h>
+#include <vgui/IScheme.h>
+#include "vgui_int.h"
+#include "hintitembase.h"
+#include <KeyValues.h>
+
+HINTCOMPLETIONFUNCTION LookupCompletionFunction( const char *name );
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : id - 
+//			priority - 
+//			player - 
+//			entity - 
+//-----------------------------------------------------------------------------
+C_TFBaseHint::C_TFBaseHint( int id, int priority, int entity, HINTCOMPLETIONFUNCTION pfn /*=NULL*/ )
+	: vgui::Panel( NULL, "TFBaseHint" ), m_CursorNone( vgui::dc_none )
+{
+	m_pObject = NULL;
+	m_pClearLabel = NULL;
+	m_pCaption = NULL;
+	m_pfnCompletion = pfn;
+
+	// Child of main panel
+	SetParent( VGui_GetClientDLLRootPanel() );
+	
+	// Put at top of z-order (happens in Think, too)
+//	MoveToFront();
+
+	// No cursor
+	SetCursor( m_CursorNone );
+	// Set to default size
+	SetSize( TFBASEHINT_DEFAULT_WIDTH, TFBASEHINT_DEFAULT_HEIGHT );
+	// We'll expressly delete it
+	SetAutoDelete( false );
+
+	// Set up default values
+	SetID( id );
+	SetPriority( priority );
+	SetEntity( entity );
+	SetCompleted( false );
+	// Target panel
+	m_hTarget		= NULL; 
+	
+	m_bMoving		= false;
+	m_flMoveRemaining	= 0.0f;
+	m_flMoveTotal		= 0.0f;
+
+	for ( int pt = 0; pt < 2; pt++ )
+	{
+		m_nMoveStart[ pt ] = 0;
+		m_nMoveEnd[ pt ] = 0;
+	}
+
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	// Create clear label
+	m_pClearLabel = new vgui::Label( this, "CLEAR", "[Enter] to remove, [Enter] twice quickly to remove all..." );
+	m_pClearLabel->SetContentAlignment( vgui::Label::a_west );
+	m_pClearLabel->SetTextInset( 3, 2 );
+
+	// Create window caption
+	m_pCaption = new vgui::Label( this, "CAPTION", "" );
+	m_pCaption->SetContentAlignment( vgui::Label::a_west );
+	m_pCaption->SetTextInset( 3, 0 );
+
+	// See if the hint started out complete!
+	CheckForCompletion();
+
+	// Always start out hidden
+	SetVisible( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TFBaseHint::~C_TFBaseHint( void )
+{
+	RemoveAllHintItems( true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Applying scheme settings
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+
+	vgui::HFont hSmallFont = pScheme->GetFont( "DefaultVerySmall" );
+	vgui::HFont hCaptionFont = pScheme->GetFont( "DefaultSmall" );
+	m_pClearLabel->SetFont( hSmallFont );
+	m_pCaption->SetFont( hCaptionFont );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pkv - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::ParseFromData( KeyValues *pkv )
+{
+	int priority = pkv->GetInt( "priority", 100 );
+	SetPriority( priority );
+	int width = pkv->GetInt( "width", TFBASEHINT_DEFAULT_WIDTH );
+	if ( !width && !stricmp( pkv->GetString( "width" ), "default" ) )
+	{
+		width = TFBASEHINT_DEFAULT_WIDTH;
+	}
+	SetSize( width, TFBASEHINT_DEFAULT_HEIGHT );
+	const char *title = pkv->GetString( "title" );
+	if ( title )
+	{
+		SetTitle( title );
+	}
+
+	const char *completionfunction = pkv->GetString( "completionfunction" );
+	if ( completionfunction && strlen( completionfunction ) > 0 )
+	{
+		SetCompletionFunction( LookupCompletionFunction( completionfunction ) );
+	}
+
+	KeyValues *items = pkv->FindKey( "items" );
+	if ( items )
+	{
+		KeyValues *pkvItem = items->GetFirstSubKey();
+		for( ; pkvItem ; pkvItem = pkvItem->GetNextKey() )
+		{
+			CHintItemBase *item = CreateHintItem( this, pkvItem->GetName() );
+			if ( item )
+			{
+				item->ParseItem( pkvItem );
+				item->ComputeTitle();
+
+				item->SetSize( GetWide(), 20 );
+				
+				AddHintItem( item );
+			}
+			else
+			{
+				Msg( "C_TFBaseHint::ParseFromData:  Failed to create hint item %s\n", pkvItem->GetName() );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : int&x - 
+//			y - 
+//			w - 
+//			&h - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::GetClientArea( int&x, int& y, int& w, int &h )
+{
+	GetSize( w, h );
+
+	x = BORDER;
+	y = BORDER + CAPTION;
+
+	w -= 2 * BORDER;
+	h -= 2 * BORDER;
+
+	h -= CAPTION;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *title - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetTitle( const char *title )
+{
+	if ( m_pCaption )
+	{
+		m_pCaption->SetText( title );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::PaintBackground()
+{
+	SetBgColor( Color( 240, 240, 220, 255 ) );
+	if ( m_pCaption )
+	{
+		m_pCaption->SetBgColor( Color( 163, 180, 200, 255 ) );
+
+		m_pCaption->SetFgColor( Color( 0, 0, 0, 255 ) );
+	}
+	if ( m_pClearLabel )
+	{
+		m_pClearLabel->SetBgColor( Color( 230, 230, 210, 255 ) );
+		m_pClearLabel->SetFgColor( Color( 100, 127, 160, 255 ) );
+	}
+
+	BaseClass::PaintBackground();
+
+	int w, h;
+	GetSize( w, h );
+
+	vgui::surface()->DrawSetColor( 0, 0, 0, 255 );
+	vgui::surface()->DrawOutlinedRect( 0, 0, w, h );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::PerformLayout()
+{
+	BaseClass::PerformLayout();
+
+	int x, y, w, h;
+	GetClientArea( x, y, w, h );
+
+	int itemh;
+
+	int needY = 4;
+
+	for ( int i = 0; i < GetNumHintItems(); i++ )
+	{
+		ITFHintItem *item = GetHintItem( i );
+		if ( item )
+		{
+			itemh = item->GetHeight();
+
+			item->SetPosition( x, y + 2 );
+			item->SetItemNumber( i + 1 );
+
+			if ( i == 0 )
+			{
+				item->SetVisible( true );
+				needY += itemh + 2;
+			}
+			else
+			{
+				item->SetVisible( false );
+			}
+		}
+	}
+
+	needY += 8;
+
+	if ( m_pClearLabel )
+	{
+		m_pClearLabel->SetBounds( x, y + needY + 2, w, 14 );
+	}
+
+	if ( m_pCaption )
+	{
+		m_pCaption->SetBounds( x, BORDER, w, CAPTION );
+	}
+
+	needY += 14 + BORDER;
+
+	int needPixels = needY - h;
+
+	int trueW, trueH;
+	GetSize( trueW, trueH );
+
+	SetSize( trueW, trueH + needPixels );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Install completion function
+// Input  : pfn - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetCompletionFunction( HINTCOMPLETIONFUNCTION pfn )
+{
+	m_pfnCompletion = pfn;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::CheckForCompletion( void )
+{
+	if ( m_pfnCompletion )
+	{
+		bool complete = (*m_pfnCompletion)( this );
+		if ( complete )
+		{
+			SetCompleted( true );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::OnTick()
+{
+	if ( !IsVisible() )
+		return;
+
+//	MoveToFront();
+
+	// Check for completion of entire hint
+	CheckForCompletion();
+
+	bool setactive = false;
+	int numactive = 0;
+	// Remove obsolete items
+	int i;
+	for ( i = m_Hints.Size() - 1; i >= 0; i-- )
+	{
+		ITFHintItem *item = m_Hints[ i ];
+		if ( !item )
+			continue;
+
+		if ( item->GetCompleted() )
+		{
+			RemoveHintItem( i );
+		}
+		else
+		{
+			numactive++;
+		}
+	}
+
+	// Mark first one as active
+	// Perform think
+	for ( i = 0; i < m_Hints.Size(); i++ )
+	{
+		ITFHintItem *item = m_Hints[ i ];
+		if ( !item )
+			continue;
+
+		if ( !setactive )
+		{
+			item->SetActive( true );
+			setactive = true;
+		}
+		else
+		{
+			item->SetActive( false );
+		}
+
+		// Think, too
+		if ( item->GetActive() )
+		{
+			item->Think();
+		}
+	}
+
+	// No more active items
+	if ( !numactive )
+	{
+		SetCompleted( true );
+	}
+
+	// Keep moving window to correct position
+	AnimatePosition();
+
+/*
+	static float nextchange = 0.0f;
+
+	if ( gpGlobals->curtime < nextchange )
+		return;
+
+	nextchange = gpGlobals->curtime + 1.0f;
+
+	int w, h;
+	GetSize( w, h );
+
+	int x = random->RandomInt( 0, ScreenWidth() - w );
+	int y = random->RandomInt( 0, ScreenHeight() - h );
+
+	SetDesiredPosition( x, y, 0.9f );
+*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_TFBaseHint::GetID( void )
+{
+	return m_nID;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : id - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetID( int id )
+{
+	m_nID = id;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_TFBaseHint::GetPriority( void )
+{
+	return m_nPriority;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : priority - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetPriority( int priority )
+{
+	m_nPriority = priority;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_TFBaseHint::GetEntity( void )
+{
+	return m_nEntity;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : C_BaseEntity
+//-----------------------------------------------------------------------------
+C_BaseEntity *C_TFBaseHint::GetBaseEntity( void )
+{
+	return m_nEntity != -1 ? cl_entitylist->GetEnt( m_nEntity ) : NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : entity - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetEntity( int entity )
+{
+	m_nEntity = entity;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *entity - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetBaseEntity( C_BaseEntity *entity )
+{
+	m_nEntity = entity ? entity->index : -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_TFBaseHint::GetCompleted( void )
+{
+	return m_bCompleted;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : completed - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetCompleted( bool completed )
+{
+	m_bCompleted = completed;
+	// Hide the window right away if it's finished
+	SetVisible( !completed );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *item - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::AddHintItem( ITFHintItem *item )
+{
+	m_Hints.AddToTail( item );
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : index - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::RemoveHintItem( int index )
+{
+	ITFHintItem *item = GetHintItem( index );
+	if ( item )
+	{
+		m_Hints.Remove( index );
+		item->DeleteThis();
+		InvalidateLayout();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_TFBaseHint::GetNumHintItems( void )
+{
+	return m_Hints.Size();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : deleteitems - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::RemoveAllHintItems( bool deleteitems )
+{
+	while ( m_Hints.Size() > 0 )
+	{
+		ITFHintItem *item = m_Hints[ 0 ];
+		m_Hints.Remove( 0 );
+		if ( deleteitems )
+		{
+			item->DeleteThis();
+		}
+	}
+
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : index - 
+//-----------------------------------------------------------------------------
+ITFHintItem	*C_TFBaseHint::GetHintItem( int index )
+{
+	if ( index < 0 || index >= m_Hints.Size() )
+	{
+		return NULL;
+	}
+
+	return m_Hints[ index ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//			movementtime - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetDesiredPosition( int x, int y, float movementtime /*=0.3f*/ )
+{
+	m_bMoving = true;
+
+	m_flMoveRemaining = movementtime;
+	m_flMoveTotal = movementtime;
+	
+	int ox, oy;
+	GetPos( ox, oy );
+
+	m_nMoveStart[ 0 ] = ox;
+	m_nMoveStart[ 1 ] = oy;
+
+	m_nMoveEnd[ 0 ] = x;
+	m_nMoveEnd[ 1 ] = y;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float C_TFBaseHint::GetMovementFraction( void )
+{
+	float frac = 0.0f;
+	
+	if ( m_flMoveTotal > 0.0f )
+	{
+		frac = 1.0f - ( m_flMoveRemaining / m_flMoveTotal );
+	}
+
+	float squared = frac * frac;
+	
+	frac = 3 * squared - 2 * frac * squared;
+
+	// Simple spline
+	frac = clamp( frac, 0.0f, 1.0f );
+
+	return frac;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::AnimatePosition( void )
+{
+	if ( !m_bMoving )
+		return;
+
+	m_flMoveRemaining -= gpGlobals->frametime;
+	if ( m_flMoveRemaining <= 0.0f )
+	{
+		m_bMoving = false;
+		SetPos( m_nMoveEnd[ 0 ], m_nMoveEnd[ 1 ] );
+		return;
+	}
+
+	float frac = GetMovementFraction();
+
+	int dx = m_nMoveEnd[ 0 ] - m_nMoveStart[ 0 ];
+	int dy = m_nMoveEnd[ 1 ] - m_nMoveStart[ 1 ];
+
+	int x, y;
+
+	x = m_nMoveStart[ 0 ] + ( int )( frac * dx );
+	y = m_nMoveStart[ 1 ] + ( int )( frac * dy );
+
+	SetPos( x, y );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Helper to center a panel
+// Input  : *panel - 
+// Output : static void
+//-----------------------------------------------------------------------------
+static void PositionHintNoTarget( C_TFBaseHint *panel )
+{
+	int w, h;
+	panel->GetSize( w, h );
+	int y = ( ScreenHeight() - h ) / 2;
+
+	panel->SetDesiredPosition( ScreenWidth() - w - 10, y );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void C_TFBaseHint::SetHintTarget( vgui::Panel *panel )
+{
+	m_hTarget = panel;
+
+	if ( panel )
+	{
+		int hintW, hintH;
+		
+		GetSize( hintW, hintH );
+
+		int x, y, w, h;
+		panel->GetBounds( x, y, w, h );
+
+		// Try and position ourselves up and to left of target item?
+		x = x - ( hintW - w );
+		y = y - ( hintH ) - 40;
+
+		// Don't let it hang off screen
+		if ( x < 3 )
+		{
+			x = 3;
+		}
+		else if ( x + hintW + 3 >= ScreenWidth() )
+		{
+			int over = ( x + hintW + 3 - ScreenWidth() );
+
+			x -= over;
+		}
+		
+		if ( y < 3 )
+		{
+			y = 3;
+		}
+		else if ( y + hintH >= ScreenHeight() )
+		{
+			int over = ( y + hintH + 3 - ScreenHeight() );
+
+			y -= over;
+		}
+
+		SetDesiredPosition( x, y );
+	}
+	else
+	{
+		PositionHintNoTarget( this );
+	}
+
+	// Tell hint items that there is a new target
+	for ( int i = 0 ; i < GetNumHintItems(); i++ )
+	{
+		ITFHintItem *item = GetHintItem( i );
+		item->SetHintTarget( panel );
+	}
+}
diff --git a/game/client/tf2/c_tf_basehint.h b/game/client/tf2/c_tf_basehint.h
new file mode 100644
index 0000000..3263673
--- /dev/null
+++ b/game/client/tf2/c_tf_basehint.h
@@ -0,0 +1,147 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_BASEHINT_H
+#define C_TF_BASEHINT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/PHandle.h>
+#include "utlvector.h"
+
+class C_BaseTFPlayer;
+class C_BaseEntity;
+class ITFHintItem;
+class KeyValues;
+namespace vgui
+{
+	class Label;
+}
+
+class C_TFBaseHint;
+
+typedef bool (*HINTCOMPLETIONFUNCTION)( C_TFBaseHint *hint );
+
+#define TFBASEHINT_DEFAULT_WIDTH 400
+#define TFBASEHINT_DEFAULT_HEIGHT 300
+
+//-----------------------------------------------------------------------------
+// Purpose: Base TF Hint UI Element
+//  hints must position themselves and are responsible for any "sub objects"
+//-----------------------------------------------------------------------------
+class C_TFBaseHint : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+public:
+	enum
+	{
+		BORDER = 2,
+		CAPTION = 17
+	};
+
+	// Factory for hints
+	static C_TFBaseHint				*CreateHint( int id, const char *subsection, int entity );
+
+	// Construction
+									C_TFBaseHint( int id, int priority, int entity, HINTCOMPLETIONFUNCTION pfn = NULL );
+	virtual							~C_TFBaseHint( void );
+
+	// Initialization
+	virtual void					ParseFromData( KeyValues *pkv );
+
+	// Redraw self
+	virtual void					PaintBackground();
+	virtual void					PerformLayout();
+	virtual void					GetClientArea( int&x, int& y, int& w, int &h );
+	virtual void					SetTitle( const char *title );
+
+	// Panel will move itself to spot over movementtime
+	virtual void					SetDesiredPosition( int x, int y, float movementtime = 0.3f );
+
+	// Target element for hint
+	virtual void					SetHintTarget( vgui::Panel *panel );
+
+	// Scheme
+	virtual void					ApplySchemeSettings(vgui::IScheme *pScheme);
+
+	// Think
+	virtual void					OnTick();
+	// Derived classes should set m_bCompleted here for entire hint
+	virtual void					CheckForCompletion( void );
+
+	// Data access
+	virtual int						GetID( void );
+	virtual void					SetID( int id );
+
+	virtual int						GetPriority( void );
+	virtual void					SetPriority( int priority );
+
+	virtual int						GetEntity( void );
+	virtual C_BaseEntity			*GetBaseEntity( void );
+	virtual void					SetEntity( int entity );
+	virtual void					SetBaseEntity( C_BaseEntity *entity );
+
+	// Install a function used to determine if the global hint requirements have
+	//  been met
+	virtual bool					GetCompleted( void );
+	virtual void					SetCompleted( bool completed );
+	virtual void					SetCompletionFunction( HINTCOMPLETIONFUNCTION pfn );
+
+	// Accessors for hint items themselves
+	virtual void					AddHintItem( ITFHintItem *item );
+	virtual void					RemoveHintItem( int index );
+	virtual int						GetNumHintItems( void );
+	virtual void					RemoveAllHintItems( bool deleteitems );
+	virtual ITFHintItem				*GetHintItem( int index );
+
+protected:
+	// Move current position toward desirec position
+	virtual void					AnimatePosition( void );
+	virtual float					GetMovementFraction( void );
+
+	// In the process of moving
+	bool							m_bMoving;
+
+	// Amount of move time remaining
+	float							m_flMoveRemaining;
+	// Total move time
+	float							m_flMoveTotal;
+	// Start/end positions for panel movement
+	int								m_nMoveStart[2];
+	int								m_nMoveEnd[2];
+
+private:
+	// ID of the hint
+	int								m_nID;
+	// Priority of the hint
+	int								m_nPriority;
+	// Associated entity
+	int								m_nEntity;
+	// Has the hint been completed
+	bool							m_bCompleted;
+	// Object hint is associated with
+	void							*m_pObject;
+	// No mouse
+	vgui::HCursor					m_CursorNone;
+	// "Press [Esc]..."
+	vgui::Label						*m_pClearLabel;
+	// Window caption
+	vgui::Label						*m_pCaption;
+
+	// Safe handle to target object
+	vgui::PHandle					m_hTarget;
+
+	// Completion function
+	HINTCOMPLETIONFUNCTION			m_pfnCompletion;
+
+	// List of items
+	CUtlVector< ITFHintItem * >		m_Hints;
+};
+
+#endif // C_TF_BASEHINT_H
diff --git a/game/client/tf2/c_tf_class_commando.cpp b/game/client/tf2/c_tf_class_commando.cpp
new file mode 100644
index 0000000..4d5e78c
--- /dev/null
+++ b/game/client/tf2/c_tf_class_commando.cpp
@@ -0,0 +1,136 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_commando.h"
+#include "usercmd.h"
+
+//=============================================================================
+//
+// Commando Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassCommando, DT_PlayerClassCommandoData )
+	RecvPropInt		( RECVINFO( m_ClassData.m_bCanBullRush ) ),
+	RecvPropInt		( RECVINFO( m_ClassData.m_bBullRush ) ),
+	RecvPropVector	( RECVINFO( m_ClassData.m_vecBullRushDir ) ),
+	RecvPropVector	( RECVINFO( m_ClassData.m_vecBullRushViewDir ) ),
+	RecvPropVector	( RECVINFO( m_ClassData.m_vecBullRushViewGoalDir ) ),
+	RecvPropFloat	( RECVINFO( m_ClassData.m_flBullRushTime ) ),
+	RecvPropFloat	( RECVINFO( m_ClassData.m_flDoubleTapForwardTime ) ),
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassCommando )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassCommandoData_t ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassCommando::C_PlayerClassCommando( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+	m_ClassData.m_bCanBullRush = false;
+	m_ClassData.m_bBullRush = false;
+	m_ClassData.m_vecBullRushDir.Init();
+	m_ClassData.m_vecBullRushViewDir.Init();
+	m_ClassData.m_vecBullRushViewGoalDir.Init();
+	m_ClassData.m_flBullRushTime = COMMANDO_TIME_INVALID;
+	m_ClassData.m_flDoubleTapForwardTime = COMMANDO_TIME_INVALID;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassCommando::~C_PlayerClassCommando()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PlayerClassCommando::ClassThink( void )
+{
+	CheckBullRushState();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PlayerClassCommando::PostClassThink( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PlayerClassCommando::ClassPreDataUpdate( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PlayerClassCommando::ClassOnDataChanged( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PlayerClassCommando::CreateMove( float flInputSampleTime, CUserCmd *pCmd )
+{
+	if ( m_ClassData.m_bBullRush )
+	{
+		pCmd->viewangles = m_ClassData.m_vecBullRushViewDir;
+		QAngle angles = m_ClassData.m_vecBullRushViewDir;
+		engine->SetViewAngles( angles );
+	} 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_PlayerClassCommando::CanGetInVehicle( void )
+{
+	if ( m_ClassData.m_bBullRush )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PlayerClassCommando::CheckBullRushState( void )
+{
+	if ( m_ClassData.m_bBullRush )
+	{
+		InterpolateBullRushViewAngles();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_PlayerClassCommando::InterpolateBullRushViewAngles( void )
+{
+	// Determine the fraction.
+	if ( m_ClassData.m_flBullRushTime < COMMANDO_BULLRUSH_VIEWDELTA_TEST )
+	{
+		m_ClassData.m_vecBullRushViewDir = m_ClassData.m_vecBullRushViewGoalDir;
+		return;
+	}
+
+	float flFraction = 1.0f - ( ( m_ClassData.m_flBullRushTime - COMMANDO_BULLRUSH_VIEWDELTA_TEST ) / COMMANDO_BULLRUSH_VIEWDELTA_TIME );
+
+	QAngle angCurrent;
+	InterpolateAngles( m_ClassData.m_vecBullRushViewDir, m_ClassData.m_vecBullRushViewGoalDir, angCurrent, flFraction ); 
+
+	NormalizeAngles( angCurrent );
+	m_ClassData.m_vecBullRushViewDir = angCurrent;
+}
diff --git a/game/client/tf2/c_tf_class_commando.h b/game/client/tf2/c_tf_class_commando.h
new file mode 100644
index 0000000..9ce42de
--- /dev/null
+++ b/game/client/tf2/c_tf_class_commando.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_COMMANDO_H
+#define C_TF_CLASS_COMMANDO_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+class C_PlayerClassCommando : public C_PlayerClass
+{
+public:
+	
+	DECLARE_CLASS( C_PlayerClassCommando, C_PlayerClass );
+
+	DECLARE_PREDICTABLE();
+
+								C_PlayerClassCommando( C_BaseTFPlayer *pPlayer );
+	virtual						~C_PlayerClassCommando();
+
+	PlayerClassCommandoData_t	*GetClassData( void ) { return &m_ClassData; } 
+
+	void						ClassThink( void );
+	void						PostClassThink( void );
+	void						ClassPreDataUpdate( void );
+	void						ClassOnDataChanged( void );
+
+	void						CreateMove( float flInputSampleTime, CUserCmd *pCmd );
+
+	// Vehicles
+	bool						CanGetInVehicle( void );
+
+	PlayerClassCommandoData_t	m_ClassData;
+
+private:
+
+	void						CheckBullRushState( void );
+	void						InterpolateBullRushViewAngles( void );
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassCommandoData )
+
+#endif // C_TF_CLASS_COMMANDO_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_defender.cpp b/game/client/tf2/c_tf_class_defender.cpp
new file mode 100644
index 0000000..e375aaf
--- /dev/null
+++ b/game/client/tf2/c_tf_class_defender.cpp
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_defender.h"
+
+//=============================================================================
+//
+// Defender Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassDefender, DT_PlayerClassDefenderData )
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassDefender )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassDefenderData_t ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassDefender::C_PlayerClassDefender( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassDefender::~C_PlayerClassDefender()
+{
+}
diff --git a/game/client/tf2/c_tf_class_defender.h b/game/client/tf2/c_tf_class_defender.h
new file mode 100644
index 0000000..a6cb73a
--- /dev/null
+++ b/game/client/tf2/c_tf_class_defender.h
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_DEFENDER_H
+#define C_TF_CLASS_DEFENDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+class C_PlayerClassDefender : public C_PlayerClass
+{
+	
+	DECLARE_CLASS( C_PlayerClassDefender, C_PlayerClass );
+
+public:
+
+	DECLARE_PREDICTABLE();
+
+	C_PlayerClassDefender( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassDefender();
+
+	PlayerClassDefenderData_t *GetClassData( void ) { return &m_ClassData; } 
+
+protected:
+
+	PlayerClassDefenderData_t	m_ClassData;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassDefenderData )
+
+#endif // C_TF_CLASS_DEFENDER_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_escort.cpp b/game/client/tf2/c_tf_class_escort.cpp
new file mode 100644
index 0000000..84e7907
--- /dev/null
+++ b/game/client/tf2/c_tf_class_escort.cpp
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_escort.h"
+
+//=============================================================================
+//
+// Escort Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassEscort, DT_PlayerClassEscortData )
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassEscort )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassEscortData_t ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassEscort::C_PlayerClassEscort( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassEscort::~C_PlayerClassEscort()
+{
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_escort.h b/game/client/tf2/c_tf_class_escort.h
new file mode 100644
index 0000000..c906764
--- /dev/null
+++ b/game/client/tf2/c_tf_class_escort.h
@@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_ESCORT_H
+#define C_TF_CLASS_ESCORT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+class C_PlayerClassEscort : public C_PlayerClass
+{
+	
+	DECLARE_CLASS( C_PlayerClassEscort, C_PlayerClass );
+
+public:
+
+	C_PlayerClassEscort( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassEscort();
+
+	DECLARE_PREDICTABLE();
+	PlayerClassEscortData_t *GetClassData( void ) { return &m_ClassData; } 
+
+protected:
+
+	PlayerClassEscortData_t	m_ClassData;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassEscortData )
+
+#endif // C_TF_CLASS_ESCORT_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_infiltrator.cpp b/game/client/tf2/c_tf_class_infiltrator.cpp
new file mode 100644
index 0000000..129cdcc
--- /dev/null
+++ b/game/client/tf2/c_tf_class_infiltrator.cpp
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_infiltrator.h"
+
+//=============================================================================
+//
+// Infiltrator Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassInfiltrator, DT_PlayerClassInfiltratorData )
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassInfiltrator )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassInfiltratorData_t ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassInfiltrator::C_PlayerClassInfiltrator( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassInfiltrator::~C_PlayerClassInfiltrator()
+{
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_infiltrator.h b/game/client/tf2/c_tf_class_infiltrator.h
new file mode 100644
index 0000000..d91f0cc
--- /dev/null
+++ b/game/client/tf2/c_tf_class_infiltrator.h
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_INFILTRATOR_H
+#define C_TF_CLASS_INFILTRATOR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+class C_PlayerClassInfiltrator : public C_PlayerClass
+{
+	
+	DECLARE_CLASS( C_PlayerClassInfiltrator, C_PlayerClass );
+
+public:
+
+	C_PlayerClassInfiltrator( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassInfiltrator();
+	
+	DECLARE_PREDICTABLE();
+
+	PlayerClassInfiltratorData_t *GetClassData( void ) { return &m_ClassData; } 
+
+protected:
+
+	PlayerClassInfiltratorData_t	m_ClassData;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassInfiltratorData )
+
+#endif // C_TF_CLASS_INFILTRATOR_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_medic.cpp b/game/client/tf2/c_tf_class_medic.cpp
new file mode 100644
index 0000000..3015929
--- /dev/null
+++ b/game/client/tf2/c_tf_class_medic.cpp
@@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_medic.h"
+
+//=============================================================================
+//
+// Medic Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassMedic, DT_PlayerClassMedicData )
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassMedic )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassMedicData_t ),
+
+END_PREDICTION_DATA()
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassMedic::C_PlayerClassMedic( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassMedic::~C_PlayerClassMedic()
+{
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_medic.h b/game/client/tf2/c_tf_class_medic.h
new file mode 100644
index 0000000..dffaa02
--- /dev/null
+++ b/game/client/tf2/c_tf_class_medic.h
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_MEDIC_H
+#define C_TF_CLASS_MEDIC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+class C_PlayerClassMedic : public C_PlayerClass
+{
+	
+	DECLARE_CLASS( C_PlayerClassMedic, C_PlayerClass );
+
+public:
+
+	C_PlayerClassMedic( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassMedic();
+
+	DECLARE_PREDICTABLE();
+
+	PlayerClassMedicData_t *GetClassData( void ) { return &m_ClassData; } 
+
+protected:
+
+	PlayerClassMedicData_t	m_ClassData;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassMedicData )
+
+#endif // C_TF_CLASS_MEDIC_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_pyro.cpp b/game/client/tf2/c_tf_class_pyro.cpp
new file mode 100644
index 0000000..c8600db
--- /dev/null
+++ b/game/client/tf2/c_tf_class_pyro.cpp
@@ -0,0 +1,44 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_pyro.h"
+
+//=============================================================================
+//
+// Medic Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassPyro, DT_PlayerClassPyroData )
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassPyro )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassPyroData_t ),
+
+END_PREDICTION_DATA()
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassPyro::C_PlayerClassPyro( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassPyro::~C_PlayerClassPyro()
+{
+}
+
+
+PlayerClassPyroData_t* C_PlayerClassPyro::GetClassData()
+{
+	return &m_ClassData; 
+}
+
diff --git a/game/client/tf2/c_tf_class_pyro.h b/game/client/tf2/c_tf_class_pyro.h
new file mode 100644
index 0000000..64365f4
--- /dev/null
+++ b/game/client/tf2/c_tf_class_pyro.h
@@ -0,0 +1,41 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_PYRO_H
+#define C_TF_CLASS_PYRO_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+
+class C_PlayerClassPyro : public C_PlayerClass
+{
+public:
+
+	DECLARE_CLASS( C_PlayerClassPyro, C_PlayerClass );
+	DECLARE_PREDICTABLE();
+
+
+	C_PlayerClassPyro( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassPyro();
+
+	PlayerClassPyroData_t *GetClassData();
+
+
+protected:
+
+	PlayerClassPyroData_t	m_ClassData;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassPyroData )
+
+
+#endif // C_TF_CLASS_PYRO_H
diff --git a/game/client/tf2/c_tf_class_recon.cpp b/game/client/tf2/c_tf_class_recon.cpp
new file mode 100644
index 0000000..0a615ce
--- /dev/null
+++ b/game/client/tf2/c_tf_class_recon.cpp
@@ -0,0 +1,54 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_recon.h"
+
+//=============================================================================
+//
+// Recon Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassRecon, DT_PlayerClassReconData )
+	RecvPropInt		( RECVINFO( m_ClassData.m_nJumpCount ) ),
+	RecvPropFloat	( RECVINFO( m_ClassData.m_flSuppressionJumpTime ) ),
+	RecvPropFloat	( RECVINFO( m_ClassData.m_flSuppressionImpactTime ) ),
+	RecvPropFloat	( RECVINFO( m_ClassData.m_flStickTime ) ),
+	RecvPropFloat	( RECVINFO( m_ClassData.m_flActiveJumpTime ) ),
+	RecvPropFloat	( RECVINFO( m_ClassData.m_flImpactDist ) ),
+	RecvPropVector	( RECVINFO( m_ClassData.m_vecImpactNormal ) ),
+	RecvPropVector	( RECVINFO( m_ClassData.m_vecUnstickVelocity ) ),
+	RecvPropInt		( RECVINFO( m_ClassData.m_bTrailParticles ) ),
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassRecon )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassReconData_t ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassRecon::C_PlayerClassRecon( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+	m_ClassData.m_nJumpCount = 0;
+	m_ClassData.m_flSuppressionJumpTime = -99999;
+	m_ClassData.m_flSuppressionImpactTime = -99999;
+	m_ClassData.m_flActiveJumpTime = -99999;
+	m_ClassData.m_flStickTime = -99999;
+	m_ClassData.m_flImpactDist = -99999;
+	m_ClassData.m_vecImpactNormal.Init();
+	m_ClassData.m_vecUnstickVelocity.Init();
+	m_ClassData.m_bTrailParticles = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassRecon::~C_PlayerClassRecon()
+{
+}
diff --git a/game/client/tf2/c_tf_class_recon.h b/game/client/tf2/c_tf_class_recon.h
new file mode 100644
index 0000000..46d8438
--- /dev/null
+++ b/game/client/tf2/c_tf_class_recon.h
@@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_RECON_H
+#define C_TF_CLASS_RECON_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "TFClassData_Shared.h"
+#include "dt_recv.h"
+
+class C_PlayerClassRecon : public C_PlayerClass
+{
+	
+	DECLARE_CLASS( C_PlayerClassRecon, C_PlayerClass );
+
+public:
+
+	C_PlayerClassRecon( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassRecon();
+
+	DECLARE_PREDICTABLE();
+
+	PlayerClassReconData_t *GetClassData( void ) { return &m_ClassData; } 
+
+	PlayerClassReconData_t	m_ClassData;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassReconData )
+
+#endif // C_TF_CLASS_RECON_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_sapper.cpp b/game/client/tf2/c_tf_class_sapper.cpp
new file mode 100644
index 0000000..cc84859
--- /dev/null
+++ b/game/client/tf2/c_tf_class_sapper.cpp
@@ -0,0 +1,53 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_sapper.h"
+
+//=============================================================================
+//
+// Sapper Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassSapper, DT_PlayerClassSapperData )
+	RecvPropFloat( RECVINFO(m_flDrainedEnergy) ),
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassSapper )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassSapperData_t ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassSapper::C_PlayerClassSapper( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassSapper::~C_PlayerClassSapper()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float C_PlayerClassSapper::GetDrainedEnergy( void )
+{
+	return m_flDrainedEnergy;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_PlayerClassSapper::DeductDrainedEnergy( float flEnergy )
+{
+	m_flDrainedEnergy = MAX( 0, m_flDrainedEnergy - flEnergy );
+}
diff --git a/game/client/tf2/c_tf_class_sapper.h b/game/client/tf2/c_tf_class_sapper.h
new file mode 100644
index 0000000..a3f7287
--- /dev/null
+++ b/game/client/tf2/c_tf_class_sapper.h
@@ -0,0 +1,45 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_TECHNICIAN_H
+#define C_TF_CLASS_TECHNICIAN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+class C_PlayerClassSapper : public C_PlayerClass
+{
+	
+	DECLARE_CLASS( C_PlayerClassSapper, C_PlayerClass );
+
+public:
+
+	C_PlayerClassSapper( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassSapper();
+
+	DECLARE_PREDICTABLE();
+
+	PlayerClassSapperData_t* GetClassData( void ) { return &m_ClassData; } 
+
+	// Energy handling
+	float	GetDrainedEnergy( void );
+	void	DeductDrainedEnergy( float flEnergy );
+
+protected:
+
+	PlayerClassSapperData_t	m_ClassData;
+
+public:
+	float	m_flDrainedEnergy;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassSapperData )
+
+#endif // C_TF_CLASS_TECHNICIAN_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_sniper.cpp b/game/client/tf2/c_tf_class_sniper.cpp
new file mode 100644
index 0000000..e2a0449
--- /dev/null
+++ b/game/client/tf2/c_tf_class_sniper.cpp
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_sniper.h"
+
+//=============================================================================
+//
+// Sniper Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassSniper, DT_PlayerClassSniperData )
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassSniper )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassSniperData_t ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassSniper::C_PlayerClassSniper( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassSniper::~C_PlayerClassSniper()
+{
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_sniper.h b/game/client/tf2/c_tf_class_sniper.h
new file mode 100644
index 0000000..078624d
--- /dev/null
+++ b/game/client/tf2/c_tf_class_sniper.h
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_SNIPER_H
+#define C_TF_CLASS_SNIPER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+class C_PlayerClassSniper : public C_PlayerClass
+{
+	
+	DECLARE_CLASS( C_PlayerClassSniper, C_PlayerClass );
+
+public:
+
+	C_PlayerClassSniper( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassSniper();
+
+	DECLARE_PREDICTABLE();
+
+	PlayerClassSniperData_t *GetClassData( void ) { return &m_ClassData; } 
+
+protected:
+
+	PlayerClassSniperData_t	m_ClassData;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassSniperData )
+
+#endif // C_TF_CLASS_SNIPER_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_support.cpp b/game/client/tf2/c_tf_class_support.cpp
new file mode 100644
index 0000000..ea85891
--- /dev/null
+++ b/game/client/tf2/c_tf_class_support.cpp
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_support.h"
+
+//=============================================================================
+//
+// Support Data Table
+//
+BEGIN_RECV_TABLE_NOBASE( C_PlayerClassSupport, DT_PlayerClassSupportData )
+END_RECV_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( C_PlayerClassSupport )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_ClassData, PlayerClassSupportData_t ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassSupport::C_PlayerClassSupport( C_BaseTFPlayer *pPlayer ) :
+	C_PlayerClass( pPlayer )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClassSupport::~C_PlayerClassSupport()
+{
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_class_support.h b/game/client/tf2/c_tf_class_support.h
new file mode 100644
index 0000000..27817cb
--- /dev/null
+++ b/game/client/tf2/c_tf_class_support.h
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_CLASS_SUPPORT_H
+#define C_TF_CLASS_SUPPORT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_playerclass.h"
+#include "dt_recv.h"
+
+class C_PlayerClassSupport : public C_PlayerClass
+{
+	
+	DECLARE_CLASS( C_PlayerClassSupport, C_PlayerClass );
+
+public:
+
+	C_PlayerClassSupport( C_BaseTFPlayer *pPlayer );
+	virtual ~C_PlayerClassSupport();
+
+	DECLARE_PREDICTABLE();
+
+	PlayerClassSupportData_t *GetClassData( void ) { return &m_ClassData; } 
+
+protected:
+
+	PlayerClassSupportData_t	m_ClassData;
+};
+
+EXTERN_RECV_TABLE( DT_PlayerClassSupportData )
+
+#endif // C_TF_CLASS_SUPPORT_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_flare.cpp b/game/client/tf2/c_tf_flare.cpp
new file mode 100644
index 0000000..7b8b806
--- /dev/null
+++ b/game/client/tf2/c_tf_flare.cpp
@@ -0,0 +1,342 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:		Flare effects
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "dlight.h"
+#include "cmodel.h"
+#include "view.h"
+#include "clientsideeffects.h"
+#include "clienteffectprecachesystem.h"
+#include "particles_simple.h"
+#include "particlemgr.h"
+#include "IEFx.h"
+#include "fx.h"
+
+//Precahce the effects
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectFlares )
+CLIENTEFFECT_MATERIAL( "effects/redflare" )
+CLIENTEFFECT_MATERIAL( "effects/yellowflare" )
+CLIENTEFFECT_MATERIAL( "effects/yellowflare_noz" )
+CLIENTEFFECT_REGISTER_END()
+
+class C_SignalFlare : public C_BaseAnimating, CSimpleEmitter
+{
+	
+	DECLARE_CLASS( C_SignalFlare, C_BaseAnimating );
+
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_SignalFlare( void );
+	~C_SignalFlare( void );
+
+	void	OnDataChanged( DataUpdateType_t updateType );
+	void	Update( float timeDelta );
+	void	NotifyDestroyParticle( Particle* pParticle );
+	void	RestoreResources( void );
+
+	float	m_flDuration;
+	float	m_flScale;
+	bool	m_bLight;
+	bool	m_bSmoke;
+
+private:
+	C_SignalFlare( const C_SignalFlare & );
+
+	SimpleParticle	*m_pParticle[2];
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_SignalFlare, DT_SignalFlare, CSignalFlare )
+	RecvPropFloat( RECVINFO( m_flDuration ) ),
+	RecvPropFloat( RECVINFO( m_flScale ) ),
+	RecvPropInt( RECVINFO( m_bLight ) ),
+	RecvPropInt( RECVINFO( m_bSmoke ) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Constructor
+//-----------------------------------------------------------------------------
+C_SignalFlare::C_SignalFlare( void ) : CSimpleEmitter( "C_SignalFlare" )
+{
+	m_pParticle[0] = NULL;
+	m_pParticle[1] = NULL;
+	m_flDuration = 0.0f;
+
+	m_bLight = true;
+	m_bSmoke = true;
+
+	SetDynamicallyAllocated( false );
+}
+
+
+//-----------------------------------------------------------------------------
+// Destructor 
+//-----------------------------------------------------------------------------
+C_SignalFlare::~C_SignalFlare( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bool - 
+//-----------------------------------------------------------------------------
+void C_SignalFlare::OnDataChanged( DataUpdateType_t updateType )
+{
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		SetSortOrigin( GetAbsOrigin() );
+	}
+
+	BaseClass::OnDataChanged( updateType );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_SignalFlare::RestoreResources( void )
+{
+	if ( m_pParticle[0] == NULL )
+	{
+		m_pParticle[0] = (SimpleParticle *) AddParticle( sizeof( SimpleParticle ), GetPMaterial( "effects/redflare" ), GetAbsOrigin() );
+		
+		if ( m_pParticle[0] != NULL )
+		{
+			m_pParticle[0]->m_uchColor[0] = m_pParticle[0]->m_uchColor[1] = m_pParticle[0]->m_uchColor[2] = 0;
+			m_pParticle[0]->m_flRoll = random->RandomInt( 0, 360 );
+			m_pParticle[0]->m_flRollDelta = random->RandomFloat( 1.0f, 4.0f );
+			m_pParticle[0]->m_flLifetime = 0.0f;
+			m_pParticle[0]->m_flDieTime	= 10.0f;
+		}
+		else
+		{
+			assert(0);
+		}
+	}
+
+	if ( m_pParticle[1] == NULL )
+	{
+		m_pParticle[1] = (SimpleParticle *) AddParticle( sizeof( SimpleParticle ), GetPMaterial( "effects/yellowflare_noz" ), GetAbsOrigin() );
+		
+		if ( m_pParticle[1] != NULL )
+		{
+			m_pParticle[1]->m_uchColor[0] = m_pParticle[1]->m_uchColor[1] = m_pParticle[1]->m_uchColor[2] = 0;
+			m_pParticle[1]->m_flRoll = random->RandomInt( 0, 360 );
+			m_pParticle[1]->m_flRollDelta = random->RandomFloat( 1.0f, 4.0f );
+			m_pParticle[1]->m_flLifetime = 0.0f;
+			m_pParticle[1]->m_flDieTime = 10.0f;
+		}
+		else
+		{
+			assert(0);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pParticle - 
+//-----------------------------------------------------------------------------
+void C_SignalFlare::NotifyDestroyParticle( Particle *pParticle )
+{
+	if ( pParticle == m_pParticle[0] )
+	{
+		m_pParticle[0] = NULL;
+	}
+
+	if ( pParticle == m_pParticle[1] )
+	{
+		m_pParticle[1] = NULL;
+	}
+
+	CSimpleEmitter::NotifyDestroyParticle( pParticle );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : timeDelta - 
+//-----------------------------------------------------------------------------
+void C_SignalFlare::Update( float timeDelta )
+{
+	CSimpleEmitter::Update( timeDelta );
+
+	//Make sure our stored resources are up to date
+	RestoreResources();
+
+	//Don't do this if the console is down
+	if ( timeDelta <= 0.0f )
+		return;
+
+	float	fColor;
+	float	baseScale = m_flScale;
+
+	//Account for fading out
+	if ( ( m_flDuration != -1.0f ) && ( ( m_flDuration - gpGlobals->curtime ) <= 10.0f ) )
+	{
+		baseScale *= ( ( m_flDuration - gpGlobals->curtime ) / 10.0f );
+	}
+
+	//Clamp the scale if vanished
+	if ( baseScale < 0.01f )
+	{
+		baseScale = 0.0f;
+
+		if ( m_pParticle[0] != NULL )
+		{	
+			m_pParticle[0]->m_flDieTime		= gpGlobals->curtime;
+			m_pParticle[0]->m_uchStartSize	= m_pParticle[0]->m_uchEndSize = 0;
+			m_pParticle[0]->m_uchColor[0]	= 0;
+			m_pParticle[0]->m_uchColor[1]	= 0;
+			m_pParticle[0]->m_uchColor[2]	= 0;
+		}
+
+		if ( m_pParticle[1] != NULL )
+		{	
+			m_pParticle[1]->m_flDieTime		= gpGlobals->curtime;
+			m_pParticle[1]->m_uchStartSize	= m_pParticle[1]->m_uchEndSize = 0;
+			m_pParticle[1]->m_uchColor[0]	= 0;
+			m_pParticle[1]->m_uchColor[1]	= 0;
+			m_pParticle[1]->m_uchColor[2]	= 0;
+		}
+
+		return;
+	}
+
+	//
+	// Dynamic light
+	//
+
+	if ( m_bLight )
+	{
+		dlight_t *dl= effects->CL_AllocDlight( index );
+
+		dl->origin	= GetAbsOrigin();
+		dl->color.r = 255;
+		dl->color.g = dl->color.b = random->RandomInt( 32, 64 );
+		dl->radius	= baseScale * random->RandomFloat( 110.0f, 128.0f );
+		dl->die		= gpGlobals->curtime;
+	}
+
+	//
+	// Smoke
+	//
+
+	if ( m_bSmoke )
+	{
+		Vector	smokeOrg = GetAbsOrigin();
+
+		Vector	flareScreenDir = ( smokeOrg - CurrentViewOrigin() );
+		VectorNormalize( flareScreenDir );
+
+		smokeOrg = smokeOrg + ( flareScreenDir * 2.0f );
+		smokeOrg[2] += baseScale * 4.0f;
+
+		SimpleParticle *sParticle = (SimpleParticle *) AddParticle( sizeof( SimpleParticle ), g_Mat_DustPuff[1], smokeOrg );
+			
+		if ( sParticle == NULL )
+			return;
+
+		sParticle->m_flLifetime		= 0.0f;
+		sParticle->m_flDieTime		= 1.0f;
+		
+		sParticle->m_vecVelocity	= Vector( random->RandomFloat( -16.0f, 16.0f ), random->RandomFloat( -16.0f, 16.0f ), random->RandomFloat( 8.0f, 16.0f ) + 32.0f );
+
+		fColor = random->RandomInt( 64, 128 );
+
+		sParticle->m_uchColor[0]	= fColor+64;
+		sParticle->m_uchColor[1]	= fColor;
+		sParticle->m_uchColor[2]	= fColor;
+		sParticle->m_uchStartAlpha	= random->RandomInt( 16, 32 );
+		sParticle->m_uchEndAlpha	= 0;
+		sParticle->m_uchStartSize	= random->RandomInt( 2, 4 );
+		sParticle->m_uchEndSize		= sParticle->m_uchStartSize * 6.0f;
+		sParticle->m_flRoll			= random->RandomInt( 0, 360 );
+		sParticle->m_flRollDelta	= random->RandomFloat( -2.0f, 2.0f );
+	}
+
+	//Check for LOS
+	if ( EffectOccluded( GetAbsOrigin() ) )
+	{
+		if ( m_pParticle[0] != NULL )
+		{
+			m_pParticle[0]->m_uchColor[0] *= 0.5f;
+			m_pParticle[0]->m_uchColor[1] *= 0.5f;
+			m_pParticle[0]->m_uchColor[2] *= 0.5f;
+		}
+
+		if ( m_pParticle[1] != NULL )
+		{
+			m_pParticle[1]->m_uchColor[0] *= 0.25f;
+			m_pParticle[1]->m_uchColor[1] *= 0.25f;
+			m_pParticle[1]->m_uchColor[2] *= 0.25f;
+		}
+
+		return;
+	}
+
+	//
+	// Outer glow
+	//
+
+	Vector	offset;
+	
+	//Cause the base of the effect to shake
+	offset.Random( -0.5f * baseScale, 0.5f * baseScale );
+	offset += GetAbsOrigin();
+
+	if ( m_pParticle[0] != NULL )
+	{
+		m_pParticle[0]->m_Pos			= offset;
+		m_pParticle[0]->m_flLifetime	= 0.0f;
+		m_pParticle[0]->m_flDieTime		= 2.0f;
+		
+		m_pParticle[0]->m_vecVelocity.Init();
+
+		fColor = random->RandomInt( 100.0f, 128.0f );
+
+		m_pParticle[0]->m_uchColor[0]	= fColor;
+		m_pParticle[0]->m_uchColor[1]	= fColor;
+		m_pParticle[0]->m_uchColor[2]	= fColor;
+		m_pParticle[0]->m_uchStartAlpha	= fColor;
+		m_pParticle[0]->m_uchEndAlpha	= fColor;
+		m_pParticle[0]->m_uchStartSize	= baseScale * (float) random->RandomInt( 32, 48 );
+		m_pParticle[0]->m_uchEndSize	= m_pParticle[0]->m_uchStartSize;
+		m_pParticle[0]->m_flRollDelta	= 0.0f;
+		
+		if ( random->RandomInt( 0, 4 ) == 3 )
+		{
+			m_pParticle[0]->m_flRoll	+= random->RandomInt( 2, 8 );
+		}
+	}
+
+	//
+	// Inner core
+	//
+
+	//Cause the base of the effect to shake
+	offset.Random( -1.0f * baseScale, 1.0f * baseScale );
+	offset += GetAbsOrigin();
+
+	if ( m_pParticle[1] != NULL )
+	{
+		m_pParticle[1]->m_Pos			= offset;
+		m_pParticle[1]->m_flLifetime	= 0.0f;
+		m_pParticle[1]->m_flDieTime		= 2.0f;
+		
+		m_pParticle[1]->m_vecVelocity.Init();
+
+		fColor = 255;
+
+		m_pParticle[1]->m_uchColor[0]	= fColor;
+		m_pParticle[1]->m_uchColor[1]	= fColor;
+		m_pParticle[1]->m_uchColor[2]	= fColor;
+		m_pParticle[1]->m_uchStartAlpha	= fColor;
+		m_pParticle[1]->m_uchEndAlpha	= fColor;
+		m_pParticle[1]->m_uchStartSize	= baseScale * (float) random->RandomInt( 2, 4 );
+		m_pParticle[1]->m_uchEndSize	= m_pParticle[0]->m_uchStartSize;
+		m_pParticle[1]->m_flRoll		= random->RandomInt( 0, 360 );
+	}
+}
diff --git a/game/client/tf2/c_tf_hintmanager.cpp b/game/client/tf2/c_tf_hintmanager.cpp
new file mode 100644
index 0000000..6aeec17
--- /dev/null
+++ b/game/client/tf2/c_tf_hintmanager.cpp
@@ -0,0 +1,427 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_hintmanager.h"
+#include "c_tf_basehint.h"
+#include <KeyValues.h>
+#include "filesystem.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+// Global off switch for hint system
+static ConVar tf2_hintsystem( "tf2_hintsystem", "0", 0, "Enable interface hints in TF2." );
+static C_TFHintManager *g_pHintManager = NULL;
+
+#define HINT_DISPLAY_STATS_FILE "scripts/hintdisplaystats.txt"
+
+static float g_flLastEscapeKeyTime = -1.0f;
+//-----------------------------------------------------------------------------
+// Purpose: Helper to create panel in center and then shift toward right edge of screen
+// Input  : *panel - 
+// Output : static void
+//-----------------------------------------------------------------------------
+static void PositionPanel( C_TFBaseHint *panel )
+{
+	int w, h;
+	panel->GetSize( w, h );
+
+	int x = ( ScreenWidth() - w ) / 2;
+	int y = ( ScreenHeight() - h ) / 2;
+
+	panel->SetPos( x, y );
+
+	panel->SetDesiredPosition( ScreenWidth() - w - 10, y - 75 );
+}
+
+IMPLEMENT_CLIENTCLASS_DT_NOBASE(C_TFHintManager, DT_TFHintManager, CTFHintManager)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TFHintManager::C_TFHintManager( void )
+{
+	g_pHintManager = this;
+
+	m_pkvHintSystem = new KeyValues( "HintSystem" );
+	if ( m_pkvHintSystem )
+	{
+		bool valid = m_pkvHintSystem->LoadFromFile( filesystem, "scripts//hintsystem.txt" );
+		if ( !valid )
+		{
+			m_pkvHintSystem->deleteThis();
+			m_pkvHintSystem = NULL;
+		}
+	}
+
+	m_pkvHintDisplayStats = new KeyValues( "HintDisplayStats" );
+	if ( m_pkvHintDisplayStats )
+	{
+		m_pkvHintDisplayStats->LoadFromFile( filesystem, HINT_DISPLAY_STATS_FILE );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : KeyValues
+//-----------------------------------------------------------------------------
+KeyValues *C_TFHintManager::GetHintKeyValues( void )
+{
+	return m_pkvHintSystem;
+}
+
+KeyValues *C_TFHintManager::GetHintDisplayStats( void )
+{
+	return m_pkvHintDisplayStats;
+}
+
+void C_TFHintManager::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Think right away
+	if ( updateType ==  DATA_UPDATE_CREATED )
+		SetNextClientThink( 0.0f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove complete hints, and activate next highest priority hint
+//-----------------------------------------------------------------------------
+void C_TFHintManager::ClientThink( void )
+{
+	SetNextClientThink( gpGlobals->curtime + 1.0 );
+
+	int i;
+	int highestPriority = -1;
+	C_TFBaseHint *best = NULL;
+	bool anyVisible = false;
+
+	// See if any of the hints are completed, otherwise, store off the highest priority one
+	for ( i = m_aHints.Size() - 1; i >= 0; i-- )
+	{
+		C_TFBaseHint *hint = m_aHints[ i ];
+
+		// See if it should just be deleted
+		if ( hint && hint->GetCompleted() )
+		{
+			m_aHints.Remove( i );
+			delete hint;
+			continue;
+		}
+
+		if ( hint->IsVisible() )
+		{
+			anyVisible = true;
+		}
+
+		if ( !best || ( hint->GetPriority() > highestPriority ) )
+		{
+			highestPriority = hint->GetPriority();
+			best = hint;
+		}
+	}
+
+	// Last hint finished, show next best one
+	if ( !anyVisible )
+	{
+		// Now hide all but best one
+		for ( i = 0; i < m_aHints.Size(); i++ )
+		{
+			C_TFBaseHint *hint = m_aHints[ i ];
+			hint->SetVisible( hint == best );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : playerIndex - 
+//			hintID - 
+//			priority - 
+//			entityIndex - 
+//-----------------------------------------------------------------------------
+C_TFBaseHint *C_TFHintManager::AddHint( int hintID, const char *subsection, int entityIndex, int maxduplicates )
+{
+	if ( !tf2_hintsystem.GetBool() )
+		return NULL;
+
+	// Don't add the same hint more than once unless maxduplicates >= 1 has been specifically requested
+	int count = CountInstancesOfHintID( hintID );
+	if ( count > maxduplicates )
+	{
+		return NULL;
+	}
+
+	C_TFBaseHint *hint = C_TFBaseHint::CreateHint( hintID, subsection, entityIndex );
+	if ( hint )
+	{
+		// Force it to compute it's exact size
+		hint->PerformLayout();
+
+		PositionPanel( hint );
+
+		m_aHints.AddToTail( hint );
+	}
+
+	return hint;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFHintManager::ClearHints( void )
+{
+	for ( int i = 0; i < m_aHints.Size(); i++ )
+	{
+		C_TFBaseHint *hint = m_aHints[ i ];
+		delete hint;
+	}
+
+	m_aHints.RemoveAll();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : playerIndex - 
+//			hintID - 
+//-----------------------------------------------------------------------------
+void C_TFHintManager::CompleteHint( int hintID, bool visibleOnly )
+{
+	for ( int i = m_aHints.Size() - 1; i >= 0; i-- )
+	{
+		C_TFBaseHint *hint = m_aHints[ i ];
+		if ( !hint )
+			continue;
+
+		if ( hint->GetID() != hintID )
+			continue;
+
+		if ( visibleOnly && !hint->IsVisible() )
+			continue;
+
+		delete hint;
+		m_aHints.Remove( i );
+		return;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : playerIndex - 
+//			hintID - 
+// Output :	Number of instances in list
+//-----------------------------------------------------------------------------
+int C_TFHintManager::CountInstancesOfHintID( int hintID )
+{
+	int c = 0;
+	for ( int i = m_aHints.Size() - 1; i >= 0; i-- )
+	{
+		C_TFBaseHint *hint = m_aHints[ i ];
+		if ( hint && hint->GetID() == hintID )
+		{
+			c++;
+		}
+	}
+
+	return c;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : playerIndex - 
+// Output : int
+//-----------------------------------------------------------------------------
+int C_TFHintManager::GetCurrentHintID( void )
+{
+	for ( int i = m_aHints.Size() - 1; i >= 0; i-- )
+	{
+		C_TFBaseHint *hint = m_aHints[ i ];
+		if ( hint && hint->IsVisible() )
+		{
+			return hint->GetID();
+		}
+	}
+
+	return TF_HINT_UNDEFINED;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFHintManager::ResetDisplayStats( void )
+{
+	if ( !m_pkvHintDisplayStats )
+	{
+		Assert( 0 );
+		return;
+	}
+
+	KeyValues *kv = m_pkvHintDisplayStats->GetFirstSubKey();
+	while ( kv )
+	{
+		KeyValues *subKey = kv->GetFirstSubKey();
+		if ( subKey && stricmp( subKey->GetName(), "times_shown") )
+		{
+			while ( subKey )
+			{
+				subKey->SetString( "times_shown", "0" );
+				subKey = subKey->GetNextKey();
+			}
+		}
+		else
+		{
+			kv->SetString( "times_shown", "0" );
+		}
+
+		kv = kv->GetNextKey();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : hintid - 
+//			100 - 
+//			1 - 
+//			-1 - 
+//-----------------------------------------------------------------------------
+C_TFBaseHint *CreateGlobalHint( int hintid, const char *subsection /*=NULL*/, int entity /*= -1*/, int maxduplicates /*=0*/ )
+{
+	if ( !g_pHintManager )
+	{
+		return NULL;
+	}
+
+	return g_pHintManager->AddHint( hintid, subsection, entity, maxduplicates );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : hintid - 
+//			100 - 
+//			1 - 
+//			-1 - 
+//-----------------------------------------------------------------------------
+C_TFBaseHint *CreateGlobalHint_Panel( vgui::Panel *targetPanel, int hintid, const char *subsection /*=NULL*/, int entity /*= -1*/, int maxduplicates /*=0*/ )
+{
+	C_TFBaseHint *hint = CreateGlobalHint( hintid, subsection, entity, maxduplicates );
+	if ( hint )
+	{
+		// Find an appropriate position near the panel
+		hint->SetHintTarget( targetPanel );
+	}
+	return hint;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Trap the escape key when a hint is showing
+// Output : Returns true if the escape key was swallowed by the hint system
+//-----------------------------------------------------------------------------
+
+// Hitting escape twice withing this amount of seconds will clear all hints pending
+#define ENTER_DOUBLETAP_TIME 1.0f
+
+bool HintSystemEscapeKey( void )
+{
+	if ( !g_pHintManager )
+		return false;
+
+	int hintID = g_pHintManager->GetCurrentHintID();
+	if ( hintID != TF_HINT_UNDEFINED )
+	{
+		bool killall = false;
+
+		float curtime = gpGlobals->curtime;
+		float dt = curtime - g_flLastEscapeKeyTime;
+
+		if ( dt < ENTER_DOUBLETAP_TIME )
+		{
+			killall = true;
+		}
+
+		g_flLastEscapeKeyTime = curtime;
+
+		if ( killall )
+		{
+			g_pHintManager->ClearHints();
+		}
+		else
+		{
+			g_pHintManager->CompleteHint( hintID, true );
+		}
+		// Swallow the escape key
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : hindid - 
+//-----------------------------------------------------------------------------
+void DestroyGlobalHint( int hintid )
+{
+	if ( !g_pHintManager )
+		return;
+
+	g_pHintManager->CompleteHint( hintid, false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : KeyValues
+//-----------------------------------------------------------------------------
+KeyValues *GetHintKeyValues( void )
+{
+	if ( !g_pHintManager )
+		return NULL;
+
+	return g_pHintManager->GetHintKeyValues();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : KeyValues
+//-----------------------------------------------------------------------------
+KeyValues *GetHintDisplayStats( void )
+{
+	if ( !g_pHintManager )
+		return NULL;
+
+	return g_pHintManager->GetHintDisplayStats();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ResetDisplayStats( void )
+{
+	if ( g_pHintManager )
+	{
+		g_pHintManager->ResetDisplayStats();
+	}
+}
+
+static ConCommand tf2_hintreset( "tf2_hintreset", ResetDisplayStats, 0, FCVAR_CHEAT );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TFHintManager::~C_TFHintManager( void )
+{
+	ClearHints();
+	g_pHintManager = NULL;
+	m_pkvHintSystem->deleteThis();
+	if ( m_pkvHintDisplayStats )
+	{
+		m_pkvHintDisplayStats->SaveToFile( filesystem, HINT_DISPLAY_STATS_FILE );
+	}
+	m_pkvHintDisplayStats->deleteThis();
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_tf_hintmanager.h b/game/client/tf2/c_tf_hintmanager.h
new file mode 100644
index 0000000..d96d80b
--- /dev/null
+++ b/game/client/tf2/c_tf_hintmanager.h
@@ -0,0 +1,87 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_HINTMANAGER_H
+#define C_TF_HINTMANAGER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "shareddefs.h"
+
+class C_TFBaseHint;
+class KeyValues;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_TFHintManager : public C_BaseEntity
+{
+	DECLARE_CLASS( C_TFHintManager, C_BaseEntity );
+public:
+	DECLARE_CLIENTCLASS();
+
+						C_TFHintManager( void );
+						~C_TFHintManager( void );
+
+	virtual void		OnDataChanged( DataUpdateType_t updateType );
+
+	// Override think method
+	virtual void		ClientThink( void );
+
+	// Add hint to list
+	C_TFBaseHint		*AddHint( int hintID, const char *subsection, int entityIndex, int maxduplicates );
+
+	// Clear hints
+	void				ClearHints( void );
+	// Complete specified hint
+	void				CompleteHint( int hintID, bool visibleOnly );
+	// Determine ID of hint currently being shown to player
+	int					GetCurrentHintID( void );
+
+	KeyValues			*GetHintKeyValues( void );
+	KeyValues			*GetHintDisplayStats( void );
+
+	// Zero out all counters
+	void				ResetDisplayStats( void );
+
+private:
+	// See how many of the type of hint are already being shown
+	int					CountInstancesOfHintID( int hintID );
+
+	// Hint list
+	CUtlVector< C_TFBaseHint * >	m_aHints;
+
+	KeyValues			*m_pkvHintSystem;
+	KeyValues			*m_pkvHintDisplayStats;
+};
+
+
+#include "tf_hints.h"
+
+class C_TFBaseHint;
+namespace vgui
+{
+	class Panel;
+}
+class KeyValues;
+
+// Use this when you want to allow an unlimited number of a certain type of hint
+// Just a huge number of simultaneous duplicates allowed
+#define HINTTYPE_NOLIMIT	5000
+
+C_TFBaseHint *CreateGlobalHint( int hintid, const char *subsection = NULL, int entity = -1, int maxduplicates = 0 );
+C_TFBaseHint *CreateGlobalHint_Panel( vgui::Panel *targetPanel, int hintid, const char *subsection = NULL, int entity = -1, int maxduplicates = 0 );
+void DestroyGlobalHint( int hintid );
+KeyValues *GetHintKeyValues( void );
+KeyValues *GetHintDisplayStats( void );
+
+// Returns true if hint system swallowed escape key
+bool HintSystemEscapeKey( void );
+
+
+#endif // C_TF_HINTMANAGER_H
diff --git a/game/client/tf2/c_tf_hints.cpp b/game/client/tf2/c_tf_hints.cpp
new file mode 100644
index 0000000..b12ff20
--- /dev/null
+++ b/game/client/tf2/c_tf_hints.cpp
@@ -0,0 +1,1468 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_basehint.h"
+#include "tf_hints.h"
+#include "hintitemorderbase.h"
+#include "iclientmode.h"
+#include "clientmode_commander.h"
+#include "hud_technologytreedoc.h"
+#include "paneleffect.h"
+#include "techtree.h"
+#include "hintitemobjectbase.h"
+#include "c_order.h"
+#include "c_basetfplayer.h"
+#include "weapon_selection.h"
+#include <KeyValues.h>
+#include "c_weapon_builder.h"
+#include "VGuiMatSurface/IMatSystemSurface.h"
+#include "c_tf_hints.h"
+#include "c_hint_events.h"
+#include "c_tf_hintmanager.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//	Class Hierarchy
+//	CHintItemBase -- base class for hint items
+//		CHintItemOrderBase -- base class for hints derived from orders ( know how to draw
+//								a white line from the hint to the order panel )
+//			CHintItemObjectBase -- base class for hints that care about another object ( stores the object type name )
+//				CHintGotoObject -- Contains logic that relates to the other object
+//				CHintWaitBuilding
+//			CHintChangeToCommander -- first level hint, doesn't rely on object, but does rely on UI manipulation
+//		CHintChooseAnyTechnology -- doesn't try to draw line to order since it's in tactical view?
+//		
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Change to commander view hint
+//-----------------------------------------------------------------------------
+class CHintChangeToCommander : public CHintItemOrderBase
+{
+	DECLARE_CLASS( CHintChangeToCommander, CHintItemOrderBase );
+	
+public:
+	CHintChangeToCommander( vgui::Panel *parent, const char *panelName );
+	virtual void Think( void );
+};
+
+DECLARE_HINTITEMFACTORY( CHintChangeToCommander )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//			*text - 
+//			itemwidth - 
+//-----------------------------------------------------------------------------
+CHintChangeToCommander::CHintChangeToCommander( vgui::Panel *parent, const char *panelName )
+: BaseClass( parent, panelName )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set completed flag if we've made it to commander mode
+// Output : 	 virtual void
+//-----------------------------------------------------------------------------
+void CHintChangeToCommander::Think( void )
+{
+	BaseClass::Think();
+
+	if ( g_pClientMode == ClientModeCommander() )
+	{
+		m_bCompleted = true;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintGotoObject : public CHintItemObjectBase
+{
+	DECLARE_CLASS( CHintGotoObject, CHintItemObjectBase );
+	
+public:
+	CHintGotoObject( vgui::Panel *parent, const char *panelName );
+	virtual void		Think( void );
+	
+private:
+	enum
+	{
+		MAX_OBJECT_TYPE = 128,
+	};
+	
+	EFFECT_HANDLE		m_ArrowEffect;
+	
+	float				m_flNextDistanceCheck;
+	IClientMode			*m_pPreviousMode;
+};
+
+DECLARE_HINTITEMFACTORY( CHintGotoObject )
+
+#define ZONE_DISTANCE_CHECK_INTERVAL 0.5f
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintGotoObject::CHintGotoObject( vgui::Panel *parent, const char *panelName ) 
+	: BaseClass( parent, panelName )
+{
+	m_ArrowEffect = CreateArrowEffect( this, parent, NULL );
+	
+	m_flNextDistanceCheck = 0.0f;
+	
+	m_pPreviousMode = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintGotoObject::Think( void )
+{
+	BaseClass::Think();
+	
+	ClientModeTFBase *basemode = ( ClientModeTFBase * )g_pClientMode;
+	CMinimapPanel *minimap = basemode->GetMinimap();
+	
+	CPanelEffect *e = g_pTF2RootPanel->FindEffect( m_ArrowEffect );
+	if ( e && minimap )
+	{
+		e->SetPanelOther( minimap );
+	}
+	
+	// Check right away if we switch modes
+	if ( g_pClientMode != m_pPreviousMode )
+	{
+		m_flNextDistanceCheck = 0.0f;
+		m_pPreviousMode = g_pClientMode;
+	}
+	
+	if ( gpGlobals->curtime < m_flNextDistanceCheck )
+	{
+		return;
+	}
+	
+	m_flNextDistanceCheck = gpGlobals->curtime + ZONE_DISTANCE_CHECK_INTERVAL;
+	
+	// The order contains the resource zone target
+	C_TFBaseHint *hint = static_cast< C_TFBaseHint * >( GetParent() );
+	if ( hint )
+	{
+		C_Order *order = dynamic_cast< C_Order * >( ClientEntityList().GetEnt( hint->GetEntity() ) );
+		if ( order )
+		{
+			C_BaseEntity *pTarget = ClientEntityList().GetEnt( order->GetTarget() );
+			if ( IsObjectOfType( pTarget ) )
+			{
+				Vector zonecenter = pTarget->WorldSpaceCenter( );
+				
+				if ( e && minimap )
+				{
+					float mapx, mapy;
+					
+					// Convert target center to map position
+					CMinimapPanel::MinimapPanel()->WorldToMinimap( MINIMAP_CLIP, zonecenter, mapx, mapy );
+					
+					e->SetUsingOffset( true, (int)mapx, (int)mapy );
+				}
+				
+				Vector delta;
+				
+				C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
+				if ( local )
+				{
+					delta = local->GetAbsOrigin() - zonecenter;
+					if ( delta.Length() < 256.0f )
+					{
+						m_bCompleted = true;
+					}
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintDeployWeapon : public CHintItemOrderBase
+{
+	DECLARE_CLASS( CHintDeployWeapon, CHintItemOrderBase );
+	
+public:
+	CHintDeployWeapon( vgui::Panel *parent, const char *panelName );
+	
+	virtual void Think( void );
+
+	virtual void		SetWeaponType( const char *type );
+	virtual char const	*GetWeaponType( void );
+
+	virtual char const	*GetKeyName( void );
+
+	virtual void		SetPrintName( const char *name );
+	virtual char const	*GetPrintName( void );
+
+	virtual void		ParseItem( KeyValues *pKeyValues );
+
+	virtual bool		CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring );
+
+private:
+	enum
+	{
+		MAX_WEAPON_TYPE = 128,
+		MAX_WEAPON_NAME = 128,
+	};
+
+	char		m_szWeaponType[ MAX_WEAPON_TYPE ];
+	char		m_szPrintName[ MAX_WEAPON_NAME ];
+};
+
+DECLARE_HINTITEMFACTORY( CHintDeployWeapon )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintDeployWeapon::CHintDeployWeapon( vgui::Panel *parent, const char *panelName ) 
+: BaseClass( parent, panelName )
+{
+	SetWeaponType( "" );
+	SetPrintName( "" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *instring - 
+//			keylength - 
+//			**ppOutstring - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintDeployWeapon::CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring )
+{
+	if ( !Q_strnicmp( instring, "keyname", strlen( "keyname" ) ) )
+	{
+		*keylength = strlen( "keyname" );
+		*ppOutstring = GetKeyName();
+		return true;
+	}
+	else if ( !Q_strnicmp( instring, "printname", strlen( "printname" ) ) )
+	{
+		*keylength = strlen( "printname" );
+		*ppOutstring = GetPrintName();
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *type - 
+//-----------------------------------------------------------------------------
+void CHintDeployWeapon::SetWeaponType( const char *type )
+{
+	Q_strncpy( m_szWeaponType, type, MAX_WEAPON_TYPE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CHintDeployWeapon::GetWeaponType( void )
+{
+	return m_szWeaponType;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+void CHintDeployWeapon::SetPrintName( const char *name )
+{
+	Q_strncpy( m_szPrintName, name, MAX_WEAPON_NAME );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CHintDeployWeapon::GetPrintName( void )
+{
+	return m_szPrintName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CHintDeployWeapon::GetKeyName( void )
+{
+	static char keyname[ 128 ];
+
+	keyname[ 0 ] = 0;
+
+	CBaseHudWeaponSelection *pHudSelection = GetHudWeaponSelection();
+	if ( pHudSelection )
+	{
+		C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+		if ( player )
+		{
+			for ( int slot = 0; slot < MAX_WEAPON_SLOTS; slot++ )
+			{
+				C_BaseCombatWeapon *weapon = pHudSelection->GetFirstPos( slot );
+				if ( !weapon )
+					continue;
+				
+				if ( !stricmp( weapon->GetName(), GetWeaponType() ) )
+				{
+					Q_snprintf( keyname, sizeof( keyname ), GetKeyNameForBinding( VarArgs( "slot%i", slot + 1 ) ) );
+					break;
+				}
+			}
+		}
+	}
+
+	return keyname;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pKeyValues - 
+//-----------------------------------------------------------------------------
+void CHintDeployWeapon::ParseItem( KeyValues *pKeyValues )
+{
+	BaseClass::ParseItem( pKeyValues );
+
+	const char *type = pKeyValues->GetString( "weapon", "" );
+	if ( type )
+	{
+		SetWeaponType( type );
+	}
+
+	const char *printname = pKeyValues->GetString( "printname", "" );
+	if ( printname )
+	{
+		SetPrintName( printname );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintDeployWeapon::Think( void )
+{
+	BaseClass::Think();
+	
+	C_BaseTFPlayer *player = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+	
+	// Get the weapon selection Hud Element
+	CBaseHudWeaponSelection *pHudSelection = GetHudWeaponSelection();
+	// Make sure it's not still active
+	if ( pHudSelection->IsActive() )
+		return;
+	
+	C_BaseCombatWeapon *weapon = GetActiveWeapon();
+	if ( !weapon )
+		return;
+	
+	if ( !stricmp( weapon->GetClientClass()->m_pNetworkName, "CWeaponBuilder" ) )
+	{
+		m_bCompleted = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintStartPlacing : public CHintItemOrderBase
+{
+	DECLARE_CLASS( CHintStartPlacing, CHintItemOrderBase );
+	
+public:
+	CHintStartPlacing( vgui::Panel *parent, const char *panelName );
+	
+	virtual void Think( void );
+private:
+};
+
+DECLARE_HINTITEMFACTORY( CHintStartPlacing )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintStartPlacing::CHintStartPlacing( vgui::Panel *parent, const char *panelName ) 
+: BaseClass( parent, panelName )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintStartPlacing::Think( void )
+{
+	BaseClass::Think();
+	
+	C_WeaponBuilder *builder = dynamic_cast< C_WeaponBuilder * >( GetActiveWeapon() );
+	if ( builder && builder->IsPlacingObject() )
+	{
+		m_bCompleted = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintStartBuilding : public CHintItemOrderBase
+{
+	DECLARE_CLASS( CHintStartBuilding, CHintItemOrderBase );
+	
+public:
+	CHintStartBuilding( vgui::Panel *parent, const char *panelName );
+	
+	virtual void Think( void );
+private:
+};
+
+DECLARE_HINTITEMFACTORY( CHintStartBuilding )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintStartBuilding::CHintStartBuilding( vgui::Panel *parent, const char *panelName ) 
+	: BaseClass( parent, panelName )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintStartBuilding::Think( void )
+{
+	BaseClass::Think();
+	
+	C_WeaponBuilder *builder = dynamic_cast< C_WeaponBuilder * >( GetActiveWeapon() );
+	if ( builder && builder->IsBuildingObject() )
+	{
+		m_bCompleted = true;
+	}
+}
+
+#define CHECK_FOR_BUILDING_INTERVAL	1.0f
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintWaitBuilding : public CHintItemObjectBase
+{
+	DECLARE_CLASS( CHintWaitBuilding, CHintItemObjectBase );
+	
+public:
+	CHintWaitBuilding( vgui::Panel *parent, const char *panelName );
+	
+	virtual void Think( void );
+private:
+	
+	float			m_flNextCheck;
+};
+
+
+DECLARE_HINTITEMFACTORY( CHintWaitBuilding )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintWaitBuilding::CHintWaitBuilding( vgui::Panel *parent, const char *panelName ) 
+	: BaseClass( parent, panelName )
+{
+	m_flNextCheck = 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintWaitBuilding::Think( void )
+{
+	BaseClass::Think();
+	
+	if ( !GetActive() )
+		return;
+	
+	C_BaseTFPlayer *player = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+	
+	if ( gpGlobals->curtime < m_flNextCheck )
+		return;
+	
+	m_flNextCheck = gpGlobals->curtime + CHECK_FOR_BUILDING_INTERVAL;
+	
+	// Find resource zone
+	ClientEntityHandle_t e = ClientEntityList().FirstHandle();
+	for ( ;  e != ClientEntityList().InvalidHandle(); e = ClientEntityList().NextHandle( e ) )
+	{
+		C_BaseEntity *ent = C_BaseEntity::Instance( e );
+		if ( !ent )
+			continue;
+		
+		if ( IsObjectOfType( ent ) )
+		{
+			C_BaseObject *obj = static_cast< C_BaseObject * >( ent );
+			
+			Assert( obj );
+			
+			if ( obj->GetTeamNumber() == player->GetTeamNumber() &&	obj->IsOwnedByLocalPlayer() )
+			{
+				m_bCompleted = true;
+				break;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintBuilderSelection : public CHintItemOrderBase
+{
+	DECLARE_CLASS( CHintBuilderSelection, CHintItemOrderBase );
+	
+public:
+	CHintBuilderSelection( vgui::Panel *parent, const char *panelName );
+	
+	virtual void Think( void );
+	virtual void		SetSelection( const char *type );
+	virtual char const	*GetSelection( void );
+
+	virtual void		ParseItem( KeyValues *pKeyValues );
+
+	virtual bool		CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring );
+
+private:
+	enum
+	{
+		MAX_SELECTION_NAME = 128,
+	};
+
+	char		m_szSelection[ MAX_SELECTION_NAME ];
+};
+
+DECLARE_HINTITEMFACTORY( CHintBuilderSelection )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintBuilderSelection::CHintBuilderSelection( vgui::Panel *parent, const char *panelName ) 
+	: BaseClass( parent, panelName )
+{
+	SetSelection( "" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *instring - 
+//			keylength - 
+//			**ppOutstring - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintBuilderSelection::CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring )
+{
+	if ( !Q_strnicmp( instring, "selection", strlen( "selection" ) ) )
+	{
+		*keylength = strlen( "selection" );
+		*ppOutstring = GetSelection();
+		return true;
+	}
+
+	return BaseClass::CheckKeyAndValue( instring, keylength, ppOutstring );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *selection - 
+//-----------------------------------------------------------------------------
+void CHintBuilderSelection::SetSelection( const char *selection )
+{
+	Q_strncpy( m_szSelection, selection, MAX_SELECTION_NAME );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CHintBuilderSelection::GetSelection( void )
+{
+	return m_szSelection;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pKeyValues - 
+//-----------------------------------------------------------------------------
+void CHintBuilderSelection::ParseItem( KeyValues *pKeyValues )
+{
+	BaseClass::ParseItem( pKeyValues );
+
+	const char *selection = pKeyValues->GetString( "selection", "" );
+	if ( selection )
+	{
+		SetSelection( selection );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintBuilderSelection::Think( void )
+{
+	BaseClass::Think();
+	
+	C_BaseTFPlayer *player = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+	
+	C_WeaponBuilder *builder = dynamic_cast< C_WeaponBuilder * >( GetActiveWeapon() );
+	if ( !builder )
+		return;
+
+	const char *selection = builder->GetCurrentSelectionObjectName();
+	if ( !selection )
+		return;
+
+	if ( !stricmp( selection, GetSelection() ) )
+	{
+		m_bCompleted = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintBuilderStartAction : public CHintItemOrderBase
+{
+	DECLARE_CLASS( CHintBuilderStartAction, CHintItemOrderBase );
+	
+public:
+	CHintBuilderStartAction( vgui::Panel *parent, const char *panelName );
+	
+	virtual void Think( void );
+	virtual void		SetAction( const char *type );
+	virtual char const	*GetAction( void );
+
+	virtual void		ParseItem( KeyValues *pKeyValues );
+
+	virtual bool		CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring );
+
+private:
+	enum
+	{
+		MAX_ACTION_NAME = 128,
+	};
+
+	char		m_szAction[ MAX_ACTION_NAME ];
+};
+
+DECLARE_HINTITEMFACTORY( CHintBuilderStartAction )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintBuilderStartAction::CHintBuilderStartAction( vgui::Panel *parent, const char *panelName ) 
+	: BaseClass( parent, panelName )
+{
+	SetAction( "" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *instring - 
+//			keylength - 
+//			**ppOutstring - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintBuilderStartAction::CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring )
+{
+	if ( !Q_strnicmp( instring, "action", strlen( "action" ) ) )
+	{
+		*keylength = strlen( "action" );
+		*ppOutstring = GetAction();
+		return true;
+	}
+
+	return BaseClass::CheckKeyAndValue( instring, keylength, ppOutstring );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *action - 
+//-----------------------------------------------------------------------------
+void CHintBuilderStartAction::SetAction( const char *action )
+{
+	Q_strncpy( m_szAction, action, MAX_ACTION_NAME );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CHintBuilderStartAction::GetAction( void )
+{
+	return m_szAction;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pKeyValues - 
+//-----------------------------------------------------------------------------
+void CHintBuilderStartAction::ParseItem( KeyValues *pKeyValues )
+{
+	BaseClass::ParseItem( pKeyValues );
+
+	const char *action = pKeyValues->GetString( "action", "" );
+	if ( action )
+	{
+		SetAction( action );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintBuilderStartAction::Think( void )
+{
+	BaseClass::Think();
+	
+	C_BaseTFPlayer *player = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+	
+	C_WeaponBuilder *builder = dynamic_cast< C_WeaponBuilder * >( GetActiveWeapon() );
+	if ( !builder )
+		return;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: A fake hud element used to force the weapon hud element to draw when it's
+//  not actually active
+//-----------------------------------------------------------------------------
+class CHudWeaponFlashHelper : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudWeaponFlashHelper, vgui::Panel );
+public:
+	CHudWeaponFlashHelper( const char *name );
+
+	virtual void Init( void );
+	virtual bool ShouldDraw( void );
+	virtual void Paint();
+	virtual void	ApplySchemeSettings( vgui::IScheme *scheme );
+
+	// Associate a weapon
+	void SetFlashWeapon( C_BaseCombatWeapon *weapon );
+
+	// Start/stop flashing
+	void StartFlashing( void );
+	void StopFlashing( void );
+
+	// Get position of weapon icon
+	void GetWeaponIconBounds( C_BaseCombatWeapon *weapon, int& x, int& y, int& w, int& h );
+
+	// Is player using the regular weapon selection UI?
+	bool IsWeaponSelectionActive( void );
+
+private:
+
+	// Currently flashing
+	bool					m_bFlashing;
+
+	// The weapon to highlight
+	EHANDLE					m_hWeapon;
+
+	// The actual weapon selection hud element
+	CBaseHudWeaponSelection		*m_pWeaponSelection;
+};
+
+DECLARE_HUDELEMENT( CHudWeaponFlashHelper )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+CHudWeaponFlashHelper::CHudWeaponFlashHelper( const char *name ) 
+	: CHudElement( name ), BaseClass( NULL, "HudWeaponFlashHelper" )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	m_bFlashing = false;
+	m_pWeaponSelection = NULL;
+
+	SetHiddenBits( HIDEHUD_MISCSTATUS | HIDEHUD_PLAYERDEAD );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponFlashHelper::Init( void )
+{
+	CHudElement::Init();
+
+	m_pWeaponSelection = GetHudWeaponSelection();
+	Assert( m_pWeaponSelection );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHudWeaponFlashHelper::ShouldDraw( void )
+{
+	return ( CHudElement::ShouldDraw() && m_bFlashing && m_pWeaponSelection );
+}
+
+void CHudWeaponFlashHelper::ApplySchemeSettings( vgui::IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+
+	SetPaintBackgroundEnabled( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponFlashHelper::Paint()
+{
+	// Stop immediately if user starts to choose weapons
+	if ( m_pWeaponSelection->IsActive() )
+	{
+		StopFlashing();
+		return;
+	}
+
+	if ( g_pClientMode == ClientModeCommander() )
+		return;
+
+	C_BaseCombatWeapon *w = ( C_BaseCombatWeapon * )( (C_BaseEntity *)m_hWeapon );
+	if ( !w )
+		return;
+
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+	
+	// Redo drawing of Weapon Menu
+	m_pWeaponSelection->DrawWList( pPlayer, w, true, EFFECT_R, EFFECT_G, EFFECT_B, EFFECT_A  );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *weapon - 
+//-----------------------------------------------------------------------------
+void CHudWeaponFlashHelper::SetFlashWeapon( C_BaseCombatWeapon *weapon )
+{
+	m_hWeapon = weapon;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponFlashHelper::StartFlashing( void )
+{
+	m_bFlashing = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponFlashHelper::StopFlashing( void )
+{
+	m_bFlashing = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *weapon - 
+//			x - 
+//			y - 
+//			w - 
+//			h - 
+//-----------------------------------------------------------------------------
+void CHudWeaponFlashHelper::GetWeaponIconBounds( C_BaseCombatWeapon *weapon, int& x, int& y,int& w, int& h )
+{
+	x = y = w = h = 0;
+
+	if ( !m_pWeaponSelection || !weapon )
+		return;
+
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+	{
+		return;
+	}
+
+	wrect_t outrect;
+	if ( !m_pWeaponSelection->ComputeRect( pPlayer, weapon, &outrect ) )
+		return;
+
+	x = outrect.left;
+	y = outrect.top;
+	w = outrect.right - outrect.left;
+	h = outrect.bottom - outrect.top;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHudWeaponFlashHelper::IsWeaponSelectionActive( void )
+{
+	if ( m_pWeaponSelection && m_pWeaponSelection->IsActive() )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Change to commander view hint
+//-----------------------------------------------------------------------------
+class CHintHudWeaponFlash : public CHintItemBase
+{
+	DECLARE_CLASS( CHintHudWeaponFlash, CHintItemBase );
+	
+public:
+	CHintHudWeaponFlash( vgui::Panel *parent, const char *panelName );
+	~CHintHudWeaponFlash( void );
+
+	virtual void	SetKeyValue( const char *key, const char *value );
+
+	void			SetWeaponName( const char *name );
+	char const		*GetWeaponName( void );
+
+	virtual bool	CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring );
+
+	virtual void	SetActive( bool bActive );
+
+	virtual void	Think( void );
+
+private:
+	C_BaseCombatWeapon *GetWeaponOfType( const char *type );
+
+	enum
+	{
+		MAX_WEAPON_NAME = 128,
+	};
+
+	bool	m_bWeaponSet;
+
+	EHANDLE m_hWeapon; 
+
+	char	m_szWeaponName[ MAX_WEAPON_NAME ];
+
+	CHudWeaponFlashHelper		*m_pWeaponFlashHelper;
+
+	EFFECT_HANDLE		m_hLineEffect;
+};
+
+DECLARE_HINTITEMFACTORY( CHintHudWeaponFlash )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//			*text - 
+//			itemwidth - 
+//-----------------------------------------------------------------------------
+CHintHudWeaponFlash::CHintHudWeaponFlash( vgui::Panel *parent, const char *panelName )
+: BaseClass( parent, panelName )
+{
+	m_bWeaponSet = false;
+	SetWeaponName( "" );
+	m_pWeaponFlashHelper = NULL;
+	m_hLineEffect = EFFECT_INVALID_HANDLE;
+
+	CreateFlashEffect( this, parent );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHintHudWeaponFlash::~CHintHudWeaponFlash( void )
+{
+	if ( m_pWeaponFlashHelper )
+	{
+		m_pWeaponFlashHelper->StopFlashing();
+		m_pWeaponFlashHelper->SetFlashWeapon( NULL );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *instring - 
+//			keylength - 
+//			**ppOutstring - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintHudWeaponFlash::CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring )
+{
+	if ( !Q_strnicmp( instring, "weapon", strlen( "weapon" ) ) )
+	{
+		*keylength = strlen( "weapon" );
+		*ppOutstring = GetWeaponName();
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+C_BaseCombatWeapon *CHintHudWeaponFlash::GetWeaponOfType( const char *type )
+{
+	CBaseHudWeaponSelection *pHudSelection = GetHudWeaponSelection();
+	if ( !pHudSelection )
+		return NULL;
+
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( player )
+	{
+		for ( int slot = 0; slot < MAX_WEAPON_SLOTS; slot++ )
+		{
+			for ( int iPos = 0; iPos < MAX_WEAPON_POSITIONS; iPos++ )
+			{
+				C_BaseCombatWeapon *weapon = pHudSelection->GetWeaponInSlot( slot, iPos );
+				if ( !weapon )
+					continue;
+			
+				if ( !stricmp( weapon->GetName(), type ) )
+				{
+					return weapon;
+				}
+			}
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *key - 
+//			*value - 
+//-----------------------------------------------------------------------------
+void CHintHudWeaponFlash::SetKeyValue( const char *key, const char *value )
+{
+	BaseClass::SetKeyValue( key, value );
+
+	if ( !stricmp( key, "weapon" ) )
+	{
+		SetWeaponName( value );
+
+		ComputeTitle();
+	}
+	else if ( !stricmp( key, "weapontype" ) )
+	{
+		// Find the weapon itself
+		C_BaseCombatWeapon *w = GetWeaponOfType( value );
+		if ( w )
+		{
+			m_hWeapon = w;
+
+			// Create open up hud effect, etc.
+			m_pWeaponFlashHelper = GET_HUDELEMENT( CHudWeaponFlashHelper );
+			if ( m_pWeaponFlashHelper )
+			{
+				m_pWeaponFlashHelper->SetFlashWeapon( w );
+
+				int x, y, wide, tall;
+
+				m_pWeaponFlashHelper->GetWeaponIconBounds( w, x, y, wide, tall );
+
+				C_TFBaseHint *hint = static_cast< C_TFBaseHint * >( GetParent() );
+
+				m_hLineEffect = CreateAxialLineEffectToRect( this, hint, x, y, wide, tall );
+
+				hint->SetDesiredPosition( x, y + tall + 50 );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintHudWeaponFlash::Think( void )
+{
+	BaseClass::Think();
+
+	if ( !m_pWeaponFlashHelper )
+		return;
+
+	if ( m_pWeaponFlashHelper->IsWeaponSelectionActive() )
+	{
+		m_bCompleted = true;
+	}
+
+	bool incommander = ( g_pClientMode == ClientModeCommander() );
+
+	CPanelEffect *effect = g_pTF2RootPanel->FindEffect( m_hLineEffect );
+	if ( effect )
+	{
+		effect->SetVisible( !incommander );
+
+		C_BaseCombatWeapon *w = static_cast< C_BaseCombatWeapon * >( ( C_BaseEntity * )m_hWeapon );
+
+		// Update target rectangle
+		if ( w )
+		{
+			int x, y, wide, tall;
+
+			m_pWeaponFlashHelper->GetWeaponIconBounds( w, x, y, wide, tall );
+
+			effect->SetTargetRect( x, y, wide, tall );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bActive - 
+//-----------------------------------------------------------------------------
+void CHintHudWeaponFlash::SetActive( bool bActive )
+{
+	BaseClass::SetActive( bActive );
+
+	if ( !m_pWeaponFlashHelper )
+		return;
+
+	if ( bActive )
+	{
+		m_pWeaponFlashHelper->StartFlashing();
+	}
+	else
+	{
+		m_pWeaponFlashHelper->StopFlashing();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+void CHintHudWeaponFlash::SetWeaponName( const char *name )
+{
+	Q_strncpy( m_szWeaponName, name, MAX_WEAPON_NAME );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CHintHudWeaponFlash::GetWeaponName( void )
+{
+	return m_szWeaponName;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+struct FUNCTIONLIST_t
+{
+	const char *name;
+	HINTCOMPLETIONFUNCTION pfn;
+};
+
+static FUNCTIONLIST_t g_CompletionFunctions[]=
+{
+	{ NULL, NULL },
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+// Output : HINTCOMPLETIONFUNCTION
+//-----------------------------------------------------------------------------
+HINTCOMPLETIONFUNCTION LookupCompletionFunction( const char *name )
+{
+	int i = 0;
+	while ( 1 )
+	{
+		FUNCTIONLIST_t *f = &g_CompletionFunctions[ i ];
+		if ( !f->name )
+			break;
+		
+		if ( !stricmp( f->name, name ) )
+		{
+			return f->pfn;
+		}
+		i++;
+	}
+	
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+struct HINTITEM_t
+{
+	const char *name;
+	CHintItemBase	*( *pfn )( vgui::Panel *parent, const char *name );
+};
+
+static HINTITEM_t g_HintItems[]=
+{
+	{ "CHintChangeToCommander", GET_HINTITEMFACTORY_NAME( CHintChangeToCommander ) },
+	{ "CHintGotoObject", GET_HINTITEMFACTORY_NAME( CHintGotoObject ) },
+	{ "CHintDeployWeapon", GET_HINTITEMFACTORY_NAME( CHintDeployWeapon ) },
+	{ "CHintStartPlacing", GET_HINTITEMFACTORY_NAME( CHintStartPlacing ) },
+	{ "CHintStartBuilding", GET_HINTITEMFACTORY_NAME( CHintStartBuilding ) },
+	{ "CHintWaitBuilding", GET_HINTITEMFACTORY_NAME( CHintWaitBuilding ) },
+	{ "CHintBuilderSelection", GET_HINTITEMFACTORY_NAME( CHintBuilderSelection ) },
+	{ "CHintBuilderStartAction", GET_HINTITEMFACTORY_NAME( CHintBuilderStartAction ) },
+	{ "CHintHudWeaponFlash", GET_HINTITEMFACTORY_NAME( CHintHudWeaponFlash ) },
+	{ NULL, NULL },
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*name - 
+// Output : CHintItemBase
+//-----------------------------------------------------------------------------
+CHintItemBase *CreateHintItem( vgui::Panel *parent, const char *name )
+{
+	int i = 0;
+	while ( 1 )
+	{
+		HINTITEM_t *hi = &g_HintItems[ i ];
+		if ( !hi->name )
+			break;
+		
+		if ( !stricmp( hi->name, name ) )
+		{
+			if ( hi->pfn )
+			{
+				return (*hi->pfn)( parent, name );
+			}
+			else
+			{
+				Assert( !"Missing function pointer in CreateHintItem table!" );
+				return NULL;
+			}
+		}
+		i++;
+	}
+	
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+CHintData g_HintDatas[] =
+{
+	// Vote
+	{ "TF_HINT_VOTEFORTECHNOLOGY", TF_HINT_VOTEFORTECHNOLOGY, 0, NULL, -1 },
+
+	// Build
+	{ "TF_HINT_BUILDRESOURCEPUMP", TF_HINT_BUILDRESOURCEPUMP, 0, HintEventFn_BuildObject, OBJ_RESOURCEPUMP },
+	{ "TF_HINT_BUILDSENTRYGUN_PLASMA", TF_HINT_BUILDSENTRYGUN_PLASMA, 0, HintEventFn_BuildObject, OBJ_SENTRYGUN_PLASMA },
+
+	// Object interaction
+	{ "TF_HINT_REPAIROBJECT", TF_HINT_REPAIROBJECT, 0, NULL, -1 },
+
+	// Technology discovery
+	{ "TF_HINT_NEWTECHNOLOGY", TF_HINT_NEWTECHNOLOGY, 0, NULL, -1 },
+	{ "TF_HINT_WEAPONRECEIVED", TF_HINT_WEAPONRECEIVED, 0, NULL, -1 },
+	
+	// Sentinal
+	{ NULL, 0, 0, NULL, -1 },
+};
+
+
+int GetNumHintDatas()
+{
+	return ARRAYSIZE( g_HintDatas );
+}
+
+
+CHintData* GetHintData( int i )
+{
+	return &g_HintDatas[i];
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : id - 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *LookupHintName( int id )
+{
+	int i = 0;
+	while ( 1 )
+	{
+		CHintData *h = &g_HintDatas[ i ];
+		if ( !h->name )
+			break;
+		
+		if ( h->id == id )
+		{
+			return h->name;
+		}
+		
+		i++;
+	}
+	
+	return NULL;
+}
+
+DECLARE_HINTFACTORY( C_TFBaseHint )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+typedef struct 
+{
+	const char *name;
+	C_TFBaseHint	*( *pfn )( int id, int entity );
+}
+HINT_t;
+
+static HINT_t g_Hints[]=
+{
+	{ "C_TFBaseHint", GET_HINTFACTORY_NAME( C_TFBaseHint ) },
+	{ NULL, NULL },
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//			id - 
+//			entity - 
+// Output : C_TFBaseHint
+//-----------------------------------------------------------------------------
+C_TFBaseHint *FactoryCreateHint( const char *name, int id, int entity )
+{
+	int i = 0;
+	while ( 1 )
+	{
+		HINT_t *hi = &g_Hints[ i ];
+		if ( !hi->name )
+			break;
+		
+		if ( !stricmp( hi->name, name ) )
+		{
+			if ( hi->pfn )
+			{
+				return (*hi->pfn)( id, entity );
+			}
+			else
+			{
+				Assert( !"Missing function pointer in FactoryCreateHint table!" );
+				return NULL;
+			}
+		}
+		i++;
+	}
+	
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Generic factory for hints
+// Input  : id - 
+//			entity - 
+// Output : C_TFBaseHint
+//-----------------------------------------------------------------------------
+C_TFBaseHint *C_TFBaseHint::CreateHint( int id, const char *subsection, int entity )
+{
+	C_TFBaseHint *hint = NULL;
+	const char *hintname = LookupHintName( id );
+	if ( !hintname )
+		return NULL;
+	
+	// See if we should see this hint any more
+	KeyValues *pkvStats = GetHintDisplayStats();
+	if ( pkvStats )
+	{
+		KeyValues *pkvStatSection = pkvStats->FindKey( hintname, true );
+		if ( pkvStatSection )
+		{
+			if ( subsection && subsection[0] )
+			{
+				pkvStatSection = pkvStatSection->FindKey( subsection, true );
+			}
+		}
+
+		if ( !pkvStatSection )
+		{
+			Assert( !"C_TFBaseHint::CreateHint:  Problem creating hint subsection" );
+			return NULL;
+		}
+
+		int times_shown = pkvStatSection->GetInt( "times_shown", 0 );
+		pkvStatSection->SetString( "times_shown", VarArgs( "%i", times_shown ) );
+
+		int times_max = pkvStatSection->GetInt( "times_max", 3 );
+		pkvStatSection->SetString( "times_max", VarArgs( "%i", times_max ) );
+
+		if ( times_shown >= times_max )
+			return NULL;
+
+		// Remember that we've seen it again
+		times_shown++;
+		pkvStatSection->SetString( "times_shown", VarArgs( "%i", times_shown ) );
+	}
+
+	// Ask Hint manager API for key values
+	KeyValues *pkvHintSystem = GetHintKeyValues();
+	if ( pkvHintSystem )
+	{
+		// 
+		// Parse the list of hints looking for name
+		KeyValues *pkvHint = pkvHintSystem->FindKey( hintname );
+		if ( pkvHint )
+		{
+			// Use classname string to construct hint
+			const char *defaultclass = "C_TFBaseHint";
+			const char *classname = pkvHint->GetString( "classname" );
+			if ( !classname || !classname[ 0 ] || !stricmp( classname, "default" ) )
+			{
+				classname = defaultclass;
+			}
+			
+			hint = FactoryCreateHint( classname, id, entity );
+			if ( hint )
+			{
+				hint->ParseFromData( pkvHint );
+			}
+		}	
+	}
+	
+	return hint;
+}
diff --git a/game/client/tf2/c_tf_hints.h b/game/client/tf2/c_tf_hints.h
new file mode 100644
index 0000000..57615bf
--- /dev/null
+++ b/game/client/tf2/c_tf_hints.h
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_HINTS_H
+#define C_TF_HINTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+class C_HintEvent_Base;
+class CHintData;
+
+// The HINTNAME_t structures are where data and code are registered for each hint type.
+typedef void (*HintEventFn)( CHintData *pData, C_HintEvent_Base *pHint );
+
+
+class CHintData
+{
+public:
+	char			*name;
+	int				id;
+	int				timesseen;
+	
+	HintEventFn		m_pEventFn;
+	int				m_ObjectType;	// If this is a hint about an object, this is the object type.
+};
+
+
+extern int			GetNumHintDatas();
+extern CHintData*	GetHintData( int i );
+
+
+#endif // C_TF_HINTS_H
diff --git a/game/client/tf2/c_tf_playerclass.cpp b/game/client/tf2/c_tf_playerclass.cpp
new file mode 100644
index 0000000..b907539
--- /dev/null
+++ b/game/client/tf2/c_tf_playerclass.cpp
@@ -0,0 +1,65 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_class_commando.h"
+#include "c_tf_class_defender.h"
+#include "c_tf_class_escort.h"
+#include "c_tf_class_infiltrator.h"
+#include "c_tf_class_medic.h"
+#include "c_tf_class_recon.h"
+#include "c_tf_class_sniper.h"
+#include "c_tf_class_support.h"
+#include "c_tf_class_sapper.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClass::C_PlayerClass( C_BaseTFPlayer *pPlayer )
+{
+	// Save peer.
+	m_pPlayer = pPlayer;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClass::~C_PlayerClass()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_PlayerClass *C_PlayerClass::Create( C_BaseTFPlayer *pPlayer, int iClassType )
+{
+	// Create the class type
+	switch ( iClassType )
+	{
+	case TFCLASS_COMMANDO: { return ( new C_PlayerClassCommando( pPlayer ) ); }
+	case TFCLASS_DEFENDER: { return ( new C_PlayerClassDefender( pPlayer ) ); }
+	case TFCLASS_ESCORT: { return ( new C_PlayerClassEscort( pPlayer ) ); }
+	case TFCLASS_INFILTRATOR:  { return ( new C_PlayerClassInfiltrator( pPlayer ) ); }
+	case TFCLASS_MEDIC: { return ( new C_PlayerClassMedic( pPlayer ) ); }
+	case TFCLASS_RECON: { return ( new C_PlayerClassRecon( pPlayer ) ); }
+	case TFCLASS_SNIPER:  { return ( new C_PlayerClassSniper( pPlayer ) ); }
+	case TFCLASS_SUPPORT:  { return ( new C_PlayerClassSupport( pPlayer ) ); }
+	case TFCLASS_SAPPER:  { return ( new C_PlayerClassSapper( pPlayer ) ); }
+	default: { return NULL; }
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_PlayerClass::Destroy( C_PlayerClass *pPlayerClass )
+{
+	if ( pPlayerClass )
+	{
+		delete pPlayerClass;
+	}
+}
diff --git a/game/client/tf2/c_tf_playerclass.h b/game/client/tf2/c_tf_playerclass.h
new file mode 100644
index 0000000..36e4317
--- /dev/null
+++ b/game/client/tf2/c_tf_playerclass.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TF_PLAYERCLASS_H
+#define C_TF_PLAYERCLASS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class C_BaseTFPlayer;
+class CUserCmd;
+
+class C_PlayerClass
+{
+public:
+
+	DECLARE_CLASS_NOBASE( C_PlayerClass );
+
+	C_PlayerClass( C_BaseTFPlayer *pPlayer );
+	~C_PlayerClass();
+
+	static C_PlayerClass   *Create( C_BaseTFPlayer *pPlayer, int iClassType );
+	static void				Destroy( C_PlayerClass *pPlayerClass );
+
+	virtual void			PreClassThink( void ) {};
+	virtual void			ClassThink( void ) {};
+	virtual void			PostClassThink( void ) {};
+
+	virtual void			ClassPreDataUpdate( void ) {};
+	virtual void			ClassOnDataChanged( void ) {};
+
+	virtual void			CreateMove( float flInputSampleTime, CUserCmd *pCmd ) {};
+
+	// Vehicles
+	virtual bool			CanGetInVehicle( void ) { return true; }
+
+protected:
+
+	C_BaseTFPlayer		*m_pPlayer;		// reference to player (peer)
+};
+
+
+#include "TFClassData_Shared.h"
+
+
+#endif // C_TF_PLAYERCLASS_H
\ No newline at end of file
diff --git a/game/client/tf2/c_tfcarrier.cpp b/game/client/tf2/c_tfcarrier.cpp
new file mode 100644
index 0000000..c516861
--- /dev/null
+++ b/game/client/tf2/c_tfcarrier.cpp
@@ -0,0 +1,30 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CObjectSentrygun
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "c_base.h
+#include "bone_setup.h"
+#include "CommanderOverlay.h"
+#include "c_ai_basenpc.h"
+#include "c_tfcarrier.h"
+
+IMPLEMENT_CLIENTCLASS_DT(C_TFCarrier, DT_TFCarrier, CTFCarrier)
+	RecvPropInt(RECVINFO(m_iHealth)),
+	RecvPropInt(RECVINFO(m_iMaxHealth)),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TFCarrier::C_TFCarrier()
+{
+	CONSTRUCT_MINIMAP_PANEL( "minimap_helicopter", MINIMAP_COLLECTORS );
+}
+
+void C_TFCarrier::SetDormant( bool inside )
+{
+	BaseClass::SetDormant( bDormant );
+	ENTITY_PANEL_ACTIVATE( "helicopter", !bDormant );
+}
diff --git a/game/client/tf2/c_tfcarrier.h b/game/client/tf2/c_tfcarrier.h
new file mode 100644
index 0000000..d49d60a
--- /dev/null
+++ b/game/client/tf2/c_tfcarrier.h
@@ -0,0 +1,43 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TFCARRIER_H
+#define C_TFCARRIER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_rescollector.h"
+#include "hud_minimap.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_TFCarrier : public C_AI_BaseNPC
+{
+	DECLARE_CLASS( C_TFCarrier, C_AI_BaseNPC );
+
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_ENTITY_PANEL();
+	DECLARE_MINIMAP_PANEL( );
+
+	C_TFCarrier();
+
+	virtual void	SetDormant( bool bDormant );
+	virtual int		GetHealth() const { return m_iHealth; }
+	virtual int		GetMaxHealth() const { return m_iMaxHealth; }
+
+public:
+	int			m_iHealth;
+	int			m_iMaxHealth;
+
+private:
+	C_TFCarrier( const C_TFCarrier & );
+};
+
+#endif // C_TFCARRIER_H
diff --git a/game/client/tf2/c_tfplayerlocaldata.h b/game/client/tf2/c_tfplayerlocaldata.h
new file mode 100644
index 0000000..d863ae2
--- /dev/null
+++ b/game/client/tf2/c_tfplayerlocaldata.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Defines the player specific data that is sent only to the player
+//			to whom it belongs.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TFPLAYERLOCALDATA_H
+#define C_TFPLAYERLOCALDATA_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "techtree.h"
+#include "c_baseobject.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Player specific data ( sent only to local player, too )
+//-----------------------------------------------------------------------------
+class CTFPlayerLocalData
+{
+public:
+	DECLARE_PREDICTABLE();
+
+	int			m_nInTacticalView;
+
+	bool		m_bKnockedDown;
+	QAngle		m_vecKnockDownDir;
+
+	bool		m_bThermalVision;
+
+	int			m_iIDEntIndex;
+
+	// Resource chunk carrying counts
+	int			m_iResourceAmmo[ RESOURCE_TYPES ];	// 0 = Normal resources, 1 = Processed resources
+
+	// Resource bank
+	int			m_iBankResources;		// Current amounts of resource in my bank
+
+	// Objects
+	CUtlVector< CHandle<C_BaseObject> > m_aObjects;
+
+	// Object sapper placement handling
+	bool		m_bAttachingSapper;
+	float		m_flSapperAttachmentFrac;
+	bool		m_bForceMapOverview;
+};
+
+#endif // C_TFPLAYERLOCALDATA_H
diff --git a/game/client/tf2/c_tfplayerresource.cpp b/game/client/tf2/c_tfplayerresource.cpp
new file mode 100644
index 0000000..edd4292
--- /dev/null
+++ b/game/client/tf2/c_tfplayerresource.cpp
@@ -0,0 +1,30 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: TF's custom C_PlayerResource
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tfplayerresource.h"
+#include "hud.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_TFPlayerResource, DT_TFPlayerResource, CTFPlayerResource)
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TFPlayerResource::C_TFPlayerResource()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TFPlayerResource::~C_TFPlayerResource()
+{
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_tfplayerresource.h b/game/client/tf2/c_tfplayerresource.h
new file mode 100644
index 0000000..210b106
--- /dev/null
+++ b/game/client/tf2/c_tfplayerresource.h
@@ -0,0 +1,30 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: TF's custom C_PlayerResource
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TFPLAYERRESOURCE_H
+#define C_TFPLAYERRESOURCE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "shareddefs.h"
+#include "c_playerresource.h"
+
+class C_TFPlayerResource : public C_PlayerResource
+{
+	DECLARE_CLASS( C_TFPlayerResource, C_PlayerResource );
+public:
+	DECLARE_CLIENTCLASS();
+
+					C_TFPlayerResource();
+	virtual			~C_TFPlayerResource();
+
+public:
+};
+
+
+#endif // C_TFPLAYERRESOURCE_H
diff --git a/game/client/tf2/c_tfteam.cpp b/game/client/tf2/c_tfteam.cpp
new file mode 100644
index 0000000..b1adecd
--- /dev/null
+++ b/game/client/tf2/c_tfteam.cpp
@@ -0,0 +1,217 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client side C_TFTeam class
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_tfteam.h"
+#include "c_basetfplayer.h"
+#include "engine/IEngineSound.h"
+#include "hud.h"
+#include "recvproxy.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+#define ATTACK_NOTIFICATION_TIME 10.0f
+
+#define MESSAGESTRINGID_RESOURCESHARVESTED	(IMessageChars::MESSAGESTRINGID_BASE+0)
+
+//-----------------------------------------------------------------------------
+// Purpose: RecvProxy that converts the Team's object UtlVector to entindexes
+//-----------------------------------------------------------------------------
+void RecvProxy_ObjectList( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	C_TFTeam *pTeam = (C_TFTeam*)pStruct;
+	CBaseHandle *pHandle = (CBaseHandle*)(&(pTeam->m_aObjects[ pData->m_iElement ])); 
+	RecvProxy_IntToEHandle( pData, pStruct, pHandle );
+}
+
+
+void RecvProxyArrayLength_TeamObjects( void *pStruct, int objectID, int currentArrayLength )
+{
+	C_TFTeam *pTeam = (C_TFTeam*)pStruct;
+	
+	if ( pTeam->m_aObjects.Count() != currentArrayLength )
+	{
+		pTeam->m_aObjects.SetSize( currentArrayLength );
+	}
+}
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_TFTeam, DT_TFTeam, CTFTeam)
+	RecvPropFloat( RECVINFO(m_fResources) ), 
+	RecvPropFloat( RECVINFO(m_fPotentialResources) ),
+	RecvPropInt( RECVINFO(m_bHaveZone) ),
+	
+	RecvPropArray2( 
+		RecvProxyArrayLength_TeamObjects,
+		RecvPropInt( "object_array_element", 0, SIZEOF_IGNORE, 0, RecvProxy_ObjectList ), 
+		MAX_OBJECTS_PER_TEAM, 
+		0, 
+		"object_array"
+		),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TFTeam::C_TFTeam()
+{
+	m_LastAttackNotificationTime = -10000;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_TFTeam::~C_TFTeam()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFTeam::NotifyBaseUnderAttack( const Vector &vecPosition, bool bPlaySound, bool bForce )
+{
+	float currentTime = gpGlobals->curtime;
+	if ( bForce || (currentTime - m_LastAttackNotificationTime > ATTACK_NOTIFICATION_TIME) )
+	{
+		m_LastAttackNotificationTime = currentTime;
+
+		if (GetLocalTeam() == this)
+		{
+			// Play a sound.
+			if (bPlaySound)
+			{
+				CLocalPlayerFilter filter;
+				C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "TFTeam.NotifyBaseUnderAttack" );
+			}
+
+			MinimapCreateTempTrace( "minimap_under_attack", MINIMAP_PERSONAL_ORDERS, vecPosition );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float C_TFTeam::GetTeamResources( void )
+{
+	return m_fResources;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float C_TFTeam::GetPotentialTeamResources( void )
+{
+	return m_fPotentialResources;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this team controls a zone of the specified resource type
+//-----------------------------------------------------------------------------
+bool C_TFTeam::GetHaveZone( void )
+{
+	return m_bHaveZone;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_TFTeam::GetNumObjects( int iObjectType )
+{
+	// Asking for a count of a specific object type?
+	if ( iObjectType > 0 )
+	{
+		int iCount = 0;
+		for ( int i = 0; i < GetNumObjects(); i++ )
+		{
+			CBaseObject *pObject = GetObject(i);
+			if ( pObject && pObject->GetType() == iObjectType )
+			{
+				iCount++;
+			}
+		}
+		return iCount;
+	}
+
+	return m_aObjects.Count();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_BaseObject *C_TFTeam::GetObject( int iIndex )
+{
+	Assert( iIndex >= 0 && iIndex < m_aObjects.Size() );
+	return static_cast<C_BaseObject*>((C_BaseEntity*)m_aObjects[iIndex]);
+}
+
+bool C_TFTeam::IsObjectValid( int iIndex )
+{
+	Assert( iIndex >= 0 && iIndex < m_aObjects.Size() );
+	return ((C_BaseEntity const*)m_aObjects[iIndex] != NULL);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Receive a spawn message from the server
+//-----------------------------------------------------------------------------
+void C_TFTeam::ReceiveMessage( int classID,  bf_read &msg )
+{
+	if ( classID != GetClientClass()->m_ClassID )
+	{
+		// message is for subclass
+		BaseClass::ReceiveMessage( classID, msg );
+		return;
+	}
+
+	int iAmount = msg.ReadLong();
+
+	int iYPos;
+
+	// Use appropriate string based on client's team
+	char sResourceString[256];
+	if ( GetLocalTeam() == this )
+	{
+		itoa(iAmount, sResourceString, 10 );
+		Q_strncat( sResourceString, " RESOURCES HARVESTED!", sizeof(sResourceString), COPY_ALL_CHARACTERS );
+		iYPos = ScreenHeight() / 4;
+	}
+	else
+	{
+		char sAmount[256];
+		itoa(iAmount, sAmount, 10 );
+		Q_strncpy( sResourceString, "ENEMY TEAM HAS HARVESTED ", sizeof(sResourceString) );
+		Q_strncat( sResourceString, sAmount, sizeof(sResourceString), COPY_ALL_CHARACTERS );
+		Q_strncat( sResourceString, " RESOURCES!", sizeof(sResourceString), COPY_ALL_CHARACTERS );
+		iYPos = (ScreenHeight() / 4) + 32;
+	}
+
+	// Clear out any old strings with this ID.
+	messagechars->RemoveStringsByID( MESSAGESTRINGID_RESOURCESHARVESTED );
+
+	// Print the string
+	int width, height;
+	messagechars->GetStringLength( g_hFontTrebuchet24, &width, &height, sResourceString );
+	messagechars->DrawStringForTime( 
+		5.0, 
+		g_hFontTrebuchet24, 
+		(ScreenWidth() - width) / 2, 
+		iYPos, 
+		192, 
+		192, 
+		192, 
+		255, 
+		sResourceString,
+		MESSAGESTRINGID_RESOURCESHARVESTED );
+}
+
diff --git a/game/client/tf2/c_tfteam.h b/game/client/tf2/c_tfteam.h
new file mode 100644
index 0000000..7ee6d61
--- /dev/null
+++ b/game/client/tf2/c_tfteam.h
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client side CTFTeam class
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_TFTEAM_H
+#define C_TFTEAM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_team.h"
+#include "shareddefs.h"
+#include "techtree.h"
+#include "imessagechars.h"
+
+class C_BaseEntity;
+class C_BaseObject;
+class CBaseTechnology;
+
+//-----------------------------------------------------------------------------
+// Purpose: TF's Team manager
+//-----------------------------------------------------------------------------
+class C_TFTeam : public C_Team
+{
+	DECLARE_CLASS( C_TFTeam, C_Team );
+public:
+	DECLARE_CLIENTCLASS();
+
+					C_TFTeam();
+	virtual			~C_TFTeam();
+
+	// Data Access
+	virtual float	GetTeamResources( void );
+	virtual float	GetPotentialTeamResources( void );
+	virtual bool	GetHaveZone( void );
+
+	// Objects, note GetObject can return NULL!
+	int				GetNumObjects( int iObjectType = -1 );
+	C_BaseObject	*GetObject( int iIndex );
+	bool			IsObjectValid( int iIndex );
+
+	void			NotifyBaseUnderAttack( const Vector &vecPosition, bool bPlaySound = true, bool bForce = false );
+
+	virtual	void	ReceiveMessage( int classID,  bf_read &msg );
+
+public:
+	// Resource UI data
+	bool	m_bHaveZone;
+
+	float	m_fResources;				// Current amounts of resources
+	float	m_fPotentialResources;		// Potential amounts of each resource when all harvesters have returned
+
+	float	m_LastAttackNotificationTime;
+
+	CUtlVector< EHANDLE > m_aObjects;
+};
+
+
+#endif // C_TFTEAM_H
diff --git a/game/client/tf2/c_vehicle_battering_ram.cpp b/game/client/tf2/c_vehicle_battering_ram.cpp
new file mode 100644
index 0000000..e4c68e1
--- /dev/null
+++ b/game/client/tf2/c_vehicle_battering_ram.cpp
@@ -0,0 +1,208 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_basefourwheelvehicle.h"
+#include "tf_movedata.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include "vgui_bitmapbutton.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_VehicleBatteringRam : public C_BaseTFFourWheelVehicle
+{
+	DECLARE_CLASS( C_VehicleBatteringRam, C_BaseTFFourWheelVehicle );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_VehicleBatteringRam();
+
+public:
+	// IClientVehicle overrides
+	virtual bool IsPassengerUsingStandardWeapons( int nRole );
+	virtual void UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd );
+
+private:
+	C_VehicleBatteringRam( const C_VehicleBatteringRam & ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT(C_VehicleBatteringRam, DT_VehicleBatteringRam, CVehicleBatteringRam)
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_VehicleBatteringRam::C_VehicleBatteringRam()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Does the player use his normal weapons while in this mode?
+//-----------------------------------------------------------------------------
+bool C_VehicleBatteringRam::IsPassengerUsingStandardWeapons( int nRole )
+{
+	return (nRole > 1);
+}
+
+//-----------------------------------------------------------------------------
+// Clamps the view angles while manning the gun 
+//-----------------------------------------------------------------------------
+void C_VehicleBatteringRam::UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd )
+{
+	int nRole = GetPassengerRole( pLocalPlayer );
+
+	// Restrict the view of the 1st passenger
+	if (nRole == 1)
+	{
+		RestrictView( nRole, -90, 90, pCmd->viewangles );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CVehicleBatteringRamControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CVehicleBatteringRamControlPanel, CObjectControlPanel );
+
+public:
+	CVehicleBatteringRamControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+private:
+	void GetInRam( void );
+
+private:
+	vgui::Label		*m_pDriverLabel;
+	vgui::Label		*m_pPassengerLabel;
+	vgui::Button	*m_pOccupyButton;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CVehicleBatteringRamControlPanel, "vehicle_battering_ram_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CVehicleBatteringRamControlPanel::CVehicleBatteringRamControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CVehicleBatteringRamControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CVehicleBatteringRamControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pDriverLabel = new vgui::Label( this, "DriverReadout", "" );
+	m_pPassengerLabel = new vgui::Label( this, "PassengerReadout", "" );
+	m_pOccupyButton = new CBitmapButton( this, "OccupyButton", "Occupy" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CVehicleBatteringRamControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_VehicleBatteringRam*>(pObj) );
+	C_VehicleBatteringRam *pRam = static_cast<C_VehicleBatteringRam*>(pObj);
+
+	char buf[256];
+	// Update the currently manned player label
+	if ( pRam->GetDriverPlayer() )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Driven by %s", pRam->GetDriverPlayer()->GetPlayerName() );
+		m_pDriverLabel->SetText( buf );
+		m_pDriverLabel->SetVisible( true );
+	}
+	else
+	{
+		m_pDriverLabel->SetVisible( false );
+	}
+
+	int nPassengerCount = pRam->GetPassengerCount();
+	int nMaxPassengerCount = pRam->GetMaxPassengerCount();
+
+	Q_snprintf( buf, sizeof( buf ), "Passengers %d/%d", nPassengerCount >= 1 ? nPassengerCount - 1 : 0, nMaxPassengerCount - 1 );
+	m_pPassengerLabel->SetText( buf );
+
+	// Update the get in button
+	if ( pRam->IsPlayerInVehicle( C_BaseTFPlayer::GetLocalPlayer() ) ) 
+	{
+		m_pOccupyButton->SetEnabled( false );
+		return;
+	}
+
+	if ( pRam->GetOwner() == C_BaseTFPlayer::GetLocalPlayer() )
+	{
+		if (nPassengerCount == nMaxPassengerCount)
+		{
+			// Owners can boot other players to get in
+			C_BaseTFPlayer *pPlayer = static_cast<C_BaseTFPlayer*>(pRam->GetPassenger( VEHICLE_ROLE_DRIVER ));
+			Q_snprintf( buf, sizeof( buf ), "Get In (Ejecting %s)", pPlayer->GetPlayerName() );
+			m_pDriverLabel->SetText( buf );
+			m_pOccupyButton->SetEnabled( true );
+		}
+		else
+		{
+			m_pOccupyButton->SetText( "Get In" );
+			m_pOccupyButton->SetEnabled( true );
+		}
+	}
+	else
+	{
+		m_pOccupyButton->SetText( "Get In" );
+		m_pOccupyButton->SetEnabled( pRam->GetPassengerCount() < pRam->GetMaxPassengerCount() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Occupy button
+//-----------------------------------------------------------------------------
+void CVehicleBatteringRamControlPanel::GetInRam( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "toggle_use" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CVehicleBatteringRamControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Occupy", 7))
+	{
+		GetInRam();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_vehicle_flatbed.cpp b/game/client/tf2/c_vehicle_flatbed.cpp
new file mode 100644
index 0000000..0457d91
--- /dev/null
+++ b/game/client/tf2/c_vehicle_flatbed.cpp
@@ -0,0 +1,183 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_basefourwheelvehicle.h"
+#include "tf_movedata.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_VehicleFlatbed : public C_BaseTFFourWheelVehicle
+{
+	DECLARE_CLASS( C_VehicleFlatbed, C_BaseTFFourWheelVehicle );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_VehicleFlatbed();
+
+private:
+	C_VehicleFlatbed( const C_VehicleFlatbed & );		// not defined, not accessible
+
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_VehicleFlatbed, DT_VehicleFlatbed, CVehicleFlatbed)
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_VehicleFlatbed::C_VehicleFlatbed()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CVehicleFlatbedControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CVehicleFlatbedControlPanel, CObjectControlPanel );
+
+public:
+	CVehicleFlatbedControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+private:
+	void GetInRam( void );
+
+private:
+	vgui::Label		*m_pDriverLabel;
+	vgui::Label		*m_pPassengerLabel;
+	vgui::Button	*m_pOccupyButton;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CVehicleFlatbedControlPanel, "vehicle_battering_ram_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CVehicleFlatbedControlPanel::CVehicleFlatbedControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CVehicleBatteringRamControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CVehicleFlatbedControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pDriverLabel = new vgui::Label( this, "DriverReadout", "" );
+	m_pPassengerLabel = new vgui::Label( this, "PassengerReadout", "" );
+	m_pOccupyButton = new vgui::Button( this, "OccupyButton", "Occupy" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CVehicleFlatbedControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_VehicleFlatbed*>(pObj) );
+	C_VehicleFlatbed *pRam = static_cast<C_VehicleFlatbed*>(pObj);
+
+	char buf[256];
+	// Update the currently manned player label
+	if ( pRam->GetDriverPlayer() )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Driven by %s", pRam->GetDriverPlayer()->GetPlayerName() );
+		m_pDriverLabel->SetText( buf );
+		m_pDriverLabel->SetVisible( true );
+	}
+	else
+	{
+		m_pDriverLabel->SetVisible( false );
+	}
+
+	int nPassengerCount = pRam->GetPassengerCount();
+	int nMaxPassengerCount = pRam->GetMaxPassengerCount();
+
+	Q_snprintf( buf, sizeof( buf ), "Passengers %d/%d", nPassengerCount >= 1 ? nPassengerCount - 1 : 0, nMaxPassengerCount - 1 );
+	m_pPassengerLabel->SetText( buf );
+
+	// Update the get in button
+	if ( pRam->IsPlayerInVehicle( C_BaseTFPlayer::GetLocalPlayer() ) ) 
+	{
+		m_pOccupyButton->SetEnabled( false );
+		return;
+	}
+
+	if ( pRam->GetOwner() == C_BaseTFPlayer::GetLocalPlayer() )
+	{
+		if (nPassengerCount == nMaxPassengerCount)
+		{
+			// Owners can boot other players to get in
+			C_BaseTFPlayer *pPlayer = static_cast<C_BaseTFPlayer*>(pRam->GetPassenger( VEHICLE_ROLE_DRIVER ));
+			Q_snprintf( buf, sizeof( buf ), "Get In (Ejecting %s)", pPlayer->GetPlayerName() );
+			m_pDriverLabel->SetText( buf );
+			m_pOccupyButton->SetEnabled( true );
+		}
+		else
+		{
+			m_pOccupyButton->SetText( "Get In" );
+			m_pOccupyButton->SetEnabled( true );
+		}
+	}
+	else
+	{
+		m_pOccupyButton->SetText( "Get In" );
+		m_pOccupyButton->SetEnabled( pRam->GetPassengerCount() < pRam->GetMaxPassengerCount() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Occupy button
+//-----------------------------------------------------------------------------
+void CVehicleFlatbedControlPanel::GetInRam( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "toggle_use" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CVehicleFlatbedControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Occupy", 7))
+	{
+		GetInRam();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_vehicle_mortar.cpp b/game/client/tf2/c_vehicle_mortar.cpp
new file mode 100644
index 0000000..844c544
--- /dev/null
+++ b/game/client/tf2/c_vehicle_mortar.cpp
@@ -0,0 +1,869 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_basefourwheelvehicle.h"
+#include "tf_movedata.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+#include "vehicle_mortar_shared.h"
+#include "vgui_rotation_slider.h"
+#include <vgui/ISurface.h>
+#include "vgui_basepanel.h"
+#include "ground_line.h"
+#include "hud_minimap.h"
+#include "vgui_bitmapimage.h"
+#include "iusesmortarpanel.h"
+
+// How long it waits after you've changed the mortar's yaw to draw using the server's value.
+#define CLIENT_MORTAR_YAW_COUNTDOWN	0.5
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_VehicleMortar : public C_BaseTFFourWheelVehicle, public IUsesMortarPanel
+{
+	DECLARE_CLASS( C_VehicleMortar, C_BaseTFFourWheelVehicle );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_VehicleMortar();
+
+	virtual void ReceiveMessage( int classID,  bf_read &msg );
+
+	// Fire off a mortar.
+	void FireMortar();
+
+	virtual void ClientThink();
+
+// C_BaseEntity overrides.
+public:
+	virtual void GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS]);
+
+// IUsesMortarPanel
+public:
+	// Get the data from this mortar needed by the panel
+	virtual void	GetMortarData( float *flClientMortarYaw, bool *bAllowedToFire, float *flPower, float *flFiringPower, float *flFiringAccuracy, int *iFiringState );
+	virtual void	SendYawCommand( void );
+	virtual void	ForceClientYawCountdown( float flTime );
+	virtual void	ClickFire( void );
+
+public:
+	// Mortar firing info.
+	int m_iFiringState; // One of the MORTAR_ defines.
+	bool m_bMortarReloading;
+	float m_flPower;
+	bool m_bAllowedToFire;
+	
+	// Parameters for the next shot.
+	float m_flFiringPower;
+	float m_flFiringAccuracy;
+
+	float m_flMortarYaw;	// What direction the mortar is aimed in.
+	float m_flMortarPitch;
+	
+	// This is what is used on the client to draw the ground line and orient the mortar.
+	// It is usually copied right over from m_flClientMortarYaw (which comes from the server),
+	// but this is also used when rotating the mortar so you can see the line move smoothly.
+	float m_flClientMortarYaw;
+
+	// This is set to about 1/4 seconds when you rotate the mortar line so you use the client's
+	// (smooth, non-lagged) yaw changes instead of the server's.
+	float m_flForceClientYawCountdown;
+
+private:
+	C_VehicleMortar( const C_VehicleMortar & );		// not defined, not accessible
+
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_VehicleMortar, DT_VehicleMortar, CVehicleMortar)
+	RecvPropFloat( RECVINFO( m_flMortarYaw ) ),
+	RecvPropFloat( RECVINFO( m_flMortarPitch ) ),
+	RecvPropBool( RECVINFO( m_bAllowedToFire ) )
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+C_VehicleMortar::C_VehicleMortar()
+{
+	m_iFiringState = MORTAR_IDLE;
+	m_bMortarReloading = false;
+	m_flPower = 0;
+	
+	m_flMortarYaw = 0;
+	m_flClientMortarYaw = 0;
+	m_flMortarPitch = 0;
+	m_flForceClientYawCountdown = 0;
+	m_bAllowedToFire = true;
+
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+}
+
+
+void C_VehicleMortar::ReceiveMessage( int classID, bf_read &msg )
+{
+	if ( classID != GetClientClass()->m_ClassID )
+	{
+		// message is for subclass
+		BaseClass::ReceiveMessage( classID, msg );
+		return;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_VehicleMortar::ClickFire()
+{
+	switch( m_iFiringState )
+	{
+	case MORTAR_IDLE:
+		m_iFiringState = MORTAR_CHARGING_POWER;
+		break;
+	
+	case MORTAR_CHARGING_POWER:
+		m_flFiringPower = m_flPower;
+		m_iFiringState = MORTAR_CHARGING_ACCURACY;
+		break;
+	
+	case MORTAR_CHARGING_ACCURACY:
+		m_flFiringAccuracy = m_flPower;
+		m_iFiringState = MORTAR_IDLE;
+
+		FireMortar();
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_VehicleMortar::FireMortar()
+{
+	char cmd[512];
+	Q_snprintf( cmd, sizeof( cmd ), "FireMortar %.2f %.2f", m_flFiringPower, m_flFiringAccuracy );
+	SendClientCommand( cmd );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_VehicleMortar::SendYawCommand( void )
+{
+	char szbuf[48];
+	Q_snprintf( szbuf, sizeof( szbuf ), "MortarYaw %0.2f\n", m_flClientMortarYaw );
+	SendClientCommand( szbuf );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_VehicleMortar::ForceClientYawCountdown( float flTime )
+{
+	m_flForceClientYawCountdown = flTime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_VehicleMortar::GetMortarData( float *flClientMortarYaw, bool *bAllowedToFire, float *flPower, float *flFiringPower, float *flFiringAccuracy, int *iFiringState )
+{
+	*flClientMortarYaw = m_flClientMortarYaw;
+	*bAllowedToFire = m_bAllowedToFire;
+	*flPower = m_flPower;
+	*flFiringPower = m_flFiringPower;
+	*flFiringAccuracy = m_flFiringAccuracy;
+	*iFiringState = m_iFiringState;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_VehicleMortar::ClientThink()
+{
+	m_flForceClientYawCountdown -= gpGlobals->frametime;
+	if ( m_flForceClientYawCountdown <= 0 )
+	{
+		m_flClientMortarYaw = m_flMortarYaw;
+	}
+}
+
+
+void C_VehicleMortar::GetBoneControllers( float controllers[MAXSTUDIOBONECTRLS])
+{
+	BaseClass::GetBoneControllers( controllers);
+
+	controllers[0] = anglemod( m_flClientMortarYaw ) / 360.0;
+	controllers[1] = anglemod( m_flMortarPitch ) / 360.0;
+}
+
+
+//-----------------------------------------------------------------------------
+// CMortarMinimapPanel
+//-----------------------------------------------------------------------------
+CMortarMinimapPanel::CMortarMinimapPanel( vgui::Panel *pParent, const char *pElementName )
+	: CMinimapPanel( pElementName )
+{
+	SetParent( pParent );
+
+	m_bMouseDown = false;
+	m_bFireButtonDown = false;
+	m_LastX = m_LastY = -1;
+	
+	m_nTextureId = vgui::surface()->CreateNewTextureID();
+	vgui::surface()->DrawSetTextureFile( m_nTextureId, "hud/minimap/mortar_slider", true, false );
+
+	m_nTextureId_CantFire = vgui::surface()->CreateNewTextureID();
+	vgui::surface()->DrawSetTextureFile( m_nTextureId_CantFire, "hud/minimap/mortar_slider_cantfire", true, false );
+}
+
+
+CMortarMinimapPanel::~CMortarMinimapPanel()
+{
+}
+
+void CMortarMinimapPanel::InitMortarMinimap( C_BaseEntity *pMortar )
+{
+	BaseClass::Init( NULL );
+
+	m_hMortar = pMortar;
+	
+	m_MortarButtonUp.Init( GetVPanel(), "hud/minimap/icon_mortarbutton_up" );
+	m_MortarButtonDown.Init( GetVPanel(), "hud/minimap/icon_mortarbutton_dn" );
+	m_MortarButtonCantFire.Init( GetVPanel(), "hud/minimap/icon_mortarbutton_cantfire" );
+	
+	m_MortarDirectionImage.Init( GetVPanel(), "hud/minimap/icon_player_arrow" );
+	m_MortarDirectionImage.SetColor( Color( 0, 255, 0, 255 ) );
+}
+
+
+C_BaseEntity *CMortarMinimapPanel::GetMortar() const
+{
+	return (C_BaseEntity*)m_hMortar;
+}
+
+
+void CMortarMinimapPanel::Paint()
+{
+	BaseClass::Paint();
+
+	C_BaseEntity *pMortar = GetMortar();
+	IUsesMortarPanel *pMortarInterface = dynamic_cast< IUsesMortarPanel* >( pMortar );
+	if ( pMortar && pMortarInterface )
+	{
+		float flClientMortarYaw, flPower, flFiringPower, flFiringAccuracy;
+		int iFiringState;
+		bool bAllowedToFire; 
+		pMortarInterface->GetMortarData( &flClientMortarYaw, &bAllowedToFire, &flPower, &flFiringPower, &flFiringAccuracy, &iFiringState );
+
+		float yaw = flClientMortarYaw + 90;
+	
+		float x, y;
+		if ( WorldToMinimap( MINIMAP_CLAMP, pMortar->GetAbsOrigin(), x, y ) )
+		{
+			int size = 20;
+			
+			BitmapImage *pImage = &m_MortarButtonCantFire;
+			if ( bAllowedToFire )
+			{				
+				if ( m_bFireButtonDown )
+					pImage = &m_MortarButtonDown;
+				else
+					pImage = &m_MortarButtonUp;
+			}
+
+			pImage->DoPaint( x-size/2, y-size/2, size, size, yaw );
+
+			size = 40;
+			m_MortarDirectionImage.DoPaint( x-size/2, y-size/2, size, size, pMortar->GetAbsAngles()[YAW] + 90 );
+
+		
+			// Draw the power bar.
+			float flAngle = pMortar->GetAbsAngles()[YAW] + flClientMortarYaw;
+			Vector vForward( -sin( DEG2RAD( flAngle ) ), cos( DEG2RAD( flAngle ) ), 0 );
+			Vector vRight( vForward.y, -vForward.x, 0 );
+
+			Vector vStartPoint = pMortar->GetAbsOrigin();
+			Vector vEndPoint = vStartPoint + vForward * MORTAR_RANGE_MAX_INITIAL;
+			Vector vInaccuracy = vEndPoint + vRight * (MORTAR_RANGE_MAX_INITIAL * MORTAR_INACCURACY_MAX_INITIAL);
+			
+			Vector2D vStart2D, vEnd2D, vInaccuracy2D;
+			WorldToMinimap( MINIMAP_ALWAYS_ACCEPT, vStartPoint, vStart2D.x, vStart2D.y );
+			WorldToMinimap( MINIMAP_ALWAYS_ACCEPT, vEndPoint, vEnd2D.x, vEnd2D.y );
+			WorldToMinimap( MINIMAP_ALWAYS_ACCEPT, vInaccuracy, vInaccuracy2D.x, vInaccuracy2D.y );
+			
+			Vector2D vDir = vEnd2D - vStart2D;
+			Vector2DNormalize( vDir );
+
+			
+			// These variables control the look.
+			float flLength = (vEnd2D - vStart2D).Length();
+			float flZeroT = 1.0f / 5;
+			float flZero = flLength * flZeroT;
+			
+			float flFirePower = MAX( flPower, flFiringPower );
+
+			float flStartFatness = 2;
+			float flEndFatness = flStartFatness;
+			
+			float flScalePower = flFiringAccuracy;
+			if ( iFiringState != MORTAR_IDLE )
+				flScalePower = flPower;
+
+			Vector2D vInaccuracyDir = vInaccuracy2D - vEnd2D;
+			flEndFatness *= vInaccuracyDir.Length() * flScalePower * 0.4;
+			flEndFatness = MAX( fabs( flEndFatness ), flStartFatness );
+			
+			Vector2D vPerp( vDir.y, -vDir.x );
+			Vector2DNormalize( vPerp );
+			
+			Vector2D vStartPerp = vPerp * flStartFatness;
+			Vector2D vEndPerp = vPerp * flEndFatness;
+
+			
+			// Draw the red-black power bars.
+			vgui::ISurface *pSurface = vgui::surface();
+			if ( bAllowedToFire )
+				pSurface->DrawSetTexture( m_nTextureId );
+			else
+				pSurface->DrawSetTexture( m_nTextureId_CantFire );
+			
+			Vector2D vZeroPerp;
+			Vector2DLerp( vStartPerp, vEndPerp, flZero / flLength, vZeroPerp );
+						
+			// Draw a black->red bar from zero to our current power.
+			float flFirePowerDistance = RemapVal( flFirePower, 0, 1, flZero, flLength );
+			Vector2D vPowerPerp;
+			Vector2DLerp( vStartPerp, vEndPerp, RemapVal( flFirePowerDistance, flZero, flLength, flZeroT, 1 ), vPowerPerp );
+
+			vgui::Vertex_t verts[4];
+			verts[0].Init( vStart2D + vDir * flZero - vZeroPerp );
+			verts[1].Init( verts[0].m_Position + vZeroPerp * 2 );
+
+			verts[2].Init( vStart2D + vDir * flFirePowerDistance + vPowerPerp, Vector2D( flFirePower, 0 ) );
+			verts[3] = verts[2];
+			verts[3].m_Position -= vPowerPerp * 2;
+			
+			pSurface->DrawSetColor( 255, 255, 255, 255 );
+			pSurface->DrawTexturedPolygon( 4, verts );
+
+
+			// Draw the power slider.
+			pSurface->DrawSetTexture( -1 );
+
+
+			vgui::Vertex_t line[2];
+			line[0].Init( vStart2D + vDir * flFirePowerDistance - vPowerPerp );
+			line[1].Init( line[0].m_Position + vPowerPerp * 2 );
+			pSurface->DrawTexturedLine( line[0], line[1] );
+
+
+
+			// Draw a white outline.
+			pSurface->DrawSetColor( 255, 255, 255, 255 );
+			vgui::Vertex_t pts[4] =
+			{
+				vgui::Vertex_t( vStart2D - vStartPerp ),
+				vgui::Vertex_t( vStart2D + vStartPerp ),
+				vgui::Vertex_t( vEnd2D + vEndPerp ),
+				vgui::Vertex_t( vEnd2D - vEndPerp )
+			};
+			pSurface->DrawTexturedPolyLine( pts, 4 );
+
+
+			// Draw the zero line.
+			line[0].Init( vStart2D + vDir * flZero - vZeroPerp );
+			line[1].Init( line[0].m_Position + vZeroPerp * 2 );
+			pSurface->DrawTexturedLine( line[0], line[1] );
+		}
+	}
+}
+
+
+void CMortarMinimapPanel::OnMousePressed( vgui::MouseCode code )
+{
+	BaseClass::OnMousePressed( code );
+
+	if (code != vgui::MOUSE_LEFT)
+		return;
+
+	C_BaseEntity *pMortar = GetMortar();
+	IUsesMortarPanel *pMortarInterface = dynamic_cast< IUsesMortarPanel* >( pMortar );
+	if ( !pMortar || !pMortarInterface )
+		return;
+
+	float flClientMortarYaw, flPower, flFiringPower, flFiringAccuracy;
+	int iFiringState;
+	bool bAllowedToFire; 
+	pMortarInterface->GetMortarData( &flClientMortarYaw, &bAllowedToFire, &flPower, &flFiringPower, &flFiringAccuracy, &iFiringState );
+	
+	// See if they clicked the "fire" button.
+	float x, y;
+	if ( WorldToMinimap( MINIMAP_ALWAYS_ACCEPT, pMortar->GetAbsOrigin(), x, y ) &&
+		(Vector2D( x, y ) - Vector2D( m_LastX, m_LastY )).Length() <= 8 )
+	{
+		if ( bAllowedToFire )
+		{
+			// Treat it like they clicked the fire button.
+			m_bFireButtonDown = true;
+			pMortarInterface->ClickFire();
+		}
+	}
+	else
+	{
+		pMortarInterface->ForceClientYawCountdown( 5000000 );
+	}
+
+	m_bMouseDown = true;
+}
+
+
+void CMortarMinimapPanel::OnCursorMoved( int x, int y )
+{
+	m_LastX = x;
+	m_LastY = y;
+
+	if ( !m_bMouseDown || m_bFireButtonDown )
+		return;
+
+	C_BaseEntity *pMortar = GetMortar();
+	IUsesMortarPanel *pMortarInterface = dynamic_cast< IUsesMortarPanel* >( pMortar );
+	if ( !pMortar || !pMortarInterface )
+		return;
+
+	float flClientMortarYaw, flPower, flFiringPower, flFiringAccuracy;
+	int iFiringState;
+	bool bAllowedToFire; 
+	pMortarInterface->GetMortarData( &flClientMortarYaw, &bAllowedToFire, &flPower, &flFiringPower, &flFiringAccuracy, &iFiringState );
+
+	float mortarX, mortarY;
+	if ( WorldToMinimap( MINIMAP_ALWAYS_ACCEPT, pMortar->GetAbsOrigin(), mortarX, mortarY ) )
+	{
+		float flAngle = atan2( x - mortarX, mortarY - y );
+		flClientMortarYaw = -anglemod( flAngle * 180.0f / M_PI + pMortar->GetAbsAngles()[YAW] );
+	}
+}
+
+
+void CMortarMinimapPanel::OnMouseReleased( vgui::MouseCode code )
+{
+	BaseClass::OnMouseReleased( code );
+
+	if ( code != vgui::MOUSE_LEFT )
+		return;
+
+	m_bMouseDown = false;
+	
+	if ( m_bFireButtonDown )
+	{
+		m_bFireButtonDown = false;
+	}
+	else
+	{
+		C_BaseEntity *pMortar = GetMortar();
+		IUsesMortarPanel *pMortarInterface = dynamic_cast< IUsesMortarPanel* >( pMortar );
+		if ( pMortar && pMortarInterface )
+		{
+			pMortarInterface->SendYawCommand();
+			pMortarInterface->ForceClientYawCountdown( CLIENT_MORTAR_YAW_COUNTDOWN );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CVehicleMortarControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CVehicleMortarControlPanel, CObjectControlPanel );
+
+public:
+	
+	CVehicleMortarControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual ~CVehicleMortarControlPanel();
+	
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnCommand( const char *command );
+	C_VehicleMortar* GetMortar() const;
+
+
+protected:
+
+	virtual vgui::Panel* TickCurrentPanel();
+
+
+private:
+
+	void OnTickMainPanel();
+	void OnTickDeployPanel( float flDeployTime );
+	void OnTickGunnerPanel();
+
+	void GetInRam( void );
+
+	void StartDeploying();
+	void StopDismantling();
+	bool IsDeploying() const;
+	bool IsUndeploying() const;
+	bool IsDeployed() const;
+
+private:
+	vgui::Label		*m_pDriverLabel;
+	vgui::Label		*m_pPassengerLabel;
+	vgui::Button	*m_pOccupyButton;
+	vgui::Button	*m_pCancelDeployButton;
+	
+	vgui::Label *m_pDeployMessageLabel; // says "Deployed in" or "Undeployed in"
+	vgui::Label *m_pDeployTimeLabel; // says "N seconds"
+	
+	vgui::EditablePanel	*m_pDeployPanel;
+	vgui::EditablePanel	*m_pGunnerPanel;
+
+	CMortarMinimapPanel *m_pMinimapPanel;
+	
+	vgui::Label *m_pReloadingLabel;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CVehicleMortarControlPanel, "vehicle_mortar_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CVehicleMortarControlPanel::CVehicleMortarControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CVehicleMortarControlPanel" ) 
+{
+	m_pDeployPanel = new CCommandChainingPanel( this, "DeployPanel" );
+	m_pDeployPanel->SetZPos( -1 );
+
+	m_pGunnerPanel = new CCommandChainingPanel( this, "GunnerPanel" );
+	m_pGunnerPanel->SetZPos( -1 );
+
+	m_pMinimapPanel = new CMortarMinimapPanel( m_pGunnerPanel, "MinimapPanel" );
+	m_pMinimapPanel->SetZPos( 10 );
+	m_pMinimapPanel->Init( NULL );
+}
+
+
+CVehicleMortarControlPanel::~CVehicleMortarControlPanel()
+{
+	delete m_pMinimapPanel;
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CVehicleMortarControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pDriverLabel = new vgui::Label( this, "DriverReadout", "" );
+	m_pPassengerLabel = new vgui::Label( this, "PassengerReadout", "" );
+	m_pOccupyButton = new vgui::Button( this, "OccupyButton", "Occupy" );
+	
+	m_pDeployMessageLabel = new vgui::Label( m_pDeployPanel, "DeployMessage", "" );
+	m_pDeployTimeLabel = new vgui::Label( m_pDeployPanel, "DeployTime", "" );
+	m_pCancelDeployButton = new vgui::Button( m_pDeployPanel, "CancelDeployButton", "" );
+
+	m_pReloadingLabel = new vgui::Label( m_pGunnerPanel, "ReloadingLabel", "" );
+
+	// Make sure all named panels are created up above because BaseClass::Init initializes them
+	// all from their keyvalues.
+	if ( !BaseClass::Init( pKeyValues, pInitData ) )
+		return false;
+
+	// Init subpanels.
+	int x, y, w, h;
+	GetBounds( x, y, w, h );
+
+	m_pMinimapPanel->LevelInit( engine->GetLevelName() );
+	m_pMinimapPanel->SetVisible( true );
+	m_pMinimapPanel->InitMortarMinimap( GetMortar() );
+	
+	m_pDeployPanel->SetBounds( x, y, w, h );
+	m_pDeployPanel->SetVisible( false );
+
+	m_pGunnerPanel->SetBounds( x, y, w, h );
+	m_pGunnerPanel->SetVisible( false );
+
+	m_pReloadingLabel->SetVisible( false );
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+
+vgui::Panel* CVehicleMortarControlPanel::TickCurrentPanel()
+{
+	C_VehicleMortar *pMortar = GetMortar();
+	if ( !pMortar )
+		return BaseClass::TickCurrentPanel();
+
+	if ( IsUndeploying() )
+	{
+		OnTickDeployPanel( pMortar->GetDeployFinishTime() );
+		return m_pDeployPanel;
+	}
+	else if ( IsDeploying() )
+	{
+		OnTickDeployPanel( pMortar->GetDeployFinishTime() );
+		return m_pDeployPanel;
+	}
+	else if ( IsDeployed() )
+	{
+		OnTickGunnerPanel();
+		return m_pGunnerPanel;
+	}
+	else
+	{
+		OnTickMainPanel();
+		return BaseClass::TickCurrentPanel();
+	}
+}
+
+
+C_VehicleMortar* CVehicleMortarControlPanel::GetMortar() const
+{
+	return dynamic_cast< C_VehicleMortar* >( GetOwningObject() );
+}
+
+
+void CVehicleMortarControlPanel::OnTickMainPanel()
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	ShowOwnerLabel( true );
+	ShowHealthLabel( true );
+
+	Assert( dynamic_cast<C_VehicleMortar*>(pObj) );
+	C_VehicleMortar *pRam = static_cast<C_VehicleMortar*>(pObj);
+
+	char buf[256];
+	// Update the currently manned player label
+	if ( pRam->GetDriverPlayer() )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Driven by %s", pRam->GetDriverPlayer()->GetPlayerName() );
+		m_pDriverLabel->SetText( buf );
+		m_pDriverLabel->SetVisible( true );
+	}
+	else
+	{
+		m_pDriverLabel->SetVisible( false );
+	}
+
+	int nPassengerCount = pRam->GetPassengerCount();
+	int nMaxPassengerCount = pRam->GetMaxPassengerCount();
+
+	Q_snprintf( buf, sizeof( buf ), "Passengers %d/%d", nPassengerCount >= 1 ? nPassengerCount - 1 : 0, nMaxPassengerCount - 1 );
+	m_pPassengerLabel->SetText( buf );
+
+	// Update the get in button
+	if ( pRam->IsPlayerInVehicle( C_BaseTFPlayer::GetLocalPlayer() ) ) 
+	{
+		m_pOccupyButton->SetEnabled( false );
+		return;
+	}
+
+	if ( pRam->GetOwner() == C_BaseTFPlayer::GetLocalPlayer() )
+	{
+		if (nPassengerCount == nMaxPassengerCount)
+		{
+			// Owners can boot other players to get in
+			C_BaseTFPlayer *pPlayer = static_cast<C_BaseTFPlayer*>(pRam->GetPassenger( VEHICLE_ROLE_DRIVER ));
+			Q_snprintf( buf, sizeof( buf ), "Get In (Ejecting %s)", pPlayer->GetPlayerName() );
+			m_pDriverLabel->SetText( buf );
+			m_pOccupyButton->SetEnabled( true );
+		}
+		else
+		{
+			m_pOccupyButton->SetText( "Get In" );
+			m_pOccupyButton->SetEnabled( true );
+		}
+	}
+	else
+	{
+		m_pOccupyButton->SetText( "Get In" );
+		m_pOccupyButton->SetEnabled( pRam->GetPassengerCount() < pRam->GetMaxPassengerCount() );
+	}
+}
+
+
+void CVehicleMortarControlPanel::OnTickDeployPanel( float flDeployTime )
+{
+	ShowDismantleButton( false );
+
+	// Update the countdown.
+	int nSec = (int)(flDeployTime - gpGlobals->curtime + 0.5f);
+	if (nSec < 0)
+		nSec = 0;
+
+	char buf[256];
+	int nLen = Q_snprintf( buf, sizeof( buf ), "%d second", nSec );
+	if (nSec != 1)
+	{
+		buf[nLen] = 's';
+		++nLen;
+		buf[nLen] = 0;
+	}
+
+	m_pDeployTimeLabel->SetText( buf );
+}
+
+
+void CVehicleMortarControlPanel::OnTickGunnerPanel()
+{
+	C_VehicleMortar *pMortar = GetMortar();
+	if ( !pMortar )
+		return;
+
+	ShowOwnerLabel( false );
+	ShowHealthLabel( false );
+
+	m_pMinimapPanel->Repaint();
+
+	// If it's reloading, tell the player
+	m_pReloadingLabel->SetVisible( pMortar->m_bMortarReloading );
+	if ( pMortar->m_bMortarReloading )
+	{
+		return;
+	}
+
+	float flAccuracySpeed = (1.0 / MORTAR_CHARGE_ACCURACY_RATE);
+
+	// Handle power charging
+	switch( pMortar->m_iFiringState )
+	{
+	case MORTAR_IDLE:
+		pMortar->m_flPower = 0;
+		break;
+
+	case MORTAR_CHARGING_POWER:
+		pMortar->m_flPower = MIN( pMortar->m_flPower + ( (1.0 / MORTAR_CHARGE_POWER_RATE) * gpGlobals->frametime), 1 );
+		pMortar->m_flFiringPower = 0;
+		pMortar->m_flFiringAccuracy = 0;
+		if ( pMortar->m_flPower >= 1.0 )
+		{
+			// Hit Max, start going down
+			pMortar->m_flFiringPower = pMortar->m_flPower;
+			pMortar->m_iFiringState = MORTAR_CHARGING_ACCURACY;
+		}
+		break;
+
+	case MORTAR_CHARGING_ACCURACY:
+		// Calculate accuracy speed
+		if ( pMortar->m_flFiringPower > 0.5 )
+		{
+			// Shots over halfway suffer an increased speed to the accuracy power, making accurate shots harder
+			float flAdjustedPower = (pMortar->m_flFiringPower - 0.5) * 3.0;
+			flAccuracySpeed += (pMortar->m_flFiringPower * flAdjustedPower);
+		}
+
+		pMortar->m_flPower = MAX( pMortar->m_flPower - ( flAccuracySpeed * gpGlobals->frametime), -0.25f);
+		if ( pMortar->m_flPower <= -0.25 )
+		{
+			// Hit Min, fire mortar
+			pMortar->m_flFiringAccuracy = pMortar->m_flPower;
+			pMortar->m_iFiringState = MORTAR_IDLE;
+
+			pMortar->FireMortar();
+		}
+		break;
+	
+	default:
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Occupy button
+//-----------------------------------------------------------------------------
+void CVehicleMortarControlPanel::GetInRam( void )
+{
+	SendToServerObject( "toggle_use" );
+}
+
+//-----------------------------------------------------------------------------
+// Starts/stops deploying
+//-----------------------------------------------------------------------------
+
+bool CVehicleMortarControlPanel::IsDeploying() const
+{
+	C_VehicleMortar *pMortar = GetMortar();
+	if ( !pMortar )
+		return false;
+
+	return !IsDeployed() && pMortar->GetDeployFinishTime() > 0.0f;
+}
+
+bool CVehicleMortarControlPanel::IsUndeploying() const
+{
+	C_VehicleMortar *pMortar = GetMortar();
+	if ( !pMortar )
+		return false;
+
+	return IsDeployed() && pMortar->GetDeployFinishTime() > 0.0f;
+}
+
+bool CVehicleMortarControlPanel::IsDeployed() const
+{
+	C_VehicleMortar *pMortar = GetMortar();
+	if ( pMortar )
+		return pMortar->GetVehicleModeDeploy() == VEHICLE_MODE_DEPLOYED;
+	else
+		return false;
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CVehicleMortarControlPanel::OnCommand( const char *command )
+{
+	C_VehicleMortar *pMortar = GetMortar();
+	if ( !pMortar )
+		return;
+
+	if (!Q_strnicmp(command, "Occupy", 7))
+	{
+		GetInRam();
+		return;
+	}
+	else if ( !Q_stricmp( command, "Deploy" ) )
+	{
+		m_pDeployMessageLabel->SetText( "Deployed in" );
+		m_pCancelDeployButton->SetVisible( true );
+
+		SendToServerObject( "Deploy" );	// Tell the server.
+	}
+	else if ( !Q_stricmp( command, "CancelDeploy" ) )
+	{
+		SendToServerObject( command );
+	}
+	else if ( !Q_stricmp( command, "Undeploy" ) )
+	{
+		m_pDeployMessageLabel->SetText( "Undeployed in" );
+		m_pCancelDeployButton->SetVisible( false );
+
+		SendToServerObject( "Undeploy" );	// Tell the server.
+	}
+	else if ( !Q_stricmp( command, "FireMortar" ) )
+	{
+		pMortar->ClickFire();
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_vehicle_motorcycle.cpp b/game/client/tf2/c_vehicle_motorcycle.cpp
new file mode 100644
index 0000000..441e74d
--- /dev/null
+++ b/game/client/tf2/c_vehicle_motorcycle.cpp
@@ -0,0 +1,184 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_basefourwheelvehicle.h"
+#include "tf_movedata.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_VehicleMotorcycle : public C_BaseTFFourWheelVehicle
+{
+	DECLARE_CLASS( C_VehicleMotorcycle, C_BaseTFFourWheelVehicle );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_VehicleMotorcycle();
+
+private:
+	C_VehicleMotorcycle( const C_VehicleMotorcycle & );		// not defined, not accessible
+
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_VehicleMotorcycle, DT_VehicleMotorcycle, CVehicleMotorcycle)
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_VehicleMotorcycle::C_VehicleMotorcycle()
+{
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CVehicleMotorcycleControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CVehicleMotorcycleControlPanel, CObjectControlPanel );
+
+public:
+	CVehicleMotorcycleControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+private:
+	void GetInCycle( void );
+
+private:
+	vgui::Label		*m_pDriverLabel;
+	vgui::Label		*m_pPassengerLabel;
+	vgui::Button	*m_pOccupyButton;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CVehicleMotorcycleControlPanel, "vehicle_wagon_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CVehicleMotorcycleControlPanel::CVehicleMotorcycleControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CVehicleMotorcycleControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CVehicleMotorcycleControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pDriverLabel = new vgui::Label( this, "DriverReadout", "" );
+	m_pPassengerLabel = new vgui::Label( this, "PassengerReadout", "" );
+	m_pOccupyButton = new vgui::Button( this, "OccupyButton", "Occupy" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CVehicleMotorcycleControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_VehicleMotorcycle*>(pObj) );
+	C_VehicleMotorcycle *pCycle = static_cast<C_VehicleMotorcycle*>(pObj);
+
+	char buf[256];
+	// Update the currently manned player label
+	if ( pCycle->GetDriverPlayer() )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Driven by %s", pCycle->GetDriverPlayer()->GetPlayerName() );
+		m_pDriverLabel->SetText( buf );
+		m_pDriverLabel->SetVisible( true );
+	}
+	else
+	{
+		m_pDriverLabel->SetVisible( false );
+	}
+
+	int nPassengerCount = pCycle->GetPassengerCount();
+	int nMaxPassengerCount = pCycle->GetMaxPassengerCount();
+
+	Q_snprintf( buf, sizeof( buf ), "Passengers %d/%d", nPassengerCount >= 1 ? nPassengerCount - 1 : 0, nMaxPassengerCount - 1 );
+	m_pPassengerLabel->SetText( buf );
+
+	// Update the get in button
+	if ( pCycle->IsPlayerInVehicle( C_BaseTFPlayer::GetLocalPlayer() ) ) 
+	{
+		m_pOccupyButton->SetEnabled( false );
+		return;
+	}
+
+	if ( pCycle->GetOwner() == C_BaseTFPlayer::GetLocalPlayer() )
+	{
+		if (nPassengerCount == nMaxPassengerCount)
+		{
+			// Owners can boot other players to get in
+			C_BaseTFPlayer *pPlayer = static_cast<C_BaseTFPlayer*>(pCycle->GetPassenger( VEHICLE_ROLE_DRIVER ));
+			Q_snprintf( buf, sizeof( buf ), "Get In (Ejecting %s)", pPlayer->GetPlayerName() );
+			m_pDriverLabel->SetText( buf );
+			m_pOccupyButton->SetEnabled( true );
+		}
+		else
+		{
+			m_pOccupyButton->SetText( "Get In" );
+			m_pOccupyButton->SetEnabled( true );
+		}
+	}
+	else
+	{
+		m_pOccupyButton->SetText( "Get In" );
+		m_pOccupyButton->SetEnabled( pCycle->GetPassengerCount() < pCycle->GetMaxPassengerCount() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Occupy button
+//-----------------------------------------------------------------------------
+void CVehicleMotorcycleControlPanel::GetInCycle( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "toggle_use" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CVehicleMotorcycleControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Occupy", 7))
+	{
+		GetInCycle();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_vehicle_siege_tower.cpp b/game/client/tf2/c_vehicle_siege_tower.cpp
new file mode 100644
index 0000000..d82c28a
--- /dev/null
+++ b/game/client/tf2/c_vehicle_siege_tower.cpp
@@ -0,0 +1,261 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Siege Tower Vechicle
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_basefourwheelvehicle.h"
+#include "tf_movedata.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include "vgui_bitmapbutton.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_VehicleSiegeTower : public C_BaseTFFourWheelVehicle
+{
+	DECLARE_CLASS( C_VehicleSiegeTower, C_BaseTFFourWheelVehicle );
+
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_VehicleSiegeTower();
+
+// C_BaseEntity overrides.
+public:
+
+//	virtual void	DebugMessages( void );
+
+private:
+
+	C_VehicleSiegeTower( const C_VehicleSiegeTower & );		// not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_VehicleSiegeTower, DT_VehicleSiegeTower, CVehicleSiegeTower )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_VehicleSiegeTower::C_VehicleSiegeTower()
+{
+}
+
+#if 0
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_VehicleSiegeTower::DebugMessages( void )
+{
+	Msg( "Seq: %d, Play: %f, Cycle: %f, Anim %f, Done: %d\n", GetSequence(), m_flPlaybackRate, GetCycle(), m_flAnimTime,
+		  ( int )m_fSequenceFinished );
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CVehicleSiegeTowerControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CVehicleSiegeTowerControlPanel, CObjectControlPanel );
+
+public:
+
+	CVehicleSiegeTowerControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+private:
+
+	void GetInTower( void );
+
+private:
+
+	vgui::Label		*m_pDriverLabel;
+	vgui::Label		*m_pPassengerLabel;
+	vgui::Button	*m_pOccupyButton;
+};
+
+DECLARE_VGUI_SCREEN_FACTORY( CVehicleSiegeTowerControlPanel, "vehicle_siege_tower_control_panel" );
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CVehicleSiegeTowerControlPanel::CVehicleSiegeTowerControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CVehicleSiegeTowerControlPanel" ) 
+{
+}
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CVehicleSiegeTowerControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pDriverLabel = new vgui::Label( this, "DriverReadout", "" );
+	m_pPassengerLabel = new vgui::Label( this, "PassengerReadout", "" );
+	m_pOccupyButton = new CBitmapButton( this, "OccupyButton", "Occupy" );
+
+	if ( !BaseClass::Init( pKeyValues, pInitData ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CVehicleSiegeTowerControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if ( !pObj )
+		return;
+
+	Assert( dynamic_cast<C_VehicleSiegeTower*>( pObj ) );
+	C_VehicleSiegeTower *pTower = static_cast<C_VehicleSiegeTower*>( pObj );
+
+	char buf[256];
+	// Update the currently manned player label
+	if ( pTower->GetDriverPlayer() )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Driven by %s", pTower->GetDriverPlayer()->GetPlayerName() );
+		m_pDriverLabel->SetText( buf );
+		m_pDriverLabel->SetVisible( true );
+	}
+	else
+	{
+		m_pDriverLabel->SetVisible( false );
+	}
+
+	int nPassengerCount = pTower->GetPassengerCount();
+	int nMaxPassengerCount = pTower->GetMaxPassengerCount();
+
+	Q_snprintf( buf, sizeof( buf ), "Passengers %d/%d", nPassengerCount >= 1 ? nPassengerCount - 1 : 0, nMaxPassengerCount - 1 );
+	m_pPassengerLabel->SetText( buf );
+
+	// Update the get in button
+	if ( pTower->IsPlayerInVehicle( C_BaseTFPlayer::GetLocalPlayer() ) ) 
+	{
+		m_pOccupyButton->SetEnabled( false );
+		return;
+	}
+
+	if ( pTower->GetOwner() == C_BaseTFPlayer::GetLocalPlayer() )
+	{
+		if ( nPassengerCount == nMaxPassengerCount )
+		{
+			// Owners can boot other players to get in
+			C_BaseTFPlayer *pPlayer = static_cast<C_BaseTFPlayer*>( pTower->GetPassenger( VEHICLE_ROLE_DRIVER ) );
+			Q_snprintf( buf, sizeof( buf ), "Get In (Ejecting %s)", pPlayer->GetPlayerName() );
+			m_pDriverLabel->SetText( buf );
+			m_pOccupyButton->SetEnabled( true );
+		}
+		else
+		{
+			m_pOccupyButton->SetText( "Get In" );
+			m_pOccupyButton->SetEnabled( true );
+		}
+	}
+	else
+	{
+		m_pOccupyButton->SetText( "Get In" );
+		m_pOccupyButton->SetEnabled( pTower->GetPassengerCount() < pTower->GetMaxPassengerCount() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Occupy button
+//-----------------------------------------------------------------------------
+void CVehicleSiegeTowerControlPanel::GetInTower( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if ( pObj )
+	{
+		pObj->SendClientCommand( "toggle_use" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CVehicleSiegeTowerControlPanel::OnCommand( const char *command )
+{
+	if ( !Q_strnicmp( command, "Occupy", 7 ) )
+	{
+		GetInTower();
+		return;
+	}
+
+	BaseClass::OnCommand( command );
+}
+
+//=============================================================================
+//
+// Siege Ladder
+//
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectSiegeLadder : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_ObjectSiegeLadder, C_BaseAnimating );
+
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectSiegeLadder();
+
+private:
+	C_ObjectSiegeLadder( const C_ObjectSiegeLadder& ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjectSiegeLadder, DT_ObjectSiegeLadder, CObjectSiegeLadder )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_ObjectSiegeLadder::C_ObjectSiegeLadder()
+{
+}
+
+
+//=============================================================================
+//
+// Siege Platform
+//
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_ObjectSiegePlatform : public C_BaseAnimating
+{
+	DECLARE_CLASS( C_ObjectSiegePlatform, C_BaseAnimating );
+
+public:
+
+	DECLARE_CLIENTCLASS();
+
+	C_ObjectSiegePlatform();
+
+private:
+	C_ObjectSiegePlatform( const C_ObjectSiegePlatform& ); // not defined, not accessible
+};
+
+IMPLEMENT_CLIENTCLASS_DT( C_ObjectSiegePlatform, DT_ObjectSiegePlatform, CObjectSiegePlatform )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+C_ObjectSiegePlatform::C_ObjectSiegePlatform()
+{
+}
+
diff --git a/game/client/tf2/c_vehicle_tank.cpp b/game/client/tf2/c_vehicle_tank.cpp
new file mode 100644
index 0000000..be29039
--- /dev/null
+++ b/game/client/tf2/c_vehicle_tank.cpp
@@ -0,0 +1,150 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_basefourwheelvehicle.h"
+#include "tf_movedata.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+#include "vgui_rotation_slider.h"
+#include <vgui/ISurface.h>
+#include "vgui_basepanel.h"
+#include "ground_line.h"
+#include "hud_minimap.h"
+#include "vgui_bitmapimage.h"
+#include "view.h"
+#include "c_basetempentity.h"
+#include "particles_simple.h"
+#include "in_buttons.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_VehicleTank : public C_BaseTFFourWheelVehicle
+{
+	DECLARE_CLASS( C_VehicleTank, C_BaseTFFourWheelVehicle );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_VehicleTank();
+
+
+	virtual void ClientThink();
+
+	virtual void OnItemPostFrame( CBaseTFPlayer *pDriver );
+
+// C_BaseEntity overrides.
+public:
+	virtual void GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS]);
+
+private:
+	C_VehicleTank( const C_VehicleTank & );		// not defined, not accessible
+
+	float m_flClientYaw;
+	float m_flClientPitch;
+
+	// Sent by the server. This is what we render with.
+	float m_flTurretYaw;
+	float m_flTurretPitch;
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_VehicleTank, DT_VehicleTank, CVehicleTank )
+	RecvPropFloat( RECVINFO( m_flTurretYaw ) ),
+	RecvPropFloat( RECVINFO( m_flTurretPitch ) )
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+C_VehicleTank::C_VehicleTank()
+{
+	m_flClientYaw = 0;
+	m_flClientPitch = 0;
+	m_flTurretYaw = 0;
+	m_flTurretPitch = 0;
+}
+
+
+void C_VehicleTank::ClientThink()
+{
+	if ( GetPassenger( VEHICLE_ROLE_DRIVER ) == C_BasePlayer::GetLocalPlayer() )
+	{
+		// Cast a ray out of the view to see where the player is looking.
+		trace_t trace;
+		UTIL_TraceLine( 
+			MainViewOrigin(), 
+			MainViewOrigin() + MainViewForward() * 100000,
+			MASK_OPAQUE, NULL,
+			COLLISION_GROUP_NONE,
+			&trace );
+
+		if ( trace.fraction < 1 )
+		{
+			// Figure out what angles our turret needs to be at in order to hit the target.
+
+			Vector vFireOrigin;
+			QAngle dummy;
+			GetAttachment( LookupAttachment( "barrel" ), vFireOrigin, dummy );
+
+			// Get a direction vector that points at the target.
+			Vector vTo = trace.endpos - vFireOrigin;
+
+			// Transform it into the tank's local space.
+			matrix3x4_t tankToWorld;
+			AngleMatrix( GetAbsAngles(), tankToWorld );
+			
+			Vector vLocalTo;
+			VectorITransform( vTo, tankToWorld, vLocalTo );
+
+			// Now figure out what the angles are in local space.
+			QAngle localAngles;
+			VectorAngles( vLocalTo, localAngles );
+
+			// Make the angles adhere to the definition in CVehicleTank's header.
+			m_flClientYaw = localAngles[YAW] - 90;
+			m_flClientPitch = anglemod( -localAngles[PITCH] );
+
+
+			char cmd[512];
+			Q_snprintf( cmd, sizeof( cmd ), "TurretAngles %.2f %.2f", m_flClientYaw, m_flClientPitch );
+			SendClientCommand( cmd );
+		}
+	}
+
+	BaseClass::ClientThink();
+}
+
+
+void C_VehicleTank::GetBoneControllers( float controllers[MAXSTUDIOBONECTRLS])
+{
+	BaseClass::GetBoneControllers( controllers );
+
+	controllers[0] = anglemod( m_flTurretYaw ) / 360.0;
+	controllers[1] = anglemod( m_flTurretPitch ) / 360.0;
+}
+
+//-----------------------------------------------------------------------------
+// Here's where we deal with weapons
+//-----------------------------------------------------------------------------
+void C_VehicleTank::OnItemPostFrame( CBaseTFPlayer *pDriver )
+{
+	if ( GetPassengerRole(pDriver) != VEHICLE_ROLE_DRIVER )
+		return;
+
+	if ( pDriver->m_nButtons & IN_ATTACK )
+	{
+	}
+	else if ( pDriver->m_nButtons & (IN_ATTACK2 | IN_SPEED) )
+	{
+		BaseClass::OnItemPostFrame( pDriver );
+	}
+}
+
diff --git a/game/client/tf2/c_vehicle_tank.h b/game/client/tf2/c_vehicle_tank.h
new file mode 100644
index 0000000..7033962
--- /dev/null
+++ b/game/client/tf2/c_vehicle_tank.h
@@ -0,0 +1,14 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_VEHICLE_TANK_H
+#define C_VEHICLE_TANK_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#endif // C_VEHICLE_TANK_H
diff --git a/game/client/tf2/c_vehicle_teleport_station.cpp b/game/client/tf2/c_vehicle_teleport_station.cpp
new file mode 100644
index 0000000..c2cf88a
--- /dev/null
+++ b/game/client/tf2/c_vehicle_teleport_station.cpp
@@ -0,0 +1,168 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_basefourwheelvehicle.h"
+#include "tf_movedata.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+#include "c_vehicle_teleport_station.h"
+
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_VehicleTeleportStation, DT_VehicleTeleportStation, CVehicleTeleportStation)
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_VehicleTeleportStation::C_VehicleTeleportStation()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CVehicleTeleportStationControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CVehicleTeleportStationControlPanel, CObjectControlPanel );
+
+public:
+	CVehicleTeleportStationControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+private:
+	void GetInVehicle( void );
+
+private:
+	vgui::Label		*m_pDriverLabel;
+	vgui::Label		*m_pPassengerLabel;
+	vgui::Button	*m_pOccupyButton;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CVehicleTeleportStationControlPanel, "vehicle_teleport_station_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CVehicleTeleportStationControlPanel::CVehicleTeleportStationControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CVehicleTeleportStationControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CVehicleTeleportStationControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pDriverLabel = new vgui::Label( this, "DriverReadout", "" );
+	m_pPassengerLabel = new vgui::Label( this, "PassengerReadout", "" );
+	m_pOccupyButton = new vgui::Button( this, "OccupyButton", "Occupy" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CVehicleTeleportStationControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_VehicleTeleportStation*>(pObj) );
+	C_VehicleTeleportStation *pVehicle = static_cast<C_VehicleTeleportStation*>(pObj);
+
+	char buf[256];
+	// Update the currently manned player label
+	if ( pVehicle->GetDriverPlayer() )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Driven by %s", pVehicle->GetDriverPlayer()->GetPlayerName() );
+		m_pDriverLabel->SetText( buf );
+		m_pDriverLabel->SetVisible( true );
+	}
+	else
+	{
+		m_pDriverLabel->SetVisible( false );
+	}
+
+	int nPassengerCount = pVehicle->GetPassengerCount();
+	int nMaxPassengerCount = pVehicle->GetMaxPassengerCount();
+
+	Q_snprintf( buf, sizeof( buf ), "Passengers %d/%d", nPassengerCount >= 1 ? nPassengerCount - 1 : 0, nMaxPassengerCount - 1 );
+	m_pPassengerLabel->SetText( buf );
+
+	// Update the get in button
+	if ( pVehicle->IsPlayerInVehicle( C_BaseTFPlayer::GetLocalPlayer() ) ) 
+	{
+		m_pOccupyButton->SetEnabled( false );
+		return;
+	}
+
+	if ( pVehicle->GetOwner() == C_BaseTFPlayer::GetLocalPlayer() )
+	{
+		if (nPassengerCount == nMaxPassengerCount)
+		{
+			// Owners can boot other players to get in
+			C_BaseTFPlayer *pPlayer = static_cast<C_BaseTFPlayer*>(pVehicle->GetPassenger( VEHICLE_ROLE_DRIVER ));
+			Q_snprintf( buf, sizeof( buf ), "Get In (Ejecting %s)", pPlayer->GetPlayerName() );
+			m_pDriverLabel->SetText( buf );
+			m_pOccupyButton->SetEnabled( true );
+		}
+		else
+		{
+			m_pOccupyButton->SetText( "Get In" );
+			m_pOccupyButton->SetEnabled( true );
+		}
+	}
+	else
+	{
+		m_pOccupyButton->SetText( "Get In" );
+		m_pOccupyButton->SetEnabled( pVehicle->GetPassengerCount() < pVehicle->GetMaxPassengerCount() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Occupy button
+//-----------------------------------------------------------------------------
+void CVehicleTeleportStationControlPanel::GetInVehicle( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "toggle_use" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CVehicleTeleportStationControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Occupy", 7))
+	{
+		GetInVehicle();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_vehicle_teleport_station.h b/game/client/tf2/c_vehicle_teleport_station.h
new file mode 100644
index 0000000..4796660
--- /dev/null
+++ b/game/client/tf2/c_vehicle_teleport_station.h
@@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_VEHICLE_TELEPORT_STATION_H
+#define C_VEHICLE_TELEPORT_STATION_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_basefourwheelvehicle.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_VehicleTeleportStation : public C_BaseTFFourWheelVehicle
+{
+	DECLARE_CLASS( C_VehicleTeleportStation, C_BaseTFFourWheelVehicle );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_VehicleTeleportStation();
+
+private:
+	C_VehicleTeleportStation( const C_VehicleTeleportStation & );		// not defined, not accessible
+};
+
+
+#endif // C_VEHICLE_TELEPORT_STATION_H
diff --git a/game/client/tf2/c_vehicle_wagon.cpp b/game/client/tf2/c_vehicle_wagon.cpp
new file mode 100644
index 0000000..475e9f3
--- /dev/null
+++ b/game/client/tf2/c_vehicle_wagon.cpp
@@ -0,0 +1,183 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "c_basefourwheelvehicle.h"
+#include "tf_movedata.h"
+#include "ObjectControlPanel.h"
+#include <vgui_controls/Label.h>
+#include <vgui_controls/Button.h>
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_VehicleWagon : public C_BaseTFFourWheelVehicle
+{
+	DECLARE_CLASS( C_VehicleWagon, C_BaseTFFourWheelVehicle );
+public:
+	DECLARE_CLIENTCLASS();
+
+	C_VehicleWagon();
+
+private:
+	C_VehicleWagon( const C_VehicleWagon & );		// not defined, not accessible
+
+};
+
+
+IMPLEMENT_CLIENTCLASS_DT(C_VehicleWagon, DT_VehicleWagon, CVehicleWagon)
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_VehicleWagon::C_VehicleWagon()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CVehicleWagonControlPanel : public CObjectControlPanel
+{
+	DECLARE_CLASS( CVehicleWagonControlPanel, CObjectControlPanel );
+
+public:
+	CVehicleWagonControlPanel( vgui::Panel *parent, const char *panelName );
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+	virtual void OnCommand( const char *command );
+
+private:
+	void GetInRam( void );
+
+private:
+	vgui::Label		*m_pDriverLabel;
+	vgui::Label		*m_pPassengerLabel;
+	vgui::Button	*m_pOccupyButton;
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CVehicleWagonControlPanel, "vehicle_wagon_control_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CVehicleWagonControlPanel::CVehicleWagonControlPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CVehicleBatteringRamControlPanel" ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CVehicleWagonControlPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+	m_pDriverLabel = new vgui::Label( this, "DriverReadout", "" );
+	m_pPassengerLabel = new vgui::Label( this, "PassengerReadout", "" );
+	m_pOccupyButton = new vgui::Button( this, "OccupyButton", "Occupy" );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CVehicleWagonControlPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	C_BaseObject *pObj = GetOwningObject();
+	if (!pObj)
+		return;
+
+	Assert( dynamic_cast<C_VehicleWagon*>(pObj) );
+	C_VehicleWagon *pWagon = static_cast<C_VehicleWagon*>(pObj);
+
+	char buf[256];
+	// Update the currently manned player label
+	if ( pWagon->GetDriverPlayer() )
+	{
+		Q_snprintf( buf, sizeof( buf ), "Driven by %s", pWagon->GetDriverPlayer()->GetPlayerName() );
+		m_pDriverLabel->SetText( buf );
+		m_pDriverLabel->SetVisible( true );
+	}
+	else
+	{
+		m_pDriverLabel->SetVisible( false );
+	}
+
+	int nPassengerCount = pWagon->GetPassengerCount();
+	int nMaxPassengerCount = pWagon->GetMaxPassengerCount();
+
+	Q_snprintf( buf, sizeof( buf ), "Passengers %d/%d", nPassengerCount >= 1 ? nPassengerCount - 1 : 0, nMaxPassengerCount - 1 );
+	m_pPassengerLabel->SetText( buf );
+
+	// Update the get in button
+	if ( pWagon->IsPlayerInVehicle( C_BaseTFPlayer::GetLocalPlayer() ) ) 
+	{
+		m_pOccupyButton->SetEnabled( false );
+		return;
+	}
+
+	if ( pWagon->GetOwner() == C_BaseTFPlayer::GetLocalPlayer() )
+	{
+		if (nPassengerCount == nMaxPassengerCount)
+		{
+			// Owners can boot other players to get in
+			C_BaseTFPlayer *pPlayer = static_cast<C_BaseTFPlayer*>(pWagon->GetPassenger( VEHICLE_ROLE_DRIVER ));
+			Q_snprintf( buf, sizeof( buf ), "Get In (Ejecting %s)", pPlayer->GetPlayerName() );
+			m_pDriverLabel->SetText( buf );
+			m_pOccupyButton->SetEnabled( true );
+		}
+		else
+		{
+			m_pOccupyButton->SetText( "Get In" );
+			m_pOccupyButton->SetEnabled( true );
+		}
+	}
+	else
+	{
+		m_pOccupyButton->SetText( "Get In" );
+		m_pOccupyButton->SetEnabled( pWagon->GetPassengerCount() < pWagon->GetMaxPassengerCount() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle clicking on the Occupy button
+//-----------------------------------------------------------------------------
+void CVehicleWagonControlPanel::GetInRam( void )
+{
+	C_BaseObject *pObj = GetOwningObject();
+	if (pObj)
+	{
+		pObj->SendClientCommand( "toggle_use" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Button click handlers
+//-----------------------------------------------------------------------------
+void CVehicleWagonControlPanel::OnCommand( const char *command )
+{
+	if (!Q_strnicmp(command, "Occupy", 7))
+	{
+		GetInRam();
+		return;
+	}
+
+	BaseClass::OnCommand(command);
+}
+
diff --git a/game/client/tf2/c_walker_base.cpp b/game/client/tf2/c_walker_base.cpp
new file mode 100644
index 0000000..004e9c6
--- /dev/null
+++ b/game/client/tf2/c_walker_base.cpp
@@ -0,0 +1,20 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_walker_base.h"
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_WalkerBase, DT_WalkerBase, CWalkerBase )
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WalkerBase::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+}
diff --git a/game/client/tf2/c_walker_base.h b/game/client/tf2/c_walker_base.h
new file mode 100644
index 0000000..62205bf
--- /dev/null
+++ b/game/client/tf2/c_walker_base.h
@@ -0,0 +1,33 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_WALKER_BASE_H
+#define C_WALKER_BASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "basetfvehicle.h"
+#include "client_class.h"
+
+
+class C_WalkerBase : public C_BaseTFVehicle
+{
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_CLASS( C_WalkerBase, C_BaseTFVehicle );
+
+	C_WalkerBase() {}
+
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+
+private:
+	C_WalkerBase( const C_WalkerBase &other ) {}
+};
+
+
+#endif // C_WALKER_BASE_H
diff --git a/game/client/tf2/c_walker_ministrider.cpp b/game/client/tf2/c_walker_ministrider.cpp
new file mode 100644
index 0000000..5608c1c
--- /dev/null
+++ b/game/client/tf2/c_walker_ministrider.cpp
@@ -0,0 +1,38 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_walker_ministrider.h"
+#include "beamdraw.h"
+#include "view.h"
+
+
+extern ConVar vehicle_free_pitch, vehicle_free_roll;
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_WalkerMiniStrider, DT_WalkerMiniStrider, CWalkerMiniStrider )
+END_RECV_TABLE()
+
+
+C_WalkerMiniStrider::C_WalkerMiniStrider()
+{
+}
+
+
+C_WalkerMiniStrider::~C_WalkerMiniStrider()
+{
+}
+
+
+void C_WalkerMiniStrider::ClientThink()
+{
+}
+
+
+void C_WalkerMiniStrider::SetupMove( CBasePlayer *pPlayer, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
+{
+}
+
diff --git a/game/client/tf2/c_walker_ministrider.h b/game/client/tf2/c_walker_ministrider.h
new file mode 100644
index 0000000..9ff51d8
--- /dev/null
+++ b/game/client/tf2/c_walker_ministrider.h
@@ -0,0 +1,63 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_WALKER_MINISTRIDER_H
+#define C_WALKER_MINISTRIDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_walker_base.h"
+#include "c_rope.h"
+
+
+#define STRIDER_BEAM_LIFETIME	1.0
+#define STRIDER_BEAM_MATERIAL	"sprites/physbeam"
+#define STRIDER_BEAM_WIDTH		25
+#define STRIDER_NUM_ROPES		6
+
+
+class CStriderBeamEffect
+{
+public:
+	Vector m_vHitPos;
+	float m_flStartTime;
+};
+
+
+class C_WalkerMiniStrider : public C_WalkerBase
+{
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_CLASS( C_WalkerMiniStrider, C_WalkerBase );
+
+	C_WalkerMiniStrider();
+	virtual ~C_WalkerMiniStrider();
+
+
+// IClientThinkable.
+public:
+	virtual void ClientThink();
+
+
+// C_BaseEntity.
+public:
+
+	virtual bool ShouldPredict() { return false; }
+	virtual void SetupMove( CBasePlayer *pPlayer, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
+
+
+// C_BaseAnimating.
+public:
+
+
+private:
+	C_WalkerMiniStrider( const C_WalkerMiniStrider &other ) {}
+};
+
+
+#endif // C_WALKER_MINISTRIDER_H
diff --git a/game/client/tf2/c_walker_strider.cpp b/game/client/tf2/c_walker_strider.cpp
new file mode 100644
index 0000000..a723125
--- /dev/null
+++ b/game/client/tf2/c_walker_strider.cpp
@@ -0,0 +1,218 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "c_walker_strider.h"
+#include "beamdraw.h"
+#include "clienteffectprecachesystem.h"
+
+extern ConVar vehicle_free_pitch, vehicle_free_roll;
+
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheWalkerStrider )
+CLIENTEFFECT_MATERIAL( STRIDER_BEAM_MATERIAL )
+CLIENTEFFECT_REGISTER_END()
+
+
+IMPLEMENT_CLIENTCLASS_DT( C_WalkerStrider, DT_WalkerStrider, CWalkerStrider )
+	RecvPropInt( RECVINFO( m_bCrouched ) )
+END_RECV_TABLE()
+LINK_ENTITY_TO_CLASS( walker_strider, C_WalkerStrider );
+
+
+ConVar cl_brush_ropes( "cl_brush_ropes", "0" );
+
+
+C_WalkerStrider::C_WalkerStrider()
+{
+	m_bCrouched = false;
+}
+
+
+C_WalkerStrider::~C_WalkerStrider()
+{
+	for ( int i=0; i < STRIDER_NUM_ROPES; i++ )
+	{
+		if ( m_hRopes[i].Get() )
+			m_hRopes[i]->Release();
+	}
+}
+
+
+float sideDist = 90;
+float downDist = -400;
+#include "studio.h"
+bool C_WalkerStrider::GetAttachment( int iAttachment, matrix3x4_t &attachmentToWorld )
+{
+	//
+	//
+	// This is a TOTAL hack, but we don't have any nodes that work well at all for mounted guns.
+	//
+	//
+	CStudioHdr *pStudioHdr = GetModelPtr( );
+	if ( !pStudioHdr || iAttachment < 1 || iAttachment > pStudioHdr->GetNumAttachments() )
+	{
+		return false;
+	}
+
+	Vector vLocalPos( 0, 0, 0 );
+	const mstudioattachment_t &pAttachment = pStudioHdr->pAttachment( iAttachment-1 );
+	if ( stricmp( pAttachment.pszName(), "build_point_left_gun" ) == 0 )
+	{
+		vLocalPos.y = sideDist;
+	}
+	else if ( stricmp( pAttachment.pszName(), "build_point_right_gun" ) == 0 )
+	{
+		vLocalPos.y = -sideDist;
+	}
+	else if ( stricmp( pAttachment.pszName(), "ThirdPersonCameraOrigin" ) == 0 )
+	{
+	}
+	else
+	{
+		// Ok, it's not one of our magical attachments. Use the regular attachment setup stuff.
+		return BaseClass::GetAttachment( iAttachment, attachmentToWorld );
+	}
+
+	if ( m_bCrouched )
+	{
+		vLocalPos.z += downDist;
+	}
+
+	// Now build the output matrix.
+	matrix3x4_t localMatrix;
+	SetIdentityMatrix( localMatrix );
+	PositionMatrix( vLocalPos, localMatrix );
+
+	ConcatTransforms( EntityToWorldTransform(), localMatrix, attachmentToWorld );
+	return true;
+}
+
+
+void C_WalkerStrider::ReceiveMessage( int classID, bf_read &msg )
+{
+	if ( classID != GetClientClass()->m_ClassID )
+	{
+		// message is for subclass
+		BaseClass::ReceiveMessage( classID, msg );
+		return;
+	}
+
+	Vector vHitPos;
+	msg.ReadBitVec3Coord( vHitPos );
+
+	CStriderBeamEffect eff;
+	eff.m_vHitPos = vHitPos;
+	eff.m_flStartTime = gpGlobals->curtime;
+	m_BeamEffects.AddToTail( eff );
+}
+
+
+float flTestSlack = 280;
+float flTestSlack2 = 380;
+
+void C_WalkerStrider::OnDataChanged( DataUpdateType_t type )
+{
+	BaseClass::OnDataChanged( type );
+
+	if ( type == DATA_UPDATE_CREATED )
+	{
+		if ( cl_brush_ropes.GetInt() )
+		{
+			// Create some ropes and hang them off certain attachments.
+			int indices[7] = 
+			{
+				LookupAttachment( "kneeL" ),
+				LookupAttachment( "kneeR" ),
+				LookupAttachment( "kneeB" ),
+				
+				LookupAttachment( "MiniGun" ),
+				LookupAttachment( "left foot" ),
+				LookupAttachment( "right foot" ),
+				LookupAttachment( "back foot" )
+			};
+			
+			m_hRopes[0] = C_RopeKeyframe::Create( this, this, indices[0], indices[1] );
+			m_hRopes[1] = C_RopeKeyframe::Create( this, this, indices[0], indices[2] );
+			m_hRopes[2] = C_RopeKeyframe::Create( this, this, indices[1], indices[2] );
+
+			for ( int i=0; i < 3; i++ )
+			{
+				if ( m_hRopes[i].Get() )
+					m_hRopes[i]->SetSlack( flTestSlack );
+			}
+
+
+			m_hRopes[3] = C_RopeKeyframe::Create( this, this, indices[3], indices[4] );
+			m_hRopes[4] = C_RopeKeyframe::Create( this, this, indices[3], indices[5] );
+			m_hRopes[5] = C_RopeKeyframe::Create( this, this, indices[3], indices[6] );
+
+			for ( i=3; i < 6; i++ )
+			{
+				if ( m_hRopes[i].Get() )
+					m_hRopes[i]->SetSlack( flTestSlack2 );
+			}
+		}
+	}
+}
+
+
+void C_WalkerStrider::ClientThink()
+{
+	// Retire beam effects.
+	int iNext;
+	for ( int i=m_BeamEffects.Head(); i != m_BeamEffects.InvalidIndex(); i=iNext )
+	{
+		iNext = m_BeamEffects.Next( i );
+	
+		if ( gpGlobals->curtime >= (m_BeamEffects[i].m_flStartTime + STRIDER_BEAM_LIFETIME) )
+		{
+			m_BeamEffects.Remove( i );
+		}
+	}
+}
+
+
+int C_WalkerStrider::DrawModel( int flags )
+{
+	BaseClass::DrawModel( flags );
+
+	IMaterial *pMaterial = materials->FindMaterial( STRIDER_BEAM_MATERIAL, TEXTURE_GROUP_CLIENT_EFFECTS );
+
+	Vector vGunPos;
+	QAngle vAngles;
+	BaseClass::GetAttachment( LookupAttachment( "BigGun" ), vGunPos, vAngles );
+
+	// Draw our beam effects.
+	FOR_EACH_LL( m_BeamEffects, i )
+	{
+		CStriderBeamEffect *pEff = &m_BeamEffects[i];
+
+		float flAlpha = (gpGlobals->curtime - pEff->m_flStartTime) / STRIDER_BEAM_LIFETIME;
+		flAlpha = 1.0 - clamp( flAlpha, 0, 1 );
+
+		CBeamSegDraw segDraw;
+		segDraw.Start( 2, pMaterial );
+
+		CBeamSeg seg;
+		seg.m_vColor.Init( 1, 0, 0 );
+		seg.m_flWidth = STRIDER_BEAM_WIDTH;
+		seg.m_flAlpha = flAlpha;
+
+		seg.m_flTexCoord = 0;
+		seg.m_vPos = vGunPos;
+		segDraw.NextSeg( &seg );
+
+		seg.m_flTexCoord = 1;
+		seg.m_vPos = pEff->m_vHitPos;
+		segDraw.NextSeg( &seg );
+		
+		segDraw.End();
+	}
+
+	return 1;
+}
+
diff --git a/game/client/tf2/c_walker_strider.h b/game/client/tf2/c_walker_strider.h
new file mode 100644
index 0000000..924e4a9
--- /dev/null
+++ b/game/client/tf2/c_walker_strider.h
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef C_WALKER_STRIDER_H
+#define C_WALKER_STRIDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "c_walker_base.h"
+#include "c_rope.h"
+
+
+#define STRIDER_BEAM_LIFETIME	1.0
+#define STRIDER_BEAM_MATERIAL	"sprites/physbeam"
+#define STRIDER_BEAM_WIDTH		25
+#define STRIDER_NUM_ROPES		6
+
+
+class CStriderBeamEffect
+{
+public:
+	Vector m_vHitPos;
+	float m_flStartTime;
+};
+
+
+class C_WalkerStrider : public C_WalkerBase
+{
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_CLASS( C_WalkerStrider, C_WalkerBase );
+
+	C_WalkerStrider();
+	virtual ~C_WalkerStrider();
+
+
+// IClientThinkable.
+public:
+	virtual void ClientThink();
+
+
+// C_BaseEntity.
+public:
+	virtual void ReceiveMessage( int classID, bf_read &msg );
+	virtual void OnDataChanged( DataUpdateType_t type );
+	virtual bool ShouldPredict() { return false; }
+
+
+// C_BaseAnimating.
+public:
+	virtual bool GetAttachment( int iAttachment, matrix3x4_t &attachmentToWorld );
+	virtual int DrawModel( int flags );
+
+
+private:
+	C_WalkerStrider( const C_WalkerStrider &other ) {}
+
+	bool m_bCrouched;
+
+	CUtlLinkedList<CStriderBeamEffect,int> m_BeamEffects;
+
+	CHandle<C_RopeKeyframe> m_hRopes[STRIDER_NUM_ROPES];
+};
+
+
+#endif // C_WALKER_STRIDER_H
diff --git a/game/client/tf2/c_weapon__stubs_tf2.cpp b/game/client/tf2/c_weapon__stubs_tf2.cpp
new file mode 100644
index 0000000..6378813
--- /dev/null
+++ b/game/client/tf2/c_weapon__stubs_tf2.cpp
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "c_tf_basecombatweapon.h"
+#include "c_weapon__stubs.h"
+#include "weapon_basecombatobject.h"
+
+// TODO for 12/22/02
+// weapon_limpetmine
+// weapon_builder:  don't do yet, waiting for Robin to change out UI
+
+
+STUB_WEAPON_CLASS( foo_weapon_machinegun, MachineGun, C_BaseCombatWeapon );
+STUB_WEAPON_CLASS( foo_weapon_select_fire_machinegun, SelectFireMachineGun, C_MachineGun );
+STUB_WEAPON_CLASS( foo_weapon_basebludgeonweapon, BaseBludgeonWeapon, C_BaseCombatWeapon );
+
+STUB_WEAPON_CLASS( cycler_weapon, WeaponCycler, C_BaseCombatWeapon );
+ 
+STUB_WEAPON_CLASS( weapon_assault_rifle, WeaponAssaultRifle, C_TFMachineGun );
+STUB_WEAPON_CLASS( weapon_laserdesignator, WeaponLaserDesignator, C_BaseTFCombatWeapon );
+STUB_WEAPON_CLASS( weapon_laserrifle, WeaponLaserRifle, C_BaseTFCombatWeapon );
+STUB_WEAPON_CLASS( weapon_obj_empgenerator, WeaponObjEMPGenerator, C_WeaponBaseCombatObject );
+STUB_WEAPON_CLASS( weapon_placedcharge, WeaponPlacedCharge, C_BaseTFCombatWeapon );
+STUB_WEAPON_CLASS( weapon_plasmarifle, WeaponPlasmaRifle, C_TFMachineGun );
+STUB_WEAPON_CLASS( weapon_shotgun, WeaponShotgun, C_TFMachineGun );
+STUB_WEAPON_CLASS( weapon_sapper_shotgun, WeaponSapperShotgun, C_WeaponShotgun );
+STUB_WEAPON_CLASS( weapon_cubemap, WeaponCubemap, C_BaseCombatWeapon );
\ No newline at end of file
diff --git a/game/client/tf2/c_weapon_builder.cpp b/game/client/tf2/c_weapon_builder.cpp
new file mode 100644
index 0000000..edb69ab
--- /dev/null
+++ b/game/client/tf2/c_weapon_builder.cpp
@@ -0,0 +1,380 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CWeaponBuilder class
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "in_buttons.h"
+#include "clientmode_tfnormal.h"
+#include "engine/IEngineSound.h"
+#include "c_weapon_builder.h"
+#include "c_weapon__stubs.h"
+#include "iinput.h"
+#include "ObjectControlPanel.h"
+#include <vgui/IVGui.h>
+
+#define BUILD_ICON_SCALE			0.75
+
+#define BUILD_ICON_BOTTOM_OFFSET	YRES(160)
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw a material on a quad
+//-----------------------------------------------------------------------------
+void DrawQuadMaterial( IMaterial *pMaterial, int iX, int iY, int iWidth, int iHeight, 
+	unsigned char r = 255, unsigned char g = 255, unsigned char b = 255, unsigned char a = 255, 
+	float flTextureLeft = 0.0, float flTextureRight = 1.0, bool bRotated = false )
+{
+	IMesh* pMesh = materials->GetDynamicMesh( true, NULL, NULL, pMaterial );
+
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
+
+	meshBuilder.Color4ub( r, g, b, a );
+	if ( bRotated )
+	{
+		meshBuilder.TexCoord2f( 0,flTextureLeft,1 );
+	}
+	else
+	{
+		meshBuilder.TexCoord2f( 0,flTextureLeft,0 );
+	}
+	meshBuilder.Position3f( iX,iY,0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color4ub( r, g, b, a );
+	if ( bRotated )
+	{
+		meshBuilder.TexCoord2f( 0,flTextureLeft,0 );
+	}
+	else
+	{
+		meshBuilder.TexCoord2f( 0,flTextureRight,0 );
+	}
+	meshBuilder.Position3f( iX+iWidth, iY, 0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color4ub( r, g, b, a );
+	if ( bRotated )
+	{
+		meshBuilder.TexCoord2f( 0,flTextureRight,0 );
+	}
+	else
+	{
+		meshBuilder.TexCoord2f( 0,flTextureRight,1 );
+	}
+	meshBuilder.Position3f( iX+iWidth, iY+iHeight, 0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color4ub( r, g, b, a );
+	if ( bRotated )
+	{
+		meshBuilder.TexCoord2f( 0,flTextureRight,1 );
+	}
+	else
+	{
+		meshBuilder.TexCoord2f( 0,flTextureLeft,1 );
+	}
+	meshBuilder.Position3f( iX, iY+iHeight, 0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.End();
+	pMesh->Draw();
+}
+
+STUB_WEAPON_CLASS_IMPLEMENT( weapon_builder, C_WeaponBuilder );
+
+IMPLEMENT_CLIENTCLASS_DT(C_WeaponBuilder, DT_WeaponBuilder, CWeaponBuilder)
+	RecvPropInt( RECVINFO(m_iBuildState) ),
+	RecvPropInt( RECVINFO(m_iCurrentObject) ),
+	RecvPropInt( RECVINFO(m_iCurrentObjectState) ),
+	RecvPropEHandle( RECVINFO(m_hObjectBeingBuilt) ),
+	RecvPropTime( RECVINFO(m_flStartTime) ),
+	RecvPropTime( RECVINFO(m_flTotalTime) ),
+	RecvPropArray
+	( 
+		RecvPropInt( RECVINFO(m_bObjectValidity[0])), m_bObjectValidity
+	),
+	RecvPropArray
+	( 
+		RecvPropInt( RECVINFO(m_bObjectBuildability[0])), m_bObjectBuildability
+	),
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_WeaponBuilder::C_WeaponBuilder()
+{
+	m_iBuildState = 0;
+	m_iCurrentObject = BUILDER_INVALID_OBJECT;
+	m_iCurrentObjectState = 0;
+	m_flStartTime = 0;
+	m_flTotalTime = 0;
+
+	m_pIconFireToSelect.Init( "Hud/build/firetobuild", TEXTURE_GROUP_VGUI );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_WeaponBuilder::~C_WeaponBuilder()
+{
+}
+
+//-----------------------------------------------------------------------------
+// A couple helper methods for drawing builder status 
+//-----------------------------------------------------------------------------
+static void DrawTextIcon( IMaterial* pMaterial, int parentWidth, int parentHeight, float r = 1.0f, float g = 1.0f, float b = 1.0f )
+{
+	if ( !pMaterial )
+		return;
+
+	// We're in build selection mode, so draw the current build icon
+	int iWidth = pMaterial->GetMappingWidth();
+	int iHeight = pMaterial->GetMappingHeight();
+	int iX = (parentWidth - iWidth) / 2;
+	int iY = (parentHeight - 216);
+	DrawQuadMaterial( pMaterial, iX, iY, iWidth, iHeight, r * 255, g * 255, b * 255 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *C_WeaponBuilder::GetCurrentSelectionObjectName( void )
+{
+	if ( m_iCurrentObject == -1 || (m_iBuildState == BS_SELECTING) )
+		return "";
+
+	return GetObjectInfo( m_iCurrentObject )->m_pBuilderWeaponName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponBuilder::Redraw()
+{
+	BaseClass::Redraw();
+
+	// Don't draw if we're hiding the weapons, or the player's dead
+	if ( gHUD.IsHidden( HIDEHUD_WEAPONSELECTION | HIDEHUD_PLAYERDEAD ) )
+		return;
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if (!pPlayer)
+		return;
+
+	vgui::Panel *pParent = GetClientModeNormal()->GetViewport();
+	int parentWidth, parentHeight;
+	pParent->GetSize(parentWidth, parentHeight);
+
+	// If we're in placement mode, draw the placement icon
+	switch( m_iBuildState )
+	{
+	case BS_PLACING:
+	case BS_PLACING_INVALID:
+		break;
+
+	default:
+		{
+			if( !inv_demo.GetInt() )
+			{
+				DrawTextIcon( m_pIconFireToSelect, parentWidth, parentHeight );
+			}
+			break;
+		}
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_WeaponBuilder::IsPlacingObject( void )
+{
+	if ( m_iBuildState == BS_PLACING || m_iBuildState == BS_PLACING_INVALID )
+		return true;
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_WeaponBuilder::IsBuildingObject( void )
+{
+	if ( m_iBuildState == BS_BUILDING )
+		return true;
+	return false;
+}
+
+#include "vgui_bitmapimage.h"
+#include "vgui_bitmappanel.h"
+
+
+//-----------------------------------------------------------------------------
+// Control screen 
+//-----------------------------------------------------------------------------
+class CHumanPDAPanel : public CVGuiScreenPanel
+{
+	DECLARE_CLASS( CHumanPDAPanel, CVGuiScreenPanel );
+
+public:
+	CHumanPDAPanel( vgui::Panel *parent, const char *panelName );
+	~CHumanPDAPanel();
+	virtual bool Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData );
+	virtual void OnTick();
+
+private:
+	C_BaseCombatWeapon *GetOwningWeapon();
+
+	vgui::Label *m_pObjectName;
+	vgui::Label *m_pObjectCost;
+	vgui::Label *m_pObjectOnTeamCount;
+	vgui::Label *m_pObjectPlacementDetails;
+
+	CBitmapPanel *m_pBitmapPanel;
+
+	BitmapImage *m_pObjectImage;
+
+	int				m_nLastObjectID;
+	int				m_nLastObjectCount;
+	int				m_nLastObjectCost;
+
+};
+
+
+DECLARE_VGUI_SCREEN_FACTORY( CHumanPDAPanel, "human_pda" );
+
+
+//-----------------------------------------------------------------------------
+// Constructor: 
+//-----------------------------------------------------------------------------
+CHumanPDAPanel::CHumanPDAPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, "CHumanPDAPanel", vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/PDAControlPanelScheme.res", "TFBase" ) ) 
+{
+	m_pObjectImage = NULL;
+
+	m_pObjectName = new vgui::Label( this, "ObjectName", "" );
+	m_pObjectCost = new vgui::Label( this, "ObjectCost", "" );
+	m_pObjectOnTeamCount = new vgui::Label( this, "ObjectOnTeamCount", "" );
+	m_pObjectPlacementDetails = new vgui::Label( this, "ObjectPlacementDetails", "" );
+
+	m_pBitmapPanel = new CBitmapPanel( this, "ObjectImage" );
+	m_pObjectImage = new BitmapImage();
+	m_pObjectImage->UsePanelRenderSize( m_pBitmapPanel->GetVPanel() );
+	m_pBitmapPanel->SetImage( m_pObjectImage );
+
+	m_nLastObjectID = -1;
+	m_nLastObjectCount = -1;
+	m_nLastObjectCost = -1;
+}
+
+CHumanPDAPanel::~CHumanPDAPanel()
+{
+	if ( m_pObjectImage )
+	{
+		delete m_pObjectImage;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CHumanPDAPanel::Init( KeyValues* pKeyValues, VGuiScreenInitData_t* pInitData )
+{
+
+	// Make sure we get ticked...
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Returns the object it's attached to 
+//-----------------------------------------------------------------------------
+C_BaseCombatWeapon *CHumanPDAPanel::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();
+}
+
+//-----------------------------------------------------------------------------
+// Frame-based update
+//-----------------------------------------------------------------------------
+void CHumanPDAPanel::OnTick()
+{
+	BaseClass::OnTick();
+
+	SetVisible( true );
+
+	char buf[256];
+
+	C_BaseCombatWeapon *weapon = GetOwningWeapon();
+	if ( !weapon )
+		return;
+
+	C_WeaponBuilder *builder = dynamic_cast< C_WeaponBuilder * >( weapon );
+	if ( !builder )
+		return;
+
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( builder->GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// FIXME: Check build state??
+
+	int objectType = builder->m_iCurrentObject;
+	CObjectInfo const *info = GetObjectInfo( objectType );
+	if ( !info )
+		return;
+
+	int numOwned = pOwner->GetNumObjects(objectType);
+	int iCost = CalculateObjectCost( objectType, numOwned, pOwner->GetTeamNumber() );
+
+	if ( m_nLastObjectID == objectType &&
+		m_nLastObjectCount == numOwned &&
+		m_nLastObjectCost == iCost)
+		return;
+
+	m_nLastObjectID = objectType;
+	m_nLastObjectCount = numOwned;
+	m_nLastObjectCost = iCost;
+
+	Q_snprintf( buf, sizeof( buf ), "hud/menu/%s", info->m_pClassName );
+	m_pObjectImage->SetImageFile( buf );
+	m_pObjectImage->SetColor( GetFgColor() );
+	
+	Q_snprintf( buf, sizeof( buf ), "%s", info->m_pStatusName );
+	m_pObjectName->SetText( buf );
+
+	Q_snprintf( buf, sizeof( buf ), "Cost:  %i", iCost );
+	m_pObjectCost->SetText( buf );
+
+	Q_snprintf( buf, sizeof( buf ), "You own:  %i", numOwned );
+	m_pObjectOnTeamCount->SetText( buf );
+
+	Q_snprintf( buf, sizeof( buf ), "%s", info->m_pBuilderPlacementString ? info->m_pBuilderPlacementString : "" );
+	m_pObjectPlacementDetails->SetText( buf );
+	//m_pObjectPlacementDetails->SizeToContents();
+}
diff --git a/game/client/tf2/c_weapon_builder.h b/game/client/tf2/c_weapon_builder.h
new file mode 100644
index 0000000..127e2b2
--- /dev/null
+++ b/game/client/tf2/c_weapon_builder.h
@@ -0,0 +1,63 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef C_WEAPON_BUILDER_H
+#define C_WEAPON_BUILDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "c_tf_basecombatweapon.h"
+#include "weapon_combat_usedwithshieldbase.h"
+
+//=============================================================================
+// Purpose: Client version of CWeaponBuiler
+//=============================================================================
+class C_WeaponBuilder : public C_WeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( C_WeaponBuilder, C_WeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_PREDICTABLE();
+
+	C_WeaponBuilder();
+	~C_WeaponBuilder();
+
+	virtual void Redraw();
+	virtual bool VisibleInWeaponSelection( void ) { return false; }
+
+	virtual bool	IsPlacingObject( void );
+	virtual bool	IsBuildingObject( void );
+
+	virtual const char *GetCurrentSelectionObjectName( void );
+
+	C_BaseObject	*GetPlacementModel( void ) { return m_hObjectBeingBuilt.Get(); }
+
+public:
+	// Builder Data
+	int			m_iBuildState;
+	unsigned int m_iCurrentObject;
+	int			m_iCurrentObjectState;
+	float		m_flStartTime;
+	float		m_flTotalTime;
+	vgui::HFont m_hFont;
+
+	// Our placement model
+	CHandle<C_BaseObject>	m_hObjectBeingBuilt;
+
+	// Objects that this builder can build
+	bool		m_bObjectValidity[ OBJ_LAST ];
+	// Buildability of each object
+	bool		m_bObjectBuildability[ OBJ_LAST ];
+
+	// Materials
+	CMaterialReference	m_pIconFireToSelect;
+
+private:
+	C_WeaponBuilder( const C_WeaponBuilder & );
+};
+#endif // C_WEAPON_BUILDER_H
diff --git a/game/client/tf2/c_weapon_chargeableplasma.cpp b/game/client/tf2/c_weapon_chargeableplasma.cpp
new file mode 100644
index 0000000..22e2471
--- /dev/null
+++ b/game/client/tf2/c_weapon_chargeableplasma.cpp
@@ -0,0 +1,358 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "iefx.h"
+#include "dlight.h"
+#include "engine/IEngineSound.h"
+#include "view.h"
+#include "beamdraw.h"
+#include "clienteffectprecachesystem.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "c_weapon__stubs.h"
+#include <vgui/ISurface.h>
+
+#define BALL_GROW_TIME	1.5
+
+// Precache the effects
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheWeaponCombat_ChargeablePlasma )
+CLIENTEFFECT_MATERIAL( "sprites/chargeball_team1" )
+CLIENTEFFECT_MATERIAL( "sprites/chargeball_team2" )
+CLIENTEFFECT_REGISTER_END()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_WeaponCombat_ChargeablePlasma : public C_WeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( C_WeaponCombat_ChargeablePlasma, C_WeaponCombatUsedWithShieldBase );
+
+public:
+	DECLARE_CLIENTCLASS();
+	DECLARE_PREDICTABLE();
+
+	C_WeaponCombat_ChargeablePlasma( void );
+	~C_WeaponCombat_ChargeablePlasma( void );
+
+	virtual void	PreDataUpdate( DataUpdateType_t updateType );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	virtual void	DrawCrosshair( void );
+	virtual void	ClientThink( );
+ 	virtual int		DrawModel( int flags );
+	virtual void	ViewModelDrawn( C_BaseViewModel *pBaseViewModel );
+	virtual void	NotifyShouldTransmit( ShouldTransmitState_t state );
+	virtual	bool	IsTransparent( );
+
+private:
+	void			StartCharging();
+	void			StopCharging();
+	void			DrawChargingEffect( float flSize, C_BaseAnimating *pAttachedEnt );
+
+private:
+	bool			m_bCharging;
+	bool			m_bLastCharging;
+	float			m_flPower;
+	float			m_flChargeStartTime;
+	CMaterialReference m_hMaterial;
+
+private:
+	C_WeaponCombat_ChargeablePlasma( const C_WeaponCombat_ChargeablePlasma & );
+};
+
+STUB_WEAPON_CLASS_IMPLEMENT( weapon_combat_chargeableplasma, C_WeaponCombat_ChargeablePlasma );
+
+IMPLEMENT_CLIENTCLASS_DT( C_WeaponCombat_ChargeablePlasma, DT_WeaponCombat_ChargeablePlasma, CWeaponCombat_ChargeablePlasma )
+	RecvPropInt( RECVINFO(m_bCharging) ),
+END_RECV_TABLE()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_WeaponCombat_ChargeablePlasma::C_WeaponCombat_ChargeablePlasma( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_WeaponCombat_ChargeablePlasma::~C_WeaponCombat_ChargeablePlasma( void )
+{
+	Holster( NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponCombat_ChargeablePlasma::PreDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PreDataUpdate( updateType );
+
+	m_bLastCharging = m_bCharging;
+}
+
+
+void C_WeaponCombat_ChargeablePlasma::NotifyShouldTransmit( ShouldTransmitState_t state )
+{
+	BaseClass::NotifyShouldTransmit(state);
+
+	if (state == SHOULDTRANSMIT_START)
+	{
+		if (m_bCharging)
+			StartCharging();
+	}
+	else if (state == SHOULDTRANSMIT_END)
+	{
+		if (m_bCharging)
+			StopCharging();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponCombat_ChargeablePlasma::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	switch( updateType )
+	{
+	case DATA_UPDATE_CREATED:
+		// So we can update our lights
+		if ( GetTeamNumber() == 1 )
+			m_hMaterial.Init( "sprites/chargeball_team1" );
+		else 
+			m_hMaterial.Init( "sprites/chargeball_team2" );
+
+		break;								
+
+	case DATA_UPDATE_DATATABLE_CHANGED:
+		if ( m_bCharging != m_bLastCharging )
+		{
+			if ( m_bCharging )
+			{
+				StartCharging();
+			}
+			else
+			{
+				StopCharging();
+			}
+		}
+		break;
+	};
+
+	if (WeaponState() == WEAPON_IS_ACTIVE)
+	{
+		// Start thinking so we can manipulate the light
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+	else
+	{
+		SetNextClientThink( CLIENT_THINK_NEVER );
+	}
+}
+
+  
+//-----------------------------------------------------------------------------
+// Deal with dynamic lighting
+//-----------------------------------------------------------------------------
+void C_WeaponCombat_ChargeablePlasma::ClientThink( )
+{
+	BaseClass::ClientThink();
+
+	C_BaseTFPlayer *pPlayer = (C_BaseTFPlayer *)GetOwner();
+	if ( !pPlayer || (pPlayer->GetHealth() <= 0))
+	{
+		SetNextClientThink( CLIENT_THINK_NEVER );
+		return;
+	}
+
+	if (!m_bCharging)
+		return;
+
+	// Determine the ball size...
+	m_flPower = (gpGlobals->curtime - m_flChargeStartTime) / BALL_GROW_TIME;
+	m_flPower = clamp( m_flPower, 0, 1 );
+
+	// FIXME: dl->origin should be based on the attachment point
+	dlight_t *dl = effects->CL_AllocDlight( entindex() );
+	dl->origin = GetRenderOrigin();
+
+	if (GetTeamNumber() == 1)
+	{
+		dl->color.r = 40;
+		dl->color.g = 60;
+		dl->color.b = 250;
+	}
+	else
+	{
+		dl->color.r = 250;
+		dl->color.g = 60;
+		dl->color.b = 40;
+	}
+
+	dl->color.exponent = 5;
+	dl->radius = 20 * m_flPower + 10;
+	dl->die = gpGlobals->curtime + 0.01;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove the ball if we're switching away
+//-----------------------------------------------------------------------------
+bool C_WeaponCombat_ChargeablePlasma::Holster( C_BaseCombatWeapon *pSwitchingTo )
+{
+	StopCharging();
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+void C_WeaponCombat_ChargeablePlasma::StartCharging()
+{
+	CLocalPlayerFilter filter;
+	EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "WeaponCombat_ChargeablePlasma.Charging" );
+	m_flChargeStartTime = gpGlobals->curtime;
+}
+
+
+void C_WeaponCombat_ChargeablePlasma::StopCharging()
+{
+	StopSound( SOUND_FROM_LOCAL_PLAYER, "WeaponCombat_ChargeablePlasma.Charging" );
+	m_bCharging = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// We're transparent because we draw a transparent charging effect
+//-----------------------------------------------------------------------------
+bool C_WeaponCombat_ChargeablePlasma::IsTransparent( )
+{
+	if (m_bCharging)
+		return true;
+	return BaseClass::IsTransparent();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the charging effect
+//-----------------------------------------------------------------------------
+void C_WeaponCombat_ChargeablePlasma::DrawChargingEffect( float flSize, C_BaseAnimating *pAttachedEnt )
+{
+	if (!pAttachedEnt)
+		return;
+
+	Vector vecOrigin;
+	QAngle vecAngles;
+	int iAttachment = pAttachedEnt->LookupAttachment( "muzzle" );
+	if ( pAttachedEnt->GetAttachment( iAttachment, vecOrigin, vecAngles ) )
+	{
+		color32 color = { 255, 255, 255, 255 };
+		materials->Bind( m_hMaterial, (IClientRenderable*)this );
+		DrawSprite( vecOrigin, flSize, flSize, color );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the model
+//-----------------------------------------------------------------------------
+int C_WeaponCombat_ChargeablePlasma::DrawModel( int flags )
+{
+	int retval = BaseClass::DrawModel( flags );
+	if (retval == 0)
+		return 0;
+
+	if (m_bCharging && IsCarrierAlive())
+	{
+		// Draw the charging effect
+		float flSize = 20 * m_flPower + 10;
+
+		DrawChargingEffect( flSize, this );
+	}
+	return retval;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the model
+//-----------------------------------------------------------------------------
+void C_WeaponCombat_ChargeablePlasma::ViewModelDrawn( C_BaseViewModel *pBaseViewModel )
+{
+	if (!m_bCharging)
+		return;
+
+	// Draw the charging effect
+	float flSize = 12 * m_flPower + 6;
+
+	if ( m_iClip1 > 0 )
+	{
+		DrawChargingEffect( flSize, pBaseViewModel );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw targeting reticle
+//-----------------------------------------------------------------------------
+void C_WeaponCombat_ChargeablePlasma::DrawCrosshair( void )
+{
+	BaseClass::DrawCrosshair();
+
+	// Find enemy players in front of me
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	trace_t tr;
+	Vector vecStart, vecEnd;
+	VectorMA( CurrentViewOrigin(), 1500, CurrentViewForward(), vecEnd );
+	VectorMA( CurrentViewOrigin(), 48, CurrentViewForward(), vecStart );
+	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, NULL, COLLISION_GROUP_NONE, &tr );
+
+	if ( tr.DidHitNonWorldEntity() )
+	{
+		C_BaseEntity *pEntity = tr.m_pEnt;
+		if ( pEntity && pEntity->IsPlayer() && !pPlayer->InSameTeam( pEntity ) )
+		{
+			// Draw a reticle
+			vgui::Color clr = gHUD.m_clrYellowish;
+			clr[3] = 128;
+
+			// Calculate circle size
+			int iRatio = 30;
+
+			// Draw the circle 
+			int iDegrees = 0;
+			Vector vecPoint, vecLastPoint(0,0,0);
+			vecPoint.z = 0.0f;
+			for ( int i = 0; i < 360; i++ )
+			{
+				float flRadians = DEG2RAD( iDegrees );
+				iDegrees += (360 / 360);
+
+				float ca = cos( flRadians );
+				float sa = sin( flRadians );
+							 
+				// Rotate it around the circle
+				vecPoint.x = (int)((ScreenWidth() / 2) + (iRatio * sa));
+				vecPoint.y = (int)((ScreenHeight() / 2) - (iRatio * ca));
+
+				// Draw the point, if it's not on the previous point, to avoid smaller circles being brighter
+				if ( vecLastPoint != vecPoint )
+				{
+					vgui::surface()->DrawSetColor( clr );
+					vgui::surface()->DrawFilledRect( vecPoint.x, vecPoint.y, vecPoint.x + 1, vecPoint.y + 1 );
+				}
+
+				vecLastPoint = vecPoint;
+			}
+		}
+	}
+}
+
diff --git a/game/client/tf2/c_weapon_mortar.cpp b/game/client/tf2/c_weapon_mortar.cpp
new file mode 100644
index 0000000..ecae3b9
--- /dev/null
+++ b/game/client/tf2/c_weapon_mortar.cpp
@@ -0,0 +1,634 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's CWeaponMortar class
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "hudelement.h"
+#include "in_buttons.h"
+#include "ground_line.h"
+#include "clientmode_tfnormal.h"
+#include "vgui_basepanel.h"
+#include "c_tf_basecombatweapon.h"
+#include "engine/IEngineSound.h"
+#include "iinput.h"
+#include "imessagechars.h"
+#include "c_weapon__stubs.h"
+
+//=============================================================================
+// Purpose: Hud Element for Mortar firing
+//=============================================================================
+class CHudMortar : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudMortar, vgui::Panel );
+
+public:
+	DECLARE_MULTIPLY_INHERITED();
+
+	CHudMortar( const char *pElementName );
+	virtual void Paint( void );
+
+	float	m_flPower;
+	float	m_flFiringPower;
+	float	m_flFiringAccuracy;
+	float	m_flReset;
+};
+
+DECLARE_HUDELEMENT( CHudMortar );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudMortar::CHudMortar( const char *pElementName ) :
+	CHudElement( pElementName ), vgui::Panel( NULL, pElementName )
+{
+	m_flPower = 0;
+	m_flFiringPower = 0;
+	m_flFiringAccuracy = 0;
+	m_flReset = 0;
+	SetPaintBackgroundEnabled( false );
+	SetAutoDelete( false );
+	SetName( "mortar" );
+
+	SetHiddenBits( HIDEHUD_PLAYERDEAD );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudMortar::Paint()
+{
+	// Clear out markers
+	if ( m_flReset && m_flReset < gpGlobals->curtime )
+	{
+		m_flFiringPower = 0;
+		m_flFiringAccuracy = 0;
+		m_flReset = 0;
+	}
+
+	int w, h;
+	GetSize( w, h );
+
+	// Use an eighth of the height for each side
+	int iOffset = h / 8;
+	int iBarHeight = h - (2 * iOffset);
+	int iZero = (w / 5);
+	int iMarker = iZero + (m_flPower * (w - iZero));
+	int iPower = iZero + (m_flFiringPower * (w - iZero));
+	int iAccuracy = iZero + (m_flFiringAccuracy * (w - iZero));
+
+	// Shade the bar
+	int alpha = 205;
+	int colorAmt = 255;
+	int nSegs = 20;
+
+	int i;
+	for(i=0; i < nSegs; i++)
+	{
+		int left = iZero + (i*w) / nSegs;
+		int right = iZero + ((i+1)*w) / nSegs;
+
+		// Don't draw past the marker
+		if ( m_flFiringPower && right > iPower )
+			right = iPower;
+		else if ( !m_flFiringPower && right > iMarker )
+			right = iMarker;
+
+		vgui::surface()->DrawSetColor( ((i + 5) * colorAmt) / nSegs, 0, 0, alpha );
+		vgui::surface()->DrawFilledRect( left, iOffset, right, iBarHeight);
+	}
+
+	// Shade back from zero
+	nSegs = 10;
+	for(i=0; i < nSegs; i++)
+	{
+		int left = (i*iZero) / nSegs;
+		int right = ((i+1)*iZero) / nSegs;
+
+		if ( m_flFiringAccuracy && left < iAccuracy )
+			left = iAccuracy;
+		else if ( !m_flFiringAccuracy && left < iMarker )
+			left = iMarker;
+
+		vgui::surface()->DrawSetColor( ((nSegs - i) * colorAmt) / nSegs, 0, 0, alpha );
+		vgui::surface()->DrawFilledRect(left, iOffset, right, iBarHeight);
+	}
+
+	// Draw the zero marker
+	vgui::surface()->DrawSetColor(255,255,255,255);
+	vgui::surface()->DrawFilledRect(iZero-2, iOffset, iZero+2, iBarHeight);
+	
+	// Draw the marker
+	vgui::surface()->DrawSetColor(255,255,255,255);
+	vgui::surface()->DrawFilledRect(iMarker-1, 0, iMarker+1, h);
+
+	// Draw the power mark if we've set one
+	if ( m_flFiringPower )
+	{
+		vgui::surface()->DrawSetColor(255,255,255,255);
+		vgui::surface()->DrawFilledRect(iPower-1, iOffset, iPower+1, iBarHeight);
+	}
+
+	// Draw the accuracy mark if we've set one
+	if ( m_flFiringAccuracy )
+	{
+		vgui::surface()->DrawSetColor(255,255,255,255);
+		vgui::surface()->DrawFilledRect(iAccuracy-1, iOffset, iAccuracy+1, iBarHeight);
+	}
+
+	// Draw box
+	vgui::surface()->DrawSetColor(255,255,255,255);
+	vgui::surface()->DrawOutlinedRect(0, iOffset, w, iBarHeight);
+}
+
+static ConVar g_CVMortarGroundLineUpdateInterval( "mortar_groundlineupdateinterval", "0.1", 0, "Number of seconds, mininum, between ground line position updates." );
+
+
+//=============================================================================
+// Purpose: Client version of CWeaponMortar
+//=============================================================================
+class C_WeaponMortar : public C_BaseTFCombatWeapon
+{
+public:
+	DECLARE_CLASS( C_WeaponMortar, C_BaseTFCombatWeapon );
+	DECLARE_CLIENTCLASS();
+	DECLARE_PREDICTABLE();
+
+	C_WeaponMortar();
+	~C_WeaponMortar();
+
+	void FireMortar( void );
+
+	virtual void PreDataUpdate( DataUpdateType_t updateType );
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+	virtual void HandleInput( void );
+	virtual void Redraw();
+	virtual void OverrideMouseInput( float *x, float *y );	
+
+	// Deploy / Holster
+	virtual bool Deploy( void );
+	virtual bool Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+
+	// Mortar Data
+	bool	m_bCarried;
+	bool	m_bMortarReloading;
+	Vector	m_vecMortarOrigin;
+	Vector	m_vecMortarAngles;
+	float	m_flPrevMortarServerYaw;
+	float	m_flMortarYaw;
+	float	m_flPrevMortarYaw;
+
+	// Input Handling
+	float	m_flNextClick;
+	float	m_flAccuracySpeed;
+	int		m_iFiringState;
+	bool	m_bRotating;
+
+	CGroundLine *m_pGroundLine;
+	CGroundLine *m_pDarkLine;
+	CHudMortar	*m_pPowerBar;
+	IMaterial	*m_pRotateIcon;
+
+	vgui::HFont		m_hFontText;
+
+private:
+	C_WeaponMortar( const C_WeaponMortar & );
+
+	float			m_flLastGroundlineUpdateTime;
+
+};
+
+STUB_WEAPON_CLASS_IMPLEMENT( weapon_mortar, C_WeaponMortar );
+
+IMPLEMENT_CLIENTCLASS_DT(C_WeaponMortar, DT_WeaponMortar, CWeaponMortar)
+	RecvPropInt( RECVINFO(m_bCarried) ),
+	RecvPropInt( RECVINFO(m_bMortarReloading) ),
+	RecvPropVector( RECVINFO(m_vecMortarOrigin) ),
+	RecvPropVector( RECVINFO(m_vecMortarAngles) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_WeaponMortar::C_WeaponMortar()
+{
+	m_bCarried = true;
+	m_bMortarReloading = false;
+	m_iFiringState = MORTAR_IDLE;
+	m_flNextClick = 0;
+	m_flAccuracySpeed = 0;
+	m_bRotating = false;
+	m_pGroundLine = NULL;
+	m_pDarkLine = NULL;
+	m_flMortarYaw = 0;
+	m_flPrevMortarYaw = -1;
+
+	m_pRotateIcon = materials->FindMaterial( "Hud/mortar/mortar_rotate", TEXTURE_GROUP_VGUI );
+	m_pRotateIcon->IncrementReferenceCount();
+
+	m_pPowerBar = GET_HUDELEMENT( CHudMortar );
+
+	m_flLastGroundlineUpdateTime = 0.0f;
+
+	m_hFontText = g_hFontTrebuchet24;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_WeaponMortar::~C_WeaponMortar()
+{
+	m_pPowerBar->SetParent( (vgui::Panel *)NULL );
+
+	if ( m_pRotateIcon != NULL )
+	{
+		m_pRotateIcon->DecrementReferenceCount();
+		m_pRotateIcon = NULL;
+	}
+
+	if ( m_pGroundLine )
+	{
+		delete m_pGroundLine;
+	}
+	if ( m_pDarkLine )
+	{
+		delete m_pDarkLine;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponMortar::PreDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PreDataUpdate(updateType);
+
+	m_flPrevMortarServerYaw = m_vecMortarAngles.y;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponMortar::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged(updateType);
+
+	// If the mortar's being carried by some other player, don't make a ground line
+	if ( !IsCarriedByLocalPlayer() )
+		return;
+
+	// Draw power chart if the mortar is deployed
+	if ( !m_bCarried && !m_bMortarReloading )
+	{
+		vgui::Panel *pParent = GetClientModeNormal()->GetViewport();
+		int parentWidth, parentHeight;
+		pParent->GetSize(parentWidth, parentHeight);
+
+		int iWidth = 256;
+		int iHeight = 40;
+		int iX = (parentWidth - iWidth) / 2;
+		int iY = (parentHeight - 200);
+
+		// Only show the power bar if the mortar's the active weapon
+		if ( IsActiveByLocalPlayer() )
+		{
+			m_pPowerBar->SetBounds( iX, iY, iWidth, iHeight );
+			m_pPowerBar->SetParent(pParent);
+		}
+		else
+		{
+			m_pPowerBar->SetParent( (vgui::Panel *)NULL );
+		}
+
+		if ( !m_bRotating && m_flPrevMortarServerYaw != m_vecMortarAngles.y )
+		{
+			m_flMortarYaw = m_vecMortarAngles.y;
+		}
+
+		// Create the Ground lines
+		if ( !m_pGroundLine )
+		{
+			m_pGroundLine = new CGroundLine();
+			m_pGroundLine->Init( "player/support/mortarline" );
+		}
+		if ( !m_pDarkLine )
+		{
+			m_pDarkLine = new CGroundLine();
+			m_pDarkLine->Init( "player/support/mortarline" );
+		}
+	}
+	else
+	{
+		m_pPowerBar->SetParent( (vgui::Panel *)NULL );
+
+		if ( m_pGroundLine )
+		{
+			delete m_pGroundLine;
+			m_pGroundLine = NULL;
+		}
+		if ( m_pDarkLine )
+		{
+			delete m_pDarkLine;
+			m_pDarkLine = NULL;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponMortar::HandleInput( void )
+{
+	// If it's being carried, ignore input
+	if ( m_bCarried )
+		return;
+	// If the player's dead, ignore input
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer == NULL )
+		return;
+	if ( pPlayer->GetHealth() < 1 )
+		return;
+
+	// Ignore input if it's reloading
+	if ( m_bMortarReloading )
+		return;
+
+	// Secondary fire rotates the mortar
+	if ( gHUD.m_iKeyBits & IN_ATTACK2 )
+	{
+		if ( pPlayer->HasPowerup(POWERUP_EMP) )
+		{
+			CLocalPlayerFilter filter;
+			EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "WeaponMortar.EMPed" );
+			return;
+		}
+		m_bRotating = true;
+
+		gHUD.m_iKeyBits &= ~IN_ATTACK2;
+
+		// Prevent firing while rotating
+		m_pPowerBar->SetParent( (vgui::Panel *)NULL );
+		return;
+	}
+	else
+	{
+		if ( m_bRotating )
+		{
+			// Bring up the firing bar again
+			vgui::Panel *pParent = GetClientModeNormal()->GetViewport();
+			m_pPowerBar->SetParent(pParent);
+			m_bRotating = false;
+		}
+	}
+
+	// Primary fire launches mortars
+	if (gHUD.m_iKeyBits & IN_ATTACK)
+	{
+		if ( pPlayer->HasPowerup(POWERUP_EMP) )
+		{
+			CLocalPlayerFilter filter;
+			EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "WeaponMortar.EMPed" );
+			return;
+		}
+
+		if ( m_flNextClick <= gpGlobals->curtime )
+		{
+			// Play click animation
+			// SendWeaponAnim( ACT_SLAM_DETONATOR_DETONATE );
+
+			// Switch states
+			switch( m_iFiringState )
+			{
+			case MORTAR_IDLE:
+				m_iFiringState = MORTAR_CHARGING_POWER;
+				break;
+			case MORTAR_CHARGING_POWER:
+				m_pPowerBar->m_flFiringPower = m_pPowerBar->m_flPower;
+				m_iFiringState = MORTAR_CHARGING_ACCURACY;
+				break;
+			case MORTAR_CHARGING_ACCURACY:
+				m_pPowerBar->m_flFiringAccuracy = m_pPowerBar->m_flPower;
+				m_iFiringState = MORTAR_IDLE;
+
+				FireMortar();
+				break;
+			default:
+				break;
+			}
+
+			input->ClearInputButton( IN_ATTACK );
+			gHUD.m_iKeyBits &= ~IN_ATTACK;
+
+			m_flNextClick = gpGlobals->curtime + 0.05;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponMortar::Redraw()
+{
+	BaseClass::Redraw();
+
+	// If the player's dead, abort
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer == NULL )
+		return;
+	if ( pPlayer->GetHealth() < 1 )
+	{
+		m_iFiringState = MORTAR_IDLE;
+		m_bCarried = true;
+		return;
+	}
+
+	// If it's reloading, tell the player
+	if ( m_bMortarReloading )
+	{
+		int width, height;
+		messagechars->GetStringLength( m_hFontText, &width, &height, "Mortar is reloading..." );
+		messagechars->DrawString( m_hFontText, (ScreenWidth() - width) / 2, YRES(350), 192, 192, 192, 255, "Mortar is reloading...", IMessageChars::MESSAGESTRINGID_NONE );
+		return;
+	}
+
+	// Handle power charging
+	switch( m_iFiringState )
+	{
+	case MORTAR_IDLE:
+		m_pPowerBar->m_flPower = 0;
+		break;
+	case MORTAR_CHARGING_POWER:
+		m_pPowerBar->m_flPower = MIN( m_pPowerBar->m_flPower + ( (1.0 / MORTAR_CHARGE_POWER_RATE) * gpGlobals->curtimeDelta), 1.0f);
+		m_pPowerBar->m_flFiringPower = 0;
+		m_pPowerBar->m_flFiringAccuracy = 0;
+		if ( m_pPowerBar->m_flPower >= 1.0 )
+		{
+			// Hit Max, start going down
+			m_pPowerBar->m_flFiringPower = m_pPowerBar->m_flPower;
+			m_iFiringState = MORTAR_CHARGING_ACCURACY;
+			m_flNextClick = gpGlobals->curtime + 0.25;
+		}
+		break;
+	case MORTAR_CHARGING_ACCURACY:
+		// Calculate accuracy speed
+		m_flAccuracySpeed = (1.0 / MORTAR_CHARGE_ACCURACY_RATE);
+		if ( m_pPowerBar->m_flFiringPower > 0.5 )
+		{
+			// Shots over halfway suffer an increased speed to the accuracy power, making accurate shots harder
+			float flAdjustedPower = (m_pPowerBar->m_flFiringPower - 0.5) * 3.0;
+			m_flAccuracySpeed += (m_pPowerBar->m_flFiringPower * flAdjustedPower);
+		}
+
+		m_pPowerBar->m_flPower = MAX( m_pPowerBar->m_flPower - ( m_flAccuracySpeed * gpGlobals->curtimeDelta), -0.25f);
+		if ( m_pPowerBar->m_flPower <= -0.25 )
+		{
+			// Hit Min, fire mortar
+			m_pPowerBar->m_flFiringAccuracy = m_pPowerBar->m_flPower;
+			m_iFiringState = MORTAR_IDLE;
+
+			FireMortar();
+			m_flNextClick = gpGlobals->curtime + 0.25;
+		}
+		break;
+	default:
+		break;
+	}
+
+	// Draw the rotate icon if the player's rotating the mortar
+	if ( m_bRotating )
+	{
+		vgui::Panel *pParent = GetClientModeNormal()->GetViewport();
+		int parentWidth, parentHeight;
+		pParent->GetSize(parentWidth, parentHeight);
+		int iWidth = 64;
+		int iHeight = 64;
+		int iX = (parentWidth - iWidth) / 2;
+		int iY = (parentHeight - 216);
+
+		IMesh* pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_pRotateIcon );
+
+		CMeshBuilder meshBuilder;
+		meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
+
+		meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+		meshBuilder.TexCoord2f( 0,0,0 );
+		meshBuilder.Position3f( iX,iY,0 );
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+		meshBuilder.TexCoord2f( 0,1,0 );
+		meshBuilder.Position3f( iX+iWidth, iY, 0 );
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+		meshBuilder.TexCoord2f( 0,1,1 );
+		meshBuilder.Position3f( iX+iWidth, iY+iHeight, 0 );
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+		meshBuilder.TexCoord2f( 0,0,1 );
+		meshBuilder.Position3f( iX, iY+iHeight, 0 );
+		meshBuilder.AdvanceVertex();
+
+		meshBuilder.End();
+		pMesh->Draw();
+	}
+
+	// Update the ground line if it's moved
+	if ( !m_bCarried && (m_flPrevMortarYaw != m_flMortarYaw ) && 
+		gpGlobals->curtime > m_flLastGroundlineUpdateTime + g_CVMortarGroundLineUpdateInterval.GetFloat() )
+	{
+		// Create the Ground line start & end points
+		Vector vecForward;
+		AngleVectors( QAngle( 0, m_flMortarYaw, 0 ), &vecForward );
+		Vector vecStart = m_vecMortarOrigin + (vecForward * MORTAR_RANGE_MIN);
+
+		float flRange = MORTAR_RANGE_MAX_INITIAL;
+		if ( pPlayer->HasNamedTechnology( "mortar_range" ) )
+			flRange = MORTAR_RANGE_MAX_UPGRADED;
+		Vector vecEnd = m_vecMortarOrigin + (vecForward * flRange);
+
+		m_pDarkLine->SetParameters( m_vecMortarOrigin, vecStart, Vector( 0.1,0.1,0.1 ), Vector( 0.1,0.1,0.1 ), 0.5, 22 );
+		m_pGroundLine->SetParameters( vecStart, vecEnd, Vector(0,1,0), Vector(1,0,0), 0.5, 22 );
+
+		m_flPrevMortarYaw = m_flMortarYaw;
+
+		m_flLastGroundlineUpdateTime = gpGlobals->curtime;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Capture mouse input for mortar rotation
+//-----------------------------------------------------------------------------
+void C_WeaponMortar::OverrideMouseInput( float *x, float *y )
+{
+	if ( !m_bRotating )
+		return;
+
+	float flX = ( *x ) * 0.05f;
+
+	m_flMortarYaw = anglemod(m_flMortarYaw - flX);
+
+	*x = 0.0f;
+	*y = 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Weapon's been deployed
+//-----------------------------------------------------------------------------
+bool C_WeaponMortar::Deploy( void )
+{
+	if ( m_pDarkLine )
+	{
+		m_pDarkLine->SetVisible( true );
+	}
+	if ( m_pGroundLine )
+	{
+		m_pGroundLine->SetVisible( true );
+	}
+
+	return BaseClass::Deploy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Weapon's been holstered
+//-----------------------------------------------------------------------------
+bool C_WeaponMortar::Holster( C_BaseCombatWeapon *pSwitchingTo )
+{
+	if ( m_pDarkLine )
+	{
+		m_pDarkLine->SetVisible( false );
+	}
+	if ( m_pGroundLine )
+	{
+		m_pGroundLine->SetVisible( false );
+	}
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponMortar::FireMortar( void )
+{
+	// Clamp inaccuracy
+	float flTempAcc = m_pPowerBar->m_flFiringAccuracy;
+	if ( flTempAcc > 0.25 )
+		flTempAcc = 0.25;
+	else if ( flTempAcc < -0.25 )
+		flTempAcc = -0.25;
+
+	// HACKHACK: This is an amazingly bad way to do it. Replace this when the
+	// client DLL can insert commands into the usercmds
+	char szbuf[48];
+	Q_snprintf( szbuf, sizeof( szbuf ), "mortar %0.2f %0.2f %0.2f\n", m_pPowerBar->m_flFiringPower, flTempAcc, m_flMortarYaw );
+	engine->ClientCmd(szbuf);
+
+	// Tell the power bar to reset soon
+	m_pPowerBar->m_flReset = gpGlobals->curtime + 1.0;
+}
\ No newline at end of file
diff --git a/game/client/tf2/c_weapon_twohandedcontainer.cpp b/game/client/tf2/c_weapon_twohandedcontainer.cpp
new file mode 100644
index 0000000..8ff85c5
--- /dev/null
+++ b/game/client/tf2/c_weapon_twohandedcontainer.cpp
@@ -0,0 +1,166 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Client's Support "weapon"
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "weapon_twohandedcontainer.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws little viewmodel attachments
+//-----------------------------------------------------------------------------
+void C_WeaponTwoHandedContainer::ViewModelDrawn( C_BaseViewModel *pBaseViewModel )
+{
+	BaseClass::ViewModelDrawn( pBaseViewModel );
+
+	if (pBaseViewModel->ViewModelIndex() != 0)
+	{
+		if ( m_hRightWeapon )
+		{
+			m_hRightWeapon->ViewModelDrawn(pBaseViewModel);
+		}
+	}
+	else
+	{
+		if ( m_hLeftWeapon )
+		{
+			m_hLeftWeapon->ViewModelDrawn(pBaseViewModel);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_WeaponTwoHandedContainer::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, 
+											  const QAngle& angles, int event, const char *options )
+{
+	bool bRight = m_hRightWeapon->OnFireEvent( pViewModel, origin, angles, event, options );
+	bool bLeft = m_hLeftWeapon->OnFireEvent( pViewModel, origin, angles, event, options );
+
+	return ( bRight || bLeft );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponTwoHandedContainer::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Did we just receive a new weapon?
+	bool rightchanged = m_hOldRightWeapon.Get() != m_hRightWeapon.Get() ? true : false;
+	bool leftchanged = m_hOldLeftWeapon.Get() != m_hLeftWeapon.Get() ? true : false;
+
+	if ( rightchanged || leftchanged )
+	{
+		/*
+		// Tell weapons that they're being holstered
+		if ( m_hRightWeapon != NULL && rightchanged )
+		{
+			m_hRightWeapon->Holster( NULL );
+		}
+		if ( m_hLeftWeapon != NULL && leftchanged )
+		{
+			m_hLeftWeapon->Holster( NULL );
+		}
+		*/
+
+		HookWeaponEntities();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponTwoHandedContainer::HookWeaponEntities( void )
+{
+	m_hOldRightWeapon	= m_hRightWeapon;
+	m_hOldLeftWeapon	= m_hLeftWeapon;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Never draw the container
+//-----------------------------------------------------------------------------
+bool C_WeaponTwoHandedContainer::ShouldDraw( void )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This weapon is the active weapon, and it should now draw anything
+//			it wants to. This gets called every frame.
+//-----------------------------------------------------------------------------
+void C_WeaponTwoHandedContainer::Redraw()
+{
+	BaseClass::Redraw();
+
+	if ( m_hRightWeapon.Get() )
+	{
+		m_hRightWeapon->Redraw();
+	}
+	if ( m_hLeftWeapon.Get() )
+	{
+		m_hLeftWeapon->Redraw();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw both weapon's ammo's
+//-----------------------------------------------------------------------------
+void C_WeaponTwoHandedContainer::DrawAmmo()
+{
+	// Just tell our active weapon to draw it's ammo, since our offhand doesn't use it
+	if ( m_hLeftWeapon )
+	{
+		m_hLeftWeapon->DrawAmmo();
+	}
+	if ( m_hRightWeapon.Get() )
+	{
+		m_hRightWeapon->DrawAmmo();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Let each weapon handle input
+//-----------------------------------------------------------------------------
+void C_WeaponTwoHandedContainer::HandleInput( void )
+{
+	BaseClass::HandleInput();
+
+	if ( m_hRightWeapon )
+	{
+		m_hRightWeapon->HandleInput();
+	}
+	if ( m_hLeftWeapon )
+	{
+		m_hLeftWeapon->HandleInput();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Let each weapon handle input
+//-----------------------------------------------------------------------------
+void C_WeaponTwoHandedContainer::OverrideMouseInput( float *x, float *y )
+{
+	BaseClass::OverrideMouseInput( x,y );
+
+	if ( m_hRightWeapon )
+	{
+		m_hRightWeapon->OverrideMouseInput( x,y );
+	}
+	if ( m_hLeftWeapon )
+	{
+		m_hLeftWeapon->OverrideMouseInput( x,y );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_WeaponTwoHandedContainer::VisibleInWeaponSelection( void )
+{
+	return false;
+}
diff --git a/game/client/tf2/clientmode_commander.cpp b/game/client/tf2/clientmode_commander.cpp
new file mode 100644
index 0000000..64fb9b7
--- /dev/null
+++ b/game/client/tf2/clientmode_commander.cpp
@@ -0,0 +1,725 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//===========================================================================//
+#include "cbase.h"
+#include "hud_chat.h"
+#include "clientmode_commander.h"
+#include "vgui_int.h"
+#include "ivmodemanager.h"
+#include "iinput.h"
+#include "kbutton.h"
+#include "usercmd.h"
+#include "c_basetfplayer.h"
+#include "view_shared.h"
+#include "in_main.h"
+#include "commanderoverlaypanel.h"
+#include "iviewrender.h"
+#include <vgui/IInput.h>
+#include <vgui/IPanel.h>
+
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+enum
+{
+	VISIBLE_STATIC_PROP_HEIGHT = 7500
+};
+
+extern Vector g_vecRenderOrigin;
+extern QAngle g_vecRenderAngles;
+
+static ConVar Commander_SlueSpeed( "commander_speed", "800.0", 0 );
+static ConVar Commander_MouseSpeed( "commander_mousespeed", "200.0", 0 );
+static ConVar Commander_RightMoveSpeedScale( "commander_rightmovespeedscale", "2.0", 0 );
+static ConVar Commander_InvertMouse( "commander_invertmouse", "1.0", 0 );
+
+// Public version of the commander mode;
+IClientMode *ClientModeCommander()
+{
+	// TF2 Commander View Mode
+	static CClientModeCommander g_ClientModeCommander;
+	return &g_ClientModeCommander;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *commander - 
+//-----------------------------------------------------------------------------
+void CCommanderViewportPanel::SetCommanderView( CClientModeCommander *commander )
+{
+	m_pCommanderView = commander;
+
+	if ( m_pOverlayPanel )
+	{
+		m_pOverlayPanel->SetCommanderView( m_pCommanderView );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CCommanderOverlayPanel
+//-----------------------------------------------------------------------------
+CCommanderOverlayPanel *CCommanderViewportPanel::GetCommanderOverlayPanel( void )
+{
+	return m_pOverlayPanel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCommanderViewportPanel::CCommanderViewportPanel( void ) :
+	m_CursorCommander( vgui::dc_arrow ),
+	m_CursorRightMouseMove(vgui::dc_hand)
+{
+	m_pOverlayPanel = new CCommanderOverlayPanel();
+	m_pOverlayPanel->SetParent( this );
+
+	SetPaintEnabled( false );
+	SetPaintBorderEnabled( false );
+	SetPaintBackgroundEnabled( false );
+
+	SetCursor( m_CursorCommander );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCommanderViewportPanel::~CCommanderViewportPanel( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// call these when commander view is enabled/disabled
+//-----------------------------------------------------------------------------
+
+
+void CCommanderViewportPanel::Enable()
+{
+	vgui::VPANEL pRoot = VGui_GetClientDLLRootPanel();
+
+	SetCursor(m_CursorCommander);
+	vgui::surface()->SetCursor( m_CursorCommander );
+
+	// Make the viewport fill the root panel.
+	if ( pRoot)
+	{
+		int wide, tall;
+		vgui::ipanel()->GetSize(pRoot, wide, tall);
+		SetBounds(0, 0, wide, tall);
+	}
+
+	C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
+
+	if ( m_pOverlayPanel && ent )
+	{
+		m_pOverlayPanel->Enable();
+	}
+
+	SetVisible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderViewportPanel::Disable()
+{
+	if ( m_pOverlayPanel )
+	{
+		m_pOverlayPanel->Disable();
+	}
+
+	SetVisible( false );
+}
+
+void CCommanderViewportPanel::MinimapClicked( const Vector& clickWorldPos )
+{
+	// Don't use Z... our current z is what we want
+	Vector actualOrigin, offset;
+	VectorCopy( clickWorldPos, actualOrigin );
+	actualOrigin.z = m_pOverlayPanel->TacticalOrigin().z;
+
+	m_pOverlayPanel->ActualToVisibleOffset( offset );
+	VectorSubtract( actualOrigin, offset, actualOrigin );
+	m_pOverlayPanel->BoundOrigin( actualOrigin );
+	m_pOverlayPanel->TacticalOrigin() = actualOrigin;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CClientModeCommander::CClientModeCommander() : BaseClass()
+{
+	m_pClear = NULL;
+	m_pSkyBox = NULL;
+	m_ScaledSlueSpeed = 10;
+	m_Log_BaseEto2 = 1.4427f;	// factor to convert from a logarithm of base E to base 2.
+
+	m_pViewport = new CCommanderViewportPanel;
+	GetCommanderViewport()->SetCommanderView( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CClientModeCommander::~CClientModeCommander()
+{
+
+}
+
+CCommanderViewportPanel *CClientModeCommander::GetCommanderViewport()
+{
+	Assert( m_pViewport );
+	return static_cast< CCommanderViewportPanel * >( m_pViewport );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called once at dll load time
+//-----------------------------------------------------------------------------
+void CClientModeCommander::Init( void )
+{
+	BaseClass::Init();
+	GetCommanderViewport()->RequestFocus();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : vgui::Panel
+//-----------------------------------------------------------------------------
+vgui::Panel *CClientModeCommander::GetMinimapParent( void )
+{
+	return GetCommanderOverlayPanel();
+}
+
+//-----------------------------------------------------------------------------
+// Inherited from IMinimapClient
+//-----------------------------------------------------------------------------
+void CClientModeCommander::MinimapClicked( const Vector& clickWorldPos )
+{
+	if ( GetCommanderViewport() )
+	{
+		GetCommanderViewport()->MinimapClicked( clickWorldPos );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCommanderOverlayPanel	*CClientModeCommander::GetCommanderOverlayPanel( void )
+{
+	if ( GetCommanderViewport() )
+	{
+		return GetCommanderViewport()->GetCommanderOverlayPanel();
+	}
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+void CClientModeCommander::Enable()
+{
+	// HACK: Find a better place for these
+	m_pClear = (ConVar *)cvar->FindVar( "gl_clear" );
+	m_pSkyBox = (ConVar *)cvar->FindVar( "r_drawskybox" );
+
+	HudCommanderOverlayMgr()->Enable( true );
+
+	BaseClass::Enable();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CClientModeCommander::Disable()
+{
+	BaseClass::Disable();
+
+	::input->ResetMouse();
+	
+	HudCommanderOverlayMgr()->Enable( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+void CClientModeCommander::Update()
+{
+	if ( !engine->IsInGame() )
+	{
+		// Disable commander view
+		modemanager->SwitchMode( false, false );
+		return;
+	}
+
+	ClientModeTFBase::Update();
+
+	Vector mins, maxs;
+	GetCommanderViewport()->GetCommanderOverlayPanel()->GetVisibleArea( mins, maxs );
+	MapData().SetVisibleArea( mins, maxs );
+
+	HudCommanderOverlayMgr()->Tick( );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CClientModeCommander::Layout()
+{
+	BaseClass::Layout();
+
+	// Force it to recompute it's boundaries
+	GetCommanderViewport()->GetCommanderOverlayPanel()->Disable();
+	GetCommanderViewport()->GetCommanderOverlayPanel()->Enable();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The mode can choose to not draw fog
+//-----------------------------------------------------------------------------
+bool CClientModeCommander::ShouldDrawFog( void )
+{
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks map bounds and determines ideal height for tactical view
+// Input  : fov - 
+//			zoom - 
+// Output : float
+//-----------------------------------------------------------------------------
+float CClientModeCommander::GetHeightForMap( float zoom )
+{
+	Vector mins, maxs;
+	MapData().GetMapBounds( mins, maxs );
+	return maxs.z + TACTICAL_ZOFFSET; 
+}
+
+
+bool CClientModeCommander::GetOrthoParameters(CViewSetup *pSetup)
+{
+	Vector vCenter;
+	float xSize, ySize;
+	GetCommanderViewport()->GetCommanderOverlayPanel()->GetOrthoRenderBox(vCenter, xSize, ySize);
+
+	pSetup->m_bOrtho = true;
+	pSetup->m_OrthoLeft   = -xSize;
+	pSetup->m_OrthoTop    = -ySize;
+	pSetup->m_OrthoRight  = xSize;
+	pSetup->m_OrthoBottom = ySize;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *angles - 
+//-----------------------------------------------------------------------------
+void CClientModeCommander::OverrideView( CViewSetup *pSetup )
+{
+	// Turn off vis when in commander mode
+	view->DisableVis();
+	VectorCopy( GetCommanderViewport()->GetCommanderOverlayPanel()->TacticalAngles(), pSetup->angles );
+	VectorCopy( GetCommanderViewport()->GetCommanderOverlayPanel()->TacticalOrigin(), pSetup->origin );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Scale commander slue speed based on viewport zoom factor
+// Output : float
+//-----------------------------------------------------------------------------
+float CClientModeCommander::GetScaledSlueSpeed( void )
+{
+	return m_ScaledSlueSpeed;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Convert move to scaled move
+// Input  : in - 
+// Output : float
+//-----------------------------------------------------------------------------
+float CClientModeCommander::Commander_ResampleMove( float in )
+{
+	float sign;
+	float move;
+
+	if ( !in )
+		return 0.0;
+
+	sign = in > 0.0 ? 1.0 : -1.0;
+	
+	move = GetScaledSlueSpeed();
+
+	return move * sign;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Zero out any movement in the command
+// Input  : *cmd - 
+//-----------------------------------------------------------------------------
+void CClientModeCommander::ResetCommand( CUserCmd *cmd )
+{
+	cmd->buttons = 0;
+	cmd->forwardmove = 0;
+	cmd->sidemove = 0;
+	cmd->upmove = 0;
+	cmd->viewangles.Init();
+}	
+
+//-----------------------------------------------------------------------------
+// Purpose: TF2 commander mode movement logic
+//-----------------------------------------------------------------------------
+void CClientModeCommander::IsometricMove( CUserCmd *cmd )
+{
+	int i;
+	Vector wishvel;
+	float fmove, smove;
+	Vector forward, right, up;
+
+	AngleVectors ( cmd->viewangles, &forward, &right, &up);  // Determine movement angles
+	
+	// Copy movement amounts
+	fmove = cmd->forwardmove;
+	smove = cmd->sidemove;
+	
+	// No up / down movement
+	forward.Init(1, 0, 0);
+	right.Init(0, -1, 0);
+
+	wishvel.Init();
+	
+	// Determine x and y parts of velocity
+	for (i=0; i < 3; i++)       
+	{
+		wishvel[i] = forward[i]*fmove + right[i]*smove;
+	}
+
+	GetCommanderViewport()->GetCommanderOverlayPanel()->TacticalOrigin() += TICK_INTERVAL * wishvel;
+	GetCommanderViewport()->GetCommanderOverlayPanel()->BoundOrigin( GetCommanderViewport()->GetCommanderOverlayPanel()->TacticalOrigin() );
+}
+
+#define WINDOWED_KEEPMOVING_PIXELS 300
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : frametime - 
+//			*cmd - 
+//-----------------------------------------------------------------------------
+void CClientModeCommander::CreateMove( float flInputSampleTime, CUserCmd *cmd )
+{
+	int mx, my;
+	int realx, realy;
+	//int sidex, sidey;
+
+	cmd->upmove = 0;
+
+	// Figure out the speed scale so their perceptual movement speed stays the same.
+	m_ScaledSlueSpeed  = Commander_SlueSpeed.GetFloat() * GetCommanderViewport()->GetCommanderOverlayPanel()->WorldUnitsPerPixel();
+	m_ScaledMouseSpeed = Commander_MouseSpeed.GetFloat() * GetCommanderViewport()->GetCommanderOverlayPanel()->WorldUnitsPerPixel();
+
+	// Translate WASD while in commander mode...
+	float temp = cmd->forwardmove;
+	// Swap forward/right
+	cmd->forwardmove = cmd->sidemove;
+	// Invert right/left
+	cmd->sidemove = -temp;
+
+	// Normalize nonzero inputs to scaled speed
+	if ( cmd->forwardmove )
+	{
+		cmd->forwardmove = ( cmd->forwardmove > 0 ) ? GetScaledSlueSpeed() : -GetScaledSlueSpeed();
+	}
+	if ( cmd->sidemove )
+	{
+		cmd->sidemove = ( cmd->sidemove > 0 ) ? GetScaledSlueSpeed() : -GetScaledSlueSpeed();
+	}
+
+	// Sample mouse
+	::input->GetFullscreenMousePos( &mx, &my, &realx, &realy );
+
+	if( GetCommanderViewport()->GetCommanderOverlayPanel()->IsRightMouseMapMoving() || ( in_commandermousemove.state & 1 ) )
+	{
+		cmd->forwardmove = m_ScaledMouseSpeed * (mx - m_LastMouseX);
+		cmd->sidemove = m_ScaledMouseSpeed * (my - m_LastMouseY);
+
+		if ( Commander_InvertMouse.GetInt() )
+		{
+			cmd->forwardmove *= -1.0f;
+			cmd->sidemove *= -1.0f;
+		}
+
+		//input->SetFullscreenMousePos( m_LastMouseX, m_LastMouseY );
+		mx = m_LastMouseX;
+		my = m_LastMouseY;
+	}
+	/*
+	else if ( input->IsFullscreenMouse() )
+	{
+		if ( abs( realx - mx ) < WINDOWED_KEEPMOVING_PIXELS && 
+			 abs( realy - my ) < WINDOWED_KEEPMOVING_PIXELS )
+		{
+			sidex = 2;
+			sidey = 2;
+
+			// Check Size of viewport
+			if ( mx < sidex )
+			{
+				cmd->forwardmove = -GetScaledSlueSpeed();
+			}
+			else if ( mx > ( ScreenWidth() - sidex ))
+			{
+				cmd->forwardmove = GetScaledSlueSpeed();
+			}
+			
+			if ( my < sidey )
+			{
+				cmd->sidemove = -GetScaledSlueSpeed();
+			}
+			else if ( my > ( ScreenHeight() - sidey ) )
+			{
+				cmd->sidemove = GetScaledSlueSpeed();
+			}
+		}
+	}
+	*/
+
+	m_LastMouseX = mx;
+	m_LastMouseY = my;
+
+	// Look straight down
+	cmd->viewangles.x = 90; // 45;
+	cmd->viewangles.y = 90; //45fmod( 3.0* 360 * (gpGlobals->curtime * 0.01), 360 );
+	cmd->viewangles.z = 0;
+
+	GetCommanderViewport()->GetCommanderOverlayPanel()->TacticalAngles() = cmd->viewangles;
+
+	IsometricMove( cmd );
+
+	// Reset command
+	ResetCommand( cmd );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Makes sure the mouse is over the same world position as it started
+//-----------------------------------------------------------------------------
+
+void CClientModeCommander::MoveMouse( Vector& worldPos )
+{
+	Vector worldCenter;
+	float wworld, hworld;
+	GetCommanderViewport()->GetCommanderOverlayPanel()->GetOrthoRenderBox(worldCenter, wworld, hworld);
+	wworld *= 2; hworld *= 2;
+
+	Vector worldDelta;
+	VectorSubtract( worldPos, worldCenter, worldDelta );
+
+	int w, h;
+	GetCommanderViewport()->GetSize( w, h );
+
+	int mx, my;
+	mx = (worldDelta.x / wworld + 0.5f) * w;
+	my = (0.5f - worldDelta.y / hworld) * h;
+
+	// Clamp
+	if (mx < 0)	mx = 0; else if (mx > w) mx = w;
+	if (my < 0)	my = 0; else if (my > h) my = h;
+
+	//input->SetFullscreenMousePos( mx, my );
+
+	m_LastMouseX = mx;
+	m_LastMouseY = my;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *newmap - 
+//-----------------------------------------------------------------------------
+void CClientModeCommander::LevelInit( const char *newmap )
+{
+	BaseClass::LevelInit( newmap );
+
+	HudCommanderOverlayMgr()->LevelShutdown();
+	MapData().LevelInit( newmap );
+	GetCommanderViewport()->GetCommanderOverlayPanel()->LevelInit( newmap );
+	HudCommanderOverlayMgr()->LevelInit( );
+
+	GetCommanderViewport()->Enable();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CClientModeCommander::LevelShutdown( void )
+{
+	GetCommanderViewport()->Disable();
+
+	MapData().LevelShutdown();
+
+	HudCommanderOverlayMgr()->LevelShutdown();
+
+	GetCommanderViewport()->GetCommanderOverlayPanel()->LevelShutdown();
+
+	BaseClass::LevelShutdown();
+}
+
+//-----------------------------------------------------------------------------
+// returns the viewport panel
+//-----------------------------------------------------------------------------
+vgui::Panel *CClientModeCommander::GetViewport()
+{
+	return m_pViewport;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CClientModeCommander::ShouldDrawEntity(C_BaseEntity *pEnt)
+{
+	return MapData().IsEntityVisibleToTactical(pEnt);
+}
+
+bool CClientModeCommander::ShouldDrawDetailObjects( )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Always draw the local player while in commander mode
+//-----------------------------------------------------------------------------
+bool CClientModeCommander::ShouldDrawLocalPlayer( C_BasePlayer *pPlayer )
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CClientModeCommander::ShouldDrawViewModel( void )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return false to disable crosshair
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CClientModeCommander::ShouldDrawCrosshair( void )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Adjust engine rendering viewport rectangle if needed
+// Input  : x - 
+//			y - 
+//			width - 
+//			height - 
+//-----------------------------------------------------------------------------
+void CClientModeCommander::AdjustEngineViewport( int& x, int& y, int& width, int& height )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Should I draw particles
+//-----------------------------------------------------------------------------
+
+bool CClientModeCommander::ShouldDrawParticles( )
+{
+	Vector vCenter;
+	float xSize, ySize;
+	GetCommanderViewport()->GetCommanderOverlayPanel()->GetOrthoRenderBox(vCenter, xSize, ySize);
+
+	// Activate/deactivate particles rendering based on zoom level
+	float maxSize = MAX( xSize, ySize );
+	return (maxSize < VISIBLE_STATIC_PROP_HEIGHT);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: When in commander mode, force gl_clear and don't draw the skybox
+//-----------------------------------------------------------------------------
+
+void CClientModeCommander::PreRender( CViewSetup *pSetup )
+{
+	if ( !m_pClear || !m_pSkyBox )
+		return;
+
+	m_fOldClear = m_pClear->GetFloat();
+	m_pClear->SetValue( 1.0f );
+	pSetup->clearColor = !!m_pClear->GetInt();
+
+	m_fOldSkybox = m_pSkyBox->GetFloat();
+	m_pSkyBox->SetValue( 0.0f );
+
+	GetOrthoParameters(pSetup);
+	render->DrawTopView( true );
+	Vector2D mins = pSetup->origin.AsVector2D();
+	Vector2D maxs = pSetup->origin.AsVector2D();
+	mins.x += pSetup->m_OrthoLeft;
+	maxs.x += pSetup->m_OrthoRight;
+	mins.y += pSetup->m_OrthoTop;
+	maxs.y += pSetup->m_OrthoBottom;
+	render->TopViewBounds( mins, maxs );
+
+	// Activate/deactivate static prop + particles rendering based on zoom level
+	Vector2D size;
+	Vector2DSubtract( maxs, mins, size );
+	float maxSize = MAX( size.x, size.y );
+	bool showStaticProps = (maxSize < VISIBLE_STATIC_PROP_HEIGHT);
+	ClientLeafSystem()->DrawStaticProps(showStaticProps);
+	ClientLeafSystem()->DrawSmallEntities(showStaticProps);
+
+	BaseClass::PreRender(pSetup);
+}
+
+void CClientModeCommander::PostRenderWorld()
+{
+	render->DrawTopView( false );
+	ClientLeafSystem()->DrawStaticProps(true);
+	ClientLeafSystem()->DrawSmallEntities(true);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Restore cvar values
+//-----------------------------------------------------------------------------
+void CClientModeCommander::PostRender( void )
+{
+	if ( !m_pClear || !m_pSkyBox )
+		return;
+
+	m_pClear->SetValue( m_fOldClear );
+	m_pSkyBox->SetValue( m_fOldSkybox );
+
+	BaseClass::PostRender();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Swallow mouse wheel when in this view
+// Input  : down - 
+//			keynum - 
+//			*pszCurrentBinding - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CClientModeCommander::KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
+{
+	switch ( keynum )
+	{
+	case MOUSE_WHEEL_UP:
+	case MOUSE_WHEEL_DOWN:
+		// Swallow
+		return 0;
+	}
+
+	// Allow engine to process
+	return BaseClass::KeyInput( down, keynum, pszCurrentBinding );
+}
+
diff --git a/game/client/tf2/clientmode_commander.h b/game/client/tf2/clientmode_commander.h
new file mode 100644
index 0000000..871dd0c
--- /dev/null
+++ b/game/client/tf2/clientmode_commander.h
@@ -0,0 +1,146 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( CLIENTMODE_COMMANDER_H )
+#define CLIENTMODE_COMMANDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "clientmode_tfbase.h"
+#include <vgui/Cursor.h>
+#include "hud_minimap.h"
+#include <vgui_controls/Panel.h>
+
+class IMaterial;
+class CCommanderViewportPanel;
+class Vector;
+class CCommanderOverlayPanel;
+namespace vgui
+{
+	class Panel;
+	class AnimationController;
+}
+
+class CClientModeCommander : public ClientModeTFBase, public IMinimapClient
+{
+	DECLARE_CLASS( CClientModeCommander, ClientModeTFBase );
+
+// IClientMode overrides.
+public:
+	
+					CClientModeCommander();
+	virtual			~CClientModeCommander();
+
+	virtual void	Init( void );
+
+	virtual void	Enable();
+	virtual void	Disable();
+	
+	virtual void	Update();
+	virtual void	Layout();
+
+	virtual bool	ShouldDrawFog( void );
+	virtual void	OverrideView( CViewSetup *pSetup );
+	virtual void	CreateMove( float flInputSampleTime, CUserCmd *cmd );
+	virtual void	LevelInit( const char *newmap );
+	virtual void	LevelShutdown( void );
+	virtual bool	ShouldDrawEntity(C_BaseEntity *pEnt);
+	virtual bool	ShouldDrawDetailObjects( );
+	virtual bool	ShouldDrawLocalPlayer( C_BasePlayer *pPlayer );
+	virtual bool	ShouldDrawViewModel( void );
+	virtual bool	ShouldDrawCrosshair( void );
+	virtual bool	ShouldDrawParticles( );
+
+	virtual void	AdjustEngineViewport( int& x, int& y, int& width, int& height );
+	virtual void	PreRender( CViewSetup *pSetup );
+	virtual void	PostRenderWorld();
+	virtual void	PostRender( void );
+	virtual vgui::Panel		*GetViewport();
+	virtual vgui::AnimationController *GetViewportAnimationController() { return NULL; }
+
+	// Input
+	virtual int		KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
+
+	// Makes the mouse sit over a particular world location
+	void	MoveMouse( Vector& worldPos );
+
+	// Inherited from IMinimapClient
+	virtual void MinimapClicked( const Vector& clickWorldPos );
+
+	CCommanderOverlayPanel	*GetCommanderOverlayPanel( void );
+
+	virtual vgui::Panel *GetMinimapParent( void );
+
+private:
+	float	GetScaledSlueSpeed( void );
+	void	ResetCommand( CUserCmd *cmd );
+	float	Commander_ResampleMove( float in );
+	void	IsometricMove( CUserCmd *cmd );
+	float	GetHeightForMap( float zoom );
+
+	// Fills in ortho parameters (and near/far Z) in pSetup for how the commander mode renders the world.
+	bool			GetOrthoParameters(CViewSetup *pSetup);
+
+	CCommanderViewportPanel *GetCommanderViewport();
+
+private:
+
+	ConVar*	m_pClear;
+	ConVar*	m_pSkyBox;
+	float	m_fOldClear;
+	float	m_fOldSkybox;
+
+	int		m_LastMouseX;
+	int		m_LastMouseY;
+
+	float	m_ScaledMouseSpeed;
+	float	m_ScaledSlueSpeed;
+	float	m_Log_BaseEto2;	// scales logarithms from base E to base 2.
+};
+
+
+//-----------------------------------------------------------------------------
+// The panel responsible for rendering the 3D view in orthographic mode
+//-----------------------------------------------------------------------------
+class CCommanderViewportPanel : public CBaseViewport
+{
+	typedef CBaseViewport BaseClass;
+
+// Panel overrides.
+public:
+					CCommanderViewportPanel( void );
+	virtual			~CCommanderViewportPanel( void );
+
+	void			Enable( void );
+	void			Disable( void );
+	void			SetCommanderView( CClientModeCommander *commander );
+	void			MinimapClicked( const Vector& clickWorldPos );
+
+	CCommanderOverlayPanel	*GetCommanderOverlayPanel( void );
+
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
+	{
+		BaseClass::ApplySchemeSettings( pScheme );
+
+		gHUD.InitColors( pScheme );
+	}
+
+private:
+
+	CCommanderOverlayPanel	*m_pOverlayPanel;
+	CClientModeCommander	*m_pCommanderView;
+
+	vgui::HCursor	m_CursorCommander;
+	vgui::HCursor	m_CursorRightMouseMove;
+
+};
+
+IClientMode *ClientModeCommander();
+
+#endif // CLIENTMODE_COMMANDER_H
\ No newline at end of file
diff --git a/game/client/tf2/clientmode_tfbase.cpp b/game/client/tf2/clientmode_tfbase.cpp
new file mode 100644
index 0000000..e702129
--- /dev/null
+++ b/game/client/tf2/clientmode_tfbase.cpp
@@ -0,0 +1,223 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//===========================================================================//
+#include "cbase.h"
+#include "clientmode_tfbase.h"
+#include "hud.h"
+#include "c_tf_basecombatweapon.h"
+#include "keydefs.h"
+#include "c_tf_hintmanager.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/IScheme.h>
+#include "filesystem.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+CMinimapPanel *ClientModeTFBase::m_pMinimap = NULL;
+vgui::HScheme g_hVGuiObjectScheme = 0;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+ClientModeTFBase::ClientModeTFBase( void )
+{
+	m_bInitialized = false;
+
+	m_pCVDrawFullSkybox = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+ClientModeTFBase::~ClientModeTFBase( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CMinimapPanel
+//-----------------------------------------------------------------------------
+CMinimapPanel *ClientModeTFBase::GetMinimap( void )
+{
+	return m_pMinimap;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+// FIXME: Remove if this ever becomes true for HL2 (I expect it will)
+ConVar 	r_radiosity		( "r_radiosity", "2" );		// do full radiosity calc?
+// FIXME: Remove when we reactivate detail props
+extern ConVar r_DrawDetailProps;
+
+void ClientModeTFBase::Init()
+{
+	BaseClass::Init();
+	C_BaseTFCombatWeapon::CreateCrosshairPanels();
+
+	// FIXME: For playtests, turn off detail props. They're causing perf problems
+	r_DrawDetailProps.SetValue("0");
+
+	// Turn lighting into a mode where we use better computation for the ambient
+	// cube on static props, and a cheap one for dynamic entities.
+ 	r_radiosity.SetValue("3");
+
+	if ( !m_pMinimap )
+	{
+		m_pMinimap = GET_HUDELEMENT( CMinimapPanel );
+	}
+
+	// Load up the object control panel scheme
+	g_hVGuiObjectScheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ObjectControlPanelScheme.res", "TFBase" );
+	if (!g_hVGuiObjectScheme)
+	{
+		Warning( "Couldn't load control panel scheme!\n" );
+	}
+
+	// Load the objects.txt file.
+	LoadObjectInfos( ::filesystem );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ClientModeTFBase::Shutdown()
+{
+	C_BaseTFCombatWeapon::DestroyCrosshairPanels();
+	BaseClass::Shutdown();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ClientModeTFBase::Enable( void )
+{
+	BaseClass::Enable();
+
+	// Hook the minimap traces into the minimap
+	if ( GetMinimap() )
+	{
+		GetMinimap()->Activate();
+	}
+}
+
+void ClientModeTFBase::LevelInit( const char *newmap )
+{
+	BaseClass::LevelInit( newmap );
+
+	// Tell the radar to load the radar's overlay map
+	//g_Radar.LoadMap( newmap );
+	if ( GetMinimap() )
+	{
+		GetMinimap()->LevelInit( newmap );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ClientModeTFBase::LevelShutdown( void )
+{
+	BaseClass::LevelShutdown();
+
+	if ( GetMinimap() )
+	{
+		GetMinimap()->LevelShutdown();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pSetup - 
+//-----------------------------------------------------------------------------
+void ClientModeTFBase::PreRender( CViewSetup *pSetup )
+{
+	Initialize();
+
+	if ( !m_pCVDrawFullSkybox )
+	{
+		assert( 0 );
+		return;
+	}
+
+	m_flOldDrawFullSkybox = m_pCVDrawFullSkybox->GetFloat();
+
+	m_pCVDrawFullSkybox->SetValue( 1 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ClientModeTFBase::PostRender( void )
+{
+	C_BaseTFPlayer *pl = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pl )
+	{
+		pl->UpdateTargetReticles();
+	}
+
+	if ( !m_pCVDrawFullSkybox )
+	{
+		assert( 0 );
+		return;
+	}
+
+	m_pCVDrawFullSkybox->SetValue( m_flOldDrawFullSkybox );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ClientModeTFBase::Initialize( void )
+{
+	if ( m_bInitialized )
+		return;
+	m_bInitialized = true;
+
+	m_pCVDrawFullSkybox = (ConVar *)cvar->FindVar( "r_drawfullskybox" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ClientModeTFBase::Update( void )
+{
+	BaseClass::Update();
+	
+	MapData().Update();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: We've received a keypress from the engine. Return 1 if the engine is allowed to handle it.
+//-----------------------------------------------------------------------------
+int	ClientModeTFBase::KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
+{
+	if ( engine->Con_IsVisible() == false )
+	{
+		// Let hint system snag first escape key release
+		if ( down && ( keynum == KEY_ENTER ) && HintSystemEscapeKey() )
+		{
+			return 0;
+		}
+
+		// Has the player hit one of his Order keys?
+		if ( pszCurrentBinding && strncmp( pszCurrentBinding, "order", 5 ) == 0 )
+		{
+			if ( down )
+			{
+				//int iOrderNumber = (pszCurrentBinding[6] - '0') - 1;
+				//GetHudOrderList()->SelectOrder( iOrderNumber );
+			}
+			return 0;
+		}
+	}
+
+	return BaseClass::KeyInput( down, keynum, pszCurrentBinding );
+}
+
diff --git a/game/client/tf2/clientmode_tfbase.h b/game/client/tf2/clientmode_tfbase.h
new file mode 100644
index 0000000..f0f5c2a
--- /dev/null
+++ b/game/client/tf2/clientmode_tfbase.h
@@ -0,0 +1,68 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef CLIENTMODE_TFBASE_H
+#define CLIENTMODE_TFBASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "clientmode_shared.h"
+
+class ConVar;
+class CMinimapPanel;
+
+namespace vgui
+{
+	typedef unsigned long HScheme;
+}
+
+
+// This class defines the base clientmode behavior in TF. Classes that derive from
+// it and override functions should forward them to the base class.
+class ClientModeTFBase : public ClientModeShared
+{
+	DECLARE_CLASS( ClientModeTFBase, ClientModeShared );
+public:
+					ClientModeTFBase( void );
+	virtual			~ClientModeTFBase( void );
+
+	virtual void	Init();
+	virtual void	Shutdown();
+
+	virtual void	Enable();
+	
+	virtual void	PreRender( CViewSetup *pSetup );
+	virtual void	PostRender();
+	virtual	void	Update();
+
+	virtual void	LevelInit( const char *newmap );
+	virtual void	LevelShutdown( void );
+
+	// Input
+	virtual int		KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
+
+	virtual CMinimapPanel	*GetMinimap( void );
+
+	virtual vgui::Panel *GetMinimapParent( void ) = 0;
+
+private:
+	void			Initialize( void );
+
+	bool			m_bInitialized;
+
+	ConVar			*m_pCVDrawFullSkybox;
+
+	float			m_flOldDrawFullSkybox;
+
+	static CMinimapPanel	*m_pMinimap;
+};
+
+
+extern vgui::HScheme g_hVGuiObjectScheme;
+
+#endif // CLIENTMODE_TFBASE_H
diff --git a/game/client/tf2/clientmode_tfnormal.cpp b/game/client/tf2/clientmode_tfnormal.cpp
new file mode 100644
index 0000000..f766e4e
--- /dev/null
+++ b/game/client/tf2/clientmode_tfnormal.cpp
@@ -0,0 +1,173 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Normal HUD mode
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud_chat.h"
+#include "clientmode_tfnormal.h"
+#include "clientmode.h"
+#include "hud.h"
+#include "iinput.h"
+#include "c_basetfplayer.h"
+#include "hud_timer.h"
+#include "usercmd.h"
+#include "in_buttons.h"
+#include "c_tf_playerclass.h"
+#include "engine/IEngineSound.h"
+#include <vgui/IInput.h>
+#include <vgui/IPanel.h>
+#include <vgui_controls/AnimationController.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Instance the singleton and expose the interface to it.
+// Output : IClientMode
+//-----------------------------------------------------------------------------
+IClientMode *GetClientModeNormal( void )
+{
+	static ClientModeTFNormal g_ClientModeNormal;
+	return &g_ClientModeNormal;
+}
+
+ClientModeTFNormal::ClientModeTFNormal()
+{
+	m_pViewport = new Viewport();
+	m_pViewport->Start( gameuifuncs, gameeventmanager );
+}
+
+ClientModeTFNormal::Viewport::Viewport()
+{
+	// use a custom scheme for the hud
+	m_bHumanScheme = true;
+	vgui::HScheme scheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientSchemeHuman.res", "HudScheme");
+	SetScheme(scheme);
+}
+
+void ClientModeTFNormal::Viewport::OnThink()
+{
+	BaseClass::OnThink();
+
+	// See if scheme should change
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if(!pPlayer)
+		return;
+	int team = pPlayer->GetTeamNumber();
+	if ( !team )
+		return;
+
+	bool human = ( team == TEAM_HUMANS ) ? true : false;
+	if ( human != m_bHumanScheme )
+	{
+		ReloadScheme();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ClientModeTFNormal::Viewport::ReloadScheme()
+{
+	// See if scheme should change
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+
+	if(!pPlayer)
+		return;
+
+	const char *schemeFile = NULL;
+
+	int team = pPlayer->GetTeamNumber();
+	if ( team )
+	{
+		m_bHumanScheme = ( team == TEAM_HUMANS ) ? true : false;
+
+		if ( m_bHumanScheme )
+		{
+			schemeFile = "resource/ClientSchemeHuman.res";
+		}
+		else
+		{
+			schemeFile = "resource/ClientSchemeAlien.res";
+		}
+	}
+
+//	BaseClass::ReloadScheme( schemeFile );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : vgui::Panel
+//-----------------------------------------------------------------------------
+vgui::Panel *ClientModeTFNormal::GetMinimapParent( void )
+{
+	return GetViewport();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void ClientModeTFNormal::Update()
+{
+	BaseClass::Update();
+	HudCommanderOverlayMgr()->Tick( );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : frametime - 
+//			*cmd - 
+//-----------------------------------------------------------------------------
+void ClientModeTFNormal::CreateMove( float flInputSampleTime, CUserCmd *cmd )
+{
+	// Let the player override the view.
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if(!pPlayer)
+		return;
+
+	// Let the player at it
+	pPlayer->CreateMove( flInputSampleTime, cmd );
+
+	// Handle knockdowns
+	if ( pPlayer->CheckKnockdownAngleOverride() )
+	{
+		QAngle ang;
+		pPlayer->GetKnockdownAngles( ang );
+
+		cmd->viewangles = ang;
+		engine->SetViewAngles( ang );
+
+		cmd->forwardmove = cmd->sidemove = cmd->upmove = 0;
+		// Only keep score if it's down
+		cmd->buttons &= ( IN_SCORE );
+	}
+
+	if ( pPlayer->GetPlayerClass() )
+	{
+		C_PlayerClass *pPlayerClass = pPlayer->GetPlayerClass();
+		pPlayerClass->CreateMove( flInputSampleTime, cmd );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool ClientModeTFNormal::ShouldDrawViewModel( void )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if(!pPlayer)
+		return false;
+
+	return pPlayer->ShouldDrawViewModel();
+}
+
+
+
+
+
diff --git a/game/client/tf2/clientmode_tfnormal.h b/game/client/tf2/clientmode_tfnormal.h
new file mode 100644
index 0000000..a2b4a34
--- /dev/null
+++ b/game/client/tf2/clientmode_tfnormal.h
@@ -0,0 +1,64 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#include <vgui/Cursor.h>
+#include "clientmode_tfbase.h"
+#include <vgui_controls/EditablePanel.h>
+
+namespace vgui
+{
+	class AnimationController;
+}
+
+
+class ClientModeTFNormal : public ClientModeTFBase
+{
+DECLARE_CLASS( ClientModeTFNormal, ClientModeTFBase );
+
+private:
+
+	class Viewport : public CBaseViewport
+	{
+	typedef CBaseViewport BaseClass;
+	// Panel overrides.
+	public:
+		Viewport();
+		virtual ~Viewport() {}
+
+		virtual void	OnThink();
+		void			ReloadScheme();
+
+		virtual void ApplySchemeSettings( vgui::IScheme *pScheme )
+		{
+			BaseClass::ApplySchemeSettings( pScheme );
+
+			gHUD.InitColors( pScheme );
+
+			SetPaintBackgroundEnabled( false );
+		}
+
+		virtual void CreateDefaultPanels( void ) { /* don't create any panels yet*/ };
+
+	private:
+		bool			m_bHumanScheme;
+	};
+
+// IClientMode overrides.
+public:
+
+	virtual void	Update();
+	virtual void	CreateMove( float flInputSampleTime, CUserCmd *cmd );
+	virtual bool	ShouldDrawViewModel( void );
+		
+	virtual vgui::Panel *GetMinimapParent( void );
+
+	ClientModeTFNormal();
+};
+
+extern IClientMode *GetClientModeNormal();
\ No newline at end of file
diff --git a/game/client/tf2/commanderoverlay.cpp b/game/client/tf2/commanderoverlay.cpp
new file mode 100644
index 0000000..3dbed6e
--- /dev/null
+++ b/game/client/tf2/commanderoverlay.cpp
@@ -0,0 +1,220 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "CommanderOverlay.h"
+#include "utlsymbol.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Singleton class responsible for managing overlay elements 
+//-----------------------------------------------------------------------------
+					  
+class CHudCommanderOverlayMgrImp : public IHudCommanderOverlayMgr
+{
+public:
+	// constructor, destructor
+	CHudCommanderOverlayMgrImp();
+	virtual ~CHudCommanderOverlayMgrImp();
+
+	// Call this when the game starts up + shuts down
+	virtual void GameInit();
+	virtual void GameShutdown();
+
+	// Call this when the level starts up + shuts down
+	virtual void LevelInit( );
+	virtual void LevelShutdown();
+
+	// add an overlay element to the commander mode
+	virtual OverlayHandle_t AddOverlay( char const* pOverlayName, C_BaseEntity* pEntity, vgui::Panel *pParent );
+
+	// removes a particular overlay
+	virtual void RemoveOverlay( OverlayHandle_t handle );
+
+	// Call this once a frame...
+	virtual void Tick( );
+
+	// Call this when commander mode is enabled or disabled
+	virtual void Enable( bool enable );
+
+private:
+	struct OverlayPanel_t
+	{
+		unsigned short	m_Team;
+		CUtlSymbol		m_Name;
+		vgui::Panel		*m_pPanel;
+		vgui::Panel		*m_pParentPanel;
+		EHANDLE			m_hEntity;
+	};
+
+	// Create, destroy panels
+	void CreatePanel( int overlay );
+	void DestroyPanel( int overlay );
+
+	// No copy constructor
+	CHudCommanderOverlayMgrImp( const CHudCommanderOverlayMgrImp& );
+
+	// List of actual overlays currently in service
+	// Linked list used so handle ids don't change
+	CUtlLinkedList< OverlayPanel_t, unsigned short > m_Overlays;
+};
+
+
+//-----------------------------------------------------------------------------
+// Returns the singleton commander overlay interface
+//-----------------------------------------------------------------------------
+IHudCommanderOverlayMgr* HudCommanderOverlayMgr()
+{
+	static CHudCommanderOverlayMgrImp s_OverlayImp;
+	return &s_OverlayImp;
+}
+
+
+//-----------------------------------------------------------------------------
+// constructor, destructor
+//-----------------------------------------------------------------------------
+CHudCommanderOverlayMgrImp::CHudCommanderOverlayMgrImp()
+{
+}
+
+CHudCommanderOverlayMgrImp::~CHudCommanderOverlayMgrImp()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Call this when the game starts up or shuts down...
+//-----------------------------------------------------------------------------
+#define OVERLAY_FILE	"scripts/commander_overlays.txt"
+
+void CHudCommanderOverlayMgrImp::GameInit()
+{
+	// Read in all overlay metaclasses...
+	PanelMetaClassMgr()->LoadMetaClassDefinitionFile( OVERLAY_FILE );
+}
+
+void CHudCommanderOverlayMgrImp::GameShutdown()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Call this when the level starts up + shuts down
+//-----------------------------------------------------------------------------
+void CHudCommanderOverlayMgrImp::LevelInit( )
+{
+}
+
+
+void CHudCommanderOverlayMgrImp::LevelShutdown()
+{
+	// Remove all panels....
+	for( unsigned short i = m_Overlays.Head(); i != m_Overlays.InvalidIndex(); i = m_Overlays.Next(i) )
+	{
+		DestroyPanel(i);
+	}
+	m_Overlays.RemoveAll();
+}
+
+
+//-----------------------------------------------------------------------------
+// Create, destroy panel...
+//-----------------------------------------------------------------------------
+void CHudCommanderOverlayMgrImp::CreatePanel( int overlay )
+{
+	Assert( m_Overlays.IsValidIndex(overlay) );
+	OverlayPanel_t& panel = m_Overlays[overlay];
+
+	// Chain keyvalues with name Team#
+	char pTeamName[6] = "Team ";
+	pTeamName[4] = '0' + panel.m_Team;
+
+	vgui::Panel *pPanel = PanelMetaClassMgr()->CreatePanelMetaClass( 
+		panel.m_Name.String(), 0, panel.m_hEntity.Get(), panel.m_pParentPanel, pTeamName );
+	m_Overlays[overlay].m_pPanel = pPanel;
+}
+
+void CHudCommanderOverlayMgrImp::DestroyPanel( int overlay )
+{
+	Assert( m_Overlays.IsValidIndex(overlay) );
+	OverlayPanel_t& panel = m_Overlays[overlay];
+	if (panel.m_pPanel)
+	{
+		PanelMetaClassMgr()->DestroyPanelMetaClass(	panel.m_pPanel );
+		m_Overlays[overlay].m_pPanel = NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// add an overlay element to the commander mode
+//-----------------------------------------------------------------------------
+OverlayHandle_t CHudCommanderOverlayMgrImp::AddOverlay( 
+	char const* pOverlayInstance, C_BaseEntity* pEntity, vgui::Panel *pParent )
+{
+	OverlayPanel_t newPanel;
+	newPanel.m_Name = pOverlayInstance;
+	newPanel.m_pPanel = NULL;
+	newPanel.m_Team = (unsigned short)~0;
+	newPanel.m_hEntity = pEntity;
+	newPanel.m_pParentPanel = pParent;
+	return m_Overlays.AddToTail( newPanel );
+}
+
+
+//-----------------------------------------------------------------------------
+// removes a particular overlay
+//-----------------------------------------------------------------------------
+void CHudCommanderOverlayMgrImp::RemoveOverlay( OverlayHandle_t handle )
+{
+	if ((handle == OVERLAY_HANDLE_INVALID) || (!m_Overlays.IsValidIndex(handle)) )
+		return;
+
+	// Deallocate the panel
+	DestroyPanel( handle );
+
+	// Remove it from our list
+	m_Overlays.Remove( handle );
+}
+
+
+//-----------------------------------------------------------------------------
+// make our sprites visible when we are enabled
+//-----------------------------------------------------------------------------
+void CHudCommanderOverlayMgrImp::Enable( bool enable )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Call this once a frame...
+//-----------------------------------------------------------------------------
+void CHudCommanderOverlayMgrImp::Tick( )
+{
+	if ( !engine->IsInGame() )
+		return;
+
+	// Iterate through all overlays
+	for( unsigned short i = m_Overlays.Head(); i != m_Overlays.InvalidIndex(); i = m_Overlays.Next(i) )
+	{
+		// Kill panels attached to dead entities...
+		if (!m_Overlays[i].m_hEntity)
+		{
+			DestroyPanel( i );
+			continue;
+		}
+
+		// make sure the panels are up-to-date based on current entity team
+		if (m_Overlays[i].m_Team != m_Overlays[i].m_hEntity->GetTeamNumber())
+		{
+			// Destroy the old team panel, create the new team panel
+			DestroyPanel( i );
+			m_Overlays[i].m_Team = m_Overlays[i].m_hEntity->GetTeamNumber();
+			CreatePanel( i );
+		}
+	}
+}
+
diff --git a/game/client/tf2/commanderoverlay.h b/game/client/tf2/commanderoverlay.h
new file mode 100644
index 0000000..c477c8c
--- /dev/null
+++ b/game/client/tf2/commanderoverlay.h
@@ -0,0 +1,153 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+
+#if !defined( COMMANDEROVERLAY_H )
+#define COMMANDEROVERLAY_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "panelmetaclassmgr.h"
+
+
+//-----------------------------------------------------------------------------
+// forward declarations
+//-----------------------------------------------------------------------------
+class C_BaseEntity;
+class KeyValues;
+
+
+//-----------------------------------------------------------------------------
+// Overlay handle
+//-----------------------------------------------------------------------------
+
+typedef unsigned short OverlayHandle_t;
+enum
+{
+	OVERLAY_HANDLE_INVALID = (OverlayHandle_t)~0
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Singleton class responsible for managing overlay elements 
+//-----------------------------------------------------------------------------
+class IHudCommanderOverlayMgr
+{
+public:
+//	// Call this when the game starts up + shuts down
+	virtual void GameInit() = 0;
+	virtual void GameShutdown() = 0;
+
+	// Call this when the level starts up + shuts down
+	virtual void LevelInit( ) = 0;
+	virtual void LevelShutdown() = 0;
+
+	// add an overlay element to the commander mode, returns a handle to it
+	virtual OverlayHandle_t AddOverlay( char const* pOverlayName, C_BaseEntity* pEntity, vgui::Panel *pParent = NULL ) = 0;
+
+	// removes a particular overlay
+	virtual void RemoveOverlay( OverlayHandle_t handle ) = 0;
+
+	// Call this once a frame...
+	virtual void Tick( ) = 0;
+
+	// Call this when commander mode is enabled or disabled
+	virtual void Enable( bool enable ) = 0;
+
+protected:
+	// Don't delete me!
+	virtual ~IHudCommanderOverlayMgr() {}
+};
+
+
+//-----------------------------------------------------------------------------
+// Returns the singleton commander overlay interface
+//-----------------------------------------------------------------------------
+IHudCommanderOverlayMgr* HudCommanderOverlayMgr();
+
+
+//-----------------------------------------------------------------------------
+// Helper class for entities to join the list of entities to render on screen
+//-----------------------------------------------------------------------------
+class CPanelRegistration
+{
+public:
+	CPanelRegistration( ) : m_Overlay(OVERLAY_HANDLE_INVALID) {}
+
+	~CPanelRegistration()
+	{
+		HudCommanderOverlayMgr()->RemoveOverlay( m_Overlay );
+	}
+
+	void Activate( C_BaseEntity* pEntity, char const* pOverlayName, bool active )
+	{
+		if( active )
+		{
+			AddOverlay( pEntity, pOverlayName );
+		}
+		else
+		{
+			RemoveOverlay();
+		}
+	}
+
+	void Activate( C_BaseEntity* pEntity, char const* pOverlayName, vgui::Panel *pParent, int sortOrder, bool active )
+	{
+		if( active )
+		{
+			AddOverlay( pEntity, pOverlayName, pParent );
+		}
+		else
+		{
+			RemoveOverlay();
+		}
+	}
+
+
+	void AddOverlay( C_BaseEntity *pEntity, const char *pOverlayName, vgui::Panel *pParent = NULL )
+	{
+		RemoveOverlay();
+		m_Overlay = HudCommanderOverlayMgr()->AddOverlay( pOverlayName, pEntity, pParent );
+	}
+
+	void RemoveOverlay()
+	{
+		if( m_Overlay != OVERLAY_HANDLE_INVALID )
+		{
+			HudCommanderOverlayMgr()->RemoveOverlay( m_Overlay );
+			m_Overlay = OVERLAY_HANDLE_INVALID;
+		}
+	}
+
+
+private:
+	OverlayHandle_t m_Overlay;
+};
+
+
+//-----------------------------------------------------------------------------
+// Macros for help with simple registration of panels
+// Put DECLARE_ENTITY_PANEL() in your class definition
+// and ENTITY_PANEL_ACTIVATE( "name" ) in the entity's SetDormant call
+//-----------------------------------------------------------------------------
+#define DECLARE_ENTITY_PANEL()							CPanelRegistration m_OverlayPanel
+#define ENTITY_PANEL_ACTIVATE( _pOverlayName, _active )	m_OverlayPanel.Activate( this, _pOverlayName, _active )
+
+
+//-----------------------------------------------------------------------------
+// Helper macro to make overlay factories one line of code. Use like this:
+//	DECLARE_OVERLAY_FACTORY( CEntityImagePanel, "image" );
+//-----------------------------------------------------------------------------
+#define DECLARE_OVERLAY_FACTORY( _PanelClass, _nameString )	\
+	DECLARE_PANEL_FACTORY( _PanelClass, C_BaseEntity, _nameString )
+
+#define DECLARE_OVERLAY_POINT_FACTORY( _PanelClass, _nameString )	\
+	DECLARE_PANEL_FACTORY( _PanelClass, void, _nameString )
+
+
+#endif // COMMANDEROVERLAY_H
\ No newline at end of file
diff --git a/game/client/tf2/commanderoverlaypanel.cpp b/game/client/tf2/commanderoverlaypanel.cpp
new file mode 100644
index 0000000..5ef2914
--- /dev/null
+++ b/game/client/tf2/commanderoverlaypanel.cpp
@@ -0,0 +1,1018 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+//-----------------------------------------------------------------------------
+// The panel responsible for rendering the 3D view in orthographic mode
+//-----------------------------------------------------------------------------
+#include "cbase.h"
+#include <vgui/VGUI.h>
+#include <vgui_controls/Controls.h>
+#include <vgui/IVGui.h>
+#include <vgui/IInput.h>
+#include <vgui/ISurface.h>
+#include "clientmode_commander.h"
+#include "vgui_int.h"
+#include "iinput.h"
+#include "kbutton.h"
+#include "hud_minimap.h"
+#include "usercmd.h"
+#include "mapdata.h"
+#include "c_basetfplayer.h"
+#include "view.h"
+#include "view_shared.h"
+#include "CommanderOverlay.h"
+#include "C_TfTeam.h"
+#include <vgui/MouseCode.h>
+#include <vgui/KeyCode.h>
+#include <vgui/IPanel.h>
+#include "commanderoverlaypanel.h"
+#include "PixelWriter.h"
+#include "materialsystem/imaterialvar.h"
+#include "materialsystem/itexture.h"
+#include "vtf/vtf.h"
+#include "engine/ivdebugoverlay.h"
+
+
+static inline int AlphaMapIndex(int x, int y)
+{
+	return y * FOG_ALPHAMAP_SIZE + x;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *commander - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::SetCommanderView( CClientModeCommander *commander )
+{
+	m_pCommanderView = commander;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCommanderOverlayPanel::CCommanderOverlayPanel( void ) :
+	vgui::Panel( NULL, "CommanderOverlayPanel" ),
+	m_CursorCommander(vgui::dc_arrow),
+	m_CursorRightMouseMove(vgui::dc_hand)
+{
+	MakePopup();
+
+	SetPaintBackgroundEnabled( false );
+	m_left.m_bMouseDown = false;
+	m_left.m_nXStart = 0;
+	m_left.m_nYStart = 0;
+
+	m_right.m_bMouseDown = false;
+	m_right.m_nXStart = 0;
+	m_right.m_nYStart = 0;
+
+	m_fZoom = 0;
+
+	m_flPreviousMaxWorldWidth = 0.0f;
+	SetVisible( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCommanderOverlayPanel::~CCommanderOverlayPanel( void )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialize rendering origin 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::InitializeRenderOrigin()
+{
+	// Initializes the rendering origin
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( player )
+	{
+		m_vecTacticalOrigin = player->GetAbsOrigin();
+	}
+	else
+	{
+		MapData().GetMapOrigin( m_vecTacticalOrigin );
+	}
+
+	Vector mins, maxs;
+	MapData().GetMapBounds( mins, maxs );
+	m_vecTacticalOrigin.z = maxs.z + TACTICAL_ZOFFSET;
+	m_vecTacticalAngles.Init( 90, 90, 0 );
+	BoundOrigin( m_vecTacticalOrigin );
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the view range: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::ComputeZoomRange()
+{
+	// This is 
+	m_MinWorldWidth = TACTICAL_MIN_VIEWABLE_SIZE;
+
+	// Get the world size
+	Vector mins, maxs, size;
+	MapData().GetMapBounds( mins, maxs );
+	VectorSubtract( maxs, mins, size );
+	float worldAspect = size[0] / size[1];
+
+//	size[ 0 ] *= 1.05f;
+//	size[ 1 ] *= 1.05f;
+
+	// Find out the panel aspect ratio
+	int w, h;
+	GetVisibleSize( w, h );
+
+	float panelAspect = (float)w / (float)h;
+
+	// Store off old zoom
+	m_flPreviousMaxWorldWidth = m_MaxWorldWidth;
+
+	if (panelAspect > worldAspect)
+	{
+		// In this case, to see the whole map, 
+		// we'll have black areas on the left + right sides
+		// Make sure we choose a width big enough to display the entire height
+		m_MaxWorldWidth = size[1] * panelAspect;
+	}
+	else
+	{
+		// In this case, to see the whole map, 
+		// we'll have black areas on the top + bottom
+		// Make sure we choose a width big enough to display the entire height
+		m_MaxWorldWidth = size[0];
+	}
+
+	// if flipping open/close the tech tree, preserver relative zoom amount
+	if ( m_flPreviousMaxWorldWidth )
+	{
+		float ratio = m_MaxWorldWidth / m_flPreviousMaxWorldWidth;
+
+		m_fZoom *= ratio;
+	}
+}	
+
+//-----------------------------------------------------------------------------
+// Call when the map changes
+//-----------------------------------------------------------------------------
+
+void CCommanderOverlayPanel::LevelInit( char const* pMapName )
+{
+	// Always look at the entire map to start with
+	m_fZoom = 0;
+	m_flPreviousMaxWorldWidth = 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::LevelShutdown( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// call these when commander view is enabled/disabled
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::Enable()
+{
+	vgui::VPANEL pRoot = VGui_GetClientDLLRootPanel();
+
+	SetCursor(m_CursorCommander);
+	SetVisible( true );
+
+	// Make the viewport fill the root panel.
+	if( pRoot)
+	{
+		int wide, tall;
+		vgui::ipanel()->GetSize(pRoot, wide, tall);
+
+		// subtract out the technology UI size
+		tall -= 0;// xxx200
+
+		SetBounds(0, 0, wide, tall);
+	}
+
+	// Cache the orthographic view size range
+	ComputeZoomRange();
+
+	// Start out looking at the whole world
+	if (m_fZoom == 0)
+		m_fZoom = m_MaxWorldWidth;
+
+	// clamp
+	if (m_fZoom < m_MinWorldWidth)
+		m_fZoom = m_MinWorldWidth;
+	else if (m_fZoom > m_MaxWorldWidth)
+		m_fZoom = m_MaxWorldWidth;
+
+	// Figure out where the camera is
+	InitializeRenderOrigin();
+
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::Disable()
+{
+	SetVisible( false );
+	// FIXME: Need a removeTickSignal!
+//	vgui::ivgui()->removeTickSignal( GetVPanel() );
+}
+
+
+//-----------------------------------------------------------------------------
+// called when we're ticked...
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::OnTick()
+{
+	if (!IsLocalPlayerInTactical() || !engine->IsInGame())
+		return;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns up to 32 players encoded as a bit per player in a 32 bit unsigned
+// Output : unsigned int
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::GetSelectedPlayerBitField( CBitVec< MAX_PLAYERS >& bits )
+{
+	CMapPlayers *pPlayer;
+
+	bits.ClearAll();
+
+	// draw all the visible players
+	for ( int playerNum = 0; playerNum < MAX_PLAYERS; playerNum++ )
+	{
+		pPlayer = &MapData().m_Players[ playerNum ];
+		if ( pPlayer->m_bSelected )
+		{
+			bits.Set( playerNum );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Counts how many players are selected
+// Output : int
+//-----------------------------------------------------------------------------
+int CCommanderOverlayPanel::CountSelectedPlayers( void )
+{
+	CMapPlayers *pPlayer;
+
+	// bitfield variable
+	int count = 0;
+
+	// draw all the visible players
+	for ( int playerNum = 0; playerNum < MAX_PLAYERS; playerNum++ )
+	{
+		pPlayer = &MapData().m_Players[ playerNum ];
+		if ( pPlayer->m_bSelected )
+		{
+			count++;
+		}
+	}
+
+	return count;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when a key is pressed
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::OnKeyPressed(vgui::KeyCode code)
+{
+	switch(code)
+	{
+	case vgui::KEY_SPACE:
+		if (m_fZoom != m_MaxWorldWidth)
+		{
+			ChangeZoomLevel(m_MaxWorldWidth);
+		}
+		else
+		{
+			Vector mouseWorldPos;
+			CenterOnMouse( mouseWorldPos );
+
+			ChangeZoomLevel(TACTICAL_SPACEBAR_VIEWABLE_SIZE);
+
+			// Place mouse over me
+			m_pCommanderView->MoveMouse( mouseWorldPos );
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: when space is hit, show the entire view
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::ChangeZoomLevel( float newZoom )
+{
+	// Make sure the mouse remains over the thing it started over
+
+	// Figure out worldspace movement based on picking ray
+	Vector rayOrigin, rayForward;
+
+	int mx, my;
+	GetMousePos( mx, my );
+
+	// Need to convert from screen space back to a worldspace ray
+	CreatePickingRay( 
+		mx, my, 
+		ScreenWidth(), ScreenHeight(),
+		CurrentViewOrigin(), 
+		CurrentViewAngles(),
+		rayOrigin,
+		rayForward );
+
+	m_fZoom = newZoom;
+
+	BoundOrigin( m_vecTacticalOrigin );
+
+	// move mouse to center and zero out any delta
+	m_pCommanderView->MoveMouse( rayOrigin );
+//	RequestFocus();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CCommanderOverlayPanel::IsRightMouseMapMoving( void )
+{
+	return m_right.m_bMouseDown;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::RightMouseMapMove( void )
+{
+	/*
+	// Figure out worldspace movement based on picking ray
+	Vector rayForward;
+	Vector vecEndPosCurrent, vecEndPosPrevious;
+
+	// Need to convert from screen space back to a worldspace ray
+	CreatePickingRay( 
+		m_right.m_nXCurrent, m_right.m_nYCurrent, 
+		ScreenWidth(), ScreenHeight(),
+		g_vecRenderOrigin, 
+		g_vecRenderAngles,
+		vecEndPosCurrent,
+		rayForward );
+
+	engine->Con_NPrintf( 8, "x %i y %i hit %.3f %.3f",
+		m_right.m_nXCurrent, m_right.m_nYCurrent, vecEndPosCurrent.x, vecEndPosCurrent.y );
+	*/
+
+	if ( !m_right.m_bMouseDown )
+		return;
+
+	/*
+	// See if there is a delta in the current and previous mouse positions
+	//
+	int dx, dy;
+
+	dx = m_right.m_nXCurrent - m_right.m_nXPrev;
+	dy = m_right.m_nYCurrent - m_right.m_nYPrev;
+
+	// No relative move
+	if ( !dx && !dy )
+		return;
+
+	// Figure out worldspace movement based on picking ray
+	Vector rayForward;
+	Vector vecEndPosCurrent, vecEndPosPrevious;
+
+	// Need to convert from screen space back to a worldspace ray
+	CreatePickingRay( 
+		m_right.m_nXCurrent, m_right.m_nYCurrent, 
+		ScreenWidth(), ScreenHeight(),
+		g_vecRenderOrigin, 
+		g_vecRenderAngles,
+		vecEndPosCurrent,
+		rayForward );
+
+	// Now create ray from old position
+	// Need to convert from screen space back to a worldspace ray
+	CreatePickingRay( 
+		m_right.m_nXPrev, m_right.m_nYPrev, 
+		ScreenWidth(), ScreenHeight(),
+		g_vecRenderOrigin, 
+		g_vecRenderAngles,
+		vecEndPosPrevious,
+		rayForward );
+
+	// Remove z component
+	vecEndPosPrevious.z = 0.0;
+	vecEndPosCurrent.z = 0.0;
+
+	// Compute offset
+	Vector viewDelta;
+	VectorSubtract( vecEndPosCurrent, vecEndPosPrevious, viewDelta );
+
+	viewDelta.z = 0.0f;
+
+	VectorAdd( m_vecTacticalOrigin, viewDelta, m_vecTacticalOrigin );
+
+	m_pCommanderView->BoundOrigin( m_vecTacticalOrigin );
+	*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Right mouse button down
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::RightMousePressed( void )
+{
+	if ( m_left.m_bMouseDown || m_right.m_bMouseDown )
+		return;
+
+	SetCursor(m_CursorRightMouseMove);
+
+	StartMovingMouse( m_right );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::RightMouseReleased( void )
+{
+	if ( !m_right.m_bMouseDown )
+		return;
+
+	m_right.m_bMouseDown = false;
+	int mx, my;
+	GetMousePos( mx, my );
+	UpdateMousePos( mx, my, m_right );
+
+	// Final move
+	RightMouseMapMove();
+
+	vgui::input()->SetMouseCapture( NULL );
+
+	SetCursor(m_CursorCommander);
+
+	// If the player's dead, and doesn't have the special sniper upgrade
+	// then check for respawn stations....
+ 	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if (!pPlayer)
+		return;
+
+	// If the player's dead, abort
+	if ( pPlayer->PlayerClass() == TFCLASS_SNIPER )
+	{
+		// Sniper's can request a respawn point when dead
+		//
+		Vector rayOrigin, rayForward;
+		Vector vecEndPos;
+
+		// Need to convert from screen space back to a worldspace ray
+		CreatePickingRay( 
+			m_right.m_nXCurrent, m_right.m_nYCurrent, 
+			ScreenWidth(), ScreenHeight(),
+			CurrentViewOrigin(), 
+			CurrentViewAngles(),
+			rayOrigin,
+			rayForward );
+
+		// Now do the trace
+		trace_t tr;
+
+		vecEndPos = rayOrigin + rayForward * MAX_TRACE_LENGTH;
+
+		UTIL_TraceLine( rayOrigin, vecEndPos, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );
+
+		// Didn't hit anything
+		if ( tr.fraction == 1.0 )
+			return;
+
+		char cmd[ 128 ];
+		Q_snprintf( cmd, sizeof( cmd ), "respawnpoint %i %i %i\n",
+			(int)tr.endpos.x,
+			(int)tr.endpos.y,
+			(int)tr.endpos.z );
+
+		engine->ServerCmd( cmd );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//			mouse - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::UpdateMousePos( int x, int y, MouseDown_t& mouse )
+{
+	// store previous
+	mouse.m_nXPrev = mouse.m_nXCurrent;
+	mouse.m_nYPrev = mouse.m_nYCurrent;
+	// update current
+	mouse.m_nXCurrent = x;
+	mouse.m_nYCurrent = y;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::OnCursorMoved(int x, int y)
+{
+	UpdateMousePos( x, y, m_left );
+	UpdateMousePos( x, y, m_right );
+
+	RightMouseMapMove();
+//	RequestFocus();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::GetMousePos( int& x, int& y )
+{
+	vgui::input()->GetCursorPos( x, y );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mouse - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::StartMovingMouse( MouseDown_t& mouse )
+{
+	mouse.m_bMouseDown = true;
+	GetMousePos( mouse.m_nXStart, mouse.m_nYStart );
+
+	mouse.m_nXCurrent = mouse.m_nXPrev = mouse.m_nXStart;
+	mouse.m_nYCurrent = mouse.m_nYPrev = mouse.m_nYStart;
+
+	vgui::input()->SetMouseCapture( GetVPanel() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Left mouse button down
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::LeftMousePressed( void )
+{
+	if ( m_left.m_bMouseDown || m_right.m_bMouseDown )
+		return;
+
+	StartMovingMouse( m_left );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : code - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::OnMousePressed(vgui::MouseCode code)
+{
+	switch ( code )
+	{
+	case vgui::MOUSE_LEFT:
+		LeftMousePressed();
+		break;
+	case vgui::MOUSE_RIGHT:
+		RightMousePressed();
+		break;
+	default:
+		BaseClass::OnMousePressed( code );
+		return;
+	}
+
+//	RequestFocus();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x0 - 
+//			y0 - 
+//			x1 - 
+//			y1 - 
+//			true - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::SelectPlayersInRectangle( int x0, int y0, int x1, int y1, bool clearOldSelections /*= true*/ )
+{
+	int num_selected = 0;
+
+	// Assume zero players in selection
+	if ( clearOldSelections )
+	{
+		m_bHaveActiveSelection = false;
+	}
+	else
+	{
+		// Count # selected
+		num_selected = CountSelectedPlayers();
+	}
+
+	CMapPlayers *pPlayer;
+	C_BaseTFPlayer	*tf2player;
+
+	// See which players on my team are within the rectangle in screen space
+	//
+	for ( int playerNum = 1; playerNum <= MAX_PLAYERS; playerNum++ )
+	{
+		pPlayer = &MapData().m_Players[ playerNum - 1 ];
+
+		if ( clearOldSelections )
+		{
+			pPlayer->m_bSelected = false;
+		}
+
+		if ( playerNum > gpGlobals->maxClients )
+		{
+			continue;
+		}
+
+		tf2player = dynamic_cast<C_BaseTFPlayer *>( cl_entitylist->GetEnt( playerNum ) );
+		if ( !tf2player )
+		{
+			continue;
+		}
+
+		// Check pvs on this guy
+		// If the entity was in the commander's PVS then show it on the minimap, too
+		//
+		if ( ArePlayersOnSameTeam( engine->GetLocalPlayer(), playerNum ) == false )
+		{
+			continue;
+		}
+
+		// Check their actual draw position
+		int drawX, drawY;
+		Vector pos, screen;
+
+		pos = tf2player->GetAbsOrigin();
+
+		// Transform
+		debugoverlay->ScreenPosition( pos, screen );
+
+		// FIXME: Get the player icon size from where?!?					
+		drawX = screen.x - 32;
+		drawY = screen.y - 40;
+		int intersectX = 64;
+		int intersectY = 64;
+
+		// Check for intersection ( with slop )
+		if ( drawX + intersectX < x0 )
+			continue;
+		if ( drawX > x1 )
+			continue;
+		if ( drawY + intersectY < y0 )
+			continue;
+		if ( drawY > y1 )
+			continue;
+
+		// Already selected?
+		if ( !pPlayer->m_bSelected )
+		{
+			// Add to selected list
+			pPlayer->m_bSelected = true;
+			num_selected++;
+		}
+	}
+
+	if ( num_selected != 0 )
+	{
+		m_bHaveActiveSelection = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Returns the visible area (not including the tech tree)
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::GetVisibleSize( int& w, int& h )
+{
+	GetSize( w, h );
+
+	// FIXME: Hack to make the map appear above the tech tree
+	h -= 200;
+}
+
+//-----------------------------------------------------------------------------
+// Returns the visible area (not including the tech tree)
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::GetVisibleArea( Vector& mins, Vector& maxs )
+{
+	float w, h;
+	GetVisibleOrthoSize( w, h );
+
+	ActualToVisibleOffset( mins );
+	mins += m_vecTacticalOrigin;
+	maxs = mins;
+	mins.x -= w; maxs.x +=w;
+	mins.y -= h; maxs.y +=h;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: User let go of left mouse button
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::LeftMouseReleased( void )
+{
+	if ( !m_left.m_bMouseDown )
+		return;
+
+	m_left.m_bMouseDown = false;
+
+	int mx, my;
+	GetMousePos( mx, my );
+	UpdateMousePos( mx, my, m_left );
+
+	vgui::input()->SetMouseCapture( NULL );
+
+	// Normalize the rectangle
+	int x0, y0, x1, y1;
+	x0 = MIN( m_left.m_nXStart, m_left.m_nXCurrent );
+	x1 = MAX( m_left.m_nXStart, m_left.m_nXCurrent );
+	y0 = MIN( m_left.m_nYStart, m_left.m_nYCurrent );
+	y1 = MAX( m_left.m_nYStart, m_left.m_nYCurrent );
+
+	bool clearOldStates = true;
+	if ( vgui::input()->IsKeyDown( vgui::KEY_LCONTROL ) )
+	{
+		clearOldStates = false;
+	}
+
+	SelectPlayersInRectangle( x0, y0, x1, y1, clearOldStates );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::GetOrthoRenderBox(Vector &vCenter, float &xSize, float &ySize)
+{
+	vCenter = m_vecTacticalOrigin;
+
+	// min and max depends on the current zoom level
+	int w, h;
+	GetParent()->GetSize( w, h );
+
+	xSize = m_fZoom;
+	ySize = xSize * ( (float)h / (float)w );
+
+	xSize *= 0.5f;
+	ySize *= 0.5f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::GetVisibleOrthoSize(float &xSize, float &ySize)
+{
+	// min and max depends on the current zoom level
+	int w, h;
+	GetVisibleSize( w, h );
+	xSize = m_fZoom;
+	ySize = xSize * ( (float)h / (float)w );
+
+	xSize *= 0.5f;
+	ySize *= 0.5f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CCommanderOverlayPanel::WorldUnitsPerPixel()
+{
+	int w, h;
+	GetParent()->GetSize( w, h );
+	return m_fZoom / w;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::ActualToVisibleOffset( Vector& offset )
+{
+	// FIXME: This doesn't work arbitrarily; we assume the visible
+	// part is on the top of the screen..
+	int w, h, wact, hact;
+	GetVisibleSize( w, h );
+	GetParent()->GetSize( wact, hact );
+	
+	float worldUnitsPerPixel = m_fZoom / wact;
+	float dWorldY = (hact - h) * 0.5f * worldUnitsPerPixel;
+	offset.Init( 0, dWorldY, 0 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Make sure origin is inside map x, y bounds ( not z )
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::BoundOrigin( Vector& camera )
+{
+	// We're going to do this entire computation assuming the camera
+	// is in the center of the viewable area, which it isn't. At the
+	// end, we'll need to apply a fixup to deal with that
+
+	Vector mins, maxs, halfsize;
+	MapData().GetMapBounds( mins, maxs );
+	VectorSubtract( maxs, mins, halfsize );
+	halfsize *= 0.5f;
+
+	// avoid black edges...
+	float dim[2];
+	GetVisibleOrthoSize( dim[0], dim[1] );
+
+	// Compute the position of the center of the visible area based on
+	// the new suggested camera position 
+	Vector actualToVisible, newVisCenter;
+	ActualToVisibleOffset( actualToVisible );
+	VectorAdd( camera, actualToVisible, newVisCenter );
+
+	// Only bound x & y
+	for ( int i = 0; i < 2; i++ )
+	{
+		if (dim[i] > halfsize[i])
+		{
+			newVisCenter[i] = mins[i] + halfsize[i];
+		}
+		else
+		{
+			newVisCenter[ i ] = MAX( newVisCenter[i], mins[i] + dim[i] );
+			newVisCenter[ i ] = MIN( newVisCenter[i], maxs[i] - dim[i] );
+		}
+	}
+
+	// Remember: The viewport takes up the entire screen; but the visible
+	// area only takes up the top half of the screen. Therefore, we need to
+	// set the origin so that the center of what we want lies at the
+	// center of the visible region
+	VectorSubtract( newVisCenter, actualToVisible, camera ); 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Given mouse/screen positions as well as the current
+//  render origin and angles, returns a unit vector through the mouse position
+//  that can be used to trace into the world under the mouse click pixel.
+// Input  : fov - 
+//			mousex - 
+//			mousey - 
+//			screenwidth - 
+//			screenheight - 
+//			vecRenderAngles - 
+//			c_x - 
+//			vpn - 
+//			vup - 
+//			360.0 - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::CreatePickingRay( int mousex, int mousey, 
+	int screenwidth, int screenheight,
+	const Vector& vecRenderOrigin, 
+	const QAngle& vecRenderAngles, 
+	Vector &rayOrigin,
+	Vector &rayDirection
+	)
+{
+	Vector vCenter;
+	float xSize, ySize;
+	GetOrthoRenderBox(vCenter, xSize, ySize);
+	
+	float xPos = RemapVal(mousex, 0, screenwidth,  vCenter.x-xSize, vCenter.x+xSize);
+	float yPos = RemapVal(mousey, 0, screenheight, vCenter.y+ySize, vCenter.y-ySize); // (flip screen y)
+	rayOrigin.Init(xPos, yPos, vCenter.z);
+	rayDirection.Init(0, 0, -1);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::OnMouseReleased(vgui::MouseCode code)
+{
+	switch ( code )
+	{
+	case vgui::MOUSE_LEFT:
+		LeftMouseReleased();
+		break;
+	case vgui::MOUSE_RIGHT:
+		RightMouseReleased();
+		break;
+	default:
+		BaseClass::OnMouseReleased( code );
+		return;
+	}
+
+//	RequestFocus();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::CenterOnMouse( Vector& mouseWorldPos )
+{
+	// Figure out worldspace movement based on picking ray
+	Vector rayForward;
+	Vector centerOrigin;
+
+	int mx, my;
+	GetMousePos( mx, my );
+
+	// Need to convert from screen space back to a worldspace ray
+	CreatePickingRay( 
+		mx, my, 
+		ScreenWidth(), ScreenHeight(),
+		CurrentViewOrigin(), 
+		CurrentViewAngles(),
+		mouseWorldPos,
+		rayForward );
+
+	CreatePickingRay( 
+		ScreenWidth()/2, ScreenHeight()/2, 
+		ScreenWidth(), ScreenHeight(),
+		CurrentViewOrigin(), 
+		CurrentViewAngles(),
+		centerOrigin,
+		rayForward );
+
+	Vector offset;
+	VectorSubtract( mouseWorldPos, centerOrigin, offset );
+	offset.z = 0.0f;
+	VectorAdd( m_vecTacticalOrigin, offset, m_vecTacticalOrigin );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : delta - 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::OnMouseWheeled(int delta)
+{
+	// Figure out worldspace movement based on picking ray
+	Vector rayOrigin;
+
+	CenterOnMouse( rayOrigin );
+
+	// Gotta do the zoom after picking the ray, or it'll use the wrong zoom factor
+	// for computing the picking ray
+	if ( delta < 0 )
+	{
+		m_fZoom *= 1.25f;
+	}
+	else if ( delta > 0 )
+	{
+		m_fZoom /= 1.25f;
+	}
+
+	m_fZoom = MIN( m_fZoom, m_MaxWorldWidth );
+	m_fZoom = MAX( m_fZoom, m_MinWorldWidth );
+
+	BoundOrigin( m_vecTacticalOrigin );
+
+	// move mouse to center and zero out any delta
+	m_pCommanderView->MoveMouse( rayOrigin );
+
+//	RequestFocus();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderOverlayPanel::Paint()
+{
+	if ( !m_left.m_bMouseDown )
+		return;
+
+	// Update mouse position, so we don't get the 1 frame lag
+	int mx, my;
+	GetMousePos( mx, my );
+	UpdateMousePos( mx, my, m_left );
+
+	int x0, x1, y0, y1;
+	// Make sure it's normalized
+	x0 = MIN( m_left.m_nXStart, m_left.m_nXCurrent );
+	x1 = MAX( m_left.m_nXStart, m_left.m_nXCurrent );
+	y0 = MIN( m_left.m_nYStart, m_left.m_nYCurrent );
+	y1 = MAX( m_left.m_nYStart, m_left.m_nYCurrent );
+
+	// Draw selection rectangle
+	vgui::surface()->DrawSetColor( 200, 220, 250, 192 );
+	vgui::surface()->DrawOutlinedRect( x0, y0, x1, y1 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CCommanderOverlayPanel::GetZoom( void )
+{
+	return (m_fZoom - m_MinWorldWidth) / (m_MaxWorldWidth - m_MinWorldWidth);
+}
diff --git a/game/client/tf2/commanderoverlaypanel.h b/game/client/tf2/commanderoverlaypanel.h
new file mode 100644
index 0000000..382732a
--- /dev/null
+++ b/game/client/tf2/commanderoverlaypanel.h
@@ -0,0 +1,143 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef COMMANDEROVERLAYPANEL_H
+#define COMMANDEROVERLAYPANEL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "CommanderOverlay.h"
+#include <vgui_controls/Panel.h>
+
+#define TACTICAL_ZOFFSET	100	
+#define TACTICAL_MIN_VIEWABLE_SIZE 1000
+#define TACTICAL_SPACEBAR_VIEWABLE_SIZE 4000
+
+#define FOG_ALPHAMAP_SIZE	64
+
+class C_TFTeam;
+class IVTFTexture;
+class ITexture;
+
+class CCommanderOverlayPanel : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+// Panel overrides.
+public:
+	CCommanderOverlayPanel( void );
+	virtual ~CCommanderOverlayPanel( void );
+
+	virtual void	Paint();
+
+	virtual void	OnMousePressed(vgui::MouseCode code);
+	virtual void	OnMouseReleased(vgui::MouseCode code);
+	virtual void	OnCursorMoved(int x, int y);
+	virtual void	OnMouseWheeled(int delta);
+	virtual void	OnKeyPressed(vgui::KeyCode code);
+	
+	// Call on enable
+	void	Enable();
+	void	Disable();
+
+	// called when we're ticked (updates our state)...
+	void	OnTick();
+
+	// Call when the map changes
+	void	LevelInit( char const* pMapName );
+	void	LevelShutdown( void );
+
+	// Returns the visible area (not including the tech tree)
+	void	GetVisibleSize( int& w, int& h );
+	
+	// Returns the visible area in world units
+	void	GetVisibleArea( Vector& mins, Vector& maxs );
+
+	// Returns the number of world units per pixel
+	float	WorldUnitsPerPixel();
+
+	// Fill in the rectangle that the view is rendered from.
+	// It is looking down negative Z, and goes from [vCenter.x-xSize, vCenter.y-ySize] to [vCenter.x+xSize, vCenter.y+ySize].
+	void	GetOrthoRenderBox(Vector &vCenter, float &xSize, float &ySize);
+	void	GetVisibleOrthoSize(float &xSize, float &ySize);
+	void	ActualToVisibleOffset( Vector& offset );
+
+	void BoundOrigin( Vector& camera );
+
+	void			CreatePickingRay( int mousex, int mousey, 
+		int screenwidth, int screenheight,
+		const Vector& vecRenderOrigin, 
+		const QAngle& vecRenderAngles, 
+		Vector &rayOrigin,
+		Vector &rayDirection
+		);
+
+	Vector&	TacticalOrigin() { return m_vecTacticalOrigin; }
+	QAngle&	TacticalAngles() { return m_vecTacticalAngles; }
+
+	float	GetZoom( void );
+
+	void	SetCommanderView( CClientModeCommander *commander );
+	bool	IsRightMouseMapMoving( void );
+
+private:
+	struct MouseDown_t
+	{
+		bool	m_bMouseDown;
+		int		m_nXStart;
+		int		m_nYStart;
+		int		m_nXCurrent;
+		int		m_nYCurrent;
+		int		m_nXPrev;
+		int		m_nYPrev;
+	};
+
+	// Compute render origin
+	void	InitializeRenderOrigin();
+
+	// Methods relating to zoom
+	void	ComputeZoomRange();
+
+	void	LeftMousePressed( void );
+	void	LeftMouseReleased( void );
+	void	RightMousePressed( void );
+	void	RightMouseReleased( void );
+	void	RightMouseMapMove( void );
+
+	// Shows the entire view
+	void	ChangeZoomLevel( float newZoom );
+
+	// Centers the view on the mouse
+	void	CenterOnMouse( Vector& mouseWorldPos );
+
+	int		CountSelectedPlayers( void );
+	void	GetSelectedPlayerBitField( CBitVec< MAX_PLAYERS >& bits );
+	void	SelectPlayersInRectangle( int x0, int y0, int x1, int y1, bool clearOldSelections = true );
+
+	void	GetMousePos( int& x, int& y );
+	void	StartMovingMouse( MouseDown_t& mouse );
+	void	UpdateMousePos( int x, int y, MouseDown_t& mouse );
+
+	// camera origin
+	Vector			m_vecTacticalOrigin;
+	QAngle			m_vecTacticalAngles;
+
+	MouseDown_t	m_left, m_right;
+
+	float	m_fZoom;		// 0 = sitting at world maxs.z. 1 = at maxs.z + (maxs.z-mins.z)*2.
+	float	m_MinWorldWidth;
+	float	m_MaxWorldWidth;
+	bool	m_bHaveActiveSelection;
+	float	m_flPreviousMaxWorldWidth;
+
+	CClientModeCommander	*m_pCommanderView;
+
+	vgui::HCursor	m_CursorCommander;
+	vgui::HCursor	m_CursorRightMouseMove;
+};
+
+#endif // COMMANDEROVERLAYPANEL_H
diff --git a/game/client/tf2/env_objecteffects.cpp b/game/client/tf2/env_objecteffects.cpp
new file mode 100644
index 0000000..4342a46
--- /dev/null
+++ b/game/client/tf2/env_objecteffects.cpp
@@ -0,0 +1,137 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+#include "cbase.h"
+#include "particles_simple.h"
+#include "particlemgr.h"
+#include "particle_collision.h"
+#include "env_objecteffects.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSmokeParticles::Setup( const Vector &origin, const Vector *direction, float angularSpread, float minSpeed, float maxSpeed, float gravity, float dampen, int flags )
+{
+	// See if we've specified a direction
+	m_ParticleCollision.Setup( origin, direction, angularSpread, minSpeed, maxSpeed, gravity, dampen );
+}
+
+void CObjectSmokeParticles::SimulateParticles( CParticleSimulateIterator *pIterator )
+{
+	float timeDelta = pIterator->GetTimeDelta();
+
+	ObjectSmokeParticle *pParticle = (ObjectSmokeParticle*)pIterator->GetFirst();
+	while ( pParticle )
+	{
+		//Update velocity
+		UpdateVelocity( pParticle, timeDelta );
+		pParticle->m_Pos += (pParticle->m_vecVelocity * timeDelta);
+		pParticle->m_vecVelocity += pParticle->m_vecAcceleration * 2 * timeDelta;
+
+		//Should this particle die?
+		pParticle->m_flLifetime += timeDelta;
+		UpdateRoll( pParticle, timeDelta );
+
+		if ( pParticle->m_flLifetime >= pParticle->m_flDieTime )
+			pIterator->RemoveParticle( pParticle );
+
+		pParticle = (ObjectSmokeParticle*)pIterator->GetNext();
+	}
+}
+
+
+void CObjectSmokeParticles::RenderParticles( CParticleRenderIterator *pIterator )
+{
+	const ObjectSmokeParticle *pParticle = (const ObjectSmokeParticle *)pIterator->GetFirst();
+	while ( pParticle )
+	{
+		//Render
+		Vector	tPos;
+
+		TransformParticle( ParticleMgr()->GetModelView(), pParticle->m_Pos, tPos );
+		float sortKey = (int) tPos.z;
+
+		//Render it
+		RenderParticle_ColorSizeAngle(
+			pIterator->GetParticleDraw(),
+			tPos,
+			UpdateColor( pParticle ),
+			UpdateAlpha( pParticle ) * GetAlphaDistanceFade( tPos, m_flNearClipMin, m_flNearClipMax ),
+			UpdateScale( pParticle ),
+			pParticle->m_flRoll );
+
+		pParticle = (const ObjectSmokeParticle *)pIterator->GetNext( sortKey );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectFireParticles::Setup( const Vector &origin, const Vector *direction, float angularSpread, float minSpeed, float maxSpeed, float gravity, float dampen, int flags )
+{
+}
+
+void CObjectFireParticles::SimulateParticles( CParticleSimulateIterator *pIterator )
+{
+	float timeDelta = pIterator->GetTimeDelta();
+
+	ObjectFireParticle *pParticle = (ObjectFireParticle*)pIterator->GetFirst();
+	while ( pParticle )
+	{
+		// Lost our parent?
+		if ( !pParticle->m_hParent )
+		{
+			pIterator->RemoveParticle( pParticle );
+		}
+		else
+		{
+			// Update position to match our parent
+			Vector vecFire;
+			QAngle angFire;
+			if ( pParticle->m_hParent->GetAttachment( pParticle->m_iAttachmentPoint, vecFire, angFire ) )
+			{
+				pParticle->m_Pos = vecFire;
+			}
+
+			// Should this particle die?
+			pParticle->m_flLifetime += timeDelta;
+
+			UpdateRoll( pParticle, timeDelta );
+
+			if ( pParticle->m_flLifetime >= pParticle->m_flDieTime )
+				pIterator->RemoveParticle( pParticle );
+		}
+
+		pParticle = (ObjectFireParticle*)pIterator->GetNext();
+	}
+}
+
+
+void CObjectFireParticles::RenderParticles( CParticleRenderIterator *pIterator )
+{
+	const ObjectFireParticle *pParticle = (const ObjectFireParticle *)pIterator->GetFirst();
+	while ( pParticle )
+	{
+		// Render
+		Vector	tPos;
+		TransformParticle( ParticleMgr()->GetModelView(), pParticle->m_Pos, tPos );
+		float sortKey = (int) tPos.z;
+
+		// Render it
+		RenderParticle_ColorSizeAngle(
+			pIterator->GetParticleDraw(),
+			tPos,
+			UpdateColor( pParticle ),
+			UpdateAlpha( pParticle ) * GetAlphaDistanceFade( tPos, m_flNearClipMin, m_flNearClipMax ),
+			UpdateScale( pParticle ),
+			pParticle->m_flRoll
+			);
+
+		pParticle = (const ObjectFireParticle *)pIterator->GetNext( sortKey );
+	}
+}
+
+
diff --git a/game/client/tf2/env_objecteffects.h b/game/client/tf2/env_objecteffects.h
new file mode 100644
index 0000000..9457145
--- /dev/null
+++ b/game/client/tf2/env_objecteffects.h
@@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef ENV_OBJECTEFFECTS_H
+#define ENV_OBJECTEFFECTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Object smoke particles. They float upward.
+//-----------------------------------------------------------------------------
+class ObjectSmokeParticle : public SimpleParticle
+{
+public:
+	Vector		m_vecAcceleration;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Object smoke particle emitter.
+//-----------------------------------------------------------------------------
+class CObjectSmokeParticles : public CSimpleEmitter
+{
+public:
+
+	CObjectSmokeParticles( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {}
+	static CSmartPtr<CObjectSmokeParticles> Create( const char *pDebugName )	{return new CObjectSmokeParticles( pDebugName );}
+
+	virtual void SimulateParticles( CParticleSimulateIterator *pIterator );
+	virtual void RenderParticles( CParticleRenderIterator *pIterator );
+
+	//Setup for point emission
+	virtual void		Setup( const Vector &origin, const Vector *direction, float angularSpread, float minSpeed, float maxSpeed, float gravity, float dampen, int flags = 0 );
+
+	CParticleCollision m_ParticleCollision;
+
+private:
+	CObjectSmokeParticles( const CObjectSmokeParticles & ); // not defined, not accessible
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Object fire particles. They know how to attach themselves to heirarchy.
+//-----------------------------------------------------------------------------
+class ObjectFireParticle : public SimpleParticle
+{
+public:
+	EHANDLE		m_hParent;
+	int			m_iAttachmentPoint;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Object smoke particle emitter.
+//-----------------------------------------------------------------------------
+class CObjectFireParticles : public CSimpleEmitter
+{
+public:
+	CObjectFireParticles( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {}
+	static CSmartPtr<CObjectFireParticles> Create( const char *pDebugName )	{return new CObjectFireParticles( pDebugName );}
+
+	virtual void SimulateParticles( CParticleSimulateIterator *pIterator );
+	virtual void RenderParticles( CParticleRenderIterator *pIterator );
+
+	//Setup for point emission
+	virtual void		Setup( const Vector &origin, const Vector *direction, float angularSpread, float minSpeed, float maxSpeed, float gravity, float dampen, int flags = 0 );
+
+private:
+	CObjectFireParticles( const CObjectFireParticles & ); // not defined, not accessible
+};
+
+#endif // ENV_OBJECTEFFECTS_H
diff --git a/game/client/tf2/fx_tf2_blood.cpp b/game/client/tf2/fx_tf2_blood.cpp
new file mode 100644
index 0000000..6b7e13a
--- /dev/null
+++ b/game/client/tf2/fx_tf2_blood.cpp
@@ -0,0 +1,347 @@
+//========= 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 "tf_shareddefs.h"
+#include "view.h"
+#include "c_basetfplayer.h"
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheEffectTF2BloodSpray )
+CLIENTEFFECT_MATERIAL( "effects/blood_gore" )
+CLIENTEFFECT_MATERIAL( "effects/blood_drop" )
+CLIENTEFFECT_MATERIAL( "effects/blood_puff" )
+CLIENTEFFECT_REGISTER_END()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : origin - 
+//			normal - 
+//			scale - 
+//-----------------------------------------------------------------------------
+void FX_TF2_BloodSpray( const Vector &origin, const Vector &normal, float scale, unsigned char r, unsigned char g, unsigned char b, int flags )
+{
+	if ( UTIL_IsLowViolence() )
+		return;
+
+	//debugoverlay->AddLineOverlay( origin, origin + normal * 72, 255, 255, 255, true, 10 ); 
+
+	float spread = 0.2f;
+	Vector color = Vector( r / 255.0f, g / 255.0f, b / 255.0f );
+	float colorRamp;
+	Vector offset;
+	int i;
+
+	Vector offDir;
+	Vector right;
+	Vector up;
+	Vector vecNormal = normal;
+
+	// Get the distance to the view
+	float flDistance = (origin - MainViewOrigin()).Length();
+	float flLODDistance = 0.25 * (flDistance / 512);
+	float flDistanceScale = 1.0 + flLODDistance;
+
+	if (vecNormal != Vector(0, 0, 1) )
+	{
+		right = vecNormal.Cross( Vector(0, 0, 1) );
+		up = right.Cross( vecNormal );
+	}
+	else
+	{
+		right = Vector(0, 0, 1);
+		up = right.Cross( vecNormal );
+	}
+
+	// If the normal's too close to being along the view, push it out
+	Vector vecForward, vecRight;
+	AngleVectors( MainViewAngles(), &vecForward, &vecRight, NULL );
+	float flDot = DotProduct( vecNormal, vecForward );
+	if ( fabs(flDot) > 0.5 )
+	{
+		float flPush = random->RandomFloat(0.5, 1.5) + flLODDistance;
+		float flRightDot = DotProduct( vecNormal, vecRight );
+		// If we're up close, randomly move it around. If we're at a distance, always push it to the side
+		// Up close, this can move it back towards the view, but the random chance still looks better
+		if ( ( flDistance >= 512 && flRightDot > 0 ) || ( flDistance < 512 && RandomFloat(0,1) > 0.5 ) )
+		{
+			// Turn it to the right
+			vecNormal += (vecRight * flPush);
+		}
+		else
+		{
+			// Turn it to the left
+			vecNormal -= (vecRight * flPush);
+		}
+	}
+
+	//
+	// Dump out drops
+	//
+	// Don't bother with these over midrange distance
+	if (flags & FX_BLOODSPRAY_DROPS && ( flDistance < 1500 ) )
+	{
+		TrailParticle *tParticle;
+
+		CSmartPtr<CTrailParticles> pTrailEmitter = CTrailParticles::Create( "blooddrops" );
+		if ( !pTrailEmitter )
+			return;
+
+		pTrailEmitter->SetSortOrigin( origin );
+
+		// Partial gravity on blood drops.
+		pTrailEmitter->SetGravity( 600.0 ); 
+		
+		// Enable simple collisions with nearby surfaces.
+		pTrailEmitter->Setup(origin, &vecNormal, 1, 10, 100, 600, 0.2, 0 );
+
+		PMaterialHandle	hMaterial = ParticleMgr()->GetPMaterial( "effects/blood_drop" );
+
+		//
+		// Long stringy drops of blood.
+		//
+		for ( i = 0; i < 7; i++ )
+		{
+			// Originate from within a circle 'scale' inches in diameter.
+			offset = origin;
+			offset += right * random->RandomFloat( -0.5f, 0.5f ) * scale;
+			offset += up * random->RandomFloat( -0.5f, 0.5f ) * scale;
+
+			tParticle = (TrailParticle *) pTrailEmitter->AddParticle( sizeof(TrailParticle), hMaterial, offset );
+
+			if ( tParticle == NULL )
+				break;
+
+			tParticle->m_flLifetime	= 0.0f;
+
+			offDir = vecNormal + RandomVector( -0.3f, 0.3f );
+
+			tParticle->m_vecVelocity = offDir * random->RandomFloat( 4.0f * scale, 40.0f * scale );
+			tParticle->m_vecVelocity[2] += random->RandomFloat( 4.0f, 16.0f ) * scale;
+
+			tParticle->m_flWidth		= random->RandomFloat( 0.5f, 1.0f ) * scale * (flDistanceScale * 1.25);
+			tParticle->m_flLength		= random->RandomFloat( 0.02f, 0.03f ) * scale * (flDistanceScale * 1.25);
+			tParticle->m_flDieTime		= random->RandomFloat( 0.5f, 1.0f );
+
+			// Ramp up the brightness as it gets farther away
+			colorRamp = random->RandomFloat( 0.5f, 0.75f ) + flLODDistance;
+			FloatToColor32( tParticle->m_color, MIN( 1.0, color[0] * colorRamp ), MIN( 1.0, color[1] * colorRamp ), MIN( 1.0, color[2] * colorRamp ), 1.0f );
+		}
+
+		//
+		// Shorter droplets.
+		//
+		// Only do these at short range
+		if ( flDistance < 512 )
+		{
+			for ( i = 0; i < 10; i++ )
+			{
+				// Originate from within a circle 'scale' inches in diameter.
+				offset = origin;
+				offset += right * random->RandomFloat( -0.5f, 0.5f ) * scale;
+				offset += up * random->RandomFloat( -0.5f, 0.5f ) * scale;
+
+				tParticle = (TrailParticle *) pTrailEmitter->AddParticle( sizeof(TrailParticle), hMaterial, offset );
+
+				if ( tParticle == NULL )
+					break;
+
+				tParticle->m_flLifetime	= 0.0f;
+
+				offDir = vecNormal + RandomVector( -1.0f, 1.0f );
+				offDir[2] += random->RandomFloat(0, 1.0f);
+
+				tParticle->m_vecVelocity = offDir * random->RandomFloat( 2.0f * scale, 25.0f * scale );
+				tParticle->m_vecVelocity[2] += random->RandomFloat( 4.0f, 16.0f ) * scale;
+
+				tParticle->m_flWidth		= random->RandomFloat( 0.25f, 0.375f ) * scale * flDistanceScale;
+				tParticle->m_flLength		= random->RandomFloat( 0.0025f, 0.005f ) * scale * flDistanceScale;
+				tParticle->m_flDieTime		= random->RandomFloat( 0.5f, 1.0f );
+
+				colorRamp = random->RandomFloat( 0.5f, 0.75f ) + flLODDistance;
+				FloatToColor32( tParticle->m_color, MIN( 1.0, color[0] * colorRamp ), MIN( 1.0, color[1] * colorRamp ), MIN( 1.0, color[2] * colorRamp ), 1.0f );
+			}
+		}
+	}
+
+	if ((flags & FX_BLOODSPRAY_GORE) || (flags & FX_BLOODSPRAY_CLOUD))
+	{
+		CSmartPtr<CBloodSprayEmitter> pSimple = CBloodSprayEmitter::Create( "bloodgore" );
+		if ( !pSimple )
+			return;
+
+		pSimple->SetSortOrigin( origin );
+		pSimple->SetGravity( 0 );
+
+		PMaterialHandle	hMaterial;
+
+		//
+		// Tight blossom of blood at the center.
+		//
+		if (flags & FX_BLOODSPRAY_GORE)
+		{
+			hMaterial = ParticleMgr()->GetPMaterial( "effects/blood_gore" );
+
+			SimpleParticle *pParticle;
+
+			for ( i = 0; i < 6; i++ )
+			{
+				// Originate from within a circle 'scale' inches in diameter.
+				offset = origin + ( 0.5 * scale * vecNormal );
+				offset += right * random->RandomFloat( -0.5f, 0.5f ) * scale;
+				offset += up * random->RandomFloat( -0.5f, 0.5f ) * scale;
+
+				pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), hMaterial, offset );
+
+				if ( pParticle != NULL )
+				{
+					pParticle->m_flLifetime = 0.0f;
+					pParticle->m_flDieTime	= 0.3f;
+
+					spread = 0.2f;
+					pParticle->m_vecVelocity.Random( -spread, spread );
+					pParticle->m_vecVelocity += vecNormal * random->RandomInt( 10, 100 );
+					//VectorNormalize( pParticle->m_vecVelocity );
+
+					colorRamp = random->RandomFloat( 0.75f, 1.0f ) + flLODDistance;
+
+					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	= random->RandomFloat( scale, scale * 4 ) * flDistanceScale;
+					pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 2 * flDistanceScale;
+					
+					pParticle->m_uchStartAlpha	= random->RandomInt( 200, 255 );
+					pParticle->m_uchEndAlpha	= 0;
+					
+					pParticle->m_flRoll			= random->RandomInt( 0, 360 );
+					pParticle->m_flRollDelta	= random->RandomFloat( -4.0f, 4.0f );
+				}
+			}
+		}
+
+		//
+		// Diffuse cloud just in front of the exit wound.
+		//
+		if (flags & FX_BLOODSPRAY_CLOUD)
+		{
+			hMaterial = ParticleMgr()->GetPMaterial( "effects/blood_puff" );
+
+			SimpleParticle *pParticle;
+
+			for ( i = 0; i < 6; i++ )
+			{
+				// Originate from within a circle '2 * scale' inches in diameter.
+				offset = origin + ( scale * vecNormal * 0.5 );
+				offset += right * random->RandomFloat( -1, 1 ) * scale;
+				offset += up * random->RandomFloat( -1, 1 ) * scale;
+
+				pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), hMaterial, offset );
+
+				if ( pParticle != NULL )
+				{
+					pParticle->m_flLifetime = 0.0f;
+					pParticle->m_flDieTime	= random->RandomFloat( 0.5f, 0.8f);
+
+					spread = 0.5f;
+					pParticle->m_vecVelocity.Random( -spread, spread );
+					pParticle->m_vecVelocity += vecNormal * random->RandomInt( 100, 200 );
+
+					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, color[1] * colorRamp ) * 255.0f;
+					pParticle->m_uchColor[2]	= MIN( 1.0f, color[2] * colorRamp ) * 255.0f;
+					
+					pParticle->m_uchStartSize	= random->RandomFloat( scale * 0.5, scale ) * flDistanceScale;
+					pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 4 * flDistanceScale;
+					
+					pParticle->m_uchStartAlpha	= random->RandomInt( 80, 128 );
+					pParticle->m_uchEndAlpha	= 0;
+					
+					pParticle->m_flRoll			= random->RandomInt( 0, 360 );
+					pParticle->m_flRollDelta	= random->RandomFloat( -4.0f, 4.0f );
+				}
+			}
+		}
+	}
+
+	// TODO: Play a sound?
+	//CLocalPlayerFilter filter;
+	//C_BaseEntity::EmitSound( filter, SOUND_FROM_WORLD, CHAN_VOICE, "Physics.WaterSplash", 1.0, ATTN_NORM, 0, 100, &origin );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bloodtype - 
+//			r - 
+//			g - 
+//			b - 
+//-----------------------------------------------------------------------------
+void GetBloodColorForTeam( int iTeam, unsigned char &r, unsigned char &g, unsigned char &b )
+{
+	if ( iTeam == TEAM_ALIENS )
+	{
+		r = 0;
+		g = 255;
+		b = 0;
+	}
+	else if ( iTeam == TEAM_HUMANS )
+	{
+		// Humans
+		r = 255;
+		g = 0;
+		b = 0;
+	}
+	else 
+	{
+		// NPCs?
+		r = 200;
+		g = 0;
+		b = 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Intercepts the blood spray message.
+//-----------------------------------------------------------------------------
+void TF2BloodSprayCallback( const CEffectData &data )
+{
+	unsigned char r = 0;
+	unsigned char g = 0;
+	unsigned char b = 0;
+
+	// Get the entity we've hit
+	C_BaseEntity *pEntity = ClientEntityList().GetEnt( data.m_nEntIndex );
+	if ( pEntity )
+	{
+		GetBloodColorForTeam( pEntity->GetTeamNumber(), r, g, b );
+		if ( pEntity->IsPlayer() )
+		{
+			C_BaseTFPlayer *pPlayer = (C_BaseTFPlayer *)pEntity;
+			pPlayer->PainSound();
+		}
+	}
+	else
+	{
+		GetBloodColorForTeam( 0, r, g, b );
+	}
+	FX_TF2_BloodSpray( data.m_vOrigin, data.m_vNormal, data.m_flScale, r, g, b, data.m_fFlags );
+}
+
+DECLARE_CLIENT_EFFECT( "tf2blood", TF2BloodSprayCallback );
diff --git a/game/client/tf2/fx_tf2_buildeffects.cpp b/game/client/tf2/fx_tf2_buildeffects.cpp
new file mode 100644
index 0000000..086ba82
--- /dev/null
+++ b/game/client/tf2/fx_tf2_buildeffects.cpp
@@ -0,0 +1,737 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Effects played when objects are building
+//
+//=============================================================================//
+
+#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 "tf_shareddefs.h"
+#include "c_impact_effects.h"
+#include "fx.h"
+#include "iviewrender_beams.h"
+#include "view.h"
+#include "IEffects.h"
+#include "c_tracer.h"
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheTF2EffectBuild )
+CLIENTEFFECT_MATERIAL( "effects/blood" )
+CLIENTEFFECT_MATERIAL( "effects/human_build_warp" )
+CLIENTEFFECT_MATERIAL( "effects/tesla_glow_noz" )
+CLIENTEFFECT_MATERIAL( "particle/particle_smokegrenade" )
+CLIENTEFFECT_MATERIAL( "effects/human_tracers/human_sparksprite_A1" )
+CLIENTEFFECT_MATERIAL( "effects/human_tracers/human_sparktracer_A_" )
+CLIENTEFFECT_MATERIAL( "effects/alien_tracers/alien_pbtracer_A_" )
+CLIENTEFFECT_MATERIAL( "effects/alien_tracers/alien_pbsprite_A1" )
+CLIENTEFFECT_REGISTER_END()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Build impact
+//-----------------------------------------------------------------------------
+void FX_BuildImpact( const Vector &origin, const QAngle &vecAngles, const Vector &vecNormal, float flScale, bool bGround = false, CBaseEntity *pIgnore = NULL )
+{
+	Vector	offset;
+	float	spread = 0.1f;
+	
+	CSmartPtr<CDustParticle> pSimple = CDustParticle::Create( "dust" );
+	pSimple->SetSortOrigin( origin );
+
+	SimpleParticle	*pParticle;
+
+	Vector color( 0.35, 0.35, 0.35 );
+	float  colorRamp;
+
+	// If we're hitting the ground, try and get the ground color
+	if ( bGround )
+	{
+		trace_t	tr;
+		UTIL_TraceLine( origin, origin + Vector(0,0,-32), MASK_SHOT, pIgnore, COLLISION_GROUP_NONE, &tr );
+		GetColorForSurface( &tr, &color );
+	}
+
+	int iNumPuffs = 8;
+	for ( int i = 0; i < iNumPuffs; i++ )
+	{
+		QAngle vecTemp = vecAngles;
+		vecTemp[YAW] += (360 / iNumPuffs) * i;
+		Vector vecForward;
+		AngleVectors( vecTemp, &vecForward );
+
+		pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), g_Mat_DustPuff[0], origin );
+
+		if ( pParticle != NULL )
+		{
+			pParticle->m_flLifetime = 0.0f;
+			pParticle->m_flDieTime	= RandomFloat( 0.5f, 1.0f );
+
+			pParticle->m_vecVelocity.Random( -spread, spread );
+			pParticle->m_vecVelocity += ( vecForward * RandomFloat( 1.0f, 6.0f ) );
+			
+			VectorNormalize( pParticle->m_vecVelocity );
+
+			float	fForce = RandomFloat( 500, 750 );
+
+			// scaled
+			pParticle->m_vecVelocity *= fForce * flScale;
+			
+			colorRamp = RandomFloat( 0.75f, 1.25f );
+			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;
+			
+			// scaled
+			pParticle->m_uchStartSize	= flScale * RandomInt( 15, 20 );
+
+			// scaled
+			pParticle->m_uchEndSize		= flScale * pParticle->m_uchStartSize * 4;
+			
+			pParticle->m_uchStartAlpha	= RandomInt( 32, 255 );
+			pParticle->m_uchEndAlpha	= 0;
+			
+			pParticle->m_flRoll			= RandomInt( 0, 360 );
+			pParticle->m_flRollDelta	= RandomFloat( -8.0f, 8.0f );
+		}
+	}			
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Large dust impact
+//-----------------------------------------------------------------------------
+void BuildImpactCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+	Vector vecNormal = data.m_vNormal;
+
+	FX_BuildImpact( vecOrigin, vecAngles, vecNormal, 1 );
+
+	// Randomly play sparks
+	if ( RandomFloat() > 0.35 )
+	{
+		// Angle them up
+		vecAngles[PITCH] = -90;
+		Vector vecForward;
+		AngleVectors( vecAngles, &vecForward );
+
+		// Sparks
+		FX_Sparks( vecOrigin, 2, 4, vecForward, 2.5, 48, 64 );
+	}
+}
+
+DECLARE_CLIENT_EFFECT( "BuildImpact", BuildImpactCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Small dust impact
+//-----------------------------------------------------------------------------
+void BuildImpactSmallCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+	Vector vecNormal = data.m_vNormal;
+
+	FX_BuildImpact( vecOrigin, vecAngles, vecNormal, 0.65 );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildImpactSmall", BuildImpactSmallCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Large dust impact to be used only when something's landed on the ground
+//-----------------------------------------------------------------------------
+void BuildImpactGroundCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+	Vector vecNormal = data.m_vNormal;
+	int iEntIndex = data.m_nEntIndex;
+
+	C_BaseEntity *pEntity = ClientEntityList().GetEnt( iEntIndex );
+	FX_BuildImpact( vecOrigin, vecAngles, vecNormal, 1, true, pEntity );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildImpactGround", BuildImpactGroundCallback );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a tesla effect between two points
+//-----------------------------------------------------------------------------
+void TF2_FX_BuildTesla( C_BaseEntity *pEntity, Vector &vecOrigin, Vector &vecEnd )
+{
+	BeamInfo_t beamInfo;
+	beamInfo.m_nType = TE_BEAMTESLA;
+	beamInfo.m_vecStart = vecOrigin;
+	beamInfo.m_vecEnd = vecEnd;
+	beamInfo.m_pszModelName = "sprites/physbeam.vmt";
+	beamInfo.m_flHaloScale = 0.0;
+	beamInfo.m_flLife = RandomFloat( 0.3, 0.55 );
+	beamInfo.m_flWidth = 5.0;
+	beamInfo.m_flEndWidth = 1;
+	beamInfo.m_flFadeLength = 0.3;
+	beamInfo.m_flAmplitude = 16;
+	beamInfo.m_flBrightness = 200.0;
+	beamInfo.m_flSpeed = 0.0;
+	beamInfo.m_nStartFrame = 0.0;
+	beamInfo.m_flFrameRate = 1.0;
+	beamInfo.m_flRed = 255.0;
+	beamInfo.m_flGreen = 255.0;
+	beamInfo.m_flBlue = 255.0;
+	beamInfo.m_nSegments = 20;
+	beamInfo.m_bRenderable = true;
+	beamInfo.m_nFlags = FBEAM_ONLYNOISEONCE;
+	
+	beams->CreateBeamPoints( beamInfo );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Tesla effect
+//-----------------------------------------------------------------------------
+void TF2_BuildTeslaCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+	int iEntIndex = data.m_nEntIndex;
+	C_BaseEntity *pEntity = ClientEntityList().GetEnt( iEntIndex );
+
+	// Send out beams around us
+	int iNumBeamsAround = 4;
+	int iNumRandomBeams = 2;
+	int iTotalBeams = iNumBeamsAround + iNumRandomBeams;
+	float flYawOffset = RandomFloat(0,360);
+	for ( int i = 0; i < iTotalBeams; i++ )
+	{
+		// Make a couple of tries at it
+		int iTries = -1;
+		Vector vecForward;
+		trace_t tr;
+		do
+		{
+			iTries++;
+
+			// Some beams are deliberatly aimed around the point, the rest are random.
+			if ( i < iNumBeamsAround )
+			{
+				QAngle vecTemp = vecAngles;
+				vecTemp[YAW] += anglemod( flYawOffset + ((360 / iTotalBeams) * i) );
+				AngleVectors( vecTemp, &vecForward );
+
+				// Randomly angle it up or down
+				vecForward.z = RandomFloat( -1, 1 );
+			}
+			else
+			{
+				vecForward = RandomVector( -1, 1 );
+			}
+
+			UTIL_TraceLine( vecOrigin, vecOrigin + (vecForward * 192), MASK_SHOT, pEntity, COLLISION_GROUP_NONE, &tr );
+		} while ( tr.fraction >= 1.0 && iTries < 3 );
+
+		Vector vecEnd = tr.endpos - (vecForward * 8);
+
+		// Only spark & glow if we hit something
+		if ( tr.fraction < 1.0 )
+		{
+			if ( !EffectOccluded( tr.endpos ) )
+			{
+				// Move it towards the camera
+				Vector vecFlash = tr.endpos;
+				Vector vecForward;
+				AngleVectors( MainViewAngles(), &vecForward );
+				vecFlash -= (vecForward * 8);
+
+				g_pEffects->EnergySplash( vecFlash, -vecForward, false );
+
+				// End glow
+				CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "dust" );
+				pSimple->SetSortOrigin( vecFlash );
+				SimpleParticle *pParticle;
+				pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/tesla_glow_noz" ), vecFlash );
+				if ( pParticle != NULL )
+				{
+					pParticle->m_flLifetime = 0.0f;
+					pParticle->m_flDieTime	= RandomFloat( 0.5, 1 );
+					pParticle->m_vecVelocity = vec3_origin;
+					Vector color( 1,1,1 );
+					float  colorRamp = RandomFloat( 0.75f, 1.25f );
+					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	= RandomFloat( 6,13 );
+					pParticle->m_uchEndSize		= pParticle->m_uchStartSize - 2;
+					pParticle->m_uchStartAlpha	= 255;
+					pParticle->m_uchEndAlpha	= 10;
+					pParticle->m_flRoll			= RandomFloat( 0,360 );
+					pParticle->m_flRollDelta	= 0;
+				}
+			}
+		}
+
+		// Build the tesla
+		TF2_FX_BuildTesla( pEntity, vecOrigin, tr.endpos );
+	}
+}
+
+DECLARE_CLIENT_EFFECT( "TF2BuildTesla", TF2_BuildTeslaCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: WarpParticle emitter 
+//			This is a particle that scales up to its max size in WARPEMMITER_MIDPOINT 
+//			of it's lifetime, the drops back to its initial size by the end of its life.
+//			Alpha scales the same way.
+//-----------------------------------------------------------------------------
+#define WARPEMMITER_MIDPOINT	0.6
+
+class CWarpParticleEmitter : public CSimpleEmitter
+{
+public:
+	
+	CWarpParticleEmitter( const char *pDebugName ) : CSimpleEmitter( pDebugName ) {}
+	
+	//Create
+	static CWarpParticleEmitter *Create( const char *pDebugName="dust" )
+	{
+		return new CWarpParticleEmitter( pDebugName );
+	}
+
+	// Scale
+	virtual float UpdateScale( const SimpleParticle *pParticle )
+	{
+		float	tLifeTime = pParticle->m_flLifetime / pParticle->m_flDieTime;
+
+		// Ramp up for the first 75% of my life, then reduce for the rest
+		if ( tLifeTime < WARPEMMITER_MIDPOINT )
+		{
+			tLifeTime = RemapVal( tLifeTime, 0, WARPEMMITER_MIDPOINT, 0, 1.0 );
+			return (float)pParticle->m_uchStartSize + ( (float)pParticle->m_uchEndSize - (float)pParticle->m_uchStartSize ) * tLifeTime;
+		}
+
+		tLifeTime -= WARPEMMITER_MIDPOINT;
+		tLifeTime = RemapVal( tLifeTime, 0, 1 - WARPEMMITER_MIDPOINT, 0, 1.0 );
+		return (float)pParticle->m_uchEndSize - ( (float)pParticle->m_uchEndSize - (float)pParticle->m_uchStartSize ) * tLifeTime;
+	}
+
+	//Alpha
+	virtual float UpdateAlpha( const SimpleParticle *pParticle )
+	{
+		float tLifeTime = pParticle->m_flLifetime / pParticle->m_flDieTime;
+		float flAlpha = 0;
+
+		// Ramp up for the first 75% of my life, then reduce for the rest
+		if ( tLifeTime < WARPEMMITER_MIDPOINT )
+		{
+			tLifeTime = RemapVal( tLifeTime, 0, WARPEMMITER_MIDPOINT, 0, 1.0 );
+			flAlpha = (float)pParticle->m_uchStartAlpha + ( (float)pParticle->m_uchEndAlpha - (float)pParticle->m_uchStartAlpha ) * tLifeTime;
+		}
+		else
+		{
+			tLifeTime -= WARPEMMITER_MIDPOINT;
+			tLifeTime = RemapVal( tLifeTime, 0, 1 - WARPEMMITER_MIDPOINT, 0, 1.0 );
+			flAlpha = (float)pParticle->m_uchEndAlpha - ( (float)pParticle->m_uchEndAlpha - (float)pParticle->m_uchStartAlpha ) * tLifeTime;
+		}
+
+		flAlpha = flAlpha / 255;
+		return flAlpha;
+	}
+
+private:
+	CWarpParticleEmitter( const CWarpParticleEmitter & ); // not defined, not accessible
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void FX_BuildWarp( Vector &vecOrigin, QAngle &vecAngles, float flScale )
+{
+	if ( EffectOccluded( vecOrigin ) )
+		return;
+
+	CSmartPtr<CSimpleEmitter> pSimple = CSimpleEmitter::Create( "dust" );
+	pSimple->SetSortOrigin( vecOrigin );
+
+	SimpleParticle *pParticle;
+
+	Vector color( 1, 1, 1 );
+	float  colorRamp;
+
+	// Big flash
+	pParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/blueflare2" ), vecOrigin );
+	if ( pParticle != NULL )
+	{
+		pParticle->m_flLifetime = 0.0f;
+		pParticle->m_flDieTime	= 0.5;
+		pParticle->m_vecVelocity = vec3_origin;
+		colorRamp = RandomFloat( 0.75f, 1.25f );
+		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	= RandomFloat( 10,15 );
+		pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 8 * flScale;
+		pParticle->m_uchStartAlpha	= 48;
+		pParticle->m_uchEndAlpha	= 0;
+		pParticle->m_flRoll			= 0;
+		pParticle->m_flRollDelta	= 0;
+	}
+
+	// Bright light
+	// Move it towards the camera
+	Vector vecForward;
+	AngleVectors( MainViewAngles(), &vecForward );
+	vecOrigin -= (vecForward * 8);
+	CSmartPtr<CWarpParticleEmitter> pWarpEmitter = CWarpParticleEmitter::Create( "dust" );
+	pWarpEmitter->SetSortOrigin( vecOrigin );
+
+	pParticle = (SimpleParticle *) pWarpEmitter->AddParticle( sizeof( SimpleParticle ), pWarpEmitter->GetPMaterial( "effects/human_build_warp" ), vecOrigin );
+	if ( pParticle != NULL )
+	{
+		pParticle->m_flLifetime = 0.0f;
+		pParticle->m_flDieTime	= 0.4;
+		pParticle->m_vecVelocity = vec3_origin;
+
+		colorRamp = RandomFloat( 0.75f, 1.25f );
+		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	= RandomInt( 10,13 ) * flScale;
+		pParticle->m_uchEndSize		= pParticle->m_uchStartSize * 9;
+		
+		pParticle->m_uchStartAlpha	= 32;
+		pParticle->m_uchEndAlpha	= 192;
+		
+		pParticle->m_flRoll			= 0;
+		pParticle->m_flRollDelta	= 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Warp effect
+//-----------------------------------------------------------------------------
+void BuildWarpCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+
+	// Warp effect
+	FX_BuildWarp( vecOrigin, vecAngles, 2 );
+	g_pEffects->EnergySplash( vecOrigin, Vector(0,0,1), false );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildWarp", BuildWarpCallback );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Small Warp effect
+//-----------------------------------------------------------------------------
+void BuildWarpSmallCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+
+	// Warp effect
+	FX_BuildWarp( vecOrigin, vecAngles, 1.5 );
+	g_pEffects->EnergySplash( vecOrigin, Vector(0,0,1), false );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildWarpSmall", BuildWarpSmallCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Spark effects
+//-----------------------------------------------------------------------------
+void BuildSparksCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+
+	// Angle them up
+	vecAngles[PITCH] = -90;
+	Vector vecForward;
+	AngleVectors( vecAngles, &vecForward );
+
+	// Sparks
+	FX_Sparks( vecOrigin, 2, 4, vecForward, 2.5, 48, 64 );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildSparks", BuildSparksCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Red Spark effects
+//-----------------------------------------------------------------------------
+void BuildSparksRedCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+
+	// Angle them up
+	vecAngles[PITCH] = -90;
+	Vector vecForward;
+	AngleVectors( vecAngles, &vecForward );
+
+	// Sparks
+	FX_Sparks( vecOrigin, 2, 4, vecForward, 2.5, 48, 64, "effects/spark2" );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildSparksRed", BuildSparksRedCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Electric sparks effect
+//-----------------------------------------------------------------------------
+void BuildSparksElectricCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	Vector vecNormal = data.m_vNormal;
+
+	// Sparks
+	FX_ElectricSpark( vecOrigin, 2, 4, &vecNormal );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildSparksElectric", BuildSparksElectricCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Metal sparks effect
+//-----------------------------------------------------------------------------
+void BuildSparksMetalCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	Vector vecNormal = data.m_vNormal;
+
+	// Sparks
+	FX_MetalSpark( vecOrigin, vecNormal, vecNormal, 2 );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildSparksMetal", BuildSparksMetalCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Metal scrape effect
+//-----------------------------------------------------------------------------
+void BuildMetalScrapeCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	Vector vecNormal = data.m_vNormal;
+
+	// Sparks
+	FX_MetalScrape( vecOrigin, vecNormal );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildMetalScrape", BuildMetalScrapeCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Warp effect that looks like it's sucking things to it
+//-----------------------------------------------------------------------------
+void FX_BuildWarpSuck( Vector &vecOrigin, QAngle &vecAngles, float flScale )
+{
+	CSmartPtr<CTrailParticles> pEmitter = CTrailParticles::Create( "BuildWarpSuck" );
+	PMaterialHandle	hParticleMaterial = pEmitter->GetPMaterial( "effects/bluespark" );
+	pEmitter->Setup( (Vector &) vecOrigin, 
+						NULL, 
+						0.0, 
+						0, 
+						64, 
+						0, 
+						0, 
+						bitsPARTICLE_TRAIL_VELOCITY_DAMPEN | bitsPARTICLE_TRAIL_FADE );
+
+	// Add particles
+	int iNumParticles = 60;
+	for ( int i = 0; i < iNumParticles; i++ )
+	{
+		Vector vOffset = RandomVector( -1, 1 );
+		VectorNormalize( vOffset );
+		float flDistance = RandomFloat( 16, 64 ) * flScale;
+		Vector vPos = vecOrigin + (vOffset * flDistance);
+		
+		TrailParticle *pParticle = (TrailParticle *) pEmitter->AddParticle( sizeof(TrailParticle), hParticleMaterial, vPos );
+		if ( pParticle )
+		{
+			float flSpeed = RandomFloat(8,16) * (flScale * flScale * flScale);
+			pParticle->m_vecVelocity = vOffset * -flSpeed;
+			pParticle->m_flDieTime = MIN( 3, (flDistance / flSpeed) + RandomFloat(0.0, 0.2) );
+			pParticle->m_flLifetime = 0;
+			pParticle->m_flWidth = RandomFloat( 2, 3 ) * flScale;
+			pParticle->m_flLength = RandomFloat( 1, 2 ) * flScale;
+
+			Color32Init( pParticle->m_color, 255, 255, 255, 255 );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Warp effect that looks like it's sucking things to it
+//-----------------------------------------------------------------------------
+void BuildWarpSuckCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+
+	FX_BuildWarpSuck( vecOrigin, vecAngles, 1.0 );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildWarpSuck", BuildWarpSuckCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Bigger Warp effect that looks like it's sucking things to it
+//-----------------------------------------------------------------------------
+void BuildWarpSuckBigCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+
+	FX_BuildWarpSuck( vecOrigin, vecAngles, 2.0 );
+}
+
+DECLARE_CLIENT_EFFECT( "BuildWarpSuckBig", BuildWarpSuckBigCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: GasSpurt Emitter
+//			This is an emitter that keeps spitting out particles for its lifetime
+//			It won't create particles if it's not in view, so it's best when short lived
+//-----------------------------------------------------------------------------
+class CGasSpurtEmitter : public CSimpleEmitter
+{
+	typedef CSimpleEmitter BaseClass;
+public:
+	CGasSpurtEmitter( const char *pDebugName ) : CSimpleEmitter( pDebugName ) 
+	{
+		m_flDeathTime = 0;
+		m_flLastParticleSpawnTime = 0;
+	}
+	
+	// Create
+	static CGasSpurtEmitter *Create( const char *pDebugName="gasspurt" )
+	{
+		return new CGasSpurtEmitter( pDebugName );
+	}
+
+	void SetLifeTime( float flTime )
+	{
+		m_flDeathTime = gpGlobals->curtime + flTime;
+	}
+
+	void SetSpurtAngle( QAngle &vecAngles )
+	{
+		AngleVectors( vecAngles, &m_vecSpurtForward );
+	}
+
+	void SetSpurtColor( const Vector4D &pColor )
+	{
+		for ( int i = 0; i <= 3; i++ )
+		{
+			m_SpurtColor[i] = pColor[i];
+		}
+	}
+
+	void SetSpawnRate( float flRate )
+	{
+		m_flSpawnRate = flRate;
+	}
+
+	void CreateSpurtParticles( void )
+	{
+		SimpleParticle *pParticle;
+
+		// Smoke
+		int numParticles = RandomInt( 1,2 );
+		for ( int i = 0; i < numParticles; i++ )
+		{
+			pParticle = (SimpleParticle *) AddParticle( sizeof( SimpleParticle ), g_Mat_DustPuff[0], m_vSortOrigin );			
+			if ( pParticle == NULL )
+				break;
+
+			pParticle->m_flLifetime = 0.0f;
+			pParticle->m_flDieTime = RandomFloat( 0.5, 1.0 );
+
+			// Random velocity around the angles forward
+			Vector vecVelocity;
+			vecVelocity.Random( -0.1f, 0.1f );
+			vecVelocity += m_vecSpurtForward;
+			VectorNormalize( vecVelocity );
+			vecVelocity	*= RandomFloat( 16.0f, 64.0f );
+			pParticle->m_vecVelocity = vecVelocity;
+
+			// Randomize the color a little
+			int color[3][2];
+			for( int i = 0; i < 3; ++i )
+			{
+				color[i][0] = MAX( 0, m_SpurtColor[i] - 64 );
+				color[i][1] = MIN( 255, m_SpurtColor[i] + 64 );
+			}
+			pParticle->m_uchColor[0] = random->RandomInt( color[0][0], color[0][1] );
+			pParticle->m_uchColor[1] = random->RandomInt( color[1][0], color[1][1] );
+			pParticle->m_uchColor[2] = random->RandomInt( color[2][0], color[2][1] );
+
+			pParticle->m_uchStartAlpha = m_SpurtColor[3];
+			pParticle->m_uchEndAlpha = 0;
+			pParticle->m_uchStartSize = RandomInt( 1, 2 );
+			pParticle->m_uchEndSize = pParticle->m_uchStartSize*3;
+			pParticle->m_flRoll	= RandomFloat( 0, 360 );
+			pParticle->m_flRollDelta = RandomFloat( -4.0f, 4.0f );
+		}			
+
+		m_flLastParticleSpawnTime = gpGlobals->curtime + m_flSpawnRate;
+	}
+
+	virtual void SimulateParticles( CParticleSimulateIterator *pIterator )
+	{
+		Particle *pParticle = (Particle*)pIterator->GetFirst();
+		while ( pParticle )
+		{
+			// If our lifetime isn't up, create more particles
+			if ( m_flDeathTime > gpGlobals->curtime )
+			{
+				if ( m_flLastParticleSpawnTime <= gpGlobals->curtime )
+				{
+					CreateSpurtParticles();
+				}
+			}
+
+			pParticle = (Particle*)pIterator->GetNext();
+		}
+
+		BaseClass::SimulateParticles( pIterator );
+	}
+
+
+private:
+	float		m_flDeathTime;
+	float		m_flLastParticleSpawnTime;
+	float		m_flSpawnRate;
+	Vector		m_vecSpurtForward;
+	Vector4D	m_SpurtColor;
+
+	CGasSpurtEmitter( const CGasSpurtEmitter & ); // not defined, not accessible
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Small hose gas spurt
+//-----------------------------------------------------------------------------
+void FX_BuildGasSpurt( Vector &vecOrigin, QAngle &vecAngles, float flLifeTime, const Vector4D &pColor )
+{
+	CSmartPtr<CGasSpurtEmitter> pSimple = CGasSpurtEmitter::Create( "FX_Smoke" );
+	pSimple->SetSortOrigin( vecOrigin );
+	pSimple->SetLifeTime( flLifeTime );
+	pSimple->SetSpurtAngle( vecAngles );
+	pSimple->SetSpurtColor( pColor );
+	pSimple->SetSpawnRate( 0.03 );
+	pSimple->CreateSpurtParticles();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Green hose gas spurt
+//-----------------------------------------------------------------------------
+void GasGreenCallback( const CEffectData &data )
+{
+	Vector vecOrigin = data.m_vOrigin;
+	QAngle vecAngles = data.m_vAngles;
+
+	Vector4D color( 50,192,50,255 );
+	FX_BuildGasSpurt( vecOrigin, vecAngles, 1.0, color );
+}
+
+DECLARE_CLIENT_EFFECT( "GasGreen", GasGreenCallback );
diff --git a/game/client/tf2/fx_tf2_impacts.cpp b/game/client/tf2/fx_tf2_impacts.cpp
new file mode 100644
index 0000000..e22c70d
--- /dev/null
+++ b/game/client/tf2/fx_tf2_impacts.cpp
@@ -0,0 +1,453 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Game-specific impact effect hooks
+//
+//=============================================================================//
+#include "cbase.h"
+#include "fx_impact.h"
+#include "decals.h"
+#include "IEffects.h"
+#include "c_breakableprop.h"
+#include "tempent.h"
+#include "c_te_legacytempents.h"
+#include "tf_shareddefs.h"
+#include "fx.h"
+
+void ImpactCreateHurtShards( Vector &vecOrigin, trace_t &tr, Vector &shotDir, int iMaterial, bool bLarge, bool bBlood );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void MakeHurt( const CEffectData &data, bool bBlood )
+{
+	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 ) )
+	{
+		// Throw out shards to show the player he's hurting it
+		ImpactCreateHurtShards( vecOrigin, tr, vecShotDir, iMaterial, false, bBlood );
+
+		// Check for custom effects based on the Decal index
+		PerformCustomEffects( vecOrigin, tr, vecShotDir, iMaterial, 1.0 );
+	}
+
+	PlayImpactSound( pEntity, tr, vecOrigin, nSurfaceProp );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Impact for:
+//				Bullets hitting targets that CAN be hurt
+//-----------------------------------------------------------------------------
+void ImpactCallback( const CEffectData &data )
+{
+	MakeHurt( data, true );
+}
+
+DECLARE_CLIENT_EFFECT( "Impact", ImpactCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Bloodless Impact for:
+//				Bullets hitting targets that CAN be hurt
+//-----------------------------------------------------------------------------
+void ImpactNoBloodCallback( const CEffectData &data )
+{
+	MakeHurt( data, false );
+}
+
+DECLARE_CLIENT_EFFECT( "ImpactNoBlood", ImpactNoBloodCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Impact for:
+//				Bullets hitting targets that CANNOT be hurt
+//-----------------------------------------------------------------------------
+void ImpactUnhurtCallback( 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
+	// Don't decal team members, but decal everything else
+
+	bool bShouldDecal = !( pEntity && pEntity->IsPlayer() );
+	if ( Impact( vecOrigin, vecStart, iMaterial, iDamageType, iHitbox, pEntity, tr, bShouldDecal ? 0 : IMPACT_NODECAL ) )
+	{
+		// Check for custom effects based on the Decal index
+		PerformCustomEffects( vecOrigin, tr, vecShotDir, iMaterial, 0 );
+	}
+
+	PlayImpactSound( pEntity, tr, vecOrigin, nSurfaceProp );
+}
+
+DECLARE_CLIENT_EFFECT( "ImpactUnhurt", ImpactUnhurtCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Impact for:
+//				Bullets hitting player's handheld shields
+//-----------------------------------------------------------------------------
+void ImpactShieldCallback( const CEffectData &data )
+{
+	trace_t tr;
+	Vector vecOrigin, vecStart, vecShotDir;
+	int iMaterial, iDamageType, iHitbox;
+	short nSurfaceProp;
+	ParseImpactData( data, &vecOrigin, &vecStart, &vecShotDir, nSurfaceProp, iMaterial, iDamageType, iHitbox );
+
+	// Don't call Impact() because we don't want to decal the player
+	Vector reflect = -vecShotDir;
+	reflect[0] += random->RandomFloat( -0.5f, 0.5f );
+	reflect[1] += random->RandomFloat( -0.5f, 0.5f );
+	reflect[2] += random->RandomFloat( 0, 0.5f );
+	FX_MetalSpark( vecOrigin, reflect, -vecShotDir, 3 );
+}
+
+DECLARE_CLIENT_EFFECT( "ImpactShield", ImpactShieldCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void MakePlasmaHurt( const CEffectData &data, bool bBlood )
+{
+	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, play our splash
+	if ( Impact( vecOrigin, vecStart, iMaterial, iDamageType, iHitbox, pEntity, tr ) )
+	{
+		// Throw out shards to show the player he's hurting it
+		ImpactCreateHurtShards( vecOrigin, tr, vecShotDir, iMaterial, false, bBlood );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Impact for:
+//				Plasma hitting targets that CAN be hurt
+//-----------------------------------------------------------------------------
+void ImpactPlasmaCallback( const CEffectData &data )
+{
+	MakePlasmaHurt( data, true );
+}
+
+DECLARE_CLIENT_EFFECT( "PlasmaHurt", ImpactPlasmaCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Impact for:
+//				Plasma hitting targets that CAN be hurt
+//-----------------------------------------------------------------------------
+void ImpactPlasmaNoBloodCallback( const CEffectData &data )
+{
+	MakePlasmaHurt( data, false );
+}
+
+DECLARE_CLIENT_EFFECT( "PlasmaHurtNoBlood", ImpactPlasmaNoBloodCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Impact for:
+//				Plasma hitting targets that CANNOT be hurt
+//-----------------------------------------------------------------------------
+void ImpactPlasmaUnhurtCallback( 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, play our splash
+	
+	bool bShouldDecal = !( pEntity && pEntity->IsPlayer() );
+	if ( Impact( vecOrigin, vecStart, iMaterial, iDamageType, iHitbox, pEntity, tr, bShouldDecal ? 0 : IMPACT_NODECAL  ) )
+	{
+		g_pEffects->EnergySplash( vecOrigin, tr.plane.normal, false );
+	}
+}
+
+DECLARE_CLIENT_EFFECT( "PlasmaUnhurt", ImpactPlasmaUnhurtCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Impact for:
+//				Plasma hitting player's handheld shields
+//-----------------------------------------------------------------------------
+void ImpactPlasmaShieldCallback( const CEffectData &data )
+{
+	trace_t tr;
+	Vector vecOrigin, vecStart, vecShotDir;
+	int iMaterial, iDamageType, iHitbox;
+	short nSurfaceProp;
+	ParseImpactData( data, &vecOrigin, &vecStart, &vecShotDir, nSurfaceProp, iMaterial, iDamageType, iHitbox );
+
+	// Bounce sparks away from the shield
+	// Don't call Impact() because we don't want to decal the player
+	Vector offset = vecOrigin - ( vecShotDir * 1.0f );
+	Vector vecDir = -vecShotDir + Vector(0,0,1.5);
+	g_pEffects->Sparks( offset, 2, 2, &vecDir );
+}
+
+DECLARE_CLIENT_EFFECT( "PlasmaShield", ImpactPlasmaShieldCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Impact for:
+//				Strider hitting anything
+//-----------------------------------------------------------------------------
+void ImpactStriderCallback( 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, play our splash
+	if ( Impact( vecOrigin, vecStart, iMaterial, iDamageType, iHitbox, pEntity, tr ) )
+	{
+		PerformCustomEffects( vecOrigin, tr, vecShotDir, iMaterial, 5 );
+	}
+}
+
+DECLARE_CLIENT_EFFECT( "Strider", ImpactStriderCallback );
+
+
+//=====================================================================================
+// SHARDS. 
+// Models for small impact tempents (not vphysics simulated)
+//--------------------------------------------------------------------
+// WOOD
+//--------------------------------------------------------------------
+#define WOOD_SHARDS		5
+const char *ImpactHurtShards_Wood_Small_Models[ WOOD_SHARDS ] = 
+{
+"models/props_debris/wood_shard_001.mdl",
+"models/props_debris/wood_shard_002.mdl",
+"models/props_debris/wood_shard_003.mdl",
+"models/props_debris/wood_shard_004.mdl",
+"models/props_debris/wood_shard_005.mdl",
+};
+// Model pointers for the above
+model_t *ImpactHurtShards_Wood_Small[ WOOD_SHARDS ];
+
+//--------------------------------------------------------------------
+// FOLIAGE
+//--------------------------------------------------------------------
+#define FOLIAGE_SHARDS		5
+const char *ImpactHurtShards_Foliage_Small_Models[ FOLIAGE_SHARDS ] = 
+{
+"models/props_debris/foliage_shard_001.mdl",
+"models/props_debris/foliage_shard_002.mdl",
+"models/props_debris/foliage_shard_003.mdl",
+"models/props_debris/foliage_shard_004.mdl",
+"models/props_debris/foliage_shard_005.mdl",
+};
+// Model pointers for the above
+model_t *ImpactHurtShards_Foliage_Small[ FOLIAGE_SHARDS ];
+
+//--------------------------------------------------------------------
+// CONCRETE
+//--------------------------------------------------------------------
+#define CONCRETE_SHARDS		1
+const char *ImpactHurtShards_Concrete_Small_Models[ CONCRETE_SHARDS ] = 
+{
+"models/props_debris/metal_shard_001.mdl",
+};
+// Model pointers for the above
+model_t *ImpactHurtShards_Concrete_Small[ CONCRETE_SHARDS ];
+
+//--------------------------------------------------------------------
+// METAL
+//--------------------------------------------------------------------
+#define METAL_SHARDS		6
+const char *ImpactHurtShards_Metal_Small_Models[ METAL_SHARDS ] = 
+{
+"models/props_debris/metal_shard_001.mdl",
+"models/props_debris/metal_shard_002.mdl",
+"models/props_debris/metal_shard_003.mdl",
+"models/props_debris/metal_shard_004.mdl",
+"models/props_debris/metal_shard_005.mdl",
+"models/props_debris/metal_shard_006.mdl",
+};
+// Model pointers for the above
+model_t *ImpactHurtShards_Metal_Small[ METAL_SHARDS ];
+
+//-----------------------------------------------------------------------------
+// Purpose: Precache all our shards
+//-----------------------------------------------------------------------------
+void PrecacheImpactShards(void *pUser)
+{
+	int i;
+
+	// Wood
+	for ( i = 0; i < WOOD_SHARDS; i++ )
+	{
+		const char *sFile = ImpactHurtShards_Wood_Small_Models[i];
+		ImpactHurtShards_Wood_Small[i] = (model_t *)engine->LoadModel( sFile );
+	}
+
+	// Foliage
+	for ( i = 0; i < FOLIAGE_SHARDS; i++ )
+	{
+		const char *sFile = ImpactHurtShards_Foliage_Small_Models[i];
+		ImpactHurtShards_Foliage_Small[i] = (model_t *)engine->LoadModel( sFile );
+	}
+
+	// Concrete
+	for ( i = 0; i < CONCRETE_SHARDS; i++ )
+	{
+		const char *sFile = ImpactHurtShards_Concrete_Small_Models[i];
+		ImpactHurtShards_Concrete_Small[i] = (model_t *)engine->LoadModel( sFile );
+	}
+
+	// Metal
+	for ( i = 0; i < METAL_SHARDS; i++ )
+	{
+		const char *sFile = ImpactHurtShards_Metal_Small_Models[i];
+		ImpactHurtShards_Metal_Small[i] = (model_t *)engine->LoadModel( sFile );
+	}
+}
+PRECACHE_REGISTER_FN(PrecacheImpactShards);
+
+//-----------------------------------------------------------------------------
+// Purpose: Throw out shards from the impact point to show we can hurt the target
+//-----------------------------------------------------------------------------
+void ImpactCreateHurtShards( Vector &vecOrigin, trace_t &tr, Vector &shotDir, int iMaterial, bool bLarge, bool bBlood )
+{
+	// Throw out the effect if any of these are true
+	if ( tr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) )
+		return;
+
+	float flShardSpread = 0.5;
+
+	Vector vecSpawnOrigin = vecOrigin;
+	
+	int iNumGibs = random->RandomInt( 1, 2 );
+	for ( int i = 0; i < iNumGibs; i++ )
+	{
+		QAngle vecAngles;
+		vecAngles[0] = random->RandomFloat(-255, 255);
+		vecAngles[1] = random->RandomFloat(-255, 255);
+		vecAngles[2] = random->RandomFloat(-255, 255);
+		Vector vecForceDir;
+		float spreadOfs = random->RandomFloat( 3.0f, 4.0f );
+		vecForceDir[0] = -shotDir[0] + random->RandomFloat( -(flShardSpread*spreadOfs), (flShardSpread*spreadOfs) );
+		vecForceDir[1] = -shotDir[1] + random->RandomFloat( -(flShardSpread*spreadOfs), (flShardSpread*spreadOfs) );
+		vecForceDir[2] = -shotDir[2] + random->RandomFloat( -(flShardSpread*spreadOfs), (flShardSpread*spreadOfs) );
+		// Add some extra vertical height
+		vecForceDir[2] += random->RandomFloat( 0, 5 );
+		vecForceDir *= random->RandomFloat( 30.0,60.0 );
+
+		model_t *pModel = NULL;
+		int iFlags = ( FTENT_COLLIDEWORLD | FTENT_FADEOUT | FTENT_GRAVITY );
+
+		// Select the right chunk for the job
+		switch ( iMaterial )
+		{
+		case CHAR_TEX_WOOD:
+			iFlags |= FTENT_ROTATE;
+			pModel = ImpactHurtShards_Wood_Small[ random->RandomInt(0,WOOD_SHARDS-1) ];
+			break;
+
+		case CHAR_TEX_FOLIAGE:
+			pModel = ImpactHurtShards_Foliage_Small[ random->RandomInt(0,FOLIAGE_SHARDS-1) ];
+			break;
+
+		case CHAR_TEX_METAL:
+		case CHAR_TEX_VENT:
+		case CHAR_TEX_GRATE:
+
+		case CHAR_TEX_CONCRETE:
+			default:
+			pModel = ImpactHurtShards_Metal_Small[ random->RandomInt(0,METAL_SHARDS-1) ];
+			break;
+
+		case CHAR_TEX_FLESH:
+			// Spray some blood out
+			if ( !bBlood )
+				return;
+
+			CEffectData	data;
+			data.m_vOrigin = vecOrigin;
+			data.m_vNormal = tr.plane.normal;
+			data.m_flScale = 4;
+			data.m_fFlags = FX_BLOODSPRAY_ALL;
+			data.m_nEntIndex = tr.m_pEnt ?  tr.m_pEnt->entindex() : 0;
+			DispatchEffect( "tf2blood", data );
+			return;
+			break;
+		/*
+		case CHAR_TEX_CONCRETE:
+		default:
+			pModel = ImpactHurtShards_Concrete_Small[ random->RandomInt(0,CONCRETE_SHARDS-1) ];
+			break;
+		*/
+		}
+		Assert( pModel );			
+
+		// ROBIN: Removed until optimized
+		return;
+
+		// Throw it out
+		tempents->SpawnTempModel( pModel, vecSpawnOrigin, vecAngles, vecForceDir, random->RandomFloat(0.5,1.5), iFlags );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Throw out breakable, vphysics gibs from the surface we hit
+//-----------------------------------------------------------------------------
+void ImpactCreateHurtGibs( Vector &vecOrigin, trace_t &tr, Vector &shotDir, int iMaterial, bool bLarge )
+{
+	// Throw out the effect if any of these are true
+	if ( tr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) )
+		return;
+
+	Vector vecSpawnOrigin = vecOrigin - (shotDir * 32);
+	float flGibSpread = 0.8;
+
+	// Custom TF2 impact effects
+	if ( iMaterial == CHAR_TEX_FOLIAGE )
+	{
+		int iNumGibs = random->RandomInt( 1, 2 );
+		for ( int i = 0; i < iNumGibs; i++ )
+		{
+			AngularImpulse angVel;
+			angVel.Random( -400.0f, 400.0f );
+			Vector vecForceDir;
+			float spreadOfs = random->RandomFloat( 3.0f, 4.0f );
+			vecForceDir[0] = -shotDir[0] + random->RandomFloat( -(flGibSpread*spreadOfs), (flGibSpread*spreadOfs) );
+			vecForceDir[1] = -shotDir[1] + random->RandomFloat( -(flGibSpread*spreadOfs), (flGibSpread*spreadOfs) );
+			vecForceDir[2] = -shotDir[2] + random->RandomFloat( -(flGibSpread*spreadOfs), (flGibSpread*spreadOfs) );
+			// Add some extra vertical height
+			vecForceDir[2] += 5;
+			vecForceDir *= random->RandomFloat( 10.0,30.0 );
+
+			//C_BreakableProp *pProp = new C_BreakableProp;
+			//pProp->CreateClientsideProp( ImpactHurtGibs_Wood_Small[ random->RandomInt(0,NUM_WOOD_GIBS_SMALL-1) ], vecSpawnOrigin, vecForceDir, angVel );
+		}
+	}
+	else 
+	{
+		PerformCustomEffects( vecOrigin, tr, shotDir, iMaterial, 1 );
+	}
+}
diff --git a/game/client/tf2/fx_tf2_tracers.cpp b/game/client/tf2/fx_tf2_tracers.cpp
new file mode 100644
index 0000000..b91552b
--- /dev/null
+++ b/game/client/tf2/fx_tf2_tracers.cpp
@@ -0,0 +1,105 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Game-specific impact effect hooks
+//
+//=============================================================================//
+#include "cbase.h"
+#include "fx.h"
+#include "c_te_effect_dispatch.h"
+#include "clienteffectprecachesystem.h"
+#include "clientsideeffects.h"
+
+// Precache the effects
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheTF2TracerEffects )
+CLIENTEFFECT_MATERIAL( "effects/human_bullet" )
+CLIENTEFFECT_MATERIAL( "effects/alien_laser" )
+CLIENTEFFECT_REGISTER_END()
+
+Vector GetTracerOrigin( const CEffectData &data );
+
+//-----------------------------------------------------------------------------
+// Purpose: Human's laser rifle Tracer
+//-----------------------------------------------------------------------------
+void HLaserTracerCallback( const CEffectData &data )
+{
+	float flVelocity = data.m_flScale;
+	Vector vecStart = GetTracerOrigin( data );
+	Vector vecEnd = data.m_vOrigin;
+	Vector shotDir;
+
+	// Get out shot direction and length
+	VectorSubtract( vecEnd, vecStart, shotDir );
+	float totalDist = VectorNormalize( shotDir );
+
+	// Don't make small tracers
+	if ( totalDist <= 32 )
+		return;
+
+	float length = MAX( 64, random->RandomFloat( 200.0f, 256.0f ) );
+	flVelocity = random->RandomFloat( 5000, 7000 );
+	float life = ( totalDist + length ) / flVelocity;
+	float flWidth = random->RandomFloat( 2.0, 2.5 );
+	
+	// Add it
+	FX_AddDiscreetLine( vecStart, shotDir, flVelocity, length, totalDist, flWidth, life, "effects/human_bullet" );
+}
+
+DECLARE_CLIENT_EFFECT( "HLaserTracer", HLaserTracerCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Alien's laser rifle Tracer
+//-----------------------------------------------------------------------------
+void ALaserTracerCallback( const CEffectData &data )
+{
+	float flVelocity = data.m_flScale;
+	Vector vecStart = GetTracerOrigin( data );
+	Vector vecEnd = data.m_vOrigin;
+	Vector shotDir;
+
+	// Get out shot direction and length
+	VectorSubtract( vecEnd, vecStart, shotDir );
+	float totalDist = VectorNormalize( shotDir );
+
+	// Don't make small tracers
+	if ( totalDist <= 32 )
+		return;
+
+	float length = MAX( 64, random->RandomFloat( 512.0f, 768.0f ) );
+	flVelocity = random->RandomFloat( 5000, 7000 );
+	float life = ( totalDist + length ) / flVelocity;
+	float flWidth = random->RandomFloat( 2.0, 3.0 );
+	
+	// Add it
+	FX_AddDiscreetLine( vecStart, shotDir, flVelocity, length, totalDist, flWidth, life, "effects/alien_laser" );
+}
+
+DECLARE_CLIENT_EFFECT( "ALaserTracer", ALaserTracerCallback );
+
+//-----------------------------------------------------------------------------
+// Purpose: Alien's minigun tracer
+//-----------------------------------------------------------------------------
+void MinigunTracerCallback( const CEffectData &data )
+{
+	float flVelocity = data.m_flScale;
+	Vector vecStart = GetTracerOrigin( data );
+	Vector vecEnd = data.m_vOrigin;
+	Vector shotDir;
+
+	// Get out shot direction and length
+	VectorSubtract( vecEnd, vecStart, shotDir );
+	float totalDist = VectorNormalize( shotDir );
+
+	// Don't make small tracers
+	if ( totalDist <= 32 )
+		return;
+
+	float length = MAX( 64, random->RandomFloat( 200.0f, 256.0f ) );
+	flVelocity = random->RandomFloat( 5000, 7000 );
+	float life = ( totalDist + length ) / flVelocity;
+	float flWidth = random->RandomFloat( 1.5, 2.0 );
+	
+	// Add it
+	FX_AddDiscreetLine( vecStart, shotDir, flVelocity, length, totalDist, flWidth, life, "effects/alien_laser" );
+}
+
+DECLARE_CLIENT_EFFECT( "MinigunTracer", MinigunTracerCallback );
diff --git a/game/client/tf2/ground_line.cpp b/game/client/tf2/ground_line.cpp
new file mode 100644
index 0000000..b59cb33
--- /dev/null
+++ b/game/client/tf2/ground_line.cpp
@@ -0,0 +1,418 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "ground_line.h"
+#include "mathlib/vplane.h"
+#include "beamdraw.h"
+#include "bitvec.h"
+#include "clientmode_commander.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+#include "clienteffectprecachesystem.h"
+#include "tier0/vprof.h"
+
+#define MAX_DOWN_DIST	300
+#define MAX_UP_DIST		300
+#define XY_PER_SEGMENT	100
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheGroundLine )
+CLIENTEFFECT_MATERIAL( "player/support/mortarline" )
+CLIENTEFFECT_REGISTER_END()
+
+static CUtlLinkedList< CGroundLine*, unsigned short >	s_GroundLines; 
+
+// ---------------------------------------------------------------------- //
+// Helpers.
+// ---------------------------------------------------------------------- //
+
+VPlane VPlaneFromCPlane(const cplane_t &plane)
+{
+	if(plane.signbits)
+		return VPlane(-plane.normal, -plane.dist);
+	else
+		return VPlane(plane.normal, plane.dist);
+}
+
+
+Vector ClipEndPos(const Vector &vStart, const Vector &vEnd, float clipDist, VPlane *pPlane)
+{
+	trace_t trace;
+
+	UTIL_TraceLine(vStart, vEnd, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace);
+	if(trace.fraction < 1)
+	{
+		*pPlane = VPlaneFromCPlane(trace.plane);
+		return trace.endpos + pPlane->m_Normal * clipDist;
+	}
+	else
+	{
+		pPlane->m_Normal.Init(0,0,1);
+		pPlane->m_Dist = DotProduct(pPlane->m_Normal, vEnd);
+		return vEnd;
+	}
+}
+
+// Tries to find the closest surface point to the specified point.
+Vector FindBestSurfacePoint(const Vector &vPos)
+{
+	static float stepDist = 500;
+	static float flHeightAboveGround = 20;
+
+	// First, find an inside point.
+
+	// Test upwards.
+	trace_t trace;
+	UTIL_TraceLine(
+		Vector(vPos[0], vPos[1], vPos[2] + stepDist),
+		vPos,
+		MASK_SOLID_BRUSHONLY,
+		NULL,
+		COLLISION_GROUP_NONE,
+		&trace);
+	if(trace.fraction < 1 && trace.fraction != 0)
+	{
+		return Vector(trace.endpos[0], trace.endpos[1], trace.endpos[2] + flHeightAboveGround );
+	}
+
+	// Test down.
+	UTIL_TraceLine(
+		vPos,
+		Vector(vPos[0], vPos[1], vPos[2] - stepDist),
+		MASK_SOLID_BRUSHONLY,
+		NULL,
+		COLLISION_GROUP_NONE,
+		&trace);
+	if(trace.fraction < 1 && trace.fraction != 0)
+	{
+		return Vector(trace.endpos[0], trace.endpos[1], trace.endpos[2] + flHeightAboveGround );
+	}
+
+	return vPos;
+}
+
+
+// Tries to find the place in the world geometry which blocks vStart from the line segment (vEnd1, vEnd2).
+// Uses a binary search so your error is |vEnd2 - vEnd1| ^ (1 / nIterations)
+bool BinSearchSegments(const Vector &vStart, const Vector &vEnd1, const Vector &vEnd2, int nIterations, Vector *out)
+{
+	trace_t trace;
+	
+	// If what was passed into us already intersects then there's nothing we can do.
+	UTIL_TraceLine(vStart, vEnd2, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace);
+	if(trace.fraction < 1)
+		return false;
+
+	Vector vecs[2] = {vEnd1, vEnd2};
+	int iIntersect = 0;	// Which vector intersects.
+	for(int i=0; i < nIterations; i++)
+	{
+		// Test the midpoint.
+		Vector mid = (vecs[0] + vecs[1]) * 0.5f;
+		UTIL_TraceLine(vStart, mid, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace);
+		if(trace.fraction < 1)
+			vecs[iIntersect] = mid;
+		else
+			vecs[!iIntersect] = mid;
+	}
+
+	*out = (vecs[0] + vecs[1]) * 0.5f;
+	return true;
+}
+
+// Tries to snap the point to its underlying plane's z.
+Vector SnapToPlane(const Vector &v)
+{
+return v;
+
+	trace_t trace;
+	UTIL_TraceLine(Vector(v[0], v[1], v[2] + 50), Vector(v[0], v[1], v[2] - 50), 
+		MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace);
+	if(trace.fraction < 1)
+		return Vector(v[0], v[1], trace.endpos[2] + 3);
+	else
+		return v;
+}
+
+
+
+// ---------------------------------------------------------------------- //
+// CGroundLine implementation.
+// ---------------------------------------------------------------------- //
+
+CGroundLine::CGroundLine()
+: BaseClass( NULL, "CGroundLine" )
+{
+	m_pMaterial = NULL;
+
+	m_ListHandle = s_GroundLines.AddToHead( this );
+	SetParent( CMinimapPanel::MinimapRootPanel() );
+
+	m_nPoints = 0;
+	SetVisible( true );
+	SetPaintBackgroundEnabled( false );
+}
+
+
+CGroundLine::~CGroundLine()
+{
+	s_GroundLines.Remove( m_ListHandle );
+	
+	m_vStart.Init();
+	m_vEnd.Init();
+	m_LineWidth = 1;
+}
+
+
+bool CGroundLine::Init(const char *pMaterialName)
+{
+	m_pMaterial = materials->FindMaterial(pMaterialName, TEXTURE_GROUP_CLIENT_EFFECTS);
+	return !!m_pMaterial;
+}
+
+
+void CGroundLine::SetParameters(
+	const Vector &vStart, 
+	const Vector &vEnd, 
+	const Vector &vStartColor,	// Color values 0-1
+	const Vector &vEndColor,
+	float alpha,
+	float lineWidth
+	)
+{
+	m_vStart = vStart;
+	m_vEnd = vEnd;
+	m_vStartColor = vStartColor;
+	m_vEndColor = vEndColor;
+	m_Alpha = alpha;
+	m_LineWidth = lineWidth;
+
+	Vector vTo( vEnd.x - vStart.x, vEnd.y - vStart.y, 0 );
+	float flXYLen = vTo.Length();
+
+	// Recalculate our segment list.
+	unsigned int nSteps = (int)flXYLen / XY_PER_SEGMENT;
+	nSteps = clamp( nSteps, 8, MAX_GROUNDLINE_SEGMENTS ) & ~1;
+	unsigned int nMaxSteps = nSteps / 2;
+
+	// First generate the sequence. We generate every other point here so it can insert fixup points to prevent
+	// it from crossing world geometry.
+	Vector pt[MAX_GROUNDLINE_SEGMENTS];
+	Vector vStep = (Vector(m_vEnd[0], m_vEnd[1], 0) - Vector(m_vStart[0], m_vStart[1], 0)) / (nMaxSteps-1);
+
+	pt[0] = FindBestSurfacePoint(m_vStart);
+
+	unsigned int i;
+	for(i=1; i < nMaxSteps; i++)
+		pt[i<<1] = FindBestSurfacePoint(pt[(i-1)<<1] + vStep);
+
+
+	CBitVec<MAX_GROUNDLINE_SEGMENTS> pointsUsed;
+	pointsUsed.ClearAll();
+
+	// Now try to make sure they don't intersect the geometry.
+	for(i=0; i < nMaxSteps-1; i++)
+	{
+		Vector &a = pt[i<<1];
+		Vector &b = pt[(i+1)<<1];
+
+		trace_t trace;
+		UTIL_TraceLine(a, b, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace);
+		if(trace.fraction < 1)
+		{
+			int cIndex = (i<<1)+1;
+			Vector &c = pt[cIndex];
+
+			// Ok, this line segment intersects the world. Do a binary search to try to find the
+			// point of intersection.
+			Vector hi, lo;
+			if(a.z < b.z)
+			{
+				hi = b;
+				lo = a;
+			}
+			else
+			{
+				hi = a;
+				lo = b;
+			}
+
+			if(BinSearchSegments(lo, hi, Vector(lo[0],lo[1],hi[2]), 15, &c))
+			{
+				pointsUsed.Set( cIndex );
+			}
+			else if(BinSearchSegments(lo, hi, Vector(hi[0],hi[1],hi[2]+500), 15, &c))
+			{
+				pointsUsed.Set( cIndex );
+			}
+		}
+	}
+
+	// Export the points.
+	m_nPoints = 0;
+	for(i=0; i < nSteps; i++)
+	{
+		// Every other point is always active.
+		if( pointsUsed.Get( i ) || !(i & 1) )
+		{
+			m_Points[m_nPoints] = pt[i];
+			++m_nPoints;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the visibility of the groundline
+//-----------------------------------------------------------------------------
+void CGroundLine::SetVisible( bool bVisible )
+{
+	m_bVisible = bVisible;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the groundline's visible
+//-----------------------------------------------------------------------------
+bool CGroundLine::IsVisible( void )
+{
+	return m_bVisible;
+}
+
+void CGroundLine::DrawAllGroundLines()
+{
+	VPROF("CGroundLine::DrawAllGroundLines()");
+	unsigned short i;
+	for( i = s_GroundLines.Head(); i != s_GroundLines.InvalidIndex(); i = s_GroundLines.Next(i) )
+	{
+		s_GroundLines[i]->Draw();
+	}
+}
+
+void CGroundLine::Draw()
+{
+	if ( !m_pMaterial || m_nPoints < 2 )
+		return;
+	if ( !IsVisible() )
+		return;
+	
+	float flAlpha = m_Alpha;
+	if( g_pClientMode == ClientModeCommander() )
+	{
+		flAlpha = 1; // draw bright..
+	}
+
+	CBeamSegDraw beamDraw;
+	beamDraw.Start( m_nPoints, m_pMaterial );
+	
+		for( unsigned int i=0; i < m_nPoints; i++ )
+		{
+			float t = (float)i / (m_nPoints - 1);
+
+			CBeamSeg seg;
+			seg.m_vPos = m_Points[i];
+			VectorLerp( m_vStartColor, m_vEndColor, t, seg.m_vColor );
+			seg.m_flTexCoord = 0;
+			seg.m_flWidth = m_LineWidth;
+			seg.m_flAlpha = m_Alpha;
+
+			beamDraw.NextSeg( &seg );
+		}
+	
+	beamDraw.End();
+}
+
+
+static inline bool ClipLine( float &x1, float &y1, float &x2, float &y2, float xClip, float sign )
+{
+	if( x1*sign < (xClip-0.001f)*sign )
+	{
+		if( x2*sign > (xClip+0.001f)*sign )
+		{
+			float t = (xClip-x1) / (x2 - x1);
+			x1 = x1 + (x2 - x1) * t;
+			y1 = y1 + (y2 - y1) * t;
+		}
+		else
+		{
+			return false;
+		}
+	}
+	else if( x2*sign < (xClip-0.001f)*sign )
+	{
+		if( x1*sign > (xClip+0.001f)*sign )
+		{
+			float t = (xClip-x1) / (x2 - x1);
+			x2 = x1 + (x2 - x1) * t;
+			y2 = y1 + (y2 - y1) * t;
+		}
+		else
+		{
+			return false;
+		}
+	}
+	
+	return true;
+}
+
+
+void CGroundLine::Paint( )
+{
+	vgui::Panel *pPanel = GetParent();
+	int wide, tall;
+	pPanel->GetSize( wide, tall );
+	
+	float tPrev = 0;
+	float xPrev, yPrev;
+	CMinimapPanel::MinimapPanel()->WorldToMinimap( MINIMAP_NOCLIP, m_vStart, xPrev, yPrev );
+
+	int nSegs = 20;
+	for( int iSeg=1; iSeg <= nSegs; iSeg++ )
+	{
+		float t = (float)iSeg / nSegs;
+
+		Vector v3DPos;
+		VectorLerp( m_vStart, m_vEnd, t, v3DPos );
+
+		float x, y;
+		CMinimapPanel::MinimapPanel()->WorldToMinimap( MINIMAP_NOCLIP, v3DPos, x, y );
+
+		// Clip the line segment on X, then Y.
+		if( ClipLine( xPrev, yPrev, x, y, 0,     1 ) &&
+			ClipLine( xPrev, yPrev, x, y, wide, -1 ) &&
+			ClipLine( yPrev, xPrev, y, x, 0,     1 ) &&
+			ClipLine( yPrev, xPrev, y, x, tall, -1 ) )
+		{
+			Vector vColor;
+			VectorLerp( m_vStartColor, m_vEndColor, t, vColor );
+			vColor *= 255.9f;
+
+			vgui::surface()->DrawSetColor( 
+				(unsigned char)RoundFloatToInt( vColor.x ), 
+				(unsigned char)RoundFloatToInt( vColor.y ), 
+				(unsigned char)RoundFloatToInt( vColor.z ), 
+				255 );
+
+			vgui::surface()->DrawLine( xPrev, yPrev, x, y );
+		}
+
+		tPrev = t;
+		xPrev = x;
+		yPrev = y;
+	}
+
+	// Draw a marker at the endpoint.
+	float xEnd, yEnd;
+	if( CMinimapPanel::MinimapPanel()->WorldToMinimap( MINIMAP_NOCLIP, m_vEnd, xEnd, yEnd ) )
+	{
+		int ix = RoundFloatToInt( xEnd );
+		int iy = RoundFloatToInt( yEnd );
+		int rectSize=1;
+
+		vgui::surface()->DrawSetColor( 255, 255, 255, 255 );
+		vgui::surface()->DrawOutlinedRect( ix-rectSize, iy-rectSize, ix+rectSize, iy+rectSize );
+	}
+}
+
+
diff --git a/game/client/tf2/ground_line.h b/game/client/tf2/ground_line.h
new file mode 100644
index 0000000..4164977
--- /dev/null
+++ b/game/client/tf2/ground_line.h
@@ -0,0 +1,80 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GROUND_LINE_H
+#define GROUND_LINE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "mathlib/vector.h"
+#include "hud_minimap.h"
+
+
+class IMaterial;
+
+
+#define MAX_GROUNDLINE_SEGMENTS	100
+
+
+// This class will lay out a line of a specified width along the ground. It follows
+// the contour of the ground as well as it can.
+class CGroundLine : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+
+public:
+					CGroundLine();
+					~CGroundLine();
+
+	// One-time initialization.
+	bool			Init(const char *pMaterialName);
+
+	// Setup the line's rendering parameters.
+	void			SetParameters(
+		const Vector &vStart, 
+		const Vector &vEnd, 
+		const Vector &vStartColor,	// Color values 0-1
+		const Vector &vEndColor,	// Color values 0-1
+		float alpha,
+		float lineWidth
+		);
+
+	// Called by the renderer when it's time to render the ground lines.
+	static void		DrawAllGroundLines();
+
+	// Set the visibility
+	void			SetVisible( bool bVisible );
+	bool			IsVisible( void );
+
+private:
+	
+	// Draw a line along the ground.
+	void			Draw();
+	void			Paint();
+
+private:
+	// Rendering parameters.
+	IMaterial		*m_pMaterial;
+	Vector			m_vStartColor;
+	Vector			m_vEndColor;
+	float			m_Alpha;
+	Vector			m_vStart;
+	Vector			m_vEnd;
+	float			m_LineWidth;
+	bool			m_bVisible;
+
+	// Points along the line.
+	Vector			m_Points[MAX_GROUNDLINE_SEGMENTS];
+	unsigned int	m_nPoints;
+
+	unsigned short	m_ListHandle;
+};
+
+
+#endif // GROUND_LINE_H
diff --git a/game/client/tf2/hintitembase.cpp b/game/client/tf2/hintitembase.cpp
new file mode 100644
index 0000000..e098306
--- /dev/null
+++ b/game/client/tf2/hintitembase.cpp
@@ -0,0 +1,425 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hintitembase.h"
+#include <vgui_controls/Controls.h>
+#include <vgui_controls/Label.h>
+#include <vgui/IVGui.h>
+#include <vgui/ISurface.h>
+#include <vgui/IScheme.h>
+#include <vgui/ILocalize.h>
+#include <KeyValues.h>
+#include "PanelEffect.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+// Input  : *parent - 
+//			*panelName - 
+//			*text - 
+//			itemwidth - 
+//-----------------------------------------------------------------------------
+CHintItemBase::CHintItemBase( vgui::Panel *parent, const char *panelName )
+: BaseClass( parent, panelName ), m_pObject( NULL )
+{
+	m_pLabel = new vgui::Label( this, "TFTextHint", "" );
+	m_pLabel->SetContentAlignment( vgui::Label::a_west );
+	
+	//	m_pIndex = new vgui::Label( this, "TFTextHintIndex", "" );
+	//	m_pIndex->setContentAlignment( vgui::Label::a_west );
+	//	m_pIndex->SetBounds( 20, 0, 20, 20 );
+	//	m_nIndex = 0;	
+	
+	m_bCompleted = false;
+	m_bActive = false;
+	m_flActivateTime = 0.0f;
+	
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	SetFormatString( "" );
+
+	m_bAutoComplete			= false;
+	m_flAutoCompleteTime	= 0.0f;
+
+	m_hSmallFont = m_hMarlettFont = 0; 
+}
+
+
+//-----------------------------------------------------------------------------
+// Scheme settings
+//-----------------------------------------------------------------------------
+void CHintItemBase::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+
+	m_hSmallFont = pScheme->GetFont( "DefaultVerySmall" );
+	m_hMarlettFont = pScheme->GetFont( "Marlett" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pKeyValues - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::ParseItem( KeyValues *pKeyValues )
+{
+	if ( !pKeyValues )
+		return;
+	
+	const char *title = pKeyValues->GetString( "title", "" );
+	if ( title )
+	{
+		SetText( title );
+	}
+
+	const char *fmt = pKeyValues->GetString( "formatstring", "" );
+	if ( fmt )
+	{
+		SetFormatString( fmt );
+	}
+
+	const char *autocomplete = pKeyValues->GetString( "autocomplete" );
+	if ( autocomplete && autocomplete[ 0 ] )
+	{
+		SetAutoComplete( ( float ) atof( autocomplete ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : elapsed_time - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetAutoComplete( float elapsed_time )
+{
+	m_bAutoComplete = true;
+	m_flAutoCompleteTime = elapsed_time;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : newWide - 
+//			newTall - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::OnSizeChanged( int newWide, int newTall )
+{
+	m_pLabel->SetBounds( 20, 0, GetWide() - 20, newTall );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *text - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetText( const char *text )
+{
+	m_pLabel->SetText( text );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *fmt - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetFormatString( const char *fmt )
+{
+	Q_strncpy( m_szFormatString, fmt, MAX_TEXT_LENGTH );
+	m_bUseFormatString = fmt[ 0 ] ? true : false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CHintItemBase::GetFormatString( void )
+{
+	Assert( m_bUseFormatString );
+	return m_szFormatString;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *instring - 
+//			keylength - 
+//			**ppOutstring - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintItemBase::CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring )
+{
+	Assert( m_bUseFormatString );
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintItemBase::ComputeTitle( void )
+{
+	if ( !m_bUseFormatString )
+		return;
+
+	char fixed[ MAX_TEXT_LENGTH ];
+
+	char *in, *out;
+	in = m_szFormatString;
+	out = fixed;
+
+	while ( *in )
+	{
+		if ( *in == '!' && *(in+1) == '!' )
+		{
+			in += 2;
+
+			int length;
+			const char *text;
+
+			if ( CheckKeyAndValue( in, &length, &text ) )
+			{
+				const char *t = text;
+				while ( *t )
+				{
+					*out++ = *t++;
+				}
+
+				in += length;
+			}
+		}
+		else
+		{
+			*out++ = *in++;
+		}
+	}
+
+	*out = 0;
+
+	SetText( fixed );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *binding - 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *CHintItemBase::GetKeyNameForBinding( const char *binding )
+{
+	const char *keyname = engine->Key_LookupBinding( binding );
+	if ( keyname )
+	{
+		return keyname;
+	}
+
+	// Return original string if not bound to a key
+	return binding;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Delete's the hint object
+//-----------------------------------------------------------------------------
+void CHintItemBase::DeleteThis( void )
+{
+	// Remove any associated effects
+	DestroyPanelEffects( this );
+	
+	delete this;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : incolor - 
+//			frac - 
+// Output : static int
+//-----------------------------------------------------------------------------
+static int TextHintColorMod( int incolor, float frac )
+{
+	int maxcolor = incolor + (int)( ( 255.0f - (float)incolor ) / 2.0f );
+	int midcolor = ( maxcolor + incolor ) / 2;
+	int range = maxcolor - midcolor;
+	
+	int clr = midcolor + range * frac;
+	
+	clr = clamp( clr, 0, 255 );
+	return clr;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintItemBase::PaintBackground()
+{
+	// force label color
+	if ( m_pLabel )
+	{
+		m_pLabel->SetFgColor( Color( 0, 0, 0, 255 ) );
+		m_pLabel->SetBgColor( Color( 0, 0, 0, 0 ) );
+	}
+	
+	int w, h;
+	
+	GetSize( w, h );
+	
+	float f2 = 0.0f;
+	
+	float dt =  gpGlobals->curtime - m_flActivateTime; 
+	
+	if ( dt < 5.0f )
+	{
+		f2 = fmod( gpGlobals->curtime, 1.0f );
+	}
+	
+	int r = 80;
+	int g = 105;
+	int b = 90;
+	
+	vgui::surface()->DrawSetTextFont( m_hMarlettFont );
+	vgui::surface()->DrawSetTextColor( r, g, b, 255 );
+	vgui::surface()->DrawSetTextPos( 2 + 3 * f2, 3 );
+
+	wchar_t ch[2];
+	g_pVGuiLocalize->ConvertANSIToUnicode( "4", ch, sizeof( ch ) );
+	vgui::surface()->DrawPrintText( ch, 1 );
+
+	if ( m_bAutoComplete )
+	{
+		vgui::surface()->DrawSetTextColor( 0, 0, 0, 63 );
+		vgui::surface()->DrawSetTextFont( m_hSmallFont );
+
+		char sz[ 32 ];
+		
+		int len = Q_snprintf( sz, sizeof( sz ), "%i", (int)( m_flAutoCompleteTime + 0.5f ) );
+
+		int x = w - len * 10 - 2;
+		int y = 6;
+
+		wchar_t szconverted[ 32 ];
+		g_pVGuiLocalize->ConvertANSIToUnicode( sz, szconverted, sizeof(szconverted)  );
+
+		vgui::surface()->DrawSetTextPos( x, y );
+		vgui::surface()->DrawPrintText( szconverted, wcslen( szconverted ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintItemBase::GetCompleted( void )
+{
+	return m_bCompleted;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : active - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetActive( bool active )
+{
+	bool changed = m_bActive != active;
+	
+	m_bActive = active;
+	
+	if ( !changed )
+		return;
+	
+	if ( m_bActive )
+	{
+		m_flActivateTime = gpGlobals->curtime;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintItemBase::GetActive( void )
+{
+	return m_bActive;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintItemBase::ShouldRenderPanelEffects( void )
+{
+	// By default, render active item's effects.
+	// A hint could have it's effects always render, though
+	return GetActive();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintItemBase::Think( void )
+{
+	// Check for completion
+	if ( m_bAutoComplete && GetActive() )
+	{
+		m_flAutoCompleteTime -= gpGlobals->frametime;
+		if ( m_flAutoCompleteTime <= 0.0f )
+		{
+			m_bCompleted = true;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CHintItemBase::GetHeight( void )
+{
+	return GetTall();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetPosition( int x, int y )
+{
+	SetPos( x, y );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : index - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetItemNumber( int index )
+{
+/*
+m_nIndex = index;
+
+  char sz[ 32 ];
+  Q_snprintf( sz, sizeof( sz ), "%i", m_nIndex );
+  
+	m_pIndex->setText( sz );
+	*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : visible - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetVisible( bool visible )
+{
+	BaseClass::SetVisible( visible );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetHintTarget( vgui::Panel *panel )
+{
+	m_pObject = panel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *key - 
+//			*value - 
+//-----------------------------------------------------------------------------
+void CHintItemBase::SetKeyValue( const char *key, const char *value )
+{
+}
diff --git a/game/client/tf2/hintitembase.h b/game/client/tf2/hintitembase.h
new file mode 100644
index 0000000..78878ea
--- /dev/null
+++ b/game/client/tf2/hintitembase.h
@@ -0,0 +1,113 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HINTITEMBASE_H
+#define HINTITEMBASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Panel.h>
+#include "itfhintitem.h"
+
+class C_TFBaseHint;
+class CHintItemBase;
+
+namespace vgui
+{
+	class Label;
+}
+
+#define DECLARE_HINTITEMFACTORY( className ) \
+	CHintItemBase *Create_##className##( vgui::Panel *parent, const char *panelName ) \
+	{ return new className( parent, panelName ); }
+
+#define GET_HINTITEMFACTORY_NAME( className ) Create_##className
+
+#define DECLARE_HINTFACTORY( className ) \
+	C_TFBaseHint *Create_##className##( int id, int entity ) \
+	{ return new className( id, 0, entity, NULL ); }
+
+#define GET_HINTFACTORY_NAME( className ) Create_##className
+
+//-----------------------------------------------------------------------------
+// Purpose: A hint that shows up as a single line o text
+//-----------------------------------------------------------------------------
+class CHintItemBase : public vgui::Panel, public ITFHintItem
+{
+	DECLARE_CLASS_GAMEROOT( CHintItemBase, vgui::Panel );
+
+public:
+	CHintItemBase( vgui::Panel *parent, const char *panelName );
+
+	// Draw some extra stuff in the Bg
+	virtual void	PaintBackground();
+	virtual void	OnSizeChanged( int newWide, int newTall );
+	virtual void	SetText( const char *text );
+
+	virtual void	SetFormatString( const char *fmt );
+	virtual const char *GetFormatString( void );
+	// If using format string
+	virtual bool	CheckKeyAndValue( const char *instring, int* keylength, const char **ppOutstring );
+	virtual void	ComputeTitle( void );
+
+	virtual void	SetAutoComplete( float elapsed_time );
+
+	// Scheme settings
+	virtual void	ApplySchemeSettings(vgui::IScheme *pScheme);
+
+	// Helper
+	virtual const char *GetKeyNameForBinding( const char *binding );
+
+	// Implement ITFHintItem
+	virtual void	ParseItem( KeyValues *pKeyValues );
+	virtual bool	GetCompleted( void );
+	virtual void	SetActive( bool active );
+	virtual bool	GetActive( void );
+	virtual void	Think( void );
+	virtual int		GetHeight( void );
+	virtual void	SetPosition( int x, int y );
+	virtual void	DeleteThis( void );
+	virtual void	SetItemNumber( int index );
+	virtual void	SetVisible( bool visible );
+	virtual void	SetHintTarget( vgui::Panel *panel );
+	virtual bool	ShouldRenderPanelEffects( void );
+	virtual void	SetKeyValue( const char *key, const char *value );
+protected:
+	enum
+	{
+		MAX_TEXT_LENGTH = 256,
+	};
+
+	// Has the hint item been completed
+	bool			m_bCompleted;
+	// Is the hint item active
+	bool			m_bActive;
+	// Text of hint
+	vgui::Label		*m_pLabel;
+	// Depends on type of hint
+	vgui::Panel		*m_pObject;
+	// Time the hint was activated
+	float			m_flActivateTime;
+
+	//	vgui::Label		*m_pIndex;
+	// Index of hint
+	//int				m_nIndex;
+
+	bool			m_bUseFormatString;
+	char			m_szFormatString[ MAX_TEXT_LENGTH ];
+
+	bool			m_bAutoComplete;
+	float			m_flAutoCompleteTime;
+
+	vgui::HFont		m_hSmallFont;
+	vgui::HFont		m_hMarlettFont;
+};
+
+CHintItemBase *CreateHintItem( vgui::Panel *parent, const char *name );
+
+#endif // HINTITEMBASE_H
diff --git a/game/client/tf2/hintitemobjectbase.cpp b/game/client/tf2/hintitemobjectbase.cpp
new file mode 100644
index 0000000..b5b0c5c
--- /dev/null
+++ b/game/client/tf2/hintitemobjectbase.cpp
@@ -0,0 +1,79 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hintitemobjectbase.h"
+#include <KeyValues.h>
+#include "c_obj_resourcepump.h"
+#include "c_func_resource.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintItemObjectBase::CHintItemObjectBase( vgui::Panel *parent, const char *panelName )
+: BaseClass( parent, panelName )
+{
+	SetObjectType( "" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pKeyValues - 
+//-----------------------------------------------------------------------------
+void CHintItemObjectBase::ParseItem( KeyValues *pKeyValues )
+{
+	BaseClass::ParseItem( pKeyValues );
+	
+	const char *type = pKeyValues->GetString( "type", "" );
+	if ( type )
+	{
+		SetObjectType( type );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *object - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHintItemObjectBase::IsObjectOfType( C_BaseEntity *object )
+{
+	if ( !stricmp( GetObjectType(), "Resource Zone" ) )
+	{
+		return dynamic_cast< C_ResourceZone *>( object ) ? true : false;
+	}
+	else if ( !stricmp( GetObjectType(), "Resource Pump" ) )
+	{
+		return dynamic_cast< C_ObjectResourcePump * >( object) ? true : false;
+	}
+	else if ( !stricmp( GetObjectType(), "BaseObject" ) )
+	{
+		return dynamic_cast< C_BaseObject * >( object) ? true : false;
+	}
+	
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *type - 
+//-----------------------------------------------------------------------------
+void CHintItemObjectBase::SetObjectType( const char *type )
+{
+	Q_strncpy( m_szObjectType, type, MAX_OBJECT_TYPE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CHintItemObjectBase::GetObjectType( void )
+{
+	return m_szObjectType;
+}
\ No newline at end of file
diff --git a/game/client/tf2/hintitemobjectbase.h b/game/client/tf2/hintitemobjectbase.h
new file mode 100644
index 0000000..a55fd9f
--- /dev/null
+++ b/game/client/tf2/hintitemobjectbase.h
@@ -0,0 +1,43 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HINTITEMOBJECTBASE_H
+#define HINTITEMOBJECTBASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "hintitemorderbase.h"
+
+class C_BaseEntity;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintItemObjectBase : public CHintItemOrderBase
+{
+	DECLARE_CLASS( CHintItemObjectBase, CHintItemOrderBase );
+	
+public:
+	CHintItemObjectBase( vgui::Panel *parent, const char *panelName );
+	
+	virtual void		ParseItem( KeyValues *pKeyValues );
+	// Is the object of type m_szObjectType
+	virtual bool		IsObjectOfType( C_BaseEntity *object );
+	virtual void		SetObjectType( const char *type );
+	virtual char const	*GetObjectType( void );
+	
+private:
+	enum
+	{
+		MAX_OBJECT_TYPE = 128,
+	};
+	
+	char				m_szObjectType[ MAX_OBJECT_TYPE ];
+};
+
+#endif // HINTITEMOBJECTBASE_H
diff --git a/game/client/tf2/hintitemorderbase.cpp b/game/client/tf2/hintitemorderbase.cpp
new file mode 100644
index 0000000..6b3073d
--- /dev/null
+++ b/game/client/tf2/hintitemorderbase.cpp
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hintitemorderbase.h"
+#include "paneleffect.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHintItemOrderBase::CHintItemOrderBase( vgui::Panel *parent, const char *panelName )
+: BaseClass( parent, panelName )
+{
+	m_bEffects = false;
+	m_LineEffect = EFFECT_INVALID_HANDLE;
+	m_FlashEffect = EFFECT_INVALID_HANDLE;
+
+	DrawAxialLineToOrder();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHintItemOrderBase::DrawAxialLineToOrder( void )
+{
+	// Derived class already set up effects
+	if ( m_bEffects )
+		return;
+
+	m_bEffects = true;
+
+	// Flash for vote order
+	m_FlashEffect = CreateFlashEffect( this, NULL );
+	// Flash the hint panel itself
+	CreateFlashEffect( this, GetParent() );
+	// Point from hint to vote order panel
+	m_LineEffect = CreateAxialLineEffect( this, GetParent(), NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void CHintItemOrderBase::SetHintTarget( vgui::Panel *panel )
+{
+	BaseClass::SetHintTarget( panel );
+
+	if ( !m_bEffects )
+		return;
+
+	// Update effect target
+	if ( !panel || !g_pTF2RootPanel )
+		return;
+	
+	CPanelEffect *e = g_pTF2RootPanel->FindEffect( m_LineEffect );
+	if ( e )
+	{
+		e->SetPanelOther( panel );
+	}
+	
+	e = g_pTF2RootPanel->FindEffect( m_FlashEffect );
+	if ( e )
+	{
+		e->SetPanel( panel );
+	}
+}
\ No newline at end of file
diff --git a/game/client/tf2/hintitemorderbase.h b/game/client/tf2/hintitemorderbase.h
new file mode 100644
index 0000000..d548c38
--- /dev/null
+++ b/game/client/tf2/hintitemorderbase.h
@@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HINTITEMORDERBASE_H
+#define HINTITEMORDERBASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "hintitembase.h"
+#include "c_tf2rootpanel.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHintItemOrderBase : public CHintItemBase
+{
+	DECLARE_CLASS( CHintItemOrderBase, CHintItemBase );
+public:
+	CHintItemOrderBase( vgui::Panel *parent, const char *panelName );
+
+	virtual void		DrawAxialLineToOrder( void );
+
+	virtual void		SetHintTarget( vgui::Panel *panel );
+
+protected:
+	bool				m_bEffects;
+
+	EFFECT_HANDLE		m_LineEffect;
+	EFFECT_HANDLE		m_FlashEffect;
+};
+
+#endif // HINTITEMORDERBASE_H
diff --git a/game/client/tf2/hud_ammo.cpp b/game/client/tf2/hud_ammo.cpp
new file mode 100644
index 0000000..637a20f
--- /dev/null
+++ b/game/client/tf2/hud_ammo.cpp
@@ -0,0 +1,265 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud_numeric.h"
+#include "hud_ammo.h"
+#include "hud.h"
+#include "iclientmode.h"
+#include <vgui_controls/AnimationController.h>
+#include <KeyValues.h>
+
+//-----------------------------------------------------------------------------
+// Singleton
+//-----------------------------------------------------------------------------
+static CHudAmmo g_HudAmmo;
+CHudAmmo* GetHudAmmo()
+{
+	return &g_HudAmmo;
+}
+
+
+//-----------------------------------------------------------------------------
+// Accessor methods to set various state associated with the ammo display
+//-----------------------------------------------------------------------------
+void CHudAmmo::SetPrimaryAmmo( int nAmmoType, int nTotalAmmo, int nClipCount, int nMaxClipCount )
+{
+	m_nAmmoType1 = nAmmoType;
+	m_nTotalAmmo1 = nTotalAmmo;
+	m_nMaxClip1 = nMaxClipCount;
+	m_nClip1 = nClipCount;
+}
+
+void CHudAmmo::SetSecondaryAmmo( int nAmmoType, int nTotalAmmo, int nClipCount, int nMaxClipCount )
+{
+	m_nAmmoType2 = nAmmoType;
+	m_nTotalAmmo2 = nTotalAmmo;
+	m_nMaxClip2 = nMaxClipCount;
+	m_nClip2 = nClipCount;
+}
+
+bool CHudAmmo::ShouldShowPrimaryClip() const
+{
+	if ( m_nAmmoType1 <= 0 )
+		return false;
+
+	if ( m_nClip1 < 0 )
+		return false;
+
+	return true;
+}
+
+bool CHudAmmo::ShouldShowSecondary() const 
+{
+	if ( m_nAmmoType2 <= 0 )
+		return false;
+
+	if ( m_nTotalAmmo2 <= 0 )
+		return false;
+
+	return true;
+}
+
+void CHudAmmo::ShowHideHudControls()
+{
+	bool showClip = ShouldShowPrimaryClip();
+	bool showSecondary = ShouldShowSecondary();
+
+	if ( showClip )
+	{
+		if ( showSecondary )
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "ShowPrimaryAmmoClipShowSecondaryAmmo" );
+		}
+		else
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "ShowPrimaryAmmoClipHideSecondaryAmmo" );
+		}
+	}
+	else
+	{
+		if ( showSecondary )
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HidePrimaryAmmoClipShowSecondaryAmmo" );
+		}
+		else
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HidePrimaryAmmoClipHideSecondaryAmmo" );
+		}
+	}
+}
+
+class CHudAmmoPrimary : public CHudNumeric
+{
+	DECLARE_CLASS_SIMPLE( CHudAmmoPrimary, CHudNumeric );
+public:
+	CHudAmmoPrimary( const char *pElementName ) : CHudNumeric( pElementName, "HudAmmoPrimary" )
+	{
+		SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+	}
+
+	virtual const char *GetLabelText() { return m_szAmmoLabel; }
+	virtual const char *GetPulseEvent( bool increment ) { return increment ? "PrimaryAmmoIncrement" : "PrimaryAmmoDecrement"; }
+
+	virtual bool		GetValue( char *val, int maxlen )
+	{
+		if ( GetHudAmmo()->m_nAmmoType1 <= 0 )
+			return false;
+
+		int count = ( GetHudAmmo()->m_nClip1 >= 0 ) ? GetHudAmmo()->m_nClip1 : GetHudAmmo()->m_nTotalAmmo1;
+		Q_snprintf( val, maxlen, "%i", count );
+		return true;
+	}
+
+	virtual Color GetColor()
+	{
+		// Get our ratio bar information
+		float	ammoPerc = 1.0f - ( (float) GetHudAmmo()->m_nClip1 ) / ( (float) GetHudAmmo()->m_nMaxClip1 );
+		bool	ammoCaution = ( ammoPerc >= CLIP_PERC_THRESHOLD );
+
+		if ( ammoCaution )
+			return m_TextColorCritical;
+
+		return m_TextColor;
+	}
+
+	virtual void ApplySchemeSettings(vgui::IScheme *scheme)
+	{
+		BaseClass::ApplySchemeSettings( scheme );
+
+		SetPaintBackgroundEnabled( true );
+	}
+
+private:
+	CPanelAnimationStringVar( 128, m_szAmmoLabel, "AmmoLabel", "Ammo" );
+};
+
+DECLARE_HUDELEMENT( CHudAmmoPrimary );
+
+class CHudAmmoPrimaryClip : public CHudNumeric
+{
+	DECLARE_CLASS_SIMPLE( CHudAmmoPrimaryClip, CHudNumeric );
+
+public:
+	CHudAmmoPrimaryClip( const char *pElementName ) : BaseClass( pElementName, "HudAmmoPrimaryClip" )
+	{
+		SetDrawLabel( false );
+
+		m_nPrevVisible = -1;
+
+		SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+	}
+
+	virtual const char *GetLabelText() { return m_szAmmoClipLabel; }
+	virtual const char *GetPulseEvent( bool increment ) { return increment ? "PrimaryAmmoClipIncrement" : "PrimaryAmmoClipDecrement"; }
+
+	virtual bool		GetValue( char *val, int maxlen )
+	{
+		int iret = _GetValue( val, maxlen ) ? 1 : 0;
+
+		if ( iret != m_nPrevVisible )
+		{
+			GetHudAmmo()->ShowHideHudControls();
+			m_nPrevVisible = iret;
+		}
+
+		return true;
+	}
+
+	virtual bool		_GetValue( char *val, int maxlen )
+	{
+		Q_snprintf( val, maxlen, "" );
+
+		if ( !GetHudAmmo()->ShouldShowPrimaryClip() )
+			return false;
+
+		int count = GetHudAmmo()->m_nTotalAmmo1;
+		Q_snprintf( val, maxlen, "%i", count );
+		return true;
+	}
+
+	virtual Color GetColor()
+	{
+		if ( GetHudAmmo()->ShouldShowPrimaryClip() )
+		{
+			if ( GetHudAmmo()->m_nTotalAmmo1 <= GetHudAmmo()->m_nMaxClip1 )
+			{
+				return m_TextColorCritical;
+			}
+		}
+
+		return m_TextColor;
+	}
+
+private:
+	int		m_nPrevVisible;
+	CPanelAnimationStringVar( 128, m_szAmmoClipLabel, "AmmoClipLabel", "PrimaryAmmoClip" );
+};
+
+DECLARE_HUDELEMENT( CHudAmmoPrimaryClip );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHudAmmoSecondary : public CHudNumeric
+{
+	DECLARE_CLASS_SIMPLE( CHudAmmoSecondary, CHudNumeric );
+
+public:
+	CHudAmmoSecondary( const char *pElementName ) : CHudNumeric( pElementName, "HudAmmoSecondary" )
+	{
+		SetDrawLabel( false );
+
+		m_nPrevVisible = -1;
+
+		SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+	}
+
+	virtual const char *GetLabelText() { return m_szAmmoSecondaryLabel; }
+	virtual const char *GetPulseEvent( bool increment ) { return increment ? "SecondaryAmmoIncrement" : "SecondaryAmmoDecrement"; }
+
+	virtual bool		GetValue( char *val, int maxlen )
+	{
+		int iret = _GetValue( val, maxlen ) ? 1 : 0;
+
+		if ( iret != m_nPrevVisible )
+		{
+			// Shift primary and clip left/right as needed
+			GetHudAmmo()->ShowHideHudControls();
+			m_nPrevVisible = iret;
+		}
+
+		return iret ? true : false;
+	}
+
+	virtual bool		_GetValue( char *val, int maxlen )
+	{
+		if ( !GetHudAmmo()->ShouldShowSecondary() )
+			return false;
+
+		int count = GetHudAmmo()->m_nTotalAmmo2;
+		Q_snprintf( val, maxlen, "%i", count );
+		return true;
+	}
+
+	virtual Color GetColor()
+	{
+		if ( GetHudAmmo()->m_nAmmoType2 > 0 &&
+			 GetHudAmmo()->m_nTotalAmmo2 == 1 )
+		{
+			return m_TextColorCritical;
+		}
+
+		return m_TextColor;
+	}
+
+private:
+	int		m_nPrevVisible;
+	CPanelAnimationStringVar( 128, m_szAmmoSecondaryLabel, "AmmoSecondaryLabel", "AmmoSecondary" );
+};
+
+DECLARE_HUDELEMENT( CHudAmmoSecondary );
diff --git a/game/client/tf2/hud_ammo.h b/game/client/tf2/hud_ammo.h
new file mode 100644
index 0000000..0c24d08
--- /dev/null
+++ b/game/client/tf2/hud_ammo.h
@@ -0,0 +1,52 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#ifndef HUD_AMMO_H
+#define HUD_AMMO_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+// This is *like* a hud element, but isn't actually a hud element.
+// It's meant to be called from hud drawing methods in various places in the code
+class CHudAmmo
+{
+public:
+	// Accessor methods to set various state associated with the ammo display
+	void SetPrimaryAmmo( int nAmmoType, int nTotalAmmo, int nClipCount = -1, int nMaxClipCount = -1 );
+	void SetSecondaryAmmo( int nAmmoType, int nTotalAmmo, int nClipCount = -1, int nMaxClipCount = -1 );
+
+	bool	ShouldShowPrimaryClip() const;
+	bool	ShouldShowSecondary() const;
+
+	void	ShowHideHudControls();
+
+private:
+	int		m_nClip1;
+	int		m_nMaxClip1;
+	int		m_nTotalAmmo1;
+	int		m_nAmmoType1;
+
+	int		m_nClip2;
+	int		m_nMaxClip2;
+	int		m_nTotalAmmo2;
+ 	int		m_nAmmoType2;
+
+friend class CHudAmmoPrimary;
+friend class CHudAmmoPrimaryClip;
+friend class CHudAmmoSecondary;
+};
+
+//-----------------------------------------------------------------------------
+// Singleton...
+//-----------------------------------------------------------------------------
+CHudAmmo* GetHudAmmo();
+
+#endif // HUD_AMMO_H
+
diff --git a/game/client/tf2/hud_commander_statuspanel.cpp b/game/client/tf2/hud_commander_statuspanel.cpp
new file mode 100644
index 0000000..46cb908
--- /dev/null
+++ b/game/client/tf2/hud_commander_statuspanel.cpp
@@ -0,0 +1,414 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Flyover/Tooltip hint area for commander
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include <stdarg.h>
+#include "hud_commander_statuspanel.h"
+#include "techtree.h"
+#include <vgui/IVGui.h>
+#include "VGuiMatSurface/IMatSystemSurface.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+#include <vgui/IScheme.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static CCommanderStatusPanel *g_pCommanderStatusPanel = NULL;
+
+// 
+#define ALPHA_ADJUST_TIME 0.1f
+#define MAX_FILLED_INFO_ALPHA 127.0f
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCommanderStatusPanel::CCommanderStatusPanel( void ) : 
+	BaseClass( NULL, "CCommanderStatusPanel" )
+{
+	m_hFont = m_hFontText = 0;
+	m_nLeftEdge = 0;
+	m_nBottomEdge = 0;
+
+//	m_pBorder = new vgui::LineBorder( 2, vgui::Color( 127, 127, 127, 255 ) );
+//	setBorder( m_pBorder );
+	
+	SetBgColor( Color( 0, 0, 0, 100 ) );
+
+	// we need updating
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+
+	InternalClear();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CCommanderStatusPanel::~CCommanderStatusPanel( void )
+{
+//	delete m_pBorder;
+}
+
+//-----------------------------------------------------------------------------
+// Scheme settings
+//-----------------------------------------------------------------------------
+void CCommanderStatusPanel::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+
+	m_hFont = pScheme->GetFont( "Trebuchet20" );
+	// FIXME:  Outline, weight 1000
+	m_hFontText = pScheme->GetFont( "Trebuchet18" );
+	// FIXME:  Outline, weight 700
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderStatusPanel::OnTick()
+{
+	// Simulate alpha
+	float dt = gpGlobals->frametime;
+	float maxmove = 1.0f / ALPHA_ADJUST_TIME;
+	float moverequested = dt * maxmove;
+
+	float remaining = m_flGoalAlpha - m_flCurrentAlpha;
+	if ( fabs( remaining ) < 0.01f )
+	{
+		if ( m_flCurrentAlpha < 0.01f )
+		{
+			InternalClear();
+			return;
+		}
+	}
+
+	if ( moverequested > fabs( remaining ) )
+	{
+		moverequested = fabs( remaining );
+	}
+
+	if ( remaining > 0.0f )
+	{
+		m_flCurrentAlpha += moverequested;
+	}
+	else
+	{
+		m_flCurrentAlpha -= moverequested;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderStatusPanel::Paint()
+{
+	if ( m_flCurrentAlpha <= 0.0f )
+		return;
+
+	int wide, tall;
+	GetSize( wide, tall );
+
+	int x = 2;
+	int y = 2;
+	
+	wide -= 4;
+	tall -= 4;
+
+	int alpha = 255.0f * m_flCurrentAlpha;
+
+	if ( m_Type == TYPE_INFO && m_nTitlePos != -1 )
+	{
+		m_szText[ m_nTitlePos ] = 0;
+
+		g_pMatSystemSurface->DrawColoredTextRect( m_hFont, x, y, wide, tall, 220, 220, 255, alpha, "%s", m_szText );
+
+		m_szText[ m_nTitlePos ] = '\n';
+
+		y += vgui::surface()->GetFontTall( m_hFont );
+		tall -= vgui::surface()->GetFontTall( m_hFont );
+
+		// Start after title
+		g_pMatSystemSurface->DrawColoredTextRect( m_hFontText, x, y, wide, tall, 255, 255, 255, alpha, "%s", &m_szText[ m_nTitlePos + 1 ] );
+
+		if ( m_bShowTechnology && m_pTechnology )
+		{
+			int x = 0;
+			int y = tall;
+			int size;
+			int r, g, b;
+			r = g = 192;
+			b = 255;
+
+			float fResourceCost = m_pTechnology->GetResourceCost();
+			float fResourceLevel = m_pTechnology->GetResourceLevel();
+
+			int techLevel = m_pTechnology->GetLevel();
+			x = 5;
+			g_pMatSystemSurface->DrawColoredText( m_hFontText, x, y, r, g, b, alpha, "Level <%i>", techLevel );
+
+			x = wide - 5;
+
+			if ( m_pTechnology->GetActive() )
+			{
+				size = g_pMatSystemSurface->DrawTextLen( m_hFontText, "Already owned" );
+
+				x -= size;
+
+				g_pMatSystemSurface->DrawColoredText( m_hFontText, x, y, r, g, b, alpha, "Already owned" );
+			}
+			else
+			{
+				if ( !fResourceCost )
+				{
+					size = g_pMatSystemSurface->DrawTextLen( m_hFontText, "Cost:  Free" );
+
+					x -= size; 
+
+					g_pMatSystemSurface->DrawColoredText( m_hFontText, x, y, r, g, b, alpha, "Cost:  Free" );
+				}
+				else
+				{
+					int sizecost = g_pMatSystemSurface->DrawTextLen( m_hFontText, "WWW: 000 (000)" ) + 5;
+					
+					size = g_pMatSystemSurface->DrawTextLen( m_hFontText, "Cost: " );
+
+					x = wide - size - 4 * sizecost;
+
+					r = 255;
+					g = 255;
+					b = 255;
+					g_pMatSystemSurface->DrawColoredText( m_hFontText, x, y, r, g, b, alpha, "Cost: " );
+
+					x += size;
+
+					char szCostString[64];
+
+					// Draw cost string backward to right justify it
+					if ( fResourceCost )
+					{
+						if ( fResourceLevel )
+							Q_snprintf( szCostString, sizeof( szCostString ), "A: %i (%i)", (int)fResourceLevel, (int)fResourceCost );
+						else
+							Q_snprintf( szCostString, sizeof( szCostString ), "A: %i", (int)fResourceCost );
+						g_pMatSystemSurface->DrawColoredText( m_hFontText, x, y, sResourceColor.r, sResourceColor.g, sResourceColor.b, alpha, "%s", szCostString );
+						sizecost = g_pMatSystemSurface->DrawTextLen( m_hFontText, "%s", szCostString ) + 2;
+					}
+					x += sizecost;
+				}
+			}
+		}
+	}
+	else
+	{
+		g_pMatSystemSurface->DrawColoredTextRect( m_hFont, 
+			x, 
+			y + tall - vgui::surface()->GetFontTall( m_hFont ) - 4, 
+			wide, 
+			vgui::surface()->GetFontTall( m_hFont ) + 2, 
+			220, 220, 255, alpha, 
+			"%s",
+			m_szText );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderStatusPanel::PaintBackground()
+{
+	if ( m_flCurrentAlpha <= 0.0f )
+		return;
+
+	if ( m_Type == TYPE_INFO )
+	{
+		int alpha = MAX_FILLED_INFO_ALPHA * m_flCurrentAlpha;
+
+		SetBgColor( Color( 0, 0, 0, alpha ) );
+
+		alpha += ( 255 - alpha ) / 2;
+
+//		m_pBorder->SetColor( vgui::Color( 120, 120, 180, alpha ) ); 
+	}
+	else
+	{
+		SetBgColor( Color( 0, 0, 0, 0 ) );
+//		m_pBorder->SetColor( vgui::Color( 0, 0, 0, 0 ) );
+	}
+	BaseClass::PaintBackground();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CCommanderStatusPanel::Clear( void )
+{
+	m_flGoalAlpha = 0.0f; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *fmt - 
+//			... - 
+//-----------------------------------------------------------------------------
+void CCommanderStatusPanel::SetText( STATUSTYPE type, const char *fmt, ... )
+{
+	va_list argptr;
+	va_start( argptr, fmt );
+	 _vsnprintf(m_szText, MAX_STATUS_TEXT, fmt, argptr);
+	va_end(argptr);
+	m_szText[ MAX_STATUS_TEXT - 1 ] = 0;
+
+	m_Type = type;
+	SetVisible( true );
+
+	m_nTitlePos = -1;
+
+	if ( m_Type == TYPE_INFO )
+	{
+		// Search for first \n
+		char *p = m_szText;
+		while ( *p && *p != '\n' )
+		{
+			p++;
+		}
+
+		if ( *p == '\n' )
+		{
+			m_nTitlePos = p - m_szText;
+		}
+	}
+
+	m_flCurrentAlpha = MAX( m_flCurrentAlpha, 0.01f );
+	m_flGoalAlpha = 1.0f;
+	m_bShowTechnology = false;
+	m_pTechnology = NULL;
+
+	RecomputeBounds();
+}
+
+void CCommanderStatusPanel::SetTechnology( CBaseTechnology *technology )
+{
+	m_bShowTechnology = true;
+	m_pTechnology = technology;
+}
+
+void CCommanderStatusPanel::InternalClear( void )
+{
+	m_Type = TYPE_UNKNOWN;
+	m_szText[ 0 ] = 0;
+	m_nTitlePos = -1;
+
+	m_flCurrentAlpha = 0.0f;
+	m_flGoalAlpha = 0.0f;
+
+	m_bShowTechnology = false;
+	m_pTechnology = NULL;
+
+	SetVisible( false );
+	SetPaintBackgroundEnabled( false );
+	SetPaintBorderEnabled( false );
+}
+
+void CCommanderStatusPanel::RecomputeBounds( void )
+{
+	int maxlines = 5;
+	int lineheight = vgui::surface()->GetFontTall( m_hFont );
+
+	int height;
+	height = lineheight + ( maxlines - 1 ) * vgui::surface()->GetFontTall( m_hFontText );
+	height += 4; // 2 pixels top and bottom
+
+	SetBounds( m_nLeftEdge, m_nBottomEdge - height, ScreenWidth() * 0.6, height );
+	SetPaintBackgroundEnabled( true );
+	SetPaintBorderEnabled( true );
+}
+
+void CCommanderStatusPanel::SetLeftBottom( int l, int b )
+{
+	m_nLeftEdge		= l;
+	m_nBottomEdge	= b;
+
+	RecomputeBounds();
+}
+
+//////////////////////////////////////////
+//
+// Status Panel Creation/Destruction and public api
+//
+//////////////////////////////////////////
+void StatusCreate( vgui::Panel *parent, int treetoprow )
+{
+	Assert( !g_pCommanderStatusPanel );
+	g_pCommanderStatusPanel = new CCommanderStatusPanel();
+	g_pCommanderStatusPanel->SetAutoDelete( false );
+	g_pCommanderStatusPanel->SetParent( parent );
+	g_pCommanderStatusPanel->SetLeftBottom( 0, treetoprow - 10 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : treeetoprow - 
+//-----------------------------------------------------------------------------
+void StatusSetTopRow( int treetoprow )
+{
+	Assert( g_pCommanderStatusPanel );
+	g_pCommanderStatusPanel->SetLeftBottom( 0, treetoprow - 10 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void StatusDestroy( void )
+{
+	delete g_pCommanderStatusPanel;
+	g_pCommanderStatusPanel = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : type - 
+//			*fmt - 
+//			... - 
+//-----------------------------------------------------------------------------
+void StatusPrint( STATUSTYPE type, const char *fmt, ... )
+{
+	char text[ CCommanderStatusPanel::MAX_STATUS_TEXT ];
+
+	va_list argptr;
+	va_start( argptr, fmt );
+	_vsnprintf(text, CCommanderStatusPanel::MAX_STATUS_TEXT, fmt, argptr);
+	va_end(argptr);
+	text[ CCommanderStatusPanel::MAX_STATUS_TEXT - 1 ] = 0;
+
+	if ( g_pCommanderStatusPanel )
+	{
+		g_pCommanderStatusPanel->SetText( type, text );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void StatusClear( void )
+{
+	if ( g_pCommanderStatusPanel )
+	{
+		g_pCommanderStatusPanel->Clear();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *technology - 
+//-----------------------------------------------------------------------------
+void StatusTechnology( CBaseTechnology *technology )
+{
+	if ( g_pCommanderStatusPanel )
+	{
+		g_pCommanderStatusPanel->SetTechnology(technology );
+	}
+}
\ No newline at end of file
diff --git a/game/client/tf2/hud_commander_statuspanel.h b/game/client/tf2/hud_commander_statuspanel.h
new file mode 100644
index 0000000..9acc888
--- /dev/null
+++ b/game/client/tf2/hud_commander_statuspanel.h
@@ -0,0 +1,93 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef COMMANDER_STATUSPANEL_H
+#define COMMANDER_STATUSPANEL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Panel.h>
+
+typedef enum
+{
+	TYPE_UNKNOWN = 0,
+	TYPE_INFO,		// More invloved, with box and grayed background
+					// If it has a \n, the lines after the first aren't as large
+	TYPE_INFONOTITLE, // Don't treat first line with a \n specially
+	TYPE_HINT		// Single line flyover
+} STATUSTYPE;
+
+namespace vgui
+{
+	class LineBorder;
+}
+
+class CBaseTechnology;
+
+//-----------------------------------------------------------------------------
+// Purpose: The status line appears along the bottom of the screen and shows
+//  tooltip style help
+//-----------------------------------------------------------------------------
+class CCommanderStatusPanel : public vgui::Panel
+{
+public:
+	typedef vgui::Panel BaseClass;
+
+	enum { MAX_STATUS_TEXT = 4096 };
+
+
+							CCommanderStatusPanel( void );
+	virtual					~CCommanderStatusPanel( void );
+
+	virtual void			ApplySchemeSettings(vgui::IScheme *pScheme);
+
+	virtual void			Paint();
+	virtual void			PaintBackground();
+	virtual void			OnTick();
+
+	// Set status text
+	virtual void			SetText( STATUSTYPE type, PRINTF_FORMAT_STRING const char *fmt, ... );
+	virtual void			SetTechnology( CBaseTechnology *technology );
+	virtual void			Clear();
+
+	virtual void			SetLeftBottom( int l, int b );
+
+private:
+	void					RecomputeBounds( void );
+	void					InternalClear();
+
+private:
+	float					m_flCurrentAlpha;
+	float					m_flGoalAlpha;
+
+	int						m_nLeftEdge;
+	int						m_nBottomEdge;
+
+	vgui::HFont				m_hFont;
+	vgui::HFont				m_hFontText;
+	vgui::LineBorder		*m_pBorder;
+
+	// Position of the first '\n' character
+	char					m_nTitlePos;
+
+
+	STATUSTYPE				m_Type;
+	char					m_szText[ MAX_STATUS_TEXT ];
+	bool					m_bShowTechnology;
+	CBaseTechnology			*m_pTechnology;
+};
+
+void StatusCreate( vgui::Panel *parent, int treetoprow );
+void StatusDestroy( void );
+void StatusSetTopRow( int treetoprow );
+
+void StatusPrint( STATUSTYPE type, PRINTF_FORMAT_STRING const char *fmt, ... );
+void StatusTechnology( CBaseTechnology *technology );
+void StatusClear( void );
+
+#endif // COMMANDER_STATUSPANEL_H
diff --git a/game/client/tf2/hud_damageindicator.cpp b/game/client/tf2/hud_damageindicator.cpp
new file mode 100644
index 0000000..40cbc55
--- /dev/null
+++ b/game/client/tf2/hud_damageindicator.cpp
@@ -0,0 +1,322 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Hud element that indicates the direction of damage taken by the player
+//
+//=============================================================================//
+#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_controls/AnimationController.h>
+#include <vgui/ISurface.h>
+#include "VGuiMatSurface/IMatSystemSurface.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imesh.h"
+#include "materialsystem/imaterialvar.h"
+#include "IEffects.h"
+#include "hudelement.h"
+
+using namespace vgui;
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHudDamageIndicator : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudDamageIndicator, vgui::Panel );
+public:
+	CHudDamageIndicator( const char *pElementName );
+	void Init( void );
+	void VidInit( void );
+	void Reset( void );
+	virtual bool ShouldDraw( void );
+
+	// Handler for our message
+	void MsgFunc_Damage( bf_read &msg );
+
+private:
+	virtual void OnThink();
+	virtual void Paint();
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+
+	// Painting
+	void GetDamagePosition( const Vector &vecDelta, float flRadius, int *xpos, int *ypos, float *flRotation );
+	void DrawDamageIndicator(int x0, int y0, int x1, int y1, float alpha, float flRotation );
+
+private:
+	// Indication times
+
+	CPanelAnimationVarAliasType( float, m_flMinimumWidth, "MinimumWidth", "10", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flMaximumWidth, "MaximumWidth", "100", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flMinimumHeight, "MinimumHeight", "20", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flMaximumHeight, "MaximumHeight", "100", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flStartRadius, "StartRadius", "140", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flEndRadius, "EndRadius", "120", "proportional_float" );
+
+	CPanelAnimationVar( float, m_iMaximumDamage, "MaximumDamage", "50" );
+	CPanelAnimationVar( float, m_flMinimumTime, "MinimumTime", "1" );
+	CPanelAnimationVar( float, m_flMaximumTime, "MaximumTime", "6" );
+	CPanelAnimationVar( float, m_flTravelTime, "TravelTime", ".1" );
+	CPanelAnimationVar( float, m_flFadeOutPercentage, "FadeOutPercentage", "0.7" );
+	CPanelAnimationVar( float, m_flNoise, "Noise", "0.1" );
+
+	// List of damages we've taken
+	struct damage_t
+	{
+		int		iScale;
+		float	flLifeTime;
+		float	flStartTime;
+		Vector	vecDelta;	// Damage origin relative to the player
+	};
+	CUtlVector<damage_t>	m_vecDamages;
+};
+
+DECLARE_HUDELEMENT( CHudDamageIndicator );
+DECLARE_HUD_MESSAGE( CHudDamageIndicator, Damage );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudDamageIndicator::CHudDamageIndicator( const char *pElementName ) :
+	CHudElement( pElementName ), BaseClass(NULL, "DamageIndicator")
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetHiddenBits( HIDEHUD_HEALTH );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::Init( void )
+{
+	HOOK_HUD_MESSAGE( CHudDamageIndicator, Damage );
+	Reset();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::Reset( void )
+{
+	m_vecDamages.Purge();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::VidInit( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::OnThink()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHudDamageIndicator::ShouldDraw( void )
+{
+	if ( !CHudElement::ShouldDraw() )
+		return false;
+
+	// Don't draw if we don't have any damage to indicate
+	if ( !m_vecDamages.Count() )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Convert a damage position in world units to the screen's units
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::GetDamagePosition( const Vector &vecDelta, float flRadius, int *xpos, int *ypos, float *flRotation )
+{
+	// Player Data
+	Vector playerPosition = MainViewOrigin();
+	QAngle playerAngles = MainViewAngles();
+
+	Vector forward, right, up(0,0,1);
+	AngleVectors (playerAngles, &forward, NULL, NULL );
+	forward.z = 0;
+	VectorNormalize(forward);
+	CrossProduct( up, forward, right );
+	float front = DotProduct(vecDelta, forward);
+	float side = DotProduct(vecDelta, right);
+	*xpos = flRadius * -side;
+	*ypos = flRadius * -front;
+
+	// Get the rotation (yaw)
+	*flRotation = atan2(*xpos,*ypos) + M_PI;
+	*flRotation *= 180 / M_PI;
+
+	float yawRadians = -(*flRotation) * M_PI / 180.0f;
+	float ca = cos( yawRadians );
+	float sa = sin( yawRadians );
+				 
+	// Rotate it around the circle
+	*xpos = (int)((ScreenWidth() / 2) + (flRadius * sa));
+	*ypos = (int)((ScreenHeight() / 2) - (flRadius * ca));
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw a single damage indicator
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::DrawDamageIndicator(int x0, int y0, int x1, int y1, float alpha, float flRotation )
+{
+	IMaterial *pMat = materials->FindMaterial( "hud/health/indicator", TEXTURE_GROUP_VGUI );
+	CMatRenderContextPtr pRenderContext( materials );
+	IMesh *pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMat );
+
+	// Get the corners, since they're being rotated
+	int wide = x1 - x0;
+	int tall = y1 - y0;
+	Vector2D vecCorners[4];
+	Vector2D center( x0 + (wide * 0.5f), y0 + (tall * 0.5f) );
+	float yawRadians = -flRotation * M_PI / 180.0f;
+	Vector2D axis[2];
+	axis[0].x = cos(yawRadians);
+	axis[0].y = sin(yawRadians);
+	axis[1].x = -axis[0].y;
+	axis[1].y = axis[0].x;
+	Vector2DMA( center, -0.5f * wide, axis[0], vecCorners[0] );
+	Vector2DMA( vecCorners[0], -0.5f * tall, axis[1], vecCorners[0] );
+	Vector2DMA( vecCorners[0], wide, axis[0], vecCorners[1] );
+	Vector2DMA( vecCorners[1], tall, axis[1], vecCorners[2] );
+	Vector2DMA( vecCorners[0], tall, axis[1], vecCorners[3] );
+
+	// Draw the sucker
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
+
+	int iAlpha = alpha * 255;
+	meshBuilder.Color4ub( 255,255,255, iAlpha );
+	meshBuilder.TexCoord2f( 0,0,0 );
+	meshBuilder.Position3f( vecCorners[0].x,vecCorners[0].y,0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color4ub( 255,255,255, iAlpha );
+	meshBuilder.TexCoord2f( 0,1,0 );
+	meshBuilder.Position3f( vecCorners[1].x,vecCorners[1].y,0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color4ub( 255,255,255, iAlpha );
+	meshBuilder.TexCoord2f( 0,1,1 );
+	meshBuilder.Position3f( vecCorners[2].x,vecCorners[2].y,0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color4ub( 255,255,255, iAlpha );
+	meshBuilder.TexCoord2f( 0,0,1 );
+	meshBuilder.Position3f( vecCorners[3].x,vecCorners[3].y,0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.End();
+	pMesh->Draw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::Paint()
+{
+	// Iterate backwards, because we might remove them as we go
+	int iSize = m_vecDamages.Count();
+	for (int i = iSize-1; i >= 0; i--)
+	{
+		// Scale size to the damage
+		int clampedDamage = clamp( m_vecDamages[i].iScale, 0, m_iMaximumDamage );
+
+		int iWidth = RemapVal(clampedDamage, 0, m_iMaximumDamage, m_flMinimumWidth, m_flMaximumWidth) * 0.5;
+		int iHeight = RemapVal(clampedDamage, 0, m_iMaximumDamage, m_flMinimumHeight, m_flMaximumHeight) * 0.5;
+
+		// Find the place to draw it
+		int xpos, ypos;
+		float flRotation;
+		float flTimeSinceStart = ( gpGlobals->curtime - m_vecDamages[i].flStartTime );
+		float flRadius = RemapVal( MIN( flTimeSinceStart, m_flTravelTime ), 0, m_flTravelTime, m_flStartRadius, m_flEndRadius );
+		GetDamagePosition( m_vecDamages[i].vecDelta, flRadius, &xpos, &ypos, &flRotation );
+
+		// Calculate life left
+		float flLifeLeft = ( m_vecDamages[i].flLifeTime - gpGlobals->curtime );
+		if ( flLifeLeft > 0 )
+		{
+			float flPercent = flTimeSinceStart / (m_vecDamages[i].flLifeTime - m_vecDamages[i].flStartTime);
+			float alpha;
+			if ( flPercent <= m_flFadeOutPercentage )
+			{
+				alpha = 1.0;
+			}
+			else
+			{
+				alpha = 1.0 - RemapVal( flPercent, m_flFadeOutPercentage, 1.0, 0.0, 1.0 );
+			}
+			DrawDamageIndicator( xpos-iWidth, ypos-iHeight, xpos+iWidth, ypos+iHeight, alpha, flRotation );
+		}
+		else
+		{
+			m_vecDamages.Remove(i);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Message handler for Damage message
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::MsgFunc_Damage( bf_read &msg )
+{
+	damage_t damage;
+	damage.iScale = msg.ReadByte();
+	if ( damage.iScale > m_iMaximumDamage )
+	{
+		damage.iScale = m_iMaximumDamage;
+	}
+	Vector vecOrigin;
+	vecOrigin.x = msg.ReadFloat();
+	vecOrigin.y = msg.ReadFloat();
+	vecOrigin.z = msg.ReadFloat();
+	damage.flStartTime = gpGlobals->curtime;
+	damage.flLifeTime = gpGlobals->curtime + RemapVal(damage.iScale, 0, m_iMaximumDamage, m_flMinimumTime, m_flMaximumTime);
+
+	if ( vecOrigin == vec3_origin )
+	{
+		vecOrigin = MainViewOrigin();
+	}
+
+	damage.vecDelta = (vecOrigin - MainViewOrigin());
+	VectorNormalize( damage.vecDelta );
+
+	// Add some noise
+	damage.vecDelta[0] += random->RandomFloat( -m_flNoise, m_flNoise );
+	damage.vecDelta[1] += random->RandomFloat( -m_flNoise, m_flNoise );
+	damage.vecDelta[2] += random->RandomFloat( -m_flNoise, m_flNoise );
+	VectorNormalize( damage.vecDelta );
+
+	m_vecDamages.AddToTail( damage );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: hud scheme settings
+//-----------------------------------------------------------------------------
+void CHudDamageIndicator::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);
+}
diff --git a/game/client/tf2/hud_deathnotice.cpp b/game/client/tf2/hud_deathnotice.cpp
new file mode 100644
index 0000000..3810bb4
--- /dev/null
+++ b/game/client/tf2/hud_deathnotice.cpp
@@ -0,0 +1,378 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Draws TF2's death notices
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud_macros.h"
+#include "hudelement.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 <game/client/iviewport.h>
+#include <KeyValues.h>
+#include "c_baseplayer.h"
+#include "c_team.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static ConVar hud_deathnotice_time( "hud_deathnotice_time", "6", 0 );
+
+// Player entries in a death notice
+struct DeathNoticePlayer
+{
+	char		szName[MAX_PLAYER_NAME_LENGTH];
+	int			iEntIndex;
+};
+
+// Contents of each entry in our list of death notices
+struct DeathNoticeItem 
+{
+	DeathNoticePlayer	Killer;
+	DeathNoticePlayer   Victim;
+	DeathNoticePlayer   Assist;
+	CHudTexture *iconDeath;
+	int			iSuicide;
+	int			iTeamKill;
+	float		flDisplayTime;
+};
+
+//-----------------------------------------------------------------------------
+// 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 SetColorForNoticePlayer( C_BasePlayer *pPlayer, int iTeamNumber );
+	void RetireExpiredDeathNotices( void );
+	void MsgFunc_DeathMsg(  bf_read &msg );
+
+private:
+
+	CPanelAnimationVarAliasType( float, m_flLineHeight, "LineHeight", "15", "proportional_float" );
+
+	CPanelAnimationVar( float, m_flMaxDeathNotices, "MaxDeathNotices", "4" );
+	CPanelAnimationVar( bool, m_bRightJustify, "RightJustify", "1" );
+
+	CPanelAnimationVar( Color, m_clrFriendlyText, "FriendlyTextColor", "FriendlyTextColor" );
+	CPanelAnimationVar( Color, m_clrEnemyText, "EnemyTextColor", "EnemyTextColor" );
+	CPanelAnimationVar( Color, m_clrMyKillsText, "MyKillsTextColor", "MyKillsTextColor" );
+
+	CPanelAnimationVar( vgui::HFont, m_hTextFont, "TextFont", "HudNumbersTimer" );
+
+	// Texture for skull symbol
+	CHudTexture		*m_iconD_skull;  
+
+	CUtlVector<DeathNoticeItem> m_DeathNotices;
+};
+
+using namespace vgui;
+
+DECLARE_HUDELEMENT( CHudDeathNotice );
+// DECLARE_HUD_MESSAGE( CHudDeathNotice, DeathMsg );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudDeathNotice::CHudDeathNotice( const char *pElementName ) :
+	CHudElement( pElementName ), BaseClass( NULL, "HudDeathNotice" )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetHiddenBits( HIDEHUD_MISCSTATUS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::ApplySchemeSettings( IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+	SetPaintBackgroundEnabled( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::Init( void )
+{
+//FIXME!!!!
+//HOOK_MESSAGE( DeathMsg );
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::VidInit( void )
+{
+	m_iconD_skull = gHUD.GetIcon( "d_skull" );
+	m_DeathNotices.Purge();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw if we've got at least one death notice in the queue
+//-----------------------------------------------------------------------------
+bool CHudDeathNotice::ShouldDraw( void )
+{
+	return ( CHudElement::ShouldDraw() && ( m_DeathNotices.Count() ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::SetColorForNoticePlayer( C_BasePlayer *pPlayer, int iTeamNumber )
+{
+	// Set the right color
+	if ( pPlayer == C_BasePlayer::GetLocalPlayer() )
+	{
+		surface()->DrawSetTextColor( m_clrMyKillsText );
+	}
+	else if ( GetLocalTeam() && GetLocalTeam()->GetTeamNumber() == iTeamNumber )
+	{
+		surface()->DrawSetTextColor( m_clrFriendlyText );
+	}
+	else
+	{
+		surface()->DrawSetTextColor( m_clrEnemyText );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudDeathNotice::Paint()
+{
+	surface()->DrawSetTextFont( m_hTextFont );
+	surface()->DrawSetTextColor( m_clrFriendlyText );
+
+	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 assist[ 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].Assist.szName, assist, sizeof( assist ) );
+
+		// Get the team numbers for the players involved
+		C_BasePlayer *pKiller = static_cast<C_BasePlayer*>(cl_entitylist->GetEnt( m_DeathNotices[i].Killer.iEntIndex ));
+		int iKillerTeam = pKiller ? pKiller->GetTeamNumber() : 0;
+		C_BasePlayer *pAssist = NULL;
+		if ( m_DeathNotices[i].Assist.iEntIndex )
+		{
+			pAssist = static_cast<C_BasePlayer*>(cl_entitylist->GetEnt( m_DeathNotices[i].Assist.iEntIndex ));
+		}
+		C_BasePlayer *pVictim = static_cast<C_BasePlayer*>(cl_entitylist->GetEnt( m_DeathNotices[i].Victim.iEntIndex ));
+		int iVictimTeam = pVictim ? pVictim->GetTeamNumber() : 0;
+
+		// Get the local position for this notice
+		int len = UTIL_ComputeStringWidth( m_hTextFont, victim );
+		int y = (m_flLineHeight * i);
+		int x;
+		if ( m_bRightJustify )
+		{
+			x = GetWide() - len - icon->Width() - 5;
+		}
+		else
+		{
+			x = 0;
+		}
+
+		// Only draw killers name if it wasn't a suicide
+		if ( !m_DeathNotices[i].iSuicide )
+		{
+			if ( m_bRightJustify )
+			{
+				x -= UTIL_ComputeStringWidth( m_hTextFont, killer );
+				if ( pAssist )
+				{
+					x -= UTIL_ComputeStringWidth( m_hTextFont, L" + " );
+					x -= UTIL_ComputeStringWidth( m_hTextFont, killer );
+				}
+			}
+
+			SetColorForNoticePlayer( pKiller, iKillerTeam );
+
+			// Draw killer's name
+			surface()->DrawSetTextPos( x, y );
+			surface()->DrawUnicodeString( killer );
+			surface()->DrawGetTextPos( x, y );
+
+			// Did we have an assistant?
+			if ( pAssist )
+			{
+				// Draw the conjuction
+				const wchar_t *sAnd = L" + ";
+				surface()->DrawSetTextPos( x, y );
+				surface()->DrawUnicodeString( sAnd );
+				surface()->DrawUnicodeString( assist );
+				surface()->DrawGetTextPos( x, y );
+			}
+		}
+
+		Color iconColor( 255, 80, 0, 255 );
+		if ( m_DeathNotices[i].iTeamKill )
+		{
+			// display it in sickly green
+			iconColor = Color( 10, 240, 10, 255 );
+		}
+
+		// Draw death weapon
+		icon->DrawSelf( x, y, iconColor );
+		x += icon->Width();
+
+		SetColorForNoticePlayer( pVictim, iVictimTeam );
+
+		// Draw victims name
+		surface()->DrawSetTextPos( x, y );
+		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::MsgFunc_DeathMsg(  bf_read &msg )
+{
+	if (!g_PR)
+		return;
+
+	int killer = msg.ReadByte();
+	int assist = msg.ReadByte();
+	int victim = msg.ReadByte();
+
+	char killedwith[32];
+	char fullkilledwith[128];
+	msg.ReadString( killedwith, sizeof(killedwith) );
+	
+	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 = g_PR->GetPlayerName( killer );
+	const char *assist_name = g_PR->GetPlayerName( assist );
+	const char *victim_name = g_PR->GetPlayerName( victim );
+	if ( !killer_name )
+		killer_name = "";
+	if ( !assist_name )
+		assist_name = "";
+	if ( !victim_name )
+		victim_name = "";
+
+	// Make a new death notice
+	DeathNoticeItem deathMsg;
+	deathMsg.Killer.iEntIndex = killer;
+	deathMsg.Assist.iEntIndex = assist;
+	deathMsg.Victim.iEntIndex = victim;
+	Q_strncpy( deathMsg.Killer.szName, killer_name, MAX_PLAYER_NAME_LENGTH );
+	Q_strncpy( deathMsg.Assist.szName, assist_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 = ( !killer || killer == victim );
+	deathMsg.iTeamKill = ( !strcmp( fullkilledwith, "d_teammate" ) );
+
+	// 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_world" ) )
+		{
+			Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s died.\n", deathMsg.Victim.szName );
+		}
+		else
+		{
+			Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s suicided.\n", deathMsg.Victim.szName );
+		}
+	}
+	else if ( deathMsg.iTeamKill )
+	{
+		Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s teamkilled %s", deathMsg.Killer.szName, deathMsg.Victim.szName );
+	}
+	else
+	{
+		if ( assist )
+		{
+			Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s and %s killed %s", deathMsg.Killer.szName, deathMsg.Assist.szName, deathMsg.Victim.szName );
+		}
+		else
+		{
+			Q_snprintf( sDeathMsg, sizeof( sDeathMsg ), "%s killed %s", deathMsg.Killer.szName, deathMsg.Victim.szName );
+		}
+	}
+
+	if ( fullkilledwith && *fullkilledwith && (*fullkilledwith > 13 ) && strcmp( fullkilledwith, "d_world" ) && !deathMsg.iTeamKill )
+	{
+		Q_strncat( sDeathMsg, VarArgs( " with %s.\n", fullkilledwith+2 ), sizeof( sDeathMsg ), COPY_ALL_CHARACTERS );
+	}
+
+	Msg( sDeathMsg );
+}
+
+
+
diff --git a/game/client/tf2/hud_emp.cpp b/game/client/tf2/hud_emp.cpp
new file mode 100644
index 0000000..f97fa3a
--- /dev/null
+++ b/game/client/tf2/hud_emp.cpp
@@ -0,0 +1,195 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+#include "c_basetfplayer.h"
+#include "tf_shareddefs.h"
+#include "iclientmode.h"
+#include "clientmode_tfnormal.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imesh.h"
+#include "materialsystem/imaterialvar.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+#include "clienteffectprecachesystem.h"
+
+// EMP level positions
+#define HUDEMP_LEFT					((ScreenWidth() / 2)- XRES(40))
+#define HUDEMP_WIDTH				XRES(16)
+#define HUDEMP_TOP					YRES(210)
+#define HUDEMP_HEIGHT				YRES(16)
+
+// Changes per second
+#define HUDEMP_FRAMERATE			30.0f
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheHudDamage )
+CLIENTEFFECT_MATERIAL( "Hud/emp/emp_damage" )
+CLIENTEFFECT_REGISTER_END()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool GetEMPDamage()
+{
+	C_BaseTFPlayer *pPlayer;
+	pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return false;
+
+	return pPlayer->HasPowerup(POWERUP_EMP) ? true : false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Icon showing EMP damage is occuring
+//-----------------------------------------------------------------------------
+class CHudEMP : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudEMP, vgui::Panel );
+
+public:
+	DECLARE_MULTIPLY_INHERITED();
+
+	CHudEMP( const char *pElementName );
+	~CHudEMP();
+
+	// vgui::Panel overrides.
+	virtual void Paint( void );
+
+	// CHudElement overrides.
+	virtual bool ShouldDraw( void );
+	virtual void Init( void );
+
+protected:
+	IMaterial		*m_pEMPIcon;
+	IMaterialVar	*m_pFrameVar;
+
+	float			m_flNextFrameChange;
+	int				m_nNumFrames;
+};
+
+//DECLARE_HUDELEMENT( CHudEMP, CHudEMP );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudEMP::CHudEMP( const char *pElementName ) :
+	CHudElement( pElementName ), vgui::Panel( NULL, pElementName )
+{
+	m_pEMPIcon = NULL;
+	m_pFrameVar = NULL;
+	m_flNextFrameChange = 0.0f;
+	m_nNumFrames = 1;
+	//SetPaintBackgroundEnabled( false );
+	SetAutoDelete( false );
+	SetName( "emp" );
+	
+	SetHiddenBits( HIDEHUD_HEALTH );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudEMP::~CHudEMP( void )
+{
+	if ( m_pEMPIcon )
+	{
+		m_pEMPIcon->DecrementReferenceCount();
+		m_pEMPIcon = NULL;
+	}
+	SetParent( (vgui::Panel *)NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Attach the jetpack bar to the main panel
+//-----------------------------------------------------------------------------
+void CHudEMP::Init( void )
+{
+	if ( !m_pEMPIcon )
+	{
+		m_pEMPIcon = materials->FindMaterial( "Hud/emp/emp_damage", TEXTURE_GROUP_VGUI );
+		assert( m_pEMPIcon );
+		m_pEMPIcon->IncrementReferenceCount();
+
+		m_pFrameVar = m_pEMPIcon->FindVar( "$frame", NULL, false );
+		m_nNumFrames = m_pEMPIcon->GetNumAnimationFrames();
+	}
+
+	SetPos( HUDEMP_LEFT, HUDEMP_TOP );
+	SetSize( HUDEMP_WIDTH, HUDEMP_HEIGHT );
+
+	vgui::Panel *pParent = GetClientModeNormal()->GetViewport();
+	SetParent(pParent);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHudEMP::ShouldDraw( void )
+{
+	return ( CHudElement::ShouldDraw() && GetEMPDamage() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the jetpack level
+//-----------------------------------------------------------------------------
+void CHudEMP::Paint()
+{
+	// Rush label
+	int iX, iY;
+	GetPos( iX, iY );
+	int iWidth = XRES(16);
+	int iHeight = YRES(16);
+
+	if ( m_pFrameVar )
+	{
+		float curtime = gpGlobals->curtime;
+
+		if ( curtime >= m_flNextFrameChange )
+		{
+			m_flNextFrameChange = curtime + ( 1.0f / HUDEMP_FRAMERATE );
+
+			int frame = m_pFrameVar->GetIntValue();
+			frame++;
+			if ( frame >= m_nNumFrames )
+			{
+				frame = 0;
+			}
+			m_pFrameVar->SetIntValue(frame);
+		}
+	}
+
+	IMesh* pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_pEMPIcon );
+
+	CMeshBuilder meshBuilder;
+	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
+
+	meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+	meshBuilder.TexCoord2f( 0,0,0 );
+	meshBuilder.Position3f( iX,iY,0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+	meshBuilder.TexCoord2f( 0,1,0 );
+	meshBuilder.Position3f( iX+iWidth, iY, 0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+	meshBuilder.TexCoord2f( 0,1,1 );
+	meshBuilder.Position3f( iX+iWidth, iY+iHeight, 0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.Color3f( 1.0, 1.0, 1.0 );
+	meshBuilder.TexCoord2f( 0,0,1 );
+	meshBuilder.Position3f( iX, iY+iHeight, 0 );
+	meshBuilder.AdvanceVertex();
+
+	meshBuilder.End();
+	pMesh->Draw();
+}
+
diff --git a/game/client/tf2/hud_health.cpp b/game/client/tf2/hud_health.cpp
new file mode 100644
index 0000000..474bc90
--- /dev/null
+++ b/game/client/tf2/hud_health.cpp
@@ -0,0 +1,217 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: TF2's Hud health display
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "hud_numeric.h"
+#include "c_basetfplayer.h"
+#include "basetfvehicle.h"
+#include <vgui_controls/AnimationController.h>
+#include <KeyValues.h>
+#include "iclientmode.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Local player health
+//-----------------------------------------------------------------------------
+class CHudHealth : public CHudNumeric
+{
+	DECLARE_CLASS_SIMPLE( CHudHealth, CHudNumeric );
+
+public:
+	CHudHealth( const char *pElementName );
+
+	virtual const char *GetLabelText() { return m_szHealthLabel; }
+	virtual const char *GetPulseEvent( bool increment ) { return increment ? "HealthIncrement" : "HealthDecrement"; }
+	virtual bool		GetValue( char *val, int maxlen );
+
+	virtual Color GetColor();
+	virtual Color GetBoxColor();
+
+private:
+	bool				GetHealth( int& value );
+
+	CPanelAnimationStringVar( 128, m_szHealthLabel, "HealthLabel", "Health" );
+};
+
+DECLARE_HUDELEMENT( CHudHealth );
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudHealth::CHudHealth( const char *pElementName ) :
+	CHudNumeric( pElementName, "HudHealth" )
+{
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD | HIDEHUD_NEEDSUIT );
+}
+
+bool CHudHealth::GetHealth( int& value )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return false;
+
+	value = pPlayer->GetHealth();
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : value - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHudHealth::GetValue( char *val, int maxlen )
+{
+	int value = 0;
+	if ( !GetHealth( value ) )
+		return false;
+
+	Q_snprintf( val, maxlen, "%i", value );
+	return true;
+}
+
+Color CHudHealth::GetColor()
+{
+	int value = 0;
+	if ( !GetHealth( value ) || value > 25  )
+		return m_TextColor;
+
+	return m_TextColorCritical;
+}
+
+Color CHudHealth::GetBoxColor()
+{
+	int value = 0;
+	if ( !GetHealth( value ) || value > 25  )
+		return m_BoxColor;
+	return m_BoxColorCritical;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Local player's vehicle health, if in one
+//-----------------------------------------------------------------------------
+class CHudVehicleHealth : public CHudNumeric
+{
+	DECLARE_CLASS_SIMPLE( CHudVehicleHealth, CHudNumeric );
+
+public:
+	CHudVehicleHealth( const char *pElementName );
+
+	virtual const char *GetLabelText() { return m_szVehicleHealthLabel; }
+	virtual const char *GetPulseEvent( bool increment ) { return increment ? "HealthVehicleIncrement" : "HealthVehicleDecrement"; }
+	virtual bool		GetValue( char *val, int maxlen );
+
+	virtual Color GetColor();
+	virtual Color GetBoxColor();
+
+private:
+	bool				GetHealth( int& value );
+
+	CPanelAnimationVar( float, m_flLingerTime, "exit_vehicle_linger_time", "2.0" );
+
+	bool				m_bPrevHealth;
+	float				m_flLingerFinish;
+	int					m_nLastHealth;
+
+	CPanelAnimationStringVar( 128, m_szVehicleHealthLabel, "VehicleHealthLabel", "Vehicle Health" );
+};
+
+DECLARE_HUDELEMENT( CHudVehicleHealth );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudVehicleHealth::CHudVehicleHealth( const char *pElementName ) :
+	CHudNumeric( pElementName, "HudVehicleHealth" )
+{
+	m_bPrevHealth = false;
+	m_flLingerFinish = 0.0f;
+	m_flLingerTime = 2.0f;
+	m_nLastHealth = 0;
+
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+}
+
+bool CHudVehicleHealth::GetHealth( int& value )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer )
+	{
+		// Draw the vehicle health:
+		C_BaseTFVehicle *pVehicleEnt = ( C_BaseTFVehicle* )pPlayer->GetVehicle();
+		if( pVehicleEnt )
+		{
+			value = pVehicleEnt->GetHealth();
+			m_nLastHealth = value;
+			bool changed = m_bPrevHealth != true;
+
+			if ( changed )
+			{
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(  "HealthVehicleEnterVehicle" );
+			}
+
+			m_bPrevHealth = true;
+			return true;
+		}
+	}
+	
+	bool changed = m_bPrevHealth != false;
+	if ( changed )
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "HealthVehicleExitVehicle" );
+		m_flLingerFinish = gpGlobals->curtime + m_flLingerTime;
+	}
+
+	m_bPrevHealth = false;
+
+	if ( gpGlobals->curtime < m_flLingerFinish )
+	{
+		value = m_nLastHealth;
+		return true;
+	}
+
+	m_flLingerFinish = 0.0f;
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : value - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHudVehicleHealth::GetValue( char *val, int maxlen )
+{
+	int value = 0;
+	bool show = GetHealth( value );
+	if ( !show )
+	{
+		return false;
+	}
+
+	Q_snprintf( val, maxlen,  "%i", value );
+	return true;
+}
+
+Color CHudVehicleHealth::GetColor()
+{
+	int value = 0;
+	if ( !GetHealth( value ) || value > 75 )
+		return m_TextColor;
+
+	return m_TextColorCritical;
+}
+
+Color CHudVehicleHealth::GetBoxColor()
+{
+	int value = 0;
+	if ( !GetHealth( value ) || value > 75 )
+		return m_BoxColor;
+	return m_BoxColorCritical;
+}
diff --git a/game/client/tf2/hud_minimap.cpp b/game/client/tf2/hud_minimap.cpp
new file mode 100644
index 0000000..dded27a
--- /dev/null
+++ b/game/client/tf2/hud_minimap.cpp
@@ -0,0 +1,1367 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud_minimap.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+#include <vgui/IVGui.h>
+#include <vgui/IInput.h>
+#include <vgui_controls/AnimationController.h>
+#include "vgui_bitmapimage.h"
+#include "clientmode_tfbase.h"
+#include "clientmode_tfnormal.h"
+#include "hud.h"
+#include "hud_commander_statuspanel.h"
+#include "view.h"
+#include "filesystem.h"
+#include "imessagechars.h"
+#include "hud_macros.h"
+#include "c_tfteam.h"
+#include "c_info_act.h"
+#include "engine/IEngineSound.h"
+#include "iinput.h"
+#include "in_buttons.h"
+#include "c_basetfplayer.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static ConVar minimap_visible( "minimap_visible", "1", 0, "Draw minimap?" );
+ConVar minimap_zoomtime( "minimap_zoomtime", "0.4", 0, "How long it takes to resize the minimap." );
+
+
+static ConVar current_team( "current_team", "-1", 0 );
+
+// Start out new maps at this zoom level
+#define DEFAULT_ZOOM_LEVEL	0
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Instantiate a temporary trace (position based, or entity based)
+//-----------------------------------------------------------------------------
+void MinimapCreateTempTrace( const char* pMetaClassName, int sortOrder, const Vector &vecPosition )
+{
+	MinimapInitData_t initData;
+	initData.m_vecPosition = vecPosition;
+
+	PanelMetaClassMgr()->CreatePanelMetaClass( 
+		pMetaClassName, sortOrder, &initData, CMinimapPanel::MinimapRootPanel() );
+}
+
+void MinimapCreateTempTrace( const char* pMetaClassName, int sortOrder, C_BaseEntity *pEntity, const Vector &vecOffset )
+{
+	MinimapInitData_t initData;
+	initData.m_pEntity = pEntity;
+	initData.m_vecPosition = vecOffset;
+
+	PanelMetaClassMgr()->CreatePanelMetaClass( 
+		pMetaClassName, sortOrder, &initData, CMinimapPanel::MinimapRootPanel() );
+}
+
+//-----------------------------------------------------------------------------
+// dummy root panel for all minimap traces
+//-----------------------------------------------------------------------------
+class CMinimapRootPanel : public Panel
+{
+	typedef Panel BaseClass;
+
+public:
+	CMinimapRootPanel( Panel *pParent = NULL ) 
+		: BaseClass( pParent,"CMinimapRootPanel" ) 
+	{
+		SetPaintBackgroundEnabled( false );
+		SetPaintEnabled( false );
+		SetAutoDelete( false );
+	}
+};
+
+class CTextHelpPanel : public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CTextHelpPanel, vgui::Panel )
+
+public:
+	
+	CTextHelpPanel();
+
+	virtual void Paint();
+	virtual void PaintBackground();
+
+	void	SetImage( BitmapImage *image );
+
+	virtual void ApplySettings( KeyValues *inResourceData )
+	{
+		BaseClass::ApplySettings( inResourceData );
+	}
+
+private:
+
+	BitmapImage		*m_pImage;
+
+	CPanelAnimationVar( Color, m_OverlayColor, "OverlayColor", "White" );
+	CPanelAnimationVar( Color, m_BorderColor, "BorderColor", "BrightFg" );
+	CPanelAnimationVar( Color, m_BackgroundColor, "BackgroundColor", "Black" );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTextHelpPanel::CTextHelpPanel()
+: BaseClass( NULL, "HudMinimapTextHelpPanel" )
+{
+	Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetVisible( false );
+	SetZPos( 1 );
+
+	m_pImage = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTextHelpPanel::PaintBackground()
+{
+	// Get alpha from image
+	if ( m_pImage )
+	{
+		Color bg = m_BackgroundColor;
+		int r, g, b, a;
+		m_pImage->GetColor( r, g, b, a );
+		bg[3] = a;
+		SetBgColor( bg );
+	
+		BaseClass::PaintBackground();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTextHelpPanel::Paint()
+{
+	BaseClass::Paint();
+
+	if ( !m_pImage )
+		return;
+
+	m_pImage->SetColor( m_OverlayColor );
+	m_pImage->DoPaint( GetVPanel() );
+
+	int w, h;
+	GetSize( w, h );
+
+	surface()->DrawSetColor( m_BorderColor );
+	surface()->DrawOutlinedRect( 0, 0, w, h );
+	surface()->DrawOutlinedRect( 1, 1, w-1, h-1 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *image - 
+//			x - 
+//			y - 
+//			w - 
+//			h - 
+//-----------------------------------------------------------------------------
+void CTextHelpPanel::SetImage( BitmapImage *image )
+{
+	m_pImage = image;
+}
+
+//-----------------------------------------------------------------------------
+// globals
+//-----------------------------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// All traces are children of this panel
+//-----------------------------------------------------------------------------
+Panel *CMinimapPanel::MinimapRootPanel()
+{
+	static CMinimapRootPanel s_MinimapRootPanel;
+	return &s_MinimapRootPanel; 
+}
+
+CMinimapPanel *CMinimapPanel::MinimapPanel()
+{
+	ClientModeTFBase *pBasemode = ( ClientModeTFBase * )g_pClientMode;
+	if ( !pBasemode )
+		return NULL;
+
+	return pBasemode->GetMinimap();
+}
+
+DECLARE_HUDELEMENT( CMinimapPanel );
+DECLARE_HUD_MESSAGE( CMinimapPanel, MinimapPulse );
+
+//-----------------------------------------------------------------------------
+// Purpose: Placeholder for small overview map with viewport rectangle/selector
+//-----------------------------------------------------------------------------
+CMinimapPanel::CMinimapPanel( const char *pElementName )
+: CHudElement( pElementName ), BaseClass( NULL, "HudMinimap" )
+{
+	Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetAutoDelete( false );
+	for ( int i = 0; i < MAX_ACT_TEAMS; i++ )
+	{
+		m_pBackground[ i ] = 0;
+	}
+	memset( m_rgOverlays, 0, sizeof( m_rgOverlays ) );
+
+	m_flExpansionFrac = 0.0f;
+
+	// Minimap zoom
+	m_bMinimapZoomed = false;
+	m_nZoomLevel = DEFAULT_ZOOM_LEVEL;
+
+	m_vecCurrentOrigin.Init();
+	m_vecMapCenter.Init();
+	m_flMapAspectRatio = 1.0f;
+	m_flViewportAspectRatio = 1.0f;
+	m_flAspectAdjustment = 1.0f;
+	m_flNormalizedXScale = 1.0f;
+	m_flNormalizedYScale = 1.0f;
+	m_flNormalizedXOffset = 0.0f;
+	m_flNormalizedYOffset = 0.0f;
+
+	m_nCurrentAct = ACT_NONE_SPECIFIED;
+
+	m_pTextPanel = new CTextHelpPanel();
+	m_pBackgroundPanel = new Panel( NULL, "BackgroundPanel" );
+
+	// We're gonna manage the lifetime of the text panel
+	// since we change it's hierarchical connections from time to time
+	m_pTextPanel->SetAutoDelete( false );
+	m_pBackgroundPanel->SetAutoDelete( false );
+	SetAutoDelete( false );
+	
+	m_pClient = NULL;
+
+	m_flZoomAdjust = 1.0f;
+	m_flPrevZoomAmount = 0.01f;
+
+	SetZPos( 10 );
+
+	ivgui()->AddTickSignal( GetVPanel() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CMinimapPanel::~CMinimapPanel( void )
+{
+	delete m_pTextPanel;
+	delete m_pBackgroundPanel;
+
+	for ( int i = 0; i < MAX_ACT_TEAMS; i++ )
+	{
+		delete m_pBackground[ i ];
+	}
+
+	ShutdownOverlays();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *scheme - 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::ApplySchemeSettings( IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+	SetPaintBackgroundEnabled( false );
+}
+
+
+//-----------------------------------------------------------------------------
+// initialization
+//-----------------------------------------------------------------------------
+void CMinimapPanel::Init( IMinimapClient* pClient )
+{
+	m_pClient = pClient;
+}
+
+//-----------------------------------------------------------------------------
+// Call this when the minimap panel is going to be drawn...
+//-----------------------------------------------------------------------------
+void CMinimapPanel::Activate()
+{
+	// The panel is a view into the minimap root panel
+	MinimapRootPanel()->SetParent( this );
+
+	Panel *pParent = g_pClientMode->GetViewport();
+
+	if ( pParent && m_pBackgroundPanel )
+	{
+		m_pBackgroundPanel->SetParent( pParent );
+		m_pBackgroundPanel->SetBounds( XRES( 0 ), YRES( 0 ), XRES( 640 ), YRES( 480 ) );
+		m_pBackgroundPanel->SetVisible( false );
+		m_pBackgroundPanel->SetZPos( 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : w - 
+//			h - 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::OnSizeChanged( int w, int h )
+{
+	BaseClass::OnSizeChanged( w, h );
+
+	MinimapRootPanel()->SetSize( w, h );
+
+	// Make sure icons are snapped to current window size
+	InvokeOnTickOnChildren( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CMinimapPanel::GetAdjustedZoom( void )
+{
+	return m_flZoomAmount * m_flZoomAdjust;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CMinimapPanel::GetTrueZoom()
+{
+	return m_flZoomAmount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : center - 
+//			scale - 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::GetMapOriginAndScale( Vector& origin, float& scale )
+{
+	origin	= m_vecCurrentOrigin;
+	scale	= GetAdjustedZoom();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : clip - 
+//			pos - 
+//			outx - 
+//			outy - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CMinimapPanel::WorldToMinimap( MinimapPosType_t posType, const Vector& pos, float& outx, float& outy )
+{
+	Vector origin;
+	float zoomscale;
+
+	GetMapOriginAndScale( origin, zoomscale );
+
+	return InternalWorldToMinimap( posType, pos, origin, zoomscale, outx, outy );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::AdjustNormalizedPositionForAspectRatio( float& x, float& y )
+{
+	x = m_flNormalizedXOffset + x * m_flNormalizedXScale;
+	y = m_flNormalizedYOffset + y * m_flNormalizedYScale;
+}
+
+//-----------------------------------------------------------------------------
+// Converts a world-space position to a coordinate in minimap panel space
+//-----------------------------------------------------------------------------
+bool CMinimapPanel::InternalWorldToMinimap( MinimapPosType_t posType, const Vector &pos, const Vector& origin, float zoomscale, float& outx, float& outy )
+{
+	int wide, tall;
+	MinimapRootPanel()->GetSize( wide, tall );
+
+	Vector worldmins, worldmaxs;
+	MapData().GetMapBounds( worldmins, worldmaxs );
+	Vector worldsize = worldmaxs - worldmins;
+
+	Vector test = ( pos -  origin );
+
+	float xfraction = 0.0f;
+	
+	if ( worldsize.x > 0 )
+	{
+		xfraction = (test.x - worldmins.x) / (worldmaxs.x - worldmins.x);
+	}
+
+	float yfraction = 0.0f;
+	
+	if ( worldsize.y > 0 )
+	{
+		yfraction = (test.y - worldmins.y) / (worldmaxs.y - worldmins.y);
+	}
+
+	xfraction = ( xfraction - 0.5f ) * zoomscale + 0.5f; 
+	yfraction = ( yfraction - 0.5f ) * zoomscale + 0.5f;
+
+	yfraction = 1.0f - yfraction;
+
+	// Adjust in case not all of map can be shown
+	AdjustNormalizedPositionForAspectRatio( xfraction, yfraction );
+
+	// Normalize?
+	bool inside = true;
+	switch ( posType )
+	{
+	case MINIMAP_CLIP:
+		{
+			// Clip the vector from minimap center to object
+			// to the minimap bounds and put the object on the edge
+			Vector2D delta( xfraction - 0.5f, yfraction - 0.5f );
+			Vector2D fdelta( fabs(delta.x), fabs(delta.y) );
+			if (fdelta.x > fdelta.y)
+			{
+				// It's more horizontal than vertical..
+				if (fdelta.x >= 0.5f)
+				{
+					float flRatio = delta.y / delta.x;
+					xfraction = clamp(xfraction, 0, 1);
+					yfraction = (xfraction - 0.5f) * flRatio + 0.5f;
+				}
+			}
+			else
+			{
+				if (fdelta.y >= 0.5f)
+				{
+					// It's more vertical than horizontal
+					float flRatio = delta.x / delta.y;
+					yfraction = clamp(yfraction, 0, 1);
+					xfraction = (yfraction - 0.5f) * flRatio + 0.5f;
+				}
+			}
+		}
+		break;
+
+	case MINIMAP_CLAMP:
+		{
+			// Clamp the position to lie within the minimap
+			xfraction = clamp(xfraction, 0, 1);
+			yfraction = clamp(yfraction, 0, 1);
+		}
+		break;
+
+	case MINIMAP_NOCLIP:
+		{
+			// See if it's off screen
+			if ( xfraction < 0.0 || xfraction > 1.0 ||
+				 yfraction < 0.0 || yfraction > 1.0 )
+			{
+				inside = false;
+			}
+		}
+		break;
+	}
+
+	outx = xfraction * wide;
+	outy = yfraction * tall;
+	
+	return inside;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *mapname - 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::LevelInit( const char *mapname )
+{
+	SetBackgroundMaterials( MapData().m_Minimap.m_szBackgroundMaterial );
+
+	m_nZoomLevel = DEFAULT_ZOOM_LEVEL;
+
+	HOOK_HUD_MESSAGE( CMinimapPanel, MinimapPulse );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Play a pulse on the minimap
+//-----------------------------------------------------------------------------
+void CMinimapPanel::MsgFunc_MinimapPulse( bf_read &msg )
+{
+	Vector vecPosition;
+	msg.ReadBitVec3Coord( vecPosition );
+	C_TFTeam *pTeam = (C_TFTeam *)GetLocalTeam();
+	if ( pTeam )
+	{
+		pTeam->NotifyBaseUnderAttack( vecPosition, false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::LevelShutdown( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Sets the background material
+//-----------------------------------------------------------------------------
+void CMinimapPanel::SetBackgroundMaterials( const char *pMaterialName )
+{
+	int i;
+	for ( i = 0; i < MAX_ACT_TEAMS; i++ )
+	{
+		delete m_pBackground[ i ];
+		m_pBackground[ i ] = NULL;
+	}
+
+	if ( pMaterialName[ 0 ] )
+	{
+		for ( i = 0; i < MAX_ACT_TEAMS; i++ )
+		{
+			char teammaterial[ 512 ];
+
+			Q_snprintf( teammaterial, sizeof( teammaterial ), "%s_team%i",
+				pMaterialName, i + 1 );
+
+			// If a _team# version exists, use that, otherwise, use the default
+			if ( g_pFullFileSystem->FileExists( VarArgs( "materials/%s.vmt", teammaterial ) ) )
+			{
+				 m_pBackground[ i ] = new BitmapImage( GetVPanel(), teammaterial );
+			}
+			else
+			{
+				 m_pBackground[ i ] = new BitmapImage( GetVPanel(), pMaterialName );
+			}
+		}
+	}
+
+	if ( m_pTextPanel )
+	{
+		m_pTextPanel->SetImage( NULL );
+	}
+
+	ShutdownOverlays();
+	InitOverlays( pMaterialName );
+}
+
+//-----------------------------------------------------------------------------
+// Called when the mouse is hit 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::OnMousePressed(MouseCode code)
+{
+	if ((code == MOUSE_LEFT) && m_pClient)
+	{
+		// Convert mouse position to world position
+		int x, y;
+		vgui::input()->GetCursorPos( x, y );
+
+		int w, h;
+		GetSize( w, h );
+
+		Vector worldPos;
+		worldPos.x = (float) x / (float) w;
+		worldPos.y = 1.0f - (float) y / (float) h;
+		worldPos.z = 0;	// z isn't used
+
+		Vector worldMins, worldMaxs;
+		MapData().GetMapBounds( worldMins, worldMaxs );
+		worldPos *= (worldMaxs - worldMins);
+		worldPos += worldMins;
+
+		m_pClient->MinimapClicked( worldPos );
+	}
+}
+
+void CMinimapPanel::SetBackgroundViewport( float minx, float miny, float maxx, float maxy, bool includedetails )
+{
+	int i;
+	int x, y, w, h;
+
+	x = 0;
+	y = 0;
+	w = GetWide();
+	h = GetTall();
+
+	if ( minx < 0.0f || maxx > 1.0f ||
+		 miny < 0.0f || maxy > 1.0f )
+	{
+		float x0 = 0.0f;
+		float y0 = 0.0f;
+		float x1 = 1.0f;
+		float y1 = 1.0f;
+
+		float xrange = maxx - minx;
+		float yrange = maxy - miny;
+
+		if ( minx < 0.0f )
+		{
+			x0 = -minx / xrange;
+			//xrange += minx;
+			maxx -= minx;
+			minx = 0.0f;
+		}
+		if ( maxx > 1.0f )
+		{
+			x1 = 1.0f - ( maxx - 1.0f ) / xrange;
+			maxx = 1.0f;
+		}
+		if ( miny < 0.0f )
+		{
+			y0 = -miny / yrange;
+			//yrange += miny;
+			maxy -= miny;
+			miny = 0.0f;
+		}
+		if ( maxy > 1.0f )
+		{
+			y1 =  1.0f - ( maxy - 1.0f ) / yrange;
+			maxy = 1.0f;
+		}
+
+		x = x0 * w;
+		y = y0 * h;
+		w = x1 * w;
+		h = y1 * h;
+	}
+
+	for ( i = 0; i < MAX_ACT_TEAMS; i++ )
+	{
+		if ( m_pBackground[ i ] )
+		{
+			m_pBackground[ i ]->SetPos( x, y );
+			m_pBackground[ i ]->SetRenderSize( w, h );
+			m_pBackground[ i ]->SetViewport( true, minx, miny, maxx, maxy );
+		}
+	}
+
+	if ( includedetails )
+	{
+		int t;
+		for ( t = 0; t < MAX_ACT_TEAMS; t++ )
+		{
+			for ( i = 0; i < MAX_ACTS; i++ )
+			{
+				Overlays *p = &m_rgOverlays[ t ][ i ];
+				if ( !p->m_bInUse )
+					continue;
+
+				if ( !p->m_pOverlay )
+					continue;
+
+				p->m_pOverlay->SetPos( x, y );
+				p->m_pOverlay->SetRenderSize( w, h );
+				p->m_pOverlay->SetViewport( true, minx, miny, maxx, maxy );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::PaintActOverlays( int teamIndex, int alpha )
+{
+	Assert( teamIndex >= 0 && teamIndex < MAX_ACT_TEAMS );
+
+	bool textshowing = false;
+
+	int i = GetCurrentActNumber();
+	if ( i != ACT_NONE_SPECIFIED )
+	{
+		i = clamp( i, 0, MAX_ACTS - 1 );
+		Overlays *p = &m_rgOverlays[ teamIndex ][ i ];
+		if ( p->m_bInUse )
+		{
+			int r, g, b, a;
+
+			if ( p->m_pOverlay )
+			{
+				p->m_pOverlay->GetColor( r, g, b, a );
+				Color clr( r, g, b, alpha );
+				p->m_pOverlay->SetColor( clr );
+				p->m_pOverlay->DoPaint( NULL, 0, (float)alpha/255.0f );
+			}
+
+			if ( p->m_pText && m_pTextPanel )
+			{
+				p->m_pText->GetColor( r, g, b, a );
+				Color clr( r, g, b, alpha );
+				p->m_pText->SetColor( clr );
+
+				m_pTextPanel->SetImage( p->m_pText );
+
+				clr = m_BackgroundColor;
+				clr[3] = alpha;
+				m_pBackgroundPanel->SetBgColor( clr );
+ 
+				textshowing = true;
+			}				
+		}
+	}
+	
+	if ( !textshowing )
+	{
+		m_pTextPanel->SetVisible( false );
+		m_pTextPanel->SetImage( NULL );
+		m_pBackgroundPanel->SetVisible( false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::OnThink()
+{
+	BaseClass::OnThink();
+
+	C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
+	if ( local )
+	{
+		if ( local->m_TFLocal.m_bForceMapOverview && m_bMinimapZoomed != local->m_TFLocal.m_bForceMapOverview )
+		{
+			SetMinimapZoom( local->m_TFLocal.m_bForceMapOverview );
+		}
+	}
+
+	if ( !IsVisible() )
+		return;
+
+	if ( m_flZoomAmount != m_flPrevZoomAmount )
+	{
+		m_flPrevZoomAmount = m_flZoomAmount;
+		ComputeMapOrigin( m_vecCurrentOrigin );	
+		InvokeOnTickOnChildren( this );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::Paint()
+{
+	if ( gHUD.IsHidden( HIDEHUD_MISCSTATUS ) )
+	{
+		// Remove the minimap zoom if the hud's hidden
+		SetMinimapZoom( false );
+		return;
+	}
+
+	C_BasePlayer *local = C_BasePlayer::GetLocalPlayer();
+	int team = 0;
+	if ( local )
+	{
+		team = local->GetTeamNumber();
+	}
+
+	int w, h;
+	GetSize( w, h );
+
+	int alpha;
+	bool shouldDrawDetails = ShouldDrawZoomDetails( alpha );
+
+	if ( m_pTextPanel && m_pBackgroundPanel )
+	{
+		m_pTextPanel->SetVisible( shouldDrawDetails );
+		m_pBackgroundPanel->SetVisible( shouldDrawDetails );
+	}
+
+	// DEBUGGING:  Allow cvar override
+	if ( current_team.GetInt() >= 0 )
+	{
+		team = current_team.GetInt();
+	}
+
+	// Can can be 0 through MAX_ACT_TEAMS
+	team = clamp( team, 0, MAX_ACT_TEAMS );
+
+	// Array index is 0 to MAX_ACT_TEAMS - 1 where a team of zero means no team and won't be indexed
+	//  due to logic that checks team > 0 
+	int teamIndex = clamp( team - 1, 0, MAX_ACT_TEAMS - 1 );
+
+	if ( m_pBackground[ teamIndex ] )
+	{
+		if ( shouldDrawDetails )
+		{
+			Color clr = m_BackgroundColor;
+			clr[3] *= alpha / 255.0f;
+			surface()->DrawSetColor( clr );
+			surface()->DrawFilledRect( 0, 0, w, h );
+		}
+
+		float offsetx, offsety;
+
+		// Need to translate m_vecCurrentOrigin into minimap space
+		InternalWorldToMinimap( 
+			MINIMAP_NOCLIP, 
+			m_vecCurrentOrigin,
+			-m_vecMapCenter,
+			1,
+			offsetx, offsety );
+
+		// Scale to 0.0f to 1.0f
+		offsetx /= (float)w;
+		offsety /= (float)h;
+
+		float minx, maxx, miny, maxy;
+
+		float xscale = 1.0f;
+		float yscale = 1.0f;
+		float startx = 0.0f;
+		float starty = 0.0f;
+
+		Assert( m_flAspectAdjustment > 0.0f );
+
+		// Note, the scale sense is inverted here
+		float invaspect = 1.0f / m_flAspectAdjustment;
+
+		if ( m_flAspectAdjustment < 1.0f )
+		{
+			xscale = invaspect;
+			startx = ( 1.0f - xscale ) * 0.5f;
+		}
+		else
+		{
+			yscale = m_flAspectAdjustment;
+			starty = ( 1.0f - yscale ) * 0.5f;
+		}
+
+		float halfzoom = ( 1.0f / GetAdjustedZoom() ) * 0.5f;
+
+		// zoom scale is already normalized, so just take half in one direction, half the other
+		minx = startx + xscale * ( offsetx - halfzoom );
+		miny = starty + yscale * ( offsety - halfzoom );
+		maxx = startx + xscale * ( offsetx + halfzoom );
+		maxy = starty + yscale * ( offsety + halfzoom );
+
+		SetBackgroundViewport( minx, miny, maxx, maxy, shouldDrawDetails );
+
+		m_pBackground[ teamIndex ]->DoPaint( NULL );
+
+		if ( shouldDrawDetails && ( team > 0 ) )
+		{
+			PaintActOverlays( teamIndex, alpha );
+		}
+	}
+	else
+	{
+		Color clr = m_BackgroundColor;
+		clr[3] *= alpha * 0.9f / 255.0f;
+
+		surface()->DrawSetColor( clr );
+		surface()->DrawFilledRect( 0, 0, w, h );
+	}
+
+	// Dumb place to do this
+	if ( !shouldDrawDetails && CurrentActIsAWaitingAct() )
+	{
+		char *cmsg = "Wait for game start...";
+		int width, height;
+		messagechars->GetStringLength( g_hFontTrebuchet24, &width, &height, cmsg );
+		messagechars->DrawString( g_hFontTrebuchet24, XRES(16), ScreenHeight() - (height * 6), 255, 255, 245, 255, cmsg, IMessageChars::MESSAGESTRINGID_NONE );
+	}
+
+	Color border = m_BorderColor;
+	border[3] = border[3] * ( alpha * 0.9f ) / 255.0f;
+
+	//border = vgui::Color( 255, 0, 120, 255 );
+
+	surface()->DrawSetColor( border );
+	surface()->DrawOutlinedRect( 0, 0, w, h );
+	surface()->DrawOutlinedRect( 1, 1, w-1, h-1 );
+}
+
+void CMinimapPanel::InvokeOnTickOnChildren( vgui::Panel *parent )
+{
+	if ( !parent )
+		return;
+
+	int c = parent->GetChildCount();
+	int i;
+	for ( i = 0; i < c; i++ )
+	{
+		vgui::Panel *child = parent->GetChild( i );
+		child->OnTick();
+		InvokeOnTickOnChildren( child );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::OnTick()
+{
+	// See if the act's changed. If it has, bring up the act overlays.
+	if ( m_nCurrentAct != GetCurrentActNumber() )
+	{
+	//	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "MinimapActChanged" );
+	//	SetMinimapZoom( true );
+		m_nCurrentAct = GetCurrentActNumber();
+	}
+
+	// Cache these only once per frame if in a valid game
+	if ( C_BasePlayer::GetLocalPlayer() && minimap_visible.GetBool() )
+	{
+		SetVisible( true );
+		ComputeMapOrigin( m_vecCurrentOrigin );	
+	}
+	else
+	{
+		SetVisible( false );
+	}
+
+	InvokeOnTickOnChildren( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : alpha - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CMinimapPanel::ShouldDrawZoomDetails( int& alpha )
+{
+	alpha = (int)m_flDetailsAlpha;
+	alpha = clamp( alpha, 0, 255 );
+
+	if ( !alpha )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : center - 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::ComputeMapOrigin( Vector& origin )
+{
+	Vector worldmins, worldmaxs, worldsize;
+	MapData().GetMapBounds( worldmins, worldmaxs );
+	VectorSubtract( worldmaxs, worldmins, worldsize );
+
+	// Cache true map center
+	m_vecMapCenter = ( worldmins + worldmaxs ) * 0.5f;
+
+	C_BasePlayer* pPlayer = C_BasePlayer::GetLocalPlayer();
+
+	Vector playerOrigin; 
+
+	if( !pPlayer )
+	{
+		playerOrigin = m_vecMapCenter;
+	}
+	else
+	{
+		playerOrigin = pPlayer->GetAbsOrigin();
+	}
+
+	origin.Init();
+	 
+	playerOrigin.z = m_vecMapCenter.z = 0.0f;
+
+	Vector delta = playerOrigin - m_vecMapCenter;
+
+	// Map center pointer is biased toward player origin as we become zoomed in to 1.0x to 2.5x and toward true world center as we zoom all the way out
+	VectorScale( delta, m_flCenterOnPlayer, origin );
+
+	int vw, vh;
+	GetSize( vw, vh );
+
+	m_flMapAspectRatio = 1.0f;
+	m_flViewportAspectRatio = 1.0f;
+	m_flAspectAdjustment = 1.0f;
+
+	if ( vh > 0 )
+	{
+		m_flViewportAspectRatio = ( float )vw / ( float )vh;
+	}
+
+	if ( worldsize.y > 0 )
+	{
+		m_flMapAspectRatio = worldsize.x / worldsize.y;
+	}
+
+	if ( m_flViewportAspectRatio > 0 )
+	{
+		m_flAspectAdjustment = m_flMapAspectRatio / m_flViewportAspectRatio;
+	}
+
+	float fittedworldunitsperpixel;
+	float zoomedworldunitsperpixel;
+	float zooomedoutworldunitsperpixel;
+	float actualworldunitsperpixel;
+
+	if ( m_flAspectAdjustment > 1.0f )
+	{
+		// World height fits exactly in minimap height at zoom 1x
+		fittedworldunitsperpixel = worldsize.y / (float)( vh );
+
+		// At higher zoom we get less world units per pixel
+		zoomedworldunitsperpixel = fittedworldunitsperpixel / m_flZoomAmount;
+
+		// at fully zoomed back view, world width fits window width instead
+		zooomedoutworldunitsperpixel = worldsize.x / (float)( vw );
+
+		// As we center more on player, we move away from zoomed out units and toward zoomed units per pixel
+		actualworldunitsperpixel = zooomedoutworldunitsperpixel + m_flCenterOnPlayer * ( zoomedworldunitsperpixel - zooomedoutworldunitsperpixel );
+
+		m_flZoomAdjust = (1-m_flCenterOnPlayer) + m_flCenterOnPlayer * ( 1/m_flViewportAspectRatio );
+	}
+	else
+	{
+		// World width fits exactly in minimap width at zoom 1x
+		fittedworldunitsperpixel = worldsize.x / (float)( vw );
+
+		// At higher zoom we get less world units per pixel
+		zoomedworldunitsperpixel = fittedworldunitsperpixel / m_flZoomAmount;
+
+		// at fully zoomed back view, world height fits window height instead
+		zooomedoutworldunitsperpixel = worldsize.y / (float)( vh );
+
+		// As we center more on player, we move away from zoomed out units and toward zoomed units per pixel
+		actualworldunitsperpixel = zooomedoutworldunitsperpixel + m_flCenterOnPlayer * ( zoomedworldunitsperpixel - zooomedoutworldunitsperpixel );
+
+		m_flZoomAdjust = (1-m_flCenterOnPlayer) + m_flCenterOnPlayer * ( 1/m_flAspectAdjustment );
+	}
+
+	Vector preOrigin = origin;
+
+	float inset_pixels = m_flInsetPixels;
+
+	float viewport_width_world_units	= ( float )( vw - 2 * inset_pixels ) * actualworldunitsperpixel;
+	float viewport_height_world_units	= ( float )( vh - 2 * inset_pixels ) * actualworldunitsperpixel;
+
+	// Insets apply when centering on player
+	m_flWorldSpaceInsets[ 0 ] = MIN( m_vecMapCenter.x, worldmins.x + m_flCenterOnPlayer * ( viewport_width_world_units ) * 0.5f );
+	m_flWorldSpaceInsets[ 1 ] = MIN( m_vecMapCenter.y, worldmins.y + m_flCenterOnPlayer * ( viewport_height_world_units ) * 0.5f );
+	m_flWorldSpaceInsets[ 2 ] = MAX( m_vecMapCenter.x, worldmaxs.x - m_flCenterOnPlayer * ( viewport_width_world_units ) * 0.5f );
+	m_flWorldSpaceInsets[ 3 ] = MAX( m_vecMapCenter.y, worldmaxs.y - m_flCenterOnPlayer * ( viewport_height_world_units ) * 0.5f );
+	
+	// Assuming origin is at center of view, compute world space left, top, right, bottom
+	m_flWorldSpaceBounds[ 0 ] = m_vecMapCenter.x + origin.x - viewport_width_world_units * 0.5f;
+	m_flWorldSpaceBounds[ 1 ] = m_vecMapCenter.y + origin.y - viewport_height_world_units * 0.5f;
+	m_flWorldSpaceBounds[ 2 ] = m_vecMapCenter.x + origin.x + viewport_width_world_units * 0.5f;
+	m_flWorldSpaceBounds[ 3 ] = m_vecMapCenter.y + origin.y + viewport_height_world_units * 0.5f;
+
+	// Clip these bounds
+	m_flClippedWorldSpaceBounds[ 0 ] = MAX( worldmins.x, m_flWorldSpaceBounds[ 0 ] );
+	m_flClippedWorldSpaceBounds[ 1 ] = MAX( worldmins.y, m_flWorldSpaceBounds[ 1 ] );
+	m_flClippedWorldSpaceBounds[ 2 ] = MIN( worldmaxs.x, m_flWorldSpaceBounds[ 2 ] );
+	m_flClippedWorldSpaceBounds[ 3 ] = MIN( worldmaxs.y, m_flWorldSpaceBounds[ 3 ] );
+
+	// Clip origin to inserts
+	origin.x = clamp( origin.x, m_flWorldSpaceInsets[ 0 ] - m_vecMapCenter.x, m_flWorldSpaceInsets[ 2 ] - m_vecMapCenter.x );
+	origin.y = clamp( origin.y, m_flWorldSpaceInsets[ 1 ] - m_vecMapCenter.y, m_flWorldSpaceInsets[ 3 ] - m_vecMapCenter.y );
+
+	/*
+	engine->Con_NPrintf( 1, "map bounds left %i top %i right %i bottom %i", 
+		(int)worldmins.x,
+		(int)worldmins.y,
+		(int)worldmaxs.x,
+		(int)worldmaxs.y );
+
+	engine->Con_NPrintf( 2, "world space bounds left %i top %i right %i bottom %i", 
+		(int)m_flWorldSpaceBounds[ 0 ],
+		(int)m_flWorldSpaceBounds[ 1 ],
+		(int)m_flWorldSpaceBounds[ 2 ],
+		(int)m_flWorldSpaceBounds[ 3 ] );
+
+	engine->Con_NPrintf( 3, "world space insets left %i top %i right %i bottom %i", 
+		(int)m_flWorldSpaceInsets[ 0 ],
+		(int)m_flWorldSpaceInsets[ 1 ],
+		(int)m_flWorldSpaceInsets[ 2 ],
+		(int)m_flWorldSpaceInsets[ 3 ] );
+
+	engine->Con_NPrintf( 4, "world space clipping left %i top %i right %i bottom %i", 
+		(int)m_flClippedWorldSpaceBounds[ 0 ],
+		(int)m_flClippedWorldSpaceBounds[ 1 ],
+		(int)m_flClippedWorldSpaceBounds[ 2 ],
+		(int)m_flClippedWorldSpaceBounds[ 3 ] );
+
+
+	engine->Con_NPrintf( 5, "world center %i %i", 
+		(int)m_vecMapCenter.x, (int)m_vecMapCenter.y );
+
+	engine->Con_NPrintf( 6, "player origin %i %i", 
+		(int)playerOrigin.x, (int)playerOrigin.y );
+
+	engine->Con_NPrintf( 7, "desired map center %i %i", 
+		(int)( m_vecMapCenter.x + preOrigin.x ), (int)( preOrigin.y + m_vecMapCenter.x ) );
+
+	engine->Con_NPrintf( 8, "actual map center %i %i", 
+		(int)( m_vecMapCenter.x + origin.x ), (int)( origin.y + m_vecMapCenter.y ) );
+
+	engine->Con_NPrintf( 9, "viewport (%ix%i) aspect %.2f world (%ix%i) aspect %f",
+		vw, vh, m_flViewportAspectRatio, (int)worldsize.x, (int)worldsize.y, m_flMapAspectRatio );
+	
+	engine->Con_NPrintf( 10, "zoom %.3f zoom adjust %.3f", 
+		m_flZoomAmount, m_flZoomAdjust );
+
+	engine->Con_NPrintf( 11, "viewport %i x %i", 
+		(int)viewport_width_world_units, (int)viewport_height_world_units );
+	*/
+
+	// Assume 100% scale and no x or y offset to make up for aspect ration diff
+	m_flNormalizedXScale = 1.0f;
+	m_flNormalizedYScale = 1.0f;
+	m_flNormalizedXOffset = 0.0f;
+	m_flNormalizedYOffset = 0.0f;
+
+	if ( m_flAspectAdjustment < 1.0f )
+	{
+		m_flNormalizedXScale = m_flAspectAdjustment;
+		// Offset 0->1 version of x value
+		m_flNormalizedXOffset = ( 1.0f - m_flNormalizedXScale ) * 0.5f;
+	}
+	else
+	{
+		m_flNormalizedYScale = 1.0f / m_flAspectAdjustment;
+		// Offset 0->1 version of y value
+		m_flNormalizedYOffset = ( 1.0f - m_flNormalizedYScale ) * 0.5f;
+	}
+}
+
+void CMinimapPanel::InitOverlays( const char *materialrootname )
+{
+	if ( !materialrootname || !materialrootname[0] )
+		return;
+
+	int t;
+	for ( t = 0; t < MAX_ACT_TEAMS; t++ )
+	{
+		char teamnum[ 2 ];
+		Q_snprintf( teamnum, sizeof( teamnum ), "%01i", t + 1 );
+
+		int i;
+		for ( i = 0; i < MAX_ACTS; i++ )
+		{
+			char actnum[ 3 ];
+
+			char filename[ 512 ];
+
+			Q_snprintf( actnum, sizeof( actnum ), "%02i", i );
+
+			Overlays *p = &m_rgOverlays[ t ][ i ];
+			Assert( p && !p->m_bInUse );
+
+			Q_snprintf( filename, sizeof( filename ), "%s_act%s_overlay_team%s",
+				materialrootname, actnum, teamnum );
+
+			// Check if file exists
+			if ( g_pFullFileSystem->FileExists( VarArgs( "materials/%s.vmt", filename ) ) )
+			{
+				p->m_pOverlay = new BitmapImage( GetVPanel(), filename );
+				p->m_bInUse = true;
+			}
+			else
+			{
+				// Try it without the team number
+				Q_snprintf( filename, sizeof( filename ), "%s_act%s_overlay",
+					materialrootname, actnum );
+
+				if ( g_pFullFileSystem->FileExists( VarArgs( "materials/%s.vmt", filename ) ) )
+				{
+					p->m_pOverlay = new BitmapImage( GetVPanel(), filename );
+					p->m_bInUse = true;
+				}
+			}
+
+			Q_snprintf( filename, sizeof( filename ), "%s_act%s_text_team%s",
+				materialrootname, actnum, teamnum );
+
+			// Check if file exists
+			if ( g_pFullFileSystem->FileExists( VarArgs( "materials/%s.vmt", filename ) ) )
+			{
+				p->m_pText = new BitmapImage( GetTextPaintPanel()->GetVPanel(), filename );
+				p->m_bInUse = true;
+			}
+			else
+			{
+				// Try it without the team number
+				Q_snprintf( filename, sizeof( filename ), "%s_act%s_text",
+					materialrootname, actnum );
+
+				// Check if file exists
+				if ( g_pFullFileSystem->FileExists( VarArgs( "materials/%s.vmt", filename ) ) )
+				{
+					p->m_pText = new BitmapImage( GetTextPaintPanel()->GetVPanel(), filename );
+					p->m_bInUse = true;
+				}
+			}
+		}	
+	}
+}
+
+void CMinimapPanel::ShutdownOverlays( void )
+{
+	int t;
+	for ( t = 0; t < MAX_ACT_TEAMS; t++ )
+	{
+
+		int i;
+		for ( i = 0; i < MAX_ACTS; i++ )
+		{
+			Overlays *p = &m_rgOverlays[ t ][ i ];
+			Assert( p );
+			if ( !p->m_bInUse )
+				continue;
+
+			delete p->m_pOverlay;
+			delete p->m_pText;
+			p->m_bInUse = false;
+			p->m_pOverlay = NULL;
+			p->m_pText = NULL;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Panel
+//-----------------------------------------------------------------------------
+Panel *CMinimapPanel::GetTextPaintPanel( void )
+{
+	ClientModeTFBase *basemode = ( ClientModeTFBase * )g_pClientMode;
+	if ( !basemode )
+	{
+		Assert( 0 );
+		return NULL;
+	}
+
+	return basemode->GetMinimapParent();
+}
+
+void CMinimapPanel::ZoomIn( void )
+{
+	if ( m_flDetailsAlpha > 0 )
+	{
+		if ( m_nZoomLevel != 0 )
+		{
+		//	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(
+		//		"MinimapZoomLevel0" );
+		}
+
+		// Full window
+		m_nZoomLevel = 0;
+	}
+	else
+	{
+		m_nZoomLevel = ( m_nZoomLevel + 1 ) % ( NUM_WIDTHS );
+		m_nZoomLevel = clamp( m_nZoomLevel, 0, NUM_WIDTHS - 1 );	
+
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(
+			m_nZoomLevel == 0 ? 
+				"MinimapZoomLevel0" :
+				"MinimapZoomLevel1" );
+	}
+}
+
+void CMinimapPanel::Zoom_Minimap_f( void )
+{
+	ClientModeTFBase *basemode = ( ClientModeTFBase * )g_pClientMode;
+	if ( !basemode )
+		return;
+
+	CMinimapPanel *minimap = basemode->GetMinimap();
+	if ( !minimap )
+		return;
+
+	minimap->ZoomIn();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMinimapPanel::ToggleMinimap( void )
+{
+	int iKeybits = ::input->GetButtonBits( 0 );
+	bool hitting_button = ( iKeybits & (IN_ATTACK | IN_ATTACK2 | IN_JUMP) ) ? true : false;
+	if ( hitting_button && !m_bMinimapZoomed )
+	{
+		CLocalPlayerFilter filter;
+		C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, "ClientModeTFNormal.ToggleMinimap" );
+	}
+
+	SetMinimapZoom( !m_bMinimapZoomed );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void Toggle_Minimap_f( void )
+{
+	ClientModeTFBase *basemode = ( ClientModeTFBase * )g_pClientMode;
+	if ( !basemode )
+		return;
+
+	CMinimapPanel *minimap = basemode->GetMinimap();
+	if ( !minimap )
+		return;
+	minimap->ToggleMinimap();
+}
+
+static ConCommand minimap( "minimap", Toggle_Minimap_f, "Toggle size of the tf2 minimap." );
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the state of the minimap's zoom
+//-----------------------------------------------------------------------------
+void CMinimapPanel::SetMinimapZoom( bool bZoom )
+{
+	C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
+	if ( local && local->m_TFLocal.m_bForceMapOverview ) 
+	{
+		bZoom = true;
+	}
+
+	bool changed = bZoom != m_bMinimapZoomed;
+	m_bMinimapZoomed = bZoom;
+	if ( bZoom )
+	{
+		m_nZoomLevel = 0;
+	}
+
+	if ( changed )
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence(
+			m_bMinimapZoomed ?
+			"MinimapZoomToFullScreen" :
+			"MinimapZoomToCorner");
+
+		CLocalPlayerFilter filter;
+		C_BaseEntity::EmitSound( filter, SOUND_FROM_LOCAL_PLAYER, m_bMinimapZoomed ? "Minimap.ZoomIn" : "Minimap.ZoomOut" );
+
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get at input data before it's used
+//-----------------------------------------------------------------------------
+void CMinimapPanel::ProcessInput()
+{
+	int iKeybits = ::input->GetButtonBits( 0 );
+
+	bool hitting_button = ( iKeybits & (IN_ATTACK | IN_ATTACK2 | IN_JUMP) ) ? true : false;
+
+	// While the minimap's zoomed, 
+	if ( m_bMinimapZoomed && hitting_button )
+	{
+		SetMinimapZoom( false );
+		::input->ClearInputButton( (IN_ATTACK | IN_ATTACK2 | IN_JUMP) );
+	}
+
+	CHudElement::ProcessInput();
+}
+
+static ConCommand zoom_minimap( "zoom_minimap", CMinimapPanel::Zoom_Minimap_f, "Zoom in on minimap." );
+
+
+
+
diff --git a/game/client/tf2/hud_minimap.h b/game/client/tf2/hud_minimap.h
new file mode 100644
index 0000000..a0c6ab1
--- /dev/null
+++ b/game/client/tf2/hud_minimap.h
@@ -0,0 +1,272 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( HUD_MINIMAP_H )
+#define HUD_MINIMAP_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "mathlib/vector.h"
+#include "cdll_client_int.h"
+#include "hudelement.h"
+#include "utllinkedlist.h"
+#include "CommanderOverlay.h"
+#include "MapData.h"
+
+class BitmapImage;
+class CTextHelpPanel;
+
+//-----------------------------------------------------------------------------
+// This interfaces gets called when a click occurs in the minimap
+//-----------------------------------------------------------------------------
+class IMinimapClient
+{
+public:
+	virtual void MinimapClicked( const Vector& clickWorldPos ) = 0;
+};
+
+
+//-----------------------------------------------------------------------------
+// Ways to perform WorldToMinimap
+//-----------------------------------------------------------------------------
+enum MinimapPosType_t
+{
+	MINIMAP_NOCLIP = 0,	// Don't draw things off the minimap
+	MINIMAP_CLAMP,		// Clamp the position to lie within the minimap
+	MINIMAP_CLIP,		// Clip the vector from minimap center to object
+						// to the minimap bounds and put the object on the edge
+	MINIMAP_ALWAYS_ACCEPT // Just do the scaling and return a value - don't worry about clipping.
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: On the left side of the screen is an overview map and a highlight 
+// rectangle showing the current viewport
+//
+// NOTE: The minimap panel is architected in such a way as to view some global
+// state. There can be many instances of the minimap panel
+//-----------------------------------------------------------------------------
+class CMinimapPanel : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CMinimapPanel, vgui::Panel );
+
+public:
+	enum
+	{
+		STABLE = 0,
+		GROWING,
+		SHRINKING
+	};
+	
+							CMinimapPanel( const char *pElementName );
+	virtual					~CMinimapPanel( void );
+
+	void					Init( IMinimapClient* pClient = NULL );
+
+	virtual void			LevelInit( const char *mapname );
+	virtual void			LevelShutdown( void );
+
+	virtual void			ApplySchemeSettings( vgui::IScheme *scheme );
+
+	virtual void			OnMousePressed(vgui::MouseCode code);
+
+	virtual void			Paint();
+
+	virtual void			OnTick();
+	virtual void			OnThink();
+
+	virtual void			OnSizeChanged( int w, int h );
+
+	// Converts a world-space position to a coordinate in minimap panel space
+	bool					WorldToMinimap( MinimapPosType_t posType, const Vector &pos, float& outx, float& outy );
+
+	// The following methods deal with management of the minimap data
+	static vgui::Panel		*MinimapRootPanel();
+	static CMinimapPanel	*MinimapPanel();
+
+	// Call this when the minimap panel is going to be drawn...
+	void					Activate();
+
+	// 0 is minimized and won't draw zoom details, 1.0 is fully maximized
+	bool					ShouldDrawZoomDetails( int& alpha );
+
+	bool					InternalWorldToMinimap( MinimapPosType_t posType, const Vector &pos, const Vector& origin, float zoomscale, float& outx, float& outy );
+
+	static void				Zoom_Minimap_f( void );
+	void					ZoomIn( void );
+
+	void					ToggleMinimap( void );
+	void					SetMinimapZoom( bool bZoom);
+
+	virtual void			ProcessInput( void );
+
+	float					GetAdjustedZoom( void );
+	float					GetTrueZoom( void );
+
+	// Handler for our message
+	void					MsgFunc_MinimapPulse( bf_read &msg );
+
+private:
+	void					SetBackgroundMaterials( char const* pMaterialName );
+
+	void					GetMapOriginAndScale( Vector& origin, float& scale );
+
+	void					SetBackgroundViewport( float minx, float miny, float maxx, float maxy, bool includedetails );
+	void					PaintActOverlays( int teamIndex, int alpha );
+	void					AdjustNormalizedPositionForAspectRatio( float& x, float& y );
+
+	void					DrawVisibleArea( void );
+
+	void					ComputeMapOrigin( Vector& origin );
+
+	void					InitOverlays( const char *materialrootname );
+	void					ShutdownOverlays( void );
+
+	vgui::Panel				*GetTextPaintPanel( void );
+
+	void					InvokeOnTickOnChildren( vgui::Panel *parent );
+
+	bool	m_DrawVisibleArea;
+	IMinimapClient	*m_pClient;
+
+	CPanelAnimationVar( float, m_flExpansionFrac, "ExpansionFrac", "0" );
+	CPanelAnimationVar( float, m_flDetailsAlpha, "DetailsAlpha", "0" );
+	CPanelAnimationVar( float, m_flMapScale, "MapScale", "2000" );
+	CPanelAnimationVar( float, m_flZoomAmount, "ZoomAmount", "1.0" );
+	CPanelAnimationVar( float, m_flCenterOnPlayer, "CenterOnPlayer", "1" );
+
+	CPanelAnimationVar( float, m_flInsetPixels, "InsetPixels", "16" );
+
+	float					m_flPrevZoomAmount;
+
+	CPanelAnimationVar( Color, m_BackgroundColor, "BackgroundColor", "Black" );
+	CPanelAnimationVar( Color, m_BorderColor, "BorderColor", "FgColor" );
+
+	int						m_nZoomLevel;
+	bool					m_bMinimapZoomed;
+	int						m_nCurrentAct;
+
+	float					m_flZoomAdjust;  // Adjustment needed to get map to fit exactly into box in one dimension assuming
+												// m_flZoomAmount == 1.0f
+
+
+	enum
+	{
+		NUM_WIDTHS = 2,
+	};
+
+
+	// Calculated once per frame and cached
+	Vector					m_vecCurrentOrigin;
+	Vector					m_vecMapCenter;
+	float					m_flMapAspectRatio;
+	float					m_flViewportAspectRatio;
+	// map aspect / viewport aspect
+	float					m_flAspectAdjustment;
+
+	float					m_flNormalizedXScale;
+	float					m_flNormalizedYScale;
+	float					m_flNormalizedXOffset;
+	float					m_flNormalizedYOffset;
+
+
+	//	These are the wordspace corners of the minimap
+	float					m_flWorldSpaceBounds[ 4 ];
+	 // These are the above, except clamped to actual world mins/maxs
+	float					m_flClippedWorldSpaceBounds[ 4 ];
+	// These are used to clamp the map origin to keep the zoomed map from scrolling off screen
+	float					m_flWorldSpaceInsets[ 4 ];
+
+	enum
+	{
+		MAX_ACTS = 16,
+		MAX_ACT_TEAMS = 2
+	};
+
+	struct Overlays
+	{
+		bool				m_bInUse;
+		BitmapImage			*m_pOverlay;
+		BitmapImage			*m_pText;
+	};
+
+	BitmapImage				*m_pBackground[ MAX_ACT_TEAMS ];
+	Overlays				m_rgOverlays[ MAX_ACT_TEAMS ][ MAX_ACTS ];
+
+	CTextHelpPanel			*m_pTextPanel;
+	vgui::Panel				*m_pBackgroundPanel;
+};
+
+
+//-----------------------------------------------------------------------------
+// minimap render order
+//-----------------------------------------------------------------------------
+enum
+{
+	MINIMAP_GROUND_LINES = 0,
+	MINIMAP_RESOURCE_ZONES,
+	MINIMAP_OBJECTS, 
+	MINIMAP_SPY_CAMERAS,
+	MINIMAP_COLLECTORS,
+	MINIMAP_MAP_GOALS,
+	MINIMAP_PLAYERS,
+	MINIMAP_LOCAL_PLAYER,
+	MINIMAP_SNIPER_RESPAWN,
+	MINIMAP_PERSONAL_ORDERS
+};
+
+
+//-----------------------------------------------------------------------------
+// Instantiate a temporary trace (position based, or entity based)
+//-----------------------------------------------------------------------------
+void MinimapCreateTempTrace( const char* pMetaClassName, int sortOrder, const Vector &vecPosition );
+void MinimapCreateTempTrace( const char* pMetaClassName, int sortOrder, C_BaseEntity *pEntity, const Vector &vecOffset );
+
+
+//-----------------------------------------------------------------------------
+// Helper macro to make overlay factories one line of code. Use like this:
+//	DECLARE_MINIMAP_FACTORY( CEntityImagePanel, "image" );
+//-----------------------------------------------------------------------------
+struct MinimapInitData_t
+{
+	C_BaseEntity *m_pEntity;
+	Vector m_vecPosition;	// relative to m_pEntity if it's specified, otherwise absolute position
+
+	MinimapInitData_t() : m_pEntity(NULL), m_vecPosition( 0, 0, 0 ) {}
+	MinimapInitData_t( C_BaseEntity *pEntity ) : m_pEntity(pEntity), m_vecPosition( 0, 0, 0 ) {}
+};
+
+#define DECLARE_MINIMAP_FACTORY( _PanelClass, _nameString )	\
+	DECLARE_PANEL_FACTORY( _PanelClass, MinimapInitData_t, _nameString )
+
+
+//-----------------------------------------------------------------------------
+// Macros for help with simple registration of minimap
+// Put DECLARE_MINIMAP_PANEL() in your class definition
+// and CONSTRUCT_MINIMAP_PANEL( "panelname", SORT_ORDER ) in your class constructor
+//-----------------------------------------------------------------------------
+#define DECLARE_MINIMAP_PANEL( )	DECLARE_METACLASS_PANEL( m_MinimapTrace )
+#define CONSTRUCT_MINIMAP_PANEL( _name, _sortorder )	\
+	MinimapInitData_t _traceInit( this );				\
+	CONSTRUCT_METACLASS_PANEL( m_MinimapTrace, _name, CMinimapPanel::MinimapRootPanel(), _sortorder, &_traceInit )
+#define DESTRUCT_MINIMAP_PANEL( )		\
+	DESTRUCT_METACLASS_PANEL( m_MinimapTrace )
+#define IS_MINIMAP_PANEL_DEFINED( )	( m_MinimapTrace.GetPanel() != NULL )
+
+// Kind of a hack; assumes all minimap panels inherit from CMinimapTracePanel, but that's reasonable..
+#define SET_MINIMAP_PANEL_VISIBILITY( _visible )		\
+	do													\
+	{													\
+		if (m_MinimapTrace.GetPanel())					\
+		{												\
+			static_cast<CMinimapTracePanel*>(m_MinimapTrace.GetPanel())->SetTraceVisibility( _visible );	\
+		}												\
+	} while (0)
+
+#endif // HUD_MINIMAP_H
\ No newline at end of file
diff --git a/game/client/tf2/hud_numeric.cpp b/game/client/tf2/hud_numeric.cpp
new file mode 100644
index 0000000..3d2937c
--- /dev/null
+++ b/game/client/tf2/hud_numeric.cpp
@@ -0,0 +1,978 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "hud_numeric.h"
+#include "iclientmode.h"
+#include <KeyValues.h>
+#include <vgui/ISurface.h>
+#include <vgui/IScheme.h>
+#include <vgui_controls/AnimationController.h>
+#include "ctype.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+using namespace vgui;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pElementName - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHudNumeric::CHudNumeric( const char *pElementName, const char *panelName )
+ : CHudElement( pElementName ), BaseClass( NULL, panelName )
+{
+	// Make sure we have the lookups built
+	BuildPrintablesList();
+
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetActive( true );
+	SetAutoDelete( false );
+
+	m_nTextLen = 0;
+	Q_memset( m_szPreviousValue, 0, sizeof( m_szPreviousValue ) );
+	Q_memset( m_szLatchedValue, 0, sizeof( m_szLatchedValue ) );
+
+	m_bDrawLabel = true;
+	m_bSendPulses = true;
+	m_bPulseForced = true;
+
+	m_flRotaryTime = 0.0f;
+	m_flRotaryStartTime = 0.0f;
+	m_flActualCharactersPerSecond = 7.0f;
+}
+
+bool CHudNumeric::s_bPrintablesBuilt;
+CUtlRBTree< int, int > CHudNumeric::m_Printables( 0, 0, DefLessFunc( int ) );
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a list of printable characters
+//-----------------------------------------------------------------------------
+void CHudNumeric::BuildPrintablesList( void )
+{
+	if ( s_bPrintablesBuilt )
+		return;
+
+	s_bPrintablesBuilt = true;
+	int i;
+	for ( i = 0; i < 256; i++ )
+	{
+		if ( isalnum( i ) )  // isprint or isgraph?
+		{
+			m_Printables.Insert( i );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find the index of a printable character
+// Input  : ch - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CHudNumeric::FindPrintableIndex( int ch )
+{
+	int idx = m_Printables.Find( ch );
+	return idx;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *scheme - 
+//-----------------------------------------------------------------------------
+void CHudNumeric::ApplySchemeSettings(IScheme *scheme)
+{
+	BaseClass::ApplySchemeSettings(scheme);
+
+	m_flActualCharactersPerSecond = (float)m_flDesiredCharactersPerSecond;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CHudNumeric::IsRotating( void ) const
+{
+	if ( gpGlobals->curtime >= m_flRotaryStartTime &&
+		 gpGlobals->curtime <= ( m_flRotaryStartTime + m_flRotaryTime ) )
+	{
+		 return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : frac - 
+//			startchar - 
+//			endchar - 
+//			prevchar - 
+//			nextchar - 
+//			subfrac - 
+//-----------------------------------------------------------------------------
+void CHudNumeric::GetRotatedChar( float frac, char startchar, char endchar, char& prevchar, char& nextchar, float& subfrac )
+{
+	// Recast into database of printable characters
+	int startidx	= FindPrintableIndex( startchar );
+	int endidx		= FindPrintableIndex( endchar );
+
+	float diff		= ( float )endidx - ( float )startidx;
+
+	// No delta
+	if ( diff == 0.0f || 
+		startidx == m_Printables.InvalidIndex() ||
+		endidx == m_Printables.InvalidIndex() )
+	{
+		prevchar	= startchar;
+		nextchar	= startchar;
+		subfrac		= 0.0f;
+
+		return;
+	}
+
+	bool reverse = false;
+	// Going backwards is same as forward except frac is reversed
+	if ( diff < 0.0f )
+	{
+		reverse = true;
+		frac = 1.0f - frac;
+		int temp = startidx;
+		startidx = endidx;
+		endidx = temp;
+		diff = -diff;
+	}
+
+	float	foutindex = (float)startidx;
+	int		outindex;
+	float   fnextindex;
+	int		nextindex;
+
+	int		maxdelta = (int)diff;
+
+	if ( m_nRotaryMaxDelta != 0 )
+	{
+		maxdelta = MIN( m_nRotaryMaxDelta, maxdelta );
+	}
+
+	// Quantize steps
+	// Map frac into maxdelta discrete intervals
+	float indicesperstep = diff / (float)maxdelta;
+	float fnumstepstaken = clamp( frac * (float)maxdelta, 0.0f, (float)( maxdelta  -0.001f ) );
+	int numstepstaken = (int)(fnumstepstaken);
+
+	foutindex = (float)startidx + (float)numstepstaken * indicesperstep;
+	foutindex = clamp( foutindex, (float)startidx, (float)endidx );
+
+	outindex	= ( int )foutindex;
+
+	fnextindex = (float)startidx + (float)( numstepstaken + 1 ) * indicesperstep;
+	fnextindex = clamp( fnextindex, (float)startidx, (float)endidx );
+
+	nextindex = (int)fnextindex;
+
+	subfrac = fnumstepstaken - (float)numstepstaken;
+
+	if ( !m_Printables.IsValidIndex( outindex ) ||
+		 !m_Printables.IsValidIndex( nextindex ) )
+	{
+		prevchar	= startchar;
+		nextchar	= startchar;
+		subfrac		= 0.0f;
+		return;
+	}
+
+	if ( reverse )
+	{
+		subfrac = 1.0f - subfrac;
+		prevchar	= m_Printables[ nextindex ];
+		nextchar	= m_Printables[ outindex ];
+	}
+	else
+	{
+		prevchar	= m_Printables[ outindex ];
+		nextchar	= m_Printables[ nextindex ];
+	}
+}	
+
+void CHudNumeric::PaintRotatedCharacterHoriz( int x, int y, vgui::HFont& font, int prevchar, int nextchar, float frac )
+{
+	frac = 3 * frac * frac - 2 * frac * frac * frac;
+
+	int abcA, abcB, abcC;
+	surface()->GetCharABCwide( font, prevchar, abcA, abcB, abcC );
+	// int fontTall = surface()->GetFontTall( font );
+
+	CharRenderInfo info;
+	if ( frac < 0.5f )
+	{
+		surface()->DrawSetTextPos( x, y );
+
+		// Paint the right half of the prevchar still
+		if ( surface()->DrawGetUnicodeCharRenderInfo( prevchar, info ) )
+		{
+			// Shift tex coord and y position half way down glyph
+			info.verts[0].m_Position.x = Lerp( 0.5f, info.verts[0].m_Position.x, info.verts[1].m_Position.x );
+			info.verts[0].m_TexCoord.x = Lerp( 0.5f, info.verts[0].m_TexCoord.x, info.verts[1].m_TexCoord.x );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		surface()->DrawSetTextPos( x, y );
+
+		// Paint up to frac from left of next char
+		if ( surface()->DrawGetUnicodeCharRenderInfo( nextchar, info ) )
+		{
+			// Shift tex coord and y position part way up glyph
+			info.verts[1].m_Position.x = Lerp( frac, info.verts[0].m_Position.x, info.verts[1].m_Position.x );
+			info.verts[1].m_TexCoord.x = Lerp( frac, info.verts[0].m_TexCoord.x, info.verts[1].m_TexCoord.x );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		// Paint divider
+
+		surface()->DrawSetTextPos( x, y );
+
+		// Paint from frac to 0.5 of prevchar on the left
+		if ( surface()->DrawGetUnicodeCharRenderInfo( prevchar, info )  )
+		{
+			// Shift tex coord and y position half way up glyph
+			vgui::Vertex_t save[2];
+			
+			save[0] = info.verts[0];
+			save[1] = info.verts[1];
+
+			info.verts[0].m_Position.x = Lerp( frac, save[0].m_Position.x, save[1].m_Position.x );
+			//info.verts[0].m_TexCoord.x = Lerp( frac, save[0].m_TexCoord.x, save[1].m_TexCoord.x );
+
+			info.verts[1].m_Position.x = Lerp( 0.5f, save[0].m_Position.x, save[1].m_Position.x );
+			info.verts[1].m_TexCoord.x = Lerp( 0.5f, save[0].m_TexCoord.x, save[1].m_TexCoord.x );
+			
+			surface()->DrawRenderCharFromInfo( info );
+		}
+	}
+	else if ( frac > 0.5f )
+	{
+		surface()->DrawSetTextPos( x, y );
+
+		// Paint entire left half of next char
+		if ( surface()->DrawGetUnicodeCharRenderInfo( nextchar, info ) )
+		{
+			// Shift tex coord and y position half way down glyph
+			info.verts[1].m_Position.x = Lerp( 0.5f, info.verts[0].m_Position.x, info.verts[1].m_Position.x );
+			info.verts[1].m_TexCoord.x = Lerp( 0.5f, info.verts[0].m_TexCoord.x, info.verts[1].m_TexCoord.x );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		surface()->DrawSetTextPos( x, y );
+
+		// paint a bit of the previous char at far right
+		if ( surface()->DrawGetUnicodeCharRenderInfo( prevchar, info ) )
+		{
+			// Shift tex coord and y position part way up glyph
+			info.verts[0].m_Position.x = Lerp( frac, info.verts[0].m_Position.x, info.verts[1].m_Position.x );
+			info.verts[0].m_TexCoord.x = Lerp( frac, info.verts[0].m_TexCoord.x, info.verts[1].m_TexCoord.x );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		// Paint divider
+
+		surface()->DrawSetTextPos( x, y );
+
+		// Paint from 0.5 to frac of next char
+		if ( surface()->DrawGetUnicodeCharRenderInfo( nextchar, info ) )
+		{
+			vgui::Vertex_t save[2];
+			
+			save[0] = info.verts[0];
+			save[1] = info.verts[1];
+
+			info.verts[0].m_Position.x = Lerp( 0.5f, save[0].m_Position.x, save[1].m_Position.x );
+			info.verts[0].m_TexCoord.x = Lerp( 0.5f, save[0].m_TexCoord.x, save[1].m_TexCoord.x );
+
+			info.verts[1].m_Position.x = Lerp( frac, save[0].m_Position.x, save[1].m_Position.x );
+			//info.verts[1].m_TexCoord.x = Lerp( frac, save[0].m_TexCoord.x, save[1].m_TexCoord.x );
+			
+			surface()->DrawRenderCharFromInfo( info );
+		}
+	}
+
+	x += ( abcA + abcB + abcC );
+	surface()->DrawSetTextPos( x, y );
+}
+
+void CHudNumeric::PaintRotatedCharacterSpeedomter( int x, int y, vgui::HFont& font, int prevchar, int nextchar, float frac )
+{
+	frac = 3 * frac * frac - 2 * frac * frac * frac;
+
+	int abcA, abcB, abcC;
+	surface()->GetCharABCwide( font, prevchar, abcA, abcB, abcC );
+	// int fontTall = surface()->GetFontTall( font );
+
+	CharRenderInfo info;
+	if ( frac <= 0.0f )
+	{
+		surface()->DrawSetTextPos( x, y );
+
+		// Paint the whole previous char
+		if ( surface()->DrawGetUnicodeCharRenderInfo( prevchar, info ) )
+		{
+			surface()->DrawRenderCharFromInfo( info );
+		}
+	}
+	else if ( frac >= 1.0f )
+	{
+		surface()->DrawSetTextPos( x, y );
+
+		// Paint the whole previous char
+		if ( surface()->DrawGetUnicodeCharRenderInfo( nextchar, info ) )
+		{
+			surface()->DrawRenderCharFromInfo( info );
+		}
+	}
+	else
+	{
+		// Draw part of previous and part of next
+		surface()->DrawSetTextPos( x, y );
+
+		if ( surface()->DrawGetUnicodeCharRenderInfo( prevchar, info ) )
+		{
+			// Shift tex coord and y position part way up glyph
+			info.verts[1].m_Position.y = Lerp( frac, info.verts[0].m_Position.y, info.verts[1].m_Position.y );
+			info.verts[1].m_TexCoord.y = Lerp( frac, info.verts[0].m_TexCoord.y, info.verts[1].m_TexCoord.y );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		// Paint divider
+
+		surface()->DrawSetTextPos( x, y );
+
+		if ( surface()->DrawGetUnicodeCharRenderInfo( nextchar, info ) )
+		{
+			// Shift tex coord and y position part way up glyph
+			info.verts[0].m_Position.y = Lerp( frac, info.verts[0].m_Position.y, info.verts[1].m_Position.y );
+			info.verts[0].m_TexCoord.y = Lerp( frac, info.verts[0].m_TexCoord.y, info.verts[1].m_TexCoord.y );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+	}
+
+	x += ( abcA + abcB + abcC );
+	surface()->DrawSetTextPos( x, y );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//			font - 
+//			prevchar - 
+//			nextchar - 
+//			frac - 
+//-----------------------------------------------------------------------------
+void CHudNumeric::PaintRotatedCharacter( int x, int y, HFont& font, int prevchar, int nextchar, float frac )
+{
+	frac = SimpleSpline( frac );
+
+	int abcA[2], abcB[2], abcC[2];
+	surface()->GetCharABCwide( font, prevchar, abcA[0], abcB[0], abcC[0] );
+	surface()->GetCharABCwide( font, nextchar, abcA[1], abcB[1], abcC[1] );
+
+	int w0 = abcA[0] + abcB[0] + abcC[0];
+	int w1 = abcA[1] + abcB[1] + abcC[1];
+
+	int cellwidth = MAX( w0, w1 );
+
+	int fontTall = surface()->GetFontTall( font );
+
+	int dividery = y + clamp( Lerp( frac, 0, fontTall ), 2, fontTall - 2 );
+
+	int xprev = x;
+	int xnext = x;
+
+	int diff = abs( abcB[0] - abcB[1] ) * 0.5f;
+
+	if ( diff != 0 )
+	{
+		// Prev is wider than next, push next right a bit
+		if ( w0 > w1 )
+		{
+			xnext += diff;
+		}
+		else
+		{
+			xprev += diff;
+		}
+	}
+
+	CharRenderInfo info;
+	if ( frac < 0.5f )
+	{
+		surface()->DrawSetTextPos( xprev, y );
+
+		// Paint the bottom half of the prevchar still
+		if ( surface()->DrawGetUnicodeCharRenderInfo( prevchar, info ) )
+		{
+			// Shift tex coord and y position half way down glyph
+			info.verts[0].m_Position.y = Lerp( 0.5f, info.verts[0].m_Position.y, info.verts[1].m_Position.y );
+			info.verts[0].m_TexCoord.y = Lerp( 0.5f, info.verts[0].m_TexCoord.y, info.verts[1].m_TexCoord.y );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		surface()->DrawSetTextPos( xnext, y );
+
+		// Paint up to frac from top of prev char
+		if ( surface()->DrawGetUnicodeCharRenderInfo( nextchar, info ) )
+		{
+			// Shift tex coord and y position part way up glyph
+			info.verts[1].m_Position.y = Lerp( frac, info.verts[0].m_Position.y, info.verts[1].m_Position.y );
+			info.verts[1].m_TexCoord.y = Lerp( frac, info.verts[0].m_TexCoord.y, info.verts[1].m_TexCoord.y );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		// Paint divider
+		if ( frac > 0.0f )
+		{
+			surface()->DrawSetColor( m_CharBgBorder );
+			surface()->DrawLine( x - abcA[0] + 1, dividery, x + abcB[0] + abcC[0] - 1, dividery );
+		}
+
+		surface()->DrawSetTextPos( xprev, y );
+
+		// Paint from frac to 0.5 of nextchar on the top
+		if ( surface()->DrawGetUnicodeCharRenderInfo( prevchar, info )  )
+		{
+			// Shift tex coord and y position half way up glyph
+			vgui::Vertex_t save[2];
+			
+			save[0] = info.verts[0];
+			save[1] = info.verts[1];
+
+			info.verts[0].m_Position.y = Lerp( frac, save[0].m_Position.y, save[1].m_Position.y );
+			//info.verts[0].m_TexCoord.y = Lerp( frac, save[0].m_TexCoord.y, save[1].m_TexCoord.y );
+
+			info.verts[1].m_Position.y = Lerp( 0.5f, save[0].m_Position.y, save[1].m_Position.y );
+			info.verts[1].m_TexCoord.y = Lerp( 0.5f, save[0].m_TexCoord.y, save[1].m_TexCoord.y );
+			
+			surface()->DrawRenderCharFromInfo( info );
+		}
+	}
+	else if ( frac >= 0.5f )
+	{
+		surface()->DrawSetTextPos( xnext, y );
+
+		// Paint entire top half of next char
+		if ( surface()->DrawGetUnicodeCharRenderInfo( nextchar, info ) )
+		{
+			// Shift tex coord and y position half way down glyph
+			info.verts[1].m_Position.y = Lerp( 0.5f, info.verts[0].m_Position.y, info.verts[1].m_Position.y );
+			info.verts[1].m_TexCoord.y = Lerp( 0.5f, info.verts[0].m_TexCoord.y, info.verts[1].m_TexCoord.y );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		surface()->DrawSetTextPos( xprev, y );
+
+		// paint a bit of the previous char at the bottom
+		if ( surface()->DrawGetUnicodeCharRenderInfo( prevchar, info ) )
+		{
+			// Shift tex coord and y position part way up glyph
+			info.verts[0].m_Position.y = Lerp( frac, info.verts[0].m_Position.y, info.verts[1].m_Position.y );
+			info.verts[0].m_TexCoord.y = Lerp( frac, info.verts[0].m_TexCoord.y, info.verts[1].m_TexCoord.y );
+			surface()->DrawRenderCharFromInfo( info );
+		}
+
+		// Paint divider
+		if ( frac < 1.0f )
+		{
+			surface()->DrawSetColor( m_CharBgBorder );
+			surface()->DrawLine( x - abcA[0] + 1, dividery, x + abcB[0] + abcC[0] - 1, dividery );
+		}
+
+		surface()->DrawSetTextPos( xnext, y );
+
+		// Paint from 0.5 to frac of next char
+		if ( surface()->DrawGetUnicodeCharRenderInfo( nextchar, info ) )
+		{
+			// Shift tex coord and y position half way up glyph
+			vgui::Vertex_t save[2];
+			
+			save[0] = info.verts[0];
+			save[1] = info.verts[1];
+
+			info.verts[0].m_Position.y = Lerp( 0.5f, save[0].m_Position.y, save[1].m_Position.y );
+			info.verts[0].m_TexCoord.y = Lerp( 0.5f, save[0].m_TexCoord.y, save[1].m_TexCoord.y );
+
+			info.verts[1].m_Position.y = Lerp( frac, save[0].m_Position.y, save[1].m_Position.y );
+			//info.verts[1].m_TexCoord.y = Lerp( frac, save[0].m_TexCoord.y, save[1].m_TexCoord.y );
+			
+			surface()->DrawRenderCharFromInfo( info );
+		}
+	}
+
+	x += cellwidth;
+	surface()->DrawSetTextPos( x, y );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *prev - 
+//			*next - 
+// Output : float
+//-----------------------------------------------------------------------------
+float CHudNumeric::MaxCharacterDiff( const char *prev, const char *next )
+{
+	float maxdiff = 0.0f;
+
+	int textlen = Q_strlen( next );
+	int prevlen = Q_strlen( prev );
+	int ch;
+	for ( ch = 0; ch < textlen; ch++ )
+	{
+		int charfromend = textlen - ch;
+		char c = next[ ch ];
+		char prevc = prev[ MAX( 0, prevlen - charfromend ) ];
+		if ( prevc == 0 )
+		{
+			int tempindex = FindPrintableIndex( c );
+			if ( tempindex != m_Printables.InvalidIndex() )
+			{
+				tempindex = MAX( 0, tempindex - 3 );
+				prevc = m_Printables[ tempindex ];
+			}
+			else
+			{
+				prevc = c;
+			}
+		}
+
+		float diff = (float)fabs( FindPrintableIndex( c ) - FindPrintableIndex( prevc ) );
+
+		if ( diff > maxdiff )
+		{
+			maxdiff = diff;
+		}
+	}
+
+	float maxdelta = maxdiff;
+
+	if ( m_nRotaryMaxDelta != 0 )
+	{
+		maxdelta = MIN( (float)m_nRotaryMaxDelta, maxdelta );
+	}
+
+	return maxdelta;
+}
+
+int CHudNumeric::ComputePixelsRequired( vgui::HFont& font, const char *text, int textlen )
+{
+	int pixels = 0;
+	for ( int ch = 0; ch < textlen; ch++ )
+	{
+		char c = text[ ch ];
+		pixels += surface()->GetCharacterWidth( font, c );
+	}
+	return pixels;
+}
+
+void CHudNumeric::DrawCharacterBackground( const char *text, int textlen, HFont& font, int x, int y )
+{
+	int abcA, abcB, abcC;
+	int fontTall = surface()->GetFontTall( font );
+
+	int ch;
+	int curx = x - ComputePixelsRequired( font, text, textlen );
+	for ( ch = 0; ch < textlen; ch++ )
+	{
+		char c = text[ ch ];
+
+		surface()->GetCharABCwide( font, c, abcA, abcB, abcC );
+
+		curx += abcA;
+
+		surface()->DrawSetColor( m_CharBg );
+		surface()->DrawFilledRect( curx - abcA, y + 2, curx + abcB + abcC, y + fontTall - 2 );
+
+		if ( m_bDrawCharacterBackgroundBorder )
+		{
+			surface()->DrawSetColor( m_CharBgBorder );
+			surface()->DrawOutlinedRect( curx - abcA, y + 2, curx + abcB + abcC, y + fontTall - 2  );
+		}
+
+		curx += ( abcB + abcC );
+	}
+}
+
+void CHudNumeric::DrawCharacterForeground( const char *text, int textlen, HFont& font, int x, int y )
+{
+	if ( m_nRotaryEffect == ROTARY_EFFECT_NONE ||
+		m_nRotaryEffect == ROTARY_EFFECT_SPEEDOMETER )	
+		return;
+
+	int abcA, abcB, abcC;
+	int fontTall = surface()->GetFontTall( font );
+
+	int ch;
+	int curx = x - ComputePixelsRequired( font, text, textlen );
+	for ( ch = 0; ch < textlen; ch++ )
+	{
+		char c = text[ ch ];
+
+		surface()->GetCharABCwide( font, c, abcA, abcB, abcC );
+
+		curx += abcA;
+
+		switch ( m_nRotaryEffect )
+		{
+		default:
+		case ROTARY_EFFECT_VERTICAL_ALARM:
+			{
+				surface()->DrawSetColor( m_CharFg );
+				surface()->DrawLine( curx - abcA + 1, y + fontTall / 2, curx + abcB + abcC - 1, y + fontTall / 2 );
+			}
+			break;
+		case ROTARY_EFFECT_HORIZONTAL_ALARM:
+			{
+				surface()->DrawSetColor( m_CharFg );
+				int avex = curx + ( - abcA + abcB + abcC ) / 2;
+				surface()->DrawLine( avex, y + 2, avex, y + fontTall - 2 );
+			}
+			break;
+		}
+
+		curx += ( abcB + abcC );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *text - 
+//			textlen - 
+//			font - 
+//			x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CHudNumeric::PaintStringRotary( float t, const char *text, int textlen, HFont& font, int x, int y )
+{
+	surface()->DrawSetTextFont( font );
+	int ch;
+
+	int prevlen = Q_strlen( m_szLatchedValue );
+
+	// Compute pixels actually required
+	int pixels = 0;
+
+	for ( ch = 0; ch < textlen; ch++ )
+	{
+		int charfromend = textlen - ch;
+		char c = text[ ch ];
+		char prevc = m_szLatchedValue[ MAX( 0, prevlen - charfromend ) ];
+		if ( prevc == 0 )
+		{
+			int tempindex = FindPrintableIndex( c );
+			if ( tempindex != m_Printables.InvalidIndex() )
+			{
+				tempindex = MAX( 0, tempindex - 3 );
+				prevc = m_Printables[ tempindex ];
+			}
+			else
+			{
+				prevc = c;
+			}
+		}
+
+		float diff = (float)fabs( FindPrintableIndex( c ) - FindPrintableIndex( prevc ) );
+
+		if ( m_nRotaryMaxDelta != 0 )
+		{
+			diff = MIN( (float)m_nRotaryMaxDelta, diff );
+		}
+
+		float dt = diff / m_flActualCharactersPerSecond;
+
+		float frac = 1.0f;
+		if ( dt > 0.0f )
+		{
+			frac = t / MIN( dt, m_flRotaryTime );
+		}
+		frac = clamp( frac, 0.0f, 1.0f );
+
+		float s;
+		char chstart, chend;
+		GetRotatedChar( frac, prevc, c, chstart, chend, s );
+
+		int w0 = surface()->GetCharacterWidth( font, chstart );
+		int w1 = surface()->GetCharacterWidth( font, chend );
+
+		pixels += MAX( w0, w1 );
+	}
+
+	surface()->DrawSetTextPos( x - pixels, y );
+
+	// Now render
+	for ( ch = 0; ch < textlen; ch++ )
+	{
+		int charfromend = textlen - ch;
+		char c = text[ ch ];
+		char prevc = m_szLatchedValue[ MAX( 0, prevlen - charfromend ) ];
+		if ( prevc == 0 )
+		{
+			int tempindex = FindPrintableIndex( c );
+			if ( tempindex != m_Printables.InvalidIndex() )
+			{
+				tempindex = MAX( 0, tempindex - 3 );
+				prevc = m_Printables[ tempindex ];
+			}
+			else
+			{
+				prevc = c;
+			}
+		}
+
+		float diff = (float)fabs( FindPrintableIndex( c ) - FindPrintableIndex( prevc ) );
+
+		if ( m_nRotaryMaxDelta != 0 )
+		{
+			diff = MIN( (float)m_nRotaryMaxDelta, diff );
+		}
+
+		float dt = diff / m_flActualCharactersPerSecond;
+
+		float frac = 1.0f;
+		if ( dt > 0.0f )
+		{
+			frac = t / MIN( dt, m_flRotaryTime );
+		}
+		frac = clamp( frac, 0.0f, 1.0f );
+
+		float s;
+		char chstart, chend;
+		GetRotatedChar( frac, prevc, c, chstart, chend, s );
+		int outx, outy;
+		surface()->DrawGetTextPos( outx, outy );
+		switch ( m_nRotaryEffect )
+		{
+		default:
+		case ROTARY_EFFECT_VERTICAL_ALARM:
+			{
+				PaintRotatedCharacter( outx, outy, font, chstart, chend, s );
+			}
+			break;
+		case ROTARY_EFFECT_HORIZONTAL_ALARM:
+			{
+				PaintRotatedCharacterHoriz( outx, outy, font, chstart, chend, s );
+			}
+			break;
+		case ROTARY_EFFECT_SPEEDOMETER:
+			{
+				PaintRotatedCharacterSpeedomter( outx, outy, font, chstart, chend, s );
+			}
+			break;
+		}
+
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *text - 
+//			textlen - 
+//			font - 
+//			x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CHudNumeric::PaintString( const char *text, int textlen, HFont& font, int x, int y )
+{
+	if ( m_nRotaryEffect != ROTARY_EFFECT_NONE && 
+		IsRotating() && 
+		m_flRotaryTime > 0.0f )
+	{
+		float rotation_time = gpGlobals->curtime - m_flRotaryStartTime;
+
+		PaintStringRotary( rotation_time, text, textlen, font, x, y );
+		
+		return;
+	}
+	PaintStringNormal( text, textlen, font, x, y );
+}
+
+void CHudNumeric::PaintStringNormal( const char *text, int textlen, vgui::HFont& font, int x, int y )
+{
+	surface()->DrawSetTextFont( font );
+	int ch;
+	surface()->DrawSetTextPos( x - ComputePixelsRequired( font, text, textlen ), y );
+
+	for ( ch = 0; ch < textlen; ch++ )
+	{
+		char c = text[ ch ];
+		surface()->DrawUnicodeChar( c );
+	}
+}
+
+void CHudNumeric::PaintBackground( void )
+{
+	char value[ MAX_VALUE_LENGTH ];
+
+	if ( !GetValue( value, sizeof( value ) ) )
+		return;
+
+	float alpha = m_flAlphaOverride / 255.0f;
+
+	Color boxColor = GetBoxColor();
+	boxColor[3] *= alpha;
+
+	SetBgColor( boxColor );
+
+	BaseClass::PaintBackground();
+
+	if ( !m_bUseIcon )
+		return;
+
+	CHudTexture *tex = m_hIcon;
+	if ( !tex )
+		return;
+
+	Color iconColor = m_IconColor;
+	iconColor[3] *= alpha;
+
+	tex->DrawSelf( m_flIconXPos, m_flIconYPos, m_flIconWidth, m_flIconHeight, iconColor );
+}
+
+void CHudNumeric::PaintValue( const char *value, int textlen, int wide, int tall, Color& clr )
+{
+	float alpha = m_flAlphaOverride / 255.0f;
+
+	Color boxColor = GetBoxColor();
+	boxColor[3] *= alpha;
+
+	SetBgColor( boxColor );
+
+	Color useColor = clr;
+	useColor[3] *= alpha;
+
+	surface()->DrawSetTextColor( useColor );
+
+	int x = wide - label_xpos_right;
+	int y = label_ypos;
+
+	if ( m_bDrawLabel ) 
+	{
+		// Label
+		PaintStringNormal( GetLabelText(), Q_strlen( GetLabelText() ), m_hLabelFont, x, y );
+	}
+
+	x = wide - value_xpos_right;
+	y = value_ypos;
+
+	if ( m_nRotaryEffect != ROTARY_EFFECT_NONE && 
+		(bool)m_bDrawCharacterBackground )
+	{
+		DrawCharacterBackground( value, textlen, m_hTextFont, x, y );
+	}
+
+	PaintString( value, textlen, m_hTextFont, x, y );
+
+	if ( m_nRotaryEffect != ROTARY_EFFECT_NONE && 
+		(bool)m_bDrawCharacterForeground )
+	{
+		DrawCharacterForeground( value, textlen, m_hTextFont, x, y );
+	}
+
+	// draw the overbright blur
+	for (float fl = m_flBlur; fl > 0.0f; fl -= 1.0f)
+	{
+		if (fl >= 1.0f)
+		{
+			PaintString( value, textlen, m_hTextFontPulsing, x, y );
+		}
+		else
+		{
+			// draw a percentage of the last one
+			Color col = useColor;
+			col[3] *= fl;
+			surface()->DrawSetTextColor(col);
+			PaintString( value, textlen, m_hTextFontPulsing, x, y );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : vgui::Color
+//-----------------------------------------------------------------------------
+Color CHudNumeric::GetColor()
+{
+	return m_TextColor;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : vgui::Color
+//-----------------------------------------------------------------------------
+Color CHudNumeric::GetBoxColor()
+{
+	return m_BoxColor;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Redraw
+//-----------------------------------------------------------------------------
+void CHudNumeric::Paint( void )
+{
+	char value[ MAX_VALUE_LENGTH ];
+
+	if ( !GetValue( value, sizeof( value ) ) )
+		return;
+
+	int w, h;
+	GetSize( w, h );
+
+	bool dopulse = ( Q_strcmp( value, m_szPreviousValue ) != 0 ) || ( m_bPulseForced );
+	bool increment = false;
+	if ( dopulse )
+	{
+		if ( atof( m_szPreviousValue ) <= atof( value ) )
+		{
+			increment = true;
+		}
+
+		Q_strncpy( m_szLatchedValue, m_szPreviousValue, sizeof( m_szLatchedValue ) );
+		m_nTextLen = Q_strlen( value );
+		
+		m_flRotaryStartTime = gpGlobals->curtime;
+		float maxdiff = MaxCharacterDiff( m_szLatchedValue, value );
+		float timerequired = maxdiff / m_flDesiredCharactersPerSecond;
+		m_flActualCharactersPerSecond = (float)m_flDesiredCharactersPerSecond;
+		m_flRotaryTime = MIN( m_flRotaryTimeMax, timerequired );
+		if ( m_flRotaryTime < timerequired )
+		{
+			// Speed up rotation since we're moving so far
+			m_flActualCharactersPerSecond =  ( timerequired / m_flRotaryTime ) * m_flDesiredCharactersPerSecond;
+		}
+	}
+
+	Q_strncpy( m_szPreviousValue, value, sizeof( m_szPreviousValue ) );
+
+	Color clr = GetColor();
+	PaintValue( value, m_nTextLen, w, h, clr );
+
+	if ( dopulse && m_bSendPulses )
+	{
+		// Start with a short pulse
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( GetPulseEvent( increment ) );
+
+		m_bPulseForced = false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Derived class has forced a pulse
+//-----------------------------------------------------------------------------
+void CHudNumeric::ForcePulse( void )
+{
+	m_bPulseForced = true;
+}
diff --git a/game/client/tf2/hud_numeric.h b/game/client/tf2/hud_numeric.h
new file mode 100644
index 0000000..20db7f5
--- /dev/null
+++ b/game/client/tf2/hud_numeric.h
@@ -0,0 +1,140 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HUD_NUMERIC_H
+#define HUD_NUMERIC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "hudelement.h"
+#include <vgui_controls/Panel.h>
+
+class CHudNumeric : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudNumeric, vgui::Panel );
+
+public:
+
+	CHudNumeric( const char *pElementName, const char *panelName );
+
+	void		SetDrawLabel( bool draw ) { m_bDrawLabel = draw; }
+	void		SetDoPulses( bool dopulses ) { m_bSendPulses = dopulses; }
+	void		ForcePulse( void );
+
+	void		SetRotaryEffect( int rotary ) { m_nRotaryEffect = rotary; }
+	void		SetRotaryTimeMax( float maxTime ) { m_flRotaryTimeMax = maxTime; }
+	void		SetRotaryCharsPerSecond( float cps ) { m_flDesiredCharactersPerSecond = cps; }
+
+	// vgui::Panel overrides.
+	virtual void Paint( void );
+	virtual void PaintBackground( void );
+
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+
+	virtual const char *GetLabelText() = 0;
+	virtual const char *GetPulseEvent( bool increment ) = 0;
+	virtual bool		GetValue( char *val, int maxlen ) = 0;
+
+	virtual Color		GetColor();
+	virtual Color		GetBoxColor();
+
+	static void			BuildPrintablesList( void );
+	static int			FindPrintableIndex( int ch );
+
+protected:
+	enum
+	{
+		ROTARY_EFFECT_NONE = 0,
+		ROTARY_EFFECT_VERTICAL_ALARM,
+		ROTARY_EFFECT_HORIZONTAL_ALARM,
+		ROTARY_EFFECT_SPEEDOMETER
+	};
+
+	enum
+	{
+		MAX_VALUE_LENGTH = 128,
+	};
+
+	void		PaintValue( const char *value, int textlen, int wide, int tall, Color& clr );
+	void		PaintString( const char *text, int textlen, vgui::HFont& font, int x, int y );
+	void		PaintStringNormal( const char *text, int textlen, vgui::HFont& font, int x, int y );
+
+	void		PaintStringRotary( float t, const char *text, int textlen, vgui::HFont& font, int x, int y );
+
+	void		GetRotatedChar( float frac, char startchar, char endchar, 
+					char& prevchar, char& nextchar, float& subfrac );
+	void		PaintRotatedCharacter( int x, int y, vgui::HFont& font, int prevchar, int nextchar, float frac );
+	void		PaintRotatedCharacterHoriz( int x, int y, vgui::HFont& font, int prevchar, int nextchar, float frac );
+	void		PaintRotatedCharacterSpeedomter( int x, int y, vgui::HFont& font, int prevchar, int nextchar, float frac );
+
+	bool		IsRotating( void ) const;
+
+	float		MaxCharacterDiff( const char *prev, const char *next );
+	void		DrawCharacterBackground( const char *text, int textlen, vgui::HFont& font, int x, int y );
+	void		DrawCharacterForeground( const char *text, int textlen, vgui::HFont& font, int x, int y );
+
+	int			ComputePixelsRequired( vgui::HFont& font, const char *text, int textlen );
+
+	int			m_nTextLen;
+	char		m_szPreviousValue[ MAX_VALUE_LENGTH ];
+	char		m_szLatchedValue[ MAX_VALUE_LENGTH ];
+
+	bool		m_bDrawLabel;
+	bool		m_bSendPulses;
+	bool		m_bPulseForced;
+
+	float		m_flRotaryTime;
+	float		m_flRotaryStartTime;
+	float		m_flActualCharactersPerSecond;
+
+	static CUtlRBTree< int, int > m_Printables;
+	static bool			s_bPrintablesBuilt;
+
+	CPanelAnimationVar( int, m_nRotaryEffect, "Rotary", "0" );
+	CPanelAnimationVar( int, m_nRotaryMaxDelta, "RotaryMaxDelta", "0" );
+	CPanelAnimationVar( float, m_flRotaryTimeMax, "RotaryMaxTime", "2.0" );
+	CPanelAnimationVar( float, m_flDesiredCharactersPerSecond, "RotarySpeed", "7.0" );
+
+	CPanelAnimationVar( bool, m_bDrawCharacterBackground, "DrawCharacterBackground", "false" );
+	CPanelAnimationVar( bool, m_bDrawCharacterForeground, "DrawCharacterForeground", "false" );
+	CPanelAnimationVar( bool, m_bDrawCharacterBackgroundBorder, "DrawCharacterBackgroundBorder", "false" );
+
+	CPanelAnimationVar( float, m_flBlur, "Blur", "0" );
+	CPanelAnimationVar( float, m_flAlphaOverride, "Alpha", "255" );
+
+	CPanelAnimationVar( Color, m_TextColor, "TextColor", "NumericText" );
+	CPanelAnimationVar( Color, m_TextColorWarning, "TextColorWarning", "NumericTextWarning" );
+	CPanelAnimationVar( Color, m_TextColorCritical, "TextColorCritical", "NumericTextCritical" );
+
+	CPanelAnimationVar( Color, m_BoxColor, "BoxColor", "NumericBox" );
+	CPanelAnimationVar( Color, m_BoxColorWarning, "BoxColorWarning", "NumericBoxWarning" );
+	CPanelAnimationVar( Color, m_BoxColorCritical, "BoxColorCritical", "NumericBoxCritical" );
+
+	CPanelAnimationVar( Color, m_CharBg, "CharBackground", "NumericCharBg" );
+	CPanelAnimationVar( Color, m_CharBgBorder, "CharBackgroundBorder", "NumericCharBgBorder" );
+	CPanelAnimationVar( Color, m_CharFg, "CharForeground", "NumericCharFg" );
+	
+	CPanelAnimationVar( vgui::HFont, m_hLabelFont, "LabelFont", "HudNumbersLabelFont" );
+	CPanelAnimationVar( vgui::HFont, m_hTextFont, "TextFont", "HudNumbersSmall" );
+	CPanelAnimationVar( vgui::HFont, m_hTextFontPulsing, "TextFontPulsing", "HudNumbersSmallGlow" );
+
+	CPanelAnimationVarAliasType( float, label_ypos, "label_ypos", "2", "proportional_float" );
+	CPanelAnimationVarAliasType( float, label_xpos_right, "label_xpos_right", "5", "proportional_float" );
+	CPanelAnimationVarAliasType( float, value_ypos, "value_ypos", "12", "proportional_float" );
+	CPanelAnimationVarAliasType( float, value_xpos_right, "value_xpos_right", "5", "proportional_float" );
+
+	CPanelAnimationVar( bool, m_bUseIcon, "UseIcon", "false" );
+	CPanelAnimationVarAliasType( float, m_flIconWidth, "IconWidth", "60", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flIconHeight, "IconHeight", "30", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flIconXPos, "IconXPos", "10", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flIconYPos, "IconYPos", "4", "proportional_float" );
+	CPanelAnimationVar( CHudTextureHandle, m_hIcon, "IconTexture", "" );
+	CPanelAnimationVar( Color, m_IconColor, "IconColor", "NumericText" );
+};
+
+#endif // HUD_NUMERIC_H
diff --git a/game/client/tf2/hud_orders.cpp b/game/client/tf2/hud_orders.cpp
new file mode 100644
index 0000000..30f2ec3
--- /dev/null
+++ b/game/client/tf2/hud_orders.cpp
@@ -0,0 +1,278 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Order window
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud_orders.h"
+#include "hud.h"
+#include "c_basetfplayer.h"
+#include "clientmode_tfnormal.h"
+#include "VGUI_BasePanel.h"
+#include <vgui/IScheme.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudLabel::SetSelected( bool bSelected )
+{
+	m_bSelected = bSelected;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudOrderList *GetHudOrderList( void )
+{
+	return GET_HUDELEMENT( CHudOrderList );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudOrder::CHudOrder( int x,int y,int wide,int tall ) : vgui::Panel( NULL, "CHudOrder")
+{
+	SetBounds( x, y, wide, tall );
+	SetAutoDelete( false );
+	m_pOrder = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudOrder::~CHudOrder( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudOrder::Init( void )
+{
+	SetSize( ORDERS_ELEMENT_WIDTH, ORDERS_ELEMENT_HEIGHT );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called every frame
+//-----------------------------------------------------------------------------
+void CHudOrder::Paint( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudOrder::SetOrder( C_Order *pOrder )
+{
+	// If we had an order, tell it to clean up
+	if ( m_pOrder )
+	{
+		m_pOrder->DestroyStatus();
+	}
+
+	m_pOrder = pOrder;
+
+	// Tell the order to create it's elements
+	if ( m_pOrder )
+	{
+		m_pOrder->CreateStatus( this );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_Order *CHudOrder::GetOrder( void )
+{
+	return m_pOrder;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudOrder::UpdateOrder( void )
+{
+	if ( m_pOrder == NULL )
+		return;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Our order has been deleted.
+//-----------------------------------------------------------------------------
+void CHudOrder::OrderRemoved( void )
+{
+	m_pOrder = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudOrder::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	Panel::ApplySchemeSettings(pScheme);
+
+	if ( m_pOrder && m_pOrder->IsPersonalOrder() )
+	{
+		SetBgColor( GetSchemeColor("HudStatusSelectedBgColor", pScheme) );
+	}
+	else
+	{
+		SetBgColor( GetSchemeColor("HudStatusBgColor", pScheme) );
+	}
+}
+
+//================================================================================================================
+// LARGE STATUS PANEL.
+//================================================================================================================
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudOrderList::CHudOrderList( const char *pElementName ) :
+	CHudElement( pElementName ), vgui::Panel( NULL, "HudOrderList" )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	SetPaintBackgroundEnabled( false );
+	for (int i = 0; i < MAX_HUD_ORDERS; i++)
+	{
+		m_pOrderPanels[i] = NULL;
+		m_pOrderLabels[i] = NULL;
+	}
+
+	SetHiddenBits( HIDEHUD_MISCSTATUS | HIDEHUD_PLAYERDEAD );
+}
+
+DECLARE_HUDELEMENT( CHudOrderList );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudOrderList::~CHudOrderList( void )
+{
+	for (int i = 0; i < MAX_HUD_ORDERS; i++)
+	{
+		if ( m_pOrderPanels[i] )
+		{
+			delete m_pOrderPanels[i];
+			delete m_pOrderLabels[i];
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudOrderList::LevelInit( void )
+{
+	SetPos( ORDERS_LEFT, ORDERS_TOP );
+	SetSize( ORDERS_WIDTH, ORDERS_HEIGHT );
+
+	for ( int i = 0; i < MAX_HUD_ORDERS; i++ )
+	{
+		m_pOrderPanels[i] = new CHudOrder( ORDERS_ELEMENT_LEFT - ORDERS_LEFT, ORDERS_ELEMENT_HEIGHT * i, ORDERS_ELEMENT_WIDTH, ORDERS_ELEMENT_HEIGHT );
+		m_pOrderPanels[i]->Init();
+
+		m_pOrderLabels[i] = new CHudLabel( NULL, "orderlabels", " " );
+		m_pOrderLabels[i]->SetBounds( 0, ORDERS_ELEMENT_HEIGHT * i, ORDERS_ELEMENT_LEFT - ORDERS_LEFT, ORDERS_ELEMENT_HEIGHT );
+		m_pOrderLabels[i]->SetContentAlignment( vgui::Label::a_northwest );
+		m_pOrderLabels[i]->SetTextInset( 4, 0 );
+
+		// Start all of them hidden
+		m_pOrderPanels[i]->SetParent( (vgui::Panel *)NULL );
+		m_pOrderLabels[i]->SetParent( (vgui::Panel *)NULL );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudOrderList::LevelShutdown( void )
+{
+	for ( int i = 0; i < MAX_HUD_ORDERS; i++ )
+	{
+		delete m_pOrderPanels[i];
+		m_pOrderPanels[i] = NULL;
+		delete m_pOrderLabels[i];
+		m_pOrderLabels[i] = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudOrderList::OnThink( void )
+{
+	// Call update for all active objects
+	for (int i = 0; i < MAX_HUD_ORDERS; i++)
+	{
+		if ( m_pOrderPanels[i] && m_pOrderPanels[i]->GetOrder() )
+		{
+			m_pOrderPanels[i]->UpdateOrder();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudOrderList::Paint( void )
+{
+//	vgui::surface()->DrawSetColor( 255,0,0, 64 );
+//	vgui::surface()->DrawOutlinedRect( 0,0, GetWide(), GetTall() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Insert the specified order into the slot
+//-----------------------------------------------------------------------------
+void CHudOrderList::InsertOrder( C_Order *pOrder, int iSlot )
+{
+	// Personal Orders don't have selection keys
+	if ( pOrder->IsPersonalOrder() )
+	{
+		m_pOrderLabels[iSlot]->SetText("");
+	}
+	else
+	{
+		// Check the key binding
+		char binding[64];
+		Q_snprintf(binding, sizeof( binding ), "order %d", iSlot+1);
+		const char *pBinding = engine->Key_LookupBinding( binding );
+		if ( pBinding && strcmp(pBinding,"") )
+		{
+			m_pOrderLabels[iSlot]->SetText( pBinding );
+		}
+	}
+
+	// Only insert it if it's not there already
+	if ( m_pOrderPanels[iSlot]->GetOrder() != pOrder )
+	{
+		m_pOrderPanels[iSlot]->SetOrder( pOrder );
+		m_pOrderPanels[iSlot]->SetParent( this );
+		m_pOrderLabels[iSlot]->SetParent( this );
+		m_pOrderLabels[iSlot]->SetSelected( pOrder->IsPersonalOrder() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: We've received a new order, or a modified old one. Figure out what to do.
+//-----------------------------------------------------------------------------
+void CHudOrderList::RecalculateOrderList( void )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+
+	// Does this player have a personal order?
+	C_Order *pOrder = pPlayer->PersonalOrder();
+	if( pOrder )
+	{
+		// Highlight the selected order (and the personal order always)
+		m_pOrderPanels[0]->SetBgColor( Color( 0,0,0, 192) );
+		m_pOrderLabels[0]->SetBgColor( Color( 0,0,0, 192) );
+	}
+}
+
diff --git a/game/client/tf2/hud_orders.h b/game/client/tf2/hud_orders.h
new file mode 100644
index 0000000..4015b30
--- /dev/null
+++ b/game/client/tf2/hud_orders.h
@@ -0,0 +1,87 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Order window
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef ORDERS_H
+#define ORDERS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/Label.h>
+#include "c_order.h"
+#include "hudelement.h"
+
+class CHudLabel;
+
+#define MAX_HUD_ORDERS		1		// Number of orders to show in the HUD
+
+//-----------------------------------------------------------------------------
+// Purpose: Panel used to display the status for an order
+//-----------------------------------------------------------------------------
+class CHudOrder : public vgui::Panel
+{
+public:
+	CHudOrder( int x,int y,int wide,int tall );
+	~CHudOrder( void );
+
+	virtual void Init( void );
+	virtual void Paint( void );
+
+	// Order handling
+	virtual void SetOrder( C_Order *pOrder );
+	virtual C_Order *GetOrder( void );
+	virtual void UpdateOrder( void );
+	virtual void OrderRemoved( void );
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+private:
+	C_Order *m_pOrder;		// Order that this panel holds
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Panel that holds all the individual order panels
+//-----------------------------------------------------------------------------
+class CHudOrderList : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudOrderList, vgui::Panel );
+public:
+	DECLARE_MULTIPLY_INHERITED();
+
+	CHudOrderList( const char *pElementName );
+	~CHudOrderList( void );
+
+	virtual void LevelInit( void );
+	virtual void LevelShutdown( void );
+	virtual void OnThink( void );
+	virtual void Paint( void );
+
+	// Order handling
+	void RecalculateOrderList( void );
+	void InsertOrder( C_Order *pOrder, int iSlot );
+
+private:
+	CHudOrder			*m_pOrderPanels[ MAX_HUD_ORDERS ];
+	CHudLabel			*m_pOrderLabels[ MAX_HUD_ORDERS ];
+};
+
+extern CHudOrderList *GetHudOrderList( void );
+
+// Position & Size
+// X
+#define ORDERS_LEFT				(ScreenWidth() - 5 - XRES(112))
+#define ORDERS_RIGHT			(ScreenWidth() - 5 )
+#define ORDERS_WIDTH			(ORDERS_RIGHT - ORDERS_LEFT)
+#define ORDERS_ELEMENT_LEFT		XRES(32)
+#define ORDERS_ELEMENT_WIDTH	(ORDERS_RIGHT - ORDERS_ELEMENT_LEFT)
+// Y
+#define ORDERS_BOTTOM			YRES(412)
+#define ORDERS_ELEMENT_HEIGHT	YRES(32)
+#define ORDERS_TOP				(ORDERS_BOTTOM - (ORDERS_ELEMENT_HEIGHT * MAX_HUD_ORDERS))
+#define ORDERS_HEIGHT			(ORDERS_BOTTOM - ORDERS_TOP)
+
+#endif // ORDER_H
diff --git a/game/client/tf2/hud_resources.cpp b/game/client/tf2/hud_resources.cpp
new file mode 100644
index 0000000..8b0a1ca
--- /dev/null
+++ b/game/client/tf2/hud_resources.cpp
@@ -0,0 +1,131 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Hud display of the local player's resource counts
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud_numeric.h"
+#include "c_basetfplayer.h"
+#include "hud_macros.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHudResources : public CHudNumeric
+{
+	DECLARE_CLASS_SIMPLE( CHudResources, CHudNumeric )
+public:
+	CHudResources( const char *pElementName );
+
+	virtual const char *GetLabelText() { return m_szResourcesLabel; }
+	virtual const char *GetPulseEvent( bool increment ) { return increment ? "ResourceIncrement" : "ResourceDecrement"; }
+	virtual bool		GetValue( char *val, int maxlen );
+
+private:
+	bool				GetResourceCount( int& value );
+
+	CPanelAnimationStringVar( 128, m_szResourcesLabel, "ResourcesLabel", "Resources" );
+};
+
+DECLARE_HUDELEMENT( CHudResources );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudResources::CHudResources( const char *pElementName ) : CHudNumeric( pElementName, "HudResources")
+{
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+}
+
+bool CHudResources::GetValue( char *val, int maxlen )
+{
+	int bank = 0;
+	if ( !GetResourceCount( bank ) )
+		return false;
+
+	Q_snprintf( val, maxlen, "%i", bank );
+	return true;
+}
+
+bool CHudResources::GetResourceCount( int& value )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return false;
+	if ( pPlayer->GetTeamNumber() == 0)
+		return false;
+
+	value = pPlayer->m_TFLocal.m_iBankResources;
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CHudResourcesPickup : public CHudNumeric
+{
+	DECLARE_CLASS_SIMPLE( CHudResourcesPickup, CHudNumeric )
+public:
+	CHudResourcesPickup( const char *pElementName );
+
+	virtual void		Init( void );
+	virtual const char *GetLabelText() { return m_szResourcesPickupLabel; }
+	virtual const char *GetPulseEvent( bool increment ) { return "ResourcePickup"; }
+	virtual bool		GetValue( char *val, int maxlen );
+
+	// Handler for our message
+	void MsgFunc_PickupRes( bf_read &msg );
+
+private:
+	int		m_iPickupAmount;
+
+	CPanelAnimationStringVar( 128, m_szResourcesPickupLabel, "ResourcesPickupLabel", "" );
+};
+
+DECLARE_HUDELEMENT( CHudResourcesPickup );
+DECLARE_HUD_MESSAGE( CHudResourcesPickup, PickupRes );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudResourcesPickup::CHudResourcesPickup( const char *pElementName ) : CHudNumeric( pElementName, "HudResourcesPickup")
+{
+	m_iPickupAmount = 0;
+
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudResourcesPickup::Init( void )
+{
+	HOOK_HUD_MESSAGE( CHudResourcesPickup, PickupRes );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHudResourcesPickup::GetValue( char *val, int maxlen )
+{
+	if ( !m_iPickupAmount )
+		return false;
+
+	Q_snprintf( val, maxlen, "+%i", m_iPickupAmount );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Message handler for PickupRes message
+//-----------------------------------------------------------------------------
+void CHudResourcesPickup::MsgFunc_PickupRes( bf_read &msg )
+{
+	m_iPickupAmount = msg.ReadByte();
+
+	ForcePulse();
+}
\ No newline at end of file
diff --git a/game/client/tf2/hud_target_id.cpp b/game/client/tf2/hud_target_id.cpp
new file mode 100644
index 0000000..46abca8
--- /dev/null
+++ b/game/client/tf2/hud_target_id.cpp
@@ -0,0 +1,230 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: HUD Target ID element
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "hudelement.h"
+#include "imessagechars.h"
+#include "c_basetfplayer.h"
+#include "c_playerresource.h"
+#include "vgui_EntityPanel.h"
+#include "vgui_healthbar.h"
+#include "commanderoverlay.h"
+#include "c_baseobject.h"
+#include "iclientmode.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)
+
+
+//-----------------------------------------------------------------------------
+// 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:
+	vgui::HFont		m_hFont;
+	int				m_iLastEntIndex;
+	float			m_flLastChangeTime;
+	char			m_sIDString[ MAX_ID_STRING ];
+};
+
+DECLARE_HUDELEMENT( CTargetID );
+
+//-----------------------------------------------------------------------------
+// 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;
+	m_sIDString[0] = 0;
+
+	SetHiddenBits( HIDEHUD_MISCSTATUS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Setup
+//-----------------------------------------------------------------------------
+void CTargetID::Init( void )
+{
+};
+
+void CTargetID::ApplySchemeSettings( vgui::IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+
+	SetPaintBackgroundEnabled( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: clear out string etc between levels
+//-----------------------------------------------------------------------------
+void CTargetID::VidInit()
+{
+	CHudElement::VidInit();
+
+	m_flLastChangeTime = 0;
+	m_iLastEntIndex = 0;
+	m_sIDString[0] = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw function for the element
+//-----------------------------------------------------------------------------
+void CTargetID::Paint()
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	// No id if still choosing class
+	if ( C_BaseTFPlayer::GetLocalPlayer()->GetClass() == TFCLASS_UNDECIDED )
+		return;
+
+	// Get our target's ent index
+	int iEntIndex = C_BaseTFPlayer::GetLocalPlayer()->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;
+			m_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_BaseTFPlayer *pPlayer = static_cast<C_BaseTFPlayer*>(cl_entitylist->GetEnt( iEntIndex ));
+		C_BaseTFPlayer *pLocalPlayer = C_BaseTFPlayer::GetLocalPlayer();
+
+		// 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->InSameTeam(pLocalPlayer) )
+			{
+				// Check distance to other player, and if the player is on the same team
+				float flDistSq = pPlayer->GetRenderOrigin().DistToSqr( pLocalPlayer->GetRenderOrigin() );
+				if ( flDistSq < PLAYER_HINT_DISTANCE_SQ )
+				{
+					Q_snprintf( m_sIDString, sizeof(m_sIDString), "%s\nHealth: %.0f percent\nUse to donate resources",
+						pPlayer->GetPlayerName(), ((float)pPlayer->GetHealth() / (float)pPlayer->GetMaxHealth() ) * 100 );
+				}
+				else
+				{
+					Q_snprintf( m_sIDString, sizeof(m_sIDString), "%s\nHealth: %.0f percent",
+						pPlayer->GetPlayerName(), ((float)pPlayer->GetHealth() / (float)pPlayer->GetMaxHealth() ) * 100 );
+				}
+			}
+			else if (( pPlayer->GetHealth() == 0) && (pLocalPlayer->GetClass() == TFCLASS_INFILTRATOR) )
+			{
+				Q_snprintf( m_sIDString, sizeof(m_sIDString), "%s\nUse to disguise as this player", pPlayer->GetPlayerName() );
+			}
+			else
+			{
+				m_sIDString[0] = 0;
+				m_iLastEntIndex = 0;
+			}
+		}
+		else
+		{
+			// Objects
+			C_BaseEntity *pEnt = cl_entitylist->GetEnt( iEntIndex );
+			if ( !pEnt || !pEnt->InSameTeam(pLocalPlayer) )
+			{
+				// This can happen because the object was destroyed
+				m_sIDString[0] = 0;
+				m_iLastEntIndex = 0;
+			}
+			else
+			{
+				// Don't check validity if it's sent by the server
+				Q_strncpy( m_sIDString, pEnt->GetIDString(), sizeof(m_sIDString) );
+				m_iLastEntIndex = iEntIndex;
+			}
+		}
+	}
+
+	// Draw our ID string
+	if ( m_sIDString[0] )
+	{
+		int width, height;
+		int ypos = YRES(300);
+
+		// Messagechars can't handle multiple line strings, so parse out the \n's and give it one line at a time
+		char *ch = m_sIDString;
+		while ( *ch )
+		{
+			// Find the next newline
+			char *next_line;
+			for ( next_line = ch; *next_line != '\n' && *next_line != 0; next_line++ )
+			{
+			}
+
+			// Stomp the newline
+			char *top = next_line;
+			if ( *top == '\n' )
+			{
+				*top = 0;
+			}
+			else
+			{
+				top = NULL;
+			}
+
+			// Draw the line
+			messagechars->GetStringLength( m_hFont, &width, &height, ch );
+			messagechars->DrawString( m_hFont, (ScreenWidth() - width) / 2, ypos, 255, 255, 245, 255, ch, IMessageChars::MESSAGESTRINGID_NONE );
+
+			ypos += height;
+
+			// Restore the newline
+			if ( top ) 
+			{
+				*top = '\n';
+			}
+
+			// Move to the next line
+			ch = next_line;
+			if ( *ch == '\n' )
+			{
+				ch++;
+			}
+		}
+	}
+}
diff --git a/game/client/tf2/hud_targetreticle.cpp b/game/client/tf2/hud_targetreticle.cpp
new file mode 100644
index 0000000..5f4349c
--- /dev/null
+++ b/game/client/tf2/hud_targetreticle.cpp
@@ -0,0 +1,183 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Target reticle hud element
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "c_basetfplayer.h"
+#include "tf_shareddefs.h"
+#include "iclientmode.h"
+#include "clientmode_tfnormal.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imesh.h"
+#include "hud_targetreticle.h"
+#include "model_types.h"
+#include "view_scene.h"
+#include "view.h"
+#include <vgui/Cursor.h>
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTargetReticle::CTargetReticle( void )
+: BaseClass( NULL, "CTargetReticle" ),
+  m_CursorNone(vgui::dc_none)
+{
+	SetCursor( m_CursorNone );
+
+	SetPaintBackgroundEnabled( false );
+	SetAutoDelete( false );
+	m_hTargetEntity = NULL;
+	m_pTargetLabel = NULL;
+	m_iReticleId = 0;
+	m_iReticleLeftId = 0;
+	m_iReticleRightId = 0;
+	m_iRenderTextureId = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTargetReticle::~CTargetReticle()
+{
+	if ( m_pTargetLabel != NULL )
+	{
+		delete m_pTargetLabel;
+		m_pTargetLabel = NULL;
+	}
+
+	SetParent( (vgui::Panel *)NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTargetReticle::Init( C_BaseEntity *pEntity, const char *sName )
+{
+	vgui::Panel *pParent = GetClientModeNormal()->GetViewport();
+	SetParent( pParent );
+	SetCursor( pParent->GetCursor() );
+
+	if ( !m_pTargetLabel )
+	{
+		m_pTargetLabel = new vgui::Label( pParent, "TargetLabel", "Unnamed" );
+		m_pTargetLabel->SetPos( 0, 0 );
+		m_pTargetLabel->SetFgColor( Color( 255, 170, 0, 255 ) );
+		m_pTargetLabel->SetPaintBackgroundEnabled( false );
+		m_pTargetLabel->SetAutoDelete( false );
+		m_pTargetLabel->SetCursor( m_CursorNone );
+	}
+
+	SetSize( XRES(32),YRES(32) );
+	m_hTargetEntity = pEntity;
+	m_pTargetLabel->SetText( sName );
+
+	int contentW, contentH;
+	m_pTargetLabel->GetContentSize( contentW, contentH );
+	m_pTargetLabel->SetWide( contentW );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_BaseEntity *CTargetReticle::GetTarget( void )
+{
+	return m_hTargetEntity;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTargetReticle::Update( void )
+{
+	if ( !m_hTargetEntity )
+	{
+		C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+		pPlayer->Remove_Target( this );
+		return;
+	}
+
+	// Load our textures..
+	if ( !m_iReticleId )
+	{
+		m_iReticleId = vgui::surface()->CreateNewTextureID();
+		vgui::surface()->DrawSetTextureFile( m_iReticleId, "Hud/target_reticle" , true, false);
+	}
+	
+	if ( !m_iReticleLeftId )
+	{
+		m_iReticleLeftId = vgui::surface()->CreateNewTextureID();
+		vgui::surface()->DrawSetTextureFile( m_iReticleLeftId, "Hud/target_reticle_left", true, false );
+	}
+	
+	if ( !m_iReticleRightId )
+	{
+		m_iReticleRightId = vgui::surface()->CreateNewTextureID();
+		vgui::surface()->DrawSetTextureFile( m_iReticleRightId, "Hud/target_reticle_right" , true, false);
+	}
+
+	int iX, iY;
+	GetTargetInScreenSpace( m_hTargetEntity, iX, iY );
+	
+	int halfWidth = GetWide() / 2;
+	halfWidth = MAX( halfWidth, m_pTargetLabel->GetWide() / 2 );
+
+	m_iRenderTextureId = m_iReticleId;
+	if( iX < halfWidth || iX > ScreenWidth()-halfWidth )
+	{
+		// It's off the screen. See what side it's on.
+		Vector vCenter = m_hTargetEntity->WorldSpaceCenter( );
+		
+		if( CurrentViewRight().Dot( vCenter - CurrentViewOrigin() ) > 0 )
+		{
+			m_iRenderTextureId = m_iReticleRightId;
+			iX = ScreenWidth() - halfWidth;
+		}
+		else
+		{
+			m_iRenderTextureId = m_iReticleLeftId;
+			iX = halfWidth;
+		}
+
+		// Put Y in the center of the screen.
+		iY = ScreenHeight() / 2;
+	}
+
+	// Move the icon there
+	SetPos( iX - (GetWide() / 2), iY - (GetTall() / 2) );
+
+	// Center the text under it
+	m_pTargetLabel->SetPos( iX - (m_pTargetLabel->GetWide() / 2), iY + (GetTall() / 2) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTargetReticle::Paint()
+{
+	if ( !m_hTargetEntity || !m_iRenderTextureId )
+		return;
+
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( pPlayer == NULL || pPlayer->GetHealth() < 1 )
+		return;
+
+	// Show hide label based on EMP state
+	bool suppress_reticle = pPlayer->HasPowerup(POWERUP_EMP);
+
+	m_pTargetLabel->SetVisible( suppress_reticle ? false : true );
+
+	// Don't draw the reticle either
+	if ( suppress_reticle )
+		return;
+
+	vgui::surface()->DrawSetTexture( m_iRenderTextureId );
+	vgui::surface()->DrawSetColor( 255, 255, 255, 255 );
+	vgui::surface()->DrawTexturedRect( 0, 0, GetWide(), GetTall() );
+}
+
diff --git a/game/client/tf2/hud_targetreticle.h b/game/client/tf2/hud_targetreticle.h
new file mode 100644
index 0000000..dfee449
--- /dev/null
+++ b/game/client/tf2/hud_targetreticle.h
@@ -0,0 +1,53 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Targeting reticle
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TARGETRETICLE_H
+#define TARGETRETICLE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Panel.h>
+#include <vgui_controls/Label.h>
+#include <vgui/Cursor.h>
+
+class IMaterial;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CTargetReticle : public vgui::Panel
+{
+	typedef vgui::Panel BaseClass;
+public:
+	CTargetReticle( void );
+	~CTargetReticle();
+
+	void			Update();
+
+	// vgui::Panel overrides.
+	virtual void	Paint( void );
+
+	void			Init( C_BaseEntity *pEntity, const char *sName );
+	C_BaseEntity*	GetTarget( void );
+
+
+protected:
+
+	EHANDLE			m_hTargetEntity;
+	vgui::Label		*m_pTargetLabel;
+	
+	int				m_iReticleId;
+	int				m_iReticleLeftId;	// When it's hanging off the edge of the screen.
+	int				m_iReticleRightId;
+
+	int				m_iRenderTextureId;
+
+	vgui::HCursor				m_CursorNone;
+};
+
+#endif // TARGETRETICLE_H
diff --git a/game/client/tf2/hud_technologytreedoc.cpp b/game/client/tf2/hud_technologytreedoc.cpp
new file mode 100644
index 0000000..5ec1859
--- /dev/null
+++ b/game/client/tf2/hud_technologytreedoc.cpp
@@ -0,0 +1,175 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud_technologytreedoc.h"
+#include "hud.h"
+#include "hud_macros.h"
+#include "techtree.h"
+#include "iclientmode.h"
+#include "hud_commander_statuspanel.h"
+#include "clientmode_commander.h"
+#include "commanderoverlaypanel.h"
+#include "tf_hints.h"
+#include "c_tf_hintmanager.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+static CTechnologyTreeDoc s_TechnologyTreeDoc;
+
+// Hook network messages
+DECLARE_MESSAGE( s_TechnologyTreeDoc, Technology )
+
+// Create object singleton on stack
+CTechnologyTreeDoc& GetTechnologyTreeDoc()
+{
+	return s_TechnologyTreeDoc;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Construction
+//-----------------------------------------------------------------------------
+CTechnologyTreeDoc::CTechnologyTreeDoc( void )
+{
+	m_pTree = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Destruction
+//-----------------------------------------------------------------------------
+CTechnologyTreeDoc::~CTechnologyTreeDoc( void )
+{
+	delete m_pTree;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Initialize the panel
+//-----------------------------------------------------------------------------
+void CTechnologyTreeDoc::Init( void )
+{
+	ReloadTechTree();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTechnologyTreeDoc::LevelInit( void )
+{
+	if ( m_pTree )
+	{
+		m_pTree->SetPreferredTechnology( NULL );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTechnologyTreeDoc::LevelShutdown( void )
+{
+	if ( m_pTree )
+	{
+		m_pTree->SetPreferredTechnology( NULL );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTechnologyTreeDoc::ReloadTechTree( void )
+{
+	// FIXME, CTechnologyTreeDoc should be an entity /MO
+	HOOK_HUD_MESSAGE( s_TechnologyTreeDoc, Technology );
+
+	// Reconstruct the tech tree
+	delete m_pTree;
+
+	// FIXME: If we reactivate this, we'll need to revisit team number here...
+	m_pTree = new CTechnologyTree( ::filesystem, 0);
+	Assert( m_pTree );
+
+	m_pTree->SetPreferredTechnology( NULL );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Receive hud update message from server
+// Input  : *pszName - 
+//			iSize - 
+//			*pbuf - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CTechnologyTreeDoc::MsgFunc_Technology(bf_read &msg)
+{
+	int index;
+	int available;
+	int voters;
+	float resourcelevel;
+	bool preferred;
+
+	// Which tech
+	index		= msg.ReadByte();
+	// Available to this team?
+	available	= msg.ReadByte();
+	// # of players indicating this as their preferred tech for new spending
+	voters		= msg.ReadByte();
+
+	preferred = ( voters & 0x80 ) ? true : false;
+	voters &= 0x7f;
+
+	resourcelevel = (float)msg.ReadShort();
+	
+	// Look it up by index
+	CBaseTechnology *item = m_pTree->GetTechnology( index );
+	if ( item )
+	{	
+		bool wasactive = item->GetActive();
+
+		bool justactivated = !wasactive && available;
+
+		// Set data elements
+		item->SetActive( available ? true : false );
+		item->SetVoters( voters );
+		item->SetResourceLevel( resourcelevel );
+
+		// If this is the tech I am voting for, clear my vote
+		if ( preferred )
+		{
+			// Sets the flag on the item, too
+			m_pTree->SetPreferredTechnology( item );
+		}
+		else
+		{
+			// Force deselection in case there is no active preference on the server any more
+			item->SetPreferred( false );
+		}
+
+		if ( justactivated && item->GetLevel() > 0 && !item->GetHintsGiven( TF_HINT_NEWTECHNOLOGY ) )
+		{
+			// So we only give this hint once this game, even if we respawn, etc.
+			item->SetHintsGiven( TF_HINT_NEWTECHNOLOGY, true );
+			// Note, only show a max of three or 4 newtechnology hints at a time
+			CreateGlobalHint( TF_HINT_NEWTECHNOLOGY, item->GetPrintName(), index, 3 );
+		}
+	}
+	
+	return 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a file of technologies to the technology tree
+//-----------------------------------------------------------------------------
+void CTechnologyTreeDoc::AddTechnologyFile( char *sFilename )
+{
+	// Add the technologies to the tech list
+	if ( m_pTree )
+	{
+		// FIXME: If we reactivate this, we'll need to revisit team number here...
+		m_pTree->AddTechnologyFile( ::filesystem, 0, sFilename );
+	}
+}
diff --git a/game/client/tf2/hud_technologytreedoc.h b/game/client/tf2/hud_technologytreedoc.h
new file mode 100644
index 0000000..c9d74a4
--- /dev/null
+++ b/game/client/tf2/hud_technologytreedoc.h
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( TF_TECHNOLOGYTREEDOC_H )
+#define TF_TECHNOLOGYTREEDOC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// Forward declarations
+class CTechnologyTree;
+
+//-----------------------------------------------------------------------------
+// Purpose: Container for views into technology tree
+//-----------------------------------------------------------------------------
+class CTechnologyTreeDoc
+{
+public:
+	// Construction
+								CTechnologyTreeDoc( void );
+	virtual						~CTechnologyTreeDoc( void );
+
+	virtual void				Init( void );
+	virtual void				ReloadTechTree( void );
+
+	virtual void				LevelInit( void );
+	virtual void				LevelShutdown( void );
+
+	inline CTechnologyTree		*GetTechnologyTree() {return m_pTree;}
+
+	void						AddTechnologyFile( char *sFilename );
+
+	// Network input
+	int							MsgFunc_Technology( bf_read &msg );
+	int							MsgFunc_Resource( bf_read &msg );
+
+private:
+	// The underlying technology data tree
+	CTechnologyTree				*m_pTree;
+};
+
+// Expose Document to rest of dll
+extern CTechnologyTreeDoc& GetTechnologyTreeDoc();
+
+
+#endif // TF_TECHNOLOGYTREEDOC_H
\ No newline at end of file
diff --git a/game/client/tf2/hud_timer.cpp b/game/client/tf2/hud_timer.cpp
new file mode 100644
index 0000000..a5b6b6a
--- /dev/null
+++ b/game/client/tf2/hud_timer.cpp
@@ -0,0 +1,298 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: HUD Timer
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "hud_macros.h"
+#include "hud_numeric.h"
+#include "c_basetfplayer.h"
+#include "hud_timer.h"
+#include "iclientmode.h"
+#include <vgui_controls/AnimationController.h>
+
+#define MIN_TIMER_ALPHA		192
+
+using namespace vgui;
+
+DECLARE_HUDELEMENT( CHudTimer );
+DECLARE_HUD_MESSAGE( CHudTimer, StartTimer );
+DECLARE_HUD_MESSAGE( CHudTimer, SetTimer );
+DECLARE_HUD_MESSAGE( CHudTimer, UpdateTimer );
+
+//-----------------------------------------------------------------------------
+// Purpose: Create the Timer
+//-----------------------------------------------------------------------------
+CHudTimer::CHudTimer( const char *pElementName ) : CHudNumeric( pElementName, "HudTimer" )
+{
+	SetDrawLabel( false );
+	SetDoPulses( false );
+	
+	SetHiddenBits( HIDEHUD_MISCSTATUS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reset Timer values
+//-----------------------------------------------------------------------------
+void CHudTimer::Init( void )
+{
+	m_iAlpha = MIN_TIMER_ALPHA;
+	m_flCurrentTime = 0.0;
+	m_flStartTime = 0.0;
+	m_flPrevTimeSlice = 0.0;
+	m_iPaused = false;
+	m_bFixedTime = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the Timer's start time, and tells the timer to go into fixed time mode.
+//-----------------------------------------------------------------------------
+void CHudTimer::SetFixedTimer( float flStartTime, float flTimeLimit )
+{
+	Init();
+
+	// Setup the Timer values
+	m_flStartTime = flStartTime;
+	m_flTimeLimit = flTimeLimit;
+	m_bFixedTime = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the Timer to a Time, and tells the timer to go into no fixed time mode.
+//-----------------------------------------------------------------------------
+void CHudTimer::SetNoFixedTimer( float flTime )
+{
+	Init();
+
+	// Setup the Timer values
+	m_flStartTime = m_flCurrentTime = flTime;
+	m_bFixedTime = false;
+
+	// Timer starts paused
+	StopTimer();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates the Timer to a specific timer without doing anything else
+//-----------------------------------------------------------------------------
+void CHudTimer::UpdateTimer( float flTime )
+{
+	m_flCurrentTime = flTime;
+	m_flPrevTimeSlice = gpGlobals->curtime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start the Timer
+//-----------------------------------------------------------------------------
+void CHudTimer::StartTimer( void )
+{
+	// Ignore start / stop if I'm in fixed time mode
+	if ( m_bFixedTime )
+		return;
+	if ( !m_iPaused )
+		return;
+
+	// Start timer
+	m_flPrevTimeSlice = gpGlobals->curtime;
+	m_iPaused = false;
+
+	// Start with a short pulse
+	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("TimerPulse");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop the Timer, without resetting it
+//-----------------------------------------------------------------------------
+void CHudTimer::StopTimer( void )
+{
+	// Ignore start / stop if I'm in fixed time mode
+	if ( m_bFixedTime )
+		return;
+	if ( m_iPaused )
+		return;
+
+	// Pause timer values
+	m_iPaused = true;
+
+	// Stop with a short pulse
+	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("TimerPulse");
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get back a color for the timer from a Green <-> Yellow <-> Red ramp
+//-----------------------------------------------------------------------------
+Color CHudTimer::GetColor( void )
+{
+	Color clr = Color( 0, 0, 0, 0 );
+
+	float flPercentagePassed = 1 - (m_flCurrentTime / m_flTimeLimit);
+
+	if ( flPercentagePassed < 0.75 )
+	{
+		clr = m_TextColor;
+	}
+	else if ( flPercentagePassed < 0.9 )
+	{
+		clr = m_TextColorWarning;
+	}
+	else
+	{
+		clr = m_TextColorCritical;
+	}
+
+	// Handle pulses ( which brighten the timer & change the font )
+	clr[3] = clamp( MIN_TIMER_ALPHA + ( m_flBlur ) * 128, 0, 255 );
+
+	// Low timer always overrides to make it bright
+	if ( flPercentagePassed > 0.99 )
+	{
+		clr[3] = 255;
+	}
+
+	return clr;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get back a color for the timer from a Green <-> Yellow <-> Red ramp
+//-----------------------------------------------------------------------------
+Color CHudTimer::GetBoxColor()
+{
+	Color boxColor = Color( 0, 0, 0, 0 );
+
+	float flPercentagePassed = 1 - (m_flCurrentTime / m_flTimeLimit);
+	if ( flPercentagePassed < 0.75 )
+	{
+		boxColor = m_BoxColor;
+	}
+	else if ( flPercentagePassed < 0.9 )
+	{
+		boxColor = m_BoxColorWarning;
+	}
+	else
+	{
+		boxColor = m_BoxColorCritical;
+	}
+
+	return boxColor;
+}
+
+bool CHudTimer::GetValue( char *value, int maxlen )
+{
+	if ( m_flStartTime == 0.0 )
+		return false;
+
+	// Convert time to Minutes and Seconds (prevent negative times)
+	int iTimerMinutes = MAX( 0, ((int)m_flCurrentTime) / 60 );
+	int iTimerSeconds = MAX( 0, ((int)m_flCurrentTime) % 60 );
+
+	Q_snprintf( value, maxlen, "%02d:%.2d", iTimerMinutes, iTimerSeconds );
+	return true;
+}
+
+void CHudTimer::OnThink( void )
+{
+	if ( m_flStartTime == 0.0 )
+		return;
+
+	// If we're in fixed time mode, calculate the current time
+	if ( m_bFixedTime )
+	{
+		// Don't paint at all if we have no timelimit
+		if ( !m_flTimeLimit )
+			return;
+
+		m_flCurrentTime = gpGlobals->curtime - m_flStartTime;
+
+		// If we have a timelimit, count down
+		if ( m_flTimeLimit )
+		{
+			m_flCurrentTime = m_flTimeLimit - m_flCurrentTime;
+		}
+
+		CheckForPulse();
+	}
+
+	// Increment the time if the Timer's going, and we're not in fixed time mode.
+	if ( !m_iPaused && !m_bFixedTime )
+	{
+		m_flCurrentTime -= gpGlobals->curtime - m_flPrevTimeSlice;
+		m_flPrevTimeSlice = gpGlobals->curtime;
+
+		// Hit the end?
+		if ( m_flCurrentTime <= 0.0 )
+		{
+			StopTimer();
+			m_flCurrentTime = 0.0;
+		}
+	}
+
+	m_flLastTime = m_flCurrentTime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check to see if the Timer should pulse
+//-----------------------------------------------------------------------------
+void CHudTimer::CheckForPulse( void )
+{
+	int pulseInterval = 60;
+	if ( m_flCurrentTime <= 60 )
+	{
+		pulseInterval = 10;
+	}
+
+	// See if we've crossed a minute boundary
+	int iLastTimerMinutes = ((int)m_flLastTime) / pulseInterval;
+	// will we get there in next half second
+	int iTimerMinutes = ((int)m_flCurrentTime - 0.5f ) / pulseInterval;
+	if ( iLastTimerMinutes != iTimerMinutes )
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("TimerPulse");
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Message Handler for the Timer Set
+//-----------------------------------------------------------------------------
+int CHudTimer::MsgFunc_SetTimer(bf_read &msg)
+{
+	float flTimeToSetTo = msg.ReadBitCoord();
+	SetNoFixedTimer( flTimeToSetTo );
+
+	return 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Message Handler for the Timer Update
+// Updates are like sets, but they don't re-evaluate the start time
+// They're used to just ensure the Client Timers don't get too far out of synch with the server's timer
+//-----------------------------------------------------------------------------
+int CHudTimer::MsgFunc_UpdateTimer(bf_read &msg)
+{
+	float flTimeToSetTo = msg.ReadBitCoord();
+	UpdateTimer( flTimeToSetTo );
+
+	return 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Message Handler for the Timer Start/Stop
+//-----------------------------------------------------------------------------
+int CHudTimer::MsgFunc_StartTimer( bf_read &msg )
+{
+	if ( msg.ReadByte() )
+	{
+		// Start the Timer
+		StartTimer();
+	}
+	else
+	{
+		// Pause the Timer
+		StopTimer();
+	}
+
+	return 1;	
+}
\ No newline at end of file
diff --git a/game/client/tf2/hud_timer.h b/game/client/tf2/hud_timer.h
new file mode 100644
index 0000000..b7645ad
--- /dev/null
+++ b/game/client/tf2/hud_timer.h
@@ -0,0 +1,70 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HUD_TIMER_H
+#define HUD_TIMER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "hud_numeric.h"
+#include <vgui_controls/Panel.h>
+
+
+//-----------------------------------------------------------------------------
+// Purpose: TF2 Countdown Timer
+//-----------------------------------------------------------------------------
+class CHudTimer : public CHudNumeric
+{
+	DECLARE_CLASS_SIMPLE( CHudTimer, CHudNumeric )
+public:
+	CHudTimer( const char *pElementName );
+
+	virtual void Init( void );
+	virtual void OnThink( void );
+
+	virtual const char *GetLabelText() { return m_szTimerLabel; }
+	virtual const char *GetPulseEvent( bool increment ) { return ""; }
+	virtual bool		GetValue( char *val, int maxlen );
+
+	virtual Color GetColor();
+	virtual Color GetBoxColor();
+
+	// Handling
+	void SetNoFixedTimer( float flTime );
+	void SetFixedTimer( float flStartTime, float flTimeLimit );
+	void UpdateTimer( float flTime );
+	void StartTimer( void );
+	void StopTimer( void );
+	void CheckForPulse( void );
+	int  MsgFunc_SetTimer( bf_read &msg );
+	int  MsgFunc_StartTimer( bf_read &msg );
+	int  MsgFunc_UpdateTimer( bf_read &msg );
+
+public:
+	int		m_iAlpha;
+	int		m_iPaused;
+	float	m_flCurrentTime;
+	float	m_flStartTime;
+	float	m_flPrevTimeSlice;
+	float	m_flPulseTime;
+	float	m_flTimeLimit;
+	float	m_flLastTime;
+
+	// The Timer has two modes of operation:
+	//	m_bFixedTime == true:  Timer can't be paused. Time displayed is an offset from the originally specified start time.
+	//  m_bFixedTime == false: Timer can be stopped & started. Time displayed is calculated on the client, and regularly updated by the server
+	//						   to ensure it doesn't get too far off the server's time.
+	bool	m_bFixedTime;
+
+private:
+	float		m_flOpenCloseTime;
+
+	CPanelAnimationStringVar( 128, m_szTimerLabel, "TimerLabel", "" );
+};
+
+#endif // HUD_TIMER_H
diff --git a/game/client/tf2/hud_vehicle_role.cpp b/game/client/tf2/hud_vehicle_role.cpp
new file mode 100644
index 0000000..2ba956d
--- /dev/null
+++ b/game/client/tf2/hud_vehicle_role.cpp
@@ -0,0 +1,80 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "hud_vehicle_role.h"
+#include "iclientmode.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+#include <KeyValues.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+DECLARE_HUDELEMENT( CVehicleRoleHudElement );
+
+using namespace vgui;
+
+CVehicleRoleHudElement::CVehicleRoleHudElement( const char *pElementName ) : 
+	CHudElement( pElementName ), BaseClass( NULL, "VehicleRoleHudElement" )
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	m_iRole = -1;
+
+	SetHiddenBits( HIDEHUD_HEALTH | HIDEHUD_PLAYERDEAD );
+}
+
+void CVehicleRoleHudElement::ApplySchemeSettings( IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+
+	m_hTextFont = scheme->GetFont( "Trebuchet24" );
+
+	SetPaintBackgroundEnabled( false );
+}
+
+
+void CVehicleRoleHudElement::ShowVehicleRole( int iRole )
+{
+	m_iRole = iRole;
+}
+
+
+void CVehicleRoleHudElement::Paint()
+{
+	if ( m_iRole == -1 )
+		return;
+
+	surface()->DrawSetTextFont( m_hTextFont );
+	surface()->DrawSetTextColor( GetFgColor() );
+
+	char str[512];
+	if ( m_iRole == VEHICLE_ROLE_DRIVER )
+	{
+		Q_strncpy( str, "Driver", sizeof( str ) );
+	}
+	else
+	{
+		Q_snprintf( str, sizeof( str ), "Passenger %d", m_iRole );
+	}
+
+	int pixels = UTIL_ComputeStringWidth( m_hTextFont, str );
+	int x = ( GetWide() - pixels ) / 2;
+
+	surface()->DrawSetTextPos( x, 0 );
+
+	char *p = str;
+	while ( *p )
+	{
+		surface()->DrawUnicodeChar( *p );
+		p++;
+	}
+}
+
+
diff --git a/game/client/tf2/hud_vehicle_role.h b/game/client/tf2/hud_vehicle_role.h
new file mode 100644
index 0000000..ddee87f
--- /dev/null
+++ b/game/client/tf2/hud_vehicle_role.h
@@ -0,0 +1,34 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef HUD_VEHICLE_ROLE_H
+#define HUD_VEHICLE_ROLE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "hudelement.h"
+#include <vgui_controls/Controls.h>
+#include <vgui_controls/Panel.h>
+
+class CVehicleRoleHudElement : public CHudElement, public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CVehicleRoleHudElement, vgui::Panel );
+public:
+	CVehicleRoleHudElement( const char *pElementName );
+	virtual void	ApplySchemeSettings( vgui::IScheme *scheme );
+	virtual void	Paint( void );
+
+	// Set which role to display on the hud.
+	void ShowVehicleRole( int iRole );
+private:
+	int m_iRole;
+	vgui::HFont	m_hTextFont;
+};
+
+
+#endif // HUD_VEHICLE_ROLE_H
diff --git a/game/client/tf2/hud_weaponselection.cpp b/game/client/tf2/hud_weaponselection.cpp
new file mode 100644
index 0000000..4b21750
--- /dev/null
+++ b/game/client/tf2/hud_weaponselection.cpp
@@ -0,0 +1,1671 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//===========================================================================//
+
+#include "cbase.h"
+#include "weapon_selection.h"
+#include "iclientmode.h"
+#include "basetfcombatweapon_shared.h"
+#include "weapon_objectselection.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 "keydefs.h"
+
+#include <vgui/IVGui.h>
+
+#include "weapon_twohandedcontainer.h"
+#ifdef CLIENT_DLL
+#include "c_weapon_builder.h"
+#include "iinput.h"
+#else
+#include "weapon_builder.h"
+#endif
+
+using namespace vgui;
+
+class CHudWeaponSelection;
+
+typedef enum 
+{
+	IMAGE_BACKGROUND = 0,
+	IMAGE_CURRENT,
+	IMAGE_INVALID
+} WeaponBoxType_t;
+
+enum
+{
+	HUMAN_WEAPON_SELECTION = 0,
+	ALIEN_WEAPON_SELECTION,
+};
+
+struct CSlotInfo
+{
+	bool	active;
+	bool	valid;
+	CHudTexture const *icon;
+	bool	drawAmmo;
+	float	ammoPerc;
+	bool	ammoCaution;
+	char	printname[ 128 ];
+	CHandle< C_BaseCombatWeapon > weapon;
+};
+
+struct CWeaponMenuItem
+{
+	// If true, it's a dummy item
+	bool							buildslot;
+	int								priority;
+	int								hotkey;
+	int								openbuildmenu;
+	bool							isvalidmenuitem;
+	CHandle< C_BaseCombatWeapon >	weapon;
+};
+
+class WeaponMenu
+{
+public:
+	WeaponMenu() : items( 0, 0, WeaponLessFunc )
+	{
+		m_bIsBuildMenu = false;
+		m_nActiveItem = 0;
+	}
+
+	void	SetActiveItem( int item )
+	{
+		bool changed = ( m_nActiveItem != item );
+
+		m_nActiveItem = item;
+
+		if ( !changed )
+			return;
+
+		const char *prefix = m_bIsBuildMenu ? "WeaponHiliteBuildMenu" : "WeaponHiliteWeaponMenu";
+
+		if ( m_nActiveItem >= 1 )
+		{
+			char slotSequence[ 128 ];
+			Q_snprintf( slotSequence, sizeof( slotSequence ), "%s%i", prefix, m_nActiveItem );
+
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( slotSequence );
+		}
+	}
+
+	int		GetActiveItem()
+	{
+		return m_nActiveItem;
+	}
+
+	static bool WeaponLessFunc( const CWeaponMenuItem& w1, const CWeaponMenuItem& w2 )
+	{
+		return w1.priority < w2.priority;
+	}
+
+	CUtlRBTree< CWeaponMenuItem, int >	items;
+	int			m_nActiveItem;
+	bool		m_bIsBuildMenu;
+};
+
+class CHudWeaponItemPanel : public vgui::Panel
+{
+	DECLARE_CLASS_SIMPLE( CHudWeaponItemPanel, vgui::Panel );
+
+public:
+	CHudWeaponItemPanel( vgui::Panel *parent, const char *panelName );
+
+	CPanelAnimationVarAliasType( float, m_flIconWidth, "IconWidth", "60", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flIconHeight, "IconHeight", "30", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flIconXPos, "IconXPos", "10", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flIconYPos, "IconYPos", "4", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flTextXPos, "TextXPos", "10", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flTextYPos, "TextYPos", "35", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flAmmoBarX, "AmmoBarX", "75", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flAmmoBarWide, "AmmoBarWide", "4", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flSelectionNumberXPos, "SelectionNumberXPos", "4", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flSelectionNumberYPos, "SelectionNumberYPos", "4", "proportional_float" );
+
+	CPanelAnimationVarAliasType( float, m_flPriceXEndPos,	"PriceXEndPos", "4", "proportional_float" );
+	CPanelAnimationVarAliasType( float, m_flPriceYEndPos,	"PriceYEndPos", "4", "proportional_float" );
+
+	CPanelAnimationVar( float, m_flGrowFraction, "GrowFraction", "1.0" );
+
+	bool				m_bInUse;
+
+	bool				m_bDrawNumbers;
+	int					m_nSlotNumber;
+	bool				m_bBuildMenu;
+
+	// Copies of data
+	CSlotInfo			info;
+	CWeaponMenuItem		menuItem;
+
+	virtual void		Paint();
+
+	virtual void		ApplySchemeSettings( vgui::IScheme *scheme );
+
+	void				SetupIcons();
+
+	enum
+	{
+		NUM_SLOT_TEAMS = 2,
+		NUM_MENU_TYPES = 3,
+	};
+
+	CHudTexture			*m_BackgroundIcons[ NUM_SLOT_TEAMS ][ NUM_MENU_TYPES ];
+
+private:
+	void TranslateColor( float percent, Color& clr );
+	void DrawBox( bool isbuildmenu, int x, int y, int wide, int tall, bool isactive, bool isvalid, float normalizedAlpha, int number );
+	int GetTeamIndex();
+	void OnWeaponSelectionDrawn( CHudWeaponSelection *selection, C_WeaponObjectSelection *weapon, bool bCurrentlySelected, 
+		int wide, int tall, Color& clr );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: tf2 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( void );
+	
+	virtual void VidInit(void);
+
+	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 OnWeaponPickup( C_BaseCombatWeapon *pWeapon );
+
+	virtual void SelectWeapon( void );
+	
+	virtual C_BaseCombatWeapon	*GetSelectedWeapon( void );
+
+	virtual void OpenSelection( void );
+
+	virtual int	KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding );
+
+	virtual void HideSelection( void );
+
+protected:
+	virtual void OnTick();
+	virtual void ApplySchemeSettings(vgui::IScheme *pScheme);
+	virtual void ApplySettings( KeyValues *resourceData );
+private:
+
+	// Offensive
+	// Defensive
+	// General Purpose
+	enum
+	{
+		BUILD_OFFENSIVE = 0,
+		BUILD_DEFENSIVE,
+		BUILD_GENERAL_PURPOSE,
+
+		NUM_BUILD_MENUS,
+	};
+
+	enum
+	{
+		MAX_WEAPON_MENU_ITEMS = 7,
+		MAX_BUILD_MENU_ITEMS = 6,
+	};
+
+	void SetupWeaponMenu( WeaponMenu& menu, C_BaseCombatWeapon *activeItem, bool drawNumbers );
+	void SetupBuildMenu( WeaponMenu& menu, C_BaseCombatWeapon *activeItem );
+
+	void DrawBox( bool isbuildmenu, int x, int y, int wide, int tall, bool current, bool isvalid, float normalizedAlpha, int number );
+
+	void TranslateColor( float percent, Color& clr );
+
+	void	ShowBuildMenu( int buildmenu );
+	void ShowBuildMenu( WeaponMenu& buildMenu );
+	void	HideBuildMenu( void );
+	WeaponMenu&	GetActiveMenu();
+	int GetLowIndex( WeaponMenu& menu );
+	void WrapIndexToRange( int& index, int low, int high );
+	int FindSlotForHotKey( WeaponMenu& menu, int hotkey );
+	int FindNextSelectableWeaponInMenu( WeaponMenu& menu, int startindex, int direction );
+	int CountSelectableItems( WeaponMenu& menu );
+	CWeaponMenuItem *GetFirstSelectableWeapon( WeaponMenu& menu );
+	const char *GetBuildMenuName( int slot );
+	const char *GetBuildMenuMaterial( int slot );
+
+	void	SelectBuildMenuSlot( WeaponMenu& buildMenu );
+
+	void	CreateWeaponItemPanels();
+
+	void	ClearBuildMenu();
+	void	RebuildMenus();
+	void	AssignSlots( WeaponMenu& menu, int firstindex );
+	void	CollapseSingleItemBuildMenus();
+	
+	void	GetSlotInfo( const CWeaponMenuItem *w, C_BaseCombatWeapon *active, CSlotInfo& info );
+
+	int GetTeamIndex();
+
+	void	SetupIcons();
+
+	CPanelAnimationVar( float, m_flAlphaOverride, "Alpha", "255.0" );
+	CPanelAnimationVar( float, m_flSelectionAlphaOverride, "SelectionAlpha", "255.0" );
+
+	CPanelAnimationVar( Color, m_TextColor, "TextColor", "SelectionTextFg" );
+	CPanelAnimationVar( Color, m_InvalidActiveColor, "InvalidActiveColor", "InvalidActiveSlotFg" );
+	CPanelAnimationVar( Color, m_InvalidActiveTextColor, "InvalidActiveTextColor", "InvalidActiveSlotText" );
+	CPanelAnimationVar( Color, m_InvalidColor, "InvalidColor", "InvalidSlotFg" );
+	CPanelAnimationVar( Color, m_InvalidTextColor, "InvalidTextColor", "InvalidSlotText" );
+	CPanelAnimationVar( Color, m_OtherColor, "OtherColor", "OtherSlotFg" );
+	CPanelAnimationVar( Color, m_OtherTextColor, "OtherTextColor", "OtherSlotText" );
+	CPanelAnimationVar( Color, m_AmmoNormalColor, "AmmoNormalColor", "AmmoNormal" );
+	CPanelAnimationVar( Color, m_AmmoCautionColor, "AmmoCautionColor", "AmmoCaution" );
+
+	CPanelAnimationVar( vgui::HFont, m_hNumberFont, "NumberFont", "HudSelectionNumbers" );
+	CPanelAnimationVar( vgui::HFont, m_hTextFont, "TextFont", "HudSelectionText" );
+	CPanelAnimationVar( vgui::HFont, m_hTextFontSmall, "TextFontSmall", "HudSelectionTextSmall" );
+	CPanelAnimationVar( vgui::HFont, m_hPriceFont, "PriceFont", "HudSelectionTextSmall" );
+
+	CPanelAnimationVar( float, m_flGrowFraction, "GrowFraction", "0.0" );
+
+	CHandle<C_BaseCombatWeapon> m_hLastPickedUpWeapon;
+	bool		m_bInSelectionMode;
+	int			m_nLastBuildTick;
+	bool		m_bInBuildMenu;
+	int			m_nActiveBuildMenu;
+
+	WeaponMenu	*m_PreviousBuildMenu;
+
+	WeaponMenu m_Weapons;
+	WeaponMenu m_BuildObjects[ NUM_BUILD_MENUS ];
+
+	CHudWeaponItemPanel *m_pWeaponPanels[ MAX_WEAPON_MENU_ITEMS ];
+	CHudWeaponItemPanel *m_pBuildPanels[ MAX_BUILD_MENU_ITEMS ];
+
+	CWeaponMenuItem *FindWeapon( WeaponMenu& menu, int hotkey );
+
+	friend class CHudWeaponItemPanel;
+};
+
+DECLARE_HUDELEMENT( CHudWeaponSelection );
+
+void CHudWeaponSelection::VidInit(void)
+{
+	CBaseHudWeaponSelection::VidInit();
+
+	SetupIcons();
+}
+
+void CHudWeaponSelection::SetupIcons()
+{
+	int i;
+
+	for ( i = 0; i < MAX_WEAPON_MENU_ITEMS; i++ )
+	{
+		m_pWeaponPanels[ i ]->SetupIcons();
+	}
+
+	for ( i = 0; i < MAX_BUILD_MENU_ITEMS; i++ )
+	{
+		m_pBuildPanels[ i ]->SetupIcons();
+	}
+}
+
+
+void CHudWeaponSelection::AssignSlots( WeaponMenu& menu, int firstindex )
+{
+	int slot = firstindex;
+
+	for ( int i = menu.items.FirstInorder(); i != menu.items.InvalidIndex(); i = menu.items.NextInorder( i ) )
+	{
+		CWeaponMenuItem *w = &menu.items[ i ];
+		w->hotkey = slot++;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::CreateWeaponItemPanels()
+{
+	int i;
+	char sz[ 128 ];
+	for ( i = 0; i < MAX_WEAPON_MENU_ITEMS; i++ )
+	{
+		Q_snprintf( sz, sizeof( sz ), "WeaponMenu%i", i + 1 );
+		m_pWeaponPanels[ i ] = new CHudWeaponItemPanel( this, sz );
+		m_pWeaponPanels[ i ]->m_nSlotNumber = i;
+		m_pWeaponPanels[ i ]->m_bBuildMenu = false;
+	}
+
+	for ( i = 0; i < MAX_BUILD_MENU_ITEMS; i++ )
+	{
+		Q_snprintf( sz, sizeof( sz ), "BuildMenu%i", i + 1 );
+		m_pBuildPanels[ i ] = new CHudWeaponItemPanel( this, sz );
+		m_pBuildPanels[ i ]->m_nSlotNumber = i;
+		m_pBuildPanels[ i ]->m_bBuildMenu = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::RebuildMenus()
+{
+	int i;
+	
+	if ( gpGlobals->tickcount == m_nLastBuildTick )
+		return;
+
+	m_nLastBuildTick =  gpGlobals->tickcount;
+
+
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+
+	m_Weapons.items.RemoveAll();
+	for ( i = 0; i < NUM_BUILD_MENUS; i++ )
+	{
+		m_BuildObjects[ i ].items.RemoveAll();
+	}
+
+	CWeaponMenuItem item;
+
+	int c = MAX_WEAPONS;
+	for ( i = 0; i < c; i++ )
+	{
+		C_BaseCombatWeapon *pWeapon = player->GetWeapon(  i );
+		if ( !pWeapon )
+		{
+			continue;
+		}
+
+		if ( !pWeapon->VisibleInWeaponSelection() )
+		{
+			continue;
+		}
+
+		item.priority = pWeapon->GetSlot() * 10 + pWeapon->GetPosition();
+		item.buildslot = false;
+		item.openbuildmenu = -1;
+		item.weapon = pWeapon;
+		item.isvalidmenuitem = true;
+
+		if ( dynamic_cast< C_WeaponObjectSelection * >( pWeapon ) )
+		{
+			// HACK
+			int firstbuildslot = 4;
+			int whichBuildMenu = clamp( pWeapon->GetSlot() - firstbuildslot, 0, NUM_BUILD_MENUS - 1 );
+
+			m_BuildObjects[ whichBuildMenu ].items.Insert( item );
+		}
+		else
+		{
+			m_Weapons.items.Insert( item );
+		}
+	}
+
+	while ( m_Weapons.items.Count() < 3 )
+	{
+		// Add build item menus
+		item.priority = 999;
+		item.buildslot = false;
+		item.openbuildmenu = -1;
+		item.weapon = NULL;
+		item.isvalidmenuitem = false;
+		m_Weapons.items.Insert( item );
+
+		m_Weapons.m_bIsBuildMenu = false;
+	}
+
+	for ( i = 0; i < NUM_BUILD_MENUS; i++ )
+	{
+		// Add build item menus
+		item.priority = 999;
+		item.buildslot = true;
+		item.openbuildmenu = i;
+		item.weapon = NULL;
+		item.isvalidmenuitem = CountSelectableItems( m_BuildObjects[ i ] ) > 0 ? true : false;
+		m_Weapons.items.Insert( item );
+	
+		// Assign build menu slots
+		AssignSlots( m_BuildObjects[ i ], 0 );
+	
+		m_BuildObjects[ i ].m_bIsBuildMenu = true;
+	}
+
+	// Now walk in order and assign hotkeys
+	AssignSlots( m_Weapons, 1 );
+
+	// Merge single item build menus into main menu
+	CollapseSingleItemBuildMenus();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::CollapseSingleItemBuildMenus()
+{
+	for ( int i = 0; i < NUM_BUILD_MENUS; i++ )
+	{
+		int count = m_BuildObjects[ i ].items.Count();
+
+		// Not an issue
+		if ( count > 1 )
+			continue;
+
+		CWeaponMenuItem *mainItem = FindWeapon( m_Weapons, 4 + i );
+		if ( !mainItem )
+			continue;
+
+		// It's empty, need to make main item a disabled slot
+		if ( count == 0 )
+		{
+			// Add build item menus
+			mainItem->isvalidmenuitem = false;
+		}
+		else
+		{
+			// Only one item in sub menu, copy it over
+			CWeaponMenuItem *buildItem = &m_BuildObjects[ i ].items[ 0 ];
+			mainItem->buildslot = false;
+			mainItem->openbuildmenu = -1;
+			mainItem->isvalidmenuitem = true;
+			mainItem->weapon = buildItem->weapon;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::ClearBuildMenu()
+{
+	for ( int i = 0; i < MAX_BUILD_MENU_ITEMS; i++ )
+	{
+		m_pBuildPanels[ i ]->m_bInUse = false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CHudWeaponSelection::CHudWeaponSelection(const char *pElementName ) : 
+	CBaseHudWeaponSelection(pElementName), BaseClass(NULL, "HudWeaponSelection")
+{
+	vgui::Panel *pParent = g_pClientMode->GetViewport();
+	SetParent( pParent );
+
+	m_nLastBuildTick = -1;
+
+	m_hNumberFont = NULL;
+	m_bInSelectionMode = false;
+
+	CreateWeaponItemPanels();
+
+	vgui::ivgui()->AddTickSignal( GetVPanel() );
+}
+
+void CHudWeaponSelection::ShowBuildMenu( int buildmenu )
+{
+	bool wasinbuild = m_bInBuildMenu;
+
+	int mainItem = buildmenu + 4;
+	m_Weapons.SetActiveItem( mainItem );
+
+	m_bInBuildMenu = true;
+	m_nActiveBuildMenu = buildmenu;
+	GetActiveMenu().SetActiveItem( GetLowIndex( GetActiveMenu() ) );
+
+	if ( !wasinbuild )
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponOpenBuildSubMenu");
+
+		switch ( buildmenu )
+		{
+		default:
+		case BUILD_OFFENSIVE:
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponOpenBuildOffensive");
+			break;
+		case BUILD_DEFENSIVE:
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponOpenBuildDefensive");
+			break;
+		case BUILD_GENERAL_PURPOSE:
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponOpenBuildGeneral");
+			break;
+		}
+	}
+}
+
+void CHudWeaponSelection::ShowBuildMenu( WeaponMenu& buildMenu )
+{
+	int c = m_Weapons.items.Count();
+	for ( int i = 0; i < c; i++ )
+	{
+		CWeaponMenuItem *item = &m_Weapons.items[ i ];
+		if ( !item || !item->buildslot )
+			continue;
+
+		WeaponMenu &menu = m_BuildObjects[ item->openbuildmenu ];
+		if ( &menu == &buildMenu )
+		{
+			ShowBuildMenu( item->openbuildmenu );
+			return;
+		}
+	}
+
+	Assert( 0 );
+}
+
+void CHudWeaponSelection::HideBuildMenu( void )
+{
+	bool wasinbuild = m_bInBuildMenu;
+
+	GetActiveMenu().SetActiveItem( GetLowIndex( GetActiveMenu() ) );
+	m_bInBuildMenu = false;
+
+	if ( wasinbuild )
+	{
+		g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponCloseBuildSubMenu");
+	}
+
+	m_nActiveBuildMenu = -1;
+}
+
+WeaponMenu&	CHudWeaponSelection::GetActiveMenu()
+{
+	return m_bInBuildMenu ? m_BuildObjects[ m_nActiveBuildMenu ] : m_Weapons;
+}
+
+int CHudWeaponSelection::GetLowIndex( WeaponMenu& menu )
+{
+	if ( menu.items.Count() == 0 )
+		return 1;
+
+	int lowindex =  menu.items[  menu.items.FirstInorder() ].hotkey;
+	return lowindex;
+}
+
+void CHudWeaponSelection::WrapIndexToRange( int& index, int low, int high )
+{
+	int delta = ( high - low ) + 1;
+	while ( index < low )
+	{
+		index += delta;
+	}
+	
+	while ( index > high )
+	{
+		index -= delta;
+	}
+}
+
+int CHudWeaponSelection::FindSlotForHotKey( WeaponMenu& menu, int hotkey )
+{
+	int count		= menu.items.Count();
+	for ( int i = 0; i < count;i++ )
+	{
+		if ( menu.items[ i ].hotkey == hotkey )
+			return i;
+	}
+
+	return 0;
+}
+
+int CHudWeaponSelection::FindNextSelectableWeaponInMenu( WeaponMenu& menu, int startindex, int direction )
+{
+	direction = direction > 0 ? 1 : -1;
+
+	int count		= menu.items.Count();
+	int lowindex	= GetLowIndex( menu );
+	int highindex	= lowindex + count - 1;
+
+	for ( int offset = 1; offset <= count; offset++ )
+	{
+		int current = startindex + offset * direction;
+		
+		WrapIndexToRange( current, lowindex, highindex );
+
+		//int slot = FindSlotForHotKey( menu, current );
+
+		//C_BaseCombatWeapon *w = menu.items[ slot ].weapon;
+		//if ( w && !w->CanBeSelected() )
+		//	continue;
+
+		return current;
+	}
+
+	return startindex;
+}
+
+int CHudWeaponSelection::CountSelectableItems( WeaponMenu& menu )
+{
+	int count = 0;
+	int c = menu.items.Count();
+	for ( int i = 0; i < c; i++ )
+	{
+		C_BaseCombatWeapon *w = menu.items[ i ].weapon;
+		if ( w && w->CanBeSelected() )
+		{
+			count++;
+		}
+	}
+	return count;
+}
+
+CWeaponMenuItem *CHudWeaponSelection::GetFirstSelectableWeapon( WeaponMenu& menu )
+{
+	int c = menu.items.Count();
+	for ( int i = 0; i < c; i++ )
+	{
+		C_BaseCombatWeapon *w = menu.items[ i ].weapon;
+		if ( w && w->CanBeSelected() )
+		{
+			return &menu.items[ i ];
+		}
+	}
+	return NULL;
+}
+
+const char *CHudWeaponSelection::GetBuildMenuName( int slot )
+{
+	switch ( slot )
+	{
+	default:
+	case BUILD_OFFENSIVE:
+		return "Offensive Object";
+	case BUILD_DEFENSIVE:
+		return "Defensive Object";
+	case BUILD_GENERAL_PURPOSE:
+		return "General Purpose";
+	}
+
+	return "General Purpose";
+}
+
+const char *CHudWeaponSelection::GetBuildMenuMaterial( int slot )
+{
+	switch ( slot )
+	{
+	default:
+	case BUILD_OFFENSIVE:
+		return "weapon_selection_offensive";
+	case BUILD_DEFENSIVE:
+		return "weapon_selection_defensive";
+	case BUILD_GENERAL_PURPOSE:
+		return "weapon_selection_general";
+	}
+
+	return "hud/menu/weapon_selection_general";
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: sets up display for showing weapon pickup
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::OnWeaponPickup( C_BaseCombatWeapon *pWeapon )
+{
+	// Nothing in TF2
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns true if the panel should draw
+//-----------------------------------------------------------------------------
+bool CHudWeaponSelection::ShouldDraw()
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pPlayer || pPlayer->GetPlayerClass() == NULL )
+	{
+		if ( IsInSelectionMode() )
+		{
+			HideSelection();
+		}
+		return false;
+	}
+	
+	bool bret = CBaseHudWeaponSelection::ShouldDraw();
+	
+	if ( !bret )
+		return false;
+
+	return ( m_bSelectionVisible || ( m_flGrowFraction > 0.0f ) ) ? true : false;
+}
+
+void CHudWeaponSelection::TranslateColor( float percent, Color& clr )
+{
+	if ( percent >= 1.0f )
+		return;
+
+	if ( percent <= 0.75f )
+	{
+		clr = Color( 0, 0, 0, 0 );
+	}
+	else
+	{
+		float frac = ( percent - 0.75f ) / 0.25f;
+
+		clr = Color( clr[0] * frac,
+			clr[1] * frac,
+			clr[2] * frac,
+			clr[3] * frac );
+	}
+}
+
+void CHudWeaponSelection::GetSlotInfo( const CWeaponMenuItem *w, C_BaseCombatWeapon *active, CSlotInfo& info )
+{
+	if ( w->buildslot )
+	{
+		info.active = !m_bInBuildMenu && ( GetActiveMenu().GetActiveItem() == w->hotkey );
+		info.valid = w->isvalidmenuitem;
+		info.icon = gHUD.GetIcon( GetBuildMenuMaterial( w->openbuildmenu ) );
+		info.drawAmmo = false;
+		info.ammoCaution = false;
+		Q_snprintf( info.printname, sizeof( info.printname ), GetBuildMenuName( w->openbuildmenu ) );
+		info.weapon = NULL;
+	}
+	else if ( !w->weapon )
+	{
+		info.active =false;
+		info.valid = false;
+		info.icon = NULL;
+		info.drawAmmo = false;
+		info.ammoCaution = false;
+		info.printname[0]=0;
+		info.weapon = NULL;
+	}
+	else
+	{
+		C_BaseCombatWeapon *pWeapon = w->weapon;
+		Assert( pWeapon );
+
+		info.active = active == pWeapon;
+		info.valid = pWeapon->CanBeSelected();
+		info.icon = info.active ? pWeapon->GetSpriteActive() : pWeapon->GetSpriteInactive();
+
+		info.drawAmmo = false;
+		info.ammoPerc = 1.0f;
+		// Don't know the max ammo, so if I don't use clips, just go red on no ammo left
+		if ( pWeapon->UsesClipsForAmmo1() || pWeapon->HasAmmo() )
+		{
+			info.ammoPerc = 1.0f - ( (float) pWeapon->Clip1() ) / ( (float)pWeapon->GetMaxClip1() );
+			info.drawAmmo = true;
+		}
+		info.ammoCaution = ( info.ammoPerc >= CLIP_PERC_THRESHOLD ) ? true : false;
+
+		Q_snprintf( info.printname, sizeof( info.printname ), "%s", pWeapon->GetPrintName() );
+		info.weapon = pWeapon;
+	}
+
+	strupr(info.printname);
+}
+
+void CHudWeaponSelection::SetupWeaponMenu( WeaponMenu& menu, C_BaseCombatWeapon *activeItem, bool drawNumbers )
+{
+	int panelPosition = 0;
+	for ( int item = menu.items.FirstInorder(); item != menu.items.InvalidIndex() && panelPosition < MAX_WEAPON_MENU_ITEMS; item = menu.items.NextInorder( item ) )
+	{
+		CWeaponMenuItem *w = &menu.items[ item ];
+		Assert( w );
+
+		CSlotInfo info;
+		GetSlotInfo( w, activeItem, info );
+
+		CHudWeaponItemPanel *panel = m_pWeaponPanels[ panelPosition++ ];
+		if ( !panel )
+		{
+			Assert( 0 );
+			continue;
+		}
+
+		panel->m_bInUse		= true;
+		panel->info			= info;
+		panel->menuItem		= *w;
+		panel->m_bDrawNumbers = drawNumbers;
+	}
+
+	for ( ; panelPosition < MAX_WEAPON_MENU_ITEMS; )
+	{
+		CHudWeaponItemPanel *panel = m_pWeaponPanels[ panelPosition++ ];
+		panel->m_bInUse = false;
+	}
+}
+
+void CHudWeaponSelection::SetupBuildMenu( WeaponMenu& menu, C_BaseCombatWeapon *activeItem )
+{
+	int panelPosition = 0;
+	for ( int item = menu.items.FirstInorder(); item != menu.items.InvalidIndex() && panelPosition < MAX_BUILD_MENU_ITEMS; item = menu.items.NextInorder( item ) )
+	{
+		CWeaponMenuItem *w = &menu.items[ item ];
+		Assert( w );
+
+		CSlotInfo info;
+		GetSlotInfo( w, activeItem, info );
+
+		CHudWeaponItemPanel *panel = m_pBuildPanels[ panelPosition++ ];
+		if ( !panel )
+		{
+			Assert( 0 );
+			continue;
+		}
+
+		panel->m_bInUse		= true;
+		panel->info			= info;
+		panel->menuItem		= *w;
+		panel->m_bDrawNumbers = false;
+	}
+
+	for ( ; panelPosition < MAX_BUILD_MENU_ITEMS; )
+	{
+		CHudWeaponItemPanel *panel = m_pBuildPanels[ panelPosition++ ];
+		panel->m_bInUse = false;
+	}
+}
+
+void CHudWeaponSelection::OnTick()
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	RebuildMenus();
+
+	int x, y;
+	GetPos(x, y);
+
+	C_BaseCombatWeapon *wpn = GetSelectedWeapon();
+
+	// Draw main menu
+	SetupWeaponMenu( m_Weapons, wpn, true );
+	
+	CWeaponMenuItem *item = FindWeapon( GetActiveMenu(), GetActiveMenu().GetActiveItem() );
+
+	WeaponMenu* otherMenu = NULL;
+	int buildMenuNumber=  0;
+
+	// Drawing build menu
+	if ( m_bInBuildMenu )
+	{
+		otherMenu = &m_BuildObjects[ m_nActiveBuildMenu ];
+		buildMenuNumber = m_nActiveBuildMenu;
+	}
+	else if ( item && item->buildslot && item->hotkey == GetActiveMenu().GetActiveItem() )
+	{
+		otherMenu = &m_BuildObjects[ item->openbuildmenu ];
+		buildMenuNumber = item->openbuildmenu;
+	}
+	else if ( m_nActiveBuildMenu >= 0 )
+	{
+		otherMenu = &m_BuildObjects[ m_nActiveBuildMenu ];
+		buildMenuNumber = m_nActiveBuildMenu;
+	}
+
+	if ( otherMenu )
+	{
+		SetupBuildMenu( *otherMenu, wpn );
+	}
+	else
+	{
+		ClearBuildMenu();
+	}
+
+	if ( otherMenu != m_PreviousBuildMenu )
+	{
+		m_PreviousBuildMenu = otherMenu;
+
+		if ( otherMenu )
+		{
+			switch ( buildMenuNumber )
+			{
+			default:
+			case BUILD_OFFENSIVE:
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponOpenBuildOffensive");
+				break;
+			case BUILD_DEFENSIVE:
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponOpenBuildDefensive");
+				break;
+			case BUILD_GENERAL_PURPOSE:
+				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponOpenBuildGeneral");
+				break;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: hud scheme settings
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::ApplySchemeSettings(vgui::IScheme *pScheme)
+{
+	BaseClass::ApplySchemeSettings(pScheme);
+	SetPaintBackgroundEnabled(false);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Select the next item in the weapon list
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::CycleToNextWeapon( void )
+{
+	// Get the local player.
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pPlayer || !pPlayer->GetPlayerClass() )
+		return;
+
+	// Make it active
+	bool justopened = false;
+	if ( !IsInSelectionMode() )
+	{
+		OpenSelection();
+		justopened = true;
+	}
+
+	RebuildMenus();
+
+	WeaponMenu& menu = GetActiveMenu();
+	int c = menu.items.Count();
+	if ( c != 0 && !justopened )
+	{
+		GetActiveMenu().SetActiveItem( FindNextSelectableWeaponInMenu( menu, GetActiveMenu().GetActiveItem(), +1 ) );
+	}
+
+	// Play the "cycle to next weapon" sound
+	pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Selects the previous item in the menu
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::CycleToPrevWeapon( void )
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pPlayer || !pPlayer->GetPlayerClass() )
+		return;
+
+	// Make it active
+	bool justopened = false;
+	if ( !IsInSelectionMode() )
+	{
+		OpenSelection();
+		justopened = true;
+	}
+
+	RebuildMenus();
+
+	WeaponMenu& menu = GetActiveMenu();
+	int c = menu.items.Count();
+	if ( c != 0 && !justopened )
+	{
+		GetActiveMenu().SetActiveItem( FindNextSelectableWeaponInMenu( menu, GetActiveMenu().GetActiveItem(), -1 ) );
+	}
+
+	// Play the "cycle to next weapon" sound
+	pPlayer->EmitSound( "Player.WeaponSelectionMoveSlot" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Switches the last weapon the player was using
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::SwitchToLastWeapon( void )
+{
+	// Get the player's last weapon
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	// If we're currently using the builder weapon, switch to the weapon we were
+	// using before we started using it.
+	C_BaseCombatWeapon *pActiveWeapon = pPlayer->GetActiveWeapon();
+	// Handle the twohanded weapon container
+	CWeaponTwoHandedContainer *pContainer = dynamic_cast< CWeaponTwoHandedContainer * >( pActiveWeapon );
+	if ( pContainer )
+	{
+		pActiveWeapon = pContainer->GetLeftWeapon();
+	}
+
+	if ( dynamic_cast< C_WeaponBuilder* >( pActiveWeapon ) )
+	{
+		::input->MakeWeaponSelection( pPlayer->GetLastWeaponBeforeObject() );
+		return;
+	}
+
+	// Switch to previous weapon normally
+	::input->MakeWeaponSelection( pPlayer->GetLastWeapon() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponMenuItem *CHudWeaponSelection::FindWeapon( WeaponMenu& menu, int hotkey )
+{
+	RebuildMenus();
+
+	int c = menu.items.Count();
+
+	for ( int i = 0; i < c; i++ )
+	{
+		CWeaponMenuItem *item = &menu.items[ i ];
+		if ( item->hotkey == hotkey )
+			return item;
+	}
+
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+C_BaseCombatWeapon *CHudWeaponSelection::GetWeaponInSlot( int iSlot, int iSlotPos )
+{
+	CWeaponMenuItem *item = FindWeapon( GetActiveMenu(), iSlot );
+	if ( item )
+	{
+		return item->weapon;
+	}
+
+	return NULL;
+}
+
+C_BaseCombatWeapon *CHudWeaponSelection::GetSelectedWeapon( void )
+{
+	RebuildMenus();
+
+	return GetWeaponInSlot( GetActiveMenu().GetActiveItem(), 0 );
+}
+
+void CHudWeaponSelection::SelectBuildMenuSlot( WeaponMenu& buildMenu )
+{
+	// Get the local player.
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	int numSelectable = CountSelectableItems( buildMenu );
+
+	if ( numSelectable >= 1 )
+	{
+		// Single item, just fast switch to it
+		CWeaponMenuItem *fastSwitchItem = GetFirstSelectableWeapon( buildMenu );
+		C_BaseCombatWeapon *w = fastSwitchItem ? fastSwitchItem->weapon : NULL;
+
+		Assert( w && w->CanBeSelected() );
+		if ( 0 && numSelectable == 1 && w && w->CanBeSelected() )
+		{
+			ShowBuildMenu( buildMenu );
+
+			m_hSelectedWeapon = w;
+			GetActiveMenu().SetActiveItem( fastSwitchItem->hotkey );
+
+			// There's only one active item in bucket, so change directly to weapon
+			SetWeaponSelected();
+			engine->ClientCmd( "cancelselect\n" );
+		}
+		else
+		{
+			// Play the "open weapon selection" sound
+			pPlayer->EmitSound( "Player.WeaponSelectionOpen" );
+
+			ShowBuildMenu( buildMenu );
+		}
+	}
+	else
+	{
+		pPlayer->EmitSound( "Player.DenyWeaponSelection" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Weapon selection code
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::SelectWeaponSlot( int iSlot )
+{
+	// Get the local player.
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	// Make sure the player's allowed to switch weapons
+	if ( pPlayer->IsAllowedToSwitchWeapons() == false )
+		return;
+
+	// Make it active
+	if ( !IsInSelectionMode() )
+	{
+		OpenSelection();
+	}
+
+	RebuildMenus();
+	CWeaponMenuItem *item = FindWeapon( GetActiveMenu(), iSlot );
+
+	C_BaseCombatWeapon *weapon = item ? item->weapon : NULL;
+
+	if ( item && item->buildslot )
+	{
+		SelectBuildMenuSlot( m_BuildObjects[ item->openbuildmenu ] );
+		return;
+	}
+
+	if ( m_bInBuildMenu )
+	{
+		CWeaponMenuItem *mainItem = FindWeapon( m_Weapons, iSlot );
+		if ( mainItem )
+		{
+			if ( mainItem->buildslot )
+			{
+				if ( mainItem->openbuildmenu == m_nActiveBuildMenu )
+				{
+					CycleToNextWeapon();
+				}
+				else
+				{
+					SelectBuildMenuSlot(  m_BuildObjects[ mainItem->openbuildmenu ] );
+				}
+			}
+			else if ( mainItem->weapon )
+			{
+				// Play the "open weapon selection" sound
+				pPlayer->EmitSound( "Player.WeaponSelectionOpen" );
+
+				m_bInBuildMenu = false;
+				m_hSelectedWeapon = mainItem->weapon;
+				GetActiveMenu().SetActiveItem( mainItem->hotkey );
+
+				// Check for fast weapon switch mode
+				if ( GetSelectedWeapon() && GetSelectedWeapon()->CanBeSelected() )
+				{	
+					// There's only one active item in bucket, so change directly to weapon
+					SetWeaponSelected();
+					engine->ClientCmd( "cancelselect\n" );
+					return;
+				}
+			}
+		}
+		return;
+	}
+
+	if ( item && weapon )
+	{
+		// Play the "open weapon selection" sound
+		pPlayer->EmitSound( "Player.WeaponSelectionOpen" );
+
+		if ( !weapon->CanBeSelected() )
+		{
+			if ( GetActiveMenu().GetActiveItem() == item->hotkey )
+			{
+				pPlayer->EmitSound( "Player.DenyWeaponSelection" );
+			}
+		}
+
+		m_hSelectedWeapon = weapon;
+		GetActiveMenu().SetActiveItem( item->hotkey );
+
+		// Check for fast weapon switch mode
+		if ( GetSelectedWeapon() && GetSelectedWeapon()->CanBeSelected() )
+		{	
+			// There's only one active item in bucket, so change directly to weapon
+			SetWeaponSelected();
+			engine->ClientCmd( "cancelselect\n" );
+			return;
+		}
+	}
+	else
+	{
+		pPlayer->EmitSound( "Player.DenyWeaponSelection" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Player has chosen to draw the currently selected weapon
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::SelectWeapon( void )
+{
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+
+	CWeaponMenuItem *item = FindWeapon( GetActiveMenu(), GetActiveMenu().GetActiveItem() );
+	if ( !item )
+	{
+		engine->ClientCmd( "cancelselect\n" );
+		return;
+	}
+
+	if ( item->buildslot )
+	{
+		SelectBuildMenuSlot(  m_BuildObjects[ item->openbuildmenu ] );
+		return;
+	}
+
+	CBaseHudWeaponSelection::SelectWeapon();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : down - 
+//			keynum - 
+//			*pszCurrentBinding - 
+//-----------------------------------------------------------------------------
+int	CHudWeaponSelection::KeyInput( int down, ButtonCode_t keynum, const char *pszCurrentBinding )
+{
+	if ( !down )
+		return 1;
+
+	if ( keynum != KEY_ESCAPE )
+		return 1;
+
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( !player )
+		return 1;
+
+	if ( !IsInSelectionMode() )
+		return 1;
+
+	if ( !m_bInBuildMenu )
+	{
+		engine->ClientCmd( "cancelselect\n" );
+		return 0;
+	}
+
+	// Play the "open weapon selection" sound
+	player->EmitSound( "Player.WeaponSelectionOpen" );
+
+	HideBuildMenu();
+
+	// Swallow the key
+	return 0;
+}
+
+void CHudWeaponSelection::OpenSelection( void )
+{
+	HideBuildMenu();
+	m_nActiveBuildMenu = -1;
+	
+	CBaseHudWeaponSelection::OpenSelection();
+	
+	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponOpenWeaponMenu");
+}
+
+void CHudWeaponSelection::HideSelection( void )
+{
+	CBaseHudWeaponSelection::HideSelection();
+	
+	if ( m_bInBuildMenu )
+	{
+		HideBuildMenu();
+	}
+
+	g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("WeaponCloseWeaponMenu");
+}
+
+int CHudWeaponSelection::GetTeamIndex()
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if(!pPlayer)
+		return HUMAN_WEAPON_SELECTION;
+	int team = pPlayer->GetTeamNumber();
+	if ( !team )
+		return HUMAN_WEAPON_SELECTION;
+
+	bool human = ( team == TEAM_HUMANS ) ? true : false;
+	return human ? HUMAN_WEAPON_SELECTION : ALIEN_WEAPON_SELECTION;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: serializes settings from a resource data container
+//-----------------------------------------------------------------------------
+void CHudWeaponSelection::ApplySettings( KeyValues *resourceData )
+{
+	BaseClass::ApplySettings( resourceData );
+
+	// loop through all the keys, applying them wherever
+	for (KeyValues *controlKeys = resourceData->GetFirstSubKey(); controlKeys != NULL; controlKeys = controlKeys->GetNextKey())
+	{
+		// Skip keys that are atomic..
+		if (controlKeys->GetDataType() != KeyValues::TYPE_NONE)
+			continue;
+
+		Panel *panel = FindChildByName( controlKeys->GetName() );
+		if ( !panel )
+			continue;
+
+		// apply the settings
+		panel->ApplySettings(controlKeys);
+	}
+}
+
+
+
+
+
+
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			*panelName - 
+//-----------------------------------------------------------------------------
+CHudWeaponItemPanel::CHudWeaponItemPanel( vgui::Panel *parent, const char *panelName )
+	: BaseClass( parent, panelName )
+{
+	m_bInUse = false;
+	m_bDrawNumbers = false;
+	m_nSlotNumber = 0;
+
+	// Copies of data
+	memset( &info, 0, sizeof( info ) );
+	memset( &menuItem, 0, sizeof( menuItem ) );
+
+	memset( m_BackgroundIcons, 0, sizeof( m_BackgroundIcons ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *scheme - 
+//-----------------------------------------------------------------------------
+void CHudWeaponItemPanel::ApplySchemeSettings( vgui::IScheme *scheme )
+{
+	BaseClass::ApplySchemeSettings( scheme );
+	SetPaintBackgroundEnabled( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponItemPanel::Paint()
+{
+	if ( !m_bInUse )
+		return;
+
+	CHudWeaponSelection *selection = static_cast< CHudWeaponSelection * >( GetParent() );
+	if ( !selection )
+		return;
+
+	int wide, tall;
+	GetSize( wide, tall );
+
+	float transparencyfrac = m_flGrowFraction;
+
+	float sizefracw = m_flGrowFraction;
+	float sizefrach = m_flGrowFraction;
+	float sizefrac = m_flGrowFraction;
+
+	bool buildMenu = m_bBuildMenu;
+
+	bool isactive = info.active;
+	bool isvalid = 	info.valid;
+
+	Color iconColor = selection->GetFgColor();
+	Color textColor  = selection->m_TextColor;
+	if ( isactive )
+	{
+		if ( !isvalid )
+		{
+			iconColor = selection->m_InvalidActiveColor;
+			textColor = selection->m_InvalidActiveTextColor;
+		}
+	}
+	else
+	{
+		if ( isvalid )
+		{
+			iconColor = selection->m_OtherColor;
+			textColor = selection->m_OtherTextColor;
+		}
+		else
+		{
+			iconColor = selection->m_InvalidColor;
+			textColor = selection->m_InvalidTextColor;
+		}
+	}
+
+	Color ammoColor = info.ammoCaution ? selection->m_AmmoCautionColor : selection->m_AmmoNormalColor;
+
+	TranslateColor( transparencyfrac, iconColor );
+	TranslateColor( transparencyfrac, textColor );
+	TranslateColor( transparencyfrac, ammoColor );
+
+	// Draw box
+	DrawBox( buildMenu, 0, 0, wide, tall, isactive, isvalid, m_flGrowFraction * 255, m_bDrawNumbers ? menuItem.hotkey : -1 );
+
+	// icons use old system, drawing in screen space
+	int iconXPos = m_flIconXPos;
+	int iconYPos = m_flIconYPos;
+	int iconWide = m_flIconWidth;
+	int iconTall = m_flIconHeight;
+
+	if ( info.icon )
+	{
+		info.icon->DrawSelf( sizefracw * iconXPos, sizefrach * iconYPos, sizefracw * iconWide, sizefrach * iconTall,
+			iconColor ); 
+	}
+
+	surface()->DrawSetTextColor( textColor );
+	HFont textFont = sizefrac < 1.0 ? selection->m_hTextFontSmall : selection->m_hTextFont;
+	surface()->DrawSetTextFont( textFont );
+	//int slen = UTIL_ComputeStringWidth( textFont, info.printname ); 
+	int charCount = Q_strlen( info.printname );
+
+	int textYPos = m_flTextYPos;
+	int textXPos = m_flTextXPos;
+
+	surface()->DrawSetTextPos( sizefracw * textXPos, sizefrach * textYPos );
+	for (char *pch = info.printname; charCount > 0; pch++, charCount--)
+	{
+		surface()->DrawUnicodeChar(*pch);
+	}
+
+	if ( info.drawAmmo )
+	{
+		int ammoBarX = m_flAmmoBarX;
+		int ammoBarWide = m_flAmmoBarWide;
+
+		// Draw the clip ratio bar
+		gHUD.DrawProgressBar( 
+			sizefracw * ammoBarX, sizefrach * iconYPos, 
+			sizefracw * ammoBarWide, sizefrach * iconTall, info.ammoPerc, 
+			ammoColor, CHud::HUDPB_VERTICAL );
+	}
+
+	// Let the weapon draw stuff too
+	if ( info.weapon )
+	{
+		C_WeaponObjectSelection *selectionWeapon = dynamic_cast< C_WeaponObjectSelection * >( info.weapon.Get() );
+		if ( selectionWeapon )
+		{
+			OnWeaponSelectionDrawn( selection, selectionWeapon, isactive, wide, tall, textColor );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: We've just been drawn in the weapon selection
+//-----------------------------------------------------------------------------
+void CHudWeaponItemPanel::OnWeaponSelectionDrawn( CHudWeaponSelection *selection, C_WeaponObjectSelection *weapon, 
+	bool bCurrentlySelected, int wide, int tall, Color& clr )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( weapon->GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// Draw our resource cost
+	int	fontHeight = vgui::surface()->GetFontTall( selection->m_hPriceFont );
+	int iCost = CalculateObjectCost( weapon->GetSubType(),  pOwner->GetNumObjects(weapon->GetSubType()), pOwner->GetTeamNumber() );
+
+	int x = wide - m_flPriceXEndPos;
+	int y = tall - m_flPriceYEndPos - fontHeight;
+
+	char text[ 32 ];
+	Q_snprintf( text, sizeof( text ), "%i", iCost );
+
+	// Compute pixels needed so we can right justify it
+	int pixels = 0;
+	char *pch;
+	for (pch = text; *pch != 0; pch++)
+	{
+		pixels += vgui::surface()->GetCharacterWidth( selection->m_hPriceFont, *pch );
+	}
+
+	vgui::surface()->DrawSetTextFont( selection->m_hPriceFont );
+	vgui::surface()->DrawSetTextPos( x - pixels, y );
+	vgui::surface()->DrawSetTextColor( clr );
+	for ( pch = text; *pch; pch++ )
+	{
+		vgui::surface()->DrawUnicodeChar(*pch);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : percent - 
+//			clr - 
+//-----------------------------------------------------------------------------
+void CHudWeaponItemPanel::TranslateColor( float percent, Color& clr )
+{
+	if ( percent >= 1.0f )
+		return;
+
+	if ( percent <= 0.75f )
+	{
+		clr = Color( 0, 0, 0, 0 );
+	}
+	else
+	{
+		float frac = ( percent - 0.75f ) / 0.25f;
+
+		clr = Color( clr[0] * frac,
+			clr[1] * frac,
+			clr[2] * frac,
+			clr[3] * frac );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: draws a selection box
+//-----------------------------------------------------------------------------
+void CHudWeaponItemPanel::DrawBox( bool isbuildmenu, int x, int y, int wide, int tall, bool isactive, bool isvalid, float normalizedAlpha, int number )
+{
+	CHudWeaponSelection *selection = static_cast< CHudWeaponSelection * >( GetParent() );
+	if ( !selection )
+	{
+		Assert( 0 );
+		return;
+	}
+
+	int team = GetTeamIndex();
+
+	Color boxColor = Color( 255, 255, 255, 255 );
+	boxColor[3] *= ( normalizedAlpha / 255.0f );
+
+	Color numberColor = selection->m_TextColor;
+
+	CHudTexture *texture;
+	
+	texture = m_BackgroundIcons[ team ][ (int)IMAGE_BACKGROUND ];
+	if ( texture )
+	{
+		texture->DrawSelf( x, y, wide, tall, boxColor );
+	}
+
+	if ( isactive )
+	{
+		if ( !isvalid )
+		{
+			texture = m_BackgroundIcons[ team ][ (int)IMAGE_INVALID ];
+			if ( texture )
+			{
+				texture->DrawSelf( x, y, wide, tall, boxColor );
+			}
+
+			numberColor = selection->m_InvalidActiveColor;
+		}
+		else
+		{
+			texture = m_BackgroundIcons[ team ][ (int)IMAGE_CURRENT ];
+			if ( texture )
+			{
+				texture->DrawSelf( x, y, wide, tall, boxColor );
+			}
+
+			numberColor = selection->m_OtherColor;
+		}
+	}
+	else
+	{
+		if ( !isvalid )
+		{
+			numberColor = selection->m_InvalidColor;
+		}
+		else
+		{
+			numberColor = selection->m_OtherColor;
+		}
+	}
+
+	// draw the number
+	if (number >= 0)
+	{
+		numberColor[3] *= ( normalizedAlpha / 255.0f );
+		surface()->DrawSetTextColor(numberColor);
+		surface()->DrawSetTextFont(selection->m_hNumberFont);
+		wchar_t wch = '0' + number;
+		surface()->DrawSetTextPos(x + m_flSelectionNumberXPos, y + m_flSelectionNumberYPos);
+		surface()->DrawUnicodeChar(wch);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CHudWeaponItemPanel::GetTeamIndex()
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if(!pPlayer)
+		return HUMAN_WEAPON_SELECTION;
+	int team = pPlayer->GetTeamNumber();
+	if ( !team )
+		return HUMAN_WEAPON_SELECTION;
+
+	bool human = ( team == TEAM_HUMANS ) ? true : false;
+	return human ? HUMAN_WEAPON_SELECTION : ALIEN_WEAPON_SELECTION;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudWeaponItemPanel::SetupIcons()
+{
+	memset( m_BackgroundIcons, 0, sizeof( m_BackgroundIcons ) );
+
+	const char *menutypestr = m_bBuildMenu ? "build" : "selection";
+
+	for ( int team = 0; team < NUM_SLOT_TEAMS; team++ )
+	{
+		const char *teamtype = team == 0 ? "human" : "alien";
+
+		for ( int type = 0; type < NUM_MENU_TYPES; type++ )
+		{
+			const char *slottype = type == 0 ? "background" : type == 1 ? "current" : "invalid";
+
+			char sz[ 256 ];
+			Q_snprintf( sz, sizeof( sz ), "%s_weapon_%s_%s_%i",
+				teamtype, menutypestr, slottype, m_nSlotNumber + 1 );
+
+			m_BackgroundIcons[ team ][ type ] = gHUD.GetIcon( sz );;
+		}
+	}
+}
diff --git a/game/client/tf2/infiltratorcamomaterialproxy.cpp b/game/client/tf2/infiltratorcamomaterialproxy.cpp
new file mode 100644
index 0000000..9d099fe
--- /dev/null
+++ b/game/client/tf2/infiltratorcamomaterialproxy.cpp
@@ -0,0 +1,84 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "proxyentity.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialvar.h"
+#include "materialsystem/imaterialsystem.h"
+#include "c_basetfplayer.h"
+#include "c_tf_basecombatweapon.h"
+
+class CInfiltratorCamoMaterialProxy : public CEntityMaterialProxy
+{
+public:
+	CInfiltratorCamoMaterialProxy();
+	virtual ~CInfiltratorCamoMaterialProxy();
+	virtual bool Init( IMaterial *pMaterial, KeyValues* pKeyValues );
+	virtual void OnBind( C_BaseEntity *pC_BaseEntity );
+
+private:
+	IMaterialVar *m_CamoVar;
+};
+
+CInfiltratorCamoMaterialProxy::CInfiltratorCamoMaterialProxy()
+{
+	m_CamoVar = NULL;
+}
+
+CInfiltratorCamoMaterialProxy::~CInfiltratorCamoMaterialProxy()
+{
+}
+
+
+bool CInfiltratorCamoMaterialProxy::Init( IMaterial *pMaterial, KeyValues* pKeyValues  )
+{
+	bool foundVar;
+
+	m_CamoVar = pMaterial->FindVar( "$alpha", &foundVar, false );
+	if( !foundVar )
+	{
+		m_CamoVar = NULL;
+		return false;
+	}
+	return true;
+}
+
+void CInfiltratorCamoMaterialProxy::OnBind( C_BaseEntity *pEnt )
+{
+	if( !m_CamoVar )
+		return;
+
+	C_BaseTFPlayer *player = dynamic_cast< C_BaseTFPlayer * >( pEnt );
+	if ( player )
+	{
+		float amount = 1 - player->ComputeCamoEffectAmount();
+		m_CamoVar->SetFloatValue( amount );
+	}
+	else
+	{
+		// Weapon model?
+		C_BaseTFCombatWeapon *pWeapon = dynamic_cast< C_BaseTFCombatWeapon * >( pEnt );
+		if ( pWeapon )
+		{
+			float amount = 1 - ((C_BaseTFPlayer *)pWeapon->GetOwner())->ComputeCamoEffectAmount();
+			m_CamoVar->SetFloatValue( amount );
+		}
+		else
+		{
+			C_BaseViewModel *pViewmodel = dynamic_cast< C_BaseViewModel * >( pEnt );
+			if ( pViewmodel )
+			{
+				// Get the local player's values
+				player = C_BaseTFPlayer::GetLocalPlayer();
+				float amount = 1 - player->ComputeCamoEffectAmount();
+				m_CamoVar->SetFloatValue( amount );
+			}
+		}
+	}
+}
+
+EXPOSE_INTERFACE( CInfiltratorCamoMaterialProxy, IMaterialProxy, "InfiltratorCamo" IMATERIAL_PROXY_INTERFACE_VERSION );
diff --git a/game/client/tf2/itfhintitem.h b/game/client/tf2/itfhintitem.h
new file mode 100644
index 0000000..218b1f7
--- /dev/null
+++ b/game/client/tf2/itfhintitem.h
@@ -0,0 +1,58 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef ITFHINTITEM_H
+#define ITFHINTITEM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+namespace vgui
+{
+	class Panel;
+}
+
+class KeyValues;
+
+//-----------------------------------------------------------------------------
+// Purpose: All TF Hint Item Panels multiply inheret from this interface
+//-----------------------------------------------------------------------------
+class ITFHintItem
+{
+public:
+	virtual void	ParseItem( KeyValues *pKeyValues ) = 0;
+
+	// Delete the hint
+	virtual void	DeleteThis( void ) = 0;
+
+	// Returns true if the hint criteria have been met
+	virtual bool	GetCompleted( void ) = 0;
+	// Mark the hint as active
+	virtual void	SetActive( bool active ) = 0;
+	// Determine if the hint is the current, active hint
+	virtual bool	GetActive( void ) = 0;
+	// Allow hint to run code
+	virtual void	Think( void ) = 0;
+	// Determine height of hint
+	virtual int		GetHeight( void ) = 0;
+	// Set screen position of hint
+	virtual void	SetPosition( int x, int y ) = 0;
+	// Tell hint where it sits in current list of hints
+	virtual void	SetItemNumber( int index ) = 0;
+	// Set the hint visible/invisible
+	virtual void	SetVisible( bool visible ) = 0;
+	// Change the target (Panel) of the hint
+	virtual void	SetHintTarget( vgui::Panel *panel ) = 0;
+	// Return true if hint should render this frame (default returns true if GetActive() is true)
+	virtual bool	ShouldRenderPanelEffects( void ) = 0;
+	// Allow item to change title text
+	virtual void	ComputeTitle( void ) = 0;
+	// Allow outside influence over keyvalues
+	virtual void	SetKeyValue( const char *key, const char *value ) = 0;
+};
+
+#endif // ITFHINTITEM_H
diff --git a/game/client/tf2/iusesmortarpanel.h b/game/client/tf2/iusesmortarpanel.h
new file mode 100644
index 0000000..3a3e23f
--- /dev/null
+++ b/game/client/tf2/iusesmortarpanel.h
@@ -0,0 +1,69 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef IUSESMORTARPANEL_H
+#define IUSESMORTARPANEL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "hud_minimap.h"
+
+// Derive from this if your entity wants to use the mortar firing panel
+class IUsesMortarPanel
+{
+public:
+	// Get the data from this mortar needed by the panel
+	virtual void	GetMortarData( float *flClientMortarYaw, bool *bAllowedToFire, float *flPower, float *flFiringPower, float *flFiringAccuracy, int *iFiringState ) = 0;
+
+	// Tell the server the mortar's been rotated
+	virtual void	SendYawCommand( void ) = 0;
+
+	// Panel's overriding client yaw
+	virtual void	ForceClientYawCountdown( float flTime ) = 0;
+
+	// Start firing
+	virtual void	ClickFire( void ) = 0;
+};
+
+// Mortar firing panel
+class CMortarMinimapPanel : public CMinimapPanel
+{
+public:
+
+	DECLARE_CLASS( CMortarMinimapPanel, CMinimapPanel );
+
+	CMortarMinimapPanel( vgui::Panel *pParent, const char *pElementName );
+	virtual ~CMortarMinimapPanel();
+	
+	void InitMortarMinimap( C_BaseEntity *pMortar );
+	C_BaseEntity *GetMortar() const;
+
+	virtual void Paint();
+	
+	void OnMousePressed( vgui::MouseCode code );
+	void OnCursorMoved( int x, int y );
+	void OnMouseReleased( vgui::MouseCode code );
+
+
+public:
+
+	EHANDLE		m_hMortar;
+	BitmapImage m_MortarButtonUp;
+	BitmapImage m_MortarButtonDown;
+	BitmapImage m_MortarButtonCantFire;
+	BitmapImage m_MortarDirectionImage;
+	
+	bool m_bMouseDown;
+	bool m_bFireButtonDown;
+	int m_LastX, m_LastY;
+	
+	// The red-black fade material for the slider.
+	int m_nTextureId;
+	int m_nTextureId_CantFire;
+};
+
+#endif // IUSESMORTARPANEL_H
diff --git a/game/client/tf2/mapdata.cpp b/game/client/tf2/mapdata.cpp
new file mode 100644
index 0000000..cc1c3c5
--- /dev/null
+++ b/game/client/tf2/mapdata.cpp
@@ -0,0 +1,372 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "mapdata.h"
+#include "hud.h"
+#include "hud_macros.h"
+#include <KeyValues.h>
+#include "playeroverlay.h"
+#include "iclientmode.h"
+#include "hud_technologytreedoc.h"
+#include "C_World.h"
+#include "c_basetfplayer.h"
+#include "c_team.h"
+#include "c_tfteam.h"
+#include "c_func_resource.h"
+#include "vgui_bitmapimage.h"
+#include "C_Shield.h"
+#include "c_obj_respawn_station.h"
+
+bool IsEntityVisibleToTactical( int iLocalTeamNumber, int iLocalTeamPlayers, 
+	int iLocalTeamObjects, int iEntIndex, const char *pEntName, int pEntTeamNumber, const Vector &pEntOrigin );
+
+// All of the parsing occurs mapdata_parse.cpp
+bool ParseMinimapData( const char *filename, MinimapData_t *pMinimap, CMapZones *pZones, CMapTeamColors *pTeamColors, KeyValues *pKV );
+
+
+//-----------------------------------------------------------------------------
+// Gets at the singleton map data 
+//-----------------------------------------------------------------------------
+
+static CMapData g_MapData;
+CMapData& MapData()
+{
+	// Singleton object
+	return g_MapData;
+}
+
+IMapData *g_pMapData = &g_MapData;
+
+DECLARE_COMMAND( g_MapData, ForceMapReload );
+
+//-----------------------------------------------------------------------------
+// Purpose: This is a total hack, but should allow reloading the mapfile.txt stuff on the fly
+//-----------------------------------------------------------------------------
+void CMapData::UserCmd_ForceMapReload( void )
+{
+	if ( m_szMap[0] )
+	{
+		LevelInit( m_szMap );
+		// Force other data to reinit itself
+		GetTechnologyTreeDoc().Init();
+		
+		// Force any needed viewport fixups
+		g_pClientMode->Disable();
+		g_pClientMode->Enable();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CMapData::CMapData( void )
+{
+	m_szMap[0]=0;
+
+	int i, j;
+	m_Minimap.m_szBackgroundMaterial[0] = 0;
+
+	for ( i = 0; i < MAX_ZONES; i++ )
+	{
+		m_Zones[ i ].m_pZoneImage = NULL;
+		m_Zones[ i ].m_nControllingTeam = -1;
+	}
+
+	for ( i = 0; i < MAX_PLAYERS; i++ )
+	{
+		m_Players[ i ].m_pImage			= NULL;
+		m_Players[ i ].m_nTeam			= 0;
+		m_Players[ i ].m_bSelected		= false;
+		m_Players[ i ].m_nSquadNumber	= 0;
+
+	}
+
+	for ( i = 0; i <= MAX_MAP_TEAMS; i++ )
+	{
+		m_TeamColors[ i ].m_pImage = NULL;
+
+		for ( j = 0; j < MAX_CLASSES; j++ )
+		{
+			if ( m_TeamColors[ i ].m_ClassColors[ j ].m_pClassImage )
+			{
+				m_TeamColors[ i ].m_ClassColors[ j ].m_pClassImage = NULL;
+			}
+		}
+	}
+
+	UseDefaults();
+}
+
+HOOK_COMMAND( forcemapreload, ForceMapReload );
+
+//-----------------------------------------------------------------------------
+// Purpose: One time init
+//-----------------------------------------------------------------------------
+void CMapData::Init( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Delete all dynamic images, but leave rest of data structures
+//-----------------------------------------------------------------------------
+void CMapData::Clear( void )
+{
+	int i, j;
+
+	// Delete old zones...
+	for ( i = 0; i < MAX_ZONES; i++ )
+	{
+		delete m_Zones[ i ].m_pZoneImage;
+		m_Zones[ i ].m_pZoneImage = NULL;
+	}
+
+	for ( i = 0; i <= MAX_MAP_TEAMS; i++ )
+	{
+		delete m_TeamColors[ i ].m_pImage;
+		m_TeamColors[ i ].m_pImage = NULL;
+
+		for ( j = 0; j < MAX_CLASSES; j++ )
+		{
+			delete m_TeamColors[ i ].m_ClassColors[ j ].m_pClassImage;
+			m_TeamColors[ i ].m_ClassColors[ j ].m_pClassImage = NULL;
+		}
+	}
+
+	m_Minimap.m_szBackgroundMaterial[0] = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CMapData::~CMapData( void )
+{
+	Clear();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set a team's default colors
+//-----------------------------------------------------------------------------
+void CMapData::SetTeamDefaultColor( int iTeamNumber, int r, int g, int b )
+{
+	m_TeamColors[ iTeamNumber ].m_clrBlip.SetColor( r,g,b, 0 );
+	m_TeamColors[ iTeamNumber ].m_clrTeam.SetColor( r,g,b, 128 );
+
+	for ( int j = 0; j < MAX_CLASSES; j++ )
+	{
+		m_TeamColors[ iTeamNumber ].m_ClassColors->m_clrClass.SetColor( r,g,b, 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Fill in placeholder colors, etc.
+//-----------------------------------------------------------------------------
+void CMapData::UseDefaults( void )
+{
+	// Init colors for all teams
+	SetTeamDefaultColor( 1, 255, 0, 0 );
+	SetTeamDefaultColor( 2, 0, 0, 255 );
+	SetTeamDefaultColor( 3, 0, 0, 0 );
+	SetTeamDefaultColor( 4, 0, 0, 0 );
+	SetTeamDefaultColor( 5, 0, 0, 0 );
+	SetTeamDefaultColor( 6, 0, 0, 0 );
+	SetTeamDefaultColor( 7, 0, 0, 0 );
+	SetTeamDefaultColor( 8, 0, 0, 0 );
+
+	m_Minimap.m_szBackgroundMaterial[0] = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Get the bounding box of the world
+//-----------------------------------------------------------------------------
+void CMapData::GetMapBounds(Vector &mins, Vector& maxs)
+{
+	C_BaseEntity *ent = cl_entitylist->GetEnt( 0 );
+	C_World* pWorld = dynamic_cast<C_World*>(ent);
+	if (pWorld)
+	{
+		VectorCopy( pWorld->m_WorldMins, mins );
+		VectorCopy( pWorld->m_WorldMaxs, maxs );
+
+		// Backward compatability...
+		if ((mins.LengthSqr() == 0.0f) && (maxs.LengthSqr() == 0.0f))
+		{
+			mins.Init( -6500, -6500, -6500 );
+			maxs.Init( 6500, 6500, 6500 );
+		}
+	}
+	else
+	{
+		Assert(0);
+		mins.Init( 0, 0, 0 );
+		maxs.Init( 1, 1, 1 );
+	}
+}
+
+void CMapData::GetMapOrigin(Vector &org)
+{
+	Vector mins, maxs;
+	GetMapBounds( mins, maxs );
+	VectorAdd( mins, maxs, org );
+	VectorMultiply( org, 0.5, org );
+}
+
+void CMapData::GetMapSize(Vector &size) 
+{
+	Vector mins, maxs;
+	GetMapBounds( mins, maxs );
+	VectorSubtract( maxs, mins, size );
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CMapData::Get3DSkyboxOrigin( Vector &vecOrigin )
+{
+	// NOTE: If the player hasn't been created yet -- this doesn't work!!!
+	//       We need to pass the data along in the map - requires a tool change.
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( pPlayer )
+	{
+		CPlayerLocalData *pLocalData = &pPlayer->m_Local;
+		VectorCopy( pLocalData->m_skybox3d.origin, vecOrigin );
+	}
+	else
+	{
+		// Debugging!
+		Assert( 0 );
+		vecOrigin.Init();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+float CMapData::Get3DSkyboxScale( void )
+{
+	// NOTE: If the player hasn't been created yet -- this doesn't work!!!
+	//       We need to pass the data along in the map - requires a tool change.
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( pPlayer )
+	{
+		CPlayerLocalData *pLocalData = &pPlayer->m_Local;
+		return pLocalData->m_skybox3d.scale;
+	}
+	else
+	{
+		// Debugging!
+		Assert( 0 );
+		return ( 1.0f );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// What's my visible area?
+//-----------------------------------------------------------------------------
+void CMapData::SetVisibleArea( const Vector& mins, const Vector& maxs )
+{
+	m_VisibleMins = mins;
+	m_VisibleMaxs = maxs;
+}
+
+void CMapData::GetVisibleArea( Vector& mins, Vector& maxs )
+{
+	mins = m_VisibleMins;
+	maxs = m_VisibleMaxs;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The client is about to change maps
+// Input  : *map - name of the new map
+//-----------------------------------------------------------------------------
+void CMapData::LevelInit( const char *map )
+{
+	Q_strncpy( m_szMap, map, MINIMAP_STRING_SIZE );
+
+	// Clear leftover data
+	Clear();
+	
+	// The name of the background material for the map is well-defined
+	Q_snprintf( m_Minimap.m_szBackgroundMaterial, MINIMAP_MATERIAL_STRING_SIZE, 
+		"hud/minimap/%s/%s", map, map );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CMapData::LevelShutdown( void )
+{
+	Clear();
+}
+
+
+//-----------------------------------------------------------------------------
+// Update fog of war
+//-----------------------------------------------------------------------------
+void CMapData::Update( void ) 
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Is entity visible to tactical?
+//-----------------------------------------------------------------------------
+bool CMapData::IsEntityVisibleToTactical( C_BaseEntity* pEnt ) const
+{
+	C_BaseTFPlayer *pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	if (!pPlayer)
+		return false;
+
+	// If the local player hasn't chosen a class or a team, nothing's visible
+	if ((pPlayer->GetClass() == TFCLASS_UNDECIDED) || (pPlayer->GetTeamNumber() == 0))
+		return false;
+
+	C_TFTeam *pTeam = (C_TFTeam *)pPlayer->GetTeam();
+	if (!pTeam)
+		return false;
+
+	// Local player is always visible, as long as he's chosen a class.
+	if (pEnt == pPlayer)
+		return true;
+
+	int iNumberObjects = 0;
+	int iNumberPlayers = 0;
+	if ( pTeam )
+	{
+		iNumberObjects = pTeam->GetNumObjects();
+		iNumberPlayers = pTeam->Get_Number_Players();
+	}
+
+	int localteam = pPlayer->GetTeamNumber();
+
+	// If on our team, not on a team, or is a resource zone, can't be cloaked
+	if ( !pEnt->GetTeamNumber() || pEnt->GetTeamNumber() == localteam )
+	{
+		return true;
+	}
+
+	// NOTE: The global IsEntityVisibleToTactical returns true in situations
+	// where the entity would otherwise not be visible
+	bool bRet = ::IsEntityVisibleToTactical( localteam, iNumberPlayers, 
+		iNumberObjects, pEnt->entindex(), pEnt->GetClassname(), pEnt->GetTeamNumber(), pEnt->GetAbsOrigin() );
+
+	if ( bRet )
+	{
+		return true;
+	}
+
+	// Make sure it's within a well-defined radius of the local player...
+	Vector2D dist;
+	Vector2DSubtract( pEnt->GetAbsOrigin().AsVector2D(), pPlayer->GetAbsOrigin().AsVector2D(), dist );
+
+	// Cloaked by this object?
+	if ( dist.LengthSqr() > LOCAL_PLAYER_SCANNER_RANGE * LOCAL_PLAYER_SCANNER_RANGE )
+		return false;
+
+	// On other team, and not cloaked by technician
+	return true;
+}
diff --git a/game/client/tf2/mapdata.h b/game/client/tf2/mapdata.h
new file mode 100644
index 0000000..a251b9b
--- /dev/null
+++ b/game/client/tf2/mapdata.h
@@ -0,0 +1,128 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( MAPDATA_H )
+#define MAPDATA_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Panel.h>
+#include <vgui/IImage.h>
+#include "mathlib/vector.h"
+#include "mapdata_shared.h"
+#include "sharedinterface.h"
+
+#define MAX_ZONES		32
+#define MAX_CLASSES		32
+#define MAX_MAP_TEAMS	8
+#define MINIMAP_MATERIAL_STRING_SIZE 64
+#define MINIMAP_STRING_SIZE 128
+
+class Vector;
+class C_BaseEntity;
+class BitmapImage;
+
+class CMapClassColors
+{
+public:
+	BitmapImage		*m_pClassImage;
+	Color		m_clrClass;
+};
+
+class CMapTeamColors
+{
+public:
+	CMapClassColors	m_ClassColors[ MAX_CLASSES ];
+
+	BitmapImage		*m_pImage;
+	Color		m_clrBlip;
+	Color		m_clrTeam;
+};
+
+class CMapPlayers
+{
+public:
+	int				m_nTeam;
+	bool			m_bVisible;
+	bool			m_bSelected;
+	int				m_nSquadNumber;
+	int				m_nXPos, m_nYPos;
+
+	BitmapImage		*m_pImage;
+	Color		m_clrPlayer;
+};
+
+class CMapZones
+{
+public:
+	int				m_nControllingTeam;
+
+	BitmapImage		*m_pZoneImage;
+};
+
+struct MinimapData_t
+{
+	char	m_szBackgroundMaterial[MINIMAP_MATERIAL_STRING_SIZE];
+};
+
+class CMapData : public IMapData
+{
+public:
+					CMapData( void );
+	virtual			~CMapData( void );
+
+	void			Init( void );
+	void			Clear( void );
+	void			LevelInit( const char *map );
+	void			LevelShutdown( void );
+
+	void			Update( );
+	bool			IsEntityVisibleToTactical( C_BaseEntity* pEnt ) const;
+
+	void			UseDefaults( void );
+	void			SetTeamDefaultColor( int iTeamNumber, int r, int g, int b );
+
+	void			UserCmd_ForceMapReload( void );
+
+	// map dimensions
+	void			GetMapBounds(Vector& mins, Vector& maxs);
+	void			GetMapOrigin(Vector& org);
+	void			GetMapSize(Vector& size);
+
+	// 3d skybox
+	void			Get3DSkyboxOrigin( Vector &vecOrigin );
+	float			Get3DSkyboxScale( void );
+
+	// Indicates the area currently visible in commander mode
+	void			SetVisibleArea( const Vector& mins, const Vector& maxs );
+	void			GetVisibleArea( Vector& mins, Vector& maxs );
+
+public:
+	CMapZones		m_Zones[ MAX_ZONES ];
+	CMapPlayers		m_Players[ MAX_PLAYERS ];
+	CMapTeamColors	m_TeamColors[ MAX_MAP_TEAMS+1 ];
+	MinimapData_t	m_Minimap;
+
+private:
+	char	m_szMap[ MINIMAP_STRING_SIZE ];
+
+	// World size + visible size in commander mode
+	Vector	m_WorldMins;
+	Vector	m_WorldMaxs;
+	Vector	m_VisibleMins;
+	Vector	m_VisibleMaxs;
+};
+
+
+//-----------------------------------------------------------------------------
+// Gets at the singleton map data 
+//-----------------------------------------------------------------------------
+CMapData& MapData();
+
+
+#endif // MAPDATA_H
\ No newline at end of file
diff --git a/game/client/tf2/minimap_players.cpp b/game/client/tf2/minimap_players.cpp
new file mode 100644
index 0000000..dcf1cbb
--- /dev/null
+++ b/game/client/tf2/minimap_players.cpp
@@ -0,0 +1,250 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "c_basetfplayer.h"
+#include "minimap_trace.h"
+#include "vgui_entityimagepanel.h"
+#include <KeyValues.h>
+#include "vgui_bitmapimage.h"
+#include "ViewConeImage.h"
+#include "VGuiMatSurface/IMatSystemSurface.h"
+#include "shareddefs.h"
+#include "voice_status.h"
+#include "iclientvehicle.h"
+
+//-----------------------------------------------------------------------------
+// Minimap panel representing players
+//-----------------------------------------------------------------------------
+class CMinimapPlayerPanel : public CMinimapTracePanel
+{
+	DECLARE_CLASS( CMinimapPlayerPanel, CMinimapTracePanel );
+
+public:
+	CMinimapPlayerPanel( vgui::Panel *parent, const char *panelName )
+		: BaseClass( parent, "CMinimapPlayerPanel" )
+	{
+	}
+
+	virtual bool Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData );
+	virtual void Paint( );
+	virtual void OnTick( );
+
+private:
+	// Parse class image data from the file
+	bool InitClassImages( KeyValues* pKeyValues, MinimapInitData_t* pInitData );
+
+	CTeamBitmapImage m_DeadImage;
+	CTeamBitmapImage m_AliveImage;
+	CTeamBitmapImage m_LocalAliveImage;
+	CTeamBitmapImage m_ArrowImage;
+	CTeamBitmapImage m_pClassAliveImages[TFCLASS_CLASS_COUNT];
+	BitmapImage m_VoiceImage;
+	bool			 m_bHasClassImage[TFCLASS_CLASS_COUNT];
+	int m_LocalOffsetX, m_LocalOffsetY;
+	int m_LocalSizeX, m_LocalSizeY;
+	int m_VoiceOffsetX, m_VoiceOffsetY;
+	int m_VoiceSizeX, m_VoiceSizeY;
+	float m_flVoiceAlpha;
+};
+
+DECLARE_MINIMAP_FACTORY( CMinimapPlayerPanel, "minimap_player_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Parse class image data from the file
+//-----------------------------------------------------------------------------
+bool CMinimapPlayerPanel::InitClassImages( KeyValues* pKeyValues, MinimapInitData_t* pInitData )
+{
+	memset( m_bHasClassImage, 0, TFCLASS_CLASS_COUNT * sizeof(bool) );
+
+	for (int i = 1; i < TFCLASS_CLASS_COUNT; ++i)
+	{
+		KeyValues *pClassSection = pKeyValues->FindKey( GetTFClassInfo(i)->m_pClassName );
+		if (!pClassSection)
+			continue;
+
+		m_bHasClassImage[i] = true;
+		if (!InitializeTeamImage( pKeyValues, GetTFClassInfo( i )->m_pClassName, this, pInitData->m_pEntity, &m_pClassAliveImages[i] ))
+			return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Parse data from the file
+//-----------------------------------------------------------------------------
+bool CMinimapPlayerPanel::Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData )
+{
+	// Must be applied to players
+	Assert( dynamic_cast< C_BaseTFPlayer * >( pInitData->m_pEntity ) );
+
+	if (!BaseClass::Init( pKeyValues, pInitData ))
+		return false;
+
+	if (!InitializeTeamImage( pKeyValues, "localaliveimage", this, pInitData->m_pEntity, &m_LocalAliveImage))
+		return false;
+
+	if (!InitializeTeamImage( pKeyValues, "aliveimage", this, pInitData->m_pEntity, &m_AliveImage ))
+		return false;
+
+	if (!InitializeTeamImage( pKeyValues, "arrowimage", this, pInitData->m_pEntity, &m_ArrowImage ))
+		return false;
+
+	if (!InitializeTeamImage( pKeyValues, "deadimage", this, pInitData->m_pEntity, &m_DeadImage ))
+		return false;
+
+	if (!InitializeImage( pKeyValues, "voiceimage", this, &m_VoiceImage ))
+		return false;
+
+	// Load class-specific images
+	if (!InitClassImages( pKeyValues, pInitData ) )
+		return false;
+
+	// Modify the size if this is the local player
+	if (!ParseCoord(pKeyValues, "localplayeroffset", m_LocalOffsetX, m_LocalOffsetY))
+		return false;
+
+	if (!ParseCoord(pKeyValues, "localplayersize", m_LocalSizeX, m_LocalSizeY ))
+		return false;
+
+	if (!ParseCoord(pKeyValues, "voiceoffset", m_VoiceOffsetX, m_VoiceOffsetY ))
+		return false;
+
+	if (!ParseCoord(pKeyValues, "voicesize", m_VoiceSizeX, m_VoiceSizeY ))
+		return false;
+
+	m_flVoiceAlpha = 0.0f;
+	SetCursor( NULL );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Render
+//-----------------------------------------------------------------------------
+void CMinimapPlayerPanel::OnTick( )
+{
+	// Modify position and size if we're the local player
+	// It's too bad, but we can't do this during Init() because 
+	// C_BaseTFPlayer::GetLocalPlayer() doesn't return the correct value at that time
+	if ( C_BaseTFPlayer::GetLocalPlayer() == GetEntity() )
+	{
+		m_OffsetX = m_LocalOffsetX;
+		m_OffsetY = m_LocalOffsetY;
+
+		m_SizeW = m_LocalSizeX;
+		m_SizeH = m_LocalSizeY;
+
+		// Make sure the local player draws on top
+		SetZPos( MINIMAP_LOCAL_PLAYER );
+
+		SetSize( m_LocalSizeX, m_LocalSizeY );
+	}
+
+	BaseClass::OnTick();
+}
+
+
+//-----------------------------------------------------------------------------
+// Render
+//-----------------------------------------------------------------------------
+void CMinimapPlayerPanel::Paint( )
+{
+	if ( gHUD.IsHidden( HIDEHUD_MISCSTATUS ) )
+		return;
+
+	C_BaseEntity* pEntity = GetEntity();
+	Assert( pEntity );
+
+	// Don't render players if they aren't on a team
+	if( pEntity->GetTeamNumber() == 0 )
+		return;
+
+	C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
+	C_BaseTFPlayer *pPlayer = static_cast< C_BaseTFPlayer * >( pEntity );
+	Assert( pPlayer );
+
+	if (!m_bClipToMap)
+		g_pMatSystemSurface->DisableClipping( true );
+
+	// Set the fade amount (only for alive players)...
+//	m_AliveImage.SetAlpha( pPlayer->GetOverlayAlpha() );
+//	m_LocalAliveImage.SetAlpha( pPlayer->GetOverlayAlpha() );
+
+	bool isLocalPlayer = ( pEntity == local );
+	
+	bool isAlive = pPlayer->GetHealth() > 0 ? true : false;
+	if ( isAlive )
+	{
+		if ( pPlayer->IsPlayerDead() )
+		{
+			isAlive = false;
+		}
+	}
+
+	float yaw = pPlayer->EyeAngles().y;
+	if ( pPlayer->InLocalTeam() && GetClientVoiceMgr()->IsPlayerSpeaking( pPlayer->entindex() ) &&
+			GetClientVoiceMgr()->IsPlayerAudible( pPlayer->entindex() ) )
+	{
+		m_flVoiceAlpha = 1.0f;
+	}
+	else if (m_flVoiceAlpha != 0.0f)
+	{
+		m_flVoiceAlpha *= 0.8f;
+		if (m_flVoiceAlpha < 0.005)
+			m_flVoiceAlpha = 0.0f;
+	}
+
+	if ( m_flVoiceAlpha != 0.0f )
+	{
+		int x = (int)(m_VoiceOffsetX - m_OffsetX + 0.5f);
+		int y = (int)(m_VoiceOffsetY - m_OffsetY + 0.5f);
+
+		g_pMatSystemSurface->DisableClipping( true );
+		m_VoiceImage.DoPaint( x, y, m_VoiceSizeX, m_VoiceSizeY, 0, m_flVoiceAlpha );
+		if (m_bClipToMap)
+			g_pMatSystemSurface->DisableClipping( false );
+	}
+				 
+	//  Draw dead guys with a different icon
+	if ( isAlive )
+	{
+		if (isLocalPlayer)
+		{
+			m_LocalAliveImage.Paint( );
+			m_ArrowImage.Paint( yaw );
+		}
+		else
+		{
+			int nPlayerClass = pPlayer->GetClass();
+			if (pPlayer->InLocalTeam() && m_bHasClassImage[nPlayerClass])
+			{
+				m_pClassAliveImages[nPlayerClass].Paint( );
+				m_ArrowImage.Paint( yaw );
+			}
+			else
+			{
+				m_AliveImage.Paint( );
+				m_ArrowImage.Paint( yaw );
+			}
+		}
+	}
+	else
+	{
+		m_DeadImage.Paint();
+	}
+
+	g_pMatSystemSurface->DisableClipping( false );
+}
+
+
+
+
diff --git a/game/client/tf2/minimap_resourcezone.cpp b/game/client/tf2/minimap_resourcezone.cpp
new file mode 100644
index 0000000..56bbdc9
--- /dev/null
+++ b/game/client/tf2/minimap_resourcezone.cpp
@@ -0,0 +1,95 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "c_func_resource.h"
+#include "vgui_bitmapimage.h"
+#include <KeyValues.h>
+#include "minimap_trace.h"
+#include "techtree.h"
+#include "shareddefs.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+class CMinimapResourceZonePanel : public CMinimapTracePanel
+{
+	DECLARE_CLASS( CMinimapResourceZonePanel, CMinimapTracePanel );
+
+public:
+	CMinimapResourceZonePanel( vgui::Panel *parent, const char *panelName );
+	virtual ~CMinimapResourceZonePanel();
+
+	virtual bool Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData );
+	virtual void Paint( );
+
+private:
+	BitmapImage *m_ppImage;
+};
+
+DECLARE_MINIMAP_FACTORY( CMinimapResourceZonePanel, "minimap_resource_zone_panel" );
+
+
+CMinimapResourceZonePanel::CMinimapResourceZonePanel( vgui::Panel *parent, const char *panelName )
+: BaseClass( parent, "CMinimapResourceZonePanel" )
+{
+	m_ppImage = NULL;
+}
+
+CMinimapResourceZonePanel::~CMinimapResourceZonePanel()
+{
+	if ( m_ppImage )
+	{
+		delete m_ppImage;
+		m_ppImage = NULL;
+	}
+}
+
+bool CMinimapResourceZonePanel::Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData )
+{
+	// Can only be applied to resource zones...
+	C_ResourceZone* pResource = dynamic_cast<C_ResourceZone*>( pInitData->m_pEntity );
+	if (!pResource)
+		return false;
+
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	// Read in the images for the resource zone...
+	// Default to null
+	m_ppImage = NULL;
+
+	char const* pMaterialName = pKeyValues->GetString( "material" );
+	if ( !pMaterialName || !pMaterialName[ 0 ] )
+		return false;
+
+	// modulation color
+	Color color;
+	if (!ParseRGBA( pKeyValues, "color", color ))
+		color.SetColor( 255, 255, 255, 255 );
+
+	// hook in the bitmap
+	m_ppImage = new BitmapImage( GetVPanel(), pMaterialName );
+	m_ppImage->SetColor( color );
+
+	return true;
+}
+
+void CMinimapResourceZonePanel::Paint( )
+{
+	if ( gHUD.IsHidden( HIDEHUD_MISCSTATUS ) )
+		return;
+
+	// Paint the image for the zone type
+	if ( m_ppImage )
+	{
+		m_ppImage->Paint();
+	}
+}
+
+
+
diff --git a/game/client/tf2/minimap_trace.cpp b/game/client/tf2/minimap_trace.cpp
new file mode 100644
index 0000000..c75afa3
--- /dev/null
+++ b/game/client/tf2/minimap_trace.cpp
@@ -0,0 +1,323 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "minimap_trace.h"
+#include "c_basetfplayer.h"
+#include "mapdata.h"
+#include "model_types.h"
+#include "clientmode_tfnormal.h"
+#include <vgui/IVGui.h>
+#include "vgui_bitmapimage.h"
+#include <KeyValues.h>
+#include "VGuiMatSurface/IMatSystemSurface.h"
+#include "shareddefs.h"
+#include "engine/ivmodelinfo.h"
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+CMinimapTracePanel::CMinimapTracePanel( vgui::Panel *parent, const char *panelName)
+	: BaseClass( parent, "CMinimapTracePanel" )
+{
+	m_pEntity = NULL;
+	SetPaintBackgroundEnabled( false );
+	m_bCanScale = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CMinimapTracePanel::~CMinimapTracePanel()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Initialization
+//-----------------------------------------------------------------------------
+bool CMinimapTracePanel::Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData )
+{
+	// NOTE: Can't use a EHANDLE here because the EHANDLE for pEntity is set up
+	// when AddEntity is called; this gets called before that happens
+	m_pEntity = pInitData->m_pEntity;
+	m_vecPosition = pInitData->m_vecPosition;
+
+	int w, h;
+	if (!ParseCoord(pKeyValues, "offset", m_OffsetX, m_OffsetY))
+		return false;
+
+	if (!ParseCoord(pKeyValues, "size", w, h ))
+		return false;
+
+	// Lifetime of the minimap trace
+	float flLifeTime = pKeyValues->GetFloat("lifetime", -1.0f);
+	if (flLifeTime > 0.0f)
+		m_flDeletionTime = gpGlobals->curtime + flLifeTime;
+	else
+		m_flDeletionTime = -1.0f;
+
+	// Optional parameters
+	m_bVisibleWhenZoomedIn = (pKeyValues->GetInt( "detail", 0 ) == 0 );
+	m_bClampToMap = (pKeyValues->GetInt( "clamp", 0 ) != 0);
+	m_bClipToMap = (pKeyValues->GetInt( "noclip", 0 ) == 0);
+	m_bCanScale = (pKeyValues->GetInt( "noscale", 0 ) == 0);
+	m_bVisible = true;
+
+	m_SizeW = w;
+	m_SizeH = h;
+
+	SetSize( w, h );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Entity accessor
+//-----------------------------------------------------------------------------
+C_BaseEntity* CMinimapTracePanel::GetEntity()
+{ 
+	return m_pEntity; 
+}
+
+void CMinimapTracePanel::SetEntity( C_BaseEntity* pEntity )
+{
+	m_pEntity = pEntity;
+}
+
+//-----------------------------------------------------------------------------
+// Sets the position of the trace in world space
+//-----------------------------------------------------------------------------
+void CMinimapTracePanel::SetPosition( const Vector &vecPosition )
+{
+	m_vecPosition = vecPosition;
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the entity position
+//-----------------------------------------------------------------------------
+bool CMinimapTracePanel::GetEntityPosition( float &x, float &y )
+{
+	C_BaseEntity *pEntity = GetEntity();
+
+	Vector pos;
+	if (!pEntity)
+	{
+		pos = m_vecPosition;
+	}
+	else
+	{
+		if (pEntity == C_BaseTFPlayer::GetLocalPlayer())
+		{
+			// Use the predicted position...
+			pos = pEntity->GetAbsOrigin();
+		}
+		else if ( !pEntity->GetModel() || modelinfo->GetModelType( pEntity->GetModel() ) != mod_brush )
+		{  
+			// If it's not a brush model, use the origin
+			pos = pEntity->GetRenderOrigin();
+		}
+		else
+		{
+			Vector mins, maxs;
+			pEntity->GetRenderBounds( mins, maxs );
+			pos = (mins + maxs) * 0.5f;
+		}
+
+		// Position is an offset when there's an entity
+		pos += m_vecPosition;
+	}
+
+	return CMinimapPanel::MinimapPanel()->WorldToMinimap( m_bClampToMap ? MINIMAP_CLIP : MINIMAP_NOCLIP, pos, x, y );
+}
+
+
+//-----------------------------------------------------------------------------
+// Causes the minimap panel to not be visible
+//-----------------------------------------------------------------------------
+void CMinimapTracePanel::SetTraceVisibility( bool bVisible )
+{
+	m_bVisible = bVisible;
+}
+
+
+//-----------------------------------------------------------------------------
+// Call this before rendering to see if the entity should be rendered
+// and to get the rendering position
+//-----------------------------------------------------------------------------
+bool CMinimapTracePanel::ComputeVisibility( )
+{
+	if (!m_bVisible)
+		return false;
+
+	C_BaseEntity* pEntity = GetEntity();
+	
+	// No entity? We must be a positional trace
+	if (!pEntity)
+		return true;
+
+	// Don't draw if it's not in the PVS
+	if ( pEntity->IsDormant() )
+		return false;
+
+	// Check visible to tactical
+	if( !MapData().IsEntityVisibleToTactical(pEntity) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// called when we're ticked...
+//-----------------------------------------------------------------------------
+void CMinimapTracePanel::OnTick()
+{
+	// Don't do anything when not in a game
+	if ( !engine->IsInGame() )
+	{
+		SetVisible( false );
+		return;
+	}
+
+	// Update our current position
+	float sx, sy;
+	bool onMap = GetEntityPosition( sx, sy );
+
+	int ofsx, ofsy;
+	ofsx = m_OffsetX;
+	ofsy = m_OffsetY;
+
+	if ( m_bCanScale )
+	{
+		int w, h;
+		GetSize( w, h );
+
+		float scale = CMinimapPanel::MinimapPanel()->GetTrueZoom();
+		if ( 1 || scale != 1.0f )
+		{
+			ofsx *= scale;
+			ofsy *= scale;
+
+			int sizew = m_SizeW * scale;
+			int sizeh = m_SizeH * scale;
+
+			SetPos( (int)(sx + ofsx + 0.5f), (int)(sy + ofsy + 0.5f));
+			SetSize( sizew, sizeh );
+		}
+		else
+		{
+			SetPos( (int)(sx + ofsx + 0.5f), (int)(sy + ofsy + 0.5f));
+		}
+	}
+	else
+	{
+		SetPos( (int)(sx + ofsx + 0.5f), (int)(sy + ofsy + 0.5f));
+	}
+
+	// Update our visibility
+	if (!onMap)
+		SetVisible( false );
+	else
+		SetVisible( ComputeVisibility( ) );
+
+	if ((m_flDeletionTime >= 0.0f) && (gpGlobals->curtime >= m_flDeletionTime))
+	{
+		MarkForDeletion();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes a panel alpha based on zoom level...
+//-----------------------------------------------------------------------------
+float CMinimapTracePanel::ComputePanelAlpha()
+{
+	if (m_bVisibleWhenZoomedIn)
+		return 1.0f;
+
+	int a;
+	if (!CMinimapPanel::MinimapPanel())
+		return 0.0f;
+
+	if (!CMinimapPanel::MinimapPanel()->ShouldDrawZoomDetails( a ))
+		return 0.0f;
+
+	return a / 255.0f;
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// A standard minimap panel that displays a bitmap
+//
+//-----------------------------------------------------------------------------
+DECLARE_MINIMAP_FACTORY( CMinimapTraceBitmapPanel, "minimap_image_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Sets the bitmap and size
+//-----------------------------------------------------------------------------
+bool CMinimapTraceBitmapPanel::Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData )
+{
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return m_Image.Init( GetVPanel(), pKeyValues );
+}
+
+
+//-----------------------------------------------------------------------------
+// Performs the rendering...
+//-----------------------------------------------------------------------------
+void CMinimapTraceBitmapPanel::Paint(  )
+{
+	if ( gHUD.IsHidden( HIDEHUD_MISCSTATUS ) )
+		return;
+
+	if (!m_bClipToMap)
+		g_pMatSystemSurface->DisableClipping( true );
+	m_Image.DoPaint( GetVPanel(), 0, ComputePanelAlpha() );
+	g_pMatSystemSurface->DisableClipping( false );
+}
+
+
+
+//-----------------------------------------------------------------------------
+//
+// A standard minimap renderable that displays a bitmap that changes when team changes
+//
+//-----------------------------------------------------------------------------
+DECLARE_MINIMAP_FACTORY( CMinimapTraceTeamBitmapPanel, "minimap_team_image_panel" );
+
+
+//-----------------------------------------------------------------------------
+// Sets the bitmap and size
+//-----------------------------------------------------------------------------
+bool CMinimapTraceTeamBitmapPanel::Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData )
+{
+	if (!BaseClass::Init(pKeyValues, pInitData))
+		return false;
+
+	return m_TeamImage.Init( this, pKeyValues, pInitData->m_pEntity );
+}
+
+
+//-----------------------------------------------------------------------------
+// Performs the rendering...
+//-----------------------------------------------------------------------------
+void CMinimapTraceTeamBitmapPanel::Paint( )
+{
+	if ( gHUD.IsHidden( HIDEHUD_MISCSTATUS ) )
+		return;
+
+	if (!m_bClipToMap)
+		g_pMatSystemSurface->DisableClipping( true );
+	m_TeamImage.SetAlpha( ComputePanelAlpha() );
+	m_TeamImage.Paint();
+	g_pMatSystemSurface->DisableClipping( false );
+}
diff --git a/game/client/tf2/minimap_trace.h b/game/client/tf2/minimap_trace.h
new file mode 100644
index 0000000..cc644cf
--- /dev/null
+++ b/game/client/tf2/minimap_trace.h
@@ -0,0 +1,153 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef MINIMAP_ENTITY_H
+#define MINIMAP_ENTITY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "hud_minimap.h"
+#include "TeamBitmapImage.h"
+#include "vgui_bitmapimage.h"
+#include <vgui_controls/Panel.h>
+
+
+// FIXME: Need to put the team color somewhere...
+// Get the team color...
+extern int g_TeamColor[3][3];
+
+
+//-----------------------------------------------------------------------------
+// A base minimap panel meant to be attached to an entity.
+// NOTE: paint() will never be called unless the entity is currently valid
+//-----------------------------------------------------------------------------
+class C_BaseEntity;
+
+class CMinimapTracePanel : public vgui::Panel
+{
+	DECLARE_CLASS_GAMEROOT( CMinimapTracePanel, vgui::Panel );
+
+public:
+				CMinimapTracePanel( vgui::Panel *parent, const char *panelName );
+	virtual		~CMinimapTracePanel();
+
+	bool	Init( KeyValues* pKeyValues, MinimapInitData_t* pMinimapData );
+
+	// Causes the minimap panel to not be visible
+	void	SetTraceVisibility( bool bVisible );
+
+	// called when we're ticked...
+	virtual void	OnTick( void );
+
+protected:
+	// Can be overridden; it's called once a frame and returns true if the
+	// object is visible to the minimap or not.	X and Y are the position of the
+	// entity in minimap space
+	virtual bool ComputeVisibility( );
+
+	// Computes a panel alpha based on zoom level...
+	float ComputePanelAlpha();
+
+	// Called by derived classes before drawing to determine if the entity is visible.
+	// Also sets the vgui surface color based on the team.
+	bool	BeginRender( CMinimapPanel* pPanel, float &x, float &y, int &team ) { return false; }
+
+	// Computes the entity position in minimap panel coordinates
+	bool	GetEntityPosition( float &x, float &y );
+
+	// Sets the position of the trace in world space
+	void	SetPosition( const Vector &vecPosition );
+
+	// Entity accessors
+	C_BaseEntity* GetEntity();
+	void SetEntity( C_BaseEntity* pEntity );
+
+protected:
+	// Bitmap positional offset
+	int m_OffsetX;
+	int m_OffsetY;
+
+	int m_SizeW;
+	int m_SizeH;
+
+	// Indicates we should clip to the map
+	bool	m_bClipToMap;
+
+	bool	m_bCanScale;
+
+private:
+	// Indicates if we're faded out when zoomed in
+	bool	m_bVisibleWhenZoomedIn;
+
+	// Indicates we should always draw, even if we're off the map
+	bool	m_bClampToMap;
+
+	// Are we invisible because the entity wants us invisible?
+	bool	m_bVisible;
+
+	// This is the entity to which we're attached
+	C_BaseEntity *m_pEntity;
+
+	// This is the location of the panel in world space
+	Vector	m_vecPosition;
+
+	// lifetime of the minimap panel
+	float	m_flDeletionTime;
+};
+
+
+//-----------------------------------------------------------------------------
+// A standard minimap panel that displays a bitmap
+//-----------------------------------------------------------------------------
+class CMinimapTraceBitmapPanel : public CMinimapTracePanel
+{
+	DECLARE_CLASS( CMinimapTraceBitmapPanel, CMinimapTracePanel );
+
+public:
+	CMinimapTraceBitmapPanel( vgui::Panel *parent, const char *panelName )
+		: BaseClass ( parent, panelName )
+	{
+	}
+
+	// Sets the bitmap and size
+	virtual bool Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData );
+
+	// Performs the rendering...
+ 	virtual void Paint();
+
+protected:
+	BitmapImage m_Image;
+};
+
+
+//-----------------------------------------------------------------------------
+// A standard minimap panel that displays a bitmap based on entity team
+//-----------------------------------------------------------------------------
+class CMinimapTraceTeamBitmapPanel : public CMinimapTracePanel
+{
+	DECLARE_CLASS( CMinimapTraceTeamBitmapPanel, CMinimapTracePanel );
+
+public:
+	CMinimapTraceTeamBitmapPanel( vgui::Panel *parent, const char *panelName )
+		: BaseClass ( parent, panelName )
+	{
+	}
+
+	// Sets the bitmap and size
+	virtual bool Init( KeyValues* pKeyValues, MinimapInitData_t* pInitData );
+
+	// Performs the rendering...
+ 	virtual void Paint();
+
+protected:
+	CTeamBitmapImage m_TeamImage;
+};
+
+
+#endif // MINIMAP_ENTITY_H
diff --git a/game/client/tf2/overlay_orders.cpp b/game/client/tf2/overlay_orders.cpp
new file mode 100644
index 0000000..ff8f830
--- /dev/null
+++ b/game/client/tf2/overlay_orders.cpp
@@ -0,0 +1,25 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $Workfile: $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "vgui_entityimagepanel.h"
+#include "CommanderOverlay.h"
+
+
+
+class COrderStatusPanel : public CEntityImagePanel
+{
+	DECLARE_CLASS( COrderStatusPanel, CEntityImagePanel );
+public:
+	COrderStatusPanel( vgui::Panel *parent, const char *panelName )
+		: BaseClass( parent, "COrderStatusPanel" )
+	{
+	}
+};
+
+
+DECLARE_OVERLAY_FACTORY( COrderStatusPanel, "personal_order" );
diff --git a/game/client/tf2/panel_effects.cpp b/game/client/tf2/panel_effects.cpp
new file mode 100644
index 0000000..505d2d6
--- /dev/null
+++ b/game/client/tf2/panel_effects.cpp
@@ -0,0 +1,1094 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"	
+#include "hud.h"
+#include "c_tf2rootpanel.h"
+#include "paneleffect.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+
+#define EFFECT_FLASH_TIME 0.7f
+
+#define EFFECT_R 100
+#define EFFECT_G 150
+#define EFFECT_B 220
+#define EFFECT_A 255
+
+#define ARROW_R 130
+#define ARROW_G 190
+#define ARROW_B 240
+#define ARROW_A 255
+
+#define AXIALLINE_R 220
+#define AXIALLINE_G 220
+#define AXIALLINE_B 255
+#define AXIALLINE_A 255
+
+//-----------------------------------------------------------------------------
+// Purpose: Helper for drawing line segments
+//-----------------------------------------------------------------------------
+class CConnectingLine
+{
+public:
+	int			m_ptStart[ 2 ];
+	int			m_ptEnd[ 2 ];
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Fill in the intersection between the two rectangles.
+// Input  : *pRect1 - 
+//			*pRect2 - 
+//			*pOut - 
+// Output : inline bool
+//-----------------------------------------------------------------------------
+inline bool GetRectIntersection( wrect_t const *pRect1, wrect_t const *pRect2, wrect_t *pOut )
+{
+	pOut->left  = MAX( pRect1->left, pRect2->left );
+	pOut->right = MIN( pRect1->right, pRect2->right );
+	if( pOut->left >= pOut->right )
+		return false;
+
+	pOut->bottom = MIN( pRect1->bottom, pRect2->bottom );
+	pOut->top    = MAX( pRect1->top, pRect2->top );
+	if( pOut->top >= pOut->bottom )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Edge to use
+//-----------------------------------------------------------------------------
+typedef enum
+{
+	TOPCENTER = 0,
+	RIGHTCENTER,
+	BOTTOMCENTER,
+	LEFTCENTER
+} LINEEDGE_t;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//			rect - 
+//			edge - 
+//			border - 
+//-----------------------------------------------------------------------------
+static void GetCenterPoint( int& x, int& y, const wrect_t& rect, LINEEDGE_t edge, int border )
+{
+	int xcenter;
+	int ycenter;
+
+	xcenter = ( rect.left + rect.right ) / 2;
+	ycenter = ( rect.top + rect.bottom ) / 2;
+
+	switch ( edge )
+	{
+	default:
+	case TOPCENTER:
+		x = xcenter;
+		y = rect.top - border;
+		break;
+	case RIGHTCENTER:
+		x = rect.right + border;
+		y = ycenter;
+		break;
+	case BOTTOMCENTER:
+		x = xcenter;
+		y = rect.bottom + border;
+		break;
+	case LEFTCENTER:
+		x = rect.left - border;
+		y = ycenter;
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Given two rectangles, finds a direct line between the two rectangles, unless
+//  they overlap, in which case no line is output.
+// Input  : x1 - 
+//			y1 - 
+//			w1 - 
+//			h1 - 
+//			x2 - 
+//			y2 - 
+//			w2 - 
+//			h2 - 
+//			output - 
+//-----------------------------------------------------------------------------
+static void FindConnectingLines_Straight( 
+	int x1, int y1, int w1, int h1, 
+	int x2, int y2, int w2, int h2, 
+	CUtlVector< CConnectingLine >& output )
+{
+	// Reset output
+	output.RemoveAll();
+
+	// If the rectangles intersect, no line needed
+	wrect_t r1;
+	r1.left = x1;
+	r1.top = y1;
+	r1.right = x1 + w1;
+	r1.bottom = y1 + h1;
+
+	wrect_t r2;
+	r2.left = x2;
+	r2.top = y2;
+	r2.right = x2 + w2;
+	r2.bottom = y2 + h2;
+
+	wrect_t dummy;
+
+	if ( GetRectIntersection( &r1, &r2, &dummy ) )
+		return;
+
+	int center1[2];
+	int center2[2];
+
+	center1[ 0 ] = x1 + w1/2;
+	center1[ 1 ] = y1 + h1/2;
+
+	center2[ 0 ] = x2 + w2/2;
+	center2[ 1 ] = y2 + h2/2;
+
+	int gaph;
+	int gapv;
+
+	LINEEDGE_t edge1 = TOPCENTER;
+	LINEEDGE_t edge2 = BOTTOMCENTER;
+
+	// Top
+	gaph = MAX( r2.left - r1.right, r1.left - r2.right );
+	gapv = MAX( r1.top - r2.bottom, r2.top - r1.bottom );
+
+	if ( gapv > gaph )
+	{
+		// vertical
+		if ( ( r1.top - r2.bottom ) > ( r2.top - r1.bottom ) )
+		{
+			edge2 = BOTTOMCENTER;
+			edge1 = TOPCENTER;
+		}
+		else
+		{
+			edge2 = TOPCENTER;
+			edge1 = BOTTOMCENTER;
+		}
+	}
+	else
+	{
+		if ( ( r1.left - r2.right ) > ( r2.left - r1.right ) )
+		{
+			// horizontal
+			edge2 = RIGHTCENTER;
+			edge1 = LEFTCENTER;
+		}
+		else
+		{
+			edge2 = LEFTCENTER;
+			edge1 = RIGHTCENTER;
+		}
+	}
+
+	int pt1[ 2 ];
+	int pt2[ 2 ];
+
+	GetCenterPoint( pt1[ 0 ], pt1[ 1 ], r1, edge1, 3 );
+	GetCenterPoint( pt2[ 0 ], pt2[ 1 ], r2, edge2, 3 );
+
+	CConnectingLine line;
+	line.m_ptStart[ 0 ] = pt1[ 0 ];
+	line.m_ptStart[ 1 ] = pt1[ 1 ];
+	line.m_ptEnd[ 0 ] = pt2[ 0 ];
+	line.m_ptEnd[ 1 ] = pt2[ 1 ];
+
+	output.AddToTail( line );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Given two non-intersecting rectangles, finds one, two or three segments
+//  which connect the midpoints of two of the sides of the items together with only
+//  axial lines.
+// Input  : x1 - 
+//			y1 - 
+//			w1 - 
+//			h1 - 
+//			x2 - 
+//			y2 - 
+//			w2 - 
+//			h2 - 
+//			output - 
+//-----------------------------------------------------------------------------
+static void FindConnectingLines_Axial( 
+	int x1, int y1, int w1, int h1, 
+	int x2, int y2, int w2, int h2, 
+	CUtlVector< CConnectingLine >& output )
+{
+	// Reset output
+	output.RemoveAll();
+
+	// If the rectangles intersect, no line needed
+	wrect_t r1;
+	r1.left = x1;
+	r1.top = y1;
+	r1.right = x1 + w1;
+	r1.bottom = y1 + h1;
+
+	wrect_t r2;
+	r2.left = x2;
+	r2.top = y2;
+	r2.right = x2 + w2;
+	r2.bottom = y2 + h2;
+	wrect_t dummy;
+
+	if ( GetRectIntersection( &r1, &r2, &dummy ) )
+		return;
+
+	int center1[2];
+	int center2[2];
+
+	center1[ 0 ] = x1 + w1/2;
+	center1[ 1 ] = y1 + h1/2;
+
+	center2[ 0 ] = x2 + w2/2;
+	center2[ 1 ] = y2 + h2/2;
+
+	int gaph;
+	int gapv;
+
+	LINEEDGE_t edge1 = TOPCENTER;
+	LINEEDGE_t edge2 = BOTTOMCENTER;
+
+	// Top
+	gaph = MAX( r2.left - r1.right, r1.left - r2.right );
+	gapv = MAX( r1.top - r2.bottom, r2.top - r1.bottom );
+
+	if ( gapv > gaph )
+	{
+		// vertical
+		if ( ( r1.top - r2.bottom ) > ( r2.top - r1.bottom ) )
+		{
+			edge2 = BOTTOMCENTER;
+			edge1 = TOPCENTER;
+		}
+		else
+		{
+			edge2 = TOPCENTER;
+			edge1 = BOTTOMCENTER;
+		}
+	}
+	else
+	{
+		if ( ( r1.left - r2.right ) > ( r2.left - r1.right ) )
+		{
+			// horizontal
+			edge2 = RIGHTCENTER;
+			edge1 = LEFTCENTER;
+		}
+		else
+		{
+			edge2 = LEFTCENTER;
+			edge1 = RIGHTCENTER;
+		}
+	}
+
+	int pt1[ 2 ];
+	int pt2[ 2 ];
+
+	GetCenterPoint( pt1[ 0 ], pt1[ 1 ], r1, edge1, 3 );
+	GetCenterPoint( pt2[ 0 ], pt2[ 1 ], r2, edge2, 3 );
+
+	CConnectingLine line;
+
+	int mid[ 2 ];
+	int size1[ 2 ];
+	int size2[ 2 ];
+
+	mid[ 0 ] = ( pt1[ 0 ] + pt2[ 0 ] ) / 2;
+	mid[ 1 ] = ( pt1[ 1 ] + pt2[ 1 ] ) / 2;
+
+	size1[ 0 ] = r1.right - r1.left;
+	size1[ 1 ] = r1.bottom - r1.top;
+
+	size2[ 0 ] = r2.right - r2.left;
+	size2[ 1 ] = r2.bottom - r2.top;
+
+	float sizefrac = 0.25f;
+
+	if ( edge1 == TOPCENTER || edge1 == BOTTOMCENTER )
+	{
+		int dx = abs( mid[ 0 ] - pt1[ 0 ] );
+		if ( dx < ( sizefrac * size1[ 0 ] ) && 
+			 dx < ( sizefrac * size2[ 0 ] ) )
+		{
+			// Gap is small, just use midpoint to align both
+			line.m_ptStart[ 0 ] = mid[ 0 ];
+			line.m_ptStart[ 1 ] = pt1[ 1 ];
+			line.m_ptEnd[ 0 ] = mid[ 0 ];
+			line.m_ptEnd[ 1 ] = pt2[ 1 ];
+
+			output.AddToTail( line );
+		}
+		else
+		{
+			// Draw an L
+			line.m_ptStart[ 0 ] = pt1[ 0 ];
+			line.m_ptStart[ 1 ] = pt1[ 1 ];
+			line.m_ptEnd[ 0 ] = pt1[ 0 ];
+			line.m_ptEnd[ 1 ] = mid[ 1 ];
+
+			output.AddToTail( line );
+
+			line.m_ptStart[ 0 ] = pt1[ 0 ];
+			line.m_ptStart[ 1 ] = mid[ 1 ];
+			line.m_ptEnd[ 0 ] = pt2[ 0 ];
+			line.m_ptEnd[ 1 ] = mid[ 1 ];
+
+			output.AddToTail( line );
+
+			line.m_ptStart[ 0 ] = pt2[ 0 ];
+			line.m_ptStart[ 1 ] = mid[ 1 ];
+			line.m_ptEnd[ 0 ] = pt2[ 0 ];
+			line.m_ptEnd[ 1 ] = pt2[ 1 ];
+
+			output.AddToTail( line );
+		}
+	}
+	else
+	{
+		int dy = abs( mid[ 1 ] - pt1[ 1 ] );
+		if ( dy < ( sizefrac * size1[ 1] ) && 
+			 dy < ( sizefrac * size2[ 1 ] ) )
+		{
+			// Gap is small, just use midpoint to align both
+			line.m_ptStart[ 0 ] = pt1[ 0 ];
+			line.m_ptStart[ 1 ] = mid[ 1 ];
+			line.m_ptEnd[ 0 ] = pt2[ 0 ];
+			line.m_ptEnd[ 1 ] = mid[ 1 ];
+
+			output.AddToTail( line );
+		}
+		else
+		{
+			// Draw an L
+			line.m_ptStart[ 0 ] = pt1[ 0 ];
+			line.m_ptStart[ 1 ] = pt1[ 1 ];
+			line.m_ptEnd[ 0 ] = mid[ 0 ];
+			line.m_ptEnd[ 1 ] = pt1[ 1 ];
+
+			output.AddToTail( line );
+
+			line.m_ptStart[ 0 ] = mid[ 0 ];
+			line.m_ptStart[ 1 ] = pt1[ 1 ];
+			line.m_ptEnd[ 0 ] = mid[ 0 ];
+			line.m_ptEnd[ 1 ] = pt2[ 1 ];
+
+			output.AddToTail( line );
+
+			line.m_ptStart[ 0 ] = mid[ 0 ];
+			line.m_ptStart[ 1 ] = pt2[ 1 ];
+			line.m_ptEnd[ 0 ] = pt2[ 0 ];
+			line.m_ptEnd[ 1 ] = pt2[ 1 ];
+
+			output.AddToTail( line );
+		}
+	}
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Map input panel rectangle into space of output panel and return extents in xywh
+// Input  : x - 
+//			y - 
+//			w - 
+//			h - 
+//			*output - 
+//			*input - 
+//-----------------------------------------------------------------------------
+void PanelToPanelRectangle( int& x, int& y, int& w, int& h, vgui::Panel *output, vgui::Panel *input )
+{
+	input->GetSize( w, h );
+	w += 2;
+	h += 2;
+
+	x = y = 0;
+	input->LocalToScreen( x, y );
+	output->ScreenToLocal( x, y );
+
+	x--;
+	y--;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Cycle between in/2 and in centered at 3/4in
+// Input  : in - 
+//			f - ranges from -1 to 1
+// Output : static int
+//-----------------------------------------------------------------------------
+static int EffectResampleColor( int in, float f )
+{
+	int base = in / 2;
+	int midpoint = ( in + base ) / 2;
+	float range = (float)( in - midpoint );
+
+	int color = midpoint + (int)( f * range );
+	return clamp( color, 0, 255 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Border flashing effect
+//-----------------------------------------------------------------------------
+class CFlashBorderPanelEffect : public CPanelEffect
+{
+	DECLARE_CLASS( CFlashBorderPanelEffect, CPanelEffect );
+public:
+
+	CFlashBorderPanelEffect( ITFHintItem *owner );
+	virtual void doPaint( vgui::Panel *panel );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *owner - 
+//-----------------------------------------------------------------------------
+CFlashBorderPanelEffect::CFlashBorderPanelEffect( ITFHintItem *owner )
+	: CPanelEffect( owner )
+{
+	// Mark type field
+	SetType( FLASHBORDER );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Paint the effect
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void CFlashBorderPanelEffect::doPaint( vgui::Panel *panel )
+{
+	vgui::Panel *p = m_hPanel;
+	if ( !p || !IsVisibleIncludingParent( p ) )
+		return;
+
+	int w, h;
+	p->GetSize( w, h );
+
+	// Convert top,left to local coordinates
+	int x = 0, y = 0;
+	p->LocalToScreen( x, y );
+	panel->ScreenToLocal( x, y );
+
+	x--;
+	y--;
+	w+=2;
+	h+=2;
+
+	float frac = fmod( gpGlobals->curtime, EFFECT_FLASH_TIME );
+	frac *= 2 * M_PI;
+	frac = cos( frac );
+
+	int r, g, b;
+
+	r = EffectResampleColor( m_r, frac );
+	g = EffectResampleColor( m_g, frac );
+	b = EffectResampleColor( m_b, frac );
+
+	vgui::surface()->DrawSetColor( r, g, b, m_a );
+
+	for ( int gap = 0; gap < 3; gap++ )
+	{
+		vgui::surface()->DrawOutlinedRect( x - gap, y - gap, x + w + gap, y + h + gap );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates an arry from m_hPanel to m_hOtherPanel
+//-----------------------------------------------------------------------------
+class CArrowPanelEffect : public CPanelEffect
+{
+	DECLARE_CLASS( CArrowPanelEffect, CPanelEffect );
+public:
+
+	CArrowPanelEffect( ITFHintItem *owner );
+
+	virtual void doPaint( vgui::Panel *panel );
+
+	void		SetDrawBorder( bool drawborder );
+	void		SetFlashing( bool flashing );
+
+protected:
+	void	DrawArrow( int startx, int starty, int endx, int endy, int r, int g, int b, int a );
+	void	DrawLine( int startx, int starty, int endx, int endy, int r, int g, int b, int a );
+	void	ComputeBestPoint( int& px, int &py, vgui::Panel *output, vgui::Panel *from, vgui::Panel *to );
+
+protected:
+
+	bool	m_bDrawBorder;
+	bool	m_bFlashing;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *owner - 
+//-----------------------------------------------------------------------------
+CArrowPanelEffect::CArrowPanelEffect( ITFHintItem *owner )
+	: CPanelEffect( owner )
+{
+	SetType( ARROW );
+
+	m_bDrawBorder = true;
+	m_bFlashing = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : drawborder - 
+//-----------------------------------------------------------------------------
+void CArrowPanelEffect::SetDrawBorder( bool drawborder )
+{
+	m_bDrawBorder = drawborder;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : flashing - 
+//-----------------------------------------------------------------------------
+void CArrowPanelEffect::SetFlashing( bool flashing )
+{
+	m_bFlashing = flashing;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : startx - 
+//			starty - 
+//			endx - 
+//			endy - 
+//			r - 
+//			g - 
+//			b - 
+//			a - 
+//-----------------------------------------------------------------------------
+void CArrowPanelEffect::DrawArrow( int startx, int starty, int endx, int endy, int r, int g, int b, int a )
+{
+	vgui::surface()->DrawSetColor( r, g, b, a );
+	
+	// Draw an arrow
+
+	Vector start( startx, starty, 0.0f );
+	Vector end( endx, endy, 0.0f );
+
+	Vector delta = end - start;
+
+	Vector right;
+
+	right.x = delta.y;
+	right.y = -delta.x;
+	right.z = 0.0f;
+
+	VectorNormalize( right );
+	Vector base;
+
+	float length = VectorNormalize( delta );
+
+	float size = MIN( length / 2.0f, 15.0f );
+
+	base = start + ( length - size ) * delta;
+
+	Vector baseLeft = base + size * 0.25f * right;
+	Vector baseRight = base - size * 0.25f * right;
+
+	vgui::surface()->DrawLine( end.x, end.y, baseLeft.x, baseLeft.y );
+	vgui::surface()->DrawLine( end.x, end.y, baseRight.x, baseRight.y );
+
+	base = start + ( length - size + size * 0.3f ) * delta;
+
+	vgui::surface()->DrawLine( base.x, base.y, baseLeft.x, baseLeft.y );
+	vgui::surface()->DrawLine( base.x, base.y, baseRight.x, baseRight.y );
+
+	vgui::surface()->DrawLine( startx, starty, base.x, base.y );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : startx - 
+//			starty - 
+//			endx - 
+//			endy - 
+//			r - 
+//			g - 
+//			b - 
+//			a - 
+//-----------------------------------------------------------------------------
+void CArrowPanelEffect::DrawLine( int startx, int starty, int endx, int endy, int r, int g, int b, int a )
+{
+	vgui::surface()->DrawSetColor( r, g, b, a );
+	vgui::surface()->DrawLine( startx, starty, endx, endy );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void CArrowPanelEffect::doPaint( vgui::Panel *panel )
+{
+	vgui::Panel *from = m_hPanel;
+	if ( !from || !IsVisibleIncludingParent( from ) )
+		return;
+
+	int r, g, b;
+	// Determine flash amount
+	if ( m_bFlashing )
+	{
+		float frac = fmod( gpGlobals->curtime, EFFECT_FLASH_TIME );
+		frac *= 2 * M_PI;
+		frac = cos( frac );
+
+		// Resample color
+
+		r = EffectResampleColor( m_r, frac );
+		g = EffectResampleColor( m_g, frac );
+		b = EffectResampleColor( m_b, frac );
+	}
+	else
+	{
+		r = m_r;
+		g = m_g;
+		b = m_b;
+	}
+
+	int startx, starty, startw, starth;
+	int endx, endy, endw, endh;
+
+	PanelToPanelRectangle( startx, starty, startw, starth, panel, from );
+
+	if ( !GetTargetRectangle( panel, endx, endy, endw, endh ) )
+		return;
+
+	CUtlVector< CConnectingLine > lines;
+
+	FindConnectingLines_Straight( startx, starty, startw, starth, endx, endy, endw, endh, lines );
+
+	int i;
+
+	if ( m_bDrawBorder )
+	{
+		for ( i = 0; i < lines.Size(); i++ )
+		{
+			CConnectingLine *l = &lines[ i ];
+
+			// Make it thicker
+			int hstep = 0;
+			int vstep = 0;
+
+			if ( abs( l->m_ptEnd[ 1 ] - l->m_ptStart[ 1 ] ) > abs( l->m_ptEnd[ 0 ] - l->m_ptStart[ 0 ] ) )
+			{
+				// Taller so draw horizontally
+				hstep = 1;
+			}
+			else
+			{
+				vstep = 1;
+			}
+
+			// Draw a black border
+			for ( int x = -1; x <= 1 + hstep; x ++ )
+			{
+				for ( int y = -1; y <= 1 + vstep; y ++ )
+				{
+					if ( !x && !y )
+						continue;
+
+					if ( i == lines.Size() - 1 )
+					{
+						DrawArrow( l->m_ptStart[ 0 ] + x, l->m_ptStart[1] + y, l->m_ptEnd[0] + x, l->m_ptEnd[1] + y, 0, 0, 0, m_a );	
+					}
+					else
+					{
+						DrawLine( l->m_ptStart[ 0 ] + x, l->m_ptStart[1] + y, l->m_ptEnd[0] + x, l->m_ptEnd[1] + y, 0, 0, 0, m_a );	
+					}
+				}
+			}
+		}
+	}
+
+	for ( i = 0; i < lines.Size(); i++ )
+	{
+		CConnectingLine *l = &lines[ i ];
+
+		// Make it thicker
+		int hstep = 0;
+		int vstep = 0;
+
+		if ( abs( l->m_ptEnd[ 1 ] - l->m_ptStart[ 1 ] ) > abs( l->m_ptEnd[ 0 ] - l->m_ptStart[ 0 ] ) )
+		{
+			// Taller so draw horizontally
+			hstep = 1;
+		}
+		else
+		{
+			vstep = 1;
+		}
+
+		if ( i == lines.Size() - 1 )
+		{
+			// Draw arrow
+			DrawArrow( l->m_ptStart[ 0 ], l->m_ptStart[ 1 ], l->m_ptEnd[ 0 ], l->m_ptEnd[ 1 ], r, g, b, m_a );
+			// Draw a second time, but thicker
+			DrawArrow( l->m_ptStart[ 0 ] + hstep, l->m_ptStart[ 1 ] + vstep, l->m_ptEnd[ 0 ] + hstep, l->m_ptEnd[ 1 ] + vstep, r, g, b, m_a );
+		}
+		else
+		{
+			// Draw arrow
+			DrawLine( l->m_ptStart[ 0 ], l->m_ptStart[ 1 ], l->m_ptEnd[ 0 ], l->m_ptEnd[ 1 ], r, g, b, m_a );
+			// Draw a second time, but thicker
+			DrawLine( l->m_ptStart[ 0 ] + hstep, l->m_ptStart[ 1 ] + vstep, l->m_ptEnd[ 0 ] + hstep, l->m_ptEnd[ 1 ] + vstep, r, g, b, m_a );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : px - 
+//			&py - 
+//			*output - 
+//			*from - 
+//			*to - 
+//-----------------------------------------------------------------------------
+void CArrowPanelEffect::ComputeBestPoint( int& px, int &py, vgui::Panel *output, vgui::Panel *from, vgui::Panel *to )
+{
+	int fw, fh;
+	int tw, th;
+	from->GetSize( fw, fh );
+	to->GetSize( tw, th );
+
+	// Convert top,left to local coordinates
+	int fx = 0, fy = 0;
+	int tx = 0, ty = 0;
+	from->LocalToScreen( fx, fy );
+	output->ScreenToLocal( fx, fy );
+
+	to->LocalToScreen( tx, ty );
+	output->ScreenToLocal( tx, ty );
+
+	fx--;
+	fy--;
+	tx--;
+	ty--;
+	fw+=2;
+	fh+=2;
+	tw+=2;
+	th+=2;
+
+	int type = 0;
+
+	// is to totally below from
+	if ( ty > ( fy + fh ) )
+	{
+		type = 0;
+	}
+	// is to totally above from
+	else if ( ty + th < fy )
+	{
+		type = 2;
+	}
+	// is to totally to the left of from
+	else if ( tx + tw < fx )
+	{
+		type = 3;
+	}
+	// is to totally to the rigth of from
+	else if ( tx > fx + fw )
+	{
+		type = 1;
+	}
+	else
+	{
+		type = 2;
+	}
+
+	int border = 1;
+
+	switch ( type )
+	{
+	// unknown, just use object center point
+	default:
+	case 4:
+		//
+		px = fx + fw  / 2;
+		py = fy + fh / 2;
+		break;
+	//bottom
+	case 0:
+		px = fx + fw / 2;
+		py = fy + fh + border;
+		break;
+	// right
+	case 1:
+		px = fx + fw + border;
+		py = fy + fh / 2;
+		break;
+	// top
+	case 2:
+		px = fx + fw / 2;
+		py = fy - border;
+		break;
+	// left
+	case 3:
+		px = fx - border;
+		py = fy + fh / 2;
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates an axial line effect between the two specified panels
+//-----------------------------------------------------------------------------
+class CAxialLinePanelEffect : public CArrowPanelEffect
+{
+DECLARE_CLASS( CAxialLinePanelEffect, CArrowPanelEffect );
+public:
+	CAxialLinePanelEffect( ITFHintItem *owner );
+
+	virtual void doPaint( vgui::Panel *panel );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *owner - 
+//-----------------------------------------------------------------------------
+CAxialLinePanelEffect::CAxialLinePanelEffect( ITFHintItem *owner )
+: CArrowPanelEffect( owner )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void CAxialLinePanelEffect::doPaint( vgui::Panel *panel )
+{
+	vgui::Panel *from = m_hPanel;
+	if ( !from || !IsVisibleIncludingParent( from ) )
+		return;
+
+	int r, g, b;
+
+	if ( m_bFlashing )
+	{
+		// Determine flash amount
+		float frac = fmod( gpGlobals->curtime, EFFECT_FLASH_TIME );
+		frac *= 2 * M_PI;
+		frac = cos( frac );
+
+		// Resample color
+		r = EffectResampleColor( m_r, frac );
+		g = EffectResampleColor( m_g, frac );
+		b = EffectResampleColor( m_b, frac );
+	}
+	else
+	{
+		r = m_r;
+		g = m_g;
+		b = m_b;
+	}
+
+	int startx, starty, startw, starth;
+	int endx, endy, endw, endh;
+
+	PanelToPanelRectangle( startx, starty, startw, starth, panel, from );
+
+	if ( !GetTargetRectangle( panel, endx, endy, endw, endh ) )
+		return;
+
+	CUtlVector< CConnectingLine > lines;
+
+	FindConnectingLines_Axial( startx, starty, startw, starth, endx, endy, endw, endh, lines );
+
+	int i;
+
+	if ( m_bDrawBorder )
+	{
+		for ( i = 0; i < lines.Size(); i++ )
+		{
+			CConnectingLine *l = &lines[ i ];
+
+			// Draw a black border
+			for ( int x = -1; x <= 1; x ++ )
+			{
+				for ( int y = -1; y <= 1; y ++ )
+				{
+					if ( !x && !y )
+						continue;
+
+					DrawLine( l->m_ptStart[ 0 ] + x, l->m_ptStart[1] + y, l->m_ptEnd[0] + x, l->m_ptEnd[1] + y, 0, 0, 0, m_a );	
+				}
+			}
+		}
+	}
+
+	// Draw actual lines
+	for ( i = 0; i < lines.Size(); i++ )
+	{
+		CConnectingLine *l = &lines[ i ];
+		DrawLine( l->m_ptStart[ 0 ], l->m_ptStart[ 1 ], l->m_ptEnd[ 0 ], l->m_ptEnd[ 1 ], r, g, b, m_a );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *owner - 
+//			*target - 
+// Output : EFFECT_HANDLE
+//-----------------------------------------------------------------------------
+EFFECT_HANDLE CreateFlashEffect( ITFHintItem *owner, vgui::Panel *target )
+{
+	if ( !g_pTF2RootPanel )
+		return EFFECT_INVALID_HANDLE;
+
+	CFlashBorderPanelEffect *e = new CFlashBorderPanelEffect( owner );
+
+	e->SetColor( EFFECT_R, EFFECT_G, EFFECT_B, EFFECT_A );
+	// e->SetEndTime( gpGlobals->curtime + 15.0f );
+	e->SetPanel( target );
+
+	g_pTF2RootPanel->AddEffect( e );
+
+	return e->GetHandle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *owner - 
+//			*from - 
+//			*to - 
+// Output : EFFECT_HANDLE
+//-----------------------------------------------------------------------------
+EFFECT_HANDLE CreateArrowEffect( ITFHintItem *owner, vgui::Panel *from, vgui::Panel *to )
+{
+	if ( !g_pTF2RootPanel )
+		return EFFECT_INVALID_HANDLE;
+
+	CArrowPanelEffect *e = new CArrowPanelEffect( owner );
+
+	e->SetColor( ARROW_R, ARROW_G, ARROW_B, ARROW_A );
+	e->SetPanel( from );
+	e->SetPanelOther( to );
+
+	g_pTF2RootPanel->AddEffect( e );
+
+	return e->GetHandle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *owner - 
+//			*from - 
+//			*to - 
+// Output : EFFECT_HANDLE
+//-----------------------------------------------------------------------------
+EFFECT_HANDLE CreateAxialLineEffect( ITFHintItem *owner, vgui::Panel *from, vgui::Panel *to )
+{
+	if ( !g_pTF2RootPanel )
+		return EFFECT_INVALID_HANDLE;
+
+	CAxialLinePanelEffect *e = new CAxialLinePanelEffect( owner );
+
+	e->SetColor( AXIALLINE_R, AXIALLINE_G, AXIALLINE_B, AXIALLINE_A );
+	e->SetPanel( from );
+	e->SetPanelOther( to );
+
+	e->SetFlashing( false );
+	e->SetDrawBorder( false );
+
+	g_pTF2RootPanel->AddEffect( e );
+
+	return e->GetHandle();
+}
+
+EFFECT_HANDLE CreateArrowEffectToPoint( ITFHintItem *owner, vgui::Panel *from, int x, int y )
+{
+	if ( !g_pTF2RootPanel )
+		return EFFECT_INVALID_HANDLE;
+
+	CArrowPanelEffect *e = new CArrowPanelEffect( owner );
+
+	e->SetColor( ARROW_R, ARROW_G, ARROW_B, ARROW_A );
+	e->SetPanel( from );
+	e->SetTargetPoint( x, y );
+
+	g_pTF2RootPanel->AddEffect( e );
+
+	return e->GetHandle();
+}
+
+EFFECT_HANDLE CreateAxialLineEffectToPoint( ITFHintItem *owner, vgui::Panel *from, int x, int y )
+{
+	if ( !g_pTF2RootPanel )
+		return EFFECT_INVALID_HANDLE;
+
+	CAxialLinePanelEffect *e = new CAxialLinePanelEffect( owner );
+
+	e->SetColor( AXIALLINE_R, AXIALLINE_G, AXIALLINE_B, AXIALLINE_A );
+	e->SetPanel( from );
+	e->SetTargetPoint( x, y );
+
+	e->SetFlashing( false );
+	e->SetDrawBorder( false );
+
+	g_pTF2RootPanel->AddEffect( e );
+
+	return e->GetHandle();
+}
+
+EFFECT_HANDLE CreateArrowEffectToRect( ITFHintItem *owner, vgui::Panel *from, int x, int y, int w, int h )
+{
+	if ( !g_pTF2RootPanel )
+		return EFFECT_INVALID_HANDLE;
+
+	CArrowPanelEffect *e = new CArrowPanelEffect( owner );
+
+	e->SetColor( ARROW_R, ARROW_G, ARROW_B, ARROW_A );
+	e->SetPanel( from );
+	e->SetTargetRect( x, y, w, h );
+
+	g_pTF2RootPanel->AddEffect( e );
+
+	return e->GetHandle();
+}
+
+EFFECT_HANDLE CreateAxialLineEffectToRect( ITFHintItem *owner, vgui::Panel *from, int x, int y, int w, int h )
+{
+	if ( !g_pTF2RootPanel )
+		return EFFECT_INVALID_HANDLE;
+
+	CAxialLinePanelEffect *e = new CAxialLinePanelEffect( owner );
+
+	e->SetColor( AXIALLINE_R, AXIALLINE_G, AXIALLINE_B, AXIALLINE_A );
+	e->SetPanel( from );
+	e->SetTargetRect( x, y, w, h );
+
+	e->SetFlashing( false );
+	e->SetDrawBorder( false );
+
+	g_pTF2RootPanel->AddEffect( e );
+
+	return e->GetHandle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *owner - 
+//-----------------------------------------------------------------------------
+void DestroyPanelEffects( ITFHintItem *owner )
+{
+	if ( !g_pTF2RootPanel )
+		return;
+
+	g_pTF2RootPanel->DestroyPanelEffects( owner );
+}
\ No newline at end of file
diff --git a/game/client/tf2/paneleffect.cpp b/game/client/tf2/paneleffect.cpp
new file mode 100644
index 0000000..8db00b1
--- /dev/null
+++ b/game/client/tf2/paneleffect.cpp
@@ -0,0 +1,414 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "PanelEffect.h"
+#include "vgui_int.h"
+#include <vgui_controls/Panel.h>
+#include <vgui/IPanel.h>
+
+void PanelToPanelRectangle( int& x, int& y, int& w, int& h, vgui::Panel *output, vgui::Panel *input );
+
+// Global panel counter for effects
+EFFECT_HANDLE CPanelEffect::m_nHandleCount = 0;
+
+//-----------------------------------------------------------------------------
+// Purpose: Base panel effect
+// Input  : *owner - 
+//-----------------------------------------------------------------------------
+CPanelEffect::CPanelEffect( ITFHintItem *owner )
+	: m_pOwner( owner )
+{
+	// Assign it a unique handle index
+	m_Handle		= ++m_nHandleCount;
+
+	SetType( UNKNOWN );
+	SetPanel( NULL );
+	SetPanelOther( NULL );
+	SetColor( 0, 0, 0, 255 );
+	SetEndTime( 0.0f );
+	SetShouldRemove( false );
+	SetUsingOffset( false, 0, 0 );
+	SetTargetType( ENDPOINT_UNKNOWN );
+	SetVisible( true );
+
+	m_ptX = 0;
+	m_ptY = 0;
+	m_rectX = 0;
+	m_rectY = 0;
+	m_rectW = 0;
+	m_rectH = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CPanelEffect::~CPanelEffect()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *owner - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetOwner( ITFHintItem *owner )
+{
+	m_pOwner = owner;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : ITFHintItem
+//-----------------------------------------------------------------------------
+ITFHintItem *CPanelEffect::GetOwner( void )
+{
+	return m_pOwner;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : EFFECT_HANDLE
+//-----------------------------------------------------------------------------
+EFFECT_HANDLE CPanelEffect::GetHandle( void )
+{
+	return m_Handle;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Override for specific painting effects
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::doPaint( vgui::Panel *panel )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Default think checks for panels that have a specific lifetime
+//-----------------------------------------------------------------------------
+void CPanelEffect::Think( void )
+{
+	if ( !m_flEndTime )
+		return;
+
+	if ( gpGlobals->curtime > m_flEndTime )
+	{
+		SetShouldRemove( true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CPanelEffect::ShouldRemove( void )
+{
+	return m_bShouldRemove;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : remove - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetShouldRemove( bool remove )
+{
+	m_bShouldRemove = remove;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : type - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetType( int type )
+{
+	m_nType = type;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CPanelEffect::GetType( void )
+{
+	return m_nType;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetPanel( vgui::Panel *panel )
+{
+	m_hPanel = panel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : vgui::Panel
+//-----------------------------------------------------------------------------
+vgui::Panel *CPanelEffect::GetPanel( void )
+{
+	return m_hPanel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *panel - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetPanelOther( vgui::Panel *panel )
+{
+	SetTargetType( ENDPOINT_PANEL );
+	m_hOtherPanel = panel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : vgui::Panel
+//-----------------------------------------------------------------------------
+vgui::Panel *CPanelEffect::GetPanelOther( void )
+{
+	return m_hOtherPanel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : r - 
+//			g - 
+//			b - 
+//			a - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetColor( int r, int g, int b, int a )
+{
+	m_r = r;
+	m_g = g;
+	m_b = b;
+	m_a = a;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : r - 
+//			g - 
+//			b - 
+//			a - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::GetColor( int& r, int& g, int& b, int& a )
+{
+	r = m_r;
+	g = m_g;
+	b = m_b;
+	a = m_a;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : time - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetEndTime( float time )
+{
+	m_flEndTime = time;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CPanelEffect::GetEndTime( void )
+{
+	return m_flEndTime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : active - 
+//			x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetUsingOffset( bool active, int x, int y )
+{
+	m_bEndpointIsCoordinate = active;
+	m_nOffset[ 0 ] = x;
+	m_nOffset[ 1 ] = y;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CPanelEffect::GetUsingOffset( void )
+{
+	return m_bEndpointIsCoordinate;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::GetOffset( int& x, int& y )
+{
+	x = m_nOffset[ 0 ];
+	y = m_nOffset[ 1 ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns false if the panel is not visible or is the child of a not visible
+//  parent
+// assumes panel hierarchy stops at the client .dll root panel
+// If parent is some other panel, then this will return false
+// Input  : *panel - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CPanelEffect::IsVisibleIncludingParent( vgui::Panel *panel )
+{
+	vgui::VPANEL p = panel->GetVPanel();
+	while ( p )
+	{
+		if ( !vgui::ipanel()->IsVisible(p) )
+			return false;
+
+		if ( p == VGui_GetClientDLLRootPanel() )
+		{
+			return true;
+		}
+
+		p = vgui::ipanel()->GetParent(p);
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CPanelEffect::GetTargetType( void )
+{
+	return m_TargetType;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : type - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetTargetType( int type )
+{
+	m_TargetType = type;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *outpanel - 
+//			int&x - 
+//			int&y - 
+//			int&w - 
+//			int&h - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CPanelEffect::GetTargetRectangle( vgui::Panel *outpanel, int&x, int&y, int&w, int&h )
+{
+	x = y = 0;
+	w = h = 1;
+
+	switch ( m_TargetType )
+	{
+	default:
+		return false;
+		break;
+	case ENDPOINT_PANEL:
+		{
+			vgui::Panel *to = m_hOtherPanel;
+			if ( !to )
+				return false;
+
+			if ( !IsVisibleIncludingParent( to ) )
+			{
+				return false;
+			}
+
+			PanelToPanelRectangle( x, y, w, h, outpanel, to );
+
+			// Using an offset into a panel
+			if ( GetUsingOffset() )
+			{
+				int ofsx, ofsy;
+
+				GetOffset( ofsx, ofsy );
+
+				x = x + ofsx-3;
+				w = 6;
+				y = y + ofsy-3;
+				h = 6;
+			}
+		}
+		break;
+	case ENDPOINT_RECTANGLE:
+		{
+			x = m_rectX;
+			y = m_rectY;
+			w = m_rectW;
+			h = m_rectH;
+		}
+		break;
+	case ENDPOINT_POINT:
+		{
+			x = m_ptX;
+			y = m_ptY;
+			w = 1;
+			h = 1;
+		}
+		break;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetTargetPoint( int x, int y )
+{
+	SetTargetType( ENDPOINT_POINT );
+	m_ptX = x;
+	m_ptY = y;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//			y - 
+//			w - 
+//			h - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetTargetRect( int x, int y, int w, int h )
+{
+	SetTargetType( ENDPOINT_RECTANGLE );
+	m_rectX = x;
+	m_rectY = y;
+	m_rectW = w;
+	m_rectH = h;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : visible - 
+//-----------------------------------------------------------------------------
+void CPanelEffect::SetVisible( bool visible )
+{
+	m_bVisible = visible;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CPanelEffect::GetVisible( void )
+{
+	return m_bVisible;
+}
+
diff --git a/game/client/tf2/paneleffect.h b/game/client/tf2/paneleffect.h
new file mode 100644
index 0000000..a5860a7
--- /dev/null
+++ b/game/client/tf2/paneleffect.h
@@ -0,0 +1,166 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef PANELEFFECT_H
+#define PANELEFFECT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+namespace vgui
+{
+	class Panel;
+}
+
+class ITFHintItem;
+
+#include <vgui_controls/PHandle.h>
+
+// Serial under of effect, for safe lookup
+typedef unsigned int EFFECT_HANDLE;
+#define EFFECT_INVALID_HANDLE (EFFECT_HANDLE)(~0)
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CPanelEffect
+{
+public:
+	DECLARE_CLASS_NOBASE( CPanelEffect );
+
+	enum
+	{
+		UNKNOWN = 0,
+		FLASHBORDER,
+		ARROW,
+	};
+
+	enum
+	{
+		ENDPOINT_UNKNOWN = 0,
+		ENDPOINT_PANEL,
+		ENDPOINT_POINT,
+		ENDPOINT_RECTANGLE,
+		ENDPOINT_ENTITY,
+	};
+
+
+							CPanelEffect( ITFHintItem *owner );
+	virtual					~CPanelEffect();
+
+	virtual void			doPaint( vgui::Panel *panel );
+
+	virtual void			Think( void );
+
+	virtual bool			ShouldRemove( void );
+	virtual void			SetShouldRemove( bool remove );
+
+	virtual EFFECT_HANDLE	GetHandle( void );
+
+	virtual void			SetType( int type );
+	virtual int				GetType( void );
+
+	virtual void			SetPanel( vgui::Panel *panel );
+	virtual vgui::Panel		*GetPanel( void );
+
+	virtual void			SetPanelOther( vgui::Panel *panel );
+	virtual vgui::Panel		*GetPanelOther( void );
+
+	virtual void			SetTargetPoint( int x, int y );
+	virtual void			SetTargetRect( int x, int y, int w, int h );
+	
+	virtual void			SetColor( int r, int g, int b, int a );
+	virtual void			GetColor( int& r, int& g, int& b, int& a );
+
+	virtual void			SetEndTime( float time );
+	virtual float			GetEndTime( void );
+
+	virtual void			SetOwner( ITFHintItem *owner );
+	virtual ITFHintItem		*GetOwner( void );
+
+	virtual void			SetUsingOffset( bool active, int x, int y );
+	virtual bool			GetUsingOffset( void );
+	virtual void			GetOffset( int& x, int& y );
+
+	virtual int				GetTargetType( void );
+	virtual void			SetTargetType( int type );
+	virtual bool			GetTargetRectangle( vgui::Panel *outpanel, int&x, int&y, int&w, int&h );
+
+	virtual void			SetVisible( bool visible );
+	virtual bool			GetVisible( void );
+
+private:
+
+	static EFFECT_HANDLE	m_nHandleCount;
+
+protected:
+
+	virtual bool			IsVisibleIncludingParent( vgui::Panel *panel );
+
+	EFFECT_HANDLE			m_Handle;
+
+	ITFHintItem				*m_pOwner;
+
+	// Data
+	
+	// type of effect
+	int						m_nType;
+
+	// effect targets
+	vgui::PHandle			m_hPanel;
+	vgui::PHandle			m_hOtherPanel;
+
+	// effect color
+	int						m_r, m_g, m_b, m_a;
+
+	float					m_flEndTime;// 0.0f for no end time
+
+	// true if we should offset endpoint of arrow/lines into m_hOtherPanel by m_nOffset amount
+	bool					m_bEndpointIsCoordinate;
+	// x, y offset into destination panel
+	int						m_nOffset[ 2 ];
+
+	bool					m_bShouldRemove;
+
+	int						m_TargetType;
+	int						m_ptX;
+	int						m_ptY;
+	int						m_rectX;
+	int						m_rectY;
+	int						m_rectW;
+	int						m_rectH;
+
+	bool					m_bVisible;
+};
+
+#define EFFECT_FLASH_TIME 0.7f
+
+#define EFFECT_R 100
+#define EFFECT_G 150
+#define EFFECT_B 220
+#define EFFECT_A 255
+
+#define ARROW_R 130
+#define ARROW_G 190
+#define ARROW_B 240
+#define ARROW_A 255
+
+#define AXIALLINE_R 220
+#define AXIALLINE_G 220
+#define AXIALLINE_B 255
+#define AXIALLINE_A 255
+
+// Panel effect APIs
+void DestroyPanelEffects( ITFHintItem *owner );
+EFFECT_HANDLE CreateFlashEffect( ITFHintItem *owner, vgui::Panel *target );
+EFFECT_HANDLE CreateArrowEffect( ITFHintItem *owner, vgui::Panel *from, vgui::Panel *to );
+EFFECT_HANDLE CreateAxialLineEffect( ITFHintItem *owner, vgui::Panel *from, vgui::Panel *to );
+EFFECT_HANDLE CreateArrowEffectToPoint( ITFHintItem *owner, vgui::Panel *from, int x, int y );
+EFFECT_HANDLE CreateAxialLineEffectToPoint( ITFHintItem *owner, vgui::Panel *from, int x, int y );
+EFFECT_HANDLE CreateArrowEffectToRect( ITFHintItem *owner, vgui::Panel *from, int x, int y, int w, int h );
+EFFECT_HANDLE CreateAxialLineEffectToRect( ITFHintItem *owner, vgui::Panel *from, int x, int y, int w, int h );
+
+#endif // PANELEFFECT_H
diff --git a/game/client/tf2/playerandobjectenumerator.cpp b/game/client/tf2/playerandobjectenumerator.cpp
new file mode 100644
index 0000000..a037b6d
--- /dev/null
+++ b/game/client/tf2/playerandobjectenumerator.cpp
@@ -0,0 +1,69 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "playerandobjectenumerator.h"
+#include "tf_shareddefs.h"
+
+// Enumator class for ragdolls being affected by explosive forces
+CPlayerAndObjectEnumerator::CPlayerAndObjectEnumerator( float radius )
+{
+	m_flRadiusSquared		= radius * radius;
+	m_Objects.RemoveAll();
+	m_pLocal = C_BasePlayer::GetLocalPlayer();
+}
+
+int	CPlayerAndObjectEnumerator::GetObjectCount()
+{
+	return m_Objects.Size();
+}
+
+C_BaseEntity *CPlayerAndObjectEnumerator::GetObject( int index )
+{
+	if ( index < 0 || index >= GetObjectCount() )
+		return NULL;
+
+	return m_Objects[ index ];
+}
+
+// Actual work code
+IterationRetval_t CPlayerAndObjectEnumerator::EnumElement( IHandleEntity *pHandleEntity )
+{
+	if ( !m_pLocal )
+		return ITERATION_STOP;
+
+	C_BaseEntity *pEnt = ClientEntityList().GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
+	if ( pEnt == NULL )
+		return ITERATION_CONTINUE;
+
+	if ( pEnt == m_pLocal )
+		return ITERATION_CONTINUE;
+
+	if ( !pEnt->IsPlayer() &&
+		 !pEnt->IsBaseObject() )
+	{
+		return ITERATION_CONTINUE;
+	}
+
+	// Ignore vehicles, since they have vcollide collisions that's push me away
+	if ( pEnt->GetCollisionGroup() == COLLISION_GROUP_VEHICLE )
+		return ITERATION_CONTINUE;
+
+	// If it's solid to player movement, don't steer around it since we'll just bump into it
+	if ( pEnt->GetCollisionGroup() == TFCOLLISION_GROUP_OBJECT_SOLIDTOPLAYERMOVEMENT )
+		return ITERATION_CONTINUE;
+
+	Vector	deltaPos = pEnt->GetAbsOrigin() - m_pLocal->GetAbsOrigin();
+	if ( deltaPos.LengthSqr() > m_flRadiusSquared )
+		return ITERATION_CONTINUE;
+
+	CHandle< C_BaseEntity > h;
+	h = pEnt;
+	m_Objects.AddToTail( h );
+
+	return ITERATION_CONTINUE;
+}
\ No newline at end of file
diff --git a/game/client/tf2/playerandobjectenumerator.h b/game/client/tf2/playerandobjectenumerator.h
new file mode 100644
index 0000000..0f6fa2d
--- /dev/null
+++ b/game/client/tf2/playerandobjectenumerator.h
@@ -0,0 +1,44 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef PLAYERANDOBJECTENUMERATOR_H
+#define PLAYERANDOBJECTENUMERATOR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "utlvector.h"
+#include "ehandle.h"
+#include "ispatialpartition.h"
+
+class C_BaseEntity;
+class C_BasePlayer;
+
+// Enumator class for finding other players and objects close to the
+//  local player
+class CPlayerAndObjectEnumerator : public IPartitionEnumerator
+{
+	DECLARE_CLASS_NOBASE( CPlayerAndObjectEnumerator );
+public:
+	//Forced constructor
+	CPlayerAndObjectEnumerator( float radius );
+
+	//Actual work code
+	virtual IterationRetval_t EnumElement( IHandleEntity *pHandleEntity );
+
+	int	GetObjectCount();
+	C_BaseEntity *GetObject( int index );
+
+public:
+	//Data members
+	float	m_flRadiusSquared;
+
+	CUtlVector< CHandle< C_BaseEntity > > m_Objects;
+	C_BasePlayer *m_pLocal;
+};
+
+#endif // PLAYERANDOBJECTENUMERATOR_H
diff --git a/game/client/tf2/playeroverlay.cpp b/game/client/tf2/playeroverlay.cpp
new file mode 100644
index 0000000..1ef91ae
--- /dev/null
+++ b/game/client/tf2/playeroverlay.cpp
@@ -0,0 +1,368 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "playeroverlay.h"
+#include "playeroverlayhealth.h"
+#include "playeroverlayname.h"
+#include "playeroverlayclass.h"
+#include "playeroverlayselected.h"
+#include "playeroverlaysquad.h"
+#include "hud_minimap.h"
+#include "c_basetfplayer.h"
+#include "mapdata.h"
+#include "c_playerresource.h"
+#include "c_team.h"
+#include "commanderoverlay.h"
+#include <KeyValues.h>
+#include <vgui/IVGui.h>
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Class factory
+//-----------------------------------------------------------------------------
+
+DECLARE_OVERLAY_FACTORY( CHudPlayerOverlay, "player" );
+
+
+// THE ACTUAL OVERLAY
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlay::CHudPlayerOverlay( vgui::Panel *parent, const char *panelName )
+: BaseClass( parent, "CHudPlayerOverlay" )
+{
+	m_pHealth	= 0;
+	m_pName		= 0;
+	m_pClass	= 0;
+	m_pSquad	= 0;
+	m_pSelected = 0;
+
+	SetAutoDelete( false );
+
+	m_hPlayer = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlay::~CHudPlayerOverlay( void )
+{
+	Clear();
+}
+
+void CHudPlayerOverlay::Clear( void )
+{
+	delete m_pHealth;
+	delete m_pName;
+	delete m_pClass;
+	delete m_pSelected;
+	delete m_pSquad;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CHudPlayerOverlay::Init( KeyValues* pInitData, C_BaseEntity* pEntity )
+{
+	Clear();
+
+	m_hPlayer = dynamic_cast< C_BaseTFPlayer * >( pEntity );
+	if (!m_hPlayer.Get())
+		return false;
+
+	if (!BaseClass::Init( pInitData, pEntity ))
+		return false;
+
+	if (!ParseRGBA(pInitData, "fgcolor", m_fgColor ))
+		return false;
+
+	if (!ParseRGBA(pInitData, "bgcolor", m_bgColor ))
+		return false;
+
+	if (!ParseCoord(pInitData, "offset", m_OffsetX, m_OffsetY ))
+		return false;
+
+	int w, h;
+	if (!ParseCoord(pInitData, "size", w, h ))
+		return false;
+
+	SetSize( w, h );
+	SetVisible( false );
+
+	m_iOrgWidth = w;
+	m_iOrgHeight = h;
+	m_iOrgOffsetX = m_OffsetX;
+	m_iOrgOffsetY = m_OffsetY;
+
+	const char *mouseover = pInitData->GetString( "mousehint", "" );
+	if ( mouseover && mouseover[ 0 ] )
+	{
+		Q_strncpy( m_szMouseOverText, mouseover, sizeof( m_szMouseOverText ) );
+	}
+
+	m_pHealth = new CHudPlayerOverlayHealth( this );
+	KeyValues* pHealthValue = pInitData->FindKey("HealthBar");
+	if (!m_pHealth->Init( pHealthValue ))
+		return false;
+
+	m_pHealth->SetVisible( false );
+	m_pHealth->SetParent( this );
+
+	m_pName = new CHudPlayerOverlayName( this, "" );
+	KeyValues* pNameValue = pInitData->FindKey("Name");
+	if (!m_pName->Init( pNameValue ))
+		return false;
+
+	m_pName->SetVisible( false );
+	m_pName->SetParent( this );
+
+	m_pClass = new CHudPlayerOverlayClass( this );
+	KeyValues* pClassValue = pInitData->FindKey("Class");
+	if (!m_pClass->Init( pClassValue ))
+		return false;
+
+	m_pClass->SetVisible( false );
+	m_pClass->SetParent( this );
+
+	m_pSquad = new CHudPlayerOverlaySquad( this, "" );
+	KeyValues* pSquadValue = pInitData->FindKey("Squad");
+	if (!m_pSquad->Init( pSquadValue ))
+		return false;
+
+	m_pSquad->SetVisible( false );
+	m_pSquad->SetParent( this );
+
+	m_pSelected = new CHudPlayerOverlaySelected( this );
+	KeyValues* pSelectedValue = pInitData->FindKey("Selection");
+	if (!m_pSelected->Init( pSelectedValue ))
+		return false;
+
+	m_pSelected->SetVisible( false );
+	m_pSelected->SetParent( this );
+
+	// Um, is there a better way?
+	m_PlayerNum = GetEntity() ? GetEntity()->index : 0;
+	if (m_PlayerNum == 0)
+		return false;
+
+	return true;
+}
+
+void CHudPlayerOverlay::Hide( void )
+{
+	SetVisible( false );
+	if ( m_pHealth )
+	{
+		m_pHealth->SetVisible( false);
+	}
+
+	if ( m_pName )
+	{
+		m_pName->SetVisible( false );
+	}
+
+	if ( m_pClass )
+	{
+		m_pClass->SetVisible( false );
+	}
+
+	if ( m_pSquad )
+	{
+		m_pSquad->SetVisible( false );
+	}
+
+	if ( m_pSelected )
+	{
+		m_pSelected->SetVisible( false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : playerNum - 
+//-----------------------------------------------------------------------------
+
+void CHudPlayerOverlay::OnTick( )
+{
+	BaseClass::OnTick();
+
+	if (!IsLocalPlayerInTactical() || !engine->IsInGame())
+	{
+		Hide();
+		return;
+	}
+
+	// Don't draw if I'm not visible in the tactical map
+	if ( MapData().IsEntityVisibleToTactical( GetEntity() ) == false )
+	{
+		Hide();
+		return;
+	}
+
+	// Don't draw it if I'm on team 0 (haven't decided on a team)
+	C_BaseTFPlayer *pPlayer = m_hPlayer.Get();
+	if (!pPlayer || (pPlayer->GetTeamNumber() == 0) || (pPlayer->GetClass() == TFCLASS_UNDECIDED))
+	{
+		Hide();
+		return;
+	}
+
+	SetVisible( true );
+
+	const char *pName = g_PR->GetPlayerName( m_PlayerNum );
+	if ( pName )
+	{
+		m_pName->SetName( pName );
+	}
+	else
+	{
+		Hide();
+		return;
+	}
+
+	Vector pos, screen;
+
+	C_BaseTFPlayer *tf2player = dynamic_cast<C_BaseTFPlayer *>( GetEntity() );
+	int iteam = 0;
+	int iclass = 0;
+	if ( tf2player )
+	{
+		iteam	= tf2player->GetTeamNumber();
+		iclass	= tf2player->PlayerClass();
+
+		// FIXME: Get max health for player
+		m_pHealth->SetHealth( (float)tf2player->GetHealth() / (float)100.0f );
+	}
+
+	m_pClass->SetImage( 0 );
+	if ( iteam != 0 && iclass != TFCLASS_UNDECIDED )
+		m_pClass->SetTeamAndClass( iteam, iclass );
+
+	// Update our position on screen
+	int sx, sy;
+	GetEntityPosition( sx, sy );
+
+	// Set the position
+	SetPos( (int)(sx + m_OffsetX + 0.5f), (int)(sy + m_OffsetY + 0.5f));
+
+	// Add it in
+	m_pHealth->SetVisible( true );
+	m_pName->SetVisible( true );
+	m_pClass->SetVisible( true );
+
+	if ( MapData().m_Players[ m_PlayerNum - 1 ].m_bSelected )
+	{
+		m_pSelected->SetVisible( true );
+	}
+	else
+	{
+		m_pSelected->SetVisible( false );
+	}
+
+	if ( MapData().m_Players[ m_PlayerNum - 1 ].m_nSquadNumber != 0 )
+	{
+		char sz[ 32 ];
+		Q_snprintf( sz, sizeof( sz ), "%i", MapData().m_Players[ m_PlayerNum - 1 ].m_nSquadNumber );
+
+		m_pSquad->SetSquad( sz );
+		m_pSquad->SetVisible( true );
+	}
+	else
+	{
+		m_pSquad->SetVisible( false );
+	}
+
+	// Hide details if it's an enemy
+	if ( ArePlayersOnSameTeam( engine->GetLocalPlayer(), m_PlayerNum ) == false )
+	{
+		m_pHealth->SetVisible( false );
+		m_pName->SetVisible( false );
+		m_pSelected->SetVisible( false );
+		m_pSquad->SetVisible( false );
+
+		// Only show class icon
+		m_pClass->SetVisible( true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlay::Paint()
+{
+	// Don't draw if I'm not visible in the tactical map
+	if ( MapData().IsEntityVisibleToTactical( GetEntity() ) == false )
+		return;
+
+	// Don't draw if if I haven't chosen a class...
+
+	SetFgColor( m_fgColor );
+	SetBgColor( m_bgColor );
+
+	BaseClass::Paint();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *panel - 
+//			fg - 
+//			bg - 
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlay::SetColorLevel( vgui::Panel *panel, Color& fg, Color& bg )
+{
+	float frac = GetAlphaFrac();
+
+	if ( frac == 1.0f )
+	{
+		panel->SetFgColor( fg );
+		panel->SetBgColor( bg );
+		return;
+	}
+
+	Color foreground;
+	Color background;
+
+	foreground = fg;
+	background = bg;
+
+	int r, g, b, a;
+	foreground.GetColor( r, g, b, a );
+	foreground.SetColor( r, g, b, (int)( ( float )a * frac ) );
+
+	panel->SetFgColor( foreground );
+
+	background.GetColor( r, g, b, a );
+	background.SetColor( r, g, b, (int)( ( float )a * frac ) );
+
+	panel->SetBgColor( background );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+float CHudPlayerOverlay::GetAlphaFrac( void )
+{
+	//
+	// return fmod( gpGlobals->curtime, 1.0f );
+
+	C_BaseTFPlayer *local = C_BaseTFPlayer::GetLocalPlayer();
+	if ( !local )
+		return 1.0;
+
+	C_BaseTFPlayer *pPlayer = m_hPlayer.Get();
+	if (!pPlayer || (pPlayer->GetTeamNumber() == local->GetTeamNumber()) )
+		return 1.0f;
+
+	return pPlayer->GetOverlayAlpha();
+}
diff --git a/game/client/tf2/playeroverlay.h b/game/client/tf2/playeroverlay.h
new file mode 100644
index 0000000..3864a6f
--- /dev/null
+++ b/game/client/tf2/playeroverlay.h
@@ -0,0 +1,68 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( PLAYEROVERLAY_H )
+#define PLAYEROVERLAY_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui/VGUI.h>
+
+#include "vgui_entitypanel.h"
+
+class CHudPlayerOverlayName;
+class CHudPlayerOverlayHealth;
+class CHudPlayerOverlayClass;
+class CHudPlayerOverlaySquad;
+class CHudPlayerOverlaySelected;
+class KeyValues;
+class C_BaseTFPlayer;
+//-----------------------------------------------------------------------------
+// Purpose: Container for overlay elements
+//-----------------------------------------------------------------------------
+
+class CHudPlayerOverlay : public CEntityPanel
+{
+public:
+	DECLARE_CLASS( CHudPlayerOverlay, CEntityPanel );
+
+					CHudPlayerOverlay( vgui::Panel *parent, const char *panelName );
+	virtual			~CHudPlayerOverlay( void );
+
+	virtual void	Clear( void );
+
+	virtual bool	Init( KeyValues* pInitData, C_BaseEntity* pEntity );
+	virtual void	OnTick( );
+
+	virtual void	Hide( void );
+
+	virtual void	Paint();
+
+	// Global fade amount
+	float			GetAlphaFrac( void );
+	void			SetColorLevel( vgui::Panel *panel, Color& fg, Color& bg );
+
+private:
+	CHudPlayerOverlayName		*m_pName;
+	CHudPlayerOverlayHealth		*m_pHealth;
+	CHudPlayerOverlayClass		*m_pClass;
+	CHudPlayerOverlaySquad		*m_pSquad;
+	CHudPlayerOverlaySelected	*m_pSelected;
+
+	int m_OffsetX, m_OffsetY;
+	int m_PlayerNum;
+
+	Color				m_fgColor;
+	Color				m_bgColor;
+
+	// These are only associated with tf players
+	CHandle<C_BaseTFPlayer>	m_hPlayer;
+};
+
+
+#endif // PLAYEROVERLAY_H
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlayclass.cpp b/game/client/tf2/playeroverlayclass.cpp
new file mode 100644
index 0000000..12684eb
--- /dev/null
+++ b/game/client/tf2/playeroverlayclass.cpp
@@ -0,0 +1,269 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "playeroverlayclass.h"
+#include "playeroverlay.h"
+#include <KeyValues.h>
+#include "commanderoverlay.h"
+#include "clientmode_tfnormal.h"
+#include "tf_shareddefs.h"
+#include "hud_commander_statuspanel.h"
+#include "vgui_bitmapimage.h"
+#include "igamesystem.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Class info. Only load it once. 
+//-----------------------------------------------------------------------------
+
+CHudPlayerOverlayClass::CMapClassColors** CHudPlayerOverlayClass::s_ppClassInfo = 0;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CCleanupPlayerOverlayClass : public CAutoGameSystem
+{
+public:
+	virtual void Shutdown()
+	{
+		if ( !CHudPlayerOverlayClass::s_ppClassInfo )
+			return;
+
+		for (int i = 0; i <= MAX_TF_TEAMS; ++i)
+		{
+			for ( int j = 0; j < TFCLASS_CLASS_COUNT; j++ )
+			{
+				delete CHudPlayerOverlayClass::s_ppClassInfo[i][j].m_pClassImage;
+			}
+			delete[] CHudPlayerOverlayClass::s_ppClassInfo[i];
+		}
+		delete[] CHudPlayerOverlayClass::s_ppClassInfo;
+	}
+};
+
+static CCleanupPlayerOverlayClass g_CleanupPlayerOverlayClass;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+CHudPlayerOverlayClass::CHudPlayerOverlayClass( CHudPlayerOverlay *baseOverlay )
+: BaseClass( NULL, "CHudPlayerOverlayClass" )
+{
+	m_pBaseOverlay = baseOverlay;
+
+	m_pImage = NULL;
+	SetPaintBackgroundEnabled( false );
+
+	// Send mouse inputs (but not cursorenter/exit for now) up to parent
+	SetReflectMouse( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+CHudPlayerOverlayClass::~CHudPlayerOverlayClass( void )
+{
+	delete m_pImage;
+}
+
+
+//-----------------------------------------------------------------------------
+// Parse class icons
+//-----------------------------------------------------------------------------
+
+bool CHudPlayerOverlayClass::ParseTeamClassInfo( KeyValues *pClassIcons, const char *classname, CMapClassColors *pClassColors )
+{
+	const char *classimage;
+	KeyValues *pClass;
+	pClass = pClassIcons->FindKey( classname );
+	if ( !pClass )
+		return false;
+
+	classimage = pClass->GetString( "material" );
+	if ( classimage && classimage[ 0 ] )
+	{
+		pClassColors->m_pClassImage = new BitmapImage( NULL, classimage );
+	}
+	else
+	{
+		return( false );
+	}
+
+	return ParseRGBA( pClass, "color", pClassColors->m_clrClass );
+}
+
+bool CHudPlayerOverlayClass::ParseTeamClassIcons( CMapClassColors *pT, KeyValues *pTeam )
+{
+	if ( !ParseTeamClassInfo( pTeam, "Recon", &pT[ TFCLASS_RECON ] ) )
+		return false;
+	if ( !ParseTeamClassInfo( pTeam, "Sniper", &pT[ TFCLASS_SNIPER ] ) )
+		return false;
+	if ( !ParseTeamClassInfo( pTeam, "Commando", &pT[ TFCLASS_COMMANDO ] ) )
+		return false;
+	if ( !ParseTeamClassInfo( pTeam, "Support", &pT[ TFCLASS_SUPPORT ] ) )
+		return false;
+	if ( !ParseTeamClassInfo( pTeam, "Medic", &pT[ TFCLASS_MEDIC ] ) )
+		return false;
+	if ( !ParseTeamClassInfo( pTeam, "Escort", &pT[ TFCLASS_ESCORT ] ) )
+		return false;
+	if ( !ParseTeamClassInfo( pTeam, "Defender", &pT[ TFCLASS_DEFENDER ] ) )
+		return false;
+	if ( !ParseTeamClassInfo( pTeam, "Sapper", &pT[ TFCLASS_SAPPER ] ) )
+		return false;
+	if ( !ParseTeamClassInfo( pTeam, "Infiltrator", &pT[ TFCLASS_INFILTRATOR ] ) )
+		return false;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Initialization
+//-----------------------------------------------------------------------------
+
+bool CHudPlayerOverlayClass::InitClassInfo( KeyValues* pKeyValues )
+{
+	if (s_ppClassInfo)
+		return true;
+
+	char teamkey[ 128 ];
+	s_ppClassInfo = new CMapClassColors*[MAX_TF_TEAMS+1];
+	for (int i = 0; i <= MAX_TF_TEAMS; ++i)
+	{
+		s_ppClassInfo[i] = new CMapClassColors[TFCLASS_CLASS_COUNT];
+		Q_snprintf( teamkey, sizeof( teamkey ), "Team%i", i );
+		KeyValues *pTeam = pKeyValues->FindKey( teamkey );
+		if (pTeam)
+		{
+			if (!ParseTeamClassIcons( s_ppClassInfo[i], pTeam ))
+				return false;
+		}
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Initialization
+//-----------------------------------------------------------------------------
+
+bool CHudPlayerOverlayClass::Init( KeyValues* pKeyValues )
+{
+	if (!pKeyValues)
+		return false;
+
+	int x, y, w, h;
+	if (!ParseRect(pKeyValues, "friendlyposition", x, y, w, h ))
+		return false;
+
+	if (!InitClassInfo( pKeyValues ))
+		return false;
+
+	SetPos( x, y );
+	SetSize( w, h );
+
+	SetImage( 0 );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pImage - Class specific image
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlayClass::SetImage( BitmapImage *pImage )
+{
+	m_pImage = pImage;
+	if (m_pImage)
+	{
+		// Make sure the image size is correct
+		int w,h;
+		GetSize(w,h);
+	}
+}
+
+void CHudPlayerOverlayClass::SetTeamAndClass( int team, int playerclass )
+{
+	if (!s_ppClassInfo)
+		return;
+
+	CMapClassColors *pCC = &s_ppClassInfo[ team ][ playerclass ];
+	if ( pCC )
+	{
+		int r, g, b, a;
+		pCC->m_clrClass.GetColor( r, g, b, a );
+		SetColor( r, g, b, a );
+		SetImage( pCC->m_pClassImage );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// If this guy changes size, so must the associated image
+//-----------------------------------------------------------------------------
+
+void CHudPlayerOverlayClass::SetSize( int w, int h ) 
+{
+	// chain...
+	Panel::SetSize( w, h );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : r - 
+//			g - 
+//			b - 
+//			a - 
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlayClass::SetColor( int r, int g, int b, int a )
+{
+	m_r = r;
+	m_g = g;
+	m_b = b;
+	m_a = a;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlayClass::Paint( void )
+{
+	int w, h;
+
+	m_pBaseOverlay->SetColorLevel( this, m_fgColor, m_bgColor );
+
+	GetSize( w, h );
+	vgui::surface()->DrawSetColor( m_r, m_g, m_b, m_a * m_pBaseOverlay->GetAlphaFrac() );
+
+	if ( !m_pImage )
+		return;
+
+	Color color;
+	color.SetColor( m_r, m_g, m_b, m_a * m_pBaseOverlay->GetAlphaFrac() );
+	m_pImage->SetColor( color );
+	m_pImage->DoPaint( GetVPanel() );
+}
+
+void CHudPlayerOverlayClass::OnCursorEntered()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusPrint( TYPE_HINT, "%s", m_pBaseOverlay->GetMouseOverText() );
+	}
+}
+
+void CHudPlayerOverlayClass::OnCursorExited()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusClear();
+	}
+}
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlayclass.h b/game/client/tf2/playeroverlayclass.h
new file mode 100644
index 0000000..ab4483d
--- /dev/null
+++ b/game/client/tf2/playeroverlayclass.h
@@ -0,0 +1,72 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#if !defined( PLAYEROVERLAYCLASS_H )
+#define PLAYEROVERLAYCLASS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vgui_basepanel.h"
+
+class BitmapImage;
+class KeyValues;
+class CHudPlayerOverlay;
+
+class CHudPlayerOverlayClass : public CBasePanel
+{
+public:
+	DECLARE_CLASS( CHudPlayerOverlayClass, CBasePanel );
+
+	CHudPlayerOverlayClass( CHudPlayerOverlay *baseOverlay );
+	virtual ~CHudPlayerOverlayClass( void );
+
+	bool Init( KeyValues* pKeyValues );
+
+	void SetColor( int r, int g, int b, int a );
+	void SetImage( BitmapImage *pImage );
+	void SetTeamAndClass( int team, int playerclass );
+
+	// Keeps the image size correct
+	virtual void SetSize( int w, int h );
+
+	virtual void Paint( void );
+
+	virtual void OnCursorEntered();
+	virtual void OnCursorExited();
+
+private:
+	class CMapClassColors
+	{
+	public:
+		CMapClassColors() : m_pClassImage(0) {}
+
+		BitmapImage	*m_pClassImage;
+		Color		m_clrClass;
+	};
+
+	// Initialize class info only once
+	static bool InitClassInfo( KeyValues* pKeyValues );
+	static bool ParseTeamClassInfo( KeyValues *pClassIcons, const char *classname, CMapClassColors *pClassColors );
+	static bool ParseTeamClassIcons( CMapClassColors *pT, KeyValues *pTeam );
+
+	static CMapClassColors** s_ppClassInfo;
+
+	int		m_r, m_g, m_b, m_a;
+	BitmapImage *m_pImage;
+
+	Color m_fgColor;
+	Color m_bgColor;
+
+	CHudPlayerOverlay *m_pBaseOverlay;
+
+	friend class CCleanupPlayerOverlayClass;
+};
+
+#endif // PLAYEROVERLAYCLASS_H
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlayhealth.cpp b/game/client/tf2/playeroverlayhealth.cpp
new file mode 100644
index 0000000..0ae023e
--- /dev/null
+++ b/game/client/tf2/playeroverlayhealth.cpp
@@ -0,0 +1,123 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "playeroverlayhealth.h"
+#include "playeroverlay.h"
+#include "CommanderOverlay.h"
+#include "hud_commander_statuspanel.h"
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlayHealth::CHudPlayerOverlayHealth( CHudPlayerOverlay *baseOverlay )
+: BaseClass( NULL, "CHudPlayerOverlayHealth" )
+{
+	m_pBaseOverlay = baseOverlay;
+
+	SetHealth( 0 );
+
+	SetPaintBackgroundEnabled( false );
+	// Send mouse inputs (but not cursorenter/exit for now) up to parent
+	SetReflectMouse( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlayHealth::~CHudPlayerOverlayHealth( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Parse values from the file
+//-----------------------------------------------------------------------------
+
+bool CHudPlayerOverlayHealth::Init( KeyValues* pInitData )
+{
+	if (!pInitData)
+		return false;
+
+	if (!ParseRGBA(pInitData, "fgcolor", m_fgColor ))
+		return false;
+
+	if (!ParseRGBA(pInitData, "bgcolor", m_bgColor ))
+		return false;
+
+	int x, y, w, h;
+	if (!ParseRect(pInitData, "position", x, y, w, h ))
+		return false;
+	SetPos( x, y );
+	SetSize( w, h );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : health - 
+//-----------------------------------------------------------------------------
+
+void CHudPlayerOverlayHealth::SetHealth( float health )
+{
+	m_Health = health;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlayHealth::Paint( void )
+{
+	int w, h;
+
+	GetSize( w, h );
+	
+	m_pBaseOverlay->SetColorLevel( this, m_fgColor, m_bgColor );
+
+	// Use a color related to health value....
+	vgui::surface()->DrawSetColor( 0, 255, 0, 255 * m_pBaseOverlay->GetAlphaFrac() );
+
+	int drawwidth;
+
+	float frac = m_Health;
+	frac = MIN( 1.0, m_Health );
+	frac = MAX( 0.0, m_Health );
+
+	drawwidth = frac * w;
+
+	vgui::surface()->DrawFilledRect( 0, 0, drawwidth, h/2 );
+
+	// This is the hurt part
+	if (w != drawwidth)
+	{
+		vgui::surface()->DrawSetColor( 255, 64, 64, 255 * m_pBaseOverlay->GetAlphaFrac() );
+		vgui::surface()->DrawFilledRect( drawwidth, 0, w, h/2 );
+	}
+}
+
+void CHudPlayerOverlayHealth::OnCursorEntered()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusPrint( TYPE_HINT, "%s", m_pBaseOverlay->GetMouseOverText() );
+	}
+}
+
+void CHudPlayerOverlayHealth::OnCursorExited()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusClear();
+	}
+}
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlayhealth.h b/game/client/tf2/playeroverlayhealth.h
new file mode 100644
index 0000000..9dc7edd
--- /dev/null
+++ b/game/client/tf2/playeroverlayhealth.h
@@ -0,0 +1,47 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( PLAYEROVERLAYHEALTH_H )
+#define PLAYEROVERLAYHEALTH_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vgui_basepanel.h"
+
+class KeyValues;
+
+class CHudPlayerOverlay;
+
+class CHudPlayerOverlayHealth : public CBasePanel
+{
+public:
+	DECLARE_CLASS( CHudPlayerOverlayHealth, CBasePanel );
+
+	CHudPlayerOverlayHealth( CHudPlayerOverlay *baseOverlay );
+	virtual ~CHudPlayerOverlayHealth( void );
+
+	bool Init( KeyValues* pInitData );
+	void SetHealth( float health );
+
+	virtual void Paint( void );
+
+	virtual void OnCursorEntered();
+	virtual void OnCursorExited();
+
+private:
+	float	m_Health;
+
+	Color m_fgColor;
+	Color m_bgColor;
+
+	CHudPlayerOverlay *m_pBaseOverlay;
+
+};
+
+#endif // PLAYEROVERLAYHEALTH_H
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlayname.cpp b/game/client/tf2/playeroverlayname.cpp
new file mode 100644
index 0000000..8d3f602
--- /dev/null
+++ b/game/client/tf2/playeroverlayname.cpp
@@ -0,0 +1,183 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include <KeyValues.h>
+#include "playeroverlay.h"
+#include "playeroverlayname.h"
+#include <KeyValues.h>
+#include "commanderoverlay.h"
+#include "hud_commander_statuspanel.h"
+#include <vgui/IVGui.h>
+#include <vgui/IScheme.h>
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlayName::CHudPlayerOverlayName( CHudPlayerOverlay *baseOverlay, const char *name ) : 
+vgui::Label( (vgui::Panel *)NULL, "OverlayName", name )
+{
+	m_pBaseOverlay = baseOverlay;
+
+	Q_strncpy( m_szName, name, sizeof( m_szName ) );
+
+	SetPaintBackgroundEnabled( false );
+
+	// Send mouse inputs (but not cursorenter/exit for now) up to parent
+	SetReflectMouse( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlayName::~CHudPlayerOverlayName( void )
+{
+}
+
+bool CHudPlayerOverlayName::Init( KeyValues* pInitData )
+{
+	if (!pInitData)
+		return false;
+
+	if (!ParseRGBA(pInitData, "fgcolor", m_fgColor ))
+		return false;
+
+	if (!ParseRGBA(pInitData, "bgcolor", m_bgColor ))
+		return false;
+
+	int x, y, w, h;
+	if (!ParseRect(pInitData, "position", x, y, w, h ))
+		return false;
+	SetPos( x, y );
+	SetSize( w, h );
+
+	SetContentAlignment( vgui::Label::a_west );
+
+	return true;
+}
+
+void CHudPlayerOverlayName::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	SetFont( pScheme->GetFont( "primary" ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlayName::SetName( const char *name )
+{
+	Q_strncpy( m_szName, name, sizeof( m_szName ) );
+	SetText( name );
+}
+
+void CHudPlayerOverlayName::Paint()
+{
+	m_pBaseOverlay->SetColorLevel( this, m_fgColor, m_bgColor );
+
+	BaseClass::Paint();
+}
+
+void CHudPlayerOverlayName::SetReflectMouse( bool reflect )
+{
+	m_bReflectMouse = true;
+}
+
+void CHudPlayerOverlayName::OnCursorMoved(int x,int y)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	LocalToScreen( x, y );
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "CursorMoved", "xpos", x, "ypos", y ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlayName::OnMousePressed(vgui::MouseCode code)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "MousePressed", "code", code ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlayName::OnMouseDoublePressed(vgui::MouseCode code)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "MouseDoublePressed", "code", code ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlayName::OnMouseReleased(vgui::MouseCode code)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "MouseReleased", "code", code ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlayName::OnMouseWheeled(int delta)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "MouseWheeled", "delta", delta ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlayName::OnCursorEntered()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusPrint( TYPE_HINT, "%s", m_pBaseOverlay->GetMouseOverText() );
+	}
+}
+
+void CHudPlayerOverlayName::OnCursorExited()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusClear();
+	}
+}
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlayname.h b/game/client/tf2/playeroverlayname.h
new file mode 100644
index 0000000..4fe7a4f
--- /dev/null
+++ b/game/client/tf2/playeroverlayname.h
@@ -0,0 +1,59 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( PLAYEROVERLAYNAME_H )
+#define PLAYEROVERLAYNAME_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Label.h>
+
+class KeyValues;
+class CHudPlayerOverlay;
+class CHudPlayerOverlayName : public vgui::Label
+{
+public:
+	typedef vgui::Label BaseClass;
+
+	CHudPlayerOverlayName( CHudPlayerOverlay *baseOverlay, const char *name );
+	virtual ~CHudPlayerOverlayName( void );
+
+	bool Init( KeyValues* pInitData );
+
+	void SetName( const char *name );
+	
+	virtual void	ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void	Paint();
+
+	virtual void	SetReflectMouse( bool reflect );
+	// If reflect mouse is true, then pass these up to parent
+	virtual void	OnCursorMoved(int x,int y);
+	virtual void	OnMousePressed(vgui::MouseCode code);
+	virtual void	OnMouseDoublePressed(vgui::MouseCode code);
+	virtual void	OnMouseReleased(vgui::MouseCode code);
+	virtual void	OnMouseWheeled(int delta);
+
+	virtual void OnCursorEntered();
+	virtual void OnCursorExited();
+private:
+
+	char			m_szName[ 64 ];
+	Color			m_fgColor;
+	Color			m_bgColor;
+
+	CHudPlayerOverlay *m_pBaseOverlay;
+
+	bool			m_bReflectMouse;
+};
+
+#endif // PLAYEROVERLAYNAME_H
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlayselected.cpp b/game/client/tf2/playeroverlayselected.cpp
new file mode 100644
index 0000000..f52912a
--- /dev/null
+++ b/game/client/tf2/playeroverlayselected.cpp
@@ -0,0 +1,130 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "playeroverlay.h"
+#include "playeroverlayselected.h"
+#include <KeyValues.h>
+#include "commanderoverlay.h"
+#include "hud_commander_statuspanel.h"
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlaySelected::CHudPlayerOverlaySelected( CHudPlayerOverlay *baseOverlay )
+ : BaseClass( NULL, "CHudPlayerOverlaySelected" )
+{
+	m_pBaseOverlay = baseOverlay;
+
+	int i;
+	for ( i = 0; i < 4; i++ )
+	{
+		m_pImages[ i ] = NULL;
+	}
+
+	SetPaintBackgroundEnabled( false );
+
+	// Send mouse inputs (but not cursorenter/exit for now) up to parent
+	SetReflectMouse( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlaySelected::~CHudPlayerOverlaySelected( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+
+bool CHudPlayerOverlaySelected::Init( KeyValues* pInitData )
+{
+	if (!pInitData)
+		return false;
+
+	if (!ParseRGBA(pInitData, "fgcolor", m_fgColor ))
+		return false;
+
+	if (!ParseRGBA(pInitData, "bgcolor", m_bgColor ))
+		return false;
+
+	int x, y, w, h;
+	if (!ParseRect(pInitData, "position", x, y, w, h ))
+		return false;
+	SetPos( x, y );
+	SetSize( w, h );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: NOTE:  This is not hooked up yet.
+// Input  : pImage -- the four corner images
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlaySelected::SetImages( BitmapImage *pImage[4] )
+{
+	int i;
+	for ( i = 0 ; i < 4; i++ )
+	{
+		m_pImages[ i ] = pImage[ i ];
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: FIXME:  Use materials for corners, not just procedural drawing?
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlaySelected::Paint( void )
+{
+	int w, h;
+
+	m_pBaseOverlay->SetColorLevel( this, m_fgColor, m_bgColor );
+
+	GetSize( w, h );
+	int r, g, b, a;
+	Color clr = GetFgColor();
+	clr.GetColor( r, g, b, a );
+	vgui::surface()->DrawSetColor( r, g, b, a );
+
+	// Draw corners
+	int inSetSize = 6;
+	int thickness = 2;
+
+	vgui::surface()->DrawFilledRect( 0, 0, inSetSize, thickness );
+	vgui::surface()->DrawFilledRect( 0, 0, thickness, inSetSize );
+
+	vgui::surface()->DrawFilledRect( w-inSetSize, 0, w, thickness );
+	vgui::surface()->DrawFilledRect( w-thickness, 0, w, inSetSize );
+
+	vgui::surface()->DrawFilledRect( w-inSetSize, h-thickness, w, h );
+	vgui::surface()->DrawFilledRect( w-thickness, h-inSetSize, w, h );
+
+	vgui::surface()->DrawFilledRect( 0, h-thickness, inSetSize, h );
+	vgui::surface()->DrawFilledRect( 0, h-inSetSize, thickness, h  );
+}
+
+void CHudPlayerOverlaySelected::OnCursorEntered()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusPrint( TYPE_HINT, "%s", m_pBaseOverlay->GetMouseOverText() );
+	}
+}
+
+void CHudPlayerOverlaySelected::OnCursorExited()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusClear();
+	}
+}
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlayselected.h b/game/client/tf2/playeroverlayselected.h
new file mode 100644
index 0000000..723b2ee
--- /dev/null
+++ b/game/client/tf2/playeroverlayselected.h
@@ -0,0 +1,46 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( PLAYEROLVERLAYSELECTED_H )
+#define PLAYEROLVERLAYSELECTED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vgui_basepanel.h"
+
+class BitmapImage;
+class KeyValues;
+class CHudPlayerOverlay;
+class CHudPlayerOverlaySelected : public CBasePanel
+{
+public:
+	DECLARE_CLASS( CHudPlayerOverlaySelected, CBasePanel );
+
+	CHudPlayerOverlaySelected( CHudPlayerOverlay *baseOverlay );
+	virtual ~CHudPlayerOverlaySelected( void );
+
+	bool Init( KeyValues* pInitData );
+
+	void SetImages( BitmapImage *pImage[4] );
+
+	virtual void Paint( void );
+
+	virtual void OnCursorEntered();
+	virtual void OnCursorExited();
+
+
+private:
+	BitmapImage *m_pImages[4];
+
+	Color m_fgColor;
+	Color m_bgColor;
+	CHudPlayerOverlay *m_pBaseOverlay;
+};
+
+#endif // PLAYEROLVERLAYSELECTED_H
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlaysquad.cpp b/game/client/tf2/playeroverlaysquad.cpp
new file mode 100644
index 0000000..f646706
--- /dev/null
+++ b/game/client/tf2/playeroverlaysquad.cpp
@@ -0,0 +1,187 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include <KeyValues.h>
+#include "playeroverlay.h"
+#include "playeroverlaysquad.h"
+#include <KeyValues.h>
+#include "panelmetaclassmgr.h"
+#include "hud_commander_statuspanel.h"
+#include <vgui/IScheme.h>
+#include <vgui/IVGui.h>
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlaySquad::CHudPlayerOverlaySquad( CHudPlayerOverlay *baseOverlay, const char *squadname ) : 
+vgui::Label( (vgui::Panel *)NULL, "OverlaySquad", squadname )
+{
+	m_pBaseOverlay = baseOverlay;
+
+	Q_strncpy( m_szSquad, squadname, sizeof( m_szSquad ) );
+
+	SetPaintBackgroundEnabled( false );
+
+	// Send mouse inputs (but not cursorenter/exit for now) up to parent
+	SetReflectMouse( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudPlayerOverlaySquad::~CHudPlayerOverlaySquad( void )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialization 
+//-----------------------------------------------------------------------------
+bool CHudPlayerOverlaySquad::Init( KeyValues* pInitData )
+{
+	if (!pInitData)
+		return false;
+
+	SetContentAlignment( vgui::Label::a_west );
+
+	if (!ParseRGBA(pInitData, "fgcolor", m_fgColor ))
+		return false;
+
+	if (!ParseRGBA(pInitData, "bgcolor", m_bgColor))
+		return false;
+
+	int x, y, w, h;
+	if (!ParseRect(pInitData, "position", x, y, w, h ))
+		return false;
+	SetPos( x, y );
+	SetSize( w, h );
+
+	return true;
+}
+
+void CHudPlayerOverlaySquad::ApplySchemeSettings( vgui::IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	SetFont( pScheme->GetFont( "primary" ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *name - 
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlaySquad::SetSquad( const char *squadname )
+{
+	Q_strncpy( m_szSquad, squadname, sizeof( m_szSquad ) );
+	SetText( squadname );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHudPlayerOverlaySquad::Paint()
+{
+	m_pBaseOverlay->SetColorLevel( this, m_fgColor, m_bgColor );
+
+	BaseClass::Paint();
+}
+
+void CHudPlayerOverlaySquad::SetReflectMouse( bool reflect )
+{
+	m_bReflectMouse = true;
+}
+
+void CHudPlayerOverlaySquad::OnCursorMoved(int x,int y)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	LocalToScreen( x, y );
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "CursorMoved", "xpos", x, "ypos", y ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlaySquad::OnMousePressed(vgui::MouseCode code)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "MousePressed", "code", code ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlaySquad::OnMouseDoublePressed(vgui::MouseCode code)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "MouseDoublePressed", "code", code ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlaySquad::OnMouseReleased(vgui::MouseCode code)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "MouseReleased", "code", code ), 
+		GetVPanel()  );
+}
+
+void CHudPlayerOverlaySquad::OnMouseWheeled(int delta)
+{
+	if ( !m_bReflectMouse )
+		return;
+
+	if ( !GetParent() )
+		return;
+
+	vgui::ivgui()->PostMessage( 
+		GetParent()->GetVPanel(), 
+		new KeyValues( "MouseWheeled", "delta", delta ), 
+		GetVPanel()  );
+}
+
+
+void CHudPlayerOverlaySquad::OnCursorEntered()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusPrint( TYPE_HINT, "%s", m_pBaseOverlay->GetMouseOverText() );
+	}
+}
+
+void CHudPlayerOverlaySquad::OnCursorExited()
+{
+	if ( m_pBaseOverlay->GetMouseOverText() )
+	{
+		StatusClear();
+	}
+}
\ No newline at end of file
diff --git a/game/client/tf2/playeroverlaysquad.h b/game/client/tf2/playeroverlaysquad.h
new file mode 100644
index 0000000..b097c59
--- /dev/null
+++ b/game/client/tf2/playeroverlaysquad.h
@@ -0,0 +1,54 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( PLAYEROVERLAYSQUAD_H )
+#define PLAYEROVERLAYSQUAD_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include <vgui_controls/Label.h>
+
+class KeyValues;
+class CHudPlayerOverlay;
+class CHudPlayerOverlaySquad : public vgui::Label
+{
+public:
+	typedef vgui::Label BaseClass;
+
+	CHudPlayerOverlaySquad( CHudPlayerOverlay *baseOverlay, const char *squadname );
+	virtual ~CHudPlayerOverlaySquad( void );
+
+	bool Init( KeyValues* pInitData );
+
+	void SetSquad( const char *squadname );
+	
+	virtual void	Paint();
+	virtual void	ApplySchemeSettings( vgui::IScheme *pScheme );
+	virtual void	SetReflectMouse( bool reflect );
+	// If reflect mouse is true, then pass these up to parent
+	virtual void	OnCursorMoved(int x,int y);
+	virtual void	OnMousePressed(vgui::MouseCode code);
+	virtual void	OnMouseDoublePressed(vgui::MouseCode code);
+	virtual void	OnMouseReleased(vgui::MouseCode code);
+	virtual void	OnMouseWheeled(int delta);
+
+	virtual void OnCursorEntered();
+	virtual void OnCursorExited();
+
+private:
+
+	char	m_szSquad[ 64 ];
+	Color	m_fgColor;
+	Color	m_bgColor;
+	CHudPlayerOverlay *m_pBaseOverlay;
+
+	bool			m_bReflectMouse;
+};
+
+#endif // PLAYEROVERLAYSQUAD_H
\ No newline at end of file
diff --git a/game/client/tf2/proxy_objpower.cpp b/game/client/tf2/proxy_objpower.cpp
new file mode 100644
index 0000000..e9f36a9
--- /dev/null
+++ b/game/client/tf2/proxy_objpower.cpp
@@ -0,0 +1,56 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Proxy to hook into an object's powered state
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialsystem.h"
+#include <KeyValues.h>
+#include "materialsystem/imaterialvar.h"
+#include "C_BaseTFPlayer.h"
+#include "functionproxy.h"
+#include "c_baseobject.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+class CTFObjectPowerProxy : public CResultProxy
+{
+public:
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pEnt );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CTFObjectPowerProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFObjectPowerProxy::OnBind( void *pArg )
+{
+	C_BaseEntity *pEntity = BindArgToEntity( pArg );
+	if (!pEntity)
+		return;
+
+	C_BaseObject *pObject = dynamic_cast<C_BaseObject*>( pEntity );
+	Assert( pObject );
+
+	float flPoweredState = (float)(!pObject->IsBuilding() && !pObject->IsPlacing() && pObject->IsPowered());
+
+	Assert( m_pResult );
+	SetFloatResult( flPoweredState );
+}
+
+
+EXPOSE_INTERFACE( CTFObjectPowerProxy, IMaterialProxy, "TFObjectPower" IMATERIAL_PROXY_INTERFACE_VERSION );
diff --git a/game/client/tf2/proxy_shield.cpp b/game/client/tf2/proxy_shield.cpp
new file mode 100644
index 0000000..214a579
--- /dev/null
+++ b/game/client/tf2/proxy_shield.cpp
@@ -0,0 +1,313 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialsystem.h"
+#include <KeyValues.h>
+#include "materialsystem/imaterialvar.h"
+#include "C_BaseTFPlayer.h"
+#include "functionproxy.h"
+#include "C_PlayerResource.h"
+#include "Weapon_CombatShield.h"
+
+// for the 2/5/03 demo
+#include "c_demo_entities.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Shield proxy base class
+//-----------------------------------------------------------------------------
+class CTFShieldProxy : public CResultProxy
+{
+protected:
+	C_WeaponCombatShield *BindArgToShield( void *pArg );
+};
+
+
+//-----------------------------------------------------------------------------
+// Gets the shield
+//-----------------------------------------------------------------------------
+C_WeaponCombatShield *CTFShieldProxy::BindArgToShield( void *pArg )
+{
+	C_BaseEntity *pEntity = BindArgToEntity( pArg );
+	if (!pEntity)
+		return NULL;
+
+	if (dynamic_cast<C_BaseViewModel*>(pEntity))
+	{
+		// If this is the view model, snack the state from the local player...
+		C_BaseTFPlayer* pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+		return pPlayer->GetShield();
+	}
+	
+	if ( dynamic_cast<C_BaseTFPlayer*>(pEntity) )
+	{
+		C_BaseTFPlayer* pPlayer = dynamic_cast<C_BaseTFPlayer*>( pEntity );
+		return pPlayer->GetShield();
+	}
+
+	return dynamic_cast<C_WeaponCombatShield*>( pEntity );
+}
+
+
+//=============================================================================
+//
+// TF Shield raising proxy. 
+//
+class CTFShieldRaiseProxy : public CTFShieldProxy
+{
+public:
+
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pEnt );
+
+private:
+	CFloatInput	m_Factor;
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CTFShieldRaiseProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	// Init shield raise times.
+	if ( !m_Factor.Init( pMaterial, pKeyValues, "scale", 1 ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CTFShieldRaiseProxy::OnBind( void *pArg )
+{
+	float flTimeSinceRaised = 0.0f;
+	C_WeaponCombatShield *pShield = BindArgToShield( pArg );
+	if (pShield)
+	{
+		flTimeSinceRaised = pShield->GetRaisingTime();
+	}
+	
+	// Return the time in seconds from when we started raising.
+	SetFloatResult( flTimeSinceRaised * m_Factor.GetFloat() );
+}
+
+EXPOSE_INTERFACE( CTFShieldRaiseProxy, IMaterialProxy, "TFShieldRaise" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//=============================================================================
+//
+// TF Shield lowering proxy. 
+//
+class CTFShieldLowerProxy : public CTFShieldProxy
+{
+public:
+
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pEnt );
+
+private:
+	CFloatInput	m_Factor;
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CTFShieldLowerProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	// Init shield raise times.
+	if ( !m_Factor.Init( pMaterial, pKeyValues, "scale", 1 ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CTFShieldLowerProxy::OnBind( void *pArg )
+{
+	float flTimeSinceLowered = 0.0f;
+	C_WeaponCombatShield *pShield = BindArgToShield( pArg );
+	if ( pShield )
+	{
+		flTimeSinceLowered = pShield->GetLoweringTime();
+	}
+	else
+	{
+		// NOTE: This is for the Feb 5 03 demo only
+		C_BaseEntity *pEntity = BindArgToEntity( pArg );
+		C_Cycler_TF2Commando *pDemoCommando = dynamic_cast<C_Cycler_TF2Commando*>( pEntity );
+		if (pDemoCommando)
+		{
+			flTimeSinceLowered = pDemoCommando->GetShieldLowerTime();
+		}
+	}
+
+	// Return the time in seconds from when we started lowering.
+	Assert( m_pResult );
+	SetFloatResult( flTimeSinceLowered * m_Factor.GetFloat() );
+
+//	Msg( "Lowering = %f\n", flTimeSinceLowered );
+}
+
+EXPOSE_INTERFACE( CTFShieldLowerProxy, IMaterialProxy, "TFShieldLower" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//=============================================================================
+//
+// TF Shield raising proxy. 
+//
+class CTFShieldVisibilityProxy : public CTFShieldProxy
+{
+public:
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pEnt );
+
+private:
+	CFloatInput	m_RaiseFactor;
+	CFloatInput	m_LowerFactor;
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CTFShieldVisibilityProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	// Init shield raise times.
+	if ( !m_RaiseFactor.Init( pMaterial, pKeyValues, "raisescale", 1 ) )
+		return false;
+
+	if ( !m_LowerFactor.Init( pMaterial, pKeyValues, "lowerscale", 1 ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CTFShieldVisibilityProxy::OnBind( void *pArg )
+{
+	float flAlpha = 0.0f;
+	C_WeaponCombatShield *pShield = BindArgToShield( pArg );
+	if ( pShield )
+	{
+		if (pShield->GetRaisingTime() != 0.0f)
+		{
+			flAlpha = pShield->GetRaisingTime() * m_RaiseFactor.GetFloat();
+			flAlpha = clamp( flAlpha, 0, 1 );
+		}
+		else
+		{
+			flAlpha = 1.0f - pShield->GetLoweringTime() * m_LowerFactor.GetFloat();
+			flAlpha = clamp( flAlpha, 0, 1 );
+		}
+	}
+
+	// Return the time in seconds from when we started lowering.
+	Assert( m_pResult );
+	SetFloatResult( flAlpha );
+}
+
+EXPOSE_INTERFACE( CTFShieldVisibilityProxy, IMaterialProxy, "TFShieldVisibility" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//=============================================================================
+//
+// TF Shield active proxy. 
+//
+class CTFShieldActiveProxy : public CTFShieldProxy
+{
+public:
+
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pEnt );
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CTFShieldActiveProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CTFShieldActiveProxy::OnBind( void *pArg )
+{
+	bool bIsShieldUp = false;
+	C_WeaponCombatShield *pShield = BindArgToShield( pArg );
+	if ( pShield )
+	{
+		bIsShieldUp = ( pShield->IsUp() == 1.0f );
+	}
+	else
+	{
+		// NOTE: This is for the Feb 5 03 demo only
+		C_BaseEntity *pEntity = BindArgToEntity( pArg );
+		C_Cycler_TF2Commando *pDemoCommando = dynamic_cast<C_Cycler_TF2Commando*>( pEntity );
+		if (pDemoCommando)
+		{
+			bIsShieldUp = pDemoCommando->IsShieldActive();
+		}
+	}
+
+	Assert( m_pResult );
+	SetFloatResult( ( float )bIsShieldUp );
+
+//	Msg( "Active = %d\n", bIsShieldUp );
+}
+
+EXPOSE_INTERFACE( CTFShieldActiveProxy, IMaterialProxy, "TFShieldActive" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//=============================================================================
+//
+// TF Shield health proxy. 
+//
+class CTFShieldHealthProxy : public CTFShieldProxy
+{
+public:
+
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pEnt );
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+bool CTFShieldHealthProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CTFShieldHealthProxy::OnBind( void *pArg )
+{
+	float flShieldHealth = 1;
+	C_WeaponCombatShield *pShield = BindArgToShield( pArg );
+	if ( pShield )
+	{
+		flShieldHealth = pShield->GetShieldHealth();
+	}
+
+	Assert( m_pResult );
+	SetFloatResult( flShieldHealth );
+}
+
+EXPOSE_INTERFACE( CTFShieldHealthProxy, IMaterialProxy, "TFShieldHealth" IMATERIAL_PROXY_INTERFACE_VERSION );
diff --git a/game/client/tf2/proxy_sunroof.cpp b/game/client/tf2/proxy_sunroof.cpp
new file mode 100644
index 0000000..894bfbc
--- /dev/null
+++ b/game/client/tf2/proxy_sunroof.cpp
@@ -0,0 +1,72 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialsystem.h"
+#include <KeyValues.h>
+#include "materialsystem/imaterialvar.h"
+#include "C_BaseTFPlayer.h"
+#include "functionproxy.h"
+#include "C_PlayerResource.h"
+#include "Weapon_CombatShield.h"
+
+// for the 2/5/03 demo
+#include "c_demo_entities.h"
+#include "c_basefourwheelvehicle.h"
+
+//=============================================================================
+//
+// TF Shield raising proxy. 
+//
+class CTFSunroofProxy : public CResultProxy
+{
+public:
+
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pEnt );
+
+private:
+
+	CFloatInput	m_Factor;
+};
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+bool CTFSunroofProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	// Init shield raise times.
+	//if ( !m_Factor.Init( pMaterial, pKeyValues, "scale", 1 ) )
+	//	return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CTFSunroofProxy::OnBind( void *pArg )
+{
+	C_BaseEntity *pEntity = BindArgToEntity( pArg );
+	C_BaseTFFourWheelVehicle* pVehicle = dynamic_cast<C_BaseTFFourWheelVehicle*>(pEntity);
+	if( !pVehicle )
+		return;
+
+	if( pVehicle->GetPassengerCount() )
+	{
+		SetFloatResult(0.f);
+	} 
+	else
+	{
+		SetFloatResult(1.f);
+	}
+}
+
+EXPOSE_INTERFACE( CTFSunroofProxy, IMaterialProxy, "TFSunroof" IMATERIAL_PROXY_INTERFACE_VERSION );
diff --git a/game/client/tf2/resourcezoneoverlay.cpp b/game/client/tf2/resourcezoneoverlay.cpp
new file mode 100644
index 0000000..97a7d51
--- /dev/null
+++ b/game/client/tf2/resourcezoneoverlay.cpp
@@ -0,0 +1,249 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Revision:     $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include <VGUI_EntityPanel.h>
+#include <KeyValues.h>
+#include "commanderoverlay.h"
+#include "clientmode_tfnormal.h"
+#include "tf_shareddefs.h"
+#include "shareddefs.h"
+#include "c_func_resource.h"
+#include "techtree.h"
+#include "c_basetfplayer.h"
+#include "vgui_HealthBar.h"
+#include "vgui_bitmapimage.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+class CResourceZoneOverlay : public CEntityPanel
+{
+	DECLARE_CLASS( CResourceZoneOverlay, CEntityPanel );
+
+public:
+	CResourceZoneOverlay( vgui::Panel *parent, const char *panelName );
+	virtual ~CResourceZoneOverlay( void );
+
+	bool Init( KeyValues* pKeyValues, C_BaseEntity* pEntity );
+	bool InitResourceBitmaps( KeyValues* pKeyValues );
+
+	void SetColor( int r, int g, int b, int a );
+	void SetImage( BitmapImage *pImage );
+
+	virtual void OnTick();
+
+	virtual void Paint( void );
+	virtual void PaintBackground( void ) {}
+
+private:
+	class CResourceBitmaps
+	{
+	public:
+		CResourceBitmaps() : m_pImage(0) {}
+
+		BitmapImage		*m_pImage;
+		Color		m_Color;
+	};
+
+	struct Rect_t
+	{
+		int x, y, w, h;
+	};
+
+	bool ParseSingleResourceBitmap( KeyValues *pKeyValues, 
+			const char *pResourceName, CResourceBitmaps *pResourceBitmap );
+	bool ParseTeamResourceBitmaps( CResourceBitmaps *pT, KeyValues *pTeam );
+
+	int					m_r, m_g, m_b, m_a;
+	CHealthBarPanel		m_UsageBar;
+	Rect_t				m_Icon;
+	C_ResourceZone		*m_pResourceZone;
+	CResourceBitmaps	m_pResourceBitmap;
+	BitmapImage			*m_pImage;
+
+};
+
+
+//-----------------------------------------------------------------------------
+// Class factory
+//-----------------------------------------------------------------------------
+
+DECLARE_OVERLAY_FACTORY( CResourceZoneOverlay, "resourcezone" );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+CResourceZoneOverlay::CResourceZoneOverlay( vgui::Panel *parent, const char *panelName )
+: BaseClass( parent, "CResourceZoneOverlay" )
+{
+	m_pImage = 0;
+	SetPaintBackgroundEnabled( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+CResourceZoneOverlay::~CResourceZoneOverlay( void )
+{
+	if ( m_pResourceBitmap.m_pImage )
+	{
+		delete m_pResourceBitmap.m_pImage;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Parse class icons
+//-----------------------------------------------------------------------------
+
+bool CResourceZoneOverlay::ParseSingleResourceBitmap( KeyValues *pKeyValues, 
+				const char *pResourceName, CResourceBitmaps *pResourceBitmap )
+{
+	const char *image;
+	KeyValues *pResource;
+	pResource = pKeyValues->FindKey( pResourceName );
+	if ( !pResource )
+		return false;
+
+	image = pResource->GetString( "material" );
+	if ( image && image[ 0 ] )
+	{
+		pResourceBitmap->m_pImage = new BitmapImage( GetVPanel(), image );
+	}
+	else
+	{
+		return( false );
+	}
+
+	return ParseRGBA( pResource, "color", pResourceBitmap->m_Color );
+}
+
+bool CResourceZoneOverlay::ParseTeamResourceBitmaps( CResourceBitmaps *pT, KeyValues *pTeam )
+{
+	if ( !ParseSingleResourceBitmap( pTeam, "Alpha", pT ) )
+		return false;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Initialization
+//-----------------------------------------------------------------------------
+
+bool CResourceZoneOverlay::InitResourceBitmaps( KeyValues* pKeyValues )
+{
+//	char teamkey[ 128 ];
+//	for (int i = 0; i < 3; ++i)
+//	{
+//		Q_snprintf( teamkey, sizeof( teamkey ), "Team%i", i );
+//		KeyValues *pTeam = pKeyValues->getSection( teamkey );
+//		if (pTeam)
+		{
+			if (!ParseTeamResourceBitmaps( &m_pResourceBitmap, pKeyValues ))
+				return false;
+		}
+//	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Initialization
+//-----------------------------------------------------------------------------
+
+bool CResourceZoneOverlay::Init( KeyValues* pKeyValues, C_BaseEntity* pEntity )
+{
+	if (!BaseClass::Init( pKeyValues, pEntity))
+		return false;
+
+	if (!pKeyValues)
+		return false;
+
+	// We gotta be attached to a resource zone
+	m_pResourceZone = dynamic_cast<C_ResourceZone*>(GetEntity());
+	if (!m_pResourceZone)
+		return false;
+
+	KeyValues* pUsage = pKeyValues->FindKey("Usage");
+	if (!m_UsageBar.Init( pUsage ))
+		return false;
+	m_UsageBar.SetParent( this );
+
+	// get the icon info...
+	if (!ParseRect( pKeyValues, "iconposition", m_Icon.x, m_Icon.y, m_Icon.w, m_Icon.h ))
+		return false;
+
+	if (!InitResourceBitmaps( pKeyValues ))
+		return false;
+
+	SetImage( 0 );
+	SetColor( m_pResourceBitmap.m_Color[0], m_pResourceBitmap.m_Color[1], m_pResourceBitmap.m_Color[2], m_pResourceBitmap.m_Color[3] );
+
+	// we need updating
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// called when we're ticked...
+//-----------------------------------------------------------------------------
+
+void CResourceZoneOverlay::OnTick()
+{
+	// Update position
+	CEntityPanel::OnTick();
+
+	SetImage( m_pResourceBitmap.m_pImage );
+	int r, g, b, a;
+	m_pResourceBitmap.m_Color.GetColor( r, g, b, a );
+	SetColor( r, g, b, a );
+
+	m_UsageBar.SetHealth( m_pResourceZone->m_flClientResources );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pImage - Class specific image
+//-----------------------------------------------------------------------------
+
+void CResourceZoneOverlay::SetImage( BitmapImage *pImage )
+{
+	m_pImage = pImage;
+}
+
+//-----------------------------------------------------------------------------
+// Sets the draw color 
+//-----------------------------------------------------------------------------
+
+void CResourceZoneOverlay::SetColor( int r, int g, int b, int a )
+{
+	m_r = r;
+	m_g = g;
+	m_b = b;
+	m_a = a;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+void CResourceZoneOverlay::Paint( void )
+{
+	if ( !m_pImage )
+		return;
+
+	ComputeAndSetSize();
+
+	Color color;
+	color.SetColor( m_r, m_g, m_b, m_a );
+	m_pImage->SetPos( m_Icon.x, m_Icon.y );
+	m_pImage->SetColor( color );
+	m_pImage->DoPaint( GetVPanel() );
+}
\ No newline at end of file
diff --git a/game/client/tf2/teammaterialproxy.cpp b/game/client/tf2/teammaterialproxy.cpp
new file mode 100644
index 0000000..9fcc923
--- /dev/null
+++ b/game/client/tf2/teammaterialproxy.cpp
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "proxyentity.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialvar.h"
+#include "c_team.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// $sineVar : name of variable that controls the alpha level (float)
+class CTeamMaterialProxy : public CEntityMaterialProxy
+{
+public:
+	CTeamMaterialProxy();
+	virtual ~CTeamMaterialProxy();
+	virtual bool Init( IMaterial *pMaterial, KeyValues* pKeyValues );
+	virtual void OnBind( C_BaseEntity *pEnt );
+
+private:
+	IMaterialVar* m_FrameVar;
+};
+
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor
+//-----------------------------------------------------------------------------
+
+CTeamMaterialProxy::CTeamMaterialProxy()
+{
+	m_FrameVar = 0;
+}
+
+CTeamMaterialProxy::~CTeamMaterialProxy()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Init baby...
+//-----------------------------------------------------------------------------
+bool CTeamMaterialProxy::Init( IMaterial *pMaterial, KeyValues* pKeyValues )
+{
+	bool foundVar;
+	m_FrameVar = pMaterial->FindVar( "$frame", &foundVar, false );
+	if( !foundVar )
+		m_FrameVar = 0;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Set the appropriate texture...
+//-----------------------------------------------------------------------------
+void CTeamMaterialProxy::OnBind( C_BaseEntity *pEnt )
+{
+	if( !m_FrameVar )
+		return;
+
+	int team = pEnt->GetRenderTeamNumber();
+	team--;
+
+	// Use that as an animated frame number
+	m_FrameVar->SetIntValue( team );
+}
+
+EXPOSE_INTERFACE( CTeamMaterialProxy, IMaterialProxy, "TeamTexture" IMATERIAL_PROXY_INTERFACE_VERSION );
diff --git a/game/client/tf2/tf_clientmode.cpp b/game/client/tf2/tf_clientmode.cpp
new file mode 100644
index 0000000..5f125b2
--- /dev/null
+++ b/game/client/tf2/tf_clientmode.cpp
@@ -0,0 +1,188 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include "cbase.h"
+#include "hud.h"
+#include "hud_macros.h"
+#include "clientmode_tfnormal.h"
+#include "clientmode.h"
+#include "clientmode_commander.h"
+#include "ivmodemanager.h"
+#include "hud_timer.h"
+#include "hud_technologytreedoc.h"
+#include "CommanderOverlay.h"
+#include "c_tf2rootpanel.h"
+#include "c_info_act.h"
+
+// default FOV for TF2
+ConVar default_fov( "default_fov", "90", FCVAR_CHEAT );
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles switching to/from commander mode
+//-----------------------------------------------------------------------------
+class CTFModeManager : public IVModeManager
+{
+public:
+	virtual void	Init( void );
+	virtual void	SwitchMode( bool commander, bool force );
+	virtual void	LevelInit( const char *newmap );
+	virtual void	LevelShutdown( void );
+
+					CTFModeManager( void );
+	virtual			~CTFModeManager( void );
+
+	void			UserCmd_Commander( void );
+	void			UserCmd_Normal( void );
+
+};
+
+static CTFModeManager g_ModeManager;
+IVModeManager *modemanager = ( IVModeManager * )&g_ModeManager;
+
+// The current client mode. Always ClientModeNormal in HL.
+IClientMode *g_pClientMode = NULL;
+
+DECLARE_COMMAND( g_ModeManager, Commander );
+DECLARE_COMMAND( g_ModeManager, Normal );
+
+HOOK_COMMAND( commander, Commander );
+HOOK_COMMAND( normal, Normal );
+
+void __MsgFunc_ActBegin(bf_read &msg);
+void __MsgFunc_ActEnd(bf_read &msg);
+
+#define MINIMAP_FILE	"scripts/minimap_overlays.txt"
+#define SCREEN_FILE		"scripts/vgui_screens.txt"
+
+//-----------------------------------------------------------------------------
+// Purpose: Intialize the mode manager
+//-----------------------------------------------------------------------------
+void CTFModeManager::Init( void )
+{
+	g_pClientMode = ClientModeCommander();
+	g_pClientMode = GetClientModeNormal();
+
+	// These define the panels that can be used by the engine
+	PanelMetaClassMgr()->LoadMetaClassDefinitionFile( MINIMAP_FILE );
+	PanelMetaClassMgr()->LoadMetaClassDefinitionFile( SCREEN_FILE );
+
+	// FIXME: Turn these into client systems
+	HudCommanderOverlayMgr()->GameInit();
+	MapData().Init();
+	GetTechnologyTreeDoc().Init();
+
+	HOOK_MESSAGE( ActBegin );
+	HOOK_MESSAGE( ActEnd );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : 
+//-----------------------------------------------------------------------------
+CTFModeManager::CTFModeManager( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : 
+//-----------------------------------------------------------------------------
+CTFModeManager::~CTFModeManager( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFModeManager::UserCmd_Commander( void )
+{
+	engine->ServerCmd( "tactical 1\n" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFModeManager::UserCmd_Normal( void )
+{
+	engine->ServerCmd( "tactical 0\n" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Switch to / from commander mode ( won't change if current mode is already
+//  correct
+// Input  : commander - 
+//-----------------------------------------------------------------------------
+void CTFModeManager::SwitchMode( bool commander, bool force )
+{
+	if ( commander && ( ( g_pClientMode != ClientModeCommander() ) || force ) )
+	{
+		g_pClientMode->Disable();
+		g_pClientMode = ClientModeCommander();
+		g_pClientMode->Enable();
+	}
+	else if ( !commander && ( ( g_pClientMode != GetClientModeNormal() ) || force ) )
+	{
+		g_pClientMode->Disable();
+		g_pClientMode = GetClientModeNormal();
+		g_pClientMode->Enable();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *newmap - 
+//-----------------------------------------------------------------------------
+void CTFModeManager::LevelInit( const char *newmap )
+{
+	GetTechnologyTreeDoc().LevelInit();
+	g_pTF2RootPanel->LevelInit();
+
+	CHudTimer *timer = GET_HUDELEMENT( CHudTimer );
+	if ( timer )
+	{
+		timer->Init();
+	}
+
+	// Tell all modes about the map change
+	ClientModeCommander()->LevelInit( newmap );
+	GetClientModeNormal()->LevelInit( newmap );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFModeManager::LevelShutdown( void )
+{
+	GetClientModeNormal()->LevelShutdown();
+	ClientModeCommander()->LevelShutdown();
+
+	g_pTF2RootPanel->LevelShutdown();
+	GetTechnologyTreeDoc().LevelShutdown();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: A new act has just begun
+//-----------------------------------------------------------------------------
+void __MsgFunc_ActBegin(bf_read &msg)
+{
+	int iActNumber = (char)msg.ReadByte();
+	float flStartTime = msg.ReadFloat();
+
+	StartAct( iActNumber, flStartTime );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: An act has just ended
+//-----------------------------------------------------------------------------
+void __MsgFunc_ActEnd(bf_read &msg)
+{
+	CHudTimer *timer = GET_HUDELEMENT( CHudTimer );
+	if ( timer )
+	{
+		timer->SetNoFixedTimer( 0.0f );
+	}
+}
diff --git a/game/client/tf2/tf_in_main.cpp b/game/client/tf2/tf_in_main.cpp
new file mode 100644
index 0000000..f7ccd63
--- /dev/null
+++ b/game/client/tf2/tf_in_main.cpp
@@ -0,0 +1,36 @@
+//========= 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 CTFInput : public CInput
+{
+public:
+	int		GetButtonBits( int );
+};
+
+static CTFInput g_Input;
+
+// Expose this interface
+IInput *input = ( IInput * )&g_Input;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove Jump from the input bits
+//-----------------------------------------------------------------------------
+int CTFInput::GetButtonBits( int bResetState )
+{
+	int iBits = CInput::GetButtonBits( bResetState );
+
+	//iBits &= ~IN_JUMP;
+
+	return iBits;
+}
diff --git a/game/client/tf2/tf_prediction.cpp b/game/client/tf2/tf_prediction.cpp
new file mode 100644
index 0000000..8ab5608
--- /dev/null
+++ b/game/client/tf2/tf_prediction.cpp
@@ -0,0 +1,245 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "prediction.h"
+#include "tf_movedata.h"
+#include "c_basetfplayer.h"
+#include "c_tf_class_recon.h"
+#include "c_tf_class_commando.h"
+
+static CTFMoveData g_TFMoveData;
+CMoveData *g_pMoveData = &g_TFMoveData;
+
+
+class CTFPrediction : public CPrediction
+{
+DECLARE_CLASS( CTFPrediction, CPrediction );
+
+public:
+	virtual void	SetupMove( C_BasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
+	virtual void	FinishMove( C_BasePlayer *player, CUserCmd *ucmd, CMoveData *move );
+
+private:
+
+	void SetupMoveRecon( CUserCmd *ucmd, C_BaseTFPlayer *pTFPlayer, IMoveHelper *pHelper, 
+					     CTFMoveData *pTFMove );
+	void SetupMoveCommando( CUserCmd *ucmd, C_BaseTFPlayer *pTFPlayer, IMoveHelper *pHelper, 
+					        CTFMoveData *pTFMove );
+
+	void FinishMoveRecon( CTFMoveData *pTFMove, C_BaseTFPlayer *pTFPlayer );
+	void FinishMoveCommando( CTFMoveData *pTFMove, C_BaseTFPlayer *pTFPlayer );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFPrediction::SetupMove( C_BasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, 
+	CMoveData *move )
+{
+	// Call the default SetupMove code.
+	BaseClass::SetupMove( player, ucmd, pHelper, move );
+
+	//
+	// Convert to TF2 data.
+	//
+	C_BaseTFPlayer *pTFPlayer = static_cast<C_BaseTFPlayer*>( player );
+	Assert( pTFPlayer );
+
+	CTFMoveData *pTFMove = static_cast<CTFMoveData*>( move );
+	Assert( pTFMove );
+
+	//
+	// Handle player class specific setup.
+	//
+	pTFMove->m_nClassID = pTFPlayer->PlayerClass();
+	switch( pTFPlayer->GetClass() )
+	{
+	case TFCLASS_RECON: 
+		{ 
+			SetupMoveRecon( ucmd, pTFPlayer, pHelper, pTFMove ); 
+			break; 
+		}
+	case TFCLASS_COMMANDO: 
+		{ 
+			SetupMoveCommando( ucmd, pTFPlayer, pHelper, pTFMove ); 
+			break;
+		}
+	default:
+		{
+//			pTFMove->m_nClassID = TFCLASS_UNDECIDED;
+			break;
+		}
+	}
+
+	//
+	// Player movement data.
+	//
+
+	// Copy the position delta.
+	pTFMove->m_vecPosDelta = pTFPlayer->m_vecPosDelta;
+
+	// Copy the momentum data.
+	pTFMove->m_iMomentumHead = pTFPlayer->m_iMomentumHead;
+	for ( int iMomentum = 0; iMomentum < CTFMoveData::MOMENTUM_MAXSIZE; iMomentum++ )
+	{
+		pTFMove->m_aMomentum[iMomentum] = pTFPlayer->m_aMomentum[iMomentum];
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFPrediction::SetupMoveRecon( CUserCmd *ucmd, C_BaseTFPlayer *pTFPlayer, IMoveHelper *pHelper, 
+								    CTFMoveData *pTFMove )
+{
+	C_PlayerClassRecon *pRecon = static_cast<C_PlayerClassRecon*>( pTFPlayer->GetPlayerClass() );
+	if ( pRecon )
+	{
+		PlayerClassReconData_t *pReconData = pRecon->GetClassData();
+		if ( pReconData )
+		{
+			pTFMove->ReconData().m_nJumpCount = pReconData->m_nJumpCount;
+			pTFMove->ReconData().m_flSuppressionJumpTime = pReconData->m_flSuppressionJumpTime;
+			pTFMove->ReconData().m_flSuppressionImpactTime = pReconData->m_flSuppressionImpactTime;
+			pTFMove->ReconData().m_flActiveJumpTime = pReconData->m_flActiveJumpTime;
+			pTFMove->ReconData().m_flStickTime = pReconData->m_flStickTime;
+			pTFMove->ReconData().m_flImpactDist = pReconData->m_flImpactDist;
+			pTFMove->ReconData().m_vecImpactNormal = pReconData->m_vecImpactNormal;
+			pTFMove->ReconData().m_vecUnstickVelocity = pReconData->m_vecUnstickVelocity;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFPrediction::SetupMoveCommando( CUserCmd *ucmd, C_BaseTFPlayer *pTFPlayer, IMoveHelper *pHelper, 
+								       CTFMoveData *pTFMove )
+{
+	C_PlayerClassCommando *pCommando = static_cast<C_PlayerClassCommando*>( pTFPlayer->GetPlayerClass() );
+	if ( pCommando )
+	{
+		PlayerClassCommandoData_t *pCommandoData = pCommando->GetClassData();
+		if ( pCommandoData )
+		{
+			pTFMove->CommandoData().m_bCanBullRush = pCommandoData->m_bCanBullRush;
+			pTFMove->CommandoData().m_bBullRush = pCommandoData->m_bBullRush;
+			pTFMove->CommandoData().m_vecBullRushDir = pCommandoData->m_vecBullRushDir;
+			pTFMove->CommandoData().m_vecBullRushViewDir = pCommandoData->m_vecBullRushViewDir;
+			pTFMove->CommandoData().m_vecBullRushViewGoalDir = pCommandoData->m_vecBullRushViewGoalDir;
+			pTFMove->CommandoData().m_flBullRushTime = pCommandoData->m_flBullRushTime;
+			pTFMove->CommandoData().m_flDoubleTapForwardTime = pCommandoData->m_flDoubleTapForwardTime;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFPrediction::FinishMove( C_BasePlayer *player, CUserCmd *ucmd, CMoveData *move )
+{
+	// Call the default FinishMove code.
+	BaseClass::FinishMove( player, ucmd, move );
+
+	//
+	// Convert to TF2 data.
+	//
+	C_BaseTFPlayer *pTFPlayer = static_cast<C_BaseTFPlayer*>( player );
+	Assert( pTFPlayer );
+
+	CTFMoveData *pTFMove = static_cast<CTFMoveData*>( move );
+	Assert( pTFMove );
+
+	//
+	// Handle player class specific setup.
+	//
+	switch( pTFPlayer->PlayerClass() )
+	{
+	case TFCLASS_RECON: 
+		{ 
+			FinishMoveRecon( pTFMove, pTFPlayer ); 
+			break; 
+		}
+	case TFCLASS_COMMANDO: 
+		{ 
+			FinishMoveCommando( pTFMove, pTFPlayer ); 
+			break;
+		}
+	default:
+		{
+			break;
+		}
+	}
+
+	//
+	// Player movement data.
+	//
+
+	// Copy the position delta.
+	pTFPlayer->m_vecPosDelta = pTFMove->m_vecPosDelta;
+
+	// Copy the momentum data back (the movement may have updated it!).
+	pTFPlayer->m_iMomentumHead = pTFMove->m_iMomentumHead;
+	for ( int iMomentum = 0; iMomentum < CTFMoveData::MOMENTUM_MAXSIZE; iMomentum++ )
+	{
+		pTFPlayer->m_aMomentum[iMomentum] = pTFMove->m_aMomentum[iMomentum];
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFPrediction::FinishMoveRecon( CTFMoveData *pTFMove, C_BaseTFPlayer *pTFPlayer )
+{
+	C_PlayerClassRecon *pRecon = static_cast<C_PlayerClassRecon*>( pTFPlayer->GetPlayerClass() );
+	if ( pRecon )
+	{
+		PlayerClassReconData_t *pReconData = pRecon->GetClassData();
+		if ( pReconData )
+		{
+			pReconData->m_nJumpCount = pTFMove->ReconData().m_nJumpCount;
+			pReconData->m_flSuppressionJumpTime = pTFMove->ReconData().m_flSuppressionJumpTime;
+			pReconData->m_flSuppressionImpactTime = pTFMove->ReconData().m_flSuppressionImpactTime;
+			pReconData->m_flActiveJumpTime = pTFMove->ReconData().m_flActiveJumpTime;
+			pReconData->m_flStickTime = pTFMove->ReconData().m_flStickTime;
+			pReconData->m_flImpactDist = pTFMove->ReconData().m_flImpactDist;
+			pReconData->m_vecImpactNormal = pTFMove->ReconData().m_vecImpactNormal;
+			pReconData->m_vecUnstickVelocity = pTFMove->ReconData().m_vecUnstickVelocity;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFPrediction::FinishMoveCommando( CTFMoveData *pTFMove, C_BaseTFPlayer *pTFPlayer )
+{
+	C_PlayerClassCommando *pCommando = static_cast<C_PlayerClassCommando*>( pTFPlayer->GetPlayerClass() );
+	if ( pCommando )
+	{
+		PlayerClassCommandoData_t *pCommandoData = pCommando->GetClassData();
+		if ( pCommandoData )
+		{
+			pCommandoData->m_bCanBullRush = pTFMove->CommandoData().m_bCanBullRush;
+			pCommandoData->m_bBullRush = pTFMove->CommandoData().m_bBullRush;
+			pCommandoData->m_vecBullRushDir = pTFMove->CommandoData().m_vecBullRushDir;
+			pCommandoData->m_vecBullRushViewDir = pTFMove->CommandoData().m_vecBullRushViewDir;
+			pCommandoData->m_vecBullRushViewGoalDir = pTFMove->CommandoData().m_vecBullRushViewGoalDir;
+			pCommandoData->m_flBullRushTime = pTFMove->CommandoData().m_flBullRushTime;
+			pCommandoData->m_flDoubleTapForwardTime = pTFMove->CommandoData().m_flDoubleTapForwardTime;
+		}
+	}
+}
+
+// Expose interface to engine
+// Expose interface to engine
+static CTFPrediction g_Prediction;
+
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CTFPrediction, IPrediction, VCLIENT_PREDICTION_INTERFACE_VERSION, g_Prediction );
+
+CPrediction *prediction = &g_Prediction;
+
diff --git a/game/client/tf2/vgui_healthbar.cpp b/game/client/tf2/vgui_healthbar.cpp
new file mode 100644
index 0000000..83e9768
--- /dev/null
+++ b/game/client/tf2/vgui_healthbar.cpp
@@ -0,0 +1,134 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "vgui_HealthBar.h"
+#include "CommanderOverlay.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : 
+//-----------------------------------------------------------------------------
+CHealthBarPanel::CHealthBarPanel( vgui::Panel *pParent ) : vgui::Panel(pParent, "CHealthBarPanel" )
+{
+	SetHealth( 0.0f );
+	SetPaintBackgroundEnabled( false );
+	SetVertical( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHealthBarPanel::~CHealthBarPanel( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Parse values from the file
+//-----------------------------------------------------------------------------
+bool CHealthBarPanel::Init( KeyValues* pInitData )
+{
+	if (!pInitData)
+		return false;
+
+	if (!ParseRGBA(pInitData, "okcolor", m_Ok ))
+		return false;
+
+	if (!ParseRGBA(pInitData, "badcolor", m_Bad ))
+		return false;
+
+	int x, y, w, h;
+	if (!ParseRect(pInitData, "position", x, y, w, h ))
+		return false;
+	SetPos( x, y );
+	SetSize( w, h );
+	SetCursor( NULL );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHealthBarPanel::SetGoodColor( int r, int g, int b, int a )
+{
+	m_Ok.SetColor( r,g,b,a );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHealthBarPanel::SetBadColor( int r, int g, int b, int a )
+{
+	m_Bad.SetColor( r,g,b,a );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHealthBarPanel::SetHealth( float health )
+{
+	m_Health = health;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHealthBarPanel::SetVertical( bool bVertical )
+{
+	m_bVertical = bVertical;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHealthBarPanel::Paint( void )
+{
+	int w, h;
+	GetSize( w, h );
+	
+	float frac;
+	frac = MIN( 1.0, m_Health );
+	frac = MAX( 0.0, m_Health );
+
+	vgui::surface()->DrawSetColor( 255,255,255,255 );
+	vgui::surface()->DrawOutlinedRect( 0,0, w,h );
+
+	int drawwidth = frac * w;
+	int drawheight = frac * h;
+
+	// Draw the Ok section
+	vgui::surface()->DrawSetColor( m_Ok[0], m_Ok[1], m_Ok[2], m_Ok[3] );
+	if ( m_bVertical )
+	{
+		vgui::surface()->DrawFilledRect( 0, h - drawheight, w, h );
+	}
+	else
+	{
+		vgui::surface()->DrawFilledRect( 0, 0, drawwidth, h );
+	}
+
+	vgui::surface()->DrawSetColor( m_Bad[0], m_Bad[1], m_Bad[2], m_Bad[3] );
+	// Draw the Bad section
+	if ( m_bVertical )
+	{
+		if (h != drawheight)
+		{
+			vgui::surface()->DrawFilledRect( 0, 0, w, h - drawheight );
+		}
+	}
+	else
+	{
+		if (w != drawwidth)
+		{
+			vgui::surface()->DrawFilledRect( drawwidth, 0, w, h );
+		}
+	}
+}
\ No newline at end of file
diff --git a/game/client/tf2/vgui_healthbar.h b/game/client/tf2/vgui_healthbar.h
new file mode 100644
index 0000000..4b68f26
--- /dev/null
+++ b/game/client/tf2/vgui_healthbar.h
@@ -0,0 +1,46 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#ifndef VGUI_HEALTHBAR_H
+#define VGUI_HEALTHBAR_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include <vgui_controls/Panel.h>
+
+class KeyValues;
+
+class CHealthBarPanel : public vgui::Panel
+{
+public:
+	CHealthBarPanel( vgui::Panel *pParent = NULL );
+	virtual ~CHealthBarPanel( void );
+
+	// Setup
+	bool Init( KeyValues* pInitData );
+	void SetGoodColor( int r, int g, int b, int a );
+	void SetBadColor( int r, int g, int b, int a );
+	void SetVertical( bool bVertical );
+
+	// Health is expected to go from 0 to 1
+	void SetHealth( float health );
+
+	virtual void Paint( void );
+	virtual void PaintBackground( void ) {}
+
+private:
+	float	m_Health;
+	Color m_Ok;
+	Color m_Bad;
+	bool	m_bVertical;	// True if this bar should be vertical
+};
+
+#endif // VGUI_HEALTHBAR_H
\ No newline at end of file
diff --git a/game/client/tf2/vgui_rootpanel_tf2.cpp b/game/client/tf2/vgui_rootpanel_tf2.cpp
new file mode 100644
index 0000000..b6bc6c9
--- /dev/null
+++ b/game/client/tf2/vgui_rootpanel_tf2.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_tf2rootpanel.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+C_TF2RootPanel *g_pTF2RootPanel = NULL;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void VGUI_CreateClientDLLRootPanel( void )
+{
+	g_pTF2RootPanel = new C_TF2RootPanel( enginevgui->GetPanel( PANEL_CLIENTDLL ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void VGUI_DestroyClientDLLRootPanel( void )
+{
+	delete g_pTF2RootPanel;
+	g_pTF2RootPanel = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Game specific root panel
+// Output : vgui::Panel
+//-----------------------------------------------------------------------------
+vgui::VPANEL VGui_GetClientDLLRootPanel( void )
+{
+	return g_pTF2RootPanel->GetVPanel();
+}
\ No newline at end of file
diff --git a/game/client/tf2/vgui_rotation_slider.cpp b/game/client/tf2/vgui_rotation_slider.cpp
new file mode 100644
index 0000000..e1ee1e6
--- /dev/null
+++ b/game/client/tf2/vgui_rotation_slider.cpp
@@ -0,0 +1,74 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include <vgui/MouseCode.h>
+#include "vgui_rotation_slider.h"
+
+
+CRotationSlider::CRotationSlider( vgui::Panel *pParent, const char *pName ) :
+	BaseClass( pParent, pName )
+{
+	AddActionSignalTarget( this );
+	SetRange( -180, 180 );
+	SetTickCaptions("-180", "180");
+	SetValue( 0 );
+	m_flYaw = 0;
+}
+
+void CRotationSlider::SetControlledObject( C_BaseObject *pObject )
+{
+	m_hObject.Set( pObject );
+}
+
+//-----------------------------------------------------------------------------
+// When the slider is activated, deactivated, or moves
+//-----------------------------------------------------------------------------
+void CRotationSlider::OnMousePressed( vgui::MouseCode code )
+{
+	BaseClass::OnMousePressed( code );
+
+	if (code != vgui::MOUSE_LEFT)
+		return;
+
+	C_BaseObject *pObj = m_hObject.Get();
+	if (pObj)
+	{
+		m_flInitialYaw = pObj->GetAbsAngles().y;
+		pObj->PreviewYaw( m_flInitialYaw );
+		pObj->ActivateYawPreview( true );
+	}
+}
+
+void CRotationSlider::OnSliderMoved( int position )
+{
+	C_BaseObject *pObj = m_hObject.Get();
+	if (pObj && pObj->IsPreviewingYaw())
+	{
+		m_flYaw = anglemod(position);
+		pObj->PreviewYaw( m_flInitialYaw - m_flYaw );
+	}
+}
+
+void CRotationSlider::OnMouseReleased( vgui::MouseCode code )
+{
+	BaseClass::OnMouseReleased( code );
+
+	if (code != vgui::MOUSE_LEFT)
+		return;
+
+	C_BaseObject *pObj = m_hObject.Get();
+	if (pObj)
+	{
+		char szbuf[48];
+		Q_snprintf( szbuf, sizeof( szbuf ), "yaw %0.2f\n",  m_flInitialYaw - m_flYaw );
+		pObj->SendClientCommand( szbuf );
+		pObj->ActivateYawPreview( false );
+		SetValue(0);
+		m_flYaw = 0;
+	}
+}
diff --git a/game/client/tf2/vgui_rotation_slider.h b/game/client/tf2/vgui_rotation_slider.h
new file mode 100644
index 0000000..549068a
--- /dev/null
+++ b/game/client/tf2/vgui_rotation_slider.h
@@ -0,0 +1,43 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef VGUI_ROTATION_SLIDER_H
+#define VGUI_ROTATION_SLIDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include <vgui_controls/Slider.h>
+#include "c_baseobject.h"
+
+
+//-----------------------------------------------------------------------------
+//
+// Slider for object control
+//
+//-----------------------------------------------------------------------------
+class CRotationSlider : public vgui::Slider
+{
+	DECLARE_CLASS_SIMPLE( CRotationSlider, vgui::Slider );
+
+public:
+	CRotationSlider( vgui::Panel *pParent, const char *pName );
+	void SetControlledObject( C_BaseObject *pObject );
+
+	virtual void OnMousePressed( vgui::MouseCode code );
+	virtual void OnMouseReleased( vgui::MouseCode code );
+	MESSAGE_FUNC_INT( OnSliderMoved, "SliderMoved", position );
+
+private:
+	CHandle<C_BaseObject>	m_hObject;
+	float m_flInitialYaw;
+	float m_flYaw;
+};
+
+
+#endif // VGUI_ROTATION_SLIDER_H
diff --git a/game/client/tf2/ztestmaterialproxy.cpp b/game/client/tf2/ztestmaterialproxy.cpp
new file mode 100644
index 0000000..102cd34
--- /dev/null
+++ b/game/client/tf2/ztestmaterialproxy.cpp
@@ -0,0 +1,64 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "materialsystem/imaterialproxy.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialvar.h"
+
+// $sineVar : name of variable that controls the alpha level (float)
+class CzTestMaterialProxy : public IMaterialProxy
+{
+public:
+	CzTestMaterialProxy();
+	virtual ~CzTestMaterialProxy();
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pC_BaseEntity );
+	virtual void Release( void ) { delete this; }
+private:
+	C_BaseEntity *BindArgToEntity( void *pArg );
+
+	IMaterialVar *m_AlphaVar;
+};
+
+CzTestMaterialProxy::CzTestMaterialProxy()
+{
+	m_AlphaVar = NULL;
+}
+
+CzTestMaterialProxy::~CzTestMaterialProxy()
+{
+}
+
+C_BaseEntity *CzTestMaterialProxy::BindArgToEntity( void *pArg )
+{
+	IClientRenderable *pRend = (IClientRenderable *)pArg;
+	return pRend->GetIClientUnknown()->GetBaseEntity();
+}
+
+bool CzTestMaterialProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	bool foundVar;
+	m_AlphaVar = pMaterial->FindVar( "$alpha", &foundVar, false );
+	return foundVar;
+}
+
+void CzTestMaterialProxy::OnBind( void *pC_BaseEntity )
+{
+	C_BaseEntity *pEnt = BindArgToEntity( pC_BaseEntity );
+	if( !pEnt )
+	{
+		return;
+	}
+
+	if (m_AlphaVar)
+	{
+		m_AlphaVar->SetFloatValue( pEnt->m_clrRender.a );
+	}
+
+}
+
+EXPOSE_INTERFACE( CzTestMaterialProxy, IMaterialProxy, "zTest" IMATERIAL_PROXY_INTERFACE_VERSION );