Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1176 lines
39 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// An ingenious device. We call it "The Magnusson Device". Not my chosen label,
// you understand, but it seemed to please the personnel.
//
// From your point of view you simply throw it at a strider and then blow it up.
//
//=============================================================================
#include "cbase.h"
#include "props.h"
#include "vphysics/constraints.h"
#include "physics_saverestore.h"
#include "model_types.h"
#include "ai_utils.h"
#include "particle_system.h"
#include "Sprite.h"
#include "citadel_effects_shared.h"
#include "soundent.h"
#include "SpriteTrail.h"
#include "te_effect_dispatch.h"
#include "beam_shared.h"
#include "npc_strider.h"
#include "npc_hunter.h"
#include "particle_parse.h"
#include "gameweaponmanager.h"
#include "gamestats.h"
extern ConVar hunter_hate_held_striderbusters;
extern ConVar hunter_hate_thrown_striderbusters;
extern ConVar hunter_hate_attached_striderbusters;
ConVar striderbuster_health( "striderbuster_health", "14" );
ConVar striderbuster_autoaim_radius( "striderbuster_autoaim_radius", "64.0f" );
ConVar striderbuster_shot_velocity( "striderbuster_shot_velocity", "2500.0", FCVAR_NONE, "Speed at which launch the bomb from the physcannon" );
ConVar striderbuster_allow_all_damage( "striderbuster_allow_all_damage", "0", FCVAR_NONE, "If set to '1' the bomb will detonate on any damage taken. Otherwise only the player may trigger it." );
//ConVar striderbuster_magnetic_radius("striderbuster_magnetic_radius","400.0f", FCVAR_NONE,"Maximum distance at which magnade experiences attraction to a target. Set to 0 to disable magnetism.");
ConVar striderbuster_magnetic_force_strider("striderbuster_magnetic_force_strider", "750000.0f", FCVAR_NONE,"Intensity of magnade's attraction to a strider.");
ConVar striderbuster_magnetic_force_hunter("striderbuster_magnetic_force_hunter","1750000.0f",FCVAR_NONE,"Intensity of magnade's attraction to a hunter.");
ConVar striderbuster_falloff_power("striderbuster_falloff_power","4",FCVAR_NONE,"Order of the distance falloff. 1 = linear 2 = quadratic");
ConVar striderbuster_leg_stick_dist( "striderbuster_leg_stick_dist", "80.0", FCVAR_NONE, "If the buster hits a strider's leg, the max distance from the head at which it sticks anyway." );
ConVar striderbuster_debugseek( "striderbuster_debugseek", "0" );
ConVar sk_striderbuster_magnet_multiplier( "sk_striderbuster_magnet_multiplier", "2.25" );
ConVar striderbuster_die_detach( "striderbuster_die_detach", "1" ); // Drop off the strider if a hunter shoots me. (Instead of exploding)
ConVar striderbuster_dive_force( "striderbuster_dive_force", "-200" ); // How much force to apply to a nosediving (dead in the air) striderbuster
ConVar striderbuster_use_particle_flare( "striderbuster_use_particle_flare", "1" );
#define STRIDERBUSTER_FLAG_KNOCKED_OFF_STRIDER 0x00000001 // We were knocked off of a strider after the player attached me.
#define SF_DONT_WEAPON_MANAGE 0x800000
#define STRIDERBUSTER_SPRITE_TRAIL "sprites/bluelaser1.vmt"
string_t g_iszVehicle;
#define BUSTER_PING_SOUND_FREQ 3.0f // How often (seconds) to issue the ping sound to remind players we are attached
static const char *s_pBusterPingThinkContext = "BusterPing";
class CWeaponStriderBuster : public CPhysicsProp
{
DECLARE_CLASS( CWeaponStriderBuster, CPhysicsProp );
DECLARE_DATADESC();
public:
CWeaponStriderBuster( void );
virtual void Precache( void );
virtual void Spawn( void );
virtual void Activate( void );
// Treat as a live target so hunters can attack us
virtual bool IsAlive() { return true; }
virtual void OnRestore( void );
virtual void VPhysicsCollision( int index, gamevcollisionevent_t *pEvent );
virtual void UpdateOnRemove( void );
virtual int OnTakeDamage( const CTakeDamageInfo &info );
virtual bool ShouldPuntUseLaunchForces( PhysGunForce_t reason ) { return ( reason == PHYSGUN_FORCE_LAUNCHED ); }
virtual QAngle PreferredCarryAngles( void ) { return m_CarryAngles; }
virtual bool HasPreferredCarryAnglesForPlayer( CBasePlayer *pPlayer ) { return true; }
virtual void OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason );
virtual void OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason );
virtual Vector PhysGunLaunchVelocity( const Vector &forward, float flMass );
virtual float GetAutoAimRadius( void ) { return striderbuster_autoaim_radius.GetFloat(); }
virtual void BusterTouch( CBaseEntity *pOther );
virtual bool ShouldAttractAutoAim( CBaseEntity *pAimingEnt ) { return IsAttachedToStrider(); }
void InputConstraintBroken( inputdata_t &inputdata );
void BusterFlyThink();
void BusterDetachThink();
void BusterPingThink();
void OnAddToCargoHold();
void OnFlechetteAttach( Vector &vecForceDir );
int NumFlechettesAttached() { return m_nAttachedFlechettes; }
float GetPickupTime() { return m_PickupTime; }
int GetStriderBusterFlags() { return m_iBusterFlags; } // I added a flags field so we don't have to keep added bools for all of these contingencies (sjb)
private:
void Launch( CBasePlayer *pPhysGunUser );
void Detonate( void );
void Shatter( CBaseEntity *pAttacker );
bool StickToEntity( CBaseEntity *pOther );
bool CreateConstraintToObject( CBaseEntity *pObject );
void DestroyConstraint( void );
bool ShouldStickToEntity( CBaseEntity *pEntity );
void CreateDestroyedEffect( void );
inline bool IsAttachedToStrider( void ) const;
bool m_bDud;
bool m_bLaunched;
bool m_bNoseDiving; // No magnetism, nosedive and break. Hunter flechettes set this.
int m_nAttachedFlechettes;
float m_flCollisionSpeedSqr;
int m_nAttachedBoneFollowerIndex;
float m_PickupTime;
IPhysicsConstraint *m_pConstraint;
EHANDLE m_hConstrainedEntity;
CHandle<CSprite> m_hGlowSprite;
CHandle<CSprite> m_hMainGlow;
//CHandle<CParticleSystem> m_hGlowTrail;
EHANDLE m_hParticleEffect;
int m_nRingTexture;
QAngle m_CarryAngles;
int m_iBusterFlags;
COutputEvent m_OnAttachToStrider;
COutputEvent m_OnDetonate;
COutputEvent m_OnShatter;
COutputEvent m_OnShotDown;
friend bool StriderBuster_IsAttachedStriderBuster( CBaseEntity *pEntity, CBaseEntity * );
};
LINK_ENTITY_TO_CLASS( prop_stickybomb, CWeaponStriderBuster );
LINK_ENTITY_TO_CLASS( weapon_striderbuster, CWeaponStriderBuster );
BEGIN_DATADESC( CWeaponStriderBuster )
DEFINE_KEYFIELD( m_bDud, FIELD_BOOLEAN, "dud" ),
DEFINE_FIELD( m_bLaunched, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bNoseDiving, FIELD_BOOLEAN ),
DEFINE_FIELD( m_nAttachedFlechettes, FIELD_INTEGER ),
DEFINE_FIELD( m_flCollisionSpeedSqr, FIELD_FLOAT ),
DEFINE_FIELD( m_hConstrainedEntity, FIELD_EHANDLE ),
DEFINE_FIELD( m_hGlowSprite, FIELD_EHANDLE ),
DEFINE_FIELD( m_hMainGlow, FIELD_EHANDLE ),
//DEFINE_FIELD( m_hGlowTrail, FIELD_EHANDLE ),
DEFINE_FIELD( m_nRingTexture, FIELD_INTEGER ),
DEFINE_FIELD( m_nAttachedBoneFollowerIndex, FIELD_INTEGER ),
DEFINE_FIELD( m_PickupTime, FIELD_TIME ),
DEFINE_FIELD( m_hParticleEffect, FIELD_EHANDLE ),
DEFINE_FIELD( m_CarryAngles, FIELD_VECTOR ),
DEFINE_FIELD( m_iBusterFlags, FIELD_INTEGER ),
DEFINE_PHYSPTR( m_pConstraint ),
DEFINE_INPUTFUNC( FIELD_VOID, "ConstraintBroken", InputConstraintBroken ),
DEFINE_OUTPUT( m_OnAttachToStrider, "OnAttachToStrider" ),
DEFINE_OUTPUT( m_OnDetonate, "OnDetonate" ),
DEFINE_OUTPUT( m_OnShatter, "OnShatter" ),
DEFINE_OUTPUT( m_OnShotDown, "OnShotDown" ),
DEFINE_ENTITYFUNC( BusterTouch ),
DEFINE_THINKFUNC( BusterFlyThink ),
DEFINE_THINKFUNC( BusterDetachThink ),
DEFINE_THINKFUNC( BusterPingThink ),
END_DATADESC()
CWeaponStriderBuster::CWeaponStriderBuster( void ) :
m_pConstraint( NULL ),
m_flCollisionSpeedSqr( -1.0f ),
m_hConstrainedEntity( NULL ),
m_nAttachedBoneFollowerIndex( -1 )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::Precache( void )
{
PrecacheScriptSound( "Weapon_StriderBuster.StickToEntity" );
PrecacheScriptSound( "Weapon_StriderBuster.Detonate" );
PrecacheScriptSound( "Weapon_StriderBuster.Dud_Detonate" );
PrecacheScriptSound( "Weapon_StriderBuster.Ping" );
PrecacheModel("sprites/orangeflare1.vmt");
UTIL_PrecacheOther( "env_citadel_energy_core" );
UTIL_PrecacheOther( "sparktrail" );
m_nRingTexture = PrecacheModel( "sprites/lgtning.vmt" );
PrecacheParticleSystem( "striderbuster_attach" );
PrecacheParticleSystem( "striderbuster_attached_pulse" );
PrecacheParticleSystem( "striderbuster_explode_core" );
PrecacheParticleSystem( "striderbuster_explode_dummy_core" );
PrecacheParticleSystem( "striderbuster_break_flechette" );
PrecacheParticleSystem( "striderbuster_trail" );
PrecacheParticleSystem( "striderbuster_shotdown_trail" );
PrecacheParticleSystem( "striderbuster_break" );
PrecacheParticleSystem( "striderbuster_flechette_attached" );
SetModelName( AllocPooledString("models/magnusson_device.mdl") );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::Spawn( void )
{
SetModelName( AllocPooledString("models/magnusson_device.mdl") );
BaseClass::Spawn();
// Setup for being shot by the player
m_takedamage = DAMAGE_EVENTS_ONLY;
// Ignore touches until launched.
SetTouch ( NULL );
AddFlag( FL_AIMTARGET|FL_OBJECT );
m_hParticleEffect = CreateEntityByName( "info_particle_system" );
if ( m_hParticleEffect )
{
m_hParticleEffect->KeyValue( "start_active", "1" );
m_hParticleEffect->KeyValue( "effect_name", "striderbuster_smoke" );
DispatchSpawn( m_hParticleEffect );
if ( gpGlobals->curtime > 0.2f )
{
m_hParticleEffect->Activate();
}
m_hParticleEffect->SetAbsOrigin( GetAbsOrigin() );
m_hParticleEffect->SetParent( this );
}
SetHealth( striderbuster_health.GetFloat() );
SetNextThink(gpGlobals->curtime + 0.01f);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::Activate( void )
{
g_iszVehicle = AllocPooledString( "prop_vehicle_jeep" );
BaseClass::Activate();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::OnRestore( void )
{
BaseClass::OnRestore();
// If we have an entity we're attached to, attempt to reconstruct our bone follower setup
if ( m_hConstrainedEntity != NULL )
{
CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(m_hConstrainedEntity.Get());
if ( pStrider != NULL )
{
// Make sure we've done this step or we'll have no controller to attach to
pStrider->InitBoneFollowers();
// Attempt to make a connection to the same bone follower we attached to previously
CBoneFollower *pBoneFollower = pStrider->GetBoneFollowerByIndex( m_nAttachedBoneFollowerIndex );
if ( CreateConstraintToObject( pBoneFollower ) == false )
{
Msg( "Failed to reattach to bone follower %d\n", m_nAttachedBoneFollowerIndex );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::DestroyConstraint( void )
{
// Destroy the constraint
if ( m_pConstraint != NULL )
{
physenv->DestroyConstraint( m_pConstraint );
m_pConstraint = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Create a constraint between this object and another
// Input : *pObject - Object to constrain ourselves to
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponStriderBuster::CreateConstraintToObject( CBaseEntity *pObject )
{
if ( m_pConstraint != NULL )
{
// Should we destroy the constraint and make a new one at this point?
Assert( 0 );
return false;
}
if ( pObject == NULL )
return false;
IPhysicsObject *pPhysObject = pObject->VPhysicsGetObject();
if ( pPhysObject == NULL )
return false;
IPhysicsObject *pMyPhysObject = VPhysicsGetObject();
if ( pPhysObject == NULL )
return false;
// Create the fixed constraint
constraint_fixedparams_t fixedConstraint;
fixedConstraint.Defaults();
fixedConstraint.InitWithCurrentObjectState( pPhysObject, pMyPhysObject );
IPhysicsConstraint *pConstraint = physenv->CreateFixedConstraint( pPhysObject, pMyPhysObject, NULL, fixedConstraint );
if ( pConstraint == NULL )
return false;
// Hold on to us
m_pConstraint = pConstraint;
pConstraint->SetGameData( (void *)this );
m_hConstrainedEntity = pObject->GetOwnerEntity();;
// Disable collisions between the two ents
PhysDisableObjectCollisions( pPhysObject, pMyPhysObject );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Physics system has just told us our constraint has been broken
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::InputConstraintBroken( inputdata_t &inputdata )
{
// Shatter with no real explosion effect
Shatter( NULL );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::UpdateOnRemove( void )
{
DestroyConstraint();
if ( m_hGlowSprite != NULL )
{
m_hGlowSprite->FadeAndDie( 0.5f );
m_hGlowSprite = NULL;
}
if ( m_hParticleEffect )
{
UTIL_Remove( m_hParticleEffect );
}
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponStriderBuster::ShouldStickToEntity( CBaseEntity *pEntity )
{
if ( pEntity == NULL )
return false;
// Must have a follow parent
CBaseEntity *pFollowParent = pEntity->GetOwnerEntity();
if ( pFollowParent == NULL )
return false;
// Must be a strider
CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(pFollowParent);
if ( pStrider == NULL )
return false;
if( m_bNoseDiving )
return false;
// Don't attach to legs
CBoneFollower *pFollower = static_cast<CBoneFollower *>(pEntity);
if ( pStrider->IsLegBoneFollower( pFollower ) )
{
Vector vecDelta = pStrider->GetAdjustedOrigin() - GetAbsOrigin();
if ( vecDelta.Length() > striderbuster_leg_stick_dist.GetFloat() )
{
return false;
}
}
// Ick, this is kind of ugly, but it's also ugly having to pass pointer into this to avoid multiple castings!
// Save this to patch up save/restore later
m_nAttachedBoneFollowerIndex = pStrider->GetBoneFollowerIndex( pFollower );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Stick to an entity (using hierarchy if we can)
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CWeaponStriderBuster::StickToEntity( CBaseEntity *pOther )
{
// Make sure the object is travelling fast enough to stick
if ( m_flCollisionSpeedSqr > 50 && !m_bNoseDiving )
{
// See if this is a valid strider bit
if ( ShouldStickToEntity( pOther ) )
{
// Attempt to constraint to it
if ( CreateConstraintToObject( pOther ) )
{
// Only works for striders, at the moment
CBaseEntity *pFollowParent = pOther->GetOwnerEntity();
if ( pFollowParent == NULL )
return false;
// Allows us to identify our constrained object later
SetOwnerEntity( pFollowParent );
// Make a sound
EmitSound( "Weapon_StriderBuster.StickToEntity" );
DispatchParticleEffect( "striderbuster_attach", GetAbsOrigin(), GetAbsAngles(), NULL );
if( striderbuster_use_particle_flare.GetBool() )
{
// We don't have to save any pointers or handles to this because it's parented to the buster.
// So it will die when the buster dies. Yay.
CParticleSystem *pFlare = (CParticleSystem *) CreateEntityByName( "info_particle_system" );
if ( pFlare != NULL )
{
pFlare->KeyValue( "start_active", "1" );
pFlare->KeyValue( "effect_name", "striderbuster_attached_pulse" );
pFlare->SetParent( this );
pFlare->SetLocalOrigin( vec3_origin );
DispatchSpawn( pFlare );
pFlare->Activate();
}
}
else
{
// Create a glow sprite
m_hGlowSprite = CSprite::SpriteCreate( "sprites/orangeflare1.vmt", GetLocalOrigin(), false );
Assert( m_hGlowSprite );
if ( m_hGlowSprite != NULL )
{
m_hGlowSprite->TurnOn();
m_hGlowSprite->SetTransparency( kRenderWorldGlow, 255, 255, 255, 255, kRenderFxNoDissipation );
m_hGlowSprite->SetAbsOrigin( GetAbsOrigin() );
m_hGlowSprite->SetScale( 5.0f );
m_hGlowSprite->m_nRenderFX = kRenderFxStrobeFaster;
m_hGlowSprite->SetGlowProxySize( 16.0f );
m_hGlowSprite->SetParent( this );
}
}
// Stop touching things
SetTouch( NULL );
// Must be a strider
CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(pFollowParent);
if ( pStrider == NULL )
return false;
// Notify the strider we're attaching to him
pStrider->StriderBusterAttached( this );
m_OnAttachToStrider.FireOutput( this, this );
// Start the ping sound.
SetContextThink( &CWeaponStriderBuster::BusterPingThink, gpGlobals->curtime + BUSTER_PING_SOUND_FREQ, s_pBusterPingThinkContext );
// Don't autodelete this one!
WeaponManager_RemoveManaged( this );
return true;
}
return false;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Create the explosion effect for the final big boom
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::CreateDestroyedEffect( void )
{
CBaseEntity *pTrail;
StopParticleEffects( this );
for ( int i = 0; i < 3; i++ )
{
pTrail = CreateEntityByName( "sparktrail" );
pTrail->SetOwnerEntity( this );
DispatchSpawn( pTrail );
}
DispatchParticleEffect( "striderbuster_explode_core", GetAbsOrigin(), GetAbsAngles() );
// Create liquid fountain gushtacular effect here!
CEffectData data;
int nNumSteps = 6;
float flRadStep = (2*M_PI) / nNumSteps;
for ( int i = 0; i < nNumSteps; i++ )
{
data.m_vOrigin = GetAbsOrigin() + RandomVector( -32.0f, 32.0f );
data.m_vNormal.x = cos( flRadStep*i );
data.m_vNormal.y = sin( flRadStep*i );
data.m_vNormal.z = 0.0f;
data.m_flScale = ( random->RandomInt( 0, 5 ) == 0 ) ? 1 : 2;
DispatchEffect( "StriderBlood", data );
}
// More effects
UTIL_ScreenShake( GetAbsOrigin(), 20.0f, 150.0, 1.0, 1250.0f, SHAKE_START );
data.m_vOrigin = GetAbsOrigin();
DispatchEffect( "cball_explode", data );
}
//-----------------------------------------------------------------------------
// Purpose: Handle a collision using our special behavior
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
// Find out what we hit.
// Don't do anything special if we're already attached to a strider.
CBaseEntity *pVictim = pEvent->pEntities[!index];
if ( pVictim == NULL || m_pConstraint != NULL )
{
BaseClass::VPhysicsCollision( index, pEvent );
return;
}
// Don't attach if we're being held by the player
if ( VPhysicsGetObject()->GetGameFlags() & FVPHYSICS_PLAYER_HELD )
{
BaseClass::VPhysicsCollision( index, pEvent );
return;
}
// Save off the speed of the object
m_flCollisionSpeedSqr = ( pEvent->preVelocity[ index ] ).LengthSqr();
// Break if we hit the world while going fast enough.
// Launched duds detonate if they hit the world at any speed.
if ( pVictim->IsWorld() && ( ( m_bDud && m_bLaunched ) || m_flCollisionSpeedSqr > Square( 500 ) ) )
{
m_OnShatter.FireOutput( this, this );
Shatter( pVictim );
return;
}
// We'll handle this later in our touch call
if ( ShouldStickToEntity( pVictim ) )
return;
// Determine if we should shatter
CBaseEntity *pOwnerEntity = pVictim->GetOwnerEntity();
bool bVictimIsStrider = ( ( pOwnerEntity != NULL ) && FClassnameIs( pOwnerEntity, "npc_strider" ) );
// Break if we hit anything other than a strider while going fast enough.
// Launched duds detonate if they hit anything other than a strider any speed.
if ( ( bVictimIsStrider == false ) && ( ( m_bDud && m_bLaunched ) || m_flCollisionSpeedSqr > Square( 500 ) ) )
{
m_OnShatter.FireOutput( this, this );
Shatter( pVictim );
return;
}
// Just bounce
BaseClass::VPhysicsCollision( index, pEvent );
}
//-----------------------------------------------------------------------------
// Purpose: Called to see if we should attach to the victim
// Input : *pOther - the victim
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::BusterTouch( CBaseEntity *pOther )
{
// Attempt to stick to the entity
StickToEntity( pOther );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
inline bool CWeaponStriderBuster::IsAttachedToStrider( void ) const
{
CBaseEntity *pAttachedEnt = GetOwnerEntity();
if ( pAttachedEnt && FClassnameIs( pAttachedEnt, "npc_strider" ) )
return true;
return false;
}
//-----------------------------------------------------------------------------
// 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 );
}
//-----------------------------------------------------------------------------
// Purpose: Intercept damage and decide whether or not we want to trigger
// Input : &info -
//-----------------------------------------------------------------------------
int CWeaponStriderBuster::OnTakeDamage( const CTakeDamageInfo &info )
{
// If we're attached, any damage from the player makes us trigger
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pAttacker = info.GetAttacker();
bool bInflictorIsPlayer = ( pInflictor != NULL && pInflictor->IsPlayer() );
bool bAttackerIsPlayer = ( pAttacker != NULL && pAttacker->IsPlayer() );
if ( GetParent() && GetParent()->ClassMatches( g_iszVehicle ) )
{
return 0;
}
// Only take damage from a player, for the moment
if ( striderbuster_allow_all_damage.GetBool() || ( IsAttachedToStrider() && ( bAttackerIsPlayer || bInflictorIsPlayer ) ) )
{
Detonate();
return 0;
}
if ( pAttacker && ( pAttacker->Classify() == CLASS_COMBINE || pAttacker->Classify() == CLASS_COMBINE_HUNTER ) )
{
if ( VPhysicsGetObject() && !VPhysicsGetObject()->IsMoveable() )
{
return 0;
}
}
// Hunters are able to destroy strider busters
if ( hunter_hate_held_striderbusters.GetBool() || hunter_hate_thrown_striderbusters.GetBool() || hunter_hate_attached_striderbusters.GetBool() )
{
if ( ( GetHealth() > 0 ) && ( pInflictor != NULL ) && FClassnameIs( pInflictor, "hunter_flechette" ) )
{
//
// Flechette impacts don't hurt the striderbuster unless it's attached to a strider,
// but the explosions always do. This is so that held or thrown striderbusters fly
// awry because of the flechette, but attached striderbusters break instantly to make
// the hunters more effective at defending the strider.
//
if ( IsAttachedToStrider() || !( info.GetDamageType() & DMG_NEVERGIB ) )
{
if( striderbuster_die_detach.GetBool() && IsAttachedToStrider() )
{
// Make the buster fall off and break.
m_takedamage = DAMAGE_NO;
CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(GetOwnerEntity());
Assert( pStrider != NULL );
pStrider->StriderBusterDetached( this );
DestroyConstraint();
// Amplify some lateral force.
Vector vecForce = info.GetDamageForce();
vecForce.z = 0.0f;
VPhysicsGetObject()->ApplyForceCenter( vecForce * 5.0f );
SetContextThink( NULL, gpGlobals->curtime, s_pBusterPingThinkContext );
SetThink( &CWeaponStriderBuster::BusterDetachThink );
SetNextThink( gpGlobals->curtime );
m_iBusterFlags |= STRIDERBUSTER_FLAG_KNOCKED_OFF_STRIDER;
return 0;
}
else
{
// Destroy the buster in place
// Make sure they know it blew up prematurely.
EmitSound( "Weapon_StriderBuster.Dud_Detonate" );
DispatchParticleEffect( "striderbuster_break_flechette", GetAbsOrigin(), GetAbsAngles() );
SetHealth( 0 );
Shatter( info.GetAttacker() );
return 0;
}
}
if ( info.GetDamage() < 5 )
{
bool bFirst = ( m_CarryAngles.x == 45 && m_CarryAngles.y == 0 && m_CarryAngles.z == 0);
float sinTime = sin( gpGlobals->curtime );
bool bSubtractX = ( bFirst ) ? ( sinTime < 0 ) : ( m_CarryAngles.x < 45 );
m_CarryAngles.x += ( 10.0 + 10.0 * fabsf( sinTime ) + random->RandomFloat( -2.5, 2.5 ) + random->RandomFloat( -2.5, 2.5 ) ) * ( ( bSubtractX ) ? -1.0 : 1.0 );
m_CarryAngles.y = 15 * ( sin( gpGlobals->curtime ) + cos( gpGlobals->curtime * 0.5 ) ) * .5 + random->RandomFloat( -15, 15 );
m_CarryAngles.z = 7.5 * ( sin( gpGlobals->curtime ) + sin( gpGlobals->curtime * 2.0 ) ) * .5 + random->RandomFloat( -7.5, 7.5 );
}
return 1;
}
}
// Allow crushing damage
if ( info.GetDamageType() & DMG_CRUSH )
return BaseClass::OnTakeDamage( info );
return 0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::OnPhysGunPickup( CBasePlayer *pPhysGunUser, PhysGunPickup_t reason )
{
m_PickupTime = gpGlobals->curtime;
m_CarryAngles.Init( 45, 0, 0 );
if ( ( reason == PICKED_UP_BY_CANNON ) && ( !HasSpawnFlags( SF_DONT_WEAPON_MANAGE ) ) )
{
WeaponManager_RemoveManaged( this );
}
else if ( reason == PUNTED_BY_CANNON )
{
Launch( pPhysGunUser );
}
BaseClass::OnPhysGunPickup( pPhysGunUser, reason );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::OnPhysGunDrop( CBasePlayer *pPhysGunUser, PhysGunDrop_t Reason )
{
if ( Reason == LAUNCHED_BY_CANNON )
{
Launch( pPhysGunUser );
}
else if ( ( Reason == DROPPED_BY_CANNON ) && ( !HasSpawnFlags( SF_DONT_WEAPON_MANAGE ) ) )
{
// This striderbuster is now fair game for autodeletion.
WeaponManager_AddManaged( this );
}
BaseClass::OnPhysGunDrop( pPhysGunUser, Reason );
}
//-----------------------------------------------------------------------------
// 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() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &forward -
// flMass -
// Output : Vector
//-----------------------------------------------------------------------------
Vector CWeaponStriderBuster::PhysGunLaunchVelocity( const Vector &forward, float flMass )
{
return ( striderbuster_shot_velocity.GetFloat() * forward );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::Shatter( CBaseEntity *pAttacker )
{
if( m_bNoseDiving )
m_OnShotDown.FireOutput( this, this );
m_takedamage = DAMAGE_YES;
if( !IsAttachedToStrider() )
{
// Don't display this particular effect if we're attached to a strider. This effect just gets lost
// in the big strider explosion anyway, so let's recover some perf.
DispatchParticleEffect( "striderbuster_break", GetAbsOrigin(), GetAbsAngles() );
}
// Buster is useless now. Stop thinking, touching.
SetThink( NULL );
SetTouch( NULL );
SetContextThink( NULL, gpGlobals->curtime, s_pBusterPingThinkContext );
// Deal deadly damage to ourselves (DMG_CRUSH is allowed, others are blocked)
CTakeDamageInfo info( pAttacker, pAttacker, RandomVector( -100, 100 ), GetAbsOrigin(), 100.0f, DMG_CRUSH );
TakeDamage( info );
}
//-----------------------------------------------------------------------------
// Purpose: Give the buster a slight attraction to striders.
// Ported back from the magnade.
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::BusterFlyThink()
{
if (IsAttachedToStrider())
return; // early out. Think no more.
// If we're nosediving, forget about magnetism.
if ( m_bNoseDiving )
{
if ( VPhysicsGetObject() )
VPhysicsGetObject()->ApplyForceCenter( Vector( 0, 0, striderbuster_dive_force.GetFloat() ) );
SetNextThink(gpGlobals->curtime + 0.01f);
return;
}
// seek?
const float magradius = 38.0 * sk_striderbuster_magnet_multiplier.GetFloat(); // radius of strider hull times multiplier
if (magradius > 0 &&
GetMoveType() == MOVETYPE_VPHYSICS &&
VPhysicsGetObject()
)
{
// find the nearest enemy.
CBaseEntity *pList[16];
Vector origin = GetAbsOrigin();
// do a find in box ( a little faster than sphere )
int count;
{
Vector mins,maxs;
mins = origin;
mins -= magradius;
maxs = origin;
maxs += magradius;
count = UTIL_EntitiesInBox(pList, 16, mins, maxs, FL_NPC);
}
float magradiusSq = Square( magradius );
float nearestDistSq = magradiusSq + 1;
int bestFit = -1;
Vector toTarget; // will be garbage unless something good is found
CNPC_Strider *pBestStrider = NULL;
for ( int ii = 0 ; ii < count ; ++ii )
{
CNPC_Strider *pStrider = dynamic_cast<CNPC_Strider *>(pList[ii]);
if ( pStrider && !pStrider->CarriedByDropship() ) // ShouldStickToEntity() doesn't work because the strider NPC isn't what we glue to
{
// get distance squared
VectorSubtract( pStrider->GetAdjustedOrigin(), GetAbsOrigin(), toTarget );
//NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + toTarget, 128, 0, 128, false, 0.1 );
float dSq = toTarget.LengthSqr();
if (dSq < nearestDistSq)
{
bestFit = ii; nearestDistSq = dSq;
pBestStrider = pStrider;
}
}
}
if (bestFit >= 0) // we found something and should attract towards it. (hysterisis later?)
{
if ( striderbuster_debugseek.GetBool() )
{
NDebugOverlay::Circle( GetAbsOrigin() + toTarget, magradius, 255, 255, 255, 255, true, .1 );
NDebugOverlay::Cross3D( GetAbsOrigin() + toTarget, magradius, 255, 255, 255, true, .1 );
}
// force magnitude.
float magnitude = GetMass() * striderbuster_magnetic_force_strider.GetFloat();
int falloff = striderbuster_falloff_power.GetInt();
switch (falloff)
{
case 1:
VPhysicsGetObject()->ApplyForceCenter( toTarget * (magnitude / nearestDistSq) ); // dividing through by distance squared normalizes toTarget and gives a linear falloff
break;
case 2:
VPhysicsGetObject()->ApplyForceCenter( toTarget * (magnitude / (nearestDistSq * sqrtf(nearestDistSq))) ); // dividing through by distance cubed normalizes toTarget and gives a quadratic falloff
break;
case 3:
VPhysicsGetObject()->ApplyForceCenter( toTarget * (magnitude / (nearestDistSq * nearestDistSq)) ); // dividing through by distance fourth normalizes toTarget and gives a cubic falloff
break;
case 4:
{
Vector toTarget;
pBestStrider->GetAttachment( "buster_target", toTarget );
if ( striderbuster_debugseek.GetBool() )
{
NDebugOverlay::Cross3D( toTarget, magradius, 255, 0, 255, true, .1 );
NDebugOverlay::Cross3D( toTarget, magradius, 255, 0, 255, true, .1 );
}
toTarget -= GetAbsOrigin();
toTarget.NormalizeInPlace();
VPhysicsGetObject()->ApplyForceCenter( toTarget * magnitude );
}
break;
default: // arbitrary powers
VPhysicsGetObject()->ApplyForceCenter( toTarget * (magnitude * powf(nearestDistSq,(falloff+1.0f)/2)) ); // square root for distance instead of squared, add one to normalize toTarget
break;
}
}
SetNextThink(gpGlobals->curtime + 0.01f);
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
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);
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::BusterPingThink()
{
EmitSound( "Weapon_StriderBuster.Ping" );
SetContextThink( &CWeaponStriderBuster::BusterPingThink, gpGlobals->curtime + BUSTER_PING_SOUND_FREQ, s_pBusterPingThinkContext );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CWeaponStriderBuster::OnAddToCargoHold()
{
if ( !HasSpawnFlags( SF_DONT_WEAPON_MANAGE ) )
{
WeaponManager_RemoveManaged( this );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
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++;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool StriderBuster_IsAttachedStriderBuster( CBaseEntity *pEntity, CBaseEntity *pAttachedTo )
{
Assert(dynamic_cast<CWeaponStriderBuster *>(pEntity));
if ( !pAttachedTo )
return static_cast<CWeaponStriderBuster *>(pEntity)->m_hConstrainedEntity != NULL;
else
return static_cast<CWeaponStriderBuster *>(pEntity)->m_hConstrainedEntity == pAttachedTo;
}
//-----------------------------------------------------------------------------
// Called when the striderbuster is placed in the jalopy's cargo container.
//-----------------------------------------------------------------------------
void StriderBuster_OnAddToCargoHold( CBaseEntity *pEntity )
{
CWeaponStriderBuster *pBuster = dynamic_cast <CWeaponStriderBuster *>( pEntity );
if ( pBuster )
{
pBuster->OnAddToCargoHold();
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool StriderBuster_OnFlechetteAttach( CBaseEntity *pEntity, Vector &vecFlechetteVelocity )
{
CWeaponStriderBuster *pBuster = dynamic_cast <CWeaponStriderBuster *>( pEntity );
if ( pBuster )
{
pBuster->OnFlechetteAttach( vecFlechetteVelocity );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int StriderBuster_NumFlechettesAttached( CBaseEntity *pEntity )
{
CWeaponStriderBuster *pBuster = dynamic_cast <CWeaponStriderBuster *>( pEntity );
if ( pBuster )
{
return pBuster->NumFlechettesAttached();
}
return 0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
float StriderBuster_GetPickupTime( CBaseEntity *pEntity )
{
CWeaponStriderBuster *pBuster = dynamic_cast <CWeaponStriderBuster *>( pEntity );
if ( pBuster )
{
return pBuster->GetPickupTime();
}
return 0;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool StriderBuster_WasKnockedOffStrider( CBaseEntity *pEntity )
{
CWeaponStriderBuster *pBuster = dynamic_cast <CWeaponStriderBuster *>( pEntity );
if ( pBuster )
{
return ((pBuster->GetStriderBusterFlags() & STRIDERBUSTER_FLAG_KNOCKED_OFF_STRIDER) != 0);
}
return false;
}