const char *CASW_Weapon::GetASWShootSound( int iIndex, int &iPitch )
{
if ( iIndex == SINGLE || iIndex == SINGLE_NPC )
{
iIndex = IsCarriedByLocalPlayer() ? SINGLE : SINGLE_NPC;
}
if ( iIndex == WPN_DOUBLE || iIndex == DOUBLE_NPC )
{
iIndex = IsCarriedByLocalPlayer() ? WPN_DOUBLE : DOUBLE_NPC;
}
if ( iIndex == RELOAD || iIndex == RELOAD_NPC )
{
iIndex = IsCarriedByLocalPlayer() ? RELOAD : RELOAD_NPC;
// play the weapon sound according to marine skill
int iSkill = MarineSkills()->GetSkillBasedValueByMarine(GetMarine(), ASW_MARINE_SKILL_RELOADING, ASW_MARINE_SUBSKILL_RELOADING_SOUND);
switch (iSkill)
{
case 5: return GetWpnData().aShootSounds[ FAST_RELOAD ]; break;
case 4: iPitch = 120; return GetWpnData().aShootSounds[ iIndex ]; break;
case 3: iPitch = 115; return GetWpnData().aShootSounds[ iIndex ]; break;
case 2: iPitch = 110; return GetWpnData().aShootSounds[ iIndex ]; break;
case 1: iPitch = 105; return GetWpnData().aShootSounds[ iIndex ]; break;
default: return GetWpnData().aShootSounds[ iIndex ]; break;
};
}
return GetShootSound( iIndex );
}
void CHL2MPScriptedWeapon::Precache( void )
{
BaseClass::Precache();
InitScriptedWeapon();
// Get the ammo indexes for the ammo's specified in the data file
if ( GetWpnData().szAmmo1[0] )
{
m_iPrimaryAmmoType = GetAmmoDef()->Index( GetWpnData().szAmmo1 );
if (m_iPrimaryAmmoType == -1)
{
Msg("ERROR: Weapon (%s) using undefined primary ammo type (%s)\n",GetClassname(), GetWpnData().szAmmo1);
}
}
if ( GetWpnData().szAmmo2[0] )
{
m_iSecondaryAmmoType = GetAmmoDef()->Index( GetWpnData().szAmmo2 );
if (m_iSecondaryAmmoType == -1)
{
Msg("ERROR: Weapon (%s) using undefined secondary ammo type (%s)\n",GetClassname(),GetWpnData().szAmmo2);
}
}
// Precache models (preload to avoid hitch)
m_iViewModelIndex = 0;
m_iWorldModelIndex = 0;
if ( GetViewModel() && GetViewModel()[0] )
{
m_iViewModelIndex = CBaseEntity::PrecacheModel( GetViewModel() );
}
if ( GetWorldModel() && GetWorldModel()[0] )
{
m_iWorldModelIndex = CBaseEntity::PrecacheModel( GetWorldModel() );
}
// Precache sounds, too
for ( int i = 0; i < NUM_SHOOT_SOUND_TYPES; ++i )
{
const char *shootsound = GetShootSound( i );
if ( shootsound && shootsound[0] )
{
CBaseEntity::PrecacheScriptSound( shootsound );
}
}
#if defined ( LUA_SDK ) && !defined( CLIENT_DLL )
BEGIN_LUA_CALL_WEAPON_METHOD( "Precache" );
END_LUA_CALL_WEAPON_METHOD( 0, 0 );
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFFlameThrower::StopFlame( bool bAbrupt /* = false */ )
{
if ( ( m_pFiringLoop || m_pFiringStartSound ) && !bAbrupt )
{
// play a quick wind-down poof when the flame stops
CLocalPlayerFilter filter;
const char *shootsound = GetShootSound( SPECIAL3 );
EmitSound( filter, entindex(), shootsound );
}
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
if ( m_pFiringLoop )
{
controller.SoundDestroy( m_pFiringLoop );
m_pFiringLoop = NULL;
}
if ( m_pFiringStartSound )
{
controller.SoundDestroy( m_pFiringStartSound );
m_pFiringStartSound = NULL;
}
if ( m_pFlameEffect )
{
if ( m_hFlameEffectHost.Get() )
{
m_hFlameEffectHost->ParticleProp()->StopEmission( m_pFlameEffect );
m_hFlameEffectHost = NULL;
}
m_pFlameEffect = NULL;
}
if ( !bAbrupt )
{
if ( m_pHitTargetSound )
{
controller.SoundDestroy( m_pHitTargetSound );
m_pHitTargetSound = NULL;
}
m_bOldHitTarget = false;
m_bHitTarget = false;
}
m_iParticleWaterLevel = -1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFFlameThrower::StartPilotLight()
{
if ( !m_pPilotLightSound )
{
StopFlame();
// Create the looping pilot light sound
const char *pilotlightsound = GetShootSound( SPECIAL2 );
CLocalPlayerFilter filter;
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
m_pPilotLightSound = controller.SoundCreate( filter, entindex(), pilotlightsound );
controller.Play( m_pPilotLightSound, 1.0, 100 );
}
}
void CWeaponDODBase::PlayWorldReloadSound( CDODPlayer *pPlayer )
{
Assert( pPlayer );
const char *shootsound = GetShootSound( RELOAD );
if ( !shootsound || !shootsound[0] )
return;
CSoundParameters params;
if ( !GetParametersForSound( shootsound, params, NULL ) )
return;
// Play weapon sound from the owner
CPASAttenuationFilter filter( pPlayer, params.soundlevel );
filter.RemoveRecipient( pPlayer ); // no local player, that is done in the model
EmitSound( filter, pPlayer->entindex(), shootsound, NULL, 0.0 );
}
//-----------------------------------------------------------------------------
// 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 ( m_flBarrelCurrentVelocity > 0 )
{
iSound = SPECIAL2; // wind down sound
#ifdef CLIENT_DLL
if ( m_flBarrelTargetVelocity > 0 )
{
m_flBarrelTargetVelocity = 0;
}
#endif
}
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:
iSound = SPECIAL3; // spinning sound
break;
case AC_STATE_DRYFIRE:
iSound = EMPTY; // out of ammo, still trying to fire
break;
default:
Assert( false );
break;
}
// if we're already playing the desired sound, nothing to do
if ( m_iMinigunSoundCur == iSound )
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;
// play the appropriate sound
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
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 );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFFlameThrower::StartFlame()
{
if ( m_iWeaponState == FT_STATE_AIRBLASTING )
{
C_BaseEntity *pModel = GetWeaponForEffect();
if ( pModel )
{
pModel->ParticleProp()->Create( "pyro_blast", PATTACH_POINT_FOLLOW, "muzzle" );
}
//CLocalPlayerFilter filter;
//EmitSound( filter, entindex(), "Weapon_FlameThrower.AirBurstAttack" );
}
else
{
CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
// normally, crossfade between start sound & firing loop in 3.5 sec
float flCrossfadeTime = 3.5;
if ( m_pFiringLoop && ( m_bCritFire != m_bFiringLoopCritical ) )
{
// If we're firing and changing between critical & noncritical, just need to change the firing loop.
// Set crossfade time to zero so we skip the start sound and go to the loop immediately.
flCrossfadeTime = 0;
StopFlame( true );
}
StopPilotLight();
if ( !m_pFiringStartSound && !m_pFiringLoop )
{
RestartParticleEffect();
CLocalPlayerFilter filter;
// Play the fire start sound
const char *shootsound = GetShootSound( SINGLE );
if ( flCrossfadeTime > 0.0 )
{
// play the firing start sound and fade it out
m_pFiringStartSound = controller.SoundCreate( filter, entindex(), shootsound );
controller.Play( m_pFiringStartSound, 1.0, 100 );
controller.SoundChangeVolume( m_pFiringStartSound, 0.0, flCrossfadeTime );
}
// Start the fire sound loop and fade it in
if ( m_bCritFire )
{
shootsound = GetShootSound( BURST );
}
else
{
shootsound = GetShootSound( SPECIAL1 );
}
m_pFiringLoop = controller.SoundCreate( filter, entindex(), shootsound );
m_bFiringLoopCritical = m_bCritFire;
// play the firing loop sound and fade it in
if ( flCrossfadeTime > 0.0 )
{
controller.Play( m_pFiringLoop, 0.0, 100 );
controller.SoundChangeVolume( m_pFiringLoop, 1.0, flCrossfadeTime );
}
else
{
controller.Play( m_pFiringLoop, 1.0, 100 );
}
}
if( m_bHitTarget != m_bOldHitTarget )
{
if ( m_bHitTarget )
{
CLocalPlayerFilter filter;
m_pHitTargetSound = controller.SoundCreate( filter, entindex(), "Weapon_FlameThrower.FireHit" );
controller.Play( m_pHitTargetSound, 1.0f, 100.0f );
}
else if ( m_pHitTargetSound )
{
controller.SoundDestroy( m_pHitTargetSound );
m_pHitTargetSound = NULL;
}
m_bOldHitTarget = m_bHitTarget;
}
}
}
