source-engine/game/shared/tf2/weapon_repairgun.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:			The Medic's Medikit weapon
//					
//
// $Workfile:     $
// $Date:         $
// $NoKeywords: $
//=============================================================================//
#include "cbase.h"
#include "basetfplayer_shared.h"
#include "in_buttons.h"
#include "weapon_combatshield.h"
#include "engine/IEngineSound.h"
#include "grenade_base_empable.h"
#include "basetfvehicle.h"
#include "tf_gamerules.h"

//#define REPAIR_GUN_DISABLES_GRENADES	// Uncomment if you want the repair gun to disable grenades.

#if defined( CLIENT_DLL )
#include "particles_simple.h"
#else
#include "ndebugoverlay.h"
#endif

#include "weapon_repairgun.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

// Buff ranges
ConVar weapon_repairgun_target_range( "weapon_repairgun_target_range", "450", FCVAR_REPLICATED, "The farthest away you can be for the repair gun to initially lock onto a player." );
ConVar weapon_repairgun_stick_range( "weapon_repairgun_stick_range", "512", FCVAR_REPLICATED, "How far away the repair gun can stay locked onto someone." );
ConVar weapon_repairgun_rate( "weapon_repairgun_rate", "12", FCVAR_REPLICATED, "Health healed per second by the repair gun." );
ConVar weapon_repairgun_damage_modifier( "weapon_repairgun_damage_modifier", "1.5", FCVAR_REPLICATED, "Scales the damage a player does while being healed with the repair gun." );
ConVar weapon_repairgun_debug( "weapon_repairgun_debug", "0", FCVAR_REPLICATED, "Show debugging info for the repair gun." );
ConVar weapon_repairgun_construction_rate( "weapon_repairgun_construction_rate", "10", FCVAR_REPLICATED, "Constructing object health healed per second by the repair gun." );

LINK_ENTITY_TO_CLASS( weapon_repairgun, CWeaponRepairGun );

PRECACHE_WEAPON_REGISTER( weapon_repairgun );

IMPLEMENT_NETWORKCLASS_ALIASED( WeaponRepairGun, DT_WeaponRepairGun )

BEGIN_NETWORK_TABLE( CWeaponRepairGun, DT_WeaponRepairGun )
#if !defined( CLIENT_DLL )
	SendPropInt( SENDINFO( m_bHealing ), 1, SPROP_UNSIGNED ),
	SendPropInt( SENDINFO( m_bAttacking ), 1, SPROP_UNSIGNED ),
	SendPropEHandle( SENDINFO( m_hHealingTarget ) ),
#else
	RecvPropInt( RECVINFO( m_bAttacking ) ),
	RecvPropInt( RECVINFO( m_bHealing ) ),
	RecvPropEHandle( RECVINFO(m_hHealingTarget) ),
#endif
END_NETWORK_TABLE()

BEGIN_PREDICTION_DATA( CWeaponRepairGun  )

	DEFINE_PRED_FIELD( m_bHealing, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD( m_bAttacking, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
	DEFINE_PRED_FIELD( m_hHealingTarget, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),

	DEFINE_FIELD( m_flHealEffectLifetime, FIELD_FLOAT ),

//	DEFINE_PRED_FIELD( m_pEmitter, FIELD_POINTER ),
//	DEFINE_PRED_FIELD( m_hParticleMaterial, FIELD_???,  ),
//	DEFINE_PRED_FIELD( m_PathParticleEvent, FIELD_???,  ),
//	DEFINE_PRED_FIELD( m_bPlayingSound, FIELD_BOOLEAN ),

END_PREDICTION_DATA()

#define PARTICLE_PATH_VEL				140.0
#define NUM_PATH_PARTICLES_PER_SEC		600.0f
#define NUM_TARGET_PARTICLES_PER_SEC	720.0f

#define NUM_REPAIRGUN_PATH_POINTS		8

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CWeaponRepairGun::CWeaponRepairGun( void )
{
	m_flHealEffectLifetime = 0;

	m_bHealing = false;
	m_bAttacking = false;

	m_flNextBuzzTime = 0;

#if defined( CLIENT_DLL )
	m_pEmitter = NULL;
	m_hParticleMaterial = INVALID_MATERIAL_HANDLE;
	m_PathParticleEvent.Init( NUM_PATH_PARTICLES_PER_SEC );
	m_bPlayingSound = false;
#endif

	SetPredictionEligible( true );
}


void CWeaponRepairGun::Precache()
{
	BaseClass::Precache();
	PrecacheScriptSound( "WeaponRepairGun.NoTarget" );
	PrecacheScriptSound( "WeaponRepairGun.Healing" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CWeaponRepairGun::Holster( CBaseCombatWeapon *pSwitchingTo )
{
	RemoveHealingTarget();
	m_bAttacking = false;

	return BaseClass::Holster( pSwitchingTo );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CWeaponRepairGun::GetTargetRange( void )
{
	return weapon_repairgun_target_range.GetFloat();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CWeaponRepairGun::GetStickRange( void )
{
	return weapon_repairgun_stick_range.GetFloat();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CWeaponRepairGun::GetHealRate( void )
{
	return weapon_repairgun_rate.GetFloat();
}

// Now make sure there isn't something other than team players in the way.
class CRepairFilter : public CTraceFilterSimple
{
public:
	CRepairFilter( CBaseEntity *pShooter ) : CTraceFilterSimple( pShooter, TFCOLLISION_GROUP_WEAPON )
	{
		m_pShooter = pShooter;
	}

	virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
	{
		// If it hit an edict the isn't the target and is on our team, then the ray is blocked.
		CBaseEntity *pEnt = static_cast<CBaseEntity*>(pHandleEntity);

		// Ignore collisions with the shooter
		if ( pEnt == m_pShooter )
			return false;
		
		// You can't heal a vehicle you are sitting in.

		if( ((CBaseTFPlayer*)m_pShooter)->IsInAVehicle() )
		{

			CBaseEntity* pVehicle = ((CBaseTFPlayer*)m_pShooter)->GetVehicle()->GetVehicleEnt();		
			if( pVehicle == pEnt )
			{
				return false;
			}
		}

#ifdef REPAIR_GUN_DISABLES_GRENADES 

			// Repairgun can also disable enemy grenades
			CBaseEMPableGrenade *pGrenade = dynamic_cast<CBaseEMPableGrenade*>(pEnt);

			// Ignore collisions with teammates, or friendly grenades
			if ( !pGrenade )
			{
				if ( pEnt->GetTeam() == m_pShooter->GetTeam() )
					return false;
			}
#else
			if ( pEnt->GetTeam() == m_pShooter->GetTeam() )
				return false;
#endif

		return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
	}

	CBaseEntity	*m_pShooter;
};

//-----------------------------------------------------------------------------
// Purpose: Vehicle checking to see if we should switch targets from a player 
//			to a vehicle, or vice versa.
//-----------------------------------------------------------------------------
CBaseEntity *CWeaponRepairGun::CheckVehicleTargets( CBaseEntity *pCurHealing )
{
	// Unable to switch to/from players?
	if ( !TargetsPlayers() )
		return pCurHealing;

	CBaseTFVehicle *pTargetVehicle = NULL;

	// If we're a fully healed player sitting in a vehicle, see if the vehicle needs healing instead
	if ( pCurHealing->IsPlayer() && pCurHealing->GetHealth() >= pCurHealing->GetMaxHealth() )
	{
		CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)pCurHealing;
		if ( !pPlayer->IsInAVehicle() )
			return pCurHealing;

		pTargetVehicle = (CBaseTFVehicle*)(pPlayer->GetVehicle()->GetVehicleEnt());
		if ( pTargetVehicle->GetHealth() < pTargetVehicle->GetMaxHealth() )
			return pTargetVehicle;
	}
	else
	{
		// If the entity is a vehicle, and it's fully healed, heal any players in it instead
		pTargetVehicle = dynamic_cast<CBaseTFVehicle *>(pCurHealing);
	}

	// Is the vehicle fully healed?
	if ( pTargetVehicle && pTargetVehicle->GetHealth() >= pTargetVehicle->GetMaxHealth() )
	{
		CBaseTFPlayer *pUnhurtPlayer = NULL;
		CBaseTFPlayer *pHurtPlayer = NULL;

		// Go through all players in the vehicle
		int iMax = pTargetVehicle->GetMaxPassengerCount();
		for ( int i = 0; i < iMax; i++ )
		{
			CBaseTFPlayer *pPlayer = (CBaseTFPlayer *)pTargetVehicle->GetPassenger(i);
			if ( pPlayer )
			{
				if ( pPlayer->GetHealth() < pPlayer->GetMaxHealth() )
				{
					pUnhurtPlayer = pPlayer;
				}
				else
				{
					pHurtPlayer = pPlayer;
				}
			}
		}

		// Heal hurt players first
		if ( pHurtPlayer )
			return pHurtPlayer;

		if ( pUnhurtPlayer )
			return pUnhurtPlayer;
	}

	return pCurHealing;
}

//-----------------------------------------------------------------------------
// Purpose: Returns a pointer to a healable target
//-----------------------------------------------------------------------------
CBaseEntity *CWeaponRepairGun::GetTargetToHeal( CBaseEntity *pCurHealing )
{
	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
	if ( !pOwner )
		return NULL;

	Vector vecSrc = pOwner->Weapon_ShootPosition( );
	

	// If we're already healing someone, stick onto them as long as possible.
	// Even if we can't heal them at the moment, lock onto them until they release the buttom.
	CBaseEntity* pTarget = pCurHealing;
	CBaseEntity* pVehicle = NULL;	// Vehicle the owner is in, or NULL.

	// You can't heal a vehicle you are sitting in, make sure we aren't healing a vehicle right after we've gotten in.
	if( ((CBaseTFPlayer*)pOwner)->IsInAVehicle() )
	{

		pVehicle = ((CBaseTFPlayer*)pOwner)->GetVehicle()->GetVehicleEnt();		
		if( pVehicle == pTarget )
		{
			pTarget = NULL;
		}
	}

	if ( pTarget && pTarget->IsAlive() && (pTarget->GetTeam() == pOwner->GetTeam()) )
	{
		// Make sure the guy didn't go out of range.
		Vector vecTargetPoint = pTarget->WorldSpaceCenter();
		Vector vecPoint;

		// If it's brush built, use absmins/absmaxs
		pTarget->CollisionProp()->CalcNearestPoint( vecSrc, &vecPoint );

#ifndef CLIENT_DLL
		//NDebugOverlay::Box( vecPoint, Vector(-2,-2,-2), Vector(2,2,2), 255,0,0, 8, 0.1 );
#endif

		float flDistance = (vecPoint - vecSrc).Length();
		if ( flDistance < GetStickRange() )
		{
			trace_t tr;
			CRepairFilter drainFilter( pOwner );
			UTIL_TraceLine( vecSrc, vecTargetPoint, MASK_SHOT, &drainFilter, &tr );
			
			if (( tr.fraction == 1.0f) || (tr.m_pEnt == pTarget))
				return CheckVehicleTargets( pTarget );
		}

		// Return null so we can't heal this player but m_hHealingPlayer stays set to them.
		return NULL;
	}
	else
	{	
		// Ok, try to find a new player to heal.
		// Get the target point and location
		Vector vecAiming;
		pOwner->EyeVectors( &vecAiming );

		// Find a player in range of this player, and make sure they're healable.
		Vector vecEnd = vecSrc + vecAiming * GetTargetRange();
		trace_t tr;

		// Use WeaponTraceLine so shields are tested...
		TFGameRules()->WeaponTraceLine( vecSrc, vecEnd, (MASK_SHOT & ~CONTENTS_HITBOX), pOwner, DMG_PROBE, &tr );

#ifndef CLIENT_DLL
		//NDebugOverlay::Box( vecSrc, Vector(-2,-2,-2), Vector(2,2,2), 192,192,0, 8, 10 );
		//NDebugOverlay::Box( vecEnd, Vector(-2,-2,-2), Vector(2,2,2), 0,255,0, 8, 10 );
		//NDebugOverlay::Box( tr.endpos, Vector(-2,-2,-2), Vector(2,2,2), 0,0,255, 8, 10 );
#endif
		
		if ( tr.fraction != 1.0 )
		{
			CBaseEntity *pEntity = tr.m_pEnt;
			if ( pEntity )
			{
				// Repairgun can also disable enemy grenades
#ifdef REPAIR_GUN_DISABLES_GRENADES 

				CBaseEMPableGrenade *pGrenade = dynamic_cast<CBaseEMPableGrenade*>(pEntity);
				if ( pGrenade && !pGrenade->InSameTeam( pOwner ) )
					return pGrenade;
#endif

				// Only target players if I'm allowed to
				if ( !TargetsPlayers() && pEntity->IsPlayer() )
					return NULL;

				// You can't heal a vehicle you are sitting in.
				if ( pVehicle && ( pVehicle == pEntity ) )
					return NULL;

				if ( (pEntity != pOwner) && pEntity->IsAlive() && pEntity->CanBePoweredUp() )
				{
					// Target needs to be on the same team
					if ( pEntity->InSameTeam( pOwner ) )
						return CheckVehicleTargets( pEntity );
				}
			}
		}

		if ( weapon_repairgun_debug.GetBool() )
		{
			ClientPrint( pOwner, HUD_PRINTCENTER, "REPAIRGUN: no target found\n" );
		}

		return NULL;
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Overloaded to handle the hold-down healing
//-----------------------------------------------------------------------------
void CWeaponRepairGun::ItemPostFrame( void )
{
	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
	if ( !pOwner )
		return;

#if !defined( CLIENT_DLL )
	if ( AppliesModifier() )
	{
		m_DamageModifier.SetModifier( weapon_repairgun_damage_modifier.GetFloat() );
	}
#endif

	// Try to start healing
	m_bAttacking = false;
	if ( (pOwner->m_nButtons & IN_ATTACK) && GetShieldState() == SS_DOWN )
	{
		PrimaryAttack();
		m_bAttacking = true;
	}
	else if ( GetCurHealingTarget() )
	{
		// Detach from the player if they release the attack button.
		RemoveHealingTarget();
	}

	// Prevent shield post frame if we're not ready to attack, or we're healing
	AllowShieldPostFrame( !m_bAttacking );

	WeaponIdle();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CWeaponRepairGun::RemoveHealingTarget()
{
	// Stop the welding animation
	if ( m_bHealing )
	{
		SendWeaponAnim( ACT_FIRE_END );
	}

	m_hHealingTarget = NULL;
#if !defined( CLIENT_DLL )
	m_DamageModifier.RemoveModifier();
#endif
	m_bHealing = false;

	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
	if ( pOwner )
	{
		pOwner->SetIDEnt( NULL );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponRepairGun::ComputeEMPFireState( void )
{
	if ( IsOwnerEMPed() )
	{
		// If we've just been EMPed, remove the heal target
		if ( GetCurHealingTarget() )
		{
			RemoveHealingTarget();
		}
		return false;
	}
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Attempt to heal any player within range of the medikit
//-----------------------------------------------------------------------------
void CWeaponRepairGun::PrimaryAttack( void )
{
	CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
	if ( !pOwner )
		return;

	// Can't fire if we've been EMPed.
	if ( !ComputeEMPFireState() )
		return;

#if !defined( CLIENT_DLL )
	// Find a Player to buff with hitscan
	CBaseEntity *pCurHealing = GetCurHealingTarget();
	CBaseEntity *pTarget = GetTargetToHeal( pCurHealing );
	if ( pTarget )
	{
		// Start the welding animation
		if ( !m_bHealing )
		{
			SendWeaponAnim( ACT_FIRE_START );
		}

		// Tell the client who we're trying to heal.
		m_bHealing = true;
		m_hHealingTarget = pTarget;

		// Repairgun needs to EMP grenades, heal everything else
#ifdef REPAIR_GUN_DISABLES_GRENADES 

		CBaseEMPableGrenade *pGrenade = dynamic_cast<CBaseEMPableGrenade*>(pTarget);
		if ( pGrenade )
		{
			pTarget->TakeEMPDamage( 1.0 );
		}
		else
#endif
		{
			// Can't bring things back from the dead
			if ( pTarget->IsAlive() )
			{
				float flBoostAmount = GetHealRate() * gpGlobals->frametime;
				// If it's an object, and it's constructing, use the construction heal rate
				if ( pTarget->Classify() == CLASS_MILITARY )
				{
					CBaseObject *pObject = dynamic_cast<CBaseObject*>(pTarget);
					if ( pObject && pObject->IsBuilding() )
					{
						flBoostAmount = weapon_repairgun_construction_rate.GetFloat() * gpGlobals->frametime;
					}
					if ( pObject && pObject->IsDying() )
					{
						flBoostAmount = 0;
					}
				}

				// If we're not succeeding, remove the damage modifier
				if ( !pTarget->AttemptToPowerup( POWERUP_BOOST, 1.0, flBoostAmount, pOwner, AppliesModifier() ? &m_DamageModifier : NULL ) )
				{
					m_DamageModifier.RemoveModifier();
				}

				// Force the player's ID target to the heal target
				pOwner->SetIDEnt( pTarget );
			}
		}
	}
	else
	{
		RemoveHealingTarget();
	}
#endif

	CheckRemoveDisguise();
}

void CWeaponRepairGun::PlayAttackAnimation( int activity )
{
	SendWeaponAnim( activity );
}

//-----------------------------------------------------------------------------
// Purpose: Idle tests to see if we're facing a valid target for the medikit
//			If so, move into the "heal-able" animation. 
//			Otherwise, move into the "not-heal-able" animation.
//-----------------------------------------------------------------------------
void CWeaponRepairGun::WeaponIdle( void )
{
	if ( HasWeaponIdleTimeElapsed() )
	{
		// Loop the welding animation
		if ( m_bHealing )
		{
			SendWeaponAnim( ACT_FIRE_LOOP );
		}
		else
		{
			// select an idle animation
			SendWeaponAnim( ACT_VM_IDLE );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: The player holding this weapon has just gained new technology.
//			Check to see if it affects the medikit
//-----------------------------------------------------------------------------
void CWeaponRepairGun::GainedNewTechnology( CBaseTechnology *pTechnology )
{
}


#if defined( CLIENT_DLL )
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CWeaponRepairGun::StopRepairSound( bool bStopHealingSound, bool bStopNoTargetSound )
{
	if ( bStopHealingSound )
	{
		StopSound( "WeaponRepairGun.Healing" );
	}

	if ( bStopNoTargetSound )
	{
		StopSound( "WeaponRepairGun.NoTarget" );
	}
}


void C_WeaponRepairGun::NotifyShouldTransmit( ShouldTransmitState_t state )
{
	// Stop emitting particles if we're going dormant.
	if ( state == SHOULDTRANSMIT_END )
	{
		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
	}

	BaseClass::NotifyShouldTransmit( state );
}


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

	if ( updateType == DATA_UPDATE_CREATED )
	{
		m_pEmitter = CSimpleEmitter::Create( "C_WeaponRepairGun" );
		
		m_hParticleMaterial = m_pEmitter->GetPMaterial( "sprites/chargeball" );
	}

	// Think?
	if ( m_bHealing && m_hHealingTarget.Get())
	{
		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
	}
	else
	{
		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
		m_bPlayingSound = false;
		StopRepairSound( true, false );

		// Are they holding the attack button but not healing anyone? Give feedback.
		if ( IsActiveByLocalPlayer() && GetOwner() && GetOwner()->IsAlive() && m_bAttacking && GetOwner() == C_BasePlayer::GetLocalPlayer() )
		{
			if ( gpGlobals->curtime >= m_flNextBuzzTime )
			{
				CLocalPlayerFilter filter;
				EmitSound( filter, entindex(), "WeaponRepairGun.NoTarget" );
				m_flNextBuzzTime = gpGlobals->curtime + 0.5f;	// only buzz every so often.
			}
		}
		else
		{
			StopRepairSound( false, true );	// Stop the "no target" sound.
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_WeaponRepairGun::ClientThink()
{
	C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();
	if ( !pPlayer )
		return;

	if ( m_hHealingTarget == NULL )
	{
		return;
	}

	// Don't show it while the player is dead. Ideally, we'd respond to m_bHealing in OnDataChanged,
	// but it stops sending the weapon when it's holstered, and it gets holstered when the player dies.
	C_BasePlayer *pFiringPlayer = dynamic_cast< C_BasePlayer* >( GetOwner() );
	if ( !pFiringPlayer || pFiringPlayer->IsPlayerDead() )
	{
		ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_NEVER );
		m_bPlayingSound = false;
		StopRepairSound();
		return;
	}

	if ( !m_bPlayingSound )
	{
		m_bPlayingSound = true;
		CLocalPlayerFilter filter;
		EmitSound( filter, entindex(), "WeaponRepairGun.Healing" );
	}

	Vector points[NUM_REPAIRGUN_PATH_POINTS];

	// First generate a sequence of points so we can parameterize the (curvy) path from the
	// tip of the gun to the target.
	Vector vForward, vOrigin;
	QAngle vAngles;
	GetShootPosition( vOrigin, vAngles );

	AngleVectors( vAngles, &vForward );

	Vector vecTargetOrg = m_hHealingTarget->WorldSpaceCenter();
	
	Vector vDirTo = vecTargetOrg - vOrigin;
	float flDistanceTo = vDirTo.Length();
	vDirTo /= flDistanceTo;

	float flBendDist = flDistanceTo * 3;
	const Vector  A = vOrigin - vForward * flBendDist;
	const Vector &B = vOrigin;
	const Vector &C = vecTargetOrg;
	const Vector  D = vecTargetOrg - vForward * flBendDist;
	
	for ( int i=0; i < NUM_REPAIRGUN_PATH_POINTS; i++ )
	{
		Catmull_Rom_Spline( A, B, C, D, (float)i / (NUM_REPAIRGUN_PATH_POINTS-1), points[i] );
	}

	// Add random short-lived particles from the gun tip to the target.
	m_pEmitter->SetSortOrigin( (vecTargetOrg + pPlayer->GetAbsOrigin()) * 0.5f );

	float flCur = gpGlobals->frametime;
	while ( m_PathParticleEvent.NextEvent( flCur ) )
	{
		float t = RandomFloat( 0, 1 );
		int iPrev = (int)( t * (NUM_REPAIRGUN_PATH_POINTS - 1.001) );
		float tPrev = (float)iPrev / (NUM_REPAIRGUN_PATH_POINTS - 1);
		float tNext = (float)(iPrev+1) / (NUM_REPAIRGUN_PATH_POINTS - 1);
		Assert( tNext <= NUM_REPAIRGUN_PATH_POINTS-1 );

		Vector vPos;
		VectorLerp( points[iPrev], points[iPrev+1], (t-tPrev) / (tNext - tPrev), vPos );
		vPos += RandomVector( -3, 3 );
		
		SimpleParticle *pParticle = m_pEmitter->AddSimpleParticle( m_hParticleMaterial, vPos );
		if ( pParticle )
		{
			// Move the points along the path.
			pParticle->m_vecVelocity = points[iPrev+1] - points[iPrev];
			VectorNormalize( pParticle->m_vecVelocity );
			pParticle->m_vecVelocity *= PARTICLE_PATH_VEL;

			pParticle->m_flRoll = 0;
			pParticle->m_flRollDelta = 0;
			pParticle->m_flDieTime = 0.2f;
			pParticle->m_flLifetime = 0;
			pParticle->m_uchColor[1] = 200; 
			pParticle->m_uchColor[0] = pParticle->m_uchColor[2] = RandomInt( 0, 128 );
			pParticle->m_uchStartAlpha = 255;
			pParticle->m_uchEndAlpha = 0;
			pParticle->m_uchStartSize = 5;
			pParticle->m_uchEndSize = 3;
			pParticle->m_iFlags = 0;
		}
	}
}

#endif