19 files changed, 3554 insertions, 3373 deletions

diff --git a/src/audio/AudioCollision.cpp b/src/audio/AudioCollision.cpp
index 4b37d83b..02330756 100644
--- a/src/audio/AudioCollision.cpp
+++ b/src/audio/AudioCollision.cpp
@@ -8,8 +8,6 @@
 #include "SurfaceTable.h"
 #include "sampman.h"
 
-const int CollisionSoundIntensity = 60;
-
 void
 cAudioManager::ReportCollision(CEntity *entity1, CEntity *entity2, uint8 surface1, uint8 surface2, float collisionPower,
                                float velocity)
@@ -32,7 +30,7 @@ cAudioManager::ReportCollision(CEntity *entity1, CEntity *entity2, uint8 surface
 	}
 	CVector pos = (v1 + v2) * 0.5f;
 	distSquared = GetDistanceSquared(pos);
-	if(distSquared < SQR(CollisionSoundIntensity)) {
+	if(distSquared < SQR(COLLISION_MAX_DIST)) {
 		m_sCollisionManager.m_sQueue.m_pEntity1 = entity1;
 		m_sCollisionManager.m_sQueue.m_pEntity2 = entity2;
 		m_sCollisionManager.m_sQueue.m_bSurface1 = surface1;
@@ -48,8 +46,8 @@ cAudioManager::ReportCollision(CEntity *entity1, CEntity *entity2, uint8 surface
 void
 cAudioCollisionManager::AddCollisionToRequestedQueue()
 {
-	int32 collisionsIndex;
-	int32 i;
+	uint32 collisionsIndex;
+	uint32 i;
 
 
 	if (m_bCollisionsInQueue < NUMAUDIOCOLLISIONS)
@@ -83,11 +81,11 @@ cAudioManager::ServiceCollisions()
 
 	m_sQueueSample.m_nEntityIndex = m_nCollisionEntity;
 
-	for(int i = 0; i < NUMAUDIOCOLLISIONS; i++)
+	for (int i = 0; i < NUMAUDIOCOLLISIONS; i++)
 		abRepeatedCollision1[i] = abRepeatedCollision2[i] = FALSE;
 
-	for(i = 0; i < m_sCollisionManager.m_bCollisionsInQueue; i++) {
-		for(j = 0; j < NUMAUDIOCOLLISIONS; j++) {
+	for (i = 0; i < m_sCollisionManager.m_bCollisionsInQueue; i++) {
+		for (j = 0; j < NUMAUDIOCOLLISIONS; j++) {
 			int index = m_sCollisionManager.m_bIndicesTable[i];
 			if ((m_sCollisionManager.m_asCollisions1[index].m_pEntity1 == m_sCollisionManager.m_asCollisions2[j].m_pEntity1)
 				&& (m_sCollisionManager.m_asCollisions1[index].m_pEntity2 == m_sCollisionManager.m_asCollisions2[j].m_pEntity2)
@@ -103,8 +101,8 @@ cAudioManager::ServiceCollisions()
 		}
 	}
 
-	for(i = 0; i < NUMAUDIOCOLLISIONS; i++) {
-		if(!abRepeatedCollision2[i]) {
+	for (i = 0; i < NUMAUDIOCOLLISIONS; i++) {
+		if (!abRepeatedCollision2[i]) {
 			m_sCollisionManager.m_asCollisions2[i].m_pEntity1 = nil;
 			m_sCollisionManager.m_asCollisions2[i].m_pEntity2 = nil;
 			m_sCollisionManager.m_asCollisions2[i].m_bSurface1 = SURFACE_DEFAULT;
@@ -116,11 +114,11 @@ cAudioManager::ServiceCollisions()
 		}
 	}
 
-	for(i = 0; i < m_sCollisionManager.m_bCollisionsInQueue; i++) {
+	for (i = 0; i < m_sCollisionManager.m_bCollisionsInQueue; i++) {
 		int index = m_sCollisionManager.m_bIndicesTable[i];
-		if(!abRepeatedCollision1[index]) {
-			for(j = 0; j < NUMAUDIOCOLLISIONS; j++) {
-				if(!abRepeatedCollision2[j]) {
+		if (!abRepeatedCollision1[index]) {
+			for (j = 0; j < NUMAUDIOCOLLISIONS; j++) {
+				if (!abRepeatedCollision2[j]) {
 					m_sCollisionManager.m_asCollisions2[j].m_nBaseVolume = 1;
 					m_sCollisionManager.m_asCollisions2[j].m_pEntity1 = m_sCollisionManager.m_asCollisions1[index].m_pEntity1;
 					m_sCollisionManager.m_asCollisions2[j].m_pEntity2 = m_sCollisionManager.m_asCollisions1[index].m_pEntity2;
@@ -134,12 +132,12 @@ cAudioManager::ServiceCollisions()
 		}
 	}
 
-	for(int i = 0; i < NUMAUDIOCOLLISIONS; i++)
+	for (int i = 0; i < NUMAUDIOCOLLISIONS; i++)
 		m_sCollisionManager.m_bIndicesTable[i] = NUMAUDIOCOLLISIONS;
 	m_sCollisionManager.m_bCollisionsInQueue = 0;
 }
 
-static const int32 gOneShotCol[] = {SFX_COL_TARMAC_1,
+static const uint32 gOneShotCol[] = {SFX_COL_TARMAC_1,
                                     SFX_COL_TARMAC_1,
                                     SFX_COL_GRASS_1,
                                     SFX_COL_GRAVEL_1,
@@ -181,7 +179,7 @@ cAudioManager::SetUpOneShotCollisionSound(const cAudioCollision &col)
 	uint16 s1;
 	uint16 s2;
 
-	int32 emittingVol;
+	uint32 emittingVol;
 	float ratio;
 
 	static uint16 counter = 28;
@@ -200,11 +198,11 @@ cAudioManager::SetUpOneShotCollisionSound(const cAudioCollision &col)
 			s1 = SURFACE_CAR_PANEL;
 			ratio = Min(1.f, 2.f * ratio);
 		}
-		emittingVol = 40.f * ratio;
+		emittingVol = 40 * ratio;
 		if(emittingVol) {
 			m_sQueueSample.m_fDistance = Sqrt(col.m_fDistance);
 			m_sQueueSample.m_nVolume =
-			    ComputeVolume(emittingVol, CollisionSoundIntensity, m_sQueueSample.m_fDistance);
+			    ComputeVolume(emittingVol, COLLISION_MAX_DIST, m_sQueueSample.m_fDistance);
 			if(m_sQueueSample.m_nVolume > 0) {
 				m_sQueueSample.m_nSampleIndex = gOneShotCol[s1];
 				switch(m_sQueueSample.m_nSampleIndex) {
@@ -268,7 +266,7 @@ cAudioManager::SetUpOneShotCollisionSound(const cAudioCollision &col)
 				SET_EMITTING_VOLUME(emittingVol);
 				RESET_LOOP_OFFSETS
 				m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-				m_sQueueSample.m_MaxDistance = CollisionSoundIntensity;
+				m_sQueueSample.m_MaxDistance = COLLISION_MAX_DIST;
 				m_sQueueSample.m_bStatic = TRUE;
 				SET_SOUND_REVERB(TRUE);
 				SET_SOUND_REFLECTION(FALSE);
@@ -286,7 +284,7 @@ cAudioManager::SetUpLoopingCollisionSound(const cAudioCollision &col, uint8 coun
 		uint8 emittingVol = SetLoopingCollisionRequestedSfxFreqAndGetVol(col);
 		if(emittingVol) {
 			CalculateDistance(distCalculated, m_sQueueSample.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, CollisionSoundIntensity, m_sQueueSample.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, COLLISION_MAX_DIST, m_sQueueSample.m_fDistance);
 			if(m_sQueueSample.m_nVolume > 0) {
 				m_sQueueSample.m_nCounter = counter;
 				m_sQueueSample.m_vecPos = col.m_vecPosition;
@@ -297,7 +295,7 @@ cAudioManager::SetUpLoopingCollisionSound(const cAudioCollision &col, uint8 coun
 				SET_EMITTING_VOLUME(emittingVol);
 				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 				m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-				m_sQueueSample.m_MaxDistance = CollisionSoundIntensity;
+				m_sQueueSample.m_MaxDistance = COLLISION_MAX_DIST;
 				m_sQueueSample.m_bStatic = FALSE;
 				m_sQueueSample.m_nFramesToPlay = 5;
 				SET_SOUND_REVERB(TRUE);
diff --git a/src/audio/AudioLogic.cpp b/src/audio/AudioLogic.cpp
index 9ca9599d..b8490563 100644
--- a/src/audio/AudioLogic.cpp
+++ b/src/audio/AudioLogic.cpp
@@ -19,6 +19,7 @@
 #include "ModelIndices.h"
 #include "MusicManager.h"
 #include "Pad.h"
+#include "ParticleObject.h"
 #include "Ped.h"
 #include "Physical.h"
 #include "Placeable.h"
@@ -44,9 +45,6 @@
 #include "Wanted.h"
 #include "KeyGen.h"
 
-// TODO: Get rid of *intensity* consts (and get rid of term 'intensity' in general)
-//       Make them defines, not floats because they were not floats on PS2
-
 void
 cAudioManager::PreInitialiseGameSpecificSetup()
 {
@@ -428,6 +426,300 @@ cAudioManager::ProcessPhysical(int32 id)
 	}
 }
 
+enum
+{
+	CAR_HELI_MAX_DIST = 250,
+	CAR_HELI_ENGINE_MAX_DIST = 140,
+	CAR_HELI_ENGINE_START_MAX_DIST = 30,
+	CAR_HELI_ENGINE_START_VOLUME = 70,
+	CAR_HELI_SEAPLANE_MAX_DIST = 20,
+	CAR_HELI_SEAPLANE_VOLUME = 100,
+	CAR_HELI_REAR_MAX_DIST = 27,
+	CAR_HELI_REAR_VOLUME = 25,
+
+	FLAT_TYRE_MAX_DIST = 60,
+	FLAT_TYRE_VOLUME = 100,
+
+
+	RAIN_ON_VEHICLE_MAX_DIST = 22,
+	RAIN_ON_VEHICLE_VOLUME = 30,
+
+	REVERSE_GEAR_MAX_DIST = 30,
+	REVERSE_GEAR_VOLUME = 24,
+
+	MODEL_CAR_ENGINE_MAX_DIST = 35,
+	MODEL_CAR_ENGINE_VOLUME = 90,
+	MODEL_HELI_ENGINE_VOLUME = 70,
+
+	VEHICLE_ROAD_NOISE_MAX_DIST = 95,
+	VEHICLE_ROAD_NOISE_VOLUME = 30,
+
+	WET_ROAD_NOISE_MAX_DIST = 30,
+	WET_ROAD_NOISE_VOLUME = 23,
+
+	VEHICLE_ENGINE_MAX_DIST = 50,
+	VEHICLE_ENGINE_BASE_VOLUME = 75,
+	VEHICLE_ENGINE_FULL_VOLUME = 90,
+
+	CESNA_IDLE_MAX_DIST = 200,
+	CESNA_REV_MAX_DIST = 90,
+	CESNA_VOLUME = 80,
+
+	PLAYER_VEHICLE_ENGINE_VOLUME = 120,
+
+	VEHICLE_SKIDDING_MAX_DIST = 40,
+	VEHICLE_SKIDDING_VOLUME = 50,
+
+	VEHICLE_HORN_MAX_DIST = 40,
+	VEHICLE_HORN_VOLUME = 80,
+
+	VEHICLE_SIREN_MAX_DIST = 110,
+	VEHICLE_SIREN_VOLUME = 80,
+
+	VEHICLE_REVERSE_WARNING_MAX_DIST = 50,
+	VEHICLE_REVERSE_WARNING_VOLUME = 60,
+
+	VEHICLE_DOORS_MAX_DIST = 40,
+	VEHICLE_DOORS_VOLUME = 100,
+
+	AIR_BRAKES_MAX_DIST = 30,
+	AIR_BRAKES_VOLUME = 70,
+
+	ENGINE_DAMAGE_MAX_DIST = 40,
+	ENGINE_DAMAGE_VOLUME = 6,
+	ENGINE_DAMAGE_ON_FIRE_VOLUME = 60,
+
+	CAR_BOMB_TICK_MAX_DIST = 40,
+	CAR_BOMB_TICK_VOLUME = 60,
+
+	VEHICLE_ONE_SHOT_HELI_BLADE_MAX_DIST = 35,
+	VEHICLE_ONE_SHOT_HELI_BLADE_VOLUME = 70,
+
+	VEHICLE_ONE_SHOT_CAR_TYRE_POP_MAX_DIST = 60,
+	VEHICLE_ONE_SHOT_CAR_TYRE_POP_VOLUME = 117,
+
+	VEHICLE_ONE_SHOT_DOOR_MAX_DIST = 50,
+	VEHICLE_ONE_SHOT_DOOR_OPEN_VOLUME = 122,
+	VEHICLE_ONE_SHOT_DOOR_CLOSE_VOLUME = 117,
+
+	VEHICLE_ONE_SHOT_WINDSHIELD_CRACK_MAX_DIST = 40,
+	VEHICLE_ONE_SHOT_WINDSHIELD_CRACK_VOLUME = 80,
+
+	VEHICLE_ONE_SHOT_CAR_JUMP_MAX_DIST = 35,
+	VEHICLE_ONE_SHOT_CAR_JUMP_VOLUME = 80,
+
+	VEHICLE_ONE_SHOT_CAR_ENGINE_START_MAX_DIST = 40,
+	VEHICLE_ONE_SHOT_CAR_ENGINE_START_VOLUME = 60,
+
+	VEHICLE_ONE_SHOT_CAR_LIGHT_BREAK_VOLUME = 30,
+
+	VEHICLE_ONE_SHOT_CAR_HYDRAULIC_MAX_DIST = 35,
+	VEHICLE_ONE_SHOT_CAR_HYDRAULIC_VOLUME = 55,
+
+	VEHICLE_ONE_SHOT_CAR_SPLASH_MAX_DIST = 60,
+	VEHICLE_ONE_SHOT_CAR_SPLASH_VOLUME = 35,
+
+	VEHICLE_ONE_SHOT_BOAT_SLOWDOWN_MAX_DIST = 50,
+
+	VEHICLE_ONE_SHOT_TRAIN_DOOR_MAX_DIST = 35,
+	VEHICLE_ONE_SHOT_TRAIN_DOOR_VOLUME = 70,
+
+	VEHICLE_ONE_SHOT_CAR_TANK_TURRET_MAX_DIST = 40,
+	VEHICLE_ONE_SHOT_CAR_TANK_TURRET_VOLUME = 90,
+
+	VEHICLE_ONE_SHOT_CAR_BOMB_TICK_MAX_DIST = 30,
+	VEHICLE_ONE_SHOT_CAR_BOMB_TICK_VOLUME = CAR_BOMB_TICK_VOLUME,
+
+	VEHICLE_ONE_SHOT_PLANE_ON_GROUND_MAX_DIST = 180,
+	VEHICLE_ONE_SHOT_PLANE_ON_GROUND_VOLUME = 75,
+
+	VEHICLE_ONE_SHOT_WEAPON_SHOT_FIRED_MAX_DIST = 120,
+	VEHICLE_ONE_SHOT_WEAPON_SHOT_FIRED_VOLUME = 65,
+
+	VEHICLE_ONE_SHOT_WEAPON_HIT_VEHICLE_MAX_DIST = 40,
+	VEHICLE_ONE_SHOT_WEAPON_HIT_VEHICLE_VOLUME = 90,
+
+	VEHICLE_ONE_SHOT_BOMB_ARMED_MAX_DIST = 50,
+	VEHICLE_ONE_SHOT_BOMB_ARMED_VOLUME = 50,
+
+	VEHICLE_ONE_SHOT_WATER_FALL_MAX_DIST = 40,
+	VEHICLE_ONE_SHOT_WATER_FALL_VOLUME = 90,
+
+	VEHICLE_ONE_SHOT_SPLATTER_MAX_DIST = 40,
+	VEHICLE_ONE_SHOT_SPLATTER_VOLUME = 55,
+
+	VEHICLE_ONE_SHOT_CAR_PED_COLLISION_MAX_DIST = 40,
+
+	TRAIN_NOISE_FAR_MAX_DIST = 140,
+	TRAIN_NOISE_NEAR_MAX_DIST = 70,
+	TRAIN_NOISE_VOLUME = 70,
+
+	BOAT_ENGINE_MAX_DIST = 90,
+	BOAT_ENGINE_REEFER_IDLE_VOLUME = 80,
+
+	BOAT_ENGINE_LOW_ACCEL_VOLUME = 45,
+	BOAT_ENGINE_HIGH_ACCEL_MIN_VOLUME = 15,
+	BOAT_ENGINE_HIGH_ACCEL_VOLUME_MULT = 105,
+
+	BOAT_MOVING_OVER_WATER_MAX_DIST = 50,
+	BOAT_MOVING_OVER_WATER_VOLUME = 30,
+
+	JUMBO_MAX_DIST = 440,
+	JUMBO_RUMBLE_SOUND_MAX_DIST = 240,
+	JUMBO_ENGINE_SOUND_MAX_DIST = 180,
+	JUMBO_WHINE_SOUND_MAX_DIST = 170,
+
+	PED_ONE_SHOT_SHIRT_FLAP_MAX_DIST = 15,
+	PED_ONE_SHOT_SHIRT_FLAP_VOLUME = 90,
+
+	PED_ONE_SHOT_MINIGUN_MAX_DIST = 150,
+	PED_ONE_SHOT_MINIGUN_VOLUME = MAX_VOLUME,
+
+	PED_ONE_SHOT_SKATING_MAX_DIST = 20,
+	PED_ONE_SHOT_SKATING_VOLUME = 70,
+
+	PED_ONE_SHOT_STEP_MAX_DIST = 20,
+	PED_ONE_SHOT_STEP_VOLUME = 45,
+
+	PED_ONE_SHOT_FALL_MAX_DIST = 30,
+	PED_ONE_SHOT_FALL_VOLUME = 80,
+
+	PED_ONE_SHOT_PUNCH_MAX_DIST = 30,
+	PED_ONE_SHOT_PUNCH_VOLUME = 100,
+
+	PED_ONE_SHOT_WEAPON_COLT45_VOLUME = 90,
+	PED_ONE_SHOT_WEAPON_UZI_VOLUME = 70,
+	PED_ONE_SHOT_WEAPON_SHOTGUN_VOLUME = 100,
+	PED_ONE_SHOT_WEAPON_M4_VOLUME = 90,
+	PED_ONE_SHOT_WEAPON_M16_VOLUME = MAX_VOLUME,
+	PED_ONE_SHOT_WEAPON_SNIPERRIFLE_VOLUME = 110,
+	PED_ONE_SHOT_WEAPON_ROCKETLAUNCHER_VOLUME = 80,
+
+	PED_ONE_SHOT_WEAPON_FLAMETHROWER_MAX_DIST = 60,
+	PED_ONE_SHOT_WEAPON_FLAMETHROWER_VOLUME = 90,
+
+	PED_ONE_SHOT_WEAPON_RELOAD_MAX_DIST = 30,
+	PED_ONE_SHOT_WEAPON_RELOAD_VOLUME = 75,
+
+	PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST = 120,
+	PED_ONE_SHOT_WEAPON_BULLET_ECHO_VOLUME = 80,
+
+	PED_ONE_SHOT_WEAPON_FLAMETHROWER_FIRE_MAX_DIST = 60,
+	PED_ONE_SHOT_WEAPON_FLAMETHROWER_FIRE_VOLUME = 70,
+
+	PED_ONE_SHOT_WEAPON_CHAINSAW_MAX_DIST = 60,
+	PED_ONE_SHOT_WEAPON_CHAINSAW_IDLE_MAX_DIST = 50,
+	PED_ONE_SHOT_WEAPON_CHAINSAW_VOLUME = 100,
+
+	PED_ONE_SHOT_WEAPON_HIT_PED_MAX_DIST = 30,
+	PED_ONE_SHOT_WEAPON_HIT_PED_VOLUME = 90,
+
+	PED_ONE_SHOT_SPLASH_MAX_DIST = 40,
+	PED_ONE_SHOT_SPLASH_PED_VOLUME = 70,
+
+	PED_COMMENT_MAX_DIST = 40,
+	PED_COMMENT_POLICE_HELI_MAX_DIST = 400,
+
+	EXPLOSION_DEFAULT_MAX_DIST = 200,
+	EXPLOSION_MOLOTOV_MAX_DIST = 150,
+	EXPLOSION_MINE_MAX_DIST = 200,
+
+	FIRE_DEFAULT_MAX_DIST = 80,
+	FIRE_DEFAULT_VOLUME = 80,
+	FIRE_BUILDING_MAX_DIST = 80,
+	FIRE_BUILDING_VOLUME = 100,
+	FIRE_PED_MAX_DIST = 25,
+	FIRE_PED_VOLUME = 60,
+	FIRE_EXTINGUISH_VOLUME = 100,
+
+	WATER_CANNON_MAX_DIST = 30,
+	WATER_CANNON_VOLUME = 50,
+
+	SCRIPT_OBJECT_SEAPLANE_LOW_FUEL_MAX_DIST = 1000,
+	SCRIPT_OBJECT_SEAPLANE_LOW_FUEL_VOLUME = 100,
+
+	SCRIPT_OBJECT_WILLIE_CARD_SWIPE_MAX_DIST = 40,
+	SCRIPT_OBJECT_WILLIE_CARD_SWIPE_VOLUME = 70,
+
+	SCRIPT_OBJECT_GATE_MAX_DIST = 40,
+
+	SCRIPT_OBJECT_BULLET_HIT_GROUND_MAX_DIST = 50,
+	SCRIPT_OBJECT_BULLET_HIT_GROUND_VOLUME = 90,
+
+	SCRIPT_OBJECT_PAYPHONE_RINGING_MAX_DIST = 80,
+	SCRIPT_OBJECT_PAYPHONE_RINGING_VOLUME = 80,
+
+	SCRIPT_OBJECT_GLASS_BREAK_MAX_DIST = 60,
+	SCRIPT_OBJECT_GLASS_BREAK_LONG_VOLUME = 70,
+	SCRIPT_OBJECT_GLASS_BREAK_SHORT_VOLUME = 60,
+
+	SCRIPT_OBJECT_GLASS_LIGHT_BREAK_MAX_DIST = 55,
+	SCRIPT_OBJECT_GLASS_LIGHT_BREAK_VOLUME = 25,
+
+	SCRIPT_OBJECT_BOX_DESTROYED_MAX_DIST = 60,
+	SCRIPT_OBJECT_BOX_DESTROYED_VOLUME = 80,
+
+	SCRIPT_OBJECT_METAL_COLLISION_VOLUME = 70,
+	SCRIPT_OBJECT_TIRE_COLLISION_VOLUME = 60,
+	SCRIPT_OBJECT_HIT_BALL_VOLUME = 60,
+
+	SCRIPT_OBJECT_GUNSHELL_MAX_DIST = 20,
+	SCRIPT_OBJECT_GUNSHELL_VOLUME = 30,
+
+	SCRIPT_OBJECT_POLICE_CELL_DOOR_CLUNK_MAX_DIST = 40,
+	SCRIPT_OBJECT_POLICE_CELL_DOOR_CLUNK_VOLUME = 60,
+
+	SCRIPT_OBJECT_GARAGE_DOOR_CLUNK_MAX_DIST = 80,
+	SCRIPT_OBJECT_GARAGE_DOOR_CLUNK_VOLUME = 60,
+
+	//SCRIPT_OBJECT_SHORT_MAX_DIST = 30,
+	SCRIPT_OBJECT_LONG_MAX_DIST = 80,
+	SCRIPT_OBJECT_DEFAULT_VOLUME = MAX_VOLUME,
+	SCRIPT_OBJECT_BANK_ALARM_VOLUME = 90,
+	SCRIPT_OBJECT_SNORING_MAX_DIST = 6,
+	SCRIPT_OBJECT_SNORING_VOLUME = 25,
+	SCRIPT_OBJECT_GARAGE_DOOR_SLIDING_VOLUME = 90,
+	SCRIPT_OBJECT_SHOOTING_RANGE_TARGET_MOVING_MAX_DIST = 40,
+	SCRIPT_OBJECT_SHOOTING_RANGE_TARGET_MOVING_VOLUME = 60,
+	SCRIPT_OBJECT_NEW_WATERFALL_VOLUME = 30,
+
+	FRONTEND_VOLUME = 127,
+
+	//CRANE_MAX_DIST = 80,
+	//CRANE_VOLUME = 100,
+
+	PROJECTILE_ROCKET_MAX_DIST = 90,
+	PROJECTILE_ROCKET_VOLUME = MAX_VOLUME,
+
+	PROJECTILE_MOLOTOV_MAX_DIST = 30,
+	PROJECTILE_MOLOTOV_VOLUME = 50,
+
+	PROJECTILE_TEARGAS_MAX_DIST = 40,
+	PROJECTILE_TEARGAS_VOLUME = 80,
+
+	ESCALATOR_MAX_DIST = 30,
+	ESCALATOR_VOLUME = 26,
+
+	ARCADE_MAX_DIST = 18,
+	ARCADE_VOLUME = 50,
+
+	GARAGES_MAX_DIST = 80,
+	GARAGES_VOLUME = 90,
+	GARAGES_DOOR_VOLUME = 60,
+
+	FIRE_HYDRANT_MAX_DIST = 35,
+	FIRE_HYDRANT_VOLUME = 40,
+
+	BRIDGE_MOTOR_MAX_DIST = 400,
+	BRIDGE_MOTOR_VOLUME = MAX_VOLUME,
+	BRIDGE_MAX_DIST = BRIDGE_MOTOR_MAX_DIST + 50,
+
+	BRIDGE_WARNING_VOLUME = 100,
+
+	MISSION_AUDIO_MAX_DIST = 80,
+	MISSION_AUDIO_VOLUME = 127,
+};
+
 #pragma region VEHICLE AUDIO
 enum eVehicleModel {
 	LANDSTAL,
@@ -683,7 +975,7 @@ const eSfxSample aEngineSounds[][2] = {
 };
 bool8 bPlayerJustEnteredCar;
 
-const bool8 HornPattern[8][44] = {
+Const static bool8 HornPattern[8][44] = {
     {FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
      FALSE, TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  TRUE,  FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE},
     {FALSE, FALSE, TRUE,  TRUE,  TRUE,  FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE,  FALSE,
@@ -705,139 +997,136 @@ const bool8 HornPattern[8][44] = {
 void
 cAudioManager::ProcessVehicle(CVehicle* veh)
 {
-	CVehicle* playerVeh;
 	cVehicleParams params;
-	CBike* bike;
-	CAutomobile* automobile;
 
-	playerVeh = FindVehicleOfPlayer();
-	if (playerVeh == veh
-		|| CGame::currArea == AREA_OVALRING
-		|| CGame::currArea == AREA_BLOOD
-		|| CGame::currArea == AREA_DIRT
-		|| CGame::currArea == AREA_EVERYWHERE
-		|| CGame::currArea == AREA_MALL
-		|| CGame::currArea == AREA_MAIN_MAP) {
-		m_sQueueSample.m_vecPos = veh->GetPosition();
-		params.m_bDistanceCalculated = FALSE;
-		params.m_pVehicle = veh;
-		params.m_fDistance = GetDistanceSquared(m_sQueueSample.m_vecPos);
-		params.m_pTransmission = veh->pHandling != nil ? &veh->pHandling->Transmission : nil;
-		params.m_nIndex = veh->m_modelIndex - MI_FIRST_VEHICLE;
-		if (veh->GetStatus() == STATUS_SIMPLE)
-			params.m_fVelocityChange = veh->AutoPilot.m_fMaxTrafficSpeed * 0.02f;
-		else
-			params.m_fVelocityChange = DotProduct(veh->m_vecMoveSpeed, veh->GetForward());
-		params.m_VehicleType = veh->m_vehType;
-		
-		if (CGame::currArea == AREA_MALL && playerVeh != veh) {
-			ProcessVehicleOneShots(params);
-			ProcessVehicleSirenOrAlarm(params);
-			ProcessEngineDamage(params);
+	if (FindVehicleOfPlayer() != veh) {
+		switch (CGame::currArea)
+		{
+		case AREA_OVALRING:
+		case AREA_BLOOD:
+		case AREA_DIRT:
+		case AREA_EVERYWHERE:
+		case AREA_MALL:
+		case AREA_MAIN_MAP:
+			break;
+		default:
 			return;
 		}
-		switch (params.m_VehicleType) {
-		case VEHICLE_TYPE_CAR:
-			automobile = (CAutomobile*)veh;
-			UpdateGasPedalAudio(veh, params.m_VehicleType);
-			if (veh->m_modelIndex == MI_RCBANDIT || veh->m_modelIndex == MI_RCBARON) {
-				ProcessModelVehicle(params);
-				ProcessEngineDamage(params);
-			} else if (veh->m_modelIndex == MI_RCRAIDER || veh->m_modelIndex == MI_RCGOBLIN) {
-				ProcessModelHeliVehicle(params);
+	}
+
+	m_sQueueSample.m_vecPos = veh->GetPosition();
+	params.m_bDistanceCalculated = FALSE;
+	params.m_pVehicle = veh;
+	params.m_fDistance = GetDistanceSquared(m_sQueueSample.m_vecPos);
+	params.m_pTransmission = veh->pHandling != nil ? &veh->pHandling->Transmission : nil;
+	params.m_nIndex = veh->m_modelIndex - MI_FIRST_VEHICLE;
+	if (veh->GetStatus() == STATUS_SIMPLE)
+		params.m_fVelocityChange = veh->AutoPilot.m_fMaxTrafficSpeed * 0.02f;
+	else
+		params.m_fVelocityChange = DotProduct(veh->m_vecMoveSpeed, veh->GetForward());
+	params.m_VehicleType = veh->m_vehType;
+		
+	if (CGame::currArea == AREA_MALL && FindVehicleOfPlayer() != veh) {
+		ProcessVehicleOneShots(params);
+		ProcessVehicleSirenOrAlarm(params);
+		ProcessEngineDamage(params);
+		return;
+	}
+	switch (params.m_VehicleType) {
+	case VEHICLE_TYPE_CAR:
+		UpdateGasPedalAudio(veh, params.m_VehicleType);
+		if (veh->m_modelIndex == MI_RCBANDIT || veh->m_modelIndex == MI_RCBARON) {
+			ProcessModelVehicle(params);
+			ProcessEngineDamage(params);
+		} else if (veh->m_modelIndex == MI_RCRAIDER || veh->m_modelIndex == MI_RCGOBLIN) {
+			ProcessModelHeliVehicle(params);
+			ProcessEngineDamage(params);
+		} else {
+			switch (veh->GetVehicleAppearance()) {
+			case VEHICLE_APPEARANCE_HELI:
+				ProcessCarHeli(params);
+				ProcessVehicleFlatTyre(params);
 				ProcessEngineDamage(params);
-			} else {
-				switch (veh->GetVehicleAppearance()) {
-				case VEHICLE_APPEARANCE_HELI:
-					ProcessCarHeli(params);
+				break;
+			case VEHICLE_APPEARANCE_BOAT:
+			case VEHICLE_APPEARANCE_PLANE:
+				break;
+			default:
+				if (ProcessVehicleRoadNoise(params)) {
+					ProcessReverseGear(params);
+					if (CWeather::WetRoads > 0.0f)
+						ProcessWetRoadNoise(params);
+					ProcessVehicleSkidding(params);
 					ProcessVehicleFlatTyre(params);
+					ProcessVehicleHorn(params);
+					ProcessVehicleSirenOrAlarm(params);
+					if (UsesReverseWarning(params.m_nIndex))
+						ProcessVehicleReverseWarning(params);
+					if(HasAirBrakes(params.m_nIndex))
+						ProcessAirBrakes(params);
+					ProcessCarBombTick(params);
+					ProcessVehicleEngine(params);
 					ProcessEngineDamage(params);
-					break;
-				case VEHICLE_APPEARANCE_BOAT:
-				case VEHICLE_APPEARANCE_PLANE:
-					break;
-				default:
-					if (ProcessVehicleRoadNoise(params)) {
-						ProcessReverseGear(params);
-						if (CWeather::WetRoads > 0.0f)
-							ProcessWetRoadNoise(params);
-						ProcessVehicleSkidding(params);
-						ProcessVehicleFlatTyre(params);
-						ProcessVehicleHorn(params);
-						ProcessVehicleSirenOrAlarm(params);
-						if (UsesReverseWarning(params.m_nIndex))
-							ProcessVehicleReverseWarning(params);
-						if(HasAirBrakes(params.m_nIndex))
-							ProcessAirBrakes(params);
-						ProcessCarBombTick(params);
-						ProcessVehicleEngine(params);
-						ProcessEngineDamage(params);
-						ProcessVehicleDoors(params);
-					}
-					break;
+					ProcessVehicleDoors(params);
 				}
+				break;
 			}
-			ProcessVehicleOneShots(params);
-			automobile->m_fVelocityChangeForAudio = params.m_fVelocityChange;
-			break;
-		case VEHICLE_TYPE_BOAT:
-			if (veh->m_modelIndex == MI_SKIMMER)
-				ProcessCarHeli(params);
-			else
-				ProcessBoatEngine(params);
-			ProcessBoatMovingOverWater(params);
-			ProcessVehicleOneShots(params);
-			break;
+		}
+		ProcessVehicleOneShots(params);
+		((CAutomobile*)veh)->m_fVelocityChangeForAudio = params.m_fVelocityChange;
+		break;
+	case VEHICLE_TYPE_BOAT:
+		if (veh->m_modelIndex == MI_SKIMMER)
+			ProcessCarHeli(params);
+		else
+			ProcessBoatEngine(params);
+		ProcessBoatMovingOverWater(params);
+		ProcessVehicleOneShots(params);
+		break;
 #ifdef GTA_TRAIN
 		case VEHICLE_TYPE_TRAIN:
 			ProcessTrainNoise(params);
 			ProcessVehicleOneShots(params);
 			break;
 #endif
-		case VEHICLE_TYPE_HELI: 
-			ProcessCarHeli(params);
-			ProcessVehicleOneShots(params);
-			break;
-		case VEHICLE_TYPE_PLANE:
-			ProcessPlane(params);
-			ProcessVehicleOneShots(params);
+	case VEHICLE_TYPE_HELI: 
+		ProcessCarHeli(params);
+		ProcessVehicleOneShots(params);
+		break;
+	case VEHICLE_TYPE_PLANE:
+		ProcessPlane(params);
+		ProcessVehicleOneShots(params);
+		ProcessVehicleFlatTyre(params);
+		break;
+	case VEHICLE_TYPE_BIKE:
+		UpdateGasPedalAudio(veh, params.m_VehicleType);
+		if (ProcessVehicleRoadNoise(params)) {
+			if (CWeather::WetRoads > 0.0f)
+				ProcessWetRoadNoise(params);
+			ProcessVehicleSkidding(params);
+			ProcessVehicleHorn(params);
+			ProcessVehicleSirenOrAlarm(params);
+			ProcessCarBombTick(params);
+			ProcessEngineDamage(params);
+			ProcessVehicleEngine(params);
 			ProcessVehicleFlatTyre(params);
-			break;
-		case VEHICLE_TYPE_BIKE:
-			bike = (CBike*)veh;
-			UpdateGasPedalAudio(veh, params.m_VehicleType);
-			if (ProcessVehicleRoadNoise(params)) {
-				if (CWeather::WetRoads > 0.0f)
-					ProcessWetRoadNoise(params);
-				ProcessVehicleSkidding(params);
-				ProcessVehicleHorn(params);
-				ProcessVehicleSirenOrAlarm(params);
-				ProcessCarBombTick(params);
-				ProcessEngineDamage(params);
-				ProcessVehicleEngine(params);
-				ProcessVehicleFlatTyre(params);
-			}
-			ProcessVehicleOneShots(params);
-			bike->m_fVelocityChangeForAudio = params.m_fVelocityChange;
-			break;
-		default:
-			break;
 		}
-		ProcessRainOnVehicle(params);
+		ProcessVehicleOneShots(params);
+		((CBike*)veh)->m_fVelocityChangeForAudio = params.m_fVelocityChange;
+		break;
+	default:
+		break;
 	}
+	ProcessRainOnVehicle(params);
 }
 
-void
+bool8
 cAudioManager::ProcessCarHeli(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 250.0f;
-
-	CVehicle* playerVeh;
-	CVehicle* veh;
 	CAutomobile* automobile;
 	CBoat* boat;
 
-	uint8 emittingVol;
+	uint8 Vol;
 	int16 brakeState;
 	int16 accelerateState;
 	uint32 freq;
@@ -850,245 +1139,175 @@ cAudioManager::ProcessCarHeli(cVehicleParams& params)
 
 	float volumeModifier;//TODO find better name
 	bool8 hunterBool;
-	
-	static uint32 freqFrontPrev = 14287;
-	static uint32 freqPropellerPrev = 7143;
-	static uint32 freqSkimmerPrev = 14287;
+	CMatrix cameraMatrix;
 
 	boat = nil;
 	automobile = nil;
 	hunterBool = FALSE;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return;
+	static uint32 freqFrontPrev = 14287;
+	static uint32 freqPropellerPrev = 7143;
+	static uint32 freqSkimmerPrev = 14287;
 
-	playerVeh = FindPlayerVehicle();
-	veh = params.m_pVehicle;
-	if (playerVeh == veh) {
-		accelerateState = Pads[0].GetAccelerate();
-		brakeState = Pads[0].GetBrake();
-	} else {
-		accelerateState = veh->m_fGasPedal * 255.0f;
-		brakeState = veh->m_fBrakePedal * 255.0f;
-	}
-	freqModifier = Abs(veh->GetUp().y);
-	cameraAngle = (DotProduct(veh->GetMatrix().GetForward(), TheCamera.GetForward()) + 1.0f) / 2.0f;
-	if (veh->m_modelIndex == MI_SKIMMER) {
-		boat = (CBoat*)veh;
-		propellerSpeed = boat->m_fMovingSpeed * 50.0f / 11.0f;
-	} else if (params.m_VehicleType == VEHICLE_TYPE_HELI) {
-		propellerSpeed = 1.0f;
-	} else {
-		automobile = (CAutomobile*)veh;
-		propellerSpeed = automobile->m_aWheelSpeed[1] * 50.0f / 11.0f;
-	}
 
-	if (propellerSpeed == 0.0f)
-		return;
+	if (params.m_fDistance < SQR(CAR_HELI_MAX_DIST)) {
+		if (FindPlayerVehicle() == params.m_pVehicle) {
+			accelerateState = Pads[0].GetAccelerate();
+			brakeState = Pads[0].GetBrake();
+		} else {
+			accelerateState = params.m_pVehicle->m_fGasPedal * 255.0f;
+			brakeState = params.m_pVehicle->m_fBrakePedal * 255.0f;
+		}
+		cameraMatrix = TheCamera.GetMatrix();
+		freqModifier = DotProduct(cameraMatrix.GetUp(), CVector(0.0f, 1.0f, 0.0f));
+		freqModifier = ABS(freqModifier);
+		cameraAngle = (DotProduct(params.m_pVehicle->GetMatrix().GetForward(), cameraMatrix.GetForward()) + 1.0f) / 2.0f;
+		if (params.m_pVehicle->GetModelIndex() == MI_SKIMMER) {
+			boat = (CBoat*)params.m_pVehicle;
+			propellerSpeed = boat->m_fMovingSpeed * 50.0f / 11.0f;
+		} else if (params.m_VehicleType == VEHICLE_TYPE_HELI) {
+			propellerSpeed = 1.0f;
+		} else {
+			automobile = (CAutomobile*)params.m_pVehicle;
+			propellerSpeed = automobile->m_aWheelSpeed[1] * 50.0f / 11.0f;
+		}
+
+		if (propellerSpeed == 0.0f)
+			return TRUE;
 
-	propellerSpeed = Min(1.0f, propellerSpeed);
-	CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+		propellerSpeed = Min(1.0f, propellerSpeed);
+		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
 
 
-	//sound on long distances
-	if (m_sQueueSample.m_fDistance >= 40.0f)
-		emittingVol = propellerSpeed * 75.0f;
-	else if (m_sQueueSample.m_fDistance >= 25.0f)
-		emittingVol = (m_sQueueSample.m_fDistance - 25.0f) * (75.0f * propellerSpeed) / 15.0f;
-	else
-		emittingVol = 0;
-	if (emittingVol != 0) {
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nCounter = 88;
-			if (boat != nil) {
-				m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_PRO3;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				if (accelerateState > 0 || brakeState > 0)
-					m_sQueueSample.m_nFrequency = 4600 + Min(1.0f, (Max(accelerateState, brakeState) / 255.0f) * freqModifier) * 563;
-				else
-					m_sQueueSample.m_nFrequency = 3651 + Min(1.0f, freqModifier) * 949;
-			} else {
-				m_sQueueSample.m_nSampleIndex = SFX_HELI_1;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+		//sound on long distances
+		if (m_sQueueSample.m_fDistance < 40.0f) {
+			if (m_sQueueSample.m_fDistance < 25.0f)
+				Vol = 0;
+			else
+				Vol = (m_sQueueSample.m_fDistance - 25.0f) * (75.0f * propellerSpeed) / 15.0f;
+		} else
+			Vol = propellerSpeed * 75.0f;
+		if (Vol > 0) {
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, CAR_HELI_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = 88;
+				if (boat != nil) {
+					m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_PRO3;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					if (accelerateState > 0 || brakeState > 0)
+						m_sQueueSample.m_nFrequency = 4600 + Min(1.0f, (Max(accelerateState, brakeState) / 255.0f) * freqModifier) * 563;
+					else
+						m_sQueueSample.m_nFrequency = 3651 + Min(1.0f, freqModifier) * 949;
+				} else {
+					m_sQueueSample.m_nSampleIndex = SFX_HELI_1;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+				}
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 2;
+				m_sQueueSample.m_nLoopCount = 0;
+				SET_EMITTING_VOLUME(Vol);
+				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+				m_sQueueSample.m_fSpeedMultiplier = 6.0f;
+				m_sQueueSample.m_MaxDistance = CAR_HELI_MAX_DIST;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 5;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
 			}
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVol);
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 5;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
 		}
-	}
 	
-	CVector backPropellerPos;
-	if (automobile != nil)
-		automobile->GetComponentWorldPosition(CAR_BOOT, backPropellerPos);
-	else if (params.m_VehicleType == VEHICLE_TYPE_HELI) 
+		CVector backPropellerPos;
+		if (automobile != nil)
+			automobile->GetComponentWorldPosition(CAR_BOOT, backPropellerPos);
+		else if (params.m_VehicleType == VEHICLE_TYPE_HELI) 
 #ifdef FIX_BUGS
-		backPropellerPos = 
+			backPropellerPos = 
 #endif
-		params.m_pVehicle->GetMatrix() * CVector(0.0f, -10.0f, 0.0f);
-	else
-		backPropellerPos = m_sQueueSample.m_vecPos;
-
-	if (params.m_fDistance >= SQR(140.0f))
-		return;
-
-	if (propellerSpeed >= 0.4f)
-		volumeModifier = (propellerSpeed - 0.4f) * 5.0f / 3.0f;
-	else
-		volumeModifier = 0.0f;
-	if (!boat) {
-		freq = Min(1300, 7000.0f * freqModifier);
-		if (playerVeh == veh && (accelerateState > 0 || brakeState > 0) && freq < 1300)//unnesesary freqModifier alredy <= 1300
-			freq = 1300;
-		if (veh->m_modelIndex == MI_HUNTER)
-			hunterBool = TRUE;
-	}
-
-
-	//sound from front of helicopter
-	emittingVol = (1.0f - cameraAngle) * volumeModifier * 127.0f;
-	m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, 140.0f, m_sQueueSample.m_fDistance);
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 3;
-		if (hunterBool) {
-			m_sQueueSample.m_nSampleIndex = SFX_HELI_APACHE_1;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nFrequency = (volumeModifier + 1.0f) * 16000 + freq;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 1;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVol);
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-			m_sQueueSample.m_MaxDistance = 140.0f;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 5;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
-		} else if (boat != nil) {
-			m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_PRO1;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-
-			if (accelerateState > 0 || brakeState > 0)
-				m_sQueueSample.m_nFrequency = 18000 + Min(1.0f, freqModifier * (Max(accelerateState, brakeState) / 255.0f)) * 2204;
-			else
-				m_sQueueSample.m_nFrequency = 14287 + Min(1.0f, freqModifier) * 3713;
-			if (propellerSpeed < 1.0f)
-				m_sQueueSample.m_nFrequency = (propellerSpeed + 1.0f) * (m_sQueueSample.m_nFrequency / 2.0f);
-			m_sQueueSample.m_nFrequency = Clamp2(m_sQueueSample.m_nFrequency, freqFrontPrev, 197);
-			freqFrontPrev = m_sQueueSample.m_nFrequency;
-
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 1;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVol);
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-			m_sQueueSample.m_MaxDistance = 140.0f;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 5;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
-		} else {
-			m_sQueueSample.m_nSampleIndex = SFX_CAR_HELI_MAI;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nFrequency = (volumeModifier + 1) * 16000 + freq;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 1;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVol);
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-			m_sQueueSample.m_MaxDistance = 140.0f;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 5;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
-		}
-	}
-
-
-	//after accel rotor sound
-	emittingVol = ((cameraAngle + 1.0f) * volumeModifier * 127.0f) / 2.0f;
-	m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, 140.0f, m_sQueueSample.m_fDistance);
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 1;
-		if (hunterBool) {
-			m_sQueueSample.m_nSampleIndex = SFX_HELI_APACHE_2;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nFrequency = (volumeModifier + 1) * 16000 + freq;
-		} else if (boat) {
-			m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_PRO2;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			params.m_pVehicle->GetMatrix() * CVector(0.0f, -10.0f, 0.0f);
+		else
+			backPropellerPos = m_sQueueSample.m_vecPos;
 
-			if (accelerateState > 0 || brakeState > 0)
-				m_sQueueSample.m_nFrequency = 9000 + Min(1.0f, (Max(accelerateState, brakeState) / 255) * freqModifier) * 1102;
+		if (params.m_fDistance < SQR(CAR_HELI_ENGINE_MAX_DIST)) {
+			if (propellerSpeed < 0.4f)
+				volumeModifier = 0.0f;
 			else
-				m_sQueueSample.m_nFrequency = 7143 + Min(1.0f, freqModifier) * 1857;
+				volumeModifier = (propellerSpeed - 0.4f) * 5.0f / 3.0f;
+			if (!boat) {
+				freq = Min(1300, 7000 * freqModifier);
+				if (FindPlayerVehicle() == params.m_pVehicle && (accelerateState > 0 || brakeState > 0) && freq < 1300)//unnesesary freqModifier alredy <= 1300
+					freq = 1300;
+				if (params.m_pVehicle->GetModelIndex() == MI_HUNTER)
+					hunterBool = TRUE;
+			}
 
-			if (propellerSpeed < 1.0f)
-				m_sQueueSample.m_nFrequency = (propellerSpeed + 1) * (m_sQueueSample.m_nFrequency / 2);
+			//sound from front of helicopter
+			Vol = (1.0f - cameraAngle) * volumeModifier * MAX_VOLUME;
+			if (!boat) {
+				if (accelerateState > 0 || brakeState > 0)
+					m_sQueueSample.m_nFrequency = 18000 + Min(1.0f, freqModifier * (Max(accelerateState, brakeState) / 255.0f)) * 2204;
+				else
+					m_sQueueSample.m_nFrequency = 14287 + Min(1.0f, freqModifier) * 3713;
+				if (propellerSpeed < 1.0f)
+					m_sQueueSample.m_nFrequency = (propellerSpeed + 1.0f) * (m_sQueueSample.m_nFrequency >> 1);
+				m_sQueueSample.m_nFrequency = Clamp2(m_sQueueSample.m_nFrequency, freqFrontPrev, 197);
+				freqFrontPrev = m_sQueueSample.m_nFrequency;
+			}
 
-			m_sQueueSample.m_nFrequency = Clamp2(m_sQueueSample.m_nFrequency, freqPropellerPrev, 98);
-			freqPropellerPrev = m_sQueueSample.m_nFrequency;
-		} else {
-			m_sQueueSample.m_nSampleIndex = SFX_CAR_HELI_MAI2;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nFrequency = (volumeModifier + 1) * 16000 + freq;
-		}
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 1;
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(emittingVol);
-		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-		m_sQueueSample.m_MaxDistance = 140.0f;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 5;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
-	}
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, CAR_HELI_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = 3;
+				if (hunterBool) {
+					m_sQueueSample.m_nSampleIndex = SFX_HELI_APACHE_1;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nFrequency = (volumeModifier + 1.0f) * 16000 + freq;
+				} else if (boat) {
+					m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_PRO1;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				} else {
+					m_sQueueSample.m_nSampleIndex = SFX_CAR_HELI_MAI;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nFrequency = (volumeModifier + 1.0f) * 16000 + freq;
+				}
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 1;
+				m_sQueueSample.m_nLoopCount = 0;
+				SET_EMITTING_VOLUME(Vol);
+				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 6.0f;
+				m_sQueueSample.m_MaxDistance = CAR_HELI_ENGINE_MAX_DIST;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 5;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
+			}
 
 
-	//engine starting sound 
-	if (boat == nil && params.m_VehicleType != VEHICLE_TYPE_HELI && m_sQueueSample.m_fDistance < 30.0f) { //strange way to check if automobile != nil
-		if (automobile->bEngineOn) {
-			if (propellerSpeed < 1.0f) {
-				emittingVol = (1.0f - propellerSpeed / 2.0f) * 70.0f;
-				m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, 30.0f, m_sQueueSample.m_fDistance);
+			//engine starting sound 
+			if (boat == nil && params.m_VehicleType != VEHICLE_TYPE_HELI && m_sQueueSample.m_fDistance < CAR_HELI_ENGINE_START_MAX_DIST && automobile->bEngineOn && propellerSpeed < 1.0f) { //strange way to check if automobile != nil
+				Vol = (1.0f - propellerSpeed / 2.0f) * CAR_HELI_ENGINE_START_VOLUME;
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, CAR_HELI_ENGINE_START_MAX_DIST, m_sQueueSample.m_fDistance);
 				if (m_sQueueSample.m_nVolume > 0) {
 					if (hunterBool) {
 						m_sQueueSample.m_nSampleIndex = SFX_HELI_APACHE_4;
 						m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-						freq = 3000.0f * propellerSpeed + 30000;
+						freq = 3000 * propellerSpeed + 30000;
 					} else {
 						m_sQueueSample.m_nSampleIndex = SFX_CAR_HELI_STA;
 						m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-						freq = 3000.0f * propellerSpeed + 6000;
+						freq = 3000 * propellerSpeed + 6000;
 					}
 					m_sQueueSample.m_nFrequency = freq;
 					m_sQueueSample.m_nCounter = 12;
 					m_sQueueSample.m_bIs2D = FALSE;
 					m_sQueueSample.m_nPriority = 1;
 					m_sQueueSample.m_nLoopCount = 0;
-					SET_EMITTING_VOLUME(emittingVol);
+					SET_EMITTING_VOLUME(Vol);
 					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 					m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-					m_sQueueSample.m_MaxDistance = 30.0f;
+					m_sQueueSample.m_MaxDistance = CAR_HELI_ENGINE_START_MAX_DIST;
 					m_sQueueSample.m_bStatic = FALSE;
 					m_sQueueSample.m_nFramesToPlay = 30;
 					SET_SOUND_REVERB(TRUE);
@@ -1096,115 +1315,152 @@ cAudioManager::ProcessCarHeli(cVehicleParams& params)
 					AddSampleToRequestedQueue();
 				}
 			}
-		}
-	}
 
+			//after accel rotor sound
 
-	if (boat) {
-		if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FIXED && m_sQueueSample.m_fDistance < 20.0f && propellerSpeed > 0.0f) {
-			m_sQueueSample.m_nVolume = ComputeVolume(propellerSpeed * 100.0f, 20.0f, m_sQueueSample.m_fDistance);
-			if (m_sQueueSample.m_nVolume > 0) {
-
+			Vol = ((cameraAngle + 1.0f) * volumeModifier * MAX_VOLUME) / 2.0f;
+			if (boat) {
 				if (accelerateState > 0 || brakeState > 0)
-					m_sQueueSample.m_nFrequency = 18000 + Min(1.0f, (Max(accelerateState, brakeState) / 255.0f) * freqModifier) * 2204;
+					m_sQueueSample.m_nFrequency = 9000 + Min(1.0f, (Max(accelerateState, brakeState) / 255) * freqModifier) * 1102;
 				else
-					m_sQueueSample.m_nFrequency = 14287 + Min(1.0f, freqModifier) * 3713;
+					m_sQueueSample.m_nFrequency = 7143 + Min(1.0f, freqModifier) * 1857;
+
 				if (propellerSpeed < 1.0f)
-					m_sQueueSample.m_nFrequency = (propellerSpeed + 1) * (m_sQueueSample.m_nFrequency / 2.0f);
-				m_sQueueSample.m_nFrequency = Clamp2(m_sQueueSample.m_nFrequency, freqSkimmerPrev, 197);
-				freqSkimmerPrev = m_sQueueSample.m_nFrequency;
+					m_sQueueSample.m_nFrequency = (propellerSpeed + 1) * (m_sQueueSample.m_nFrequency >> 1);
 
-				m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_PRO4;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_nCounter = 12;
-				m_sQueueSample.m_bIs2D = FALSE;
-				m_sQueueSample.m_nPriority = 3;
-				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(propellerSpeed * 100.0f);
-				SET_LOOP_OFFSETS(SFX_SEAPLANE_PRO4)
-				m_sQueueSample.m_fSpeedMultiplier = 5.0f;
-				m_sQueueSample.m_MaxDistance = 20.0f;
-				m_sQueueSample.m_bStatic = FALSE;
-				m_sQueueSample.m_nFramesToPlay = 7;
-				SET_SOUND_REVERB(TRUE);
-				SET_SOUND_REFLECTION(FALSE);
-				AddSampleToRequestedQueue();
+				m_sQueueSample.m_nFrequency = Clamp2(m_sQueueSample.m_nFrequency, freqPropellerPrev, 98);
+				freqPropellerPrev = m_sQueueSample.m_nFrequency;
 			}
-		}
-	} else {
-		//vacuum cleaner sound
-		vecPosOld = m_sQueueSample.m_vecPos;
-		distanceCalculatedOld = params.m_bDistanceCalculated;
-		distanceOld = params.m_fDistance;
-
-		m_sQueueSample.m_vecPos = backPropellerPos;
-		params.m_bDistanceCalculated = FALSE;
-		params.m_fDistance = GetDistanceSquared(m_sQueueSample.m_vecPos);
-		if (params.m_fDistance < SQR(27.0f)) {
-			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(volumeModifier * 25.0f, 27.0f, m_sQueueSample.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, CAR_HELI_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
 			if (m_sQueueSample.m_nVolume > 0) {
-				m_sQueueSample.m_nCounter = 2;
-				m_sQueueSample.m_nSampleIndex = hunterBool ? SFX_HELI_APACHE_3 : SFX_CAR_HELI_REA;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_nCounter = 1;
+				if (hunterBool) {
+					m_sQueueSample.m_nSampleIndex = SFX_HELI_APACHE_2;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nFrequency = (volumeModifier + 1) * 16000 + freq;
+				} else if (boat) {
+					m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_PRO2;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				} else {
+					m_sQueueSample.m_nSampleIndex = SFX_CAR_HELI_MAI2;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nFrequency = (volumeModifier + 1) * 16000 + freq;
+				}
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_nPriority = 1;
-				m_sQueueSample.m_nFrequency = (volumeModifier + 1.0f) * 16000;
 				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(volumeModifier * 25.0f);
+				SET_EMITTING_VOLUME(Vol);
 				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 				m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-				m_sQueueSample.m_MaxDistance = 27.0f;
+				m_sQueueSample.m_MaxDistance = CAR_HELI_ENGINE_MAX_DIST;
 				m_sQueueSample.m_bStatic = FALSE;
 				m_sQueueSample.m_nFramesToPlay = 5;
 				SET_SOUND_REVERB(TRUE);
 				SET_SOUND_REFLECTION(FALSE);
 				AddSampleToRequestedQueue();
 			}
-		}
+
+			if (boat) {
+				if (TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_FIXED && m_sQueueSample.m_fDistance < CAR_HELI_SEAPLANE_MAX_DIST && propellerSpeed > 0.0f) {
+					m_sQueueSample.m_nVolume = ComputeVolume(propellerSpeed * CAR_HELI_SEAPLANE_VOLUME, CAR_HELI_SEAPLANE_MAX_DIST, m_sQueueSample.m_fDistance);
+					if (accelerateState > 0 || brakeState > 0)
+						m_sQueueSample.m_nFrequency = 18000 + Min(1.0f, (Max(accelerateState, brakeState) / 255.0f) * freqModifier) * 2204;
+					else
+						m_sQueueSample.m_nFrequency = 14287 + Min(1.0f, freqModifier) * 3713;
+					if (propellerSpeed < 1.0f)
+						m_sQueueSample.m_nFrequency = (propellerSpeed + 1) * (m_sQueueSample.m_nFrequency >> 1);
+					m_sQueueSample.m_nFrequency = Clamp2(m_sQueueSample.m_nFrequency, freqSkimmerPrev, 197);
+					freqSkimmerPrev = m_sQueueSample.m_nFrequency;
+					if (m_sQueueSample.m_nVolume > 0) {
+						m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_PRO4;
+						m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+						m_sQueueSample.m_nCounter = 12;
+						m_sQueueSample.m_bIs2D = FALSE;
+						m_sQueueSample.m_nPriority = 3;
+						m_sQueueSample.m_nLoopCount = 0;
+						SET_EMITTING_VOLUME(propellerSpeed * CAR_HELI_SEAPLANE_VOLUME);
+						SET_LOOP_OFFSETS(SFX_SEAPLANE_PRO4)
+						m_sQueueSample.m_fSpeedMultiplier = 5.0f;
+						m_sQueueSample.m_MaxDistance = CAR_HELI_SEAPLANE_MAX_DIST;
+						m_sQueueSample.m_bStatic = FALSE;
+						m_sQueueSample.m_nFramesToPlay = 7;
+						SET_SOUND_REVERB(TRUE);
+						SET_SOUND_REFLECTION(FALSE);
+						AddSampleToRequestedQueue();
+					}
+				}
+			} else {
+				//vacuum cleaner sound
+				vecPosOld = m_sQueueSample.m_vecPos;
+				distanceCalculatedOld = params.m_bDistanceCalculated;
+				distanceOld = params.m_fDistance;
+
+				m_sQueueSample.m_vecPos = backPropellerPos;
+				params.m_bDistanceCalculated = FALSE;
+				params.m_fDistance = GetDistanceSquared(m_sQueueSample.m_vecPos);
+				if (params.m_fDistance < SQR(CAR_HELI_REAR_MAX_DIST)) {
+					CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+					m_sQueueSample.m_nVolume = ComputeVolume(volumeModifier * CAR_HELI_REAR_VOLUME, CAR_HELI_REAR_MAX_DIST, m_sQueueSample.m_fDistance);
+					if (m_sQueueSample.m_nVolume > 0) {
+						m_sQueueSample.m_nCounter = 2;
+						m_sQueueSample.m_nSampleIndex = hunterBool ? SFX_HELI_APACHE_3 : SFX_CAR_HELI_REA;
+						m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+						m_sQueueSample.m_bIs2D = FALSE;
+						m_sQueueSample.m_nPriority = 1;
+						m_sQueueSample.m_nFrequency = (volumeModifier + 1.0f) * 16000;
+						m_sQueueSample.m_nLoopCount = 0;
+						SET_EMITTING_VOLUME(volumeModifier * CAR_HELI_REAR_VOLUME);
+						SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+						m_sQueueSample.m_fSpeedMultiplier = 6.0f;
+						m_sQueueSample.m_MaxDistance = CAR_HELI_REAR_MAX_DIST;
+						m_sQueueSample.m_bStatic = FALSE;
+						m_sQueueSample.m_nFramesToPlay = 5;
+						SET_SOUND_REVERB(TRUE);
+						SET_SOUND_REFLECTION(FALSE);
+						AddSampleToRequestedQueue();
+					}
+				}
 		
-		m_sQueueSample.m_vecPos = vecPosOld;
-		params.m_bDistanceCalculated = distanceCalculatedOld;
-		params.m_fDistance = distanceOld;
+				m_sQueueSample.m_vecPos = vecPosOld;
+				params.m_bDistanceCalculated = distanceCalculatedOld;
+				params.m_fDistance = distanceOld;
+			}
+		}
+		return TRUE;
 	}
+	return FALSE;
 }
 
 void
 cAudioManager::ProcessRainOnVehicle(cVehicleParams& params)
 {
-	const int SOUND_INTENSITY = 22.0f;
-
-	CVehicle *veh;
-	uint8 emittingVol;
-
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY) || CWeather::Rain <= 0.01f || CCullZones::CamNoRain() && CCullZones::PlayerNoRain())
-		return;
-
-	veh = params.m_pVehicle;
-	veh->m_bRainAudioCounter++;
-	if (veh->m_bRainAudioCounter >= 2) {
-		veh->m_bRainAudioCounter = 0;
-		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		emittingVol = 30.0f * CWeather::Rain;
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nCounter = veh->m_bRainSamplesCounter++;
-			if (veh->m_bRainSamplesCounter > 4)
-				veh->m_bRainSamplesCounter = 68;
-			m_sQueueSample.m_nSampleIndex = (m_anRandomTable[1] & 3) + SFX_CAR_RAIN_1;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 9;
-			m_sQueueSample.m_nFrequency = m_anRandomTable[1] % 4000 + 28000;
-			m_sQueueSample.m_nLoopCount = 1;
-			SET_EMITTING_VOLUME(emittingVol);
-			RESET_LOOP_OFFSETS
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			m_sQueueSample.m_bStatic = TRUE;
-			SET_SOUND_REVERB(FALSE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
+	if (params.m_fDistance < SQR(RAIN_ON_VEHICLE_MAX_DIST) && CWeather::Rain > 0.01f && (!CCullZones::CamNoRain() || !CCullZones::PlayerNoRain())) {
+		CVehicle *veh = params.m_pVehicle;
+		veh->m_bRainAudioCounter++;
+		if (veh->m_bRainAudioCounter >= 2) {
+			veh->m_bRainAudioCounter = 0;
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			uint8 Vol = RAIN_ON_VEHICLE_VOLUME * CWeather::Rain;
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, RAIN_ON_VEHICLE_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = veh->m_bRainSamplesCounter++;
+				if (veh->m_bRainSamplesCounter > 4)
+					veh->m_bRainSamplesCounter = 68;
+				m_sQueueSample.m_nSampleIndex = (m_anRandomTable[1] & 3) + SFX_CAR_RAIN_1;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 9;
+				m_sQueueSample.m_nFrequency = m_anRandomTable[1] % 4000 + 28000;
+				m_sQueueSample.m_nLoopCount = 1;
+				SET_EMITTING_VOLUME(Vol);
+				RESET_LOOP_OFFSETS
+				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+				m_sQueueSample.m_MaxDistance = RAIN_ON_VEHICLE_MAX_DIST;
+				m_sQueueSample.m_bStatic = TRUE;
+				SET_SOUND_REVERB(FALSE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
+			}
 		}
 	}
 }
@@ -1212,62 +1468,60 @@ cAudioManager::ProcessRainOnVehicle(cVehicleParams& params)
 bool8
 cAudioManager::ProcessReverseGear(cVehicleParams& params)
 {
-	const int reverseGearIntensity = 30;
-
-	CAutomobile* automobile;
+	CVehicle *veh;
+	CAutomobile *automobile;
+	uint8 Vol;
 	float modificator;
-	uint8 emittingVolume;
 
-	if (params.m_fDistance >= SQR(reverseGearIntensity))
-		return FALSE;
-	automobile = (CAutomobile*)params.m_pVehicle;
-	if (automobile->m_modelIndex == MI_CADDY)
-		return TRUE;
-	if (automobile->bEngineOn && (automobile->m_fGasPedal < 0.0f || automobile->m_nCurrentGear == 0)) {
-		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		if (automobile->m_nDriveWheelsOnGround != 0) {
-			modificator = params.m_fVelocityChange / params.m_pTransmission->fMaxReverseVelocity;
-		} else {
-			if (automobile->m_nDriveWheelsOnGroundPrev != 0)
-				automobile->m_fGasPedalAudio *= 0.4f;
-			modificator = automobile->m_fGasPedalAudio;
-		}
-		modificator = Abs(modificator);
-		emittingVolume = modificator * 24.0f;
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVolume, reverseGearIntensity, m_sQueueSample.m_fDistance);
-
-		if (m_sQueueSample.m_nVolume > 0) {
-			if (params.m_pVehicle->m_fGasPedal >= 0.0f) {
-				m_sQueueSample.m_nCounter = 62;
-				m_sQueueSample.m_nSampleIndex = SFX_REVERSE_GEAR_2;
-			} else {
-				m_sQueueSample.m_nCounter = 61;
-				m_sQueueSample.m_nSampleIndex = SFX_REVERSE_GEAR;
+	if (params.m_fDistance < SQR(REVERSE_GEAR_MAX_DIST)) {
+		veh = params.m_pVehicle;
+		if (veh->GetModelIndex() == MI_CADDY)
+			return TRUE;
+		if (veh->bEngineOn && (veh->m_fGasPedal < 0.0f || veh->m_nCurrentGear == 0)) {
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			automobile = (CAutomobile*)params.m_pVehicle;
+			if (automobile->m_nDriveWheelsOnGround > 0)
+				modificator = params.m_fVelocityChange / params.m_pTransmission->fMaxReverseVelocity;
+			else {
+				if (automobile->m_nDriveWheelsOnGroundPrev > 0)
+					automobile->m_fGasPedalAudio *= 0.4f;
+				modificator = automobile->m_fGasPedalAudio;
+			}
+			modificator = ABS(modificator);
+			Vol = (REVERSE_GEAR_VOLUME * modificator);
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, REVERSE_GEAR_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				if (params.m_pVehicle->m_fGasPedal < 0.0f) {
+					m_sQueueSample.m_nCounter = 61;
+					m_sQueueSample.m_nSampleIndex = SFX_REVERSE_GEAR;
+				} else {
+					m_sQueueSample.m_nCounter = 62;
+					m_sQueueSample.m_nSampleIndex = SFX_REVERSE_GEAR_2;
+				}
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 3;
+				m_sQueueSample.m_nFrequency = (6000 * modificator) + 7000;
+				m_sQueueSample.m_nLoopCount = 0;
+				SET_EMITTING_VOLUME(Vol);
+				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+				m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+				m_sQueueSample.m_MaxDistance = REVERSE_GEAR_MAX_DIST;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 5;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
 			}
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 3;
-			m_sQueueSample.m_nFrequency = (6000.0f * modificator) + 7000;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVolume);
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = reverseGearIntensity;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 5;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
 		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 void
 cAudioManager::ProcessModelHeliVehicle(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 35.0f;
-
 	static uint32 prevFreq = 22050;
 
 	uint32 freq;
@@ -1275,449 +1529,431 @@ cAudioManager::ProcessModelHeliVehicle(cVehicleParams& params)
 	int16 acceletateState;
 	int16 brakeState;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return;
-
-	if (FindPlayerVehicle() == params.m_pVehicle)
-		isPlayerVeh = TRUE;
-	else
-#ifdef FIX_BUGS
-		isPlayerVeh = CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle == params.m_pVehicle;
-#else
-		isPlayerVeh = CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle != nil;
-#endif
-	if (isPlayerVeh) {
-		brakeState = Pads[0].GetBrake();
-		acceletateState = Max(Pads[0].GetAccelerate(), Abs(Pads[0].GetCarGunUpDown()) * 2);
-	} else {
-		acceletateState = 255.0f * params.m_pVehicle->m_fGasPedal;
-		brakeState = 255.0f * params.m_pVehicle->m_fBrakePedal;
-	}
-	if (acceletateState < brakeState)
-		acceletateState = brakeState;
-	freq = Clamp2(5 * acceletateState + 22050, (int)prevFreq, 30);
-	CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-	m_sQueueSample.m_nVolume = ComputeVolume(70, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 2;
-		m_sQueueSample.m_nSampleIndex = SFX_CAR_RC_HELI;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 3;
-		m_sQueueSample.m_nFrequency = freq;
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(70);
-		SET_LOOP_OFFSETS(SFX_CAR_RC_HELI)
-		m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 4;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
+	if (params.m_fDistance < SQR(MODEL_CAR_ENGINE_MAX_DIST)) {
+		if (FindPlayerVehicle() == params.m_pVehicle)
+			isPlayerVeh = TRUE;
+		else
+	#ifdef FIX_BUGS
+			isPlayerVeh = CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle == params.m_pVehicle;
+	#else
+			isPlayerVeh = CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle != nil;
+	#endif
+		if (isPlayerVeh) {
+			brakeState = Pads[0].GetBrake();
+			acceletateState = Max(Pads[0].GetAccelerate(), Abs(Pads[0].GetCarGunUpDown()) * 2);
+		} else {
+			acceletateState = 255.0f * params.m_pVehicle->m_fGasPedal;
+			brakeState = 255.0f * params.m_pVehicle->m_fBrakePedal;
+		}
+		if (acceletateState < brakeState)
+			acceletateState = brakeState;
+		freq = Clamp2(5 * acceletateState + 22050, (int)prevFreq, 30);
+		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+		m_sQueueSample.m_nVolume = ComputeVolume(MODEL_HELI_ENGINE_VOLUME, MODEL_CAR_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
+		if (m_sQueueSample.m_nVolume > 0) {
+			m_sQueueSample.m_nCounter = 2;
+			m_sQueueSample.m_nSampleIndex = SFX_CAR_RC_HELI;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_nPriority = 3;
+			m_sQueueSample.m_nFrequency = freq;
+			m_sQueueSample.m_nLoopCount = 0;
+			SET_EMITTING_VOLUME(MODEL_HELI_ENGINE_VOLUME);
+			SET_LOOP_OFFSETS(SFX_CAR_RC_HELI)
+			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+			m_sQueueSample.m_MaxDistance = MODEL_CAR_ENGINE_MAX_DIST;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 4;
+			SET_SOUND_REVERB(TRUE);
+			SET_SOUND_REFLECTION(FALSE);
+			AddSampleToRequestedQueue();
+		}
+		if (isPlayerVeh)
+			prevFreq = freq;
 	}
-	if (isPlayerVeh)
-		prevFreq = freq;
 }
 
 void
 cAudioManager::ProcessModelVehicle(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 35.0f;
-
 	static uint32 prevFreq = 14000;
-	static uint8 prevVolume = 0;
+	static uint8 LastVol = 0;
 
 	uint32 freq;
 	int16 acceletateState;
 	int16 brakeState;
-	uint8 volume;
+	uint8 Vol;
 	bool8 isPlayerVeh;
 	bool8 vehSlowdown;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return;
-
-	if (FindPlayerVehicle() == params.m_pVehicle)
-		isPlayerVeh = TRUE;
-	else
-#ifdef FIX_BUGS
-		isPlayerVeh = CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle == params.m_pVehicle;
-#else
-		isPlayerVeh = CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle != nil;
-#endif
-	if (params.m_pVehicle->m_modelIndex == MI_RCBANDIT) {
-		if (((CAutomobile*)params.m_pVehicle)->m_nDriveWheelsOnGround != 0) {
-			volume = Min(127, 127.0f * Abs(params.m_fVelocityChange) * 3.0f);
-			freq = 8000.0f * Abs(params.m_fVelocityChange) + 14000;
-		} else {
-			volume = 127;
-			freq = 25000;
-		}
-		if (isPlayerVeh) {
-			volume = Clamp2(volume, prevVolume, 7);
-			freq = Clamp2(freq, prevFreq, 800);
-		}
-		if (volume > 0) {
-			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(volume, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-			if (m_sQueueSample.m_nVolume > 0) {
-				m_sQueueSample.m_nCounter = 2;
-				m_sQueueSample.m_nSampleIndex = SFX_RC_REV;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_bIs2D = FALSE;
-				m_sQueueSample.m_nPriority = 1;
-				m_sQueueSample.m_nFrequency = freq;
-				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(volume);
-				SET_LOOP_OFFSETS(SFX_RC_REV)
-				m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-				m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-				m_sQueueSample.m_bStatic = FALSE;
-				m_sQueueSample.m_nFramesToPlay = 4;
-				SET_SOUND_REVERB(TRUE);
-				SET_SOUND_REFLECTION(FALSE);
-				AddSampleToRequestedQueue();
+	if (params.m_fDistance < SQR(MODEL_CAR_ENGINE_MAX_DIST)) {
+		if (FindPlayerVehicle() == params.m_pVehicle)
+			isPlayerVeh = TRUE;
+		else
+	#ifdef FIX_BUGS
+			isPlayerVeh = CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle == params.m_pVehicle;
+	#else
+			isPlayerVeh = CWorld::Players[CWorld::PlayerInFocus].m_pRemoteVehicle != nil;
+	#endif
+		if (params.m_pVehicle->m_modelIndex == MI_RCBANDIT) {
+			if (((CAutomobile*)params.m_pVehicle)->m_nDriveWheelsOnGround != 0) {
+				Vol = Min(127, 127.0f * Abs(params.m_fVelocityChange) * 3.0f);
+				freq = 8000.0f * Abs(params.m_fVelocityChange) + 14000;
+			} else {
+				Vol = 127;
+				freq = 25000;
 			}
-		}
-		if (isPlayerVeh) {
-			prevFreq = freq;
-			prevVolume = volume;
-		}
-	} else if (params.m_pVehicle != nil) {
-		if (isPlayerVeh) {
-			acceletateState = Pads[0].GetAccelerate();
-			brakeState = Pads[0].GetBrake();
-		} else {
-			acceletateState = 255.0f * params.m_pVehicle->m_fGasPedal;
-			brakeState = 255.0f * params.m_pVehicle->m_fBrakePedal;
-		}
-		if (acceletateState < brakeState)
-			acceletateState = brakeState;
-		if (acceletateState <= 0) {
-			vehSlowdown = TRUE;
-			volume = 127;
-			freq = 18000;
-		} else {
-			vehSlowdown = FALSE;
-			volume = Min(127, (127 * acceletateState / 255) * 3.0f * Abs(params.m_fVelocityChange));
-			freq = Min(22000, (8000 * acceletateState / 255 + 14000) * 3.0f * Abs(params.m_fVelocityChange));
-		}
-		if (isPlayerVeh && !vehSlowdown) {
-			volume = Clamp2(volume, prevVolume, 7);
-			freq = Clamp2(freq, prevFreq, 800);
-		}
-		if (!vehSlowdown)
-#ifdef THIS_IS_STUPID
-			freq += 8000.0f * Abs(DotProduct(params.m_pVehicle->GetUp(), CVector(0.0f, 1.0f, 0.0f)));
-#else
-			freq += 8000.0f * Abs(params.m_pVehicle->GetUp().y);
-#endif
-		if (params.m_pVehicle->bIsDrowning)
-			volume /= 4;
-		if (volume > 0) {
-			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(volume, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-			if (m_sQueueSample.m_nVolume > 0) {
-				if (vehSlowdown) {
-					m_sQueueSample.m_nCounter = 0;
-					m_sQueueSample.m_nSampleIndex = SFX_RC_IDLE;
-					m_sQueueSample.m_nFramesToPlay = 6;
-				} else {
+			if (isPlayerVeh) {
+				Vol = Clamp2(Vol, LastVol, 7);
+				freq = Clamp2(freq, prevFreq, 800);
+			}
+			if (Vol > 0) {
+				CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, MODEL_CAR_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
 					m_sQueueSample.m_nCounter = 2;
 					m_sQueueSample.m_nSampleIndex = SFX_RC_REV;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 1;
+					m_sQueueSample.m_nFrequency = freq;
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(Vol);
+					SET_LOOP_OFFSETS(SFX_RC_REV)
+					m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+					m_sQueueSample.m_MaxDistance = MODEL_CAR_ENGINE_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
 					m_sQueueSample.m_nFramesToPlay = 4;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
 				}
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_bIs2D = FALSE;
-				m_sQueueSample.m_nPriority = 3;
-				m_sQueueSample.m_nFrequency = freq;
-				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(volume);
-				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-				m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-				m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-				m_sQueueSample.m_bStatic = FALSE;
-				SET_SOUND_REVERB(TRUE);
-				SET_SOUND_REFLECTION(FALSE);
-				AddSampleToRequestedQueue();
 			}
-		}
-		if (isPlayerVeh) {
-			if (vehSlowdown) {
+			if (isPlayerVeh) {
 				prevFreq = freq;
-				prevVolume = volume;
+				LastVol = Vol;
+			}
+		} else if (params.m_pVehicle != nil) {
+			if (isPlayerVeh) {
+				acceletateState = Pads[0].GetAccelerate();
+				brakeState = Pads[0].GetBrake();
+			} else {
+				acceletateState = 255.0f * params.m_pVehicle->m_fGasPedal;
+				brakeState = 255.0f * params.m_pVehicle->m_fBrakePedal;
+			}
+			if (acceletateState < brakeState)
+				acceletateState = brakeState;
+			if (acceletateState <= 0) {
+				vehSlowdown = TRUE;
+				Vol = 127;
+				freq = 18000;
+			} else {
+				vehSlowdown = FALSE;
+				Vol = Min(127, (127 * acceletateState / 255) * 3.0f * Abs(params.m_fVelocityChange));
+				freq = Min(22000, (8000 * acceletateState / 255 + 14000) * 3.0f * Abs(params.m_fVelocityChange));
+			}
+			if (isPlayerVeh && !vehSlowdown) {
+				Vol = Clamp2(Vol, LastVol, 7);
+				freq = Clamp2(freq, prevFreq, 800);
+			}
+			if (!vehSlowdown)
+	#ifdef THIS_IS_STUPID
+				freq += 8000.0f * Abs(DotProduct(params.m_pVehicle->GetUp(), CVector(0.0f, 1.0f, 0.0f)));
+	#else
+				freq += 8000.0f * Abs(params.m_pVehicle->GetUp().y);
+	#endif
+			if (params.m_pVehicle->bIsDrowning)
+				Vol >>= 2;
+			if (Vol > 0) {
+				CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, MODEL_CAR_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
+					if (vehSlowdown) {
+						m_sQueueSample.m_nCounter = 0;
+						m_sQueueSample.m_nSampleIndex = SFX_RC_IDLE;
+						m_sQueueSample.m_nFramesToPlay = 6;
+					} else {
+						m_sQueueSample.m_nCounter = 2;
+						m_sQueueSample.m_nSampleIndex = SFX_RC_REV;
+						m_sQueueSample.m_nFramesToPlay = 4;
+					}
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 3;
+					m_sQueueSample.m_nFrequency = freq;
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(Vol);
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+					m_sQueueSample.m_MaxDistance = MODEL_CAR_ENGINE_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
+				}
+			}
+			if (isPlayerVeh) {
+				if (vehSlowdown) {
+					prevFreq = freq;
+					LastVol = Vol;
+				}
 			}
 		}
 	}
 }
 
-void
+bool8
 cAudioManager::ProcessVehicleFlatTyre(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 60.0f;
-
 	CAutomobile* automobile;
 	CBike* bike;
 	bool8 wheelBurst;
-	uint8 emittingVol;
+	uint8 Vol;
 
 	float modifier;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return;
-
-	switch (params.m_VehicleType) {
-	case VEHICLE_TYPE_CAR:
-		automobile = (CAutomobile*)params.m_pVehicle;
-		wheelBurst = FALSE;
-		for (int i = 0; i < 4; i++)
-			if (automobile->Damage.GetWheelStatus(i) == WHEEL_STATUS_BURST && automobile->m_aWheelTimer[i] > 0.0f)
-				wheelBurst = TRUE;
-		if (!wheelBurst)
-			return;
-		break;
-	case VEHICLE_TYPE_BIKE:
-		bike = (CBike*)params.m_pVehicle;
-		wheelBurst = FALSE;
-		for(int i = 0; i < 2; i++)
-			if (bike->m_wheelStatus[i] == WHEEL_STATUS_BURST && bike->m_aWheelTimer[i] > 0.0f)
-				wheelBurst = TRUE;
-		if (!wheelBurst)
-			return;
-		break;
-	default:
-		return;
-	}
-	modifier = Min(1.0f, Abs(params.m_fVelocityChange) / (0.3f * params.m_pTransmission->fMaxVelocity));
-	if (modifier > 0.01f) { //mb can be replaced by (emittingVol > 1)
-		emittingVol = (100.0f * modifier);
-		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nCounter = 95;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 5;
-			m_sQueueSample.m_nSampleIndex = SFX_TYRE_BURST_L;
-			m_sQueueSample.m_nFrequency = (5500.0f * modifier) + 8000;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVol);
-			SET_LOOP_OFFSETS(SFX_TYRE_BURST_L)
-			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 3;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
+	if (params.m_fDistance < SQR(FLAT_TYRE_MAX_DIST)) {
+		switch (params.m_VehicleType) {
+		case VEHICLE_TYPE_CAR:
+			automobile = (CAutomobile*)params.m_pVehicle;
+			wheelBurst = FALSE;
+			for (int i = 0; i < 4; i++)
+				if (automobile->Damage.GetWheelStatus(i) == WHEEL_STATUS_BURST && automobile->m_aWheelTimer[i] > 0.0f)
+					wheelBurst = TRUE;
+			if (!wheelBurst)
+				return TRUE;
+			break;
+		case VEHICLE_TYPE_BIKE:
+			bike = (CBike*)params.m_pVehicle;
+			wheelBurst = FALSE;
+			for(int i = 0; i < 2; i++)
+				if (bike->m_wheelStatus[i] == WHEEL_STATUS_BURST && bike->m_aWheelTimer[i] > 0.0f)
+					wheelBurst = TRUE;
+			if (!wheelBurst)
+				return TRUE;
+			break;
+		default:
+			return TRUE;
+		}
+		modifier = Min(1.0f, Abs(params.m_fVelocityChange) / (0.3f * params.m_pTransmission->fMaxVelocity));
+		if (modifier > 0.01f) {
+			Vol = (FLAT_TYRE_VOLUME * modifier);
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, FLAT_TYRE_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = 95;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 5;
+				m_sQueueSample.m_nSampleIndex = SFX_TYRE_BURST_L;
+				m_sQueueSample.m_nFrequency = (5500.0f * modifier) + 8000;
+				m_sQueueSample.m_nLoopCount = 0;
+				SET_EMITTING_VOLUME(Vol);
+				SET_LOOP_OFFSETS(SFX_TYRE_BURST_L)
+				m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+				m_sQueueSample.m_MaxDistance = FLAT_TYRE_MAX_DIST;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 3;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
+			}
 		}
+		return TRUE;
 	}
+	return FALSE;
 }
 
 bool8
 cAudioManager::ProcessVehicleRoadNoise(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 95.0f;
-
-	int32 emittingVol;
+	uint8 Vol;
 	uint32 freq;
 	float multiplier;
 	int sampleFreq;
 	float velocity;
 	uint8 wheelsOnGround;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-	switch (params.m_VehicleType) {
-	case VEHICLE_TYPE_CAR:
-		wheelsOnGround = ((CAutomobile*)params.m_pVehicle)->m_nWheelsOnGround;
-		break;
-	case VEHICLE_TYPE_BIKE:
-		wheelsOnGround = ((CBike*)params.m_pVehicle)->m_nWheelsOnGround;
-		break;
-	default:
-		wheelsOnGround = 4;
-		break;
-	}
-	if (params.m_pTransmission == nil || wheelsOnGround == 0)
-		return TRUE;
-
-	velocity = Abs(params.m_fVelocityChange);
-	if (velocity > 0.0f) {
-		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		emittingVol = 30.f * Min(1.f, velocity / (0.5f * params.m_pTransmission->fMaxVelocity));
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nCounter = 0;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 3;
-			if (params.m_pVehicle->m_nSurfaceTouched == SURFACE_WATER) {
-				m_sQueueSample.m_nSampleIndex = SFX_BOAT_WATER_LOOP;
-				freq = 6050 * emittingVol / 30 + 16000;
-			} else {
-				m_sQueueSample.m_nSampleIndex = SFX_ROAD_NOISE;
-				multiplier = (m_sQueueSample.m_fDistance / SOUND_INTENSITY) * 0.5f;
-				sampleFreq = SampleManager.GetSampleBaseFrequency(SFX_ROAD_NOISE);
-				freq = (sampleFreq * multiplier) + ((3 * sampleFreq) / 4);
+	if (params.m_fDistance < SQR(VEHICLE_ROAD_NOISE_MAX_DIST)) {
+		switch (params.m_VehicleType) {
+		case VEHICLE_TYPE_CAR:
+			wheelsOnGround = ((CAutomobile*)params.m_pVehicle)->m_nWheelsOnGround;
+			break;
+		case VEHICLE_TYPE_BIKE:
+			wheelsOnGround = ((CBike*)params.m_pVehicle)->m_nWheelsOnGround;
+			break;
+		default:
+			wheelsOnGround = 4;
+			break;
+		}
+		if ((params.m_pTransmission != nil) && (wheelsOnGround > 0)) {
+			velocity = Abs(params.m_fVelocityChange);
+			if (velocity > 0.0f) {
+				CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+				Vol = VEHICLE_ROAD_NOISE_VOLUME * Min(1.0f, velocity / (0.5f * params.m_pTransmission->fMaxVelocity));
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, VEHICLE_ROAD_NOISE_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
+					m_sQueueSample.m_nCounter = 0;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 3;
+					if (params.m_pVehicle->m_nSurfaceTouched == SURFACE_WATER) {
+						m_sQueueSample.m_nSampleIndex = SFX_BOAT_WATER_LOOP;
+						freq = 6050 * Vol / VEHICLE_ROAD_NOISE_VOLUME + 16000;
+					} else {
+						m_sQueueSample.m_nSampleIndex = SFX_ROAD_NOISE;
+						multiplier = (m_sQueueSample.m_fDistance / VEHICLE_ROAD_NOISE_MAX_DIST) * 0.5f;
+						sampleFreq = SampleManager.GetSampleBaseFrequency(SFX_ROAD_NOISE);
+						freq = (sampleFreq * multiplier) + ((3 * sampleFreq) >> 2);
+					}
+					m_sQueueSample.m_nFrequency = freq;
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(Vol);
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 6.0f;
+					m_sQueueSample.m_MaxDistance = VEHICLE_ROAD_NOISE_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
+					m_sQueueSample.m_nFramesToPlay = 4;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
+				}
 			}
-			m_sQueueSample.m_nFrequency = freq;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVol);
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 4;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
 		}
+		return TRUE;
 	}
-
-	return TRUE;
+	return FALSE;
 }
 
 bool8
 cAudioManager::ProcessWetRoadNoise(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 30.0f;
-
 	float relativeVelocity;
-	int32 emittingVol;
+	uint8 Vol;
 	float multiplier;
 	int freq;
-	float velocity;
+	float velChange;
 	uint8 wheelsOnGround;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-	switch (params.m_VehicleType) {
-	case VEHICLE_TYPE_CAR:
-		wheelsOnGround = ((CAutomobile*)params.m_pVehicle)->m_nWheelsOnGround;
-		break;
-	case VEHICLE_TYPE_BIKE:
-		wheelsOnGround = ((CBike*)params.m_pVehicle)->m_nWheelsOnGround;
-		break;
-	default:
-		wheelsOnGround = 4;
-		break;
-	}
-	if (params.m_pTransmission == nil || wheelsOnGround == 0)
-		return TRUE;
-
-	velocity = Abs(params.m_fVelocityChange);
-	if (velocity > 0.0f) {
-		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		relativeVelocity = Min(1.0f, velocity / (0.5f * params.m_pTransmission->fMaxVelocity));
-		emittingVol = 23.0f * relativeVelocity * CWeather::WetRoads;
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nCounter = 1;
-			m_sQueueSample.m_nSampleIndex = SFX_ROAD_NOISE;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 3;
-			multiplier = (m_sQueueSample.m_fDistance / SOUND_INTENSITY) * 0.5f;
-			freq = SampleManager.GetSampleBaseFrequency(SFX_ROAD_NOISE);
-			m_sQueueSample.m_nFrequency = freq + freq * multiplier;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVol);
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 4;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
+	if (params.m_fDistance < SQR(WET_ROAD_NOISE_MAX_DIST)) {
+		switch (params.m_VehicleType) {
+		case VEHICLE_TYPE_CAR:
+			wheelsOnGround = ((CAutomobile*)params.m_pVehicle)->m_nWheelsOnGround;
+			break;
+		case VEHICLE_TYPE_BIKE:
+			wheelsOnGround = ((CBike*)params.m_pVehicle)->m_nWheelsOnGround;
+			break;
+		default:
+			wheelsOnGround = 4;
+			break;
+		}
+		if ((params.m_pTransmission != nil) && (wheelsOnGround > 0)) {
+			velChange = Abs(params.m_fVelocityChange);
+			if (velChange > 0.0f) {
+				CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+				relativeVelocity = Min(1.0f, velChange / (0.5f * params.m_pTransmission->fMaxVelocity));
+				Vol = WET_ROAD_NOISE_VOLUME * relativeVelocity * CWeather::WetRoads;
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, WET_ROAD_NOISE_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
+					m_sQueueSample.m_nCounter = 1;
+					m_sQueueSample.m_nSampleIndex = SFX_ROAD_NOISE;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 3;
+					multiplier = (m_sQueueSample.m_fDistance / WET_ROAD_NOISE_MAX_DIST) * 0.5f;
+					freq = SampleManager.GetSampleBaseFrequency(SFX_ROAD_NOISE);
+					m_sQueueSample.m_nFrequency = freq + freq * multiplier;
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(Vol);
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 6.0f;
+					m_sQueueSample.m_MaxDistance = WET_ROAD_NOISE_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
+					m_sQueueSample.m_nFramesToPlay = 4;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
+				}
+			}
 		}
+		return TRUE;
 	}
-
-	return TRUE;
+	return FALSE;
 }
 
 bool8
 cAudioManager::ProcessVehicleEngine(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 50.0f;
-
-	CVehicle* playerVeh;
-	CVehicle* veh;
-	CAutomobile* automobile;
-	cTransmission* transmission;
-	CBike* bike;
-	tWheelState* wheelState;
-	float* gasPedalAudioPtr;
-
-	int32 freq = 0;
-	uint8 currentGear;
-	uint8 emittingVol;
-	int8 wheelsOnGround;
-	int8 wheelsOnGroundPrev;
+	CAutomobile *automobile;
 	float relativeGearChange;
-	float relativeChange;
+#ifdef FIX_BUGS
+	uint32 freq = 0; // uninitialized variable
+#else
+	uint32 freq;
+#endif
+	uint8 Vol;
+	cTransmission *transmission;
+	uint8 currentGear;
 	float modificator;
-	float traction;
-	bool8 isMoped;
-	bool8 caddyBool;
-
-	isMoped = FALSE;
-	caddyBool = FALSE;
-	traction = 0.0f;
-	if (params.m_fDistance < SQR(SOUND_INTENSITY)) {
-		playerVeh = FindPlayerVehicle();
-		veh = params.m_pVehicle;
-		if (playerVeh == veh && veh->GetStatus() == STATUS_WRECKED) {
+	uint8 wheelsOnGround;
+	uint8 wheelsOnGroundPrev;
+	CBike *bike;
+	tWheelState *wheelState;
+	float *gasPedalAudioPtr;
+
+	bool8 isMoped = FALSE;
+	bool8 isGolfCart = FALSE;
+	float traction = 0.0f;
+	if (params.m_fDistance < SQR(VEHICLE_ENGINE_MAX_DIST)) {
+		if (FindPlayerVehicle() == params.m_pVehicle && params.m_pVehicle->GetStatus() == STATUS_WRECKED) {
 			SampleManager.StopChannel(CHANNEL_PLAYER_VEHICLE_ENGINE);
 			return TRUE;
 		}
-		if (veh->bEngineOn) {
+		if (params.m_pVehicle->bEngineOn) {
 			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			if (playerVeh == veh && veh->m_modelIndex != MI_CADDY) {
+			if (FindPlayerVehicle() == params.m_pVehicle && params.m_pVehicle->GetModelIndex() != MI_CADDY)
 				ProcessPlayersVehicleEngine(params, params.m_pVehicle);
-				return TRUE;
-			}
-			transmission = params.m_pTransmission;
-			if (transmission != nil) {
-				switch (veh->m_modelIndex) {
-				case MI_PIZZABOY:
-				case MI_FAGGIO:
-					isMoped = TRUE;
-					currentGear = transmission->nNumberOfGears;
-					break;
-				case MI_CADDY:
-					currentGear = transmission->nNumberOfGears;
-					caddyBool = TRUE;
-					break;
-				default:
-					currentGear = veh->m_nCurrentGear;
-					break;
-				}
-				switch (params.m_VehicleType) {
-				case VEHICLE_TYPE_CAR:
-					automobile = (CAutomobile*)veh;
-					wheelsOnGround = automobile->m_nDriveWheelsOnGround;
-					wheelsOnGroundPrev = automobile->m_nDriveWheelsOnGroundPrev;
-					wheelState = automobile->m_aWheelState;
-					gasPedalAudioPtr = &automobile->m_fGasPedalAudio;
-					break;
-				case VEHICLE_TYPE_BIKE:
-					bike = (CBike*)veh;
-					wheelsOnGround = bike->m_nDriveWheelsOnGround;
-					wheelsOnGroundPrev = bike->m_nDriveWheelsOnGroundPrev;
-					wheelState = bike->m_aWheelState;
-					gasPedalAudioPtr = &bike->m_fGasPedalAudio;
-					break;
-				default:
-					debug(" ** AUDIOLOG: Unrecognised vehicle type %d in ProcessVehicleEngine() * \n", params.m_VehicleType);
-					return TRUE;
-				}
-
-				if (wheelsOnGround != 0) {
-					if (!veh->bIsHandbrakeOn || isMoped && caddyBool) { //mb bug, bcs it's can't be TRUE together
-						if (veh->GetStatus() == STATUS_SIMPLE || isMoped || caddyBool) {
+			else {
+				transmission = params.m_pTransmission;
+				if (transmission != nil) {
+					switch (params.m_pVehicle->GetModelIndex()) {
+					case MI_PIZZABOY:
+					case MI_FAGGIO:
+						isMoped = TRUE;
+						currentGear = transmission->nNumberOfGears;
+						break;
+					case MI_CADDY:
+						currentGear = transmission->nNumberOfGears;
+						isGolfCart = TRUE;
+						break;
+					default:
+						currentGear = params.m_pVehicle->m_nCurrentGear;
+						break;
+					}
+					switch (params.m_VehicleType) {
+					case VEHICLE_TYPE_CAR:
+						automobile = (CAutomobile*)params.m_pVehicle;
+						wheelsOnGround = automobile->m_nDriveWheelsOnGround;
+						wheelsOnGroundPrev = automobile->m_nDriveWheelsOnGroundPrev;
+						wheelState = automobile->m_aWheelState;
+						gasPedalAudioPtr = &automobile->m_fGasPedalAudio;
+						break;
+					case VEHICLE_TYPE_BIKE:
+						bike = (CBike*)params.m_pVehicle;
+						wheelsOnGround = bike->m_nDriveWheelsOnGround;
+						wheelsOnGroundPrev = bike->m_nDriveWheelsOnGroundPrev;
+						wheelState = bike->m_aWheelState;
+						gasPedalAudioPtr = &bike->m_fGasPedalAudio;
+						break;
+					default:
+						debug(" ** AUDIOLOG: Unrecognised vehicle type %d in ProcessVehicleEngine() * \n", params.m_VehicleType);
+						return TRUE;
+					}
+					if (wheelsOnGround > 0) {
+						if (params.m_pVehicle->bIsHandbrakeOn && (!isMoped || !isGolfCart)) { // what a weird check
+							if (params.m_fVelocityChange == 0.0f)
+								traction = 0.9f;
+						} else if (params.m_pVehicle->GetStatus() == STATUS_SIMPLE || isMoped || isGolfCart) {
 							traction = 0.0f;
 						} else {
 							switch (transmission->nDriveType) {
@@ -1758,102 +1994,100 @@ cAudioManager::ProcessVehicleEngine(cVehicleParams& params)
 								break;
 							}
 						}
-					} else if (params.m_fVelocityChange == 0.0f) {
-						traction = 0.9f;
-					}
-					if (transmission->fMaxVelocity <= 0.0f) {
-						relativeChange = 0.0f;
-						modificator = 0.0f;
-					} else {
-						if (!isMoped && !caddyBool) {
-							if (currentGear != 0) {
-								relativeGearChange = Min(1.0f,
-									params.m_fVelocityChange - transmission->Gears[currentGear].fShiftDownVelocity) / transmission->fMaxVelocity * 2.5f;
-								if (traction == 0.0f && veh->GetStatus() != STATUS_SIMPLE && 
-									params.m_fVelocityChange < transmission->Gears[1].fShiftUpVelocity)
-									traction = 0.7f;
-								relativeChange = traction * *gasPedalAudioPtr * 0.95f + (1.0f - traction) * relativeGearChange;
-							} else {
-								relativeChange = Min(1.0f,
-									1.0f - Abs((params.m_fVelocityChange - transmission->Gears[0].fShiftDownVelocity) / transmission->fMaxReverseVelocity));
+						if (transmission->fMaxVelocity > 0.0f) {
+							if (isMoped || isGolfCart)
+								modificator = Min(1.0f, Abs(params.m_fVelocityChange / transmission->fMaxVelocity > 1.0f));
+							else {
+								if (currentGear > 0) {
+									relativeGearChange = Min(1.0f,
+										params.m_fVelocityChange - transmission->Gears[currentGear].fShiftDownVelocity) / transmission->fMaxVelocity * 2.5f;
+									if (traction == 0.0f && params.m_pVehicle->GetStatus() != STATUS_SIMPLE &&
+										params.m_fVelocityChange < transmission->Gears[1].fShiftUpVelocity)
+										traction = 0.7f;
+									modificator = traction * *gasPedalAudioPtr * 0.95f + (1.0f - traction) * relativeGearChange;
+								} else {
+									modificator = Min(1.0f,
+										1.0f - Abs((params.m_fVelocityChange - transmission->Gears[0].fShiftDownVelocity) / transmission->fMaxReverseVelocity));
+								}
 							}
-							modificator = relativeChange;
-						} else {
-							modificator = Min(1.0f, Abs(params.m_fVelocityChange / transmission->fMaxVelocity > 1.0f));
-						}
+						} else
+							modificator = 0.0f;
+					} else {
+						if (wheelsOnGroundPrev > 0)
+							*gasPedalAudioPtr *= 0.4f;
+						modificator = *gasPedalAudioPtr;
 					}
+					if (currentGear == 0 || wheelsOnGround > 0) {
+						if (params.m_VehicleType == VEHICLE_TYPE_BIKE)
+							freq = 22050;
+						else
+							freq = 13000 * modificator + 14000;
+					} else
+						freq = 1200 * currentGear + 18000 * modificator + 14000;
+					if (modificator < 0.75f)
+						Vol = modificator / 0.75f * (VEHICLE_ENGINE_FULL_VOLUME - VEHICLE_ENGINE_BASE_VOLUME) + VEHICLE_ENGINE_BASE_VOLUME;
+					else
+						Vol = VEHICLE_ENGINE_FULL_VOLUME;
 				} else {
-					if (wheelsOnGroundPrev != 0)
-						*gasPedalAudioPtr *= 0.4f;
-					relativeChange = *gasPedalAudioPtr;
-					modificator = relativeChange;
+					modificator = 0.0f;
+					Vol = VEHICLE_ENGINE_BASE_VOLUME;
 				}
-				if (currentGear != 0 || wheelsOnGround == 0)
-					freq = 1200 * currentGear + 18000.0f * modificator + 14000;
-				else if (params.m_VehicleType == VEHICLE_TYPE_BIKE)
-					freq = 22050;
-				else
-					freq = 13000.0f * modificator + 14000;
-				if (modificator >= 0.75f)
-					emittingVol = 90;
-				else
-					emittingVol = modificator * (4.0f / 3.0f) * 15.0f + 75;
-			} else {
-				modificator = 0.0f;
-				emittingVol = 75;
-			}
-			if (veh->bIsDrowning)
-				emittingVol /= 4;
-			if (caddyBool) {
-				emittingVol = 100.0f * modificator;
-				freq = 2130.0f * modificator + 4270;
-				m_sQueueSample.m_nCounter = 2;
-			}
-			m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-			if (m_sQueueSample.m_nVolume > 0) {
-				if (!caddyBool) {
-					if (veh->GetStatus() == STATUS_SIMPLE) {
-						if (modificator < 0.02f) {
-							m_sQueueSample.m_nSampleIndex = aEngineSounds[aVehicleSettings[params.m_nIndex].m_nBank - CAR_SFX_BANKS_OFFSET][0];
-							m_sQueueSample.m_nCounter = 52;
-							freq = 10000.0f * modificator + 22050;
+				if (params.m_pVehicle->bIsDrowning)
+					Vol >>= 2;
+				if (isGolfCart) {
+					Vol = 100 * modificator;
+					freq = 2130 * modificator + 4270;
+					m_sQueueSample.m_nCounter = 2;
+				}
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, VEHICLE_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
+					if (!isGolfCart) {
+						if (params.m_pVehicle->GetStatus() == STATUS_SIMPLE) {
+							if (modificator < 0.02f) {
+								m_sQueueSample.m_nSampleIndex = aEngineSounds[aVehicleSettings[params.m_nIndex].m_nBank - CAR_SFX_BANKS_OFFSET][0];
+								freq = 10000 * modificator + 22050;
+								m_sQueueSample.m_nCounter = 52;
+							} else {
+								m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nAccelerationSampleIndex;
+								m_sQueueSample.m_nCounter = 2;
+							}
 						} else {
-							m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nAccelerationSampleIndex;
-							m_sQueueSample.m_nCounter = 2;
+							if (params.m_pVehicle->m_fGasPedal < 0.02f) {
+								m_sQueueSample.m_nSampleIndex = aEngineSounds[aVehicleSettings[params.m_nIndex].m_nBank - CAR_SFX_BANKS_OFFSET][0];
+								freq = 10000 * modificator + 22050;
+								m_sQueueSample.m_nCounter = 52;
+							} else {
+								m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nAccelerationSampleIndex;
+								m_sQueueSample.m_nCounter = 2;
+							}
 						}
+					}
+					if (isGolfCart) {
+						if (FindVehicleOfPlayer() == params.m_pVehicle)
+							m_sQueueSample.m_nSampleIndex = SFX_CAR_AFTER_ACCEL_12;
+						else
+							m_sQueueSample.m_nSampleIndex = SFX_CAR_REV_GOLFCART;
+						m_sQueueSample.m_nBankIndex = SFX_BANK_0; // TODO: PS2 bank
+						m_sQueueSample.m_nFrequency = freq + 20 * m_sQueueSample.m_nEntityIndex % 100;
 					} else {
-						if (veh->m_fGasPedal < 0.02f) {
-							m_sQueueSample.m_nSampleIndex = aEngineSounds[aVehicleSettings[params.m_nIndex].m_nBank - CAR_SFX_BANKS_OFFSET][0];
-							m_sQueueSample.m_nCounter = 52;
-							freq = 10000.0f * modificator + 22050;
-						} else {
-							m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nAccelerationSampleIndex;
-							m_sQueueSample.m_nCounter = 2;
-						}
+						m_sQueueSample.m_nBankIndex = SFX_BANK_0; // TODO: PS2 bank
+						m_sQueueSample.m_nFrequency = freq + 100 * m_sQueueSample.m_nEntityIndex % 1000;
 					}
-					m_sQueueSample.m_nFrequency = freq + 100 * m_sQueueSample.m_nBankIndex % 1000;
-				} else {
-					if (FindVehicleOfPlayer() == params.m_pVehicle)
-						m_sQueueSample.m_nSampleIndex = SFX_CAR_AFTER_ACCEL_12;
-					else
-						m_sQueueSample.m_nSampleIndex = SFX_CAR_REV_GOLFCART;
-					m_sQueueSample.m_nFrequency = freq + 20 * m_sQueueSample.m_nBankIndex % 100;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 3;
+					if (m_sQueueSample.m_nSampleIndex == SFX_CAR_IDLE_TRUCK || m_sQueueSample.m_nSampleIndex == SFX_CAR_REV_TRUCK)
+						m_sQueueSample.m_nFrequency >>= 1;
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(Vol);
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 6.0f;
+					m_sQueueSample.m_MaxDistance = VEHICLE_ENGINE_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
+					m_sQueueSample.m_nFramesToPlay = 8;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
 				}
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_bIs2D = FALSE;
-				m_sQueueSample.m_nPriority = 3;
-				if (m_sQueueSample.m_nSampleIndex == SFX_CAR_IDLE_TRUCK || m_sQueueSample.m_nSampleIndex == SFX_CAR_REV_TRUCK)
-					m_sQueueSample.m_nFrequency /= 2;
-				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(emittingVol);
-				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-				m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-				m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-				m_sQueueSample.m_bStatic = FALSE;
-				m_sQueueSample.m_nFramesToPlay = 8;
-				SET_SOUND_REVERB(TRUE);
-				SET_SOUND_REFLECTION(FALSE);
-				AddSampleToRequestedQueue();
 			}
 		}
 		return TRUE;
@@ -1892,9 +2126,9 @@ cAudioManager::PlayerJustLeftCar(void)
 }
 
 void
-cAudioManager::AddPlayerCarSample(uint8 emittingVolume, uint32 freq, uint32 sample, uint8 bank, uint8 counter, bool8 notLooping)
+cAudioManager::AddPlayerCarSample(uint8 Vol, uint32 freq, uint32 sample, uint8 bank, uint8 counter, bool8 bLooping)
 {
-	m_sQueueSample.m_nVolume = ComputeVolume(emittingVolume, 50.f, m_sQueueSample.m_fDistance);
+	m_sQueueSample.m_nVolume = ComputeVolume(Vol, VEHICLE_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
 	if (m_sQueueSample.m_nVolume > 0) {
 		m_sQueueSample.m_nCounter = counter;
 		m_sQueueSample.m_nSampleIndex = sample;
@@ -1906,16 +2140,15 @@ cAudioManager::AddPlayerCarSample(uint8 emittingVolume, uint32 freq, uint32 samp
 		m_sQueueSample.m_bIs2D = FALSE;
 		m_sQueueSample.m_nPriority = 0;
 		m_sQueueSample.m_nFrequency = freq;
-		if (notLooping) {
+		if (bLooping) {
 			m_sQueueSample.m_nLoopCount = 0;
 			m_sQueueSample.m_nFramesToPlay = 8;
-		} else {
+		} else
 			m_sQueueSample.m_nLoopCount = 1;
-		}
-		SET_EMITTING_VOLUME(emittingVolume);
+		SET_EMITTING_VOLUME(Vol);
 		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 		m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-		m_sQueueSample.m_MaxDistance = 50.0f;
+		m_sQueueSample.m_MaxDistance = VEHICLE_ENGINE_MAX_DIST;
 		m_sQueueSample.m_bStatic = FALSE;
 		SET_SOUND_REVERB(TRUE);
 		SET_SOUND_REFLECTION(FALSE);
@@ -1926,9 +2159,9 @@ cAudioManager::AddPlayerCarSample(uint8 emittingVolume, uint32 freq, uint32 samp
 void
 cAudioManager::ProcessCesna(cVehicleParams &params)
 {
-	if(params.m_fDistance < SQR(200)) {
+	if(params.m_fDistance < SQR(CESNA_IDLE_MAX_DIST)) {
 		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		m_sQueueSample.m_nVolume = ComputeVolume(80, 200.f, m_sQueueSample.m_fDistance);
+		m_sQueueSample.m_nVolume = ComputeVolume(CESNA_VOLUME, CESNA_IDLE_MAX_DIST, m_sQueueSample.m_fDistance);
 		if (m_sQueueSample.m_nVolume > 0) {
 			m_sQueueSample.m_nCounter = 52;
 			m_sQueueSample.m_nSampleIndex = SFX_CESNA_IDLE;
@@ -1938,17 +2171,17 @@ cAudioManager::ProcessCesna(cVehicleParams &params)
 			m_sQueueSample.m_nFrequency = 12500;
 			m_sQueueSample.m_nLoopCount = 0;
 			m_sQueueSample.m_nFramesToPlay = 8;
-			SET_EMITTING_VOLUME(80);
+			SET_EMITTING_VOLUME(CESNA_VOLUME);
 			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-			m_sQueueSample.m_MaxDistance = 200.0f;
+			m_sQueueSample.m_MaxDistance = CESNA_IDLE_MAX_DIST;
 			m_sQueueSample.m_bStatic = FALSE;
 			SET_SOUND_REVERB(TRUE);
 			SET_SOUND_REFLECTION(FALSE);
 			AddSampleToRequestedQueue();
 		}
-		if(params.m_fDistance < SQR(90)) {
-			m_sQueueSample.m_nVolume = ComputeVolume(80, 90.f, m_sQueueSample.m_fDistance);
+		if(params.m_fDistance < SQR(CESNA_REV_MAX_DIST)) {
+			m_sQueueSample.m_nVolume = ComputeVolume(CESNA_VOLUME, CESNA_REV_MAX_DIST, m_sQueueSample.m_fDistance);
 			if (m_sQueueSample.m_nVolume > 0) {
 				m_sQueueSample.m_nCounter = 2;
 				m_sQueueSample.m_nSampleIndex = SFX_CESNA_REV;
@@ -1958,10 +2191,10 @@ cAudioManager::ProcessCesna(cVehicleParams &params)
 				m_sQueueSample.m_nFrequency = 25000;
 				m_sQueueSample.m_nLoopCount = 0;
 				m_sQueueSample.m_nFramesToPlay = 4;
-				SET_EMITTING_VOLUME(80);
+				SET_EMITTING_VOLUME(CESNA_VOLUME);
 				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 				m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-				m_sQueueSample.m_MaxDistance = 90.0f;
+				m_sQueueSample.m_MaxDistance = CESNA_REV_MAX_DIST;
 				m_sQueueSample.m_bStatic = FALSE;
 				SET_SOUND_REVERB(TRUE);
 				SET_SOUND_REFLECTION(FALSE);
@@ -1976,33 +2209,36 @@ cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams& params, CVehicle* veh
 {
 	static int32 GearFreqAdj[] = { 6000, 6000, 3400, 1200, 0, -1000 };
 
-	tWheelState* wheelState;
-	CAutomobile* automobile;
-	CBike* bike;
-	CVector pos;
-	float* gasPedalAudioPtr;
+	float relativeVelocityChange;
+	float accelerationMultipler;
+	uint8 wheelInUseCounter;
+	float time;
+	int baseFreq;
+	uint8 vol;
+	int32 freq;
 
+	int freqModifier;
+	uint32 soundOffset;
+	uint8 engineSoundType;
 	int16 accelerateState;
 	int16 brakeState;
-	int32 freq;
-	int32 baseFreq;
-	int32 freqModifier;
+	bool8 channelUsed;
+
+	uint8 currentGear;
+	float gasPedalAudio;
+	CVector pos;
+	bool8 slowingDown;
+
+	tWheelState *wheelState;
+	CAutomobile *automobile;
+	CBike *bike;
+	float *gasPedalAudioPtr;
+
 	uint32 gearSoundLength;
-	uint32 soundOffset;
-	uint8 engineSoundType;
-	uint8 wheelInUseCounter;
 	uint8 wheelsOnGround;
-	uint8 vol;
-	uint8 currentGear;
 	uint8 wheelsOnGroundPrev;
 
-	float accelerationMultipler;
-	float gasPedalAudio;
 	float velocityChangeForAudio;
-	float relativeVelocityChange;
-	float time;
-	bool8 channelUsed;
-	bool8 slowingDown;
 	bool8 noGearBox;
 	bool8 stuckInSand;
 
@@ -2031,16 +2267,20 @@ cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams& params, CVehicle* veh
 		CurrentPretendGear = 1;
 		bHandbrakeOnLastFrame = FALSE;
 	}
+#ifdef FIX_BUGS // fix acceleration sound on exiting the vehicle
+	if (CReplay::IsPlayingBack() || FindPlayerPed()->GetPedState() == PED_EXIT_CAR) {
+#else
 	if (CReplay::IsPlayingBack()) {
-		accelerateState = (255.0f * Clamp(params.m_pVehicle->m_fGasPedal, 0.0f, 1.0f));
-		brakeState = (255.0f * Clamp(params.m_pVehicle->m_fBrakePedal, 0.0f, 1.0f));
+#endif
+		accelerateState = (255 * Clamp(params.m_pVehicle->m_fGasPedal, 0.0f, 1.0f));
+		brakeState = (255 * Clamp(params.m_pVehicle->m_fBrakePedal, 0.0f, 1.0f));
 	} else {
 		accelerateState = Pads[0].GetAccelerate();
 		brakeState = Pads[0].GetBrake();
 	}
 	slowingDown = params.m_fVelocityChange < -0.001f;
 	channelUsed = SampleManager.GetChannelUsedFlag(nChannel);
-	if (params.m_pVehicle->m_modelIndex == MI_PIZZABOY || params.m_pVehicle->m_modelIndex == MI_FAGGIO) {
+	if (params.m_pVehicle->GetModelIndex() == MI_PIZZABOY || params.m_pVehicle->GetModelIndex() == MI_FAGGIO) {
 		CurrentPretendGear = params.m_pTransmission->nNumberOfGears;
 		currentGear = CurrentPretendGear;
 		if (params.m_pVehicle->bIsHandbrakeOn) {
@@ -2048,13 +2288,11 @@ cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams& params, CVehicle* veh
 			nCruising = 0;
 			LastAccel = 0;
 			accelerateState = 0;
-		} else {
+		} else
 			nCruising = 1;
-		}
 		isMoped = TRUE;
-	} else {
+	} else
 		currentGear = params.m_pVehicle->m_nCurrentGear;
-	}
 
 	switch (params.m_VehicleType) {
 	case VEHICLE_TYPE_CAR:
@@ -2116,15 +2354,17 @@ cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams& params, CVehicle* veh
 	if (params.m_fVelocityChange != 0.0f) {
 		time = params.m_pVehicle->m_vecMoveSpeed.z / params.m_fVelocityChange;
 		if (time > 0.0f)
-			freqModifier = -(Min(0.2f, time) * 3000.0f * 5.0f);
+			freqModifier = -(Min(0.2f, time) * 3000 * 5);
 		else
-			freqModifier = -(Max(-0.2f, time) * 3000.0f * 5.0f);
+			freqModifier = -(Max(-0.2f, time) * 3000 * 5);
 		if (slowingDown)
 			freqModifier = -freqModifier;
 	} else
 		freqModifier = 0;
+
 	if (params.m_VehicleType == VEHICLE_TYPE_BIKE && bike->bExtraSpeed)
 		freqModifier += 1400;
+
 	gearSoundLength = 0;
 	engineSoundType = aVehicleSettings[params.m_nIndex].m_nBank;
 	soundOffset = gBankStartOffset[engineSoundType] - gBankStartOffset[CAR_SFX_BANKS_OFFSET];
@@ -2177,15 +2417,14 @@ cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams& params, CVehicle* veh
 		noGearBox = TRUE;
 		break;
 	}
-	if (!channelUsed || nCruising || noGearBox) {
-		gearSoundStartTime = CTimer::GetTimeInMilliseconds();
-	} else {
+	if (channelUsed && nCruising == 0 && !noGearBox) {
 		gearSoundLength -= 1000;
 		if (CTimer::GetTimeInMilliseconds() - gearSoundStartTime > gearSoundLength) {
 			channelUsed = FALSE;
 			gearSoundStartTime = CTimer::GetTimeInMilliseconds();
 		}
-	}
+	} else
+		gearSoundStartTime = CTimer::GetTimeInMilliseconds();
 	relativeVelocityChange = 2.0f * params.m_fVelocityChange / params.m_pTransmission->fMaxVelocity;
 	accelerationMultipler = Clamp(relativeVelocityChange, 0.0f, 1.0f);
 	gasPedalAudio = accelerationMultipler;
@@ -2202,56 +2441,7 @@ cAudioManager::ProcessPlayersVehicleEngine(cVehicleParams& params, CVehicle* veh
 	default:
 		break;
 	}*/
-	if (accelerateState <= 0) {
-		if (slowingDown) {
-			if (channelUsed) {
-				SampleManager.StopChannel(nChannel);
-				bAccelSampleStopped = TRUE;
-			}
-			if (wheelsOnGround == 0 || params.m_pVehicle->bIsHandbrakeOn || lostTraction)
-				gasPedalAudio = *gasPedalAudioPtr;
-			else if (params.m_VehicleType == VEHICLE_TYPE_BIKE)
-				gasPedalAudio = 0.0f;
-			else
-				gasPedalAudio = Min(1.0f, params.m_fVelocityChange / params.m_pTransmission->fMaxReverseVelocity);
-			*gasPedalAudioPtr = Max(0.0f, gasPedalAudio);
-		} else if (LastAccel > 0) {
-			if (channelUsed) {
-				SampleManager.StopChannel(nChannel);
-				bAccelSampleStopped = TRUE;
-			}
-			nCruising = 0;
-			if (wheelsOnGround == 0
-				|| params.m_pVehicle->bIsHandbrakeOn
-				|| lostTraction
-				|| params.m_fVelocityChange < 0.01f && *gasPedalAudioPtr > 0.2f) {
-				if (isMoped) {
-					gasPedalAudio = 0.0f;
-				} else {
-					*gasPedalAudioPtr *= 0.6f;
-					gasPedalAudio = *gasPedalAudioPtr;
-				}
-			}
-			if (gasPedalAudio > 0.05f) {
-				freq = (5000.f * ((gasPedalAudio - 0.05f) * 20.f / 19)) + 19000;
-				vol = (25.0f * ((gasPedalAudio - 0.05f) * 20.f / 19)) + 40;
-				if (params.m_pVehicle->bIsDrowning)
-					vol /= 4;
-				if (engineSoundType == SFX_BANK_TRUCK)
-					freq /= 2;
-				AddPlayerCarSample(vol, freq, soundOffset + SFX_CAR_FINGER_OFF_ACCEL_1, engineSoundType, 63, FALSE);
-			}
-		}
-		freq = (10000.f * gasPedalAudio) + 22050;
-		vol = 110 - (40.0f * gasPedalAudio);
-		if (engineSoundType == SFX_BANK_TRUCK)
-			freq /= 2;
-		if (params.m_pVehicle->bIsDrowning)
-			vol /= 4;
-		AddPlayerCarSample(vol, freq, aEngineSounds[engineSoundType - CAR_SFX_BANKS_OFFSET][0], SFX_BANK_0, 52, TRUE);
-
-		CurrentPretendGear = Max(1, currentGear);
-	} else {
+	if (accelerateState > 0) {
 		if (nCruising > 0) {
 PlayCruising:
 			bAccelSampleStopped = TRUE;
@@ -2260,15 +2450,16 @@ PlayCruising:
 				|| lostTraction || currentGear < params.m_pTransmission->nNumberOfGears - 1)) {
 				nCruising = 0;
 			} else {
-				if (accelerateState >= 220 && params.m_fVelocityChange + 0.001f >= velocityChangeForAudio) {
+				if (accelerateState < 220 || params.m_fVelocityChange + 0.001f < velocityChangeForAudio) {
+					if (nCruising > 3)
+						nCruising--; 
+				} else
 					if (nCruising < 800)
 						nCruising++;
-				} else if (nCruising > 3)
-					nCruising--;
 				freq = 27 * nCruising + freqModifier + 22050;
 				if (engineSoundType == SFX_BANK_TRUCK)
 					freq >>= 1;
-				AddPlayerCarSample(120, freq, soundOffset + SFX_CAR_AFTER_ACCEL_1, engineSoundType, 64, TRUE);
+				AddPlayerCarSample(PLAYER_VEHICLE_ENGINE_VOLUME, freq, soundOffset + SFX_CAR_AFTER_ACCEL_1, engineSoundType, 64, TRUE);
 			}
 		} else {
 			stuckInSand = params.m_VehicleType == VEHICLE_TYPE_CAR && ((CAutomobile*)params.m_pVehicle)->bStuckInSand;
@@ -2284,10 +2475,10 @@ PlayCruising:
 						baseFreq = (15000 * *gasPedalAudioPtr) + 14000;
 					else
 						baseFreq = (25000 * *gasPedalAudioPtr) + 14000;
-					vol = (25.0f * *gasPedalAudioPtr) + 60;
+					vol = (25 * *gasPedalAudioPtr) + 60;
 				} else {
 					baseFreq = (8000 * accelerationMultipler) + 16000;
-					vol = (25.0f * accelerationMultipler) + 60;
+					vol = (25 * accelerationMultipler) + 60;
 					*gasPedalAudioPtr = accelerationMultipler;
 				}
 				freq = freqModifier + baseFreq;
@@ -2338,11 +2529,11 @@ PlayCruising:
 				}
 
 #ifdef EXTERNAL_3D_SOUND
-				SampleManager.SetChannelEmittingVolume(CHANNEL_PLAYER_VEHICLE_ENGINE, 120);
+				SampleManager.SetChannelEmittingVolume(CHANNEL_PLAYER_VEHICLE_ENGINE, PLAYER_VEHICLE_ENGINE_VOLUME);
 				SampleManager.SetChannel3DPosition(CHANNEL_PLAYER_VEHICLE_ENGINE, pos.x, pos.y, pos.z);
-				SampleManager.SetChannel3DDistances(CHANNEL_PLAYER_VEHICLE_ENGINE, 50.0f, 50.0f * 0.25f);
+				SampleManager.SetChannel3DDistances(CHANNEL_PLAYER_VEHICLE_ENGINE, VEHICLE_ENGINE_MAX_DIST, VEHICLE_ENGINE_MAX_DIST / 4.0f);
 #else
-				SampleManager.SetChannelVolume(nChannel, ComputeVolume(120, 50.0f, m_sQueueSample.m_fDistance));
+				SampleManager.SetChannelVolume(nChannel, ComputeVolume(PLAYER_VEHICLE_ENGINE_VOLUME, VEHICLE_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance));
 				SampleManager.SetChannelPan(nChannel, m_sQueueSample.m_nPan);
 #endif
 				freq = GearFreqAdj[CurrentPretendGear] + freqModifier + 22050;
@@ -2361,6 +2552,55 @@ PlayCruising:
 				}
 			}
 		}
+	} else {
+		if (slowingDown) {
+			if (channelUsed) {
+				SampleManager.StopChannel(nChannel);
+				bAccelSampleStopped = TRUE;
+			}
+			if (wheelsOnGround == 0 || params.m_pVehicle->bIsHandbrakeOn || lostTraction)
+				gasPedalAudio = *gasPedalAudioPtr;
+			else if (params.m_VehicleType == VEHICLE_TYPE_BIKE)
+				gasPedalAudio = 0.0f;
+			else
+				gasPedalAudio = Min(1.0f, params.m_fVelocityChange / params.m_pTransmission->fMaxReverseVelocity);
+			*gasPedalAudioPtr = Max(0.0f, gasPedalAudio);
+		} else if (LastAccel > 0) {
+			if (channelUsed) {
+				SampleManager.StopChannel(nChannel);
+				bAccelSampleStopped = TRUE;
+			}
+			nCruising = 0;
+			if (wheelsOnGround == 0
+				|| params.m_pVehicle->bIsHandbrakeOn
+				|| lostTraction
+				|| params.m_fVelocityChange < 0.01f && *gasPedalAudioPtr > 0.2f) {
+				if (params.m_pVehicle->GetModelIndex() == MI_PIZZABOY || params.m_pVehicle->GetModelIndex() == MI_FAGGIO) {
+					gasPedalAudio = 0.0f;
+				} else {
+					*gasPedalAudioPtr *= 0.6f;
+					gasPedalAudio = *gasPedalAudioPtr;
+				}
+			}
+			if (gasPedalAudio > 0.05f) {
+				freq = (5000 * ((gasPedalAudio - 0.05f) / 0.95f)) + 19000;
+				vol = (25 * ((gasPedalAudio - 0.05f) / 0.95f)) + 40;
+				if (params.m_pVehicle->bIsDrowning)
+					vol >>= 2;
+				if (engineSoundType == SFX_BANK_TRUCK)
+					freq >>= 1;
+				AddPlayerCarSample(vol, freq, soundOffset + SFX_CAR_FINGER_OFF_ACCEL_1, engineSoundType, 63, FALSE);
+			}
+		}
+		freq = (10000 * gasPedalAudio) + 22050;
+		vol = 110 - (40 * gasPedalAudio);
+		if (engineSoundType == SFX_BANK_TRUCK)
+			freq >>= 1;
+		if (params.m_pVehicle->bIsDrowning)
+			vol >>= 2;
+		AddPlayerCarSample(vol, freq, aEngineSounds[engineSoundType - CAR_SFX_BANKS_OFFSET][0], SFX_BANK_0, 52, TRUE);
+
+		CurrentPretendGear = Max(1, currentGear);
 	}
 	LastAccel = accelerateState;
 
@@ -2371,8 +2611,6 @@ PlayCruising:
 bool8
 cAudioManager::ProcessVehicleSkidding(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 40.0f;
-
 	CAutomobile *automobile;
 	CBike *bike;
 	uint8 numWheels;
@@ -2382,109 +2620,110 @@ cAudioManager::ProcessVehicleSkidding(cVehicleParams& params)
 
 
 	cTransmission *transmission;
-	int32 emittingVol;
+	uint8 Vol;
 	float newSkidVal = 0.0f;
 	float skidVal = 0.0f;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-	switch (params.m_VehicleType) {
-	case VEHICLE_TYPE_CAR:
-		automobile = (CAutomobile*)params.m_pVehicle;
-		numWheels = 4;
-		wheelStateArr = automobile->m_aWheelState;
-		wheelsOnGround = automobile->m_nWheelsOnGround;
-		gasPedalAudio = automobile->m_fGasPedalAudio;
-		break;
-	case VEHICLE_TYPE_BIKE:
-		bike = (CBike*)params.m_pVehicle;
-		numWheels = 2;
-		wheelStateArr = bike->m_aWheelState;
-		wheelsOnGround = bike->m_nWheelsOnGround;
-		gasPedalAudio = bike->m_fGasPedalAudio;
-		break;
-	default:
-		debug("\n * AUDIOLOG:  ProcessVehicleSkidding() Unsupported vehicle type %d * \n", params.m_VehicleType);
-		return TRUE;
-	}
-	if (wheelsOnGround == 0)
-		return TRUE;
-	CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-
-	for (uint8 i = 0; i < numWheels; i++) {
-		if (wheelStateArr[i] == WHEEL_STATE_NORMAL)
-			continue;
-		transmission = params.m_pTransmission;
-		switch (transmission->nDriveType) {
-		case '4':
-			newSkidVal = GetVehicleDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], gasPedalAudio, transmission, params.m_fVelocityChange);
-			break;
-		case 'F':
-			if (i == CARWHEEL_FRONT_LEFT || i == CARWHEEL_FRONT_RIGHT)
-				newSkidVal = GetVehicleDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], gasPedalAudio, transmission, params.m_fVelocityChange);
-			else
-				newSkidVal = GetVehicleNonDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], transmission, params.m_fVelocityChange);
+	if (params.m_fDistance < SQR(VEHICLE_SKIDDING_MAX_DIST)) {
+		switch (params.m_VehicleType) {
+		case VEHICLE_TYPE_CAR:
+			automobile = (CAutomobile*)params.m_pVehicle;
+			numWheels = 4;
+			wheelStateArr = automobile->m_aWheelState;
+			wheelsOnGround = automobile->m_nWheelsOnGround;
+			gasPedalAudio = automobile->m_fGasPedalAudio;
 			break;
-		case 'R':
-			if (i == CARWHEEL_REAR_LEFT || i == CARWHEEL_REAR_RIGHT)
-				newSkidVal = GetVehicleDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], gasPedalAudio, transmission, params.m_fVelocityChange);
-			else
-				newSkidVal = GetVehicleNonDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], transmission, params.m_fVelocityChange);
+		case VEHICLE_TYPE_BIKE:
+			bike = (CBike*)params.m_pVehicle;
+			numWheels = 2;
+			wheelStateArr = bike->m_aWheelState;
+			wheelsOnGround = bike->m_nWheelsOnGround;
+			gasPedalAudio = bike->m_fGasPedalAudio;
 			break;
 		default:
-			break;
+			debug("\n * AUDIOLOG:  ProcessVehicleSkidding() Unsupported vehicle type %d * \n", params.m_VehicleType);
+			return TRUE;
 		}
-		skidVal = Max(skidVal, newSkidVal);
-	}
-
-	if (skidVal > 0.0f) {
-		emittingVol = 50.f * skidVal;
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nCounter = 3;
-			switch (params.m_pVehicle->m_nSurfaceTouched) {
-			case SURFACE_GRASS:
-			case SURFACE_HEDGE:
-				m_sQueueSample.m_nSampleIndex = SFX_RAIN;
-				emittingVol /= 4;
-				m_sQueueSample.m_nFrequency = 13000.f * skidVal + 35000.f;
-				m_sQueueSample.m_nVolume /= 4;
-				if (m_sQueueSample.m_nVolume == 0)
-					return TRUE;
-				break;
-			case SURFACE_GRAVEL:
-			case SURFACE_MUD_DRY:
-			case SURFACE_SAND:
-			case SURFACE_WATER:
-			case SURFACE_SAND_BEACH:
-				m_sQueueSample.m_nSampleIndex = SFX_GRAVEL_SKID;
-				m_sQueueSample.m_nFrequency = 6000.f * skidVal + 10000.f;
-				break;
+		if (wheelsOnGround > 0) {
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
 
-			default:
-				m_sQueueSample.m_nSampleIndex = SFX_SKID;
-				m_sQueueSample.m_nFrequency = 5000.f * skidVal + 11000.f;
-				if (params.m_VehicleType == VEHICLE_TYPE_BIKE)
-					m_sQueueSample.m_nFrequency += 2000;
-				break;
+			for (uint8 i = 0; i < numWheels; i++) {
+				if (wheelStateArr[i] == WHEEL_STATE_NORMAL)
+					continue;
+				transmission = params.m_pTransmission;
+				switch (transmission->nDriveType) {
+				case '4':
+					newSkidVal = GetVehicleDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], gasPedalAudio, transmission, params.m_fVelocityChange);
+					break;
+				case 'F':
+					if (i == CARWHEEL_FRONT_LEFT || i == CARWHEEL_FRONT_RIGHT)
+						newSkidVal = GetVehicleDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], gasPedalAudio, transmission, params.m_fVelocityChange);
+					else
+						newSkidVal = GetVehicleNonDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], transmission, params.m_fVelocityChange);
+					break;
+				case 'R':
+					if (i == CARWHEEL_REAR_LEFT || i == CARWHEEL_REAR_RIGHT)
+						newSkidVal = GetVehicleDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], gasPedalAudio, transmission, params.m_fVelocityChange);
+					else
+						newSkidVal = GetVehicleNonDriveWheelSkidValue(params.m_pVehicle, wheelStateArr[i], transmission, params.m_fVelocityChange);
+					break;
+				default:
+					break;
+				}
+				skidVal = Max(skidVal, newSkidVal);
 			}
 
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 8;
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVol);
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 3;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
+			if (skidVal > 0.0f) {
+				Vol = VEHICLE_SKIDDING_VOLUME * skidVal;
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, VEHICLE_SKIDDING_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
+					m_sQueueSample.m_nCounter = 3;
+					switch (params.m_pVehicle->m_nSurfaceTouched) {
+					case SURFACE_GRASS:
+					case SURFACE_HEDGE:
+						m_sQueueSample.m_nSampleIndex = SFX_RAIN;
+						Vol >>= 2;
+						m_sQueueSample.m_nFrequency = 13000 * skidVal + 35000;
+						m_sQueueSample.m_nVolume >>= 2;
+						if (m_sQueueSample.m_nVolume == 0)
+							return TRUE;
+						break;
+					case SURFACE_GRAVEL:
+					case SURFACE_MUD_DRY:
+					case SURFACE_SAND:
+					case SURFACE_WATER:
+					case SURFACE_SAND_BEACH:
+						m_sQueueSample.m_nSampleIndex = SFX_GRAVEL_SKID;
+						m_sQueueSample.m_nFrequency = 6000 * skidVal + 10000;
+						break;
+
+					default:
+						m_sQueueSample.m_nSampleIndex = SFX_SKID;
+						m_sQueueSample.m_nFrequency = 5000 * skidVal + 11000;
+						if (params.m_VehicleType == VEHICLE_TYPE_BIKE)
+							m_sQueueSample.m_nFrequency += 2000;
+						break;
+					}
+
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 8;
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(Vol);
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+					m_sQueueSample.m_MaxDistance = VEHICLE_SKIDDING_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
+					m_sQueueSample.m_nFramesToPlay = 3;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
+				}
+			}
 		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 float
@@ -2536,61 +2775,54 @@ cAudioManager::GetVehicleNonDriveWheelSkidValue(CVehicle *veh, tWheelState wheel
 bool8
 cAudioManager::ProcessVehicleHorn(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 40.0f;
-
-	CVehicle *veh;
-	uint8 volume;
-
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-
-	veh = params.m_pVehicle;
-	if (veh->m_bSirenOrAlarm && UsesSirenSwitching(params))
-		return TRUE;
+	if (params.m_fDistance < SQR(VEHICLE_HORN_MAX_DIST)) {
+		if (params.m_pVehicle->m_bSirenOrAlarm && UsesSirenSwitching(params))
+			return TRUE;
 
-	if (veh->m_modelIndex == MI_MRWHOOP)
-		return TRUE;
+		if (params.m_pVehicle->GetModelIndex() == MI_MRWHOOP)
+			return TRUE;
 
-	if (veh->IsAlarmOn())
-		return TRUE;
+		if (params.m_pVehicle->IsAlarmOn())
+			return TRUE;
 
-	if (veh->m_nCarHornTimer != 0) {
-		if (veh->GetStatus() != STATUS_PLAYER) {
-			veh->m_nCarHornTimer = Min(44, veh->m_nCarHornTimer);
-			if (veh->m_nCarHornTimer == 44)
-				veh->m_nCarHornPattern = (m_FrameCounter + m_sQueueSample.m_nEntityIndex) & 7;
+		if (params.m_pVehicle->m_nCarHornTimer > 0) {
+			if (params.m_pVehicle->GetStatus() != STATUS_PLAYER) {
+				params.m_pVehicle->m_nCarHornTimer = Min(44, params.m_pVehicle->m_nCarHornTimer);
+				if (params.m_pVehicle->m_nCarHornTimer == 44)
+					params.m_pVehicle->m_nCarHornPattern = (m_FrameCounter + m_sQueueSample.m_nEntityIndex) & 7;
 
-			if (!HornPattern[veh->m_nCarHornPattern][44 - veh->m_nCarHornTimer])
-				return TRUE;
-		}
+				if (!HornPattern[params.m_pVehicle->m_nCarHornPattern][44 - params.m_pVehicle->m_nCarHornTimer])
+					return TRUE;
+			}
 
-		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		volume = veh->bIsDrowning ? 20 : 80;
-		m_sQueueSample.m_nVolume = ComputeVolume(volume, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nCounter = 4;
-			m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nHornSample;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_nFrequency = aVehicleSettings[params.m_nIndex].m_nHornFrequency;
-			m_sQueueSample.m_nLoopCount = 0;
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(params.m_pVehicle->bIsDrowning ? VEHICLE_HORN_VOLUME / 4 : VEHICLE_HORN_VOLUME, VEHICLE_HORN_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = 4;
+				m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nHornSample;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 2;
+				m_sQueueSample.m_nFrequency = aVehicleSettings[params.m_nIndex].m_nHornFrequency;
+				m_sQueueSample.m_nLoopCount = 0;
 #ifdef FIX_BUGS
-			SET_EMITTING_VOLUME(volume);
+				SET_EMITTING_VOLUME(params.m_pVehicle->bIsDrowning ? VEHICLE_HORN_VOLUME / 4 : VEHICLE_HORN_VOLUME);
 #else
-			SET_EMITTING_VOLUME(80);
+				SET_EMITTING_VOLUME(VEHICLE_HORN_VOLUME);
 #endif
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 5.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 4;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
+				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+				m_sQueueSample.m_fSpeedMultiplier = 5.0f;
+				m_sQueueSample.m_MaxDistance = VEHICLE_HORN_MAX_DIST;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 4;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
+			}
 		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
@@ -2610,67 +2842,63 @@ cAudioManager::UsesSirenSwitching(cVehicleParams& params)
 bool8
 cAudioManager::ProcessVehicleSirenOrAlarm(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 110.0f;
-
-	CVehicle *veh;
-	uint8 volume;
-
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-
-	veh = params.m_pVehicle;
-	if (!veh->m_bSirenOrAlarm && !veh->IsAlarmOn())
-		return TRUE;
+	uint8 Vol;
 
-	if (veh->IsAlarmOn()) {
-		if (CTimer::GetTimeInMilliseconds() > veh->m_nCarHornTimer)
-			veh->m_nCarHornTimer = CTimer::GetTimeInMilliseconds() + 750;
+	if (params.m_fDistance < SQR(VEHICLE_SIREN_MAX_DIST)) {
+		CVehicle *veh = params.m_pVehicle;
+		if (veh->m_bSirenOrAlarm || veh->IsAlarmOn()) {
+			if (veh->IsAlarmOn()) {
+				if (CTimer::GetTimeInMilliseconds() > veh->m_nCarHornTimer)
+					veh->m_nCarHornTimer = CTimer::GetTimeInMilliseconds() + 750;
 
-		if (veh->m_nCarHornTimer < CTimer::GetTimeInMilliseconds() + 375)
-			return TRUE;
-	}
+				if (veh->m_nCarHornTimer < CTimer::GetTimeInMilliseconds() + 375)
+					return TRUE;
+			}
 
-	CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-	volume = veh->bIsDrowning ? 20 : 80;
-	m_sQueueSample.m_nVolume = ComputeVolume(volume, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 5;
-		if (UsesSiren(params)) {
-			if (params.m_pVehicle->GetStatus() == STATUS_ABANDONED)
-				return TRUE;
-			if (veh->m_nCarHornTimer != 0 && params.m_nIndex != FIRETRUK && params.m_nIndex != MRWHOOP) {
-				m_sQueueSample.m_nSampleIndex = SFX_SIREN_FAST;
-				if (params.m_nIndex == FBIRANCH)
-					m_sQueueSample.m_nFrequency = 12668;
-				else
-					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SIREN_FAST);
-				m_sQueueSample.m_nCounter = 60;
-			} else if (params.m_nIndex == VICECHEE) {
-				m_sQueueSample.m_nSampleIndex = SFX_POLICE_SIREN_SLOW;
-				m_sQueueSample.m_nFrequency = 11440;
-			} else {
-				m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nSirenOrAlarmSample;
-				m_sQueueSample.m_nFrequency = aVehicleSettings[params.m_nIndex].m_nSirenOrAlarmFrequency;
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			Vol = veh->bIsDrowning ? VEHICLE_SIREN_VOLUME / 4 : VEHICLE_SIREN_VOLUME;
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, VEHICLE_SIREN_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = 5;
+				if (UsesSiren(params)) {
+					if (params.m_pVehicle->GetStatus() == STATUS_ABANDONED)
+						return TRUE;
+					if (veh->m_nCarHornTimer > 0 && params.m_nIndex != FIRETRUK && params.m_nIndex != MRWHOOP) {
+						m_sQueueSample.m_nSampleIndex = SFX_SIREN_FAST;
+						if (params.m_nIndex == FBIRANCH)
+							m_sQueueSample.m_nFrequency = 12668;
+						else
+							m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SIREN_FAST);
+						m_sQueueSample.m_nCounter = 60;
+					} else if (params.m_nIndex == VICECHEE) {
+						m_sQueueSample.m_nSampleIndex = SFX_POLICE_SIREN_SLOW;
+						m_sQueueSample.m_nFrequency = 11440;
+					} else {
+						m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nSirenOrAlarmSample;
+						m_sQueueSample.m_nFrequency = aVehicleSettings[params.m_nIndex].m_nSirenOrAlarmFrequency;
+					}
+				} else {
+					m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nHornSample;
+					m_sQueueSample.m_nFrequency = aVehicleSettings[params.m_nIndex].m_nHornFrequency;
+				}
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 1;
+				m_sQueueSample.m_nLoopCount = 0;
+				SET_EMITTING_VOLUME(Vol);
+				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+				m_sQueueSample.m_fSpeedMultiplier = 7.0f;
+				m_sQueueSample.m_MaxDistance = VEHICLE_SIREN_MAX_DIST;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 5;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
 			}
-		} else {
-			m_sQueueSample.m_nSampleIndex = aVehicleSettings[params.m_nIndex].m_nHornSample;
-			m_sQueueSample.m_nFrequency = aVehicleSettings[params.m_nIndex].m_nHornFrequency;
 		}
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 1;
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(volume);
-		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		m_sQueueSample.m_fSpeedMultiplier = 7.0f;
-		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 5;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
@@ -2682,131 +2910,120 @@ cAudioManager::UsesReverseWarning(uint32 model)
 bool8
 cAudioManager::ProcessVehicleReverseWarning(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 50.0f;
-
 	CVehicle *veh = params.m_pVehicle;
-	uint8 volume;
-
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
 
-	if (veh->bEngineOn && veh->m_fGasPedal < 0.0f) {
-		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		volume = veh->bIsDrowning ? 15 : 60;
-		m_sQueueSample.m_nVolume = ComputeVolume(volume, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nCounter = 12;
-			m_sQueueSample.m_nSampleIndex = SFX_REVERSE_WARNING;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_nFrequency = (100 * m_sQueueSample.m_nEntityIndex & 1023) + SampleManager.GetSampleBaseFrequency(SFX_REVERSE_WARNING);
-			m_sQueueSample.m_nLoopCount = 0;
+	if (params.m_fDistance < SQR(VEHICLE_REVERSE_WARNING_MAX_DIST)) {
+		if (veh->bEngineOn && veh->m_fGasPedal < 0.0f) {
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(veh->bIsDrowning ? VEHICLE_REVERSE_WARNING_VOLUME / 4 : VEHICLE_REVERSE_WARNING_VOLUME, VEHICLE_REVERSE_WARNING_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = 12;
+				m_sQueueSample.m_nSampleIndex = SFX_REVERSE_WARNING;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 2;
+				m_sQueueSample.m_nFrequency = (100 * m_sQueueSample.m_nEntityIndex % 1024) + SampleManager.GetSampleBaseFrequency(SFX_REVERSE_WARNING);
+				m_sQueueSample.m_nLoopCount = 0;
 #ifdef FIX_BUGS
-			SET_EMITTING_VOLUME(volume);
+				SET_EMITTING_VOLUME(veh->bIsDrowning ? VEHICLE_REVERSE_WARNING_VOLUME / 4 : VEHICLE_REVERSE_WARNING_VOLUME);
 #else
-			SET_EMITTING_VOLUME(60);
+				SET_EMITTING_VOLUME(VEHICLE_REVERSE_WARNING_VOLUME);
 #endif
-			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 3;
-			SET_SOUND_REVERB(TRUE);
-			SET_SOUND_REFLECTION(FALSE);
-			AddSampleToRequestedQueue();
+				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+				m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+				m_sQueueSample.m_MaxDistance = VEHICLE_REVERSE_WARNING_MAX_DIST;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 3;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
+			}
 		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
 cAudioManager::ProcessVehicleDoors(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 40.0f;
-
 	CAutomobile *automobile;
 	int8 doorState;
-	int32 emittingVol;
+	uint8 Vol;
 	float velocity;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-
-	automobile = (CAutomobile *)params.m_pVehicle;
-	CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-	for (uint8 i = 0; i < ARRAY_SIZE(automobile->Doors); i++) {
-		if (automobile->Damage.GetDoorStatus(i) == DOOR_STATUS_SWINGING) {
-			doorState = automobile->Doors[i].m_nDoorState;
-			if (doorState == DOORST_OPEN || doorState == DOORST_CLOSED) {
-				velocity = Min(0.3f, Abs(automobile->Doors[i].m_fAngVel));
-				if (velocity > 0.0035f) {
-					emittingVol = (100.0f * velocity * 10.0f / 3.0f);
-					m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-					if (m_sQueueSample.m_nVolume > 0) {
-						m_sQueueSample.m_nCounter = i + 6;
-						m_sQueueSample.m_nSampleIndex = m_anRandomTable[1] % 6 + SFX_COL_CAR_PANEL_1;
-						m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex) + RandomDisplacement(1000);
-						m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-						m_sQueueSample.m_bIs2D = FALSE;
-						m_sQueueSample.m_nPriority = 10;
-						m_sQueueSample.m_nLoopCount = 1;
-						SET_EMITTING_VOLUME(emittingVol);
-						RESET_LOOP_OFFSETS
-						m_sQueueSample.m_fSpeedMultiplier = 1.0f;
-						m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-						m_sQueueSample.m_bStatic = TRUE;
-						SET_SOUND_REVERB(TRUE);
-						SET_SOUND_REFLECTION(TRUE);
-						AddSampleToRequestedQueue();
+	if (params.m_fDistance < SQR(VEHICLE_DOORS_MAX_DIST)) {
+		automobile = (CAutomobile *)params.m_pVehicle;
+		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+		for (uint8 i = 0; i < ARRAY_SIZE(automobile->Doors); i++) {
+			if (automobile->Damage.GetDoorStatus(i) == DOOR_STATUS_SWINGING) {
+				doorState = automobile->Doors[i].m_nDoorState;
+				if (doorState == DOORST_OPEN || doorState == DOORST_CLOSED) {
+					velocity = Min(0.3f, Abs(automobile->Doors[i].m_fAngVel));
+					if (velocity > 0.0035f) {
+						Vol = (VEHICLE_DOORS_VOLUME * velocity / 0.3f);
+						m_sQueueSample.m_nVolume = ComputeVolume(Vol, VEHICLE_DOORS_MAX_DIST, m_sQueueSample.m_fDistance);
+						if (m_sQueueSample.m_nVolume > 0) {
+							m_sQueueSample.m_nCounter = i + 6;
+							m_sQueueSample.m_nSampleIndex = m_anRandomTable[1] % 6 + SFX_COL_CAR_PANEL_1;
+							m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex) + RandomDisplacement(1000);
+							m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+							m_sQueueSample.m_bIs2D = FALSE;
+							m_sQueueSample.m_nPriority = 10;
+							m_sQueueSample.m_nLoopCount = 1;
+							SET_EMITTING_VOLUME(Vol);
+							RESET_LOOP_OFFSETS
+							m_sQueueSample.m_fSpeedMultiplier = 1.0f;
+							m_sQueueSample.m_MaxDistance = VEHICLE_DOORS_MAX_DIST;
+							m_sQueueSample.m_bStatic = TRUE;
+							SET_SOUND_REVERB(TRUE);
+							SET_SOUND_REFLECTION(TRUE);
+							AddSampleToRequestedQueue();
+						}
 					}
 				}
 			}
 		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
 cAudioManager::ProcessAirBrakes(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 30.0f;
 	CAutomobile *automobile;
-	uint8 volume;
-
-	if (params.m_fDistance > SQR(SOUND_INTENSITY))
-		return FALSE;
-	automobile = (CAutomobile *)params.m_pVehicle;
-	if (!automobile->bEngineOn)
-		return TRUE;
+	uint8 Vol;
 
-	if ((automobile->m_fVelocityChangeForAudio < 0.025f || params.m_fVelocityChange >= 0.025f) &&
-	    (automobile->m_fVelocityChangeForAudio > -0.025f || params.m_fVelocityChange <= 0.025f))
+	if (params.m_fDistance < SQR(AIR_BRAKES_MAX_DIST)) {
+		automobile = (CAutomobile *)params.m_pVehicle;
+		if (automobile->bEngineOn && (automobile->m_fVelocityChangeForAudio >= 0.025f && params.m_fVelocityChange < 0.025f ||
+			automobile->m_fVelocityChangeForAudio <= -0.025f && params.m_fVelocityChange > 0.025f)) {
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			Vol = m_anRandomTable[0] % 10 + AIR_BRAKES_VOLUME;
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, AIR_BRAKES_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = 13;
+				m_sQueueSample.m_nSampleIndex = SFX_AIR_BRAKES;
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_AIR_BRAKES);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 10;
+				m_sQueueSample.m_nLoopCount = 1;
+				SET_EMITTING_VOLUME(Vol);
+				RESET_LOOP_OFFSETS
+				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+				m_sQueueSample.m_MaxDistance = AIR_BRAKES_MAX_DIST;
+				m_sQueueSample.m_bStatic = TRUE;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
+			}
+		}
 		return TRUE;
-
-	CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-	volume = m_anRandomTable[0] % 10 + 70;
-	m_sQueueSample.m_nVolume = ComputeVolume(volume, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 13;
-		m_sQueueSample.m_nSampleIndex = SFX_AIR_BRAKES;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_AIR_BRAKES);
-		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 10;
-		m_sQueueSample.m_nLoopCount = 1;
-		SET_EMITTING_VOLUME(volume);
-		RESET_LOOP_OFFSETS
-		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		m_sQueueSample.m_bStatic = TRUE;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
 	}
-
-	return TRUE;
+	return FALSE;
 }
 
 bool8
@@ -2819,295 +3036,303 @@ cAudioManager::HasAirBrakes(uint32 model)
 bool8
 cAudioManager::ProcessEngineDamage(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 40.0f;
-
-	float health;
-	uint8 emittingVolume;
+	uint8 Vol;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-	if (params.m_pVehicle->m_modelIndex == MI_CADDY)
-		return TRUE;
-	if (params.m_pVehicle->GetStatus() == STATUS_WRECKED)
-		return TRUE;
-	health = params.m_pVehicle->m_fHealth;
-	if (health < 390.0f) {
-		if (health < 250.0f) {
-			emittingVolume = 60;
+	if (params.m_fDistance < SQR(ENGINE_DAMAGE_MAX_DIST)) {
+		if (params.m_pVehicle->m_modelIndex == MI_CADDY)
+			return TRUE;
+		if (params.m_pVehicle->GetStatus() == STATUS_WRECKED || params.m_pVehicle->m_fHealth >= 390)
+			return TRUE;
+		if (params.m_pVehicle->m_fHealth < 250.0f) {
+			Vol = 60;
 			m_sQueueSample.m_nSampleIndex = SFX_CAR_ON_FIRE;
 			m_sQueueSample.m_nPriority = 7;
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_CAR_ON_FIRE);
 		} else {
-			emittingVolume = 30;
+			Vol = 30;
 			m_sQueueSample.m_nSampleIndex = SFX_PALM_TREE_LO;
 			m_sQueueSample.m_nPriority = 7;
 			m_sQueueSample.m_nFrequency = 27000;
 		}
 		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
 		if (params.m_pVehicle->bIsDrowning)
-			emittingVolume /= 2;
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVolume, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
+			Vol >>= 2;
+		m_sQueueSample.m_nVolume = ComputeVolume(Vol, ENGINE_DAMAGE_MAX_DIST, m_sQueueSample.m_fDistance);
 		if (m_sQueueSample.m_nVolume > 0) {
 			m_sQueueSample.m_nCounter = 28;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(emittingVolume);
+			SET_EMITTING_VOLUME(Vol);
 			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+			m_sQueueSample.m_MaxDistance = ENGINE_DAMAGE_MAX_DIST;
 			m_sQueueSample.m_bStatic = FALSE;
 			m_sQueueSample.m_nFramesToPlay = 3;
 			SET_SOUND_REVERB(TRUE);
 			SET_SOUND_REFLECTION(FALSE);
 			AddSampleToRequestedQueue();
 		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
 cAudioManager::ProcessCarBombTick(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 40.0f;
-	const uint8 EMITTING_VOLUME = 60;
-
 	uint8 bombType;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-	if (params.m_pVehicle->bEngineOn) {
-		switch (params.m_VehicleType) {
-		case VEHICLE_TYPE_CAR:
-			bombType = ((CAutomobile*)params.m_pVehicle)->m_bombType;
-			break;
-		case VEHICLE_TYPE_BIKE:
-			bombType = ((CBike*)params.m_pVehicle)->m_bombType;
-			break;
-		default:
-			debug("\n * AUDIOLOG:  ProcessCarBombTick()  Unsupported vehicle type %d * \n", params.m_VehicleType);
-			return TRUE;
-			break;
-		}
-		if (bombType == CARBOMB_TIMEDACTIVE) {
-			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(EMITTING_VOLUME, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-			if (m_sQueueSample.m_nVolume > 0) {
-				m_sQueueSample.m_nCounter = 35;
-				m_sQueueSample.m_nSampleIndex = SFX_COUNTDOWN;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_bIs2D = FALSE;
-				m_sQueueSample.m_nPriority = 0;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_COUNTDOWN);
-				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(EMITTING_VOLUME);
-				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-				m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-				m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-				m_sQueueSample.m_bStatic = FALSE;
-				m_sQueueSample.m_nFramesToPlay = 3;
-				SET_SOUND_REVERB(TRUE);
-				SET_SOUND_REFLECTION(FALSE);
-				AddSampleToRequestedQueue();
+	if (params.m_fDistance < SQR(CAR_BOMB_TICK_MAX_DIST)) {
+		if (params.m_pVehicle->bEngineOn) {
+			switch (params.m_VehicleType) {
+			case VEHICLE_TYPE_CAR:
+				bombType = ((CAutomobile*)params.m_pVehicle)->m_bombType;
+				break;
+			case VEHICLE_TYPE_BIKE:
+				bombType = ((CBike*)params.m_pVehicle)->m_bombType;
+				break;
+			default:
+				debug("\n * AUDIOLOG:  ProcessCarBombTick()  Unsupported vehicle type %d * \n", params.m_VehicleType);
+				return TRUE;
+			}
+			if (bombType == CARBOMB_TIMEDACTIVE) {
+				CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+				m_sQueueSample.m_nVolume = ComputeVolume(CAR_BOMB_TICK_VOLUME, CAR_BOMB_TICK_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
+					m_sQueueSample.m_nCounter = 35;
+					m_sQueueSample.m_nSampleIndex = SFX_COUNTDOWN;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 0;
+					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_COUNTDOWN);
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(CAR_BOMB_TICK_VOLUME);
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+					m_sQueueSample.m_MaxDistance = CAR_BOMB_TICK_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
+					m_sQueueSample.m_nFramesToPlay = 3;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
+				}
 			}
 		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 void
 cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 {
 	int16 event;
-	uint8 emittingVol;
-	float relVol;
-	float vol;
-	bool8 noReflections;
+	uint8 Vol;
+	float eventRelVol;
+	float eventVol;
+	bool8 bLoop;
 	bool8 stereo;
 	float maxDist;
+	static uint8 WaveIndex = 41;
 	static uint8 GunIndex = 53;
+	cPedParams pedParams;
+	static uint32 WaterFallFrame = 0;
 
 	for (uint16 i = 0; i < m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_AudioEvents; i++) {
-		noReflections = FALSE;
+		bLoop = FALSE;
 		stereo = FALSE;
 		SET_SOUND_REFLECTION(FALSE);
 		event = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i];
 		switch (event) {
-		case SOUND_CAR_DOOR_CLOSE_BONNET:
-		case SOUND_CAR_DOOR_CLOSE_BUMPER:
-		case SOUND_CAR_DOOR_CLOSE_FRONT_LEFT:
-		case SOUND_CAR_DOOR_CLOSE_FRONT_RIGHT:
-		case SOUND_CAR_DOOR_CLOSE_BACK_LEFT:
-		case SOUND_CAR_DOOR_CLOSE_BACK_RIGHT: {
-			const float SOUND_INTENSITY = 50.0f;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[2] % 5 + 122;
+		case SOUND_HELI_BLADE:
+		{
+			static uint8 HeliIndex = 89;
+			eventRelVol = ((CAutomobile*)params.m_pVehicle)->m_aWheelSpeed[1] * 50.0f / 11.0f;
+			if (eventRelVol < 0.2f || eventRelVol == 1.0f)
+				continue;
+			Vol = (1.0f - eventRelVol) * VEHICLE_ONE_SHOT_HELI_BLADE_VOLUME;
+			maxDist = SQR(VEHICLE_ONE_SHOT_HELI_BLADE_MAX_DIST);
+			m_sQueueSample.m_nSampleIndex = SFX_CAR_HELI_ROT;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = HeliIndex++;
+			if (HeliIndex > 90)
+				HeliIndex = 89;
+			m_sQueueSample.m_nFrequency = (8000 * eventRelVol) + 16000;
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_HELI_BLADE_MAX_DIST;
+			break;
+		}
+		case SOUND_CAR_WINDSHIELD_CRACK:
+			maxDist = SQR(VEHICLE_ONE_SHOT_WINDSHIELD_CRACK_MAX_DIST);
+			m_sQueueSample.m_nSampleIndex = SFX_GLASS_CRACK;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 68;
+			Vol = m_anRandomTable[1] % 30 + VEHICLE_ONE_SHOT_WINDSHIELD_CRACK_VOLUME;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GLASS_CRACK);
+			m_sQueueSample.m_nPriority = 5;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_WINDSHIELD_CRACK_MAX_DIST;
+			break;
+		case SOUND_CAR_DOOR_OPEN_BONNET:
+		case SOUND_CAR_DOOR_OPEN_BUMPER:
+		case SOUND_CAR_DOOR_OPEN_FRONT_LEFT:
+		case SOUND_CAR_DOOR_OPEN_FRONT_RIGHT:
+		case SOUND_CAR_DOOR_OPEN_BACK_LEFT:
+		case SOUND_CAR_DOOR_OPEN_BACK_RIGHT:
+			maxDist = SQR(VEHICLE_ONE_SHOT_DOOR_MAX_DIST);
+			Vol = m_anRandomTable[1] % (MAX_VOLUME - VEHICLE_ONE_SHOT_DOOR_CLOSE_VOLUME) + VEHICLE_ONE_SHOT_DOOR_CLOSE_VOLUME;
 			switch (aVehicleSettings[params.m_nIndex].m_bDoorType) {
 			case OLD_DOOR:
-				m_sQueueSample.m_nSampleIndex = SFX_OLD_CAR_DOOR_CLOSE;
+				m_sQueueSample.m_nSampleIndex = SFX_OLD_CAR_DOOR_OPEN;
 				break;
 			case NEW_DOOR:
-				m_sQueueSample.m_nSampleIndex = SFX_NEW_CAR_DOOR_CLOSE;
+			default:
+				m_sQueueSample.m_nSampleIndex = SFX_NEW_CAR_DOOR_OPEN;
 				break;
 			case TRUCK_DOOR:
-				m_sQueueSample.m_nSampleIndex = SFX_TRUCK_DOOR_CLOSE;
+				m_sQueueSample.m_nSampleIndex = SFX_TRUCK_DOOR_OPEN;
 				break;
 			case BUS_DOOR:
 				m_sQueueSample.m_nSampleIndex = SFX_AIR_BRAKES;
 				break;
-			default:
-				m_sQueueSample.m_nSampleIndex = SFX_NEW_CAR_DOOR_CLOSE;
-				break;
 			}
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 #ifdef THIS_IS_STUPID
-			m_sQueueSample.m_nCounter = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i] + 22;
+			m_sQueueSample.m_nCounter = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i] + 10;
 #else
-			m_sQueueSample.m_nCounter = event + 22;
+			m_sQueueSample.m_nCounter = event + 10;
 #endif
 			if (params.m_pVehicle->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI)
-				m_sQueueSample.m_nFrequency = 28062;
+				m_sQueueSample.m_nFrequency = 23459;
 			else
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 			m_sQueueSample.m_nPriority = 3;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_DOOR_MAX_DIST;
 			SET_SOUND_REFLECTION(TRUE);
 			break;
-		}
-		case SOUND_CAR_DOOR_OPEN_BONNET:
-		case SOUND_CAR_DOOR_OPEN_BUMPER:
-		case SOUND_CAR_DOOR_OPEN_FRONT_LEFT:
-		case SOUND_CAR_DOOR_OPEN_FRONT_RIGHT:
-		case SOUND_CAR_DOOR_OPEN_BACK_LEFT:
-		case SOUND_CAR_DOOR_OPEN_BACK_RIGHT: {
-			const float SOUND_INTENSITY = 50.0f;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[1] % 10 + 117;
+		case SOUND_CAR_DOOR_CLOSE_BONNET:
+		case SOUND_CAR_DOOR_CLOSE_BUMPER:
+		case SOUND_CAR_DOOR_CLOSE_FRONT_LEFT:
+		case SOUND_CAR_DOOR_CLOSE_FRONT_RIGHT:
+		case SOUND_CAR_DOOR_CLOSE_BACK_LEFT:
+		case SOUND_CAR_DOOR_CLOSE_BACK_RIGHT:
+			maxDist = SQR(VEHICLE_ONE_SHOT_DOOR_MAX_DIST);
+			Vol = m_anRandomTable[2] % (MAX_VOLUME - VEHICLE_ONE_SHOT_DOOR_OPEN_VOLUME) + VEHICLE_ONE_SHOT_DOOR_OPEN_VOLUME;
 			switch (aVehicleSettings[params.m_nIndex].m_bDoorType) {
 			case OLD_DOOR:
-				m_sQueueSample.m_nSampleIndex = SFX_OLD_CAR_DOOR_OPEN;
+				m_sQueueSample.m_nSampleIndex = SFX_OLD_CAR_DOOR_CLOSE;
+				break;
+			case NEW_DOOR:
+			default:
+				m_sQueueSample.m_nSampleIndex = SFX_NEW_CAR_DOOR_CLOSE;
 				break;
 			case TRUCK_DOOR:
-				m_sQueueSample.m_nSampleIndex = SFX_TRUCK_DOOR_OPEN;
+				m_sQueueSample.m_nSampleIndex = SFX_TRUCK_DOOR_CLOSE;
 				break;
 			case BUS_DOOR:
 				m_sQueueSample.m_nSampleIndex = SFX_AIR_BRAKES;
 				break;
-			default:
-				m_sQueueSample.m_nSampleIndex = SFX_NEW_CAR_DOOR_OPEN;
-				break;
 			}
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 #ifdef THIS_IS_STUPID
-			m_sQueueSample.m_nCounter = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i] + 10;
+			m_sQueueSample.m_nCounter = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i] + 22;
 #else
-			m_sQueueSample.m_nCounter = event + 10;
+			m_sQueueSample.m_nCounter = event + 22;
 #endif
 			if (params.m_pVehicle->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI)
-				m_sQueueSample.m_nFrequency = 23459;
+				m_sQueueSample.m_nFrequency = 28062;
 			else
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
 			m_sQueueSample.m_nPriority = 3;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_DOOR_MAX_DIST;
 			SET_SOUND_REFLECTION(TRUE);
 			break;
-		}
-		case SOUND_CAR_WINDSHIELD_CRACK: {
-			const float SOUND_INTENSITY = 40.0f;
-			maxDist = SQR(SOUND_INTENSITY);
-			m_sQueueSample.m_nSampleIndex = SFX_GLASS_CRACK;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 68;
-			emittingVol = m_anRandomTable[1] % 30 + 80;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GLASS_CRACK);
-			m_sQueueSample.m_nPriority = 5;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		} break;
-		case SOUND_CAR_JUMP: 
-		case SOUND_CAR_JUMP_2: {
-			const float SOUND_INTENSITY = 35.0f;
-			static uint8 WheelIndex = 82;
-			maxDist = SQR(SOUND_INTENSITY);
-#ifdef THIS_IS_STUPID
-			if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i] == SOUND_CAR_JUMP_2) {
-#else
-			if (event == SOUND_CAR_JUMP_2) {
-#endif
-				m_sQueueSample.m_nSampleIndex = SFX_TYRE_BURST_B;
-				emittingVol = Max(50.0f, 2 * (60.0f * m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]));
-			} else {
-				m_sQueueSample.m_nSampleIndex = SFX_TYRE_BUMP;
-				emittingVol = Max(80.f, 2 * (100.0f * m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]));
-			}
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = WheelIndex++;
-			if (WheelIndex > 85)
-				WheelIndex = 82;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TYRE_BUMP);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
-			if (params.m_VehicleType == VEHICLE_TYPE_BIKE)
-				m_sQueueSample.m_nFrequency *= 2;
-			m_sQueueSample.m_nPriority = 6;
-			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			break;
-		}
-		case SOUND_CAR_TYRE_POP: {
-			const float SOUND_INTENSITY = 60.0f;
-			static uint8 WheelIndex = 91;
-			m_sQueueSample.m_nSampleIndex = SFX_TYRE_BURST;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = WheelIndex++;
-			if (WheelIndex > 94)
-				WheelIndex = 91;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TYRE_BURST);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(2000);
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[4] % 10 + 117;
-			break;
-		}
-		case SOUND_CAR_ENGINE_START: {
-			const float SOUND_INTENSITY = 40.0f;
+		case SOUND_CAR_ENGINE_START:
 			if (params.m_pVehicle->GetVehicleAppearance() != VEHICLE_APPEARANCE_CAR
 				|| params.m_pVehicle->m_modelIndex == MI_CADDY)
 				continue;
-			emittingVol = 60;
-			maxDist = SQR(SOUND_INTENSITY);
+			Vol = VEHICLE_ONE_SHOT_CAR_ENGINE_START_VOLUME;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_ENGINE_START_MAX_DIST);
 			m_sQueueSample.m_nSampleIndex = SFX_CAR_STARTER;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nCounter = 33;
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_CAR_STARTER);
 			m_sQueueSample.m_nPriority = 1;
 			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_ENGINE_START_MAX_DIST;
 			SET_SOUND_REFLECTION(TRUE);
 			break;
-		}
-		case SOUND_CAR_LIGHT_BREAK: {
-			const float SOUND_INTENSITY = 30.0f;
+		case SOUND_WEAPON_HIT_VEHICLE:
+			m_sQueueSample.m_nSampleIndex = m_anRandomTable[m_sQueueSample.m_nEntityIndex % ARRAY_SIZE(m_anRandomTable)] % 6 + SFX_BULLET_CAR_1;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 34;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+			m_sQueueSample.m_nPriority = 7;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_WEAPON_HIT_VEHICLE_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_WEAPON_HIT_VEHICLE_MAX_DIST);
+			Vol = m_anRandomTable[3] % 20 + VEHICLE_ONE_SHOT_WEAPON_HIT_VEHICLE_VOLUME;
+			break;
+		case SOUND_BOMB_TIMED_ACTIVATED:
+		case SOUND_91:
+		case SOUND_BOMB_ONIGNITION_ACTIVATED:
+		case SOUND_BOMB_TICK:
+			m_sQueueSample.m_nSampleIndex = SFX_ARM_BOMB;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 36;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ARM_BOMB);
+			m_sQueueSample.m_nPriority = 0;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_BOMB_ARMED_MAX_DIST;
+			SET_SOUND_REFLECTION(TRUE);
+			Vol = VEHICLE_ONE_SHOT_BOMB_ARMED_VOLUME;
+			maxDist = SQR(VEHICLE_ONE_SHOT_BOMB_ARMED_MAX_DIST);
+			break;
+		case SOUND_CAR_LIGHT_BREAK:
 			m_sQueueSample.m_nSampleIndex = SFX_GLASS_SHARD_1;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nCounter = 37;
 			m_sQueueSample.m_nFrequency = 9 * SampleManager.GetSampleBaseFrequency(SFX_GLASS_SHARD_1) / 10;
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 8);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 3);
 			m_sQueueSample.m_nPriority = 5;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[4] % 10 + 30;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_WINDSHIELD_CRACK_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_WINDSHIELD_CRACK_MAX_DIST);
+			Vol = m_anRandomTable[4] % 10 + VEHICLE_ONE_SHOT_CAR_LIGHT_BREAK_VOLUME;
+			break;
+		case SOUND_PLANE_ON_GROUND:
+			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_LAND_WHEELS;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 81;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_JUMBO_LAND_WHEELS);
+			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_PLANE_ON_GROUND_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_PLANE_ON_GROUND_MAX_DIST);
+			Vol = m_anRandomTable[4] % 25 + VEHICLE_ONE_SHOT_PLANE_ON_GROUND_VOLUME;
+			break;
+		case SOUND_CAR_JERK:
+			m_sQueueSample.m_nSampleIndex = SFX_SHAG_SUSPENSION;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 87;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SHAG_SUSPENSION);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 3);
+			m_sQueueSample.m_nPriority = 5;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_HYDRAULIC_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_HYDRAULIC_MAX_DIST);
+			Vol = m_anRandomTable[1] % 15 + VEHICLE_ONE_SHOT_CAR_HYDRAULIC_VOLUME;
 			break;
-		}
 		case SOUND_CAR_HYDRAULIC_1:
-		case SOUND_CAR_HYDRAULIC_2: {
-			const float SOUND_INTENSITY = 35.0f;
+		case SOUND_CAR_HYDRAULIC_2:
 			if (event == SOUND_CAR_HYDRAULIC_1)
 				m_sQueueSample.m_nFrequency = 15600;
 			else
@@ -3115,164 +3340,119 @@ cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 			m_sQueueSample.m_nSampleIndex = SFX_SUSPENSION_FAST_MOVE;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nCounter = 51;
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 8);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 3);
 			m_sQueueSample.m_nPriority = 5;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[0] % 15 + 55;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_HYDRAULIC_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_HYDRAULIC_MAX_DIST);
+			Vol = m_anRandomTable[0] % 15 + VEHICLE_ONE_SHOT_CAR_HYDRAULIC_VOLUME;
 			break;
-		}
-		case SOUND_CAR_HYDRAULIC_3: {
-			const float SOUND_INTENSITY = 35.0f;
+		case SOUND_CAR_HYDRAULIC_3:
 			m_sQueueSample.m_nSampleIndex = SFX_SUSPENSION_SLOW_MOVE_LOOP;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nCounter = 86;
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SUSPENSION_SLOW_MOVE_LOOP);
 			m_sQueueSample.m_nPriority = 5;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_HYDRAULIC_MAX_DIST;
 			m_sQueueSample.m_nFramesToPlay = 7;
-			noReflections = TRUE;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[0] % 15 + 55;
+			bLoop = TRUE;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_HYDRAULIC_MAX_DIST);
+			Vol = m_anRandomTable[0] % 15 + VEHICLE_ONE_SHOT_CAR_HYDRAULIC_VOLUME;
 			break;
-		}
-		case SOUND_CAR_JERK: {
-			const float SOUND_INTENSITY = 35.0f;
-			m_sQueueSample.m_nSampleIndex = SFX_SHAG_SUSPENSION;
+		case SOUND_WATER_FALL:
+			if (m_FrameCounter <= WaterFallFrame)
+				continue;
+			WaterFallFrame = m_FrameCounter + 6;
+			m_sQueueSample.m_nSampleIndex = SFX_SPLASH_1;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 87;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SHAG_SUSPENSION);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 8);
-			m_sQueueSample.m_nPriority = 5;
+			m_sQueueSample.m_nCounter = 15;
+			m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 16000;
+			m_sQueueSample.m_nPriority = 1;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[1] % 15 + 55;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_WATER_FALL_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_WATER_FALL_MAX_DIST);
+			SET_SOUND_REFLECTION(TRUE);
+			Vol = m_anRandomTable[4] % 20 + VEHICLE_ONE_SHOT_WATER_FALL_VOLUME;
 			break;
-		}
-		case SOUND_CAR_SPLASH: {
-			const float SOUND_INTENSITY = 60.0f;
-			static uint8 WaveIndex = 41;
-			vol = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
-			if (vol <= 150.0f)
+		case SOUND_CAR_BOMB_TICK:
+			m_sQueueSample.m_nSampleIndex = SFX_BOMB_BEEP;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 80;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BOMB_BEEP);
+			m_sQueueSample.m_nPriority = 3;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_BOMB_TICK_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_BOMB_TICK_MAX_DIST);
+			SET_SOUND_REFLECTION(TRUE);
+			Vol = VEHICLE_ONE_SHOT_CAR_BOMB_TICK_VOLUME;
+			break;
+		case SOUND_CAR_SPLASH:
+			eventVol = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
+			if (eventVol <= 150)
 				continue;
-			if (vol > 800.0f)
-				m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] = 800.0f;
-			relVol = (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] - 150.0f) / 650.0f;
+			if (eventVol > 800)
+				m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] = 800;
+			eventRelVol = (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] - 150) / (800 - 150);
 			m_sQueueSample.m_nSampleIndex = (m_anRandomTable[0] & 1) + SFX_BOAT_SPLASH_1;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nCounter = WaveIndex++;
 			if (WaveIndex > 46)
 				WaveIndex = 41;
-			m_sQueueSample.m_nFrequency = (7000.0f * relVol) + 6000;
+			m_sQueueSample.m_nFrequency = (7000 * eventRelVol) + 6000;
 			m_sQueueSample.m_nPriority = 3;
 			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			emittingVol = (35.0f * relVol);
-			maxDist = SQR(SOUND_INTENSITY);
-			break;
-		}
-		/*case SOUND_17: {
-			const float SOUND_INTENSITY = 50.0f;
-			m_sQueueSample.m_nSampleIndex = SFX_POLICE_BOAT_THUMB_OFF;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 47;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_POLICE_BOAT_THUMB_OFF) + RandomDisplacement(600);
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_fSoundIntensity = SOUND_INTENSITY;
-			emittingVol = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
-			maxDist = SQR(SOUND_INTENSITY);
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_SPLASH_MAX_DIST;
+			Vol = (VEHICLE_ONE_SHOT_CAR_SPLASH_VOLUME * eventRelVol);
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_SPLASH_MAX_DIST);
 			break;
-		}*/
-#ifdef GTA_TRAIN
-		case SOUND_TRAIN_DOOR_CLOSE:
-		case SOUND_TRAIN_DOOR_OPEN: {
-			const float SOUND_INTENSITY = 35.0f;
-			m_sQueueSample.m_nSampleIndex = SFX_AIR_BRAKES;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 59;
-			m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 11025;
-			m_sQueueSample.m_nPriority = 5;
-			m_sQueueSample.m_fSpeedMultiplier = 5.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[1] % 20 + 70;
-			break;
-		}
+		case SOUND_CAR_JUMP: 
+		case SOUND_CAR_JUMP_2:
+		{
+			static uint8 iWheelIndex = 82;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_JUMP_MAX_DIST);
+#ifdef THIS_IS_STUPID
+			if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i] == SOUND_CAR_JUMP_2) {
+#else
+			if (event == SOUND_CAR_JUMP_2) {
 #endif
-		case SOUND_CAR_TANK_TURRET_ROTATE: {
-			const float SOUND_INTENSITY = 40.0f;
-			vol = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
-			if (vol > 24.0f / 625.0f)
-				vol = 24.0f / 625.0f;
-			m_sQueueSample.m_nSampleIndex = SFX_TANK_TURRET;
+				m_sQueueSample.m_nSampleIndex = SFX_TYRE_BURST_B;
+				Vol = Max(50, 2 * (60 * m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]));
+			} else {
+				m_sQueueSample.m_nSampleIndex = SFX_TYRE_BUMP;
+				Vol = Max(VEHICLE_ONE_SHOT_CAR_JUMP_VOLUME, 2 * (100 * m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]));
+			}
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 79;
-			m_sQueueSample.m_nFrequency = (3000.0f * vol * 625.0f / 24.0f) + 9000;
-			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_nCounter = iWheelIndex++;
+			if (iWheelIndex > 85)
+				iWheelIndex = 82;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TYRE_BUMP);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
+			if (params.m_VehicleType == VEHICLE_TYPE_BIKE)
+				m_sQueueSample.m_nFrequency <<= 1;
+			m_sQueueSample.m_nPriority = 6;
 			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_nFramesToPlay = 3;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			emittingVol = (37.0f * vol * 625.0f / 24.0f) + 90;
-			maxDist = SQR(SOUND_INTENSITY);
-			noReflections = TRUE;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_JUMP_MAX_DIST;
 			break;
 		}
-		case SOUND_CAR_BOMB_TICK: {
-			const float SOUND_INTENSITY = 30.0f;
-			m_sQueueSample.m_nSampleIndex = SFX_BOMB_BEEP;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 80;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BOMB_BEEP);
-			m_sQueueSample.m_nPriority = 3;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			SET_SOUND_REFLECTION(TRUE);
-			emittingVol = 60;
-			break;
-		}
-		case SOUND_PLANE_ON_GROUND: {
-			const float SOUND_INTENSITY = 180.0f;
-			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_LAND_WHEELS;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 81;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_JUMBO_LAND_WHEELS);
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[4] % 25 + 75;
-			break;
-		}
-		case SOUND_HELI_BLADE:{
-			const float SOUND_INTENSITY = 35.0f;
-			static uint8 HeliIndex = 89;
-			relVol = ((CAutomobile*)params.m_pVehicle)->m_aWheelSpeed[1] * 50.0f / 11.0f;
-			if (relVol < 0.2f || relVol == 1.0f)
-				continue;
-			emittingVol = (1.0f - relVol) * 70.0f;
-			maxDist = SQR(SOUND_INTENSITY);
-			m_sQueueSample.m_nSampleIndex = SFX_CAR_HELI_ROT;
+		case SOUND_CAR_TYRE_POP:
+		{
+			static uint8 WheelIndex = 91;
+			m_sQueueSample.m_nSampleIndex = SFX_TYRE_BURST;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = HeliIndex++;
-			if (HeliIndex > 90)
-				HeliIndex = 89;
-			m_sQueueSample.m_nFrequency = (8000.0f * relVol) + 16000;
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+			m_sQueueSample.m_nCounter = WheelIndex++;
+			if (WheelIndex > 94)
+				WheelIndex = 91;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TYRE_BURST);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(2000);
 			m_sQueueSample.m_nPriority = 2;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_TYRE_POP_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_TYRE_POP_MAX_DIST);
+			Vol = m_anRandomTable[4] % (MAX_VOLUME-VEHICLE_ONE_SHOT_CAR_TYRE_POP_VOLUME) + VEHICLE_ONE_SHOT_CAR_TYRE_POP_VOLUME;
 			break;
 		}
-		case SOUND_WEAPON_SHOT_FIRED: {
-			const float SOUND_INTENSITY = 120.0f;
-			CVehicle *playerVeh;
-			CPlayerPed *playerPed;
-
+		case SOUND_WEAPON_SHOT_FIRED:
 			switch (params.m_pVehicle->m_modelIndex) {
 			case MI_HUNTER:
 			case MI_CHOPPER:
@@ -3282,13 +3462,7 @@ cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 			case MI_VCNMAV:
 				if (params.m_pVehicle->m_modelIndex == MI_HUNTER) {
 					if (Pads[0].GetHandBrake() == 0) {
-						playerVeh = FindPlayerVehicle();
-						playerPed = FindPlayerPed();
-						if (playerVeh == nil && playerPed != nil) {
-							if (playerPed->m_attachedTo != nil && playerPed->m_attachedTo->GetType() == ENTITY_TYPE_VEHICLE)
-								playerVeh = (CVehicle*)playerPed->m_attachedTo;
-						}
-						if (playerVeh != params.m_pVehicle) {
+						if (FindVehicleOfPlayer() != params.m_pVehicle) {
 							m_sQueueSample.m_nSampleIndex = SFX_M60_LEFT;
 							m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 						} else {
@@ -3303,32 +3477,32 @@ cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 					m_sQueueSample.m_nSampleIndex = SFX_M60_LEFT;
 					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				}
-				maxDist = SQR(SOUND_INTENSITY);
+				maxDist = SQR(VEHICLE_ONE_SHOT_WEAPON_SHOT_FIRED_MAX_DIST);
 				m_sQueueSample.m_nCounter = GunIndex++;
-				emittingVol = MAX_VOLUME;
+				Vol = MAX_VOLUME;
 				if (GunIndex > 58)
 					GunIndex = 53;
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_M60_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 				m_sQueueSample.m_nPriority = 2;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+				m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_WEAPON_SHOT_FIRED_MAX_DIST;
 				SET_SOUND_REFLECTION(TRUE);
 				stereo = TRUE;
 				break;
 			default:
 			{
-				maxDist = SQR(SOUND_INTENSITY);
+				maxDist = SQR(VEHICLE_ONE_SHOT_WEAPON_SHOT_FIRED_MAX_DIST);
 #ifdef FIX_BUGS
-				int32 sampleIndex;
-				int32 frequency;
+				uint32 sampleIndex;
+				uint32 frequency;
 				CPed *pPed = params.m_pVehicle->pDriver;
 				if(!pPed)
 					continue;
 				if(!pPed->HasWeaponSlot(WEAPONSLOT_SUBMACHINEGUN) || (params.m_pVehicle->GetModelIndex() == MI_PREDATOR && !pPed->IsPedDoingDriveByShooting())) {
 					sampleIndex = SFX_UZI_LEFT;
 					frequency = SampleManager.GetSampleBaseFrequency(sampleIndex);
-					frequency += RandomDisplacement(frequency / 32);
+					frequency += RandomDisplacement(frequency >> 5);
 				} else
 					switch(pPed->GetWeapon(WEAPONSLOT_SUBMACHINEGUN).m_eWeaponType) {
 					case WEAPONTYPE_TEC9:
@@ -3342,12 +3516,12 @@ cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 					case WEAPONTYPE_MP5:
 						sampleIndex = SFX_MP5_LEFT;
 						frequency = SampleManager.GetSampleBaseFrequency(sampleIndex);
-						frequency += RandomDisplacement(frequency / 32);
+						frequency += RandomDisplacement(frequency >> 5);
 						break;
 					default:
 						sampleIndex = SFX_UZI_LEFT;
 						frequency = SampleManager.GetSampleBaseFrequency(sampleIndex);
-						frequency += RandomDisplacement(frequency / 32);
+						frequency += RandomDisplacement(frequency >> 5);
 						break;
 					}
 				m_sQueueSample.m_nSampleIndex = sampleIndex;
@@ -3356,96 +3530,38 @@ cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 #endif
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = GunIndex++;
-				emittingVol = m_anRandomTable[2] % 15 + 65;
+				Vol = m_anRandomTable[2] % 15 + VEHICLE_ONE_SHOT_WEAPON_SHOT_FIRED_VOLUME;
 				if(GunIndex > 58) GunIndex = 53;
 #ifdef FIX_BUGS
 				m_sQueueSample.m_nFrequency = frequency;
 #else
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_UZI_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 #endif
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+				m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_WEAPON_SHOT_FIRED_MAX_DIST;
 				SET_SOUND_REFLECTION(TRUE);
 				break;
 			}
 			}
 			break;
-		}
-		case SOUND_WEAPON_HIT_VEHICLE: {
-			const float SOUND_INTENSITY = 40.0f;
-			m_sQueueSample.m_nSampleIndex = m_anRandomTable[m_sQueueSample.m_nEntityIndex % ARRAY_SIZE(m_anRandomTable)] % 6 + SFX_BULLET_CAR_1;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 34;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
-			m_sQueueSample.m_nPriority = 7;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[3] % 20 + 90;
-			break;
-		}
-		case SOUND_BOMB_TIMED_ACTIVATED:
-		case SOUND_91:
-		case SOUND_BOMB_ONIGNITION_ACTIVATED:
-		case SOUND_BOMB_TICK: {
-			const float SOUND_INTENSITY = 50.0f;
-			m_sQueueSample.m_nSampleIndex = SFX_ARM_BOMB;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 36;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ARM_BOMB);
-			m_sQueueSample.m_nPriority = 0;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			SET_SOUND_REFLECTION(TRUE);
-			emittingVol = 50;
-			maxDist = SQR(SOUND_INTENSITY);
-			break;
-		}
-		case SOUND_PED_HELI_PLAYER_FOUND: {
-			cPedParams pedParams;
-			pedParams.m_bDistanceCalculated = params.m_bDistanceCalculated;
-			pedParams.m_fDistance = params.m_fDistance;
-			SetupPedComments(pedParams, SOUND_PED_HELI_PLAYER_FOUND);
-			continue;
-		}
-		/* case SOUND_PED_BODYCAST_HIT:
-			pedParams.m_pPed = nil;
-			pedParams.m_bDistanceCalculated = FALSE;
-			pedParams.m_fDistance = 0.0f;
-			pedParams.m_bDistanceCalculated = params.m_bDistanceCalculated;
-			pedParams.m_fDistance = params.m_fDistance;
-			SetupPedComments(&pedParams, SOUND_PED_BODYCAST_HIT);
-			continue; */
-		case SOUND_PED_VCPA_PLAYER_FOUND: {
-			cPedParams pedParams;
-			pedParams.m_bDistanceCalculated = params.m_bDistanceCalculated;
-			pedParams.m_fDistance = params.m_fDistance;
-			SetupPedComments(pedParams, SOUND_PED_VCPA_PLAYER_FOUND);
-			continue;
-		}
-		case SOUND_WATER_FALL: {
-			const float SOUND_INTENSITY = 40.0f;
-			static uint32 WaterFallFrame = 0;
-			if (m_FrameCounter <= WaterFallFrame)
-				continue;
-			WaterFallFrame = m_FrameCounter + 6;
-			m_sQueueSample.m_nSampleIndex = SFX_SPLASH_1;
+#ifdef GTA_TRAIN
+		case SOUND_TRAIN_DOOR_CLOSE:
+		case SOUND_TRAIN_DOOR_OPEN:
+			m_sQueueSample.m_nSampleIndex = SFX_AIR_BRAKES;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 15;
-			m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 16000;
-			m_sQueueSample.m_nPriority = 1;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
-			SET_SOUND_REFLECTION(TRUE);
-			emittingVol = m_anRandomTable[4] % 20 + 90;
+			m_sQueueSample.m_nCounter = 59;
+			m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 11025;
+			m_sQueueSample.m_nPriority = 5;
+			m_sQueueSample.m_fSpeedMultiplier = 5.0f;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_TRAIN_DOOR_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_TRAIN_DOOR_MAX_DIST);
+			Vol = m_anRandomTable[1] % 20 + VEHICLE_ONE_SHOT_TRAIN_DOOR_VOLUME;
 			break;
-		}
-		case SOUND_SPLATTER: {
-			const float SOUND_INTENSITY = 40.0f;
+#endif
+		case SOUND_SPLATTER:
+		{
 			static uint8 CrunchOffset = 0;
 			m_sQueueSample.m_nSampleIndex = CrunchOffset + SFX_PED_CRUNCH_1;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
@@ -3453,40 +3569,64 @@ cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 			m_sQueueSample.m_nFrequency = RandomDisplacement(6000) + 16000;
 			m_sQueueSample.m_nPriority = 1;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_SPLATTER_MAX_DIST;
 			CrunchOffset++;
-			maxDist = SQR(SOUND_INTENSITY);
-			emittingVol = m_anRandomTable[4] % 20 + 55;
+			maxDist = SQR(VEHICLE_ONE_SHOT_SPLATTER_MAX_DIST);
+			Vol = m_anRandomTable[4] % 20 + VEHICLE_ONE_SHOT_SPLATTER_VOLUME;
 			CrunchOffset %= 2;
 			SET_SOUND_REFLECTION(TRUE);
 			break;
 		}
-		case SOUND_CAR_PED_COLLISION: {
-			const float SOUND_INTENSITY = 40.0f;
-			vol = Min(20.0f, m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]);
-			emittingVol = Min(127, (3 * (vol / 20.0f * 127.f)) / 2);
-			if (emittingVol == 0)
+		case SOUND_CAR_PED_COLLISION:
+			eventVol = Min(20.0f, m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]);
+			Vol = Min(MAX_VOLUME, (3 * (eventVol / 20 * MAX_VOLUME)) / 2);
+			if (Vol == 0)
 				continue;
 
 			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_1;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nCounter = 50;
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 			m_sQueueSample.m_nPriority = 1;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-			maxDist = SQR(SOUND_INTENSITY);
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_PED_COLLISION_MAX_DIST;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_PED_COLLISION_MAX_DIST);
+			break;
+		case SOUND_PED_HELI_PLAYER_FOUND:
+			pedParams.m_bDistanceCalculated = params.m_bDistanceCalculated;
+			pedParams.m_fDistance = params.m_fDistance;
+			SetupPedComments(pedParams, SOUND_PED_HELI_PLAYER_FOUND);
+			continue;
+		case SOUND_PED_VCPA_PLAYER_FOUND:
+			pedParams.m_bDistanceCalculated = params.m_bDistanceCalculated;
+			pedParams.m_fDistance = params.m_fDistance;
+			SetupPedComments(pedParams, SOUND_PED_VCPA_PLAYER_FOUND);
+			continue;
+		case SOUND_CAR_TANK_TURRET_ROTATE:
+			eventVol = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
+			if (eventVol > 96.0f / 2500.0f)
+				eventVol = 96.0f / 2500.0f;
+			m_sQueueSample.m_nSampleIndex = SFX_TANK_TURRET;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 79;
+			m_sQueueSample.m_nFrequency = (3000 * eventVol / (96.0f / 2500.0f)) + 9000;
+			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+			m_sQueueSample.m_nFramesToPlay = 3;
+			m_sQueueSample.m_MaxDistance = VEHICLE_ONE_SHOT_CAR_TANK_TURRET_MAX_DIST;
+			Vol = (37 * eventVol / (96.0f / 2500.0f)) + VEHICLE_ONE_SHOT_CAR_TANK_TURRET_VOLUME;
+			maxDist = SQR(VEHICLE_ONE_SHOT_CAR_TANK_TURRET_MAX_DIST);
+			bLoop = TRUE;
 			break;
-		}
 		default:
 			continue;
 		}
 		if (params.m_fDistance < maxDist) {
 			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
 			if (m_sQueueSample.m_nVolume > 0) {
-				if (noReflections) {
+				if (bLoop) {
 					m_sQueueSample.m_nLoopCount = 0;
 					m_sQueueSample.m_bStatic = FALSE;
 				} else {
@@ -3494,7 +3634,7 @@ cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 					m_sQueueSample.m_bStatic = TRUE;
 				}
 				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-				SET_EMITTING_VOLUME(emittingVol);
+				SET_EMITTING_VOLUME(Vol);
 				SET_SOUND_REVERB(TRUE);
 				if (stereo) {
 					if(m_sQueueSample.m_fDistance < 0.2f * m_sQueueSample.m_MaxDistance) {
@@ -3526,65 +3666,64 @@ cAudioManager::ProcessVehicleOneShots(cVehicleParams& params)
 bool8
 cAudioManager::ProcessTrainNoise(cVehicleParams& params)
 {
-	const float SOUND_INTENSITY = 140.0f;
-
 	CTrain *train;
-	uint8 emittingVol;
+	uint8 Vol;
 	float speedMultipler;
 
-	if (params.m_fDistance >= SQR(SOUND_INTENSITY))
-		return FALSE;
-
-	if (params.m_fVelocityChange > 0.0f) {
-		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-		train = (CTrain *)params.m_pVehicle;
-		speedMultipler = Min(1.0f, train->m_fSpeed * 250.f / 51.f);
-		emittingVol = (70.f * speedMultipler);
-		if (train->m_fWagonPosition == 0.0f) {
-			m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-			if (m_sQueueSample.m_nVolume > 0) {
-				m_sQueueSample.m_nCounter = 32;
-				m_sQueueSample.m_nSampleIndex = SFX_TRAIN;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_bIs2D = FALSE;
-				m_sQueueSample.m_nPriority = 2;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TRAIN);
-				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(emittingVol);
-				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-				m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-				m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-				m_sQueueSample.m_bStatic = FALSE;
-				m_sQueueSample.m_nFramesToPlay = 3;
-				SET_SOUND_REVERB(TRUE);
-				SET_SOUND_REFLECTION(FALSE);
-				AddSampleToRequestedQueue();
+	if (params.m_fDistance < SQR(TRAIN_NOISE_FAR_MAX_DIST)){
+		if (params.m_fVelocityChange > 0.0f) {
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			train = (CTrain *)params.m_pVehicle;
+			speedMultipler = Min(1.0f, train->m_fSpeed * 250.0f / 51.0f);
+			Vol = (TRAIN_NOISE_VOLUME * speedMultipler);
+			if (train->m_fWagonPosition == 0.0f) {
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, TRAIN_NOISE_FAR_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
+					m_sQueueSample.m_nCounter = 32;
+					m_sQueueSample.m_nSampleIndex = SFX_TRAIN;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 2;
+					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TRAIN);
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(Vol);
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+					m_sQueueSample.m_MaxDistance = TRAIN_NOISE_FAR_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
+					m_sQueueSample.m_nFramesToPlay = 3;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
+				}
 			}
+			/*
+			if (params.m_fDistance < SQR(TRAIN_NOISE_NEAR_MAX_DIST)) {
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, TRAIN_NOISE_NEAR_MAX_DIST, m_sQueueSample.m_fDistance);
+				if (m_sQueueSample.m_nVolume > 0) {
+					m_sQueueSample.m_nCounter = 33;
+					m_sQueueSample.m_nSampleIndex = SFX_TRAIN_NEAR;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_nPriority = 5;
+					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TRAIN_NEAR) + 100 * m_sQueueSample.m_nEntityIndex % 987;
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_EMITTING_VOLUME(Vol);
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					m_sQueueSample.m_fSpeedMultiplier = 6.0f;
+					m_sQueueSample.m_MaxDistance = TRAIN_NOISE_NEAR_MAX_DIST;
+					m_sQueueSample.m_bStatic = FALSE;
+					m_sQueueSample.m_nFramesToPlay = 3;
+					SET_SOUND_REVERB(TRUE);
+					SET_SOUND_REFLECTION(FALSE);
+					AddSampleToRequestedQueue();
+				}
+			}
+			*/
 		}
-		//const float SOUND_INTENSITY = 70.0f;
-		//if (params.m_fDistance < SQR(SOUND_INTENSITY)) {
-		//	m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-		//	if (m_sQueueSample.m_nVolume > 0) {
-		//		m_sQueueSample.m_nCounter = 33;
-		//		m_sQueueSample.m_nSampleIndex = SFX_TRAIN_NEAR;
-		//		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		//		m_sQueueSample.m_bIs2D = FALSE;
-		//		m_sQueueSample.m_nPriority = 5;
-		//		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TRAIN_NEAR) + 100 * m_sQueueSample.m_nEntityIndex % 987;
-		//		m_sQueueSample.m_nLoopCount = 0;
-		//		SET_EMITTING_VOLUME(emittingVol);
-		//		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		//		m_sQueueSample.m_fSpeedMultiplier = 6.0f;
-		//		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		//		m_sQueueSample.m_bStatic = FALSE;
-		//		m_sQueueSample.m_nFramesToPlay = 3;
-		//		SET_SOUND_REVERB(TRUE);
-		//		SET_SOUND_REFLECTION(FALSE);
-		//		AddSampleToRequestedQueue();
-		//	}
-		//}
-	}
-	return TRUE;
+		return TRUE;
+	}
+	return FALSE;
 }
 #endif
 bool8
@@ -3594,25 +3733,23 @@ cAudioManager::ProcessBoatEngine(cVehicleParams& params)
 	float padRelativeAccerate;
 
 	bool8 isV12 = FALSE;
-	static int32 LastFreq = 2000;
-	static int8 LastVol = 0;
-
-	static const float intensity = 90.0f;
+	static uint32 LastFreq = 2000;
+	static uint8 LastVol = 0;
 
-	if (params.m_fDistance < SQR(intensity)) {
+	if (params.m_fDistance < SQR(BOAT_ENGINE_MAX_DIST)) {
 		boat = (CBoat *)params.m_pVehicle;
 		if(boat->GetStatus() == STATUS_WRECKED)
 			return TRUE;
 
 		float freqModificator;
 		float volModificator;
-		int BaseVol;
-		int BaseFreq;
+		uint8 BaseVol;
+		uint32 BaseFreq;
 
 		switch(boat->GetModelIndex()) {
 		case MI_RIO:
-			freqModificator = 490.0f;
-			volModificator = 60.0f;
+			freqModificator = 490;
+			volModificator = 60;
 			BaseVol = 20;
 			BaseFreq = 1888;
 			break;
@@ -3622,22 +3759,22 @@ cAudioManager::ProcessBoatEngine(cVehicleParams& params)
 		case MI_COASTG:
 		case MI_DINGHY:
 		case MI_JETMAX:
-			freqModificator = 6000.0f;
-			volModificator = 60.0f;
+			freqModificator = 6000;
+			volModificator = 60;
 			isV12 = TRUE;
 			BaseFreq = 9000;
 			BaseVol = 20;
 			break;
 		case MI_REEFER:
-			freqModificator = 715.0f;
-			volModificator = 80.0f;
+			freqModificator = 715;
+			volModificator = 80;
 			BaseVol = 0;
 			BaseFreq = 3775;
 			break;
 		case MI_TROPIC:
 		case MI_MARQUIS:
-			freqModificator = 463.0f;
-			volModificator = 60.0f;
+			freqModificator = 463;
+			volModificator = 60;
 			BaseVol = 20;
 			BaseFreq = 1782;
 			break;
@@ -3648,16 +3785,15 @@ cAudioManager::ProcessBoatEngine(cVehicleParams& params)
 		bool8 bIsPlayerVeh;
 
 		if(FindPlayerVehicle() == params.m_pVehicle) {
-			float padAccelerate = Max(Pads[0].GetAccelerate(), Pads[0].GetBrake());
-			padRelativeAccerate = padAccelerate / 255.0f;
+			padRelativeAccerate = Max(Pads[0].GetAccelerate(), Pads[0].GetBrake()) / 255.0f;
 			bIsPlayerVeh = TRUE;
 		} else {
 			padRelativeAccerate = Max(params.m_pVehicle->m_fGasPedal, params.m_pVehicle->m_fBrakePedal);
 			bIsPlayerVeh = FALSE;
 		}
 
-		int Freq = BaseFreq + (padRelativeAccerate * freqModificator);
-		int Vol = BaseVol + (padRelativeAccerate * volModificator);
+		uint32 Freq = BaseFreq + (padRelativeAccerate * freqModificator);
+		uint8 Vol = BaseVol + (padRelativeAccerate * volModificator);
 
 		if(!boat->bPropellerInWater)
 			Freq = (9 * Freq) / 8;
@@ -3682,7 +3818,7 @@ cAudioManager::ProcessBoatEngine(cVehicleParams& params)
 
 		if (Vol > 0) {
 			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(Vol, intensity, m_sQueueSample.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, BOAT_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
 			if (m_sQueueSample.m_nVolume > 0) {
 				m_sQueueSample.m_nFrequency = Freq;
 				m_sQueueSample.m_nCounter = 40;
@@ -3697,7 +3833,7 @@ cAudioManager::ProcessBoatEngine(cVehicleParams& params)
 				SET_EMITTING_VOLUME(Vol);
 				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 				m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-				m_sQueueSample.m_MaxDistance = intensity;
+				m_sQueueSample.m_MaxDistance = BOAT_ENGINE_MAX_DIST;
 				m_sQueueSample.m_bStatic = FALSE;
 				m_sQueueSample.m_nFramesToPlay = 7;
 				SET_SOUND_REVERB(TRUE);
@@ -3708,7 +3844,7 @@ cAudioManager::ProcessBoatEngine(cVehicleParams& params)
 
 		if(boat->GetModelIndex() == MI_REEFER) {
 			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(80, intensity, m_sQueueSample.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(BOAT_ENGINE_REEFER_IDLE_VOLUME, BOAT_ENGINE_MAX_DIST, m_sQueueSample.m_fDistance);
 			if (m_sQueueSample.m_nVolume > 0) {
 				m_sQueueSample.m_nFrequency = 6000;
 				m_sQueueSample.m_nCounter = 39;
@@ -3718,10 +3854,10 @@ cAudioManager::ProcessBoatEngine(cVehicleParams& params)
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(80);
+				SET_EMITTING_VOLUME(BOAT_ENGINE_REEFER_IDLE_VOLUME);
 				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 				m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-				m_sQueueSample.m_MaxDistance = intensity;
+				m_sQueueSample.m_MaxDistance = BOAT_ENGINE_MAX_DIST;
 				m_sQueueSample.m_bStatic = FALSE;
 				m_sQueueSample.m_nFramesToPlay = 7;
 				SET_SOUND_REVERB(TRUE);
@@ -3742,41 +3878,39 @@ bool8
 cAudioManager::ProcessBoatMovingOverWater(cVehicleParams& params)
 {
 	float velocityChange;
-	int32 vol;
+	uint8 Vol;
 	float multiplier;
 
-	if (params.m_fDistance > SQR(50))
-		return FALSE;
-
-	velocityChange = Abs(params.m_fVelocityChange);
-	if (velocityChange <= 0.0005f && ((CBoat*)params.m_pVehicle)->bBoatInWater)
+	if (params.m_fDistance < SQR(BOAT_MOVING_OVER_WATER_MAX_DIST)) {
+		velocityChange = Abs(params.m_fVelocityChange);
+		if (velocityChange > 0.0005f && ((CBoat*)params.m_pVehicle)->bBoatInWater) {
+			velocityChange = Min(0.75f, velocityChange);
+			multiplier = (velocityChange - 0.0005f) / (1499.0f / 2000.0f);
+			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+			Vol = (BOAT_MOVING_OVER_WATER_VOLUME * multiplier);
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, BOAT_MOVING_OVER_WATER_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = 38;
+				m_sQueueSample.m_nSampleIndex = SFX_BOAT_WATER_LOOP;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nPriority = 3;
+				m_sQueueSample.m_nFrequency = (6050 * multiplier) + 16000;
+				m_sQueueSample.m_nLoopCount = 0;
+				SET_EMITTING_VOLUME(Vol);
+				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+				m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+				m_sQueueSample.m_MaxDistance = BOAT_MOVING_OVER_WATER_MAX_DIST;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 6;
+				SET_SOUND_REVERB(TRUE);
+				SET_SOUND_REFLECTION(FALSE);
+				AddSampleToRequestedQueue();
+			}
+		}
 		return TRUE;
-
-	velocityChange = Min(0.75f, velocityChange);
-	multiplier = (velocityChange - 0.0005f) / (1499.0f / 2000.0f);
-	CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-	vol = (30.f * multiplier);
-	m_sQueueSample.m_nVolume = ComputeVolume(vol, 50.f, m_sQueueSample.m_fDistance);
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 38;
-		m_sQueueSample.m_nSampleIndex = SFX_BOAT_WATER_LOOP;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 3;
-		m_sQueueSample.m_nFrequency = (6050.f * multiplier) + 16000;
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(vol);
-		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-		m_sQueueSample.m_MaxDistance = 50.0f;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 6;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
 	}
-
-	return TRUE;
+	return FALSE;
 }
 
 void
@@ -3810,29 +3944,33 @@ cAudioManager::ProcessJumbo(cVehicleParams& params)
 	CPlane *plane;
 	float position;
 
-	 if (params.m_fDistance >= SQR(440))
-		return;
-
-	CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-	plane = (CPlane*)params.m_pVehicle;
-	DoJumboVolOffset();
-	position = PlanePathPosition[plane->m_nPlaneId];
-	if (position <= TakeOffPoint) {
-		if (plane->m_fSpeed > 0.103344f) {
-			ProcessJumboAccel(plane);
+	if (params.m_fDistance < SQR(JUMBO_MAX_DIST)) {
+		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
+		plane = (CPlane*)params.m_pVehicle;
+		DoJumboVolOffset();
+		position = PlanePathPosition[plane->m_nPlaneId];
+		if (position > TakeOffPoint) {
+			if (300.0f + TakeOffPoint < position) {
+				if (LandingPoint - 350.0f < position) {
+					if (position > LandingPoint) {
+						if (plane->m_fSpeed > 0.103344f)
+							ProcessJumboDecel(plane);
+						else
+							ProcessJumboTaxi();
+					}
+					else
+						ProcessJumboLanding(plane);
+				}
+				else
+					ProcessJumboFlying();
+			} else
+				ProcessJumboTakeOff(plane);
 		} else {
-			ProcessJumboTaxi();
+			if (plane->m_fSpeed > 0.103344f)
+				ProcessJumboAccel(plane);
+			else
+				ProcessJumboTaxi();
 		}
-	} else if (position <= TakeOffPoint + 300.0f) {
-		ProcessJumboTakeOff(plane);
-	} else if (position <= LandingPoint - 350.0f) {
-		ProcessJumboFlying();
-	} else if (position <= LandingPoint) {
-		ProcessJumboLanding(plane);
-	} else if (plane->m_fSpeed > 0.103344f) {
-		ProcessJumboDecel(plane);
-	} else {
-		ProcessJumboTaxi();
 	}
 }
 
@@ -3848,25 +3986,25 @@ cAudioManager::ProcessJumboTaxi()
 void
 cAudioManager::ProcessJumboAccel(CPlane *plane)
 {
-	int32 engineFreq;
-	int32 vol;
+	uint32 engineFreq;
+	uint8 vol;
 	float modificator;
-	float freqModifier;
+	float freqMult;
 
 	if (SetupJumboFlySound(20)) {
 		modificator = Min(1.0f, (plane->m_fSpeed - 0.103344f) * 1.6760077f);
-		if (SetupJumboRumbleSound(MAX_VOLUME * modificator) && SetupJumboTaxiSound((1.0f - modificator) * 75.f)) {
-			if (modificator < 0.2f) {
-				freqModifier = modificator * 5.0f;
-				vol = MAX_VOLUME * freqModifier;
-				engineFreq = 6050.0f * freqModifier + 16000;
-			} else {
-				freqModifier = 1.0f;
+		if (SetupJumboRumbleSound(MAX_VOLUME * modificator) && SetupJumboTaxiSound((1.0f - modificator) * 75)) {
+			if (modificator >= 0.2f) {
+				freqMult = 1;
 				engineFreq = 22050;
 				vol = MAX_VOLUME;
+			} else {
+				freqMult = modificator * 5;
+				vol = freqMult * MAX_VOLUME;
+				engineFreq = freqMult * 6050 + 16000;
 			}
 			SetupJumboEngineSound(vol, engineFreq);
-			SetupJumboWhineSound(18, 14600.0f * freqModifier + 29500);
+			SetupJumboWhineSound(18, 14600 * freqMult + 29500);
 		}
 	}
 }
@@ -3874,11 +4012,10 @@ cAudioManager::ProcessJumboAccel(CPlane *plane)
 void
 cAudioManager::ProcessJumboTakeOff(CPlane *plane)
 {
-	const float modificator = (PlanePathPosition[plane->m_nPlaneId] - TakeOffPoint) / 300.f;
-
-	if (SetupJumboFlySound((107.f * modificator) + 20) && SetupJumboRumbleSound(MAX_VOLUME * (1.f - modificator))) {
+	float modificator = (PlanePathPosition[plane->m_nPlaneId] - TakeOffPoint) / 300;
+	if (SetupJumboFlySound((107 * modificator) + 20) && SetupJumboRumbleSound(MAX_VOLUME * (1.0f - modificator))) {
 		if (SetupJumboEngineSound(MAX_VOLUME, 22050))
-			SetupJumboWhineSound(18.f * (1.f - modificator), 44100);
+			SetupJumboWhineSound(18 * (1.0f - modificator), 44100);
 	}
 }
 
@@ -3892,11 +4029,11 @@ cAudioManager::ProcessJumboFlying()
 void
 cAudioManager::ProcessJumboLanding(CPlane *plane)
 {
-	const float modificator = (LandingPoint - PlanePathPosition[plane->m_nPlaneId]) / 350.f;
-	if (SetupJumboFlySound(107.f * modificator + 20)) {
-		if (SetupJumboTaxiSound(75.f * (1.f - modificator))) {
+	float modificator = (LandingPoint - PlanePathPosition[plane->m_nPlaneId]) / 350;
+	if (SetupJumboFlySound(107 * modificator + 20)) {
+		if (SetupJumboTaxiSound(75 * (1.0f - modificator))) {
 			SetupJumboEngineSound(MAX_VOLUME, 22050);
-			SetupJumboWhineSound(18.f * (1.f - modificator), 14600.f * modificator + 29500);
+			SetupJumboWhineSound(18 * (1.0f - modificator), 14600 * modificator + 29500);
 		}
 	}
 }
@@ -3905,8 +4042,8 @@ void
 cAudioManager::ProcessJumboDecel(CPlane *plane)
 {
 	if (SetupJumboFlySound(20) && SetupJumboTaxiSound(75)) {
-		const float modificator = Min(1.f, (plane->m_fSpeed - 0.103344f) * 1.6760077f);
-		SetupJumboEngineSound(MAX_VOLUME * modificator, 6050.f * modificator + 16000);
+		float modificator = Min(1.0f, (plane->m_fSpeed - 0.103344f) * 1.6760077f);
+		SetupJumboEngineSound(MAX_VOLUME * modificator, 6050* modificator + 16000);
 		SetupJumboWhineSound(18, 29500);
 	}
 }
@@ -3914,167 +4051,159 @@ cAudioManager::ProcessJumboDecel(CPlane *plane)
 bool8
 cAudioManager::SetupJumboTaxiSound(uint8 vol)
 {
-	const float SOUND_INTENSITY = 180.0f;
-	if (m_sQueueSample.m_fDistance >= SOUND_INTENSITY)
-		return FALSE;
-
-	uint8 emittingVol = (vol / 2) + ((vol / 2) * m_sQueueSample.m_fDistance / SOUND_INTENSITY);
+	if (m_sQueueSample.m_fDistance < JUMBO_ENGINE_SOUND_MAX_DIST) {
+		uint8 Vol = (vol >> 1) + ((vol >> 1) * m_sQueueSample.m_fDistance / JUMBO_ENGINE_SOUND_MAX_DIST);
 
-	if (m_sQueueSample.m_fDistance / SOUND_INTENSITY < 0.7f)
-		emittingVol -= emittingVol * gJumboVolOffsetPercentage / 100;
-	m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
+		if (m_sQueueSample.m_fDistance / JUMBO_ENGINE_SOUND_MAX_DIST < 0.7f)
+			Vol -= Vol * gJumboVolOffsetPercentage / 100;
+		m_sQueueSample.m_nVolume = ComputeVolume(Vol, JUMBO_ENGINE_SOUND_MAX_DIST, m_sQueueSample.m_fDistance);
 
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 1;
-		m_sQueueSample.m_nSampleIndex = SFX_JUMBO_TAXI;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 1;
-		m_sQueueSample.m_nFrequency = GetJumboTaxiFreq();
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(emittingVol);
-		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 4;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
+		if (m_sQueueSample.m_nVolume > 0) {
+			m_sQueueSample.m_nCounter = 1;
+			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_TAXI;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_nPriority = 1;
+			m_sQueueSample.m_nFrequency = GetJumboTaxiFreq();
+			m_sQueueSample.m_nLoopCount = 0;
+			SET_EMITTING_VOLUME(Vol);
+			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
+			m_sQueueSample.m_MaxDistance = JUMBO_ENGINE_SOUND_MAX_DIST;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 4;
+			SET_SOUND_REVERB(TRUE);
+			SET_SOUND_REFLECTION(FALSE);
+			AddSampleToRequestedQueue();
+		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
-cAudioManager::SetupJumboWhineSound(uint8 emittingVol, uint32 freq)
+cAudioManager::SetupJumboWhineSound(uint8 Vol, uint32 freq)
 {
-	const float SOUND_INTENSITY = 170.0f;
-
-	if (m_sQueueSample.m_fDistance >= SOUND_INTENSITY)
-		return FALSE;
-
-	m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 2;
-		m_sQueueSample.m_nSampleIndex = SFX_JUMBO_WHINE;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 1;
-		m_sQueueSample.m_nFrequency = freq;
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(emittingVol);
-		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 4;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
+	if (m_sQueueSample.m_fDistance < JUMBO_WHINE_SOUND_MAX_DIST) {
+		m_sQueueSample.m_nVolume = ComputeVolume(Vol, JUMBO_WHINE_SOUND_MAX_DIST, m_sQueueSample.m_fDistance);
+		if (m_sQueueSample.m_nVolume > 0) {
+			m_sQueueSample.m_nCounter = 2;
+			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_WHINE;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_nPriority = 1;
+			m_sQueueSample.m_nFrequency = freq;
+			m_sQueueSample.m_nLoopCount = 0;
+			SET_EMITTING_VOLUME(Vol);
+			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
+			m_sQueueSample.m_MaxDistance = JUMBO_WHINE_SOUND_MAX_DIST;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 4;
+			SET_SOUND_REVERB(TRUE);
+			SET_SOUND_REFLECTION(FALSE);
+			AddSampleToRequestedQueue();
+		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
-cAudioManager::SetupJumboEngineSound(uint8 vol, uint32 freq)
+cAudioManager::SetupJumboEngineSound(uint8 Vol, uint32 freq)
 {
-	const float SOUND_INTENSITY = 180.0f;
-	if (m_sQueueSample.m_fDistance >= SOUND_INTENSITY)
-		return FALSE;
-
-	uint8 emittingVol = vol - gJumboVolOffsetPercentage / 100;
-	m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 3;
-		m_sQueueSample.m_nSampleIndex = SFX_JUMBO_ENGINE;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 1;
-		m_sQueueSample.m_nFrequency = freq;
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(emittingVol);
-		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 4;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
+	if (m_sQueueSample.m_fDistance < JUMBO_ENGINE_SOUND_MAX_DIST) {
+		uint8 FinalVol = Vol - gJumboVolOffsetPercentage / 100;
+		m_sQueueSample.m_nVolume = ComputeVolume(FinalVol, JUMBO_ENGINE_SOUND_MAX_DIST, m_sQueueSample.m_fDistance);
+		if (m_sQueueSample.m_nVolume > 0) {
+			m_sQueueSample.m_nCounter = 3;
+			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_ENGINE;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_nPriority = 1;
+			m_sQueueSample.m_nFrequency = freq;
+			m_sQueueSample.m_nLoopCount = 0;
+			SET_EMITTING_VOLUME(FinalVol);
+			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
+			m_sQueueSample.m_MaxDistance = JUMBO_ENGINE_SOUND_MAX_DIST;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 4;
+			SET_SOUND_REVERB(TRUE);
+			SET_SOUND_REFLECTION(FALSE);
+			AddSampleToRequestedQueue();
+		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
-cAudioManager::SetupJumboFlySound(uint8 emittingVol)
+cAudioManager::SetupJumboFlySound(uint8 Vol)
 {
-	const float SOUND_INTENSITY = 440.0f;
-	if(m_sQueueSample.m_fDistance >= SOUND_INTENSITY) return FALSE;
-
-	int32 vol = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-	m_sQueueSample.m_nVolume = vol;
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 0;
-		m_sQueueSample.m_nSampleIndex = SFX_JUMBO_DIST_FLY;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = FALSE;
-		m_sQueueSample.m_nPriority = 1;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_JUMBO_DIST_FLY);
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(emittingVol);
-		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 5;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
+	if (m_sQueueSample.m_fDistance < JUMBO_MAX_DIST) {
+		m_sQueueSample.m_nVolume = ComputeVolume(Vol, JUMBO_MAX_DIST, m_sQueueSample.m_fDistance);
+		if (m_sQueueSample.m_nVolume > 0) {
+			m_sQueueSample.m_nCounter = 0;
+			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_DIST_FLY;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_nPriority = 1;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_JUMBO_DIST_FLY);
+			m_sQueueSample.m_nLoopCount = 0;
+			SET_EMITTING_VOLUME(Vol);
+			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
+			m_sQueueSample.m_MaxDistance = JUMBO_MAX_DIST;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 5;
+			SET_SOUND_REVERB(TRUE);
+			SET_SOUND_REFLECTION(FALSE);
+			AddSampleToRequestedQueue();
+		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 bool8
-cAudioManager::SetupJumboRumbleSound(uint8 emittingVol)
+cAudioManager::SetupJumboRumbleSound(uint8 Vol)
 {
-	const float SOUND_INTENSITY = 240.0f;
-	if (m_sQueueSample.m_fDistance >= SOUND_INTENSITY)
-		return FALSE;
-
-	m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-
-	if (m_sQueueSample.m_nVolume > 0) {
-		m_sQueueSample.m_nCounter = 5;
-		m_sQueueSample.m_nSampleIndex = SFX_JUMBO_RUMBLE;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_bIs2D = TRUE;
-		m_sQueueSample.m_nPriority = 1;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_JUMBO_RUMBLE);
-		m_sQueueSample.m_nLoopCount = 0;
-		SET_EMITTING_VOLUME(emittingVol);
-		SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-		m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-		m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-		m_sQueueSample.m_bStatic = FALSE;
-		m_sQueueSample.m_nFramesToPlay = 12;
-		m_sQueueSample.m_nPan = 0;
-		SET_SOUND_REVERB(TRUE);
-		SET_SOUND_REFLECTION(FALSE);
-		AddSampleToRequestedQueue();
-		m_sQueueSample.m_nCounter = 6;
-		m_sQueueSample.m_nSampleIndex = SFX_JUMBO_RUMBLE;
-		m_sQueueSample.m_nFrequency += 200;
-		m_sQueueSample.m_nPan = 127;
-		AddSampleToRequestedQueue();
+	if (m_sQueueSample.m_fDistance < JUMBO_RUMBLE_SOUND_MAX_DIST) {
+		m_sQueueSample.m_nVolume = ComputeVolume(Vol, JUMBO_RUMBLE_SOUND_MAX_DIST, m_sQueueSample.m_fDistance);
+		if (m_sQueueSample.m_nVolume > 0) {
+			m_sQueueSample.m_nCounter = 5;
+			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_RUMBLE;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_bIs2D = TRUE;
+			m_sQueueSample.m_nPriority = 1;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_JUMBO_RUMBLE);
+			m_sQueueSample.m_nLoopCount = 0;
+			SET_EMITTING_VOLUME(Vol);
+			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
+			m_sQueueSample.m_MaxDistance = JUMBO_RUMBLE_SOUND_MAX_DIST;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 12;
+			m_sQueueSample.m_nPan = 0;
+			SET_SOUND_REVERB(TRUE);
+			SET_SOUND_REFLECTION(FALSE);
+			AddSampleToRequestedQueue();
+			m_sQueueSample.m_nCounter = 6;
+			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_RUMBLE;
+			m_sQueueSample.m_nFrequency += 200;
+			m_sQueueSample.m_nPan = 127;
+			AddSampleToRequestedQueue();
+		}
+		return TRUE;
 	}
-	return TRUE;
+	return FALSE;
 }
 
 int32
 cAudioManager::GetJumboTaxiFreq()
 {
-	return (1.f / 180 * 10950 * m_sQueueSample.m_fDistance) + 22050; // todo port fix to re3
+	return (1.0f / 180 * 10950 * m_sQueueSample.m_fDistance) + 22050; // todo port fix to re3
 }
 
 #pragma endregion Some jumbo crap
@@ -4115,8 +4244,8 @@ cAudioManager::ProcessPed(CPhysical *ped)
 void
 cAudioManager::ProcessPedOneShots(cPedParams &params)
 {
-	uint8 emittingVol;
-	int32 sampleIndex;
+	uint8 Vol;
+	uint32 sampleIndex;
 
 	CPed *ped = params.m_pPed;
 
@@ -4124,7 +4253,11 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 	int16 sound;
 	bool8 stereo;
 	CWeapon *weapon;
-	float maxDist = 0.f; // uninitialized variable
+#ifdef FIX_BUGS
+	float maxDist = 0.0f; // uninitialized variable
+#else
+	float maxDist;
+#endif
 
 	static uint8 iSound = 21;
 	static uint32 iSplashFrame = 0;
@@ -4136,14 +4269,161 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 		SET_SOUND_REFLECTION(FALSE);
 		sound = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i];
 		switch (sound) {
+		case SOUND_SHIRT_WIND_FLAP:
+			if (params.m_pPed->IsPlayer() && params.m_pPed->m_pMyVehicle) {
+				if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] > 0.0f) {
+					if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] > 1.0f)
+						m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] = 1.0f;
+
+					Vol = PED_ONE_SHOT_SHIRT_FLAP_VOLUME * m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
+
+					switch (params.m_pPed->m_pMyVehicle->GetModelIndex())
+					{
+					case MI_ANGEL:
+					case MI_FREEWAY:
+						m_sQueueSample.m_nSampleIndex = SFX_CAR_WIND_17;
+						break;
+					case MI_PCJ600:
+						m_sQueueSample.m_nSampleIndex = SFX_CAR_WIND_20;
+						break;
+					case MI_SANCHEZ:
+						m_sQueueSample.m_nSampleIndex = SFX_CAR_WIND_19;
+						break;
+					case MI_PIZZABOY:
+					case MI_FAGGIO:
+						m_sQueueSample.m_nSampleIndex = SFX_CAR_WIND_18;
+						break;
+					default:
+						continue;
+					};
+
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nCounter = 71;
+					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+					m_sQueueSample.m_nPriority = 3;
+					m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+					m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_SHIRT_FLAP_MAX_DIST;
+					maxDist = SQR(PED_ONE_SHOT_SHIRT_FLAP_MAX_DIST);
+					m_sQueueSample.m_nLoopCount = 0;
+					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+					SET_EMITTING_VOLUME(Vol);
+					m_sQueueSample.m_bIs2D = FALSE;
+					m_sQueueSample.m_bStatic = FALSE;
+					m_sQueueSample.m_nFramesToPlay = 3;
+				}
+			}
+			continue;
+		case SOUND_WEAPON_MINIGUN_ATTACK:
+			m_sQueueSample.m_nSampleIndex = SFX_MINIGUN_FIRE_LEFT;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 68;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_MINIGUN_FIRE_LEFT);
+			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_MINIGUN_MAX_DIST;
+			Vol = PED_ONE_SHOT_MINIGUN_VOLUME;
+			maxDist = SQR(PED_ONE_SHOT_MINIGUN_MAX_DIST);
+			m_sQueueSample.m_nLoopCount = 0;
+			SET_LOOP_OFFSETS(SFX_MINIGUN_FIRE_LEFT)
+			SET_EMITTING_VOLUME(PED_ONE_SHOT_MINIGUN_VOLUME);
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 3;
+			break;
+		case SOUND_WEAPON_MINIGUN_2:
+			m_sQueueSample.m_nSampleIndex = SFX_MINIGUN_FIRE_RIGHT;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 69;
+			m_sQueueSample.m_nFrequency = 18569;
+			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_MINIGUN_MAX_DIST;
+			Vol = PED_ONE_SHOT_MINIGUN_VOLUME * m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
+			maxDist = SQR(PED_ONE_SHOT_MINIGUN_MAX_DIST);
+			m_sQueueSample.m_nLoopCount = 0;
+			SET_LOOP_OFFSETS(SFX_MINIGUN_FIRE_RIGHT)
+			SET_EMITTING_VOLUME(Vol);
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 3;
+			break;
+		case SOUND_WEAPON_MINIGUN_3:
+			m_sQueueSample.m_nSampleIndex = SFX_MINIGUN_STOP;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 69;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_MINIGUN_STOP);
+			m_sQueueSample.m_nPriority = 4;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_MINIGUN_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_MINIGUN_MAX_DIST);
+			m_sQueueSample.m_nLoopCount = 1;
+			RESET_LOOP_OFFSETS
+			Vol = PED_ONE_SHOT_MINIGUN_VOLUME;
+			SET_EMITTING_VOLUME(PED_ONE_SHOT_MINIGUN_VOLUME);
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_bStatic = TRUE;
+			SET_SOUND_REFLECTION(TRUE);
+			break;
+		case SOUND_SKATING:
+		{
+			uint32 soundParams = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
+			uint8 param1 = soundParams & 0xFF;
+			uint32 param2 = soundParams >> 8;
+			m_sQueueSample.m_nSampleIndex = (m_anRandomTable[3] & 1) + SFX_SKATE_1;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = iSound;
+			stereo = TRUE;
+			iSound++;
+			m_sQueueSample.m_nFrequency = m_anRandomTable[1] % 1000 + 17000;
+			if (param2 == 0)
+				m_sQueueSample.m_nFrequency = (3 * m_sQueueSample.m_nFrequency) >> 2;
+			m_sQueueSample.m_nPriority = 6;
+			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_SKATING_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_SKATING_MAX_DIST);
+			m_sQueueSample.m_nLoopCount = 1;
+			RESET_LOOP_OFFSETS
+			Vol = (m_anRandomTable[2] % 20 + PED_ONE_SHOT_SKATING_VOLUME) * param1 / MAX_VOLUME;
+			SET_EMITTING_VOLUME(Vol);
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_bStatic = TRUE;
+			SET_SOUND_REFLECTION(TRUE);
+			break;
+		}
+		case SOUND_FALL_LAND:
+		case SOUND_FALL_COLLAPSE:
+			if (ped->bIsInTheAir)
+				continue;
+			maxDist = SQR(PED_ONE_SHOT_FALL_MAX_DIST);
+			Vol = m_anRandomTable[3] % 20 + PED_ONE_SHOT_FALL_VOLUME;
+			if (ped->m_nSurfaceTouched == SURFACE_WATER)
+				m_sQueueSample.m_nSampleIndex = (m_anRandomTable[3] % 4) + SFX_FOOTSTEP_WATER_1;
+			else if (sound == SOUND_FALL_LAND)
+				m_sQueueSample.m_nSampleIndex = SFX_BODY_LAND;
+			else
+				m_sQueueSample.m_nSampleIndex = SFX_BODY_LAND_AND_FALL;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			m_sQueueSample.m_nCounter = 1;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 17);
+			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_FALL_MAX_DIST;
+			m_sQueueSample.m_nLoopCount = 1;
+			RESET_LOOP_OFFSETS
+			SET_EMITTING_VOLUME(Vol);
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_bStatic = TRUE;
+			SET_SOUND_REFLECTION(TRUE);
+			break;
 		case SOUND_STEP_START:
 		case SOUND_STEP_END:
 			if (params.m_pPed->bIsInTheAir)
 				continue;
-			emittingVol = m_anRandomTable[3] % 15 + 45;
+			Vol = m_anRandomTable[3] % 15 + PED_ONE_SHOT_STEP_VOLUME;
 			if (FindPlayerPed() != m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_pEntity)
-				emittingVol /= 2;
-			maxDist = 400.f;
+				Vol >>= 1;
+			maxDist = SQR(PED_ONE_SHOT_STEP_MAX_DIST);
 			switch (params.m_pPed->m_nSurfaceTouched) {
 			case SURFACE_GRASS:
 				sampleIndex = m_anRandomTable[1] % 5 + SFX_FOOTSTEP_GRASS_1;
@@ -4190,11 +4470,11 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 17);
 			switch (params.m_pPed->m_nMoveState) {
 			case PEDMOVE_WALK:
-				emittingVol /= 4;
+				Vol >>= 2;
 				m_sQueueSample.m_nFrequency = 9 * m_sQueueSample.m_nFrequency / 10;
 				break;
 			case PEDMOVE_RUN:
-				emittingVol /= 2;
+				Vol >>= 1;
 				m_sQueueSample.m_nFrequency = 11 * m_sQueueSample.m_nFrequency / 10;
 				break;
 			case PEDMOVE_SPRINT:
@@ -4205,288 +4485,116 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 			}
 			m_sQueueSample.m_nPriority = 5;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 20.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_STEP_MAX_DIST;
 			m_sQueueSample.m_nLoopCount = 1;
 			RESET_LOOP_OFFSETS
-			SET_EMITTING_VOLUME(emittingVol);
+			SET_EMITTING_VOLUME(Vol);
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_bStatic = TRUE;
 			SET_SOUND_REFLECTION(TRUE);
 			break;
-		case SOUND_FALL_LAND:
-		case SOUND_FALL_COLLAPSE:
-			if (ped->bIsInTheAir)
+		case SOUND_WEAPON_AK47_BULLET_ECHO:
+		{
+			uint32 weaponType = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
+			switch (weaponType) {
+			case WEAPONTYPE_SPAS12_SHOTGUN:
+				m_sQueueSample.m_nSampleIndex = SFX_SPAS12_TAIL_LEFT;
+				break;
+			case WEAPONTYPE_M60:
+			case WEAPONTYPE_HELICANNON:
+				m_sQueueSample.m_nSampleIndex = SFX_SPAS12_TAIL_LEFT;
+			case WEAPONTYPE_UZI:
+			case WEAPONTYPE_MP5:
+				m_sQueueSample.m_nSampleIndex = SFX_UZI_END_LEFT;
+				break;
+			case WEAPONTYPE_TEC9:
+			case WEAPONTYPE_SILENCED_INGRAM:
+				m_sQueueSample.m_nSampleIndex = SFX_TEC_TAIL;
+				break;
+			case WEAPONTYPE_M4:
+			case WEAPONTYPE_RUGER:
+			case WEAPONTYPE_SNIPERRIFLE:
+			case WEAPONTYPE_LASERSCOPE:
+				m_sQueueSample.m_nSampleIndex = SFX_RUGER_TAIL;
+				break;
+				break;
+			default:
 				continue;
-			maxDist = SQR(30);
-			emittingVol = m_anRandomTable[3] % 20 + 80;
-			if (ped->m_nSurfaceTouched == SURFACE_WATER) {
-				m_sQueueSample.m_nSampleIndex = (m_anRandomTable[3] & 3) + SFX_FOOTSTEP_WATER_1;
-			} else if (sound == SOUND_FALL_LAND) {
-				m_sQueueSample.m_nSampleIndex = SFX_BODY_LAND;
-			} else {
-				m_sQueueSample.m_nSampleIndex = SFX_BODY_LAND_AND_FALL;
 			}
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 1;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 17);
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 30.0f;
-			m_sQueueSample.m_nLoopCount = 1;
-			RESET_LOOP_OFFSETS
-			SET_EMITTING_VOLUME(emittingVol);
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = TRUE;
-			SET_SOUND_REFLECTION(TRUE);
-			break;
-		case SOUND_FIGHT_37:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_1;
-			m_sQueueSample.m_nFrequency = 18000;
-			goto AddFightSound;
-		case SOUND_FIGHT_38:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_1;
-			m_sQueueSample.m_nFrequency = 16500;
-			goto AddFightSound;
-		case SOUND_FIGHT_39:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_1;
-			m_sQueueSample.m_nFrequency = 20000;
-			goto AddFightSound;
-		case SOUND_FIGHT_40:
-		case SOUND_186:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_2;
-			m_sQueueSample.m_nFrequency = 18000;
-			goto AddFightSound;
-		case SOUND_FIGHT_41:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_2;
-			m_sQueueSample.m_nFrequency = 16500;
-			goto AddFightSound;
-		case SOUND_FIGHT_42:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_2;
-			m_sQueueSample.m_nFrequency = 20000;
-			goto AddFightSound;
-		case SOUND_FIGHT_43:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_4;
-			m_sQueueSample.m_nFrequency = 18000;
-			goto AddFightSound;
-		case SOUND_FIGHT_44:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_4;
-			m_sQueueSample.m_nFrequency = 16500;
-			goto AddFightSound;
-		case SOUND_FIGHT_45:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_4;
-			m_sQueueSample.m_nFrequency = 20000;
-			goto AddFightSound;
-		case SOUND_FIGHT_46:
-		case SOUND_187:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_5;
-			m_sQueueSample.m_nFrequency = 18000;
-			goto AddFightSound;
-		case SOUND_FIGHT_47:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_5;
-			m_sQueueSample.m_nFrequency = 16500;
-			goto AddFightSound;
-		case SOUND_FIGHT_48:
-			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_5;
-			m_sQueueSample.m_nFrequency = 20000;
-		AddFightSound:
-			{
-				uint32 soundParams = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]; // wtf? storing int as float
-				uint8 damagerType = soundParams & 0xFF;
-				uint32 weaponType = soundParams >> 8;
-
-				if (damagerType == ENTITY_TYPE_PED) {
-					if (weaponType == WEAPONTYPE_BRASSKNUCKLE) {
-						CPed* ped = params.m_pPed;
-						uint32 fightMove = ped->m_curFightMove;
-						// LCS:removed for now
-						//if (fightMove == FIGHTMOVE_BACKLEFT || fightMove == FIGHTMOVE_STDPUNCH || fightMove == FIGHTMOVE_PUNCH ||
-						if (
-							ped->m_nPedState == PED_ATTACK) {
-							CEntity* damageEntity = ped->m_pDamageEntity;
-							if (!damageEntity)
-								m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 2 + SFX_HAMMER_HIT_1;
-							else if (damageEntity->GetType() != ENTITY_TYPE_PED)
-								m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 2 + SFX_HAMMER_HIT_1;
-							// LCS:removed for now
-							//else if (((CPed*)damageEntity)->m_curFightMove != FIGHTMOVE_HITHEAD)
-							else if(1)
-								m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 2 + SFX_HAMMER_HIT_1;
-							else
-								m_sQueueSample.m_nSampleIndex = SFX_HAMMER_HIT_1;
-						}
-					}
-				}
-				else {
-					m_sQueueSample.m_nSampleIndex = m_anRandomTable[4] % 6 + SFX_COL_CAR_PANEL_1;
-					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-					m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
-				}
-			}
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = iSound;
+			m_sQueueSample.m_nCounter = iSound++;
 			narrowSoundRange = TRUE;
-			iSound++;
-			m_sQueueSample.m_nPriority = 3;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 30.0f;
-			maxDist = SQR(30);
-			m_sQueueSample.m_nLoopCount = 1;
-			RESET_LOOP_OFFSETS
-			emittingVol = m_anRandomTable[3] % 26 + 100;
-			SET_EMITTING_VOLUME(emittingVol);
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = TRUE;
-			SET_SOUND_REFLECTION(TRUE);
-			break;
-		case SOUND_WEAPON_BAT_ATTACK:
-		case SOUND_WEAPON_KNIFE_ATTACK:
-		{
-			uint32 soundParams = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]; // wtf? storing int as float
-			uint8 damagerType = soundParams & 0xFF;
-			uint32 weaponType = soundParams >> 8;
-			if (damagerType == ENTITY_TYPE_PED) {
-				switch (weaponType) {
-				case WEAPONTYPE_SCREWDRIVER:
-				case WEAPONTYPE_KNIFE:
-				case WEAPONTYPE_CLEAVER:
-				case WEAPONTYPE_MACHETE:
-				case WEAPONTYPE_KATANA:
-					if (sound == SOUND_WEAPON_KNIFE_ATTACK)
-						m_sQueueSample.m_nSampleIndex = SFX_KNIFE_SLASH;
-					else
-						m_sQueueSample.m_nSampleIndex = SFX_KNIFE_STAB;
-					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-					m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
-					break;
-				case WEAPONTYPE_HAMMER:
-					m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 2 + SFX_HAMMER_HIT_1;
-					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-					m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
-					break;
-				default:
-					m_sQueueSample.m_nSampleIndex = SFX_BAT_HIT_LEFT;
-					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-					m_sQueueSample.m_nFrequency = RandomDisplacement(2000) + 22000;
-					stereo = TRUE;
-					break;
-				}
-			}
-			else {
-				m_sQueueSample.m_nSampleIndex = m_anRandomTable[4] % 6 + SFX_COL_CAR_PANEL_1;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+			switch (weaponType) {
+			case WEAPONTYPE_SILENCED_INGRAM:
+				m_sQueueSample.m_nFrequency = 26000;
+				break;
+			case WEAPONTYPE_TEC9:
+				m_sQueueSample.m_nFrequency = 13000;
+				break;
+			case WEAPONTYPE_M4:
+				m_sQueueSample.m_nFrequency = 15600;
+				break;
+			case WEAPONTYPE_LASERSCOPE:
+				m_sQueueSample.m_nFrequency = 7904;
+				break;
+			case WEAPONTYPE_SNIPERRIFLE:
+				m_sQueueSample.m_nFrequency = 9959;
+				break;
+			default:
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+				break;
 			}
-			m_sQueueSample.m_nCounter = iSound++;
-			narrowSoundRange = TRUE;
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 			m_sQueueSample.m_nPriority = 3;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 30.0f;
-			maxDist = SQR(30);
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 			m_sQueueSample.m_nLoopCount = 1;
 			RESET_LOOP_OFFSETS
-			emittingVol = m_anRandomTable[2] % 20 + 100;
-			SET_EMITTING_VOLUME(emittingVol);
+			Vol = m_anRandomTable[4] % 10 + PED_ONE_SHOT_WEAPON_BULLET_ECHO_VOLUME;
+			SET_EMITTING_VOLUME(Vol);
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_bStatic = TRUE;
 			SET_SOUND_REFLECTION(TRUE);
 			break;
 		}
-		case SOUND_WEAPON_CHAINSAW_IDLE:
-			if (FindVehicleOfPlayer())
-				continue;
-			m_sQueueSample.m_nSampleIndex = SFX_CAR_CHAINSAW_IDLE;
-#ifdef GTA_PS2
-			m_sQueueSample.m_nBankIndex = SFX_BANK_CAR_CHAINSAW;
-#else
+		case SOUND_WEAPON_FLAMETHROWER_FIRE:
+			m_sQueueSample.m_nSampleIndex = SFX_FLAMETHROWER_START_LEFT;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-#endif
-			m_sQueueSample.m_nCounter = 70;
-			m_sQueueSample.m_nFrequency = 27000;
+			m_sQueueSample.m_nCounter = iSound++;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_FLAMETHROWER_START_LEFT);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 			m_sQueueSample.m_nPriority = 3;
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = 50.0f;
-			maxDist = SQR(50);
-			m_sQueueSample.m_nLoopCount = 0;
-			emittingVol = 100;
-			SET_LOOP_OFFSETS(SFX_CAR_CHAINSAW_IDLE)
-			SET_EMITTING_VOLUME(100);
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 5;
-			break;
-		case SOUND_WEAPON_CHAINSAW_ATTACK:
-			if (FindVehicleOfPlayer())
-				continue;
-			m_sQueueSample.m_nSampleIndex = SFX_CAR_CHAINSAW_ATTACK;
-#ifdef GTA_PS2
-			m_sQueueSample.m_nBankIndex = SFX_BANK_CAR_CHAINSAW;
-#else
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-#endif
-			m_sQueueSample.m_nCounter = 68;
-			m_sQueueSample.m_nFrequency = 27000;
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = 60.0f;
-			maxDist = SQR(60);
-			m_sQueueSample.m_nLoopCount = 0;
-			emittingVol = 100;
-			SET_LOOP_OFFSETS(SFX_CAR_CHAINSAW_ATTACK)
-			SET_EMITTING_VOLUME(100);
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 5;
-			break;
-		case SOUND_WEAPON_CHAINSAW_MADECONTACT:
-			if (FindVehicleOfPlayer())
-				continue;
-			if ((int32)m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] != ENTITY_TYPE_PED)
-				ReportCollision(params.m_pPed, params.m_pPed, SURFACE_CAR, SURFACE_TARMAC, 0.0f, 0.09f);
-			m_sQueueSample.m_nSampleIndex = SFX_CAR_CHAINSAW_ATTACK;
-#ifdef GTA_PS2
-			m_sQueueSample.m_nBankIndex = SFX_BANK_CAR_CHAINSAW;
-#else
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-#endif
-			m_sQueueSample.m_nCounter = 68;
-			m_sQueueSample.m_nFrequency = RandomDisplacement(500) + 22000;
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = 60.0f;
-			maxDist = SQR(60);
-			m_sQueueSample.m_nLoopCount = 0;
-			emittingVol = 100;
-			SET_LOOP_OFFSETS(SFX_CAR_CHAINSAW_ATTACK)
-			SET_EMITTING_VOLUME(100);
+			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_FLAMETHROWER_FIRE_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_WEAPON_FLAMETHROWER_FIRE_MAX_DIST);
+			m_sQueueSample.m_nLoopCount = 1;
+			RESET_LOOP_OFFSETS
+			Vol = PED_ONE_SHOT_WEAPON_FLAMETHROWER_FIRE_VOLUME;
+			SET_EMITTING_VOLUME(PED_ONE_SHOT_WEAPON_FLAMETHROWER_FIRE_VOLUME);
 			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 5;
+			m_sQueueSample.m_bStatic = TRUE;
 			break;
 		case SOUND_WEAPON_SHOT_FIRED:
 			weapon = ped->GetWeapon();
 			if (!weapon)
 				continue;
 			switch (weapon->m_eWeaponType) {
-			case WEAPONTYPE_ROCKET:
-			case WEAPONTYPE_ROCKETLAUNCHER:
-				m_sQueueSample.m_nSampleIndex = SFX_ROCKET_LEFT;
+			case WEAPONTYPE_PYTHON:
+				m_sQueueSample.m_nSampleIndex = SFX_PYTHON_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ROCKET_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
-				m_sQueueSample.m_nPriority = 1;
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_PYTHON_LEFT);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[0] % 20 + 80;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = MAX_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				SET_SOUND_REFLECTION(TRUE);
@@ -4498,115 +4606,112 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_COLT45_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[1] % 10 + 90;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[1] % 10 + PED_ONE_SHOT_WEAPON_COLT45_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				SET_SOUND_REFLECTION(TRUE);
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_PYTHON:
-				m_sQueueSample.m_nSampleIndex = SFX_PYTHON_LEFT;
+			case WEAPONTYPE_ROCKET:
+			case WEAPONTYPE_ROCKETLAUNCHER:
+				m_sQueueSample.m_nSampleIndex = SFX_ROCKET_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_PYTHON_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
-				m_sQueueSample.m_nPriority = 3;
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ROCKET_LEFT);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+				m_sQueueSample.m_nPriority = 1;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = 127;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[0] % 20 + PED_ONE_SHOT_WEAPON_ROCKETLAUNCHER_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				SET_SOUND_REFLECTION(TRUE);
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_SHOTGUN:
-			case WEAPONTYPE_STUBBY_SHOTGUN:
-				m_sQueueSample.m_nSampleIndex = SFX_SHOTGUN_LEFT;
+			case WEAPONTYPE_FLAMETHROWER:
+				m_sQueueSample.m_nSampleIndex = SFX_FLAMETHROWER_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_nCounter = iSound++;
-				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SHOTGUN_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+				m_sQueueSample.m_nCounter = 9;
+				Vol = PED_ONE_SHOT_WEAPON_FLAMETHROWER_VOLUME;
+				m_sQueueSample.m_nFrequency = (10 * m_sQueueSample.m_nEntityIndex % 2048) + SampleManager.GetSampleBaseFrequency(SFX_FLAMETHROWER_LEFT);
 				m_sQueueSample.m_nPriority = 3;
-				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
-				m_sQueueSample.m_nLoopCount = 1;
-				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[2] % 10 + 100;
-				SET_EMITTING_VOLUME(emittingVol);
+				m_sQueueSample.m_fSpeedMultiplier = 4.0f;
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_FLAMETHROWER_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_FLAMETHROWER_MAX_DIST);
+				m_sQueueSample.m_nLoopCount = 0;
+				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
+				SET_EMITTING_VOLUME(PED_ONE_SHOT_WEAPON_FLAMETHROWER_VOLUME);
 				m_sQueueSample.m_bIs2D = FALSE;
-				m_sQueueSample.m_bStatic = TRUE;
-				SET_SOUND_REFLECTION(TRUE);
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nFramesToPlay = 6;
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_SPAS12_SHOTGUN:
-				m_sQueueSample.m_nSampleIndex = SFX_SPAS12_LEFT;
+			case WEAPONTYPE_M60:
+			case WEAPONTYPE_HELICANNON:
+				m_sQueueSample.m_nSampleIndex = SFX_M60_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SPAS12_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_M60_LEFT);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[2] % 10 + 100;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = PED_ONE_SHOT_WEAPON_M16_VOLUME;
+				SET_EMITTING_VOLUME(PED_ONE_SHOT_WEAPON_M16_VOLUME);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
-				SET_SOUND_REFLECTION(TRUE);
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_TEC9:
-				m_sQueueSample.m_nSampleIndex = SFX_TEC_LEFT;
+			case WEAPONTYPE_MP5:
+				m_sQueueSample.m_nSampleIndex = SFX_MP5_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = RandomDisplacement(500) + 17000;
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_MP5_LEFT);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[3] % 15 + 70;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[3] % 15 + PED_ONE_SHOT_WEAPON_UZI_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_UZI:
-			case WEAPONTYPE_MINIGUN:
-				m_sQueueSample.m_nSampleIndex = SFX_UZI_LEFT;
+			case WEAPONTYPE_TEC9:
+				m_sQueueSample.m_nSampleIndex = SFX_TEC_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_UZI_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+				m_sQueueSample.m_nFrequency = RandomDisplacement(500) + 17000;
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[3] % 15 + 70;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[3] % 15 + PED_ONE_SHOT_WEAPON_UZI_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				stereo = TRUE;
@@ -4619,31 +4724,31 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 				m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 34000;
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[3] % 15 + 70;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[3] % 15 + PED_ONE_SHOT_WEAPON_UZI_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_MP5:
-				m_sQueueSample.m_nSampleIndex = SFX_MP5_LEFT;
+			case WEAPONTYPE_RUGER:
+				m_sQueueSample.m_nSampleIndex = SFX_RUGER_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_MP5_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_RUGER_LEFT);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[3] % 15 + 70;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[3] % 15 + PED_ONE_SHOT_WEAPON_M4_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				stereo = TRUE;
@@ -4656,31 +4761,32 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 				m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 43150;
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[3] % 15 + 90;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[3] % 15 + PED_ONE_SHOT_WEAPON_M4_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_RUGER:
-				m_sQueueSample.m_nSampleIndex = SFX_RUGER_LEFT;
+			case WEAPONTYPE_UZI:
+			case WEAPONTYPE_MINIGUN:
+				m_sQueueSample.m_nSampleIndex = SFX_UZI_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_RUGER_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_UZI_LEFT);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[3] % 15 + 90;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[3] % 15 + PED_ONE_SHOT_WEAPON_UZI_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				stereo = TRUE;
@@ -4695,56 +4801,59 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 					m_sQueueSample.m_nFrequency = 25472;
 				else
 					m_sQueueSample.m_nFrequency = 20182;
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = m_anRandomTable[4] % 10 + 110;
-				SET_EMITTING_VOLUME(emittingVol);
+				Vol = m_anRandomTable[4] % 10 + PED_ONE_SHOT_WEAPON_SNIPERRIFLE_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
 				SET_SOUND_REFLECTION(TRUE);
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_FLAMETHROWER:
-				m_sQueueSample.m_nSampleIndex = SFX_FLAMETHROWER_LEFT;
+			case WEAPONTYPE_SPAS12_SHOTGUN:
+				m_sQueueSample.m_nSampleIndex = SFX_SPAS12_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_nCounter = 9;
-				emittingVol = 90;
-				m_sQueueSample.m_nFrequency = (10 * m_sQueueSample.m_nEntityIndex & 2047) + SampleManager.GetSampleBaseFrequency(SFX_FLAMETHROWER_LEFT);
+				m_sQueueSample.m_nCounter = iSound++;
+				narrowSoundRange = TRUE;
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SPAS12_LEFT);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 				m_sQueueSample.m_nPriority = 3;
-				m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-				m_sQueueSample.m_MaxDistance = 60.0f;
-				maxDist = SQR(60);
-				m_sQueueSample.m_nLoopCount = 0;
-				SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-				SET_EMITTING_VOLUME(90);
+				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
+				m_sQueueSample.m_nLoopCount = 1;
+				RESET_LOOP_OFFSETS
+				Vol = m_anRandomTable[2] % 10 + PED_ONE_SHOT_WEAPON_SHOTGUN_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
-				m_sQueueSample.m_bStatic = FALSE;
-				m_sQueueSample.m_nFramesToPlay = 6;
+				m_sQueueSample.m_bStatic = TRUE;
+				SET_SOUND_REFLECTION(TRUE);
 				stereo = TRUE;
 				break;
-			case WEAPONTYPE_M60:
-			case WEAPONTYPE_HELICANNON:
-				m_sQueueSample.m_nSampleIndex = SFX_M60_LEFT;
+			case WEAPONTYPE_SHOTGUN:
+			case WEAPONTYPE_STUBBY_SHOTGUN:
+				m_sQueueSample.m_nSampleIndex = SFX_SHOTGUN_LEFT;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nCounter = iSound++;
 				narrowSoundRange = TRUE;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_M60_LEFT);
-				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SHOTGUN_LEFT);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-				m_sQueueSample.m_MaxDistance = 120.0f;
-				maxDist = SQR(120);
+				m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST;
+				maxDist = SQR(PED_ONE_SHOT_WEAPON_BULLET_ECHO_MAX_DIST);
 				m_sQueueSample.m_nLoopCount = 1;
 				RESET_LOOP_OFFSETS
-				emittingVol = 127;
-				SET_EMITTING_VOLUME(127);
+				Vol = m_anRandomTable[2] % 10 + PED_ONE_SHOT_WEAPON_SHOTGUN_VOLUME;
+				SET_EMITTING_VOLUME(Vol);
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_bStatic = TRUE;
+				SET_SOUND_REFLECTION(TRUE);
 				stereo = TRUE;
 				break;
 			default:
@@ -4753,23 +4862,11 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 			break;
 		case SOUND_WEAPON_RELOAD:
 			switch ((int32)m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]) {
-			case WEAPONTYPE_ROCKET:
-			case WEAPONTYPE_ROCKETLAUNCHER:
-				m_sQueueSample.m_nSampleIndex = SFX_ROCKET_RELOAD;
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ROCKET_RELOAD);
-				break;
 			case WEAPONTYPE_COLT45:
 			case WEAPONTYPE_PYTHON:
 				m_sQueueSample.m_nSampleIndex = SFX_PISTOL_RELOAD;
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_PISTOL_RELOAD) + RandomDisplacement(300);
 				break;
-			case WEAPONTYPE_SHOTGUN:
-			case WEAPONTYPE_SPAS12_SHOTGUN:
-			case WEAPONTYPE_STUBBY_SHOTGUN:
-			case WEAPONTYPE_RUGER:
-				m_sQueueSample.m_nSampleIndex = SFX_AK47_RELOAD;
-				m_sQueueSample.m_nFrequency = 30290;
-				break;
 			case WEAPONTYPE_TEC9:
 			case WEAPONTYPE_UZI:
 			case WEAPONTYPE_SILENCED_INGRAM:
@@ -4780,6 +4877,18 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 				m_sQueueSample.m_nSampleIndex = SFX_AK47_RELOAD;
 				m_sQueueSample.m_nFrequency = 39243;
 				break;
+			case WEAPONTYPE_SHOTGUN:
+			case WEAPONTYPE_SPAS12_SHOTGUN:
+			case WEAPONTYPE_STUBBY_SHOTGUN:
+			case WEAPONTYPE_RUGER:
+				m_sQueueSample.m_nSampleIndex = SFX_AK47_RELOAD;
+				m_sQueueSample.m_nFrequency = 30290;
+				break;
+			case WEAPONTYPE_ROCKET:
+			case WEAPONTYPE_ROCKETLAUNCHER:
+				m_sQueueSample.m_nSampleIndex = SFX_ROCKET_RELOAD;
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ROCKET_RELOAD);
+				break;
 			case WEAPONTYPE_SNIPERRIFLE:
 			case WEAPONTYPE_LASERSCOPE:
 				m_sQueueSample.m_nSampleIndex = SFX_RIFLE_RELOAD;
@@ -4788,121 +4897,263 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 			default:
 				continue;
 			}
-			emittingVol = 75;
+			Vol = PED_ONE_SHOT_WEAPON_RELOAD_VOLUME;
 			m_sQueueSample.m_nCounter = iSound++;
 			narrowSoundRange = TRUE;
 			m_sQueueSample.m_nFrequency += RandomDisplacement(300);
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nPriority = 5;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 30.0f;
-			maxDist = SQR(30);
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_RELOAD_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_WEAPON_RELOAD_MAX_DIST);
 			m_sQueueSample.m_nLoopCount = 1;
 			RESET_LOOP_OFFSETS
-			SET_EMITTING_VOLUME(75);
+			SET_EMITTING_VOLUME(PED_ONE_SHOT_WEAPON_RELOAD_VOLUME);
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_bStatic = TRUE;
 			SET_SOUND_REFLECTION(TRUE);
 			break;
-		case SOUND_WEAPON_AK47_BULLET_ECHO:
-		{
-			uint32 weaponType = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
-			switch (weaponType) {
-			case WEAPONTYPE_SPAS12_SHOTGUN:
-				m_sQueueSample.m_nSampleIndex = SFX_SPAS12_TAIL_LEFT;
-				break;
-			case WEAPONTYPE_TEC9:
-			case WEAPONTYPE_SILENCED_INGRAM:
-				m_sQueueSample.m_nSampleIndex = SFX_TEC_TAIL;
-				break;
-			case WEAPONTYPE_UZI:
-			case WEAPONTYPE_MP5:
-				m_sQueueSample.m_nSampleIndex = SFX_UZI_END_LEFT;
-				break;
-			case WEAPONTYPE_M4:
-			case WEAPONTYPE_RUGER:
-			case WEAPONTYPE_SNIPERRIFLE:
-			case WEAPONTYPE_LASERSCOPE:
-				m_sQueueSample.m_nSampleIndex = SFX_RUGER_TAIL;
-				break;
-			case WEAPONTYPE_M60:
-			case WEAPONTYPE_HELICANNON:
-				//m_sQueueSample.m_nSampleIndex = SFX_M60_TAIL_LEFT;
-				break;
-			default:
-				continue;
-			}
+		case SOUND_WEAPON_HIT_PED:
+			m_sQueueSample.m_nSampleIndex = SFX_BULLET_PED;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nCounter = iSound++;
 			narrowSoundRange = TRUE;
-			switch (weaponType) {
-			case WEAPONTYPE_TEC9:
-				m_sQueueSample.m_nFrequency = 13000;
-				break;
-			case WEAPONTYPE_SILENCED_INGRAM:
-				m_sQueueSample.m_nFrequency = 26000;
-				break;
-			case WEAPONTYPE_M4:
-				m_sQueueSample.m_nFrequency = 15600;
-				break;
-			case WEAPONTYPE_SNIPERRIFLE:
-				m_sQueueSample.m_nFrequency = 9959;
-				break;
-			case WEAPONTYPE_LASERSCOPE:
-				m_sQueueSample.m_nFrequency = 7904;
-				break;
-			default:
-				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-				break;
-			}
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
-			m_sQueueSample.m_nPriority = 3;
+			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BULLET_PED);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 3);
+			m_sQueueSample.m_nPriority = 7;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 120.0f;
-			maxDist = SQR(120);
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_HIT_PED_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_WEAPON_HIT_PED_MAX_DIST);
 			m_sQueueSample.m_nLoopCount = 1;
 			RESET_LOOP_OFFSETS
-			emittingVol = m_anRandomTable[4] % 10 + 80;
-			SET_EMITTING_VOLUME(emittingVol);
+			Vol = m_anRandomTable[0] % 20 + PED_ONE_SHOT_WEAPON_HIT_PED_VOLUME;
+			SET_EMITTING_VOLUME(Vol);
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_bStatic = TRUE;
-			SET_SOUND_REFLECTION(TRUE);
 			break;
-		}
-		case SOUND_WEAPON_FLAMETHROWER_FIRE:
-			m_sQueueSample.m_nSampleIndex = SFX_FLAMETHROWER_START_LEFT;
+		case SOUND_WEAPON_CHAINSAW_MADECONTACT:
+			if (FindVehicleOfPlayer())
+				continue;
+			if ((int32)m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] != ENTITY_TYPE_PED)
+				ReportCollision(params.m_pPed, params.m_pPed, SURFACE_CAR, SURFACE_TARMAC, 0.0f, 0.09f);
+			m_sQueueSample.m_nSampleIndex = SFX_CAR_CHAINSAW_ATTACK;
+#ifdef GTA_PS2
+			m_sQueueSample.m_nBankIndex = SFX_BANK_CAR_CHAINSAW;
+#else
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+#endif
+			m_sQueueSample.m_nCounter = 68;
+			m_sQueueSample.m_nFrequency = RandomDisplacement(500) + 22000;
+			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_CHAINSAW_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_WEAPON_CHAINSAW_MAX_DIST);
+			m_sQueueSample.m_nLoopCount = 0;
+			Vol = PED_ONE_SHOT_WEAPON_CHAINSAW_VOLUME;
+			SET_LOOP_OFFSETS(SFX_CAR_CHAINSAW_ATTACK)
+			SET_EMITTING_VOLUME(PED_ONE_SHOT_WEAPON_CHAINSAW_VOLUME);
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 5;
+			break;
+		case SOUND_WEAPON_CHAINSAW_ATTACK:
+			if (FindVehicleOfPlayer())
+				continue;
+			m_sQueueSample.m_nSampleIndex = SFX_CAR_CHAINSAW_ATTACK;
+#ifdef GTA_PS2
+			m_sQueueSample.m_nBankIndex = SFX_BANK_CAR_CHAINSAW;
+#else
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+#endif
+			m_sQueueSample.m_nCounter = 68;
+			m_sQueueSample.m_nFrequency = 27000;
+			m_sQueueSample.m_nPriority = 2;
+			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_CHAINSAW_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_WEAPON_CHAINSAW_MAX_DIST);
+			m_sQueueSample.m_nLoopCount = 0;
+			Vol = PED_ONE_SHOT_WEAPON_CHAINSAW_VOLUME;
+			SET_LOOP_OFFSETS(SFX_CAR_CHAINSAW_ATTACK)
+			SET_EMITTING_VOLUME(PED_ONE_SHOT_WEAPON_CHAINSAW_VOLUME);
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 5;
+			break;
+		case SOUND_WEAPON_CHAINSAW_IDLE:
+			if (FindVehicleOfPlayer())
+				continue;
+			m_sQueueSample.m_nSampleIndex = SFX_CAR_CHAINSAW_IDLE;
+#ifdef GTA_PS2
+			m_sQueueSample.m_nBankIndex = SFX_BANK_CAR_CHAINSAW;
+#else
+			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+#endif
+			m_sQueueSample.m_nCounter = 70;
+			m_sQueueSample.m_nFrequency = 27000;
+			m_sQueueSample.m_nPriority = 3;
+			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_CHAINSAW_IDLE_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_WEAPON_CHAINSAW_IDLE_MAX_DIST);
+			m_sQueueSample.m_nLoopCount = 0;
+			Vol = PED_ONE_SHOT_WEAPON_CHAINSAW_VOLUME;
+			SET_LOOP_OFFSETS(SFX_CAR_CHAINSAW_IDLE)
+			SET_EMITTING_VOLUME(PED_ONE_SHOT_WEAPON_CHAINSAW_VOLUME);
+			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_bStatic = FALSE;
+			m_sQueueSample.m_nFramesToPlay = 5;
+			break;
+		case SOUND_WEAPON_BAT_ATTACK:
+		case SOUND_WEAPON_KNIFE_ATTACK:
+		{
+			uint32 soundParams = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]; // wtf? storing int as float
+			uint8 damagerType = soundParams & 0xFF;
+			uint32 weaponType = soundParams >> 8;
+			if (damagerType == ENTITY_TYPE_PED) {
+				switch (weaponType) {
+				case WEAPONTYPE_SCREWDRIVER:
+				case WEAPONTYPE_KNIFE:
+				case WEAPONTYPE_CLEAVER:
+				case WEAPONTYPE_MACHETE:
+				case WEAPONTYPE_KATANA:
+					if (sound == SOUND_WEAPON_KNIFE_ATTACK)
+						m_sQueueSample.m_nSampleIndex = SFX_KNIFE_SLASH;
+					else
+						m_sQueueSample.m_nSampleIndex = SFX_KNIFE_STAB;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+					m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+					break;
+				case WEAPONTYPE_HAMMER:
+					m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 2 + SFX_HAMMER_HIT_1;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+					m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+					break;
+				default:
+					m_sQueueSample.m_nSampleIndex = SFX_BAT_HIT_LEFT;
+					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+					m_sQueueSample.m_nFrequency = RandomDisplacement(2000) + 22000;
+					stereo = TRUE;
+					break;
+				}
+			}
+			else {
+				m_sQueueSample.m_nSampleIndex = m_anRandomTable[4] % 6 + SFX_COL_CAR_PANEL_1;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+				m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
+			}
 			m_sQueueSample.m_nCounter = iSound++;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_FLAMETHROWER_START_LEFT);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+			narrowSoundRange = TRUE;
 			m_sQueueSample.m_nPriority = 3;
-			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-			m_sQueueSample.m_MaxDistance = 60.0f;
-			maxDist = SQR(60);
+			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_PUNCH_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_PUNCH_MAX_DIST);
 			m_sQueueSample.m_nLoopCount = 1;
 			RESET_LOOP_OFFSETS
-			emittingVol = 70;
-			SET_EMITTING_VOLUME(70);
+			Vol = m_anRandomTable[2] % 20 + PED_ONE_SHOT_PUNCH_VOLUME;
+			SET_EMITTING_VOLUME(Vol);
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_bStatic = TRUE;
+			SET_SOUND_REFLECTION(TRUE);
 			break;
-		case SOUND_WEAPON_HIT_PED:
-			m_sQueueSample.m_nSampleIndex = SFX_BULLET_PED;
+		}
+		case SOUND_FIGHT_37:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_1;
+			m_sQueueSample.m_nFrequency = 18000;
+			goto AddFightSound;
+		case SOUND_FIGHT_38:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_1;
+			m_sQueueSample.m_nFrequency = 16500;
+			goto AddFightSound;
+		case SOUND_FIGHT_39:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_1;
+			m_sQueueSample.m_nFrequency = 20000;
+			goto AddFightSound;
+		case SOUND_FIGHT_40:
+		case SOUND_186:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_2;
+			m_sQueueSample.m_nFrequency = 18000;
+			goto AddFightSound;
+		case SOUND_FIGHT_41:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_2;
+			m_sQueueSample.m_nFrequency = 16500;
+			goto AddFightSound;
+		case SOUND_FIGHT_42:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_2;
+			m_sQueueSample.m_nFrequency = 20000;
+			goto AddFightSound;
+		case SOUND_FIGHT_43:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_4;
+			m_sQueueSample.m_nFrequency = 18000;
+			goto AddFightSound;
+		case SOUND_FIGHT_44:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_4;
+			m_sQueueSample.m_nFrequency = 16500;
+			goto AddFightSound;
+		case SOUND_FIGHT_45:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_4;
+			m_sQueueSample.m_nFrequency = 20000;
+			goto AddFightSound;
+		case SOUND_FIGHT_46:
+		case SOUND_187:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_5;
+			m_sQueueSample.m_nFrequency = 18000;
+			goto AddFightSound;
+		case SOUND_FIGHT_47:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_5;
+			m_sQueueSample.m_nFrequency = 16500;
+			goto AddFightSound;
+		case SOUND_FIGHT_48:
+			m_sQueueSample.m_nSampleIndex = SFX_FIGHT_5;
+			m_sQueueSample.m_nFrequency = 20000;
+		AddFightSound:
+			{
+				uint32 soundParams = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i]; // wtf? storing int as float
+				uint8 damagerType = soundParams & 0xFF;
+				uint32 weaponType = soundParams >> 8;
+
+				if (damagerType == ENTITY_TYPE_PED) {
+					if (weaponType == WEAPONTYPE_BRASSKNUCKLE) {
+						/*
+						CPed* ped = params.m_pPed;
+						uint32 fightMove = ped->m_curFightMove;
+						if (fightMove == FIGHTMOVE_BACKLEFT || fightMove == FIGHTMOVE_STDPUNCH || fightMove == FIGHTMOVE_PUNCH ||
+							ped->m_nPedState == PED_ATTACK) {
+							CEntity* damageEntity = ped->m_pDamageEntity;
+							if (!damageEntity)
+								m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 2 + SFX_HAMMER_HIT_1;
+							else if (damageEntity->GetType() != ENTITY_TYPE_PED)
+								m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 2 + SFX_HAMMER_HIT_1;
+							else if (((CPed*)damageEntity)->m_curFightMove != FIGHTMOVE_HITHEAD)
+								m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 2 + SFX_HAMMER_HIT_1;
+							else
+								m_sQueueSample.m_nSampleIndex = SFX_HAMMER_HIT_1;
+						}
+						*/
+					}
+				}
+				else {
+					m_sQueueSample.m_nSampleIndex = m_anRandomTable[4] % 6 + SFX_COL_CAR_PANEL_1;
+					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+					m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+				}
+			}
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = iSound++;
+			m_sQueueSample.m_nCounter = iSound;
 			narrowSoundRange = TRUE;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BULLET_PED);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 8);
-			m_sQueueSample.m_nPriority = 7;
+			iSound++;
+			m_sQueueSample.m_nPriority = 3;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 30.0f;
-			maxDist = SQR(30);
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_PUNCH_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_PUNCH_MAX_DIST);
 			m_sQueueSample.m_nLoopCount = 1;
 			RESET_LOOP_OFFSETS
-			emittingVol = m_anRandomTable[0] % 20 + 90;
-			SET_EMITTING_VOLUME(emittingVol);
+			Vol = m_anRandomTable[3] % 26 + PED_ONE_SHOT_PUNCH_VOLUME;
+			SET_EMITTING_VOLUME(Vol);
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_bStatic = TRUE;
+			SET_SOUND_REFLECTION(TRUE);
 			break;
 		case SOUND_SPLASH:
 			if (m_FrameCounter <= iSplashFrame)
@@ -4915,12 +5166,12 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 			m_sQueueSample.m_nFrequency = RandomDisplacement(1400) + 20000;
 			m_sQueueSample.m_nPriority = 1;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 40.0f;
-			maxDist = SQR(40);
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_SPLASH_MAX_DIST;
+			maxDist = SQR(PED_ONE_SHOT_SPLASH_MAX_DIST);
 			m_sQueueSample.m_nLoopCount = 1;
 			RESET_LOOP_OFFSETS
-			emittingVol = m_anRandomTable[2] % 30 + 70;
-			SET_EMITTING_VOLUME(emittingVol);
+			Vol = m_anRandomTable[2] % 30 + PED_ONE_SHOT_SPLASH_PED_VOLUME;
+			SET_EMITTING_VOLUME(Vol);
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_bStatic = TRUE;
 			SET_SOUND_REFLECTION(TRUE);
@@ -4945,144 +5196,23 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 			m_sQueueSample.m_nCounter = iSound++;
 			narrowSoundRange = TRUE;
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 			m_sQueueSample.m_nPriority = 3;
 			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 30.0f;
+			m_sQueueSample.m_MaxDistance = PED_ONE_SHOT_WEAPON_HIT_PED_MAX_DIST;
 			if (weaponType == WEAPONTYPE_UNARMED || weaponType == WEAPONTYPE_BRASSKNUCKLE)
-				emittingVol = m_anRandomTable[1] % 10 + 35;
+				Vol = m_anRandomTable[1] % 10 + 35;
 			else
-				emittingVol = m_anRandomTable[2] % 20 + 70;
-			maxDist = SQR(30);
-			m_sQueueSample.m_nLoopCount = 1;
-			RESET_LOOP_OFFSETS
-			SET_EMITTING_VOLUME(emittingVol);
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = TRUE;
-			SET_SOUND_REFLECTION(TRUE);
-			break;
-		}
-		case SOUND_SKATING:
-		{
-			uint32 soundParams = m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
-			uint8 param1 = soundParams & 0xFF;
-			uint32 param2 = soundParams >> 8;
-			m_sQueueSample.m_nSampleIndex = (m_anRandomTable[3] & 1) + SFX_SKATE_1;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = iSound;
-			stereo = TRUE;
-			iSound++;
-			m_sQueueSample.m_nFrequency = m_anRandomTable[1] % 1000 + 17000;
-			if (param2 == 0)
-				m_sQueueSample.m_nFrequency = (3 * m_sQueueSample.m_nFrequency) / 4;
-			m_sQueueSample.m_nPriority = 6;
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = 20.0f;
-			maxDist = SQR(20);
+				Vol = m_anRandomTable[2] % 20 + 70;
+			maxDist = SQR(PED_ONE_SHOT_WEAPON_HIT_PED_MAX_DIST);
 			m_sQueueSample.m_nLoopCount = 1;
 			RESET_LOOP_OFFSETS
-			emittingVol = (m_anRandomTable[2] % 20 + 70) * param1 / 127;
-			SET_EMITTING_VOLUME(emittingVol);
+			SET_EMITTING_VOLUME(Vol);
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_bStatic = TRUE;
 			SET_SOUND_REFLECTION(TRUE);
 			break;
 		}
-		case SOUND_WEAPON_MINIGUN_ATTACK:
-			m_sQueueSample.m_nSampleIndex = SFX_MINIGUN_FIRE_LEFT;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 68;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_MINIGUN_FIRE_LEFT);
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = 150.0f;
-			emittingVol = 127;
-			maxDist = SQR(150);
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_LOOP_OFFSETS(SFX_MINIGUN_FIRE_LEFT)
-			SET_EMITTING_VOLUME(127);
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 3;
-			break;
-		case SOUND_WEAPON_MINIGUN_2:
-			m_sQueueSample.m_nSampleIndex = SFX_MINIGUN_FIRE_RIGHT;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 69;
-			m_sQueueSample.m_nFrequency = 18569;
-			m_sQueueSample.m_nPriority = 2;
-			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-			m_sQueueSample.m_MaxDistance = 150.0f;
-			emittingVol = 127.0f * m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
-			maxDist = SQR(150);
-			m_sQueueSample.m_nLoopCount = 0;
-			SET_LOOP_OFFSETS(SFX_MINIGUN_FIRE_RIGHT)
-			SET_EMITTING_VOLUME(emittingVol);
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = FALSE;
-			m_sQueueSample.m_nFramesToPlay = 3;
-			break;
-		case SOUND_WEAPON_MINIGUN_3:
-			m_sQueueSample.m_nSampleIndex = SFX_MINIGUN_STOP;
-			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-			m_sQueueSample.m_nCounter = 69;
-			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_MINIGUN_STOP);
-			m_sQueueSample.m_nPriority = 4;
-			m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-			m_sQueueSample.m_MaxDistance = 150.0f;
-			maxDist = SQR(150);
-			m_sQueueSample.m_nLoopCount = 1;
-			RESET_LOOP_OFFSETS
-			emittingVol = 127;
-			SET_EMITTING_VOLUME(127);
-			m_sQueueSample.m_bIs2D = FALSE;
-			m_sQueueSample.m_bStatic = TRUE;
-			SET_SOUND_REFLECTION(TRUE);
-			break;
-		case SOUND_SHIRT_WIND_FLAP:
-			if (params.m_pPed->IsPlayer() && params.m_pPed->m_pMyVehicle) {
-				if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] > 0.0f) {
-					if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] > 1.0f)
-						m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i] = 1.0f;
-
-					emittingVol = 90.0f * m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_afVolume[i];
-
-					switch (params.m_pPed->m_pMyVehicle->GetModelIndex())
-					{
-					case MI_ANGEL:
-					case MI_FREEWAY:
-						m_sQueueSample.m_nSampleIndex = SFX_CAR_WIND_17;
-						break;
-					case MI_PIZZABOY:
-					case MI_FAGGIO:
-						m_sQueueSample.m_nSampleIndex = SFX_CAR_WIND_18;
-						break;
-					case MI_PCJ600:
-						m_sQueueSample.m_nSampleIndex = SFX_CAR_WIND_20;
-						break;
-					case MI_SANCHEZ:
-						m_sQueueSample.m_nSampleIndex = SFX_CAR_WIND_19;
-						break;
-					default:
-						continue;
-					};
-
-					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-					m_sQueueSample.m_nCounter = 71;
-					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-					m_sQueueSample.m_nPriority = 3;
-					m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-					m_sQueueSample.m_MaxDistance = 15.0f;
-					maxDist = SQR(15);
-					m_sQueueSample.m_nLoopCount = 0;
-					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-					SET_EMITTING_VOLUME(emittingVol);
-					m_sQueueSample.m_bIs2D = FALSE;
-					m_sQueueSample.m_bStatic = FALSE;
-					m_sQueueSample.m_nFramesToPlay = 3;
-				}
-			}
-			continue;
 		default:
 			SetupPedComments(params, sound);
 			continue;
@@ -5092,28 +5222,28 @@ cAudioManager::ProcessPedOneShots(cPedParams &params)
 			iSound = 21;
 		if (params.m_fDistance < maxDist) {
 			CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
-			m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(Vol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
 			if (m_sQueueSample.m_nVolume > 0) {
 				if (stereo) {
 					if (m_sQueueSample.m_fDistance < 0.2f * m_sQueueSample.m_MaxDistance) {
 						m_sQueueSample.m_bIs2D = TRUE;
 						m_sQueueSample.m_nPan = 0;
-					} else {
+					} else
 						stereo = FALSE;
-					}
 				}
 				SET_SOUND_REVERB(TRUE);
 				AddSampleToRequestedQueue();
 				if (stereo) {
 					m_sQueueSample.m_nPan = 127;
 					m_sQueueSample.m_nSampleIndex++;
-					if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i] != SOUND_WEAPON_SHOT_FIRED ||
-					    weapon->m_eWeaponType != WEAPONTYPE_FLAMETHROWER) {
+					if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[i] == SOUND_WEAPON_SHOT_FIRED &&
+					    weapon->m_eWeaponType == WEAPONTYPE_FLAMETHROWER)
+						m_sQueueSample.m_nCounter++;
+					else {
 						m_sQueueSample.m_nCounter = iSound++;
 						if (iSound > 60)
 							iSound = 21;
-					} else
-						m_sQueueSample.m_nCounter++;
+					}
 					AddSampleToRequestedQueue();
 				}
 			}
@@ -5144,64 +5274,59 @@ void
 cAudioManager::ProcessPlayerMood()
 {
 	CPlayerPed *playerPed;
-	uint32& lastMissionPassedTime = CTheScripts::GetLastMissionPassedTime();
 	uint32 curTime = CTimer::GetTimeInMilliseconds();
 
-	if (m_nPlayerMoodTimer <= curTime) {
-		playerPed = FindPlayerPed();
-		if (playerPed != nil) {
+	if (m_nPlayerMoodTimer > curTime)
+		return;
 
-			if (playerPed->m_pWanted->GetWantedLevel() > 3) {
-				m_nPlayerMood = PLAYER_MOOD_ANGRY;
-				return;
-			}
-			if (playerPed->m_pWanted->GetWantedLevel() > 1) {
-				m_nPlayerMood = PLAYER_MOOD_PISSED_OFF;
-				return;
-			}
+	playerPed = FindPlayerPed();
+	if (!playerPed)
+		return;
 
-			if (lastMissionPassedTime != -1) {
-				if (curTime < lastMissionPassedTime) {
-					lastMissionPassedTime = curTime;
-					return;
-				}
-				if (curTime < lastMissionPassedTime + 180000) {
-					m_nPlayerMood = PLAYER_MOOD_WISECRACKING;
-					return;
-				}
-			}
-			m_nPlayerMood = PLAYER_MOOD_CALM;
-		}
-	}
+	if (playerPed->m_pWanted->GetWantedLevel() > 3)
+		m_nPlayerMood = PLAYER_MOOD_ANGRY;
+	else if (playerPed->m_pWanted->GetWantedLevel() > 1)
+		m_nPlayerMood = PLAYER_MOOD_PISSED_OFF;
+	else if (CTheScripts::GetLastMissionPassedTime() != -1) {
+		if (curTime >= CTheScripts::GetLastMissionPassedTime()) {
+			if (curTime < CTheScripts::GetLastMissionPassedTime() + 180000)
+				m_nPlayerMood = PLAYER_MOOD_WISECRACKING;
+			else
+				m_nPlayerMood = PLAYER_MOOD_CALM;
+		} else
+			CTheScripts::GetLastMissionPassedTime() = curTime;
+	} else
+		m_nPlayerMood = PLAYER_MOOD_CALM;
 }
 
 void
 cAudioManager::SetupPedComments(cPedParams &params, uint16 sound)
 {
 	CPed *ped = params.m_pPed;
-	uint8 emittingVol;
-	float soundIntensity;
+	uint8 Vol;
+	float maxDist;
 	tPedComment pedComment;
 
 	if(ped != nil) {
 		if(!ped->m_canTalk) return;
 		m_bGenericSfx = FALSE;
 		pedComment.m_nSampleIndex = GetPedCommentSfx(ped, sound);
-		if(pedComment.m_nSampleIndex == NO_SAMPLE) return;
-		soundIntensity = 40.0f;
+		if(pedComment.m_nSampleIndex == NO_SAMPLE)
+			return;
+		maxDist = PED_COMMENT_MAX_DIST;
 	} else {
 		m_bGenericSfx = TRUE;
 		switch(sound) {
 		case SOUND_PED_HELI_PLAYER_FOUND:
-			soundIntensity = 400.0f;
+			maxDist = PED_COMMENT_POLICE_HELI_MAX_DIST;
 			pedComment.m_nSampleIndex = m_anRandomTable[m_sQueueSample.m_nEntityIndex % 4] % 29 + SFX_PHCHAT1;
 			break;
 		case SOUND_PED_VCPA_PLAYER_FOUND:
-			soundIntensity = 400.0f;
+			maxDist = PED_COMMENT_POLICE_HELI_MAX_DIST;
 			pedComment.m_nSampleIndex = m_anRandomTable[m_sQueueSample.m_nEntityIndex % 4] % 29 + SFX_PBCHAT1;
 			break;
 		case SOUND_INJURED_PED_MALE_OUCH:
-			soundIntensity = 40.0f;
+			maxDist = PED_COMMENT_MAX_DIST;
 #ifdef FIX_BUGS
 			pedComment.m_nSampleIndex = m_anRandomTable[m_sQueueSample.m_nEntityIndex % 4] % 53 + SFX_MALE_PAIN_01;
 #else
@@ -5209,7 +5334,7 @@ cAudioManager::SetupPedComments(cPedParams &params, uint16 sound)
 #endif
 			break;
 		case SOUND_INJURED_PED_FEMALE:
-			soundIntensity = 40.0f;
+			maxDist = PED_COMMENT_MAX_DIST;
 			pedComment.m_nSampleIndex = m_anRandomTable[m_sQueueSample.m_nEntityIndex % 4] % 34 + SFX_FEMALE_PAIN_01;
 			break;
 		default:
@@ -5217,13 +5342,13 @@ cAudioManager::SetupPedComments(cPedParams &params, uint16 sound)
 		}
 	}
 
-	if(params.m_fDistance < SQR(soundIntensity)) {
+	if(params.m_fDistance < SQR(maxDist)) {
 		CalculateDistance(params.m_bDistanceCalculated, params.m_fDistance);
 		if(CWorld::GetIsLineOfSightClear(TheCamera.GetPosition(), m_sQueueSample.m_vecPos, true, false, false, false, false, false))
-			emittingVol = MAX_VOLUME;
+			Vol = PED_COMMENT_VOLUME;
 		else
-			emittingVol = 31;
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, soundIntensity, m_sQueueSample.m_fDistance);
+			Vol = PED_COMMENT_VOLUME_BEHIND_WALL;
+		m_sQueueSample.m_nVolume = ComputeVolume(Vol, maxDist, m_sQueueSample.m_fDistance);
 		pedComment.m_nProcess = 10;
 		if (m_sQueueSample.m_nVolume > 0) {
 			pedComment.m_nEntityIndex = m_sQueueSample.m_nEntityIndex;
@@ -5231,7 +5356,7 @@ cAudioManager::SetupPedComments(cPedParams &params, uint16 sound)
 			pedComment.m_fDistance = m_sQueueSample.m_fDistance;
 			pedComment.m_nVolume = m_sQueueSample.m_nVolume;
 #if defined(EXTERNAL_3D_SOUND) && defined(FIX_BUGS)
-			pedComment.m_nEmittingVolume = emittingVol;
+			pedComment.m_nEmittingVolume = Vol;
 #endif
 			m_sPedComments.Add(&pedComment);
 		}
@@ -8030,49 +8155,51 @@ cPedComments::Add(tPedComment *com)
 {
 	uint8 index;
 
-	if (m_nCommentsInBank[m_nActiveBank] >= NUM_PED_COMMENTS_SLOTS) {
-		index = m_nIndexMap[m_nActiveBank][NUM_PED_COMMENTS_SLOTS - 1];
-		if (m_asPedComments[m_nActiveBank][index].m_nVolume > com->m_nVolume)
+	// copypasted priority check from cAudioManager::AddSampleToRequestedQueue
+
+	if (m_nPedCommentCount[m_nActiveQueue] >= NUM_PED_COMMENTS_SLOTS) {
+		index = m_aPedCommentOrderList[m_nActiveQueue][NUM_PED_COMMENTS_SLOTS - 1];
+		if (m_aPedCommentQueue[m_nActiveQueue][index].m_nVolume > com->m_nVolume)
 			return;
 	} else
-		index = m_nCommentsInBank[m_nActiveBank]++;
+		index = m_nPedCommentCount[m_nActiveQueue]++;
 
-	m_asPedComments[m_nActiveBank][index] = *com;
+	m_aPedCommentQueue[m_nActiveQueue][index] = *com;
 
+	// this bit is basically copypasted cAudioManager::AddDetailsToRequestedOrderList
 	uint8 i = 0;
 	if (index != 0) {
 		for (i = 0; i < index; i++) {
-			if (m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][i]].m_nVolume < m_asPedComments[m_nActiveBank][index].m_nVolume)
+			if (m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][i]].m_nVolume < m_aPedCommentQueue[m_nActiveQueue][index].m_nVolume)
 				break;
 		}
 
 		if (i < index)
-			memmove(&m_nIndexMap[m_nActiveBank][i + 1], &m_nIndexMap[m_nActiveBank][i], NUM_PED_COMMENTS_SLOTS - 1 - i);
+			memmove(&m_aPedCommentOrderList[m_nActiveQueue][i + 1], &m_aPedCommentOrderList[m_nActiveQueue][i], NUM_PED_COMMENTS_SLOTS - 1 - i);
 	}
 
-	m_nIndexMap[m_nActiveBank][i] = index;
+	m_aPedCommentOrderList[m_nActiveQueue][i] = index;
 }
 
 void
 cPedComments::Process()
 {
 	uint32 sampleIndex;
-	uint8 actualUsedBank;
-	tPedComment *comment;
+	uint8 queue;
 	static uint8 counter = 0;
-	static int32 prevSamples[10] = { NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE };
+	static uint32 prevSamples[10] = { NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE, NO_SAMPLE };
 
-	if(AudioManager.m_bIsPaused) return;
+	if (AudioManager.m_bIsPaused) return;
 
-	if(m_nCommentsInBank[m_nActiveBank]) {
+	if (m_nPedCommentCount[m_nActiveQueue]) {
 		for(int i = 0; i < ARRAY_SIZE(prevSamples); i++) {
-			if(m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_nSampleIndex ==
+			if(m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_nSampleIndex ==
 			   prevSamples[(counter + 1 + i) % ARRAY_SIZE(prevSamples)]) {
-				m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_nProcess = -1;
+				m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_nProcess = -1;
 				goto PedCommentAlreadyAdded;
 			}
 		}
-		sampleIndex = m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_nSampleIndex;
+		sampleIndex = m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_nSampleIndex;
 		switch(SampleManager.IsPedCommentLoaded(sampleIndex)) { // yes, this was a switch
 		case FALSE:
 #if defined(GTA_PC) && !defined(FIX_BUGS)
@@ -8081,13 +8208,13 @@ cPedComments::Process()
 				SampleManager.LoadPedComment(sampleIndex);
 			break;
 		case TRUE:
-			AudioManager.m_sQueueSample.m_nEntityIndex = m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_nEntityIndex;
+			AudioManager.m_sQueueSample.m_nEntityIndex = m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_nEntityIndex;
 			AudioManager.m_sQueueSample.m_nCounter = 0;
 			AudioManager.m_sQueueSample.m_nSampleIndex = sampleIndex;
 			AudioManager.m_sQueueSample.m_nBankIndex = SFX_BANK_PED_COMMENTS;
 			AudioManager.m_sQueueSample.m_nPriority = 3;
-			AudioManager.m_sQueueSample.m_nVolume = m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_nVolume;
-			AudioManager.m_sQueueSample.m_fDistance = m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_fDistance;
+			AudioManager.m_sQueueSample.m_nVolume = m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_nVolume;
+			AudioManager.m_sQueueSample.m_fDistance = m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_fDistance;
 			AudioManager.m_sQueueSample.m_nLoopCount = 1;
 #ifndef GTA_PS2
 			AudioManager.m_sQueueSample.m_nLoopStart = 0;
@@ -8095,7 +8222,7 @@ cPedComments::Process()
 #endif
 #ifdef EXTERNAL_3D_SOUND
 	#ifdef FIX_BUGS
-			AudioManager.m_sQueueSample.m_nEmittingVolume = m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_nEmittingVolume;
+			AudioManager.m_sQueueSample.m_nEmittingVolume = m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_nEmittingVolume;
 	#else
 			AudioManager.m_sQueueSample.m_nEmittingVolume = MAX_VOLUME;
 	#endif // FIX_BUGS
@@ -8107,9 +8234,9 @@ cPedComments::Process()
 #else
 			AudioManager.m_sQueueSample.m_fSpeedMultiplier = 3.0f;
 #endif
-			AudioManager.m_sQueueSample.m_MaxDistance = 40.0f;
+			AudioManager.m_sQueueSample.m_MaxDistance = PED_COMMENT_MAX_DIST;
 			AudioManager.m_sQueueSample.m_bStatic = TRUE;
-			AudioManager.m_sQueueSample.m_vecPos = m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_vecPos;
+			AudioManager.m_sQueueSample.m_vecPos = m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_vecPos;
 #ifdef AUDIO_REVERB
 			AudioManager.m_sQueueSample.m_bReverb = TRUE;
 #endif // AUDIO_REVERB
@@ -8131,7 +8258,7 @@ cPedComments::Process()
 			if (CTimer::GetIsSlowMotionActive())
 				AudioManager.m_sQueueSample.m_nFrequency >>= 1;
 #endif
-			m_asPedComments[m_nActiveBank][m_nIndexMap[m_nActiveBank][0]].m_nProcess = -1;
+			m_aPedCommentQueue[m_nActiveQueue][m_aPedCommentOrderList[m_nActiveQueue][0]].m_nProcess = -1;
 			prevSamples[counter++] = sampleIndex;
 			if(counter == 10) counter = 0;
 			AudioManager.AddSampleToRequestedQueue();
@@ -8144,27 +8271,27 @@ cPedComments::Process()
 			break;
 		}
 	}
+
 PedCommentAlreadyAdded:
-	// Switch bank
-	if (m_nActiveBank == 0) {
-		actualUsedBank = 0;
-		m_nActiveBank = 1;
+	// Switch queue
+	if (m_nActiveQueue == 0) {
+		queue = 0;
+		m_nActiveQueue = 1;
 	} else {
-		actualUsedBank = 1;
-		m_nActiveBank = 0;
-	}
-	comment = m_asPedComments[actualUsedBank];
-	for (uint32 i = 0; i < m_nCommentsInBank[actualUsedBank]; i++) {
-		if (m_asPedComments[actualUsedBank][m_nIndexMap[actualUsedBank][i]].m_nProcess > 0) {
-			m_asPedComments[actualUsedBank][m_nIndexMap[actualUsedBank][i]].m_nProcess--;
-			Add(&comment[m_nIndexMap[actualUsedBank][i]]);
+		queue = 1;
+		m_nActiveQueue = 0;
+	}
+	for (uint8 i = 0; i < m_nPedCommentCount[queue]; i++) {
+		if (m_aPedCommentQueue[queue][m_aPedCommentOrderList[queue][i]].m_nProcess > 0) {
+			m_aPedCommentQueue[queue][m_aPedCommentOrderList[queue][i]].m_nProcess--;
+			Add(&m_aPedCommentQueue[queue][m_aPedCommentOrderList[queue][i]]);
 		}
 	}
 
-	for (uint32 i = 0; i < NUM_PED_COMMENTS_SLOTS; i++) {
-		m_nIndexMap[actualUsedBank][i] = NUM_PED_COMMENTS_SLOTS;
-	}
-	m_nCommentsInBank[actualUsedBank] = 0;
+	// clear queue
+	for (uint8 i = 0; i < NUM_PED_COMMENTS_SLOTS; i++)
+		m_aPedCommentOrderList[queue][i] = NUM_PED_COMMENTS_SLOTS;
+	m_nPedCommentCount[queue] = 0;
 #if defined(GTA_PC) && !defined(FIX_BUGS)
 	if(m_bDelay)
 		if(CTimer::GetTimeInMilliseconds() - m_nDelayTimer > 6000) m_bDelay = FALSE;
@@ -8178,7 +8305,7 @@ PedCommentAlreadyAdded:
 #pragma endregion All the ped audio code
 
 void
-cAudioManager::ProcessExplosions(int32 explosion)
+cAudioManager::ProcessExplosions(int32 id)
 {
 	uint8 type;
 	float distSquared;
@@ -8192,32 +8319,32 @@ cAudioManager::ProcessExplosions(int32 explosion)
 			case EXPLOSION_ROCKET:
 			case EXPLOSION_BARREL:
 			case EXPLOSION_TANK_GRENADE:
-				m_sQueueSample.m_MaxDistance = 200.0f;
+				m_sQueueSample.m_MaxDistance = EXPLOSION_DEFAULT_MAX_DIST;
 				m_sQueueSample.m_nSampleIndex = SFX_EXPLOSION_2;
 				m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 19000;
 				m_sQueueSample.m_nPriority = 0;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				SET_SOUND_REFLECTION(TRUE);
 				break;
-			case EXPLOSION_MOLOTOV:
-				m_sQueueSample.m_MaxDistance = 150.0f;
-				m_sQueueSample.m_nSampleIndex = SFX_EXPLOSION_3;
-				m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 19000;
-				m_sQueueSample.m_nPriority = 0;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				SET_SOUND_REFLECTION(FALSE);
-				break;
 			case EXPLOSION_MINE:
 			case EXPLOSION_HELI_BOMB:
-				m_sQueueSample.m_MaxDistance = 200.0f;
+				m_sQueueSample.m_MaxDistance = EXPLOSION_MINE_MAX_DIST;
 				m_sQueueSample.m_nSampleIndex = SFX_ROCKET_LEFT;
 				m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 12347;
 				m_sQueueSample.m_nPriority = 0;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				SET_SOUND_REFLECTION(TRUE);
 				break;
+			case EXPLOSION_MOLOTOV:
+				m_sQueueSample.m_MaxDistance = EXPLOSION_MOLOTOV_MAX_DIST;
+				m_sQueueSample.m_nSampleIndex = SFX_EXPLOSION_3;
+				m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 19000;
+				m_sQueueSample.m_nPriority = 0;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				SET_SOUND_REFLECTION(FALSE);
+				break;
 			default:
-				m_sQueueSample.m_MaxDistance = 200.0f;
+				m_sQueueSample.m_MaxDistance = EXPLOSION_DEFAULT_MAX_DIST;
 				m_sQueueSample.m_nSampleIndex = SFX_EXPLOSION_1;
 				m_sQueueSample.m_nFrequency = RandomDisplacement(1000) + 19500;
 				if (type == EXPLOSION_HELI)
@@ -8251,10 +8378,10 @@ cAudioManager::ProcessExplosions(int32 explosion)
 }
 
 void
-cAudioManager::ProcessFires(int32)
+cAudioManager::ProcessFires(int32 id)
 {
 	CEntity *entity;
-	uint8 emittingVol;
+	uint8 Vol;
 	float distSquared;
 
 	for (uint8 i = 0; i < NUM_FIRES; i++) {
@@ -8263,41 +8390,41 @@ cAudioManager::ProcessFires(int32)
 			if (entity) {
 				switch (entity->GetType()) {
 				case ENTITY_TYPE_BUILDING:
-					m_sQueueSample.m_MaxDistance = 80.0f;
+					m_sQueueSample.m_MaxDistance = FIRE_BUILDING_MAX_DIST;
 					m_sQueueSample.m_nSampleIndex = SFX_CAR_ON_FIRE;
-					emittingVol = 100;
+					Vol = FIRE_BUILDING_VOLUME;
 					m_sQueueSample.m_nFrequency = 8 * SampleManager.GetSampleBaseFrequency(SFX_CAR_ON_FIRE) / 10;
-					m_sQueueSample.m_nFrequency += i * (m_sQueueSample.m_nFrequency / 64);
+					m_sQueueSample.m_nFrequency += i * (m_sQueueSample.m_nFrequency >> 6);
 					m_sQueueSample.m_nPriority = 6;
 					break;
 				case ENTITY_TYPE_PED:
-					m_sQueueSample.m_MaxDistance = 25.0f;
+					m_sQueueSample.m_MaxDistance = FIRE_PED_MAX_DIST;
 					m_sQueueSample.m_nSampleIndex = SFX_PED_ON_FIRE;
 					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_PED_ON_FIRE);
-					emittingVol = 60;
-					m_sQueueSample.m_nFrequency += i * (m_sQueueSample.m_nFrequency / 64);
+					Vol = FIRE_PED_VOLUME;
+					m_sQueueSample.m_nFrequency += i * (m_sQueueSample.m_nFrequency >> 6);
 					m_sQueueSample.m_nPriority = 10;
 					break;
 				default:
-					m_sQueueSample.m_MaxDistance = 80.0f;
+					m_sQueueSample.m_MaxDistance = FIRE_DEFAULT_MAX_DIST;
 					m_sQueueSample.m_nSampleIndex = SFX_CAR_ON_FIRE;
 					m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_CAR_ON_FIRE);
-					m_sQueueSample.m_nFrequency += i * (m_sQueueSample.m_nFrequency / 64);
-					emittingVol = 80;
+					m_sQueueSample.m_nFrequency += i * (m_sQueueSample.m_nFrequency >> 6);
+					Vol = FIRE_DEFAULT_VOLUME;
 					m_sQueueSample.m_nPriority = 8;
 				}
 			} else {
-				m_sQueueSample.m_MaxDistance = 80.0f;
+				m_sQueueSample.m_MaxDistance = FIRE_DEFAULT_MAX_DIST;
 				m_sQueueSample.m_nSampleIndex = SFX_CAR_ON_FIRE;
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_CAR_ON_FIRE);
-				emittingVol = 80;
+				Vol = FIRE_DEFAULT_VOLUME;
 				m_sQueueSample.m_nPriority = 8;
 			}
 			m_sQueueSample.m_vecPos = gFireManager.m_aFires[i].m_vecPos;
 			distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
 			if (distSquared < SQR(m_sQueueSample.m_MaxDistance)) {
 				m_sQueueSample.m_fDistance = Sqrt(distSquared);
-				m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
 				if (m_sQueueSample.m_nVolume > 0) {
 					m_sQueueSample.m_nCounter = i;
 					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
@@ -8306,7 +8433,7 @@ cAudioManager::ProcessFires(int32)
 					m_sQueueSample.m_bIs2D = FALSE;
 					m_sQueueSample.m_nLoopCount = 0;
 					m_sQueueSample.m_bStatic = FALSE;
-					SET_EMITTING_VOLUME(emittingVol);
+					SET_EMITTING_VOLUME(Vol);
 					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 					SET_SOUND_REVERB(TRUE);
 					SET_SOUND_REFLECTION(FALSE);
@@ -8315,12 +8442,12 @@ cAudioManager::ProcessFires(int32)
 			}
 			if (gFireManager.m_aFires[i].m_bExtinguishedWithWater) {
 				gFireManager.m_aFires[i].m_bExtinguishedWithWater = FALSE;
-				emittingVol = 100.0f * gFireManager.m_aFires[i].m_fWaterExtinguishCountdown;
-				m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
+				Vol = FIRE_EXTINGUISH_VOLUME * gFireManager.m_aFires[i].m_fWaterExtinguishCountdown;
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
 				if (m_sQueueSample.m_nVolume > 0) {
 					m_sQueueSample.m_nSampleIndex = SFX_JUMBO_TAXI;
 					m_sQueueSample.m_nFrequency = 19591;
-					m_sQueueSample.m_nFrequency += i * (m_sQueueSample.m_nFrequency / 64);
+					m_sQueueSample.m_nFrequency += i * (m_sQueueSample.m_nFrequency >> 6);
 					m_sQueueSample.m_nPriority = 9;
 					m_sQueueSample.m_nCounter = i + 40;
 					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
@@ -8329,7 +8456,7 @@ cAudioManager::ProcessFires(int32)
 					m_sQueueSample.m_bIs2D = FALSE;
 					m_sQueueSample.m_nLoopCount = 0;
 					m_sQueueSample.m_bStatic = FALSE;
-					SET_EMITTING_VOLUME(emittingVol);
+					SET_EMITTING_VOLUME(Vol);
 					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 					SET_SOUND_REVERB(TRUE);
 					SET_SOUND_REFLECTION(FALSE);
@@ -8341,19 +8468,17 @@ cAudioManager::ProcessFires(int32)
 }
 
 void
-cAudioManager::ProcessWaterCannon(int32)
+cAudioManager::ProcessWaterCannon(int32 id)
 {
-	const float SOUND_INTENSITY = 30.0f;
-
 	for (uint32 i = 0; i < NUM_WATERCANNONS; i++) {
 		if (CWaterCannons::aCannons[i].m_nId) {
 			m_sQueueSample.m_vecPos = CWaterCannons::aCannons[0].m_avecPos[CWaterCannons::aCannons[i].m_nCur];
 			float distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
-			if (distSquared < SQR(SOUND_INTENSITY)) {
+			if (distSquared < SQR(WATER_CANNON_MAX_DIST)) {
 				m_sQueueSample.m_fDistance = Sqrt(distSquared);
-				m_sQueueSample.m_nVolume = ComputeVolume(50, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
+				m_sQueueSample.m_nVolume = ComputeVolume(WATER_CANNON_VOLUME, WATER_CANNON_MAX_DIST, m_sQueueSample.m_fDistance);
 				if (m_sQueueSample.m_nVolume > 0) {
-					m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+					m_sQueueSample.m_MaxDistance = WATER_CANNON_MAX_DIST;
 					m_sQueueSample.m_nSampleIndex = SFX_JUMBO_TAXI;
 					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 					m_sQueueSample.m_nFrequency = 15591;
@@ -8364,7 +8489,7 @@ cAudioManager::ProcessWaterCannon(int32)
 					m_sQueueSample.m_bIs2D = FALSE;
 					m_sQueueSample.m_nLoopCount = 0;
 					m_sQueueSample.m_bStatic = FALSE;
-					SET_EMITTING_VOLUME(50);
+					SET_EMITTING_VOLUME(WATER_CANNON_VOLUME);
 					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 					SET_SOUND_REVERB(TRUE);
 					SET_SOUND_REFLECTION(FALSE);
@@ -8376,14 +8501,11 @@ cAudioManager::ProcessWaterCannon(int32)
 }
 
 #pragma region SCRIPT_OBJECTS
-const int SCRIPT_OBJECT_INTENSITY_S = 30;
-const int SCRIPT_OBJECT_INTENSITY_L = 80;
-
 void
 cAudioManager::ProcessScriptObject(int32 id)
 {
 	if (MusicManager.m_nMusicMode == MUSICMODE_GAME) {
-		cAudioScriptObject* entity = (cAudioScriptObject*)m_asAudioEntities[id].m_pEntity;
+		cAudioScriptObject *entity = (cAudioScriptObject*)m_asAudioEntities[id].m_pEntity;
 		if (entity != nil) {
 			m_sQueueSample.m_vecPos = entity->Posn;
 			if (m_asAudioEntities[id].m_AudioEvents == 1)
@@ -8398,53 +8520,30 @@ void
 cAudioManager::ProcessOneShotScriptObject(uint8 sound)
 {
 	CPlayerPed *playerPed;
-	uint8 emittingVolume;
+	uint8 Vol;
 	float distSquared;
 
 	static uint8 iSound = 0;
 
 	switch (sound) {
-	case SCRIPT_SOUND_POLICE_CELL_DOOR_CLUNK:
-		m_sQueueSample.m_MaxDistance = 40.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_COL_GATE;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_nFrequency = 10600;
-		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
-		m_sQueueSample.m_nPriority = 3;
-		emittingVolume = 60;
-		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		SET_SOUND_REFLECTION(TRUE);
-		break;
-	case SCRIPT_SOUND_GARAGE_DOOR_CLUNK:
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_COL_CAR_PANEL_2; // huh?
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_nFrequency = 22000;
-		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
-		m_sQueueSample.m_nPriority = 4;
-		emittingVolume = 60;
-		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		SET_SOUND_REFLECTION(TRUE);
-		break;
-	case SCRIPT_SOUND_SHOOTING_RANGE_TARGET_HIT:
-	case SCRIPT_SOUND_BULLET_HIT_GROUND_1:
-	case SCRIPT_SOUND_BULLET_HIT_GROUND_2:
-	case SCRIPT_SOUND_BULLET_HIT_GROUND_3:
-		m_sQueueSample.m_MaxDistance = 50.0f;
-		m_sQueueSample.m_nSampleIndex = m_anRandomTable[iSound % 5] % 3 + SFX_BULLET_WALL_1;
+	case SCRIPT_SOUND_SEAPLANE_LOW_FUEL:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_SEAPLANE_LOW_FUEL_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_LOW;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
-		m_sQueueSample.m_nPriority = 9;
+		Vol = SCRIPT_OBJECT_SEAPLANE_LOW_FUEL_VOLUME;
+#ifdef FIX_BUGS
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_SEAPLANE_LOW);
+#else
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_CAR_HORN_JEEP);
+#endif
+		m_sQueueSample.m_nPriority = 1;
 		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		emittingVolume = m_anRandomTable[2] % 20 + 90;
+		m_sQueueSample.m_bIs2D = TRUE;
+		SET_SOUND_REFLECTION(FALSE);
 		break;
 	case SCRIPT_SOUND_WILLIE_CARD_SWIPE:
-		emittingVolume = 70;
-		m_sQueueSample.m_MaxDistance = 40.0f;
+		Vol = SCRIPT_OBJECT_WILLIE_CARD_SWIPE_VOLUME;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_WILLIE_CARD_SWIPE_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_BOMB_BEEP;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_nFrequency = 20159;
@@ -8453,85 +8552,8 @@ cAudioManager::ProcessOneShotScriptObject(uint8 sound)
 		m_sQueueSample.m_bIs2D = FALSE;
 		SET_SOUND_REFLECTION(FALSE);
 		break;
-	case SCRIPT_SOUND_MALE_AMBULANCE_OUCH:
-	{
-		cPedParams pedParams;
-		pedParams.m_fDistance = GetDistanceSquared(m_sQueueSample.m_vecPos);
-		SetupPedComments(pedParams, SOUND_INJURED_PED_MALE_OUCH);
-		return;
-	}
-	case SCRIPT_SOUND_FEMALE_AMBULANCE_OUCH:
-	{
-		cPedParams pedParams;
-		pedParams.m_fDistance = GetDistanceSquared(m_sQueueSample.m_vecPos);
-		SetupPedComments(pedParams, SOUND_INJURED_PED_FEMALE);
-		return;
-	}
-	case SCRIPT_SOUND_SEAPLANE_LOW_FUEL:
-		m_sQueueSample.m_MaxDistance = 1000.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_SEAPLANE_LOW;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		emittingVolume = 100;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_CAR_HORN_JEEP); // BUG?
-		m_sQueueSample.m_nPriority = 1;
-		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_bIs2D = TRUE;
-		SET_SOUND_REFLECTION(FALSE);
-		break;
-	//case SCRIPT_SOUND_PAYPHONE_RINGING:
-	//	m_sQueueSample.m_MaxDistance = 80.0f;
-	//	m_sQueueSample.m_nSampleIndex = SFX_PHONE_RING;
-	//	m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-	//	emittingVolume = 80;
-	//	m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_PHONE_RING);
-	//	m_sQueueSample.m_nPriority = 1;
-	//	m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-	//	m_sQueueSample.m_bIs2D = FALSE;
-	//	SET_SOUND_REFLECTION(FALSE);
-	//	break;
-	case SCRIPT_SOUND_GLASS_BREAK_L:
-		m_sQueueSample.m_MaxDistance = 60.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_GLASS_SMASH;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		emittingVolume = 70;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GLASS_SMASH);
-		m_sQueueSample.m_nPriority = 3;
-		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		break;
-	case SCRIPT_SOUND_GLASS_BREAK_S:
-		m_sQueueSample.m_MaxDistance = 60.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_GLASS_SMASH;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		emittingVolume = 60;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GLASS_SMASH);
-		m_sQueueSample.m_nPriority = 3;
-		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		break;
-	case SCRIPT_SOUND_GLASS_CRACK:
-		m_sQueueSample.m_MaxDistance = 60.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_GLASS_CRACK;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		emittingVolume = 70;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GLASS_CRACK);
-		m_sQueueSample.m_nPriority = 3;
-		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		SET_SOUND_REFLECTION(TRUE);
-		break;
-	case SCRIPT_SOUND_GLASS_LIGHT_BREAK:
-		m_sQueueSample.m_MaxDistance = 55.0f;
-		m_sQueueSample.m_nSampleIndex = (m_anRandomTable[4] & 3) + SFX_GLASS_SHARD_1;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		m_sQueueSample.m_nFrequency = RandomDisplacement(2000) + 19000;
-		m_sQueueSample.m_nPriority = 9;
-		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		emittingVolume = RandomDisplacement(11) + 25;
-		break;
 	case SCRIPT_SOUND_BOX_DESTROYED_1:
-		m_sQueueSample.m_MaxDistance = 60.0f;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_BOX_DESTROYED_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_WOODEN_BOX_SMASH;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_nFrequency = RandomDisplacement(1500) + 18600;
@@ -8539,10 +8561,10 @@ cAudioManager::ProcessOneShotScriptObject(uint8 sound)
 		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
 		m_sQueueSample.m_bIs2D = FALSE;
 		SET_SOUND_REFLECTION(TRUE);
-		emittingVolume = m_anRandomTable[2] % 20 + 80;
+		Vol = m_anRandomTable[2] % 20 + SCRIPT_OBJECT_BOX_DESTROYED_VOLUME;
 		break;
 	case SCRIPT_SOUND_BOX_DESTROYED_2:
-		m_sQueueSample.m_MaxDistance = 60.0f;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_BOX_DESTROYED_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_CARDBOARD_BOX_SMASH;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_nFrequency = RandomDisplacement(1500) + 18600;
@@ -8550,43 +8572,43 @@ cAudioManager::ProcessOneShotScriptObject(uint8 sound)
 		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
 		m_sQueueSample.m_bIs2D = FALSE;
 		SET_SOUND_REFLECTION(TRUE);
-		emittingVolume = m_anRandomTable[2] % 20 + 80;
+		Vol = m_anRandomTable[2] % 20 + SCRIPT_OBJECT_BOX_DESTROYED_VOLUME;
 		break;
 	case SCRIPT_SOUND_METAL_COLLISION:
-		m_sQueueSample.m_MaxDistance = 60.0f;
+		m_sQueueSample.m_MaxDistance = COLLISION_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = m_anRandomTable[3] % 5 + SFX_COL_CAR_1;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
 		m_sQueueSample.m_bIs2D = FALSE;
 		SET_SOUND_REFLECTION(TRUE);
-		emittingVolume = m_anRandomTable[2] % 30 + 70;
+		Vol = m_anRandomTable[2] % 30 + SCRIPT_OBJECT_METAL_COLLISION_VOLUME;
 		break;
 	case SCRIPT_SOUND_TIRE_COLLISION:
-		m_sQueueSample.m_MaxDistance = 60.0f;
+		m_sQueueSample.m_MaxDistance = COLLISION_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_TYRE_BUMP;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
 		m_sQueueSample.m_bIs2D = FALSE;
 		SET_SOUND_REFLECTION(TRUE);
-		emittingVolume = m_anRandomTable[2] % 30 + 60;
+		Vol = m_anRandomTable[2] % 30 + SCRIPT_OBJECT_TIRE_COLLISION_VOLUME;
 		break;
 	case SCRIPT_SOUND_HIT_BALL:
-		m_sQueueSample.m_MaxDistance = 60.0f;
+		m_sQueueSample.m_MaxDistance = COLLISION_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_HIT_BALL;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 		m_sQueueSample.m_nPriority = 5;
 		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
 		m_sQueueSample.m_bIs2D = FALSE;
 		SET_SOUND_REFLECTION(TRUE);
-		emittingVolume = m_anRandomTable[2] % 30 + 60;
+		Vol = m_anRandomTable[2] % 30 + SCRIPT_OBJECT_HIT_BALL_VOLUME;
 		break;
 	case SCRIPT_SOUND_GUNSHELL_DROP:
 		playerPed = FindPlayerPed();
@@ -8618,21 +8640,127 @@ cAudioManager::ProcessOneShotScriptObject(uint8 sound)
 			m_sQueueSample.m_nFrequency = RandomDisplacement(1500) + 30000;
 			m_sQueueSample.m_nPriority = 15;
 		}
-		m_sQueueSample.m_MaxDistance = 20.0f;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_GUNSHELL_MAX_DIST;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
 		m_sQueueSample.m_bIs2D = FALSE;
-		emittingVolume = m_anRandomTable[2] % 20 + 30;
+		Vol = m_anRandomTable[2] % 20 + SCRIPT_OBJECT_GUNSHELL_VOLUME;
 		break;
 	case SCRIPT_SOUND_GUNSHELL_DROP_SOFT:
 		m_sQueueSample.m_nSampleIndex = SFX_BULLET_SHELL_HIT_GROUND_2;
 		m_sQueueSample.m_nFrequency = RandomDisplacement(500) + 11000;
 		m_sQueueSample.m_nPriority = 18;
-		m_sQueueSample.m_MaxDistance = 20.0f;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_GUNSHELL_MAX_DIST;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
 		m_sQueueSample.m_bIs2D = FALSE;
-		emittingVolume = m_anRandomTable[2] % 20 + 30;
+		Vol = m_anRandomTable[2] % 20 + SCRIPT_OBJECT_GUNSHELL_VOLUME;
+		break;
+	case SCRIPT_SOUND_SHOOTING_RANGE_TARGET_HIT:
+	case SCRIPT_SOUND_BULLET_HIT_GROUND_1:
+	case SCRIPT_SOUND_BULLET_HIT_GROUND_2:
+	case SCRIPT_SOUND_BULLET_HIT_GROUND_3:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_BULLET_HIT_GROUND_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = m_anRandomTable[iSound % 5] % 3 + SFX_BULLET_WALL_1;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
+		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+		m_sQueueSample.m_nPriority = 9;
+		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		Vol = m_anRandomTable[2] % 20 + SCRIPT_OBJECT_BULLET_HIT_GROUND_VOLUME;
+		break;
+/*
+	case SCRIPT_SOUND_PAYPHONE_RINGING:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_PAYPHONE_RINGING_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_PHONE_RING;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		Vol = SCRIPT_OBJECT_PAYPHONE_RINGING_VOLUME;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_PHONE_RING);
+		m_sQueueSample.m_nPriority = 1;
+		m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		SET_SOUND_REFLECTION(FALSE);
+		break;
+*/
+	case SCRIPT_SOUND_GLASS_BREAK_L:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_GLASS_BREAK_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_GLASS_SMASH;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		Vol = SCRIPT_OBJECT_GLASS_BREAK_LONG_VOLUME;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GLASS_SMASH);
+		m_sQueueSample.m_nPriority = 3;
+		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		break;
+	case SCRIPT_SOUND_GLASS_BREAK_S:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_GLASS_BREAK_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_GLASS_SMASH;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		Vol = SCRIPT_OBJECT_GLASS_BREAK_SHORT_VOLUME;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GLASS_SMASH);
+		m_sQueueSample.m_nPriority = 3;
+		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		break;
+	case SCRIPT_SOUND_GLASS_CRACK:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_GLASS_BREAK_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_GLASS_CRACK;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		Vol = SCRIPT_OBJECT_GLASS_BREAK_LONG_VOLUME;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GLASS_CRACK);
+		m_sQueueSample.m_nPriority = 3;
+		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		SET_SOUND_REFLECTION(TRUE);
+		break;
+	case SCRIPT_SOUND_GLASS_LIGHT_BREAK:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_GLASS_LIGHT_BREAK_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = (m_anRandomTable[4] & 3) + SFX_GLASS_SHARD_1;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		m_sQueueSample.m_nFrequency = RandomDisplacement(2000) + 19000;
+		m_sQueueSample.m_nPriority = 9;
+		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		Vol = RandomDisplacement(11) + SCRIPT_OBJECT_GLASS_LIGHT_BREAK_VOLUME;
+		break;
+	case SCRIPT_SOUND_MALE_AMBULANCE_OUCH:
+	{
+		cPedParams pedParams;
+		pedParams.m_fDistance = GetDistanceSquared(m_sQueueSample.m_vecPos);
+		SetupPedComments(pedParams, SOUND_INJURED_PED_MALE_OUCH);
+		return;
+	}
+	case SCRIPT_SOUND_FEMALE_AMBULANCE_OUCH:
+	{
+		cPedParams pedParams;
+		pedParams.m_fDistance = GetDistanceSquared(m_sQueueSample.m_vecPos);
+		SetupPedComments(pedParams, SOUND_INJURED_PED_FEMALE);
+		return;
+	}
+	case SCRIPT_SOUND_POLICE_CELL_DOOR_CLUNK:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_POLICE_CELL_DOOR_CLUNK_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_COL_GATE;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		m_sQueueSample.m_nFrequency = 10600;
+		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+		m_sQueueSample.m_nPriority = 3;
+		Vol = SCRIPT_OBJECT_POLICE_CELL_DOOR_CLUNK_VOLUME;
+		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		SET_SOUND_REFLECTION(TRUE);
+		break;
+	case SCRIPT_SOUND_GARAGE_DOOR_CLUNK:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_GARAGE_DOOR_CLUNK_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_COL_CAR_PANEL_2; // huh?
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		m_sQueueSample.m_nFrequency = 22000;
+		m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
+		m_sQueueSample.m_nPriority = 4;
+		Vol = SCRIPT_OBJECT_GARAGE_DOOR_CLUNK_VOLUME;
+		m_sQueueSample.m_fSpeedMultiplier = 0.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		SET_SOUND_REFLECTION(TRUE);
 		break;
 	default:
 		return;
@@ -8641,12 +8769,12 @@ cAudioManager::ProcessOneShotScriptObject(uint8 sound)
 	distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
 	if (distSquared < SQR(m_sQueueSample.m_MaxDistance)) {
 		m_sQueueSample.m_fDistance = Sqrt(distSquared);
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVolume, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
+		m_sQueueSample.m_nVolume = ComputeVolume(Vol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
 		if (m_sQueueSample.m_nVolume > 0) {
 			m_sQueueSample.m_nCounter = iSound++;
 			m_sQueueSample.m_nLoopCount = 1;
 			m_sQueueSample.m_bStatic = TRUE;
-			SET_EMITTING_VOLUME(emittingVolume);
+			SET_EMITTING_VOLUME(Vol);
 			RESET_LOOP_OFFSETS
 			SET_SOUND_REVERB(TRUE);
 			AddSampleToRequestedQueue();
@@ -8657,60 +8785,15 @@ cAudioManager::ProcessOneShotScriptObject(uint8 sound)
 void
 cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 {
-	uint8 emittingVolume;
+	uint8 Vol;
 	float distSquared;
 
 	switch(sound) {
-	case SCRIPT_SOUND_BANK_ALARM_LOOP:
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_BUILDINGS_BANK_ALARM;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_BANK_ALARM;
-		emittingVolume = 90;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BUILDINGS_BANK_ALARM);
-		m_sQueueSample.m_nPriority = 2;
-		m_sQueueSample.m_nFramesToPlay = 3;
-		m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		break;
-	case SCRIPT_SOUND_POLICE_CELL_DOOR_SLIDING_LOOP:
-	case SCRIPT_SOUND_GARAGE_DOOR_SLIDING_LOOP:
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_GARAGE_DOOR_LOOP;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		emittingVolume = 90;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GARAGE_DOOR_LOOP);
-		m_sQueueSample.m_nPriority = 3;
-		m_sQueueSample.m_nFramesToPlay = 3;
-		m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		break;
-	case SCRIPT_SOUND_SNORING_LOOP:
-		m_sQueueSample.m_MaxDistance = 6.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_SNORE;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_SNORING;
-		emittingVolume = 25;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BUILDING_SNORE);
-		m_sQueueSample.m_nPriority = 6;
-		m_sQueueSample.m_nFramesToPlay = 3;
-		m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		break;
-	case SCRIPT_SOUND_SHOOTING_RANGE_TARGET_MOVING_LOOP:
-		m_sQueueSample.m_MaxDistance = 40.0f;
-		m_sQueueSample.m_nSampleIndex = SFX_TANK_TURRET;
-		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-		emittingVolume = 60;
-		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TANK_TURRET);
-		m_sQueueSample.m_nPriority = 4;
-		m_sQueueSample.m_nFramesToPlay = 3;
-		m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-		m_sQueueSample.m_bIs2D = FALSE;
-		break;
 	case SCRIPT_SOUND_NEW_BUILDING_BAR_1:
 		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_BAR_1;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_BAR_1;
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8720,8 +8803,8 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 	case SCRIPT_SOUND_NEW_BUILDING_BAR_2:
 		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_BAR_2;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_BAR_2;
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8731,8 +8814,8 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 	case SCRIPT_SOUND_NEW_BUILDING_BAR_3:
 		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_BAR_3;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_BAR_3;
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8742,8 +8825,8 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 	case SCRIPT_SOUND_NEW_BUILDING_BAR_4:
 		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_BAR_4;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_BAR_4;
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8752,11 +8835,11 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		break;
 	case SCRIPT_SOUND_NEW_BUILDING_MALIBU_1:
 		if(MusicManager.m_nPlayingTrack == STREAMED_SOUND_MALIBU_AMBIENT) return;
-		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_MAL1;
+		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_MALIBU_1;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_MALIBU_1;
 		MusicManager.SetMalibuClubTrackPos(SCRIPT_SOUND_NEW_BUILDING_MALIBU_1);
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8765,11 +8848,11 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		break;
 	case SCRIPT_SOUND_NEW_BUILDING_MALIBU_2:
 		if(MusicManager.m_nPlayingTrack == STREAMED_SOUND_MALIBU_AMBIENT) return;
-		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_MAL2;
+		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_MALIBU_2;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_MALIBU_2;
 		MusicManager.SetMalibuClubTrackPos(SCRIPT_SOUND_NEW_BUILDING_MALIBU_2);
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8778,11 +8861,11 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		break;
 	case SCRIPT_SOUND_NEW_BUILDING_MALIBU_3:
 		if(MusicManager.m_nPlayingTrack == STREAMED_SOUND_MALIBU_AMBIENT) return;
-		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_MAL3;
+		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_MALIBU_3;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_MALIBU_3;
 		MusicManager.SetMalibuClubTrackPos(SCRIPT_SOUND_NEW_BUILDING_MALIBU_3);
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8791,11 +8874,11 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		break;
 	case SCRIPT_SOUND_NEW_BUILDING_STRIP_1:
 		if(MusicManager.m_nPlayingTrack == STREAMED_SOUND_STRIPCLUB_AMBIENT) return;
-		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_STR1;
+		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_STRIP_1;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_STRIP_1;
 		MusicManager.SetStripClubTrackPos(SCRIPT_SOUND_NEW_BUILDING_STRIP_1);
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8804,11 +8887,11 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		break;
 	case SCRIPT_SOUND_NEW_BUILDING_STRIP_2:
 		if(MusicManager.m_nPlayingTrack == STREAMED_SOUND_STRIPCLUB_AMBIENT) return;
-		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_STR2;
+		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_STRIP_2;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_STRIP_2;
 		MusicManager.SetStripClubTrackPos(SCRIPT_SOUND_NEW_BUILDING_STRIP_2);
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8817,11 +8900,11 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 		break;
 	case SCRIPT_SOUND_NEW_BUILDING_STRIP_3:
 		if(MusicManager.m_nPlayingTrack == STREAMED_SOUND_STRIPCLUB_AMBIENT) return;
-		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_STR3;
+		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_STRIP_3;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_STRIP_3;
 		MusicManager.SetStripClubTrackPos(SCRIPT_SOUND_NEW_BUILDING_STRIP_3);
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
@@ -8831,17 +8914,62 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 	case SCRIPT_SOUND_NEW_BUILDING_CHURCH:
 		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_CHURCH;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_CHURCH;
-		m_sQueueSample.m_MaxDistance = 80.0f;
-		emittingVolume = 127;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		Vol = SCRIPT_OBJECT_DEFAULT_VOLUME;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 		m_sQueueSample.m_nPriority = 3;
 		m_sQueueSample.m_nFramesToPlay = 15;
 		m_sQueueSample.m_fSpeedMultiplier = 4.0f;
 		m_sQueueSample.m_bIs2D = FALSE;
 		break;
+	case SCRIPT_SOUND_SNORING_LOOP:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_SNORING_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_BUILDING_SNORE;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_SNORING;
+		Vol = SCRIPT_OBJECT_SNORING_VOLUME;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BUILDING_SNORE);
+		m_sQueueSample.m_nPriority = 6;
+		m_sQueueSample.m_nFramesToPlay = 3;
+		m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		break;
+	case SCRIPT_SOUND_BANK_ALARM_LOOP:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_BUILDINGS_BANK_ALARM;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_BUILDING_BANK_ALARM;
+		Vol = SCRIPT_OBJECT_BANK_ALARM_VOLUME;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BUILDINGS_BANK_ALARM);
+		m_sQueueSample.m_nPriority = 2;
+		m_sQueueSample.m_nFramesToPlay = 3;
+		m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		break;
+	case SCRIPT_SOUND_POLICE_CELL_DOOR_SLIDING_LOOP:
+	case SCRIPT_SOUND_GARAGE_DOOR_SLIDING_LOOP:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_GARAGE_DOOR_LOOP;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		Vol = SCRIPT_OBJECT_GARAGE_DOOR_SLIDING_VOLUME;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_GARAGE_DOOR_LOOP);
+		m_sQueueSample.m_nPriority = 3;
+		m_sQueueSample.m_nFramesToPlay = 3;
+		m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		break;
+	case SCRIPT_SOUND_SHOOTING_RANGE_TARGET_MOVING_LOOP:
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_SHOOTING_RANGE_TARGET_MOVING_MAX_DIST;
+		m_sQueueSample.m_nSampleIndex = SFX_TANK_TURRET;
+		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+		Vol = SCRIPT_OBJECT_SHOOTING_RANGE_TARGET_MOVING_VOLUME;
+		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_TANK_TURRET);
+		m_sQueueSample.m_nPriority = 4;
+		m_sQueueSample.m_nFramesToPlay = 3;
+		m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+		m_sQueueSample.m_bIs2D = FALSE;
+		break;
 	case SCRIPT_SOUND_NEW_WATERFALL:
-		emittingVolume = 30;
-		m_sQueueSample.m_MaxDistance = 80.0f;
+		Vol = SCRIPT_OBJECT_NEW_WATERFALL_VOLUME;
+		m_sQueueSample.m_MaxDistance = SCRIPT_OBJECT_LONG_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_BOAT_WATER_LOOP;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_nFrequency = 20812;
@@ -8856,14 +8984,14 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 	distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
 	if(distSquared < SQR(m_sQueueSample.m_MaxDistance)) {
 		m_sQueueSample.m_fDistance = Sqrt(distSquared);
-		m_sQueueSample.m_nVolume = ComputeVolume(emittingVolume, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
+		m_sQueueSample.m_nVolume = ComputeVolume(Vol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
 		if (m_sQueueSample.m_nVolume > 0) {
 			m_sQueueSample.m_nCounter = 0;
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_nLoopCount = 0;
 			m_sQueueSample.m_bStatic = FALSE;
 			SET_SOUND_REVERB(TRUE);
-			SET_EMITTING_VOLUME(emittingVolume);
+			SET_EMITTING_VOLUME(Vol);
 			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 			SET_SOUND_REFLECTION(FALSE);
 			AddSampleToRequestedQueue();
@@ -8875,7 +9003,7 @@ cAudioManager::ProcessLoopingScriptObject(uint8 sound)
 void
 cAudioManager::ProcessWeather(int32 id)
 {
-	uint8 vol;
+	uint8 Vol;
 	float x;
 	float y;
 	float modifier;
@@ -8884,27 +9012,27 @@ cAudioManager::ProcessWeather(int32 id)
 	static uint8 iSound = 0;
 
 	if (m_asAudioEntities[id].m_AudioEvents > 0 && m_asAudioEntities[id].m_awAudioEvent[0] == SOUND_LIGHTNING) {
-		if (m_asAudioEntities[id].m_afVolume[0] < 10.0f) {
+		if (m_asAudioEntities[id].m_afVolume[0] < 10) {
 			m_sQueueSample.m_nSampleIndex = SFX_EXPLOSION_2;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_nFrequency = RandomDisplacement(500) + 4000;
-			vol = (m_asAudioEntities[id].m_afVolume[0] * 10.0f * 0.1f) + 35;
-			vol += 35;
+			Vol = (m_asAudioEntities[id].m_afVolume[0] * 10.0f * 0.1f);
+			Vol += 35;
 		} else {
 			m_sQueueSample.m_nSampleIndex = SFX_EXPLOSION_1;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_GENERIC_EXTRA;
 			m_sQueueSample.m_nFrequency = RandomDisplacement(500) + 4000;
-			vol = ((m_asAudioEntities[id].m_afVolume[0] - 10.0f) * 10.0f * 0.1f);
-			vol += 40;
+			Vol = ((m_asAudioEntities[id].m_afVolume[0] - 10.0f) * 10.0f * 0.1f);
+			Vol += 40;
 		}
-		m_sQueueSample.m_nVolume = vol;
+		m_sQueueSample.m_nVolume = Vol;
 		if (TheCamera.SoundDistUp < 20.0f)
-			m_sQueueSample.m_nVolume <<= 1;
+			m_sQueueSample.m_nVolume >>= 1;
 		if (iSound == 4)
 			iSound = 0;
 		m_sQueueSample.m_nCounter = iSound++;
 		m_sQueueSample.m_nPriority = 0;
-		m_sQueueSample.m_nPan = (m_anRandomTable[2] & 15) + 55;
+		m_sQueueSample.m_nPan = (m_anRandomTable[2] % 16) + 55;
 		m_sQueueSample.m_bIs2D = TRUE;
 		m_sQueueSample.m_nLoopCount = 1;
 		m_sQueueSample.m_bStatic = TRUE;
@@ -8941,7 +9069,7 @@ cAudioManager::ProcessWeather(int32 id)
 	if (wind > 0.0f && CObject::fDistToNearestTree < 75.0f) {
 		m_sQueueSample.m_nSampleIndex = SFX_PALM_TREE_LO;
 		m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_PALM_TREE_LO);
-		m_sQueueSample.m_nVolume = (m_anRandomTable[1] % 10 + 45.0f) * (75.0f - CObject::fDistToNearestTree) * (4.0f / 300.0f) * wind;
+		m_sQueueSample.m_nVolume = (m_anRandomTable[1] % 10 + 45.0f) * (75.0f - CObject::fDistToNearestTree) / 75.0f * wind;
 		m_sQueueSample.m_nCounter = 5;
 		m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 		m_sQueueSample.m_nPriority = 1;
@@ -9129,13 +9257,13 @@ cAudioManager::ProcessFrontEnd()
 			m_sQueueSample.m_nFrequency = 32000;
 		else if (sample == SOUND_BULLETTRACE_1 || sample == SOUND_BULLETTRACE_2) {
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
-			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
+			m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 5);
 		} else if (staticFreq)
 			m_sQueueSample.m_nFrequency = 5382;
 		else
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 
-		m_sQueueSample.m_nVolume = 127;
+		m_sQueueSample.m_nVolume = FRONTEND_VOLUME;
 		//if (m_sQueueSample.m_nSampleIndex == SFX_HURRICANE_MA && CWeather::Wind > 1.0f)
 		//	m_sQueueSample.m_nVolume = (CWeather::Wind - 1.0f) * m_sQueueSample.m_nVolume;
 		m_sQueueSample.m_nCounter = iSound++;
@@ -9191,16 +9319,15 @@ cAudioManager::ProcessCrane()
 	CCrane *crane = (CCrane *)m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_pEntity;
 	float distSquared;
 	bool8 distCalculated = FALSE;
-	static const int intensity = 80;
 
 	if (crane) {
 		if (crane->m_nCraneStatus == CCrane::ACTIVATED) {
 			if (crane->m_nCraneState != CCrane::IDLE) {
 				m_sQueueSample.m_vecPos = crane->m_pCraneEntity->GetPosition();
 				distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
-				if (distSquared < SQR(intensity)) {
+				if (distSquared < SQR(CRANE_MAX_DIST)) {
 					CalculateDistance(distCalculated, distSquared);
-					m_sQueueSample.m_nVolume = ComputeVolume(100, 80.f, m_sQueueSample.m_fDistance);
+					m_sQueueSample.m_nVolume = ComputeVolume(CRANE_VOLUME, CRANE_MAX_DIST, m_sQueueSample.m_fDistance);
 					if (m_sQueueSample.m_nVolume > 0) {
 						m_sQueueSample.m_nCounter = 0;
 						m_sQueueSample.m_nSampleIndex = SFX_CRANE_MAGNET;
@@ -9209,17 +9336,17 @@ cAudioManager::ProcessCrane()
 						m_sQueueSample.m_nPriority = 2;
 						m_sQueueSample.m_nFrequency = 6000;
 						m_sQueueSample.m_nLoopCount = 0;
-						SET_EMITTING_VOLUME(100);
+						SET_EMITTING_VOLUME(CRANE_VOLUME);
 						SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 						m_sQueueSample.m_fSpeedMultiplier = 4.0f;
-						m_sQueueSample.m_fSoundIntensity = intensity;
+						m_sQueueSample.m_MaxDistance = CRANE_MAX_DIST;
 						m_sQueueSample.m_bStatic = FALSE;
 						m_sQueueSample.m_nFramesToPlay = 3;
 						SET_SOUND_REVERB(TRUE);
 						SET_SOUND_REFLECTION(FALSE);
 						AddSampleToRequestedQueue();
 					}
-					if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_AudioEvents) {
+					if (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_AudioEvents > 0) {
 						m_sQueueSample.m_nCounter = 1;
 						m_sQueueSample.m_nSampleIndex = SFX_COL_CAR_2;
 						m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_COL_CAR_2);
@@ -9238,51 +9365,50 @@ cAudioManager::ProcessCrane()
 void
 cAudioManager::ProcessProjectiles()
 {
-	uint8 emittingVol;
-	float distSquared;
+	uint8 Vol;
 
 	for (uint8 i = 0; i < NUM_PROJECTILES; i++) {
 		if (CProjectileInfo::GetProjectileInfo(i)->m_bInUse) {
 			switch (CProjectileInfo::GetProjectileInfo(i)->m_eWeaponType) {
 			case WEAPONTYPE_TEARGAS:
-				emittingVol = 80;
-				m_sQueueSample.m_MaxDistance = 40.0f;
+				Vol = PROJECTILE_TEARGAS_VOLUME;
+				m_sQueueSample.m_MaxDistance = PROJECTILE_TEARGAS_MAX_DIST;
 				m_sQueueSample.m_nSampleIndex = SFX_PALM_TREE_LO;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nFrequency = 13879;
 				m_sQueueSample.m_nPriority = 7;
 				break;
-			case WEAPONTYPE_MOLOTOV:
-				emittingVol = 50;
-				m_sQueueSample.m_MaxDistance = 30.0f;
-				m_sQueueSample.m_nSampleIndex = SFX_PED_ON_FIRE;
-				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-				m_sQueueSample.m_nFrequency = 32 * SampleManager.GetSampleBaseFrequency(SFX_PED_ON_FIRE) / 25;
-				m_sQueueSample.m_nPriority = 7;
-				break;
 			case WEAPONTYPE_ROCKET:
-				emittingVol = 127;
-				m_sQueueSample.m_MaxDistance = 90.0f;
+				Vol = PROJECTILE_ROCKET_VOLUME;
+				m_sQueueSample.m_MaxDistance = PROJECTILE_ROCKET_MAX_DIST;
 				m_sQueueSample.m_nSampleIndex = SFX_ROCKET_FLY;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ROCKET_FLY);
 				m_sQueueSample.m_nPriority = 3;
 				break;
+			case WEAPONTYPE_MOLOTOV:
+				Vol = PROJECTILE_MOLOTOV_VOLUME;
+				m_sQueueSample.m_MaxDistance = PROJECTILE_MOLOTOV_MAX_DIST;
+				m_sQueueSample.m_nSampleIndex = SFX_PED_ON_FIRE;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_nFrequency = 32 * SampleManager.GetSampleBaseFrequency(SFX_PED_ON_FIRE) / 25;
+				m_sQueueSample.m_nPriority = 7;
+				break;
 			default:
-				return;
+				continue;
 			}
 			m_sQueueSample.m_fSpeedMultiplier = 4.0f;
 			m_sQueueSample.m_nFramesToPlay = 3;
 			m_sQueueSample.m_vecPos = CProjectileInfo::ms_apProjectile[i]->GetPosition();
-			distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
+			float distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
 			if (distSquared < SQR(m_sQueueSample.m_MaxDistance)) {
 				m_sQueueSample.m_fDistance = Sqrt(distSquared);
-				m_sQueueSample.m_nVolume = ComputeVolume(emittingVol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
+				m_sQueueSample.m_nVolume = ComputeVolume(Vol, m_sQueueSample.m_MaxDistance, m_sQueueSample.m_fDistance);
 				if (m_sQueueSample.m_nVolume > 0) {
 					m_sQueueSample.m_nCounter = i;
 					m_sQueueSample.m_bIs2D = FALSE;
 					m_sQueueSample.m_nLoopCount = 0;
-					SET_EMITTING_VOLUME(emittingVol);
+					SET_EMITTING_VOLUME(Vol);
 					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 					m_sQueueSample.m_bStatic = FALSE;
 					SET_SOUND_REVERB(TRUE);
@@ -9297,9 +9423,6 @@ cAudioManager::ProcessProjectiles()
 void
 cAudioManager::ProcessEscalators()
 {
-	const float SOUND_INTENSITY = 30.0f;
-	const uint8 EMITTING_VOLUME = 26;
-
 	float distance;
 
 	for (int i = 0; i < CEscalators::NumEscalators; i++) {
@@ -9307,9 +9430,9 @@ cAudioManager::ProcessEscalators()
 			continue;
 		m_sQueueSample.m_vecPos = CEscalators::GetEscalator(i).GetPosition();
 		distance = GetDistanceSquared(m_sQueueSample.m_vecPos);
-		if (distance < SQR(SOUND_INTENSITY)) {
+		if (distance < SQR(ESCALATOR_MAX_DIST)) {
 			m_sQueueSample.m_fDistance = Sqrt(distance);
-			m_sQueueSample.m_nVolume = ComputeVolume(EMITTING_VOLUME, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
+			m_sQueueSample.m_nVolume = ComputeVolume(ESCALATOR_VOLUME, ESCALATOR_MAX_DIST, m_sQueueSample.m_fDistance);
 			if (m_sQueueSample.m_nVolume > 0) {
 				m_sQueueSample.m_nSampleIndex = SFX_BOAT_V12_LOOP;
 				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
@@ -9317,11 +9440,11 @@ cAudioManager::ProcessEscalators()
 				m_sQueueSample.m_nPriority = 3;
 				m_sQueueSample.m_fSpeedMultiplier = 3.0f;
 				m_sQueueSample.m_nFramesToPlay = 5;
-				m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+				m_sQueueSample.m_MaxDistance = ESCALATOR_MAX_DIST;
 				m_sQueueSample.m_nCounter = i;
 				m_sQueueSample.m_bIs2D = FALSE;
 				m_sQueueSample.m_nLoopCount = 0;
-				SET_EMITTING_VOLUME(EMITTING_VOLUME);
+				SET_EMITTING_VOLUME(ESCALATOR_VOLUME);
 				SET_LOOP_OFFSETS(SFX_BOAT_V12_LOOP)
 				SET_SOUND_REVERB(TRUE);
 				m_sQueueSample.m_bStatic = FALSE;
@@ -9338,44 +9461,41 @@ CVector aVecExtraSoundPosition[] = { CVector(-1042.546f, 88.794f, 11.324f), CVec
 void 
 cAudioManager::ProcessExtraSounds()
 {
-	//const float SOUND_INTENSITY = 18.0f;
-	//const uint8 EMITTING_VOLUME = 50;
-
-	//float distance;
-
-	//for (int i = 0; i < ARRAY_SIZE(aVecExtraSoundPosition); i++) {
-	//	m_sQueueSample.m_vecPos = aVecExtraSoundPosition[i];
-	//	distance = GetDistanceSquared(m_sQueueSample.m_vecPos);
-	//	if (distance < SQR(SOUND_INTENSITY)) {
-	//		m_sQueueSample.m_fDistance = Sqrt(distance);
-	//		m_sQueueSample.m_nVolume = ComputeVolume(EMITTING_VOLUME, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
-	//		if (m_sQueueSample.m_nVolume > 0) {
-	//			m_sQueueSample.m_nCounter = i;
-	//			m_sQueueSample.m_nSampleIndex = SFX_ARCADE;
-	//			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
-	//			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ARCADE);
-	//			m_sQueueSample.m_bIs2D = FALSE;
-	//			m_sQueueSample.m_nLoopCount = 0;
-	//			m_sQueueSample.m_bStatic = FALSE;
-	//			m_sQueueSample.m_nPriority = 4;
-	//			m_sQueueSample.m_fSpeedMultiplier = 3.0f;
-	//			SET_EMITTING_VOLUME(EMITTING_VOLUME);
-	//			SET_LOOP_OFFSETS(SFX_ARCADE)
-	//			SET_SOUND_REVERB(TRUE);
-	//			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
-	//			SET_SOUND_REFLECTION(FALSE);
-	//			m_sQueueSample.m_nFramesToPlay = 3;
-	//			AddSampleToRequestedQueue();
-	//		}
-	//	}
-	//}
+/*
+	float distance;
+
+	for (int i = 0; i < ARRAY_SIZE(aVecExtraSoundPosition); i++) {
+		m_sQueueSample.m_vecPos = aVecExtraSoundPosition[i];
+		distance = GetDistanceSquared(m_sQueueSample.m_vecPos);
+		if (distance < SQR(ARCADE_MAX_DIST)) {
+			m_sQueueSample.m_fDistance = Sqrt(distance);
+			m_sQueueSample.m_nVolume = ComputeVolume(ARCADE_VOLUME, ARCADE_MAX_DIST, m_sQueueSample.m_fDistance);
+			if (m_sQueueSample.m_nVolume > 0) {
+				m_sQueueSample.m_nCounter = i;
+				m_sQueueSample.m_nSampleIndex = SFX_ARCADE;
+				m_sQueueSample.m_nBankIndex = SFX_BANK_0;
+				m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_ARCADE);
+				m_sQueueSample.m_bIs2D = FALSE;
+				m_sQueueSample.m_nLoopCount = 0;
+				m_sQueueSample.m_bStatic = FALSE;
+				m_sQueueSample.m_nPriority = 4;
+				m_sQueueSample.m_fSpeedMultiplier = 3.0f;
+				SET_EMITTING_VOLUME(ARCADE_VOLUME);
+				SET_LOOP_OFFSETS(SFX_ARCADE)
+				SET_SOUND_REVERB(TRUE);
+				m_sQueueSample.m_MaxDistance = ARCADE_MAX_DIST;
+				SET_SOUND_REFLECTION(FALSE);
+				m_sQueueSample.m_nFramesToPlay = 3;
+				AddSampleToRequestedQueue();
+			}
+		}
+	}
+*/
 }
 
 void
 cAudioManager::ProcessGarages()
 {
-	const float SOUND_INTENSITY = 80.0f;
-
 	CEntity *entity;
 	uint8 state;
 	uint32 sampleIndex;
@@ -9398,12 +9518,11 @@ cAudioManager::ProcessGarages()
 		m_sQueueSample.m_vecPos = entity->GetPosition();
 		distCalculated = FALSE;
 		distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
-		if (distSquared < SQR(SOUND_INTENSITY)) {
+		if (distSquared < SQR(GARAGES_MAX_DIST)) {
 			state = CGarages::aGarages[i].m_eGarageState;
-			// while is here just to exit prematurely and avoid goto
-			while (state == GS_OPENING || state == GS_CLOSING || state == GS_AFTERDROPOFF) {
+			if (state == GS_OPENING || state == GS_CLOSING || state == GS_AFTERDROPOFF) {
 				CalculateDistance(distCalculated, distSquared);
-				m_sQueueSample.m_nVolume = ComputeVolume(90, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
+				m_sQueueSample.m_nVolume = ComputeVolume(GARAGES_VOLUME, GARAGES_MAX_DIST, m_sQueueSample.m_fDistance);
 				if (m_sQueueSample.m_nVolume > 0) {
 					if (CGarages::aGarages[i].m_eGarageType == GARAGE_CRUSHER) {
 						if (CGarages::aGarages[i].m_eGarageState == GS_AFTERDROPOFF) {
@@ -9413,14 +9532,15 @@ cAudioManager::ProcessGarages()
 								else
 									sampleIndex = m_anRandomTable[2] % 6 + SFX_COL_CAR_PANEL_1;
 								m_sQueueSample.m_nSampleIndex = sampleIndex;
-								m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex) / 2;
-								m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency / 16);
+								m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex) >> 1;
+								m_sQueueSample.m_nFrequency += RandomDisplacement(m_sQueueSample.m_nFrequency >> 4);
 								m_sQueueSample.m_nLoopCount = 1;
 								m_sQueueSample.m_bStatic = TRUE;
 								m_sQueueSample.m_nCounter = iSound++;
 								if (iSound < 32)
 									iSound = 32;
-							} else break; // premature exit to go straight to the for loop
+							} else
+								goto CheckGarageEvents; // premature exit to go straight to the for loop
 						} else {
 							m_sQueueSample.m_nSampleIndex = SFX_FISHING_BOAT_IDLE;
 							m_sQueueSample.m_nFrequency = 6543;
@@ -9443,24 +9563,24 @@ cAudioManager::ProcessGarages()
 					m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 					m_sQueueSample.m_bIs2D = FALSE;
 					m_sQueueSample.m_nPriority = 3;
-					SET_EMITTING_VOLUME(90);
+					SET_EMITTING_VOLUME(GARAGES_VOLUME);
 					SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 					m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-					m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+					m_sQueueSample.m_MaxDistance = GARAGES_MAX_DIST;
 					SET_SOUND_REVERB(TRUE);
 					SET_SOUND_REFLECTION(FALSE);
 					AddSampleToRequestedQueue();
 				}
-				break;
 			}
 		}
+CheckGarageEvents:
 		for (j = 0; j < m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_AudioEvents; j++) {
 			switch (m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_awAudioEvent[j]) {
 			case SOUND_GARAGE_DOOR_CLOSED:
 			case SOUND_GARAGE_DOOR_OPENED:
-				if (distSquared < SQR(SOUND_INTENSITY)) {
+				if (distSquared < SQR(GARAGES_MAX_DIST)) {
 					CalculateDistance(distCalculated, distSquared);
-					m_sQueueSample.m_nVolume = ComputeVolume(60, SOUND_INTENSITY, m_sQueueSample.m_fDistance);
+					m_sQueueSample.m_nVolume = ComputeVolume(GARAGES_DOOR_VOLUME, GARAGES_MAX_DIST, m_sQueueSample.m_fDistance);
 					if (m_sQueueSample.m_nVolume > 0) {
 						if (CGarages::aGarages[i].m_eGarageType == GARAGE_CRUSHER) {
 							m_sQueueSample.m_nSampleIndex = SFX_COL_CAR_PANEL_2;
@@ -9474,9 +9594,9 @@ cAudioManager::ProcessGarages()
 						}
 						m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 						m_sQueueSample.m_nPriority = 4;
-						SET_EMITTING_VOLUME(60);
+						SET_EMITTING_VOLUME(GARAGES_DOOR_VOLUME);
 						m_sQueueSample.m_fSpeedMultiplier = 0.0f;
-						m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+						m_sQueueSample.m_MaxDistance = GARAGES_MAX_DIST;
 						SET_SOUND_REVERB(TRUE); 
 						m_sQueueSample.m_bIs2D = FALSE;
 						m_sQueueSample.m_bStatic = TRUE;
@@ -9500,39 +9620,36 @@ cAudioManager::ProcessGarages()
 void
 cAudioManager::ProcessFireHydrant()
 {
-	const float SOUND_INTENSITY = 35;
-
 	float distSquared;
 	bool8 distCalculated = FALSE;
 
-	m_sQueueSample.m_vecPos = ((CEntity *)m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_pEntity)->GetPosition();
+	m_sQueueSample.m_vecPos = ((CParticleObject*)m_asAudioEntities[m_sQueueSample.m_nEntityIndex].m_pEntity)->GetPosition();
 	distSquared = GetDistanceSquared(m_sQueueSample.m_vecPos);
-	if (distSquared < SQR(SOUND_INTENSITY)) {
+	if (distSquared < SQR(FIRE_HYDRANT_MAX_DIST)) {
 		CalculateDistance(distCalculated, distSquared);
-		m_sQueueSample.m_nVolume = ComputeVolume(40, 35.0f, m_sQueueSample.m_fDistance);
+		m_sQueueSample.m_nVolume = ComputeVolume(FIRE_HYDRANT_VOLUME, FIRE_HYDRANT_MAX_DIST, m_sQueueSample.m_fDistance);
 		if (m_sQueueSample.m_nVolume > 0) {
-			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_TAXI;
-			m_sQueueSample.m_nPriority = 4;
-			m_sQueueSample.m_nFrequency = 15591;
 			m_sQueueSample.m_nCounter = 0;
-			SET_EMITTING_VOLUME(40);
+			m_sQueueSample.m_nSampleIndex = SFX_JUMBO_TAXI;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
 			m_sQueueSample.m_bIs2D = FALSE;
+			m_sQueueSample.m_nPriority = 4;
+			m_sQueueSample.m_nFrequency = 15591;
 			m_sQueueSample.m_nLoopCount = 0;
+			SET_EMITTING_VOLUME(FIRE_HYDRANT_VOLUME);
 			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
-			m_sQueueSample.m_MaxDistance = SOUND_INTENSITY;
+			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+			m_sQueueSample.m_MaxDistance = FIRE_HYDRANT_MAX_DIST;
 			m_sQueueSample.m_bStatic = FALSE;
-			SET_SOUND_REFLECTION(FALSE);
 			m_sQueueSample.m_nFramesToPlay = 3;
-			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
+			SET_SOUND_REVERB(TRUE);
+			SET_SOUND_REFLECTION(FALSE);
 			AddSampleToRequestedQueue();
 		}
 	}
 }
 #ifdef GTA_BRIDGE
 #pragma region BRIDGE
-const int bridgeIntensity = 400;
-
 void
 cAudioManager::ProcessBridge()
 {
@@ -9542,7 +9659,7 @@ cAudioManager::ProcessBridge()
 	if (CBridge::pLiftRoad) {
 		m_sQueueSample.m_vecPos = CBridge::pLiftRoad->GetPosition();
 		dist = GetDistanceSquared(m_sQueueSample.m_vecPos);
-		if (dist < SQR(450.0f)) {
+		if (dist < SQR(BRIDGE_MAX_DIST)) {
 			CalculateDistance(distCalculated, dist);
 			switch (CBridge::State) {
 			case STATE_BRIDGE_LOCKED:
@@ -9566,35 +9683,39 @@ cAudioManager::ProcessBridge()
 void
 cAudioManager::ProcessBridgeWarning()
 {
-	// TODO: LCS
-/*	if (CStats::CommercialPassed && m_sQueueSample.m_fDistance < 450.f) {
-		m_sQueueSample.m_nVolume = ComputeVolume(100, 450.f, m_sQueueSample.m_fDistance);
+/*
+	if (!CStats::CommercialPassed)
+		return;
+
+	if (m_sQueueSample.m_fDistance < BRIDGE_MAX_DIST) {
+		m_sQueueSample.m_nVolume = ComputeVolume(BRIDGE_WARNING_VOLUME, BRIDGE_MAX_DIST, m_sQueueSample.m_fDistance);
 		if (m_sQueueSample.m_nVolume > 0) {
 			m_sQueueSample.m_nCounter = 0;
 			m_sQueueSample.m_nSampleIndex = SFX_BRIDGE_OPEN_WARNING;
-			m_sQueueSample.m_nBankIndex = SAMPLEBANK_EXTRAS;
+			m_sQueueSample.m_nBankIndex = SFX_BANK_GENERIC_EXTRA;
 			m_sQueueSample.m_bIs2D = FALSE;
 			m_sQueueSample.m_nPriority = 1;
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(SFX_BRIDGE_OPEN_WARNING);
 			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(100);
+			SET_EMITTING_VOLUME(BRIDGE_WARNING_VOLUME);
 			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_MaxDistance = 450.0f;
+			m_sQueueSample.m_MaxDistance = BRIDGE_MAX_DIST;
 			m_sQueueSample.m_bStatic = FALSE;
 			m_sQueueSample.m_nFramesToPlay = 8;
 			SET_SOUND_REVERB(FALSE);
 			SET_SOUND_REFLECTION(FALSE);
 			AddSampleToRequestedQueue();
 		}
-	}*/
+	}
+*/
 }
 
 void
 cAudioManager::ProcessBridgeMotor()
 {
-	if (m_sQueueSample.m_fDistance < bridgeIntensity) {
-		m_sQueueSample.m_nVolume = ComputeVolume(MAX_VOLUME, bridgeIntensity, m_sQueueSample.m_fDistance);
+	if (m_sQueueSample.m_fDistance < BRIDGE_MOTOR_MAX_DIST) {
+		m_sQueueSample.m_nVolume = ComputeVolume(BRIDGE_MOTOR_VOLUME, BRIDGE_MOTOR_MAX_DIST, m_sQueueSample.m_fDistance);
 		if (m_sQueueSample.m_nVolume > 0) {
 			m_sQueueSample.m_nCounter = 1;
 			m_sQueueSample.m_nSampleIndex = SFX_FISHING_BOAT_IDLE; // todo check sfx name
@@ -9603,10 +9724,10 @@ cAudioManager::ProcessBridgeMotor()
 			m_sQueueSample.m_nPriority = 1;
 			m_sQueueSample.m_nFrequency = 5500;
 			m_sQueueSample.m_nLoopCount = 0;
-			SET_EMITTING_VOLUME(MAX_VOLUME);
+			SET_EMITTING_VOLUME(BRIDGE_MOTOR_VOLUME);
 			SET_LOOP_OFFSETS(m_sQueueSample.m_nSampleIndex)
 			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_MaxDistance = bridgeIntensity;
+			m_sQueueSample.m_MaxDistance = BRIDGE_MOTOR_MAX_DIST;
 			m_sQueueSample.m_bStatic = FALSE;
 			m_sQueueSample.m_nFramesToPlay = 3;
 			SET_SOUND_REVERB(FALSE);
@@ -9618,18 +9739,24 @@ cAudioManager::ProcessBridgeMotor()
 void
 cAudioManager::ProcessBridgeOneShots()
 {
-	if (CBridge::State == STATE_LIFT_PART_IS_UP && CBridge::OldState == STATE_LIFT_PART_MOVING_UP)
+	float maxDist;
+
+	if (CBridge::State == STATE_LIFT_PART_IS_UP && CBridge::OldState == STATE_LIFT_PART_MOVING_UP) {
+		maxDist = BRIDGE_MOTOR_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_COL_CONTAINER_1;
-	else if (CBridge::State == STATE_LIFT_PART_IS_DOWN && CBridge::OldState == STATE_LIFT_PART_MOVING_DOWN)
+	} else if (CBridge::State == STATE_LIFT_PART_IS_DOWN && CBridge::OldState == STATE_LIFT_PART_MOVING_DOWN) {
+		maxDist = BRIDGE_MOTOR_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_COL_CONTAINER_1;
-	else if (CBridge::State == STATE_LIFT_PART_MOVING_UP && CBridge::OldState == STATE_LIFT_PART_ABOUT_TO_MOVE_UP)
+	} else if (CBridge::State == STATE_LIFT_PART_MOVING_UP && CBridge::OldState == STATE_LIFT_PART_ABOUT_TO_MOVE_UP) {
+		maxDist = BRIDGE_MOTOR_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_COL_CONTAINER_1;
-	else if (CBridge::State == STATE_LIFT_PART_MOVING_DOWN && CBridge::OldState == STATE_LIFT_PART_IS_UP)
+	} else if (CBridge::State == STATE_LIFT_PART_MOVING_DOWN && CBridge::OldState == STATE_LIFT_PART_IS_UP) {
+		maxDist = BRIDGE_MOTOR_MAX_DIST;
 		m_sQueueSample.m_nSampleIndex = SFX_COL_CONTAINER_1;
-	else return;
+	} else return;
 
-	if (m_sQueueSample.m_fDistance < bridgeIntensity) {
-		m_sQueueSample.m_nVolume = ComputeVolume(MAX_VOLUME, bridgeIntensity, m_sQueueSample.m_fDistance);
+	if (m_sQueueSample.m_fDistance < maxDist) {
+		m_sQueueSample.m_nVolume = ComputeVolume(BRIDGE_MOTOR_VOLUME, maxDist, m_sQueueSample.m_fDistance);
 		if (m_sQueueSample.m_nVolume > 0) {
 			m_sQueueSample.m_nCounter = 2;
 			m_sQueueSample.m_nBankIndex = SFX_BANK_0;
@@ -9637,10 +9764,10 @@ cAudioManager::ProcessBridgeOneShots()
 			m_sQueueSample.m_nPriority = 1;
 			m_sQueueSample.m_nFrequency = SampleManager.GetSampleBaseFrequency(m_sQueueSample.m_nSampleIndex);
 			m_sQueueSample.m_nLoopCount = 1;
-			SET_EMITTING_VOLUME(MAX_VOLUME);
+			SET_EMITTING_VOLUME(BRIDGE_MOTOR_VOLUME);
 			RESET_LOOP_OFFSETS
 			m_sQueueSample.m_fSpeedMultiplier = 2.0f;
-			m_sQueueSample.m_MaxDistance = bridgeIntensity;
+			m_sQueueSample.m_MaxDistance = maxDist;
 			m_sQueueSample.m_bStatic = TRUE;
 			SET_SOUND_REVERB(FALSE);
 			SET_SOUND_REFLECTION(FALSE);
@@ -9656,11 +9783,10 @@ bool8 g_bMissionAudioLoadFailed[MISSION_AUDIO_SLOTS];
 
 struct MissionAudioData {
 	const char *m_pName;
-	int32 m_nId;
+	uint32 m_nId;
 };
 
-
-const MissionAudioData MissionAudioNameSfxAssoc[] = {
+Const MissionAudioData MissionAudioNameSfxAssoc[] = {
 	{"JDAISH2", SFX_JD_SHOCKED_2},
 	{"JDAICR2", SFX_JD_CRASH_CAR_2},
 	{"JDAICR1", SFX_JD_CRASH_CAR_1},
@@ -11530,7 +11656,7 @@ const MissionAudioData MissionAudioNameSfxAssoc[] = {
 	{nil, 0}
 };
 
-int32
+uint32
 FindMissionAudioSfx(const char *name)
 {
 	for (uint32 i = 0; MissionAudioNameSfxAssoc[i].m_pName != nil; i++) {
@@ -11570,7 +11696,7 @@ void
 cAudioManager::PreloadMissionAudio(uint8 slot, Const char *name)
 {
 	if (m_bIsInitialised && slot < MISSION_AUDIO_SLOTS) {
-		int32 missionAudioSfx = FindMissionAudioSfx(name);
+		uint32 missionAudioSfx = FindMissionAudioSfx(name);
 		if (missionAudioSfx != NO_SAMPLE) {
 			m_nMissionAudioSampleIndex[slot] = missionAudioSfx;
 			m_nMissionAudioLoadingStatus[slot] = LOADING_STATUS_NOT_LOADED;
@@ -11627,11 +11753,11 @@ cAudioManager::IsMissionAudioSamplePlaying(uint8 slot)
 			return m_nMissionAudioPlayStatus[slot] == PLAY_STATUS_PLAYING;
 		else
 			return TRUE;
-	} else {
-		static int32 cPretendFrame[MISSION_AUDIO_SLOTS] = { 1, 1 };
-
-		return (cPretendFrame[slot]++ % 64) != 0;
 	}
+
+	static uint32 cPretendFrame[MISSION_AUDIO_SLOTS] = { 1, 1 };
+
+	return (cPretendFrame[slot]++ % 64) != 0;
 }
 
 bool8
@@ -11644,7 +11770,7 @@ cAudioManager::IsMissionAudioSampleFinished(uint8 slot)
 			return TRUE;
 	}
 
-	static int32 cPretendFrame[MISSION_AUDIO_SLOTS] = { 1, 1 };
+	static uint32 cPretendFrame[MISSION_AUDIO_SLOTS] = { 1, 1 };
 
 	return (cPretendFrame[slot]++ % 64) == 0;
 }
@@ -11669,7 +11795,7 @@ void
 cAudioManager::ProcessMissionAudioSlot(uint8 slot)
 {
 	float dist;
-	uint8 emittingVol;
+	uint8 Vol;
 	uint8 pan;
 	float distSquared;
 	CVector vec;
@@ -11678,154 +11804,152 @@ cAudioManager::ProcessMissionAudioSlot(uint8 slot)
 	static uint8 nFramesUntilFailedLoad[MISSION_AUDIO_SLOTS] = { 0, 0 };
 	static uint8 nFramesForPretendPlaying[MISSION_AUDIO_SLOTS] = { 0, 0 };
 
-	if (m_nMissionAudioSampleIndex[slot] == NO_SAMPLE) return;
-
-	switch (m_nMissionAudioLoadingStatus[slot]) {
-	case LOADING_STATUS_NOT_LOADED:
-		// TODO: LoadMissionAudio
-		SampleManager.LoadPedComment(m_nMissionAudioSampleIndex[slot]);
-		SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, SampleManager.GetSampleBaseFrequency(m_nMissionAudioSampleIndex[slot]));
-		m_nMissionAudioLoadingStatus[slot] = LOADING_STATUS_LOADED;
-		nFramesUntilFailedLoad[slot] = 0;
-		break;
-	case LOADING_STATUS_LOADED:
-		if (!m_bIsMissionAudioAllowedToPlay[slot])
-			return;
-		if (g_bMissionAudioLoadFailed[slot]) {
-			if (m_bTimerJustReset) {
-				ClearMissionAudio(slot);
-				SampleManager.StopChannel(CHANNEL_POLICE_RADIO);
-				SampleManager.StopChannel(slot + CHANNEL_MISSION_AUDIO_1);
+	if (m_nMissionAudioSampleIndex[slot] != NO_SAMPLE) {
+		switch (m_nMissionAudioLoadingStatus[slot]) {
+		case LOADING_STATUS_NOT_LOADED:
+			// TODO: LoadMissionAudio
+			SampleManager.LoadPedComment(m_nMissionAudioSampleIndex[slot]);
+			SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, SampleManager.GetSampleBaseFrequency(m_nMissionAudioSampleIndex[slot]));
+			m_nMissionAudioLoadingStatus[slot] = LOADING_STATUS_LOADED;
+			nFramesUntilFailedLoad[slot] = 0;
+			break;
+		case LOADING_STATUS_FAILED:
+			if (++nFramesUntilFailedLoad[slot] >= 120) {
 				nFramesForPretendPlaying[slot] = 0;
-				nCheckPlayingDelay[slot] = 0;
+				g_bMissionAudioLoadFailed[slot] = TRUE;
 				nFramesUntilFailedLoad[slot] = 0;
-			} else if (!m_bIsPaused) {
-				if (++nFramesForPretendPlaying[slot] < 90) {
-					m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_PLAYING;
-				} else {
-					m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_FINISHED;
-					m_nMissionAudioSampleIndex[slot] = NO_SAMPLE;
+				m_nMissionAudioLoadingStatus[slot] = LOADING_STATUS_LOADED;
+			}
+			return;
+		default:
+			return;
+		case LOADING_STATUS_LOADED:
+			if (!m_bIsMissionAudioAllowedToPlay[slot])
+				break;
+			if (g_bMissionAudioLoadFailed[slot]) {
+				if (m_bTimerJustReset) {
+					ClearMissionAudio(slot);
+					SampleManager.StopChannel(CHANNEL_POLICE_RADIO);
+					SampleManager.StopChannel(slot + CHANNEL_MISSION_AUDIO_1);
+					nFramesForPretendPlaying[slot] = 0;
+					nCheckPlayingDelay[slot] = 0;
+					nFramesUntilFailedLoad[slot] = 0;
+				} else if (!m_bIsPaused) {
+					if (++nFramesForPretendPlaying[slot] >= 90) {
+						m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_FINISHED;
+						m_nMissionAudioSampleIndex[slot] = NO_SAMPLE;
+					} else
+						m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_PLAYING;
 				}
+				break;
 			}
-			break;
-		}
-		switch (m_nMissionAudioPlayStatus[slot]) {
-		case PLAY_STATUS_STOPPED:
-			if (MissionScriptAudioUsesPoliceChannel(m_nMissionAudioSampleIndex[slot])) {
-				SetMissionScriptPoliceAudio(m_nMissionAudioSampleIndex[slot]);
-			} else {
-				SampleManager.InitialiseChannel(slot + CHANNEL_MISSION_AUDIO_1, m_nMissionAudioSampleIndex[slot], SFX_BANK_PED_COMMENTS);
-				if (m_bIsPaused)
-					SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, 0);
-				else
-					SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, SampleManager.GetSampleBaseFrequency(m_nMissionAudioSampleIndex[slot]));
-				if (m_bIsMissionAudio2D[slot]) {
-					SampleManager.SetChannelVolume(slot + CHANNEL_MISSION_AUDIO_1, 127);
-					SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, 63);
-					if (m_nMissionAudioSampleIndex[slot] == SFX_SFX_CAMERA_LEFT || m_nMissionAudioSampleIndex[slot] == SFX_SFX_AIRHORN_LEFT)
-						SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, 0);
-					else if (m_nMissionAudioSampleIndex[slot] == SFX_SFX_CAMERA_RIGHT || m_nMissionAudioSampleIndex[slot] == SFX_SFX_AIRHORN_RIGHT)
-						SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, 127);
+			switch (m_nMissionAudioPlayStatus[slot]) {
+			case PLAY_STATUS_STOPPED:
+				if (MissionScriptAudioUsesPoliceChannel(m_nMissionAudioSampleIndex[slot]))
+					SetMissionScriptPoliceAudio(m_nMissionAudioSampleIndex[slot]);
+				else {
+					SampleManager.InitialiseChannel(slot + CHANNEL_MISSION_AUDIO_1, m_nMissionAudioSampleIndex[slot], SFX_BANK_PED_COMMENTS);
+					if (m_bIsPaused)
+						SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, 0);
 					else
+						SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, SampleManager.GetSampleBaseFrequency(m_nMissionAudioSampleIndex[slot]));
+					if (m_bIsMissionAudio2D[slot]) {
+						SampleManager.SetChannelVolume(slot + CHANNEL_MISSION_AUDIO_1, 127);
 						SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, 63);
-				} else {
-					distSquared = GetDistanceSquared(m_vecMissionAudioPosition[slot]);
-					if (distSquared >= SQR(80.0f)) {
-						emittingVol = 0;
-						pan = 63;
+						if (m_nMissionAudioSampleIndex[slot] == SFX_SFX_CAMERA_LEFT || m_nMissionAudioSampleIndex[slot] == SFX_SFX_AIRHORN_LEFT)
+							SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, 0);
+						else if (m_nMissionAudioSampleIndex[slot] == SFX_SFX_CAMERA_RIGHT || m_nMissionAudioSampleIndex[slot] == SFX_SFX_AIRHORN_RIGHT)
+							SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, 127);
+						else
+							SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, 63);
 					} else {
-						emittingVol = 127;
-						if (distSquared > 0.0f) {
-							dist = Sqrt(distSquared);
-							emittingVol = ComputeVolume(127, 80.0f, dist);
-						}
-						TranslateEntity(&m_vecMissionAudioPosition[slot], &vec);
-						pan = ComputePan(80.f, &vec);
+						distSquared = GetDistanceSquared(m_vecMissionAudioPosition[slot]);
+						if (distSquared < SQR(MISSION_AUDIO_MAX_DIST)) {
+							if (distSquared > 0.0f) {
+								dist = Sqrt(distSquared);
+								Vol = ComputeVolume(MISSION_AUDIO_VOLUME, MISSION_AUDIO_MAX_DIST, dist);
+							} else
+								Vol = MISSION_AUDIO_VOLUME;
+							TranslateEntity(&m_vecMissionAudioPosition[slot], &vec);
+							pan = ComputePan(MISSION_AUDIO_MAX_DIST, &vec);
+						} else {
+							Vol = 0;
+							pan = 63;
+						} 
+						SampleManager.SetChannelVolume(slot + CHANNEL_MISSION_AUDIO_1, Vol);
+						SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, pan);
 					}
-					SampleManager.SetChannelVolume(slot + CHANNEL_MISSION_AUDIO_1, emittingVol);
-					SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, pan);
+					SampleManager.StartChannel(slot + CHANNEL_MISSION_AUDIO_1);
 				}
-				SampleManager.StartChannel(slot + CHANNEL_MISSION_AUDIO_1);
-			}
-			m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_PLAYING;
-			nCheckPlayingDelay[slot] = 30;
-			break;
-		case PLAY_STATUS_PLAYING:
-			if (m_bTimerJustReset) {
-				ClearMissionAudio(slot);
-				SampleManager.StopChannel(CHANNEL_POLICE_RADIO);
-				SampleManager.StopChannel(slot + CHANNEL_MISSION_AUDIO_1);
+				m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_PLAYING;
+				nCheckPlayingDelay[slot] = 30;
 				break;
-			}
-			if (MissionScriptAudioUsesPoliceChannel(m_nMissionAudioSampleIndex[slot])) {
-				if (!m_bIsPaused) {
-					if (nCheckPlayingDelay[slot]) {
-						--nCheckPlayingDelay[slot];
-					} else if ((g_bMissionAudioLoadFailed[slot] && m_nMissionAudioFramesToPlay[slot]-- == 0) || GetMissionScriptPoliceAudioPlayingStatus() == PLAY_STATUS_FINISHED) {
-						debug("FINISHED PLAYINGXXXXXXXXXXXXX");
+			case PLAY_STATUS_PLAYING:
+				if (m_bTimerJustReset) {
+					ClearMissionAudio(slot);
+					SampleManager.StopChannel(CHANNEL_POLICE_RADIO);
+					SampleManager.StopChannel(slot + CHANNEL_MISSION_AUDIO_1);
+					return;
+				}
+				if (MissionScriptAudioUsesPoliceChannel(m_nMissionAudioSampleIndex[slot])) {
+					if (!m_bIsPaused) {
+						if (nCheckPlayingDelay[slot] > 0) {
+							nCheckPlayingDelay[slot]--;
+						} else if ((g_bMissionAudioLoadFailed[slot] && m_nMissionAudioFramesToPlay[slot]-- == 0) || GetMissionScriptPoliceAudioPlayingStatus() == PLAY_STATUS_FINISHED) {
+							debug("FINISHED PLAYINGXXXXXXXXXXXXX");
+							m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_FINISHED;
+
+							m_nMissionAudioSampleIndex[slot] = NO_SAMPLE;
+							SampleManager.StopChannel(CHANNEL_POLICE_RADIO);
+							m_nMissionAudioFramesToPlay[slot] = 0;
+						}
+					}
+				} else if (m_bIsMissionAudioPlaying[slot]) {
+					if (!SampleManager.GetChannelUsedFlag(slot + CHANNEL_MISSION_AUDIO_1) && !m_bIsPaused && !m_bWasPaused) {
 						m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_FINISHED;
-
 						m_nMissionAudioSampleIndex[slot] = NO_SAMPLE;
-						SampleManager.StopChannel(CHANNEL_POLICE_RADIO);
+						SampleManager.StopChannel(slot + CHANNEL_MISSION_AUDIO_1);
 						m_nMissionAudioFramesToPlay[slot] = 0;
-					}
-				}
-			} else if (m_bIsMissionAudioPlaying[slot]) {
-				if (SampleManager.GetChannelUsedFlag(slot + CHANNEL_MISSION_AUDIO_1) || m_bIsPaused || m_bWasPaused) {
-					if (m_bIsPaused)
-						SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, 0);
-					else
-					{
-						SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, SampleManager.GetSampleBaseFrequency(m_nMissionAudioSampleIndex[slot]));
-						if (!m_bIsMissionAudio2D[slot]) {
-							distSquared = GetDistanceSquared(m_vecMissionAudioPosition[slot]);
-							if (distSquared >= SQR(80.0f)) {
-								emittingVol = 0;
-								pan = 63;
-							} else {
-								emittingVol = 127;
-								if (distSquared > 0.0f) {
-									dist = Sqrt(distSquared);
-									emittingVol = ComputeVolume(127, 80.0f, dist);
-								}
-								TranslateEntity(&m_vecMissionAudioPosition[slot], &vec);
-								pan = ComputePan(80.f, &vec);
+					} else {
+						if (m_bIsPaused)
+							SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, 0);
+						else {
+							SampleManager.SetChannelFrequency(slot + CHANNEL_MISSION_AUDIO_1, SampleManager.GetSampleBaseFrequency(m_nMissionAudioSampleIndex[slot]));
+							if (!m_bIsMissionAudio2D[slot]) {
+								distSquared = GetDistanceSquared(m_vecMissionAudioPosition[slot]);
+								if (distSquared < SQR(MISSION_AUDIO_MAX_DIST)) {
+									if (distSquared > 0.0f) {
+										dist = Sqrt(distSquared);
+										Vol = ComputeVolume(MISSION_AUDIO_VOLUME, MISSION_AUDIO_MAX_DIST, dist);
+									} else
+										Vol = MISSION_AUDIO_VOLUME;
+									TranslateEntity(&m_vecMissionAudioPosition[slot], &vec);
+									pan = ComputePan(MISSION_AUDIO_MAX_DIST, &vec);
+								} else {
+									Vol = 0;
+									pan = 63;
+								} 
+								SampleManager.SetChannelVolume(slot + CHANNEL_MISSION_AUDIO_1, Vol);
+								SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, pan);
 							}
-							SampleManager.SetChannelVolume(slot + CHANNEL_MISSION_AUDIO_1, emittingVol);
-							SampleManager.SetChannelPan(slot + CHANNEL_MISSION_AUDIO_1, pan);
 						}
-					}
+					} 
 				} else {
-					m_nMissionAudioPlayStatus[slot] = PLAY_STATUS_FINISHED;
-					m_nMissionAudioSampleIndex[slot] = NO_SAMPLE;
-					SampleManager.StopChannel(slot + CHANNEL_MISSION_AUDIO_1);
-					m_nMissionAudioFramesToPlay[slot] = 0;
-				}
-			} else {
-				if (m_bIsPaused)
-					break;
-				if (nCheckPlayingDelay[slot]--) {
-					if (!SampleManager.GetChannelUsedFlag(slot + CHANNEL_MISSION_AUDIO_1))
+					if (m_bIsPaused)
 						break;
-					nCheckPlayingDelay[slot] = 0;
+					if (nCheckPlayingDelay[slot]-- > 0) {
+						if (!SampleManager.GetChannelUsedFlag(slot + CHANNEL_MISSION_AUDIO_1))
+							break;
+						nCheckPlayingDelay[slot] = 0;
+					}
+					m_bIsMissionAudioPlaying[slot] = TRUE;
 				}
-				m_bIsMissionAudioPlaying[slot] = TRUE;
+				break;
+			default:
+				break;
 			}
 			break;
-		default:
-			break;
-		}
-		break;
-	case LOADING_STATUS_FAILED:
-		if (++nFramesUntilFailedLoad[slot] >= 120) {
-			nFramesForPretendPlaying[slot] = 0;
-			g_bMissionAudioLoadFailed[slot] = TRUE;
-			nFramesUntilFailedLoad[slot] = 0;
-			m_nMissionAudioLoadingStatus[slot] = LOADING_STATUS_LOADED;
 		}
-		break;
-	default:
-		break;
 	}
 }
 
diff --git a/src/audio/AudioManager.cpp b/src/audio/AudioManager.cpp
index d2b0aa4e..b9970562 100644
--- a/src/audio/AudioManager.cpp
+++ b/src/audio/AudioManager.cpp
@@ -747,9 +747,8 @@ cAudioManager::AddDetailsToRequestedOrderList(uint8 sample)
 			    m_aRequestedQueue[m_nActiveQueue][sample].m_nFinalPriority)
 				break;
 		}
-		if (i < sample) {
+		if (i < sample) 
 			memmove(&m_aRequestedOrderList[m_nActiveQueue][i + 1], &m_aRequestedOrderList[m_nActiveQueue][i], m_nActiveSamples - i - 1);
-		}
 	}
 	m_aRequestedOrderList[m_nActiveQueue][i] = sample;
 }
@@ -770,23 +769,30 @@ cAudioManager::AddReflectionsToRequestedQueue()
 	uint32 oldCounter = m_sQueueSample.m_nCounter;
 	float oldDist = m_sQueueSample.m_fDistance;
 	CVector oldPos = m_sQueueSample.m_vecPos;
+#ifndef USE_TIME_SCALE_FOR_AUDIO
 	if ( CTimer::GetIsSlowMotionActive() ) {
 		emittingVolume = m_sQueueSample.m_nVolume;
 		oldFreq = m_sQueueSample.m_nFrequency;
-	} else {
+	} else
+#endif
 		emittingVolume = (9 * m_sQueueSample.m_nVolume) / 16;
-	}
-	m_sQueueSample.m_MaxDistance /= 2.f;
+	m_sQueueSample.m_MaxDistance /= 2.0f;
 
 	uint32 halfOldFreq = oldFreq >> 1;
 
 	for (uint32 i = 0; i < ARRAY_SIZE(m_afReflectionsDistances); i++) {
+#ifndef USE_TIME_SCALE_FOR_AUDIO
 		if ( CTimer::GetIsSlowMotionActive() )
 			m_afReflectionsDistances[i] = (m_anRandomTable[i % 4] % 3) * 50.f / 8.f;
+#endif
 
 		reflectionDistance = m_afReflectionsDistances[i];
 		if (reflectionDistance > 0.0f && reflectionDistance < 100.f && reflectionDistance < m_sQueueSample.m_MaxDistance) {
+#ifndef USE_TIME_SCALE_FOR_AUDIO
 			m_sQueueSample.m_nReflectionDelay = CTimer::GetIsSlowMotionActive() ? (reflectionDistance * 600.f / 1029.f) : (reflectionDistance * 300.f / 1029.f);
+#else
+			m_sQueueSample.m_nReflectionDelay = reflectionDistance * 300.f / 1029.f;
+#endif
 			if (m_sQueueSample.m_nReflectionDelay > 3) {
 				m_sQueueSample.m_fDistance = m_afReflectionsDistances[i];
 				SET_EMITTING_VOLUME(emittingVolume);
@@ -795,9 +801,12 @@ cAudioManager::AddReflectionsToRequestedQueue()
 				if (m_sQueueSample.m_nVolume > emittingVolume / 16) {
 					m_sQueueSample.m_nCounter = oldCounter + (i + 1) * 256;
 					if (m_sQueueSample.m_nLoopCount > 0) {
+#ifndef USE_TIME_SCALE_FOR_AUDIO
 						if ( CTimer::GetIsSlowMotionActive() ) {
 							m_sQueueSample.m_nFrequency = halfOldFreq + ((halfOldFreq * i) / ARRAY_SIZE(m_afReflectionsDistances));
-						} else {
+						} else
+#endif
+						{
 							noise = RandomDisplacement(m_sQueueSample.m_nFrequency / 32);
 							if (noise > 0)
 								m_sQueueSample.m_nFrequency -= noise;
@@ -979,9 +988,9 @@ cAudioManager::AddReleasingSounds()
 						if (sample.m_nSampleIndex >= SAMPLEBANK_PED_START && sample.m_nSampleIndex <= SAMPLEBANK_PED_END) { // check if it's ped comment
 							uint8 vol;
 							if (CWorld::GetIsLineOfSightClear(TheCamera.GetPosition(), sample.m_vecPos, true, false, false, false, false, false))
-								vol = MAX_VOLUME;
+								vol = PED_COMMENT_VOLUME;
 							else
-								vol = 31;
+								vol = PED_COMMENT_VOLUME_BEHIND_WALL;
 #ifdef EXTERNAL_3D_SOUND
 							sample.m_nEmittingVolume = vol;
 #endif
@@ -997,7 +1006,7 @@ cAudioManager::AddReleasingSounds()
 								if (sample.m_nEmittingVolumeChange > 0)
 									sample.m_nEmittingVolumeChange = volumeDiff * sample.m_nEmittingVolumeChange;
 #endif
-								sample.m_nVolume = Min(127, newVolume);
+								sample.m_nVolume = Min(MAX_VOLUME, newVolume);
 							}
 						}
 						if (sample.m_nVolume == 0)
@@ -1393,6 +1402,41 @@ cAudioManager::GenerateIntegerRandomNumberTable()
 		m_anRandomTable[i] = myrand();
 }
 
+void
+cAudioManager::DirectlyEnqueueSample(uint32 sample, uint8 bank, uint32 counter, uint32 priority, uint32 freq, uint8 volume, uint8 framesToPlay, uint32 notStereo)
+{
+	m_sQueueSample.m_nSampleIndex = sample;
+	m_sQueueSample.m_nBankIndex = bank;
+	m_sQueueSample.m_nCounter = counter;
+	m_sQueueSample.m_nFrequency = freq;
+	m_sQueueSample.m_nVolume = volume;
+	SET_EMITTING_VOLUME(volume);
+	m_sQueueSample.m_nPriority = priority;
+	m_sQueueSample.m_nFramesToPlay = framesToPlay;
+	m_sQueueSample.m_bReflections = FALSE;
+	m_sQueueSample.m_nLoopCount = 0;
+	SET_LOOP_OFFSETS(sample)
+#ifdef FIX_BUGS
+	m_sQueueSample.m_bIs2D = TRUE;
+#else
+	m_sQueueSample.m_bIs2D = FALSE;
+#endif
+	m_sQueueSample.m_bStatic = FALSE;
+	SET_SOUND_REVERB(FALSE);
+#ifdef FIX_BUGS
+	m_sQueueSample.m_nPan = 63;
+	AddSampleToRequestedQueue();
+#else
+	// this is dumb and wrong, what were they thinking?
+	m_sQueueSample.m_nPan = 0;
+	AudioManager.AddSampleToRequestedQueue();
+	if (!notStereo) {
+		m_sQueueSample.m_nPan = 127;
+		AudioManager.AddSampleToRequestedQueue();
+	}
+#endif
+}
+
 #ifdef EXTERNAL_3D_SOUND
 void
 cAudioManager::AdjustSamplesVolume()
diff --git a/src/audio/AudioManager.h b/src/audio/AudioManager.h
index 73920d42..f9472a52 100644
--- a/src/audio/AudioManager.h
+++ b/src/audio/AudioManager.h
@@ -99,10 +99,10 @@ VALIDATE_SIZE(tPedComment, 28);
 class cPedComments
 {
 public:
-	tPedComment m_asPedComments[NUM_PED_COMMENTS_BANKS][NUM_PED_COMMENTS_SLOTS];
-	uint8 m_nIndexMap[NUM_PED_COMMENTS_BANKS][NUM_PED_COMMENTS_SLOTS];
-	uint8 m_nCommentsInBank[NUM_PED_COMMENTS_BANKS];
-	uint8 m_nActiveBank;
+	tPedComment m_aPedCommentQueue[NUM_SOUND_QUEUES][NUM_PED_COMMENTS_SLOTS];
+	uint8 m_aPedCommentOrderList[NUM_SOUND_QUEUES][NUM_PED_COMMENTS_SLOTS];
+	uint8 m_nPedCommentCount[NUM_SOUND_QUEUES];
+	uint8 m_nActiveQueue;
 #ifdef GTA_PC
 	bool8 m_bDelay;
 	uint32 m_nDelayTimer;
@@ -111,14 +111,14 @@ public:
 	cPedComments()
 	{
 		for (int i = 0; i < NUM_PED_COMMENTS_SLOTS; i++)
-			for (int j = 0; j < NUM_PED_COMMENTS_BANKS; j++) {
-				m_asPedComments[j][i].m_nProcess = -1;
-				m_nIndexMap[j][i] = NUM_PED_COMMENTS_SLOTS;
+			for (int j = 0; j < NUM_SOUND_QUEUES; j++) {
+				m_aPedCommentQueue[j][i].m_nProcess = -1;
+				m_aPedCommentOrderList[j][i] = NUM_PED_COMMENTS_SLOTS;
 			}
 
-		for (int i = 0; i < NUM_PED_COMMENTS_BANKS; i++)
-			m_nCommentsInBank[i] = 0;
-		m_nActiveBank = 0;
+		for (int i = 0; i < NUM_SOUND_QUEUES; i++)
+			m_nPedCommentCount[i] = 0;
+		m_nActiveQueue = 0;
 	}
 	void Add(tPedComment *com);
 	void Process();
@@ -359,6 +359,7 @@ public:
 	void ClearActiveSamples();
 	void GenerateIntegerRandomNumberTable();
 	void LoadBankIfNecessary(uint8 bank);
+	void DirectlyEnqueueSample(uint32 sample, uint8 bank, uint32 counter, uint32 priority, uint32 freq, uint8 volume, uint8 framesToPlay, uint32 notStereo = 0);
 
 #ifdef EXTERNAL_3D_SOUND // actually must have been && AUDIO_MSS as well
 	void AdjustSamplesVolume(); // inlined
@@ -381,12 +382,12 @@ public:
 
 	// vehicles
 	void ProcessVehicle(CVehicle *vehicle);
-	void ProcessCarHeli(cVehicleParams &params);
+	bool8 ProcessCarHeli(cVehicleParams &params);
 	void ProcessRainOnVehicle(cVehicleParams &params);
 	bool8 ProcessReverseGear(cVehicleParams &params);
 	void ProcessModelHeliVehicle(cVehicleParams &params);
 	void ProcessModelVehicle(cVehicleParams &params);
-	void ProcessVehicleFlatTyre(cVehicleParams &params);
+	bool8 ProcessVehicleFlatTyre(cVehicleParams &params);
 	bool8 ProcessVehicleRoadNoise(cVehicleParams &params);
 	bool8 ProcessWetRoadNoise(cVehicleParams &params);
 	bool8 ProcessVehicleEngine(cVehicleParams &params);
@@ -663,3 +664,10 @@ public:
 
 
 extern cAudioManager AudioManager;
+
+enum
+{
+	PED_COMMENT_VOLUME = 127,
+	PED_COMMENT_VOLUME_BEHIND_WALL = 31,
+	COLLISION_MAX_DIST = 60,
+};
diff --git a/src/audio/AudioSamples.h b/src/audio/AudioSamples.h
index 41c2e3d4..49e40be4 100644
--- a/src/audio/AudioSamples.h
+++ b/src/audio/AudioSamples.h
@@ -454,12 +454,12 @@ enum eSfxSample
 	SFX_BUILDING_BAR_2,
 	SFX_BUILDING_BAR_3,
 	SFX_BUILDING_BAR_4,
-	SFX_BUILDING_MAL1,
-	SFX_BUILDING_MAL2,
-	SFX_BUILDING_MAL3,
-	SFX_BUILDING_STR1,
-	SFX_BUILDING_STR2,
-	SFX_BUILDING_STR3,
+	SFX_BUILDING_MALIBU_1,
+	SFX_BUILDING_MALIBU_2,
+	SFX_BUILDING_MALIBU_3,
+	SFX_BUILDING_STRIP_1,
+	SFX_BUILDING_STRIP_2,
+	SFX_BUILDING_STRIP_3,
 	SFX_BUILDING_CHURCH,
 	SFX_BUILDING_FAN_1,
 	SFX_BUILDING_FAN_2,
diff --git a/src/audio/PolRadio.cpp b/src/audio/PolRadio.cpp
index 467060fa..fda3aa09 100644
--- a/src/audio/PolRadio.cpp
+++ b/src/audio/PolRadio.cpp
@@ -140,7 +140,7 @@ cAudioManager::ServicePoliceRadio()
 #ifdef FIX_BUGS
 						nLastSeen -= CTimer::GetLogicalFramesPassed();
 #else
-						--nLastSeen;
+						nLastSeen--;
 #endif
 					else {
 						nLastSeen = m_anRandomTable[1] % 1000 + 2000;
@@ -159,12 +159,12 @@ cAudioManager::ServicePoliceRadioChannel(uint8 wantedLevel)
 {
 	bool8 processed = FALSE;
 	uint32 sample;
-	int32 freq;
+	uint32 freq;
 
 	static int cWait = 0;
 	static bool8 bChannelOpen = FALSE;
 	static uint8 bMissionAudioPhysicalPlayingStatus = PLAY_STATUS_STOPPED;
-	static int32 PoliceChannelFreq = 22050;
+	static uint32 PoliceChannelFreq = 22050;
 
 	if (!m_bIsInitialised) return;
 
@@ -268,12 +268,12 @@ cAudioManager::SetupCrimeReport()
 	float quarterX;
 	float quarterY;
 	int i;
-	int32 sampleIndex;
+	uint32 sampleIndex;
 	bool8 processed = FALSE;
 
 	if (MusicManager.m_nMusicMode == MUSICMODE_CUTSCENE) return FALSE;
 
-	if (60 - m_sPoliceRadioQueue.m_nSamplesInQueue <= 9) {
+	if (POLICE_RADIO_QUEUE_MAX_SAMPLES - m_sPoliceRadioQueue.m_nSamplesInQueue <= 9) {
 		AgeCrimes();
 		return TRUE;
 	}
@@ -347,114 +347,114 @@ cAudioManager::SetupCrimeReport()
 	return TRUE;
 }
 
+Const uint32 gCarColourTable[][3] = {
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLACK, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_WHITE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
+	{SFX_POLICE_RADIO_BRIGHT, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, SFX_SFX_POLICE_RADIO_BLUE, SFX_SFX_POLICE_RADIO_GREY},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
+	{NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
+	{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE}
+};
+
 void
 cAudioManager::SetupSuspectLastSeenReport()
 {
 	CVehicle *veh;
 	uint8 color1;
-	int32 main_color;
-	int32 sample;
-
-	int32 color_pre_modifier;
-	int32 color_post_modifier;
-
-	const int32 gCarColourTable[][3] = {
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLACK, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_WHITE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
-		{SFX_POLICE_RADIO_BRIGHT, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, SFX_SFX_POLICE_RADIO_BLUE, SFX_SFX_POLICE_RADIO_GREY},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_RED, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_ORANGE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_YELLOW, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_GREEN, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_BLUE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
-		{NO_SAMPLE, SFX_SFX_POLICE_RADIO_PURPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
-	    {NO_SAMPLE, SFX_SFX_POLICE_RADIO_SILVER, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_LIGHT, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE},
-		{SFX_POLICE_RADIO_DARK, NO_SAMPLE, NO_SAMPLE}
-	};
+	uint32 main_color;
+	uint32 sample;
+
+	uint32 color_pre_modifier;
+	uint32 color_post_modifier;
 
 	if (MusicManager.m_nMusicMode != MUSICMODE_CUTSCENE) {
 		veh = FindVehicleOfPlayer();
@@ -691,7 +691,7 @@ cAudioManager::PlaySuspectLastSeen(float x, float y, float z)
 	float halfY;
 	float quarterX;
 	float quarterY;
-	int32 sample;
+	uint32 sample;
 	bool8 processed = FALSE;
 	CVector vec = CVector(x, y, z);
 
diff --git a/src/audio/sampman.h b/src/audio/sampman.h
index 60a07bbb..b1bef0e6 100644
--- a/src/audio/sampman.h
+++ b/src/audio/sampman.h
@@ -6,10 +6,10 @@
 #define MAX_FREQ DIGITALRATE
 
 struct tSample {
-	int32 nOffset;
+	uint32 nOffset;
 	uint32 nSize;
-	int32 nFrequency;
-	int32 nLoopStart;
+	uint32 nFrequency;
+	uint32 nLoopStart;
 	int32 nLoopEnd;
 };
 
@@ -213,8 +213,8 @@ public:
 
 	int32 _GetPedCommentSlot(uint32 nComment);
 	
-	int32  GetSampleBaseFrequency  (uint32 nSample);
-	int32  GetSampleLoopStartOffset(uint32 nSample);
+	uint32 GetSampleBaseFrequency  (uint32 nSample);
+	uint32 GetSampleLoopStartOffset(uint32 nSample);
 	int32  GetSampleLoopEndOffset  (uint32 nSample);
 	uint32 GetSampleLength         (uint32 nSample);
 	
diff --git a/src/audio/sampman_miles.cpp b/src/audio/sampman_miles.cpp
index 9e412e4a..65cfff01 100644
--- a/src/audio/sampman_miles.cpp
+++ b/src/audio/sampman_miles.cpp
@@ -377,15 +377,15 @@ SetUpDebugBanksInfo()
 	gBankStartOffset[43] = SFX_BUILDING_BAR_2;
 	gBankStartOffset[44] = SFX_BUILDING_BAR_3;
 	gBankStartOffset[45] = SFX_BUILDING_BAR_4;
-	gBankStartOffset[46] = SFX_BUILDING_MAL1;
-	gBankStartOffset[47] = SFX_BUILDING_MAL2;
+	gBankStartOffset[46] = SFX_BUILDING_MALIBU_1;
+	gBankStartOffset[47] = SFX_BUILDING_MALIBU_2;
 	gBankStartOffset[42] = SFX_BUILDING_BAR_1;
-	gBankStartOffset[49] = SFX_BUILDING_STR1;
-	gBankStartOffset[50] = SFX_BUILDING_STR2;
-	gBankStartOffset[51] = SFX_BUILDING_STR3;
+	gBankStartOffset[49] = SFX_BUILDING_STRIP_1;
+	gBankStartOffset[50] = SFX_BUILDING_STRIP_2;
+	gBankStartOffset[51] = SFX_BUILDING_STRIP_3;
 	gBankStartOffset[52] = SFX_BUILDING_CHURCH;
 	gBankStartOffset[53] = SFX_BUILDING_FAN_1;
-	gBankStartOffset[48] = SFX_BUILDING_MAL3;
+	gBankStartOffset[48] = SFX_BUILDING_MALIBU_3;
 	gBankStartOffset[55] = SFX_BUILDING_INSECTS_1;
 	gBankStartOffset[56] = SFX_BUILDING_INSECTS_2;
 	gBankStartOffset[54] = SFX_BUILDING_FAN_2;
@@ -1721,13 +1721,13 @@ cSampleManager::GetBankContainingSound(uint32 offset)
 	return INVALID_SFX_BANK;
 }
 
-int32
+uint32
 cSampleManager::GetSampleBaseFrequency(uint32 nSample)
 {
 	return m_aSamples[nSample].nFrequency;
 }
 
-int32
+uint32
 cSampleManager::GetSampleLoopStartOffset(uint32 nSample)
 {
 	return m_aSamples[nSample].nLoopStart;
diff --git a/src/audio/sampman_null.cpp b/src/audio/sampman_null.cpp
index 627d122b..7cc2d385 100644
--- a/src/audio/sampman_null.cpp
+++ b/src/audio/sampman_null.cpp
@@ -184,14 +184,14 @@ cSampleManager::GetBankContainingSound(uint32 offset)
 	return INVALID_SFX_BANK;
 }
 
-int32
+uint32
 cSampleManager::GetSampleBaseFrequency(uint32 nSample)
 {
 	ASSERT( nSample < TOTAL_AUDIO_SAMPLES );
 	return 0;
 }
 
-int32
+uint32
 cSampleManager::GetSampleLoopStartOffset(uint32 nSample)
 {
 	ASSERT( nSample < TOTAL_AUDIO_SAMPLES );
diff --git a/src/audio/sampman_oal.cpp b/src/audio/sampman_oal.cpp
index 697b5d0b..0f0cc8c8 100644
--- a/src/audio/sampman_oal.cpp
+++ b/src/audio/sampman_oal.cpp
@@ -364,15 +364,15 @@ SetUpDebugBanksInfo()
 	gBankStartOffset[43] = SFX_BUILDING_BAR_2;
 	gBankStartOffset[44] = SFX_BUILDING_BAR_3;
 	gBankStartOffset[45] = SFX_BUILDING_BAR_4;
-	gBankStartOffset[46] = SFX_BUILDING_MAL1;
-	gBankStartOffset[47] = SFX_BUILDING_MAL2;
+	gBankStartOffset[46] = SFX_BUILDING_MALIBU_1;
+	gBankStartOffset[47] = SFX_BUILDING_MALIBU_2;
 	gBankStartOffset[42] = SFX_BUILDING_BAR_1;
-	gBankStartOffset[49] = SFX_BUILDING_STR1;
-	gBankStartOffset[50] = SFX_BUILDING_STR2;
-	gBankStartOffset[51] = SFX_BUILDING_STR3;
+	gBankStartOffset[49] = SFX_BUILDING_STRIP_1;
+	gBankStartOffset[50] = SFX_BUILDING_STRIP_2;
+	gBankStartOffset[51] = SFX_BUILDING_STRIP_3;
 	gBankStartOffset[52] = SFX_BUILDING_CHURCH;
 	gBankStartOffset[53] = SFX_BUILDING_FAN_1;
-	gBankStartOffset[48] = SFX_BUILDING_MAL3;
+	gBankStartOffset[48] = SFX_BUILDING_MALIBU_3;
 	gBankStartOffset[55] = SFX_BUILDING_INSECTS_1;
 	gBankStartOffset[56] = SFX_BUILDING_INSECTS_2;
 	gBankStartOffset[54] = SFX_BUILDING_FAN_2;
@@ -1436,14 +1436,14 @@ cSampleManager::GetBankContainingSound(uint32 offset)
 	return INVALID_SFX_BANK;
 }
 
-int32
+uint32
 cSampleManager::GetSampleBaseFrequency(uint32 nSample)
 {
 	ASSERT( nSample < TOTAL_AUDIO_SAMPLES );
 	return m_aSamples[nSample].nFrequency;
 }
 
-int32
+uint32
 cSampleManager::GetSampleLoopStartOffset(uint32 nSample)
 {
 	ASSERT( nSample < TOTAL_AUDIO_SAMPLES );
diff --git a/src/core/Radar.cpp b/src/core/Radar.cpp
index 6fb28184..b93b7d02 100644
--- a/src/core/Radar.cpp
+++ b/src/core/Radar.cpp
@@ -1573,7 +1573,7 @@ CRadar::ToggleTargetMarker(float x, float y)
 		ms_RadarTrace[nextBlip].m_bDim = 0;
 		ms_RadarTrace[nextBlip].m_bInUse = 1;
 		ms_RadarTrace[nextBlip].m_Radius = 1.0f;
-		CVector pos(x, y, CWorld::FindGroundZForCoord(x,y));
+		CVector pos(x, y, 0.0f);
 		TargetMarkerPos = pos;
 		ms_RadarTrace[nextBlip].m_vec2DPos = pos;
 		ms_RadarTrace[nextBlip].m_vecPos = pos;
diff --git a/src/core/config.h b/src/core/config.h
index b20f85ae..0d29ff58 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -129,7 +129,6 @@ enum Config {
 	NUMINVISIBLEENTITIES = 150,
 
 	NUM_AUDIOENTITY_EVENTS = 4,
-	NUM_PED_COMMENTS_BANKS = 2,
 	NUM_PED_COMMENTS_SLOTS = 20,
 
 	NUM_SOUND_QUEUES = 2,
diff --git a/src/core/re3.cpp b/src/core/re3.cpp
index ca1915b0..4c2b9388 100644
--- a/src/core/re3.cpp
+++ b/src/core/re3.cpp
@@ -47,6 +47,7 @@
 #include "CarCtrl.h"
 #include "Population.h"
 #include "IniFile.h"
+#include "Zones.h"
 
 #include "crossplatform.h"
 
@@ -771,12 +772,14 @@ FixCar(void)
 static void
 TeleportToWaypoint(void)
 {
-	if (FindPlayerVehicle()) {
-		if (CRadar::TargetMarkerId != -1)
-			FindPlayerVehicle()->Teleport(CRadar::TargetMarkerPos + CVector(0.0f, 0.0f, FindPlayerVehicle()->GetColModel()->boundingSphere.center.z));
-	} else
-		if(CRadar::TargetMarkerId != -1)
-			FindPlayerPed()->Teleport(CRadar::TargetMarkerPos + CVector(0.0f, 0.0f, FEET_OFFSET));
+	if (CRadar::TargetMarkerId == -1)
+		return;
+	CEntity* pEntityToTeleport = FindPlayerEntity();
+	CVector vNewPos = CRadar::TargetMarkerPos;
+	CStreaming::LoadScene(vNewPos);
+	CStreaming::LoadSceneCollision(vNewPos);
+	vNewPos.z = CWorld::FindGroundZForCoord(vNewPos.x, vNewPos.y) + pEntityToTeleport->GetDistanceFromCentreOfMassToBaseOfModel();
+	pEntityToTeleport->Teleport(vNewPos);
 }
 #endif
 
diff --git a/src/modelinfo/ModelIndices.h b/src/modelinfo/ModelIndices.h
index b3d3ef41..4cbcffff 100644
--- a/src/modelinfo/ModelIndices.h
+++ b/src/modelinfo/ModelIndices.h
@@ -1091,13 +1091,19 @@ enum
 
 
 	// these indices are original
+	MI_SKIMMER = -1000,
 	MI_CADDY = -999,
+	MI_TROPIC = -992,
+	MI_COASTG = -991,
 	MI_MARQUIS = -990,
+	MI_RIO = -988,
+	MI_DINGHY = -987,
 	MI_SEASPAR = -986,
 	MI_SPARROW = -985,
 	MI_VOODOO = -984,
 	MI_FBIRANCH = -982,
 	MI_SANDKING = -981,
+	MI_SQUALO = -974,
 	MI_PHEONIX = -973,
 	MI_COMET = -972,
 	MI_KAUFMAN = -967,
@@ -1119,13 +1125,9 @@ enum
 	MI_VIRGO,
 	MI_GREENWOO,
 
-	// 25 of the following MIs originally are in this set:
-	// {-1000, -997, -995, -994, -993, -991, -989, -987, -983, -980, -976, -974, -971, -970, -968, -966, -965, -964, -963, -962, -961, -960, -959, -958, -957, -956}
-	MI_SQUALO = -2000,
-	MI_JETMAX,
-	MI_COASTG,
-	MI_DINGHY,
-	MI_SKIMMER,
+	// 22 of the following MIs originally are in this set:
+	// {-997, -995, -994, -993, -989, -983, -980, -976, -971, -970, -968, -966, -965, -964, -963, -962, -961, -960, -959, -958, -957, -956}
+	MI_JETMAX = -2000,
 	MI_CUBAN,
 	MI_RANCHER,
 	MI_BLISTAC,
diff --git a/src/peds/EmergencyPed.cpp b/src/peds/EmergencyPed.cpp
index 954c1c79..0257d291 100644
--- a/src/peds/EmergencyPed.cpp
+++ b/src/peds/EmergencyPed.cpp
@@ -206,7 +206,7 @@ CEmergencyPed::MedicAI(void)
 				if (!waitUntilMedicEntersCar) {
 					CCarCtrl::JoinCarWithRoadSystem(m_pMyVehicle);
 					m_pMyVehicle->AutoPilot.m_nCarMission = MISSION_CRUISE;
-					m_pMyVehicle->m_bSirenOrAlarm = 0;
+					m_pMyVehicle->m_bSirenOrAlarm = false;
 					m_pMyVehicle->AutoPilot.m_nCruiseSpeed = 12;
 					m_pMyVehicle->AutoPilot.m_nDrivingStyle = DRIVINGSTYLE_SLOW_DOWN_FOR_CARS;
 					if (m_pMyVehicle->bIsAmbulanceOnDuty) {
diff --git a/src/peds/Ped.h b/src/peds/Ped.h
index d1d08c2f..f415b386 100644
--- a/src/peds/Ped.h
+++ b/src/peds/Ped.h
@@ -822,8 +822,10 @@ public:
 	void RestorePreviousObjective(void);
 	void SetIdle(void);
 #ifdef _MSC_VER
+#if _MSC_VER >= 1920 && _MSC_VER < 1929
 	__declspec(noinline) // workaround for a compiler bug, hooray MS :P
 #endif
+#endif
 	void SetObjective(eObjective, void*);
 	void SetObjective(eObjective);
 	void SetObjective(eObjective, int16, int16);
diff --git a/src/vehicles/Boat.cpp b/src/vehicles/Boat.cpp
index 416f2aa0..cf46f37b 100644
--- a/src/vehicles/Boat.cpp
+++ b/src/vehicles/Boat.cpp
@@ -1139,8 +1139,8 @@ CBoat::RenderWaterOutPolys(void)
 		RwIm3DVertexSetPos(&KeepWaterOutVertices[3],  1.3f, -2.832f, 0.51f);
 		break;
 	case MI_SQUALO:
-		RwIm3DVertexSetPos(&KeepWaterOutVertices[0], -1.222f,  2.004f, 0.846f);
-		RwIm3DVertexSetPos(&KeepWaterOutVertices[1],  1.222f,  2.004f, 0.846f);
+		RwIm3DVertexSetPos(&KeepWaterOutVertices[0], -1.222f,  2.004f, 1.409f);
+		RwIm3DVertexSetPos(&KeepWaterOutVertices[1],  1.222f,  2.004f, 1.409f);
 		RwIm3DVertexSetPos(&KeepWaterOutVertices[2], -1.24f,  -1.367f, 0.846f);
 		RwIm3DVertexSetPos(&KeepWaterOutVertices[3],  1.24f,  -1.367f, 0.846f);
 		break;
diff --git a/src/vehicles/Ferry.cpp b/src/vehicles/Ferry.cpp
index 89a0de9f..339c2819 100644
--- a/src/vehicles/Ferry.cpp
+++ b/src/vehicles/Ferry.cpp
@@ -14,6 +14,7 @@
 #include "TempColModels.h"
 #include "WaterLevel.h"
 #include "World.h"
+#include "sampman.h"
 
 CFerryInst* CFerry::mspInst;
 
@@ -706,7 +707,7 @@ void CFerry::OpenDoor(void)
 	m_bUseFrontDoor = true;
 	if (fDistToCar4 < fDistToCar1)
 		m_bUseFrontDoor = false;
-	// AudioManager.DirectlyEnqueueSample(0xb8,0,0,1,0x5622,0x7f,0x14,0); // TODO
+	AudioManager.DirectlyEnqueueSample(SFX_GATE_START_CLU, SFX_BANK_0, 0, 1, 22050, 127, 20);
 }
 
 void CFerry::CloseDoor(void)
@@ -714,7 +715,7 @@ void CFerry::CloseDoor(void)
 	printf("closing the ferry door\n");
 	m_nDoorState = FERRY_DOOR_CLOSING;
 	m_nDoorTimer = CTimer::GetTimeInMilliseconds() + 10000;
-	// AudioManager.DirectlyEnqueueSample(0xb8, 0, 0, 1, 0x5622, 0x7f, 0x14, 0); // TODO
+	AudioManager.DirectlyEnqueueSample(SFX_GATE_START_CLU, SFX_BANK_0, 0, 1, 22050, 127, 20); // shouldn't this be SFX_GATE_STOP_CLU?
 }
 
 bool CFerry::IsDoorOpen(void)
@@ -798,7 +799,7 @@ void CFerry::PlayArrivedHorn(void)
 	float fDistToCamera = (GetPosition() - TheCamera.GetPosition()).Magnitude();
 	if (fDistToCamera < 200.0f) {
 		uint8 volume = (200.0f - fDistToCamera) / 200.0f * 127;
-		// AudioManager.DirectlyEnqueueSample(0x32, 0, 0, 1, 18000, volume, 0x32, 0); // TODO
+		AudioManager.DirectlyEnqueueSample(SFX_CAR_HORN_TRUCK, SFX_BANK_0, 0, 1, 18000, volume, 50);
 	}
 }
 
diff --git a/src/vehicles/Vehicle.h b/src/vehicles/Vehicle.h
index 763bd56e..7be4e563 100644
--- a/src/vehicles/Vehicle.h
+++ b/src/vehicles/Vehicle.h
@@ -277,7 +277,7 @@ public:
 	uint8 m_vehLCS_2A4;	// some timer
 	uint32 m_nCarHornTimer;
 	uint8 m_nCarHornPattern;
-	uint8 m_bSirenOrAlarm;
+	bool m_bSirenOrAlarm;
 	uint8 m_nCarHornDelay;
 	int8 m_comedyControlState;
 	int32 m_vehLCS_2B0;