1HEADmaster

1 files changed, 2441 insertions, 0 deletions

diff --git a/game/server/tf/tf_obj_sentrygun.cpp b/game/server/tf/tf_obj_sentrygun.cpp
new file mode 100644
index 0000000..20a1786
--- /dev/null
+++ b/game/server/tf/tf_obj_sentrygun.cpp
@@ -0,0 +1,2441 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Engineer's Sentrygun OMG
+//
+// $NoKeywords: $
+//=============================================================================//
+#include "cbase.h"
+
+#include "tf_obj_sentrygun.h"
+#include "engine/IEngineSound.h"
+#include "tf_player.h"
+#include "tf_team.h"
+#include "world.h"
+#include "tf_projectile_rocket.h"
+#include "te_effect_dispatch.h"
+#include "tf_gamerules.h"
+#include "ammodef.h"
+#include "tf_weapon_wrench.h"
+#include "tf_weapon_laser_pointer.h"
+#include "tf_weapon_shotgun.h"
+#include "bot/map_entities/tf_bot_hint_sentrygun.h"
+#include "bot/tf_bot.h"
+#include "nav_mesh/tf_nav_mesh.h"
+#include "nav_pathfind.h"
+#include "tf_weapon_knife.h"
+#include "tf_logic_robot_destruction.h"
+#include "tf_target_dummy.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+extern bool IsInCommentaryMode();
+
+extern ConVar tf_nav_in_combat_range;
+
+// Ground placed version
+#define SENTRY_MODEL_PLACEMENT			"models/buildables/sentry1_blueprint.mdl"
+#define SENTRY_MODEL_LEVEL_1			"models/buildables/sentry1.mdl"
+#define SENTRY_MODEL_LEVEL_1_UPGRADE	"models/buildables/sentry1_heavy.mdl"
+#define SENTRY_MODEL_LEVEL_2			"models/buildables/sentry2.mdl"
+#define SENTRY_MODEL_LEVEL_2_UPGRADE	"models/buildables/sentry2_heavy.mdl"
+#define SENTRY_MODEL_LEVEL_3			"models/buildables/sentry3.mdl"
+#define SENTRY_MODEL_LEVEL_3_UPGRADE	"models/buildables/sentry3_heavy.mdl"
+
+#define SENTRY_ROCKET_MODEL "models/buildables/sentry3_rockets.mdl"
+
+#define SENTRYGUN_MINS			Vector(-20, -20, 0)
+#define SENTRYGUN_MAXS			Vector( 20,  20, 66)
+
+#define SENTRYGUN_ADD_SHELLS	40
+#define SENTRYGUN_ADD_ROCKETS	8
+
+#define SENTRY_THINK_DELAY	0.05
+
+#define	SENTRYGUN_CONTEXT	"SentrygunContext"
+
+#define SENTRYGUN_RECENTLY_ATTACKED_TIME 2.0
+
+#define SENTRYGUN_MINIGUN_RESIST_LVL_1		0.0
+#define SENTRYGUN_MINIGUN_RESIST_LVL_2		0.15
+#define SENTRYGUN_MINIGUN_RESIST_LVL_3		0.20
+
+#define SENTRYGUN_SAPPER_OWNER_DAMAGE_MODIFIER	0.66f
+
+#define SENTRYGUN_MAX_LEVEL_MINI			1
+#define MINI_SENTRY_SCALE			0.75f
+#define DISPOSABLE_SCALE			0.65f
+#define SMALL_SENTRY_SCALE			0.80f
+
+#define WRANGLER_DISABLE_TIME		3.0f
+
+enum
+{	
+	SENTRYGUN_ATTACHMENT_MUZZLE = 0,
+	SENTRYGUN_ATTACHMENT_MUZZLE_ALT,
+	SENTRYGUN_ATTACHMENT_ROCKET,
+};
+
+enum target_ranges
+{
+	RANGE_MELEE,
+	RANGE_NEAR,
+	RANGE_MID,
+	RANGE_FAR,
+};
+
+#define VECTOR_CONE_TF_SENTRY		Vector( 0.1, 0.1, 0 )
+
+//-----------------------------------------------------------------------------
+// Purpose: Only send the LocalWeaponData to the player carrying the weapon
+//-----------------------------------------------------------------------------
+void* SendProxy_SendLocalObjectDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
+{
+	// Get the weapon entity
+	CBaseObject *pObject = (CBaseObject*)pVarData;
+	if ( pObject )
+	{
+		// Only send this chunk of data to the player carrying this weapon
+		CBasePlayer *pPlayer = ToBasePlayer( pObject->GetOwner() );
+		if ( pPlayer )
+		{
+			pRecipients->SetOnly( pPlayer->GetClientIndex() );
+			return (void*)pVarData;
+		}
+	}
+
+	return NULL;
+}
+REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendLocalObjectDataTable );
+
+BEGIN_NETWORK_TABLE_NOBASE( CObjectSentrygun, DT_SentrygunLocalData )
+	SendPropInt( SENDINFO(m_iKills), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
+	SendPropInt( SENDINFO(m_iAssists), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
+END_NETWORK_TABLE()
+
+IMPLEMENT_SERVERCLASS_ST( CObjectSentrygun, DT_ObjectSentrygun )
+	SendPropInt( SENDINFO(m_iAmmoShells), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
+	SendPropInt( SENDINFO(m_iAmmoRockets), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
+	SendPropInt( SENDINFO(m_iState), Q_log2( SENTRY_NUM_STATES ) + 1, SPROP_UNSIGNED ),
+	SendPropBool( SENDINFO( m_bPlayerControlled ) ),
+	SendPropInt( SENDINFO( m_nShieldLevel ), 4, SPROP_UNSIGNED ),
+	SendPropEHandle( SENDINFO( m_hEnemy ) ),
+	SendPropEHandle( SENDINFO( m_hAutoAimTarget ) ),
+	SendPropDataTable( "SentrygunLocalData", 0, &REFERENCE_SEND_TABLE( DT_SentrygunLocalData ), SendProxy_SendLocalObjectDataTable ),
+END_SEND_TABLE()
+
+BEGIN_DATADESC( CObjectSentrygun )
+END_DATADESC()
+
+LINK_ENTITY_TO_CLASS(obj_sentrygun, CObjectSentrygun);
+PRECACHE_REGISTER(obj_sentrygun);
+
+ConVar tf_sentrygun_damage( "tf_sentrygun_damage", "16", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+ConVar tf_sentrygun_mini_damage( "tf_sentrygun_mini_damage", "8", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+ConVar tf_sentrygun_ammocheat( "tf_sentrygun_ammocheat", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+extern ConVar tf_obj_upgrade_per_hit;
+ConVar tf_sentrygun_newtarget_dist( "tf_sentrygun_newtarget_dist", "200", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+ConVar tf_sentrygun_metal_per_shell( "tf_sentrygun_metal_per_shell", "1", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+ConVar tf_sentrygun_metal_per_rocket( "tf_sentrygun_metal_per_rocket", "2", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+ConVar tf_sentrygun_notarget( "tf_sentrygun_notarget", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+ConVar tf_sentrygun_max_absorbed_damage_while_controlled_for_achievement( "tf_sentrygun_max_absorbed_damage_while_controlled_for_achievement", "500", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+ConVar tf_sentrygun_kill_after_redeploy_time_achievement( "tf_sentrygun_kill_after_redeploy_time_achievement", "10", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+extern ConVar tf_cheapobjects;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CObjectSentrygun::CObjectSentrygun()
+{
+	// Don't bother with health modifying attributes here, because we don't have an owner yet, and it'll be stomped in FirstSpawn()
+	int iHealth = GetMaxHealthForCurrentLevel();
+	SetMaxHealth( iHealth );
+	SetHealth( iHealth );
+	SetType( OBJ_SENTRYGUN );
+
+	m_bFireNextFrame = false;
+	m_bFireRocketNextFrame = false;
+	m_flAutoAimStartTime = 0.f;
+	m_bPlayerControlled = false;
+	m_iLifetimeShieldedDamage = 0;
+	m_flFireRate = 1.f;
+	m_flSentryRange = SENTRY_MAX_RANGE;
+	m_nShieldLevel.Set( SHIELD_NONE );
+
+	m_lastTeammateWrenchHit = NULL;
+	m_lastTeammateWrenchHitTimer.Invalidate();
+
+	m_flScaledSentry = 1.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::Spawn()
+{
+	m_iPitchPoseParameter = -1;
+	m_iYawPoseParameter = -1;
+
+	SetModel( SENTRY_MODEL_PLACEMENT );
+
+	// Rotate Details
+	m_iRightBound = 45;
+	m_iLeftBound = 315;
+	m_iBaseTurnRate = 6;
+	m_flFieldOfView = VIEW_FIELD_NARROW;
+
+	// Give the Gun some ammo
+	m_iAmmoShells = 0;
+	m_iAmmoRockets = 0;
+
+	float flMaxAmmoMult = 1.f;
+	if ( GetOwner() )
+	{
+		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), flMaxAmmoMult, mvm_sentry_ammo );
+	}
+
+	m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_1 * flMaxAmmoMult;
+	m_iMaxAmmoRockets = SENTRYGUN_MAX_ROCKETS * flMaxAmmoMult;
+
+	m_iAmmoType = GetAmmoDef()->Index( "TF_AMMO_PRIMARY" );
+
+	// Start searching for enemies
+	m_hEnemy = NULL;
+
+	m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_1;
+
+	m_lastTeammateWrenchHit = NULL;
+	m_lastTeammateWrenchHitTimer.Invalidate();
+
+	BaseClass::Spawn();
+
+	SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_1 );
+
+	SetBuildingSize();
+
+	m_iState.Set( SENTRY_STATE_INACTIVE );
+
+	SetContextThink( &CObjectSentrygun::SentryThink, gpGlobals->curtime + SENTRY_THINK_DELAY, SENTRYGUN_CONTEXT );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::FirstSpawn()
+{
+	m_flLastAttackedTime = 0;
+
+	int iHealth = GetMaxHealthForCurrentLevel();
+
+	SetMaxHealth( iHealth );
+	SetHealth( iHealth );
+
+	BaseClass::FirstSpawn();
+}
+
+Vector CObjectSentrygun::GetEnemyAimPosition( CBaseEntity* pEnemy ) const
+{
+	// Default to pointing to the origin
+	Vector vecPos = pEnemy->WorldSpaceCenter();
+
+	CTFPlayer* pTFEnemy = ToTFPlayer( pEnemy );
+
+	// This is expensive, so only do it if our target is in a state that requires it
+	if ( pTFEnemy )
+	{
+		bool bShouldUseAccurateMethod = false; 
+
+		int playerFlags = pTFEnemy->GetFlags();
+		// Crouch jumping makes your box weird
+		bShouldUseAccurateMethod |= !( playerFlags & FL_ONGROUND ) && ( playerFlags & FL_DUCKING );
+		// Taunting can make your box weird
+		bShouldUseAccurateMethod |= pTFEnemy->m_Shared.InCond( TF_COND_TAUNTING );
+
+		if ( bShouldUseAccurateMethod )
+		{
+			// Use this bone as the the aim target
+			int iSpineBone = pTFEnemy->LookupBone( "bip_spine_2" );
+			if ( iSpineBone != -1 )
+			{
+				QAngle angles;
+				pTFEnemy->GetBonePosition( iSpineBone, vecPos, angles );
+			}
+		}
+	}
+
+	return vecPos;
+}
+
+void CObjectSentrygun::SentryThink( void )
+{
+	m_flSentryRange = SENTRY_MAX_RANGE;
+	if ( !IsDisposableBuilding() )
+	{
+		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), m_flSentryRange, mult_sentry_range );
+	}
+
+	switch( m_iState )
+	{
+	case SENTRY_STATE_INACTIVE:
+	case SENTRY_STATE_UPGRADING:		// Base class handles this
+		break;
+
+	case SENTRY_STATE_SEARCHING:
+		SentryRotate();
+		break;
+
+	case SENTRY_STATE_ATTACKING:
+		Attack();
+		break;
+
+	default:
+		Assert( 0 );
+		break;
+	}
+
+	SetContextThink( &CObjectSentrygun::SentryThink, gpGlobals->curtime + SENTRY_THINK_DELAY, SENTRYGUN_CONTEXT );
+
+	if ( m_nShieldLevel > 0 && (gpGlobals->curtime > m_flShieldFadeTime) )
+	{
+		m_nShieldLevel.Set( SHIELD_NONE );
+		m_vecGoalAngles.x = 0;
+	}
+
+	// infinite ammo for enemy team in MvM mode
+	if ( TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
+	{
+		m_iAmmoRockets = SENTRYGUN_MAX_ROCKETS;
+		m_iMaxAmmoRockets = SENTRYGUN_MAX_ROCKETS;
+		m_iAmmoShells = SENTRYGUN_MAX_SHELLS_3;
+		m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_3;
+	}
+}
+
+void CObjectSentrygun::StartPlacement( CTFPlayer *pPlayer )
+{
+	BaseClass::StartPlacement( pPlayer );
+
+	// Set my build size
+	m_vecBuildMins = SENTRYGUN_MINS;
+	m_vecBuildMaxs = SENTRYGUN_MAXS;
+	m_vecBuildMins -= Vector( 4,4,0 );
+	m_vecBuildMaxs += Vector( 4,4,0 );
+
+	MakeMiniBuilding( pPlayer );
+	MakeDisposableBuilding( pPlayer );
+	MakeScaledBuilding( GetBuilder() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Start building the object
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::StartBuilding( CBaseEntity *pBuilder )
+{
+	SetStartBuildingModel();
+
+	// Have to re-call this in case the player changed their weapon
+	// between StartPlacement and StartBuilding.
+	MakeMiniBuilding( GetBuilder() );
+	MakeDisposableBuilding( GetBuilder() );
+	MakeScaledBuilding( GetBuilder() );
+
+	if ( IsMiniBuilding() )
+	{
+		SetBodygroup( FindBodygroupByName( "mini_sentry_light" ), 1 );
+	}
+
+	CreateBuildPoints();
+
+	SetPoseParameter( m_iPitchPoseParameter, 0.0 );
+	SetPoseParameter( m_iYawPoseParameter, 0.0 );
+
+	SetObjectMode( IsDisposableBuilding() ? MODE_SENTRYGUN_DISPOSABLE : MODE_SENTRYGUN_NORMAL );
+
+	return BaseClass::StartBuilding( pBuilder );
+}
+
+void CObjectSentrygun::SetStartBuildingModel( void )
+{
+	SetModel( SENTRY_MODEL_LEVEL_1_UPGRADE );
+	m_iState.Set( SENTRY_STATE_INACTIVE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::MakeMiniBuilding( CTFPlayer* pPlayer )
+{
+	if ( !ShouldBeMiniBuilding( pPlayer ) || IsMiniBuilding() )
+		return;
+
+	BaseClass::MakeMiniBuilding( pPlayer );
+	SetModelScale( MINI_SENTRY_SCALE );
+
+	int iHealth = GetMaxHealthForCurrentLevel();
+
+	SetMaxHealth( iHealth );
+	SetHealth( iHealth / 2.0f );
+	SetBuildingSize();
+}
+
+//-----------------------------------------------------------------------------
+int CObjectSentrygun::GetMaxUpgradeLevel( )
+{ 
+	if ( IsDisposableBuilding() || IsMiniBuilding() )
+		return SENTRYGUN_MAX_LEVEL_MINI;
+
+	return BaseClass::GetMaxUpgradeLevel(); 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::OnGoActive( void )
+{
+	SetModel( SENTRY_MODEL_LEVEL_1 );
+
+	if ( IsMiniBuilding() )
+	{
+		SetBodygroup( FindBodygroupByName( "mini_sentry_light" ), 1 );
+	}
+
+	m_iState.Set( SENTRY_STATE_SEARCHING );
+
+	// Orient it
+	QAngle angles = GetAbsAngles();
+
+	m_vecCurAngles.y = UTIL_AngleMod( angles.y );
+	m_iRightBound = UTIL_AngleMod( (int)angles.y - 50 );
+	m_iLeftBound = UTIL_AngleMod( (int)angles.y + 50 );
+	if ( m_iRightBound > m_iLeftBound )
+	{
+		m_iRightBound = m_iLeftBound;
+		m_iLeftBound = UTIL_AngleMod( (int)angles.y - 50);
+	}
+
+	// Start it rotating
+	m_vecGoalAngles.y = m_iRightBound;
+	m_vecGoalAngles.x = m_vecCurAngles.x = 0;
+	m_bTurningRight = true;
+
+	EmitSound( "Building_Sentrygun.Built" );
+
+	// if our eye pos is underwater, we're waterlevel 3, else 0
+	bool bUnderwater = ( UTIL_PointContents( EyePosition() ) & MASK_WATER ) ? true : false;
+	SetWaterLevel( ( bUnderwater ) ? 3 : 0 );	
+
+	if ( m_bCarryDeploy )
+	{
+		m_iAmmoShells = m_iOldAmmoShells;
+		m_iAmmoRockets = m_iOldAmmoRockets;
+	}
+	else
+	{
+		m_iAmmoShells = m_iMaxAmmoShells;
+		m_iAmmoRockets = m_iMaxAmmoRockets;
+	}
+
+	// Init attachments for level 1 sentry gun
+	m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE] = LookupAttachment( "muzzle" );
+	m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE_ALT] = 0;
+	m_iAttachments[SENTRYGUN_ATTACHMENT_ROCKET] = 0;
+
+	BaseClass::OnGoActive();
+
+	IGameEvent * event = gameeventmanager->CreateEvent( "sentry_on_go_active" );
+	if ( event )
+	{
+		event->SetInt( "index", entindex() );	// object entity index
+
+		gameeventmanager->FireEvent( event, true );	// don't send to clients
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::Precache()
+{
+	BaseClass::Precache();
+
+	int iModelIndex;
+
+	// Models
+	PrecacheModel( SENTRY_MODEL_PLACEMENT );
+
+	iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_1 );
+	PrecacheGibsForModel( iModelIndex );
+
+	iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_1_UPGRADE );
+	PrecacheGibsForModel( iModelIndex );
+
+	iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_2 );
+	PrecacheGibsForModel( iModelIndex );
+
+	iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_2_UPGRADE );
+	PrecacheGibsForModel( iModelIndex );
+
+	iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_3 );
+	PrecacheGibsForModel( iModelIndex );
+
+	iModelIndex = PrecacheModel( SENTRY_MODEL_LEVEL_3_UPGRADE );
+	PrecacheGibsForModel( iModelIndex );
+
+	PrecacheModel( SENTRY_ROCKET_MODEL );
+	PrecacheModel( "models/effects/sentry1_muzzle/sentry1_muzzle.mdl" );
+
+	PrecacheModel( "models/buildables/sentry_shield.mdl" );
+
+	// Sounds
+	PrecacheScriptSound( "Building_Sentrygun.Fire" );
+	PrecacheScriptSound( "Building_Sentrygun.Fire2" );	// level 2 sentry
+	PrecacheScriptSound( "Building_Sentrygun.Fire3" );	// level 3 sentry
+	PrecacheScriptSound( "Building_Sentrygun.FireRocket" );
+	PrecacheScriptSound( "Building_Sentrygun.Alert" );
+	PrecacheScriptSound( "Building_Sentrygun.AlertTarget" );
+	PrecacheScriptSound( "Building_Sentrygun.Idle" );
+	PrecacheScriptSound( "Building_Sentrygun.Idle2" );	// level 2 sentry
+	PrecacheScriptSound( "Building_Sentrygun.Idle3" );	// level 3 sentry
+	PrecacheScriptSound( "Building_Sentrygun.Built" );
+	PrecacheScriptSound( "Building_Sentrygun.Empty" );
+	PrecacheScriptSound( "Building_Sentrygun.ShaftFire" );
+	PrecacheScriptSound( "Building_Sentrygun.ShaftFire2" );
+	PrecacheScriptSound( "Building_Sentrygun.ShaftFire3" );
+	PrecacheScriptSound( "Building_Sentrygun.ShaftLaserPass" );
+	PrecacheScriptSound( "Building_MiniSentrygun.Fire" );
+
+	PrecacheParticleSystem( "sentrydamage_1" );
+	PrecacheParticleSystem( "sentrydamage_2" );
+	PrecacheParticleSystem( "sentrydamage_3" );
+	PrecacheParticleSystem( "sentrydamage_4" );
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::CanBeUpgraded( CTFPlayer *pPlayer )
+{
+	if ( m_bWasMapPlaced && !HasSpawnFlags(SF_SENTRY_UPGRADEABLE) )
+	{
+		return false;
+	}
+
+	return BaseClass::CanBeUpgraded( pPlayer );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Raises the Sentrygun one level
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::StartUpgrading( void )
+{
+	BaseClass::StartUpgrading();
+
+	float flMaxAmmoMult = 1.f;
+	if ( GetOwner() )
+	{
+		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), flMaxAmmoMult, mvm_sentry_ammo );
+	}
+
+	switch( m_iUpgradeLevel )
+	{
+	case 2:
+		SetModel( SENTRY_MODEL_LEVEL_2_UPGRADE );
+		m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_2;
+		SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_2 );
+		m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_2 * flMaxAmmoMult;
+		break;
+	case 3:
+		SetModel( SENTRY_MODEL_LEVEL_3_UPGRADE );
+		if ( !m_bCarryDeploy )
+		{
+			m_iAmmoRockets = SENTRYGUN_MAX_ROCKETS;
+		}
+		m_flHeavyBulletResist = SENTRYGUN_MINIGUN_RESIST_LVL_3;
+		SetViewOffset( SENTRYGUN_EYE_OFFSET_LEVEL_3 );
+		m_iMaxAmmoShells = SENTRYGUN_MAX_SHELLS_3 * flMaxAmmoMult;
+		break;
+	default:
+		Assert(0);
+		break;
+	}
+
+	// more ammo capability
+	if ( !m_bCarryDeploy )
+	{
+		m_iAmmoShells = m_iMaxAmmoShells;
+	}
+
+	m_iState.Set( SENTRY_STATE_UPGRADING );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::FinishUpgrading( void )
+{
+	BaseClass::FinishUpgrading();
+
+	m_iState.Set( SENTRY_STATE_SEARCHING );
+	m_hEnemy = NULL;
+
+	switch( m_iUpgradeLevel )
+	{
+	case 1:
+		// This can happen when a saper downgrades a sentry
+		// No need to do anything here
+		break;
+	case 2:
+		SetModel( SENTRY_MODEL_LEVEL_2 );
+		break;
+	case 3:
+		SetModel( SENTRY_MODEL_LEVEL_3 );
+		break;
+	default:
+		Assert(0);
+		break;
+	}
+
+	// Look up the new attachments
+	m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE] = LookupAttachment( "muzzle_l" );
+	m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE_ALT] = LookupAttachment( "muzzle_r" );
+	m_iAttachments[SENTRYGUN_ATTACHMENT_ROCKET] = LookupAttachment( "rocket_l" );
+}
+
+//-----------------------------------------------------------------------------
+// Hit by a friendly engineer's wrench
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::OnWrenchHit( CTFPlayer *pPlayer, CTFWrench *pWrench, Vector hitLoc )
+{
+	if ( IsDisposableBuilding() )
+		return false;
+
+	bool bDidWork = false;
+
+	// If the player repairs it at all, we're done
+	if ( GetHealth() < GetMaxHealth() )
+	{
+		// STAGING_ENGY
+		// Mod repair value by shield value
+		float flRepairValue = pWrench->GetRepairValue();
+		if ( m_nShieldLevel == SHIELD_NORMAL )
+		{
+			flRepairValue *= SHIELD_NORMAL_VALUE;
+		}
+		
+		if ( Command_Repair( pPlayer, flRepairValue ) )
+		{
+			DoWrenchHitEffect( hitLoc, true, false );
+			bDidWork = true;
+		}
+	}
+
+	// Don't put in upgrade metal until the sentry is fully healed
+	if ( !bDidWork )
+	{
+		if ( CheckUpgradeOnHit( pPlayer ) )
+		{
+			DoWrenchHitEffect( hitLoc, false, true );
+			bDidWork = true;
+		}
+	}
+
+	if ( !IsUpgrading() )
+	{
+		// player ammo into rockets
+		//	1 ammo = 1 shell
+		//  2 ammo = 1 rocket
+		//  only fill rockets if we have extra shells
+
+		int iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
+
+		// If the sentry has less that 100% ammo, put some ammo in it
+		if ( m_iAmmoShells < m_iMaxAmmoShells && iPlayerMetal > 0 )
+		{
+			int iMaxShellsPlayerCanAfford = (int)( (float)iPlayerMetal / tf_sentrygun_metal_per_shell.GetFloat() );
+
+			// cap the amount we can add
+			int iAmountToAdd = MIN( SENTRYGUN_ADD_SHELLS, iMaxShellsPlayerCanAfford );
+			iAmountToAdd = MIN( ( m_iMaxAmmoShells - m_iAmmoShells ), iAmountToAdd );
+
+			// STAGING_ENGY
+			// Mod Ammo if shielded
+			if ( m_nShieldLevel == SHIELD_NORMAL )
+			{
+				iAmountToAdd *= SHIELD_NORMAL_VALUE;
+			}
+
+			pPlayer->RemoveAmmo( iAmountToAdd * tf_sentrygun_metal_per_shell.GetInt(), TF_AMMO_METAL );
+			m_iAmmoShells += iAmountToAdd;
+
+			if ( iAmountToAdd > 0 )
+			{
+				bDidWork = true;
+			}
+		}
+
+		// One rocket per two ammo
+		iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
+
+		if ( m_iAmmoRockets < m_iMaxAmmoRockets && m_iUpgradeLevel == 3 && iPlayerMetal > 0  )
+		{
+			int iMaxRocketsPlayerCanAfford = (int)( (float)iPlayerMetal / tf_sentrygun_metal_per_rocket.GetFloat() );
+
+			int iAmountToAdd = MIN( ( SENTRYGUN_ADD_ROCKETS ), iMaxRocketsPlayerCanAfford );
+			iAmountToAdd = MIN( ( m_iMaxAmmoRockets - m_iAmmoRockets ), iAmountToAdd );
+
+			// STAGING_ENGY
+			// Mod Ammo if shielded
+			if ( m_nShieldLevel == SHIELD_NORMAL )
+			{
+				iAmountToAdd *= SHIELD_NORMAL_VALUE;
+			}
+
+			pPlayer->RemoveAmmo( iAmountToAdd * tf_sentrygun_metal_per_rocket.GetFloat(), TF_AMMO_METAL );
+			m_iAmmoRockets += iAmountToAdd;
+
+			if ( iAmountToAdd > 0 )
+			{
+				bDidWork = true;
+			}
+		}
+	}
+
+	if ( GetOwner() != pPlayer )
+	{
+		if ( bDidWork && m_bPlayerControlled )
+		{
+			pPlayer->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_HELP_MANUAL_SENTRY, 1 );
+		}
+
+		// keep track of who last hit us with a wrench for kill assists
+		m_lastTeammateWrenchHit = pPlayer;
+		m_lastTeammateWrenchHitTimer.Start();
+	}
+
+	return bDidWork;
+}
+
+//-----------------------------------------------------------------------------
+// Debug infos
+//-----------------------------------------------------------------------------
+int CObjectSentrygun::DrawDebugTextOverlays(void) 
+{
+	int text_offset = BaseClass::DrawDebugTextOverlays();
+
+	if (m_debugOverlays & OVERLAY_TEXT_BIT) 
+	{
+		char tempstr[512];
+
+		Q_snprintf( tempstr, sizeof( tempstr ), "Level: %d", m_iUpgradeLevel.Get() );
+		EntityText(text_offset,tempstr,0);
+		text_offset++;
+
+		Q_snprintf( tempstr, sizeof( tempstr ), "Shells: %d / %d", m_iAmmoShells.Get(), m_iMaxAmmoShells.Get() );
+		EntityText(text_offset,tempstr,0);
+		text_offset++;
+
+		if ( m_iUpgradeLevel == 3 )
+		{
+			Q_snprintf( tempstr, sizeof( tempstr ), "Rockets: %d / %d", m_iAmmoRockets.Get(), m_iMaxAmmoRockets.Get() );
+			EntityText(text_offset,tempstr,0);
+			text_offset++;
+		}
+
+		Q_snprintf( tempstr, sizeof( tempstr ), "Upgrade metal %d", m_iUpgradeMetal.Get() );
+		EntityText(text_offset,tempstr,0);
+		text_offset++;
+
+		Vector vecSrc = EyePosition();
+		Vector forward;
+
+		// m_vecCurAngles
+		AngleVectors( m_vecCurAngles, &forward );
+		NDebugOverlay::Line( vecSrc, vecSrc + forward * 200, 0, 255, 0, false, 0.1 );
+
+		// m_vecGoalAngles
+		AngleVectors( m_vecGoalAngles, &forward );
+		NDebugOverlay::Line( vecSrc, vecSrc + forward * 200, 0, 0, 255, false, 0.1 );
+	}
+
+	return text_offset;
+}
+
+//-----------------------------------------------------------------------------
+// Returns the sentry targeting range the target is in
+//-----------------------------------------------------------------------------
+int CObjectSentrygun::Range( CBaseEntity *pTarget )
+{
+	Vector vecOrg = EyePosition();
+	Vector vecTargetOrg = pTarget->EyePosition();
+
+	int iDist = ( vecTargetOrg - vecOrg ).Length();
+
+	if (iDist < 132)
+		return RANGE_MELEE;
+	if (iDist < 550)
+		return RANGE_NEAR;
+	if (iDist < m_flSentryRange)
+		return RANGE_MID;
+	return RANGE_FAR;
+}
+
+//-----------------------------------------------------------------------------
+// Look for a target
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::FindTarget()
+{
+	if ( m_bPlayerControlled )
+	{
+		m_flShieldFadeTime = gpGlobals->curtime + WRANGLER_DISABLE_TIME;
+	}
+	m_bPlayerControlled = false;
+
+	// Disable the sentry guns for ifm.
+	if ( tf_sentrygun_notarget.GetBool() )
+		return false;
+
+	if ( IsInCommentaryMode() )
+		return false;
+
+	// Sapper, etc.
+	if ( IsDisabled() )
+		return false;
+
+	// Loop through players within SENTRY_MAX_RANGE units (sentry range).
+	Vector vecSentryOrigin = EyePosition();
+
+	// find the enemy team
+	int iEnemyTeam = ( GetTeamNumber() == TF_TEAM_BLUE ) ? TF_TEAM_RED : TF_TEAM_BLUE;
+	CTFTeam *pTeam = TFTeamMgr()->GetTeam( iEnemyTeam );
+	if ( !pTeam )
+		return false;
+
+	// If we have an enemy get his minimum distance to check against.
+	Vector vecSegment;
+	Vector vecTargetCenter;
+	float flMinDist2 = m_flSentryRange * m_flSentryRange;
+	CBaseEntity *pTargetCurrent = NULL;
+	CBaseEntity *pTargetOld = m_hEnemy.Get();
+	float flOldTargetDist2 = FLT_MAX;
+	bool bDummyTarget = false;
+
+	// Sentry Decoy
+	// If we already have a sentry decoy target, keep shooting at it
+	// Otherwise look for a sentry decoy's first
+	if ( pTargetCurrent == NULL )
+	{
+		CTFTargetDummy *pDummy = dynamic_cast<CTFTargetDummy*>( pTargetOld );
+		if ( pDummy )
+		{
+			pTargetCurrent = pDummy;
+			bDummyTarget = true;
+		}
+		else
+		{
+			// Search through all dummies and find one in range
+			for ( int i = 0; i < ITFTargetDummy::AutoList().Count(); ++i )
+			{
+				pDummy = static_cast<CTFTargetDummy*>( ITFTargetDummy::AutoList()[i] );
+				if ( InSameTeam( pDummy ) )
+					continue;
+
+				vecTargetCenter = pDummy->GetAbsOrigin();
+				vecTargetCenter += pDummy->GetViewOffset();
+				VectorSubtract( vecTargetCenter, vecSentryOrigin, vecSegment );
+				float flDist2 = vecSegment.LengthSqr();
+
+				// Check to see if the target is closer than the already validated target.
+				if ( flDist2 > flMinDist2 )
+					continue;
+
+				// Ray trace!!!
+				if ( FVisible( pDummy, MASK_SHOT | CONTENTS_GRATE ) )
+				{
+					pTargetCurrent = pDummy;
+					bDummyTarget = true;
+				}
+			}
+		}
+	}
+
+	// If our builder has an active laser pointer we don't seek targets.
+	CTFPlayer* pBuilder = GetBuilder();
+	if ( pBuilder )
+	{
+		// CTFLaserPointer* pPointer = static_cast<CTFLaserPointer*>( pBuilder->Weapon_OwnsThisID( TF_WEAPON_LASER_POINTER ) );
+		// FIX ME:  Temp fix until we find out why the pointer thinks its deployed after spawn
+		CTFLaserPointer* pPointer = dynamic_cast<CTFLaserPointer*>( pBuilder->GetActiveWeapon() );
+		if ( pPointer && pPointer->HasLaserDot() && !IsDisposableBuilding() )
+		{
+			m_bPlayerControlled = true;
+			m_nShieldLevel.Set( SHIELD_NORMAL );
+			m_flShieldFadeTime = gpGlobals->curtime + WRANGLER_DISABLE_TIME;
+
+			// If not target dummy, use laserdot, otherwise targetdummy overrides
+			if ( !bDummyTarget || !pTargetCurrent )
+			{
+				pTargetCurrent = pPointer->GetLaserDot();
+
+				// Are we in our brief auto aim period?
+				float flAutoAimTime = gpGlobals->curtime - m_flAutoAimStartTime;
+				if ( m_hAutoAimTarget && (flAutoAimTime < 0.2f) )
+				{
+					// Only use the auto aim target if we can actually range to him.
+					Vector vecSrc;
+					QAngle vecAng;
+					GetAttachment( GetFireAttachment(), vecSrc, vecAng );
+					Vector vecEnemy = GetEnemyAimPosition( m_hAutoAimTarget );
+					trace_t	trace;
+					CTraceFilterIgnoreTeammatesAndTeamObjects filter( pBuilder, COLLISION_GROUP_NONE, pBuilder->GetTeamNumber() );
+					UTIL_TraceLine( vecSrc, vecEnemy, MASK_SOLID, &filter, &trace );
+					if ( trace.m_pEnt == m_hAutoAimTarget )
+					{
+						pTargetCurrent = m_hAutoAimTarget;
+					}
+					else
+					{
+						m_hAutoAimTarget = NULL;
+					}
+				}
+				else
+				{
+					m_hAutoAimTarget = NULL;
+				}
+			}
+
+			if ( pTargetCurrent->GetAbsOrigin().DistTo( vecSentryOrigin ) > 30.f )
+			{
+				if ( pTargetCurrent != pTargetOld )
+				{
+					FoundTarget( pTargetCurrent, vecSentryOrigin, true );
+				}
+				return true;
+			}
+			else
+			{
+				pTargetCurrent = NULL;
+			}
+		}
+	}
+
+	// Don't auto track to targets while under the effects of the player shield.
+	// The shield fades 3 seconds after we disengage from player control.
+	if ( m_nShieldLevel == SHIELD_NORMAL )
+		return false;
+
+	// is there an active truce?
+	bool bTruceActive = TFGameRules() && TFGameRules()->IsTruceActive();
+		
+	if ( ( pTargetCurrent == NULL ) && !bTruceActive )
+	{
+		// Sentries will try to target players first, then objects.  However, if the enemy held was an object it will continue
+		// to try and attack it first.
+		int nTeamCount = pTeam->GetNumPlayers();
+		for ( int iPlayer = 0; iPlayer < nTeamCount; ++iPlayer )
+		{
+			CTFPlayer *pTargetPlayer = static_cast<CTFPlayer*>( pTeam->GetPlayer( iPlayer ) );
+			if ( pTargetPlayer == NULL )
+				continue;
+
+			// Make sure the player is alive.
+			if ( !pTargetPlayer->IsAlive() )
+				continue;
+
+			if ( pTargetPlayer->GetFlags() & FL_NOTARGET )
+				continue;
+
+			vecTargetCenter = pTargetPlayer->GetAbsOrigin();
+			vecTargetCenter += pTargetPlayer->GetViewOffset();
+			VectorSubtract( vecTargetCenter, vecSentryOrigin, vecSegment );
+			float flDist2 = vecSegment.LengthSqr();
+
+			// Check to see if the target is closer than the already validated target.
+			if ( flDist2 > flMinDist2 )
+				continue;
+
+			// It is closer, check to see if the target is valid.
+			if ( ValidTargetPlayer( pTargetPlayer, vecSentryOrigin, vecTargetCenter ) )
+			{
+				flMinDist2 = flDist2;
+				pTargetCurrent = pTargetPlayer;
+
+				// Store the current target distance if we come across it
+				if ( pTargetPlayer == pTargetOld )
+				{
+					flOldTargetDist2 = flDist2;
+				}
+			}
+		}
+	}
+
+	// If we already have a target, don't check objects.
+	if ( pTargetCurrent == NULL )
+	{
+		// target non-player bots
+		CUtlVector< INextBot * > botVector;
+		TheNextBots().CollectAllBots( &botVector );
+
+		float closeBotRangeSq = m_flSentryRange * m_flSentryRange;
+
+		for( int b=0; b<botVector.Count(); ++b )
+		{
+			CBaseCombatCharacter *bot = botVector[b]->GetEntity();
+
+			Vector vecBotTarget = GetEnemyAimPosition( bot );
+			float rangeSq = ( vecBotTarget - vecSentryOrigin ).LengthSqr();
+
+			if ( rangeSq < closeBotRangeSq )
+			{
+				if ( ValidTargetBot( bot, vecSentryOrigin, vecBotTarget ) )
+				{
+					closeBotRangeSq = rangeSq;
+					pTargetCurrent = bot;
+				}
+			}
+		}
+
+		if ( ( pTargetCurrent == NULL ) && !bTruceActive )
+		{
+			// target objects
+			int nTeamObjectCount = pTeam->GetNumObjects();
+			for ( int iObject = 0; iObject < nTeamObjectCount; ++iObject )
+			{
+				CBaseObject *pTargetObject = pTeam->GetObject( iObject );
+				if ( !pTargetObject )
+					continue;
+
+				vecTargetCenter = pTargetObject->GetAbsOrigin();
+				vecTargetCenter += pTargetObject->GetViewOffset();
+				VectorSubtract( vecTargetCenter, vecSentryOrigin, vecSegment );
+				float flDist2 = vecSegment.LengthSqr();
+
+				// Store the current target distance if we come across it
+				if ( pTargetObject == pTargetOld )
+				{
+					flOldTargetDist2 = flDist2;
+				}
+
+				// Check to see if the target is closer than the already validated target.
+				if ( flDist2 > flMinDist2 )
+					continue;
+
+				// It is closer, check to see if the target is valid.
+				if ( ValidTargetObject( pTargetObject, vecSentryOrigin, vecTargetCenter ) )
+				{
+					flMinDist2 = flDist2;
+					pTargetCurrent = pTargetObject;
+				}
+			}
+		}
+	}
+
+	// We have a target.
+	if ( pTargetCurrent )
+	{
+		if ( pTargetCurrent != pTargetOld )
+		{
+			// Always target dummies
+			// flMinDist2 is the new target's distance
+			// flOldTargetDist2 is the old target's distance
+			// Don't switch unless the new target is closer by some percentage
+			if ( bDummyTarget || flMinDist2 < ( flOldTargetDist2 * 0.75f ) )
+			{
+				FoundTarget( pTargetCurrent, vecSentryOrigin );
+			}
+		}
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::ValidTargetPlayer( CTFPlayer *pPlayer, const Vector &vecStart, const Vector &vecEnd )
+{
+	// Keep shooting at spies that go invisible after we acquire them as a target.
+	if ( pPlayer->m_Shared.GetPercentInvisible() > 0.5 )
+		return false;
+
+	// Keep shooting at spies that disguise after we acquire them as at a target.
+	if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pPlayer->m_Shared.GetDisguiseTeam() == GetTeamNumber() && pPlayer != m_hEnemy )
+		return false;
+
+	// Don't shoot spys that are pretending to be a dispenser
+	if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED_AS_DISPENSER ) )
+		return false;
+
+	// Don't target spies after they OnKill disguise with 'Your Eternal Reward'
+	if ( ( pPlayer->m_Shared.InCond( TF_COND_DISGUISING ) || pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
+		&& pPlayer->m_Shared.GetDisguiseTeam() == GetTeamNumber() )
+	{
+		CTFKnife *pKnife = dynamic_cast<CTFKnife *>( pPlayer->GetActiveTFWeapon() );
+		if ( pKnife && pKnife->GetKnifeType() == KNIFE_DISGUISE_ONKILL )
+			return false;
+	}
+
+	// Not across water boundary.
+	if ( ( GetWaterLevel() == 0 && pPlayer->GetWaterLevel() >= 3 ) || ( GetWaterLevel() == 3 && pPlayer->GetWaterLevel() <= 0 ) )
+		return false;
+
+	// Ray trace!!!
+	return FVisible( pPlayer, MASK_SHOT | CONTENTS_GRATE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::ValidTargetObject( CBaseObject *pObject, const Vector &vecStart, const Vector &vecEnd )
+{
+	// Ignore objects being placed, they are not real objects yet.
+	if ( pObject->IsPlacing() )
+		return false;
+
+	// Ignore sappers.
+	if ( pObject->MustBeBuiltOnAttachmentPoint() )
+		return false;
+
+	// Not across water boundary.
+	if ( ( GetWaterLevel() == 0 && pObject->GetWaterLevel() >= 3 ) || ( GetWaterLevel() == 3 && pObject->GetWaterLevel() <= 0 ) )
+		return false;
+
+	if ( pObject->GetObjectFlags() & OF_DOESNT_HAVE_A_MODEL )
+		return false;
+
+	// Ray trace.
+	return FVisible( pObject, MASK_SHOT | CONTENTS_GRATE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::ValidTargetBot( CBaseCombatCharacter *pBot, const Vector &vecStart, const Vector &vecEnd )
+{
+	// Already collected all of the players in FindTarget()
+	if ( pBot->IsPlayer() )
+		return false;
+
+	// Don't want to shoot bots that are dead, on the same team, or aren't solid (they won't take damage anyway)
+	if  ( !pBot->IsAlive() || pBot->InSameTeam( this ) || pBot->IsSolidFlagSet( FSOLID_NOT_SOLID ) )
+		return false;
+
+	// Not across water boundary.
+	if ( ( GetWaterLevel() == 0 && pBot->GetWaterLevel() >= 3 ) || ( GetWaterLevel() == 3 && pBot->GetWaterLevel() <= 0 ) )
+		return false;
+
+	if ( TFGameRules() && TFGameRules()->IsPlayingRobotDestructionMode() )
+	{
+		CTFRobotDestruction_Robot *pRobot = dynamic_cast< CTFRobotDestruction_Robot* >( pBot );
+		if ( pRobot && pRobot->GetShieldedState() )
+			return false;
+	}
+
+	// Ray trace.
+	CBaseEntity *pBlocker;
+	bool bVisible = FVisible( pBot, MASK_SHOT | CONTENTS_GRATE, &pBlocker );
+
+	if ( bVisible )
+		return true;
+
+	// Also valid if it's parented to the blocker
+	if ( pBlocker == pBot->GetParent() )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Found a Target
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::FoundTarget( CBaseEntity *pTarget, const Vector &vecSoundCenter, bool bNoSound )
+{
+	m_hEnemy = pTarget;
+
+	if ( ( m_iAmmoShells > 0 ) || ( m_iAmmoRockets > 0 && m_iUpgradeLevel == 3 ) )
+	{
+		// Play one sound to everyone but the target.
+		CPASFilter filter( vecSoundCenter );
+
+		if ( pTarget->IsPlayer() )
+		{
+			CTFPlayer *pPlayer = ToTFPlayer( pTarget );
+
+			// Play a specific sound just to the target and remove it from the general recipient list.
+			if ( !bNoSound )
+			{
+				CSingleUserRecipientFilter singleFilter( pPlayer );
+				EmitSentrySound( singleFilter, entindex(), "Building_Sentrygun.AlertTarget" );
+				filter.RemoveRecipient( pPlayer );
+
+				// if the target is a bot, alert it
+				CTFBot *bot = ToTFBot( pPlayer );
+				if ( bot )
+				{
+					bot->GetVisionInterface()->AddKnownEntity( this );
+					bot->RememberEnemySentry( this, bot->GetAbsOrigin() );
+				}
+			}
+		}
+
+		if ( !bNoSound )
+		{
+			EmitSentrySound( filter, entindex(), "Building_Sentrygun.Alert" );
+		}
+	}
+
+	// Update timers, we are attacking now!
+	m_iState.Set( SENTRY_STATE_ATTACKING );
+	m_flNextAttack = gpGlobals->curtime + SENTRY_THINK_DELAY;
+	if ( m_flNextRocketAttack < gpGlobals->curtime )
+	{
+		m_flNextRocketAttack = gpGlobals->curtime;// + 0.5;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// FInViewCone - returns true is the passed ent is in
+// the caller's forward view cone. The dot product is performed
+// in 2d, making the view cone infinitely tall. 
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::FInViewCone ( CBaseEntity *pEntity )
+{
+	Vector forward;
+	AngleVectors( m_vecCurAngles, &forward );
+
+	Vector2D vec2LOS = ( pEntity->GetAbsOrigin() - GetAbsOrigin() ).AsVector2D();
+	vec2LOS.NormalizeInPlace();
+
+	float flDot = vec2LOS.Dot( forward.AsVector2D() );
+
+	if ( flDot > m_flFieldOfView )
+	{
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Make sure our target is still valid, and if so, fire at it
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::Attack()
+{
+	StudioFrameAdvance( );
+
+	if ( IsUsingReverseBuild() || !FindTarget() )
+	{
+		m_iState.Set( SENTRY_STATE_SEARCHING );
+		m_hEnemy = NULL;
+		return;
+	}
+
+	// Track enemy
+	Vector vecMid = EyePosition();
+	Vector vecMidEnemy = GetEnemyAimPosition( m_hEnemy );
+	Vector vecDirToEnemy = vecMidEnemy - vecMid;
+
+	QAngle angToTarget;
+	VectorAngles( vecDirToEnemy, angToTarget );
+
+	angToTarget.y = UTIL_AngleMod( angToTarget.y );
+	if (angToTarget.x < -180)
+		angToTarget.x += 360;
+	if (angToTarget.x > 180)
+		angToTarget.x -= 360;
+
+	// now all numbers should be in [1...360]
+	// pin to turret limitations to [-50...50]
+	if (angToTarget.x > 50)
+		angToTarget.x = 50;
+	else if (angToTarget.x < -50)
+		angToTarget.x = -50;
+	m_vecGoalAngles.y = angToTarget.y;
+	m_vecGoalAngles.x = angToTarget.x;
+
+	MoveTurret();
+
+	// Fire on the target if it's within 10 units of being aimed right at it
+	if ( m_flNextAttack <= gpGlobals->curtime && (m_vecGoalAngles - m_vecCurAngles).Length() <= 10 )
+	{
+		if ( !m_bPlayerControlled || m_bFireNextFrame )
+		{
+			m_bFireNextFrame = false;
+			Fire();
+		}
+
+		m_flFireRate = 1.f;
+		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), m_flFireRate, mult_sentry_firerate );
+
+		if ( m_bPlayerControlled )
+		{
+			m_flFireRate *= 0.5f;
+		}
+			
+		if ( IsMiniBuilding() && !IsDisposableBuilding() )
+		{
+			m_flFireRate *= 0.75f;
+		}
+
+		if ( GetBuilder() && GetBuilder()->m_Shared.InCond( TF_COND_CRITBOOSTED_USER_BUFF ) )
+		{
+			m_flFireRate *= 0.4f;
+		}
+
+		if ( m_iUpgradeLevel == 1 )
+		{
+			// Level 1 sentries fire slower
+			m_flNextAttack = gpGlobals->curtime + (0.2*m_flFireRate);
+		}
+		else
+		{
+			m_flNextAttack = gpGlobals->curtime + (0.1*m_flFireRate);
+		}
+	}
+	else
+	{
+		// SetSentryAnim( TFTURRET_ANIM_SPIN );
+	}
+
+	if ( m_bPlayerControlled && m_bFireRocketNextFrame )
+	{
+		m_bFireRocketNextFrame = false;
+		FireRocket();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::FireRocket()
+{
+	if ( m_flNextRocketAttack >= gpGlobals->curtime || m_iAmmoRockets <= 0 )
+		return false;
+
+	if ( m_hEnemy.Get() == NULL )
+		return false;
+
+	Vector vecAimDir;
+
+	Vector vecSrc;
+	QAngle vecAng;
+
+	GetAttachment( m_iAttachments[SENTRYGUN_ATTACHMENT_ROCKET], vecSrc, vecAng );
+
+	Vector vecEnemyPos = GetEnemyAimPosition( m_hEnemy );
+	vecAimDir = vecEnemyPos - vecSrc;
+	vecAimDir.NormalizeInPlace();
+
+	// If we cannot see their WorldSpaceCenter ( possible, as we do our target finding based
+	// on the eye position of the target ) then fire at the eye position
+	trace_t tr;
+
+	CTraceFilterSimple traceFilter( this, COLLISION_GROUP_NONE );
+	ITraceFilter *pFilterChain = NULL;
+
+	CTraceFilterIgnoreFriendlyCombatItems traceFilterCombatItem( this, COLLISION_GROUP_NONE, GetTeamNumber() );
+	if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
+	{
+		// Ignore teammates and their (physical) upgrade items in MvM
+		pFilterChain = &traceFilterCombatItem;
+	}
+
+	CTraceFilterChain traceFilterChain( &traceFilter, pFilterChain );
+	UTIL_TraceLine( vecSrc, vecEnemyPos, MASK_SOLID, &traceFilterChain, &tr);
+
+	if ( m_bPlayerControlled || (tr.m_pEnt && !tr.m_pEnt->IsWorld()) )
+	{
+		// NOTE: vecAng is not actually set by GetAttachment!!!
+		QAngle angDir;
+		VectorAngles( vecAimDir, angDir );
+
+		EmitSentrySound( "Building_Sentrygun.FireRocket" );
+
+		QAngle angAimDir;
+		VectorAngles( vecAimDir, angAimDir );
+		CTFProjectile_SentryRocket *pProjectile = CTFProjectile_SentryRocket::Create( vecSrc, angAimDir, this, GetBuilder() );
+		if ( pProjectile )
+		{
+			int iDamage = 100;
+			CALL_ATTRIB_HOOK_INT_ON_OTHER( GetOwner(), iDamage, mult_engy_sentry_damage );
+			pProjectile->SetDamage( iDamage );
+		}
+
+		// Setup next rocket shot
+		if ( m_bPlayerControlled )
+		{
+			m_flNextRocketAttack = gpGlobals->curtime + 2.25;
+		}
+		else
+		{
+			AddGesture( ACT_RANGE_ATTACK2 );
+			m_flNextRocketAttack = gpGlobals->curtime + 3;
+		}
+
+		if ( !tf_sentrygun_ammocheat.GetBool() && !HasSpawnFlags( SF_SENTRY_INFINITE_AMMO ) )
+		{
+			m_iAmmoRockets--;
+		}
+	}
+
+	m_timeSinceLastFired.Start();
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+int CObjectSentrygun::GetFireAttachment()
+{
+	int iAttachment;
+
+	if ( m_iUpgradeLevel > 1 && m_iLastMuzzleAttachmentFired == m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE] )
+	{
+		// level 2 and 3 turrets alternate muzzles each time they fizzy fizzy fire.
+		iAttachment = m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE_ALT];
+	}
+	else
+	{
+		iAttachment = m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE];
+	}
+	m_iLastMuzzleAttachmentFired = iAttachment;
+
+	return iAttachment;
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::OnKilledEnemy(CBasePlayer* pVictim)
+{
+	if ( !pVictim )
+		return;
+
+	CTFPlayer *pOwner = GetOwner();
+	if ( !pOwner )
+		return;
+
+	if ( m_bPlayerControlled && pVictim->GetAbsOrigin().DistToSqr( GetAbsOrigin() ) > ( m_flSentryRange * m_flSentryRange ) )
+	{
+		pOwner->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_MANUAL_SENTRY_KILLS_BEYOND_RANGE );
+	}
+
+	CTFPlayer *pCTFVictim = static_cast<CTFPlayer *>( pVictim );
+	if ( pCTFVictim->GetControlPointStandingOn() != NULL )
+	{
+		pOwner->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_SENTRY_KILL_CAPS, 1 );
+	}
+
+	if ( (gpGlobals->curtime - GetCarryDeployTime() < tf_sentrygun_kill_after_redeploy_time_achievement.GetInt()) &&
+		 GetUpgradeLevel() == 3 )
+	{
+		pOwner->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_MOVE_SENTRY_GET_KILL );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Fire on our target
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::Fire()
+{
+	//NDebugOverlay::Cross3D( m_hEnemy->WorldSpaceCenter(), 10, 255, 0, 0, false, 0.1 );
+
+	Vector vecAimDir;
+
+	// Level 3 Turrets fire rockets every 3 seconds
+	if ( m_iUpgradeLevel == 3 &&
+		 m_iAmmoRockets > 0 &&
+		 m_flNextRocketAttack < gpGlobals->curtime &&
+		 !m_bPlayerControlled )
+	{
+		FireRocket();
+	}
+
+	// All turrets fire shells
+	if ( m_iAmmoShells > 0 )
+	{
+		if ( !IsPlayingGesture( ACT_RANGE_ATTACK1 ) )
+		{
+			RemoveGesture( ACT_RANGE_ATTACK1_LOW );
+			AddGesture( ACT_RANGE_ATTACK1 );
+		}
+
+		if ( m_hEnemy.Get() == NULL )
+			return false;
+
+		Vector vecSrc;
+		QAngle vecAng;
+
+		int iAttachment = GetFireAttachment();
+		GetAttachment( iAttachment, vecSrc, vecAng );
+
+		Vector vecMidEnemy = GetEnemyAimPosition( m_hEnemy );
+
+		// If we cannot see their WorldSpaceCenter ( possible, as we do our target finding based
+		// on the eye position of the target ) then fire at the eye position
+		trace_t tr;
+		CTraceFilterSimple traceFilter( this, COLLISION_GROUP_NONE );
+		ITraceFilter *pFilterChain = NULL;
+
+		CTraceFilterIgnoreFriendlyCombatItems traceFilterCombatItem( this, COLLISION_GROUP_NONE, GetTeamNumber() );
+		if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
+		{
+			// Ignore teammates and their (physical) upgrade items in MvM
+			pFilterChain = &traceFilterCombatItem;
+		}
+
+		CTraceFilterChain traceFilterChain( &traceFilter, pFilterChain );
+		UTIL_TraceLine( vecSrc, vecMidEnemy, MASK_SOLID, &traceFilterChain, &tr);
+
+		if ( !tr.m_pEnt || tr.m_pEnt->IsWorld() )
+		{
+			// Hack it lower a little bit..
+			// The eye position is not always within the hitboxes for a standing TF Player
+			vecMidEnemy = m_hEnemy->EyePosition() + Vector(0,0,-5);
+		}
+
+		vecAimDir = vecMidEnemy - vecSrc;
+
+		float flDistToTarget = vecAimDir.Length();
+
+		vecAimDir.NormalizeInPlace();
+
+		//NDebugOverlay::Cross3D( vecSrc, 10, 255, 0, 0, false, 0.1 );
+
+		FireBulletsInfo_t info;
+
+		info.m_vecSrc = vecSrc;
+		info.m_vecDirShooting = vecAimDir;
+		info.m_iTracerFreq = 1;
+		info.m_iShots = 1;
+		info.m_pAttacker = GetBuilder();
+		if ( info.m_pAttacker == NULL )
+		{
+			info.m_pAttacker = this;
+		}
+		if ( m_bPlayerControlled )
+		{
+			info.m_vecSpread = VECTOR_CONE_3DEGREES;
+		}
+		else
+		{
+			info.m_vecSpread = vec3_origin;
+		}
+		info.m_flDistance = flDistToTarget + 100;
+		info.m_iAmmoType = m_iAmmoType;
+
+		if ( IsMiniBuilding() )
+		{
+			info.m_flDamage = tf_sentrygun_mini_damage.GetFloat();
+			info.m_flDamageForceScale = 0.0f;
+		}
+		else
+		{
+			info.m_flDamage = tf_sentrygun_damage.GetFloat();
+		}
+
+		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), info.m_flDamage, mult_engy_sentry_damage );
+
+		FireBullets( info );
+
+		// sentry gun fire 'heats up' the nav mesh around it
+		UpdateNavMeshCombatStatus();
+
+
+		//NDebugOverlay::Line( vecSrc, vecSrc + vecAimDir * 1000, 255, 0, 0, false, 0.1 );
+
+		CEffectData data;
+		data.m_nEntIndex = entindex();
+		data.m_nAttachmentIndex = iAttachment;
+		data.m_fFlags = m_iUpgradeLevel;
+		data.m_vOrigin = vecSrc;
+		DispatchEffect( "TF_3rdPersonMuzzleFlash_SentryGun", data );
+
+		if ( IsMiniBuilding() )
+		{
+			EmitSound_t params;
+			params.m_pSoundName = "Building_MiniSentrygun.Fire";
+			params.m_flSoundTime = 0;
+			params.m_pflSoundDuration = 0;
+			params.m_bWarnOnDirectWaveReference = true;
+			CPASAttenuationFilter filter( this, "Building_MiniSentrygun.Fire" );
+			EmitSound( filter, entindex(), params );
+		}
+		else
+		{
+			if ( !m_bPlayerControlled )
+			{
+				switch( m_iUpgradeLevel )
+				{
+				case 1:
+				default:
+					EmitSentrySound( "Building_Sentrygun.Fire" );
+					break;
+				case 2:
+					EmitSentrySound( "Building_Sentrygun.Fire2" );
+					break;
+				case 3:
+					EmitSentrySound( "Building_Sentrygun.Fire3" );
+					break;
+				}
+			}
+			else
+			{
+				switch ( m_iUpgradeLevel )
+				{
+				case 1:
+					EmitSentrySound( "Building_Sentrygun.ShaftFire" );
+					break;
+				case 2:
+					EmitSentrySound( "Building_Sentrygun.ShaftFire2" );
+					break;
+				case 3:
+					EmitSentrySound( "Building_Sentrygun.ShaftFire3" );
+					break;
+				}
+			}
+		}
+
+		if ( !tf_sentrygun_ammocheat.GetBool() && !HasSpawnFlags( SF_SENTRY_INFINITE_AMMO ) )
+		{
+			m_iAmmoShells--;
+		}
+	}
+	else
+	{
+		if ( m_iUpgradeLevel > 1 )
+		{
+			if ( !IsPlayingGesture( ACT_RANGE_ATTACK1_LOW ) )
+			{
+				RemoveGesture( ACT_RANGE_ATTACK1 );
+				AddGesture( ACT_RANGE_ATTACK1_LOW );
+			}
+		}
+
+		// Out of ammo, play a click
+		EmitSound( "Building_Sentrygun.Empty" );
+
+		// Disposable sentries blow up when their ammo runs out
+		if ( IsDisposableBuilding() )
+		{
+			DetonateObject();
+		}
+
+		m_flNextAttack = gpGlobals->curtime + 0.2;
+	}
+
+	// note when we last fired at en enemy (or tried to)
+	m_timeSinceLastFired.Start();
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::ModifyFireBulletsDamage( CTakeDamageInfo* dmgInfo )
+{
+	if ( m_bPlayerControlled && dmgInfo )
+	{
+		dmgInfo->SetDamageCustom( TF_DMG_CUSTOM_PLAYER_SENTRY );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+float CObjectSentrygun::GetPushMultiplier()
+{
+	if ( IsMiniBuilding() )
+		return 8.f;
+	else
+		return 16.f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
+{
+	trace_t tmptrace;
+	tmptrace.endpos = tr.endpos + RandomVector(-10,10);
+
+	// Sentryguns are perfectly accurate, but this doesn't look good for tracers.
+	// Add a little noise to them, but not enough so that it looks like they're missing.
+	BaseClass::MakeTracer( vecTracerSrc, tmptrace, iTracerType );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: MakeTracer asks back for the attachment index
+//-----------------------------------------------------------------------------
+int	CObjectSentrygun::GetTracerAttachment( void )
+{
+	return m_iAttachments[SENTRYGUN_ATTACHMENT_MUZZLE];
+}
+
+//-----------------------------------------------------------------------------
+// Rotate and scan for targets
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::SentryRotate( void )
+{
+	if ( GetReversesBuildingConstructionSpeed() )
+	{
+		m_iState.Set( SENTRY_STATE_INACTIVE );
+		return;
+	}
+
+	// if we're playing a fire gesture, stop it
+	if ( IsPlayingGesture( ACT_RANGE_ATTACK1 ) )
+	{
+		RemoveGesture( ACT_RANGE_ATTACK1 );
+	}
+
+	if ( IsPlayingGesture( ACT_RANGE_ATTACK1_LOW ) )
+	{
+		RemoveGesture( ACT_RANGE_ATTACK1_LOW );
+	}
+
+	// animate
+	StudioFrameAdvance();
+
+	// Look for a target
+	if ( FindTarget() )
+		return;
+	
+	// Rotate
+	if ( !MoveTurret() )
+	{
+		// Change direction
+
+		if ( IsDisabled() || m_nShieldLevel == SHIELD_NORMAL )
+		{
+			EmitSound( "Building_Sentrygun.Disabled" );
+			m_vecGoalAngles.x = 30;
+		}
+		else
+		{
+			switch( m_iUpgradeLevel )
+			{
+			case 1:
+			default:
+				EmitSentrySound( "Building_Sentrygun.Idle" );
+				break;
+			case 2:
+				EmitSound( "Building_Sentrygun.Idle2" );
+				break;
+			case 3:
+				EmitSound( "Building_Sentrygun.Idle3" );
+				break;
+			}
+
+			// Switch rotation direction
+			if ( m_bTurningRight )
+			{
+				m_bTurningRight = false;
+				m_vecGoalAngles.y = m_iLeftBound;
+			}
+			else
+			{
+				m_bTurningRight = true;
+				m_vecGoalAngles.y = m_iRightBound;
+			}
+
+			// Randomly look up and down a bit
+			if (random->RandomFloat(0, 1) < 0.3)
+			{
+				m_vecGoalAngles.x = (int)random->RandomFloat(-10,10);
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add the EMP effect
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::OnStartDisabled( void )
+{
+	// stay at current rotation, angle down
+	m_vecGoalAngles.x = m_vecCurAngles.x;
+	m_vecGoalAngles.y = m_vecCurAngles.y;
+
+	// target = nULL
+
+	BaseClass::OnStartDisabled();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove the EMP effect
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::OnEndDisabled( void )
+{
+	// return to normal rotations
+	if ( m_bTurningRight )
+	{
+		m_bTurningRight = false;
+		m_vecGoalAngles.y = m_iLeftBound;
+	}
+	else
+	{
+		m_bTurningRight = true;
+		m_vecGoalAngles.y = m_iRightBound;
+	}
+
+	m_vecGoalAngles.x = 0;
+
+	BaseClass::OnEndDisabled();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+int CObjectSentrygun::GetBaseTurnRate( void )
+{
+	if ( m_bPlayerControlled )
+	{
+		return m_iBaseTurnRate * 100;
+	}
+	else
+	{
+		return m_iBaseTurnRate;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+bool CObjectSentrygun::MoveTurret( void )
+{
+	bool bMoved = false;
+
+	int iBaseTurnRate = GetBaseTurnRate();
+	
+	if ( IsMiniBuilding() )
+	{
+		iBaseTurnRate *= 1.35f;
+	}
+
+	// any x movement?
+	if ( m_vecCurAngles.x != m_vecGoalAngles.x )
+	{
+		float flDir = m_vecGoalAngles.x > m_vecCurAngles.x ? 1 : -1 ;
+
+		m_vecCurAngles.x += SENTRY_THINK_DELAY * ( iBaseTurnRate * 5 ) * flDir;
+
+		// if we started below the goal, and now we're past, peg to goal
+		if ( flDir == 1 )
+		{
+			if (m_vecCurAngles.x > m_vecGoalAngles.x)
+				m_vecCurAngles.x = m_vecGoalAngles.x;
+		} 
+		else
+		{
+			if (m_vecCurAngles.x < m_vecGoalAngles.x)
+				m_vecCurAngles.x = m_vecGoalAngles.x;
+		}
+
+		SetPoseParameter( m_iPitchPoseParameter, -m_vecCurAngles.x );
+
+		bMoved = true;
+	}
+
+	if ( m_vecCurAngles.y != m_vecGoalAngles.y )
+	{
+		float flDir = m_vecGoalAngles.y > m_vecCurAngles.y ? 1 : -1 ;
+		float flDist = fabs( m_vecGoalAngles.y - m_vecCurAngles.y );
+		bool bReversed = false;
+
+		if ( flDist > 180 )
+		{
+			flDist = 360 - flDist;
+			flDir = -flDir;
+			bReversed = true;
+		}
+
+		if ( m_hEnemy.Get() == NULL )
+		{
+			if ( flDist > 30 )
+			{
+				if ( m_flTurnRate < iBaseTurnRate * 10 )
+				{
+					m_flTurnRate += iBaseTurnRate;
+				}
+			}
+			else
+			{
+				// Slow down
+				if ( m_flTurnRate > (iBaseTurnRate * 5) )
+					m_flTurnRate -= iBaseTurnRate;
+			}
+		}
+		else
+		{
+			// When tracking enemies, move faster and don't slow
+			if ( flDist > 30 )
+			{
+				if (m_flTurnRate < iBaseTurnRate * 30)
+				{
+					m_flTurnRate += iBaseTurnRate * 3;
+				}
+			}
+		}
+
+		m_vecCurAngles.y += SENTRY_THINK_DELAY * m_flTurnRate * flDir;
+
+		// if we passed over the goal, peg right to it now
+		if (flDir == -1)
+		{
+			if ( (bReversed == false && m_vecGoalAngles.y > m_vecCurAngles.y) ||
+				(bReversed == true && m_vecGoalAngles.y < m_vecCurAngles.y) )
+			{
+				m_vecCurAngles.y = m_vecGoalAngles.y;
+			}
+		} 
+		else
+		{
+			if ( (bReversed == false && m_vecGoalAngles.y < m_vecCurAngles.y) ||
+                (bReversed == true && m_vecGoalAngles.y > m_vecCurAngles.y) )
+			{
+				m_vecCurAngles.y = m_vecGoalAngles.y;
+			}
+		}
+
+		if ( m_vecCurAngles.y < 0 )
+		{
+			m_vecCurAngles.y += 360;
+		}
+		else if ( m_vecCurAngles.y >= 360 )
+		{
+			m_vecCurAngles.y -= 360;
+		}
+
+		if ( flDist < ( SENTRY_THINK_DELAY * 0.5 * iBaseTurnRate ) )
+		{
+			m_vecCurAngles.y = m_vecGoalAngles.y;
+		}
+
+		QAngle angles = GetAbsAngles();
+
+		float flYaw = m_vecCurAngles.y - angles.y;
+
+		SetPoseParameter( m_iYawPoseParameter, -flYaw );
+
+		InvalidatePhysicsRecursive( ANIMATION_CHANGED );
+
+		bMoved = true;
+	}
+
+	if ( !bMoved || m_flTurnRate <= 0 )
+	{
+		m_flTurnRate = iBaseTurnRate * 5;
+	}
+
+	return bMoved;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Note our last attacked time
+//-----------------------------------------------------------------------------
+int CObjectSentrygun::OnTakeDamage( const CTakeDamageInfo &info )
+{
+	CTakeDamageInfo newInfo = info;
+
+	// As we increase in level, we get more resistant to minigun bullets, to compensate for
+	// our increased surface area taking more minigun hits.
+	if ( ( info.GetDamageType() & DMG_BULLET ) && ( info.GetDamageCustom() == TF_DMG_CUSTOM_MINIGUN ) )
+	{
+		float flDamage = newInfo.GetDamage();
+		flDamage *= ( 1.0 - m_flHeavyBulletResist );
+		newInfo.SetDamage( flDamage );
+	}
+	
+	// If we are shielded due to player control, we take less damage.
+	bool bFullyShielded = ( m_nShieldLevel > 0 ) && !HasSapper() && !IsPlasmaDisabled();
+	if ( bFullyShielded )
+	{
+		float flDamage = newInfo.GetDamage();
+		flDamage *= ( m_nShieldLevel == SHIELD_NORMAL ) ? SHIELD_NORMAL_VALUE : SHIELD_MAX_VALUE;
+		newInfo.SetDamage( flDamage );
+	}
+
+	// Check to see if we are being sapped.
+	if ( HasSapper() )
+	{
+		// Get the sapper owner.
+		CBaseObject *pSapper = GetObjectOfTypeOnMe( OBJ_ATTACHMENT_SAPPER );
+
+		// Take less damage if the owner is causing additional damage.
+		if ( pSapper && ( info.GetAttacker() == pSapper->GetOwner() ) )
+		{
+			float flDamage = newInfo.GetDamage() * SENTRYGUN_SAPPER_OWNER_DAMAGE_MODIFIER;
+			newInfo.SetDamage( flDamage );
+		}
+	}
+
+	int iDamageTaken = BaseClass::OnTakeDamage( newInfo );
+
+	if ( iDamageTaken > 0 )
+	{
+		m_flLastAttackedTime = gpGlobals->curtime;
+
+		// check for achievement
+		if ( bFullyShielded )
+		{
+			int iPrevLifetimeShieldedDamage = m_iLifetimeShieldedDamage;
+			m_iLifetimeShieldedDamage += iDamageTaken;
+			const int kMaxDamageForAchievement = tf_sentrygun_max_absorbed_damage_while_controlled_for_achievement.GetInt();
+			if ( iPrevLifetimeShieldedDamage <= kMaxDamageForAchievement && m_iLifetimeShieldedDamage > kMaxDamageForAchievement )
+			{
+				CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
+				if ( pOwner && pOwner->IsPlayerClass( TF_CLASS_ENGINEER ) )
+				{
+					pOwner->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_MANUAL_SENTRY_ABSORB_DMG );
+				}
+			}
+		}
+	}
+
+	return iDamageTaken;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called when this object is destroyed
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::Killed( const CTakeDamageInfo &info )
+{
+	CTFPlayer *pTFKiller = ToTFPlayer( info.GetAttacker() );
+	if ( pTFKiller && pTFKiller->IsPlayerClass( TF_CLASS_SOLDIER ) )
+	{
+		if ( pTFKiller->GetAbsOrigin().DistTo( GetAbsOrigin() ) > SENTRY_MAX_RANGE )
+		{
+			pTFKiller->AwardAchievement( ACHIEVEMENT_TF_SOLDIER_DESTROY_SENTRY_OUT_OF_RANGE );
+		}
+		//If we are in the corridor map, then we check for the achievement for it.
+		else if ( m_hEnemy && !( pTFKiller->GetFlags() & FL_ONGROUND ) )
+		{
+			CBaseEntity *pDamager = GetBuilder();
+			
+			if ( NULL == pDamager )
+			{
+				pDamager = this;
+			}
+
+			static const float DAMAGE_INTERVAL = 2.0f;
+			if ( pTFKiller->m_AchievementData.IsDamagerInHistory( pDamager, DAMAGE_INTERVAL ) )
+			{
+				//Check the map.
+				if ( 0 == Q_stricmp( "tra_sol_corridor", STRING( gpGlobals->mapname ) ) )
+				{
+#ifdef TF_SOLDIER_TRAINING_ACHIEVEMENTS
+					//If the attacker was in the air when this sentry died, give him an achievement.
+					pTFKiller->AwardAchievement( ACHIEVEMENT_TF_SOLDIER_TRAINING_COR_SENTRY_FROM_AIR );
+#endif // TF_SOLDIER_TRAINING_ACHIEVEMENTS
+				}
+			}
+		}
+	}
+
+	// Tell our owner's shotgun the sentry died.
+	CTFPlayer *pOwner = ToTFPlayer( GetOwner() );
+	if ( pOwner )
+	{
+		CTFShotgun_Revenge* pShotgun = dynamic_cast<CTFShotgun_Revenge*>( pOwner->Weapon_OwnsThisID( TF_WEAPON_SENTRY_REVENGE ) );
+		if ( pShotgun )
+		{
+			pShotgun->SentryKilled( GetKills() * 2 + GetAssists() );
+		}
+	}
+
+	// find nearby sentry hint
+	if ( TFGameRules() && TFGameRules()->IsInTraining() )
+	{
+		CTFBotHintSentrygun *sentryHint;
+		for( sentryHint = static_cast< CTFBotHintSentrygun * >( gEntList.FindEntityByClassname( NULL, "bot_hint_sentrygun" ) );
+			sentryHint;
+			sentryHint = static_cast< CTFBotHintSentrygun * >( gEntList.FindEntityByClassname( sentryHint, "bot_hint_sentrygun" ) ) )
+		{
+			if ( sentryHint->IsEnabled() && sentryHint->InSameTeam( this ) )
+			{
+				Vector toMe = GetAbsOrigin() - sentryHint->GetAbsOrigin();
+				float dist2 = toMe.LengthSqr();
+				if ( dist2 < 1.0f )
+				{
+					sentryHint->OnSentryGunDestroyed( this );
+					sentryHint->DecrementUseCount();
+					break;
+				}
+			}
+		}
+	}
+
+	// Engineers destroying their own sentry don't escape the buster.
+	// Destroying disposable sentries doesn't reset the buster.
+	if ( info.GetAttacker() != this && !IsDisposableBuilding() )
+	{
+		// Sentry Buster mission accomplished
+		if ( pOwner )
+		{
+			pOwner->ResetAccumulatedSentryGunDamageDealt();
+			pOwner->ResetAccumulatedSentryGunKillCount();
+		}
+	}
+
+	// do normal handling
+	BaseClass::Killed( info );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::SetModel( const char *pModel )
+{
+	float flPoseParam0 = 0.0;
+	float flPoseParam1 = 0.0;
+
+	// Save pose parameters across model change
+	if ( m_iPitchPoseParameter >= 0 )
+	{
+		flPoseParam0 = GetPoseParameter( m_iPitchPoseParameter );
+	}
+
+	if ( m_iYawPoseParameter >= 0 )
+	{
+		flPoseParam1 = GetPoseParameter( m_iYawPoseParameter );
+	}
+
+	BaseClass::SetModel( pModel );
+
+	// Reset this after model change
+	SetBuildingSize();
+	SetSolid( SOLID_BBOX );
+
+	// Restore pose parameters
+	m_iPitchPoseParameter = LookupPoseParameter( "aim_pitch" );
+	m_iYawPoseParameter = LookupPoseParameter( "aim_yaw" );
+
+	SetPoseParameter( m_iPitchPoseParameter, flPoseParam0 );
+	SetPoseParameter( m_iYawPoseParameter, flPoseParam1 );
+
+	CreateBuildPoints();
+
+	ReattachChildren();
+
+	ResetSequenceInfo();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::SetBuildingSize()
+{
+	// Mini's do NOT need to have their size set here, SetModelScale already handles scaling for hulls (change from MvM)
+	UTIL_SetSize( this, SENTRYGUN_MINS, SENTRYGUN_MAXS );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::MakeCarriedObject( CTFPlayer *pCarrier )
+{
+	BaseClass::MakeCarriedObject( pCarrier );
+
+	m_iOldAmmoShells = m_iAmmoShells;
+	m_iOldAmmoRockets = m_iAmmoRockets;
+
+	m_nShieldLevel.Set( SHIELD_NONE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::MakeDisposableBuilding( CTFPlayer* pPlayer )
+{
+	// We don't have our main gun
+	if ( !( pPlayer->GetNumObjects( OBJ_SENTRYGUN ) && pPlayer->CanBuild( OBJ_SENTRYGUN ) == CB_CAN_BUILD ) )
+		return;
+
+	// We're carrying our main gun
+	if ( pPlayer->m_Shared.IsCarryingObject() && pPlayer->m_Shared.GetCarriedObject() && !pPlayer->m_Shared.GetCarriedObject()->IsDisposableBuilding() )
+		return;
+
+	if ( IsDisposableBuilding() )
+		return;
+
+	SetMaxHealth( SENTRYGUN_MINI_MAX_HEALTH );
+	SetHealth( SENTRYGUN_MINI_MAX_HEALTH );
+
+	SetModelScale( DISPOSABLE_SCALE );
+	
+	BaseClass::MakeDisposableBuilding( pPlayer );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::RemoveAllAmmo()
+{
+	m_iOldAmmoShells = m_iAmmoShells;
+	m_iOldAmmoRockets = m_iAmmoRockets;
+
+	m_iAmmoShells = 0;
+	m_iAmmoRockets = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::EmitSentrySound( IRecipientFilter& filter, int iEntIndex, const char *soundname )
+{
+	EmitSound_t params;
+	params.m_pSoundName = soundname;
+	params.m_flSoundTime = 0;
+	params.m_pflSoundDuration = 0;
+	params.m_bWarnOnDirectWaveReference = true;
+	
+	if ( IsMiniBuilding() )
+	{
+		StopSound( soundname );
+		params.m_nPitch = PITCH_HIGH;
+		params.m_nFlags = SND_CHANGE_PITCH;
+	}
+
+	EmitSound( filter, entindex(), params );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::EmitSentrySound( const char* soundname )
+{
+	CPASAttenuationFilter filter( this, soundname );
+
+	EmitSound_t params;
+	params.m_pSoundName = soundname;
+	params.m_flSoundTime = 0;
+	params.m_pflSoundDuration = 0;
+	params.m_bWarnOnDirectWaveReference = true;
+	
+	if ( IsMiniBuilding() || m_flFireRate != 1.f )
+	{
+		StopSound( soundname );
+		params.m_nPitch = IsMiniBuilding() ? PITCH_HIGH : RemapValClamped( m_flFireRate, 1.0f, 0.5f, 100.f, 120.f );
+		params.m_nFlags = SND_CHANGE_PITCH;
+	}
+
+	EmitSound( filter, entindex(), params );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CTFPlayer *CObjectSentrygun::GetAssistingTeammate( float maxAssistDuration ) const
+{
+	if ( maxAssistDuration > 0.0f && ( !m_lastTeammateWrenchHitTimer.HasStarted() || m_lastTeammateWrenchHitTimer.IsGreaterThen( maxAssistDuration ) ) )
+		return NULL;
+
+	return m_lastTeammateWrenchHit;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::SetAutoAimTarget( CTFPlayer* pPlayer )
+{
+	if ( !pPlayer )
+		return;
+
+	// No auto aim target if a dummy is found
+	CBaseEntity *pTargetOld = m_hEnemy.Get();
+	if ( pTargetOld )
+	{
+		CTFTargetDummy *pDummy = dynamic_cast<CTFTargetDummy*>( pTargetOld );
+		if ( pDummy )
+		{
+			m_hAutoAimTarget = NULL;
+			return;
+		}
+	}
+
+	m_hAutoAimTarget = pPlayer;
+	m_flAutoAimStartTime = gpGlobals->curtime;
+}
+
+
+//-----------------------------------------------------------------------------
+void CObjectSentrygun::UpdateNavMeshCombatStatus( void )
+{
+	// mark region as 'in combat'
+	if ( m_inCombatThrottleTimer.IsElapsed() )
+	{
+		// important to keep this at one second, so rate cvars make sense (units/sec)
+		m_inCombatThrottleTimer.Start( 1.0f );
+
+		UpdateLastKnownArea();
+
+		// only search up/down StepHeight as a cheap substitute for line of sight
+		CUtlVector< CNavArea * > nearbyAreaVector;
+		CollectSurroundingAreas( &nearbyAreaVector, GetLastKnownArea(), tf_nav_in_combat_range.GetFloat(), StepHeight, StepHeight );
+
+		for( int i=0; i<nearbyAreaVector.Count(); ++i )
+		{
+			CTFNavArea *area = static_cast< CTFNavArea * >( nearbyAreaVector[i] );
+
+			// hacky - we want sentry gunfire to immediately heat the area since it is so dangerous
+			area->OnCombat();
+			area->OnCombat();
+			area->OnCombat();
+			area->OnCombat();
+			area->OnCombat();
+		}
+	}
+}
+//-------------------------------------------------------------------------------------------------------------------------------
+int CObjectSentrygun::GetUpgradeMetalRequired()
+{
+	int iMetal = BaseClass::GetUpgradeMetalRequired();
+	int iSmallSentry = 0;
+	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), iSmallSentry, build_small_sentries );
+	if ( iSmallSentry )
+	{
+		iMetal *= 0.75f;
+	}
+	
+	return iMetal;
+}
+
+//-------------------------------------------------------------------------------------------------------------------------------
+int CObjectSentrygun::GetMaxHealthForCurrentLevel( void )
+{
+	int iHealth = BaseClass::GetMaxHealthForCurrentLevel();
+	if ( IsScaledSentry() )
+	{
+		iHealth *= 0.66f;
+	}
+	return iHealth;
+}
+//-------------------------------------------------------------------------------------------------------------------------------
+void CObjectSentrygun::MakeScaledBuilding( CTFPlayer *pPlayer )
+{
+	int iSmallSentry = 0;
+	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetOwner(), iSmallSentry, build_small_sentries );
+	if ( iSmallSentry )
+	{
+		m_flScaledSentry = iSmallSentry ? SMALL_SENTRY_SCALE : 1.0f;
+
+		SetModelScale( m_flScaledSentry );
+
+		int iHealth = GetMaxHealthForCurrentLevel();
+
+		SetMaxHealth( iHealth );
+		SetHealth( iHealth );
+		SetBuildingSize();
+	}
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+LINK_ENTITY_TO_CLASS( tf_projectile_sentryrocket, CTFProjectile_SentryRocket );
+
+IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_SentryRocket, DT_TFProjectile_SentryRocket )
+
+BEGIN_NETWORK_TABLE( CTFProjectile_SentryRocket, DT_TFProjectile_SentryRocket )
+END_NETWORK_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: Creation
+//-----------------------------------------------------------------------------
+CTFProjectile_SentryRocket *CTFProjectile_SentryRocket::Create( const Vector &vecOrigin, const QAngle &vecAngles, CBaseEntity *pOwner, CBaseEntity *pScorer )
+{
+	CTFProjectile_SentryRocket *pRocket = static_cast<CTFProjectile_SentryRocket*>( CTFBaseRocket::Create( NULL, "tf_projectile_sentryrocket", vecOrigin, vecAngles, pOwner ) );
+
+	if ( pRocket )
+	{
+		pRocket->SetScorer( pScorer );
+	}
+
+	return pRocket;
+}
+
+CTFProjectile_SentryRocket::CTFProjectile_SentryRocket()
+{
+	UseClientSideAnimation();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void CTFProjectile_SentryRocket::Spawn()
+{
+	BaseClass::Spawn();
+
+	SetModel( SENTRY_ROCKET_MODEL );
+
+	UTIL_SetSize( this, vec3_origin, vec3_origin );
+
+	ResetSequence( LookupSequence("idle") );
+}
+
+#ifdef STAGING_ONLY
+//-----------------------------------------------------------------------------
+// Purpose: Directly create a sentry gun at the precise position and orientation desired
+//-----------------------------------------------------------------------------
+void CC_SentrygunSpawn( const CCommand& args )
+{
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return; 
+
+	CObjectSentrygun *sentry = (CObjectSentrygun *)CreateEntityByName( "obj_sentrygun" );
+	if ( sentry )
+	{
+		CBasePlayer* pPlayer = UTIL_GetCommandClient();
+		trace_t tr;
+		Vector forward;
+		pPlayer->EyeVectors( &forward );
+		UTIL_TraceLine( pPlayer->EyePosition(),
+						pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_SOLID, 
+						pPlayer, COLLISION_GROUP_NONE, &tr );
+
+		if ( tr.fraction != 1.0 )
+		{
+			sentry->SetAbsOrigin( tr.endpos );
+			QAngle angles = pPlayer->BodyAngles();
+			angles.x = 0.0f;
+			angles.z = 0.0f;
+			sentry->SetAbsAngles( angles );
+		}
+
+		int iSentryLevel = 2;
+		int iTeamNum = pPlayer->GetTeamNumber();
+
+		if ( args.ArgC() > 1 )
+		{
+			int i = atoi(args[1]);
+			if ( abs(i) >= 1 && abs(i) <= 3)
+			{
+				iSentryLevel = abs(i)-1;
+			}
+
+			if ( i < 0)
+			{
+				iTeamNum = GetEnemyTeam( iTeamNum );
+			}
+		}
+
+		sentry->m_nDefaultUpgradeLevel = iSentryLevel;
+
+		sentry->Spawn();
+		sentry->ChangeTeam( iTeamNum );
+
+		sentry->InitializeMapPlacedObject();
+	}
+}
+static ConCommand sentrygun_spawn( "sentrygun_spawn", CC_SentrygunSpawn, "Spawns a Sentrygun where the player is looking. Takes a parameter for level of sentry [1-3: default 3]. If the passed sentry level < 0, an enemy sentry is spawned.", FCVAR_GAMEDLL | FCVAR_CHEAT );
+
+#endif // STAGING_ONLY
\ No newline at end of file