d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
125 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 88b8830e8b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '88b8830e8b'
${ noResults }
source-engine/game/server/episodic/weapon_striderbuster.cpp

1175 lines
39 KiB
Raw Blame History

//========= 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;
}