using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib;
using BoneLib.BoneMenu;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using Resonix;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Main), "Resonix", "2.0.0", "Clifnite", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Resonix")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Resonix")]
[assembly: AssemblyTitle("Resonix")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Resonix
{
	public static class Classifier
	{
		public static SoundKind Classify(string source, string clip)
		{
			string n = (source + "|" + clip).ToLowerInvariant();
			if (Has(n, "fusion", "voicechat", "voice chat", "voip", "microphone", "remoteplayer"))
			{
				return SoundKind.FusionVoice;
			}
			if (Has(n, "npc", "voice", "dialog", "speech", "talk", "ford", "nullbody"))
			{
				return SoundKind.NpcVoice;
			}
			if (Has(n, "gun", "shot", "firearm", "rifle", "pistol", "smg", "shotgun", "revolver"))
			{
				return SoundKind.Gunshot;
			}
			if (Has(n, "explosion", "explode", "blast", "grenade"))
			{
				return SoundKind.Explosion;
			}
			if (Has(n, "impact", "hit", "collision", "ricochet", "thud"))
			{
				return SoundKind.Impact;
			}
			if (Has(n, "foot", "step", "walk", "run"))
			{
				return SoundKind.Footstep;
			}
			if (Has(n, "reload", "slide", "bolt", "mechan", "mag"))
			{
				return SoundKind.Mechanical;
			}
			if (Has(n, "music", "song", "radio"))
			{
				return SoundKind.Music;
			}
			if (Has(n, "ambient", "ambience", "wind", "hum"))
			{
				return SoundKind.Ambient;
			}
			return SoundKind.Unknown;
		}

		private static bool Has(string n, params string[] terms)
		{
			foreach (string value in terms)
			{
				if (n.Contains(value))
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class Config
	{
		public static MelonPreferences_Category Category;

		public static MelonPreferences_Entry<bool> Enabled;

		public static MelonPreferences_Entry<bool> GunVariation;

		public static MelonPreferences_Entry<bool> ImpactVariation;

		public static MelonPreferences_Entry<bool> VoiceOverhaul;

		public static MelonPreferences_Entry<bool> NpcVoices;

		public static MelonPreferences_Entry<bool> FusionVoices;

		public static MelonPreferences_Entry<bool> Occlusion;

		public static MelonPreferences_Entry<bool> HearingResponse;

		public static MelonPreferences_Entry<bool> DistanceAudio;

		public static MelonPreferences_Entry<bool> EnvironmentAudio;

		public static MelonPreferences_Entry<bool> FusionSafeMode;

		public static MelonPreferences_Entry<float> GunPitchVariation;

		public static MelonPreferences_Entry<float> GunVolumeVariation;

		public static MelonPreferences_Entry<float> GunLoudness;

		public static MelonPreferences_Entry<float> GunRange;

		public static MelonPreferences_Entry<float> VoiceOcclusion;

		public static MelonPreferences_Entry<float> WorldOcclusion;

		public static MelonPreferences_Entry<float> HearingStrength;

		public static MelonPreferences_Entry<float> HearingRecovery;

		public static void Initialize()
		{
			Category = MelonPreferences.CreateCategory("Resonix2");
			Enabled = Category.CreateEntry<bool>("Enabled", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			GunVariation = Category.CreateEntry<bool>("GunVariation", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			ImpactVariation = Category.CreateEntry<bool>("ImpactVariation", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			VoiceOverhaul = Category.CreateEntry<bool>("VoiceOverhaul", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			NpcVoices = Category.CreateEntry<bool>("NpcVoices", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			FusionVoices = Category.CreateEntry<bool>("FusionVoices", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			Occlusion = Category.CreateEntry<bool>("Occlusion", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			HearingResponse = Category.CreateEntry<bool>("HearingResponse", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			DistanceAudio = Category.CreateEntry<bool>("DistanceAudio", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			EnvironmentAudio = Category.CreateEntry<bool>("EnvironmentAudio", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			FusionSafeMode = Category.CreateEntry<bool>("FusionSafeMode", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			GunPitchVariation = Category.CreateEntry<float>("GunPitchVariation", 0.085f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			GunVolumeVariation = Category.CreateEntry<float>("GunVolumeVariation", 0.05f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			GunLoudness = Category.CreateEntry<float>("GunLoudness", 0.92f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			GunRange = Category.CreateEntry<float>("GunRange", 95f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			VoiceOcclusion = Category.CreateEntry<float>("VoiceOcclusion", 0.72f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			WorldOcclusion = Category.CreateEntry<float>("WorldOcclusion", 0.55f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			HearingStrength = Category.CreateEntry<float>("HearingStrength", 0.68f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			HearingRecovery = Category.CreateEntry<float>("HearingRecovery", 3.5f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
			MelonPreferences.Save();
		}
	}
	public static class FusionBridge
	{
		public static bool Loaded { get; private set; }

		public static void Refresh()
		{
			try
			{
				Loaded = AppDomain.CurrentDomain.GetAssemblies().Any((Assembly a) => (a.GetName().Name ?? "").IndexOf("Fusion", StringComparison.OrdinalIgnoreCase) >= 0);
			}
			catch
			{
				Loaded = false;
			}
		}
	}
	public static class GunSoundSystem
	{
		public static int ShotChanges { get; private set; }

		public static void Process(AudioSource source, SourceState state, SoundKind kind)
		{
			if (!Config.GunVariation.Value || (Object)(object)source == (Object)null || state == null || kind != SoundKind.Gunshot)
			{
				return;
			}
			int num = (((Object)(object)source.clip != (Object)null) ? ((Object)source.clip).GetInstanceID() : 0);
			int num2 = 0;
			try
			{
				num2 = source.timeSamples;
			}
			catch
			{
			}
			if (source.isPlaying && (!state.LastPlaying || state.LastClipId != num || num2 + 256 < state.LastTimeSamples))
			{
				float num3 = Mathf.Clamp(Config.GunPitchVariation.Value, 0f, 0.18f);
				float num4 = Mathf.Clamp(Config.GunVolumeVariation.Value, 0f, 0.12f);
				float num5 = Mathf.Clamp01(Config.GunLoudness.Value);
				source.pitch = Mathf.Clamp(state.OriginalPitch + Random.Range(0f - num3, num3), 0.78f, 1.22f);
				float num6 = Mathf.Clamp01(state.OriginalVolume + Random.Range(0f - num4, num4));
				source.volume = Mathf.Lerp(num6, 1f, num5);
				if (source.spatialBlend > 0.1f && Config.DistanceAudio.Value)
				{
					source.maxDistance = Mathf.Max(state.OriginalMaxDistance, Mathf.Clamp(Config.GunRange.Value, 20f, 150f));
					source.minDistance = Mathf.Max(state.OriginalMinDistance, Mathf.Lerp(1f, 3.2f, num5));
				}
				ShotChanges++;
			}
			state.LastPlaying = source.isPlaying;
			state.LastClipId = num;
			state.LastTimeSamples = num2;
		}

		public static void Reset()
		{
			ShotChanges = 0;
		}
	}
	public static class HearingSystem
	{
		private static float _shock;

		private static float _baseVolume = 1f;

		public static float Shock => _shock;

		public static void Initialize()
		{
			try
			{
				_baseVolume = AudioListener.volume;
			}
			catch
			{
				_baseVolume = 1f;
			}
		}

		public static void Observe(AudioSource source, SoundKind kind, float distance)
		{
			if (Config.HearingResponse.Value && !((Object)(object)source == (Object)null))
			{
				float num = ((kind == SoundKind.Explosion) ? 0.95f : ((kind == SoundKind.Gunshot) ? 0.78f : ((kind == SoundKind.Impact && source.volume > 0.75f) ? 0.12f : 0f)));
				if (!(num <= 0f))
				{
					float num2 = ((kind == SoundKind.Gunshot) ? Mathf.Clamp(Config.GunRange.Value * 0.25f, 10f, 30f) : 14f);
					num *= Mathf.Clamp01(1f - distance / num2) * Mathf.Clamp01(Config.HearingStrength.Value);
					_shock = Mathf.Max(_shock, num);
				}
			}
		}

		public static void Tick()
		{
			float num = Mathf.Max(0.5f, Config.HearingRecovery.Value);
			_shock = Mathf.MoveTowards(_shock, 0f, Time.deltaTime / num);
			try
			{
				AudioListener.volume = Mathf.Lerp(_baseVolume, _baseVolume * 0.3f, _shock);
			}
			catch
			{
			}
		}

		public static void Test()
		{
			_shock = Mathf.Max(_shock, 0.75f);
		}

		public static void Reset()
		{
			_shock = 0f;
			try
			{
				AudioListener.volume = _baseVolume;
			}
			catch
			{
			}
		}
	}
	public static class ImpactSystem
	{
		public static void Process(AudioSource source, SourceState state, SoundKind kind)
		{
			if (Config.ImpactVariation.Value && !((Object)(object)source == (Object)null) && state != null && kind == SoundKind.Impact && source.isPlaying && !state.LastPlaying)
			{
				source.pitch = Mathf.Clamp(state.OriginalPitch + Random.Range(-0.035f, 0.035f), 0.85f, 1.15f);
			}
		}
	}
	public sealed class Main : MelonMod
	{
		public override void OnInitializeMelon()
		{
			Config.Initialize();
			Runtime.Initialize();
			Menu.Build();
			MelonLogger.Msg("[Resonix] 2.0 full BONELAB audio overhaul initialized.");
		}

		public override void OnUpdate()
		{
			if (Config.Enabled.Value)
			{
				Runtime.Tick();
			}
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			Runtime.Reset();
		}
	}
	public static class Menu
	{
		public static void Build()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			Page obj = Page.Root.CreatePage("Resonix", new Color(0.55f, 0.85f, 1f), 0, true);
			obj.CreateBool("Enabled", Color.green, Config.Enabled.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.Enabled, v);
			});
			Page obj2 = obj.CreatePage("Gun Audio", Color.white, 0, true);
			obj2.CreateBool("Per-Shot Variation", Color.white, Config.GunVariation.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.GunVariation, v);
			});
			obj2.CreateFloat("Pitch Variation", Color.white, Config.GunPitchVariation.Value, 0.005f, 0f, 0.18f, (Action<float>)delegate(float v)
			{
				Save(Config.GunPitchVariation, v);
			});
			obj2.CreateFloat("Volume Variation", Color.white, Config.GunVolumeVariation.Value, 0.005f, 0f, 0.12f, (Action<float>)delegate(float v)
			{
				Save(Config.GunVolumeVariation, v);
			});
			obj2.CreateFloat("Gun Loudness", Color.white, Config.GunLoudness.Value, 0.05f, 0.25f, 1f, (Action<float>)delegate(float v)
			{
				Save(Config.GunLoudness, v);
			});
			obj2.CreateFloat("Gun Range", Color.white, Config.GunRange.Value, 5f, 20f, 150f, (Action<float>)delegate(float v)
			{
				Save(Config.GunRange, v);
			});
			Page obj3 = obj.CreatePage("Voices", Color.cyan, 0, true);
			obj3.CreateBool("Voice Overhaul", Color.white, Config.VoiceOverhaul.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.VoiceOverhaul, v);
			});
			obj3.CreateBool("NPC Voices", Color.white, Config.NpcVoices.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.NpcVoices, v);
			});
			obj3.CreateBool("Fusion Player Voices", Color.white, Config.FusionVoices.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.FusionVoices, v);
			});
			obj3.CreateFloat("Voice Occlusion", Color.white, Config.VoiceOcclusion.Value, 0.05f, 0f, 1f, (Action<float>)delegate(float v)
			{
				Save(Config.VoiceOcclusion, v);
			});
			Page obj4 = obj.CreatePage("World Acoustics", Color.green, 0, true);
			obj4.CreateBool("Door / Wall Muffling", Color.white, Config.Occlusion.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.Occlusion, v);
			});
			obj4.CreateBool("Distance Audio", Color.white, Config.DistanceAudio.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.DistanceAudio, v);
			});
			obj4.CreateBool("Environment Audio", Color.white, Config.EnvironmentAudio.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.EnvironmentAudio, v);
			});
			obj4.CreateBool("Impact Variation", Color.white, Config.ImpactVariation.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.ImpactVariation, v);
			});
			obj4.CreateFloat("World Occlusion", Color.white, Config.WorldOcclusion.Value, 0.05f, 0f, 1f, (Action<float>)delegate(float v)
			{
				Save(Config.WorldOcclusion, v);
			});
			Page obj5 = obj.CreatePage("Hearing", Color.yellow, 0, true);
			obj5.CreateBool("Hearing Response", Color.white, Config.HearingResponse.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.HearingResponse, v);
			});
			obj5.CreateFloat("Hearing Strength", Color.white, Config.HearingStrength.Value, 0.05f, 0f, 1f, (Action<float>)delegate(float v)
			{
				Save(Config.HearingStrength, v);
			});
			obj5.CreateFloat("Recovery Time", Color.white, Config.HearingRecovery.Value, 0.25f, 0.5f, 10f, (Action<float>)delegate(float v)
			{
				Save(Config.HearingRecovery, v);
			});
			obj5.CreateFunction("Test Hearing Effect", Color.white, (Action)HearingSystem.Test);
			Page obj6 = obj.CreatePage("Compatibility", Color.magenta, 0, true);
			obj6.CreateBool("Fusion Safe Mode", Color.white, Config.FusionSafeMode.Value, (Action<bool>)delegate(bool v)
			{
				Save(Config.FusionSafeMode, v);
			});
			obj6.CreateFunction("Print Audio Report", Color.white, (Action)Report.Print);
		}

		private static void Save(MelonPreferences_Entry<bool> e, bool v)
		{
			e.Value = v;
			MelonPreferences.Save();
		}

		private static void Save(MelonPreferences_Entry<float> e, float v)
		{
			e.Value = v;
			MelonPreferences.Save();
		}
	}
	public static class OcclusionSystem
	{
		public static void Process(AudioSource source, SourceState state, SoundKind kind, Transform listener)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (!Config.Occlusion.Value || (Object)(object)source == (Object)null || state == null || (Object)(object)listener == (Object)null || kind == SoundKind.Music)
			{
				return;
			}
			Vector3 val = ((Component)source).transform.position - listener.position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.35f)
			{
				state.Occlusion = Mathf.MoveTowards(state.Occlusion, 0f, 0.2f);
				return;
			}
			bool flag = false;
			try
			{
				RaycastHit val2 = default(RaycastHit);
				flag = Physics.Raycast(listener.position, ((Vector3)(ref val)).normalized, ref val2, magnitude, -1, (QueryTriggerInteraction)1);
			}
			catch
			{
			}
			float num = (flag ? 1f : 0f);
			state.Occlusion = Mathf.MoveTowards(state.Occlusion, num, 0.18f);
			if (!(state.Occlusion <= 0.01f))
			{
				bool flag2 = kind == SoundKind.NpcVoice || kind == SoundKind.FusionVoice;
				float num2 = (flag2 ? Mathf.Clamp01(Config.VoiceOcclusion.Value) : Mathf.Clamp01(Config.WorldOcclusion.Value));
				float num3 = Mathf.Lerp(1f, flag2 ? 0.36f : 0.55f, state.Occlusion * num2);
				source.volume *= num3;
				if (flag2)
				{
					source.pitch = Mathf.Lerp(source.pitch, Mathf.Clamp(state.OriginalPitch * 0.985f, 0.8f, 1.2f), state.Occlusion * num2 * 0.25f);
				}
			}
		}
	}
	public static class Report
	{
		public static void Print()
		{
			MelonLogger.Msg("[Resonix] ===== AUDIO REPORT =====");
			MelonLogger.Msg($"Playing sources: {Runtime.PlayingSources}");
			MelonLogger.Msg($"Tracked sources: {SourceRegistry.Count}");
			MelonLogger.Msg($"Per-shot pitch changes: {GunSoundSystem.ShotChanges}");
			MelonLogger.Msg($"Hearing effect: {HearingSystem.Shock:0.00}");
			MelonLogger.Msg($"Fusion detected: {FusionBridge.Loaded}");
			MelonLogger.Msg("[Resonix] ========================");
		}
	}
	public static class Runtime
	{
		private static float _nextScan;

		private static float _nextFusion;

		public static int PlayingSources { get; private set; }

		public static void Initialize()
		{
			HearingSystem.Initialize();
			FusionBridge.Refresh();
		}

		public static void Tick()
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			HearingSystem.Tick();
			if (Time.time >= _nextFusion)
			{
				_nextFusion = Time.time + 5f;
				FusionBridge.Refresh();
			}
			float num = ((FusionBridge.Loaded && Config.FusionSafeMode.Value) ? 0.14f : 0.08f);
			if (Time.time < _nextScan)
			{
				return;
			}
			_nextScan = Time.time + num;
			Transform val = null;
			try
			{
				val = Player.Head;
			}
			catch
			{
			}
			AudioSource[] array;
			try
			{
				array = Il2CppArrayBase<AudioSource>.op_Implicit(Object.FindObjectsOfType<AudioSource>());
			}
			catch
			{
				return;
			}
			PlayingSources = 0;
			AudioSource[] array2 = array;
			foreach (AudioSource val2 in array2)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				SourceState sourceState = SourceRegistry.Get(val2);
				if (sourceState != null)
				{
					string clip = (((Object)(object)val2.clip != (Object)null) ? ((Object)val2.clip).name : "");
					SoundKind kind = Classifier.Classify(((Object)val2).name, clip);
					if (val2.isPlaying)
					{
						PlayingSources++;
						float distance = (((Object)(object)val != (Object)null) ? Vector3.Distance(val.position, ((Component)val2).transform.position) : 999f);
						GunSoundSystem.Process(val2, sourceState, kind);
						ImpactSystem.Process(val2, sourceState, kind);
						VoiceSystem.Process(val2, sourceState, kind, val);
						OcclusionSystem.Process(val2, sourceState, kind, val);
						HearingSystem.Observe(val2, kind, distance);
					}
					else
					{
						sourceState.LastPlaying = false;
						val2.pitch = Mathf.Lerp(val2.pitch, sourceState.OriginalPitch, 0.2f);
						val2.volume = Mathf.Lerp(val2.volume, sourceState.OriginalVolume, 0.2f);
					}
				}
			}
		}

		public static void Reset()
		{
			_nextScan = 0f;
			PlayingSources = 0;
			GunSoundSystem.Reset();
			SourceRegistry.Reset();
			HearingSystem.Reset();
		}
	}
	public enum SoundKind
	{
		Unknown,
		Gunshot,
		Explosion,
		Impact,
		Footstep,
		Mechanical,
		NpcVoice,
		FusionVoice,
		Ambient,
		Music
	}
	public static class SourceRegistry
	{
		private static readonly Dictionary<int, SourceState> States = new Dictionary<int, SourceState>();

		public static int Count => States.Count;

		public static SourceState Get(AudioSource source)
		{
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			int instanceID = ((Object)source).GetInstanceID();
			if (!States.TryGetValue(instanceID, out var value))
			{
				value = new SourceState
				{
					Source = source,
					OriginalPitch = source.pitch,
					OriginalVolume = source.volume,
					OriginalMinDistance = source.minDistance,
					OriginalMaxDistance = source.maxDistance
				};
				States[instanceID] = value;
			}
			return value;
		}

		public static void Reset()
		{
			foreach (SourceState value in States.Values)
			{
				if (!((Object)(object)value?.Source == (Object)null))
				{
					try
					{
						value.Source.pitch = value.OriginalPitch;
						value.Source.volume = value.OriginalVolume;
						value.Source.minDistance = value.OriginalMinDistance;
						value.Source.maxDistance = value.OriginalMaxDistance;
					}
					catch
					{
					}
				}
			}
			States.Clear();
		}
	}
	public sealed class SourceState
	{
		public AudioSource Source;

		public float OriginalPitch;

		public float OriginalVolume;

		public float OriginalMinDistance;

		public float OriginalMaxDistance;

		public float LastTime;

		public int LastTimeSamples;

		public bool LastPlaying;

		public int LastClipId;

		public float Occlusion;
	}
	public static class VoiceSystem
	{
		public static void Process(AudioSource source, SourceState state, SoundKind kind, Transform listener)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (!Config.VoiceOverhaul.Value || (Object)(object)source == (Object)null || state == null || (Object)(object)listener == (Object)null)
			{
				return;
			}
			bool num = kind == SoundKind.NpcVoice && Config.NpcVoices.Value;
			bool flag = kind == SoundKind.FusionVoice && Config.FusionVoices.Value;
			if (num || flag)
			{
				float num2 = Vector3.Distance(listener.position, ((Component)source).transform.position);
				if (source.spatialBlend > 0.1f)
				{
					float num3 = Mathf.Clamp01(num2 / 22f);
					float num4 = state.OriginalVolume * Mathf.Lerp(1f, 0.72f, num3);
					source.volume = Mathf.Lerp(source.volume, num4, 0.2f);
				}
			}
		}
	}
}