457 lines
11 KiB
C++
457 lines
11 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Hand grenade
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "npcevent.h"
|
|
#include "hl1mp_basecombatweapon_shared.h"
|
|
//#include "basecombatcharacter.h"
|
|
//#include "AI_BaseNPC.h"
|
|
#ifdef CLIENT_DLL
|
|
#include "hl1/hl1_c_player.h"
|
|
#else
|
|
#include "hl1_player.h"
|
|
#endif
|
|
#include "gamerules.h"
|
|
#include "in_buttons.h"
|
|
#ifdef CLIENT_DLL
|
|
#else
|
|
#include "soundent.h"
|
|
#include "game.h"
|
|
#endif
|
|
#include "vstdlib/random.h"
|
|
#include "engine/IEngineSound.h"
|
|
#ifdef CLIENT_DLL
|
|
#else
|
|
#include "hl1_basegrenade.h"
|
|
#endif
|
|
|
|
|
|
#define HANDGRENADE_MODEL "models/w_grenade.mdl"
|
|
|
|
|
|
#ifndef CLIENT_DLL
|
|
|
|
extern ConVar sk_plr_dmg_grenade;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CHandGrenade
|
|
//-----------------------------------------------------------------------------
|
|
LINK_ENTITY_TO_CLASS( grenade_hand, CHandGrenade );
|
|
|
|
BEGIN_DATADESC( CHandGrenade )
|
|
DEFINE_ENTITYFUNC( BounceTouch ),
|
|
END_DATADESC()
|
|
|
|
|
|
void CHandGrenade::Spawn( void )
|
|
{
|
|
SetMoveType( MOVETYPE_FLYGRAVITY, MOVECOLLIDE_FLY_BOUNCE );
|
|
SetSolid( SOLID_BBOX );
|
|
AddSolidFlags( FSOLID_NOT_STANDABLE );
|
|
|
|
SetModel( HANDGRENADE_MODEL );
|
|
|
|
UTIL_SetSize( this, Vector( 0, 0, 0 ), Vector( 0, 0, 0 ) );
|
|
|
|
m_bHasWarnedAI = false;
|
|
}
|
|
|
|
|
|
void CHandGrenade::Precache( void )
|
|
{
|
|
BaseClass::Precache( );
|
|
|
|
PrecacheScriptSound( "Weapon_HandGrenade.GrenadeBounce" );
|
|
|
|
PrecacheModel( HANDGRENADE_MODEL );
|
|
}
|
|
|
|
|
|
void CHandGrenade::ShootTimed( CBaseCombatCharacter *pOwner, Vector vecVelocity, float flTime )
|
|
{
|
|
SetAbsVelocity( vecVelocity );
|
|
|
|
SetThrower( pOwner );
|
|
SetOwnerEntity( pOwner );
|
|
|
|
SetTouch( &CHandGrenade::BounceTouch ); // Bounce if touched
|
|
|
|
m_flDetonateTime = gpGlobals->curtime + flTime;
|
|
SetThink( &CBaseGrenade::TumbleThink );
|
|
SetNextThink( gpGlobals->curtime + 0.1 );
|
|
if ( flTime < 0.1 )
|
|
{
|
|
SetNextThink( gpGlobals->curtime );
|
|
SetAbsVelocity( vec3_origin );
|
|
}
|
|
|
|
// SetSequence( SelectWeightedSequence( ACT_GRENADE_TOSS ) );
|
|
SetSequence( 0 );
|
|
m_flPlaybackRate = 1.0;
|
|
|
|
SetAbsAngles( QAngle( 0,0,60) );
|
|
|
|
AngularImpulse angImpulse;
|
|
angImpulse[0] = random->RandomInt( -200, 200 );
|
|
angImpulse[1] = random->RandomInt( 400, 500 );
|
|
angImpulse[2] = random->RandomInt( -100, 100 );
|
|
ApplyLocalAngularVelocityImpulse( angImpulse );
|
|
|
|
SetGravity( UTIL_ScaleForGravity( 400 ) ); // use a lower gravity for grenades to make them easier to see
|
|
SetFriction( 0.8 );
|
|
|
|
SetDamage( sk_plr_dmg_grenade.GetFloat() );
|
|
SetDamageRadius( GetDamage() * 2.5 );
|
|
}
|
|
|
|
|
|
void CHandGrenade ::BounceSound( void )
|
|
{
|
|
EmitSound( "Weapon_HandGrenade.GrenadeBounce" );
|
|
}
|
|
|
|
|
|
void CHandGrenade::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;
|
|
|
|
// Do a special test for players
|
|
if ( pOther->IsPlayer() )
|
|
{
|
|
// Never hit a player again (we'll explode and fixup anyway)
|
|
SetCollisionGroup( COLLISION_GROUP_DEBRIS );
|
|
}
|
|
// only do damage if we're moving fairly fast
|
|
if ( (pOther->m_takedamage != DAMAGE_NO) && (m_flNextAttack < gpGlobals->curtime && GetAbsVelocity().Length() > 100))
|
|
{
|
|
if ( GetThrower() )
|
|
{
|
|
trace_t tr;
|
|
tr = CBaseEntity::GetTouchTrace( );
|
|
ClearMultiDamage( );
|
|
Vector forward;
|
|
AngleVectors( GetAbsAngles(), &forward );
|
|
|
|
CTakeDamageInfo info( this, GetThrower(), 1, DMG_CLUB );
|
|
CalculateMeleeDamageForce( &info, forward, tr.endpos );
|
|
pOther->DispatchTraceAttack( info, forward, &tr );
|
|
ApplyMultiDamage();
|
|
}
|
|
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
|
|
CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin(), m_flDamage / 0.4, 0.3 );
|
|
m_bHasWarnedAI = TRUE;
|
|
}
|
|
|
|
// HACKHACK - On ground isn't always set, so look for ground underneath
|
|
trace_t tr;
|
|
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() - Vector(0,0,10), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( tr.fraction < 1.0 )
|
|
{
|
|
// add a bit of static friction
|
|
// SetAbsVelocity( GetAbsVelocity() * 0.8 );
|
|
SetSequence( SelectWeightedSequence( ACT_IDLE ) );
|
|
SetAbsAngles( vec3_angle );
|
|
}
|
|
|
|
// play bounce sound
|
|
BounceSound();
|
|
|
|
m_flPlaybackRate = GetAbsVelocity().Length() / 200.0;
|
|
if (m_flPlaybackRate > 1.0)
|
|
m_flPlaybackRate = 1;
|
|
else if (m_flPlaybackRate < 0.5)
|
|
m_flPlaybackRate = 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
#define CWeaponHandGrenade C_WeaponHandGrenade
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CWeaponHandGrenade
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CWeaponHandGrenade : public CBaseHL1MPCombatWeapon
|
|
{
|
|
DECLARE_CLASS( CWeaponHandGrenade, CBaseHL1MPCombatWeapon );
|
|
public:
|
|
|
|
DECLARE_NETWORKCLASS();
|
|
DECLARE_PREDICTABLE();
|
|
|
|
CWeaponHandGrenade( void );
|
|
|
|
void Precache( void );
|
|
void PrimaryAttack( void );
|
|
void WeaponIdle( void );
|
|
bool Deploy( void );
|
|
bool Holster( CBaseCombatWeapon *pSwitchingTo = NULL );
|
|
|
|
// DECLARE_SERVERCLASS();
|
|
DECLARE_DATADESC();
|
|
|
|
private:
|
|
// float m_flStartThrow;
|
|
// float m_flReleaseThrow;
|
|
CNetworkVar( float, m_flStartThrow );
|
|
CNetworkVar( float, m_flReleaseThrow );
|
|
};
|
|
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponHandGrenade, DT_WeaponHandGrenade );
|
|
|
|
BEGIN_NETWORK_TABLE( CWeaponHandGrenade, DT_WeaponHandGrenade )
|
|
#ifdef CLIENT_DLL
|
|
RecvPropFloat( RECVINFO( m_flStartThrow ) ),
|
|
RecvPropFloat( RECVINFO( m_flReleaseThrow ) ),
|
|
#else
|
|
SendPropFloat( SENDINFO( m_flStartThrow ) ),
|
|
SendPropFloat( SENDINFO( m_flReleaseThrow ) ),
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_PREDICTION_DATA( CWeaponHandGrenade )
|
|
#ifdef CLIENT_DLL
|
|
DEFINE_PRED_FIELD( m_flStartThrow, FIELD_INTEGER, FTYPEDESC_INSENDTABLE ),
|
|
DEFINE_PRED_FIELD( m_flReleaseThrow, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
|
|
#endif
|
|
END_PREDICTION_DATA()
|
|
|
|
LINK_ENTITY_TO_CLASS( weapon_handgrenade, CWeaponHandGrenade );
|
|
|
|
PRECACHE_WEAPON_REGISTER( weapon_handgrenade );
|
|
|
|
//IMPLEMENT_SERVERCLASS_ST( CWeaponHandGrenade, DT_WeaponHandGrenade )
|
|
//END_SEND_TABLE()
|
|
|
|
BEGIN_DATADESC( CWeaponHandGrenade )
|
|
END_DATADESC()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CWeaponHandGrenade::CWeaponHandGrenade( void )
|
|
{
|
|
m_bReloadsSingly = false;
|
|
m_bFiresUnderwater = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponHandGrenade::Precache( void )
|
|
{
|
|
#ifndef CLIENT_DLL
|
|
UTIL_PrecacheOther( "grenade_hand" );
|
|
#endif
|
|
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponHandGrenade::PrimaryAttack( void )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
|
|
if ( !pPlayer )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( ( m_flStartThrow <= 0 ) && pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
|
|
{
|
|
m_flStartThrow = gpGlobals->curtime;
|
|
m_flReleaseThrow = 0;
|
|
|
|
SendWeaponAnim( ACT_VM_PRIMARYATTACK );
|
|
SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
|
|
}
|
|
}
|
|
|
|
|
|
void CWeaponHandGrenade::WeaponIdle( void )
|
|
{
|
|
if ( m_flReleaseThrow == 0 && m_flStartThrow )
|
|
m_flReleaseThrow = gpGlobals->curtime;
|
|
|
|
if ( !HasWeaponIdleTimeElapsed() )
|
|
return;
|
|
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
|
|
if ( !pPlayer )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( m_flStartThrow )
|
|
{
|
|
Vector vecAiming = pPlayer->GetAutoaimVector( 0 );
|
|
|
|
QAngle angThrow;
|
|
VectorAngles( vecAiming, angThrow );
|
|
|
|
Vector vecUp;
|
|
Vector vecRight;
|
|
AngleVectors( angThrow, NULL, &vecRight, &vecUp );
|
|
|
|
if ( angThrow.x > 180 ) // player is pitching up
|
|
angThrow.x = -15 - ( 360 - angThrow.x ) * ( ( 90 - 10 ) / 90.0 );
|
|
else // player is pitching down
|
|
angThrow.x = -15 + angThrow.x * ( ( 90 + 10 ) / 90.0 );
|
|
|
|
float flVel = ( 90 - angThrow.x ) * 4;
|
|
if ( flVel > 500 )
|
|
flVel = 500;
|
|
|
|
Vector vecFwd;
|
|
AngleVectors( angThrow, &vecFwd );
|
|
|
|
Vector vecSrc = pPlayer->EyePosition() + vecFwd * 16;
|
|
Vector vecThrow = vecFwd * flVel + pPlayer->GetAbsVelocity();
|
|
|
|
QAngle angles;
|
|
VectorAngles( vecThrow, angles );
|
|
#ifndef CLIENT_DLL
|
|
CHandGrenade *pGrenade = (CHandGrenade*)Create( "grenade_hand", vecSrc, angles );
|
|
if ( pGrenade )
|
|
{
|
|
// always explode 3 seconds after the pin was pulled
|
|
float flTime = m_flStartThrow - gpGlobals->curtime + 3.0;
|
|
if ( flTime < 0 )
|
|
{
|
|
flTime = 0;
|
|
}
|
|
|
|
pGrenade->ShootTimed( pPlayer, vecThrow, flTime );
|
|
}
|
|
#endif
|
|
|
|
if ( flVel < 500 )
|
|
{
|
|
SendWeaponAnim( ACT_HANDGRENADE_THROW1 );
|
|
}
|
|
else if ( flVel < 1000 )
|
|
{
|
|
SendWeaponAnim( ACT_HANDGRENADE_THROW2 );
|
|
}
|
|
else
|
|
{
|
|
SendWeaponAnim( ACT_HANDGRENADE_THROW3 );
|
|
}
|
|
|
|
// player "shoot" animation
|
|
pPlayer->SetAnimation( PLAYER_ATTACK1 );
|
|
|
|
m_flReleaseThrow = 0;
|
|
m_flStartThrow = 0;
|
|
|
|
SetWeaponIdleTime( gpGlobals->curtime + 0.5 );
|
|
m_flNextPrimaryAttack = gpGlobals->curtime + 0.5;
|
|
m_flNextSecondaryAttack = gpGlobals->curtime + 0.5;
|
|
|
|
pPlayer->RemoveAmmo( 1, m_iPrimaryAmmoType );
|
|
|
|
return;
|
|
}
|
|
else if ( m_flReleaseThrow > 0 )
|
|
{
|
|
// we've finished the throw, restart.
|
|
m_flStartThrow = 0;
|
|
|
|
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
|
|
{
|
|
SendWeaponAnim( ACT_VM_DRAW );
|
|
}
|
|
else
|
|
{
|
|
// RetireWeapon();
|
|
return;
|
|
}
|
|
|
|
SetWeaponIdleTime( gpGlobals->curtime + random->RandomFloat( 10, 15 ) );
|
|
m_flReleaseThrow = -1;
|
|
return;
|
|
}
|
|
|
|
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
|
|
{
|
|
float flRand = random->RandomFloat( 0, 1 );
|
|
if ( flRand <= 0.75 )
|
|
{
|
|
SendWeaponAnim( ACT_VM_IDLE );
|
|
SetWeaponIdleTime( gpGlobals->curtime + random->RandomFloat( 10, 15 ) );// how long till we do this again.
|
|
}
|
|
else
|
|
{
|
|
SendWeaponAnim( ACT_VM_FIDGET );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CWeaponHandGrenade::Deploy( void )
|
|
{
|
|
m_flReleaseThrow = -1;
|
|
|
|
return DefaultDeploy( (char*)GetViewModel(), (char*)GetWorldModel(), ACT_VM_DRAW, (char*)GetAnimPrefix() );
|
|
}
|
|
|
|
bool CWeaponHandGrenade::Holster( CBaseCombatWeapon *pSwitchingTo )
|
|
{
|
|
CBasePlayer *pPlayer = ToBasePlayer( GetOwner() );
|
|
if ( !pPlayer )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( m_flStartThrow > 0 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( !BaseClass::Holster( pSwitchingTo ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) <= 0 )
|
|
{
|
|
#ifndef CLIENT_DLL
|
|
SetThink( &CWeaponHandGrenade::DestroyItem );
|
|
SetNextThink( gpGlobals->curtime + 0.1 );
|
|
#endif
|
|
}
|
|
|
|
pPlayer->SetNextAttack( gpGlobals->curtime + 0.5 );
|
|
|
|
return true;
|
|
}
|