sqwarmed/sdk_src/game/shared/basegrenade_shared.cpp

554 lines
16 KiB
C++

//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include "cbase.h"
#include "decals.h"
#include "basegrenade_shared.h"
#include "shake.h"
#include "engine/IEngineSound.h"
#if !defined( CLIENT_DLL )
#include "soundent.h"
#include "entitylist.h"
#include "GameStats.h"
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern int g_sModelIndexFireball; // (in combatweapon.cpp) holds the index for the fireball
extern int g_sModelIndexWExplosion; // (in combatweapon.cpp) holds the index for the underwater explosion
extern int g_sModelIndexSmoke; // (in combatweapon.cpp) holds the index for the smoke cloud
extern ConVar sk_plr_dmg_grenade;
#if !defined( CLIENT_DLL )
// Global Savedata for friction modifier
BEGIN_DATADESC( CBaseGrenade )
// nextGrenade
DEFINE_FIELD( m_hThrower, FIELD_EHANDLE ),
// m_fRegisteredSound ???
DEFINE_FIELD( m_bIsLive, FIELD_BOOLEAN ),
DEFINE_FIELD( m_DmgRadius, FIELD_FLOAT ),
DEFINE_FIELD( m_flDetonateTime, FIELD_TIME ),
DEFINE_FIELD( m_flWarnAITime, FIELD_TIME ),
DEFINE_FIELD( m_flDamage, FIELD_FLOAT ),
DEFINE_FIELD( m_iszBounceSound, FIELD_STRING ),
DEFINE_FIELD( m_bHasWarnedAI, FIELD_BOOLEAN ),
// Function Pointers
DEFINE_THINKFUNC( Smoke ),
DEFINE_ENTITYFUNC( BounceTouch ),
DEFINE_ENTITYFUNC( SlideTouch ),
DEFINE_ENTITYFUNC( ExplodeTouch ),
DEFINE_USEFUNC( DetonateUse ),
DEFINE_THINKFUNC( DangerSoundThink ),
DEFINE_THINKFUNC( PreDetonate ),
DEFINE_THINKFUNC( Detonate ),
DEFINE_THINKFUNC( TumbleThink ),
END_DATADESC()
void SendProxy_CropFlagsToPlayerFlagBitsLength( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID);
#endif
IMPLEMENT_NETWORKCLASS_ALIASED( BaseGrenade, DT_BaseGrenade )
BEGIN_NETWORK_TABLE( CBaseGrenade, DT_BaseGrenade )
#if !defined( CLIENT_DLL )
SendPropFloat( SENDINFO( m_flDamage ), 10, SPROP_ROUNDDOWN, 0.0, 256.0f ),
SendPropFloat( SENDINFO( m_DmgRadius ), 10, SPROP_ROUNDDOWN, 0.0, 1024.0f ),
SendPropInt( SENDINFO( m_bIsLive ), 1, SPROP_UNSIGNED ),
// SendPropTime( SENDINFO( m_flDetonateTime ) ),
SendPropEHandle( SENDINFO( m_hThrower ) ),
SendPropVector( SENDINFO( m_vecVelocity ), 0, SPROP_NOSCALE ),
// HACK: Use same flag bits as player for now
SendPropInt ( SENDINFO(m_fFlags), PLAYER_FLAG_BITS, SPROP_UNSIGNED, SendProxy_CropFlagsToPlayerFlagBitsLength ),
#else
RecvPropFloat( RECVINFO( m_flDamage ) ),
RecvPropFloat( RECVINFO( m_DmgRadius ) ),
RecvPropInt( RECVINFO( m_bIsLive ) ),
// RecvPropTime( RECVINFO( m_flDetonateTime ) ),
RecvPropEHandle( RECVINFO( m_hThrower ) ),
// Need velocity from grenades to make animation system work correctly when running
RecvPropVector( RECVINFO(m_vecVelocity), 0, RecvProxy_LocalVelocity ),
RecvPropInt( RECVINFO( m_fFlags ) ),
#endif
END_NETWORK_TABLE()
LINK_ENTITY_TO_CLASS( grenade, CBaseGrenade );
#if defined( CLIENT_DLL )
BEGIN_PREDICTION_DATA( CBaseGrenade )
DEFINE_PRED_FIELD( m_hThrower, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_bIsLive, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD( m_DmgRadius, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
// DEFINE_PRED_FIELD_TOL( m_flDetonateTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
DEFINE_PRED_FIELD( m_flDamage, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
DEFINE_PRED_FIELD_TOL( m_vecVelocity, FIELD_VECTOR, FTYPEDESC_INSENDTABLE, 0.5f ),
DEFINE_PRED_FIELD_TOL( m_flNextAttack, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, TD_MSECTOLERANCE ),
// DEFINE_FIELD( m_fRegisteredSound, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_iszBounceSound, FIELD_STRING ),
END_PREDICTION_DATA()
#endif
// Grenades flagged with this will be triggered when the owner calls detonateSatchelCharges
#define SF_DETONATE 0x0001
// UNDONE: temporary scorching for PreAlpha - find a less sleazy permenant solution.
void CBaseGrenade::Explode( trace_t *pTrace, int bitsDamageType )
{
#if !defined( CLIENT_DLL )
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();
int contents = UTIL_PointContents ( vecAbsOrigin, MASK_ALL );
if ( pTrace->fraction != 1.0 )
{
Vector vecNormal = pTrace->plane.normal;
surfacedata_t *pdata = physprops->GetSurfaceData( pTrace->surface.surfaceProps );
CPASFilter filter( vecAbsOrigin );
te->Explosion( filter, -1.0, // don't apply cl_interp delay
&vecAbsOrigin,
!( contents & MASK_WATER ) ? g_sModelIndexFireball : g_sModelIndexWExplosion,
m_DmgRadius * .03,
25,
TE_EXPLFLAG_NONE,
m_DmgRadius,
m_flDamage,
&vecNormal,
(char) pdata->game.material );
}
else
{
CPASFilter filter( vecAbsOrigin );
te->Explosion( filter, -1.0, // don't apply cl_interp delay
&vecAbsOrigin,
!( contents & MASK_WATER ) ? g_sModelIndexFireball : g_sModelIndexWExplosion,
m_DmgRadius * .03,
25,
TE_EXPLFLAG_NONE,
m_DmgRadius,
m_flDamage );
}
#if !defined( CLIENT_DLL )
CSoundEnt::InsertSound ( SOUND_COMBAT, GetAbsOrigin(), BASEGRENADE_EXPLOSION_VOLUME, 3.0 );
#endif
// Use the thrower's position as the reported position
Vector vecReported = m_hThrower ? m_hThrower->GetAbsOrigin() : vec3_origin;
EmitSound( "BaseGrenade.Explode" );
CTakeDamageInfo info( this, m_hThrower, GetBlastForce(), GetAbsOrigin(), m_flDamage, bitsDamageType, 0, &vecReported );
RadiusDamage( info, GetAbsOrigin(), m_DmgRadius, CLASS_NONE, NULL );
UTIL_DecalTrace( pTrace, "Scorch" );
SetThink( &CBaseGrenade::SUB_Remove );
SetTouch( NULL );
SetSolid( SOLID_NONE );
AddEffects( EF_NODRAW );
SetAbsVelocity( vec3_origin );
#if HL2_EPISODIC
// Because the grenade is zipped out of the world instantly, the EXPLOSION sound that it makes for
// the AI is also immediately destroyed. For this reason, we now make the grenade entity inert and
// throw it away in 1/10th of a second instead of right away. Removing the grenade instantly causes
// intermittent bugs with env_microphones who are listening for explosions. They will 'randomly' not
// hear explosion sounds when the grenade is removed and the SoundEnt thinks (and removes the sound)
// before the env_microphone thinks and hears the sound.
SetNextThink( gpGlobals->curtime + 0.1 );
#else
SetNextThink( gpGlobals->curtime );
#endif//HL2_EPISODIC
#if defined( HL2_DLL )
CBasePlayer *pPlayer = ToBasePlayer( m_hThrower.Get() );
if ( pPlayer )
{
gamestats->Event_WeaponHit( pPlayer, true, "weapon_frag", info );
}
#endif
#endif
}
void CBaseGrenade::Smoke( void )
{
Vector vecAbsOrigin = GetAbsOrigin();
if ( UTIL_PointContents ( vecAbsOrigin, MASK_WATER ) & MASK_WATER )
{
UTIL_Bubbles( vecAbsOrigin - Vector( 64, 64, 64 ), vecAbsOrigin + Vector( 64, 64, 64 ), 100 );
}
else
{
CPVSFilter filter( vecAbsOrigin );
te->Smoke( filter, 0.0,
&vecAbsOrigin, g_sModelIndexSmoke,
m_DmgRadius * 0.03,
24 );
}
#if !defined( CLIENT_DLL )
SetThink ( &CBaseGrenade::SUB_Remove );
#endif
SetNextThink( gpGlobals->curtime );
}
void CBaseGrenade::Event_Killed( const CTakeDamageInfo &info )
{
Detonate( );
}
#if !defined( CLIENT_DLL )
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseGrenade::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
// Support player pickup
if ( useType == USE_TOGGLE )
{
CBasePlayer *pPlayer = ToBasePlayer( pActivator );
if ( pPlayer )
{
pPlayer->PickupObject( this );
return;
}
}
// Pass up so we still call any custom Use function
BaseClass::Use( pActivator, pCaller, useType, value );
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Timed grenade, this think is called when time runs out.
//-----------------------------------------------------------------------------
void CBaseGrenade::DetonateUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
SetThink( &CBaseGrenade::Detonate );
SetNextThink( gpGlobals->curtime );
}
void CBaseGrenade::PreDetonate( void )
{
#if !defined( CLIENT_DLL )
CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin(), 400, 1.5, this );
#endif
SetThink( &CBaseGrenade::Detonate );
SetNextThink( gpGlobals->curtime + 1.5 );
}
void CBaseGrenade::Detonate( void )
{
trace_t tr;
Vector vecSpot;// trace starts here!
SetThink( NULL );
vecSpot = GetAbsOrigin() + Vector ( 0 , 0 , 8 );
UTIL_TraceLine ( vecSpot, vecSpot + Vector ( 0, 0, -32 ), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, & tr);
if( tr.startsolid )
{
// Since we blindly moved the explosion origin vertically, we may have inadvertently moved the explosion into a solid,
// in which case nothing is going to be harmed by the grenade's explosion because all subsequent traces will startsolid.
// If this is the case, we do the downward trace again from the actual origin of the grenade. (sjb) 3/8/2007 (for ep2_outland_09)
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, -32), MASK_SHOT_HULL, this, COLLISION_GROUP_NONE, &tr );
}
Explode( &tr, DMG_BLAST );
if ( GetShakeAmplitude() )
{
UTIL_ScreenShake( GetAbsOrigin(), GetShakeAmplitude(), 150.0, 1.0, GetShakeRadius(), SHAKE_START );
}
}
//
// Contact grenade, explode when it touches something
//
void CBaseGrenade::ExplodeTouch( CBaseEntity *pOther )
{
trace_t tr;
Vector vecSpot;// trace starts here!
Assert( pOther );
if ( !pOther->IsSolid() )
return;
Vector velDir = GetAbsVelocity();
VectorNormalize( velDir );
vecSpot = GetAbsOrigin() - velDir * 32;
UTIL_TraceLine( vecSpot, vecSpot + velDir * 64, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
Explode( &tr, DMG_BLAST );
}
void CBaseGrenade::DangerSoundThink( void )
{
if (!IsInWorld())
{
Remove( );
return;
}
#if !defined( CLIENT_DLL )
CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin() + GetAbsVelocity() * 0.5, GetAbsVelocity().Length( ), 0.2, this );
#endif
SetNextThink( gpGlobals->curtime + 0.2 );
if (GetWaterLevel() != 0)
{
SetAbsVelocity( GetAbsVelocity() * 0.5 );
}
}
void CBaseGrenade::BounceTouch( CBaseEntity *pOther )
{
if ( pOther->IsSolidFlagSet(FSOLID_TRIGGER | FSOLID_VOLUME_CONTENTS) )
return;
// don't hit the guy that launched this grenade
if ( pOther == GetThrower() )
return;
// only do damage if we're moving fairly fast
if ( (pOther->m_takedamage != DAMAGE_NO) && (m_flNextAttack < gpGlobals->curtime && GetAbsVelocity().Length() > 100))
{
if (m_hThrower)
{
#if !defined( CLIENT_DLL )
trace_t tr;
tr = CBaseEntity::GetTouchTrace( );
ClearMultiDamage( );
Vector forward;
AngleVectors( GetLocalAngles(), &forward, NULL, NULL );
CTakeDamageInfo info( this, m_hThrower, 1, DMG_CLUB );
CalculateMeleeDamageForce( &info, GetAbsVelocity(), GetAbsOrigin() );
pOther->DispatchTraceAttack( info, forward, &tr );
ApplyMultiDamage();
#endif
}
m_flNextAttack = gpGlobals->curtime + 1.0; // debounce
}
Vector vecTestVelocity;
// m_vecAngVelocity = Vector (300, 300, 300);
// this is my heuristic for modulating the grenade velocity because grenades dropped purely vertical
// or thrown very far tend to slow down too quickly for me to always catch just by testing velocity.
// trimming the Z velocity a bit seems to help quite a bit.
vecTestVelocity = GetAbsVelocity();
vecTestVelocity.z *= 0.45;
if ( !m_bHasWarnedAI && vecTestVelocity.Length() <= 60 )
{
// grenade is moving really slow. It's probably very close to where it will ultimately stop moving.
// emit the danger sound.
// register a radius louder than the explosion, so we make sure everyone gets out of the way
#if !defined( CLIENT_DLL )
CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin(), m_flDamage / 0.4, 0.3, this );
#endif
m_bHasWarnedAI = true;
}
if (GetFlags() & FL_ONGROUND)
{
// add a bit of static friction
// SetAbsVelocity( GetAbsVelocity() * 0.8 );
// SetSequence( random->RandomInt( 1, 1 ) ); // FIXME: missing tumble animations
}
else
{
// play bounce sound
BounceSound();
}
m_flPlaybackRate = GetAbsVelocity().Length() / 200.0;
if (GetPlaybackRate() > 1.0)
m_flPlaybackRate = 1;
else if (GetPlaybackRate() < 0.5)
m_flPlaybackRate = 0;
}
void CBaseGrenade::SlideTouch( CBaseEntity *pOther )
{
// don't hit the guy that launched this grenade
if ( pOther == GetThrower() )
return;
// m_vecAngVelocity = Vector (300, 300, 300);
if (GetFlags() & FL_ONGROUND)
{
// add a bit of static friction
// SetAbsVelocity( GetAbsVelocity() * 0.95 );
if (GetAbsVelocity().x != 0 || GetAbsVelocity().y != 0)
{
// maintain sliding sound
}
}
else
{
BounceSound();
}
}
void CBaseGrenade ::BounceSound( void )
{
// Doesn't need to do anything anymore! Physics makes the sound.
}
void CBaseGrenade ::TumbleThink( void )
{
if (!IsInWorld())
{
Remove( );
return;
}
StudioFrameAdvance( );
SetNextThink( gpGlobals->curtime + 0.1f );
//
// Emit a danger sound one second before exploding.
//
if (m_flDetonateTime - 1 < gpGlobals->curtime)
{
#if !defined( CLIENT_DLL )
CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin() + GetAbsVelocity() * (m_flDetonateTime - gpGlobals->curtime), 400, 0.1, this );
#endif
}
if (m_flDetonateTime <= gpGlobals->curtime)
{
SetThink( &CBaseGrenade::Detonate );
}
if (GetWaterLevel() != 0)
{
SetAbsVelocity( GetAbsVelocity() * 0.5 );
m_flPlaybackRate = 0.2;
}
}
void CBaseGrenade::Precache( void )
{
BaseClass::Precache( );
PrecacheScriptSound( "BaseGrenade.Explode" );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CBaseCombatCharacter
//-----------------------------------------------------------------------------
CBaseCombatCharacter *CBaseGrenade::GetThrower( void )
{
CBaseCombatCharacter *pResult = ToBaseCombatCharacter( m_hThrower );
if ( !pResult && GetOwnerEntity() != NULL )
{
pResult = ToBaseCombatCharacter( GetOwnerEntity() );
}
return pResult;
}
//-----------------------------------------------------------------------------
void CBaseGrenade::SetThrower( CBaseCombatCharacter *pThrower )
{
m_hThrower = pThrower;
// if this is the first thrower, set it as the original thrower
if ( NULL == m_hOriginalThrower )
{
m_hOriginalThrower = pThrower;
}
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
// Input :
// Output :
//-----------------------------------------------------------------------------
CBaseGrenade::~CBaseGrenade(void)
{
};
//-----------------------------------------------------------------------------
// Purpose: Constructor
// Input :
// Output :
//-----------------------------------------------------------------------------
CBaseGrenade::CBaseGrenade(void)
{
m_hThrower = NULL;
m_hOriginalThrower = NULL;
m_bIsLive = false;
m_DmgRadius = 100;
m_flDetonateTime = 0;
m_bHasWarnedAI = false;
SetSimulatedEveryTick( true );
};