using System;
using System.Buffers.Binary;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using AIGraph;
using AK;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Unity.IL2CPP;
using Feedback;
using ForgeCore;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppInterop.Runtime.Runtime;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using NVorbis;
using NVorbis.Contracts;
using NVorbis.Ogg;
using Player;
using SNetwork;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ForgeAudio")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+66ec6b43e1a1603bac84a4b9a226674300b2fc7d")]
[assembly: AssemblyProduct("ForgeAudio")]
[assembly: AssemblyTitle("ForgeAudio")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 ForgeAudio
{
	internal sealed class Catalog
	{
		internal readonly Dictionary<string, CueDefinition> Cues = new Dictionary<string, CueDefinition>(StringComparer.OrdinalIgnoreCase);

		internal readonly Dictionary<string, BusDefinition> Buses = new Dictionary<string, BusDefinition>(StringComparer.OrdinalIgnoreCase);

		internal readonly Dictionary<string, AudioFailure> Failures = new Dictionary<string, AudioFailure>(StringComparer.OrdinalIgnoreCase);

		internal AudioFailure? Error;

		internal string[] Files => Cues.Values.SelectMany((CueDefinition cue) => cue.Clips).Distinct<string>(StringComparer.OrdinalIgnoreCase).OrderBy<string, string>((string file) => file, StringComparer.OrdinalIgnoreCase)
			.ToArray();

		internal HashSet<string> DirectFiles => new HashSet<string>(Cues.Values.Where((CueDefinition cue) => cue.IsDirect).SelectMany((CueDefinition cue) => cue.Clips), StringComparer.OrdinalIgnoreCase);

		internal HashSet<string> MixedFiles => new HashSet<string>(Cues.Values.Where((CueDefinition cue) => !cue.IsDirect).SelectMany((CueDefinition cue) => cue.Clips), StringComparer.OrdinalIgnoreCase);
	}
	internal static class CueCatalog
	{
		internal const string SettingsFile = "cues.json";

		internal const int MaxSettingsBytes = 1048576;

		private static readonly string[] OtherAudio = new string[9] { ".wav", ".mp3", ".flac", ".m4a", ".aac", ".opus", ".wma", ".aif", ".aiff" };

		private static readonly string[] CueFields = CueSchema.Names(CueSchema.Cue.All);

		private static readonly string[] LayerFields = CueSchema.Names(CueSchema.Layer.All);

		private static readonly string[] SpaceFields = CueSchema.Names(CueSchema.Space.All);

		private static readonly string[] BusFields = CueSchema.Names(CueSchema.Bus.All);

		internal static string CueName(string relativeFile)
		{
			string text = PosixPath.ToPosix(relativeFile);
			return text.Substring(0, text.Length - Path.GetExtension(text).Length);
		}

		internal static bool IsOgg(string file)
		{
			return string.Equals(Path.GetExtension(file), ".ogg", StringComparison.OrdinalIgnoreCase);
		}

		internal static Catalog Build(IEnumerable<string> files, string? settings)
		{
			Catalog catalog = new Catalog();
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			List<string> list = new List<string>();
			foreach (string file in files)
			{
				string text = PosixPath.ToPosix(file);
				if (IsOgg(text))
				{
					dictionary[text] = text;
				}
				else if (Array.IndexOf(OtherAudio, Path.GetExtension(text).ToLowerInvariant()) >= 0)
				{
					list.Add(text);
				}
			}
			List<(string, JsonElement)> list2 = new List<(string, JsonElement)>();
			JsonDocument jsonDocument = null;
			try
			{
				if (settings == null)
				{
					throw new FormatException("the folder has no cues.json: every cue plays on a bus and every bus names its category (" + AudioCategories.Known + "), so the cues must be listed there.");
				}
				if (settings.Length > 1048576)
				{
					throw new FormatException("cues.json exceeds 1 MiB.");
				}
				jsonDocument = JsonDocument.Parse(settings, new JsonDocumentOptions
				{
					MaxDepth = 12,
					CommentHandling = JsonCommentHandling.Skip,
					AllowTrailingCommas = true
				});
				if (jsonDocument.RootElement.ValueKind != JsonValueKind.Object)
				{
					throw new FormatException("cues.json must be an object with \"buses\" and \"cues\".");
				}
				foreach (JsonProperty item in jsonDocument.RootElement.EnumerateObject())
				{
					string name = item.Name;
					if ((!(name == "buses") && !(name == "cues")) || 1 == 0)
					{
						throw new FormatException("cues.json has unknown section '" + item.Name + "' (known: buses, cues).");
					}
					if (item.Value.ValueKind != JsonValueKind.Object)
					{
						throw new FormatException("cues.json section '" + item.Name + "' must be an object.");
					}
					HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
					foreach (JsonProperty item2 in item.Value.EnumerateObject())
					{
						if (string.IsNullOrWhiteSpace(item2.Name))
						{
							throw new FormatException("cues.json has an empty " + item.Name + " name.");
						}
						if (!hashSet.Add(item2.Name))
						{
							throw new FormatException("cues.json names '" + item2.Name + "' twice in " + item.Name + ".");
						}
						if (item.Name == "buses")
						{
							catalog.Buses[item2.Name] = ParseBus(item2.Name, item2.Value);
						}
						else
						{
							list2.Add((item2.Name, item2.Value));
						}
					}
				}
				HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				foreach (var (text2, value) in list2)
				{
					try
					{
						CueDefinition cueDefinition = ParseCue(text2, value, dictionary, catalog.Buses);
						foreach (string clip in cueDefinition.Clips)
						{
							if (!string.Equals(CueName(clip), text2, StringComparison.OrdinalIgnoreCase))
							{
								hashSet2.Add(clip);
							}
						}
						catalog.Cues[text2] = cueDefinition;
						catalog.Failures.Remove(text2);
					}
					catch (Exception ex) when (((ex is FormatException || ex is InvalidOperationException || ex is KeyNotFoundException) ? 1 : 0) != 0)
					{
						catalog.Failures[text2] = new AudioFailure(AudioError.InvalidSettings, "cues.json cue '" + text2 + "': " + ex.Message);
					}
				}
				foreach (string key2 in dictionary.Keys)
				{
					string text3 = CueName(key2);
					if (!hashSet2.Contains(key2) && !catalog.Cues.ContainsKey(text3) && !catalog.Failures.ContainsKey(text3))
					{
						catalog.Failures[text3] = new AudioFailure(AudioError.InvalidSettings, key2 + " is not a cue in cues.json and no cue's layer uses it; name it there with its bus (\"" + text3 + "\": {\"bus\": \"...\"}).");
					}
				}
				foreach (string item3 in list)
				{
					string key = CueName(item3);
					if (!catalog.Cues.ContainsKey(key) && !catalog.Failures.ContainsKey(key))
					{
						catalog.Failures[key] = new AudioFailure(AudioError.UnsupportedCodec, item3 + " is not Ogg Vorbis. Convert the folder: python convert_audio.py convert <source folder> <audio folder>");
					}
				}
			}
			catch (Exception ex2) when (((ex2 is JsonException || ex2 is FormatException) ? 1 : 0) != 0)
			{
				catalog.Cues.Clear();
				catalog.Error = new AudioFailure(AudioError.InvalidSettings, "cues.json: " + ex2.Message);
			}
			finally
			{
				jsonDocument?.Dispose();
			}
			return catalog;
		}

		private static void CheckFields(JsonElement value, string[] known, string what)
		{
			if (value.ValueKind != JsonValueKind.Object)
			{
				throw new FormatException(what + " must be an object.");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (JsonProperty item in value.EnumerateObject())
			{
				if (Array.IndexOf(known, item.Name) < 0)
				{
					throw new FormatException("unknown " + what + " setting '" + item.Name + "' (known: " + string.Join(", ", known) + ").");
				}
				if (!hashSet.Add(item.Name))
				{
					throw new FormatException(what + " setting '" + item.Name + "' appears twice.");
				}
			}
		}

		private static BusDefinition ParseBus(string name, JsonElement value)
		{
			try
			{
				CheckFields(value, BusFields, "bus");
				BusDefinition busDefinition = new BusDefinition
				{
					Name = name,
					Category = CategoryOf(value, CueSchema.Bus.Category.Name, "category"),
					Gain = GainOf(value, CueSchema.Bus.Gain, CueSchema.Bus.GainDb, 1f),
					Seats = Integer(value, CueSchema.Bus.Seats, 0)
				};
				if (value.TryGetProperty(CueSchema.Bus.Duck.Name, out var value2))
				{
					CheckFields(value2, new string[2] { "categories", "db" }, "duck");
					Field duckCategories = CueSchema.Bus.DuckCategories;
					if (!value2.TryGetProperty("categories", out var value3) || value3.ValueKind != JsonValueKind.Array || value3.GetArrayLength() < duckCategories.MinI || value3.GetArrayLength() > duckCategories.MaxI)
					{
						throw new FormatException("duck.categories must list " + duckCategories.MinI + " to " + duckCategories.MaxI + " categories (" + AudioCategories.Known + ").");
					}
					busDefinition.Duck = (from t in value3.EnumerateArray()
						select CategoryOf(t, "duck.categories")).Distinct().ToArray();
					AudioCategory[] duck = busDefinition.Duck;
					foreach (AudioCategory category in duck)
					{
						busDefinition.DuckMask |= AudioCategories.Bit(category);
					}
					busDefinition.DuckDb = Number(value2, CueSchema.Bus.DuckDb, busDefinition.DuckDb);
				}
				return busDefinition;
			}
			catch (FormatException ex)
			{
				throw new FormatException("bus '" + name + "': " + ex.Message);
			}
		}

		private static CueDefinition ParseCue(string name, JsonElement value, Dictionary<string, string> oggs, Dictionary<string, BusDefinition> buses)
		{
			CheckFields(value, CueFields, "cue");
			CueDefinition cueDefinition = new CueDefinition
			{
				Name = name
			};
			if (value.TryGetProperty("layers", out var value2))
			{
				Field layers = CueSchema.Cue.Layers;
				if (value2.ValueKind != JsonValueKind.Array || value2.GetArrayLength() < layers.MinI || value2.GetArrayLength() > layers.MaxI)
				{
					throw new FormatException("layers must list " + layers.MinI + " to " + layers.MaxI + " layers.");
				}
				cueDefinition.Layers = (from layer in value2.EnumerateArray()
					select ParseLayer(layer, oggs)).ToArray();
			}
			else
			{
				string text = oggs.Keys.FirstOrDefault((string file) => string.Equals(CueName(file), name, StringComparison.OrdinalIgnoreCase)) ?? throw new FormatException("there is no file " + name + ".ogg and no layers list.");
				cueDefinition.Layers = new LayerDefinition[1]
				{
					new LayerDefinition
					{
						Clips = new string[1] { text }
					}
				};
			}
			(cueDefinition.GainMin, cueDefinition.Gain) = GainRange(value);
			if (value.TryGetProperty("pitch", out var value3))
			{
				(cueDefinition.PitchMin, cueDefinition.PitchMax) = PitchRange(value3);
			}
			cueDefinition.Loop = Flag(value, CueSchema.Cue.Loop.Key, cueDefinition.Loop);
			cueDefinition.Priority = Integer(value, CueSchema.Cue.Priority, cueDefinition.Priority);
			cueDefinition.MaxVoices = Integer(value, CueSchema.Cue.MaxVoices, cueDefinition.MaxVoices);
			cueDefinition.MaxPerEmitter = Integer(value, CueSchema.Cue.MaxPerEmitter, cueDefinition.MaxVoices, cueDefinition.MaxVoices);
			cueDefinition.MinInterval = Number(value, CueSchema.Cue.MinInterval, cueDefinition.MinInterval);
			cueDefinition.Environment = Flag(value, CueSchema.Cue.Environment.Key, cueDefinition.Environment);
			cueDefinition.MaxSeconds = Number(value, CueSchema.Cue.MaxSeconds, 0f);
			if (!value.TryGetProperty(CueSchema.Cue.BusName.Key, out var value4))
			{
				throw new FormatException("a cue needs a bus (the bus names its category: " + AudioCategories.Known + ").");
			}
			string text2 = ((value4.ValueKind == JsonValueKind.String) ? value4.GetString().Trim() : "");
			if (!buses.ContainsKey(text2))
			{
				throw new FormatException("bus '" + text2 + "' is not defined in \"buses\".");
			}
			cueDefinition.Bus = buses[text2].Name;
			if (value.TryGetProperty("place", out var value5))
			{
				if (value5.ValueKind == JsonValueKind.String)
				{
					cueDefinition.SelfPlace = (cueDefinition.OtherPlace = PlaceOf(value5));
				}
				else
				{
					CheckFields(value5, new string[2] { "self", "other" }, "place");
					if (value5.TryGetProperty("self", out var value6))
					{
						cueDefinition.SelfPlace = PlaceOf(value6);
					}
					if (value5.TryGetProperty("other", out var value7))
					{
						cueDefinition.OtherPlace = PlaceOf(value7);
					}
				}
			}
			if (value.TryGetProperty("space", out var value8))
			{
				cueDefinition.Space = ParseSpace(value8);
			}
			if (cueDefinition.Loop)
			{
				if (cueDefinition.Layers.Length != 1 || cueDefinition.Layers[0].OffsetMs != 0f || cueDefinition.Layers[0].RangeStart != 0f || cueDefinition.Layers[0].RangeEnd >= 0f || cueDefinition.Layers[0].FadeInMs != 0f || cueDefinition.Layers[0].FadeOutMs != 0f || cueDefinition.Layers[0].PitchMin != 1f || cueDefinition.Layers[0].PitchMax != 1f || cueDefinition.Layers[0].DistanceMin != 0f || !float.IsPositiveInfinity(cueDefinition.Layers[0].DistanceMax) || cueDefinition.Layers[0].LowpassHz != 0f)
				{
					throw new FormatException("a loop has exactly one layer with only clips and gain; its sample-exact loop point cannot be shaped.");
				}
				if (cueDefinition.MaxSeconds != 0f)
				{
					throw new FormatException("a loop has no maxSeconds.");
				}
			}
			return cueDefinition;
		}

		private static LayerDefinition ParseLayer(JsonElement value, Dictionary<string, string> oggs)
		{
			CheckFields(value, LayerFields, "layer");
			LayerDefinition layerDefinition = new LayerDefinition();
			Field clips = CueSchema.Layer.Clips;
			if (!value.TryGetProperty(clips.Key, out var value2) || value2.ValueKind != JsonValueKind.Array || value2.GetArrayLength() < clips.MinI || value2.GetArrayLength() > clips.MaxI)
			{
				throw new FormatException("a layer's clips must list " + clips.MinI + " to " + clips.MaxI + " .ogg files.");
			}
			List<string> list = new List<string>();
			foreach (JsonElement item in value2.EnumerateArray())
			{
				string text = ((item.ValueKind == JsonValueKind.String) ? item.GetString() : null);
				if (text == null)
				{
					throw new FormatException("clips entries must be file names.");
				}
				string text2 = PosixPath.ToPosix(text);
				if (!IsOgg(text2) || Path.IsPathRooted(text2) || ((ReadOnlySpan<string>)text2.Split('/')).Contains(".."))
				{
					throw new FormatException("clip '" + text2 + "' must be a .ogg file inside the audio folder.");
				}
				if (!oggs.TryGetValue(text2, out string value3))
				{
					throw new FormatException("clip file '" + text2 + "' was not found.");
				}
				if (list.Contains<string>(value3, StringComparer.OrdinalIgnoreCase))
				{
					throw new FormatException("clip '" + text2 + "' is listed twice.");
				}
				list.Add(value3);
			}
			layerDefinition.Clips = list.ToArray();
			layerDefinition.OffsetMs = Number(value, CueSchema.Layer.OffsetMs, 0f);
			layerDefinition.Gain = GainOf(value, CueSchema.Layer.Gain, CueSchema.Layer.GainDb, 1f);
			if (value.TryGetProperty(CueSchema.Layer.Range.Key, out var value4))
			{
				Field range = CueSchema.Layer.Range;
				if (value4.ValueKind != JsonValueKind.Array || value4.GetArrayLength() != 2 || value4[0].ValueKind != JsonValueKind.Number || value4[1].ValueKind != JsonValueKind.Number)
				{
					throw new FormatException("range must be [startSeconds, endSeconds].");
				}
				layerDefinition.RangeStart = Range(value4[0].GetSingle(), range.MinF, range.MaxF, "range start");
				layerDefinition.RangeEnd = Range(value4[1].GetSingle(), layerDefinition.RangeStart + 0.001f, range.MaxF, "range end");
			}
			layerDefinition.FadeInMs = Number(value, CueSchema.Layer.FadeInMs, 0f);
			layerDefinition.FadeOutMs = Number(value, CueSchema.Layer.FadeOutMs, 0f);
			if (value.TryGetProperty(CueSchema.Layer.Pitch.Key, out var value5))
			{
				(layerDefinition.PitchMin, layerDefinition.PitchMax) = PitchRange(value5);
			}
			if (value.TryGetProperty(CueSchema.Layer.Distance.Key, out var value6))
			{
				CheckFields(value6, new string[2] { "min", "max" }, "distance");
				layerDefinition.DistanceMin = Number(value6, CueSchema.Layer.DistanceMin, 0f);
				layerDefinition.DistanceMax = Number(value6, "max", layerDefinition.DistanceMin + 0.01f, CueSchema.Layer.DistanceMax.MaxF, float.PositiveInfinity);
			}
			layerDefinition.LowpassHz = Number(value, CueSchema.Layer.LowpassHz, 0f);
			return layerDefinition;
		}

		private static SpaceDefinition ParseSpace(JsonElement value)
		{
			CheckFields(value, SpaceFields, "space");
			SpaceDefinition spaceDefinition = new SpaceDefinition
			{
				Near = Number(value, CueSchema.Space.Near, 2f),
				Far = Number(value, CueSchema.Space.Far, 30f),
				Blend = Number(value, CueSchema.Space.Blend, 1f),
				Spread = Number(value, CueSchema.Space.Spread, 0f),
				Doppler = Number(value, CueSchema.Space.Doppler, 0f),
				Cull = Flag(value, CueSchema.Space.Cull.Key, fallback: true)
			};
			if (spaceDefinition.Far <= spaceDefinition.Near)
			{
				throw new FormatException("far must be greater than near.");
			}
			if (value.TryGetProperty(CueSchema.Space.Curve.Key, out var value2))
			{
				if (value2.ValueKind != JsonValueKind.String)
				{
					if (value2.ValueKind == JsonValueKind.Array)
					{
						int arrayLength = value2.GetArrayLength();
						if (arrayLength >= 2 && arrayLength <= 32)
						{
							List<float> list = new List<float>();
							List<float> list2 = new List<float>();
							foreach (JsonElement item in value2.EnumerateArray())
							{
								if (item.ValueKind != JsonValueKind.Array || item.GetArrayLength() != 2 || item[0].ValueKind != JsonValueKind.Number || item[1].ValueKind != JsonValueKind.Number)
								{
									throw new FormatException("curve points must be [metres, gain] pairs.");
								}
								float num = Range(item[0].GetSingle(), 0f, 10000f, "curve metres");
								if (list.Count > 0)
								{
									if (num <= list[list.Count - 1])
									{
										throw new FormatException("curve metres must increase.");
									}
								}
								list.Add(num);
								list2.Add(Range(item[1].GetSingle(), 0f, 4f, "curve gain"));
							}
							spaceDefinition.Curve = new DistanceCurve
							{
								Shape = DistanceCurve.Kind.Points,
								Distances = list.ToArray(),
								Gains = list2.ToArray()
							};
							goto IL_0298;
						}
					}
					throw new FormatException("curve must be \"linear\", \"log\" or 2 to 32 [metres, gain] points.");
				}
				DistanceCurve curve = spaceDefinition.Curve;
				string text = value2.GetString();
				DistanceCurve.Kind shape;
				if (!(text == "linear"))
				{
					if (!(text == "log"))
					{
						throw new FormatException("curve must be \"linear\", \"log\" or a list of [metres, gain] points.");
					}
					shape = DistanceCurve.Kind.Log;
				}
				else
				{
					shape = DistanceCurve.Kind.Linear;
				}
				curve.Shape = shape;
			}
			goto IL_0298;
			IL_0298:
			return spaceDefinition;
		}

		private static (float, float) PitchRange(JsonElement pitch)
		{
			float minF = CueSchema.Cue.Pitch.MinF;
			float maxF = CueSchema.Cue.Pitch.MaxF;
			float min = minF;
			if (pitch.ValueKind == JsonValueKind.Number)
			{
				float num = Range(pitch.GetSingle(), min, maxF, "pitch");
				return (num, num);
			}
			if (pitch.ValueKind == JsonValueKind.Array && pitch.GetArrayLength() == 2)
			{
				float num2 = Range(pitch[0].GetSingle(), min, maxF, "pitch");
				return (num2, Range(pitch[1].GetSingle(), num2, maxF, "pitch"));
			}
			throw new FormatException("pitch must be a number or [min, max].");
		}

		private static AudioCategory CategoryOf(JsonElement owner, string key, string what)
		{
			if (!owner.TryGetProperty(key, out var value))
			{
				throw new FormatException("needs a " + what + " (" + AudioCategories.Known + ").");
			}
			return CategoryOf(value, what);
		}

		private static AudioCategory CategoryOf(JsonElement value, string what)
		{
			if (value.ValueKind != JsonValueKind.String || !AudioCategories.TryParse(value.GetString(), out var category))
			{
				throw new FormatException(what + " must be one of " + AudioCategories.Known + ".");
			}
			return category;
		}

		private static Place PlaceOf(JsonElement e)
		{
			if (e.ValueKind == JsonValueKind.String)
			{
				return e.GetString() switch
				{
					"auto" => Place.Auto, 
					"2d" => Place.TwoD, 
					"world" => Place.World, 
					"follow" => Place.Follow, 
					_ => throw new FormatException("place must be \"2d\", \"world\", \"follow\" or \"auto\"."), 
				};
			}
			throw new FormatException("place must be \"2d\", \"world\", \"follow\" or \"auto\".");
		}

		private static float GainOf(JsonElement e, Field linear, Field decibels, float fallback)
		{
			JsonElement value;
			bool num = e.TryGetProperty(linear.Key, out value);
			bool flag = e.TryGetProperty(decibels.Key, out value);
			if (num && flag)
			{
				throw new FormatException(linear.Key + " and " + decibels.Key + " cannot both be set.");
			}
			if (!flag)
			{
				return Number(e, linear, fallback);
			}
			return MathF.Pow(10f, Number(e, decibels, 0f) / 20f);
		}

		private static (float Min, float Max) GainRange(JsonElement e)
		{
			JsonElement value;
			bool num = e.TryGetProperty("gain", out value);
			JsonElement value2;
			bool hasDb = e.TryGetProperty("gainDb", out value2);
			if (num && hasDb)
			{
				throw new FormatException("gain and gainDb cannot both be set.");
			}
			if (!num && !hasDb)
			{
				return (Min: 1f, Max: 1f);
			}
			Field obj = (hasDb ? CueSchema.Cue.GainDb : CueSchema.Cue.Gain);
			JsonElement jsonElement = (hasDb ? value2 : value);
			string key = obj.Key;
			float minF = obj.MinF;
			float maxF = obj.MaxF;
			float min = minF;
			string text = key;
			JsonElement jsonElement2 = jsonElement;
			if (jsonElement2.ValueKind == JsonValueKind.Number)
			{
				float num2 = From(Range(jsonElement2.GetSingle(), min, maxF, text));
				return (Min: num2, Max: num2);
			}
			if (jsonElement2.ValueKind == JsonValueKind.Array && jsonElement2.GetArrayLength() == 2 && jsonElement2[0].ValueKind == JsonValueKind.Number && jsonElement2[1].ValueKind == JsonValueKind.Number)
			{
				float num3 = Range(jsonElement2[0].GetSingle(), min, maxF, text);
				return (Min: From(num3), Max: From(Range(jsonElement2[1].GetSingle(), num3, maxF, text)));
			}
			throw new FormatException(text + " must be a number or [min, max].");
			float From(float v)
			{
				if (!hasDb)
				{
					return v;
				}
				return MathF.Pow(10f, v / 20f);
			}
		}

		private static bool Flag(JsonElement e, string key, bool fallback)
		{
			if (!e.TryGetProperty(key, out var value))
			{
				return fallback;
			}
			return value.ValueKind switch
			{
				JsonValueKind.True => true, 
				JsonValueKind.False => false, 
				_ => throw new FormatException(key + " must be true or false."), 
			};
		}

		private static int Integer(JsonElement e, Field field, int fallback)
		{
			return Integer(e, field.Key, field.MinI, field.MaxI, fallback);
		}

		private static int Integer(JsonElement e, Field field, int max, int fallback)
		{
			return Integer(e, field.Key, field.MinI, max, fallback);
		}

		private static float Number(JsonElement e, Field field, float fallback)
		{
			return Number(e, field.Key, field.MinF, field.MaxF, fallback);
		}

		private static int Integer(JsonElement e, string key, int min, int max, int fallback)
		{
			if (!e.TryGetProperty(key, out var value))
			{
				return fallback;
			}
			if (value.ValueKind != JsonValueKind.Number || !value.TryGetInt32(out var value2) || value2 < min || value2 > max)
			{
				throw new FormatException(key + " must be a whole number from " + min + " to " + max + ".");
			}
			return value2;
		}

		private static float Number(JsonElement e, string key, float min, float max, float fallback)
		{
			if (!e.TryGetProperty(key, out var value))
			{
				return fallback;
			}
			if (value.ValueKind != JsonValueKind.Number)
			{
				throw new FormatException(key + " must be a number.");
			}
			return Range(value.GetSingle(), min, max, key);
		}

		private static float Range(float n, float min, float max, string key)
		{
			if (!float.IsFinite(n) || !(n >= min) || !(n <= max))
			{
				throw new FormatException(key + " must be from " + min + " to " + max + ".");
			}
			return n;
		}
	}
	internal readonly record struct OggInfo(int Channels, int SampleRate, long Frames)
	{
		internal long DecodedBytes => Frames * Channels * 4;

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			builder.Append("Channels = ");
			builder.Append(Channels.ToString());
			builder.Append(", SampleRate = ");
			builder.Append(SampleRate.ToString());
			builder.Append(", Frames = ");
			builder.Append(Frames.ToString());
			return true;
		}
	}
	internal static class AssetValidation
	{
		internal const int MaxFileBytes = 67108864;

		internal const long MaxDecodedBytes = 536870912L;

		internal const long MaxCompressedCache = 268435456L;

		internal static Result<OggInfo> Ogg(byte[] bytes)
		{
			if (bytes.Length > 67108864)
			{
				return Result<OggInfo>.Fail(AudioError.AssetLimit, "file exceeds 64 MiB.");
			}
			if (bytes.Length < 58 || bytes[0] != 79 || bytes[1] != 103 || bytes[2] != 103 || bytes[3] != 83 || bytes[4] != 0 || bytes[26] < 1)
			{
				return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "not an Ogg file (convert it with convert_audio.py).");
			}
			int num = 27 + bytes[26];
			if (num + 30 > bytes.Length || bytes[num] != 1 || Encoding.ASCII.GetString(bytes, num + 1, 6) != "vorbis")
			{
				return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "Ogg but not Vorbis (Opus is not supported).");
			}
			byte b = bytes[num + 11];
			uint num2 = BinaryPrimitives.ReadUInt32LittleEndian(bytes.AsSpan(num + 12));
			bool flag = ((b < 1 || b > 2) ? true : false);
			bool flag2 = flag;
			if (!flag2)
			{
				bool flag3 = ((num2 < 8000 || num2 > 192000) ? true : false);
				flag2 = flag3;
			}
			if (flag2 || BinaryPrimitives.ReadUInt32LittleEndian(bytes.AsSpan(num + 7)) != 0 || bytes[num + 29] != 1)
			{
				return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "expected mono or stereo Vorbis at 8 to 192 kHz.");
			}
			uint num3 = BinaryPrimitives.ReadUInt32LittleEndian(bytes.AsSpan(14));
			int num4 = 0;
			uint num5 = 0u;
			ulong num6 = 0uL;
			bool flag4 = false;
			while (num4 < bytes.Length)
			{
				if (flag4 || bytes.Length - num4 < 27 || bytes[num4] != 79 || bytes[num4 + 1] != 103 || bytes[num4 + 2] != 103 || bytes[num4 + 3] != 83 || bytes[num4 + 4] != 0 || BinaryPrimitives.ReadUInt32LittleEndian(bytes.AsSpan(num4 + 14)) != num3 || BinaryPrimitives.ReadUInt32LittleEndian(bytes.AsSpan(num4 + 18)) != num5++)
				{
					return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "invalid or chained Ogg pages (one Vorbis stream is required).");
				}
				byte b2 = bytes[num4 + 5];
				if ((num4 == 0 && b2 != 2 && b2 != 6) || (num4 != 0 && (b2 & 2) != 0))
				{
					return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "invalid Ogg beginning-of-stream flag.");
				}
				byte b3 = bytes[num4 + 26];
				int num7 = num4 + 27 + b3;
				if (num7 > bytes.Length)
				{
					return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "truncated Ogg segment table.");
				}
				int num8 = 0;
				for (int i = 0; i < b3; i++)
				{
					num8 += bytes[num4 + 27 + i];
				}
				if (num8 > bytes.Length - num7 || (num4 == 0 && num8 < 30))
				{
					return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "truncated Ogg page.");
				}
				ulong num9 = BinaryPrimitives.ReadUInt64LittleEndian(bytes.AsSpan(num4 + 6));
				if (num9 != ulong.MaxValue)
				{
					if (num9 < num6)
					{
						return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "non-monotonic Vorbis sample positions.");
					}
					num6 = num9;
					if (num6 > (ulong)((long)num2 * 3600L) || num6 > 536870912uL / (ulong)b / 4)
					{
						return Result<OggInfo>.Fail(AudioError.AssetLimit, "longer than one hour or over 512 MiB of decoded audio.");
					}
				}
				flag4 = (b2 & 4) != 0;
				num4 = num7 + num8;
			}
			if (!flag4 || num6 == 0L)
			{
				return Result<OggInfo>.Fail(AudioError.UnsupportedCodec, "Ogg stream is truncated (no final page).");
			}
			return Result<OggInfo>.Ok(new OggInfo(b, (int)num2, (long)num6));
		}
	}
	internal sealed class ClaimBook<T> where T : class
	{
		internal sealed class Entry
		{
			internal readonly T Owner;

			internal readonly int Kinds;

			internal readonly int Priority;

			internal readonly long Order;

			internal IntPtr[] Pointers = Array.Empty<IntPtr>();

			internal bool Live;

			internal Entry(T owner, int kinds, int priority, long order)
			{
				Owner = owner;
				Kinds = kinds;
				Priority = priority;
				Order = order;
			}
		}

		private readonly Dictionary<IntPtr, List<Entry>> _byPointer = new Dictionary<IntPtr, List<Entry>>();

		private readonly List<Entry> _live = new List<Entry>();

		private long _order;

		internal int Count => _live.Count;

		internal Entry Add(T owner, IntPtr[] pointers, int kinds, int priority)
		{
			Entry entry = new Entry(owner, kinds, priority, ++_order)
			{
				Live = true
			};
			_live.Add(entry);
			Index(entry, pointers);
			return entry;
		}

		internal void Reset(Entry entry, IntPtr[] pointers)
		{
			if (entry.Live)
			{
				Unindex(entry);
				Index(entry, pointers);
			}
		}

		internal bool Remove(Entry entry)
		{
			if (!entry.Live)
			{
				return false;
			}
			entry.Live = false;
			Unindex(entry);
			_live.Remove(entry);
			return true;
		}

		internal void Clear()
		{
			foreach (Entry item in _live)
			{
				item.Live = false;
				item.Pointers = Array.Empty<IntPtr>();
			}
			_live.Clear();
			_byPointer.Clear();
		}

		internal T? Find(IntPtr pointer, int kind)
		{
			if (_live.Count == 0 || pointer == IntPtr.Zero || !_byPointer.TryGetValue(pointer, out List<Entry> value))
			{
				return null;
			}
			for (int i = 0; i < value.Count; i++)
			{
				if ((value[i].Kinds & kind) != 0)
				{
					return value[i].Owner;
				}
			}
			return null;
		}

		private void Index(Entry entry, IntPtr[] pointers)
		{
			entry.Pointers = pointers;
			foreach (IntPtr intPtr in pointers)
			{
				if (intPtr == IntPtr.Zero)
				{
					continue;
				}
				if (!_byPointer.TryGetValue(intPtr, out List<Entry> value))
				{
					value = (_byPointer[intPtr] = new List<Entry>(1));
				}
				if (!value.Contains(entry))
				{
					int j;
					for (j = 0; j < value.Count && (value[j].Priority > entry.Priority || (value[j].Priority == entry.Priority && value[j].Order > entry.Order)); j++)
					{
					}
					value.Insert(j, entry);
				}
			}
		}

		private void Unindex(Entry entry)
		{
			IntPtr[] pointers = entry.Pointers;
			foreach (IntPtr key in pointers)
			{
				if (_byPointer.TryGetValue(key, out List<Entry> value))
				{
					value.Remove(entry);
					if (value.Count == 0)
					{
						_byPointer.Remove(key);
					}
				}
			}
			entry.Pointers = Array.Empty<IntPtr>();
		}
	}
	internal enum ControlRoute
	{
		Run,
		Queue,
		Drop
	}
	internal static class ControlRouting
	{
		internal static ControlRoute Decide(bool ready, bool onMainThread)
		{
			if (ready)
			{
				if (!onMainThread)
				{
					return ControlRoute.Queue;
				}
				return ControlRoute.Run;
			}
			return ControlRoute.Drop;
		}
	}
	internal sealed record MixedAudio(float[] Samples, int Channels, int SampleRate)
	{
		internal int Frames => Samples.Length / Channels;

		internal double Seconds => (double)Frames / (double)SampleRate;

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			RuntimeHelpers.EnsureSufficientExecutionStack();
			builder.Append("Samples = ");
			builder.Append(Samples);
			builder.Append(", Channels = ");
			builder.Append(Channels.ToString());
			builder.Append(", SampleRate = ");
			builder.Append(SampleRate.ToString());
			return true;
		}
	}
	internal readonly record struct MixProfile(float Min, float Max, int Mask)
	{
		internal bool Silent => Mask == 0;

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			builder.Append("Min = ");
			builder.Append(Min.ToString());
			builder.Append(", Max = ");
			builder.Append(Max.ToString());
			builder.Append(", Mask = ");
			builder.Append(Mask.ToString());
			return true;
		}
	}
	internal static class CueMix
	{
		internal const int MaxVariants = 16;

		internal const double MaxMixSeconds = 60.0;

		internal const float CapFadeRatio = 0.12f;

		internal const float CapFadeMin = 0.04f;

		internal const float CapFadeMax = 0.15f;

		internal static MixProfile[] Profiles(CueDefinition cue)
		{
			SortedSet<float> sortedSet = new SortedSet<float> { 0f };
			LayerDefinition[] layers = cue.Layers;
			foreach (LayerDefinition layerDefinition in layers)
			{
				if (layerDefinition.DistanceMin > 0f)
				{
					sortedSet.Add(layerDefinition.DistanceMin);
				}
				if (float.IsFinite(layerDefinition.DistanceMax))
				{
					sortedSet.Add(layerDefinition.DistanceMax);
				}
			}
			float[] array = sortedSet.ToArray();
			List<MixProfile> list = new List<MixProfile>();
			for (int j = 0; j < array.Length; j++)
			{
				int num = 0;
				for (int k = 0; k < cue.Layers.Length; k++)
				{
					if (cue.Layers[k].DistanceMin <= array[j] && array[j] < cue.Layers[k].DistanceMax)
					{
						num |= 1 << k;
					}
				}
				float max = ((j + 1 < array.Length) ? array[j + 1] : float.PositiveInfinity);
				if (list.Count > 0)
				{
					if (list[list.Count - 1].Mask == num)
					{
						list[list.Count - 1] = list[list.Count - 1]with
						{
							Max = max
						};
						continue;
					}
				}
				list.Add(new MixProfile(array[j], max, num));
			}
			return list.ToArray();
		}

		internal static int ProfileAt(MixProfile[] profiles, float distance)
		{
			for (int i = 0; i < profiles.Length; i++)
			{
				if (distance < profiles[i].Max)
				{
					return i;
				}
			}
			return profiles.Length - 1;
		}

		internal static int Variants(CueDefinition cue)
		{
			return Math.Min(16, cue.Layers.Max((LayerDefinition layer) => layer.Clips.Length));
		}

		internal static float LayerPitch(CueDefinition cue, LayerDefinition layer, int variant, int layerIndex)
		{
			if (layer.PitchMin != layer.PitchMax)
			{
				return layer.PitchMin + (layer.PitchMax - layer.PitchMin) * Unit(cue.Name, variant, layerIndex);
			}
			return layer.PitchMin;
		}

		private static float Unit(string name, int variant, int layer)
		{
			uint num = 2166136261u;
			foreach (char c in name)
			{
				num = (num ^ c) * 16777619;
			}
			num = (num ^ (uint)variant) * 16777619;
			num = (num ^ (uint)layer) * 16777619;
			num ^= num >> 15;
			num *= 2246822519u;
			num ^= num >> 13;
			return (float)(num & 0xFFFFFF) / 16777216f;
		}

		internal static MixedAudio? Render(CueDefinition cue, MixProfile profile, int variant, Func<string, DecodedAudio> source)
		{
			if (profile.Silent)
			{
				return null;
			}
			int sampleRate = source(cue.Layers[0].Clips[0]).SampleRate;
			int channels = ((!cue.Clips.Any((string file) => source(file).Channels > 1)) ? 1 : 2);
			List<(int, float[])> list = new List<(int, float[])>();
			long frames = 0L;
			for (int num = 0; num < cue.Layers.Length; num++)
			{
				if ((profile.Mask & (1 << num)) != 0)
				{
					LayerDefinition layerDefinition = cue.Layers[num];
					float[] array = RenderLayer(cue, layerDefinition, num, variant, source(layerDefinition.Clips[variant % layerDefinition.Clips.Length]), sampleRate, channels);
					int num2 = (int)Math.Round((double)(layerDefinition.OffsetMs * (float)sampleRate) / 1000.0);
					list.Add((num2, array));
					frames = Math.Max(frames, num2 + (long)array.Length / (long)channels);
				}
			}
			if (cue.MaxSeconds > 0f)
			{
				frames = Math.Min(frames, (long)Math.Round(cue.MaxSeconds * (float)sampleRate));
			}
			if (frames <= 0 || (double)frames > 60.0 * (double)sampleRate)
			{
				throw new InvalidDataException("the mix is empty or longer than " + 60.0 + " seconds.");
			}
			float[] array2 = new float[frames * channels];
			foreach (var item3 in list)
			{
				int item = item3.Item1;
				float[] item2 = item3.Item2;
				int num3 = (int)Math.Min(item2.Length, (frames - item) * channels);
				for (int num4 = 0; num4 < num3; num4++)
				{
					array2[item * channels + num4] += item2[num4];
				}
			}
			if (cue.MaxSeconds > 0f && list.Any<(int, float[])>(((int Offset, float[] Samples) part) => part.Offset + (long)part.Samples.Length / (long)channels > frames))
			{
				int num5 = (int)Math.Min(frames / 2, Math.Round(Math.Clamp(cue.MaxSeconds * 0.12f, 0.04f, 0.15f) * (float)sampleRate));
				for (int num6 = 0; num6 < num5; num6++)
				{
					float num7 = (float)(num5 - 1 - num6) / (float)Math.Max(1, num5 - 1);
					for (int num8 = 0; num8 < channels; num8++)
					{
						array2[(frames - num5 + num6) * channels + num8] *= num7;
					}
				}
			}
			for (int num9 = 0; num9 < array2.Length; num9++)
			{
				array2[num9] = Math.Clamp(array2[num9], -1f, 1f);
			}
			return new MixedAudio(array2, channels, sampleRate);
		}

		private static float[] RenderLayer(CueDefinition cue, LayerDefinition layer, int index, int variant, DecodedAudio clip, int rate, int channels)
		{
			int frames = clip.Frames;
			int num = Math.Min(frames, (int)Math.Round(layer.RangeStart * (float)clip.SampleRate));
			int num2 = ((layer.RangeEnd < 0f) ? frames : Math.Min(frames, (int)Math.Round(layer.RangeEnd * (float)clip.SampleRate)));
			if (num >= num2)
			{
				throw new InvalidDataException("layer range is outside the clip (" + ((double)frames / (double)clip.SampleRate).ToString("F3", CultureInfo.InvariantCulture) + " s long).");
			}
			double num3 = (double)clip.SampleRate / (double)rate * (double)LayerPitch(cue, layer, variant, index);
			int num4 = (int)Math.Floor((double)(num2 - num - 1) / num3) + 1;
			float[] array = new float[num4 * channels];
			for (int i = 0; i < num4; i++)
			{
				double num5 = (double)num + (double)i * num3;
				int num6 = (int)num5;
				float num7 = (float)(num5 - (double)num6);
				int num8 = Math.Min(num6 + 1, num2 - 1);
				for (int j = 0; j < channels; j++)
				{
					int num9 = ((clip.Channels != 1) ? j : 0);
					float num10 = clip.Samples[num6 * clip.Channels + num9];
					float num11 = clip.Samples[num8 * clip.Channels + num9];
					array[i * channels + j] = num10 + (num11 - num10) * num7;
				}
			}
			if (layer.LowpassHz > 0f)
			{
				float num12 = (float)Math.Exp(Math.PI * -2.0 * (double)layer.LowpassHz / (double)rate);
				for (int k = 0; k < channels; k++)
				{
					float num13 = 0f;
					float num14 = 0f;
					for (int l = 0; l < num4; l++)
					{
						num13 = array[l * channels + k] * (1f - num12) + num13 * num12;
						num14 = (array[l * channels + k] = num13 * (1f - num12) + num14 * num12);
					}
				}
			}
			int num15 = Math.Min(num4, (int)Math.Round((double)(layer.FadeInMs * (float)rate) / 1000.0));
			int num16 = Math.Min(num4, (int)Math.Round((double)(layer.FadeOutMs * (float)rate) / 1000.0));
			for (int m = 0; m < num4; m++)
			{
				float num17 = layer.Gain;
				if (m < num15)
				{
					num17 *= (float)m / (float)Math.Max(1, num15);
				}
				int num18 = num4 - 1 - m;
				if (num18 < num16)
				{
					num17 *= (float)num18 / (float)Math.Max(1, num16);
				}
				if (num17 != 1f)
				{
					for (int n = 0; n < channels; n++)
					{
						array[m * channels + n] *= num17;
					}
				}
			}
			return array;
		}

		internal static float Loudness(CueDefinition cue, float busGain, float distance)
		{
			return cue.Gain * busGain * cue.Space.Attenuation(distance);
		}
	}
	internal enum AudioCategory
	{
		Ui,
		Weapon,
		Explosion,
		Debris,
		Ambience,
		Voice,
		Vehicle,
		Device,
		Music
	}
	internal static class AudioCategories
	{
		internal const int Count = 9;

		internal static readonly string[] Names = new string[9] { "ui", "weapon", "explosion", "debris", "ambience", "voice", "vehicle", "device", "music" };

		internal static readonly int[] Limits = new int[9] { 8, 16, 10, 12, 8, 4, 48, 10, 2 };

		internal static readonly string[] Meanings = new string[9] { "menus, prompts, confirmations and warnings", "gunfire, reloads and weapon handling", "blasts and impacts", "falling debris, shrapnel and settling rubble", "beds, hums and room tones", "speech and radio voices", "suits, drop pods and other vehicles: steps, servos, engines", "machines in the world: beacons, turrets, supply pods, terminals", "music" };

		internal static string Known => string.Join(", ", Names);

		internal static string Name(AudioCategory category)
		{
			return Names[(int)category];
		}

		internal static int Bit(AudioCategory category)
		{
			return 1 << (int)category;
		}

		internal static bool TryParse(string? name, out AudioCategory category)
		{
			int num = ((name == null) ? (-1) : Array.IndexOf<string>(Names, name));
			category = ((num >= 0) ? ((AudioCategory)num) : AudioCategory.Ui);
			return num >= 0;
		}
	}
	internal enum Place
	{
		Auto,
		TwoD,
		World,
		Follow
	}
	internal sealed class BusDefinition
	{
		internal string Name = "";

		internal AudioCategory Category;

		internal float Gain = 1f;

		internal int Seats;

		internal AudioCategory[] Duck = Array.Empty<AudioCategory>();

		internal float DuckDb = 6f;

		internal int DuckMask;
	}
	internal sealed class DistanceCurve
	{
		internal enum Kind
		{
			Linear,
			Log,
			Points
		}

		internal Kind Shape;

		internal float[] Distances = Array.Empty<float>();

		internal float[] Gains = Array.Empty<float>();

		internal float Evaluate(float distance, float near, float far, bool cull)
		{
			if (cull && distance >= far)
			{
				return 0f;
			}
			if (distance <= near)
			{
				if (Shape != Kind.Points)
				{
					return 1f;
				}
				return PointGain(distance);
			}
			switch (Shape)
			{
			case Kind.Log:
			{
				float num = near / far;
				return Math.Clamp((near / distance - num) / (1f - num), 0f, 1f);
			}
			case Kind.Points:
				return PointGain(distance);
			default:
				if (!(distance >= far))
				{
					return 1f - (distance - near) / (far - near);
				}
				return 0f;
			}
		}

		private float PointGain(float distance)
		{
			if (distance <= Distances[0])
			{
				return Gains[0];
			}
			for (int i = 1; i < Distances.Length; i++)
			{
				if (!(distance > Distances[i]))
				{
					float num = (distance - Distances[i - 1]) / (Distances[i] - Distances[i - 1]);
					return Gains[i - 1] + (Gains[i] - Gains[i - 1]) * num;
				}
			}
			return Gains[^1];
		}
	}
	internal sealed class SpaceDefinition
	{
		internal float Near = 2f;

		internal float Far = 30f;

		internal DistanceCurve Curve = new DistanceCurve();

		internal float Blend = 1f;

		internal float Spread;

		internal float Doppler;

		internal bool Cull = true;

		internal float Attenuation(float distance)
		{
			float num = Curve.Evaluate(distance, Near, Far, Cull);
			if (Cull && distance >= Far)
			{
				return 0f;
			}
			return 1f + (num - 1f) * Blend;
		}
	}
	internal sealed class LayerDefinition
	{
		internal string[] Clips = Array.Empty<string>();

		internal float OffsetMs;

		internal float Gain = 1f;

		internal float RangeStart;

		internal float RangeEnd = -1f;

		internal float FadeInMs;

		internal float FadeOutMs;

		internal float PitchMin = 1f;

		internal float PitchMax = 1f;

		internal float DistanceMin;

		internal float DistanceMax = float.PositiveInfinity;

		internal float LowpassHz;

		internal bool IsPlain
		{
			get
			{
				if (OffsetMs == 0f && Gain == 1f && RangeStart == 0f && RangeEnd < 0f && FadeInMs == 0f && FadeOutMs == 0f && PitchMin == 1f && PitchMax == 1f && DistanceMin == 0f && float.IsPositiveInfinity(DistanceMax))
				{
					return LowpassHz == 0f;
				}
				return false;
			}
		}
	}
	internal sealed class CueDefinition
	{
		internal string Name = "";

		internal LayerDefinition[] Layers = Array.Empty<LayerDefinition>();

		internal float Gain = 1f;

		internal float GainMin = 1f;

		internal float PitchMin = 1f;

		internal float PitchMax = 1f;

		internal bool Loop;

		internal int Priority = 100;

		internal int MaxVoices = 8;

		internal int MaxPerEmitter = 8;

		internal float MinInterval;

		internal bool Environment = true;

		internal string Bus = "";

		internal float MaxSeconds;

		internal Place SelfPlace;

		internal Place OtherPlace;

		internal SpaceDefinition Space = new SpaceDefinition();

		internal IEnumerable<string> Clips => Layers.SelectMany((LayerDefinition layer) => layer.Clips).Distinct<string>(StringComparer.OrdinalIgnoreCase);

		internal bool IsDirect
		{
			get
			{
				if (Layers.Length == 1 && Layers[0].IsPlain)
				{
					return MaxSeconds == 0f;
				}
				return false;
			}
		}
	}
	internal enum FieldKind
	{
		Integer,
		Number,
		Range,
		Flag,
		Choice,
		Name,
		List,
		Group
	}
	internal sealed record Field(string Name, FieldKind Kind, string Summary, double Min = 0.0, double Max = 0.0, object? Default = null, string[]? Values = null, string Unit = "", bool Required = false)
	{
		internal string Key => Name.Substring(Name.LastIndexOf('.') + 1);

		internal float MinF => (float)Min;

		internal float MaxF => (float)Max;

		internal int MinI => (int)Min;

		internal int MaxI => (int)Max;

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			RuntimeHelpers.EnsureSufficientExecutionStack();
			builder.Append("Name = ");
			builder.Append((object?)Name);
			builder.Append(", Kind = ");
			builder.Append(Kind.ToString());
			builder.Append(", Summary = ");
			builder.Append((object?)Summary);
			builder.Append(", Min = ");
			builder.Append(Min.ToString());
			builder.Append(", Max = ");
			builder.Append(Max.ToString());
			builder.Append(", Default = ");
			builder.Append(Default);
			builder.Append(", Values = ");
			builder.Append(Values);
			builder.Append(", Unit = ");
			builder.Append((object?)Unit);
			builder.Append(", Required = ");
			builder.Append(Required.ToString());
			return true;
		}
	}
	internal static class CueSchema
	{
		internal static class Bus
		{
			internal static readonly Field Category = new Field("category", FieldKind.Choice, "The global category the bus belongs to; all mods share each category's voice limit.", 0.0, 0.0, null, AudioCategories.Names, "", Required: true);

			internal static readonly Field Gain = new Field("gain", FieldKind.Number, "Volume of every cue on the bus, linear. Use either gain or gainDb.", 0.0, 4.0, 1f);

			internal static readonly Field GainDb = new Field("gainDb", FieldKind.Number, "Volume of every cue on the bus, in decibels. Use either gain or gainDb.", -60.0, 12.0, null, null, "dB");

			internal static readonly Field Seats = new Field("seats", FieldKind.Integer, "How many sounds of the bus may play at once from one emitter; the weakest are faded out for a stronger newcomer.", 1.0, 64.0, 0, null, "sounds");

			internal static readonly Field Duck = new Field("duck", FieldKind.Group, "Lowers other categories while a sound of this bus plays.");

			internal static readonly Field DuckCategories = new Field("duck.categories", FieldKind.List, "The categories to lower.", 1.0, 9.0, null, AudioCategories.Names, "", Required: true);

			internal static readonly Field DuckDb = new Field("duck.db", FieldKind.Number, "How far to lower them.", 0.5, 48.0, 6f, null, "dB");

			internal static readonly Field[] All = new Field[7] { Category, Gain, GainDb, Seats, Duck, DuckCategories, DuckDb };
		}

		internal static class Cue
		{
			internal static readonly Field BusName = new Field("bus", FieldKind.Name, "The bus the cue plays on; it must be defined in \"buses\". The bus decides the category.", 0.0, 0.0, null, null, "", Required: true);

			internal static readonly Field Layers = new Field("layers", FieldKind.List, "The layers mixed into the cue. Without it the cue plays the .ogg file of the same name.", 1.0, 8.0);

			internal static readonly Field Gain = new Field("gain", FieldKind.Range, "Volume, linear; a [min, max] pair lets each play pick between them. Use either gain or gainDb.", 0.0, 4.0, 1f);

			internal static readonly Field GainDb = new Field("gainDb", FieldKind.Range, "Volume in decibels; a [min, max] pair lets each play pick between them.", -60.0, 12.0, null, null, "dB");

			internal static readonly Field Pitch = new Field("pitch", FieldKind.Range, "Playback speed as a factor; a [min, max] pair lets each play pick between them.", 0.1, 3.0, 1f);

			internal static readonly Field Loop = new Field("loop", FieldKind.Flag, "Repeats seamlessly. A loop has exactly one layer with only clips and gain.", 0.0, 0.0, false);

			internal static readonly Field Priority = new Field("priority", FieldKind.Integer, "Higher priority wins when voices run out; 200 and up counts as a warning.", 0.0, 255.0, 100);

			internal static readonly Field MaxVoices = new Field("maxVoices", FieldKind.Integer, "How many plays of the cue may sound at once.", 1.0, 256.0, 8);

			internal static readonly Field MaxPerEmitter = new Field("maxPerEmitter", FieldKind.Integer, "How many plays of the cue may sound at once from one emitter; at most maxVoices.", 1.0, 256.0, 8);

			internal static readonly Field MinInterval = new Field("minInterval", FieldKind.Number, "The shortest gap between two plays of the cue.", 0.0, 60.0, 0f, null, "s");

			internal static readonly Field Environment = new Field("environment", FieldKind.Flag, "Whether room acoustics (occlusion, room tone) apply.", 0.0, 0.0, true);

			internal static readonly Field MaxSeconds = new Field("maxSeconds", FieldKind.Number, "The longest the cue may last; the mix is cut there and fades out. 0 means no cap.", 0.05, 60.0, 0f, null, "s");

			internal static readonly Field Place = new Field("place", FieldKind.Choice, "Where the sound sits: in the listener's head (2d), at a world point (world) or following an object (follow); auto keeps what the caller supplied. A { \"self\", \"other\" } pair sets the local player's own sounds and everyone else's separately.", 0.0, 0.0, "auto", PlaceValues);

			internal static readonly Field Space = new Field("space", FieldKind.Group, "How the cue is heard in space; see the space settings.");

			internal static readonly Field[] All = new Field[14]
			{
				BusName, Layers, Gain, GainDb, Pitch, Loop, Priority, MaxVoices, MaxPerEmitter, MinInterval,
				Environment, MaxSeconds, Place, Space
			};
		}

		internal static class Layer
		{
			internal static readonly Field Clips = new Field("clips", FieldKind.List, "The .ogg files of the layer; each play picks one.", 1.0, 32.0, null, null, "", Required: true);

			internal static readonly Field OffsetMs = new Field("offsetMs", FieldKind.Number, "Delay before the layer starts.", 0.0, 60000.0, 0f, null, "ms");

			internal static readonly Field Gain = new Field("gain", FieldKind.Number, "Layer volume, linear. Use either gain or gainDb.", 0.0, 4.0, 1f);

			internal static readonly Field GainDb = new Field("gainDb", FieldKind.Number, "Layer volume in decibels. Use either gain or gainDb.", -60.0, 12.0, null, null, "dB");

			internal static readonly Field Range = new Field("range", FieldKind.List, "[start, end] seconds of the clip to use.", 0.0, 600.0, null, null, "s");

			internal static readonly Field FadeInMs = new Field("fadeInMs", FieldKind.Number, "Fade-in length.", 0.0, 10000.0, 0f, null, "ms");

			internal static readonly Field FadeOutMs = new Field("fadeOutMs", FieldKind.Number, "Fade-out length.", 0.0, 10000.0, 0f, null, "ms");

			internal static readonly Field Pitch = new Field("pitch", FieldKind.Range, "Layer playback speed as a factor.", 0.1, 3.0, 1f);

			internal static readonly Field Distance = new Field("distance", FieldKind.Group, "The listener distances inside which the layer plays, so a far layer can replace the near one.");

			internal static readonly Field DistanceMin = new Field("distance.min", FieldKind.Number, "Nearest distance.", 0.0, 100000.0, 0f, null, "m");

			internal static readonly Field DistanceMax = new Field("distance.max", FieldKind.Number, "Farthest distance; unbounded when omitted.", 0.0, 100000.0, null, null, "m");

			internal static readonly Field LowpassHz = new Field("lowpassHz", FieldKind.Number, "Low-pass cutoff; 0 leaves the layer unfiltered.", 50.0, 20000.0, 0f, null, "Hz");

			internal static readonly Field[] All = new Field[12]
			{
				Clips, OffsetMs, Gain, GainDb, Range, FadeInMs, FadeOutMs, Pitch, Distance, DistanceMin,
				DistanceMax, LowpassHz
			};
		}

		internal static class Space
		{
			internal static readonly Field Near = new Field("near", FieldKind.Number, "Distance up to which the sound is at full volume.", 0.01, 10000.0, 2f, null, "m");

			internal static readonly Field Far = new Field("far", FieldKind.Number, "Distance beyond which the sound is silent (when cull is on); greater than near.", 0.01, 10000.0, 30f, null, "m");

			internal static readonly Field Curve = new Field("curve", FieldKind.Choice, "Loudness by distance: \"linear\", \"log\", or 2 to 32 [metres, gain] points with increasing metres.", 0.0, 0.0, "linear", CurveShapes);

			internal static readonly Field Blend = new Field("blend", FieldKind.Number, "0 hears the sound flat (no distance loss, no panning), 1 fully positioned.", 0.0, 1.0, 1f);

			internal static readonly Field Spread = new Field("spread", FieldKind.Number, "How much the sound widens, which reduces panning.", 0.0, 180.0, 0f, null, "degrees");

			internal static readonly Field Doppler = new Field("doppler", FieldKind.Number, "How strongly relative motion shifts the pitch.", 0.0, 5.0, 0f);

			internal static readonly Field Cull = new Field("cull", FieldKind.Flag, "Beyond far the sound is silent and takes no voice.", 0.0, 0.0, true);

			internal static readonly Field[] All = new Field[7] { Near, Far, Curve, Blend, Spread, Doppler, Cull };
		}

		internal const int MaxClips = 32;

		internal const int MaxLayers = 8;

		internal const float CurveMetresMax = 10000f;

		internal const float CurveGainMax = 4f;

		internal static readonly string[] PlaceValues = new string[4] { "auto", "2d", "world", "follow" };

		internal static readonly string[] CurveShapes = new string[2] { "linear", "log" };

		internal static string[] Names(Field[] fields)
		{
			return (from field in fields
				where !field.Name.Contains('.')
				select field.Name).ToArray();
		}
	}
	internal static class GainPick
	{
		internal static float At(float min, float max, double unit)
		{
			if (min >= max)
			{
				return max;
			}
			float num = (float)Math.Clamp(unit, 0.0, 1.0);
			if (!(min <= 0f))
			{
				return min * MathF.Pow(max / min, num);
			}
			return min + (max - min) * num;
		}
	}
	internal static class CategoryVolume
	{
		internal static float Map(AudioCategory category, float master, float sfx, float music, float dialogue, bool muteBackground, bool focused, float kitMaster = 1f, float kitCategory = 1f)
		{
			if (muteBackground && !focused)
			{
				return 0f;
			}
			return Unit(master) * Unit(category switch
			{
				AudioCategory.Music => music, 
				AudioCategory.Voice => dialogue, 
				_ => sfx, 
			}) * Unit(kitMaster) * Unit(kitCategory);
		}

		private static float Unit(float n)
		{
			if (!float.IsFinite(n))
			{
				return 0f;
			}
			return Math.Clamp(n, 0f, 1f);
		}
	}
	internal enum ListenerDecision
	{
		Unavailable,
		ReuseExternal,
		KeepOwned,
		CreateOwned
	}
	internal static class ListenerPolicy
	{
		internal static ListenerDecision Decide(bool cameraActive, bool ownedOnCamera, int otherActive)
		{
			if (otherActive <= 0)
			{
				if (cameraActive)
				{
					if (!ownedOnCamera)
					{
						return ListenerDecision.CreateOwned;
					}
					return ListenerDecision.KeepOwned;
				}
				return ListenerDecision.Unavailable;
			}
			return ListenerDecision.ReuseExternal;
		}
	}
	internal enum OneShotState
	{
		Playing,
		Completed,
		Stalled
	}
	internal struct OneShotProgress
	{
		private double _phase;

		private double _lastDsp;

		private double _lastPosition;

		private double _lastProgress;

		private double _started;

		internal OneShotProgress(double position, double dsp, double now)
		{
			_phase = (_lastPosition = position);
			_lastDsp = dsp;
			_lastProgress = (_started = now);
		}

		internal OneShotState Update(double position, bool playing, double duration, float pitch, double dsp, double now)
		{
			double num = Math.Max(0.0, dsp - _lastDsp);
			_lastDsp = dsp;
			_phase = Math.Max(position, _phase + num * (double)pitch);
			if (num > 0.0 || position > _lastPosition)
			{
				_lastProgress = now;
			}
			_lastPosition = position;
			if (position >= duration || _phase >= duration + 0.25 || (!playing && now - _started >= 0.1))
			{
				return OneShotState.Completed;
			}
			if (!(now - _lastProgress >= 2.0))
			{
				return OneShotState.Playing;
			}
			return OneShotState.Stalled;
		}
	}
	internal enum VoiceGroup
	{
		General,
		Dialogue,
		Warning,
		EnvironmentLoop
	}
	internal readonly record struct VoiceRank(int Priority, float Audibility, double Started, VoiceGroup Group = VoiceGroup.General);
	internal static class VoicePolicy
	{
		internal const int Capacity = 64;

		internal const int LogicalCapacity = 256;

		internal static bool CanSteal(VoiceRank incoming, VoiceRank current, double now)
		{
			if (now - current.Started >= 0.1)
			{
				if (incoming.Priority <= current.Priority)
				{
					if (incoming.Priority == current.Priority)
					{
						return incoming.Audibility > current.Audibility + 0.05f;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		internal static bool Less(VoiceRank a, VoiceRank b)
		{
			if (a.Priority >= b.Priority)
			{
				if (a.Priority == b.Priority)
				{
					if (!(a.Audibility < b.Audibility))
					{
						if (a.Audibility == b.Audibility)
						{
							return a.Started < b.Started;
						}
						return false;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		internal static int Select(ReadOnlySpan<VoiceRank?> active, VoiceRank incoming, double now)
		{
			Span<int> span = stackalloc int[4];
			span.Clear();
			for (int i = 0; i < active.Length; i++)
			{
				VoiceRank? voiceRank = active[i];
				if (!voiceRank.HasValue)
				{
					return i;
				}
				span[(int)voiceRank.GetValueOrDefault().Group]++;
			}
			bool flag = span[(int)incoming.Group] < Reserved(incoming.Group);
			int num = -1;
			int num2 = -1;
			for (int j = 0; j < active.Length; j++)
			{
				VoiceRank value = active[j].Value;
				if (value.Group == incoming.Group || span[(int)value.Group] > Reserved(value.Group))
				{
					if (flag && value.Group != incoming.Group && now - value.Started >= 0.1 && (num2 < 0 || Less(value, active[num2].Value)))
					{
						num2 = j;
					}
					if (CanSteal(incoming, value, now) && (num < 0 || Less(value, active[num].Value)))
					{
						num = j;
					}
				}
			}
			if (num2 < 0)
			{
				return num;
			}
			return num2;
		}

		internal static int Reserved(VoiceGroup group)
		{
			if (group != VoiceGroup.General)
			{
				return 8;
			}
			return 0;
		}

		internal static VoiceGroup Group(AudioCategory category, bool loop, int priority)
		{
			if (category == AudioCategory.Voice)
			{
				return VoiceGroup.Dialogue;
			}
			VoiceGroup result;
			if (priority >= 200)
			{
				result = VoiceGroup.Warning;
			}
			else
			{
				bool flag = loop;
				if (flag)
				{
					bool flag2 = ((category == AudioCategory.Ambience || category == AudioCategory.Music) ? true : false);
					flag = flag2;
				}
				result = (flag ? VoiceGroup.EnvironmentLoop : VoiceGroup.General);
			}
			return result;
		}
	}
	internal readonly record struct BusMember(int Priority, float Audibility, double Started);
	internal static class BusPolicy
	{
		internal const float ReplaceFade = 0.06f;

		internal static int Evict(ReadOnlySpan<BusMember> holders, int seats, int incomingPriority, float incomingAudibility, Span<int> victims)
		{
			int num = holders.Length - seats + 1;
			if (num <= 0)
			{
				return 0;
			}
			for (int i = 0; i < holders.Length; i++)
			{
				victims[i] = i;
			}
			for (int j = 1; j < holders.Length; j++)
			{
				int num2 = victims[j];
				int num3 = j - 1;
				while (num3 >= 0 && Weaker(holders[num2], holders[victims[num3]]))
				{
					victims[num3 + 1] = victims[num3];
					num3--;
				}
				victims[num3 + 1] = num2;
			}
			for (int k = 0; k < num; k++)
			{
				BusMember busMember = holders[victims[k]];
				if (busMember.Priority > incomingPriority || (busMember.Priority == incomingPriority && incomingAudibility < busMember.Audibility * 0.5f))
				{
					return -1;
				}
			}
			return num;
		}

		internal static bool Weaker(BusMember a, BusMember b)
		{
			if (a.Priority == b.Priority)
			{
				if (a.Audibility == b.Audibility)
				{
					return a.Started < b.Started;
				}
				return a.Audibility < b.Audibility;
			}
			return a.Priority < b.Priority;
		}
	}
	internal enum CategoryAdmission
	{
		Room,
		PushOut,
		Refuse
	}
	internal static class CategoryPolicy
	{
		internal static CategoryAdmission Admit(ReadOnlySpan<BusMember> holders, int limit, int incomingPriority, float incomingAudibility, out int victim)
		{
			victim = -1;
			if (holders.Length < limit)
			{
				return CategoryAdmission.Room;
			}
			int num = 0;
			for (int i = 1; i < holders.Length; i++)
			{
				if (BusPolicy.Weaker(holders[i], holders[num]))
				{
					num = i;
				}
			}
			BusMember busMember = holders[num];
			if (incomingPriority > busMember.Priority || (incomingPriority == busMember.Priority && incomingAudibility > busMember.Audibility))
			{
				victim = num;
				return CategoryAdmission.PushOut;
			}
			return CategoryAdmission.Refuse;
		}
	}
	internal readonly record struct DuckSource(int Index, int Mask, float Factor);
	internal static class DuckPolicy
	{
		internal const float DownRate = 25f;

		internal const float UpRate = 6f;

		internal static float Factor(float decibels)
		{
			return MathF.Pow(10f, (0f - decibels) / 20f);
		}

		internal static float Target(ReadOnlySpan<DuckSource> duckers, int index, AudioCategory category)
		{
			int num = AudioCategories.Bit(category);
			float num2 = 1f;
			ReadOnlySpan<DuckSource> readOnlySpan = duckers;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				DuckSource duckSource = readOnlySpan[i];
				if (duckSource.Index != index && (duckSource.Mask & num) != 0 && duckSource.Factor < num2)
				{
					num2 = duckSource.Factor;
				}
			}
			return num2;
		}

		internal static float Step(float current, float target, float dt)
		{
			return current + (target - current) * (1f - MathF.Exp((0f - dt) * ((target < current) ? 25f : 6f)));
		}
	}
	internal sealed class OcclusionSchedule
	{
		internal const int RaysPerFrame = 4;

		internal const double Interval = 0.2;

		private readonly double[] _due = new double[64];

		private int _cursor;

		private int _frame = -1;

		private int _used;

		internal void Reset(int slot)
		{
			_due[slot] = 0.0;
		}

		internal int Next(int frame, double now, bool[] eligible)
		{
			if (frame != _frame)
			{
				_frame = frame;
				_used = 0;
			}
			if (_used == 4)
			{
				return -1;
			}
			for (int i = 0; i < _due.Length; i++)
			{
				int cursor = _cursor;
				_cursor = (_cursor + 1) % _due.Length;
				if (eligible[cursor] && !(now < _due[cursor]))
				{
					_due[cursor] = now + 0.2;
					_used++;
					return cursor;
				}
			}
			return -1;
		}
	}
	internal sealed class EndGate
	{
		internal bool Ended { get; private set; }

		internal bool End()
		{
			if (Ended)
			{
				return false;
			}
			Ended = true;
			return true;
		}
	}
	internal enum PrewarmStep
	{
		Started,
		Waiting,
		Refused
	}
	internal sealed class PrewarmProgress
	{
		internal const int MaxRefused = 600;

		private readonly string _identity;

		private readonly string[] _cues;

		private int _next;

		private int _refused;

		internal bool Done { get; private set; }

		internal string? Current
		{
			get
			{
				if (!Done)
				{
					return _cues[_next];
				}
				return null;
			}
		}

		internal PrewarmProgress(string identity, string[] cues)
		{
			_identity = identity;
			_cues = cues;
			Done = cues.Length == 0;
		}

		internal static string[] OneShots(IEnumerable<CueDefinition> cues)
		{
			List<string> list = new List<string>();
			foreach (CueDefinition cue in cues)
			{
				if (!cue.Loop)
				{
					list.Add(cue.Name);
				}
			}
			return list.ToArray();
		}

		internal string? Report(PrewarmStep step, string detail = "")
		{
			if (Done)
			{
				return null;
			}
			switch (step)
			{
			case PrewarmStep.Waiting:
				return null;
			case PrewarmStep.Refused:
				if (++_refused < 600)
				{
					return null;
				}
				Done = true;
				return _identity + " sounds could not be prewarmed: " + _cues[_next] + " was refused " + _refused + " times (" + detail + ").";
			default:
				_refused = 0;
				if (++_next >= _cues.Length)
				{
					Done = true;
				}
				return null;
			}
		}
	}
	internal static class CueRequirement
	{
		internal static string? Missing(Func<string, bool> has, IEnumerable<string> cues)
		{
			List<string> list = null;
			foreach (string cue in cues)
			{
				if (!has(cue))
				{
					(list ?? (list = new List<string>())).Add(cue);
				}
			}
			if (list != null)
			{
				return string.Join(", ", list);
			}
			return null;
		}
	}
	public enum AudioError
	{
		None,
		InvalidSettings,
		InvalidSource,
		PathOutsideRoot,
		UnsupportedCodec,
		DecodeFailed,
		AssetLimit,
		InvalidIdentity,
		DuplicateLibrary,
		NotReady,
		LibraryDisposed,
		CueNotFound,
		WrongThread,
		InvalidOptions,
		ListenerUnavailable,
		TargetDestroyed,
		VoiceLimit,
		EnvironmentUnavailable,
		CallbackFailed,
		DeviceChanged,
		Cancelled,
		VoiceFailed
	}
	public readonly struct AudioFailure
	{
		public AudioError Code { get; }

		public string Detail { get; }

		internal AudioFailure(AudioError code, string detail)
		{
			Code = code;
			Detail = detail;
		}

		public override string ToString()
		{
			return Code.ToString() + ": " + Detail;
		}
	}
	internal readonly struct Result<T>
	{
		private readonly T _value;

		private readonly AudioFailure _error;

		public bool Success { get; }

		public AudioFailure Error
		{
			get
			{
				if (Success || _error.Code != AudioError.None)
				{
					return _error;
				}
				return new AudioFailure(AudioError.NotReady, "Uninitialized result.");
			}
		}

		public T Value
		{
			get
			{
				if (!Success)
				{
					throw new InvalidOperationException(Error.ToString());
				}
				return _value;
			}
		}

		private Result(T value)
		{
			_value = value;
			Success = true;
			_error = default(AudioFailure);
		}

		private Result(AudioFailure error)
		{
			_value = default(T);
			Success = false;
			_error = error;
		}

		internal static Result<T> Ok(T value)
		{
			return new Result<T>(value);
		}

		internal static Result<T> Fail(AudioError code, string detail)
		{
			return new Result<T>(new AudioFailure(code, detail));
		}

		internal static Result<T> Fail(AudioFailure failure)
		{
			return new Result<T>(failure);
		}
	}
	internal static class AudioLog
	{
		internal static Action<string, AudioFailure> Sink = delegate(string key, AudioFailure error)
		{
			Console.Error.WriteLine("ForgeAudio " + error);
		};

		internal static void Report(string key, AudioFailure error)
		{
			Sink(key, error);
		}

		internal static void Report(string key, AudioError code, string detail)
		{
			Report(key, new AudioFailure(code, detail));
		}

		internal static void Report(AudioFailure error)
		{
			Sink(error.ToString(), error);
		}

		internal static void Report(AudioError code, string detail)
		{
			Report(new AudioFailure(code, detail));
		}
	}
	[Flags]
	public enum BodySound
	{
		Footstep = 1,
		Movement = 2
	}
	[Flags]
	public enum WeaponAction
	{
		ReloadStart = 1,
		ReloadDone = 2,
		DryFire = 4
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	internal struct SyncedPlay
	{
		internal ulong Library;

		internal ulong Cue;

		internal float X;

		internal float Y;

		internal float Z;

		internal float Gain;

		internal float CueGain;

		internal float Pitch;

		internal float StartSeconds;

		internal int Dimension;

		internal byte Variant;

		internal byte Place;
	}
	internal enum SyncPlace : byte
	{
		TwoD,
		World
	}
	internal readonly record struct SyncRequest(ulong Library, ulong Cue, SyncPlace Place, float X, float Y, float Z, float Gain, float CueGain, float Pitch, float StartSeconds, int Dimension, int Variant);
	internal static class SyncCodec
	{
		internal const int MaxVariant = 254;

		internal static SyncedPlay Encode(ulong library, ulong cue, SyncPlace place, float x, float y, float z, float gain, float cueGain, float pitch, float startSeconds, int dimension, int variant)
		{
			return new SyncedPlay
			{
				Library = library,
				Cue = cue,
				Place = (byte)place,
				X = x,
				Y = y,
				Z = z,
				Gain = gain,
				CueGain = cueGain,
				Pitch = pitch,
				StartSeconds = startSeconds,
				Dimension = ((place == SyncPlace.TwoD) ? (-1) : dimension),
				Variant = (byte)Math.Clamp(variant, 0, 254)
			};
		}

		internal static bool TryDecode(in SyncedPlay message, out SyncRequest request, out string reason)
		{
			request = default(SyncRequest);
			reason = "";
			if (message.Place > 1)
			{
				reason = "unknown placement " + message.Place;
				return false;
			}
			SyncPlace place = (SyncPlace)message.Place;
			if (message.Library == 0L || message.Cue == 0L)
			{
				reason = "no library or cue";
				return false;
			}
			if (!In(message.Gain, 0f, 4f) || !In(message.CueGain, 0f, 4f) || !In(message.Pitch, 0.1f, 3f) || !In(message.StartSeconds, 0f, 3600f))
			{
				reason = "gain, cue volume, pitch or start out of range";
				return false;
			}
			if (place == SyncPlace.World && (!float.IsFinite(message.X) || !float.IsFinite(message.Y) || !float.IsFinite(message.Z) || message.Dimension < 0))
			{
				reason = "a world sound needs a finite position and a dimension";
				return false;
			}
			if (message.Variant > 254)
			{
				reason = "variant out of range";
				return false;
			}
			request = new SyncRequest(message.Library, message.Cue, place, message.X, message.Y, message.Z, message.Gain, message.CueGain, message.Pitch, message.StartSeconds, (place == SyncPlace.TwoD) ? (-1) : message.Dimension, message.Variant);
			return true;
		}

		private static bool In(float value, float min, float max)
		{
			if (float.IsFinite(value) && value >= min)
			{
				return value <= max;
			}
			return false;
		}
	}
	internal static class SyncKey
	{
		internal static ulong Of(string name)
		{
			ulong num = 14695981039346656037uL;
			for (int i = 0; i < name.Length; i++)
			{
				char c = char.ToLowerInvariant(name[i]);
				num = Fnv.Mix64(Fnv.Mix64(num, (byte)c), (byte)((int)c >> 8));
			}
			if (num != 0L)
			{
				return num;
			}
			return 1uL;
		}
	}
	internal static class VariantPick
	{
		internal static int Next(int count, ref int last, Random random)
		{
			if (count < 2)
			{
				last = 0;
				return 0;
			}
			int num = random.Next(count - 1);
			if (num >= last)
			{
				num++;
			}
			return last = num;
		}
	}
	internal sealed record DecodedAudio(float[] Samples, int Channels, int SampleRate)
	{
		internal int Frames => Samples.Length / Channels;

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			RuntimeHelpers.EnsureSufficientExecutionStack();
			builder.Append("Samples = ");
			builder.Append(Samples);
			builder.Append(", Channels = ");
			builder.Append(Channels.ToString());
			builder.Append(", SampleRate = ");
			builder.Append(SampleRate.ToString());
			return true;
		}
	}
	internal static class VorbisDecode
	{
		private sealed class BoundedPackets : IPacketProvider
		{
			private readonly IPacketProvider _inner;

			private readonly CancellationToken _cancellation;

			private readonly int _limit;

			private int _served;

			public bool CanSeek => false;

			public int StreamSerial => _inner.StreamSerial;

			internal BoundedPackets(IPacketProvider inner, int limit, CancellationToken cancellation)
			{
				_inner = inner;
				_limit = limit;
				_cancellation = cancellation;
			}

			public IPacket? GetNextPacket()
			{
				_cancellation.ThrowIfCancellationRequested();
				if (++_served > _limit)
				{
					throw new InvalidDataException("Vorbis stream yields more packets than the file can hold.");
				}
				IPacket nextPacket = _inner.GetNextPacket();
				if (nextPacket != null)
				{
					return (IPacket?)(object)new Packet(nextPacket);
				}
				return null;
			}

			public IPacket? PeekNextPacket()
			{
				IPacket val = _inner.PeekNextPacket();
				if (val != null)
				{
					return (IPacket?)(object)new Packet(val);
				}
				return null;
			}

			public long SeekTo(long granulePos, int preRoll, GetPacketGranuleCount getPacketGranuleCount)
			{
				throw new NotSupportedException("Kit decodes whole clips without seeking.");
			}

			public long GetGranuleCount()
			{
				return _inner.GetGranuleCount();
			}
		}

		private sealed class Packet : IPacket
		{
			private readonly IPacket _inner;

			public bool IsResync => _inner.IsResync;

			public bool IsShort => _inner.IsShort;

			public long? GranulePosition => _inner.GranulePosition;

			public bool IsEndOfStream => false;

			public int BitsRead => _inner.BitsRead;

			public int BitsRemaining => _inner.BitsRemaining;

			public int ContainerOverheadBits => _inner.ContainerOverheadBits;

			internal Packet(IPacket inner)
			{
				_inner = inner;
			}

			public ulong TryPeekBits(int count, out int bitsRead)
			{
				return _inner.TryPeekBits(count, ref bitsRead);
			}

			public void SkipBits(int count)
			{
				_inner.SkipBits(count);
			}

			public ulong ReadBits(int count)
			{
				return _inner.ReadBits(count);
			}

			public void Done()
			{
				_inner.Done();
			}

			public void Reset()
			{
				_inner.Reset();
			}
		}

		internal const int ToleranceFrames = 16384;

		private const int ChunkFrames = 16384;

		internal static DecodedAudio Decode(byte[] bytes, OggInfo info, CancellationToken cancellation)
		{
			cancellation.ThrowIfCancellationRequested();
			try
			{
				return DecodeChecked(bytes, info, cancellation);
			}
			catch (Exception ex) when ((!(ex is InvalidDataException) && !(ex is OperationCanceledException)) || 1 == 0)
			{
				throw new InvalidDataException("Vorbis decoder rejected the stream: " + ex.GetType().Name + ": " + ex.Message, ex);
			}
		}

		private static DecodedAudio DecodeChecked(byte[] bytes, OggInfo info, CancellationToken cancellation)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			ContainerReader val = new ContainerReader((Stream)new MemoryStream(bytes, writable: false), true);
			try
			{
				IPacketProvider stream = null;
				val.NewStreamCallback = (NewStreamHandler)delegate(IPacketProvider provider)
				{
					if (stream == null)
					{
						stream = provider;
					}
					return true;
				};
				if (!val.TryInit() || stream == null)
				{
					throw new InvalidDataException("No Vorbis stream in the Ogg container.");
				}
				StreamDecoder val2 = new StreamDecoder((IPacketProvider)(object)new BoundedPackets(stream, bytes.Length + 16, cancellation))
				{
					ClipSamples = true
				};
				try
				{
					if (val2.Channels != info.Channels || val2.SampleRate != info.SampleRate)
					{
						throw new InvalidDataException("Vorbis header disagrees with the Ogg identification page.");
					}
					int channels = info.Channels;
					int num = checked((int)((info.Frames + 16384) * channels));
					float[] array = new float[num];
					int num2 = 0;
					while (true)
					{
						cancellation.ThrowIfCancellationRequested();
						int num3 = Math.Min(16384 * channels, num - num2);
						if (num3 == 0)
						{
							if (val2.Read((Span<float>)new float[channels], 0, channels) == 0)
							{
								break;
							}
							throw new InvalidDataException("Vorbis audio runs more than " + 16384 + " frames past its declared end.");
						}
						int num4 = val2.Read((Span<float>)array, num2, num3);
						if (num4 == 0)
						{
							break;
						}
						num2 += num4;
					}
					int num5 = num2 / channels;
					if (num5 <= 0 || info.Frames - num5 > 16384)
					{
						throw new InvalidDataException("Vorbis audio ends " + (info.Frames - num5) + " frames before its declared end.");
					}
					Array.Resize(ref array, (int)Math.Min(num5, info.Frames) * channels);
					for (int num6 = 0; num6 < array.Length; num6++)
					{
						if (!float.IsFinite(array[num6]))
						{
							throw new InvalidDataException("Vorbis decoder produced non-finite samples.");
						}
					}
					return new DecodedAudio(array, channels, info.SampleRate);
				}
				finally
				{
					((IDisposable)val2)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
	}
	public enum PlayStatus
	{
		Failed,
		Played,
		Virtualized,
		DistanceCulled,
		BudgetRejected,
		Throttled
	}
	public enum PlaybackState
	{
		Playing,
		Virtualized,
		Fading,
		Ended
	}
	public enum EndReason
	{
		Completed,
		Stopped,
		Stolen,
		TargetDestroyed,
		LevelExit,
		CheckpointReload,
		LibraryDisposed,
		DeviceChanged,
		Failed,
		PluginUnloaded,
		Replaced,
		PushedOut
	}
	public sealed class PlayOptions
	{
		private static readonly Dictionary<float, PlayOptions> Gains = new Dictionary<float, PlayOptions>();

		public float Gain { get; init; } = 1f;

		public float? Pitch { get; init; }

		public int? Variant { get; init; }

		public float StartSeconds { get; init; }

		public bool IsSelf { get; init; }

		public int? Dimension { get; init; }

		public object? Emitter { get; init; }

		public static PlayOptions OfGain(float gain)
		{
			if (!Gains.TryGetValue(gain, out PlayOptions value))
			{
				Dictionary<float, PlayOptions> gains = Gains;
				PlayOptions obj = new PlayOptions
				{
					Gain = gain
				};
				value = obj;
				gains.Add(gain, obj);
			}
			return value;
		}
	}
	public readonly struct PlayResult
	{
		private readonly AudioFailure _error;

		public PlayStatus Status { get; }

		public AudioHandle? Handle { get; }

		public AudioFailure Error
		{
			get
			{
				if (Status != PlayStatus.Failed || _error.Code != AudioError.None)
				{
					return _error;
				}
				return new AudioFailure(AudioError.NotReady, "Uninitialized play result.");
			}
		}

		public bool Accepted
		{
			get
			{
				PlayStatus status = Status;
				if ((uint)(status - 1) <= 1u)
				{
					return true;
				}
				return false;
			}
		}

		internal PlayResult(PlayStatus status, AudioHandle? handle = null, AudioFailure error = default(AudioFailure))
		{
			Status = status;
			Handle = handle;
			_error = error;
		}
	}
	public sealed class AudioHandle
	{
		internal readonly EndGate Gate = new EndGate();

		internal Playback? Playback;

		public long Generation { get; }

		public PlaybackState State => Playback?.State ?? PlaybackState.Ended;

		public EndReason? Reason { get; private set; }

		public event Action<EndReason>? Ended;

		internal AudioHandle(long generation)
		{
			Generation = generation;
		}

		public bool Stop(float fadeSeconds = 0f)
		{
			return Engine.Control(this, fadeSeconds, ControlKind.Stop);
		}

		public bool SetGain(float gain)
		{
			return Engine.Control(this, gain, ControlKind.Gain);
		}

		internal void Finish(EndReason reason)
		{
			if (Gate.End())
			{
				Playback = null;
				Reason = reason;
				Engine.NotifyEnded(this);
			}
		}

		internal void DispatchEnded()
		{
			Action<EndReason> action = this.Ended;
			this.Ended = null;
			if (action == null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<EndReason> action2 = (Action<EndReason>)invocationList[i];
				try
				{
					action2(Reason.Value);
				}
				catch (Exception ex)
				{
					AudioLog.Report(AudioError.CallbackFailed, ex.ToString());
				}
			}
		}
	}
	public sealed class AudioLibrary : IDisposable
	{
		internal Catalog Catalog = new Catalog();

		internal readonly Dictionary<string, CueHandle> Cues = new Dictionary<string, CueHandle>(StringComparer.OrdinalIgnoreCase);

		internal readonly List<ClipLease> Assets = new List<ClipLease>();

		internal readonly ulong Key;

		internal readonly Dictionary<ulong, CueHandle> CueKeys = new Dictionary<ulong, CueHandle>();

		private static readonly PlayOptions Silent = new PlayOptions
		{
			Gain = 0f
		};

		private PrewarmProgress? _prewarm;

		public string Identity { get; }

		public string Folder { get; }

		public bool IsLoaded { get; internal set; }

		public bool IsDisposed { get; private set; }

		public AudioFailure? Error { get; internal set; }

		internal AudioLibrary(string identity, string folder)
		{
			Identity = identity;
			Folder = folder;
			Key = SyncKey.Of(identity);
		}

		public AudioCue Cue(string cue)
		{
			return new AudioCue(this, cue ?? throw new ArgumentNullException("cue"));
		}

		public bool Has(string cue)
		{
			if (cue != null)
			{
				return Cues.ContainsKey(cue);
			}
			return false;
		}

		public PlayResult Play(string cue, PlayOptions? options = null)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Engine.Play(this, cue, EmitterKind.TwoD, default(Vector3), null, options);
		}

		public PlayResult Play(string cue, Vector3 position, PlayOptions? options = null)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return Engine.Play(this, cue, EmitterKind.Positioned, position, null, options);
		}

		public PlayResult Play(string cue, Transform follow, PlayOptions? options = null)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Engine.Play(this, cue, EmitterKind.Attached, default(Vector3), follow, options);
		}

		public void StopAll(float fadeSeconds = 0f)
		{
			Engine.StopLibrary(this, fadeSeconds);
		}

		public void Dispose()
		{
			if (!IsDisposed)
			{
				if (!AudioKit.Ready)
				{
					IsDisposed = true;
					return;
				}
				if (Environment.CurrentManagedThreadId != AudioKit.MainThread)
				{
					Engine.QueueDispose(this);
					return;
				}
				IsDisposed = true;
				Engine.DisposeLibrary(this);
			}
		}

		public AudioSustain Sustain(string cue, Transform owner, PlayOptions? options = null, Func<bool>? keepWhile = null)
		{
			if ((Object)(object)owner == (Object)null)
			{
				throw new ArgumentNullException("owner");
			}
			AudioSustain audioSustain = new AudioSustain(this, cue, owner, options, keepWhile);
			if (Emitter.Gone((Object?)(object)owner) || IsDisposed)
			{
				audioSustain.IsActive = false;
				return audioSustain;
			}
			audioSustain.Voice = Play(cue, owner, options).Handle;
			Sustains.Add(audioSustain);
			return audioSustain;
		}

		public AudioVoice Voice(Transform anchor)
		{
			return new AudioVoice(this, anchor ?? throw new ArgumentNullException("anchor"));
		}

		public void Require(params string[] cues)
		{
			AudioFailure? error = Error;
			if (error.HasValue)
			{
				AudioFailure valueOrDefault = error.GetValueOrDefault();
				throw new InvalidDataException(Identity + " sounds cannot load: " + valueOrDefault);
			}
			if (!IsLoaded)
			{
				throw new InvalidOperationException(Identity + " sounds have not finished loading.");
			}
			string text = CueRequirement.Missing(Has, cues);
			if (text != null)
			{
				throw new InvalidDataException(Identity + " sounds missing from the audio folder or its cues.json: " + text);
			}
		}

		public bool Prewarm()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (IsDisposed || Error.HasValue)
			{
				return true;
			}
			if (!IsLoaded)
			{
				return false;
			}
			if (_prewarm == null)
			{
				_prewarm = new PrewarmProgress(Identity, PrewarmProgress.OneShots(Cues.Values.Select((CueHandle cue) => cue.Definition)));
			}
			string current = _prewarm.Current;
			if (current == null)
			{
				return true;
			}
			PlayResult playResult = Play(current, GameContext.Ear, Silent);
			PrewarmStep step = ((playResult.Status == PlayStatus.Failed) ? ((playResult.Error.Code == AudioError.ListenerUnavailable) ? PrewarmStep.Waiting : PrewarmStep.Refused) : PrewarmStep.Started);
			string text = _prewarm.Report(step, playResult.Error.Detail);
			if (text != null)
			{
				AudioLog.Report(AudioError.NotReady, text);
			}
			return _prewarm.Done;
		}

		internal void ResetPrewarm()
		{
			_prewarm = null;
		}

		public PlayResult Play(string cue, GameObject follow, PlayOptions? options = null)
		{
			if (!Emitter.Gone((Object?)(object)follow))
			{
				return Play(cue, follow.transform, options);
			}
			return Engine.TargetGone(this, cue);
		}

		public AudioSustain Sustain(string cue, GameObject owner, PlayOptions? options = null, Func<bool>? keepWhile = null)
		{
			if (!Emitter.Gone((Object?)(object)owner))
			{
				return Sustain(cue, owner.transform, options, keepWhile);
			}
			return new AudioSustain(this, cue, null, options, keepWhile)
			{
				IsActive = false
			};
		}
	}
	public interface IWeaponActionHandler
	{
		void Play(WeaponAction action);
	}
	public sealed class WeaponActionClaim : IDisposable
	{
		internal readonly IWeaponActionHandler Handler;

		internal ClaimBook<WeaponActionClaim>.Entry? Entry;

		internal bool HandlerFailed;

		public string ModId { get; }

		public Item Weapon { get; }

		public WeaponAction Kinds { get; }

		public int Priority { get; }

		public bool Active => Entry?.Live ?? false;

		internal WeaponActionClaim(string modId, Item weapon, WeaponAction kinds, int priority, IWeaponActionHandler handler)
		{
			ModId = modId;
			Weapon = weapon;
			Kinds = kinds;
			Priority = priority;
			Handler = handler;
		}

		public void Dispose()
		{
			if (Entry != null)
			{
				WeaponActions.Book.Remove(Entry);
			}
		}
	}
	public static class AudioKit
	{
		public const string PluginId = "NAinfini.ForgeAudio";

		public const string FolderName = "audio";

		internal static int MainThread;

		internal static bool Ready;

		private static readonly Dictionary<string, uint> GameEventIds = new Dictionary<string, uint>(StringComparer.OrdinalIgnoreCase);

		internal static bool OnMainThread
		{
			get
			{
				if (Ready)
				{
					return Environment.CurrentManagedThreadId == MainThread;
				}
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static AudioLibrary Load(string identity, string? folder = null)
		{
			if (folder == null)
			{
				string location = Assembly.GetCallingAssembly().Location;
				folder = (string.IsNullOrEmpty(location) ? "" : Path.Combine(Path.GetDirectoryName(location), "audio"));
			}
			return Assets.Load(identity, folder);
		}

		internal static bool ValidIdentity(string? identity)
		{
			if (identity != null && identity.Length <= 100)
			{
				return Regex.IsMatch(identity, "^[A-Za-z0-9][A-Za-z0-9_.-]*$");
			}
			return false;
		}

		public static BodySoundClaim? ClaimBodySounds(string modId, GameObject root, BodySound kinds, IBodySoundHandler handler, int priority = 0)
		{
			return BodySounds.Claim(modId, root, kinds, handler, priority);
		}

		public static WeaponActionClaim? ClaimWeaponActions(string modId, Item weapon, WeaponAction kinds, IWeaponActionHandler handler, int priority = 0)
		{
			return WeaponActions.Claim(modId, weapon, kinds, handler, priority);
		}

		public static bool PostGameEvent(uint eventId, Vector3 position)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (eventId == 0)
			{
				AudioLog.Report(AudioError.InvalidOptions, "A game sound event needs a non-zero event ID.");
				return false;
			}
			if (!OnMainThread)
			{
				AudioLog.Report(AudioError.WrongThread, "PostGameEvent must be called on the Unity main thread after the kit started.");
				return false;
			}
			try
			{
				CellSound.Post(eventId, position);
				return true;
			}
			catch (Exception ex)
			{
				AudioLog.Report(AudioError.VoiceFailed, "Game sound event " + eventId + " could not be posted: " + ex);
				return false;
			}
		}

		public static bool PostGameEvent(string eventName, Vector3 position)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(eventName))
			{
				AudioLog.Report(AudioError.InvalidOptions, "A game sound event needs a name.");
				return false;
			}
			if (!OnMainThread)
			{
				AudioLog.Report(AudioError.WrongThread, "PostGameEvent must be called on the Unity main thread after the kit started.");
				return false;
			}
			if (!GameEventIds.TryGetValue(eventName, out var value))
			{
				try
				{
					Type typeFromHandle = typeof(EVENTS);
					object obj = typeFromHandle.GetProperty(eventName, BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public)?.GetValue(null) ?? typeFromHandle.GetField(eventName, BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
					if (obj == null)
					{
						AudioLog.Report(AudioError.CueNotFound, "The game has no sound event named '" + eventName + "' (AK.EVENTS).");
						return false;
					}
					value = Convert.ToUInt32(obj);
				}
				catch (Exception ex)
				{
					AudioLog.Report(AudioError.CueNotFound, "The game sound event '" + eventName + "' could not be read: " + ex);
					return false;
				}
				GameEventIds[eventName] = value;
			}
			return PostGameEvent(value, position);
		}

		public static int DimensionAt(Vector3 position, bool preferLocalPlayer = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GameContext.DimensionAt(position, preferLocalPlayer);
		}
	}
	public interface IBodySoundHandler
	{
		bool Play(BodySound kind, Vector3 position);
	}
	public sealed class BodySoundClaim : IDisposable
	{
		internal readonly IBodySoundHandler Handler;

		internal readonly Transform RootTransform;

		internal ClaimBook<BodySoundClaim>.Entry? Entry;

		internal bool HandlerFailed;

		public string ModId { get; }

		public GameObject Root { get; }

		public BodySound Kinds { get; }

		public int Priority { get; }

		public bool Active => Entry?.Live ?? false;

		internal BodySoundClaim(string modId, GameObject root, BodySound kinds, int priority, IBodySoundHandler handler)
		{
			ModId = modId;
			Root = root;
			Kinds = kinds;
			Priority = priority;
			Handler = handler;
			RootTransform = root.transform;
		}

		public void Refresh()
		{
			if (Active)
			{
				if ((Object)(object)Root == (Object)null || ((Il2CppObjectBase)Root).WasCollected)
				{
					Dispose();
				}
				else
				{
					BodySounds.Book.Reset(Entry, BodySounds.Collect(Root));
				}
			}
		}

		public void Dispose()
		{
			if (Entry != null)
			{
				BodySounds.Book.Remove(Entry);
			}
		}
	}
	internal sealed class ClipLease
	{
		internal readonly string Key;

		internal readonly AudioClip Clip;

		internal readonly long CompressedBytes;

		internal readonly long DecodedBytes;

		internal int References;

		internal ClipLease(string key, AudioClip clip, long compressed, long decoded)
		{
			Key = key;
			Clip = clip;
			CompressedBytes = compressed;
			DecodedBytes = decoded;
			Assets.Keep<AudioClip>(clip);
		}
	}
	internal sealed class CueHandle
	{
		internal readonly AudioLibrary Library;

		internal readonly CueDefinition Definition;

		internal readonly BusDefinition Bus;

		internal readonly MixProfile[] Profiles;

		internal readonly ClipLease[]?[] Clips;

		internal readonly int Variants;

		internal double NextAllowed;

		internal int LastVariant = -1;

		internal CueHandle(AudioLibrary library, CueDefinition definition, BusDefinition bus, MixProfile[] profiles, ClipLease[]?[] clips)
		{
			Library = library;
			Definition = definition;
			Bus = bus;
			Profiles = profiles;
			Clips = clips;
			Variants = clips.First((ClipLease[] stretch) => stretch != null).Length;
		}
	}
	internal static class Assets
	{
		private sealed class Prepared
		{
			internal byte[] Data = Array.Empty<byte>();

			internal OggInfo Info;

			internal string Hash = "";

			internal AudioFailure? Failure;
		}

		private sealed class Loading
		{
			internal readonly AudioLibrary Library;

			internal readonly string[] Files;

			internal readonly CancellationTokenSource Cancel = new CancellationTokenSource();

			internal readonly Dictionary<string, ClipLease> Clips = new Dictionary<string, ClipLease>(StringComparer.OrdinalIgnoreCase);

			internal readonly Dictionary<string, AudioFailure> Failed = new Dictionary<string, AudioFailure>(StringComparer.OrdinalIgnoreCase);

			internal readonly Dictionary<string, DecodedAudio> Pcm = new Dictionary<string, DecodedAudio>(StringComparer.OrdinalIgnoreCase);

			internal readonly Dictionary<string, (MixProfile[] Profiles, ClipLease[]?[] Clips)> Mixed = new Dictionary<string, (MixProfile[], ClipLease[][])>(StringComparer.OrdinalIgnoreCase);

			internal readonly HashSet<string> DirectFiles;

			internal readonly HashSet<string> MixedFiles;

			internal Queue<CueDefinition>? Todo;

			internal int Index;

			internal Task<Prepared>? Preparing;

			internal Prepared? Ready;

			internal Task<DecodedAudio>? Decoding;

			internal string File => Files[Index];

			internal Loading(AudioLibrary library, string[] files)
			{
				Library = library;
				Files = files;
				DirectFiles = library.Catalog.DirectFiles;
				MixedFiles = library.Catalog.MixedFiles;
			}
		}

		private static readonly Queue<Loading> Pending = new Queue<Loading>();

		private static readonly Dictionary<string, ClipLease> Cache = new Dictionary<string, ClipLease>(StringComparer.Ordinal);

		private static readonly List<AudioLibrary> Libraries = new List<AudioLibrary>();

		private static Loading? _active;

		internal static long CompressedBytes;

		internal static long DecodedBytes;

		internal static IReadOnlyList<AudioLibrary> Loaded => Libraries;

		internal static AudioLibrary Load(string identity, string folder)
		{
			AudioLibrary audioLibrary = new AudioLibrary(identity ?? "", folder);
			AudioFailure? audioFailure = null;
			if (!AudioKit.Ready)
			{
				audioFailure = new AudioFailure(AudioError.NotReady, "ForgeAudio is not loaded; add [BepInDependency(AudioKit.PluginId)] to your plugin.");
			}
			else if (!AudioKit.OnMainThread)
			{
				audioFailure = new AudioFailure(AudioError.WrongThread, "AudioKit.Load must run on the Unity main thread (your plugin's Load).");
			}
			else
			{
				AudioFailure? failure = ClipUpload.Failure;
				if (failure.HasValue)
				{
					AudioFailure valueOrDefault = failure.GetValueOrDefault();
					audioFailure = valueOrDefault;
				}
				else if (!AudioKit.ValidIdentity(identity))
				{
					audioFailure = new AudioFailure(AudioError.InvalidIdentity, "identity '" + identity + "' must be letters, digits, '.', '_' or '-' (at most 100).");
				}
				else if (Libraries.Any((AudioLibrary other) => string.Equals(other.Identity, identity, StringComparison.OrdinalIgnoreCase)))
				{
					audioFailure = new AudioFailure(AudioError.DuplicateLibrary, "a library named '" + identity + "' is already loaded.");
				}
				else if (string.IsNullOrEmpty(folder) || !Path.IsPathFullyQualified(folder))
				{
					audioFailure = new AudioFailure(AudioError.PathOutsideRoot, "audio folder '" + folder + "' is not an absolute path; pass the folder to AudioKit.Load.");
				}
				else if (!Directory.Exists(folder))
				{
					audioFailure = new AudioFailure(AudioError.InvalidSource, "audio folder not found: " + folder);
				}
			}
			if (!audioFailure.HasValue)
			{
				try
				{
					string root = Path.GetFullPath(folder);
					string[] files = (from file in Directory.EnumerateFiles(root, "*", SearchOption.AllDirectories)
						select Path.GetRelativePath(root, file)).ToArray();
					string path = Path.Combine(root, "cues.json");
					audioLibrary.Catalog = CueCatalog.Build(files, File.Exists(path) ? File.ReadAllText(path) : null);
					audioFailure = audioLibrary.Catalog.Error;
				}
				catch (Exception ex) when (((ex is IOException || ex is UnauthorizedAccessException) ? 1 : 0) != 0)
				{
					audioFailure = new AudioFailure(AudioError.InvalidSource, "audio folder unreadable: " + ex);
				}
			}
			if (audioFailure.HasValue)
			{
				AudioFailure valueOrDefault2 = audioFailure.GetValueOrDefault();
				audioLibrary.Error = new AudioFailure(valueOrDefault2.Code, identity + ": " + valueOrDefault2.Detail + " No sounds will play.");
				audioLibrary.IsLoaded = true;
				AudioLog.Report(audioLibrary.Error.Value);
				return audioLibrary;
			}
			foreach (KeyValuePair<string, AudioFailure> failure2 in audioLibrary.Catalog.Failures)
			{
				AudioLog.Report(failure2.Value.Code, identity + ": " + failure2.Value.Detail);
			}
			Libraries.Add(audioLibrary);
			SyncPlays.Register(audioLibrary);
			Loading item = new Loading(audioLibrary, audioLibrary.Catalog.Files);
			Pending.Enqueue(item);
			return audioLibrary;
		}

		internal static void Tick()
		{
			if (_active == null && Pending.Count != 0)
			{
				_active = Pending.Dequeue();
			}
			Loading r = _active;
			if (r == null)
			{
				return;
			}
			if (r.Library.IsDisposed)
			{
				Abort(r);
				return;
			}
			if (r.Index == r.Files.Length)
			{
				if (BuildNext(r))
				{
					Complete(r);
				}
				return;
			}
			string file = r.File;
			try
			{
				bool flag = r.MixedFiles.Contains(file);
				bool flag2 = r.DirectFiles.Contains(file);
				if (r.Ready == null)
				{
					Loading loading = r;
					if (loading.Preparing == null)
					{
						loading.Preparing = Task.Run(() => Prepare(Path.Combine(r.Library.Folder, file), r.Cancel.Token));
					}
					if (!r.Preparing.IsCompleted)
					{
						return;
					}
					r.Ready = r.Preparing.GetAwaiter().GetResult();
					r.Preparing = null;
					AudioFailure? failure = r.Ready.Failure;
					if (failure.HasValue)
					{
						AudioFailure valueOrDefault = failure.GetValueOrDefault();
						Fail(r, valueOrDefault);
						return;
					}
					if (flag2 && !flag && Cache.TryGetValue(r.Ready.Hash, out ClipLease value))
					{
						value.References++;
						Accept(r, value);
						return;
					}
					OggInfo info = r.Ready.Info;
					if (DecodedBytes + info.DecodedBytes > 536870912 || CompressedBytes + r.Ready.Data.Length > 268435456)
					{
						Fail(r, new AudioFailure(AudioError.AssetLimit, "the audio cache is full (512 MiB decoded / 256 MiB compressed in total)."));
						return;
					}
				}
				if (r.Decoding == null)
				{
					Prepared prepared = r.Ready;
					CancellationToken token = r.Cancel.Token;
					r.Decoding = Task.Run(() => VorbisDecode.Decode(prepared.Data, prepared.Info, token));
				}
				else if (r.Decoding.IsCompleted)
				{
					DecodedAudio result = r.Decoding.GetAwaiter().GetResult();
					r.Decoding = null;
					if (flag)
					{
						r.Pcm[file] = result;
					}
					if (!flag2)
					{
						Next(r);
						return;
					}
					if (Cache.TryGetValue(r.Ready.Hash, out ClipLease value2))
					{
						value2.References++;
						Accept(r, value2);
						return;
					}
					AudioClip clip = MakeClip(r.Library.Identity + "/" + CueCatalog.CueName(file), result);
					ClipLease clipLease = new ClipLease(r.Ready.Hash, clip, r.Ready.Data.Length, (long)result.Frames * (long)result.Channels * 4)
					{
						References = 1
					};