// Copyright (C) 2007 Id Software, Inc.
//


#include "../precompiled.h"
#pragma hdrstop

#if defined( _DEBUG ) && !defined( ID_REDIRECT_NEWDELETE )
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#include "SoundControl.h"
#include "../Player.h"
#include "Transport.h"
#include "../../decllib/DeclSurfaceType.h"
#include "JetPack.h"

/*
===============================================================================

	sdVehicleSoundControlBase

===============================================================================
*/

sdVehicleSoundControlBase::soundControlFactory_t sdVehicleSoundControlBase::s_factory;

/*
================
sdVehicleSoundControlBase::Init
================
*/
void sdVehicleSoundControlBase::Init( sdTransport* transport ) {
	owner = transport;
}

/*
================
sdVehicleSoundControlBase::Startup
================
*/
void sdVehicleSoundControlBase::Startup( void ) {
	s_factory.RegisterType( "husky", soundControlFactory_t::Allocator< sdVehicleSoundControl_Wheeled > );
	s_factory.RegisterType( "badger", soundControlFactory_t::Allocator< sdVehicleSoundControl_Wheeled > );
	s_factory.RegisterType( "trojan", soundControlFactory_t::Allocator< sdVehicleSoundControl_Wheeled > );
	s_factory.RegisterType( "wheeled", soundControlFactory_t::Allocator< sdVehicleSoundControl_Wheeled > );
	s_factory.RegisterType( "tracked", soundControlFactory_t::Allocator< sdVehicleSoundControl_Tracked > );
	s_factory.RegisterType( "helicopter", soundControlFactory_t::Allocator< sdVehicleSoundControl_Helicopter > );
	s_factory.RegisterType( "jetpack", soundControlFactory_t::Allocator< sdVehicleSoundControl_JetPack > );
	s_factory.RegisterType( "speedboat", soundControlFactory_t::Allocator< sdVehicleSoundControl_SpeedBoat > );
}

/*
================
sdVehicleSoundControlBase::Shutdown
================
*/
void sdVehicleSoundControlBase::Shutdown( void ) {
	s_factory.Shutdown();
}

/*
================
sdVehicleSoundControlBase::InWater
================
*/
bool sdVehicleSoundControlBase::InWater( void ) const {
	return owner->GetPhysics()->InWater() > 0.0005f;
}

/*
================
sdVehicleSoundControlBase::Submerged
================
*/
bool sdVehicleSoundControlBase::Submerged( void ) const {
	return owner->GetPhysics()->InWater() > 0.5f;
}

/*
================
sdVehicleSoundControlBase::Alloc
================
*/
sdVehicleSoundControlBase* sdVehicleSoundControlBase::Alloc( const char* name ) {
	return s_factory.CreateType( name );
}


/*
===============================================================================

	sdVehicleSoundControl_Simple

===============================================================================
*/

/*
================
sdVehicleSoundControl_Simple::Init
================
*/
void sdVehicleSoundControl_Simple::Init( sdTransport* transport ) {
	sdVehicleSoundControlBase::Init( transport );

	lowPitch			= owner->spawnArgs.GetFloat( "engine_pitch_low" );
	highPitch			= owner->spawnArgs.GetFloat( "engine_pitch_high" );
	lowSpeed			= owner->spawnArgs.GetFloat( "engine_speed_low" );
	highSpeed			= owner->spawnArgs.GetFloat( "engine_speed_high" );

	maxSoundLevel		= owner->spawnArgs.GetFloat( "max_sound_level", "-5" );

	maxHornWaterLevel	= owner->spawnArgs.GetFloat( "max_horn_water_level", "0.5" );
}

/*
================
sdVehicleSoundControl_Simple::CalcSoundParms
================
*/
void sdVehicleSoundControl_Simple::CalcSoundParms( soundParms_t& parms ) const {
	parms.inWater		= InWater();
	parms.submerged		= Submerged();
	parms.speedKPH		= UPStoKPH( owner->GetPhysics()->GetLinearVelocity() * owner->GetPhysics()->GetAxis()[ 0 ] );
	parms.absSpeedKPH	= idMath::Fabs( parms.speedKPH );

	parms.newSoundLevel = maxSoundLevel - ( 1.0f / ( 0.01f * ( parms.absSpeedKPH + 0.00001f ) ) );

	float speedDiff = parms.absSpeedKPH - lowSpeed;
	if ( speedDiff < 0.0f ) {
		speedDiff = 0.0f;
	}

	if ( parms.speedKPH < 0.5f || ( parms.inWater && !owner->IsAmphibious() ) ) {
		parms.newSoundPitch = lowPitch;
	} else {
		parms.newSoundPitch = Lerp( lowPitch, highPitch, speedDiff / ( highSpeed - lowSpeed ) );
	}
}

/*
================
sdVehicleSoundControl_Simple::OnSurfaceTypeChanged
================
*/
void sdVehicleSoundControl_Simple::OnSurfaceTypeChanged( const sdDeclSurfaceType* surfaceType ) {
	groundIsOffRoad = false;

	if ( surfaceType == NULL ) {
		groundSurfaceType = "";
		return;
	}

	if ( surfaceType->GetProperties().GetBool( "offroad" ) ) {
		groundSurfaceType = "_offroad";
		groundIsOffRoad = true;
	} else {
		groundSurfaceType = "_";
		groundSurfaceType += surfaceType->GetType();
	}
}

/*
================
sdVehicleSoundControl_Simple::StartHornSound
================
*/
void sdVehicleSoundControl_Simple::StartHornSound( void ) {
	if ( owner->GetPhysics()->InWater() > maxHornWaterLevel ) {
		StopHornSound();
		return;
	}

	if ( simpleSoundFlags.playingHornSound ) {
		return;
	}
	simpleSoundFlags.playingHornSound = true;

	owner->StartSound( "snd_horn_loop", SND_VEHICLE_HORN, 0, NULL );	
}

/*
================
sdVehicleSoundControl_Simple::StopHornSound
================
*/
void sdVehicleSoundControl_Simple::StopHornSound( void ) {
	if ( !simpleSoundFlags.playingHornSound ) {
		return;
	}
	simpleSoundFlags.playingHornSound = false;

	owner->StartSound( "snd_horn_stop", SND_VEHICLE_HORN, 0, NULL );
}

/*
================
sdVehicleSoundControl_Simple::StartCockpitSound
================
*/
void sdVehicleSoundControl_Simple::StartCockpitSound( void ) {
	if ( simpleSoundFlags.playingCockpitSound ) {
		return;
	}
	simpleSoundFlags.playingCockpitSound = true;

	if ( !owner->IsWeaponEMPed() ) {
		owner->StartSound( "snd_cockpit", SND_VEHICLE_INTERIOR, 0, NULL );
	} else {
		owner->StartSound( "snd_cockpit_emped", SND_VEHICLE_INTERIOR, 0, NULL );
	}
}

/*
================
sdVehicleSoundControl_Simple::StopCockpitSound
================
*/
void sdVehicleSoundControl_Simple::StopCockpitSound( void ) {
	if ( !simpleSoundFlags.playingCockpitSound ) {
		return;
	}
	simpleSoundFlags.playingCockpitSound = false;

	owner->StopSound( SND_VEHICLE_INTERIOR );
}

/*
================
sdVehicleSoundControl_Simple::OnEMPStateChanged
================
*/
void sdVehicleSoundControl_Simple::OnEMPStateChanged( void ) {
	idPlayer* driver = owner->GetPositionManager().FindDriver();
	if ( !owner->IsEMPed() ) {
		if ( driver != NULL ) {
			owner->StartSound( "snd_engine_start", SND_VEHICLE_DRIVE, 0, NULL );
			owner->StartSound( "snd_engine_start_interior", SND_VEHICLE_INTERIOR_DRIVE, 0, NULL );
		}
	} else {
		if ( driver != NULL ) {
			owner->StartSound( "snd_engine_stop", SND_VEHICLE_DRIVE, 0, NULL );
			owner->StartSound( "snd_engine_stop_interior", SND_VEHICLE_INTERIOR_DRIVE, 0, NULL );
		}
	}
}

/*
================
sdVehicleSoundControl_Simple::OnWeaponEMPStateChanged
================
*/
void sdVehicleSoundControl_Simple::OnWeaponEMPStateChanged( void ) {
	StopCockpitSound();
	if ( !owner->GetPositionManager().IsEmpty() ) {
		if ( !owner->IsWeaponEMPed() ) {
			owner->StartSound( "snd_cockpit_end_emped", SND_VEHICLE_INTERIOR_POWERUP, 0, NULL );
		}
		StartCockpitSound();
	}
}

/*
===============================================================================

	sdVehicleSoundControl_CrossFade

===============================================================================
*/

/*
================
sdVehicleSoundControl_CrossFade::Init
================
*/
void sdVehicleSoundControl_CrossFade::Init( sdTransport* transport ) {
	sdVehicleSoundControl_Simple::Init( transport );

	accelSpoolTime = transport->spawnArgs.GetFloat( "engine_accel_spool_time", "0.17" );
	decelSpoolTime = transport->spawnArgs.GetFloat( "engine_decel_spool_time", "0.25" );

	idleMinSpeed = transport->spawnArgs.GetFloat( "engine_idle_min_speed", "22.0" );
	idleMaxSpeed = transport->spawnArgs.GetFloat( "engine_idle_max_speed", "30.0" );
	idleMinVol = transport->spawnArgs.GetFloat( "engine_idle_min_vol", "0.0" );
	idleMaxVol = transport->spawnArgs.GetFloat( "engine_idle_max_vol", "-15.0" );
	idlePower = transport->spawnArgs.GetFloat( "engine_idle_power", "1.0" );
	idleFadeTime = transport->spawnArgs.GetFloat( "engine_idle_fade_time", "0.066" );

	driveMinSpeed = transport->spawnArgs.GetFloat( "engine_drive_min_speed", "0.0" );
	driveMaxSpeed = transport->spawnArgs.GetFloat( "engine_drive_max_speed", "30.0" );
	driveMinVol = transport->spawnArgs.GetFloat( "engine_drive_min_vol", "-10.0" );
	driveMaxVol = transport->spawnArgs.GetFloat( "engine_drive_max_vol", "0.0" );
	drivePower = transport->spawnArgs.GetFloat( "engine_drive_power", "0.5" );
	driveFadeTime = transport->spawnArgs.GetFloat( "engine_drive_fade_time", "0.066" );

	accelPitchMultiplier = transport->spawnArgs.GetFloat( "engine_accel_pitch_mult", "3.0" );
	accelPitchOffset = transport->spawnArgs.GetFloat( "engine_accel_pitch_offset", "1.0" );

	accelMinSpeed = transport->spawnArgs.GetFloat( "engine_accel_min_speed", "0.0" );
	accelMidSpeed = transport->spawnArgs.GetFloat( "engine_accel_mid_speed", "5.0" );
	accelMaxSpeed = transport->spawnArgs.GetFloat( "engine_accel_max_speed", "30.0" );
	accelMinVol = transport->spawnArgs.GetFloat( "engine_accel_min_vol", "-10.0" );
	accelMidVol = transport->spawnArgs.GetFloat( "engine_accel_mid_vol", "5.0" );
	accelMaxVol = transport->spawnArgs.GetFloat( "engine_accel_max_vol", "-10.0" );
	accelPowerLow = transport->spawnArgs.GetFloat( "engine_accel_power_low", "0.1" );
	accelPowerHigh = transport->spawnArgs.GetFloat( "engine_accel_power_high", "3.0" );
	accelFadeTime = transport->spawnArgs.GetFloat( "engine_accel_fade_time", "0.0" );

	accelYawVolume = transport->spawnArgs.GetFloat( "engine_accel_yaw_vol", "0.0" );
	accelYawVolumeMultiplier = transport->spawnArgs.GetFloat( "engine_accel_yaw_vol_mult", "0.0" );
	accelYawPitch = transport->spawnArgs.GetFloat( "engine_accel_yaw_pitch", "0.0" );
	accelYawPitchMultiplier = transport->spawnArgs.GetFloat( "engine_accel_yaw_pitch_mult", "0.0" );

	engineSpeed = 0.0f;
	lastVolumeIncreaseValue = 0.0f;
}

/*
================
sdVehicleSoundControl_CrossFade::CalcSoundParmsAdvanced
================
*/
void sdVehicleSoundControl_CrossFade::CalcSoundParmsAdvanced( soundParmsAdvanced_t& parms ) {
	sdVehicleSoundControl_Simple::CalcSoundParms( parms.simple );
	const sdVehicleInput& input = owner->GetInput();

	if ( parms.simple.absSpeedKPH > engineSpeed ) {
		engineSpeed = Lerp( engineSpeed, parms.simple.absSpeedKPH, MS2SEC( gameLocal.msec ) / accelSpoolTime );
	} else {
		engineSpeed = Lerp( engineSpeed, parms.simple.absSpeedKPH, MS2SEC( gameLocal.msec ) / decelSpoolTime );
	}

	engineSpeed -= 1.0f;
	if ( engineSpeed < 0.0001f ) {
		engineSpeed = 0.0f;
	}

#define FADE_SOUND( speed, minSpeed, maxSpeed, minVol, maxVol, power ) ( idMath::Pow( idMath::ClampFloat( 0.0f, 1.0f, ( speed - minSpeed ) / ( maxSpeed - minSpeed ) ), power ) * ( maxVol - minVol ) + minVol )
#define FADE_SOUND_2( speed, minSpeed, midSpeed, maxSpeed, minVol, midVol, maxVol, loPower, hiPower ) ( speed < midSpeed ? FADE_SOUND( speed, minSpeed, midSpeed, minVol, midVol, loPower ) : FADE_SOUND( speed, midSpeed, maxSpeed, midVol, maxVol, hiPower ) )

	parms.idleVolume = FADE_SOUND( engineSpeed, idleMinSpeed, idleMaxSpeed, idleMinVol, idleMaxVol, idlePower );
	parms.driveVolume = FADE_SOUND( engineSpeed, driveMinSpeed, driveMaxSpeed, driveMinVol, driveMaxVol, drivePower );

	// accel sound volume & pitch depends on the status of the inputs too
	float currentAccelPitchOffset = accelPitchOffset;
	float accelEngineSpeed = engineSpeed;
	float yawVel = RAD2DEG( owner->GetPhysics()->GetAngularVelocity() * owner->GetPhysics()->GetAxis()[ 2 ] );
	if ( accelYawVolume > 0.0f ) {
		accelEngineSpeed += accelYawVolumeMultiplier * idMath::ClampFloat( 0.0f, 1.0f, idMath::Fabs( yawVel ) / accelYawVolume );
	}
	if ( accelYawPitch > 0.0f ) {
		currentAccelPitchOffset += accelYawPitchMultiplier * idMath::ClampFloat( 0.0f, 1.0f, idMath::Fabs( yawVel ) / accelYawPitch );
	}
	
	float volumeIncreaseValue = 0.0f;
	float inputVal = 0.0f;
	if ( owner->GetPhysics()->HasGroundContacts() || ( owner->GetPhysics()->InWater() && owner->IsAmphibious() ) ) {
		inputVal = input.GetForward() > 0.0f ? input.GetForward() : -input.GetForward() * 0.3f;
		if ( accelYawVolumeMultiplier > 0.0f ) {
			inputVal = Max( inputVal, idMath::Fabs( input.GetRight() ) );
		}
		float midVol = inputVal * accelMidVol;
		if ( inputVal > 0.01f ) {
			volumeIncreaseValue = 0.3f;

			// factor in some of the up-vector
			float upNess = RAD2DEG( idMath::ACos( idMath::ClampFloat( 0.0f, 1.0f, owner->GetPhysics()->GetAxis()[ 0 ].z ) ) );
			upNess = 1.0f - upNess / 90.0f;
			//accelEngineSpeed = Lerp( accelEngineSpeed, accelMidSpeed, upNess );
			volumeIncreaseValue = Max( upNess, volumeIncreaseValue );
		}
	}

	if ( volumeIncreaseValue < lastVolumeIncreaseValue ) {
		volumeIncreaseValue = Lerp( lastVolumeIncreaseValue, volumeIncreaseValue, MS2SEC( gameLocal.msec ) / 0.3f );
	}
	if ( volumeIncreaseValue < 0.0001f ) {
		volumeIncreaseValue = 0.0f;
	}
	lastVolumeIncreaseValue = volumeIncreaseValue;

	parms.accelVolume = FADE_SOUND_2( accelEngineSpeed, accelMinSpeed, accelMidSpeed, accelMaxSpeed, accelMinVol, accelMidVol * inputVal, accelMaxVol, accelPowerLow, accelPowerHigh );
	parms.accelPitch = ( parms.simple.newSoundPitch - lowPitch ) * accelPitchMultiplier + currentAccelPitchOffset;

	parms.accelVolume = Lerp( parms.accelVolume, accelMidVol, idMath::Sqrt( volumeIncreaseValue ) );

	// increase the pitch too
	parms.simple.newSoundPitch += volumeIncreaseValue*( highPitch - lowPitch );
	parms.accelPitch += volumeIncreaseValue*( highPitch - lowPitch );

	parms.simple.newSoundPitch = Min( parms.simple.newSoundPitch, highPitch );
	parms.accelPitch = Min( parms.accelPitch, highPitch * 1.5f );
}

/*
================
sdVehicleSoundControl_CrossFade::StartEngineSounds
================
*/
void sdVehicleSoundControl_CrossFade::StartEngineSounds() {
	owner->StartSound( "snd_engine_idle", SND_VEHICLE_DRIVE, 0, NULL );
	owner->StartSound( "snd_engine_drive", SND_VEHICLE_DRIVE2, 0, NULL );
	owner->StartSound( "snd_engine_hardaccel", SND_VEHICLE_DRIVE3, 0, NULL );
	owner->FadeSound( SND_VEHICLE_DRIVE, -60.0f, 0.0f );
	owner->FadeSound( SND_VEHICLE_DRIVE2, -60.0f, 0.0f );
	owner->FadeSound( SND_VEHICLE_DRIVE3, -60.0f, 0.0f );

	owner->StartSound( "snd_engine_idle_interior", SND_VEHICLE_INTERIOR_DRIVE, 0, NULL );
	owner->StartSound( "snd_engine_drive_interior", SND_VEHICLE_INTERIOR_DRIVE2, 0, NULL );
	owner->StartSound( "snd_engine_hardaccel_interior", SND_VEHICLE_INTERIOR_DRIVE3, 0, NULL );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE, -60.0f, 0.0f );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE2, -60.0f, 0.0f );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE3, -60.0f, 0.0f );

	engineSpeed = 0.0f;
	lastVolumeIncreaseValue = 0.0f;
}

/*
================
sdVehicleSoundControl_CrossFade::StopEngineSounds
================
*/
void sdVehicleSoundControl_CrossFade::StopEngineSounds() {
	owner->FadeSound( SND_VEHICLE_DRIVE, -60.0f, 0.3f );
	owner->FadeSound( SND_VEHICLE_DRIVE2, -60.0f, 0.3f );
	owner->FadeSound( SND_VEHICLE_DRIVE3, -60.0f, 0.3f );

	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE, -60.0f, 0.3f );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE2, -60.0f, 0.3f );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE3, -60.0f, 0.3f );

	soundKillTime = gameLocal.time + 300;
}

/*
================
sdVehicleSoundControl_CrossFade::UpdateEngineSounds
================
*/
void sdVehicleSoundControl_CrossFade::UpdateEngineSounds( soundParmsAdvanced_t& parms ) {
	idPlayer* driver = owner->GetPositionManager().FindDriver();

	if ( driver != NULL && !owner->IsEMPed() && ( !parms.simple.submerged || owner->IsAmphibious() ) ) {
		// set the results
		owner->SetChannelPitchShift( SND_VEHICLE_DRIVE, parms.simple.newSoundPitch );
		owner->SetChannelPitchShift( SND_VEHICLE_DRIVE2, parms.simple.newSoundPitch );
		owner->SetChannelPitchShift( SND_VEHICLE_DRIVE3, parms.accelPitch );
		owner->FadeSound( SND_VEHICLE_DRIVE, parms.idleVolume, idleFadeTime );
		owner->FadeSound( SND_VEHICLE_DRIVE2, parms.driveVolume, driveFadeTime );
		owner->FadeSound( SND_VEHICLE_DRIVE3, parms.accelVolume, accelFadeTime );

		owner->SetChannelPitchShift( SND_VEHICLE_INTERIOR_DRIVE, parms.simple.newSoundPitch );
		owner->SetChannelPitchShift( SND_VEHICLE_INTERIOR_DRIVE2, parms.simple.newSoundPitch );
		owner->SetChannelPitchShift( SND_VEHICLE_INTERIOR_DRIVE3, parms.accelPitch );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE, parms.idleVolume, idleFadeTime );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE2, parms.driveVolume, driveFadeTime );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE3, parms.accelVolume, accelFadeTime );

		soundKillTime = gameLocal.time + 5000;
	} else {
		engineSpeed = 0.0f;
		lastVolumeIncreaseValue = 0.0f;
	}

	// stop the sounds after an expiry has finished
	if ( gameLocal.time >= soundKillTime ) {
		owner->StopSound( SND_VEHICLE_DRIVE );
		owner->StopSound( SND_VEHICLE_DRIVE2 );
		owner->StopSound( SND_VEHICLE_DRIVE3 );
		owner->StopSound( SND_VEHICLE_INTERIOR_DRIVE );
		owner->StopSound( SND_VEHICLE_INTERIOR_DRIVE2 );
		owner->StopSound( SND_VEHICLE_INTERIOR_DRIVE3 );
	}
}

/*
===============================================================================

	sdVehicleSoundControl_Wheeled

===============================================================================
*/

/*
================
sdVehicleSoundControl_Wheeled::sdVehicleSoundControl_Wheeled
================
*/
sdVehicleSoundControl_Wheeled::sdVehicleSoundControl_Wheeled( void ) {
	soundFlags.playingOffRoadSound		= false;
	soundFlags.skidSoundFadedOut		= false;
	soundFlags.playingSkidSound			= false;
	soundFlags.inWater					= false;
	soundFlags.playingDriveSound		= false;

	groundSurfaceType					= NULL;
}

/*
================
sdVehicleSoundControl_Wheeled::sdVehicleSoundControl_Wheeled
================
*/
void sdVehicleSoundControl_Wheeled::Init( sdTransport* transport ) {
	sdVehicleSoundControl_CrossFade::Init( transport );
}

/*
================
sdVehicleSoundControl_Wheeled::Update
================
*/
void sdVehicleSoundControl_Wheeled::Update( void ) {
	idPlayer* driver = owner->GetPositionManager().FindDriver();

	if ( driver != NULL ) {
		const usercmd_t& cmd = gameLocal.usercmds[ driver->entityNumber ];

		if ( cmd.buttons.btn.modeSwitch ) {
			StartHornSound();
		} else {
			StopHornSound();
		}
	} else {
		StopHornSound();
	}

	soundParmsAdvanced_t parms;
	CalcSoundParmsAdvanced( parms );
	UpdateEngineSounds( parms );

	if ( parms.simple.absSpeedKPH > 10.f ) {
		FadeSkidSoundIn( parms.simple.newSoundLevel );
	} else {
		FadeSkidSoundOut();
	}

	if ( parms.simple.inWater ) {
		EnterWater( parms.simple.absSpeedKPH );

		owner->SetChannelVolume( SND_VEHICLE_OFFROAD, parms.simple.newSoundLevel );
	} else {
		ExitWater( parms.simple.absSpeedKPH );

		if ( parms.simple.absSpeedKPH > 0.1f ) {
			owner->SetChannelVolume( SND_VEHICLE_OFFROAD, parms.simple.newSoundLevel );

			StartOffRoadSound( false );
		} else {
			StopOffRoadSound();
		}
	}

	const sdVehicleInput& input = owner->GetInput();

	bool wantSkid	= false;
	bool wantDrive	= false;
	bool brakesOn	= input.GetBraking() | input.GetHandBraking();

	if ( !parms.simple.inWater ) {
		if ( parms.simple.absSpeedKPH > 30.f ) {
			wantSkid = brakesOn;
		}
	}

	if ( wantSkid ) {
		StartSkidSound( false );
	} else {
		StopSkidSound();
	}

	if ( !owner->IsEMPed() && !parms.simple.submerged && driver != NULL ) {
		StartDriveSound();
	} else {
		StopDriveSound();
	}
}

/*
================
sdVehicleSoundControl_Wheeled::OnPlayerEntered
================
*/
void sdVehicleSoundControl_Wheeled::OnPlayerEntered( idPlayer* player, int position, int oldPosition ) {
	if ( position == 0 ) {
		if ( !owner->IsEMPed() ) {
			owner->StartSound( "snd_engine_start", SND_VEHICLE_START, 0, NULL );
		}

		StartCockpitSound();
	}
}

/*
================
sdVehicleSoundControl_Wheeled::OnPlayerExited
================
*/
void sdVehicleSoundControl_Wheeled::OnPlayerExited( idPlayer* player, int position ) {
	if ( position == 0 ) {
		StopHornSound();
		StopOffRoadSound();

		if ( !owner->IsEMPed() ) {
			owner->StartSound( "snd_engine_stop", SND_VEHICLE_STOP, 0, NULL );
		}

		StopCockpitSound();
	}
}

/*
================
sdVehicleSoundControl_Wheeled::OnEMPStateChanged
================
*/
void sdVehicleSoundControl_Wheeled::OnEMPStateChanged( void ) {
	sdVehicleSoundControl_Simple::OnEMPStateChanged();
}

/*
================
sdVehicleSoundControl_Wheeled::OnWeaponEMPStateChanged
================
*/
void sdVehicleSoundControl_Wheeled::OnWeaponEMPStateChanged( void ) {
	sdVehicleSoundControl_Simple::OnWeaponEMPStateChanged();
}

/*
================
sdVehicleSoundControl_Wheeled::StartOffRoadSound
================
*/
void sdVehicleSoundControl_Wheeled::StartOffRoadSound( bool force ) {
	if ( !force && soundFlags.playingOffRoadSound ) {
		return;
	}
	soundFlags.playingOffRoadSound = true;

	idStr snd( va( "snd_wheel%s", groundSurfaceType.c_str() ) );
	if ( !idStr::Cmp( owner->spawnArgs.GetString( snd.c_str() ), "" ) ) {
		snd = "snd_wheel";
	}

	owner->StartSound( snd.c_str(), SND_VEHICLE_OFFROAD, 0, NULL );
	owner->SetChannelVolume( SND_VEHICLE_OFFROAD, -60.0f );
}

/*
================
sdVehicleSoundControl_Wheeled::StopOffRoadSound
================
*/
void sdVehicleSoundControl_Wheeled::StopOffRoadSound( void ) {
	if ( !soundFlags.playingOffRoadSound ) {
		return;
	}
	soundFlags.playingOffRoadSound = false;

	owner->StopSound( SND_VEHICLE_OFFROAD );
}

/*
================
sdVehicleSoundControl_Wheeled::FadeSkidSoundIn
================
*/
void sdVehicleSoundControl_Wheeled::FadeSkidSoundIn( float volume ) {
	owner->SetChannelVolume( SND_VEHICLE_SKID, volume );
	soundFlags.skidSoundFadedOut = false;
}

/*
================
sdVehicleSoundControl_Wheeled::FadeSkidSoundOut
================
*/
void sdVehicleSoundControl_Wheeled::FadeSkidSoundOut( void ) {
	if ( soundFlags.skidSoundFadedOut ) {
		return;
	}
	soundFlags.skidSoundFadedOut = true;
	owner->FadeSound( SND_VEHICLE_SKID, -60.f, 0.5f );
}

/*
================
sdVehicleSoundControl_Wheeled::OnSurfaceTypeChanged
================
*/
void sdVehicleSoundControl_Wheeled::OnSurfaceTypeChanged( const sdDeclSurfaceType* surfaceType ) {
	sdVehicleSoundControl_Simple::OnSurfaceTypeChanged( surfaceType );

	if ( soundFlags.playingOffRoadSound ) {
		StartOffRoadSound( true );
	}

	if ( soundFlags.playingSkidSound ) {
		StartSkidSound( true );
	}
}

/*
================
sdVehicleSoundControl_Wheeled::EnterWater
================
*/
void sdVehicleSoundControl_Wheeled::EnterWater( float absSpeedKPH ) {
	if ( soundFlags.inWater ) {
		return;
	}
	soundFlags.inWater = true;

	StopOffRoadSound();

	owner->StartSound( "snd_water_wake", SND_VEHICLE_OFFROAD, 0, NULL );
	owner->StartSound( absSpeedKPH > 30.f ? "snd_water_enter" : "snd_water_splash", SND_VEHICLE_MISC, 0, NULL );

	if ( owner->IsAmphibious() ) {
		owner->StartSound( "snd_engine_water_idle", SND_VEHICLE_DRIVE, 0, NULL );
		owner->StartSound( "snd_engine_water_drive", SND_VEHICLE_DRIVE2, 0, NULL );
		owner->StartSound( "snd_engine_water_hardaccel", SND_VEHICLE_DRIVE3, 0, NULL );
		owner->FadeSound( SND_VEHICLE_DRIVE, -60.0f, 0.0f );
		owner->FadeSound( SND_VEHICLE_DRIVE2, -60.0f, 0.0f );
		owner->FadeSound( SND_VEHICLE_DRIVE3, -60.0f, 0.0f );

		owner->StartSound( "snd_engine_water_idle_interior", SND_VEHICLE_INTERIOR_DRIVE, 0, NULL );
		owner->StartSound( "snd_engine_water_drive_interior", SND_VEHICLE_INTERIOR_DRIVE2, 0, NULL );
		owner->StartSound( "snd_engine_water_hardaccel_interior", SND_VEHICLE_INTERIOR_DRIVE3, 0, NULL );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE, -60.0f, 0.0f );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE2, -60.0f, 0.0f );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE3, -60.0f, 0.0f );
	}
}

/*
================
sdVehicleSoundControl_Wheeled::ExitWater
================
*/
void sdVehicleSoundControl_Wheeled::ExitWater( float absSpeedKPH ) {
	if ( !soundFlags.inWater ) {
		return;
	}
	soundFlags.inWater = false;

	owner->StartSound( absSpeedKPH > 30.f ? "snd_water_exit" : "snd_water_splash", SND_VEHICLE_MISC, 0, NULL );

	if ( owner->IsAmphibious() ) {
		owner->StartSound( "snd_engine_idle", SND_VEHICLE_DRIVE, 0, NULL );
		owner->StartSound( "snd_engine_drive", SND_VEHICLE_DRIVE2, 0, NULL );
		owner->StartSound( "snd_engine_hardaccel", SND_VEHICLE_DRIVE3, 0, NULL );
		owner->FadeSound( SND_VEHICLE_DRIVE, -60.0f, 0.0f );
		owner->FadeSound( SND_VEHICLE_DRIVE2, -60.0f, 0.0f );
		owner->FadeSound( SND_VEHICLE_DRIVE3, -60.0f, 0.0f );

		owner->StartSound( "snd_engine_idle_interior", SND_VEHICLE_INTERIOR_DRIVE, 0, NULL );
		owner->StartSound( "snd_engine_drive_interior", SND_VEHICLE_INTERIOR_DRIVE2, 0, NULL );
		owner->StartSound( "snd_engine_hardaccel_interior", SND_VEHICLE_INTERIOR_DRIVE3, 0, NULL );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE, -60.0f, 0.0f );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE2, -60.0f, 0.0f );
		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE3, -60.0f, 0.0f );
	}
}

/*
================
sdVehicleSoundControl_Wheeled::StartSkidSound
================
*/
void sdVehicleSoundControl_Wheeled::StartSkidSound( bool force ) {
	if ( !force && soundFlags.playingSkidSound ) {
		return;
	}

	if ( !soundFlags.playingSkidSound ) {
		owner->FadeSound( SND_VEHICLE_DRIVE, -30.f, 0.05f );
	}

	soundFlags.playingSkidSound = true;

	idStr snd( va( "snd_skid%s", groundSurfaceType.c_str() ) );
	if ( !idStr::Cmp( owner->spawnArgs.GetString( snd.c_str() ), "" ) ) {
		snd = "snd_skid";
	}

	owner->StartSound( snd.c_str(), SND_VEHICLE_SKID, 0, NULL );
}

/*
================
sdVehicleSoundControl_Wheeled::StopSkidSound
================
*/
void sdVehicleSoundControl_Wheeled::StopSkidSound( void ) {
	if ( !soundFlags.playingSkidSound ) {
		return;
	}
	soundFlags.playingSkidSound = false;

	owner->FadeSound( SND_VEHICLE_DRIVE, 0.f, 0.05f );
}

/*
================
sdVehicleSoundControl_Wheeled::StartDriveSound
================
*/
void sdVehicleSoundControl_Wheeled::StartDriveSound( void ) {
	if ( soundFlags.playingDriveSound ) {
		return;
	}
	soundFlags.playingDriveSound = true;

	StartEngineSounds();
}

/*
================
sdVehicleSoundControl_Wheeled::StopDriveSound
================
*/
void sdVehicleSoundControl_Wheeled::StopDriveSound( void ) {
	if ( !soundFlags.playingDriveSound ) {
		return;
	}
	soundFlags.playingDriveSound = false;
	StopEngineSounds();
}

/*
===============================================================================

	sdVehicleSoundControl_Tracked

===============================================================================
*/

/*
================
sdVehicleSoundControl_Tracked::sdVehicleSoundControl_Tracked
================
*/
sdVehicleSoundControl_Tracked::sdVehicleSoundControl_Tracked( void ) {
	soundFlags.playingOffRoadSound	= false;
	soundFlags.playingDriveSound	= false;
	soundFlags.inWater				= false;
}

/*
================
sdVehicleSoundControl_Tracked::Update
================
*/
void sdVehicleSoundControl_Tracked::Update( void ) {
	idPlayer* driver = owner->GetPositionManager().FindDriver();
	const sdVehicleInput& input = owner->GetInput();

	if ( driver != NULL ) {
		const usercmd_t& cmd = gameLocal.usercmds[ driver->entityNumber ];

		if ( cmd.buttons.btn.modeSwitch ) {
			StartHornSound();
		} else {
			StopHornSound();
		}
	} else {
		StopHornSound();
	}

	soundParmsAdvanced_t parms;
	CalcSoundParmsAdvanced( parms );
	UpdateEngineSounds( parms );

	if ( parms.simple.inWater ) {
		EnterWater( parms.simple.absSpeedKPH );

		owner->SetChannelVolume( SND_VEHICLE_OFFROAD, parms.simple.newSoundLevel );
	} else {
		ExitWater( parms.simple.absSpeedKPH );

		if ( parms.simple.absSpeedKPH > 1.f ) {
			StartOffRoadSound();

			float newTrackPitch = ( parms.simple.absSpeedKPH * 0.005f ) + 0.7f;
			owner->SetChannelPitchShift( SND_VEHICLE_INTERIOR_OFFROAD, newTrackPitch );
			owner->SetChannelPitchShift( SND_VEHICLE_OFFROAD, newTrackPitch );

			if ( groundIsOffRoad ) {
				owner->FadeSound( SND_VEHICLE_INTERIOR_OFFROAD, parms.simple.newSoundLevel - 10.f, 0.1f );
				owner->FadeSound( SND_VEHICLE_OFFROAD, parms.simple.newSoundLevel - 2.f, 0.1f );
			} else {
				owner->FadeSound( SND_VEHICLE_INTERIOR_OFFROAD, parms.simple.newSoundLevel - 8.f, 0.1f );
				owner->FadeSound( SND_VEHICLE_OFFROAD, parms.simple.newSoundLevel, 0.1f );
			}
		} else {
			StopOffRoadSound();
		}
	}

	if ( !owner->IsEMPed() && !parms.simple.submerged && driver != NULL ) {
		StartDriveSound();
	} else {
		StopDriveSound();
	}
}

/*
================
sdVehicleSoundControl_Tracked::OnPlayerEntered
================
*/
void sdVehicleSoundControl_Tracked::OnPlayerEntered( idPlayer* player, int position, int oldPosition ) {
	if ( position == 0 && !owner->IsEMPed() ) {
		owner->StartSound( "snd_engine_start", SND_VEHICLE_START, 0, NULL );
		owner->StartSound( "snd_engine_start_interior", SND_VEHICLE_INTERIOR_START, 0, NULL );
	}

	StartCockpitSound();
}

/*
================
sdVehicleSoundControl_Tracked::OnPlayerExited
================
*/
void sdVehicleSoundControl_Tracked::OnPlayerExited( idPlayer* player, int position ) {
	if ( position == 0 && !owner->IsEMPed() ) {
		owner->StartSound( "snd_engine_stop", SND_VEHICLE_STOP, 0, NULL );
		owner->StartSound( "snd_engine_stop_interior", SND_VEHICLE_INTERIOR_STOP, 0, NULL );
	}

	if ( owner->GetPositionManager().IsEmpty() ) {
		StopCockpitSound();
	}
}

/*
================
sdVehicleSoundControl_Tracked::OnSurfaceTypeChanged
================
*/
void sdVehicleSoundControl_Tracked::OnSurfaceTypeChanged( const sdDeclSurfaceType* surfaceType ) {
	sdVehicleSoundControl_Simple::OnSurfaceTypeChanged( surfaceType );
}

/*
================
sdVehicleSoundControl_Tracked::OnEMPStateChanged
================
*/
void sdVehicleSoundControl_Tracked::OnEMPStateChanged( void ) {
//	sdVehicleSoundControl_Simple::OnEMPStateChanged();
	idPlayer* driver = owner->GetPositionManager().FindDriver();
	if ( !owner->IsEMPed() ) {
		if ( driver != NULL ) {
			owner->StartSound( "snd_engine_start", SND_VEHICLE_START, 0, NULL );
			owner->StartSound( "snd_engine_start_interior", SND_VEHICLE_INTERIOR_START, 0, NULL );
		}
	} else {
		if ( driver != NULL ) {
			owner->StartSound( "snd_engine_stop", SND_VEHICLE_STOP, 0, NULL );
			owner->StartSound( "snd_engine_stop_interior", SND_VEHICLE_INTERIOR_STOP, 0, NULL );
		}
	}
}

/*
================
sdVehicleSoundControl_Tracked::OnWeaponEMPStateChanged
================
*/
void sdVehicleSoundControl_Tracked::OnWeaponEMPStateChanged( void ) {
	sdVehicleSoundControl_Simple::OnWeaponEMPStateChanged();
}

/*
================
sdVehicleSoundControl_Tracked::Init
================
*/
void sdVehicleSoundControl_Tracked::Init( sdTransport* transport ) {
	sdVehicleSoundControl_CrossFade::Init( transport );
}

/*
================
sdVehicleSoundControl_Tracked::StartOffRoadSound
================
*/
void sdVehicleSoundControl_Tracked::StartOffRoadSound( void ) {
	if ( soundFlags.playingOffRoadSound ) {
		return;
	}
	soundFlags.playingOffRoadSound = true;

	owner->StartSound( "snd_tracks_interior", SND_VEHICLE_INTERIOR_OFFROAD, 0, NULL );
	owner->SetChannelVolume( SND_VEHICLE_INTERIOR_OFFROAD, -60.f );
	owner->StartSound( "snd_tracks", SND_VEHICLE_OFFROAD, 0, NULL );
	owner->SetChannelVolume( SND_VEHICLE_OFFROAD, -60.f );
}

/*
================
sdVehicleSoundControl_Tracked::StopOffRoadSound
================
*/
void sdVehicleSoundControl_Tracked::StopOffRoadSound( void ) {
	if ( !soundFlags.playingOffRoadSound ) {
		return;
	}
	soundFlags.playingOffRoadSound = false;

	owner->StopSound( SND_VEHICLE_INTERIOR_OFFROAD );
	owner->StopSound( SND_VEHICLE_OFFROAD );
}

/*
================
sdVehicleSoundControl_Tracked::EnterWater
================
*/
void sdVehicleSoundControl_Tracked::EnterWater( float absSpeedKPH ) {
	if ( soundFlags.inWater ) {
		return;
	}
	soundFlags.inWater = true;

	StopOffRoadSound();

	owner->StartSound( "snd_water_wake", SND_VEHICLE_OFFROAD, 0, NULL );
	owner->StartSound( absSpeedKPH > 10.f ? "snd_water_enter" : "snd_water_splash", SND_VEHICLE_MISC, 0, NULL );
}

/*
================
sdVehicleSoundControl_Tracked::ExitWater
================
*/
void sdVehicleSoundControl_Tracked::ExitWater( float absSpeedKPH ) {
	if ( !soundFlags.inWater ) {
		return;
	}
	soundFlags.inWater = false;

	owner->StartSound( absSpeedKPH > 10.f ? "snd_water_exit" : "snd_water_splash", SND_VEHICLE_MISC, 0, NULL );
}

/*
================
sdVehicleSoundControl_Tracked::StartDriveSound
================
*/
void sdVehicleSoundControl_Tracked::StartDriveSound( void ) {
	if ( soundFlags.playingDriveSound ) {
		return;
	}
	soundFlags.playingDriveSound = true;

	StartEngineSounds();
}

/*
================
sdVehicleSoundControl_Tracked::StopDriveSound
================
*/
void sdVehicleSoundControl_Tracked::StopDriveSound( void ) {
	if ( !soundFlags.playingDriveSound ) {
		return;
	}
	soundFlags.playingDriveSound = false;
	StopEngineSounds();
}

/*
===============================================================================

	sdVehicleSoundControl_Helicopter

===============================================================================
*/

/*
================
sdVehicleSoundControl_Helicopter::sdVehicleSoundControl_Helicopter
================
*/
sdVehicleSoundControl_Helicopter::sdVehicleSoundControl_Helicopter( void ) {
	soundFlags.playingRotorSound		= false;
	soundFlags.playingTurbineSound		= false;
	soundFlags.playingThrottleSound		= false;
	soundFlags.playingTailRotorSound	= false;
}

/*
================
sdVehicleSoundControl_Helicopter::Update
================
*/
void sdVehicleSoundControl_Helicopter::Update( void ) {
	soundParms_t parms;
	CalcSoundParms( parms );

	owner->SetChannelPitchShift( SND_VEHICLE_INTERIOR_IDLE, parms.newSoundPitch );
	owner->SetChannelPitchShift( SND_VEHICLE_IDLE, parms.newSoundPitch );

	const sdVehicleInput& input = owner->GetInput();

	if ( soundFlags.playingThrottleSound ) {
		float newLevel = ( input.GetCollective() * 30.f ) - 10.f;
		if ( newLevel > 1.f ) {
			newLevel = 1.f;
		}

		owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE2, newLevel, 0.1f );
		owner->FadeSound( SND_VEHICLE_DRIVE2, newLevel, 0.1f );
	}

	if ( input.GetRight() != 0.f ) {
		FadeTailRotorIn();
	} else {
		FadeTailRotorOut();
	}

	if ( parms.submerged ) {
		EnterWater();
	} else {
		ExitWater();
	}
}

/*
================
sdVehicleSoundControl_Helicopter::OnPlayerEntered
================
*/
void sdVehicleSoundControl_Helicopter::OnPlayerEntered( idPlayer* player, int position, int oldPosition ) {
	if ( position == 0 ) {
		if ( !owner->IsEMPed() ) {
			StartTurbineSound();
			StartRotorSound();
			StartThrottleSound();
		}
	}	
}

/*
================
sdVehicleSoundControl_Helicopter::OnPlayerExited
================
*/
void sdVehicleSoundControl_Helicopter::OnPlayerExited( idPlayer* player, int position ) {
	if ( position == 0 ) {
		if ( !owner->IsEMPed() ) {
			StopTurbineSound();
			StopRotorSound();
			StopThrottleSound();
		}
	}
}

/*
================
sdVehicleSoundControl_Helicopter::OnSurfaceTypeChanged
================
*/
void sdVehicleSoundControl_Helicopter::OnSurfaceTypeChanged( const sdDeclSurfaceType* surfaceType ) {
	sdVehicleSoundControl_Simple::OnSurfaceTypeChanged( surfaceType );
}

/*
================
sdVehicleSoundControl_Helicopter::OnEMPStateChanged
================
*/
void sdVehicleSoundControl_Helicopter::OnEMPStateChanged( void ) {
	idPlayer* driver = owner->GetPositionManager().FindDriver();
	if ( !owner->IsEMPed() ) {
		if ( driver != NULL ) {
			StartTurbineSound();
			StartRotorSound();
			StartThrottleSound();
		}
	} else {
		if ( driver != NULL ) {
			StopTurbineSound();
			StopRotorSound();
			StopThrottleSound();
		}
	}
}

/*
================
sdVehicleSoundControl_Helicopter::OnWeaponEMPStateChanged
================
*/
void sdVehicleSoundControl_Helicopter::OnWeaponEMPStateChanged( void ) {
	sdVehicleSoundControl_Simple::OnWeaponEMPStateChanged();
}

/*
================
sdVehicleSoundControl_Helicopter::Init
================
*/
void sdVehicleSoundControl_Helicopter::Init( sdTransport* transport ) {
	sdVehicleSoundControl_Simple::Init( transport );

	owner->StartSound( "snd_cockpit", SND_VEHICLE_INTERIOR, 0, NULL );
	owner->StartSound( "snd_rotor_tail", SND_VEHICLE_DRIVE3, 0, NULL );
}

/*
================
sdVehicleSoundControl_Helicopter::StartTurbineSound
================
*/
void sdVehicleSoundControl_Helicopter::StartTurbineSound( void ) {
	if ( soundFlags.playingTurbineSound ) {
		return;
	}
	soundFlags.playingTurbineSound = true;

	owner->StartSound( "snd_turbine_start_interior", SND_VEHICLE_INTERIOR_IDLE, 0, NULL );
	owner->StartSound( "snd_turbine_start", SND_VEHICLE_IDLE, 0, NULL );
}

/*
================
sdVehicleSoundControl_Helicopter::StopTurbineSound
================
*/
void sdVehicleSoundControl_Helicopter::StopTurbineSound( void ) {
	if ( !soundFlags.playingTurbineSound ) {
		return;
	}
	soundFlags.playingTurbineSound = false;

	owner->StartSound( "snd_turbine_stop_interior", SND_VEHICLE_INTERIOR_IDLE, 0, NULL );
	owner->StartSound( "snd_turbine_stop", SND_VEHICLE_IDLE, 0, NULL );
}

/*
================
sdVehicleSoundControl_Helicopter::StartRotorSound
================
*/
void sdVehicleSoundControl_Helicopter::StartRotorSound( void ) {
	if ( soundFlags.playingRotorSound ) {
		return;
	}
	soundFlags.playingRotorSound = true;

	owner->StartSound( "snd_rotor_start_interior", SND_VEHICLE_INTERIOR_DRIVE, 0, NULL );
	owner->StartSound( "snd_rotor_start", SND_VEHICLE_DRIVE, 0, NULL );
}

/*
================
sdVehicleSoundControl_Helicopter::StopRotorSound
================
*/
void sdVehicleSoundControl_Helicopter::StopRotorSound( void ) {
	if ( !soundFlags.playingRotorSound ) {
		return;
	}
	soundFlags.playingRotorSound = false;

	owner->StartSound( "snd_rotor_stop_interior", SND_VEHICLE_INTERIOR_DRIVE, 0, NULL );
	owner->StartSound( "snd_rotor_stop", SND_VEHICLE_DRIVE, 0, NULL );
}

/*
================
sdVehicleSoundControl_Helicopter::StartThrottleSound
================
*/
void sdVehicleSoundControl_Helicopter::StartThrottleSound( void ) {
	if ( soundFlags.playingThrottleSound ) {
		return;
	}
	soundFlags.playingThrottleSound = true;

	owner->StartSound( "snd_rotor_throttle_interior", SND_VEHICLE_INTERIOR_DRIVE2, 0, NULL );
	owner->StartSound( "snd_rotor_throttle", SND_VEHICLE_DRIVE2, 0, NULL );
}

/*
================
sdVehicleSoundControl_Helicopter::StopThrottleSound
================
*/
void sdVehicleSoundControl_Helicopter::StopThrottleSound( void ) {
	if ( !soundFlags.playingThrottleSound ) {
		return;
	}
	soundFlags.playingThrottleSound = false;

	owner->StopSound( SND_VEHICLE_INTERIOR_DRIVE2 );
	owner->StopSound( SND_VEHICLE_DRIVE2 );
}

/*
================
sdVehicleSoundControl_Helicopter::FadeTailRotorIn
================
*/
void sdVehicleSoundControl_Helicopter::FadeTailRotorIn( void ) {
	if ( soundFlags.playingTailRotorSound ) {
		return;
	}
	soundFlags.playingTailRotorSound = true;

	owner->FadeSound( SND_VEHICLE_DRIVE3, 0.f, 0.5f );
}

/*
================
sdVehicleSoundControl_Helicopter::FadeTailRotorOut
================
*/
void sdVehicleSoundControl_Helicopter::FadeTailRotorOut( void ) {
	if ( !soundFlags.playingTailRotorSound ) {
		return;
	}
	soundFlags.playingTailRotorSound = false;

	owner->FadeSound( SND_VEHICLE_DRIVE3, -60.f, 1.f );
}

/*
================
sdVehicleSoundControl_Helicopter::EnterWater
================
*/
void sdVehicleSoundControl_Helicopter::EnterWater( void ) {
	if ( soundFlags.inWater ) {
		return;
	}
	soundFlags.inWater = true;

	owner->StartSound( "snd_water_enter", SND_VEHICLE_MISC, 0, NULL );
}

/*
================
sdVehicleSoundControl_Helicopter::ExitWater
================
*/
void sdVehicleSoundControl_Helicopter::ExitWater( void ) {
	if ( !soundFlags.inWater ) {
		return;
	}
	soundFlags.inWater = false;
}



/*
===============================================================================

	sdVehicleSoundControl_JetPack

===============================================================================
*/

/*
================
sdVehicleSoundControl_JetPack::sdVehicleSoundControl_JetPack
================
*/
sdVehicleSoundControl_JetPack::sdVehicleSoundControl_JetPack( void ) {
	nextJetStartSoundTime		= 0;

	soundFlags.playingJetSound	= false;
	soundFlags.playingIdleSound	= false;
}

/*
================
sdVehicleSoundControl_JetPack::Update
================
*/
void sdVehicleSoundControl_JetPack::Update( void ) {
	const idVec3& upAxis = owner->GetAxis()[ 2 ];
	const idVec3& velocity = owner->GetPhysics()->GetLinearVelocity();
	float absSpeedKPH = ( velocity - ( velocity*upAxis )*upAxis ).Length();

	if ( soundFlags.playingIdleSound ) {
		float idealNewPitch = ( absSpeedKPH * soundSpeedMultiplier ) + soundSpeedOffset;
		if ( idealNewPitch > soundPitchMax ) {
			idealNewPitch = soundPitchMax;
		}

		float newPitch = Lerp( lastSoundPitch, idealNewPitch, soundRampRate );
		owner->SetChannelPitchShift( SND_VEHICLE_IDLE, newPitch );
		lastSoundPitch = newPitch;
	}

	const sdVehicleInput& input = owner->GetInput();
	
	bool playJetSound = false;

	idPlayer* driver = owner->GetPositionManager().FindDriver();
	if ( driver && !owner->IsEMPed() ) {
		if ( gameLocal.usercmds[ driver->entityNumber ].buttons.btn.sprint ) {
			if ( jetPack->GetChargeFraction() > 0.f ) {
				playJetSound = true;
			}
		}
	}

	if ( playJetSound ) {
		StartJetSound();
	} else {
		StopJetSound();
	}

	// play jumped sound
	if ( jetPack->GetJetPackPhysics()->HasJumped() ) {
		owner->StartSound( "snd_jump", SND_VEHICLE_JUMP, 0, NULL );
	}
}

/*
================
sdVehicleSoundControl_JetPack::OnPlayerEntered
================
*/
void sdVehicleSoundControl_JetPack::OnPlayerEntered( idPlayer* player, int position, int oldPosition ) {
	if ( position == 0 && !owner->IsEMPed() ) {
		StartIdleSound();
	}
}

/*
================
sdVehicleSoundControl_JetPack::OnPlayerExited
================
*/
void sdVehicleSoundControl_JetPack::OnPlayerExited( idPlayer* player, int position ) {
	if ( position == 0 && !owner->IsEMPed() ) {
		StopIdleSound();
	}
}

/*
================
sdVehicleSoundControl_JetPack::OnSurfaceTypeChanged
================
*/
void sdVehicleSoundControl_JetPack::OnSurfaceTypeChanged( const sdDeclSurfaceType* surfaceType ) {
}

/*
================
sdVehicleSoundControl_JetPack::OnEMPStateChanged
================
*/
void sdVehicleSoundControl_JetPack::OnEMPStateChanged( void ) {
	idPlayer* driver = owner->GetPositionManager().FindDriver();
	if ( !owner->IsEMPed() ) {
		if ( driver != NULL ) {
			StartIdleSound();
		}
	} else {
		if ( driver != NULL ) {
			StopIdleSound();
		}
	}
}

/*
================
sdVehicleSoundControl_JetPack::OnWeaponEMPStateChanged
================
*/
void sdVehicleSoundControl_JetPack::OnWeaponEMPStateChanged( void ) {
}

/*
================
sdVehicleSoundControl_JetPack::Init
================
*/
void sdVehicleSoundControl_JetPack::Init( sdTransport* transport ) {
	sdVehicleSoundControlBase::Init( transport );

	jetPack = transport->Cast< sdJetPack >();
	if ( jetPack == NULL ) {
		gameLocal.Error( "sdVehicleSoundControl_JetPack::Init Tried To Attach To a Non JetPack Entity" );
	}

	soundSpeedMultiplier	= transport->spawnArgs.GetFloat( "sound_speed_multiplier", "0.005" );
	soundSpeedOffset		= transport->spawnArgs.GetFloat( "sound_speed_offset", "1" );
	soundPitchMax			= transport->spawnArgs.GetFloat( "sound_pitch_max", "2.5" );
	soundRampRate			= transport->spawnArgs.GetFloat( "sound_ramp_rate", "0.1" );

	lastSoundPitch			= soundSpeedOffset;
}

/*
================
sdVehicleSoundControl_JetPack::StartJetSound
================
*/
void sdVehicleSoundControl_JetPack::StartJetSound( void ) {
	if ( soundFlags.playingJetSound ) {
		return;
	}
	soundFlags.playingJetSound = true;
	
	if ( !owner->IsEMPed() ) {
		owner->StartSound( "snd_jet", SND_VEHICLE_DRIVE, 0, NULL );

		if ( nextJetStartSoundTime < gameLocal.time ) {
			owner->StartSound( "snd_jet_start", SND_VEHICLE_DRIVE2, 0, NULL );
			nextJetStartSoundTime = gameLocal.time + 950;

			owner->FadeSound( SND_VEHICLE_DRIVE2, -15.0f, 0.0f );
			owner->FadeSound( SND_VEHICLE_DRIVE2, 0.0f, 0.05f );

			owner->FadeSound( SND_VEHICLE_DRIVE, -30.0f, 0.0f );
			owner->FadeSound( SND_VEHICLE_DRIVE, 0.0f, 0.5f );
		}
	}
}

/*
================
sdVehicleSoundControl_JetPack::StopJetSound
================
*/
void sdVehicleSoundControl_JetPack::StopJetSound( void ) {
	if ( !soundFlags.playingJetSound ) {
		return;
	}
	soundFlags.playingJetSound = false;
	
	owner->FadeSound( SND_VEHICLE_DRIVE, -60.0f, 2.0f );
	owner->FadeSound( SND_VEHICLE_DRIVE2, -60.0f, 2.0f );
}

/*
================
sdVehicleSoundControl_JetPack::StartIdleSound
================
*/
void sdVehicleSoundControl_JetPack::StartIdleSound( void ) {
	if ( soundFlags.playingIdleSound ) {
		return;
	}
	soundFlags.playingIdleSound = true;

	if ( !owner->IsEMPed() ) {
		owner->StartSound( "snd_idle", SND_VEHICLE_IDLE, 0, NULL );
	}
}

/*
================
sdVehicleSoundControl_JetPack::StopIdleSound
================
*/
void sdVehicleSoundControl_JetPack::StopIdleSound( void ) {
	if ( !soundFlags.playingIdleSound ) {
		return;
	}
	soundFlags.playingIdleSound = false;

	owner->StopSound( SND_VEHICLE_IDLE );
}





/*
===============================================================================

	sdVehicleSoundControl_SpeedBoat

===============================================================================
*/

/*
================
sdVehicleSoundControl_SpeedBoat::sdVehicleSoundControl_SpeedBoat
================
*/
sdVehicleSoundControl_SpeedBoat::sdVehicleSoundControl_SpeedBoat( void ) {
	soundFlags.playingDriveSound	= false;
	soundFlags.inWater				= false;
}

/*
================
sdVehicleSoundControl_SpeedBoat::Update
================
*/
void sdVehicleSoundControl_SpeedBoat::Update( void ) {
	soundParmsAdvanced_t parms;
	CalcSoundParmsAdvanced( parms );
	UpdateEngineSounds( parms );

	const sdVehicleInput& input = owner->GetInput();

	if ( !owner->IsEMPed() && !parms.simple.submerged && input.GetPlayer() != NULL ) {
		StartDriveSound();
	} else {
		StopDriveSound();
	}

	if ( parms.simple.inWater ) {
		EnterWater();

		owner->SetChannelVolume( SND_VEHICLE_DRIVE4, parms.simple.newSoundLevel );
	} else {
		ExitWater();
	}
}

/*
================
sdVehicleSoundControl_SpeedBoat::OnPlayerEntered
================
*/
void sdVehicleSoundControl_SpeedBoat::OnPlayerEntered( idPlayer* player, int position, int oldPosition ) {
	if ( position == 0 && !owner->IsEMPed() ) {
		owner->StartSound( "snd_engine_start", SND_VEHICLE_START, 0, NULL );
	}
}

/*
================
sdVehicleSoundControl_SpeedBoat::OnPlayerExited
================
*/
void sdVehicleSoundControl_SpeedBoat::OnPlayerExited( idPlayer* player, int position ) {
	if ( position == 0 && !owner->IsEMPed() ) {
		owner->StartSound( "snd_engine_stop", SND_VEHICLE_STOP, 0, NULL );
	}
}

/*
================
sdVehicleSoundControl_SpeedBoat::OnSurfaceTypeChanged
================
*/
void sdVehicleSoundControl_SpeedBoat::OnSurfaceTypeChanged( const sdDeclSurfaceType* surfaceType ) {
	sdVehicleSoundControl_CrossFade::OnSurfaceTypeChanged( surfaceType );
}

/*
================
sdVehicleSoundControl_SpeedBoat::OnEMPStateChanged
================
*/
void sdVehicleSoundControl_SpeedBoat::OnEMPStateChanged( void ) {
	sdVehicleSoundControl_CrossFade::OnEMPStateChanged();
}

/*
================
sdVehicleSoundControl_SpeedBoat::OnWeaponEMPStateChanged
================
*/
void sdVehicleSoundControl_SpeedBoat::OnWeaponEMPStateChanged( void ) {
	sdVehicleSoundControl_CrossFade::OnEMPStateChanged();
}

/*
================
sdVehicleSoundControl_SpeedBoat::Init
================
*/
void sdVehicleSoundControl_SpeedBoat::Init( sdTransport* transport ) {
	sdVehicleSoundControl_CrossFade::Init( transport );
}

/*
================
sdVehicleSoundControl_SpeedBoat::StartDriveSound
================
*/
void sdVehicleSoundControl_SpeedBoat::StartDriveSound( void ) {
	if ( soundFlags.playingDriveSound ) {
		return;
	}
	soundFlags.playingDriveSound = true;

	owner->StartSound( "snd_engine_water_idle", SND_VEHICLE_DRIVE, 0, NULL );
	owner->StartSound( "snd_engine_water_drive", SND_VEHICLE_DRIVE2, 0, NULL );
	owner->StartSound( "snd_engine_water_hardaccel", SND_VEHICLE_DRIVE3, 0, NULL );
	owner->FadeSound( SND_VEHICLE_DRIVE, -60.0f, 0.0f );
	owner->FadeSound( SND_VEHICLE_DRIVE2, -60.0f, 0.0f );
	owner->FadeSound( SND_VEHICLE_DRIVE3, -60.0f, 0.0f );

	owner->StartSound( "snd_engine_water_idle_interior", SND_VEHICLE_INTERIOR_DRIVE, 0, NULL );
	owner->StartSound( "snd_engine_water_drive_interior", SND_VEHICLE_INTERIOR_DRIVE2, 0, NULL );
	owner->StartSound( "snd_engine_water_hardaccel_interior", SND_VEHICLE_INTERIOR_DRIVE3, 0, NULL );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE, -60.0f, 0.0f );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE2, -60.0f, 0.0f );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE3, -60.0f, 0.0f );


	engineSpeed = 0.0f;
	lastVolumeIncreaseValue = 0.0f;
}

/*
================
sdVehicleSoundControl_SpeedBoat::StopDriveSound
================
*/
void sdVehicleSoundControl_SpeedBoat::StopDriveSound( void ) {
	if ( !soundFlags.playingDriveSound ) {
		return;
	}

	soundFlags.playingDriveSound = false;

	owner->FadeSound( SND_VEHICLE_DRIVE, -60.0f, 0.3f );
	owner->FadeSound( SND_VEHICLE_DRIVE2, -60.0f, 0.3f );
	owner->FadeSound( SND_VEHICLE_DRIVE3, -60.0f, 0.3f );

	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE, -60.0f, 0.3f );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE2, -60.0f, 0.3f );
	owner->FadeSound( SND_VEHICLE_INTERIOR_DRIVE3, -60.0f, 0.3f );

	soundKillTime = gameLocal.time + 300;
}

/*
================
sdVehicleSoundControl_SpeedBoat::EnterWater
================
*/
void sdVehicleSoundControl_SpeedBoat::EnterWater( void ) {
	if ( soundFlags.inWater ) {
		return;
	}
	soundFlags.inWater = true;

	owner->StartSound( "snd_water_splash", SND_VEHICLE_MISC, 0, NULL );
	owner->StartSound( "snd_water_wake", SND_VEHICLE_DRIVE4, 0, NULL );
}

/*
================
sdVehicleSoundControl_SpeedBoat::ExitWater
================
*/
void sdVehicleSoundControl_SpeedBoat::ExitWater( void ) {
	if ( !soundFlags.inWater ) {
		return;
	}
	soundFlags.inWater = false;

	owner->StartSound( "snd_water_splash", SND_VEHICLE_MISC, 0, NULL );
	owner->StopSound( SND_VEHICLE_DRIVE4 );
}