void C_EntityFlame::CreateEffect( void )
{
if ( m_hEffect )
{
ParticleProp()->StopEmission( m_hEffect, true );
m_hEffect->SetControlPointEntity( 0, NULL );
m_hEffect->SetControlPointEntity( 1, NULL );
m_hEffect = NULL;
}
#ifdef TF_CLIENT_DLL
m_hEffect = ParticleProp()->Create( "burningplayer_red", PATTACH_ABSORIGIN_FOLLOW );
#else
m_hEffect = ParticleProp()->Create( "burning_character", PATTACH_ABSORIGIN_FOLLOW );
#endif
if ( m_hEffect )
{
C_BaseEntity *pEntity = m_hEntAttached;
m_hOldAttached = m_hEntAttached;
ParticleProp()->AddControlPoint( m_hEffect, 1, pEntity, PATTACH_ABSORIGIN_FOLLOW );
m_hEffect->SetControlPoint( 0, GetAbsOrigin() );
m_hEffect->SetControlPoint( 1, GetAbsOrigin() );
m_hEffect->SetControlPointEntity( 0, pEntity );
m_hEffect->SetControlPointEntity( 1, pEntity );
}
}
void C_ASW_AOEGrenade_Projectile::UpdateParticleAttachments( CNewParticleEffect *pEffect, C_BaseEntity *pTarget )
{
if ( GetArcAttachmentName() )
{
bool bAttachWeapon = false;
if ( ShouldAttachEffectToWeapon() )
{
C_ASW_Marine *pMarine = C_ASW_Marine::AsMarine( pTarget );
if ( pMarine && pMarine->GetActiveASWWeapon() )
{
C_ASW_Weapon *pWeapon = pMarine->GetActiveASWWeapon();
int iAttachment = pWeapon->LookupAttachment( "muzzle" );
if ( pWeapon->IsOffensiveWeapon() && iAttachment > 0 )
{
bAttachWeapon = true;
ParticleProp()->AddControlPoint( pEffect, 1, pWeapon, PATTACH_POINT_FOLLOW, "muzzle" );
}
}
}
if ( !bAttachWeapon )
ParticleProp()->AddControlPoint( pEffect, 1, pTarget, PATTACH_POINT_FOLLOW, GetArcAttachmentName() );
}
else
{
ParticleProp()->AddControlPoint( pEffect, 1, pTarget, PATTACH_ABSORIGIN_FOLLOW );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : updateType -
//-----------------------------------------------------------------------------
void CTFGrenadePipebombProjectile::OnDataChanged(DataUpdateType_t updateType)
{
BaseClass::OnDataChanged( updateType );
if ( updateType == DATA_UPDATE_CREATED )
{
m_flCreationTime = gpGlobals->curtime;
ParticleProp()->Create( GetTrailParticleName(), PATTACH_ABSORIGIN_FOLLOW );
m_bPulsed = false;
CTFPipebombLauncher *pLauncher = dynamic_cast<CTFPipebombLauncher*>( m_hLauncher.Get() );
if ( pLauncher )
{
pLauncher->AddPipeBomb( this );
}
if ( m_bCritical )
{
switch( GetTeamNumber() )
{
case TF_TEAM_BLUE:
if ( m_iType == TF_GL_MODE_REMOTE_DETONATE )
{
ParticleProp()->Create( "critical_grenade_blue", PATTACH_ABSORIGIN_FOLLOW );
}
else
{
ParticleProp()->Create( "critical_pipe_blue", PATTACH_ABSORIGIN_FOLLOW );
}
break;
case TF_TEAM_RED:
if ( m_iType == TF_GL_MODE_REMOTE_DETONATE )
{
ParticleProp()->Create( "critical_grenade_red", PATTACH_ABSORIGIN_FOLLOW );
}
else
{
ParticleProp()->Create( "critical_pipe_red", PATTACH_ABSORIGIN_FOLLOW );
}
break;
default:
break;
}
}
}
else if ( m_bTouched )
{
//ParticleProp()->StopEmission();
}
}
void C_AI_BaseNPC::UpdateOnRemove( void )
{
#ifdef TF_CLASSIC_CLIENT
ParticleProp()->OwnerSetDormantTo( true );
ParticleProp()->StopParticlesInvolving( this );
RemoveAllCond();
#endif
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Create a telekinetic beam effect from my head to an object
// TODO: use a point attachment.
//-----------------------------------------------------------------------------
void C_NPC_Advisor::StartBeamFX( C_BaseEntity *pOnEntity )
{
Assert(pOnEntity);
if (!pOnEntity)
return;
CNewParticleEffect *pEffect = ParticleProp()->Create( "Advisor_Psychic_Beam", PATTACH_ABSORIGIN_FOLLOW );
Assert(pEffect);
if (!pEffect) return;
ParticleProp()->AddControlPoint( pEffect, 1, pOnEntity, PATTACH_ABSORIGIN_FOLLOW );
}
void CWeaponDrainGrenade::OnDataChanged( DataUpdateType_t updateType )
{
if (updateType == DATA_UPDATE_CREATED)
{
m_apEffects.AddToTail(ParticleProp()->Create( "grenade_particle", PATTACH_ABSORIGIN_FOLLOW ));
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_FireSmoke::Start( void )
{
const char *lpszEffectName;
int nSize = (int) floor( m_flStartScale / 36.0f );
switch ( nSize )
{
case 0:
lpszEffectName = ( m_nFlags & bitsFIRESMOKE_SMOKE ) ? "env_fire_tiny_smoke" : "env_fire_tiny";
break;
case 1:
lpszEffectName = ( m_nFlags & bitsFIRESMOKE_SMOKE ) ? "env_fire_small_smoke" : "env_fire_small";
break;
case 2:
lpszEffectName = ( m_nFlags & bitsFIRESMOKE_SMOKE ) ? "env_fire_medium_smoke" : "env_fire_medium";
break;
case 3:
default:
lpszEffectName = ( m_nFlags & bitsFIRESMOKE_SMOKE ) ? "env_fire_large_smoke" : "env_fire_large";
break;
}
// Create the effect of the correct size
m_hEffect = ParticleProp()->Create( lpszEffectName, PATTACH_ABSORIGIN );
}
void C_ASW_Buzzer::UpdateFireEmitters()
{
bool bOnFire = (m_bOnFire && !IsEffectActive(EF_NODRAW));
if (bOnFire != m_bClientOnFire)
{
m_bClientOnFire = bOnFire;
if (m_bClientOnFire)
{
if ( !m_pBurningEffect )
{
m_pBurningEffect = UTIL_ASW_CreateFireEffect( this );
}
EmitSound( "ASWFire.BurningFlesh" );
}
else
{
if ( m_pBurningEffect )
{
ParticleProp()->StopEmission( m_pBurningEffect );
m_pBurningEffect = NULL;
}
StopSound("ASWFire.BurningFlesh");
if ( C_BaseEntity::IsAbsQueriesValid() )
EmitSound("ASWFire.StopBurning");
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_ParticleSystem::PostDataUpdate( DataUpdateType_t updateType )
{
BaseClass::PostDataUpdate( updateType );
// Always restart if just created and updated
// FIXME: Does this play fairly with PVS?
if ( updateType == DATA_UPDATE_CREATED )
{
if ( m_bActive )
{
// Delayed here so that we don't get invalid abs queries on level init with active particle systems
SetNextClientThink( gpGlobals->curtime );
}
}
else
{
if ( m_bOldActive != m_bActive )
{
if ( m_bActive )
{
// Delayed here so that we don't get invalid abs queries on level init with active particle systems
SetNextClientThink( gpGlobals->curtime );
}
else
{
ParticleProp()->StopEmission();
}
}
}
}
C_ASW_TeslaTrap::~C_ASW_TeslaTrap()
{
if ( m_hEffects )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hEffects );
m_hEffects = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_ParticleSystem::ClientThink( void )
{
if ( m_bActive )
{
const char *pszName = GetParticleSystemNameFromIndex( m_iEffectIndex );
if ( pszName && pszName[0] )
{
CNewParticleEffect *pEffect = ParticleProp()->Create( pszName, PATTACH_ABSORIGIN_FOLLOW );
AssertMsg1( pEffect, "Particle system couldn't make %s", pszName );
if (pEffect)
{
for ( int i = 0 ; i < kMAXCONTROLPOINTS ; ++i )
{
CBaseEntity *pOnEntity = m_hControlPointEnts[i].Get();
if ( pOnEntity )
{
ParticleProp()->AddControlPoint( pEffect, i + 1, pOnEntity, PATTACH_ABSORIGIN_FOLLOW );
}
AssertMsg2( m_iControlPointParents[i] >= 0 && m_iControlPointParents[i] <= kMAXCONTROLPOINTS ,
"Particle system specified bogus control point parent (%d) for point %d.",
m_iControlPointParents[i], i );
if (m_iControlPointParents[i] != 0)
{
pEffect->SetControlPointParent(i+1, m_iControlPointParents[i]);
}
}
// NOTE: What we really want here is to compare our lifetime and that of our children and see if this delta is
// already past the end of it, denoting that we're finished. In that case, just destroy us and be done. -- jdw
// TODO: This can go when the SkipToTime code below goes
ParticleProp()->OnParticleSystemUpdated( pEffect, 0.0f );
// Skip the effect ahead if we're restarting it
float flTimeDelta = gpGlobals->curtime - m_flStartTime;
if ( flTimeDelta > 0.01f )
{
VPROF_BUDGET( "C_ParticleSystem::ClientThink SkipToTime", "Particle Simulation" );
pEffect->SkipToTime( flTimeDelta );
}
}
}
}
}
//-----------------------------------------------------------------------------
// terminate a telekinetic beam effect from my head to an object
//-----------------------------------------------------------------------------
void C_NPC_Advisor::StopBeamFX( C_BaseEntity *pOnEntity )
{
Assert(pOnEntity);
if (!pOnEntity)
return;
ParticleProp()->StopParticlesInvolving( pOnEntity );
}
void C_ASW_Sentry_Top::CreateRadiusBeamEdges( const Vector &vecStart, const Vector &vecDir, int iControlPoint )
{
if ( !m_hRadiusDisplay )
return;
ParticleProp()->AddControlPoint( m_hRadiusDisplay, iControlPoint, this, PATTACH_CUSTOMORIGIN );
m_hRadiusDisplay->SetControlPointEntity( iControlPoint, this );
AdjustRadiusBeamEdges( vecStart, vecDir, iControlPoint );
}
void C_ASW_Sentry_Top::OnDataChanged( DataUpdateType_t updateType )
{
if ( updateType == DATA_UPDATE_CREATED )
{
SetNextClientThink(gpGlobals->curtime);
m_fPrevDeployYaw = m_fDeployYaw;
}
if ( m_bLowAmmo && !m_hWarningLight )
{
m_hWarningLight = ParticleProp()->Create( "sentry_light_lowammo", PATTACH_ABSORIGIN_FOLLOW );
if ( m_hWarningLight )
{
ParticleProp()->AddControlPoint( m_hWarningLight, 0, this, PATTACH_POINT_FOLLOW, "attach_light" );
}
}
BaseClass::OnDataChanged( updateType );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFRocketLauncher::CreateMuzzleFlashEffects( C_BaseEntity *pAttachEnt, int nIndex )
{
BaseClass::CreateMuzzleFlashEffects( pAttachEnt, nIndex );
// Don't do backblast effects in first person
C_TFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
if ( pOwner->IsLocalPlayer() )
return;
ParticleProp()->Create( "rocketbackblast", PATTACH_POINT_FOLLOW, "backblast" );
}
C_ASW_Sentry_Top::~C_ASW_Sentry_Top()
{
if ( m_hRadiusDisplay )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hRadiusDisplay );
m_hRadiusDisplay = NULL;
}
if ( m_hWarningLight )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hWarningLight );
m_hWarningLight = NULL;
}
if ( m_hPilotLight )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hPilotLight );
m_hPilotLight = NULL;
}
}
void CEconWearable::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( type == DATA_UPDATE_DATATABLE_CHANGED )
{
if (Q_stricmp(m_ParticleName, "") && !m_pUnusualParticle)
{
m_pUnusualParticle = ParticleProp()->Create(m_ParticleName, PATTACH_ABSORIGIN_FOLLOW);
}
}
}
C_ASW_Buzzer::~C_ASW_Buzzer()
{
m_bOnFire = false;
UpdateFireEmitters();
if ( m_pTrailEffect )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_pTrailEffect );
m_pTrailEffect = NULL;
}
}
void CASW_Weapon_Welder::CreateWeldingEffects( C_ASW_Door* pDoor )
{
if ( !m_bIsFiring || !GetOwner() || !pDoor )
return;
if ( m_hWeldEffects )
{
RemoveWeldingEffects();
}
if ( !m_hWeldEffects )
{
if ( m_bWeldSeal )
m_hWeldEffects = ParticleProp()->Create( "welding_door_seal", PATTACH_CUSTOMORIGIN );
else
m_hWeldEffects = ParticleProp()->Create( "welding_door_cut", PATTACH_CUSTOMORIGIN );
if ( m_hWeldEffects )
{
m_hWeldEffects->SetControlPoint( 0, pDoor->GetSparkNormal( GetMarine() ) );
m_hWeldEffects->SetControlPointForwardVector( 0, pDoor->GetWeldFacingPoint( GetMarine() ) );
}
/*
m_pLaserPointerEffect->SetControlPoint( 1, vecOrigin );
m_pLaserPointerEffect->SetControlPoint( 2, tr.endpos );
m_pLaserPointerEffect->SetControlPointForwardVector ( 1, vecDirShooting );
Vector vecImpactY, vecImpactZ;
VectorVectors( tr.plane.normal, vecImpactY, vecImpactZ );
vecImpactY *= -1.0f;
m_pLaserPointerEffect->SetControlPointOrientation( 2, vecImpactY, vecImpactZ, tr.plane.normal );
m_pLaserPointerEffect->SetControlPoint( 3, Vector( alpha, 0, 0 ) );
if ( m_hWeldEffects )
{
ParticleProp()->AddControlPoint( m_pLaserPointerEffect, 1, this, PATTACH_CUSTOMORIGIN );
ParticleProp()->AddControlPoint( m_pLaserPointerEffect, 2, this, PATTACH_CUSTOMORIGIN );
}
*/
}
}
void C_CFPlayer::OnDataChanged( DataUpdateType_t type )
{
BaseClass::OnDataChanged( type );
if ( type == DATA_UPDATE_CREATED )
{
SetNextClientThink( CLIENT_THINK_ALWAYS );
}
UpdateVisibility();
if ( m_bOverdrive && !m_pOverdriveEffect )
{
m_pOverdriveEffect = ParticleProp()->Create( "overdrive", PATTACH_ABSORIGIN_FOLLOW );
}
else if ( !m_bOverdrive && m_pOverdriveEffect )
{
ParticleProp()->StopEmission( m_pOverdriveEffect );
m_pOverdriveEffect = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TFProjectile_Rocket::CreateRocketTrails( void )
{
if ( IsDormant() )
return;
if ( enginetrace->GetPointContents( GetAbsOrigin() ) & MASK_WATER )
{
ParticleProp()->Create( "rockettrail_underwater", PATTACH_POINT_FOLLOW, "trail" );
}
else
{
ParticleProp()->Create( GetTrailParticleName(), PATTACH_POINT_FOLLOW, "trail" );
}
if ( m_bCritical )
{
switch( GetTeamNumber() )
{
case TF_TEAM_RED:
ParticleProp()->Create("critical_rocket_red", PATTACH_ABSORIGIN_FOLLOW);
break;
case TF_TEAM_BLUE:
ParticleProp()->Create( "critical_rocket_blue", PATTACH_ABSORIGIN_FOLLOW );
break;
case TF_TEAM_GREEN:
ParticleProp()->Create("critical_rocket_green", PATTACH_ABSORIGIN_FOLLOW);
break;
case TF_TEAM_YELLOW:
ParticleProp()->Create("critical_rocket_yellow", PATTACH_ABSORIGIN_FOLLOW);
break;
default:
break;
}
}
}
void CDABViewModel::DoMuzzleFlash()
{
#ifdef CLIENT_DLL
int id;
switch (GetDAWeapon()->GetWeaponType())
{
case WT_PISTOL:
default:
id = GetDAWeapon ()->GetWeaponID ();
if (SDK_WEAPON_AKIMBO_BERETTA == id || SDK_WEAPON_AKIMBO_M1911 == id)
{/*HACK: Alternate attachment for akimbos, where else to put this?*/
if (((CAkimbobase *)GetDAWeapon ())->shootright)
ParticleProp()->Create ("muzzleflash_pistol", PATTACH_POINT_FOLLOW, "2");
else
ParticleProp()->Create ("muzzleflash_pistol", PATTACH_POINT_FOLLOW, "1");
}
else ParticleProp()->Create( "muzzleflash_pistol", PATTACH_POINT_FOLLOW, "1" );
break;
case WT_SMG:
ParticleProp()->Create( "muzzleflash_smg", PATTACH_POINT_FOLLOW, "1" );
break;
case WT_RIFLE:
ParticleProp()->Create( "muzzleflash_rifle", PATTACH_POINT_FOLLOW, "1" );
break;
case WT_SHOTGUN:
ParticleProp()->Create( "muzzleflash_shotgun", PATTACH_POINT_FOLLOW, "1" );
break;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Start the buzzer's engine sound.
//-----------------------------------------------------------------------------
void C_ASW_Buzzer::UpdateOnRemove( void )
{
BaseClass::UpdateOnRemove();
SoundShutdown();
m_bOnFire = false;
UpdateFireEmitters();
if ( m_pTrailEffect )
{
ParticleProp()->StopEmission( m_pTrailEffect, false, true, false );
m_pTrailEffect = NULL;
}
}
void C_ASW_Sentry_Top::UpdateOnRemove()
{
BaseClass::UpdateOnRemove();
if ( m_hRadiusDisplay )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hRadiusDisplay );
m_hRadiusDisplay = NULL;
}
if ( m_hWarningLight )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hWarningLight );
m_hWarningLight = NULL;
}
if ( m_hPilotLight )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hPilotLight );
m_hPilotLight = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TFProjectile_Rocket::CreateRocketTrails( void )
{
if ( IsDormant() )
return;
if ( enginetrace->GetPointContents( GetAbsOrigin() ) & MASK_WATER )
{
ParticleProp()->Create( "rockettrail_underwater", PATTACH_POINT_FOLLOW, "trail" );
}
else
{
ParticleProp()->Create( GetTrailParticleName(), PATTACH_POINT_FOLLOW, "trail" );
}
if ( m_bCritical )
{
if ( TFGameRules() && TFGameRules()->IsDeathmatch() )
{
C_TFPlayer *pPlayer = ToTFPlayer(GetOwnerEntity());
if (pPlayer)
{
pPlayer->m_Shared.SetParticleToMercColor(
ParticleProp()->Create("critical_rocket_dm", PATTACH_ABSORIGIN_FOLLOW)
);
return;
}
ParticleProp()->Create("critical_rocket_red", PATTACH_ABSORIGIN_FOLLOW);
}
switch( GetTeamNumber() )
{
case TF_TEAM_RED:
ParticleProp()->Create("critical_rocket_red", PATTACH_ABSORIGIN_FOLLOW);
break;
case TF_TEAM_BLUE:
ParticleProp()->Create("critical_rocket_blue", PATTACH_ABSORIGIN_FOLLOW );
break;
case TF_TEAM_GREEN:
ParticleProp()->Create("critical_rocket_green", PATTACH_ABSORIGIN_FOLLOW);
break;
case TF_TEAM_YELLOW:
ParticleProp()->Create("critical_rocket_yellow", PATTACH_ABSORIGIN_FOLLOW);
break;
default:
break;
}
}
}
void C_TFVehicle::Simulate(void)
{
// The dim light is the flashlight.
if ( m_bHeadlightIsOn )
{
if ( m_pHeadlight == NULL )
{
// Turned on the headlight; create it.
m_pHeadlight = new CHeadlightEffect;
if ( m_pHeadlight == NULL )
return;
m_pHeadlight->TurnOn();
}
QAngle vAngle;
Vector vVector;
Vector vecForward, vecRight, vecUp;
int iAttachment = LookupAttachment( "headlight" );
if ( iAttachment != INVALID_PARTICLE_ATTACHMENT )
{
GetAttachment( iAttachment, vVector, vAngle );
AngleVectors( vAngle, &vecForward, &vecRight, &vecUp );
m_pHeadlight->UpdateLight( vVector, vecForward, vecRight, vecUp, JEEP_HEADLIGHT_DISTANCE );
}
}
else if ( m_pHeadlight )
{
// Turned off the flashlight; delete it.
delete m_pHeadlight;
m_pHeadlight = NULL;
}
// TODO: Move this to OnDataChanged
if ( m_bEnableDamageEffects && !m_pSmokeParticle )
{
m_pSmokeParticle = ParticleProp()->Create( m_iszSmokeParticleName , PATTACH_ABSORIGIN_FOLLOW );
}
else if ( !m_bEnableDamageEffects && m_pSmokeParticle )
{
m_pSmokeParticle->StopEmission( false, false );
m_pSmokeParticle = NULL;
}
BaseClass::Simulate();
}
void C_ASW_Shaman::UpdateEffects()
{
if ( !m_hHealingTarget.Get() || GetHealth() <= 0 )
{
if ( m_pHealEffect )
{
m_pHealEffect->StopEmission();
m_pHealEffect = NULL;
}
return;
}
if ( m_pHealEffect )
{
if ( m_pHealEffect->GetControlPointEntity( 1 ) != m_hHealingTarget.Get() )
{
m_pHealEffect->StopEmission();
m_pHealEffect = NULL;
}
}
if ( !m_pHealEffect )
{
m_pHealEffect = ParticleProp()->Create( "shaman_heal_attach", PATTACH_POINT_FOLLOW, "nozzle" ); // "heal_receiver"
}
Assert( m_pHealEffect );
if ( m_pHealEffect->GetControlPointEntity( 1 ) == NULL )
{
C_BaseEntity *pTarget = m_hHealingTarget.Get();
Vector vOffset( 0.0f, 0.0f, pTarget->WorldSpaceCenter().z - pTarget->GetAbsOrigin().z );
ParticleProp()->AddControlPoint( m_pHealEffect, 1, pTarget, PATTACH_ABSORIGIN_FOLLOW, NULL, vOffset );
m_pHealEffect->SetControlPointOrientation( 0, pTarget->Forward(), -pTarget->Left(), pTarget->Up() );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_TFProjectile_Rocket::OnDataChanged( DataUpdateType_t updateType )
{
BaseClass::OnDataChanged(updateType);
if ( updateType == DATA_UPDATE_CREATED )
{
CreateRocketTrails();
}
if ( m_iOldTeamNum && m_iOldTeamNum != m_iTeamNum )
{
ParticleProp()->StopEmission();
CreateRocketTrails();
}
}
CASW_Weapon_Welder::~CASW_Weapon_Welder()
{
if ( m_pWeldingSound )
{
CSoundEnvelopeController::GetController().Shutdown(m_pWeldingSound);
}
#ifdef CLIENT_DLL
if ( m_hWeldEffects )
{
ParticleProp()->StopEmissionAndDestroyImmediately( m_hWeldEffects );
m_hWeldEffects = NULL;
}
#endif
}
void CTFGrenadePipebombProjectile::Simulate( void )
{
BaseClass::Simulate();
if ( m_iType != TF_GL_MODE_REMOTE_DETONATE )
return;
if ( m_bPulsed == false )
{
if ( (gpGlobals->curtime - m_flCreationTime) >= tf_grenadelauncher_livetime.GetFloat() )
{
if ( GetTeamNumber() == TF_TEAM_RED )
{
ParticleProp()->Create( "stickybomb_pulse_red", PATTACH_ABSORIGIN );
}
else
{
ParticleProp()->Create( "stickybomb_pulse_blue", PATTACH_ABSORIGIN );
}
m_bPulsed = true;
}
}
}
