1HEADmaster

1 files changed, 1496 insertions, 0 deletions

diff --git a/game/shared/tf/tf_weapon_minigun.cpp b/game/shared/tf/tf_weapon_minigun.cpp
new file mode 100644
index 0000000..1f5a4fd
--- /dev/null
+++ b/game/shared/tf/tf_weapon_minigun.cpp
@@ -0,0 +1,1496 @@
+//========= 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