//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::OnFlechetteAttach( Vector &vecFlechetteVelocity )
{
if ( m_bLaunched )
{
Vector vecForce = vecFlechetteVelocity;
VectorNormalize( vecForce );
vecForce *= 1000;
vecForce.z = -5000;
VPhysicsGetObject()->ApplyForceCenter( vecForce );
}
if ( !GetParent() || !GetParent()->ClassMatches( g_iszVehicle ) )
{
if ( !m_bNoseDiving )
{
//m_hGlowTrail->StopParticleSystem();
StopParticleEffects( this );
if( m_iBusterFlags & STRIDERBUSTER_FLAG_KNOCKED_OFF_STRIDER )
{
DispatchParticleEffect( "striderbuster_shotdown_trail", PATTACH_ABSORIGIN_FOLLOW, this );
}
else
{
DispatchParticleEffect( "striderbuster_flechette_attached", PATTACH_ABSORIGIN_FOLLOW, this );
}
}
m_bNoseDiving = true;
}
m_nAttachedFlechettes++;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAntlionGrub::Squash( CBaseEntity *pOther, bool bDealDamage, bool bSpawnBlood )
{
// If we're already squashed, then don't bother doing it again!
if ( GetEffects() & EF_NODRAW )
return;
SpawnSquashedGrub();
AddEffects( EF_NODRAW );
AddSolidFlags( FSOLID_NOT_SOLID );
// Stop being attached to us
if ( m_hGlowSprite )
{
FadeGlow();
m_hGlowSprite->SetParent( NULL );
}
EmitSound( "NPC_Antlion_Grub.Die" );
EmitSound( "NPC_Antlion_Grub.Squish" );
// if vort stepped on me, maybe he wants to say something
if ( pOther && FClassnameIs( pOther, "npc_vortigaunt" ) )
{
Assert(dynamic_cast<CNPC_Vortigaunt *>(pOther));
static_cast<CNPC_Vortigaunt *>(pOther)->OnSquishedGrub(this);
}
SetTouch( NULL );
//if ( bSpawnBlood )
{
// Temp squash effect
Vector vecForward, vecUp;
AngleVectors( GetAbsAngles(), &vecForward, NULL, &vecUp );
// Start effects at either end of the grub
Vector vecSplortPos = GetAbsOrigin() + vecForward * 14.0f;
DispatchParticleEffect( "GrubSquashBlood", vecSplortPos, GetAbsAngles() );
vecSplortPos = GetAbsOrigin() - vecForward * 16.0f;
Vector vecDir = -vecForward;
QAngle vecAngles;
VectorAngles( vecDir, vecAngles );
DispatchParticleEffect( "GrubSquashBlood", vecSplortPos, vecAngles );
MakeSquashDecals( GetAbsOrigin() + vecForward * 32.0f );
MakeSquashDecals( GetAbsOrigin() - vecForward * 32.0f );
}
// Deal deadly damage to ourself
if ( bDealDamage )
{
CTakeDamageInfo info( pOther, pOther, Vector( 0, 0, -1 ), GetAbsOrigin(), GetHealth()+1, DMG_CRUSH );
TakeDamage( info );
}
}
int ASW_GiveAmmo( CASW_Marine *pMarine, float flCount, const char *pszAmmoName, CBaseEntity *pAmmoEntity, bool bSuppressSound = false )
{
int iAmmoType = GetAmmoDef()->Index(pszAmmoName);
if ( iAmmoType == -1 )
{
Msg("ERROR: Attempting to give unknown ammo type (%s)\n",pszAmmoName);
return 0;
}
int amount = pMarine->GiveAmmo( flCount, iAmmoType, bSuppressSound );
if ( amount == 0 )
amount = pMarine->GiveAmmoToAmmoBag( flCount, iAmmoType, bSuppressSound );
if ( amount > 0 )
{
pMarine->TookAmmoPickup( pAmmoEntity );
// Check the ammo type... for some doing a spilling bullet effect isn't fictionally appropriate
if ( iAmmoType != GetAmmoDef()->Index( "ASW_F" ) && iAmmoType != GetAmmoDef()->Index( "ASW_ML" ) && iAmmoType != GetAmmoDef()->Index( "ASW_TG" ) && iAmmoType != GetAmmoDef()->Index( "ASW_GL" ) )
{
// Do effects
int iAmmoCost = CASW_Ammo_Drop_Shared::GetAmmoUnitCost( iAmmoType );
if ( iAmmoCost < 20 )
{
pAmmoEntity->EmitSound( "ASW_Ammobag.Pickup_sml" );
DispatchParticleEffect( "ammo_satchel_take_sml", pAmmoEntity->GetAbsOrigin() + Vector( 0, 0, 4 ), vec3_angle );
}
else if ( iAmmoCost < 75 )
{
pAmmoEntity->EmitSound( "ASW_Ammobag.Pickup_med" );
DispatchParticleEffect( "ammo_satchel_take_med", pAmmoEntity->GetAbsOrigin() + Vector( 0, 0, 4 ), vec3_angle );
}
else
{
pAmmoEntity->EmitSound( "ASW_Ammobag.Pickup_lrg" );
DispatchParticleEffect( "ammo_satchel_take_lrg", pAmmoEntity->GetAbsOrigin() + Vector( 0, 0, 4 ), vec3_angle );
}
}
IGameEvent * event = gameeventmanager->CreateEvent( "ammo_pickup" );
if ( event )
{
CASW_Player *pPlayer = pMarine->GetCommander();
event->SetInt( "userid", ( pPlayer ? pPlayer->GetUserID() : 0 ) );
event->SetInt( "entindex", pMarine->entindex() );
gameeventmanager->FireEvent( event );
}
}
return amount;
}
void CASW_Weapon_Chainsaw::EndAttack( void )
{
if ( m_fireState != FIRE_OFF )
{
StartAttackOffSound();
#ifdef CLIENT_DLL
DispatchParticleEffect( "mining_laser_exhaust", PATTACH_POINT_FOLLOW, this, "eject1" );
#endif
}
StopChainsawSound();
SetWeaponIdleTime( gpGlobals->curtime + 2.0 );
m_flNextPrimaryAttack = gpGlobals->curtime + GetWeaponInfo()->m_flFireRate;
m_flNextSecondaryAttack = gpGlobals->curtime + GetWeaponInfo()->m_flFireRate;
SetFiringState(FIRE_OFF);
ClearIsFiring();
DestroyEffect();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void BloodImpactCallback( const CEffectData & data )
{
bool bFoundBlood = false;
// Find which sort of blood we are
for ( int i = 0; i < ARRAYSIZE( bloodCallbacks ); i++ )
{
if ( bloodCallbacks[i].nColor == data.m_nColor )
{
QAngle vecAngles;
VectorAngles( -data.m_vNormal, vecAngles );
DispatchParticleEffect( bloodCallbacks[i].lpszParticleSystemName, data.m_vOrigin, vecAngles );
bFoundBlood = true;
break;
}
}
if ( bFoundBlood == false )
{
Vector vecPosition;
vecPosition = data.m_vOrigin;
// Fetch the blood color.
colorentry_t color;
GetBloodColor( data.m_nColor, color );
FX_BloodBulletImpact( vecPosition, data.m_vNormal, data.m_flScale, color.r, color.g, color.b );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::Detonate( void )
{
CBaseEntity *pVictim = GetOwnerEntity();
if ( !m_bDud && pVictim )
{
// Kill the strider (with magic effect)
CBasePlayer *pPlayer = AI_GetSinglePlayer();
CTakeDamageInfo info( pPlayer, this, RandomVector( -100.0f, 100.0f ), GetAbsOrigin(), pVictim->GetHealth(), DMG_GENERIC );
pVictim->TakeDamage( info );
gamestats->Event_WeaponHit( ToBasePlayer( pPlayer ), true, GetClassname(), info );
// Tracker 62293: There's a bug where the inflictor/attacker are reversed when calling TakeDamage above so the player never gets
// credit for the strider buster kills. The code has a bunch of assumptions lower level, so it's safer to just fix it here by
// crediting a kill to the player directly.
gamestats->Event_PlayerKilledOther( pPlayer, pVictim, info );
}
m_OnDetonate.FireOutput( this, this );
// Explode
if ( !m_bDud )
{
CreateDestroyedEffect();
EmitSound( "Weapon_StriderBuster.Detonate" );
}
else
{
DispatchParticleEffect( "striderbuster_explode_dummy_core", GetAbsOrigin(), GetAbsAngles() );
EmitSound( "Weapon_StriderBuster.Dud_Detonate" );
}
// Go to bits!
Shatter( pVictim );
}
void PerformCustomEffects( const Vector &vecOrigin, trace_t &tr, const Vector &shotDir, int iMaterial, int iScale, int nFlags )
{
// Throw out the effect if any of these are true
if ( tr.surface.flags & (SURF_SKY|SURF_NODRAW|SURF_HINT|SURF_SKIP) )
return;
if ( cl_new_impact_effects.GetInt() )
{
PerformNewCustomEffects( vecOrigin, tr, shotDir, iMaterial, iScale, nFlags );
return;
}
bool bNoFlecks = !r_drawflecks.GetBool();
if ( !bNoFlecks )
{
bNoFlecks = ( ( nFlags & FLAGS_CUSTIOM_EFFECTS_NOFLECKS ) != 0 );
}
// Cement and wood have dust and flecks
if ( ( iMaterial == CHAR_TEX_CONCRETE ) || ( iMaterial == CHAR_TEX_TILE ) )
{
FX_DebrisFlecks( vecOrigin, &tr, iMaterial, iScale, bNoFlecks );
}
else if ( iMaterial == CHAR_TEX_WOOD )
{
FX_DebrisFlecks( vecOrigin, &tr, iMaterial, iScale, bNoFlecks );
}
else if ( ( iMaterial == CHAR_TEX_DIRT ) || ( iMaterial == CHAR_TEX_SAND ) )
{
FX_DustImpact( vecOrigin, &tr, iScale );
}
else if ( iMaterial == CHAR_TEX_ANTLION )
{
FX_AntlionImpact( vecOrigin, &tr );
}
else if ( ( iMaterial == CHAR_TEX_METAL ) || ( iMaterial == CHAR_TEX_VENT ) )
{
Vector reflect;
float dot = shotDir.Dot( tr.plane.normal );
reflect = shotDir + ( tr.plane.normal * ( dot*-2.0f ) );
reflect[0] += random->RandomFloat( -0.2f, 0.2f );
reflect[1] += random->RandomFloat( -0.2f, 0.2f );
reflect[2] += random->RandomFloat( -0.2f, 0.2f );
FX_MetalSpark( vecOrigin, reflect, tr.plane.normal, iScale );
}
else if ( iMaterial == CHAR_TEX_COMPUTER )
{
Vector offset = vecOrigin + ( tr.plane.normal * 1.0f );
g_pEffects->Sparks( offset );
}
else if ( iMaterial == CHAR_TEX_WARPSHIELD )
{
QAngle vecAngles;
VectorAngles( -shotDir, vecAngles );
DispatchParticleEffect( "warp_shield_impact", vecOrigin, vecAngles );
}
}
void Particle_Test_Start( CBasePlayer* pPlayer, const char *name, bool bStart )
{
if ( !pPlayer )
return;
int iAttachType = GetAttachTypeFromString( particle_test_attach_mode.GetString() );
if ( iAttachType < 0 )
{
Warning( "Invalid attach type specified for particle_test in cvar 'particle_test_attach_mode.\n" );
return;
}
int iAttachmentIndex = particle_test_attach_attachment.GetInt();
const char *pszParticleFile = particle_test_file.GetString();
CBaseEntity *pEntity = NULL;
while ( (pEntity = GetNextCommandEntity( pPlayer, name, pEntity )) != NULL )
{
/*
Fire the test particle system on this entity
*/
DispatchParticleEffect(
pszParticleFile,
(ParticleAttachment_t)iAttachType,
pEntity,
iAttachmentIndex,
true ); // stops existing particle systems
}
}
void CASW_Boomer_Blob::DoExplosion( )
{
// scorch the ground
trace_t tr;
UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, -80 ), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr);
if ( m_bMaster )
{
if ( ( tr.m_pEnt != GetWorldEntity() ) || ( tr.hitbox != 0 ) )
{
// non-world needs smaller decals
if( tr.m_pEnt && !tr.m_pEnt->IsNPC() )
{
UTIL_DecalTrace( &tr, "SmallScorch" );
}
}
else
{
UTIL_DecalTrace( &tr, "Scorch" );
}
UTIL_ASW_ScreenShake( GetAbsOrigin(), 7.0f, 45.0f, 0.5f, 150, SHAKE_START );
}
// explosion effects
DispatchParticleEffect( "boomer_drop_explosion", GetAbsOrigin(), Vector( m_DmgRadius, 0.0f, 0.0f ), QAngle( 0.0f, 0.0f, 0.0f ) );
EmitSound( "ASW_Boomer_Grenade.Explode" );
// damage to nearby things
ASWGameRules()->RadiusDamage( CTakeDamageInfo( this, m_hFirer.Get(), m_flDamage, DMG_BLAST ), GetAbsOrigin(), m_DmgRadius, CLASS_NONE, NULL );
}
void CASW_Grenade_PRifle::CreateEffects( void )
{
CEffectData data;
data.m_vOrigin = GetAbsOrigin();
CPASFilter filter( data.m_vOrigin );
filter.SetIgnorePredictionCull(true);
DispatchParticleEffect( "prifle_grenade_fx", PATTACH_ABSORIGIN_FOLLOW, this, "fuse", false, -1, &filter );
/*
int nAttachment = LookupAttachment( "fuse" );
m_pGlowTrail = CSpriteTrail::SpriteTrailCreate( "sprites/bluelaser1.vmt", GetLocalOrigin(), false );
if ( m_pGlowTrail != NULL )
{
m_pGlowTrail->FollowEntity( this );
m_pGlowTrail->SetAttachment( this, nAttachment );
m_pGlowTrail->SetTransparency( kRenderTransAdd, 255, 255, 255, asw_grentrail_brightness.GetInt(), kRenderFxNone );
m_pGlowTrail->SetStartWidth( asw_grentrail_width.GetFloat() );
m_pGlowTrail->SetEndWidth( asw_grentrail_widthend.GetFloat() );
m_pGlowTrail->SetLifeTime( asw_grentrail_lifetime.GetFloat() );
m_pGlowTrail->SetMinFadeLength(asw_grentrail_fade.GetFloat());
}
*/
}
void CWeaponDrainGrenade::Explode( CBaseCombatCharacter* pAttacker,
CBaseEntity* pInflictor,
CBaseEntity* pIgnore,
Vector vecPosition,
float flDamage,
float flRadius,
float flDrainFocus )
{
#if !defined( CLIENT_DLL )
//CSoundEnt::InsertSound ( SOUND_COMBAT, vecPosition, 1024, 3.0 );
CTakeDamageInfo info;
info.CFSet( pInflictor, pAttacker, vec3_origin, vecPosition, flDamage, DMG_BLAST, WEAPON_NONE, &vecPosition, false );
info.SetDrainFocus( flDrainFocus );
DispatchParticleEffect("grenade_explosion", vecPosition, vec3_angle, pIgnore);
//TODO: Figure out sound.
CPASAttenuationFilter filter( this );
filter.UsePredictionRules();
EmitSound( filter, entindex(), "Numen.FireAoE" );
//CSoundEnt::InsertSound ( SOUND_COMBAT, GetAbsOrigin(), BASEGRENADE_EXPLOSION_VOLUME, 3.0 );
RadiusDamage( info, vecPosition, flRadius );
#endif //!defined( CLIENT_DLL )
}
void CC_DispatchParticle( const CCommand& args )
{
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
if ( !pLocalPlayer )
return;
if ( args.ArgC() < 2 )
{
DevMsg( "Use: dispatch_particle {particle_name} {surface_offset_distance}\n" );
return;
}
float flSurfaceOffsetDistance = 0.f;
if ( args.ArgC() == 3 )
{
flSurfaceOffsetDistance = atof( args[2] );
}
Vector vForward;
pLocalPlayer->GetVectors( &vForward, NULL, NULL );
trace_t tr;
UTIL_TraceLine( pLocalPlayer->EyePosition(), pLocalPlayer->EyePosition() + vForward * 3000, MASK_SOLID_BRUSHONLY, NULL, &tr );
Vector vTargetDeathPos = tr.endpos;
DispatchParticleEffect( args[1], vTargetDeathPos + flSurfaceOffsetDistance * tr.plane.normal, vec3_angle );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
//-----------------------------------------------------------------------------
void CGrubNugget::Event_Killed( const CTakeDamageInfo &info )
{
AddEffects( EF_NODRAW );
DispatchParticleEffect( "antlion_spit_player", GetAbsOrigin(), QAngle( -90, 0, 0 ) );
EmitSound( "NPC_Antlion_Grub.Explode" );
BaseClass::Event_Killed( info );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
// &vecDir -
// *ptr -
//-----------------------------------------------------------------------------
void CAntlionGrub::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
{
QAngle vecAngles;
VectorAngles( -vecDir, vecAngles );
DispatchParticleEffect( "GrubBlood", ptr->endpos, vecAngles );
BaseClass::TraceAttack( info, vecDir, ptr );
}
void CASW_Boomer_Blob::CheckNearbyTargets( )
{
// see if an alien is nearby
if ( gpGlobals->curtime >= m_fEarliestAOEDetonationTime )
{
if ( !m_bModelOpening && gpGlobals->curtime >= (m_fDetonateTime - ASW_BOOMER_WARN_DELAY) )
{
// we are one second from detonating, commit to detonating and start the opening sequence
// regardless of anyone nearby
m_bModelOpening = true;
ResetSequence( LookupSequence( "MortarBugProjectile_Opening" ) );
CEffectData data;
data.m_vOrigin = GetAbsOrigin();
CPASFilter filter( data.m_vOrigin );
filter.SetIgnorePredictionCull(true);
DispatchParticleEffect( "boomer_grenade_open", PATTACH_ABSORIGIN_FOLLOW, this, -1, false, -1, &filter );
}
// if we exceeded the detonation time, just detonate
if ( gpGlobals->curtime >= m_fDetonateTime )
{
Detonate();
return;
}
// if the model is opening, do the animation advance
if ( m_bModelOpening )
{
StudioFrameAdvance();
SetNextThink( gpGlobals->curtime );
return;
}
float flRadius = asw_boomer_blob_radius_check_scale.GetFloat() * m_DmgRadius;
Vector vecSrc = GetAbsOrigin();
CBaseEntity *pEntity = NULL;
for ( CEntitySphereQuery sphere( vecSrc, flRadius ); ( pEntity = sphere.GetCurrentEntity() ) != NULL; sphere.NextEntity() )
{
if ( !pEntity || !pEntity->IsPlayer() )
continue;
// give them a 2 second warning before detonation
m_fDetonateTime = MIN( m_fDetonateTime, m_fDetonateTime + ASW_BOOMER_WARN_DELAY );
}
}
if ( m_fDetonateTime <= gpGlobals->curtime + asw_boomer_blob_radius_check_interval.GetFloat() )
{
SetThink( &CASW_Boomer_Blob::Detonate );
SetNextThink( m_fDetonateTime );
}
else
{
SetThink( &CASW_Boomer_Blob::CheckNearbyTargets );
SetNextThink( gpGlobals->curtime + asw_boomer_blob_radius_check_interval.GetFloat() );
}
}
void CASW_Boomer_Blob::CreateEffects()
{
CEffectData data;
data.m_vOrigin = GetAbsOrigin();
CPASFilter filter( data.m_vOrigin );
filter.SetIgnorePredictionCull(true);
DispatchParticleEffect( "boomer_projectile_main_trail", PATTACH_ABSORIGIN_FOLLOW, this, -1, false, -1, &filter );
EmitSound( "ASW_Boomer_Projectile.Spawned" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGERocket::CreateSmokeTrail( void )
{
const CBaseEntity *host = te->GetSuppressHost();
te->SetSuppressHost( NULL );
DispatchParticleEffect( "ge_rocket_trail", PATTACH_POINT_FOLLOW, this, "smoke" );
te->SetSuppressHost( (CBaseEntity*)host );
}
void PhysFrictionEffect( Vector &vecPos, Vector vecVel, float energy, int surfaceProps, int surfacePropsHit )
{
QAngle angDirection;
VectorAngles( vecVel, angDirection );
surfacedata_t *psurf = physprops->GetSurfaceData( surfaceProps );
surfacedata_t *phit = physprops->GetSurfaceData( surfacePropsHit );
switch ( phit->game.material )
{
case CHAR_TEX_DIRT:
if ( energy < MASS10_SPEED2ENERGY(15) )
break;
DispatchParticleEffect( "impact_physics_dust", vecPos, angDirection );
break;
case CHAR_TEX_CONCRETE:
if ( energy < MASS10_SPEED2ENERGY(28) )
break;
DispatchParticleEffect( "impact_physics_dust", vecPos, angDirection );
break;
}
//Metal sparks
if ( energy > MASS10_SPEED2ENERGY(50) )
{
// make sparks for metal/concrete scrapes with enough energy
if ( psurf->game.material == CHAR_TEX_METAL || psurf->game.material == CHAR_TEX_GRATE )
{
switch ( phit->game.material )
{
case CHAR_TEX_CONCRETE:
case CHAR_TEX_METAL:
DispatchParticleEffect( "impact_physics_sparks", vecPos, angDirection );
break;
}
}
}
}
void CASW_Weapon_Electrified_Armor::PrimaryAttack( void )
{
if ( !ASWGameRules() )
return;
CASW_Marine *pMarine = GetMarine();
if ( !pMarine || pMarine->IsElectrifiedArmorActive() )
return;
#ifndef CLIENT_DLL
bool bThisActive = (pMarine->GetActiveASWWeapon() == this);
#endif
// sets the animation on the marine holding this weapon
//pMarine->SetAnimation( PLAYER_ATTACK1 );
#ifndef CLIENT_DLL
float flDuration = asw_electrified_armor_duration.GetFloat();
pMarine->AddElectrifiedArmor( flDuration );
// stun aliens within the radius
ASWGameRules()->ShockNearbyAliens( pMarine, this );
// CTakeDamageInfo info( this, GetOwnerEntity(), 5, DMG_SHOCK );
// info.SetDamageCustom( DAMAGE_FLAG_NO_FALLOFF );
// RadiusDamage( info, GetAbsOrigin(), flRadius, CLASS_ASW_MARINE, NULL );
DispatchParticleEffect( "electrified_armor_burst", pMarine->GetAbsOrigin(), QAngle( 0, 0, 0 ) );
// count as a shot fired
if ( pMarine->GetMarineResource() )
{
pMarine->GetMarineResource()->UsedWeapon( this , 1 );
pMarine->OnWeaponFired( this, 1 );
}
#endif
// decrement ammo
m_iClip1 -= 1;
m_flNextPrimaryAttack = gpGlobals->curtime + 4.0f;
if (!m_iClip1 && pMarine->GetAmmoCount(m_iPrimaryAmmoType) <= 0)
{
// weapon is lost when all stims are gone
#ifndef CLIENT_DLL
if (pMarine)
{
pMarine->Weapon_Detach(this);
if (bThisActive)
pMarine->SwitchToNextBestWeapon(NULL);
}
Kill();
#endif
}
}
void Particle_Test_Stop( CBasePlayer* pPlayer, const char *name, bool bStart )
{
if ( !pPlayer )
return;
CBaseEntity *pEntity = NULL;
while ( (pEntity = GetNextCommandEntity( pPlayer, name, pEntity )) != NULL )
{
//Stop all particle systems on the selected entity
DispatchParticleEffect( "", PATTACH_ABSORIGIN, pEntity, 0, true );
}
}
//-----------------------------------------------------------------------------
// Fling the buster with the physcannon either via punt or launch.
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::Launch( CBasePlayer *pPhysGunUser )
{
if ( !HasSpawnFlags( SF_DONT_WEAPON_MANAGE ) )
{
WeaponManager_RemoveManaged( this );
}
m_bLaunched = true;
// Notify all nearby hunters that we were launched.
Hunter_StriderBusterLaunched( this );
// Start up the eye glow
m_hMainGlow = CSprite::SpriteCreate( "sprites/blueglow1.vmt", GetLocalOrigin(), false );
if ( m_hMainGlow != NULL )
{
m_hMainGlow->FollowEntity( this );
m_hMainGlow->SetTransparency( kRenderGlow, 255, 255, 255, 140, kRenderFxNoDissipation );
m_hMainGlow->SetScale( 2.0f );
m_hMainGlow->SetGlowProxySize( 8.0f );
}
if ( !m_bNoseDiving )
{
DispatchParticleEffect( "striderbuster_trail", PATTACH_ABSORIGIN_FOLLOW, this );
}
else
{
DispatchParticleEffect( "striderbuster_shotdown_trail", PATTACH_ABSORIGIN_FOLLOW, this );
}
// We get our touch function from the physics system
SetTouch ( &CWeaponStriderBuster::BusterTouch );
SetThink( &CWeaponStriderBuster::BusterFlyThink );
SetNextThink( gpGlobals->curtime );
gamestats->Event_WeaponFired( pPhysGunUser, true, GetClassname() );
}
void CASW_Rocket::DoExplosion( bool bHitWall )
{
Vector vecExplosionPos = GetAbsOrigin();
CPASFilter filter( vecExplosionPos );
EmitSound( m_szDetonationSound );
DispatchParticleEffect( "explosion_air_small", GetAbsOrigin(), vec3_angle );
CTakeDamageInfo info( this, GetOwnerEntity(), GetDamage(), DMG_BLAST );
info.SetWeapon( m_hCreatorWeapon );
ASWGameRules()->RadiusDamage( info, GetAbsOrigin(), 50, CLASS_NONE, NULL );
}
void CWeaponUzi::PrimaryAttack( void )
{
BaseClass::PrimaryAttack();
m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
//BP muzzlefash de la mort
/*Vector vecShootOrigin;
QAngle angShootDir;
GetAttachment(LookupAttachment("muzzle"), vecShootOrigin, angShootDir);
DispatchParticleEffect("muzzleflash_final_uzi", vecShootOrigin, angShootDir);*/
/*if(!GetOwner()->IsAlive())
ToBasePlayer( GetOwner() )->DoMuzzleFlash();*/
#define EASY_DAMPEN 0.5f
#define MAX_VERTICAL_KICK 1.0f //Degrees
#define SLIDE_LIMIT 2.0f //Seconds
//Get the view kick
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
if ( pPlayer == NULL )
return;
//pPlayer->DoMuzzleFlash();
Vector vForward, vRight, vUp;
pPlayer->EyeVectors( &vForward, &vRight, &vUp );
Vector vecShootOrigin;
QAngle angShootDir;
GetAttachment(LookupAttachment("muzzle"), vecShootOrigin, angShootDir);
#ifdef CLIENT_DLL
Vector muzzlePoint = pPlayer->Weapon_ShootPosition() + vForward * 18.0f + vRight * 6.0f + vUp * -3.0f;
#else
Vector muzzlePoint = vecShootOrigin;
#endif
DispatchParticleEffect("muzzleflash_final_uzi", muzzlePoint, angShootDir);
#ifdef CLIENT_DLL
dlight_t *el = effects->CL_AllocDlight( LIGHT_INDEX_MUZZLEFLASH + index );
el->origin = muzzlePoint;
el->radius = random->RandomInt( 32, 64 );
el->decay = el->radius / 0.05f;
el->die = gpGlobals->curtime + 0.2f;
el->color.r = 255;
el->color.g = 192;
el->color.b = 64;
el->color.exponent = 5;
#endif
DoMachineGunKick( pPlayer, EASY_DAMPEN, MAX_VERTICAL_KICK, m_fFireDuration, SLIDE_LIMIT );
}
float CNPC_PoisonZombie::GetHitgroupDamageMultiplier(int iHitGroup, const CTakeDamageInfo &info)
{
switch (iHitGroup)
{
case HITGROUP_HEAD:
{
int HeadshotRandom = random->RandomInt(0, 6);
if (!(g_Language.GetInt() == LANGUAGE_GERMAN || UTIL_IsLowViolence()))
{
if (!m_fIsHeadless && HeadshotRandom == 0 && !(info.GetDamageType() & DMG_NEVERGIB) || !m_fIsHeadless && info.GetDamageType() & DMG_SNIPER && !(info.GetDamageType() & DMG_NEVERGIB))
{
DispatchParticleEffect("headshotspray_zombie", PATTACH_POINT_FOLLOW, this, "headcrab1", true);
CGib::SpawnSpecificGibs(this, 3, 750, 1500, "models/gibs/agib_p3.mdl", 6);
CGib::SpawnSpecificGibs(this, 3, 750, 1500, "models/gibs/agib_p4.mdl", 6);
EmitSound("Gore.Headshot");
RemoveHead();
}
else
{
return 2.0f;
}
}
else
{
if (info.GetDamageType() & DMG_BUCKSHOT)
{
float flDist = FLT_MAX;
if (info.GetAttacker())
{
flDist = (GetAbsOrigin() - info.GetAttacker()->GetAbsOrigin()).Length();
}
if (flDist <= POISONZOMBIE_BUCKSHOT_TRIPLE_DAMAGE_DIST)
{
return 3.0f;
}
}
else
{
return 2.0f;
}
}
}
}
return BaseClass::GetHitgroupDamageMultiplier(iHitGroup, info);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void DispatchParticleEffect( const char *pszParticleName, ParticleAttachment_t iAttachType, CBaseEntity *pEntity, const char *pszAttachmentName, bool bResetAllParticlesOnEntity )
{
int iAttachment = -1;
if ( pEntity && pEntity->GetBaseAnimating() )
{
// Find the attachment point index
iAttachment = pEntity->GetBaseAnimating()->LookupAttachment( pszAttachmentName );
if ( iAttachment <= 0 )
{
Warning("Model '%s' doesn't have attachment '%s' to attach particle system '%s' to.\n", STRING(pEntity->GetBaseAnimating()->GetModelName()), pszAttachmentName, pszParticleName );
return;
}
}
DispatchParticleEffect( pszParticleName, iAttachType, pEntity, iAttachment, bResetAllParticlesOnEntity );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float CNPC_CombineS::GetHitgroupDamageMultiplier( int iHitGroup, const CTakeDamageInfo &info )
{
bool isNohead = false;
switch( iHitGroup )
{
case HITGROUP_HEAD:
int HeadshotRandom = random->RandomInt(0, 4);
if (!(g_Language.GetInt() == LANGUAGE_GERMAN || UTIL_IsLowViolence()) && g_fr_headshotgore.GetBool())
{
if (isNohead == false && HeadshotRandom == 0 && !(info.GetDamageType() & DMG_NEVERGIB) || isNohead == false && (info.GetDamageType() & (DMG_SNIPER | DMG_BUCKSHOT)) && !(info.GetDamageType() & DMG_NEVERGIB))
{
SetModel("models/gibs/combine_soldier_beheaded.mdl");
DispatchParticleEffect("headshotspray", PATTACH_POINT_FOLLOW, this, "bloodspurt", true);
SpawnBlood(GetAbsOrigin(), g_vecAttackDir, BloodColor(), info.GetDamage());
CGib::SpawnSpecificGibs(this, 6, 750, 1500, "models/gibs/pgib_p3.mdl", 6);
CGib::SpawnSpecificGibs(this, 6, 750, 1500, "models/gibs/pgib_p4.mdl", 6);
EmitSound("Gore.Headshot");
m_iHealth = 0;
g_pGameRules->iHeadshotCount += 1;
isNohead = true;
CBasePlayer *pPlayer = UTIL_PlayerByIndex(1);
if (g_fr_economy.GetBool())
{
pPlayer->AddMoney(5);
}
if (!g_fr_classic.GetBool())
{
pPlayer->AddXP(7);
}
}
else
{
// Soldiers take double headshot damage
return 2.0f;
}
}
else
{
// Soldiers take double headshot damage
return 2.0f;
}
}
return BaseClass::GetHitgroupDamageMultiplier( iHitGroup, info );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponSMG1::FireNPCPrimaryAttack( CBaseCombatCharacter *pOperator, Vector &vecShootOrigin, Vector &vecShootDir )
{
Vector vecShootOrigin2; //The origin of the shot
QAngle angShootDir2; //The angle of the shot
//We need to figure out where to place the particle effect, so lookup where the muzzle is
GetAttachment( LookupAttachment( "muzzle" ), vecShootOrigin2, angShootDir2 );
// FIXME: use the returned number of bullets to account for >10hz firerate
WeaponSoundRealtime( SINGLE_NPC );
CSoundEnt::InsertSound( SOUND_COMBAT|SOUND_CONTEXT_GUNFIRE, pOperator->GetAbsOrigin(), SOUNDENT_VOLUME_MACHINEGUN, 0.2, pOperator, SOUNDENT_CHANNEL_WEAPON, pOperator->GetEnemy() );
pOperator->FireBullets( 1, vecShootOrigin, vecShootDir, VECTOR_CONE_PRECALCULATED,
MAX_TRACE_LENGTH, m_iPrimaryAmmoType, 2, entindex(), 0 );
//pOperator->DoMuzzleFlash();
DispatchParticleEffect( "muzzle_smg1", vecShootOrigin2, angShootDir2);
m_iClip1 = m_iClip1 - 1;
}
void CBaseGrenadeProjectile::Explode( trace_t *pTrace, int bitsDamageType )
{
SetModelName( NULL_STRING );//invisible
AddSolidFlags( FSOLID_NOT_SOLID );
m_takedamage = DAMAGE_NO;
// Pull out of the wall a bit
if ( pTrace->fraction != 1.0 )
{
SetAbsOrigin( pTrace->endpos + (pTrace->plane.normal * 0.6) );
}
Vector vecAbsOrigin = GetAbsOrigin();
// Since this code only runs on the server, make sure it shows the tempents it creates.
// This solves a problem with remote detonating the pipebombs (client wasn't seeing the explosion effect)
CDisablePredictionFiltering disabler;
DispatchParticleEffect("grenade_exp1", vecAbsOrigin, QAngle(0, 0, 0));
CSoundEnt::InsertSound ( SOUND_COMBAT, vecAbsOrigin, BASEGRENADE_EXPLOSION_VOLUME, 3.0 );
// Use the thrower's position as the reported position
Vector vecReported = GetThrower() ? GetThrower()->GetAbsOrigin() : vec3_origin;
CTakeDamageInfo info( this, GetThrower(), GetBlastForce(), vecAbsOrigin, m_flDamage, bitsDamageType, 0, &vecReported );
RadiusDamage( info, vecAbsOrigin, m_DmgRadius, CLASS_NONE, NULL );
UTIL_DecalTrace( pTrace, "Scorch" );
EmitSound( "BaseGrenade.Explode" );
SetThink( &CBaseGrenade::SUB_Remove );
SetTouch( NULL );
SetSolid( SOLID_NONE );
AddEffects( EF_NODRAW );
SetAbsVelocity( vec3_origin );
SetNextThink( gpGlobals->curtime );
}
void CWeaponSMG1::PrimaryAttack( void )
{
if ( ( gpGlobals->curtime - .5f ) > m_flLastAttackTime )
{
m_nShotsFired = 1;
}
if ( m_nShotsFired == 15 )
{
m_nShotsFired = 1;
CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
if( pOwner )
{
DispatchParticleEffect("weapon_muzzle_smoke_long", PATTACH_POINT_FOLLOW, pOwner->GetViewModel(), "muzzle", true);
}
}
BaseClass::PrimaryAttack();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::BusterDetachThink()
{
SetNextThink( gpGlobals->curtime + 0.1f );
trace_t tr;
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector( 0, 0, 1200), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
if( fabs(tr.startpos.z - tr.endpos.z) < 240.0f )
{
SetThink(NULL);
EmitSound( "Weapon_StriderBuster.Dud_Detonate" );
DispatchParticleEffect( "striderbuster_break_flechette", GetAbsOrigin(), GetAbsAngles() );
SetHealth( 0 );
CTakeDamageInfo info;
info.SetDamage( 1.0f );
info.SetAttacker( this );
info.SetInflictor( this );
Shatter(this);
}
}