tf2/tf2_src/game/shared/tf/tf_weapon_grenade_pipebomb.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: TF Pipebomb Grenade.
//
//=============================================================================//
#include "cbase.h"
#include "tf_weaponbase.h"
#include "tf_gamerules.h"
#include "npcevent.h"
#include "engine/IEngineSound.h"
#include "tf_weapon_grenade_pipebomb.h"
#include "tf_weapon_pipebomblauncher.h"
#include "tf_weapon_grenadelauncher.h"

// Client specific.
#ifdef CLIENT_DLL
#include "c_tf_player.h"
#include "IEffects.h"
#include "materialsystem/imaterialvar.h"
#include "functionproxy.h"
// Server specific.
#else
#include "tf_player.h"
#include "items.h"
#include "tf_weaponbase_grenadeproj.h"
#include "soundent.h"
#include "KeyValues.h"
#include "IEffects.h"
#include "props.h"
#include "func_respawnroom.h"
#include "tf_ammo_pack.h"
#include "takedamageinfo.h"
#include "tf_team.h"
#include "physics_collisionevent.h"
#ifdef TF_RAID_MODE
#include "player_vs_environment/boss_alpha/boss_alpha.h"
#endif // TF_RAID_MODE
#include "tf_weapon_medigun.h"
#endif

#define TF_WEAPON_PIPEBOMB_TIMER		3.0f //Seconds

#define TF_WEAPON_PIPEBOMB_GRAVITY		0.5f
#define TF_WEAPON_PIPEBOMB_FRICTION		0.8f
#define TF_WEAPON_PIPEBOMB_ELASTICITY	0.45f

#define TF_WEAPON_PIPEBOMB_TIMER_DMG_REDUCTION		0.6

extern ConVar tf_grenadelauncher_max_chargetime;
ConVar tf_grenadelauncher_chargescale( "tf_grenadelauncher_chargescale", "1.0", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
ConVar tf_grenadelauncher_livetime( "tf_grenadelauncher_livetime", "0.8", FCVAR_CHEAT | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
extern ConVar tf_sticky_radius_ramp_time;
extern ConVar tf_sticky_airdet_radius;

#ifndef CLIENT_DLL

ConVar tf_grenadelauncher_min_contact_speed( "tf_grenadelauncher_min_contact_speed", "100", FCVAR_DEVELOPMENTONLY );
extern ConVar tf_obj_gib_velocity_min;
extern ConVar tf_obj_gib_velocity_max;
extern ConVar tf_obj_gib_maxspeed;
#endif

IMPLEMENT_NETWORKCLASS_ALIASED( TFGrenadePipebombProjectile, DT_TFProjectile_Pipebomb )

BEGIN_NETWORK_TABLE( CTFGrenadePipebombProjectile, DT_TFProjectile_Pipebomb )
#ifdef CLIENT_DLL
RecvPropInt( RECVINFO( m_bTouched ) ),
RecvPropInt( RECVINFO( m_iType ) ),
RecvPropEHandle( RECVINFO( m_hLauncher ) ),
RecvPropBool( RECVINFO( m_bDefensiveBomb ) ),
#else
SendPropBool( SENDINFO( m_bTouched ) ),
SendPropInt( SENDINFO( m_iType ), 3 ),
SendPropEHandle( SENDINFO( m_hLauncher ) ),
SendPropBool( SENDINFO( m_bDefensiveBomb ) ),
#endif
END_NETWORK_TABLE()

#ifdef GAME_DLL
static string_t s_iszTrainName;
#endif

//-----------------------------------------------------------------------------
// Purpose: 
// Input  :  - 
//-----------------------------------------------------------------------------
CTFGrenadePipebombProjectile::CTFGrenadePipebombProjectile()
{
	m_bTouched = false;
	m_flChargeTime = 0.0f;
	m_bDetonateOnPulse = false;
#ifdef GAME_DLL
	s_iszTrainName  = AllocPooledString( "models/props_vehicles/train_enginecar.mdl" );
	m_flDeflectedTime = 0.0f;
	m_bWallShatter = false;
	m_bDefensiveBomb = false;
	m_bSendPlayerDestroyedEvent = true;
	m_bCanTakeDamage = true;
#else
	pEffectTrail = NULL;
	pEffectCrit = NULL;
	m_iCachedDeflect = 0;
	m_bHighlight = false;
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  :  - 
//-----------------------------------------------------------------------------
CTFGrenadePipebombProjectile::~CTFGrenadePipebombProjectile()
{
#ifdef CLIENT_DLL

	if ( pEffectTrail )
	{
		ParticleProp()->StopEmission( pEffectTrail );
	}
	if ( pEffectCrit )
	{
		ParticleProp()->StopEmission( pEffectCrit );
	}
	if ( m_pGlowEffect )
	{
		delete m_pGlowEffect;
		m_pGlowEffect = NULL;
	}

#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGrenadePipebombProjectile::GetWeaponID( void ) const
{
	if ( m_iType == TF_GL_MODE_CANNONBALL )
	{
		return TF_WEAPON_CANNON;
	}

	return ( HasStickyEffects() ? TF_WEAPON_GRENADE_PIPEBOMB : TF_WEAPON_GRENADE_DEMOMAN );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CTFGrenadePipebombProjectile::GetDamageType( void )
{
	int iDmgType = BaseClass::GetDamageType();

	// If we're a pipebomb, we do distance based damage falloff for just the first few seconds of our life
	if ( m_iType == TF_GL_MODE_REMOTE_DETONATE )
	{
		if ( gpGlobals->curtime - m_flCreationTime < 5.0 )
		{
			iDmgType |= DMG_USEDISTANCEMOD;
		}
	}

	return iDmgType;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGrenadePipebombProjectile::ShouldMiniCritOnReflect() const
{
	return GetType() == TF_GL_MODE_REGULAR;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::UpdateOnRemove( void )
{
	// Tell our launcher that we were removed
	CTFPipebombLauncher *pLauncher = dynamic_cast<CTFPipebombLauncher*>( m_hLauncher.Get() );

	if ( pLauncher )
	{
		pLauncher->DeathNotice( this );
	}

	BaseClass::UpdateOnRemove();
}

#ifdef CLIENT_DLL
//=============================================================================
//
// TF Pipebomb Grenade Projectile functions (Client specific).
//

//-----------------------------------------------------------------------------
// Purpose: 
// Output : const char
//-----------------------------------------------------------------------------
const char *CTFGrenadePipebombProjectile::GetTrailParticleName( void )
{
	int iTeamNumber = GetTeamNumber();

	if ( GetDeflected() && m_iType != TF_GL_MODE_REMOTE_DETONATE  )
	{
		CTFPlayer *pOwner =  ToTFPlayer( GetDeflectOwner() );

		if ( pOwner )
		{
			iTeamNumber = pOwner->GetTeamNumber();
		}
	}

	if ( HasStickyEffects() )
	{
		if ( iTeamNumber == TF_TEAM_BLUE )
		{
			return "stickybombtrail_blue";
		}
		else
		{
			return "stickybombtrail_red";
		}
	}
	else
	{
		if ( iTeamNumber == TF_TEAM_BLUE )
		{
			return "pipebombtrail_blue";
		}
		else
		{
			return "pipebombtrail_red";
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : updateType - 
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::OnDataChanged(DataUpdateType_t updateType)
{
	BaseClass::OnDataChanged( updateType );

	if ( updateType == DATA_UPDATE_CREATED )
	{
		m_flCreationTime = gpGlobals->curtime;
		m_bPulsed = false;

		CTFPipebombLauncher *pLauncher = dynamic_cast<CTFPipebombLauncher*>( m_hLauncher.Get() );

		if ( pLauncher )
		{
			pLauncher->AddPipeBomb( this );
		}

		if ( m_bDefensiveBomb && C_BasePlayer::GetLocalPlayer() == GetThrower() )
		{
			if ( GetTeamNumber() == TF_TEAM_RED )
			{
				m_pGlowEffect = new CGlowObject( this, Vector( 150, 0, 0 ), 1.0, true );
			}
			else
			{
				m_pGlowEffect = new CGlowObject( this, Vector( 0, 0, 150 ), 1.0, true );
			}
		}

		CreateTrailParticles();
	}
	else if ( m_bTouched )
	{
		//ParticleProp()->StopEmission();
	}

	if ( m_iCachedDeflect != GetDeflected() )
	{
		CreateTrailParticles();
	}

	m_iCachedDeflect = GetDeflected();
}

void CTFGrenadePipebombProjectile::CreateTrailParticles( void )
{
	if ( pEffectTrail )
	{
		ParticleProp()->StopEmission( pEffectTrail );
	}

	if ( pEffectCrit )
	{
		ParticleProp()->StopEmission( pEffectCrit );
	}

	pEffectTrail = ParticleProp()->Create( GetTrailParticleName(), PATTACH_ABSORIGIN_FOLLOW );

	int iTeamNumber = GetTeamNumber();

	if ( GetDeflected() && m_iType != TF_GL_MODE_REMOTE_DETONATE )
	{
		CTFPlayer *pOwner =  ToTFPlayer( GetDeflectOwner() );

		if ( pOwner )
		{
			iTeamNumber = pOwner->GetTeamNumber();
		}
	}

	if ( m_bCritical )
	{
		switch( iTeamNumber )
		{
		case TF_TEAM_BLUE:

			if ( HasStickyEffects() )
			{
				pEffectCrit = ParticleProp()->Create( "critical_grenade_blue", PATTACH_ABSORIGIN_FOLLOW );
			}
			else
			{
				pEffectCrit = ParticleProp()->Create( "critical_pipe_blue", PATTACH_ABSORIGIN_FOLLOW );
			}
			break;
		case TF_TEAM_RED:

			if ( HasStickyEffects() )
			{
				pEffectCrit = ParticleProp()->Create( "critical_grenade_red", PATTACH_ABSORIGIN_FOLLOW );
			}
			else
			{
				pEffectCrit = ParticleProp()->Create( "critical_pipe_red", PATTACH_ABSORIGIN_FOLLOW );
			}
			break;
		default:
			break;
		}
	}

}


extern ConVar tf_grenadelauncher_livetime;

void CTFGrenadePipebombProjectile::Simulate( void )
{
	BaseClass::Simulate();

	if ( !HasStickyEffects() )
		return;

	if ( m_bPulsed == false )
	{
		if ( (gpGlobals->curtime - m_flCreationTime) >= GetLiveTime() )
		{
			if ( GetTeamNumber() == TF_TEAM_RED )
			{
				ParticleProp()->Create( "stickybomb_pulse_red", PATTACH_ABSORIGIN_FOLLOW );
			}
			else
			{
				ParticleProp()->Create( "stickybomb_pulse_blue", PATTACH_ABSORIGIN_FOLLOW );
			}

			m_bPulsed = true;

			if ( m_bDetonateOnPulse )
			{
				Detonate();
			}
		}
	}
}

//------------------------------------------------------------------------------
// Purpose: Don't draw if we haven't yet gone past our original spawn point
// Input  : flags - 
//-----------------------------------------------------------------------------
int CTFGrenadePipebombProjectile::DrawModel( int flags )
{
	if ( gpGlobals->curtime < ( m_flCreationTime + 0.1 ) )
		return 0;

	return BaseClass::DrawModel( flags );
}

#else

//=============================================================================
//
// TF Pipebomb Grenade Projectile functions (Server specific).
//
#define TF_WEAPON_PIPEGRENADE_MODEL		"models/weapons/w_models/w_grenade_grenadelauncher.mdl"
#define TF_WEAPON_CANNONBALL_MODEL		"models/weapons/w_models/w_cannonball.mdl"
#define TF_WEAPON_PIPEBOMB_MODEL		"models/weapons/w_models/w_stickybomb.mdl"
#define TF_WEAPON_PIPEBOMB2_MODEL		"models/weapons/w_models/w_stickybomb2.mdl"
#define TF_WEAPON_PIPEBOMBD_MODEL		"models/weapons/w_models/w_stickybomb_d.mdl"
#define TF_WEAPON_PIPEBOMB_BOUNCE_SOUND	"Weapon_Grenade_Pipebomb.Bounce"
#define TF_WEAPON_CANNON_IMPACT_SOUND	"Weapon_LooseCannon.BallImpact"
#define TF_WEAPON_GRENADE_DETONATE_TIME		2.0f
#define TF_WEAPON_GRENADE_XBOX_DAMAGE 112

BEGIN_DATADESC( CTFGrenadePipebombProjectile )
END_DATADESC()

LINK_ENTITY_TO_CLASS( tf_projectile_pipe_remote, CTFGrenadePipebombProjectile );
PRECACHE_WEAPON_REGISTER( tf_projectile_pipe_remote );

LINK_ENTITY_TO_CLASS( tf_projectile_pipe, CTFGrenadePipebombProjectile );
PRECACHE_WEAPON_REGISTER( tf_projectile_pipe );

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CTFGrenadePipebombProjectile::GetPipebombClass( int iPipeBombType )
{
	switch ( iPipeBombType )
	{
	case TF_GL_MODE_REGULAR:
		return "tf_projectile_pipe";
	case TF_GL_MODE_REMOTE_DETONATE:
	case TF_GL_MODE_REMOTE_DETONATE_PRACTICE:
		return "tf_projectile_pipe_remote";
	default:
		return "tf_projectile_pipe";
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFGrenadePipebombProjectile* CTFGrenadePipebombProjectile::Create( const Vector &position, const QAngle &angles, 
																    const Vector &velocity, const AngularImpulse &angVelocity, 
																    CBaseCombatCharacter *pOwner, const CTFWeaponInfo &weaponInfo, 
																	int iPipeBombType, float flMultDmg )
{
	// Translate a projectile type into a pipebomb type.
	int iPipeBombDetonateType;
	switch ( iPipeBombType )
	{
	case TF_PROJECTILE_PIPEBOMB_REMOTE:
		{
			iPipeBombDetonateType = TF_GL_MODE_REMOTE_DETONATE;
		}
		break;
	case TF_PROJECTILE_PIPEBOMB_PRACTICE:
		{
			iPipeBombDetonateType = TF_GL_MODE_REMOTE_DETONATE_PRACTICE;
		}
		break;
	case TF_PROJECTILE_CANNONBALL:
		{
			iPipeBombDetonateType = TF_GL_MODE_CANNONBALL;
		}
		break;
	default:
		iPipeBombDetonateType = TF_GL_MODE_REGULAR;
	}
	
	const char* pszBombClass = GetPipebombClass( iPipeBombDetonateType );
	CTFGrenadePipebombProjectile *pGrenade = static_cast<CTFGrenadePipebombProjectile*>( CBaseEntity::CreateNoSpawn( pszBombClass, position, angles, pOwner ) );
	if ( pGrenade )
	{
		// Set the pipebomb mode before calling spawn, so the model & associated vphysics get setup properly
		pGrenade->SetPipebombMode( iPipeBombDetonateType );
		DispatchSpawn( pGrenade );

		pGrenade->InitGrenade( velocity, angVelocity, pOwner, weaponInfo );
		pGrenade->SetDamage( pGrenade->GetDamage() * flMultDmg );
		pGrenade->SetFullDamage( pGrenade->GetDamage() );

		if ( pGrenade->m_iType != TF_GL_MODE_REMOTE_DETONATE )
		{
			// Some hackery here. Reduce the damage, so that if we explode on timeout,
			// we'll do less damage. If we explode on contact, we'll restore this to full damage.
			pGrenade->SetDamage( pGrenade->GetDamage() * TF_WEAPON_PIPEBOMB_TIMER_DMG_REDUCTION );
		}

		pGrenade->ApplyLocalAngularVelocityImpulse( angVelocity );

		if ( pOwner )
		{
			pGrenade->SetTruceValidForEnt( pOwner->IsTruceValidForEnt() );
		}
	}

	return pGrenade;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::Spawn()
{
	if ( HasStickyEffects() )
	{
		// Set this to max, so effectively they do not self-implode.

		if ( m_iType == TF_GL_MODE_REMOTE_DETONATE_PRACTICE )
		{
			SetModel( TF_WEAPON_PIPEBOMB2_MODEL );
		}
		else
		{
			SetModel( TF_WEAPON_PIPEBOMB_MODEL );
		}
		SetDetonateTimerLength( FLT_MAX );
		SetContextThink( &CTFGrenadePipebombProjectile::PreArmThink, gpGlobals->curtime + 0.001f, "PRE_ARM_THINK" ); // Next frame.
		SetTouch( &CTFGrenadePipebombProjectile::StickybombTouch );
	}
	else
	{
		if ( m_iType == TF_GL_MODE_CANNONBALL )
		{
			SetModel( TF_WEAPON_CANNONBALL_MODEL );
		}
		else
		{
			SetModel( TF_WEAPON_PIPEGRENADE_MODEL );
		}
		SetDetonateTimerLength( TF_WEAPON_GRENADE_DETONATE_TIME );
		SetTouch( &CTFGrenadePipebombProjectile::PipebombTouch );
	}

	SetCustomPipebombModel();

	BaseClass::Spawn();

	m_bTouched = false;
	m_flCreationTime = gpGlobals->curtime;

	// We want to get touch functions called so we can damage enemy players
	AddSolidFlags( FSOLID_TRIGGER );

	m_flMinSleepTime = 0;
	AddFlag( FL_GRENADE );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::Precache()
{
	int iModel = PrecacheModel( TF_WEAPON_PIPEBOMB_MODEL );
	PrecacheGibsForModel( iModel );

	iModel = PrecacheModel( TF_WEAPON_PIPEBOMB2_MODEL );
	PrecacheGibsForModel( iModel );

	iModel = PrecacheModel( TF_WEAPON_PIPEBOMBD_MODEL );
	PrecacheGibsForModel( iModel );

	iModel = PrecacheModel( TF_WEAPON_PIPEGRENADE_MODEL );
	PrecacheGibsForModel( iModel );

	iModel = PrecacheModel( TF_WEAPON_CANNONBALL_MODEL );
	PrecacheGibsForModel( iModel );

	// Must add All custom Models here
	iModel = PrecacheModel( "models/workshop/weapons/c_models/c_kingmaker_sticky/w_kingmaker_stickybomb.mdl" );
	iModel = PrecacheModel( "models/workshop/weapons/c_models/c_quadball/w_quadball_grenade.mdl" );

	PrecacheParticleSystem( "stickybombtrail_blue" );
	PrecacheParticleSystem( "stickybombtrail_red" );

	PrecacheScriptSound( TF_WEAPON_PIPEBOMB_BOUNCE_SOUND );
	PrecacheScriptSound( TF_WEAPON_CANNON_IMPACT_SOUND );

	BaseClass::Precache();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::SetPipebombMode( int iPipebombMode /* = TF_GL_MODE_REGULAR */ )
{
	m_iType.Set( iPipebombMode );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::BounceSound( void )
{
	EmitSound( TF_WEAPON_PIPEBOMB_BOUNCE_SOUND );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::Detonate()
{
	if ( gpGlobals->curtime > m_flDetonateTime )
	{
		if ( GetLauncher() )
		{
			float flFizzle = 0;
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetLauncher(), flFizzle, stickybomb_fizzle_time );
			if ( flFizzle )
			{
				Fizzle();
			}
		}
	}

	if ( m_bFizzle )
	{
		g_pEffects->Sparks( GetAbsOrigin(), 1, 2 );
		Destroy( false );

		if ( HasStickyEffects() )
		{
			CreatePipebombGibs();
		}

		return;
	}

	BaseClass::Detonate();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGrenadePipebombProjectile::DetonateStickies()
{
	if ( !GetLauncher() )
		return false;

	bool bDetonateSticky = false;

	Vector vecOrigin = GetAbsOrigin();
	const int maxEntities = 64;
	CBaseEntity	*pObjects[ maxEntities ];
	int count = UTIL_EntitiesInSphere( pObjects, maxEntities, vecOrigin, GetDamageRadius(), FL_GRENADE );

	int iStickiesRemoved = 0;

	trace_t tr;
	for ( int i = 0; i < count; i++ )
	{
		if ( pObjects[i]->GetTeamNumber() == GetLauncher()->GetTeamNumber() )
			continue;

		CTFGrenadePipebombProjectile *pGrenade = dynamic_cast < CTFGrenadePipebombProjectile*> ( pObjects[i] );
		if ( !pGrenade )
			continue;

		if ( pGrenade->m_iType != TF_GL_MODE_REMOTE_DETONATE )
			continue;

		if ( pGrenade->m_bFizzle )
			continue;

		UTIL_TraceLine( vecOrigin, pGrenade->GetAbsOrigin(), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
		if ( tr.fraction < 1.0 )
			continue; // No line of sight to the bomb.

		pGrenade->Fizzle();
		pGrenade->Detonate();

		iStickiesRemoved++;

		bDetonateSticky = true;
	}

	CTFPlayer *pOwner = ToTFPlayer( GetThrower() );
	if ( iStickiesRemoved && pOwner )
	{
		pOwner->AwardAchievement( ACHIEVEMENT_TF_DEMOMAN_DESTROY_X_STICKYBOMBS, iStickiesRemoved );
	}

	return bDetonateSticky;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::CreatePipebombGibs( void )
{
	CPVSFilter filter( GetAbsOrigin() );
	UserMessageBegin( filter, "CheapBreakModel" );
		WRITE_SHORT( GetModelIndex() );
		WRITE_VEC3COORD( GetAbsOrigin() );
	MessageEnd();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::Fizzle( void )
{
	m_bFizzle = true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::StickybombTouch( CBaseEntity *pOther )
{
#ifdef GAME_DLL
#ifdef TF_RAID_MODE
	if ( TFGameRules()->IsRaidMode() )
	{
		if ( dynamic_cast< CBossAlpha * >( pOther ) != NULL )
		{
			// stickies stick to the boss
			m_bTouched = true;
			VPhysicsGetObject()->EnableMotion( false );

			SetParent( pOther );
		}
	}
#endif
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::PipebombTouch( CBaseEntity *pOther )
{
	if ( pOther == GetThrower() )
		return;

	// Verify a correct "other."
	if ( !pOther->IsSolid() || pOther->IsSolidFlagSet( FSOLID_VOLUME_CONTENTS ) )
		return;

	// Handle hitting skybox (disappear).
	trace_t pTrace;
	Vector velDir = GetAbsVelocity();
	VectorNormalize( velDir );
	Vector vOrigin = GetAbsOrigin();
	Vector vecSpot = vOrigin - velDir * 32;
	UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID, this, COLLISION_GROUP_NONE, &pTrace );

	if ( pTrace.fraction < 1.0 && pTrace.surface.flags & SURF_SKY )
	{
		UTIL_Remove( this );
		return;
	}

	// PASSTIME always explode when it hits the ball
	// fixme find a non-strcmp way to do this
	if ( !V_strcmp( pOther->GetClassname(), "passtime_ball" ) )
	{
		Explode( &pTrace, GetDamageType() );
		return;
	}

	//If we already touched a surface then we're not exploding on contact anymore.
	if ( m_bTouched == true )
		return;

	bool bExploded = false;

	// Blow up if we hit an enemy we can damage
	if ( pOther->GetTeamNumber() && pOther->GetTeamNumber() != GetTeamNumber() && pOther->m_takedamage != DAMAGE_NO )
	{
		// Check to see if this is a respawn room.
		if ( !pOther->IsPlayer() )
		{
			CFuncRespawnRoom *pRespawnRoom = dynamic_cast<CFuncRespawnRoom*>( pOther );
			if ( pRespawnRoom )
			{
				if ( !pRespawnRoom->PointIsWithin( vOrigin ) )
					return;
			}
		}
		
		if ( m_iType == TF_GL_MODE_CANNONBALL )
		{
			// Damage the player to push them back
			CBaseEntity *pAttacker = GetThrower();
			if ( pAttacker && ( pOther->IsPlayer() || pOther->IsBaseObject() ) )
			{
				// check if we already penetrate through this victim
				if ( !m_penetratedEntities.HasElement( pOther ) )
				{
					// Impact damage scales with distance
					float flDistanceSq = (pOther->GetAbsOrigin() - pAttacker->GetAbsOrigin()).LengthSqr();
					float flImpactDamage = RemapValClamped( flDistanceSq, 512 * 512, 1024 * 1024, 50, 25 );

					CTakeDamageInfo info( this, pAttacker, m_hLauncher, vec3_origin, vOrigin, flImpactDamage, GetDamageType(), TF_DMG_CUSTOM_CANNONBALL_PUSH );
					pOther->TakeDamage( info );

					CTFPlayer *pVictim = ToTFPlayer( pOther );
					if ( pVictim )
					{
						// apply airblast - Apply stun if they are effectively grounded so we can knock them up
						if ( !pVictim->m_Shared.InCond( TF_COND_KNOCKED_INTO_AIR ) )
						{
							pVictim->m_Shared.StunPlayer( 0.5, 1.f, TF_STUN_MOVEMENT, ToTFPlayer( pAttacker ) );
						}

						Vector vecToTarget = pVictim->WorldSpaceCenter() - pAttacker->WorldSpaceCenter();
						VectorNormalize( vecToTarget );
						vecToTarget *= 400;
						vecToTarget.z += 350;	// Mimic Flamethrower AirBlast
						pVictim->ApplyAirBlastImpulse( vecToTarget );
					}

					m_penetratedEntities.AddToTail( pOther );

					EmitSound( TF_WEAPON_CANNON_IMPACT_SOUND );

					// Add this guy to our donk list.  If this grenade explodes and hits anyone on our launcher's
					// donk list, they get minicrit
					CTFGrenadeLauncher* pLauncher =  dynamic_cast<CTFGrenadeLauncher*>( GetLauncher() );
					if( pLauncher )
					{
						pLauncher->AddDonkVictim( pOther );
					}
				}
				return;
			}
		}

		// Save this entity as enemy, they will take 100% damage.
		m_hEnemy = pOther;	

		// Restore damage. See comment in CTFGrenadePipebombProjectile::Create() above to understand this.
		m_flDamage = m_flFullDamage;
		Explode( &pTrace, GetDamageType() );
		bExploded = true;
	}

	// Train hack!
	if ( !bExploded && pOther->GetModelName() == s_iszTrainName && ( pOther->GetAbsVelocity().LengthSqr() > 1.0f ) )
	{
		Explode( &pTrace, GetDamageType() );
		bExploded = true;
	}

	// Explode on contact with a Boss, too
	if ( !bExploded && TFGameRules()->GetActiveBoss() && pOther == TFGameRules()->GetActiveBoss() )
	{
		Explode( &pTrace, GetDamageType() );
		bExploded = true;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
extern bool PropDynamic_CollidesWithGrenades( CBaseEntity* pBaseEntity );

void CTFGrenadePipebombProjectile::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
	BaseClass::VPhysicsCollision( index, pEvent );

	int otherIndex = !index;
	CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex];

	if ( !pHitEntity )
		return;

	if ( m_bWallShatter )
	{
		Fizzle();
		Detonate();
		return;
	}

	if ( m_iType == TF_GL_MODE_REGULAR || m_iType == TF_GL_MODE_CANNONBALL )
	{
		if ( PropDynamic_CollidesWithGrenades( pHitEntity) )
		{
			if ( m_bTouched == false )
			{
				SetThink( &CTFGrenadePipebombProjectile::Detonate );
				SetNextThink( gpGlobals->curtime );
			}
		}
		// Blow up if we hit an enemy we can damage
		else if ( pHitEntity->GetTeamNumber() && pHitEntity->GetTeamNumber() != GetTeamNumber() && pHitEntity->m_takedamage != DAMAGE_NO )
		{
			SetThink( &CTFGrenadePipebombProjectile::Detonate );
			SetNextThink( gpGlobals->curtime );
		}

		if ( m_bTouched == false )
		{
			SetDamage( GetDamageScaleOnWorldContact() * GetDamage() );

			int iNoBounce = 0;
			if ( GetLauncher() )
			{
				CALL_ATTRIB_HOOK_INT_ON_OTHER( GetLauncher(), iNoBounce, grenade_no_bounce )
				if ( iNoBounce )
				{
					Vector velocity;
					AngularImpulse angularVelocity;
					VPhysicsGetObject()->GetVelocity( &velocity, &angularVelocity );
					velocity *= 0.1f;
					VPhysicsGetObject()->SetVelocity( &velocity, &angularVelocity );
				}
			}
		}
		
		m_bTouched = true;
		return;
	}

	// Handle hitting skybox (disappear).
	surfacedata_t *pprops = physprops->GetSurfaceData( pEvent->surfaceProps[otherIndex] );
	if ( pprops->game.material == 'X' )
	{
		// uncomment to destroy grenade upon hitting sky brush
		//SetThink( &CTFGrenadePipebombProjectile::SUB_Remove );
		//SetNextThink( gpGlobals->curtime );
		return;
	}

	bool bIsDynamicProp = ( NULL != dynamic_cast<CDynamicProp *>( pHitEntity ) );

	// Temp: Don't stick to the saw blades in sawmill.
	// We should make the saws their own entity type for networking.
	if ( FStrEq( pHitEntity->m_iParent.ToCStr(), "sawmovelinear01" ) ||
		 FStrEq( pHitEntity->m_iParent.ToCStr(), "sawmovelinear02" ) ||
		  PropDynamic_CollidesWithGrenades( pHitEntity) )
	{
		bIsDynamicProp = false;
	}

	// Pipebombs stick to the world when they touch it
	if ( pHitEntity && ( pHitEntity->IsWorld() || bIsDynamicProp ) && gpGlobals->curtime > m_flMinSleepTime )
	{
		m_bTouched = true;

		g_PostSimulationQueue.QueueCall( VPhysicsGetObject(), &IPhysicsObject::EnableMotion, false );

		// Save impact data for explosions.
		m_bUseImpactNormal = true;
		pEvent->pInternalData->GetSurfaceNormal( m_vecImpactNormal );
		m_vecImpactNormal.Negate();
		m_flTouchedTime = gpGlobals->curtime;

		float flFizzle = 0;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetLauncher(), flFizzle, stickybomb_fizzle_time );
		if ( flFizzle > 0 )
		{
			SetDetonateTimerLength( flFizzle );
		}
	}
}

ConVar tf_grenade_forcefrom_bullet( "tf_grenade_forcefrom_bullet", "2.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_grenade_forcefrom_buckshot( "tf_grenade_forcefrom_buckshot", "0.75", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_grenade_forcefrom_blast( "tf_grenade_forcefrom_blast", "0.15", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_grenade_force_sleeptime( "tf_grenade_force_sleeptime", "1.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );	// How long after being shot will we re-stick to the world.
ConVar tf_pipebomb_force_to_move( "tf_pipebomb_force_to_move", "1500.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_pipebomb_deflect_reset_time( "tf_pipebomb_deflect_reset_time", "10.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );

//-----------------------------------------------------------------------------
// Purpose: If we are shot after being stuck to the world, move a bit
//-----------------------------------------------------------------------------
int CTFGrenadePipebombProjectile::OnTakeDamage( const CTakeDamageInfo &info )
{
	if ( !info.GetAttacker() )
	{
		Assert( !info.GetAttacker() );
		return 0;
	}

	bool bSameTeam = ( info.GetAttacker()->GetTeamNumber() == GetTeamNumber() );
	if ( !bSameTeam && CanTakeDamage() )
	{
		if ( m_bTouched && HasStickyEffects() && ( info.GetDamageType() & (DMG_BULLET|DMG_BUCKSHOT|DMG_BLAST|DMG_SONIC|DMG_MELEE) ) )
		{
			Vector vecForce = info.GetDamageForce();

			bool bBreakPipes = false;

			if ( info.GetDamageType() & (DMG_BULLET|DMG_MELEE) )
			{
				vecForce *= tf_grenade_forcefrom_bullet.GetFloat();
				bBreakPipes = true;
			}
			if ( info.GetDamageType() & DMG_SONIC )
			{
				vecForce *= tf_grenade_forcefrom_bullet.GetFloat();
			}
			else if ( info.GetDamageType() & DMG_BUCKSHOT )
			{
				vecForce *= tf_grenade_forcefrom_buckshot.GetFloat();
				bBreakPipes = true;
			}
			else if ( info.GetDamageType() & DMG_BLAST )
			{
				vecForce *= tf_grenade_forcefrom_blast.GetFloat();
			}

			if ( bBreakPipes == true )
			{
				// we might get multiple calls for the same pipe when shooting it with a shotgun,
				// so make sure it only sends the player_destroyed_pipebomb event once
				if ( m_bSendPlayerDestroyedEvent )
				{
					if ( info.GetAttacker()->IsPlayer() )
					{
						CTFPlayer *pPlayer = ToTFPlayer( info.GetAttacker() );
						if ( pPlayer )
						{
							IGameEvent * event = gameeventmanager->CreateEvent( "player_destroyed_pipebomb" );
							if ( event )
							{
								event->SetInt( "userid", pPlayer->GetUserID() );
								gameeventmanager->FireEvent( event );
							}

							if ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) )
							{
								// If we are near a building, award achievement progress.
								CTFTeam *pTeam = pPlayer->GetTFTeam();
								if ( pTeam )
								{
									for ( int i=0; i<pTeam->GetNumObjects(); i++ )
									{
										CBaseObject *pObject = pTeam->GetObject(i);
										if ( pObject && pObject->GetAbsOrigin().DistTo( GetAbsOrigin() ) < 100 &&
											pObject->ObjectType() != OBJ_ATTACHMENT_SAPPER )
										{
											pPlayer->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_DESTROY_STICKIES, 1 );
											break; // Only one award per sticky.
										}
									}
								}
							}
						}

						m_bSendPlayerDestroyedEvent = false;
					}
				}

				Fizzle();
				Detonate();
			}

			// If the force is sufficient, detach & move the pipebomb
			float flForce = tf_pipebomb_force_to_move.GetFloat();
			if ( vecForce.LengthSqr() > (flForce*flForce) )
			{
				if ( VPhysicsGetObject() )
				{
					VPhysicsGetObject()->EnableMotion( true );
				}

				CTakeDamageInfo newInfo = info;
				newInfo.SetDamageForce( vecForce );

				VPhysicsTakeDamage( newInfo );

				// The pipebomb will re-stick to the ground after this time expires
				m_flMinSleepTime = gpGlobals->curtime + tf_grenade_force_sleeptime.GetFloat();
				m_bTouched = false;

				// It has moved the data is no longer valid.
				m_bUseImpactNormal = false;
				m_vecImpactNormal.Init();

				return 1;
			}
		}
	}

	return 0;
}

void CTFGrenadePipebombProjectile::IncrementDeflected( void )
{
	BaseClass::IncrementDeflected();

	if ( GetDeflected() && HasStickyEffects() )
	{
		m_flDeflectedTime = gpGlobals->curtime + tf_pipebomb_deflect_reset_time.GetFloat();
	}

	int iTeamNumber = GetTeamNumber();

	CTFPlayer *pOwner =  ToTFPlayer( GetDeflectOwner() );

	if ( pOwner )
	{
		iTeamNumber = pOwner->GetTeamNumber();
	}

	if ( !HasStickyEffects() )
	{
		m_nSkin = ( iTeamNumber == TF_TEAM_BLUE ) ? 1 : 0;
	}
}

void CTFGrenadePipebombProjectile::DetonateThink( void )
{
	BaseClass::DetonateThink();

	if ( m_flDeflectedTime <= gpGlobals->curtime && HasStickyEffects() )
	{
		ResetDeflected();
		SetDeflectOwner( NULL );
	}

	// If we received our crit via a medic, make sure they still exist.
	if ( m_CritMedics.Count()  )
	{
		if ( TFGameRules() && ( TFGameRules()->InSetup() || TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS ) )
		{
			bool bRemove = true;

			FOR_EACH_VEC( m_CritMedics, i )
			{
				if ( m_CritMedics[i] && m_CritMedics[i]->GetPlayerClass()->GetClassIndex() == TF_CLASS_MEDIC )
				{
					bRemove = false;
					break;
				}
			}

			// No medic(s)
			if ( bRemove )
			{
				Fizzle();
				Detonate();
				return;
			}
		}
		else
		{
			// Clear the vector when the game starts
			m_CritMedics.RemoveAll();
		}
	}
}

void CTFGrenadePipebombProjectile::PreArmThink( void )
{
	SetContextThink( &CTFGrenadePipebombProjectile::ArmThink, gpGlobals->curtime + GetLiveTime(), "ARM_THINK" );
}

void CTFGrenadePipebombProjectile::ArmThink( void )
{
	// When between waves in MvM, players sometimes switch to medic just so demos can place crit stickies, 
	// and then switch back.  This code removes the sticky if the medic switches ( in DetonateThink() )
	if ( IsCritical() && HasStickyEffects() && TFGameRules() && ( TFGameRules()->InSetup() || TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS ) )
	{
		CTFPlayer *pOwner = ToTFPlayer( GetThrower() );
		if ( pOwner && pOwner->m_Shared.InCond( TF_COND_CRITBOOSTED ) && !pOwner->m_Shared.InCond( TF_COND_CRITBOOSTED_USER_BUFF ) )
		{
			// Find the medic(s)
			for ( int i = 0; i < pOwner->m_Shared.GetNumHealers(); i++ )
			{
				CTFPlayer *pMedic = ToTFPlayer( pOwner->m_Shared.GetHealerByIndex( i ) );
				if ( !pMedic )
					continue;

				CWeaponMedigun *pMedigun = dynamic_cast <CWeaponMedigun*>( pMedic->GetActiveTFWeapon() );
				if ( pMedigun && pMedigun->IsReleasingCharge() && pMedigun->GetChargeType() == MEDIGUN_CHARGE_CRITICALBOOST )
				{
					m_CritMedics.AddToTail( pMedic );
				}
			}

			// We didn't find the medic.  What provided TF_COND_CRITBOOSTED?
			Assert( m_CritMedics.Count() );
		}
	}

	if ( m_bDetonateOnPulse )
	{
		Detonate();
	}
}

#endif

//------------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFGrenadePipebombProjectile::GetLiveTime( void )
{
	float flLiveTime = tf_grenadelauncher_livetime.GetFloat();

	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetLauncher(), flLiveTime, sticky_arm_time );

	if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
	{
		CTFPlayer *pOwner = ToTFPlayer( GetThrower() );

		if ( pOwner )
		{
			if ( pOwner->m_Shared.GetCarryingRuneType() == RUNE_HASTE )
			{
				flLiveTime *= 0.5f;
			}
			else if ( pOwner->m_Shared.GetCarryingRuneType() == RUNE_KING || pOwner->m_Shared.InCond( TF_COND_KING_BUFFED ) )
			{
				flLiveTime *= 0.75f;
			}
		}
	}

	return flLiveTime;
}

#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Grenade was deflected.
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::Deflected( CBaseEntity *pDeflectedBy, Vector& vecDir )
{
	CTFPlayer *pTFDeflector = ToTFPlayer( pDeflectedBy );
	if ( !pTFDeflector )
		return;

	CTFPlayer* pOldOwner = NULL;
	if ( HasStickyEffects() )
	{
		CTakeDamageInfo info;

		float flForceMultiplier = 1.0f;
		ITFChargeUpWeapon *pWeapon = dynamic_cast<ITFChargeUpWeapon*>( pTFDeflector->GetActiveWeapon() );
		if ( pWeapon )
		{
			flForceMultiplier = RemapValClamped( ( gpGlobals->curtime - pWeapon->GetChargeBeginTime() ),
												 0.0f,
												 pWeapon->GetChargeMaxTime(),
												 1.0f,
												 2.0f );
		}
		Vector vecForce = vecDir * flForceMultiplier * -CTFWeaponBase::DeflectionForce( WorldAlignSize(), 90, 12.0f );
		
		pOldOwner = ToTFPlayer( GetThrower() );
		info.SetAttacker( pDeflectedBy );
		info.SetDamageForce( vecForce );
		info.SetDamageType( DMG_SONIC );
		info.SetWeapon( pTFDeflector->GetActiveTFWeapon() );
		OnTakeDamage( info );
	}
	else
	{
		ChangeTeam( pTFDeflector->GetTeamNumber() );
		SetLauncher( pTFDeflector->GetActiveWeapon() );
		pOldOwner = ToTFPlayer( GetThrower() );
		SetThrower( pTFDeflector );

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

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

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

	SetDeflectOwner( pTFDeflector );
	IncrementDeflected();
}
#endif


#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Highlight FX
//-----------------------------------------------------------------------------
class CProxyStickybombGlowColor : public CResultProxy
{
public:
	void OnBind( void *pC_BaseEntity )
	{
		Assert( m_pResult );

		if ( !pC_BaseEntity )
		{
			m_pResult->SetVecValue( 1, 1, 1 );
			return;
		}

		CTFGrenadePipebombProjectile *pGrenade = NULL;
		C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
		if ( !pEntity )
		{
			m_pResult->SetVecValue( 1, 1, 1 );
			return;
		}

		// default to [1 1 1]
		Vector vResult = Vector( 1, 1, 1 );

		pGrenade = dynamic_cast<CTFGrenadePipebombProjectile*>( pEntity );
		if ( pGrenade )
		{
			if ( pGrenade->IsHighlighted() )
			{
				int iTeamNumber = pGrenade->GetTeamNumber();
				if ( iTeamNumber == TF_TEAM_RED )
				{
					vResult = Vector ( 100.f, 0.f, 0.f );
					if ( pGrenade->m_pGlowEffect )
					{
						pGrenade->m_pGlowEffect->SetColor( Vector( 250, 0, 0 ) );
					}
				}
				else
				{
					vResult = Vector ( 0.f, 0.f, 100.f );
					if ( pGrenade->m_pGlowEffect )
					{
						pGrenade->m_pGlowEffect->SetColor( Vector( 0, 0, 250 ) );
					}
				}
			}
			else
			{
				int iTeamNumber = pGrenade->GetTeamNumber();
				if ( iTeamNumber == TF_TEAM_RED )
				{
					if ( pGrenade->m_pGlowEffect )
					{
						pGrenade->m_pGlowEffect->SetColor( Vector( 200, 100, 100 ) );
					}
				}
				else
				{
					if ( pGrenade->m_pGlowEffect )
					{
						pGrenade->m_pGlowEffect->SetColor( Vector( 100, 100, 200 ) );
					}
				}
			}
		}
		m_pResult->SetVecValue( vResult.x, vResult.y, vResult.z );
	}
};
EXPOSE_INTERFACE( CProxyStickybombGlowColor, IMaterialProxy, "StickybombGlowColor" IMATERIAL_PROXY_INTERFACE_VERSION );
#endif

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#if GAME_DLL
int CTFGrenadePipebombProjectile::GetDamageCustom()
{
	if ( m_iType == TF_GL_MODE_REMOTE_DETONATE )
	{
		if ( !m_bTouched )
		{
			return TF_DMG_CUSTOM_AIR_STICKY_BURST;
		}
		else if ( m_bDefensiveBomb )
		{
			return TF_DMG_CUSTOM_DEFENSIVE_STICKY;
		}
		else
		{
			return TF_DMG_CUSTOM_STANDARD_STICKY;
		}
	}
	else if ( m_iType == TF_GL_MODE_REMOTE_DETONATE_PRACTICE )
	{
		return TF_DMG_CUSTOM_PRACTICE_STICKY;
	}

	return BaseClass::GetDamageCustom();
}


float CTFGrenadePipebombProjectile::GetDamageScaleOnWorldContact()
{
	float flGrenadeDamageScaleOnWorldContact = 1.f;
	if ( GetLauncher() )
	{
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetLauncher(),flGrenadeDamageScaleOnWorldContact, grenade_damage_reduction_on_world_contact );
	}
	return flGrenadeDamageScaleOnWorldContact;
}
#endif

//-----------------------------------------------------------------------------
float CTFGrenadePipebombProjectile::GetDamageRadius() 
{
	float flRadiusMod = 1.0f;

#ifdef GAME_DLL
	// winbomb prevention.
	// Air Det
	if ( m_iType == TF_GL_MODE_REMOTE_DETONATE )
	{
		if ( m_bTouched == false )
		{
			float flArmTime = tf_grenadelauncher_livetime.GetFloat();
			flRadiusMod *= RemapValClamped( gpGlobals->curtime - m_flCreationTime, flArmTime, flArmTime + tf_sticky_radius_ramp_time.GetFloat(), tf_sticky_airdet_radius.GetFloat(), 1.0 );
		}
	}
#endif // GAME_DLL
	return BaseClass::GetDamageRadius() * flRadiusMod;
}