using System;
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.4.1.0")]
[assembly: AssemblyInformationalVersion("1.4.1-dev.9+a55fed8219785d43881db6881f099e57e5410128")]
[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.4.1")]
	[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.4.1 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.4.1";
	}
}
namespace FinallyCorrectKeys.Util
{
	internal class ActionBindings
	{
		private static readonly InputActionAsset actions = IngamePlayerSettings.Instance.playerInput.actions;

		internal static readonly string discardBinding = "Discard";

		internal static readonly string useBinding = "Use";

		internal static readonly string activateItemBinding = "ActivateItem";

		internal static readonly string secondaryUseBinding = "ItemSecondaryUse";

		internal static readonly string tertiaryUseBinding = "ItemTertiaryUse";

		internal static readonly string inspectItemBinding = "InspectItem";

		internal static readonly string sprintBinding = "Sprint";

		internal static readonly string scanBinding = "PingScan";

		internal static readonly string interactBinding = "Interact";

		internal static readonly string buildBinding = "BuildMode";

		internal static readonly string rotateBinding = "ReloadBatteries";

		internal static readonly string storeBinding = "Delete";

		internal static InputBinding GetInputBinding(string actionName)
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			return actions.FindAction(actionName, false).bindings[0];
		}

		internal static string GetInputBindingString(string actionName)
		{
			//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(actionName);
			return ((InputBinding)(ref inputBinding)).ToDisplayString((DisplayStringOptions)0, (InputControl)null);
		}
	}
	internal class BindingReplacer
	{
		internal static string Replace(string text, string toReplace, string actionName)
		{
			return text.Replace(toReplace, "[" + ActionBindings.GetInputBindingString(actionName) + "\u200b]");
		}
	}
}
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("[G]"))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, "[G]", ActionBindings.discardBinding);
					text2 = ActionBindings.discardBinding;
				}
				else if (text.Contains("[LMB]"))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, "[LMB]", ActionBindings.activateItemBinding);
					text2 = ActionBindings.activateItemBinding;
				}
				else if (text.Contains("[Q]"))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, "[Q]", ActionBindings.secondaryUseBinding);
					text2 = ActionBindings.secondaryUseBinding;
				}
				else if (text.Contains("[E]"))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, "[E]", ActionBindings.tertiaryUseBinding);
					text2 = ActionBindings.tertiaryUseBinding;
				}
				else if (text.Contains("[Z]"))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, "[Z]", ActionBindings.inspectItemBinding);
					text2 = ActionBindings.inspectItemBinding;
				}
				else if (text.Contains("[Q/E]"))
				{
					string newValue = $"[{ActionBindings.GetInputBindingString(ActionBindings.secondaryUseBinding)}/{ActionBindings.GetInputBindingString(ActionBindings.tertiaryUseBinding)}]";
					((TMP_Text)line).text = text.Replace("[Q/E]", newValue);
					text2 = ActionBindings.secondaryUseBinding + " and " + ActionBindings.tertiaryUseBinding;
				}
				else if (text.StartsWith("Sprint"))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, "[Shift]", ActionBindings.sprintBinding);
					text2 = ActionBindings.sprintBinding;
				}
				else if (text.StartsWith("Scan"))
				{
					((TMP_Text)line).text = BindingReplacer.Replace(text, "[RMB]", ActionBindings.scanBinding);
					text2 = ActionBindings.scanBinding;
				}
				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
	{
		[HarmonyPatch("SetHoverTipAndCurrentInteractTrigger")]
		[HarmonyPostfix]
		private static void SetHoverTipAndCurrentInteractTriggerPatch(PlayerControllerB __instance)
		{
			TextMeshProUGUI cursorTip = __instance.cursorTip;
			if (((TMP_Text)cursorTip).text.Contains("[E]"))
			{
				((TMP_Text)cursorTip).text = BindingReplacer.Replace(((TMP_Text)cursorTip).text, "[E]", ActionBindings.interactBinding);
			}
		}
	}
	[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, "[B]", ActionBindings.buildBinding);
			text = BindingReplacer.Replace(text, "[R]", ActionBindings.rotateBinding);
			text = BindingReplacer.Replace(text, "[X]", ActionBindings.storeBinding);
			((TMP_Text)HUDManager.Instance.buildModeControlTip).text = text;
			FinallyCorrectKeys.Logger.LogDebug((object)string.Format("[{0}] Replaced the {1} and {2} and {3} binding.", "ShipBuildModeManagerPatches", ActionBindings.buildBinding, ActionBindings.rotateBinding, ActionBindings.storeBinding));
		}
	}
}
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)
		{
		}
	}
}