415 lines
12 KiB
C++
415 lines
12 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Minigun
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include "weapon_combat_usedwithshieldbase.h"
|
|
#include "in_buttons.h"
|
|
#include "takedamageinfo.h"
|
|
#include "SoundEmitterSystem/isoundemittersystembase.h"
|
|
#include "tf_gamerules.h"
|
|
|
|
// Damage CVars
|
|
ConVar weapon_minigun_damage( "weapon_minigun_damage","10", FCVAR_REPLICATED, "Minigun damage per pellet" );
|
|
ConVar weapon_minigun_range( "weapon_minigun_range","1500", FCVAR_REPLICATED, "Minigun maximum range" );
|
|
ConVar weapon_minigun_pellets( "weapon_minigun_pellets","2", FCVAR_REPLICATED, "Minigun pellets per fire" );
|
|
ConVar weapon_minigun_ducking_mod( "weapon_minigun_ducking_mod", "0.75", FCVAR_REPLICATED, "Minigun ducking speed modifier" );
|
|
|
|
#if defined( CLIENT_DLL )
|
|
#include "hud.h"
|
|
#include "fx.h"
|
|
#define CWeaponMinigun C_WeaponMinigun
|
|
extern ConVar zoom_sensitivity_ratio;
|
|
extern ConVar default_fov;
|
|
#else
|
|
#endif
|
|
|
|
// Time taken to fully wind up/down
|
|
#define MINIGUN_WIND_TIME 2
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CWeaponMinigun : public CWeaponCombatUsedWithShieldBase
|
|
{
|
|
DECLARE_CLASS( CWeaponMinigun, CWeaponCombatUsedWithShieldBase );
|
|
public:
|
|
DECLARE_NETWORKCLASS();
|
|
DECLARE_PREDICTABLE();
|
|
|
|
CWeaponMinigun( void );
|
|
|
|
virtual void Precache();
|
|
|
|
virtual bool Holster( CBaseCombatWeapon *pSwitchingTo );
|
|
virtual const Vector& GetBulletSpread( void );
|
|
virtual void ItemPostFrame( void );
|
|
virtual void PrimaryAttack( void );
|
|
virtual void AddViewKick( void );
|
|
virtual float GetFireRate( void );
|
|
virtual float GetDefaultAnimSpeed( void );
|
|
virtual void BulletWasFired( const Vector &vecStart, const Vector &vecEnd );
|
|
|
|
// All predicted weapons need to implement and return true
|
|
virtual bool IsPredicted( void ) const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void ReduceRotation( void );
|
|
void AttemptToReload( void );
|
|
|
|
#if defined( CLIENT_DLL )
|
|
public:
|
|
virtual bool ShouldPredict( void )
|
|
{
|
|
if ( GetOwner() &&
|
|
GetOwner() == C_BasePlayer::GetLocalPlayer() )
|
|
return true;
|
|
|
|
return BaseClass::ShouldPredict();
|
|
}
|
|
|
|
virtual bool OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options );
|
|
virtual void OnDataChanged( DataUpdateType_t updateType );
|
|
virtual void ClientThink( void );
|
|
#endif
|
|
|
|
public:
|
|
float m_flOwnersMaxSpeed;
|
|
CNetworkVar( float, m_flRotationSpeed ); // When 1, firing commences.
|
|
bool m_bSoundPlaying;
|
|
|
|
private:
|
|
CWeaponMinigun( const CWeaponMinigun & );
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CWeaponMinigun::CWeaponMinigun( void )
|
|
{
|
|
SetPredictionEligible( true );
|
|
m_flRotationSpeed = 0;
|
|
m_bSoundPlaying = false;
|
|
}
|
|
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( WeaponMinigun, DT_WeaponMinigun )
|
|
|
|
BEGIN_NETWORK_TABLE( CWeaponMinigun, DT_WeaponMinigun )
|
|
#if !defined( CLIENT_DLL )
|
|
SendPropFloat( SENDINFO( m_flRotationSpeed ), 8, SPROP_ROUNDDOWN, 0, 1 ),
|
|
#else
|
|
RecvPropFloat( RECVINFO( m_flRotationSpeed ) ),
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_PREDICTION_DATA( CWeaponMinigun )
|
|
DEFINE_PRED_FIELD_TOL( m_flRotationSpeed, FIELD_FLOAT, FTYPEDESC_INSENDTABLE, 0.01f ),
|
|
END_PREDICTION_DATA()
|
|
|
|
LINK_ENTITY_TO_CLASS( weapon_minigun, CWeaponMinigun );
|
|
PRECACHE_WEAPON_REGISTER(weapon_minigun);
|
|
|
|
void CWeaponMinigun::Precache()
|
|
{
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CWeaponMinigun::Holster( CBaseCombatWeapon *pSwitchingTo )
|
|
{
|
|
m_flRotationSpeed = 0;
|
|
|
|
return BaseClass::Holster( pSwitchingTo );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the accuracy derived from weapon and player, and return it
|
|
//-----------------------------------------------------------------------------
|
|
const Vector& CWeaponMinigun::GetBulletSpread( void )
|
|
{
|
|
static Vector cone = VECTOR_CONE_8DEGREES;
|
|
return cone;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponMinigun::ItemPostFrame( void )
|
|
{
|
|
CBaseTFPlayer *pOwner = ToBaseTFPlayer( GetOwner() );
|
|
if (!pOwner)
|
|
return;
|
|
|
|
// This should work, and avoids sending extra network data. If it doesn't, we'll have to send down the unchanged max speed.
|
|
if ( !m_flRotationSpeed )
|
|
{
|
|
m_flOwnersMaxSpeed = pOwner->MaxSpeed();
|
|
}
|
|
|
|
float flLastRotationSpeed = m_flRotationSpeed;
|
|
|
|
CheckReload();
|
|
|
|
// Handle firing
|
|
if ( (pOwner->m_nButtons & IN_ATTACK ) && (m_flNextPrimaryAttack <= gpGlobals->curtime) )
|
|
{
|
|
if ( m_iClip1 > 0 )
|
|
{
|
|
if ( m_flRotationSpeed < 0.99 )
|
|
{
|
|
// If we're starting, play the sound
|
|
m_flRotationSpeed = min(1, m_flRotationSpeed + (gpGlobals->frametime / MINIGUN_WIND_TIME) );
|
|
}
|
|
else
|
|
{
|
|
PrimaryAttack();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AttemptToReload();
|
|
}
|
|
}
|
|
|
|
// Reload button (or fire button when we're out of ammo)
|
|
if ( m_flNextPrimaryAttack <= gpGlobals->curtime )
|
|
{
|
|
if ( pOwner->m_nButtons & IN_RELOAD )
|
|
{
|
|
AttemptToReload();
|
|
}
|
|
else if ( !((pOwner->m_nButtons & IN_ATTACK) || (pOwner->m_nButtons & IN_ATTACK2) || (pOwner->m_nButtons & IN_RELOAD)) )
|
|
{
|
|
if ( !m_iClip1 && HasPrimaryAmmo() )
|
|
{
|
|
AttemptToReload();
|
|
}
|
|
else
|
|
{
|
|
ReduceRotation();
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the speed changed, modify our movement speed
|
|
if ( m_flRotationSpeed != flLastRotationSpeed )
|
|
{
|
|
pOwner->SetMaxSpeed( m_flOwnersMaxSpeed * (1.0 - (m_flRotationSpeed * 0.5)) );
|
|
}
|
|
|
|
WeaponIdle();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponMinigun::ReduceRotation( void )
|
|
{
|
|
if ( m_flRotationSpeed > 0 )
|
|
{
|
|
m_flRotationSpeed = MAX(0, m_flRotationSpeed - (gpGlobals->frametime / MINIGUN_WIND_TIME) );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponMinigun::AttemptToReload( void )
|
|
{
|
|
// Wind down before reloading
|
|
if ( m_flRotationSpeed > 0 )
|
|
{
|
|
ReduceRotation();
|
|
}
|
|
else
|
|
{
|
|
Reload();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponMinigun::PrimaryAttack( void )
|
|
{
|
|
CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
|
|
if (!pPlayer)
|
|
return;
|
|
|
|
// Fire the bullets
|
|
Vector vecSrc = pPlayer->Weapon_ShootPosition( );
|
|
Vector vecAiming;
|
|
pPlayer->EyeVectors( &vecAiming );
|
|
|
|
PlayAttackAnimation( GetPrimaryAttackActivity() );
|
|
|
|
// Make a satisfying force, and knock them into the air
|
|
float flForceScale = (100) * 75 * 4;
|
|
Vector vecForce = vecAiming;
|
|
vecForce.z += 0.7;
|
|
vecForce *= flForceScale;
|
|
|
|
CTakeDamageInfo info( this, pPlayer, vecForce, vec3_origin, weapon_minigun_damage.GetFloat(), DMG_BULLET | DMG_BUCKSHOT);
|
|
TFGameRules()->FireBullets( info, weapon_minigun_pellets.GetFloat(),
|
|
vecSrc, vecAiming, GetBulletSpread(), weapon_minigun_range.GetFloat(), m_iPrimaryAmmoType, 0, entindex(), 0 );
|
|
|
|
AddViewKick();
|
|
|
|
m_flNextPrimaryAttack = gpGlobals->curtime + GetFireRate();
|
|
m_iClip1 = m_iClip1 - 1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponMinigun::AddViewKick( void )
|
|
{
|
|
// Get the view kick
|
|
CBaseTFPlayer *pPlayer = ToBaseTFPlayer( GetOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
QAngle viewPunch;
|
|
viewPunch.x = SHARED_RANDOMFLOAT( -0.5f, 0.5f );
|
|
viewPunch.y = SHARED_RANDOMFLOAT( -1.0f, 1.0f );
|
|
viewPunch.z = 0;
|
|
|
|
if ( pPlayer->GetFlags() & FL_DUCKING )
|
|
{
|
|
viewPunch *= 0.25;
|
|
}
|
|
|
|
pPlayer->ViewPunch( viewPunch );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
float CWeaponMinigun::GetFireRate( void )
|
|
{
|
|
float flFireRate = SHARED_RANDOMFLOAT( 0.05, 0.1 );
|
|
|
|
CBaseTFPlayer *pPlayer = static_cast<CBaseTFPlayer*>( GetOwner() );
|
|
if ( pPlayer )
|
|
{
|
|
// Ducking players should fire more rapidly.
|
|
if ( pPlayer->GetFlags() & FL_DUCKING )
|
|
{
|
|
flFireRate *= weapon_minigun_ducking_mod.GetFloat();
|
|
}
|
|
}
|
|
|
|
return flFireRate;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Match the anim speed to the weapon speed while crouching
|
|
//-----------------------------------------------------------------------------
|
|
float CWeaponMinigun::GetDefaultAnimSpeed( void )
|
|
{
|
|
if ( GetOwner() && GetOwner()->IsPlayer() )
|
|
{
|
|
if ( GetOwner()->GetFlags() & FL_DUCKING )
|
|
return (1.0 + (1.0 - weapon_minigun_ducking_mod.GetFloat()) );
|
|
}
|
|
|
|
return 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw the minigun effect
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponMinigun::BulletWasFired( const Vector &vecStart, const Vector &vecEnd )
|
|
{
|
|
UTIL_Tracer( (Vector&)vecStart, (Vector&)vecEnd, entindex(), 1, 5000, false, "MinigunTracer" );
|
|
}
|
|
|
|
#if defined ( CLIENT_DLL )
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CWeaponMinigun::OnFireEvent( C_BaseViewModel *pViewModel, const Vector& origin, const QAngle& angles, int event, const char *options )
|
|
{
|
|
// Suppress the shell ejection from the HL2 model we're using for prototyping
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : updateType -
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponMinigun::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
BaseClass::OnDataChanged( updateType );
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
ClientThinkList()->SetNextClientThink( GetClientHandle(), CLIENT_THINK_ALWAYS );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CWeaponMinigun::ClientThink()
|
|
{
|
|
CBaseTFPlayer *pPlayer = (CBaseTFPlayer*)GetOwner();
|
|
if (!pPlayer)
|
|
return;
|
|
|
|
if ( m_flRotationSpeed )
|
|
{
|
|
WeaponSound_t nSound = SPECIAL1;
|
|
|
|
// If we're firing, play that sound instead
|
|
if ( m_flRotationSpeed >= 0.99 )
|
|
{
|
|
nSound = SINGLE;
|
|
}
|
|
else
|
|
{
|
|
m_bSoundPlaying = true;
|
|
}
|
|
|
|
// If we have some sounds from the weapon classname.txt file, play a random one of them
|
|
const char *shootsound = GetShootSound( nSound );
|
|
if ( !shootsound || !shootsound[0] )
|
|
return;
|
|
|
|
CSoundParameters params;
|
|
if ( !GetParametersForSound( shootsound, params, NULL ) )
|
|
return;
|
|
|
|
// Shift pitch according to barrel rotation
|
|
float flPitch = 30 + (90 * m_flRotationSpeed);
|
|
|
|
CPASAttenuationFilter filter( GetOwner(), params.soundlevel );
|
|
Vector vecOrigin = GetOwner()->GetAbsOrigin();
|
|
|
|
EmitSound_t ep;
|
|
ep.m_nChannel = CHAN_WEAPON;
|
|
ep.m_pSoundName = shootsound;
|
|
ep.m_flVolume = params.volume;
|
|
ep.m_SoundLevel = params.soundlevel;
|
|
ep.m_nFlags = SND_CHANGE_PITCH;
|
|
ep.m_nPitch = (int)flPitch;
|
|
ep.m_pOrigin = &vecOrigin;
|
|
|
|
|
|
EmitSound( filter, GetOwner()->entindex(), ep );
|
|
}
|
|
else if ( m_bSoundPlaying )
|
|
{
|
|
m_bSoundPlaying = false;
|
|
StopWeaponSound( SPECIAL1 );
|
|
StopWeaponSound( SINGLE );
|
|
}
|
|
}
|
|
|
|
#endif |