using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FinallyCorrectKeys.Configuration;
using FinallyCorrectKeys.Patches;
using FinallyCorrectKeys.Util;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;

[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("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: AssemblyCompany("Rminin.FinallyCorrectKeys")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.6.0.0")]
[assembly: AssemblyInformationalVersion("1.6.0+287b09eb5833b37867fed8bcf68f9b7461dc4706")]
[assembly: AssemblyProduct("FinallyCorrectKeys")]
[assembly: AssemblyTitle("Rminin.FinallyCorrectKeys")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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.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]
	[Microsoft.CodeAnalysis.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]
	[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;
		}
	}
}
namespace FinallyCorrectKeys
{
	[BepInPlugin("Rminin.FinallyCorrectKeys", "FinallyCorrectKeys", "1.6.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class FinallyCorrectKeys : BaseUnityPlugin
	{
		public static FinallyCorrectKeys Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static Harmony? Harmony { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Config.Load(((BaseUnityPlugin)this).Config);
			Patch();
			LobbyCompatibilityConfig.Init((BaseUnityPlugin)(object)this);
			Logger.LogInfo((object)"Rminin.FinallyCorrectKeys v1.6.0 has loaded!");
		}

		internal static void Patch()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("Rminin.FinallyCorrectKeys");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching...");
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Rminin.FinallyCorrectKeys";

		public const string PLUGIN_NAME = "FinallyCorrectKeys";

		public const string PLUGIN_VERSION = "1.6.0";
	}
}
namespace FinallyCorrectKeys.Util
{
	internal class ActionBindings
	{
		private static readonly InputActionAsset actions = IngamePlayerSettings.Instance.playerInput.actions;

		internal static Dictionary<Bindings, InputAction> actionMap = new Dictionary<Bindings, InputAction>();

		internal static InputAction interactAction = actions.FindAction(Bindings.INTERACT.Name, false);

		internal static InputBinding interactBind = interactAction.bindings[0];

		internal static string interactDisplayString = ((InputBinding)(ref interactBind)).ToDisplayString((DisplayStringOptions)0, (InputControl)null);

		internal static InputAction GetInputAction(Bindings binding)
		{
			if (actionMap.ContainsKey(binding))
			{
				return actionMap[binding];
			}
			InputAction val = actions.FindAction((string)binding, false);
			actionMap.Add(binding, val);
			return val;
		}

		internal static InputBinding GetInputBinding(Bindings binding)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return GetInputAction(binding).bindings[0];
		}

		internal static string GetInputBindingString(Bindings binding)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			InputBinding inputBinding = GetInputBinding(binding);
			return ((InputBinding)(ref inputBinding)).ToDisplayString((DisplayStringOptions)0, (InputControl)null);
		}
	}
	internal class BindingReplacer
	{
		internal static string Replace(string text, string toReplace, Bindings binding)
		{
			return text.Replace(toReplace, "[" + ActionBindings.GetInputBindingString(binding) + "\u200b]");
		}
	}
	public class Bindings
	{
		public readonly string Name;

		public readonly string StandardKey;

		public static readonly Bindings DISCARD = new Bindings("Discard", "G");

		public static readonly Bindings USE = new Bindings("Use", "LMB");

		public static readonly Bindings ACTIVATE_ITEM = new Bindings("ActivateItem", "LMB");

		public static readonly Bindings SECONDARY_USE = new Bindings("ItemSecondaryUse", "Q");

		public static readonly Bindings TERTIARY_USE = new Bindings("ItemTertiaryUse", "E");

		public static readonly Bindings INSPECT_ITEM = new Bindings("InspectItem", "Z");

		public static readonly Bindings SPRINT = new Bindings("Sprint", "Shift");

		public static readonly Bindings SCAN = new Bindings("PingScan", "RMB");

		public static readonly Bindings INTERACT = new Bindings("Interact", "E");

		public static readonly Bindings BUILD = new Bindings("BuildMode", "B");

		public static readonly Bindings ROTATE = new Bindings("ReloadBatteries", "R");

		public static readonly Bindings STORE = new Bindings("Delete", "X");

		private Bindings(string name, string standardKey)
		{
			Name = name;
			StandardKey = standardKey;
		}

		public string ToHUDFormat()
		{
			return "[" + StandardKey + "]";
		}

		public override string ToString()
		{
			return Name;
		}

		public static implicit operator string(Bindings b)
		{
			return b.ToString();
		}
	}
}
namespace FinallyCorrectKeys.Patches
{
	[HarmonyPatch(typeof(HUDManager))]
	public class HUDManagerPatches
	{
		private static HUDManager _instance;

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void AwakePatch(HUDManager __instance)
		{
			_instance = __instance;
			if (Config.wordWrap.Value == Config.WordWrapOption.Disabled)
			{
				SetWordWrap(enabled: false);
			}
		}

		[HarmonyPatch("ChangeControlTipMultiple")]
		[HarmonyPostfix]
		private static void ChangeControlTipMultiplePatch(HUDManager __instance)
		{
			if (Config.disableControlTips.Value)
			{
				HideControlTips(__instance.controlTipLines);
				return;
			}
			ApplyWordWrapConfig();
			ReplaceKeysInControlTipMultiple(__instance.controlTipLines);
		}

		[HarmonyPatch("ChangeControlTip")]
		[HarmonyPostfix]
		public static void ChangeControlTipPatch(HUDManager __instance, int toolTipNumber, string changeTo)
		{
			if (Config.disableControlTips.Value)
			{
				HideControlTips(__instance.controlTipLines);
				return;
			}
			FinallyCorrectKeys.Logger.LogDebug((object)string.Format("[{0}] Parameters of ChangeControlTip:\nToolTipNumber: {1}\nChangeTo: {2}", "HUDManagerPatches", toolTipNumber, changeTo));
			TextMeshProUGUI val = __instance.controlTipLines[toolTipNumber];
			ApplyWordWrapGreater(val);
			ReplaceKeysInControlTip(val);
			if (__instance.forceChangeTextCoroutine != null)
			{
				((MonoBehaviour)__instance).StopCoroutine(__instance.forceChangeTextCoroutine);
				FinallyCorrectKeys.Logger.LogDebug((object)"[HUDManagerPatches] Coroutine to force text change stopped.");
			}
			__instance.forceChangeTextCoroutine = ((MonoBehaviour)__instance).StartCoroutine(__instance.ForceChangeText(val, ((TMP_Text)val).text));
			FinallyCorrectKeys.Logger.LogDebug((object)"[HUDManagerPatches] Coroutine to force text change started.");
		}

		public static void SetWordWrap(bool enabled)
		{
			TextMeshProUGUI[] controlTipLines = _instance.controlTipLines;
			foreach (TextMeshProUGUI val in controlTipLines)
			{
				((TMP_Text)val).enableWordWrapping = enabled;
			}
			FinallyCorrectKeys.Logger.LogDebug((object)string.Format("[{0}] Set word wrapping of controlTipLines to: {1}", "HUDManagerPatches", enabled));
		}

		public static void ApplyWordWrapConfig()
		{
			TextMeshProUGUI[] controlTipLines = _instance.controlTipLines;
			foreach (TextMeshProUGUI line in controlTipLines)
			{
				ApplyWordWrapGreater(line);
			}
		}

		public static void HideControlTips()
		{
			HideControlTips(_instance.controlTipLines);
		}

		private static void ReplaceKeysInControlTip(TextMeshProUGUI line)
		{
			string text = ((TMP_Text)line).text;
			if (!string.IsNullOrWhiteSpace(text))
			{
				string text2 = string.Empty;
				if (text.Contains(Bindings.DISCARD.ToHUDFormat()))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, Bindings.DISCARD.ToHUDFormat(), Bindings.DISCARD);
					text2 = Bindings.DISCARD;
				}
				else if (text.Contains(Bindings.ACTIVATE_ITEM.ToHUDFormat()))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, Bindings.ACTIVATE_ITEM.ToHUDFormat(), Bindings.ACTIVATE_ITEM);
					text2 = Bindings.ACTIVATE_ITEM;
				}
				else if (text.Contains(Bindings.SECONDARY_USE.ToHUDFormat()))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, Bindings.SECONDARY_USE.ToHUDFormat(), Bindings.SECONDARY_USE);
					text2 = Bindings.SECONDARY_USE;
				}
				else if (text.Contains(Bindings.TERTIARY_USE.ToHUDFormat()))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, Bindings.TERTIARY_USE.ToHUDFormat(), Bindings.TERTIARY_USE);
					text2 = Bindings.TERTIARY_USE;
				}
				else if (text.Contains(Bindings.INSPECT_ITEM.ToHUDFormat()))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, Bindings.INSPECT_ITEM.ToHUDFormat(), Bindings.INSPECT_ITEM);
					text2 = Bindings.INSPECT_ITEM;
				}
				else if (text.Contains($"[{Bindings.SECONDARY_USE.StandardKey}/{Bindings.TERTIARY_USE.StandardKey}]"))
				{
					string newValue = $"[{ActionBindings.GetInputBindingString(Bindings.SECONDARY_USE)}/{ActionBindings.GetInputBindingString(Bindings.TERTIARY_USE)}]";
					((TMP_Text)line).text = text.Replace($"[{Bindings.SECONDARY_USE.StandardKey}/{Bindings.TERTIARY_USE.StandardKey}]", newValue);
					text2 = string.Concat(Bindings.SECONDARY_USE, " and ", Bindings.TERTIARY_USE);
				}
				if (string.IsNullOrEmpty(text2))
				{
					FinallyCorrectKeys.Logger.LogDebug((object)"[HUDManagerPatches] No keybind found to replace");
					return;
				}
				FinallyCorrectKeys.Logger.LogDebug((object)("[HUDManagerPatches] Binding " + text2 + " replaced:\nOld: " + text + "\nNew: " + ((TMP_Text)line).text));
			}
		}

		private static void ApplyWordWrapGreater(TextMeshProUGUI line)
		{
			if (Config.wordWrap.Value == Config.WordWrapOption.EnabledIfGreater)
			{
				((TMP_Text)line).enableWordWrapping = ((TMP_Text)line).text.Length > Config.wordWrapLimit.Value;
			}
		}

		private static void ReplaceKeysInControlTipMultiple(TextMeshProUGUI[] lines)
		{
			for (int i = 0; i < lines.Length; i++)
			{
				ReplaceKeysInControlTip(lines[i]);
			}
		}

		private static void HideControlTips(TextMeshProUGUI[] lines)
		{
			for (int i = 0; i < lines.Length; i++)
			{
				((TMP_Text)lines[i]).text = "";
			}
			FinallyCorrectKeys.Logger.LogDebug((object)"[HUDManagerPatches] Hid control tips.");
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class PlayerControllerBPatches
	{
		private static DateTime timestamp = DateTime.Now;

		[HarmonyPatch("SetHoverTipAndCurrentInteractTrigger")]
		[HarmonyPostfix]
		private static void SetHoverTipAndCurrentInteractTriggerPatch(PlayerControllerB __instance)
		{
			TextMeshProUGUI cursorTip = __instance.cursorTip;
			if (((TMP_Text)cursorTip).text.Contains(Bindings.INTERACT.ToHUDFormat()))
			{
				UpdateInteractDisplayString();
				((TMP_Text)cursorTip).text = ((TMP_Text)cursorTip).text.Replace(Bindings.INTERACT.ToHUDFormat(), "[" + ActionBindings.interactDisplayString + "]");
			}
		}

		private static void UpdateInteractDisplayString()
		{
			DateTime dateTime = timestamp;
			timestamp = DateTime.Now;
			if (!(timestamp - dateTime <= TimeSpan.FromSeconds(3.0)))
			{
				string inputBindingString = ActionBindings.GetInputBindingString(Bindings.INTERACT);
				if (ActionBindings.interactDisplayString.Equals(inputBindingString))
				{
					FinallyCorrectKeys.Logger.LogDebug((object)"[PlayerControllerBPatches] No change in Interaction Keybind detected.");
					return;
				}
				FinallyCorrectKeys.Logger.LogDebug((object)("[PlayerControllerBPatches] Updating ActionBindings display string from: " + ActionBindings.interactDisplayString + " to: " + inputBindingString));
				ActionBindings.interactDisplayString = inputBindingString;
			}
		}
	}
	[HarmonyPatch(typeof(ShipBuildModeManager))]
	public class ShipBuildModeManagerPatches
	{
		[HarmonyPatch("CreateGhostObjectAndHighlight")]
		[HarmonyPostfix]
		private static void CreateGhostObjectAndHighlight(ShipBuildModeManager __instance)
		{
			string text = ((TMP_Text)HUDManager.Instance.buildModeControlTip).text;
			text = BindingReplacer.Replace(text, Bindings.BUILD.ToHUDFormat(), Bindings.BUILD);
			text = BindingReplacer.Replace(text, Bindings.ROTATE.ToHUDFormat(), Bindings.ROTATE);
			text = BindingReplacer.Replace(text, Bindings.STORE.ToHUDFormat(), Bindings.STORE);
			((TMP_Text)HUDManager.Instance.buildModeControlTip).text = text;
			FinallyCorrectKeys.Logger.LogDebug((object)string.Format("[{0}] Replaced the {1} and {2} and {3} binding.", "ShipBuildModeManagerPatches", Bindings.BUILD, Bindings.ROTATE, Bindings.STORE));
		}
	}
}
namespace FinallyCorrectKeys.Configuration
{
	internal class Config
	{
		internal enum WordWrapOption
		{
			Enabled,
			EnabledIfGreater,
			Disabled
		}

		internal static ConfigEntry<bool> disableControlTips;

		internal static ConfigEntry<WordWrapOption> wordWrap;

		internal static ConfigEntry<int> wordWrapLimit;

		internal static void Load(ConfigFile config)
		{
			disableControlTips = config.Bind<bool>("General", "Disable Control Tips", false, "Hides the control tips (should also work if other mods that use the control tips).\nIf you disable this setting while control tips are hidden, you need to change the inventory slot to reload them.");
			wordWrap = config.Bind<WordWrapOption>("General", "Word Wrap", WordWrapOption.EnabledIfGreater, "Option for controlling word wrap.\n\n" + $"{WordWrapOption.Enabled}: Word wrap enabled (Vanilla)\n\n" + $"{WordWrapOption.EnabledIfGreater}: Word wrap enabled for lines which are longer than the word wrap limit (Recommended)\n\n" + $"{WordWrapOption.Disabled}: Word wrap disabled");
			wordWrapLimit = config.Bind<int>("General", "Word Wrap Limit", 50, "Customizable limit of when word wrap should be enabled.");
			if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
			{
				LoadLethalConfig();
			}
		}

		internal static void LoadLethalConfig()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0073: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_0093: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			BoolCheckBoxConfigItem val = new BoolCheckBoxConfigItem(disableControlTips, false);
			disableControlTips.SettingChanged += OnDisableControlTipsChanged;
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
			EnumDropDownConfigItem<WordWrapOption> val2 = new EnumDropDownConfigItem<WordWrapOption>(wordWrap, false);
			wordWrap.SettingChanged += OnWordWrapChanged;
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
			ConfigEntry<int> obj = wordWrapLimit;
			IntSliderOptions val3 = new IntSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<int>)val3).Min = 0;
			((BaseRangeOptions<int>)val3).Max = 100;
			IntSliderConfigItem val4 = new IntSliderConfigItem(obj, val3);
			wordWrapLimit.SettingChanged += OnWordWrapLimitChanged;
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
		}

		private static void OnDisableControlTipsChanged(object obj, EventArgs args)
		{
			FinallyCorrectKeys.Logger.LogDebug((object)string.Format("[{0}] LethalConfig Option {1} changed to {2}", "Config", "disableControlTips", disableControlTips.Value));
			if (disableControlTips.Value)
			{
				HUDManagerPatches.HideControlTips();
			}
		}

		private static void OnWordWrapLimitChanged(object obj, EventArgs args)
		{
			FinallyCorrectKeys.Logger.LogDebug((object)string.Format("[{0}] LethalConfig Option {1} changed to {2}", "Config", "wordWrapLimit", wordWrapLimit.Value));
			HUDManagerPatches.ApplyWordWrapConfig();
		}

		private static void OnWordWrapChanged(object obj, EventArgs args)
		{
			FinallyCorrectKeys.Logger.LogDebug((object)string.Format("[{0}] LethalConfig Option {1} changed to {2}", "Config", "wordWrap", wordWrap.Value));
			switch (wordWrap.Value)
			{
			case WordWrapOption.Enabled:
				HUDManagerPatches.SetWordWrap(enabled: true);
				break;
			case WordWrapOption.Disabled:
				HUDManagerPatches.SetWordWrap(enabled: false);
				break;
			case WordWrapOption.EnabledIfGreater:
				HUDManagerPatches.ApplyWordWrapConfig();
				break;
			default:
				FinallyCorrectKeys.Logger.LogError((object)string.Format("[{0}] Unkown value {1} for option {2}", "Config", wordWrap.Value, "wordWrap"));
				break;
			}
		}
	}
	internal static class LobbyCompatibilityConfig
	{
		public static void Init(BaseUnityPlugin plugin)
		{
			if (Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility"))
			{
				LoadLobbyCompatibilityConfig(plugin.Info.Metadata);
			}
		}

		private static void LoadLobbyCompatibilityConfig(BepInPlugin plugin)
		{
			PluginHelper.RegisterPlugin(plugin.GUID, plugin.Version, (CompatibilityLevel)0, (VersionStrictness)0);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}