1497 lines
40 KiB
C++
1497 lines
40 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
#include "cbase.h"
|
|
#include "tf_weapon_minigun.h"
|
|
#include "decals.h"
|
|
#include "in_buttons.h"
|
|
#include "tf_fx_shared.h"
|
|
#include "debugoverlay_shared.h"
|
|
#include "tf_gamerules.h"
|
|
|
|
// Client specific.
|
|
#ifdef CLIENT_DLL
|
|
#include "c_tf_player.h"
|
|
#include "soundenvelope.h"
|
|
#include "achievementmgr.h"
|
|
#include "baseachievement.h"
|
|
#include "achievements_tf.h"
|
|
#include "prediction.h"
|
|
#include "clientmode_tf.h"
|
|
#include "bone_setup.h"
|
|
// NVNT haptics system interface
|
|
#include "haptics/ihaptics.h"
|
|
// Server specific.
|
|
#else
|
|
#include "tf_player.h"
|
|
#include "particle_parse.h"
|
|
#include "tf_gamestats.h"
|
|
#include "baseprojectile.h"
|
|
#endif
|
|
|
|
#define MAX_BARREL_SPIN_VELOCITY 20
|
|
#define TF_MINIGUN_SPINUP_TIME 0.75f
|
|
#define TF_MINIGUN_PENALTY_PERIOD 1.f
|
|
|
|
//=============================================================================
|
|
//
|
|
// Weapon Minigun tables.
|
|
//
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFMinigun, DT_WeaponMinigun )
|
|
|
|
BEGIN_NETWORK_TABLE( CTFMinigun, DT_WeaponMinigun )
|
|
// Client specific.
|
|
#ifdef CLIENT_DLL
|
|
RecvPropInt( RECVINFO( m_iWeaponState ) ),
|
|
RecvPropBool( RECVINFO( m_bCritShot ) )
|
|
// Server specific.
|
|
#else
|
|
SendPropInt( SENDINFO( m_iWeaponState ), 4, SPROP_UNSIGNED | SPROP_CHANGES_OFTEN ),
|
|
SendPropBool( SENDINFO( m_bCritShot ) )
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
#ifdef CLIENT_DLL
|
|
BEGIN_PREDICTION_DATA( CTFMinigun )
|
|
DEFINE_FIELD( m_iWeaponState, FIELD_INTEGER ),
|
|
END_PREDICTION_DATA()
|
|
#endif
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_weapon_minigun, CTFMinigun );
|
|
PRECACHE_WEAPON_REGISTER( tf_weapon_minigun );
|
|
|
|
|
|
// Server specific.
|
|
#ifndef CLIENT_DLL
|
|
BEGIN_DATADESC( CTFMinigun )
|
|
END_DATADESC()
|
|
#endif
|
|
|
|
//=============================================================================
|
|
//
|
|
// Weapon Minigun functions.
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor.
|
|
//-----------------------------------------------------------------------------
|
|
CTFMinigun::CTFMinigun()
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
m_pSoundCur = NULL;
|
|
|
|
m_hEjectBrassWeapon = NULL;
|
|
m_pEjectBrassEffect = NULL;
|
|
m_iEjectBrassAttachment = -1;
|
|
|
|
m_hMuzzleEffectWeapon = NULL;
|
|
m_pMuzzleEffect = NULL;
|
|
m_iMuzzleAttachment = -1;
|
|
|
|
m_nShotsFired = 0;
|
|
|
|
ListenForGameEvent( "teamplay_round_active" );
|
|
ListenForGameEvent( "localplayer_respawn" );
|
|
|
|
m_bRageDraining = false;
|
|
m_bPrevRageDraining = false;
|
|
#endif
|
|
m_bAttack3Down = false;
|
|
|
|
WeaponReset();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor.
|
|
//-----------------------------------------------------------------------------
|
|
CTFMinigun::~CTFMinigun()
|
|
{
|
|
WeaponReset();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::WeaponReset( void )
|
|
{
|
|
BaseClass::WeaponReset();
|
|
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pPlayer )
|
|
{
|
|
pPlayer->m_Shared.RemoveCond( TF_COND_AIMING );
|
|
pPlayer->TeamFortress_SetSpeed();
|
|
|
|
#ifdef GAME_DLL
|
|
pPlayer->ClearWeaponFireScene();
|
|
m_flAegisCheckTime = 0.0f;
|
|
#endif
|
|
|
|
m_flNextRingOfFireAttackTime = 0.0f;
|
|
m_flLastAmmoDrainTime = gpGlobals->curtime;
|
|
m_flAccumulatedAmmoDrain = 0.0f;
|
|
}
|
|
|
|
SetWeaponState( AC_STATE_IDLE );
|
|
m_iWeaponMode = TF_WEAPON_PRIMARY_MODE;
|
|
m_bCritShot = false;
|
|
m_flStartedFiringAt = -1.0f;
|
|
m_flStartedWindUpAt = -1.f;
|
|
m_flNextFiringSpeech = 0.0f;
|
|
|
|
m_flBarrelAngle = 0.0f;
|
|
|
|
m_flBarrelCurrentVelocity = 0.0f;
|
|
m_flBarrelTargetVelocity = 0.0f;
|
|
|
|
#ifdef CLIENT_DLL
|
|
if ( m_pSoundCur )
|
|
{
|
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pSoundCur );
|
|
m_pSoundCur = NULL;
|
|
}
|
|
|
|
m_iMinigunSoundCur = -1;
|
|
m_flMinigunSoundCurrentPitch = 1.0f;
|
|
|
|
StopMuzzleEffect();
|
|
StopBrassEffect();
|
|
#endif
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
int CTFMinigun::UpdateTransmitState( void )
|
|
{
|
|
// ALWAYS transmit to all clients.
|
|
return SetTransmitState( FL_EDICT_ALWAYS );
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::Precache( void )
|
|
{
|
|
PrecacheScriptSound( "Halloween.HeadlessBossAxeHitWorld" );
|
|
|
|
// FIXME: Do we still need these??
|
|
PrecacheScriptSound( "MVM.GiantHeavyGunWindUp" );
|
|
PrecacheScriptSound( "MVM.GiantHeavyGunWindDown" );
|
|
PrecacheScriptSound( "MVM.GiantHeavyGunFire" );
|
|
PrecacheScriptSound( "MVM.GiantHeavyGunSpin" );
|
|
|
|
BaseClass::Precache();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::ItemPostFrame( void )
|
|
{
|
|
// Prevent base code from ever playing empty sounds, minigun handles them manually.
|
|
m_flNextEmptySoundTime = gpGlobals->curtime + 1.0;
|
|
|
|
#ifdef GAME_DLL
|
|
CBasePlayer *pOwner = GetPlayerOwner();
|
|
if ( pOwner )
|
|
{
|
|
if ( ( pOwner->m_nButtons & IN_ATTACK3 ) && !m_bAttack3Down )
|
|
{
|
|
ActivatePushBackAttackMode();
|
|
m_bAttack3Down = true;
|
|
}
|
|
else if ( !( pOwner->m_nButtons & IN_ATTACK3 ) && m_bAttack3Down )
|
|
{
|
|
m_bAttack3Down = false;
|
|
}
|
|
}
|
|
#endif // GAME_DLL
|
|
|
|
BaseClass::ItemPostFrame();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::PrimaryAttack()
|
|
{
|
|
SharedAttack();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::SharedAttack()
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
if ( !CanAttack() )
|
|
{
|
|
WeaponIdle();
|
|
return;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
m_bRageDraining = pPlayer->m_Shared.IsRageDraining();
|
|
#endif // CLIENT_DLL
|
|
|
|
if ( pPlayer->m_nButtons & IN_ATTACK )
|
|
{
|
|
m_iWeaponMode = TF_WEAPON_PRIMARY_MODE;
|
|
}
|
|
else if ( pPlayer->m_nButtons & IN_ATTACK2 )
|
|
{
|
|
m_iWeaponMode = TF_WEAPON_SECONDARY_MODE;
|
|
}
|
|
|
|
switch ( m_iWeaponState )
|
|
{
|
|
default:
|
|
case AC_STATE_IDLE:
|
|
{
|
|
// Removed the need for cells to powerup the AC
|
|
WindUp();
|
|
|
|
float flSpinUpTime = TF_MINIGUN_SPINUP_TIME;
|
|
CALL_ATTRIB_HOOK_FLOAT( flSpinUpTime, mult_minigun_spinup_time );
|
|
|
|
float flSpinTimeMultiplier = Max( flSpinUpTime, 0.00001f );
|
|
if ( pPlayer->GetViewModel( 0 ) )
|
|
{
|
|
pPlayer->GetViewModel( 0 )->SetPlaybackRate( TF_MINIGUN_SPINUP_TIME / flSpinTimeMultiplier );
|
|
}
|
|
if ( pPlayer->GetViewModel( 1 ) )
|
|
{
|
|
pPlayer->GetViewModel( 1 )->SetPlaybackRate( TF_MINIGUN_SPINUP_TIME / flSpinTimeMultiplier );
|
|
}
|
|
|
|
m_flNextPrimaryAttack = gpGlobals->curtime + flSpinUpTime;
|
|
m_flNextSecondaryAttack = gpGlobals->curtime + flSpinUpTime;
|
|
m_flTimeWeaponIdle = gpGlobals->curtime + flSpinUpTime;
|
|
m_flStartedFiringAt = -1.f;
|
|
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_PRE );
|
|
break;
|
|
}
|
|
case AC_STATE_STARTFIRING:
|
|
{
|
|
// Start playing the looping fire sound
|
|
if ( m_flNextPrimaryAttack <= gpGlobals->curtime )
|
|
{
|
|
if ( m_iWeaponMode == TF_WEAPON_SECONDARY_MODE )
|
|
{
|
|
SetWeaponState( AC_STATE_SPINNING );
|
|
}
|
|
else
|
|
{
|
|
SetWeaponState( AC_STATE_FIRING );
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
if ( m_iWeaponState == AC_STATE_SPINNING )
|
|
{
|
|
pPlayer->SpeakWeaponFire( MP_CONCEPT_WINDMINIGUN );
|
|
}
|
|
else
|
|
{
|
|
pPlayer->SpeakWeaponFire( MP_CONCEPT_FIREMINIGUN );
|
|
}
|
|
#endif
|
|
|
|
m_flNextSecondaryAttack = m_flNextPrimaryAttack = m_flTimeWeaponIdle = gpGlobals->curtime + 0.1;
|
|
}
|
|
break;
|
|
}
|
|
case AC_STATE_FIRING:
|
|
{
|
|
if ( m_iWeaponMode == TF_WEAPON_SECONDARY_MODE )
|
|
{
|
|
SetWeaponState( AC_STATE_SPINNING );
|
|
}
|
|
|
|
if ( m_iWeaponState == AC_STATE_SPINNING )
|
|
{
|
|
#ifdef GAME_DLL
|
|
pPlayer->ClearWeaponFireScene();
|
|
pPlayer->SpeakWeaponFire( MP_CONCEPT_WINDMINIGUN );
|
|
#endif
|
|
m_flNextSecondaryAttack = m_flNextPrimaryAttack = m_flTimeWeaponIdle = gpGlobals->curtime + 0.1;
|
|
|
|
}
|
|
else if ( pPlayer->GetAmmoCount(m_iPrimaryAmmoType) <= 0 )
|
|
{
|
|
SetWeaponState( AC_STATE_DRYFIRE );
|
|
}
|
|
else
|
|
{
|
|
if ( m_flStartedFiringAt < 0 )
|
|
{
|
|
m_flStartedFiringAt = gpGlobals->curtime;
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
if ( m_flNextFiringSpeech < gpGlobals->curtime )
|
|
{
|
|
m_flNextFiringSpeech = gpGlobals->curtime + 5.0;
|
|
pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_MINIGUN_FIREWEAPON );
|
|
}
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
int nAmmo = 0;
|
|
if ( prediction->IsFirstTimePredicted() &&
|
|
C_BasePlayer::GetLocalPlayer() == pPlayer )
|
|
{
|
|
nAmmo = pPlayer->GetAmmoCount( m_iPrimaryAmmoType );
|
|
}
|
|
#endif
|
|
|
|
// Only fire if we're actually shooting
|
|
BaseClass::PrimaryAttack(); // fire and do timers
|
|
|
|
#ifdef CLIENT_DLL
|
|
if ( prediction->IsFirstTimePredicted() &&
|
|
C_BasePlayer::GetLocalPlayer() == pPlayer &&
|
|
nAmmo != pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) ) // did PrimaryAttack() fire a shot? (checking our ammo to find out)
|
|
{
|
|
m_nShotsFired++;
|
|
if ( m_nShotsFired == 1000 ) // == and not >= so we don't keep awarding this every shot after it's achieved
|
|
{
|
|
g_AchievementMgrTF.OnAchievementEvent( ACHIEVEMENT_TF_HEAVY_FIRE_LOTS );
|
|
}
|
|
// NVNT the local player fired a shot. notify the haptics system.
|
|
if ( haptics )
|
|
haptics->ProcessHapticEvent(2,"Weapons","minigun_fire");
|
|
}
|
|
#endif
|
|
CalcIsAttackCritical();
|
|
m_bCritShot = IsCurrentAttackACrit();
|
|
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_PRIMARY );
|
|
|
|
#ifdef GAME_DLL
|
|
|
|
int iAttackProjectiles = 0;
|
|
CALL_ATTRIB_HOOK_INT( iAttackProjectiles, attack_projectiles );
|
|
|
|
#ifdef TF_RAID_MODE
|
|
if ( TFGameRules()->IsBossBattleMode() )
|
|
{
|
|
iAttackProjectiles = 1;
|
|
}
|
|
#endif // TF_RAID_MODE
|
|
|
|
if ( iAttackProjectiles )
|
|
{
|
|
AttackEnemyProjectiles();
|
|
}
|
|
|
|
#endif // GAME_DLL
|
|
|
|
m_flTimeWeaponIdle = gpGlobals->curtime + 0.2;
|
|
}
|
|
break;
|
|
}
|
|
case AC_STATE_DRYFIRE:
|
|
{
|
|
m_flStartedFiringAt = -1.f;
|
|
m_flStartedWindUpAt = -1.f;
|
|
|
|
if ( pPlayer->GetAmmoCount(m_iPrimaryAmmoType) > 0 )
|
|
{
|
|
SetWeaponState( AC_STATE_FIRING );
|
|
}
|
|
else if ( m_iWeaponMode == TF_WEAPON_SECONDARY_MODE )
|
|
{
|
|
SetWeaponState( AC_STATE_SPINNING );
|
|
}
|
|
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
|
|
break;
|
|
}
|
|
case AC_STATE_SPINNING:
|
|
{
|
|
m_flStartedFiringAt = -1.f;
|
|
|
|
if ( m_iWeaponMode == TF_WEAPON_PRIMARY_MODE )
|
|
{
|
|
if ( pPlayer->GetAmmoCount(m_iPrimaryAmmoType) > 0 )
|
|
{
|
|
#ifdef GAME_DLL
|
|
pPlayer->ClearWeaponFireScene();
|
|
pPlayer->SpeakWeaponFire( MP_CONCEPT_FIREMINIGUN );
|
|
#endif
|
|
SetWeaponState( AC_STATE_FIRING );
|
|
}
|
|
else
|
|
{
|
|
SetWeaponState( AC_STATE_DRYFIRE );
|
|
}
|
|
}
|
|
|
|
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( pPlayer->GetAmmoCount( m_iPrimaryAmmoType ) > 0 )
|
|
{
|
|
if ( m_iWeaponState > AC_STATE_STARTFIRING )
|
|
{
|
|
int nRingOfFireWhileAiming = 0;
|
|
CALL_ATTRIB_HOOK_INT( nRingOfFireWhileAiming, ring_of_fire_while_aiming );
|
|
if ( nRingOfFireWhileAiming != 0 )
|
|
{
|
|
RingOfFireAttack( nRingOfFireWhileAiming );
|
|
}
|
|
}
|
|
|
|
if ( m_iWeaponState == AC_STATE_SPINNING || m_iWeaponState == AC_STATE_FIRING )
|
|
{
|
|
int nUsesAmmoWhileAiming = 0;
|
|
CALL_ATTRIB_HOOK_INT( nUsesAmmoWhileAiming, uses_ammo_while_aiming );
|
|
if ( nUsesAmmoWhileAiming > 0 )
|
|
{
|
|
m_flAccumulatedAmmoDrain += nUsesAmmoWhileAiming * ( gpGlobals->curtime - m_flLastAmmoDrainTime );
|
|
m_flLastAmmoDrainTime = gpGlobals->curtime;
|
|
|
|
if ( m_flAccumulatedAmmoDrain > 1.0f )
|
|
{
|
|
int nAmmoRemoved = m_flAccumulatedAmmoDrain;
|
|
pPlayer->RemoveAmmo( nAmmoRemoved, m_iPrimaryAmmoType );
|
|
|
|
m_flAccumulatedAmmoDrain -= nAmmoRemoved;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CTFMinigun::SetWeaponState( MinigunState_t nState )
|
|
{
|
|
if ( m_iWeaponState != nState )
|
|
{
|
|
if ( m_iWeaponState == AC_STATE_IDLE || m_iWeaponState == AC_STATE_STARTFIRING || m_iWeaponState == AC_STATE_DRYFIRE )
|
|
{
|
|
// Transitioning from non firing or non fully spinning states resets when our drain start point and when the ring of fire can start
|
|
m_flLastAmmoDrainTime = gpGlobals->curtime;
|
|
m_flNextRingOfFireAttackTime = gpGlobals->curtime + 0.5f;
|
|
}
|
|
|
|
m_iWeaponState = nState;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Fall through to Primary Attack
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::SecondaryAttack( void )
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
SharedAttack();
|
|
}
|
|
|
|
void CTFMinigun::RingOfFireAttack( int nDamage )
|
|
{
|
|
if ( m_flNextRingOfFireAttackTime == 0.0f || m_flNextRingOfFireAttackTime > gpGlobals->curtime )
|
|
return;
|
|
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
#ifdef GAME_DLL
|
|
|
|
Vector vOrigin = pPlayer->GetAbsOrigin();
|
|
const float flFireRadius = 135.0f;
|
|
const float flFireRadiusSqr = flFireRadius * flFireRadius;
|
|
|
|
CBaseEntity *pEntity = NULL;
|
|
for ( CEntitySphereQuery sphere( vOrigin, flFireRadius ); (pEntity = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity() )
|
|
{
|
|
// Skip players on the same team or who are invuln
|
|
CTFPlayer *pVictim = ToTFPlayer( pEntity );
|
|
if ( !pVictim || InSameTeam( pVictim ) || pVictim->m_Shared.InCond( TF_COND_INVULNERABLE ) )
|
|
continue;
|
|
|
|
// Make sure their bounding box is near our ground plane
|
|
Vector vMins = pVictim->GetPlayerMins();
|
|
Vector vMaxs = pVictim->GetPlayerMaxs();
|
|
if ( !( vOrigin.z > pVictim->GetAbsOrigin().z + vMins.z - 32.0f && vOrigin.z < pVictim->GetAbsOrigin().z + vMaxs.z ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// CEntitySphereQuery actually does a box test. So we need to make sure the distance is less than the radius first.
|
|
Vector vecPos;
|
|
pEntity->CollisionProp()->CalcNearestPoint( vOrigin, &vecPos );
|
|
if ( ( vOrigin - vecPos ).LengthSqr() > flFireRadiusSqr )
|
|
continue;
|
|
|
|
// Finally LOS test
|
|
trace_t tr;
|
|
Vector vecSrc = WorldSpaceCenter();
|
|
Vector vecSpot = pEntity->WorldSpaceCenter();
|
|
CTraceFilterSimple filter( this, COLLISION_GROUP_PROJECTILE );
|
|
UTIL_TraceLine( vecSrc, vecSpot, MASK_SOLID_BRUSHONLY, &filter, &tr );
|
|
|
|
// If we don't trace the whole way to the target, and we didn't hit the target entity, we're blocked
|
|
if ( tr.fraction != 1.0 && tr.m_pEnt != pEntity )
|
|
continue;
|
|
|
|
pVictim->TakeDamage( CTakeDamageInfo( pPlayer, pPlayer, this, vec3_origin, vOrigin, nDamage, DMG_PLASMA, 0, &vOrigin ) );
|
|
}
|
|
|
|
DispatchParticleEffect( "heavy_ring_of_fire", pPlayer->GetAbsOrigin(), vec3_angle );
|
|
|
|
#else
|
|
|
|
DispatchParticleEffect( "heavy_ring_of_fire_fp", pPlayer->GetAbsOrigin(), vec3_angle );
|
|
|
|
#endif // #ifdef GAME_DLL
|
|
|
|
m_flNextRingOfFireAttackTime = gpGlobals->curtime + 0.5f;
|
|
}
|
|
|
|
#ifdef GAME_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Scans along a line for rockets and grenades to destroy
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::AttackEnemyProjectiles( void )
|
|
{
|
|
if ( gpGlobals->curtime < m_flAegisCheckTime )
|
|
return;
|
|
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// Parameters
|
|
const int nSweepDist = 300; // How far out
|
|
const int nHitDist = ( pPlayer->IsMiniBoss() ) ? 56 : 38; // How far from the center line (radial)
|
|
float flRechargeTime = 0.1f;
|
|
|
|
// Pos
|
|
const Vector &vecGunPos = ( pPlayer->IsMiniBoss() ) ? pPlayer->Weapon_ShootPosition() : pPlayer->EyePosition();
|
|
Vector vecForward;
|
|
AngleVectors( GetAbsAngles(), &vecForward );
|
|
Vector vecGunAimEnd = vecGunPos + vecForward * (float)nSweepDist;
|
|
|
|
bool bDebug = false;
|
|
if ( bDebug )
|
|
{
|
|
// NDebugOverlay::Sphere( vecGunPos + vecForward * nSweepDist, nSweepDist, 0, 255, 0, 40, 5 );
|
|
NDebugOverlay::Box( vecGunPos, -Vector( 5, 5, 5 ), Vector( 5, 5, 5 ), 255, 0, 0, 40, 5 );
|
|
NDebugOverlay::Box( vecGunAimEnd, -Vector( 5, 5, 5 ), Vector( 5, 5, 5 ), 255, 0, 0, 40, 5 );
|
|
NDebugOverlay::Line( vecGunPos, vecGunAimEnd, 255, 255, 255, true, 5 );
|
|
}
|
|
|
|
// Iterate through each grenade/rocket in the sphere
|
|
const int nMaxEnts = 32;
|
|
CBaseEntity *pObjects[ nMaxEnts ];
|
|
int nCount = UTIL_EntitiesInSphere( pObjects, nMaxEnts, vecGunPos, nSweepDist, FL_GRENADE );
|
|
for ( int i = 0; i < nCount; i++ )
|
|
{
|
|
if ( InSameTeam( pObjects[i] ) )
|
|
continue;
|
|
|
|
// Hit?
|
|
const Vector &vecGrenadePos = pObjects[i]->GetAbsOrigin();
|
|
float flDistToLine = CalcDistanceToLineSegment( vecGrenadePos, vecGunPos, vecGunAimEnd );
|
|
if ( flDistToLine <= nHitDist )
|
|
{
|
|
if ( pPlayer->FVisible( pObjects[i], MASK_SOLID ) == false )
|
|
continue;
|
|
|
|
if ( ( pObjects[i]->GetFlags() & FL_ONGROUND ) )
|
|
continue;
|
|
|
|
if ( !pObjects[i]->IsDeflectable() )
|
|
continue;
|
|
|
|
CBaseProjectile *pProjectile = dynamic_cast< CBaseProjectile* >( pObjects[i] );
|
|
if ( pProjectile && pProjectile->IsDestroyable() )
|
|
{
|
|
pProjectile->IncrementDestroyableHitCount();
|
|
|
|
if ( bDebug )
|
|
{
|
|
NDebugOverlay::Box( vecGrenadePos, -Vector( 5, 5, 5 ), Vector( 5, 5, 5 ), 255, 0, 255, 40, 5 );
|
|
}
|
|
|
|
// Did we destroy it?
|
|
int iAttackProjectiles = 0;
|
|
CALL_ATTRIB_HOOK_INT( iAttackProjectiles, attack_projectiles );
|
|
int nHitsRequired = m_bCritShot ? 1 : (int)RemapValClamped( iAttackProjectiles, 1, 2, 2, 1 );
|
|
if ( pProjectile->GetDestroyableHitCount() >= nHitsRequired )
|
|
{
|
|
pProjectile->Destroy( false, true );
|
|
|
|
EmitSound( "Halloween.HeadlessBossAxeHitWorld" );
|
|
|
|
CTF_GameStats.Event_PlayerAwardBonusPoints( pPlayer, NULL, 2 );
|
|
|
|
// Weaker version has a longer cooldown
|
|
if ( iAttackProjectiles < 2 )
|
|
{
|
|
flRechargeTime = 0.3f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Nicked it
|
|
pObjects[i]->EmitSound( "FX_RicochetSound.Ricochet" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_flAegisCheckTime = gpGlobals->curtime + flRechargeTime;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Reduces damage and adds extra knockback.
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::ActivatePushBackAttackMode( void )
|
|
{
|
|
CTFPlayer *pOwner = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pOwner )
|
|
return;
|
|
|
|
int iRage = 0;
|
|
CALL_ATTRIB_HOOK_INT_ON_OTHER( pOwner, iRage, generate_rage_on_dmg );
|
|
if ( !iRage )
|
|
return;
|
|
|
|
if ( pOwner->m_Shared.IsRageDraining() )
|
|
return;
|
|
|
|
if ( pOwner->m_Shared.GetRageMeter() < 100.f )
|
|
{
|
|
pOwner->EmitSound( "Player.DenyWeaponSelection" );
|
|
return;
|
|
}
|
|
|
|
pOwner->m_Shared.StartRageDrain();
|
|
EmitSound( "Heavy.Battlecry03" );
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: UI Progress (same as GetProgress() without the division by 100.0f)
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFMinigun::IsRageFull( void )
|
|
{
|
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
|
if ( !pPlayer )
|
|
return false;
|
|
|
|
return ( pPlayer->m_Shared.GetRageMeter() >= 100.0f );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFMinigun::EffectMeterShouldFlash( void )
|
|
{
|
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
|
if ( !pPlayer )
|
|
return false;
|
|
|
|
if ( pPlayer && ( IsRageFull() || pPlayer->m_Shared.IsRageDraining() ) )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFMinigun::CanInspect() const
|
|
{
|
|
return BaseClass::CanInspect() && CanHolster();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: UI Progress
|
|
//-----------------------------------------------------------------------------
|
|
float CTFMinigun::GetProgress( void )
|
|
{
|
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
|
if ( !pPlayer )
|
|
return 0.f;
|
|
|
|
return pPlayer->m_Shared.GetRageMeter() / 100.0f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::WindUp( void )
|
|
{
|
|
// Get the player owning the weapon.
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
// Play wind-up animation and sound (SPECIAL1).
|
|
SendWeaponAnim( ACT_MP_ATTACK_STAND_PREFIRE );
|
|
|
|
// Set the appropriate firing state.
|
|
SetWeaponState( AC_STATE_STARTFIRING );
|
|
pPlayer->m_Shared.AddCond( TF_COND_AIMING );
|
|
|
|
#ifndef CLIENT_DLL
|
|
pPlayer->StopRandomExpressions();
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
WeaponSoundUpdate();
|
|
#endif
|
|
|
|
// Update player's speed
|
|
pPlayer->TeamFortress_SetSpeed();
|
|
|
|
if ( m_flStartedWindUpAt == -1.f )
|
|
{
|
|
m_flStartedWindUpAt = gpGlobals->curtime;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFMinigun::CanHolster( void ) const
|
|
{
|
|
bool bCanHolster = CanHolsterWhileSpinning();
|
|
|
|
CTFPlayer *pPlayer = GetTFPlayerOwner();
|
|
if( pPlayer )
|
|
{
|
|
// PASSTIME need to be able to immediately holster when you catch the ball
|
|
if ( pPlayer->m_Shared.HasPasstimeBall() )
|
|
return true;
|
|
|
|
// TF_COND_MELEE_ONLY need to be able to immediately holster and switch to melee weapon
|
|
if ( pPlayer->m_Shared.InCond( TF_COND_MELEE_ONLY ) )
|
|
return true;
|
|
}
|
|
|
|
#ifdef STAGING_ONLY
|
|
// Agility powerup allows holstering while spinning
|
|
bCanHolster |= ( pPlayer && pPlayer->m_Shared.GetCarryingRuneType() == RUNE_AGILITY );
|
|
#endif //STAGING_ONLY
|
|
|
|
if ( bCanHolster )
|
|
{
|
|
if ( m_iWeaponState == AC_STATE_STARTFIRING || m_iWeaponState == AC_STATE_FIRING )
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if ( m_iWeaponState > AC_STATE_IDLE )
|
|
return false;
|
|
|
|
if ( GetActivity() == ACT_MP_ATTACK_STAND_POSTFIRE || GetActivity() == ACT_PRIMARY_ATTACK_STAND_POSTFIRE )
|
|
{
|
|
if ( !IsViewModelSequenceFinished() )
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return BaseClass::CanHolster();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFMinigun::Holster( CBaseCombatWeapon *pSwitchingTo )
|
|
{
|
|
if ( m_iWeaponState > AC_STATE_IDLE )
|
|
{
|
|
WindDown();
|
|
}
|
|
|
|
return BaseClass::Holster( pSwitchingTo );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFMinigun::Lower( void )
|
|
{
|
|
if ( m_iWeaponState > AC_STATE_IDLE )
|
|
{
|
|
WindDown();
|
|
}
|
|
|
|
return BaseClass::Lower();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::WindDown( void )
|
|
{
|
|
// Get the player owning the weapon.
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( !pPlayer )
|
|
return;
|
|
|
|
SendWeaponAnim( ACT_MP_ATTACK_STAND_POSTFIRE );
|
|
|
|
#ifdef CLIENT_DLL
|
|
if ( !HasSpinSounds() && m_iWeaponState == AC_STATE_FIRING )
|
|
{
|
|
PlayStopFiringSound();
|
|
}
|
|
#endif
|
|
|
|
// Set the appropriate firing state.
|
|
SetWeaponState( AC_STATE_IDLE );
|
|
pPlayer->m_Shared.RemoveCond( TF_COND_AIMING );
|
|
#ifdef CLIENT_DLL
|
|
WeaponSoundUpdate();
|
|
#else
|
|
pPlayer->ClearWeaponFireScene();
|
|
#endif
|
|
|
|
// Time to weapon idle.
|
|
m_flTimeWeaponIdle = gpGlobals->curtime + 2.0;
|
|
|
|
// Update player's speed
|
|
pPlayer->TeamFortress_SetSpeed();
|
|
|
|
#ifdef CLIENT_DLL
|
|
m_flBarrelTargetVelocity = 0;
|
|
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( pLocalPlayer && GetOwner() == pLocalPlayer )
|
|
{
|
|
IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_winddown" );
|
|
if ( event )
|
|
{
|
|
gameeventmanager->FireEventClientSide( event );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
m_flStartedWindUpAt = -1.f;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::WeaponIdle()
|
|
{
|
|
if ( gpGlobals->curtime < m_flTimeWeaponIdle )
|
|
return;
|
|
|
|
// Always wind down if we've hit here, because it only happens when the player has stopped firing/spinning
|
|
if ( m_iWeaponState != AC_STATE_IDLE )
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerOwner() );
|
|
if ( pPlayer )
|
|
{
|
|
pPlayer->DoAnimationEvent( PLAYERANIMEVENT_ATTACK_POST );
|
|
}
|
|
|
|
WindDown();
|
|
return;
|
|
}
|
|
|
|
BaseClass::WeaponIdle();
|
|
|
|
m_flTimeWeaponIdle = gpGlobals->curtime + 12.5;// how long till we do this again.
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::FireGameEvent( IGameEvent * event )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
|
|
if ( pLocalPlayer && GetOwner() == pLocalPlayer )
|
|
{
|
|
if ( FStrEq( event->GetName(), "teamplay_round_active" ) ||
|
|
FStrEq( event->GetName(), "localplayer_respawn" ) )
|
|
{
|
|
m_nShotsFired = 0;
|
|
}
|
|
}
|
|
|
|
BaseClass::FireGameEvent( event );
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFMinigun::SendWeaponAnim( int iActivity )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
// Client procedurally animates the barrel bone
|
|
if ( iActivity == ACT_MP_ATTACK_STAND_PRIMARYFIRE || iActivity == ACT_MP_ATTACK_STAND_PREFIRE )
|
|
{
|
|
m_flBarrelTargetVelocity = MAX_BARREL_SPIN_VELOCITY;
|
|
}
|
|
else if ( iActivity == ACT_MP_ATTACK_STAND_POSTFIRE )
|
|
{
|
|
m_flBarrelTargetVelocity = 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
// When we start firing, play the startup firing anim first
|
|
if ( iActivity == ACT_VM_PRIMARYATTACK )
|
|
{
|
|
// If we're already playing the fire anim, let it continue. It loops.
|
|
if ( GetActivity() == ACT_VM_PRIMARYATTACK )
|
|
return true;
|
|
|
|
// Otherwise, play the start it
|
|
return BaseClass::SendWeaponAnim( ACT_VM_PRIMARYATTACK );
|
|
}
|
|
|
|
return BaseClass::SendWeaponAnim( iActivity );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This will force the minigun to turn off the firing sound and play the spinning sound
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::HandleFireOnEmpty( void )
|
|
{
|
|
if ( m_iWeaponState == AC_STATE_FIRING || m_iWeaponState == AC_STATE_SPINNING )
|
|
{
|
|
SetWeaponState( AC_STATE_DRYFIRE );
|
|
|
|
SendWeaponAnim( ACT_VM_SECONDARYATTACK );
|
|
|
|
if ( m_iWeaponMode == TF_WEAPON_SECONDARY_MODE )
|
|
{
|
|
SetWeaponState ( AC_STATE_SPINNING );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
float CTFMinigun::GetProjectileDamage( void )
|
|
{
|
|
float flDamage = BaseClass::GetProjectileDamage();
|
|
|
|
if ( GetFiringDuration() < TF_MINIGUN_PENALTY_PERIOD )
|
|
{
|
|
float flMod = 1.f;
|
|
flMod = RemapValClamped( GetFiringDuration(), 0.2f, TF_MINIGUN_PENALTY_PERIOD, 0.5f, 1.f );
|
|
flDamage *= flMod;
|
|
}
|
|
|
|
return flDamage;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
float CTFMinigun::GetWeaponSpread( void )
|
|
{
|
|
float flSpread = BaseClass::GetWeaponSpread();
|
|
|
|
// How long have we been spun up - sans the min period required to fire
|
|
float flPreFireWindUp = GetWindUpDuration() - TF_MINIGUN_SPINUP_TIME;
|
|
// DevMsg( "PreFireTime: %.2f\n", flPreFireWindUp );
|
|
|
|
if ( GetFiringDuration() < TF_MINIGUN_PENALTY_PERIOD && flPreFireWindUp < 1.f )
|
|
{
|
|
// If we've spun up - prior to pressing fire - reduce accuracy penalty
|
|
float flSpinTime = Max( flPreFireWindUp, GetFiringDuration() );
|
|
const float flMaxSpread = 1.5f;
|
|
float flMod = RemapValClamped( flSpinTime, 0.f, TF_MINIGUN_PENALTY_PERIOD, flMaxSpread, 1.f );
|
|
// DevMsg( "SpreadMod: %.2f\n", flMod );
|
|
|
|
flSpread *= flMod;
|
|
}
|
|
|
|
return flSpread;
|
|
}
|
|
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CStudioHdr *CTFMinigun::OnNewModel( void )
|
|
{
|
|
CStudioHdr *hdr = BaseClass::OnNewModel();
|
|
|
|
m_iBarrelBone = LookupBone( "barrel" );
|
|
|
|
// skip resetting this while recording in the tool
|
|
// we change the weapon to the worldmodel and back to the viewmodel when recording
|
|
// which causes the minigun to not spin while recording
|
|
if ( !IsToolRecording() )
|
|
{
|
|
m_flBarrelAngle = 0;
|
|
|
|
m_flBarrelCurrentVelocity = 0;
|
|
m_flBarrelTargetVelocity = 0;
|
|
}
|
|
|
|
return hdr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::StandardBlendingRules( CStudioHdr *hdr, Vector pos[], Quaternion q[], float currentTime, int boneMask )
|
|
{
|
|
BaseClass::StandardBlendingRules( hdr, pos, q, currentTime, boneMask );
|
|
|
|
if (m_iBarrelBone != -1)
|
|
{
|
|
UpdateBarrelMovement();
|
|
|
|
// Weapon happens to be aligned to (0,0,0)
|
|
// If that changes, use this code block instead to
|
|
// modify the angles
|
|
|
|
/*
|
|
RadianEuler a;
|
|
QuaternionAngles( q[iBarrelBone], a );
|
|
|
|
a.x = m_flBarrelAngle;
|
|
|
|
AngleQuaternion( a, q[iBarrelBone] );
|
|
*/
|
|
|
|
AngleQuaternion( RadianEuler( 0, 0, m_flBarrelAngle ), q[m_iBarrelBone] );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Updates the velocity and position of the rotating barrel
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::UpdateBarrelMovement()
|
|
{
|
|
if ( m_flBarrelCurrentVelocity != m_flBarrelTargetVelocity )
|
|
{
|
|
float flBarrelAcceleration = CanHolsterWhileSpinning() ? 0.5f : 0.1f;
|
|
|
|
// update barrel velocity to bring it up to speed or to rest
|
|
m_flBarrelCurrentVelocity = Approach( m_flBarrelTargetVelocity, m_flBarrelCurrentVelocity, flBarrelAcceleration );
|
|
|
|
if ( 0 == m_flBarrelCurrentVelocity )
|
|
{
|
|
// if we've stopped rotating, turn off the wind-down sound
|
|
WeaponSoundUpdate();
|
|
}
|
|
}
|
|
|
|
// update the barrel rotation based on current velocity
|
|
m_flBarrelAngle += m_flBarrelCurrentVelocity * gpGlobals->frametime;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
// Brass ejection and muzzle flash.
|
|
HandleBrassEffect();
|
|
HandleMuzzleEffect();
|
|
|
|
BaseClass::OnDataChanged( updateType );
|
|
|
|
WeaponSoundUpdate();
|
|
|
|
// Turn off the firing sound here for the Tomislav
|
|
if( m_iPrevMinigunState == AC_STATE_FIRING &&
|
|
( m_iWeaponState == AC_STATE_SPINNING || m_iWeaponState == AC_STATE_IDLE ) )
|
|
{
|
|
if ( !HasSpinSounds() )
|
|
{
|
|
PlayStopFiringSound();
|
|
}
|
|
}
|
|
|
|
m_iPrevMinigunState = m_iWeaponState;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::UpdateOnRemove( void )
|
|
{
|
|
if ( m_pSoundCur )
|
|
{
|
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pSoundCur );
|
|
m_pSoundCur = NULL;
|
|
}
|
|
|
|
// Force the particle system off.
|
|
StopMuzzleEffect();
|
|
StopBrassEffect();
|
|
|
|
BaseClass::UpdateOnRemove();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::SetDormant( bool bDormant )
|
|
{
|
|
// If I'm going from active to dormant and I'm carried by another player, stop our firing sound.
|
|
if ( !IsCarriedByLocalPlayer() )
|
|
{
|
|
// Am I firing? Stop the firing sound.
|
|
if ( !IsDormant() && bDormant && m_iWeaponState >= AC_STATE_FIRING )
|
|
{
|
|
WeaponSoundUpdate();
|
|
}
|
|
|
|
// If firing and going dormant - stop the brass effect.
|
|
if ( !IsDormant() && bDormant && m_iWeaponState != AC_STATE_IDLE )
|
|
{
|
|
StopMuzzleEffect();
|
|
StopBrassEffect();
|
|
}
|
|
}
|
|
|
|
// Deliberately skip base combat weapon
|
|
C_BaseEntity::SetDormant( bDormant );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// won't be called for w_ version of the model, so this isn't getting updated twice
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::ItemPreFrame( void )
|
|
{
|
|
UpdateBarrelMovement();
|
|
BaseClass::ItemPreFrame();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::StartBrassEffect()
|
|
{
|
|
StopBrassEffect();
|
|
|
|
m_hEjectBrassWeapon = GetWeaponForEffect();
|
|
if ( !m_hEjectBrassWeapon )
|
|
return;
|
|
|
|
if ( UsingViewModel() && !g_pClientMode->ShouldDrawViewModel() )
|
|
{
|
|
// Prevent effects when the ViewModel is hidden with r_drawviewmodel=0
|
|
return;
|
|
}
|
|
|
|
// Try and setup the attachment point if it doesn't already exist.
|
|
// This caching will mess up if we go third person from first - we only do this in taunts and don't fire so we should
|
|
// be okay for now.
|
|
if ( m_iEjectBrassAttachment == -1 )
|
|
{
|
|
m_iEjectBrassAttachment = m_hEjectBrassWeapon->LookupAttachment( "eject_brass" );
|
|
}
|
|
|
|
// Start the brass ejection, if a system hasn't already been started.
|
|
if ( m_iEjectBrassAttachment > 0 && m_pEjectBrassEffect == NULL )
|
|
{
|
|
m_pEjectBrassEffect = m_hEjectBrassWeapon->ParticleProp()->Create( "eject_minigunbrass", PATTACH_POINT_FOLLOW, m_iEjectBrassAttachment );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::StartMuzzleEffect()
|
|
{
|
|
StopMuzzleEffect();
|
|
|
|
m_hMuzzleEffectWeapon = GetWeaponForEffect();
|
|
if ( !m_hMuzzleEffectWeapon )
|
|
return;
|
|
|
|
if ( UsingViewModel() && !g_pClientMode->ShouldDrawViewModel() )
|
|
{
|
|
// Prevent effects when the ViewModel is hidden with r_drawviewmodel=0
|
|
return;
|
|
}
|
|
|
|
// Try and setup the attachment point if it doesn't already exist.
|
|
// This caching will mess up if we go third person from first - we only do this in taunts and don't fire so we should
|
|
// be okay for now.
|
|
if ( m_iMuzzleAttachment <= 0 )
|
|
{
|
|
m_iMuzzleAttachment = m_hMuzzleEffectWeapon->LookupAttachment( "muzzle" );
|
|
}
|
|
|
|
// Start the muzzle flash, if a system hasn't already been started.
|
|
if ( m_iMuzzleAttachment > 0 && m_pMuzzleEffect == NULL )
|
|
{
|
|
m_pMuzzleEffect = m_hMuzzleEffectWeapon->ParticleProp()->Create( "muzzle_minigun_constant", PATTACH_POINT_FOLLOW, m_iMuzzleAttachment );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::StopBrassEffect()
|
|
{
|
|
if ( !m_hEjectBrassWeapon )
|
|
return;
|
|
|
|
// Stop the brass ejection.
|
|
if ( m_pEjectBrassEffect )
|
|
{
|
|
m_hEjectBrassWeapon->ParticleProp()->StopEmission( m_pEjectBrassEffect );
|
|
m_hEjectBrassWeapon = NULL;
|
|
m_pEjectBrassEffect = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::StopMuzzleEffect()
|
|
{
|
|
if ( !m_hMuzzleEffectWeapon )
|
|
return;
|
|
|
|
// Stop the muzzle flash.
|
|
if ( m_pMuzzleEffect )
|
|
{
|
|
m_hMuzzleEffectWeapon->ParticleProp()->StopEmission( m_pMuzzleEffect );
|
|
m_hMuzzleEffectWeapon = NULL;
|
|
m_pMuzzleEffect = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::HandleBrassEffect()
|
|
{
|
|
if ( m_iWeaponState == AC_STATE_FIRING && m_pEjectBrassEffect == NULL )
|
|
{
|
|
StartBrassEffect();
|
|
}
|
|
else if ( m_iWeaponState != AC_STATE_FIRING && m_pEjectBrassEffect )
|
|
{
|
|
StopBrassEffect();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::HandleMuzzleEffect()
|
|
{
|
|
if ( m_iWeaponState == AC_STATE_FIRING && m_pMuzzleEffect == NULL )
|
|
{
|
|
StartMuzzleEffect();
|
|
}
|
|
else if ( m_iWeaponState != AC_STATE_FIRING && m_pMuzzleEffect )
|
|
{
|
|
StopMuzzleEffect();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: View model barrel rotation angle. Calculated here, implemented in
|
|
// tf_viewmodel.cpp
|
|
//-----------------------------------------------------------------------------
|
|
float CTFMinigun::GetBarrelRotation( void )
|
|
{
|
|
return m_flBarrelAngle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::ViewModelAttachmentBlending( CStudioHdr *hdr, Vector pos[], Quaternion q[], float currentTime, int boneMask )
|
|
{
|
|
int iBarrelBone = Studio_BoneIndexByName( hdr, "barrel" );
|
|
|
|
// Assert( iBarrelBone != -1 );
|
|
|
|
if ( iBarrelBone != -1 )
|
|
{
|
|
if ( hdr->boneFlags( iBarrelBone ) & boneMask )
|
|
{
|
|
RadianEuler a;
|
|
QuaternionAngles( q[iBarrelBone], a );
|
|
|
|
a.z = GetBarrelRotation();
|
|
|
|
AngleQuaternion( a, q[iBarrelBone] );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::CreateMove( float flInputSampleTime, CUserCmd *pCmd, const QAngle &vecOldViewAngles )
|
|
{
|
|
// Prevent jumping while firing
|
|
if ( m_iWeaponState != AC_STATE_IDLE )
|
|
{
|
|
pCmd->buttons &= ~IN_JUMP;
|
|
}
|
|
|
|
BaseClass::CreateMove( flInputSampleTime, pCmd, vecOldViewAngles );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Ensures the correct sound (including silence) is playing for
|
|
// current weapon state.
|
|
//-----------------------------------------------------------------------------
|
|
void CTFMinigun::WeaponSoundUpdate()
|
|
{
|
|
// determine the desired sound for our current state
|
|
int iSound = -1;
|
|
switch ( m_iWeaponState )
|
|
{
|
|
case AC_STATE_IDLE:
|
|
if ( !HasSpinSounds() && m_iMinigunSoundCur == SPECIAL2 )
|
|
{
|
|
// Don't turn off SPECIAL2 (stop firing sound) for non spinning miniguns.
|
|
// We don't have a wind-down sound.
|
|
return;
|
|
}
|
|
else if ( HasSpinSounds() && m_flBarrelCurrentVelocity > 0 )
|
|
{
|
|
iSound = SPECIAL2; // wind down sound
|
|
|
|
if ( m_flBarrelTargetVelocity > 0 )
|
|
{
|
|
m_flBarrelTargetVelocity = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iSound = -1;
|
|
}
|
|
break;
|
|
case AC_STATE_STARTFIRING:
|
|
iSound = SPECIAL1; // wind up sound
|
|
break;
|
|
case AC_STATE_FIRING:
|
|
{
|
|
if ( m_bCritShot == true )
|
|
{
|
|
iSound = BURST; // Crit sound
|
|
}
|
|
else
|
|
{
|
|
iSound = WPN_DOUBLE; // firing sound
|
|
}
|
|
}
|
|
break;
|
|
case AC_STATE_SPINNING:
|
|
if ( HasSpinSounds() )
|
|
iSound = SPECIAL3; // spinning sound
|
|
else
|
|
return;
|
|
break;
|
|
case AC_STATE_DRYFIRE:
|
|
iSound = EMPTY; // out of ammo, still trying to fire
|
|
break;
|
|
default:
|
|
Assert( false );
|
|
break;
|
|
}
|
|
|
|
// Get the pitch we should play at
|
|
float flPitch = 1.0f;
|
|
|
|
float flSpeed = ApplyFireDelay( 1.0f );
|
|
if ( flSpeed != 1.0f )
|
|
{
|
|
flPitch = RemapValClamped( flSpeed, 1.5f, 0.5f, 80.f, 120.f );
|
|
}
|
|
|
|
if ( m_bRageDraining )
|
|
{
|
|
flPitch /= 1.65;
|
|
}
|
|
|
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
|
|
// if we're already playing the desired sound, nothing to do
|
|
if ( m_iMinigunSoundCur == iSound && m_bPrevRageDraining == m_bRageDraining )
|
|
{
|
|
// If the pitch is different we need to modify it
|
|
if ( m_flMinigunSoundCurrentPitch != flPitch )
|
|
{
|
|
m_flMinigunSoundCurrentPitch = flPitch;
|
|
|
|
if ( m_pSoundCur )
|
|
{
|
|
controller.SoundChangePitch( m_pSoundCur, m_flMinigunSoundCurrentPitch, 0.3f );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// if we're playing some other sound, stop it
|
|
if ( m_pSoundCur )
|
|
{
|
|
// Stop the previous sound immediately
|
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pSoundCur );
|
|
m_pSoundCur = NULL;
|
|
}
|
|
m_iMinigunSoundCur = iSound;
|
|
// if there's no sound to play for current state, we're done
|
|
if ( -1 == iSound )
|
|
return;
|
|
|
|
m_flMinigunSoundCurrentPitch = flPitch;
|
|
|
|
// play the appropriate sound
|
|
const char *shootsound = GetShootSound( iSound );
|
|
CLocalPlayerFilter filter;
|
|
m_pSoundCur = controller.SoundCreate( filter, entindex(), shootsound );
|
|
controller.Play( m_pSoundCur, 1.0, 100 );
|
|
controller.SoundChangeVolume( m_pSoundCur, 1.0, 0.1 );
|
|
|
|
if ( m_flMinigunSoundCurrentPitch != 1.0f )
|
|
{
|
|
controller.SoundChangePitch( m_pSoundCur, m_flMinigunSoundCurrentPitch, 0.0 );
|
|
}
|
|
|
|
m_bPrevRageDraining = m_bRageDraining;
|
|
}
|
|
|
|
void CTFMinigun::PlayStopFiringSound()
|
|
{
|
|
if ( m_pSoundCur )
|
|
{
|
|
CSoundEnvelopeController::GetController().SoundDestroy( m_pSoundCur );
|
|
m_pSoundCur = NULL;
|
|
}
|
|
|
|
m_iMinigunSoundCur = SPECIAL2;
|
|
|
|
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
|
|
const char *shootsound = GetShootSound( SPECIAL2 );
|
|
CLocalPlayerFilter filter;
|
|
m_pSoundCur = controller.SoundCreate( filter, entindex(), shootsound );
|
|
controller.Play( m_pSoundCur, 1.0, 100 );
|
|
controller.SoundChangeVolume( m_pSoundCur, 1.0, 0.1 );
|
|
}
|
|
|
|
#endif
|