1HEADmaster

138 files changed, 34359 insertions, 0 deletions

diff --git a/game/shared/tf2/baseobject_shared.cpp b/game/shared/tf2/baseobject_shared.cpp
new file mode 100644
index 0000000..5c77335
--- /dev/null
+++ b/game/shared/tf2/baseobject_shared.cpp
@@ -0,0 +1,583 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "baseobject_shared.h"
+#include <KeyValues.h>
+#include "tf_shareddefs.h"
+#include "engine/ivmodelinfo.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Parse our model and create the buildpoints in it
+//-----------------------------------------------------------------------------
+void CBaseObject::CreateBuildPoints( void )
+{
+	// Clear out any existing build points
+	m_BuildPoints.RemoveAll();
+
+	KeyValues * modelKeyValues = new KeyValues("");
+	if ( !modelKeyValues->LoadFromBuffer( modelinfo->GetModelName( GetModel() ), modelinfo->GetModelKeyValueText( GetModel() ) ) )
+	{
+		return;
+	}
+
+	// Do we have a build point section?
+	KeyValues *pkvAllBuildPoints = modelKeyValues->FindKey("build_points");
+	if ( pkvAllBuildPoints )
+	{
+		KeyValues *pkvBuildPoint = pkvAllBuildPoints->GetFirstSubKey();
+		while ( pkvBuildPoint )
+		{
+			// Find the attachment first
+			const char *sAttachment = pkvBuildPoint->GetName();
+			int iAttachmentNumber = LookupAttachment( sAttachment );
+			if ( iAttachmentNumber )
+			{
+				AddAndParseBuildPoint( iAttachmentNumber, pkvBuildPoint );
+			}
+			else
+			{
+				Msg( "ERROR: Model %s specifies buildpoint %s, but has no attachment named %s.\n", STRING(GetModelName()), pkvBuildPoint->GetString(), pkvBuildPoint->GetString() );
+			}
+
+			pkvBuildPoint = pkvBuildPoint->GetNextKey();
+		}
+	}
+
+	// Any virtual build points (build points that aren't on an attachment)?
+	pkvAllBuildPoints = modelKeyValues->FindKey("virtual_build_points");
+	if ( pkvAllBuildPoints )
+	{
+		KeyValues *pkvBuildPoint = pkvAllBuildPoints->GetFirstSubKey();
+		while ( pkvBuildPoint )
+		{
+			AddAndParseBuildPoint( -1, pkvBuildPoint );
+			pkvBuildPoint = pkvBuildPoint->GetNextKey();
+		}
+	}
+
+	modelKeyValues->deleteThis();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::AddAndParseBuildPoint( int iAttachmentNumber, KeyValues *pkvBuildPoint )
+{
+	int iPoint = AddBuildPoint( iAttachmentNumber );
+
+	
+	m_BuildPoints[iPoint].m_bPutInAttachmentSpace = (pkvBuildPoint->GetInt( "PutInAttachmentSpace", 0 ) != 0);
+
+	// Now see if we've got a set of valid objects specified
+	KeyValues *pkvValidObjects = pkvBuildPoint->FindKey( "valid_objects" );
+	if ( pkvValidObjects )
+	{
+		KeyValues *pkvObject = pkvValidObjects->GetFirstSubKey();
+		while ( pkvObject )
+		{
+			const char *pSpecifiedObject = pkvObject->GetName();
+			int iLenObjName = Q_strlen( pSpecifiedObject );
+
+			// Find the object index for the name
+			for ( int i = 0; i < OBJ_LAST; i++ )
+			{
+				if ( !Q_strncmp( GetObjectInfo( i )->m_pClassName, pSpecifiedObject, iLenObjName) )
+				{
+					AddValidObjectToBuildPoint( iPoint, i );
+					break;
+				}
+			}
+
+			pkvObject = pkvObject->GetNextKey();
+		}
+	}
+
+	SetBuildPointPassenger( iPoint, pkvBuildPoint->GetInt( "passenger", -1 ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a new buildpoint to my list of buildpoints
+//-----------------------------------------------------------------------------
+int CBaseObject::AddBuildPoint( int iAttachmentNum )
+{
+	// Make a new buildpoint
+	BuildPoint_t sNewPoint;
+	sNewPoint.m_hObject = NULL;
+	sNewPoint.m_iAttachmentNum = iAttachmentNum;
+	sNewPoint.m_iPassenger = -1;
+	sNewPoint.m_bPutInAttachmentSpace = false;
+	Q_memset( sNewPoint.m_bValidObjects, 0, sizeof( sNewPoint.m_bValidObjects ) );
+
+	// Insert it into our list
+	return m_BuildPoints.AddToTail( sNewPoint );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Indicate which passenger position this build point is associated with
+//-----------------------------------------------------------------------------
+void CBaseObject::SetBuildPointPassenger( int iPoint, int iPassenger )
+{
+	m_BuildPoints[iPoint].m_iPassenger = iPassenger;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseObject::GetBuildPointPassenger( int iPoint ) const
+{
+	return m_BuildPoints[iPoint].m_iPassenger;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::AddValidObjectToBuildPoint( int iPoint, int iObjectType )
+{
+	Assert( iPoint <= GetNumBuildPoints() );
+	m_BuildPoints[iPoint].m_bValidObjects[ iObjectType ] = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseObject::GetNumBuildPoints( void ) const
+{
+	return m_BuildPoints.Size();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseObject* CBaseObject::GetBuildPointObject( int iPoint )
+{
+	Assert( iPoint >= 0 && iPoint <= GetNumBuildPoints() );
+
+	return m_BuildPoints[iPoint].m_hObject;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the specified object type can be built on this point
+//-----------------------------------------------------------------------------
+bool CBaseObject::CanBuildObjectOnBuildPoint( int iPoint, int iObjectType )
+{
+	Assert( iPoint >= 0 && iPoint <= GetNumBuildPoints() );
+
+	// Allowed to build here?
+	if ( !m_BuildPoints[iPoint].m_bValidObjects[ iObjectType ] )
+		return false;
+
+	// Buildpoint empty?
+	return ( m_BuildPoints[iPoint].m_hObject == NULL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseObject::GetBuildPoint( int iPoint, Vector &vecOrigin, QAngle &vecAngles )
+{
+	Assert( iPoint >= 0 && iPoint <= GetNumBuildPoints() );
+
+	int iAttachmentNum = m_BuildPoints[iPoint].m_iAttachmentNum;
+	if ( iAttachmentNum == -1 )
+	{
+		vecOrigin = GetAbsOrigin();
+		vecAngles = GetAbsAngles();
+		return true;
+	}
+	else
+	{
+		return GetAttachment( m_BuildPoints[iPoint].m_iAttachmentNum, vecOrigin, vecAngles );
+	}
+}
+
+
+int CBaseObject::GetBuildPointAttachmentIndex( int iPoint ) const
+{
+	Assert( iPoint >= 0 && iPoint <= GetNumBuildPoints() );
+
+	if ( m_BuildPoints[iPoint].m_bPutInAttachmentSpace )
+	{
+		return m_BuildPoints[iPoint].m_iAttachmentNum;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CBaseObject::SetObjectOnBuildPoint( int iPoint, CBaseObject *pObject )
+{
+	Assert( iPoint >= 0 && iPoint <= GetNumBuildPoints() );
+	m_BuildPoints[iPoint].m_hObject = pObject;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CBaseObject::GetMaxSnapDistance( int iPoint )
+{
+	Assert( iPoint >= 0 && iPoint <= GetNumBuildPoints() );
+
+	if ( m_BuildPoints[iPoint].m_iAttachmentNum == -1 )
+	{
+		// Virtual build points need some more space since they represent an upgrade to the whole object.
+		return 128;
+	}
+	else
+	{
+		return 128;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the number of objects on my build points
+//-----------------------------------------------------------------------------
+int CBaseObject::GetNumObjectsOnMe( void )
+{
+	int iObjects = 0;
+	for ( int i = 0; i < GetNumBuildPoints(); i++ )
+	{
+		if ( m_BuildPoints[i].m_hObject )
+		{
+			iObjects++;
+		}
+	}
+
+	return iObjects;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the first object build on this object
+//-----------------------------------------------------------------------------
+CBaseEntity *CBaseObject::GetFirstObjectOnMe( void )
+{
+	for ( int i = 0; i < GetNumBuildPoints(); i++ )
+	{
+		if ( m_BuildPoints[i].m_hObject )
+			return m_BuildPoints[i].m_hObject;
+	}
+
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// I've finished building the specified object on the specified build point
+//-----------------------------------------------------------------------------
+int CBaseObject::FindObjectOnBuildPoint( CBaseObject *pObject )
+{
+	for (int i = m_BuildPoints.Count(); --i >= 0; )
+	{
+		if (m_BuildPoints[i].m_hObject == pObject)
+			return i;
+	}
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseObject *CBaseObject::GetObjectOfTypeOnMe( int iObjectType )
+{
+	for ( int iObject = 0; iObject < GetNumObjectsOnMe(); ++iObject )
+	{
+		CBaseObject *pObject = dynamic_cast<CBaseObject*>( m_BuildPoints[iObject].m_hObject.Get() );
+		if ( pObject )
+		{
+			if ( pObject->GetType() == iObjectType )
+				return pObject;
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::RemoveAllObjects( void )
+{
+	for ( int i = 0; i < GetNumBuildPoints(); i++ )
+	{
+		if ( m_BuildPoints[i].m_hObject )
+		{
+#ifndef CLIENT_DLL
+			UTIL_Remove( m_BuildPoints[i].m_hObject );
+#endif
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseObject	*CBaseObject::GetParentObject( void )
+{
+	if ( GetMoveParent() )
+		return dynamic_cast<CBaseObject*>(GetMoveParent());
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if I ever accept this powerup type
+//-----------------------------------------------------------------------------
+bool CBaseObject::CanPowerupEver( int iPowerup )
+{
+	Assert( iPowerup >= 0 && iPowerup < MAX_POWERUPS );
+
+	// Un-repairable objects can't be boosted
+	switch( iPowerup )
+	{
+#ifndef CLIENT_DLL
+	case POWERUP_BOOST:
+		if ( !m_flRepairMultiplier )
+			return false;
+		break;
+#endif
+
+	case POWERUP_POWER:
+		// Do we use power?
+		if ( m_fObjectFlags & OF_DOESNT_NEED_POWER )
+			return false;
+
+		// Objects on vehicles never need power
+		if ( IsBuiltOnAttachment() )
+		{
+			if ( GetParentObject() && GetParentObject()->IsAVehicle() )
+				return false;
+		}
+
+		// Ok, I'll be needing some juice
+		return true;
+
+	default:
+		break;
+	}
+
+	// Don't accept any powerups if we're placing
+	if ( IsPlacing() )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if I can be powered by this powerup right now
+//-----------------------------------------------------------------------------
+bool CBaseObject::CanPowerupNow( int iPowerup )
+{
+	Assert( iPowerup >= 0 && iPowerup < MAX_POWERUPS );
+
+	if ( !CanPowerupEver(iPowerup) )
+		return false;
+
+	// Un-repairable objects can't be boosted
+	switch( iPowerup )
+	{
+	case POWERUP_POWER:
+		// If I have power, I don't need it
+		if ( IsPowered() )
+			return false;
+		return true;
+
+	default:
+		break;
+	}
+
+	// Don't accept any powerups if we're placing
+	if ( IsPlacing() )
+		return false;
+
+#ifdef CLIENT_DLL
+	return true;
+#else
+	return BaseClass::CanPowerupEver( iPowerup );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this object has power
+//-----------------------------------------------------------------------------
+bool CBaseObject::IsPowered( void )
+{
+	if ( !CanPowerupEver( POWERUP_POWER ) )
+		return true;
+
+#ifdef CLIENT_DLL
+	return ( HasPowerup(POWERUP_POWER) );
+#else
+	return ( HasPowerup(POWERUP_POWER) || m_hPowerPack );
+#endif
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CBaseObject::GetSapperAttachTime( void )
+{
+	return GetObjectInfo( GetType() )->m_flSapperAttachTime;
+}
+
+static ConVar sv_ignore_hitboxes( "sv_ignore_hitboxes", "0", FCVAR_REPLICATED, "Disable hitboxes" );
+
+bool CBaseObject::TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr )
+{
+	bool bReturn = BaseClass::TestHitboxes( ray, fContentsMask, tr );
+
+	if( !sv_ignore_hitboxes.GetBool() )
+		return bReturn;
+
+
+	if( !bReturn )
+	{
+		return false;
+	}
+
+	if( tr.fraction == 1.f  && !tr.allsolid && !tr.startsolid )
+	{
+		return false;
+	}
+
+	return bReturn;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this object should be active
+//-----------------------------------------------------------------------------
+bool CBaseObject::ShouldBeActive( void )
+{
+	// Placing and/or constructing objects shouldn't be active
+	if ( IsPlacing() || IsBuilding() )
+		return false;
+
+	// Powered? Or don't need it
+	if ( CanPowerupEver(POWERUP_POWER) && !HasPowerup( POWERUP_POWER ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the object's type
+//-----------------------------------------------------------------------------
+void CBaseObject::SetType( int iObjectType )
+{
+	m_iObjectType = iObjectType;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : act - 
+//-----------------------------------------------------------------------------
+void CBaseObject::SetActivity( Activity act ) 
+{ 
+	// Allow any model swapping, etc. to occur
+	OnActivityChanged( act );
+
+	// Hrm, it's not actually a studio model...
+	if ( !GetModelPtr() )
+		return;
+
+	int sequence = SelectWeightedSequence( act ); 
+	if ( sequence != ACTIVITY_NOT_AVAILABLE )
+	{
+		m_Activity = act; 
+		SetObjectSequence( sequence );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Activity
+//-----------------------------------------------------------------------------
+Activity CBaseObject::GetActivity( ) const
+{ 
+	return m_Activity;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : act - 
+//-----------------------------------------------------------------------------
+void CBaseObject::OnActivityChanged( Activity act )
+{
+	// Nothing
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Thin wrapper over CBaseAnimating::SetSequence to do bookkeeping.
+// Input  : sequence - 
+//-----------------------------------------------------------------------------
+void CBaseObject::SetObjectSequence( int sequence )
+{
+	ResetSequence( sequence );
+	SetCycle( 0 );
+
+#if !defined( CLIENT_DLL )
+	if ( IsUsingClientSideAnimation() )
+	{
+		ResetClientsideFrame();
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::AttemptToGoActive( void )
+{
+	// Go active if we can
+	if ( ShouldBeActive() )
+	{
+		OnGoActive();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::OnGoActive( void )
+{
+#ifndef CLIENT_DLL
+	// Play startup animation
+	PlayStartupAnimation();
+
+	// Switch to the on state
+	if ( GetModelPtr() )
+	{
+		int index = FindBodygroupByName( "powertoggle" );
+		if ( index >= 0 )
+		{
+			SetBodygroup( index, 1 );
+		}
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObject::OnGoInactive( void )
+{
+#ifndef CLIENT_DLL
+	if ( GetModelPtr() )
+	{
+		// Switch to the off state
+		int index = FindBodygroupByName( "powertoggle" );
+		if ( index >= 0 )
+		{
+			SetBodygroup( index, 0 );
+		}
+	}
+#endif
+}
\ No newline at end of file
diff --git a/game/shared/tf2/baseobject_shared.h b/game/shared/tf2/baseobject_shared.h
new file mode 100644
index 0000000..b556098
--- /dev/null
+++ b/game/shared/tf2/baseobject_shared.h
@@ -0,0 +1,49 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef BASEOBJECT_SHARED_H
+#define BASEOBJECT_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_shareddefs.h"
+
+#if defined( CLIENT_DLL )
+#define CBaseObject C_BaseObject
+#endif
+
+class CBaseObject;
+typedef CHandle<CBaseObject>	ObjectHandle;
+struct BuildPoint_t
+{
+	// If this is true, then objects are parented to the attachment point instead of 
+	// parented to the entity's abs origin + angles. That way, they'll move if the 
+	// attachment point animates.
+	bool			m_bPutInAttachmentSpace;	
+
+	int				m_iAttachmentNum;
+	ObjectHandle	m_hObject;
+	int				m_iPassenger;
+	bool			m_bValidObjects[ OBJ_LAST ];
+};
+
+struct VulnerablePoint_t
+{
+	float m_fDamageMultiplier;
+	int   m_nSet;
+	int	  m_nBox;
+};
+
+// Shared header file for players
+#if defined( CLIENT_DLL )
+#include "c_baseobject.h"
+#else
+#include "tf_obj.h"
+#endif
+
+#endif // BASEOBJECT_SHARED_H
diff --git a/game/shared/tf2/basetfcombatweapon_shared.cpp b/game/shared/tf2/basetfcombatweapon_shared.cpp
new file mode 100644
index 0000000..9484284
--- /dev/null
+++ b/game/shared/tf2/basetfcombatweapon_shared.cpp
@@ -0,0 +1,497 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "basetfcombatweapon_shared.h"
+#include "weapon_twohandedcontainer.h"
+
+#if !defined( CLIENT_DLL )
+#include "soundent.h"
+#else
+#include "functionproxy.h"
+#include "ivrenderview.h"
+#include "cl_animevent.h"
+#include "fx.h"
+#endif
+
+CBaseTFCombatWeapon::CBaseTFCombatWeapon ( void )
+{
+	m_bReflectViewModelAnimations = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFCombatWeapon::Precache( void )
+{
+	BaseClass::Precache();
+
+#if !defined( CLIENT_DLL )
+	// Connect to my CVars
+	m_pDamageCVar = cvar->FindVar( UTIL_VarArgs( "%s_damage", GetClassname() ) );
+	m_pRangeCVar = cvar->FindVar( UTIL_VarArgs( "%s_range", GetClassname() ) );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	CBaseTFCombatWeapon::GetPrimaryAmmo( void )
+{
+	// Get the local player
+	CBasePlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( pPlayer == NULL )
+		return 0;
+
+	return pPlayer->GetAmmoCount( m_iPrimaryAmmoType );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Checks if the owner is EMPed
+//-----------------------------------------------------------------------------
+bool CBaseTFCombatWeapon::IsOwnerEMPed()
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ((!pPlayer) || (!pPlayer->GetPlayerClass()))
+		return false;
+
+	return ( pPlayer->HasPowerup(POWERUP_EMP) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Temporarily remove disguise
+//-----------------------------------------------------------------------------
+void CBaseTFCombatWeapon::CheckRemoveDisguise( void )
+{
+#if !defined( CLIENT_DLL )
+	CBaseTFPlayer *player = static_cast< CBaseTFPlayer * >( GetOwner());
+	if ( player )
+	{
+		// Always remove camo
+		player->ClearCamouflage();
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Factor in the player's anim speed to the sequence duration for weapons
+//-----------------------------------------------------------------------------
+float CBaseTFCombatWeapon::SequenceDuration( int iSequence )
+{
+	float flDuration = BaseClass::SequenceDuration( iSequence );
+	CBaseTFPlayer *pOwner = (CBaseTFPlayer *)GetOwner();
+	if ( pOwner )
+	{
+		flDuration /= pOwner->GetDefaultAnimSpeed();
+	}
+
+	return flDuration;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Override weapon sound. TF doesn't use ATTN_GUNFIRE for it's weapon attenuations.
+//-----------------------------------------------------------------------------
+void CBaseTFCombatWeapon::WeaponSound( WeaponSound_t shoot_type, float soundtime /*= 0.0f*/ )
+{
+#if !defined( CLIENT_DLL )
+	// HACKHACK: Force a combat sound to alert NPCs, for antlion prototype
+	CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 600, 0.1 );
+#endif
+
+	BaseClass::WeaponSound( shoot_type, soundtime );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the point from which to create the weapon's tracer
+//-----------------------------------------------------------------------------
+Vector CBaseTFCombatWeapon::GetTracerSrc( Vector &vecSrc, Vector &vecFireDir )
+{
+	QAngle vecAngles;
+	VectorAngles( vecFireDir, vecAngles );
+	Vector right;
+	AngleVectors( vecAngles, NULL, &right, NULL );
+	return (vecSrc + Vector ( 0,0,-4 ) + right * 2 + vecFireDir * 16);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : activity - 
+//-----------------------------------------------------------------------------
+void CBaseTFCombatWeapon::PlayAttackAnimation( int activity )
+{
+	SendWeaponAnim( activity );
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		pPlayer->SetAnimation( PLAYER_ATTACK1 );
+		pPlayer->SetLastAttackTime( gpGlobals->curtime );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : sequence - 
+//-----------------------------------------------------------------------------
+bool CBaseTFCombatWeapon::SendWeaponAnim( int iActivity )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return false;
+
+	CBaseTFCombatWeapon *pOther = NULL;
+
+	// See if we are wielding multiple weapons
+	CWeaponTwoHandedContainer *pContainer = dynamic_cast< CWeaponTwoHandedContainer * >( pPlayer->GetActiveWeapon() );
+	if ( pContainer )
+	{
+		// Make sure they exist
+		CBaseTFCombatWeapon  *left = static_cast< CBaseTFCombatWeapon  * >( pContainer->GetLeftWeapon() );
+		CBaseTFCombatWeapon  *right = static_cast< CBaseTFCombatWeapon  * >( pContainer->GetRightWeapon() );
+		if ( !left || !right )
+			return false;
+
+		// Make sure one of them is this!!!
+		if ( left != this && right != this )
+			return false;
+
+		// Get pointer to other one
+		pOther = left;
+		if ( left == this )
+		{
+			pOther = right;
+		}
+
+		Assert(pOther);
+
+		// Now ask our other weapon if it would like to stomp my animation attempt
+		iActivity = pOther->ReplaceOtherWeaponsActivity( iActivity );
+		if ( iActivity == -1 )
+			return false;
+	}
+
+	// Always pass through to base
+	BaseClass::SendWeaponAnim( iActivity );
+
+	if ( !IsReflectingAnimations() )
+		return false;
+
+	// See if we are wielding multiple weapons
+	if ( !pContainer )
+		return false;
+
+	Assert(pOther);
+	// Send our other weapon the activity code
+	iActivity = GetOtherWeaponsActivity( iActivity );
+	if ( iActivity != -1 )
+	{
+		pOther->SendWeaponAnim( iActivity );
+
+		// Remember it for weapon switching
+		m_iLastReflectedActivity = iActivity;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : reflect - 
+//-----------------------------------------------------------------------------
+void CBaseTFCombatWeapon::SetReflectViewModelAnimations( bool reflect )
+{
+	m_bReflectViewModelAnimations = reflect;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTFCombatWeapon::IsReflectingAnimations( void ) const
+{
+	return m_bReflectViewModelAnimations;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseTFCombatWeapon::IsCamouflaged( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)GetOwner();
+	if ( pPlayer && pPlayer->IsCamouflaged() )
+		return true;
+		
+	return false;
+}
+
+#if defined( CLIENT_DLL )
+static ConVar	cl_bobcycle( "cl_bobcycle","0.8" );
+static ConVar	cl_bob( "cl_bob","0.002" );
+static ConVar	cl_bobup( "cl_bobup","0.5" );
+
+// Register these cvars if needed for easy tweaking
+static ConVar	v_iyaw_cycle( "v_iyaw_cycle", "2"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_iroll_cycle( "v_iroll_cycle", "0.5"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_ipitch_cycle( "v_ipitch_cycle", "1"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_iyaw_level( "v_iyaw_level", "0.3"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_iroll_level( "v_iroll_level", "0.1"/*, FCVAR_UNREGISTERED*/ );
+static ConVar	v_ipitch_level( "v_ipitch_level", "0.3"/*, FCVAR_UNREGISTERED*/ );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CBaseTFCombatWeapon::CalcViewmodelBob( void )
+{
+	static	double	bobtime;
+	static float	bob;
+	float	cycle;
+	
+	CBasePlayer *player = ToBasePlayer( GetOwner() );
+	if ( !player )
+		return 0.0f;
+
+	if ( ( player->GetGroundEntity() == NULL ) || !gpGlobals->frametime )
+	{
+		return bob;		// just use old value
+	}
+
+	bobtime += gpGlobals->frametime;
+	
+	cycle = bobtime - (int)(bobtime/cl_bobcycle.GetFloat())*cl_bobcycle.GetFloat();
+	cycle /= cl_bobcycle.GetFloat();
+
+	if (cycle < cl_bobup.GetFloat())
+	{
+		cycle = M_PI * cycle / cl_bobup.GetFloat();
+	}
+	else
+	{
+		cycle = M_PI + M_PI*(cycle-cl_bobup.GetFloat())/(1.0 - cl_bobup.GetFloat());
+	}
+
+	// bob is proportional to simulated velocity in the xy plane
+	// (don't count Z, or jumping messes it up)
+	bob = player->GetAbsVelocity().Length2D() * cl_bob.GetFloat();
+	
+	bob = bob*0.3 + bob*0.7*sin(cycle);
+
+	bob = MIN( 4.0, bob );
+	bob = MAX( -7.0, bob );
+	return bob;
+	
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+void CBaseTFCombatWeapon::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
+{
+	float fIdleScale = 2.0f;
+
+	// Bias so view models aren't all synced to each other
+	//float curtime = gpGlobals->curtime + ( viewmodelindex * 2 * M_PI / GetViewModelCount() );
+
+	float curtime = gpGlobals->curtime + ( viewmodel->entindex() * 2 * M_PI );
+
+	origin[ROLL]	-= fIdleScale * sin(curtime*v_iroll_cycle.GetFloat()) * v_iroll_level.GetFloat();
+	origin[PITCH]	-= fIdleScale * sin(curtime*v_ipitch_cycle.GetFloat()) * (v_ipitch_level.GetFloat() * 0.5);
+	origin[YAW]		-= fIdleScale * sin(curtime*v_iyaw_cycle.GetFloat()) * v_iyaw_level.GetFloat();
+
+	Vector	forward;
+	AngleVectors( angles, &forward, NULL, NULL );
+
+	float	flBob = CalcViewmodelBob();
+
+	// Apply bob, but scaled down to 40%
+	VectorMA( origin, flBob * 0.4, forward, origin );
+
+	// Z bob a bit more
+	origin[2] += flBob;
+
+	// throw in a little tilt.
+	angles[ YAW ]	-= flBob * 0.6;
+	angles[ ROLL ]	-= flBob * 0.5;
+	angles[ PITCH ]	-= flBob * 0.4;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: TF specific weapon anim events
+//-----------------------------------------------------------------------------
+bool CBaseTFCombatWeapon::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
+{
+	switch( event )
+	{
+	case CL_EVENT_MUZZLEFLASH0:
+	case CL_EVENT_MUZZLEFLASH1:
+	case CL_EVENT_MUZZLEFLASH2:
+	case CL_EVENT_MUZZLEFLASH3:
+		{
+			int iAttachment = -1;
+			Vector attachOrigin;
+			QAngle attachAngles; 
+
+			// First person muzzle flashes
+			switch (event) 
+			{
+			case CL_EVENT_MUZZLEFLASH0:
+				iAttachment = 0;
+				break;
+
+			case CL_EVENT_MUZZLEFLASH1:
+				iAttachment = 1;
+				break;
+
+			case CL_EVENT_MUZZLEFLASH2:
+				iAttachment = 2;
+				break;
+
+			case CL_EVENT_MUZZLEFLASH3:
+				iAttachment = 3;
+				break;
+			}
+
+			// Did we find it?
+			if ( pViewModel->GetAttachment( iAttachment+1, attachOrigin, attachAngles ) )
+			{
+				//int iType = atoi( options );
+
+				// Is our owner boosted?
+				CBasePlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+				if ( pPlayer && pPlayer->HasPowerup(POWERUP_BOOST) )
+				{
+					unsigned char color[3];
+					color[0] = 50;
+					color[1] = 255;
+					color[2] = 50;
+					FX_MuzzleEffect( attachOrigin, attachAngles, 1.0, GetRefEHandle(), &color[0] );
+				}
+				else
+				{
+					FX_MuzzleEffect( attachOrigin, attachAngles, 1.0, GetRefEHandle() );
+				}
+
+				return true;
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	return false;
+}
+
+//============================================================================================================
+// OWNER BOOSTED PROXY FOR WEAPONS / PLAYERS
+//============================================================================================================
+class CPlayerBoostedProxy : public CResultProxy
+{
+public:
+	bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	void OnBind( void *pC_BaseEntity );
+
+private:
+	CFloatInput	m_Factor;
+};
+
+bool CPlayerBoostedProxy::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 CPlayerBoostedProxy::OnBind( void *pRenderable )
+{
+	// Find the view angle between the player and this entity....
+	IClientRenderable *pRend = (IClientRenderable *)pRenderable;
+	C_BaseEntity *pEntity = pRend->GetIClientUnknown()->GetBaseEntity();
+	CBaseTFPlayer *pPlayer = NULL;
+	C_BaseViewModel *pViewModel = dynamic_cast<C_BaseViewModel*>(pEntity);
+	if ( pViewModel )
+	{
+		pPlayer = C_BaseTFPlayer::GetLocalPlayer();
+	}
+	else
+	{
+		CBaseTFCombatWeapon *pWeapon = dynamic_cast<CBaseTFCombatWeapon*>(pEntity);
+		if ( pWeapon )
+		{
+			pPlayer = ToBaseTFPlayer( pWeapon->GetOwner() );
+		}
+		else 
+		{
+			pPlayer = dynamic_cast<CBaseTFPlayer*>(pEntity);
+		}
+	}
+
+	// Find him?
+	if ( pPlayer )
+	{
+		float flBoosted = (int)pPlayer->HasPowerup( POWERUP_BOOST );
+		SetFloatResult( flBoosted * m_Factor.GetFloat() );
+	}
+}
+
+EXPOSE_INTERFACE( CPlayerBoostedProxy, IMaterialProxy, "PlayerBoosted" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+#else
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CBaseTFCombatWeapon::CalcViewmodelBob( void )
+{
+	return 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+void CBaseTFCombatWeapon::AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles )
+{
+}
+
+#endif
+
+LINK_ENTITY_TO_CLASS( basetfcombatweapon, CBaseTFCombatWeapon );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseTFCombatWeapon , DT_BaseTFCombatWeapon )
+
+BEGIN_NETWORK_TABLE( CBaseTFCombatWeapon , DT_BaseTFCombatWeapon )
+#if !defined( CLIENT_DLL )
+
+	 // Don't network any animation stuff to client
+ 	SendPropExclude( "DT_AnimTimeMustBeFirst", "m_flAnimTime" ),
+ 	SendPropExclude( "DT_BaseAnimating", "m_flCycle" ),
+
+	SendPropInt( SENDINFO( m_bReflectViewModelAnimations ), 1, SPROP_UNSIGNED ),
+#else
+	RecvPropInt( RECVINFO( m_bReflectViewModelAnimations ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CBaseTFCombatWeapon )
+
+	// If true, reflect and weapon animations to all view models
+	DEFINE_PRED_FIELD( m_bReflectViewModelAnimations, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_FIELD( m_iLastReflectedActivity, FIELD_INTEGER )
+
+END_PREDICTION_DATA()
diff --git a/game/shared/tf2/basetfcombatweapon_shared.h b/game/shared/tf2/basetfcombatweapon_shared.h
new file mode 100644
index 0000000..4c16acf
--- /dev/null
+++ b/game/shared/tf2/basetfcombatweapon_shared.h
@@ -0,0 +1,152 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef BASETFCOMBATWEAPON_SHARED_H
+#define BASETFCOMBATWEAPON_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "baseplayer_shared.h"
+#include "basetfplayer_shared.h"
+#include "basecombatweapon_shared.h"
+
+#if defined( CLIENT_DLL )
+#define CBaseTFCombatWeapon C_BaseTFCombatWeapon
+#endif
+//-----------------------------------------------------------------------------
+// Purpose: Client side rep of CBaseTFCombatWeapon 
+//-----------------------------------------------------------------------------
+class CBaseTFCombatWeapon : public CBaseCombatWeapon
+{
+	DECLARE_CLASS( CBaseTFCombatWeapon, CBaseCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CBaseTFCombatWeapon ();
+
+	virtual void	Precache( void );
+
+	bool			IsCamouflaged( void );
+
+	virtual Vector	GetTracerSrc( Vector &vecSrc, Vector &vecFireDir );
+
+	// Check if the owner is being EMP'd and if we can't fire, play an appropriate
+	//  failure sound
+	// Default is to allow firing no matter what
+	virtual bool	ComputeEMPFireState( void ) { return true; }
+
+	virtual void	CheckRemoveDisguise( void );
+
+	virtual int		GetImpactScale( void ) { return 1; };
+
+	// FIXME: why are these virtual?
+	virtual float	SequenceDuration( int iSequence );
+	virtual float	SequenceDuration( void ) { return SequenceDuration( GetSequence() ); }
+
+	virtual void	WeaponSound( WeaponSound_t sound_type, float soundtime = 0.0f );
+
+	virtual void	PlayAttackAnimation( int activity ); 
+
+	virtual bool	SendWeaponAnim( int iActivity );
+	virtual void	SetReflectViewModelAnimations( bool reflect );
+	virtual bool	IsReflectingAnimations( void ) const;
+	virtual int		GetLastReflectedActivity( void ) { return m_iLastReflectedActivity; };
+	virtual int		GetOtherWeaponsActivity( int iActivity ) { return iActivity; }
+	virtual int		ReplaceOtherWeaponsActivity( int iActivity ) { return iActivity; }
+	virtual bool	SupportsTwoHanded( void ) { return false; };
+
+	virtual void	CleanupOnActStart( void ) { return; }
+
+	bool			IsOwnerEMPed();
+
+	virtual void	BulletWasFired( const Vector &vecStart, const Vector &vecEnd ) { return; };
+
+	// Technology handling
+	virtual void	GainedNewTechnology( CBaseTechnology *pTechnology ) { return; };
+
+	/*
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+	*/
+
+	virtual int		GetPrimaryAmmo( void );
+
+	virtual void	AddViewmodelBob( CBaseViewModel *viewmodel, Vector &origin, QAngle &angles );
+	virtual float	CalcViewmodelBob( void );
+
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() &&
+			GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	// Camo
+	virtual int		GetFxBlend( void );
+	virtual bool	IsTransparent( void );
+
+	virtual int		GetSecondaryAmmo( void );
+	virtual int		DrawModel( int flags );
+	virtual void	DrawAmmo( void );
+	virtual void	DrawMiniAmmo( void );
+	virtual bool	ShouldDrawPickup( void );
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+
+	virtual const char *GetPrintName( void );
+	virtual bool		ShouldShowUsageHint( void );
+
+	static void			CreateCrosshairPanels( void );
+	static void			DestroyCrosshairPanels( void );
+
+	virtual bool	OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+
+protected:
+ 	static vgui::Label	*m_pCrosshairAmmo;
+
+private:
+	// Share crosshair stuff among all weapons
+	static bool			m_bCrosshairInitialized;
+	// Create/destroy shared crosshair object
+	static void			InitializeCrosshairPanels( void );
+
+private:
+	CBaseTFCombatWeapon ( const CBaseTFCombatWeapon  & );
+
+#else
+	virtual void	AddAssociatedObject( CBaseObject *pObject ) { }
+	virtual void	RemoveAssociatedObject( CBaseObject *pObject ) { }
+protected:
+
+	// CVars that contain my damage details
+	const ConVar	*m_pDamageCVar;
+	const ConVar	*m_pRangeCVar;
+
+#endif
+
+protected:
+	// If true, reflect and weapon animations to all view models
+	CNetworkVar( bool, m_bReflectViewModelAnimations );
+	int				m_iLastReflectedActivity;
+
+	float			bobtime;
+	float			bob;
+};
+
+#endif // BASETFCOMBATWEAPON_SHARED_H
+
+
+
diff --git a/game/shared/tf2/basetfplayer_shared.cpp b/game/shared/tf2/basetfplayer_shared.cpp
new file mode 100644
index 0000000..0634411
--- /dev/null
+++ b/game/shared/tf2/basetfplayer_shared.cpp
@@ -0,0 +1,825 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: TF2's player object, code shared between client & server.
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combatshield.h"
+#include "weapon_objectselection.h"
+#include "weapon_twohandedcontainer.h"
+#ifdef CLIENT_DLL
+#include "c_weapon_builder.h"
+#else
+#include "weapon_builder.h"
+#include "basegrenade_shared.h"
+#include "grenade_objectsapper.h"
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseTFPlayer::IsClass( TFClass iClass )
+{
+	if ( !GetPlayerClass()  )
+	{
+		// Special case for undecided players
+		if ( iClass == TFCLASS_UNDECIDED )
+			return true;
+		return false;
+	}
+
+	return ( PlayerClass() == iClass );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponCombatShield *CBaseTFPlayer::GetCombatShield( void )
+{
+	if ( !m_hWeaponCombatShield )
+	{
+		if ( GetTeamNumber() == TEAM_ALIENS )
+		{
+			m_hWeaponCombatShield = static_cast< CWeaponCombatShield * >( Weapon_OwnsThisType( "weapon_combat_shield_alien" ) );
+#ifndef CLIENT_DLL
+			if ( !m_hWeaponCombatShield )
+			{
+				m_hWeaponCombatShield = static_cast< CWeaponCombatShield * >( GiveNamedItem( "weapon_combat_shield_alien" ) );
+			}
+#endif
+		}
+		else
+		{
+			m_hWeaponCombatShield = static_cast< CWeaponCombatShield * >( Weapon_OwnsThisType( "weapon_combat_shield" ) );
+#ifndef CLIENT_DLL
+			if ( !m_hWeaponCombatShield )
+			{
+				m_hWeaponCombatShield = static_cast< CWeaponCombatShield * >( GiveNamedItem( "weapon_combat_shield" ) );
+			}
+#endif
+		}
+	}
+
+	return m_hWeaponCombatShield;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check to see if the shot is blocked by the player's handheld shield
+//-----------------------------------------------------------------------------
+bool CBaseTFPlayer::IsHittingShield( const Vector &vecVelocity, float *flDamage )
+{
+	if (!IsParrying() && !IsBlocking())
+		return false;
+
+	Vector2D vecDelta = vecVelocity.AsVector2D();
+	Vector2DNormalize( vecDelta );
+
+	Vector forward;
+	AngleVectors( GetLocalAngles(), &forward );
+
+	Vector2DNormalize( forward.AsVector2D() );
+
+	float flDot = DotProduct2D( vecDelta, forward.AsVector2D() );
+
+	// This gives us a little more than a 90 degree protection angle
+	if (flDot < -0.67f)
+	{
+		// We've hit the players handheld shield, see if the shield can do anything about it
+		if ( flDamage && GetCombatShield() )
+		{
+			// Return true if the shield blocked it all
+			*flDamage = GetCombatShield()->AttemptToBlock( *flDamage );
+			return ( !(*flDamage) );
+		}
+		
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Play a sound to show we've been hurt
+//-----------------------------------------------------------------------------
+void CBaseTFPlayer::PainSound( void )
+{
+	char *sSoundName = NULL;
+
+	if ( GetTeamNumber() == TEAM_HUMANS )
+	{
+		sSoundName = "Humans.Pain";
+	}
+	else if ( GetTeamNumber() == TEAM_ALIENS )
+	{
+		switch( PlayerClass() )
+		{
+		case TFCLASS_COMMANDO:
+			sSoundName = "AlienCommando.Pain";
+			break;
+
+		case TFCLASS_MEDIC:
+			sSoundName = "AlienMedic.Pain";
+			break;
+
+		case TFCLASS_DEFENDER:
+			sSoundName = "AlienDefender.Pain";
+			break;
+
+		case TFCLASS_ESCORT:
+			sSoundName = "AlienEscort.Pain";
+			break;
+
+		default:
+			break;
+		}
+	}
+
+	if ( !sSoundName )
+		return;
+
+	CPASAttenuationFilter filter( this, sSoundName );
+	EmitSound( filter, entindex(), sSoundName );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if we should record our last weapon when switching between the two specified weapons
+//-----------------------------------------------------------------------------
+bool CBaseTFPlayer::Weapon_ShouldSetLast( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon )
+{
+	// Don't record last weapons when switching to an object
+	if ( dynamic_cast< CWeaponObjectSelection* >( pNewWeapon ) )
+	{
+		// Store this weapon off so we can switch back to it
+		// Don't store it if it's also an object
+		CBaseCombatWeapon *pLast = pOldWeapon->GetLastWeapon();
+#ifdef CLIENT_DLL
+		if ( !dynamic_cast< C_WeaponBuilder* >( pLast ) )
+#else
+		if ( !dynamic_cast< CWeaponBuilder* >( pLast ) )
+#endif
+		{
+			m_hLastWeaponBeforeObject = pLast;
+		}
+		return false;
+	}
+
+	// Don't record last weapons when switching from the builder
+	// If the old weapon is a twohanded container, check the left weapon
+	CWeaponTwoHandedContainer *pContainer = dynamic_cast< CWeaponTwoHandedContainer * >( pOldWeapon );
+	if ( pContainer )
+	{
+		pOldWeapon = dynamic_cast< CBaseTFCombatWeapon  * >( pContainer->GetLeftWeapon() );
+	}
+#ifdef CLIENT_DLL
+	if ( dynamic_cast< C_WeaponBuilder* >( pOldWeapon ) )
+		return false;
+#else
+	if ( dynamic_cast< CWeaponBuilder* >( pOldWeapon ) )
+		return false;
+#endif
+
+	return BaseClass::Weapon_ShouldSetLast( pOldWeapon, pNewWeapon );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if we should allow selection of the specified item
+//-----------------------------------------------------------------------------
+bool CBaseTFPlayer::Weapon_ShouldSelectItem( CBaseCombatWeapon *pWeapon )
+{
+	CBaseCombatWeapon *pActiveWeapon = GetActiveWeapon();
+	// If the old weapon is a twohanded container, check the left weapon
+	CWeaponTwoHandedContainer *pContainer = dynamic_cast< CWeaponTwoHandedContainer * >( pActiveWeapon );
+	if ( pContainer )
+	{
+		pActiveWeapon = pContainer->GetLeftWeapon();
+	}
+
+	return ( pWeapon != pActiveWeapon );
+}
+
+#ifndef CLIENT_DLL
+// Sapper handling is all here because it'll soon be shared Client / Server
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseTFPlayer::IsAttachingSapper( void )
+{
+	return ( m_TFLocal.m_bAttachingSapper );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CBaseTFPlayer::GetSapperAttachmentTime( void )
+{
+	return (gpGlobals->curtime - m_flSapperAttachmentStartTime);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFPlayer::StartAttachingSapper( CBaseObject *pObject, CGrenadeObjectSapper *pSapper )
+{
+	Assert( pSapper );
+
+	m_TFLocal.m_bAttachingSapper = true;
+	m_TFLocal.m_flSapperAttachmentFrac = 0.0f;
+
+	m_hSappedObject = pObject;
+	m_flSapperAttachmentStartTime = gpGlobals->curtime;
+	m_flSapperAttachmentFinishTime = gpGlobals->curtime + m_hSappedObject->GetSapperAttachTime();
+	m_hSapper = pSapper;
+	m_hSapper->SetArmed( false );
+
+	CPASAttenuationFilter filter( m_hSapper, "WeaponObjectSapper.Attach" );
+	EmitSound( filter, m_hSapper->entindex(), "WeaponObjectSapper.Attach" );
+
+	// Drop the player's weapon
+	if ( GetActiveWeapon() )
+	{
+		GetActiveWeapon()->Holster();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFPlayer::CheckSapperAttaching( void )
+{
+	// Did we stop attaching?
+	if ( !m_TFLocal.m_bAttachingSapper )
+	{
+		if ( m_TFLocal.m_flSapperAttachmentFrac )
+		{
+			StopAttaching();
+		}
+		return;
+	}
+
+	// Object gone?
+	if ( m_hSappedObject == NULL )
+	{
+		StopAttaching();
+		return;
+	}
+
+	// Sapper gone?
+	if ( m_hSapper == NULL )
+	{
+		StopAttaching();
+		return;
+	}
+
+	// Make sure I'm still looking at the target
+	trace_t tr;
+	Vector vecAiming;
+	Vector vecSrc = EyePosition();
+	EyeVectors( &vecAiming );
+	UTIL_TraceLine( vecSrc, vecSrc + (vecAiming * 128), MASK_SOLID, this, TFCOLLISION_GROUP_WEAPON, &tr );
+	if ( tr.fraction == 1.0 || tr.m_pEnt != m_hSappedObject )
+	{
+		StopAttaching();
+		return;
+	}
+
+	// Finished?
+	if ( m_flSapperAttachmentFinishTime >= gpGlobals->curtime )
+	{
+		float dt = m_flSapperAttachmentFinishTime - m_flSapperAttachmentStartTime;
+		if ( dt > 0.0f )
+		{
+			m_TFLocal.m_flSapperAttachmentFrac = ( gpGlobals->curtime - m_flSapperAttachmentStartTime ) / dt;
+			m_TFLocal.m_flSapperAttachmentFrac = clamp( m_TFLocal.m_flSapperAttachmentFrac, 0.0f, 1.0f );
+		}
+		else
+		{
+			m_TFLocal.m_flSapperAttachmentFrac = 0.0f;
+		}
+		return;
+	}
+
+	FinishAttaching();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFPlayer::CleanupAfterAttaching( void )
+{
+	Assert( m_TFLocal.m_bAttachingSapper );
+	m_TFLocal.m_bAttachingSapper = false;
+
+	m_flSapperAttachmentFinishTime = -1;
+	m_flSapperAttachmentStartTime = -1;
+	m_TFLocal.m_flSapperAttachmentFrac = 0.0f;
+
+	// Restore the player's weapon
+	m_flNextAttack = gpGlobals->curtime;
+	if ( GetActiveWeapon() )
+	{
+		GetActiveWeapon()->Deploy();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFPlayer::StopAttaching( void )
+{
+	CleanupAfterAttaching();	
+
+	if ( m_hSapper != NULL )
+	{
+		CPASAttenuationFilter filter( m_hSapper, "WeaponObjectSapper.AttachFail" );
+		EmitSound( filter, m_hSapper->entindex(), "WeaponObjectSapper.AttachFail" );
+
+		m_hSapper->SetTargetObject( NULL );
+		m_hSapper->Remove( );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFPlayer::FinishAttaching( void )
+{
+	CleanupAfterAttaching();
+
+	if ( m_hSapper != NULL )
+	{
+		m_hSapper->SetTargetObject( m_hSappedObject );
+		m_hSapper->SetArmed( true );
+	}
+}
+#endif
+
+// Below this many degrees, slow down turning rate linearly
+#define FADE_TURN_DEGREES	45.0f
+// After this, need to start turning feet
+#define MAX_TORSO_ANGLE		90.0f
+// Below this amount, don't play a turning animation/perform IK
+#define MIN_TURN_ANGLE_REQUIRING_TURN_ANIMATION		15.0f
+
+static ConVar tf2_feetyawrunscale( "tf2_feetyawrunscale", "2", FCVAR_REPLICATED, "Multiplier on tf2_feetyawrate to allow turning faster when running." );
+extern ConVar sv_backspeed;
+extern ConVar mp_feetyawrate;
+extern ConVar mp_facefronttime;
+extern ConVar mp_ik;
+
+CPlayerAnimState::CPlayerAnimState( CBaseTFPlayer *outer )
+	: m_pOuter( outer )
+{
+	m_flGaitYaw = 0.0f;
+	m_flGoalFeetYaw = 0.0f;
+	m_flCurrentFeetYaw = 0.0f;
+	m_flCurrentTorsoYaw = 0.0f;
+	m_flLastYaw = 0.0f;
+	m_flLastTurnTime = 0.0f;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPlayerAnimState::Update()
+{
+	m_angRender = GetOuter()->GetLocalAngles();
+
+	ComputePoseParam_BodyYaw();
+	ComputePoseParam_BodyPitch( GetOuter()->GetModelPtr() );
+	ComputePoseParam_BodyLookYaw();
+
+	ComputePlaybackRate();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPlayerAnimState::ComputePlaybackRate()
+{
+	// Determine ideal playback rate
+	Vector vel;
+	GetOuterAbsVelocity( vel );
+
+	float speed = vel.Length2D();
+
+	bool isMoving = ( speed > 0.5f ) ? true : false;
+
+	Activity currentActivity = 	GetOuter()->GetSequenceActivity( GetOuter()->GetSequence() );
+
+	switch ( currentActivity )
+	{
+	case ACT_WALK:
+	case ACT_RUN:
+	case ACT_IDLE:
+		{
+			float maxspeed = GetOuter()->MaxSpeed();
+			if ( isMoving && ( maxspeed > 0.0f ) )
+			{
+				float flFactor = 1.0f;
+
+				// HACK HACK:: Defender backward animation is animated at 0.6 times speed, so scale up animation for this class
+				//  if he's running backward.
+
+				// Not sure if we're really going to do all classes this way.
+				if ( GetOuter()->IsClass( TFCLASS_DEFENDER ) ||
+					 GetOuter()->IsClass( TFCLASS_MEDIC ) )
+				{
+					Vector facing;
+					Vector moving;
+
+					moving = vel;
+					AngleVectors( GetOuter()->GetLocalAngles(), &facing );
+					VectorNormalize( moving );
+
+					float dot = moving.Dot( facing );
+					if ( dot < 0.0f )
+					{
+						float backspeed = sv_backspeed.GetFloat();
+						flFactor = 1.0f - fabs( dot ) * (1.0f - backspeed);
+
+						if ( flFactor > 0.0f )
+						{
+							flFactor = 1.0f / flFactor;
+						}
+					}
+				}
+
+				// Note this gets set back to 1.0 if sequence changes due to ResetSequenceInfo below
+				GetOuter()->SetPlaybackRate( ( speed * flFactor ) / maxspeed );
+
+				// BUG BUG:
+				// This stuff really should be m_flPlaybackRate = speed / m_flGroundSpeed
+			}
+			else
+			{
+				GetOuter()->SetPlaybackRate( 1.0f );
+			}
+		}
+		break;
+	default:
+		{
+			GetOuter()->SetPlaybackRate( 1.0f );
+		}
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CBasePlayer
+//-----------------------------------------------------------------------------
+CBaseTFPlayer *CPlayerAnimState::GetOuter()
+{
+	return m_pOuter;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : dt - 
+//-----------------------------------------------------------------------------
+void CPlayerAnimState::EstimateYaw( void )
+{
+	float dt = gpGlobals->frametime;
+
+	if ( !dt )
+	{
+		return;
+	}
+
+	Vector est_velocity;
+	QAngle	angles;
+
+	GetOuterAbsVelocity( est_velocity );
+
+	angles = GetOuter()->GetLocalAngles();
+
+	if ( est_velocity[1] == 0 && est_velocity[0] == 0 )
+	{
+		float flYawDiff = angles[YAW] - m_flGaitYaw;
+		flYawDiff = flYawDiff - (int)(flYawDiff / 360) * 360;
+		if (flYawDiff > 180)
+			flYawDiff -= 360;
+		if (flYawDiff < -180)
+			flYawDiff += 360;
+
+		if (dt < 0.25)
+			flYawDiff *= dt * 4;
+		else
+			flYawDiff *= dt;
+
+		m_flGaitYaw += flYawDiff;
+		m_flGaitYaw = m_flGaitYaw - (int)(m_flGaitYaw / 360) * 360;
+	}
+	else
+	{
+		m_flGaitYaw = (atan2(est_velocity[1], est_velocity[0]) * 180 / M_PI);
+
+		if (m_flGaitYaw > 180)
+			m_flGaitYaw = 180;
+		else if (m_flGaitYaw < -180)
+			m_flGaitYaw = -180;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Override for backpeddling
+// Input  : dt - 
+//-----------------------------------------------------------------------------
+void CPlayerAnimState::ComputePoseParam_BodyYaw( void )
+{
+	int iYaw = GetOuter()->LookupPoseParameter( "move_yaw" );
+	if ( iYaw < 0 )
+		return;
+
+	// view direction relative to movement
+	float flYaw;	 
+
+	EstimateYaw();
+
+	QAngle	angles = GetOuter()->GetLocalAngles();
+	float ang = angles[ YAW ];
+	if ( ang > 180.0f )
+	{
+		ang -= 360.0f;
+	}
+	else if ( ang < -180.0f )
+	{
+		ang += 360.0f;
+	}
+
+	// calc side to side turning
+	flYaw = ang - m_flGaitYaw;
+	// Invert for mapping into 8way blend
+	flYaw = -flYaw;
+	flYaw = flYaw - (int)(flYaw / 360) * 360;
+
+	if (flYaw < -180)
+	{
+		flYaw = flYaw + 360;
+	}
+	else if (flYaw > 180)
+	{
+		flYaw = flYaw - 360;
+	}
+	
+	GetOuter()->SetPoseParameter( iYaw, flYaw );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CPlayerAnimState::ComputePoseParam_BodyPitch( CStudioHdr *pStudioHdr )
+{
+	// Get pitch from v_angle
+	float flPitch = GetOuter()->GetLocalAngles()[ PITCH ];
+	if ( flPitch > 180.0f )
+	{
+		flPitch -= 360.0f;
+	}
+	flPitch = clamp( flPitch, -90, 90 );
+
+	QAngle absangles = GetOuter()->GetAbsAngles();
+	absangles.x = 0.0f;
+	m_angRender = absangles;
+
+	// See if we have a blender for pitch
+	int pitch = GetOuter()->LookupPoseParameter( pStudioHdr, "body_pitch" );
+	if ( pitch < 0 )
+		return;
+
+	GetOuter()->SetPoseParameter( pStudioHdr, pitch, flPitch );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : goal - 
+//			maxrate - 
+//			dt - 
+//			current - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CPlayerAnimState::ConvergeAngles( float goal,float maxrate, float dt, float& current )
+{
+	int direction = TURN_NONE;
+
+	float anglediff = goal - current;
+	float anglediffabs = fabs( anglediff );
+
+	anglediff = AngleNormalize( anglediff );
+
+	float scale = 1.0f;
+	if ( anglediffabs <= FADE_TURN_DEGREES )
+	{
+		scale = anglediffabs / FADE_TURN_DEGREES;
+		// Always do at least a bit of the turn ( 1% )
+		scale = clamp( scale, 0.01f, 1.0f );
+	}
+
+	float maxmove = maxrate * dt * scale;
+
+	if ( fabs( anglediff ) < maxmove )
+	{
+		current = goal;
+	}
+	else
+	{
+		if ( anglediff > 0 )
+		{
+			current += maxmove;
+			direction = TURN_LEFT;
+		}
+		else
+		{
+			current -= maxmove;
+			direction = TURN_RIGHT;
+		}
+	}
+
+	current = AngleNormalize( current );
+
+	return direction;
+}
+
+void CPlayerAnimState::ComputePoseParam_BodyLookYaw( void )
+{
+	QAngle absangles = GetOuter()->GetAbsAngles();
+	absangles.y = AngleNormalize( absangles.y );
+	m_angRender = absangles;
+
+	// See if we even have a blender for pitch
+	int upper_body_yaw = GetOuter()->LookupPoseParameter( "body_yaw" );
+	if ( upper_body_yaw < 0 )
+	{
+		return;
+	}
+
+	// Assume upper and lower bodies are aligned and that we're not turning
+	float flGoalTorsoYaw = 0.0f;
+	int turning = TURN_NONE;
+	float turnrate = mp_feetyawrate.GetFloat();
+
+	Vector vel;
+	
+	GetOuterAbsVelocity( vel );
+
+	bool isMoving = ( vel.Length() > 0.0f ) ? true : false;
+
+	if ( !isMoving )
+	{
+		// Just stopped moving, try and clamp feet
+		if ( m_flLastTurnTime <= 0.0f )
+		{
+			m_flLastTurnTime	= gpGlobals->curtime;
+			m_flLastYaw			= GetOuter()->GetAbsAngles().y;
+			// Snap feet to be perfectly aligned with torso/eyes
+			m_flGoalFeetYaw		= GetOuter()->GetAbsAngles().y;
+			m_flCurrentFeetYaw	= m_flGoalFeetYaw;
+			m_nTurningInPlace	= TURN_NONE;
+		}
+
+		// If rotating in place, update stasis timer
+		if ( m_flLastYaw != GetOuter()->GetAbsAngles().y )
+		{
+			m_flLastTurnTime	= gpGlobals->curtime;
+			m_flLastYaw			= GetOuter()->GetAbsAngles().y;
+		}
+
+		if ( m_flGoalFeetYaw != m_flCurrentFeetYaw )
+		{
+			m_flLastTurnTime	= gpGlobals->curtime;
+		}
+
+		turning = ConvergeAngles( m_flGoalFeetYaw, turnrate, gpGlobals->frametime, m_flCurrentFeetYaw );
+
+		// See how far off current feetyaw is from true yaw
+		float yawdelta = GetOuter()->GetAbsAngles().y - m_flCurrentFeetYaw;
+		yawdelta = AngleNormalize( yawdelta );
+
+		bool rotated_too_far = false;
+
+		float yawmagnitude = fabs( yawdelta );
+		// If too far, then need to turn in place
+		if ( yawmagnitude > MAX_TORSO_ANGLE )
+		{
+			rotated_too_far = true;
+		}
+
+		// Standing still for a while, rotate feet around to face forward
+		// Or rotated too far
+		// FIXME:  Play an in place turning animation
+		if ( rotated_too_far || 
+			( gpGlobals->curtime > m_flLastTurnTime + mp_facefronttime.GetFloat() ) )
+		{
+			m_flGoalFeetYaw		= GetOuter()->GetAbsAngles().y;
+			m_flLastTurnTime	= gpGlobals->curtime;
+
+			float yd = m_flCurrentFeetYaw - m_flGoalFeetYaw;
+			if ( yd > 0 )
+			{
+				m_nTurningInPlace = TURN_RIGHT;
+			}
+			else if ( yd < 0 )
+			{
+				m_nTurningInPlace = TURN_LEFT;
+			}
+			else
+			{
+				m_nTurningInPlace = TURN_NONE;
+			}
+
+			turning = ConvergeAngles( m_flGoalFeetYaw, turnrate, gpGlobals->frametime, m_flCurrentFeetYaw );
+			yawdelta = GetOuter()->GetAbsAngles().y - m_flCurrentFeetYaw;
+		}
+
+		// Snap upper body into position since the delta is already smoothed for the feet
+		flGoalTorsoYaw = yawdelta;
+		m_flCurrentTorsoYaw = flGoalTorsoYaw;
+	}
+	else
+	{
+		m_flLastTurnTime = 0.0f;
+		m_nTurningInPlace = TURN_NONE;
+		m_flGoalFeetYaw = GetOuter()->GetAbsAngles().y;
+		flGoalTorsoYaw = 0.0f;
+		turning = ConvergeAngles( m_flGoalFeetYaw, turnrate, gpGlobals->frametime, m_flCurrentFeetYaw );
+		m_flCurrentTorsoYaw = GetOuter()->GetAbsAngles().y - m_flCurrentFeetYaw;
+	}
+
+
+	if ( turning == TURN_NONE )
+	{
+		m_nTurningInPlace = turning;
+	}
+
+	if ( m_nTurningInPlace != TURN_NONE )
+	{
+		// If we're close to finishing the turn, then turn off the turning animation
+		if ( fabs( m_flCurrentFeetYaw - m_flGoalFeetYaw ) < MIN_TURN_ANGLE_REQUIRING_TURN_ANIMATION )
+		{
+			m_nTurningInPlace = TURN_NONE;
+		}
+	}
+
+	// Counter rotate upper body as needed
+	ConvergeAngles( flGoalTorsoYaw, turnrate, gpGlobals->frametime, m_flCurrentTorsoYaw );
+
+	// Rotate entire body into position
+	absangles = GetOuter()->GetAbsAngles();
+	absangles.y = m_flCurrentFeetYaw;
+	m_angRender = absangles;
+
+	GetOuter()->SetPoseParameter( upper_body_yaw, clamp( m_flCurrentTorsoYaw, -90.0f, 90.0f ) );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : activity - 
+// Output : Activity
+//-----------------------------------------------------------------------------
+Activity CPlayerAnimState::BodyYawTranslateActivity( Activity activity )
+{
+	// Not even standing still, sigh
+	if ( activity != ACT_IDLE )
+		return activity;
+
+	// Not turning
+	switch ( m_nTurningInPlace )
+	{
+	default:
+	case TURN_NONE:
+		return activity;
+	/*
+	case TURN_RIGHT:
+		return ACT_TURNRIGHT45;
+	case TURN_LEFT:
+		return ACT_TURNLEFT45;
+	*/
+	case TURN_RIGHT:
+	case TURN_LEFT:
+		return mp_ik.GetBool() ? ACT_TURN : activity;
+	}
+
+	Assert( 0 );
+	return activity;
+}
+
+const QAngle& CPlayerAnimState::GetRenderAngles()
+{
+	return m_angRender;
+}
+
+
+void CPlayerAnimState::GetOuterAbsVelocity( Vector& vel )
+{
+#if defined( CLIENT_DLL )
+	GetOuter()->EstimateAbsVelocity( vel );
+#else
+	vel = GetOuter()->GetAbsVelocity();
+#endif
+}
diff --git a/game/shared/tf2/basetfplayer_shared.h b/game/shared/tf2/basetfplayer_shared.h
new file mode 100644
index 0000000..0085f01
--- /dev/null
+++ b/game/shared/tf2/basetfplayer_shared.h
@@ -0,0 +1,22 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef BASETFPLAYER_SHARED_H
+#define BASETFPLAYER_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// Shared header file for players
+#if defined( CLIENT_DLL )
+#define CBaseTFPlayer C_BaseTFPlayer
+#include "c_basetfplayer.h"
+#else
+#include "tf_player.h"
+#endif
+
+#endif // BASETFPLAYER_SHARED_H
diff --git a/game/shared/tf2/basetfvehicle.cpp b/game/shared/tf2/basetfvehicle.cpp
new file mode 100644
index 0000000..1825753
--- /dev/null
+++ b/game/shared/tf2/basetfvehicle.cpp
@@ -0,0 +1,1179 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A base vehicle class
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "basetfvehicle.h"
+#include "tf_movedata.h"
+#include "in_buttons.h"
+#include "baseplayer_shared.h"
+
+#if defined( CLIENT_DLL )
+	#include "hud_vehicle_role.h"
+	#include "hud.h"
+	#include "hud_crosshair.h"
+#else
+	#include "tf_team.h"
+	#include "tf_gamerules.h"
+	#include "tf_func_construction_yard.h"
+	#include "ndebugoverlay.h"
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseTFVehicle, DT_BaseTFVehicle );
+
+BEGIN_NETWORK_TABLE( CBaseTFVehicle, DT_BaseTFVehicle )
+#if !defined( CLIENT_DLL )
+	SendPropInt( SENDINFO(m_nMaxPassengers), CBaseTFVehicle::MAX_PASSENGER_BITS, SPROP_UNSIGNED ),
+	SendPropArray( SendPropEHandle(SENDINFO_ARRAY(m_hPassengers)), m_hPassengers ),
+	SendPropEHandle( SENDINFO(m_hDriverGun) ),
+#else
+	RecvPropInt( RECVINFO(m_nMaxPassengers) ),
+	RecvPropArray( RecvPropEHandle(RECVINFO(m_hPassengers[0])), m_hPassengers ),
+	RecvPropEHandle( RECVINFO(m_hDriverGun) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CBaseTFVehicle )
+
+	DEFINE_PRED_ARRAY( m_hPassengers, FIELD_EHANDLE, CBaseTFVehicle::MAX_PASSENGERS, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+extern float RemapAngleRange( float startInterval, float endInterval, float value );
+extern ConVar road_feel;
+
+ConVar vehicle_view_offset_forward( "vehicle_view_offset_forward", "-280", FCVAR_REPLICATED );
+ConVar vehicle_view_offset_right( "vehicle_view_offset_right", "0", FCVAR_REPLICATED );
+ConVar vehicle_view_offset_up( "vehicle_view_offset_up", "50", FCVAR_REPLICATED );
+ConVar vehicle_thirdperson( "vehicle_thirdperson", "1", FCVAR_REPLICATED, "Enable/disable thirdperson camera view in vehicles" );
+
+ConVar vehicle_attach_eye_angles( "vehicle_attach_eye_angles", "0", FCVAR_REPLICATED, "Attach player eye angles to vehicle attachments" );
+
+#define PITCH_CURVE_ZERO		10	// pitch less than this is clamped to zero
+#define PITCH_CURVE_LINEAR		45	// pitch greater than this is copied out
+
+#define ROLL_CURVE_ZERO		5		// roll less than this is clamped to zero
+#define ROLL_CURVE_LINEAR	45		// roll greater than this is copied out
+
+#if defined( CLIENT_DLL )
+	ConVar road_feel( "road_feel", "0.1", FCVAR_NOTIFY | FCVAR_REPLICATED );
+#else
+	// Deterioration
+	#define DETERIORATION_THINK_CONTEXT			"VehicleDeteriorationThink"
+	#define PASSENGER_THINK_CONTEXT				"VehiclePassengerThink"
+	ConVar  vehicle_deterioration_start_time( "vehicle_deterioration_start_time", "90", 0, "Time it takes for a vehicle to start deteriorating after being left alone." );
+
+	#define DETERIORATION_DISTANCE				(600 * 600)		// Never deteriorate if team mates are within this distance
+
+#endif // CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseTFVehicle::CBaseTFVehicle()
+{
+	SetPredictionEligible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::Spawn()
+{
+	BaseClass::Spawn();
+	CollisionProp()->SetSurroundingBoundsType( USE_OBB_COLLISION_BOUNDS );
+
+#if defined( CLIENT_DLL )
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+	m_pIconDefaultCrosshair = NULL;
+#else
+	m_fObjectFlags |= OF_DOESNT_NEED_POWER | OF_MUST_BE_BUILT_ON_ATTACHMENT;
+	SetContextThink( VehiclePassengerThink, 2.0, PASSENGER_THINK_CONTEXT );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Vehicle overrides
+//-----------------------------------------------------------------------------
+CBaseEntity* CBaseTFVehicle::GetVehicleEnt()
+{
+	return this;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
+{
+	// animate + update attachment points
+#ifdef CLIENT_DLL
+	StudioFrameAdvance();
+#else
+	StudioFrameAdvance();
+	// This calls StudioFrameAdvance, then we use the results from that to determine where to move.
+	DispatchAnimEvents( this );
+#endif
+	
+	CTFMoveData *pMoveData = (CTFMoveData*)move; 
+	Assert( sizeof(VehicleBaseMoveData_t) <= pMoveData->VehicleDataMaxSize() );
+
+	VehicleBaseMoveData_t *pVehicleData = (VehicleBaseMoveData_t*)pMoveData->VehicleData();
+	pVehicleData->m_pVehicle = this;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move )
+{
+	VehicleDriverGunThink();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the driver as a tfplayer pointer
+//-----------------------------------------------------------------------------
+CBaseTFPlayer *CBaseTFVehicle::GetDriverPlayer()
+{
+	return m_hPassengers[VEHICLE_DRIVER].Get();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Can we get into the vehicle?
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::CanGetInVehicle( CBaseTFPlayer *pPlayer )
+{
+	if ( !IsPowered() )
+		return false;
+
+	if ( !InSameTeam( pPlayer ) )
+		return false;
+
+	// Player/Class-specific query.
+	return pPlayer->CanGetInVehicle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Here's where we deal with weapons
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::OnItemPostFrame( CBaseTFPlayer *pDriver )
+{
+	// If we have a gun for the driver, handle it
+	if ( m_hDriverGun )
+	{
+		if ( GetPassengerRole(pDriver) != VEHICLE_DRIVER )
+			return;
+
+		if ( pDriver->m_nButtons & (IN_ATTACK | IN_ATTACK2) )
+		{
+			// Time to fire?
+			if ( m_hDriverGun->CanFireNow() )
+			{
+				m_hDriverGun->Fire( pDriver );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseTFVehicle::GetPassengerRole( CBasePlayer *pEnt )
+{
+	Assert( pEnt->IsPlayer() );
+	for ( int i = m_nMaxPassengers; --i >= 0; )
+	{
+		if (m_hPassengers[i] == pEnt)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+Vector CBaseTFVehicle::GetSoundEmissionOrigin() const
+{
+	return WorldSpaceCenter() + Vector( 0, 0, 64 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBasePlayer* CBaseTFVehicle::GetPassenger( int nRole )
+{
+	return m_hPassengers[nRole].Get();
+}
+
+
+//-----------------------------------------------------------------------------
+// Is a particular player in the vehicle?
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::IsPlayerInVehicle( CBaseTFPlayer *pPlayer )
+{
+	return (GetPassengerRole( pPlayer ) >= 0);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseTFVehicle::GetPassengerCount() const
+{
+	// FIXME: Cache this off!
+	int nCount = 0;
+	for (int i = m_nMaxPassengers; --i >= 0; )
+	{
+		if (m_hPassengers[i].Get())
+		{
+			++nCount;
+		}
+	}
+	return nCount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseTFVehicle::GetMaxPassengerCount() const
+{
+	return m_nMaxPassengers;
+}
+
+//-----------------------------------------------------------------------------
+// Process input
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::ItemPostFrame( CBasePlayer *pPassenger )
+{
+#ifndef CLIENT_DLL
+	Assert( GetPassengerRole( pPassenger ) != -1 );
+	if (pPassenger->m_afButtonPressed & (IN_USE /*| IN_JUMP*/)) 
+	{
+		// Get the player out..
+		pPassenger->LeaveVehicle();
+		return;
+	}
+#endif
+
+	OnItemPostFrame( static_cast<CBaseTFPlayer*>(pPassenger) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Reset the time before this vehicle begins to deteriorate
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::ResetDeteriorationTime( void )
+{
+#if !defined (CLIENT_DLL)
+	SetContextThink( VehicleDeteriorationThink, gpGlobals->curtime + vehicle_deterioration_start_time.GetFloat(), DETERIORATION_THINK_CONTEXT );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Prevent driving in construction yards
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::IsReadyToDrive( void )
+{
+#if !defined( CLIENT_DLL )
+	return ( PointInConstructionYard( GetAbsOrigin() ) == false );
+#else
+	return true;
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Process input
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::SetMaxPassengerCount( int nCount )
+{
+#if !defined( CLIENT_DLL )
+	Assert( (nCount >= 1) && (nCount <= MAX_PASSENGERS) );
+	m_nMaxPassengers = nCount;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+//
+// Server-only code here
+//
+//-----------------------------------------------------------------------------
+
+#if !defined (CLIENT_DLL)
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::FinishedBuilding( void )
+{
+	BaseClass::FinishedBuilding();
+
+	// See if we've finished building on a vehicle that has a passenger slot assigned to my buildpoint.
+	CBaseObject	*pParent = GetParentObject();
+	if ( pParent && pParent->IsAVehicle() )
+	{
+		CBaseTFVehicle *pVehicle = static_cast<CBaseTFVehicle*>(pParent);
+		int iRole = pVehicle->GetChildVehicleRole( this );
+		if ( iRole != -1 )
+		{
+			// Is there a player in the role assigned to this buildpoint?
+			CBaseTFPlayer *pExistingPlayer = static_cast<CBaseTFPlayer*>( pVehicle->GetPassenger( iRole ) );
+			if ( pExistingPlayer )
+			{
+				// Remove the player from my parent vehicle and put them in me
+				pExistingPlayer->LeaveVehicle();
+
+				// Get in the vehicle.
+				pExistingPlayer->GetInVehicle( this, VEHICLE_DRIVER );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::VehicleDeteriorationThink( void )
+{
+	StartDeteriorating();
+
+	SetContextThink( NULL, gpGlobals->curtime + vehicle_deterioration_start_time.GetFloat(), DETERIORATION_THINK_CONTEXT );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::VehiclePassengerThink( void )
+{
+	SetNextThink( gpGlobals->curtime + 10.0, PASSENGER_THINK_CONTEXT );
+
+	if ( IsPlacing() )
+	{
+		ResetDeteriorationTime();
+		return;
+	}
+
+	// If there are any passengers in the vehicle, push off deterioration time
+	if ( GetPassengerCount() )
+	{
+		ResetDeteriorationTime();
+		return;
+	}
+
+	// See if there are any team members nearby
+	if ( GetTeam() )
+	{
+		int iNumPlayers = GetTFTeam()->GetNumPlayers();
+		for ( int i = 0; i < iNumPlayers; i++ )
+		{
+			if ( GetTFTeam()->GetPlayer(i) )
+			{
+				Vector vecOrigin = GetTFTeam()->GetPlayer(i)->GetAbsOrigin();
+				if ( (vecOrigin - GetAbsOrigin()).LengthSqr() < DETERIORATION_DISTANCE )
+				{
+					// Found one nearby, reset our deterioration time
+					ResetDeteriorationTime();
+					return;
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Figure out which role of a vehicle a child vehicle is sitting in..
+//-----------------------------------------------------------------------------
+int CBaseTFVehicle::GetChildVehicleRole( CBaseTFVehicle *pChild )
+{
+	int nBuildPoints = GetNumBuildPoints();
+	for( int i = 0; i < nBuildPoints; i++ )
+	{	
+		CBaseObject* pObject = GetBuildPointObject(i);
+		if (pObject == pChild)
+		{
+			return GetBuildPointPassenger(i);
+		}
+	}
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Vehicles are permanently oriented off angle for vphysics.
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::GetVectors(Vector* pForward, Vector* pRight, Vector* pUp) const
+{
+	// This call is necessary to cause m_rgflCoordinateFrame to be recomputed
+	const matrix3x4_t &entityToWorld = EntityToWorldTransform();
+
+	if (pForward != NULL)
+	{
+		MatrixGetColumn( entityToWorld, 1, *pForward ); 
+	}
+
+	if (pRight != NULL)
+	{
+		MatrixGetColumn( entityToWorld, 0, *pRight ); 
+	}
+
+	if (pUp != NULL)
+	{
+		MatrixGetColumn( entityToWorld, 2, *pUp ); 
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get into the vehicle
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	BaseClass::Use( pActivator, pCaller, useType, value );
+
+	if ( useType == USE_ON )
+	{
+		CBaseTFPlayer *pPlayer = dynamic_cast<CBaseTFPlayer*>(pActivator);
+		if ( pPlayer && InSameTeam(pPlayer) )
+		{
+			// Check to see if we are really using nearby build points:
+			if( !UseAttachedItem( pActivator, pCaller, useType, value ) )
+			{
+				// Attempt to board the vehicle:
+				AttemptToBoardVehicle( pPlayer );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Figure out if I should be using an attached item rather than this vehicle itself.
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::UseAttachedItem( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	CBaseTFPlayer* pPlayer = dynamic_cast<CBaseTFPlayer*>(pActivator);
+	if ( !pPlayer || !InSameTeam(pPlayer) )
+		return false;
+
+	Vector vecPlayerOrigin = pPlayer->GetAbsOrigin();
+	int nBestBuildPoint = -1;
+	float fBestDistance = FLT_MAX;
+
+	// Get the closest regular entry point:
+	int nRole = LocateEntryPoint( pPlayer, &fBestDistance );
+
+	// Iterate through each of the build points, if any, and see which we are closest to.
+	int nBuildPoints = GetNumBuildPoints();
+	for( int i = 0; i < nBuildPoints; i++ )
+	{	
+		CBaseObject* pObject = GetBuildPointObject(i);
+
+		// If there's something in the build point that isn't in the process of being built or placed:
+		if( pObject && !pObject->IsPlacing() && !pObject->IsBuilding() ) 
+		{
+			Vector vecOrigin;
+			QAngle vecAngles;
+
+			// If the build point is the default point for this role, just take it 
+			if (GetBuildPointPassenger(i) == nRole)
+			{
+				nBestBuildPoint = i;
+				break;
+			}
+
+			// And I can get the build point.
+			if( GetBuildPoint( i, vecOrigin, vecAngles )  )
+			{
+				float fLength2dSqr = (vecOrigin - vecPlayerOrigin).AsVector2D().LengthSqr();
+				if( fLength2dSqr < fBestDistance )
+				{
+					nBestBuildPoint = i;
+					fBestDistance = fLength2dSqr; 
+				}
+			}
+		}
+	}
+
+	if( nBestBuildPoint >= 0 )
+	{
+		// They're using an item on me, so push out the deterioration time
+		ResetDeteriorationTime();
+		GetBuildPointObject(nBestBuildPoint)->Use( pActivator, pCaller, useType, value );
+		return true;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Object has been removed...
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::DestroyObject( void )
+{
+	for (int i = m_nMaxPassengers; --i >= 0; )
+	{
+		if (m_hPassengers[i])
+		{
+			m_hPassengers[i]->LeaveVehicle();
+		}
+	}
+
+	BaseClass::DestroyObject();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+int CBaseTFVehicle::GetEmptyRole( void )
+{
+	for ( int iPassenger = 0; iPassenger < m_nMaxPassengers; ++iPassenger )
+	{
+		if ( !m_hPassengers[iPassenger].Get() )
+			return iPassenger;
+	}
+
+	return -1;	
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Try to board the vehicle
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::AttemptToBoardVehicle( CBaseTFPlayer *pPlayer )
+{
+	if ( !CanGetInVehicle( pPlayer ) )
+		return;
+
+	// Locate the entry point.
+	int nRole = LocateEntryPoint( pPlayer );
+	if ( nRole != -1 )
+	{
+		// Set the owner flag.
+		bool bOwner = ( pPlayer == GetOwner() );
+		if ( bOwner )
+		{
+			// Check to see if a player exists at this location (role).
+			CBaseTFPlayer *pExistingPlayer = static_cast<CBaseTFPlayer*>( GetPassenger( nRole ) );
+			if ( pExistingPlayer )
+			{
+				pExistingPlayer->LeaveVehicle();
+
+				// Get in the vehicle.
+				pPlayer->GetInVehicle( this, nRole );
+
+				// Then see if we can move the other player to another slot in this vehicle
+				int nEmptyRole = GetEmptyRole();
+				if ( nEmptyRole != -1 )
+				{
+					pExistingPlayer->GetInVehicle( this, nEmptyRole );
+				}
+				return;
+			}
+		}
+
+		// Get in the vehicle.
+		pPlayer->GetInVehicle( this, nRole );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle commands sent from vgui panels on the client 
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::ClientCommand( CBaseTFPlayer *pPlayer, const CCommand &args )
+{
+	ResetDeteriorationTime();
+
+	if ( FStrEq( pCmd, "toggle_use" ) )
+	{
+		AttemptToBoardVehicle( pPlayer );
+		return true;
+	}
+
+	return BaseClass::ClientCommand( pPlayer, args );
+}
+
+//-----------------------------------------------------------------------------
+// Get a position in *world space* inside the vehicle for the player to exit at
+// NOTE: This doesn't check for obstructions
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::GetInitialPassengerExitPoint( int nRole, Vector *pAbsPoint, QAngle *pAbsAngles )
+{
+	char pAttachmentName[32];
+	Q_snprintf( pAttachmentName, sizeof( pAttachmentName ), "vehicle_exit_passenger%d", nRole );
+	int exitAttachmentIndex = LookupAttachment(pAttachmentName);
+	if (exitAttachmentIndex <= 0)
+	{
+		// bad attachment, just return the origin
+		*pAbsPoint = GetAbsOrigin();
+		pAbsPoint->z += WorldAlignMaxs()[2] + 50.0f;
+		return;
+	}
+
+	QAngle vehicleExitAngles;
+	if( !pAbsAngles )
+	{
+		pAbsAngles = &vehicleExitAngles;
+	}
+
+	GetAttachment( exitAttachmentIndex, *pAbsPoint, *pAbsAngles );
+}
+
+
+//-----------------------------------------------------------------------------
+// Get a point to leave the vehicle from
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::IsValidExitPoint( int nRole, Vector *pExitPoint, QAngle *pAngles )
+{
+	GetInitialPassengerExitPoint( nRole, pExitPoint, pAngles );
+
+	// Check the exit point:
+	Vector vecStart = *pExitPoint;
+	Vector vecEnd = *pExitPoint + Vector(0,0,20);
+	trace_t tr;
+	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
+	if ( (tr.fraction < 1.f)  )
+		return false;
+
+	vecEnd = *pExitPoint + Vector(20,20,20);
+	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
+	if ( (tr.fraction < 1.f)  )
+		return false;
+
+	vecEnd = *pExitPoint + Vector(-20,-20,20);
+	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
+	if ( (tr.fraction < 1.f)  )
+		return false;
+
+	vecEnd = *pExitPoint + Vector(20,-20,20);
+	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
+	if ( (tr.fraction < 1.f)  )
+		return false;
+
+	vecEnd = *pExitPoint + Vector(-20,20,20);
+	UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr);
+	if ( (tr.fraction < 1.f)  )
+		return false;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::GetPassengerExitPoint( CBasePlayer *pPlayer, int nRole, Vector *pAbsPosition, QAngle *pAbsAngles )
+{
+
+	// Deal with vehicles built on other vehicles
+	CBaseTFVehicle *pParentVehicle = dynamic_cast<CBaseTFVehicle*>(GetMoveParent());
+	if (pParentVehicle)
+	{
+		int nParentVehicleRole = pParentVehicle->GetChildVehicleRole( this );
+		if (nParentVehicleRole >= 0)
+		{
+			pParentVehicle->GetPassengerExitPoint( pPlayer, nParentVehicleRole, pAbsPosition, pAbsAngles );
+			return;
+		}
+	}
+
+	// Deal with vehicles build on objects
+	IHasBuildPoints *pMount = dynamic_cast<IHasBuildPoints*>(GetMoveParent());
+	if (pMount)
+	{
+		int nBuildPoint = pMount->FindObjectOnBuildPoint( this );
+		if (nBuildPoint >= 0)
+		{
+			pMount->GetExitPoint( pPlayer, nBuildPoint, pAbsPosition, pAbsAngles );
+			return;
+		}
+	}
+
+	Vector vNewPos;
+	GetInitialPassengerExitPoint( nRole, pAbsPosition, pAbsAngles );
+	if ( EntityPlacementTest(pPlayer, *pAbsPosition, vNewPos, true) )
+	{
+		*pAbsPosition = vNewPos;
+		return;
+	}
+
+	// Find the first valid exit point
+	for( int iExitPoint = 0; iExitPoint < m_nMaxPassengers; ++iExitPoint )
+	{
+		if (iExitPoint == nRole)
+			continue;
+
+		GetInitialPassengerExitPoint( iExitPoint, pAbsPosition, pAbsAngles );
+		if ( EntityPlacementTest(pPlayer, *pAbsPosition, vNewPos, true) )
+		{
+			*pAbsPosition = vNewPos;
+			return;
+		}
+	}
+
+	// Worst case, we will be returning the vehicle's origin + 50z here
+	*pAbsPosition = GetAbsOrigin();
+	pAbsPosition->z = WorldAlignMaxs()[2] + 150.0f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::GetPassengerExitPoint( int nRole, Vector *pAbsPosition, QAngle *pAbsAngles )
+{
+	// FIXME: Clean this up
+	CBasePlayer *pPlayer = GetPassenger(nRole);
+	GetPassengerExitPoint( pPlayer, nRole, pAbsPosition, pAbsAngles );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseTFVehicle::GetEntryAnimForPoint( const Vector &vecPoint )
+{
+	return ACTIVITY_NOT_AVAILABLE;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CBaseTFVehicle::GetExitAnimToUse( Vector &vecEyeExitEndpoint, bool &bAllPointsBlocked )
+{
+	bAllPointsBlocked = false;
+	return ACTIVITY_NOT_AVAILABLE;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::HandleEntryExitFinish( bool bExitAnimOn, bool bResetAnim )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pPlayer - 
+//			false - 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::HandlePassengerEntry( CBasePlayer *pPlayer, bool bAllowEntryOutsideZone )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pPlayer - 
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::HandlePassengerExit( CBasePlayer *pPlayer )
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get and set the current driver.
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::SetPassenger( int nRole, CBasePlayer *pEnt )
+{
+	Assert( !pEnt || pEnt->IsPlayer() );
+	Assert( nRole >= 0 && nRole < m_nMaxPassengers );
+	Assert( !m_hPassengers[nRole].Get() || !pEnt );
+	m_hPassengers.Set( nRole, dynamic_cast<CBaseTFPlayer*>(pEnt) );
+
+	// If the vehicle's deteriorating, I get to own it now
+	if ( IsDeteriorating() )
+	{
+		StopDeteriorating();
+		SetBuilder( (CBaseTFPlayer*)pEnt, true );
+	}
+
+	ResetDeteriorationTime();
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Get a position in *world space* inside the vehicle for the player to start at
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::GetPassengerStartPoint( int nRole, Vector *pAbsPoint, QAngle *pAbsAngles )
+{
+	char pAttachmentName[32];
+	Q_snprintf( pAttachmentName, sizeof( pAttachmentName ), "vehicle_feet_passenger%d", nRole );
+	int nFeetAttachmentIndex = LookupAttachment(pAttachmentName);
+	GetAttachment( nFeetAttachmentIndex, *pAbsPoint, *pAbsAngles );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+#define INITIAL_MAX_DISTANCE  999999.0f
+
+int CBaseTFVehicle::LocateEntryPoint( CBaseTFPlayer *pPlayer, float* fBest2dDistanceSqr )
+{
+	// Get the players origin and compare it to all the entry points on the
+	// vehicle.
+	Vector vecPlayerPos = pPlayer->GetAbsOrigin();
+	Vector vecEntryPos;
+	QAngle vecEntryAngle;
+
+	int   iMinEntry = -1;
+	float flMinDistance2 = INITIAL_MAX_DISTANCE;
+
+	// Is the player the owner of the vehicle?
+	bool bOwner = ( pPlayer == GetOwner() );
+
+	char szPassengerEyes[32];
+	for( int iEntryPoint = 0; iEntryPoint < m_nMaxPassengers; ++iEntryPoint )
+	{
+		// If not the owner, check to see if the entry point is available.  The
+		// entry point is always available for the owner.
+		bool bOccupied = ( GetPassenger( iEntryPoint ) != NULL );
+
+		// Also check for child vehicles...
+
+		if ( bOccupied && !bOwner )
+			continue;
+	
+		// FIXME: Cache off the entry point
+		Q_snprintf( szPassengerEyes, sizeof( szPassengerEyes ), "vehicle_feet_passenger%d", iEntryPoint );
+		int nAttachmentIndex = LookupAttachment( szPassengerEyes );
+
+		float flDistance2;
+		if (nAttachmentIndex > 0)
+		{
+			GetAttachment( nAttachmentIndex, vecEntryPos, vecEntryAngle );
+			Vector vecDelta = vecEntryPos - vecPlayerPos;
+			flDistance2 = vecDelta.AsVector2D().LengthSqr();
+		}
+		else
+		{
+			// No attachment? Choose it if we must as a last resort
+			flDistance2 = INITIAL_MAX_DISTANCE - 1;
+		}
+
+		if ( flDistance2 < flMinDistance2 )
+		{
+			flMinDistance2 = flDistance2;
+			iMinEntry = iEntryPoint;
+		}
+	}
+
+	if( fBest2dDistanceSqr )
+	{
+		*fBest2dDistanceSqr = flMinDistance2;
+	}
+	return iMinEntry;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set a gun that the driver can control
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::SetDriverGun( CBaseObjectDriverGun *pGun )
+{
+	m_hDriverGun = pGun;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update the driver's gun
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::VehicleDriverGunThink( void )
+{
+	if ( !m_hDriverGun )
+		return;
+
+	// No driver?
+	CBaseTFPlayer *pDriver = GetDriverPlayer();
+	if ( !pDriver )
+		return;
+
+	QAngle vecTargetAngles = m_hDriverGun->GetCurrentAngles();
+
+	// Cast a ray out of the view to see where the player is looking.
+	trace_t trace;
+	Vector vecForward;
+	Vector vecSrc;
+	QAngle angEyeAngles;
+	GetVehicleViewPosition( VEHICLE_DRIVER, &vecSrc, &angEyeAngles, NULL );
+	AngleVectors( angEyeAngles, &vecForward, NULL, NULL );
+	Vector vecEnd = vecSrc + (vecForward * 10000);
+	UTIL_TraceLine( vecSrc, vecEnd, MASK_OPAQUE, this, COLLISION_GROUP_NONE, &trace );
+
+	//NDebugOverlay::Box( vecSrc, -Vector(10,10,10), Vector(10,10,10), 255,0,0,8, 5 );
+	//NDebugOverlay::Box( vecEnd, -Vector(10,10,10), Vector(10,10,10), 0,255,0,8, 5 );
+	//NDebugOverlay::Box( trace.endpos, -Vector(10,10,10), Vector(10,10,10), 255,255,255,8, 0.1 );
+
+	if ( trace.fraction < 1 )
+	{
+		// Figure out what angles our turret needs to be at in order to hit the target.
+		Vector vFireOrigin = m_hDriverGun->GetFireOrigin();
+
+		//NDebugOverlay::Box( vFireOrigin, -Vector(10,10,10), Vector(10,10,10), 0,255,0,8, 0.1 );
+
+		// 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 );
+
+		vecTargetAngles[YAW] = localAngles[YAW] - 90;
+		vecTargetAngles[PITCH] = anglemod( localAngles[PITCH] );
+	}
+
+	// Set the gun's angles
+	m_hDriverGun->SetTargetAngles( vecTargetAngles );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::ShouldUseThirdPersonVehicleView()
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Returns the unperterbed view position for a particular role
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::GetRoleViewPosition( int nRole, Vector *pVehicleEyeOrigin, QAngle *pVehicleEyeAngles )
+{
+	// Generate the view position in world space.
+	Vector vAbsOrigin;
+	QAngle vAbsAngle;
+	bool bUsingThirdPersonCamera = GetRoleAbsViewPosition( nRole, &vAbsOrigin, &vAbsAngle );
+
+	
+	// Make a matrix for it.
+	matrix3x4_t absMatrix;
+	AngleMatrix( vAbsAngle, absMatrix );
+	MatrixSetColumn( vAbsOrigin, 3, absMatrix );
+
+
+	// Transform the matrix into local space.
+	matrix3x4_t worldToEntity, local;
+	MatrixInvert( EntityToWorldTransform(), worldToEntity );
+	ConcatTransforms( worldToEntity, absMatrix, local ); 
+
+
+	// Suck out the origin and angles.
+	pVehicleEyeOrigin->Init( local[0][3], local[1][3], local[2][3] );
+	MatrixAngles( local, *pVehicleEyeAngles );
+
+	return bUsingThirdPersonCamera;
+}
+
+bool CBaseTFVehicle::GetRoleAbsViewPosition( int nRole, Vector *pAbsVehicleEyeOrigin, QAngle *pAbsVehicleEyeAngles )
+{
+	int iAttachment = LookupAttachment( "ThirdPersonCameraOrigin" );
+	if ( ShouldUseThirdPersonVehicleView() && vehicle_thirdperson.GetInt() && nRole == VEHICLE_DRIVER && iAttachment > 0 )
+	{
+		// Ok, we're using third person. Leave their angles intact but rotate theirt view around the
+		// ThirdPersonCameraOrigin attachment.
+		Vector vAttachOrigin;
+		QAngle vAttachAngles;
+		GetAttachment( iAttachment, vAttachOrigin, vAttachAngles );
+
+		Vector vForward, vRight, vUp;
+		AngleVectors( *pAbsVehicleEyeAngles, &vForward, &vRight, &vUp );
+
+		*pAbsVehicleEyeOrigin = vAttachOrigin + vForward * vehicle_view_offset_forward.GetFloat() + 
+			vRight * vehicle_view_offset_right.GetFloat() + 
+			vUp * vehicle_view_offset_up.GetFloat();
+	
+		// Returning true tells the caller that we're using a third-person camera origin.
+		return true;
+	}
+	else
+	{
+		// Use the vehicle_eyes_passengerX attachments.
+		Assert( nRole >= 0 );
+		char pAttachmentName[32];
+		Q_snprintf( pAttachmentName, sizeof( pAttachmentName ), "vehicle_eyes_passenger%d", nRole );
+		int eyeAttachmentIndex = LookupAttachment(pAttachmentName);
+		
+		QAngle vTempAngles;
+		GetAttachment( eyeAttachmentIndex, *pAbsVehicleEyeOrigin, vTempAngles );
+		
+		if ( vehicle_attach_eye_angles.GetInt() )
+			*pAbsVehicleEyeAngles = vTempAngles;
+
+		return false;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Modify the player view/camera while in a vehicle
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::GetVehicleViewPosition( int nRole, Vector *pAbsOrigin, QAngle *pAbsAngles, float *pFOV /*= NULL*/ )
+{
+	// UNDONE: Use attachment point on the vehicle, not hardcoded player eyes
+	Assert( nRole >= 0 );
+	CBasePlayer *pPlayer = GetPassenger( nRole );
+	Assert( pPlayer );
+
+	Vector vehicleEyeOrigin;
+	QAngle vehicleEyeAngles = pPlayer->LocalEyeAngles();
+	
+	GetRoleAbsViewPosition( nRole, &vehicleEyeOrigin, &vehicleEyeAngles ); 
+
+	*pAbsOrigin = vehicleEyeOrigin;
+	*pAbsAngles = vehicleEyeAngles;
+
+	/*
+ 	if ( bUsingThirdPersonCamera )
+	{
+		*pAbsOrigin = vehicleEyeOrigin;
+		*pAbsAngles = vehicleEyeAngles;
+	}
+	else
+	{
+		matrix3x4_t vehicleEyePosToWorld;
+
+		AngleMatrix( vehicleEyeAngles, vehicleEyePosToWorld );
+
+		// Compute the relative rotation between the unperterbed eye attachment + the eye angles
+		matrix3x4_t cameraToWorld;
+		AngleMatrix( *pAbsAngles, cameraToWorld );
+
+		matrix3x4_t worldToEyePos;
+		MatrixInvert( vehicleEyePosToWorld, worldToEyePos );
+
+		matrix3x4_t vehicleCameraToEyePos;
+		ConcatTransforms( worldToEyePos, cameraToWorld, vehicleCameraToEyePos );
+
+		// Now perterb the attachment point
+		if( inv_demo.GetInt() )
+		{
+			vehicleEyeAngles.x = RemapAngleRange( PITCH_CURVE_ZERO * road_feel.GetFloat(), PITCH_CURVE_LINEAR, vehicleEyeAngles.x );
+			vehicleEyeAngles.z = RemapAngleRange( ROLL_CURVE_ZERO * road_feel.GetFloat(), ROLL_CURVE_LINEAR, vehicleEyeAngles.z );
+		} 
+		else
+		{
+			vehicleEyeAngles.x = RemapAngleRange( PITCH_CURVE_ZERO, PITCH_CURVE_LINEAR, vehicleEyeAngles.x );
+			vehicleEyeAngles.z = RemapAngleRange( ROLL_CURVE_ZERO, ROLL_CURVE_LINEAR, vehicleEyeAngles.z );
+		}
+
+		AngleMatrix( vehicleEyeAngles, vehicleEyeOrigin, vehicleEyePosToWorld );
+
+		// Now treat the relative eye angles as being relative to this new, perterbed view position...
+		matrix3x4_t newCameraToWorld;
+		ConcatTransforms( vehicleEyePosToWorld, vehicleCameraToEyePos, newCameraToWorld );
+
+		// output new view abs angles
+		MatrixAngles( newCameraToWorld, *pAbsAngles );
+
+		// UNDONE: *pOrigin would already be correct in single player if the HandleView() on the server ran after vphysics
+		MatrixGetColumn( newCameraToWorld, 3, *pAbsOrigin );
+	}
+	*/
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// Client-only code here
+//
+//-----------------------------------------------------------------------------
+
+#if defined (CLIENT_DLL)
+
+void CBaseTFVehicle::ClientThink()
+{
+	BaseClass::ClientThink();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseTFVehicle::ShouldPredict( void )
+{
+	// Only predict vehicles driven by local players
+	return GetDriverPlayer() ? GetDriverPlayer()->IsLocalPlayer() : false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the angles that a player in the specified role should be using for visuals
+//-----------------------------------------------------------------------------
+QAngle CBaseTFVehicle::GetPassengerAngles( QAngle angCurrent, int nRole )
+{
+	// Just use your current angles
+	return angCurrent;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::DrawHudElements( void )
+{
+	// If we've got a driver gun, tell it to draw it's elements
+	if ( m_hDriverGun )
+	{
+		m_hDriverGun->DrawHudElements();
+	}
+
+	DrawHudBoostData();
+	SetupCrosshair();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::DrawHudBoostData( void )
+{
+#define HUD_IMAGE_LEFT	XRES( 568 )
+
+	// Boostable vehicle
+	if ( IsBoostable() )
+	{
+		// Set our color
+		CHudTexture *pVehicleBoostLabel = gHUD.GetIcon( "no2" );
+		if ( pVehicleBoostLabel )
+		{
+			int nScreenY = ScreenHeight() - YRES( 12 );
+			float nOneHudHeight = ( YRES(10) + pVehicleBoostLabel->Height() );
+			nScreenY -= ( nOneHudHeight * 3 );
+		
+			pVehicleBoostLabel->DrawSelf( HUD_IMAGE_LEFT, nScreenY - pVehicleBoostLabel->Height(), gHUD.m_clrNormal );
+			gHUD.DrawProgressBar( HUD_IMAGE_LEFT, nScreenY + YRES( 4 ), XRES( 70 ), YRES( 4 ), m_nBoostTimeLeft / 100.0f, gHUD.m_clrNormal, CHud::HUDPB_HORIZONTAL_INV );
+		}
+	}
+
+#undef HUD_IMAGE_LEFT
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set a crosshair when in a vehicle and we don't have a proper 
+//          crosshair sprite (ie. a commando laser rifle).
+//-----------------------------------------------------------------------------
+void CBaseTFVehicle::SetupCrosshair( void )
+{
+	if ( !m_pIconDefaultCrosshair )
+	{
+		// Init the default crosshair the first time.
+		CHudTexture newTexture;
+		Q_strncpy( newTexture.szTextureFile, "sprites/crosshairs", sizeof( newTexture.szTextureFile ) );
+
+		newTexture.rc.left		= 0;
+		newTexture.rc.top		= 48;
+		newTexture.rc.right		= newTexture.rc.left + 24;
+		newTexture.rc.bottom	= newTexture.rc.top + 24;
+		m_pIconDefaultCrosshair = gHUD.AddUnsearchableHudIconToList( newTexture );
+	}
+
+	CHudCrosshair *crosshair = GET_HUDELEMENT( CHudCrosshair );
+	if ( crosshair )
+	{
+		if ( !crosshair->HasCrosshair() && m_pIconDefaultCrosshair )
+		{
+			crosshair->SetCrosshair( m_pIconDefaultCrosshair, gHUD.m_clrNormal );
+		}
+	}
+}
+
+#endif
diff --git a/game/shared/tf2/basetfvehicle.h b/game/shared/tf2/basetfvehicle.h
new file mode 100644
index 0000000..47c5dae
--- /dev/null
+++ b/game/shared/tf2/basetfvehicle.h
@@ -0,0 +1,272 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A base vehicle class
+//
+//=============================================================================//
+
+#ifndef BASETFVEHICLE_H
+#define BASETFVEHICLE_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfplayer_shared.h"
+#include "baseobject_shared.h"
+#include "tf_obj_basedrivergun_shared.h"
+
+#if defined( CLIENT_DLL )
+#include "iclientvehicle.h"
+#else
+#include "IServerVehicle.h"
+#endif
+
+
+class CMoveData;
+class CUserCmd;
+class CBasePlayer;
+
+#if defined( CLIENT_DLL )
+#define CBaseTFVehicle C_BaseTFVehicle
+#endif
+
+class CBaseTFVehicle;
+class CBaseObjectDriverGun;
+
+struct VehicleBaseMoveData_t
+{
+	CBaseTFVehicle	*m_pVehicle;
+};
+
+// ------------------------------------------------------------------------ //
+// The base class that all vehicles in tf2 will derive from
+// ------------------------------------------------------------------------ //
+#if defined( CLIENT_DLL )
+class CBaseTFVehicle : public CBaseObject, public IClientVehicle
+#else
+class CBaseTFVehicle : public CBaseObject, public IServerVehicle
+#endif
+{
+	DECLARE_CLASS( CBaseTFVehicle, CBaseObject );
+
+public:
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CBaseTFVehicle();
+
+#if !defined (CLIENT_DLL)
+	// CBaseEntity overrides
+	virtual void	FinishedBuilding( void );
+	virtual void	DestroyObject( );
+	virtual void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	virtual bool	UseAttachedItem( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	virtual void	GetVectors(Vector* pForward, Vector* pRight, Vector* pUp) const;
+
+	virtual bool	ClientCommand( CBaseTFPlayer *pPlayer, const CCommand &args );
+
+	// IVehicle overrides
+	virtual IServerVehicle*	GetServerVehicle() { return this; }
+
+	virtual CBaseEntity* GetVehicleEnt();
+
+	// Get and set the current driver.
+	virtual void SetPassenger( int nRole, CBasePlayer *pEnt );
+
+	// Where do we get out of the vehicle?
+	virtual bool GetPassengerExitPoint( int nRole, Vector *pExitPoint, QAngle *pAngles );
+
+	virtual Class_T			ClassifyPassenger( CBasePlayer *pPassenger, Class_T defaultClassification ) { return defaultClassification; }
+	virtual float			DamageModifier ( CTakeDamageInfo &info ) { return 1.0; }
+	virtual const vehicleparams_t	*GetVehicleParams( void ) { return NULL; }
+
+	virtual bool			IsVehicleUpright( void ) { return true; }
+	virtual bool			IsPassengerEntering( void ) { Assert( 0 ); return true; }
+	virtual bool			IsPassengerExiting( void ) { Assert( 0 ); return true; }
+
+	// NPC Driving
+	virtual bool			NPC_CanDrive( void ) { return true; }
+	virtual void			NPC_SetDriver( CNPC_VehicleDriver *pDriver ) { return; }
+	virtual void			NPC_DriveVehicle( void ) { return; }
+	virtual void			NPC_ThrottleCenter( void ) { return; }
+	virtual void			NPC_ThrottleReverse( void ) { return; }
+	virtual void			NPC_ThrottleForward( void ) { return; }
+	virtual void			NPC_Brake( void ) { return; }
+	virtual void			NPC_TurnLeft( float flDegrees ) { return; }
+	virtual void			NPC_TurnRight( float flDegrees ) { return; }
+	virtual void			NPC_TurnCenter( void ) { return; }
+	virtual void			NPC_PrimaryFire( void ) { return; }
+	virtual void			NPC_SecondaryFire( void ) { return; }
+	virtual bool			NPC_HasPrimaryWeapon( void ) { return false; }
+	virtual bool			NPC_HasSecondaryWeapon( void ) { return false; }
+	virtual void			NPC_AimPrimaryWeapon( Vector vecTarget ) { return; }
+	virtual void			NPC_AimSecondaryWeapon( Vector vecTarget ) { return; }
+
+	// Weapon handling
+	virtual void			Weapon_PrimaryRanges( float *flMinRange, float *flMaxRange ) { *flMinRange = 0; *flMaxRange = 0; }
+	virtual void			Weapon_SecondaryRanges( float *flMinRange, float *flMaxRange ) { *flMinRange = 0; *flMaxRange = 0; }
+	virtual float			Weapon_PrimaryCanFireAt( void ) { return gpGlobals->curtime; }		// Return the time at which this vehicle's primary weapon can fire again
+	virtual float			Weapon_SecondaryCanFireAt( void ) { return gpGlobals->curtime; }	// Return the time at which this vehicle's secondary weapon can fire again
+
+	// Vehicles dont want to attach to anything they're built upon
+	virtual bool ShouldAttachToParent( void ) { return false; }
+
+	virtual bool	MustNotBeBuiltInConstructionYard( void ) const { return false; }
+
+	// Purpose: Try to board the vehicle
+	void AttemptToBoardVehicle( CBaseTFPlayer *pPlayer );
+
+	// Figure out which role of a parent vehicle this vehicle is sitting in..
+	int GetParentVehicleRole();
+
+	// Purpose: 
+	void GetPassengerExitPoint( CBasePlayer *pPlayer, int nRole, Vector *pAbsPosition, QAngle *pAbsAngles );
+	int	 GetEntryAnimForPoint( const Vector &vecPoint );
+	int  GetExitAnimToUse( Vector &vecEyeExitEndpoint, bool &bAllPointsBlocked );
+	void HandleEntryExitFinish( bool bExitAnimOn, bool bResetAnim );
+	void HandlePassengerEntry( CBasePlayer *pPlayer, bool bAllowEntryOutsideZone = false );
+	bool HandlePassengerExit( CBasePlayer *pPlayer );
+
+	// Deterioration
+	void	VehicleDeteriorationThink( void );
+	void	VehiclePassengerThink( void );
+
+#endif
+
+	bool	IsReadyToDrive( void );
+
+	virtual bool	IsAVehicle( void ) { return true; }
+
+	// Get a position in *local space* inside the vehicle for the player to start at
+	virtual void GetPassengerStartPoint( int nRole, Vector *pPoint, QAngle *pAngles );
+
+#if defined( CLIENT_DLL )
+	// C_BaseEntity overrides
+	virtual IClientVehicle*	GetClientVehicle() { return this; }
+
+	virtual C_BaseEntity	*GetVehicleEnt();
+
+	virtual void ClientThink();
+
+	// Fills in the unperterbed view position for a particular role.
+
+	// Prediction
+	virtual bool	ShouldPredict( void );
+	virtual bool	IsPredicted( void ) const { return true; }
+
+	// IClientVehicle
+
+	// Called at time player enters vehicle
+	virtual void	GetVehicleFOV( float &flFOV ) { return; }
+	virtual void	DrawHudElements( void );
+
+	// Get the angles that a player in the specified role should be using for visuals
+	virtual QAngle	GetPassengerAngles( QAngle angCurrent, int nRole );
+
+	// Allows the vehicle to restrict view angles
+	virtual void	UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd ) {}
+	virtual void	GetVehicleClipPlanes( float &flZNear, float &flZFar ) const {}
+
+	bool			IsBoostable( void )		{ return m_bBoostUpgrade; }
+
+	// Hud
+	virtual void	DrawHudBoostData( void );
+	virtual void	SetupCrosshair( void );
+
+#endif
+
+	int		LocateEntryPoint( CBaseTFPlayer *pPlayer, float* fBest2dDistanceSqr= NULL );
+
+	// This lets the object decide whether or not it wants to use the ThirdPersonCameraOrigin attachment for its view.
+	// The manned guns use first-person when they're on the ground and third-person when they're in a vehicle.
+	virtual bool	ShouldUseThirdPersonVehicleView();
+	virtual void	GetVehicleViewPosition( int nRole, Vector *pOrigin, QAngle *pAngles, float *pFOV = NULL );
+	virtual bool	GetRoleViewPosition( int nRole, Vector *pVehicleEyeOrigin, QAngle *pVehicleEyeAngles );
+	virtual bool	GetRoleAbsViewPosition( int nRole, Vector *pAbsVehicleEyeOrigin, QAngle *pAbsVehicleEyeAngles );
+
+	// Can a given passenger take damage?
+	virtual bool	IsPassengerDamagable( int nRole ) { return (nRole != VEHICLE_DRIVER); }
+
+
+	virtual void	Spawn();
+	virtual void	SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
+	virtual void	ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove ) {}
+	virtual void	FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move );
+	virtual void	ItemPostFrame( CBasePlayer *pPassenger );
+
+	virtual CBasePlayer* GetPassenger( int nRole = VEHICLE_DRIVER );
+	virtual int		GetPassengerRole( CBasePlayer *pEnt );
+
+	// Does the player use his normal weapons while in this mode?
+	virtual bool	IsPassengerUsingStandardWeapons( int nRole = VEHICLE_DRIVER ) { return false; }
+
+	virtual Vector GetSoundEmissionOrigin() const;
+
+	// Returns the driver as a tfplayer pointer
+	CBaseTFPlayer *GetDriverPlayer();
+	
+	int	GetMaxPassengerCount() const;
+	int GetPassengerCount() const;
+
+	// Is a particular player in the vehicle?
+	bool IsPlayerInVehicle( CBaseTFPlayer *pPlayer );
+
+	void	ResetDeteriorationTime( void );
+
+	// Driver controlled guns
+	void	SetDriverGun( CBaseObjectDriverGun *pGun );
+	void	VehicleDriverGunThink( void );
+
+protected:
+	enum
+	{
+		MAX_PASSENGERS = 4,
+		MAX_PASSENGER_BITS = 3
+	};
+
+	// Can we get into the vehicle?
+	virtual bool CanGetInVehicle( CBaseTFPlayer *pPlayer );
+
+	// Here's where we deal with weapons
+	virtual void OnItemPostFrame( CBaseTFPlayer *pDriver );
+
+	// Specify the number of roles we can have
+	void SetMaxPassengerCount( int nMaxPassengers );
+
+	bool	IsValidExitPoint( int nRole, Vector *pExitPoint, QAngle *pAngles );
+	int 	GetEmptyRole( void );
+
+private:
+#if !defined (CLIENT_DLL)
+	// Get the parent vehicle of this vehicle..
+	CBaseTFVehicle *GetParentVehicle();
+
+	// Get a position in *world space* inside the vehicle for the player to exit at
+	void GetInitialPassengerExitPoint( int nRole, Vector *pAbsPoint, QAngle *pAbsAngles );
+
+	// Figure out which role of a vehicle a child vehicle is sitting in..
+	int GetChildVehicleRole( CBaseTFVehicle *pChild );
+#endif
+
+private:
+	typedef CHandle<CBaseTFPlayer> CPlayerHandle;
+	CNetworkArray( CPlayerHandle, m_hPassengers, MAX_PASSENGERS );
+	CNetworkVar( int, m_nMaxPassengers );
+
+	// Driver controlled gun
+	CNetworkHandle( CBaseObjectDriverGun, m_hDriverGun );
+
+#if defined( CLIENT_DLL )
+
+	CHudTexture			*m_pIconDefaultCrosshair;
+
+	bool			m_bBoostUpgrade;
+	int				m_nBoostTimeLeft;
+
+private:
+	CBaseTFVehicle( const CBaseTFVehicle & ); // not defined, not accessible
+#endif
+};
+
+#endif // BASETFVEHICLE_H
diff --git a/game/shared/tf2/env_laserdesignation.cpp b/game/shared/tf2/env_laserdesignation.cpp
new file mode 100644
index 0000000..543be1a
--- /dev/null
+++ b/game/shared/tf2/env_laserdesignation.cpp
@@ -0,0 +1,328 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Entity used to highlight laser designation points to clients
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "tf_obj_manned_plasmagun.h"
+#include "env_laserdesignation.h"
+
+#if !defined( CLIENT_DLL )
+
+#include "tf_vehicle_tank.h"
+#include "tf_obj_manned_missilelauncher.h"
+
+#endif
+
+extern ConVar weapon_grenade_rocket_track_range_mod;
+extern ConVar vehicle_tank_range;
+extern ConVar weapon_rocket_launcher_range;
+extern ConVar obj_manned_missilelauncher_range_off;
+
+//-----------------------------------------------------------------------------
+// Stores a list of all laser designations
+//-----------------------------------------------------------------------------
+CUtlVector< EHANDLE >	CEnvLaserDesignation::m_LaserDesignatorsTeam1;
+CUtlVector< EHANDLE >	CEnvLaserDesignation::m_LaserDesignatorsTeam2;
+
+IMPLEMENT_NETWORKCLASS_ALIASED( EnvLaserDesignation, DT_EnvLaserDesignation )
+
+BEGIN_NETWORK_TABLE( CEnvLaserDesignation, DT_EnvLaserDesignation )
+#if !defined( CLIENT_DLL )
+	SendPropInt( SENDINFO( m_bActive ), 1, SPROP_UNSIGNED ),
+#else
+	RecvPropInt( RECVINFO( m_bActive ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CEnvLaserDesignation  )
+	DEFINE_PRED_FIELD( m_bActive, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( env_laserdesignation, CEnvLaserDesignation );
+PRECACHE_REGISTER( env_laserdesignation );
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a laser designation
+//-----------------------------------------------------------------------------
+CEnvLaserDesignation *CEnvLaserDesignation::Create( CBasePlayer *pOwner )
+{
+	CEnvLaserDesignation *pDesignation = (CEnvLaserDesignation*)CreateEntityByName("env_laserdesignation"); 
+	pDesignation->Spawn();
+	pDesignation->SetOwnerEntity( pOwner );
+	pDesignation->ChangeTeam( pOwner->GetTeamNumber() );
+	pDesignation->SetActive( false );
+
+	return pDesignation;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a laser designation
+//-----------------------------------------------------------------------------
+CEnvLaserDesignation *CEnvLaserDesignation::CreatePredicted( CBasePlayer *pOwner )
+{
+#if !defined( NO_ENTITY_PREDICTION )
+	CEnvLaserDesignation *pDesignation = (CEnvLaserDesignation*)CREATE_PREDICTED_ENTITY("env_laserdesignation"); 
+	if ( pDesignation )
+	{
+		pDesignation->Spawn();
+		pDesignation->SetOwnerEntity( pOwner );
+		pDesignation->SetPlayerSimulated( pOwner );
+		pDesignation->ChangeTeam( pOwner->GetTeamNumber() );
+		pDesignation->SetActive( false );
+	}
+
+	return pDesignation;
+#else
+	return NULL;
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CEnvLaserDesignation::CEnvLaserDesignation( void )
+{
+	m_bActive = -1;	// So the first setactive will take effect
+	m_bPrevActive = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CEnvLaserDesignation::~CEnvLaserDesignation( void )
+{
+	EHANDLE hLaser;
+	hLaser = this;
+
+	if ( GetTeamNumber() == 1 )
+	{
+		m_LaserDesignatorsTeam1.FindAndRemove( hLaser );
+	}
+	else if ( GetTeamNumber() == 2 )
+	{
+		m_LaserDesignatorsTeam2.FindAndRemove( hLaser );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CEnvLaserDesignation::Spawn( void )
+{
+	SetModel( "models/projectiles/grenade_limpet.mdl" );
+	SetMoveType( MOVETYPE_NONE );
+	SetSolid( SOLID_NONE );
+	SetSize( vec3_origin, vec3_origin );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CEnvLaserDesignation::ChangeTeam( int iTeamNum )
+{
+	Assert( iTeamNum > 0 && iTeamNum < MAX_TF_TEAMS );
+
+	EHANDLE hLaser;
+	hLaser = this;
+	if ( iTeamNum == 1 )
+	{
+		m_LaserDesignatorsTeam1.AddToTail( hLaser );
+	}
+	else if ( iTeamNum == 2 )
+	{
+		m_LaserDesignatorsTeam2.AddToTail( hLaser );
+	}
+
+	BaseClass::ChangeTeam( iTeamNum );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CEnvLaserDesignation::SetActive( bool bActive )
+{
+	if ( bActive == m_bActive )
+		return;
+
+	if ( !bActive )
+	{
+		AddEffects( EF_NODRAW );
+	}
+	else
+	{
+		IncrementInterpolationFrame();
+		RemoveEffects( EF_NODRAW );
+	}
+
+#if defined( CLIENT_DLL )
+	ENTITY_PANEL_ACTIVATE( "laserdesignation", bActive );
+#endif
+
+	m_bActive = bActive;
+}
+
+#if !defined( CLIENT_DLL )
+
+
+int CEnvLaserDesignation::UpdateTransmitState()
+{
+	return SetTransmitState( FL_EDICT_FULLCHECK );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CEnvLaserDesignation::ShouldTransmit( const CCheckTransmitInfo *pInfo )
+{
+	// Only transmit to players who care about laser designation: 
+	//	- Player designating
+	//	- Players in tanks
+	//	- Commandos
+	CBaseEntity* pRecipientEntity = CBaseEntity::Instance( pInfo->m_pClientEnt );
+	if ( pRecipientEntity->IsPlayer() )
+	{
+		CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)pRecipientEntity;
+
+		// Designating player?
+		if ( pPlayer == GetOwnerEntity() )
+			return SetTransmitState( FL_EDICT_ALWAYS );
+					
+		if ( !InSameTeam( pPlayer ) )
+			return FL_EDICT_DONTSEND;
+			
+		// In a tank?
+		if ( pPlayer->IsInAVehicle() )
+		{
+			CBaseEntity	*pVehicle  = pPlayer->GetVehicle()->GetVehicleEnt();
+			if ( dynamic_cast<CVehicleTank*>(pVehicle) )
+			{
+				// Make sure it's within range of the tank's fire
+				static float flTankRange = 0;
+				if ( !flTankRange )
+				{
+					flTankRange = vehicle_tank_range.GetFloat() * weapon_grenade_rocket_track_range_mod.GetFloat();
+					flTankRange *= flTankRange;
+				}
+
+				float flDistanceSqr = ( GetAbsOrigin() - pPlayer->GetAbsOrigin() ).LengthSqr();
+				if ( flDistanceSqr < flTankRange )
+					return FL_EDICT_ALWAYS;
+			}
+			else if ( dynamic_cast<CObjectMannedMissileLauncher*>(pVehicle) )
+			{
+				// Make sure it's within range of the manned missile launcher's fire
+				static float flGunRange = 0;
+				if ( !flGunRange )
+				{
+					flGunRange = obj_manned_missilelauncher_range_off.GetFloat() * weapon_grenade_rocket_track_range_mod.GetFloat();
+					flGunRange *= flGunRange;
+				}
+
+				float flDistanceSqr = ( GetAbsOrigin() - pPlayer->GetAbsOrigin() ).LengthSqr();
+				if ( flDistanceSqr < flGunRange )
+					return FL_EDICT_ALWAYS;
+			}
+		}
+
+		// Is the player a commando?
+		if ( pPlayer->PlayerClass() == TFCLASS_COMMANDO )
+		{
+			// Make sure it's within range of the commando's rockets
+			static float flCommandoRange = 0;
+			if ( !flCommandoRange )
+			{
+				flCommandoRange = weapon_rocket_launcher_range.GetFloat() * weapon_grenade_rocket_track_range_mod.GetFloat();
+				flCommandoRange *= flCommandoRange;
+			}
+
+			float flDistanceSqr = ( GetAbsOrigin() - pPlayer->GetAbsOrigin() ).LengthSqr();
+			if ( flDistanceSqr < flCommandoRange )
+				return FL_EDICT_ALWAYS;
+		}
+	}
+
+	return FL_EDICT_DONTSEND;
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	CEnvLaserDesignation::GetNumLaserDesignators( int iTeamNumber )
+{
+	Assert( iTeamNumber > 0 && iTeamNumber < MAX_TF_TEAMS );
+
+	if ( iTeamNumber == 1 )
+		return m_LaserDesignatorsTeam1.Count();
+
+	return m_LaserDesignatorsTeam2.Count();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CEnvLaserDesignation::GetLaserDesignation( int iTeamNumber, int iDesignator, Vector *vecOrigin )
+{
+	Assert( iTeamNumber > 0 && iTeamNumber < MAX_TF_TEAMS );
+
+	CHandle<CEnvLaserDesignation> hLaser;
+	if ( iTeamNumber == 1 )
+	{
+		Assert( iDesignator < m_LaserDesignatorsTeam1.Count() );
+		hLaser = m_LaserDesignatorsTeam1[iDesignator];
+	}
+	else
+	{
+		Assert( iDesignator < m_LaserDesignatorsTeam2.Count() );
+		hLaser = m_LaserDesignatorsTeam2[iDesignator];
+	}
+
+	// Active?
+	if ( !hLaser.Get() || !hLaser->IsActive() )
+		return false;
+
+	*vecOrigin = hLaser->GetAbsOrigin();
+	return true;
+}
+
+#if defined( CLIENT_DLL )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CEnvLaserDesignation::DrawModel( int flags )
+{
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : updateType - 
+//-----------------------------------------------------------------------------
+void CEnvLaserDesignation::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( m_bActive != m_bPrevActive )
+	{
+		ENTITY_PANEL_ACTIVATE( "laserdesignation", m_bActive );
+	}
+	m_bPrevActive = m_bActive.Get();
+}
+
+//-----------------------------------------------------------------------------
+// Add, remove object from the panel 
+//-----------------------------------------------------------------------------
+void CEnvLaserDesignation::SetDormant( bool bDormant )
+{
+	BaseClass::SetDormant( bDormant );
+
+	ENTITY_PANEL_ACTIVATE( "laserdesignation", (!bDormant && m_bActive) );
+}
+
+#endif
\ No newline at end of file
diff --git a/game/shared/tf2/env_laserdesignation.h b/game/shared/tf2/env_laserdesignation.h
new file mode 100644
index 0000000..c715498
--- /dev/null
+++ b/game/shared/tf2/env_laserdesignation.h
@@ -0,0 +1,80 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef ENV_LASERDESIGNATION_H
+#define ENV_LASERDESIGNATION_H
+#pragma once
+
+#if defined( CLIENT_DLL )
+#define CEnvLaserDesignation C_EnvLaserDesignation
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: A laser designation point
+//-----------------------------------------------------------------------------
+class CEnvLaserDesignation : public CBaseAnimating
+{
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+	DECLARE_CLASS( CEnvLaserDesignation, CBaseAnimating );
+
+	CEnvLaserDesignation( void );
+	~CEnvLaserDesignation( void );
+
+	virtual void Spawn( void );
+	virtual void ChangeTeam( int iTeamNum );
+
+	// Designation
+	void	SetActive( bool bActive );
+	bool	IsActive( void ) { return m_bActive; }
+
+		// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwnerEntity() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	DECLARE_ENTITY_PANEL();
+
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+	virtual void SetDormant( bool bDormant );
+
+	virtual int		DrawModel( int flags );
+#else
+	virtual int		UpdateTransmitState();	
+	virtual int		ShouldTransmit( const CCheckTransmitInfo *pInfo );
+#endif
+
+	// Global Designator access
+	static CEnvLaserDesignation *Create( CBasePlayer *pOwner );
+	static CEnvLaserDesignation *CreatePredicted( CBasePlayer *pOwner );
+	static int		GetNumLaserDesignators( int iTeamNumber );
+	static bool		GetLaserDesignation( int iTeamNumber, int iDesignator, Vector *vecOrigin );
+
+protected:
+	static CUtlVector< EHANDLE >	m_LaserDesignatorsTeam1;
+	static CUtlVector< EHANDLE >	m_LaserDesignatorsTeam2;
+
+	CNetworkVar( bool, m_bActive );
+
+	bool	m_bPrevActive;
+private:
+	CEnvLaserDesignation( const CEnvLaserDesignation& src );
+};
+
+#endif // ENV_LASERDESIGNATION_H
diff --git a/game/shared/tf2/gasoline_shared.h b/game/shared/tf2/gasoline_shared.h
new file mode 100644
index 0000000..efd9280
--- /dev/null
+++ b/game/shared/tf2/gasoline_shared.h
@@ -0,0 +1,40 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GASOLINE_SHARED_H
+#define GASOLINE_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#define PYRO_AMMO_TYPE	"Gasoline"
+
+
+// Radius in inches of each gasoline blob. They should render to about this size.
+#define GASOLINE_BLOB_RADIUS				30
+
+// Blobs start to attract each other when their centerpoints get this close.
+#define GASOLINE_ATTRACT_START_DISTANCE		(GASOLINE_BLOB_RADIUS + 20)
+
+
+// Blobs expire after this long whether they are lit or not.
+#define MAX_LIT_GASOLINE_BLOB_LIFETIME			5.0
+#define MAX_UNLIT_GASOLINE_BLOB_LIFETIME		20.0
+
+
+// Heat per second given off by fire.
+#define FIRE_DAMAGE_PER_SEC					85
+
+
+#define BLOBFLAG_LIT			0x01	// This blob is on fire.
+#define BLOBFLAG_STOPPED		0x02	// This means it has hit a surface and stopped moving.
+#define BLOBFLAG_USE_GRAVITY	0x04
+#define NUM_BLOB_FLAGS			3
+
+
+#endif // GASOLINE_SHARED_H
diff --git a/game/shared/tf2/grenade_antipersonnel.cpp b/game/shared/tf2/grenade_antipersonnel.cpp
new file mode 100644
index 0000000..21ecd9b
--- /dev/null
+++ b/game/shared/tf2/grenade_antipersonnel.cpp
@@ -0,0 +1,211 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "tf_basecombatweapon.h"
+#include "basegrenade_shared.h"
+#include "engine/IEngineSound.h"
+#include "tf_shareddefs.h"
+#include "IEffects.h"
+#include "Sprite.h"
+#include "grenade_antipersonnel.h"
+
+// Damage CVars
+ConVar	weapon_antipersonnel_grenade_damage( "weapon_antipersonnel_grenade_damage","0", FCVAR_NONE, "Anti-personnel grenade maximum damage" );
+ConVar	weapon_antipersonnel_grenade_radius( "weapon_antipersonnel_grenade_radius","0", FCVAR_NONE, "Anti-personnel grenade splash radius" );
+
+#if !defined( CLIENT_DLL )
+// Server Only
+ConVar weapon_antipersonnel_grenade_force( "weapon_antipersonnel_grenade_force","225.0", FCVAR_NONE, "Grenade explosive force modifier." );
+#endif
+
+
+IMPLEMENT_SERVERCLASS_ST(CGrenadeAntiPersonnel, DT_GrenadeAntiPersonnel)
+END_SEND_TABLE()
+
+LINK_ENTITY_TO_CLASS( grenade_antipersonnel, CGrenadeAntiPersonnel );
+PRECACHE_WEAPON_REGISTER(grenade_antipersonnel);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CGrenadeAntiPersonnel::CGrenadeAntiPersonnel()
+{
+	UseClientSideAnimation();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CGrenadeAntiPersonnel::Precache( void )
+{
+	BaseClass::Precache( );
+
+	PrecacheModel( "models/weapons/w_grenade.mdl" );
+	PrecacheModel( "sprites/redglow1.vmt" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeAntiPersonnel::Spawn( void )
+{
+	Precache();
+
+	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
+	SetSolid( SOLID_BBOX );
+	SetGravity( 1.0 );
+	SetFriction( 0.9 );
+	SetElasticity( 2.0f );
+	SetModel( "models/weapons/w_grenade.mdl" );
+	UTIL_SetSize(this, vec3_origin, vec3_origin);
+	SetTouch( BounceTouch );
+	SetCollisionGroup( TFCOLLISION_GROUP_GRENADE );
+
+	m_flDetonateTime = gpGlobals->curtime + 3.0;
+	SetThink( TumbleThink );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	// Set my damages to the cvar values
+	SetDamage( weapon_antipersonnel_grenade_damage.GetFloat() );
+	SetDamageRadius( weapon_antipersonnel_grenade_radius.GetFloat() );
+
+	// Create a green light
+	m_pLiveSprite = CSprite::SpriteCreate( "sprites/redglow1.vmt", GetLocalOrigin() + Vector(0,0,1), false );
+	m_pLiveSprite->SetTransparency( kRenderGlow, 0, 255, 0, 128, kRenderFxNoDissipation );
+	m_pLiveSprite->SetBrightness( 255 );
+	m_pLiveSprite->SetScale( 1 );
+	m_pLiveSprite->SetAttachment( this, 0 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeAntiPersonnel::UpdateOnRemove( void )
+{
+	// Remove our live sprite
+	if ( m_pLiveSprite )
+	{
+		UTIL_Remove( m_pLiveSprite );
+		m_pLiveSprite = NULL;
+	}
+
+	// Chain at end to mimic destructor unwind order
+	BaseClass::UpdateOnRemove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Allow shield parry's
+//-----------------------------------------------------------------------------
+void CGrenadeAntiPersonnel::BounceTouch( CBaseEntity *pOther )
+{
+	// Don't blow up on trigger brushes
+	Assert( pOther );
+	if ( !pOther->IsSolid() )
+		return;
+
+	if ( pOther->GetCollisionGroup() == TFCOLLISION_GROUP_SHIELD )
+	{
+		// Move away from the shield...
+		// Fling it out a little extra along the plane normal
+		Vector vecCenter;
+		AngleVectors( pOther->GetAbsAngles(), &vecCenter );
+
+		// Bounce off the ground if it's on the ground...
+		Vector vecNewVelocity = GetAbsVelocity();
+		VectorMultiply( vecCenter, 400.0f, vecNewVelocity );
+		if ((GetFlags() & FL_ONGROUND) && vecNewVelocity.z <= 100.0f)
+		{
+			vecNewVelocity.z = 100.0f;
+		}
+		SetAbsVelocity( vecNewVelocity );
+	}
+
+	// If we're set to explode on contact, and we just hit an enemy, go kaboom
+	if ( m_bExplodeOnContact && !InSameTeam(pOther) && pOther->m_takedamage != DAMAGE_NO )
+	{
+		Detonate();
+		return;
+	}
+
+	BaseClass::BounceTouch( pOther );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the radius for the screenshake
+//-----------------------------------------------------------------------------
+float CGrenadeAntiPersonnel::GetShakeRadius( void )
+{
+	return (m_DmgRadius * 2);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a missile
+//-----------------------------------------------------------------------------
+void CGrenadeAntiPersonnel::Detonate( void )
+{
+	BaseClass::Detonate();
+
+	// iterate on all entities in the vicinity and find vehicles
+	CBaseEntity *pEntity = NULL;
+	for ( CEntitySphereQuery sphere( GetAbsOrigin(), m_DmgRadius ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
+	{
+		// Check team.
+		if ( pEntity->GetTeam() == GetTeam() )
+			continue;
+
+		if ( pEntity->GetServerVehicle() ) 
+		{
+			IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();
+			if ( pPhysObject )
+			{
+				// Rocket the vehicle in the direction of the incoming rocket.
+				Vector vecForceDir = pEntity->GetAbsOrigin() - GetAbsOrigin();
+				float flDistance = VectorNormalize( vecForceDir );
+
+				if ( flDistance >= 0.0f && flDistance < m_DmgRadius )
+				{
+					vecForceDir.z = 1.0f;
+					VectorNormalize( vecForceDir );
+					
+					float flForce = pPhysObject->GetMass();
+					flForce += ( 4 * 500.0f );				// Wheels
+					flForce *= weapon_antipersonnel_grenade_force.GetFloat();
+					flForce *= ( 1.0f - ( flDistance / m_DmgRadius ) );
+					
+					vecForceDir *= flForce;
+					
+					pPhysObject->ApplyForceOffset( vecForceDir, GetAbsOrigin() );
+				}
+			}		
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a missile
+//-----------------------------------------------------------------------------
+CGrenadeAntiPersonnel *CGrenadeAntiPersonnel::Create( const Vector &vecOrigin, const Vector &vecForward, CBasePlayer *pOwner )
+{
+	CGrenadeAntiPersonnel *pGrenade = (CGrenadeAntiPersonnel*)CreateEntityByName("grenade_antipersonnel");
+
+	UTIL_SetOrigin( pGrenade, vecOrigin );
+	pGrenade->Spawn();
+	pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+	pGrenade->SetOwnerEntity( pOwner );
+	pGrenade->SetThrower( pOwner );
+	pGrenade->SetAbsVelocity( vecForward );
+	QAngle angles;
+	VectorAngles( vecForward, angles );
+	pGrenade->SetLocalAngles( angles );
+	pGrenade->SetLocalAngularVelocity( RandomAngle(-500,500) );
+
+	return pGrenade;
+}
+
+
+
diff --git a/game/shared/tf2/grenade_antipersonnel.h b/game/shared/tf2/grenade_antipersonnel.h
new file mode 100644
index 0000000..2538f78
--- /dev/null
+++ b/game/shared/tf2/grenade_antipersonnel.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GRENADE_ANTIPERSONNEL_H
+#define GRENADE_ANTIPERSONNEL_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CSprite;
+
+#include "grenade_base_empable.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Antipersonnel grenade
+//-----------------------------------------------------------------------------
+class CGrenadeAntiPersonnel : public CBaseEMPableGrenade
+{
+	DECLARE_CLASS( CGrenadeAntiPersonnel, CBaseEMPableGrenade );
+public:
+	CGrenadeAntiPersonnel();
+
+	DECLARE_SERVERCLASS();
+
+	virtual void	Spawn( void );
+	virtual void	Precache( void );
+	virtual void	UpdateOnRemove( void );
+	virtual void	BounceTouch( CBaseEntity *pOther );
+//	virtual void	BounceSound( void );
+	virtual float	GetShakeRadius( void );
+
+	virtual void	Detonate( void );   
+
+	// Damage type accessors
+	virtual int GetDamageType() const { return DMG_BLAST; }
+
+	static CGrenadeAntiPersonnel *CGrenadeAntiPersonnel::Create( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner );
+
+	void	SetExplodeOnContact( bool bExplode ) { m_bExplodeOnContact = bExplode; }
+
+private:
+	CSprite		*m_pLiveSprite;
+	bool		m_bExplodeOnContact;
+};
+
+#endif // GRENADE_ANTIPERSONNEL_H
diff --git a/game/shared/tf2/grenade_base_empable.cpp b/game/shared/tf2/grenade_base_empable.cpp
new file mode 100644
index 0000000..2d46e80
--- /dev/null
+++ b/game/shared/tf2/grenade_base_empable.cpp
@@ -0,0 +1,89 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basegrenade_shared.h"
+#include "engine/IEngineSound.h"
+#include "grenade_base_empable.h"
+#include "IEffects.h"
+
+#if !defined( CLIENT_DLL )
+// Global Savedata 
+BEGIN_DATADESC( CBaseEMPableGrenade )
+	// Function Pointers
+	DEFINE_THINKFUNC( FizzleThink ),
+END_DATADESC()
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseEMPableGrenade, DT_BaseEMPableGrenade )
+
+BEGIN_NETWORK_TABLE( CBaseEMPableGrenade, DT_BaseEMPableGrenade )
+#if !defined( CLIENT_DLL )
+	SendPropFloat( SENDINFO( m_flFizzleDuration ), 10, SPROP_ROUNDDOWN, 0.0, 256.0f ),
+#else
+	RecvPropFloat( RECVINFO( m_flFizzleDuration ) ),
+#endif
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS( base_empable_grenade, CBaseEMPableGrenade );
+
+BEGIN_PREDICTION_DATA( CBaseEMPableGrenade  )
+
+	DEFINE_PRED_FIELD( m_flFizzleDuration, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+#define GRENADE_FIZZLE_DURATION		0.5
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseEMPableGrenade::CBaseEMPableGrenade( void )
+{
+	m_flFizzleDuration = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply EMP damage to class
+//-----------------------------------------------------------------------------
+bool CBaseEMPableGrenade::TakeEMPDamage( float duration )
+{
+	// If we're fizzling already, ignore extra EMP damage
+	if ( m_flFizzleDuration )
+		return true;
+
+	// Fizzle away in a couple of seconds
+	m_flFizzleDuration = gpGlobals->curtime + MIN( duration, GRENADE_FIZZLE_DURATION );
+	SetThink( FizzleThink );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Fizzle out and remove self from the world.
+//-----------------------------------------------------------------------------
+void CBaseEMPableGrenade::FizzleThink( void )
+{
+	float flDeltaTime = m_flFizzleDuration - gpGlobals->curtime;
+
+	// Keep fizzling until it's time to go
+	if ( flDeltaTime > 0.0f )
+	{
+		// Emit a fizzle sound
+		EmitSound( "BaseEMPableGrenade.Fizzle" );
+
+		// Smoke & Spark
+		g_pEffects->Sparks( GetAbsOrigin() );
+		UTIL_Smoke( GetAbsOrigin(), random->RandomInt( 4, 7), 10 );
+	}
+	else
+	{
+		Remove( );
+		return;
+	}
+
+	SetNextThink( gpGlobals->curtime + 0.1f );
+}
diff --git a/game/shared/tf2/grenade_base_empable.h b/game/shared/tf2/grenade_base_empable.h
new file mode 100644
index 0000000..3da030d
--- /dev/null
+++ b/game/shared/tf2/grenade_base_empable.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GRENADE_BASE_EMPABLE_H
+#define GRENADE_BASE_EMPABLE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basegrenade_shared.h"
+
+#if defined( CLIENT_DLL )
+#define CBaseEMPableGrenade C_BaseEMPableGrenade
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: EMP grenade
+//-----------------------------------------------------------------------------
+class CBaseEMPableGrenade : public CBaseGrenade
+{
+	DECLARE_CLASS( CBaseEMPableGrenade, CBaseGrenade );
+public:
+	DECLARE_PREDICTABLE();
+	DECLARE_NETWORKCLASS();
+
+#if !defined( CLIENT_DLL )
+	DECLARE_DATADESC();
+#endif
+
+	CBaseEMPableGrenade();
+
+	virtual bool	CanTakeEMPDamage( void ) { return true; }
+	virtual bool	TakeEMPDamage( float duration );
+	
+	void	FizzleThink( void );
+
+private:
+	CNetworkVar( float, m_flFizzleDuration );
+
+private:
+	CBaseEMPableGrenade( const CBaseEMPableGrenade & ); // not defined, not accessible
+
+};
+
+
+#endif // GRENADE_BASE_EMPABLE_H
diff --git a/game/shared/tf2/grenade_emp.cpp b/game/shared/tf2/grenade_emp.cpp
new file mode 100644
index 0000000..800c80f
--- /dev/null
+++ b/game/shared/tf2/grenade_emp.cpp
@@ -0,0 +1,343 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "basegrenade_shared.h"
+#include "engine/IEngineSound.h"
+#include "tf_shareddefs.h"
+#include "Sprite.h"
+#include "grenade_emp.h"
+#include "tf_gamerules.h"
+
+#if defined( CLIENT_DLL )
+
+#include "particles_simple.h"
+
+#else
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+int g_iEMPPulseEffectIndex = 0;
+
+// Damage CVars
+ConVar	weapon_emp_grenade_duration( "weapon_emp_grenade_duration","5", FCVAR_REPLICATED, "Duration of the EMP grenade's effect." );
+ConVar	weapon_emp_grenade_object_duration( "weapon_emp_grenade_object_duration","5", FCVAR_REPLICATED, "Duration of the EMP grenade's effect on objects." );
+ConVar	weapon_emp_grenade_radius( "weapon_emp_grenade_radius","256", FCVAR_REPLICATED, "EMP grenade splash radius" );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( GrenadeEMP, DT_GrenadeEMP );
+
+BEGIN_NETWORK_TABLE( CGrenadeEMP, DT_GrenadeEMP )
+#if !defined( CLIENT_DLL )
+	SendPropEHandle( SENDINFO( m_hLiveSprite ) ),
+#else
+	RecvPropEHandle( RECVINFO( m_hLiveSprite ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CGrenadeEMP )
+	DEFINE_PRED_FIELD( m_hLiveSprite, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( grenade_emp, CGrenadeEMP );
+PRECACHE_REGISTER(grenade_emp);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CGrenadeEMP::CGrenadeEMP()
+{
+	SetPredictionEligible( true );
+
+#if defined( CLIENT_DLL )
+	m_ParticleEvent.Init( 100 );
+#else
+	UseClientSideAnimation();
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::Precache( void )
+{
+	BaseClass::Precache( );
+
+	PrecacheModel( "models/weapons/w_grenade.mdl" );
+	PrecacheModel( "sprites/redglow1.vmt" );
+	g_iEMPPulseEffectIndex = PrecacheModel( "sprites/lgtning.spr" );
+
+	PrecacheScriptSound( "GrenadeEMP.Bounce" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::Spawn( void )
+{
+	Precache();
+
+	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
+	SetSolid( SOLID_BBOX );
+	//m_flGravity = 1.0;
+	SetFriction( 0.75 );
+	SetModel( "models/weapons/w_grenade.mdl" );
+	SetSize( Vector( -4, -4, -4), Vector(4, 4, 4) );
+	SetTouch( BounceTouch );
+	SetCollisionGroup( TFCOLLISION_GROUP_GRENADE );
+
+	m_flDetonateTime = gpGlobals->curtime + 4.0;
+	SetThink( TumbleThink );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	// Set my damages to the cvar values
+	SetDamage( weapon_emp_grenade_duration.GetFloat() );
+	SetDamageRadius( weapon_emp_grenade_radius.GetFloat() );
+
+	// Create a white light
+	CBasePlayer *player = ToBasePlayer( GetOwnerEntity() );
+	if ( player )
+	{
+		m_hLiveSprite = SPRITE_CREATE_PREDICTABLE( "sprites/chargeball2.vmt", GetLocalOrigin() + Vector(0,0,1), false );
+		if ( m_hLiveSprite )
+		{
+			m_hLiveSprite->SetOwnerEntity( player );
+			m_hLiveSprite->SetPlayerSimulated( player );
+			m_hLiveSprite->SetTransparency( kRenderGlow, 255, 255, 255, 128, kRenderFxNoDissipation );
+			m_hLiveSprite->SetBrightness( 255 );
+			m_hLiveSprite->SetScale( 0.15, 5.0f );
+			m_hLiveSprite->SetAttachment( this, 0 );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::UpdateOnRemove( void )
+{
+	// Remove our live sprite
+	if ( m_hLiveSprite )
+	{
+		m_hLiveSprite->Remove( );
+		m_hLiveSprite = NULL;
+	}
+
+	// Chain at end to mimic destructor unwind order
+	BaseClass::UpdateOnRemove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::Explode( trace_t *pTrace, int bitsDamageType )
+{
+#if !defined( CLIENT_DLL )
+	// While in scope, this will allow messages to pass through without being filtered.
+	CDisablePredictionFiltering dpf;
+
+	// Create EMP pulse effect
+	int iEmpRings = 4;
+	float fEmpDelay = 0.05f;
+	float delay = 0.0f;
+	float frac;
+	for ( int r = 0 ; r < iEmpRings; r++, delay += fEmpDelay )
+	{
+		frac = (float)( r )/(float)(iEmpRings - 1);
+
+		CBroadcastRecipientFilter filter;
+
+		// Since this doesn't fire on the client right now, ignore the culling of the local player
+		filter.SetIgnorePredictionCull( true );
+
+		te->BeamRingPoint( filter, delay, 
+			GetAbsOrigin() + Vector(0,0,32) ,  // origin
+			64.0f,					// start radius
+			weapon_emp_grenade_radius.GetFloat() * 2,					// end radius
+			g_iEMPPulseEffectIndex, 
+			0, // halo index
+			0, // start frame
+			2, // framerate
+			0.3f, //  life
+			25.0, // width
+			50, // spread
+			2, // amplitude
+			50 + ( 1-frac ) * 200, 
+			63, 
+			63 + 127 * frac, 
+			255 - frac * 127, 
+			20 );
+	}
+
+	ApplyRadiusEMPEffect( GetThrower(), GetAbsOrigin() + Vector(0,0,16) );
+	Remove( );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: EMP enemies around the grenade
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::ApplyRadiusEMPEffect( CBaseEntity *pOwner, const Vector& vecCenter )
+{
+	// Oh oh, owner is gone...
+	if ( !pOwner )
+		return;
+
+#if !defined( CLIENT_DLL )
+	CBaseEntity *pEntity = NULL;
+
+	for ( CEntitySphereQuery sphere( vecCenter, weapon_emp_grenade_radius.GetFloat() ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
+	{
+		// Ignore team members, and unaligned targets
+		if ( pOwner->InSameTeam( pEntity ) || pEntity->GetTeamNumber() == 0 )
+			continue;
+
+		if ( pEntity->IsSolidFlagSet( FSOLID_NOT_SOLID ) )
+			continue;
+
+		// Make sure it's not blocked by a shield or wall
+		trace_t tr;
+		if ( TFGameRules()->IsTraceBlockedByWorldOrShield( vecCenter, pEntity->WorldSpaceCenter(), this, DMG_PROBE, &tr ) )
+			continue;
+
+		if ( pEntity->CanBePoweredUp() )
+		{
+			// Is it an object?
+			if ( pEntity->Classify() == CLASS_MILITARY )
+			{
+				pEntity->AttemptToPowerup( POWERUP_EMP, weapon_emp_grenade_object_duration.GetFloat() );
+			}
+			else
+			{
+				pEntity->AttemptToPowerup( POWERUP_EMP, weapon_emp_grenade_duration.GetFloat() );
+			}
+		}
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Allow shield parry's
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::BounceTouch( CBaseEntity *pOther )
+{
+	Assert( pOther );
+	if ( !pOther->IsSolid() )
+		return;
+
+	BaseClass::BounceTouch( pOther );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Play a distinctive grenade bounce sound to warn nearby players
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::BounceSound( void )
+{
+	CPASAttenuationFilter filter( this, "GrenadeEMP.Bounce" );
+	filter.UsePredictionRules();
+	EmitSound( filter, entindex(), "GrenadeEMP.Bounce" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the amplitude for the screenshake
+//-----------------------------------------------------------------------------
+float CGrenadeEMP::GetShakeAmplitude( void )
+{
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a missile
+//-----------------------------------------------------------------------------
+CGrenadeEMP *CGrenadeEMP::Create( const Vector &vecOrigin, const Vector &vecForward, CBasePlayer *pOwner )
+{
+	CGrenadeEMP *pGrenade = (CGrenadeEMP*)CREATE_PREDICTED_ENTITY( "grenade_emp" );
+	if ( pGrenade )
+	{
+		UTIL_SetOrigin( pGrenade, vecOrigin );
+		pGrenade->SetOwnerEntity( pOwner );
+		pGrenade->Spawn();
+		pGrenade->SetPlayerSimulated( pOwner );
+		pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+
+		pGrenade->SetThrower( pOwner );
+
+		pGrenade->SetAbsVelocity( vecForward );
+
+		QAngle angles;
+		VectorAngles( vecForward, angles );
+		pGrenade->SetLocalAngles( angles );
+
+		pGrenade->SetLocalAngularVelocity( SHARED_RANDOMANGLE( -500, 500 ) );
+	}
+
+	return pGrenade;
+}
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Only think when sapping
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Trail smoke
+//-----------------------------------------------------------------------------
+void CGrenadeEMP::ClientThink( void )
+{
+return;
+
+	CSmartPtr<CSimpleEmitter> pEmitter = CSimpleEmitter::Create( "EMPGrenade::Effect" );
+	PMaterialHandle	hSphereMaterial = pEmitter->GetPMaterial( "sprites/chargeball" );
+
+	// Add particles at the target.
+	float flCur = gpGlobals->frametime;
+	while ( m_ParticleEvent.NextEvent( flCur ) )
+	{
+		Vector vecOrigin = GetAbsOrigin() + RandomVector( -2,2 );
+		pEmitter->SetSortOrigin( vecOrigin );
+
+		SimpleParticle *pParticle = (SimpleParticle *) pEmitter->AddParticle( sizeof(SimpleParticle), hSphereMaterial, vecOrigin );
+		if ( pParticle == NULL )
+			return;
+
+		pParticle->m_flLifetime	= 0.0f;
+		pParticle->m_flDieTime	= random->RandomFloat( 0.1f, 0.3f );
+
+		pParticle->m_uchStartSize	= random->RandomFloat(2,4);
+		pParticle->m_uchEndSize		= pParticle->m_uchStartSize + 2;
+
+		pParticle->m_vecVelocity = vec3_origin;
+		pParticle->m_uchStartAlpha = 128;
+		pParticle->m_uchEndAlpha = 0;
+		pParticle->m_flRoll	= random->RandomFloat( 180, 360 );
+		pParticle->m_flRollDelta = random->RandomFloat( -1, 1 );
+
+		pParticle->m_uchColor[0] = 128;
+		pParticle->m_uchColor[1] = 128;
+		pParticle->m_uchColor[2] = 128;
+	}
+}
+
+int CGrenadeEMP::DrawModel( int flags )
+{
+	bool bret = BaseClass::DrawModel( flags );
+
+	return bret;
+}
+
+#endif
+
diff --git a/game/shared/tf2/grenade_emp.h b/game/shared/tf2/grenade_emp.h
new file mode 100644
index 0000000..3ee68a4
--- /dev/null
+++ b/game/shared/tf2/grenade_emp.h
@@ -0,0 +1,82 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GRENADE_EMP_H
+#define GRENADE_EMP_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CSprite;
+
+#include "grenade_base_empable.h"
+
+#if defined( CLIENT_DLL )
+
+#define CGrenadeEMP C_GrenadeEMP
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: EMP grenade
+//-----------------------------------------------------------------------------
+class CGrenadeEMP : public CBaseEMPableGrenade
+{
+	DECLARE_CLASS( CGrenadeEMP, CBaseEMPableGrenade );
+public:
+	CGrenadeEMP();
+
+	DECLARE_PREDICTABLE();
+	DECLARE_NETWORKCLASS();
+
+	virtual void	Spawn( void );
+	virtual void	Precache( void );
+	virtual void	UpdateOnRemove( void );
+	virtual void	Explode( trace_t *pTrace, int bitsDamageType );
+	virtual void	BounceTouch( CBaseEntity *pOther );
+	virtual void	BounceSound( void );
+	virtual float	GetShakeAmplitude( void );
+	virtual int		GetDamageType() const { return DMG_BLAST; }
+
+	void	ApplyRadiusEMPEffect( CBaseEntity *pOwner, const Vector& vecCenter );
+	
+	static CGrenadeEMP *CGrenadeEMP::Create( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner );
+
+	// A derived class should return true here so that weapon sounds, etc, can
+	//  apply the proper filter
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetThrower() &&
+			GetThrower() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink( void );
+
+	TimedEvent		m_ParticleEvent;
+
+	virtual int			DrawModel( int flags );
+
+#endif
+
+private:
+	CNetworkHandle( CSprite, m_hLiveSprite );
+
+private:
+	CGrenadeEMP( const CGrenadeEMP & );
+};
+
+#endif // GRENADE_EMP_H
diff --git a/game/shared/tf2/grenade_limpetmine.cpp b/game/shared/tf2/grenade_limpetmine.cpp
new file mode 100644
index 0000000..098d626
--- /dev/null
+++ b/game/shared/tf2/grenade_limpetmine.cpp
@@ -0,0 +1,406 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "tf_basecombatweapon.h"
+#include "basegrenade_shared.h"
+#include "weapon_limpetmine.h"
+#include "engine/IEngineSound.h"
+#include "grenade_limpetmine.h"
+#include "tf_shareddefs.h"
+#include "IEffects.h"
+#include "player.h"
+#include "basetfvehicle.h"
+
+#define LIMPET_LIVE_TIME			0.5		// Time it takes before a limpet can be detonated after placement
+#define LIMPET_LIFETIME				120		// After this time, limpets fizzle naturally
+#define LIMPET_FIZZLE_DURATION		2.0f
+#define LIMPET_MINS					Vector(-5, -5, 0)
+#define LIMPET_MAXS					Vector( 5,  5, 10)
+
+// Damage CVars
+ConVar	weapon_limpetmine_grenade_damage( "weapon_limpetmine_grenade_damage","0", FCVAR_NONE, "Limpet Mine's grenade maximum damage" );
+ConVar	weapon_limpetmine_grenade_radius( "weapon_limpetmine_grenade_radius","0", FCVAR_NONE, "Limpet Mine's grenade splash radius" );
+
+// Global Savedata for friction modifier
+BEGIN_DATADESC( CLimpetMine )
+	// Function Pointers
+	DEFINE_THINKFUNC( LiveThink ),
+	DEFINE_ENTITYFUNC( StickyTouch ),
+	DEFINE_THINKFUNC( LimpetThink ),
+END_DATADESC()
+
+
+IMPLEMENT_SERVERCLASS_ST(CLimpetMine, DT_LimpetMine)
+	SendPropInt(SENDINFO(m_bLive), 1, SPROP_UNSIGNED ),
+END_SEND_TABLE()
+
+LINK_ENTITY_TO_CLASS( grenade_limpetmine, CLimpetMine );
+
+//-----------------------------------------------------------------------------
+// Static initializers: 
+//-----------------------------------------------------------------------------
+CLimpetMine*	CLimpetMine::allLimpets		= NULL;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CLimpetMine::CLimpetMine( void )
+{
+	UseClientSideAnimation();
+
+	// ---------------------------------
+	//  Add to linked list of limpets
+	// ---------------------------------
+	nextLimpet = CLimpetMine::allLimpets;
+	CLimpetMine::allLimpets = this;
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CLimpetMine::~CLimpetMine( void )
+{
+	// --------------------------------------
+	//  Remove from linked list of limpets
+	// --------------------------------------
+	CLimpetMine *pLimpet = CLimpetMine::allLimpets;
+	if (pLimpet == this)
+	{
+		CLimpetMine::allLimpets = pLimpet->nextLimpet;
+	}
+	else
+	{
+		while (pLimpet)
+		{
+			if (pLimpet->nextLimpet == this)
+			{
+				pLimpet->nextLimpet = pLimpet->nextLimpet->nextLimpet;
+				break;
+			}
+			pLimpet = pLimpet->nextLimpet;
+		}
+	}
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CLimpetMine::Precache( void )
+{
+	PrecacheModel( "models/projectiles/grenade_limpet.mdl" );
+	PrecacheScriptSound( "LimpetMine.Beep" );
+	PrecacheScriptSound( "LimpetMine.Fizzle" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CLimpetMine::Spawn( void )
+{
+	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
+	SetSolid( SOLID_BBOX );
+	SetGravity( 1.0 );
+	SetFriction( 1.25 );
+	SetModel( "models/projectiles/grenade_limpet.mdl");
+	UTIL_SetSize( this, LIMPET_MINS, LIMPET_MAXS );
+	m_bLive = false;
+	m_bFizzleInit = false;
+	m_bEMPed = false;
+	SetThink( LiveThink );
+	SetNextThink( gpGlobals->curtime + LIMPET_LIVE_TIME );
+	SetTouch( StickyTouch );
+
+	// Causes these to collide with everything but NPCs and players
+	SetCollisionGroup( TFCOLLISION_GROUP_GRENADE );
+
+	AddFlag( FL_OBJECT ); 
+	// Prevent sentry guns detecting these.
+	AddFlag( FL_NOTARGET );
+
+	// Set my damages to the cvar values
+	SetDamage( weapon_limpetmine_grenade_damage.GetFloat() );
+	SetDamageRadius( weapon_limpetmine_grenade_radius.GetFloat() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this limpet mine can be detonated yet
+//-----------------------------------------------------------------------------
+bool CLimpetMine::IsLive( void )
+{
+	return m_bLive;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CLimpetMine::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	Assert( pCaller );
+
+	// USE_SET Means we're being asked to fizzle out and dielf
+	if ( useType == USE_SET )
+	{
+		if ( !m_bFizzleInit )
+		{
+			// Set the defuse - fizzle think
+			m_flFizzleDuration = gpGlobals->curtime + 0.3;
+			SetThink( LimpetThink );
+			SetNextThink( gpGlobals->curtime + 0.1f );
+			m_bFizzleInit = true;
+		}
+	}
+	else if ( IsLive() )
+	{
+		// Get the TF2 player that owns this limpet:
+		CBaseTFPlayer *pPlayer = NULL;
+		if ( m_hLauncher )
+		{
+			pPlayer = ToBaseTFPlayer( m_hLauncher->GetOwner() );
+		}
+
+		// Get the TF2 player that is calling this object, if any:
+		CBaseTFPlayer *pCallerPlayer = NULL;
+		if ( pCaller )
+		{
+			pCallerPlayer = ToBaseTFPlayer( pCaller );
+		}
+
+		// If the owning player is directly using the limpet, then pick it up:
+		if( pPlayer && pCallerPlayer && pPlayer->IsSameClass( pCallerPlayer ) )
+		{	
+			if ( m_hLauncher )
+			{
+				pPlayer->GiveAmmo( 1, m_hLauncher->m_iPrimaryAmmoType );
+				m_hLauncher->DecrementLimpets();
+			}
+			UTIL_Remove( this );
+		}
+		else if ( pActivator && !pActivator->InSameTeam( this ) )
+		{
+			// only the owning player can detonate his own limpets, so return if this isn't the owner.
+			return;
+		}
+
+		// We're being detonated
+
+		// If are EMPed then we cannot be detonated.
+		else if ( !IsEMPed() )
+		{
+			// Beep and detonate soon afterwards
+			EmitSound( "LimpetMine.Beep" );
+
+			SetThink( Detonate );
+			SetNextThink( gpGlobals->curtime + 0.5f );
+
+			// Pretend I'm not live anymore so I don't get exploded again
+			m_bLive = false;
+
+			if ( m_hLauncher )
+			{
+				m_hLauncher->DecrementLimpets();
+			}
+
+		}
+
+
+	}
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CLimpetMine::TakeEMPDamage( float duration )
+{
+	if ( !m_bFizzleInit )
+	{
+		// Set the defuse - fizzle think
+		float flDuration = MIN( duration, LIMPET_FIZZLE_DURATION );
+		m_flFizzleDuration = gpGlobals->curtime + ( flDuration - 1.0f );
+		SetThink( LimpetThink );
+		SetNextThink( gpGlobals->curtime + 0.1f );
+		m_bFizzleInit = true;
+		m_bEMPed = true;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a limpet mine
+//-----------------------------------------------------------------------------
+CLimpetMine* CLimpetMine::Create( const Vector &vecOrigin, const Vector &vecForward, CBasePlayer *pOwner )
+{
+	CLimpetMine *pGrenade = (CLimpetMine*)CreateEntityByName("grenade_limpetmine");
+
+	pGrenade->Teleport( &vecOrigin, NULL, NULL );
+	pGrenade->Spawn();
+	pGrenade->SetOwnerEntity( pOwner );
+	pGrenade->SetThrower( pOwner );
+	pGrenade->SetAbsVelocity( vecForward );
+	pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+
+	return pGrenade;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Keep a pointer to the launcher (parent)
+//-----------------------------------------------------------------------------
+void CLimpetMine::SetLauncher( CWeaponLimpetmine *pLauncher )
+{
+	m_hLauncher = pLauncher;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Go Live
+//-----------------------------------------------------------------------------
+void CLimpetMine::LiveThink( void )
+{
+	m_bLive = true;
+
+	// Remove myself after a while
+	m_flFizzleDuration = gpGlobals->curtime + LIMPET_LIFETIME + 0.3;
+	SetNextThink( gpGlobals->curtime + 0.1f );
+	SetThink( LimpetThink );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Make the grenade stick to whatever it touches
+//-----------------------------------------------------------------------------
+void CLimpetMine::StickyTouch( CBaseEntity *pOther )
+{
+	Assert( pOther );
+	if ( !pOther->IsSolid() )
+		return;
+
+	if ( !pOther->IsBSPModel() && !pOther->GetBaseAnimating() )
+		return;
+
+	BounceSound();
+	m_bStuckToTarget = false;
+
+	// Bounce off of shields
+	if ( pOther->GetCollisionGroup() == TFCOLLISION_GROUP_SHIELD )
+	{
+		// Move away from the shield...
+		// Fling it out a little extra along the plane normal
+		Vector vecNewVelocity;
+		Vector vecCenter;
+		AngleVectors( pOther->GetAbsAngles(), &vecCenter );
+		VectorMultiply( vecCenter, 400.0f, vecNewVelocity );
+		SetAbsVelocity( vecNewVelocity );
+		return;
+	}
+
+	// Only stick to non-moving entities
+	if ( !pOther->GetBaseAnimating() )
+		return;
+
+	// Don't stick to team members
+	if ( InSameTeam( pOther ) )
+		return;
+
+	// ROBIN: Removed stick to enemies for now
+ 	{
+ 		SetAbsVelocity( vec3_origin );
+ 		SetMoveType( MOVETYPE_NONE );
+ 		return;
+	}
+
+	m_bStuckToTarget = true;
+
+	// Orient to stick to the wall I just hit
+	trace_t tr;
+	Vector vecPrev = GetLocalOrigin() - (GetAbsVelocity() * 0.1);
+	UTIL_TraceLine( vecPrev, vecPrev + (GetAbsVelocity() * 2), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
+	if ( tr.fraction != 1 )
+	{
+		// Orient the *up* axis to be along the plane normal
+		Vector perp( 1, 0, 0 );
+		Vector forward, right;
+		CrossProduct( perp, tr.plane.normal, forward );
+		if (forward.LengthSqr() < 0.1f)
+		{
+			perp.Init( 0, 1, 0 );
+			CrossProduct( perp, tr.plane.normal, forward );
+		}
+		VectorNormalize( forward );
+		CrossProduct( tr.plane.normal, forward, right );
+
+		VMatrix orientation( forward, right, tr.plane.normal );
+
+		QAngle angles;
+		MatrixToAngles( orientation, angles );
+		SetAbsAngles( angles );
+	}
+
+	SetAbsVelocity( vec3_origin );
+	SetMoveType( MOVETYPE_NONE );
+
+	// At this point, it shouldn't affect player movement
+	SetCollisionGroup( COLLISION_GROUP_DEBRIS );
+	BounceSound();
+
+	SetParent( pOther );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Once the limpet's active, it starts running this
+//-----------------------------------------------------------------------------
+void CLimpetMine::LimpetThink( void )
+{
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	// If I'm not ready to fizzle yet, make sure my parent's still there.
+	if ( m_bStuckToTarget )
+	{
+		// Lost our parent?
+		if ( !GetMoveParent() )
+		{
+			m_bStuckToTarget = false;
+			// Fall to the ground
+			SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );
+			SetTouch( StickyTouch );
+		}
+	}
+
+	float flDeltaTime = m_flFizzleDuration - gpGlobals->curtime;
+
+	// Not ready to fizzle yet?
+	if ( flDeltaTime > 0.3 )
+		return;
+
+	// Start fizzling
+	if ( flDeltaTime > 0.0f )
+	{
+		// Emit a fizzle sound
+		EmitSound( "LimpetMine.Fizzle" );
+
+		g_pEffects->Sparks( GetAbsOrigin() );
+
+		// Smoke.
+		UTIL_Smoke( GetAbsOrigin(), random->RandomInt( 1, 3), 10 );
+	}
+	else
+	{
+		// Done fizzling - no more sound.
+		StopSound( "LimpetMine.Fizzle" );
+		UTIL_Remove( this );
+
+		// Remove this limpet mine from the launcher deployment count.
+		if ( m_hLauncher )
+		{
+			m_hLauncher->DecrementLimpets();
+		}
+
+		return;
+	}
+}
diff --git a/game/shared/tf2/grenade_limpetmine.h b/game/shared/tf2/grenade_limpetmine.h
new file mode 100644
index 0000000..426df4b
--- /dev/null
+++ b/game/shared/tf2/grenade_limpetmine.h
@@ -0,0 +1,70 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GRENADE_LIMPETMINE_H
+#define GRENADE_LIMPETMINE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CWeaponLimpetmine;
+
+//=====================================================================================================
+// LIMPET MINE
+//=====================================================================================================
+class CLimpetMine : public CBaseGrenade
+{
+	DECLARE_CLASS( CLimpetMine, CBaseGrenade );
+
+public:
+	DECLARE_SERVERCLASS();
+	DECLARE_DATADESC();
+
+	CLimpetMine( void );
+	virtual ~CLimpetMine( void );
+
+	// Creation and Initialization
+	virtual void	Spawn( void );
+	virtual void	Precache( void );
+	static CLimpetMine* CLimpetMine::Create( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner );
+	virtual int		GetDamageType() const { return DMG_BLAST; }
+	virtual bool	CanBePoweredUp( void ) { return false; }
+
+	// Detonation
+	virtual void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+	bool			IsLive( void );
+	virtual int	    ObjectCaps( void ) { return BaseClass::ObjectCaps() | FCAP_IMPULSE_USE; }
+
+	// EMP
+	virtual bool	CanTakeEMPDamage() { return true; }
+	virtual bool	TakeEMPDamage( float duration );	
+	bool			IsEMPed( void ) { return m_bEMPed; }
+
+	// Think and Touch
+	void			LiveThink( void );
+	void			StickyTouch( CBaseEntity *pOther );
+	void			LimpetThink( void );
+
+	// Parent
+	void			SetLauncher( CWeaponLimpetmine *pLauncher );
+
+public:
+	static CLimpetMine* allLimpets;				// A linked list of all limpets
+	CLimpetMine*		nextLimpet;				// The next limpet in list of all limpets
+
+
+	CNetworkVar( bool, m_bLive );					// are we active?
+	bool				m_bStuckToTarget;			// If true, the limpet stuck to something when it went active
+	bool				m_bEMPed;					// have we been EMPed?
+	bool				m_bFizzleInit;				// initialize the fizzle (EMP) process
+	float				m_flFizzleDuration;			// fizzle duration
+
+	CHandle<CWeaponLimpetmine> m_hLauncher;				// parent (weapon launched from)
+
+};
+
+#endif // GRENADE_LIMPETMINE_H
diff --git a/game/shared/tf2/grenade_objectsapper.cpp b/game/shared/tf2/grenade_objectsapper.cpp
new file mode 100644
index 0000000..5975d35
--- /dev/null
+++ b/game/shared/tf2/grenade_objectsapper.cpp
@@ -0,0 +1,211 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "player.h"
+#include "tf_obj.h"
+#include "basegrenade_shared.h"
+#include "grenade_objectsapper.h"
+#include "engine/IEngineSound.h"
+
+// Damage CVars
+static ConVar	weapon_objectsapper_damage( "weapon_objectsapper_damage","50", FCVAR_NONE, "Damage done, per second, by the object sapper." );
+
+// Global Savedata for friction modifier
+BEGIN_DATADESC( CGrenadeObjectSapper )
+
+	// Function Pointers
+	DEFINE_THINKFUNC( SapperThink ),
+
+END_DATADESC()
+
+IMPLEMENT_SERVERCLASS_ST(CGrenadeObjectSapper, DT_GrenadeObjectSapper)
+	SendPropInt(SENDINFO(m_bSapping), 1, SPROP_UNSIGNED ),
+END_SEND_TABLE();
+
+LINK_ENTITY_TO_CLASS( grenade_objectsapper, CGrenadeObjectSapper );
+PRECACHE_WEAPON_REGISTER(grenade_objectsapper);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeObjectSapper::Spawn( void )
+{
+	SetMoveType( MOVETYPE_NONE );
+	SetSolid( SOLID_BBOX );
+	AddSolidFlags( FSOLID_NOT_SOLID );
+	SetGravity( 0.0 );
+	SetFriction( 1.0 );
+	SetModel( "models/sapper.mdl");
+	UTIL_SetSize(this, Vector( -8, -8, -8), Vector(8, 8, 8));
+	SetCollisionGroup( TFCOLLISION_GROUP_WEAPON );
+	m_takedamage = DAMAGE_NO;
+	m_iHealth = 50.0;
+	m_bSapping = false;
+	
+	// Set my damages to the cvar values
+	SetDamage( weapon_objectsapper_damage.GetFloat() * 0.1 );
+	SetDamageRadius( 0 );
+
+	SetTouch( NULL );
+	SetThink( SapperThink );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	m_bArmed = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CGrenadeObjectSapper::Precache( void )
+{
+	PrecacheModel( "models/sapper.mdl" );
+
+	PrecacheScriptSound( "GrenadeObjectSapper.Arming" );
+	PrecacheScriptSound( "GrenadeObjectSapper.RemoveSapper" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeObjectSapper::PlayArmingSound( void )
+{
+	EmitSound( "GrenadeObjectSapper.Arming" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : armed - 
+//-----------------------------------------------------------------------------
+void CGrenadeObjectSapper::SetArmed( bool armed )
+{
+	bool ch = armed != m_bArmed;
+	m_bArmed = armed;
+
+	// Going armed
+	if ( ch && m_bArmed )
+	{
+		PlayArmingSound();
+	}
+
+	if ( m_bArmed )
+	{
+		RemoveEffects( EF_NODRAW );
+	}
+	else
+	{
+		AddEffects( EF_NODRAW );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CGrenadeObjectSapper::GetArmed( void ) const
+{
+	return m_bArmed;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sap the health from the object I'm attached to
+//-----------------------------------------------------------------------------
+void CGrenadeObjectSapper::SapperThink( void )
+{
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	// Not armed yet?
+	if ( !GetArmed() )
+		return;
+
+	// Remove myself if I'm armed, but don't have an object to sap
+	if ( !m_hTargetObject )
+	{
+		UTIL_Remove( this );
+		return;
+	}
+
+	m_bSapping = true;
+
+	// Damage our target (add DMG_CRUSH to prevent physics damage)
+	m_hTargetObject->TakeDamage( CTakeDamageInfo( this, GetThrower(), GetDamage(), GetDamageType() | DMG_CRUSH ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set our target object
+//-----------------------------------------------------------------------------
+void CGrenadeObjectSapper::SetTargetObject( CBaseObject *pObject )
+{
+	// Remove myself from any object I'm on
+	if ( m_hTargetObject != pObject )
+	{
+		if ( m_hTargetObject.Get() )
+		{
+			m_hTargetObject->RemoveSapper( this );
+			SetParent( NULL );
+		}
+
+		m_hTargetObject = pObject;
+
+		// Tell any object I've just been attached to
+		if ( m_hTargetObject )
+		{
+			m_hTargetObject->AddSapper( this );
+			SetParent( m_hTargetObject );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Allow players to remove sappers from objects
+//-----------------------------------------------------------------------------
+void CGrenadeObjectSapper::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
+{
+	// Only enemies remove the sapper
+	if ( !InSameTeam( pActivator ) )
+	{
+		// Enemy is grabbing me
+		EmitSound( "GrenadeObjectSapper.RemoveSapper" );
+		SetTargetObject( NULL );
+		UTIL_Remove( this );
+	}
+/*	
+	ROBIN: Removed self-removal of sapper
+
+	else
+	{
+		// Ignore everyone except my owner
+		if ( pPlayer != m_hOwner )
+			return;
+		if ( pPlayer->GiveAmmo( 1, "Sappers") )
+		{
+			// Picked up, remove me
+			SetTargetObject( NULL );
+			UTIL_Remove( this );
+		}
+	}
+*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create an object sapper grenade
+//-----------------------------------------------------------------------------
+CGrenadeObjectSapper *CGrenadeObjectSapper::Create( const Vector &vecOrigin, const Vector &vecForward, CBasePlayer *pOwner, CBaseObject *pObject )
+{
+	CGrenadeObjectSapper *pGrenade = (CGrenadeObjectSapper*)CreateEntityByName("grenade_objectsapper");
+
+	UTIL_SetOrigin( pGrenade, vecOrigin );
+	pGrenade->Spawn();
+	pGrenade->SetThrower( pOwner );
+	pGrenade->SetAbsVelocity( vec3_origin );
+	QAngle angles;
+	VectorAngles( vecForward, angles );
+	angles.x -= 90;
+	pGrenade->SetLocalAngles( angles );
+	pGrenade->ChangeTeam( pOwner->GetTeamNumber() );
+	
+	return pGrenade;
+}
diff --git a/game/shared/tf2/grenade_objectsapper.h b/game/shared/tf2/grenade_objectsapper.h
new file mode 100644
index 0000000..8984a21
--- /dev/null
+++ b/game/shared/tf2/grenade_objectsapper.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GRENADE_OBJECTSAPPER_H
+#define GRENADE_OBJECTSAPPER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CBaseObject;
+
+//-----------------------------------------------------------------------------
+// Purpose: Object sapper grenade
+//-----------------------------------------------------------------------------
+class CGrenadeObjectSapper : public CBaseGrenade
+{
+	DECLARE_CLASS( CGrenadeObjectSapper, CBaseGrenade );
+public:
+	DECLARE_DATADESC();
+	DECLARE_SERVERCLASS();
+
+	virtual void	Spawn( void );
+	virtual void	Precache( void );
+	virtual int		GetDamageType() const { return DMG_BLAST; }
+	virtual void	SapperThink( void );
+	void			SetTargetObject( CBaseObject *pObject );
+
+	void			SetArmed( bool armed );
+	bool			GetArmed( void ) const;
+
+	void			PlayArmingSound( void );
+
+	// Pickup
+	virtual int		ObjectCaps( void ) { return FCAP_IMPULSE_USE; };
+	virtual void	Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
+
+	static CGrenadeObjectSapper *CGrenadeObjectSapper::Create( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner, CBaseObject *pObject );
+
+public:
+	CNetworkVar( bool, m_bSapping );
+	CHandle<CBaseObject>	m_hTargetObject;
+
+	bool					m_bArmed;
+};
+
+#endif // GRENADE_OBJECTSAPPER_H
diff --git a/game/shared/tf2/grenade_rocket.cpp b/game/shared/tf2/grenade_rocket.cpp
new file mode 100644
index 0000000..881ed74
--- /dev/null
+++ b/game/shared/tf2/grenade_rocket.cpp
@@ -0,0 +1,176 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "engine/IEngineSound.h"
+#include "grenade_rocket.h"
+
+extern short	g_sModelIndexFireball;
+
+IMPLEMENT_SERVERCLASS_ST( CGrenadeRocket, DT_GrenadeRocket)
+END_SEND_TABLE()
+
+BEGIN_DATADESC( CGrenadeRocket )
+
+	DEFINE_FIELD( m_flDamage, FIELD_FLOAT ),
+
+	// Function Pointers
+	DEFINE_FUNCTION( MissileTouch ),
+	DEFINE_FUNCTION( FollowThink ),
+
+END_DATADESC()
+LINK_ENTITY_TO_CLASS( grenade_rocket, CGrenadeRocket );
+PRECACHE_REGISTER(grenade_rocket);
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CGrenadeRocket::CGrenadeRocket()
+{
+	m_pRealOwner = NULL;
+	m_hLockTarget = NULL;
+	UseClientSideAnimation();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CGrenadeRocket::Precache( void )
+{
+	PrecacheModel( "models/weapons/w_missile.mdl" );
+
+	PrecacheScriptSound( "GrenadeRocket.FlyLoop" );
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeRocket::Spawn( void )
+{
+	Precache();
+
+	SetMoveType( MOVETYPE_FLY );
+	SetSolid( SOLID_BBOX );
+	SetModel( "models/weapons/w_missile.mdl" );
+	UTIL_SetSize( this, vec3_origin, vec3_origin );
+
+	SetCollisionGroup( TFCOLLISION_GROUP_WEAPON );
+	SetTouch( MissileTouch );
+
+	SetDamage( 50 );
+
+	// Forward!
+	Vector forward;
+	AngleVectors( GetLocalAngles(), &forward, NULL, NULL );
+	SetAbsVelocity( forward * ROCKET_VELOCITY );
+
+	EmitSound( "GrenadeRocket.FlyLoop" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeRocket::MissileTouch( CBaseEntity *pOther )
+{
+	Assert( pOther );
+	if ( !pOther->IsSolid() )
+		return;
+
+	Vector vecAbsOrigin = GetAbsOrigin();
+	CPASFilter filter( vecAbsOrigin );
+	te->Explosion( filter, 0.0,	&vecAbsOrigin, g_sModelIndexFireball, 2.0, 15, TE_EXPLFLAG_NONE, 100, m_flDamage );
+
+	StopSound( "GrenadeRocket.FlyLoop" );
+
+	// Don't apply explosive damage if it hit a shield of any kind...
+	bool bHittingShield = false;
+	if (pOther->GetCollisionGroup() == TFCOLLISION_GROUP_SHIELD)
+	{
+		bHittingShield = true;
+	}
+	else if ( pOther->IsPlayer() )
+	{
+		CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>(pOther);
+
+		trace_t tr;
+		float flDamage = m_flDamage;
+		bHittingShield = pPlayer->IsHittingShield( GetAbsVelocity(), &flDamage );
+	}
+
+	if (!bHittingShield)
+	{
+		RadiusDamage( CTakeDamageInfo( this, m_pRealOwner, m_flDamage, DMG_BLAST ), vecAbsOrigin, 100, CLASS_NONE, NULL );
+	}
+
+	UTIL_Remove( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Make this rocket lock onto it's target and track it
+//-----------------------------------------------------------------------------
+void CGrenadeRocket::LockOnto( CBaseEntity *pTarget )
+{
+	m_hLockTarget = pTarget;
+	SetThink( FollowThink );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Try and turn towards the target point
+//-----------------------------------------------------------------------------
+void CGrenadeRocket::FollowThink( void )
+{
+	if ( m_hLockTarget == NULL )
+		return;
+
+	// Weave slightly drunkenly to target
+	Vector vecTarget = m_hLockTarget->GetAbsOrigin() - GetLocalOrigin();
+	VectorNormalize( vecTarget );
+
+	QAngle angles;
+	VectorAngles( vecTarget, angles );
+	SetLocalAngles( angles );
+	
+	Vector vecVelocity = GetAbsVelocity();
+	float flSpeed = vecVelocity.Length();
+	vecVelocity = vecVelocity * 0.2 + vecTarget * flSpeed * 1.2;
+	// Clip to maxspeed
+	if ( vecVelocity.Length() > ROCKET_VELOCITY )
+	{
+		VectorNormalize( vecVelocity );
+		vecVelocity *= ROCKET_VELOCITY;
+	}
+	SetAbsVelocity( vecVelocity );
+
+	SetNextThink( gpGlobals->curtime + 0.1f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a missile
+//-----------------------------------------------------------------------------
+CGrenadeRocket *CGrenadeRocket::Create( const Vector &vecOrigin, const Vector &vecForward, edict_t *pentOwner = NULL, CBaseEntity *pRealOwner = NULL )
+{
+	CGrenadeRocket *pRocket = (CGrenadeRocket *)CreateEntityByName("grenade_rocket" );
+
+	UTIL_SetOrigin( pRocket, vecOrigin );
+	QAngle angles;
+	VectorAngles( vecForward, angles );
+	pRocket->SetLocalAngles( angles );
+	pRocket->Spawn();
+	pRocket->SetOwnerEntity( Instance( pentOwner ) );
+	pRocket->m_pRealOwner = pRealOwner;
+
+	if (pentOwner)
+	{
+		CBaseEntity *pOwnerEnt = GetContainingEntity( pentOwner );
+		pRocket->ChangeTeam( pOwnerEnt->GetTeamNumber() );
+	}
+
+	return pRocket;
+}
diff --git a/game/shared/tf2/grenade_rocket.h b/game/shared/tf2/grenade_rocket.h
new file mode 100644
index 0000000..e3f7d56
--- /dev/null
+++ b/game/shared/tf2/grenade_rocket.h
@@ -0,0 +1,60 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef GRENADE_ROCKET_H
+#define GRENADE_ROCKET_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define ROCKET_VELOCITY			1000
+
+//====================================================================================
+// Purpose: ROCKET LAUNCHER SENTRYGUN'S ROCKETS
+//====================================================================================
+class CGrenadeRocket : public CBaseAnimating
+{
+	DECLARE_CLASS( CGrenadeRocket, CBaseAnimating );
+public:
+
+	DECLARE_DATADESC();
+	DECLARE_SERVERCLASS();
+
+	CGrenadeRocket();
+
+	void Spawn( void );
+	void Precache( void );
+	void MissileTouch( CBaseEntity *pOther );
+	void LockOnto( CBaseEntity *pTarget );
+	void FollowThink( void );
+
+	// Damage accessors.
+	virtual float GetDamage(void)
+	{
+		return m_flDamage;
+	}
+	
+	virtual void SetDamage(float flDamage)
+	{
+		m_flDamage = flDamage;
+	}
+
+	virtual int GetDamageType() const
+	{
+		return DMG_BLAST;
+	}
+
+	static CGrenadeRocket *CGrenadeRocket::Create( const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner, CBaseEntity *pRealOwner );
+
+public:
+	EHANDLE		m_hLockTarget;
+	EHANDLE		m_hOwner;
+	EHANDLE		m_pRealOwner;
+	float		m_flDamage;
+};
+
+#endif // GRENADE_ROCKET_H
diff --git a/game/shared/tf2/grenade_stickybomb.cpp b/game/shared/tf2/grenade_stickybomb.cpp
new file mode 100644
index 0000000..dfadbdc
--- /dev/null
+++ b/game/shared/tf2/grenade_stickybomb.cpp
@@ -0,0 +1,129 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Sticky bombs thrown by the recon
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "player.h"
+#include "basegrenade_shared.h"
+#include "tf_shareddefs.h"
+#include "Sprite.h"
+
+
+// Damage CVars
+ConVar	grenade_stickybomb_damage( "grenade_stickybomb_damage","0", 0, "Recon's stickybomb maximum damage" );
+ConVar	grenade_stickybomb_radius( "grenade_stickybomb_radius","0", 0, "Recon's stickybomb splash radius" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CGrenadeStickyBomb : public CBaseGrenade
+{
+	DECLARE_CLASS( CGrenadeStickyBomb, CBaseGrenade );
+public:
+	CGrenadeStickyBomb();
+
+	DECLARE_DATADESC();
+
+	void Spawn( void );
+	void Precache( void );
+	void SetTimer( float timer );
+	void StickyTouch( CBaseEntity *pOther );
+	virtual void	Explode( trace_t *pTrace, int bitsDamageType );
+	virtual int		GetDamageType() const { return DMG_BLAST; }
+
+private:
+	CSprite		*m_pLiveSprite;
+};
+
+// Global Savedata for friction modifier
+BEGIN_DATADESC( CGrenadeStickyBomb )
+
+	// Function Pointers
+	DEFINE_ENTITYFUNC( StickyTouch ),
+
+END_DATADESC()
+
+
+LINK_ENTITY_TO_CLASS( grenade_stickybomb, CGrenadeStickyBomb );
+PRECACHE_WEAPON_REGISTER(grenade_stickybomb);
+
+CGrenadeStickyBomb::CGrenadeStickyBomb()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CGrenadeStickyBomb::Precache( void )
+{
+	PrecacheModel( "models/weapons/w_grenade.mdl" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeStickyBomb::Spawn( void )
+{
+	Precache();
+
+	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
+	SetSolid( SOLID_BBOX );
+	SetGravity( 0.6 );
+	SetFriction( 1.0 );
+	SetModel( "models/weapons/w_grenade.mdl");
+	UTIL_SetSize(this, Vector( -4, -4, -4), Vector(4, 4, 4));
+	SetTouch( StickyTouch );
+	SetCollisionGroup( TFCOLLISION_GROUP_WEAPON );
+
+	// Create a red light
+	m_pLiveSprite = CSprite::SpriteCreate( "sprites/redglow1.vmt", GetLocalOrigin(), false );
+	m_pLiveSprite->SetTransparency( kRenderGlow, 255, 200, 200, 255, kRenderFxNoDissipation );
+	m_pLiveSprite->SetBrightness( 255 );
+	m_pLiveSprite->SetScale( 0.3 );
+	m_pLiveSprite->SetAttachment( this, 0 );
+
+	// Set my damages to the cvar values
+	SetDamage( grenade_stickybomb_damage.GetFloat() );
+	SetDamageRadius( grenade_stickybomb_radius.GetFloat() );
+
+	SetTimer( 2.0 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CGrenadeStickyBomb::SetTimer( float timer )
+{
+	SetThink( Detonate );
+	SetNextThink( gpGlobals->curtime + timer );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Make the grenade stick to whatever it touches
+//-----------------------------------------------------------------------------
+void CGrenadeStickyBomb::StickyTouch( CBaseEntity *pOther )
+{
+	if ( pOther->IsBSPModel() == false )
+		return;
+
+	BounceSound();
+	SetAbsVelocity( vec3_origin );
+	SetMoveType( MOVETYPE_NONE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove my glow when I'm removed
+//-----------------------------------------------------------------------------
+void CGrenadeStickyBomb::Explode( trace_t *pTrace, int bitsDamageType )
+{
+	if ( m_pLiveSprite )
+	{
+		UTIL_Remove( m_pLiveSprite );
+		m_pLiveSprite = NULL;
+	}
+
+	BaseClass::Explode( pTrace, bitsDamageType );
+}
diff --git a/game/shared/tf2/ihasbuildpoints.h b/game/shared/tf2/ihasbuildpoints.h
new file mode 100644
index 0000000..bb24d74
--- /dev/null
+++ b/game/shared/tf2/ihasbuildpoints.h
@@ -0,0 +1,60 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef IHASBUILDPOINTS_H
+#define IHASBUILDPOINTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CBaseObject;
+
+// Derive from this interface if your entity can have objects placed on build points on it
+class IHasBuildPoints
+{
+public:
+	// Tell me how many build points you have
+	virtual int			GetNumBuildPoints( void ) const = 0;
+
+	// Give me the origin & angles of the specified build point
+	virtual bool		GetBuildPoint( int iPoint, Vector &vecOrigin, QAngle &vecAngles ) = 0;
+
+	// If the build point wants to parent built objects to an attachment point on the entity,
+	// it'll return a value >= 1 here specifying which attachment to sit on.
+	virtual int			GetBuildPointAttachmentIndex( int iPoint ) const = 0;
+
+	// Can I build the specified object on the specified build point?
+	virtual bool		CanBuildObjectOnBuildPoint( int iPoint, int iObjectType ) = 0;
+
+	// I've finished building the specified object on the specified build point
+	virtual void		SetObjectOnBuildPoint( int iPoint, CBaseObject *pObject ) = 0;
+
+	// Get the number of objects build on this entity
+	virtual int			GetNumObjectsOnMe( void ) = 0;
+
+	// Get the first object that's built on me
+	virtual CBaseEntity	*GetFirstObjectOnMe( void ) = 0;
+
+	// Get the first object of type, return NULL if no such type available
+	virtual CBaseObject *GetObjectOfTypeOnMe( int iObjectType ) = 0;
+
+	// Remove all objects built on me
+	virtual void		RemoveAllObjects( void ) = 0;
+
+	// Return the maximum distance that this entity's build points can be snapped to
+	virtual float		GetMaxSnapDistance( int iPoint ) = 0;
+
+	// Return true if it's possible that build points on this entity may move in local space (i.e. due to animation)
+	virtual bool		ShouldCheckForMovement( void ) = 0;
+
+	// I've finished building the specified object on the specified build point
+	virtual int			FindObjectOnBuildPoint( CBaseObject *pObject ) = 0;
+
+	// Returns an exit point for a vehicle built on a build point...
+	virtual void		GetExitPoint( CBaseEntity *pPlayer, int iPoint, Vector *pAbsOrigin, QAngle *pAbsAngles ) = 0;
+};
+
+#endif // IHASBUILDPOINTS_H
diff --git a/game/shared/tf2/plasmaprojectile.cpp b/game/shared/tf2/plasmaprojectile.cpp
new file mode 100644
index 0000000..d2d5ce4
--- /dev/null
+++ b/game/shared/tf2/plasmaprojectile.cpp
@@ -0,0 +1,843 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "plasmaprojectile.h"
+//#include "smoke_trail.h"
+#include "basecombatweapon_shared.h"
+#include "tf_shareddefs.h"
+#if !defined( CLIENT_DLL )
+#include "tf_shield.h"
+#else
+#include "c_tracer.h"
+#include "hud.h"
+#include "view.h"
+#include "c_te_effect_dispatch.h"
+#endif
+#include "IEffects.h"
+//#include "tf_player.h"
+#include "basetfplayer_shared.h"
+#include "engine/IEngineSound.h"
+#include "worldsize.h"
+#include "tf_gamerules.h"
+#include "ammodef.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+extern ConVar tf_knockdowntime;
+
+#define PLASMA_LIFETIME				2.0
+
+// Time intervals at which we should simulate plasma projectiles
+#define PLASMA_SIM_DELTA			0.01
+#define PLASMA_VELOCITY_SQR			(PLASMA_VELOCITY*PLASMA_VELOCITY)
+
+#if defined( CLIENT_DLL )
+	ConVar	shot_width( "shot_width","8", 0, "Shot" );
+	ConVar	shot_length( "shot_length","140", 0, "Shot" );
+	ConVar	shot_head_size( "shot_head_size","6", 0, "Shot" );
+#endif
+
+#if !defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: PLASMA PROJECTILE
+//-----------------------------------------------------------------------------
+BEGIN_DATADESC( CBasePlasmaProjectile )
+
+	DEFINE_FIELD( m_flDamage, FIELD_FLOAT ),
+
+	// Function Pointers
+	DEFINE_ENTITYFUNC( MissileTouch ),
+
+END_DATADESC()
+#endif
+
+BEGIN_NETWORK_TABLE_NOBASE( CPlasmaProjectileShared, DT_PlasmaProjectileShared )
+#if !defined( CLIENT_DLL )
+	// These are parameters that are used to generate the entire motion
+	SendPropVector(SENDINFO(m_vecSpawnPosition), 0, SPROP_COORD),
+	SendPropVector(SENDINFO(m_vTracerDir), 0, SPROP_NOSCALE), //SPROP_NORMAL),
+	SendPropTime(SENDINFO(m_flSpawnTime)),
+	SendPropTime(SENDINFO(m_flDeathTime)),
+	SendPropFloat(SENDINFO(m_flSpawnSpeed), 0, SPROP_NOSCALE),
+#else
+	RecvPropVector(RECVINFO(m_vecSpawnPosition)),
+	RecvPropVector(RECVINFO(m_vTracerDir)),
+	RecvPropTime(RECVINFO(m_flSpawnTime)),
+	RecvPropTime(RECVINFO(m_flDeathTime)),
+	RecvPropFloat(RECVINFO(m_flSpawnSpeed)),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA_NO_BASE( CPlasmaProjectileShared )
+
+	DEFINE_PRED_FIELD_TOL( m_vecSpawnPosition, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.125f ),
+	DEFINE_PRED_FIELD_TOL( m_vTracerDir, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.01f ),
+	DEFINE_PRED_FIELD( m_flSpawnTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flDeathTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flSpawnSpeed, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PositionHistory_t )
+
+	DEFINE_FIELD( m_Position, FIELD_VECTOR ),
+	DEFINE_FIELD( m_Time, FIELD_FLOAT ),
+
+END_PREDICTION_DATA()
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BasePlasmaProjectile, DT_BasePlasmaProjectile)
+
+BEGIN_NETWORK_TABLE( CBasePlasmaProjectile, DT_BasePlasmaProjectile )
+#if !defined( CLIENT_DLL )
+	SendPropDataTable(SENDINFO_DT(m_Shared), &REFERENCE_SEND_TABLE(DT_PlasmaProjectileShared)),
+
+	SendPropExclude( "DT_BaseEntity", "m_vecVelocity" ),
+	SendPropExclude( "DT_BaseEntity", "m_vecAbsOrigin" ),
+
+	//SendPropVector(SENDINFO(m_vecGunOriginOffset), 0, SPROP_COORD),
+
+#else
+	RecvPropDataTable(RECVINFO_DT(m_Shared), 0, &REFERENCE_RECV_TABLE(DT_PlasmaProjectileShared)),
+
+	//RecvPropVector(RECVINFO(m_vecGunOriginOffset)),
+#endif
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS( base_plasmaprojectile, CBasePlasmaProjectile );
+PRECACHE_REGISTER(base_plasmaprojectile);
+
+BEGIN_PREDICTION_DATA( CBasePlasmaProjectile )
+
+	DEFINE_PRED_TYPEDESCRIPTION( m_Shared, CPlasmaProjectileShared ),
+
+	DEFINE_PRED_FIELD( m_vecAbsOrigin, FIELD_VECTOR, FTYPEDESC_PRIVATE | FTYPEDESC_OVERRIDE ),
+	DEFINE_PRED_FIELD( m_vecVelocity, FIELD_VECTOR, FTYPEDESC_PRIVATE | FTYPEDESC_OVERRIDE ),
+
+	DEFINE_FIELD( m_flMaxRange, FIELD_FLOAT ),
+
+	// Predicted, but not in networking stream
+	DEFINE_PRED_TYPEDESCRIPTION( m_pPreviousPositions[0], PositionHistory_t ), 
+	DEFINE_PRED_TYPEDESCRIPTION( m_pPreviousPositions[1], PositionHistory_t ), 
+	DEFINE_PRED_TYPEDESCRIPTION( m_pPreviousPositions[2], PositionHistory_t ), 
+	DEFINE_PRED_TYPEDESCRIPTION( m_pPreviousPositions[3], PositionHistory_t ), 
+	DEFINE_PRED_TYPEDESCRIPTION( m_pPreviousPositions[4], PositionHistory_t ), 
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBasePlasmaProjectile::CBasePlasmaProjectile()
+{
+#if defined( CLIENT_DLL )
+	m_pHeadParticle = NULL;
+	m_pTrailParticle = NULL;
+	m_pParticleMgr = NULL;
+#endif
+
+	SetPredictionEligible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBasePlasmaProjectile::~CBasePlasmaProjectile()
+{
+#if defined( CLIENT_DLL )
+	if( m_pParticleMgr )
+	{
+		m_pParticleMgr->RemoveEffect( &m_ParticleEffect );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::Precache( void )
+{
+	SetCollisionGroup( TFCOLLISION_GROUP_WEAPON );
+
+	PrecacheScriptSound( "BasePlasmaProjectile.ShieldBlock" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::Spawn( void )
+{
+	Precache();
+
+	SetSolid( SOLID_BBOX );
+	SetSize( vec3_origin, vec3_origin );
+	SetCollisionGroup( TFCOLLISION_GROUP_WEAPON );
+	SetTouch( MissileTouch );
+	m_DamageType = DMG_ENERGYBEAM;
+	SetMoveType( MOVETYPE_CUSTOM );
+	m_flDamage = 0;
+	// SetMaxRange( 0 );
+	SetExplosive( 0 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::Activate( void )
+{
+	BaseClass::Activate();
+
+#if defined( CLIENT_DLL )
+	if ( IsClientCreated() && !m_pParticleMgr )
+	{
+		Start(ParticleMgr(), NULL);
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::SetDamage( float flDamage )
+{
+	m_flDamage = flDamage;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CBasePlasmaProjectile::GetDamage( void )
+{
+	return m_flDamage;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::SetMaxRange( float flRange )
+{
+	m_flMaxRange = flRange;
+
+	// If we have a max range, calculate death time based upon velocity
+	if ( m_flMaxRange )
+	{
+		float flSpeed = GetAbsVelocity().Length();
+		Assert( flSpeed );
+		m_Shared.SetDeathTime( m_Shared.GetSpawnTime() + (flRange / flSpeed) );
+	}
+	else
+	{
+		m_Shared.SetDeathTime( m_Shared.GetSpawnTime() + PLASMA_LIFETIME );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the radius of the explosion created when this shot impacts
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::SetExplosive( float flRadius )
+{
+	m_flExplosiveRadius = flRadius;
+}
+
+//-----------------------------------------------------------------------------
+// Perform custom physics on this dude (when we're in ballistic mode)
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::PerformCustomPhysics( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity )
+{
+#ifdef CLIENT_DLL
+	RecalculatePositions( pNewPosition, pNewVelocity, pNewAngles, pNewAngVelocity );
+#else
+	// Simulate next position
+	m_Shared.ComputePosition( gpGlobals->curtime, pNewPosition, pNewVelocity, pNewAngles, pNewAngVelocity );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pOther - 
+//			tr - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBasePlasmaProjectile::ProjectileHitShield( CBaseEntity *pOther, trace_t& tr )
+{
+	if ( !pOther )
+		return false;
+
+	if ( !pOther->IsPlayer() )
+		return false;
+#if !defined( CLIENT_DLL )
+	CBaseTFPlayer* pPlayer = static_cast<CBaseTFPlayer*>(pOther);
+	float flDamage = GetDamage();
+	if ( !pPlayer->IsHittingShield( GetAbsVelocity(), &flDamage ) )
+		return false;
+#else
+	return false;
+#endif
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pOther - 
+//			tr - 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::HandleShieldImpact( CBaseEntity *pOther, trace_t& tr )
+{
+	// Block
+	EmitSound( "BasePlasmaProjectile.ShieldBlock" );
+
+	// Remove the particle, and make a particle shower
+	g_pEffects->EnergySplash( tr.endpos, tr.plane.normal, ( m_flExplosiveRadius != 0 ) );
+
+	Remove( );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::MissileTouch( CBaseEntity *pOther )
+{
+	Assert( pOther );
+	if ( !pOther->IsSolid() )
+		return;
+
+	// Create a plasma effect
+	trace_t	tr;
+	Vector velDir = GetAbsVelocity();
+	VectorNormalize( velDir );
+	Vector vecSpot = GetLocalOrigin() - velDir * 32;
+
+	// First, just clip to the box
+	Ray_t ray;
+	ray.Init( vecSpot, vecSpot + velDir * 64 );
+	enginetrace->ClipRayToEntity( ray, MASK_SHOT, pOther, &tr );
+
+	// Create the appropriate impact
+	bool bHurtTarget = ( !InSameTeam( pOther ) && pOther->m_takedamage != DAMAGE_NO );
+	WeaponImpact( &tr, velDir, bHurtTarget, pOther, GetDamageType() );
+
+#if !defined( CLIENT_DLL )
+	CBaseEntity *pOwner = m_hOwner;
+
+	// Do damage (unless I'm explosive, in which case I'll do damage later)
+	if ( m_flDamage && !m_flExplosiveRadius )
+	{
+		ClearMultiDamage();
+		// Assume it's a projectile, so use its velocity instead
+		Vector vecDamageOrigin = GetAbsVelocity();
+		VectorNormalize( vecDamageOrigin );
+		vecDamageOrigin = GetAbsOrigin() - (vecDamageOrigin * 32);
+		CTakeDamageInfo info( this, pOwner, m_flDamage, m_DamageType );
+		CalculateBulletDamageForce( &info, GetAmmoDef()->Index("MediumRound"), GetAbsVelocity(), vecDamageOrigin );
+		pOther->DispatchTraceAttack( info, velDir, &tr );
+		ApplyMultiDamage();
+	}
+#endif
+
+	Detonate();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Plasma projectiles return their owner as their scorer
+//-----------------------------------------------------------------------------
+CBasePlayer *CBasePlasmaProjectile::GetScorer( void )
+{
+	return ToBasePlayer( m_hOwner );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Explode and die
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::Detonate( void )
+{
+#if !defined( CLIENT_DLL )
+	// Should I explode?
+	if ( m_flExplosiveRadius )
+	{
+		RadiusDamage( CTakeDamageInfo( this, GetOwnerEntity(), m_flDamage, m_DamageType | DMG_BLAST ), GetAbsOrigin(), m_flExplosiveRadius, CLASS_NONE, NULL );
+	}
+#endif
+	Remove( );
+}
+
+#if defined( CLIENT_DLL )
+
+//-----------------------------------------------------------------------------
+// Add the position to the history 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::AddPositionToHistory( const Vector& org, float flSimTime )
+{
+	// Store the particle position history
+	// Push the others down the stack
+	for ( int i = MAX_HISTORY-1; i >= 1; i-- )
+	{
+		m_pPreviousPositions[i].m_Position = m_pPreviousPositions[i-1].m_Position;
+		m_pPreviousPositions[i].m_Time = m_pPreviousPositions[i-1].m_Time;
+	}
+
+	m_pPreviousPositions[0].m_Position = org;
+	m_pPreviousPositions[0].m_Time = flSimTime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : org - 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::ResetPositionHistories( const Vector& org )
+{
+	for ( int i = 0; i < MAX_HISTORY; i++ )
+	{
+		m_pPreviousPositions[ i ].m_Position = org; //; - (m_Shared.TracerDir() * 48 * i);;
+		m_pPreviousPositions[ i ].m_Time = gpGlobals->curtime;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::OnDataChanged(DataUpdateType_t updateType)
+{
+	BaseClass::OnDataChanged(updateType);
+
+	if ( updateType != DATA_UPDATE_CREATED )
+		return;
+
+	if ( !m_pParticleMgr )
+	{
+		Start(ParticleMgr(), NULL);
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::RecalculatePositions( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity )
+{
+	// Recalculate all points?
+	float flSimTime;
+	if ( !m_pPreviousPositions[0].m_Time )
+	{
+		flSimTime = m_Shared.GetSpawnTime();
+	}
+	else
+	{
+		flSimTime = gpGlobals->curtime;
+	}
+
+	// Simulate the points
+	for ( int i = 0; i < MAX_HISTORY; i++ )
+	{
+		if ( flSimTime < m_Shared.GetSpawnTime() )
+		{
+			flSimTime = m_Shared.GetSpawnTime();
+		}
+
+		Vector vecVelocity, vNewOrigin;
+  		QAngle vecAngles, vecAngularVelocity;
+		// Only fill out the data with the most recent sim
+		if ( i == 0 )
+		{
+			m_Shared.ComputePosition( flSimTime, &vNewOrigin, &vecVelocity, pNewAngles, pNewAngVelocity );
+			*pNewPosition = vNewOrigin;
+			*pNewVelocity =vecVelocity;
+		}
+		else
+		{
+  			m_Shared.ComputePosition( flSimTime, &vNewOrigin, &vecVelocity, &vecAngles, &vecAngularVelocity );
+		}
+		AddPositionToHistory( vNewOrigin, flSimTime );
+
+		// As we slow down, simulate slower
+		float flSpeed = vecVelocity.LengthSqr();
+		if ( flSpeed )
+		{
+			flSimTime -= PLASMA_SIM_DELTA * (PLASMA_VELOCITY_SQR / flSpeed);
+		}
+		else
+		{
+			flSimTime -= PLASMA_SIM_DELTA;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::ClientThink( void )
+{
+	BaseClass::ClientThink();
+
+  	// Don't mess with origin if it's being forward simulated on the client
+  	if ( GetPredictable() || IsClientCreated() )
+  		return;
+
+  	Assert( !GetMoveParent() );
+
+	Vector pNewPosition, pNewVelocity;
+	QAngle pNewAngles, pNewAngVelocity;
+	RecalculatePositions( &pNewPosition, &pNewVelocity, &pNewAngles, &pNewAngVelocity );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : isbeingremoved - 
+//			*predicted - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBasePlasmaProjectile::OnPredictedEntityRemove( bool isbeingremoved, C_BaseEntity *predicted )
+{
+	BaseClass::OnPredictedEntityRemove( isbeingremoved, predicted );
+
+	CBasePlasmaProjectile *bpp = dynamic_cast< CBasePlasmaProjectile * >( predicted );
+	if ( !bpp )
+	{
+		// Hrm, we didn't link up to correct type!!!
+		Assert( 0 );
+		// Delete right away since it's fucked up
+		return true;
+	}
+
+	memcpy( m_pPreviousPositions, bpp->m_pPreviousPositions, sizeof( m_pPreviousPositions ) );
+
+	m_vecGunOriginOffset = bpp->m_vecGunOriginOffset;
+
+	// Don't delete right away
+	return true; // isbeingremoved;
+}
+
+#define REMAP_BLEND_TIME		0.5f
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : slot - 
+//			curtime - 
+//			outpos - 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::RemapPosition( Vector &vecStart, float curtime, Vector& outpos )
+{
+	outpos = vecStart;
+	if ( curtime > m_Shared.GetSpawnTime() + REMAP_BLEND_TIME )
+		return;
+
+	float frac = ( curtime - m_Shared.GetSpawnTime() ) / REMAP_BLEND_TIME;
+	frac = 1.0f - clamp( frac, 0.0f, 1.0f );
+
+	Vector scaledOffset;
+	VectorScale( m_vecGunOriginOffset, frac, scaledOffset );
+
+	outpos += scaledOffset;
+}
+
+#define TIME_TILL_MAX_LENGTH	1.0
+
+//-----------------------------------------------------------------------------
+// Purpose: Update state + render
+//-----------------------------------------------------------------------------
+bool CBasePlasmaProjectile::SimulateAndRender(Particle *pInParticle, ParticleDraw *pDraw, float &sortKey)
+{
+	if ( IsDormantPredictable() )
+		return true;
+
+	if ( GetMoveType() == MOVETYPE_NONE )
+		return true;
+
+	// Update the particle position
+	pInParticle->m_Pos = GetAbsOrigin();
+
+	// Add our blended offset
+	if ( gpGlobals->curtime < m_Shared.GetSpawnTime() + REMAP_BLEND_TIME )
+	{
+		float frac = ( gpGlobals->curtime - m_Shared.GetSpawnTime() ) / REMAP_BLEND_TIME;
+		frac = 1.0f - clamp( frac, 0.0f, 1.0f );
+		Vector scaledOffset;
+		VectorScale( m_vecGunOriginOffset, frac, scaledOffset );
+		pInParticle->m_Pos += scaledOffset;
+	}
+
+	float timeDelta = pDraw->GetTimeDelta();
+
+	// Render the head particle
+	if ( pInParticle == m_pHeadParticle )
+	{
+		SimpleParticle *pParticle = (SimpleParticle *) pInParticle;
+		pParticle->m_flLifetime += timeDelta;
+
+		// Render
+		Vector tPos, vecOrigin;
+		RemapPosition( m_pPreviousPositions[MAX_HISTORY-1].m_Position, m_pPreviousPositions[MAX_HISTORY-1].m_Time, vecOrigin );
+
+		TransformParticle( ParticleMgr()->GetModelView(), vecOrigin, tPos );
+		sortKey = (int) tPos.z;
+
+		//Render it
+		RenderParticle_ColorSizeAngle(
+			pDraw,
+			tPos,
+			UpdateColor( pParticle, timeDelta ),
+			UpdateAlpha( pParticle, timeDelta ) * GetAlphaDistanceFade( tPos, 16, 64 ),
+			UpdateScale( pParticle, timeDelta ),
+			UpdateRoll( pParticle, timeDelta ) );
+
+		/*
+		if ( m_flNextSparkEffect < gpGlobals->curtime )
+		{
+			// Drop sparks?
+			if ( GetTeamNumber() == TEAM_HUMANS )
+			{
+				g_pEffects->Sparks( pInParticle->m_Pos, 1, 3 );
+			}
+			else
+			{
+				g_pEffects->EnergySplash( pInParticle->m_Pos, vec3_origin );
+			}
+			m_flNextSparkEffect = gpGlobals->curtime + RandomFloat( 0.5, 2 );
+		}
+		*/
+
+		return true;
+	}
+
+	// Render the trail
+	TrailParticle *pParticle = (TrailParticle *) pInParticle;
+	pParticle->m_flLifetime += timeDelta;
+	Vector vecScreenStart, vecScreenDelta;
+	sortKey = pParticle->m_Pos.z;
+
+	// NOTE: We need to do everything in screen space
+	float flFragmentLength = (MAX_HISTORY > 1) ? 1.0 / (float)(MAX_HISTORY-1) : 1.0;
+
+	for ( int i = 0; i < (MAX_HISTORY-1); i++ )
+	{
+		Vector vecWorldStart, vecWorldEnd, vecScreenEnd;
+		float flStartV, flEndV;
+
+		// Did we just appear?
+		if ( m_pPreviousPositions[i].m_Time == 0 )
+			continue;
+
+		RemapPosition( m_pPreviousPositions[i+1].m_Position, m_pPreviousPositions[i+1].m_Time, vecWorldStart );
+		RemapPosition( m_pPreviousPositions[i].m_Position, m_pPreviousPositions[i].m_Time, vecWorldEnd );
+
+		// Texture wrapping
+		flStartV = (flFragmentLength * (i+1));
+		flEndV = (flFragmentLength * i);
+		
+		TransformParticle( ParticleMgr()->GetModelView(), vecWorldStart, vecScreenStart );
+		TransformParticle( ParticleMgr()->GetModelView(), vecWorldEnd, vecScreenEnd );
+		Vector vecScreenDelta = (vecScreenEnd - vecScreenStart);
+		if ( vecScreenDelta == vec3_origin )
+			continue;
+
+		/*
+		Vector vecForward, vecRight;
+		AngleVectors( MainViewAngles(), &vecForward, &vecRight, NULL );
+		Vector vecWorldDelta = ( vecWorldEnd - vecWorldStart );
+		VectorNormalize( vecWorldDelta );
+		float flDot = fabs(DotProduct( vecWorldDelta, vecForward ));
+		if ( flDot > 0.99 )
+		{
+			// Remap alpha
+			pParticle->m_flColor[3] = 1.0 - MIN( 1.0, RemapVal( flDot, 0.99, 1.0, 0, 1 ) );
+		}
+		*/
+
+		// See if we should fade
+		float color[4];
+		Color32ToFloat4( color, pParticle->m_color );
+		Tracer_Draw( pDraw, vecScreenStart, vecScreenDelta, pParticle->m_flWidth, color, flStartV, flEndV );
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::Start(CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs)
+{
+	m_pParticleMgr = pParticleMgr;
+	m_pParticleMgr->AddEffect( &m_ParticleEffect, this );
+
+	PMaterialHandle	HeadMaterial, TrailMaterial;
+
+	// Load the projectile material
+	if ( GetTeamNumber() == TEAM_HUMANS )
+	{
+		HeadMaterial = m_ParticleEffect.FindOrAddMaterial( "effects/human_tracers/human_sparksprite_A1" );
+		TrailMaterial = m_ParticleEffect.FindOrAddMaterial( "effects/human_tracers/human_sparktracer_A_" );
+	}
+	else
+	{
+		HeadMaterial = m_ParticleEffect.FindOrAddMaterial( "effects/alien_tracers/alien_pbsprite_A1" );
+		TrailMaterial = m_ParticleEffect.FindOrAddMaterial( "effects/alien_tracers/alien_pbtracer_A_" );
+	}
+
+	// Create the head & trail
+	m_pHeadParticle = (SimpleParticle *)m_ParticleEffect.AddParticle(sizeof(SimpleParticle), HeadMaterial );
+	m_pTrailParticle = (TrailParticle *)m_ParticleEffect.AddParticle(sizeof(TrailParticle), TrailMaterial );
+	if ( !m_pHeadParticle || !m_pTrailParticle )
+		return;
+
+	// 3rd person particles are larger
+	bool bFirst = (GetOwnerEntity() == C_BasePlayer::GetLocalPlayer());
+
+	m_pHeadParticle->m_Pos = GetRenderOrigin();
+	m_pHeadParticle->m_uchColor[0] = 255;
+	m_pHeadParticle->m_uchColor[1] = 255;
+	m_pHeadParticle->m_uchColor[2] = 255;
+	if ( bFirst )
+	{
+		m_pHeadParticle->m_uchStartSize = 6;
+	}
+	else
+	{
+		m_pHeadParticle->m_uchStartSize = shot_head_size.GetInt();
+	}
+	m_pHeadParticle->m_uchEndSize	= m_pHeadParticle->m_uchStartSize;
+	m_pHeadParticle->m_uchStartAlpha = 255;
+	m_pHeadParticle->m_uchEndAlpha = 255;
+	m_pHeadParticle->m_flRoll = 0;
+	m_pHeadParticle->m_flRollDelta = 10;
+	m_pHeadParticle->m_iFlags = 0;
+
+	m_pTrailParticle->m_flLifetime = 0;
+	m_pTrailParticle->m_Pos = GetRenderOrigin();
+	if ( bFirst )
+	{
+		m_pTrailParticle->m_flWidth = 25;
+		m_pTrailParticle->m_flLength = 140;
+	}
+	else
+	{
+		m_pTrailParticle->m_flWidth = shot_width.GetFloat();
+		m_pTrailParticle->m_flLength = shot_length.GetFloat();
+	}
+	Color32Init( m_pTrailParticle->m_color, 255, 255, 255, 255 );
+
+	m_flNextSparkEffect = gpGlobals->curtime + RandomFloat( 0.05, 0.4 );
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Setup this projectile's starting values
+//-----------------------------------------------------------------------------
+void CBasePlasmaProjectile::SetupProjectile( const Vector &vecOrigin, const Vector &vecForward, int damageType, CBaseEntity *pOwner )
+{
+	UTIL_SetOrigin( this, vecOrigin );
+
+	QAngle angles;
+	VectorAngles( vecForward, angles );
+	SetLocalAngles( angles );
+
+	SetOwnerEntity( pOwner );
+	Spawn();
+
+	float flMySpeed = PLASMA_VELOCITY;// + RandomFloat( -500, 500 );
+	SetAbsVelocity( vecForward * flMySpeed );
+	m_DamageType = damageType;
+	m_Shared.Init( vecOrigin, vecForward, flMySpeed );
+#ifdef CLIENT_DLL
+	ResetPositionHistories( GetAbsOrigin() );
+#endif
+	m_Shared.SetSpawnTime( gpGlobals->curtime );
+
+	// Set my team
+	ChangeTeam( pOwner->GetTeamNumber() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a missile
+//-----------------------------------------------------------------------------
+CBasePlasmaProjectile *CBasePlasmaProjectile::Create( const Vector &vecOrigin, const Vector &vecForward, int damageType, CBaseEntity *pOwner = NULL )
+{
+	CBasePlasmaProjectile *pMissile = (CBasePlasmaProjectile*)CreateEntityByName("base_plasmaprojectile");
+	pMissile->SetupProjectile( vecOrigin, vecForward, damageType, pOwner );
+
+	return pMissile;
+}
+
+CBasePlasmaProjectile *CBasePlasmaProjectile::CreatePredicted( const Vector &vecOrigin, const Vector &vecForward, const Vector& gunOffset, int damageType, CBasePlayer *pOwner )
+{
+	CBasePlasmaProjectile *pMissile = (CBasePlasmaProjectile*)CREATE_PREDICTED_ENTITY("base_plasmaprojectile");
+	if ( pMissile )
+	{
+		pMissile->SetOwnerEntity( pOwner );
+		pMissile->SetPlayerSimulated( pOwner );
+		pMissile->SetupProjectile( vecOrigin, vecForward, damageType, pOwner );
+		pMissile->m_vecGunOriginOffset = gunOffset;
+	}
+
+	return pMissile;
+}
+
+//===============================================================================================================
+// Power Projectile
+//===============================================================================================================
+//-----------------------------------------------------------------------------
+// Purpose: Create a power projectile
+//-----------------------------------------------------------------------------
+CPowerPlasmaProjectile *CPowerPlasmaProjectile::Create( const Vector &vecOrigin, const Vector &vecForward, int damageType, CBaseEntity *pOwner = NULL )
+{
+	CPowerPlasmaProjectile *pMissile = (CPowerPlasmaProjectile*)CreateEntityByName("powerplasmaprojectile");
+	pMissile->SetupProjectile( vecOrigin, vecForward, damageType, pOwner );
+	pMissile->SetPower( 1.0 );
+
+	return pMissile;
+}
+
+CPowerPlasmaProjectile *CPowerPlasmaProjectile::CreatePredicted( const Vector &vecOrigin, const Vector &vecForward, const Vector& gunOffset, int damageType, CBasePlayer *pOwner )
+{
+	CPowerPlasmaProjectile *pMissile = (CPowerPlasmaProjectile*)CREATE_PREDICTED_ENTITY("powerplasmaprojectile");
+	if ( pMissile )
+	{
+		pMissile->SetOwnerEntity( pOwner );
+		pMissile->SetPlayerSimulated( pOwner );
+		pMissile->SetupProjectile( vecOrigin, vecForward, damageType, pOwner );
+		pMissile->SetPower( 1.0 );
+		pMissile->m_vecGunOriginOffset = gunOffset;
+	}
+
+	return pMissile;
+}
+
+CPowerPlasmaProjectile::CPowerPlasmaProjectile( void )
+{
+	m_flPower = 0;
+	SetPredictionEligible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Factor power into size
+//-----------------------------------------------------------------------------
+float CPowerPlasmaProjectile::GetSize( void )
+{
+	return ( 2 * (m_flPower * 2));
+}
+
+IMPLEMENT_NETWORKCLASS_ALIASED( PowerPlasmaProjectile, DT_PowerPlasmaProjectile);
+
+BEGIN_NETWORK_TABLE( CPowerPlasmaProjectile, DT_PowerPlasmaProjectile)
+#if !defined( CLIENT_DLL )
+	SendPropFloat( SENDINFO( m_flPower ), 7, SPROP_ROUNDDOWN, 1.0f, 10.0 ),
+#else
+	RecvPropFloat(RECVINFO(m_flPower)),
+#endif
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS( powerplasmaprojectile, CPowerPlasmaProjectile );
+PRECACHE_REGISTER(powerplasmaprojectile);
+
+BEGIN_PREDICTION_DATA( CPowerPlasmaProjectile )
+
+	DEFINE_PRED_FIELD_TOL( m_flPower, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.05f ),
+
+END_PREDICTION_DATA()
diff --git a/game/shared/tf2/plasmaprojectile.h b/game/shared/tf2/plasmaprojectile.h
new file mode 100644
index 0000000..13427e6
--- /dev/null
+++ b/game/shared/tf2/plasmaprojectile.h
@@ -0,0 +1,245 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef PLASMAPROJECTILE_H
+#define PLASMAPROJECTILE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "predictable_entity.h"
+
+#include "baseparticleentity.h"
+#include "plasmaprojectile_shared.h"
+
+#if !defined( CLIENT_DLL )
+#include "iscorer.h"
+#else
+#include "particle_prototype.h"
+#include "particles_simple.h"
+#include "particle_util.h"
+#include "c_baseplayer.h"
+#include "fx_sparks.h"
+#endif
+
+#if defined( CLIENT_DLL )
+#define CBasePlasmaProjectile C_BasePlasmaProjectile
+#endif
+
+#define MAX_HISTORY			5
+#define GUIDED_FADE_TIME	0.25f
+#define	GUIDED_WIDTH		3
+
+struct PositionHistory_t
+{
+	DECLARE_PREDICTABLE();
+
+	Vector	m_Position;
+	float	m_Time;
+};
+
+// ------------------------------------------------------------------------ //
+// CBasePlasmaProjectile
+// ------------------------------------------------------------------------ //
+class CBasePlasmaProjectile : public CBaseParticleEntity
+#if !defined( CLIENT_DLL )
+, public IScorer
+#endif
+{
+	DECLARE_CLASS( CBasePlasmaProjectile, CBaseParticleEntity );
+public:
+	CBasePlasmaProjectile();
+	~CBasePlasmaProjectile();
+
+	DECLARE_PREDICTABLE();
+	DECLARE_NETWORKCLASS();
+
+#if !defined( CLIENT_DLL )
+	DECLARE_DATADESC();
+#endif
+
+	virtual bool ProjectileHitShield( CBaseEntity *pOther, trace_t& tr );
+	virtual void HandleShieldImpact( CBaseEntity *pOther, trace_t& tr );
+
+	virtual void Spawn( void );
+	virtual void Precache( void );
+	virtual void Activate( void );
+
+	virtual void MissileTouch( CBaseEntity *pOther );
+	virtual float GetDamage( void );
+	virtual void SetDamage( float flDamage );
+	virtual void SetMaxRange( float flRange );
+	virtual void SetExplosive( float flRadius );
+	virtual void PerformCustomPhysics( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity );
+
+	// Purpose: Returns the type of damage that this entity inflicts.
+	int GetDamageType() const
+	{
+		return m_DamageType;
+	}
+
+	virtual float	GetSize( void ) { return 6.0; };
+
+	// FIXME!!!! Override the think of the baseparticle Think functions
+	virtual void Think( void ) { CBaseEntity::Think(); }
+
+	void		SetupProjectile( const Vector &vecOrigin, const Vector &vecForward, int damageType, CBaseEntity *pOwner = NULL );
+	static CBasePlasmaProjectile *Create( const Vector &vecOrigin, const Vector &vecForward, int damageType, CBaseEntity *pOwner );
+	static CBasePlasmaProjectile *CreatePredicted( const Vector &vecOrigin, const Vector &vecForward, const Vector& gunOffset, int damageType, CBasePlayer *pOwner );
+
+	void		RecalculatePositions( Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity );
+
+// IScorer
+public:
+	// Return the entity that should receive the score
+	virtual CBasePlayer *GetScorer( void );
+	// Return the entity that should get assistance credit
+	virtual CBasePlayer *GetAssistant( void ) { return NULL; };
+	
+protected:
+	void		Detonate( void );
+
+	// A derived class should return true here so that weapon sounds, etc, can
+	//  apply the proper filter
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwnerEntity() &&
+			GetOwnerEntity() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	virtual	void	OnDataChanged(DataUpdateType_t updateType);
+	virtual void	Start(CParticleMgr *pParticleMgr, IPrototypeArgAccess *pArgs);
+	virtual bool	SimulateAndRender(Particle *pParticle, ParticleDraw *pDraw, float &sortKey);
+
+	// Add the position to the history 
+	void		AddPositionToHistory( const Vector& org, float flSimTime );
+	void		ResetPositionHistories( const Vector& org );
+	// Adjustments for shots straight out of local player's eyes
+	void		RemapPosition( Vector &vecStart, float curtime, Vector& outpos );
+
+	// Scale
+	virtual float UpdateScale( SimpleParticle *pParticle, float timeDelta )
+	{
+		return (float)pParticle->m_uchStartSize + RandomInt( -2,2 );
+	}
+
+	// Alpha
+	virtual float UpdateAlpha( SimpleParticle *pParticle, float timeDelta )
+	{
+		return (pParticle->m_uchStartAlpha + RandomInt( -50, 0 ) ) / 255.0f;
+	}
+	virtual	float	UpdateRoll( SimpleParticle *pParticle, float timeDelta )
+	{
+		pParticle->m_flRoll += pParticle->m_flRollDelta * timeDelta;
+
+		return pParticle->m_flRoll;
+	}
+	virtual Vector	UpdateColor( SimpleParticle *pParticle, float timeDelta )
+	{
+		static Vector	cColor;
+
+		cColor[0] = pParticle->m_uchColor[0] / 255.0f;
+		cColor[1] = pParticle->m_uchColor[1] / 255.0f;
+		cColor[2] = pParticle->m_uchColor[2] / 255.0f;
+
+		return cColor;
+	}
+
+	// Should this object cast shadows?
+	virtual ShadowType_t	ShadowCastType() { return SHADOWS_NONE; }
+	
+	virtual void	ClientThink( void );
+	virtual bool	OnPredictedEntityRemove( bool isbeingremoved, C_BaseEntity *predicted );
+
+protected:
+	SimpleParticle	*m_pHeadParticle;
+	TrailParticle	*m_pTrailParticle;
+	CParticleMgr	*m_pParticleMgr;
+	float			m_flNextSparkEffect;
+#endif
+public:
+	EHANDLE		m_hOwner;
+
+protected:
+	CNetworkVarEmbedded( CPlasmaProjectileShared, m_Shared );
+
+	Vector		m_vecGunOriginOffset;
+
+	CNetworkVar( float, m_flPower );
+
+	// Explosive radius
+	float		m_flExplosiveRadius;
+
+	// Maximum range
+	float		m_flMaxRange;
+
+	float		m_flDamage;
+	int			m_DamageType;
+
+	Vector		m_vecTargetOffset;
+
+	PositionHistory_t	m_pPreviousPositions[MAX_HISTORY];
+
+private:
+	CBasePlasmaProjectile( const CBasePlasmaProjectile & );
+};
+
+#if defined( CLIENT_DLL )
+#define CPowerPlasmaProjectile C_PowerPlasmaProjectile
+#endif
+
+// ------------------------------------------------------------------------ //
+// Plasma projectile that has a concept of variable power
+// ------------------------------------------------------------------------ //
+class CPowerPlasmaProjectile : public CBasePlasmaProjectile
+{
+	DECLARE_CLASS( CPowerPlasmaProjectile, CBasePlasmaProjectile );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CPowerPlasmaProjectile();
+
+	void	SetPower( float flPower ) { m_flPower = flPower; };
+	static CPowerPlasmaProjectile* Create( const Vector &vecOrigin, const Vector &vecForward, int damageType, CBaseEntity *pOwner );
+	static CPowerPlasmaProjectile* CreatePredicted( const Vector &vecOrigin, const Vector &vecForward, const Vector& gunOffset, int damageType, CBasePlayer *pOwner );
+
+	virtual float	GetSize( void );
+
+	// A derived class should return true here so that weapon sounds, etc, can
+	//  apply the proper filter
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwnerEntity() &&
+			GetOwnerEntity() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+
+private:
+	CPowerPlasmaProjectile( const CPowerPlasmaProjectile & );
+
+};
+
+#endif // PLASMAPROJECTILE_H
diff --git a/game/shared/tf2/plasmaprojectile_shared.cpp b/game/shared/tf2/plasmaprojectile_shared.cpp
new file mode 100644
index 0000000..8bbe622
--- /dev/null
+++ b/game/shared/tf2/plasmaprojectile_shared.cpp
@@ -0,0 +1,72 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "plasmaprojectile_shared.h"
+
+#define PLASMA_LIFETIME				2.0
+
+ConVar	plasma_gravity( "plasma_gravity","1000", FCVAR_REPLICATED, "Plasma gravity" );
+ConVar	plasma_drag( "plasma_drag","2", FCVAR_REPLICATED, "Plasma drag" );
+
+
+//-----------------------------------------------------------------------------
+// Setup state needed to perform the physics computation
+//-----------------------------------------------------------------------------
+void CPlasmaProjectileShared::Init( const Vector &vecStart, const Vector &vecDir, float flSpawnSpeed )
+{
+	m_vecSpawnPosition = vecStart;
+	m_vTracerDir = vecDir;
+	m_flSpawnSpeed = flSpawnSpeed;
+}
+
+void CPlasmaProjectileShared::SetSpawnTime( float flSpawnTime )
+{
+	m_flSpawnTime = flSpawnTime;
+}
+
+void CPlasmaProjectileShared::SetDeathTime( float flDeathTime )
+{
+	m_flDeathTime = flDeathTime;
+}
+
+
+//-----------------------------------------------------------------------------
+// Perform custom physics on this dude (when we're in ballistic mode)
+//-----------------------------------------------------------------------------
+void CPlasmaProjectileShared::ComputePosition( float flTime, Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity )
+{
+	float flLifeTime = flTime - m_flSpawnTime;
+	if (flLifeTime < 0)
+		return;
+
+	// Travel ballistically until we run out of juice..
+	if (flTime <= m_flDeathTime)
+	{
+		VectorMultiply( m_vTracerDir, m_flSpawnSpeed, *pNewVelocity );
+		VectorMA( m_vecSpawnPosition, flLifeTime, *pNewVelocity, *pNewPosition );
+	}
+	else
+	{
+		VectorMultiply( m_vTracerDir, m_flSpawnSpeed, *pNewVelocity );
+		VectorMA( m_vecSpawnPosition, m_flDeathTime - m_flSpawnTime, *pNewVelocity, *pNewPosition );
+
+		// Ran out of juice... fall!
+		float flFallTime = flTime - m_flDeathTime;
+
+		float flDragFactor = exp( -plasma_drag.GetFloat() * flFallTime );
+		*pNewVelocity *= flDragFactor;
+
+		float flDist = (m_flSpawnSpeed / plasma_drag.GetFloat()) * ( 1.0f - flDragFactor );
+		VectorMA( *pNewPosition, flDist, m_vTracerDir, *pNewPosition );
+
+		// Add in the effects of gravity!
+		pNewVelocity->z -= flFallTime * plasma_gravity.GetFloat();
+		pNewPosition->z -= 0.5f * plasma_gravity.GetFloat() * flFallTime * flFallTime; 
+	}
+}
+
+
diff --git a/game/shared/tf2/plasmaprojectile_shared.h b/game/shared/tf2/plasmaprojectile_shared.h
new file mode 100644
index 0000000..2b112b8
--- /dev/null
+++ b/game/shared/tf2/plasmaprojectile_shared.h
@@ -0,0 +1,48 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef PLASMAPROJECTILE_SHARED_H
+#define PLASMAPROJECTILE_SHARED_H
+
+#ifndef _WIN32
+#pragma once
+#endif
+
+#include "predictable_entity.h"
+#include "server_class.h"
+#include "client_class.h"
+#include "mathlib/vector.h"
+
+class CPlasmaProjectileShared
+{
+public:
+	DECLARE_PREDICTABLE();
+	DECLARE_NETWORKCLASS_NOBASE();
+	DECLARE_CLASS_NOBASE( CPlasmaProjectileShared );
+	DECLARE_EMBEDDED_NETWORKVAR();
+
+public:
+	void Init( const Vector &vecStart, const Vector &vecDir, float flSpawnSpeed );
+	float GetSpawnTime() const { return m_flSpawnTime; }
+	void SetSpawnTime( float flSpawnTime );
+	void SetDeathTime( float flDeathTime );
+	float GetDeathTime() const { return m_flDeathTime; }
+
+	void ComputePosition( float flTime, Vector *pNewPosition, Vector *pNewVelocity, QAngle *pNewAngles, QAngle *pNewAngVelocity );
+
+	const Vector &TracerDir() { return m_vTracerDir.Get(); }
+
+private:
+	CNetworkVector( m_vTracerDir );
+	CNetworkVector( m_vecSpawnPosition );
+	CNetworkVar( float, m_flSpawnTime );
+	CNetworkVar( float, m_flSpawnSpeed );
+	CNetworkVar( float, m_flDeathTime );
+};
+
+
+#endif // PLASMAPROJECTILE_SHARED_H
diff --git a/game/shared/tf2/techtree.cpp b/game/shared/tf2/techtree.cpp
new file mode 100644
index 0000000..e1f732a
--- /dev/null
+++ b/game/shared/tf2/techtree.cpp
@@ -0,0 +1,1173 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Shared interface to the tech tree & individual technologies
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+
+#ifndef CLIENT_DLL
+#include "tf_player.h"
+#include "tf_team.h"
+#include "info_customtech.h"
+#endif
+#include "techtree.h"
+
+bool ParseTechnologyFile( CUtlVector< CBaseTechnology* > &pTechnologyList, IFileSystem* pFileSystem, int nTeamNumber, char *sFileName );
+
+// Color codes for resources
+rescolor sResourceColor = { 64,	255, 64 };
+
+// Prototype names for resources
+char sResourceName[] = "Jojierium";
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseTechnology::CBaseTechnology( void )
+{
+	m_nTechLevel = 0;
+	ZeroPreferences();
+	SetAvailable( false );
+	SetActive( false );
+	SetPreferred( false );
+	SetVoters( 0 );
+	SetCost( 0 );
+	SetDirty( false );
+	m_fResourceLevel = 0;
+	memset( m_ClassResults, 0, sizeof( m_ClassResults ) );
+	memset( m_pszName, 0, sizeof( m_pszName ) );
+	memset( m_pszPrintName, 0, sizeof( m_pszPrintName ) );
+	memset( m_pszDescription, 0, sizeof( m_pszDescription ) );
+	memset( m_pszTeamSoundFile, 0, sizeof( m_pszTeamSoundFile ) );
+	memset( m_apszContainedTechs, 0, sizeof( m_apszContainedTechs ) );
+	memset( m_pContainedTechs, 0, sizeof(m_pContainedTechs) );
+	memset( m_apszDependentTechs, 0, sizeof( m_apszDependentTechs ) );
+	memset( m_pDependentTechs, 0, sizeof(m_pDependentTechs) );
+	m_iContainedTechs = 0;
+	m_iDependentTechs = 0;
+	m_iTeamSound = 0;
+	m_bGoalTechnology = false;
+	m_bClassUpgrade = false;
+	m_bVehicle = false;
+	m_bTechLevelUpgrade = false;
+	m_bResourceTech = false;
+	
+	memset( m_szTextureName, 0, sizeof( m_szTextureName ) );
+	m_nTextureID = 0;
+
+	memset( m_szButtonName, 0, sizeof( m_szButtonName ) );
+
+	m_nNumWeaponAssociations = 0;
+	memset( m_rgszWeaponAssociation, 0, sizeof( m_rgszWeaponAssociation ) );
+
+	SetHidden( false );
+	ResetHintsGiven();
+}	
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseTechnology::~CBaseTechnology( void )
+{
+}
+
+static bool NameStartsWith( const char *name, const char *prefix )
+{
+	if ( !name || !name[ 0 ] || !prefix || !prefix[ 0 ] )
+		return false;
+
+	if ( !strnicmp( name, prefix, strlen( prefix ) ) )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the technology name
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetName( const char *pName )
+{
+	Q_strncpy( m_pszName, pName, sizeof(m_pszName) );
+
+	// Determine special information about this technology
+	m_bClassUpgrade		= NameStartsWith( pName, "class_" );
+	m_bVehicle			= NameStartsWith( pName, "vehicle_" );
+	m_bTechLevelUpgrade	= NameStartsWith( pName, "tech_level_" ); 
+	// HACK: Assume global techs relate to resources for now
+	m_bResourceTech		= NameStartsWith( pName, "g_" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the technology print name
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetPrintName( const char *pName )
+{
+	Q_strncpy( m_pszPrintName, pName, sizeof(m_pszPrintName) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the technology description
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetDescription( const char *pDesc )
+{
+	Q_strncpy( m_pszDescription, pDesc, sizeof(m_pszDescription) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pName - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetButtonName( const char *pName )
+{
+	Q_strncpy( m_szButtonName, pName, sizeof(m_szButtonName) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the technology level
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetLevel( int iLevel )
+{
+	m_nTechLevel = iLevel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *texture - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetTextureName( const char *texture )
+{
+	Q_strncpy( m_szTextureName, texture, sizeof( m_szTextureName ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : id - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetTextureId( int id )
+{
+	m_nTextureID = id;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the technologies resource costs
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetCost( float fResourceCost )
+{
+	m_fResourceCost = fResourceCost;
+
+	RecalculateOverallLevel();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set a specific class's sound
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetClassResultSound( int iClass, const char *pSound )
+{
+	if (!pSound)
+		return;
+
+	Assert( iClass >= 0 && iClass < TFCLASS_CLASS_COUNT );
+
+	// Class of 0 is the team's sound file
+	if ( iClass == 0 )
+	{
+		Q_strncpy( m_pszTeamSoundFile, pSound, sizeof(m_pszTeamSoundFile) );
+	}
+	else
+	{
+		m_ClassResults[iClass].bClassTouched = true;
+		Q_strncpy( m_ClassResults[iClass].pszSoundFile, pSound, sizeof(m_ClassResults[iClass].pszSoundFile) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : associate - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetClassResultAssociateWeapons( int iClass, bool associate )
+{
+	Assert( iClass >= 0 && iClass < TFCLASS_CLASS_COUNT );
+
+	m_ClassResults[iClass].m_bAssociateWeaponsForClass = associate;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set a specific class's precached sound 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetClassResultSound( int iClass, int iSound )
+{
+	Assert( iClass >= 0 && iClass < TFCLASS_CLASS_COUNT );
+
+	// Class of 0 is the team's sound file
+	if ( iClass == 0 )
+	{
+		m_iTeamSound = iSound;
+	}
+	else
+	{
+		m_ClassResults[iClass].iSound = iSound;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set a specific class's description
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetClassResultDescription( int iClass, const char *pDesc )
+{
+	if (!pDesc)
+		return;
+
+	Assert( iClass > 0 && iClass < TFCLASS_CLASS_COUNT );
+	m_ClassResults[iClass].bClassTouched = true;
+
+	Q_strncpy( m_ClassResults[iClass].pszDescription, pDesc, sizeof(m_ClassResults[iClass].pszDescription)  );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a technology contained within this one
+//-----------------------------------------------------------------------------
+void CBaseTechnology::AddContainedTechnology( const char *pszTech )
+{
+	Q_strncpy( m_apszContainedTechs[ m_iContainedTechs ], pszTech, sizeof(m_apszContainedTechs[0])  );
+	m_iContainedTechs++;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a technology dependency within this one
+//-----------------------------------------------------------------------------
+void CBaseTechnology::AddDependentTechnology( const char *pszTech )
+{
+	Q_strncpy( m_apszDependentTechs[ m_iDependentTechs ], pszTech, sizeof(m_apszDependentTechs[0])  );
+	m_iDependentTechs++;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if this technology affects the specified class
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::AffectsClass( int iClass )
+{
+	// If this technology directly affects this class, return true
+	if ( m_ClassResults[ iClass ].bClassTouched )
+		return true;
+
+	// If not, do any of our contained techs affect the specified class
+	for (int i = 0; i < m_iContainedTechs; i++ )
+	{
+		if ( m_pContainedTechs[i] )
+		{
+			if ( m_pContainedTechs[i]->AffectsClass( iClass ) )
+				return true;
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::IsClassUpgrade( void )
+{
+	return m_bClassUpgrade;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::IsVehicle( void )
+{
+	return m_bVehicle;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::IsResourceTech( void )
+{
+	return m_bResourceTech;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::IsTechLevelUpgrade( void )
+{
+	return m_bTechLevelUpgrade;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the level to which this technology belongs
+// Output : int
+//-----------------------------------------------------------------------------
+int CBaseTechnology::GetLevel( void )
+{
+	return m_nTechLevel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Cost of technology in resource specified
+//-----------------------------------------------------------------------------
+float CBaseTechnology::GetResourceCost( void )
+{
+	return m_fResourceCost;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Retrieves the current amount of resources spent on the technology
+//-----------------------------------------------------------------------------
+float CBaseTechnology::GetResourceLevel( void )
+{
+	return m_fResourceLevel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets a resource level to an amount
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetResourceLevel( float flResourceLevel )
+{
+	if ( m_fResourceLevel == flResourceLevel )
+		return;
+
+	m_fResourceLevel = flResourceLevel;
+
+	// Update my level & watchers
+	RecalculateOverallLevel();
+	UpdateWatchers();
+
+	// Force me to be resent to clients
+	SetDirty( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Increase the level of the specified resource spent on this technology
+// Output : Returns true if the technology's had enough resources to be bought
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::IncreaseResourceLevel( float flResourcesToSpend )
+{
+	SetResourceLevel( m_fResourceLevel + flResourcesToSpend );
+
+	// Have my costs been met?
+	if ( GetResourceLevel() < GetResourceCost() )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Figure out my overall owned percentage 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::RecalculateOverallLevel( void )
+{
+	if ( !GetResourceCost() )
+	{
+		m_flOverallOwnedPercentage = 0;
+	}
+	else
+	{
+		m_flOverallOwnedPercentage = GetResourceLevel() / GetResourceCost();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CBaseTechnology::GetOverallLevel( void )
+{
+	return m_flOverallOwnedPercentage;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Force this technology to complete itself
+//-----------------------------------------------------------------------------
+void CBaseTechnology::ForceComplete( void )
+{
+	SetResourceLevel( GetResourceCost() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::IsAGoalTechnology( void )
+{
+	return m_bGoalTechnology;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetGoalTechnology( bool bGoal )
+{
+	m_bGoalTechnology = bGoal;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the name of this technology
+// Output : const
+//-----------------------------------------------------------------------------
+const char	*CBaseTechnology::GetName( void )
+{
+	return m_pszName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns printable name of this technology
+// Output : const
+//-----------------------------------------------------------------------------
+const char	*CBaseTechnology::GetPrintName( void )
+{
+	return m_pszPrintName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *CBaseTechnology::GetButtonName( void )
+{
+	return m_szButtonName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *CBaseTechnology::GetTextureName(void )
+{
+	return m_szTextureName;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CBaseTechnology::GetTextureId( void )
+{
+	return m_nTextureID;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns description for item
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *CBaseTechnology::GetDescription( int iPlayerClass )
+{
+	// If we have a custom description for the local player's class, return that instead
+	if ( AffectsClass( iPlayerClass ) )
+	{
+		if ( m_ClassResults[iPlayerClass].pszDescription )
+			return m_ClassResults[iPlayerClass].pszDescription;
+	}
+
+	// Otherwise, return the general description
+	return m_pszDescription;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns sound filename to play for this technology
+//-----------------------------------------------------------------------------
+const char *CBaseTechnology::GetSoundFile( int iClass )
+{
+	// Class of 0 is the team sound
+	if ( !iClass )
+		return m_pszTeamSoundFile;
+
+	Assert(iClass > 0 && iClass < TFCLASS_CLASS_COUNT );
+	return m_ClassResults[iClass].pszSoundFile;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns sound to play for this technology
+//-----------------------------------------------------------------------------
+int	CBaseTechnology::GetSound( int iClass )
+{
+	// Class of 0 is the team sound
+	if ( !iClass )
+		return m_iTeamSound;
+
+	Assert(iClass > 0 && iClass < TFCLASS_CLASS_COUNT );
+	return m_ClassResults[iClass].iSound;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : iClass - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::GetAssociateWeaponsForClass( int iClass )
+{
+	if ( !iClass )
+		return false;
+
+	Assert(iClass > 0 && iClass < TFCLASS_CLASS_COUNT );
+	return m_ClassResults[iClass].m_bAssociateWeaponsForClass;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether the technology is available to the team
+// Input  : state - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetAvailable( bool state )
+{
+	if ( state != m_bAvailable )
+	{
+		SetDirty( true );
+	}
+
+	m_bAvailable = state;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Determine whether team posses the technology
+// Output : Returns 1 if available, 0 otherwise
+//-----------------------------------------------------------------------------
+int CBaseTechnology::GetAvailable( void )
+{
+	return m_bAvailable;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Zero out team preference counters
+//-----------------------------------------------------------------------------
+void CBaseTechnology::ZeroPreferences( void )
+{
+	if ( m_nPreferenceCount )
+	{
+		SetDirty( true );
+	}
+
+	m_nPreferenceCount = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Increment preference counter
+//-----------------------------------------------------------------------------
+void CBaseTechnology::IncrementPreferences( void )
+{
+	m_nPreferenceCount++;
+	SetDirty( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Retrieve preference count
+//-----------------------------------------------------------------------------
+int CBaseTechnology::GetPreferenceCount( void )
+{
+	return m_nPreferenceCount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+int CBaseTechnology::GetNumWeaponAssociations( void )
+{
+	return m_nNumWeaponAssociations;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CBaseTechnology::GetAssociatedWeapon( int index )
+{
+	if ( index < 0 || index >= m_nNumWeaponAssociations )
+	{
+		return "";
+	}
+
+	return m_rgszWeaponAssociation[ index ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *weaponname - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::AddAssociatedWeapon( const char *weaponname )
+{
+	if ( m_nNumWeaponAssociations >= MAX_ASSOCIATED_WEAPONS )
+	{
+		Assert( !"CBaseTechnology::AddAssociatedWeapon:  m_nNumWeaponAssociations >= MAX_ASSOCIATED_WEAPONS" );
+		return;
+	}
+	Q_strncpy( m_rgszWeaponAssociation[ m_nNumWeaponAssociations++ ], weaponname, TECHNOLOGY_WEAPONNAME_LENGTH );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	CBaseTechnology::GetNumberContainedTechs( void )
+{
+	return m_iContainedTechs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const char *CBaseTechnology::GetContainedTechName( int iTech )
+{
+	Assert( iTech >= 0 && iTech < m_iContainedTechs );
+	return m_apszContainedTechs[ iTech ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetContainedTech( int iTech, CBaseTechnology *pTech )
+{
+	Assert( iTech >= 0 && iTech < m_iContainedTechs );
+	m_pContainedTechs[iTech] = pTech;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int	CBaseTechnology::GetNumberDependentTechs( void )
+{
+	return m_iDependentTechs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const char *CBaseTechnology::GetDependentTechName( int iTech )
+{
+	Assert( iTech >= 0 && iTech < m_iDependentTechs );
+	return m_apszDependentTechs[ iTech ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetDependentTech( int iTech, CBaseTechnology *pTech )
+{
+	Assert( iTech >= 0 && iTech < m_iDependentTechs );
+	Assert( pTech );
+	m_pDependentTechs[iTech] = pTech;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this tech depends on the specified tech
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::DependsOn( CBaseTechnology *pTech )
+{
+	for ( int i = 0; i < GetNumberDependentTechs(); i++ )
+	{
+		if ( m_pDependentTechs[i] == pTech )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this tech has a dependent tech that's not been completed yet
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::HasInactiveDependencies( void )
+{
+	for ( int i = 0; i < GetNumberDependentTechs(); i++ )
+	{
+		// This condition can occur if there's a bug in the .txt file
+		// where a tech is told to depend on a non-existent tech
+		if (!m_pDependentTechs[i])
+			continue;
+
+		// Client uses m_bActive, Server uses m_bAvailable (?)
+		if ( m_pDependentTechs[i]->GetAvailable() == false && m_pDependentTechs[i]->GetActive() == false )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Dirty bit, used for fast knowledge of when to resend techs
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::IsDirty( void )
+{
+	return m_bDirty;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetDirty( bool bDirty )
+{
+	m_bDirty = bDirty;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set availability state for item
+// Input  : state - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetActive( bool state )
+{
+	m_bActive = state;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Retrieve availability state
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::GetActive( void )
+{
+	return m_bActive;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set whether this is our local preferred item
+// Input  : state - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetPreferred( bool state )
+{
+	m_bPreferred = state;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Retrieve local preferred state
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::GetPreferred( void )
+{
+	return m_bPreferred;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the number of players preferring this tech
+// Input  : voters - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetVoters( int voters )
+{
+	m_nVoters = voters;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the number of players preferring this tech
+// Output : int
+//-----------------------------------------------------------------------------
+int CBaseTechnology::GetVoters( void )
+{
+	return m_nVoters;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : hide - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetHidden( bool hide )
+{
+	m_bHidden = hide;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::IsHidden( void )
+{
+	return m_bHidden;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::ResetHintsGiven( void )
+{
+	m_HintsGiven.RemoveAll();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CBaseTechnology::GetHintsGiven( int type )
+{
+	if ( m_HintsGiven.Find( type ) != m_HintsGiven.InvalidIndex() )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : given - 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::SetHintsGiven( int type, bool given )
+{
+	if ( given )
+	{
+		if ( m_HintsGiven.Find( type ) != m_HintsGiven.InvalidIndex() )
+			return;
+
+		m_HintsGiven.AddToTail( type );
+	}
+	else
+	{
+		int idx = m_HintsGiven.Find( type );
+		if ( idx == m_HintsGiven.InvalidIndex() )
+			return;
+
+		m_HintsGiven.Remove( idx );
+	}
+}
+
+//====================================================================================================================
+// EVIL GAME DLL ONLY CODE FOR TECHNOLOGIES
+//====================================================================================================================
+#ifndef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::AddTechnologyToPlayer( CBaseTFPlayer *pPlayer )
+{
+	// Tell playerclasses listed to recalculate their technologies, only if they're listed in the class results
+	if ( pPlayer->PlayerClass() )
+	{
+		if ( m_ClassResults[ pPlayer->PlayerClass() ].bClassTouched )
+		{
+			CPlayerClass *pPlayerClass = pPlayer->GetPlayerClass();
+			pPlayerClass->GainedNewTechnology( this );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::AddTechnologyToTeam( CTFTeam *pTeam )
+{
+	SetAvailable( true );
+
+	// Enable all the technologies this group contains
+	if ( m_iContainedTechs )
+	{
+		for (int i = 0; i < m_iContainedTechs; i++ )
+		{
+			if ( m_pContainedTechs[i] )
+			{
+				pTeam->EnableTechnology( m_pContainedTechs[i] );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: A technology watcher entity wants to register as a watcher for this technology
+//-----------------------------------------------------------------------------
+void CBaseTechnology::RegisterWatcher( CInfoCustomTechnology *pWatcher )
+{
+	m_aWatchers.AddToTail( pWatcher );
+	pWatcher->UpdateTechPercentage( 0 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseTechnology::UpdateWatchers( void )
+{
+	// Tell all my watchers
+	for (int i = 0; i < m_aWatchers.Size(); i++ )
+	{
+		m_aWatchers[i]->UpdateTechPercentage( GetOverallLevel() );
+	}
+}
+#else
+//-----------------------------------------------------------------------------
+// Purpose: Client DLL UpdateWatchers does nothing
+//-----------------------------------------------------------------------------
+void CBaseTechnology::UpdateWatchers( void )
+{
+}
+#endif
+
+
+
+
+//====================================================================================================================
+// SHARED TECHNOLOGY TREE
+//====================================================================================================================
+//-----------------------------------------------------------------------------
+// Purpose: Construct raw technology tree
+// Output : 
+//-----------------------------------------------------------------------------
+CTechnologyTree::CTechnologyTree( IFileSystem* pFileSystem, int nTeamNumber )
+{
+	// Reset preference counter
+	ClearPreferenceCount();
+
+	// Parse the list from the data file
+	if ( ParseTechnologyFile( m_Technologies, pFileSystem, nTeamNumber, "scripts/technologytree.txt" ) == false )
+	{
+		Assert(0);
+		return;
+	}
+
+	LinkContainedTechnologies();
+	LinkDependentTechnologies();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Link all the contained technologies
+//-----------------------------------------------------------------------------
+void CTechnologyTree::LinkContainedTechnologies( void )
+{
+	for ( int i=0; i < m_Technologies.Size(); i++)
+	{
+		for ( int j = 0; j < m_Technologies[i]->GetNumberContainedTechs(); j++ )
+		{
+			const char *pName = m_Technologies[i]->GetContainedTechName( j );
+			CBaseTechnology *pTech = GetTechnology( pName );
+			if ( pTech )
+			{
+				m_Technologies[i]->SetContainedTech( j, pTech );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Link all the dependent technologies
+//-----------------------------------------------------------------------------
+void CTechnologyTree::LinkDependentTechnologies( void )
+{
+	for ( int i=0; i < m_Technologies.Size(); i++)
+	{
+		for ( int j = 0; j < m_Technologies[i]->GetNumberDependentTechs(); j++ )
+		{
+			const char *pName = m_Technologies[i]->GetDependentTechName( j );
+			CBaseTechnology *pTech = GetTechnology( pName );
+			if ( pTech )
+			{
+				m_Technologies[i]->SetDependentTech( j, pTech );
+			}
+			else
+			{
+				Warning("Unable to find dependent technology %s!\n", pName );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTechnologyTree::~CTechnologyTree( void )
+{
+	Shutdown();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Delete all items in the tree
+//-----------------------------------------------------------------------------
+void CTechnologyTree::Shutdown( void )
+{
+	// Loop through all used items
+	int iSize = m_Technologies.Size();
+	for ( int i = iSize-1; i >= 0; i-- )
+	{
+		CBaseTechnology *pItem = m_Technologies[ i ];
+		delete pItem;
+	}
+	m_Technologies.Purge();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a new technology to the tree
+//-----------------------------------------------------------------------------
+void CTechnologyTree::AddTechnologyFile( IFileSystem* pFileSystem, int nTeamNumber, char *sFileName )
+{
+	ParseTechnologyFile( m_Technologies, pFileSystem, nTeamNumber, sFileName );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the index of the specified item
+//-----------------------------------------------------------------------------
+int	CTechnologyTree::GetIndex( CBaseTechnology *pItem )
+{
+	for ( int i=0; i < m_Technologies.Size(); i++)
+	{
+		if ( m_Technologies[i] == pItem )
+			return i;
+	}
+
+	return -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Retrieve item by index
+//-----------------------------------------------------------------------------
+CBaseTechnology *CTechnologyTree::GetTechnology( int index )
+{
+	if ( index < 0 || index >= m_Technologies.Size() )
+		return NULL;
+
+	return m_Technologies[ index ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseTechnology* CTechnologyTree::GetTechnology( const char *pName )
+{
+	for ( int i=0; i < m_Technologies.Size(); i++)
+	{
+		if( stricmp( pName, m_Technologies[i]->GetName() ) == 0 )
+			return m_Technologies[i];
+	}
+	
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return current number of objects
+// Output : int
+//-----------------------------------------------------------------------------
+int CTechnologyTree::GetNumberTechnologies( void )
+{
+	return m_Technologies.Size();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set preferred item ( turns off all other preferences first )
+//-----------------------------------------------------------------------------
+void CTechnologyTree::SetPreferredTechnology( CBaseTechnology *pItem )
+{
+	// Turn all of the others off
+	for ( int i = 0; i < m_Technologies.Size(); i++ )
+	{
+		CBaseTechnology *item = m_Technologies[ i ];
+		item->SetPreferred( false );
+	}
+
+	// Turn this one on
+	if ( pItem )
+	{
+		pItem->SetPreferred( true );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the technology preferred by this client
+//-----------------------------------------------------------------------------
+CBaseTechnology* CTechnologyTree::GetPreferredTechnology( void )
+{
+	// Turn all of the others off
+	for ( int i = 0; i < m_Technologies.Size(); i++ )
+	{
+		CBaseTechnology *item = m_Technologies[ i ];
+		if ( item->GetPreferred() )
+			return item;
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the number of players who've voted on techs
+//-----------------------------------------------------------------------------
+int	CTechnologyTree::GetPreferenceCount( void )
+{
+	return m_nPreferenceCount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Zero global preference counters
+//-----------------------------------------------------------------------------
+void CTechnologyTree::ClearPreferenceCount( void )
+{
+	m_nPreferenceCount = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Increment preference counter
+//-----------------------------------------------------------------------------
+void CTechnologyTree::IncrementPreferences( void )
+{
+	m_nPreferenceCount++;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the most voted-for technologies 
+// Input  : iDesireLevel: 1 = Most voted for, 2 = 2nd most voted for, etc
+//-----------------------------------------------------------------------------
+CBaseTechnology *CTechnologyTree::GetDesiredTechnology( int iDesireLevel )
+{
+	Assert( iDesireLevel > 0 && iDesireLevel < m_Technologies.Size() );
+
+	// Dump the techs into a temporary array
+	CBaseTechnology *pSortedTechs[ MAX_TECHNOLOGIES ];
+	int iMaxTech = 0;
+	for ( int i = 0; i < m_Technologies.Size(); i++ )
+	{
+		// Skip Techs that are already available
+		CBaseTechnology *technology = m_Technologies[i];
+		if(!technology)
+			continue;
+
+		if ( technology->GetAvailable() == false )
+		{
+			pSortedTechs[iMaxTech] = m_Technologies[i];
+			iMaxTech++;
+		}
+	}
+
+	// Not enough unresearched techs?
+	if ( iMaxTech < iDesireLevel )
+		return NULL;
+
+	// Bubble sort the tech array into order of desire
+	int swapped = 1;
+	while ( swapped )
+	{
+		swapped = 0;
+		for ( int i = 1; i < iMaxTech; i++ )
+		{
+			if ( pSortedTechs[i]->GetPreferenceCount() > pSortedTechs[i-1]->GetPreferenceCount() )
+			{
+				CBaseTechnology *pTemp = pSortedTechs[i];
+				pSortedTechs[i] = pSortedTechs[i-1];
+				pSortedTechs[i-1] = pTemp;
+				swapped = 1;
+			}
+		}
+	}
+
+	return pSortedTechs[ iDesireLevel - 1 ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find out what percentage of techs in a given level this team owns
+//-----------------------------------------------------------------------------
+float CTechnologyTree::GetPercentageOfTechLevelOwned( int iTechLevel )
+{
+	float fTotalTechs = 0;
+	float fTechsOwned = 0;
+
+	for ( int i = 0; i < m_Technologies.Size(); i++ )
+	{
+		CBaseTechnology *technology = m_Technologies[i];
+		if ( !technology )
+			continue;
+
+		if ( technology->GetLevel() != iTechLevel )
+			continue;
+
+		fTotalTechs++;
+
+		// Do we have it?
+		if ( technology->GetAvailable() )
+		{
+			fTechsOwned++;
+		}
+	}
+
+	if ( !fTotalTechs )
+		return 0.0;
+
+	return ( fTechsOwned / fTotalTechs );
+}
diff --git a/game/shared/tf2/techtree.h b/game/shared/tf2/techtree.h
new file mode 100644
index 0000000..bac9764
--- /dev/null
+++ b/game/shared/tf2/techtree.h
@@ -0,0 +1,320 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( TECHTREE_H )
+#define TECHTREE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+// Evil, Game DLL only code
+#ifndef CLIENT_DLL
+class CBaseTFPlayer;
+class CTFTeam;
+class CInfoCustomTechnology;
+#endif
+
+class IFileSystem;
+
+//===========================================================================================
+// Technology tree defines
+#define MAX_TF_TECHLEVELS				6		// Number of TF2 tech levels
+#define TECHLEVEL_PERCENTAGE_NEEDED		0.5		// Percentage of a tech level that must be owned before the next tech level becomes available
+#define MAX_TECHNOLOGIES				128		// Max number of resource types
+#define MAX_ASSOCIATED_WEAPONS			2		// Max number of weapons that a tech can be associated with
+
+// Indexes into resource arrays
+#define NORMAL_RESOURCES				0
+#define PROCESSED_RESOURCES				1
+#define RESOURCE_TYPES					2
+
+// Tech
+#define TECHNOLOGY_NAME_LENGTH				64		// Max length of a tech name
+#define TECHNOLOGY_PRINTNAME_LENGTH			128		// Max length of a tech's print name
+#define TECHNOLOGY_DESC_LENGTH				256		// Max length of a tech's description
+#define MAX_CONTAINED_TECHNOLOGIES			16		// Max number of technologies that can be contained within another technology
+#define MAX_DEPENDANT_TECHNOLOGIES			16		// Max number of technologies that a tech can depend on
+#define TECHNOLOGY_SOUNDFILENAME_LENGTH		256
+#define TECHNOLOGY_TEXTURENAME_LENGTH		128
+#define TECHNOLOGY_BUTTONNAME_LENGTH		64
+#define TECHNOLOGY_WEAPONNAME_LENGTH		128
+
+// Color codes for Resources
+struct rescolor
+{
+	int r;
+	int g;
+	int b;
+};
+
+// Class result structure for technologies
+struct classresult_t
+{
+	bool	bClassTouched;									// This technology directly affects this class
+	char	pszSoundFile[TECHNOLOGY_SOUNDFILENAME_LENGTH];	// Filename of the sound
+	int		iSound;											// Sound played to members of this class when this technology is achieved
+	char	pszDescription[TECHNOLOGY_DESC_LENGTH];			// Description for this technology shown only to this class
+
+	// If true, then we should determine what weapons should be given to the player
+	//  of this class when this technology is received by looking at the "associated_weapons"
+	// data
+	bool	m_bAssociateWeaponsForClass;
+};
+
+extern char		sResourceName[32];
+extern rescolor sResourceColor;
+
+
+#include "utlvector.h"
+#include "tf_shareddefs.h"
+
+
+//===========================================================================================
+//-----------------------------------------------------------------------------
+// Purpose: A Technology
+//-----------------------------------------------------------------------------
+class CBaseTechnology
+{
+public:
+	// Constructions
+						CBaseTechnology( void );
+	virtual				~CBaseTechnology( void );
+
+	// Data read from the data file
+	virtual void		SetName( const char *pName );
+	virtual void		SetPrintName( const char *pName );
+	virtual void		SetDescription( const char *pDesc );
+	virtual void		SetButtonName( const char *pName );
+	virtual void		SetLevel( int iLevel );
+	virtual void		SetCost( float fResourceCost );
+	virtual void		SetClassResultSound( int iClass, const char *pSound );
+	virtual void		SetClassResultSound( int iClass, int iSound );
+	virtual void		SetClassResultDescription( int iClass, const char *pDesc );
+	virtual void		SetClassResultAssociateWeapons( int iClass, bool associate );
+	virtual void		AddContainedTechnology( const char *pszTech );
+	virtual void		AddDependentTechnology( const char *pszTech );
+
+	// Returns true if the specified class is affected by this technology, or any contained techs
+	virtual bool		AffectsClass( int iClass );
+
+	virtual bool		IsClassUpgrade( void );
+	virtual bool		IsVehicle( void );
+	virtual bool		IsTechLevelUpgrade( void );
+	virtual bool		IsResourceTech( void );
+
+	virtual void		SetHidden( bool hide );
+	virtual bool		IsHidden( void );
+
+	// Used by client to avoid giving you the same hint twice for a technology
+	//  during a game/session
+	virtual void		ResetHintsGiven( void );
+	virtual bool		GetHintsGiven( int type );
+	virtual void		SetHintsGiven( int type, bool given );
+
+	// Returns the level to which this technology belongs
+	virtual int			GetLevel( void );
+	// Returns the internal name of the technology ( no spaces )
+	virtual const char	*GetName( void );
+	// Returns the printable name of the technology
+	virtual const char	*GetPrintName( void );
+	// Returns the button name of the technology;
+	virtual const char	*GetButtonName( void );
+	// Returns the non-class specific description of this technology
+	virtual const char  *GetDescription( int iPlayerClass );
+	// Returns the sound to play for this technology
+	virtual const char	*GetSoundFile( int iClass );
+	virtual int			GetSound( int iClass );
+	// Set availability of the technology for the specified team
+	virtual void		SetAvailable( bool state );
+	// Returns true if the team has the technology
+	virtual int			GetAvailable( void );
+	// Zero out all preference/voting by players
+	virtual void		ZeroPreferences( void );
+	// Add one to the preference count for this technology for the specified team
+	virtual void		IncrementPreferences( void );
+	// Retrieve the number of player's who want to vote for this technology
+	virtual int			GetPreferenceCount( void );
+
+	// Retrieves the cost of purchasing the technology (doesn't factor in the resource levels)
+	float				GetResourceCost( void );
+	
+	// Retrieves the current amount of resources spent on the technology
+	float				GetResourceLevel( void );
+
+	// Sets a resource level to an amount
+	void				SetResourceLevel( float flResourceLevel );
+	// Spends resources on buying this technology
+	bool				IncreaseResourceLevel( float flResourcesToSpend );
+	// Figure out my overall owned percentage
+	void				RecalculateOverallLevel( void );
+	float				GetOverallLevel( void );
+	void				ForceComplete( void );
+
+	// Goal technologies ( Techs related to a team's goal in a map )
+	bool				IsAGoalTechnology( void );
+	void				SetGoalTechnology( bool bGoal );
+
+	// Check if class wants to enumerate weapon associations
+	bool				GetAssociateWeaponsForClass( int iClass );
+
+	// Weapon associatations
+	int					GetNumWeaponAssociations( void );
+	char const			*GetAssociatedWeapon( int index );
+	void				AddAssociatedWeapon( const char *weaponname );
+
+	// Contained Technology access
+	int					GetNumberContainedTechs( void );
+	const char			*GetContainedTechName( int iTech );
+	void				SetContainedTech( int iTech, CBaseTechnology *pTech );
+
+	// Dependent Technology access
+	int					GetNumberDependentTechs( void );
+	const char			*GetDependentTechName( int iTech );
+	void				SetDependentTech( int iTech, CBaseTechnology *pTech );
+	bool				DependsOn( CBaseTechnology *pTech );
+	bool				HasInactiveDependencies( void );
+
+	// Dirty bit, used for fast knowledge of when to resend techs
+	bool				IsDirty( void );
+	void				SetDirty( bool bDirty );
+
+// Evil, Game DLL only code
+#ifndef CLIENT_DLL
+	// The technology has been acquired by the team.
+	virtual void		AddTechnologyToTeam( CTFTeam *pTeam );
+	// The technology has just been acquired, for each player on the acquiring team
+	//  ask the technology to add any necessary weapons/items/abilities/modifiers, etc.
+	virtual void		AddTechnologyToPlayer( CBaseTFPlayer *player );
+	// A technology watcher entity wants to register as a watcher for this technology
+	virtual void		RegisterWatcher( CInfoCustomTechnology *pWatcher );
+	CUtlVector< CInfoCustomTechnology* > m_aWatchers;
+#endif
+
+	void				UpdateWatchers( void );
+
+	// Hud Data
+	void				SetActive( bool state );
+	bool				GetActive( void );
+	void				SetPreferred( bool state );
+	bool				GetPreferred( void );
+	void				SetVoters( int voters );
+	int					GetVoters( void );
+
+	void				SetTextureName( const char *texture );
+	const char			*GetTextureName( void );
+	void				SetTextureId( int id );
+	int					GetTextureId( void );
+
+private:
+	// Name of the technology. Used to identify it in code.
+	char				m_pszName[ TECHNOLOGY_NAME_LENGTH ];
+	// Print name of the technology. Used to print the name of this technology to users.
+	char				m_pszPrintName[ TECHNOLOGY_PRINTNAME_LENGTH ];
+	// Button name of technology in the tech tree
+	char				m_szButtonName[ TECHNOLOGY_BUTTONNAME_LENGTH ];
+	// Description of the technology
+	char				m_pszDescription[ TECHNOLOGY_DESC_LENGTH ];
+	// Level to which the technology belongs
+	int					m_nTechLevel;
+	// Sound played to the entire team when this technology is received
+	char				m_pszTeamSoundFile[ TECHNOLOGY_SOUNDFILENAME_LENGTH ];
+	int					m_iTeamSound;
+	// Results for this technology when it's achieved, on a per-class basis
+	classresult_t		m_ClassResults[ TFCLASS_CLASS_COUNT ];
+
+	// Resource costs
+	float				m_fResourceCost;
+	// Resource levels (amount of resource spent on the technology so far)
+	float				m_fResourceLevel; 
+	float				m_flOverallOwnedPercentage;
+
+	// Technologies contained within this one
+	char				m_apszContainedTechs[ MAX_CONTAINED_TECHNOLOGIES ][ TECHNOLOGY_NAME_LENGTH ];
+	int					m_iContainedTechs;
+	CBaseTechnology		*m_pContainedTechs[ MAX_CONTAINED_TECHNOLOGIES ];
+
+	// Technologies this tech depends on
+	char				m_apszDependentTechs[ MAX_DEPENDANT_TECHNOLOGIES ][ TECHNOLOGY_NAME_LENGTH ];
+	int					m_iDependentTechs;
+	CBaseTechnology		*m_pDependentTechs[ MAX_DEPENDANT_TECHNOLOGIES ];
+
+	// Weapon association
+	int					m_nNumWeaponAssociations;
+	char				m_rgszWeaponAssociation[ MAX_ASSOCIATED_WEAPONS ][ TECHNOLOGY_WEAPONNAME_LENGTH ];
+
+	// Does the team have access to the technology
+	bool				m_bAvailable;
+
+	// Is this a "placeholder" tech that shouldn't show up in the real tree
+	bool				m_bHidden;
+
+	CUtlVector< int >	m_HintsGiven;
+
+	// Count of how many team members voted for this technology for spending resources
+	int					m_nPreferenceCount;
+
+	bool				m_bGoalTechnology;	// True if this tech's related to a team's goal in the current map
+	bool				m_bClassUpgrade; // True if the tech unlocks a new class
+	bool				m_bVehicle; // True if the tech unlocks a vehicle
+	bool				m_bTechLevelUpgrade;  // True if the tech unlocks a new tech level
+	bool				m_bResourceTech; // True if related to resource gathering
+
+	// Dirty bit, used for fast knowledge of when to resend techs
+	bool				m_bDirty;
+
+	// Hud data
+	bool				m_bActive;
+	bool				m_bPreferred;
+	int					m_nVoters;
+	
+	int					m_nTextureID;
+	char				m_szTextureName[ TECHNOLOGY_TEXTURENAME_LENGTH ];
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: The Technology Tree.
+//-----------------------------------------------------------------------------
+class CTechnologyTree
+{
+public:
+	// Construction
+					CTechnologyTree( IFileSystem* pFileSystem, int nTeamNumber );
+	virtual			~CTechnologyTree( void );
+
+	// Startup/shutdown
+	void			Shutdown( void );
+	
+	// Accessors
+	void			AddTechnologyFile( IFileSystem* pFileSystem, int nTeamNumber, char *sFileName );
+	void			LinkContainedTechnologies( void );
+	void			LinkDependentTechnologies( void );
+	int				GetIndex( CBaseTechnology *pItem );		// Get the index of the specified item
+	CBaseTechnology *GetTechnology( int index );
+	CBaseTechnology *GetTechnology( const char *pName );
+	float			GetPercentageOfTechLevelOwned( int iTechLevel );
+
+	// Size of list
+	int				GetNumberTechnologies( void );
+
+	// Local client's preferred item
+	void			SetPreferredTechnology( CBaseTechnology *pItem );
+	CBaseTechnology *GetPreferredTechnology( void );
+
+	// Preference handling
+	void			ClearPreferenceCount( void );
+	void			IncrementPreferences( void );
+	int				GetPreferenceCount( void );				// Get the number of players who've voted on techs
+	CBaseTechnology *GetDesiredTechnology( int iDesireLevel );
+
+	// Growable list of technologies
+	CUtlVector< CBaseTechnology * > m_Technologies;
+
+	int				m_nPreferenceCount;
+};
+
+
+#endif // TECHTREE_H
\ No newline at end of file
diff --git a/game/shared/tf2/techtree_parse.cpp b/game/shared/tf2/techtree_parse.cpp
new file mode 100644
index 0000000..4b05d2b
--- /dev/null
+++ b/game/shared/tf2/techtree_parse.cpp
@@ -0,0 +1,183 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Shared code that parse the Technology Tree on the client & server.
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "utlvector.h"
+#include "tf_shareddefs.h"
+#include "techtree.h"
+#include <KeyValues.h>
+#include "filesystem.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Parse a class result chunk inside a technology keyvalue
+//-----------------------------------------------------------------------------
+void ParseClassResult( CBaseTechnology *pTechnology, KeyValues *pkvResult, int iClass )
+{
+	if ( !pkvResult )
+		return;
+
+	// All is a special case, used by general technologies
+	if ( iClass == TFCLASS_CLASS_COUNT )
+	{
+		for (int i = TFCLASS_RECON; i < TFCLASS_CLASS_COUNT; i++)
+		{
+			pTechnology->SetClassResultSound( i, pkvResult->GetString( "sound", NULL ) );
+			pTechnology->SetClassResultDescription( i, pkvResult->GetString( "description", NULL ) );
+			pTechnology->SetClassResultAssociateWeapons( i, pkvResult->GetInt( "associateweapons", 0 ) ? true : false );
+		}
+	}
+	else
+	{
+		pTechnology->SetClassResultSound( iClass, pkvResult->GetString( "sound", NULL ) );
+		pTechnology->SetClassResultDescription( iClass, pkvResult->GetString( "description", NULL ) );
+		pTechnology->SetClassResultAssociateWeapons( iClass, pkvResult->GetInt( "associateweapons", 0 ) ? true : false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Parse a technology from a keyvalues chunk in the data file
+//-----------------------------------------------------------------------------
+void ParseTechnology( CBaseTechnology *pTechnology, KeyValues *pkvTech )
+{
+	// Get the general data
+	pTechnology->SetName( pkvTech->GetName() );
+	pTechnology->SetPrintName( pkvTech->GetString( "printname", "" ) );
+	// Use the print name if no button name specified
+	pTechnology->SetButtonName( pkvTech->GetString( "buttonname", pTechnology->GetPrintName() ) );
+	pTechnology->SetDescription( pkvTech->GetString( "description", "" ) );
+	pTechnology->SetTextureName( pkvTech->GetString( "texture", "" ) );
+	pTechnology->SetLevel( pkvTech->GetInt( "level", 0 ) );
+	pTechnology->SetGoalTechnology( pkvTech->GetInt( "goal", 0 ) > 0 );
+	pTechnology->SetHidden( pkvTech->GetInt( "hidden", 0 ) != 0 );
+
+	// Retrieve weapon associations
+	KeyValues *pkvWeaponAssociations = pkvTech->FindKey( "associated_weapons" );
+	if ( pkvWeaponAssociations )
+	{
+		KeyValues *pkvWA = pkvWeaponAssociations->GetFirstSubKey();
+		while ( pkvWA )
+		{
+			const char *weaponname = pkvWA->GetString();
+			if ( weaponname && weaponname[ 0 ] )
+			{
+				pTechnology->AddAssociatedWeapon( weaponname );
+			}
+
+			pkvWA = pkvWA->GetNextKey();
+		}
+	}
+
+	// Get the cost
+	pTechnology->SetCost( pkvTech->GetFloat( "resourcecost", 0.0 ) );
+
+	// Get the class results
+	KeyValues *pkvClassResults = pkvTech->FindKey( "class_results" );
+	if ( pkvClassResults )
+	{
+		// Try and get each class result
+		for ( int iClass=0; iClass < TFCLASS_CLASS_COUNT; iClass++ )
+		{
+			ParseClassResult( pTechnology, pkvClassResults->FindKey( GetTFClassInfo( iClass )->m_pClassName ), iClass );
+		}
+		
+		ParseClassResult( pTechnology, pkvClassResults->FindKey( "all" ), TFCLASS_CLASS_COUNT );
+	}
+
+	// Get any technologies contained within this one
+	KeyValues *pkvTechnologies = pkvTech->FindKey( "technologies" );
+	if ( pkvTechnologies )
+	{
+		KeyValues *pkvTechnology = pkvTechnologies->GetFirstSubKey();
+		int iContainedTechs = 0;
+		while ( pkvTechnology )
+		{
+			if ( iContainedTechs >= MAX_CONTAINED_TECHNOLOGIES )
+				break;
+
+			pTechnology->AddContainedTechnology( pkvTechnology->GetString() ); 
+
+			iContainedTechs++;
+			pkvTechnology = pkvTechnology->GetNextKey();
+		}
+	}
+
+	// Get any dependencies for this tech
+	KeyValues *pkvDependencies = pkvTech->FindKey( "dependencies" );
+	if ( pkvDependencies )
+	{
+		KeyValues *pkvTechnology = pkvDependencies->GetFirstSubKey();
+		int iDependentTechs = 0;
+		while ( pkvTechnology )
+		{
+			if ( iDependentTechs >= MAX_DEPENDANT_TECHNOLOGIES )
+				break;
+
+			pTechnology->AddDependentTechnology( pkvTechnology->GetString() ); 
+
+			iDependentTechs++;
+			pkvTechnology = pkvTechnology->GetNextKey();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Parse the technology tree file and dump the data into the utlvector list
+//-----------------------------------------------------------------------------
+bool ParseTechnologyFile( CUtlVector< CBaseTechnology * > &pTechnologyList, IFileSystem* filesystem, int nTeamNumber, char *sFileName )
+{
+	// Open the technology tree datafile
+	KeyValues *pkvTechTreeFile = new KeyValues( "TechTreeDataFile" );
+	if ( pkvTechTreeFile->LoadFromFile( filesystem, sFileName, "GAME" ) == false )
+		return false;
+	
+	// Parse the list of techs
+	KeyValues *pkvTech = pkvTechTreeFile->GetFirstSubKey();
+	while ( pkvTech )
+	{
+		// Reached the maximum number of techs allowed?
+		if ( pTechnologyList.Size() >= MAX_TECHNOLOGIES )
+		{
+			pkvTechTreeFile->deleteThis();
+			return false;
+		}
+
+		// Create the technology
+		CBaseTechnology *pTechnology = NULL;
+		int nTeamTech = pkvTech->GetInt( "team", 0 );
+		if ((nTeamTech == 0) || (nTeamTech == nTeamNumber))
+		{
+			pTechnology = new CBaseTechnology();
+			ParseTechnology( pTechnology, pkvTech );
+
+			// Find out if it's already in the list
+			for ( int i = 0; i < pTechnologyList.Size(); i++ )
+			{
+				if ( !strcmp(pTechnologyList[i]->GetName(), pTechnology->GetName() ) )
+				{
+					// Found it in the tree already, so delete and continue
+					delete pTechnology;
+					pTechnology = NULL;
+					break;
+				}
+			}
+		}
+
+		// If we haven't deleted it, add it to the list
+		if ( pTechnology )
+		{
+			pTechnologyList.AddToTail( pTechnology );
+		}
+
+		pkvTech = pkvTech->GetNextKey();
+	}
+
+	pkvTechTreeFile->deleteThis();
+	return true;
+}
+
diff --git a/game/shared/tf2/tf_gamemovement.cpp b/game/shared/tf2/tf_gamemovement.cpp
new file mode 100644
index 0000000..46366d9
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement.cpp
@@ -0,0 +1,2149 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement.h"
+#include "in_buttons.h"
+#include "tier0/vprof.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+
+#define	SPEED_STOP_THRESHOLD		1.0f
+#define BUMP_MAX_COUNT				8
+
+//#define IMPACT_NORMAL_FLOOR			0.35f
+#define	IMPACT_NORMAL_FLOOR			0.7f
+#define IMPACT_NORMAL_WALL			0.0f
+
+enum
+{
+	MOVEMENT_BLOCKED_NONE  = 0x0,
+	MOVEMENT_BLOCKED_WALL  = 0x1,
+	MOVEMENT_BLOCKED_FLOOR = 0x2,
+	MOVEMENT_BLOCKED_ALL   = 0x4
+};
+
+#define SPEED_CROP_FRACTION_WALKING		0.4f
+#define SPEED_CROP_FRACTION_USING		0.3f
+#define SPEED_CROP_FRACTION_DUCKING		0.3f
+
+char    *va(char *format, ...);
+
+extern bool g_bMovementOptimizations;
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::CategorizePosition( void )
+{
+	VPROF( "CTFGameMovement::CategorizePosition" );
+
+	// Doing this before we move may introduce a potential latency in water detection, but
+	// doing it after can get us stuck on the bottom in water if the amount we move up
+	// is less than the 1 pixel 'threshold' we're about to snap to.	Also, we'll call
+	// this several times per frame, so we really need to avoid sticking to the bottom of
+	// water on each call, and the converse case will correct itself if called twice.
+	CheckWater();
+
+	trace_t trace;
+	Vector vStart( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z );
+	Vector vEnd( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z - 66 );
+
+	// Assume we are not on the ground
+	SetGroundEntity( NULL );
+	m_pSurfaceData = NULL;
+	m_surfaceFriction = 1.0f;
+	m_chTextureType = 'C';
+
+	// Check our velocity in z (are we shooting up really fast - then we are not on ground).
+	if ( mv->m_vecVelocity.z <= 180.0f )
+	{
+		// Move downward.
+		TracePlayerBBox( vStart, vEnd, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+
+		// Check to see if we are on the ground
+		if ( ( ( trace.plane.normal.z >= IMPACT_NORMAL_FLOOR ) || trace.IsDispSurfaceWalkable() ) && ( trace.fraction < 0.06f ) )
+		{
+			SetGroundEntity( &trace );
+			VectorCopy( trace.plane.normal, m_vecGroundNormal );
+
+			// Add standing on object to touch list
+			if ( trace.DidHitNonWorldEntity() )
+			{
+				MoveHelper()->AddToTouched( trace, mv->m_vecVelocity );
+			}
+
+			// Reset water jumping.
+			player->m_flWaterJumpTime = 0.0f;
+
+			// If we could make the move, drop us down that 1 pixel
+			if ( ( int )player->GetWaterLevel() < WL_Waist && !trace.startsolid && !trace.allsolid )
+			{
+				// check distance we would like to move -- this is supposed to just keep up
+				// "on the ground" surface not stap us back to earth
+				mv->m_vecAbsOrigin = vStart + trace.fraction * ( vEnd - vStart );
+//				VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+			}		
+		}
+
+		// NOTE: should this be surrounded by trace.fraction <= 1.0f ?????
+
+		// Setup surface properties.
+		{
+			VPROF( "CTFGameMovement::CategorizePosition / Surface Props" );
+			IPhysicsSurfaceProps *physprops = MoveHelper( )->GetSurfaceProps();
+			m_surfaceProps = trace.surface.surfaceProps;
+			m_pSurfaceData = physprops->GetSurfaceData( m_surfaceProps );
+			physprops->GetPhysicsProperties( m_surfaceProps, NULL, NULL, &m_surfaceFriction, NULL );
+		}
+
+		// HACKHACK: Scale this to fudge the relationship between vphysics friction values and player friction values.
+		// A value of 0.8f feels pretty normal for vphysics, whereas 1.0f is normal for players.
+		// This scaling trivially makes them equivalent.  REVISIT if this affects low friction surfaces too much.
+		m_surfaceFriction *= 1.25f;
+		if ( m_surfaceFriction > 1.0f )
+			m_surfaceFriction = 1.0f;
+		m_chTextureType = m_pSurfaceData->game.material;
+	}
+
+	// If we are not on the ground...
+	if ( player->GetGroundEntity() == NULL )
+	{
+		player->m_Local.m_flFallVelocity = -mv->m_vecVelocity.z;
+	}
+
+	// Store off the starting water level
+	m_nOldWaterLevel = player->GetWaterLevel();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::HandleLadder( void )
+{
+	// No ladder movement if the player is dead or on a train.
+	if ( player->pl.deadflag || ( player->GetFlags() & FL_ONTRAIN ) )
+		return;
+
+	// Ladder initialization.
+	m_nOnLadder = 0;
+
+	if ( !BaseClass::LadderMove() && ( player->GetMoveType() == MOVETYPE_LADDER ) )
+	{
+		// clear ladder stuff unless player is noclipping or being lifted by barnacle. 
+		// it will be set immediately again next frame if necessary
+		player->SetMoveType( MOVETYPE_WALK );
+		player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::SpeedCrop( void )
+{
+	// Verify speed hasn't been cropped already (shouldn't have!!!).
+	if ( m_iSpeedCropped & SPEED_CROPPED_DUCK )
+		return;
+
+	// Set the speed cropped flag.
+	m_iSpeedCropped		|= SPEED_CROPPED_DUCK;
+
+	// If the "walking" key is pressed -- crop speed.
+	if ( mv->m_nButtons & IN_SPEED )
+	{
+		mv->m_flForwardMove *= SPEED_CROP_FRACTION_WALKING;
+		mv->m_flSideMove *= SPEED_CROP_FRACTION_WALKING;
+		mv->m_flUpMove *= SPEED_CROP_FRACTION_WALKING;
+	}
+	// If the "use" key is pressed and the player is on the ground -- crop speed.
+	else if ( ( mv->m_nButtons & IN_USE ) && ( player->GetGroundEntity() != NULL ) )
+	{
+		mv->m_flForwardMove *= SPEED_CROP_FRACTION_USING;
+		mv->m_flSideMove *= SPEED_CROP_FRACTION_USING;
+		mv->m_flUpMove *= SPEED_CROP_FRACTION_USING;
+	}
+	// If the player is "ducking" -- crop speed
+	else if ( player->GetFlags() & FL_DUCKING )
+	{
+		mv->m_flForwardMove *= SPEED_CROP_FRACTION_DUCKING;
+		mv->m_flSideMove *= SPEED_CROP_FRACTION_DUCKING;
+		mv->m_flUpMove *= SPEED_CROP_FRACTION_DUCKING;
+	}
+
+	// Moving backwards happens more slowly
+	float flAngle = atan2( mv->m_flSideMove, mv->m_flForwardMove ) / M_PI;
+	flAngle = 2.0f * (fabs(flAngle) - 0.5f);
+	flAngle = clamp( flAngle, 0.0f, 1.0f );
+	float flFactor = 1.0f - fabs(flAngle) * (1.0f - sv_backspeed.GetFloat());
+
+	mv->m_flForwardMove *= flFactor;
+	mv->m_flSideMove *= flFactor;
+}
+
+
+//-----------------------------------------------------------------------------
+// Figures out how the constraint should slow us down
+//-----------------------------------------------------------------------------
+float CTFGameMovement::ComputeConstraintSpeedFactor( void )
+{
+	// If we have a constraint, slow down because of that too...
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove || pTFMove->m_flConstraintRadius == 0.0f )
+		return 1.0f;
+
+	float flDistSq = mv->m_vecAbsOrigin.DistToSqr( pTFMove->m_vecConstraintCenter );
+
+	float flOuterRadiusSq = pTFMove->m_flConstraintRadius * pTFMove->m_flConstraintRadius;
+	float flInnerRadiusSq = pTFMove->m_flConstraintRadius - pTFMove->m_flConstraintWidth;
+	flInnerRadiusSq *= flInnerRadiusSq;
+
+	// Only slow us down if we're inside the constraint ring
+	if ((flDistSq <= flInnerRadiusSq) || (flDistSq >= flOuterRadiusSq))
+		return 1.0f;
+
+	// Only slow us down if we're running away from the center
+	Vector vecDesired;
+	VectorMultiply( m_vecForward, mv->m_flForwardMove, vecDesired );
+	VectorMA( vecDesired, mv->m_flSideMove, m_vecRight, vecDesired );
+	VectorMA( vecDesired, mv->m_flUpMove, m_vecUp, vecDesired );
+
+	Vector vecDelta;
+	VectorSubtract( mv->m_vecAbsOrigin, pTFMove->m_vecConstraintCenter, vecDelta );
+	VectorNormalize( vecDelta );
+	VectorNormalize( vecDesired );
+	if (DotProduct( vecDelta, vecDesired ) < 0.0f)
+		return 1.0f;
+
+	float flFrac = (sqrt(flDistSq) - (pTFMove->m_flConstraintRadius - pTFMove->m_flConstraintWidth)) / pTFMove->m_flConstraintWidth;
+
+	float flSpeedFactor = Lerp( flFrac, 1.0f, pTFMove->m_flConstraintSpeedFactor ); 
+	return flSpeedFactor;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Called in PrePlayerMove(), this function clamps the player's overall
+//          speed.  It is clamped to either the maximum client's or server's 
+//          speed (whichever is lower).
+//-----------------------------------------------------------------------------
+void CTFGameMovement::SetupSpeed( void )
+{
+	// Reset the outgoing applied velocity.
+	mv->m_outWishVel.Init();
+
+	// Don't clamp speed if we are sin an "ISOMETRIC" or "NOCLIP" movetype.
+	if ( ( player->GetMoveType() == MOVETYPE_ISOMETRIC ) ||
+		 ( player->GetMoveType() == MOVETYPE_NOCLIP ) )
+		 return;
+
+	// Some events negate speed, check for these first.
+	if ( ( player->GetFlags() & FL_FROZEN ) || ( player->GetFlags() & FL_ONTRAIN ) ||  IsDead() )
+	{
+		mv->m_flForwardMove = 0;
+		mv->m_flSideMove = 0;
+		mv->m_flUpMove = 0;
+		return;
+	}
+
+	// Calculate the players max speed given movements.
+	float flSpeed = ( mv->m_flForwardMove * mv->m_flForwardMove ) +
+		            ( mv->m_flSideMove * mv->m_flSideMove ) +
+			 	    ( mv->m_flUpMove * mv->m_flUpMove );
+	if ( flSpeed == 0.0f )
+		return;
+
+	flSpeed = sqrt( flSpeed );
+
+	// NOTE: The client max speed was set to the movement max speed (mv->m_flMaxSpeed)
+	//       in the SetupMove, however the _ProcessMovement code post sets
+	//       mv->m_flMaxSpeed to the maximum server speed (sv_maxspeed),
+	//       thus, the need to the check.  If we forego the maximum server speed, 
+	//       this code can be removed.
+	if ( mv->m_flClientMaxSpeed )
+	{
+		mv->m_flMaxSpeed = MIN( mv->m_flClientMaxSpeed, mv->m_flMaxSpeed );
+	}
+
+	// Slow down by the speed factor
+	float flSpeedFactor = 1.0f;
+	if (m_pSurfaceData)
+	{
+		flSpeedFactor = m_pSurfaceData->game.maxSpeedFactor;
+	}
+
+	// If we have a constraint, slow down because of that too...
+	// Get the TF movement data
+	float flConstraintSpeedFactor = ComputeConstraintSpeedFactor();
+	if (flConstraintSpeedFactor < flSpeedFactor)
+		flSpeedFactor = flConstraintSpeedFactor;
+
+	mv->m_flMaxSpeed *= flSpeedFactor;
+
+	if ( flSpeed > mv->m_flMaxSpeed )
+	{
+		float flRatio = mv->m_flMaxSpeed / flSpeed;
+		mv->m_flForwardMove *= flRatio;
+		mv->m_flSideMove *= flRatio;
+		mv->m_flUpMove *= flRatio;
+	}
+
+	// Crop speed if necessary.
+	SpeedCrop();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::FinishUnDuck( void )
+{
+	int i;
+	trace_t trace;
+	Vector newOrigin;
+
+	Vector vDuckHullMin = GetPlayerMins( true );
+	Vector vStandHullMin = GetPlayerMins( false );
+
+	VectorCopy( mv->m_vecAbsOrigin, newOrigin );
+
+	if ( player->GetGroundEntity() != NULL )
+	{
+		for ( i = 0; i < 3; i++ )
+		{
+			newOrigin[i] += ( vDuckHullMin[i] - vStandHullMin[i] );
+		}
+	}
+	else
+	{
+  		Vector viewDelta = player->GetViewOffset() - GetPlayerViewOffset( false );
+		VectorAdd( newOrigin, viewDelta, newOrigin );
+	}
+	
+	TracePlayerBBox( newOrigin, newOrigin, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+	if ( !trace.startsolid )
+	{
+		player->m_Local.m_bDucked = false;
+
+		// Oh, no, changing hulls stuck us into something, try unsticking downward first.
+		TracePlayerBBox( newOrigin, newOrigin, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+		if ( trace.startsolid )
+		{
+			// See if we are stuck?  If so, stay ducked with the duck hull until we have a clear spot
+			player->m_Local.m_bDucked = true;
+			return;
+		}
+
+		player->RemoveFlag( FL_DUCKING );
+		player->m_Local.m_bDucking  = false;
+		player->SetViewOffset( GetPlayerViewOffset( false ) );
+		player->m_Local.m_flDucktime = 0;
+		
+		VectorCopy( newOrigin, mv->m_vecAbsOrigin );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::HandleDuck( void )
+{
+	// Store button presses and changes.
+	int buttonsChanged	= ( mv->m_nOldButtons ^ mv->m_nButtons );	// These buttons have changed this frame
+	int buttonsPressed	=  buttonsChanged & mv->m_nButtons;			// The changed ones still down are "pressed"
+	int buttonsReleased	=  buttonsChanged & mv->m_nOldButtons;		// The changed ones which were previously down are "released"
+
+	if ( mv->m_nButtons & IN_DUCK )
+	{
+		mv->m_nOldButtons |= IN_DUCK;
+	}
+	else
+	{
+		mv->m_nOldButtons &= ~IN_DUCK;
+	}
+
+	// Handle the player dead case.
+	if ( IsDead() && ( player->GetFlags() & FL_DUCKING ) )
+	{
+		FinishUnDuck();
+		return;
+	}
+
+	if ( ( mv->m_nButtons & IN_DUCK ) || ( player->m_Local.m_bDucking ) || ( player->GetFlags() & FL_DUCKING ) )
+	{
+		// Remove all movement when ducking!
+		mv->m_flForwardMove = 0.0f;
+		mv->m_flSideMove = 0.0f;
+		mv->m_flUpMove = 0.0f;
+
+		if ( mv->m_nButtons & IN_DUCK )
+		{
+			if ( ( buttonsPressed & IN_DUCK ) && !( player->GetFlags() & FL_DUCKING ) )
+			{
+				// Use 1 second so super long jump will work
+				player->m_Local.m_flDucktime = 1000;
+				player->m_Local.m_bDucking    = true;
+			}
+
+			float duckmilliseconds = MAX( 0.0f, 1000.0f - (float)player->m_Local.m_flDucktime );
+			float duckseconds = duckmilliseconds / 1000.0f;
+			
+			if ( player->m_Local.m_bDucking )
+			{
+				// Finish ducking immediately if duck time is over or not on ground
+				if ( ( duckseconds > TIME_TO_DUCK ) || 
+					( player->GetGroundEntity() == NULL ) )
+				{
+					FinishDuck();
+				}
+				else
+				{
+					// Calc parametric time
+					float duckFraction = SimpleSpline( duckseconds / TIME_TO_DUCK );
+					SetDuckedEyeOffset( duckFraction );
+				}
+			}
+		}
+		else
+		{
+			if ( (buttonsReleased & IN_DUCK ) && ( player->GetFlags() & FL_DUCKING ) )
+			{
+				// Use 1 second so super long jump will work
+				player->m_Local.m_flDucktime = 1000;
+				player->m_Local.m_bDucking    = true;  // or unducking
+			}
+
+			float duckmilliseconds = MAX( 0.0f, 1000.0f - (float)player->m_Local.m_flDucktime );
+			float duckseconds = duckmilliseconds / 1000.0f;
+
+			if ( player->m_Local.m_bDucking ) // or unducking
+			{
+				// Finish ducking immediately if duck time is over or not on ground
+				if ( ( duckseconds > TIME_TO_UNDUCK ) ||
+					 ( player->GetGroundEntity() == NULL ) )
+				{
+					FinishUnDuck();
+				}
+				else
+				{
+					// Calc parametric time
+					float duckFraction = SimpleSpline( 1.0f - ( duckseconds / TIME_TO_UNDUCK ) );
+					SetDuckedEyeOffset( duckFraction );
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::SetupViewAngles( void )
+{
+	// Cache the view angles.
+	AngleVectors( mv->m_vecViewAngles, &m_vecForward, &m_vecRight, &m_vecUp );
+
+	// Add a view punch if necessary.
+	QAngle	v_angle = ( mv->m_vecViewAngles + player->m_Local.m_vecPunchAngle );
+	
+	// Adjust the view roll angle.
+	if ( ( player->GetMoveType() != MOVETYPE_ISOMETRIC ) && ( player->GetMoveType() != MOVETYPE_NOCLIP ) )
+	{
+		mv->m_vecViewAngles[ROLL] = CalcRoll( v_angle, mv->m_vecVelocity, sv_rollangle.GetFloat(), sv_rollspeed.GetFloat() ) * 4.0f;
+	}
+	else
+	{
+		mv->m_vecViewAngles[ROLL] = 0.0f;
+	}
+
+	// Copy the yaw and pitch.
+	// NOTE: Adjust the client view angles to match the values on the server.
+	mv->m_vecViewAngles[PITCH] = v_angle[PITCH];
+	mv->m_vecViewAngles[YAW] = v_angle[YAW];
+	if ( mv->m_vecViewAngles[YAW] > 180.0f )
+	{
+		mv->m_vecViewAngles[YAW] -= 360.0f;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::CheckDeath( void )
+{
+	// If we are dead, setup the appropriate data
+	if ( IsDead() )
+	{
+		mv->m_flForwardMove = 0.0f;
+		mv->m_flSideMove = 0.0f;
+		mv->m_flUpMove = 0.0f;
+
+		VectorCopy( mv->m_vecOldAngles, mv->m_vecViewAngles );
+
+		player->SetViewOffset( VEC_DEAD_VIEWHEIGHT_SCALED( this ) );
+
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::UpdateTimers( void )
+{
+	BaseClass::ReduceTimers();
+	BaseClass::DecayPunchAngle();
+}
+
+
+//-----------------------------------------------------------------------------
+// Should the step sound play?
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::ShouldPlayStepSound( surfacedata_t *psurface, float fvol )
+{
+	if ( !m_nOnLadder && Vector2DLength( mv->m_vecVelocity.AsVector2D() ) <= 100 )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : step - 
+//			fvol - 
+//			force - force sound to play
+//-----------------------------------------------------------------------------
+void CTFGameMovement::PlayStepSound( surfacedata_t *psurface, float fvol, bool force )
+{
+	if ( gpGlobals->maxClients > 1 && !sv_footsteps.GetFloat() )
+		return;
+
+	if ( !psurface )
+		return;
+
+	if (!force && !ShouldPlayStepSound( psurface, fvol ))
+		return;
+
+// TODO:  See note above, should this be hooked up?
+//	PlantFootprint( psurface );
+
+	unsigned short stepSoundName = player->m_Local.m_nStepside ? psurface->sounds.stepleft : psurface->sounds.stepright;
+	player->m_Local.m_nStepside = !player->m_Local.m_nStepside;
+
+	if ( !stepSoundName )
+		return;
+
+	if ( !mv->m_bFirstRunOfFunctions )
+		return;
+
+	IPhysicsSurfaceProps *physprops = MoveHelper( )->GetSurfaceProps();
+	const char *pSoundName = physprops->GetString( stepSoundName );
+	char szSound[256];
+
+	// Prepend our team's footsteps
+	if ( player->GetTeamNumber() == TEAM_HUMANS )
+	{
+		Q_snprintf( szSound, sizeof(szSound), "Human.%s", pSoundName );
+	}
+	else if ( player->GetTeamNumber() == TEAM_ALIENS )
+	{
+		Q_snprintf( szSound, sizeof(szSound), "Alien.%s", pSoundName );
+	}
+	else
+	{
+		return;
+	}
+
+	CSoundParameters params;
+	if ( !CBaseEntity::GetParametersForSound( szSound, params, NULL ) )
+		return;
+
+	MoveHelper( )->StartSound( mv->m_vecAbsOrigin, CHAN_BODY, params.soundname, fvol, params.soundlevel, 0, params.pitch );
+}	
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+int CTFGameMovement::CheckStuck( void )
+{
+	VPROF( "CTFGameMovement::CheckStuck" );
+
+	// NOTE: I am not bothering much with this as I am going to 
+	//       implement an new UnSticking process.
+	if ( ( player->GetMoveType() == MOVETYPE_NOCLIP ) ||
+         ( player->GetMoveType() == MOVETYPE_NONE ) ||
+		 ( player->GetMoveType() == MOVETYPE_ISOMETRIC ) )
+		 return 0;
+
+	return BaseClass::CheckStuck();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::PrePlayerMove( void )
+{
+	VPROF( "CTFGameMovement::PrePlayerMove" );
+
+	// Assume we don't touch anything (Reset the touch list).
+	MoveHelper()->ResetTouchList();
+
+	// Check to see if we are stuck.
+	if ( CheckStuck() )
+		return false;
+
+	// Update (reduce) movement timers.
+	UpdateTimers();
+
+	// Check to see if the player is dead and setup death data, otherwise setup 
+	// the players view angles.
+	if ( !CheckDeath() )
+	{
+		SetupViewAngles();
+	}
+
+	// Handle ducking.
+	HandleDuck();
+
+	// Handle ladder.
+	HandleLadder();
+
+	// Categorize the player's position.
+	CategorizePosition();
+
+	// Calculate the player's movement speed (has to happen after categorize position)
+	SetupSpeed();
+
+	// Update our stepping sound (based on the player's location).
+	player->UpdateStepSound( m_pSurfaceData, mv->m_vecAbsOrigin, mv->m_vecVelocity );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::PostPlayerMove( void )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::HandlePlayerMove( void )
+{
+	// Handle movement.
+	switch ( player->GetMoveType() )
+	{
+		case MOVETYPE_NONE:
+			{
+				break;
+			}
+		case MOVETYPE_NOCLIP:
+			{
+				FullNoClipMove( sv_noclipspeed.GetFloat(), sv_noclipaccelerate.GetFloat() );
+				break;
+			}
+		case MOVETYPE_FLY:
+		case MOVETYPE_FLYGRAVITY:
+			{
+				FullTossMove();
+				break;
+			}
+
+		case MOVETYPE_LADDER:
+			{
+				FullLadderMove(); 
+				break;
+			}
+
+		case MOVETYPE_WALK:
+			{
+				// This should be moved elsewhere!!!  Just get it going for now.
+				CTFMoveData *pTFMove = TFMove();
+				Vector vecPlayerOrigin( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z );
+				FullWalkMove();
+				Vector vecPlayerDelta;
+				VectorSubtract( mv->m_vecAbsOrigin, vecPlayerOrigin, vecPlayerDelta );
+
+				if ( ( fabs( vecPlayerDelta.x ) > 0.0001f ) || 
+					 ( fabs( vecPlayerDelta.y ) > 0.0001f ) ||
+					 ( fabs( vecPlayerDelta.z ) > 0.0001f ) )
+				{
+					VectorCopy( vecPlayerDelta, pTFMove->m_vecPosDelta );
+				}
+				break;
+			}
+
+		case MOVETYPE_ISOMETRIC:
+			{
+				//IsometricMove();
+				// Could also try:  FullTossMove();
+				FullWalkMove();
+				break;
+			}
+
+		default:
+			{
+				DevMsg( 1, "Bogus pmove player movetype %i on (%i) 0=cl 1=sv\n", player->GetMoveType(), player->IsServer());
+				break;
+			}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::PlayerMove( void )
+{
+	VPROF( "CTFGameMovement::PlayerMove" );
+
+	// Setup and initialization pre-player movement.
+	if (!PrePlayerMove())
+		return;
+
+	// Handle Movement
+	HandlePlayerMove();
+
+	// Clean-up and updates post-player movement.
+	PostPlayerMove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::FullWalkMove()
+{
+	VPROF( "CTFGameMovement::FullWalkMove" );
+
+	if ( !CheckWater() ) 
+	{
+		StartGravity();
+	}
+
+	// If we are leaping out of the water, just update the counters.
+	if (player->m_flWaterJumpTime)
+	{
+		WaterJump();
+		TryPlayerMove();
+		// See if we are still in water?
+		CheckWater();
+		return;
+	}
+
+	// If we are swimming in the water, see if we are nudging against a place we can jump up out
+	//  of, and, if so, start out jump.  Otherwise, if we are not moving up, then reset jump timer to 0
+	if ( player->GetWaterLevel() >= WL_Waist ) 
+	{
+		if ( player->GetWaterLevel() == WL_Waist )
+		{
+			CheckWaterJump();
+		}
+
+			// If we are falling again, then we must not trying to jump out of water any more.
+		if ( mv->m_vecVelocity[2] < 0 && 
+			 player->m_flWaterJumpTime )
+		{
+			player->m_flWaterJumpTime = 0;
+		}
+
+		// Was jump button pressed?
+		if (mv->m_nButtons & IN_JUMP)
+		{
+			CheckJumpButton();
+		}
+		else
+		{
+			mv->m_nOldButtons &= ~IN_JUMP;
+		}
+
+		// Perform regular water movement
+		WaterMove();
+		VectorSubtract (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
+
+		// Redetermine position vars
+		CategorizePosition();
+	}
+	else
+	// Not fully underwater
+	{
+		// Was jump button pressed?
+		if (mv->m_nButtons & IN_JUMP)
+		{
+			CheckJumpButton();
+		}
+		else
+		{
+			mv->m_nOldButtons &= ~IN_JUMP;
+		}
+
+		// Fricion is handled before we add in any base velocity. That way, if we are on a conveyor, 
+		//  we don't slow when standing still, relative to the conveyor.
+		if (player->GetGroundEntity() != NULL)
+		{
+			mv->m_vecVelocity[2] = 0.0;
+			Friction();
+		}
+
+		// Make sure velocity is valid.
+		CheckVelocity();
+
+		if (player->GetGroundEntity() != NULL)
+		{
+//			WalkMove();
+			WalkMove2();
+		}
+		else
+		{
+ 			AirMove();  // Take into account movement when in air.
+		}
+
+		// Set final flags.
+		CategorizePosition();
+
+		// Now pull the base velocity back out.   Base velocity is set if you are on a moving object, like
+		//  a conveyor (or maybe another monster?)
+		VectorSubtract (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
+
+		// Make sure velocity is valid.
+		CheckVelocity();
+
+		// Add any remaining gravitational component.
+		if ( !CheckWater() )
+		{
+			FinishGravity();
+		}
+
+		// If we are on ground, no downward velocity.
+		if ( player->GetGroundEntity() != NULL )
+		{
+			mv->m_vecVelocity[2] = 0;
+		}
+		CheckFalling();
+	}
+
+	if  ( ( m_nOldWaterLevel == WL_NotInWater && player->GetWaterLevel() != WL_NotInWater ) ||
+		  ( m_nOldWaterLevel != WL_NotInWater && player->GetWaterLevel() == WL_NotInWater ) )
+	{
+		PlaySwimSound();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::AirMove( void )
+{
+	VPROF( "CTFGameMovement::AirMove" );
+
+	// NOTE: This was causing some additional problems with walking on physics
+	//       objects.  The movement system needs to be cleaned up!  Keep the old
+	//       code until the system has been fixed.s
+	BaseClass::AirMove();
+	return;
+
+
+	int			i;
+	Vector		wishvel;
+	float		fmove, smove;
+	Vector		wishdir;
+	float		wishspeed;
+	Vector forward, right, up;
+
+	// Initialize the movement stack.
+	VectorCopy( mv->m_vecAbsOrigin, m_aMovementStack[0].m_vecPosition );
+	VectorCopy( m_vecGroundNormal, m_aMovementStack[0].m_vecImpactNormal );
+	m_nMovementStackSize = 1;
+
+	AngleVectors (mv->m_vecViewAngles, &forward, &right, &up);  // Determine movement angles
+	
+	// Copy movement amounts
+	fmove = mv->m_flForwardMove;
+	smove = mv->m_flSideMove;
+	
+	// Zero out z components of movement vectors
+	forward[2] = 0;
+	right[2]   = 0;
+	VectorNormalize(forward);  // Normalize remainder of vectors
+	VectorNormalize(right);    // 
+
+	for (i=0 ; i<2 ; i++)       // Determine x and y parts of velocity
+		wishvel[i] = forward[i]*fmove + right[i]*smove;
+	wishvel[2] = 0;             // Zero out z part of velocity
+
+	VectorCopy (wishvel, wishdir);   // Determine maginitude of speed of move
+	wishspeed = VectorNormalize(wishdir);
+
+	//
+	// clamp to server defined max speed
+	//
+	if (wishspeed > mv->m_flMaxSpeed)
+	{
+		VectorScale (wishvel, mv->m_flMaxSpeed/wishspeed, wishvel);
+		wishspeed = mv->m_flMaxSpeed;
+	}
+	
+	AirAccelerate( wishdir, wishspeed, sv_airaccelerate.GetFloat() );
+
+	// Add in any base velocity to the current velocity.
+	VectorAdd(mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
+
+	TryPlayerMove2();
+
+	// Try to stand up.
+	TryStanding();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::WalkMove( void )
+{
+	_WalkMove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This is here until the new movement code is complete.  I needed
+//          to override hl2's walk move so that "floors" are identified 
+//          differently.
+//-----------------------------------------------------------------------------
+void CTFGameMovement::_WalkMove( void )
+{
+	VPROF( "CTFGameMovement::_WalkMove" );
+
+	int clip;
+	int i;
+
+	Vector wishvel;
+	float spd;
+	float fmove, smove;
+	Vector wishdir;
+	float wishspeed;
+
+	Vector dest, start;
+	Vector original, originalvel;
+	Vector down, downvel;
+	float downdist, updist;
+	trace_t pm;
+	Vector forward, right, up;
+
+	AngleVectors (mv->m_vecViewAngles, &forward, &right, &up);  // Determine movement angles
+
+	CHandle< CBaseEntity > oldground;
+	oldground = player->GetGroundEntity();
+	
+	// Copy movement amounts
+	fmove = mv->m_flForwardMove;
+	smove = mv->m_flSideMove;
+	
+	// Zero out z components of movement vectors
+	forward[2] = 0;
+	right[2]   = 0;
+	
+	VectorNormalize (forward);  // Normalize remainder of vectors.
+	VectorNormalize (right);    // 
+
+	for (i=0 ; i<2 ; i++)       // Determine x and y parts of velocity
+		wishvel[i] = forward[i]*fmove + right[i]*smove;
+	
+	wishvel[2] = 0;             // Zero out z part of velocity
+
+	VectorCopy (wishvel, wishdir);   // Determine maginitude of speed of move
+	wishspeed = VectorNormalize(wishdir);
+
+	//
+	// Clamp to server defined max speed
+	//
+	if (wishspeed > mv->m_flMaxSpeed)
+	{
+		VectorScale (wishvel, mv->m_flMaxSpeed/wishspeed, wishvel);
+		wishspeed = mv->m_flMaxSpeed;
+	}
+
+	// Set pmove velocity
+	mv->m_vecVelocity[2] = 0;
+	Accelerate ( wishdir, wishspeed, sv_accelerate.GetFloat() );
+	mv->m_vecVelocity[2] = 0;
+
+	// Add in any base velocity to the current velocity.
+	VectorAdd (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
+
+	spd = VectorLength( mv->m_vecVelocity );
+
+	if (spd < 1.0f)
+	{
+		mv->m_vecVelocity.Init();
+		return;
+	}
+
+	// first try just moving to the destination	
+	dest[0] = mv->m_vecAbsOrigin[0] + mv->m_vecVelocity[0]*gpGlobals->frametime;
+	dest[1] = mv->m_vecAbsOrigin[1] + mv->m_vecVelocity[1]*gpGlobals->frametime;	
+	dest[2] = mv->m_vecAbsOrigin[2];
+
+	// first try moving directly to the next spot
+	VectorCopy (dest, start);
+
+	TracePlayerBBox( mv->m_vecAbsOrigin, dest, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
+
+	// If we made it all the way, then copy trace end
+	//  as new player position.
+
+	mv->m_outWishVel += wishdir * wishspeed;
+
+	if (pm.fraction == 1)
+	{
+		VectorCopy( pm.endpos, mv->m_vecAbsOrigin );
+		return;
+	}
+
+	if (oldground == NULL &&   // Don't walk up stairs if not on ground.
+		player->GetWaterLevel()  == 0)
+		return;
+
+	if (player->m_flWaterJumpTime)         // If we are jumping out of water, don't do anything more.
+		return;
+
+	// Try sliding forward both on ground and up 16 pixels
+	//  take the move that goes farthest
+	VectorCopy (mv->m_vecAbsOrigin, original);       // Save out original pos &
+	VectorCopy (mv->m_vecVelocity, originalvel);  //  velocity.
+
+	// Slide move
+	clip = TryPlayerMove();
+
+	// Copy the results out
+	VectorCopy (mv->m_vecAbsOrigin  , down);
+	VectorCopy (mv->m_vecVelocity, downvel);
+
+	// Reset original values.
+	VectorCopy (original, mv->m_vecAbsOrigin);
+	VectorCopy (originalvel, mv->m_vecVelocity);
+
+	// Start out up one stair height
+	VectorCopy (mv->m_vecAbsOrigin, dest);
+	dest[2] += player->m_Local.m_flStepSize;
+
+	TracePlayerBBox( mv->m_vecAbsOrigin, dest, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
+
+	// If we started okay and made it part of the way at least,
+	//  copy the results to the movement start position and then
+	//  run another move try.
+	if (!pm.startsolid && !pm.allsolid)
+	{
+		VectorCopy (pm.endpos, mv->m_vecAbsOrigin);
+	}
+
+	// slide move the rest of the way.
+	clip = TryPlayerMove();
+
+	// Now try going back down from the end point
+	//  press down the stepheight
+	VectorCopy (mv->m_vecAbsOrigin, dest);
+	dest[2] -= player->m_Local.m_flStepSize;
+
+	TracePlayerBBox( mv->m_vecAbsOrigin, dest, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
+
+	// If we are not on the ground any more then
+	//  use the original movement attempt
+	if ( pm.plane.normal[2] < IMPACT_NORMAL_FLOOR )
+		goto usedown;
+	// If the trace ended up in empty space, copy the end
+	//  over to the origin.
+	if (!pm.startsolid && !pm.allsolid)
+	{
+		VectorCopy (pm.endpos, mv->m_vecAbsOrigin);
+	}
+	// Copy this origion to up.
+	VectorCopy (mv->m_vecAbsOrigin, up);
+
+	// decide which one went farther
+	downdist = (down[0] - original[0])*(down[0] - original[0])
+		     + (down[1] - original[1])*(down[1] - original[1]);
+	updist   = (up[0]   - original[0])*(up[0]   - original[0])
+		     + (up[1]   - original[1])*(up[1]   - original[1]);
+
+	if (downdist > updist)
+	{
+usedown:
+	;
+		VectorCopy (down   , mv->m_vecAbsOrigin);
+		VectorCopy (downvel, mv->m_vecVelocity);
+	}
+	else // copy z value from slide move
+		mv->m_vecVelocity[2] = downvel[2];
+
+	float stepDist = mv->m_vecAbsOrigin.z - original.z;
+	if ( stepDist > 0 )
+	{
+		mv->m_outStepHeight += stepDist;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::AccelerateWithoutMomentum( Vector &wishdir, float wishspeed, float accel )
+{
+	// No acceleration if the player is water-jumping or dead.
+	if ( player->pl.deadflag || player->m_flWaterJumpTime )
+		return;
+
+	// See if we are changing direction a bit
+//	float flCurrentSpeed = mv->m_vecVelocity.Dot( wishdir );
+	float flCurrentSpeed = mv->m_vecVelocity.Length();
+
+	// Reduce wishspeed by the amount of veer.
+	float flAddSpeed = wishspeed - flCurrentSpeed;
+
+	// If not going to add any speed, done.
+	if ( flAddSpeed <= 0.0f )
+		return;
+
+	// Determine amount of accleration.
+	float flAccelSpeed = accel * gpGlobals->frametime * wishspeed * m_surfaceFriction;
+
+	// Cap at addspeed
+	if ( flAccelSpeed > flAddSpeed )
+	{
+		flAccelSpeed = flAddSpeed;
+	}
+
+	// Adjust velocity.
+	for ( int iAxis = 0; iAxis < 3; iAxis++ )
+	{
+		mv->m_vecVelocity[iAxis] += flAccelSpeed * wishdir[iAxis];
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::Accelerate( Vector &wishdir, float wishspeed, float accel )
+{
+	// No acceleration if the player is water-jumping or dead.
+	if ( player->pl.deadflag || player->m_flWaterJumpTime )
+		return;
+
+	// See if we are changing direction a bit
+//	float flCurrentSpeed = mv->m_vecVelocity.Dot( wishdir );
+	float flCurrentSpeed = mv->m_vecVelocity.Length();
+
+	// Reduce wishspeed by the amount of veer.
+	float flAddSpeed = wishspeed - flCurrentSpeed;
+
+	// If not going to add any speed, done.
+	if ( flAddSpeed <= 0.0f )
+		return;
+
+	// Determine amount of accleration.
+	float flAccelSpeed = accel * gpGlobals->frametime * wishspeed * m_surfaceFriction;
+
+	// Cap at addspeed
+	if ( flAccelSpeed > flAddSpeed )
+	{
+		flAccelSpeed = flAddSpeed;
+	}
+
+	// Gravity.
+	float flGravityAdj = CalcGravityAdjustment( wishdir );
+
+	// Adjust velocity.
+	for ( int iAxis = 0; iAxis < 3; iAxis++ )
+	{
+		mv->m_vecVelocity[iAxis] += ( flAccelSpeed * wishdir[iAxis] * flGravityAdj );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+float CTFGameMovement::CalcGravityAdjustment( const Vector &wishdir )
+{
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return 1.0f;
+
+	if ( player->GetMoveType() == MOVETYPE_NOCLIP )
+		return 1.0f;
+
+	Vector vecPositionDelta = pTFMove->m_vecPosDelta;
+	VectorNormalize( vecPositionDelta );
+
+	// Hard-code my table
+	float flModifier = 0.0f;
+	if ( vecPositionDelta.z < -0.342f )
+	{
+		flModifier = 1.25f;
+	}
+	else if ( vecPositionDelta.z < 0.0f )
+	{
+		flModifier = 1.15f;
+	}
+	else if ( vecPositionDelta.z < 0.342f )	/* >20 */
+	{
+		flModifier = 1.0f;
+	}
+	else if ( vecPositionDelta.z < 0.5f ) /* 20-30 */
+	{
+		float flDelta = 0.5f - vecPositionDelta.z;
+		flDelta /= 0.158f;
+		flDelta = 1.0f - flDelta;
+		flModifier = 1.0f - ( 0.25 * flDelta );
+	}
+	else if ( vecPositionDelta.z < 0.707f ) /* 30-45 */
+	{
+		float flDelta = 0.707f - vecPositionDelta.z;
+		flDelta /= 0.207f;
+		flDelta = 1.0f - flDelta;
+		flModifier = 0.75 - ( 0.25f * flDelta );
+	}
+	else if ( vecPositionDelta.z < 0.766f ) /* 45-50 */
+	{
+		float flDelta = 0.766f - vecPositionDelta.z;
+		flDelta /= 0.059f;
+		flDelta = 1.0f - flDelta;
+		flModifier = 0.5f - ( 0.40f * flDelta );
+	}
+	else
+	{
+		flModifier = 0.35f;
+	}
+
+	AddToMomentumList( flModifier );
+	flModifier = GetMomentum();
+
+#if 0
+	// Debug!
+	if ( player->IsServer() )
+	{
+		Msg( "Server:Gravity Adj = %lf\n", flModifier );
+	}
+	else
+	{
+		Msg( "Client:Gravity Adj = %lf\n", flModifier );
+	}
+#endif
+
+	return flModifier;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::CalcWishVelocityAndPosition( Vector &vWishPos, Vector &vWishDir,
+												   float &flWishSpeed )
+{
+	//
+	// Determine the movement angles.
+	//
+	Vector vForward, vRight, vUp;
+	AngleVectors( mv->m_vecViewAngles, &vForward, &vRight, &vUp );
+
+	//
+	// Zero out the z component of the movement vectors and renormalize.
+	//
+	vForward.z = 0.0f;
+	VectorNormalize( vForward );
+	vRight.z = 0.0f;
+	VectorNormalize( vRight );
+
+	//
+	// Determine the xy parts of the velocity.
+	//
+	Vector vWishVel( 0.0f, 0.0f, 0.0f );
+	for ( int axis = 0; axis < 2; axis++ )
+	{
+		vWishVel[axis] = ( vForward[axis] * mv->m_flForwardMove ) +
+			             ( vRight[axis] * mv->m_flSideMove );
+	}
+	vWishVel.z = 0.0f;
+
+	//
+	// Componentize the velocity into direction and speed.
+	//
+	VectorCopy( vWishVel, vWishDir );
+	flWishSpeed = VectorNormalize( vWishDir );
+	if ( flWishSpeed > mv->m_flMaxSpeed )
+	{
+		VectorScale( vWishVel, ( mv->m_flMaxSpeed / flWishSpeed ), vWishVel );
+		flWishSpeed = mv->m_flMaxSpeed;
+	}
+
+	//
+	// Accelerate (in the plane).
+	//
+	mv->m_vecVelocity.z = 0.0f;
+	Accelerate( vWishDir, flWishSpeed, sv_accelerate.GetFloat() );
+	mv->m_vecVelocity.z = 0.0f;
+
+	// Add in any base velocity (from conveyers, etc.) to the current velocity.
+	VectorAdd( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
+
+	//
+	// Stop the player (zero out velocity) if the player's speed is below a
+	// given threshold.
+	//
+	float flSpeed = VectorLength( mv->m_vecVelocity );
+	if ( flSpeed < SPEED_STOP_THRESHOLD )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	//
+	// Calculate the wish position.
+	//
+	vWishPos.x = mv->m_vecAbsOrigin.x + ( mv->m_vecVelocity.x * gpGlobals->frametime );
+	vWishPos.y = mv->m_vecAbsOrigin.y + ( mv->m_vecVelocity.y * gpGlobals->frametime );
+	vWishPos.z = mv->m_vecAbsOrigin.z;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+inline void CTFGameMovement::TracePlayerBBoxWithStep( const Vector &vStart, const Vector &vEnd, 
+							unsigned int fMask, int collisionGroup, trace_t &trace )
+{
+	VPROF( "CTFGameMovement::TracePlayerBBoxWithStep" );
+
+	Vector vHullMin = GetPlayerMins( player->m_Local.m_bDucked );
+	vHullMin.z += player->m_Local.m_flStepSize;
+	Vector vHullMax = GetPlayerMaxs( player->m_Local.m_bDucked );
+
+	Ray_t ray;
+	ray.Init( vStart, vEnd, vHullMin, vHullMax );
+	UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &trace );
+}
+
+#if 0
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+inline void CGameMovement::TracePlayerBBox( const Vector &start, const Vector &end, 
+							unsigned int fMask, int collisionGroup, trace_t& pm )
+{
+	VPROF( "CTFGameMovement::TracePlayerBBox" );
+
+	Ray_t ray;
+	ray.Init( start, end, GetPlayerMins( player->m_Local.m_bDucked ), GetPlayerMaxs( player->m_Local.m_bDucked ) );
+	UTIL_TraceRay( ray, fMask, mv->m_nPlayerHandle.Get(), collisionGroup, &pm );
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+inline int CTFGameMovement::BlockerType( const Vector &vImpactNormal )
+{
+	// If the impact plane has a high z component in the normal, then
+	// it is probably a floor.
+	if ( vImpactNormal.z > IMPACT_NORMAL_FLOOR )
+		return 1;
+
+	// If the impact plane has a zero z component in the normal, then it is
+	// probably a step or wall.
+	if ( vImpactNormal.z == IMPACT_NORMAL_WALL )
+		return 2;
+
+	// None
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::RedirectGroundVelocity( const trace_t &trace )
+{
+	// Check for max planes.
+	if ( m_nImpactPlaneCount >= MAX_IMPACT_PLANES )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	// Add the impact plane normal to the list.
+	VectorCopy( trace.plane.normal, m_aImpactPlaneNormals[m_nImpactPlaneCount] );
+	m_nImpactPlaneCount++;
+	
+	int iPlane, iPlane2;
+	for ( iPlane = 0; iPlane < m_nImpactPlaneCount; iPlane++ )
+	{
+		// Reduce and redirect the player's velocity.
+		Vector vecVelocity( mv->m_vecVelocity.x, mv->m_vecVelocity.y, mv->m_vecVelocity.z );
+
+		// Don't let negatively sloped surfaces drive you into the ground.
+		if ( m_aImpactPlaneNormals[iPlane].z < 0.0f )
+		{
+			m_aImpactPlaneNormals[iPlane].z = 0.0f;
+			VectorNormalize( m_aImpactPlaneNormals[iPlane] );
+		}
+
+		ClipVelocity( vecVelocity, m_aImpactPlaneNormals[iPlane], mv->m_vecVelocity, 1.0f );
+
+		// Check to see if we need to continue clipping?
+		for( iPlane2 = 0; iPlane2 < m_nImpactPlaneCount; iPlane2++ )
+		{
+			if ( iPlane != iPlane2 )
+			{
+				if ( mv->m_vecVelocity.Dot( m_aImpactPlaneNormals[iPlane2] ) < 0.0f )
+					break;
+			}
+		}
+		if ( iPlane2 == m_nImpactPlaneCount )
+			break;
+	}
+
+	if ( iPlane == m_nImpactPlaneCount )
+	{
+		// Go along the crease here!
+		if ( m_nImpactPlaneCount != 2 )
+		{
+			mv->m_vecVelocity.Init();
+			return false;
+		}
+		else
+		{
+			Vector vecCross;
+			CrossProduct( m_aImpactPlaneNormals[0], m_aImpactPlaneNormals[1], vecCross );
+			float flScalar = vecCross.Dot( mv->m_vecVelocity );
+			VectorScale( vecCross, flScalar, mv->m_vecVelocity );
+		}
+	}
+
+	// If the original velocity is against the current velocity, stop dead to 
+	// avoid tiny occilations in sloping corners
+	if ( mv->m_vecVelocity.Dot( m_vecOriginalVelocity ) <= 0.0f )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::RedirectAirVelocity( const trace_t &trace )
+{
+	// Check for max planes.
+	if ( m_nImpactPlaneCount >= MAX_IMPACT_PLANES )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	// Add the impact plane normal to the list.
+	VectorCopy( trace.plane.normal, m_aImpactPlaneNormals[m_nImpactPlaneCount] );
+	m_nImpactPlaneCount++;
+
+	for ( int iPlane = 0; iPlane < m_nImpactPlaneCount; iPlane++ )
+	{
+		// Reduce and redirect the player's velocity.
+		Vector vecVelocity( mv->m_vecVelocity.x, mv->m_vecVelocity.y, mv->m_vecVelocity.z );
+
+		// Don't let negatively sloped surfaces drive you into the ground.
+		if ( m_aImpactPlaneNormals[iPlane].z < 0.0f )
+		{
+			m_aImpactPlaneNormals[iPlane].z = 0.0f;
+			VectorNormalize( m_aImpactPlaneNormals[iPlane] );
+		}
+
+		if ( m_aImpactPlaneNormals[iPlane].z > IMPACT_NORMAL_FLOOR )
+		{
+			ClipVelocity( vecVelocity, m_aImpactPlaneNormals[iPlane], mv->m_vecVelocity, 1.0f );
+		}
+		else
+		{
+			ClipVelocity( vecVelocity, m_aImpactPlaneNormals[iPlane], mv->m_vecVelocity, 1.0f + sv_bounce.GetFloat() * ( 1.0f - m_surfaceFriction ) );
+		}
+	}	
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::CollisionResponseNone( const trace_t &trace )
+{
+	// Move the player to the trace's ending position.
+	VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+
+	// Add the position to the stack.
+	if ( m_nMovementStackSize < MOVEMENTSTACK_MAXSIZE )
+	{
+		VectorCopy( mv->m_vecAbsOrigin, m_aMovementStack[m_nMovementStackSize].m_vecPosition );
+		VectorCopy( mv->m_vecVelocity, m_aMovementStack[m_nMovementStackSize].m_vecVelocity );
+		VectorCopy( m_aMovementStack[m_nMovementStackSize].m_vecImpactNormal, 
+			m_aMovementStack[m_nMovementStackSize].m_vecImpactNormal );
+		m_nMovementStackSize++;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::CollisionResponseStuck( void )
+{
+	mv->m_vecVelocity.Init();
+	//DevMsg( 1, "CollisionResponseStuck: %s is stuck (%s).\n", player->GetClassname(), player->IsServer() ? "sv" : "cl" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::CollisionResponseGeneric( const trace_t &trace, int &nBlocked )
+{
+	// Check for any movement.
+	if ( trace.fraction > 0.0f )
+	{
+		// Move the partial move and reset the impact plane count.
+		VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+		m_nImpactPlaneCount = 0;
+
+		// Add the data to the movement stack. -- the velocity is wrong here!!!
+		if ( m_nMovementStackSize < MOVEMENTSTACK_MAXSIZE )
+		{
+			VectorCopy( mv->m_vecAbsOrigin, m_aMovementStack[m_nMovementStackSize].m_vecPosition );
+			VectorCopy( mv->m_vecVelocity, m_aMovementStack[m_nMovementStackSize].m_vecVelocity );
+			VectorCopy( trace.plane.normal, m_aMovementStack[m_nMovementStackSize].m_vecImpactNormal );
+			m_nMovementStackSize++;
+		}
+	}
+
+	// Sanity check - Impact plane count.
+	Assert( m_nImpactPlaneCount < MAX_IMPACT_PLANES );
+
+	// Add the entity to the touched list (list itself maintains uniqueness).
+	MoveHelper()->AddToTouched( trace, mv->m_vecVelocity );
+
+	// Check for special "blockers" (walls, steps, floor).
+    nBlocked |= BlockerType( trace.plane.normal );
+	
+	// Re-direct or bounce the player's velocity vector.
+	if ( player->GetGroundEntity() != NULL )
+	{
+		return RedirectGroundVelocity( trace );
+	}
+	else
+	{
+		return RedirectAirVelocity( trace );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: See comment _WalkMove
+//-----------------------------------------------------------------------------
+int CTFGameMovement::TryPlayerMove( Vector *pFirstDest=NULL, trace_t *pFirstTrace=NULL )
+{
+	VPROF( "CTFGameMovement::TryPlayerMove" );
+
+	int			bumpcount, numbumps;
+	Vector		dir;
+	float		d;
+	int			numplanes;
+	Vector		planes[5/*MAX_CLIP_PLANES*/];
+	Vector		primal_velocity, original_velocity;
+	Vector      new_velocity;
+	int			i, j;
+	trace_t	pm;
+	Vector		end;
+	float		time_left, allFraction;
+	int			blocked;		
+	
+	numbumps  = 4;           // Bump up to four times
+	
+	blocked   = 0;           // Assume not blocked
+	numplanes = 0;           //  and not sliding along any planes
+	VectorCopy (mv->m_vecVelocity, original_velocity);  // Store original velocity
+	VectorCopy (mv->m_vecVelocity, primal_velocity);
+	
+	allFraction = 0;
+	time_left = gpGlobals->frametime;   // Total time for this movement operation.
+
+	new_velocity.Init();
+
+	for (bumpcount=0 ; bumpcount < numbumps; bumpcount++)
+	{
+		if ( mv->m_vecVelocity.Length() == 0.0 )
+			break;
+
+		// Assume we can move all the way from the current origin to the
+		//  end point.
+		VectorMA( mv->m_vecAbsOrigin, time_left, mv->m_vecVelocity, end );
+
+		// See if we can make it from origin to end point.
+		if ( g_bMovementOptimizations )
+		{
+			// If their velocity Z is 0, then we can avoid an extra trace here during WalkMove.
+			if ( pFirstDest && end == *pFirstDest )
+				pm = *pFirstTrace;
+			else
+				TracePlayerBBox( mv->m_vecAbsOrigin, end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
+		}
+		else
+		{
+			TracePlayerBBox( mv->m_vecAbsOrigin, end, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, pm );
+		}
+
+		allFraction += pm.fraction;
+
+		// If we started in a solid object, or we were in solid space
+		//  the whole way, zero out our velocity and return that we
+		//  are blocked by floor and wall.
+		if (pm.allsolid)
+		{	
+			// entity is trapped in another solid
+			VectorCopy (vec3_origin, mv->m_vecVelocity);
+			return 4;
+		}
+
+		// If we moved some portion of the total distance, then
+		//  copy the end position into the pmove.origin and 
+		//  zero the plane counter.
+		if( pm.fraction > 0 )
+		{	
+			// actually covered some distance
+			VectorCopy (pm.endpos, mv->m_vecAbsOrigin);
+			VectorCopy (mv->m_vecVelocity, original_velocity);
+			numplanes = 0;
+		}
+
+		// If we covered the entire distance, we are done
+		//  and can return.
+		if (pm.fraction == 1)
+		{
+			 break;		// moved the entire distance
+		}
+
+		// Indicate a collision occurred...
+		OnTryPlayerMoveCollision( pm );
+
+		// Save entity that blocked us (since fraction was < 1.0)
+		//  for contact
+		// Add it if it's not already in the list!!!
+		MoveHelper( )->AddToTouched( pm, mv->m_vecVelocity );
+
+		// If the plane we hit has a high z component in the normal, then
+		//  it's probably a floor
+		if (pm.plane.normal[2] > IMPACT_NORMAL_FLOOR)
+		{
+			blocked |= 1;		// floor
+		}
+		// If the plane has a zero z component in the normal, then it's a 
+		//  step or wall
+		if (!pm.plane.normal[2])
+		{
+			blocked |= 2;		// step / wall
+		}
+
+		// Reduce amount of m_flFrameTime left by total time left * fraction
+		//  that we covered.
+		time_left -= time_left * pm.fraction;
+		
+		// Did we run out of planes to clip against?
+		if (numplanes >= 5/*MAX_CLIP_PLANES*/)
+		{	
+			// this shouldn't really happen
+			//  Stop our movement if so.
+			VectorCopy (vec3_origin, mv->m_vecVelocity);
+			//Con_DPrintf("Too many planes 4\n");
+
+			break;
+		}
+
+		// Set up next clipping plane
+		VectorCopy (pm.plane.normal, planes[numplanes]);
+		numplanes++;
+
+		// modify original_velocity so it parallels all of the clip planes
+		//
+		if ( player->GetMoveType() == MOVETYPE_WALK &&
+			((player->GetGroundEntity() == NULL) /*|| (mv->m_fFriction != 1)*/ ) )	// relfect player velocity
+		{
+			for ( i = 0; i < numplanes; i++ )
+			{
+				if ( planes[i][2] > IMPACT_NORMAL_FLOOR  )
+				{
+					// floor or slope
+					ClipVelocity( original_velocity, planes[i], new_velocity, 1 );
+					VectorCopy( new_velocity, original_velocity );
+				}
+				else
+				{
+					ClipVelocity( original_velocity, planes[i], new_velocity, 1.0 + sv_bounce.GetFloat() * (1 - m_surfaceFriction) );
+				}
+			}
+
+			VectorCopy( new_velocity, mv->m_vecVelocity );
+			VectorCopy( new_velocity, original_velocity );
+		}
+		else
+		{
+			for (i=0 ; i < numplanes ; i++)
+			{
+				ClipVelocity (
+					original_velocity,
+					planes[i],
+					mv->m_vecVelocity,
+					1);
+
+				for (j=0 ; j<numplanes ; j++)
+					if (j != i)
+					{
+						// Are we now moving against this plane?
+						if (mv->m_vecVelocity.Dot(planes[j]) < 0)
+							break;	// not ok
+					}
+				if (j == numplanes)  // Didn't have to clip, so we're ok
+					break;
+			}
+			
+			// Did we go all the way through plane set
+			if (i != numplanes)
+			{	// go along this plane
+				// pmove.velocity is set in clipping call, no need to set again.
+				;  
+			}
+			else
+			{	// go along the crease
+				if (numplanes != 2)
+				{
+					VectorCopy (vec3_origin, mv->m_vecVelocity);
+					break;
+				}
+				CrossProduct (planes[0], planes[1], dir);
+				d = dir.Dot(mv->m_vecVelocity);
+				VectorScale (dir, d, mv->m_vecVelocity );
+			}
+
+			//
+			// if original velocity is against the original velocity, stop dead
+			// to avoid tiny occilations in sloping corners
+			//
+			d = mv->m_vecVelocity.Dot(primal_velocity);
+			if (d <= 0)
+			{
+				//Con_DPrintf("Back\n");
+				VectorCopy (vec3_origin, mv->m_vecVelocity);
+				break;
+			}
+		}
+	}
+
+	if ( allFraction == 0 )
+	{
+		VectorCopy (vec3_origin, mv->m_vecVelocity);
+	}
+
+	return blocked;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+int CTFGameMovement::TryPlayerMove2( void )
+{
+	VPROF( "CTFGameMovement::TryPlayerMove2" );
+
+	int	nBlocked = MOVEMENT_BLOCKED_NONE;
+	trace_t	trace;
+	float flTimeLeft = gpGlobals->frametime;
+	m_nImpactPlaneCount = 0;
+
+	// Save off the original velocity -- coming in.
+	VectorCopy( mv->m_vecVelocity, m_vecOriginalVelocity );
+
+	float flTotalFraction = 0.0f;
+	for ( int iBump = 0; iBump < BUMP_MAX_COUNT; iBump++ )
+	{
+		// Check to see if we have any velocity left. EXPENSIVE!!!!
+		if ( mv->m_vecVelocity.Length() == 0.0f )
+			break;
+
+		//
+		// Calculate the wish position. 
+		//
+		Vector vecWishPos;
+		VectorMA( mv->m_vecAbsOrigin, flTimeLeft, mv->m_vecVelocity, vecWishPos );
+
+		//
+		// Attempt the move.
+		//
+		// NOTE:  This check can hit players and objects
+		TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecWishPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER, trace );
+
+		//  but if it didn't no need to do another trace for movement only
+		if ( trace.fraction == 1.0f )
+		{
+			flTotalFraction += trace.fraction;
+			CollisionResponseNone( trace );
+			break;
+		}
+		else
+		{
+			// Add the entity to the touched list (list itself maintains uniqueness).
+			MoveHelper()->AddToTouched( trace, mv->m_vecVelocity );
+			// Do a non-solid to player trace now, instead, and override what's in trace
+			TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecWishPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+		}
+
+		flTotalFraction += trace.fraction;
+
+		// Handle stuck in solid.
+		if ( trace.allsolid )
+		{
+			CollisionResponseStuck();
+			return MOVEMENT_BLOCKED_ALL;
+		}
+
+		// Handle full movement.
+		if ( trace.fraction == 1.0f )
+		{
+			CollisionResponseNone( trace );
+			break;
+		}
+
+		// Handle partial movement.
+		if ( !CollisionResponseGeneric( trace, nBlocked ) )
+			break;
+
+		// Reduce the time left.
+		flTimeLeft -= ( flTimeLeft * trace.fraction );
+
+		/*
+		//
+		// Attempt the move.
+		//
+		TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecWishPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+		flTotalFraction += trace.fraction;
+
+		// Handle stuck in solid.
+		if ( trace.allsolid )
+		{
+			CollisionResponseStuck();
+			return MOVEMENT_BLOCKED_ALL;
+		}
+
+		// Handle full movement.
+		if ( trace.fraction == 1.0f )
+		{
+			CollisionResponseNone( trace );
+			break;
+		}
+
+		// Handle partial movement.
+		if ( !CollisionResponseGeneric( trace, nBlocked ) )
+			break;
+
+		// Reduce the time left.
+		flTimeLeft -= ( flTimeLeft * trace.fraction );
+		*/
+	}
+	
+	// Finally, check for any movement.
+	if ( flTotalFraction == 0.0f )
+	{
+		CollisionResponseStuck();
+	}
+
+	return nBlocked;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::TryStanding( void )
+{
+	VPROF( "CTFGameMovement::TryStanding" );
+
+	// Step down.
+	Vector vecStandPos( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z - player->m_Local.m_flStepSize );
+
+	trace_t trace;
+	TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+	if ( trace.fraction == 1.0f )
+		return;
+
+	// Attempt to stand up.
+	vecStandPos.z = mv->m_vecAbsOrigin.z + ( ( 1.0f - trace.fraction ) * player->m_Local.m_flStepSize );
+	TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+	// A fraction of 1.0 means we stood up fine - done.
+	if ( trace.fraction == 1.0f )
+	{
+		VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+		return;
+	}
+
+	// Use the movement stack to pop back and resolve the stand.
+	if ( m_nMovementStackSize > 0 )
+	{
+		VectorCopy( m_aMovementStack[m_nMovementStackSize-1].m_vecPosition, mv->m_vecAbsOrigin );
+		VectorCopy( m_aMovementStack[m_nMovementStackSize-1].m_vecVelocity, mv->m_vecVelocity );
+		m_nMovementStackSize--; 
+		TryStanding();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::ResolveStanding( void )
+{
+	VPROF( "CTFGameMovement::ResolveStanding" );
+
+	//
+	// Attempt to move down twice your step height.  Anything between 0.5 and 1.0
+	// is a valid "stand" value.
+	//
+	Vector vecStandPos( mv->m_vecAbsOrigin.x, mv->m_vecAbsOrigin.y, mv->m_vecAbsOrigin.z - ( player->m_Local.m_flStepSize * 2.0f ) );
+
+	trace_t trace;
+	TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+
+	// Anything between 0.5 and 1.0 is a valid stand value
+	if ( fabs( trace.fraction - 0.5 ) < 0.0004f )
+	{
+		return;
+	}
+
+//	if ( trace.fraction == 0.5 )
+//	{
+//		VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+//		return;
+//	}
+
+	if ( trace.fraction > 0.5f )
+	{
+		trace.fraction -= 0.5f;
+		Vector vecNewOrigin;
+		vecNewOrigin = mv->m_vecAbsOrigin + trace.fraction * ( vecStandPos - mv->m_vecAbsOrigin );
+		mv->m_vecAbsOrigin = vecNewOrigin;
+		return;
+	}
+
+	// Less than 0.5 mean we need to attempt to push up the difference.
+	vecStandPos.z = ( mv->m_vecAbsOrigin.z + ( ( 0.5f - trace.fraction ) * ( player->m_Local.m_flStepSize * 2.0f ) ) );
+	TracePlayerBBoxWithStep( mv->m_vecAbsOrigin, vecStandPos, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, trace );
+	
+	// A fraction of 1.0 means we stood up fine - done.
+	if ( trace.fraction == 1.0f )
+	{
+		VectorCopy( trace.endpos, mv->m_vecAbsOrigin );
+		return;
+	}
+
+	// Use the movement stack to pop back and resolve the stand.
+	if ( m_nMovementStackSize > 0 )
+	{
+		VectorCopy( m_aMovementStack[m_nMovementStackSize-1].m_vecPosition, mv->m_vecAbsOrigin );
+		VectorCopy( m_aMovementStack[m_nMovementStackSize-1].m_vecVelocity, mv->m_vecVelocity );
+		m_nMovementStackSize--; 
+		ResolveStanding();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovement::WalkMove2( void )
+{
+	VPROF( "CTFGameMovement::WalkMove2" );
+
+	// Initialize the movement stack.
+	VectorCopy( mv->m_vecAbsOrigin, m_aMovementStack[0].m_vecPosition );
+	VectorCopy( m_vecGroundNormal, m_aMovementStack[0].m_vecImpactNormal );
+	m_nMovementStackSize = 1;
+
+	// Calculate the wish velocity and position.  The function returns false if 
+	// the velocity is zero, it returns true otherwise.
+	Vector vWishPos, vWishDir;
+	float flWishSpeed;
+	if ( !CalcWishVelocityAndPosition( vWishPos, vWishDir, flWishSpeed ) )
+		return;
+
+	// For physics player shadow.
+	mv->m_outWishVel += vWishDir * flWishSpeed;
+
+	// Lift up the players feet (bring the minimum z componenet up by the step
+	// size) and sweep.
+	TryPlayerMove2();
+
+	// Try to stand up at movement's end.
+	ResolveStanding();
+
+	// For physics player shadow.
+	float flStepHeight = mv->m_vecAbsOrigin.z - m_aMovementStack[0].m_vecPosition.z;
+	if ( flStepHeight > 0.0f )
+	{
+		mv->m_outStepHeight += flStepHeight;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::SetMomentumList( float flValue )
+{
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return;
+
+	// Fill in the momentum list.
+	pTFMove->m_iMomentumHead = 0;
+	for ( int iMomentum = 0; iMomentum < CTFMoveData::MOMENTUM_MAXSIZE; iMomentum++ )
+	{
+		pTFMove->m_aMomentum[iMomentum] = flValue;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CTFGameMovement::AddToMomentumList( float flValue )
+{
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return;
+
+	// Insert the new gravity value into the list.
+	pTFMove->m_aMomentum[pTFMove->m_iMomentumHead] = flValue;
+	pTFMove->m_iMomentumHead = ( pTFMove->m_iMomentumHead + 1 ) % CTFMoveData::MOMENTUM_MAXSIZE;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CTFGameMovement::GetMomentum( void )
+{
+	// Get the TF movement data.
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return 1.0f;
+
+	float flTotal = 0.0f;
+	for ( int iMomentum = 0; iMomentum < CTFMoveData::MOMENTUM_MAXSIZE; iMomentum++ )
+	{
+		flTotal += pTFMove->m_aMomentum[iMomentum];
+	}
+	
+	flTotal /= CTFMoveData::MOMENTUM_MAXSIZE;
+
+	return flTotal;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CTFGameMovement::CheckJumpButton( void )
+{
+	if (player->pl.deadflag)
+	{
+		mv->m_nOldButtons |= IN_JUMP ;	// don't jump again until released
+		return false;
+	}
+
+	// See if we are waterjumping.  If so, decrement count and return.
+	if (player->m_flWaterJumpTime)
+	{
+		player->m_flWaterJumpTime -= gpGlobals->frametime;
+		if (player->m_flWaterJumpTime < 0)
+			player->m_flWaterJumpTime = 0;
+		
+		return false;
+	}
+
+	// If we are in the water most of the way...
+	if ( player->GetWaterLevel() >= 2 )
+	{	
+		// swimming, not jumping
+		SetGroundEntity( NULL );
+
+		if(player->GetWaterType() == CONTENTS_WATER)    // We move up a certain amount
+			mv->m_vecVelocity[2] = 100;
+		else if (player->GetWaterType() == CONTENTS_SLIME)
+			mv->m_vecVelocity[2] = 80;
+		
+		// play swiming sound
+		if ( player->m_flSwimSoundTime <= 0 )
+		{
+			// Don't play sound again for 1 second
+			player->m_flSwimSoundTime = 1000;
+			PlaySwimSound();
+		}
+
+		return false;
+	}
+
+	// No more effect
+ 	if (player->GetGroundEntity() == NULL)
+	{
+		mv->m_nOldButtons |= IN_JUMP;
+		return false;		// in air, so no effect
+	}
+
+	if ( mv->m_nOldButtons & IN_JUMP )
+		return false;		// don't pogo stick
+
+	// In the air now.
+    SetGroundEntity( NULL );
+	
+	PlayStepSound( m_pSurfaceData, 1.0, true );
+	
+	MoveHelper()->PlayerSetAnimation( PLAYER_JUMP );
+
+	float flGroundFactor = 1.0f;
+	if (m_pSurfaceData)
+	{
+		flGroundFactor = m_pSurfaceData->game.jumpFactor; 
+	}
+
+	float flMul;
+	flMul = sqrt(2 * GetCurrentGravity() * 45.0);
+
+	// Acclerate upward
+	// If we are ducking...
+	float startz = mv->m_vecVelocity[2];
+	if ( (  player->m_Local.m_bDucking ) || (  player->GetFlags() & FL_DUCKING ) )
+	{
+		// d = 0.5 * g * t^2		- distance traveled with linear accel
+		// t = sqrt(2.0 * 45 / g)	- how long to fall 45 units
+		// v = g * t				- velocity at the end (just invert it to jump up that high)
+		// v = g * sqrt(2.0 * 45 / g )
+		// v^2 = g * g * 2.0 * 45 / g
+		// v = sqrt( g * 2.0 * 45 )
+		mv->m_vecVelocity[2] = flGroundFactor * flMul;  // 2 * gravity * height
+	}
+	else
+	{
+		mv->m_vecVelocity[2] += flGroundFactor * flMul;  // 2 * gravity * height
+	}
+
+	FinishGravity();
+
+	mv->m_outJumpVel.z += mv->m_vecVelocity[2] - startz;
+	mv->m_outStepHeight += 0.1f;
+
+	// Flag that we jumped.
+	mv->m_nOldButtons |= IN_JUMP;	// don't jump again until released
+	return true;
+}
diff --git a/game/shared/tf2/tf_gamemovement.h b/game/shared/tf2/tf_gamemovement.h
new file mode 100644
index 0000000..cb72f09
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement.h
@@ -0,0 +1,126 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_H
+#define TF_GAMEMOVEMENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "gamemovement.h"
+#include "tf_movedata.h"
+#include "movevars_shared.h"
+
+class CBaseTFPlayer;
+class CBasePlayer;
+
+//-----------------------------------------------------------------------------
+// This class is the GameMovement class for team fortress and overrides 
+// some of the default behavior.
+//-----------------------------------------------------------------------------
+class CTFGameMovement : public CGameMovement
+{
+	// Team Fortress 2 game movement base class.
+	DECLARE_CLASS( CTFGameMovement, CGameMovement );
+
+public:
+
+	// CGameMovement public overrides.
+	virtual void PlayerMove( void );
+
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData ) {}
+
+	// Utility
+	inline CTFMoveData *TFMove( void )	{ return static_cast<CTFMoveData*>( mv ); }
+
+protected:
+	// Player movement functions.
+	virtual bool	PrePlayerMove( void );
+	virtual void	HandlePlayerMove( void );
+	virtual void	PostPlayerMove( void );
+
+	// Player pre-movement functions.
+	virtual int		CheckStuck( void );
+	virtual void	UpdateTimers( void );
+	bool			CheckDeath( void );
+	virtual void	SetupViewAngles( void );
+	virtual void	HandleDuck( void );
+	virtual void	FinishUnDuck( void );
+	virtual void	SetupSpeed( void );
+	void			SpeedCrop( void );
+	void			Accelerate( Vector& wishdir, float wishspeed, float accel);
+	void			AccelerateWithoutMomentum( Vector& wishdir, float wishspeed, float accel);
+	virtual float	GetAirSpeedCap( void );
+	float			CalcGravityAdjustment( const Vector &wishdir );
+	void			HandleLadder( void );
+	virtual void	CategorizePosition( void );
+	virtual bool	CheckJumpButton( void );
+
+	virtual void	PlayStepSound( surfacedata_t *psurface, float fvol, bool force );
+	// Should the step sound play?
+	virtual bool	ShouldPlayStepSound( surfacedata_t *psurface, float fvol );
+
+	// Specific movement functions.
+	virtual void	FullWalkMove();
+	virtual void	WalkMove( void );
+	virtual void	_WalkMove( void );
+	void			WalkMove2( void );
+	void			AirMove( void );
+	virtual int		TryPlayerMove( Vector *pFirstDest=NULL, trace_t *pFirstTrace=NULL );
+	int				TryPlayerMove2( void );
+	void			ResolveStanding( void );
+	void			TryStanding( void );
+	bool			ChargeMove( void );
+	bool			StunMove( void );
+
+	void			EndCharge( void );
+
+	virtual void	HandleDuckingSpeedCrop( void );
+
+	// Figures out how the constraint should slow us down
+	float			ComputeConstraintSpeedFactor( void );
+
+	// Movement helpers.
+	virtual bool	CalcWishVelocityAndPosition( Vector &vWishPos, Vector &vWishDir, float &flWishSpeed );
+	inline void		TracePlayerBBoxWithStep( const Vector &vStart, const Vector &vEnd, unsigned int fMask, int collisionGroup, trace_t &trace );
+
+	// Momentum
+	void			SetMomentumList( float flValue = 1.0f );
+	void			AddToMomentumList( float flValue );
+	float			GetMomentum( void );
+
+	// Collision response functions.
+	bool			CollisionResponseGeneric( const trace_t &trace, int &nBlocked );
+	void			CollisionResponseStuck( void );
+	void			CollisionResponseNone( const trace_t &trace );
+	bool			RedirectGroundVelocity( const trace_t &trace );
+	bool			RedirectAirVelocity( const trace_t &trace );
+	inline int		BlockerType( const Vector &vImpactNormal );
+
+protected:
+
+	// Per movement collision data cache(s)
+	Vector					m_vecGroundNormal;
+	Vector					m_vecOriginalVelocity;
+	int						m_nLanding;
+
+	enum { MAX_IMPACT_PLANES = 5 };
+	int						m_nImpactPlaneCount;
+	Vector					m_aImpactPlaneNormals[MAX_IMPACT_PLANES];
+
+	enum { MOVEMENTSTACK_MAXSIZE = 10 };
+	struct MovementStackData_t
+	{
+		Vector m_vecPosition;
+		Vector m_vecVelocity;
+		Vector m_vecImpactNormal;
+	};
+	int						m_nMovementStackSize;
+	MovementStackData_t		m_aMovementStack[MOVEMENTSTACK_MAXSIZE];
+};
+
+#endif // TF_GAMEMOVEMENT_H
diff --git a/game/shared/tf2/tf_gamemovement_chooser.cpp b/game/shared/tf2/tf_gamemovement_chooser.cpp
new file mode 100644
index 0000000..d059dae
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_chooser.cpp
@@ -0,0 +1,76 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_chooser.h"
+#include "tf_movedata.h"
+
+static CTFGameMovementChooser g_GameMovement;
+IGameMovement *g_pGameMovement = ( IGameMovement* )&g_GameMovement;
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementChooser::CTFGameMovementChooser()
+{
+	// Allocate memory for a movement type for each class (0 = undecided)
+	m_Movements.SetSize( TFCLASS_CLASS_COUNT );
+
+	// NOTE: the order here matches the enum order in tf_shareddefs.h
+	m_Movements[TFCLASS_RECON] = &m_ReconMovement;
+	m_Movements[TFCLASS_COMMANDO] = &m_CommandoMovement;
+	m_Movements[TFCLASS_MEDIC] = &m_MedicMovement;
+	m_Movements[TFCLASS_DEFENDER] = &m_DefenderMovement;
+	m_Movements[TFCLASS_SNIPER] = &m_SniperMovement;
+	m_Movements[TFCLASS_SUPPORT] = &m_SupportMovement;
+	m_Movements[TFCLASS_ESCORT] = &m_EscortMovement;
+	m_Movements[TFCLASS_SAPPER] = &m_SapperMovement;
+	m_Movements[TFCLASS_INFILTRATOR] = &m_InfiltratorMovement;
+	m_Movements[TFCLASS_PYRO] = &m_PyroMovement;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementChooser::ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData )
+{
+	// Convert CMoveData to CTFMoveData
+	CTFMoveData *pTFMoveData = static_cast<CTFMoveData*>( pMoveData );
+	
+	// Cache the current class id
+	m_nClassID = pTFMoveData->m_nClassID;
+
+	// Player class movement. (If possible)
+	if ( m_nClassID != TFCLASS_UNDECIDED )
+	{
+		m_Movements[m_nClassID]->ProcessClassMovement( (CBaseTFPlayer *)pPlayer, pTFMoveData );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementChooser::GetPlayerMins( bool ducked ) const
+{
+	// Player class mins.
+	return m_Movements[m_nClassID]->GetPlayerMins( ducked );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementChooser::GetPlayerMaxs( bool ducked ) const
+{
+	return m_Movements[m_nClassID]->GetPlayerMins( ducked );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementChooser::GetPlayerViewOffset( bool ducked ) const
+{
+	return m_Movements[m_nClassID]->GetPlayerViewOffset( ducked );
+}
diff --git a/game/shared/tf2/tf_gamemovement_chooser.h b/game/shared/tf2/tf_gamemovement_chooser.h
new file mode 100644
index 0000000..a1284bc
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_chooser.h
@@ -0,0 +1,69 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_CHOOSER_H
+#define TF_GAMEMOVEMENT_CHOOSER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "utlvector.h"
+#include "IGameMovement.h"
+#include "tf_gamemovement.h"
+#include "tf_gamemovement_recon.h"
+#include "tf_gamemovement_commando.h"
+#include "tf_gamemovement_medic.h"
+#include "tf_gamemovement_defender.h"
+#include "tf_gamemovement_sniper.h"
+#include "tf_gamemovement_support.h"
+#include "tf_gamemovement_escort.h"
+#include "tf_gamemovement_sapper.h"
+#include "tf_gamemovement_infiltrator.h"
+#include "tf_gamemovement_pyro.h"
+
+//=============================================================================
+//
+// Team Fortess Game Movement Chooser
+//
+class CTFGameMovementChooser : public IGameMovement
+{
+public:
+
+	CTFGameMovementChooser();
+
+	// Process the current movement command
+	virtual void ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMoveData );		
+
+	// Allows other parts of the engine to find out the normal and ducked player bbox sizes
+	virtual const Vector &GetPlayerMins( bool ducked ) const;
+	virtual const Vector &GetPlayerMaxs( bool ducked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool ducked ) const;
+
+protected:
+
+	// Cache the current class id.
+	int								m_nClassID;
+
+	// Create the class specific movement singletons.
+	CTFGameMovementRecon			m_ReconMovement;
+	CTFGameMovementCommando			m_CommandoMovement;
+	CTFGameMovementMedic			m_MedicMovement;
+	CTFGameMovementDefender			m_DefenderMovement;
+	CTFGameMovementSniper			m_SniperMovement;
+	CTFGameMovementSupport			m_SupportMovement;
+	CTFGameMovementEscort			m_EscortMovement;
+	CTFGameMovementSapper			m_SapperMovement;
+	CTFGameMovementInfiltrator		m_InfiltratorMovement;
+	CTFGameMovementPyro				m_PyroMovement;
+
+	// Vector of class specific movements (for quick addressing).
+	CUtlVector<CTFGameMovement*>	m_Movements;
+};
+
+extern IGameMovement *g_pGameMovement;
+
+#endif // TF_GAMEMOVEMENT_CHOOSER_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_commando.cpp b/game/shared/tf2/tf_gamemovement_commando.cpp
new file mode 100644
index 0000000..bcdfce3
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_commando.cpp
@@ -0,0 +1,424 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "in_buttons.h"
+#include "tf_gamemovement_commando.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementCommando::CTFGameMovementCommando()
+{
+	m_pCommandoData = NULL;
+
+	m_vStandMins = COMMANDOCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = COMMANDOCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = COMMANDOCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = COMMANDOCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = COMMANDOCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = COMMANDOCLASS_VIEWOFFSET_DUCK;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementCommando::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassCommandoData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+
+	// Is this how I want to handle this???
+//	m_pCommandoData = &pTFMoveData->CommandoData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementCommando::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementCommando::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementCommando::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovementCommando::CheckDoubleTapForward( void )
+{
+	// Check for other movement keys!!!
+	if ( ( TFMove()->m_nButtons & IN_MOVELEFT ) || ( TFMove()->m_nButtons & IN_MOVERIGHT ) ||
+		 ( TFMove()->m_nButtons & IN_BACK ) || ( TFMove()->m_nButtons & IN_JUMP ) )
+	{
+		TFMove()->CommandoData().m_flDoubleTapForwardTime = COMMANDO_TIME_INVALID;
+		return false;
+	}
+
+
+	if ( ( TFMove()->m_nButtons & IN_FORWARD ) && !( TFMove()->m_nOldButtons & IN_FORWARD ) )
+	{
+		// Start timer.
+		if ( TFMove()->CommandoData().m_flDoubleTapForwardTime == COMMANDO_TIME_INVALID )
+		{
+			TFMove()->CommandoData().m_flDoubleTapForwardTime = COMMANDO_DOUBLETAP_TIME;
+		}
+		// Check for a double tap.
+		else
+		{
+			if ( TFMove()->CommandoData().m_flDoubleTapForwardTime > 0.0f )
+				return true;
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementCommando::CheckBullRush( void )
+{
+	// Don't check for bullrush if we are dead!
+	if ( IsDead() )
+		return;
+
+	// Don't go into bullrush if noclipping
+	if ( player->GetMoveType() == MOVETYPE_NOCLIP )
+		return;
+
+	// Cannot bullrush inside of a vehicle (manned <gun>).
+#if !defined (CLIENT_DLL)
+	IServerVehicle *pVehicle = player->GetVehicle();
+	if ( pVehicle )
+		return;
+#else
+	IClientVehicle *pVehicle = player->GetVehicle();
+	if ( pVehicle )
+		return;
+#endif
+
+	if ( CheckDoubleTapForward() && !TFMove()->CommandoData().m_bBullRush && 
+		 TFMove()->CommandoData().m_bCanBullRush && !( player->GetFlags() & FL_DUCKING ) )
+	{
+		// Set in a bull rush.
+		TFMove()->CommandoData().m_bBullRush = true;
+
+		// Set timers.
+		TFMove()->CommandoData().m_flBullRushTime = COMMANDO_BULLRUSH_TIME;
+
+		// Lock view/move angles
+		Vector vBullrushDir;
+		AngleVectors( TFMove()->m_vecViewAngles, &vBullrushDir, NULL, NULL );
+		TFMove()->CommandoData().m_vecBullRushDir = vBullrushDir;
+		TFMove()->CommandoData().m_vecBullRushViewDir = TFMove()->m_vecViewAngles;
+		TFMove()->CommandoData().m_vecBullRushViewGoalDir.Init();
+		TFMove()->CommandoData().m_vecBullRushViewGoalDir.SetY( TFMove()->m_vecViewAngles.y );
+
+		// Set movement type.
+		player->SetMoveType( (MoveType_t)COMMANDO_MOVETYPE_BULLRUSH );
+		player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovementCommando::PrePlayerMove( void )
+{
+	// Assume we don't touch anything (Reset the touch list).
+	MoveHelper()->ResetTouchList();
+
+	// Check to see if we are stuck.
+	if ( CheckStuck() )
+		return false;
+
+	CheckBullRush();
+
+	// Update (reduce) movement timers.
+	UpdateTimers();
+
+	// Check to see if the player is dead and setup death data, otherwise setup 
+	// the players view angles.
+	if ( !CheckDeath() )
+	{
+		SetupViewAngles();
+	}
+
+	// Handle ducking.
+	HandleDuck();
+
+	// Handle ladder.
+	HandleLadder();
+
+	// Categorize the player's position.
+	CategorizePosition();
+
+	// Calculate the player's movement speed (has to happen after categorize position)
+	SetupSpeed();
+
+	// Update our stepping sound (based on the player's location).
+	player->UpdateStepSound( m_pSurfaceData, mv->m_vecAbsOrigin, mv->m_vecVelocity );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementCommando::HandlePlayerMove( void )
+{
+	// Handle the specific bull rush movement type.
+	if ( player->GetMoveType() == COMMANDO_MOVETYPE_BULLRUSH )
+	{
+		BullRushMove();
+		return;
+	}
+
+	// Let the default TF2 player movement code handle the move.
+	BaseClass::HandlePlayerMove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementCommando::HandleDuck( void )
+{
+	if ( player->GetMoveType() == COMMANDO_MOVETYPE_BULLRUSH )
+		return;
+
+	BaseClass::HandleDuck();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementCommando::UpdateTimers( void )
+{
+	BaseClass::UpdateTimers();
+
+	CTFMoveData *pMoveData = TFMove();
+	if ( !pMoveData )
+		return;
+
+	float frame_msec = 1000.0f * gpGlobals->frametime;
+
+	// Decrement the bull rush time.
+	if ( pMoveData->CommandoData().m_flBullRushTime != COMMANDO_TIME_INVALID )
+	{
+		if ( pMoveData->CommandoData().m_flBullRushTime > 0.0f )
+		{
+			pMoveData->CommandoData().m_flBullRushTime -= frame_msec;
+		}
+		else
+		{
+			TFMove()->CommandoData().m_bBullRush = false;
+			TFMove()->CommandoData().m_flBullRushTime = COMMANDO_TIME_INVALID;
+			player->SetMoveType( MOVETYPE_WALK );
+			player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
+		}
+	}
+
+	if ( pMoveData->CommandoData().m_flDoubleTapForwardTime != COMMANDO_TIME_INVALID )
+	{
+		if ( pMoveData->CommandoData().m_flDoubleTapForwardTime > 0.0f )
+		{
+			pMoveData->CommandoData().m_flDoubleTapForwardTime -= frame_msec;
+		}
+		else
+		{
+			pMoveData->CommandoData().m_flDoubleTapForwardTime = COMMANDO_TIME_INVALID;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementCommando::SetupViewAngles( void )
+{
+
+	BaseClass::SetupViewAngles();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementCommando::SetupSpeed( void )
+{
+	BaseClass::SetupSpeed();
+
+	if ( player->GetMoveType() == COMMANDO_MOVETYPE_BULLRUSH )
+	{
+		mv->m_flMaxSpeed = sv_maxspeed.GetFloat();
+
+		// Slow down by the speed factor
+		if (m_pSurfaceData)
+		{
+			mv->m_flMaxSpeed *= m_pSurfaceData->game.maxSpeedFactor;
+		}
+
+		mv->m_flForwardMove = TFMove()->m_flClientMaxSpeed * 4.0f;
+		mv->m_flUpMove = 0.0f;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CTFGameMovementCommando::CalcWishVelocityAndPosition( Vector &vWishPos, Vector &vWishDir, float &flWishSpeed )
+{
+	//
+	// Determine the movement angles.
+	//
+	Vector vForward, vRight, vUp;
+	if ( player->GetMoveType() == COMMANDO_MOVETYPE_BULLRUSH )
+	{
+		vForward = TFMove()->CommandoData().m_vecBullRushDir;
+		// Cross the bullrush direction with the z-axis to get the right vector.
+		CrossProduct( vForward, Vector( 0.0f, 0.0f, 1.0f ), vRight );
+		vUp.Init();
+	}
+	else
+	{
+		AngleVectors( mv->m_vecViewAngles, &vForward, &vRight, &vUp );
+
+		//
+		// Zero out the z component of the movement vectors and renormalize.
+		//
+		vForward.z = 0.0f;
+		VectorNormalize( vForward );
+		vRight.z = 0.0f;
+		VectorNormalize( vRight );
+	}
+
+	//
+	// Determine the xy parts of the velocity.
+	//
+	Vector vWishVel( 0.0f, 0.0f, 0.0f );
+	for ( int axis = 0; axis < 2; axis++ )
+	{
+		vWishVel[axis] = ( vForward[axis] * mv->m_flForwardMove ) +
+			             ( vRight[axis] * mv->m_flSideMove );
+	}
+	vWishVel.z = 0.0f;
+
+	//
+	// Componentize the velocity into direction and speed.
+	//
+	VectorCopy( vWishVel, vWishDir );
+	flWishSpeed = VectorNormalize( vWishDir );
+
+	if ( flWishSpeed > mv->m_flMaxSpeed )
+	{
+		VectorScale( vWishVel, ( mv->m_flMaxSpeed / flWishSpeed ), vWishVel );
+		flWishSpeed = mv->m_flMaxSpeed;
+	}
+
+	//
+	// Accelerate (in the plane).
+	//
+	mv->m_vecVelocity.z = 0.0f;
+	Accelerate( vWishDir, flWishSpeed, sv_accelerate.GetFloat() );
+	mv->m_vecVelocity.z = 0.0f;
+
+	// Add in any base velocity (from conveyers, etc.) to the current velocity.
+	VectorAdd( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
+
+	//
+	// Stop the player (zero out velocity) if the player's speed is below a
+	// given threshold.
+	//
+	float flSpeed = VectorLength( mv->m_vecVelocity );
+	if ( flSpeed < 1.0f /*SPEED_STOP_THRESHOLD*/ )
+	{
+		mv->m_vecVelocity.Init();
+		return false;
+	}
+
+	//
+	// Calculate the wish position.
+	//
+	vWishPos.x = mv->m_vecAbsOrigin.x + ( mv->m_vecVelocity.x * gpGlobals->frametime );
+	vWishPos.y = mv->m_vecAbsOrigin.y + ( mv->m_vecVelocity.y * gpGlobals->frametime );
+	vWishPos.z = mv->m_vecAbsOrigin.z;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementCommando::BullRushMove( void )
+{
+	CTFMoveData *pMoveData = TFMove();
+	if ( !pMoveData )
+		return;
+
+	// Ignoring water for now!!!!
+	StartGravity();
+
+	// Fricion is handled before we add in any base velocity. That way, if we are on a conveyor, 
+	//  we don't slow when standing still, relative to the conveyor.
+	if (player->GetGroundEntity() != NULL)
+	{
+		mv->m_vecVelocity[2] = 0.0;
+		Friction();
+	}
+
+	// Make sure velocity is valid.
+	CheckVelocity();
+
+	if (player->GetGroundEntity() != NULL)
+	{
+		WalkMove2();
+	}
+	else
+	{
+		AirMove();  // Take into account movement when in air.
+	}
+
+	// Set final flags.
+	CategorizePosition();
+
+	// Now pull the base velocity back out.   Base velocity is set if you are on a moving object, like
+	//  a conveyor (or maybe another monster?)
+	VectorSubtract (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
+
+	// Make sure velocity is valid.
+	CheckVelocity();
+
+	// Add any remaining gravitational component.
+	FinishGravity();
+
+	// If we are on ground, no downward velocity.
+	if ( player->GetGroundEntity() != NULL )
+	{
+		mv->m_vecVelocity[2] = 0;
+	}
+
+	CheckFalling();
+}
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_commando.h b/game/shared/tf2/tf_gamemovement_commando.h
new file mode 100644
index 0000000..fa3982a
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_commando.h
@@ -0,0 +1,64 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_COMMANDO_H
+#define TF_GAMEMOVEMENT_COMMANDO_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Commando Game Movement Class
+//
+class CTFGameMovementCommando : public CTFGameMovement
+{
+public:
+
+	DECLARE_CLASS( CTFGameMovementCommando, CTFGameMovement );
+
+	CTFGameMovementCommando();
+
+	// Interface Implementation
+	void			ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	Vector const   &GetPlayerMins( bool bDucked ) const;
+	Vector const   &GetPlayerMaxs( bool bDucked ) const;
+	Vector const   &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	// TF2 movement overrides.
+	bool			PrePlayerMove( void );
+	void			HandlePlayerMove( void );
+	void			HandleDuck( void );
+
+	void			SetupViewAngles( void );
+	void			UpdateTimers( void );
+	void			SetupSpeed( void );
+
+	bool			CalcWishVelocityAndPosition( Vector &vWishPos, Vector &vWishDir, float &flWishSpeed );
+
+	bool			CheckDoubleTapForward( void );
+
+	void			CheckBullRush( void );
+	void			BullRushMove( void );
+
+	PlayerClassCommandoData_t  *m_pCommandoData; 
+	Vector						m_vStandMins;
+	Vector						m_vStandMaxs;
+	Vector						m_vStandViewOffset;
+	Vector						m_vDuckMins;
+	Vector						m_vDuckMaxs;
+	Vector						m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_COMMANDO_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_defender.cpp b/game/shared/tf2/tf_gamemovement_defender.cpp
new file mode 100644
index 0000000..e485ff5
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_defender.cpp
@@ -0,0 +1,65 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_defender.h"
+#include "tf_movedata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementDefender::CTFGameMovementDefender()
+{
+	m_pDefenderData = NULL;
+
+	m_vStandMins = DEFENDERCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = DEFENDERCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = DEFENDERCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = DEFENDERCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = DEFENDERCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = DEFENDERCLASS_VIEWOFFSET_DUCK;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementDefender::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassDefenderData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+	m_pDefenderData = &pTFMoveData->DefenderData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementDefender::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementDefender::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementDefender::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
diff --git a/game/shared/tf2/tf_gamemovement_defender.h b/game/shared/tf2/tf_gamemovement_defender.h
new file mode 100644
index 0000000..e71feb7
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_defender.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_DEFENDER_H
+#define TF_GAMEMOVEMENT_DEFENDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Defender Game Movement Class
+//
+class CTFGameMovementDefender : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementDefender, CTFGameMovement );
+
+public:
+
+	CTFGameMovementDefender();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	PlayerClassDefenderData_t	*m_pDefenderData; 
+	Vector						m_vStandMins;
+	Vector						m_vStandMaxs;
+	Vector						m_vStandViewOffset;
+	Vector						m_vDuckMins;
+	Vector						m_vDuckMaxs;
+	Vector						m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_DEFENDER_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_escort.cpp b/game/shared/tf2/tf_gamemovement_escort.cpp
new file mode 100644
index 0000000..7ce0c48
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_escort.cpp
@@ -0,0 +1,65 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_escort.h"
+#include "tf_movedata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementEscort::CTFGameMovementEscort()
+{
+	m_pEscortData = NULL;
+
+	m_vStandMins = ESCORTCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = ESCORTCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = ESCORTCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = ESCORTCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = ESCORTCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = ESCORTCLASS_VIEWOFFSET_DUCK;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementEscort::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassEscortData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+	m_pEscortData = &pTFMoveData->EscortData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementEscort::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementEscort::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementEscort::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
diff --git a/game/shared/tf2/tf_gamemovement_escort.h b/game/shared/tf2/tf_gamemovement_escort.h
new file mode 100644
index 0000000..c07d9b8
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_escort.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_ESCORT_H
+#define TF_GAMEMOVEMENT_ESCORT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Escort Game Movement Class
+//
+class CTFGameMovementEscort : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementEscort, CTFGameMovement );
+
+public:
+
+	CTFGameMovementEscort();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	PlayerClassEscortData_t	*m_pEscortData; 
+	Vector					m_vStandMins;
+	Vector					m_vStandMaxs;
+	Vector					m_vStandViewOffset;
+	Vector					m_vDuckMins;
+	Vector					m_vDuckMaxs;
+	Vector					m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_ESCORT_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_infiltrator.cpp b/game/shared/tf2/tf_gamemovement_infiltrator.cpp
new file mode 100644
index 0000000..543f1e2
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_infiltrator.cpp
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_infiltrator.h"
+#include "tf_movedata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementInfiltrator::CTFGameMovementInfiltrator()
+{
+	m_pInfiltratorData = NULL;
+
+	m_vStandMins = INFILTRATORCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = INFILTRATORCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = INFILTRATORCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = INFILTRATORCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = INFILTRATORCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = INFILTRATORCLASS_VIEWOFFSET_DUCK;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementInfiltrator::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassInfiltratorData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+	m_pInfiltratorData = &pTFMoveData->InfiltratorData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementInfiltrator::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementInfiltrator::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementInfiltrator::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
diff --git a/game/shared/tf2/tf_gamemovement_infiltrator.h b/game/shared/tf2/tf_gamemovement_infiltrator.h
new file mode 100644
index 0000000..16b5f59
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_infiltrator.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_INFILTRATOR_H
+#define TF_GAMEMOVEMENT_INFILTRATOR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Infiltrator Game Movement Class
+//
+class CTFGameMovementInfiltrator : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementInfiltrator, CTFGameMovement );
+
+public:
+
+	CTFGameMovementInfiltrator();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	PlayerClassInfiltratorData_t	*m_pInfiltratorData; 
+	Vector							m_vStandMins;
+	Vector							m_vStandMaxs;
+	Vector							m_vStandViewOffset;
+	Vector							m_vDuckMins;
+	Vector							m_vDuckMaxs;
+	Vector							m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_INFILTRATOR_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_medic.cpp b/game/shared/tf2/tf_gamemovement_medic.cpp
new file mode 100644
index 0000000..1982004
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_medic.cpp
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_medic.h"
+#include "tf_movedata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementMedic::CTFGameMovementMedic()
+{
+	m_pMedicData = NULL;
+
+	m_vStandMins = MEDICCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = MEDICCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = MEDICCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = MEDICCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = MEDICCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = MEDICCLASS_VIEWOFFSET_DUCK;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementMedic::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassMedicData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+	m_pMedicData = &pTFMoveData->MedicData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementMedic::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementMedic::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementMedic::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
diff --git a/game/shared/tf2/tf_gamemovement_medic.h b/game/shared/tf2/tf_gamemovement_medic.h
new file mode 100644
index 0000000..223c741
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_medic.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_MEDIC_H
+#define TF_GAMEMOVEMENT_MEDIC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Medic Game Movement Class
+//
+class CTFGameMovementMedic : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementMedic, CTFGameMovement );
+
+public:
+
+	CTFGameMovementMedic();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	PlayerClassMedicData_t	*m_pMedicData; 
+	Vector					m_vStandMins;
+	Vector					m_vStandMaxs;
+	Vector					m_vStandViewOffset;
+	Vector					m_vDuckMins;
+	Vector					m_vDuckMaxs;
+	Vector					m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_MEDIC_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_pyro.cpp b/game/shared/tf2/tf_gamemovement_pyro.cpp
new file mode 100644
index 0000000..8bbc2d8
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_pyro.cpp
@@ -0,0 +1,63 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_pyro.h"
+#include "tf_movedata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementPyro::CTFGameMovementPyro()
+{
+	m_pPyroData = NULL;
+
+	m_vStandMins = PYROCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = PYROCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = PYROCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = PYROCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = PYROCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = PYROCLASS_VIEWOFFSET_DUCK;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementPyro::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassPyroData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+	m_pPyroData = &pTFMoveData->PyroData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementPyro::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementPyro::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementPyro::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
+
diff --git a/game/shared/tf2/tf_gamemovement_pyro.h b/game/shared/tf2/tf_gamemovement_pyro.h
new file mode 100644
index 0000000..8aa25b5
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_pyro.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_PYRO_H
+#define TF_GAMEMOVEMENT_PYRO_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Pyro Game Movement Class
+//
+class CTFGameMovementPyro : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementPyro, CTFGameMovement );
+
+public:
+
+	CTFGameMovementPyro();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	PlayerClassPyroData_t	*m_pPyroData; 
+	Vector							m_vStandMins;
+	Vector							m_vStandMaxs;
+	Vector							m_vStandViewOffset;
+	Vector							m_vDuckMins;
+	Vector							m_vDuckMaxs;
+	Vector							m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_PYRO_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_recon.cpp b/game/shared/tf2/tf_gamemovement_recon.cpp
new file mode 100644
index 0000000..c9b8987
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_recon.cpp
@@ -0,0 +1,595 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_recon.h"
+#include "tf_movedata.h"
+#include "in_buttons.h"
+			   
+#define TIME_WALL_SUPPRESSION_JUMP	    100
+#define TIME_WALL_SUPPRESSION_IMPACT	400
+#define TIME_WALL_STICK					 50
+#define TIME_STRAFE_STICK				 50
+#define TIME_LEAP_STICK					300
+#define TIME_WALL_ACTIVATE_JUMP			300
+#define TIME_WALL_INVALID				-99999
+#define MAX_VERTICAL_SPEED				400
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementRecon::CTFGameMovementRecon()
+{
+	m_pReconData = NULL;
+
+	m_vStandMins = RECONCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = RECONCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = RECONCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = RECONCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = RECONCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = RECONCLASS_VIEWOFFSET_DUCK;
+
+	m_bPerformingAirMove = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementRecon::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMove )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassReconData_t::PLAYERCLASS_ID == pTFMove->m_nClassID );
+	m_pReconData = &pTFMove->ReconData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, pTFMove );
+
+	// Set the jump count appropriately...
+	// If we've hit the ground, we can double jump again...
+	if ((player->GetGroundEntity() != NULL) && (pTFMove->ReconData().m_flStickTime == TIME_WALL_INVALID))
+	{
+		m_pReconData->m_nJumpCount = 0;
+		ResetWallImpact( (CTFMoveData*)mv );
+	}
+}
+
+void CTFGameMovementRecon::PostPlayerMove( void )
+{
+	BaseClass::PostPlayerMove( );
+
+	if (m_pReconData->m_flStickTime != TIME_WALL_INVALID)
+	{
+		// We're stuck, so stick!
+		mv->m_vecVelocity.Init( 0.0f, 0.0f, 0.0f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementRecon::UpdateTimers( void )
+{
+	BaseClass::UpdateTimers();
+
+	CTFMoveData *pTFMove = TFMove();
+	if ( !pTFMove )
+		return;
+
+	float frame_msec = 1000.0f * gpGlobals->frametime;
+
+	// Decrement the recon timers.
+	if ( pTFMove->ReconData().m_flSuppressionJumpTime != TIME_WALL_INVALID )
+	{
+		pTFMove->ReconData().m_flSuppressionJumpTime -= frame_msec;
+		if ( pTFMove->ReconData().m_flSuppressionJumpTime <= 0.0f )
+		{
+			pTFMove->ReconData().m_flSuppressionJumpTime = TIME_WALL_INVALID;
+		}
+	}
+
+	if ( pTFMove->ReconData().m_flSuppressionImpactTime != TIME_WALL_INVALID )
+	{
+		pTFMove->ReconData().m_flSuppressionImpactTime -= frame_msec;
+		if ( pTFMove->ReconData().m_flSuppressionImpactTime <= 0.0f )
+		{
+			pTFMove->ReconData().m_flSuppressionImpactTime = TIME_WALL_INVALID;
+		}
+	}
+
+	if ( pTFMove->ReconData().m_flActiveJumpTime != TIME_WALL_INVALID )
+	{
+		pTFMove->ReconData().m_flActiveJumpTime -= frame_msec;
+		if ( pTFMove->ReconData().m_flActiveJumpTime <= 0.0f )
+		{
+			pTFMove->ReconData().m_flActiveJumpTime = TIME_WALL_INVALID;
+		}
+	}
+
+	if ( pTFMove->ReconData().m_flStickTime != TIME_WALL_INVALID )
+	{
+		pTFMove->ReconData().m_flStickTime -= frame_msec;
+		if ( pTFMove->ReconData().m_flStickTime <= 0.0f )
+		{
+			pTFMove->ReconData().m_flStickTime = TIME_WALL_INVALID;
+
+			// Restore velocity at this time
+			pTFMove->m_vecVelocity = pTFMove->ReconData().m_vecUnstickVelocity;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Implement this if you want to know when the player collides during OnPlayerMove
+//-----------------------------------------------------------------------------
+void CTFGameMovementRecon::OnTryPlayerMoveCollision( trace_t &tr )
+{
+	if ( !m_bPerformingAirMove )
+		return;
+	
+	// Only keep track of world collisions
+	if ( tr.DidHitWorld() )
+	{
+		CTFMoveData *pTFMove = TFMove();
+		if ( pTFMove )
+		{
+			if ( ( pTFMove->ReconData().m_flSuppressionJumpTime == TIME_WALL_INVALID ) &&
+				 ( pTFMove->ReconData().m_flSuppressionImpactTime == TIME_WALL_INVALID ) )
+			{
+				// No walljumps off of mostly horizontal surfaces...
+				if ( fabs( tr.plane.normal.z ) > 0.9f )
+					return;
+			
+				// No walljumps off of the same plane as the last one...
+				if ( (pTFMove->ReconData().m_flImpactDist == tr.plane.dist) && 
+					(VectorsAreEqual(pTFMove->ReconData().m_vecImpactNormal, tr.plane.normal, 1e-2) ) )
+				{
+					return;
+				}
+
+				// If you hit a wall, no double jumps for you
+				pTFMove->ReconData().m_nJumpCount = 2;
+				
+				// Play an impact sound
+				MoveHelper()->StartSound( pTFMove->m_vecAbsOrigin, "Recon.WallJump" );
+
+				pTFMove->ReconData().m_vecImpactNormal = tr.plane.normal;
+				pTFMove->ReconData().m_flImpactDist = tr.plane.dist;
+
+				pTFMove->ReconData().m_flActiveJumpTime = TIME_WALL_ACTIVATE_JUMP;
+				pTFMove->ReconData().m_flSuppressionImpactTime = TIME_WALL_SUPPRESSION_IMPACT;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementRecon::AirMove()
+{
+	m_bPerformingAirMove = true;
+
+	// When in the air, recon travels ballistically
+	if ( TFMove()->ReconData().m_nJumpCount )
+	{
+		// Add in any base velocity to the current velocity.
+		VectorAdd( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
+
+		TryPlayerMove();
+	}
+	else
+	{
+		// But if we're falling (or coming up off ladders), treat it normally
+		BaseClass::AirMove();
+	}
+
+	m_bPerformingAirMove = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check the jump button to make various jumps
+//-----------------------------------------------------------------------------
+bool CTFGameMovementRecon::CheckWaterJump()
+{
+	// See if we are waterjumping.  If so, decrement count and return.
+	if (player->m_flWaterJumpTime)
+	{
+		player->m_flWaterJumpTime -= gpGlobals->frametime;
+		if (player->m_flWaterJumpTime < 0)
+			player->m_flWaterJumpTime = 0;
+		
+		return true;
+	}
+
+	// If we are in the water most of the way...
+	if ( player->GetWaterLevel() >= 2 )
+	{	
+		// swimming, not jumping
+		SetGroundEntity( NULL );
+
+		if(player->GetWaterType() == CONTENTS_WATER)    // We move up a certain amount
+			mv->m_vecVelocity[2] = 100;
+		else if (player->GetWaterType() == CONTENTS_SLIME)
+			mv->m_vecVelocity[2] = 80;
+		
+		// play swiming sound
+		if ( player->m_flSwimSoundTime <= 0 )
+		{
+			// Don't play sound again for 1 second
+			player->m_flSwimSoundTime = 1000;
+			PlaySwimSound();
+		}
+		return true;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Resets the impact time
+//-----------------------------------------------------------------------------
+void CTFGameMovementRecon::ResetWallImpact( CTFMoveData *pTFMove )
+{
+	if ( pTFMove->ReconData().m_flActiveJumpTime != TIME_WALL_INVALID )
+	{
+		pTFMove->ReconData().m_flActiveJumpTime = TIME_WALL_INVALID;
+		pTFMove->ReconData().m_flSuppressionImpactTime = TIME_WALL_INVALID;
+		pTFMove->ReconData().m_vecImpactNormal.Init( 9999, 9999, 9999 );
+		pTFMove->ReconData().m_flImpactDist = -9999.0f;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check the jump button to make various jumps
+//-----------------------------------------------------------------------------
+bool CTFGameMovementRecon::CheckWallJump( CTFMoveData *pTFMove )
+{
+	if ( player->GetGroundEntity() != NULL )
+		return false;
+
+	if ( pTFMove->ReconData().m_flActiveJumpTime == TIME_WALL_INVALID )
+		return false;
+
+	// Play a jump sound
+	PlayStepSound( m_pSurfaceData, 1.0, true );
+
+	Vector jumpDir;
+	if ( ( pTFMove->m_nButtons & ( IN_MOVELEFT | IN_MOVERIGHT ) ) )
+	{
+		AngleVectors( pTFMove->m_vecViewAngles, NULL, &jumpDir, NULL );
+
+		// Apply strafe jump...
+		jumpDir *= ( pTFMove->m_nButtons & IN_MOVELEFT ) ? -1.0f : 1.0f;
+		jumpDir.z = 0.0f;
+
+		if ( pTFMove->m_nButtons & ( IN_FORWARD | IN_BACK ) )
+		{
+			Vector forward;
+			AngleVectors( pTFMove->m_vecViewAngles, &forward, NULL, NULL );
+			forward *= 0.5f;
+			forward *= ( pTFMove->m_nButtons & IN_BACK ) ? -1.0f : 1.0f;
+			forward.z = 0.0;
+			jumpDir += forward;
+		}
+
+		VectorNormalize( jumpDir );
+		jumpDir *= 400;
+	}
+	else
+	{
+		AngleVectors( pTFMove->m_vecViewAngles, &jumpDir, NULL, NULL );
+		jumpDir *= ( pTFMove->m_nButtons & IN_BACK ) ? -1.0f : 1.0f;
+		jumpDir.z = 0.0;
+
+		VectorNormalize( jumpDir );
+		jumpDir *= 400;
+	}
+
+	pTFMove->ReconData().m_flStickTime = TIME_WALL_STICK;
+	pTFMove->ReconData().m_vecUnstickVelocity.Init( jumpDir.x, jumpDir.y, 
+		pTFMove->m_vecVelocity[2] + 1.5 * sqrt(2 * 800 * 45.0) );
+	if (pTFMove->ReconData().m_vecUnstickVelocity.GetZ() > MAX_VERTICAL_SPEED)
+		pTFMove->ReconData().m_vecUnstickVelocity.SetZ( MAX_VERTICAL_SPEED );
+
+	pTFMove->m_vecVelocity.Init( 0, 0, 0 );
+
+	// Don't allow jump into wall
+	float normalComponent = DotProduct( pTFMove->ReconData().m_vecUnstickVelocity, pTFMove->ReconData().m_vecImpactNormal );
+	if ( normalComponent < 0 )
+	{
+		Vector vUnstickVel;
+		VectorMA( pTFMove->ReconData().m_vecUnstickVelocity, -normalComponent, 
+			pTFMove->ReconData().m_vecImpactNormal, vUnstickVel );
+		pTFMove->ReconData().m_vecUnstickVelocity = vUnstickVel;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check the jump button to make various jumps
+//-----------------------------------------------------------------------------
+bool CTFGameMovementRecon::CheckBackJump( bool bWasInAir )
+{
+	if ((mv->m_nButtons & IN_BACK) == 0)
+		return false;
+
+	Vector jumpDir, right;
+	AngleVectors( mv->m_vecViewAngles, &jumpDir, &right, NULL );
+	jumpDir.z = 0.0f;
+	jumpDir *= -1.0f;
+
+	if (mv->m_nButtons & (IN_MOVELEFT | IN_MOVERIGHT))
+	{
+		// Apply strafe jump...
+		right *= (mv->m_nButtons & IN_MOVELEFT) ? -1.0f : 1.0f;
+		right.z = 0.0f;
+
+		// Make us not jump quite at a 45% angle if both are selected
+		right *= 0.5f;
+		jumpDir += right;
+	}
+
+	VectorNormalize( jumpDir );
+
+	float flGroundFactor = 1.0f;
+	if ((m_pSurfaceData) /*&& (!bWasInAir)*/ )
+	{
+		flGroundFactor = m_pSurfaceData->game.jumpFactor;
+	}
+
+	jumpDir *= 150 * flGroundFactor;
+
+	// Dampen current motion
+	mv->m_vecVelocity[0] *= 0.5f;
+	mv->m_vecVelocity[1] *= 0.5f;
+
+	float flSideFactor = (bWasInAir) ? 2.0f : 1.0f;
+	float flUpFactor = (bWasInAir) ? 0.5f : 1.5f;
+	flSideFactor *= flGroundFactor;
+	flUpFactor *= flGroundFactor;
+
+	mv->m_vecVelocity[0] += flSideFactor * jumpDir.x;
+	mv->m_vecVelocity[1] += flSideFactor * jumpDir.y;
+	mv->m_vecVelocity[2] += flUpFactor * sqrt(2 * 800 * 45.0); 
+
+	mv->m_vecVelocity[0] = clamp( mv->m_vecVelocity[0], -200, 200 );
+	mv->m_vecVelocity[1] = clamp( mv->m_vecVelocity[1], -200, 200 );
+	if (mv->m_vecVelocity[2] > MAX_VERTICAL_SPEED)
+		mv->m_vecVelocity[2] = MAX_VERTICAL_SPEED;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check the jump button to make various jumps
+//-----------------------------------------------------------------------------
+bool CTFGameMovementRecon::CheckStrafeJump( bool bWasInAir )
+{
+	if ( (mv->m_nButtons & (IN_MOVELEFT | IN_MOVERIGHT)) == 0 )
+		return false;
+
+	if (mv->m_nButtons & IN_FORWARD)
+		return false;
+
+	Vector jumpDir;
+	AngleVectors( mv->m_vecViewAngles, NULL, &jumpDir, NULL );
+
+	// Apply strafe jump...
+	jumpDir *= (mv->m_nButtons & IN_MOVELEFT) ? -1.0f : 1.0f;
+	jumpDir.z = 0.0f;
+	VectorNormalize( jumpDir );
+
+	float flGroundFactor = 1.0f;
+	if ((m_pSurfaceData) /*&& (!bWasInAir)*/ )
+	{
+		flGroundFactor = m_pSurfaceData->game.jumpFactor;
+	}
+
+	jumpDir *= 300 * flGroundFactor;
+
+	// Dampen current motion
+	mv->m_vecVelocity[0] *= 0.5f;
+	mv->m_vecVelocity[1] *= 0.5f;
+	mv->m_vecVelocity[0] += jumpDir.x;
+	mv->m_vecVelocity[1] += jumpDir.y;
+
+	if (!bWasInAir)
+		mv->m_vecVelocity[2] += flGroundFactor * sqrt(2 * 800 * 45.0);  // 2 * gravity * height
+	else
+		mv->m_vecVelocity[2] += 0.5f * sqrt(2 * 800 * 45.0);  // 2 * gravity * height
+
+	mv->m_vecVelocity[0] = clamp( mv->m_vecVelocity[0], -400, 400 );
+	mv->m_vecVelocity[1] = clamp( mv->m_vecVelocity[1], -400, 400 );
+	if (mv->m_vecVelocity[2] > MAX_VERTICAL_SPEED)
+		mv->m_vecVelocity[2] = MAX_VERTICAL_SPEED;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check the jump button to make various jumps
+//-----------------------------------------------------------------------------
+bool CTFGameMovementRecon::CheckForwardJump( bool bWasInAir )
+{
+	// If we are ducking...
+	if ( ( player->m_Local.m_bDucking ) || ( player->GetFlags() & FL_DUCKING ) )
+	{
+		// d = 0.5 * g * t^2		- distance traveled with linear accel
+		// t = sqrt(2.0 * 45 / g)	- how long to fall 45 units
+		// v = g * t				- velocity at the end (just invert it to jump up that high)
+		// v = g * sqrt(2.0 * 45 / g )
+		// v^2 = g * g * 2.0 * 45 / g
+		// v = sqrt( g * 2.0 * 45 )
+		mv->m_vecVelocity[2] = sqrt(2 * 800 * 45.0);  // 2 * gravity * height
+	}
+	else
+	{
+		Vector forward, right;
+		AngleVectors( mv->m_vecViewAngles, &forward, &right, NULL );
+ 		forward.z = 0.0;
+
+		if ((mv->m_nButtons & IN_FORWARD) == 0)
+		{
+			forward.x = forward.y = 0.0f;
+		}
+
+		if (mv->m_nButtons & (IN_MOVELEFT | IN_MOVERIGHT))
+		{
+			// Apply strafe jump...
+			right *= (mv->m_nButtons & IN_MOVELEFT) ? -1.0f : 1.0f;
+			right.z = 0.0f;
+
+			// Make us not jump quite at a 45% angle if both are selected
+			right *= 0.5f;
+			forward += right;
+		}
+
+		VectorNormalize( forward );
+
+		// Slow down by the speed factor
+		float flGroundFactor = 1.0f;
+		if ((m_pSurfaceData) /* && (!bWasInAir) */ )
+		{
+			flGroundFactor = m_pSurfaceData->game.jumpFactor;
+		}
+
+		forward *= 400 * flGroundFactor;	  
+
+		// Dampen current motion
+		mv->m_vecVelocity[0] *= 0.5f;
+		mv->m_vecVelocity[1] *= 0.5f;
+		mv->m_vecVelocity[0] += forward.x;
+		mv->m_vecVelocity[1] += forward.y;
+
+		float flUpFactor = (bWasInAir) ? 0.7f : 1.0f;
+		flUpFactor *= flGroundFactor;
+
+		mv->m_vecVelocity[2] += flUpFactor * MAX_VERTICAL_SPEED;
+
+		// Limit their velocity in X and Y. We don't want to just clamp because that will change the
+		// direction we're moving in.		
+		for ( int i=0; i < 2; i++ )
+		{
+			float flAbs = fabs( mv->m_vecVelocity[i] );
+			if ( flAbs > 400 )
+			{
+				mv->m_vecVelocity[0] *= (400.0f / flAbs);
+				mv->m_vecVelocity[1] *= (400.0f / flAbs);
+			}
+		}
+
+		if (mv->m_vecVelocity[2] > MAX_VERTICAL_SPEED)
+ 			mv->m_vecVelocity[2] = MAX_VERTICAL_SPEED;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check the jump button to make various jumps
+//-----------------------------------------------------------------------------
+bool CTFGameMovementRecon::CheckJumpButton()
+{
+	// FIXME: Refactor this so we don't have this complicated duplicate
+	// code here + in gamemovement.cpp
+
+	if ( player->pl.deadflag )
+	{
+		mv->m_nOldButtons |= IN_JUMP ;	// don't jump again until released
+		return false;
+	}
+
+	// Water jumps!
+	if ( CheckWaterJump() )
+		return false;
+
+	if ( mv->m_nOldButtons & IN_JUMP )
+		return false;		// don't pogo stick
+
+	CTFMoveData *pTFMove = static_cast<CTFMoveData*>( mv );
+
+	// Check for wall jump...
+	if ( !CheckWallJump( pTFMove ) )
+	{
+		// If we already did one air jump, can't do another 
+ 		if ( (player->GetGroundEntity() == NULL ) && ( pTFMove->ReconData().m_nJumpCount > 1) )
+		{
+			mv->m_nOldButtons |= IN_JUMP;
+			return false;		// in air, so no effect
+		}
+
+		pTFMove->ReconData().m_nJumpCount += 1;
+
+		// Am I doing a double-jump?
+		bool bWasInAir = (player->GetGroundEntity() == NULL);
+
+		// In the air now.
+		SetGroundEntity( NULL );
+		
+		PlayStepSound( m_pSurfaceData, 1.0, true );
+
+		if (!CheckBackJump(bWasInAir))
+		{
+			if (CheckStrafeJump(bWasInAir))
+			{
+				// Can't double jump out of a roll....
+				pTFMove->ReconData().m_nJumpCount += 1;
+			}
+			else
+			{
+				CheckForwardJump(bWasInAir);
+			}
+		}
+	}
+
+	pTFMove->ReconData().m_flSuppressionJumpTime = TIME_WALL_SUPPRESSION_JUMP;	
+
+	FinishGravity();
+
+	mv->m_outWishVel = mv->m_vecVelocity;
+	mv->m_outStepHeight += 0.1f;
+
+	// Flag that we jumped.
+	mv->m_nOldButtons |= IN_JUMP;	// don't jump again until released
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementRecon::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementRecon::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementRecon::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
diff --git a/game/shared/tf2/tf_gamemovement_recon.h b/game/shared/tf2/tf_gamemovement_recon.h
new file mode 100644
index 0000000..f6cb953
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_recon.h
@@ -0,0 +1,73 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_RECON_H
+#define TF_GAMEMOVEMENT_RECON_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Recon Game Movement Class
+//
+class CTFGameMovementRecon : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementRecon, CTFGameMovement );
+
+public:
+
+	CTFGameMovementRecon();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+	// Purpose:
+	virtual void			AirMove();
+
+protected:
+	virtual void			PostPlayerMove( void );
+
+	void					UpdateTimers( void );
+
+	// Purpose: Check the jump button to make various jumps
+	bool					CheckJumpButton();
+
+	// Check various jump types
+	bool					CheckWaterJump();
+	bool					CheckWallJump(CTFMoveData *pTFMove);
+	bool					CheckBackJump( bool bWasInAir );
+	bool					CheckStrafeJump( bool bWasInAir );
+	bool					CheckForwardJump( bool bWasInAir );
+
+	// Resets the impact time
+	void					ResetWallImpact(CTFMoveData *pTFMove);
+
+	// Implement this if you want to know when the player collides during OnPlayerMove
+	virtual void			OnTryPlayerMoveCollision( trace_t &tr );
+
+	PlayerClassReconData_t	*m_pReconData; 
+	Vector					m_vStandMins;
+	Vector					m_vStandMaxs;
+	Vector					m_vStandViewOffset;
+	Vector					m_vDuckMins;
+	Vector					m_vDuckMaxs;
+	Vector					m_vDuckViewOffset;
+	bool					m_bPerformingAirMove;
+};
+
+#endif // TF_GAMEMOVEMENT_RECON_H
diff --git a/game/shared/tf2/tf_gamemovement_sapper.cpp b/game/shared/tf2/tf_gamemovement_sapper.cpp
new file mode 100644
index 0000000..3e10a31
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_sapper.cpp
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_sapper.h"
+#include "tf_movedata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementSapper::CTFGameMovementSapper()
+{
+	m_pSapperData = NULL;
+
+	m_vStandMins = SAPPERCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = SAPPERCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = SAPPERCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = SAPPERCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = SAPPERCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = SAPPERCLASS_VIEWOFFSET_DUCK;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementSapper::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassSapperData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+	m_pSapperData = &pTFMoveData->SapperData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSapper::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSapper::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSapper::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
diff --git a/game/shared/tf2/tf_gamemovement_sapper.h b/game/shared/tf2/tf_gamemovement_sapper.h
new file mode 100644
index 0000000..ecb9c23
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_sapper.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Sapper's game movement
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_SAPPER_H
+#define TF_GAMEMOVEMENT_SAPPER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Sapper Game Movement Class
+//
+class CTFGameMovementSapper : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementSapper, CTFGameMovement );
+
+public:
+
+	CTFGameMovementSapper();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	PlayerClassSapperData_t	*m_pSapperData; 
+	Vector						m_vStandMins;
+	Vector						m_vStandMaxs;
+	Vector						m_vStandViewOffset;
+	Vector						m_vDuckMins;
+	Vector						m_vDuckMaxs;
+	Vector						m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_SAPPER_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_sniper.cpp b/game/shared/tf2/tf_gamemovement_sniper.cpp
new file mode 100644
index 0000000..3a37ad2
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_sniper.cpp
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_sniper.h"
+#include "tf_movedata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementSniper::CTFGameMovementSniper()
+{
+	m_pSniperData = NULL;
+
+	m_vStandMins = SNIPERCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = SNIPERCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = SNIPERCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = SNIPERCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = SNIPERCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = SNIPERCLASS_VIEWOFFSET_DUCK;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementSniper::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassSniperData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+	m_pSniperData = &pTFMoveData->SniperData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSniper::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSniper::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSniper::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
diff --git a/game/shared/tf2/tf_gamemovement_sniper.h b/game/shared/tf2/tf_gamemovement_sniper.h
new file mode 100644
index 0000000..bad34ca
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_sniper.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_SNIPER_H
+#define TF_GAMEMOVEMENT_SNIPER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Sniper Game Movement Class
+//
+class CTFGameMovementSniper : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementSniper, CTFGameMovement );
+
+public:
+
+	CTFGameMovementSniper();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	PlayerClassSniperData_t	*m_pSniperData; 
+	Vector					m_vStandMins;
+	Vector					m_vStandMaxs;
+	Vector					m_vStandViewOffset;
+	Vector					m_vDuckMins;
+	Vector					m_vDuckMaxs;
+	Vector					m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_SNIPER_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamemovement_support.cpp b/game/shared/tf2/tf_gamemovement_support.cpp
new file mode 100644
index 0000000..cc6ae77
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_support.cpp
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_gamemovement_support.h"
+#include "tf_movedata.h"
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+CTFGameMovementSupport::CTFGameMovementSupport()
+{
+	m_pSupportData = NULL;
+
+	m_vStandMins = SUPPORTCLASS_HULL_STAND_MIN;
+	m_vStandMaxs = SUPPORTCLASS_HULL_STAND_MAX;
+	m_vStandViewOffset = SUPPORTCLASS_VIEWOFFSET_STAND;
+
+	m_vDuckMins = SUPPORTCLASS_HULL_DUCK_MIN;
+	m_vDuckMaxs = SUPPORTCLASS_HULL_DUCK_MAX;
+	m_vDuckViewOffset = SUPPORTCLASS_VIEWOFFSET_DUCK;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFGameMovementSupport::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData )
+{
+	// Get the class specific data from the TFMoveData structure
+	Assert( PlayerClassSupportData_t::PLAYERCLASS_ID == pTFMoveData->m_nClassID );
+	m_pSupportData = &pTFMoveData->SupportData();
+
+	// to test pass it through!!
+	BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, static_cast<CMoveData*>( pTFMoveData ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSupport::GetPlayerMins( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMins : m_vStandMins; 
+}
+	
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSupport::GetPlayerMaxs( bool bDucked ) const
+{
+	return bDucked ? m_vDuckMaxs : m_vStandMaxs;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector &CTFGameMovementSupport::GetPlayerViewOffset( bool bDucked ) const
+{
+	return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
+}
diff --git a/game/shared/tf2/tf_gamemovement_support.h b/game/shared/tf2/tf_gamemovement_support.h
new file mode 100644
index 0000000..9523174
--- /dev/null
+++ b/game/shared/tf2/tf_gamemovement_support.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Auto Repair
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMEMOVEMENT_SUPPORT_H
+#define TF_GAMEMOVEMENT_SUPPORT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_gamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CTFMoveData;
+
+//=============================================================================
+//
+// Support Game Movement Class
+//
+class CTFGameMovementSupport : public CTFGameMovement
+{
+
+	DECLARE_CLASS( CTFGameMovementSupport, CTFGameMovement );
+
+public:
+
+	CTFGameMovementSupport();
+
+	// Interface Implementation
+//	virtual void ProcessMovement( CTFMoveData *pTFMoveData );
+	virtual void ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMoveData );
+	virtual const Vector &GetPlayerMins( bool bDucked ) const;
+	virtual const Vector &GetPlayerMaxs( bool bDucked ) const;
+	virtual const Vector &GetPlayerViewOffset( bool bDucked ) const;
+
+protected:
+
+	PlayerClassSupportData_t	*m_pSupportData; 
+	Vector						m_vStandMins;
+	Vector						m_vStandMaxs;
+	Vector						m_vStandViewOffset;
+	Vector						m_vDuckMins;
+	Vector						m_vDuckMaxs;
+	Vector						m_vDuckViewOffset;
+};
+
+#endif // TF_GAMEMOVEMENT_SUPPORT_H
\ No newline at end of file
diff --git a/game/shared/tf2/tf_gamerules.cpp b/game/shared/tf2/tf_gamerules.cpp
new file mode 100644
index 0000000..cf9b980
--- /dev/null
+++ b/game/shared/tf2/tf_gamerules.cpp
@@ -0,0 +1,2242 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The TF Game rules 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "tf_gamerules.h"
+#include "tf_shareddefs.h"
+#include "ammodef.h"
+#include "basetfcombatweapon_shared.h"
+#include <KeyValues.h>
+
+
+#ifdef CLIENT_DLL
+
+	#include "c_shield.h"
+	#include "c_te_effect_dispatch.h"
+	#define CShield C_Shield
+
+#else
+	
+	#include "tf_shield.h"
+	#include "te_effect_dispatch.h"
+	#include "player.h"
+	#include "tf_player.h"
+	#include "game.h"
+	#include "gamerules.h"
+	#include "teamplay_gamerules.h"
+	#include "menu_base.h"
+	#include "ammodef.h"
+	#include "techtree.h"
+	#include "tf_team.h"
+	#include "tf_shield.h"
+	#include "mathlib/mathlib.h"
+	#include "entitylist.h"
+	#include "basecombatweapon.h"
+	#include "voice_gamemgr.h"
+	#include "tf_class_infiltrator.h"
+	#include "team_messages.h"
+	#include "ndebugoverlay.h"
+	#include "bot_base.h"
+	#include "vstdlib/random.h"
+	#include "info_act.h"
+	#include "igamesystem.h"
+	#include "filesystem.h"
+	#include "info_vehicle_bay.h"
+	#include "IserverVehicle.h"
+	#include "weapon_builder.h"
+	#include "weapon_objectselection.h"
+	#include "tf_player_resource.h"
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+REGISTER_GAMERULES_CLASS( CTeamFortress );
+
+
+#ifdef CLIENT_DLL
+
+
+#else
+   
+	#define MAX_OBJECT_COMMAND_DISTANCE 120.0f
+
+	class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
+	{
+	public:
+		virtual bool		CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker )
+		{
+			// Gagged players can't talk at all
+			if ( ((CBaseTFPlayer*)pTalker)->CanSpeak() == false )
+				return false;
+
+			// Dead players can only be heard by other dead team mates
+			if ( pTalker->IsAlive() == false )
+			{
+				if ( pListener->IsAlive() == false )
+					return ( pListener->InSameTeam( pTalker ) );
+
+				return false;
+			}
+
+			return ( pListener->InSameTeam( pTalker ) );
+		}
+	};
+	CVoiceGameMgrHelper g_VoiceGameMgrHelper;
+	IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;
+
+
+	// Load the objects.txt file.
+	class CObjectsFileLoad : public CAutoGameSystem
+	{
+	public:
+		virtual bool Init()
+		{
+			LoadObjectInfos( filesystem );
+			return true;
+		}
+	} g_ObjectsFileLoad;
+
+
+
+	extern bool		g_fGameOver;
+	float			g_flNextReinforcementTime = 0.0f;
+	extern ConVar	tf_knockdowntime;
+
+	// Time between reinforcements
+	#define REINFORCEMENT_TIME		15.0
+
+	ConVar    sk_plr_dmg_grenade		( "sk_plr_dmg_grenade","0");
+
+	char *sTeamNames[] =
+	{
+		"Unassigned",
+		"Spectator",
+		"Human",
+		"Alien",
+	};
+
+	// Handle the "PossessBot" command.
+	void PossessBot_f()
+	{
+		CBaseTFPlayer *pPlayer = CBaseTFPlayer::Instance( UTIL_GetCommandClientIndex() );
+		if ( !pPlayer )
+			return;
+
+		// Put the local player in control of this bot.
+		if ( args.ArgC() != 2 )
+		{
+			Warning( "PossessBot <client index>\n" );
+			return;
+		}
+
+		int iBotClient = atoi( args[1) );
+		int iBotEnt = iBotClient + 1;
+		
+		if ( iBotClient < 0 || 
+			iBotClient >= gpGlobals->maxClients || 
+			pPlayer->entindex() == iBotEnt )
+		{
+			Warning( "PossessBot <client index>\n" );
+		}
+		else
+		{
+			edict_t *pPlayerData = pPlayer->edict();
+			edict_t *pBotData = engine->PEntityOfEntIndex( iBotEnt );
+			if ( pBotData && pBotData->GetUnknown() )
+			{
+				// SWAP EDICTS
+
+				// Backup things we don't want to swap.
+				edict_t oldPlayerData = *pPlayerData;
+				edict_t oldBotData = *pBotData;
+
+				// Swap edicts.
+				edict_t tmp = *pPlayerData;
+				*pPlayerData = *pBotData;
+				*pBotData = tmp;
+
+				CBaseEntity *pPlayerBaseEnt = CBaseEntity::Instance( pPlayerData );
+				CBaseEntity *pBotBaseEnt = CBaseEntity::Instance( pBotData );
+
+				// Make the other a bot and make the player not a bot.
+				pPlayerBaseEnt->RemoveFlag( FL_FAKECLIENT );
+				pBotBaseEnt->AddFlag( FL_FAKECLIENT );
+			
+				// Point the CBaseEntities at the right players.
+				pPlayerBaseEnt->NetworkProp()->SetEdict( pPlayerData );
+				pBotBaseEnt->NetworkProp()->SetEdict( pBotData );
+
+				// Freeze the bot.
+				pBotBaseEnt->AddEFlags( EFL_BOT_FROZEN );
+
+				// Remove orders to both of them..
+				CTFTeam *pTeam = pPlayer->GetTFTeam();
+				if ( pTeam )
+				{
+					pTeam->RemoveOrdersToPlayer( (CBaseTFPlayer*)pPlayerBaseEnt );
+					pTeam->RemoveOrdersToPlayer( (CBaseTFPlayer*)pBotBaseEnt );
+				}
+			}
+		}
+	}
+
+
+	// Handler for the "bot" command.
+	CON_COMMAND_F( "bot", "Add a bot.", FCVAR_CHEAT )
+	{
+		CBaseTFPlayer *pPlayer = CBaseTFPlayer::Instance( UTIL_GetCommandClientIndex() );
+
+		// The bot command uses switches like command-line switches.
+		// -count <count> tells how many bots to spawn.
+		// -team <index> selects the bot's team. Default is -1 which chooses randomly.
+		//	Note: if you do -team !, then it 
+		// -class <index> selects the bot's class. Default is -1 which chooses randomly.
+		// -frozen prevents the bots from running around when they spawn in.
+
+		// Look at -count.
+		int count = args.FindArgInt( "-count", 1 );
+		count = clamp( count, 1, 16 );
+
+		int iTeam = -1;
+		const char *pVal = args.FindArg( "-team" );
+		if ( pVal )
+		{
+			if ( pVal[0] == '!' )
+			{
+				iTeam = pPlayer->GetTFTeam()->GetEnemyTeam()->GetTeamNumber();
+			}
+			else
+			{
+				iTeam = atoi( pVal );
+				iTeam = clamp( iTeam, 0, (GetNumberOfTeams()-1) );
+			}
+		}
+
+		int iClass = args.FindArgInt( "-class", -1 );
+		iClass = clamp( iClass, -1, TFCLASS_CLASS_COUNT );
+		if ( iClass == TFCLASS_UNDECIDED )
+			iClass = TFCLASS_RECON;
+		
+		// Look at -frozen.
+		bool bFrozen = !!args.FindArg( "-frozen" );
+			
+		// Ok, spawn all the bots.
+		while ( --count >= 0 )
+		{
+			BotPutInServer( bFrozen, iTeam, iClass );
+		}
+	}
+
+
+	ConCommand cc_PossessBot( "PossessBot", PossessBot_f, "Toggle. Possess a bot.\n\tArguments: <bot client number>", FCVAR_CHEAT );
+
+
+	Vector MaybeDropToGround( 
+		CBaseEntity *pMainEnt, 
+		bool bDropToGround, 
+		const Vector &vPos, 
+		const Vector &vMins, 
+		const Vector &vMaxs )
+	{
+		if ( bDropToGround )
+		{
+			trace_t trace;
+			UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace );
+			return trace.endpos;
+		}
+		else
+		{
+			return vPos;
+		}
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: This function can be used to find a valid placement location for an entity.
+	//			Given an origin to start looking from and a minimum radius to place the entity at,
+	//			it will sweep out a circle around vOrigin and try to find a valid spot (on the ground)
+	//			where mins and maxs will fit.
+	// Input  : *pMainEnt - Entity to place
+	//			&vOrigin - Point to search around
+	//			fRadius - Radius to search within
+	//			nTries - Number of tries to attempt
+	//			&mins - mins of the Entity
+	//			&maxs - maxs of the Entity
+	//			&outPos - Return point
+	// Output : Returns true and fills in outPos if it found a spot.
+	//-----------------------------------------------------------------------------
+	bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround )
+	{
+		// This function moves the box out in each dimension in each step trying to find empty space like this:
+		//
+		//											  X  
+		//							   X			  X  
+		// Step 1:   X     Step 2:    XXX   Step 3: XXXXX
+		//							   X 			  X  
+		//											  X  
+		//
+			 
+		Vector mins, maxs;
+		pMainEnt->CollisionProp()->WorldSpaceAABB( &mins, &maxs );
+		mins -= pMainEnt->GetAbsOrigin();
+		maxs -= pMainEnt->GetAbsOrigin();
+
+		// Put some padding on their bbox.
+		float flPadSize = 5;
+		Vector vTestMins = mins - Vector( flPadSize, flPadSize, flPadSize );
+		Vector vTestMaxs = maxs + Vector( flPadSize, flPadSize, flPadSize );
+
+		// First test the starting origin.
+		if ( UTIL_IsSpaceEmpty( pMainEnt, vOrigin + vTestMins, vOrigin + vTestMaxs ) )
+		{
+			outPos = MaybeDropToGround( pMainEnt, bDropToGround, vOrigin, vTestMins, vTestMaxs );
+			return true;
+		}
+
+		Vector vDims = vTestMaxs - vTestMins;
+
+
+		// Keep branching out until we get too far.
+		int iCurIteration = 0;
+		int nMaxIterations = 15;
+		
+		int offset = 0;
+		do
+		{
+			for ( int iDim=0; iDim < 3; iDim++ )
+			{
+				float flCurOffset = offset * vDims[iDim];
+
+				for ( int iSign=0; iSign < 2; iSign++ )
+				{
+					Vector vBase = vOrigin;
+					vBase[iDim] += (iSign*2-1) * flCurOffset;
+				
+					if ( UTIL_IsSpaceEmpty( pMainEnt, vBase + vTestMins, vBase + vTestMaxs ) )
+					{
+						// Ensure that there is a clear line of sight from the spawnpoint entity to the actual spawn point.
+						// (Useful for keeping things from spawning behind walls near a spawn point)
+						trace_t tr;
+						UTIL_TraceLine( vOrigin, vBase, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &tr );
+
+						if ( tr.fraction != 1.0 )
+						{
+							continue;
+						}
+
+						outPos = MaybeDropToGround( pMainEnt, bDropToGround, vBase, vTestMins, vTestMaxs );
+						return true;
+					}
+				}
+			}
+
+			++offset;
+		} while ( iCurIteration++ < nMaxIterations );
+
+	//	Warning( "EntityPlacementTest for ent %d:%s failed!\n", pMainEnt->entindex(), pMainEnt->GetClassname() );
+		return false;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	CBaseEntity *CTeamFortress::GetPlayerSpawnSpot( CBasePlayer *pPlayer )
+	{
+		CBaseEntity *pSpawnSpot = pPlayer->EntSelectSpawnPoint();
+
+		// Make sure the spawn spot isn't blocked...
+		Vector vecTestOrg = pSpawnSpot->GetAbsOrigin();
+
+		vecTestOrg.z += pPlayer->WorldAlignSize().z * 0.5;
+		Vector origin;
+		EntityPlacementTest( pPlayer, vecTestOrg, origin, true );
+		
+		// Move the player to the place it said.
+		pPlayer->Teleport( &origin, NULL, NULL );
+
+		pPlayer->SetAbsVelocity( vec3_origin );
+		pPlayer->SetLocalAngles( pSpawnSpot->GetLocalAngles() );
+		pPlayer->m_Local.m_vecPunchAngle = vec3_angle;
+		pPlayer->SnapEyeAngles( pSpawnSpot->GetLocalAngles() );
+		
+		return pSpawnSpot;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	CTeamFortress::CTeamFortress()
+	{
+		m_bAllowWeaponSwitch = true;
+
+		// Create the team managers
+		for ( int i = 0; i < MAX_TF_TEAMS; i++ )
+		{
+			CTFTeam *pTeam = static_cast<CTFTeam*>(CreateEntityByName( "tf_team_manager" ));
+			pTeam->Init( sTeamNames[i], i );
+
+			g_Teams.AddToTail( pTeam );
+		}
+
+		// Create the hint manager
+		CBaseEntity::Create( "tf_hintmanager", vec3_origin, vec3_angle );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	CTeamFortress::~CTeamFortress()
+	{
+		// Note, don't delete each team since they are in the gEntList and will 
+		// automatically be deleted from there, instead.
+		g_Teams.Purge();
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	void CTeamFortress::UpdateClientData( CBasePlayer *player )
+	{
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Called after every level and load change
+	//-----------------------------------------------------------------------------
+	void CTeamFortress::LevelInitPostEntity()
+	{
+		g_flNextReinforcementTime = gpGlobals->curtime + REINFORCEMENT_TIME;
+		BaseClass::LevelInitPostEntity();
+	}
+
+	void CTeamFortress::CreateStandardEntities()
+	{
+		// Create the player resource
+		g_pPlayerResource = (CPlayerResource*)CBaseEntity::Create( "tf_player_manager", vec3_origin, vec3_angle );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: The gamerules think function
+	//-----------------------------------------------------------------------------
+	void CTeamFortress::Think( void )
+	{
+		BaseClass::Think();
+
+		// Check the reinforcement time
+		if ( g_flNextReinforcementTime <= gpGlobals->curtime )
+		{
+			//Msg( "Reinforcement Tick\n" );
+
+			// Reinforce any dead players
+			for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+			{
+				CBaseTFPlayer *pPlayer = ToBaseTFPlayer( UTIL_PlayerByIndex(i) );
+				if ( pPlayer )
+				{
+					// Ready to respawn?
+					if ( pPlayer->IsReadyToReinforce() )
+					{
+						pPlayer->Reinforce();
+						//pPlayer->GetTFTeam()->PostMessage( TEAMMSG_REINFORCEMENTS_ARRIVED );
+					}
+				}
+			}
+
+			g_flNextReinforcementTime += REINFORCEMENT_TIME;
+		}
+
+		// Tell each Team to think
+		for ( int i = 0; i < GetNumberOfTeams(); i++ )
+		{
+			GetGlobalTeam( i )->Think();
+		}
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Player has just left the game
+	//-----------------------------------------------------------------------------
+	void CTeamFortress::ClientDisconnected( edict_t *pClient )
+	{
+		CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)CBaseEntity::Instance( pClient );
+		if ( pPlayer )
+		{
+			// Tell all orders that this player's left
+			COrderEvent_PlayerDisconnected order( pPlayer );
+			GlobalOrderEvent( &order );
+
+			// Delete this player's playerclass
+			pPlayer->ClearPlayerClass();
+		}
+
+		BaseClass::ClientDisconnected( pClient );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: TF2 Specific Client Commands
+	// Input  :
+	// Output :
+	//-----------------------------------------------------------------------------
+	bool CTeamFortress::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
+	{
+		CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)pEdict;
+
+		const char *pcmd = args[0];
+		if ( FStrEq( pcmd, "objcmd" ) )
+		{
+			if ( args.ArgC() < 3 )
+				return true;
+
+			int entindex = atoi( args[1] );
+			edict_t* pEdict = INDEXENT(entindex);
+			if (pEdict)
+			{
+				CBaseEntity* pBaseEntity = GetContainingEntity(pEdict);
+				CBaseObject* pObject = dynamic_cast<CBaseObject*>(pBaseEntity);
+				if (pObject && pObject->InSameTeam(pPlayer))
+				{
+					// We have to be relatively close to the object too...
+
+					// FIXME: When I put in a better dismantle solution (namely send the dismantle 
+					// command along with a cancledismantle command), re-enable this.
+					// Also, need to solve the problem of control panels on large objects
+					// For the battering ram, for instance, this distance is too far.
+
+	//				float flDistSq = pObject->GetAbsOrigin().DistToSqr( pPlayer->GetAbsOrigin() );
+	//				if (flDistSq <= (MAX_OBJECT_COMMAND_DISTANCE * MAX_OBJECT_COMMAND_DISTANCE))
+					{
+						CCommand objectArgs( args.ArgC() - 2, &args.ArgV()[2]);
+						pObject->ClientCommand( pPlayer, objectArgs );
+					}
+				}
+			}
+
+			return true;
+		}
+
+		if ( FStrEq( pcmd, "buildvehicle" ) )
+		{
+			if ( args.ArgC() < 3 )
+				return true;
+
+			int entindex = atoi( args[1] );
+			int ivehicle = atoi( args[2] );
+			edict_t *pEdict = INDEXENT(entindex);
+			if (pEdict)
+			{
+				CBaseEntity *pBaseEntity = GetContainingEntity(pEdict);
+				CVGuiScreenVehicleBay *pBayScreen = dynamic_cast<CVGuiScreenVehicleBay*>(pBaseEntity);
+				if ( pBayScreen && pBayScreen->InSameTeam(pPlayer) )
+				{
+					// Need the same logic as objcmd above to ensure the player's near the vehicle bay vgui screen
+					pBayScreen->BuildVehicle( pPlayer, ivehicle );
+				}
+			}
+
+			return true;
+		}
+
+		// TF Commands
+		if ( FStrEq( pcmd, "menuselect" ) )
+		{
+			if ( pPlayer->m_pCurrentMenu == NULL )
+				return true;
+			if ( args.ArgC() < 2 )
+				return true;
+
+			int slot = atoi( args[1] );
+
+			// select the item from the current menu
+			if ( pPlayer->m_pCurrentMenu->Input( pPlayer, slot ) == false )
+			{
+				// invalid selection, force menu refresh
+				pPlayer->m_MenuUpdateTime = gpGlobals->curtime;
+				pPlayer->m_MenuRefreshTime = gpGlobals->curtime;
+			}
+			return true;
+		}
+		else if ( FStrEq( pcmd, "changeclass" ) )
+		{
+			pPlayer->m_pCurrentMenu = gMenus[MENU_CLASS];
+			pPlayer->m_MenuUpdateTime = gpGlobals->curtime;
+			pPlayer->m_MenuRefreshTime = gpGlobals->curtime;
+			return true;
+		}
+		else if ( FStrEq( pcmd, "changeteam" ) )
+		{
+			pPlayer->m_pCurrentMenu = gMenus[MENU_TEAM];
+			pPlayer->m_MenuUpdateTime = gpGlobals->curtime;
+			pPlayer->m_MenuRefreshTime = gpGlobals->curtime;
+			return true;
+		}
+		else if ( FStrEq( pcmd, "tactical" ) )
+		{
+			bool bTactical = args[1][0] == '!' ? !pPlayer->GetLocalData()->m_nInTacticalView : (atoi( args[1] ) ? true : false);
+
+			pPlayer->ShowTacticalView( bTactical );
+			return true;
+		}
+		else if ( FStrEq( pcmd, "tech" ) )
+		{
+			CTFTeam *pTFTeam = pPlayer->GetTFTeam();
+			if ( !pTFTeam )
+				return true;
+
+			if ( args.ArgC() == 2 )
+			{
+				const char *name = args[1];
+
+				CBaseTechnology *tech = pTFTeam->m_pTechnologyTree->GetTechnology( name );
+				if ( tech )
+				{
+					pTFTeam->EnableTechnology( tech );
+				}
+			}
+			else
+			{
+				Msg( "usage:  tech <name>\n" );
+			}
+			return true;	   
+		}
+		else if ( FStrEq( pcmd, "techall" ) )
+		{
+			if ( pPlayer->GetTFTeam() )
+			{
+				pPlayer->GetTFTeam()->EnableAllTechnologies();
+			}
+			return true;
+		}
+		else if ( FStrEq( pcmd, "tank" ) )
+		{
+			CBaseEntity::Create( "tank", pPlayer->WorldSpaceCenter(), pPlayer->GetLocalAngles() );
+		}
+		else if ( FStrEq( pcmd, "addres" ) || FStrEq( pcmd, "ar" ) )
+		{
+			if ( args.ArgC() == 3 )
+			{
+				int team = atoi( args[1] );
+				float flResourceAmount = atof( args[2] );
+				if ( team >= 0 && team < GetNumberOfTeams() ) 
+				{
+					GetGlobalTFTeam( team )->AddTeamResources( flResourceAmount );
+				}
+			}
+			else
+			{
+				Msg( "usage:  ar <team 1 : 2> <amount>\n" );
+			}
+			return true;
+		}
+		else if ( FStrEq( pcmd, "preftech" ) )
+		{
+			CTFTeam *pTFTeam = pPlayer->GetTFTeam();
+			if ( !pTFTeam )
+				return true;
+
+			if ( args.ArgC() == 2 )
+			{
+				int iPrefTechIndex = atoi( args[1] );
+
+				pPlayer->SetPreferredTechnology( pTFTeam->m_pTechnologyTree, iPrefTechIndex );
+				
+			}
+			return true;
+		}
+		else if( FStrEq( pcmd, "decaltest" ) )
+		{
+			trace_t trace;
+			int entityIndex;
+			Vector vForward;
+
+			AngleVectors( pEdict->GetAbsAngles(), &vForward, NULL, NULL );
+
+			UTIL_TraceLine( pEdict->GetAbsOrigin(), pEdict->GetAbsOrigin() + vForward * 10000,  MASK_SOLID_BRUSHONLY, pEdict, COLLISION_GROUP_NONE, &trace );
+
+			entityIndex = trace.GetEntityIndex();
+
+			int id = UTIL_PrecacheDecal( "decals/tscorch", true );
+			CBroadcastRecipientFilter filter;
+			te->BSPDecal( filter, 0.0, 
+				&trace.endpos, entityIndex, id );
+
+			return true; 
+		}
+		else if( FStrEq( pcmd, "killorder" ) )
+		{
+			if( pPlayer->GetTFTeam() )
+				pPlayer->GetTFTeam()->RemoveOrdersToPlayer( pPlayer );
+		
+			return true;
+		}
+		else if( BaseClass::ClientCommand( pEdict, args ) )
+		{
+			return true;
+		}
+		else
+		{
+			return pPlayer->ClientCommand( args );
+		}
+
+		return false;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Player has just spawned. Equip them.
+	//-----------------------------------------------------------------------------
+	void CTeamFortress::PlayerSpawn( CBasePlayer *pPlayer )
+	{
+		pPlayer->EquipSuit();
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	//-----------------------------------------------------------------------------
+	bool CTeamFortress::PlayFootstepSounds( CBasePlayer *pl )
+	{
+		if ( footsteps.GetInt() == 0 )
+			return false;
+
+		CBaseTFPlayer *tfPlayer = static_cast< CBaseTFPlayer * >( pl );
+		if ( tfPlayer )
+		{
+			if ( tfPlayer->IsKnockedDown() )
+			{
+				return false;
+			}
+		}
+
+		// only make step sounds in multiplayer if the player is moving fast enough
+		if ( pl->IsOnLadder() || pl->GetAbsVelocity().Length2D() > 100 )
+			return true;  
+
+		return false;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Remove falling damage for jetpacking recons
+	//-----------------------------------------------------------------------------
+	float CTeamFortress::FlPlayerFallDamage( CBasePlayer *pPlayer )
+	{
+		int iFallDamage = (int)falldamage.GetFloat();
+
+		CBaseTFPlayer *pTFPlayer = (CBaseTFPlayer *)pPlayer;
+		if ( pTFPlayer->IsClass( TFCLASS_RECON ) )
+			return 0;
+
+		switch ( iFallDamage )
+		{
+		case 1://progressive
+			pPlayer->m_Local.m_flFallVelocity -= PLAYER_MAX_SAFE_FALL_SPEED;
+			return pPlayer->m_Local.m_flFallVelocity * DAMAGE_FOR_FALL_SPEED;
+			break;
+		default:
+		case 0:// fixed
+			return 10;
+			break;
+		}
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Is the ray blocked by enemy shields?
+	//-----------------------------------------------------------------------------
+	bool CTeamFortress::IsBlockedByEnemyShields( const Vector& src, const Vector& end, int nFriendlyTeam )
+	{
+		// Iterate over all shields on the same team, disable them so
+		// we don't intersect with them...
+		CShield::ActivateShields( false, nFriendlyTeam );
+
+		bool bBlocked = CShield::IsBlockedByShields( src, end );
+
+		CShield::ActivateShields( true, nFriendlyTeam );
+
+		return bBlocked;
+	}
+
+
+	//-----------------------------------------------------------------------------
+	// Traces a line vs a shield, returns damage reduction
+	//-----------------------------------------------------------------------------
+	float CTeamFortress::WeaponTraceEntity( CBaseEntity *pEntity, 
+		const Vector &src, const Vector &end, unsigned int mask, trace_t *pTrace )
+	{
+		int damageType = pEntity->GetDamageType();
+
+		// Iterate over all shields on the same team, disable them so
+		// we don't intersect with them...
+		CShield::ActivateShields( false, pEntity->GetTeamNumber() );
+
+		// Trace it baby...
+		float damage = 1.0f;
+		bool done;
+		do 
+		{
+			// FIXME: Optimize so we don't test the same ray but start at the
+			// previous collision point
+			done = true;
+			UTIL_TraceEntity( pEntity, src, end, mask, pTrace );
+
+			// Shield check...
+			if (pTrace->fraction != 1.0)
+			{
+				CBaseEntity *pCollidedEntity = pTrace->m_pEnt;
+
+				// Did we hit a shield?
+				CShield* pShield = dynamic_cast<CShield*>(pCollidedEntity);
+				if (pShield)
+				{
+					Vector vecDir;
+					VectorSubtract( end, src, vecDir );
+
+					// Let's see if we let this damage type through...
+					if (pShield->ProtectionAmount( damageType ) == 1.0f)
+					{
+						// We deflected all of the damage
+						pShield->RegisterDeflection( vecDir, damageType, pTrace );
+						damage = 0.0f;
+					}
+					else
+					{
+						// We deflected part of the damage, but we need to trace again
+						// only this time we can't let the shield register a collision
+						damage *= 1.0f - pShield->ProtectionAmount( damageType );
+
+						// FIXME: DMG_BULLET should be something else
+						pShield->RegisterPassThru( vecDir, damageType, pTrace );
+						pShield->ActivateCollisions( false );
+
+						done = false;
+					}
+				}
+			}
+		}
+		while (!done);
+
+		// Reduce the damage dealt... but don't worry about if if the
+		// shield actually deflected it. In that case, we actually want
+		// explosive things to explode at full blast power. The shield will prevent
+		// the blast damage to things behind the shield
+		if (damage != 0.0)
+		{
+			pEntity->SetDamage(pEntity->GetDamage() * damage);
+		}
+
+		// Reactivate all shields
+		CShield::ActivateShields( true );
+		return damage;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Is trace blocked by a world or a shield?
+	//-----------------------------------------------------------------------------
+	bool CTeamFortress::IsTraceBlockedByWorldOrShield( const Vector& src, const Vector& end, CBaseEntity *pShooter, int damageType, trace_t* pTrace )
+	{
+		// Iterate over all shields on the same team, disable them so
+		// we don't intersect with them...
+		CShield::ActivateShields( false, pShooter->GetTeamNumber() );
+
+		//NDebugOverlay::Line( src, pTrace->endpos, 255,255,255, true, 5.0 );
+		//NDebugOverlay::Box( pTrace->endpos, Vector(-2,-2,-2), Vector(2,2,2), 255,255,255, true, 5.0 );
+
+		// Now make sure there isn't something other than team players in the way.
+		class CShieldWorldFilter : public CTraceFilterSimple
+		{
+		public:
+			CShieldWorldFilter( CBaseEntity *pShooter ) : CTraceFilterSimple( pShooter, TFCOLLISION_GROUP_WEAPON )
+			{
+			}
+
+			virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
+			{
+				CBaseEntity *pEnt = static_cast<CBaseEntity*>(pHandleEntity);
+
+				// Did we hit a brushmodel?
+				if ( pEnt->GetSolid() == SOLID_BSP )
+					return true;
+
+				// Ignore collisions with everything but shields
+				if ( pEnt->GetCollisionGroup() != TFCOLLISION_GROUP_SHIELD )
+					return false;
+
+				return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
+			}
+		};
+
+		trace_t tr;
+		CShieldWorldFilter shieldworldFilter( pShooter );
+		UTIL_TraceLine( src, end, MASK_SOLID, &shieldworldFilter, pTrace );
+
+		// Shield check...
+		if (pTrace->fraction != 1.0)
+		{
+			CBaseEntity *pEntity = pTrace->m_pEnt;
+			CShield* pShield = dynamic_cast<CShield*>(pEntity);
+			if (pShield)
+			{
+				Vector vecDir;
+				VectorSubtract( end, src, vecDir );
+
+				// We deflected all of the damage
+				pShield->RegisterDeflection( vecDir, damageType, pTrace );
+			}
+		}
+
+		// Reactivate all shields
+		CShield::ActivateShields( true );
+		return ( pTrace->fraction < 1.0 );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Default implementation of radius damage
+	//-----------------------------------------------------------------------------
+	void CTeamFortress::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore )
+	{
+		CBaseEntity *pEntity = NULL;
+		trace_t		tr;
+		float		flAdjustedDamage, falloff;
+		Vector		vecSpot;
+		Vector vecSrc = vecSrcIn;
+
+		if ( flRadius )
+			falloff = info.GetDamage() / flRadius;
+		else
+			falloff = 1.0;
+
+		int bInWater = (UTIL_PointContents ( vecSrc ) & MASK_WATER) ? true : false;
+
+		// in case grenade is lying on the ground
+		// Is this even needed anymore? Grenades already jump up in their explode code...
+		vecSrc.z += 1;
+
+		// iterate on all entities in the vicinity.
+		for ( CEntitySphereQuery sphere( vecSrc, flRadius ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
+		{
+			if ( pEntity->m_takedamage != DAMAGE_NO )
+			{
+				// UNDONE: this should check a damage mask, not an ignore
+				if ( iClassIgnore != CLASS_NONE && pEntity->Classify() == iClassIgnore )
+					continue;
+
+				// blast's don't tavel into or out of water
+				if (bInWater && pEntity->GetWaterLevel() == 0)
+					continue;
+				if (!bInWater && pEntity->GetWaterLevel() == 3)
+					continue;
+
+				// Copy initial values out of the info
+				CTakeDamageInfo subInfo = info;
+				if ( !subInfo.GetAttacker() )
+				{
+					subInfo.SetAttacker( subInfo.GetInflictor() );
+				}
+
+				// Don't bother with hitboxes on this test
+				vecSpot = pEntity->WorldSpaceCenter( );
+				WeaponTraceLine ( vecSrc, vecSpot, MASK_SHOT & (~CONTENTS_HITBOX), subInfo.GetInflictor(), subInfo.GetDamageType(), &tr );
+				if ( tr.fraction != 1.0 && tr.m_pEnt != pEntity )
+					continue;
+
+				// We're going to need to see if it actually hit a shield
+				// the explosion can 'see' this entity, so hurt them!
+				if (tr.startsolid)
+				{
+					// if we're stuck inside them, fixup the position and distance
+					tr.endpos = vecSrc;
+					tr.fraction = 0.0;
+				}
+				
+				// decrease damage for an ent that's farther from the bomb.
+				flAdjustedDamage = ( vecSrc - tr.endpos ).Length() * falloff;
+				flAdjustedDamage = subInfo.GetDamage() - flAdjustedDamage;
+				if ( flAdjustedDamage > 0 )
+				{
+					// Knockdown
+					// For now, just use damage. Eventually we should do it on a per-weapon basis.
+					/*
+					if ( pEntity->IsPlayer() && flAdjustedDamage > 40 )
+					{
+						Vector vecForce = vecSpot - vecSrc;
+						// Reduce the Z component and increase the X,Y
+						vecForce.x *= 3.0;
+						vecForce.y *= 3.0;
+						vecForce.z *= 0.5;
+						VectorNormalize( vecForce );
+						((CBaseTFPlayer*)pEntity)->KnockDownPlayer( vecForce, flAdjustedDamage * 15.0f, tf_knockdowntime.GetFloat() );
+					}
+					*/
+					
+					// Msg( "hit %s\n", pEntity->GetClassname() );
+					subInfo.SetDamage( flAdjustedDamage );
+
+					Vector dir = tr.endpos - vecSrc;
+					if ( VectorNormalize( dir ) == 0 )
+					{
+						dir = vecSpot - vecSrc;
+						VectorNormalize( dir );
+					}
+
+					// If we don't have a damage force, manufacture one
+					if ( subInfo.GetDamagePosition() == vec3_origin || subInfo.GetDamageForce() == vec3_origin )
+					{
+						CalculateExplosiveDamageForce( &subInfo, dir, vecSrc );
+					}
+
+					if (tr.fraction != 1.0)
+					{
+						ClearMultiDamage( );
+
+						pEntity->DispatchTraceAttack( subInfo, dir, &tr );
+						ApplyMultiDamage();
+					}
+					else
+					{
+						pEntity->TakeDamage( subInfo );
+					}
+				}
+			}
+		}
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Find out if this player had an assistant when he killed an enemy
+	//-----------------------------------------------------------------------------
+	CBasePlayer *CTeamFortress::GetDeathAssistant( CBaseEntity *pKiller, CBaseEntity *pInflictor )
+	{
+		if ( !pKiller || pKiller->Classify() != CLASS_PLAYER )
+			return NULL;
+
+		CBaseTFPlayer *pAssistant = NULL;
+
+		// Killing entity might be specifying a scorer player
+		IScorer *pScorerInterface = dynamic_cast<IScorer*>( pKiller );
+		if ( pScorerInterface )
+		{
+			pAssistant = (CBaseTFPlayer*)pScorerInterface->GetAssistant();
+		}
+
+		// Inflicting entity might be specifying a scoring player
+		if ( !pAssistant )
+		{
+			pScorerInterface = dynamic_cast<IScorer*>( pInflictor );
+			if ( pScorerInterface )
+			{
+				pAssistant = (CBaseTFPlayer*)pScorerInterface->GetAssistant();
+			}
+		}
+
+		// Don't allow self assistance
+		Assert( pAssistant != pKiller );
+		return pAssistant;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : *pVictim - 
+	//			*pKiller - 
+	//			*pInflictor - 
+	//-----------------------------------------------------------------------------
+	void CTeamFortress::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
+	{
+		// Work out what killed the player, and send a message to all clients about it
+		const char *killer_weapon_name = "world";		// by default, the player is killed by the world
+		int killer_index = 0;
+		int assist_index = 0;
+
+		// Find the killer & the scorer
+		CBaseEntity *pInflictor = info.GetInflictor();
+		CBaseEntity *pKiller = info.GetAttacker();
+		CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor );
+		CBasePlayer *pAssistant = GetDeathAssistant( pKiller, pInflictor );
+
+		if ( pAssistant )
+		{
+			assist_index = pAssistant->entindex();
+		}
+
+		// Custom kill type?
+		if ( info.GetDamageCustom() )
+		{
+			killer_weapon_name = GetDamageCustomString( info );
+			if ( pScorer )
+			{
+				killer_index = pScorer->entindex();
+			}
+		}
+		else
+		{
+			// Is the killer a client?
+			if ( pScorer )
+			{
+				killer_index = pScorer->entindex();
+				
+				if ( pInflictor )
+				{
+					if ( pInflictor == pScorer )
+					{
+						// If the inflictor is the killer,  then it must be their current weapon doing the damage
+						if ( pScorer->GetActiveWeapon() )
+						{
+							killer_weapon_name = pScorer->GetActiveWeapon()->GetDeathNoticeName();
+						}
+					}
+					else
+					{
+						killer_weapon_name = STRING( pInflictor->m_iClassname );  // it's just that easy
+					}
+				}
+			}
+			else
+			{
+				killer_weapon_name = STRING( pInflictor->m_iClassname );
+			}
+
+			// strip the NPC_* or weapon_* from the inflictor's classname
+			if ( strncmp( killer_weapon_name, "weapon_", 7 ) == 0 )
+			{
+				killer_weapon_name += 7;
+			}
+			else if ( strncmp( killer_weapon_name, "NPC_", 8 ) == 0 )
+			{
+				killer_weapon_name += 8;
+			}
+			else if ( strncmp( killer_weapon_name, "func_", 5 ) == 0 )
+			{
+				killer_weapon_name += 5;
+			}
+		}
+
+/*		CReliableBroadcastRecipientFilter filter;
+		UserMessageBegin( filter, "DeathMsg" );
+			WRITE_BYTE( killer_index );						// the killer
+			WRITE_BYTE( assist_index );						// the assistant, if any
+			WRITE_BYTE( ENTINDEX(pVictim->edict()) );		// the victim
+			WRITE_STRING( killer_weapon_name );		// what they were killed by (should this be a string?)
+		MessageEnd();
+
+		// Did he kill himself?
+		if ( pVictim == pScorer )  
+		{  
+			UTIL_LogPrintf( "\"%s<%i>\" killed self with %s\n",  pVictim->GetPlayerName(), engine->GetPlayerUserId( pVictim->edict() ), killer_weapon_name );
+		}
+		else if ( pScorer )
+		{
+			UTIL_LogPrintf( "\"%s<%i>\" killed \"%s<%i>\" with %s\n",  pScorer->GetPlayerName() ),
+				engine->GetPlayerUserId( pScorer->edict() ),
+				pVictim->GetPlayerName(),
+				engine->GetPlayerUserId( pVictim->edict() ),
+				killer_weapon_name );
+		}
+		else
+		{  
+			// killed by the world
+			UTIL_LogPrintf( "\"%s<%i>\" killed by world with %s\n",  pVictim->GetPlayerName(), engine->GetPlayerUserId( pVictim->edict() ), killer_weapon_name );
+		} */
+
+		KeyValues * event = new KeyValues( "player_death" );
+		event->SetInt("killer", pScorer ? pScorer->GetUserID() : 0 );
+		event->SetInt("victim", pVictim->GetUserID() );
+		event->SetString("weapon", killer_weapon_name );
+
+		gameeventmanager->FireEvent( event );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Custom kill types for TF
+	//-----------------------------------------------------------------------------
+	const char *CTeamFortress::GetDamageCustomString( const CTakeDamageInfo &info )
+	{
+		switch( info.GetDamageCustom() )
+		{
+		case DMG_KILL_BULLRUSH:
+				return "bullrush";
+				break;
+		default:
+			break;
+		};
+
+		return "INVALID CUSTOM KILL TYPE";
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : *pListener - 
+	//			*pSpeaker - 
+	// Output : Returns true on success, false on failure.
+	//-----------------------------------------------------------------------------
+	bool CTeamFortress::PlayerCanHearChat( CBasePlayer *pListener, CBasePlayer *pSpeaker )
+	{
+		if ( BaseClass::PlayerCanHearChat( pListener, pSpeaker ) )
+		{
+			return true;
+		}
+
+		CBaseTFPlayer *listener = static_cast< CBaseTFPlayer * >( pListener );
+		CBaseTFPlayer *speaker = static_cast< CBaseTFPlayer * >( pSpeaker );
+
+		if ( listener && speaker )
+		{
+			if ( listener->IsClass( TFCLASS_INFILTRATOR ) )
+			{
+				Vector delta;
+				delta = listener->EarPosition() - speaker->GetAbsOrigin();
+				if ( delta.Length() < INFILTRATOR_EAVESDROP_RADIUS )
+				{
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+
+	void CTeamFortress::InitDefaultAIRelationships( void )
+	{
+		//  Allocate memory for default relationships
+		CBaseCombatCharacter::AllocateDefaultRelationships();
+
+		// --------------------------------------------------------------
+		// First initialize table so we can report missing relationships
+		// --------------------------------------------------------------
+		int i, j;
+		for (i=0;i<NUM_AI_CLASSES;i++)
+		{
+			for (j=0;j<NUM_AI_CLASSES;j++)
+			{
+				// By default all relationships are neutral of priority zero
+				CBaseCombatCharacter::SetDefaultRelationship( (Class_T)i, (Class_T)j, D_NU, 0 );
+			}
+		}
+
+		// ------------------------------------------------------------
+		//	> CLASS_ANTLION
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_PLAYER,			D_HT, 5);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_BARNACLE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_CITIZEN_PASSIVE,	D_HT, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_COMBINE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_MANHACK,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_METROPOLICE,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_MILITARY,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_SCANNER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_STALKER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_PROTOSNIPER,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_ANTLION,			D_LI, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ANTLION,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_BARNACLE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_BARNACLE,			D_LI, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_CITIZEN_PASSIVE,	D_HT, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_COMBINE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_MANHACK,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_METROPOLICE,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_MILITARY,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_STALKER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BARNACLE,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_BULLSEYE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_ANTLION,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_CITIZEN_REBEL,	D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_CONSCRIPT,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_HEADCRAB,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_VORTIGAUNT,		D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_ZOMBIE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_BULLSEYE,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_CITIZEN_PASSIVE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_BARNACLE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_CITIZEN_REBEL,	D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_CONSCRIPT,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_HEADCRAB,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_MANHACK,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_MISSILE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_VORTIGAUNT,		D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_ZOMBIE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_PASSIVE,	CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_CITIZEN_REBEL
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_BARNACLE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_CITIZEN_REBEL,	D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_COMBINE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_CONSCRIPT,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_MANHACK,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_METROPOLICE,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_MILITARY,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_MISSILE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_SCANNER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_STALKER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_VORTIGAUNT,		D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_ZOMBIE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CITIZEN_REBEL,		CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_COMBINE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_BARNACLE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_MISSILE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_COMBINE,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_CONSCRIPT
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_BARNACLE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_CITIZEN_REBEL,	D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_COMBINE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_CONSCRIPT,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_MANHACK,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_METROPOLICE,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_MILITARY,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_SCANNER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_STALKER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_VORTIGAUNT,		D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_CONSCRIPT,			CLASS_EARTH_FAUNA,		D_NU, 0);
+		
+		// ------------------------------------------------------------
+		//	> CLASS_FLARE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_ANTLION,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_CITIZEN_REBEL,	D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_CONSCRIPT,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_HEADCRAB,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_VORTIGAUNT,		D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_ZOMBIE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_FLARE,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_HEADCRAB
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_CITIZEN_PASSIVE,	D_HT, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_COMBINE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_HEADCRAB,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_METROPOLICE,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_ZOMBIE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_HEADCRAB,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+
+		// ------------------------------------------------------------
+		//	> CLASS_MANHACK
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_CITIZEN_PASSIVE,	D_HT, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_HEADCRAB,			D_HT,-1);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MANHACK,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_METROPOLICE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_METROPOLICE,		CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_MILITARY
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MILITARY,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_MISSILE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_MISSILE,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_NONE
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_ANTLION,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_BULLSEYE,			D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_CITIZEN_REBEL,	D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_CONSCRIPT,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_HEADCRAB,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_VORTIGAUNT,		D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_ZOMBIE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_NONE,				CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_PLAYER
+		// ------------------------------------------------------------
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_BARNACLE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_BULLSEYE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_CITIZEN_REBEL,	D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_COMBINE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_CONSCRIPT,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_MANHACK,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_METROPOLICE,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_MILITARY,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_SCANNER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_STALKER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_VORTIGAUNT,		D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_PROTOSNIPER,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PLAYER,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_SCANNER
+		// ------------------------------------------------------------	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_HEADCRAB,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_ZOMBIE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_SCANNER,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_STALKER
+		// ------------------------------------------------------------	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_HEADCRAB,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_ZOMBIE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_STALKER,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_VORTIGAUNT
+		// ------------------------------------------------------------	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_PLAYER,			D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_BARNACLE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_CITIZEN_PASSIVE,	D_NU, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_CITIZEN_REBEL,	D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_COMBINE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_CONSCRIPT,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_HEADCRAB,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_MANHACK,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_METROPOLICE,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_MILITARY,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_SCANNER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_STALKER,			D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_VORTIGAUNT,		D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_VORTIGAUNT,		CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_ZOMBIE
+		// ------------------------------------------------------------	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_CITIZEN_PASSIVE,	D_HT, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_COMBINE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_HEADCRAB,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_MANHACK,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_METROPOLICE,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_MILITARY,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_MISSILE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_ZOMBIE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_ZOMBIE,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_PROTOSNIPER
+		// ------------------------------------------------------------	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_NONE,				D_NU, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_PLAYER,			D_HT, 0);			
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_ANTLION,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_BULLSEYE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_CITIZEN_PASSIVE,	D_HT, 0);	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_CITIZEN_REBEL,	D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_COMBINE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_CONSCRIPT,		D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_FLARE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_HEADCRAB,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_MANHACK,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_METROPOLICE,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_MILITARY,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_MISSILE,			D_NU, 5);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_SCANNER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_STALKER,			D_NU, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_VORTIGAUNT,		D_HT, 0);		
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_ZOMBIE,			D_HT, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_PROTOSNIPER,			CLASS_EARTH_FAUNA,		D_NU, 0);
+
+		// ------------------------------------------------------------
+		//	> CLASS_EARTH_FAUNA
+		//
+		// Fears pretty much everything except other earth fauna:
+		// 
+		// 5. Fears flares and missiles most of all.
+		// 4. Fears flying machines next.
+		// 3. Fears aliens next.
+		// 2. Fears combine human military next.
+		// 1. Fears humans next.
+		// 0. Fears the player the least.
+		//
+		// ------------------------------------------------------------	
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_NONE,				D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_PLAYER,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_ANTLION,			D_FR, 2);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_BARNACLE,			D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_BULLSEYE,			D_FR, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_CITIZEN_PASSIVE,	D_FR, 1);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_CITIZEN_REBEL,	D_FR, 1);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_COMBINE,			D_FR, 3);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_CONSCRIPT,		D_FR, 1);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_FLARE,			D_FR, 5);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_HEADCRAB,			D_FR, 2);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_MANHACK,			D_FR, 4);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_METROPOLICE,		D_FR, 1);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_MILITARY,			D_FR, 1);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_MISSILE,			D_FR, 5);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_SCANNER,			D_FR, 4);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_STALKER,			D_FR, 2);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_VORTIGAUNT,		D_FR, 2);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_ZOMBIE,			D_FR, 1);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_PROTOSNIPER,		D_NU, 0);
+		CBaseCombatCharacter::SetDefaultRelationship(CLASS_EARTH_FAUNA,			CLASS_EARTH_FAUNA,		D_LI, 0);
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Return a pointer to the opposing team
+	//-----------------------------------------------------------------------------
+	CTFTeam *GetOpposingTeam( CTeam *pTeam )
+	{
+		// Hacky!
+		if ( pTeam->GetTeamNumber() == 1 )
+			return GetGlobalTFTeam( 2 );
+
+		return GetGlobalTFTeam( 1 );
+	}
+
+
+	//------------------------------------------------------------------------------
+	// Purpose : Return classify text for classify type
+	//------------------------------------------------------------------------------
+	const char *CTeamFortress::AIClassText(int classType)
+	{
+		switch (classType)
+		{
+			case CLASS_NONE:			return "CLASS_NONE";
+			case CLASS_PLAYER:			return "CLASS_PLAYER";
+			case CLASS_ANTLION:			return "CLASS_ANTLION";
+			case CLASS_BARNACLE:		return "CLASS_BARNACLE";
+			case CLASS_BULLSEYE:		return "CLASS_BULLSEYE";
+			case CLASS_CITIZEN_PASSIVE: return "CLASS_CITIZEN_PASSIVE";		
+			case CLASS_CITIZEN_REBEL:	return "CLASS_CITIZEN_REBEL";
+			case CLASS_COMBINE:			return "CLASS_COMBINE";
+			case CLASS_CONSCRIPT:		return "CLASS_CONSCRIPT";
+			case CLASS_HEADCRAB:		return "CLASS_HEADCRAB";
+			case CLASS_MANHACK:			return "CLASS_MANHACK";
+			case CLASS_METROPOLICE:		return "CLASS_METROPOLICE";
+			case CLASS_MILITARY:		return "CLASS_MILITARY";	
+			case CLASS_SCANNER:			return "CLASS_SCANNER";		
+			case CLASS_STALKER:			return "CLASS_STALKER";		
+			case CLASS_VORTIGAUNT:		return "CLASS_VORTIGAUNT";
+			case CLASS_ZOMBIE:			return "CLASS_ZOMBIE";
+			case CLASS_PROTOSNIPER:		return "CLASS_PROTOSNIPER";
+			case CLASS_MISSILE:			return "CLASS_MISSILE";
+			case CLASS_FLARE:			return "CLASS_FLARE";
+			case CLASS_EARTH_FAUNA:		return "CLASS_EARTH_FAUNA";
+
+			default:					return "MISSING CLASS in ClassifyText()";
+		}
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: When gaining new technologies in TF, prevent auto switching if we
+	//  receive a weapon during the switch
+	// Input  : *pPlayer - 
+	//			*pWeapon - 
+	// Output : Returns true on success, false on failure.
+	//-----------------------------------------------------------------------------
+	bool CTeamFortress::FShouldSwitchWeapon( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon )
+	{
+		if ( !GetAllowWeaponSwitch() )
+			return false;
+
+		// Never auto switch to object placement
+		if ( dynamic_cast<CWeaponBuilder*>(pWeapon) ) 
+			return false;
+		if ( dynamic_cast<CWeaponObjectSelection*>(pWeapon) ) 
+			return false;
+
+		return BaseClass::FShouldSwitchWeapon( pPlayer, pWeapon );
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : allow - 
+	//-----------------------------------------------------------------------------
+	void CTeamFortress::SetAllowWeaponSwitch( bool allow )
+	{
+		m_bAllowWeaponSwitch = allow;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Output : Returns true on success, false on failure.
+	//-----------------------------------------------------------------------------
+	bool CTeamFortress::GetAllowWeaponSwitch( void )
+	{
+		return m_bAllowWeaponSwitch;
+	}
+
+	//-----------------------------------------------------------------------------
+	// Purpose: 
+	// Input  : *pPlayer - 
+	// Output : const char
+	//-----------------------------------------------------------------------------
+	const char *CTeamFortress::SetDefaultPlayerTeam( CBasePlayer *pPlayer )
+	{
+		Assert( pPlayer );
+		// int clientIndex = pPlayer->entindex();
+		// engine->SetClientKeyValue( clientIndex, engine->GetInfoKeyBuffer( pPlayer->edict() ), "model", "" );
+		return BaseClass::SetDefaultPlayerTeam( pPlayer );
+	}
+
+	// Called when game rules are destroyed by CWorld
+	void CTeamFortress::LevelShutdown( void )
+	{
+		g_flNextReinforcementTime = 0.0f;
+
+		g_hCurrentAct = NULL;
+
+		BaseClass::LevelShutdown();
+	}
+
+	void InitBodyQue(void)
+	{
+		// FIXME: Make this work
+	}
+
+#endif
+
+
+// ----------------------------------------------------------------------------- //
+// Shared CTeamFortress code.
+// ----------------------------------------------------------------------------- //
+
+//-----------------------------------------------------------------------------
+// Purpose: Send the appropriate weapon impact
+//-----------------------------------------------------------------------------
+void WeaponImpact( trace_t *tr, Vector vecDir, bool bHurt, CBaseEntity *pEntity, int iDamageType )
+{
+	// If we hit a combat shield, play the hit effect
+	if ( iDamageType & (DMG_PLASMA | DMG_ENERGYBEAM) )
+	{
+		if ( bHurt )
+		{
+			Assert( pEntity );
+			bool bHitHandheldShield = (pEntity->IsPlayer() && ((CBaseTFPlayer*)pEntity)->IsHittingShield( vecDir, NULL ));
+			if ( bHitHandheldShield )
+			{
+				UTIL_ImpactTrace( tr, iDamageType, "PlasmaShield" );
+			}
+			else
+			{
+				// Client waits for server version 
+#ifndef CLIENT_DLL
+				// Make sure the server sends to us, even though we're predicting
+				CDisablePredictionFiltering dpf;
+				UTIL_ImpactTrace( tr, iDamageType, "PlasmaHurt" );
+#endif
+			}
+		}
+		else
+		{
+			UTIL_ImpactTrace( tr, iDamageType, "PlasmaUnhurt" );
+		}
+	}
+	else
+	{
+		if ( bHurt )
+		{
+			Assert( pEntity );
+			bool bHitHandheldShield = (pEntity->IsPlayer() && ((CBaseTFPlayer*)pEntity)->IsHittingShield( vecDir, NULL ));
+			if ( bHitHandheldShield )
+			{
+				UTIL_ImpactTrace( tr, iDamageType, "ImpactShield" );
+			}
+			else
+			{
+				// Client waits for server version 
+#ifndef CLIENT_DLL
+				// Make sure the server sends to us, even though we're predicting
+				CDisablePredictionFiltering dpf;
+				UTIL_ImpactTrace( tr, iDamageType, "Impact" );
+#endif
+			}
+		}
+		else
+		{
+			UTIL_ImpactTrace( tr, iDamageType, "ImpactUnhurt" );
+		}
+	}
+}
+
+
+static bool CheckCollisionGroupPlayerMovement( int collisionGroup0, int collisionGroup1 )
+{
+ 	if ( collisionGroup0 == COLLISION_GROUP_PLAYER )
+	{
+		// Players don't collide with objects or other players
+		if ( collisionGroup1 == COLLISION_GROUP_PLAYER || collisionGroup1 == TFCOLLISION_GROUP_OBJECT )
+			return false;
+ 	}
+
+
+	if ( collisionGroup1 == COLLISION_GROUP_PLAYER_MOVEMENT )
+	{
+		// This is only for probing, so it better not be on both sides!!!
+		Assert( collisionGroup0 != COLLISION_GROUP_PLAYER_MOVEMENT );
+
+		// No collide with players any more
+		// Nor with objects or grenades
+		switch ( collisionGroup0 )
+		{
+		default:
+			break;
+		case COLLISION_GROUP_PLAYER:
+			return false;
+		case TFCOLLISION_GROUP_OBJECT_SOLIDTOPLAYERMOVEMENT:
+			// Certain objects are still solid to player movement
+			return true;
+		case TFCOLLISION_GROUP_COMBATOBJECT:
+		case TFCOLLISION_GROUP_OBJECT:
+			return false;
+		case TFCOLLISION_GROUP_GRENADE:
+		case COLLISION_GROUP_DEBRIS:
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+void CTeamFortress::WeaponTraceLine( const Vector& src, const Vector& end, unsigned int mask, CBaseEntity *pShooter, int damageType, trace_t* pTrace )
+{
+	// Iterate over all shields on the same team, disable them so
+	// we don't intersect with them...
+	CShield::ActivateShields( false, pShooter->GetTeamNumber() );
+
+	UTIL_TraceLine(src, end, mask, pShooter, TFCOLLISION_GROUP_WEAPON, pTrace);
+
+//	NDebugOverlay::Line( src, pTrace->endpos, 255,255,255, true, 5.0 );
+//	NDebugOverlay::Box( pTrace->endpos, Vector(-2,-2,-2), Vector(2,2,2), 255,255,255, true, 5.0 );
+
+	// Shield check...
+	if (pTrace->fraction != 1.0)
+	{
+		CBaseEntity *pEntity = pTrace->m_pEnt;
+		CShield* pShield = dynamic_cast<CShield*>(pEntity);
+		if (pShield)
+		{
+			Vector vecDir;
+			VectorSubtract( end, src, vecDir );
+
+			// We deflected all of the damage
+			pShield->RegisterDeflection( vecDir, damageType, pTrace );
+		}
+	}
+
+	// Reactivate all shields
+	CShield::ActivateShields( true );
+}
+
+
+bool CTeamFortress::ShouldCollide( int collisionGroup0, int collisionGroup1 )
+{
+	if ( collisionGroup0 > collisionGroup1 )
+	{
+		// swap so that lowest is always first
+		swap(collisionGroup0,collisionGroup1);
+	}
+
+	// Ignore base class HL2 definition for COLLISION_GROUP_WEAPON, change to COLLISION_GROUP_NONE
+	if ( collisionGroup0 == COLLISION_GROUP_WEAPON )
+	{
+		collisionGroup0 = COLLISION_GROUP_NONE;
+	}
+	if ( collisionGroup1 == COLLISION_GROUP_WEAPON )
+	{
+		collisionGroup1 = COLLISION_GROUP_NONE;
+	}
+
+	// Shields collide with weapons + grenades only
+	if ( collisionGroup0 == TFCOLLISION_GROUP_SHIELD )
+	{
+		return ((collisionGroup1 == TFCOLLISION_GROUP_WEAPON) || (collisionGroup1 == TFCOLLISION_GROUP_GRENADE));
+	}
+
+	// Weapons can collide with things (players) in vehicles.
+	if( collisionGroup0 == COLLISION_GROUP_IN_VEHICLE && collisionGroup1 == TFCOLLISION_GROUP_WEAPON )
+	{
+		return true;
+	}
+
+	// COLLISION TEST:
+	// Players don't collide with other players or objects
+	if ( !CheckCollisionGroupPlayerMovement( collisionGroup0, collisionGroup1 ) )
+		return false;
+	// Reciprocal test
+	if ( !CheckCollisionGroupPlayerMovement( collisionGroup1, collisionGroup0 ) )
+		return false;
+
+	// Grenades don't collide with debris
+	if ( collisionGroup1 == TFCOLLISION_GROUP_GRENADE )
+	{
+		if ( collisionGroup0 == COLLISION_GROUP_DEBRIS )
+			return false;
+	}
+
+	// Combat objects don't collide with players
+	if ( collisionGroup1 == TFCOLLISION_GROUP_COMBATOBJECT )
+	{
+		if ( collisionGroup0 == COLLISION_GROUP_PLAYER )
+			return false;
+	}
+
+	// Resource chunks don't collide with each other or vehicles
+	if ( collisionGroup1 == TFCOLLISION_GROUP_RESOURCE_CHUNK )
+	{	
+		if ( collisionGroup0 == TFCOLLISION_GROUP_RESOURCE_CHUNK )
+			return false;
+//		if ( collisionGroup0 == COLLISION_GROUP_VEHICLE )
+//			return false;
+	}
+
+	return BaseClass::ShouldCollide( collisionGroup0, collisionGroup1 ); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fire a generic bullet
+//-----------------------------------------------------------------------------
+void CTeamFortress::FireBullets( const CTakeDamageInfo &info, int cShots, const Vector &vecSrc, const Vector &vecDirShooting, 
+								const Vector &vecSpread, float flDistance, int iAmmoType, 
+								int iTracerFreq, int firingEntID, int attachmentID, const char *sCustomTracer )
+{
+	static int tracerCount;
+	bool tracer;
+	trace_t	tr;
+	CTakeDamageInfo subInfo = info;
+	CBaseTFCombatWeapon *pWeapon = dynamic_cast<CBaseTFCombatWeapon*>(info.GetInflictor());
+
+	Assert( subInfo.GetInflictor() );
+
+	// Default attacker is the inflictor
+	if ( subInfo.GetAttacker() == NULL )
+	{
+		subInfo.SetAttacker( subInfo.GetInflictor() );
+	}
+
+	// --------------------------------------------------
+	//  Get direction vectors for spread
+	// --------------------------------------------------
+	Vector vecUp = Vector(0,0,1);
+	Vector vecRight;
+	CrossProduct ( vecDirShooting,  vecUp,		vecRight );	
+	CrossProduct ( vecDirShooting, -vecRight,   vecUp  );	
+
+#ifndef CLIENT_DLL
+	ClearMultiDamage();
+#endif
+
+	int seed = 0;
+
+	for (int iShot = 0; iShot < cShots; iShot++)
+	{
+		// get circular gaussian spread
+		float x, y, z;
+
+		do 
+		{
+			float x1, x2, y1, y2;
+
+			// Note the additional seed because otherwise we get the same set of random #'s and will get stuck
+			//  in an infinite loop here potentially
+			// FIXME:  Can we use a gaussian random # function instead?  ywb
+			if ( CBaseEntity::GetPredictionRandomSeed() != -1 )
+			{
+				x1 = SHARED_RANDOMFLOAT_SEED( -0.5, 0.5, ++seed );
+				x2 = SHARED_RANDOMFLOAT_SEED( -0.5, 0.5, ++seed );
+				y1 = SHARED_RANDOMFLOAT_SEED( -0.5, 0.5, ++seed );
+				y2 = SHARED_RANDOMFLOAT_SEED( -0.5, 0.5, ++seed );
+			}
+			else
+			{
+				x1 = RandomFloat( -0.5, 0.5 );
+				x2 = RandomFloat( -0.5, 0.5 );
+				y1 = RandomFloat( -0.5, 0.5 );
+				y2 = RandomFloat( -0.5, 0.5 );
+			}
+
+			x = x1 + x2;
+			y = y1 + y2;
+
+			z = x*x+y*y;
+		} while (z > 1);
+
+		Vector vecDir = vecDirShooting + x * vecSpread.x * vecRight + y * vecSpread.y * vecUp;
+		Vector vecEnd = vecSrc + vecDir * flDistance;
+
+		// Try the trace
+		WeaponTraceLine( vecSrc, vecEnd, MASK_SHOT, subInfo.GetInflictor(), subInfo.GetDamageType(), &tr );
+
+		tracer = false;
+		if (iTracerFreq != 0 && (tracerCount++ % iTracerFreq) == 0)
+		{
+			Vector vecTracerSrc;
+
+			// adjust tracer position for player
+			if ( subInfo.GetInflictor()->IsPlayer() )
+			{
+				Vector forward, right;
+				CBasePlayer *pPlayer = ToBasePlayer( subInfo.GetInflictor() );
+				pPlayer->EyeVectors( &forward, &right, NULL );
+				vecTracerSrc = vecSrc + Vector ( 0 , 0 , -4 ) + right * 2 + forward * 16;
+			}
+			else
+			{
+				vecTracerSrc = vecSrc;
+			}
+			
+			if ( iTracerFreq != 1 )		// guns that always trace also always decal
+				tracer = true;
+
+			if ( sCustomTracer )
+			{
+				UTIL_Tracer( vecTracerSrc, tr.endpos, subInfo.GetInflictor()->entindex(), TRACER_DONT_USE_ATTACHMENT, 0, false, (char*)sCustomTracer );
+			}
+			else
+			{
+				UTIL_Tracer( vecTracerSrc, tr.endpos, subInfo.GetInflictor()->entindex() );
+			}
+		}
+
+		// do damage, paint decals
+		if ( tr.fraction != 1.0 )
+		{
+			CBaseEntity *pEntity = tr.m_pEnt;
+
+			// NOTE: If we want to know more than whether or not the entity can actually be hurt
+			//		 for the purposes of impact effects, the client needs to know a lot more.
+			bool bTargetCouldBeHurt = false;
+			if ( pEntity->m_takedamage )
+			{
+				if ( !pEntity->InSameTeam( subInfo.GetInflictor() ) )
+				{
+					bTargetCouldBeHurt = true;
+				}
+#ifndef CLIENT_DLL
+				subInfo.SetDamagePosition( vecSrc );
+				// Hit the target 
+				pEntity->DispatchTraceAttack( subInfo, vecDir, &tr ); 
+#endif
+			}
+ 
+			// No decal if we hit a shield
+			if ( pEntity->GetCollisionGroup() != TFCOLLISION_GROUP_SHIELD )
+			{
+				WeaponImpact( &tr, vecDir, bTargetCouldBeHurt, pEntity, subInfo.GetDamageType() );
+			}
+		}
+
+		if ( pWeapon )
+		{
+			pWeapon->BulletWasFired( vecSrc, tr.endpos );
+		}
+	}
+
+	// Apply any damage we've stacked up
+#ifndef CLIENT_DLL
+	ApplyMultiDamage();
+#endif
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Init TF2 ammo definitions
+//-----------------------------------------------------------------------------
+CAmmoDef *GetAmmoDef()
+{
+	static CAmmoDef def;
+	static bool bInitted = false;
+
+	if ( !bInitted )
+	{
+		bInitted = true;
+		
+		def.AddAmmoType("Bullets",			DMG_BULLET,	TRACER_LINE, 0,	0, INFINITE_AMMO, 0, 0);
+		def.AddAmmoType("Rockets",			DMG_BLAST,	TRACER_LINE, 0,	0, 6, 0, 0);
+		def.AddAmmoType("Grenades",			DMG_BLAST,	TRACER_LINE, 0,	0, 3, 0, 0);
+		def.AddAmmoType("ShieldGrenades",		DMG_ENERGYBEAM,	TRACER_LINE, 0,	0, 5, 0, 0);
+		def.AddAmmoType("ShotgunEnergy",		DMG_ENERGYBEAM,	TRACER_LINE, 0,	0, INFINITE_AMMO, 0, 0);
+		def.AddAmmoType("PlasmaGrenade",		DMG_ENERGYBEAM|DMG_BLAST, TRACER_LINE, 0, 0, 30, 0, 0);
+		def.AddAmmoType("ResourceChunks",		DMG_GENERIC,TRACER_LINE, 0,	0, 4, 0, 0);		// Resource chunks
+		def.AddAmmoType("Limpets",			DMG_BLAST,	TRACER_LINE, 0,	0, 40, 0, 0);
+		def.AddAmmoType("Gasoline",			DMG_BURN,	TRACER_LINE, 0,	0, 80, 0, 0);
+
+		// Combat Objects
+		def.AddAmmoType("RallyFlags",			DMG_GENERIC, TRACER_NONE, 0, 0,	1, 0, 0);
+		def.AddAmmoType("EMPGenerators",		DMG_GENERIC, TRACER_NONE, 0, 0,	1, 0, 0);
+	}
+
+	return &def;
+}
diff --git a/game/shared/tf2/tf_gamerules.h b/game/shared/tf2/tf_gamerules.h
new file mode 100644
index 0000000..9c4ce4f
--- /dev/null
+++ b/game/shared/tf2/tf_gamerules.h
@@ -0,0 +1,142 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: The TF Game rules object
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_GAMERULES_H
+#define TF_GAMERULES_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "Teamplay_GameRules.h"
+#include "takedamageinfo.h"
+
+
+#ifdef CLIENT_DLL
+
+	#define CTeamFortress C_TeamFortress
+
+#endif
+
+
+class CTeamFortress : public CTeamplayRules
+{
+public:
+	DECLARE_CLASS( CTeamFortress, CTeamplayRules );
+
+	int DefaultFOV( void ) { return 90; }
+
+	// Shared implementation between client and server.
+	void WeaponTraceLine( const Vector& src, const Vector& end, unsigned int mask, CBaseEntity *pShooter, int damageType, trace_t* pTrace );
+	
+	virtual bool ShouldCollide( int collisionGroup0, int collisionGroup1 );
+	
+	virtual void FireBullets( const CTakeDamageInfo &info, int cShots, const Vector &vecSrc, const Vector &vecDirShooting, 
+		const Vector &vecSpread, float flDistance, int iBulletType, int iTracerFreq, int firingEntID, 
+		int attachmentID, const char *sCustomTracer = NULL );
+
+
+#ifdef CLIENT_DLL
+
+
+#else
+
+	CTeamFortress();
+	virtual ~CTeamFortress();
+
+	CBaseEntity *GetPlayerSpawnSpot( CBasePlayer *pPlayer );
+
+	virtual void Think( void );
+	virtual void LevelInitPostEntity( void );
+
+	virtual void CreateStandardEntities();
+
+	// Called when game rules are destroyed by CWorld
+	virtual void LevelShutdown( void );
+
+	virtual void ClientDisconnected( edict_t *pClient );
+	virtual bool ClientCommand( CBaseEntity *pEdict, const CCommand &args );
+	virtual void PlayerSpawn( CBasePlayer *pPlayer );
+
+	virtual bool PlayTextureSounds( void ) { return true; }
+	virtual bool PlayFootstepSounds( CBasePlayer *pl );
+	virtual float FlPlayerFallDamage( CBasePlayer *pPlayer );
+	virtual void  RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore );
+	// Let the game rules specify if fall death should fade screen to black
+	virtual bool  FlPlayerFallDeathDoesScreenFade( CBasePlayer *pl ) { return FALSE; }
+
+	bool	IsTraceBlockedByWorldOrShield( const Vector& src, const Vector& end, CBaseEntity *pShooter, int damageType, trace_t* pTrace );
+
+	virtual float WeaponTraceEntity( CBaseEntity *pEntity, const Vector &vecStart, const Vector &vecEnd, unsigned int mask, trace_t *ptr );
+
+	virtual void UpdateClientData( CBasePlayer *pl );
+	
+	// Death notices
+	virtual void		DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+	virtual const char  *GetDamageCustomString( const CTakeDamageInfo &info );
+	CBasePlayer			*GetDeathAssistant( CBaseEntity *pKiller, CBaseEntity *pInflictor );
+
+	virtual bool PlayerCanHearChat( CBasePlayer *pListener, CBasePlayer *pSpeaker );
+	virtual void			InitDefaultAIRelationships( void );
+
+	virtual const char *GetGameDescription( void ) { return "TeamFortress 2"; }  // this is the game name that gets seen in the server browser
+	virtual const char *AIClassText(int classType);
+
+	virtual bool FShouldSwitchWeapon( CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon );
+
+	virtual const char *SetDefaultPlayerTeam( CBasePlayer *pPlayer );
+
+	// Is the ray blocked by enemy shields?
+	bool IsBlockedByEnemyShields( const Vector& src, const Vector& end, int nFriendlyTeam );
+
+public:
+
+	virtual void	SetAllowWeaponSwitch( bool allow );
+	virtual bool	GetAllowWeaponSwitch( void );
+private:
+
+	// Don't allow switching weapons while gaining new technologies
+	bool			m_bAllowWeaponSwitch;
+
+#endif
+
+};
+
+//-----------------------------------------------------------------------------
+// Gets us at the team fortress game rules
+//-----------------------------------------------------------------------------
+
+inline CTeamFortress* TFGameRules()
+{
+	#ifdef _DEBUG
+		Assert( dynamic_cast< CTeamFortress* >( g_pGameRules ) );
+	#endif
+
+	return static_cast<CTeamFortress*>(g_pGameRules);
+}
+
+// Send the appropriate weapon impact.
+void WeaponImpact( trace_t *tr, Vector vecDir, bool bHurt, CBaseEntity *pEntity, int iDamageType );
+
+
+#ifdef CLIENT_DLL
+
+#else
+
+	//-----------------------------------------------------------------------------
+	// Purpose: Useful utility functions
+	//-----------------------------------------------------------------------------
+	class CTFTeam;
+	CTFTeam *GetOpposingTeam( CTeam *pTeam );
+	bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround );
+
+#endif
+
+#endif // TF_GAMERULES_H
diff --git a/game/shared/tf2/tf_hints.h b/game/shared/tf2/tf_hints.h
new file mode 100644
index 0000000..dce1561
--- /dev/null
+++ b/game/shared/tf2/tf_hints.h
@@ -0,0 +1,34 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_HINTS_H
+#define TF_HINTS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+enum
+{
+	TF_HINT_UNDEFINED = 0,
+	TF_HINT_VOTEFORTECHNOLOGY,
+	TF_HINT_BUILDRESOURCEPUMP,
+	TF_HINT_BUILDRESOURCEBOX,
+	TF_HINT_BUILDZONEINCREASER,
+	TF_HINT_BUILDSENTRYGUN_PLASMA,
+	TF_HINT_BUILDSANDBAG,
+	TF_HINT_BUILDANTIMORTAR,
+	TF_HINT_REPAIROBJECT,
+
+	TF_HINT_WEAPONRECEIVED,
+
+	TF_HINT_NEWTECHNOLOGY,
+
+	// Must be at end
+	TF_HINT_LASTHINT,
+};
+
+#endif // TF_HINTS_H
diff --git a/game/shared/tf2/tf_movedata.h b/game/shared/tf2/tf_movedata.h
new file mode 100644
index 0000000..75f1462
--- /dev/null
+++ b/game/shared/tf2/tf_movedata.h
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_MOVEDATA_H
+#define TF_MOVEDATA_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "igamemovement.h"
+#include "tfclassdata_shared.h"
+
+class CPlayerClassData;
+
+// This class contains TF-specific prediction data. CMoveData can be casted to this class in
+// CTFPlayerMove and CTFGameMovement to do TF-specific movement.
+class CTFMoveData : public CMoveData
+{
+public:
+
+	Vector		m_vecPosDelta;
+
+	// Revisit this!!!
+	enum { MOMENTUM_MAXSIZE = 10 };
+	float		m_aMomentum[MOMENTUM_MAXSIZE];
+	int			m_iMomentumHead;
+
+	int			m_nClassID;
+
+	inline PlayerClassCommandoData_t	&CommandoData()		{ return m_CommandoData; }
+	inline PlayerClassDefenderData_t	&DefenderData()		{ return m_DefenderData; }
+	inline PlayerClassEscortData_t		&EscortData()		{ return m_EscortData; }
+	inline PlayerClassInfiltratorData_t	&InfiltratorData()	{ return m_InfiltratorData; }
+	inline PlayerClassMedicData_t		&MedicData()		{ return m_MedicData; }
+	inline PlayerClassReconData_t		&ReconData()		{ return m_ReconData; }
+	inline PlayerClassSniperData_t		&SniperData()		{ return m_SniperData; }
+	inline PlayerClassSupportData_t		&SupportData()		{ return m_SupportData; }
+	inline PlayerClassSapperData_t		&SapperData()		{ return m_SapperData; }
+	inline PlayerClassPyroData_t		&PyroData()			{ return m_PyroData; }
+	inline void*						VehicleData()		{ return m_VehicleData; }
+	inline int							VehicleDataMaxSize()
+	{
+		return VEHICLE_DATA_SIZE;
+	}
+
+private:
+	enum
+	{
+		VEHICLE_DATA_SIZE = 256
+	};
+
+	PlayerClassCommandoData_t m_CommandoData;
+	PlayerClassDefenderData_t m_DefenderData;
+	PlayerClassEscortData_t m_EscortData;
+	PlayerClassInfiltratorData_t m_InfiltratorData;
+	PlayerClassMedicData_t m_MedicData;
+	PlayerClassReconData_t m_ReconData;
+	PlayerClassSniperData_t m_SniperData;
+	PlayerClassSupportData_t m_SupportData;
+	PlayerClassSapperData_t m_SapperData;
+	PlayerClassPyroData_t m_PyroData;
+
+	unsigned char m_VehicleData[VEHICLE_DATA_SIZE];
+};
+
+
+#endif // TF_MOVEDATA_H
diff --git a/game/shared/tf2/tf_obj_base_manned_gun.cpp b/game/shared/tf2/tf_obj_base_manned_gun.cpp
new file mode 100644
index 0000000..6d3f015
--- /dev/null
+++ b/game/shared/tf2/tf_obj_base_manned_gun.cpp
@@ -0,0 +1,680 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A stationary gun that players can man
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "tf_obj_base_manned_gun.h"
+#include "tf_obj_manned_plasmagun_shared.h"
+#include "in_buttons.h"
+#include "tf_movedata.h"
+#include "tf_gamerules.h"
+
+#if defined( CLIENT_DLL )
+#include "hudelement.h"
+#include "bone_setup.h"
+#include "hud_ammo.h"
+#include "hud_crosshair.h"
+#else
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( ObjectBaseMannedGun, DT_ObjectBaseMannedGun )
+
+BEGIN_NETWORK_TABLE( CObjectBaseMannedGun, DT_ObjectBaseMannedGun )
+#if !defined( CLIENT_DLL )
+	SendPropInt	(SENDINFO(m_nMoveStyle),	2, SPROP_UNSIGNED ),
+	SendPropInt	(SENDINFO(m_nAmmoType),		8 ),
+	SendPropInt	(SENDINFO(m_nAmmoCount),	6, SPROP_UNSIGNED ),
+	SendPropAngle(SENDINFO(m_flGunYaw),		12 ),
+	SendPropAngle(SENDINFO(m_flGunPitch),	12 ),
+	SendPropAngle(SENDINFO(m_flBarrelPitch), 12 ),
+
+	SendPropEHandle( SENDINFO( m_hLaserDesignation ) ),
+	SendPropEHandle( SENDINFO( m_hBeam ) ),
+
+#else
+	RecvPropInt( RECVINFO(m_nMoveStyle) ),
+	RecvPropInt( RECVINFO(m_nAmmoType) ),
+	RecvPropInt( RECVINFO(m_nAmmoCount) ),
+	RecvPropFloat( RECVINFO(m_flGunYaw) ),
+	RecvPropFloat( RECVINFO(m_flGunPitch) ),
+	RecvPropFloat( RECVINFO(m_flBarrelPitch) ),
+
+	RecvPropEHandle( RECVINFO( m_hLaserDesignation ) ),
+	RecvPropEHandle( RECVINFO( m_hBeam ) ),
+
+#endif
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS( tf_obj_base_manned_gun, CObjectBaseMannedGun );
+
+BEGIN_PREDICTION_DATA( CObjectBaseMannedGun  )
+
+	DEFINE_PRED_FIELD( m_nMoveStyle, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_nAmmoType, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_nAmmoCount, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+
+	DEFINE_PRED_FIELD_TOL( m_flGunYaw, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.5f),
+	DEFINE_PRED_FIELD_TOL( m_flGunPitch, FIELD_FLOAT, FTYPEDESC_INSENDTABLE | FTYPEDESC_NOERRORCHECK, 0.125f ),
+	DEFINE_PRED_FIELD_TOL( m_flBarrelPitch, FIELD_FLOAT, FTYPEDESC_INSENDTABLE | FTYPEDESC_NOERRORCHECK, 0.125f ),
+
+	DEFINE_PRED_FIELD( m_hLaserDesignation, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+
+	DEFINE_PRED_FIELD( m_hBeam, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+
+	DEFINE_FIELD( m_flBarrelHeight, FIELD_FLOAT ),
+
+//	DEFINE_FIELD( m_nBarrelAttachment, FIELD_INTEGER ),
+//	DEFINE_FIELD( m_nBarrelPivotAttachment, FIELD_INTEGER ),
+//	DEFINE_FIELD( m_nStandAttachment, FIELD_INTEGER ),
+//	DEFINE_FIELD( m_nEyesAttachment, FIELD_INTEGER ),
+
+END_PREDICTION_DATA()
+
+extern ConVar mannedgun_usethirdperson;
+static ConVar obj_manned_gun_designator_range( "obj_manned_gun_designator_range","2048", FCVAR_REPLICATED, "Manned gun's laser designation range" );
+ConVar obj_child_range_factor( "obj_child_range_factor","1.1", FCVAR_REPLICATED, "Factor applied to range of objects that are built on a buildpoint" );
+
+// Restoring initial state handling
+#define OBJ_BASE_MANNEDGUN_THINK_CONTEXT		"BaseMannedGunThink"
+#define MANNEDGUN_RESTORE_TIME					5.0
+#define MANNEDGUN_RESTORE_TURN_RATE				150
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CObjectBaseMannedGun::CObjectBaseMannedGun()
+{
+	m_nMoveStyle = MOVEMENT_STYLE_STANDARD;
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets the movement style
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::SetMovementStyle( MovementStyle_t style )
+{
+	m_nMoveStyle = style;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::Precache()
+{
+	BaseClass::Precache();
+#if !defined( CLIENT_DLL )
+	PrecacheVGuiScreen( "screen_obj_manned_plasmagun" );
+	PrecacheMaterial( "sprites/laserbeam" );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::Spawn()
+{
+	m_takedamage = DAMAGE_YES;
+
+	SetMaxPassengerCount( 1 );
+
+	m_flGunYaw = 0;
+	m_flGunPitch = 0;
+	m_flBarrelPitch = 0;
+
+	BaseClass::Spawn();
+
+	// Manned guns don't need to be built like other vehicles
+	int curFlags = GetObjectFlags();
+	curFlags &= ~OF_MUST_BE_BUILT_IN_CONSTRUCTION_YARD;
+	curFlags &= ~OF_MUST_BE_BUILT_ON_ATTACHMENT;
+	curFlags &= ~OF_DOESNT_NEED_POWER;
+	curFlags |= OF_DONT_PREVENT_BUILD_NEAR_OBJ;
+	SetObjectFlags( curFlags );
+
+	m_flMaxRange = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculate the max range of this gun
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::CalculateMaxRange( float flDefensiveRange, float flOffensiveRange )
+{
+	if ( GetTeamNumber() == TEAM_HUMANS )
+	{
+		m_flMaxRange = flDefensiveRange;
+		if ( GetParentObject() )
+		{
+			m_flMaxRange *= obj_child_range_factor.GetFloat();
+		}
+	}
+	else
+	{
+		m_flMaxRange = flOffensiveRange;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Sets up various attachment points once the model is selected 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::OnModelSelected()
+{
+	m_nBarrelAttachment = LookupAttachment( "barrel" );
+	m_nBarrelPivotAttachment = LookupAttachment( "barrelpivot" );
+	m_nStandAttachment = LookupAttachment( "vehicle_feet_passenger0" );
+	m_nEyesAttachment = LookupAttachment( "vehicle_eyes_passenger0" );
+
+	// Find the barrel height in its quiescent state...
+	Vector vBarrel;
+	QAngle vBarrelAngles;
+	GetAttachmentLocal( m_nBarrelAttachment, vBarrel, vBarrelAngles );
+	m_flBarrelHeight = vBarrel.z;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::UpdateOnRemove( void )
+{
+	if ( m_hLaserDesignation.Get() )
+	{
+		m_hLaserDesignation->Remove( );
+		m_hLaserDesignation = NULL;
+	}
+
+	// Chain at end to mimic destructor unwind order
+	BaseClass::UpdateOnRemove();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets info about the control panels
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName )
+{
+	pPanelName = "screen_obj_manned_plasmagun";
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Hide the base of the gun if it's on an attachment
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::SetupAttachedVersion( void )
+{
+	BaseClass::SetupAttachedVersion();
+
+	SetBodygroup( 1, true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::SetupUnattachedVersion( void )
+{
+	BaseClass::SetupUnattachedVersion();
+
+	SetBodygroup( 1, false );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::OnGoInactive( void )
+{
+	BaseClass::OnGoInactive();
+
+	// If we've got a player in the gun, tell him he's got to get out
+	if ( GetDriverPlayer() )
+	{
+		ClientPrint( GetDriverPlayer(), HUD_PRINTCENTER, "Lost power to the manned gun!" );
+		GetDriverPlayer()->LeaveVehicle();
+	}
+
+#if 0
+	if ( GetBuffStation() )
+	{
+		GetBuffStation()->DeBuffObject( this );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Can we get into the vehicle?
+//-----------------------------------------------------------------------------
+bool CObjectBaseMannedGun::CanGetInVehicle( CBaseTFPlayer *pPlayer )
+{
+	if ( !IsPowered() )
+	{
+		ClientPrint( pPlayer, HUD_PRINTCENTER, "No power source for the manned gun!" );
+		return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the eye position 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::GetVehicleViewPosition( int nRole, Vector *pOrigin, QAngle *pAngles, float *pFOV /*= NULL*/ )
+{
+	BaseClass::GetVehicleViewPosition( nRole, pOrigin, pAngles, pFov );
+	return;
+	Assert( nRole == VEHICLE_DRIVER );
+	QAngle vPlayerFeetAngles;
+	GetAttachment(m_nEyesAttachment, *pOrigin, vPlayerFeetAngles);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return to our original facing after a while
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::BaseMannedGunThink( void )
+{
+	// If someone's got in the gun, stop moving
+	if ( GetDriverPlayer() )
+		return;
+
+	// Otherwise, move back towards the initial state
+	if ( m_flGunPitch )
+	{
+		float flPitch = anglemod( m_flGunPitch );
+		if (( flPitch <= 180 ) && ( flPitch >= 0 ))
+		{
+			m_flGunPitch = MAX( 0, flPitch - (gpGlobals->frametime * MANNEDGUN_RESTORE_TURN_RATE) );
+		}
+		else
+		{
+			m_flGunPitch = flPitch + (gpGlobals->frametime * MANNEDGUN_RESTORE_TURN_RATE);
+			if ( m_flGunPitch >= 360 )
+			{
+				m_flGunPitch = 0;
+			}
+		}
+	}
+	else if ( m_flGunYaw )
+	{
+		if ( m_flGunYaw > 180 )
+		{
+			m_flGunYaw = m_flGunYaw + (gpGlobals->frametime * MANNEDGUN_RESTORE_TURN_RATE);
+			if ( m_flGunYaw >= 360 )
+			{
+				m_flGunYaw = 0;
+			}
+		}
+		else
+		{
+			m_flGunYaw = MAX( 0, m_flGunYaw - (gpGlobals->frametime * MANNEDGUN_RESTORE_TURN_RATE) );
+		}
+
+	}
+	else
+	{
+		// We're done
+		return;
+	}
+
+	// Keep thinking
+	SetContextThink( BaseMannedGunThink, gpGlobals->curtime + 0.1, OBJ_BASE_MANNEDGUN_THINK_CONTEXT );
+}
+
+#ifndef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: Get and set the current driver.
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::SetPassenger( int nRole, CBasePlayer *pEnt )
+{
+	BaseClass::SetPassenger( nRole, pEnt );
+
+	// If we don't have a driver anymore, return to our original facing after a while
+	if ( !GetDriverPlayer() && (m_flGunPitch || m_flGunYaw) )
+	{
+		StopDesignating();
+		SetContextThink( BaseMannedGunThink, gpGlobals->curtime + MANNEDGUN_RESTORE_TIME, OBJ_BASE_MANNEDGUN_THINK_CONTEXT );
+	}
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Here's where we deal with weapons
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::OnItemPostFrame( CBaseTFPlayer *pDriver )
+{
+	// I can't do anything if I'm not active
+	if ( !ShouldBeActive() )
+		return;
+
+	if ( !IsReadyToDrive() )
+		return;
+
+	// If we don't have a laser designator yet, create one
+	if ( !m_hLaserDesignation )
+	{
+		m_hLaserDesignation = CEnvLaserDesignation::CreatePredicted( pDriver ); 
+	}
+
+	// Designating?
+	if (pDriver->m_nButtons & IN_ATTACK2)
+	{
+		UpdateDesignator();
+		return;
+	}
+
+	StopDesignating();
+
+	// Fire our base weapon?
+	if ( pDriver->m_nButtons & IN_ATTACK )
+	{
+		Fire();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::StopDesignating( void )
+{
+	// Remove our beam if we just stopped designating
+	if ( m_hBeam.Get() )
+	{
+		m_hBeam->Remove(  );
+	}
+
+	if ( m_hLaserDesignation.Get() )
+	{
+		m_hLaserDesignation->SetActive( false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update the designator position
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::UpdateDesignator( void )
+{
+	// Make the beam, if we don't have one yet
+	if ( !m_hBeam && GetDriverPlayer() )
+	{
+		m_hBeam = BEAM_CREATE_PREDICTABLE_PERSIST( "sprites/laserbeam.vmt", 5, GetDriverPlayer() );
+		if ( m_hBeam.Get() )
+		{
+			m_hBeam->PointEntInit( vec3_origin, this );
+			m_hBeam->SetEndAttachment( m_nBarrelAttachment );
+			m_hBeam->SetColor( 255, 32, 32 );
+			m_hBeam->SetBrightness( 255 );
+			m_hBeam->SetNoise( 0 );
+			m_hBeam->SetWidth( 0.5 );
+			m_hBeam->SetEndWidth( 0.5 );
+		}
+	}
+
+	// We have to flush the bone cache because it's possible that only the bone controllers
+	// have changed since the bonecache was generated, and bone controllers aren't checked.
+	InvalidateBoneCache();
+
+	QAngle vecAng;
+	Vector vecSrc, vecAim;
+	GetAttachment( m_nBarrelAttachment, vecSrc, vecAng );
+	AngleVectors( vecAng, &vecAim, 0, 0 );
+
+	// "Fire" the designator beam
+	Vector vecEnd = vecSrc + vecAim * obj_manned_gun_designator_range.GetFloat();
+	trace_t tr;
+	TFGameRules()->WeaponTraceLine(vecSrc, vecEnd, MASK_SHOT, this, DMG_PROBE, &tr);
+
+	if ( m_hLaserDesignation.Get() )
+	{
+		// Only update our designated target point if we hit something
+		if ( tr.fraction != 1.0 )
+		{
+			m_hLaserDesignation->SetActive( true );
+			m_hLaserDesignation->SetAbsOrigin( tr.endpos );
+		}
+		else
+		{
+			m_hLaserDesignation->SetActive( false );
+		}
+	}
+
+	// Update beam visual
+	if ( m_hBeam.Get() )
+	{
+		m_hBeam->SetStartPos( tr.endpos );
+		m_hBeam->RelinkBeam();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::SetupMove( CBasePlayer *pPlayer, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move )
+{
+	BaseClass::SetupMove( pPlayer, ucmd, pHelper, move );
+
+	CTFMoveData *pMoveData = (CTFMoveData*)move; 
+	Assert( sizeof(MannedPlasmagunData_t) <= pMoveData->VehicleDataMaxSize() );
+
+	MannedPlasmagunData_t *pVehicleData = (MannedPlasmagunData_t*)pMoveData->VehicleData();
+	pVehicleData->m_pVehicle = this;
+	pVehicleData->m_flGunYaw = m_flGunYaw;
+	pVehicleData->m_flGunPitch = m_flGunPitch;
+	pVehicleData->m_flBarrelPitch = m_flBarrelPitch;
+	pVehicleData->m_nMoveStyle = m_nMoveStyle;
+	pVehicleData->m_flBarrelHeight = m_flBarrelHeight;
+	pVehicleData->m_nBarrelPivotAttachment = m_nBarrelPivotAttachment;
+	pVehicleData->m_nBarrelAttachment = m_nBarrelAttachment;
+	pVehicleData->m_nStandAttachment = m_nStandAttachment;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move )
+{
+	BaseClass::FinishMove( player, ucmd, move );
+	CTFMoveData *pMoveData = (CTFMoveData*)move; 
+	Assert( sizeof(MannedPlasmagunData_t) <= pMoveData->VehicleDataMaxSize() );
+
+	MannedPlasmagunData_t *pVehicleData = (MannedPlasmagunData_t*)pMoveData->VehicleData();
+	m_flGunYaw = pVehicleData->m_flGunYaw;
+	m_flGunPitch = pVehicleData->m_flGunPitch;
+	m_flBarrelPitch = pVehicleData->m_flBarrelPitch;
+
+	// Set the bone state..
+	SetBoneController( 0, m_flGunYaw );
+	SetBoneController( 1, m_flGunPitch );
+
+	if ( m_nMoveStyle == MOVEMENT_STYLE_BARREL_PIVOT )
+	{
+		SetBoneController( 2, m_flBarrelPitch );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectBaseMannedGun::ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove )
+{
+	m_Movement.ProcessMovement( pPlayer, pMove );
+
+	m_flGunPitch = AngleNormalize( m_flGunPitch );
+	m_flBarrelPitch = AngleNormalize( m_flBarrelPitch );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CObjectBaseMannedGun::GetGunYaw() const
+{
+	return m_flGunYaw;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CObjectBaseMannedGun::GetGunPitch() const
+{
+	return m_flGunPitch;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CObjectBaseMannedGun::ShouldUseThirdPersonVehicleView( void )
+{
+	if ( mannedgun_usethirdperson.GetInt() )
+	{
+		// We want to use third person if we're mounted on a vehicle.
+		return dynamic_cast< CBaseTFVehicle* >( GetMoveParent() ) != NULL;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_ObjectBaseMannedGun::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged(updateType);
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		// FIXME: Will this work with build animations models?
+
+		m_nBarrelAttachment = LookupAttachment( "barrel" );
+		m_nBarrelPivotAttachment = LookupAttachment( "barrelpivot" );
+		m_nStandAttachment = LookupAttachment( "vehicle_feet_passenger0" );
+
+		// Find the barrel height in its quiescent state...
+		Vector vBarrel;
+		QAngle vBarrelAngles;
+		GetAttachmentLocal(m_nBarrelAttachment, vBarrel, vBarrelAngles);
+		m_flBarrelHeight = vBarrel.z;
+
+		// HACK HACK:  This should be read from a .txt file at some point!!!!
+		CHudTexture newTexture;
+		Q_strncpy( newTexture.szTextureFile, "sprites/crosshairs", sizeof( newTexture.szTextureFile ) );
+
+		newTexture.rc.left		= 0;
+		newTexture.rc.top		= 48;
+		newTexture.rc.right		= newTexture.rc.left + 24;
+		newTexture.rc.bottom	= newTexture.rc.top + 24;
+		iconCrosshair = gHUD.AddUnsearchableHudIconToList( newTexture );
+	}
+	else
+	{
+		// Set the bone state..
+		SetBoneController( 0, m_flGunYaw );
+		SetBoneController( 1, m_flGunPitch );
+
+		if ( m_nMoveStyle == MOVEMENT_STYLE_BARREL_PIVOT )
+		{
+			SetBoneController( 2, m_flBarrelPitch );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Clamps the view angles while manning the gun 
+//-----------------------------------------------------------------------------
+void C_ObjectBaseMannedGun::UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd )
+{
+#if 0
+	// Confine the view to the appropriate yaw range...
+	float flAngleDiff = AngleDiff( pCmd->viewangles[YAW], flCenterYaw );
+
+	// Here, we must clamp to the cone...
+	if (flAngleDiff < m_Movement.GetMinYaw())
+		pCmd->viewangles[YAW] = anglemod(flCenterYaw + m_Movement.GetMinYaw());
+	else if (flAngleDiff > m_Movement.GetMaxYaw())
+		pCmd->viewangles[YAW] = anglemod(flCenterYaw + m_Movement.GetMaxYaw());
+#endif
+
+	// Prevent too much downward looking
+	if ( pCmd->viewangles[PITCH] > m_Movement.GetMaxPitch())
+	{
+		pCmd->viewangles[PITCH] = m_Movement.GetMaxPitch();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Orients the gun correctly 
+//-----------------------------------------------------------------------------
+void C_ObjectBaseMannedGun::GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS], float dadt)
+{
+	// turret angle values:
+	// 0 = front, 90 = left, 180 = back, 270 = right
+	studiohdr_t *pModel = modelinfo->GetStudiomodel( GetModel() );
+	Studio_SetController(pModel, 0, m_flGunYaw,   controllers[0]);
+	Studio_SetController(pModel, 1, m_flGunPitch, controllers[1]);
+
+	if ( m_nMoveStyle == MOVEMENT_STYLE_BARREL_PIVOT )
+	{
+		Studio_SetController(pModel, 2, m_flBarrelPitch, controllers[2]);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the angles that a player in the specified role should be using for visuals
+//-----------------------------------------------------------------------------
+QAngle C_ObjectBaseMannedGun::GetPassengerAngles( QAngle angCurrent, int nRole )
+{
+	// Stomp the current angle's pitch with our rotation
+	QAngle vecNewAngles = angCurrent;
+	angCurrent[PITCH] = m_flGunPitch;
+
+	return angCurrent;
+}
+
+//-----------------------------------------------------------------------------
+// Renders hud elements
+//-----------------------------------------------------------------------------
+void C_ObjectBaseMannedGun::DrawHudElements( void )
+{
+	GetHudAmmo()->SetPrimaryAmmo( m_nAmmoType, m_nAmmoCount );
+	GetHudAmmo()->SetSecondaryAmmo( -1, -1 );
+
+	// Let the plasma gun operator see a crosshair
+	DrawCrosshair();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the weapon's crosshair
+//-----------------------------------------------------------------------------
+void C_ObjectBaseMannedGun::DrawCrosshair()
+{
+	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
+	if ( !player )
+		return;
+
+	CHudCrosshair *crosshair = GET_HUDELEMENT( CHudCrosshair );
+	if ( !crosshair )
+		return;
+	
+	if ( iconCrosshair )
+	{
+		crosshair->SetCrosshair( iconCrosshair, gHUD.m_clrNormal );
+	}
+	else
+	{
+		static wrect_t nullrc;
+		crosshair->SetCrosshair( 0, Color( 255, 255, 255, 255 ) );
+	}
+}
+
+#endif
diff --git a/game/shared/tf2/tf_obj_base_manned_gun.h b/game/shared/tf2/tf_obj_base_manned_gun.h
new file mode 100644
index 0000000..d2b8ef3
--- /dev/null
+++ b/game/shared/tf2/tf_obj_base_manned_gun.h
@@ -0,0 +1,169 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A stationary gun that players can man
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_OBJ_BASE_MANNED_GUN_H
+#define TF_OBJ_BASE_MANNED_GUN_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfvehicle.h"
+#include "tf_obj_manned_plasmagun_shared.h"
+#include "env_laserdesignation.h"
+#include "beam_shared.h"
+
+class CMoveData;
+
+#if defined( CLIENT_DLL )
+
+#define CObjectBaseMannedGun C_ObjectBaseMannedGun
+#define CBaseTFVehicle		C_BaseTFVehicle
+
+#endif
+
+// ------------------------------------------------------------------------ //
+// A stationary gun that players can man that's built by the player
+// ------------------------------------------------------------------------ //
+class CObjectBaseMannedGun : public CBaseTFVehicle
+{
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+	DECLARE_CLASS( CObjectBaseMannedGun, CBaseTFVehicle );
+
+					CObjectBaseMannedGun();
+
+	virtual void	Spawn();
+	virtual void	Precache();
+	virtual void	UpdateOnRemove( void );
+	virtual void	GetControlPanelInfo( int nPanelIndex, const char *&pPanelName );
+	virtual bool	CanTakeEMPDamage( void ) { return true; }
+	virtual void	OnGoInactive( void );
+
+	// Vehicle overrides
+#ifndef CLIENT_DLL
+	virtual void	SetPassenger( int nRole, CBasePlayer *pEnt );
+#endif
+	virtual bool	IsPassengerVisible( int nRole = VEHICLE_DRIVER ) { return true; }
+
+	// Returns the eye position 
+	virtual void	GetVehicleViewPosition( int nRole, Vector *pOrigin, QAngle *pAngles, float *pFOV = NULL );
+
+	// Manned plasma passengers aren't damagable
+	//virtual bool	IsPassengerDamagable( int nRole = VEHICLE_DRIVER ) { return false; }
+
+	virtual void	ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove );
+	virtual void	SetupMove( CBasePlayer *player, CUserCmd *ucmd, IMoveHelper *pHelper, CMoveData *move );
+	virtual void	FinishMove( CBasePlayer *player, CUserCmd *ucmd, CMoveData *move );
+
+	virtual bool	ShouldAttachToParent( void ) { return true; }
+
+	virtual bool	MustNotBeBuiltInConstructionYard( void ) const { return true; }
+
+	virtual bool	ShouldUseThirdPersonVehicleView( void );
+
+	virtual void	BaseMannedGunThink( void );
+
+	float GetGunYaw() const;
+	float GetGunPitch() const;
+
+	// Buff
+	bool			CanBeHookedToBuffStation( void );
+
+#if defined ( CLIENT_DLL )
+// IClientVehicle overrides.
+public:
+	virtual void DrawHudElements( void );
+	virtual void UpdateViewAngles( C_BasePlayer *pLocalPlayer, CUserCmd *pCmd );
+
+	virtual QAngle GetPassengerAngles( QAngle angCurrent, int nRole );
+
+// C_BaseEntity overrides.
+public:
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+	virtual void GetBoneControllers(float controllers[MAXSTUDIOBONECTRLS], float dadt);
+
+private:
+	void	DrawCrosshair( void );
+
+#endif
+
+protected:
+	// Sets up various attachment points once the model is selected 
+	// Derived classes should call this from within their SetTeamModel call
+	void OnModelSelected();
+
+	// Can we get into the vehicle?
+	virtual bool CanGetInVehicle( CBaseTFPlayer *pPlayer );
+
+	// Here's where we deal with weapons
+	virtual void OnItemPostFrame( CBaseTFPlayer *pPassenger );
+
+	// Fire the weapon
+	virtual void Fire( void ) {}
+
+	void		StopDesignating( void );
+	void		UpdateDesignator( void );
+
+	virtual void SetupAttachedVersion( void );
+	virtual void SetupUnattachedVersion( void );
+
+	// Sets the movement style
+	void SetMovementStyle( MovementStyle_t style );
+
+	// Calculate the max range of this gun
+	void CalculateMaxRange( float flDefensiveRange, float flOffensiveRange );
+
+protected:
+	// Movement...
+	CObjectMannedPlasmagunMovement m_Movement;
+
+	float	m_flMaxRange;
+
+	// attachment points
+	int m_nBarrelAttachment;
+	int m_nBarrelPivotAttachment;
+	int m_nStandAttachment;
+	int m_nEyesAttachment;
+
+	// Movement style
+	CNetworkVar( MovementStyle_t, m_nMoveStyle );
+
+	// Barrel height...
+	float	m_flBarrelHeight;
+
+	CNetworkVar( int, m_nAmmoType );
+	CNetworkVar( int, m_nAmmoCount );
+	CNetworkVar( float, m_flGunYaw );		// 0 = front, 90 = left, 180 = back, 270 = right
+	CNetworkVar( float, m_flGunPitch );	// 0 = forward, -90 = pointing down, 90 = pointing up..
+	CNetworkVar( float, m_flBarrelPitch );
+
+	float	m_flReturnToInitialTime;
+
+	// Laser designation
+	CNetworkHandle( CBeam, m_hBeam );
+	CNetworkHandle( CEnvLaserDesignation, m_hLaserDesignation );
+
+#if defined( CLIENT_DLL )
+	CHudTexture 					*iconCrosshair;
+
+private:
+	CObjectBaseMannedGun( const CObjectBaseMannedGun & ); // not defined, not accessible
+#endif
+};
+
+
+//-----------------------------------------------------------------------------
+// Inline methods 
+//-----------------------------------------------------------------------------
+inline bool	CObjectBaseMannedGun::CanBeHookedToBuffStation( void ) 
+{ 
+	return true; 
+}
+
+#endif // TF_OBJ_BASE_MANNED_GUN_H
diff --git a/game/shared/tf2/tf_obj_basedrivergun_shared.cpp b/game/shared/tf2/tf_obj_basedrivergun_shared.cpp
new file mode 100644
index 0000000..e0dabca
--- /dev/null
+++ b/game/shared/tf2/tf_obj_basedrivergun_shared.cpp
@@ -0,0 +1,92 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Base class for object upgrading objects
+//
+//=============================================================================//
+#include "cbase.h"
+#include "baseobject_shared.h"
+#include "tf_obj_basedrivergun_shared.h"
+#include "basetfvehicle.h"
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseObjectDriverGun, DT_BaseObjectDriverGun )
+
+BEGIN_NETWORK_TABLE( CBaseObjectDriverGun, DT_BaseObjectDriverGun )
+#if !defined( CLIENT_DLL )
+	SendPropVector( SENDINFO(m_vecGunAngles), -1, SPROP_COORD ),
+#else
+	RecvPropVector( RECVINFO(m_vecGunAngles) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CBaseObjectDriverGun )
+	DEFINE_PRED_FIELD_TOL( m_vecGunAngles, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 1.0f ),
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseObjectDriverGun::CBaseObjectDriverGun()
+{
+	m_vecGunAngles = QAngle(0,0,0);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObjectDriverGun::Spawn()
+{
+	BaseClass::Spawn();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObjectDriverGun::FinishedBuilding( void )
+{
+#if !defined( CLIENT_DLL )
+	BaseClass::FinishedBuilding();
+
+	CBaseTFVehicle *pVehicle = dynamic_cast<CBaseTFVehicle*>(GetParentObject());
+	Assert( pVehicle );
+
+	pVehicle->SetDriverGun( this );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObjectDriverGun::SetTargetAngles( const QAngle &vecAngles )
+{
+	m_vecGunAngles = vecAngles;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const QAngle &CBaseObjectDriverGun::GetCurrentAngles( void )
+{
+	return m_vecGunAngles.Get();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+Vector CBaseObjectDriverGun::GetFireOrigin( void )
+{
+	return GetAbsOrigin();
+}
+
+#ifdef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CBaseObjectDriverGun::ShouldPredict( void )
+{
+	CBaseTFVehicle *pVehicle = dynamic_cast<CBaseTFVehicle*>(GetParentObject());
+	if ( pVehicle && pVehicle->GetDriverPlayer() == C_BasePlayer::GetLocalPlayer() )
+		return true;
+
+	return BaseClass::ShouldPredict();
+}
+#endif
\ No newline at end of file
diff --git a/game/shared/tf2/tf_obj_basedrivergun_shared.h b/game/shared/tf2/tf_obj_basedrivergun_shared.h
new file mode 100644
index 0000000..3d79cd1
--- /dev/null
+++ b/game/shared/tf2/tf_obj_basedrivergun_shared.h
@@ -0,0 +1,64 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Base class for object upgrading objects
+//
+//=============================================================================//
+
+#ifndef TF_OBJ_BASEDRIVERGUN_H
+#define TF_OBJ_BASEDRIVERGUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#if defined( CLIENT_DLL )
+#define CBaseObjectDriverGun C_BaseObjectDriverGun
+#endif
+
+#include "tf_obj_baseupgrade_shared.h"
+
+// ------------------------------------------------------------------------ 
+// Base class for objects that, when built on a vehicle, become under control of the driver
+// ------------------------------------------------------------------------ 
+class CBaseObjectDriverGun : public CBaseObjectUpgrade
+{
+DECLARE_CLASS( CBaseObjectDriverGun, CBaseObjectUpgrade );
+
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CBaseObjectDriverGun();
+
+	virtual void	Spawn( void );
+	virtual void	FinishedBuilding( void );
+
+	// Firing
+	virtual bool	CanFireNow( void ) { return false; }
+	virtual void	Fire( CBaseTFPlayer *pDriver ) { return; }
+
+	// Turning
+	virtual void			SetTargetAngles( const QAngle &vecAngles );
+	virtual const QAngle	&GetCurrentAngles( void );
+	virtual Vector			GetFireOrigin( void );
+
+	// HUD
+	virtual void			DrawHudElements( void ) { return; }
+
+#ifdef CLIENT_DLL
+	// All predicted weapons need to implement and return true
+	virtual bool	IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+	virtual bool	ShouldPredict( void );
+#endif
+
+protected:
+	CNetworkQAngle( m_vecGunAngles );
+
+private:
+	CBaseObjectDriverGun( const CBaseObjectDriverGun & ); // not defined, not accessible
+};
+
+#endif // TF_OBJ_BASEDRIVERGUN_H
diff --git a/game/shared/tf2/tf_obj_baseupgrade_shared.cpp b/game/shared/tf2/tf_obj_baseupgrade_shared.cpp
new file mode 100644
index 0000000..9f0f30f
--- /dev/null
+++ b/game/shared/tf2/tf_obj_baseupgrade_shared.cpp
@@ -0,0 +1,58 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Base class for object upgrading objects
+//
+//=============================================================================//
+#include "cbase.h"
+#include "baseobject_shared.h"
+#include "tf_obj_baseupgrade_shared.h"
+
+IMPLEMENT_NETWORKCLASS_ALIASED( BaseObjectUpgrade, DT_BaseObjectUpgrade )
+
+BEGIN_NETWORK_TABLE( CBaseObjectUpgrade, DT_BaseObjectUpgrade )
+END_NETWORK_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseObjectUpgrade::CBaseObjectUpgrade()
+{
+#if !defined( CLIENT_DLL )
+	UseClientSideAnimation();
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseObjectUpgrade::Spawn()
+{
+	BaseClass::Spawn();
+
+#if !defined( CLIENT_DLL )
+	m_fObjectFlags |= OF_DONT_PREVENT_BUILD_NEAR_OBJ | OF_ALLOW_REPEAT_PLACEMENT | 
+					  OF_DOESNT_NEED_POWER | OF_MUST_BE_BUILT_ON_ATTACHMENT; 
+
+	// Prevent anyone shooting / emping / buffing me
+	SetSolid( SOLID_NONE );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Prevent Team Damage
+//-----------------------------------------------------------------------------
+int CBaseObjectUpgrade::OnTakeDamage( const CTakeDamageInfo &info )
+{
+#if !defined( CLIENT_DLL )
+	// Check teams
+	if ( info.GetDamageType() & DMG_BLAST )
+	{
+		return 0;
+	}
+
+	return BaseClass::OnTakeDamage( info );
+#else
+	return 0;
+#endif
+}
\ No newline at end of file
diff --git a/game/shared/tf2/tf_obj_baseupgrade_shared.h b/game/shared/tf2/tf_obj_baseupgrade_shared.h
new file mode 100644
index 0000000..cccbc63
--- /dev/null
+++ b/game/shared/tf2/tf_obj_baseupgrade_shared.h
@@ -0,0 +1,41 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Base class for object upgrading objects
+//
+//=============================================================================//
+
+#ifndef TF_OBJ_BASEUPGRADE_H
+#define TF_OBJ_BASEUPGRADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "baseobject_shared.h"
+#include "takedamageinfo.h"
+
+#if defined( CLIENT_DLL )
+#define CBaseObjectUpgrade C_BaseObjectUpgrade
+#endif
+
+// ------------------------------------------------------------------------ //
+// Base class for object upgrading objects
+// ------------------------------------------------------------------------ //
+class CBaseObjectUpgrade : public CBaseObject
+{
+DECLARE_CLASS( CBaseObjectUpgrade, CBaseObject );
+
+public:
+	DECLARE_NETWORKCLASS();
+
+	CBaseObjectUpgrade();
+
+	virtual void	Spawn( void );
+	virtual bool	IsAnUpgrade( void )			{ return true; }
+	virtual int		OnTakeDamage( const CTakeDamageInfo &info );
+
+private:
+	CBaseObjectUpgrade( const CBaseObjectUpgrade & ); // not defined, not accessible
+};
+
+#endif // TF_OBJ_BASEUPGRADE_H
diff --git a/game/shared/tf2/tf_obj_driver_machinegun_shared.cpp b/game/shared/tf2/tf_obj_driver_machinegun_shared.cpp
new file mode 100644
index 0000000..f914978
--- /dev/null
+++ b/game/shared/tf2/tf_obj_driver_machinegun_shared.cpp
@@ -0,0 +1,219 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Vehicle mounted machinegun that the driver controls
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "baseobject_shared.h"
+#include "tf_obj_driver_machinegun_shared.h"
+#include "engine/IEngineSound.h"
+#include "ammodef.h"
+#include "tf_gamerules.h"
+
+#if defined( CLIENT_DLL )
+#include "hud_ammo.h"
+#else
+#endif
+
+// ------------------------------------------------------------------------ //
+#define DRIVER_MACHINEGUN_MINS				Vector(-10, -10, 0)
+#define DRIVER_MACHINEGUN_MAXS				Vector( 10,  10, 10)
+#define DRIVER_MACHINEGUN_MODEL				"models/objects/obj_manned_plasmagun.mdl"
+
+IMPLEMENT_NETWORKCLASS_ALIASED( ObjectDriverMachinegun, DT_ObjectDriverMachinegun )
+
+BEGIN_NETWORK_TABLE( CObjectDriverMachinegun, DT_ObjectDriverMachinegun )
+#if !defined( CLIENT_DLL )
+	SendPropInt( SENDINFO(m_nAmmoCount), 7, SPROP_UNSIGNED ),
+#else
+	RecvPropInt( RECVINFO(m_nAmmoCount) ),
+#endif
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS(obj_driver_machinegun, CObjectDriverMachinegun);
+PRECACHE_REGISTER(obj_driver_machinegun);
+
+BEGIN_PREDICTION_DATA( CObjectDriverMachinegun )
+	DEFINE_PRED_FIELD( m_nAmmoCount, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+
+ConVar	obj_driver_machinegun_health( "obj_driver_machinegun_health","100", FCVAR_REPLICATED, "Driver's mounted machinegun health" );
+ConVar	obj_driver_machinegun_range( "obj_driver_machinegun_range","1048", FCVAR_REPLICATED, "Driver's mounted machinegun range" );
+ConVar	obj_driver_machinegun_damage( "obj_driver_machinegun_damage","10", FCVAR_REPLICATED, "Driver's mounted machinegun damage" );
+ConVar	obj_driver_machinegun_max_ammo( "obj_driver_machinegun_max_ammo","30", FCVAR_REPLICATED, "Driver's mounted machinegun ammo" );
+ConVar	obj_driver_machinegun_ammo_recharge_rate( "obj_driver_machinegun_ammo_recharge_rate","0.5", FCVAR_REPLICATED, "Driver's mounted machinegun ammo recharge rate" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CObjectDriverMachinegun::CObjectDriverMachinegun()
+{
+	SetPredictionEligible( true );
+
+#if !defined( CLIENT_DLL )
+	m_iHealth = obj_driver_machinegun_health.GetInt();
+#endif
+
+	m_flNextAttack = 0;
+	m_nMaxAmmoCount = m_nAmmoCount = obj_driver_machinegun_max_ammo.GetInt();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectDriverMachinegun::Spawn()
+{
+	Precache();
+	SetModel( DRIVER_MACHINEGUN_MODEL );
+
+#if !defined( CLIENT_DLL )
+	SetBodygroup( 1, true );
+
+	UTIL_SetSize(this, DRIVER_MACHINEGUN_MINS, DRIVER_MACHINEGUN_MAXS);
+	m_takedamage = DAMAGE_YES;
+
+	SetType( OBJ_DRIVER_MACHINEGUN );
+	m_fObjectFlags |= OF_SUPPRESS_NOTIFY_UNDER_ATTACK | OF_DONT_AUTO_REPAIR;
+
+	SetThink( RechargeThink );
+#endif
+
+ 	m_nBarrelAttachment = LookupAttachment( "barrel" );
+	m_nAmmoType = GetAmmoDef()->Index( "Bullets" );
+
+	BaseClass::Spawn();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectDriverMachinegun::Precache()
+{
+	PrecacheModel( DRIVER_MACHINEGUN_MODEL );
+
+	PrecacheScriptSound( "DriverMachinegun.Fire" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CObjectDriverMachinegun::CanFireNow( void )
+{
+	if ( !m_nAmmoCount )
+		return false;
+
+	return ( m_flNextAttack < gpGlobals->curtime );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectDriverMachinegun::Fire( CBaseTFPlayer *pDriver )
+{
+	// We have to flush the bone cache because it's possible that only the bone controllers
+	// have changed since the bonecache was generated, and bone controllers aren't checked.
+	InvalidateBoneCache();
+
+	QAngle vecAng;
+	Vector vecSrc, vecAim;
+	GetAttachment( m_nBarrelAttachment, vecSrc, vecAng );
+	AngleVectors( vecAng, &vecAim, 0, 0 );
+
+	static Vector spread = VECTOR_CONE_5DEGREES;
+	TFGameRules()->FireBullets( CTakeDamageInfo( this, pDriver, obj_driver_machinegun_damage.GetFloat(), DMG_BULLET ), 
+			1, vecSrc, vecAim, spread, obj_driver_machinegun_range.GetFloat(), m_nAmmoType, 4, entindex(), m_nBarrelAttachment );
+
+#if !defined (CLIENT_DLL)
+	SetActivity( ACT_VM_PRIMARYATTACK );
+#else
+	int sequence = SelectWeightedSequence( ACT_VM_PRIMARYATTACK ); 
+	if ( sequence != ACTIVITY_NOT_AVAILABLE )
+	{
+		ResetSequence( sequence );
+		SetCycle( 0 );
+		m_bClientSideFrameReset = !m_bClientSideFrameReset;
+	}
+#endif
+	DoMuzzleFlash();
+
+	CPASAttenuationFilter filter( this );
+	filter.UsePredictionRules();
+	EmitSound( filter, entindex(), "DriverMachinegun.Fire" );
+
+	m_nAmmoCount -= 1;
+
+#if !defined (CLIENT_DLL)
+	SetNextThink( gpGlobals->curtime + obj_driver_machinegun_ammo_recharge_rate.GetFloat() );
+#endif
+
+	// If I'm EMPed, slow the firing rate down
+	m_flNextAttack = gpGlobals->curtime + ( HasPowerup(POWERUP_EMP) ? 0.3f : 0.15f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectDriverMachinegun::SetTargetAngles( const QAngle &vecAngles )
+{
+	BaseClass::SetTargetAngles( vecAngles );
+
+#if !defined( CLIENT_DLL )
+	SetBoneController( 0, vecAngles[YAW] );
+	SetBoneController( 1, vecAngles[PITCH] );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+Vector CObjectDriverMachinegun::GetFireOrigin( void )
+{
+	Vector vecOrigin;
+	QAngle dummy;
+	GetAttachment( m_nBarrelAttachment, vecOrigin, dummy );
+	return vecOrigin;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Rcharge my ammo count
+//-----------------------------------------------------------------------------
+void CObjectDriverMachinegun::RechargeThink( void )
+{
+#if !defined( CLIENT_DLL )
+	SetNextThink( gpGlobals->curtime + obj_driver_machinegun_ammo_recharge_rate.GetFloat() );
+
+	// I can't do anything if I'm not active
+	if ( !ShouldBeActive() )
+		return;
+
+	if (m_nAmmoCount < m_nMaxAmmoCount)
+	{
+		m_nAmmoCount += 1;
+	}
+#endif
+}
+
+// Client code only
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CObjectDriverMachinegun::GetBoneControllers( float controllers[MAXSTUDIOBONECTRLS] )
+{
+	BaseClass::GetBoneControllers( controllers );
+
+	controllers[0] = anglemod( m_vecGunAngles[YAW] ) / 360.0;
+	controllers[1] = anglemod( m_vecGunAngles[PITCH] ) / 360.0;
+}
+
+//-----------------------------------------------------------------------------
+// Renders hud elements
+//-----------------------------------------------------------------------------
+void CObjectDriverMachinegun::DrawHudElements( void )
+{
+	GetHudAmmo()->SetPrimaryAmmo( m_nAmmoType, m_nAmmoCount );
+	GetHudAmmo()->SetSecondaryAmmo( -1, -1 );
+}
+#endif
diff --git a/game/shared/tf2/tf_obj_driver_machinegun_shared.h b/game/shared/tf2/tf_obj_driver_machinegun_shared.h
new file mode 100644
index 0000000..436d421
--- /dev/null
+++ b/game/shared/tf2/tf_obj_driver_machinegun_shared.h
@@ -0,0 +1,62 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Vehicle mounted machinegun that the driver controls
+//
+//=============================================================================//
+
+#ifndef TF_OBJ_DRIVER_MACHINEGUN_H
+#define TF_OBJ_DRIVER_MACHINEGUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_obj_basedrivergun_shared.h"
+
+#if defined( CLIENT_DLL )
+#define CObjectDriverMachinegun C_ObjectDriverMachinegun
+#endif
+
+// ------------------------------------------------------------------------ //
+// Mounted machinegun
+// ------------------------------------------------------------------------ //
+class CObjectDriverMachinegun : public CBaseObjectDriverGun
+{
+DECLARE_CLASS( CObjectDriverMachinegun, CBaseObjectDriverGun );
+
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CObjectDriverMachinegun();
+
+	virtual void	Spawn();
+	virtual void	Precache();
+
+	// Firing
+	virtual bool	CanFireNow( void );
+	virtual void	Fire( CBaseTFPlayer *pDriver );
+
+	// Turning
+	virtual Vector	GetFireOrigin( void );
+	virtual void	SetTargetAngles( const QAngle &vecAngles );
+
+#if defined( CLIENT_DLL )
+	void			GetBoneControllers( float controllers[MAXSTUDIOBONECTRLS] );
+	virtual void	DrawHudElements( void );
+#endif
+
+	// Ammo
+	void			RechargeThink( void );
+
+private:
+	float	m_flNextAttack;
+	int		m_nBarrelAttachment;
+	int		m_nAmmoType;
+	CNetworkVar( int, m_nAmmoCount );
+	int		m_nMaxAmmoCount;
+
+private:
+	CObjectDriverMachinegun( const CObjectDriverMachinegun & ); // not defined, not accessible
+};
+
+#endif // TF_OBJ_DRIVER_MACHINEGUN_H
diff --git a/game/shared/tf2/tf_obj_manned_plasmagun.cpp b/game/shared/tf2/tf_obj_manned_plasmagun.cpp
new file mode 100644
index 0000000..0743bfc
--- /dev/null
+++ b/game/shared/tf2/tf_obj_manned_plasmagun.cpp
@@ -0,0 +1,304 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A stationary gun that players can man
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "tf_obj_manned_plasmagun.h"
+#include "ammodef.h"
+#include "plasmaprojectile.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include "tf_gamerules.h"
+
+#define MANNED_PLASMAGUN_MINS			Vector(-20, -20, 0)
+#define MANNED_PLASMAGUN_MAXS			Vector( 20,  20, 55)
+#define MANNED_PLASMAGUN_ALIEN_MODEL	"models/objects/obj_manned_plasmagun.mdl"
+#define MANNED_PLASMAGUN_HUMAN_MODEL	"models/objects/human_obj_manned_plasmagun.mdl"
+
+#define MANNED_PLASMAGUN_RECHARGE_TIME	0.2
+#define MANNED_PLASMAGUN_IDLE_RECHARGE_TIME	0.1
+
+#define MANNED_PLASMAGUN_IDLE_TIME	2.0
+
+#if !defined( CLIENT_DLL )
+BEGIN_DATADESC( CObjectMannedPlasmagun )
+
+	DEFINE_THINKFUNC( RechargeThink ),
+
+END_DATADESC()
+#endif
+
+IMPLEMENT_NETWORKCLASS_ALIASED( ObjectMannedPlasmagun, DT_ObjectMannedPlasmagun )
+
+BEGIN_NETWORK_TABLE( CObjectMannedPlasmagun, DT_ObjectMannedPlasmagun )
+#if !defined( CLIENT_DLL )
+	SendPropTime( SENDINFO( m_flNextIdleTime ) ),
+	SendPropInt( SENDINFO( m_bFiringLeft ), 1, SPROP_UNSIGNED ),
+
+	SendPropInt( SENDINFO( m_nNextThinkTick ) ),
+#else
+	RecvPropTime( RECVINFO( m_flNextIdleTime ) ),
+	RecvPropInt( RECVINFO( m_bFiringLeft ) ),
+
+	RecvPropInt		( RECVINFO( m_nNextThinkTick ) ),
+
+#endif
+END_NETWORK_TABLE()
+
+
+BEGIN_PREDICTION_DATA( CObjectMannedPlasmagun  )
+	DEFINE_PRED_FIELD_TOL( m_flNextIdleTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+	DEFINE_PRED_FIELD( m_bFiringLeft, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+
+	DEFINE_PRED_FIELD( m_nNextThinkTick, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+
+//	DEFINE_FIELD( m_nRightBarrelAttachment, FIELD_INTEGER ),
+	DEFINE_FIELD( m_nMaxAmmoCount, FIELD_INTEGER ),
+
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS(obj_manned_plasmagun, CObjectMannedPlasmagun);
+PRECACHE_REGISTER(obj_manned_plasmagun);
+
+// CVars
+ConVar	obj_manned_plasmagun_health( "obj_manned_plasmagun_health","100", FCVAR_REPLICATED, "Manned Plasmagun health" );
+ConVar	obj_manned_plasmagun_range_def( "obj_manned_plasmagun_range_def","1000", FCVAR_REPLICATED, "Defensive Manned Plasmagun range" );
+ConVar	obj_manned_plasmagun_range_off( "obj_manned_plasmagun_range_off","1000", FCVAR_REPLICATED, "Offensive Manned Plasmagun range" );
+ConVar	obj_manned_plasmagun_damage( "obj_manned_plasmagun_damage","20", FCVAR_REPLICATED, "Manned Plasmagun damage" );
+ConVar	obj_manned_plasmagun_radius( "obj_manned_plasmagun_radius","128", FCVAR_REPLICATED, "Manned Plasmagun explosive radius" );
+ConVar	obj_manned_plasmagun_clip( "obj_manned_plasmagun_clip","35", FCVAR_REPLICATED, "Manned Plasmagun's clip size" );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CObjectMannedPlasmagun::CObjectMannedPlasmagun()
+{
+	m_bFiringLeft = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectMannedPlasmagun::Precache()
+{
+	BaseClass::Precache();
+	PrecacheModel( MANNED_PLASMAGUN_ALIEN_MODEL );
+	PrecacheModel( MANNED_PLASMAGUN_HUMAN_MODEL );
+
+	PrecacheScriptSound( "ObjectMannedPlasmagun.Fire" );
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectMannedPlasmagun::SetupTeamModel( void )
+{
+	// FIXME: When adding in build animations here, make sure C_ObjectBaseMannedGun::OnDataChanged
+	// does the right thing on the client!!
+	if ( GetTeamNumber() == TEAM_HUMANS )
+	{
+		SetMovementStyle( MOVEMENT_STYLE_BARREL_PIVOT );
+		SetModel( MANNED_PLASMAGUN_HUMAN_MODEL );
+	}
+	else
+	{
+		SetMovementStyle( MOVEMENT_STYLE_STANDARD );
+		SetModel( MANNED_PLASMAGUN_ALIEN_MODEL );
+	}
+
+	// Call this to get all the attachment points happy
+	OnModelSelected();
+
+	// Get our extra barrel
+	m_nRightBarrelAttachment = LookupAttachment( "barrelR" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectMannedPlasmagun::Spawn()
+{
+	Precache();
+
+	SetSolid( SOLID_BBOX );
+
+	SetSize( MANNED_PLASMAGUN_MINS, MANNED_PLASMAGUN_MAXS );
+	SetHealth( obj_manned_plasmagun_health.GetInt() );
+
+	SetNextThink( gpGlobals->curtime + MANNED_PLASMAGUN_IDLE_RECHARGE_TIME );
+
+	SetType( OBJ_MANNED_PLASMAGUN );
+
+	m_nAmmoCount = m_nMaxAmmoCount = obj_manned_plasmagun_clip.GetInt();
+	m_flNextAttack = gpGlobals->curtime;
+	m_nAmmoType = GetAmmoDef()->Index( "RechargeEnergy" );
+	SetThink( RechargeThink );
+
+	BaseClass::Spawn();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finished the build
+//-----------------------------------------------------------------------------
+void CObjectMannedPlasmagun::FinishedBuilding( void )
+{
+	BaseClass::FinishedBuilding();
+
+	CalculateMaxRange( obj_manned_plasmagun_range_def.GetFloat(), obj_manned_plasmagun_range_off.GetFloat() );
+}
+
+//-----------------------------------------------------------------------------
+// Recharge think...
+//-----------------------------------------------------------------------------
+void CObjectMannedPlasmagun::RechargeThink(  )
+{
+	// Prevent manned guns from deteriorating
+	ResetDeteriorationTime();
+
+	float flNextRechargeTime = MANNED_PLASMAGUN_RECHARGE_TIME;
+	/*
+	ROBIN: Remove idle recharging for now
+
+	if (gpGlobals->curtime >= m_flNextIdleTime)
+		flNextRechargeTime = MANNED_PLASMAGUN_IDLE_RECHARGE_TIME; 
+	else
+		flNextRechargeTime = MANNED_PLASMAGUN_RECHARGE_TIME;
+	*/
+
+	// If I'm EMPed, slow the recharge rate down
+	if ( HasPowerup(POWERUP_EMP) )
+	{
+		flNextRechargeTime *= 1.5;
+	}
+	SetNextThink( gpGlobals->curtime + flNextRechargeTime );
+
+	// I can't do anything if I'm not active
+	if ( !ShouldBeActive() )
+		return;
+
+	if (m_nAmmoCount < m_nMaxAmmoCount)
+	{
+		++m_nAmmoCount;
+	}
+	else
+	{
+		// No need to think when it's full
+		SetNextThink( gpGlobals->curtime + 5.0f );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Plasma sentrygun's fire
+//-----------------------------------------------------------------------------
+void CObjectMannedPlasmagun::Fire( )
+{
+	if (m_flNextAttack > gpGlobals->curtime)
+		return;
+
+	// Because the plasma sentrygun always thinks it has ammo (see below)
+	// we might not have ammo here, in which case we should just abort.
+	if ( !m_nAmmoCount )
+		return;
+
+	// Make sure we think soon enough in case of firing...
+	float flNextRecharge = gpGlobals->curtime + (HasPowerup(POWERUP_EMP) ? MANNED_PLASMAGUN_RECHARGE_TIME * 1.5 : MANNED_PLASMAGUN_RECHARGE_TIME);
+	SetNextThink( gpGlobals->curtime + flNextRecharge );
+
+	// We have to flush the bone cache because it's possible that only the bone controllers
+	// have changed since the bonecache was generated, and bone controllers aren't checked.
+	InvalidateBoneCache();
+
+	QAngle vecAng;
+	Vector vecSrc, vecAim;
+
+	// Alternate barrels when firing
+	if ( m_bFiringLeft )
+	{
+		// Aliens permanently fire left barrel because they have no right
+		if ( GetTeamNumber() == TEAM_HUMANS )
+		{
+			m_bFiringLeft = false;
+		}
+		GetAttachment( m_nBarrelAttachment, vecSrc, vecAng );
+		SetActivity( ACT_VM_PRIMARYATTACK );
+	}
+	else
+	{
+		m_bFiringLeft = true;
+		GetAttachment( m_nRightBarrelAttachment, vecSrc, vecAng );
+		SetActivity( ACT_VM_SECONDARYATTACK );
+	}
+
+	// Get the distance to the target
+	AngleVectors( vecAng, &vecAim, 0, 0 );
+
+	int damageType = GetAmmoDef()->DamageType( m_nAmmoType );
+	CBasePlasmaProjectile *pPlasma = CBasePlasmaProjectile::CreatePredicted( vecSrc, vecAim, Vector( 0, 0, 0 ), damageType, GetDriverPlayer() );
+	if ( pPlasma )
+	{
+		pPlasma->SetDamage( obj_manned_plasmagun_damage.GetFloat() );
+		pPlasma->m_hOwner = GetDriverPlayer();
+		//pPlasma->SetOwnerEntity( this );
+		pPlasma->SetMaxRange( m_flMaxRange );
+		if ( obj_manned_plasmagun_radius.GetFloat() )
+		{
+			pPlasma->SetExplosive( obj_manned_plasmagun_radius.GetFloat() );
+		}
+	}
+
+	CSoundParameters params;
+	if ( GetParametersForSound( "ObjectMannedPlasmagun.Fire", params, NULL ) )
+	{
+		CPASAttenuationFilter filter( this, params.soundlevel );
+		if ( IsPredicted() )
+		{
+			filter.UsePredictionRules();
+		}
+		EmitSound( filter, entindex(), "ObjectMannedPlasmagun.Fire" );
+	}
+//	SetSentryAnim( TFTURRET_ANIM_FIRE );
+	DoMuzzleFlash();
+
+	--m_nAmmoCount;
+
+	m_flNextIdleTime = gpGlobals->curtime + MANNED_PLASMAGUN_IDLE_TIME;
+
+	// If I'm EMPed, slow the firing rate down
+	m_flNextAttack = gpGlobals->curtime + ( HasPowerup(POWERUP_EMP) ? 0.3f : 0.1f );
+}
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : updateType - 
+//-----------------------------------------------------------------------------
+void CObjectMannedPlasmagun::PostDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PostDataUpdate( updateType );
+
+	bool teamchanged = GetTeamNumber() != m_nPreviousTeam;
+
+	if ( teamchanged ||
+		updateType == DATA_UPDATE_CREATED )
+	{
+		C_BaseAnimating::AllowBoneAccess( true, false );
+		SetupTeamModel();
+		C_BaseAnimating::AllowBoneAccess( false, false );
+	}
+}
+
+void CObjectMannedPlasmagun::PreDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PreDataUpdate( updateType );
+
+	m_nPreviousTeam = GetTeamNumber();
+}
+
+#endif
diff --git a/game/shared/tf2/tf_obj_manned_plasmagun.h b/game/shared/tf2/tf_obj_manned_plasmagun.h
new file mode 100644
index 0000000..9bd35c0
--- /dev/null
+++ b/game/shared/tf2/tf_obj_manned_plasmagun.h
@@ -0,0 +1,88 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A stationary gun that players can man
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_OBJ_MANNED_PLASMAGUN_H
+#define TF_OBJ_MANNED_PLASMAGUN_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_obj_base_manned_gun.h"
+
+#if defined( CLIENT_DLL )
+
+#define CObjectMannedPlasmagun C_ObjectMannedPlasmagun
+
+#endif
+
+// ------------------------------------------------------------------------ //
+// A stationary gun that players can man that's built by the player
+// ------------------------------------------------------------------------ //
+class CObjectMannedPlasmagun : public CObjectBaseMannedGun
+{
+public:
+#if !defined( CLIENT_DLL )
+	DECLARE_DATADESC();
+#endif
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+	DECLARE_CLASS( CObjectMannedPlasmagun, CObjectBaseMannedGun );
+
+	static CObjectMannedPlasmagun* Create(const Vector &vOrigin, const QAngle &vAngles);
+
+					CObjectMannedPlasmagun();
+
+	virtual void	Spawn();
+	virtual void	Precache();
+	virtual void	SetupTeamModel( void );
+	virtual void	FinishedBuilding( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	virtual void	PreDataUpdate( DataUpdateType_t updateType );
+	virtual void	PostDataUpdate( DataUpdateType_t updateType );
+#endif
+
+protected:
+	// Think function
+	void RechargeThink();
+
+	// Fire the weapon
+	virtual void Fire( void );
+	
+protected:
+	int		m_nMaxAmmoCount;
+	CNetworkVar( float, m_flNextIdleTime );
+
+	// Handling for the multiple barrels
+	int		m_nRightBarrelAttachment;
+	CNetworkVar( bool, m_bFiringLeft );
+
+private:
+	CObjectMannedPlasmagun( const CObjectMannedPlasmagun& src );
+
+	int		m_nPreviousTeam;
+};
+
+
+#endif // TF_OBJ_MANNED_PLASMAGUN_H
diff --git a/game/shared/tf2/tf_obj_manned_plasmagun_shared.cpp b/game/shared/tf2/tf_obj_manned_plasmagun_shared.cpp
new file mode 100644
index 0000000..9cbb4f1
--- /dev/null
+++ b/game/shared/tf2/tf_obj_manned_plasmagun_shared.cpp
@@ -0,0 +1,117 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A stationary gun that players can man
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "tf_obj_manned_plasmagun_shared.h"
+#include "tf_movedata.h"
+
+ConVar mannedgun_usethirdperson( "mannedgun_usethirdperson", "1", FCVAR_REPLICATED, "Use third person view while in manned guns built on vehicles." );
+
+#define MANNED_PLASMAGUN_AIMING_CONE_ANGLE	45.0f	// total angle of aiming
+#define MANNED_PLASMAGUN_YAW_SPEED			1000.0f
+#define MANNED_PLASMAGUN_MAX_PITCH			50.0f
+#define MANNED_PLASMAGUN_BARREL_MAX_PITCH	30.0f
+
+float CObjectMannedPlasmagunMovement::GetMaxYaw() const
+{
+	return MANNED_PLASMAGUN_AIMING_CONE_ANGLE;
+}
+
+float CObjectMannedPlasmagunMovement::GetMinYaw() const
+{
+	return -MANNED_PLASMAGUN_AIMING_CONE_ANGLE;
+}
+
+float CObjectMannedPlasmagunMovement::GetMaxPitch() const
+{
+	return MANNED_PLASMAGUN_MAX_PITCH;
+}
+
+void CObjectMannedPlasmagunMovement::ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove )
+{
+	CTFMoveData *pMoveData = (CTFMoveData*)pMove; 
+	Assert( sizeof(MannedPlasmagunData_t) <= pMoveData->VehicleDataMaxSize() );
+
+	MannedPlasmagunData_t *pVehicleData = (MannedPlasmagunData_t*)pMoveData->VehicleData();
+
+	bool bSimple = (pVehicleData->m_nMoveStyle == MOVEMENT_STYLE_SIMPLE);
+	CBaseTFVehicle *pVehicle = pVehicleData->m_pVehicle;
+
+	// Flush caches since bone controllers might be wrong since they are not in the cache yet
+	pVehicle->InvalidateBoneCache();
+
+	// Get the view direction *in world coordinates*
+	Vector vPlayerEye = pPlayer->EyePosition();
+	QAngle angEyeAngles = pPlayer->LocalEyeAngles();
+	Vector vPlayerForward;
+	AngleVectors( angEyeAngles, &vPlayerForward, NULL, NULL );
+
+
+	// Now figure out the pitch. This is done by casting a ray to see where the player's aiming reticle is pointing.
+	// Then we do some trig to find out what angle the turret should point so it can see the target.
+	// NOTE: this is done in the tank's local space so it works when the tank is banked.
+	VMatrix mGunToWorld = SetupMatrixTranslation(pVehicle->GetAbsOrigin()) * SetupMatrixAngles(pVehicle->GetAbsAngles());
+	VMatrix mWorldToGun = mGunToWorld.InverseTR();
+
+	// First trace only on the world..
+	Vector start = vPlayerEye;
+	Vector end   = start + vPlayerForward * 5000.0f;
+
+	Vector vTarget;
+	if ( bSimple )
+	{
+		vTarget = end;
+	}
+	else
+	{
+		trace_t trace;
+		UTIL_TraceLine(start, end, MASK_SOLID_BRUSHONLY, pVehicle, COLLISION_GROUP_NONE, &trace);
+		vTarget = trace.endpos;
+		if(trace.fraction == 1)
+		{
+			// It didn't hit the world, so trace on ents.
+			UTIL_TraceLine(start, end, MASK_PLAYERSOLID|MASK_NPCSOLID, pVehicle, COLLISION_GROUP_NONE, &trace);
+			vTarget = trace.endpos;
+			if(trace.fraction == 1)
+			{
+				// Didn't hit any ents.. just assume it's way out in front of the player's view.
+				vTarget = end;
+			}
+		}
+	}
+
+	// Transform the world position into gun space.
+	vTarget = mWorldToGun * vTarget;
+
+
+	// Compute the position of the barrel pivot point as measured in the coordinate system of the gun
+	Vector vTurretBase;
+	QAngle vTurretBaseAngles;
+	pVehicle->GetAttachment(pVehicleData->m_nBarrelPivotAttachment, vTurretBase, vTurretBaseAngles);
+
+	vTurretBase = mWorldToGun * vTurretBase;
+
+	// Make everything be relative to the pivot...
+	vTarget -= vTurretBase;
+
+
+	// Now we've got the target vector in local space. Now just figure out what 
+	// the gun angles need to be to hit the target.
+	QAngle vWantedAngles;
+	VectorAngles( vTarget, vWantedAngles );
+
+	pVehicleData->m_flGunPitch = vWantedAngles[PITCH];
+	pVehicleData->m_flGunYaw = vWantedAngles[YAW];
+
+
+	// Place the player at the feet of the vehicle
+	Vector vStandAngles;
+
+	pVehicle->GetAttachmentLocal(pVehicleData->m_nStandAttachment, pMove->m_vecAbsOrigin, pMove->m_vecAngles);
+}
+
+
diff --git a/game/shared/tf2/tf_obj_manned_plasmagun_shared.h b/game/shared/tf2/tf_obj_manned_plasmagun_shared.h
new file mode 100644
index 0000000..396c0a4
--- /dev/null
+++ b/game/shared/tf2/tf_obj_manned_plasmagun_shared.h
@@ -0,0 +1,50 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: A stationary gun that players can man
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_OBJ_MANNED_PLASMAGUN_SHARED_H
+#define TF_OBJ_MANNED_PLASMAGUN_SHARED_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfvehicle.h"
+
+class CMoveData;
+
+enum MovementStyle_t
+{
+	MOVEMENT_STYLE_STANDARD = 0,
+	MOVEMENT_STYLE_BARREL_PIVOT = 1,
+	MOVEMENT_STYLE_SIMPLE = 2,
+};
+
+struct MannedPlasmagunData_t : public VehicleBaseMoveData_t
+{
+	float	m_flGunYaw;
+	float	m_flGunPitch;
+	float	m_flBarrelPitch;
+	float	m_flBarrelHeight;
+	int		m_nBarrelPivotAttachment;
+	int		m_nBarrelAttachment;
+	int		m_nStandAttachment;
+	MovementStyle_t	m_nMoveStyle;
+};
+
+
+class CObjectMannedPlasmagunMovement
+{
+public:
+	void ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove );
+	float GetMaxYaw() const;
+	float GetMinYaw() const;
+	float GetMaxPitch() const;
+};
+
+
+
+#endif // TF_OBJ_MANNED_PLASMAGUN_SHARED_H
diff --git a/game/shared/tf2/tf_playeranimstate.h b/game/shared/tf2/tf_playeranimstate.h
new file mode 100644
index 0000000..9dcd249
--- /dev/null
+++ b/game/shared/tf2/tf_playeranimstate.h
@@ -0,0 +1,76 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef TF_PLAYERANIMSTATE_H
+#define TF_PLAYERANIMSTATE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "studio.h"
+
+#if defined( CLIENT_DLL )
+#define CBaseTFPlayer C_BaseTFPlayer
+#endif
+
+class CPlayerAnimState
+{
+public:
+	enum
+	{
+		TURN_NONE = 0,
+		TURN_LEFT,
+		TURN_RIGHT
+	};
+
+						CPlayerAnimState( CBaseTFPlayer *outer );
+
+	Activity			BodyYawTranslateActivity( Activity activity );
+
+	void				Update();
+
+	const QAngle&		GetRenderAngles();
+				
+	void				GetPoseParameters( float poseParameter[MAXSTUDIOPOSEPARAM] );
+
+	CBaseTFPlayer		*GetOuter();
+
+private:
+	void				GetOuterAbsVelocity( Vector& vel );
+
+	int					ConvergeAngles( float goal,float maxrate, float dt, float& current );
+
+	void				EstimateYaw( void );
+	void				ComputePoseParam_BodyYaw( void );
+	void				ComputePoseParam_BodyPitch( void );
+	void				ComputePoseParam_BodyLookYaw( void );
+
+	void				ComputePlaybackRate();
+
+	CBaseTFPlayer		*m_pOuter;
+
+	float				m_flGaitYaw;
+	float				m_flStoredCycle;
+
+	// The following variables are used for tweaking the yaw of the upper body when standing still and
+	//  making sure that it smoothly blends in and out once the player starts moving
+	// Direction feet were facing when we stopped moving
+	float				m_flGoalFeetYaw;
+	float				m_flCurrentFeetYaw;
+
+	float				m_flCurrentTorsoYaw;
+
+	// To check if they are rotating in place
+	float				m_flLastYaw;
+	// Time when we stopped moving
+	float				m_flLastTurnTime;
+
+	// One of the above enums
+	int					m_nTurningInPlace;
+
+	QAngle				m_angRender;
+};
+#endif // TF_PLAYERANIMSTATE_H
diff --git a/game/shared/tf2/tf_reconvars.cpp b/game/shared/tf2/tf_reconvars.cpp
new file mode 100644
index 0000000..dc1e2eb
--- /dev/null
+++ b/game/shared/tf2/tf_reconvars.cpp
@@ -0,0 +1,64 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_reconvars.h"
+
+// FIXME: put these in a config file.
+CReconJetpackLevel g_ReconJetpackLevels[MAX_TF_TECHLEVELS] =
+{
+	{
+	0.35f,	// How fast the jetpack recharges.
+	1.0f,	// How fast the jetpack depletes.
+	-0.1f,	// When the jetpack is fully depleted, it snaps to this so the pilot sputters.
+	150,	// Fastest you can go upwards.
+	15		// How fast it accelerates.
+	},
+
+	{
+	0.55f,	// How fast the jetpack recharges.
+	0.75f,	// How fast the jetpack depletes.
+	-0.1f,	// When the jetpack is fully depleted, it snaps to this so the pilot sputters.
+	150,	// Fastest you can go upwards.
+	15		// How fast it accelerates.
+	},
+
+	{
+	0.55f,	// How fast the jetpack recharges.
+	0.55f,	// How fast the jetpack depletes.
+	-0.1f,	// When the jetpack is fully depleted, it snaps to this so the pilot sputters.
+	200,	// Fastest you can go upwards.
+	15		// How fast it accelerates.
+	},
+
+	{
+	0.75f,	// How fast the jetpack recharges.
+	0.35f,	// How fast the jetpack depletes.
+	-0.1f,	// When the jetpack is fully depleted, it snaps to this so the pilot sputters.
+	200,	// Fastest you can go upwards.
+	15		// How fast it accelerates.
+	},
+
+	// Not used
+
+	{
+	0.7f,	// How fast the jetpack recharges.
+	1.0f,	// How fast the jetpack depletes.
+	-0.1f,	// When the jetpack is fully depleted, it snaps to this so the pilot sputters.
+	130,	// Fastest you can go upwards.
+	15		// How fast it accelerates.
+	},
+
+	{
+	0.7f,	// How fast the jetpack recharges.
+	1.0f,	// How fast the jetpack depletes.
+	-0.1f,	// When the jetpack is fully depleted, it snaps to this so the pilot sputters.
+	130,	// Fastest you can go upwards.
+	15		// How fast it accelerates.
+	},
+};
+
+
diff --git a/game/shared/tf2/tf_reconvars.h b/game/shared/tf2/tf_reconvars.h
new file mode 100644
index 0000000..6d87840
--- /dev/null
+++ b/game/shared/tf2/tf_reconvars.h
@@ -0,0 +1,31 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_RECONVARS_H
+#define TF_RECONVARS_H
+#pragma once
+
+
+#include "techtree.h"
+
+
+// Jetpack vars for each tech level.
+class CReconJetpackLevel
+{
+public:
+	float m_RechargeRate;	// How fast the jetpack recharges.
+	float m_DepleteRate;	// How fast the jetpack depletes.
+	float m_NegSnap;		// When the jetpack is fully depleted, it snaps to this so the pilot sputters.
+	float m_MaxVerticalVel;	// Fastest you can go upwards.
+	float m_AccelRate;		// How fast it accelerates.
+};
+
+
+extern CReconJetpackLevel g_ReconJetpackLevels[MAX_TF_TECHLEVELS];
+
+
+#endif // TF_RECONVARS_H
diff --git a/game/shared/tf2/tf_shareddefs.cpp b/game/shared/tf2/tf_shareddefs.cpp
new file mode 100644
index 0000000..32d63be
--- /dev/null
+++ b/game/shared/tf2/tf_shareddefs.cpp
@@ -0,0 +1,605 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Data shared between the client & game dlls
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_shareddefs.h"
+#include "tier0/dbg.h"
+#include "basetypes.h"
+#include <KeyValues.h>
+
+#ifndef CLIENT_DLL
+
+	#include "tf_team.h"
+	#include "tf_class_commando.h"
+	#include "tf_class_defender.h"
+	#include "tf_class_escort.h"
+	#include "tf_class_infiltrator.h"
+	#include "tf_class_medic.h"
+	#include "tf_class_recon.h"
+	#include "tf_class_sniper.h"
+	#include "tf_class_support.h"
+	#include "tf_class_sapper.h"
+	#include "tf_class_pyro.h"
+
+#else
+
+	#include "c_tfteam.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"
+
+#define CTFTeam C_TFTeam
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"	
+
+ConVar inv_demo( "inv_demo","0", FCVAR_REPLICATED, "Invasion demo." );
+ConVar lod_effect_distance( "lod_effect_distance","3240000", FCVAR_REPLICATED, "Distance at which effects LOD." );
+ConVar tf_cheapobjects( "tf_cheapobjects","0", FCVAR_REPLICATED, "Set to 1 and all objects will cost 0" );
+
+
+//--------------------------------------------------------------------------
+// OBJECTS
+//--------------------------------------------------------------------------
+static int g_iClassInfo_Undecided[] =
+{
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Recon[] =
+{
+	OBJ_WAGON,
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Commando[] =
+{
+	OBJ_POWERPACK,
+	OBJ_VEHICLE_BOOST,
+	OBJ_DRAGONSTEETH,
+	OBJ_MANNED_MISSILELAUNCHER,
+	OBJ_SANDBAG_BUNKER,
+	OBJ_DRAGONSTEETH,
+
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Medic[] =
+{
+	OBJ_POWERPACK,
+	OBJ_SELFHEAL,
+	OBJ_BUFF_STATION,
+	OBJ_MANNED_PLASMAGUN,
+	OBJ_SANDBAG_BUNKER,
+	OBJ_BUNKER,
+	OBJ_DRAGONSTEETH,
+	OBJ_SHIELDWALL,
+
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Defender[] =
+{
+	OBJ_POWERPACK,
+	OBJ_SENTRYGUN_PLASMA,
+	OBJ_MANNED_MISSILELAUNCHER,
+	OBJ_BARBED_WIRE,
+	OBJ_DRAGONSTEETH,
+	OBJ_TOWER,
+	OBJ_SANDBAG_BUNKER,
+	OBJ_BUNKER,
+	OBJ_DRIVER_MACHINEGUN,
+	//OBJ_MORTAR,
+
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Sniper[] =
+{
+	OBJ_WAGON,
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Support[] =
+{
+	OBJ_WAGON,
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Escort[] =
+{
+	OBJ_SHIELDWALL,
+	OBJ_MANNED_SHIELD,
+	OBJ_SANDBAG_BUNKER,
+	OBJ_BUNKER,
+
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Sapper[] =
+{
+	OBJ_POWERPACK,
+	OBJ_DRAGONSTEETH,
+	OBJ_TOWER,
+	OBJ_SANDBAG_BUNKER,
+	OBJ_MANNED_PLASMAGUN,
+
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Infiltrator[] =
+{
+	OBJ_WAGON,
+	OBJ_LAST
+};
+
+static int g_iClassInfo_Pyro[] =
+{
+	OBJ_WAGON,
+	OBJ_LAST
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool IsObjectAnUpgrade( int iObjectType )
+{
+	return ( iObjectType >= OBJ_SELFHEAL && iObjectType < OBJ_BATTERING_RAM );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool IsObjectAVehicle( int iObjectType )
+{
+	return ( iObjectType >= OBJ_BATTERING_RAM && iObjectType < OBJ_TOWER );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool IsObjectADefensiveBuilding( int iObjectType )
+{
+	return ( iObjectType >= OBJ_TOWER );
+}
+
+//--------------------------------------------------------------------------
+// PLAYER CLASSES
+//--------------------------------------------------------------------------
+
+#if defined( CLIENT_DLL )
+	
+	#define DEFINE_PLAYERCLASS_ALLOC_FNS( className, iClass )				\
+		C_PlayerClass* AllocClient##className##( C_BaseTFPlayer *pPlayer )	\
+		{																	\
+			return new C_PlayerClass##className##( pPlayer );				\
+		}																	\
+		CPlayerClass* AllocServer##className##( CBaseTFPlayer *pPlayer )	\
+		{																	\
+			Assert( false );												\
+			return NULL;													\
+		}
+
+	#define GENERATE_PLAYERCLASS_INFO( className )		\
+		AllocClient##className##, AllocServer##className, NULL
+
+
+	// ------------------------------------------------------------------------------------- //
+	// DT_AllPlayerClasses recv table.
+	// ------------------------------------------------------------------------------------- //
+
+	BEGIN_RECV_TABLE_NOBASE( C_AllPlayerClasses, DT_AllPlayerClasses )
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_COMMANDO]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassCommandoData ),		DataTableRecvProxy_PointerDataTable ),
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_DEFENDER]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassDefenderData ),		DataTableRecvProxy_PointerDataTable ),
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_ESCORT]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassEscortData ),			DataTableRecvProxy_PointerDataTable ),
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_INFILTRATOR]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassInfiltratorData ), DataTableRecvProxy_PointerDataTable ),
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_MEDIC]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassMedicData ),				DataTableRecvProxy_PointerDataTable ),
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_RECON]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassReconData ),				DataTableRecvProxy_PointerDataTable ),
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_SNIPER]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassSniperData ),			DataTableRecvProxy_PointerDataTable ),
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_SUPPORT]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassSupportData ),			DataTableRecvProxy_PointerDataTable ),
+		RecvPropDataTable( RECVINFO_DT(m_pClasses[TFCLASS_SAPPER]), 0, &REFERENCE_RECV_TABLE( DT_PlayerClassSapperData ),	DataTableRecvProxy_PointerDataTable )
+	END_RECV_TABLE()
+
+#else		
+
+	#define DEFINE_PLAYERCLASS_ALLOC_FNS( className, iClass )				\
+		ConVar class_##className##_health( "class_" #className "_health", "0", FCVAR_NONE, #className "'s max health" ); \
+		C_PlayerClass* AllocClient##className##( C_BaseTFPlayer *pPlayer )	\
+		{																	\
+			Assert( false );												\
+			return NULL;													\
+		}																	\
+		CPlayerClass* AllocServer##className##( CBaseTFPlayer *pPlayer )	\
+		{																	\
+			return new CPlayerClass##className##( pPlayer, iClass );		\
+		}																	
+
+	#define GENERATE_PLAYERCLASS_INFO( className )		\
+		AllocClient##className##, AllocServer##className, &class_##className##_health
+
+
+	// ------------------------------------------------------------------------------------- //
+	// DT_AllPlayerClasses recv table.
+	// ------------------------------------------------------------------------------------- //
+
+	BEGIN_SEND_TABLE_NOBASE( CAllPlayerClasses, DT_AllPlayerClasses )
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_COMMANDO]), 	&REFERENCE_SEND_TABLE( DT_PlayerClassCommandoData ),	SendProxy_DataTablePtrToDataTable ),
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_DEFENDER]), 	&REFERENCE_SEND_TABLE( DT_PlayerClassDefenderData ),	SendProxy_DataTablePtrToDataTable ),
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_ESCORT]), 	&REFERENCE_SEND_TABLE( DT_PlayerClassEscortData ),		SendProxy_DataTablePtrToDataTable ),
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_INFILTRATOR]),&REFERENCE_SEND_TABLE( DT_PlayerClassInfiltratorData ), SendProxy_DataTablePtrToDataTable ),
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_MEDIC]),		&REFERENCE_SEND_TABLE( DT_PlayerClassMedicData ),		SendProxy_DataTablePtrToDataTable ),
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_RECON]),		&REFERENCE_SEND_TABLE( DT_PlayerClassReconData ),		SendProxy_DataTablePtrToDataTable ),
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_SNIPER]),		&REFERENCE_SEND_TABLE( DT_PlayerClassSniperData ),		SendProxy_DataTablePtrToDataTable ),
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_SUPPORT]),	&REFERENCE_SEND_TABLE( DT_PlayerClassSupportData ),		SendProxy_DataTablePtrToDataTable ),
+		SendPropDataTable( SENDINFO_DT(m_pClasses[TFCLASS_SAPPER]),		&REFERENCE_SEND_TABLE( DT_PlayerClassSapperData ),	SendProxy_DataTablePtrToDataTable )
+	END_SEND_TABLE()
+
+#endif
+
+
+
+// ------------------------------------------------------------------------------------- //
+// CAllPlayerClasses implementation.
+// ------------------------------------------------------------------------------------- //
+
+CAllPlayerClasses::CAllPlayerClasses( PLAYER_TYPE *pPlayer )
+{
+	for ( int i=0; i < TFCLASS_CLASS_COUNT; i++ )
+	{
+		m_pClasses[i] = NULL;
+
+#if defined( CLIENT_DLL )
+		if ( GetTFClassInfo( i )->m_pClientAlloc )
+			m_pClasses[i] = GetTFClassInfo( i )->m_pClientAlloc( pPlayer );
+#else
+		if ( GetTFClassInfo( i )->m_pServerAlloc )
+			m_pClasses[i] = GetTFClassInfo( i )->m_pServerAlloc( pPlayer );
+#endif
+	}
+}
+
+CAllPlayerClasses::~CAllPlayerClasses()
+{
+	for ( int i=0; i < TFCLASS_CLASS_COUNT; i++ )
+	{
+		delete m_pClasses[i];
+	}
+}
+
+PLAYER_CLASS_TYPE* CAllPlayerClasses::GetPlayerClass( int iClass )
+{
+	Assert( iClass >= 0 && iClass < TFCLASS_CLASS_COUNT );
+	return m_pClasses[iClass];
+}
+
+
+
+DEFINE_PLAYERCLASS_ALLOC_FNS( Recon,		TFCLASS_RECON );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Commando,		TFCLASS_COMMANDO );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Medic,		TFCLASS_MEDIC );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Defender,		TFCLASS_DEFENDER );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Sniper,		TFCLASS_SNIPER );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Support,		TFCLASS_SUPPORT );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Escort,		TFCLASS_ESCORT );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Sapper,	TFCLASS_SAPPER );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Infiltrator,	TFCLASS_INFILTRATOR );
+DEFINE_PLAYERCLASS_ALLOC_FNS( Pyro,			TFCLASS_PYRO );
+
+CTFClassInfo g_TFClassInfos[ TFCLASS_CLASS_COUNT ] =
+{
+	{ "Undecided",	g_iClassInfo_Undecided,		false, NULL, NULL, NULL },
+	{ "Recon",		g_iClassInfo_Recon,			false, GENERATE_PLAYERCLASS_INFO( Recon ) },
+	{ "Commando",	g_iClassInfo_Commando,		true, GENERATE_PLAYERCLASS_INFO( Commando ) },
+	{ "Medic",		g_iClassInfo_Medic,			true, GENERATE_PLAYERCLASS_INFO( Medic ) },
+	{ "Defender",	g_iClassInfo_Defender,		true, GENERATE_PLAYERCLASS_INFO( Defender ) },
+	{ "Sniper",		g_iClassInfo_Sniper,		false, GENERATE_PLAYERCLASS_INFO( Sniper ) },
+	{ "Support",	g_iClassInfo_Support,		false, GENERATE_PLAYERCLASS_INFO( Support ) },
+	{ "Escort",		g_iClassInfo_Escort,		true, GENERATE_PLAYERCLASS_INFO( Escort ) },
+	{ "Sapper",		g_iClassInfo_Sapper,		true, GENERATE_PLAYERCLASS_INFO( Sapper ) },
+	{ "Infiltrator",g_iClassInfo_Infiltrator,	false, GENERATE_PLAYERCLASS_INFO( Infiltrator ) },
+	{ "Pyro",		g_iClassInfo_Pyro,			false, GENERATE_PLAYERCLASS_INFO( Pyro ) }
+};
+
+
+const CTFClassInfo* GetTFClassInfo( int i )
+{
+	Assert( i >= 0 && i < TFCLASS_CLASS_COUNT );
+	return &g_TFClassInfos[i];
+}
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CObjectInfo tables.
+// ------------------------------------------------------------------------------------------------ //
+
+CObjectInfo::CObjectInfo( char *pObjectName )
+{
+	m_pObjectName = pObjectName;
+	m_pClassName = NULL;
+	m_flBuildTime = -9999;
+	m_nMaxObjects = -9999;
+	m_Cost = -9999;
+	m_CostMultiplierPerInstance = -999;
+	m_UpgradeCost = -9999;
+	m_MaxUpgradeLevel = -9999;
+	m_pBuilderWeaponName = NULL;
+	m_pBuilderPlacementString = NULL;
+	m_SelectionSlot = -9999;
+	m_SelectionPosition = -9999;
+	m_bSolidToPlayerMovement = false;
+	m_flSapperAttachTime = -9999;
+	m_pIconActive = NULL;
+}
+
+
+CObjectInfo::~CObjectInfo()
+{
+	delete [] m_pClassName;
+	delete [] m_pStatusName;
+	delete [] m_pBuilderWeaponName;
+	delete [] m_pBuilderPlacementString;
+	delete [] m_pIconActive;
+}
+
+
+CObjectInfo g_ObjectInfos[OBJ_LAST] =
+{
+	CObjectInfo( "OBJ_POWERPACK" ),
+	CObjectInfo( "OBJ_RESUPPLY" ),
+	CObjectInfo( "OBJ_SENTRYGUN_PLASMA" ),
+	CObjectInfo( "OBJ_SENTRYGUN_ROCKET_LAUNCHER" ),
+	CObjectInfo( "OBJ_SHIELDWALL" ),
+	CObjectInfo( "OBJ_RESOURCEPUMP" ),
+	CObjectInfo( "OBJ_RESPAWN_STATION" ),
+	CObjectInfo( "OBJ_RALLYFLAG" ),
+	CObjectInfo( "OBJ_MANNED_PLASMAGUN" ),
+	CObjectInfo( "OBJ_MANNED_MISSILELAUNCHER" ),
+	CObjectInfo( "OBJ_MANNED_SHIELD" ),
+	CObjectInfo( "OBJ_EMPGENERATOR" ),
+	CObjectInfo( "OBJ_BUFF_STATION" ),
+	CObjectInfo( "OBJ_BARBED_WIRE" ),
+	CObjectInfo( "OBJ_MCV_SELECTION_PANEL" ),
+	CObjectInfo( "OBJ_MAPDEFINED" ),
+	CObjectInfo( "OBJ_MORTAR" ),
+	CObjectInfo( "OBJ_SELFHEAL" ),
+	CObjectInfo( "OBJ_ARMOR_UPGRADE" ),
+	CObjectInfo( "OBJ_VEHICLE_BOOST" ),
+	CObjectInfo( "OBJ_EXPLOSIVES" ),
+	CObjectInfo( "OBJ_DRIVER_MACHINEGUN" ),
+	CObjectInfo( "OBJ_BATTERING_RAM" ),
+	CObjectInfo( "OBJ_SIEGE_TOWER" ),
+	CObjectInfo( "OBJ_WAGON" ),
+	CObjectInfo( "OBJ_FLATBED" ),
+	CObjectInfo( "OBJ_VEHICLE_MORTAR" ),
+	CObjectInfo( "OBJ_VEHICLE_TELEPORT_STATION" ),
+	CObjectInfo( "OBJ_VEHICLE_TANK" ),
+	CObjectInfo( "OBJ_VEHICLE_MOTORCYCLE" ),
+	CObjectInfo( "OBJ_WALKER_STRIDER" ),
+	CObjectInfo( "OBJ_WALKER_MINI_STRIDER" ),
+	CObjectInfo( "OBJ_TOWER" ),
+	CObjectInfo( "OBJ_TUNNEL" ),
+	CObjectInfo( "OBJ_SANDBAG_BUNKER" ),
+	CObjectInfo( "OBJ_BUNKER" ),
+	CObjectInfo( "OBJ_DRAGONSTEETH" ),
+};
+
+
+char* ReadAndAllocStringValue( KeyValues *pSub, const char *pName, const char *pFilename )
+{
+	const char *pValue = pSub->GetString( pName, NULL );
+	if ( !pValue )
+	{
+		DevWarning( "Can't get key value	'%s' from file '%s'.\n", pName, pFilename );
+		return "";
+	}
+
+	int len = Q_strlen( pValue ) + 1;
+	char *pAlloced = new char[ len ];
+	Assert( pAlloced );
+	Q_strncpy( pAlloced, pValue, len );
+	return pAlloced;
+}
+
+
+bool AreObjectInfosLoaded()
+{
+	return g_ObjectInfos[0].m_pClassName != NULL;
+}
+
+
+void LoadObjectInfos( IBaseFileSystem *pFileSystem )
+{
+	const char *pFilename = "scripts/objects.txt";
+
+	// Make sure this stuff hasn't already been loaded.
+	Assert( !AreObjectInfosLoaded() );
+
+	KeyValues *pValues = new KeyValues( "Object descriptions" );
+	if ( !pValues->LoadFromFile( pFileSystem, pFilename, "GAME" ) )
+	{
+		Error( "Can't open %s for object info.", pFilename );
+		pValues->deleteThis();
+		return;
+	}
+
+	// Now read each class's information in.
+	for ( int iObj=0; iObj < ARRAYSIZE( g_ObjectInfos ); iObj++ )
+	{
+		CObjectInfo *pInfo = &g_ObjectInfos[iObj];
+		KeyValues *pSub = pValues->FindKey( pInfo->m_pObjectName );
+		if ( !pSub )
+		{
+			Error( "Missing section '%s' from %s.", pInfo->m_pObjectName, pFilename );
+			pValues->deleteThis();
+			return;
+		}
+
+		// Read all the info in.
+		if ( (pInfo->m_flBuildTime = pSub->GetFloat( "BuildTime", -999 )) == -999 ||
+			 (pInfo->m_nMaxObjects = pSub->GetInt( "MaxObjects", -999 )) == -999 ||
+	 		 (pInfo->m_Cost = pSub->GetInt( "Cost", -999 )) == -999 ||
+			 (pInfo->m_CostMultiplierPerInstance = pSub->GetFloat( "CostMultiplier", -999 )) == -999 ||
+			 (pInfo->m_UpgradeCost = pSub->GetInt( "UpgradeCost", -999 )) == -999 ||
+			 (pInfo->m_MaxUpgradeLevel = pSub->GetInt( "MaxUpgradeLevel", -999 )) == -999 ||
+			 (pInfo->m_SelectionSlot = pSub->GetInt( "SelectionSlot", -999 )) == -999 ||
+			 (pInfo->m_SelectionPosition = pSub->GetInt( "SelectionPosition", -999 )) == -999 ||
+			 (pInfo->m_flSapperAttachTime = pSub->GetInt( "SapperAttachTime", -999 )) == -999 )
+		{
+			Error( "Missing data for object '%s' in %s.", pInfo->m_pObjectName, pFilename );
+			pValues->deleteThis();
+			return;
+		}
+
+		pInfo->m_pClassName = ReadAndAllocStringValue( pSub, "ClassName", pFilename );
+		pInfo->m_pStatusName = ReadAndAllocStringValue( pSub, "StatusName", pFilename );
+		pInfo->m_pBuilderWeaponName = ReadAndAllocStringValue( pSub, "BuilderWeaponName", pFilename );
+		pInfo->m_pBuilderPlacementString = ReadAndAllocStringValue( pSub, "BuilderPlacementString", pFilename );
+		pInfo->m_bSolidToPlayerMovement = pSub->GetInt( "SolidToPlayerMovement", 0 ) ? true : false;
+		pInfo->m_pIconActive = ReadAndAllocStringValue( pSub, "Icon", pFilename );
+	}
+
+	pValues->deleteThis();
+}
+
+
+const CObjectInfo* GetObjectInfo( int iObject )
+{
+	Assert( iObject >= 0 && iObject < OBJ_LAST );
+	Assert( AreObjectInfosLoaded() );
+	return &g_ObjectInfos[iObject];
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the specified class is allowed to build the specified object type
+//-----------------------------------------------------------------------------
+bool ClassCanBuild( int iClass, int iObjectType )
+{
+	for ( int i = 0; i < OBJ_LAST; i++ )
+	{
+		// Hit the end?
+		if ( g_TFClassInfos[iClass].m_pClassObjects[i] == OBJ_LAST )
+			return false;
+
+		// Found it?
+		if ( g_TFClassInfos[iClass].m_pClassObjects[i] == iObjectType )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the cost of another object of the specified type
+//			If bLast is set, return the cost of the last built object of the specified type
+//-----------------------------------------------------------------------------
+
+int CalculateObjectCost( int iObjectType, int iNumberOfObjects, int iTeam, bool bLast )
+{
+	if ( tf_cheapobjects.GetInt() )
+	{
+		return 0;
+	}
+
+	// Find out how much the next object should cost
+	if ( bLast )
+	{
+		iNumberOfObjects = MAX(0,iNumberOfObjects-1);
+	}
+
+	int iCost = GetObjectInfo( iObjectType )->m_Cost;
+
+	// If a cost is negative, it means the first object of that type is free, and then
+	// it counts up as normal, using the negative value.
+	if ( iCost < 0 )
+	{
+		if ( iNumberOfObjects == 0 )
+			return 0;
+		iCost *= -1;
+		iNumberOfObjects--;
+	}
+
+	// MCVs have special rules: The team's first one is always free
+	if ( iObjectType == OBJ_VEHICLE_TELEPORT_STATION )
+	{
+		CTFTeam *pTeam = (CTFTeam *)GetGlobalTeam(iTeam);
+		if ( pTeam && pTeam->GetNumObjects(OBJ_VEHICLE_TELEPORT_STATION) == 0 )
+		{
+			iCost = 0;
+		}
+	}
+
+	// Human objects cost less across the board
+	if ( iTeam == TEAM_HUMANS )
+	{
+		iCost = ( ((float)iCost) * 0.8 );
+	}
+
+	// Calculate the cost based upon the number of objects
+	for ( int i = 0; i < iNumberOfObjects; i++ )
+	{
+		iCost *= GetObjectInfo( iObjectType )->m_CostMultiplierPerInstance;
+	}
+
+	return iCost;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculate the cost to upgrade an object of a specific type
+//-----------------------------------------------------------------------------
+int	CalculateObjectUpgrade( int iObjectType, int iObjectLevel )
+{
+	// Max level?
+	if ( iObjectLevel >= GetObjectInfo( iObjectType )->m_MaxUpgradeLevel )
+		return 0;
+
+	int iCost = GetObjectInfo( iObjectType )->m_UpgradeCost;
+	for ( int i = 0; i < (iObjectLevel - 1); i++ )
+	{
+		iCost *= OBJECT_UPGRADE_COST_MULTIPLIER_PER_LEVEL;
+	}
+
+	return iCost;
+}
+
+//--------------------------------------------------------------------------
+// MORTAR
+//--------------------------------------------------------------------------
+// Names for each mortar ammo type
+char *MortarAmmoNames[ MA_LASTAMMOTYPE ] =
+{
+	"Normal Rounds",
+	//"Smoke Rounds",
+	"Cluster Rounds",
+	"Starburst Rounds",
+};
+
+// Techs needs for each mortar ammo type
+char *MortarAmmoTechs[ MA_LASTAMMOTYPE ] =
+{
+	"",
+	//"mortar_ammo_smoke",
+	"mortar_ammo_cluster",
+	"mortar_ammo_starburst",
+};
+
+// Max amounts of each mortar ammo type in a single mortar
+int	MortarAmmoMax[ MA_LASTAMMOTYPE ] = 
+{
+	-1,		// -1 is infinite ammo
+	//20,
+	20,
+	10,
+};
diff --git a/game/shared/tf2/tf_shareddefs.h b/game/shared/tf2/tf_shareddefs.h
new file mode 100644
index 0000000..310ac15
--- /dev/null
+++ b/game/shared/tf2/tf_shareddefs.h
@@ -0,0 +1,663 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_SHAREDDEFS_H
+#define TF_SHAREDDEFS_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define MAX_TF_TEAMS		4
+
+extern ConVar	inv_demo;
+extern ConVar	lod_effect_distance;
+
+#include "const.h"
+
+//--------------------------------------------------------------------------
+// Teams
+#define TEAM_HUMANS		1
+#define TEAM_ALIENS		2
+
+//--------------------------------------------------------------------------
+// TF player flags.
+#define	TF_PLAYER_HIDDEN		(1<<0)
+#define TF_PLAYER_DAMAGE_BOOST	(1<<1)
+#define TF_PLAYER_NUMFLAGS		2
+//--------------------------------------------------------------------------
+// Custom Kill types
+#define DMG_KILL_BULLRUSH	1
+
+
+//--------------
+// TF2 SPECIFIC	DAMAGE FLAGS
+//--------------
+#define DMG_EMP				(DMG_LASTGENERICFLAG<<1)	// Hit by EMP
+#define DMG_PROBE			(DMG_LASTGENERICFLAG<<2)	// Doing a shield-aware probe (heal guns, emp guns)
+
+
+//--------------------------------------------------------------------------
+// Zone states
+#define ZONE_FRIENDLY		1
+#define ZONE_ENEMY			2
+#define ZONE_CONTESTED		3
+
+//--------------------------------------------------------------------------
+// Loot state
+#define LOOT_NOT			0
+#define LOOT_CAPABLE		1
+#define LOOT_LOOTING		2
+
+//--------------------------------------------------------------------------
+// Powerups
+//--------------------------------------------------------------------------
+enum
+{
+	POWERUP_BOOST,		// Medic, buff station
+	POWERUP_EMP,		// Technician
+	POWERUP_RUSH,		// Rally flag
+	POWERUP_POWER,		// Object power
+	MAX_POWERUPS
+};
+
+#define	MAX_CABLE_CONNECTIONS 4
+
+//--------------------------------------------------------------------------
+// Acts
+//--------------------------------------------------------------------------
+#define MIN_ACT_OVERLAY_TIME		10.0
+
+// C/C_InfoAct spawnflags
+#define SF_ACT_INTERMISSION				1
+#define SF_ACT_WAITINGFORGAMESTART		2
+
+#define SF_ACT_BITS						2
+
+//--------------------------------------------------------------------------
+// Order types
+//--------------------------------------------------------------------------
+enum
+{
+	ORDER_NONE = 0,
+	ORDER_ATTACK,				// Enemy held resource zone, attack it and capture it
+	ORDER_DEFEND,				// Defend a resource zone we own
+	ORDER_CAPTURE,				// Resource zone not held by either team, capture it
+	ORDER_KILL,					// Kill a specific enemy player
+	ORDER_HEAL,					// Heal a specific friendly player
+	ORDER_BUILD,				// Order to build something.
+								// m_iStructure is one of the OBJ_ defines.
+								// If it's a sentry gun order, it's always OBJ_SENTRYGUN_PLASMA.
+	ORDER_REPAIR,				// Repair a built item.
+	ORDER_MORTAR_ATTACK,		// Build a mortar to shell an enemy object.
+	ORDER_ASSIST				// Assist a player who is under attack.
+};
+
+
+//--------------------------------------------------------------------------
+// Collision groups
+//--------------------------------------------------------------------------
+enum
+{
+	TFCOLLISION_GROUP_SHIELD = LAST_SHARED_COLLISION_GROUP,
+	TFCOLLISION_GROUP_WEAPON,
+	TFCOLLISION_GROUP_GRENADE,
+	TFCOLLISION_GROUP_RESOURCE_CHUNK,
+	// Combat objects (override for above)
+	TFCOLLISION_GROUP_COMBATOBJECT,
+	// Objects in general
+	TFCOLLISION_GROUP_OBJECT,
+	TFCOLLISION_GROUP_OBJECT_SOLIDTOPLAYERMOVEMENT,
+};
+
+//--------------------------------------------------------------------------
+// MAP DEFINED OBJECTS
+//--------------------------------------------------------------------------
+#define MAX_OBJ_CUSTOMNAME_SIZE		128
+
+//--------------------------------------------------------------------------
+// OBJECTS
+//--------------------------------------------------------------------------
+enum
+{
+	OBJ_POWERPACK=0,
+	OBJ_RESUPPLY,
+	OBJ_SENTRYGUN_PLASMA,			// Orders always refer to this type of sentry gun.
+	OBJ_SENTRYGUN_ROCKET_LAUNCHER,
+	OBJ_SHIELDWALL,
+	OBJ_RESOURCEPUMP,
+	OBJ_RESPAWN_STATION,
+	OBJ_RALLYFLAG,
+	OBJ_MANNED_PLASMAGUN,
+	OBJ_MANNED_MISSILELAUNCHER,
+	OBJ_MANNED_SHIELD,
+	OBJ_EMPGENERATOR,
+	OBJ_BUFF_STATION,
+	OBJ_BARBED_WIRE,
+	OBJ_MCV_SELECTION_PANEL,
+	OBJ_MAPDEFINED,
+	OBJ_MORTAR,
+	// ADD STANDARD OBJECTS HERE
+
+	// Upgrades
+	OBJ_SELFHEAL,
+	OBJ_ARMOR_UPGRADE,
+	OBJ_VEHICLE_BOOST,
+	OBJ_EXPLOSIVES,
+	OBJ_DRIVER_MACHINEGUN,
+	// ADD UPGRADES HERE
+
+	// Vehicles
+	OBJ_BATTERING_RAM,
+	OBJ_SIEGE_TOWER,
+	OBJ_WAGON,
+	OBJ_FLATBED,
+	OBJ_VEHICLE_MORTAR,
+	OBJ_VEHICLE_TELEPORT_STATION,
+	OBJ_VEHICLE_TANK,
+	OBJ_VEHICLE_MOTORCYCLE,
+	OBJ_WALKER_STRIDER,
+	OBJ_WALKER_MINI_STRIDER,
+	// ADD VEHICLES HERE
+
+	// Defensive buildings
+	OBJ_TOWER,
+	OBJ_TUNNEL,
+	OBJ_SANDBAG_BUNKER,
+	OBJ_BUNKER,
+	OBJ_DRAGONSTEETH,
+	// ADD DEFENSIVE-ONLY BUILDINGS HERE
+
+	// If you add a new object, you need to add it to the g_ObjectInfos array 
+	// in tf_shareddefs.cpp, and add it's data to the scripts/object.txt
+
+	OBJ_LAST,
+};
+
+#define OBJECT_COST_MULTIPLIER_PER_OBJECT			3
+#define OBJECT_UPGRADE_COST_MULTIPLIER_PER_LEVEL	3
+
+bool IsObjectAnUpgrade( int iObjectType );
+bool IsObjectAVehicle( int iObjectType );
+bool IsObjectADefensiveBuilding( int iObjectType );
+
+class CHudTexture;
+
+class CObjectInfo
+{
+public:
+	CObjectInfo( char *pObjectName );	
+	~CObjectInfo();
+
+	// This is initialized by the code and matched with a section in objects.txt
+	char	*m_pObjectName;
+
+	// This stuff all comes from objects.txt
+	char	*m_pClassName;					// Code classname (in LINK_ENTITY_TO_CLASS).
+	char	*m_pStatusName;					// Shows up when crosshairs are on the object.
+	float	m_flBuildTime;
+	int		m_nMaxObjects;					// Maximum number of objects per player
+	int		m_Cost;							// Base object resource cost
+	float	m_CostMultiplierPerInstance;	// Cost multiplier
+	int		m_UpgradeCost;					// Base object resource cost for upgrading
+	int		m_MaxUpgradeLevel;				// Max object upgrade level
+	char	*m_pBuilderWeaponName;			// Names shown for each object onscreen when using the builder weapon
+	char	*m_pBuilderPlacementString;		// String shown to player during placement of this object
+	int		m_SelectionSlot;				// Weapon selection slots for objects
+	int		m_SelectionPosition;			// Weapon selection positions for objects
+	bool	m_bSolidToPlayerMovement;
+	float	m_flSapperAttachTime;			// Time it takes to place a sapper on this object
+
+	// HUD weapon selection menu icon ( from hud_textures.txt )
+	char	*m_pIconActive;
+};
+
+// Loads the objects.txt script.
+class IBaseFileSystem;
+void LoadObjectInfos( IBaseFileSystem *pFileSystem );
+
+// Get a CObjectInfo from a TFOBJ_ define.
+const CObjectInfo* GetObjectInfo( int iObject );
+
+
+// Object utility funcs
+bool	ClassCanBuild( int iClass, int iObjectType );
+int		CalculateObjectCost( int iObjectType, int iNumberOfObjects, int iTeam, bool bLast = false );
+int		CalculateObjectUpgrade( int iObjectType, int iObjectLevel );
+
+//--------------------------------------------------------------------------
+// OBJECT FLAGS
+//--------------------------------------------------------------------------
+enum
+{
+	OF_SUPPRESS_APPEAR_ON_MINIMAP			= 0x0001,
+	OF_SUPPRESS_NOTIFY_UNDER_ATTACK			= 0x0002,
+	OF_SUPPRESS_VISIBLE_TO_TACTICAL			= 0x0004,
+	OF_ALLOW_REPEAT_PLACEMENT				= 0x0008,
+	OF_SUPPRESS_TECH_ANALYZER				= 0x0010,
+	OF_DONT_AUTO_REPAIR						= 0x0020,
+	OF_ALIGN_TO_GROUND						= 0x0040,		// Align my angles to match the ground underneath me
+	OF_DONT_PREVENT_BUILD_NEAR_OBJ			= 0x0080,		// Don't prevent building if there's another object nearby
+	OF_CAN_BE_PICKED_UP						= 0x0100,
+	OF_DOESNT_NEED_POWER					= 0x0200,		// Doesn't need power, even on the human team
+	OF_DOESNT_HAVE_A_MODEL					= 0x0400,		// It's built from map placed geometry
+	OF_MUST_BE_BUILT_IN_CONSTRUCTION_YARD	= 0x0800,
+	OF_MUST_BE_BUILT_IN_RESOURCE_ZONE		= 0x1000,
+	OF_MUST_BE_BUILT_ON_ATTACHMENT			= 0x2000,
+	OF_CANNOT_BE_DISMANTLED					= 0x4000,
+
+	OF_BIT_COUNT	= 15
+};
+
+
+//--------------------------------------------------------------------------
+// Builder "weapon" states
+//--------------------------------------------------------------------------
+enum 
+{
+	BS_IDLE = 0,
+	BS_SELECTING,
+	BS_PLACING,
+	BS_PLACING_INVALID,
+	BS_BUILDING,
+	BS_REPAIR,
+};
+
+
+//--------------------------------------------------------------------------
+// Builder object id...
+//--------------------------------------------------------------------------
+enum
+{
+	BUILDER_OBJECT_BITS = 8,
+	BUILDER_INVALID_OBJECT = ((1 << BUILDER_OBJECT_BITS) - 1)
+};
+
+// Analyzer state
+enum
+{
+	AS_INACTIVE = 0,
+	AS_SUBVERTING,
+	AS_ANALYZING
+};
+
+// Max number of objects a team can have
+#define MAX_OBJECTS_PER_TEAM	512
+#define MAX_OBJECTS_PER_PLAYER	64
+
+
+//--------------------------------------------------------------------------
+// BUILDING
+//--------------------------------------------------------------------------
+// Build checks will return one of these for a player
+enum
+{
+	CB_CAN_BUILD,			// Player is allowed to build this object
+	CB_NOT_RESEARCHED,		// Player's team hasn't researched this object
+	CB_LIMIT_REACHED,		// Player has reached the limit of the number of these objects allowed
+	CB_NEED_RESOURCES,		// Player doesn't have enough resources to build this object
+	CB_NEED_ADRENALIN,		// Commando doesn't have enough adrenalin to build a rally flag
+};
+
+//--------------------------------------------------------------------------
+// MORTAR
+//--------------------------------------------------------------------------
+// Mortar Firing States
+enum
+{
+	MORTAR_IDLE,
+	MORTAR_CHARGING_POWER,
+	MORTAR_CHARGING_ACCURACY,
+};
+
+// Mortar salvos
+#define MORTAR_SALVO_SIZE					5
+#define MORTAR_RELOAD_TIME					5.0
+
+// Mortar firing details
+#define	MORTAR_RANGE_MIN					1024
+#define MORTAR_RANGE_MAX_INITIAL			3000
+#define MORTAR_RANGE_MAX_UPGRADED			5000
+
+// Inaccuracy Data
+// These values are all max inaccuracies. The accuracy used is between 0 & Max, based upon how close the player gets to hitting
+// the fire button at the right time on the mortar firing slider bar.
+// Perpendicular-to-the-shot inaccuracy
+#define MORTAR_INACCURACY_MAX_INITIAL		0.85		// Percentage of distance that a mortar can be wide of the mark
+#define MORTAR_INACCURACY_MAX_UPGRADED		0.35		// Percentage of distance that a mortar can be wide of the mark
+// Distance inaccuracy
+#define MORTAR_DIST_INACCURACY				0.3			// Percentage of distance that the mortar can deviate
+
+// Mortar firing details
+#define MORTAR_CHARGE_POWER_RATE			1.5		// Time taken to hit full charge for power
+#define MORTAR_CHARGE_ACCURACY_RATE			1.25	// Time taken to hit perfect accuracy, given a half-power shot
+
+// Mortar ammo types
+enum MortarAmmoType
+{
+	MA_SHELL = 0,		// Normal mortar round
+	//MA_SMOKE,			// Smoke mortar round
+	MA_CLUSTER,			// Mirv mortar round
+	MA_STARBURST,		// Starburst / phosphorous mortar round
+
+	MA_LASTAMMOTYPE,
+};
+
+extern char *MortarAmmoNames[ MA_LASTAMMOTYPE ];
+extern char *MortarAmmoTechs[ MA_LASTAMMOTYPE ];
+extern int	MortarAmmoMax[ MA_LASTAMMOTYPE ];
+
+//--------------------------------------------------------------------------
+// ROCKET PACK
+//--------------------------------------------------------------------------
+#define RP_LOCK_TIME			3.0			// Time taken to lock onto a target
+
+//--------------------------------------------------------------------------
+// PARTICLE BEAM
+//--------------------------------------------------------------------------
+#define PB_RECHARGE_TIME		30.0		// Time taken to recharge the particle beam
+
+//--------------------------------------------------------------------------
+// PLASMA PROJECTILE TYPES
+//--------------------------------------------------------------------------
+enum
+{
+	PLASMATYPE_GATLING,
+	PLASMATYPE_EMP,
+	PLASMATYPE_GUIDED,
+	PLASMATYPE_GUIDED_NOTARGET,
+	PLASMATYPE_GUIDED_PARRIED,
+	PLASMATYPE_PLASMABALL,
+	PLASMATYPE_PLASMABALL_EXPLOSIVE,
+};
+
+#define	PLASMA_VELOCITY	( 2500 )
+
+//--------------------------------------------------------------------------
+// SCANNERS
+//--------------------------------------------------------------------------
+// Ranges
+#define SCANNER_RANGE			3000
+#define LOCAL_PLAYER_SCANNER_RANGE 1500
+
+//--------------------------------------------------------------------------
+// EMP
+//--------------------------------------------------------------------------
+#define EMP_HITSCAN_DURATION	5.0f
+
+//--------------------------------------------------------------------------
+// KNOCKDOWN
+//--------------------------------------------------------------------------
+// Knockdown blend in and out times
+#define KNOCKDOWN_BLEND_IN ( 0.3f )
+#define KNOCKDOWN_BLEND_OUT ( 0.5f )
+
+//--------------------------------------------------------------------------
+// THERMAL VISION
+//--------------------------------------------------------------------------
+// Thermal vision radius 
+// Players outside of this radius will not be sent to the local player
+// Player's inside start to fade at the startfade distance and are alpha'd out completely
+//  at the full radius
+#define THERMAL_VISION_RADIUS		( 1024.0f )
+#define THERMAL_VISION_STARTFADE	( THERMAL_VISION_RADIUS / 2.0f )
+
+//--------------------------------------------------------------------------
+// CAMO
+//--------------------------------------------------------------------------
+// Infiltrator Camouflage constants
+// # of seconds to go into/back into camo mode
+#define CAMO_ENABLETIME				( 3.0f )
+// # of seconds to remove
+#define CAMO_REMOVETIME				( 1.0f )
+// # of seconds to temporarily suppress
+#define CAMO_SUPPRESSTIME			( 1.0f )
+
+// Outside this, exclude from PVS
+#define CAMO_OUTER_RADIUS			( 2048.0f )
+// From here to outer, just alpha to 0
+#define CAMO_INNER_RADIUS			( CAMO_OUTER_RADIUS / 2.0f )
+// 75 % opacity at the inner_radius
+#define CAMO_INNER_ALPHA			( 192 )
+// From here to inner fade alpha again and start using invis effect
+#define CAMO_INVIS_RADIUS			( CAMO_INNER_RADIUS / 2.0f )
+
+// Infiltrator's phaseout duration
+#define INFILTRATOR_PHASEOUT_DURATION 30.0f
+// Time required to recharge
+#define INFILTRATOR_PHASEOUT_RECHARGETIME 30.0f
+
+// After sitting still, remove from tactical and minimiap starting at this time
+#define SNIPER_STATIONARY_FADESTART		2.5f
+// After sitting still, remove from tactical and minimiap starting and finishing here
+#define SNIPER_STATIONARY_FADEFINISH	7.5f
+
+// Infiltrator Camouflage constants
+// # of seconds to go into/back into camo mode
+#define CAMO_ENABLETIME				( 3.0f )
+// # of seconds to remove
+#define CAMO_REMOVETIME				( 1.0f )
+// # of seconds to temporarily suppress
+#define CAMO_SUPPRESSTIME			( 1.0f )
+
+// Outside this, exclude from PVS
+#define CAMO_OUTER_RADIUS			( 2048.0f )
+// From here to outer, just alpha to 0
+#define CAMO_INNER_RADIUS			( CAMO_OUTER_RADIUS / 2.0f )
+// 75 % opacity at the inner_radius
+#define CAMO_INNER_ALPHA			( 192 )
+// From here to inner fade alpha again and start using invis effect
+#define CAMO_INVIS_RADIUS			( CAMO_INNER_RADIUS / 2.0f )
+
+// Infiltrator's phaseout duration
+#define INFILTRATOR_PHASEOUT_DURATION 30.0f
+// Time required to recharge
+#define INFILTRATOR_PHASEOUT_RECHARGETIME 30.0f
+
+// After sitting still, remove from tactical and minimiap starting at this time
+#define SNIPER_STATIONARY_FADESTART		2.5f
+// After sitting still, remove from tactical and minimiap starting and finishing here
+#define SNIPER_STATIONARY_FADEFINISH	7.5f
+
+
+//--------------------------------------------------------------------------
+// ANIM STATEMACHINE DEFINES
+//--------------------------------------------------------------------------
+// Sniper deploy node
+enum
+{
+	SNIPER_DEPLOY_START = 1,
+	SNIPER_DEPLOY_IDLE,
+	SNIPER_DEPLOY_LEAVE,
+};
+
+//--------------------------------------------------------------------------
+// COMBAT SHIELD
+//--------------------------------------------------------------------------
+#define SHIELD_HITGROUP				1
+
+// Length after raising the shield during which releasing the shield will cause a parry
+#define PARRY_DETECTION_TIME			0.5
+// Length after a parry detection in which a parry can occur
+#define PARRY_OPPORTUNITY_LENGTH		0.3
+// Length after a parry has finished before I can do anything again
+#define PARRY_VULNERABLE_TIME			0.5
+
+//--------------------------------------------------------------------------
+// SENTRYGUNS
+//--------------------------------------------------------------------------
+// Time it takes to turtle / unturtle
+#define	SENTRY_TURTLE_TIME		2.0
+
+//--------------------------------------------------------------------------
+// PORTABLE POWER GENERATOR - BUFF STATION
+//--------------------------------------------------------------------------
+#define BUFF_STATION_MAX_PLAYERS		4
+#define BUFF_STATION_MAX_PLAYER_BITS	3
+#define BUFF_STATION_MAX_OBJECTS		3
+#define BUFF_STATION_MAX_OBJECT_BITS	2
+
+//--------------------------------------------------------------------------
+// ADRENALIN
+//--------------------------------------------------------------------------
+// Animation speed while in adrenalin
+#define ADRENALIN_ANIM_SPEED	1.5
+
+//--------------------------------------------------------------------------
+// PLASMA RIFLE
+//--------------------------------------------------------------------------
+#define MAX_RIFLE_POWER		3.0
+#define RIFLE_CHARGE_TIME	2.0
+
+//--------------------------------------------------------------------------
+// HUMAN POWER PACKS
+//--------------------------------------------------------------------------
+#define MAX_OBJECTS_PER_PACK		3
+
+//--------------------------------------------------------------------------
+// Rally flag defines
+//--------------------------------------------------------------------------
+
+#define RALLYFLAG_MINS				Vector(-20, -20, 0)
+#define RALLYFLAG_MAXS				Vector( 20,  20, 90)
+#define RALLYFLAG_RADIUS			512			
+#define RALLYFLAG_LIFETIME			30
+#define RALLYFLAG_RATE				2			// Rate at which it looks for friendlies to rally
+#define RALLYFLAG_ADRENALIN_TIME	5			// Time an adrenalin rush lasts
+#define RALLYFLAG_MODEL				"models/props/common/holo_banner/holo_banner.mdl"
+
+
+//--------------------------------------------------------------------------
+// Resupply-related stuff
+//--------------------------------------------------------------------------
+enum ResupplyBuyType_t
+{
+	RESUPPLY_BUY_AMMO = 0,
+	RESUPPLY_BUY_HEALTH,
+	RESUPPLY_BUY_GRENADES,
+	RESUPPLY_BUY_ALL,
+
+	RESUPPLY_BUY_TYPE_COUNT
+};
+
+#define RESUPPLY_HEALTH_COST			20
+#define RESUPPLY_AMMO_COST				5
+#define RESUPPLY_GRENADES_COST			25
+#define RESUPPLY_ALL_COST				50
+#define RESUPPLY_ROCKET_COST			100
+
+// Build animation events
+#define TF_OBJ_ENABLEBODYGROUP			6000
+#define TF_OBJ_DISABLEBODYGROUP			6001
+#define TF_OBJ_ENABLEALLBODYGROUPS		6002
+#define TF_OBJ_DISABLEALLBODYGROUPS		6003
+#define TF_OBJ_PLAYBUILDSOUND			6004
+
+//--------------------------------------------------------------------------
+// Class id
+//--------------------------------------------------------------------------
+
+#include "tfclassdata_shared.h"
+
+
+//--------------------------------------------------------------------------
+//
+// Class info tables. Any time a class is added or removed, this is where
+// generic data about each class is stored.
+//
+// The other things you need to add or remove for a class are:
+//
+// - A class derived from CPlayerClass.
+// - Class-specific accessors and data members functions in CTFMoveData.
+// - tf_gamemovement_chooser.h and CTFGameMovementChooser::CTFGameMovementChooser().
+// - DEFINE_PRED_TYPEDESCRIPTION_PTR entries in c_basetfplayer.cpp
+// - Add class_X_health in skill1.cfg.
+//
+//--------------------------------------------------------------------------
+
+class CPlayerClass;
+class CBaseTFPlayer;
+typedef CPlayerClass* (*PlayerClassAllocFn_Server)( CBaseTFPlayer *pPlayer );
+
+class C_PlayerClass;
+class C_BaseTFPlayer;
+typedef C_PlayerClass* (*PlayerClassAllocFn_Client)( C_BaseTFPlayer *pPlayer );
+
+
+class ConVar;
+
+
+class CTFClassInfo
+{
+public:
+	char		*m_pClassName;
+	
+	// Objects that each class can build
+	// OBJ_X, OBJ_Y ... terminated with OBJ_LAST.
+	int			*m_pClassObjects;
+
+	// This is just to make stats gathering easy... which classes are in the game right now?
+	bool		m_pCurrentlyActive;
+
+	PlayerClassAllocFn_Client	m_pClientAlloc;		// Only valid in client.dll
+	PlayerClassAllocFn_Server	m_pServerAlloc;		// Only valid in the game dll
+
+	ConVar		*m_pMaxHealthCVar;					// Only valid in game dll
+};
+
+const CTFClassInfo* GetTFClassInfo( int i );
+
+
+#if defined( CLIENT_DLL )
+
+	#define CAllPlayerClasses	C_AllPlayerClasses
+	#define PLAYER_CLASS_TYPE	C_PlayerClass
+	#define PLAYER_TYPE			C_BaseTFPlayer
+	
+	EXTERN_RECV_TABLE( DT_AllPlayerClasses );
+
+#else
+
+	#define PLAYER_CLASS_TYPE	CPlayerClass
+	#define PLAYER_TYPE			CBaseTFPlayer
+
+	EXTERN_SEND_TABLE( DT_AllPlayerClasses );
+
+#endif
+
+
+class PLAYER_TYPE;
+class PLAYER_CLASS_TYPE;
+
+//
+// The player object contains this on both the client and the server.
+// It holds a copy of each player class that can be used.
+//
+class CAllPlayerClasses // (#define as C_AllPlayerClasses on the client)
+{
+public:
+						CAllPlayerClasses( PLAYER_TYPE *pPlayer );
+						~CAllPlayerClasses();
+
+	PLAYER_CLASS_TYPE*	GetPlayerClass( int iClass );
+
+public:
+
+	PLAYER_CLASS_TYPE*	m_pClasses[ TFCLASS_CLASS_COUNT ];
+};
+
+//--------------------------------------------------------------------------
+// Impact data
+//--------------------------------------------------------------------------
+// This sucks
+#define NUM_WOOD_GIBS_SMALL		5
+extern const char *ImpactHurtGibs_Wood_Small[ NUM_WOOD_GIBS_SMALL ];
+
+#define PLAYER_MSG_PERSONAL_SHIELD	2
+
+#endif // TF_SHAREDDEFS_H
+
diff --git a/game/shared/tf2/tf_shield_mobile_shared.cpp b/game/shared/tf2/tf_shield_mobile_shared.cpp
new file mode 100644
index 0000000..e5d153b
--- /dev/null
+++ b/game/shared/tf2/tf_shield_mobile_shared.cpp
@@ -0,0 +1,850 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:			The Escort's Shield weapon
+//
+// $Revision: $
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "in_buttons.h"
+#include "tf_shieldshared.h"
+#include "tf_shareddefs.h"
+#include "baseentity_shared.h"
+
+#if defined( CLIENT_DLL )
+
+#include "c_shield.h"
+
+#else
+
+#include "tf_shield.h"
+#include "gamerules.h"
+
+#endif
+
+
+#if defined( CLIENT_DLL )
+#define CShieldMobile C_ShieldMobile
+#define CShield C_Shield
+#endif
+
+
+//-----------------------------------------------------------------------------
+// ConVars
+//-----------------------------------------------------------------------------
+ConVar	shield_mobile_power( "shield_mobile_power","30", FCVAR_REPLICATED, "Max power level of a escort's mobile projected shield." );
+ConVar	shield_mobile_recharge_delay( "shield_mobile_recharge_delay","0.1", FCVAR_REPLICATED, "Time after taking damage before mobile projected shields begin to recharge." );
+ConVar	shield_mobile_recharge_amount( "shield_mobile_recharge_amount","2", FCVAR_REPLICATED, "Power recharged each recharge tick for mobile projected shields." );
+ConVar	shield_mobile_recharge_time( "shield_mobile_recharge_time","0.5", FCVAR_REPLICATED, "Time between each recharge tick for mobile projected shields." );
+
+
+#define EMP_WAVE_AMPLITUDE 8.0f
+
+
+//-----------------------------------------------------------------------------
+// Mobile version of the shield 
+//-----------------------------------------------------------------------------
+class CShieldMobile;
+class CShieldMobileActiveVertList : public IActiveVertList
+{
+public:
+	void			Init( CShieldMobile *pShield );
+
+// IActiveVertList overrides.
+public:
+
+	virtual int		GetActiveVertState( int iVert );
+	virtual void	SetActiveVertState( int iVert, int bOn );
+
+private:
+	CShieldMobile	*m_pShield;
+};
+
+
+//-----------------------------------------------------------------------------
+// Mobile version of the shield 
+//-----------------------------------------------------------------------------
+class CShieldMobile : public CShield, public IEntityEnumerator
+{
+	DECLARE_CLASS( CShieldMobile, CShield );
+
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	friend class CShieldMobileActiveVertList;
+
+	CShieldMobile();
+
+#ifndef CLIENT_DLL
+	DECLARE_DATADESC();
+#endif
+
+public:
+	void Spawn( void );
+	void Precache( void );
+	void ShieldThink( void );
+	virtual void ClientThink();
+	virtual void SetAngularSpringConstant( float flConstant );
+	virtual void SetFrontDistance( float flDistance );
+	virtual void ComputeWorldSpaceSurroundingBox( Vector *pWorldMins, Vector *pWorldMaxs );
+
+	virtual void SetAttachmentIndex( int nAttachmentIndex );
+	virtual void SetEMPed( bool isEmped );
+	virtual void SetAlwaysOrient( bool bOrient );
+ 	virtual bool IsAlwaysOrienting( );
+
+	virtual int Width();
+	virtual int Height();
+	virtual bool IsPanelActive( int x, int y );
+	virtual const Vector& GetPoint( int x, int y );
+	virtual void SetCenterAngles( const QAngle& angles );
+	virtual void SetThetaPhi( float flTheta, float flPhi );
+
+	virtual void GetRenderBounds( Vector& mins, Vector& maxs );
+
+	// All predicted weapons need to implement and return true
+	virtual bool IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+public:
+#ifdef CLIENT_DLL
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+	virtual void GetBounds( Vector& mins, Vector& maxs );
+	virtual void AddEntity( );
+	virtual void GetShieldData( const Vector** ppVerts, float* pOpacity, float* pBlend );
+
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwnerEntity() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+#endif
+
+public:
+	// Inherited from IEntityEnumerator
+	virtual bool EnumEntity( IHandleEntity *pHandleEntity ); 
+
+private:
+	// Teleport!
+	void OnTeleported(  );
+	void SimulateShield( void );
+
+private:
+	struct SweepContext_t
+	{
+		SweepContext_t( const CBaseEntity *passentity, int collisionGroup ) :
+			m_Filter( passentity, collisionGroup ) {}
+
+		CTraceFilterSimple m_Filter;
+		Vector m_vecStartDelta;
+		Vector m_vecEndDelta;
+	};
+
+	enum
+	{
+		NUM_SUBDIVISIONS = 21,
+	};
+
+	enum
+	{
+		SHIELD_ORIENT_TO_OWNER = 0x2
+	};
+
+private:
+	CShieldMobile( const CShieldMobile & );
+	void ComputeBoundingBox( void );
+	void DetermineObstructions( );
+
+private:
+#ifdef CLIENT_DLL
+	// Is a particular panel an edge?
+	bool IsVertexValid( float s, float t ) const;
+	void PreRender( );
+#endif
+
+private:
+	CShieldMobileActiveVertList	m_VertList;
+	QAngle m_tmpAngLockedAngles;
+
+	// Bitfield indicating which vertices are active
+	CShieldEffect m_ShieldEffect;
+	CNetworkArray( unsigned char, m_pVertsActive, SHIELD_NUM_CONTROL_POINTS >> 3 );
+	CNetworkVar( unsigned char, m_ShieldState );
+	CNetworkVar( float, m_flFrontDistance );
+	CNetworkVar( QAngle, m_angLockedAngles );
+	SweepContext_t *m_pEnumCtx;
+
+	// This is the width + height of the shield, not the current theta, phi
+	CNetworkVar( float, m_flShieldTheta );
+	CNetworkVar( float, m_flShieldPhi );
+	CNetworkVar( float, m_flSpringConstant );
+	CNetworkVar( int, m_nAttachmentIndex );
+};
+
+
+//=============================================================================
+// Shield effect
+//=============================================================================
+#ifndef CLIENT_DLL
+
+BEGIN_DATADESC( CShieldMobile )
+
+	DEFINE_THINKFUNC( ShieldThink ),
+
+END_DATADESC()
+
+#endif
+
+LINK_ENTITY_TO_CLASS( shield_mobile, CShieldMobile );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( ShieldMobile, DT_ShieldMobile );
+
+// -------------------------------------------------------------------------------- //
+// This data only gets sent to clients that ARE this player entity.
+// -------------------------------------------------------------------------------- //
+
+BEGIN_NETWORK_TABLE(CShieldMobile, DT_ShieldMobile)
+#if !defined( CLIENT_DLL )
+	SendPropInt		(SENDINFO(m_ShieldState),	2, SPROP_UNSIGNED ),
+	SendPropArray(
+		SendPropInt( SENDINFO_ARRAY(m_pVertsActive), 8, SPROP_UNSIGNED),
+		m_pVertsActive),
+
+	SendPropFloat( SENDINFO(m_flFrontDistance), 0, SPROP_NOSCALE ),
+	SendPropFloat( SENDINFO(m_flShieldTheta), 0, SPROP_NOSCALE ),
+	SendPropFloat( SENDINFO(m_flShieldPhi), 0, SPROP_NOSCALE ),
+	SendPropFloat( SENDINFO(m_flSpringConstant), 0, SPROP_NOSCALE ),
+	SendPropQAngles( SENDINFO(m_angLockedAngles), 9 ),
+	SendPropInt	(SENDINFO(m_nAttachmentIndex),	10, SPROP_UNSIGNED ),
+
+	// Don't bother sending these, they are totally controlled by the think function
+	SendPropExclude( "DT_BaseEntity", "m_vecOrigin" ),
+	SendPropExclude( "DT_BaseEntity", "m_angAbsRotation[0]" ),
+	SendPropExclude( "DT_BaseEntity", "m_angAbsRotation[1]" ),
+	SendPropExclude( "DT_BaseEntity", "m_angAbsRotation[2]" ),
+
+#else
+	RecvPropInt( RECVINFO(m_ShieldState) ),
+	RecvPropArray( 
+		RecvPropInt( RECVINFO(m_pVertsActive[0])), 
+		m_pVertsActive 
+	),
+	RecvPropFloat( RECVINFO(m_flFrontDistance) ),
+	RecvPropFloat( RECVINFO(m_flShieldTheta) ),
+	RecvPropFloat( RECVINFO(m_flShieldPhi) ),
+	RecvPropFloat( RECVINFO(m_flSpringConstant) ),
+	RecvPropQAngles( RECVINFO( m_angLockedAngles ) ),
+	RecvPropInt	(RECVINFO(m_nAttachmentIndex) ),
+#endif
+
+END_NETWORK_TABLE()
+
+
+BEGIN_PREDICTION_DATA( CShieldMobile )
+
+	DEFINE_PRED_FIELD( m_ShieldState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flFrontDistance, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_angLockedAngles, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_TYPEDESCRIPTION( m_ShieldEffect, CShieldEffect ),
+	DEFINE_FIELD( m_nNextThinkTick, FIELD_INTEGER ),
+	DEFINE_FIELD( m_tmpAngLockedAngles, FIELD_VECTOR ),
+
+	// FIXME: How can I make this work now that I have an embedded collision property?
+//	DEFINE_PRED_FIELD( m_vecMins, FIELD_VECTOR, FTYPEDESC_INSENDTABLE | FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
+//	DEFINE_PRED_FIELD( m_vecMaxs, FIELD_VECTOR, FTYPEDESC_INSENDTABLE | FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
+
+#ifdef CLIENT_DLL
+	DEFINE_PRED_FIELD( m_vecNetworkOrigin, FIELD_VECTOR, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_angNetworkAngles, FIELD_VECTOR, FTYPEDESC_OVERRIDE | FTYPEDESC_NOERRORCHECK ),
+#endif
+
+END_PREDICTION_DATA()
+
+
+	
+//-----------------------------------------------------------------------------
+// CShieldMobileActiveVertList functions
+//-----------------------------------------------------------------------------
+void CShieldMobileActiveVertList::Init( CShieldMobile *pShield )
+{
+	m_pShield = pShield;
+}
+
+
+int CShieldMobileActiveVertList::GetActiveVertState( int iVert )
+{
+	return m_pShield->m_pVertsActive[iVert>>3] & (1 << (iVert & 7));
+}
+
+
+void CShieldMobileActiveVertList::SetActiveVertState( int iVert, int bOn )
+{
+	unsigned char val;	
+	if ( bOn )
+		val = m_pShield->m_pVertsActive[iVert>>3] | (1 << (iVert & 7));
+	else
+		val = m_pShield->m_pVertsActive[iVert>>3] & ~(1 << (iVert & 7));
+
+	m_pShield->m_pVertsActive.Set( iVert>>3, val );
+}
+
+
+//-----------------------------------------------------------------------------
+// constructor
+//-----------------------------------------------------------------------------
+CShieldMobile::CShieldMobile()
+{
+	SetPredictionEligible( true );
+	m_VertList.Init( this );
+	m_flFrontDistance = 0;
+	SetAngularSpringConstant( 2.0f );
+	SetThetaPhi( SHIELD_INITIAL_THETA, SHIELD_INITIAL_PHI ); 
+	m_nAttachmentIndex = 0;
+
+#ifdef CLIENT_DLL
+	InitShield( SHIELD_NUM_HORIZONTAL_POINTS, SHIELD_NUM_VERTICAL_POINTS, NUM_SUBDIVISIONS );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CShieldMobile::Precache( void )
+{
+	m_ShieldEffect.SetActiveVertexList( &m_VertList );
+	m_ShieldEffect.SetCollisionGroup( TFCOLLISION_GROUP_SHIELD );
+	BaseClass::Precache();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CShieldMobile::Spawn( void )
+{
+	Precache();
+	BaseClass::Spawn();
+	AddSolidFlags( FSOLID_FORCE_WORLD_ALIGNED );
+
+//	Assert( GetOwnerEntity() );
+	m_angLockedAngles.Set( vec3_angle );
+	m_tmpAngLockedAngles = vec3_angle;
+	m_ShieldEffect.Spawn(GetAbsOrigin(), GetAbsAngles());
+	m_ShieldState = 0;
+	SetAlwaysOrient( true );
+
+	// All movement occurs during think
+	SetMoveType( MOVETYPE_NONE );
+
+	SetThink( ShieldThink );
+	SetNextThink( gpGlobals->curtime + 0.01f );
+
+#ifdef CLIENT_DLL
+	// This goofiness is required so that non-predicted entities work
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CShieldMobile::SetAlwaysOrient( bool bOrient ) 
+{
+	if (bOrient)
+	{
+		m_ShieldState.Set( m_ShieldState.Get() | SHIELD_ORIENT_TO_OWNER );
+	}
+	else
+	{
+		m_angLockedAngles.Set( m_tmpAngLockedAngles );
+		m_ShieldState.Set( m_ShieldState.Get() & (~SHIELD_ORIENT_TO_OWNER) );
+	}
+}
+
+int CShieldMobile::Width()
+{ 
+	return SHIELD_NUM_HORIZONTAL_POINTS; 
+}
+
+int CShieldMobile::Height()
+{ 
+	return SHIELD_NUM_VERTICAL_POINTS; 
+}
+
+const Vector& CShieldMobile::GetPoint( int x, int y )
+{ 
+	return m_ShieldEffect.GetPoint( x, y ); 
+}
+
+	
+void CShieldMobile::SetAttachmentIndex( int nAttachmentIndex )
+{
+	m_nAttachmentIndex = nAttachmentIndex;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the render bounds
+//-----------------------------------------------------------------------------
+void CShieldMobile::GetRenderBounds( Vector& mins, Vector& maxs )
+{
+	mins = m_ShieldEffect.GetRenderMins();
+	maxs = m_ShieldEffect.GetRenderMaxs();
+}
+
+//-----------------------------------------------------------------------------
+// Return true if the panel is active 
+//-----------------------------------------------------------------------------
+bool CShieldMobile::IsPanelActive( int x, int y )
+{
+	return m_ShieldEffect.IsPanelActive(x, y);
+}
+
+
+//-----------------------------------------------------------------------------
+// Called when the shield is EMPed
+//-----------------------------------------------------------------------------
+void CShieldMobile::SetEMPed( bool isEmped )
+{
+	CShield::SetEMPed(isEmped);
+	if (IsEMPed())
+		m_ShieldState |= SHIELD_MOBILE_EMP;
+	else
+		m_ShieldState &= ~SHIELD_MOBILE_EMP;
+}
+
+
+//-----------------------------------------------------------------------------
+// Set the shield angles
+//-----------------------------------------------------------------------------
+void CShieldMobile::SetCenterAngles( const QAngle& angles )
+{
+	// The tmp ang locked angles is simply there to prevent unnecessary network traffic
+	m_tmpAngLockedAngles = angles;
+	if ( ( m_ShieldState.Get() & SHIELD_ORIENT_TO_OWNER ) == 0 ) 
+	{
+		m_angLockedAngles.Set( angles );
+	}
+}
+
+bool CShieldMobile::IsAlwaysOrienting( )
+{
+	return ( m_ShieldState.Get() & SHIELD_ORIENT_TO_OWNER ) != 0;
+}
+
+void CShieldMobile::SetAngularSpringConstant( float flConstant )
+{
+	m_flSpringConstant = flConstant;
+	m_ShieldEffect.SetAngularSpringConstant( flConstant );
+}
+
+void CShieldMobile::SetFrontDistance( float flDistance )
+{
+	m_flFrontDistance = flDistance;
+}
+
+void CShieldMobile::SetThetaPhi( float flTheta, float flPhi )
+{ 
+	// This sets the bounds of the shield; how tall + wide is it?
+	m_flShieldTheta = flTheta;
+	m_flShieldPhi = flPhi;
+	m_ShieldEffect.SetThetaPhi(flTheta, flPhi); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the shield bounding box
+//-----------------------------------------------------------------------------
+void CShieldMobile::ComputeBoundingBox( void )
+{
+	Vector mins, maxs;
+	m_ShieldEffect.ComputeBounds(mins, maxs); 
+	SetCollisionBounds( mins, maxs );
+}
+
+
+//-----------------------------------------------------------------------------
+// Compute world axis-aligned bounding box
+//-----------------------------------------------------------------------------
+void CShieldMobile::ComputeWorldSpaceSurroundingBox( Vector *pWorldMins, Vector *pWorldMaxs )
+{
+	// We don't use USE_SPECIFIED_BOUNDS because that would generate a ton of network traffic
+	VectorAdd( CollisionProp()->GetCollisionOrigin(), CollisionProp()->OBBMins(), *pWorldMins );
+	VectorAdd( CollisionProp()->GetCollisionOrigin(), CollisionProp()->OBBMaxs(), *pWorldMaxs );
+}
+
+
+//-----------------------------------------------------------------------------
+// Determines shield obstructions 
+//-----------------------------------------------------------------------------
+void CShieldMobile::DetermineObstructions( )
+{
+	m_ShieldEffect.ComputeVertexActivity();
+}
+
+
+//-----------------------------------------------------------------------------
+// Called by the enumerator call in ShieldThink 
+//-----------------------------------------------------------------------------
+bool CShieldMobile::EnumEntity( IHandleEntity *pHandleEntity )
+{
+#ifdef CLIENT_DLL
+	CBaseEntity *pOther = cl_entitylist->GetBaseEntityFromHandle( pHandleEntity->GetRefEHandle() );
+#else
+	CBaseEntity *pOther = gEntList.GetBaseEntity( pHandleEntity->GetRefEHandle() );
+#endif
+
+	if (!pOther)
+		return true;
+
+	// Blow off non-solid things
+	if ( !::IsSolid(pOther->GetSolid(), pOther->GetSolidFlags()) )
+		return true;
+
+	// No model, blow it off
+	if ( !pOther->GetModelIndex() )
+		return true;
+	
+	// Blow off point-sized things....
+	if ( pOther->IsPointSized() )
+		return true;
+
+	// Don't bother if we shouldn't be colliding with this guy...
+	if (!m_pEnumCtx->m_Filter.ShouldHitEntity( pOther, MASK_SOLID ))
+		return true;
+
+	// The shield is in its final position, so we're gonna have to determine the
+	// point of collision by working in the space of the final position....
+	// We do this by moving the obstruction by the relative movement amount...
+	Vector vecObsMins, vecObsMaxs, vecObsCenter;
+	pOther->CollisionProp()->WorldSpaceAABB( &vecObsMins, &vecObsMaxs );
+	vecObsCenter = (vecObsMins + vecObsMaxs) * 0.5f;
+	vecObsMins -= vecObsCenter;
+	vecObsMaxs -= vecObsCenter;
+
+	Vector vecStart, vecEnd;
+	VectorAdd( vecObsCenter, m_pEnumCtx->m_vecStartDelta, vecStart );
+	VectorAdd( vecStart, m_pEnumCtx->m_vecEndDelta, vecEnd );
+
+
+	Ray_t ray;
+	ray.Init( vecStart, vecEnd, vecObsMins, vecObsMaxs );
+
+	trace_t tr;
+	if (TestCollision( ray, pOther->PhysicsSolidMaskForEntity(), tr ))
+	{
+		// Ok, we got a collision. Let's indicate it happened...
+		// At the moment, we'll report the collision point as being on the
+		// surface of the shield in its final position, which is kind of bogus...
+		pOther->PhysicsImpact( this, tr );
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Update the shield position: 
+//-----------------------------------------------------------------------------
+void CShieldMobile::SimulateShield( void )
+{
+	CBaseEntity *owner = GetOwnerEntity();
+	Vector origin;
+	if ( owner )
+	{
+		if ( m_ShieldState & SHIELD_ORIENT_TO_OWNER ) 
+		{
+			if ( owner->IsPlayer() )
+			{
+				m_ShieldEffect.SetDesiredAngles( owner->EyeAngles() );
+			}
+			else
+			{
+				m_ShieldEffect.SetDesiredAngles( owner->GetAbsAngles() );
+			}
+		}
+		else
+		{
+			m_ShieldEffect.SetDesiredAngles( m_angLockedAngles );
+		}
+
+		if ( m_nAttachmentIndex == 0 )
+		{
+			origin = owner->EyePosition();
+		}
+		else
+		{
+			QAngle angles;
+			CBaseAnimating *pAnim = dynamic_cast<CBaseAnimating*>( owner );
+			if (pAnim)
+			{
+				pAnim->GetAttachment( m_nAttachmentIndex, origin, angles );
+			}
+			else
+			{
+				origin = owner->EyePosition();
+			}
+		}
+
+		if ( m_flFrontDistance )
+		{
+			Vector vForward;
+			AngleVectors( m_ShieldEffect.GetDesiredAngles(), &vForward );
+			origin += vForward * m_flFrontDistance;
+		}
+	}
+	else
+	{
+		Assert( 0 );
+		origin = vec3_origin;
+	}
+
+	// We pretty much always need to recompute this
+	CollisionProp()->MarkSurroundingBoundsDirty();
+
+	Vector vecOldOrigin = m_ShieldEffect.GetCurrentPosition();
+	
+	Vector vecDelta;
+	VectorSubtract( origin, vecOldOrigin, vecDelta );
+
+	float flMaxDist = 100 + m_flFrontDistance;
+	if (vecDelta.LengthSqr() > flMaxDist * flMaxDist )
+	{
+		OnTeleported();
+		return;
+	}
+
+	m_ShieldEffect.SetDesiredOrigin( origin );
+	m_ShieldEffect.Simulate(gpGlobals->frametime);
+	DetermineObstructions();
+	SetAbsOrigin( m_ShieldEffect.GetCurrentPosition() );
+	SetAbsAngles( m_ShieldEffect.GetCurrentAngles() );
+
+#ifdef CLIENT_DLL
+	// Necessary because we exclude the network origin
+	SetNetworkOrigin( m_ShieldEffect.GetCurrentPosition() );
+	SetNetworkAngles( m_ShieldEffect.GetCurrentAngles() );
+#endif
+
+	// Compute a composite bounding box surrounding the initial + new positions..
+	Vector vecCompositeMins = WorldAlignMins() + vecOldOrigin;
+	Vector vecCompositeMaxs = WorldAlignMaxs() + vecOldOrigin;
+
+	ComputeBoundingBox();
+
+	// Sweep the shield through the world + touch things it hits...
+	SweepContext_t ctx( this, GetCollisionGroup() );
+	VectorSubtract( GetAbsOrigin(), vecOldOrigin, ctx.m_vecStartDelta );
+
+	if (ctx.m_vecStartDelta != vec3_origin)
+	{
+		// FIXME: Brutal hack; needed because IntersectRayWithTriangle misses stuff
+		// especially with short rays; I'm not sure what to do about this.
+		// This basically simulates a shield thickness of 15 units
+		ctx.m_vecEndDelta = ctx.m_vecStartDelta;
+		VectorNormalize( ctx.m_vecEndDelta );
+		ctx.m_vecEndDelta *= -15.0f;
+
+		Vector vecNewMins = WorldAlignMins() + GetAbsOrigin();
+		Vector vecNewMaxs = WorldAlignMaxs() + GetAbsOrigin();
+		VectorMin( vecCompositeMins, vecNewMins, vecCompositeMins );
+		VectorMax( vecCompositeMaxs, vecNewMaxs, vecCompositeMaxs );
+
+		m_pEnumCtx = &ctx;
+		enginetrace->EnumerateEntities( vecCompositeMins, vecCompositeMaxs, this );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Update the shield position: 
+//-----------------------------------------------------------------------------
+void CShieldMobile::ShieldThink( void )
+{
+	SimulateShield();
+
+#ifdef CLIENT_DLL
+	m_ShieldEffect.ComputeControlPoints();
+	m_ShieldEffect.ComputePanelActivity();
+#endif
+
+	SetNextThink( gpGlobals->curtime + 0.01f );
+}
+
+void CShieldMobile::ClientThink()
+{
+#ifdef CLIENT_DLL
+	if ( GetPredictable() )
+		return;
+
+	SimulateShield();
+	m_ShieldEffect.ComputeControlPoints();
+	m_ShieldEffect.ComputePanelActivity();
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Teleport!
+//-----------------------------------------------------------------------------
+void CShieldMobile::OnTeleported(  )
+{
+	CBaseEntity *owner = GetOwnerEntity();
+	if (!owner)
+		return;
+
+	m_ShieldEffect.SetCurrentAngles( owner->GetAbsAngles() );
+
+	Vector origin;
+	origin = owner->EyePosition();
+	if ( m_flFrontDistance )
+	{
+		Vector vForward;
+		AngleVectors( m_ShieldEffect.GetCurrentAngles(), &vForward );
+		origin += vForward * m_flFrontDistance;
+	}
+
+	m_ShieldEffect.SetCurrentPosition( origin );
+}
+
+
+
+#ifdef CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Get this after the data changes
+//-----------------------------------------------------------------------------
+void CShieldMobile::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+	m_ShieldEffect.SetThetaPhi( m_flShieldTheta, m_flShieldPhi );
+	m_ShieldEffect.SetAngularSpringConstant( m_flSpringConstant );
+}
+
+
+//-----------------------------------------------------------------------------
+// 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, 0, 0 );
+
+				// 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 CShieldMobile::AddEntity( )
+{
+	BaseClass::AddEntity( );
+	PreRender();
+}
+
+
+//-----------------------------------------------------------------------------
+// Bounds computation
+//-----------------------------------------------------------------------------
+void CShieldMobile::GetBounds( Vector& mins, Vector& maxs )
+{
+	m_ShieldEffect.ComputeBounds( mins, maxs );
+}
+
+
+//-----------------------------------------------------------------------------
+// Gets at the control point data; who knows how it was made?
+//-----------------------------------------------------------------------------
+void CShieldMobile::GetShieldData( const Vector** 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;
+		}
+	}
+}
+
+
+#endif // CLIENT_DLL
+
+
+#ifndef CLIENT_DLL
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a mobile version of the shield
+//-----------------------------------------------------------------------------
+CShield *CreateMobileShield( CBaseEntity *owner, float flFrontDistance )
+{
+	CShieldMobile *pShield = (CShieldMobile*)CreateEntityByName("shield_mobile");
+
+	pShield->SetOwnerEntity( owner );
+	pShield->SetLocalAngles( owner->GetAbsAngles() );
+	pShield->SetFrontDistance( flFrontDistance );
+
+	// Start it in the right place
+	Vector vForward;
+	AngleVectors( owner->GetAbsAngles(), &vForward );
+	Vector vecOrigin = owner->EyePosition() + (vForward * flFrontDistance);
+	UTIL_SetOrigin( pShield, vecOrigin );
+
+	pShield->ChangeTeam( owner->GetTeamNumber() );
+	pShield->SetupRecharge( shield_mobile_power.GetFloat(), shield_mobile_recharge_delay.GetFloat(), shield_mobile_recharge_amount.GetFloat(), shield_mobile_recharge_time.GetFloat() );
+	pShield->Spawn();
+
+	return pShield;
+}
+
+#endif
+
diff --git a/game/shared/tf2/tf_shieldshared.cpp b/game/shared/tf2/tf_shieldshared.cpp
new file mode 100644
index 0000000..a7370ce
--- /dev/null
+++ b/game/shared/tf2/tf_shieldshared.cpp
@@ -0,0 +1,579 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:			The Escort's Shield weapon effect
+//
+// $Workfile:     $
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+
+#include "tf_shieldshared.h"
+#include "edict.h"
+#include "mathlib/vmatrix.h"
+#include "engine/IEngineTrace.h"
+
+#ifdef CLIENT_DLL
+#include "cdll_client_int.h"
+#else
+#include "gameinterface.h"
+#endif	
+
+
+	  
+BEGIN_PREDICTION_DATA_NO_BASE( CShieldEffect )
+
+	DEFINE_FIELD( m_TestPoint, FIELD_INTEGER ),
+	DEFINE_FIELD( m_Position, FIELD_VECTOR ),
+	DEFINE_FIELD( m_Velocity, FIELD_VECTOR ),
+	DEFINE_FIELD( m_CurrentAngles, FIELD_VECTOR ),
+	DEFINE_FIELD( m_Theta, FIELD_FLOAT ),
+	DEFINE_FIELD( m_Phi, FIELD_FLOAT ),
+	DEFINE_FIELD( m_ThetaVelocity, FIELD_FLOAT ),
+	DEFINE_FIELD( m_PhiVelocity, FIELD_FLOAT ),
+	DEFINE_FIELD( m_vecDesiredOrigin, FIELD_VECTOR ),
+	DEFINE_FIELD( m_angDesiredAngles, FIELD_VECTOR ),
+	DEFINE_FIELD( m_ShieldTheta, FIELD_FLOAT ),
+	DEFINE_FIELD( m_ShieldPhi, FIELD_FLOAT ),
+
+END_PREDICTION_DATA()
+
+
+
+//-----------------------------------------------------------------------------
+// constructor, destructor
+//-----------------------------------------------------------------------------
+CShieldEffect::CShieldEffect( )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// compute rest positions of the springs
+//-----------------------------------------------------------------------------
+void CShieldEffect::ComputeRestPositions()
+{
+	int i;
+
+	m_vecRenderMins.Init( FLT_MAX, FLT_MAX, FLT_MAX );
+	m_vecRenderMaxs.Init( -FLT_MAX, -FLT_MAX, -FLT_MAX );
+
+	// Set the initial directions and distances (in shield space)...
+	for	( i = 0; i < SHIELD_NUM_VERTICAL_POINTS; ++i)
+	{
+		// Choose phi centered at pi/2
+		float phi = (M_PI - m_ShieldPhi) * 0.5f + m_ShieldPhi * 
+			(float)i / (float)(SHIELD_NUM_VERTICAL_POINTS - 1);
+
+		for (int j = 0; j < SHIELD_NUM_HORIZONTAL_POINTS; ++j)
+		{
+			// Choose theta centered at pi/2 also (y, or forward axis)
+			float theta = (M_PI - m_ShieldTheta) * 0.5f + m_ShieldTheta * 
+				(float)j / (float)(SHIELD_NUM_HORIZONTAL_POINTS - 1);
+
+			int idx = i * SHIELD_NUM_HORIZONTAL_POINTS + j;
+
+			m_pFixedDirection[idx].x = cos(theta) * sin(phi);
+			m_pFixedDirection[idx].y = sin(theta) * sin(phi);
+			m_pFixedDirection[idx].z = cos(phi);
+
+			m_pFixedDirection[idx] *= m_RestLength;
+
+			VectorMin( m_vecRenderMins, m_pFixedDirection[idx], m_vecRenderMins );
+			VectorMax( m_vecRenderMaxs, m_pFixedDirection[idx], m_vecRenderMaxs );
+		}
+	}
+
+	// Compute box for fake volume testing
+	Vector dist = m_pFixedDirection[0] - m_pFixedDirection[1];
+	float l = dist.Length(); // * m_RestLength;
+	SetShieldPanelSize( Vector( -l * 0.25f, -l * 0.25f, -l * 0.25f), 
+		Vector( l * 0.25f, l * 0.25f, l * 0.25f) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets orientation + position
+//-----------------------------------------------------------------------------
+void CShieldEffect::SetDesiredOrigin( const Vector& origin )
+{
+	VectorCopy( origin, m_vecDesiredOrigin );
+}
+
+void CShieldEffect::SetDesiredAngles( const QAngle& angles )
+{
+	VectorCopy( angles, m_angDesiredAngles );
+}
+
+const QAngle& CShieldEffect::GetDesiredAngles() const
+{
+	return m_angDesiredAngles;
+}
+
+
+//-----------------------------------------------------------------------------
+// Gets a point...
+//-----------------------------------------------------------------------------
+const Vector& CShieldEffect::GetPoint( int x, int y ) const
+{
+	return m_pControlPoint[ x + y * SHIELD_NUM_HORIZONTAL_POINTS ];
+}
+
+const Vector& CShieldEffect::GetPoint( int i ) const
+{
+	return m_pControlPoint[ i ];
+}
+
+Vector& CShieldEffect::GetPoint( int i )
+{
+	return m_pControlPoint[ i ];
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets the collision group
+//-----------------------------------------------------------------------------
+void CShieldEffect::SetCollisionGroup( int group )
+{
+	m_CollisionGroup = group;
+}
+
+
+//-----------------------------------------------------------------------------
+// Hooks in active bits...
+//-----------------------------------------------------------------------------
+void CShieldEffect::SetActiveVertexList( IActiveVertList *pActiveVerts )
+{
+	m_pActiveVerts = pActiveVerts;
+
+	// No points are visible initially
+	for ( int i=0; i < SHIELD_VERTEX_BYTES*8; i++ )
+		m_pActiveVerts->SetActiveVertState( i, 0 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Is a particular vertex active?
+//-----------------------------------------------------------------------------
+bool CShieldEffect::IsVertexActive( int x, int y ) const
+{
+	if ((x < 0) || (y < 0) || (x >= SHIELD_NUM_HORIZONTAL_POINTS) ||
+		(y >= SHIELD_NUM_VERTICAL_POINTS))
+	{
+		return false;
+	}
+
+	int idx = x + (SHIELD_NUM_HORIZONTAL_POINTS) * y;
+	return m_pActiveVerts->GetActiveVertState( idx ) != 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Is a particular panel active?
+//-----------------------------------------------------------------------------
+bool CShieldEffect::IsPanelActive( int x, int y ) const
+{
+	if ((x < 0) || (y < 0) || (x >= SHIELD_HORIZONTAL_PANEL_COUNT) ||
+		(y >= SHIELD_VERTICAL_PANEL_COUNT))
+	{
+		return false;
+	}
+
+	int idx = x + (SHIELD_HORIZONTAL_PANEL_COUNT) * y;
+	return m_pActivePanels[idx];
+}
+
+
+//-----------------------------------------------------------------------------
+// Recompute whether the panels are active or not
+//-----------------------------------------------------------------------------
+void CShieldEffect::ComputePanelActivity()
+{
+	// Check neighbors to see how many squares we've got
+	for	( int i = 0; i < SHIELD_NUM_HORIZONTAL_POINTS - 1; ++i)
+	{
+		for ( int j = 0; j < SHIELD_NUM_VERTICAL_POINTS - 1; ++j)
+		{
+			int idx = i + j * (SHIELD_NUM_HORIZONTAL_POINTS - 1);
+
+			// Test the neighbors
+			m_pActivePanels[idx] = 
+				IsVertexActive( i, j ) ||
+				IsVertexActive( i+1, j ) ||
+				IsVertexActive( i, j+1 ) ||
+				IsVertexActive( i+1, j+1 );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Compute vertex activity
+//-----------------------------------------------------------------------------
+
+enum
+{
+	SHIELD_TESTS_PER_FRAME = 4
+};
+
+
+void CShieldEffect::ComputeVertexActivity()
+{
+	int i;
+	for ( i = 0; i < SHIELD_TESTS_PER_FRAME; ++i )
+	{
+		// Visit points in random order...
+		int pt = m_PointList[m_TestPoint];
+
+		// Collision test...
+		// Check a line that goes farther out than our current point...
+		// This will let us check for resting contact
+		trace_t tr;
+		CTraceFilterWorldOnly traceFilter;
+		UTIL_TraceHull( m_Position, m_pControlPoint[pt], 
+			m_PanelBoxMin, m_PanelBoxMax, MASK_SOLID_BRUSHONLY, &traceFilter, &tr );
+		bool isActive = (!tr.allsolid) && ( (tr.fraction - 1.0f) >= 0.0f );
+
+		m_pActiveVerts->SetActiveVertState( pt, isActive );
+
+		if (++m_TestPoint >= SHIELD_NUM_CONTROL_POINTS)
+			m_TestPoint = 0;
+
+	}
+
+	ComputePanelActivity();
+}
+
+
+//-----------------------------------------------------------------------------
+// bounding box for collision
+//-----------------------------------------------------------------------------
+void CShieldEffect::SetShieldPanelSize( Vector& mins, Vector& maxs )
+{
+	m_PanelBoxMin = mins;
+	m_PanelBoxMax = maxs;
+}
+
+
+//-----------------------------------------------------------------------------
+// bounding box for collision
+//-----------------------------------------------------------------------------
+void CShieldEffect::ComputeBounds( Vector& mins, Vector& maxs )
+{
+	VectorCopy( m_pControlPoint[0], mins );
+	VectorCopy( m_pControlPoint[0], maxs );
+
+	for (int i = 1; i < SHIELD_NUM_CONTROL_POINTS; ++i)
+	{
+		VectorMin( mins, m_pControlPoint[i], mins );
+		VectorMax( maxs, m_pControlPoint[i], maxs );
+	}
+
+	// Bounds are in local coords
+	mins -= m_Position;
+	maxs -= m_Position;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CShieldEffect::Precache( void )
+{
+	m_RestLength = 200.0;
+
+	m_SpringConstant = 30.0f;
+	m_DampConstant = 4.0f; 
+	m_ViscousDrag = 4.0f;
+	m_Mass = 1.0f;
+
+	m_AngularSpringConstant = 2.0f;
+	m_AngularViscousDrag = 4.0f;
+
+	SetThetaPhi( SHIELD_INITIAL_THETA, SHIELD_INITIAL_PHI );
+}
+
+
+//-----------------------------------------------------------------------------
+// Compute orientation matrix: 
+//-----------------------------------------------------------------------------
+void CShieldEffect::ComputeOrientationMatrix()
+{
+	// Generate the orientation matrix from theta and phi...
+	// X = forward direction, Y - left direction
+	Vector forward, left, up;
+	forward.x = cos(m_Theta) * sin(m_Phi);
+	forward.y = sin(m_Theta) * sin(m_Phi);
+	forward.z = cos(m_Phi);
+
+	left.x = -forward.y;
+	left.y = forward.x;
+	left.z = 0;
+
+	if ( VectorNormalize(left) == 0.0f )
+		left.Init( 0.0f, 1.0f, 0.0f );
+
+	CrossProduct( forward, left, up );
+
+	m_Orientation.SetBasisVectors( forward, left, up );
+
+	// Turn the current matrix into angles...
+	MatrixToAngles( m_Orientation, m_CurrentAngles ); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CShieldEffect::Spawn( const Vector& currentPosition, const QAngle& currentAngles )
+{
+	Precache();
+
+	VectorCopy( currentPosition, m_Position );
+	m_Velocity.Init();
+	
+	Vector forward;
+	AngleVectors( currentAngles, &forward, 0, 0 );
+	m_Phi = acos( forward.z );
+	m_Theta = atan2( forward.y, forward.x );
+	m_PhiVelocity = 0.0f;
+	m_ThetaVelocity = 0.0f;
+	ComputeOrientationMatrix();
+	VectorCopy( currentAngles, m_CurrentAngles );
+	VectorCopy( currentAngles, m_angDesiredAngles );
+
+	// No points are visible initially
+	memset( m_pActivePanels, 0, SHIELD_PANELS_COUNT );
+
+	m_TestPoint = 0;
+
+	// Choose random order to visit shield verts
+	int i;
+	for ( i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i )
+	{
+		m_PointList[i] = i;
+	}
+
+	for ( i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i )
+	{
+		int j = rand() % SHIELD_NUM_CONTROL_POINTS;
+		swap( m_PointList[i], m_PointList[j] ); 
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the opacity....
+//-----------------------------------------------------------------------------
+float CShieldEffect::ComputeOpacity( const Vector& pt, const Vector& center ) const
+{
+	float dist = pt.DistTo( center ) / m_RestLength;
+	if (dist > 1.0)
+		dist = 1.0f;
+	return 32 + (1.0 - dist) * 192;
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes control points
+//-----------------------------------------------------------------------------
+void CShieldEffect::ComputeControlPoints()
+{
+	Vector forward, right, up;
+	AngleVectors(m_CurrentAngles, &forward, &right, &up);
+
+	for ( int i = 0; i < SHIELD_NUM_CONTROL_POINTS; ++i )
+	{
+		// Compute the world space position...
+		VectorCopy( m_Position, m_pControlPoint[i] );
+		m_pControlPoint[i] += right * m_pFixedDirection[i].x;
+		m_pControlPoint[i] += up * m_pFixedDirection[i].z;
+		m_pControlPoint[i] += forward * m_pFixedDirection[i].y;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Gets the frustum size
+//-----------------------------------------------------------------------------
+void CShieldEffect::GetPanelSize( Vector& mins, Vector& maxs ) const
+{
+	VectorCopy( m_PanelBoxMin, mins );
+	VectorCopy( m_PanelBoxMax, maxs );
+}
+
+
+void CShieldEffect::SetAngularSpringConstant( float flConstant )
+{
+	m_AngularSpringConstant = flConstant;
+}
+
+
+//-----------------------------------------------------------------------------
+// Set the shield theta & phi
+//-----------------------------------------------------------------------------
+void CShieldEffect::SetThetaPhi( float flTheta, float flPhi )
+{
+	m_ShieldTheta = M_PI * flTheta / 180.0f;
+	m_ShieldPhi = M_PI * flPhi / 180.0f;
+
+	// Computes the rest positions
+	ComputeRestPositions();
+}
+
+
+//-----------------------------------------------------------------------------
+// The current position (computed by Simulate on the server)
+//-----------------------------------------------------------------------------
+const Vector& CShieldEffect::GetCurrentPosition()
+{
+	return m_Position;
+}
+
+void CShieldEffect::SetCurrentPosition( const Vector& pos )
+{
+	m_Position = pos;
+}
+
+void CShieldEffect::SetCurrentAngles( const QAngle& angles )
+{
+	VectorCopy( angles, m_CurrentAngles );
+}
+
+
+//-----------------------------------------------------------------------------
+// Simulate the center of mass 
+//-----------------------------------------------------------------------------
+void CShieldEffect::SimulateTranslation( float dt )
+{
+	// Hook's law for a damped spring:
+	// got two particles, a and b with positions xa and xb and velocities va and vb
+	// and l = xa - xb
+	// fa = -( ks * (|l| - r) + kd * (va - vb) dot (l) / |l|) * l/|l|
+	Vector dx, force;
+
+	// Case where we're connected to a control point
+	dx = m_Position - m_vecDesiredOrigin;
+
+	// rest condition
+	float length = dx.Length();
+	float speedSq = m_Velocity.LengthSqr(); 
+	if ((length < 1e-3) && (speedSq < 1e-6))
+		return;
+
+	// Compute force
+	if (length > 1e-3)
+		dx /= length;
+	else
+		dx.Init( 0, 0, 0 );
+
+	float springfactor = m_SpringConstant * length;
+	float dampfactor = m_DampConstant * DotProduct( m_Velocity, dx );
+	force = dx * -( springfactor + dampfactor );
+
+	assert( force.IsValid( ) );
+	Vector drag = m_Velocity * m_ViscousDrag;
+	force -= drag;
+
+	// Update position and velocity
+	m_Position += m_Velocity * dt; 
+	m_Velocity += force * dt / m_Mass;
+
+	assert( m_Velocity.IsValid( ) );
+
+	// clamp for stability
+	if (speedSq > 1e6)
+	{
+		m_Velocity *= 1e3 / sqrt(speedSq);
+	}
+}
+
+
+void CShieldEffect::SimulateRotation( float dt, const Vector& forward )
+{
+	// Here's a torsional spring for the angular component...
+	// A little tricky: We need to actually think about 2 torsional springs,
+	// one in thetha (x-y plane), and one in phi (z-plane)
+
+	float phi2 = acos( forward.z );
+	float dPhi = m_Phi - phi2;
+
+	float theta2 = atan2( forward.y, forward.x );
+	float dTheta = (m_Theta - theta2);
+	if (dTheta > M_PI)
+		dTheta -= 2 * M_PI;
+	else if (dTheta < -M_PI)
+		dTheta += 2 * M_PI;
+
+	// rest condition...
+	if ((fabs(dTheta) < 1e-3) && (fabs(m_ThetaVelocity) < 1e-6) && 
+		(fabs(dPhi) < 1e-3) && (fabs(m_PhiVelocity) < 1e-6))
+	{
+		return;
+	}
+
+	float springfactor = m_AngularSpringConstant * dTheta;
+	float torqueTheta = -springfactor; // + dampfactor);
+	torqueTheta -= m_ThetaVelocity * m_AngularViscousDrag;
+
+	springfactor = m_AngularSpringConstant * dPhi;
+	float torqueTPhi = -springfactor; // + dampfactor);
+	torqueTPhi -= m_PhiVelocity * m_AngularViscousDrag;
+
+	// Update position and velocity
+	m_Theta += m_ThetaVelocity * dt; 
+	m_ThetaVelocity += torqueTheta * dt;
+	m_Phi += m_PhiVelocity * dt; 
+	m_PhiVelocity += torqueTPhi * dt;
+
+	// clamp for stability
+	if (fabs(m_ThetaVelocity) > 1e2)
+	{
+		m_ThetaVelocity *= 1e2 / m_ThetaVelocity;
+	}
+	if (fabs(m_PhiVelocity) > 1e2)
+	{
+		m_PhiVelocity *= 1e2 / m_PhiVelocity;
+	}
+
+	ComputeOrientationMatrix();
+}
+
+
+//-----------------------------------------------------------------------------
+// Update the shield position: 
+//-----------------------------------------------------------------------------
+void CShieldEffect::Simulate( float dt )
+{
+	// We're gonna basically assume a spring connected to the center control point
+	Vector forward;
+	AngleVectors(m_angDesiredAngles, &forward, 0, 0);
+
+	// We've got two springs: a spring connected to the origin
+	// and a torsional spring connected to the view direction.
+
+	// Stiff spring, subdivide time....
+	dt /= SHIELD_TIME_SUBVISIBIONS;
+	for (int i = 0; i < SHIELD_TIME_SUBVISIBIONS; ++i)
+	{
+		SimulateTranslation( dt );
+		SimulateRotation( dt, forward );
+	}
+
+	ComputeControlPoints();
+}
+
+
+//-----------------------------------------------------------------------------
+// Determines shield obstructions 
+//-----------------------------------------------------------------------------
+static inline bool IsPointValid( bool* pActivePoints, int i, int j )
+{
+	// Here's the control point we're checking
+	int idx = j * SHIELD_NUM_HORIZONTAL_POINTS + i;
+
+	return pActivePoints[idx];
+}
+
+
+
diff --git a/game/shared/tf2/tf_shieldshared.h b/game/shared/tf2/tf_shieldshared.h
new file mode 100644
index 0000000..52ed301
--- /dev/null
+++ b/game/shared/tf2/tf_shieldshared.h
@@ -0,0 +1,262 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_SHIELD_SHARED_H
+#define TF_SHIELD_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "mathlib/mathlib.h"
+#include "mathlib/vector.h"
+#include "mathlib/vmatrix.h"
+#include "utlvector.h"
+#include "SheetSimulator.h"
+#include "predictable_entity.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Shield (mobile version)
+//-----------------------------------------------------------------------------
+enum
+{
+	SHIELD_NUM_HORIZONTAL_POINTS = 8,
+	SHIELD_NUM_VERTICAL_POINTS = 8,
+	SHIELD_NUM_CONTROL_POINTS = SHIELD_NUM_HORIZONTAL_POINTS * SHIELD_NUM_VERTICAL_POINTS,
+	SHIELD_INITIAL_THETA = 135,
+	SHIELD_INITIAL_PHI = 90,
+	SHIELD_HORIZONTAL_PANEL_COUNT = (SHIELD_NUM_HORIZONTAL_POINTS - 1),
+	SHIELD_VERTICAL_PANEL_COUNT = (SHIELD_NUM_VERTICAL_POINTS - 1),
+	SHIELD_PANELS_COUNT = (SHIELD_HORIZONTAL_PANEL_COUNT * SHIELD_VERTICAL_PANEL_COUNT),
+	SHIELD_VERTEX_BYTES = (SHIELD_NUM_CONTROL_POINTS + 7) >> 3,
+	SHIELD_TIME_SUBVISIBIONS = 2
+};
+
+//--------------------------------------------------------------------------
+// Mobile shield state flags
+//--------------------------------------------------------------------------
+enum
+{
+	SHIELD_MOBILE_EMP = 0x1
+};
+
+
+//--------------------------------------------------------------------------
+// Shield grenade state
+//--------------------------------------------------------------------------
+enum
+{
+	SHIELD_FLAT_EMP = 0x1,
+	SHIELD_FLAT_INACTIVE = 0x2
+};
+
+enum
+{
+	SHIELD_FLAT_SHUTDOWN_TIME = 1
+};
+
+enum
+{
+	SHIELD_GRENADE_WIDTH = 150,
+	SHIELD_GRENADE_HEIGHT = 150,
+};
+
+
+#define SHIELD_DAMAGE_CHANGE_TIME	1.5f
+
+
+//-----------------------------------------------------------------------------
+// Amount of time it takes to fade the shield in or out due to EMP 
+//-----------------------------------------------------------------------------
+#define SHIELD_EMP_FADE_TIME 0.7f
+
+
+//-----------------------------------------------------------------------------
+// Amount of time it takes a point to wobble when EMPed
+//-----------------------------------------------------------------------------
+#define SHIELD_EMP_WOBBLE_TIME 0.1f
+
+
+//-----------------------------------------------------------------------------
+// Methods we must install into the effect
+//-----------------------------------------------------------------------------
+class IActiveVertList
+{
+public:
+	virtual int		GetActiveVertState( int iVert ) = 0;
+	virtual void	SetActiveVertState( int iVert, int bOn ) = 0;
+};
+
+
+class CShieldEffect
+{
+	DECLARE_CLASS_NOBASE( CShieldEffect );
+	DECLARE_PREDICTABLE();
+
+public:
+	CShieldEffect();
+
+	void Precache();
+	void Spawn(const Vector& currentPosition, const QAngle& currentAngles);
+
+	// Sets the collision group
+	void SetCollisionGroup( int group );
+
+	// Computes the opacity....
+	float ComputeOpacity( const Vector& pt, const Vector& center ) const;
+
+	// Computes the bounds
+	void ComputeBounds( Vector& mins, Vector& maxs );
+
+	// Simulation
+	void Simulate( float dt );
+
+	// Sets desired orientation + position
+	void SetDesiredOrigin( const Vector& origin );
+	void SetDesiredAngles( const QAngle& angles );
+	const QAngle& GetDesiredAngles() const;
+
+	// Hooks in active bits...
+	void SetActiveVertexList( IActiveVertList *pActiveVerts );
+
+	// Gets a point...
+	const Vector& GetPoint( int x, int y ) const;
+	const Vector& GetPoint( int i ) const;
+	Vector& GetPoint( int i );
+
+	// Computes control points
+	void ComputeControlPoints();
+
+	// The current angles (computed by Simulate on the server)
+	const QAngle& GetCurrentAngles() const;
+	void SetCurrentAngles( const QAngle& angles);
+
+	// The current position (computed by Simulate on the server)
+	const Vector& GetCurrentPosition();
+	void SetCurrentPosition( const Vector& pos );
+
+	// Compute vertex activity
+	void ComputeVertexActivity();
+
+	// Recompute whether the panels are active or not
+	void ComputePanelActivity();
+
+	// Is a particular vertex active?
+	bool IsVertexActive( int x, int y ) const;
+
+	// Is a particular panel active?
+	bool IsPanelActive( int x, int y ) const;
+
+	// Gets a control point (for collision)
+	const Vector& GetControlPoint( int i ) const { return m_pControlPoint[i]; }
+
+	// Returns the panel size (for collision testing)
+	void GetPanelSize( Vector& mins, Vector& maxs ) const;
+
+	// Change the angular spring constant. This affects how fast the shield rotates to face the angles
+	// given in SetAngles. Higher numbers are more responsive, but if you go too high (around 40), it will
+	// jump past the specified angles and wiggle a little bit.
+	void SetAngularSpringConstant( float flConstant );
+
+	// Set the shield theta & phi
+	void SetThetaPhi( float flTheta, float flPhi );
+
+	// Returns the render bounds
+	const Vector& GetRenderMins() const;
+	const Vector& GetRenderMaxs() const;
+
+private:
+	// Simulation set up
+	void ComputeRestPositions();
+	void SetShieldPanelSize( Vector& mins, Vector& maxs );
+	void SimulateTranslation( float dt );
+	void SimulateRotation( float dt, const Vector& forward );
+	void ComputeOrientationMatrix();
+
+	float m_RestLength;
+	float m_PlaneDist;
+	float m_ShieldTheta;
+	float m_ShieldPhi;
+
+	// Spring constants
+	float m_SpringConstant;
+	float m_DampConstant;
+	float m_ViscousDrag;
+	float m_Mass;
+
+	float m_AngularSpringConstant;
+	float m_AngularViscousDrag;
+
+	// collision group
+	int		m_CollisionGroup;
+
+	// Directions of the control points in shield space
+	Vector	m_pFixedDirection[SHIELD_NUM_CONTROL_POINTS];
+
+	// Position of the control points in world space
+	Vector	m_pControlPoint[SHIELD_NUM_CONTROL_POINTS];
+
+	// Bitfield indicating which vertices are active
+	IActiveVertList *m_pActiveVerts;
+
+	// Bitfield indicating which panels are active
+	bool	m_pActivePanels[SHIELD_PANELS_COUNT];
+
+	// Which point on the shield to test next
+	int		m_TestPoint;
+	int		m_PointList[SHIELD_NUM_CONTROL_POINTS];
+
+	// desired position + orientation
+	Vector	m_vecDesiredOrigin;
+	QAngle	m_angDesiredAngles;
+
+	// collision box
+	Vector  m_PanelBoxMin;
+	Vector	m_PanelBoxMax;
+
+	// Render bounds (shield space)
+	Vector  m_vecRenderMins;
+	Vector	m_vecRenderMaxs;
+
+	// Actual center position (relative to m_Origin)
+	// + velocity (world space)
+	Vector	m_Position;
+	Vector	m_Velocity;
+
+	// our current orientation....
+	QAngle  m_CurrentAngles;
+	VMatrix	m_Orientation;
+	float	m_Theta;
+	float	m_Phi;
+	float	m_ThetaVelocity;
+	float	m_PhiVelocity;
+};
+
+
+//-----------------------------------------------------------------------------
+// Inline methods
+//-----------------------------------------------------------------------------
+inline const QAngle& CShieldEffect::GetCurrentAngles() const 
+{ 
+	return m_CurrentAngles; 
+}
+
+//-----------------------------------------------------------------------------
+// Returns the render bounds
+//-----------------------------------------------------------------------------
+inline const Vector& CShieldEffect::GetRenderMins() const
+{
+	return m_vecRenderMins;
+}
+
+inline const Vector& CShieldEffect::GetRenderMaxs() const
+{
+	return m_vecRenderMaxs;
+}
+
+
+#endif // TF_SHIELD_SHARED_H
diff --git a/game/shared/tf2/tf_tacticalmap.cpp b/game/shared/tf2/tf_tacticalmap.cpp
new file mode 100644
index 0000000..19e2d42
--- /dev/null
+++ b/game/shared/tf2/tf_tacticalmap.cpp
@@ -0,0 +1,122 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Shared stuff for the Tactical map
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+
+// Unfortunate hack.
+// Needed to cycle through the player & radar scanner entities in both the client and game dlls
+#ifdef CLIENT_DLL
+
+// Client DLL functions
+#include "c_team.h"
+#include "c_tfteam.h"
+#include "c_basetfplayer.h"
+#include "C_BaseObject.h"
+
+static inline bool IsPlayerCamoed( int iEntIndex )
+{
+	C_BaseTFPlayer* pPlayer = (C_BaseTFPlayer*)ClientEntityList().GetClientEntity(iEntIndex);
+	if (!pPlayer)
+		return false;
+
+	return pPlayer->IsCamouflaged();
+}
+
+static inline bool IsPlayerVisible( int iEntIndex )
+{
+	C_BaseTFPlayer* pPlayer = (C_BaseTFPlayer*)ClientEntityList().GetClientEntity(iEntIndex);
+	if (!pPlayer)
+		return false;
+
+	return pPlayer->GetClass() != TFCLASS_UNDECIDED;
+}
+
+static inline bool IsEntityAnObject( int iEntIndex )
+{
+	IClientNetworkable *pEnt = ClientEntityList().GetClientEntity(iEntIndex);
+	return dynamic_cast<C_BaseObject*>(pEnt) != 0;
+}
+
+#else
+
+// Game DLL functions
+#include "team.h"
+#include "tf_team.h"
+#include "tf_player.h"
+
+static inline bool IsPlayerCamoed( int iEntIndex )
+{
+	CBaseTFPlayer* pPlayer = (CBaseTFPlayer *)CBaseEntity::Instance( engine->PEntityOfEntIndex( iEntIndex ) );
+	if (!pPlayer)
+		return false;
+	return pPlayer->IsCamouflaged();
+}
+
+static inline bool IsPlayerVisible( int iEntIndex )
+{
+	CBaseTFPlayer* pPlayer = (CBaseTFPlayer *)CBaseEntity::Instance( engine->PEntityOfEntIndex( iEntIndex ) );
+	if (!pPlayer)
+		return false;
+	return pPlayer->PlayerClass() != TFCLASS_UNDECIDED;
+}
+
+static inline bool IsEntityAnObject( int iEntIndex )
+{
+	CBaseEntity* pEnt = CBaseEntity::Instance( engine->PEntityOfEntIndex( iEntIndex ) );
+	CBaseObject *pObject = dynamic_cast<CBaseObject*>(pEnt);
+	if (!pObject)
+		return false;
+
+	// Don't bother with boring ones... they're boring!
+	return ((pObject->GetObjectFlags( ) & OF_SUPPRESS_VISIBLE_TO_TACTICAL) == 0);
+}
+
+#endif
+
+// Visibility defines
+#define PLAYER_VISIBILITY_DISTANCE			2000		// Distance around a player that's exposed on the tactical map
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the entity is visible on this player's tactical map
+//-----------------------------------------------------------------------------
+bool IsEntityVisibleToTactical( int iLocalTeamNumber, int iLocalTeamPlayers, 
+	int iLocalTeamObjects, int entIndex, const char *pEntName, int iEntTeamNumber, const Vector &entOrigin )
+{
+	// Resource zones are always visible
+	if ( !strcmp( pEntName, "trigger_resourcezone") )
+		return true;
+
+	// Tunnels are always visible
+	if ( !strcmp( pEntName, "obj_tunnel") || !strcmp( pEntName, "obj_tunnel_prop") )
+		return true;
+
+	// Fixed shields are never visible
+	if ( !strcmp( pEntName, "shield") )
+		return false;
+
+	// NOTE: If you're looking for various object types, fix the ugly hack
+	// in mapdata.cpp!!
+	if ( iLocalTeamNumber == iEntTeamNumber )
+	{
+		// Objects are always visible to their team
+		if (IsEntityAnObject( entIndex ))
+			return true;
+
+		// Players are always visible to their team
+		if (!Q_strncmp( pEntName, "player", 7) )
+			return true;
+
+		// Resource collectors are always visible to their team
+		if ( !strcmp( pEntName, "npc_rescollector_aerial") )
+			return true;
+	}
+
+	return false;
+}
+
+
+
diff --git a/game/shared/tf2/tf_usermessages.cpp b/game/shared/tf2/tf_usermessages.cpp
new file mode 100644
index 0000000..15266d2
--- /dev/null
+++ b/game/shared/tf2/tf_usermessages.cpp
@@ -0,0 +1,43 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "usermessages.h"
+#include "shake.h"
+#include "voice_gamemgr.h"
+
+void RegisterUserMessages( void )
+{
+	usermessages->Register( "Geiger", 1 );
+	usermessages->Register( "Train", 1 );
+	usermessages->Register( "HudText", -1 );
+	usermessages->Register( "SayText", -1 );
+	usermessages->Register( "TextMsg", -1 );
+	usermessages->Register( "HudMsg", -1 );
+	usermessages->Register( "ResetHUD", 1 );		// called every respawn
+	usermessages->Register( "GameTitle", 0 );
+	usermessages->Register( "ItemPickup", -1 );
+	usermessages->Register( "ShowMenu", -1 );
+	usermessages->Register( "Shake", 13 );
+	usermessages->Register( "Fade", 10 );
+	usermessages->Register( "VGUIMenu", -1 );	// Show VGUI menu
+
+	usermessages->Register( "VoiceMask", VOICE_MAX_PLAYERS_DW*4 * 2 + 1 );
+	usermessages->Register( "RequestState", 0 );
+	usermessages->Register( "CloseCaption", -1 ); // Show a caption (by string id number)(duration in 10th of a second)
+	usermessages->Register( "HintText", -1 );
+	usermessages->Register( "AmmoDenied", 2 );
+
+	// TF User messages
+	usermessages->Register( "Damage", 13 );
+	usermessages->Register( "Accuracy", 2 );
+	usermessages->Register( "ZoneState", 1 );
+	usermessages->Register( "Technology", -1 );
+	usermessages->Register( "ActBegin", -1 );
+	usermessages->Register( "ActEnd", -1 );
+	usermessages->Register( "MinimapPulse", -1 );
+	usermessages->Register( "PickupRes", 1 );
+}
\ No newline at end of file
diff --git a/game/shared/tf2/tf_vehicleshared.h b/game/shared/tf2/tf_vehicleshared.h
new file mode 100644
index 0000000..db735d5
--- /dev/null
+++ b/game/shared/tf2/tf_vehicleshared.h
@@ -0,0 +1,47 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TF_VEHICLESHARED_H
+#define TF_VEHICLESHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+enum VehicleModeDeploy_e
+{
+	VEHICLE_MODE_NORMAL = 0,
+	VEHICLE_MODE_DEPLOYING,
+	VEHICLE_MODE_UNDEPLOYING,
+	VEHICLE_MODE_DEPLOYED
+};
+#define NUM_VEHICLE_DEPLOYMODE_BITS	2
+
+
+// Attachment indices.
+#define TANK_ATTACHMENT_TURRET_FIREPOS	1
+#define TANK_ATTACHMENT_TURRET_BASE		2
+#define TANK_ATTACHMENT_PLAYER_WAIST	3
+
+// Tread indices.
+enum TreadIndex
+{
+	TREAD_LEFT=0, 
+	TREAD_RIGHT=1
+};
+
+// Tread states (send across the wire).
+enum TreadState
+{
+	TREAD_NOTMOVING=0,
+	TREAD_FORWARD=1,
+	TREAD_BACKWARD=2
+};
+
+
+
+#endif // TF_VEHICLESHARED_H
diff --git a/game/shared/tf2/tfclassdata_shared.cpp b/game/shared/tf2/tfclassdata_shared.cpp
new file mode 100644
index 0000000..00273d6
--- /dev/null
+++ b/game/shared/tf2/tfclassdata_shared.cpp
@@ -0,0 +1,58 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tfclassdata_shared.h"
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassCommandoData_t )
+
+	DEFINE_PRED_FIELD( m_bCanBullRush, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bBullRush, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_vecBullRushDir, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_vecBullRushViewDir, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_vecBullRushViewGoalDir, FIELD_VECTOR, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flBullRushTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flDoubleTapForwardTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassReconData_t )
+
+	DEFINE_FIELD( m_nJumpCount, FIELD_INTEGER ),
+	DEFINE_FIELD( m_flSuppressionJumpTime, FIELD_FLOAT ),
+	DEFINE_FIELD( m_flSuppressionImpactTime, FIELD_FLOAT ),
+	DEFINE_FIELD( m_flActiveJumpTime, FIELD_FLOAT ),
+	DEFINE_FIELD( m_flStickTime, FIELD_FLOAT ),
+	DEFINE_FIELD( m_vecImpactNormal, FIELD_VECTOR ),
+	DEFINE_FIELD( m_flImpactDist, FIELD_FLOAT ),
+	DEFINE_FIELD( m_vecUnstickVelocity, FIELD_VECTOR ),
+	DEFINE_FIELD( m_bTrailParticles, FIELD_BOOLEAN ),
+
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassDefenderData_t )
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassEscortData_t )
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassInfiltratorData_t )
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassMedicData_t )
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassSniperData_t )
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassSupportData_t )
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassSapperData_t )
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA_NO_BASE( PlayerClassPyroData_t )
+END_PREDICTION_DATA()
diff --git a/game/shared/tf2/tfclassdata_shared.h b/game/shared/tf2/tfclassdata_shared.h
new file mode 100644
index 0000000..9a35d04
--- /dev/null
+++ b/game/shared/tf2/tfclassdata_shared.h
@@ -0,0 +1,368 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef TFCLASSDATA_SHARED_H
+#define TFCLASSDATA_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "mathlib/vector.h"
+
+
+enum TFClass
+{
+	TFCLASS_UNDECIDED = 0,
+
+	TFCLASS_RECON,
+	TFCLASS_COMMANDO,
+	TFCLASS_MEDIC,
+	TFCLASS_DEFENDER,
+	TFCLASS_SNIPER,
+	TFCLASS_SUPPORT,
+	TFCLASS_ESCORT,
+	TFCLASS_SAPPER,
+	TFCLASS_INFILTRATOR,
+	TFCLASS_PYRO,
+
+	// TFCLASS_INDIRECT,
+
+	TFCLASS_CLASS_COUNT,
+};
+
+
+//=============================================================================
+//
+// Class Shared Data
+//
+#define PLAYERCLASS_HULL_STAND_MIN		Vector( -24.0f, -24.0f,  0.0f )
+#define PLAYERCLASS_HULL_STAND_MAX		Vector(  24.0f,  24.0f,  72.0f )
+#define PLAYERCLASS_VIEWOFFSET_STAND	Vector(   0.0f,   0.0f,  64.0f )
+
+#define PLAYERCLASS_HULL_DUCK_MIN		Vector( -24.0f, -24.0f,  0.0f )
+#define PLAYERCLASS_HULL_DUCK_MAX		Vector(  24.0f,  24.0f,  36.0f )
+#define PLAYERCLASS_VIEWOFFSET_DUCK		Vector(   0.0f,   0.0f,  30.0f )
+
+#define PLAYERCLASS_STEPSIZE			18.0f
+
+//=============================================================================
+//
+// Commando Class Specific Data
+//
+//#define COMMANDO_TEST
+
+#ifndef COMMANDO_TEST
+
+#define COMMANDOCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define COMMANDOCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define COMMANDOCLASS_VIEWOFFSET_STAND		PLAYERCLASS_VIEWOFFSET_STAND
+
+#define COMMANDOCLASS_HULL_DUCK_MIN			PLAYERCLASS_HULL_DUCK_MIN
+#define COMMANDOCLASS_HULL_DUCK_MAX			PLAYERCLASS_HULL_DUCK_MAX
+#define COMMANDOCLASS_VIEWOFFSET_DUCK		PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define COMMANDOCLASS_STEPSIZE				PLAYERCLASS_STEPSIZE
+
+#else
+
+#define COMMANDOCLASS_HULL_STAND_MIN		Vector( -18.0f, -18.0f,   0.0f )
+#define COMMANDOCLASS_HULL_STAND_MAX		Vector(  18.0f,  18.0f,  54.0f )
+#define COMMANDOCLASS_VIEWOFFSET_STAND		Vector(   0.0f,   0.0f,  51.0f )
+
+#define COMMANDOCLASS_HULL_DUCK_MIN			Vector( -18.0f, -18.0f,   0.0f )
+#define COMMANDOCLASS_HULL_DUCK_MAX			Vector(  18.0f,  18.0f,  40.0f )
+#define COMMANDOCLASS_VIEWOFFSET_DUCK		Vector(   0.0f,   0.0f,  35.0f )
+
+#define COMMANDOCLASS_STEPSIZE				18.0f
+
+#endif
+
+#define COMMANDO_MOVETYPE_BULLRUSH			( MOVETYPE_LAST + 1 )
+
+#define COMMANDO_TIME_INVALID				-9999.0f
+#define COMMANDO_DOUBLETAP_TIME				300.0f
+#define COMMANDO_BULLRUSH_TIME				2000.0f
+#define COMMANDO_BULLRUSH_VIEWDELTA_TIME	1000.0f
+#define COMMANDO_BULLRUSH_VIEWDELTA_TEST	( COMMANDO_BULLRUSH_TIME - COMMANDO_BULLRUSH_VIEWDELTA_TIME )
+
+struct PlayerClassCommandoData_t
+{
+	DECLARE_PREDICTABLE();
+	DECLARE_CLASS_NOBASE( PlayerClassCommandoData_t );
+	DECLARE_EMBEDDED_NETWORKVAR();
+
+	enum { PLAYERCLASS_ID = TFCLASS_COMMANDO };
+
+	CNetworkVar( bool, m_bCanBullRush );
+	CNetworkVar( bool, m_bBullRush );
+	CNetworkVector( m_vecBullRushDir );
+	CNetworkQAngle( m_vecBullRushViewDir );
+	CNetworkQAngle( m_vecBullRushViewGoalDir );
+	CNetworkVar( float, m_flBullRushTime );
+	CNetworkVar( float, m_flDoubleTapForwardTime );
+};
+
+
+//=============================================================================
+//
+// Defender Class Specific Data
+//
+#if 0
+#define DEFENDERCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define DEFENDERCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define DEFENDERCLASS_VIEWOFFSET_STAND		PLAYERCLASS_VIEWOFFSET_STAND
+
+#define DEFENDERCLASS_HULL_DUCK_MIN			PLAYERCLASS_HULL_DUCK_MIN
+#define DEFENDERCLASS_HULL_DUCK_MAX			PLAYERCLASS_HULL_DUCK_MAX
+#define DEFENDERCLASS_VIEWOFFSET_DUCK		PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define DEFENDERCLASS_STEPSIZE				PLAYERCLASS_STEPSIZE
+#else
+#define DEFENDERCLASS_HULL_STAND_MIN		Vector( -18.0f, -18.0f,   0.0f )
+#define DEFENDERCLASS_HULL_STAND_MAX		Vector(  18.0f,  18.0f,  55.0f )
+#define DEFENDERCLASS_VIEWOFFSET_STAND		Vector(   0.0f,   0.0f,  53.0f )
+
+#define DEFENDERCLASS_HULL_DUCK_MIN			Vector( -18.0f, -18.0f,   0.0f )
+#define DEFENDERCLASS_HULL_DUCK_MAX			Vector(  18.0f,  18.0f,  30.0f )
+#define DEFENDERCLASS_VIEWOFFSET_DUCK		Vector(   0.0f,   0.0f,  25.0f )
+
+#define DEFENDERCLASS_STEPSIZE				15.0f
+#endif
+
+struct PlayerClassDefenderData_t
+{
+	DECLARE_PREDICTABLE();
+
+	enum { PLAYERCLASS_ID = TFCLASS_DEFENDER };
+
+};
+
+//=============================================================================
+//
+// Escort Class Specific Data
+//
+#if 0
+#define ESCORTCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define ESCORTCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define ESCORTCLASS_VIEWOFFSET_STAND	PLAYERCLASS_VIEWOFFSET_STAND
+
+#define ESCORTCLASS_HULL_DUCK_MIN		PLAYERCLASS_HULL_DUCK_MIN
+#define ESCORTCLASS_HULL_DUCK_MAX		PLAYERCLASS_HULL_DUCK_MAX
+#define ESCORTCLASS_VIEWOFFSET_DUCK		PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define ESCORTCLASS_STEPSIZE			PLAYERCLASS_STEPSIZE
+#else
+#define ESCORTCLASS_HULL_STAND_MIN		Vector( -24.0f, -24.0f,   0.0f )
+#define ESCORTCLASS_HULL_STAND_MAX		Vector(  24.0f,  24.0f,  74.0f )
+#define ESCORTCLASS_VIEWOFFSET_STAND	Vector(   0.0f,   0.0f,  67.0f )
+
+#define ESCORTCLASS_HULL_DUCK_MIN		Vector( -24.0f, -24.0f,   0.0f )
+#define ESCORTCLASS_HULL_DUCK_MAX		Vector(  24.0f,  24.0f,  72.0f )
+#define ESCORTCLASS_VIEWOFFSET_DUCK		Vector(   0.0f,   0.0f,  48.0f )
+
+#define ESCORTCLASS_STEPSIZE			18.0f
+#endif
+
+struct PlayerClassEscortData_t
+{
+	DECLARE_PREDICTABLE();
+
+	enum { PLAYERCLASS_ID = TFCLASS_ESCORT };
+
+};
+
+//=============================================================================
+//
+// Infiltrator Class Specific Data
+//
+#define INFILTRATORCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define INFILTRATORCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define INFILTRATORCLASS_VIEWOFFSET_STAND	PLAYERCLASS_VIEWOFFSET_STAND
+
+#define INFILTRATORCLASS_HULL_DUCK_MIN		PLAYERCLASS_HULL_DUCK_MIN
+#define INFILTRATORCLASS_HULL_DUCK_MAX		PLAYERCLASS_HULL_DUCK_MAX
+#define INFILTRATORCLASS_VIEWOFFSET_DUCK	PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define INFILTRATORCLASS_STEPSIZE			PLAYERCLASS_STEPSIZE
+
+struct PlayerClassInfiltratorData_t
+{
+	DECLARE_PREDICTABLE();
+
+	enum { PLAYERCLASS_ID = TFCLASS_INFILTRATOR };
+
+};
+
+
+//=============================================================================
+//
+// Pyro Class Specific Data
+//
+
+#define PYROCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define PYROCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define PYROCLASS_VIEWOFFSET_STAND		PLAYERCLASS_VIEWOFFSET_STAND
+
+#define PYROCLASS_HULL_DUCK_MIN			PLAYERCLASS_HULL_DUCK_MIN
+#define PYROCLASS_HULL_DUCK_MAX			PLAYERCLASS_HULL_DUCK_MAX
+#define PYROCLASS_VIEWOFFSET_DUCK		PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define PYROCLASS_STEPSIZE				PLAYERCLASS_STEPSIZE
+
+struct PlayerClassPyroData_t
+{
+	DECLARE_PREDICTABLE();
+
+	enum { PLAYERCLASS_ID = TFCLASS_PYRO };
+
+};
+
+
+//=============================================================================
+//
+// Medic Class Specific Data
+//
+#define MEDICCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define MEDICCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define MEDICCLASS_VIEWOFFSET_STAND		PLAYERCLASS_VIEWOFFSET_STAND
+
+#define MEDICCLASS_HULL_DUCK_MIN		PLAYERCLASS_HULL_DUCK_MIN
+#define MEDICCLASS_HULL_DUCK_MAX		PLAYERCLASS_HULL_DUCK_MAX
+#define MEDICCLASS_VIEWOFFSET_DUCK		PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define MEDICCLASS_STEPSIZE				PLAYERCLASS_STEPSIZE
+
+struct PlayerClassMedicData_t
+{
+	DECLARE_PREDICTABLE();
+
+	enum { PLAYERCLASS_ID = TFCLASS_MEDIC };
+
+};
+
+//=============================================================================
+//
+// Recon Class Specific Data
+//
+#define RECONCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define RECONCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define RECONCLASS_VIEWOFFSET_STAND		PLAYERCLASS_VIEWOFFSET_STAND
+
+#define RECONCLASS_HULL_DUCK_MIN		PLAYERCLASS_HULL_DUCK_MIN
+#define RECONCLASS_HULL_DUCK_MAX		PLAYERCLASS_HULL_DUCK_MAX
+#define RECONCLASS_VIEWOFFSET_DUCK		PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define RECONCLASS_STEPSIZE				PLAYERCLASS_STEPSIZE
+
+struct PlayerClassReconData_t
+{
+	DECLARE_PREDICTABLE();
+	DECLARE_CLASS_NOBASE( PlayerClassReconData_t );
+	DECLARE_EMBEDDED_NETWORKVAR();
+
+
+	enum { PLAYERCLASS_ID = TFCLASS_RECON };
+
+	// For in-air jumps
+	CNetworkVar( int, m_nJumpCount );
+
+	// For wall jumps
+	CNetworkVar( float, m_flSuppressionJumpTime );
+	CNetworkVar( float, m_flSuppressionImpactTime );
+	CNetworkVar( float, m_flActiveJumpTime );
+	CNetworkVar( float, m_flStickTime );
+	CNetworkVector(	m_vecImpactNormal );
+	CNetworkVar( float, m_flImpactDist );
+	CNetworkVector( m_vecUnstickVelocity );
+
+	// Trail
+	CNetworkVar( bool, m_bTrailParticles );
+};
+
+
+//=============================================================================
+//
+// Sniper Class Specific Data
+//
+#define SNIPERCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define SNIPERCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define SNIPERCLASS_VIEWOFFSET_STAND	PLAYERCLASS_VIEWOFFSET_STAND
+
+#define SNIPERCLASS_HULL_DUCK_MIN		PLAYERCLASS_HULL_DUCK_MIN
+#define SNIPERCLASS_HULL_DUCK_MAX		PLAYERCLASS_HULL_DUCK_MAX
+#define SNIPERCLASS_VIEWOFFSET_DUCK		PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define SNIPERCLASS_STEPSIZE			PLAYERCLASS_STEPSIZE
+
+struct PlayerClassSniperData_t
+{
+	DECLARE_PREDICTABLE();
+
+	enum { PLAYERCLASS_ID = TFCLASS_SNIPER };
+
+};
+
+//=============================================================================
+//
+// Support Class Specific Data
+//
+#if 0
+#define SUPPORTCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define SUPPORTCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define SUPPORTCLASS_VIEWOFFSET_STAND	PLAYERCLASS_VIEWOFFSET_STAND
+
+#define SUPPORTCLASS_HULL_DUCK_MIN		PLAYERCLASS_HULL_DUCK_MIN
+#define SUPPORTCLASS_HULL_DUCK_MAX		PLAYERCLASS_HULL_DUCK_MAX
+#define SUPPORTCLASS_VIEWOFFSET_DUCK	PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define SUPPORTCLASS_STEPSIZE			PLAYERCLASS_STEPSIZE
+#else
+#define SUPPORTCLASS_HULL_STAND_MIN		Vector( -30.0f, -30.0f,   0.0f )
+#define SUPPORTCLASS_HULL_STAND_MAX		Vector(  30.0f,  30.0f, 106.0f )
+#define SUPPORTCLASS_VIEWOFFSET_STAND	Vector(   0.0f,   0.0f,  120.0f )
+
+#define SUPPORTCLASS_HULL_DUCK_MIN		Vector( -30.0f, -30.0f,   0.0f )
+#define SUPPORTCLASS_HULL_DUCK_MAX		Vector(  30.0f,  30.0f,  72.0f )
+#define SUPPORTCLASS_VIEWOFFSET_DUCK	Vector(   0.0f,   0.0f,  64.0f )
+
+#define SUPPORTCLASS_STEPSIZE			27.0f
+#endif
+
+struct PlayerClassSupportData_t
+{
+	DECLARE_PREDICTABLE();
+
+	enum { PLAYERCLASS_ID = TFCLASS_SUPPORT };
+
+};
+
+//=============================================================================
+//
+// Sapper Class Specific Data
+//
+#define SAPPERCLASS_HULL_STAND_MIN		PLAYERCLASS_HULL_STAND_MIN
+#define SAPPERCLASS_HULL_STAND_MAX		PLAYERCLASS_HULL_STAND_MAX
+#define SAPPERCLASS_VIEWOFFSET_STAND	PLAYERCLASS_VIEWOFFSET_STAND
+
+#define SAPPERCLASS_HULL_DUCK_MIN		PLAYERCLASS_HULL_DUCK_MIN
+#define SAPPERCLASS_HULL_DUCK_MAX		PLAYERCLASS_HULL_DUCK_MAX
+#define SAPPERCLASS_VIEWOFFSET_DUCK		PLAYERCLASS_VIEWOFFSET_DUCK
+
+#define SAPPERCLASS_STEPSIZE			PLAYERCLASS_STEPSIZE
+
+struct PlayerClassSapperData_t
+{
+	DECLARE_PREDICTABLE();
+
+	enum { PLAYERCLASS_ID = TFCLASS_SAPPER };
+};
+
+
+#include "tf_shareddefs.h"
+
+
+#endif // TFCLASSDATA_SHARED_H
diff --git a/game/shared/tf2/vehicle_mortar_shared.h b/game/shared/tf2/vehicle_mortar_shared.h
new file mode 100644
index 0000000..adbe60b
--- /dev/null
+++ b/game/shared/tf2/vehicle_mortar_shared.h
@@ -0,0 +1,18 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef VEHICLE_MORTAR_SHARED_H
+#define VEHICLE_MORTAR_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+// How long it takes to deploy the mortar.
+#define VEHICLE_MORTAR_DEPLOY_WAIT_TIME	3
+
+
+#endif // VEHICLE_MORTAR_SHARED_H
diff --git a/game/shared/tf2/weapon_arcwelder.cpp b/game/shared/tf2/weapon_arcwelder.cpp
new file mode 100644
index 0000000..27c6ae3
--- /dev/null
+++ b/game/shared/tf2/weapon_arcwelder.cpp
@@ -0,0 +1,322 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "in_buttons.h"
+#include "tf_gamerules.h"
+#include "weapon_combatshield.h"
+
+#if defined( CLIENT_DLL )
+
+#include "particles_simple.h"
+#include "fx.h"
+#include "fx_quad.h"
+#include "clienteffectprecachesystem.h"
+
+#define CWeaponArcWelder C_WeaponArcWelder
+#else
+#endif
+
+#include "weapon_repairgun.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+
+// Buff ranges
+ConVar weapon_arcwelder_target_range( "weapon_arcwelder_target_range", "90", FCVAR_REPLICATED, "The farthest away you can be for the arcwelder to initially lock onto a target." );
+ConVar weapon_arcwelder_stick_range( "weapon_arcwelder_stick_range", "100", FCVAR_REPLICATED, "How far away the arcwelder can stay locked onto someone." );
+ConVar weapon_arcwelder_rate( "weapon_arcwelder_rate", "15", FCVAR_REPLICATED );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponArcWelder : public CWeaponRepairGun
+{
+	DECLARE_CLASS( CWeaponArcWelder, CWeaponRepairGun );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponArcWelder( void );
+
+	virtual void Precache();
+
+	virtual float	GetTargetRange( void );
+	virtual float	GetStickRange( void );
+	virtual float	GetHealRate( void );
+	virtual bool	AppliesModifier( void ) { return false; }
+	virtual bool	TargetsPlayers( void ) { return false; }
+	virtual CBaseEntity *GetTargetToHeal( CBaseEntity *pCurHealing );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual void	ClientThink( void );
+	virtual bool	OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+	virtual void	ViewModelDrawn( C_BaseViewModel *pViewModel );
+
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+
+private:
+	bool		m_bWelding;
+
+#if defined( CLIENT_DLL )
+	float		m_flNextEffectTime;
+#endif
+
+private:														
+	CWeaponArcWelder( const CWeaponArcWelder & );
+};
+
+LINK_ENTITY_TO_CLASS( weapon_arcwelder, CWeaponArcWelder );
+
+PRECACHE_WEAPON_REGISTER( weapon_arcwelder );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponArcWelder, DT_WeaponArcWelder )
+
+BEGIN_NETWORK_TABLE( CWeaponArcWelder, DT_WeaponArcWelder )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponArcWelder )
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponArcWelder::CWeaponArcWelder()
+{
+	SetPredictionEligible( true );
+	m_bWelding = false;
+#ifdef CLIENT_DLL
+	m_flNextEffectTime = 0;
+#endif
+}
+
+void CWeaponArcWelder::Precache()
+{
+	BaseClass::Precache();
+
+	PrecacheScriptSound( "WeaponRepairGun.Healing" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponArcWelder::GetTargetRange( void )
+{
+	return weapon_arcwelder_target_range.GetFloat();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponArcWelder::GetStickRange( void )
+{
+	return weapon_arcwelder_target_range.GetFloat();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponArcWelder::GetHealRate( void )
+{
+	return weapon_arcwelder_rate.GetFloat();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a pointer to a healable target
+//-----------------------------------------------------------------------------
+CBaseEntity *CWeaponArcWelder::GetTargetToHeal( CBaseEntity *pCurHealing )
+{
+	CBaseEntity *pTarget = BaseClass::GetTargetToHeal(pCurHealing);
+	if ( !pTarget )
+		return pTarget;
+
+	// Make sure the target is within our field of view
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return NULL;
+
+	Vector vecAiming;
+	pOwner->EyeVectors( &vecAiming );
+
+	// Find a player in range of this player, and make sure they're healable.
+	Vector vecSrc = pOwner->Weapon_ShootPosition( );
+	Vector vecEnd = vecSrc + vecAiming * GetTargetRange();
+	trace_t tr;
+
+	// Use WeaponTraceLine so shields are tested...
+	TFGameRules()->WeaponTraceLine( vecSrc, vecEnd, (MASK_SHOT & ~CONTENTS_HITBOX), pOwner, DMG_PROBE, &tr );
+	if ( tr.fraction != 1.0 && tr.m_pEnt == pTarget )
+		return pTarget;
+
+	return NULL;
+}
+
+#ifdef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponArcWelder::ClientThink( void )
+{
+	CBasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	if ( m_hHealingTarget == NULL )
+		return;
+
+	// Don't show it while the player is dead. Ideally, we'd respond to m_bHealing in OnDataChanged,
+	// but it stops sending the weapon when it's holstered, and it gets holstered when the player dies.
+	C_BasePlayer *pFiringPlayer = dynamic_cast< C_BasePlayer* >( GetOwner() );
+	if ( !pFiringPlayer || pFiringPlayer->IsPlayerDead() )
+	{
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
+		m_bPlayingSound = false;
+		StopRepairSound();
+		return;
+	}
+
+	// Start playing the heal sound, if we're not already
+	if ( !m_bPlayingSound )
+	{
+		m_bPlayingSound = true;
+		CLocalPlayerFilter filter;
+		EmitSound( filter, entindex(), "WeaponRepairGun.Healing" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponArcWelder::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
+{
+	CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return true;
+
+	switch ( event )
+	{
+	case 7001:
+		m_bWelding = true;
+		return true;
+	case 7002:
+		m_bWelding = false;
+		return true;
+	default:
+		break;
+	};
+
+	return BaseClass::OnFireEvent( pViewModel, origin, angles, event, options );
+}
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheArcWelderEffect )
+CLIENTEFFECT_MATERIAL( "particle/smoke_arcwelder" )
+CLIENTEFFECT_MATERIAL( "effects/spark2" )
+CLIENTEFFECT_MATERIAL( "effects/blueflare" )
+CLIENTEFFECT_MATERIAL( "effects/blueflare2" )
+CLIENTEFFECT_REGISTER_END()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponArcWelder::ViewModelDrawn( C_BaseViewModel *pViewModel )
+{
+	if ( !m_bWelding || !m_hHealingTarget.Get() )
+		return;
+
+	if ( m_flNextEffectTime > gpGlobals->curtime )
+		return;
+	m_flNextEffectTime = gpGlobals->curtime + 0.1;
+
+	// Get our weldpoint
+	Vector attachOrigin;
+	QAngle attachAngles; 
+	pViewModel->GetAttachment( pViewModel->LookupAttachment("muzzle"), attachOrigin, attachAngles );
+	Vector vecEnd = m_hHealingTarget->WorldSpaceCenter();
+	trace_t tr;
+
+	// Use WeaponTraceLine so shields are tested...
+	TFGameRules()->WeaponTraceLine( attachOrigin, vecEnd, (MASK_SHOT & ~CONTENTS_HITBOX), GetOwner(), DMG_PROBE, &tr );
+
+	// Smoke
+	unsigned char color[3];
+	int iColOff = random->RandomInt(-16,16);
+	color[0] = 120 + iColOff;
+	color[1] = 230 + iColOff;
+	color[2] = 235 + iColOff;
+	/*
+	// Pull out from the target a bit
+	Vector vecOrigin = vecEnd;
+	Vector vecFromTarget = (vecEnd - attachOrigin);
+	VectorNormalize( vecFromTarget );
+	vecOrigin -= (vecFromTarget * 24);
+	*/
+
+	Vector vecOrigin = attachOrigin;
+	// Velocity
+	Vector vecVelocity = tr.plane.normal;
+	vecVelocity.z += random->RandomFloat( 8, 12 );
+	// Add it
+	CSmartPtr<CSimpleEmitter> pSimple = FX_Smoke( vecOrigin, vecVelocity, 
+		random->RandomFloat( 4, 8 ),		// Scale
+		1,	
+		random->RandomFloat( 0.5, 3.0 ),	// Dietime
+		color, 
+		random->RandomInt( 64, 200 ),		// Alpha
+		"particle/smoke_arcwelder",	
+		random->RandomInt(0,255),			// Roll
+		0 );								// Rolldelta
+
+	// Sparks
+	FX_Sparks( vecOrigin, 1, 4, tr.plane.normal, 2.5, 8, 64, "effects/spark2" );
+
+	// Bright Glow
+	SimpleParticle *sParticle;
+	sParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/blueflare" ), vecOrigin );
+	if ( sParticle == NULL )
+		return;
+	sParticle->m_flLifetime		= 0.0f;
+	sParticle->m_flDieTime		= 0.5f;
+	sParticle->m_vecVelocity.Init();
+	sParticle->m_uchColor[0]	= 255;
+	sParticle->m_uchColor[1]	= 255;
+	sParticle->m_uchColor[2]	= 255;
+	sParticle->m_uchStartSize	= random->RandomInt(5,7);
+	sParticle->m_uchEndSize		= sParticle->m_uchStartSize;
+	sParticle->m_flRoll			= random->RandomInt(0,360);
+	sParticle->m_flRollDelta	= 0;
+
+	// Dull Glow
+	sParticle = (SimpleParticle *) pSimple->AddParticle( sizeof( SimpleParticle ), pSimple->GetPMaterial( "effects/blueflare2" ), vecOrigin );
+	if ( sParticle == NULL )
+		return;
+	sParticle->m_flLifetime		= 0.0f;
+	sParticle->m_flDieTime		= 0.2f;
+	sParticle->m_vecVelocity.Init();
+	sParticle->m_uchColor[0]	= 255;
+	sParticle->m_uchColor[1]	= 255;
+	sParticle->m_uchColor[2]	= 255;
+	sParticle->m_uchStartSize	= random->RandomInt(15,20);
+	sParticle->m_uchEndSize		= sParticle->m_uchStartSize;
+	sParticle->m_flRoll			= random->RandomInt(0,360);
+	sParticle->m_flRollDelta	= 0;
+}
+#endif
diff --git a/game/shared/tf2/weapon_basecombatobject.cpp b/game/shared/tf2/weapon_basecombatobject.cpp
new file mode 100644
index 0000000..4d02d43
--- /dev/null
+++ b/game/shared/tf2/weapon_basecombatobject.cpp
@@ -0,0 +1,126 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_basecombatobject.h"
+//====================================================================================================
+// BASE COMBAT OBJECT WEAPON
+//====================================================================================================
+
+LINK_ENTITY_TO_CLASS( weapon_basecombatobject, CWeaponBaseCombatObject );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponBaseCombatObject, DT_WeaponBaseCombatObject )
+
+BEGIN_NETWORK_TABLE( CWeaponBaseCombatObject, DT_WeaponBaseCombatObject )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponBaseCombatObject )
+
+/*
+	DEFINE_PRED_ARRAY( m_szObjectName, FIELD_CHARACTER, sizeof( m_szObjectName ) ),
+	DEFINE_PRED_FIELD( m_vecBuildMins, FIELD_VECTOR, 0 ),
+	DEFINE_PRED_FIELD( m_vecBuildMaxs, FIELD_VECTOR, 0 ),
+*/
+
+END_PREDICTION_DATA()
+
+
+CWeaponBaseCombatObject::CWeaponBaseCombatObject()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Place the combat object
+//-----------------------------------------------------------------------------
+void CWeaponBaseCombatObject::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = dynamic_cast<CBaseTFPlayer*>((CBaseEntity*)GetOwner());
+	if ( !pPlayer )
+		return;
+	if ( pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
+		return;
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+
+	Vector vecPlaceOrigin;
+	QAngle angPlaceAngles;
+	if ( GetPlacePosition( pPlayer, &vecPlaceOrigin, &angPlaceAngles ) == false )
+	{
+		WeaponSound( WPN_DOUBLE );
+		return;
+	}
+
+	// Place the combat object
+	PlaceCombatObject( pPlayer, vecPlaceOrigin, angPlaceAngles );
+
+	WeaponSound( SINGLE );
+	pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+
+	// If I'm now out of ammo, switch away
+	if ( !HasPrimaryAmmo() )
+	{
+		pPlayer->SelectLastItem();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if we found a valid placement point
+//-----------------------------------------------------------------------------
+bool CWeaponBaseCombatObject::GetPlacePosition( CBaseTFPlayer *pBuilder, Vector *vecPlaceOrigin, QAngle *angPlaceAngles )
+{
+	Vector vecForward;
+	QAngle vecAngles = vec3_angle;
+	vecAngles.y = pBuilder->EyeAngles().y;
+	AngleVectors( vecAngles, &vecForward, NULL, NULL);
+	*vecPlaceOrigin = pBuilder->WorldSpaceCenter() + (vecForward * ((m_vecBuildMaxs.x - m_vecBuildMins.x) + 32));
+	if ( UTIL_PointContents( *vecPlaceOrigin ) != CONTENTS_EMPTY )
+		return false;
+
+	// Room to fit?
+	trace_t tr;
+	UTIL_TraceHull( *vecPlaceOrigin, *vecPlaceOrigin + Vector(0,0,-64), m_vecBuildMins, m_vecBuildMaxs, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
+	if ( tr.allsolid || tr.startsolid )
+		return false;
+	if ( tr.fraction == 1.0 )
+		return false;
+
+	*vecPlaceOrigin = tr.endpos;
+	//VectorAngles( tr.plane.normal, *angPlaceAngles );
+	*angPlaceAngles = QAngle(0,0,0);
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Put the combat object for this weapon on the specified point
+//-----------------------------------------------------------------------------
+void CWeaponBaseCombatObject::PlaceCombatObject( CBaseTFPlayer *pBuilder, Vector vecOrigin, QAngle angles )
+{
+#if !defined( CLIENT_DLL )
+	Assert( m_szObjectName != NULL );
+
+	CBaseEntity *pEntity = CreateEntityByName( m_szObjectName );
+	pEntity->SetLocalAngles( angles );
+	pEntity->Spawn();
+	pEntity->Teleport( &vecOrigin, &angles, &vec3_origin );
+
+	// If it's an object, set it's builder & team
+	CBaseObject *pObject = dynamic_cast< CBaseObject * >( pEntity );
+	if ( pObject )
+	{
+		pObject->SetBuilder( pBuilder );
+		pObject->ChangeTeam( pBuilder->GetTeamNumber() );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponBaseCombatObject::GetFireRate( void )
+{
+	return 0.5;
+}
diff --git a/game/shared/tf2/weapon_basecombatobject.h b/game/shared/tf2/weapon_basecombatobject.h
new file mode 100644
index 0000000..37e802f
--- /dev/null
+++ b/game/shared/tf2/weapon_basecombatobject.h
@@ -0,0 +1,68 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_BASECOMBATOBJECT_H
+#define WEAPON_BASECOMBATOBJECT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfcombatweapon_shared.h"
+
+class CBaseTFPlayer;
+
+#if defined( CLIENT_DLL )
+
+#define CWeaponBaseCombatObject C_WeaponBaseCombatObject
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Base class for combat object weapons
+//-----------------------------------------------------------------------------
+class CWeaponBaseCombatObject : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponBaseCombatObject, CBaseTFCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponBaseCombatObject();
+
+	virtual void	PrimaryAttack( void );
+	virtual bool	GetPlacePosition( CBaseTFPlayer *pBuilder, Vector *vecPlaceOrigin, QAngle *angPlaceAngles );
+	virtual void	PlaceCombatObject( CBaseTFPlayer *pBuilder, Vector vecOrigin, QAngle angles );
+	virtual float	GetFireRate( void );
+
+protected:
+	char	*m_szObjectName;
+	Vector	m_vecBuildMins;
+	Vector	m_vecBuildMaxs;
+
+	/*
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+	*/
+
+private:														
+	CWeaponBaseCombatObject( const CWeaponBaseCombatObject & );						
+};
+
+#endif // WEAPON_BASECOMBATOBJECT_H
diff --git a/game/shared/tf2/weapon_builder.cpp b/game/shared/tf2/weapon_builder.cpp
new file mode 100644
index 0000000..7d90410
--- /dev/null
+++ b/game/shared/tf2/weapon_builder.cpp
@@ -0,0 +1,530 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:			The "weapon" used to build objects
+//					
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "tf_basecombatweapon.h"
+#include "EntityList.h"
+#include "in_buttons.h"
+#include "weapon_builder.h"
+#include "tf_obj.h"
+#include "sendproxy.h"
+#include "weapon_objectselection.h"
+#include "info_act.h"
+#include "vguiscreen.h"
+
+extern ConVar tf2_object_hard_limits;
+extern ConVar tf_fastbuild;
+
+EXTERN_SEND_TABLE(DT_BaseCombatWeapon)
+
+IMPLEMENT_SERVERCLASS_ST(CWeaponBuilder, DT_WeaponBuilder)
+	SendPropInt( SENDINFO( m_iBuildState ), 4, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iCurrentObject ), BUILDER_OBJECT_BITS, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_iCurrentObjectState ), 4, SPROP_UNSIGNED ),
+	SendPropEHandle( SENDINFO( m_hObjectBeingBuilt ) ),
+	SendPropTime( SENDINFO( m_flStartTime ) ),
+	SendPropTime( SENDINFO( m_flTotalTime ) ),
+	SendPropArray
+	( 
+		SendPropInt( SENDINFO_ARRAY(m_bObjectValidity), 1, SPROP_UNSIGNED), m_bObjectValidity
+	),
+	SendPropArray
+	( 
+		SendPropInt( SENDINFO_ARRAY(m_bObjectBuildability), 1, SPROP_UNSIGNED), m_bObjectBuildability
+	),
+END_SEND_TABLE()
+
+LINK_ENTITY_TO_CLASS( weapon_builder, CWeaponBuilder );
+PRECACHE_WEAPON_REGISTER(weapon_builder);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponBuilder::CWeaponBuilder()
+{
+	for ( int i=0; i < m_bObjectValidity.Count(); i++ )
+		m_bObjectValidity.Set( i, 0 );
+
+	m_iCurrentObject = BUILDER_INVALID_OBJECT;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::Precache( void )
+{
+	BaseClass::Precache();
+
+	PrecacheModel( "models/weapons/v_slam.mdl" );
+	PrecacheVGuiScreen( "screen_human_pda" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets info about the control panels
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::GetControlPanelInfo( int nPanelIndex, const char *&pPanelName )
+{
+	pPanelName = "screen_human_pda";
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CWeaponBuilder::ShouldShowControlPanels( void )
+{
+	if ( GetActivity() == ACT_VM_IDLE )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::UpdateOnRemove( void )
+{
+	// Tell the player he's lost his build weapon
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( pOwner && pOwner->GetWeaponBuilder() == this )
+	{
+		pOwner->SetWeaponBuilder( NULL );
+	}
+
+	// Chain at end to mimic destructor unwind order
+	BaseClass::UpdateOnRemove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Builder weapon has just been given to a player
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::Equip( CBaseCombatCharacter *pOwner )
+{
+	BaseClass::Equip( pOwner );
+	((CBaseTFPlayer*)pOwner)->SetWeaponBuilder( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a new object type to this build weapon. This will allow
+//			the player carrying this builder to build the object.
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::AddBuildableObject( int iObjectType )
+{
+	m_bObjectValidity.Set( iObjectType, true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponBuilder::CanDeploy( void )
+{
+	if ( m_iCurrentObject != BUILDER_INVALID_OBJECT )
+	{
+		SetCurrentState( BS_PLACING );
+		StartPlacement(); 
+		m_flNextPrimaryAttack = gpGlobals->curtime + 0.35f;
+	}
+	else
+	{
+		m_hObjectBeingBuilt = NULL;
+		SetCurrentState( BS_IDLE );
+		SetCurrentObject( m_iCurrentObject );
+	}
+	return BaseClass::CanDeploy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponBuilder::Deploy( )
+{
+#if !defined( CLIENT_DLL )
+	if ( m_hObjectBeingBuilt.Get() && m_hObjectBeingBuilt->IsAnUpgrade() )
+		return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_SLAM_STICKWALL_ND_DRAW, (char*)GetAnimPrefix() );
+
+	return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() );
+#else
+	return true;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Prevent switching when working on something
+//-----------------------------------------------------------------------------
+bool CWeaponBuilder::CanHolster( void )
+{
+	if ( IsBuilding() )
+		return false;
+
+	return BaseClass::CanHolster();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseCombatWeapon *CWeaponBuilder::GetLastWeapon( void )
+{
+	return BaseClass::GetLastWeapon();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop placement when holstering
+//-----------------------------------------------------------------------------
+bool CWeaponBuilder::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	if ( m_iBuildState == BS_PLACING || m_iBuildState == BS_PLACING_INVALID )
+	{
+		SetCurrentState( BS_IDLE );
+	}
+	StopPlacement();
+
+	return BaseClass::Holster(pSwitchingTo);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// Ignore input while the player's building anything
+	if ( pOwner->IsBuilding() )
+		return;
+
+	// Switch away if I'm not in placement mode
+	if ( m_iBuildState != BS_PLACING && m_iBuildState != BS_PLACING_INVALID )
+	{
+		pOwner->SwitchToNextBestWeapon( NULL );
+		return;
+	}
+
+	if (( pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+	{
+		PrimaryAttack();
+	}
+
+	// Allow shield post frame 
+	AllowShieldPostFrame( true );
+
+	WeaponIdle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start placing or building the currently selected object
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// What state should we move to?
+	switch( m_iBuildState )
+	{
+	case BS_IDLE:
+		{
+			// Idle state starts selection
+			SetCurrentState( BS_SELECTING );
+		}
+		break;
+
+	case BS_SELECTING:
+		{
+			// Do nothing, client handles selection
+			return;
+		}
+		break;
+
+	case BS_PLACING:
+		{
+			if ( m_hObjectBeingBuilt )
+			{
+				// Give the object a chance to veto the "start building" command. Objects like barbed wire
+				// may want to change their properties instead of actually building yet.
+				if ( m_hObjectBeingBuilt->PreStartBuilding() )
+				{
+					int iFlags = m_hObjectBeingBuilt->GetObjectFlags();
+
+					// Can't build if the game hasn't started
+					if ( !tf_fastbuild.GetInt() && CurrentActIsAWaitingAct() )
+					{
+						ClientPrint( pOwner, HUD_PRINTCENTER, "Can't build until the game's started.\n" );
+						return;
+					}
+
+					StartBuilding();
+
+					// Should we switch away?
+					if ( iFlags & OF_ALLOW_REPEAT_PLACEMENT )
+					{
+						// Start placing another
+						SetCurrentState( BS_PLACING );
+						StartPlacement(); 
+					}
+					else
+					{
+						pOwner->SwitchToNextBestWeapon( NULL );
+					}
+				}
+			}
+		}
+		break;
+
+	case BS_PLACING_INVALID:
+		{
+			WeaponSound( SINGLE_NPC );
+
+			// If there is any associated error text when placing the object, display it
+			if( m_hObjectBeingBuilt != NULL )
+			{
+				if (m_hObjectBeingBuilt->MustBeBuiltInResourceZone())
+				{
+					ClientPrint( pOwner, HUD_PRINTCENTER, "Only placeable in an empty resource zone.\n" );
+				}
+				else if (m_hObjectBeingBuilt->MustBeBuiltInConstructionYard())
+				{
+					ClientPrint( pOwner, HUD_PRINTCENTER, "Only placeable in a construction yard.\n" );
+				}
+			}
+		}
+		break;
+	}
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + 0.2f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the builder to the specified state
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::SetCurrentState( int iState )
+{
+	// Check the current build state... we may need to shut some stuff down...
+	switch(m_iBuildState)
+	{
+	case BS_PLACING:
+	case BS_PLACING_INVALID:
+		{
+			if ((iState != BS_PLACING) && (iState != BS_PLACING_INVALID) && (iState != BS_BUILDING))
+			{
+				StopPlacement();
+				WeaponSound( SPECIAL1 );
+			}
+		}
+		break;
+	}
+
+	m_iBuildState = iState;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the builder to the specified object
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::SetCurrentObject( int iObject )
+{
+	// Fixup for invalid objects
+	if (iObject < 0)
+		iObject = BUILDER_INVALID_OBJECT;
+
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	int i;
+
+	// If -1 was passed in, set to our first available object
+	if ( iObject == BUILDER_INVALID_OBJECT )
+	{
+		for ( i = 0; i < OBJ_LAST; i++ )
+		{
+			if ( m_bObjectValidity[i] )
+			{
+				iObject = i;
+				break;
+			}
+		}
+	}
+
+	// Recalculate the buildability of each object (for propagation to the client)
+	for ( i=0; i < m_bObjectBuildability.Count(); i++ )
+		m_bObjectBuildability.Set( i, 0 );
+
+	for ( i = 0; i < OBJ_LAST; i++ )
+	{
+		if ( m_bObjectValidity[i] && pOwner->CanBuild(i) == CB_CAN_BUILD )
+		{
+			m_bObjectBuildability.Set( i, true );
+		}
+	}
+
+	m_iCurrentObject = iObject;
+	m_iCurrentObjectState = pOwner->CanBuild( m_iCurrentObject );
+	m_flStartTime = 0;
+	m_flTotalTime = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Idle updates the position of the build placement model
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::WeaponIdle( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// If we're in placement mode, update the placement model
+	switch( m_iBuildState )
+	{
+	case BS_PLACING:
+	case BS_PLACING_INVALID:
+		{
+			if ( UpdatePlacement() )
+			{
+				SetCurrentState( BS_PLACING );
+			}
+			else
+			{
+				SetCurrentState( BS_PLACING_INVALID );
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	if ( HasWeaponIdleTimeElapsed() )
+	{
+		SendWeaponAnim( ACT_VM_IDLE );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The player holding this weapon has just gained new technology.
+//			Check to see if it affects the medikit
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::GainedNewTechnology( CBaseTechnology *pTechnology )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		// Force a recalculation of the state for this object
+		SetCurrentObject( m_iCurrentObject );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start placing the object
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::StartPlacement( void )
+{
+	StopPlacement();
+
+	// Create the slab
+	m_hObjectBeingBuilt = (CBaseObject*)CreateEntityByName( GetObjectInfo( m_iCurrentObject )->m_pClassName );
+	if ( m_hObjectBeingBuilt )
+	{
+		m_hObjectBeingBuilt->Spawn();
+		m_hObjectBeingBuilt->StartPlacement( ToBaseTFPlayer( GetOwner() ) );
+		UpdatePlacement();
+
+		// Stomp this here in the same frame we make the object, so prevent clientside warnings that it's under attack
+		m_hObjectBeingBuilt->m_iHealth = OBJECT_CONSTRUCTION_STARTINGHEALTH;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the viewmodel according to the type of object we're placing
+//-----------------------------------------------------------------------------
+const char *CWeaponBuilder::GetViewModel( int viewmodelindex /*=0*/ )  const
+{
+	if ( m_hObjectBeingBuilt.Get() && m_hObjectBeingBuilt->IsAnUpgrade() )
+		return "models/weapons/v_slam.mdl";
+
+	return BaseClass::GetViewModel( viewmodelindex );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::StopPlacement( void )
+{
+	if ( m_hObjectBeingBuilt )
+	{
+		m_hObjectBeingBuilt->StopPlacement();
+		m_hObjectBeingBuilt = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Move the placement model to the current position. Return false if it's an invalid position
+//-----------------------------------------------------------------------------
+bool CWeaponBuilder::UpdatePlacement( void )
+{
+	if ( !m_hObjectBeingBuilt )
+		return false;
+
+	return m_hObjectBeingBuilt->UpdatePlacement( ToBaseTFPlayer(GetOwner()) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Player holding this weapon has started building something
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::StartBuilding( void )
+{
+	if ( m_hObjectBeingBuilt.Get() && UpdatePlacement() )
+	{
+		SetCurrentState( BS_BUILDING );
+		m_hObjectBeingBuilt->StartBuilding( GetOwner() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Player holding this weapon has aborted the build of an object
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::StoppedBuilding( int iObjectType )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		// Force a recalculation of the state for this object
+		SetCurrentObject( m_iCurrentObject );
+		SetCurrentState( BS_IDLE );
+
+		WeaponSound( SPECIAL2 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponBuilder::IsBuilding( void )
+{
+	return ( m_iBuildState == BS_BUILDING );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The player holding this weapon has just finished building an object
+//-----------------------------------------------------------------------------
+void CWeaponBuilder::FinishedObject( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		// We're no longer building anything...
+		m_hObjectBeingBuilt = NULL;
+
+		// Force a recalculation of the state for this object
+		SetCurrentObject( m_iCurrentObject );
+		SetCurrentState( BS_IDLE );
+	}
+}
diff --git a/game/shared/tf2/weapon_builder.h b/game/shared/tf2/weapon_builder.h
new file mode 100644
index 0000000..a684dbb
--- /dev/null
+++ b/game/shared/tf2/weapon_builder.h
@@ -0,0 +1,90 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_BUILDER_H
+#define WEAPON_BUILDER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_combat_usedwithshieldbase.h"
+
+class CBaseObject;
+
+//=========================================================
+// Builder Weapon
+//=========================================================
+class CWeaponBuilder : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponBuilder, CWeaponCombatUsedWithShieldBase );
+public:
+	CWeaponBuilder();
+
+	virtual void	UpdateOnRemove( void );
+
+	DECLARE_SERVERCLASS();
+
+	virtual void	Precache( void );
+	virtual bool	CanDeploy( void );
+	virtual bool	CanHolster( void );
+	virtual CBaseCombatWeapon *GetLastWeapon( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual void	WeaponIdle( void );
+	virtual bool	Deploy( void );	
+	virtual const char	*GetViewModel( int viewmodelindex = 0 ) const;
+
+	void	SetCurrentState( int iState );
+	void	SetCurrentObject( int iObject );
+
+	virtual void	GainedNewTechnology( CBaseTechnology *pTechnology );
+	virtual void	Equip( CBaseCombatCharacter *pOwner );
+
+	// Add a new object type to the list of objects this builder weapon can build
+	void	AddBuildableObject( int iObjectType );
+
+	// Placement
+	void	StartPlacement( void );
+	void	StopPlacement( void );
+	bool	UpdatePlacement( void );
+
+	// Building
+	void	StartBuilding( void );
+	void	StoppedBuilding( int iObjectType );
+	bool	IsBuilding( void );
+	void	FinishedObject( void );
+
+	virtual void	GetControlPanelInfo( int nPanelIndex, const char *&pPanelName );
+
+	virtual bool			ShouldShowControlPanels( void );
+
+private:
+	void	PerformModifications( CBaseObject* pObject );
+
+public:
+	CNetworkVar( int, m_iBuildState );
+	CNetworkVar( unsigned int, m_iCurrentObject );
+	int		m_iCurrentObjectID;
+	CNetworkVar( int, m_iCurrentObjectState );
+
+	// Objects that this builder can build
+	CNetworkArray( bool, m_bObjectValidity, OBJ_LAST );
+	// Buildability of each object
+	CNetworkArray( bool, m_bObjectBuildability, OBJ_LAST );
+
+	// Build data for the current object, propagated when the player starts to build it
+	CNetworkVar( float, m_flStartTime );
+	CNetworkVar( float, m_flTotalTime );
+
+	float	m_flLastRepairTime;
+
+	CNetworkHandle( CBaseObject, m_hObjectBeingBuilt );
+};
+
+
+#endif // WEAPON_BUILDER_H
diff --git a/game/shared/tf2/weapon_combat_basegrenade.cpp b/game/shared/tf2/weapon_combat_basegrenade.cpp
new file mode 100644
index 0000000..470c4b6
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_basegrenade.cpp
@@ -0,0 +1,152 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:	Base class for hand-thrown grenades that work with the handheld shield
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combat_basegrenade.h"
+#include "weapon_combatshield.h"
+#include "in_buttons.h"
+
+LINK_ENTITY_TO_CLASS( weapon_combat_basegrenade, CWeaponCombatBaseGrenade );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatBaseGrenade, DT_WeaponCombatBaseGrenade )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatBaseGrenade, DT_WeaponCombatBaseGrenade )
+#if !defined( CLIENT_DLL )
+	SendPropTime( SENDINFO( m_flStartedThrowAt ) ),
+#else
+	RecvPropTime( RECVINFO( m_flStartedThrowAt ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatBaseGrenade  )
+
+	DEFINE_PRED_FIELD_TOL( m_flStartedThrowAt, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponCombatBaseGrenade::CWeaponCombatBaseGrenade( void )
+{
+	m_flStartedThrowAt = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponCombatBaseGrenade::GetFireRate( void )
+{	
+	return 2.0; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatBaseGrenade::ItemPostFrame( void )
+{
+	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	AllowShieldPostFrame( !m_flStartedThrowAt );
+
+	// Look for button downs
+	if ( (pOwner->m_nButtons & IN_ATTACK) && GetShieldState() == SS_DOWN && !m_flStartedThrowAt && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+	{
+		m_flStartedThrowAt = gpGlobals->curtime;
+
+		SendWeaponAnim( ACT_VM_DRAW );
+	}
+
+	// Look for button ups
+	if ( (pOwner->m_afButtonReleased & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime) && m_flStartedThrowAt )
+	{
+		m_flNextPrimaryAttack = gpGlobals->curtime;
+		PrimaryAttack();
+		m_flStartedThrowAt = 0;
+	}
+
+	//  No buttons down?
+	if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+	{
+		WeaponIdle( );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatBaseGrenade::PrimaryAttack( void )
+{
+	CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	if ( !ComputeEMPFireState() )
+		return;
+
+	// player "shoot" animation
+	PlayAttackAnimation( ACT_VM_THROW );
+
+	ThrowGrenade();
+
+	// Setup for refire
+	m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+	CheckRemoveDisguise();
+
+	// If I'm now out of ammo, switch away
+	if ( !HasPrimaryAmmo() )
+	{
+		pPlayer->SelectLastItem();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatBaseGrenade::ThrowGrenade( void )
+{
+	CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	BaseClass::WeaponSound(WPN_DOUBLE);
+
+	// Calculate launch velocity (3 seconds for max distance)
+	float flThrowTime = MIN( (gpGlobals->curtime - m_flStartedThrowAt), 3.0 );
+	float flSpeed = 650 + (175 * flThrowTime);
+
+	// If the player's crouched, roll the grenade
+	if ( pPlayer->GetFlags() & FL_DUCKING )
+	{
+		// Launch the grenade
+		Vector vecForward;
+		QAngle vecAngles = pPlayer->EyeAngles();
+		// Throw it up just a tad
+		vecAngles.x = -1;
+		AngleVectors( vecAngles, &vecForward, NULL, NULL);
+		Vector vecOrigin;
+		VectorLerp( pPlayer->EyePosition(), pPlayer->GetAbsOrigin(), 0.25f, vecOrigin );
+		vecOrigin += (vecForward * 16);
+		vecForward = vecForward * flSpeed;
+		CreateGrenade(vecOrigin, vecForward, pPlayer );
+	}
+	else
+	{
+		// Launch the grenade
+		Vector vecForward;
+		QAngle vecAngles = pPlayer->EyeAngles();
+		AngleVectors( vecAngles, &vecForward, NULL, NULL);
+		Vector vecOrigin = pPlayer->EyePosition();
+		vecOrigin += (vecForward * 16);
+		vecForward = vecForward * flSpeed;
+		CreateGrenade(vecOrigin, vecForward, pPlayer );
+	}
+
+	pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+}
diff --git a/game/shared/tf2/weapon_combat_basegrenade.h b/game/shared/tf2/weapon_combat_basegrenade.h
new file mode 100644
index 0000000..83fd358
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_basegrenade.h
@@ -0,0 +1,66 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_COMBAT_BASEGRENADE_H
+#define WEAPON_COMBAT_BASEGRENADE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_combat_usedwithshieldbase.h"
+#include "basegrenade_shared.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponCombatBaseGrenade C_WeaponCombatBaseGrenade
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponCombatBaseGrenade : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponCombatBaseGrenade, CWeaponCombatUsedWithShieldBase );
+public:
+	CWeaponCombatBaseGrenade();
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual float	GetFireRate( void );
+	virtual void	ThrowGrenade( void );
+
+	// Custom grenade types
+	virtual CBaseGrenade *CreateGrenade( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner ) { return NULL; }
+
+	/*
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+	*/
+
+public:
+	CNetworkVar( float, m_flStartedThrowAt );
+
+private:														
+	CWeaponCombatBaseGrenade( const CWeaponCombatBaseGrenade & );						
+};
+
+#endif // WEAPON_COMBAT_BASEGRENADE_H
diff --git a/game/shared/tf2/weapon_combat_burstrifle.cpp b/game/shared/tf2/weapon_combat_burstrifle.cpp
new file mode 100644
index 0000000..ca9c3c3
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_burstrifle.cpp
@@ -0,0 +1,327 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Burst rifle & Shield combo
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combatshield.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "in_buttons.h"
+#include "plasmaprojectile.h"
+#include "IEffects.h"
+
+#if defined( CLIENT_DLL )
+#include "fx.h"
+
+#define CWeaponCombatBurstRifle C_WeaponCombatBurstRifle
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+// Damage CVars
+ConVar	weapon_combat_burstrifle_damage( "weapon_combat_burstrifle_damage","10", FCVAR_REPLICATED, "Burst Rifle damage" );
+ConVar	weapon_combat_burstrifle_range( "weapon_combat_burstrifle_range","500", FCVAR_REPLICATED, "Burst Rifle maximum range" );
+ConVar	weapon_combat_burstrifle_ducking_mod( "weapon_combat_burstrifle_ducking_mod", "0.75", FCVAR_REPLICATED, "Burst Rifle ducking speed modifier" );
+
+#define MAX_RIFLE_POWER					3.0
+#define RIFLE_CHARGE_TIME				2.0
+#define BURSTRIFLE_BOOSTED_FIRERATE		0.015f
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponCombatBurstRifle : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponCombatBurstRifle, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatBurstRifle( void );
+
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual float 	GetFireRate( void );
+	virtual float	GetDefaultAnimSpeed( void );
+	virtual const Vector& GetBulletSpread( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+private:
+	CWeaponCombatBurstRifle( const CWeaponCombatBurstRifle & );
+
+public:
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() && 
+			GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	void GetViewmodelBoneControllers( C_BaseViewModel *pViewModel, float controllers[MAXSTUDIOBONECTRLS]);
+	void ViewModelDrawn( C_BaseViewModel *pViewModel );
+
+private:
+
+	void BoostedMuzzleFlash( C_BaseViewModel *pViewModel, const Vector &vecOrigin, const QAngle &angle, float flScale );
+
+	struct model_t			*m_pSpriteBurstRifleFlash[5];
+
+#endif
+};
+
+CWeaponCombatBurstRifle::CWeaponCombatBurstRifle( void )
+{
+	SetPredictionEligible( true );
+}
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatBurstRifle, DT_WeaponCombatBurstRifle )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatBurstRifle, DT_WeaponCombatBurstRifle )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatBurstRifle )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_combat_burstrifle, CWeaponCombatBurstRifle );
+PRECACHE_WEAPON_REGISTER(weapon_combat_burstrifle);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatBurstRifle::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	if ( UsesClipsForAmmo1() )
+	{
+		CheckReload();
+	}
+
+	// Handle firing
+	if ( GetShieldState() == SS_DOWN && !m_bInReload )
+	{
+		if ( (pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+		{
+			if ( m_iClip1 > 0 )
+			{
+				// Fire the plasma shot
+				PrimaryAttack();
+			}
+			else
+			{
+				Reload();
+			}
+		}
+
+		// Reload button (or fire button when we're out of ammo)
+		if ( m_flNextPrimaryAttack <= gpGlobals->curtime ) 
+		{
+			if ( pOwner->m_nButtons & IN_RELOAD ) 
+			{
+				Reload();
+			}
+			else if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+			{
+				if ( !m_iClip1 && HasPrimaryAmmo() )
+				{
+					Reload();
+				}
+			}
+		}
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're charging
+	AllowShieldPostFrame( m_flNextPrimaryAttack <= gpGlobals->curtime || m_bInReload );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the accuracy derived from weapon and player, and return it
+//-----------------------------------------------------------------------------
+const Vector& CWeaponCombatBurstRifle::GetBulletSpread( void )
+{
+	static Vector cone = VECTOR_CONE_5DEGREES;
+	return cone;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatBurstRifle::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+	
+	WeaponSound(SINGLE);
+
+	// Fire the bullets
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecSpread = GetBulletSpread();
+	Vector vecAiming, vecRight, vecUp;
+	pPlayer->EyeVectors( &vecAiming, &vecRight, &vecUp );
+
+	// Add some inaccuracy
+	int seed = 0;
+	float x, y, z;
+	do 
+	{
+		float x1, x2, y1, y2;
+
+		// Note the additional seed because otherwise we get the same set of random #'s and will get stuck
+		//  in an infinite loop here potentially
+		// FIXME:  Can we use a gaussian random # function instead?  ywb
+		x1 = SHARED_RANDOMFLOAT_SEED( -0.5, 0.5, ++seed );
+		x2 = SHARED_RANDOMFLOAT_SEED( -0.5, 0.5, ++seed );
+		y1 = SHARED_RANDOMFLOAT_SEED( -0.5, 0.5, ++seed );
+		y2 = SHARED_RANDOMFLOAT_SEED( -0.5, 0.5, ++seed );
+
+		x = x1 + x2;
+		y = y1 + y2;
+
+		z = x*x+y*y;
+	} while (z > 1);
+	Vector vecDir = vecAiming + x * vecSpread.x * vecRight + y * vecSpread.y * vecUp;
+
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	// Shift it down a bit so the firer can see it
+	Vector right, forward;
+	AngleVectors( pPlayer->EyeAngles() + pPlayer->m_Local.m_vecPunchAngle, &forward, &right, NULL );
+	Vector vecStartSpot = vecSrc;
+
+	// Get the firing position
+#ifdef CLIENT_DLL
+	// On our client, grab the viewmodel's firing position
+	Vector vecWorldOffset = vecStartSpot + Vector(0,0,-8) + right * 12 + forward * 16;
+#else
+	// For everyone else, grab the weapon model's position
+	/*
+	Vector vecWorldOffset;
+	QAngle angIgnore;
+	GetAttachment( LookupAttachment( "muzzle" ), vecWorldOffset, angIgnore );
+	*/
+
+	Vector vecWorldOffset = vecStartSpot + Vector(0,0,-8) + right * 12 + forward * 16;
+#endif
+	Vector gunOffset = vecWorldOffset - vecStartSpot;
+
+	CPowerPlasmaProjectile *pPlasma = CPowerPlasmaProjectile::CreatePredicted( vecStartSpot, vecDir, gunOffset, DMG_ENERGYBEAM, pPlayer );
+	if ( pPlasma )
+	{
+		pPlasma->SetDamage( weapon_combat_burstrifle_damage.GetFloat() );
+		pPlasma->m_hOwner = pPlayer;
+		pPlasma->SetPower( 2.0 );
+		pPlasma->SetMaxRange( weapon_combat_burstrifle_range.GetFloat() );
+		pPlasma->Activate();
+	}
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_iClip1 = m_iClip1 - 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponCombatBurstRifle::GetFireRate( void )
+{	
+	if ( !inv_demo.GetFloat() )
+	{
+		float flFireRate = ( SequenceDuration() * 0.6f ) + SHARED_RANDOMFLOAT( 0.0, 0.035f );
+
+		CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>( GetOwner() );
+		if ( pPlayer )
+		{
+			// Ducking players should fire more rapidly.
+			if ( pPlayer->GetFlags() & FL_DUCKING )
+			{
+				flFireRate *= weapon_combat_burstrifle_ducking_mod.GetFloat();
+			}
+		}
+		
+		return flFireRate;
+	}
+
+	// Get the player and check to see if we are powered up.
+	CBaseTFPlayer *pPlayer = ( CBaseTFPlayer* )GetOwner();
+	if ( pPlayer && pPlayer->HasPowerup( POWERUP_BOOST ) )
+	{
+		return BURSTRIFLE_BOOSTED_FIRERATE;
+	}
+
+	return SHARED_RANDOMFLOAT( 0.075f, 0.15f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Match the anim speed to the weapon speed while crouching
+//-----------------------------------------------------------------------------
+float CWeaponCombatBurstRifle::GetDefaultAnimSpeed( void )
+{
+	if ( GetOwner() && GetOwner()->IsPlayer() )
+	{
+		if ( GetOwner()->GetFlags() & FL_DUCKING )
+			return (1.0 + (1.0 - weapon_combat_burstrifle_ducking_mod.GetFloat()) );
+	}
+
+	return 1.0;
+}
+
+#if defined ( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatBurstRifle::GetViewmodelBoneControllers( C_BaseViewModel *pViewModel, 
+														   float controllers[MAXSTUDIOBONECTRLS])
+{
+	float flAmmoCount;
+	C_BaseTFPlayer *pPlayer = ( C_BaseTFPlayer* )GetOwner();
+	if ( pPlayer && pPlayer->IsDamageBoosted() )
+	{
+		flAmmoCount = random->RandomFloat( 0.0f, 1.0f );
+	}
+	else
+	{
+		// Dial shows ammo count!
+		flAmmoCount = ( float )m_iClip1 / ( float )GetMaxClip1();
+	}
+
+	// Add some shake
+	flAmmoCount += RandomFloat( -0.02, 0.02 );
+	controllers[0] = flAmmoCount;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatBurstRifle::ViewModelDrawn( C_BaseViewModel *pViewModel )
+{
+	C_BaseTFPlayer *pPlayer = ( C_BaseTFPlayer* )GetOwner();
+	if ( pPlayer && pPlayer->IsDamageBoosted() )
+	{			
+		Vector vecBarrelPos;
+		QAngle angMuzzle;
+		int iAttachment = pViewModel->LookupAttachment( "muzzle" );
+		pViewModel->GetAttachment( iAttachment, vecBarrelPos, angMuzzle );
+
+		unsigned char color[3];
+		color[0] = 50;
+		color[1] = 128;
+		color[2] = 50;
+		FX_Smoke( vecBarrelPos, angMuzzle, 0.5, 1, &color[0], 192 );
+	}
+}
+#endif
diff --git a/game/shared/tf2/weapon_combat_chargeableplasma.cpp b/game/shared/tf2/weapon_combat_chargeableplasma.cpp
new file mode 100644
index 0000000..3507030
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_chargeableplasma.cpp
@@ -0,0 +1,322 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Chargeable Plasma & Shield combo
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "weapon_combatshield.h"
+#include "tf_guidedplasma.h"
+#include "in_buttons.h"
+#include "tf_gamerules.h"
+
+#define BURST_FIRE_RATE			0.15
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponCombat_ChargeablePlasma : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponCombat_ChargeablePlasma, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_SERVERCLASS();
+
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual float 	GetFireRate( void );
+	virtual void	Spawn();
+	virtual bool	Deploy( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	virtual void	Precache( void );
+	virtual	void	GainedNewTechnology( CBaseTechnology *pTechnology );
+	virtual CBaseEntity *GetLockTarget( void );
+
+private:
+	CNetworkVar( bool, m_bCharging );
+	float	m_flChargeStartTime;
+	float	m_flPower;
+	float	m_flNextBurstShotTime;
+	int		m_iBurstShotsRemaining;
+	bool	m_bHasBurstShot;
+	bool	m_bHasCharge;
+
+	// Guidance
+	EHANDLE	m_hLockTarget;
+	Vector	m_vecTargetOffset;
+	float	m_flLockedAt;
+};
+
+IMPLEMENT_SERVERCLASS_ST(CWeaponCombat_ChargeablePlasma, DT_WeaponCombat_ChargeablePlasma )
+	SendPropInt( SENDINFO( m_bCharging ), 1, SPROP_UNSIGNED ),
+END_SEND_TABLE()
+
+LINK_ENTITY_TO_CLASS( weapon_combat_chargeableplasma, CWeaponCombat_ChargeablePlasma );
+PRECACHE_WEAPON_REGISTER(weapon_combat_chargeableplasma);
+
+
+//-----------------------------------------------------------------------------
+// Spawn weapon
+//-----------------------------------------------------------------------------
+void CWeaponCombat_ChargeablePlasma::Spawn()
+{
+	BaseClass::Spawn();
+	m_bHasBurstShot = false;
+	m_bHasCharge = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombat_ChargeablePlasma::Precache( void )
+{
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// New technologies: 
+//-----------------------------------------------------------------------------
+void CWeaponCombat_ChargeablePlasma::GainedNewTechnology( CBaseTechnology *pTechnology )
+{
+	BaseClass::GainedNewTechnology( pTechnology );
+
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( (CBaseEntity*)GetOwner() );
+	if ( pPlayer )
+	{
+		// Charge-up mode?
+		if ( pPlayer->HasNamedTechnology( "com_comboshield_charge" ) )
+		{
+			m_bHasCharge = true;
+		}
+		else
+		{
+			m_bHasCharge = false;
+		}
+
+		// Burst shot mode?
+		if ( pPlayer->HasNamedTechnology( "com_comboshield_tripleshot" ) )
+		{
+			m_bHasBurstShot = true;
+		}
+		else
+		{
+			m_bHasBurstShot = false;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombat_ChargeablePlasma::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	if ( UsesClipsForAmmo1() )
+	{
+		CheckReload();
+	}
+
+	// If burst shots are firing, ignore input
+	if ( m_iBurstShotsRemaining > 0 )
+	{
+		if ( gpGlobals->curtime < m_flNextBurstShotTime )
+			return;
+
+		if ( m_iClip1 > 0 )
+		{
+			PrimaryAttack();
+		}
+
+		m_iBurstShotsRemaining--;
+		m_flNextBurstShotTime = gpGlobals->curtime + BURST_FIRE_RATE;
+		m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+		return;
+	}
+
+	// Handle charge firing
+	if ( m_iClip1 > 0 && GetShieldState() == SS_DOWN && !m_bInReload )
+	{
+		if ( (pOwner->m_nButtons & IN_ATTACK ) )
+		{
+			if (m_bHasCharge)
+			{
+				if ( !m_bCharging && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+				{
+					m_bCharging = true;
+					m_flChargeStartTime = gpGlobals->curtime;
+
+					// Get a lock target right now
+					m_hLockTarget = GetLockTarget();
+				}
+			}
+			else
+			{
+				// Fire the plasma shot
+				if (m_flNextPrimaryAttack <= gpGlobals->curtime)
+					PrimaryAttack();
+			}
+		}
+		else if ( m_bCharging )
+		{
+			m_bCharging = false;
+
+			// Fire the plasma shot
+			PrimaryAttack();
+
+			// We might be firing a burst shot
+			if (m_bHasBurstShot)
+			{
+				if ( m_flPower >= (MAX_CHARGED_TIME * 0.5) )
+				{
+					if ( m_flPower >= MAX_CHARGED_TIME )
+					{
+						m_iBurstShotsRemaining = 2;
+					}
+					else
+					{
+						m_iBurstShotsRemaining = 1;
+					}
+
+					m_flNextBurstShotTime = gpGlobals->curtime + BURST_FIRE_RATE;
+				}
+			}
+		}
+	}
+
+	// Reload button
+	if ( m_iBurstShotsRemaining == 0 && !m_bCharging )
+	{
+		if ( pOwner->m_nButtons & IN_RELOAD && UsesClipsForAmmo1() && !m_bInReload )
+		{
+			Reload();
+		}
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're charging
+	AllowShieldPostFrame( !m_bCharging && ((m_flNextPrimaryAttack <= gpGlobals->curtime) || m_bInReload) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombat_ChargeablePlasma::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+	
+	WeaponSound(SINGLE);
+
+	// Fire the bullets
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+
+	// If we already have a lock target from button down, see if we shouldn't try and get a new one
+	// Only do this is the button was released immediately
+	if ( !m_hLockTarget || ( m_flLockedAt < gpGlobals->curtime ) )
+	{
+		m_hLockTarget = GetLockTarget();
+	}
+
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	// Shift it down a bit so the firer can see it
+	Vector right;
+	AngleVectors( pPlayer->EyeAngles() + pPlayer->m_Local.m_vecPunchAngle, NULL, &right, NULL );
+	Vector vecStartSpot = vecSrc + Vector(0,0,-8) + right * 12;
+
+	CGuidedPlasma *pShot = CGuidedPlasma::Create(vecStartSpot, vecAiming, m_hLockTarget, m_vecTargetOffset, pPlayer);
+
+	// Set it's charged power level
+	if (m_bHasCharge)
+		m_flPower = MIN( MAX_CHARGED_TIME, gpGlobals->curtime - m_flChargeStartTime );
+	else
+		m_flPower = 0.0f;
+
+	float flDamageMult = RemapVal( m_flPower, 0, MAX_CHARGED_TIME, 1.0, MAX_CHARGED_POWER );
+	pShot->SetPowerLevel( flDamageMult );
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_iClip1 = m_iClip1 - 1;
+	m_hLockTarget = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponCombat_ChargeablePlasma::GetFireRate( void )
+{	
+	return SequenceDuration();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponCombat_ChargeablePlasma::Deploy( void )
+{
+	if ( BaseClass::Deploy() )
+	{
+		GainedNewTechnology(NULL);
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Our player just died
+//-----------------------------------------------------------------------------
+bool CWeaponCombat_ChargeablePlasma::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	bool bReturn = BaseClass::Holster(pSwitchingTo);
+
+	// Stop the charging sound
+	if ( m_bCharging )
+	{
+		m_bCharging = false;
+	}
+
+	return bReturn;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Try and find an entity to lock onto
+//-----------------------------------------------------------------------------
+CBaseEntity *CWeaponCombat_ChargeablePlasma::GetLockTarget( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if ( !pPlayer )
+		return NULL;
+
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+	Vector vecEnd = vecSrc + vecAiming * MAX_TRACE_LENGTH;
+
+	trace_t tr;
+	TFGameRules()->WeaponTraceLine( vecSrc, vecEnd, MASK_SHOT, pPlayer, GetDamageType(), &tr );
+
+	if ( (tr.fraction < 1.0f) && tr.m_pEnt )
+	{
+		CBaseEntity *pTargetEntity = tr.m_pEnt;
+
+		// Don't guide on same team or on anything other than players, objects, and NPCs
+		if ( pTargetEntity->InSameTeam(pPlayer) || (!pTargetEntity->IsPlayer() 
+			&& (pTargetEntity->MyNPCPointer() == NULL)) )
+			return NULL;
+
+		// Compute the target offset relative to the target
+		Vector vecWorldOffset;
+		VectorSubtract( tr.endpos, pTargetEntity->GetAbsOrigin(), vecWorldOffset );
+		VectorIRotate( vecWorldOffset, pTargetEntity->EntityToWorldTransform(), m_vecTargetOffset ); 
+		m_flLockedAt = gpGlobals->curtime + 0.2;
+		return pTargetEntity;
+	}
+
+	return NULL;
+}
diff --git a/game/shared/tf2/weapon_combat_grenade.cpp b/game/shared/tf2/weapon_combat_grenade.cpp
new file mode 100644
index 0000000..781b710
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_grenade.cpp
@@ -0,0 +1,97 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:	The Commando's anti-personnel grenades
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "weapon_combat_basegrenade.h"
+#include "weapon_combatshield.h"
+#include "in_buttons.h"
+
+#if !defined( CLIENT_DLL )
+#include "grenade_antipersonnel.h"
+#else
+#define CWeaponCombatGrenade C_WeaponCombatGrenade
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+class CBaseGrenade;
+
+//-----------------------------------------------------------------------------
+// Purpose: Combo shield & grenade weapon
+//-----------------------------------------------------------------------------
+class CWeaponCombatGrenade : public CWeaponCombatBaseGrenade
+{
+	DECLARE_CLASS( CWeaponCombatGrenade, CWeaponCombatBaseGrenade );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatGrenade();
+
+	virtual void Precache( void );
+	virtual CBaseGrenade *CreateGrenade( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+private:														
+	CWeaponCombatGrenade( const CWeaponCombatGrenade & );						
+
+};
+
+CWeaponCombatGrenade::CWeaponCombatGrenade( void )
+{
+	SetPredictionEligible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatGrenade::Precache( void )
+{
+	BaseClass::Precache();
+#if !defined( CLIENT_DLL )
+	UTIL_PrecacheOther( "grenade_antipersonnel" );
+#endif
+}
+
+CBaseGrenade *CWeaponCombatGrenade::CreateGrenade( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner )
+{
+#if !defined( CLIENT_DLL )
+	return CGrenadeAntiPersonnel::Create(vecOrigin, vecAngles, pOwner );
+#else
+	return NULL;
+#endif
+}
+
+
+LINK_ENTITY_TO_CLASS( weapon_combat_grenade, CWeaponCombatGrenade );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatGrenade, DT_WeaponCombatGrenade )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatGrenade, DT_WeaponCombatGrenade )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatGrenade )
+END_PREDICTION_DATA()
+
+PRECACHE_WEAPON_REGISTER(weapon_combat_grenade);
diff --git a/game/shared/tf2/weapon_combat_grenade_emp.cpp b/game/shared/tf2/weapon_combat_grenade_emp.cpp
new file mode 100644
index 0000000..feb6062
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_grenade_emp.cpp
@@ -0,0 +1,92 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:	The Commando's anti-personnel grenades
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "Sprite.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "weapon_combat_basegrenade.h"
+#include "weapon_combatshield.h"
+#include "in_buttons.h"
+#include "grenade_emp.h"
+
+
+#if defined( CLIENT_DLL )
+
+#define CWeaponCombatGrenadeEMP C_WeaponCombatGrenadeEMP
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Combo shield & grenade weapon
+//-----------------------------------------------------------------------------
+class CWeaponCombatGrenadeEMP : public CWeaponCombatBaseGrenade
+{
+	DECLARE_CLASS( CWeaponCombatGrenadeEMP, CWeaponCombatBaseGrenade );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatGrenadeEMP();
+
+	virtual void Precache( void );
+	virtual CBaseGrenade *CreateGrenade( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+private:														
+	CWeaponCombatGrenadeEMP( const CWeaponCombatGrenadeEMP & );						
+
+};
+
+LINK_ENTITY_TO_CLASS( weapon_combat_grenade_emp, CWeaponCombatGrenadeEMP );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatGrenadeEMP, DT_WeaponCombatGrenadeEMP )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatGrenadeEMP, DT_WeaponCombatGrenadeEMP )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatGrenadeEMP )
+END_PREDICTION_DATA()
+
+PRECACHE_WEAPON_REGISTER(weapon_combat_grenade_emp);
+
+CWeaponCombatGrenadeEMP::CWeaponCombatGrenadeEMP( void )
+{
+	SetPredictionEligible( true );
+}
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatGrenadeEMP::Precache( void )
+{
+	BaseClass::Precache();
+#if !defined( CLIENT_DLL )
+	UTIL_PrecacheOther( "grenade_emp" );
+#endif
+}
+
+CBaseGrenade *CWeaponCombatGrenadeEMP::CreateGrenade( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner )
+{
+	return CGrenadeEMP::Create(vecOrigin, vecAngles, pOwner );
+}
diff --git a/game/shared/tf2/weapon_combat_laserrifle.cpp b/game/shared/tf2/weapon_combat_laserrifle.cpp
new file mode 100644
index 0000000..e751686
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_laserrifle.cpp
@@ -0,0 +1,375 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Laser Rifle & Shield combo
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "weapon_combatshield.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "in_buttons.h"
+#include "takedamageinfo.h"
+#include "beam_shared.h"
+#include "tf_gamerules.h"
+
+// Damage CVars
+ConVar	weapon_combat_laserrifle_damage( "weapon_combat_laserrifle_damage","20", FCVAR_REPLICATED, "Laser rifle damage" );
+ConVar	weapon_combat_laserrifle_range( "weapon_combat_laserrifle_range","1000", FCVAR_REPLICATED, "Laser rifle maximum range" );
+ConVar	weapon_combat_laserrifle_ducking_mod( "weapon_combat_laserrifle_ducking_mod", "0.75", FCVAR_REPLICATED, "Laser rifle ducking ROF modifier" );
+
+#if defined( CLIENT_DLL )
+#include "fx.h"
+#include "hud.h"
+#include "c_te_effect_dispatch.h"
+#include <vgui/ISurface.h>
+
+#define CWeaponCombatLaserRifle C_WeaponCombatLaserRifle
+
+#else
+
+#include "te_effect_dispatch.h"
+
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponCombatLaserRifle : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponCombatLaserRifle, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatLaserRifle( void );
+
+	virtual const Vector& GetBulletSpread( void );
+	virtual void	ItemBusyFrame( void );
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual float 	GetFireRate( void );
+	virtual float	GetDefaultAnimSpeed( void );
+	virtual void	BulletWasFired( const Vector &vecStart, const Vector &vecEnd );
+
+	void			RecalculateAccuracy( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool	IsPredicted( void ) const
+	{ 
+		return true;
+	}
+private:
+	CWeaponCombatLaserRifle( const CWeaponCombatLaserRifle & );
+
+public:
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() && 
+			GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+	virtual void	DrawCrosshair( void );
+#endif
+
+private:
+	float	m_flInaccuracy;
+	float	m_flAccuracyTime;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponCombatLaserRifle::CWeaponCombatLaserRifle( void )
+{
+	SetPredictionEligible( true );
+	m_flInaccuracy = 0;
+	m_flAccuracyTime = 0;
+}
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatLaserRifle, DT_WeaponCombatLaserRifle )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatLaserRifle, DT_WeaponCombatLaserRifle )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatLaserRifle )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_combat_laserrifle, CWeaponCombatLaserRifle );
+PRECACHE_WEAPON_REGISTER(weapon_combat_laserrifle);
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the accuracy derived from weapon and player, and return it
+//-----------------------------------------------------------------------------
+const Vector& CWeaponCombatLaserRifle::GetBulletSpread( void )
+{
+	static Vector cone = VECTOR_CONE_8DEGREES;
+	return cone;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatLaserRifle::ItemBusyFrame( void )
+{
+	BaseClass::ItemBusyFrame();
+
+	RecalculateAccuracy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatLaserRifle::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	if ( UsesClipsForAmmo1() )
+	{
+		CheckReload();
+	}
+
+	RecalculateAccuracy();
+
+	// Handle firing
+	if ( GetShieldState() == SS_DOWN && !m_bInReload )
+	{
+		if ( (pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+		{
+			if ( m_iClip1 > 0 )
+			{
+				// Fire the plasma shot
+				PrimaryAttack();
+			}
+			else
+			{
+				Reload();
+			}
+		}
+
+		// Reload button (or fire button when we're out of ammo)
+		if ( m_flNextPrimaryAttack <= gpGlobals->curtime ) 
+		{
+			if ( pOwner->m_nButtons & IN_RELOAD ) 
+			{
+				Reload();
+			}
+			else if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+			{
+				if ( !m_iClip1 && HasPrimaryAmmo() )
+				{
+					Reload();
+				}
+			}
+		}
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're charging
+	AllowShieldPostFrame( m_flNextPrimaryAttack <= gpGlobals->curtime || m_bInReload );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatLaserRifle::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+	
+	WeaponSound(SINGLE);
+
+	// Fire the bullets
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	// Reduce the spread if the player's ducking
+	Vector vecSpread = GetBulletSpread();
+	vecSpread *= m_flInaccuracy;
+
+	TFGameRules()->FireBullets( CTakeDamageInfo( this, pPlayer, weapon_combat_laserrifle_damage.GetFloat(), DMG_PLASMA), 1, 
+		vecSrc, vecAiming, vecSpread, weapon_combat_laserrifle_range.GetFloat(), m_iPrimaryAmmoType, 0, entindex(), 0 );
+
+	m_flInaccuracy += 0.3;
+	m_flInaccuracy = clamp(m_flInaccuracy, 0, 1);
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_iClip1 = m_iClip1 - 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponCombatLaserRifle::GetFireRate( void )
+{	
+	float flFireRate = ( SequenceDuration() * 0.4 ) + SHARED_RANDOMFLOAT( 0.0, 0.035f );
+
+	CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>( GetOwner() );
+	if ( pPlayer )
+	{
+		// Ducking players should fire more rapidly.
+		if ( pPlayer->GetFlags() & FL_DUCKING )
+		{
+			flFireRate *= weapon_combat_laserrifle_ducking_mod.GetFloat();
+		}
+	}
+	
+	return flFireRate;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatLaserRifle::RecalculateAccuracy( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+
+	m_flAccuracyTime += gpGlobals->frametime;
+
+	while ( m_flAccuracyTime > 0.05 )
+	{
+		if ( !(pPlayer->GetFlags() & FL_ONGROUND) )
+		{
+			m_flInaccuracy += 0.05;
+		}
+		else if ( pPlayer->GetFlags() & FL_DUCKING )
+		{
+			m_flInaccuracy -= 0.08;
+		}
+/*
+		else if ( pPlayer->GetLocalVelocity().LengthSqr() > (100*100) )
+		{
+			// Never get worse than 1/2 accuracy from running
+			if ( m_flInaccuracy < 0.25 )
+			{
+				m_flInaccuracy += 0.01;
+				if ( m_flInaccuracy > 0.5 )
+				{
+					m_flInaccuracy = 0.5;
+				}
+			}
+			else if ( m_flInaccuracy > 0.25 )
+			{
+				m_flInaccuracy -= 0.01;
+			}
+		}
+*/
+		else
+		{
+			m_flInaccuracy -= 0.04;
+		}
+
+		// Crouching prevents accuracy ever going beyond a point
+		if ( pPlayer->GetFlags() & FL_DUCKING )
+		{
+			m_flInaccuracy = clamp(m_flInaccuracy, 0, 0.8);
+		}
+		else
+		{
+			m_flInaccuracy = clamp(m_flInaccuracy, 0, 1);
+		}
+
+		m_flAccuracyTime -= 0.05;
+
+#ifndef CLIENT_DLL
+		//if ( m_flInaccuracy )
+			//Msg("Inaccuracy %.2f (%.2f)\n", m_flInaccuracy, gpGlobals->curtime );
+#endif
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Match the anim speed to the weapon speed while crouching
+//-----------------------------------------------------------------------------
+float CWeaponCombatLaserRifle::GetDefaultAnimSpeed( void )
+{
+	if ( GetOwner() && GetOwner()->IsPlayer() )
+	{
+		if ( GetOwner()->GetFlags() & FL_DUCKING )
+			return (1.0 + (1.0 - weapon_combat_laserrifle_ducking_mod.GetFloat()) );
+	}
+
+	return 1.0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the laser rifle effect
+//-----------------------------------------------------------------------------
+void CWeaponCombatLaserRifle::BulletWasFired( const Vector &vecStart, const Vector &vecEnd )
+{
+	// Humans fire jazzed up bullets, Aliens fire laserbeams
+	if ( GetTeamNumber() == TEAM_HUMANS )
+	{
+		UTIL_Tracer( (Vector&)vecStart, (Vector&)vecEnd, entindex(), 1, 5000, false, "HLaserTracer" );
+	}
+	else
+	{
+		UTIL_Tracer( (Vector&)vecStart, (Vector&)vecEnd, entindex(), 1, 5000, false, "ALaserTracer" );
+	}
+}
+
+#ifdef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: Draw the weapon's crosshair
+//-----------------------------------------------------------------------------
+void CWeaponCombatLaserRifle::DrawCrosshair( void )
+{
+	BaseClass::DrawCrosshair();
+
+	// Draw the targeting zone around the crosshair
+	int r, g, b, a;
+	gHUD.m_clrYellowish.GetColor( r, g, b, a );
+
+	// Check to see if we are in vgui mode
+	C_BaseTFPlayer *pPlayer	= static_cast<C_BaseTFPlayer*>( GetOwner() );
+	if ( !pPlayer || pPlayer->IsInVGuiInputMode() )
+		return;
+
+	// Draw a crosshair & accuracy hoodad
+	int iBarWidth = XRES(10);
+	int iBarHeight = YRES(10);
+	int iTotalWidth = (iBarWidth * 2) + (40 * m_flInaccuracy) + XRES(10);
+	int iTotalHeight = (iBarHeight * 2) + (40 * m_flInaccuracy) + YRES(10);
+	
+	// Horizontal bars
+	int iLeft = (ScreenWidth() - iTotalWidth) / 2;
+	int iMidHeight = (ScreenHeight() / 2);
+
+	Color dark( r, g, b, 32 );
+	Color light( r, g, b, 160 );
+
+	vgui::surface()->DrawSetColor( dark );
+
+	vgui::surface()->DrawFilledRect( iLeft, iMidHeight-1, iLeft+ iBarWidth, iMidHeight + 2 );
+	vgui::surface()->DrawFilledRect( iLeft + iTotalWidth - iBarWidth, iMidHeight-1, iLeft + iTotalWidth, iMidHeight + 2 );
+
+	vgui::surface()->DrawSetColor( light );
+
+	vgui::surface()->DrawFilledRect( iLeft, iMidHeight, iLeft + iBarWidth, iMidHeight + 1 );
+	vgui::surface()->DrawFilledRect( iLeft + iTotalWidth - iBarWidth, iMidHeight, iLeft + iTotalWidth, iMidHeight + 1 );
+	
+	// Vertical bars
+	int iTop = (ScreenHeight() - iTotalHeight) / 2;
+	int iMidWidth = (ScreenWidth() / 2);
+
+	vgui::surface()->DrawSetColor( dark );
+	
+	vgui::surface()->DrawFilledRect( iMidWidth-1, iTop, iMidWidth + 2, iTop + iBarHeight );
+	vgui::surface()->DrawFilledRect( iMidWidth-1, iTop + iTotalHeight - iBarHeight, iMidWidth + 2, iTop + iTotalHeight );
+
+	vgui::surface()->DrawSetColor( light );
+
+	vgui::surface()->DrawFilledRect( iMidWidth, iTop, iMidWidth + 1, iTop + iBarHeight );
+	vgui::surface()->DrawFilledRect( iMidWidth, iTop + iTotalHeight - iBarHeight, iMidWidth + 1, iTop + iTotalHeight );
+}
+#endif
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_combat_plasma_grenade_launcher.cpp b/game/shared/tf2/weapon_combat_plasma_grenade_launcher.cpp
new file mode 100644
index 0000000..17431ad
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_plasma_grenade_launcher.cpp
@@ -0,0 +1,195 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Burst rifle & Shield combo
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combatshield.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "in_buttons.h"
+#include "plasmaprojectile.h"
+
+#if !defined( CLIENT_DLL )
+
+#include "grenade_antipersonnel.h"
+
+#else
+
+#define CWeaponCombatPlasmaGrenadeLauncher C_WeaponCombatPlasmaGrenadeLauncher
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+// Damage CVars
+ConVar	weapon_combat_plasmagrenadelauncher_damage( "weapon_combat_plasmagrenadelauncher_damage","40", FCVAR_REPLICATED, "Burst Rifle damage" );
+ConVar	weapon_combat_plasmagrenadelauncher_radius( "weapon_combat_plasmagrenadelauncher_radius","100", FCVAR_REPLICATED, "Burst Rifle maximum range" );
+
+
+#define MAX_RIFLE_POWER		3.0
+#define RIFLE_CHARGE_TIME	2.0
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponCombatPlasmaGrenadeLauncher : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponCombatPlasmaGrenadeLauncher, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatPlasmaGrenadeLauncher();
+
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual float 	GetFireRate( void );
+	virtual void	Precache( void );
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() && 
+			GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+private:
+	CWeaponCombatPlasmaGrenadeLauncher( const CWeaponCombatPlasmaGrenadeLauncher & );
+
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatPlasmaGrenadeLauncher, DT_WeaponCombatPlasmaGrenadeLauncher )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatPlasmaGrenadeLauncher, DT_WeaponCombatPlasmaGrenadeLauncher )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatPlasmaGrenadeLauncher )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_combat_plasmagrenadelauncher, CWeaponCombatPlasmaGrenadeLauncher );
+PRECACHE_WEAPON_REGISTER(weapon_combat_plasmagrenadelauncher);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponCombatPlasmaGrenadeLauncher::CWeaponCombatPlasmaGrenadeLauncher()
+{
+	m_bReloadsSingly = true;
+	SetPredictionEligible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaGrenadeLauncher::Precache( void )
+{
+	BaseClass::Precache();
+#if !defined( CLIENT_DLL )
+	UTIL_PrecacheOther( "grenade_antipersonnel" );
+#endif
+	PrecacheModel( "models/weapons/w_grenade.mdl" );
+}
+
+void CWeaponCombatPlasmaGrenadeLauncher::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	if ( UsesClipsForAmmo1() )
+	{
+		CheckReload();
+	}
+
+	// Handle firing
+	if ( GetShieldState() == SS_DOWN && !m_bInReload )
+	{
+		if ( (pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+		{
+			if ( m_iClip1 > 0 )
+			{
+				// Fire the plasma shot
+				PrimaryAttack();
+			}
+			else
+			{
+				Reload();
+			}
+		}
+
+		// Reload button (or fire button when we're out of ammo)
+		if ( m_flNextPrimaryAttack <= gpGlobals->curtime ) 
+		{
+			if ( pOwner->m_nButtons & IN_RELOAD ) 
+			{
+				Reload();
+			}
+			else if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+			{
+				if ( !m_iClip1 && HasPrimaryAmmo() )
+				{
+					Reload();
+				}
+			}
+		}
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're charging
+	AllowShieldPostFrame( m_flNextPrimaryAttack <= gpGlobals->curtime || m_bInReload );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaGrenadeLauncher::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+	
+	WeaponSound(SINGLE);
+
+	// Fire the bullets
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	// Launch the grenade
+	Vector vecForward;
+	pPlayer->EyeVectors( &vecForward );
+	Vector vecOrigin = pPlayer->EyePosition();
+	vecOrigin += (vecForward);
+
+#if !defined( CLIENT_DLL )
+	float flSpeed = 1200;
+
+	CGrenadeAntiPersonnel* pGrenade = CGrenadeAntiPersonnel::Create(vecOrigin, vecForward * flSpeed, pPlayer );
+	pGrenade->SetModel( "models/weapons/w_grenade.mdl" );
+	pGrenade->SetBounceSound( "PlasmaGrenade.Bounce" );
+	pGrenade->SetDamage( weapon_combat_plasmagrenadelauncher_damage.GetFloat() );
+	pGrenade->SetDamageRadius( weapon_combat_plasmagrenadelauncher_radius.GetFloat() );
+	pGrenade->SetExplodeOnContact( true );
+#endif
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_iClip1 = m_iClip1 - 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponCombatPlasmaGrenadeLauncher::GetFireRate( void )
+{	
+	return SequenceDuration() * 3;
+}
diff --git a/game/shared/tf2/weapon_combat_plasmarifle.cpp b/game/shared/tf2/weapon_combat_plasmarifle.cpp
new file mode 100644
index 0000000..2ede901
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_plasmarifle.cpp
@@ -0,0 +1,559 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Chargeable Plasma & Shield combo
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combatshield.h"
+#include "in_buttons.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "plasmaprojectile.h"
+#include "in_buttons.h"
+#include "tf_shareddefs.h"
+
+#if defined( CLIENT_DLL )
+
+#include "iefx.h"
+#include "dlight.h"
+#include "clienteffectprecachesystem.h"
+#include "beamdraw.h"
+
+#define CWeaponCombatPlasmaRifle C_WeaponCombatPlasmaRifle
+#define CWeaponCombatPlasmaRifleHuman C_WeaponCombatPlasmaRifleHuman
+#define CWeaponCombatPlasmaRifleAlien C_WeaponCombatPlasmaRifleAlien
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+#if defined( CLIENT_DLL )
+
+class CChargeBall;
+// Precache the effects
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheWeaponCombatPlasmaRifle )
+CLIENTEFFECT_MATERIAL( "sprites/chargeball_team1" )
+CLIENTEFFECT_MATERIAL( "sprites/chargeball_team2" )
+CLIENTEFFECT_REGISTER_END()
+
+#endif
+
+// Damage CVars
+ConVar	weapon_combat_plasmarifle_damage( "weapon_combat_plasmarifle_damage","10", FCVAR_REPLICATED, "Plasma Rifle maximum damage" );
+ConVar	weapon_combat_plasmarifle_range( "weapon_combat_plasmarifle_range","500", FCVAR_REPLICATED, "Plasma Rifle maximum range" );
+ConVar	weapon_combat_plasmarifle_radius( "weapon_combat_plasmarifle_radius","90", FCVAR_REPLICATED, "Plasma Rifle explosion radius when charged" );
+ConVar	weapon_combat_plasmarifle_ducking_mod( "weapon_combat_plasmarifle_ducking_mod", "0.6f", FCVAR_REPLICATED, "Plasma Rifle ducking speed modifier" );
+
+//-----------------------------------------------------------------------------
+// Purpose: Shared viersion of CWeaponCombatPlasmaRifle
+//-----------------------------------------------------------------------------
+class CWeaponCombatPlasmaRifle : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponCombatPlasmaRifle, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+#if !defined( CLIENT_DLL )
+	DECLARE_DATADESC();
+#endif
+
+	CWeaponCombatPlasmaRifle( void ) {}
+
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual float 	GetFireRate( void );
+	virtual void	Spawn();
+	virtual bool	Deploy( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	void			ChargeThink( void );
+	virtual float	GetDefaultAnimSpeed( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+private:
+	CWeaponCombatPlasmaRifle( const CWeaponCombatPlasmaRifle & );
+public:
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() && 
+			GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual int		DrawModel( int flags );
+	virtual void	ViewModelDrawn( CBaseViewModel *pBaseViewModel );
+	virtual void	ClientThink( );
+	virtual bool	IsTransparent( );
+private:
+	// Purpose: Draws the charging effect
+	void DrawChargingEffect( float flSize, CBaseAnimating *pAttachedEnt );
+	CMaterialReference m_hMaterial;
+
+#endif
+private:
+	CNetworkVar( float, m_flPower );
+	CNetworkVar( bool, m_bCharging );
+};
+
+//-----------------------------------------------------------------------------
+// Spawn weapon
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaRifle::Spawn()
+{
+	BaseClass::Spawn();
+	m_flPower = 1;
+	m_bCharging = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaRifle::ItemPostFrame( void )
+{
+	ChargeThink();
+
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	if ( UsesClipsForAmmo1() )
+	{
+		CheckReload();
+	}
+
+	// Handle charge firing
+	if ( GetShieldState() == SS_DOWN && !m_bInReload )
+	{
+		if ( (pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+		{
+			if ( m_iClip1 > 0 )
+			{
+				// Fire the plasma shot
+				PrimaryAttack();
+				m_flPower = 1.0;
+			}
+			else
+			{
+				Reload();
+			}
+		}
+
+		// Reload button (or fire button when we're out of ammo)
+		if ( m_flNextPrimaryAttack <= gpGlobals->curtime ) 
+		{
+			if ( pOwner->m_nButtons & IN_RELOAD ) 
+			{
+				Reload();
+			}
+			else if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+			{
+				if ( !m_iClip1 && HasPrimaryAmmo() )
+				{
+					Reload();
+				}
+			}
+		}
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're charging
+	AllowShieldPostFrame( m_flNextPrimaryAttack <= gpGlobals->curtime || m_bInReload );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaRifle::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+	
+	WeaponSound(SINGLE);
+
+	// Fire the bullets
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	// Shift it down a bit so the firer can see it
+	Vector right, forward;
+	AngleVectors( pPlayer->EyeAngles() + pPlayer->m_Local.m_vecPunchAngle, &forward, &right, NULL );
+	Vector vecStartSpot = vecSrc;
+
+	Vector gunOffset = Vector(0,0,-8) + right * 12 + forward * 16;
+
+	CPowerPlasmaProjectile *pPlasma = CPowerPlasmaProjectile::CreatePredicted( vecStartSpot, vecAiming, gunOffset, DMG_ENERGYBEAM, pPlayer );
+	if ( pPlasma )
+	{
+		pPlasma->SetDamage( m_flPower * weapon_combat_plasmarifle_damage.GetFloat() );
+		pPlasma->m_hOwner = pPlayer;
+		pPlasma->SetPower( m_flPower );
+		// Calculate range based upon charge power
+		float flRange = weapon_combat_plasmarifle_range.GetFloat() + RemapVal( m_flPower, 1.0, MAX_RIFLE_POWER, 0, weapon_combat_plasmarifle_range.GetFloat() * 0.75 );
+		pPlasma->SetMaxRange( flRange );
+		pPlasma->Activate();
+	}
+
+	// Go explosive if fully charged
+//	if ( m_flPower >= MAX_RIFLE_POWER )
+//	{
+//		pPlasma->SetExplosive( weapon_combat_plasmarifle_radius.GetFloat() );
+//		pPlasma->SetPlasmaType( PLASMATYPE_PLASMABALL_EXPLOSIVE );
+//	}
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_iClip1 = m_iClip1 - 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponCombatPlasmaRifle::GetFireRate( void )
+{
+	float flFireRate = ( SequenceDuration() * 0.4 ) + SHARED_RANDOMFLOAT( 0.0, 0.035f );
+
+	// Get the player.
+	CBaseTFPlayer *pPlayer = ( CBaseTFPlayer* )GetOwner();
+	if ( pPlayer )
+	{
+		// Fire more rapidly when we are ducking.
+		if ( pPlayer->GetFlags() & FL_DUCKING )
+		{
+			flFireRate *= weapon_combat_plasmarifle_ducking_mod.GetFloat();
+		}
+	}
+
+	return flFireRate;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponCombatPlasmaRifle::Deploy( void )
+{
+	if ( BaseClass::Deploy() )
+	{
+		m_bCharging = true;
+		GainedNewTechnology(NULL);
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Our player just died
+//-----------------------------------------------------------------------------
+bool CWeaponCombatPlasmaRifle::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	if ( BaseClass::Holster(pSwitchingTo) )
+	{
+		m_bCharging = false;
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Match the anim speed to the weapon speed while crouching
+//-----------------------------------------------------------------------------
+float CWeaponCombatPlasmaRifle::GetDefaultAnimSpeed( void )
+{
+	if ( GetOwner() && GetOwner()->IsPlayer() )
+	{
+		if ( GetOwner()->GetFlags() & FL_DUCKING )
+			return (1.0 + (1.0 - weapon_combat_plasmarifle_ducking_mod.GetFloat()) );
+	}
+
+	return 1.0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Charge up over time
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaRifle::ChargeThink( void )
+{
+	if ( !m_bCharging )
+		return;
+
+	if ( IsOwnerEMPed() )
+	{
+		m_flPower = 1;
+	}
+	else if ( m_iClip1 > 0 && m_flPower < MAX_RIFLE_POWER )
+	{
+		m_flPower = MIN( MAX_RIFLE_POWER, m_flPower + (((MAX_RIFLE_POWER-1.0) / RIFLE_CHARGE_TIME) * gpGlobals->frametime ) );
+	}
+}
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaRifle::OnDataChanged( DataUpdateType_t updateType )
+{
+	SetPredictionEligible( true );
+
+	BaseClass::OnDataChanged( updateType );
+
+	if (updateType == DATA_UPDATE_CREATED)
+	{
+		if ( GetTeamNumber() == 1 )
+			m_hMaterial.Init( "sprites/chargeball_team1", TEXTURE_GROUP_CLIENT_EFFECTS );
+		else 
+			m_hMaterial.Init( "sprites/chargeball_team2", TEXTURE_GROUP_CLIENT_EFFECTS );
+	}
+
+	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 CWeaponCombatPlasmaRifle::ClientThink( )
+{
+	BaseClass::ClientThink();
+
+	if (!inv_demo.GetInt())
+	{
+		C_BaseTFPlayer *pPlayer = (C_BaseTFPlayer *)GetOwner();
+		if ( !pPlayer || (pPlayer->GetHealth() <= 0) || !IsDormant() )
+		{
+			SetNextClientThink( CLIENT_THINK_NEVER );
+			return;
+		}
+
+		// 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 = 7;
+		dl->radius = 20 * m_flPower + 10;
+		dl->die = gpGlobals->curtime + 0.01;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the charging effect
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaRifle::DrawChargingEffect( float flSize, CBaseAnimating *pAttachedEnt )
+{
+	if (!pAttachedEnt)
+		return;
+
+	Vector vecMuzzleOrigin, vecBarrelOrigin;
+	QAngle angMuzzleAngles, angBarrelAngles;
+	int iMuzzle = pAttachedEnt->LookupAttachment( "muzzle" );
+	//int iBarrel = pAttachedEnt->LookupAttachment( "barrel" );
+
+	if ( pAttachedEnt->GetAttachment( iMuzzle, vecMuzzleOrigin, angMuzzleAngles ) )
+	{
+		// View model attachments are modified so you can place entities at the attachment
+		// point and when they are rendered (with a different FOV than the view model itself uses)
+		// they will render in the right spot when the view model is drawn.
+		// 
+		// In this case though, we are rendering at the same time as the view model, so we want
+		// the attachment point before the correction has been applied.
+		pAttachedEnt->UncorrectViewModelAttachment( vecMuzzleOrigin );
+
+		// If I'm fully charged, put funky effects on the ball
+		materials->Bind( m_hMaterial, this );
+		
+		if ( m_flPower >= MAX_RIFLE_POWER )
+		{
+			float frac = fmod( gpGlobals->curtime, 1.0 );
+			frac *= 2 * M_PI;
+			frac = sin( frac );
+			flSize += (frac * 2) - 1.5;
+			int colorFade = 190 + (int)( frac * 32.0f );
+
+			color32 color = { 0, 0, 0, 255 };
+			if ( GetTeamNumber() == 1 )
+			{
+				color.r = colorFade;
+				color.g = colorFade;
+			}
+			else 
+			{
+				color.g = colorFade;
+			}
+			DrawSprite( vecMuzzleOrigin, flSize, flSize, color );
+		}
+		else
+		{
+			color32 color = { 255, 255, 255, 255 };
+			DrawSprite( vecMuzzleOrigin, flSize, flSize, color );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// We're transparent because we draw a transparent charging effect
+//-----------------------------------------------------------------------------
+bool CWeaponCombatPlasmaRifle::IsTransparent( )
+{
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the model
+//-----------------------------------------------------------------------------
+int CWeaponCombatPlasmaRifle::DrawModel( int flags )
+{
+	int retval = BaseClass::DrawModel( flags );
+	if (retval == 0)
+		return 0;
+
+	if (IsCarrierAlive())
+	{
+		// FIXME: Maybe do some client-side simulation on the size?
+		// It may get jerky otherwise
+
+		// Draw the charging effect
+		float flSize = 10 * m_flPower + 5;
+
+		DrawChargingEffect( flSize, this );
+	}
+	return retval;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Draws the model
+//-----------------------------------------------------------------------------
+void CWeaponCombatPlasmaRifle::ViewModelDrawn( CBaseViewModel *pBaseViewModel )
+{
+	// Draw the charging effect
+	float flSize = 4 * m_flPower + 1;
+
+	if ( m_iClip1 > 0 )
+	{
+		DrawChargingEffect( flSize, pBaseViewModel );
+	}
+}
+#endif
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatPlasmaRifle, DT_WeaponCombatPlasmaRifle )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatPlasmaRifle, DT_WeaponCombatPlasmaRifle )
+#if !defined( CLIENT_DLL )
+	SendPropFloat( SENDINFO( m_flPower ), 14, SPROP_ROUNDUP, 1.0f, MAX_RIFLE_POWER ),
+	SendPropInt( SENDINFO( m_bCharging ), 1, SPROP_UNSIGNED ),
+#else
+	RecvPropFloat( RECVINFO( m_flPower ) ),
+	RecvPropInt( RECVINFO( m_bCharging ) ),
+#endif
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS( weapon_combat_plasmarifle_base, CWeaponCombatPlasmaRifle );
+
+BEGIN_PREDICTION_DATA( CWeaponCombatPlasmaRifle  )
+
+	DEFINE_PRED_FIELD_TOL( m_flPower, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.05f ),
+	DEFINE_PRED_FIELD( m_bCharging, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+#if !defined( CLIENT_DLL )
+
+BEGIN_DATADESC( CWeaponCombatPlasmaRifle )
+
+	// Function Pointers
+	DEFINE_FUNCTION( ChargeThink ),
+
+END_DATADESC()
+
+// PRECACHE_WEAPON_REGISTER(weapon_combat_plasmarifle_base);
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Need to do different art on client vs server
+//-----------------------------------------------------------------------------
+class CWeaponCombatPlasmaRifleHuman : public CWeaponCombatPlasmaRifle
+{
+	DECLARE_CLASS( CWeaponCombatPlasmaRifleHuman, CWeaponCombatPlasmaRifle );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatPlasmaRifleHuman( void ) {}
+
+private:
+	CWeaponCombatPlasmaRifleHuman( const CWeaponCombatPlasmaRifleHuman & );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Need to do different art on client vs server
+//-----------------------------------------------------------------------------
+class CWeaponCombatPlasmaRifleAlien : public CWeaponCombatPlasmaRifle
+{
+	DECLARE_CLASS( CWeaponCombatPlasmaRifleAlien, CWeaponCombatPlasmaRifle );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatPlasmaRifleAlien( void ) {}
+
+private:
+	CWeaponCombatPlasmaRifleAlien( const CWeaponCombatPlasmaRifleAlien & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatPlasmaRifleHuman, DT_WeaponCombatPlasmaRifleHuman )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatPlasmaRifleHuman, DT_WeaponCombatPlasmaRifleHuman )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatPlasmaRifleHuman )
+END_PREDICTION_DATA()
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatPlasmaRifleAlien, DT_WeaponCombatPlasmaRifleAlien )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatPlasmaRifleAlien, DT_WeaponCombatPlasmaRifleAlien )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatPlasmaRifleAlien )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_combat_plasmarifle, CWeaponCombatPlasmaRifleHuman );
+LINK_ENTITY_TO_CLASS( weapon_combat_plasmarifle_alien, CWeaponCombatPlasmaRifleAlien );
+
+PRECACHE_WEAPON_REGISTER(weapon_combat_plasmarifle);
+PRECACHE_WEAPON_REGISTER(weapon_combat_plasmarifle_alien);
diff --git a/game/shared/tf2/weapon_combat_shotgun.cpp b/game/shared/tf2/weapon_combat_shotgun.cpp
new file mode 100644
index 0000000..ac5ddaf
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_shotgun.cpp
@@ -0,0 +1,318 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Shotgun & Shield combo
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "weapon_combatshield.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "in_buttons.h"
+#include "takedamageinfo.h"
+#include "tf_gamerules.h"
+
+// Damage CVars
+ConVar	weapon_combat_shotgun_damage( "weapon_combat_shotgun_damage","5", FCVAR_REPLICATED, "Shotgun damage per pellet" );
+ConVar	weapon_combat_shotgun_powered_damage( "weapon_combat_shotgun_powered_damage","10", FCVAR_REPLICATED, "Shotgun damage per pellet when powered" );
+ConVar	weapon_combat_shotgun_range( "weapon_combat_shotgun_range","900", FCVAR_REPLICATED, "Shotgun maximum range" );
+ConVar	weapon_combat_shotgun_pellets( "weapon_combat_shotgun_pellets","8", FCVAR_REPLICATED, "Shotgun pellets per fire" );
+ConVar	weapon_combat_shotgun_ducking_mod( "weapon_combat_shotgun_ducking_mod", "0.75", FCVAR_REPLICATED, "Shotgun ducking speed modifier" );
+ConVar	weapon_combat_shotgun_energy_cost( "weapon_combat_shotgun_energy_cost", "0.1", FCVAR_REPLICATED, "Sapper's energy cost to fire a powered shotgun round" );
+
+
+#if defined( CLIENT_DLL )
+#include "fx.h"
+#include "c_tf_class_sapper.h"
+#define CWeaponCombatShotgun C_WeaponCombatShotgun
+#define CPlayerClassSapper C_PlayerClassSapper
+#else
+#include "tf_class_sapper.h"
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponCombatShotgun : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponCombatShotgun, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatShotgun( void );
+
+	virtual const Vector& GetBulletSpread( void );
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual float 	GetFireRate( void );
+	virtual float	GetDefaultAnimSpeed( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool	IsPredicted( void ) const
+	{ 
+		return true;
+	}
+private:
+	CWeaponCombatShotgun( const CWeaponCombatShotgun & );
+
+public:
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() && 
+			GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	bool OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+	void ViewModelDrawn( C_BaseViewModel *pViewModel );
+#endif
+
+private:
+	// If true, the current shot being fired is a powered shot, using some of the Sapper's energy
+	bool		m_bPoweredShot;
+	float		m_flOwnersEnergyLevel;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponCombatShotgun::CWeaponCombatShotgun( void )
+{
+	SetPredictionEligible( true );
+	m_bReloadsSingly = true;
+	m_flOwnersEnergyLevel = 0;
+}
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatShotgun, DT_WeaponCombatShotgun )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatShotgun, DT_WeaponCombatShotgun )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatShotgun )
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_combat_shotgun, CWeaponCombatShotgun );
+PRECACHE_WEAPON_REGISTER(weapon_combat_shotgun);
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the accuracy derived from weapon and player, and return it
+//-----------------------------------------------------------------------------
+const Vector& CWeaponCombatShotgun::GetBulletSpread( void )
+{
+	static Vector cone = VECTOR_CONE_20DEGREES;
+	static Vector powered_cone = VECTOR_CONE_10DEGREES;
+
+	if ( m_bPoweredShot )
+		return powered_cone;
+
+	return cone;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShotgun::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	// Get our player's energy level
+	if ( pOwner->PlayerClass() == TFCLASS_SAPPER )
+	{
+		CPlayerClassSapper *pSapper = static_cast<CPlayerClassSapper*>( pOwner->GetPlayerClass() );
+		if ( pSapper )
+		{
+			m_flOwnersEnergyLevel = pSapper->GetDrainedEnergy();
+		}
+	}
+
+	if ( UsesClipsForAmmo1() )
+	{
+		CheckReload();
+	}
+
+	// Handle firing
+	if ( GetShieldState() == SS_DOWN && !m_bInReload )
+	{
+		if ( (pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+		{
+			if ( m_iClip1 > 0 )
+			{
+				// Fire the plasma shot
+				PrimaryAttack();
+			}
+			else
+			{
+				Reload();
+			}
+		}
+
+		// Reload button (or fire button when we're out of ammo)
+		if ( m_flNextPrimaryAttack <= gpGlobals->curtime ) 
+		{
+			if ( pOwner->m_nButtons & IN_RELOAD ) 
+			{
+				Reload();
+			}
+			else if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+			{
+				if ( !m_iClip1 && HasPrimaryAmmo() )
+				{
+					Reload();
+				}
+			}
+		}
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're charging
+	AllowShieldPostFrame( m_flNextPrimaryAttack <= gpGlobals->curtime || m_bInReload );
+
+	WeaponIdle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShotgun::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+	
+	WeaponSound(SINGLE);
+
+	// Fire the bullets
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	float flDamage = weapon_combat_shotgun_damage.GetFloat();
+
+	m_bPoweredShot = false;
+	// Always allow a powered shot, even if they have less than the actual cost.
+	// Prevents them having to examine the energy bar carefully to know if they have enough.
+	if ( m_flOwnersEnergyLevel || pPlayer->HasPowerup(POWERUP_BOOST) )
+	{
+		if ( m_flOwnersEnergyLevel )
+		{
+			CPlayerClassSapper *pSapper = static_cast<CPlayerClassSapper*>( pPlayer->GetPlayerClass() );
+			pSapper->DeductDrainedEnergy( weapon_combat_shotgun_energy_cost.GetFloat() );
+		}
+
+		m_bPoweredShot = true;
+
+		flDamage = weapon_combat_shotgun_powered_damage.GetFloat();
+	}
+
+	// Make a satisfying shotgun force, and knock them into the air
+	float flForceScale = (100) * 75;
+	Vector vecForce = vecAiming;
+	vecForce.z += 0.7;
+	vecForce *= flForceScale;
+	
+	CTakeDamageInfo info( this, pPlayer, vecForce, vec3_origin, flDamage, DMG_BULLET | DMG_BUCKSHOT);
+	TFGameRules()->FireBullets( info, weapon_combat_shotgun_pellets.GetFloat(), vecSrc, vecAiming, GetBulletSpread(), weapon_combat_shotgun_range.GetFloat(), m_iPrimaryAmmoType, 2, entindex(), 0 );
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_iClip1 = m_iClip1 - 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponCombatShotgun::GetFireRate( void )
+{	
+	float flFireRate = ( SequenceDuration() * 2) + SHARED_RANDOMFLOAT( 0.0, 0.035f );
+
+	CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>( GetOwner() );
+	if ( pPlayer )
+	{
+		// Ducking players should fire more rapidly.
+		if ( pPlayer->GetFlags() & FL_DUCKING )
+		{
+			flFireRate *= weapon_combat_shotgun_ducking_mod.GetFloat();
+		}
+	}
+	
+	return flFireRate;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Match the anim speed to the weapon speed while crouching
+//-----------------------------------------------------------------------------
+float CWeaponCombatShotgun::GetDefaultAnimSpeed( void )
+{
+	if ( GetOwner() && GetOwner()->IsPlayer() )
+	{
+		if ( GetOwner()->GetFlags() & FL_DUCKING )
+			return (1.0 + (1.0 - weapon_combat_shotgun_ducking_mod.GetFloat()) );
+	}
+
+	return 1.0;
+}
+
+#if defined ( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponCombatShotgun::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
+{
+	CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return true;
+
+	if ( m_flOwnersEnergyLevel || pPlayer->HasPowerup(POWERUP_BOOST) )
+	{
+		Vector vecMuzzlePos, vecBarrelPos;
+		QAngle angMuzzle;
+		int iAttachment = pViewModel->LookupAttachment( "0" );
+		pViewModel->GetAttachment( iAttachment, vecBarrelPos, angMuzzle );
+		//pViewModel->UncorrectViewModelAttachment( vecBarrelPos );	
+		iAttachment = pViewModel->LookupAttachment( "muzzle" );
+		pViewModel->GetAttachment( 0, vecMuzzlePos, angMuzzle );
+		
+		unsigned char color[3];
+		color[0] = 50;
+		color[1] = 255;
+		color[2] = 50;
+		FX_MuzzleEffect( vecBarrelPos, angMuzzle, 1.0, GetRefEHandle(), &color[0] );
+	
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShotgun::ViewModelDrawn( C_BaseViewModel *pViewModel )
+{
+	CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	if ( m_flOwnersEnergyLevel )
+	{			
+		Vector vecMuzzlePos, vecBarrelPos;
+		QAngle angMuzzle;
+		int iAttachment = pViewModel->LookupAttachment( "0" );
+		pViewModel->GetAttachment( iAttachment, vecBarrelPos, angMuzzle );
+		//pViewModel->UncorrectViewModelAttachment( vecBarrelPos );	
+		iAttachment = pViewModel->LookupAttachment( "muzzle" );
+		pViewModel->GetAttachment( 0, vecMuzzlePos, angMuzzle );
+
+		unsigned char color[3];
+		color[0] = 50;
+		color[1] = 128;
+		color[2] = 50;
+		FX_Smoke( vecBarrelPos, angMuzzle, MAX(0.3,m_flOwnersEnergyLevel), 1, &color[0], 255 );
+	}
+}
+#endif
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_combat_usedwithshieldbase.cpp b/game/shared/tf2/weapon_combat_usedwithshieldbase.cpp
new file mode 100644
index 0000000..53fc9a2
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_usedwithshieldbase.cpp
@@ -0,0 +1,111 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "weapon_combatshield.h"
+#include "weapon_twohandedcontainer.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Make sure we're not switching directly to this weapon, since this 
+//			weapon can only be "switched" to by the twohandedcontainer weapon.
+//-----------------------------------------------------------------------------
+bool CWeaponCombatUsedWithShieldBase::CanDeploy( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if (!pPlayer)
+		return false;
+
+	// Make sure the current weapon is a twohanded weapon container
+	CWeaponTwoHandedContainer *pContainer = dynamic_cast<CWeaponTwoHandedContainer*>(pPlayer->GetActiveWeapon());
+	if ( !pContainer )
+	{
+		// Not the two handed container, so deploy the two handed container instead
+		pContainer = ( CWeaponTwoHandedContainer * )pPlayer->Weapon_OwnsThisType( "weapon_twohandedcontainer" );
+		if ( !pContainer )
+			return BaseClass::Deploy();
+
+		// Deploy the container
+		pPlayer->Weapon_Switch( pContainer );
+
+		// Make sure the container's using the desired weapon
+		pContainer->SetWeapons( this, pContainer->GetRightWeapon() );
+		return false;
+	}
+
+	return BaseClass::CanDeploy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : allow - 
+//-----------------------------------------------------------------------------
+void CWeaponCombatUsedWithShieldBase::AllowShieldPostFrame( bool allow )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	CWeaponCombatShield *shield = static_cast< CWeaponCombatShield * >( pOwner->Weapon_OwnsThisType( "weapon_combat_shield" ) );
+	if ( !shield )
+		return;
+
+	shield->SetAllowPostFrame( allow );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CWeaponCombatUsedWithShieldBase::GetShieldState( void )
+{	
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return SS_DOWN;
+
+	CWeaponCombatShield *pShield = pOwner->GetCombatShield();
+	if ( !pShield )
+		return SS_DOWN;
+
+	return pShield->GetShieldState();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Mirror the values in the container, if there is one
+// Input  : *pPlayer - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CWeaponCombatUsedWithShieldBase::UpdateClientData( CBasePlayer *pPlayer )
+{
+	if ( !pPlayer )
+	{
+		return BaseClass::UpdateClientData( pPlayer );
+	}
+
+	CWeaponTwoHandedContainer *pContainer = ( CWeaponTwoHandedContainer * )pPlayer->Weapon_OwnsThisType( "weapon_twohandedcontainer" );
+	if ( !pContainer || pContainer != pPlayer->GetActiveWeapon() )
+		return BaseClass::UpdateClientData( pPlayer );
+
+	// Make sure this weapon is one of the container's active weapons
+	if ( pContainer->GetLeftWeapon() != this && pContainer->GetRightWeapon() != this )
+		return BaseClass::UpdateClientData( pPlayer );
+
+	int retval = pContainer->UpdateClientData( pPlayer );
+	m_iState =  pContainer->m_iState;
+	return retval;
+}
+
+LINK_ENTITY_TO_CLASS( weapon_combat_usedwithshieldbase, CWeaponCombatUsedWithShieldBase );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatUsedWithShieldBase, DT_WeaponCombatUsedWithShieldBase )
+
+BEGIN_NETWORK_TABLE( CWeaponCombatUsedWithShieldBase, DT_WeaponCombatUsedWithShieldBase )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatUsedWithShieldBase )
+END_PREDICTION_DATA()
diff --git a/game/shared/tf2/weapon_combat_usedwithshieldbase.h b/game/shared/tf2/weapon_combat_usedwithshieldbase.h
new file mode 100644
index 0000000..7db6ea4
--- /dev/null
+++ b/game/shared/tf2/weapon_combat_usedwithshieldbase.h
@@ -0,0 +1,59 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_COMBAT_USEDWITHSHIELDBASE_H
+#define WEAPON_COMBAT_USEDWITHSHIELDBASE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfcombatweapon_shared.h"
+
+class CBasePlayer;
+
+#if defined( CLIENT_DLL )
+#define CWeaponCombatUsedWithShieldBase C_WeaponCombatUsedWithShieldBase
+#endif
+
+class CWeaponCombatUsedWithShieldBase : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponCombatUsedWithShieldBase, CBaseTFCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatUsedWithShieldBase( void ) {}
+
+	virtual bool	CanDeploy( void );
+	virtual int		UpdateClientData( CBasePlayer *pPlayer );
+	virtual bool	SupportsTwoHanded( void ) { return true; };
+	void			AllowShieldPostFrame( bool allow );
+	virtual int		GetShieldState( void );
+
+	/*
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+	*/
+
+private:														
+	CWeaponCombatUsedWithShieldBase( const CWeaponCombatUsedWithShieldBase & );						
+
+};
+#endif // WEAPON_COMBAT_USEDWITHSHIELDBASE_H
diff --git a/game/shared/tf2/weapon_combatshield.cpp b/game/shared/tf2/weapon_combatshield.cpp
new file mode 100644
index 0000000..6b9d87d
--- /dev/null
+++ b/game/shared/tf2/weapon_combatshield.cpp
@@ -0,0 +1,1205 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Combative shield weapon
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_twohandedcontainer.h"
+#include "weapon_combatshield.h"
+#include "engine/IEngineSound.h"
+#include "in_buttons.h"
+#include "weapon_combat_usedwithshieldbase.h"
+
+#if !defined( CLIENT_DLL )
+#include "tf_shield.h"
+
+extern ConVar tf_knockdowntime;
+
+#else
+
+#include "iviewrender_beams.h"
+#include "c_team.h"
+#include "cdll_int.h"
+#include "hudelement.h"
+#include "bone_setup.h"
+#include "beamdraw.h"
+#include <vgui/ISurface.h>
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// Damage CVars
+ConVar	weapon_combat_shield_rechargetime( "weapon_combat_shield_rechargetime","4", FCVAR_REPLICATED, "Time after taking damage before the shields starts recharging" );
+ConVar	weapon_combat_shield_rechargeamount( "weapon_combat_shield_rechargeamount","0.03", FCVAR_REPLICATED, "Amount shield recharges every 10th of a second (must be an int)" );
+ConVar	weapon_combat_shield_factor( "weapon_combat_shield_factor","0.4", FCVAR_REPLICATED, "Factor applied to damage the shield blocks" );
+
+ConVar  weapon_combat_shield_teslaspeed( "weapon_combat_shield_teslaspeed", "0.025f", FCVAR_REPLICATED, "Speed of the tesla effect on the view model." );
+ConVar	weapon_combat_shield_teslaskitter( "weapon_combat_shield_teslaskitter", "0.3f", FCVAR_REPLICATED, "Speed of the tesla skitter effect (percentage)." );
+ConVar	weapon_combat_shield_teslaeffect( "weapon_combat_shield_teslaeffect", "4", FCVAR_REPLICATED, "Experimenting with effects." );
+
+ConVar	weapon_combat_shield_health( "weapon_combat_shield_health", "100", FCVAR_REPLICATED, "Combat shield's maximum health." );
+
+// HACK:  If we don't set this then we get a pop when transitioning into / out of idle animation
+//  for commando_test model because the origin is wrong
+// This can be removed once the model itself is fixed
+#define SHIELD_FADOUT_TIME 0.2f
+
+//-----------------------------------------------------------------------------
+// Constructor, destructor: 
+//-----------------------------------------------------------------------------
+CWeaponCombatShield::CWeaponCombatShield()
+{
+	m_bAllowPostFrame = true;
+	m_bHasShieldParry = false;
+	m_flShieldHealth = 1.0;
+#if defined( CLIENT_DLL )
+	m_flFlashTimeEnd = 0;
+
+	m_flTeslaSpeed = weapon_combat_shield_teslaspeed.GetFloat();
+	m_flTeslaSkitter = weapon_combat_shield_teslaskitter.GetFloat();
+	m_flTeslaLeftInc = 0.0f;
+	m_flTeslaRightInc = 0.0f;
+	m_pTeslaBeam = NULL;
+	m_pTeslaBeam2 = NULL;
+
+	m_flShieldInc = 1.0f;
+	m_pShieldBeam = NULL;
+	m_pShieldBeam2 = NULL;
+	m_pShieldBeam3 = NULL;
+#endif
+	SetPredictionEligible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::Precache( void )
+{
+	BaseClass::Precache();
+
+	PrecacheModel( "sprites/blueflare1.vmt" );
+	PrecacheModel( "sprites/physbeam.vmt" );
+
+	PrecacheScriptSound( "WeaponCombatShield.TakeBash" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponCombatShield::Deploy( void )
+{
+	if ( BaseClass::Deploy() )
+	{
+		GainedNewTechnology(NULL);
+		SetShieldState( SS_DOWN );
+		return true;
+	}
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the activity the other weapon in our twohanded container should play for this activity
+//-----------------------------------------------------------------------------
+int	CWeaponCombatShield::GetOtherWeaponsActivity( int iActivity )
+{
+	switch ( iActivity )
+	{
+	case ACT_VM_HAULBACK:
+		return ACT_VM_DRAW;
+
+	case ACT_VM_SECONDARYATTACK:
+		return ACT_VM_HOLSTER;
+
+	default:
+		break;
+	};
+
+	return -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the activity the other weapon in our twohanded container should 
+//			play instead of the one it's attempting to play.
+//-----------------------------------------------------------------------------
+int	CWeaponCombatShield::ReplaceOtherWeaponsActivity( int iActivity )
+{
+	switch ( iActivity )
+	{
+	case ACT_VM_IDLE:
+		// If I'm active, don't let it idle
+		if ( GetShieldState() != SS_DOWN )
+			return -1;
+
+	default:
+		break;
+	};
+
+	return BaseClass::ReplaceOtherWeaponsActivity(iActivity);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponCombatShield::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	CBaseTFPlayer *player = ToBaseTFPlayer( GetOwner() );
+	if ( player )
+	{
+		player->SetBlocking( false );
+		player->SetParrying( false );
+
+		if ( m_iShieldState != SS_DOWN && 
+			 m_iShieldState != SS_UNAVAILABLE )
+		{
+			SetShieldState( SS_LOWERING );
+		}
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: I've been bashed by another player's shield
+//-----------------------------------------------------------------------------
+bool CWeaponCombatShield::TakeShieldBash( CBaseTFPlayer *pBasher )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return false;
+
+	// If I'm blocking, drop my block and prevent me from doing anything
+	if ( GetShieldState() == SS_UP ||
+		 GetShieldState() == SS_RAISING ||
+		 GetShieldState() == SS_LOWERING )
+	{
+		// Make the shield unavailable
+		SetShieldState( SS_UNAVAILABLE );
+		SendWeaponAnim( ACT_VM_HITCENTER );
+
+		m_flShieldUnavailableEndTime = gpGlobals->curtime + 2.0;
+
+		// Play a sound	
+		EmitSound( "WeaponCombatShield.TakeBash" );		
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::SetShieldState( int iShieldState )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	switch (iShieldState )
+	{
+	default:
+	case SS_DOWN:
+		pOwner->SetBlocking( false );
+		m_flShieldUpStartTime = 0;
+		m_flShieldParryEndTime = 0;
+		m_flShieldUnavailableEndTime = 0;
+		m_flShieldRaisedTime = 0.0f;
+		m_flShieldLoweredTime = 0.0f;
+		break;
+
+	case SS_UP:
+		SendWeaponAnim( ACT_VM_FIDGET );
+		pOwner->SetBlocking( true );
+		m_flShieldDownStartTime = 0.0f;
+		m_flShieldParryEndTime = 0;
+		m_flShieldUnavailableEndTime = 0;
+		m_flShieldRaisedTime = 0.0f;
+		m_flShieldLoweredTime = 0.0f;
+		break;
+
+	case SS_PARRYING:
+		pOwner->SetBlocking( false );
+		pOwner->SetParrying( true );
+		m_flShieldParryEndTime = gpGlobals->curtime + PARRY_OPPORTUNITY_LENGTH;
+		m_flShieldParrySwingEndTime = gpGlobals->curtime + 1.0f;	// a hack to make it look ok
+		m_flShieldUnavailableEndTime = gpGlobals->curtime + SequenceDuration();
+		m_flNextPrimaryAttack = m_flShieldUnavailableEndTime;
+		m_flShieldRaisedTime = 0.0f;
+		m_flShieldLoweredTime = 0.0f;
+		break;
+
+	case SS_PARRYING_FINISH_SWING:
+		pOwner->SetBlocking( false );
+		pOwner->SetParrying( false );
+		break;
+
+	case SS_UNAVAILABLE:
+		SendWeaponAnim( ACT_VM_HAULBACK );
+		pOwner->SetBlocking( false );
+		pOwner->SetParrying( false );
+		break;
+
+	case SS_RAISING:
+		{
+			pOwner->SetBlocking( false );
+			pOwner->SetParrying( false );
+			m_flShieldRaisedTime = gpGlobals->curtime + SequenceDuration();
+			m_flShieldUpStartTime = gpGlobals->curtime;
+		}
+		break;
+	case SS_LOWERING:
+		{
+			SendWeaponAnim( ACT_VM_HAULBACK );
+			pOwner->SetBlocking( false );
+			pOwner->SetParrying( false );
+			m_flShieldLoweredTime = gpGlobals->curtime + SequenceDuration();
+			m_flShieldDownStartTime = gpGlobals->curtime;
+		}
+		break;
+	};
+
+	m_iShieldState = iShieldState;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check to see if the shield state should change
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::UpdateShieldState( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// Check to see if I should move out of the current state
+	switch ( m_iShieldState )
+	{
+	default:
+	case SS_DOWN:
+	case SS_UP:
+		break;
+
+	case SS_RAISING:
+			if ( gpGlobals->curtime > m_flShieldRaisedTime )
+			{
+				SetShieldState( SS_UP );
+			}
+			break;
+	case SS_LOWERING:
+		if ( gpGlobals->curtime > m_flShieldLoweredTime )
+		{
+			SetShieldState( SS_DOWN );
+		}
+		break;
+
+	case SS_PARRYING:
+		if ( gpGlobals->curtime > m_flShieldParryEndTime )
+		{
+			SetShieldState( SS_PARRYING_FINISH_SWING );
+		}
+		break;
+
+	case SS_PARRYING_FINISH_SWING:
+		if ( gpGlobals->curtime > m_flShieldParrySwingEndTime )
+		{
+			SetShieldState( SS_UNAVAILABLE );
+		}
+		break;
+
+	case SS_UNAVAILABLE:
+		if ( gpGlobals->curtime > m_flShieldUnavailableEndTime )
+		{
+			SetShieldState( SS_DOWN );
+		}
+		break;
+	};
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CWeaponCombatShield::GetShieldState( void )
+{
+	return m_iShieldState;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::SetShieldUsable( bool bUsable )
+{
+	// Shutting down!
+	if ( !bUsable )
+	{
+		if ( m_iShieldState == SS_UP || m_iShieldState == SS_RAISING )
+		{
+			// We've got our shield up, so drop it (play sound & animation).
+			SendWeaponAnim( ACT_VM_HAULBACK );
+			WeaponSound( SPECIAL2 );			
+			SetShieldState( SS_LOWERING );			
+		}
+	}
+
+	m_bUsable = bUsable;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CWeaponCombatShield::ShieldUsable( void )
+{
+	return m_bUsable;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : allow - 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::SetAllowPostFrame( bool allow )
+{
+	m_bAllowPostFrame = allow;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::ItemPostFrame( void )
+{
+	if ( m_bAllowPostFrame )
+	{
+		ShieldPostFrame();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Allow the shield to interrupt reloads, etc.
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::ItemBusyFrame( void )
+{
+	if ( m_bAllowPostFrame )
+	{
+		ShieldPostFrame();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The player holding this weapon has just gained new technology.
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::GainedNewTechnology( CBaseTechnology *pTechnology )
+{
+	BaseClass::GainedNewTechnology( pTechnology );
+
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		// Has a parry?
+		if ( pPlayer->HasNamedTechnology( "com_comboshield_parry" ) )
+		{
+			m_bHasShieldParry = true;
+		}
+		else
+		{
+			m_bHasShieldParry = false;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the shield input
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::ShieldPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	UpdateShieldState();
+	CheckReload();
+
+	// Store off EMP state
+	bool isEMPed = IsOwnerEMPed();
+
+	// If the shield's unavailable, just abort
+	if ( GetShieldState() == SS_UNAVAILABLE )
+		return;
+
+	if ( m_flNextPrimaryAttack > gpGlobals->curtime )
+		return;
+
+	bool shieldRaised = ( GetShieldState() == SS_UP );
+	bool shieldRaising = ( GetShieldState() == SS_RAISING );
+
+	//	GetShieldState() == SS_LOWERING );
+
+	// If my shield's out of power, I can't do anything with it
+	if ( !GetShieldHealth() )
+		return;
+
+	// Was the shield button just pressed?
+	if ( GetShieldState() == SS_DOWN && !isEMPed && pOwner->m_nButtons & IN_ATTACK2 )
+	{
+		// Play sound & anim
+		WeaponSound( SPECIAL1 );
+		SendWeaponAnim( ACT_VM_SECONDARYATTACK );
+
+		SetShieldState( SS_RAISING );
+		
+		// Abort any reloads in progess
+		pOwner->AbortReload();
+	}
+	else if ( ( shieldRaised || shieldRaising ) && !FBitSet( pOwner->m_nButtons, IN_ATTACK2 ) )
+	{
+		// Shield button was just released, check to see if we were parrying
+		bool shouldParry = (gpGlobals->curtime < (m_flShieldUpStartTime + PARRY_DETECTION_TIME ));
+
+		if ( m_bHasShieldParry && shouldParry )
+		{
+			// Parry!
+			// Play sound & anim
+			WeaponSound( SPECIAL2 );
+			SendWeaponAnim( ACT_VM_SWINGHIT );
+
+			SetShieldState( SS_PARRYING );
+
+			// Bash enemies in front of me
+			ShieldBash();
+		}
+		else
+		{
+			// Player's just lowered his shield
+			// Play sound & anim
+			WeaponSound( SPECIAL2 );
+			SendWeaponAnim( ACT_VM_HAULBACK );
+
+			SetShieldState( SS_LOWERING );
+			m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+		}
+	}
+	else if ( GetShieldState() == SS_UP && ( pOwner->m_nButtons & IN_ATTACK2 ) && ( isEMPed ) )
+	{
+		// We've got our shield up, and we were just EMPed, so drop it
+		// Play sound & anim
+		SendWeaponAnim( ACT_VM_HAULBACK );
+		WeaponSound( SPECIAL2 );
+
+		SetShieldState( SS_LOWERING );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Bash enemies in front of me with my shield
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::ShieldBash( void )
+{
+#if 0
+	// ROBIN: Disabled shield bash
+	return;
+
+	// Get any players in front of me
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// Get the target point and location
+	Vector vecAiming;
+	Vector vecSrc = pOwner->Weapon_ShootPosition( pOwner->GetOrigin() );	
+	pOwner->EyeVectors( &vecAiming );
+
+	// Find a player in range of this player, and make sure they're healable
+	trace_t tr;
+	Vector vecEnd = vecSrc + (vecAiming * SHIELD_BASH_RANGE);
+	UTIL_TraceLine( vecSrc, vecEnd, MASK_SHOT, pOwner->edict(), COLLISION_GROUP_NONE, &tr);
+	if (tr.fraction != 1.0)
+	{
+		CBaseEntity *pEntity = CBaseEntity::Instance(tr.u.ent);
+		if ( pEntity )
+		{
+			CBaseTFPlayer *pPlayer = ToBaseTFPlayer( pEntity );
+			if ( pPlayer && (pPlayer != pOwner) )
+			{
+				// Target needs to be on the eneny team
+				if ( pPlayer->IsAlive() && !pPlayer->InSameTeam( pOwner ) )
+				{
+					// Ok, we have an enemy player
+					pPlayer->TakeShieldBash( pOwner );
+				}
+			}
+		}
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Attempt to block the incoming attack, and return the damage it 
+//			should do after the block, if any.
+//-----------------------------------------------------------------------------
+float CWeaponCombatShield::AttemptToBlock( float flDamage )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer || !weapon_combat_shield_factor.GetFloat() )
+		return 0;
+
+	// Block as much of the damage as we can
+	float flPowerNeeded = flDamage * weapon_combat_shield_factor.GetFloat();
+	flPowerNeeded = RemapVal( flPowerNeeded, 0, weapon_combat_shield_health.GetFloat(), 0, 1 );
+	float flPowerUsed = MIN( flPowerNeeded, GetShieldHealth() );
+
+#ifndef CLIENT_DLL
+	RemoveShieldHealth( flPowerUsed );
+
+	// Start recharging shortly after taking damage
+	SetThink( ShieldRechargeThink );
+	SetNextThink( gpGlobals->curtime + weapon_combat_shield_rechargetime.GetFloat() );
+#endif
+
+	// Failed to block it all?
+	if ( flPowerUsed < flPowerNeeded )
+	{
+#ifndef CLIENT_DLL
+		// Force the shield to drop if it's up
+		if ( GetShieldState() == SS_UP )
+		{
+			// Play sound & anim
+			SendWeaponAnim( ACT_VM_HAULBACK );
+			WeaponSound( SPECIAL2 );
+			SetShieldState( SS_LOWERING );
+		}
+#endif
+
+		return ( flDamage - (flPowerUsed * (1.0 / weapon_combat_shield_factor.GetFloat())) );
+	}
+
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponCombatShield::GetShieldHealth( void )
+{
+	return m_flShieldHealth;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::AddShieldHealth( float flHealth )
+{
+	m_flShieldHealth = MIN( 1.0, m_flShieldHealth + flHealth );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::RemoveShieldHealth( float flHealth )
+{
+	m_flShieldHealth = MAX( 0.0, m_flShieldHealth - flHealth );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Recharge the shield
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::ShieldRechargeThink( void )
+{
+// FIXME:
+//xxx
+#if !defined( CLIENT_DLL )
+	if ( GetShieldHealth() >= 1.0 )
+	{
+		SetThink( NULL );
+		return;
+	}
+
+	AddShieldHealth( weapon_combat_shield_rechargeamount.GetFloat() );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+#endif
+}
+
+
+//====================================================================================
+// WEAPON CLIENT HANDLING
+//====================================================================================
+int CWeaponCombatShield::UpdateClientData( CBasePlayer *pPlayer )
+{
+	if ( !pPlayer )
+	{
+		return BaseClass::UpdateClientData( pPlayer );
+	}
+
+	CWeaponTwoHandedContainer *pContainer = ( CWeaponTwoHandedContainer * )pPlayer->Weapon_OwnsThisType( "weapon_twohandedcontainer" );
+	if ( !pContainer || pContainer != pPlayer->GetActiveWeapon() )
+		return BaseClass::UpdateClientData( pPlayer );
+
+	// Make sure this weapon is one of the container's active weapons
+	if ( pContainer->GetLeftWeapon() != this && pContainer->GetRightWeapon() != this )
+		return BaseClass::UpdateClientData( pPlayer );
+
+	int retval = pContainer->UpdateClientData( pPlayer );
+	m_iState =  pContainer->m_iState;
+	return retval;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CWeaponCombatShield::VisibleInWeaponSelection( void )
+{
+	return false;
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+bool CWeaponCombatShield::IsUp( void )
+{
+	return ( GetShieldState() == SS_UP );
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+float CWeaponCombatShield::GetRaisingTime( void )
+{
+	if ((GetShieldState() != SS_UP ) && (GetShieldState() != SS_RAISING))
+		return 0.0f;
+
+	return gpGlobals->curtime - m_flShieldUpStartTime;
+}
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+float CWeaponCombatShield::GetLoweringTime( void )
+{
+	if ((GetShieldState() != SS_DOWN ) && (GetShieldState() != SS_LOWERING))
+		return 0.0f;
+
+	return gpGlobals->curtime - m_flShieldDownStartTime;
+}
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: Draw the ammo counts
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::DrawAmmo( void )
+{
+	// ROBIN: Removed this now that the shield colors itself to show health level
+	return;
+
+	int r, g, b, a;
+	int x, y;
+
+	// Get the shield power level
+	float flPowerLevel = GetShieldHealth();
+	float flInverseFactor = 1.0 - flPowerLevel;
+
+	// Set our color
+	gHUD.m_clrNormal.GetColor( r, g, b, a );
+	
+	int iWidth = XRES(12);
+	int iHeight = YRES(64);
+
+	x = XRES(548);
+	y = ( ScreenHeight() - YRES(2) - iHeight );
+
+	// Flashing the power level?
+	float flFlash = 0;
+	if ( gpGlobals->curtime < m_flFlashTimeEnd && !GetPrimaryAmmo() )
+	{
+		flFlash = fmod( gpGlobals->curtime, 0.25 );
+		flFlash *= 2 * M_PI;
+		flFlash = cos( flFlash );
+	}
+
+	// draw the exhausted portion of the bar.
+	vgui::surface()->DrawSetColor( Color( r, g * flPowerLevel, b * flPowerLevel, 100 + (flFlash * 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: 
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::GetViewmodelBoneControllers( C_BaseViewModel *pViewModel, float controllers[MAXSTUDIOBONECTRLS])
+{
+	// Dial shows the shield power level
+	float flPowerLevel = 1.0;
+	if ( GetShieldState() == SS_UP )
+	{
+		flPowerLevel = GetShieldHealth();
+	}
+	else if ( GetShieldState() == SS_RAISING )
+	{
+		// Bring the power up with the animation
+		float flTotal = m_flShieldRaisedTime - m_flShieldUpStartTime;
+		float flCurrent = (gpGlobals->curtime - m_flShieldUpStartTime);
+		flPowerLevel = flCurrent / flTotal;
+	}
+	else if ( GetShieldState() == SS_LOWERING )
+	{
+		// Bring the power down with the animation
+		float flTotal = (m_flShieldLoweredTime - m_flShieldDownStartTime);
+		float flCurrent = (gpGlobals->curtime - m_flShieldDownStartTime);
+		flPowerLevel = 1.0 - (flCurrent / flTotal);
+	}
+
+	// Make the middle point be full power (right of the middle being powered up)
+	// Adjust a little for the perspective.
+	flPowerLevel *= 0.55;
+
+	// Add some shake
+	flPowerLevel += RandomFloat( -0.02, 0.02 );
+	controllers[0] = flPowerLevel;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::ViewModelDrawn( C_BaseViewModel *pViewModel )
+{
+	if ( m_iShieldState == SS_DOWN )
+		return;
+
+	DrawBeams( pViewModel );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::InitShieldBeam( void )
+{
+	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 = 2.0f;
+	beamInfo.m_flEndWidth = 2.0f;
+	beamInfo.m_flFadeLength = 0.0f;
+	beamInfo.m_flAmplitude = 4.0f;
+	beamInfo.m_flBrightness = 50.0f;
+	beamInfo.m_flSpeed = 5.0f;
+	beamInfo.m_nStartFrame = 0;
+	beamInfo.m_flFrameRate = 0.0f;
+	beamInfo.m_flRed = 255.0f;
+	beamInfo.m_flGreen = 255.0f;
+	beamInfo.m_flBlue = 128.0f;
+	beamInfo.m_nSegments = 15;
+	beamInfo.m_bRenderable = false;
+	
+	m_pShieldBeam = beams->CreateBeamPoints( 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 = 1.5f;
+	beamInfo.m_flEndWidth = 1.5f;
+	beamInfo.m_flFadeLength = 0.0f;
+	beamInfo.m_flAmplitude = 8.0f;
+	beamInfo.m_flBrightness = 75.0f;
+	beamInfo.m_flSpeed = 10.0f;
+	beamInfo.m_nStartFrame = 0;
+	beamInfo.m_flFrameRate = 0.0f;
+	beamInfo.m_flRed = 255.0f;
+	beamInfo.m_flGreen = 255.0f;
+	beamInfo.m_flBlue = 128.0f;
+	beamInfo.m_nSegments = 20;
+	beamInfo.m_bRenderable = false;
+
+	m_pShieldBeam2 = beams->CreateBeamPoints( 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 = 3.0f;
+	beamInfo.m_flEndWidth = 3.0f;
+	beamInfo.m_flFadeLength = 0.0f;
+	beamInfo.m_flAmplitude = 5.5f;
+	beamInfo.m_flBrightness = 50.0f;
+	beamInfo.m_flSpeed = 10.0f;
+	beamInfo.m_nStartFrame = 0;
+	beamInfo.m_flFrameRate = 0.0f;
+	beamInfo.m_flRed = 255.0f;
+	beamInfo.m_flGreen = 255.0f;
+	beamInfo.m_flBlue = 128.0f;
+	beamInfo.m_nSegments = 18;
+	beamInfo.m_bRenderable = false;
+
+	m_pShieldBeam3 = beams->CreateBeamPoints( beamInfo );	
+
+	m_hShieldSpriteMaterial.Init( "sprites/blueflare1", TEXTURE_GROUP_CLIENT_EFFECTS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::InitTeslaBeam( void )
+{
+	BeamInfo_t beamInfo;
+
+	beamInfo.m_vecStart.Init();
+	beamInfo.m_vecEnd.Init();
+	beamInfo.m_pszModelName = "sprites/blueflare1.vmt";
+	beamInfo.m_flHaloScale = 0.0f;
+	beamInfo.m_flLife = 0.0f;
+	beamInfo.m_flWidth = 1.0f;
+	beamInfo.m_flEndWidth = 1.0f;
+	beamInfo.m_flFadeLength = 0.0f;
+	beamInfo.m_flAmplitude = 16.0f;
+	beamInfo.m_flBrightness = 255.0f;
+	beamInfo.m_flSpeed = 25.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 = 15;
+	beamInfo.m_bRenderable = false;
+	
+	m_pTeslaBeam = beams->CreateBeamPoints( beamInfo );
+
+	beamInfo.m_vecStart.Init();
+	beamInfo.m_vecEnd.Init();
+	beamInfo.m_pszModelName = "sprites/blueflare1.vmt";
+	beamInfo.m_flHaloScale = 0.0f;
+	beamInfo.m_flLife = 0.0f;
+	beamInfo.m_flWidth = 1.0f;
+	beamInfo.m_flEndWidth = 1.0f;
+	beamInfo.m_flFadeLength = 0.0f;
+	beamInfo.m_flAmplitude = 27.0f;
+	beamInfo.m_flBrightness = 100.0f;
+	beamInfo.m_flSpeed = 15.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 = 8;
+	beamInfo.m_bRenderable = false;
+	
+	m_pTeslaBeam2 = beams->CreateBeamPoints( beamInfo );
+
+	m_hTeslaSpriteMaterial.Init( "sprites/blueflare1", TEXTURE_GROUP_CLIENT_EFFECTS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Render a tesla beam in the veiw model.
+//
+// NOTE: This is a big ugly mess that will get cleaned up when I nail down
+//       the effect.
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::DrawBeams( C_BaseViewModel *pViewModel )
+{
+	// Verify data.
+	if ( !pViewModel )
+		return;
+
+	// Only humans have the tesla effects
+	if ( GetTeamNumber() == TEAM_ALIENS )
+		return;
+
+	// Init
+	if ( !m_pTeslaBeam ) 
+	{ 
+		InitTeslaBeam(); 
+	}
+	if ( !m_pShieldBeam ) 
+	{ 
+		InitShieldBeam(); 
+	}
+
+	if ( !m_pShieldBeam || !m_pTeslaBeam )
+		return;
+
+	// Variables
+	BeamInfo_t beamInfo;
+	QAngle vecAngle;
+	int iAttachment;
+
+	// Setup a color reflecting the health
+	float flShieldHealth = GetShieldHealth();
+	color32 color;
+	color.r = 206;
+	color.g = flShieldHealth * 182;
+	color.b = flShieldHealth * 127;
+	color.a = 255;
+
+	// Tesla Effect
+	Vector vecRightTop, vecRightBottom;
+	Vector vecLeftTop, vecLeftBottom;
+	iAttachment = pViewModel->LookupAttachment( "LeftBottom" );
+	pViewModel->GetAttachment( iAttachment, vecLeftBottom, vecAngle );
+	pViewModel->UncorrectViewModelAttachment( vecLeftBottom );
+
+	iAttachment = pViewModel->LookupAttachment( "LeftTip" );
+	pViewModel->GetAttachment( iAttachment, vecLeftTop, vecAngle );
+	pViewModel->UncorrectViewModelAttachment( vecLeftTop );
+
+	iAttachment = pViewModel->LookupAttachment( "RightBottom" );
+	pViewModel->GetAttachment( iAttachment, vecRightBottom, vecAngle );
+	pViewModel->UncorrectViewModelAttachment( vecRightBottom );
+
+	iAttachment = pViewModel->LookupAttachment( "RightTip" );
+	pViewModel->GetAttachment( iAttachment, vecRightTop, vecAngle );
+	pViewModel->UncorrectViewModelAttachment( vecRightTop );
+
+	m_flTeslaLeftInc += weapon_combat_shield_teslaspeed.GetFloat();
+	m_flTeslaRightInc += weapon_combat_shield_teslaspeed.GetFloat();
+	if ( m_flTeslaLeftInc > 1.0f ) { m_flTeslaLeftInc = 0.0f; }
+	if ( m_flTeslaRightInc > 1.0f ) { m_flTeslaRightInc = 0.0f; }
+
+	Vector vecLeft = vecLeftTop - vecLeftBottom;
+	Vector vecRight = vecRightTop - vecRightBottom;
+	Vector vecStart = vecLeftBottom + ( m_flTeslaLeftInc * vecLeft );
+	Vector vecEnd = vecRightBottom + ( m_flTeslaRightInc * vecRight );
+
+	beamInfo.m_vecStart = vecStart;
+	beamInfo.m_vecEnd = vecEnd;
+	beamInfo.m_flRed = color.r;
+	beamInfo.m_flGreen = color.g;
+	beamInfo.m_flBlue = color.b;
+	beams->UpdateBeamInfo( m_pTeslaBeam, beamInfo );	
+	beams->UpdateBeamInfo( m_pTeslaBeam2, beamInfo );	
+	beams->DrawBeam( m_pTeslaBeam );
+	beams->DrawBeam( m_pTeslaBeam2 );
+
+	// Draw a sprite at the tip of the tesla coil.
+	float flSize = 4.0f;
+
+	materials->Bind( m_hShieldSpriteMaterial, this );
+	DrawSprite( vecStart, flSize, flSize, color );
+	DrawSprite( vecEnd, flSize, flSize, color );
+
+	// Shield Effect
+	float flPercentage = random->RandomFloat( 0.0f, 1.0f );
+	if ( flPercentage < weapon_combat_shield_teslaskitter.GetFloat() )
+	{
+		char szShieldJoint[16];
+		int nJoint = random->RandomInt( 1, 8 );
+		Q_snprintf( szShieldJoint, sizeof( szShieldJoint ), "Shield%d", nJoint );
+
+		Vector vecJoint;
+		int iAttachment = pViewModel->LookupAttachment( &szShieldJoint[0] );
+		pViewModel->GetAttachment( iAttachment, vecJoint, vecAngle );
+		pViewModel->UncorrectViewModelAttachment( vecJoint );	
+
+		if ( nJoint < 5 )
+		{
+			beamInfo.m_vecStart = vecLeftTop;
+		}
+		else
+		{
+			beamInfo.m_vecStart = vecRightTop;
+		}
+		beamInfo.m_vecEnd = vecJoint;
+		beams->UpdateBeamInfo( m_pTeslaBeam, beamInfo );	
+		beams->UpdateBeamInfo( m_pTeslaBeam2, beamInfo );	
+		beams->DrawBeam( m_pTeslaBeam );
+		beams->DrawBeam( m_pTeslaBeam2 );
+
+		float flSize = 7.0f; 
+		color32 color = { 206, 181, 127, 255 };
+		materials->Bind( m_hShieldSpriteMaterial, this );
+		DrawSprite( beamInfo.m_vecStart, flSize, flSize, color );
+	}
+
+#if 0
+	// Shield Effect
+	char szShieldJoint[16];
+	Vector vecShieldJoints[8];
+	for( int iJoint = 0; iJoint < 8; ++iJoint )
+	{
+		Q_snprintf( szShieldJoint, sizeof( szShieldJoint ), "Shield%d", iJoint+1 );
+		iAttachment = pViewModel->LookupAttachment( &szShieldJoint[0] );
+		pViewModel->GetAttachment( iAttachment, vecShieldJoints[iJoint], vecAngle );
+		pViewModel->UncorrectViewModelAttachment( vecShieldJoints[iJoint] );	
+	}
+
+	// Shield Internal
+	if ( m_flShieldInc < 1.0f )
+	{
+		Vector vecEdge, vecEnd;
+		if ( m_bLeftToRight )
+		{
+			vecEdge = vecShieldJoints[((m_nShieldEdge+1)%8)] - vecShieldJoints[m_nShieldEdge];
+			vecEnd = vecShieldJoints[m_nShieldEdge] + ( m_flShieldInc * vecEdge );
+		}
+		else
+		{
+			vecEdge = vecShieldJoints[m_nShieldEdge] - vecShieldJoints[((m_nShieldEdge+1)%8)];
+			vecEnd = vecShieldJoints[((m_nShieldEdge+1)%8)] + ( m_flShieldInc * vecEdge );
+		}
+
+		if ( m_nShieldEdge < 5 )
+		{
+			beamInfo.m_vecStart = vecLeftTop;
+		}
+		else
+		{
+			beamInfo.m_vecStart = vecRightTop;
+		}
+
+		beamInfo.m_vecEnd = vecEnd;
+		beams->UpdateBeamPoints( m_pShieldBeam2, beamInfo );
+		beams->UpdateBeamPoints( m_pShieldBeam3, beamInfo );
+		beams->DrawBeam( m_pShieldBeam2 );
+		beams->DrawBeam( m_pShieldBeam3 );
+
+		m_flShieldInc += m_flShieldSpeed;
+	}
+	else
+	{
+		m_flShieldInc = 0.0f;
+		m_flShieldSpeed = random->RandomFloat( 0.015f, 0.15f );
+		m_nShieldEdge = random->RandomInt( 0, 7 );
+
+		float flSide = random->RandomFloat( 0.0f, 1.0f );
+		m_bLeftToRight = ( flSide < 0.5f );
+	}
+
+	// Shield Outline
+	for( iJoint = 0; iJoint < 8; ++iJoint )
+	{
+		beamInfo.m_vecStart = vecShieldJoints[iJoint];
+		beamInfo.m_vecEnd = vecShieldJoints[(iJoint+1)%8];
+		beams->UpdateBeamPoints( m_pShieldBeam, beamInfo );
+		beams->UpdateBeamPoints( m_pShieldBeam2, beamInfo );
+		beams->DrawBeam( m_pShieldBeam );
+		beams->DrawBeam( m_pShieldBeam2 );
+
+		// Draw a sprite at the tip of the tesla coil.
+		float flSize = 3.0f;
+		color32 color = { 255, 255, 0, 255 };
+		materials->Bind( m_hShieldSpriteMaterial, this );
+		DrawSprite( vecShieldJoints[iJoint], flSize, flSize, color );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: If the shield has no health, and they're trying to raise it, flash the power level
+//-----------------------------------------------------------------------------
+void CWeaponCombatShield::HandleInput( void )
+{
+	// If the player's dead, ignore input
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer || pPlayer->GetHealth() < 0 )
+		return;
+
+	// Attempting to raise the shield?
+	if ( !GetShieldHealth() && ( gHUD.m_iKeyBits & IN_ATTACK2 ) )
+	{
+		m_flFlashTimeEnd = gpGlobals->curtime + 1.0;
+	}
+}
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_combat_shield, CWeaponCombatShield );
+LINK_ENTITY_TO_CLASS( weapon_combat_shield_alien, CWeaponCombatShieldAlien );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatShield , DT_WeaponCombatShield )
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponCombatShieldAlien, DT_WeaponCombatShieldAlien )
+
+#if !defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: Only send the LocalWeaponData to the player carrying the weapon
+//-----------------------------------------------------------------------------
+void* SendProxy_SendCombatShieldLocalWeaponDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
+{
+	// Get the weapon entity
+	CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pVarData;
+	if ( pWeapon )
+	{
+		// Only send this chunk of data to the player carrying this weapon
+		CBasePlayer *pPlayer = ToBasePlayer( pWeapon->GetOwner() );
+		if ( pPlayer )
+		{
+			pRecipients->SetOnly( pPlayer->GetClientIndex() );
+			return (void*)pVarData;
+		}
+	}
+	
+	return NULL;
+}
+REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendCombatShieldLocalWeaponDataTable );
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Propagation data for weapons. Only sent when a player's holding it.
+//-----------------------------------------------------------------------------
+BEGIN_NETWORK_TABLE_NOBASE( CWeaponCombatShield, DT_WeaponCombatShieldLocal )
+#if !defined( CLIENT_DLL )
+	SendPropTime( SENDINFO( m_flShieldParryEndTime ) ),
+	SendPropTime( SENDINFO( m_flShieldParrySwingEndTime ) ),
+	SendPropTime( SENDINFO( m_flShieldUnavailableEndTime ) ),
+	SendPropTime( SENDINFO( m_flShieldRaisedTime ) ),
+	SendPropTime( SENDINFO( m_flShieldLoweredTime ) ),
+#else
+	RecvPropTime( RECVINFO( m_flShieldParryEndTime ) ),
+	RecvPropTime( RECVINFO( m_flShieldParrySwingEndTime ) ),
+	RecvPropTime( RECVINFO( m_flShieldUnavailableEndTime ) ),
+	RecvPropTime( RECVINFO( m_flShieldRaisedTime ) ),
+	RecvPropTime( RECVINFO( m_flShieldLoweredTime ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_NETWORK_TABLE( CWeaponCombatShield , DT_WeaponCombatShield )
+#if !defined( CLIENT_DLL )
+	SendPropDataTable("this", 0, &REFERENCE_SEND_TABLE(DT_WeaponCombatShieldLocal), SendProxy_SendCombatShieldLocalWeaponDataTable ),
+	SendPropTime( SENDINFO( m_flShieldUpStartTime ) ),
+	SendPropTime( SENDINFO( m_flShieldDownStartTime ) ),
+	SendPropInt( SENDINFO( m_iShieldState ), 3, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_bAllowPostFrame ), 1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_bHasShieldParry ), 1, SPROP_UNSIGNED ),
+	SendPropFloat(SENDINFO( m_flShieldHealth ), 8, SPROP_ROUNDDOWN, 0.0f, 1.0f ),
+#else
+	RecvPropDataTable("this", 0, 0, &REFERENCE_RECV_TABLE(DT_WeaponCombatShieldLocal)),
+	RecvPropTime( RECVINFO( m_flShieldUpStartTime ) ),
+	RecvPropTime( RECVINFO( m_flShieldDownStartTime ) ),
+	RecvPropInt( RECVINFO( m_iShieldState ) ),
+	RecvPropInt( RECVINFO( m_bAllowPostFrame ) ),
+	RecvPropInt( RECVINFO( m_bHasShieldParry ) ),
+	RecvPropFloat(RECVINFO( m_flShieldHealth ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_NETWORK_TABLE( CWeaponCombatShieldAlien, DT_WeaponCombatShieldAlien )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatShield  )
+
+	DEFINE_PRED_FIELD( m_iShieldState, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bAllowPostFrame, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bHasShieldParry, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flShieldHealth, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+
+	DEFINE_PRED_FIELD_TOL( m_flShieldUpStartTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+	DEFINE_PRED_FIELD_TOL( m_flShieldDownStartTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+	DEFINE_PRED_FIELD_TOL( m_flShieldParryEndTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+	DEFINE_PRED_FIELD_TOL( m_flShieldParrySwingEndTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+	DEFINE_PRED_FIELD_TOL( m_flShieldUnavailableEndTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+	DEFINE_PRED_FIELD_TOL( m_flShieldRaisedTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+	DEFINE_PRED_FIELD_TOL( m_flShieldLoweredTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+
+END_PREDICTION_DATA()
+
+BEGIN_PREDICTION_DATA( CWeaponCombatShieldAlien )
+END_PREDICTION_DATA()
+
+PRECACHE_WEAPON_REGISTER(weapon_combat_shield);
+PRECACHE_WEAPON_REGISTER(weapon_combat_shield_alien);
+
+
+
+
+
diff --git a/game/shared/tf2/weapon_combatshield.h b/game/shared/tf2/weapon_combatshield.h
new file mode 100644
index 0000000..fdece5c
--- /dev/null
+++ b/game/shared/tf2/weapon_combatshield.h
@@ -0,0 +1,185 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_COMBATSHIELD_SHARED_H
+#define WEAPON_COMBATSHIELD_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfcombatweapon_shared.h"
+
+// Shield States
+enum
+{
+	SS_DOWN,			// Not in use
+	SS_RAISING,			// Going up
+	SS_UP,				// Up, active, and blocking
+	SS_LOWERING,		// Going down
+	SS_PARRYING,		// In the process of parrying
+	SS_PARRYING_FINISH_SWING,	// Time to allow the parrying animation to finish
+	SS_UNAVAILABLE,		// Post-parry, unavailable for using
+};
+
+// Shield Hitboxes
+enum
+{
+	SS_HITBOX_NOSHIELD,
+	SS_HITBOX_FULLSHIELD,
+	SS_HITBOX_SMALLSHIELD,
+};
+
+// Range of the shield bash
+#define SHIELD_BASH_RANGE	64.0
+
+#if defined( CLIENT_DLL )
+class Beam_t;
+
+#define CWeaponCombatShield C_WeaponCombatShield
+#define CWeaponCombatShieldAlien C_WeaponCombatShieldAlien
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Shared version of CWeaponCombatShield
+//-----------------------------------------------------------------------------
+class CWeaponCombatShield : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponCombatShield, CBaseTFCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+					CWeaponCombatShield();
+
+	virtual void	Precache( void );
+
+	virtual bool	Deploy( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	virtual bool	TakeShieldBash( CBaseTFPlayer *pBasher );
+	virtual void	ItemPostFrame( void );
+	virtual void	ItemBusyFrame( void );
+	virtual void	ShieldPostFrame( void );
+	virtual	void	GainedNewTechnology( CBaseTechnology *pTechnology );
+	virtual int		UpdateClientData( CBasePlayer *pPlayer );
+
+	void			SetShieldState( int iShieldState );
+	void			UpdateShieldState( void );
+	int				GetShieldState( void );
+
+	void			ShieldBash( void );
+
+	void			SetAllowPostFrame( bool allow );
+	void			SetShieldUsable( bool bUsable );
+	bool			ShieldUsable( void );
+
+	// Shield power levels
+	float			AttemptToBlock( float flDamage );
+	void			ShieldRechargeThink( void );
+
+	virtual bool	VisibleInWeaponSelection( void );
+	virtual int		GetOtherWeaponsActivity( int iActivity );
+	virtual int		ReplaceOtherWeaponsActivity( int iActivity );
+	
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+	bool			IsUp( void );
+	float			GetRaisingTime( void );
+	float			GetLoweringTime( void );
+
+	// Shield health handling
+	float			GetShieldHealth( void );
+	void			AddShieldHealth( float flHealth );
+	void			RemoveShieldHealth( float flHealth );
+
+#if defined( CLIENT_DLL )
+	virtual void	GetViewmodelBoneControllers( CBaseViewModel *pViewModel, float controllers[MAXSTUDIOBONECTRLS]);
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() && 
+			GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	virtual void	DrawAmmo( void );
+	virtual void	HandleInput( void );
+
+	virtual void	ViewModelDrawn( C_BaseViewModel *pViewModel );
+
+	void			InitShieldBeam( void );
+	void			InitTeslaBeam( void );
+	
+	void			DrawBeams( C_BaseViewModel *pViewModel );
+
+#endif
+
+private:
+	CWeaponCombatShield( const CWeaponCombatShield& );
+
+	CNetworkVar( int, m_iShieldState );
+
+	bool			m_bUsable;
+
+	CNetworkVar( float, m_flShieldUpStartTime );
+	CNetworkVar( float, m_flShieldDownStartTime );
+	CNetworkVar( float, m_flShieldParryEndTime );
+	CNetworkVar( float, m_flShieldParrySwingEndTime );
+	CNetworkVar( float, m_flShieldUnavailableEndTime );
+
+	CNetworkVar( float, m_flShieldRaisedTime );
+	CNetworkVar( float, m_flShieldLoweredTime );
+
+	CNetworkVar( float, m_flShieldHealth );
+
+	CNetworkVar( bool, m_bAllowPostFrame );
+	CNetworkVar( bool, m_bHasShieldParry );
+
+#if defined( CLIENT_DLL )
+	float			m_flFlashTimeEnd;
+
+	float				m_flTeslaSpeed;
+	float				m_flTeslaSkitter;
+	float				m_flTeslaLeftInc;
+	float				m_flTeslaRightInc;
+	Beam_t				*m_pTeslaBeam;
+	Beam_t				*m_pTeslaBeam2;
+	CMaterialReference	m_hTeslaSpriteMaterial;
+
+	bool				m_bLeftToRight;
+	int					m_nShieldEdge;
+	float				m_flShieldSpeed;
+	float				m_flShieldInc;
+	Beam_t				*m_pShieldBeam;
+	Beam_t				*m_pShieldBeam2;
+	Beam_t				*m_pShieldBeam3;
+	CMaterialReference	m_hShieldSpriteMaterial;
+#endif
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Need to do different art on client vs server
+//-----------------------------------------------------------------------------
+class CWeaponCombatShieldAlien : public CWeaponCombatShield
+{
+	DECLARE_CLASS( CWeaponCombatShieldAlien, CWeaponCombatShield );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponCombatShieldAlien( void ) {}
+
+private:
+	CWeaponCombatShieldAlien( const CWeaponCombatShieldAlien & );
+};
+
+
+#endif // WEAPON_COMBATSHIELD_SHARED_H
diff --git a/game/shared/tf2/weapon_drainbeam.cpp b/game/shared/tf2/weapon_drainbeam.cpp
new file mode 100644
index 0000000..925fa15
--- /dev/null
+++ b/game/shared/tf2/weapon_drainbeam.cpp
@@ -0,0 +1,523 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Sapper's draining beam
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "in_buttons.h"
+#include "weapon_combatshield.h"
+#include "engine/IEngineSound.h"
+#include "grenade_base_empable.h"
+
+#if defined( CLIENT_DLL )
+
+#include "particles_simple.h"
+
+#else
+
+#include "tf_gamerules.h"
+#include "tf_class_sapper.h"
+
+#endif
+
+#include "weapon_drainbeam.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+#define PARTICLE_PATH_VEL				140.0
+#define NUM_PATH_PARTICLES_PER_SEC		600.0f
+#define NUM_DRIBBLE_PARTICLES_PER_SEC	20.0f
+
+#define NUM_DRAINBEAM_PATH_POINTS		8
+
+// Buff ranges
+static ConVar weapon_drainbeam_target_range( "weapon_drainbeam_target_range", "900", FCVAR_REPLICATED, "The farthest away you can be for the drain gun to initially lock onto a target." );
+static ConVar weapon_drainbeam_stick_range( "weapon_drainbeam_stick_range", "612", FCVAR_REPLICATED, "How far away the drain gun can stay locked onto a target." );
+static ConVar weapon_drainbeam_max_rate( "weapon_drainbeam_max_rate", "10", FCVAR_REPLICATED );
+static ConVar weapon_drainbeam_max_rate_time( "weapon_drainbeam_max_rate_time", "5", FCVAR_REPLICATED );
+static ConVar weapon_drainbeam_emp_time_factor( "weapon_drainbeam_emp_time_factor", "0.75", FCVAR_REPLICATED );
+
+
+LINK_ENTITY_TO_CLASS( weapon_drainbeam, CWeaponDrainBeam );
+
+PRECACHE_WEAPON_REGISTER( weapon_drainbeam );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponDrainBeam, DT_WeaponDrainBeam )
+
+BEGIN_NETWORK_TABLE( CWeaponDrainBeam, DT_WeaponDrainBeam )
+#if !defined( CLIENT_DLL )
+	SendPropInt( SENDINFO( m_bDraining ), 1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_bAttacking ), 1, SPROP_UNSIGNED ),
+	SendPropVector( SENDINFO( m_vFireTarget ), 0, SPROP_COORD ),
+	SendPropEHandle( SENDINFO( m_hDrainTarget ) ),
+#else
+	RecvPropInt( RECVINFO( m_bAttacking ) ),
+	RecvPropInt( RECVINFO( m_bDraining ) ),
+	RecvPropVector( RECVINFO(m_vFireTarget) ),
+	RecvPropEHandle( RECVINFO(m_hDrainTarget) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponDrainBeam  )
+
+	DEFINE_PRED_FIELD( m_bDraining, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bAttacking, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD_TOL( m_vFireTarget, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.125f ),
+
+	DEFINE_PRED_FIELD( m_hDrainTarget, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+
+//	DEFINE_PRED_FIELD( m_pEmitter, FIELD_POINTER ),
+//	DEFINE_PRED_FIELD( m_hParticleMaterial, FIELD_???,  ),
+//	DEFINE_PRED_FIELD( m_PathParticleEvent, FIELD_???,  ),
+//	DEFINE_PRED_FIELD( m_DribbleParticleEvent, FIELD_??? ),
+//	DEFINE_PRED_FIELD( m_bPlayingSound, FIELD_BOOLEAN ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponDrainBeam::CWeaponDrainBeam( void )
+{
+	m_bDraining = false;
+	m_bAttacking = false;
+	m_flNextBuzzTime = 0;
+
+	SetPredictionEligible( true );
+#if defined( CLIENT_DLL )
+	m_pEmitter = NULL;
+	m_hParticleMaterial = INVALID_MATERIAL_HANDLE;
+	m_PathParticleEvent.Init( NUM_PATH_PARTICLES_PER_SEC );
+	m_DribbleParticleEvent.Init( NUM_DRIBBLE_PARTICLES_PER_SEC ); 
+	m_bPlayingSound = false;
+#endif
+}
+
+void CWeaponDrainBeam::Precache()
+{
+	BaseClass::Precache();
+
+	PrecacheScriptSound( "WeaponRepairGun.Healing" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponDrainBeam::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	RemoveDrainTarget();
+	
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a pointer to a drainable target
+//-----------------------------------------------------------------------------
+CBaseEntity *CWeaponDrainBeam::GetTargetToDrain( CBaseEntity *pCurDrainTarget )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return NULL;
+
+#if !defined( CLIENT_DLL )
+	Vector vecSrc = pOwner->Weapon_ShootPosition( );
+
+	// ROBIN: Disabled drainbeam locking to target
+/*
+	// If we're already draining something, stick onto it as long as possible.
+	CBaseEntity *pEntity = pCurDrainTarget;
+	if ( pEntity && pEntity->IsAlive() )
+	{
+		// Make sure the target didn't go out of range.
+		Vector vecTargetCenter = pEntity->Center();
+		if ( (vecTargetCenter - vecSrc).Length() < weapon_drainbeam_stick_range.GetFloat() )
+		{
+			// Now make sure there isn't something other than team players in the way.
+			class CDrainFilter : public CTraceFilterSimple
+			{
+			public:
+				CDrainFilter( CBaseEntity *pShooter ) : CTraceFilterSimple( pShooter, TFCOLLISION_GROUP_WEAPON )
+				{
+					m_pShooter = pShooter;
+				}
+
+				virtual bool ShouldHitEntity( IServerEntity *pServerEntity, int contentsMask )
+				{
+					// If it hit an edict the isn't the target and is on our team, then the ray is blocked.
+					CBaseEntity *pEnt = (CBaseEntity *)pServerEntity;
+
+					// Ignore collisions with the shooter
+					if ( pEnt == m_pShooter )
+						return false;
+
+					// Ignore neutral objects
+					if ( pEnt->GetTeamNumber() == 0 )
+						return false;
+
+					// Ignore collisions with teammates
+					if ( pEnt->GetTeam() == m_pShooter->GetTeam() )
+						return false;
+
+					// Ignore players
+					if ( pEnt->IsPlayer() )
+						return false;
+
+					return CTraceFilterSimple::ShouldHitEntity( pServerEntity, contentsMask );
+				}
+
+				CBaseEntity	*m_pShooter;
+			};
+
+			trace_t tr;
+			CDrainFilter drainFilter( pOwner );
+			engine->TraceLine( vecSrc, vecTargetCenter, MASK_SHOT, &drainFilter, &tr );
+			
+			if (( tr.fraction == 1.0f) || (tr.m_pEnt == pEntity))
+				return pEntity;
+		}
+
+		// Return null so we can't target this player but m_hDrainTarget stays set to them.
+		return NULL;
+	}
+	else
+*/
+	{	
+		// Ok, try to find a new target to drain.
+		// Get the target point and location
+		Vector vecAiming;
+		pOwner->EyeVectors( &vecAiming );
+
+		// Find a player in range of this player, and make sure they're drainable.
+		Vector vecEnd = vecSrc + vecAiming * weapon_drainbeam_target_range.GetFloat();
+		trace_t tr;
+
+		// Use WeaponTraceLine so shields are tested...
+		TFGameRules()->WeaponTraceLine( vecSrc, vecEnd, MASK_SHOT & (~CONTENTS_HITBOX), pOwner, DMG_PROBE, &tr );
+		
+		if ( tr.fraction != 1.0 )
+		{
+			CBaseEntity *pEntity = tr.m_pEnt;
+			if ( pEntity && (pEntity != pOwner) && pEntity->IsAlive() )
+			{
+				// Target needs to not be a player, take EMP damage, and needs to be an enemy
+				if ( !pEntity->IsPlayer() && pEntity->CanBePoweredUp() && pEntity->GetTeamNumber() != 0 && !pEntity->InSameTeam( pOwner ) )
+				{
+					// If we've just locked onto a new target, restart our drain rate
+					if ( pCurDrainTarget != pEntity )
+					{
+						m_flDrainStartedAt = gpGlobals->curtime;
+					}
+					return pEntity;
+				}
+			}
+		}
+
+		return NULL;
+	}
+#endif
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Overloaded to handle the hold-down draining
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// Try to start draining
+	m_bAttacking = false;
+	if ( (pOwner->m_nButtons & IN_ATTACK) && GetShieldState() == SS_DOWN )
+	{
+		PrimaryAttack();
+		m_bAttacking = true;
+	}
+	else if ( GetCurDrainTarget() )
+	{
+		// Detach from the player if they release the attack button.
+		RemoveDrainTarget();
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're draining
+	AllowShieldPostFrame( !m_bAttacking );
+
+	WeaponIdle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::RemoveDrainTarget( void )
+{
+	m_hDrainTarget = NULL;
+	m_bDraining = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Attempt to drain any player within range of the medikit
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+#if !defined( CLIENT_DLL )
+	// Find a target to drain
+	CBaseEntity *pTarget = GetTargetToDrain( GetCurDrainTarget() );
+	if ( pTarget )
+	{
+		// EMP the target
+		if ( pTarget->CanBePoweredUp() )
+		{
+			// Increase the EMP time based upon the time we spent draining
+			float flDrainTime = (gpGlobals->curtime - m_flDrainStartedAt);
+			float flPostDrainTime = weapon_drainbeam_emp_time_factor.GetFloat() * flDrainTime;
+			if ( pTarget->AttemptToPowerup( POWERUP_EMP, flPostDrainTime ) )
+			{
+				// Crank up the drain rate based on the time since we started draining this target
+				flDrainTime = MIN( weapon_drainbeam_max_rate_time.GetFloat(), flDrainTime );
+				float flDrainAmount = weapon_drainbeam_max_rate.GetFloat() * ( flDrainTime / weapon_drainbeam_max_rate_time.GetFloat() );
+
+				// It uses floating point in here so it doesn't lose the fractional part on small frame times.
+				static float flCurDamageAmt = 0.99;
+				float flOldDamageAmt = flCurDamageAmt;
+				flCurDamageAmt += gpGlobals->frametime * flDrainAmount;
+				int iDamage = (int)flCurDamageAmt - (int)flOldDamageAmt;
+
+				// Accumulated enough to do something?
+				if ( iDamage )
+				{
+					// EMPed my target, make it take damage
+					if ( pTarget->GetHealth() )
+					{
+						pTarget->TakeDamage( CTakeDamageInfo( this, pOwner, iDamage, DMG_GENERIC ) );
+					}
+
+					// Increase my health
+					if ( pOwner->GetHealth() < pOwner->GetMaxHealth() )
+					{
+						int maxHealthToAdd = pOwner->GetMaxHealth() - pOwner->GetHealth();
+						int nHealthAdded = MIN( iDamage, maxHealthToAdd );
+						pOwner->TakeHealth( nHealthAdded, DMG_GENERIC );
+					}
+
+					// If I'm a sapper, I store off the energy
+					if ( pOwner->IsClass( TFCLASS_SAPPER ) )
+					{
+						((CPlayerClassSapper*)pOwner->GetPlayerClass())->AddDrainedEnergy( iDamage );
+					}
+				}
+			}
+		}
+
+		// Tell the client who we're trying to drain.
+		m_bDraining = true;
+		m_vFireTarget = pTarget->WorldSpaceCenter();
+		m_hDrainTarget = pTarget;
+	}
+	else
+	{
+		RemoveDrainTarget();
+	}
+#endif
+
+	// Fire continuously.
+	m_flNextPrimaryAttack = gpGlobals->curtime;
+
+	CheckRemoveDisguise();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::PlayAttackAnimation( int activity )
+{
+	SendWeaponAnim( activity );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::WeaponIdle( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::GainedNewTechnology( CBaseTechnology *pTechnology )
+{
+}
+
+#if defined( CLIENT_DLL )
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::StopDrainSound( bool bStopHealingSound, bool bStopNoTargetSound )
+{
+	if ( bStopHealingSound )
+		StopSound( entindex(), "WeaponRepairGun.Healing" );
+
+	if ( bStopNoTargetSound )
+		StopSound( entindex(), "WeaponRepairGun.NoTarget" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		m_pEmitter = CSimpleEmitter::Create( "C_WeaponDrainBeam" );
+		m_hParticleMaterial = m_pEmitter->GetPMaterial( "sprites/chargeball" );
+
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
+	}
+
+	// Think?
+	if ( !m_bDraining )
+	{
+		m_bPlayingSound = false;
+		StopDrainSound( true, false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponDrainBeam::ClientThink()
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	// Don't show it while the player is dead. Ideally, we'd respond to m_bDraining in OnDataChanged,
+	// but it stops sending the weapon when it's holstered, and it gets holstered when the player dies.
+	C_BasePlayer *pFiringPlayer = dynamic_cast< C_BasePlayer* >( GetOwner() );
+	if ( !pFiringPlayer || pFiringPlayer->IsPlayerDead() )
+	{
+		m_bPlayingSound = false;
+		StopDrainSound();
+		return;
+	}
+
+	// Abort if we're not draining, or the player doesn't have the fire button down
+	if ( !m_bDraining && !m_bAttacking )
+		return;
+
+	// Ready for particle emission, sir
+	m_pEmitter->SetSortOrigin( (m_vFireTarget + pPlayer->GetAbsOrigin()) * 0.5f );
+	float flCur = gpGlobals->frametime;
+	Vector vForward, vOrigin;
+	QAngle vAngles;
+	GetShootPosition( vOrigin, vAngles );
+	AngleVectors( vAngles, &vForward );
+
+	// Are they holding the attack button but not draining anyone? Give feedback.
+	if ( !m_bDraining )
+	{
+		// Add random short-lived particles from the gun tip to the target.
+		while ( m_DribbleParticleEvent.NextEvent( flCur ) )
+		{
+			Vector vPos = vOrigin;
+			vPos += RandomVector( -2, 2 );
+			SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
+			if ( pParticle )
+			{
+				// Move the points along the path.
+				pParticle->m_vecVelocity = vForward;
+				pParticle->m_vecVelocity *= 50;
+
+				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 = 0;
+				pParticle->m_iFlags = 0;
+			}
+		}
+		return;
+	}
+
+	if ( !m_bPlayingSound )
+	{
+		m_bPlayingSound = true;
+		CLocalPlayerFilter filter;
+
+		EmitSound( filter, entindex(), "WeaponRepairGun.Healing" );
+	}
+
+	Vector points[NUM_DRAINBEAM_PATH_POINTS];
+
+	// First generate a sequence of points so we can parameterize the (curvy) path from the
+	// tip of the gun to the target.
+	Vector vDirTo = m_vFireTarget - vOrigin;
+	float flDistanceTo = vDirTo.Length();
+	vDirTo /= flDistanceTo;
+
+	float flBendDist = flDistanceTo * 3;
+	const Vector  A = vOrigin - vForward * flBendDist;
+	const Vector &B = vOrigin;
+	const Vector &C = m_vFireTarget;
+	const Vector  D = m_vFireTarget - vForward * flBendDist;
+	
+	for ( int i=0; i < NUM_DRAINBEAM_PATH_POINTS; i++ )
+	{
+		Catmull_Rom_Spline( A, B, C, D, (float)i / (NUM_DRAINBEAM_PATH_POINTS-1), points[i] );
+	}
+
+	// Add random short-lived particles from the gun tip to the target.
+	while ( m_PathParticleEvent.NextEvent( flCur ) )
+	{
+		float t = RandomFloat( 0, 1 );
+		int iPrev = (int)( t * (NUM_DRAINBEAM_PATH_POINTS - 1.001) );
+		float tPrev = (float)iPrev / (NUM_DRAINBEAM_PATH_POINTS - 1);
+		float tNext = (float)(iPrev+1) / (NUM_DRAINBEAM_PATH_POINTS - 1);
+		Assert( tNext <= NUM_DRAINBEAM_PATH_POINTS-1 );
+
+		Vector vPos;
+		VectorLerp( points[iPrev], points[iPrev+1], (t-tPrev) / (tNext - tPrev), vPos );
+		vPos += RandomVector( -2, 2 );
+		
+		SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
+		if ( pParticle )
+		{
+			// Move the points along the path.
+			pParticle->m_vecVelocity = points[iPrev+1] - points[iPrev];
+			VectorNormalize( pParticle->m_vecVelocity );
+			pParticle->m_vecVelocity *= -PARTICLE_PATH_VEL;
+
+			pParticle->m_flRoll = 0;
+			pParticle->m_flRollDelta = 0;
+			pParticle->m_flDieTime = 0.2f;
+			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;
+		}
+	}
+}
+#endif
diff --git a/game/shared/tf2/weapon_drainbeam.h b/game/shared/tf2/weapon_drainbeam.h
new file mode 100644
index 0000000..61239ce
--- /dev/null
+++ b/game/shared/tf2/weapon_drainbeam.h
@@ -0,0 +1,99 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_DRAINBEAM_H
+#define WEAPON_DRAINBEAM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_combat_usedwithshieldbase.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponDrainBeam C_WeaponDrainBeam
+#endif
+
+//=========================================================
+// Medikit Weapon
+//=========================================================
+class CWeaponDrainBeam : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponDrainBeam, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponDrainBeam( void );
+
+	virtual void	Precache();
+
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual void	WeaponIdle( void );
+
+	virtual void	PlayAttackAnimation( int activity );
+	virtual void	GainedNewTechnology( CBaseTechnology *pTechnology );
+
+	// Draining
+	CBaseEntity		*GetTargetToDrain( CBaseEntity *pCurDrainTarget );
+	CBaseEntity		*GetCurDrainTarget( void )	{ return m_hDrainTarget; }
+	void			RemoveDrainTarget( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+	// Stop all sounds being output.
+	void			StopDrainSound( bool bStopHealingSound = true, bool bStopNoTargetSound = true );
+// IClientNetworkable.
+public:
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+// IClientThinkable.
+public:
+
+	virtual void	ClientThink();
+
+#endif
+
+public:
+	CNetworkHandle( CBaseEntity, m_hDrainTarget );
+
+// Networked data.
+public:
+	CNetworkVar( bool, m_bDraining );
+	CNetworkVar( bool, m_bAttacking );
+	CNetworkVector( m_vFireTarget );
+
+#if defined( CLIENT_DLL )
+	CSmartPtr<CSimpleEmitter> m_pEmitter;
+	PMaterialHandle			m_hParticleMaterial;
+
+	TimedEvent				m_PathParticleEvent;
+	TimedEvent				m_DribbleParticleEvent;
+
+	bool					m_bPlayingSound;
+#else
+	float					m_flDrainStartedAt;
+#endif
+private:
+	double					m_flNextBuzzTime;
+	
+	CWeaponDrainBeam( const CWeaponDrainBeam & );
+};
+
+#endif // WEAPON_DRAINBEAM_H
diff --git a/game/shared/tf2/weapon_flame_thrower.cpp b/game/shared/tf2/weapon_flame_thrower.cpp
new file mode 100644
index 0000000..9d98227
--- /dev/null
+++ b/game/shared/tf2/weapon_flame_thrower.cpp
@@ -0,0 +1,434 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "in_buttons.h"
+#include "weapon_combatshield.h"
+#include "weapon_flame_thrower.h"
+#include "gasoline_shared.h"
+#include "ammodef.h"
+
+
+#define FLAME_THROWER_FIRE_INTERVAL		0.3		// Eject a fire blob entity this often.
+
+#define FLAMETHROWER_FLAME_DISTANCE		400.0
+
+#define FLAMETHROWER_FLAME_SPEED		500.0	//
+
+#define FLAMETHROWER_DAMAGE_PER_SEC		1000
+
+// How far the flame particles will spread from the center.
+#define FLAMETHROWER_SPREAD_ANGLE		15.0
+
+
+// ------------------------------------------------------------------------------------------------ //
+// Pretty little tables.
+// ------------------------------------------------------------------------------------------------ //
+
+#if defined( CLIENT_DLL )
+
+	#include "vstdlib/random.h"
+	#include "engine/IEngineSound.h"
+
+	#define FLAMETHROWER_PARTICLES_PER_SEC	100
+
+#else
+
+	#include "gasoline_blob.h"
+	#include "fire_damage_mgr.h"
+	#include "tf_gamerules.h"
+	
+	#define FLAMETHROWER_DAMAGE_INTERVAL	0.2
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+PRECACHE_WEAPON_REGISTER( weapon_flame_thrower );
+
+LINK_ENTITY_TO_CLASS( weapon_flame_thrower, CWeaponFlameThrower );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponFlameThrower, DT_WeaponFlameThrower )
+
+BEGIN_NETWORK_TABLE( CWeaponFlameThrower, DT_WeaponFlameThrower )
+	#if defined( CLIENT_DLL )
+		RecvPropInt( RECVINFO( m_bFiring ) )
+	#else
+		SendPropInt( SENDINFO( m_bFiring ), 1, SPROP_UNSIGNED )
+	#endif
+END_NETWORK_TABLE()
+		  
+BEGIN_PREDICTION_DATA( CWeaponFlameThrower )
+
+	DEFINE_PRED_FIELD( m_bFiring, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+
+static inline void GenerateRandomFlameThrowerVelocity( Vector &vOut, const Vector &vForward, const Vector &vRight, const Vector &vUp )
+{
+	static float radians = DEG2RAD( 90 - FLAMETHROWER_SPREAD_ANGLE );
+	static float v = cos( radians ) / sin( radians );
+	
+	vOut = vForward + vRight * RandomFloat( -v, v ) + vUp * RandomFloat( -v, v );
+	VectorNormalize( vOut );
+}
+
+template< class T >
+int FindInArray( const T pTest, const T *pArray, int arrayLen )
+{
+	for ( int i=0; i < arrayLen; i++ )
+	{
+		if ( pTest == pArray[i] )
+			return i;
+	}
+	return -1;
+}
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CWeaponFlameThrower implementation.
+// ------------------------------------------------------------------------------------------------ //
+
+CWeaponFlameThrower::CWeaponFlameThrower()
+{
+	InternalConstructor( false );
+}
+
+
+CWeaponFlameThrower::CWeaponFlameThrower( bool bCanister )
+{
+	InternalConstructor( bCanister );
+}
+
+void CWeaponFlameThrower::Precache()
+{
+	BaseClass::Precache();
+
+	PrecacheScriptSound( "FlameThrower.Sound" );
+}
+
+void CWeaponFlameThrower::InternalConstructor( bool bCanister )
+{
+	m_bCanister = bCanister;
+
+	m_bFiring = false;							   	
+	m_flNextPrimaryAttack = -1;
+
+	#if defined( CLIENT_DLL )
+	{
+		m_hFlameEmitter = CSimpleEmitter::Create( "flamethrower" );
+		
+		m_hFireMaterial = INVALID_MATERIAL_HANDLE;
+		if ( IsGasCanister() )
+		{
+			m_hFireMaterial = m_hFlameEmitter->GetPMaterial( "particle/particle_noisesphere" );
+		}
+		else
+		{
+			m_hFireMaterial = m_hFlameEmitter->GetPMaterial( "particle/fire" );
+		}
+	
+		m_FlameEvent.Init( FLAMETHROWER_PARTICLES_PER_SEC );
+
+		m_bSoundOn = false;
+	}
+	#endif
+}
+
+
+CWeaponFlameThrower::~CWeaponFlameThrower()
+{
+	#if defined( CLIENT_DLL )
+		StopFlameSound();
+	#endif
+}
+
+
+bool CWeaponFlameThrower::IsGasCanister() const
+{
+	return m_bCanister;
+}
+
+
+bool CWeaponFlameThrower::IsPredicted() const
+{
+	return true;
+}
+
+
+void CWeaponFlameThrower::ItemPostFrame()
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	if ( pOwner->IsAlive() && 
+		(pOwner->m_nButtons & IN_ATTACK) && 
+		GetShieldState() == SS_DOWN &&
+		GetPrimaryAmmo() > 2 )
+	{
+		PrimaryAttack();
+		m_bFiring = true;
+
+		// Prevent shield post frame if we're not ready to attack, or we're healing
+		AllowShieldPostFrame( false );
+	}
+	else
+	{
+		AllowShieldPostFrame( true );
+		m_flNextPrimaryAttack = -1;
+		m_bFiring = false;
+
+#if defined( CLIENT_DLL )
+#else
+		m_hPrevBlob = NULL;
+
+		// It's easy to lay down gasoline and forget to leave enough ammo to ignite it, so
+		// this allows the pyro to ignite any nearby gasoline blobs for free.
+		if ( !m_bCanister && GetPrimaryAmmo() <= 2 )
+		{
+			IgniteNearbyGasolineBlobs();
+		}
+#endif
+	}
+}
+
+
+void CWeaponFlameThrower::PrimaryAttack()
+{
+	#if defined( CLIENT_DLL )
+	
+	#else
+
+		CBasePlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+		if ( !pOwner )
+			return;
+		
+		// Ok.. find eligible entities in a cone in front of us.
+		Vector vOrigin = pOwner->Weapon_ShootPosition( );
+		Vector vForward, vRight, vUp;
+		AngleVectors( pOwner->GetAbsAngles(), &vForward, &vRight, &vUp );
+
+		// Find some entities to burn.
+		CBaseEntity *pHitEnts[64];
+		int nHitEnts = 0;
+
+		#define NUM_TEST_VECTORS	30
+		for ( int iTest=0; iTest < NUM_TEST_VECTORS; iTest++ )
+		{	
+			Vector vVel;  
+			GenerateRandomFlameThrowerVelocity( vVel, vForward, vRight, vUp );
+
+			trace_t tr;
+			UTIL_TraceLine( vOrigin, vOrigin + vVel * FLAMETHROWER_FLAME_DISTANCE, MASK_SHOT & (~CONTENTS_HITBOX), NULL, COLLISION_GROUP_NONE, &tr );
+			if ( tr.m_pEnt )
+			{
+				if ( TFGameRules()->IsTraceBlockedByWorldOrShield( vOrigin, vOrigin + vVel * FLAMETHROWER_FLAME_DISTANCE, GetOwner(), DMG_BURN | DMG_PROBE, &tr ) == false )
+				{
+					CBaseEntity *pTestEnt = tr.m_pEnt;
+					if ( pTestEnt && IsBurnableEnt( pTestEnt, GetTeamNumber() ) )
+					{
+						if ( FindInArray( pTestEnt, pHitEnts, nHitEnts ) == -1 )
+						{
+							pHitEnts[nHitEnts++] = pTestEnt;
+							if ( nHitEnts >= ARRAYSIZE( pHitEnts ) )
+								break;
+						}
+					}
+				}	
+			}
+		}
+
+		for ( int iHitEnt=0; iHitEnt < nHitEnts; iHitEnt++ )
+		{
+			CBaseEntity *pEnt = pHitEnts[iHitEnt];
+
+			float flDist = (pEnt->GetAbsOrigin() - vOrigin).Length();
+			float flPercent = 1.0 - flDist / FLAMETHROWER_FLAME_DISTANCE;
+			if ( flPercent < 0.1 )
+				flPercent = 0.1;
+
+			float flDamage = flPercent * FLAMETHROWER_DAMAGE_PER_SEC;
+			GetFireDamageMgr()->AddDamage( pEnt, GetOwner(), flDamage, !IsGasolineBlob( pEnt ) );
+		}
+		
+
+		// Drop a new petrol blob.
+		if ( gpGlobals->curtime >= m_flNextPrimaryAttack )
+		{
+			float flLifetime = MAX_LIT_GASOLINE_BLOB_LIFETIME;
+			if ( IsGasCanister() )
+				flLifetime = MAX_UNLIT_GASOLINE_BLOB_LIFETIME;
+
+			CGasolineBlob *pBlob = CGasolineBlob::Create( GetOwner(), vOrigin, vForward * FLAMETHROWER_FLAME_SPEED, false, FLAMETHROWER_FLAME_DISTANCE / FLAMETHROWER_FLAME_SPEED, flLifetime );
+			if ( pBlob )
+			{
+				if ( IsGasCanister() )
+				{
+					// Link the previous blob to this one.
+					pBlob->AddAutoBurnBlob( m_hPrevBlob );
+					if ( m_hPrevBlob.Get() )
+						m_hPrevBlob->AddAutoBurnBlob( pBlob );
+
+					m_hPrevBlob = pBlob;
+				}
+				else
+				{
+					pBlob->SetLit( true );
+				}
+			}
+
+			pOwner->RemoveAmmo( 2, m_iPrimaryAmmoType );
+
+			// Drop a blob every half second.
+			m_flNextPrimaryAttack = gpGlobals->curtime + FLAME_THROWER_FIRE_INTERVAL;
+		}
+
+	#endif
+}
+
+
+#if defined( CLIENT_DLL )
+
+	bool CWeaponFlameThrower::ShouldPredict()
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+
+	void CWeaponFlameThrower::NotifyShouldTransmit( ShouldTransmitState_t state )
+	{
+		BaseClass::NotifyShouldTransmit( state );
+
+		if ( state == SHOULDTRANSMIT_START )
+		{
+			SetNextClientThink( CLIENT_THINK_ALWAYS );
+		}		
+		else if ( state == SHOULDTRANSMIT_END )
+		{
+			SetNextClientThink( CLIENT_THINK_NEVER );
+			StopFlameSound();
+		}
+	}
+
+	void CWeaponFlameThrower::ClientThink()
+	{
+		// Spew some particles out.
+		if ( !IsDormant() && IsCarrierAlive() && m_bFiring && m_hFlameEmitter.IsValid() )
+		{
+			unsigned char color[4] = { 255, 128, 0, 255 };
+			if ( IsGasCanister() )
+			{
+				color[0] = color[1] = color[2] = 200;
+				color[3] = 255;
+			}
+
+			StartSound();
+			
+			Vector vForward, vUp, vRight, vOrigin;
+			QAngle vAngles;
+			GetShootPosition( vOrigin, vAngles );
+			AngleVectors( vAngles, &vForward, &vRight, &vUp );
+			
+			// Spew out flame particles.
+			float dt = gpGlobals->frametime;
+			while ( m_FlameEvent.NextEvent( dt ) )
+			{
+				SimpleParticle *p = m_hFlameEmitter->AddSimpleParticle( 
+					m_hFireMaterial, 
+					vOrigin + RandomVector( -3, 3 ),
+					FLAMETHROWER_FLAME_DISTANCE / FLAMETHROWER_FLAME_SPEED,	// lifetime,
+					9	// size
+					);
+
+				if ( p )
+				{
+					p->m_uchColor[0] = color[0];
+					p->m_uchColor[1] = color[1];
+					p->m_uchColor[2] = color[2];
+					p->m_uchStartAlpha = color[3];
+					p->m_uchEndAlpha = 0;
+					GenerateRandomFlameThrowerVelocity( p->m_vecVelocity, vForward, vRight, vUp );
+					p->m_vecVelocity *= RandomFloat( FLAMETHROWER_FLAME_SPEED * 0.9, FLAMETHROWER_FLAME_SPEED * 1.1 );
+				}
+			}
+		}
+		else
+		{
+			StopFlameSound();
+		}
+	}
+
+
+	void CWeaponFlameThrower::StartSound()
+	{
+		if ( !m_bSoundOn )
+		{
+			CLocalPlayerFilter filter;
+			EmitSound( filter, entindex(), "FlameThrower.Sound" );
+
+			m_bSoundOn = true;
+		}
+	}
+
+
+	void CWeaponFlameThrower::StopFlameSound()
+	{
+		if ( m_bSoundOn )
+		{
+			StopSound( entindex(), "FlameThrower.Sound" );
+			m_bSoundOn = false;
+		}
+	}
+
+
+#else
+
+	bool CWeaponFlameThrower::Holster( CBaseCombatWeapon *pSwitchingTo )
+	{
+		m_bFiring = false;
+		
+		return BaseClass::Holster( pSwitchingTo );
+	}
+
+
+	void CWeaponFlameThrower::IgniteNearbyGasolineBlobs()
+	{
+		CBasePlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+		if ( !pOwner )
+			return;
+
+		Vector vOrigin = pOwner->Weapon_ShootPosition( );
+		CBaseEntity *ents[128];
+		float dists[128];
+		int nEnts = FindBurnableEntsInSphere(
+			ents,
+			dists,
+			ARRAYSIZE( dists ),
+			vOrigin,
+			50,
+			pOwner );
+
+		for ( int i=0; i < nEnts; i++ )
+		{
+			CGasolineBlob *pBlob = dynamic_cast< CGasolineBlob* >( ents[i] );
+			if ( pBlob )
+			{
+				GetFireDamageMgr()->AddDamage( pBlob, pOwner, 500, false );
+			}
+		}
+	}
+
+#endif
+
+
diff --git a/game/shared/tf2/weapon_flame_thrower.h b/game/shared/tf2/weapon_flame_thrower.h
new file mode 100644
index 0000000..f2700e2
--- /dev/null
+++ b/game/shared/tf2/weapon_flame_thrower.h
@@ -0,0 +1,95 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_FLAME_THROWER_H
+#define WEAPON_FLAME_THROWER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_combat_usedwithshieldbase.h"
+
+#if defined( CLIENT_DLL )
+	#define CWeaponFlameThrower C_WeaponFlameThrower
+
+	#include "particlemgr.h"
+	#include "particle_util.h"
+	#include "particles_simple.h"
+
+#else
+
+	class CGasolineBlob;
+
+#endif
+
+//=========================================================
+// Medikit Weapon
+//=========================================================
+class CWeaponFlameThrower : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponFlameThrower, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponFlameThrower();
+	CWeaponFlameThrower( bool bCanister );
+	~CWeaponFlameThrower();
+
+	virtual void			Precache();
+
+	// The gas canister says yes so we can do different things.
+	bool					IsGasCanister() const;
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const;
+	virtual void			ItemPostFrame();
+
+
+#if defined( CLIENT_DLL )
+
+	virtual bool	ShouldPredict( void );
+
+	virtual void			NotifyShouldTransmit( ShouldTransmitState_t state );
+	virtual void			ClientThink();
+
+	// Start/stop the fire sound.
+	void					StartSound();
+	void					StopFlameSound();
+	bool					m_bSoundOn;	// Is the sound on?
+
+	CSmartPtr<CSimpleEmitter>	m_hFlameEmitter;
+	PMaterialHandle				m_hFireMaterial;
+	TimedEvent					m_FlameEvent;
+
+#else
+
+	virtual bool			Holster( CBaseCombatWeapon *pSwitchingTo );
+	void					IgniteNearbyGasolineBlobs();
+
+private:
+
+	// Used to link the blobs together.
+	CHandle<CGasolineBlob>	m_hPrevBlob;
+
+
+#endif
+
+
+private:
+
+	void		PrimaryAttack();
+	void		InternalConstructor( bool bCanister );
+
+	CNetworkVar( bool, m_bFiring );
+	bool		m_bCanister;	// Tells if we're a gas canister or a flamethrower (both act in similar ways).
+	float		m_flNextPrimaryAttack;
+
+	CWeaponFlameThrower( const CWeaponFlameThrower & );
+};
+
+#endif // WEAPON_FLAME_THROWER_H
diff --git a/game/shared/tf2/weapon_gas_can.cpp b/game/shared/tf2/weapon_gas_can.cpp
new file mode 100644
index 0000000..28684b1
--- /dev/null
+++ b/game/shared/tf2/weapon_gas_can.cpp
@@ -0,0 +1,35 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "in_buttons.h"
+#include "weapon_combatshield.h"
+#include "weapon_gas_can.h"
+
+
+LINK_ENTITY_TO_CLASS( weapon_gas_can, CWeaponGasCan );
+
+PRECACHE_WEAPON_REGISTER( weapon_flame_thrower );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGasCan, DT_WeaponGasCan )
+
+BEGIN_NETWORK_TABLE( CWeaponGasCan, DT_WeaponGasCan )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponGasCan )
+END_PREDICTION_DATA()
+
+
+// ------------------------------------------------------------------------------------------------ //
+// CWeaponGasCan implementation.
+// ------------------------------------------------------------------------------------------------ //
+
+CWeaponGasCan::CWeaponGasCan() : CWeaponFlameThrower( true )
+{
+}
+
+
diff --git a/game/shared/tf2/weapon_gas_can.h b/game/shared/tf2/weapon_gas_can.h
new file mode 100644
index 0000000..2df1850
--- /dev/null
+++ b/game/shared/tf2/weapon_gas_can.h
@@ -0,0 +1,39 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_GAS_CAN_H
+#define WEAPON_GAS_CAN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_combat_usedwithshieldbase.h"
+#include "weapon_flame_thrower.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponGasCan C_WeaponGasCan
+#endif
+
+//=========================================================
+// Medikit Weapon
+//=========================================================
+class CWeaponGasCan : public CWeaponFlameThrower
+{
+	DECLARE_CLASS( CWeaponGasCan, CWeaponFlameThrower );
+public:
+	CWeaponGasCan();
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+
+private:
+
+	CWeaponGasCan( const CWeaponGasCan & );
+};
+
+#endif // WEAPON_GAS_CAN_H
diff --git a/game/shared/tf2/weapon_grenade_rocket.cpp b/game/shared/tf2/weapon_grenade_rocket.cpp
new file mode 100644
index 0000000..2f32f56
--- /dev/null
+++ b/game/shared/tf2/weapon_grenade_rocket.cpp
@@ -0,0 +1,390 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Rockets (Weapon)
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_grenade_rocket.h"
+
+#if defined( CLIENT_DLL )
+// Client Only
+#include "hud.h"
+#include "particles_simple.h"
+#else
+// Server Only
+#include "gameinterface.h"
+#include "engine/IEngineSound.h"
+#include "explode.h"
+#include "tf_team.h"
+#include "env_laserdesignation.h"
+#include "iservervehicle.h"
+#endif
+
+LINK_ENTITY_TO_CLASS( weapon_grenade_rocket, CWeaponGrenadeRocket );
+BEGIN_PREDICTION_DATA( CWeaponGrenadeRocket )
+END_PREDICTION_DATA()
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponGrenadeRocket, DT_WeaponGrenadeRocket )
+BEGIN_NETWORK_TABLE( CWeaponGrenadeRocket, DT_WeaponGrenadeRocket )
+//#if !defined( CLIENT_DLL )
+//#else
+//#endif
+END_NETWORK_TABLE()
+
+#define WEAPON_GRENADE_ROCKET_VELOCITY			1000
+
+#if !defined( CLIENT_DLL )
+// Server Only
+ConVar weapon_grenade_rocket_track_range_mod( "weapon_grenade_rocket_track_range_mod","1.5", FCVAR_NONE, "Range multiplier when a rocket's tracking a designated target." );
+ConVar weapon_grenade_rocket_force( "weapon_grenade_rocket_force","150.0", FCVAR_NONE, "Rocket force modifier." ); 
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeaponGrenadeRocket::CWeaponGrenadeRocket()
+{
+	m_flDamage = 100.0f;
+
+#if !defined( CLIENT_DLL )
+	// Server Only
+	UseClientSideAnimation();
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Deconstructor
+//-----------------------------------------------------------------------------
+CWeaponGrenadeRocket::~CWeaponGrenadeRocket()
+{
+#if defined( CLIENT_DLL )
+	StopSound( entindex(), "GrenadeRocket.FlyLoop" );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a weapon grenade rocket
+//-----------------------------------------------------------------------------
+CWeaponGrenadeRocket *CWeaponGrenadeRocket::Create( const Vector &vecOrigin, const Vector &vecForward, float flMaxRange, CBaseEntity *pOwner )
+{
+#if !defined( CLIENT_DLL )
+	CWeaponGrenadeRocket *pRocket = ( CWeaponGrenadeRocket* )CreateEntityByName( "weapon_grenade_rocket" );
+
+	UTIL_SetOrigin( pRocket, vecOrigin );
+	QAngle angles;
+	VectorAngles( vecForward, angles );
+	pRocket->SetLocalAngles( angles );
+	pRocket->Spawn();
+	pRocket->SetOwnerEntity( pOwner );
+	pRocket->ChangeTeam( pOwner->GetTeamNumber() );
+	pRocket->SetMaxRange( flMaxRange );
+
+	return pRocket;
+#else
+	return NULL;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::SetMaxRange( float flRange )
+{
+	m_flMaxRange = flRange;
+	m_flFallingSpeed = 200;	// Initial falling speed
+
+	// Reduce max range for upward shots
+	Vector vecForward;
+	GetVectors( &vecForward, NULL, NULL );
+	if ( vecForward.z > 0 )
+	{
+		m_flMaxRange = MAX(1, m_flMaxRange - (vecForward.z * 1200));
+	}
+	else 
+	{
+		m_flMaxRange -= (vecForward.z * 2400);
+	}
+
+#if !defined( CLIENT_DLL )
+	if ( m_flMaxRange )
+	{
+		float flSpeed = GetLocalVelocity().Length();
+		Assert( flSpeed );
+		m_flExceedRangeTime = gpGlobals->curtime + (m_flMaxRange / flSpeed);
+
+		// Start looking for designators
+		SetThink( TrackThink );
+		SetNextThink( gpGlobals->curtime + 0.1f );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::Spawn( void )
+{
+#if !defined( CLIENT_DLL )
+	Precache();
+
+	m_flRadius = 100;
+	SetMoveType( MOVETYPE_FLY );
+	SetSolid( SOLID_BBOX );
+	SetModel( "models/weapons/w_missile.mdl" );
+	UTIL_SetSize( this, vec3_origin, vec3_origin );
+
+	SetCollisionGroup( TFCOLLISION_GROUP_WEAPON );
+
+	// Forward!
+	Vector forward;
+	AngleVectors( GetLocalAngles(), &forward, NULL, NULL );
+	SetAbsVelocity( forward * WEAPON_GRENADE_ROCKET_VELOCITY );
+	
+	SetTouch( RocketTouch );
+#else
+	// Start our flying sound loop
+	CPASAttenuationFilter filter( this );
+	filter.MakeReliable();
+	EmitSound( filter, entindex(), "GrenadeRocket.FlyLoop" );
+#endif
+}
+
+#if !defined( CLIENT_DLL )
+// Server Only
+	
+//-----------------------------------------------------------------------------
+// Purpose: Return my owner as my scorer
+//-----------------------------------------------------------------------------
+CBasePlayer *CWeaponGrenadeRocket::GetScorer( void )
+{
+	return ToBasePlayer( m_hOwner );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::Precache( void )
+{
+	PrecacheModel( "models/weapons/w_missile.mdl" );
+
+	PrecacheScriptSound( "GrenadeRocket.FlyLoop" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: We've exceeded this rocket's range, start heading downward, randomly
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::ExceededRangeThink( void )
+{
+	Vector vecZ( 0,0,1 );
+	Vector vecPerp;
+
+	// Weave drunkely and head down
+	Vector vecVelocity = GetLocalVelocity();
+	CrossProduct( vecVelocity, vecZ, vecPerp );
+	VectorNormalize( vecPerp );
+	vecPerp *= random->RandomFloat(-100,100);
+	vecVelocity += vecPerp;
+	vecVelocity.z -= m_flFallingSpeed;
+	m_flFallingSpeed += 50;
+	SetLocalVelocity( vecVelocity );
+
+	SetAnglesToMatchVelocity();
+	SetNextThink( gpGlobals->curtime + 0.3 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Track towards my my designated target
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::TrackThink( void )
+{
+	SetNextThink( gpGlobals->curtime + 0.3 );
+
+	// Have I exceeded my range?
+	if ( gpGlobals->curtime > m_flExceedRangeTime )
+	{
+		SetThink( ExceededRangeThink );
+		// Start falling immediately
+		ExceededRangeThink();
+		return;
+	}
+
+	// Look for any laser designators in tracking view
+	int iTeam = GetTeamNumber();
+	int iCount = CEnvLaserDesignation::GetNumLaserDesignators( iTeam );
+	if ( !iCount )
+		return;
+
+	// Get the potential lock range
+	float flIncreasedMaxRange = m_flMaxRange * weapon_grenade_rocket_track_range_mod.GetFloat();
+	float flNearestDot = 0.95;
+	Vector vecNearestTarget = vec3_origin;
+	bool bFoundOne = false;
+
+	// Any valid designated targets?
+	for ( int i = 0; i < iCount; i++ )
+	{
+		Vector vecTarget;
+		if ( !CEnvLaserDesignation::GetLaserDesignation( iTeam, i, &vecTarget ) )
+			continue;
+	
+		// Check validity of designated target
+		Vector vecToTarget = ( vecTarget - GetAbsOrigin() );
+		float flDistanceSqr = vecToTarget.LengthSqr();
+		// Make sure it's not too far
+		if ( flDistanceSqr > (flIncreasedMaxRange*flIncreasedMaxRange) )
+			continue;
+
+		// Make sure it's near my flight path
+		VectorNormalize(vecToTarget);
+		Vector vecForward;
+		GetVectors( &vecForward, NULL, NULL );
+		float flDot = DotProduct( vecToTarget, vecForward );
+		if ( flDot < flNearestDot )
+			continue;
+
+		flNearestDot = flDot;
+		vecNearestTarget = vecTarget;
+		bFoundOne = true;
+	}
+
+	// No valid targets
+	if ( !bFoundOne )
+		return;
+
+	SetNextThink( gpGlobals->curtime + 0.1f );
+
+	// Turn towards my target
+	Vector vecToTarget = (vecNearestTarget - GetAbsOrigin());
+	VectorNormalize(vecToTarget);
+
+	// Shamelessly ripped from HL1 RPG
+	float flSpeed = GetAbsVelocity().Length();
+	SetAbsVelocity( (GetAbsVelocity() * 0.5) + (vecToTarget * flSpeed * 0.498) );
+
+	SetAnglesToMatchVelocity();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set angles to match our velocity
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::SetAnglesToMatchVelocity( void )
+{
+	QAngle angles;
+	VectorAngles( GetAbsVelocity(), angles );
+	SetLocalAngles( angles );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::RocketTouch( CBaseEntity *pOther )
+{
+	Assert( pOther );
+	if ( !pOther->IsSolid() )
+		return;
+
+	// Apply forces to vehicles.
+	if ( pOther->GetServerVehicle() )
+	{
+		ApplyForcesToVehicle( pOther );
+	}
+
+	CPASFilter filter( GetAbsOrigin() );
+	te->Explosion( filter, 0.0,	&GetAbsOrigin(), g_sModelIndexFireball, 2.0, 15, TE_EXPLFLAG_NONE, 100, m_flDamage );
+
+	// Use the owner's position as the reported position
+	Vector vecReported = vec3_origin;
+	if ( GetOwnerEntity() )
+	{
+		vecReported = GetOwnerEntity()->GetAbsOrigin();
+	}
+	RadiusDamage( CTakeDamageInfo( this, GetOwnerEntity(), vec3_origin, GetAbsOrigin(), GetDamage(), GetDamageType(), 0, &vecReported ), GetAbsOrigin(), GetDamageRadius(), CLASS_NONE, NULL );
+
+	UTIL_Remove( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::ApplyForcesToVehicle( CBaseEntity *pEntity )
+{
+	// Check team - don't apply forces to our own team's vehicles.
+	if ( pEntity->GetTeam() == GetTeam() )
+		return;
+
+	IServerVehicle *pVehicle = pEntity->GetServerVehicle();
+	if ( !pVehicle )
+		return;
+
+	IPhysicsObject *pPhysObject = pEntity->VPhysicsGetObject();
+	if ( pPhysObject )
+	{
+		//------------------------------------------------------------
+		// Rocket the vehicle in the direction of the incoming rocket.
+		//------------------------------------------------------------	
+		Vector vecForceDir = GetAbsVelocity();
+		vecForceDir.z = 0.0f;
+		VectorNormalize( vecForceDir );
+
+		float flForce = pPhysObject->GetMass();
+		flForce += ( 4.0f * 100.0f );				// Wheels
+		flForce *= weapon_grenade_rocket_force.GetFloat();
+
+		vecForceDir *= flForce;
+
+		pPhysObject->ApplyForceOffset( vecForceDir, GetAbsOrigin() );
+	}
+}
+
+#else
+// Client Only
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	// Only think when "rocketing."
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Spawn rocket effects!
+//-----------------------------------------------------------------------------
+void CWeaponGrenadeRocket::ClientThink( void )
+{
+	// Fire smoke puffs out the side
+	CSmartPtr<CSimpleEmitter> pSmokeEmitter = CSimpleEmitter::Create( "C_GrenadeRocket::Effect" );
+	pSmokeEmitter->SetSortOrigin( GetAbsOrigin() );
+	PMaterialHandle	hSphereMaterial = pSmokeEmitter->GetPMaterial( "particle/particle_noisesphere" );
+	int iSmokeClouds = random->RandomInt( 1,2 );
+	for ( int i = 0; i < iSmokeClouds; i++ )
+	{
+		SimpleParticle *pParticle = ( SimpleParticle* ) pSmokeEmitter->AddParticle( sizeof( SimpleParticle ), hSphereMaterial, GetAbsOrigin() );
+		if ( !pParticle )
+			return;
+
+		// Particle data.
+		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;
+	}
+}
+
+#endif
+
diff --git a/game/shared/tf2/weapon_grenade_rocket.h b/game/shared/tf2/weapon_grenade_rocket.h
new file mode 100644
index 0000000..32bdf8c
--- /dev/null
+++ b/game/shared/tf2/weapon_grenade_rocket.h
@@ -0,0 +1,82 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Rockets (Weapon)
+//
+//=============================================================================//
+
+#ifndef WEAPON_GRENADE_ROCKET_H
+#define WEAPON_GRENADE_ROCKET_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#if defined( CLIENT_DLL )
+// Client Only
+	#define CWeaponGrenadeRocket C_WeaponGrenadeRocket
+#else
+#include "iscorer.h"
+#endif
+
+class CWeaponGrenadeRocket: public CBaseAnimating
+#if !defined( CLIENT_DLL )
+, public IScorer
+#endif
+{
+	DECLARE_CLASS( CWeaponGrenadeRocket, CBaseAnimating );
+
+public:
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponGrenadeRocket();
+	~CWeaponGrenadeRocket();
+
+	void	Spawn( void );
+	void	SetRealOwner( CBasePlayer *pOwner ) { m_hOwner = pOwner; }
+	float	GetDamage( void ) { return m_flDamage; }
+	void	SetDamage( float flDamage ) { m_flDamage = flDamage; }
+	int		GetDamageType() const { return DMG_BLAST; }
+	float	GetDamageRadius( void ) { return m_flRadius; }
+	void	SetDamageRadius( float flRadius ) { m_flRadius = flRadius; }
+	void	SetMaxRange( float flRange );
+	void	RocketTouch( CBaseEntity *pOther );
+
+	static CWeaponGrenadeRocket *Create( const Vector &vecOrigin, const Vector &vecAngles, float flMaxRange, CBaseEntity *pRealOwner );
+
+#if !defined( CLIENT_DLL )
+// Server Only
+	void	Precache( void );
+
+	void	SetAnglesToMatchVelocity( void );
+	void	ExceededRangeThink( void );
+	void	TrackThink( void );
+	void	ApplyForcesToVehicle( CBaseEntity *pEntity );
+
+// IScorer
+public:
+	// Return the entity that should receive the score
+	virtual CBasePlayer *GetScorer( void );
+	// Return the entity that should get assistance credit
+	virtual CBasePlayer *GetAssistant( void ) { return NULL; };
+
+#else
+// Client Only
+	void	OnDataChanged( DataUpdateType_t updateType );
+	void	ClientThink( void );
+#endif
+
+private:
+
+	CWeaponGrenadeRocket( const CWeaponGrenadeRocket& );
+
+private:
+	float			m_flDamage;
+	float			m_flRadius;
+	float			m_flMaxRange;
+	float			m_flFallingSpeed;
+	float			m_flExceedRangeTime;
+	EHANDLE			m_hOwner;
+};
+
+#endif // WEAPON_GRENADE_ROCKET_H
diff --git a/game/shared/tf2/weapon_harpoon.cpp b/game/shared/tf2/weapon_harpoon.cpp
new file mode 100644
index 0000000..d5da872
--- /dev/null
+++ b/game/shared/tf2/weapon_harpoon.cpp
@@ -0,0 +1,735 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:	Harpoon
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "basetfcombatweapon_shared.h"
+#include "in_buttons.h"
+#include "engine/IEngineSound.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponHarpoon C_WeaponHarpoon
+#endif
+
+class CHarpoon; 
+
+// Fist defines
+#define	FIST_RANGE			90
+
+#if !defined( CLIENT_DLL )
+
+ConVar	weapon_harpoon_damage( "weapon_harpoon_damage","40", FCVAR_NONE, "Harpoon impale damage" );
+ConVar	weapon_fist_damage( "weapon_fist_damage","50", FCVAR_NONE, "Fist damage to everything other than objects" );
+ConVar	weapon_fist_damage_objects( "weapon_fist_damage_objects","150", FCVAR_NONE, "Fist damage to objects" );
+
+#include "rope.h"
+#include "rope_shared.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Harpoon thrown by the harpoon weapon
+//-----------------------------------------------------------------------------
+class CHarpoon : public CBaseAnimating
+{
+	DECLARE_CLASS( CHarpoon, CBaseAnimating );
+public:
+	DECLARE_DATADESC();
+	DECLARE_SERVERCLASS();
+
+	CHarpoon( void );
+	virtual void	Spawn( void );
+	virtual void	Precache( void );
+
+	void SetHarpoonAngles( void );
+	void FlyThink( void );
+	void ConstrainThink( void );
+	void HarpoonTouch( CBaseEntity *pOther );
+
+	static CHarpoon *Create( const Vector &vecOrigin, const Vector &vecForward, CBasePlayer *pOwner );
+	CRopeKeyframe	*GetRope( void ) { return m_hRope; }
+	void			SetRope( CRopeKeyframe *pRope ) { m_hRope = pRope; }
+	CBaseEntity		*GetImpaledTarget( void ) { return m_hImpaledTarget; }
+	void			SetLinkedHarpoon( CHarpoon *pLinkedHarpoon ) { m_hLinkedHarpoon = pLinkedHarpoon; }
+	void			CheckLinkedHarpoon( void );
+	void			ImpaleTarget( CBaseEntity *pOther );
+
+private:
+	// Impaling
+	CNetworkVector( m_vecOffset );
+	CNetworkQAngle( m_angOffset );
+	float		m_flConstrainLength;
+
+	CHandle< CRopeKeyframe >	m_hRope;
+	EHANDLE						m_hImpaledTarget;
+	CHandle< CHarpoon >			m_hLinkedHarpoon;
+};
+
+LINK_ENTITY_TO_CLASS( harpoon, CHarpoon );
+PRECACHE_REGISTER(harpoon);
+
+IMPLEMENT_SERVERCLASS_ST(CHarpoon, DT_Harpoon)
+	SendPropVector( SENDINFO(m_vecOffset), -1, SPROP_COORD ),
+	SendPropVector( SENDINFO(m_angOffset), -1, SPROP_COORD ),
+END_SEND_TABLE()
+
+BEGIN_DATADESC( CHarpoon )
+	// Function Pointers
+	DEFINE_FUNCTION( HarpoonTouch ),
+	DEFINE_FUNCTION( FlyThink ),
+	DEFINE_FUNCTION( ConstrainThink ),
+END_DATADESC()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHarpoon::CHarpoon( void )
+{
+	UseClientSideAnimation();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHarpoon::Spawn( void )
+{
+	Precache();
+
+	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );
+	SetSolid( SOLID_BBOX );
+	//m_flGravity = 1.0;
+	SetFriction( 0.75 );
+	SetModel( "models/weapons/w_harpoon.mdl" );
+	UTIL_SetSize(this, Vector( -4, -4, -4), Vector(4, 4, 4));
+	SetCollisionGroup( TFCOLLISION_GROUP_GRENADE );
+
+	SetTouch( HarpoonTouch );
+	SetThink( FlyThink );
+	SetNextThink( gpGlobals->curtime + 0.1f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHarpoon::Precache( void )
+{
+	PrecacheModel( "models/weapons/w_harpoon.mdl" );
+
+	PrecacheScriptSound( "Harpoon.Impact" );
+	PrecacheScriptSound( "Harpoon.Impale" );
+	PrecacheScriptSound( "Harpoon.HitFlesh" );
+	PrecacheScriptSound( "Harpoon.HitMetal" );
+	PrecacheScriptSound( "Harpoon.Yank" );
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHarpoon::SetHarpoonAngles( void )
+{
+	QAngle angles;
+	VectorAngles( GetAbsVelocity(), angles );
+	SetLocalAngles( angles );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHarpoon::HarpoonTouch( CBaseEntity *pOther )
+{
+	// If we've stuck something, freeze. Make sure we hit it along our velocity.
+	if ( pOther->GetCollisionGroup() != TFCOLLISION_GROUP_SHIELD )
+	{
+		// Perform the collision response...
+		const trace_t &tr = CBaseEntity::GetTouchTrace( );
+
+		Vector vecNewVelocity;
+		PhysicsClipVelocity (GetAbsVelocity(), tr.plane.normal, vecNewVelocity, 2.0 - GetFriction());
+		SetAbsVelocity( vecNewVelocity );
+	}
+	else
+	{
+		// Move away from the shield...
+		// Fling it out a little extra along the plane normal
+		Vector vecCenter;
+		AngleVectors( pOther->GetAbsAngles(), &vecCenter );
+
+		Vector vecNewVelocity;
+		VectorMultiply( vecCenter, 400.0f, vecNewVelocity );
+		SetAbsVelocity( vecNewVelocity );
+	}
+
+	if ( !pOther->IsBSPModel() && !pOther->GetBaseAnimating() )
+		return;
+
+	// At this point, it shouldn't affect player movement
+	SetCollisionGroup( COLLISION_GROUP_DEBRIS );
+
+	// Remove myself soon
+	SetThink( SUB_Remove );
+	SetNextThink( gpGlobals->curtime + 30.0 );
+
+	m_hImpaledTarget = pOther;
+
+	// Should I impale something?
+	if ( pOther->GetBaseAnimating() )
+	{
+		CheckLinkedHarpoon();
+
+		if ( pOther->GetMoveType() != MOVETYPE_NONE )
+		{
+			ImpaleTarget( pOther );
+			return;
+		}
+	}
+
+	CheckLinkedHarpoon();
+
+	EmitSound( "Harpoon.Impact" );
+
+	// Stop moving
+	SetMoveType( MOVETYPE_NONE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check to see if we've got a linked harpoon, and see if we should constrain something
+//-----------------------------------------------------------------------------
+void CHarpoon::CheckLinkedHarpoon( void )
+{
+	if ( m_hLinkedHarpoon )
+	{
+		CHarpoon *pPlayerHarpoon = NULL;
+		CHarpoon *pNonMovingHarpoon = NULL;
+
+		// Find out if either of us has impaled something
+		if ( GetImpaledTarget() && m_hLinkedHarpoon->GetImpaledTarget() )
+		{
+			// Only care about players for now. One of the targets must be a player.
+			CBaseTFPlayer *pPlayer = NULL;
+			CBaseEntity *pOtherTarget = NULL;
+			if ( GetImpaledTarget()->IsPlayer() )
+			{
+				pPlayer = (CBaseTFPlayer*)GetImpaledTarget();
+				pPlayerHarpoon = this;
+				pNonMovingHarpoon = m_hLinkedHarpoon;
+			}
+			else if ( m_hLinkedHarpoon->GetImpaledTarget()->IsPlayer() )
+			{
+				pPlayer = (CBaseTFPlayer*)m_hLinkedHarpoon->GetImpaledTarget();
+				pNonMovingHarpoon = this;
+				pPlayerHarpoon = m_hLinkedHarpoon;
+			}
+
+			// Found a player?
+			if ( pPlayer )
+			{
+				pOtherTarget = pNonMovingHarpoon->GetImpaledTarget();
+
+				// For now, we have to be linked to a non-moving target. Eventually we could support linked moving targets.
+				// pOtherTarget == NULL means the harpoon's buried in the world.
+				if ( pOtherTarget->IsBSPModel() || pOtherTarget->GetMoveType() == MOVETYPE_NONE )
+				{
+					// Add a little slack
+					m_flConstrainLength = ( m_hLinkedHarpoon->GetAbsOrigin() - GetAbsOrigin() ).Length() + 150;
+					pPlayer->ActivateMovementConstraint( NULL, pNonMovingHarpoon->GetAbsOrigin(), m_flConstrainLength, 150.0f, 0.1f );
+					// Square it for later checking
+					m_flConstrainLength *= m_flConstrainLength;
+
+					// Start checking the length
+					pPlayerHarpoon->m_flConstrainLength = m_flConstrainLength;
+					pPlayerHarpoon->SetThink( ConstrainThink );
+					pPlayerHarpoon->SetNextThink( gpGlobals->curtime + 0.1f );
+
+					// Make the rope taught, and prevent it resizing
+					if ( m_hRope )
+					{
+						m_hRope->m_RopeFlags &= ~ROPE_RESIZE;
+						m_hRope->RecalculateLength();
+					}
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHarpoon::ImpaleTarget( CBaseEntity *pOther )
+{
+	// Impale!
+	EmitSound( "Harpoon.Impale" );
+
+	// Calculate our impale offset
+	m_vecOffset = (pOther->GetAbsOrigin() - GetAbsOrigin());
+	m_angOffset = (pOther->GetAbsAngles() - GetAbsAngles());
+
+	FollowEntity( pOther );
+
+	// Do some damage to the target
+	if ( pOther->m_takedamage )
+	{
+		CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwnerEntity() );
+		if ( !pOwner )
+			return;
+
+		pOther->TakeDamage( CTakeDamageInfo( this, pOwner, weapon_harpoon_damage.GetFloat(), DMG_GENERIC ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CHarpoon::FlyThink( void )
+{
+	SetHarpoonAngles();
+
+	SetNextThink( gpGlobals->curtime + 0.1f );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check to see if our target has moved beyond our length
+//-----------------------------------------------------------------------------
+void CHarpoon::ConstrainThink( void )
+{
+	if ( !GetImpaledTarget() || !m_hLinkedHarpoon.Get() )
+		return;
+
+	// Moved too far away?
+	float flDistSq = m_hLinkedHarpoon->GetAbsOrigin().DistToSqr( GetImpaledTarget()->GetAbsOrigin() ); 
+	if ( flDistSq > m_flConstrainLength )
+	{
+		// Break the rope
+		if ( m_hRope )
+		{
+			m_hRope->DetachPoint(1);
+			m_hRope->DieAtNextRest();
+			m_hRope = NULL;
+		}
+
+		// If we're impaling a player, remove his movement constraint
+		if ( GetImpaledTarget()->IsPlayer() )
+		{
+			CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)GetImpaledTarget();
+			pPlayer->DeactivateMovementConstraint();
+		}
+
+		SetThink( NULL );
+	}
+	else
+	{
+		SetNextThink( gpGlobals->curtime + 0.1f );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHarpoon *CHarpoon::Create( const Vector &vecOrigin, const Vector &vecForward, CBasePlayer *pOwner )
+{
+	CHarpoon *pHarpoon = (CHarpoon*)CreateEntityByName("harpoon");
+
+	UTIL_SetOrigin( pHarpoon, vecOrigin );
+	pHarpoon->Spawn();
+	pHarpoon->ChangeTeam( pOwner->GetTeamNumber() );
+	pHarpoon->SetOwnerEntity( pOwner );
+	pHarpoon->SetAbsVelocity( vecForward );
+	pHarpoon->SetHarpoonAngles();
+
+	return pHarpoon;
+}
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponHarpoon : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponHarpoon, CBaseTFCombatWeapon );
+public:
+	CWeaponHarpoon();
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual void	SecondaryAttack( void );
+	virtual float	GetFireRate( void );
+	virtual void	ThrowGrenade( void );
+	virtual void	DetachRope( void );
+	virtual void	YankHarpoon( void );
+
+	// Custom grenade types
+	virtual CHarpoon *CreateHarpoon( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner );
+
+	/*
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+	*/
+
+public:
+	CNetworkVar( float, m_flStartedThrowAt );
+	float	m_flCantThrowUntil;
+	float	m_flSecondaryAttackAt;
+	bool	m_bActiveHarpoon;
+
+#if !defined( CLIENT_DLL )
+	CHandle< CRopeKeyframe >	m_hRope;
+	CHandle< CHarpoon >			m_hHarpoon;
+#endif
+
+private:														
+	CWeaponHarpoon( const CWeaponHarpoon & );
+};
+
+LINK_ENTITY_TO_CLASS( weapon_harpoon, CWeaponHarpoon );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponHarpoon, DT_WeaponHarpoon )
+
+BEGIN_NETWORK_TABLE( CWeaponHarpoon, DT_WeaponHarpoon )
+#if !defined( CLIENT_DLL )
+	SendPropTime( SENDINFO( m_flStartedThrowAt ) ),
+#else
+	RecvPropTime( RECVINFO( m_flStartedThrowAt ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponHarpoon  )
+
+	DEFINE_PRED_FIELD_TOL( m_flStartedThrowAt, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
+
+END_PREDICTION_DATA()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponHarpoon::CWeaponHarpoon( void )
+{
+	m_flStartedThrowAt = 0;
+	m_flCantThrowUntil = 0;
+	m_flSecondaryAttackAt = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponHarpoon::GetFireRate( void )
+{	
+	return 2.0; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponHarpoon::ItemPostFrame( void )
+{
+	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	// Look for button downs
+	if ( (pOwner->m_afButtonPressed & IN_ATTACK) && !m_flStartedThrowAt && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+	{
+		// If we don't have a harpoon, throw one out. Otherwise, yank it back.
+		if ( m_bActiveHarpoon )
+		{
+			YankHarpoon();
+		}
+		else
+		{
+			m_bActiveHarpoon = true;
+			m_flStartedThrowAt = gpGlobals->curtime;
+			PlayAttackAnimation( ACT_VM_PULLBACK );
+			m_flCantThrowUntil = gpGlobals->curtime + SequenceDuration();
+		}
+	}
+	else if ( m_flCantThrowUntil && m_bActiveHarpoon && !(pOwner->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime) && (m_flCantThrowUntil <= gpGlobals->curtime)  )
+	{
+		m_flNextPrimaryAttack = gpGlobals->curtime;
+		PrimaryAttack();
+		m_flStartedThrowAt = 0;
+		m_flCantThrowUntil = 0;
+	}
+	else if ( (pOwner->m_nButtons & IN_ATTACK2) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+	{
+		PlayAttackAnimation( ACT_VM_SECONDARYATTACK );
+		m_flSecondaryAttackAt = gpGlobals->curtime + SequenceDuration() * 0.3;
+		m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration();
+	}
+	else if ( m_flSecondaryAttackAt && m_flSecondaryAttackAt < gpGlobals->curtime )
+	{
+		SecondaryAttack();
+		m_flSecondaryAttackAt = 0;
+	}
+
+	//  No buttons down?
+	if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+	{
+		WeaponIdle( );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponHarpoon::PrimaryAttack( void )
+{
+	CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	if ( !ComputeEMPFireState() )
+		return;
+
+	ThrowGrenade();
+
+	// Setup for refire
+	m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+	CheckRemoveDisguise();
+
+	// If I'm now out of ammo, switch away
+	if ( !HasPrimaryAmmo() )
+	{
+		pPlayer->SelectLastItem();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponHarpoon::SecondaryAttack( void )
+{
+	CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	// Slap things in front of me
+	Vector vecForward;
+	Vector vecBox = Vector( FIST_RANGE,FIST_RANGE,FIST_RANGE * 1.5 ) * 0.5;
+	pPlayer->EyeVectors( &vecForward );
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecCenter = vecSrc + (FIST_RANGE * 0.5 * vecForward);
+
+#if !defined( CLIENT_DLL )
+	//NDebugOverlay::Box( vecCenter, -Vector(2,2,2), Vector(2,2,2), 255,0,0,20,2.0);
+	//NDebugOverlay::Box( vecCenter, -vecBox, vecBox, 255,255,255,20,2.0);
+
+	bool bHitMetal = false;
+	bool bHitPlayer = false;
+
+	CBaseEntity	*pList[100];
+	int count = UTIL_EntitiesInBox( pList, 100, vecSrc - vecBox, vecSrc + vecBox, FL_CLIENT|FL_NPC|FL_OBJECT );
+	for ( int i = 0; i < count; i++ )
+	{
+		CBaseEntity *pEntity = pList[i];
+		if ( !pEntity->m_takedamage )
+			continue;
+		if ( pEntity->InSameTeam( this ) )
+			continue;
+
+		//NDebugOverlay::EntityBounds( pEntity, 0,255,0,20,2.0);
+		if ( pEntity->IsPlayer() )
+		{
+			bHitPlayer = true;
+			CTakeDamageInfo info( this, pPlayer, weapon_fist_damage.GetFloat(), DMG_CLUB );
+			CalculateMeleeDamageForce( &info, (pEntity->GetAbsOrigin() - vecCenter), pEntity->GetAbsOrigin() );
+			pEntity->TakeDamage( info );
+		}
+		else if ( pEntity->Classify() == CLASS_MILITARY )
+		{
+			bHitMetal = true;
+			CTakeDamageInfo info( this, pPlayer, weapon_fist_damage_objects.GetFloat(), DMG_CLUB );
+			CalculateMeleeDamageForce( &info, (pEntity->GetAbsOrigin() - vecCenter), pEntity->GetAbsOrigin() );
+			pEntity->TakeDamage( info );
+		}
+		else
+		{
+			bHitMetal = true;
+			CTakeDamageInfo info( this, pPlayer, weapon_fist_damage.GetFloat(), DMG_CLUB );
+			CalculateMeleeDamageForce( &info, (pEntity->GetAbsOrigin() - vecCenter), pEntity->GetAbsOrigin() );
+			pEntity->TakeDamage( info );
+		}
+	}
+
+	// Play the right sound
+	if ( bHitPlayer )
+	{
+		EmitSound( "Harpoon.HitFlesh" );
+	}
+	else if ( bHitMetal )
+	{
+		EmitSound( "Harpoon.HitMetal" );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponHarpoon::ThrowGrenade( void )
+{
+	CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	BaseClass::WeaponSound(WPN_DOUBLE);
+
+	// Calculate launch velocity (3 seconds for max distance)
+	float flThrowTime = MIN( (gpGlobals->curtime - m_flStartedThrowAt), 3.0 );
+	float flSpeed = 1000 + (200 * flThrowTime);
+
+	PlayAttackAnimation( ACT_VM_PRIMARYATTACK );
+
+	// If the player's crouched, roll the grenade
+	if ( pPlayer->GetFlags() & FL_DUCKING )
+	{
+		// Launch the grenade
+		Vector vecForward;
+		QAngle vecAngles = pPlayer->EyeAngles();
+		// Throw it up just a tad
+		vecAngles.x = -1;
+		AngleVectors( vecAngles, &vecForward, NULL, NULL);
+		Vector vecOrigin;
+		VectorLerp( pPlayer->EyePosition(), pPlayer->GetAbsOrigin(), 0.25f, vecOrigin );
+		vecOrigin += (vecForward * 16);
+		vecForward = vecForward * flSpeed;
+		CreateHarpoon(vecOrigin, vecForward, pPlayer );
+	}
+	else
+	{
+		// Launch the grenade
+		Vector vecForward;
+		QAngle vecAngles = pPlayer->EyeAngles();
+		AngleVectors( vecAngles, &vecForward, NULL, NULL);
+		Vector vecOrigin = pPlayer->EyePosition();
+		vecOrigin += (vecForward * 16);
+		vecForward = vecForward * flSpeed;
+		CreateHarpoon(vecOrigin, vecForward, pPlayer );
+	}
+
+	pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Give the harpoon a yank
+//-----------------------------------------------------------------------------
+void CWeaponHarpoon::YankHarpoon( void )
+{
+	CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+#if !defined( CLIENT_DLL )
+	if ( m_bActiveHarpoon && m_hHarpoon.Get() )
+	{
+		// If the harpoon's impaled something, pull it towards me
+		CBaseEntity *pTarget = m_hHarpoon->GetImpaledTarget();
+		if ( pTarget )
+		{
+			if ( !pTarget->IsBSPModel() && pTarget->GetMoveType() != MOVETYPE_NONE )
+			{
+				// Bring him to me!
+				EmitSound( "Harpoon.Yank" );
+
+				// Get a yank vector, and raise it a little to get them off the ground if they're on it
+				Vector vecOverHere = ( pPlayer->GetAbsOrigin() - pTarget->GetAbsOrigin() );
+				VectorNormalize( vecOverHere );
+				if ( pTarget->GetFlags() & FL_ONGROUND )
+				{
+					pTarget->SetGroundEntity( NULL );
+					vecOverHere.z = 0.5;
+				}
+				pTarget->ApplyAbsVelocityImpulse( vecOverHere * 500 );
+
+				PlayAttackAnimation( ACT_VM_HAULBACK );
+			}
+		}
+		m_hHarpoon->SetThink( SUB_Remove );
+		m_hHarpoon->SetNextThink( gpGlobals->curtime + 5.0 );
+		m_hHarpoon = NULL;
+		m_bActiveHarpoon = false;
+	}
+
+	DetachRope();
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponHarpoon::DetachRope( void )
+{
+#if !defined( CLIENT_DLL )
+	if ( m_hRope )
+	{
+		m_hRope->DetachPoint(1);
+		m_hRope->DieAtNextRest();
+		m_hRope = NULL;
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHarpoon *CWeaponHarpoon::CreateHarpoon( const Vector &vecOrigin, const Vector &vecAngles, CBasePlayer *pOwner )
+{
+#if !defined( CLIENT_DLL )
+	CHarpoon *pHarpoon = CHarpoon::Create(vecOrigin, vecAngles, pOwner );
+	if ( pHarpoon )
+	{
+		// Create the rope on first throw. Otherwise attach our existing rope.
+		if ( !m_hRope )
+		{
+			CRopeKeyframe *pRope = CRopeKeyframe::Create( pHarpoon, pOwner, 0, 0 );
+			if ( pRope )
+			{
+				pRope->m_RopeLength = 1.0;
+				pRope->m_Slack = 50.0f;
+				pRope->m_Width = 2;
+				pRope->m_nSegments = ROPE_MAX_SEGMENTS;
+				pRope->m_RopeFlags |= ROPE_RESIZE | ROPE_COLLIDE;
+			}
+			m_hRope = pRope;
+			pHarpoon->SetRope( m_hRope );
+		}
+		else
+		{
+			m_hRope->SetEndPoint( pHarpoon, 0 );
+			pHarpoon->SetRope( m_hRope ); 
+			m_hRope = NULL;
+		}
+
+		// Do we already have a harpoon out?
+		CHarpoon *pOldHarpoon = m_hHarpoon;
+		m_hHarpoon = pHarpoon;
+
+		if ( pOldHarpoon )
+		{
+			pOldHarpoon->SetLinkedHarpoon( m_hHarpoon );
+			pHarpoon->SetLinkedHarpoon( pOldHarpoon );
+			m_hHarpoon = NULL;
+		}
+	}
+	return pHarpoon;
+#else
+	return NULL;
+#endif
+}
diff --git a/game/shared/tf2/weapon_infiltrator.cpp b/game/shared/tf2/weapon_infiltrator.cpp
new file mode 100644
index 0000000..86dd51b
--- /dev/null
+++ b/game/shared/tf2/weapon_infiltrator.cpp
@@ -0,0 +1,150 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:			The Infiltrator's Weapon
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "tf_player.h"
+#include "tf_defines.h"
+#include "in_buttons.h"
+#include "weapon_infiltrator.h"
+#include "gamerules.h"
+#include "ammodef.h"
+
+#define INFILTRATOR_STAB_RANGE 64.0f
+
+// Damage CVars
+ConVar	weapon_infiltrator_damage( "weapon_infiltrator_damage","0", FCVAR_NONE, "Infiltrator backstab damage" );
+ConVar	weapon_infiltrator_range( "weapon_infiltrator_range","0", FCVAR_NONE, "Infiltrator backstab range" );
+
+//=====================================================================================================
+// INFILTRATOR WEAPON
+//=====================================================================================================
+IMPLEMENT_SERVERCLASS_ST(CWeaponInfiltrator, DT_WeaponInfiltrator)
+END_SEND_TABLE()
+
+LINK_ENTITY_TO_CLASS( weapon_infiltrator, CWeaponInfiltrator );
+PRECACHE_WEAPON_REGISTER(weapon_infiltrator);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponInfiltrator::CWeaponInfiltrator( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponInfiltrator::Precache( void )
+{
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CWeaponInfiltrator::ComputeEMPFireState( void )
+{
+	if (IsOwnerEMPed())
+	{
+		// FIXME: Need a sound
+		//UTIL_EmitSound( pPlayer->pev, CHAN_WEAPON, g_pszEMPGatlingFizzle, 1.0, ATTN_NORM );
+		return false;
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponInfiltrator::Deploy( void )
+{
+	// Play a shing! sound
+	WeaponSound( SPECIAL1 );
+	return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponInfiltrator::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pTarget = GetAssassinationTarget();
+	if ( pTarget == NULL )
+		return;
+	
+	WeaponSound( SINGLE );
+	PlayAttackAnimation( ACT_VM_PRIMARYATTACK );
+	m_flNextPrimaryAttack = gpGlobals->curtime + SequenceDuration( m_nSequence ) * 0.5;
+
+	// Instant kill
+	pTarget->TakeDamage( CTakeDamageInfo( this, GetOwner(), 500.0f, DMG_SLASH ) );
+	// Gag until respawn
+	pTarget->SetGagged( true );
+
+	CheckRemoveDisguise();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Overloaded to handle the hold-down healing
+//-----------------------------------------------------------------------------
+void CWeaponInfiltrator::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// Stab 'em
+	if (( pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+	{
+		PrimaryAttack();
+	}
+
+	WeaponIdle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: See if there's an assassination target in front of the player.
+// Output : Returns true if a target's found.
+//-----------------------------------------------------------------------------
+CBaseTFPlayer *CWeaponInfiltrator::GetAssassinationTarget( void )
+{
+	if ( !ComputeEMPFireState() )
+		return NULL;
+
+	CBaseTFPlayer *pPlayer = static_cast< CBaseTFPlayer * >( GetOwner() );
+	if ( !pPlayer )
+		return NULL;
+
+	trace_t tr;
+	Vector vecForward;
+	pPlayer->EyeVectors( &vecForward );
+	Vector vecOrigin = pPlayer->EyePosition();
+	UTIL_TraceLine( vecOrigin, vecOrigin + INFILTRATOR_STAB_RANGE * vecForward, MASK_SHOT, pPlayer, GetCollisionGroup(), &tr );
+	if ( tr.fraction == 1.0f || !tr.m_pEnt )
+		return NULL;
+	CBaseEntity *pEntity = tr.m_pEnt;
+	if ( !pEntity || !pEntity->IsPlayer() )
+		return NULL;
+	if ( !pEntity->IsPlayer() )
+		return NULL;
+
+	// Don't target friendlies
+	if ( pEntity->InSameTeam( pPlayer ) )
+		return NULL;
+
+	// See if the player is facing the right direction
+	Vector fwd1, fwd2;
+	AngleVectors( pPlayer->GetAbsAngles(), &fwd1, NULL, NULL );
+	AngleVectors( pEntity->GetAbsAngles(), &fwd2, NULL, NULL );
+
+	float dot = fwd1.Dot( fwd2 );
+	if ( dot <= 0.0f )
+		return NULL;
+
+	return (CBaseTFPlayer*)pEntity;
+}
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_infiltrator.h b/game/shared/tf2/weapon_infiltrator.h
new file mode 100644
index 0000000..2dc7060
--- /dev/null
+++ b/game/shared/tf2/weapon_infiltrator.h
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_INFILTRATOR_H
+#define WEAPON_INFILTRATOR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_basecombatweapon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Infiltrator's weapon
+//-----------------------------------------------------------------------------
+class CWeaponInfiltrator : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponInfiltrator, CBaseTFCombatWeapon );
+public:
+	DECLARE_SERVERCLASS();
+
+	CWeaponInfiltrator();
+
+	virtual void	Precache( void );
+	virtual void	PrimaryAttack( void );
+	virtual bool	ComputeEMPFireState( void );
+	virtual bool	Deploy( void );
+	virtual void	ItemPostFrame( void );
+
+	CBaseTFPlayer	*GetAssassinationTarget( void );
+};
+
+#endif // WEAPON_INFILTRATOR_H
diff --git a/game/shared/tf2/weapon_laserdesignator.cpp b/game/shared/tf2/weapon_laserdesignator.cpp
new file mode 100644
index 0000000..4f9ef46
--- /dev/null
+++ b/game/shared/tf2/weapon_laserdesignator.cpp
@@ -0,0 +1,394 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "NPCEvent.h"
+#include "tf_basecombatweapon.h"
+#include "smoke_trail.h"
+#include "tf_player.h"
+#include "in_buttons.h"
+#include "tf_gamerules.h"
+#include "ammodef.h"
+#include "IEffects.h"
+#include "vstdlib/random.h"
+#include "effects.h"
+#include "baseviewmodel.h"
+#include "basegrenade_shared.h"
+#include "grenade_limpetmine.h"
+#include "tf_obj_sentrygun.h"
+#include "tf_obj_aerial_sentry_station.h"
+
+
+// Damage CVars
+ConVar	weapon_laserdesignator_range( "weapon_laserdesignator_range","1024", FCVAR_NONE, "Laser Designator maximum range" );
+
+// ------------------------------------------------------------------------ //
+// CWeaponLaserDesignator
+// ------------------------------------------------------------------------ //
+class CWeaponLaserDesignator : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponLaserDesignator, CBaseTFCombatWeapon );
+public:	
+	virtual void	Precache( void );
+	virtual float	GetFireRate( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	virtual bool	ComputeEMPFireState( void );
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+
+	bool	ValidDesignationTarget( CBaseEntity *pEntity );
+	bool	TargetIsInLock( CBaseTFPlayer *pPlayer, CBaseEntity *pTarget, float *flMaxDot );
+
+	// Designation
+	void	StartDesignating( void );
+	void	StopDesignating( void );
+	void	UpdateBeam( void );
+	void	DesignateSentriesToAttack( CBaseEntity *pEntity );
+
+public:
+	// Designation
+	bool	m_bDesignating;
+
+	// Beam
+	CBeam	*m_pBeam;
+};
+
+LINK_ENTITY_TO_CLASS( weapon_laserdesignator, CWeaponLaserDesignator );
+PRECACHE_WEAPON_REGISTER(weapon_laserdesignator);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLaserDesignator::Precache( void )
+{
+	BaseClass::Precache();
+	PrecacheModel( "sprites/laserbeam.vmt" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponLaserDesignator::GetFireRate()
+{
+	return 0.2;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop thinking and holster
+//-----------------------------------------------------------------------------
+bool CWeaponLaserDesignator::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	StopDesignating();
+	return BaseClass::Holster(pSwitchingTo);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CWeaponLaserDesignator::ComputeEMPFireState( void )
+{
+	if (IsOwnerEMPed())
+	{
+		// FIXME: Need a sound
+		//UTIL_EmitSound( pPlayer->pev, CHAN_WEAPON, g_pszEMPGatlingFizzle, 1.0, ATTN_NORM );
+		return false;
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLaserDesignator::ItemPostFrame( void )
+{
+	CBasePlayer *pPlayer = GetOwner();
+	if (pPlayer == NULL)
+		return;
+
+	// Are we already welding?
+	if ( m_bDesignating )
+	{
+		if ( pPlayer->m_nButtons & (IN_ATTACK | IN_ATTACK2) )
+		{
+			UpdateBeam();
+		}
+		else
+		{
+			StopDesignating();
+		}
+	}
+	else
+	{
+		if ( (pPlayer->m_nButtons & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+		{
+			// Start designating
+			PrimaryAttack();
+			UpdateBeam();
+		}
+	}
+
+	// Always idle
+	WeaponIdle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start designating with the laser
+//-----------------------------------------------------------------------------
+void CWeaponLaserDesignator::StartDesignating( void )
+{
+	m_bDesignating = true;
+
+	if ( !m_pBeam )
+	{
+		CBaseTFPlayer *pPlayer = ToBaseTFPlayer( m_hOwner );
+		if ( !pPlayer )
+			return;
+		int iIndex = pPlayer->entindex();
+
+		m_pBeam = CBeam::BeamCreate( "sprites/laserbeam.vmt", 1 );
+		m_pBeam->PointEntInit( vec3_origin, iIndex );
+		m_pBeam->SetEndAttachment( 1 );
+		m_pBeam->SetColor( 255, 32, 32 );
+		m_pBeam->SetBrightness( 255 );
+		m_pBeam->SetNoise( 0 );
+		m_pBeam->SetWidth( 2 );
+		m_pBeam->SetEndWidth( 1 );
+		m_pBeam->SetStartEntity( ENTINDEX(m_hOwner->edict()) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop designating with the laser
+//-----------------------------------------------------------------------------
+void CWeaponLaserDesignator::StopDesignating( void )
+{
+	m_bDesignating = false;
+	if ( m_pBeam )
+	{
+		UTIL_Remove( m_pBeam );
+		m_pBeam = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLaserDesignator::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( m_hOwner );
+	if ( !pPlayer )
+		return;
+	
+	if ( !ComputeEMPFireState() )
+		return;
+
+	WeaponSound(SINGLE);
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+	pPlayer->AddEffects( EF_MUZZLEFLASH );
+
+	StartDesignating();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update the beam position and do designator functions
+//-----------------------------------------------------------------------------
+void CWeaponLaserDesignator::UpdateBeam( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( m_hOwner );
+	if ( !pPlayer )
+		return;
+
+	ASSERT( m_pBeam );
+
+	// "Fire" the designator beam
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( pPlayer->GetOrigin() );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+	Vector vecEnd = vecSrc + vecAiming * weapon_laserdesignator_range.GetFloat();
+
+	trace_t tr;
+	TFGameRules()->WeaponTraceLine(vecSrc, vecEnd, MASK_SHOT, pPlayer, DMG_ENERGYBEAM, &tr);
+
+	// Update beam visual
+	m_pBeam->SetStartPos( tr.endpos );
+	m_pBeam->RelinkBeam();
+
+	// Perform designator functions
+	// Did we hit something?
+	CBaseEntity *pEntity = CBaseEntity::Instance( tr.u.ent );
+	if ( pEntity )
+	{
+		// TODO: We dynamic_cast the entity we choose twice. Fix it.
+
+		// If we hit a target we don't care about, try and grab the nearest valid target to our crosshair
+		if ( !ValidDesignationTarget( pEntity ) )
+		{
+			pEntity = NULL;
+
+			// Grab the entity nearest the crosshair
+			float bestdot = AUTOAIM_20DEGREES;
+			float flSize = weapon_laserdesignator_range.GetFloat() * 0.5;
+			Vector vecCenter = vecSrc + vecAiming * flSize;
+
+			// Find a target.
+			CBaseEntity *pList[100];
+			Vector delta( flSize, flSize, flSize );
+			int count = UTIL_EntitiesInBox( pList, 100, vecCenter - delta, vecCenter + delta, FL_CLIENT|FL_NPC|FL_OBJECT );
+			for ( int i = 0; i < count; i++ )
+			{
+				CBaseEntity *pTarget = pList[i];
+				if ( !ValidDesignationTarget(pTarget) )
+					continue;
+				if ( TargetIsInLock( pPlayer, pTarget, &bestdot ) == false )
+					continue;
+				if ( (pTarget->Center() - pPlayer->Center() ).Length() > weapon_laserdesignator_range.GetFloat() )
+					continue;
+
+				// Can shoot at this one
+				pEntity = pTarget;
+			}
+		}
+
+		// Couldn't find anything
+		if ( !pEntity )
+			return;
+
+		// If we hit a player, and it's an enemy, tell my sentryguns to attack it
+		if ( pEntity->IsPlayer() && !pPlayer->InSameTeam(pEntity) )
+		{
+			DesignateSentriesToAttack( pEntity );
+		}
+		else if ( pEntity->GetFlags() & FL_NPC )
+		{
+			// If it's an enemy NPC, tell my sentryguns to attack it
+			if ( !pPlayer->InSameTeam( pEntity ) )
+			{
+				DesignateSentriesToAttack( pEntity );
+			}
+		}
+		else
+		{
+			// Is it a sentrygun? If so, tell it to toggle it's sunken state.
+			if ( pEntity->Classify() == CLASS_MILITARY )
+			{
+				CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun *>(pEntity);
+				if ( pSentry && pSentry->GetBuilder() == pPlayer )
+				{
+					pSentry->ToggleTurtle();
+				}
+				else 
+				{
+					// If it's an enemy object, tell my sentryguns to attack it
+					if ( !pPlayer->InSameTeam( pEntity ) )
+					{
+						DesignateSentriesToAttack( pEntity );
+					}
+				}
+			}
+
+			// Is it a limpet mine? If so, detonate it
+			CLimpetMine *pLimpet = dynamic_cast<CLimpetMine *>(pEntity);
+			if ( pLimpet && pLimpet->IsLive() && pLimpet->m_hOwner->pev == pPlayer->pev )
+			{
+				pLimpet->Use( pPlayer, pPlayer, USE_ON, 0 );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the specified entity is a valid one for designation
+//-----------------------------------------------------------------------------
+bool CWeaponLaserDesignator::ValidDesignationTarget( CBaseEntity *pEntity )
+{
+	// Ignore the world
+	if ( pEntity->entindex() == 0 )
+		return false;
+
+	// Ignore players on my team
+	if ( pEntity->IsPlayer() && pEntity->InSameTeam(m_hOwner) )
+		return false;
+
+	// Is it a sentrygun? If so, tell it to toggle it's sunken state.
+	if ( pEntity->Classify() == CLASS_MILITARY )
+		return true;
+
+	// My limpet mines are valid
+	CLimpetMine *pLimpet = dynamic_cast<CLimpetMine *>(pEntity);
+	if ( pLimpet && pLimpet->IsLive() && pLimpet->m_hOwner->pev == m_hOwner->pev )
+		return true;
+
+	// NPCs are valid
+	if ( pEntity->GetFlags() & FL_NPC )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the target entity's close enough to the player's crosshair to lock onto
+//-----------------------------------------------------------------------------
+bool CWeaponLaserDesignator::TargetIsInLock( CBaseTFPlayer *pPlayer, CBaseEntity *pTarget, float *flMaxDot )
+{
+	Vector	center = pTarget->Center();
+	Vector	dir = center - pPlayer->Center();
+	float	length = VectorNormalize( dir );
+	Vector forward, right, up;
+	pPlayer->EyeVectors( &forward, &right, &up );
+
+	// Make sure it's in front of the player
+	if ( DotProduct( dir, forward ) < 0.0f )
+		return false;
+
+	float dot = fabs( DotProduct(dir, right ) ) + fabs( DotProduct(dir, up ) );
+
+	// Tweak for distance
+	dot *= 1.0f + 4.0f * ( length / MAX_COORD_RANGE );
+
+	// Outside the dot?
+	if ( dot > *flMaxDot )
+		return false;
+
+	// Open LOS?
+	trace_t tr;
+	UTIL_TraceLine( pPlayer->Center(), center, MASK_SHOT, edict(), COLLISION_GROUP_NONE, &tr );
+	if ( ( tr.fraction != 1.0f ) && ( tr.u.ent != pTarget->edict() ) )
+		return false;
+
+	*flMaxDot = dot;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the player's sentryguns to all attack the specified target
+//-----------------------------------------------------------------------------
+void CWeaponLaserDesignator::DesignateSentriesToAttack( CBaseEntity *pEntity )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( m_hOwner );
+	if ( !pPlayer )
+		return;
+
+	// Tell all this player's sentryguns
+	for ( int i = 0; i < pPlayer->m_aObjects.Size(); i++ )
+	{
+		CBaseObject *pObj = pPlayer->m_aObjects[i];
+		if ( !pObj )
+			continue;
+
+		if ( pObj->IsSentrygun() )
+		{
+			CObjectSentrygun *pSentry = static_cast<CObjectSentrygun *>(pObj);
+			pSentry->DesignateTarget( pEntity );
+		}
+
+		if ( pObj->GetType() == OBJ_AERIAL_SENTRY_STATION )
+		{
+			CObjectAerialSentryStation *pSentryStation = static_cast<CObjectAerialSentryStation *>(pObj);
+			pSentryStation->DesignateTarget( pEntity );
+		}
+	}
+}
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_laserrifle.cpp b/game/shared/tf2/weapon_laserrifle.cpp
new file mode 100644
index 0000000..04a4d5f
--- /dev/null
+++ b/game/shared/tf2/weapon_laserrifle.cpp
@@ -0,0 +1,160 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Medic's Laser rifle
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "NPCEvent.h"
+#include "tf_basecombatweapon.h"
+#include "basecombatcharacter.h"
+#include "smoke_trail.h"
+#include "tf_player.h"
+#include "in_buttons.h"
+#include "tf_gamerules.h"
+#include "ammodef.h"
+#include "IEffects.h"
+#include "vstdlib/random.h"
+
+// Damage CVars
+ConVar	weapon_laserrifle_damage( "weapon_laserrifle_damage","0", FCVAR_NONE, "Laser Rifle maximum damage" );
+ConVar	weapon_laserrifle_range( "weapon_laserrifle_range","0", FCVAR_NONE, "Laser Rifle maximum range" );
+
+// ------------------------------------------------------------------------ //
+// CWeaponLaserRifle
+// ------------------------------------------------------------------------ //
+class CWeaponLaserRifle : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponLaserRifle, CBaseTFCombatWeapon );
+public:	
+	virtual void	Precache( void );
+	virtual float	GetFireRate( void );
+	virtual void	PrimaryAttack( void );
+	virtual bool	ComputeEMPFireState( void );
+	
+	// Beam
+	int		m_iSpriteTexture;
+};
+
+LINK_ENTITY_TO_CLASS( weapon_laserrifle, CWeaponLaserRifle );
+PRECACHE_WEAPON_REGISTER(weapon_laserrifle);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLaserRifle::Precache( void )
+{
+	BaseClass::Precache();
+
+	m_iSpriteTexture = PrecacheModel( "sprites/physbeam.vmt" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponLaserRifle::GetFireRate()
+{
+	return 0.2;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CWeaponLaserRifle::ComputeEMPFireState( void )
+{
+	if (IsOwnerEMPed())
+	{
+		// FIXME: Need a sound
+		//UTIL_EmitSound( pPlayer->pev, CHAN_WEAPON, g_pszEMPGatlingFizzle, 1.0, ATTN_NORM );
+		return false;
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLaserRifle::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( m_hOwner );
+	if ( !pPlayer )
+		return;
+	
+	if ( !ComputeEMPFireState() )
+		return;
+
+	WeaponSound(SINGLE);
+
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	pPlayer->AddEffects( EF_MUZZLEFLASH );
+
+	// Fire the beam: BLOW OFF AUTOAIM
+	Vector vecSrc	 = pPlayer->Weapon_ShootPosition( pPlayer->GetOrigin() );
+	Vector vecAiming, right, up;
+	pPlayer->EyeVectors( &vecAiming, &right, &up);
+
+	Vector vecSpread = VECTOR_CONE_4DEGREES;
+
+	// Get endpoint
+	float x, y, z;
+	do {
+		x = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5);
+		y = random->RandomFloat(-0.5,0.5) + random->RandomFloat(-0.5,0.5);
+		z = x*x+y*y;
+	} while (z > 1);
+	Vector vecDir = vecAiming + x * vecSpread.x * right + y * vecSpread.y * up;
+	Vector vecEnd = vecSrc + vecDir * weapon_laserrifle_range.GetFloat();
+
+	trace_t tr;
+	float damagefactor = TFGameRules()->WeaponTraceLine(vecSrc, vecEnd, MASK_SHOT, pPlayer, DMG_ENERGYBEAM, &tr);
+
+	// Hit target?
+	if (tr.fraction != 1.0)
+	{
+		CBaseEntity *pEntity = CBaseEntity::Instance(tr.u.ent);
+		if ( pEntity )
+		{
+			ClearMultiDamage();
+			float flDamage = GetDamage( (tr.endpos - vecSrc).Length(), tr.hitgroup );
+			flDamage *= damagefactor;  
+			pEntity->TraceAttack( CTakeDamageInfo( pPlayer, pPlayer, flDamage, DMG_ENERGYBEAM ), vecDir, &tr );
+			ApplyMultiDamage( pPlayer, pPlayer );
+		}
+
+		g_pEffects->EnergySplash( tr.endpos, tr.plane.normal );
+	}
+
+	// Get hacked gun position
+	AngleVectors( pPlayer->EyeAngles() + pPlayer->m_Local.m_vecPunchAngle, NULL, &right, NULL );
+	Vector vecTracerSrc = vecSrc + Vector (0,0,-8) + right * 12 + vecDir * 16;
+
+	// Laser beam
+	CBroadcastRecipientFilter filter;
+	te->BeamPoints( filter, 0.0,
+					&vecTracerSrc, 
+					&tr.endpos, 
+					m_iSpriteTexture, 
+					0,		// Halo index
+					0,		// Start frame
+					0,		// Frame rate
+					0.2,	// Life
+					15,		// Width
+					15,		// EndWidth
+					0,		// FadeLength
+					0,		// Amplitude
+					200,	// r
+					200,	// g
+					255,	// b
+					255,	// a
+					255	);	// speed
+
+	pPlayer->m_iAmmo[m_iPrimaryAmmoType]--;
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+
+	CheckRemoveDisguise();
+}
diff --git a/game/shared/tf2/weapon_limpetmine.cpp b/game/shared/tf2/weapon_limpetmine.cpp
new file mode 100644
index 0000000..e85f2b2
--- /dev/null
+++ b/game/shared/tf2/weapon_limpetmine.cpp
@@ -0,0 +1,688 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "in_buttons.h"
+#include "tf_shareddefs.h"
+#include "basegrenade_shared.h"
+#include "basetfcombatweapon_shared.h"
+#include "weapon_limpetmine.h"
+#include "IEffects.h"
+#include "engine/IEngineSound.h"
+#include "weapon_grenade_rocket.h"
+#include "beam_shared.h"
+#include "tf_gamerules.h"
+
+#if defined( CLIENT_DLL )
+#else
+#include "grenade_limpetmine.h"
+#include "tf_obj_sentrygun.h"
+#include "ai_network.h"
+#include "tf_team.h"
+#endif
+
+// Damage CVars
+ConVar	weapon_laserdesignator_range( "weapon_laserdesignator_range","2048", FCVAR_REPLICATED, "Laser Designator maximum range" );
+ConVar	weapon_limpetmine_max_deployed( "weapon_limpetmine_max_deployed","0", FCVAR_REPLICATED, "Maximum number of Limpet Mines that can be deployed at a single time" );
+ConVar	weapon_limpetmine_max_distance_off_trace( "weapon_limpetmine_max_distance_off_trace","25", FCVAR_REPLICATED, "Maximum distance off of the trace that a limpet can be." );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponLimpetmine, DT_WeaponLimpetmine )
+
+BEGIN_NETWORK_TABLE( CWeaponLimpetmine, DT_WeaponLimpetmine )
+#if !defined( CLIENT_DLL )
+	SendPropInt( SENDINFO( m_iDeployedLimpets ), 5, SPROP_UNSIGNED ),
+	SendPropEHandle( SENDINFO( m_hDesignatedEntity ) ),
+#else
+	RecvPropInt( RECVINFO( m_iDeployedLimpets ) ),
+	RecvPropEHandle( RECVINFO(m_hDesignatedEntity) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponLimpetmine  )
+
+	DEFINE_PRED_FIELD( m_iDeployedLimpets, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_hDesignatedEntity, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_limpetmine, CWeaponLimpetmine );
+PRECACHE_WEAPON_REGISTER(weapon_limpetmine);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponLimpetmine::CWeaponLimpetmine( void )
+{
+	SetPredictionEligible( true );
+
+	m_hDesignatedEntity = NULL;
+	m_flNextBuzzTime = 0;
+	m_iDeployedLimpets = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::Precache( void )
+{
+	BaseClass::Precache();
+
+#ifndef CLIENT_DLL
+	UTIL_PrecacheOther( "grenade_limpetmine" );
+#endif
+
+	PrecacheScriptSound( "WeaponLimpetmine.Deny" );
+
+	PrecacheModel( "sprites/laserbeam.vmt" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::UpdateOnRemove( void )
+{
+#ifndef CLIENT_DLL
+	RemoveDeployedLimpets();
+
+	if ( m_hLaserDesignation )
+	{
+		UTIL_Remove( m_hLaserDesignation );
+	}
+#endif
+
+	// Chain at end to mimic destructor unwind order
+	BaseClass::UpdateOnRemove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::CleanupOnActStart( void )
+{
+#ifndef CLIENT_DLL
+	RemoveDeployedLimpets();
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponLimpetmine::GetFireRate( void )
+{	
+	return 0.5; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Limpetmine considers itself as having ammo at all times, because it contains the designator
+//-----------------------------------------------------------------------------
+bool CWeaponLimpetmine::HasAnyAmmo( void )
+{
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop thinking and holster
+//-----------------------------------------------------------------------------
+bool CWeaponLimpetmine::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	StopDesignating();
+	return BaseClass::Holster(pSwitchingTo);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::ItemPostFrame( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+#ifndef CLIENT_DLL
+	// If we don't have a laser designator yet, create one
+	if ( !m_hLaserDesignation )
+	{
+		m_hLaserDesignation = CEnvLaserDesignation::Create( pPlayer ); 
+	}
+#endif
+
+	// Is the player trying to designate?
+	if ( pPlayer->m_nButtons & IN_ATTACK )
+	{
+		if ( m_bDesignating )
+		{
+#ifndef CLIENT_DLL
+			ActivateBeam();
+#endif
+		}
+		else if ( m_flNextPrimaryAttack <= gpGlobals->curtime )
+		{
+			StartDesignating();
+#ifndef CLIENT_DLL
+			ActivateBeam();
+#endif
+		}
+	}
+	else if ( m_bDesignating )
+	{
+		StopDesignating();
+	}
+	else if ( (pPlayer->m_nButtons & IN_ATTACK2) && !m_flStartedLaunchingAt && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+	{
+		m_flStartedLaunchingAt = gpGlobals->curtime;
+
+		SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+	}
+	else if ( (pPlayer->m_afButtonReleased & IN_ATTACK2) && (m_flNextPrimaryAttack <= gpGlobals->curtime) && m_flStartedLaunchingAt )
+	{
+		m_flNextPrimaryAttack = gpGlobals->curtime;
+		PrimaryAttack();
+		m_flStartedLaunchingAt = 0;
+	}
+
+	UpdateBeamTarget();
+
+	// Always idle
+	WeaponIdle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	// Don't allow anymore limpets to be placed if we've reached the max
+	if ( m_iDeployedLimpets >= weapon_limpetmine_max_deployed.GetInt() )
+	{
+#ifdef CLIENT_DLL
+		// We should flash the limpet mine count on the weapon at this point
+		CLocalPlayerFilter filter;
+		EmitSound( filter, entindex(), "WeaponLimpetmine.Deny" );
+		m_flNextBuzzTime = gpGlobals->curtime + 0.5f;	// only buzz every so often.
+#endif
+		return;
+	}
+
+	if ( IsOwnerEMPed() )
+		return;
+
+	trace_t tr;
+	// Get an aim vector. Don't use GetAimVector() because we don't want autoaiming.
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+
+	// Calculate launch velocity (3 seconds for max distance)
+	float flThrowTime = MIN( (gpGlobals->curtime - m_flStartedLaunchingAt), 3.0 );
+	float flSpeed = 600 + (300 * flThrowTime);
+	vecAiming *= flSpeed;
+
+	WeaponSound( WPN_DOUBLE );
+#ifndef CLIENT_DLL
+	ThrowLimpet( pPlayer, vecSrc, vecAiming );
+#endif
+	SendWeaponAnim( ACT_VM_SECONDARYATTACK );
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_flNextSecondaryAttack = gpGlobals->curtime + GetFireRate();
+
+	pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+}
+
+#if !defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::ThrowLimpet( CBasePlayer *pPlayer, Vector vecSrc, Vector vecAiming )
+{
+	CLimpetMine *pLimpet = CLimpetMine::Create(vecSrc, vecAiming, pPlayer);
+	pLimpet->SetLauncher( this );
+
+	// Increase the limpet count
+	m_iDeployedLimpets += 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Detonates all deployed limpets for this weapon
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::DetonateDeployedLimpets( void )
+{
+	CBaseEntity *pEntity = NULL;
+	while ((pEntity = gEntList.FindEntityByClassname( pEntity, "grenade_limpetmine" )) != NULL)
+	{
+		CLimpetMine* pLimpet = (CLimpetMine*)pEntity;
+		if ( pLimpet->IsLive() && pLimpet->GetThrower() == GetOwner() )
+		{
+			pLimpet->Use( GetOwner(), this, USE_ON, 0 );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Quietly removes all deployed limpets for this weapon
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::RemoveDeployedLimpets( void )
+{
+	CBaseEntity *pEntity = NULL;
+	while ((pEntity = gEntList.FindEntityByClassname( pEntity, "grenade_limpetmine" )) != NULL)
+	{
+		CLimpetMine* pLimpet = (CLimpetMine*)pEntity;
+		if ( pLimpet->GetThrower() == GetOwner() )
+		{
+			pLimpet->Use( GetOwner(), this, USE_SET, 0 );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::ActivateBeam( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	Assert( m_pBeam );
+	if( m_hDesignatedEntity != NULL )
+	{
+		CBaseEntity* pEntity = m_hDesignatedEntity.Get();
+
+		// If we hit a player, and it's an enemy, tell my sentryguns to attack it
+		if ( pEntity->IsPlayer() && !pPlayer->InSameTeam(pEntity) )
+		{
+			DesignateSentriesToAttack( pEntity );
+		}
+		else if ( pEntity->GetFlags() & FL_NPC )
+		{
+			// If it's an enemy NPC, tell my sentryguns to attack it
+			if ( !pPlayer->InSameTeam( pEntity ) )
+			{
+				DesignateSentriesToAttack( pEntity );
+			}
+		}
+		else
+		{
+			// Is it a sentrygun? If so, tell it to toggle it's sunken state.
+			if ( pEntity->Classify() == CLASS_MILITARY )
+			{
+				CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun *>(pEntity);
+				if ( pSentry && pSentry->GetBuilder() == pPlayer )
+				{
+					pSentry->ToggleTurtle();
+					return;
+				}
+				else 
+				{
+					// If it's an enemy object, tell my sentryguns to attack it
+					if ( !pPlayer->InSameTeam( pEntity ) )
+					{
+						DesignateSentriesToAttack( pEntity );
+						return;
+					}
+				}
+			}
+
+			// Is it a limpet mine? If so, detonate it
+			CLimpetMine *pLimpet = dynamic_cast<CLimpetMine *>(pEntity);
+			if ( pLimpet && pLimpet->IsLive() && pLimpet->GetThrower() == pPlayer )
+			{
+				pLimpet->Use( pPlayer, this, USE_ON, 0 );
+			}
+
+		}
+	} 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the specified entity is a valid one for designation
+//-----------------------------------------------------------------------------
+bool CWeaponLimpetmine::ValidDesignationTarget( CBaseEntity *pEntity )
+{
+	if( !pEntity )
+		return false;
+
+	// Ignore the world
+	if ((!pEntity) || ( pEntity->entindex() == 0 ))
+		return false;
+
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	Assert(pPlayer);
+	if(!pPlayer) 
+		return false;
+
+	// Ignore players on my team
+	if ( pEntity->IsPlayer() )
+	{
+		if( pEntity->InSameTeam(GetOwner()) )
+			return false;
+		else
+			return true;
+	}
+
+	// can either target my own sentry guns to turtle, or enemy buildings to target for sentries:
+	if ( pEntity->Classify() == CLASS_MILITARY )
+	{
+		// Is it a sentry gun I built?
+		if ( dynamic_cast<CObjectSentrygun *>(pEntity) && ((CObjectSentrygun*)pEntity)->GetBuilder() == pPlayer )
+		{
+			return true;
+		}
+		// Is it an enemy object?
+		else if ( !pPlayer->InSameTeam( pEntity ) )
+		{
+			return true;
+		}
+	}
+
+	// My limpet mines are valid
+	CLimpetMine *pLimpet = dynamic_cast<CLimpetMine *>(pEntity);
+	if ( pLimpet && pLimpet->IsLive() && pLimpet->GetThrower() == GetOwner() )
+		return true;
+
+	// NPCs are valid
+	if ( pEntity->GetFlags() & FL_NPC )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the player's sentryguns to all attack the specified target
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::DesignateSentriesToAttack( CBaseEntity *pEntity )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	// Tell all this player's sentryguns
+	for ( int i = 0; i < pPlayer->GetObjectCount(); i++ )
+	{
+		CBaseObject *pObj = pPlayer->GetObject(i);
+		if ( !pObj )
+			continue;
+
+		if ( pObj->IsSentrygun() )
+		{
+			CObjectSentrygun *pSentry = static_cast<CObjectSentrygun *>(pObj);
+			pSentry->DesignateTarget( pEntity );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseEntity* CWeaponLimpetmine::GetDesignatedEntity( CBaseTFPlayer *pPlayer )
+{
+	// Construct the start and end vectors.
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+	Vector vecEnd = vecSrc + vecAiming * weapon_laserdesignator_range.GetFloat();
+
+	float fBestDistanceSq = FLT_MAX;
+	CBaseEntity* pBestEntity = NULL;
+	float fMaxDist = weapon_limpetmine_max_distance_off_trace.GetFloat();
+	float fMaxDistSq = fMaxDist * fMaxDist;
+
+	// Check all limpets against a cylinder:
+	if( CLimpetMine::allLimpets )
+	{
+		for ( CLimpetMine *pLimpet = CLimpetMine::allLimpets ;pLimpet; pLimpet = pLimpet->nextLimpet)
+		{
+			// Find the closest limpet to the center of the cylinder:
+			if( pLimpet->IsLive() && pLimpet->GetThrower() != NULL && pLimpet->GetThrower() == pPlayer )
+			{
+				Vector vecNearestPoint = PointOnLineNearestPoint( vecSrc, vecEnd, pLimpet->GetAbsOrigin() );
+
+				float fDistSq = ( pLimpet->GetAbsOrigin() - vecNearestPoint ).LengthSqr();
+				
+				if (( fDistSq > fMaxDistSq ) || ( fDistSq >= fBestDistanceSq ))
+					continue;
+
+				if (TFGameRules()->IsBlockedByEnemyShields( vecSrc, pLimpet->GetAbsOrigin(), GetOwner()->GetTeamNumber() ))
+					continue;
+
+				pBestEntity = pLimpet;
+				fBestDistanceSq = fDistSq;
+			}
+		}
+
+		if( pBestEntity )
+			return pBestEntity;
+	}
+
+	// Check to see if we are designating a combat object:
+	for ( int i = 0; i < pPlayer->GetObjectCount(); i++ )
+	{
+		CBaseObject *pObj = pPlayer->GetObject(i);
+		if ( !pObj || !pObj->IsSentrygun() )
+			continue;
+
+		Vector vecObjCenter = pObj->WorldSpaceCenter();
+		Vector vecNearestPoint = PointOnLineNearestPoint( vecSrc, vecEnd, vecObjCenter );
+
+		float fDistSq = ( vecObjCenter - vecNearestPoint ).LengthSqr();
+		
+		if (( fDistSq > fMaxDistSq ) || ( fDistSq >= fBestDistanceSq ))
+			continue;
+
+		if (TFGameRules()->IsBlockedByEnemyShields( vecSrc, vecObjCenter, GetOwner()->GetTeamNumber() ))
+			continue;
+
+		pBestEntity = pObj;
+		fBestDistanceSq = fDistSq;
+	}
+
+	// Valid or NULL
+	return pBestEntity;
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::WeaponIdle( void )
+{
+	if ( HasWeaponIdleTimeElapsed() )
+	{
+		if ( m_bDesignating || m_flStartedLaunchingAt )
+		{
+			SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+		}
+		else
+		{
+			SendWeaponAnim( ACT_VM_IDLE );
+		}
+		SetWeaponIdleTime( gpGlobals->curtime + 0.2 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start designating with the laser
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::StartDesignating( void )
+{
+	m_bDesignating = true;
+
+	// Add myself to the designated target list
+	Vector vecOrigin(0,0,0);
+
+	SendWeaponAnim( ACT_VM_PRIMARYATTACK );
+
+#ifndef CLIENT_DLL
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	if ( !m_pBeam )
+	{
+		m_pBeam = CBeam::BeamCreate( "sprites/laserbeam.vmt", 5 );
+
+		m_pBeam->PointEntInit( vec3_origin, this );
+		m_pBeam->SetEndAttachment( 1 );
+		m_pBeam->SetColor( 255, 32, 32 );
+		m_pBeam->SetBrightness( 255 );
+		m_pBeam->SetNoise( 0 );
+		m_pBeam->SetWidth( 0.5 );
+		m_pBeam->SetEndWidth( 0.5 );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop designating with the laser
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::StopDesignating( void )
+{
+	SendWeaponAnim( ACT_VM_IDLE );
+
+	m_bDesignating = false;
+
+#ifndef CLIENT_DLL
+	if ( m_pBeam )
+	{
+		UTIL_Remove( m_pBeam );
+		m_pBeam = NULL;
+	}
+
+	if ( m_hLaserDesignation )
+	{
+		m_hLaserDesignation->SetActive( false );
+	}
+
+	// Remove any designated target:
+	m_hDesignatedEntity.Set( NULL );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update the beam position and do designator functions
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::UpdateBeamTarget()
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	// "Fire" the designator beam
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+	Vector vecEnd = vecSrc + vecAiming * weapon_laserdesignator_range.GetFloat();
+
+	trace_t tr;
+	TFGameRules()->WeaponTraceLine(vecSrc, vecEnd, MASK_SHOT, pPlayer, DMG_PROBE, &tr);
+
+	// Only update our designated target point if we hit something
+#ifndef CLIENT_DLL
+	if ( tr.fraction != 1.0 && m_bDesignating )
+	{
+		m_hLaserDesignation->SetActive( true );
+		m_hLaserDesignation->SetAbsOrigin( tr.endpos );
+	}
+	else
+	{
+		m_hLaserDesignation->SetActive( false );
+	}
+
+	// Update beam visual
+	if( m_pBeam )
+	{
+		m_pBeam->SetStartPos( tr.endpos );
+		m_pBeam->RelinkBeam();
+	}
+
+	CBaseEntity* pEntity= NULL;
+
+	// Perform designator functions
+	// Did we hit something?
+	//pEntity = CBaseEntity::Instance( tr.u.ent );
+
+	// If we hit a target we don't care about, try and grab the nearest valid target to our crosshair
+	//if ( !ValidDesignationTarget( pEntity ) )
+	{
+		// Get the designated entity, ignoring trace information:
+		pEntity = GetDesignatedEntity( pPlayer );
+		
+		if( !ValidDesignationTarget( pEntity ) )
+		{
+			m_hDesignatedEntity.Set( NULL );
+			return;
+		}
+	}
+
+	// We have a valid entity, light it up.
+	m_hDesignatedEntity.Set( pEntity );
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponLimpetmine::DecrementLimpets( void )
+{
+#ifndef CLIENT_DLL
+	if ( m_iDeployedLimpets )
+	{
+		m_iDeployedLimpets -= 1;
+	}
+#endif
+}
+
+#ifdef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: Limpet mine's always selectable, because the laser designator can always fire
+//-----------------------------------------------------------------------------
+bool C_WeaponLimpetmine::CanBeSelected( void )
+{
+	return true;
+}
+
+void C_WeaponLimpetmine::PreDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PreDataUpdate( updateType );
+
+	m_hOldDesignatedEntity = m_hDesignatedEntity;
+}
+
+void C_WeaponLimpetmine::PostDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PostDataUpdate( updateType );
+
+	if ( GetOwner() == C_BaseTFPlayer::GetLocalPlayer() )
+	{
+		// Old target isn't valid anymore, so reset it's render properties
+		if ( m_hOldDesignatedEntity.Get() && m_hOldDesignatedEntity != m_hDesignatedEntity )
+		{
+			m_hOldDesignatedEntity->m_nRenderFX = m_eDesignatedEntityOriginalRenderFx;
+			m_hOldDesignatedEntity->SetRenderMode( (RenderMode_t)m_eDesignatedEntityOriginalRenderMode );
+		}
+
+		// New target? Set it's render properties
+		if ( m_hDesignatedEntity != NULL && m_hOldDesignatedEntity != m_hDesignatedEntity )
+		{
+			// Store off original info for designated entity
+			m_eDesignatedEntityOriginalRenderFx		= m_hDesignatedEntity->m_nRenderFX;
+			m_eDesignatedEntityOriginalRenderMode	= m_hDesignatedEntity->GetRenderMode();
+
+			// Set up alpha blended pulsefast renderer
+			m_hDesignatedEntity->m_nRenderFX	= kRenderFxPulseFastWider;
+			m_hDesignatedEntity->SetRenderMode( kRenderTransAlpha );
+		}
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_limpetmine.h b/game/shared/tf2/weapon_limpetmine.h
new file mode 100644
index 0000000..3040e14
--- /dev/null
+++ b/game/shared/tf2/weapon_limpetmine.h
@@ -0,0 +1,109 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_LIMPETMINE_H
+#define WEAPON_LIMPETMINE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class CBeam;
+
+#if defined( CLIENT_DLL )
+#define CWeaponLimpetmine C_WeaponLimpetmine
+#else
+#include "env_laserdesignation.h"
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Combination limpet mine & laser designator weapon
+//-----------------------------------------------------------------------------
+class CWeaponLimpetmine : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponLimpetmine, CBaseTFCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponLimpetmine( void );
+
+	virtual void	UpdateOnRemove( void );
+
+	virtual void	Precache( void );
+	virtual float	GetFireRate( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual void	WeaponIdle( void );
+	virtual bool	HasAnyAmmo( void );
+	virtual void	CleanupOnActStart( void );
+
+	// Designation
+	void			StartDesignating( void );
+	void			StopDesignating( void );
+	void			UpdateBeamTarget( );
+
+	// Limpet counting
+	void			DecrementLimpets( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool	IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+// Server DLL only
+#if !defined( CLIENT_DLL )
+	void			DetonateDeployedLimpets( void );
+	void			RemoveDeployedLimpets( void );
+	void			ThrowLimpet( CBasePlayer *pPlayer, Vector vecSrc, Vector vecAiming );
+	void			ActivateBeam();
+	void			DesignateSentriesToAttack( CBaseEntity *pEntity );
+	bool			ValidDesignationTarget( CBaseEntity *pEntity );
+	CBaseEntity		*GetDesignatedEntity( CBaseTFPlayer *pPlayer );	// Visually highlight those limpets in player's view cone
+
+public:
+	CHandle<CEnvLaserDesignation>	m_hLaserDesignation;
+#endif
+
+// Client DLL only
+#if defined( CLIENT_DLL )
+public:
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	virtual bool CanBeSelected( void );
+	virtual void PreDataUpdate( DataUpdateType_t updateType );
+	virtual void PostDataUpdate( DataUpdateType_t updateType );
+#endif
+
+protected:
+	// Designation
+	bool		m_bDesignating;
+	CNetworkHandle( CBaseEntity, m_hDesignatedEntity );
+	EHANDLE		m_hOldDesignatedEntity;
+	int			m_eDesignatedEntityOriginalRenderFx;
+	int			m_eDesignatedEntityOriginalRenderMode;
+
+	// Beam
+	CBeam		*m_pBeam;
+
+	// Limpets
+	float		m_flStartedLaunchingAt;
+	CNetworkVar( int, m_iDeployedLimpets );
+	int			m_flNextBuzzTime;
+
+private:
+	CWeaponLimpetmine( const CWeaponLimpetmine & );
+};
+
+#endif // WEAPON_LIMPETMINE_H
diff --git a/game/shared/tf2/weapon_minigun.cpp b/game/shared/tf2/weapon_minigun.cpp
new file mode 100644
index 0000000..a8fcb3e
--- /dev/null
+++ b/game/shared/tf2/weapon_minigun.cpp
@@ -0,0 +1,415 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Minigun
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "in_buttons.h"
+#include "takedamageinfo.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include "tf_gamerules.h"
+
+// Damage CVars
+ConVar	weapon_minigun_damage( "weapon_minigun_damage","10", FCVAR_REPLICATED, "Minigun damage per pellet" );
+ConVar	weapon_minigun_range( "weapon_minigun_range","1500", FCVAR_REPLICATED, "Minigun maximum range" );
+ConVar	weapon_minigun_pellets( "weapon_minigun_pellets","2", FCVAR_REPLICATED, "Minigun pellets per fire" );
+ConVar	weapon_minigun_ducking_mod( "weapon_minigun_ducking_mod", "0.75", FCVAR_REPLICATED, "Minigun ducking speed modifier" );
+
+#if defined( CLIENT_DLL )
+#include "hud.h"
+#include "fx.h"
+#define CWeaponMinigun C_WeaponMinigun
+extern ConVar zoom_sensitivity_ratio;
+extern ConVar default_fov;
+#else
+#endif
+
+// Time taken to fully wind up/down
+#define MINIGUN_WIND_TIME		2
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponMinigun : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponMinigun, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS(); 
+	DECLARE_PREDICTABLE();
+
+	CWeaponMinigun( void );
+
+	virtual void	Precache();
+
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual const Vector& GetBulletSpread( void );
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual void	AddViewKick( void );
+	virtual float 	GetFireRate( void );
+	virtual float	GetDefaultAnimSpeed( void );
+	virtual void	BulletWasFired( const Vector &vecStart, const Vector &vecEnd );
+
+	// All predicted weapons need to implement and return true
+	virtual bool	IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+	void			ReduceRotation( void );
+	void			AttemptToReload( void );
+
+#if defined( CLIENT_DLL )
+public:
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() && 
+			GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	virtual bool	OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	ClientThink( void );
+#endif
+
+public:
+	float	m_flOwnersMaxSpeed;
+	CNetworkVar( float, m_flRotationSpeed );	// When 1, firing commences.
+	bool	m_bSoundPlaying;
+
+private:
+	CWeaponMinigun( const CWeaponMinigun & );
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponMinigun::CWeaponMinigun( void )
+{
+	SetPredictionEligible( true );
+	m_flRotationSpeed = 0;
+	m_bSoundPlaying = false;
+}
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMinigun, DT_WeaponMinigun )
+
+BEGIN_NETWORK_TABLE( CWeaponMinigun, DT_WeaponMinigun )
+#if !defined( CLIENT_DLL )
+	SendPropFloat( SENDINFO( m_flRotationSpeed ), 8, SPROP_ROUNDDOWN, 0, 1 ),
+#else
+	RecvPropFloat( RECVINFO( m_flRotationSpeed ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponMinigun )
+	DEFINE_PRED_FIELD_TOL( m_flRotationSpeed, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.01f ),
+END_PREDICTION_DATA()
+
+LINK_ENTITY_TO_CLASS( weapon_minigun, CWeaponMinigun );
+PRECACHE_WEAPON_REGISTER(weapon_minigun);
+
+void CWeaponMinigun::Precache()
+{
+	BaseClass::Precache();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponMinigun::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	m_flRotationSpeed = 0;
+	
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the accuracy derived from weapon and player, and return it
+//-----------------------------------------------------------------------------
+const Vector& CWeaponMinigun::GetBulletSpread( void )
+{
+	static Vector cone = VECTOR_CONE_8DEGREES;
+	return cone;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMinigun::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	// This should work, and avoids sending extra network data. If it doesn't, we'll have to send down the unchanged max speed.
+	if ( !m_flRotationSpeed )
+	{
+		m_flOwnersMaxSpeed = pOwner->MaxSpeed();
+	}
+
+	float flLastRotationSpeed = m_flRotationSpeed;
+
+	CheckReload();
+
+	// Handle firing
+	if ( (pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+	{
+		if ( m_iClip1 > 0 )
+		{
+			if ( m_flRotationSpeed < 0.99 )
+			{
+				// If we're starting, play the sound
+				m_flRotationSpeed = min(1, m_flRotationSpeed + (gpGlobals->frametime / MINIGUN_WIND_TIME) );
+			}
+			else
+			{
+				PrimaryAttack();
+			}
+		}
+		else
+		{
+			AttemptToReload();
+		}
+	}
+
+	// Reload button (or fire button when we're out of ammo)
+	if ( m_flNextPrimaryAttack <= gpGlobals->curtime ) 
+	{
+		if ( pOwner->m_nButtons & IN_RELOAD ) 
+		{
+			AttemptToReload();
+		}
+		else if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+		{
+			if ( !m_iClip1 && HasPrimaryAmmo() )
+			{
+				AttemptToReload();
+			}
+			else
+			{
+				ReduceRotation();
+			}
+		}
+	}
+
+	// If the speed changed, modify our movement speed
+	if ( m_flRotationSpeed != flLastRotationSpeed )
+	{
+		pOwner->SetMaxSpeed( m_flOwnersMaxSpeed * (1.0 - (m_flRotationSpeed * 0.5)) );
+	}
+
+	WeaponIdle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMinigun::ReduceRotation( void )
+{
+	if ( m_flRotationSpeed > 0 )
+	{
+		m_flRotationSpeed = MAX(0, m_flRotationSpeed - (gpGlobals->frametime / MINIGUN_WIND_TIME) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMinigun::AttemptToReload( void )
+{
+	// Wind down before reloading
+	if ( m_flRotationSpeed > 0 )
+	{
+		ReduceRotation();
+	}
+	else
+	{
+		Reload();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMinigun::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+	
+	// Fire the bullets
+	Vector vecSrc = pPlayer->Weapon_ShootPosition( );
+	Vector vecAiming;
+	pPlayer->EyeVectors( &vecAiming );
+
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	// Make a satisfying force, and knock them into the air
+	float flForceScale = (100) * 75 * 4;
+	Vector vecForce = vecAiming;
+	vecForce.z += 0.7;
+	vecForce *= flForceScale;
+	
+	CTakeDamageInfo info( this, pPlayer, vecForce, vec3_origin, weapon_minigun_damage.GetFloat(), DMG_BULLET | DMG_BUCKSHOT);
+	TFGameRules()->FireBullets( info, weapon_minigun_pellets.GetFloat(), 
+		vecSrc, vecAiming, GetBulletSpread(), weapon_minigun_range.GetFloat(), m_iPrimaryAmmoType, 0, entindex(), 0 );
+
+	AddViewKick();
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_iClip1 = m_iClip1 - 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMinigun::AddViewKick( void )
+{
+	// Get the view kick
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	QAngle viewPunch;
+	viewPunch.x = SHARED_RANDOMFLOAT( -0.5f, 0.5f );
+	viewPunch.y = SHARED_RANDOMFLOAT( -1.0f, 1.0f );
+	viewPunch.z = 0;
+
+	if ( pPlayer->GetFlags() & FL_DUCKING )
+	{
+		viewPunch *= 0.25;
+	}
+
+	pPlayer->ViewPunch( viewPunch );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponMinigun::GetFireRate( void )
+{	
+	float flFireRate = SHARED_RANDOMFLOAT( 0.05, 0.1 );
+
+	CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>( GetOwner() );
+	if ( pPlayer )
+	{
+		// Ducking players should fire more rapidly.
+		if ( pPlayer->GetFlags() & FL_DUCKING )
+		{
+			flFireRate *= weapon_minigun_ducking_mod.GetFloat();
+		}
+	}
+	
+	return flFireRate;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Match the anim speed to the weapon speed while crouching
+//-----------------------------------------------------------------------------
+float CWeaponMinigun::GetDefaultAnimSpeed( void )
+{
+	if ( GetOwner() && GetOwner()->IsPlayer() )
+	{
+		if ( GetOwner()->GetFlags() & FL_DUCKING )
+			return (1.0 + (1.0 - weapon_minigun_ducking_mod.GetFloat()) );
+	}
+
+	return 1.0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the minigun effect
+//-----------------------------------------------------------------------------
+void CWeaponMinigun::BulletWasFired( const Vector &vecStart, const Vector &vecEnd )
+{
+	UTIL_Tracer( (Vector&)vecStart, (Vector&)vecEnd, entindex(), 1, 5000, false, "MinigunTracer" );
+}
+
+#if defined ( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponMinigun::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
+{
+	// Suppress the shell ejection from the HL2 model we're using for prototyping
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : updateType - 
+//-----------------------------------------------------------------------------
+void CWeaponMinigun::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMinigun::ClientThink()
+{
+	CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
+	if (!pPlayer)
+		return;
+
+	if ( m_flRotationSpeed )
+	{
+		WeaponSound_t nSound = SPECIAL1;
+
+		// If we're firing, play that sound instead
+		if ( m_flRotationSpeed >= 0.99 )
+		{
+			nSound = SINGLE;
+		}
+		else
+		{
+			m_bSoundPlaying = true;
+		}
+
+		// If we have some sounds from the weapon classname.txt file, play a random one of them
+		const char *shootsound = GetShootSound( nSound );
+		if ( !shootsound || !shootsound[0] )
+			return; 
+
+		CSoundParameters params;
+		if ( !GetParametersForSound( shootsound, params, NULL ) )
+			return;
+
+		// Shift pitch according to barrel rotation
+		float flPitch = 30 + (90 * m_flRotationSpeed);
+
+		CPASAttenuationFilter filter( GetOwner(), params.soundlevel );
+		Vector vecOrigin = GetOwner()->GetAbsOrigin();
+		
+		EmitSound_t ep;
+		ep.m_nChannel = CHAN_WEAPON;
+		ep.m_pSoundName = shootsound;
+		ep.m_flVolume = params.volume;
+		ep.m_SoundLevel = params.soundlevel;
+		ep.m_nFlags = SND_CHANGE_PITCH;
+		ep.m_nPitch = (int)flPitch;
+		ep.m_pOrigin = &vecOrigin;
+
+
+		EmitSound( filter, GetOwner()->entindex(), ep ); 
+	}
+	else if ( m_bSoundPlaying )
+	{
+		m_bSoundPlaying = false;
+		StopWeaponSound( SPECIAL1 );
+		StopWeaponSound( SINGLE );
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_mortar.cpp b/game/shared/tf2/weapon_mortar.cpp
new file mode 100644
index 0000000..2fcd467
--- /dev/null
+++ b/game/shared/tf2/weapon_mortar.cpp
@@ -0,0 +1,367 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "tf_basecombatweapon.h"
+#include "tf_defines.h"
+#include "in_buttons.h"
+#include "gamerules.h"
+#include "ammodef.h"
+#include "tf_obj.h"
+#include "weapon_mortar.h"
+#include "smoke_trail.h"
+#include "tf_shareddefs.h"
+#include "tf_team.h"
+#include "tf_gamerules.h"
+#include "tf_obj_antimortar.h"
+#include "vstdlib/random.h"
+#include "engine/IEngineSound.h"
+
+extern short	g_sModelIndexFireball;
+
+// Damage CVars
+ConVar	weapon_mortar_shell_damage( "weapon_mortar_shell_damage","0", FCVAR_NONE, "Mortar's standard shell maximum damage" );
+ConVar	weapon_mortar_shell_radius( "weapon_mortar_shell_radius","0", FCVAR_NONE, "Mortar's standard shell splash radius" );
+ConVar	weapon_mortar_starburst_damage( "weapon_mortar_starburst_damage","0", FCVAR_NONE, "Mortar's starburst maximum damage" );
+ConVar	weapon_mortar_starburst_radius( "weapon_mortar_starburst_radius","0", FCVAR_NONE, "Mortar's starburst splash radius" );
+ConVar	weapon_mortar_cluster_shells( "weapon_mortar_cluster_shells","0", FCVAR_NONE, "Number of shells a mortar cluster round bursts into" );
+
+
+//=====================================================================================================
+// MORTAR WEAPON
+//=====================================================================================================
+LINK_ENTITY_TO_CLASS( weapon_mortar, CWeaponMortar );
+PRECACHE_WEAPON_REGISTER(weapon_mortar);
+
+EXTERN_SEND_TABLE(DT_BaseCombatWeapon)
+
+IMPLEMENT_SERVERCLASS_ST(CWeaponMortar, DT_WeaponMortar)
+	SendPropInt( SENDINFO( m_bCarried ), 2, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_bMortarReloading ), 2, SPROP_UNSIGNED ),
+	SendPropVector( SENDINFO(m_vecMortarOrigin), -1, SPROP_COORD ),
+	SendPropVector( SENDINFO(m_vecMortarAngles), -1, SPROP_COORD ),
+END_SEND_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponMortar::CWeaponMortar( void )
+{
+#ifdef _DEBUG
+	m_vecMortarOrigin.Init();
+	m_vecMortarAngles.Init();
+#endif
+
+	m_bCarried = true;
+	m_bMortarReloading = false;
+	m_hDeployedMortar = NULL;
+	m_bRangeUpgraded = false;
+	m_bAccuracyUpgraded = false;
+}
+
+void CWeaponMortar::Precache()
+{
+	BaseClass::Precache();
+
+	PrecacheScriptSound( "WeaponMortar.EMPed" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponMortar::GetFireRate( void )
+{	
+	return 3.0; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponMortar::Deploy( )
+{
+	return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_SLAM_TRIPMINE_DRAW, (char*)GetAnimPrefix() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::ItemPostFrame( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if (pPlayer == NULL)
+		return;
+
+	if ( pPlayer->m_nButtons & IN_ATTACK )
+	{
+		if ( m_bCarried )
+		{
+			ClientPrint( pPlayer, HUD_PRINTCENTER, "\n\n\n\n\n\n\n\n\n\nBuild your mortar with the build weapon first!" );
+		}
+	}
+	else if ( pPlayer->m_nButtons & IN_ATTACK2 )
+	{
+		SecondaryAttack();
+	}
+
+	// No buttons down.
+	if (!(( pPlayer->m_nButtons & IN_ATTACK ) || ( pPlayer->m_nButtons & IN_ATTACK2 )))
+	{
+		WeaponIdle();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CWeaponMortar::ComputeEMPFireState( void )
+{
+	if (IsOwnerEMPed())
+	{
+		CPASAttenuationFilter filter( GetOwner(), "WeaponMortar.EMPed" );
+		EmitSound( filter, GetOwner()->entindex(), "WeaponMortar.EMPed" );
+		return false;
+	}
+	return true;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+	// Can't attack if taking EMP damage
+	if ( !ComputeEMPFireState() )
+		return;
+	if ( IsOwnerEMPed() )
+		return;
+	if ( m_hDeployedMortar == NULL )
+		return;
+
+	if ( m_hDeployedMortar->FireMortar( m_flFiringPower, m_flFiringAccuracy, m_bRangeUpgraded, m_bAccuracyUpgraded ) )
+	{
+		WeaponSound( SINGLE );
+	}
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+
+	CheckRemoveDisguise();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::Fire( float flPower, float flAccuracy )
+{
+	m_flFiringPower = flPower;
+	m_flFiringAccuracy = flAccuracy;
+
+	PrimaryAttack();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::SecondaryAttack( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	// Setup for refire
+	m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
+	m_flNextSecondaryAttack = gpGlobals->curtime + 1.0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Player's finished deploying his mortar
+//-----------------------------------------------------------------------------
+void CWeaponMortar::DeployMortar( CObjectMortar *pMortar )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	ClientPrint( pPlayer, HUD_PRINTCENTER, "\n\n\n\n\n\n\n\n\n\nMortar Deployed" );
+
+	m_bCarried = false;
+	m_hDeployedMortar = pMortar;
+	m_hDeployedMortar->m_hMortarWeapon = this;
+	SendWeaponAnim( ACT_SLAM_DETONATOR_DRAW );
+
+	m_vecMortarOrigin = m_hDeployedMortar->GetLocalOrigin();
+	m_vecMortarAngles = m_hDeployedMortar->GetLocalAngles();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Mortar object has been removed
+//-----------------------------------------------------------------------------
+void CWeaponMortar::MortarObjectRemoved( void )
+{
+	m_hDeployedMortar = NULL;
+	m_bCarried = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::SetYaw( float flYaw )
+{
+	if ( m_hDeployedMortar == NULL )
+		return;
+
+	QAngle angles = m_hDeployedMortar->GetLocalAngles();
+	angles.y = flYaw;
+	m_hDeployedMortar->SetLocalAngles( angles );
+	m_vecMortarAngles = angles;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the deployed mortar's firing round
+//-----------------------------------------------------------------------------
+void CWeaponMortar::SetRoundType( int iRoundType )
+{
+	if ( m_hDeployedMortar == NULL )
+		return;
+
+	// Make sure we've got the technology for this round type
+	if ( MortarAmmoTechs[ iRoundType ] && MortarAmmoTechs[ iRoundType ][0] )
+	{
+		CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+		if ( !pPlayer )
+			return;
+		// Does the player have the technology?
+		if ( pPlayer->HasNamedTechnology( MortarAmmoTechs[ iRoundType ] ) == false )
+			return;
+	}
+
+	m_hDeployedMortar->m_iRoundType = iRoundType;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::MortarDestroyed( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		ClientPrint( pPlayer, HUD_PRINTCENTER, "\n\n\n\n\n\n\n\n\n\nMortar Destroyed!" );
+	}
+
+	if ( pPlayer && pPlayer->GetActiveWeapon() == this )
+	{
+		SendWeaponAnim( ACT_SLAM_TRIPMINE_DRAW );
+	}
+
+	MortarObjectRemoved();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pObject - 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::AddAssociatedObject( CBaseObject *pObject )
+{
+	Assert( pObject );
+	
+	// Can't handle this object
+	CObjectMortar *mortar = dynamic_cast< CObjectMortar * >( pObject );
+	if ( !mortar )
+		return;
+
+	m_bCarried = false;
+	
+	m_hDeployedMortar = mortar;
+	mortar->m_hMortarWeapon = this;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pObject - 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::RemoveAssociatedObject( CBaseObject *pObject )
+{
+	Assert( pObject );
+
+	// Can't handle this object
+	CObjectMortar *mortar = dynamic_cast< CObjectMortar * >( pObject );
+	if ( !mortar )
+		return;
+
+	if ( m_hDeployedMortar == mortar )
+	{
+		m_hDeployedMortar = NULL;
+		m_bCarried = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The player holding this weapon has just gained new technology.
+//			Check to see if it affects the mortar
+//-----------------------------------------------------------------------------
+void CWeaponMortar::GainedNewTechnology( CBaseTechnology *pTechnology )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( pPlayer )
+	{
+		// Range upgraded?
+		if ( pPlayer->HasNamedTechnology("mortar_range") )
+			m_bRangeUpgraded = true;
+		else
+			m_bRangeUpgraded = false;
+
+		// Accuracy upgraded?
+		if ( pPlayer->HasNamedTechnology("mortar_accuracy") )
+			m_bAccuracyUpgraded = true;
+		else
+			m_bAccuracyUpgraded = false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponMortar::WeaponIdle( void )
+{
+	if ( HasWeaponIdleTimeElapsed() )
+	{
+		if ( m_bCarried )
+		{
+			SendWeaponAnim( ACT_SLAM_TRIPMINE_IDLE );
+		}
+		else
+		{
+			SendWeaponAnim( ACT_SLAM_DETONATOR_IDLE );
+		}
+
+		SetWeaponIdleTime( gpGlobals->curtime + 1.0 );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: My mortar object is reloading
+//-----------------------------------------------------------------------------
+void CWeaponMortar::MortarIsReloading( void )
+{
+	m_bMortarReloading = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: My mortar object has finished reloading
+//-----------------------------------------------------------------------------
+void CWeaponMortar::MortarFinishedReloading( void )
+{
+	m_bMortarReloading = false;
+}
diff --git a/game/shared/tf2/weapon_mortar.h b/game/shared/tf2/weapon_mortar.h
new file mode 100644
index 0000000..c32db7d
--- /dev/null
+++ b/game/shared/tf2/weapon_mortar.h
@@ -0,0 +1,84 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_MORTAR_H
+#define WEAPON_MORTAR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+class SmokeTrail;
+class CWeaponMortar;
+
+#include "tf_basecombatweapon.h"
+#include "particle_smokegrenade.h"
+#include "utllinkedlist.h"
+#include "tf_obj_mortar.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponMortar : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponMortar, CBaseTFCombatWeapon );
+public:
+	DECLARE_SERVERCLASS();
+
+	CWeaponMortar();
+
+	virtual void Precache();
+
+	// Input
+	void Fire( float flPower, float flAccuracy );
+	void PrimaryAttack( void );
+	void SecondaryAttack( void );
+
+	// Deployment / Pick-up
+	void DeployMortar( CObjectMortar *pMortar );
+	void PickupMortar( void );
+	void MortarDestroyed( void );
+	void MortarObjectRemoved( void );
+
+	// Turning
+	void SetYaw( float flYaw );
+
+	// Firing
+	virtual void	ItemPostFrame( void );
+	virtual float	GetFireRate( void );
+
+	// Ammo
+	virtual void	SetRoundType( int iRoundType );
+
+	virtual bool	Deploy( void );
+	virtual void	WeaponIdle( void );
+
+	virtual void	GainedNewTechnology( CBaseTechnology *pTechnology );
+	virtual void	AddAssociatedObject( CBaseObject *pObject );
+	virtual void	RemoveAssociatedObject( CBaseObject *pObject );
+
+	virtual bool	ComputeEMPFireState( void );
+
+	void			MortarIsReloading( void );
+	void			MortarFinishedReloading( void );
+
+public:
+	// Data
+	bool			m_bCarried;
+	bool			m_bMortarReloading;
+	CHandle< CObjectMortar > m_hDeployedMortar;
+	Vector			m_vecMortarOrigin;
+	QAngle			m_vecMortarAngles;
+	bool			m_bRangeUpgraded;
+	bool			m_bAccuracyUpgraded;
+
+	// Firing
+	float			m_flFiringPower;
+	float			m_flFiringAccuracy;
+};
+
+#endif // WEAPON_MORTAR_H
diff --git a/game/shared/tf2/weapon_obj_empgenerator.cpp b/game/shared/tf2/weapon_obj_empgenerator.cpp
new file mode 100644
index 0000000..e1004da
--- /dev/null
+++ b/game/shared/tf2/weapon_obj_empgenerator.cpp
@@ -0,0 +1,37 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "tf_basecombatweapon.h"
+#include "tf_obj.h"
+#include "tf_obj_empgenerator.h"
+#include "weapon_basecombatobject.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Combat object weapon for the EMP Generator
+//-----------------------------------------------------------------------------
+class CWeaponObjEMPGenerator : public CWeaponBaseCombatObject
+{
+	DECLARE_CLASS( CWeaponObjEMPGenerator, CWeaponBaseCombatObject );
+public:
+	CWeaponObjEMPGenerator( void );
+
+	DECLARE_SERVERCLASS();
+};
+
+IMPLEMENT_SERVERCLASS_ST( CWeaponObjEMPGenerator, DT_WeaponObjEMPGenerator )
+END_SEND_TABLE()
+
+LINK_ENTITY_TO_CLASS( weapon_obj_empgenerator, CWeaponObjEMPGenerator );
+PRECACHE_WEAPON_REGISTER(weapon_obj_empgenerator);
+
+CWeaponObjEMPGenerator::CWeaponObjEMPGenerator( void )
+{
+	m_szObjectName = "obj_empgenerator";
+	m_vecBuildMins = EMPGENERATOR_MINS - Vector( 4,4,4 );
+	m_vecBuildMaxs = EMPGENERATOR_MAXS + Vector( 4,4,4 );
+}
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_obj_rallyflag.cpp b/game/shared/tf2/weapon_obj_rallyflag.cpp
new file mode 100644
index 0000000..6a041ef
--- /dev/null
+++ b/game/shared/tf2/weapon_obj_rallyflag.cpp
@@ -0,0 +1,74 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_basecombatobject.h"
+
+#if !defined( CLIENT_DLL )
+// #include "grenade_antipersonnel.h"
+#else
+
+#define CWeaponObjRallyFlag C_WeaponObjRallyFlag
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Combat object weapon for the Rally Flag
+//-----------------------------------------------------------------------------
+class CWeaponObjRallyFlag : public CWeaponBaseCombatObject
+{
+	DECLARE_CLASS( CWeaponObjRallyFlag, CWeaponBaseCombatObject );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponObjRallyFlag( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+private:														
+	CWeaponObjRallyFlag( const CWeaponObjRallyFlag & );						
+
+};
+
+CWeaponObjRallyFlag::CWeaponObjRallyFlag( void )
+{
+	m_szObjectName = "obj_rallyflag";
+	m_vecBuildMins = RALLYFLAG_MINS - Vector( 4,4,4 );
+	m_vecBuildMaxs = RALLYFLAG_MAXS + Vector( 4,4,4 );
+	SetPredictionEligible( true );
+}
+
+LINK_ENTITY_TO_CLASS( weapon_obj_rallyflag, CWeaponObjRallyFlag );
+
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponObjRallyFlag, DT_WeaponObjRallyFlag )
+
+BEGIN_NETWORK_TABLE( CWeaponObjRallyFlag, DT_WeaponObjRallyFlag )
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponObjRallyFlag )
+END_PREDICTION_DATA()
+
+PRECACHE_WEAPON_REGISTER(weapon_obj_rallyflag);
diff --git a/game/shared/tf2/weapon_objectselection.cpp b/game/shared/tf2/weapon_objectselection.cpp
new file mode 100644
index 0000000..e04e8cb
--- /dev/null
+++ b/game/shared/tf2/weapon_objectselection.cpp
@@ -0,0 +1,216 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "basetfcombatweapon_shared.h"
+
+#if defined( CLIENT_DLL )
+#include "hud.h"
+#include <vgui_controls/Controls.h>
+#include <vgui/ISurface.h>
+#endif
+
+#include "weapon_objectselection.h"
+
+#if !defined( CLIENT_DLL )
+#include "weapon_builder.h"
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+LINK_ENTITY_TO_CLASS( weapon_objectselection, CWeaponObjectSelection );
+
+PRECACHE_WEAPON_REGISTER( weapon_objectselection );
+
+BEGIN_PREDICTION_DATA( CWeaponObjectSelection )
+END_PREDICTION_DATA()
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponObjectSelection, DT_WeaponObjectSelection )
+
+BEGIN_NETWORK_TABLE( CWeaponObjectSelection, DT_WeaponObjectSelection )
+#if !defined( CLIENT_DLL )
+	SendPropInt( SENDINFO( m_iObjectType ), 8, SPROP_UNSIGNED ),
+#else
+	RecvPropInt( RECVINFO( m_iObjectType ) ),
+#endif
+END_NETWORK_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponObjectSelection::CWeaponObjectSelection()
+{
+#if defined( CLIENT_DLL )
+	m_bNeedSpriteSetup = true;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Deploy the builder weapon instead of this weapon, and tell it to switch to this object.
+//-----------------------------------------------------------------------------
+bool CWeaponObjectSelection::CanDeploy( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if (!pPlayer)
+		return false;
+
+#if !defined(CLIENT_DLL)
+	// Select a state for the builder weapon
+	CWeaponBuilder *pBuilder = pPlayer->GetWeaponBuilder();
+	if ( pBuilder )
+	{
+		pBuilder->SetCurrentObject( m_iObjectType );
+		pPlayer->Weapon_Switch( pBuilder );
+		pPlayer->SetNextAttack( gpGlobals->curtime );
+	}
+#endif
+
+	// Never deploy this weapon
+	return false;
+}
+
+
+void CWeaponObjectSelection::SetType( int iType )
+{
+	m_iObjectType = iType;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Setup the weapon selection sprite we should use for this weapon
+//-----------------------------------------------------------------------------
+void CWeaponObjectSelection::SetupObjectSelectionSprite( void )
+{
+#ifdef CLIENT_DLL
+	// Use the sprite details from the text file, with a custom sprite
+	char *iconTexture = GetObjectInfo( m_iObjectType )->m_pIconActive;
+	if ( iconTexture && iconTexture[ 0 ] )
+	{
+		m_pSelectionTexture = gHUD.GetIcon( iconTexture );
+	}
+	else
+	{
+		m_pSelectionTexture = NULL;
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if this weapon has some ammo
+//-----------------------------------------------------------------------------
+bool CWeaponObjectSelection::HasAmmo( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return false;
+
+	int iCost = CalculateObjectCost( m_iObjectType,  pOwner->GetNumObjects(m_iObjectType), pOwner->GetTeamNumber() );
+	return ( pOwner->GetBankResources() >= iCost );
+}
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponObjectSelection::PreDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PreDataUpdate(updateType);
+
+	m_iOldObjectType = m_iObjectType;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : updateType - 
+//-----------------------------------------------------------------------------
+void CWeaponObjectSelection::PostDataUpdate( DataUpdateType_t updateType )
+{
+	BaseClass::PostDataUpdate( updateType );
+
+	// Note, can't do this in OnDataChanged since you can get multiple
+	//  predataupdates/postdataupdates in one frame but only one OnDataChanged just before 
+	//  rendering
+	if ( m_iOldObjectType != m_iObjectType )
+	{
+		m_bNeedSpriteSetup = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponObjectSelection::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged(updateType);
+
+	// If our type has changed or we've never been set up, then
+	//  setup our object selection sprite
+	if ( m_bNeedSpriteSetup)
+	{
+		m_bNeedSpriteSetup = false;
+		SetupObjectSelectionSprite();
+	}
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CWeaponObjectSelection::GetSubType( void )
+{ 
+#if !defined( CLIENT_DLL )
+	return BaseClass::GetSubType();
+#else
+	// We don't network down the subtype, so use out object type
+	return m_iObjectType; 
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CWeaponObjectSelection::GetSlot( void ) const
+{
+	return GetObjectInfo( m_iObjectType )->m_SelectionSlot;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int CWeaponObjectSelection::GetPosition( void ) const
+{
+	return GetObjectInfo( m_iObjectType )->m_SelectionPosition;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+const char *CWeaponObjectSelection::GetPrintName( void ) const
+{
+	return GetObjectInfo( m_iObjectType )->m_pStatusName;
+}
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudTexture const * CWeaponObjectSelection::GetSpriteActive( void ) const
+{
+	return m_pSelectionTexture;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CHudTexture const * CWeaponObjectSelection::GetSpriteInactive( void ) const
+{
+	return m_pSelectionTexture;
+}
+
+#endif
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_objectselection.h b/game/shared/tf2/weapon_objectselection.h
new file mode 100644
index 0000000..90f86bb
--- /dev/null
+++ b/game/shared/tf2/weapon_objectselection.h
@@ -0,0 +1,69 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_OBJECTSELECTION_H
+#define WEAPON_OBJECTSELECTION_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#if defined( CLIENT_DLL )
+#define CWeaponObjectSelection C_WeaponObjectSelection
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: This is a 'weapon' that's used to put objects into the client's weapon selection 
+//-----------------------------------------------------------------------------
+class CWeaponObjectSelection : public CBaseTFCombatWeapon
+{ 
+	DECLARE_CLASS( CWeaponObjectSelection, CBaseTFCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponObjectSelection();
+
+#if defined( CLIENT_DLL )
+	virtual void	PreDataUpdate( DataUpdateType_t updateType );
+	virtual void	PostDataUpdate( DataUpdateType_t updateType );
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+#endif
+
+	// Overridden to handle objects
+	virtual bool	CanDeploy( void );
+	virtual bool	HasAmmo( void );
+	virtual int		GetSubType( void );
+	virtual int		GetSlot( void ) const;
+	virtual int		GetPosition( void ) const;
+	virtual const char *GetPrintName( void ) const;
+
+#ifdef CLIENT_DLL
+	virtual CHudTexture const *GetSpriteActive( void ) const;
+	virtual CHudTexture const *GetSpriteInactive( void ) const;
+#endif
+
+	// Set this selection's object type
+	void	SetType( int iType );
+	void	SetupObjectSelectionSprite( void );
+
+	virtual bool	SupportsTwoHanded( void ) { return true; };
+
+protected:
+	CNetworkVar( int, m_iObjectType );
+	int		m_iOldObjectType;
+
+#ifdef CLIENT_DLL
+	CHudTexture		*m_pSelectionTexture;
+	bool			m_bNeedSpriteSetup;
+	vgui::HFont		m_hNumberFont;
+#endif
+
+private:														
+	CWeaponObjectSelection( const CWeaponObjectSelection & );						
+};
+
+#endif // WEAPON_OBJECTSELECTION_H
diff --git a/game/shared/tf2/weapon_pistols.cpp b/game/shared/tf2/weapon_pistols.cpp
new file mode 100644
index 0000000..47c51a9
--- /dev/null
+++ b/game/shared/tf2/weapon_pistols.cpp
@@ -0,0 +1,134 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:	Recon's dual semi-auto pistols
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "tf_basecombatweapon.h"
+#include "in_buttons.h"
+#include "gamerules.h"
+#include "ammodef.h"
+#include "basegrenade_shared.h"
+
+ConVar	weapon_pistols_damage( "weapon_pistols_damage","0", FCVAR_NONE, "Recon pistols maximum damage" );
+ConVar	weapon_pistols_range( "weapon_pistols_range","0", FCVAR_NONE, "Recon pistols maximum range" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponPistols : public CTFMachineGun
+{
+	DECLARE_CLASS( CWeaponPistols, CTFMachineGun );
+public:
+	virtual float			GetFireRate( void );
+	virtual const Vector&	GetBulletSpread( void ); 
+	virtual bool			Deploy( void );
+	virtual void			PrimaryAttack( void );
+	virtual void			SecondaryAttack( void );
+	virtual void			ItemPostFrame( void );
+
+private:
+	float		m_flSoonestPrimaryAttack;
+	float		m_flLastPrimaryAttack;
+};
+
+LINK_ENTITY_TO_CLASS( weapon_pistols, CWeaponPistols );
+PRECACHE_WEAPON_REGISTER(weapon_pistols);
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the accuracy derived from weapon and player, and return it
+//-----------------------------------------------------------------------------
+const Vector& CWeaponPistols::GetBulletSpread( void )
+{
+	static Vector cone;
+	cone = VECTOR_CONE_10DEGREES;
+
+	// Modify accuracy based upon firing rate
+	// Maximum accuracy's used if you're firing at the standard rate of the gun
+	float flModifier = MIN( GetFireRate(), gpGlobals->curtime - m_flLastPrimaryAttack );
+	flModifier = 1.0 - RemapVal( flModifier, 0, GetFireRate(), 0, 1.0 );
+	cone *= flModifier;
+
+	return cone;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponPistols::GetFireRate( void )
+{	
+	return 0.5; 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+bool CWeaponPistols::Deploy( void )
+{
+	m_flSoonestPrimaryAttack = gpGlobals->curtime;
+	m_flLastPrimaryAttack = gpGlobals->curtime;
+	return BaseClass::Deploy();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponPistols::PrimaryAttack( void )
+{
+	m_flSoonestPrimaryAttack = gpGlobals->curtime + 0.1;
+	BaseClass::PrimaryAttack();
+	m_flLastPrimaryAttack = gpGlobals->curtime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Throw out a sticky bomb
+//-----------------------------------------------------------------------------
+void CWeaponPistols::SecondaryAttack( void )
+{
+	/* FIXME: Temporarily disabled
+	CBasePlayer *pPlayer = GetOwner();
+	if ( pPlayer == NULL )
+		return;
+
+	// Calculate position & velocity
+	Vector vecForward;
+	pPlayer->EyeVectors( &vecForward );
+	Vector vecOrigin = pPlayer->EyePosition();
+	vecOrigin += (vecForward * 16);
+
+	// Create the stickybomb
+	CBaseGrenade *pGrenade = (CBaseGrenade*)CreateEntityByName("grenade_stickybomb");
+	UTIL_SetOrigin( pGrenade->pev, vecOrigin );
+	pGrenade->Spawn();
+	pGrenade->SetOwnerEntity( pPlayer );
+	pGrenade->m_hOwner = pPlayer;
+	pGrenade->m_vecVelocity = vecForward * 1200;
+	VectorAngles( vecForward, pGrenade->GetAngles() );
+
+	// Reduce ammo, setup for refire
+	pPlayer->m_iAmmo[m_iSecondaryAmmoType]--;
+	m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
+	*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponPistols::ItemPostFrame( void )
+{
+	CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
+	if ( pPlayer == NULL )
+		return;
+
+	// Allow a refire as fast as the player can click
+	if ( ( ( pPlayer->m_nButtons & IN_ATTACK ) == false ) && ( m_flSoonestPrimaryAttack < gpGlobals->curtime )
+		/* && ( m_flNextSecondaryAttack < gpGlobals->curtime )*/ )
+	{
+		m_flNextPrimaryAttack = gpGlobals->curtime - 0.1f;
+	}
+
+	BaseClass::ItemPostFrame();
+}
+
diff --git a/game/shared/tf2/weapon_plasmarifle.cpp b/game/shared/tf2/weapon_plasmarifle.cpp
new file mode 100644
index 0000000..d89f7f5
--- /dev/null
+++ b/game/shared/tf2/weapon_plasmarifle.cpp
@@ -0,0 +1,74 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Medic's plasma rifle
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "tf_player.h"
+#include "in_buttons.h"
+#include "gamerules.h"
+#include "ammodef.h"
+#include "entitylist.h"
+#include "plasmaprojectile.h"
+#include "tf_shareddefs.h"
+#include "basegrenade_shared.h"
+#include "tf_basecombatweapon.h"
+
+// Damage CVars
+ConVar	weapon_plasmarifle_damage( "weapon_plasmarifle_damage","0", FCVAR_NONE, "Plasma Rifle maximum damage" );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponPlasmaRifle : public CTFMachineGun
+{
+	DECLARE_CLASS( CWeaponPlasmaRifle, CTFMachineGun );
+public:
+	virtual void	FireBullets( CBaseTFCombatWeapon *pWeapon, int cShots, const Vector &vecSrc, const Vector &vecDirShooting, const Vector &vecSpread, float flDistance, int iBulletType, int iTracerFreq);
+	virtual const Vector& GetBulletSpread( void ); 
+	virtual float	GetFireRate( void );
+};
+
+LINK_ENTITY_TO_CLASS( weapon_plasmarifle, CWeaponPlasmaRifle );
+PRECACHE_WEAPON_REGISTER(weapon_plasmarifle);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponPlasmaRifle::FireBullets( CBaseTFCombatWeapon *pWeapon, int cShots, const Vector &vecSrc, const Vector &vecDirShooting, const Vector &vecSpread, float flDistance, int iBulletType, int iTracerFreq )
+{
+	CBaseTFPlayer *pPlayer = static_cast< CBaseTFPlayer * >( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	Vector vecForward;
+	pPlayer->EyeVectors( &vecForward );
+	Vector vecOrigin = pPlayer->EyePosition();
+	trace_t tr;
+
+	Vector vecTracerSrc = pWeapon->GetTracerSrc( (Vector&)vecSrc, (Vector&)vecDirShooting );
+
+	// Fire the emp projectile
+	CBasePlasmaProjectile *pPlasma = CBasePlasmaProjectile::Create( vecTracerSrc, vecDirShooting, DMG_ENERGYBEAM, pPlayer );
+	pPlasma->SetDamage( weapon_plasmarifle_damage.GetFloat() );
+	pPlasma->m_hOwner = pPlayer;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the accuracy derived from weapon and player, and return it
+//-----------------------------------------------------------------------------
+const Vector& CWeaponPlasmaRifle::GetBulletSpread( void )
+{
+	static Vector cone = VECTOR_CONE_4DEGREES;
+	return cone;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponPlasmaRifle::GetFireRate( void )
+{	
+	return 0.2; 
+}
+
diff --git a/game/shared/tf2/weapon_repairgun.cpp b/game/shared/tf2/weapon_repairgun.cpp
new file mode 100644
index 0000000..b2e626d
--- /dev/null
+++ b/game/shared/tf2/weapon_repairgun.cpp
@@ -0,0 +1,740 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:			The Medic's Medikit weapon
+//					
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "in_buttons.h"
+#include "weapon_combatshield.h"
+#include "engine/IEngineSound.h"
+#include "grenade_base_empable.h"
+#include "basetfvehicle.h"
+#include "tf_gamerules.h"
+
+//#define REPAIR_GUN_DISABLES_GRENADES	// Uncomment if you want the repair gun to disable grenades.
+
+#if defined( CLIENT_DLL )
+#include "particles_simple.h"
+#else
+#include "ndebugoverlay.h"
+#endif
+
+#include "weapon_repairgun.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+// Buff ranges
+ConVar weapon_repairgun_target_range( "weapon_repairgun_target_range", "450", FCVAR_REPLICATED, "The farthest away you can be for the repair gun to initially lock onto a player." );
+ConVar weapon_repairgun_stick_range( "weapon_repairgun_stick_range", "512", FCVAR_REPLICATED, "How far away the repair gun can stay locked onto someone." );
+ConVar weapon_repairgun_rate( "weapon_repairgun_rate", "12", FCVAR_REPLICATED, "Health healed per second by the repair gun." );
+ConVar weapon_repairgun_damage_modifier( "weapon_repairgun_damage_modifier", "1.5", FCVAR_REPLICATED, "Scales the damage a player does while being healed with the repair gun." );
+ConVar weapon_repairgun_debug( "weapon_repairgun_debug", "0", FCVAR_REPLICATED, "Show debugging info for the repair gun." );
+ConVar weapon_repairgun_construction_rate( "weapon_repairgun_construction_rate", "10", FCVAR_REPLICATED, "Constructing object health healed per second by the repair gun." );
+
+LINK_ENTITY_TO_CLASS( weapon_repairgun, CWeaponRepairGun );
+
+PRECACHE_WEAPON_REGISTER( weapon_repairgun );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponRepairGun, DT_WeaponRepairGun )
+
+BEGIN_NETWORK_TABLE( CWeaponRepairGun, DT_WeaponRepairGun )
+#if !defined( CLIENT_DLL )
+	SendPropInt( SENDINFO( m_bHealing ), 1, SPROP_UNSIGNED ),
+	SendPropInt( SENDINFO( m_bAttacking ), 1, SPROP_UNSIGNED ),
+	SendPropEHandle( SENDINFO( m_hHealingTarget ) ),
+#else
+	RecvPropInt( RECVINFO( m_bAttacking ) ),
+	RecvPropInt( RECVINFO( m_bHealing ) ),
+	RecvPropEHandle( RECVINFO(m_hHealingTarget) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponRepairGun  )
+
+	DEFINE_PRED_FIELD( m_bHealing, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_bAttacking, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_hHealingTarget, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+
+	DEFINE_FIELD( m_flHealEffectLifetime, FIELD_FLOAT ),
+
+//	DEFINE_PRED_FIELD( m_pEmitter, FIELD_POINTER ),
+//	DEFINE_PRED_FIELD( m_hParticleMaterial, FIELD_???,  ),
+//	DEFINE_PRED_FIELD( m_PathParticleEvent, FIELD_???,  ),
+//	DEFINE_PRED_FIELD( m_bPlayingSound, FIELD_BOOLEAN ),
+
+END_PREDICTION_DATA()
+
+#define PARTICLE_PATH_VEL				140.0
+#define NUM_PATH_PARTICLES_PER_SEC		600.0f
+#define NUM_TARGET_PARTICLES_PER_SEC	720.0f
+
+#define NUM_REPAIRGUN_PATH_POINTS		8
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponRepairGun::CWeaponRepairGun( void )
+{
+	m_flHealEffectLifetime = 0;
+
+	m_bHealing = false;
+	m_bAttacking = false;
+
+	m_flNextBuzzTime = 0;
+
+#if defined( CLIENT_DLL )
+	m_pEmitter = NULL;
+	m_hParticleMaterial = INVALID_MATERIAL_HANDLE;
+	m_PathParticleEvent.Init( NUM_PATH_PARTICLES_PER_SEC );
+	m_bPlayingSound = false;
+#endif
+
+	SetPredictionEligible( true );
+}
+
+
+void CWeaponRepairGun::Precache()
+{
+	BaseClass::Precache();
+	PrecacheScriptSound( "WeaponRepairGun.NoTarget" );
+	PrecacheScriptSound( "WeaponRepairGun.Healing" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CWeaponRepairGun::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	RemoveHealingTarget();
+	m_bAttacking = false;
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponRepairGun::GetTargetRange( void )
+{
+	return weapon_repairgun_target_range.GetFloat();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponRepairGun::GetStickRange( void )
+{
+	return weapon_repairgun_stick_range.GetFloat();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponRepairGun::GetHealRate( void )
+{
+	return weapon_repairgun_rate.GetFloat();
+}
+
+// Now make sure there isn't something other than team players in the way.
+class CRepairFilter : public CTraceFilterSimple
+{
+public:
+	CRepairFilter( CBaseEntity *pShooter ) : CTraceFilterSimple( pShooter, TFCOLLISION_GROUP_WEAPON )
+	{
+		m_pShooter = pShooter;
+	}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
+	{
+		// If it hit an edict the isn't the target and is on our team, then the ray is blocked.
+		CBaseEntity *pEnt = static_cast<CBaseEntity*>(pHandleEntity);
+
+		// Ignore collisions with the shooter
+		if ( pEnt == m_pShooter )
+			return false;
+		
+		// You can't heal a vehicle you are sitting in.
+
+		if( ((CBaseTFPlayer*)m_pShooter)->IsInAVehicle() )
+		{
+
+			CBaseEntity* pVehicle = ((CBaseTFPlayer*)m_pShooter)->GetVehicle()->GetVehicleEnt();		
+			if( pVehicle == pEnt )
+			{
+				return false;
+			}
+		}
+
+#ifdef REPAIR_GUN_DISABLES_GRENADES 
+
+			// Repairgun can also disable enemy grenades
+			CBaseEMPableGrenade *pGrenade = dynamic_cast<CBaseEMPableGrenade*>(pEnt);
+
+			// Ignore collisions with teammates, or friendly grenades
+			if ( !pGrenade )
+			{
+				if ( pEnt->GetTeam() == m_pShooter->GetTeam() )
+					return false;
+			}
+#else
+			if ( pEnt->GetTeam() == m_pShooter->GetTeam() )
+				return false;
+#endif
+
+		return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
+	}
+
+	CBaseEntity	*m_pShooter;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Vehicle checking to see if we should switch targets from a player 
+//			to a vehicle, or vice versa.
+//-----------------------------------------------------------------------------
+CBaseEntity *CWeaponRepairGun::CheckVehicleTargets( CBaseEntity *pCurHealing )
+{
+	// Unable to switch to/from players?
+	if ( !TargetsPlayers() )
+		return pCurHealing;
+
+	CBaseTFVehicle *pTargetVehicle = NULL;
+
+	// If we're a fully healed player sitting in a vehicle, see if the vehicle needs healing instead
+	if ( pCurHealing->IsPlayer() && pCurHealing->GetHealth() >= pCurHealing->GetMaxHealth() )
+	{
+		CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)pCurHealing;
+		if ( !pPlayer->IsInAVehicle() )
+			return pCurHealing;
+
+		pTargetVehicle = (CBaseTFVehicle*)(pPlayer->GetVehicle()->GetVehicleEnt());
+		if ( pTargetVehicle->GetHealth() < pTargetVehicle->GetMaxHealth() )
+			return pTargetVehicle;
+	}
+	else
+	{
+		// If the entity is a vehicle, and it's fully healed, heal any players in it instead
+		pTargetVehicle = dynamic_cast<CBaseTFVehicle *>(pCurHealing);
+	}
+
+	// Is the vehicle fully healed?
+	if ( pTargetVehicle && pTargetVehicle->GetHealth() >= pTargetVehicle->GetMaxHealth() )
+	{
+		CBaseTFPlayer *pUnhurtPlayer = NULL;
+		CBaseTFPlayer *pHurtPlayer = NULL;
+
+		// Go through all players in the vehicle
+		int iMax = pTargetVehicle->GetMaxPassengerCount();
+		for ( int i = 0; i < iMax; i++ )
+		{
+			CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)pTargetVehicle->GetPassenger(i);
+			if ( pPlayer )
+			{
+				if ( pPlayer->GetHealth() < pPlayer->GetMaxHealth() )
+				{
+					pUnhurtPlayer = pPlayer;
+				}
+				else
+				{
+					pHurtPlayer = pPlayer;
+				}
+			}
+		}
+
+		// Heal hurt players first
+		if ( pHurtPlayer )
+			return pHurtPlayer;
+
+		if ( pUnhurtPlayer )
+			return pUnhurtPlayer;
+	}
+
+	return pCurHealing;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a pointer to a healable target
+//-----------------------------------------------------------------------------
+CBaseEntity *CWeaponRepairGun::GetTargetToHeal( CBaseEntity *pCurHealing )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return NULL;
+
+	Vector vecSrc = pOwner->Weapon_ShootPosition( );
+	
+
+	// If we're already healing someone, stick onto them as long as possible.
+	// Even if we can't heal them at the moment, lock onto them until they release the buttom.
+	CBaseEntity* pTarget = pCurHealing;
+	CBaseEntity* pVehicle = NULL;	// Vehicle the owner is in, or NULL.
+
+	// You can't heal a vehicle you are sitting in, make sure we aren't healing a vehicle right after we've gotten in.
+	if( ((CBaseTFPlayer*)pOwner)->IsInAVehicle() )
+	{
+
+		pVehicle = ((CBaseTFPlayer*)pOwner)->GetVehicle()->GetVehicleEnt();		
+		if( pVehicle == pTarget )
+		{
+			pTarget = NULL;
+		}
+	}
+
+	if ( pTarget && pTarget->IsAlive() && (pTarget->GetTeam() == pOwner->GetTeam()) )
+	{
+		// Make sure the guy didn't go out of range.
+		Vector vecTargetPoint = pTarget->WorldSpaceCenter();
+		Vector vecPoint;
+
+		// If it's brush built, use absmins/absmaxs
+		pTarget->CollisionProp()->CalcNearestPoint( vecSrc, &vecPoint );
+
+#ifndef CLIENT_DLL
+		//NDebugOverlay::Box( vecPoint, Vector(-2,-2,-2), Vector(2,2,2), 255,0,0, 8, 0.1 );
+#endif
+
+		float flDistance = (vecPoint - vecSrc).Length();
+		if ( flDistance < GetStickRange() )
+		{
+			trace_t tr;
+			CRepairFilter drainFilter( pOwner );
+			UTIL_TraceLine( vecSrc, vecTargetPoint, MASK_SHOT, &drainFilter, &tr );
+			
+			if (( tr.fraction == 1.0f) || (tr.m_pEnt == pTarget))
+				return CheckVehicleTargets( pTarget );
+		}
+
+		// Return null so we can't heal this player but m_hHealingPlayer stays set to them.
+		return NULL;
+	}
+	else
+	{	
+		// Ok, try to find a new player to heal.
+		// Get the target point and location
+		Vector vecAiming;
+		pOwner->EyeVectors( &vecAiming );
+
+		// Find a player in range of this player, and make sure they're healable.
+		Vector vecEnd = vecSrc + vecAiming * GetTargetRange();
+		trace_t tr;
+
+		// Use WeaponTraceLine so shields are tested...
+		TFGameRules()->WeaponTraceLine( vecSrc, vecEnd, (MASK_SHOT & ~CONTENTS_HITBOX), pOwner, DMG_PROBE, &tr );
+
+#ifndef CLIENT_DLL
+		//NDebugOverlay::Box( vecSrc, Vector(-2,-2,-2), Vector(2,2,2), 192,192,0, 8, 10 );
+		//NDebugOverlay::Box( vecEnd, Vector(-2,-2,-2), Vector(2,2,2), 0,255,0, 8, 10 );
+		//NDebugOverlay::Box( tr.endpos, Vector(-2,-2,-2), Vector(2,2,2), 0,0,255, 8, 10 );
+#endif
+		
+		if ( tr.fraction != 1.0 )
+		{
+			CBaseEntity *pEntity = tr.m_pEnt;
+			if ( pEntity )
+			{
+				// Repairgun can also disable enemy grenades
+#ifdef REPAIR_GUN_DISABLES_GRENADES 
+
+				CBaseEMPableGrenade *pGrenade = dynamic_cast<CBaseEMPableGrenade*>(pEntity);
+				if ( pGrenade && !pGrenade->InSameTeam( pOwner ) )
+					return pGrenade;
+#endif
+
+				// Only target players if I'm allowed to
+				if ( !TargetsPlayers() && pEntity->IsPlayer() )
+					return NULL;
+
+				// You can't heal a vehicle you are sitting in.
+				if ( pVehicle && ( pVehicle == pEntity ) )
+					return NULL;
+
+				if ( (pEntity != pOwner) && pEntity->IsAlive() && pEntity->CanBePoweredUp() )
+				{
+					// Target needs to be on the same team
+					if ( pEntity->InSameTeam( pOwner ) )
+						return CheckVehicleTargets( pEntity );
+				}
+			}
+		}
+
+		if ( weapon_repairgun_debug.GetBool() )
+		{
+			ClientPrint( pOwner, HUD_PRINTCENTER, "REPAIRGUN: no target found\n" );
+		}
+
+		return NULL;
+	}
+
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Overloaded to handle the hold-down healing
+//-----------------------------------------------------------------------------
+void CWeaponRepairGun::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+#if !defined( CLIENT_DLL )
+	if ( AppliesModifier() )
+	{
+		m_DamageModifier.SetModifier( weapon_repairgun_damage_modifier.GetFloat() );
+	}
+#endif
+
+	// Try to start healing
+	m_bAttacking = false;
+	if ( (pOwner->m_nButtons & IN_ATTACK) && GetShieldState() == SS_DOWN )
+	{
+		PrimaryAttack();
+		m_bAttacking = true;
+	}
+	else if ( GetCurHealingTarget() )
+	{
+		// Detach from the player if they release the attack button.
+		RemoveHealingTarget();
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're healing
+	AllowShieldPostFrame( !m_bAttacking );
+
+	WeaponIdle();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponRepairGun::RemoveHealingTarget()
+{
+	// Stop the welding animation
+	if ( m_bHealing )
+	{
+		SendWeaponAnim( ACT_FIRE_END );
+	}
+
+	m_hHealingTarget = NULL;
+#if !defined( CLIENT_DLL )
+	m_DamageModifier.RemoveModifier();
+#endif
+	m_bHealing = false;
+
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( pOwner )
+	{
+		pOwner->SetIDEnt( NULL );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CWeaponRepairGun::ComputeEMPFireState( void )
+{
+	if ( IsOwnerEMPed() )
+	{
+		// If we've just been EMPed, remove the heal target
+		if ( GetCurHealingTarget() )
+		{
+			RemoveHealingTarget();
+		}
+		return false;
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Attempt to heal any player within range of the medikit
+//-----------------------------------------------------------------------------
+void CWeaponRepairGun::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// Can't fire if we've been EMPed.
+	if ( !ComputeEMPFireState() )
+		return;
+
+#if !defined( CLIENT_DLL )
+	// Find a Player to buff with hitscan
+	CBaseEntity *pCurHealing = GetCurHealingTarget();
+	CBaseEntity *pTarget = GetTargetToHeal( pCurHealing );
+	if ( pTarget )
+	{
+		// Start the welding animation
+		if ( !m_bHealing )
+		{
+			SendWeaponAnim( ACT_FIRE_START );
+		}
+
+		// Tell the client who we're trying to heal.
+		m_bHealing = true;
+		m_hHealingTarget = pTarget;
+
+		// Repairgun needs to EMP grenades, heal everything else
+#ifdef REPAIR_GUN_DISABLES_GRENADES 
+
+		CBaseEMPableGrenade *pGrenade = dynamic_cast<CBaseEMPableGrenade*>(pTarget);
+		if ( pGrenade )
+		{
+			pTarget->TakeEMPDamage( 1.0 );
+		}
+		else
+#endif
+		{
+			// Can't bring things back from the dead
+			if ( pTarget->IsAlive() )
+			{
+				float flBoostAmount = GetHealRate() * gpGlobals->frametime;
+				// If it's an object, and it's constructing, use the construction heal rate
+				if ( pTarget->Classify() == CLASS_MILITARY )
+				{
+					CBaseObject *pObject = dynamic_cast<CBaseObject*>(pTarget);
+					if ( pObject && pObject->IsBuilding() )
+					{
+						flBoostAmount = weapon_repairgun_construction_rate.GetFloat() * gpGlobals->frametime;
+					}
+					if ( pObject && pObject->IsDying() )
+					{
+						flBoostAmount = 0;
+					}
+				}
+
+				// If we're not succeeding, remove the damage modifier
+				if ( !pTarget->AttemptToPowerup( POWERUP_BOOST, 1.0, flBoostAmount, pOwner, AppliesModifier() ? &m_DamageModifier : NULL ) )
+				{
+					m_DamageModifier.RemoveModifier();
+				}
+
+				// Force the player's ID target to the heal target
+				pOwner->SetIDEnt( pTarget );
+			}
+		}
+	}
+	else
+	{
+		RemoveHealingTarget();
+	}
+#endif
+
+	CheckRemoveDisguise();
+}
+
+void CWeaponRepairGun::PlayAttackAnimation( int activity )
+{
+	SendWeaponAnim( activity );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Idle tests to see if we're facing a valid target for the medikit
+//			If so, move into the "heal-able" animation. 
+//			Otherwise, move into the "not-heal-able" animation.
+//-----------------------------------------------------------------------------
+void CWeaponRepairGun::WeaponIdle( void )
+{
+	if ( HasWeaponIdleTimeElapsed() )
+	{
+		// Loop the welding animation
+		if ( m_bHealing )
+		{
+			SendWeaponAnim( ACT_FIRE_LOOP );
+		}
+		else
+		{
+			// select an idle animation
+			SendWeaponAnim( ACT_VM_IDLE );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: The player holding this weapon has just gained new technology.
+//			Check to see if it affects the medikit
+//-----------------------------------------------------------------------------
+void CWeaponRepairGun::GainedNewTechnology( CBaseTechnology *pTechnology )
+{
+}
+
+
+#if defined( CLIENT_DLL )
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponRepairGun::StopRepairSound( bool bStopHealingSound, bool bStopNoTargetSound )
+{
+	if ( bStopHealingSound )
+	{
+		StopSound( "WeaponRepairGun.Healing" );
+	}
+
+	if ( bStopNoTargetSound )
+	{
+		StopSound( "WeaponRepairGun.NoTarget" );
+	}
+}
+
+
+void C_WeaponRepairGun::NotifyShouldTransmit( ShouldTransmitState_t state )
+{
+	// Stop emitting particles if we're going dormant.
+	if ( state == SHOULDTRANSMIT_END )
+	{
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
+	}
+
+	BaseClass::NotifyShouldTransmit( state );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : updateType - 
+//-----------------------------------------------------------------------------
+void C_WeaponRepairGun::OnDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		m_pEmitter = CSimpleEmitter::Create( "C_WeaponRepairGun" );
+		
+		m_hParticleMaterial = m_pEmitter->GetPMaterial( "sprites/chargeball" );
+	}
+
+	// Think?
+	if ( m_bHealing && m_hHealingTarget.Get())
+	{
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
+	}
+	else
+	{
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
+		m_bPlayingSound = false;
+		StopRepairSound( true, false );
+
+		// Are they holding the attack button but not healing anyone? Give feedback.
+		if ( IsActiveByLocalPlayer() && GetOwner() && GetOwner()->IsAlive() && m_bAttacking && GetOwner() == C_BasePlayer::GetLocalPlayer() )
+		{
+			if ( gpGlobals->curtime >= m_flNextBuzzTime )
+			{
+				CLocalPlayerFilter filter;
+				EmitSound( filter, entindex(), "WeaponRepairGun.NoTarget" );
+				m_flNextBuzzTime = gpGlobals->curtime + 0.5f;	// only buzz every so often.
+			}
+		}
+		else
+		{
+			StopRepairSound( false, true );	// Stop the "no target" sound.
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_WeaponRepairGun::ClientThink()
+{
+	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pPlayer )
+		return;
+
+	if ( m_hHealingTarget == NULL )
+	{
+		return;
+	}
+
+	// Don't show it while the player is dead. Ideally, we'd respond to m_bHealing in OnDataChanged,
+	// but it stops sending the weapon when it's holstered, and it gets holstered when the player dies.
+	C_BasePlayer *pFiringPlayer = dynamic_cast< C_BasePlayer* >( GetOwner() );
+	if ( !pFiringPlayer || pFiringPlayer->IsPlayerDead() )
+	{
+		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
+		m_bPlayingSound = false;
+		StopRepairSound();
+		return;
+	}
+
+	if ( !m_bPlayingSound )
+	{
+		m_bPlayingSound = true;
+		CLocalPlayerFilter filter;
+		EmitSound( filter, entindex(), "WeaponRepairGun.Healing" );
+	}
+
+	Vector points[NUM_REPAIRGUN_PATH_POINTS];
+
+	// First generate a sequence of points so we can parameterize the (curvy) path from the
+	// tip of the gun to the target.
+	Vector vForward, vOrigin;
+	QAngle vAngles;
+	GetShootPosition( vOrigin, vAngles );
+
+	AngleVectors( vAngles, &vForward );
+
+	Vector vecTargetOrg = m_hHealingTarget->WorldSpaceCenter();
+	
+	Vector vDirTo = vecTargetOrg - vOrigin;
+	float flDistanceTo = vDirTo.Length();
+	vDirTo /= flDistanceTo;
+
+	float flBendDist = flDistanceTo * 3;
+	const Vector  A = vOrigin - vForward * flBendDist;
+	const Vector &B = vOrigin;
+	const Vector &C = vecTargetOrg;
+	const Vector  D = vecTargetOrg - vForward * flBendDist;
+	
+	for ( int i=0; i < NUM_REPAIRGUN_PATH_POINTS; i++ )
+	{
+		Catmull_Rom_Spline( A, B, C, D, (float)i / (NUM_REPAIRGUN_PATH_POINTS-1), points[i] );
+	}
+
+	// Add random short-lived particles from the gun tip to the target.
+	m_pEmitter->SetSortOrigin( (vecTargetOrg + pPlayer->GetAbsOrigin()) * 0.5f );
+
+	float flCur = gpGlobals->frametime;
+	while ( m_PathParticleEvent.NextEvent( flCur ) )
+	{
+		float t = RandomFloat( 0, 1 );
+		int iPrev = (int)( t * (NUM_REPAIRGUN_PATH_POINTS - 1.001) );
+		float tPrev = (float)iPrev / (NUM_REPAIRGUN_PATH_POINTS - 1);
+		float tNext = (float)(iPrev+1) / (NUM_REPAIRGUN_PATH_POINTS - 1);
+		Assert( tNext <= NUM_REPAIRGUN_PATH_POINTS-1 );
+
+		Vector vPos;
+		VectorLerp( points[iPrev], points[iPrev+1], (t-tPrev) / (tNext - tPrev), vPos );
+		vPos += RandomVector( -3, 3 );
+		
+		SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
+		if ( pParticle )
+		{
+			// Move the points along the path.
+			pParticle->m_vecVelocity = points[iPrev+1] - points[iPrev];
+			VectorNormalize( pParticle->m_vecVelocity );
+			pParticle->m_vecVelocity *= PARTICLE_PATH_VEL;
+
+			pParticle->m_flRoll = 0;
+			pParticle->m_flRollDelta = 0;
+			pParticle->m_flDieTime = 0.2f;
+			pParticle->m_flLifetime = 0;
+			pParticle->m_uchColor[1] = 200; 
+			pParticle->m_uchColor[0] = pParticle->m_uchColor[2] = RandomInt( 0, 128 );
+			pParticle->m_uchStartAlpha = 255;
+			pParticle->m_uchEndAlpha = 0;
+			pParticle->m_uchStartSize = 5;
+			pParticle->m_uchEndSize = 3;
+			pParticle->m_iFlags = 0;
+		}
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_repairgun.h b/game/shared/tf2/weapon_repairgun.h
new file mode 100644
index 0000000..7a954a6
--- /dev/null
+++ b/game/shared/tf2/weapon_repairgun.h
@@ -0,0 +1,112 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_REPAIRGUN_H
+#define WEAPON_REPAIRGUN_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "weapon_combat_usedwithshieldbase.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponRepairGun C_WeaponRepairGun
+#endif
+
+//=========================================================
+// Medikit Weapon
+//=========================================================
+class CWeaponRepairGun : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponRepairGun, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponRepairGun( void );
+
+	virtual void	Precache();
+
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo );
+	virtual void	ItemPostFrame( void );
+	virtual void	PrimaryAttack( void );
+	virtual void	WeaponIdle( void );
+	virtual void	PlayAttackAnimation( int activity );
+	virtual void	GainedNewTechnology( CBaseTechnology *pTechnology );
+	virtual bool	ComputeEMPFireState( void );
+
+	virtual float	GetTargetRange( void );
+	virtual float	GetStickRange( void );
+	virtual float	GetHealRate( void );
+	virtual bool	AppliesModifier( void ) { return true; }
+	virtual bool	TargetsPlayers( void ) { return true; }
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+
+	// Stop all sounds being output.
+	void			StopRepairSound( bool bStopHealingSound = true, bool bStopNoTargetSound = true );
+
+	// This is used to stop making particles when the entity goes dormant.
+	virtual void	NotifyShouldTransmit( ShouldTransmitState_t state );
+// IClientNetworkable.
+public:
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+// IClientThinkable.
+public:
+
+	virtual void	ClientThink();
+
+#endif
+
+protected:
+	virtual CBaseEntity		*GetTargetToHeal( CBaseEntity *pCurHealing );
+	virtual CBaseEntity		*CheckVehicleTargets( CBaseEntity *pCurHealing );
+
+private:
+	CBaseEntity*			GetCurHealingTarget()	{ return m_hHealingTarget; }
+	void					RemoveHealingTarget();
+
+	double					m_flNextBuzzTime;
+
+	float					m_flHealEffectLifetime;	// Count down until the healing effect goes off.
+#if !defined( CLIENT_DLL )
+	CDamageModifier			m_DamageModifier;		// This attaches to whoever we're healing.
+#endif
+	CNetworkVar( bool, m_bAttacking );
+
+protected:
+// Networked data.
+	CNetworkVar( bool, m_bHealing );
+	CNetworkHandle( CBaseEntity, m_hHealingTarget );
+
+#if defined( CLIENT_DLL )
+	CSmartPtr<CSimpleEmitter> m_pEmitter;
+	PMaterialHandle			m_hParticleMaterial;
+
+	TimedEvent				m_PathParticleEvent;
+
+	bool					m_bPlayingSound;
+
+#endif
+private:														
+	CWeaponRepairGun( const CWeaponRepairGun & );
+};
+
+#endif // WEAPON_REPAIRGUN_H
diff --git a/game/shared/tf2/weapon_rocketlauncher.cpp b/game/shared/tf2/weapon_rocketlauncher.cpp
new file mode 100644
index 0000000..10bc934
--- /dev/null
+++ b/game/shared/tf2/weapon_rocketlauncher.cpp
@@ -0,0 +1,211 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Rocket Launcher (Weapon)
+//
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_combatshield.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "weapon_rocketlauncher.h"
+#include "in_buttons.h"
+
+#include "plasmaprojectile.h"
+#include "weapon_grenade_rocket.h"
+
+#if !defined( CLIENT_DLL )
+// Server Only
+#include "grenade_rocket.h"
+#else
+// Client Only
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+ 
+PRECACHE_WEAPON_REGISTER( weapon_rocket_launcher );
+LINK_ENTITY_TO_CLASS( weapon_rocket_launcher, CWeaponRocketLauncher );
+
+BEGIN_PREDICTION_DATA( CWeaponRocketLauncher )
+END_PREDICTION_DATA()
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponRocketLauncher, DT_WeaponRocketLauncher )
+BEGIN_NETWORK_TABLE( CWeaponRocketLauncher, DT_WeaponRocketLauncher )
+//#if !defined( CLIENT_DLL )
+//#else
+//#endif
+END_NETWORK_TABLE()
+
+#if !defined( CLIENT_DLL )
+// Server Only
+ConVar weapon_rocket_launcher_damage( "weapon_rocket_launcher_damage","300", FCVAR_NONE, "Rocker launcher damage" );
+ConVar weapon_rocket_launcher_range( "weapon_rocket_launcher_range", "768", FCVAR_NONE, "Rocket launcher range" );
+#endif
+
+#define WEAPON_ROCKET_LAUNCHER_FIRERATE		1.0f
+#define WEAPON_ROCKET_LAUNCHER_START_AMMO	1
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CWeaponRocketLauncher::CWeaponRocketLauncher()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Deconstructor
+//-----------------------------------------------------------------------------
+CWeaponRocketLauncher::~CWeaponRocketLauncher()
+{
+}
+
+//-----------------------------------------------------------------------------/
+// Purpose: Don't fire when EMPed
+//-----------------------------------------------------------------------------
+bool CWeaponRocketLauncher::ComputeEMPFireState( void )
+{
+	if ( IsOwnerEMPed() )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CWeaponRocketLauncher::Spawn( void )
+{
+	BaseClass::Spawn();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle deploying, undeploying, firing, etc.
+// TODO: Add a deploy to the firing!  Currently no reloading!
+//-----------------------------------------------------------------------------
+void CWeaponRocketLauncher::ItemPostFrame( void )
+{
+	// Get the player.
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	if ( UsesClipsForAmmo1() )
+	{
+		CheckReload();
+	}
+
+#if !defined( CLIENT_DLL )
+	if ( !HasPrimaryAmmo() && ( m_flNextPrimaryAttack <= gpGlobals->curtime ) )
+	{
+		pPlayer->SwitchToNextBestWeapon( NULL );
+	}
+#endif
+
+	// Handle Firing
+	if ( GetShieldState() == SS_DOWN && !m_bInReload )
+	{
+		// Attempting to fire.
+		if ( ( pPlayer->m_nButtons & IN_ATTACK ) && ( m_flNextPrimaryAttack <= gpGlobals->curtime ) )
+		{
+			if ( m_iClip1 > 0 )
+			{
+				PrimaryAttack();
+			}
+			else
+			{
+				Reload();
+			}
+		}
+
+		// Reload button (or fire button when we're out of ammo)
+		if ( m_flNextPrimaryAttack <= gpGlobals->curtime ) 
+		{
+			if ( pPlayer->m_nButtons & IN_RELOAD ) 
+			{
+				Reload();
+			}
+			else if ( !((pPlayer->m_nButtons & IN_ATTACK) || (pPlayer->m_nButtons & IN_ATTACK2) || (pPlayer->m_nButtons & IN_RELOAD)) )
+			{
+				if ( !m_iClip1 && HasPrimaryAmmo() )
+				{
+					Reload();
+				}
+			}
+		}
+	}
+
+	// Prevent shield post frame if we're not ready to attack, or we're charging
+	AllowShieldPostFrame( m_flNextPrimaryAttack <= gpGlobals->curtime || m_bInReload );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Firing
+//-----------------------------------------------------------------------------
+void CWeaponRocketLauncher::PrimaryAttack( void )
+{
+	CBaseTFPlayer *pPlayer = ( CBaseTFPlayer* )GetOwner();
+	if ( !pPlayer )
+		return;
+
+	if ( !ComputeEMPFireState() )
+		return;
+
+	// Weapon "Fire" sound.
+	WeaponSound( SINGLE );
+
+	// Play the attack animation (need one for rocket launcher - deploy?)
+	PlayAttackAnimation( GetPrimaryAttackActivity() );
+
+	// Fire the rocket (Get the position and angles).
+	Vector vecFirePos = pPlayer->Weapon_ShootPosition();
+	Vector vecFireAng;
+	pPlayer->EyeVectors( &vecFireAng );
+
+	// Shift it down a bit so the firer can see it
+	Vector vecRight;
+	AngleVectors( pPlayer->EyeAngles() + pPlayer->m_Local.m_vecPunchAngle, NULL, &vecRight, NULL );
+	vecFirePos += Vector( 0, 0, -8 ) + vecRight * 12;
+
+	// Create the rocket.
+#if !defined( CLIENT_DLL )
+	CWeaponGrenadeRocket *pRocket = CWeaponGrenadeRocket::Create( vecFirePos, vecFireAng, weapon_rocket_launcher_range.GetFloat(), pPlayer );
+#else
+	CWeaponGrenadeRocket *pRocket = CWeaponGrenadeRocket::Create( vecFirePos, vecFireAng, 0, pPlayer );
+#endif
+	if ( pRocket )
+	{
+		pRocket->SetRealOwner( pPlayer );
+#if !defined( CLIENT_DLL )
+		pRocket->SetDamage( weapon_rocket_launcher_damage.GetFloat() );
+#endif
+	}
+
+	// Essentially you are done!
+	m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
+	m_iClip1 = m_iClip1 - 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the rocket launcher firing rate.
+//-----------------------------------------------------------------------------
+float CWeaponRocketLauncher::GetFireRate( void )
+{
+	return WEAPON_ROCKET_LAUNCHER_FIRERATE;
+}
+
+#if defined( CLIENT_DLL )
+// Client Only
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CWeaponRocketLauncher::ShouldPredict( void )
+{
+	if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+		return true;
+	
+	return BaseClass::ShouldPredict();
+}
+
+#endif
diff --git a/game/shared/tf2/weapon_rocketlauncher.h b/game/shared/tf2/weapon_rocketlauncher.h
new file mode 100644
index 0000000..0c42571
--- /dev/null
+++ b/game/shared/tf2/weapon_rocketlauncher.h
@@ -0,0 +1,58 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Rocket Launcher (Weapon)
+//
+//=============================================================================//
+
+#ifndef WEAPON_ROCKETLAUNCHER_H
+#define WEAPON_ROCKETLAUNCHER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfcombatweapon_shared.h"
+
+#if defined( CLIENT_DLL )
+// Client Only
+	#define CWeaponRocketLauncher C_WeaponRocketLauncher
+#endif
+
+//=============================================================================
+//
+// Rocket Launcher (Weapon)
+//
+class CWeaponRocketLauncher : public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponRocketLauncher, CWeaponCombatUsedWithShieldBase );
+
+public:
+// Client & Server
+
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponRocketLauncher();
+	~CWeaponRocketLauncher();
+
+	void	Spawn( void );
+
+	// All predicted weapons need to implement and return true
+	bool	IsPredicted( void ) const { return true; }
+	void	PrimaryAttack( void );
+	void	ItemPostFrame( void );
+	float	GetFireRate( void );
+	bool	ComputeEMPFireState( void );
+
+#if defined( CLIENT_DLL )
+// Client Only
+
+	bool	ShouldPredict( void );
+#endif
+
+private:
+// Client & Server
+
+	CWeaponRocketLauncher( const CWeaponRocketLauncher& );
+};
+
+#endif // WEAPON_ROCKETLAUNCHER_H
\ No newline at end of file
diff --git a/game/shared/tf2/weapon_shield.cpp b/game/shared/tf2/weapon_shield.cpp
new file mode 100644
index 0000000..f711a50
--- /dev/null
+++ b/game/shared/tf2/weapon_shield.cpp
@@ -0,0 +1,218 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:			The Escort's Shield weapon
+//
+// $Revision: $
+// $NoKeywords: $
+//=============================================================================//
+
+#include "cbase.h"
+#include "weapon_shield.h"
+#include "in_buttons.h"
+#include <float.h>
+#include "mathlib/mathlib.h"
+#include "engine/IEngineSound.h"
+
+#if defined( CLIENT_DLL )
+#include "c_shield.h"
+#else
+#include "tf_shield.h"
+#endif
+
+//-----------------------------------------------------------------------------
+// Shield WEAPON
+//-----------------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS( weapon_shield, CWeaponShield );
+PRECACHE_WEAPON_REGISTER(weapon_shield);
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponShield, DT_WeaponShield )
+
+BEGIN_NETWORK_TABLE(CWeaponShield, DT_WeaponShield)
+#ifdef CLIENT_DLL
+	RecvPropEHandle (RECVINFO(m_hDeployedShield)),
+#else
+	SendPropEHandle (SENDINFO(m_hDeployedShield)),
+#endif
+END_NETWORK_TABLE()
+
+
+BEGIN_PREDICTION_DATA( CWeaponShield  )
+
+	DEFINE_FIELD( m_bIsDeployed, FIELD_BOOLEAN ),
+	DEFINE_FIELD( m_bShieldPositionLocked, FIELD_BOOLEAN ),
+
+END_PREDICTION_DATA()
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponShield::CWeaponShield( void )
+{
+	SetPredictionEligible( true );
+	m_bIsDeployed = false;
+}
+
+void CWeaponShield::UpdateOnRemove( void )
+{
+#ifdef GAME_DLL
+	if ( m_hDeployedShield.Get() )
+	{
+		m_hDeployedShield.Get()->Remove( );
+		m_hDeployedShield.Set( NULL );
+	}
+#endif
+
+	// Chain at end to mimic destructor unwind order
+	BaseClass::UpdateOnRemove();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Given the distance the hit occurred at, return the damage done
+//-----------------------------------------------------------------------------
+float CWeaponShield::GetDamage( float flDistance, int iLocation )
+{
+	// Can't injure at all over this distance
+	return 0.0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponShield::GetFireRate( void )
+{	
+	return 1.0; 
+}
+
+
+//-----------------------------------------------------------------------------
+// Deploy the shield! 
+//-----------------------------------------------------------------------------
+bool CWeaponShield::Deploy( )
+{
+	if ( !BaseClass::Deploy() )
+		return false;
+
+	// NOTE: the underlying system can cause Deploy to be called twice in a row
+	if ( m_bIsDeployed )
+		return true;
+
+	// We gotta make the actual shield effect....
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if ( !pPlayer )
+		return false;
+
+#ifdef GAME_DLL
+	Assert( !m_hDeployedShield.Get().IsValid() ); 
+	m_hDeployedShield = CreateMobileShield( pPlayer );
+#endif
+
+	SetShieldPositionLocked( false );
+	m_bIsDeployed = true;
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove the shield
+//-----------------------------------------------------------------------------
+bool CWeaponShield::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+#ifdef GAME_DLL
+	if ( m_hDeployedShield.Get() )
+	{
+		m_hDeployedShield.Get()->Remove( );
+		m_hDeployedShield.Set( NULL );
+	}
+#endif
+
+	m_bIsDeployed = false;
+
+	return BaseClass::Holster( pSwitchingTo );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponShield::ItemPostFrame( void )
+{
+	CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+	if (pPlayer == NULL)
+		return;
+
+	// Disabled
+	if ( ComputeEMPFireState() )
+	{
+		// Handle deployment & pick-up (firing is handled on the client)
+		if ( pPlayer->m_nButtons & IN_ATTACK2 )
+		{
+			if ( gpGlobals->curtime >= m_flNextPrimaryAttack) 
+			{
+				PrimaryAttack();
+			}
+		}
+	}
+
+	WeaponIdle();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponShield::PrimaryAttack( void )
+{
+	CShield *shield = m_hDeployedShield.Get();
+	if ( shield )
+	{
+		SetShieldPositionLocked( !m_bShieldPositionLocked );
+
+#ifdef GAME_DLL
+		if ( m_bShieldPositionLocked )
+		{
+			ClientPrint( ToBasePlayer(GetOwner()), HUD_PRINTCENTER, "Projected Shield Locked" );
+		}
+		else
+		{
+			ClientPrint( ToBasePlayer(GetOwner()), HUD_PRINTCENTER, "Projected Shield Tracking" );
+		}
+#endif
+	}
+
+	m_flNextPrimaryAttack = gpGlobals->curtime + 0.25f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Lock the projected shield
+//-----------------------------------------------------------------------------
+void CWeaponShield::SetShieldPositionLocked( bool bLocked )
+{
+	m_bShieldPositionLocked = bLocked; 
+	if ( m_hDeployedShield.Get() )
+	{
+		if ( bLocked && m_hDeployedShield.Get()->IsAlwaysOrienting() )
+		{
+			CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
+			m_hDeployedShield.Get()->SetCenterAngles( pPlayer->EyeAngles() );
+		}
+		m_hDeployedShield.Get()->SetAlwaysOrient( !bLocked );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Idle processing
+//-----------------------------------------------------------------------------
+void CWeaponShield::WeaponIdle( void )
+{
+	bool isEmped = IsOwnerEMPed();
+
+	if (m_hDeployedShield.Get())
+	{
+		m_hDeployedShield.Get()->SetEMPed( isEmped ); 
+	}
+}
diff --git a/game/shared/tf2/weapon_shield.h b/game/shared/tf2/weapon_shield.h
new file mode 100644
index 0000000..9d6bb21
--- /dev/null
+++ b/game/shared/tf2/weapon_shield.h
@@ -0,0 +1,83 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_SHIELD_H
+#define WEAPON_SHIELD_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//#include "tf_player.h"
+#include "basetfcombatweapon_shared.h"
+#include "tf_shieldshared.h"
+
+
+#if defined( CLIENT_DLL )
+#define CWeaponShield C_WeaponShield
+#define CShield C_Shield
+#endif
+
+class CShield;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CWeaponShield : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponShield, CBaseTFCombatWeapon );
+
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponShield();
+	
+	virtual void UpdateOnRemove( void );
+
+	// Firing
+	virtual void	ItemPostFrame( void );
+	virtual float	GetFireRate( void );
+	virtual float	GetDamage( float flDistance, int iLocation );
+
+	virtual bool	Deploy( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	virtual void	WeaponIdle( void );
+	virtual bool	VisibleInWeaponSelection( void ) { return false; }
+
+	// All predicted weapons need to implement and return true
+	virtual bool IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+
+private:
+	CWeaponShield( const CWeaponShield & );
+
+	// Lock the projected shield
+	void SetShieldPositionLocked( bool bLocked );
+
+	// Input
+	void PrimaryAttack( void );
+
+private:
+	// Data
+	CNetworkVar( CHandle<CShield>, m_hDeployedShield );
+	bool m_bShieldPositionLocked;
+	bool m_bIsDeployed;
+};
+
+#endif // WEAPON_SHIELD_H
diff --git a/game/shared/tf2/weapon_shieldgrenade.cpp b/game/shared/tf2/weapon_shieldgrenade.cpp
new file mode 100644
index 0000000..a06d1a5
--- /dev/null
+++ b/game/shared/tf2/weapon_shieldgrenade.cpp
@@ -0,0 +1,211 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_combat_usedwithshieldbase.h"
+#include "weapon_combat_basegrenade.h"
+#include "weapon_combatshield.h"
+#include "in_buttons.h"
+
+#if !defined( CLIENT_DLL )
+#include "tf_shieldgrenade.h"
+#else
+
+#define CWeaponShieldGrenade C_WeaponShieldGrenade
+
+#endif
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+#define SHIELD_GRENADE_LIFETIME	10.0f		// 10 seconds
+
+//-----------------------------------------------------------------------------
+// The shield grenade weapon
+//-----------------------------------------------------------------------------
+
+class CWeaponShieldGrenade: public CWeaponCombatUsedWithShieldBase
+{
+	DECLARE_CLASS( CWeaponShieldGrenade, CWeaponCombatUsedWithShieldBase );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponShieldGrenade();
+
+	void	Spawn( void );
+	void	ItemPostFrame( void );
+	void	PrimaryAttack( void );
+	void	ThrowGrenade( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+	virtual bool	ShouldPredict( void )
+	{
+		if ( GetOwner() == C_BasePlayer::GetLocalPlayer() )
+			return true;
+
+		return BaseClass::ShouldPredict();
+	}
+#endif
+private:
+	// A hack to work around missing animation feature
+	float	m_flStartedThrowAt;
+
+private:														
+	CWeaponShieldGrenade( const CWeaponShieldGrenade & );
+};
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponShieldGrenade, DT_WeaponShieldGrenade )
+
+BEGIN_NETWORK_TABLE( CWeaponShieldGrenade, DT_WeaponShieldGrenade )
+END_NETWORK_TABLE()
+
+LINK_ENTITY_TO_CLASS( weapon_shield_grenade, CWeaponShieldGrenade );
+PRECACHE_WEAPON_REGISTER(weapon_shield_grenade);
+
+BEGIN_PREDICTION_DATA( CWeaponShieldGrenade )
+	DEFINE_FIELD( m_flStartedThrowAt, FIELD_FLOAT ),
+END_PREDICTION_DATA();
+
+CWeaponShieldGrenade::CWeaponShieldGrenade( void )
+{
+	SetPredictionEligible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Yeehaw
+//-----------------------------------------------------------------------------
+void CWeaponShieldGrenade::Spawn( void )
+{
+	BaseClass::Spawn();
+    m_flStartedThrowAt = 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponShieldGrenade::ItemPostFrame( void )
+{
+	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
+	if (!pOwner)
+		return;
+
+	// Look for button downs
+	if ( (pOwner->m_nButtons & IN_ATTACK) && !m_flStartedThrowAt && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
+	{
+		m_flStartedThrowAt = gpGlobals->curtime;
+
+		SendWeaponAnim( ACT_VM_DRAW );
+	}
+
+	// Look for button ups
+	if ( (pOwner->m_afButtonReleased & IN_ATTACK) && (m_flNextPrimaryAttack <= gpGlobals->curtime) && m_flStartedThrowAt )
+	{
+		m_flNextPrimaryAttack = gpGlobals->curtime;
+		PrimaryAttack();
+		m_flStartedThrowAt = 0;
+	}
+
+	//  No buttons down?
+	if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
+	{
+		WeaponIdle( );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponShieldGrenade::PrimaryAttack( void )
+{
+	CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	if ( !ComputeEMPFireState() )
+		return;
+
+	if ( !GetPrimaryAmmo() )
+		return;
+
+	// player "shoot" animation
+	PlayAttackAnimation( ACT_VM_THROW );
+
+	ThrowGrenade();
+
+	// Setup for refire
+	m_flNextPrimaryAttack = gpGlobals->curtime + 1.0;
+	CheckRemoveDisguise();
+
+	// If I'm now out of ammo, switch away
+	if ( !HasPrimaryAmmo() )
+	{
+		g_pGameRules->GetNextBestWeapon( pPlayer, NULL );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponShieldGrenade::ThrowGrenade( void )
+{
+	CBasePlayer *pPlayer = dynamic_cast<CBasePlayer*>( GetOwner() );
+	if ( !pPlayer )
+		return;
+
+	BaseClass::WeaponSound(WPN_DOUBLE);
+
+	// Calculate launch velocity (3 seconds for max distance)
+	float flThrowTime = MIN( (gpGlobals->curtime - m_flStartedThrowAt), 3.0 );
+	float flSpeed = 800 + (200 * flThrowTime);
+
+	// If the player's crouched, roll the grenade
+	if ( pPlayer->GetFlags() & FL_DUCKING )
+	{
+		// Launch the grenade
+		Vector vecForward;
+		QAngle vecAngles = pPlayer->EyeAngles();
+		// Throw it up just a tad
+		vecAngles.x = -1;
+		AngleVectors( vecAngles, &vecForward, NULL, NULL);
+		Vector vecOrigin;
+		VectorLerp( pPlayer->EyePosition(), pPlayer->GetAbsOrigin(), 0.25f, vecOrigin );
+		vecOrigin += (vecForward * 16);
+		vecForward = vecForward * flSpeed;
+
+		QAngle vecGrenAngles;
+		vecGrenAngles.Init( 0, vecAngles.y, 0 );
+#if !defined( CLIENT_DLL )
+		CreateShieldGrenade( vecOrigin, vecGrenAngles, vecForward, vec3_angle, pPlayer, SHIELD_GRENADE_LIFETIME );
+#endif
+	}
+	else
+	{
+		// Launch the grenade
+		Vector vecForward;
+		QAngle vecAngles = pPlayer->EyeAngles();
+		AngleVectors( vecAngles, &vecForward, NULL, NULL);
+		Vector vecOrigin = pPlayer->EyePosition();
+		vecOrigin += (vecForward * 16);
+		vecForward = vecForward * flSpeed;
+
+		QAngle vecGrenAngles;
+		vecGrenAngles.Init( 0, vecAngles.y, 0 );
+#if !defined( CLIENT_DLL )
+		CreateShieldGrenade( vecOrigin, vecGrenAngles, vecForward, vec3_angle, pPlayer, SHIELD_GRENADE_LIFETIME );
+#endif
+	}
+
+	pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
+}
diff --git a/game/shared/tf2/weapon_twohandedcontainer.cpp b/game/shared/tf2/weapon_twohandedcontainer.cpp
new file mode 100644
index 0000000..62bedaf
--- /dev/null
+++ b/game/shared/tf2/weapon_twohandedcontainer.cpp
@@ -0,0 +1,395 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Support weapon and weapons contained within it
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+#include "basetfplayer_shared.h"
+#include "weapon_twohandedcontainer.h"
+#include "baseviewmodel_shared.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponTwoHandedContainer::CWeaponTwoHandedContainer()
+{
+	m_hRightWeapon = NULL;
+	m_hLeftWeapon = NULL;
+	SetPredictionEligible( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CWeaponTwoHandedContainer::~CWeaponTwoHandedContainer()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponTwoHandedContainer::Spawn( void )
+{
+	BaseClass::Spawn();
+}
+
+#ifdef CLIENT_DLL
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponTwoHandedContainer::GetViewmodelBoneControllers( CBaseViewModel *pViewModel, float controllers[MAXSTUDIOBONECTRLS])
+{
+	C_BasePlayer *player = ToBasePlayer( GetOwner() );
+	Assert( player );
+
+	if ( !player )
+		return;
+
+	// Find the weapon that matches the viewmodel
+	if ( m_hLeftWeapon != NULL && player->GetViewModel(0) == pViewModel )
+	{
+		m_hLeftWeapon->GetViewmodelBoneControllers( pViewModel, controllers);
+	}
+	else if ( m_hRightWeapon != NULL && player->GetViewModel(1) == pViewModel )
+	{
+		m_hRightWeapon->GetViewmodelBoneControllers( pViewModel, controllers);
+	}
+}
+
+#else // CLIENT_DLL
+
+void CWeaponTwoHandedContainer::SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways )
+{
+	// Skip this work if we're already marked for transmission.
+	if ( pInfo->m_pTransmitEdict->Get( entindex() ) )
+		return;
+
+	// Send our left and right weapons.
+	if ( m_hLeftWeapon )
+		m_hLeftWeapon->SetTransmit( pInfo, bAlways );
+
+	if ( m_hRightWeapon )
+		m_hRightWeapon->SetTransmit( pInfo, bAlways );
+
+	BaseClass::SetTransmit( pInfo, bAlways );
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const char *CWeaponTwoHandedContainer::GetViewModel( int viewmodelindex /*=0*/ )
+{
+	if ( m_hLeftWeapon != NULL && m_hRightWeapon != NULL )
+	{
+		if ( viewmodelindex == 0 )
+		{
+			return m_hLeftWeapon->GetViewModel();
+		}
+		else
+		{
+			return m_hRightWeapon->GetViewModel();
+		}
+	}
+	return BaseClass::GetViewModel( viewmodelindex );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the string to print death notices with
+//-----------------------------------------------------------------------------
+char *CWeaponTwoHandedContainer::GetDeathNoticeName( void )
+{
+	// If we have a weapon in our left slot, return it. Otherwise, return this weapon.
+	if ( m_hLeftWeapon )
+		return m_hLeftWeapon->GetDeathNoticeName();
+
+	return BaseClass::GetDeathNoticeName();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponTwoHandedContainer::ItemPostFrame( void )
+{
+	// HACK HACK:  Do nonshield first in case it disallows ItemPostFrame on shield
+	if ( m_hLeftWeapon != NULL )
+	{
+// REMOVE WHEN ALL WEAPONS ARE PREDICTED!
+#if defined( CLIENT_DLL )
+		if ( m_hLeftWeapon->IsPredicted() )
+#endif
+		m_hLeftWeapon->ItemPostFrame();
+	}
+
+	if ( m_hRightWeapon != NULL && m_hRightWeapon->IsPredicted() )
+	{
+// REMOVE WHEN ALL WEAPONS ARE PREDICTED!
+#if defined( CLIENT_DLL )
+		if ( m_hRightWeapon->IsPredicted() )
+#endif
+		m_hRightWeapon->ItemPostFrame();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called each frame by the player PostThink, if the player's not ready to attack yet
+//-----------------------------------------------------------------------------
+void CWeaponTwoHandedContainer::ItemBusyFrame( void )
+{
+	// HACK HACK:  Do nonshield first in case it disallows ItemPostFrame on shield
+	if ( m_hLeftWeapon != NULL )
+	{
+		m_hLeftWeapon->ItemBusyFrame();
+	}
+
+	if ( m_hRightWeapon != NULL )
+	{
+		m_hRightWeapon->ItemBusyFrame();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CWeaponTwoHandedContainer::SetWeapons( CBaseTFCombatWeapon *left, CBaseTFCombatWeapon *right )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( !pOwner )
+		return;
+
+	// Do we have a different left weapon?
+	if ( m_hLeftWeapon.Get() && m_hLeftWeapon != left )
+	{
+		// Holster our old one
+		m_hLeftWeapon->Holster();
+		m_hLeftWeapon = NULL;
+	}
+	// Do we have a different right weapon?
+	if ( m_hRightWeapon.Get() && m_hRightWeapon != right )
+	{
+		// Holster our old one
+		m_hRightWeapon->Holster();
+		m_hRightWeapon = NULL;
+	}
+
+	// Make new weapons if we need to
+	if ( !m_hLeftWeapon )
+	{
+		m_hLeftWeapon = left;
+		if ( m_hLeftWeapon )
+		{
+			m_hLeftWeapon->SetOwner( pOwner );
+			m_hLeftWeapon->Deploy();
+			m_hLeftWeapon->SetViewModelIndex( 0 );
+			//m_hLeftWeapon->SendWeaponAnim( ACT_IDLE );
+		}
+	}
+
+	if ( !m_hRightWeapon )
+	{
+		m_hRightWeapon = right;
+		if ( m_hRightWeapon )
+		{
+			m_hRightWeapon->SetOwner( pOwner );
+			m_hRightWeapon->Deploy();
+			m_hRightWeapon->SetViewModelIndex( 1 );
+			//m_hRightWeapon->SendWeaponAnim( ACT_IDLE );
+
+			UnhideSecondViewmodel();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Unhide the second viewmodel, in case we're switching from a single weapon
+//-----------------------------------------------------------------------------
+void CWeaponTwoHandedContainer::UnhideSecondViewmodel( void )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+	if ( pOwner )
+	{
+		CBaseViewModel *pVM = pOwner->GetViewModel(1);
+		if ( pVM )
+		{
+			pVM->RemoveEffects( EF_NODRAW );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Abort any reload we have in progress
+//-----------------------------------------------------------------------------
+void CWeaponTwoHandedContainer::AbortReload( void )
+{
+	BaseClass::AbortReload();
+
+	if ( m_hLeftWeapon )
+	{
+		m_hLeftWeapon->AbortReload();
+	}
+	if ( m_hRightWeapon )
+	{
+		m_hRightWeapon->AbortReload();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Return true if the left weapon has any ammo
+//-----------------------------------------------------------------------------
+bool CWeaponTwoHandedContainer::HasAnyAmmo( void )
+{
+	if ( m_hLeftWeapon )
+		return m_hLeftWeapon->HasAnyAmmo();
+
+	return BaseClass::HasAnyAmmo();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Deploy and start thinking
+//-----------------------------------------------------------------------------
+bool CWeaponTwoHandedContainer::Deploy( void )
+{
+	if ( !BaseClass::Deploy() )
+		return false;
+
+	if ( m_hLeftWeapon )
+	{
+		m_hLeftWeapon->Deploy();
+	}
+	if ( m_hRightWeapon )
+	{
+		m_hRightWeapon->Deploy();
+		UnhideSecondViewmodel();
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CBaseCombatWeapon *CWeaponTwoHandedContainer::GetLastWeapon( void )
+{
+	if ( m_hLeftWeapon )
+		return m_hLeftWeapon->GetLastWeapon();
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CWeaponTwoHandedContainer::GetDefaultAnimSpeed( void )
+{
+	if ( m_hLeftWeapon )
+		return m_hLeftWeapon->GetDefaultAnimSpeed();
+
+	return 1.0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stop thinking and holster
+//-----------------------------------------------------------------------------
+bool CWeaponTwoHandedContainer::Holster( CBaseCombatWeapon *pSwitchingTo )
+{
+	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
+
+	// If I'm holstering a weapon for another weapon that supports two-handed, just switch them out
+	CBaseTFCombatWeapon	*pWeapon = (CBaseTFCombatWeapon	*)pSwitchingTo;
+	if ( pWeapon && pWeapon->SupportsTwoHanded() )
+	{
+		// For now, holster the left weapon and switch it.
+		// In the future, we might want weapons to say which side they'd like to be on
+		SetWeapons( pWeapon, m_hRightWeapon );
+		
+		// We might need to force the new weapon to be in the right animation
+		if ( 0 ) //if ( m_hRightWeapon.Get() && m_hRightWeapon->IsReflectingAnimations() )
+		{
+			pWeapon->SendWeaponAnim( m_hRightWeapon->GetLastReflectedActivity() );
+		}
+
+		UnhideSecondViewmodel();
+		return false;
+	}
+
+	if ( m_hLeftWeapon )
+	{
+		m_hLeftWeapon->Holster(pSwitchingTo);
+	}
+	if ( m_hRightWeapon )
+	{
+		m_hRightWeapon->Holster(pSwitchingTo);
+	}
+
+	// We're changing to a single weapon, so hide the second viewmodel
+	if ( pOwner )
+	{
+		CBaseViewModel *pVM = pOwner->GetViewModel(1);
+		if ( pVM )
+		{
+			pVM->AddEffects( EF_NODRAW );
+		}
+	}
+
+	return BaseClass::Holster(pSwitchingTo);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the correct weight of our active weapon
+//-----------------------------------------------------------------------------
+int CWeaponTwoHandedContainer::GetWeight( void )
+{
+	if ( !m_hLeftWeapon )
+		return BaseClass::GetWeight();
+
+	return m_hLeftWeapon->GetWpnData().iWeight;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CBaseTFCombatWeapon
+//-----------------------------------------------------------------------------
+CBaseTFCombatWeapon *CWeaponTwoHandedContainer::GetLeftWeapon( void )
+{
+	return m_hLeftWeapon;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CBaseTFCombatWeapon
+//-----------------------------------------------------------------------------
+CBaseTFCombatWeapon *CWeaponTwoHandedContainer::GetRightWeapon( void )
+{
+	return m_hRightWeapon;
+}
+
+LINK_ENTITY_TO_CLASS( weapon_twohandedcontainer, CWeaponTwoHandedContainer );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( WeaponTwoHandedContainer , DT_WeaponTwoHandedContainer )
+BEGIN_NETWORK_TABLE( CWeaponTwoHandedContainer , DT_WeaponTwoHandedContainer )
+#if !defined( CLIENT_DLL )
+	SendPropEHandle( SENDINFO(m_hRightWeapon) ),
+	SendPropEHandle( SENDINFO(m_hLeftWeapon) ),
+#else
+	RecvPropEHandle( RECVINFO(m_hRightWeapon ) ),
+	RecvPropEHandle( RECVINFO(m_hLeftWeapon ) ),
+#endif
+END_NETWORK_TABLE()
+
+BEGIN_PREDICTION_DATA( CWeaponTwoHandedContainer  )
+
+	DEFINE_PRED_FIELD( m_hRightWeapon, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_hLeftWeapon, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+#if defined( CLIENT_DLL )
+	// DEFINE_FIELD( m_hOldRightWeapon, FIELD_EHANDLE ),
+	// DEFINE_FIELD( m_hOldLeftWeapon, FIELD_EHANDLE ),
+#endif
+
+END_PREDICTION_DATA()
+
+PRECACHE_WEAPON_REGISTER(weapon_twohandedcontainer);
diff --git a/game/shared/tf2/weapon_twohandedcontainer.h b/game/shared/tf2/weapon_twohandedcontainer.h
new file mode 100644
index 0000000..04cd942
--- /dev/null
+++ b/game/shared/tf2/weapon_twohandedcontainer.h
@@ -0,0 +1,97 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef WEAPON_TWOHANDEDCONTAINER_H
+#define WEAPON_TWOHANDEDCONTAINER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "basetfcombatweapon_shared.h"
+#include "baseviewmodel_shared.h"
+#include "studio.h"
+
+#if defined( CLIENT_DLL )
+#define CWeaponTwoHandedContainer C_WeaponTwoHandedContainer
+#endif
+
+class CBaseViewModel;
+
+//-----------------------------------------------------------------------------
+// Purpose: Client side rep of CBaseTFCombatWeapon 
+//-----------------------------------------------------------------------------
+class CWeaponTwoHandedContainer : public CBaseTFCombatWeapon
+{
+	DECLARE_CLASS( CWeaponTwoHandedContainer, CBaseTFCombatWeapon );
+public:
+	DECLARE_NETWORKCLASS();
+	DECLARE_PREDICTABLE();
+
+	CWeaponTwoHandedContainer();
+	~CWeaponTwoHandedContainer();
+
+	virtual void	Spawn( void );
+	virtual void	ItemPostFrame( void );
+	virtual void	ItemBusyFrame( void );
+	virtual void	SetWeapons( CBaseTFCombatWeapon *left, CBaseTFCombatWeapon *right );
+	virtual void	UnhideSecondViewmodel( void );
+	virtual void	AbortReload( void );
+	virtual bool	HasAnyAmmo( void );
+	virtual bool	Deploy( void );
+	virtual bool	Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
+	virtual CBaseCombatWeapon *GetLastWeapon( void );
+	virtual int		GetWeight( void );
+
+	virtual const char *GetViewModel( int viewmodelindex = 0 );
+	virtual char	   *GetDeathNoticeName( void );
+	virtual float	GetDefaultAnimSpeed( void );
+
+	// All predicted weapons need to implement and return true
+	virtual bool			IsPredicted( void ) const
+	{ 
+		return true;
+	}
+
+#if defined( CLIENT_DLL )
+
+	virtual bool OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
+	virtual void GetViewmodelBoneControllers( CBaseViewModel *pViewModel, float controllers[MAXSTUDIOBONECTRLS]);
+
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+
+	virtual bool ShouldDraw( void );
+	virtual void Redraw(void);
+	virtual void DrawAmmo( void );
+	virtual void HandleInput( void );
+	virtual void OverrideMouseInput( float *x, float *y );
+	virtual void ViewModelDrawn( CBaseViewModel *pBaseViewModel );
+	void		 HookWeaponEntities( void );
+	virtual bool VisibleInWeaponSelection( void );
+
+private:
+	CWeaponTwoHandedContainer( const CWeaponTwoHandedContainer & );
+public:
+
+#else
+	
+	virtual void SetTransmit( CCheckTransmitInfo *pInfo, bool bAlways );
+
+#endif
+
+	CBaseTFCombatWeapon		*GetLeftWeapon( void );
+	CBaseTFCombatWeapon		*GetRightWeapon( void );
+
+public:
+	CNetworkHandle( CBaseTFCombatWeapon, m_hRightWeapon );
+	CNetworkHandle( CBaseTFCombatWeapon, m_hLeftWeapon );
+#if defined( CLIENT_DLL )
+	CHandle<CBaseTFCombatWeapon>	m_hOldRightWeapon;
+	CHandle<CBaseTFCombatWeapon>	m_hOldLeftWeapon;
+#endif
+};
+
+#endif // WEAPON_TWOHANDEDCONTAINER_H