using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
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.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FFmpeg.AutoGen;
using GameConsole;
using GameConsole.CommandTree;
using GreyAnnouncer.AnnouncerCore;
using GreyAnnouncer.AudioLoading;
using GreyAnnouncer.AudioSourceComponent;
using GreyAnnouncer.Base;
using GreyAnnouncer.Config;
using GreyAnnouncer.FrontEnd;
using GreyAnnouncer.Util;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using PluginConfig.API.Functionals;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using plog;
using plog.Models;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("GreyAnnouncer")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.4.1.0")]
[assembly: AssemblyInformationalVersion("1.4.1+f4bd37883942b0db524b1d306d3f22e8c0839333")]
[assembly: AssemblyProduct("GreyAnnouncer")]
[assembly: AssemblyTitle("GreyAnnouncer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
public class StreamedAudioData
{
	private const int _CHUNK_SIZE = 8192;

	private readonly LinkedList<float[]> _chunks = new LinkedList<float[]>();

	private float[] _currentChunk = new float[8192];

	private int _currentPos;

	public int Channels { get; set; }

	public int SampleRate { get; set; }

	public int TotalSamples { get; private set; }

	public void AddSamples(float[] samples)
	{
		int num = 0;
		int num2 = samples.Length;
		while (num2 > 0)
		{
			int num3 = Math.Min(8192 - _currentPos, num2);
			Array.Copy(samples, num, _currentChunk, _currentPos, num3);
			_currentPos += num3;
			num += num3;
			num2 -= num3;
			TotalSamples += num3;
			if (_currentPos >= 8192)
			{
				_chunks.AddLast(_currentChunk);
				_currentChunk = new float[8192];
				_currentPos = 0;
			}
		}
	}

	public float[] GetAllSamples()
	{
		float[] array = new float[TotalSamples];
		int num = 0;
		foreach (float[] chunk in _chunks)
		{
			Array.Copy(chunk, 0, array, num, chunk.Length);
			num += chunk.Length;
		}
		if (_currentPos > 0)
		{
			Array.Copy(_currentChunk, 0, array, num, _currentPos);
		}
		return array;
	}
}
public class Category : MonoBehaviour
{
	public Toggle enabledToggle;

	public Slider volumeSlider;

	public Slider cooldownSlider;

	private TextMeshProUGUI _titleText;

	private TextMeshProUGUI _volumeLabel;

	private TextMeshProUGUI _cooldownLabel;

	public void Awake()
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Expected O, but got Unknown
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
		((Graphic)((Component)this).gameObject.AddComponent<Image>()).color = new Color(0.12f, 0.12f, 0.12f, 1f);
		HorizontalLayoutGroup obj = ((Component)this).gameObject.AddComponent<HorizontalLayoutGroup>();
		((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
		((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
		((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
		((LayoutGroup)obj).childAlignment = (TextAnchor)3;
		((HorizontalOrVerticalLayoutGroup)obj).spacing = 6f;
		((LayoutGroup)obj).padding = new RectOffset(8, 8, 3, 3);
		((Component)this).gameObject.AddComponent<LayoutElement>().preferredHeight = 28f;
		_titleText = UIBuilder.AddLabel(((Component)this).transform, "Category", 13, new Color(0f, 1f, 1f), -1f, 110f, 0f, (TextAlignmentOptions)4097);
		UIBuilder.AddLabel(((Component)this).transform, "En", 12, Color.white, -1f, 18f, 0f, (TextAlignmentOptions)4097);
		enabledToggle = UIBuilder.AddToggle(((Component)this).transform);
		UIBuilder.AddLabel(((Component)this).transform, "Vol", 12, Color.white, -1f, 24f, 0f, (TextAlignmentOptions)4097);
		volumeSlider = AddSteppedSlider("VolumeSlider", 0f, 5f, 0.1f);
		_volumeLabel = UIBuilder.AddLabel(((Component)this).transform, "1.0", 12, Color.white, -1f, 32f, 0f, (TextAlignmentOptions)4097);
		((UnityEvent<float>)(object)volumeSlider.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
		{
			((TMP_Text)_volumeLabel).text = v.ToString("F1");
		});
		UIBuilder.AddLabel(((Component)this).transform, "CD", 12, Color.white, -1f, 22f, 0f, (TextAlignmentOptions)4097);
		cooldownSlider = AddSteppedSlider("CooldownSlider", 0f, 10f, 0.1f);
		_cooldownLabel = UIBuilder.AddLabel(((Component)this).transform, "3.0", 12, Color.white, -1f, 32f, 0f, (TextAlignmentOptions)4097);
		((UnityEvent<float>)(object)cooldownSlider.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
		{
			((TMP_Text)_cooldownLabel).text = v.ToString("F1");
		});
	}

	public void SetName(string name)
	{
		((TMP_Text)_titleText).text = name;
	}

	public void SetVolume(float v)
	{
		volumeSlider.SetValueWithoutNotify(v);
		((TMP_Text)_volumeLabel).text = v.ToString("F1");
	}

	public void SetCooldown(float v)
	{
		cooldownSlider.SetValueWithoutNotify(v);
		((TMP_Text)_cooldownLabel).text = v.ToString("F1");
	}

	private Slider AddSteppedSlider(string name, float min, float max, float step)
	{
		Slider s = UIBuilder.AddSlider(((Component)this).transform, min, min, max);
		((Object)((Component)s).gameObject).name = name;
		s.wholeNumbers = false;
		((UnityEvent<float>)(object)s.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
		{
			s.SetValueWithoutNotify(Mathf.Round(v / step) * step);
		});
		return s;
	}
}
internal static class LogHelper
{
	internal static ManualLogSource log { get; set; }

	public static void LogInfo(object data, [CallerMemberName] string member = "")
	{
		ManualLogSource obj = log;
		if (obj != null)
		{
			obj.LogInfo((object)$"[{member}] {data}");
		}
	}

	public static void LogWarning(object data, [CallerMemberName] string member = "")
	{
		ManualLogSource obj = log;
		if (obj != null)
		{
			obj.LogWarning((object)$"[{member}] {data}");
		}
	}

	public static void LogError(object data, [CallerMemberName] string member = "")
	{
		ManualLogSource obj = log;
		if (obj != null)
		{
			obj.LogError((object)$"[{member}] {data}");
		}
	}

	public static void LogDebug(object data, [CallerMemberName] string member = "")
	{
		ManualLogSource obj = log;
		if (obj != null)
		{
			obj.LogDebug((object)$"[{member}] {data}");
		}
	}

	private static string GetClassName(string path)
	{
		return Path.GetFileNameWithoutExtension(path);
	}
}
namespace GreyAnnouncer
{
	public enum AudioLoadOptions
	{
		Load_then_Play,
		Preload_and_Play
	}
	public enum AudioPlayOptions
	{
		Override_Last,
		Independent
	}
	[PublicAPI]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method, Inherited = false)]
	public sealed class EntryPointAttribute : Attribute
	{
	}
	[PublicAPI]
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	internal sealed class PatchOnEntryAttribute : Attribute
	{
	}
	[BepInPlugin("greycsont.ultrakill.GreyAnnouncer", "Grey Announcer", "1.4.1")]
	[BepInProcess("ULTRAKILL.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private void Awake()
		{
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)4;
			LogHelper.log = ((BaseUnityPlugin)this).Logger;
			LogHelper.LogInfo("Plugin greycsont.ultrakill.GreyAnnouncer is loaded!", "Awake");
			LoadMainModule();
			LoadOptionalModule();
		}

		private void LoadMainModule()
		{
			PluginSettings.Initialize();
		}

		private void LoadOptionalModule()
		{
			LoadPatches();
		}

		private void LoadPatches()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Harmony val = new Harmony("greycsont.ultrakill.GreyAnnouncer");
			List<MethodInfo> list = new List<MethodInfo>();
			Type[] types = typeof(Plugin).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttribute<PatchOnEntryAttribute>() != null)
				{
					try
					{
						val.PatchAll(type);
					}
					catch (Exception arg)
					{
						LogHelper.LogError($"FUCK PATCHING {type.Name}, {arg}", "LoadPatches");
						throw;
					}
				}
				if (type.GetCustomAttribute<EntryPointAttribute>() == null)
				{
					continue;
				}
				MethodInfo[] array = (from mi in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
					where mi.GetCustomAttribute<EntryPointAttribute>() != null
					select mi).ToArray();
				int num = array.Length;
				if (num <= 1)
				{
					switch (num)
					{
					case 0:
						LogHelper.LogError("Type " + type.FullName + " is marked as an entry point but has no methods marked with EntryPointAttribute.", "LoadPatches");
						break;
					case 1:
						if (array[0].GetParameters().Length != 0)
						{
							LogHelper.LogError("Entry point method " + type.FullName + "." + array[0].Name + " must have no parameters.", "LoadPatches");
						}
						else
						{
							list.Add(array[0]);
						}
						break;
					}
				}
				else
				{
					LogHelper.LogError("Type " + type.FullName + " has multiple entry points defined. Only one is allowed.", "LoadPatches");
				}
			}
			foreach (MethodInfo item in list)
			{
				LogHelper.LogInfo("Invoking entry point: " + item.DeclaringType?.FullName + "." + item.Name, "LoadPatches");
				try
				{
					item.Invoke(null, null);
				}
				catch (Exception data)
				{
					LogHelper.LogError(data, "LoadPatches");
				}
			}
		}
	}
	[EntryPoint]
	internal static class PluginDependencies
	{
		public const string PLUGINCONFIGURATOR_GUID = "com.eternalUnion.pluginConfigurator";

		public static void LoadIfPluginExists(string guid, string moduleName, Action loader)
		{
			if (!Chainloader.PluginInfos.ContainsKey(guid))
			{
				LogHelper.LogWarning("Plugin " + guid + " not loaded, skipping " + moduleName, "LoadIfPluginExists");
				return;
			}
			try
			{
				loader?.Invoke();
				LogHelper.LogInfo("Loaded optional module: " + moduleName, "LoadIfPluginExists");
			}
			catch (Exception ex)
			{
				LogHelper.LogError("Exception while loading " + moduleName + ": " + ex.Message, "LoadIfPluginExists");
			}
		}

		[EntryPoint]
		public static void CheckPluginLoaded()
		{
			LoadIfPluginExists("com.eternalUnion.pluginConfigurator", "PluginConfiguratorEntry", delegate
			{
				LoadByReflection("GreyAnnouncer.FrontEnd.PluginConfiguratorEntry", "Initialize");
			});
		}

		public static void LoadByReflection(string assemblyName, string methodName, object[] parameter = null)
		{
			try
			{
				Assembly.GetExecutingAssembly().GetType(assemblyName).GetMethod(methodName, BindingFlags.Static | BindingFlags.Public)?.Invoke(null, parameter);
			}
			catch (Exception arg)
			{
				LogHelper.LogError($"Failed to load {assemblyName}'s {methodName} by : {arg}", "LoadByReflection");
			}
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_GUID = "greycsont.ultrakill.GreyAnnouncer";

		public const string PLUGIN_NAME = "Grey Announcer";

		public const string PLUGIN_VERSION = "1.4.1";
	}
}
namespace GreyAnnouncer.Util
{
	public sealed class CoroutineRunner : MonoBehaviour
	{
		[CompilerGenerated]
		private static CoroutineRunner <Instance>k__BackingField;

		public static CoroutineRunner Instance
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				if ((Object)(object)<Instance>k__BackingField == (Object)null)
				{
					GameObject val = new GameObject("CoroutineRunner");
					<Instance>k__BackingField = val.AddComponent<CoroutineRunner>();
					Object.DontDestroyOnLoad((Object)val);
				}
				return <Instance>k__BackingField;
			}
		}
	}
	public static class FileSystemUtil
	{
		public static void ValidateAndPrepareDirectory(string directoryPath)
		{
			if (!Directory.Exists(directoryPath))
			{
				LogHelper.LogWarning("Directory not found: " + directoryPath, "ValidateAndPrepareDirectory");
				Directory.CreateDirectory(directoryPath);
			}
		}

		public static void EnsureDirectoryExists(string filePath)
		{
			string directoryName = Path.GetDirectoryName(filePath);
			if (!Directory.Exists(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
		}

		public static void CopyDirectoryParallel(string source, string targetRoot)
		{
			try
			{
				string fileName = Path.GetFileName(source.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
				string item = Path.Combine(targetRoot, fileName);
				Stack<(string, string)> stack = new Stack<(string, string)>();
				stack.Push((source, item));
				while (stack.Count > 0)
				{
					var (path, currDest) = stack.Pop();
					if (!Directory.Exists(currDest))
					{
						Directory.CreateDirectory(currDest);
					}
					Parallel.ForEach(Directory.GetFiles(path), new ParallelOptions
					{
						MaxDegreeOfParallelism = 8
					}, delegate(string file)
					{
						string fileName3 = Path.GetFileName(file);
						string destFileName = Path.Combine(currDest, fileName3);
						File.Copy(file, destFileName, overwrite: true);
					});
					string[] directories = Directory.GetDirectories(path);
					foreach (string text in directories)
					{
						string fileName2 = Path.GetFileName(text);
						stack.Push((text, Path.Combine(currDest, fileName2)));
					}
				}
			}
			catch (Exception ex)
			{
				LogHelper.LogError("failed to copy: " + ex.Message, "CopyDirectoryParallel");
			}
		}
	}
	public static class GuidPrefixAdder
	{
		private const string Prefix = "GreyAnnouncer_";

		public static string AddPrefixToGUID(params string[] GUIDs)
		{
			if (GUIDs == null || GUIDs.Length == 0)
			{
				throw new ArgumentException("At least one key must be provided.", "GUIDs");
			}
			string text = string.Join("_", GUIDs).ToUpper();
			return "GreyAnnouncer_" + text;
		}
	}
	public static class JsonManager
	{
		public static T ReadJson<T>(string path) where T : class
		{
			if (!File.Exists(path))
			{
				return null;
			}
			return DeserializeJson<T>(path);
		}

		public static T WriteJson<T>(string path, T data) where T : class
		{
			string directoryName = Path.GetDirectoryName(path);
			if (!Directory.Exists(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			return SerializeAndSaveJson(path, data);
		}

		private static T DeserializeJson<T>(string path) where T : class
		{
			try
			{
				return JsonConvert.DeserializeObject<T>(File.ReadAllText(path)) ?? throw new InvalidOperationException("Failed to deserialize JSON at '" + path + "' into type " + typeof(T).Name);
			}
			catch (FileNotFoundException)
			{
				return null;
			}
			catch (Exception ex2)
			{
				LogHelper.LogError("Error reading JSON '" + path + "': " + ex2.Message, "DeserializeJson");
				throw;
			}
		}

		private static T SerializeAndSaveJson<T>(string path, T data) where T : class
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)data, (Formatting)1);
				File.WriteAllText(path, contents);
				return data;
			}
			catch (Exception ex)
			{
				LogHelper.LogError("Error writing JSON '" + path + "': " + ex.Message, "SerializeAndSaveJson");
				throw;
			}
		}
	}
	public static class PathHelper
	{
		public static string GetCurrentPluginPath(params string[] paths)
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			return CleanPath((paths == null || paths.Length == 0) ? directoryName : Path.Combine(directoryName, Path.Combine(paths)));
		}

		public static string GetGamePath(string filePath)
		{
			return CleanPath(Path.Combine(Paths.GameRootPath, filePath));
		}

		[Description("Reference : (因win程序员想偷懒! 竟在剪切板插入隐藏字符) https://www.bilibili.com/video/BV1ebLczjEWZ (Accessed in 24/4/2025)")]
		public static string CleanPath(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return path;
			}
			char[] trimChars = new char[5] { '\u202a', '\u202b', '\u202c', '\u202d', '\u202e' };
			string text = path.TrimStart(trimChars);
			if (!path.Equals(text))
			{
				LogHelper.LogInfo("[CleanPath] Path cleaned: Original='" + path + "', Cleaned='" + text + "'", "CleanPath");
			}
			return text;
		}

		public static string GetFile(string filePath, string fileName)
		{
			string text = Path.Combine(filePath, fileName);
			if (File.Exists(text))
			{
				return text;
			}
			return null;
		}

		public static bool TryGetExtension(string filePath, out string foundExtension, params string[] extensions)
		{
			foundExtension = null;
			if (string.IsNullOrWhiteSpace(filePath))
			{
				return false;
			}
			string[] source = (from e in extensions.SelectMany((string e) => e.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries))
				select e.Trim()).ToArray();
			string text = filePath.Trim();
			while (!string.IsNullOrEmpty(text))
			{
				string ext = Path.GetExtension(text)?.Trim();
				if (string.IsNullOrEmpty(ext))
				{
					break;
				}
				if (source.Any((string e) => e.Equals(ext, StringComparison.OrdinalIgnoreCase)))
				{
					foundExtension = ext;
					return true;
				}
				text = Path.Combine(Path.GetDirectoryName(text) ?? "", Path.GetFileNameWithoutExtension(text));
			}
			return false;
		}
	}
	public static class ProcessHelper
	{
		[Description("Reference : (C# 判断操作系统是 Windows 还是 Linux - 青叶煮酒 - 博客园, 11/1/2022) https://www.cnblogs.com/dhqy/p/15787463.html (Accessed in 25/4/2025)")]
		public static void OpenDirectory(string path)
		{
			if (!string.IsNullOrEmpty(path) && Directory.Exists(path))
			{
				if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
				{
					Process.Start("explorer.exe", path);
				}
				else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
				{
					Process.Start("xdg-open", path);
				}
				else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
				{
					Process.Start("open", path);
				}
				else
				{
					LogHelper.LogWarning("Unsupported OS platform.", "OpenDirectory");
				}
			}
			else
			{
				LogHelper.LogWarning("The path is not valid or the directory does not exist.", "OpenDirectory");
			}
		}

		internal static string FindExecutable(string executableName, string fallbackPath = null)
		{
			bool num = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
			string path = (num ? (executableName + ".exe") : executableName);
			char separator = (num ? ';' : ':');
			string environmentVariable = Environment.GetEnvironmentVariable(executableName);
			if (!string.IsNullOrEmpty(environmentVariable) && Directory.Exists(environmentVariable) && File.Exists(Path.Combine(environmentVariable, path)))
			{
				return environmentVariable;
			}
			string environmentVariable2 = Environment.GetEnvironmentVariable("PATH");
			if (!string.IsNullOrEmpty(environmentVariable2))
			{
				string[] array = environmentVariable2.Split(separator);
				foreach (string text in array)
				{
					if (!string.IsNullOrWhiteSpace(text) && File.Exists(Path.Combine(text, path)))
					{
						return text;
					}
				}
			}
			if (!string.IsNullOrEmpty(fallbackPath) && Directory.Exists(fallbackPath))
			{
				return fallbackPath;
			}
			return null;
		}
	}
	public static class UnityPathManager
	{
		public static Canvas FindCanvas()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			for (int i = 0; i < rootGameObjects.Length; i++)
			{
				Canvas component = rootGameObjects[i].GetComponent<Canvas>();
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
			}
			return null;
		}

		public static async Task<Texture2D> LoadTextureFromFileAsync(string path)
		{
			UnityWebRequest request = UnityWebRequestTexture.GetTexture("file:///" + path);
			try
			{
				TaskCompletionSource<Texture2D> tcs = new TaskCompletionSource<Texture2D>();
				((AsyncOperation)request.SendWebRequest()).completed += delegate
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Invalid comparison between Unknown and I4
					if ((int)request.result == 1)
					{
						tcs.SetResult(DownloadHandlerTexture.GetContent(request));
					}
					else
					{
						tcs.SetResult(null);
					}
				};
				return await tcs.Task;
			}
			finally
			{
				if (request != null)
				{
					((IDisposable)request).Dispose();
				}
			}
		}
	}
}
namespace GreyAnnouncer.FrontEnd
{
	public class AnnouncerConfigFields
	{
		public BoolField RandomizeAudioField;

		public Dictionary<string, CategoryFields> CategoryFields;
	}
	public class CategoryFields
	{
		public BoolField Enabled;

		public FloatField Volume;

		public FloatSliderField Cooldown;

		public BoolField ExcludeFromRandom;
	}
	[Description("This object is loaded via reflection from Plugin.cs")]
	public static class PluginConfiguratorEntry
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static OnValueChangeEventDelegate <>9__25_0;

			public static OnValueChangeEventDelegate <>9__25_1;

			public static EnumValueChangeEventDelegate<AudioPlayOptions> <>9__25_2;

			public static EnumValueChangeEventDelegate<AudioLoadOptions> <>9__25_3;

			public static OnClick <>9__25_4;

			public static OnClick <>9__25_5;

			public static OnClick <>9__25_6;

			public static BoolValueChangeEventDelegate <>9__26_0;

			public static BoolValueChangeEventDelegate <>9__26_1;

			public static OnClick <>9__26_2;

			public static Action<string> <>9__29_0;

			internal void <CreateAudioControls>b__25_0(FloatSliderValueChangeEvent e)
			{
				Setting.audioSourceVolume = e.newValue;
			}

			internal void <CreateAudioControls>b__25_1(FloatSliderValueChangeEvent e)
			{
				Setting.spatialBlend = e.newValue;
			}

			internal void <CreateAudioControls>b__25_2(EnumValueChangeEvent<AudioPlayOptions> e)
			{
				Setting.audioPlayOptions = (int)e.value;
			}

			internal void <CreateAudioControls>b__25_3(EnumValueChangeEvent<AudioLoadOptions> e)
			{
				Setting.audioLoadingStrategy = (int)e.value;
			}

			internal void <CreateAudioControls>b__25_4()
			{
				AnnouncerManager.ReloadAllAnnouncers();
			}

			internal void <CreateAudioControls>b__25_5()
			{
				advancedPanel.OpenPanel();
			}

			internal void <CreateAudioControls>b__25_6()
			{
				creditPanel.OpenPanel();
			}

			internal void <CreateAdvancedOptionPanel>b__26_0(BoolValueChangeEvent e)
			{
				Setting.isLowPassFilterEnabled = e.value;
			}

			internal void <CreateAdvancedOptionPanel>b__26_1(BoolValueChangeEvent e)
			{
				Setting.isFFmpegSupportEnabled = e.value;
			}

			internal void <CreateAdvancedOptionPanel>b__26_2()
			{
				AudioSourceManager.StopAllAudioSource();
			}

			internal void <CreateDelegateTextFromBackEnd>b__29_0(string log)
			{
				audioLoaderLogHeader.text = log + "\n";
			}
		}

		private static readonly Color m_greyColour = new Color(0.85f, 0.85f, 0.85f, 1f);

		private static readonly Color m_CyanColour = new Color(0f, 1f, 1f, 1f);

		private static readonly Color m_OrangeColour = new Color(1f, 0.6f, 0.2f, 1f);

		private static readonly Color m_RedColour = new Color(1f, 0f, 0f, 1f);

		private static readonly Color m_PurpleColour = new Color(1f, 0f, 1f, 1f);

		[CompilerGenerated]
		private static PluginConfigurator <config>k__BackingField;

		public static ConfigHeader audioLoaderLogHeader;

		private static ConfigPanel advancedPanel;

		private static ConfigPanel creditPanel;

		private static List<RegistedAnnouncerPage> _pages = new List<RegistedAnnouncerPage>();

		private static FloatSliderField volumeSlider;

		private static FloatSliderField spatialBlendSlider;

		private static EnumField<AudioPlayOptions> playOption;

		private static EnumField<AudioLoadOptions> loadOption;

		private static BoolField lowpassToggle;

		private static BoolField ffmpegToggle;

		public static PluginConfigurator config
		{
			get
			{
				return <config>k__BackingField;
			}
			private set
			{
				<config>k__BackingField = value;
			}
		}

		public static void Initialize()
		{
			CreatePluginPages();
			Build();
		}

		private static void CreatePluginPages()
		{
			config = PluginConfigurator.Create("Grey Announcer", "greycsont.ultrakill.GreyAnnouncer");
			config.SetIconWithURL(PathHelper.GetCurrentPluginPath("./../../icon.png"));
		}

		public static void Build()
		{
			CreateMainSettingSectionTitle();
			CreateAnnouncerPage();
			CreateAudioControls();
			CreateAdvancedOptionPanel();
			CreateCreditsPanel();
			CreateAnnouncerSection();
			CreateDelegateTextFromBackEnd();
			AnnouncerManager.OnRegistered += AddAnnouncerPage;
			Setting.syncUI = (Action)Delegate.Combine(Setting.syncUI, new Action(SyncUI));
		}

		public static void SyncUI()
		{
			volumeSlider.value = Setting.audioSourceVolume;
			playOption.value = (AudioPlayOptions)Setting.audioPlayOptions;
			loadOption.value = (AudioLoadOptions)Setting.audioLoadingStrategy;
			lowpassToggle.value = Setting.isLowPassFilterEnabled;
			ffmpegToggle.value = Setting.isFFmpegSupportEnabled;
		}

		public static void CreateAnnouncerPage()
		{
			foreach (IAnnouncer announcer in AnnouncerManager.announcers)
			{
				RegistedAnnouncerPage item = new RegistedAnnouncerPage(announcer);
				_pages.Add(item);
			}
		}

		private static void CreateMainSettingSectionTitle()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			new ConfigSpace(config.rootPanel, 15f);
			new ConfigHeader(config.rootPanel, "Main Settings", 24).textColor = m_CyanColour;
		}

		private static void CreateAudioControls()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Expected O, but got Unknown
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Expected O, but got Unknown
			volumeSlider = new FloatSliderField(config.rootPanel, "Master Volume", "Audio_Volume", Tuple.Create(0f, 1f), 1f, 2, false);
			volumeSlider.value = Setting.audioSourceVolume;
			FloatSliderField obj = volumeSlider;
			object obj2 = <>c.<>9__25_0;
			if (obj2 == null)
			{
				OnValueChangeEventDelegate val = delegate(FloatSliderValueChangeEvent e)
				{
					Setting.audioSourceVolume = e.newValue;
				};
				<>c.<>9__25_0 = val;
				obj2 = (object)val;
			}
			obj.onValueChange += (OnValueChangeEventDelegate)obj2;
			spatialBlendSlider = new FloatSliderField(config.rootPanel, "Spatial Blend", "Spatial_Blend", Tuple.Create(0f, 1f), 1f, 2, false);
			spatialBlendSlider.value = Setting.spatialBlend;
			FloatSliderField obj3 = spatialBlendSlider;
			object obj4 = <>c.<>9__25_1;
			if (obj4 == null)
			{
				OnValueChangeEventDelegate val2 = delegate(FloatSliderValueChangeEvent e)
				{
					Setting.spatialBlend = e.newValue;
				};
				<>c.<>9__25_1 = val2;
				obj4 = (object)val2;
			}
			obj3.onValueChange += (OnValueChangeEventDelegate)obj4;
			playOption = new EnumField<AudioPlayOptions>(config.rootPanel, "Audio Play Strategy", "Audio_Play_Strategy", AudioPlayOptions.Override_Last, false);
			playOption.value = (AudioPlayOptions)Setting.audioPlayOptions;
			playOption.onValueChange += delegate(EnumValueChangeEvent<AudioPlayOptions> e)
			{
				Setting.audioPlayOptions = (int)e.value;
			};
			loadOption = new EnumField<AudioLoadOptions>(config.rootPanel, "Audio Load Strategy", "Audio_Load_Strategy", AudioLoadOptions.Load_then_Play, false);
			loadOption.value = (AudioLoadOptions)Setting.audioLoadingStrategy;
			loadOption.onValueChange += delegate(EnumValueChangeEvent<AudioLoadOptions> e)
			{
				Setting.audioLoadingStrategy = (int)e.value;
			};
			new ConfigSpace(config.rootPanel, 7f);
			ButtonArrayField val3 = new ButtonArrayField(config.rootPanel, "audio_button_array", 3, new float[3] { 0.4f, 0.4f, 0.2f }, new string[3] { "Reload", "Advance", "Credit" }, 5f);
			ButtonClickEvent obj5 = val3.OnClickEventHandler(0);
			object obj6 = <>c.<>9__25_4;
			if (obj6 == null)
			{
				OnClick val4 = delegate
				{
					AnnouncerManager.ReloadAllAnnouncers();
				};
				<>c.<>9__25_4 = val4;
				obj6 = (object)val4;
			}
			obj5.onClick += (OnClick)obj6;
			ButtonClickEvent obj7 = val3.OnClickEventHandler(1);
			object obj8 = <>c.<>9__25_5;
			if (obj8 == null)
			{
				OnClick val5 = delegate
				{
					advancedPanel.OpenPanel();
				};
				<>c.<>9__25_5 = val5;
				obj8 = (object)val5;
			}
			obj7.onClick += (OnClick)obj8;
			ButtonClickEvent obj9 = val3.OnClickEventHandler(2);
			object obj10 = <>c.<>9__25_6;
			if (obj10 == null)
			{
				OnClick val6 = delegate
				{
					creditPanel.OpenPanel();
				};
				<>c.<>9__25_6 = val6;
				obj10 = (object)val6;
			}
			obj9.onClick += (OnClick)obj10;
		}

		private static void CreateAdvancedOptionPanel()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			advancedPanel = new ConfigPanel(config.rootPanel, "Advanced", "Advanced_Option");
			((ConfigField)advancedPanel).hidden = true;
			new ConfigSpace(advancedPanel, 15f);
			lowpassToggle = new BoolField(advancedPanel, "LowPassFilter when under water", "LowPassFilter_Enabled", true, false);
			lowpassToggle.value = Setting.isLowPassFilterEnabled;
			BoolField obj = lowpassToggle;
			object obj2 = <>c.<>9__26_0;
			if (obj2 == null)
			{
				BoolValueChangeEventDelegate val = delegate(BoolValueChangeEvent e)
				{
					Setting.isLowPassFilterEnabled = e.value;
				};
				<>c.<>9__26_0 = val;
				obj2 = (object)val;
			}
			obj.onValueChange += (BoolValueChangeEventDelegate)obj2;
			ffmpegToggle = new BoolField(advancedPanel, "Use FFmpeg to load unknown format", "FFmpeg_Support", false, false);
			ffmpegToggle.value = Setting.isFFmpegSupportEnabled;
			BoolField obj3 = ffmpegToggle;
			object obj4 = <>c.<>9__26_1;
			if (obj4 == null)
			{
				BoolValueChangeEventDelegate val2 = delegate(BoolValueChangeEvent e)
				{
					Setting.isFFmpegSupportEnabled = e.value;
				};
				<>c.<>9__26_1 = val2;
				obj4 = (object)val2;
			}
			obj3.onValueChange += (BoolValueChangeEventDelegate)obj4;
			new ConfigHeader(advancedPanel, "this will try to load unknown format to AudioClip via FFmpeg\n makesure there's a executable in environment path `ffmpeg` or `PATH`\n\n ", 24)
			{
				tmpAnchor = (TextAlignmentOptions)258,
				textSize = 12,
				textColor = m_greyColour
			};
			new ConfigSpace(config.rootPanel, 15f);
			new ConfigHeader(advancedPanel, "Emergency", 24).textColor = m_RedColour;
			ButtonField val3 = new ButtonField(advancedPanel, "Stop All Audio Source", "Stop_All_Audio_Source");
			object obj5 = <>c.<>9__26_2;
			if (obj5 == null)
			{
				OnClick val4 = delegate
				{
					AudioSourceManager.StopAllAudioSource();
				};
				<>c.<>9__26_2 = val4;
				obj5 = (object)val4;
			}
			val3.onClick += (OnClick)obj5;
		}

		private static void CreateCreditsPanel()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			creditPanel = new ConfigPanel(config.rootPanel, "Credits", "Credits");
			((ConfigField)creditPanel).hidden = true;
			new ConfigSpace(creditPanel, 15f);
			new ConfigHeader(creditPanel, "Credits", 24).textColor = m_PurpleColour;
			new ConfigSpace(creditPanel, 20f);
			ConfigHeader val = new ConfigHeader(creditPanel, "", 24)
			{
				tmpAnchor = (TextAlignmentOptions)257,
				textSize = 20
			};
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Thanks:\nhttps://unsplash.com/photos/white-textile-on-brown-wooden-table-_kUxT8WkoeY?utm_source=unsplash&utm_medium=referral&utm_content=creditShareLink");
			stringBuilder.AppendLine("\n- OSU! \n(https://osu.ppy.sh/) some UX are copied from lazer(YES EDIT EXTERNALLY), use .ini as config cuz `skin.ini` is pretty easy to edit");
			stringBuilder.AppendLine("\n- Artless Games \n(https://space.bilibili.com/1237125233) 14 Minesweeper variants");
			stringBuilder.AppendLine("\n- Announcer Mod \n(https://www.nexusmods.com/ultrakill/mods/54) I started of this project is just because the mod isn't update in the few days after revamp");
			stringBuilder.AppendLine("\n- PluginConfigurator doc \n(https://github.com/eternalUnion/UKPluginConfigurator/wiki) Easy to use tbh (except changing font)");
			stringBuilder.AppendLine("\n- ULTRASTATS \n(https://thunderstore.io/c/ultrakill/p/AtomSmasher/ULTRASTATS/)\n Great mod, Goat dev");
			stringBuilder.AppendLine("\n- Maxwell's puzzling demon \n(https://store.steampowered.com/app/2770160/) Fun puzzle game");
			stringBuilder.AppendLine("\n- A mod that currently WIP \n(Advert Placeholder) Pretty FUN I would say");
			stringBuilder.AppendLine("\n- HappySKZC, jamcame, ZHU!.");
			stringBuilder.AppendLine("\n");
			stringBuilder.AppendLine("\n- Everyone who used this mod.");
			stringBuilder.AppendLine("\n\n\n\n");
			stringBuilder.AppendLine("\n- FUCK YOU UNITY.");
			stringBuilder.AppendLine("\n\n\n\n\n\n\n\n\n");
			stringBuilder.AppendLine("Turn up the bass!\nTHWWWWOOOOOMPPPP DHGDHGDHGDHGDHGDHG BWOBWOBWOBWOB BWOBWOBWOBWOB BWOBWOBWOBWOBWOB BWAHH BWAHH BWAHH HMRMRMRMRMRMRMRMMR WOH WOH WOH- H H H HHHHH THWWOOMPPPP DHGDHGDHGDHGDHGDHG BWOBWOBWOBWOB.. BWOBWOBWOBWOB.. BWOBWOBWOBWOBWOB.... HRMMMMMMMMMMMMMMMMRRR- HRRRRRRR HRRRRRRRR HRRRRRR HRRRRRRRR HRRR HR-YOOOH!!!!!!\n\n- shadow of cats");
			val.text = stringBuilder.ToString();
		}

		private static void CreateAnnouncerSection()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			new ConfigHeader(config.rootPanel, "Announcer Section", 24).textColor = m_OrangeColour;
			audioLoaderLogHeader = new ConfigHeader(config.rootPanel, "", 24);
			audioLoaderLogHeader.tmpAnchor = (TextAlignmentOptions)257;
			audioLoaderLogHeader.textSize = 12;
			audioLoaderLogHeader.textColor = m_CyanColour;
		}

		private static void CreateDelegateTextFromBackEnd()
		{
			AudioLoader.onPluginConfiguratorLogUpdated = delegate(string log)
			{
				audioLoaderLogHeader.text = log + "\n";
			};
		}

		private static void AddAnnouncerPage(IAnnouncer announcer)
		{
			RegistedAnnouncerPage item = new RegistedAnnouncerPage(announcer);
			_pages.Add(item);
		}
	}
	public class RegistedAnnouncerPage
	{
		private string _title;

		private IAnnouncer _announcer;

		private StringListField _announcerField;

		private ConfigPanel _panel;

		private AnnouncerConfigFields _fields = new AnnouncerConfigFields
		{
			CategoryFields = new Dictionary<string, CategoryFields>()
		};

		private ConfigHeader _mismatchHeader;

		private static readonly Color HeaderColor = new Color(0.85f, 0.85f, 0.85f, 1f);

		private PluginConfigurator _pluginConfigurator => PluginConfiguratorEntry.config;

		public RegistedAnnouncerPage(IAnnouncer announcer)
		{
			Build(announcer);
		}

		public void Build(IAnnouncer announcer)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			_title = announcer.title;
			_announcer = announcer;
			_panel = new ConfigPanel(_pluginConfigurator.rootPanel, _title, _title);
			new ConfigSpace(_panel, 15f);
			new ConfigHeader(_panel, _title, 30).textColor = HeaderColor;
			List<string> availablePacks = AudioAnnouncer.GetAvailablePacks(_announcer.title);
			_announcerField = new StringListField(_panel, "Selected Announcer", _announcer.title + "_Selected_Announcer", availablePacks, availablePacks.FirstOrDefault() ?? "default", false);
			_announcerField.value = Path.GetFileName(_announcer.announcerPath);
			_announcerField.onValueChange += (StringListValueChangeEventDelegate)delegate(StringListValueChangeEvent e)
			{
				_announcer.announcerPath = Path.Combine(Setting.announcersPath, _announcer.title, e.value);
			};
			new ButtonField(_panel, "Open Current Announcer Folder", _announcer.title + "_Open_Current_Announcer_Folder").onClick += (OnClick)delegate
			{
				_announcer.EditExternally();
			};
			_mismatchHeader = new ConfigHeader(_panel, "", 24)
			{
				textColor = new Color(1f, 0.4f, 0.4f),
				textSize = 14
			};
			if (_announcer.isConfigLoaded)
			{
				BuildConfigSection();
			}
			IAnnouncer announcer2 = _announcer;
			announcer2.syncUI = (Action)Delegate.Combine(announcer2.syncUI, new Action(ApplyConfigToUI));
		}

		private void BuildConfigSection()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			new ConfigSpace(_panel, 15f);
			new ConfigHeader(_panel, "Configuration", 24);
			_fields.RandomizeAudioField = new BoolField(_panel, "Randomize Audio On Play", _announcer.title + "_RandomizeAudioOnPlay", false, false);
			_fields.RandomizeAudioField.defaultValue = false;
			_fields.RandomizeAudioField.value = _announcer.announcerConfig.RandomizeAudioOnPlay;
			_fields.RandomizeAudioField.onValueChange += (BoolValueChangeEventDelegate)delegate(BoolValueChangeEvent e)
			{
				_announcer.announcerConfig.RandomizeAudioOnPlay = e.value;
			};
			foreach (KeyValuePair<string, CategorySetting> item in _announcer.announcerConfig.CategorySetting)
			{
				string key = item.Key;
				new ConfigHeader(_panel, item.Key, 24).textColor = new Color(0f, 1f, 1f);
				CategoryFields value = new CategoryFields
				{
					Enabled = CreateEnabledField(_panel, key, defaultValue: true),
					Volume = CreateVolumeField(_panel, key, 1f),
					Cooldown = CreateCooldownField(_panel, key, 3f),
					ExcludeFromRandom = CreateExcludeFromRandomField(_panel, key, defaultValue: false)
				};
				_fields.CategoryFields[key] = value;
			}
		}

		private BoolField CreateEnabledField(ConfigPanel panel, string guid, bool defaultValue)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_0094: Expected O, but got Unknown
			string text = _announcer.title + "_" + GuidPrefixAdder.AddPrefixToGUID(guid, "Enabled");
			BoolField val = new BoolField(panel, "Enabled", text, defaultValue, false)
			{
				defaultValue = defaultValue,
				value = _announcer.announcerConfig.CategorySetting[guid].Enabled
			};
			val.onValueChange += (BoolValueChangeEventDelegate)delegate(BoolValueChangeEvent e)
			{
				_announcer.announcerConfig.CategorySetting[guid].Enabled = e.value;
			};
			return val;
		}

		private FloatField CreateVolumeField(ConfigPanel panel, string guid, float defaultValue)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_0094: Expected O, but got Unknown
			string text = _announcer.title + "_" + GuidPrefixAdder.AddPrefixToGUID(guid, "VolumeMultiplier");
			FloatField val = new FloatField(panel, "Volume", text, defaultValue, false)
			{
				defaultValue = defaultValue,
				value = _announcer.announcerConfig.CategorySetting[guid].VolumeMultiplier
			};
			val.onValueChange += (FloatValueChangeEventDelegate)delegate(FloatValueChangeEvent e)
			{
				_announcer.announcerConfig.CategorySetting[guid].VolumeMultiplier = e.value;
			};
			return val;
		}

		private FloatSliderField CreateCooldownField(ConfigPanel panel, string guid, float defaultValue)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00a4: Expected O, but got Unknown
			string text = _announcer.title + "_" + GuidPrefixAdder.AddPrefixToGUID(guid, "Cooldown");
			FloatSliderField val = new FloatSliderField(panel, "Cooldown", text, Tuple.Create(0.2f, 6f), defaultValue, 1, false)
			{
				defaultValue = defaultValue,
				value = _announcer.announcerConfig.CategorySetting[guid].Cooldown
			};
			val.onValueChange += (OnValueChangeEventDelegate)delegate(FloatSliderValueChangeEvent e)
			{
				_announcer.announcerConfig.CategorySetting[guid].Cooldown = e.newValue;
			};
			return val;
		}

		private BoolField CreateExcludeFromRandomField(ConfigPanel panel, string guid, bool defaultValue)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			string text = _announcer.title + "_" + GuidPrefixAdder.AddPrefixToGUID(guid, "ExcludeFromRandom");
			BoolField val = new BoolField(panel, "Exclude From Random Selection", text, defaultValue, false)
			{
				defaultValue = defaultValue,
				value = _announcer.announcerConfig.CategorySetting[guid].ExcludeFromRandom
			};
			val.onValueChange += (BoolValueChangeEventDelegate)delegate(BoolValueChangeEvent e)
			{
				_announcer.announcerConfig.CategorySetting[guid].ExcludeFromRandom = e.value;
			};
			((ConfigField)val).hidden = !_announcer.announcerConfig.RandomizeAudioOnPlay;
			return val;
		}

		public void ApplyConfigToUI()
		{
			LogHelper.LogDebug("ApplyConfigToUI called", "ApplyConfigToUI");
			string fileName = Path.GetFileName(_announcer.announcerPath);
			_announcerField.value = fileName;
			if (!_announcer.isConfigLoaded)
			{
				_mismatchHeader.text = (string.IsNullOrEmpty(_announcer.configMismatchInfo) ? "Config not loaded." : ("Config mismatch — " + _announcer.configMismatchInfo));
				return;
			}
			_mismatchHeader.text = "";
			PackConfig announcerConfig = _announcer.announcerConfig;
			if (_fields.RandomizeAudioField == null)
			{
				BuildConfigSection();
			}
			_fields.RandomizeAudioField.value = announcerConfig.RandomizeAudioOnPlay;
			foreach (KeyValuePair<string, CategoryFields> categoryField in _fields.CategoryFields)
			{
				string key = categoryField.Key;
				CategoryFields value = categoryField.Value;
				if (announcerConfig.CategorySetting.TryGetValue(key, out var value2))
				{
					value.Enabled.value = value2.Enabled;
					value.Volume.value = value2.VolumeMultiplier;
					value.Cooldown.value = value2.Cooldown;
					value.ExcludeFromRandom.value = value2.ExcludeFromRandom;
					((ConfigField)value.ExcludeFromRandom).hidden = !announcerConfig.RandomizeAudioOnPlay;
				}
			}
		}
	}
	public class AdvancedPanel : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__StopAllAudioSource;
		}

		private Toggle _lpToggle;

		private Toggle _ffToggle;

		public void SyncUI()
		{
			_lpToggle.SetIsOnWithoutNotify(Setting.isLowPassFilterEnabled);
			_ffToggle.SetIsOnWithoutNotify(Setting.isFFmpegSupportEnabled);
		}

		public void Awake()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Expected O, but got Unknown
			UIBuilder.SetFullStretch(((Component)this).GetComponent<RectTransform>() ?? ((Component)this).gameObject.AddComponent<RectTransform>());
			Transform item = UIBuilder.BuildScrollView(((Component)this).transform, new RectOffset(12, 12, 12, 12)).content;
			UIBuilder.AddLabel(item, "Advanced", 26, new Color(0.5f, 0.8f, 1f), 23f, -1f, -1f, (TextAlignmentOptions)513);
			UIBuilder.AddSeparator(item);
			UIBuilder.AddSpace(item, 6f);
			Transform transform = UIBuilder.AddRow(item, "LowPass_Row", 28f).transform;
			UIBuilder.AddLabel(transform, "LowPass Filter when under water", 13, Color.white, -1f, -1f, 1f, (TextAlignmentOptions)513);
			_lpToggle = UIBuilder.AddToggle(transform, 30f);
			_lpToggle.isOn = Setting.isLowPassFilterEnabled;
			((UnityEvent<bool>)(object)_lpToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
			{
				Setting.isLowPassFilterEnabled = v;
			});
			UIBuilder.AddSpace(item, 4f);
			Transform transform2 = UIBuilder.AddRow(item, "FFmpeg_Row", 28f).transform;
			UIBuilder.AddLabel(transform2, "FFmpeg Support", 13, Color.white, -1f, -1f, 1f, (TextAlignmentOptions)513);
			_ffToggle = UIBuilder.AddToggle(transform2, 30f);
			_ffToggle.isOn = Setting.isFFmpegSupportEnabled;
			((UnityEvent<bool>)(object)_ffToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
			{
				Setting.isFFmpegSupportEnabled = v;
			});
			UIBuilder.AddLabel(item, "Enables loading unknown audio/video via FFmpeg.\nMake sure 'ffmpeg' is available in PATH.", 11, UIBuilder.SubLabelColor, 38f, -1f, -1f, (TextAlignmentOptions)513);
			UIBuilder.AddSpace(item, 10f);
			UIBuilder.AddSeparator(item);
			UIBuilder.AddSpace(item, 4f);
			UIBuilder.AddLabel(item, "Emergency", 13, new Color(1f, 0.3f, 0.3f), 20f, -1f, -1f, (TextAlignmentOptions)513);
			ButtonClickedEvent onClick = UIBuilder.AddButton(item, "Stop All Audio Sources", 13).onClick;
			object obj = <>O.<0>__StopAllAudioSource;
			if (obj == null)
			{
				UnityAction val = AudioSourceManager.StopAllAudioSource;
				<>O.<0>__StopAllAudioSource = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			Setting.syncUI = (Action)Delegate.Combine(Setting.syncUI, new Action(SyncUI));
		}

		private void OnDestroy()
		{
			Setting.syncUI = (Action)Delegate.Remove(Setting.syncUI, new Action(SyncUI));
		}
	}
	public class AnnouncerPanel : MonoBehaviour
	{
		private IAnnouncer _announcer;

		private Transform _content;

		private Dropdown _announcerDropdown;

		private Toggle _randomizeToggle;

		private TextMeshProUGUI _mismatchLabel;

		private readonly Dictionary<string, Category> _categories = new Dictionary<string, Category>();

		public void Initialize(IAnnouncer announcer)
		{
			_announcer = announcer;
			IAnnouncer announcer2 = _announcer;
			announcer2.syncUI = (Action)Delegate.Combine(announcer2.syncUI, new Action(Refresh));
			Build();
		}

		public void Refresh()
		{
			if (_announcer == null)
			{
				return;
			}
			string currentPack = Path.GetFileName(_announcer.announcerPath);
			int num = _announcerDropdown.options.FindIndex((OptionData o) => o.text == currentPack);
			if (num >= 0)
			{
				_announcerDropdown.SetValueWithoutNotify(num);
			}
			if (!_announcer.isConfigLoaded)
			{
				((TMP_Text)_mismatchLabel).text = (string.IsNullOrEmpty(_announcer.configMismatchInfo) ? "Config not loaded." : ("Config mismatch — " + _announcer.configMismatchInfo));
				return;
			}
			((TMP_Text)_mismatchLabel).text = "";
			PackConfig announcerConfig = _announcer.announcerConfig;
			if ((Object)(object)_randomizeToggle == (Object)null)
			{
				BuildConfigSection(announcerConfig);
			}
			Toggle randomizeToggle = _randomizeToggle;
			if (randomizeToggle != null)
			{
				randomizeToggle.SetIsOnWithoutNotify(announcerConfig.RandomizeAudioOnPlay);
			}
			foreach (KeyValuePair<string, Category> category in _categories)
			{
				if (announcerConfig.CategorySetting.TryGetValue(category.Key, out var value))
				{
					category.Value.enabledToggle.SetIsOnWithoutNotify(value.Enabled);
					category.Value.SetVolume(value.VolumeMultiplier);
					category.Value.SetCooldown(value.Cooldown);
				}
			}
		}

		private void Build()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			UIBuilder.SetFullStretch(((Component)this).GetComponent<RectTransform>() ?? ((Component)this).gameObject.AddComponent<RectTransform>());
			Transform parent = (_content = UIBuilder.BuildScrollView(((Component)this).transform).content);
			UIBuilder.AddLabel(parent, _announcer.title, 26, Color.white, 36f, -1f, -1f, (TextAlignmentOptions)513);
			UIBuilder.AddSpace(parent, 3f);
			UIBuilder.AddLabel(parent, "Selected Announcer", 13, UIBuilder.SubLabelColor, 22f, -1f, -1f, (TextAlignmentOptions)513);
			List<string> availablePacks = AudioAnnouncer.GetAvailablePacks(_announcer.title);
			_announcerDropdown = UIBuilder.AddDropdown(parent, availablePacks);
			string fileName = Path.GetFileName(_announcer.announcerPath);
			int num = availablePacks.IndexOf(fileName);
			if (num >= 0)
			{
				_announcerDropdown.SetValueWithoutNotify(num);
			}
			((UnityEvent<int>)(object)_announcerDropdown.onValueChanged).AddListener((UnityAction<int>)delegate(int idx)
			{
				string text = _announcerDropdown.options[idx].text;
				_announcer.announcerPath = Path.Combine(Setting.announcersPath, _announcer.title, text);
			});
			UIBuilder.AddSpace(parent, 3f);
			((UnityEvent)UIBuilder.AddButton(parent, "Open Current Announcer Folder").onClick).AddListener((UnityAction)delegate
			{
				_announcer.EditExternally();
			});
			UIBuilder.AddSpace(parent, 3f);
			_mismatchLabel = UIBuilder.AddLabel(parent, "", 14, new Color(1f, 0.4f, 0.4f), 22f, -1f, -1f, (TextAlignmentOptions)513);
			if (_announcer.isConfigLoaded)
			{
				BuildConfigSection(_announcer.announcerConfig);
			}
		}

		private void BuildConfigSection(PackConfig cfg)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = UIBuilder.AddRow(_content, "RandomizeRow").transform;
			UIBuilder.AddLabel(transform, "Randomize Audio On Play", 14, Color.white, -1f, 200f, 1f, (TextAlignmentOptions)513);
			_randomizeToggle = UIBuilder.AddToggle(transform, 30f);
			_randomizeToggle.isOn = cfg.RandomizeAudioOnPlay;
			((UnityEvent<bool>)(object)_randomizeToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
			{
				_announcer.announcerConfig.RandomizeAudioOnPlay = v;
			});
			UIBuilder.AddSpace(_content, 3f);
			UIBuilder.AddLabel(_content, "Configuration", 20, new Color(0.85f, 0.85f, 0.85f), 30f, -1f, -1f, (TextAlignmentOptions)513);
			foreach (KeyValuePair<string, CategorySetting> item in cfg.CategorySetting)
			{
				string key = item.Key;
				GameObject val = new GameObject("Category_" + key, new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(_content, false);
				Category category = val.AddComponent<Category>();
				category.SetName(key);
				category.enabledToggle.isOn = item.Value.Enabled;
				((UnityEvent<bool>)(object)category.enabledToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
				{
					if (_announcer.announcerConfig.CategorySetting.TryGetValue(key, out var value3))
					{
						value3.Enabled = v;
					}
				});
				category.SetVolume(item.Value.VolumeMultiplier);
				((UnityEvent<float>)(object)category.volumeSlider.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
				{
					if (_announcer.announcerConfig.CategorySetting.TryGetValue(key, out var value2))
					{
						value2.VolumeMultiplier = v;
					}
				});
				category.SetCooldown(item.Value.Cooldown);
				((UnityEvent<float>)(object)category.cooldownSlider.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
				{
					if (_announcer.announcerConfig.CategorySetting.TryGetValue(key, out var value))
					{
						value.Cooldown = v;
					}
				});
				_categories[key] = category;
				UIBuilder.AddSpace(_content, 3f);
			}
		}
	}
	public class CreditsPanel : MonoBehaviour
	{
		public void Awake()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			UIBuilder.SetFullStretch(((Component)this).GetComponent<RectTransform>() ?? ((Component)this).gameObject.AddComponent<RectTransform>());
			Transform item = UIBuilder.BuildScrollView(((Component)this).transform, new RectOffset(12, 12, 12, 12)).content;
			UIBuilder.AddLabel(item, "Credits", 26, new Color(1f, 0.3f, 1f), 23f, -1f, -1f, (TextAlignmentOptions)513);
			UIBuilder.AddSeparator(item);
			UIBuilder.AddSpace(item, 6f);
			UIBuilder.AddLabel(item, BuildCreditText(), 13, Color.white, -1f, -1f, -1f, (TextAlignmentOptions)257);
		}

		private static string BuildCreditText()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Thanks:");
			stringBuilder.AppendLine("https://unsplash.com/photos/white-textile-on-brown-wooden-table-_kUxT8WkoeY");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- OSU!");
			stringBuilder.AppendLine("  (https://osu.ppy.sh/) some UX are copied from lazer (YES EDIT EXTERNALLY),");
			stringBuilder.AppendLine("  use .ini as config cuz `skin.ini` is pretty easy to edit");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- Artless Games");
			stringBuilder.AppendLine("  (https://space.bilibili.com/1237125233) 14 Minesweeper variants");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- Announcer Mod");
			stringBuilder.AppendLine("  (https://www.nexusmods.com/ultrakill/mods/54) I started this project just");
			stringBuilder.AppendLine("  because the mod wasn't updated a few days after revamp");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- PluginConfigurator doc");
			stringBuilder.AppendLine("  (https://github.com/eternalUnion/UKPluginConfigurator/wiki)");
			stringBuilder.AppendLine("  Easy to use tbh (except changing font)");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- Maxwell's puzzling demon");
			stringBuilder.AppendLine("  (https://store.steampowered.com/app/2770160/)");
			stringBuilder.AppendLine("  Fun puzzle game");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- A mod that currently WIP");
			stringBuilder.AppendLine("  (Advert Placeholder)");
			stringBuilder.AppendLine("  Pretty FUN I would say");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- 快乐萨卡兹厨, jamcame, 夕柱.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- Everyone who used this mod.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- FUCK YOU UNITY.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("Turn up the bass!");
			stringBuilder.AppendLine("THWWWWOOOOMPPPP DHGDHGDHGDHGDHGDHG BWOBWOBWOBWOB BWOBWOBWOBWOB BWOBWOBWOBWOBWOB");
			stringBuilder.AppendLine("BWAHH BWAHH BWAHH HMRMRMRMRMRMRMRMMR WOH WOH WOH- H H H HHHHH");
			stringBuilder.AppendLine("THWWOOMPPPP DHGDHGDHGDHGDHGDHG BWOBWOBWOBWOB.. BWOBWOBWOBWOB..");
			stringBuilder.AppendLine("BWOBWOBWOBWOBWOB.... HRMMMMMMMMMMMMMMMMRRR- HRRRRRRR HRRRRRRRR HRRRRRR HRRRRRRRR");
			stringBuilder.AppendLine("HRRR HR-YOOOH!!!!!!");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("- shadow of cats");
			return stringBuilder.ToString();
		}
	}
	public class MainPanel : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__ReloadAllAnnouncers;
		}

		private Transform _navContent;

		private Transform _rightPanelRoot;

		private readonly List<AnnouncerPanel> _panels = new List<AnnouncerPanel>();

		private readonly List<GameObject> _navButtons = new List<GameObject>();

		private GameObject _advancedPanelObj;

		private GameObject _creditsPanelObj;

		private Slider _volumeSlider;

		private Dropdown _playDd;

		private Dropdown _loadDd;

		public void Awake()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			UIBuilder.SetFullStretch(((Component)this).GetComponent<RectTransform>() ?? ((Component)this).gameObject.AddComponent<RectTransform>());
			Transform item = UIBuilder.BuildScrollView(CreatePanel("LeftPanel", 0f, 0.4f, new Color(0.18f, 0.18f, 0.18f, 0.95f)).transform, new RectOffset(8, 8, 8, 8), addScrollbar: false).content;
			_navContent = item;
			BuildGlobalSettings(_navContent);
			GameObject val = CreatePanel("RightPanel", 0.4f, 1f, new Color(0.1f, 0.1f, 0.1f, 1f));
			_rightPanelRoot = val.transform;
			_advancedPanelObj = CreateSpecialPanel<AdvancedPanel>("AdvancedPanel");
			_creditsPanelObj = CreateSpecialPanel<CreditsPanel>("CreditsPanel");
			foreach (IAnnouncer allAnnouncer in AnnouncerManager.GetAllAnnouncers())
			{
				AddAnnouncerPanel(allAnnouncer);
			}
			AnnouncerManager.OnRegistered += AddAnnouncerPanel;
			Setting.syncUI = (Action)Delegate.Combine(Setting.syncUI, new Action(SyncUI));
		}

		private void OnDestroy()
		{
			AnnouncerManager.OnRegistered -= AddAnnouncerPanel;
			Setting.syncUI = (Action)Delegate.Remove(Setting.syncUI, new Action(SyncUI));
		}

		private void SyncUI()
		{
			_volumeSlider.SetValueWithoutNotify(Setting.audioSourceVolume);
			_playDd.SetValueWithoutNotify(Setting.audioPlayOptions);
			_loadDd.SetValueWithoutNotify(Setting.audioLoadingStrategy);
		}

		private void BuildGlobalSettings(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Expected O, but got Unknown
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Expected O, but got Unknown
			UIBuilder.AddLabel(parent, "Settings", 15, new Color(0.5f, 0.8f, 1f), 23f, -1f, -1f, (TextAlignmentOptions)513);
			UIBuilder.AddLabel(parent, "Master Volume", 12, UIBuilder.SubLabelColor, 20f, -1f, -1f, (TextAlignmentOptions)513);
			_volumeSlider = UIBuilder.AddSlider(parent, Setting.audioSourceVolume, 0f, 1f);
			((UnityEvent<float>)(object)_volumeSlider.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
			{
				Setting.audioSourceVolume = v;
			});
			UIBuilder.AddLabel(parent, "Play Strategy", 12, UIBuilder.SubLabelColor, 20f, -1f, -1f, (TextAlignmentOptions)513);
			_playDd = UIBuilder.AddDropdown(parent, (from s in Enum.GetNames(typeof(AudioPlayOptions))
				select s.Replace('_', ' ')).ToList(), 30f);
			_playDd.value = Setting.audioPlayOptions;
			((UnityEvent<int>)(object)_playDd.onValueChanged).AddListener((UnityAction<int>)delegate(int v)
			{
				Setting.audioPlayOptions = v;
			});
			UIBuilder.AddLabel(parent, "Load Strategy", 12, UIBuilder.SubLabelColor, 20f, -1f, -1f, (TextAlignmentOptions)513);
			_loadDd = UIBuilder.AddDropdown(parent, (from s in Enum.GetNames(typeof(AudioLoadOptions))
				select s.Replace('_', ' ')).ToList(), 30f);
			_loadDd.value = Setting.audioLoadingStrategy;
			((UnityEvent<int>)(object)_loadDd.onValueChanged).AddListener((UnityAction<int>)delegate(int v)
			{
				Setting.audioLoadingStrategy = v;
			});
			Transform transform = UIBuilder.AddRow(parent, "ActionRow", 36f).transform;
			Button obj = UIBuilder.AddButton(transform, "Reload", 12);
			((Component)obj).GetComponent<LayoutElement>().flexibleWidth = 1f;
			ButtonClickedEvent onClick = obj.onClick;
			object obj2 = <>O.<0>__ReloadAllAnnouncers;
			if (obj2 == null)
			{
				UnityAction val = AnnouncerManager.ReloadAllAnnouncers;
				<>O.<0>__ReloadAllAnnouncers = val;
				obj2 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj2);
			Button obj3 = UIBuilder.AddButton(transform, "Advanced", 12);
			((Component)obj3).GetComponent<LayoutElement>().flexibleWidth = 1f;
			((UnityEvent)obj3.onClick).AddListener(new UnityAction(ShowAdvanced));
			Button obj4 = UIBuilder.AddButton(transform, "Credits", 12);
			((Component)obj4).GetComponent<LayoutElement>().flexibleWidth = 1f;
			((UnityEvent)obj4.onClick).AddListener(new UnityAction(ShowCredits));
			UIBuilder.AddSeparator(parent);
			UIBuilder.AddLabel(parent, "Announcers", 13, new Color(1f, 0.7f, 0.3f), 21f, -1f, -1f, (TextAlignmentOptions)513);
		}

		private void AddAnnouncerPanel(IAnnouncer announcer)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			int index = _panels.Count;
			Button val = UIBuilder.AddButton(_navContent, announcer.title, 14, 44f);
			UIBuilder.StyleButton(((Component)val).gameObject, index == 0);
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				ShowPanel(index);
			});
			GameObject val2 = new GameObject("AnnouncerPanel_" + announcer.title, new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(_rightPanelRoot, false);
			UIBuilder.SetFullStretch(val2.GetComponent<RectTransform>());
			AnnouncerPanel announcerPanel = val2.AddComponent<AnnouncerPanel>();
			announcerPanel.Initialize(announcer);
			val2.SetActive(index == 0);
			_panels.Add(announcerPanel);
			_navButtons.Add(((Component)val).gameObject);
		}

		private void ShowPanel(int index)
		{
			_advancedPanelObj.SetActive(false);
			_creditsPanelObj.SetActive(false);
			for (int i = 0; i < _panels.Count; i++)
			{
				((Component)_panels[i]).gameObject.SetActive(i == index);
				UIBuilder.StyleButton(_navButtons[i], i == index);
			}
		}

		private void ShowAdvanced()
		{
			foreach (AnnouncerPanel panel in _panels)
			{
				((Component)panel).gameObject.SetActive(false);
			}
			foreach (GameObject navButton in _navButtons)
			{
				UIBuilder.StyleButton(navButton, active: false);
			}
			_advancedPanelObj.SetActive(true);
			_creditsPanelObj.SetActive(false);
		}

		private void ShowCredits()
		{
			foreach (AnnouncerPanel panel in _panels)
			{
				((Component)panel).gameObject.SetActive(false);
			}
			foreach (GameObject navButton in _navButtons)
			{
				UIBuilder.StyleButton(navButton, active: false);
			}
			_advancedPanelObj.SetActive(false);
			_creditsPanelObj.SetActive(true);
		}

		private GameObject CreateSpecialPanel<T>(string name) where T : MonoBehaviour
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(_rightPanelRoot, false);
			UIBuilder.SetFullStretch(val.GetComponent<RectTransform>());
			val.AddComponent<T>();
			val.SetActive(false);
			return val;
		}

		private GameObject CreatePanel(string name, float xMin, float xMax, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(((Component)this).transform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(xMin, 0f);
			component.anchorMax = new Vector2(xMax, 1f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			((Graphic)val.GetComponent<Image>()).color = color;
			return val;
		}
	}
	public static class UIBuilder
	{
		public static readonly Color NavActive = new Color(0.25f, 0.45f, 0.65f);

		public static readonly Color NavInactive = new Color(0.22f, 0.22f, 0.22f);

		public static readonly Color SeparatorColor = new Color(0.4f, 0.4f, 0.4f);

		public static readonly Color SubLabelColor = new Color(0.7f, 0.7f, 0.7f);

		public static void SetFullStretch(RectTransform rt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
			((Transform)rt).localScale = Vector3.one;
		}

		public static GameObject AddRow(Transform parent, string name, float height = 30f, float spacing = 8f)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = spacing;
			val.AddComponent<LayoutElement>().preferredHeight = height;
			return val;
		}

		public static TextMeshProUGUI AddLabel(Transform parent, string text, int fontSize, Color color, float preferredHeight = -1f, float preferredWidth = -1f, float flexibleWidth = -1f, TextAlignmentOptions alignment = 513)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Label_" + text, new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent(parent, false);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			if (preferredHeight >= 0f)
			{
				val2.preferredHeight = preferredHeight;
			}
			if (preferredWidth >= 0f)
			{
				val2.preferredWidth = preferredWidth;
			}
			if (flexibleWidth >= 0f)
			{
				val2.flexibleWidth = flexibleWidth;
			}
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = fontSize;
			((Graphic)component).color = color;
			((TMP_Text)component).alignment = alignment;
			return component;
		}

		public static Button AddButton(Transform parent, string label, int fontSize = 14, float height = 36f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DefaultControls.CreateButton(default(Resources));
			((Object)obj).name = "Btn_" + label;
			obj.transform.SetParent(parent, false);
			obj.AddComponent<LayoutElement>().preferredHeight = height;
			SetButtonLabel(obj, label, fontSize);
			return obj.GetComponent<Button>();
		}

		public static void StyleButton(GameObject btnObj, bool active)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Image component = btnObj.GetComponent<Image>();
			if (component != null)
			{
				((Graphic)component).color = (active ? NavActive : NavInactive);
			}
		}

		public static void SetButtonLabel(GameObject btnObj, string text, int fontSize)
		{
			TextMeshProUGUI componentInChildren = btnObj.GetComponentInChildren<TextMeshProUGUI>();
			if (componentInChildren != null)
			{
				((TMP_Text)componentInChildren).text = text;
				((TMP_Text)componentInChildren).fontSize = fontSize;
				return;
			}
			Text componentInChildren2 = btnObj.GetComponentInChildren<Text>();
			if (componentInChildren2 != null)
			{
				componentInChildren2.text = text;
				componentInChildren2.fontSize = fontSize;
			}
		}

		public static Toggle AddToggle(Transform parent, float preferredWidth = 24f, float preferredHeight = 28f)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = DefaultControls.CreateToggle(default(Resources));
			val.transform.SetParent(parent, false);
			LayoutElement val2 = val.AddComponent<LayoutElement>();
			val2.preferredWidth = preferredWidth;
			val2.flexibleWidth = 0f;
			if (preferredHeight >= 0f)
			{
				val2.preferredHeight = preferredHeight;
			}
			Toggle component = val.GetComponent<Toggle>();
			GameObject val3 = new GameObject("Indicator", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val3.transform.SetParent(val.transform, false);
			SetFullStretch(val3.GetComponent<RectTransform>());
			TextMeshProUGUI tmp = val3.GetComponent<TextMeshProUGUI>();
			((TMP_Text)tmp).text = (component.isOn ? "x" : "");
			((TMP_Text)tmp).fontSize = 14f;
			((Graphic)tmp).color = Color.black;
			((TMP_Text)tmp).alignment = (TextAlignmentOptions)514;
			((Graphic)tmp).raycastTarget = false;
			((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
			{
				((TMP_Text)tmp).text = (v ? "x" : "");
			});
			return component;
		}

		public static Slider AddSlider(Transform parent, float value, float min, float max, float preferredHeight = 28f, float preferredWidth = -1f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DefaultControls.CreateSlider(default(Resources));
			obj.transform.SetParent(parent, false);
			LayoutElement val = obj.AddComponent<LayoutElement>();
			val.preferredHeight = preferredHeight;
			if (preferredWidth >= 0f)
			{
				val.preferredWidth = preferredWidth;
				val.flexibleWidth = 0f;
			}
			else
			{
				val.flexibleWidth = 1f;
			}
			Slider component = obj.GetComponent<Slider>();
			component.minValue = min;
			component.maxValue = max;
			component.value = value;
			return component;
		}

		public static Dropdown AddDropdown(Transform parent, List<string> options, float height = 36f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DefaultControls.CreateDropdown(default(Resources));
			obj.transform.SetParent(parent, false);
			obj.AddComponent<LayoutElement>().preferredHeight = height;
			Dropdown component = obj.GetComponent<Dropdown>();
			component.ClearOptions();
			component.AddOptions(options);
			return component;
		}

		public static void AddSpace(Transform parent, float height)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Space", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			val.AddComponent<LayoutElement>().preferredHeight = height;
		}

		public static void AddSeparator(Transform parent)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Separator", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			val.AddComponent<LayoutElement>().preferredHeight = 1f;
			((Graphic)val.GetComponent<Image>()).color = SeparatorColor;
		}

		public static (ScrollRect scrollRect, Transform content) BuildScrollView(Transform parent, RectOffset padding = null, bool addScrollbar = true)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected O, but got Unknown
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Expected O, but got Unknown
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ScrollView", new Type[2]
			{
				typeof(RectTransform),
				typeof(ScrollRect)
			});
			val.transform.SetParent(parent, false);
			SetFullStretch(val.GetComponent<RectTransform>());
			ScrollRect component = val.GetComponent<ScrollRect>();
			GameObject val2 = new GameObject("Viewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(RectMask2D),
				typeof(Image)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			SetFullStretch(component2);
			if (addScrollbar)
			{
				component2.offsetMax = new Vector2(-20f, 0f);
			}
			((Graphic)val2.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0f);
			GameObject val3 = new GameObject("Content", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val2.transform, false);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			VerticalLayoutGroup obj = val3.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 8f;
			((LayoutGroup)obj).padding = (RectOffset)(((object)padding) ?? ((object)new RectOffset(12, 12, 12, 12)));
			val3.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			component.content = component3;
			component.viewport = component2;
			component.horizontal = false;
			component.vertical = true;
			if (addScrollbar)
			{
				GameObject val4 = new GameObject("Scrollbar", new Type[3]
				{
					typeof(RectTransform),
					typeof(Scrollbar),
					typeof(Image)
				});
				val4.transform.SetParent(val.transform, false);
				RectTransform component4 = val4.GetComponent<RectTransform>();
				component4.anchorMin = new Vector2(1f, 0f);
				component4.anchorMax = new Vector2(1f, 1f);
				component4.offsetMin = new Vector2(-20f, 0f);
				component4.offsetMax = Vector2.zero;
				((Graphic)val4.GetComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f, 0.6f);
				Scrollbar component5 = val4.GetComponent<Scrollbar>();
				component5.direction = (Direction)2;
				GameObject val5 = new GameObject("Handle", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val5.transform.SetParent(val4.transform, false);
				SetFullStretch(val5.GetComponent<RectTransform>());
				((Graphic)val5.GetComponent<Image>()).color = new Color(0.6f, 0.6f, 0.6f);
				component.verticalScrollbar = component5;
				component5.handleRect = val5.GetComponent<RectTransform>();
			}
			return (component, val3.transform);
		}
	}
	public class UIFactory : MonoBehaviour
	{
		public GameObject mainPanel;

		public InputAction _toggleUIAction;

		public bool isAllowTrigger;

		public void Start()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			LogHelper.LogDebug("Register UIFactory Actions", "Start");
			_toggleUIAction = new InputAction((string)null, (InputActionType)0, "<Keyboard>/backslash", "hold(duration=0.5)", (string)null, (string)null);
			_toggleUIAction.performed += delegate
			{
				isAllowTrigger = true;
			};
			_toggleUIAction.canceled += delegate
			{
				TryOpenUI();
			};
			_toggleUIAction.Enable();
		}

		public void TryOpenUI()
		{
			LogHelper.LogDebug("TryOpenUI Called", "TryOpenUI");
			if (isAllowTrigger)
			{
				if ((Object)(object)mainPanel == (Object)null)
				{
					CreateUI();
				}
				else
				{
					mainPanel.SetActive(!mainPanel.activeSelf);
				}
				isAllowTrigger = false;
			}
		}

		public void CreateUI()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			LogHelper.LogInfo("Loading UI...", "CreateUI");
			Canvas val = UnityPathManager.FindCanvas();
			if (!((Object)(object)val == (Object)null))
			{
				mainPanel = new GameObject("MainPanelHost");
				mainPanel.transform.SetParent(((Component)val).transform, false);
				mainPanel.AddComponent<MainPanel>();
				RectTransform obj = mainPanel.GetComponent<RectTransform>() ?? mainPanel.AddComponent<RectTransform>();
				obj.anchorMin = Vector2.zero;
				obj.anchorMax = Vector2.one;
				obj.anchoredPosition = Vector2.zero;
				obj.offsetMax = new Vector2(-20f, -20f);
				obj.offsetMin = new Vector2(20f, 20f);
				LogHelper.LogInfo("UI Initialized at full size with margins.", "CreateUI");
			}
		}
	}
}
namespace GreyAnnouncer.Base
{
	public abstract class NotifyBase : INotifyPropertyChanged
	{
		private bool _suspendNotify;

		private bool _hasPendingChange;

		public event PropertyChangedEventHandler PropertyChanged;

		public void BeginUpdate()
		{
			_suspendNotify = true;
		}

		public void EndUpdate()
		{
			_suspendNotify = false;
			if (_hasPendingChange)
			{
				_hasPendingChange = false;
				this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(null));
			}
		}

		protected bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
		{
			if (EqualityComparer<T>.Default.Equals(field, value))
			{
				return false;
			}
			field = value;
			if (!_suspendNotify)
			{
				RaiseChanged(propertyName);
			}
			else
			{
				_hasPendingChange = true;
			}
			return true;
		}

		protected void RaiseChanged(string name = null)
		{
			if (_suspendNotify)
			{
				_hasPendingChange = true;
			}
			else
			{
				this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
			}
		}
	}
	public class ObservableDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, INotifyCollectionChanged, INotifyPropertyChanged where TValue : INotifyPropertyChanged
	{
		private readonly Dictionary<TKey, TValue> _dict = new Dictionary<TKey, TValue>();

		public TValue this[TKey key]
		{
			get
			{
				return _dict[key];
			}
			set
			{
				TValue val2;
				if (_dict.ContainsKey(key))
				{
					TValue val = _dict[key];
					ref TValue reference = ref val;
					val2 = default(TValue);
					if (val2 == null)
					{
						val2 = reference;
						reference = ref val2;
					}
					reference.PropertyChanged -= OnItemPropertyChanged;
					_dict[key] = value;
					ref TValue reference2 = ref value;
					val2 = default(TValue);
					if (val2 == null)
					{
						val2 = reference2;
						reference2 = ref val2;
					}
					reference2.PropertyChanged += OnItemPropertyChanged;
					this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, value, val));
					this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Count"));
				}
				else
				{
					_dict[key] = value;
					ref TValue reference3 = ref value;
					val2 = default(TValue);
					if (val2 == null)
					{
						val2 = reference3;
						reference3 = ref val2;
					}
					reference3.PropertyChanged += OnItemPropertyChanged;
					this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, value));
					this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Count"));
				}
			}
		}

		public ICollection<TKey> Keys => _dict.Keys;

		public ICollection<TValue> Values => _dict.Values;

		public int Count => _dict.Count;

		public bool IsReadOnly => false;

		public event NotifyCollectionChangedEventHandler CollectionChanged;

		public event PropertyChangedEventHandler PropertyChanged;

		public void Add(TKey key, TValue value)
		{
			this[key] = value;
		}

		public bool Remove(TKey key)
		{
			if (_dict.TryGetValue(key, out var value))
			{
				ref TValue reference = ref value;
				TValue val = default(TValue);
				if (val == null)
				{
					val = reference;
					reference = ref val;
				}
				reference.PropertyChanged -= OnItemPropertyChanged;
				bool num = _dict.Remove(key);
				if (num)
				{
					this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, value));
					PropertyChangedEventHandler propertyChanged = this.PropertyChanged;
					if (propertyChanged == null)
					{
						return num;
					}
					propertyChanged(this, new PropertyChangedEventArgs("Count"));
				}
				return num;
			}
			return false;
		}

		public bool ContainsKey(TKey key)
		{
			return _dict.ContainsKey(key);
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			return _dict.TryGetValue(key, out value);
		}

		public void Clear()
		{
			foreach (TValue value in _dict.Values)
			{
				TValue current = value;
				ref TValue reference = ref current;
				TValue val = default(TValue);
				if (val == null)
				{
					val = reference;
					reference = ref val;
				}
				reference.PropertyChanged -= OnItemPropertyChanged;
			}
			_dict.Clear();
			this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
			this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Count"));
		}

		private void OnItemPropertyChanged(object sender, PropertyChangedEventArgs e)
		{
			this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Item." + e.PropertyName));
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return _dict.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return _dict.GetEnumerator();
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			Add(item.Key, item.Value);
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			if (_dict.ContainsKey(item.Key))
			{
				return _dict[item.Key].Equals(item.Value);
			}
			return false;
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			throw new NotImplementedException();
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}
	}
}
namespace GreyAnnouncer.Config
{
	public static class BepInExConfig
	{
		[ConfigInfo("Audio", "Audio_source_volume", "Volume of the Announcer (Range: 0f ~ 1f)")]
		public static ConfigEntry<float> audioSourceVolume;

		[ConfigInfo("Audio", "Under_water_low_pass_filter_Enabled", "Set to true to enable muffle effect when under water")]
		public static ConfigEntry<bool> isLowPassFilterEnabled;

		[ConfigInfo("Audio", "Audio_Play_Option", "0: new audio will override the old one, 1: audio will not effect each other")]
		public static ConfigEntry<int> audioPlayOptions;

		[ConfigInfo("Audio", "Audio_Loading_Option", "0: load from file (less RAM), 1: preload (less latency)")]
		public static ConfigEntry<int> audioLoadingStrategy;

		[ConfigInfo("Advanced", "FFmpeg_Support", "Set to true to enable FFmpeg support for non-Unity audio formats")]
		public static ConfigEntry<bool> isFFmpegSupportEnabled;

		public static void Initialize(Plugin plugin)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			foreach (FieldInfo item in from f in typeof(BepInExConfig).GetFields(BindingFlags.Static | BindingFlags.Public)
				where f.GetCustomAttribute<ConfigInfoAttribute>() != null
				select f)
			{
				try
				{
					ConfigInfoAttribute customAttribute = item.GetCustomAttribute<ConfigInfoAttribute>();
					object defaultValueForField = GetDefaultValueForField(item.Name);
					Type type = item.FieldType.GetGenericArguments()[0];
					ConfigDescription val = new ConfigDescription(customAttribute.Description, (AcceptableValueBase)null, Array.Empty<object>());
					object value = ((object)((BaseUnityPlugin)plugin).Config).GetType().GetMethods().First((MethodInfo m) => m.Name == "Bind" && m.GetParameters().Length == 4 && m.GetParameters()[3].ParameterType == typeof(ConfigDescription))
						.MakeGenericMethod(type)
						.Invoke(((BaseUnityPlugin)plugin).Config, new object[4] { customAttribute.Section, customAttribute.Name, defaultValueForField, val });
					item.SetValue(null, value);
				}
				catch (Exception ex)
				{
					LogHelper.LogError("Failed to bind config field " + item.Name + ": " + (ex.InnerException?.Message ?? ex.Message), "Initialize");
				}
			}
			LogHelper.LogInfo("BepInExConfig initialized successfully.", "Initialize");
		}

		private static object GetDefaultValueForField(string fieldName)
		{
			return fieldName switch
			{
				"audioSourceVolume" => 1f, 
				"isLowPassFilterEnabled" => true, 
				"audioPlayOptions" => 0, 
				"audioLoadingStrategy" => 0, 
				"isFFmpegSupportEnabled" => false, 
				_ => throw new ArgumentException("[Config] No default value defined for: " + fieldName), 
			};
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	public class ConfigInfoAttribute : Attribute
	{
		public string Section { get; }

		public string Name { get; }

		public string Description { get; }

		public ConfigInfoAttribute(string section, string name, string description)
		{
			Section = section;
			Name = name;
			Description = description;
		}
	}
	public class PluginSettings
	{
		private const string FileName = "settings.json";

		public static PluginSettings Instance { get; private set; }

		public float AudioSourceVolume { get; set; } = 1f;


		public bool IsLowPassFilterEnabled { get; set; } = true;


		public int AudioPlayOptions { get; set; }

		public int AudioLoadingStrategy { get; set; }

		public bool IsFFmpegSupportEnabled { get; set; }

		public float SpatialBlend { get; set; }

		public static void Initialize()
		{
			Instance = JsonManager.ReadJson<PluginSettings>(PathHelper.GetCurrentPluginPath("settings.json"));
			if (Instance == null)
			{
				Instance = new PluginSettings();
				Save();
			}
		}

		public static void Save()
		{
			JsonManager.WriteJson(PathHelper.GetCurrentPluginPath("settings.json"), Instance);
		}
	}
	public static class Setting
	{
		public static Action syncUI;

		public static float audioSourceVolume
		{
			get
			{
				return PluginSettings.Instance.AudioSourceVolume;
			}
			set
			{
				PluginSettings.Instance.AudioSourceVolume = value;
				SoloAudioSource.Instance.UpdateSoloAudioSourceVolume(value);
				SaveSettings();
			}
		}

		public static float spatialBlend
		{
			get
			{
				return PluginSettings.Instance.SpatialBlend;
			}
			set
			{
				PluginSettings.Instance.SpatialBlend = value;
				SaveSettings();
			}
		}

		public static bool isLowPassFilterEnabled
		{
			get
			{
				return PluginSettings.Instance.IsLowPassFilterEnabled;
			}
			set
			{
				PluginSettings.Instance.IsLowPassFilterEnabled = value;
				UnderwaterController_inWater_Instance.CheckIsInWater();
				SaveSettings();
			}
		}

		public static int audioPlayOptions
		{
			get
			{
				return PluginSettings.Instance.AudioPlayOptions;
			}
			set
			{
				PluginSettings.Instance.AudioPlayOptions = value;
				SaveSettings();
			}
		}

		public static int audioLoadingStrategy
		{
			get
			{
				return PluginSettings.Instance.AudioLoadingStrategy;
			}
			set
			{
				PluginSettings.Instance.AudioLoadingStrategy = value;
				if (value.Equals(0))
				{
					LogHelper.LogInfo("Clear audio clip cache", "audioLoadingStrategy");
					AnnouncerManager.ClearAudioClipsCache();
				}
				if (value.Equals(1))
				{
					LogHelper.LogInfo("Reloading all announcer audio", "audioLoadingStrategy");
					AnnouncerManager.ReloadAllAnnouncers();
				}
				SaveSettings();
			}
		}

		public static bool isFFmpegSupportEnabled
		{
			get
			{
				return PluginSettings.Instance.IsFFmpegSupportEnabled;
			}
			set
			{
				PluginSettings.Instance.IsFFmpegSupportEnabled = value;
				SaveSettings();
			}
		}

		public static string announcersPath => PathHelper.GetCurrentPluginPath("announcers");

		private static void SaveSettings()
		{
			PluginSettings.Save();
			syncUI?.Invoke();
		}
	}
}
namespace GreyAnnouncer.Commands
{
	public sealed class CommandsToRegister : CommandRoot, IConsoleLogger
	{
		public override string Name => "grey";

		public override string Description => "";

		public Logger Log { get; } = new Logger("grey");


		public CommandsToRegister(Console con)
			: base(con)
		{
		}//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown


		public override Branch BuildTree(Console con)
		{
			return CommandRoot.Branch(((CommandRoot)this).Name, (Node[])(object)new Node[5]
			{
				(Node)GetMainSettingBranches(),
				(Node)GetUtilBranches(),
				(Node)GetAnnouncerBranches(),
				(Node)GetTestBranches(),
				(Node)CommandRoot.Leaf("help", (Action)delegate
				{
					Log.Info("=== GreyAnnouncer Command Reference ===", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("[Main Settings] grey m", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  audiosourcevolume get/set <float>   - Global announcer volume (0.0 ~ 1.0)", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  ffmpegenabled     get/set <bool>    - Enable FFmpeg support for non-Unity audio formats", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  lowpassenabled    get/set <bool>    - Enable underwater low-pass filter effect", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  announcerspath    get/set <string>  - Folder path where announcer packs are stored", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("[Announcer] grey a <announcer>", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  randomize         get/set <bool>    - Randomize category selection on playback", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  category <name>   get/set", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("    enabled         get/set <bool>    - Enable or disable this category", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("    volume          get/set <float>   - Volume multiplier for this category", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("    cooldown        get/set <float>   - Cooldown in seconds between plays", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("    audiofiles      get/set <files>   - Audio files assigned to this category", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  editexternal                        - Open announcer folder in file explorer", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  reload                              - Reload announcer config from disk", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  structure                           - Print announcer object tree", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("[Utilities] grey u", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  reloadannouncers                   - Reload all announcers", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("  stopallaudiosources                - Stop all active audio sources", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("", (IEnumerable<Tag>)null, (string)null, (object)null);
					Log.Info("[Test] grey t", (IEnumerable<Tag>)null, (string)null, (object)null);
				}, false)
			});
		}

		private Branch GetMainSettingBranches()
		{
			return CommandRoot.Branch("m", (Node[])(object)new Node[4]
			{
				(Node)CommandRoot.Branch("audiosourcevolume", (Node[])(object)new Node[2]
				{
					(Node)CommandRoot.Branch("get", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf((Action)delegate
					{
						Log.Info($"Audio Source Volume: {Setting.audioSourceVolume}", (IEnumerable<Tag>)null, (string)null, (object)null);
					}, false) }),
					(Node)CommandRoot.Branch("set", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf<float>((Action<float>)delegate(float val)
					{
						Setting.audioSourceVolume = val;
						Log.Info($"Audio Source Volume set to {val}", (IEnumerable<Tag>)null, (string)null, (object)null);
					}, false) })
				}),
				(Node)CommandRoot.Branch("ffmpegenabled", (Node[])(object)new Node[2]
				{
					(Node)CommandRoot.Branch("get", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf((Action)delegate
					{
						Log.Info($"FFmpeg Support Enabled: {Setting.isFFmpegSupportEnabled}", (IEnumerable<Tag>)null, (string)null, (object)null);
					}, false) }),
					(Node)CommandRoot.Branch("set", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf<bool>((Action<bool>)delegate(bool val)
					{
						Setting.isFFmpegSupportEnabled = val;
						Log.Info($"FFmpeg Support Enabled set to {val}", (IEnumerable<Tag>)null, (string)null, (object)null);
					}, false) })
				}),
				(Node)CommandRoot.Branch("lowpassenabled", (Node[])(object)new Node[2]
				{
					(Node)CommandRoot.Branch("get", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf((Action)delegate
					{
						Log.Info($"Under Water Low Pass Filter Enabled: {Setting.isLowPassFilterEnabled}", (IEnumerable<Tag>)null, (string)null, (object)null);
					}, false) }),
					(Node)CommandRoot.Branch("set", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf<bool>((Action<bool>)delegate(bool val)
					{
						Setting.isLowPassFilterEnabled = val;
						Log.Info($"Under Water Low Pass Filter Enabled set to {val}", (IEnumerable<Tag>)null, (string)null, (object)null);
					}, false) })
				}),
				(Node)CommandRoot.Branch("announcerspath", (Node[])(object)new Node[2]
				{
					(Node)CommandRoot.Branch("get", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf((Action)delegate
					{
						Log.Info("Current Announcers Path: " + Setting.announcersPath, (IEnumerable<Tag>)null, (string)null, (object)null);
					}, false) }),
					(Node)CommandRoot.Branch("set", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf<string>((Action<string>)delegate(string val)
					{
						Log.Info("This command doesn't have any effect yet", (IEnumerable<Tag>)null, (string)null, (object)null);
						Log.Info("Announcers Path set to " + val, (IEnumerable<Tag>)null, (string)null, (object)null);
					}, false) })
				})
			});
		}

		private Branch GetAnnouncerBranches()
		{
			Node[] array = (Node[])(object)AnnouncerManager.GetAllAnnouncers().Select(delegate(IAnnouncer a)
			{
				string title = a.title;
				Node[] obj = new Node[4]
				{
					(Node)CommandRoot.Branch("randomize", (Node[])(object)new Node[2]
					{
						(Node)CommandRoot.Branch("get", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf((Action)delegate
						{
							Log.Info($"RandomizeAudioOnPlay: {a.announcerConfig.RandomizeAudioOnPlay}", (IEnumerable<Tag>)null, (string)null, (object)null);
						}, false) }),
						(Node)CommandRoot.Branch("set", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf<bool>((Action<bool>)delegate(bool val)
						{
							a.announcerConfig.RandomizeAudioOnPlay = val;
							Log.Info($"Set RandomizeAudioOnPlay to {val}", (IEnumerable<Tag>)null, (string)null, (object)null);
						}, false) })
					}),
					default(Node),
					default(Node),
					default(Node)
				};
				Node[] array2 = (Node[])(object)a.announcerConfig.CategorySetting.Select(delegate(KeyValuePair<string, CategorySetting> kvp)
				{
					string key = kvp.Key;
					CategorySetting category = kvp.Value;
					return CommandRoot.Branch(key, (Node[])(object)new Node[2]
					{
						(Node)CommandRoot.Branch("get", (Node[])(object)new Node[4]
						{
							(Node)CommandRoot.Leaf("enabled", (Action)delegate
							{
								Log.Info($"Enabled: {category.Enabled}", (IEnumerable<Tag>)null, (string)null, (object)null);
							}, false),
							(Node)CommandRoot.Leaf("volume", (Action)delegate
							{
								Log.Info($"VolumeMultiplier: {category.VolumeMultiplier}", (IEnumerable<Tag>)null, (string)null, (object)null);
							}, false),
							(Node)CommandRoot.Leaf("cooldown", (Action)delegate
							{
								Log.Info($"Cooldown: {category.Cooldown}", (IEnumerable<Tag>)null, (string)null, (object)null);
							}, false),
							(Node)CommandRoot.Leaf("audiofiles", (Action)delegate
							{
								Log.Info("AudioFiles: " + string.Join(", ", category.AudioFiles), (IEnumerable<Tag>)null, (string)null, (object)null);
							}, false)
						}),
						(Node)CommandRoot.Branch("set", (Node[])(object)new Node[4]
						{
							(Node)CommandRoot.Leaf<bool>("enabled", (Action<bool>)delegate(bool val)
							{
								category.Enabled = val;
							}, false),
							(Node)CommandRoot.Leaf<float>("volume", (Action<float>)delegate(float val)
							{
								category.VolumeMultiplier = val;
							}, false),
							(Node)CommandRoot.Leaf<float>("cooldown", (Action<float>)delegate(float val)
							{
								category.Cooldown = val;
							}, false),
							(Node)CommandRoot.Leaf<string[]>("audiofiles", (Action<string[]>)delegate(string[] files)
							{
								category.AudioFiles.Clear();
								category.AudioFiles.AddRange(files);
								Log.Info("AudioFiles set: " + string.Join(", ", files), (IEnumerable<Tag>)null, (string)null, (object)null);
							}, false)
						})
					});
				}).ToArray();
				obj[1] = (Node)CommandRoot.Branch("category", array2);
				obj[2] = (Node)CommandRoot.Leaf("editexternal", (Action)delegate
				{
					a.EditExternally();
				}, false);
				obj[3] = (Node)CommandRoot.Leaf("reload", (Action)delegate
				{
					a.ReloadPack();
				}, false);
				return CommandRoot.Branch(title, (Node[])(object)obj);
			}).ToArray();
			return CommandRoot.Branch("a", array);
		}

		public Branch GetUtilBranches()
		{
			return CommandRoot.Branch("u", (Node[])(object)new Node[2]
			{
				(Node)CommandRoot.Leaf("reloadannouncers", (Action)delegate
				{
					AnnouncerManager.ReloadAllAnnouncers();
				}, false),
				(Node)CommandRoot.Leaf("stopallaudiosources", (Action)delegate
				{
					AudioSourceManager.StopAllAudioSource();
				}, false)
			});
		}

		private Branch GetTestBranches()
		{
			return CommandRoot.Branch("t", (Node[])(object)new Node[1] { (Node)CommandRoot.Leaf<string>("ffmpeg", (Action<string>)async delegate(string path)
			{
				Log.Info("Testing FFmpeg load: " + path, (IEnumerable<Tag>)null, (string)null, (object)null);
				try
				{
					AudioClip val = await FFmpegSupport.DecodeAndLoadViaFFmpeg(path);
					if ((Object)(object)val != (Object)null)
					{
						Log.Info($"OK — loaded clip: {val.length:F2}s, ch={val.channels}, rate={val.frequency}", (IEnumerable<Tag>)null, (string)null, (object)null);
					}
					else
					{
						Log.Warning("FFmpeg returned null clip.", (IEnumerable<Tag>)null, (string)null, (object)null);
					}
				}
				catch (Exception ex)
				{
					Log.Error("FFmpeg failed: " + ex.Message, (IEnumerable<Tag>)null, (string)null, (object)null);
				}
			}, false) });
		}
	}
	[HarmonyPatch(typeof(Console))]
	public class ConsolePatcher
	{
		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		public static void AddConsoleCommands(Console __instance)
		{
			__instance.RegisterCommand((ICommand)(object)new CommandsToRegister(__instance));
		}
	}
}
namespace GreyAnnouncer.AudioSourceComponent
{
	public static class AudioSourceManager
	{
		[CompilerGenerated]
		private sealed class <FadeVolume>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AudioSource audioSource;

			public float? targetVolume;

			public float? multiplier;

			public float duration;

			private float <startVolume>5__2;

			private float <endVolume>5__3;

			private float <timeStep>5__4;

			private float <time>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FadeVolume>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)audioSource == (Object)null)
					{
						return false;
					}
					<startVolume>5__2 = audioSource.volume;
					if (targetVolume.HasValue)
					{
						<endVolume>5__3 = Mathf.Clamp01(targetVolume.Value);
					}
					else
					{
						if (!multiplier.HasValue)
						{
							return false;
						}
						<endVolume>5__3 = Mathf.Clamp01(<startVolume>5__2 * multiplier.Value);
					}
					<timeStep>5__4 = duration / 5f;
					<time>5__5 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__5 < duration)
				{
					audioSource.volume = Mathf.Lerp(<startVolume>5__2, <endVolume>5__3, <time>5__5 / duration);
					<time>5__5 += <timeStep>5__4;
					<>2__current = (object)new WaitForSeconds(<timeStep>5__4);
					<>1__state = 1;
					return true;
				}
				audioSource.volume = <endVolume>5__3;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static AudioSource AddLowPassFilter(AudioSource audioSource)
		{
			if ((Object)(object)audioSource == (Object)null)
			{
				return null;
			}
			AudioLowPassFilter obj = ((Component)audioSource).gameObject.GetComponent<AudioLowPassFilter>() ?? ((Component)audioSource).gameObject.AddComponent<AudioLowPassFilter>();
			obj.cutoffFrequency = 1000f;
			obj.lowpassResonanceQ = 1f;
			return audioSource;
		}

		public static AudioSource RemoveLowPassFilter(AudioSource audioSource)
		{
			if ((Object)(object)audioSource == (Object)null)
			{
				return null;
			}
			AudioLowPassFilter component = ((Component)audioSource).GetComponent<AudioLowPassFilter>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			return audioSource;
		}

		[IteratorStateMachine(typeof(<FadeVolume>d__2))]
		public static IEnumerator FadeVolume(AudioSource audioSource, float duration, float? targetVolume = null, float? multiplier = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeVolume>d__2(0)
			{
				audioSource = audioSource,
				duration = duration,
				targetVolume = targetVolume,
				multiplier = multiplier
			};
		}

		public static void StopAllAudioSource()
		{
			SoloAudioSource.Instance.StopAudioSource();
		}
	}
	public sealed class SoloAudioSource : MonoBehaviour
	{
		private AudioSource _audioSource;

		private static SoloAudioSource _instance;

		public static SoloAudioSource Instance
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("GreyAnnouncer_SoloAudioSource");
					val.transform.SetParent(((Component)MonoSingleton<CameraController>.Instance).transform);
					val.transform.localPosition = Vector3.zero;
					_instance = val.AddComponent<SoloAudioSource>();
				}
				return _instance;
			}
		}

		public void Play(Sound sound)
		{
			if (TryFindAudioSource())
			{
				_audioSource.Stop();
				ConfigureAndPlayAudioSource(sound, _audioSource);
			}
		}

		public void PlayOneShot(Sound sound)
		{
			if (TryFindAudioSource())
			{
				ConfigureAndPlayAudioSource(sound, _audioSource);
			}
		}

		private void ConfigureAndPlayAudioSource(Sound sound, AudioSource audioSource)
		{
			AudioSourceExtensions.SetSpatialBlend(audioSource, Mathf.Clamp01(Setting.spatialBlend));
			audioSource.priority = sound.priority;
			audioSource.clip = sound.clip;
			audioSource = UnderwaterController_inWater_Instance.GetAudioSourceWithLowPassFilter(_audioSource);
			audioSource.volume = Setting.audioSourceVolume;
			AudioSourceExtensions.PlayOneShot(audioSource, sound.clip, sound.volume, true);
		}

		public void AddAudioLowPassFilter()
		{
			_audioSource = AudioSourceManager.AddLowPassFilter(_audioSource);
		}

		public void RemoveAudioLowPassFilter()
		{
			_audioSource = AudioSourceManager.RemoveLowPassFilter(_audioSource);
		}

		public void UpdateSoloAudioSourceVolume(float targetVolume, float duration = 0.35f)
		{
			if ((Object)(object)_audioSource != (Object)null)
			{
				((MonoBehaviour)this).StartCoroutine(AudioSourceManager.FadeVolume(_audioSource, duration, targetVolume));
			}
		}

		public void StopAudioSource()
		{
			_audioSource.Stop();
			Object.Destroy((Object)(object)_audioSource.clip);
		}

		private bool TryFindAudioSource()
		{
			if ((Object)(object)_audioSource == (Object)null)
			{
				_audioSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			}
			return (Object)(object)_audioSource != (Object)null;
		}
	}
	public class Sound
	{
		public string category;

		public AudioClip clip;

		[Range(0f, 1f)]
		public float volume = 1f;

		public bool loop;

		public int priority;

		public AudioMixerGroup AudioMixerGroup;

		public Sound(string category, AudioClip clip, float volume)
		{
			this.category = category;
			this.clip = clip;
			this.volume = volume;
		}
	}
	public static class SoundDispatcher
	{
		public static void SendClipToAudioSource(Sound sound)
		{
			switch (Setting.audioPlayOptions)
			{
			case 0:
				SoloAudioSource.Instance.Play(sound);
				break;
			case 1:
				SoloAudioSource.Instance.PlayOneShot(sound);
				break;
			default:
				SoloAudioSource.Instance.Play(sound);
				break;
			}
		}
	}
	[Description("Because it's..... related so I just put it at here instead of creating a new object file")]
	public static class UnderwaterController_inWater_Instance
	{
		public static bool isInWater => MonoSingleton<UnderwaterController>.Instance?.inWater ?? false;

		public static void CheckIsInWater()
		{
			if (!isInWater || !Setting.isLowPassFilterEnabled)
			{
				RemoveAudioLowPassFilterFromAllAudioSource();
			}
			else if (isInWater)
			{
				AddAudioLowPassFilterToAllAudioSource();
			}
		}

		public static AudioSource GetAudioSourceWithLowPassFilter(AudioSource audioSource)
		{
			if ((Object)(object)audioSource == (Object)null)
			{
				return null;
			}
			audioSource = ((!isInWater || !Setting.isLowPassFilterEnabled) ? AudioSourceManager.RemoveLowPassFilter(audioSource) : AudioSourceManager.AddLowPassFilter(audioSource));
			return audioSource;
		}

		private static void RemoveAudioLowPassFilterFromAllAudioSource()
		{
			SoloAudioSource.Instance.RemoveAudioLowPassFilter();
		}

		private static void AddAudioLowPassFilterToAllAudioSource()
		{
			SoloAudioSource.Instance.AddAudioLowPassFilter();
		}
	}
	[Description("Q : Why? A : Prevent when audio is playing and enter/out of the water")]
	[HarmonyPatch(typeof(UnderwaterController))]
	public class UnderwaterPatcher
	{
		[HarmonyPostfix]
		[HarmonyPatch("EnterWater")]
		public static void EnterWater()
		{
			UnderwaterController_inWater_Instance.CheckIsInWater();
		}

		[HarmonyPostfix]
		[HarmonyPatch("OutWater")]
		public static void OutWater()
		{
			UnderwaterController_inWater_Instance.CheckIsInWater();
		}
	}
}
namespace GreyAnnouncer.AudioLoading
{
	public static class AudioClipLoader
	{
		public static async Task<AudioClip> LoadAudioClipAsync(string path)
		{
			string text = Path.GetExtension(path).ToLower();
			AudioType unityAudioType = GetUnityAudioType(text);
			AudioClip result = null;
			try
			{
				if ((int)unityAudioType != 0)
				{
					result = await UnitySupport.LoadWithUnityAsync(path, unityAudioType);
				}
				else if (Setting.isFFmpegSupportEnabled)
				{
					result = await FFmpegSupport.DecodeAndLoadViaFFmpeg(path);
				}
				else
				{
					LogHelper.LogError("Unsupported audio format: 「" + text + "」 for " + path, "LoadAudioClipAsync");
				}
				return result;
			}
			catch (Exception ex)
			{
				LogHelper.LogError("Error while loading " + path + ": " + ex.Message + "\n" + ex.StackTrace, "LoadAudioClipAsync");
				return null;
			}
		}

		[Description("https://docs.unity3d.com/2022.3/Documentation//ScriptReference/AudioType.html")]
		private static AudioType GetUnityAudioType(string extension)
		{
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			return (AudioType)(extension switch
			{
				".aac" => 1, 
				".aiff" => 2, 
				".aif" => 2, 
				".aifc" => 2, 
				".it" => 10, 
				".mod" => 12, 
				".mp3" => 13, 
				".mpga" => 13, 
				".mpeg" => 13, 
				".ogg" => 14, 
				".s3m" => 17, 
				".wav" => 20, 
				".xm" => 21, 
				".xma" => 22, 
				".vag" => 23, 
				_ => 0, 
			});
		}
	}
	public static class FFmpegSupport
	{
		static FFmpegSupport()
		{
			ffmpeg.RootPath = ProcessHelper.FindExecutable("ffmpeg");
			if (ffmpeg.RootPath == null)
			{
				LogHelper.LogWarning("ffmpeg not found. Audio decoding via FFmpeg will fail.", ".cctor");
			}
		}

		public unsafe static Task<AudioClip> DecodeAndLoadViaFFmpeg(string filePath)
		{
			return Task.Run(delegate
			{
				AVFormatContext* formatContext = null;
				AVCodecContext* ptr = null;
				SwrContext* swrCtx = null;
				AVPacket* packet = null;
				AVFrame* frame = null;
				LogHelper.LogDebug("ffmpeg path: " + ffmpeg.RootPath, "DecodeAndLoadViaFFmpeg");
				LogHelper.LogDebug("ffmpeg version: " + ffmpeg.av_version_info(), "DecodeAndLoadViaFFmpeg");
				ffmpeg.avformat_network_init();
				try
				{
					formatContext = InitializeFormatContext(filePath);
					int audioStreamIndex = FindAudioStreamIndex(formatContext);
					ptr = InitializeCodecContext(formatContext, audioStreamIndex);
					swrCtx = InitializeResampler(ptr);
					packet = ffmpeg.av_packet_alloc();
					frame = ffmpeg.av_frame_alloc();
					float[] allSamples = DecodeAudioFrames(formatContext, ptr, swrCtx, packet, frame, audioStreamIndex).GetAllSamples();
					int nb_channels = ((AVChannelLayout)(&((AVCodecContext)ptr).ch_layout)).nb_channels;
					int sample_rate = ((AVCodecContext)ptr).sample_rate;
					int num = allSamples.Length / nb_channels;
					AudioClip obj = AudioClip.Create("decoded_clip", num, nb_channels, sample_rate, false);
					obj.SetData(allSamples, 0);
					return obj;
				}
				finally
				{
					CleanupResources(frame, packet, ptr, swrCtx, formatContext);
				}
			});
		}

		private unsafe static AVFormatContext* InitializeFormatContext(string filePath)
		{
			AVFormatContext* ptr = ffmpeg.avformat_alloc_context();
			if (ffmpeg.avformat_open_input(&ptr, filePath, (AVInputFormat*)null, (AVDictionary**)null) != 0)
			{
				throw new Exception("Could not open input file.");
			}
			if (ffmpeg.avformat_find_stream_info(ptr, (AVDictionary**)null) != 0)
			{
				throw new Exception("Could not find stream info.");
			}
			return ptr;
		}

		private unsafe static int FindAudioStreamIndex(AVFormatContext* formatContext)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			for (int i = 0; i < ((AVFormatContext)formatContext).nb_streams; i++)
			{
				if ((int)((AVCodecParameters)((AVStream)((AVFormatContext)formatContext).streams[i]).codecpar).codec_type == 1)
				{
					return i;
				}
			}
			throw new Exception("No audio stream found.");
		}

		private unsafe static AVCodecContext* InitializeCodecContext(AVFormatContext* formatContext, int audioStreamIndex)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			AVCodecParameters* codecpar = ((AVStream)((AVFormatContext)formatContext).streams[audioStreamIndex]).codecpar;
			AVCodec* ptr = ffmpeg.avcodec_find_decoder(((AVCodecParameters)codecpar).codec_id);
			if (ptr == null)
			{
				throw new Exception("Unsupported codec");
			}
			AVCodecContext* ptr2 = ffmpeg.avcodec_alloc_context3(ptr);
			ffmpeg.avcodec_parameters_to_context(ptr2, codecpar);
			if (ffmpeg.avcodec_open2(ptr2, ptr, (AVDictionary**)null) < 0)
			{
				ffmpeg.avcodec_free_context(&ptr2);
				throw new Exception("Could not open codec");
			}
			return ptr2;
		}

		private unsafe static SwrContext* InitializeResampler(AVCodecContext* codecCtx)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			int nb_channels = ((AVChannelLayout)(&((AVCodecContext)codecCtx).ch_layout)).nb_channels;
			AVChannelLayout ch_layout = ((AVCodecContext)codecCtx).ch_layout;
			AVChannelLayout val = default(AVChannelLayout);
			ffmpeg.av_channel_layout_default(&val, nb_channels);
			SwrContext* intPtr = ffmpeg.swr_alloc();
			ffmpeg.av_opt_set_chlayout((void*)intPtr, "in_chlayout", &ch_layout, 0);
			ffmpeg.av_opt_set_chlayout((void*)intPtr, "out_chlayout", &val, 0);
			ffmpeg.av_opt_set_int((void*)intPtr, "in_sample_rate", (long)((AVCodecContext)codecCtx).sample_rate, 0);
			ffmpeg.av_opt_set_int((void*)intPtr, "out_sample_rate", (long)((AVCodecContext)codecCtx).sample_rate, 0);
			ffmpeg.av_opt_set_sample_fmt((void*)intPtr, "in_sample_fmt", ((AVCodecContext)codecCtx).sample_fmt, 0);
			ffmpeg.av_opt_set_sample_fmt((void*)intPtr, "out_sample_fmt", (AVSampleFormat)3, 0);
			ffmpeg.swr_init(intPtr);
			return intPtr;
		}

		private unsafe static StreamedAudioData DecodeAudioFrames(AVFormatContext* formatContext, AVCodecContext* codecCtx, SwrContext* swrCtx, AVPacket* packet, AVFrame* frame, int audioStreamIndex)
		{
			StreamedAudioData streamedAudioData = new StreamedAudioData
			{
				Channels = ((AVChannelLayout)(&((AVCodecContext)codecCtx).ch_layout)).nb_channels,
				SampleRate = ((AVCodecContext)codecCtx).sample_rate
			};
			while (ffmpeg.av_read_frame(formatContext, packet) >= 0)
			{
				if (((AVPacket)packet).stream_index != audioStreamIndex)
				{
					ffmpeg.av_packet_unref(packet);
					continue;
				}
				ProcessAudioFrame(codecCtx, swrCtx, packet, frame, streamedAudioData);
				ffmpeg.av_packet_unref(packet);
			}
			return streamedAudioData;
		}

		private unsafe static void ProcessAudioFrame(AVCodecContext* codecCtx, SwrContext* swrCtx, AVPacket* packet, AVFrame* frame, StreamedAudioData streamedData)
		{
			byte** ptr = stackalloc byte*[1];
			int num = ffmpeg.avcodec_send_packet(codecCtx, packet);
			if (num < 0 && num != ffmpeg.AVERROR<int>(ffmpeg.EAGAIN))
			{
				throw new Exception($"avcodec_send_packet failed: {num}");
			}
			int num2 = default(int);
			while (ffmpeg.avcodec_receive_frame(codecCtx, frame) == 0)
			{
				ffmpeg.av_samples_alloc_array_and_samples(&ptr, &num2, ((AVChannelLayout)(&((AVCodecContext)codecCtx).ch_layout)).nb_channels, ((AVFrame)frame).nb_samples, (AVSampleFormat)3, 0);
				int num3 = ffmpeg.swr_convert(swrCtx, ptr, ((AVFrame)frame).nb_samples, ((AVFrame)frame).extended_data, ((AVFrame)frame).nb_samples);
				float[] array = new float[ffmpeg.av_samples_get_buffer_size((int*)null, ((AVChannelLayout)(&((AVCodecContext)codecCtx).ch_layout)).nb_channels, num3, (AVSampleFormat)3, 1) / 4];
				Marshal.Copy((IntPtr)(*ptr), array, 0, array.Length);
				streamedData.AddSamples(array);
				ffmpeg.av_freep((void*)ptr);
			}
		}

		private unsafe static void CleanupResources(AVFrame* frame, AVPacket* packet, AVCodecContext* codecCtx, SwrContext* swrCtx, AVFormatContext* formatContext)
		{
			if (frame != null)
			{
				ffmpeg.av_frame_free(&frame);
			}
			if (packet != null)
			{
				ffmpeg.av_packet_free(&packet);
			}
			if (codecCtx != null)
			{
				ffmpeg.avcodec_free_context(&codecCtx);
			}
			if (swrCtx != null)
			{
				ffmpeg.swr_close(swrCtx);
				ffmpeg.swr_free(&swrCtx);
			}
			if (formatContext != null)
			{
				ffmpeg.avformat_close_input(&formatContext);
				ffmpeg.avformat_free_context(formatContext);
			}
			ffmpeg.avformat_network_deinit();
		}
	}
	public static class UnitySupport
	{
		public static async Task<AudioClip> LoadWithUnityAsync(string path, AudioType audioType)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			string absoluteUri = new Uri(path).AbsoluteUri;
			UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(absoluteUri, audioType);
			try
			{
				UnityWebRequestAsyncOperation operation = www.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Delay(10);
				}
				if ((int)www.result != 1)
				{
					LogHelper.LogError("UnityRequest Failed to load audio: " + www.error, "LoadWithUnityAsync");
					return null;
				}
				return DownloadHandlerAudioClip.GetContent(www);
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}
	}
}
namespace GreyAnnouncer.RankAnnouncer
{
	[EntryPoint]
	public static class RankAnnouncer
	{
		private static readonly List<string> category = new List<string> { "Destruction", "Chaotic", "Brutal", "Anarchic", "Supreme", "SSadistic", "SSShitstorm", "ULTRAKILL" };

		private static AudioAnnouncer _announcer;

		public static readonly string title = "RankAnnouncer";

		[EntryPoint]
		public static void Initialize()
		{
			_announcer = new AudioAnnouncer(new AudioLoader(), new CooldownManager(category.ToArray()), new JsonConfigManager(), category, title, "greythroat");
		}

		public static void PlayRankSound(int rank)
		{
			_announcer?.PlayAudioViaCategory(category[rank]);
		}
	}
	[PatchOnEntry]
	[HarmonyPatch(typeof(StyleHUD))]
	public static class StyleHUDPatcher
	{
		[HarmonyPostfix]
		[HarmonyPatch("AscendRank")]
		public static void GetNonDrankAscend(StyleHUD __instance)
		{
			int rankIndex = __instance.rankIndex;
			if (rankIndex >= 0 && rankIndex <= 7)
			{
				RankAnnouncer.PlayRankSound(rankIndex);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("ComboStart")]
		public static void GetDrank(StyleHUD __instance)
		{
			if (__instance.rankIndex == 0)
			{
				RankAnnouncer.PlayRankSound(0);
			}
		}
	}
}
namespace GreyAnnouncer.FinalRankAnnouncer
{
	[HarmonyPatch(typeof(FinalRank))]
	public static class FinalRankPatcher
	{
		[HarmonyPrefix]
		[HarmonyPatch("FlashPanel")]
		public static void FlashPanelPatch(ref GameObject panel, FinalRank __instance)
		{
			if (!((Object)(object)panel != (Object)(object)((Component)__instance.toAppear[__instance.i].transform.parent.GetChild(1)).gameObject))
			{
				LogHelper.LogDebug($"FinalRank.i(index) : {__instance.i}", "FlashPanelPatch");
				_ = __instance.i;
				_ = 1;
				_ = 2;
				_ = 3;
			}
		}
	}
	[EntryPoint]
	public static class FinalRankAnnouncer
	{
		private static readonly List<string> category = new List<string> { "D", "C", "B", "A", "S", "P" };

		private static AudioAnnouncer _announcer;

		[EntryPoint]
		public static void Initialize()
		{
		}

		public static void PlayRankSound(int rank)
		{
			_announcer?.PlayAudioViaCategory(category[rank]);
		}
	}
}
namespace GreyAnnouncer.AnnouncerCore
{
	public class PackConfig : NotifyBase
	{
		private bool _randomizeAudioOnPlay;

		public bool RandomizeAudioOnPlay
		{
			get
			{
				return _randomizeAudioOnPlay;
			}
			set
			{
				SetField(ref _randomizeAudioOnPlay, value, "RandomizeAudioOnPlay");
			}
		}

		public ObservableDictionary<string, CategorySetting> CategorySetting { get; } = new ObservableDictionary<string, CategorySetting>();


		public PackConfig()
		{
			CategorySetting.CollectionChanged += delegate
			{
				RaiseChanged("CategorySetting");
			};
			CategorySetting.PropertyChanged += delegate
			{
				RaiseChanged("CategorySetting");
			};
		}

		public void AddCategory(string key, CategorySetting setting)
		{
			CategorySetting[key] = setting;
		}

		public PackConfig SetCategorySettingMap(Dictionary<string, CategorySetting> map)
		{
			CategorySetting.Clear();
			foreach (KeyValuePair<string, CategorySetting> item in map)
			{
				AddCategory(item.Key, item.Value);
			}
			return this;
		}

		public void ApplyFrom(PackConfig src)
		{
			BeginUpdate();
			if (src == null)
			{
				EndUpdate();
				return;
			}
			RandomizeAudioOnPlay = src.RandomizeAudioOnPlay;
			foreach (KeyValuePair<string, CategorySetting> item in src.CategorySetting)
			{
				string key = item.Key;
				CategorySetting value = item.Value;
				if (!CategorySetting.TryGetValue(key, out var value2))
				{
					value2 = new CategorySetting();
					CategorySetting[key] = value2;
				}
				value2.ApplyFrom(value);
			}
			foreach (string item2 in CategorySetting.Keys.Where((string k) => !src.CategorySetting.ContainsKey(k)).ToList())
			{
				CategorySetting.Remove(item2);
			}
			EndUpdate();
		}
	}
	public class CategorySetting : NotifyBase
	{
		private bool _enabled = true;

		private bool _excludeFromRandom;

		private float _volumeMultiplier = 1f;

		private float _cooldown = 1.5f;

		private List<string> _audioFiles = new List<string>();

		public bool Enabled
		{
			get
			{
				return _enabled;
			}
			set
			{
				SetField(ref _enabled, value, "Enabled");
			}
		}

		public bool ExcludeFromRandom
		{
			get
			{
				return _excludeFromRandom;
			}
			set
			{
				SetField(ref _excludeFromRandom, value, "ExcludeFromRandom");
			}
		}

		public float VolumeMultiplier
		{
			get
			{
				return _volumeMultiplier;
			}
			set
			{
				SetField(ref _volumeMultiplier, value, "VolumeMultiplier");
			}
		}

		public float Cooldown
		{
			get
			{
				return _cooldown;
			}
			set
			{
				SetField(ref _cooldown, value, "Cooldown");
			}
		}

		public List<string> AudioFiles
		{
			get
			{
				return _audioFiles;
			}
			set
			{
				_audioFiles = value ?? new List<string>();
			}
		}

		public void ApplyFrom(CategorySetting src)
		{
			if (src != null)
			{
				Enabled = src.Enabled;
				VolumeMultiplier = src.VolumeMultiplier;
				Cooldown = src.Cooldown;
				AudioFiles.Clear();
				AudioFiles.AddRange(src.AudioFiles);
			}
		}
	}
	public static class AnnouncerManager
	{
		public static List<IAnnouncer> announcers = new List<IAnnouncer>();

		public static Action reloadAnnouncer;

		public static Action resetCooldown;

		public static Action clearAudioClipCache;

		public static long playRequestId = 0L;

		public static event Action<IAnnouncer> OnRegistered;

		public static List<IAnnouncer> GetAllAnnouncers()
		{
			return announcers;
		}

		public static void AddAnnouncer(IAnnouncer announcer)
		{
			announcers.Add(announcer);
			AnnouncerManager.OnRegistered?.Invoke(announcer);
		}

		public static void ReloadAllAnnouncers()
		{
			reloadAnnouncer?.Invoke();
		}

		public static void ResetCooldown()
		{
			resetCooldown?.Invoke();
		}

		public static void ClearAudioClipsCache()
		{
			clearAudioClipCache?.Invoke();
		}
	}
	public class AudioAnnouncer : IAnnouncer
	{
		private IAudioLoader _audioLoader;

		private ICooldownManager _cooldownManager;

		private IConfigManager _configManager;

		private List<string> category;

		private string _defaultAnnouncerConfigPath;

		[CompilerGenerated]
		private string <announcerPath>k__BackingField;

		[CompilerGenerated]
		private PackConfig <announcerConfig>k__BackingField;

		private bool _initialized;

		public string title { get; private set; }

		public Action syncUI { get; set; }

		public string announcerPath
		{
			get
			{
				return <announcerPath>k__BackingField;
			}
			set
			{
				LogHelper.LogDebug("announcerPath seted", "announcerPath");
				<announcerPath>k__BackingField = value;
				SaveSelectedPack(value);
				ReloadPack();
			}
		}

		public PackConfig announcerConfig
		{
			get
			{
				return <announcerConfig>k__BackingField;
			}
			set
			{
				LogHelper.LogDebug("setter trigged", "announcerConfig");
				if (<announcerConfig>k__BackingField != value)
				{
					if (<announcerConfig>k__BackingField != null)
					{
						<announcerConfig>k__BackingField.PropertyChanged -= OnAnnouncerConfigChanged;
					}
					<announcerConfig>k__BackingField = value;
					if (<announcerConfig>k__BackingField != null)
					{
						<announcerConfig>k__BackingField.PropertyChanged += OnAnnouncerConfigChanged;
					}
					OnAnnouncerConfigSwitched();
				}
			}
		}

		public bool isConfigLoaded { get; private set; }

		public string configMismatchInfo { get; private set; }

		private string IndexPath => Path.Combine(Setting.announcersPath, title, "index.json");

		private PackConfig LoadConfig()
		{
			LogHelper.LogDebug("Loading config for " + title + " from: " + announcerPath, "LoadConfig");
			if (!File.Exists(_configManager.ConfigPath(announcerPath)))
			{
				LogHelper.LogDebug("No config found in " + announcerPath, "LoadConfig");
				return null;
			}
			PackConfig packConfig = _configManager.Load(announcerPath);
			if (!IsCategoryMatch(packConfig, category))
			{
				LogHelper.LogError("[" + title + "] AnnouncerConfig category mismatch — " + configMismatchInfo, "LoadConfig");
				isConfigLoaded = false;
				return null;
			}
			isConfigLoaded = true;
			return packConfig;
		}

		private bool IsCategoryMatch(PackConfig config, List<string> expected)
		{
			ICollection<string> keys = config.CategorySetting.Keys;
			List<string> list = expected.Except(keys).ToList();
			List<string> values = keys.Except(expected).ToList();
			if (list.Count == 0)
			{
				return true;
			}
			configMismatchInfo = "Missing: [" + string.Join(", ", list) + "], Extra: [" + string.Join(", ", values) + "]";
			return false;
		}

		private void OnAnnouncerConfigChanged(object sender, PropertyChangedEventArgs e)
		{
			LogHelper.LogDebug("AnnouncerConfig changed: " + e.PropertyName, "OnAnnouncerConfigChanged");
			SaveConfig();
		}

		private void OnAnnouncerConfigSwitched()
		{
			LogHelper.LogDebug("AnnouncerConfig Switched", "OnAnnouncerConfigSwitched");
			if (announcerConfig != null && isConfigLoaded)
			{
				_audioLoader.FindAvailableAudioAsync();
				SaveConfig();
			}
		}

		private void SaveConfig()
		{
			_configManager.Save(announcerPath, announcerConfig);
			if (_initialized)
			{
				syncUI();
			}
		}

		public AudioAnnouncer(IAudioLoader audioLoader, ICooldownManager cooldownManager, IConfigManager configManager, List<string> category, string title, string defaultAnnouoncerConfigPath)
		{
			_audioLoader = audioLoader;
			_audioLoader.SetProvider(this);
			_cooldownManager = cooldownManager;
			_configManager = configManager;
			_defaultAnnouncerConfigPath = defaultAnnouoncerConfigPath;
			this.category = category;
			this.title = title;
			announcerPath = LoadSelectedPack();
			SubscribeAnnouncerManager();
			_initialized = true;
		}

		public async Task PlayAudioViaCategory(string category)
		{
			LogHelper.LogInfo("Request to play audio for category: " + category, "PlayAudioViaCategory");
			try
			{
				if (ValidatePlayCondition(category))
				{
					await PlayAudioClip(category);
				}
			}
			catch (Exception ex)
			{
				LogPlaybackError(ex);
			}
		}

		public void ReloadPack()
		{
			announcerConfig = LoadConfig();
		}

		public void ResetCooldown()
		{
			_cooldownManager.ResetCooldowns();
		}

		public void ClearAudioClipsCache()
		{
			_audioLoader.ClearCache();
		}

		private void SetCooldown(string category, float cooldown)
		{
			_cooldownManager.StartCooldowns(category, cooldown);
		}

		private bool ValidatePlayCondition(string category)
		{
			ValidationState playValidationState = GetPlayValidationState(category);
			if (playValidationState != 0)
			{
				LogHelper.LogDebug($"PlayValidationState: {category}, {playValidationState}", "ValidatePlayCondition");
				return false;
			}
			return true;
		}

		private async Task PlayAudioClip(string category)
		{
			LogHelper.LogDebug("Attempting to play audio for category: " + category, "PlayAudioClip");
			Sound sound;
			if (announcerConfig.RandomizeAudioOnPlay)
			{
				List<string> categories = this.category.Where((string c) => !announcerConfig.CategorySetting[c].ExcludeFromRandom).ToList();
				sound = await _audioLoader.GetRandomAudioClipInCategory(categories);
			}
			else
			{
				sound = await _audioLoader.GetAudioClipInCategory(category);
			}
			if (sound == null)
			{
				LogHelper.LogWarning("Failed to load audio clip may for this category: " + category + ", if you are using Load_Then_Play then it's normal", "PlayAudioClip");
				return;
			}
			if (_cooldownManager.IsIndividualCooldownActive(sound.category))
			{
				LogHelper.LogDebug("The sound's category " + sound.category + " is still in cooldown", "PlayAudioClip");
				return;
			}
			LogHelper.LogDebug($"category : {sound.category}, Cooldown : {announcerConfig.CategorySetting[sound.category].Cooldown}", "PlayAudioClip");
			SoundDispatcher.SendClipToAudioSource(sound);
			SetCooldown(sound.category, announcerConfig.CategorySetting[sound.category].Cooldown);
		}

		private ValidationState GetPlayValidationState(string category)
		{
			if (_cooldownManager == null || _audioLoader == null)
			{
				return ValidationState.ComponentsNotInitialized;
			}
			if (announcerConfig == null)
			{
				return ValidationState.ConfigNotLoaded;
			}
			if (!announcerConfig.CategorySetting.ContainsKey(category))
			{
				return ValidationState.InvalidKey;
			}
			if (!announcerConfig.CategorySetting[category].Enabled)
			{
				return ValidationState.DisabledByConfig;
			}
			if (_cooldownManager.IsIndividualCooldownActive(category))
			{
				return ValidationState.IndividualCooldown;
			}
			return ValidationState.Success;
		}

		private void SubscribeAnnouncerManager()
		{
			AnnouncerManager.reloadAnnouncer = (Action)Delegate.Combine(AnnouncerManager.reloadAnnouncer, new Action(ReloadPack));
			AnnouncerManager.resetCooldown = (Action)Delegate.Combine(AnnouncerManager.resetCooldown, new Action(ResetCooldown));
			AnnouncerManager.clearAudioClipCache = (Action)Delegate.Combine(AnnouncerManager.clearAudioClipCache, new Action(ClearAudioClipsCache));
			AnnouncerManager.AddAnnouncer(this);
		}

		public void EditExternally()
		{
			ProcessHelper.OpenDirectory(announcerPath);
		}

		private void LogPlaybackError(Exception ex)
		{
			LogHelper.LogError("An error occurred while playing sound: " + ex.Message + "\n" + ex.StackTrace, "LogPlaybackError");
		}

		private string LoadSelectedPack()
		{
			string text = JsonManager.ReadJson<string>(IndexPath);
			if (text == null)
			{
				text = _defaultAnnouncerConfigPath;
				JsonManager.WriteJson(IndexPath, text);
			}
			return Path.Combine(Setting.announcersPath, title, text);
		}

		private void SaveSelectedPack(string fullPath)
		{
			JsonManager.WriteJson(IndexPath, Path.GetFileName(fullPath));
		}

		public static List<string> GetAvailablePacks(string title)
		{
			string path = Path.Combine(Setting.announcersPath, title);
			Directory.CreateDirectory(path);
			return Directory.GetDirectories(path).Select(Path.GetFileName).ToList();
		}
	}
	public class AudioLoader : IAudioLoader
	{
		private IAnnouncer _announcer;

		public static Action<string> onPluginConfiguratorLogUpdated;

		private readonly HashSet<string> _categoryFailed = new HashSet<string>();

		private readonly Dictionary<string, List<AudioClip>> _audioClips = new Dictionary<string, List<AudioClip>>();

		public PackConfig announcerConfig => _announcer?.announcerConfig;

		public string announcerPath => _announcer?.announcerPath;

		[Description("Q : Why do you using whole AnnouncerJsonSetting as input instead only CategoryAudioMap?A : For future, what kinds of future? idk.")]
		public AudioLoader()
		{
		}

		public async Task<Sound> GetAudioClipInCategory(string category)
		{
			(string, AudioClip)? tuple = await ResolveClip(() => LoadAndGetSingleAudioClip(category), () => GetClipFromCache(category));
			if (!tuple.HasValue || (Object)(object)tuple.Value.Item2 == (Object)null)
			{
				LogHelper.LogWarning($"No audio clip available for category 「{category}」, strategy: {Setting.audioLoadingStrategy}", "GetAudioClipInCategory");
				return null;
			}
			return new Sound(tuple.Value.Item1, tuple.Value.Item2, announcerConfig.CategorySetting[tuple.Value.Item1].VolumeMultiplier);
		}

		public async Task<Sound> GetRandomAudioClipInCategory(List<string> categories)
		{
			(string, AudioClip)? tuple = await ResolveClip(() => GetRandomClipFromAllAvailableFiles(categories), () => GetRandomClipFromAudioClips(categories));
			if (!tuple.HasValue || (Object)(object)tuple.Value.Item2 == (Object)null)
			{
				LogHelper.LogWarning(string.Format("No audio clip available for category 「{0}」, strategy: {1}", string.Join(", ", categories), Setting.audioLoadingStrategy), "GetRandomAudioClipInCategory");
				return null;
			}
			return new Sound(tuple.Value.Item1, tuple.Value.Item2, announcerConfig.CategorySetting[tuple.Value.Item1].VolumeMultiplier);
		}

		private async Task<(string, AudioClip)?> ResolveClip(Func<Task<(string, AudioClip)>> onDemandLoader, Func<(string, AudioClip)> cachedLoader)
		{
			if (Setting.audioLoadingStrategy == 0)
			{
				long currentRequestId = ++AnnouncerManager.playRequestId;
				(string, AudioClip) value = await onDemandLoader();
				if (currentRequestId != AnnouncerManager.playRequestId && Setting.audioPlayOptions == 0)
				{
					return null;
				}
				return value;
			}
			return cachedLoader();
		}

		public void SetProvider(IAnnouncer provider)
		{
			_announcer = provider;
		}

		public async Task FindAvailableAudioAsync()
		{
			ClearCache();
			if (Setting.audioLoadingStrategy != 0)
			{
				LogHelper.LogInfo("Starting to find available audio", "FindAvailableAudioAsync");
				await LoadAllCategoriesAsync();
				LogLoadingResults();
			}
		}

		public void ClearCache()
		{
			ClearAudioClipCache();
			_categoryFailed.Clear();
		}

		private bool TryResolveAudioFiles(string category, out List<string> validFiles)
		{
			validFiles = null;
			if (!announcerConfig.CategorySetting.TryGetValue(category, out var value))
			{
				return false;
			}
			if (value.AudioFiles == null || value.AudioFiles.Count == 0)
			{
				return false;
			}
			validFiles = value.AudioFiles.Select((string name) => PathHelper.GetFile(announcerPath, name)).Where(File.Exists).ToList();
			if (validFiles.Count == 0)
			{
				return false;
			}
			List<string> list = value.AudioFiles.Except<string>(validFiles.Select(Path.GetFileName)).ToList();
			if (list.Count > 0)
			{
				LogHelper.LogWarning("「" + category + "」 missing files: " + string.Join(", ", list), "TryResolveAudioFiles");
			}
			return true;
		}

		public async Task<(string category, AudioClip clip)> LoadAndGetSingleAudioClip(string category)
		{
			if (!announcerConfig.CategorySetting.TryGetValue(category, out var _))
			{
				LogHelper.LogError("Category 「" + category + "」 not found in config", "LoadAndGetSingleAudioClip");
				return (null, null);
			}
			if (!TryResolveAudioFiles(category, out var validFiles))
			{
				return (null, null);
			}
			AudioClip val = await AudioClipLoader.LoadAudioClipAsync(validFiles[Random.Range(0, validFiles.Count)]);
			if ((Object)(object)val == (Object)null)
			{
				LogHelper.LogError("Selected file failed to load for category 「" + category + "」", "LoadAndGetSingleAudioClip");
			}
			return (category, val);
		}

		public async Task<(string category, AudioClip clip)> GetRandomClipFromAllAvailableFiles(List<string> categories)
		{
			List<(string, string)> list = new List<(string, string)>();
			foreach (string category in categories)
			{
				if (TryResolveAudioFiles(category, out var validFiles))
				{
					list.AddRange(validFiles.Select((string path) => (category, path)));
				}
			}
			if (list.Count == 0)
			{
				return (null, null);
			}
			(string category, string path) selected = list[Random.Range(0, list.Count)];
			AudioClip val = await AudioClipLoader.LoadAudioClipAsync(selected.path);
			if ((Object)(object)val == (Object)null)
			{
				LogHelper.LogError("Selected file failed to load for category 「" + selected.category + "」", "GetRandomClipFromAllAvailableFiles");
				return (null, null);
			}
			return (selected.category, val);
		}

		public (string category, AudioClip clip) GetClipFromCache(string category)
		{
			if (_categoryFailed.Contains(category))
			{
				LogHelper.LogError("Category 「" + category + "」 previously failed to load", "GetClipFromCache");
				return (null, null);
			}
			if (!announcerConfig.CategorySetting.ContainsKey(category))
			{
				LogHelper.LogError("Category 「" + category + "」 not found in config", "GetClipFromCache");
				return (null, null);
			}
			if (!_audioClips.TryGetValue(category, out var value) || value.Count == 0)
			{
				LogHelper.LogError("No clips in cache for category 「" + category + "」", "GetClipFromCache");
				return (null, null);
			}
			AudioClip item = value[Random.Range(0, value.Count)];
			return (category, item);
		}

		public (string category, AudioClip clip) GetRandomClipFromAudioClips(List<string> categories)
		{
			List<(string, AudioClip)> list = _audioClips.Where((KeyValuePair<string, List<AudioClip>> kvp) => categories.Contains(kvp.Key)).SelectMany((KeyValuePair<string, List<AudioClip>> kvp) => from clip in kvp.Value
				where (Object)(object)clip != (Object)null
				select (kvp.Key, clip)).ToList();
			if (list.Count == 0)
			{
				return (null, null);
			}
			var (item, item2) = list[Random.Range(0, list.Count)];
			return (item, item2);
		}

		private async Task LoadAllCategoriesAsync()
		{
			(string, List<AudioClip>)[] array = await Task.WhenAll(announcerConfig.CategorySetting.Keys.Select(WrapWithCategory));
			for (int i = 0; i < array.Length; i++)
			{
				var (key, list) = array[i];
				if (list != null && list.Count > 0)
				{
					_audioClips[key] = list;
				}
			}
			async Task<(string, List<AudioClip>)> WrapWithCategory(string cat)
			{
				return (cat, await LoadCategoryAsync(cat));
			}
		}

		private async Task<List<AudioClip>> LoadCategoryAsync(string category)
		{
			if (!TryResolveAudioFiles(category, out var validFiles))
			{
				_categoryFailed.Add(category);
				return null;
			}
			LogHelper.LogInfo($"Loading category 「{category}」 with {validFiles.Count} files", "LoadCategoryAsync");
			try
			{
				List<AudioClip> list = (await Task.WhenAll(validFiles.Select(AudioClipLoader.LoadAudioClipAsync))).Where((AudioClip c) => (Object)(object)c != (Object)null).ToList();
				if (list.Count > 0)
				{
					LogHelper.LogInfo($"Successfully loaded {list.Count}/{validFiles.Count} clips for 「{category}」", "LoadCategoryAsync");
					return list;
				}
				_categoryFailed.Add(category);
				LogHelper.LogDebug("Failed to load category 「" + category + "」: All audio files failed to load", "LoadCategoryAsync");
				return null;
			}
			catch (Exception ex)
			{
				_categoryFailed.Add(category);
				LogHelper.LogDebug("Failed to load category 「" + category + "」: Exception during loading: " + ex.Message, "LoadCategoryAsync");
				return null;
			}
		}

		private void ClearAudioClipCache()
		{
			foreach (AudioClip item in from c in _audioClips.Values.SelectMany((List<AudioClip> list) => list)
				where (Object)(object)c != (Object)null
				select c)
			{
				Object.Destroy((Object)(object)item);
			}
			_audioClips.Clear();
		}

		private void LogLoadingResults()
		{
			LogHelper.LogDebug(_announcer.title + " Loading directory: " + announcerPath, "LogLoadingResults");
			if (_categoryFailed.Count > 0)
			{
				LogHelper.LogWarning("Failed to load categories: " + string.Join(", ", _categoryFailed), "LogLoadingResults");
			}
			else
			{
				LogHelper.LogInfo("All categories successfully loaded", "LogLoadingResults");
			}
		}
	}
	public class CooldownManager : ICooldownManager
	{
		[CompilerGenerated]
		private sealed class <CooldownCoroutine>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float initialCooldown;

			public Action<float> setCooldown;

			private float <cooldown>5__2;

			private float <deltaTimeTime>5__3;

			private float <timePassed>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <CooldownCoroutine>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if (initialCooldown <= 0f)
					{
						setCooldown(0f);
						return false;
					}
					<cooldown>5__2 = initialCooldown;
					float num = <cooldown>5__2 * 3f / 4f;
					<deltaTimeTime>5__3 = <cooldown>5__2 * 1f / 4f;
					setCooldown(<cooldown>5__2);
					<>2__current = (object)new WaitForSeconds(num);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<timePassed>5__4 = 0f;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (<timePassed>5__4 < <deltaTimeTime>5__3)
				{
					<timePassed>5__4 += Time.deltaTime;
					<cooldown>5__2 -= Time.deltaTime;
					setCooldown(<cooldown>5__2);
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				setCooldown(0f);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Dictionary<string, float> _individualCooldowns = new Dictionary<string, float>();

		public CooldownManager(string[] audioCategories)
		{
			foreach (string key in audioCategories)
			{
				_individualCooldowns[key] = 0f;
			}
		}

		public bool IsIndividualCooldownActive(string category)
		{
			return _individualCooldowns[category] > 0f;
		}

		public void StartCooldowns(string category, float duration)
		{
			StartIndividualCooldown(category, duration);
		}

		public void ResetCooldowns()
		{
			foreach (string item in _individualCooldowns.Keys.ToList())
			{
				_individualCooldowns[item] = 0f;
			}
		}

		private void StartIndividualCooldown(string category, float duration)
		{
			((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(CooldownCoroutine(delegate(float value)
			{
				_individualCooldowns[category] = value;
			}, duration));
		}

		[IteratorStateMachine(typeof(<CooldownCoroutine>d__6))]
		private IEnumerator CooldownCoroutine(Action<float> setCooldown, float initialCooldown)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CooldownCoroutine>d__6(0)
			{
				setCooldown = setCooldown,
				initialCooldown = initialCooldown
			};
		}
	}
	public interface IAnnouncer
	{
		string title { get; }

		string announcerPath { get; set; }

		PackConfig announcerConfig { get; }

		Action syncUI { get; set; }

		bool isConfigLoaded { get; }

		string configMismatchInfo { get; }

		void EditExternally();

		void ReloadPack();
	}
	public interface IAudioLoader
	{
		Task<Sound> GetAudioClipInCategory(string category);

		Task<Sound> GetRandomAudioClipInCategory(List<string> categories);

		Task FindAvailableAudioAsync();

		void ClearCache();

		void SetProvider(IAnnouncer provider);
	}
	public interface IConfigManager
	{
		string ConfigPath(string directory);

		PackConfig Load(string directory);

		void Save(string directory, PackConfig config);
	}
	public interface ICooldownManager
	{
		bool IsIndividualCooldownActive(string category);

		void StartCooldowns(string category, float duration);

		void ResetCooldowns();
	}
	public class JsonConfigManager : IConfigManager
	{
		public string ConfigPath(string directory)
		{
			return Path.Combine(directory, "config.json");
		}

		public PackConfig Load(string directory)
		{
			return JsonManager.ReadJson<PackConfig>(ConfigPath(directory));
		}

		public void Save(string directory, PackConfig config)
		{
			JsonManager.WriteJson(ConfigPath(directory), config);
		}
	}
	public enum ValidationState
	{
		Success,
		IndividualCooldown,
		DisabledByConfig,
		ComponentsNotInitialized,
		InvalidKey,
		ConfigNotLoaded
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}