using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Utilities;
using Vote_Pause.Configuration;
using Vote_Pause.Patches;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Mirror")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.glarmer.Vote_Pause")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+e6be22d40b52164f31d93989474a2d422db9de2e")]
[assembly: AssemblyProduct("com.github.glarmer.Vote_Pause")]
[assembly: AssemblyTitle("Vote Pause")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Vote_Pause
{
	public struct ClientPausedMessage : NetworkMessage
	{
		public bool IsPaused;
	}
	public static class Networker
	{
		public static void RegisterNetwork()
		{
			RegisterSerialisers();
			if (NetworkClient.active)
			{
				RegisterClient();
			}
			if (NetworkServer.active)
			{
				RegisterServer();
			}
		}

		private static void RegisterSerialisers()
		{
			Writer<ClientPausedMessage>.write = delegate(NetworkWriter writer, ClientPausedMessage message)
			{
				NetworkWriterExtensions.WriteBool(writer, message.IsPaused);
			};
			Reader<ClientPausedMessage>.read = (NetworkReader reader) => new ClientPausedMessage
			{
				IsPaused = NetworkReaderExtensions.ReadBool(reader)
			};
			Writer<ServerPausedMessage>.write = delegate(NetworkWriter writer, ServerPausedMessage message)
			{
				NetworkWriterExtensions.WriteBool(writer, message.IsPaused);
			};
			Reader<ServerPausedMessage>.read = (NetworkReader reader) => new ServerPausedMessage
			{
				IsPaused = NetworkReaderExtensions.ReadBool(reader)
			};
		}

		private static void RegisterServer()
		{
			PauseManager.Instance.Pauses.Clear();
			NetworkServer.RegisterHandler<ClientPausedMessage>((Action<NetworkConnectionToClient, ClientPausedMessage>)OnClientPauseChanged, true);
			NetworkServer.OnDisconnectedEvent = (Action<NetworkConnectionToClient>)Delegate.Combine(NetworkServer.OnDisconnectedEvent, new Action<NetworkConnectionToClient>(OnClientDisconnected));
		}

		private static void RegisterClient()
		{
			NetworkClient.RegisterHandler<ServerPausedMessage>((Action<ServerPausedMessage>)OnServerPauseChanged, true);
		}

		private static void OnClientPauseChanged(NetworkConnectionToClient sender, ClientPausedMessage message)
		{
			PauseManager.Instance.Pauses[sender.connectionId] = message.IsPaused;
			PauseManager.Instance.DecideAndPause();
		}

		private static void OnServerPauseChanged(ServerPausedMessage message)
		{
			PauseManager.Instance.PauseGame(message.IsPaused);
		}

		private static void OnClientDisconnected(NetworkConnectionToClient conn)
		{
			if (Enumerable.Contains(PauseManager.Instance.Pauses.Keys, conn.connectionId))
			{
				PauseManager.Instance.Pauses.Remove(conn.connectionId);
			}
		}

		public static void SendServerPausedState(bool paused)
		{
			if (NetworkServer.active)
			{
				NetworkServer.SendToAll<ServerPausedMessage>(new ServerPausedMessage
				{
					IsPaused = paused
				}, 0, false);
			}
		}

		public static void SendClientPausedState(bool paused)
		{
			if (NetworkClient.isConnected)
			{
				NetworkClient.Send<ClientPausedMessage>(new ClientPausedMessage
				{
					IsPaused = paused
				}, 0);
			}
		}
	}
	public class PauseManager : MonoBehaviour
	{
		public static PauseManager Instance;

		public readonly Dictionary<int, bool> Pauses = new Dictionary<int, bool>();

		public void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Object.DontDestroyOnLoad((Object)(object)Instance);
			}
			InputManager.Instance.OnPauseMenuOpen += OnPauseMenuOpen;
			InputManager.Instance.OnPauseMenuClose += OnPauseMenuClose;
		}

		private void OnPauseMenuOpen()
		{
			if (NetworkServer.active)
			{
				Plugin.Log.LogInfo((object)"Paused server 1");
			}
			if (NetworkClient.active)
			{
				Plugin.Log.LogInfo((object)"Paused client 1");
				Networker.SendClientPausedState(paused: true);
			}
		}

		private void OnPauseMenuClose()
		{
			if (NetworkServer.active)
			{
				Plugin.Log.LogInfo((object)"Unpaused server 1");
			}
			if (NetworkClient.active)
			{
				Plugin.Log.LogInfo((object)"Unpaused client 1");
				Networker.SendClientPausedState(paused: false);
			}
		}

		public void DecideAndPause()
		{
			Plugin.Log.LogInfo((object)"DecideAndPause");
			float num = NetworkManager.singleton.numPlayers;
			float num2 = 0f;
			float num3 = 0.45f;
			foreach (KeyValuePair<int, bool> pause in Pauses)
			{
				if (pause.Value)
				{
					num2 += 1f;
				}
			}
			Plugin.Log.LogInfo((object)$"Paused players: {num2}/{num}");
			bool flag = num2 / num > num3;
			if (flag)
			{
				Plugin.Log.LogInfo((object)"Paused players is enough to pause!");
			}
			Networker.SendServerPausedState(flag);
		}

		public void PauseGame(bool shouldPause)
		{
			Time.timeScale = ((!shouldPause) ? 1 : 0);
		}

		public void OnDestroy()
		{
			InputManager.Instance.OnPauseMenuOpen -= OnPauseMenuOpen;
			InputManager.Instance.OnPauseMenuClose -= OnPauseMenuClose;
		}
	}
	[BepInPlugin("com.github.glarmer.Vote_Pause", "Vote Pause", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		private Harmony _harmony;

		private ModConfigurationUI _ui;

		public GameObject VoteObject;

		public const string Id = "com.github.glarmer.Vote_Pause";

		internal static ManualLogSource Log { get; private set; }

		public static Plugin Instance { get; private set; }

		public static ConfigurationHandler ConfigurationHandler { get; private set; }

		public static string Name => "Vote Pause";

		public static string Version => "0.1.0";

		private void Awake()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			ConfigurationHandler = new ConfigurationHandler(((BaseUnityPlugin)this).Config);
			GameObject val = new GameObject(Name);
			Object.DontDestroyOnLoad((Object)(object)val);
			_ui = val.AddComponent<ModConfigurationUI>();
			_ui.Init(new List<Option>(2)
			{
				Option.Bool("Enabled", ConfigurationHandler.ConfigEnabled),
				Option.InputAction("Menu Key", ConfigurationHandler.ConfigMenuKey)
			});
			Log.LogInfo((object)"Configuration UI loaded");
			_harmony = new Harmony("com.github.glarmer.Vote_Pause");
			_harmony.PatchAll(typeof(StoneWardsNetworkManagerPatches));
			VoteObject = new GameObject("VoteObject");
			Object.DontDestroyOnLoad((Object)(object)VoteObject);
			Log.LogInfo((object)("Plugin " + Name + " is loaded."));
		}

		private void Update()
		{
			if (ConfigurationHandler.MenuAction.WasPressedThisFrame())
			{
				_ui.ToggleMenu();
			}
			if (Input.GetKeyDown((KeyCode)112))
			{
				Time.timeScale = 0f;
			}
			else if (Input.GetKeyDown((KeyCode)108))
			{
				Time.timeScale = 1f;
			}
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			ConfigurationHandler?.Dispose();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	public struct ServerPausedMessage : NetworkMessage
	{
		public bool IsPaused;
	}
}
namespace Vote_Pause.Patches
{
	public static class StoneWardsNetworkManagerPatches
	{
		[HarmonyPatch(typeof(NetworkHelper), "OnStartClient")]
		[HarmonyPostfix]
		private static void OnStartClientPostfix(NetworkHelper __instance)
		{
			Plugin.Log.LogInfo((object)"Start client postfix");
			Plugin.Instance.VoteObject.AddComponent<PauseManager>();
			Networker.RegisterNetwork();
		}
	}
}
namespace Vote_Pause.Configuration
{
	public sealed class ConfigurationHandler
	{
		private readonly ConfigFile _config;

		public ConfigEntry<string> ConfigMenuKey { get; }

		public ConfigEntry<bool> ConfigEnabled { get; }

		public InputAction MenuAction { get; private set; }

		public bool Enabled => ConfigEnabled.Value;

		public ConfigurationHandler(ConfigFile configFile)
		{
			_config = configFile;
			ConfigMenuKey = _config.Bind<string>("General", "Config Menu Key", "<Keyboard>/f2", "Control path for opening the mod configuration menu (e.g. <Keyboard>/f2, <Keyboard>/space, <Keyboard>/escape)");
			ConfigEnabled = _config.Bind<bool>("General", "Enabled", true, "Whether or not the mod is enabled.");
			SetupInputAction();
			ConfigMenuKey.SettingChanged += OnMenuKeyChanged;
			Plugin.Log.LogInfo((object)"ConfigurationHandler initialised");
		}

		private void OnMenuKeyChanged(object sender, EventArgs e)
		{
			SetupInputAction();
		}

		private void SetupInputAction()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			InputAction menuAction = MenuAction;
			if (menuAction != null)
			{
				menuAction.Dispose();
			}
			MenuAction = new InputAction((string)null, (InputActionType)1, (string)null, (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(MenuAction, ConfigMenuKey.Value, (string)null, (string)null, (string)null);
			MenuAction.Enable();
		}

		public void Dispose()
		{
			ConfigMenuKey.SettingChanged -= OnMenuKeyChanged;
			InputAction menuAction = MenuAction;
			if (menuAction != null)
			{
				menuAction.Dispose();
			}
			_config.Save();
		}
	}
	public class ModConfigurationUI : MonoBehaviour
	{
		private List<Option> _options = new List<Option>();

		public bool _visible;

		private int _selectedIndex;

		private bool _waitingForBinding;

		private Option? _bindingTarget;

		private Texture2D? _whiteTex;

		private GUIStyle _titleStyle;

		private GUIStyle _rowStyle;

		private GUIStyle _hintStyle;

		private GUIStyle _buttonStyle;

		private string titleText = Plugin.Name + " Settings | v" + Plugin.Version;

		private string hintText = "Tab or ↑/↓:  Move • Enter/Click: Change • Scroll Wheel or ←/→ Arrows: Adjust Numerical Values • +/-: Scale Menu";

		private int RowHeight = 32;

		private int PanelWidth = 460;

		private int Pad = 12;

		private int TitleFontSize = 22;

		private int OptionFontSize = 16;

		private int HintFontSize = 14;

		private const int ButtonWidth = 30;

		private const int ButtonHeight = 30;

		private const int ButtonHintSpacing = 4;

		public static ModConfigurationUI? Instance;

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)Instance);
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			StartClosed();
		}

		private void StartClosed()
		{
			_visible = false;
		}

		private void Open()
		{
			_visible = true;
		}

		private void Close()
		{
			_visible = false;
			_waitingForBinding = false;
			_bindingTarget = null;
		}

		public void ToggleMenu()
		{
			_visible = !_visible;
			if (_visible)
			{
				Open();
				if (_options != null && _options.Count > 0 && _options[_selectedIndex].IsDisabled())
				{
					CycleSelection(1);
				}
			}
			else
			{
				Close();
			}
		}

		private void CalculatePanelWidth()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			float num = _titleStyle.CalcSize(new GUIContent(titleText)).x;
			foreach (Option option in _options)
			{
				float x = _rowStyle.CalcSize(new GUIContent(option.Label + ": " + option.DisplayValue())).x;
				if (x > num)
				{
					num = x;
				}
			}
			int num2 = CalculateHintWidth();
			num = Mathf.Max(num, (float)num2);
			PanelWidth = Mathf.Clamp((int)num + Pad * 2, 460, Screen.width - Pad * 2);
		}

		private int CalculateHintWidth()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			float num = _hintStyle.CalcHeight(new GUIContent("Test"), 9999f);
			float num2 = num * 2f;
			for (int i = 200; i < Screen.width - Pad * 2; i += 20)
			{
				float num3 = _hintStyle.CalcHeight(new GUIContent(hintText), (float)i);
				if (num3 <= num2)
				{
					return i;
				}
			}
			return Screen.width - Pad * 2;
		}

		private void Scale(int scale)
		{
			if (scale >= 0 || HintFontSize >= 2)
			{
				TitleFontSize += scale * 2;
				OptionFontSize += scale * 2;
				HintFontSize += scale * 2;
				RowHeight = OptionFontSize + 16;
				CalculatePanelWidth();
			}
		}

		public void Init(List<Option> options)
		{
			_options = options ?? new List<Option>();
			_selectedIndex = 0;
			hintText = Plugin.ConfigurationHandler.ConfigMenuKey.Value.Split("/")[^1].ToUpper() + ": Open/Close • Tab or ↑/↓:  Move • Enter/Click: Change • Scroll Wheel or ←/→ Arrows: Adjust Numerical Values • +/-: Scale Menu";
		}

		private void EnsureStyles()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_0067: Expected O, but got Unknown
			//IL_0072: 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: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00a0: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_whiteTex == (Object)null)
			{
				_whiteTex = new Texture2D(1, 1);
				_whiteTex.SetPixel(0, 0, Color.white);
				_whiteTex.Apply();
			}
			_titleStyle = new GUIStyle(GUI.skin.label)
			{
				fontSize = TitleFontSize,
				alignment = (TextAnchor)3,
				fontStyle = (FontStyle)1
			};
			_rowStyle = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)3,
				fontSize = OptionFontSize,
				padding = new RectOffset(10, 10, 4, 4)
			};
			_hintStyle = new GUIStyle(GUI.skin.label)
			{
				fontSize = HintFontSize,
				alignment = (TextAnchor)3,
				wordWrap = true
			};
			_buttonStyle = new GUIStyle(GUI.skin.button)
			{
				fontSize = OptionFontSize,
				alignment = (TextAnchor)4
			};
		}

		private void Update()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			if (_waitingForBinding && ((ButtonControl)Keyboard.current.anyKey).wasPressedThisFrame)
			{
				Enumerator<KeyControl> enumerator = Keyboard.current.allKeys.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						KeyControl current = enumerator.Current;
						if (((ButtonControl)current).wasPressedThisFrame)
						{
							string path = ((InputControl)current).path;
							_bindingTarget.StringEntry.Value = path;
							Plugin.Log.LogInfo((object)("Rebound " + _bindingTarget.Label + " to " + path));
							_waitingForBinding = false;
							hintText = _bindingTarget.DisplayValue() + ": Open/Close • Tab or ↑/↓:  Move • Enter/Click: Change • Scroll Wheel or ←/→ Arrows: Adjust Numerical Values • +/-: Scale Menu";
							_bindingTarget = null;
							break;
						}
					}
					return;
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
			}
			if (_visible && _options != null && _options.Count != 0)
			{
				if (Input.GetKeyDown((KeyCode)9))
				{
					bool flag = Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303);
					CycleSelection((!flag) ? 1 : (-1));
				}
				if (Input.GetKeyDown((KeyCode)61) || Input.GetKeyDown((KeyCode)43))
				{
					Scale(1);
				}
				if (Input.GetKeyDown((KeyCode)45))
				{
					Scale(-1);
				}
				if (Input.GetKeyDown((KeyCode)273))
				{
					CycleSelection(-1);
				}
				if (Input.GetKeyDown((KeyCode)274))
				{
					CycleSelection(1);
				}
				if (Input.GetKeyDown((KeyCode)13) || Input.GetKeyDown((KeyCode)271))
				{
					ToggleSelected();
				}
				if (Input.GetKeyDown((KeyCode)276))
				{
					AdjustNumerical(-1);
				}
				if (Input.GetKeyDown((KeyCode)275))
				{
					AdjustNumerical(1);
				}
				float y = ((InputControl<Vector2>)(object)Mouse.current.scroll).ReadValue().y;
				if (y > 0f)
				{
					AdjustNumerical(1);
				}
				else if (y < 0f)
				{
					AdjustNumerical(-1);
				}
			}
		}

		private void ToggleSelected()
		{
			Option option = _options[_selectedIndex];
			if (option.IsDisabled())
			{
				return;
			}
			switch (option.Type)
			{
			case Option.OptionType.Bool:
				option.BoolEntry.Value = !option.BoolEntry.Value;
				break;
			case Option.OptionType.Int:
			{
				int num2 = option.IntEntry.Value + option.Step;
				if (num2 > option.MaxInt)
				{
					num2 = option.MinInt;
				}
				option.IntEntry.Value = num2;
				break;
			}
			case Option.OptionType.Float:
			{
				float num = option.FloatEntry.Value + option.FloatStep;
				if (num > option.MaxFloat)
				{
					num = option.MinFloat;
				}
				option.FloatEntry.Value = num;
				break;
			}
			case Option.OptionType.InputAction:
				_waitingForBinding = true;
				_bindingTarget = option;
				break;
			case Option.OptionType.String:
				break;
			}
		}

		private void AdjustNumerical(int delta)
		{
			Option option = _options[_selectedIndex];
			if (!option.IsDisabled())
			{
				if (option.Type == Option.OptionType.Int)
				{
					int value = Mathf.Clamp(option.IntEntry.Value + delta * option.Step, option.MinInt, option.MaxInt);
					option.IntEntry.Value = value;
				}
				else if (option.Type == Option.OptionType.Float)
				{
					float value2 = Mathf.Clamp(option.FloatEntry.Value + (float)delta * option.FloatStep, option.MinFloat, option.MaxFloat);
					option.FloatEntry.Value = value2;
				}
			}
		}

		private void CycleSelection(int delta)
		{
			if (_options == null || _options.Count == 0)
			{
				return;
			}
			int selectedIndex = _selectedIndex;
			do
			{
				_selectedIndex = (_selectedIndex + delta) % _options.Count;
				if (_selectedIndex < 0)
				{
					_selectedIndex += _options.Count;
				}
			}
			while (_options[_selectedIndex].IsDisabled() && _selectedIndex != selectedIndex);
		}

		private void OnGUI()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: 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_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible)
			{
				return;
			}
			EnsureStyles();
			if (_options == null)
			{
				_options = new List<Option>();
			}
			CalculatePanelWidth();
			float num = _titleStyle.CalcHeight(new GUIContent(titleText), (float)(PanelWidth - Pad * 2));
			float num2 = _options.Count * (RowHeight + 4);
			float num3 = _hintStyle.CalcHeight(new GUIContent(hintText), (float)(PanelWidth - Pad * 2));
			int num4 = Pad + (int)num + 8 + (int)num2 + Pad + (int)num3 + 30 + 4 + Pad;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(20f, 20f, (float)PanelWidth, (float)num4);
			GUI.color = new Color(0f, 0f, 0f, 0.75f);
			GUI.DrawTexture(val, (Texture)(object)_whiteTex);
			GUI.color = Color.white;
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref val)).x + (float)Pad, ((Rect)(ref val)).y + (float)Pad, ((Rect)(ref val)).width - (float)(Pad * 2), num);
			GUI.Label(val2, titleText, _titleStyle);
			float num5 = ((Rect)(ref val2)).yMax + 8f;
			Rect val3 = default(Rect);
			for (int i = 0; i < _options.Count; i++)
			{
				((Rect)(ref val3))..ctor(((Rect)(ref val)).x + (float)Pad, num5, ((Rect)(ref val)).width - (float)(Pad * 2), (float)RowHeight);
				Option option = _options[i];
				if (((Rect)(ref val3)).Contains(Event.current.mousePosition) && !option.IsDisabled())
				{
					_selectedIndex = i;
				}
				DrawOptionBackground(val3);
				if (i == _selectedIndex && !option.IsDisabled())
				{
					DrawSelectedOverlay(val3);
				}
				GUI.enabled = !option.IsDisabled();
				if (option.Label == "Menu Key" && _waitingForBinding)
				{
					DrawWaitingOverlay(val3);
					GUI.Button(val3, "Press any key...", _rowStyle);
				}
				else if (GUI.Button(val3, option.Label + ": " + option.DisplayValue(), _rowStyle) && !option.IsDisabled())
				{
					ToggleSelected();
				}
				GUI.enabled = true;
				num5 += (float)(RowHeight + 4);
			}
			Rect val4 = default(Rect);
			((Rect)(ref val4))..ctor(((Rect)(ref val)).x + (float)Pad, num5 + (float)Pad, ((Rect)(ref val)).width - (float)(Pad * 2), num3);
			GUI.Label(val4, hintText, _hintStyle);
			float num6 = ((Rect)(ref val4)).yMax + 4f;
			if (GUI.Button(new Rect(((Rect)(ref val)).xMax - 60f - (float)Pad, num6, 30f, 30f), "+", _buttonStyle))
			{
				Scale(1);
			}
			if (GUI.Button(new Rect(((Rect)(ref val)).xMax - 30f - (float)Pad, num6, 30f, 30f), "-", _buttonStyle))
			{
				Scale(-1);
			}
		}

		private void DrawOptionBackground(Rect rect)
		{
			//IL_0014: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			GUI.color = new Color(0.3f, 0.3f, 0.3f, 0.8f);
			GUI.DrawTexture(rect, (Texture)(object)_whiteTex);
			GUI.color = Color.white;
		}

		private void DrawSelectedOverlay(Rect rect)
		{
			//IL_0014: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			GUI.color = new Color(1f, 1f, 1f, 0.24f);
			GUI.DrawTexture(rect, (Texture)(object)_whiteTex);
			GUI.color = Color.white;
		}

		private void DrawWaitingOverlay(Rect rect)
		{
			//IL_0014: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			GUI.color = new Color(0f, 0f, 0f, 0.6f);
			GUI.DrawTexture(rect, (Texture)(object)_whiteTex);
			GUI.color = Color.white;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_whiteTex != (Object)null)
			{
				Object.Destroy((Object)(object)_whiteTex);
				_whiteTex = null;
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	public class Option
	{
		public enum OptionType
		{
			Bool,
			Int,
			String,
			InputAction,
			Float
		}

		public string Label { get; set; }

		public OptionType Type { get; set; }

		public ConfigEntry<bool> BoolEntry { get; set; }

		public ConfigEntry<int> IntEntry { get; set; }

		public ConfigEntry<string> StringEntry { get; set; }

		public int MinInt { get; set; }

		public int MaxInt { get; set; }

		public int Step { get; set; }

		public Func<bool> IsDisabled { get; set; } = () => false;

		public Func<string> DisplayValue { get; set; } = () => "";

		public ConfigEntry<float> FloatEntry { get; set; }

		public float MinFloat { get; set; }

		public float MaxFloat { get; set; }

		public float FloatStep { get; set; }

		private Option(string label, OptionType type)
		{
			Label = label;
			Type = type;
		}

		public static Option Float(string label, ConfigEntry<float> entry, float min, float max, float step = 0.05f, Func<bool>? isDisabled = null)
		{
			return new Option(label, OptionType.Float)
			{
				FloatEntry = entry,
				MinFloat = min,
				MaxFloat = max,
				FloatStep = step,
				IsDisabled = (isDisabled ?? ((Func<bool>)(() => false))),
				DisplayValue = () => entry.Value.ToString("F3")
			};
		}

		public static Option Bool(string label, ConfigEntry<bool> entry, Func<bool>? isDisabled = null)
		{
			return new Option(label, OptionType.Bool)
			{
				BoolEntry = entry,
				IsDisabled = (isDisabled ?? ((Func<bool>)(() => false))),
				DisplayValue = () => (!entry.Value) ? "OFF" : "ON"
			};
		}

		public static Option InputAction(string label, ConfigEntry<string> entry, Func<bool>? isDisabled = null)
		{
			return new Option(label, OptionType.InputAction)
			{
				StringEntry = entry,
				IsDisabled = (isDisabled ?? ((Func<bool>)(() => false))),
				DisplayValue = delegate
				{
					string[] array = entry.Value.Split("/");
					return (array.Length <= 1) ? entry.Value : array[^1].ToUpper();
				}
			};
		}

		public static Option Int(string label, ConfigEntry<int> entry, int min, int max, int step = 1, Func<bool>? isDisabled = null)
		{
			return new Option(label, OptionType.Int)
			{
				IntEntry = entry,
				MinInt = min,
				MaxInt = max,
				Step = step,
				IsDisabled = (isDisabled ?? ((Func<bool>)(() => false))),
				DisplayValue = () => entry.Value.ToString()
			};
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}