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

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// TF Arrow
//
//=============================================================================
#include "cbase.h"
#include "tf_projectile_arrow.h"
#include "soundent.h"
#include "tf_fx.h"
#include "props.h"
#include "baseobject_shared.h"
#include "SpriteTrail.h"
#include "IEffects.h"
#include "te_effect_dispatch.h"
#include "collisionutils.h"
#include "bone_setup.h"
#include "decals.h"
#include "tf_player.h"
#include "tf_gamestats.h"
#include "tf_pumpkin_bomb.h"
#include "tf_weapon_shovel.h"
#include "player_vs_environment/tf_tank_boss.h"
#include "halloween/halloween_base_boss.h"
#include "halloween/merasmus/merasmus_trick_or_treat_prop.h"
#include "tf_logic_robot_destruction.h"

#include "tf_gamerules.h"
#include "bot/tf_bot.h"
#include "tf_weapon_medigun.h"
#include "soundenvelope.h"


//=============================================================================
//
// TF Arrow Projectile functions (Server specific).
//
#define ARROW_MODEL_GIB1			"models/weapons/w_models/w_arrow_gib1.mdl"
#define ARROW_MODEL_GIB2			"models/weapons/w_models/w_arrow_gib2.mdl"

#define ARROW_GRAVITY				0.3f

#define ARROW_THINK_CONTEXT			"CTFProjectile_ArrowThink"

#define CLAW_TRAIL_RED				"effects/repair_claw_trail_red.vmt"
#define CLAW_TRAIL_BLU				"effects/repair_claw_trail_blue.vmt"
#define CLAW_GIB1					"models/weapons/w_models/w_repair_claw_gib1.mdl"
#define CLAW_GIB2					"models/weapons/w_models/w_repair_claw_gib2.mdl"

#define CLAW_REPAIR_EFFECT_BLU		"repair_claw_heal_blue"
#define CLAW_REPAIR_EFFECT_RED		"repair_claw_heal_red"
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( tf_projectile_arrow, CTFProjectile_Arrow );
PRECACHE_WEAPON_REGISTER( tf_projectile_arrow );

IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_Arrow, DT_TFProjectile_Arrow )

BEGIN_NETWORK_TABLE( CTFProjectile_Arrow, DT_TFProjectile_Arrow )
	SendPropBool( SENDINFO( m_bArrowAlight ) ),
	SendPropBool( SENDINFO( m_bCritical ) ),
	SendPropInt( SENDINFO( m_iProjectileType ) ),
END_NETWORK_TABLE()

BEGIN_DATADESC( CTFProjectile_Arrow )
DEFINE_THINKFUNC( ImpactThink ),
END_DATADESC()

//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( tf_projectile_healing_bolt, CTFProjectile_HealingBolt );
PRECACHE_WEAPON_REGISTER( tf_projectile_healing_bolt );

IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_HealingBolt, DT_TFProjectile_HealingBolt )

BEGIN_NETWORK_TABLE( CTFProjectile_HealingBolt, DT_TFProjectile_HealingBolt )
END_NETWORK_TABLE()

BEGIN_DATADESC( CTFProjectile_HealingBolt )
END_DATADESC()

//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( tf_projectile_grapplinghook, CTFProjectile_GrapplingHook );
PRECACHE_WEAPON_REGISTER( tf_projectile_grapplinghook );

IMPLEMENT_NETWORKCLASS_ALIASED( TFProjectile_GrapplingHook, DT_TFProjectile_GrapplingHook )

BEGIN_NETWORK_TABLE( CTFProjectile_GrapplingHook, DT_TFProjectile_GrapplingHook )
END_NETWORK_TABLE()

BEGIN_DATADESC( CTFProjectile_GrapplingHook )
END_DATADESC()

//-----------------------------------------------------------------------------
// Purpose: Helper to set a grappling hook target on all healers of this player
//-----------------------------------------------------------------------------
static void SetMedicsGrapplingHookTarget( CTFPlayer *pTFPlayer, CBaseEntity *pGrappleTarget )
{
	int i;
	int iNumHealers = pTFPlayer->m_Shared.GetNumHealers();
	for ( i = 0 ; i < iNumHealers ; i++ )
	{
		CTFPlayer *pMedic = ToTFPlayer( pTFPlayer->m_Shared.GetHealerByIndex( i ) );
		// Only want medics who are directly healing us with their medigun, not e.g. AoE healers.
		if ( pMedic && ToTFPlayer ( pMedic->MedicGetHealTarget() ) == pTFPlayer )
		{
			pMedic->SetGrapplingHookTarget( pGrappleTarget );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Arrow::CTFProjectile_Arrow()
{
	m_flImpactTime = 0.0f;
	m_flTrailLife = 0.f;
	m_pTrail = NULL;
	m_bStruckEnemy = false;
	m_bArrowAlight = false;
	m_iDeflected = 0;
	m_bCritical = false;
	m_flInitTime = 0;
	m_bPenetrate = false;
	m_iProjectileType = TF_PROJECTILE_ARROW;
	m_iWeaponId = TF_WEAPON_COMPOUND_BOW;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Arrow::~CTFProjectile_Arrow()
{
	m_HitEntities.Purge();
}

static const char* GetArrowEntityName( ProjectileType_t projectileType )
{
	switch ( projectileType )
	{
	case TF_PROJECTILE_HEALING_BOLT:
	case TF_PROJECTILE_FESTIVE_HEALING_BOLT:
#ifdef STAGING_ONLY
	case TF_PROJECTILE_MILK_BOLT:
#endif
		return "tf_projectile_healing_bolt";
	case TF_PROJECTILE_GRAPPLINGHOOK:
		return "tf_projectile_grapplinghook";
	
	default:
		return "tf_projectile_arrow";
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFProjectile_Arrow *CTFProjectile_Arrow::Create( const Vector &vecOrigin, const QAngle &vecAngles, const float fSpeed, const float fGravity, ProjectileType_t projectileType, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
	const char* pszArrowEntityName = GetArrowEntityName( projectileType );
	CTFProjectile_Arrow *pArrow = static_cast<CTFProjectile_Arrow*>( CBaseEntity::Create( pszArrowEntityName, vecOrigin, vecAngles, pOwner ) );
	if ( pArrow )
	{
		pArrow->InitArrow( vecAngles, fSpeed, fGravity, projectileType, pOwner, pScorer );
	}

	return pArrow;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::InitArrow( const QAngle &vecAngles, const float fSpeed, const float fGravity, ProjectileType_t projectileType, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
	// Initialize the owner.
	SetOwnerEntity( pOwner );

	// Set team.
	ChangeTeam( pOwner->GetTeamNumber() );

	// must override projectile type before Spawn for proper model
	m_iProjectileType = projectileType;

	// Spawn.
	Spawn();

	SetGravity( fGravity );

	SetCritical( true );

	// Setup the initial velocity.
	Vector vecForward, vecRight, vecUp;
	AngleVectors( vecAngles, &vecForward, &vecRight, &vecUp );

	Vector vecVelocity = vecForward * fSpeed;
	
	SetAbsVelocity( vecVelocity );	
	SetupInitialTransmittedGrenadeVelocity( vecVelocity );

	// Setup the initial angles.
	QAngle angles;
	VectorAngles( vecVelocity, angles );
	SetAbsAngles( angles );

	// Save the scoring player.
	SetScorer( pScorer );

	// Create a trail.
	CreateTrail();

	// Add ourselves to the hit entities list so we dont shoot ourselves
	m_HitEntities.AddToTail( pOwner->entindex() );

	m_flInitTime = gpGlobals->curtime;

#ifdef STAGING_ONLY
	if ( m_iProjectileType == TF_PROJECTILE_SNIPERBULLET )
	{
		CTFPlayer* pTFOwner = ToTFPlayer( pOwner );
		m_bFiredWhileZoomed = ( pTFOwner && pTFOwner->m_Shared.InCond( TF_COND_ZOOMED ) );
	}
	else
#endif // STAGING_ONLY
	{
		m_bFiredWhileZoomed = false;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::Spawn()
{
	if ( m_iProjectileType == TF_PROJECTILE_BUILDING_REPAIR_BOLT )
	{
		SetModel( g_pszArrowModels[MODEL_ARROW_BUILDING_REPAIR] );
		m_iWeaponId = TF_WEAPON_SHOTGUN_BUILDING_RESCUE;
	}
	else if ( m_iProjectileType == TF_PROJECTILE_FESTIVE_ARROW )
	{
		SetModel( g_pszArrowModels[MODEL_FESTIVE_ARROW_REGULAR] );
	}
	else if ( m_iProjectileType == TF_PROJECTILE_HEALING_BOLT 
#ifdef STAGING_ONLY
		|| m_iProjectileType == TF_PROJECTILE_MILK_BOLT 
#endif
	) {
		SetModel( g_pszArrowModels[MODEL_SYRINGE] );
		SetModelScale( 3.0f );
	}
	else if ( m_iProjectileType == TF_PROJECTILE_FESTIVE_HEALING_BOLT )
	{
		SetModel( g_pszArrowModels[MODEL_FESTIVE_HEALING_BOLT] );
		SetModelScale( 3.0f );
	}
#ifdef STAGING_ONLY
	else if ( m_iProjectileType == TF_PROJECTILE_SNIPERBULLET )
	{
		SetModel( g_pszArrowModels[MODEL_SYRINGE] );
		//SetModelScale( 3.0f );
	}
#endif // STAGING_ONLY
	else if ( m_iProjectileType == TF_PROJECTILE_GRAPPLINGHOOK )
	{
		SetModel( g_pszArrowModels[MODEL_GRAPPLINGHOOK] );
	}
	else
	{
		SetModel( g_pszArrowModels[MODEL_ARROW_REGULAR] );
	}

	SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_CUSTOM );
	UTIL_SetSize( this, Vector( -1.0f, -1.0f, -1.0f ), Vector( 1.0f, 1.0f, 1.0f ) );
	SetSolid( SOLID_BBOX );	

	SetCollisionGroup( TFCOLLISION_GROUP_ROCKETS );
	AddEffects( EF_NOSHADOW );
	AddFlag( FL_GRENADE );

	SetTouch( &CTFProjectile_Arrow::ArrowTouch );

	// Set team.
	m_nSkin = GetArrowSkin();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::Precache()
{
	int arrow_model = PrecacheModel( g_pszArrowModels[MODEL_ARROW_REGULAR] );
	int claw_model = PrecacheModel( g_pszArrowModels[MODEL_ARROW_BUILDING_REPAIR] );
	int festive_arrow_model = PrecacheModel( g_pszArrowModels[MODEL_FESTIVE_ARROW_REGULAR] );
	PrecacheModel( g_pszArrowModels[MODEL_FESTIVE_HEALING_BOLT] );

	PrecacheGibsForModel( arrow_model );
	PrecacheGibsForModel( claw_model );
	PrecacheGibsForModel( festive_arrow_model );
	//PrecacheGibsForModel( festive_healing_arrow_model );
	PrecacheModel( "effects/arrowtrail_red.vmt" );
	PrecacheModel( "effects/arrowtrail_blu.vmt" );
	PrecacheModel( "effects/healingtrail_red.vmt" );
	PrecacheModel( "effects/healingtrail_blu.vmt" );
	PrecacheModel( CLAW_TRAIL_RED );
	PrecacheModel( CLAW_TRAIL_BLU );
	PrecacheParticleSystem( CLAW_REPAIR_EFFECT_BLU );
	PrecacheParticleSystem( CLAW_REPAIR_EFFECT_RED );
	PrecacheScriptSound( "Weapon_Arrow.ImpactFlesh" );
	PrecacheScriptSound( "Weapon_Arrow.ImpactMetal" );
	PrecacheScriptSound( "Weapon_Arrow.ImpactWood" );
	PrecacheScriptSound( "Weapon_Arrow.ImpactConcrete" );
	PrecacheScriptSound( "Weapon_Arrow.Nearmiss" );
	PrecacheScriptSound( "Weapon_Arrow.ImpactFleshCrossbowHeal" );

	BaseClass::Precache();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::SetScorer( CBaseEntity *pScorer )
{
	m_Scorer = pScorer;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CBasePlayer *CTFProjectile_Arrow::GetScorer( void )
{
	return dynamic_cast<CBasePlayer *>( m_Scorer.Get() );
}

//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::CanHeadshot() 
{ 
	CBaseEntity *pOwner = GetScorer();
	if ( pOwner == NULL )
		return false;

	if ( m_iProjectileType == TF_PROJECTILE_BUILDING_REPAIR_BOLT 
		|| m_iProjectileType == TF_PROJECTILE_HEALING_BOLT 
		|| m_iProjectileType == TF_PROJECTILE_FESTIVE_HEALING_BOLT 
#ifdef STAGING_ONLY
		|| m_iProjectileType == TF_PROJECTILE_MILK_BOLT
#endif
	) {
		return false;
	}

#ifdef STAGING_ONLY
	if ( m_iProjectileType == TF_PROJECTILE_SNIPERBULLET )
	{
		return m_bFiredWhileZoomed;
	}
#endif // STAGING_ONLY

	return true; 
}

//-----------------------------------------------------------------------------
// Purpose: Healing bolt damage.
//-----------------------------------------------------------------------------
float CTFProjectile_Arrow::GetDamage()
{
	if ( m_iProjectileType == TF_PROJECTILE_HEALING_BOLT
		|| m_iProjectileType == TF_PROJECTILE_FESTIVE_HEALING_BOLT
#ifdef STAGING_ONLY
		|| m_iProjectileType == TF_PROJECTILE_MILK_BOLT 
#endif
	) {
		float lifeTimeScale = RemapValClamped( gpGlobals->curtime - m_flInitTime, 0.0f, 0.6f, 0.5f, 1.0f );	
		return m_flDamage * lifeTimeScale;
	}
	return BaseClass::GetDamage();
}


//-----------------------------------------------------------------------------
// Purpose: Moves the arrow to a particular bbox.
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::PositionArrowOnBone( mstudiobbox_t *pBox, CBaseAnimating *pOtherAnim )
{
	CStudioHdr *pStudioHdr = pOtherAnim->GetModelPtr();
	if ( !pStudioHdr )
		return false;

	mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( pOtherAnim->GetHitboxSet() );
	if ( !set )
		return false;
	if ( !set->numhitboxes )			// Target must have hit boxes.
		return false;

	if ( pBox->bone < 0 || pBox->bone >= pStudioHdr->numbones() )	// Bone index must be valid.
		return false;

	CBoneCache *pCache = pOtherAnim->GetBoneCache();
	if ( !pCache )
		return false;

	matrix3x4_t *bone_matrix = pCache->GetCachedBone( pBox->bone );
	if ( !bone_matrix )
		return false;

	Vector vecBoxAbsMins, vecBoxAbsMaxs;
	TransformAABB( *bone_matrix, pBox->bbmin, pBox->bbmax, vecBoxAbsMins, vecBoxAbsMaxs );

	// Adjust the arrow so it isn't exactly in the center of the box.
	Vector position;
	Vector vecDelta = vecBoxAbsMaxs - vecBoxAbsMins;
	float frand = (float) rand() / VALVE_RAND_MAX;
	position.x = vecBoxAbsMins.x + vecDelta.x*0.6f - vecDelta.x*frand*0.2f;
	frand = (float) rand() / VALVE_RAND_MAX;
	position.y = vecBoxAbsMins.y + vecDelta.y*0.6f - vecDelta.y*frand*0.2f;
	frand = (float) rand() / VALVE_RAND_MAX;
	position.z = vecBoxAbsMins.z + vecDelta.z*0.6f - vecDelta.z*frand*0.2f;
	SetAbsOrigin( position );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: This was written after PositionArrowOnBone, but the two might be mergable?
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::GetBoneAttachmentInfo( mstudiobbox_t *pBox, CBaseAnimating *pOtherAnim, Vector &bonePosition, QAngle &boneAngles, int &boneIndexAttached, int &physicsBoneIndex )
{
	// Find a bone to stick to.
	matrix3x4_t arrowWorldSpace;
	MatrixCopy( EntityToWorldTransform(), arrowWorldSpace );

	// Get the bone info so we can follow the bone.
	boneIndexAttached = pBox->bone;
	physicsBoneIndex = pOtherAnim->GetPhysicsBone( boneIndexAttached );
	matrix3x4_t boneToWorld;
	pOtherAnim->GetBoneTransform( boneIndexAttached, boneToWorld );

	Vector attachedBonePos;
	QAngle attachedBoneAngles;
	pOtherAnim->GetBonePosition( boneIndexAttached, attachedBonePos, attachedBoneAngles );

	// Transform my current position/orientation into the hit bone's space.
	matrix3x4_t worldToBone, localMatrix;
	MatrixInvert( boneToWorld, worldToBone );
	ConcatTransforms( worldToBone, arrowWorldSpace, localMatrix );
	MatrixAngles( localMatrix, boneAngles, bonePosition );
}

//-----------------------------------------------------------------------------
int	CTFProjectile_Arrow::GetProjectileType ( void ) const	
{ 
	return m_iProjectileType;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::StrikeTarget( mstudiobbox_t *pBox, CBaseEntity *pOther )
{
	if ( !pOther )
		return false;

	// Different path for arrows that heal friendly buildings.
	if ( pOther->IsBaseObject() )
	{
		if ( OnArrowImpactObject( pOther ) )
		{
			return false;
		}
	}

	// Block and break on invulnerable players
	CTFPlayer *pTFPlayerOther = ToTFPlayer( pOther );
	if ( pTFPlayerOther && pTFPlayerOther->m_Shared.IsInvulnerable() )
		return false;

	CBaseAnimating *pOtherAnim = dynamic_cast< CBaseAnimating* >(pOther);
	if ( !pOtherAnim )
		return false;

	bool bBreakArrow = IsBreakable() && ( ( dynamic_cast< CTFTankBoss* >( pOther ) != NULL ) || ( dynamic_cast< CHalloweenBaseBoss* >( pOther ) != NULL ) );

	// Position the arrow so its on the bone, within a reasonable region defined by the bbox.
	if ( !m_bPenetrate && !bBreakArrow )
	{
		if ( !PositionArrowOnBone( pBox, pOtherAnim ) )
		{
			return false;
		}
	}

	//
	const Vector &vecOrigin = GetAbsOrigin();
	Vector vecVelocity = GetAbsVelocity();
	int nDamageCustom = 0;
	bool bApplyEffect = true;
	int nDamageType = GetDamageType();

	// Are we a headshot?
	bool bHeadshot = false;
	if ( pBox->group == HITGROUP_HEAD && CanHeadshot() )
	{
		bHeadshot = true;
	}

	// Damage the entity we struck.
	CBaseEntity *pAttacker = GetScorer();
	if ( !pAttacker )
	{
		// likely not launched by a player
		pAttacker = GetOwnerEntity();
	}
	
	if ( pAttacker )
	{
		// Check if we have the penetrate attribute.  We don't want
		// to strike the same target multiple times.
		if ( m_bPenetrate )
		{
			// Don't strike the same target again
			if ( m_HitEntities.Find( pOther->entindex() ) != m_HitEntities.InvalidIndex() )
			{
				bApplyEffect = false;
			}
			else
			{
				m_HitEntities.AddToTail( pOther->entindex() );
			}
		}

		if ( !InSameTeam( pOther ) )
		{
			IScorer *pScorerInterface = dynamic_cast<IScorer*>( pAttacker );
			if ( pScorerInterface )
			{
				pAttacker = pScorerInterface->GetScorer();
			}

			if ( m_bArrowAlight )
			{
				nDamageType |= DMG_IGNITE;
				nDamageCustom = TF_DMG_CUSTOM_FLYINGBURN;
			}

			if ( bHeadshot )
			{
				nDamageType |= DMG_CRITICAL;
				nDamageCustom = TF_DMG_CUSTOM_HEADSHOT;
			}

			if ( m_bCritical )
			{
				nDamageType |= DMG_CRITICAL;
			}

#ifdef GAME_DLL
			if ( TFGameRules()->IsPVEModeControlled( pAttacker ) )
			{
				// scenario bots cant crit (unless they always do)
				CTFBot *bot = ToTFBot( pAttacker );
				if ( !bot || !bot->HasAttribute( CTFBot::ALWAYS_CRIT ) )
				{
					nDamageType &= ~DMG_CRITICAL;
				}
			}
#endif
			// Damage
			if ( bApplyEffect )
			{
				// Apply Milk First so we can get health from this
				if ( m_bApplyMilkOnHit && pOther->IsPlayer() )
				{
					CTFPlayer *pVictim = ToTFPlayer( pOther );
					if ( pVictim && pVictim->m_Shared.CanBeDebuffed() && pVictim->CanGetWet() )
					{
						// duration is based on damage
						float flDuration = RemapValClamped( GetDamage(), 25.0f, 75.0f, 6.0f, 10.0f );
						pVictim->m_Shared.AddCond( TF_COND_MAD_MILK, flDuration, pAttacker );
						pVictim->m_Shared.SetPeeAttacker( ToTFPlayer( pAttacker ) );
						pVictim->SpeakConceptIfAllowed( MP_CONCEPT_JARATE_HIT );
					}
				}

				CTakeDamageInfo info( this, pAttacker, m_hLauncher, vecVelocity, vecOrigin, GetDamage(), nDamageType, nDamageCustom );
				pOther->TakeDamage( info );

				// Play an impact sound.
				ImpactSound( "Weapon_Arrow.ImpactFlesh", true );
			}
		}
		else if ( pOther->IsPlayer() ) // Hit a team-mate.
		{
			// Heal
			if ( bApplyEffect )
			{
				ImpactTeamPlayer( dynamic_cast<CTFPlayer*>( pOther ) );
			}
		}
	}

	if ( !m_bPenetrate && !bBreakArrow )
	{
		OnArrowImpact( pBox, pOther, pAttacker );
	}

	// Perform a blood mesh decal trace.
	trace_t tr;
	Vector start = vecOrigin - vecVelocity * gpGlobals->frametime;
	Vector end = vecOrigin + vecVelocity * gpGlobals->frametime;
	CTraceFilterCollisionArrows filter( this, GetOwnerEntity() );
	UTIL_TraceLine( start, end, CONTENTS_HITBOX|CONTENTS_MONSTER|CONTENTS_SOLID, &filter, &tr );
	UTIL_ImpactTrace( &tr, 0 );

	// Break it?
	if ( bBreakArrow )
	{
		return false;
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::OnArrowImpact( mstudiobbox_t *pBox, CBaseEntity *pOther, CBaseEntity *pAttacker )
{
	CBaseAnimating *pOtherAnim = dynamic_cast< CBaseAnimating* >(pOther);
	if ( !pOtherAnim )
		return;

	const Vector &vecOrigin = GetAbsOrigin();
	Vector vecVelocity = GetAbsVelocity();

	Vector bonePosition = vec3_origin;
	QAngle boneAngles = QAngle(0,0,0);
	int boneIndexAttached = -1;
	int physicsBoneIndex = -1;
	GetBoneAttachmentInfo( pBox, pOtherAnim, bonePosition, boneAngles, boneIndexAttached, physicsBoneIndex );
	bool bSendImpactMessage = true;

	// Did we kill the target?
	if ( !pOther->IsAlive() && pOther->IsPlayer() )
	{
		CTFPlayer *pTFPlayerOther = dynamic_cast<CTFPlayer*>(pOther);
		if ( pTFPlayerOther && pTFPlayerOther->m_hRagdoll )
		{
			VectorNormalize( vecVelocity );
			if ( CheckRagdollPinned( vecOrigin, vecVelocity, boneIndexAttached, physicsBoneIndex, pTFPlayerOther->m_hRagdoll, pBox->group, pTFPlayerOther->entindex() ) )
			{
				pTFPlayerOther->StopRagdollDeathAnim();
				bSendImpactMessage = false;
			}
		}
	}

	// Notify relevant clients of an arrow impact.
	if ( bSendImpactMessage )
	{
		IGameEvent * event = gameeventmanager->CreateEvent( "arrow_impact" );
		if ( event )
		{
			event->SetInt( "attachedEntity", pOther->entindex() );
			event->SetInt( "shooter", pAttacker ? pAttacker->entindex() : 0 );
			event->SetInt( "attachedEntity", pOther->entindex() );
			event->SetInt( "boneIndexAttached", boneIndexAttached );
			event->SetFloat( "bonePositionX", bonePosition.x );
			event->SetFloat( "bonePositionY", bonePosition.y );
			event->SetFloat( "bonePositionZ", bonePosition.z );
			event->SetFloat( "boneAnglesX", boneAngles.x );
			event->SetFloat( "boneAnglesY", boneAngles.y );
			event->SetFloat( "boneAnglesZ", boneAngles.z );
			event->SetInt( "projectileType", GetProjectileType() );
			gameeventmanager->FireEvent( event );
		}
	}

	FadeOut( 3.0 );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::OnArrowImpactObject( CBaseEntity *pOther )
{
	if ( InSameTeam( pOther ) )
	{
		BuildingHealingArrow( pOther );
	}
	return false;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::ImpactThink( void )
{
}

//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::BuildingHealingArrow( CBaseEntity *pOther )
{
	// This arrow impacted a building
	// If its a building on our team, heal it
	if ( !pOther->IsBaseObject() )
		return;

	CBaseEntity *pAttacker = GetScorer();
	if ( pAttacker == NULL )
		return;

	// if not on our team, forget about it
	if ( GetTeamNumber() != pOther->GetTeamNumber() )
		return;

	int iArrowsHealBuildings = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pAttacker, iArrowsHealBuildings, arrow_heals_buildings );
	if ( iArrowsHealBuildings == 0 )
		return;

	CBaseObject *pBuilding = dynamic_cast< CBaseObject * >( pOther );
	if ( !pBuilding || !pBuilding->CanBeRepaired() || pBuilding->HasSapper() || pBuilding->IsPlasmaDisabled() || pBuilding->IsBuilding() || pBuilding->IsPlacing() )
		return;

	// if building is sheilded, reduce health gain
	if ( pBuilding->GetShieldLevel() == SHIELD_NORMAL )
	{
		iArrowsHealBuildings *= SHIELD_NORMAL_VALUE;
	}

	float flNewHealth = MIN( pBuilding->GetMaxHealth(), (int)pBuilding->GetHealth() + iArrowsHealBuildings );
	int iHealthAdded = (int)(flNewHealth - pBuilding->GetHealth());
	if ( iHealthAdded > 0 )
	{
		pBuilding->SetHealth( flNewHealth );

		IGameEvent * event = gameeventmanager->CreateEvent( "building_healed" );
		if ( event )
		{
			// HLTV event priority, not transmitted
			event->SetInt( "priority", 1 );	

			// Healed by another player.
			event->SetInt( "building", pBuilding->entindex() );
			event->SetInt( "healer", pAttacker->entindex() );
			event->SetInt( "amount", iHealthAdded );
			gameeventmanager->FireEvent( event );
		}

		const char *pParticleName = GetTeamNumber() == TF_TEAM_BLUE ? CLAW_REPAIR_EFFECT_BLU : CLAW_REPAIR_EFFECT_RED;
		CPVSFilter filter( GetAbsOrigin() );
		TE_TFParticleEffect( filter, 0.0, pParticleName, GetAbsOrigin(), vec3_angle );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CTFProjectile_Arrow::GetArrowSkin() const
{
	int nTeam = GetTeamNumber();
	if ( GetOwnerEntity() && GetOwnerEntity()->IsPlayer() )
	{
		CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
		if ( pOwner && pOwner->IsPlayerClass( TF_CLASS_SPY ) && pOwner->m_Shared.InCond( TF_COND_DISGUISED ) )
		{
			nTeam = pOwner->m_Shared.GetDisguiseTeam();
		}
	}
	return ( nTeam == TF_TEAM_BLUE ) ? 1 : 0;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::OnArrowMissAllPlayers()
{
	CTFPlayer* pOwner = ToTFPlayer( GetOwnerEntity() );
	if( pOwner && pOwner->IsPlayerClass( TF_CLASS_SNIPER ) )
	{
		EconEntity_OnOwnerKillEaterEventNoPartner( assert_cast<CEconEntity *>( m_hLauncher.Get() ), pOwner, kKillEaterEvent_NEGATIVE_SniperShotsMissed );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::ArrowTouch( CBaseEntity *pOther )
{
	// Safety net hack:
	// We routinely introduce new entity types, and arrows
	// are repeat-offenders at not getting along with them.
	// If enough time goes by, just remove the arrow.
	float flAliveTime = gpGlobals->curtime - m_flInitTime;
	if ( flAliveTime >= 10.f )
	{
		Warning( "Arrow alive for %f3.2\n seconds", flAliveTime );
		UTIL_Remove( this );
	}

	if ( m_bStruckEnemy || (GetMoveType() == MOVETYPE_NONE) )
		return;

	if ( !pOther )
		return;

	bool bShield = pOther->IsCombatItem() && !InSameTeam( pOther );
	CTFPumpkinBomb *pPumpkinBomb = dynamic_cast< CTFPumpkinBomb * >( pOther );

	if ( pOther->IsSolidFlagSet( FSOLID_TRIGGER | FSOLID_VOLUME_CONTENTS ) && !pPumpkinBomb && !bShield )
		return;

	// test against combat characters, which include players, engineer buildings, and NPCs
	CBaseCombatCharacter *pOtherCombatCharacter = dynamic_cast< CBaseCombatCharacter * >( pOther );

	if ( !pOtherCombatCharacter )
	{
		// It might be a track train with boss parented
		pOtherCombatCharacter = dynamic_cast< CBaseCombatCharacter * >( pOther->FirstMoveChild() );
		if ( pOtherCombatCharacter )
		{
			pOther = pOtherCombatCharacter;
		}
	}

	CTFMerasmusTrickOrTreatProp *pMerasmusProp = dynamic_cast< CTFMerasmusTrickOrTreatProp* >( pOther );
	CTFRobotDestruction_Robot *pRobot = dynamic_cast< CTFRobotDestruction_Robot* >( pOther );
	if ( pOther->IsWorld() || ( !pOtherCombatCharacter && !pPumpkinBomb && !pMerasmusProp && !bShield && !pRobot ) )
	{
		// Check to see if we struck the skybox.
		CheckSkyboxImpact( pOther );

		// If we've only got 1 entity in the hit list (the attacker by default) and we've not been deflected
		// then we can consider this arrow to have completely missed all players.
		if( m_HitEntities.Count() == 1 && GetDeflected() == 0 )
		{
			OnArrowMissAllPlayers();
		}

		return;
	}

	CBaseAnimating *pAnimOther = dynamic_cast<CBaseAnimating*>(pOther);
	CStudioHdr *pStudioHdr = NULL;
	mstudiohitboxset_t *set = NULL;
	if ( pAnimOther )
	{
		pStudioHdr = pAnimOther->GetModelPtr();
		if ( pStudioHdr )
		{
			set = pStudioHdr->pHitboxSet( pAnimOther->GetHitboxSet() );
		}
	}

	if ( !pAnimOther || !pStudioHdr || !set )
	{
		// Whatever we hit doesn't have hitboxes. Ignore it.
		UTIL_Remove( this );
		return;
	}

	// We struck the collision box of a player or a buildable object.
	// Trace forward to see if we struck a hitbox.
	CTraceFilterCollisionArrows filter( this, GetOwnerEntity() );
	Vector start = GetAbsOrigin();
	Vector vel = GetAbsVelocity();
	trace_t tr;
	UTIL_TraceLine( start, start + vel * gpGlobals->frametime, CONTENTS_HITBOX|CONTENTS_MONSTER|CONTENTS_SOLID, &filter, &tr );

	// If we hit a hitbox, stop tracing.
	mstudiobbox_t *closest_box = NULL;
	if ( tr.m_pEnt && tr.m_pEnt->GetTeamNumber() != GetTeamNumber() )
	{
		// This means the arrow was true and was flying directly at a hitbox on the target.
		// We'll attach to that hitbox.
		closest_box = set->pHitbox( tr.hitbox );
	}

	if ( !closest_box )
	{
		// Locate the hitbox closest to our point of impact on the collision box.
		Vector position, start, forward;
		QAngle angles;
		float closest_dist = 99999;

		// Intense, but extremely accurate:
		AngleVectors( GetAbsAngles(), &forward );
		start = GetAbsOrigin() + forward*16;
		for ( int i = 0; i < set->numhitboxes; i++ )
		{
			mstudiobbox_t *pbox = set->pHitbox( i );

			pAnimOther->GetBonePosition( pbox->bone, position, angles );

			Ray_t ray;
			ray.Init( start, position );
			trace_t tr;
			IntersectRayWithBox( ray, position+pbox->bbmin, position+pbox->bbmax, 0.f, &tr );
			float dist = tr.endpos.DistTo( start );

			if ( dist < closest_dist )
			{
				closest_dist = dist;
				closest_box = pbox;
			}
		}
	}

	if ( closest_box  )
	{
		// See if we're supposed to stick in the target.
		bool bStrike = StrikeTarget( closest_box, pOther );
		if ( bStrike && !m_bPenetrate)
		{
			// If we're here, it means StrikeTarget() called FadeOut( 3.0 )
			SetAbsOrigin( start );
		}

		if ( !bStrike || bShield )
		{
			BreakArrow();
		}

		// Slightly confusing.  If we're here, the arrow stopped at the
		// target and will fade or break.  Setting this prevents the
		// touch code from re-running during the delay.
		if ( !m_bPenetrate  )
		{
			m_bStruckEnemy = true;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::CheckSkyboxImpact( CBaseEntity *pOther )
{
	trace_t tr;
	Vector velDir = GetAbsVelocity();
	VectorNormalize( velDir );
	Vector vecSpot = GetAbsOrigin() - velDir * 32;
	UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID, this, COLLISION_GROUP_DEBRIS, &tr );
	if ( tr.fraction < 1.0 && tr.surface.flags & SURF_SKY )
	{
		// We hit the skybox, go away soon.
		FadeOut( 3.f );
		return;
	}

	if ( !pOther->IsWorld() )
	{
		BreakArrow();
	}
	else
	{
		CEffectData	data;
		data.m_vOrigin = tr.endpos;
		data.m_vNormal = velDir;
		data.m_nEntIndex = 0;/*tr.fraction != 1.0f;*/
		data.m_nAttachmentIndex = 0;
		data.m_nMaterial = 0;
		data.m_fFlags = GetProjectileType();
		data.m_nColor = GetArrowSkin();

		DispatchEffect( "TFBoltImpact", data );

		FadeOut( 3.f );

		// Play an impact sound.
		const char* pszSoundName = "Weapon_Arrow.ImpactMetal";
		surfacedata_t *psurf = physprops->GetSurfaceData( tr.surface.surfaceProps );
		if ( psurf )
		{
			switch ( psurf->game.material )
			{
			case CHAR_TEX_GRATE:
			case CHAR_TEX_METAL:
				pszSoundName = "Weapon_Arrow.ImpactMetal";
				break;

			case CHAR_TEX_CONCRETE:
				pszSoundName = "Weapon_Arrow.ImpactConcrete";
				break;

			case CHAR_TEX_WOOD:
				pszSoundName = "Weapon_Arrow.ImpactWood";
				break;
			}
		}
		ImpactSound( pszSoundName );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Plays an impact sound. Louder for the attacker.
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::ImpactSound( const char *pszSoundName, bool bLoudForAttacker )
{
	CTFPlayer *pAttacker = ToTFPlayer( GetScorer() );
	if ( !pAttacker )
		return;

	if ( bLoudForAttacker )
	{
		float soundlen = 0;
		EmitSound_t params;
		params.m_flSoundTime = 0;
		params.m_pSoundName = pszSoundName;
		params.m_pflSoundDuration = &soundlen;
		CPASFilter filter( GetAbsOrigin() );
		filter.RemoveRecipient( ToTFPlayer(pAttacker) );
		EmitSound( filter, entindex(), params );

		CSingleUserRecipientFilter attackerFilter( ToTFPlayer(pAttacker) );
		EmitSound( attackerFilter, pAttacker->entindex(), params );
	}
	else
	{
		EmitSound( pszSoundName );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::BreakArrow()
{
	FadeOut( 3.f );
	CPVSFilter filter( GetAbsOrigin() );
	UserMessageBegin( filter, "BreakModel" );
		WRITE_SHORT( GetModelIndex() );
		WRITE_VEC3COORD( GetAbsOrigin() );
		WRITE_ANGLES( GetAbsAngles() );
		WRITE_SHORT( m_nSkin );
	MessageEnd();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFProjectile_Arrow::CheckRagdollPinned( const Vector &start, const Vector &vel, int boneIndexAttached, int physicsBoneIndex, CBaseEntity *pOther, int iHitGroup, int iVictim )
{
	// Pin to the wall.
	trace_t tr;
	UTIL_TraceLine( start, start + vel * 125, MASK_BLOCKLOS, NULL, COLLISION_GROUP_NONE, &tr );
	if ( tr.fraction != 1.0f && tr.DidHitWorld() )
	{
		CEffectData	data;

		data.m_vOrigin = tr.endpos;
		data.m_vNormal = vel;
		data.m_nEntIndex = pOther->entindex();
		data.m_nAttachmentIndex = boneIndexAttached;
		data.m_nMaterial = physicsBoneIndex;
		data.m_nDamageType = iHitGroup;
		data.m_nSurfaceProp = iVictim;
		data.m_fFlags = GetProjectileType();
		data.m_nColor = GetArrowSkin();

		if ( GetScorer() )
		{
			data.m_nHitBox = GetScorer()->entindex();
		}

		DispatchEffect( "TFBoltImpact", data );

		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::FadeOut( int iTime )
{
	SetMoveType( MOVETYPE_NONE );
	SetAbsVelocity( vec3_origin	);
	AddSolidFlags( FSOLID_NOT_SOLID );
	AddEffects( EF_NODRAW );

	// Start remove timer.
	SetContextThink( &CTFProjectile_Arrow::RemoveThink, gpGlobals->curtime + iTime, "ARROW_REMOVE_THINK" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::RemoveThink( void )
{
	UTIL_Remove( this );
}

//-----------------------------------------------------------------------------
const char *CTFProjectile_Arrow::GetTrailParticleName( void )
{
	if ( m_iProjectileType == TF_PROJECTILE_BUILDING_REPAIR_BOLT )
	{	
		return ( GetTeamNumber() == TF_TEAM_RED ) ? CLAW_TRAIL_RED : CLAW_TRAIL_BLU;
	}
	else if ( m_iProjectileType == TF_PROJECTILE_HEALING_BOLT || m_iProjectileType == TF_PROJECTILE_FESTIVE_HEALING_BOLT )
	{
		return ( GetTeamNumber() == TF_TEAM_RED ) ? "effects/healingtrail_red.vmt" : "effects/healingtrail_blu.vmt";
	}

	return ( GetTeamNumber() == TF_TEAM_RED ) ? "effects/arrowtrail_red.vmt" : "effects/arrowtrail_blu.vmt";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::CreateTrail( void )
{
	if ( IsDormant() )
		return;

	if ( !m_pTrail )
	{
		int width = 3;
		switch ( m_iProjectileType )
		{
			case TF_PROJECTILE_BUILDING_REPAIR_BOLT:
				width = 5;
				break;
			case TF_PROJECTILE_HEALING_BOLT:
			case TF_PROJECTILE_FESTIVE_HEALING_BOLT:
			case TF_PROJECTILE_GRAPPLINGHOOK:
#ifdef STAGING_ONLY
			case TF_PROJECTILE_SNIPERBULLET:
#endif // STAGING_ONLY
				return; // do not create arrow trail for healing bolt, use particle instead (client only)
		}
		
		const char *pTrailTeamName = GetTrailParticleName();
		CSpriteTrail *pTempTrail = NULL;

		pTempTrail = CSpriteTrail::SpriteTrailCreate( pTrailTeamName, GetAbsOrigin(), true );
		pTempTrail->FollowEntity( this );
		pTempTrail->SetTransparency( kRenderTransAlpha, 255, 255, 255, 255, kRenderFxNone );
		pTempTrail->SetStartWidth( width );
		pTempTrail->SetTextureResolution( 1.0f / ( 96.0f * 1.0f ) );
		pTempTrail->SetLifeTime( 0.3 );
		pTempTrail->TurnOn();
		pTempTrail->SetAttachment( this, 0 );
		m_pTrail = pTempTrail;
		SetContextThink( &CTFProjectile_Arrow::RemoveTrail, gpGlobals->curtime + 3, "FadeTrail");
	}
}

//-----------------------------------------------------------------------------
// Purpose: Fade and kill the trail
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::RemoveTrail( void )
{
	if ( !m_pTrail )
		return;

	if ( m_pTrail )
	{
		if ( m_flTrailLife <= 0 )
		{
			UTIL_Remove( m_pTrail );
			m_flTrailLife = 1.0f;
		}
		else	
		{
			float fAlpha = 128 * m_flTrailLife;

			CSpriteTrail *pTempTrail = dynamic_cast< CSpriteTrail*>( m_pTrail.Get() );

			if ( pTempTrail )
			{
				pTempTrail->SetBrightness( int(fAlpha) );
			}

			m_flTrailLife = m_flTrailLife - 0.1f;
			SetContextThink( &CTFProjectile_Arrow::RemoveTrail, gpGlobals->curtime + 0.05, "FadeTrail");
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::AdjustDamageDirection( const CTakeDamageInfo &info, Vector &dir, CBaseEntity *pEnt )
{
	if ( pEnt )
	{
		dir = info.GetDamagePosition() - info.GetDamageForce() - pEnt->WorldSpaceCenter();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Arrow was deflected.
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::IncrementDeflected( void )
{
	m_iDeflected++; 

	// Change trail color.
	if ( m_pTrail )
	{
		UTIL_Remove( m_pTrail );
		m_pTrail = NULL;
		m_flTrailLife = 1.0f;
	}
	CreateTrail();
}

//-----------------------------------------------------------------------------
// Purpose: Arrow was deflected.
//-----------------------------------------------------------------------------
void CTFProjectile_Arrow::Deflected( CBaseEntity *pDeflectedBy, Vector &vecDir )
{
	CTFPlayer *pTFDeflector = ToTFPlayer( pDeflectedBy );
	if ( !pTFDeflector )
		return;

	ChangeTeam( pTFDeflector->GetTeamNumber() );
	SetLauncher( pTFDeflector->GetActiveWeapon() );

	CTFPlayer* pOldOwner = ToTFPlayer( GetOwnerEntity() );
	SetOwnerEntity( pTFDeflector );

	if ( pOldOwner )
	{
		pOldOwner->SpeakConceptIfAllowed( MP_CONCEPT_DEFLECTED, "projectile:1,victim:1" );
	}

	if ( pTFDeflector->m_Shared.IsCritBoosted() )
	{
		SetCritical( true );
	}

	CTFWeaponBase::SendObjectDeflectedEvent( pTFDeflector, pOldOwner, GetWeaponID(), this );

	IncrementDeflected();
	SetScorer( pTFDeflector );

	// Purge our hit list so we can hit everyone again
	m_HitEntities.Purge();
	// Add ourselves so we dont hit ourselves
	m_HitEntities.AddToTail( pTFDeflector->entindex() );
}


//-----------------------------------------------------------------------------
// Purpose: Setup function.
//-----------------------------------------------------------------------------
void CTFProjectile_HealingBolt::InitArrow( const QAngle &vecAngles, const float fSpeed, const float fGravity, ProjectileType_t projectileType, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
	BaseClass::InitArrow( vecAngles, fSpeed, fGravity, projectileType, pOwner, pScorer );

	//SetNextThink( gpGlobals->curtime );
}

//-----------------------------------------------------------------------------
// Purpose: Healing bolt heal.
//-----------------------------------------------------------------------------
void CTFProjectile_HealingBolt::ImpactTeamPlayer( CTFPlayer *pOther )
{
	if ( !pOther )
		return;

#ifdef STAGING_ONLY
	// Milk Arrows only heal teammates on special shot
	if ( GetProjectileType() == TF_PROJECTILE_MILK_BOLT && !m_bApplyMilkOnHit )
		return;
#endif

	CTFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
	if ( !pOwner )
		return;

	// Don't heal players using a weapon that blocks healing
	CTFWeaponBase *pWeapon = pOther->GetActiveTFWeapon();
	if ( pWeapon )
	{
		int iBlockHealing = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iBlockHealing, weapon_blocks_healing );
		if ( iBlockHealing )
			return;
	}

	float flHealth = GetDamage() * 2.0f;

#ifdef STAGING_ONLY
	// Milk Arrows give a resist bubble on hitting a teammate
	if ( GetProjectileType() == TF_PROJECTILE_MILK_BOLT )
	{
		// use damage to scale time
		float flResistDuration = RemapValClamped( flHealth, 0, 150, 1, 3 );
		pOther->m_Shared.AddCond( TF_COND_MEDIGUN_UBER_BULLET_RESIST, flResistDuration, pOwner );
		pOther->m_Shared.AddCond( TF_COND_MEDIGUN_UBER_BLAST_RESIST, flResistDuration, pOwner );
		pOther->m_Shared.AddCond( TF_COND_MEDIGUN_UBER_FIRE_RESIST, flResistDuration, pOwner );
	}
#endif

	// Scale this if needed
	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pOther, flHealth, mult_healing_from_medics );
	
	int iActualHealed = pOther->TakeHealth( flHealth, DMG_GENERIC );
	if ( iActualHealed <= 0 )
		return;

	// Play an impact sound.
	ImpactSound( "Weapon_Arrow.ImpactFleshCrossbowHeal" );

	CTF_GameStats.Event_PlayerHealedOther( pOwner, flHealth );

	IGameEvent * event = gameeventmanager->CreateEvent( "player_healed" );
	if ( event )
	{
		// HLTV event priority, not transmitted
		event->SetInt( "priority", 1 );	

		// Healed by another player.
		event->SetInt( "patient", pOther->GetUserID() );
		event->SetInt( "healer", pOwner->GetUserID() );
		event->SetInt( "amount", flHealth );
		gameeventmanager->FireEvent( event );
	}

	event = gameeventmanager->CreateEvent( "player_healonhit" );
	if ( event )
	{
		event->SetInt( "amount", flHealth );
		event->SetInt( "entindex", pOther->entindex() );
		item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX;
		if ( pWeapon && pWeapon->GetAttributeContainer() && pWeapon->GetAttributeContainer()->GetItem() )
		{
			healingItemDef = pWeapon->GetAttributeContainer()->GetItem()->GetItemDefIndex();
		}
		event->SetInt( "weapon_def_index", healingItemDef );
		gameeventmanager->FireEvent( event ); 
	}

	event = gameeventmanager->CreateEvent( "crossbow_heal" );
	if ( event )
	{
		event->SetInt( "healer", pOwner->GetUserID() );
		event->SetInt( "target", pOther->GetUserID() );
		event->SetInt( "amount", flHealth );
		gameeventmanager->FireEvent( event ); 
	}

	// Give a litte bit of uber based on actual healing
	// Give them a little bit of Uber
	CWeaponMedigun *pMedigun = static_cast<CWeaponMedigun *>( pOwner->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
	if ( pMedigun )
	{
		// On Mediguns, per frame, the amount of uber added is based on 
		// Default heal rate is 24per second, we scale based on that and frametime
		pMedigun->AddCharge( ( iActualHealed / 24.0f ) * gpGlobals->frametime );
	}
	pOther->m_Shared.AddCond( TF_COND_HEALTH_OVERHEALED, 1.2f );

	EconEntity_OnOwnerKillEaterEvent_Batched( dynamic_cast<CEconEntity *>( GetLauncher() ), pOwner, pOther, kKillEaterEvent_AllyHealingDone, flHealth );
}


CTFProjectile_GrapplingHook::CTFProjectile_GrapplingHook()
	: m_pImpactFleshSoundLoop( NULL )
{
}

//-----------------------------------------------------------------------------
// Purpose: Spawn
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::Spawn()
{
	BaseClass::Spawn();

	SetMoveType( MOVETYPE_FLY, MOVECOLLIDE_FLY_CUSTOM );
}


void CTFProjectile_GrapplingHook::Precache()
{
	BaseClass::Precache();

	PrecacheModel( "models/weapons/c_models/c_grapple_proj/c_grapple_proj.mdl" );
	PrecacheScriptSound( "WeaponGrapplingHook.ImpactFlesh" );
	PrecacheScriptSound( "WeaponGrapplingHook.ImpactDefault" );
	PrecacheScriptSound( "WeaponGrapplingHook.ImpactFleshLoop" );
}


//-----------------------------------------------------------------------------
// Purpose: Spawn
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::UpdateOnRemove()
{
	// clear hook target
	CTFPlayer *pTFPlayer = ToTFPlayer( GetOwnerEntity() );
	if ( pTFPlayer )
	{
		// Clear any healers grappling with us
		SetMedicsGrapplingHookTarget( pTFPlayer, NULL );
		pTFPlayer->SetGrapplingHookTarget( NULL );
		pTFPlayer->m_Shared.RemoveCond( TF_COND_GRAPPLINGHOOK );
	}

	StopImpactFleshSoundLoop();

	BaseClass::UpdateOnRemove();
}

//-----------------------------------------------------------------------------
// Purpose: Setup function.
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::InitArrow( const QAngle &vecAngles, const float fSpeed, const float fGravity, ProjectileType_t projectileType, CBaseEntity *pOwner, CBaseEntity *pScorer )
{
	BaseClass::InitArrow( vecAngles, fSpeed, fGravity, projectileType, pOwner, pScorer );

	CTFPlayer *pTFPlayer = ToTFPlayer( pOwner );
	if ( pTFPlayer )
	{
		pTFPlayer->m_Shared.AddCond( TF_COND_GRAPPLINGHOOK );
	}
}


//-----------------------------------------------------------------------------
// Purpose: OnArrowImpact
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::OnArrowImpact( mstudiobbox_t *pBox, CBaseEntity *pOther, CBaseEntity *pAttacker )
{
	HookTarget( pOther );
}


//-----------------------------------------------------------------------------
// Purpose: OnArrowImpactObject
//-----------------------------------------------------------------------------
bool CTFProjectile_GrapplingHook::OnArrowImpactObject( CBaseEntity *pOther )
{
	HookTarget( pOther );
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: CheckSkyboxImpact
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::CheckSkyboxImpact( CBaseEntity *pOther )
{
	trace_t tr;
	Vector velDir = GetAbsVelocity();
	VectorNormalize( velDir );
	Vector vecSpot = GetAbsOrigin() - velDir * 32;
	UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID, this, COLLISION_GROUP_DEBRIS, &tr );
	if ( tr.fraction < 1.0 && tr.surface.flags & SURF_SKY )
	{
		// We hit the skybox, go away soon.
		FadeOut( 1.f );
		return;
	}

	if ( !pOther->IsWorld() )
	{
		HookTarget( pOther );
	}
	else
	{
		HookTarget( pOther );

		// rotate the hook model to be perpendicular to the world surface
		Vector vUp;
		AngleVectors( GetAbsAngles(), NULL, NULL, &vUp );
		QAngle qNewAngles;
		VectorAngles( -tr.plane.normal, vUp, qNewAngles );
		SetAbsAngles( qNewAngles );
		SetAbsOrigin( GetAbsOrigin() + 3.f * tr.plane.normal );
	}
}


//-----------------------------------------------------------------------------
// Purpose: HookTarget
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::HookTarget( CBaseEntity *pOther )
{
	if ( !GetOwnerEntity() || !pOther )
		return;

	CTFPlayer *pTFPlayer = ToTFPlayer( GetOwnerEntity() );
	if ( !pTFPlayer || pTFPlayer->GetGrapplingHookTarget() )
		return;

	CBaseEntity *pTarget = pOther->IsWorld() ? this : pOther;
	const char *pszSoundName = NULL;
	if ( pTarget->IsPlayer() )
	{
		pszSoundName = "WeaponGrapplingHook.ImpactFlesh";
	}
	else
	{
		pszSoundName = "WeaponGrapplingHook.ImpactDefault";
	}
	ImpactSound( pszSoundName );

	pTFPlayer->SetGrapplingHookTarget( pTarget, true );
	// Grapple any medics to us
	SetMedicsGrapplingHookTarget( pTFPlayer, pTFPlayer );

	// Stop moving!
	if ( pOther->IsPlayer() )
	{
		FollowEntity( pOther, false );
		StartImpactFleshSoundLoop();
	}
	else
		SetMoveType( MOVETYPE_NONE );

	SetContextThink( &CTFProjectile_GrapplingHook::HookLatchedThink, gpGlobals->curtime + 0.1f, "HookLatchedThink" );
}


//-----------------------------------------------------------------------------
// Purpose: HookLatchedThink
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::HookLatchedThink()
{
	// if owner is dead, remove the hook
	CTFPlayer *pTFPlayer = ToTFPlayer( GetOwnerEntity() );
	if ( !pTFPlayer || !pTFPlayer->IsAlive() )
	{
		UTIL_Remove( this );
		return;
	}

	// if the target nolonger exist or target player is dead, remove the hook
	CBaseEntity *pHookTarget = pTFPlayer->GetGrapplingHookTarget();
	if ( !pHookTarget || ( pHookTarget->IsPlayer() && !pHookTarget->IsAlive() ) )
	{
		UTIL_Remove( this );
		return;
	}
	
	SetContextThink( &CTFProjectile_GrapplingHook::HookLatchedThink, gpGlobals->curtime + 0.1f, "HookLatchedThink" );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::StartImpactFleshSoundLoop()
{
	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
	CPASAttenuationFilter filter( this );
	m_pImpactFleshSoundLoop = controller.SoundCreate( filter, entindex(), "WeaponGrapplingHook.ImpactFleshLoop" );
	controller.Play( m_pImpactFleshSoundLoop, 1.0, 100 );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFProjectile_GrapplingHook::StopImpactFleshSoundLoop()
{
	if ( m_pImpactFleshSoundLoop )
	{
		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
		controller.SoundDestroy( m_pImpactFleshSoundLoop );
		m_pImpactFleshSoundLoop = NULL;
	}
}