tf2/tf2_src/game/server/tf/tf_obj_sapper.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Slowly damages the object it's attached to
//
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "tf_player.h"
#include "tf_team.h"
#include "tf_gamerules.h"
#include "tf_obj.h"
#include "tf_obj_sentrygun.h"
#include "tf_obj_sapper.h"
#include "ndebugoverlay.h"
#include "tf_gamestats.h"
#include "tf_obj_teleporter.h"
#include "tf_weapon_builder.h"
#include "tf_fx.h"

#include "bot/tf_bot.h"

ConVar tf_mvm_notice_sapped_squadmates_delay( "tf_mvm_notice_sapped_squadmates_delay", "1", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "How long it takes for a squad leader to notice his squadmate was sapped" );


// ------------------------------------------------------------------------ //

#define SAPPER_MINS				Vector(0, 0, 0)
#define SAPPER_MAXS				Vector(1, 1, 1)

const char * g_sapperModel = "models/buildables/sapper_placed.mdl";
const char * g_sapperPlacementModel = "models/buildables/sapper_placement.mdl";

BEGIN_DATADESC( CObjectSapper )
	DEFINE_THINKFUNC( SapperThink ),
END_DATADESC()

IMPLEMENT_SERVERCLASS_ST(CObjectSapper, DT_ObjectSapper)
END_SEND_TABLE();

LINK_ENTITY_TO_CLASS(obj_attachment_sapper, CObjectSapper);
PRECACHE_REGISTER(obj_attachment_sapper);

ConVar	obj_sapper_amount( "obj_sapper_amount", "25", FCVAR_NONE, "Amount of health inflicted by a Sapper object per second" );

#define SAPPER_THINK_CONTEXT		"SapperThink"
#define SAPPER_REMOVE_DISABLE_TIME			0.5f

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CObjectSapper::CObjectSapper()
{
	m_szPlacementModel[ 0 ] = '\0';
	m_szSapperModel[ 0 ] = '\0';
	szSapperSound[ 0 ] = '\0';

	m_iHealth = GetBaseHealth();
	SetMaxHealth( m_iHealth );

	m_flSelfDestructTime = 0;

	UseClientSideAnimation();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectSapper::UpdateOnRemove()
{
	StopSound( "Weapon_Sapper.Timer" );
	StopSound( "Weapon_sd_sapper.Timer" );
	StopSound( "Weapon_p2rec.Timer" );
#ifdef STAGING_ONLY
	StopSound( "WeaponDynamiteSapper.TickTock" );
	StopSound( "WeaponDynamiteSapper.BellRing" );
#endif

	if( GetBuilder() )
	{
		GetBuilder()->OnSapperFinished( m_flSapperStartTime );
	}
	

	BaseClass::UpdateOnRemove();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectSapper::Spawn()
{
	SetModel( GetSapperModelName( SAPPER_MODEL_PLACEMENT ) );

	m_takedamage = DAMAGE_YES;
	m_iHealth = GetBaseHealth();

	SetType( OBJ_ATTACHMENT_SAPPER );

	BaseClass::Spawn();

	Vector mins = SAPPER_MINS;
	Vector maxs = SAPPER_MAXS;
	CollisionProp()->SetSurroundingBoundsType( USE_SPECIFIED_BOUNDS, &mins, &maxs );

	int nFlags = m_fObjectFlags | OF_ALLOW_REPEAT_PLACEMENT;

	// Don't allow repeat placement as a human spy in MvM
	if ( TFGameRules() && TFGameRules()->GameModeUsesMiniBosses() && 
		 GetBuilder() && !GetBuilder()->IsBot() )
	{
		nFlags &= ~( OF_ALLOW_REPEAT_PLACEMENT );
	}

	m_fObjectFlags.Set( nFlags );

	SetSolid( SOLID_NONE );

#ifdef STAGING_ONLY	
	m_bIsRinging = false;
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectSapper::Precache()
{
	Precache( "c_sapper.mdl" );			// Precache the placed and placement models for the sappers
#ifdef STAGING_ONLY	
	Precache( "c_sd_sapper.mdl" );
#else
	Precache( "w_sd_sapper.mdl" );
#endif
	Precache( "c_p2rec.mdl" );
	Precache( "c_sapper_xmas.mdl" );
	Precache( "c_breadmonster_sapper.mdl" );

	PrecacheScriptSound( "Weapon_Sapper.Plant" );
	PrecacheScriptSound( "Weapon_Sapper.Timer" );
	PrecacheScriptSound( "Weapon_sd_sapper.Timer" );
	PrecacheScriptSound( "Weapon_p2rec.Timer" );
#ifdef STAGING_ONLY	
	PrecacheScriptSound( "WeaponDynamiteSapper.TickTock" );
	PrecacheScriptSound( "WeaponDynamiteSapper.BellRing" );
#endif

	// Precache the Wheatley Sapper sounds
	PrecacheScriptSound( "PSap.null" );
	PrecacheScriptSound( "Psap.Attached" );
	PrecacheScriptSound( "Psap.AttachedPW" );
	PrecacheScriptSound( "PSap.Damage" );
	PrecacheScriptSound( "PSap.Death" );
	PrecacheScriptSound( "PSap.DeathLong" );
	PrecacheScriptSound( "PSap.Deploy" );
	PrecacheScriptSound( "PSap.DeployAgain" );
	PrecacheScriptSound( "PSap.DeployIntro" );
	PrecacheScriptSound( "PSap.Hacked" );
	PrecacheScriptSound( "Psap.HackedFollowup" );
	PrecacheScriptSound( "Psap.HackedLoud" );
	PrecacheScriptSound( "PSap.Hacking" );
	PrecacheScriptSound( "PSap.HackingPW" );
	PrecacheScriptSound( "PSap.HackingShort" );
	PrecacheScriptSound( "PSap.Holster" );
	PrecacheScriptSound( "PSap.HolsterFast" );
	PrecacheScriptSound( "Psap.Idle" );
	PrecacheScriptSound( "Psap.IdleHack02" );
	PrecacheScriptSound( "Psap.IdleHarmless02" );
	PrecacheScriptSound( "PSap.IdleIntro01" );
	PrecacheScriptSound( "PSap.IdleIntro02" );
	PrecacheScriptSound( "PSap.IdleIntro03" );
	PrecacheScriptSound( "PSap.IdleIntro04" );
	PrecacheScriptSound( "PSap.IdleKnife02" );
	PrecacheScriptSound( "PSap.IdleKnife03" );
	PrecacheScriptSound( "PSap.Sneak" );

	BaseClass::Precache();
}

void CObjectSapper::Precache( const char *pchBaseModel )
{
	m_szPlacementModel[ 0 ] = '\0';
	m_szSapperModel[ 0 ] = '\0';

	int iModelIndex;

	iModelIndex = PrecacheModel( GetSapperModelName( SAPPER_MODEL_PLACED, pchBaseModel ) );
	PrecacheGibsForModel( iModelIndex );
	PrecacheModel( GetSapperModelName( SAPPER_MODEL_PLACEMENT, pchBaseModel ) );

	m_szPlacementModel[ 0 ] = '\0';
	m_szSapperModel[ 0 ] = '\0';
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectSapper::FinishedBuilding( void )
{
	BaseClass::FinishedBuilding();

	CBaseEntity *pEntity =  m_hBuiltOnEntity.Get();
	if ( pEntity )
	{
		if ( GetParentObject() )
		{
			GetParentObject()->OnAddSapper();

			CBaseObject *pObject = dynamic_cast<CBaseObject *>( m_hBuiltOnEntity.Get() );
			if ( pObject )
			{
				if ( GetBuilder() && pObject->GetBuilder() )
				{
					IGameEvent * event = gameeventmanager->CreateEvent( "player_sapped_object" );
					if ( event )
					{
						event->SetInt( "userid", GetBuilder()->GetUserID() );
						event->SetInt( "ownerid", pObject->GetBuilder()->GetUserID() );
						event->SetInt( "object", pObject->ObjectType() );
						event->SetInt( "sapperid", entindex() );

						gameeventmanager->FireEvent( event );
					}
				}
			}
		}
	}

	if( GetBuilder() )
	{
		m_flSapperStartTime = gpGlobals->curtime;
		GetBuilder()->OnSapperStarted( m_flSapperStartTime );
	}

	EmitSound( "Weapon_Sapper.Plant" );
	EmitSound( GetSapperSoundName() );	// start looping "Weapon_Sapper.Timer", killed when we die

	m_flSapperDamageAccumulator = 0;
	m_flLastThinkTime = gpGlobals->curtime;
	m_flLastHealthLeachTime = gpGlobals->curtime;

	SetContextThink( &CObjectSapper::SapperThink, gpGlobals->curtime + 0.1, SAPPER_THINK_CONTEXT );
}

//-----------------------------------------------------------------------------
// Purpose: Change our model based on the object we are attaching to
//-----------------------------------------------------------------------------
void CObjectSapper::SetupAttachedVersion( void )
{
	if ( !IsParentValid() )
		return;

	if ( IsPlacing() )
	{
		CBaseEntity *pEntity = m_hBuiltOnEntity.Get();
		if ( pEntity )
		{
			SetModel( GetSapperModelName( SAPPER_MODEL_PLACEMENT ) );
		}
	}

	BaseClass::SetupAttachedVersion();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectSapper::OnGoActive( void )
{
	if ( !IsParentValid() )
		return;

	// set new model
	CBaseEntity *pEntity = m_hBuiltOnEntity.Get();

	m_flSelfDestructTime = 0;
	CTFPlayer *pBuilder = ToTFPlayer( GetBuilder() );

	if ( pEntity )
	{
		SetModel( GetSapperModelName( SAPPER_MODEL_PLACED ) );
		
		if ( pEntity->IsPlayer() )	// Sapped bot in MvM mode, or player in bountymode
		{
			float flTime = 4.f;

			if ( pBuilder )
			{
				int iRoboSapper = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pBuilder, iRoboSapper, robo_sapper );

				CTFPlayer *pTFParent = ToTFPlayer( GetParentEntity() );
				if ( pTFParent && pTFParent->IsAlive() )
				{	
					int nRadius = 200;

					switch( iRoboSapper )
					{
					case 2:
						flTime = 5.5f;
						nRadius = 225;
						break;
					case 3:
						flTime = 7.f;
						nRadius = 250;
						break;
					default:
						break;
					}

					// Unlimited, single-target version of the RoboSapper
					if ( GetObjectMode() == MODE_SAPPER_ANTI_ROBOT )
					{
						nRadius = 0;
					}

					ApplyRoboSapper( pTFParent, flTime, nRadius );
				}
			}

			m_flSelfDestructTime = gpGlobals->curtime + flTime;
		}

#ifdef STAGING_ONLY			
		//if ( pBuilder )
		//{
		//	float flExplodeOnTimer = 0;
		//	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pBuilder, flExplodeOnTimer, sapper_explodes_on_timer )
		//	{
		//		if ( flExplodeOnTimer != 0 )
		//		{
		//			// timer is based on health of the object
		//			// Sappers normally do 25dps
		//			//float flTimer = pEntity->GetMaxHealth() * 0.04f;
		//			//m_flSelfDestructTime = gpGlobals->curtime + flExplodeOnTimer;
		//		}
		//	}
		//}
#endif
	}

	UTIL_SetSize( this, SAPPER_MINS, SAPPER_MAXS );
	SetSolid( SOLID_NONE );

	BaseClass::OnGoActive();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CObjectSapper::IsParentValid( void )
{
	bool bValid = false;

	CBaseEntity *pEntity = m_hBuiltOnEntity.Get();
	if ( pEntity )
	{
		if ( pEntity->IsPlayer() )	// sapped bot in MvM mode
		{
			bValid = true;
		}
		else
		{
			CBaseObject *pObject = dynamic_cast<CBaseObject *>( pEntity ); 
			if ( pObject )
			{
				bValid = true;
			}
		}
	}

	if ( !bValid )
	{
		DestroyObject();
	}

	return bValid;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectSapper::DetachObjectFromObject( void )
{
	CBaseObject *pParent = GetParentObject();
	if ( pParent )
	{
		pParent->OnRemoveSapper();

#ifdef STAGING_ONLY
		CTFPlayer *pBuilder = GetBuilder();
		if ( pBuilder && pParent->GetHealth() < 0 )
		{
			// Attr on Det
			float flExplodeOnTimer = 0;
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pBuilder, flExplodeOnTimer, sapper_explodes_on_det );

			if ( flExplodeOnTimer )
			{
				float flDamage = pParent->GetMaxHealth() * 1.5;
				Vector vecOrigin = GetAbsOrigin();

				// Use the building as the det position			
				CTakeDamageInfo detInfo;
				detInfo.SetDamage( flDamage );
				detInfo.SetAttacker( this );
				detInfo.SetInflictor( this );
				detInfo.SetDamageType( DMG_BLAST );

				// Generate Large Radius Damage
				float flRadius = 200.0f;
				CTFRadiusDamageInfo radiusinfo( &detInfo, vecOrigin, flRadius, NULL, flRadius );
				TFGameRules()->RadiusDamage( radiusinfo );

				DispatchParticleEffect( "explosionTrail_seeds_mvm", vecOrigin, GetAbsAngles() );
			}
		}
#endif
	}

	BaseClass::DetachObjectFromObject();
}

//-----------------------------------------------------------------------------
const char* CObjectSapper::GetSapperModelName( SapperModel_t nModel, const char *pchModelName /*= NULL */)
{
	// Check to see if we have model names generated, if not we must generate
	if ( m_szPlacementModel[0] == '\0' || m_szSapperModel[0] == '\0' )
	{
		if ( !pchModelName )
		{
			if ( GetBuilder() )
			{
				CTFWeaponBuilder *pWeapon = dynamic_cast< CTFWeaponBuilder* >( GetBuilder()->Weapon_GetWeaponByType( TF_WPN_TYPE_BUILDING ) );
				if ( pWeapon )
				{
					pchModelName = pWeapon->GetWorldModel();
				}
			}
		}

		if ( !pchModelName )
		{
			 if ( nModel >= SAPPER_MODEL_PLACEMENT )
				 return g_sapperPlacementModel;
			 return g_sapperModel;
		}

		// Generate Models
		// Name base
		char szModelName[ _MAX_PATH ];
		V_FileBase( pchModelName, szModelName, sizeof( szModelName ) );
		pchModelName = szModelName + 2;

#ifdef STAGING_ONLY	
		if (!V_strcmp(pchModelName, "sd_sapper"))
		{
			V_snprintf(m_szPlacementModel, sizeof(m_szPlacementModel), "models/workshop_partner/buildables/%s%s", pchModelName, "_placement.mdl");
			V_snprintf(m_szSapperModel, sizeof(m_szSapperModel), "models/workshop_partner/buildables/%s%s", pchModelName, "_placed.mdl");
		}
		else
#endif
		{
			V_snprintf(m_szPlacementModel, sizeof(m_szPlacementModel), "models/buildables/%s%s", pchModelName, "_placement.mdl");
			V_snprintf(m_szSapperModel, sizeof(m_szSapperModel), "models/buildables/%s%s", pchModelName, "_placed.mdl");
		}
	}

	if ( nModel >= SAPPER_MODEL_PLACEMENT )
	{
		return m_szPlacementModel;
	}
	return m_szSapperModel;
}

//-----------------------------------------------------------------------------
const char* CObjectSapper::GetSapperSoundName( void )
{
	if ( szSapperSound[ 0 ] == '\0' )
	{
		const char *pchModelName = NULL;
		if ( GetBuilder() )
		{
			CTFWeaponBuilder *pWeapon = dynamic_cast< CTFWeaponBuilder* >( GetBuilder()->Weapon_GetWeaponByType( TF_WPN_TYPE_BUILDING ) );
			if ( pWeapon )
			{
				pchModelName = pWeapon->GetWorldModel();
			}
		}

#ifdef STAGING_ONLY
		// // Attr on Det
		float flExplodeOnTimer = 0;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBuilder(), flExplodeOnTimer, sapper_explodes_on_det );
		if ( flExplodeOnTimer )
		{
			EmitSound( "Weapon_Sapper.Timer" );
			return "WeaponDynamiteSapper.TickTock";
		}
#endif

		if ( !pchModelName )
		{
			return "Weapon_Sapper.Timer";
		}

		char szModelName[ _MAX_PATH ];
		V_FileBase( pchModelName, szModelName, sizeof( szModelName ) );

		pchModelName = szModelName + 2;

		V_snprintf( szSapperSound, sizeof( szSapperSound ), "Weapon_%s.Timer", pchModelName );
	}

	return szSapperSound;
}

//-----------------------------------------------------------------------------
// Purpose: Slowly destroy the object I'm attached to
//-----------------------------------------------------------------------------
void CObjectSapper::SapperThink( void )
{
	if ( !GetTeam() )
		return;

	bool bThink = true;

	CBaseEntity *pEntity = m_hBuiltOnEntity.Get();
	if ( pEntity )
	{
		if ( pEntity->IsPlayer() )	// sapping bots in MvM mode
		{
			bool bDestroy = false;

			CTFPlayer *pTFOwner = ToTFPlayer( m_hBuiltOnEntity.Get() );
			CTFPlayer *pBuilder = GetBuilder();
			if ( !pBuilder || !pTFOwner || ( pTFOwner && !pTFOwner->IsAlive() ) )
			{		
				bDestroy = true;
			}

#ifdef STAGING_ONLY 
			/*if ( gpGlobals->curtime >= m_flSelfDestructTime )
			{
				bDestroy = true;
				Explode();
			}*/
#else
			if ( gpGlobals->curtime >= m_flSelfDestructTime )
			{
				bDestroy = true;
				Explode();
			}
#endif			

			if ( bDestroy )
			{
				DestroyObject();
				bThink = false;
				return;
			}
		}
		else
		{
			CBaseObject *pObject = GetParentObject();
			if ( !pObject )
			{
				DestroyObject();
				bThink = false;
				return;
			}

			// Don't bring objects back from the dead
			if ( !pObject->IsAlive() || pObject->IsDying() )
				return;

			CTFPlayer *pBuilder = GetBuilder();

			// how much damage to give this think?
			float flTimeSinceLastThink = gpGlobals->curtime - m_flLastThinkTime;
			float flDamageToGive = ( flTimeSinceLastThink ) * obj_sapper_amount.GetFloat();
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pBuilder, flDamageToGive, mult_sapper_damage );

			// add to accumulator
			m_flSapperDamageAccumulator += flDamageToGive;

			int iDamage = (int)m_flSapperDamageAccumulator;

			m_flSapperDamageAccumulator -= iDamage;

			// sapper building damage added to health of Vampire Powerup carrier
			if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
			{
				CTFPlayer *pTFOwner = ToTFPlayer( GetOwner() ); 
			
				if ( pTFOwner && pTFOwner->m_Shared.GetCarryingRuneType() == RUNE_VAMPIRE )
				{
					pTFOwner->TakeHealth( flDamageToGive, DMG_GENERIC );
				}
			}

			int iCustomDamage = 0;
			if ( GetReversesBuildingConstructionSpeed() != 0.0f )
			{
				iCustomDamage = TF_DMG_CUSTOM_SAPPER_RECORDER_DEATH;
			}

			CTakeDamageInfo info;
			info.SetDamage( iDamage );
			info.SetAttacker( this );
			info.SetInflictor( this );
			info.SetDamageType( DMG_CRUSH );
			info.SetDamageCustom( iCustomDamage );

			pObject->TakeDamage( info );

			if ( gpGlobals->curtime - m_flLastHealthLeachTime > 1.0f )
			{
				m_flLastHealthLeachTime = gpGlobals->curtime;

				float flHealOwnerPerSecond = 0.0f;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pBuilder, flHealOwnerPerSecond, sapper_damage_leaches_health );

				if ( flHealOwnerPerSecond )
				{
					CTFPlayer *pSpyOwner = GetOwner();
					if ( pSpyOwner && pSpyOwner->IsAlive() )
					{
						pSpyOwner->TakeHealth( flHealOwnerPerSecond, DMG_IGNORE_MAXHEALTH );
						pSpyOwner->m_Shared.HealthKitPickupEffects( flHealOwnerPerSecond );
					}
				}
			}

#ifdef STAGING_ONLY
			if ( !m_bIsRinging && pObject->GetHealth() < 60.0f )
			{
				int iDetonate = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pBuilder, iDetonate, sapper_explodes_on_det );
				if ( iDetonate )
				{
					EmitSound( "WeaponDynamiteSapper.BellRing" );
					m_bIsRinging = true;
				}
			}
			
			//float flExplodeOnTimer = 0;
			//CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pBuilder, flExplodeOnTimer, sapper_explodes_on_det );

			////if ( flExplodeOnTimer != 0 && m_flSelfDestructTime < gpGlobals->curtime )
			//if ( flExplodeOnTimer )
			//{
			//	float flDamage = pObject->GetMaxHealth() * 1.5;
			//	Explode();
			//	DestroyObject();

			//	Vector vecOrigin = GetAbsOrigin();

			//	// Use the building as the det position			
			//	CTakeDamageInfo detInfo;
			//	detInfo.SetDamage( flDamage );
			//	detInfo.SetAttacker( this );
			//	detInfo.SetInflictor( this );
			//	detInfo.SetDamageType( DMG_BLAST );

			//	// Destroy the building by doubly applying damage
			//	pObject->TakeDamage( detInfo );

			//	// Generate Large Radius Damage
			//	float flRadius = 200.0f;	// same as pipebomb launcher
			//	CTFRadiusDamageInfo radiusinfo( &detInfo, vecOrigin, flRadius, NULL, flRadius );
			//	TFGameRules()->RadiusDamage( radiusinfo );

			//	DispatchParticleEffect( "explosionTrail_seeds_mvm", vecOrigin, GetAbsAngles() );
			//}
#endif			
		}
	}

	if ( bThink )
	{
		SetNextThink( gpGlobals->curtime + 0.1f, SAPPER_THINK_CONTEXT );
	}

	m_flLastThinkTime = gpGlobals->curtime;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CObjectSapper::OnTakeDamage( const CTakeDamageInfo &info )
{
	if ( info.GetDamageCustom() != TF_DMG_WRENCH_FIX )
	{
		// See if the weapon has a "I damage sappers" attribute on it
		int iDmgSappers = 0;
		CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(info.GetWeapon());
		if ( pWeapon )
		{
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iDmgSappers, set_dmg_apply_to_sapper );
		}
		if ( iDmgSappers == 0 )
			return 0;
	}

	// Is the damage from something other than another sapper? (which might be on our matching teleporter)
	if ( !( info.GetDamageType() & DMG_FROM_OTHER_SAPPER ) )
	{
		if ( GetParentObject() )
		{
			CTakeDamageInfo localDamageInfo = info;
			localDamageInfo.AddDamageType( DMG_FROM_OTHER_SAPPER );

			// If there's a matching teleporter with a sapper then have that sapper take damage, too.
			CObjectTeleporter *pParentTeleporter = dynamic_cast< CObjectTeleporter * >( GetParentObject() );
			if ( pParentTeleporter )
			{
				// GetMatchingTeleporter is set when a matching teleporter is ACTIVE
				// if we don't find the cache matching teleporter, try to find with a more expensive FindMatch func
				CObjectTeleporter *pMatchingTeleporter = pParentTeleporter->GetMatchingTeleporter() ? pParentTeleporter->GetMatchingTeleporter() : pParentTeleporter->FindMatch();
				if ( pMatchingTeleporter && pMatchingTeleporter->HasSapper() )
				{
					// Do damage to any attached buildings
					IHasBuildPoints *pBPInterface = dynamic_cast< IHasBuildPoints * >( pMatchingTeleporter );
					int iNumObjects = pBPInterface->GetNumObjectsOnMe();
					for ( int iPoint = 0 ; iPoint < iNumObjects ; iPoint++ )
					{
						CBaseObject *pObject = pMatchingTeleporter->GetBuildPointObject( iPoint );
						if ( pObject && pObject->IsHostileUpgrade() )
						{
							pObject->TakeDamage( localDamageInfo );
						}
					}
				}
			}
		}
	}

	return BaseClass::OnTakeDamage( info );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObjectSapper::Killed( const CTakeDamageInfo &info )
{
	CBaseEntity *pInflictor = info.GetInflictor();
	CBaseEntity *pKiller = info.GetAttacker();
	CTFPlayer *pScorer = ToTFPlayer( TFGameRules()->GetDeathScorer( pKiller, pInflictor, this ) );

	// We don't own the building we removed the sapper from
	if ( pScorer && GetParentObject() && GetParentObject()->GetOwner() != pScorer )
	{
		// Give a bonus point for it
		if ( TFGameRules()->GameModeUsesUpgrades() )
		{
			CTF_GameStats.Event_PlayerAwardBonusPoints( pScorer, this, 10 );
		}

		if ( pScorer->IsPlayerClass( TF_CLASS_ENGINEER ) )
		{
			pScorer->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_DESTROY_SAPPERS, 1 );
		}
	}

	// Optional: if a weapon was used to destroy this sapper, we give the weapon an opportunity
	//			 to adjust its stats.
	{
		CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( info.GetWeapon() );
		if ( pWeapon )
		{
			EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( info.GetWeapon() ),		// econ entity
											  pWeapon->GetTFPlayerOwner(),							// scorer
											  GetOwner(),											// victim
											  kKillEaterEvent_SapperDestroyed );
		}
	}

	CBaseObject *pParent = GetParentObject();
	if ( pParent )
	{
		pParent->SetPlasmaDisabled( SAPPER_REMOVE_DISABLE_TIME );
	}

	BaseClass::Killed( info );
}

int CObjectSapper::GetBaseHealth( void )
{
	float flSapperHealth = SAPPER_MAX_HEALTH;
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBuilder(), flSapperHealth, mult_sapper_health );

	return flSapperHealth;
}

//-----------------------------------------------------------------------------
// Purpose: Search for players to apply RoboSapper effects to
//-----------------------------------------------------------------------------
void CObjectSapper::ApplyRoboSapper( CTFPlayer *pTarget, float flDuration, int nRadius /*= 200*/ )
{
	// Apply effects to primary target
	if ( IsValidRoboSapperTarget( pTarget ) )
	{
		ApplyRoboSapperEffects( pTarget, flDuration );
	}

	// If we have a radius, search it for valid targets
	if ( nRadius )
	{
		int iCount = 0;
		for ( int i = 1; i < gpGlobals->maxClients; i++ )
		{
			CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
			if ( !pPlayer )
				continue;

			// Ignore the primary target (handled above)
			if ( pPlayer == pTarget )
				continue;

			// Same team, alive, etc
			if ( !IsValidRoboSapperTarget( pPlayer ) )
				continue;

			// Range check from pTarget
			Vector vecDist = pPlayer->GetAbsOrigin() - GetAbsOrigin();
			if ( vecDist.LengthSqr() > nRadius * nRadius )
				continue;

			// Ignore bots we can't see
			trace_t	trace;
			UTIL_TraceLine( pPlayer->WorldSpaceCenter(), WorldSpaceCenter(), MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &trace );
			if ( trace.fraction < 1.0f )
				continue;

			// Apply
			if ( ApplyRoboSapperEffects( pPlayer, flDuration ) )
				iCount++;
		}

		// ACHIEVEMENT_TF_MVM_SPY_SAP_ROBOTS
		if ( iCount >= 10 )
		{
			CTFPlayer *pBuilder = ToTFPlayer( GetBuilder() );
			if ( pBuilder && TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
			{
				pBuilder->AwardAchievement( ACHIEVEMENT_TF_MVM_SPY_SAP_ROBOTS );
			}
		}

		Vector vecOrigin = GetAbsOrigin();
		CPVSFilter filter( vecOrigin );
		TE_TFParticleEffect( filter, 0.f, "Explosion_ShockWave_01", vecOrigin, vec3_angle );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Applies effects of the RoboSapper to pTarget for flDuration
//-----------------------------------------------------------------------------
bool CObjectSapper::ApplyRoboSapperEffects( CTFPlayer *pTarget, float flDuration )
{
	if ( !pTarget )
		return false;

	int iStunFlags = TF_STUN_MOVEMENT | TF_STUN_CONTROLS | TF_STUN_NO_EFFECTS;

	// Giants and players can't be fully incapacitated - only slowed
	CTFBot *pTFBot = static_cast<CTFBot *>( pTarget );
	if ( ( pTFBot && pTFBot->IsMiniBoss() ) || !pTFBot )
	{
		iStunFlags = TF_STUN_MOVEMENT;
	}

	pTarget->m_Shared.StunPlayer( flDuration, 0.85f, iStunFlags, GetBuilder() );
	pTarget->m_Shared.AddCond( TF_COND_SAPPED, flDuration, GetBuilder() );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Valid player to apply RoboSapper effects to?
//-----------------------------------------------------------------------------
bool CObjectSapper::IsValidRoboSapperTarget( CTFPlayer *pTarget )
{
	if ( !pTarget )
		return false;

	if ( !pTarget->IsAlive() )
		return false;

	if ( GetBuilder() && GetBuilder()->GetTeamNumber() == pTarget->GetTeam()->GetTeamNumber() )
		return false;

	if ( pTarget->m_Shared.IsInvulnerable() )
		return false;

	if ( pTarget->m_Shared.InCond( TF_COND_PHASE ) )
		return false;

	if ( pTarget->m_Shared.InCond( TF_COND_SAPPED ) )
		return false;

	if ( pTarget->m_Shared.InCond( TF_COND_REPROGRAMMED ) )
		return false;

	return true;
}

float CObjectSapper::GetReversesBuildingConstructionSpeed( void )
{
	float flReverseSpeed = 0.0f;
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetBuilder(), flReverseSpeed, sapper_degenerates_buildings );

	return flReverseSpeed;
}