source-engine/game/server/tf/tf_obj_sentrygun.cpp

//========= 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