using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Xml;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using ModifAmorphic.Outward.ActionUI.DataModels;
using ModifAmorphic.Outward.ActionUI.Extensions;
using ModifAmorphic.Outward.ActionUI.Models;
using ModifAmorphic.Outward.ActionUI.Monobehaviours;
using ModifAmorphic.Outward.ActionUI.Patches;
using ModifAmorphic.Outward.ActionUI.Plugin.Services;
using ModifAmorphic.Outward.ActionUI.Services;
using ModifAmorphic.Outward.ActionUI.Services.Injectors;
using ModifAmorphic.Outward.ActionUI.Settings;
using ModifAmorphic.Outward.Config;
using ModifAmorphic.Outward.Config.Models;
using ModifAmorphic.Outward.Coroutines;
using ModifAmorphic.Outward.Extensions;
using ModifAmorphic.Outward.GameObjectResources;
using ModifAmorphic.Outward.Logging;
using ModifAmorphic.Outward.Modules;
using ModifAmorphic.Outward.Modules.Localization;
using ModifAmorphic.Outward.Unity.ActionMenus;
using ModifAmorphic.Outward.Unity.ActionUI;
using ModifAmorphic.Outward.Unity.ActionUI.Data;
using ModifAmorphic.Outward.Unity.ActionUI.EquipmentSets;
using ModifAmorphic.Outward.Unity.ActionUI.Models.EquipmentSets;
using Newtonsoft.Json;
using Rewired;
using Rewired.Data;
using Rewired.Data.Mapping;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("ModifAmorphic.Outward.ActionUI.Plugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0748ee4c3e5cabdf3003c1bbf7caa92a7535e9c1")]
[assembly: AssemblyProduct("ModifAmorphic.Outward.ActionUI.Plugin")]
[assembly: AssemblyTitle("ModifAmorphic.Outward.ActionUI.Plugin")]
[assembly: AssemblyVersion("1.0.0.0")]
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
public class ConfigurationManagerAttributes : Attribute
{
	public bool? ShowRangeAsPercent;

	public Action<ConfigEntryBase> CustomDrawer;

	public bool? Browsable;

	public string Category;

	public object DefaultValue;

	public bool? HideDefaultButton;

	public bool? HideSettingName;

	public string Description;

	public int? Order;

	public bool? ReadOnly;

	public bool? IsAdvanced;
}
namespace ModifAmorphic.Outward.ActionUI
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("ModifAmorphic.Outward.ActionUI", "Action Bar", "1.1.2")]
	public class ActionUIPlugin : BaseUnityPlugin
	{
		private static ServicesProvider _servicesProvider;

		internal static BaseUnityPlugin Instance;

		internal static ServicesProvider Services => _servicesProvider;

		internal void Awake()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			Instance = (BaseUnityPlugin)(object)this;
			ActionUISettings.Init(((BaseUnityPlugin)this).Config);
			new GlobalConfigService();
			IModifLogger val = null;
			Harmony val2 = new Harmony("ModifAmorphic.Outward.ActionUI");
			try
			{
				val = LoggerFactory.ConfigureLogger("ModifAmorphic.Outward.ActionUI", "Action Bar", (LogLevel)2);
				val.LogInfo("Patching...");
				val2.PatchAll(typeof(PauseMenuPatches));
				val2.PatchAll(typeof(SplitPlayerPatches));
				val2.PatchAll(typeof(LobbySystemPatches));
				val2.PatchAll(typeof(CharacterUIPatches));
				Startup startup = new Startup();
				val.LogInfo("Starting Action Bar 1.1.2...");
				_servicesProvider = new ServicesProvider((BaseUnityPlugin)(object)this);
				startup.Start(val2, _servicesProvider);
			}
			catch (Exception ex)
			{
				if (val != null)
				{
					val.LogException("Failed to enable ModifAmorphic.Outward.ActionUI Action Bar 1.1.2.", ex);
				}
				val2.UnpatchSelf();
				throw;
			}
		}
	}
	internal class DurabilityDisplayStartup : IStartable
	{
		private readonly Harmony _harmony;

		private readonly ServicesProvider _services;

		private readonly Func<IModifLogger> _loggerFactory;

		private readonly ModifGoService _modifGoService;

		private readonly LevelCoroutines _coroutines;

		private readonly string DurabilityModId = "ModifAmorphic.Outward.ActionUI.DurabilityDisplay";

		private IModifLogger Logger => _loggerFactory();

		public DurabilityDisplayStartup(ServicesProvider services, ModifGoService modifGoService, LevelCoroutines coroutines, Func<IModifLogger> loggerFactory)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			_services = services;
			_modifGoService = modifGoService;
			_coroutines = coroutines;
			_loggerFactory = loggerFactory;
			_harmony = new Harmony(DurabilityModId);
		}

		public void Start()
		{
			Logger.LogInfo("Starting Durability Display...");
			_harmony.PatchAll(typeof(EquipmentPatches));
			_services.AddSingleton<DurabilityDisplayService>(new DurabilityDisplayService(_services.GetService<PlayerMenuService>(), _coroutines, _loggerFactory));
		}
	}
	internal class HotbarsStartup : IStartable
	{
		private readonly Harmony _harmony;

		private readonly ServicesProvider _services;

		private readonly PlayerMenuService _playerMenuService;

		private readonly Func<IModifLogger> _loggerFactory;

		private readonly ModifGoService _modifGoService;

		private readonly LevelCoroutines _coroutines;

		private readonly string HotbarsModId = "ModifAmorphic.Outward.ActionUI.Hotbars";

		private IModifLogger Logger => _loggerFactory();

		public HotbarsStartup(ServicesProvider services, PlayerMenuService playerMenuService, ModifGoService modifGoService, LevelCoroutines coroutines, Func<IModifLogger> loggerFactory)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			_services = services;
			_playerMenuService = playerMenuService;
			_modifGoService = modifGoService;
			_coroutines = coroutines;
			_loggerFactory = loggerFactory;
			_harmony = new Harmony(HotbarsModId);
		}

		public void Start()
		{
			Logger.LogInfo("Starting Hotbars...");
			Logger.LogInfo("Patching...");
			_harmony.PatchAll(typeof(InputManager_BasePatches));
			_harmony.PatchAll(typeof(RewiredInputsPatches));
			_harmony.PatchAll(typeof(QuickSlotPanelPatches));
			_harmony.PatchAll(typeof(ControlsInputPatches));
			_harmony.PatchAll(typeof(CharacterQuickSlotManagerPatches));
			_harmony.PatchAll(typeof(SkillMenuPatches));
			_harmony.PatchAll(typeof(ItemDisplayDropGroundPatches));
			_harmony.PatchAll(typeof(EquipmentPatches));
			_services.AddSingleton<HotbarServicesInjector>(new HotbarServicesInjector(_services, _playerMenuService, _coroutines, _loggerFactory));
		}

		public void Stop()
		{
			_harmony.UnpatchSelf();
		}
	}
	internal class InventoryStartup : IStartable
	{
		private readonly Harmony _harmony;

		private readonly ServicesProvider _services;

		private readonly PlayerMenuService _playerMenuService;

		private readonly Func<IModifLogger> _loggerFactory;

		private readonly ModifGoService _modifGoService;

		private readonly LevelCoroutines _coroutines;

		private readonly string ModId = "ModifAmorphic.Outward.ActionUI.CharacterInventory";

		private readonly LocalizationModule _localizationsModule;

		private IModifLogger Logger => _loggerFactory();

		public InventoryStartup(ServicesProvider services, PlayerMenuService playerMenuService, ModifGoService modifGoService, LevelCoroutines coroutines, Func<IModifLogger> loggerFactory)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			_services = services;
			_playerMenuService = playerMenuService;
			_modifGoService = modifGoService;
			_coroutines = coroutines;
			_loggerFactory = loggerFactory;
			_harmony = new Harmony(ModId);
			_localizationsModule = ModifModules.GetLocalizationModule(ModId);
		}

		public void Start()
		{
			Logger.LogInfo("Starting Inventory Mods...");
			try
			{
				_localizationsModule.RegisterLocalization("Context_Item_MoveToStash", "Move to Stash");
			}
			catch (Exception ex)
			{
				Logger.LogWarning("Failed to register localizations in InventoryStartup. This is likely due to LocalizationManager not being ready yet. Proceeding with startup. Error: " + ex.Message);
			}
			_harmony.PatchAll(typeof(CharacterInventoryPatches));
			_harmony.PatchAll(typeof(EquipmentMenuPatches));
			_harmony.PatchAll(typeof(InventoryContentDisplayPatches));
			_harmony.PatchAll(typeof(ItemDisplayPatches));
			_harmony.PatchAll(typeof(ItemDisplayClickPatches));
			_harmony.PatchAll(typeof(CurrencyDisplayClickPatches));
			_harmony.PatchAll(typeof(NetworkInstantiateManagerPatches));
			_harmony.PatchAll(typeof(CharacterManagerPatches));
			_harmony.PatchAll(typeof(MenuPanelPatches));
			_harmony.PatchAll(typeof(ItemDisplayOptionPanelPatches));
			_services.AddSingleton<InventoryServicesInjector>(new InventoryServicesInjector(_services, _playerMenuService, _modifGoService, _coroutines, _loggerFactory));
		}
	}
	internal interface IStartable
	{
		void Start();
	}
	internal static class ModInfo
	{
		public const string ModId = "ModifAmorphic.Outward.ActionUI";

		public const string ModName = "Action Bar";

		public const string ModVersion = "1.1.2";

		public const string MinimumConfigVersion = "1.0.0";
	}
	internal static class Starter
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static bool TryStart(IStartable startable)
		{
			try
			{
				Logger.LogDebug("Starting " + startable.GetType().Name + ".");
				startable.Start();
				return true;
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to start " + startable.GetType().Name + ".", ex);
			}
			return false;
		}
	}
	internal class Startup
	{
		private ServicesProvider _services;

		private Func<IModifLogger> _loggerFactory;

		private IModifLogger Logger => _loggerFactory();

		internal void Start(Harmony harmony, ServicesProvider services)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			_services = services;
			SettingsService settingsService = new SettingsService(services.GetService<BaseUnityPlugin>(), "1.0.0");
			ConfigSettings configSettings = settingsService.ConfigureSettings();
			ActionUISettings.Init(_services.GetService<BaseUnityPlugin>().Config);
			services.AddSingleton<ConfigSettings>(configSettings).AddFactory<IModifLogger>((Func<IModifLogger>)(() => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI"))).AddSingleton<ModifCoroutine>(new ModifCoroutine(services.GetService<BaseUnityPlugin>(), (Func<IModifLogger>)services.GetService<IModifLogger>))
				.AddSingleton<LevelCoroutines>(new LevelCoroutines(services.GetService<BaseUnityPlugin>(), (Func<IModifLogger>)services.GetService<IModifLogger>))
				.AddSingleton<ResetActionUIsService>(new ResetActionUIsService(services, services.GetService<LevelCoroutines>(), (Func<IModifLogger>)services.GetService<IModifLogger>))
				.AddSingleton<ModifGoService>(new ModifGoService((Func<IModifLogger>)services.GetService<IModifLogger>))
				.AddSingleton<RewiredListener>(new RewiredListener(services.GetService<BaseUnityPlugin>(), services.GetService<LevelCoroutines>(), configSettings, (Func<IModifLogger>)services.GetService<IModifLogger>))
				.AddSingleton<IActionUIProfileService>((IActionUIProfileService)(object)new GlobalActionUIProfileService())
				.AddSingleton<IHotbarProfileService>((IHotbarProfileService)(object)new GlobalHotbarService())
				.AddSingleton<IPositionsProfileService>((IPositionsProfileService)(object)new GlobalPositionsService());
			_loggerFactory = services.GetServiceFactory<IModifLogger>();
			GameObject val = ConfigureAssetBundle();
			services.AddSingleton<SharedServicesInjector>(new SharedServicesInjector(services, (Func<IModifLogger>)services.GetService<IModifLogger>)).AddSingleton<PositionsService>(new PositionsService((ModifCoroutine)(object)services.GetService<LevelCoroutines>(), services.GetService<ModifGoService>(), (Func<IModifLogger>)services.GetService<IModifLogger>)).AddSingleton<PlayerMenuService>(new PlayerMenuService(services.GetService<BaseUnityPlugin>(), ((Component)val.GetComponentInChildren<PlayerActionMenus>(true)).gameObject, services.GetService<SharedServicesInjector>(), services.GetService<PositionsService>(), services.GetService<LevelCoroutines>(), services.GetService<ModifGoService>(), (Func<IModifLogger>)services.GetService<IModifLogger>))
				.AddSingleton<PositionsServicesInjector>(new PositionsServicesInjector(_services, services.GetService<PlayerMenuService>(), services.GetService<ModifGoService>(), (ModifCoroutine)(object)services.GetService<LevelCoroutines>(), (Func<IModifLogger>)services.GetService<IModifLogger>));
			services.AddSingleton<InventoryStartup>(new InventoryStartup(services, services.GetService<PlayerMenuService>(), services.GetService<ModifGoService>(), services.GetService<LevelCoroutines>(), _loggerFactory)).AddSingleton<HotbarsStartup>(new HotbarsStartup(services, services.GetService<PlayerMenuService>(), services.GetService<ModifGoService>(), services.GetService<LevelCoroutines>(), _loggerFactory));
			Starter.TryStart(services.GetService<HotbarsStartup>());
			Starter.TryStart(services.GetService<InventoryStartup>());
		}

		public GameObject ConfigureAssetBundle()
		{
			GameObject val = AttachScripts(typeof(PlayerActionMenus).Assembly);
			Logger.LogDebug("Loading asset bundle action-ui.");
			AssetBundle val2 = LoadAssetBundle(BaseUnityPluginExtensions.GetPluginDirectory(_services.GetService<BaseUnityPlugin>()), "", "action-ui");
			string[] allAssetNames = val2.GetAllAssetNames();
			string text = "";
			string[] array = allAssetNames;
			foreach (string text2 in array)
			{
				text = text + text2 + ", ";
			}
			Logger.LogDebug("Assets in Bundle: " + text);
			GameObject val3 = val2.LoadAsset<GameObject>("assets/prefabs/actionui.prefab");
			val3.SetActive(false);
			Logger.LogDebug("Loaded asset assets/prefabs/actionui.prefab.");
			Object.DontDestroyOnLoad((Object)(object)val3);
			val2.Unload(false);
			GameObject modResources = _services.GetService<ModifGoService>().GetModResources("ModifAmorphic.Outward.ActionUI", false);
			val3.transform.SetParent(modResources.transform);
			GameObject gameObject = ((Component)val3.transform.Find("PlayersServicesProvider")).gameObject;
			GameObject modResources2 = _services.GetService<ModifGoService>().GetModResources("ModifAmorphic.Outward.ActionUI", true);
			GameObject val4 = Object.Instantiate<GameObject>(gameObject);
			val4.transform.SetParent(modResources2.transform);
			((Object)val4).name = "PlayersServicesProvider";
			GameObject gameObject2 = ((Component)val3.transform.Find("ActionSprites")).gameObject;
			GameObject val5 = Object.Instantiate<GameObject>(gameObject2);
			val5.transform.SetParent(modResources2.transform);
			((Object)val5).name = "ActionSprites";
			GameObject gameObject3 = ((Component)val3.transform.Find("Prefabs")).gameObject;
			GameObject val6 = Object.Instantiate<GameObject>(gameObject3, modResources.transform);
			((Object)val6).name = "Prefabs";
			Object.Destroy((Object)(object)gameObject);
			Object.Destroy((Object)(object)gameObject2);
			Object.Destroy((Object)(object)gameObject3);
			Object.Destroy((Object)(object)val);
			return val3;
		}

		public GameObject AttachScripts(Assembly sourceAssembly)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			IEnumerable<Type> enumerable = from type in sourceAssembly.GetTypes()
				where type.GetCustomAttributes(typeof(UnityScriptComponentAttribute), inherit: true).Length != 0
				select type;
			ModifGoService service = _services.GetService<ModifGoService>();
			GameObject modResources = service.GetModResources("ModifAmorphic.Outward.ActionUI", false);
			GameObject val = new GameObject("scripts");
			val.transform.SetParent(modResources.transform);
			foreach (Type item in enumerable)
			{
				Logger.LogTrace("Attaching script " + item.FullName);
				val.AddComponent(item);
			}
			return val;
		}

		private AssetBundle LoadAssetBundle(string pluginPath, string bundleDirectory, string bundleFileName)
		{
			using FileStream fileStream = new FileStream(Path.Combine(pluginPath, Path.Combine(bundleDirectory, bundleFileName)), FileMode.Open, FileAccess.Read);
			return AssetBundle.LoadFromStream((Stream)fileStream);
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Settings
{
	public static class ActionUISettings
	{
		public static class ActionViewer
		{
			public const string SkillsTab = "Skills";

			public const string ConsumablesTab = "Consumables";

			public const string DeployablesTab = "Deployables";

			public const string WeaponsTab = "Weapons";

			public const string ArmorTab = "Armor";

			public const string CosmeticsTab = "Cosmetics";

			public const string EquippedTab = "Equipped";
		}

		public static readonly string PluginPath = Path.GetDirectoryName(ActionUIPlugin.Instance.Info.Location);

		public static readonly string ConfigPath = Path.GetDirectoryName(ActionUIPlugin.Instance.Config.ConfigFilePath);

		public static readonly string GlobalKeymapsPath = Path.Combine(ConfigPath, "ActionUI_Keymaps");

		public static readonly string CharacterHotbarsPath = Path.Combine(ConfigPath, "ActionUI_CharacterSlots");

		public static ConfigEntry<int> Rows;

		public static ConfigEntry<int> SlotsPerRow;

		public static ConfigEntry<int> Scale;

		public static ConfigEntry<bool> HideLeftNav;

		public static ConfigEntry<bool> CombatMode;

		public static ConfigEntry<bool> ShowCooldownTimer;

		public static ConfigEntry<bool> PreciseCooldownTime;

		public static ConfigEntry<string> DisabledSlots;

		public static ConfigEntry<bool> OpenPositioningUI;

		public static ConfigEntry<bool> ResetPositions;

		public static ConfigEntry<float> HotbarPositionX;

		public static ConfigEntry<float> HotbarPositionY;

		public static ConfigEntry<bool> SetHotkeyMode;

		public static ConfigEntry<string> SerializedPositions;

		public static ConfigEntry<string> SerializedHotbars;

		public static void Init(ConfigFile config)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Expected O, but got Unknown
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Expected O, but got Unknown
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Expected O, but got Unknown
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Expected O, but got Unknown
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Expected O, but got Unknown
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Expected O, but got Unknown
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Expected O, but got Unknown
			Rows = config.Bind<int>("Hotbar", "Rows", 1, new ConfigDescription("Number of action bar rows.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 4), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false
				}
			}));
			SlotsPerRow = config.Bind<int>("Hotbar", "SlotsPerRow", 11, new ConfigDescription("Number of slots per row.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false
				}
			}));
			Scale = config.Bind<int>("Hotbar", "Scale", 100, new ConfigDescription("Scale of the action bars in percent.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(50, 200), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false
				}
			}));
			HideLeftNav = config.Bind<bool>("Hotbar", "HideLeftNav", false, new ConfigDescription("Hide the left navigation arrows.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false
				}
			}));
			CombatMode = config.Bind<bool>("Hotbar", "CombatMode", true, new ConfigDescription("Automatically show action bars when entering combat.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false
				}
			}));
			ShowCooldownTimer = config.Bind<bool>("Hotbar", "ShowCooldownTimer", true, new ConfigDescription("Show numeric cooldown timer on slots.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false
				}
			}));
			PreciseCooldownTime = config.Bind<bool>("Hotbar", "PreciseCooldownTime", false, new ConfigDescription("Show decimal precision for cooldowns.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false
				}
			}));
			DisabledSlots = config.Bind<string>("Hotbar", "DisabledSlots", "", new ConfigDescription("Internal list of disabled slot indices.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false,
					IsAdvanced = true
				}
			}));
			OpenPositioningUI = config.Bind<bool>("UI Positioning", "Open Visual Editor", false, new ConfigDescription("Click to open the visual drag-and-drop editor.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					CustomDrawer = DrawPositionButton,
					HideDefaultButton = true,
					IsAdvanced = false
				}
			}));
			ResetPositions = config.Bind<bool>("UI Positioning", "Reset UI Positions", false, new ConfigDescription("Reset all UI elements to their default positions.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					CustomDrawer = DrawResetInfo,
					HideDefaultButton = true,
					IsAdvanced = false
				}
			}));
			HotbarPositionX = config.Bind<float>("UI Positioning", "Hotbar X", 0f, new ConfigDescription("Horizontal position of the Hotbar.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-3840f, 0f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false,
					CustomDrawer = DrawHotbarX,
					HideDefaultButton = true
				}
			}));
			HotbarPositionY = config.Bind<float>("UI Positioning", "Hotbar Y", 0f, new ConfigDescription("Vertical position of the Hotbar.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-2160f, 0f), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					IsAdvanced = false,
					CustomDrawer = DrawHotbarY,
					HideDefaultButton = true
				}
			}));
			SetHotkeyMode = config.Bind<bool>("Input", "Set Hotkey Mode", false, new ConfigDescription("Click to enter hotkey assignment mode.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					CustomDrawer = DrawHotkeyModeButton,
					HideDefaultButton = true,
					IsAdvanced = false
				}
			}));
			SerializedPositions = config.Bind<string>("Internal", "SerializedPositions", "", new ConfigDescription("JSON serialized UI positions.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false,
					IsAdvanced = true
				}
			}));
			SerializedHotbars = config.Bind<string>("Internal", "SerializedHotbars", "", new ConfigDescription("JSON serialized hotbar configuration.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false,
					IsAdvanced = true
				}
			}));
		}

		private static void CloseConfigWindow()
		{
			try
			{
				Type type = Type.GetType("ConfigurationManager.ConfigurationManager, ConfigurationManager");
				if (type == null)
				{
					return;
				}
				Object val = Object.FindObjectOfType(type);
				if (val != (Object)null)
				{
					PropertyInfo property = type.GetProperty("DisplayingWindow");
					if (property != null)
					{
						property.SetValue(val, false, null);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static void DrawPositionButton(ConfigEntryBase entry)
		{
			if (GUILayout.Button("Open Visual Editor", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
			{
				CloseConfigWindow();
				PlayerActionMenus[] array = Object.FindObjectsOfType<PlayerActionMenus>();
				PlayerActionMenus[] array2 = array;
				foreach (PlayerActionMenus val in array2)
				{
					val.MainSettingsMenu.ShowMenu((ActionSettingsMenus)5);
				}
			}
		}

		private static void DrawResetInfo(ConfigEntryBase entry)
		{
			if (GUILayout.Button("Reset Positions", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
			{
				GlobalConfigService.Instance.PositionsProfile.Positions.Clear();
				GlobalConfigService.Instance.SavePositions();
				HotbarPositionX.Value = (float)((ConfigEntryBase)HotbarPositionX).DefaultValue;
				HotbarPositionY.Value = (float)((ConfigEntryBase)HotbarPositionY).DefaultValue;
				PositionableUI[] array = Object.FindObjectsOfType<PositionableUI>();
				PositionableUI[] array2 = array;
				foreach (PositionableUI val in array2)
				{
					val.ResetToOrigin();
				}
			}
		}

		private static void DrawHotbarX(ConfigEntryBase entry)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			float centerValue = (float)(-Screen.width) / 2f;
			string text = "";
			try
			{
				HotbarsContainer val = Object.FindObjectOfType<HotbarsContainer>();
				if ((Object)(object)val != (Object)null)
				{
					float num = Screen.width;
					Canvas componentInParent = ((Component)val).GetComponentInParent<Canvas>();
					if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.rootCanvas != (Object)null)
					{
						Rect rect = ((Component)componentInParent.rootCanvas).GetComponent<RectTransform>().rect;
						num = ((Rect)(ref rect)).width;
					}
					float num2 = 0f;
					float num3 = 0f;
					float num4 = 50f;
					float num5 = 5f;
					bool flag = false;
					GridLayoutGroup[] componentsInChildren = ((Component)val).GetComponentsInChildren<GridLayoutGroup>(true);
					GridLayoutGroup val2 = ((IEnumerable<GridLayoutGroup>)componentsInChildren).FirstOrDefault((Func<GridLayoutGroup, bool>)((GridLayoutGroup g) => ((Object)g).name == "BaseHotbarGrid")) ?? UnityEngineExtensions.FirstOrDefault<GridLayoutGroup>((IList<GridLayoutGroup>)componentsInChildren);
					if ((Object)(object)val2 != (Object)null)
					{
						num2 = ((LayoutGroup)val2).padding.left;
						num3 = ((LayoutGroup)val2).padding.right;
						num4 = val2.cellSize.x;
						num5 = val2.spacing.x;
						flag = true;
					}
					int value = SlotsPerRow.Value;
					float num6 = (num4 + num5) * (float)value - num5;
					float num7 = num6 + num2 + num3;
					float num8 = (float)Scale.Value / 100f;
					float num9 = (num6 / 2f + num3) * num8;
					centerValue = 0f - num / 2f + num9;
					if (flag)
					{
						text = "";
					}
					else
					{
						text = "";
					}
				}
			}
			catch (Exception)
			{
			}
			DrawHotbarSetting(entry, "Center", centerValue);
		}

		private static void DrawHotbarY(ConfigEntryBase entry)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			float centerValue = (float)(-Screen.height) / 2f;
			HotbarsContainer val = Object.FindObjectOfType<HotbarsContainer>();
			if ((Object)(object)val != (Object)null)
			{
				RectTransform component = ((Component)val).GetComponent<RectTransform>();
				LayoutRebuilder.ForceRebuildLayoutImmediate(component);
				Canvas componentInParent = ((Component)val).GetComponentInParent<Canvas>();
				RectTransform val2 = null;
				val2 = (RectTransform)(((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.rootCanvas != (Object)null) ? ((Component)componentInParent.rootCanvas).GetComponent<RectTransform>() : ((!((Object)(object)componentInParent != (Object)null)) ? ((object)/*isinst with value type is only supported in some contexts*/) : ((object)((Component)componentInParent).GetComponent<RectTransform>())));
				float num;
				Rect rect;
				if (!Object.op_Implicit((Object)(object)val2))
				{
					num = Screen.height;
				}
				else
				{
					rect = val2.rect;
					num = ((Rect)(ref rect)).height;
				}
				float num2 = num;
				rect = component.rect;
				float num3 = ((Rect)(ref rect)).height * ((Component)val).transform.localScale.y;
				centerValue = 0f - num2 / 2f + num3 / 2f;
			}
			DrawHotbarSetting(entry, "Center", centerValue);
		}

		private static void DrawHotbarSetting(ConfigEntryBase entry, string centerLabel, float centerValue)
		{
			float num = (float)entry.BoxedValue;
			AcceptableValueRange<float> val = (AcceptableValueRange<float>)(object)entry.Description.AcceptableValues;
			float num2 = val.MinValue;
			float num3 = val.MaxValue;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			float num4 = GUILayout.HorizontalSlider(num, num2, num3, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			string s = GUILayout.TextField(num4.ToString("F1"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(50f) });
			if (float.TryParse(s, out var result))
			{
				num4 = Mathf.Clamp(result, num2, num3);
			}
			if (GUILayout.Button(centerLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
			{
				num4 = centerValue;
			}
			if (GUILayout.Button("Reset", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
			{
				num4 = (float)entry.DefaultValue;
			}
			GUILayout.EndHorizontal();
			if (Mathf.Abs(num4 - num) > 0.001f)
			{
				entry.BoxedValue = num4;
				RefreshHotbarPositionFromConfig();
			}
		}

		private static void RefreshHotbarPositionFromConfig()
		{
			HotbarsContainer[] array = Object.FindObjectsOfType<HotbarsContainer>();
			HotbarsContainer[] array2 = array;
			foreach (HotbarsContainer val in array2)
			{
				PositionableUI component = ((Component)val).GetComponent<PositionableUI>();
				if ((Object)(object)component != (Object)null)
				{
					component.SetPosition(HotbarPositionX.Value, 0f - HotbarPositionY.Value);
				}
			}
		}

		private static void DrawHotkeyModeButton(ConfigEntryBase entry)
		{
			if (!GUILayout.Button("Enter Hotkey Mode", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
			{
				return;
			}
			CloseConfigWindow();
			PlayerActionMenus[] array = Object.FindObjectsOfType<PlayerActionMenus>();
			PlayerActionMenus[] array2 = array;
			foreach (PlayerActionMenus val in array2)
			{
				if ((Object)(object)val.MainSettingsMenu != (Object)null && (Object)(object)val.MainSettingsMenu.HotkeyCaptureMenu != (Object)null)
				{
					val.MainSettingsMenu.HotkeyCaptureMenu.Show();
				}
			}
		}
	}
	internal class ConfigSettings
	{
		private const string HotbarsSection = "Hotbars";

		private const int HotbarsTopOrder = int.MaxValue;

		private const string AdvancedSection = "zz--Advanced Settings--zz";

		private const int AdvancedTopOrder = -1000;

		public ConfigSetting<int> Hotbars { get; } = new ConfigSetting<int>
		{
			Name = "Hotbars",
			DefaultValue = 1,
			Section = "Hotbars",
			DisplayName = "Hotbars",
			Description = "Amount of hotbars.",
			Order = 2147483646,
			IsAdvanced = false
		};


		public ConfigSetting<int> ActionSlots { get; } = new ConfigSetting<int>
		{
			Name = "ActionSlots",
			DefaultValue = 8,
			Section = "Hotbars",
			DisplayName = "Hotbar Action Slots",
			Description = "The number of slots per hotbar.",
			Order = 2147483645,
			IsAdvanced = false
		};


		public ConfigSetting<LogLevel> LogLevel { get; } = new ConfigSetting<LogLevel>
		{
			Name = "LogLevel",
			DefaultValue = (LogLevel)2,
			Section = "zz--Advanced Settings--zz",
			DisplayName = "Minimum level for logging",
			Description = "The threshold for logging events to the UnityEngine.Debug logger. " + Enum.GetName(typeof(LogLevel), (object)(LogLevel)2) + " is the default.",
			Order = -1001,
			IsAdvanced = true
		};


		public ConfigSetting<string> ConfigVersion { get; } = new ConfigSetting<string>
		{
			Name = "ConfigVersion",
			DefaultValue = "1.1.2",
			Section = "zz--Advanced Settings--zz",
			DisplayName = "Created with version",
			Description = "The version of Action Bar this configuration file was created for.  **Warning - Changing this could result in resetting all config values.**",
			Order = -1002,
			IsAdvanced = true
		};

	}
	public class HotbarSettings
	{
		private static List<IHotbarSlotData> hotbarAssignments = new List<IHotbarSlotData> { (IHotbarSlotData)(object)new HotbarData
		{
			HotbarIndex = 0,
			RewiredActionId = RewiredConstants.ActionSlots.HotbarNavActions[0].id,
			RewiredActionName = RewiredConstants.ActionSlots.HotbarNavActions[0].name,
			Slots = new List<ISlotData>
			{
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 0,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "Q",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[0].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[0].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 1,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "E",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[1].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[1].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 2,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "R",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[2].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[2].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 3,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "1",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[3].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[3].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 4,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "2",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[4].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[4].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 5,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "3",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[5].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[5].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 6,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "4",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[6].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[6].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 7,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "5",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[7].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[7].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 8,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "6",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[8].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[8].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 9,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "7",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[9].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[9].id
					}
				},
				(ISlotData)(object)new SlotData
				{
					SlotIndex = 10,
					Config = (IActionSlotConfig)(object)new ActionConfig
					{
						HotkeyText = "8",
						RewiredActionName = RewiredConstants.ActionSlots.Actions[10].name,
						RewiredActionId = RewiredConstants.ActionSlots.Actions[10].id
					}
				}
			}
		} };

		internal static HotbarProfileData DefaulHotbarProfile = new HotbarProfileData
		{
			Rows = 1,
			SlotsPerRow = hotbarAssignments.First().Slots.Count,
			Hotbars = hotbarAssignments,
			HideLeftNav = false,
			CombatMode = true,
			Scale = 100,
			NextRewiredActionId = RewiredConstants.ActionSlots.NextHotbarAction.id,
			NextRewiredActionName = RewiredConstants.ActionSlots.NextHotbarAction.name,
			PrevRewiredActionId = RewiredConstants.ActionSlots.PreviousHotbarAction.id,
			PrevRewiredActionName = RewiredConstants.ActionSlots.PreviousHotbarAction.name
		};
	}
	internal class InventorySettings
	{
		public const int MaxSetItemID = -1310000000;

		public const int MinSetItemID = -1319999999;

		public const int MaxItemID = -1320000000;

		public const int MinItemID = -1329999999;

		public const string MoveToStashKey = "Context_Item_MoveToStash";

		public static readonly HashSet<AreaEnum> StashAreas = new HashSet<AreaEnum>
		{
			(AreaEnum)100,
			(AreaEnum)200,
			(AreaEnum)500,
			(AreaEnum)300,
			(AreaEnum)400,
			(AreaEnum)601
		};
	}
	internal static class RewiredConstants
	{
		public static class ActionMenus
		{
			public const int CategoryMapId = 130000;

			public static InputMapCategory CategoryMap;

			public const int ActionCategoryId = 130001;

			public static InputCategory ActionCategory;

			static ActionMenus()
			{
				CategoryMap = GetMapCategory("ActionMenus", "ActionMenus", 130000, userAssignable: true);
				ActionCategory = GetActionCategory("ActionMenus", "ActionMenus", 130001, userAssignable: true);
			}
		}

		public static class ActionSlots
		{
			public const int CategoryMapId = 131000;

			public static InputMapCategory CategoryMap;

			public const int ActionCategoryId = 131001;

			public static InputCategory ActionCategory;

			public static List<InputAction> Actions;

			public static List<InputAction> HotbarNavActions;

			public const string NameFormat = "ActionSlot_00";

			public const string NavNameFormat = "Hotbar_00";

			public static InputAction NextHotbarAction;

			public static InputAction PreviousHotbarAction;

			public static InputAction NextHotbarAxisAction;

			public static InputAction PreviousHotbarAxisAction;

			public const string SelectHotbarNameFormat = "SelectHotbar_00";

			public static readonly string DefaultKeyboardMapFile;

			public static readonly string DefaultMouseMapFile;

			public static readonly string DefaultJoystickMapFile;

			static ActionSlots()
			{
				DefaultKeyboardMapFile = Path.Combine(ActionUISettings.PluginPath, "Profiles", "Default", "Default-Keyboard-Map_ActionSlots.xml");
				DefaultMouseMapFile = Path.Combine(ActionUISettings.PluginPath, "Profiles", "Default", "Default-Mouse-Map_ActionSlots.xml");
				DefaultJoystickMapFile = string.Empty;
				CategoryMap = GetMapCategory("ActionSlots", "ActionSlots", 131000, userAssignable: true);
				ActionCategory = GetActionCategory("ActionSlots", "ActionSlots", 131001, userAssignable: true);
				Actions = GetSlotsActions("ActionSlot_00", "Action Slot ##0", (InputActionType)1, userAssignable: true, ActionCategory.id, 131500, 64);
				HotbarNavActions = GetHotbarNavActions("Hotbar_00", "Hotbar ##0", (InputActionType)1, userAssignable: true, ActionCategory.id, 131200, 64);
				NextHotbarAction = GetAction(131100, "NextHotbar", "Next Hotbar", (InputActionType)1, userAssignable: true, ActionCategory.id);
				PreviousHotbarAction = GetAction(131101, "PreviousHotbar", "Previous Hotbar", (InputActionType)1, userAssignable: true, ActionCategory.id);
				NextHotbarAxisAction = GetAction(131102, "NextHotbar+", "Next Hotbar", (InputActionType)0, userAssignable: true, ActionCategory.id);
				PreviousHotbarAxisAction = GetAction(131103, "PreviousHotbar-", "Previous Hotbar", (InputActionType)0, userAssignable: true, ActionCategory.id);
				HotbarNavActions.Add(NextHotbarAction);
				HotbarNavActions.Add(PreviousHotbarAction);
				HotbarNavActions.Add(NextHotbarAxisAction);
				HotbarNavActions.Add(PreviousHotbarAxisAction);
			}
		}

		private static InputMapCategory GetMapCategory(string name, string descriptiveName, int id, bool userAssignable)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			InputMapCategory val = new InputMapCategory();
			ReflectionExtensions.SetPrivateField<InputMapCategory, string>(val, "_name", name);
			ReflectionExtensions.SetPrivateField<InputMapCategory, string>(val, "_descriptiveName", descriptiveName);
			ReflectionExtensions.SetPrivateField<InputMapCategory, int>(val, "_id", id);
			ReflectionExtensions.SetPrivateField<InputMapCategory, bool>(val, "_userAssignable", userAssignable);
			return val;
		}

		private static InputCategory GetActionCategory(string name, string descriptiveName, int id, bool userAssignable)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			InputCategory val = new InputCategory();
			ReflectionExtensions.SetPrivateField<InputCategory, string>(val, "_name", name);
			ReflectionExtensions.SetPrivateField<InputCategory, string>(val, "_descriptiveName", descriptiveName);
			ReflectionExtensions.SetPrivateField<InputCategory, int>(val, "_id", id);
			ReflectionExtensions.SetPrivateField<InputCategory, bool>(val, "_userAssignable", userAssignable);
			return val;
		}

		private static List<InputAction> GetSlotsActions(string nameFormat, string descriptiveNameFormat, InputActionType inputActionType, bool userAssignable, int actionCategoryId, int startingId, int amount)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			List<InputAction> list = new List<InputAction>();
			for (int i = 0; i < amount; i++)
			{
				int num = i + 1;
				InputAction action = GetAction(i + startingId, num.ToString(nameFormat), num.ToString(descriptiveNameFormat), inputActionType, userAssignable, actionCategoryId);
				list.Add(action);
			}
			return list;
		}

		private static List<InputAction> GetHotbarNavActions(string nameFormat, string descriptiveNameFormat, InputActionType inputActionType, bool userAssignable, int actionCategoryId, int startingId, int amount)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			List<InputAction> list = new List<InputAction>();
			for (int i = 0; i < amount; i++)
			{
				int num = i + 1;
				InputAction action = GetAction(i + startingId, num.ToString(nameFormat), num.ToString(descriptiveNameFormat), inputActionType, userAssignable, actionCategoryId);
				list.Add(action);
			}
			return list;
		}

		public static InputAction GetAction(int id, string name, string descriptiveName, InputActionType inputActionType, bool userAssignable, int actionCategoryId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			InputAction val = new InputAction();
			ReflectionExtensions.SetPrivateField<InputAction, int>(val, "_id", id);
			ReflectionExtensions.SetPrivateField<InputAction, string>(val, "_name", name);
			ReflectionExtensions.SetPrivateField<InputAction, string>(val, "_descriptiveName", descriptiveName);
			ReflectionExtensions.SetPrivateField<InputAction, InputActionType>(val, "_type", inputActionType);
			ReflectionExtensions.SetPrivateField<InputAction, bool>(val, "_userAssignable", userAssignable);
			ReflectionExtensions.SetPrivateField<InputAction, int>(val, "_categoryId", actionCategoryId);
			return val;
		}
	}
	internal class SettingsService
	{
		private readonly ConfigManagerService _configManagerService;

		private readonly ConfigSettingsService _configService;

		private readonly string _minConfigVersion;

		private readonly IModifLogger _logger = LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public SettingsService(BaseUnityPlugin plugin, string minConfigVersion)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			_logger.LogTrace("SettingsService() plugin is " + (((Object)(object)plugin == (Object)null) ? "null" : "not null") + ". minConfigVersion: " + minConfigVersion);
			ConfigManagerService configManagerService = new ConfigManagerService(plugin);
			ConfigSettingsService configService = new ConfigSettingsService(plugin);
			_configManagerService = configManagerService;
			_configService = configService;
			_minConfigVersion = minConfigVersion;
		}

		public ConfigSettings ConfigureSettings()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			ConfigSettings settings = new ConfigSettings();
			if (!MeetsMinimumVersion(_minConfigVersion))
			{
			}
			_configService.BindConfigSetting<LogLevel>(settings.LogLevel, (Action<SettingValueChangedArgs<LogLevel>>)delegate
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				LoggerFactory.ConfigureLogger("ModifAmorphic.Outward.ActionUI", "Action Bar", settings.LogLevel.Value);
			}, false, false);
			LoggerFactory.ConfigureLogger("ModifAmorphic.Outward.ActionUI", "Action Bar", settings.LogLevel.Value);
			_configService.BindConfigSetting<string>(settings.ConfigVersion, (Action<SettingValueChangedArgs<string>>)null, false, false);
			return settings;
		}

		private bool MeetsMinimumVersion(string minimumVersion)
		{
			string text = _configService.PeekSavedConfigValue<string>(new ConfigSettings().ConfigVersion);
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			if (!Version.TryParse(text, out Version result) || !Version.TryParse(minimumVersion, out Version result2))
			{
				return false;
			}
			_logger.LogDebug(string.Format("Current Config {0}? {1}. Compared: ", "MeetsMinimumVersion", result.CompareTo(result2) >= 0) + $"ConfigVersion: {result} to MinimumVersion: {result2}");
			return result.CompareTo(result2) >= 0;
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Plugin.Services
{
	internal class RewiredListener
	{
		private readonly ConfigSettings _settings;

		private readonly Func<IModifLogger> _getLogger;

		private readonly BaseUnityPlugin _baseUnityPlugin;

		private readonly LevelCoroutines _coroutine;

		private IModifLogger Logger => _getLogger();

		public RewiredListener(BaseUnityPlugin baseUnityPlugin, LevelCoroutines coroutine, ConfigSettings settings, Func<IModifLogger> getLogger)
		{
			_baseUnityPlugin = baseUnityPlugin;
			_coroutine = coroutine;
			_settings = settings;
			_getLogger = getLogger;
			InputManager_BasePatches.BeforeInitialize += InitializeActonMenus;
		}

		private void InitializeActonMenus(InputManager_Base inputManager)
		{
			ActionCategoryMap privateField = ReflectionExtensions.GetPrivateField<UserData, ActionCategoryMap>(inputManager.userData, "actionCategoryMap");
			ReflectionExtensions.GetPrivateField<UserData, List<InputMapCategory>>(inputManager.userData, "mapCategories").Add(RewiredConstants.ActionMenus.CategoryMap);
			ReflectionExtensions.GetPrivateField<UserData, List<InputCategory>>(inputManager.userData, "actionCategories").Add(RewiredConstants.ActionMenus.ActionCategory);
			privateField.AddCategory(RewiredConstants.ActionMenus.ActionCategory.id);
			ReflectionExtensions.GetPrivateField<UserData, List<InputMapCategory>>(inputManager.userData, "mapCategories").Add(RewiredConstants.ActionSlots.CategoryMap);
			ReflectionExtensions.GetPrivateField<UserData, List<InputCategory>>(inputManager.userData, "actionCategories").Add(RewiredConstants.ActionSlots.ActionCategory);
			ReflectionExtensions.GetPrivateField<UserData, ActionCategoryMap>(inputManager.userData, "actionCategoryMap").AddCategory(RewiredConstants.ActionSlots.ActionCategory.id);
			List<InputAction> privateField2 = ReflectionExtensions.GetPrivateField<UserData, List<InputAction>>(inputManager.userData, "actions");
			foreach (InputAction action in RewiredConstants.ActionSlots.Actions)
			{
				Logger.LogDebug($"Adding action {action.name} with id {action.id}");
				ReflectionExtensions.GetPrivateField<UserData, List<InputAction>>(inputManager.userData, "actions").Add(action);
				ReflectionExtensions.GetPrivateField<UserData, ActionCategoryMap>(inputManager.userData, "actionCategoryMap").AddAction(action.categoryId, action.id);
			}
			foreach (InputAction hotbarNavAction in RewiredConstants.ActionSlots.HotbarNavActions)
			{
				Logger.LogDebug($"Adding hotbar nav action {hotbarNavAction.name} with id {hotbarNavAction.id}");
				ReflectionExtensions.GetPrivateField<UserData, List<InputAction>>(inputManager.userData, "actions").Add(hotbarNavAction);
				ReflectionExtensions.GetPrivateField<UserData, ActionCategoryMap>(inputManager.userData, "actionCategoryMap").AddAction(hotbarNavAction.categoryId, hotbarNavAction.id);
			}
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Services
{
	internal class ControllerMapService : IDisposable
	{
		public class MouseButton
		{
			public KeyCode KeyCode { get; set; }

			public int elementIdentifierId { get; set; }

			public string DisplayName { get; set; }
		}

		private readonly Func<IModifLogger> _getLogger;

		private readonly HotkeyCaptureMenu _captureDialog;

		private readonly IHotbarProfileService _hotbarProfileService;

		private readonly IActionUIProfileService _profileService;

		private readonly HotbarService _hotbarService;

		private readonly Player _player;

		private readonly ModifCoroutine _coroutine;

		private const string KeyboardMapFile = "KeyboardMap_ActionSlots.xml";

		private const string MouseMapFile = "Mouse_ActionSlots.xml";

		private const string JoystickMapFile = "Joystick_ActionSlots.xml";

		private static Dictionary<ControllerType, string> MapFiles = new Dictionary<ControllerType, string>
		{
			{
				(ControllerType)0,
				"KeyboardMap_ActionSlots.xml"
			},
			{
				(ControllerType)1,
				"Mouse_ActionSlots.xml"
			},
			{
				(ControllerType)2,
				"Joystick_ActionSlots.xml"
			}
		};

		public static Dictionary<KeyCode, MouseButton> MouseButtons = new Dictionary<KeyCode, MouseButton>
		{
			{
				(KeyCode)0,
				new MouseButton
				{
					KeyCode = (KeyCode)0,
					elementIdentifierId = -1,
					DisplayName = string.Empty
				}
			},
			{
				(KeyCode)323,
				new MouseButton
				{
					KeyCode = (KeyCode)323,
					elementIdentifierId = 3,
					DisplayName = "LMB"
				}
			},
			{
				(KeyCode)324,
				new MouseButton
				{
					KeyCode = (KeyCode)324,
					elementIdentifierId = 4,
					DisplayName = "RMB"
				}
			},
			{
				(KeyCode)325,
				new MouseButton
				{
					KeyCode = (KeyCode)325,
					elementIdentifierId = 5,
					DisplayName = "MB 3"
				}
			},
			{
				(KeyCode)326,
				new MouseButton
				{
					KeyCode = (KeyCode)326,
					elementIdentifierId = 6,
					DisplayName = "MB 4"
				}
			},
			{
				(KeyCode)327,
				new MouseButton
				{
					KeyCode = (KeyCode)327,
					elementIdentifierId = 7,
					DisplayName = "MB 5"
				}
			},
			{
				(KeyCode)328,
				new MouseButton
				{
					KeyCode = (KeyCode)328,
					elementIdentifierId = 8,
					DisplayName = "MB 6"
				}
			}
		};

		public static Dictionary<int, MouseButton> MouseButtonElementIds = new Dictionary<int, MouseButton>
		{
			{
				2,
				new MouseButton
				{
					KeyCode = (KeyCode)325,
					elementIdentifierId = 2,
					DisplayName = "Wheel"
				}
			},
			{
				3,
				new MouseButton
				{
					KeyCode = (KeyCode)323,
					elementIdentifierId = 3,
					DisplayName = "LMB"
				}
			},
			{
				4,
				new MouseButton
				{
					KeyCode = (KeyCode)324,
					elementIdentifierId = 4,
					DisplayName = "RMB"
				}
			},
			{
				5,
				new MouseButton
				{
					KeyCode = (KeyCode)325,
					elementIdentifierId = 5,
					DisplayName = "MB 3"
				}
			},
			{
				6,
				new MouseButton
				{
					KeyCode = (KeyCode)326,
					elementIdentifierId = 6,
					DisplayName = "MB 4"
				}
			},
			{
				7,
				new MouseButton
				{
					KeyCode = (KeyCode)327,
					elementIdentifierId = 7,
					DisplayName = "MB 5"
				}
			},
			{
				8,
				new MouseButton
				{
					KeyCode = (KeyCode)328,
					elementIdentifierId = 8,
					DisplayName = "MB 6"
				}
			}
		};

		private bool disposedValue;

		private static readonly HashSet<KeyCode> MouseKeyCodes = new HashSet<KeyCode>
		{
			(KeyCode)323,
			(KeyCode)324,
			(KeyCode)325,
			(KeyCode)326,
			(KeyCode)327,
			(KeyCode)328,
			(KeyCode)329
		};

		private IModifLogger Logger => _getLogger();

		public ControllerMapService(HotkeyCaptureMenu captureDialog, IHotbarProfileService hotbarProfileService, IActionUIProfileService profileService, HotbarService hotbarService, Player player, ModifCoroutine coroutine, Func<IModifLogger> getLogger)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			_captureDialog = captureDialog;
			_hotbarService = hotbarService;
			_player = player;
			_coroutine = coroutine;
			_getLogger = getLogger;
			_hotbarProfileService = hotbarProfileService;
			_profileService = profileService;
			RewiredInputsPatches.AfterSaveAllMaps += TryRemoveActionUIMaps;
			RewiredInputsPatches.AfterExportXmlData += RewiredInputsPatches_AfterExportXmlData;
			_hotbarProfileService.OnProfileChanged += SlotAmountChanged;
			_captureDialog.OnKeysSelected += new OnKeysSelectedDelegate(CaptureDialog_OnKeysSelected);
		}

		private void RewiredInputsPatches_AfterExportXmlData(int playerId)
		{
			if (playerId == _player.id)
			{
				LoadConfigMaps(forceRefresh: true);
			}
		}

		private void TryRemoveActionUIMaps(RewiredInputs rewiredInputs)
		{
			try
			{
				if (rewiredInputs.PlayerID != _player.id)
				{
					return;
				}
				Dictionary<string, string> privateField = ReflectionExtensions.GetPrivateField<RewiredInputs, Dictionary<string, string>>(rewiredInputs, "m_mappingData");
				List<string> list = privateField.Keys.Where((string k) => UnityEngineExtensions.Contains(k, "categoryId=131000", StringComparison.InvariantCultureIgnoreCase)).ToList();
				foreach (string item in list)
				{
					try
					{
						if (privateField.Remove(item))
						{
							Logger.LogDebug("Removed ControllerMap '" + item + "'.");
						}
						else
						{
							Logger.LogWarning("Failed to remove ControllerMap '" + item + "'.");
						}
					}
					catch (Exception ex)
					{
						Logger.LogException("Exception removing ControllerMap '" + item + "'", ex);
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.LogException($"Failed to remove ActionUI Controller maps for player ID {rewiredInputs.PlayerID}.", ex2);
			}
		}

		public (KeyboardMap keyboardMap, MouseMap mouseMap) LoadConfigMaps(bool forceRefresh = false)
		{
			(KeyboardMap, MouseMap) result = (GetActionSlotsMap<KeyboardMap>(forceRefresh), GetActionSlotsMap<MouseMap>(forceRefresh));
			if (forceRefresh)
			{
				_hotbarService.TryConfigureHotbars(_hotbarProfileService.GetProfile());
			}
			return result;
		}

		public void Save()
		{
			var (controllerMap, controllerMap2) = LoadConfigMaps();
			SaveControllerMap((ControllerMap)(object)controllerMap);
			SaveControllerMap((ControllerMap)(object)controllerMap2);
			ControlsInput.ExportXmlData(_player.id);
		}

		private void CaptureDialog_OnKeysSelected(int slotIndex, HotkeyCategories category, KeyGroup keyGroup)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Invalid comparison between Unknown and I4
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Invalid comparison between Unknown and I4
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Invalid comparison between Unknown and I4
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Invalid comparison between Unknown and I4
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			(KeyboardMap keyboardMap, MouseMap mouseMap) tuple = LoadConfigMaps();
			KeyboardMap item = tuple.keyboardMap;
			MouseMap item2 = tuple.mouseMap;
			List<ControllerMap> list = new List<ControllerMap>();
			string keyName = Keyboard.GetKeyName(keyGroup.KeyCode, GetModifierKeyFlags(keyGroup.Modifiers));
			Logger.LogDebug($"KeyCode {keyGroup.KeyCode} has Keyboard KeyName {keyName}.");
			ControllerType controllerType;
			if (!string.IsNullOrWhiteSpace(keyName) && !MouseKeyCodes.Contains(keyGroup.KeyCode))
			{
				controllerType = (ControllerType)0;
			}
			else
			{
				if (!MouseKeyCodes.Contains(keyGroup.KeyCode))
				{
					return;
				}
				controllerType = (ControllerType)1;
			}
			list.Add((ControllerMap)(object)item);
			list.Add((ControllerMap)(object)item2);
			if ((int)category == 1)
			{
				SetActionSlotHotkey(slotIndex, keyGroup, controllerType, list);
			}
			else if ((int)category == 4)
			{
				SetHotbarHotkey(slotIndex, keyGroup, controllerType, list);
			}
			else if ((int)category == 3 || (int)category == 2)
			{
				SetHotbarNavHotkey(category, keyGroup, controllerType, list);
			}
		}

		private void SlotAmountChanged(IHotbarProfile hotbarProfile, HotbarProfileChangeTypes changeType)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if (hotbarProfile.Rows != 1)
			{
				if ((int)changeType == 5)
				{
					ShiftActionSlotsForward(hotbarProfile);
				}
				else if ((int)changeType == 6)
				{
					ShiftActionSlotsBack(hotbarProfile);
				}
			}
		}

		private void ShiftActionSlotsForward(IHotbarProfile hotbarProfile)
		{
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			(KeyboardMap keyboardMap, MouseMap mouseMap) tuple = LoadConfigMaps();
			KeyboardMap item = tuple.keyboardMap;
			MouseMap item2 = tuple.mouseMap;
			List<ControllerMap> list = new List<ControllerMap>
			{
				(ControllerMap)(object)item,
				(ControllerMap)(object)item2
			};
			int index = hotbarProfile.SlotsPerRow - 1;
			int num = hotbarProfile.Rows * hotbarProfile.SlotsPerRow;
			List<IHotbarSlotData> hotbars = hotbarProfile.Hotbars;
			int num2 = hotbarProfile.Rows - 1;
			ElementAssignment assignment = default(ElementAssignment);
			for (int num3 = num2; num3 > 0; num3--)
			{
				int num4 = num3 * hotbarProfile.SlotsPerRow;
				int num5 = (num3 + 1) * hotbarProfile.SlotsPerRow - 1;
				for (int num6 = num5; num6 >= num4; num6--)
				{
					ActionConfig actionConfig = hotbars[0].Slots[num6].Config as ActionConfig;
					ControllerType val = (ControllerType)0;
					int previousActionId = ((ActionConfig)(object)hotbars[0].Slots[num6].Config).RewiredActionId - num3;
					ActionElementMap val2 = ((IEnumerable<ActionElementMap>)((ControllerMap)item).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == previousActionId));
					ControllerMap map = (ControllerMap)(object)item;
					if (val2 == null || num6 == num5)
					{
						((ElementAssignment)(ref assignment))..ctor(val, (ControllerElementType)1, -1, (AxisRange)1, (KeyCode)0, (ModifierKeyFlags)0, actionConfig.RewiredActionId, (Pole)0, false);
					}
					else
					{
						((ElementAssignment)(ref assignment))..ctor(val, (ControllerElementType)1, val2.elementIdentifierId, (AxisRange)1, val2.keyCode, val2.modifierKeyFlags, actionConfig.RewiredActionId, (Pole)0, false);
					}
					ConfigureButtonMapping(assignment, val, map, out var hotkeyText);
					actionConfig.HotkeyText = hotkeyText;
				}
			}
			ActionConfig actionConfig2 = hotbars[0].Slots[index].Config as ActionConfig;
			ConfigureButtonMapping(new ElementAssignment((KeyCode)0, (ModifierKeyFlags)0, actionConfig2.RewiredActionId, (Pole)0, -1), (ControllerType)0, (ControllerMap)(object)item, out var hotkeyText2);
			ConfigureButtonMapping(new ElementAssignment((KeyCode)0, (ModifierKeyFlags)0, actionConfig2.RewiredActionId, (Pole)0, -1), (ControllerType)0, (ControllerMap)(object)item2, out hotkeyText2);
			actionConfig2.HotkeyText = string.Empty;
			for (int i = 1; i < hotbars.Count; i++)
			{
				for (int j = 0; j < hotbars[i].Slots.Count; j++)
				{
					hotbars[i].Slots[j].Config.HotkeyText = hotbars[0].Slots[j].Config.HotkeyText;
				}
			}
			SaveControllerMap((ControllerMap)(object)item);
			SaveControllerMap((ControllerMap)(object)item2);
		}

		private void ShiftActionSlotsBack(IHotbarProfile hotbarProfile)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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_010c: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			(KeyboardMap keyboardMap, MouseMap mouseMap) tuple = LoadConfigMaps();
			KeyboardMap item = tuple.keyboardMap;
			MouseMap item2 = tuple.mouseMap;
			List<ControllerMap> list = new List<ControllerMap>
			{
				(ControllerMap)(object)item,
				(ControllerMap)(object)item2
			};
			List<IHotbarSlotData> hotbars = hotbarProfile.Hotbars;
			ElementAssignment assignment = default(ElementAssignment);
			for (int i = 1; i < hotbarProfile.Rows; i++)
			{
				int num = i * hotbarProfile.SlotsPerRow;
				int num2 = (i + 1) * hotbarProfile.SlotsPerRow - 1;
				for (int j = num; j <= num2; j++)
				{
					ActionConfig actionConfig = hotbars[0].Slots[j].Config as ActionConfig;
					int nextActionId = ((ActionConfig)(object)hotbars[0].Slots[j].Config).RewiredActionId + i;
					ControllerType val = (ControllerType)0;
					ActionElementMap val2 = ((IEnumerable<ActionElementMap>)((ControllerMap)item).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == nextActionId));
					ControllerMap map = (ControllerMap)(object)item;
					if (val2 == null)
					{
						val2 = ((IEnumerable<ActionElementMap>)((ControllerMap)item2).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == nextActionId));
						val = (ControllerType)1;
						map = (ControllerMap)(object)item2;
					}
					if (val2 == null)
					{
						((ElementAssignment)(ref assignment))..ctor(val, (ControllerElementType)1, -1, (AxisRange)1, (KeyCode)0, (ModifierKeyFlags)0, actionConfig.RewiredActionId, (Pole)0, false);
					}
					else
					{
						((ElementAssignment)(ref assignment))..ctor(val, (ControllerElementType)1, val2.elementIdentifierId, (AxisRange)1, val2.keyCode, val2.modifierKeyFlags, actionConfig.RewiredActionId, (Pole)0, false);
					}
					ConfigureButtonMapping(assignment, val, map, out var hotkeyText);
					actionConfig.HotkeyText = hotkeyText;
				}
			}
			for (int k = 1; k < hotbars.Count; k++)
			{
				for (int l = 0; l < hotbars[k].Slots.Count; l++)
				{
					hotbars[k].Slots[l].Config.HotkeyText = hotbars[0].Slots[l].Config.HotkeyText;
				}
			}
			SaveControllerMap((ControllerMap)(object)item);
			SaveControllerMap((ControllerMap)(object)item2);
		}

		private void SetActionSlotHotkey(int slotIndex, KeyGroup keyGroup, ControllerType controllerType, List<ControllerMap> maps)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogDebug($"Setting ActionSlot Hotkey for Slot Index {slotIndex} to KeyCode {keyGroup.KeyCode}.");
			IHotbarProfile profile = _hotbarProfileService.GetProfile();
			List<IHotbarSlotData> hotbars = profile.Hotbars;
			ActionConfig actionConfig = (ActionConfig)(object)hotbars[0].Slots[slotIndex].Config;
			ConfigureButtonMapping(actionConfig.RewiredActionId, keyGroup, controllerType, maps, out var hotkeyText);
			for (int i = 0; i < hotbars.Count; i++)
			{
				hotbars[i].Slots[slotIndex].Config.HotkeyText = hotkeyText;
				Logger.LogDebug($"Setting Hotkey to '{hotkeyText}' for hotbar {i}, slot {slotIndex}.");
			}
			_hotbarProfileService.Save();
			_hotbarService.TryConfigureHotbars(profile);
		}

		private void SetHotbarHotkey(int id, KeyGroup keyGroup, ControllerType controllerType, IEnumerable<ControllerMap> maps)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogDebug($"Setting Hotbar Hotkey for Bar Index {id}.");
			IHotbarProfile profile = _hotbarProfileService.GetProfile();
			HotbarData hotbarData = (HotbarData)(object)profile.Hotbars[id];
			ConfigureButtonMapping(hotbarData.RewiredActionId, keyGroup, controllerType, maps, out var hotkeyText);
			hotbarData.HotbarHotkey = hotkeyText;
			_hotbarProfileService.Save();
			_hotbarService.TryConfigureHotbars(profile);
		}

		private void SetHotbarNavHotkey(HotkeyCategories category, KeyGroup keyGroup, ControllerType controllerType, IEnumerable<ControllerMap> maps)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			HotbarProfileData hotbarProfileData = (HotbarProfileData)(object)_hotbarProfileService.GetProfile();
			int rewiredActionId = (((int)category == 3) ? hotbarProfileData.NextRewiredActionId : hotbarProfileData.PrevRewiredActionId);
			if ((int)keyGroup.KeyCode == 325 && (int)keyGroup.AxisDirection > 0)
			{
				rewiredActionId = (((int)category == 3) ? hotbarProfileData.NextRewiredAxisActionId : hotbarProfileData.PrevRewiredAxisActionId);
			}
			ConfigureButtonMapping(rewiredActionId, keyGroup, controllerType, maps, out var hotkeyText);
			if ((int)category == 3)
			{
				hotbarProfileData.NextHotkey = hotkeyText;
				Logger.LogDebug("Setting NextHotkey text to " + hotkeyText + ".");
			}
			else
			{
				Logger.LogDebug("Setting PrevHotkey text to " + hotkeyText + ".");
				hotbarProfileData.PrevHotkey = hotkeyText;
			}
			_hotbarProfileService.Save();
			_hotbarService.TryConfigureHotbars((IHotbarProfile)(object)hotbarProfileData);
		}

		private void ConfigureButtonMapping(int rewiredActionId, KeyGroup keyGroup, ControllerType controllerType, IEnumerable<ControllerMap> maps, out string hotkeyText)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_002e: 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_0037: Invalid comparison between Unknown and I4
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Invalid comparison between Unknown and I4
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Invalid comparison between Unknown and I4
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Invalid comparison between Unknown and I4
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_0071: Invalid comparison between Unknown and I4
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			hotkeyText = string.Empty;
			ElementAssignment assignment = default(ElementAssignment);
			foreach (ControllerMap map in maps)
			{
				int num = -1;
				AxisRange val = (AxisRange)(((int)keyGroup.AxisDirection != 2) ? 1 : 2);
				Pole val2 = (Pole)((int)keyGroup.AxisDirection == 2);
				if (map.controllerType == controllerType)
				{
					if ((int)controllerType == 1)
					{
						num = (((int)keyGroup.KeyCode != 325 || (int)keyGroup.AxisDirection <= 0) ? MouseButtons[keyGroup.KeyCode].elementIdentifierId : 2);
					}
					Logger.LogDebug($"Configuring Button Mapping for ControllerType {map.controllerType} and actionId {rewiredActionId}. Setting elementIdentifierId to {num}.  Keycode is {keyGroup.KeyCode}");
					if ((int)keyGroup.AxisDirection == 0)
					{
						((ElementAssignment)(ref assignment))..ctor(map.controllerType, (ControllerElementType)1, num, (AxisRange)1, keyGroup.KeyCode, GetModifierKeyFlags(keyGroup.Modifiers), rewiredActionId, (Pole)0, false);
					}
					else
					{
						((ElementAssignment)(ref assignment))..ctor(map.controllerType, (ControllerElementType)0, num, val, keyGroup.KeyCode, GetModifierKeyFlags(keyGroup.Modifiers), rewiredActionId, val2, false);
					}
				}
				else
				{
					Logger.LogDebug($"Configuring Removal Button Mapping for ControllerType {map.controllerType} and actionId {rewiredActionId}.");
					((ElementAssignment)(ref assignment))..ctor(map.controllerType, (ControllerElementType)1, num, (AxisRange)1, (KeyCode)0, (ModifierKeyFlags)0, rewiredActionId, (Pole)0, false);
				}
				ConfigureButtonMapping(assignment, controllerType, map, out var hotkeyText2);
				if (!string.IsNullOrWhiteSpace(hotkeyText2))
				{
					hotkeyText = hotkeyText2;
				}
				SaveControllerMap(map);
			}
		}

		private void ConfigureButtonMapping(ElementAssignment assignment, ControllerType controllerType, ControllerMap map, out string hotkeyText)
		{
			//IL_0007: 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)
			//IL_0035: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Invalid comparison between Unknown and I4
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Invalid comparison between Unknown and I4
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Invalid comparison between Unknown and I4
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Invalid comparison between Unknown and I4
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Invalid comparison between Unknown and I4
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Invalid comparison between Unknown and I4
			hotkeyText = string.Empty;
			List<ActionElementMap> maps = map.AllMaps.Where((ActionElementMap m) => m.actionId == assignment.actionId).ToList();
			AddHotbarNavMaps(assignment, map, ref maps);
			if (maps.Any())
			{
				for (int i = 0; i < maps.Count; i++)
				{
					if (map.DeleteElementMap(maps[i].id))
					{
						Logger.LogDebug($"Deleted existing map {maps[i].id} for rewiredId {assignment.actionId}.");
					}
				}
			}
			RemoveExistingAssignments(assignment, map);
			if (map.controllerType != controllerType)
			{
				return;
			}
			if ((int)assignment.keyboardKey != 0 || ((int)map.controllerType == 1 && MouseButtonElementIds.TryGetValue(assignment.elementIdentifierId, out var value) && (int)value.KeyCode > 0))
			{
				bool flag = map.ReplaceOrCreateElementMap(assignment);
				Logger.LogDebug($"Attempted replace or create element map {assignment.elementMapId} to use keyboardKey {assignment.keyboardKey} in {map.controllerType} ControllerMap {map.id}.  Result was {flag}");
			}
			ActionElementMap? obj = ((IEnumerable<ActionElementMap>)map.ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == assignment.actionId));
			hotkeyText = ((obj != null) ? obj.elementIdentifierName : null);
			if ((int)map.controllerType != 1 || !MouseButtonElementIds.TryGetValue(assignment.elementIdentifierId, out var value2))
			{
				return;
			}
			hotkeyText = value2.DisplayName;
			if ((int)value2.KeyCode == 325)
			{
				if ((int)assignment.axisRange == 1)
				{
					hotkeyText += "+";
				}
				else if ((int)assignment.axisRange == 2)
				{
					hotkeyText += "-";
				}
			}
		}

		private void RemoveExistingAssignments(ElementAssignment assignment, ControllerMap map)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			ElementAssignmentConflictCheck val = CreateConflictCheck(map, assignment);
			int num = map.RemoveElementAssignmentConflicts(val);
			Logger.LogDebug($"Removed {num} conflicts for key {assignment.keyboardKey} and modifiers {assignment.modifierKeyFlags}.");
		}

		private ElementAssignmentConflictCheck CreateConflictCheck(ControllerMap map, ElementAssignment assignment)
		{
			//IL_0003: 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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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)
			ElementAssignmentConflictCheck result = ((ElementAssignment)(ref assignment)).ToElementAssignmentConflictCheck();
			((ElementAssignmentConflictCheck)(ref result)).playerId = map.id;
			((ElementAssignmentConflictCheck)(ref result)).controllerType = map.controllerType;
			((ElementAssignmentConflictCheck)(ref result)).controllerId = map.controllerId;
			((ElementAssignmentConflictCheck)(ref result)).controllerMapId = map.id;
			((ElementAssignmentConflictCheck)(ref result)).controllerMapCategoryId = map.categoryId;
			return result;
		}

		private void AddHotbarNavMaps(ElementAssignment assignment, ControllerMap map, ref List<ActionElementMap> maps)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			if (assignment.actionId == RewiredConstants.ActionSlots.NextHotbarAction.id)
			{
				ActionElementMap val = ((IEnumerable<ActionElementMap>)map.AllMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == RewiredConstants.ActionSlots.NextHotbarAxisAction.id));
				if (val != null)
				{
					maps.Add(val);
				}
			}
			if (assignment.actionId == RewiredConstants.ActionSlots.PreviousHotbarAction.id)
			{
				ActionElementMap val2 = ((IEnumerable<ActionElementMap>)map.AllMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == RewiredConstants.ActionSlots.PreviousHotbarAxisAction.id));
				if (val2 != null)
				{
					maps.Add(val2);
				}
			}
			if (assignment.actionId == RewiredConstants.ActionSlots.NextHotbarAxisAction.id)
			{
				ActionElementMap val3 = ((IEnumerable<ActionElementMap>)map.AllMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == RewiredConstants.ActionSlots.NextHotbarAction.id));
				if (val3 != null)
				{
					maps.Add(val3);
				}
			}
			if (assignment.actionId == RewiredConstants.ActionSlots.PreviousHotbarAxisAction.id)
			{
				ActionElementMap val4 = ((IEnumerable<ActionElementMap>)map.AllMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == RewiredConstants.ActionSlots.PreviousHotbarAction.id));
				if (val4 != null)
				{
					maps.Add(val4);
				}
			}
		}

		private void SaveControllerMap(ControllerMap controllerMap)
		{
			//IL_000d: 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)
			string text = Path.Combine(GetProfileFolder(), MapFiles[controllerMap.controllerType]);
			Logger.LogInfo($"Saving Controller Map {((controllerMap != null) ? new ControllerType?(controllerMap.controllerType) : null)} to '{text}'.");
			string xml = controllerMap.ToXmlString();
			XmlDocument xmlDocument = new XmlDocument();
			xmlDocument.LoadXml(xml);
			using XmlTextWriter xmlTextWriter = new XmlTextWriter(text, Encoding.UTF8);
			xmlTextWriter.Formatting = Formatting.Indented;
			xmlTextWriter.Indentation = 4;
			xmlDocument.Save(xmlTextWriter);
			xmlTextWriter.Close();
		}

		private T GetActionSlotsMap<T>(bool forceRefresh) where T : ControllerMap
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			ControllerType val = (ControllerType)20;
			if (typeof(KeyboardMap).IsAssignableFrom(typeof(T)))
			{
				val = (ControllerType)0;
			}
			else if (typeof(MouseMap).IsAssignableFrom(typeof(T)))
			{
				val = (ControllerType)1;
			}
			else if (typeof(JoystickMap).IsAssignableFrom(typeof(T)))
			{
				val = (ControllerType)2;
			}
			Logger.LogDebug($"ActionSlots using {val} ControllerMap for player {_player.id}");
			if ((int)val == 20)
			{
				return default(T);
			}
			T map = _player.controllers.maps.GetMap<T>(0, 131000, 0);
			if (map != null && !forceRefresh)
			{
				Logger.LogDebug($"ActionSlots {val} ControllerMap found loaded for player {_player.id}");
				return map;
			}
			string keyMapFileXml = GetKeyMapFileXml(val);
			T val2 = (T)(object)ControllerMap.CreateFromXml(val, keyMapFileXml);
			if (map != null)
			{
				Logger.LogDebug($"Replacing ActionSlots {val} ControllerMap found loaded for player {_player.id}");
				_player.controllers.maps.RemoveMap<T>(0, ((ControllerMap)val2).id);
			}
			_player.controllers.maps.AddMap<T>(0, (ControllerMap)(object)val2);
			return val2;
		}

		private string GetKeyMapFileXml(ControllerType controllerType)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			HotbarProfileData hotbarProfileData = (HotbarProfileData)(object)_hotbarProfileService.GetProfile();
			string text;
			string text2;
			if ((int)controllerType == 0)
			{
				text = RewiredConstants.ActionSlots.DefaultKeyboardMapFile;
				text2 = Path.Combine(ActionUISettings.PluginPath, "Default-Keyboard-Map_ActionSlots.xml");
			}
			else if ((int)controllerType == 1)
			{
				text = RewiredConstants.ActionSlots.DefaultMouseMapFile;
				text2 = Path.Combine(ActionUISettings.PluginPath, "Default-Mouse-Map_ActionSlots.xml");
			}
			else
			{
				if ((int)controllerType != 2)
				{
					return string.Empty;
				}
				text = RewiredConstants.ActionSlots.DefaultJoystickMapFile;
				text2 = string.Empty;
			}
			string text3 = text;
			if (!File.Exists(text3) && !string.IsNullOrEmpty(text2) && File.Exists(text2))
			{
				Logger.LogDebug("Default keymap not found at '" + text + "', using fallback at '" + text2 + "'.");
				text3 = text2;
			}
			string text4 = text3;
			if (hotbarProfileData != null)
			{
				text4 = Path.Combine(GetProfileFolder(), MapFiles[controllerType]);
				if (!File.Exists(text4))
				{
					string directoryName = Path.GetDirectoryName(text4);
					if (!Directory.Exists(directoryName))
					{
						Directory.CreateDirectory(directoryName);
					}
					if (!File.Exists(text3))
					{
						Logger.LogWarning("No default keymap file found. Checked: '" + text + "' and '" + text2 + "'. Cannot create profile keymap.");
						return string.Empty;
					}
					File.Copy(text3, text4);
					Logger.LogDebug("Copied default keymap from '" + text3 + "' to '" + text4 + "'.");
				}
			}
			Logger.LogDebug($"Loading ActionSlots {controllerType} ControllerMap for player {_player.id} at location '{text4}'.");
			return File.ReadAllText(text4);
		}

		private string GetProfileFolder()
		{
			if (!Directory.Exists(ActionUISettings.GlobalKeymapsPath))
			{
				Directory.CreateDirectory(ActionUISettings.GlobalKeymapsPath);
			}
			return ActionUISettings.GlobalKeymapsPath;
		}

		private ModifierKeyFlags GetModifierKeyFlags(IEnumerable<KeyCode> modifiers)
		{
			//IL_0002: 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_0025: 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_0046: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			ModifierKeyFlags val = (ModifierKeyFlags)0;
			if (modifiers.Contains((KeyCode)307) || modifiers.Contains((KeyCode)308))
			{
				val = (ModifierKeyFlags)(val | 0xC);
			}
			if (modifiers.Contains((KeyCode)305) || modifiers.Contains((KeyCode)306))
			{
				val = (ModifierKeyFlags)(val | 3);
			}
			if (modifiers.Contains((KeyCode)303) || modifiers.Contains((KeyCode)304))
			{
				val = (ModifierKeyFlags)(val | 0x30);
			}
			return val;
		}

		protected virtual void Dispose(bool disposing)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				RewiredInputsPatches.AfterSaveAllMaps -= TryRemoveActionUIMaps;
				RewiredInputsPatches.AfterExportXmlData -= RewiredInputsPatches_AfterExportXmlData;
				if (_hotbarProfileService != null)
				{
					_hotbarProfileService.OnProfileChanged -= SlotAmountChanged;
				}
				if ((Object)(object)_captureDialog != (Object)null)
				{
					_captureDialog.OnKeysSelected -= new OnKeysSelectedDelegate(CaptureDialog_OnKeysSelected);
				}
			}
			disposedValue = true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	internal class HotbarKeyListener : IHotbarNavActions
	{
		private readonly Player _player;

		public HotbarKeyListener(Player player)
		{
			_player = player;
		}

		public bool IsNextRequested()
		{
			return _player.GetButtonDown(RewiredConstants.ActionSlots.NextHotbarAction.id) || !Mathf.Approximately(_player.GetAxis(RewiredConstants.ActionSlots.NextHotbarAxisAction.id), 0f);
		}

		public bool IsPreviousRequested()
		{
			return _player.GetButtonDown(RewiredConstants.ActionSlots.PreviousHotbarAction.id) || !Mathf.Approximately(_player.GetAxis(RewiredConstants.ActionSlots.PreviousHotbarAxisAction.id), 0f);
		}

		public bool IsHotbarRequested(out int hotbarIndex)
		{
			hotbarIndex = -1;
			if (!_player.GetAnyButtonDown())
			{
				return false;
			}
			for (int i = 0; i < RewiredConstants.ActionSlots.HotbarNavActions.Count; i++)
			{
				if (_player.GetButtonDown(RewiredConstants.ActionSlots.HotbarNavActions[i].id))
				{
					hotbarIndex = i;
					return true;
				}
			}
			return false;
		}
	}
	internal class HotbarService : IDisposable
	{
		private sealed class WeaponContextSnapshot
		{
			public int MainWeaponType { get; }

			public int OffWeaponType { get; }

			public string[] ResolveKeys { get; }

			public string EditKey { get; }

			public string Signature { get; }

			public WeaponContextSnapshot(int mainWeaponType, int offWeaponType, string[] resolveKeys, string editKey)
			{
				MainWeaponType = mainWeaponType;
				OffWeaponType = offWeaponType;
				ResolveKeys = resolveKeys ?? Array.Empty<string>();
				EditKey = editKey ?? GlobalHotbarService.GetBaselineContextKey();
				Signature = $"{MainWeaponType}|{OffWeaponType}";
			}
		}

		private readonly Func<IModifLogger> _getLogger;

		private readonly HotbarsContainer _hotbars;

		private readonly Player _player;

		private readonly Character _character;

		private readonly CharacterUI _characterUI;

		private readonly IHotbarProfileService _hotbarProfileService;

		private readonly IActionUIProfileService _profileService;

		private readonly SlotDataService _slotData;

		private readonly LevelCoroutines _levelCoroutines;

		private bool _saveDisabled;

		private bool _isProfileInit;

		private bool _isStarted = false;

		private string _activeContextSignature = string.Empty;

		private bool _pendingHotbarConfigRefresh;

		private const int NoWeaponType = -1;

		private const int OffhandNonWeaponContextOffset = 1000000;

		private const int MainNonWeaponContextOffset = 2000000;

		private bool disposedValue;

		private bool _isConfiguring = false;

		private IModifLogger Logger => _getLogger();

		public Guid InstanceID { get; } = Guid.NewGuid();


		public HotbarService(HotbarsContainer hotbarsContainer, Player player, Character character, IHotbarProfileService hotbarProfileService, IActionUIProfileService profileService, SlotDataService slotData, LevelCoroutines levelCoroutines, Func<IModifLogger> getLogger)
		{
			if ((Object)(object)hotbarsContainer == (Object)null)
			{
				throw new ArgumentNullException("hotbarsContainer");
			}
			if ((Object)(object)character == (Object)null)
			{
				throw new ArgumentNullException("character");
			}
			if (hotbarProfileService == null)
			{
				throw new ArgumentNullException("hotbarProfileService");
			}
			if (profileService == null)
			{
				throw new ArgumentNullException("profileService");
			}
			if (slotData == null)
			{
				throw new ArgumentNullException("slotData");
			}
			_hotbars = hotbarsContainer;
			_player = player;
			_character = character;
			_characterUI = character.CharacterUI;
			_hotbarProfileService = hotbarProfileService;
			_profileService = profileService;
			_slotData = slotData;
			_levelCoroutines = levelCoroutines;
			_getLogger = getLogger;
			QuickSlotPanelPatches.StartInitAfter += DisableKeyboardQuickslots;
			SkillMenuPatches.AfterOnSectionSelected += SetSkillsMovable;
			ItemDisplayDropGroundPatches.TryGetIsDropValids.Add(_player.id, TryGetIsDropValid);
			EquipmentPatches.AfterOnEquip += OnEquipmentChanged;
			EquipmentPatches.AfterOnUnequip += OnEquipmentChanged;
			_hotbars.OnAwake += StartNextFrame;
			if (_hotbars.IsAwake)
			{
				StartNextFrame();
			}
		}

		private void StartNextFrame()
		{
			try
			{
				((ModifCoroutine)_levelCoroutines).DoNextFrame((Action)delegate
				{
					Start();
				});
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to start HotbarService coroutine Start.", ex);
			}
		}

		public void Start()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_isStarted = true;
				_saveDisabled = true;
				SwapCanvasGroup();
				IHotbarProfile orCreateActiveProfile = GetOrCreateActiveProfile();
				if (_hotbarProfileService is GlobalHotbarService globalHotbarService)
				{
					globalHotbarService.LoadCharacterSlots(UID.op_Implicit(_character.UID));
				}
				TryConfigureHotbars(orCreateActiveProfile, (HotbarProfileChangeTypes)0);
				_hotbars.ClearChanges();
				_hotbarProfileService.OnProfileChanged += TryConfigureHotbars;
				_hotbars.OnHasChanges.AddListener(new UnityAction(Save));
				CharacterUIPatches.AfterRefreshHUDVisibility += ShowHideHotbars;
				AssignSlotActions();
				AssignSlotActions();
				EnsureNoWeaponDynamicPresetsInitialized();
				ApplyDynamicPresetsForCurrentWeapon(force: true);
				ShowHideHotbars(_characterUI);
				InitializePositionConfig();
				ActionUISettings.Rows.SettingChanged += OnHotbarConfigChanged;
				ActionUISettings.SlotsPerRow.SettingChanged += OnHotbarConfigChanged;
				ActionUISettings.Scale.SettingChanged += OnHotbarConfigChanged;
				ActionUISettings.HideLeftNav.SettingChanged += OnHotbarConfigChanged;
				ActionUISettings.CombatMode.SettingChanged += OnHotbarConfigChanged;
				ActionUISettings.ShowCooldownTimer.SettingChanged += OnHotbarConfigChanged;
				ActionUISettings.PreciseCooldownTime.SettingChanged += OnHotbarConfigChanged;
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to start HotbarService.", ex);
			}
		}

		private void ShowHideHotbars(CharacterUI characterui)
		{
			//IL_0007: 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)
			if (!(characterui.TargetCharacter.UID != _character.UID))
			{
				int num = UnityEngineExtensions.ToInt(OptionManager.Instance.GetHudVisibility(_character.OwnerPlayerSys.PlayerID));
				((Component)_hotbars.ActionBarsCanvas).GetComponent<CanvasGroup>().alpha = num;
			}
		}

		private void SetSkillsMovable(ItemListDisplay itemListDisplay)
		{
			IActionUIProfile activeProfile = _profileService.GetActiveProfile();
			if (activeProfile == null || activeProfile.ActionSlotsEnabled)
			{
				ItemDisplay[] componentsInChildren = ((Component)itemListDisplay).GetComponentsInChildren<ItemDisplay>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].Movable = true;
				}
			}
		}

		private bool TryGetIsDropValid(ItemDisplay draggedDisplay, Character character, out bool result)
		{
			result = false;
			if (!((Object)(object)((draggedDisplay != null) ? draggedDisplay.RefItem : null) == (Object)null))
			{
				Item refItem = draggedDisplay.RefItem;
				Skill val = (Skill)(object)((refItem is Skill) ? refItem : null);
				if (val != null)
				{
					Logger.LogDebug("TryGetIsDropValid:: Blocking drop of skill " + ((Object)val).name + " to DropPanel.");
					return true;
				}
			}
			return false;
		}

		public void TryConfigureHotbars(IHotbarProfile profile)
		{
			try
			{
				if (!_hotbars.IsAwake || !_isStarted)
				{
					return;
				}
				Character character = _character;
				if ((Object)(object)((character != null) ? character.Inventory : null) == (Object)null)
				{
					return;
				}
				_isConfiguring = true;
				_saveDisabled = true;
				SetProfileHotkeys(profile);
				_hotbars.Controller.ConfigureHotbars(profile);
				ActionSlot[][] hotbars = _hotbars.Hotbars;
				foreach (ActionSlot[] array in hotbars)
				{
					if (array == null)
					{
						continue;
					}
					ActionSlot[] array2 = array;
					foreach (ActionSlot val in array2)
					{
						if ((Object)(object)val != (Object)null && (Object)(object)val.ActionButton != (Object)null)
						{
							UnityEngineExtensions.GetOrAddComponent<ActionSlotDropper>(((Component)val.ActionButton).gameObject).SetLogger(_getLogger);
						}
					}
				}
				if (profile.HideLeftNav)
				{
					_hotbars.LeftHotbarNav.Hide();
				}
				else
				{
					_hotbars.LeftHotbarNav.Show();
				}
				if (_isProfileInit)
				{
					AssignSlotActions(profile);
				}
				ScaleHotbars(profile.Scale);
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to configure Hotbars.", ex);
			}
			finally
			{
				_isConfiguring = false;
				_saveDisabled = false;
				if (_pendingHotbarConfigRefresh)
				{
					_pendingHotbarConfigRefresh = false;
					OnHotbarConfigChanged(this, EventArgs.Empty);
				}
			}
		}

		private void TryConfigureHotbars(IHotbarProfile profile, HotbarProfileChangeTypes changeType)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			try
			{
				if ((int)changeType == 11)
				{
					ScaleHotbars(profile.Scale);
				}
				else
				{
					TryConfigureHotbars(profile);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to configure Hotbars.", ex);
			}
		}

		private void Save()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!_isConfiguring && _hotbars.HasChanges && !_saveDisabled)
				{
					IHotbarProfile orCreateActiveProfile = GetOrCreateActiveProfile();
					Logger.LogDebug(string.Format("{0}_{1}: Hotbar changes detected. Saving.", "HotbarService", InstanceID));
					SyncDynamicPresetsForCurrentWeapon();
					_hotbarProfileService.Update(_hotbars);
					if (_hotbarProfileService is GlobalHotbarService globalHotbarService)
					{
						globalHotbarService.SaveCharacterSlots(UID.op_Implicit(_character.UID));
					}
					_hotbars.ClearChanges();
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to Save Hotbar changes.", ex);
			}
		}

		private void ScaleHotbars(int scaleAmount)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_hotbars == (Object)null))
			{
				float num = (float)scaleAmount / 100f;
				((Component)_hotbars).transform.localScale = new Vector3(num, num, 1f);
			}
		}

		private void SwapCanvasGroup()
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			try
			{
				QuickSlotControllerSwitcher val = ((IEnumerable<QuickSlotControllerSwitcher>)((Component)_characterUI).GetComponentsInChildren<QuickSlotControllerSwitcher>()).FirstOrDefault((Func<QuickSlotControllerSwitcher, bool>)((QuickSlotControllerSwitcher q) => ((Object)q).name == "QuickSlot"));
				if ((Object)(object)val == (Object)null)
				{
					Logger.LogWarning("[HotbarService] QuickSlotControllerSwitcher not found!");
					return;
				}
				CanvasGroup privateField = ReflectionExtensions.GetPrivateField<QuickSlotControllerSwitcher, CanvasGroup>(val, "m_keyboardQuickSlots");
				CanvasGroup privateField2 = ReflectionExtensions.GetPrivateField<QuickSlotControllerSwitcher, CanvasGroup>(val, "m_gamepadQuickSlots");
				if (_hotbars.VanillaSuppressionTargets == null)
				{
					_hotbars.VanillaSuppressionTargets = new List<GameObject>();
				}
				_hotbars.VanillaSuppressionTargets.Clear();
				if ((Object)(object)privateField != (Object)null)
				{
					((Component)privateField).gameObject.SetActive(false);
					privateField.alpha = 0f;
					_hotbars.VanillaSuppressionTargets.Add(((Component)privateField).gameObject);
				}
				GameObject val2 = new GameObject("DummyKeyboardSlots");
				val2.transform.SetParent(((Component)val).transform);
				CanvasGroup val3 = val2.AddComponent<CanvasGroup>();
				val3.alpha = 0f;
				val3.blocksRaycasts = false;
				val3.interactable = false;
				ReflectionExtensions.SetPrivateField<QuickSlotControllerSwitcher, CanvasGroup>(val, "m_keyboardQuickSlots", val3);
				if (_hotbars.VanillaOverlayTargets == null)
				{
					_hotbars.VanillaOverlayTargets = new List<CanvasGroup>();
				}
				_hotbars.VanillaOverlayTargets.Clear();
				if ((Object)(object)privateField2 != (Object)null)
				{
					_hotbars.VanillaOverlayTargets.Add(privateField2);
				}
				Logger.LogDebug($"[HotbarService] SwapCanvasGroup Complete. KeyboardGroup found: {(Object)(object)privateField != (Object)null}, GamepadGroup found: {(Object)(object)privateField2 != (Object)null}. Swapped to Dummy.");
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to populate VanillaOverlayTargets or disable QuickSlots.", ex);
			}
		}

		public void DisableKeyboardQuickslots(KeyboardQuickSlotPanel keyboard)
		{
			if ((Object)(object)keyboard != (Object)null && ((Component)keyboard).gameObject.activeSelf)
			{
				IModifLogger logger = Logger;
				int? obj;
				if (keyboard == null)
				{
					obj = null;
				}
				else
				{
					CharacterUI characterUI = ((UIElement)keyboard).CharacterUI;
					obj = ((characterUI != null) ? new int?(characterUI.RewiredID) : null);
				}
				logger.LogDebug($"Disabling Keyboard QuickSlots for RewiredID {obj}.");
				((Component)keyboard).gameObject.SetActive(false);
			}
		}

		private IHotbarProfile GetOrCreateActiveProfile()
		{
			IActionUIProfile activeProfile = _profileService.GetActiveProfile();
			IHotbarProfile profile = _hotbarProfileService.GetProfile();
			Logger.LogDebug("Got or Created Active Profile '" + activeProfile.Name + "'");
			return profile;
		}

		public void AssignSlotActions()
		{
			AssignSlotActions(GetOrCreateActiveProfile());
		}

		public void AssignSlotActions(IHotbarProfile profile)
		{
			Logger.LogDebug(string.Format("{0}_{1}: Assigning Slot Actions.", "HotbarService", InstanceID));
			_saveDisabled = true;
			_isConfiguring = true;
			try
			{
				for (int i = 0; i < profile.Hotbars.Count; i++)
				{
					for (int j = 0; j < profile.Hotbars[i].Slots.Count; j++)
					{
						try
						{
							SlotData slotData = profile.Hotbars[i].Slots[j] as SlotData;
							ActionSlot val = _hotbars.Controller.GetActionSlots()[i][j];
							bool flag = false;
							if (slotData != null && (Object)(object)val != (Object)null && _slotData.TryGetItemSlotAction(slotData, profile.CombatMode, out var slotAction))
							{
								try
								{
									val.Controller.AssignSlotAction(slotAction, false);
									flag = true;
								}
								catch (Exception ex)
								{
									Logger.LogException($"Failed to assign slot action '{((slotAction != null) ? slotAction.DisplayName : null)}' to Bar {i}, Slot Index {j}.", ex);
								}
							}
							if (!flag)
							{
								val.Controller.AssignEmptyAction();
							}
						}
						catch (Exception ex2)
						{
							Logger.LogException($"Failed to assign action to slot {i}_{j}.", ex2);
						}
					}
				}
				SetProfileHotkeys(profile);
				if (!_isProfileInit)
				{
					_isProfileInit = true;
				}
				_hotbars.Controller.Refresh();
			}
			finally
			{
				Logger.LogDebug("Clearing Hotbar Change Flag and enabling save.");
				_hotbars.ClearChanges();
				_saveDisabled = false;
				_isConfiguring = false;
			}
		}

		private void OnEquipmentChanged(Character character, Equipment equipment)
		{
			//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)
			try
			{
				if (_isStarted && !((Object)(object)character == (Object)null) && !((Object)(object)_character == (Object)null) && !(character.UID != _character.UID))
				{
					((ModifCoroutine)_levelCoroutines).DoNextFrame((Action)delegate
					{
						ApplyDynamicPresetsForCurrentWeapon();
					});
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed applying dynamic presets after equipment change.", ex);
			}
		}

		private void ApplyDynamicPresetsForCurrentWeapon(bool force = false)
		{
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			if (!(_hotbarProfileService is GlobalHotbarService globalHotbarService))
			{
				return;
			}
			WeaponContextSnapshot currentWeaponContext = GetCurrentWeaponContext();
			if (!force && string.Equals(currentWeaponContext.Signature, _activeContextSignature, StringComparison.Ordinal))
			{
				return;
			}
			_activeContextSignature = currentWeaponContext.Signature;
			IHotbarProfile orCreateActiveProfile = GetOrCreateActiveProfile();
			bool flag = false;
			ActionSlot[][] actionSlots = _hotbars.Controller.GetActionSlots();
			for (int i = 0; i < actionSlots.Length; i++)
			{
				ActionSlot[] array = actionSlots[i];
				for (int j = 0; j < array.Length; j++)
				{
					ActionSlot val = array[j];
					if (((val != null) ? val.Config : null) == null || !val.Config.IsDynamic)
					{
						continue;
					}
					SlotDataEntry slotEntry = null;
					bool flag2 = false;
					for (int k = 0; k < currentWeaponContext.ResolveKeys.Length; k++)
					{
						if (globalHotbarService.TryGetDynamicPresetSlot(currentWeaponContext.ResolveKeys[k], i, j, out slotEntry))
						{
							flag2 = true;
							break;
						}
					}
					if (!flag2 || slotEntry == null)
					{
						continue;
					}
					ISlotAction slotAction;
					if (slotEntry.ItemID <= 0 && string.IsNullOrWhiteSpace(slotEntry.ItemUID))
					{
						if (val.SlotAction != null)
						{
							val.Controller.AssignEmptyAction();
							flag = true;
						}
					}
					else if ((val.SlotAction == null || val.SlotAction.ActionId != slotEntry.ItemID || !string.Equals(val.SlotAction.ActionUid ?? string.Empty, slotEntry.ItemUID ?? string.Empty, StringComparison.Ordinal)) && _slotData.TryGetItemSlotAction(slotEntry.ItemID, slotEntry.ItemUID, orCreateActiveProfile.CombatMode, out slotAction))
					{
						val.Controller.AssignSlotAction(slotAction, true);
						flag = true;
					}
				}
			}
			if (flag)
			{
				_hotbarProfileService.Update(_hotbars);
				globalHotbarService.SaveCharacterSlots(UID.op_Implicit(_character.UID));
				_hotbars.ClearChanges();
			}
		}

		private void SyncDynamicPresetsForCurrentWeapon()
		{
			if (!(_hotbarProfileService is GlobalHotbarService globalHotbarService))
			{
				return;
			}
			WeaponContextSnapshot currentWeaponContext = GetCurrentWeaponContext();
			string editKey = currentWeaponContext.EditKey;
			ActionSlot[][] actionSlots = _hotbars.Controller.GetActionSlots();
			for (int i = 0; i < actionSlots.Length; i++)
			{
				ActionSlot[] array = actionSlots[i];
				for (int j = 0; j < array.Length; j++)
				{
					ActionSlot val = array[j];
					if (((val != null) ? val.Config : null) == null || !val.Config.IsDynamic)
					{
						continue;
					}
					if (val.SlotAction == null)
					{
						if (string.Equals(editKey, GlobalHotbarService.GetBaselineContextKey(), StringComparison.Ordinal))
						{
							globalHotbarService.SetDynamicPresetSlot(editKey, i, j, -1, null);
						}
						else
						{
							globalHotbarService.RemoveDynamicPresetSlot(editKey, i, j);
						}
					}
					else
					{
						globalHotbarService.SetDynamicPresetSlot(editKey, i, j, val.SlotAction.ActionId, val.SlotAction.ActionUid);
					}
				}
			}
		}

		private void EnsureNoWeaponDynamicPresetsInitialized()
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			if (!(_hotbarProfileService is GlobalHotbarService globalHotbarService))
			{
				return;
			}
			ActionSlot[][] actionSlots = _hotbars.Controller.GetActionSlots();
			for (int i = 0; i < actionSlots.Length; i++)
			{
				ActionSlot[] array = actionSlots[i];
				for (int j = 0; j < array.Length; j++)
				{
					ActionSlot val = array[j];
					if (((val != null) ? val.Config : null) == null || !val.Config.IsDynamic)
					{
						continue;
					}
					string baselineContextKey = GlobalHotbarService.GetBaselineContextKey();
					if (!globalHotbarService.TryGetDynamicPresetSlot(baselineContextKey, i, j, out var _))
					{
						if (val.SlotAction == null)
						{
							globalHotbarService.SetDynamicPresetSlot(baselineContextKey, i, j, -1, null);
						}
						else
						{
							globalHotbarService.SetDynamicPresetSlot(baselineContextKey, i, j, val.SlotAction.ActionId, val.SlotAction.ActionUid);
						}
					}
				}
			}
			if (_hotbarProfileService is GlobalHotbarService globalHotbarService2 && (Object)(object)_character != (Object)null)
			{
				globalHotbarService2.SaveCharacterSlots(UID.op_Implicit(_character.UID));
			}
		}

		private WeaponContextSnapshot GetCurrentWeaponContext()
		{
			int mainWeaponType = -1;
			int offWeaponType = -1;
			try
			{
				Equipment val = ReadMainHandEquipment(_character);
				Equipment val2 = ReadOffhandEquipment(_character);
				if ((Object)(object)val == (Object)null)
				{
					Weapon val3 = ReadCurrentWeapon(_character);
					if ((Object)(object)val3 != (Object)null && ((Object)(object)val2 == (Object)null || val3 != val2))
					{
						val = (Equipment)(object)val3;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					mainWeaponType = GetMainContextType(val);
				}
				if ((Object)(object)val2 != (Object)null && val2 != val)
				{
					offWeaponType = GetOffhandContextType(val2);
				}
			}
			catch
			{
				mainWeaponType = -1;
				offWeaponType = -1;
			}
			string[] resolveKeys = BuildResolveKeys(mainWeaponType, offWeaponType);
			string editKey = BuildEditKey(mainWeaponType, offWeaponType);
			return new WeaponContextSnapshot(mainWeaponType, offWeaponType, resolveKeys, editKey);
		}

		private static Weapon ReadCurrentWeapon(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return null;
			}
			Type type = ((object)character).GetType();
			object? obj = type.GetProperty("CurrentWeapon", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(character, null);
			Weapon val = (Weapon)((obj is Weapon) ? obj : null);
			if (val != null)
			{
				return val;
			}
			CharacterInventory inventory = character.Inventory;
			CharacterEquipment val2 = ((inventory != null) ? inventory.Equipment : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			object? obj2 = ((object)val2).GetType().GetProperty("CurrentWeapon", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val2, null);
			return (Weapon)((obj2 is Weapon) ? obj2 : null);
		}

		private static Equipment ReadMainHandEquipment(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return null;
			}
			Equipment val = ReadEquipmentFromPropertyNames(character, "RightHandWeapon", "RightHandEquipment", "MainHandWeapon", "MainHandEquipment");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			CharacterInventory inventory = character.Inventory;
			CharacterEquipment val2 = ((inventory != null) ? inventory.Equipment : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Equipment val3 = ReadEquipmentFromPropertyNames(val2, "RightHandWeapon", "RightHandEquipment", "MainHandWeapon", "MainHandEquipment");
			if ((Object)(object)val3 != (Object)null)
			{
				return val3;
			}
			return ReadEquipmentFromSlots(character, isMainHand: true);
		}

		private static Equipment ReadOffhandEquipment(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return null;
			}
			Equipment val = ReadEquipmentFromPropertyNames(character, "LeftHandWeapon", "LeftHandEquipment", "OffHandWeapon", "OffHandEquipment");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			CharacterInventory inventory = character.Inventory;
			CharacterEquipment val2 = ((inventory != null) ? inventory.Equipment : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			Equipment val3 = ReadEquipmentFromPropertyNames(val2, "LeftHandWeapon", "LeftHandEquipment", "OffHandWeapon", "OffHandEquipment");
			if ((Object)(object)val3 != (Object)null)
			{
				return val3;
			}
			return ReadEquipmentFromSlots(character, isMainHand: false);
		}

		private static Equipment ReadEquipmentFromPropertyNames(object source, params string[] propertyNames)
		{
			if (source == null || propertyNames == null || propertyNames.Length == 0)
			{
				return null;
			}
			Type type = source.GetType();
			for (int i = 0; i < propertyNames.Length; i++)
			{
				PropertyInfo property = type.GetProperty(propertyNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(property == null))
				{
					object? value = property.GetValue(source, null);
					Equipment val = (Equipment)((value is Equipment) ? value : null);
					if (val != null)
					{
						return val;
					}
				}
			}
			return null;
		}

		private static int GetMainContextType(Equipment mainEquipment)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			if ((Object)(object)mainEquipment == (Object)null)
			{
				return -1;
			}
			Weapon val = (Weapon)(object)((mainEquipment is Weapon) ? mainEquipment : null);
			if (val != null)
			{
				return (int)val.Type;
			}
			if (TryGetStableEquipmentContextId(mainEquipment, out var itemId))
			{
				return 2000000 + itemId;
			}
			return -1;
		}

		private static int GetOffhandContextType(Equipment offhandEquipment)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			if ((Object)(object)offhandEquipment == (Object)null)
			{
				return -1;
			}
			Weapon val = (Weapon)(object)((offhandEquipment is Weapon) ? offhandEquipment : null);
			if (val != null)
			{
				return (int)val.Type;
			}
			if (TryGetStableEquipmentContextId(offhandEquipment, out var itemId))
			{
				return 1000000 + itemId;
			}
			return -1;
		}

		private static Equipment ReadEquipmentFromSlots(Character character, bool isMainHand)
		{
			CharacterInventory val = ((character != null) ? character.Inventory : null);
			CharacterEquipment val2 = ((val != null) ? val.Equipment : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			IEnumerable<object> enumerable = ReadObjectEnumerable(val2, "EquipmentSlots", "m_equipmentSlots", "Slots", "m_slots");
			if (enumerable == null)
			{
				return null;
			}
			foreach (object item in enumerable)
			{
				if (item == null)
				{
					continue;
				}
				string text = ReadSlotTypeName(item);
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				bool flag = text.IndexOf("Right", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Main", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Primary", StringComparison.OrdinalIgnoreCase) >= 0;
				bool flag2 = text.IndexOf("Left", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Off", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Secondary", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Lantern", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Lexicon", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Tome", StringComparison.OrdinalIgnoreCase) >= 0;
				if ((!isMainHand || flag) && (isMainHand || flag2))
				{
					Equipment val3 = ReadEquipmentFromPropertyNames(item, "EquippedItem", "m_equippedItem", "Item");
					if ((Object)(object)val3 != (Object)null)
					{
						return val3;
					}
				}
			}
			return null;
		}

		private static IEnumerable<object> ReadObjectEnumerable(object source, params string[] memberNames)
		{
			if (source == null || memberNames == null || memberNames.Length == 0)
			{
				return null;
			}
			Type type = source.GetType();
			for (int i = 0; i < memberNames.Length; i++)
			{
				if (type.GetProperty(memberNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(source, null) is IEnumerable enumerable)
				{
					List<object> list = new List<object>();
					foreach (object item in enumerable)
					{
						list.Add(item);
					}
					return list;
				}
				if (!(type.GetField(memberNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(source) is IEnumerable enumerable2))
				{
					continue;
				}
				List<object> list2 = new List<object>();
				foreach (object item2 in enumerable2)
				{
					list2.Add(item2);
				}
				return list2;
			}
			return null;
		}

		private static string ReadSlotTypeName(object slot)
		{
			if (slot == null)
			{
				return null;
			}
			Type type = slot.GetType();
			object obj = type.GetProperty("SlotType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(slot, null);
			if (obj != null)
			{
				return obj.ToString();
			}
			return (type.GetField("m_slotType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(slot))?.ToString();
		}

		private static bool TryGetStableEquipmentContextId(Equipment equipment, out int itemId)
		{
			itemId = 0;
			if ((Object)(object)equipment == (Object)null)
			{
				return false;
			}
			if (TryReadIntMember(equipment, out itemId, "ItemID", "ItemId", "ID", "m_itemID", "m_itemId", "_itemID", "_itemId"))
			{
				return itemId > 0;
			}
			string text = ReadStringMember(equipment, "UID", "ItemUID", "ItemUid", "m_uid", "m_UID", "_uid");
			if (!string.IsNullOrWhiteSpace(text))
			{
				itemId = StablePositiveHash(text);
				return itemId > 0;
			}
			string name = ((Object)equipment).name;
			if (!string.IsNullOrWhiteSpace(name))
			{
				itemId = StablePositiveHash("name:" + name);
				return itemId > 0;
			}
			return false;
		}

		private static bool TryReadIntMember(object source, out int value, params string[] memberNames)
		{
			value = 0;
			if (source == null || memberNames == null || memberNames.Length == 0)
			{
				return false;
			}
			Type type = source.GetType();
			for (int i = 0; i < memberNames.Length; i++)
			{
				PropertyInfo property = type.GetProperty(memberNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && TryConvertToInt(property.GetValue(source, null), out value))
				{
					return true;
				}
				FieldInfo field = type.GetField(memberNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null && TryConvertToInt(field.GetValue(source), out value))
				{
					return true;
				}
				MethodInfo method = type.GetMethod(memberNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				if (method != null && TryConvertToInt(method.Invoke(source, null), out value))
				{
					return true;
				}
			}
			return false;
		}

		private static string ReadStringMember(object source, params string[] memberNames)
		{
			if (source == null || memberNames == null || memberNames.Length == 0)
			{
				return null;
			}
			Type type = source.GetType();
			for (int i = 0; i < memberNames.Length; i++)
			{
				if (type.GetProperty(memberNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(source, null) is string text && !string.IsNullOrWhiteSpace(text))
				{
					return text;
				}
				if (type.GetField(memberNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(source) is string text2 && !string.IsNullOrWhiteSpace(text2))
				{
					return text2;
				}
			}
			return null;
		}

		private static bool TryConvertToInt(object value, out int result)
		{
			result = 0;
			if (value == null)
			{
				return false;
			}
			if (!(value is int num))
			{
				if (!(value is long num2))
				{
					if (value is short num3)
					{
						short num4 = num3;
						result = num4;
						return true;
					}
					if (!(value is uint num5))
					{
						if (value is byte b)
						{
							byte b2 = b;
							result = b2;
							return true;
						}
						if (value is string text)
						{
							string s = text;
							if (int.TryParse(s, out var result2))
							{
								result = result2;
								return true;
							}
						}
					}
					else
					{
						uint num6 = num5;
						if (num6 <= int.MaxValue)
						{
							result = (int)num6;
							return true;
						}
					}
				}
				else
				{
					long num7 = num2;
					if (num7 <= int.MaxValue && num7 >= int.MinValue)
					{
						result = (int)num7;
						return true;
					}
				}
				return false;
			}
			int num8 = num;
			result = num8;
			return true;
		}

		private static int StablePositiveHash(string text)
		{
			uint num = 2166136261u;
			for (int i = 0; i < text.Length; i++)
			{
				num ^= text[i];
				num *= 16777619;
			}
			int num2 = (int)(num & 0x7FFFFFFF);
			return (num2 == 0) ? 1 : num2;
		}

		private static string[] BuildResolveKeys(int mainWeaponType, int offWeaponType)
		{
			List<string> list = new List<string>(4);
			if (mainWeaponType != -1 && offWeaponType != -1)
			{
				list.Add(GlobalHotbarService.GetComboContextKey(mainWeaponType, offWeaponType));
			}
			if (mainWeaponType != -1)
			{
				list.Add(GlobalHotbarService.GetMainContextKey(mainWeaponType));
			}
			if (offWeaponType != -1)
			{
				list.Add(GlobalHotbarService.GetOffContextKey(offWeaponType));
			}
			list.Add(GlobalHotbarService.GetBaselineContextKey());
			return list.Distinct().ToArray();
		}

		private static string BuildEditKey(int mainWeaponType, int offWeaponType)
		{
			if (mainWeaponType != -1 && offWeaponType != -1)
			{
				return GlobalHotbarService.GetComboContextKey(mainWeaponType, offWeaponType);
			}
			if (mainWeaponType != -1)
			{
				return GlobalHotbarService.GetMainContextKey(mainWeaponType);
			}
			if (offWeaponType != -1)
			{
				return GlobalHotbarService.GetOffContextKey(offWeaponType);
			}
			return GlobalHotbarService.GetBaselineContextKey();
		}

		private void SetProfileHotkeys(IHotbarProfile profile)
		{
			KeyboardMap map = _player.controllers.maps.GetMap<KeyboardMap>(0, 131000, 0);
			MouseMap map2 = _player.controllers.maps.GetMap<MouseMap>(0, 131000, 0);
			if (map == null || map2 == null)
			{
				Logger.LogWarning($"SetProfileHotkeys: Controller maps not found for player {_player.id}. Skipping hotkey configuration. (KeyMap: {map != null}, MouseMap: {map2 != null})");
				return;
			}
			HotbarProfileData profileData = (HotbarProfileData)(object)profile;
			HotbarProfileData hotbarProfileData = profileData;
			ActionElementMap? obj = ((IEnumerable<ActionElementMap>)((ControllerMap)map).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == profileData.NextRewiredActionId));
			hotbarProfileData.NextHotkey = ((obj != null) ? obj.elementIdentifierName : null);
			if (string.IsNullOrWhiteSpace(profileData.NextHotkey))
			{
				HotbarProfileData hotbarProfileData2 = profileData;
				ActionElementMap? obj2 = ((IEnumerable<ActionElementMap>)((ControllerMap)map2).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == profileData.NextRewiredActionId));
				hotbarProfileData2.NextHotkey = ((obj2 != null) ? obj2.elementIdentifierName : null);
			}
			if (string.IsNullOrWhiteSpace(profileData.NextHotkey) && ((ControllerMap)map2).AllMaps.Any((ActionElementMap m) => m.actionId == profileData.NextRewiredAxisActionId))
			{
				profileData.NextHotkey = "Wheel+";
			}
			HotbarProfileData hotbarProfileData3 = profileData;
			ActionElementMap? obj3 = ((IEnumerable<ActionElementMap>)((ControllerMap)map).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == profileData.PrevRewiredActionId));
			hotbarProfileData3.PrevHotkey = ((obj3 != null) ? obj3.elementIdentifierName : null);
			if (string.IsNullOrWhiteSpace(profileData.PrevHotkey))
			{
				HotbarProfileData hotbarProfileData4 = profileData;
				ActionElementMap? obj4 = ((IEnumerable<ActionElementMap>)((ControllerMap)map2).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == profileData.PrevRewiredActionId));
				hotbarProfileData4.PrevHotkey = ((obj4 != null) ? obj4.elementIdentifierName : null);
			}
			if (string.IsNullOrWhiteSpace(profileData.PrevHotkey) && ((ControllerMap)map2).AllMaps.Any((ActionElementMap m) => m.actionId == profileData.PrevRewiredAxisActionId))
			{
				profileData.PrevHotkey = "Wheel-";
			}
			foreach (HotbarData bar2 in profileData.Hotbars)
			{
				HotbarData hotbarData = bar2;
				ActionElementMap? obj5 = ((IEnumerable<ActionElementMap>)((ControllerMap)map).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == bar2.RewiredActionId));
				hotbarData.HotbarHotkey = ((obj5 != null) ? obj5.elementIdentifierName : null);
				foreach (ISlotData slot in bar2.Slots)
				{
					ActionConfig config2 = (ActionConfig)(object)slot.Config;
					ActionElementMap val = ((IEnumerable<ActionElementMap>)((ControllerMap)map).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == config2.RewiredActionId));
					if (val != null)
					{
						slot.Config.HotkeyText = val.elementIdentifierName;
					}
					else
					{
						slot.Config.HotkeyText = string.Empty;
					}
				}
			}
			foreach (HotbarData bar in profileData.Hotbars)
			{
				ActionElementMap val2 = ((IEnumerable<ActionElementMap>)((ControllerMap)map2).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == bar.RewiredActionId));
				if (val2 != null)
				{
					bar.HotbarHotkey = ControllerMapService.MouseButtonElementIds[val2.elementIdentifierId].DisplayName;
				}
				foreach (ISlotData slot2 in bar.Slots)
				{
					ActionConfig config = (ActionConfig)(object)slot2.Config;
					ActionElementMap val3 = ((IEnumerable<ActionElementMap>)((ControllerMap)map2).ButtonMaps).FirstOrDefault((Func<ActionElementMap, bool>)((ActionElementMap m) => m.actionId == config.RewiredActionId));
					if (val3 != null)
					{
						slot2.Config.HotkeyText = ControllerMapService.MouseButtonElementIds[val3.elementIdentifierId].DisplayName;
					}
				}
			}
		}

		protected virtual void Dispose(bool disposing)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				Logger.LogDebug(string.Format("Disposing of {0} instance '{1}'. Unsubscribing to events.", "HotbarService", InstanceID));
				QuickSlotPanelPatches.StartInitAfter -= DisableKeyboardQuickslots;
				SkillMenuPatches.AfterOnSectionSelected -= SetSkillsMovable;
				EquipmentPatches.AfterOnEquip -= OnEquipmentChanged;
				EquipmentPatches.AfterOnUnequip -= OnEquipmentChanged;
				if (ItemDisplayDropGroundPatches.TryGetIsDropValids.ContainsKey(_player.id))
				{
					ItemDisplayDropGroundPatches.TryGetIsDropValids.Remove(_player.id);
				}
				if ((Object)(object)_hotbars != (Object)null)
				{
					_hotbars.OnHasChanges.RemoveListener(new UnityAction(Save));
					_hotbars.OnAwake -= StartNextFrame;
				}
				if (_hotbarProfileService != null)
				{
					_hotbarProfileService.OnProfileChanged -= TryConfigureHotbars;
				}
				ActionUISettings.HotbarPositionX.SettingChanged -= OnHotbarPositionConfigChanged;
				ActionUISettings.HotbarPositionY.SettingChanged -= OnHotbarPositionConfigChanged;
				ActionUISettings.Rows.SettingChanged -= OnHotbarConfigChanged;
				ActionUISettings.SlotsPerRow.SettingChanged -= OnHotbarConfigChanged;
				ActionUISettings.Scale.SettingChanged -= OnHotbarConfigChanged;
				ActionUISettings.HideLeftNav.SettingChanged -= OnHotbarConfigChanged;
				ActionUISettings.CombatMode.SettingChanged -= OnHotbarConfigChanged;
				ActionUISettings.ShowCooldownTimer.SettingChanged -= OnHotbarConfigChanged;
				ActionUISettings.PreciseCooldownTime.SettingChanged -= OnHotbarConfigChanged;
				if ((Object)(object)_hotbars != (Object)null)
				{
					PositionableUI component = ((Component)_hotbars).GetComponent<PositionableUI>();
					if ((Object)(object)component != (Object)null)
					{
						component.UIElementMoved.RemoveListener((UnityAction<PositionableUI>)OnHotbarUIMoved);
					}
				}
			}
			disposedValue = true;
		}

		private void InitializePositionConfig()
		{
			PositionableUI component = ((Component)_hotbars).GetComponent<PositionableUI>();
			if ((Object)(object)component != (Object)null)
			{
				component.SetPosition(ActionUISettings.HotbarPositionX.Value, 0f - ActionUISettings.HotbarPositionY.Value);
				ActionUISettings.HotbarPositionX.SettingChanged += OnHotbarPositionConfigChanged;
				ActionUISettings.HotbarPositionY.SettingChanged += OnHotbarPositionConfigChanged;
				component.UIElementMoved.AddListener((UnityAction<PositionableUI>)OnHotbarUIMoved);
			}
		}

		private void OnHotbarPositionConfigChanged(object sender, EventArgs e)
		{
			if ((Object)(object)_hotbars != (Object)null)
			{
				PositionableUI component = ((Component)_hotbars).GetComponent<PositionableUI>();
				if ((Object)(object)component != (Object)null)
				{
					component.SetPosition(ActionUISettings.HotbarPositionX.Value, 0f - ActionUISettings.HotbarPositionY.Value);
				}
			}
		}

		private void OnHotbarConfigChanged(object sender, EventArgs e)
		{
			if (!_isStarted || (Object)(object)_hotbars == (Object)null)
			{
				return;
			}
			if (_isConfiguring)
			{
				_pendingHotbarConfigRefresh = true;
				return;
			}
			try
			{
				IHotbarProfile val = _hotbarProfileService.GetProfile();
				if (val == null)
				{
					return;
				}
				while (val.Rows < ActionUISettings.Rows.Value)
				{
					val = _hotbarProfileService.AddRow();
				}
				while (val.Rows > ActionUISettings.Rows.Value)
				{
					val = _hotbarProfileService.RemoveRow();
				}
				while (val.SlotsPerRow < ActionUISettings.SlotsPerRow.Value)
				{
					val = _hotbarProfileService.AddSlot();
				}
				while (val.SlotsPerRow > ActionUISettings.SlotsPerRow.Value)
				{
					val = _hotbarProfileService.RemoveSlot();
				}
				if (val.Scale != ActionUISettings.Scale.Value)
				{
					val = _hotbarProfileService.SetScale(ActionUISettings.Scale.Value);
				}
				if (val.HideLeftNav != ActionUISettings.HideLeftNav.Value)
				{
					val = _hotbarProfileService.SetHideLeftNav(ActionUISettings.HideLeftNav.Value);
				}
				if (val.CombatMode != ActionUISettings.CombatMode.Value)
				{
					val = _hotbarProfileService.SetCombatMode(ActionUISettings.CombatMode.Value);
				}
				if (val.Hotbars.Count > 0 && val.Hotbars[0].Slots.Count > 0)
				{
					IActionSlotConfig config = val.Hotbars[0].Slots[0].Config;
					if (config.ShowCooldownTime != ActionUISettings.ShowCooldownTimer.Value || config.PreciseCooldownTime != ActionUISettings.PreciseCooldownTime.Value)
					{
						val = _hotbarProfileService.SetCooldownTimer(ActionUISettings.ShowCooldownTimer.Value, ActionUISettings.PreciseCooldownTime.Value);
					}
				}
				TryConfigureHotbars(val, (HotbarProfileChangeTypes)0);
				_hotbars.ClearChanges();
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed applying hotbar settings from config.", ex);
			}
		}

		private void OnHotbarUIMoved(PositionableUI p)
		{
			//IL_0007: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			float num = p.RectTransform.anchoredPosition.x - p.DynamicOffset.x;
			float num2 = p.RectTransform.anchoredPosition.y - p.DynamicOffset.y;
			if (Math.Abs(ActionUISettings.HotbarPositionX.Value - num) > 0.1f)
			{
				ActionUISettings.HotbarPositionX.Value = num;
			}
			if (Math.Abs(ActionUISettings.HotbarPositionY.Value - (0f - num2)) > 0.1f)
			{
				ActionUISettings.HotbarPositionY.Value = 0f - num2;
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class InventoryService : IDisposable, IStartable
	{
		private readonly Func<IModifLogger> _getLogger;

		private Character _character;

		private readonly int _playerID;

		private readonly IActionUIProfileService _profileService;

		private bool _isRemoved;

		private readonly LevelCoroutines _coroutines;

		private bool disposedValue;

		private IModifLogger Logger => _getLogger();

		private CharacterInventory _characterInventory => _character.Inventory;

		private CharacterEquipment _characterEquipment => _character.Inventory.Equipment;

		private IActionUIProfile _profile => _profileService.GetActiveProfile();

		public InventoryService(Character character, IActionUIProfileService profileService, LevelCoroutines coroutines, Func<IModifLogger> getLogger)
		{
			_character = character;
			_profileService = profileService;
			_coroutines = coroutines;
			_getLogger = getLogger;
			_playerID = _character.OwnerPlayerSys.PlayerID;
		}

		public void Start()
		{
			try
			{
				CharacterInventoryPatches.AfterInventoryIngredients += AddStashIngredients;
				CharacterManagerPatches.AfterAddCharacter += ConfigureStashPreserverDelayed;
				ItemDisplayOptionPanelPatches.TryGetActiveActions.Add(_playerID, TryAddStashActionID);
				ItemDisplayOptionPanelPatches.PlayersPressedAction.Add(_playerID, StashContextButtonPressed);
				ItemDisplayPatches.PlayersUpdateValueDisplay.Add(_playerID, TryAddCurrencyValue);
				MenuPanelPatches.AfterOnHideInventoryMenu += HideCurrencyValues;
				_profileService.OnActiveProfileChanged += TryConfigureStashPreserver;
				_profileService.OnActiveProfileSwitched += TryConfigureStashPreserver;
				((ModifCoroutine)_coroutines).DoWhen((Func<bool>)(() => (Object)(object)_characterInventory.Stash != (Object)null), (Action)delegate
				{
					TryConfigureStashPreserver(_profile);
				}, 180, 0f, (Func<bool>)null);
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to start InventoryService.", ex);
			}
		}

		private bool TryAddStashActionID(int rewiredId, Item item, List<int> baseActiveActions, out List<int> activeActions)
		{
			activeActions = null;
			if (rewiredId != _playerID || !GetStashInventoryEnabled() || (Object)(object)item == (Object)null)
			{
				return false;
			}
			if (ItemDisplayOptionPanelPatches.PlayersMoveToStashID == -1)
			{
				return false;
			}
			int num = baseActiveActions.IndexOf(7);
			int num2 = baseActiveActions.IndexOf(8);
			int num3 = ((num2 != -1) ? num2 : num);
			if (num3 == -1)
			{
				return false;
			}
			if (_characterInventory.Stash.Contains(item.UID))
			{
				return false;
			}
			activeActions = new List<int>();
			for (int i = 0; i < baseActiveActions.Count(); i++)
			{
				activeActions.Add(baseActiveActions[i]);
				if (i == num3)
				{
					activeActions.Add(ItemDisplayOptionPanelPatches.PlayersMoveToStashID);
				}
			}
			return true;
		}

		private bool TryAddCurrencyValue(ItemDisplay itemDisplay)
		{
			if (!_profile.StorageSettingsProfile.DisplayCurrencyEnabled)
			{
				return false;
			}
			Item refItem = itemDisplay.RefItem;
			if ((Object)(object)refItem == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_character?.CharacterUI != (Object)null && (Object)(object)_characterInventory != (Object)null && (_character.CharacterUI.GetIsMenuDisplayed((MenuScreens)12) || !_characterInventory.OwnsItem(refItem.UID)))
			{
				return false;
			}
			if (!_character.CharacterUI.GetIsMenuDisplayed((MenuScreens)2))
			{
				return false;
			}
			GameObject privateField = ReflectionExtensions.GetPrivateField<ItemDisplay, GameObject>(itemDisplay, "m_valueHolder");
			if ((Object)(object)privateField == (Object)null)
			{
				return false;
			}
			if (privateField.activeSelf)
			{
				return true;
			}
			Text privateField2 = ReflectionExtensions.GetPrivateField<ItemDisplay, Text>(itemDisplay, "m_lblValue");
			if ((Object)(object)privateField2 == (Object)null)
			{
				return false;
			}
			DictionaryExt<UID, Merchant> val = typeof(Merchant).GetField("m_sceneMerchants", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null) as DictionaryExt<UID, Merchant>;
			Merchant val2 = null;
			if (val != null && val.Values.Any())
			{
				val2 = UnityEngineExtensions.FirstOrDefault<Merchant>((IList<Merchant>)val.Values);
			}
			int num;
			if ((Object)(object)val2 != (Object)null)
			{
				Logger.LogDebug("Getting merchant " + ((val2 != null) ? val2.ShopName : null) + "'s sell to amount for item " + ((refItem != null) ? ((Object)refItem).name : null));
				num = refItem.GetSellValue(_character, val2, false);
				Logger.LogDebug($"Got merchant {val2.ShopName}'s sell to amount of {num} for item {((Object)refItem).name}");
			}
			else
			{
				float privateField3 = ReflectionExtensions.GetPrivateField<Item, float>(refItem, "m_overrideSellModifier");
				float num2 = (((double)privateField3 != -1.0) ? privateField3 : 0.3f);
				num = Mathf.RoundToInt((float)refItem.RawCurrentValue * num2);
				Logger.LogDebug($"Got default sell to amount of {num} for item {((Object)refItem).name}");
			}
			privateField.SetActive(true);
			privateField2.text = num.ToString();
			return true;
		}

		private void HideCurrencyValues(InventoryMenu menu)
		{
			Logger.LogDebug("HideCurrencyValues: Hiding sell to amounts for menu " + ((Object)menu).name + ".");
			InventoryContentDisplay componentInChildren = ((Component)menu).GetComponentInChildren<InventoryContentDisplay>();
			Logger.LogDebug($"HideCurrencyValues: invDisplay==null=={(Object)(object)componentInChildren == (Object)null}.");
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			ItemDisplay[] componentsInChildren = ((Component)componentInChildren).GetComponentsInChildren<ItemDisplay>();
			Logger.LogDebug($"HideCurrencyValues: itemDisplays.Length=={componentsInChildren.Length}.");
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				GameObject privateField = ReflectionExtensions.GetPrivateField<ItemDisplay, GameObject>(componentsInChildren[i], "m_valueHolder");
				if ((Object)(object)privateField != (Object)null && privateField.activeSelf)
				{
					privateField.SetActive(false);
					Text privateField2 = ReflectionExtensions.GetPrivateField<ItemDisplay, Text>(componentsInChildren[i], "m_lblValue");
					if ((Object)(object)privateField2 != (Object)null)
					{
						privateField2.text = string.Empty;
					}
				}
			}
		}

		private void StashContextButtonPressed(int actionID, ItemDisplay itemDisplay)
		{
			if (ItemDisplayOptionPanelPatches.PlayersMoveToStashID != -1 && ItemDisplayOptionPanelPatches.PlayersMoveToStashID == actionID)
			{
				itemDisplay.TryMoveTo(_characterInventory.Stash);
			}
		}

		private void AddStashIngredients(CharacterInventory characterInventory, Character character, Tag craftingStationTag, ref DictionaryExt<int, CompatibleIngredient> sortedIngredients)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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)
			if (GetCraftFromStashEnabled() && !((Object)(object)character.Stash == (Object)null) && !(character.UID != _character.UID))
			{
				List<Item> list = character.Stash.GetContainedItems().ToList();
				MethodInfo method = ((object)characterInventory).GetType().GetMethod("InventoryIngredients", BindingFlags.Instance | BindingFlags.NonPublic);
				method.Invoke(characterInventory, new object[3] { craftingStationTag, sortedIngredients, list });
			}
		}

		private void TryConfigureStashPreserver(IActionUIProfile profile)
		{
			try
			{
				Logger.LogDebug("Trying to Configure Stash Preserver for profile '" + ((profile != null) ? profile.Name : null) + "'.");
				ConfigureStashPreserver(_character);
				if (PlayerSystemExtensions.IsHostPlayer(_character.OwnerPlayerSys))
				{
					IEnumerable<Character> enumerable = CharacterManager.Instance.Characters.Values.Where((Character c) => !c.IsAI);
					{
						foreach (Character item in enumerable)
						{
							ConfigureStashPreserver(item);
						}
						return;
					}
				}
				if (PhotonNetwork.isNonMasterClientInRoom)
				{
					ConfigureStashPreserver(_character);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to configure stash preserver.", ex);
			}
		}

		private void ConfigureStashPreserverDelayed(Character character)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			if ((int)character.InstantiationType == 1)
			{
				((ModifCoroutine)_coroutines).DoWhen((Func<bool>)stashCreated, (Action)delegate
				{
					ConfigureStashPreserver(character);
				}, 120, 0f, (Func<bool>)null);
			}
			bool stashCreated()
			{
				CharacterInventory inventory = character.Inventory;
				return (Object)(object)((inventory != null) ? inventory.Stash : null) != (Object)null && ((Item)character.Inventory.Stash).IsFirstSyncDone;
			}
		}

		private float CalculateDurabilityReduction(Item item, Character character, float durabilityReduction)
		{
			//IL_0013: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			StashSettingsProfile stashSettingsProfile = _profile.StashSettingsProfile;
			if (_character.UID != _character.UID || (Object)(object)item.PerishScript == (Object)null || !stashSettingsProfile.PreservesFoodEnabled || !item.Tags.Contains(TagSourceManager.Food))
			{
				return durabilityReduction;
			}
			float privateProperty = ReflectionExtensions.GetPrivateProperty<Perishable, float>(item.PerishScript, "DeltaGameTime");
			float num = item.PerishScript.DepletionRate * privateProperty;
			if (!Mathf.Approximately(durabilityReduction, num) && durabilityReduction != num)
			{
				Logger.LogDebug($"Calculated new durability reduction for character {character.UID} Item {((Object)item).name}. Original reduction: {durabilityReduction}. Adjusted reduction: {num}");
			}
			return num;
		}

		private void ConfigureStashPreserver(Character character)
		{
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			ItemContainer stash = character.Stash;
			StashSettingsProfile stashSettingsProfile = _profile.StashSettingsProfile;
			Preserver val = ReflectionExtensions.GetPrivateField<ItemContainer, Preserver>(stash, "m_preservationExt");
			TagSourceSelector foodTag = ReflectionExtensions.GetPrivateField<TagSourceManager, TagSourceSelector>(TagSourceManager.Instance, "m_foodTag");
			if (stashSettingsProfile.PreservesFoodEnabled)
			{
				bool flag = false;
				if ((Object)(object)val == (Object)null)
				{
					val = UnityEngineExtensions.GetOrAddComponent<Preserver>(((Component)stash).gameObject);
					flag = true;
				}
				List<PreservedElement> privateField = ReflectionExtensions.GetPrivateField<Preserver, List<PreservedElement>>(val, "m_preservedElements");
				if (!flag)
				{
					if (privateField.Count == 0)
					{
						flag = true;
					}
					else
					{
						PreservedElement val2 = ((IEnumerable<PreservedElement>)privateField).FirstOrDefault((Func<PreservedElement, bool>)((PreservedElement p) => p.Tag.Tag == foodTag.Tag));
						if (val2 == null)
						{
							flag = true;
						}
						else if (val.NullifyPerishing && stashSettingsProfile.PreservesFoodAmount != 100)
						{
							flag = true;
						}
						else if (!val.NullifyPerishing && stashSettingsProfile.PreservesFoodAmount == 100)
						{
							flag = true;
						}
						else if (!Mathf.Approximately(val2.Preservation, (float)stashSettingsProfile.PreservesFoodAmount) && (!val.NullifyPerishing || stashSettingsProfile.PreservesFoodAmount != 100))
						{
							flag = true;
						}
					}
				}
				if (!flag)
				{
					return;
				}
				val.NullifyPerishing = stashSettingsProfile.PreservesFoodAmount == 100;
				privateField.RemoveAll((PreservedElement p) => p.Tag == foodTag);
				privateField.Add(new PreservedElement
				{
					Preservation = (val.NullifyPerishing ? 100f : ((float)stashSettingsProfile.PreservesFoodAmount)),
					Tag = foodTag
				});
				((Item)stash).AddItemExtension((ItemExtension)(object)val);
				List<Item> itemsFromTag = stash.GetItemsFromTag(TagSourceManager.Food);
				Perishable[] componentsInChildren = ((Component)stash).GetComponentsInChildren<Perishable>();
				Perishable[] array = componentsInChildren;
				foreach (Perishable val3 in array)
				{
					try
					{
						if ((Object)(object)val3 != (Object)null)
						{
							((ItemExtension)val3).ItemParentChanged();
						}
					}
					catch (Exception ex)
					{
						Logger.LogException("Unable to set preservation for perishable " + ((val3 != null) ? ((Object)val3).name : null) + ".", ex);
					}
				}
				Logger.LogInfo($"Stash preservation amount set to {stashSettingsProfile.PreservesFoodAmount}% for character '{((character != null) ? character.Name : null)}' '{((character != null) ? new UID?(character.UID) : null)}'");
			}
			else if (TryRemoveStashPreserver())
			{
				Logger.LogInfo("Stash set to not preserve food.");
			}
		}

		private bool TryRemoveStashPreserver()
		{
			try
			{
				ItemContainer stash = _characterInventory.Stash;
				if ((Object)(object)((stash != null) ? ((Component)stash).gameObject : null) == (Object)null)
				{
					Logger.LogInfo("Stash was null. Exiting TryRemoveStashPreserver.");
					return false;
				}
				Preserver privateField = ReflectionExtensions.GetPrivateField<ItemContainer, Preserver>(stash, "m_preservationExt");
				if ((Object)(object)privateField != (Object)null)
				{
					ReflectionExtensions.SetPrivateField<ItemContainer, Preserver>(stash, "m_preservationExt", (Preserver)null);
				}
				Preserver component = ((Component)stash).gameObject.GetComponent<Preserver>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
					return true;
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to remove stash preserver.", ex);
			}
			return false;
		}

		public static Dictionary<string, Item> GetItemPrefabs()
		{
			FieldInfo field = typeof(ResourcesPrefabManager).GetField("ITEM_PREFABS", BindingFlags.Static | BindingFlags.NonPublic);
			return (Dictionary<string, Item>)field.GetValue(null);
		}

		public bool GetAreaContainsStash()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			AreaEnum area;
			return TryGetCurrentAreaEnum(out area) && InventorySettings.StashAreas.Contains(area);
		}

		public bool GetStashInventoryEnabled()
		{
			return _profile.StashSettingsProfile.CharInventoryEnabled && (GetAreaContainsStash() || _profile.StashSettingsProfile.CharInventoryAnywhereEnabled);
		}

		public bool GetMerchantStashEnabled()
		{
			return _profile.StashSettingsProfile.MerchantEnabled && (GetAreaContainsStash() || _profile.StashSettingsProfile.MerchantAnywhereEnabled);
		}

		public bool GetCraftFromStashEnabled()
		{
			return _profile.StashSettingsProfile.CraftingInventoryEnabled && (GetAreaContainsStash() || _profile.StashSettingsProfile.CraftingInventoryAnywhereEnabled);
		}

		public static bool TryGetCurrentAreaEnum(out AreaEnum area)
		{
			area = (AreaEnum)0;
			AreaManager instance = AreaManager.Instance;
			string text = ((instance == null) ? null : instance.CurrentArea?.SceneName);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			area = (AreaEnum)AreaManager.Instance.GetAreaIndexFromSceneName(text);
			return true;
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				CharacterInventoryPatches.AfterInventoryIngredients -= AddStashIngredients;
				CharacterManagerPatches.AfterAddCharacter -= ConfigureStashPreserverDelayed;
				if (_profileService != null)
				{
					_profileService.OnActiveProfileChanged -= TryConfigureStashPreserver;
					_profileService.OnActiveProfileSwitched -= TryConfigureStashPreserver;
				}
				ItemDisplayOptionPanelPatches.TryGetActiveActionsDelegate tryGetActiveActionsDelegate = default(ItemDisplayOptionPanelPatches.TryGetActiveActionsDelegate);
				IDictionaryExtensions.TryRemove<int, ItemDisplayOptionPanelPatches.TryGetActiveActionsDelegate>((IDictionary<int, ItemDisplayOptionPanelPatches.TryGetActiveActionsDelegate>)ItemDisplayOptionPanelPatches.TryGetActiveActions, _playerID, ref tryGetActiveActionsDelegate);
				ItemDisplayOptionPanelPatches.PressedActionDelegate pressedActionDelegate = default(ItemDisplayOptionPanelPatches.PressedActionDelegate);
				IDictionaryExtensions.TryRemove<int, ItemDisplayOptionPanelPatches.PressedActionDelegate>((IDictionary<int, ItemDisplayOptionPanelPatches.PressedActionDelegate>)ItemDisplayOptionPanelPatches.PlayersPressedAction, _playerID, ref pressedActionDelegate);
				ItemDisplayPatches.BeforeUpdateValueDisplayDelegate beforeUpdateValueDisplayDelegate = default(ItemDisplayPatches.BeforeUpdateValueDisplayDelegate);
				IDictionaryExtensions.TryRemove<int, ItemDisplayPatches.BeforeUpdateValueDisplayDelegate>((IDictionary<int, ItemDisplayPatches.BeforeUpdateValueDisplayDelegate>)ItemDisplayPatches.PlayersUpdateValueDisplay, _playerID, ref beforeUpdateValueDisplayDelegate);
				MenuPanelPatches.AfterOnHideInventoryMenu -= HideCurrencyValues;
			}
			_character = null;
			disposedValue = true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	internal class SlotActionViewData : IActionViewData
	{
		private readonly Func<IModifLogger> _getLogger;

		private readonly Player _player;

		private readonly Character _character;

		private readonly CharacterInventory _inventory;

		private readonly SlotDataService _slotData;

		private readonly IActionUIProfileService _profileService;

		private IModifLogger Logger => _getLogger();

		public SlotActionViewData(Player player, Character character, SlotDataService slotData, IActionUIProfileService profileService, Func<IModifLogger> getLogger)
		{
			if (player == null)
			{
				throw new ArgumentNullException("player");
			}
			if ((Object)(object)character == (Object)null)
			{
				throw new ArgumentNullException("character");
			}
			_player = player;
			_character = character;
			_slotData = slotData;
			_inventory = character.Inventory;
			_profileService = profileService;
			_getLogger = getLogger;
		}

		public IEnumerable<IActionsDisplayTab> GetActionsTabData()
		{
			List<ActionsDisplayTab> list = new List<ActionsDisplayTab>();
			int num = 0;
			list.Add(new ActionsDisplayTab
			{
				DisplayName = "Skills",
				TabOrder = num++,
				GetSlotActionsQuery = () => GetActiveSkills()
			});
			list.Add(new ActionsDisplayTab
			{
				DisplayName = "Consumables",
				TabOrder = num++,
				GetSlotActionsQuery = () => GetConsumables()
			});
			list.Add(new ActionsDisplayTab
			{
				DisplayName = "Deployables",
				TabOrder = num++,
				GetSlotActionsQuery = () => GetDeployables()
			});
			list.Add(new ActionsDisplayTab
			{
				DisplayName = "Weapons",
				TabOrder = num++,
				GetSlotActionsQuery = () => GetWeapons()
			});
			list.Add(new ActionsDisplayTab
			{
				DisplayName = "Armor",
				TabOrder = num++,
				GetSlotActionsQuery = () => GetArmor()
			});
			list.Add(new ActionsDisplayTab
			{
				DisplayName = "Cosmetics",
				TabOrder = num++,
				GetSlotActionsQuery = () => GetCosmeticSkills()
			});
			return (IEnumerable<IActionsDisplayTab>)list;
		}

		public IEnumerable<ISlotAction> GetAllActions()
		{
			List<ISlotAction> list = new List<ISlotAction>();
			list.AddRange(GetArmor());
			list.AddRange(GetWeapons());
			list.AddRange(GetEquipped());
			list.AddRange(GetDeployables());
			list.AddRange(GetConsumables());
			return list.OrderBy((ISlotAction i) => i.DisplayName);
		}

		public IEnumerable<ISlotAction> GetWeapons()
		{
			List<ISlotAction> list = new List<ISlotAction>();
			list.AddRange(from s in _inventory.Equipment.EquipmentSlots
				where (Object)(object)s != (Object)null && s.HasItemEquipped && ((int)s.SlotType == 6 || (int)s.SlotType == 5)
				select s into e
				select _slotData.GetSlotAction((Item)(object)e.EquippedItem));
			list.AddRange(from i in _inventory.Pouch.GetContainedItems()
				where i is Weapon
				select i into w
				select _slotData.GetSlotAction(w));
			if (_inventory.HasABag)
			{
				list.AddRange(from i in ((ItemContainer)_inventory.EquippedBag.Container).GetContainedItems()
					where i is Weapon
					select i into w
					select _slotData.GetSlotAction(w));
			}
			return list;
		}

		public IEnumerable<ISlotAction> GetActiveSkills()
		{
			return from Skill s in ((CharacterKnowledge)_inventory.SkillKnowledge).GetLearnedItems()
				where ((Item)s).IsQuickSlotable && !s.IsCosmetic && !(s is EquipmentSetSkill)
				select _slotData.GetSlotAction((Item)(object)s);
		}

		public IEnumerable<ISlotAction> GetCosmeticSkills()
		{
			return from Skill s in ((CharacterKnowledge)_inventory.SkillKnowledge).GetLearnedItems()
				where ((Item)s).IsQuickSlotable && s.IsCosmetic && !(s is EquipmentSetSkill)
				select _slotData.GetSlotAction((Item)(object)s);
		}

		public IEnumerable<ISlotAction> GetConsumables()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return from i in _inventory.GetOwnedItems(TagSourceManager.Consumable)
				group i by i.ItemID into i
				select _slotData.GetSlotAction(i.First());
		}

		public IEnumerable<ISlotAction> GetDeployables()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return from s in _inventory.GetOwnedItems(TagSourceManager.Deployable)
				select _slotData.GetSlotAction(s);
		}

		public IEnumerable<ISlotAction> GetEquipped()
		{
			return from s in _inventory.Equipment.EquipmentSlots
				where (Object)(object)s != (Object)null && s.HasItemEquipped
				select s into e
				select _slotData.GetSlotAction((Item)(object)e.EquippedItem);
		}

		public IEnumerable<ISlotAction> GetArmor()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			return from s in ((IEnumerable<Item>)(from s in _inventory.Equipment.EquipmentSlots
					where (Object)(object)s != (Object)null && s.HasItemEquipped && ((int)s.SlotType == 0 || (int)s.SlotType == 1 || (int)s.SlotType == 3)
					select s into e
					select e.EquippedItem)).Union(_inventory.GetOwnedItems(TagSourceManager.Armor))
				select _slotData.GetSlotAction(s);
		}
	}
	internal class SlotDataService : IDisposable
	{
		private readonly Func<IModifLogger> _getLogger;

		private readonly Player _rewiredPlayer;

		private readonly Character _character;

		private readonly CharacterInventory _inventory;

		private readonly IHotbarProfileService _profileService;

		private bool disposedValue;

		private IModifLogger Logger => _getLogger();

		public SlotDataService(Player rewiredPlayer, Character character, IHotbarProfileService profileService, Func<IModifLogger> getLogger)
		{
			if (rewiredPlayer == null)
			{
				throw new ArgumentNullException("rewiredPlayer");
			}
			if ((Object)(object)character == (Object)null)
			{
				throw new ArgumentNullException("character");
			}
			_rewiredPlayer = rewiredPlayer;
			_character = character;
			_inventory = character.Inventory;
			_profileService = profileService;
			_getLogger = getLogger;
		}

		public bool TryGetItemSlotAction(SlotData slotData, bool combatModeEnabled, out ISlotAction slotAction)
		{
			return TryGetItemSlotAction(slotData.ItemID, slotData.ItemUID, combatModeEnabled, out slotAction);
		}

		public bool TryGetItemSlotAction(int itemID, string itemUID, bool combatModeEnabled, out ISlotAction slotAction)
		{
			slotAction = null;
			if (!TryFindOwnedItem(itemID, itemUID, out var item) && !TryFindPrefab(itemID, out item))
			{
				return false;
			}
			Skill val = (Skill)(object)((item is Skill) ? item : null);
			if (val != null)
			{
				slotAction = (ISlotAction)(object)new SkillSlotAction(val, _rewiredPlayer, _character, this, combatModeEnabled, _getLogger);
			}
			else
			{
				Equipment val2 = (Equipment)(object)((item is Equipment) ? item : null);
				if (val2 != null)
				{
					slotAction = (ISlotAction)(object)new EquipmentSlotAction(val2, _rewiredPlayer, _character, this, combatModeEnabled, _getLogger);
				}
				else
				{
					slotAction = (ISlotAction)(object)new ItemSlotAction(item, _rewiredPlayer, _character, this, combatModeEnabled, _getLogger);
				}
			}
			return slotAction != null;
		}

		public bool TryFindOwnedItem(int itemId, string uid, out Item item)
		{
			item = null;
			IEnumerable<Item> source = from s in ((CharacterKnowledge)_inventory.SkillKnowledge).GetLearnedItems()
				where s.ItemID == itemId
				select s;
			if (source.Any())
			{
				item = source.FirstOrDefault((Func<Item, bool>)((Item s) => s.ItemID == itemId)) ?? source.First();
				return true;
			}
			if (!_inventory.OwnsOrHasEquipped(itemId))
			{
				return false;
			}
			if (!string.IsNullOrEmpty(uid))
			{
				Item item2 = ItemManager.Instance.GetItem(uid);
				if ((Object)(object)item2 != (Object)null && (Object)(object)((EffectSynchronizer)item2).OwnerCharacter == (Object)(object)_character)
				{
					item = item2;
					return true;
				}
			}
			List<Item> ownedItems = _inventory.GetOwnedItems(itemId);
			if (ownedItems != null && ownedItems.Any())
			{
				item = ownedItems.First();
				return true;
			}
			_inventory.Equipment.OwnsItem(itemId, ref item);
			return (Object)(object)item != (Object)null;
		}

		public bool TryFindPrefab(int itemId, out Item item)
		{
			item = ResourcesPrefabManager.Instance.GetItemPrefab(itemId);
			return (Object)(object)item != (Object)null;
		}

		public ISlotAction GetSlotAction(Item item)
		{
			Skill val = (Skill)(object)((item is Skill) ? item : null);
			if (val != null)
			{
				Player rewiredPlayer = _rewiredPlayer;
				Character character = _character;
				IHotbarProfile profile = _profileService.GetProfile();
				return (ISlotAction)(object)new SkillSlotAction(val, rewiredPlayer, character, this, profile == null || profile.CombatMode, _getLogger);
			}
			Equipment val2 = (Equipment)(object)((item is Equipment) ? item : null);
			if (val2 != null)
			{
				Player rewiredPlayer2 = _rewiredPlayer;
				Character character2 = _character;
				IHotbarProfile profile2 = _profileService.GetProfile();
				return (ISlotAction)(object)new EquipmentSlotAction(val2, rewiredPlayer2, character2, this, profile2 == null || profile2.CombatMode, _getLogger);
			}
			Player rewiredPlayer3 = _rewiredPlayer;
			Character character3 = _character;
			IHotbarProfile profile3 = _profileService.GetProfile();
			return (ISlotAction)(object)new ItemSlotAction(item, rewiredPlayer3, character3, this, profile3 == null || profile3.CombatMode, _getLogger);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!disposedValue)
			{
				if (disposing)
				{
				}
				disposedValue = true;
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	internal class DurabilityDisplayService
	{
		private readonly Func<IModifLogger> _loggerFactory;

		private PlayerMenuService _playerMenuService;

		private LevelCoroutines _coroutines;

		private bool _unequipedAdded;

		private bool _equipTracked = false;

		private bool _configured = false;

		private static readonly UnequippedDurabilityTracker UnequippedHelm = new UnequippedDurabilityTracker((EquipSlots)1, (DurableEquipmentType)1, 1f);

		private static readonly UnequippedDurabilityTracker UnequippedChest = new UnequippedDurabilityTracker((EquipSlots)2, (DurableEquipmentType)2, 1f);

		private static readonly UnequippedDurabilityTracker UnequippedBoots = new UnequippedDurabilityTracker((EquipSlots)5, (DurableEquipmentType)6, 1f);

		private static readonly Dictionary<EquipSlots, UnequippedDurabilityTracker> Unequipped = new Dictionary<EquipSlots, UnequippedDurabilityTracker>
		{
			{ UnequippedHelm.DurableEquipmentSlot, UnequippedHelm },
			{ UnequippedChest.DurableEquipmentSlot, UnequippedChest },
			{ UnequippedBoots.DurableEquipmentSlot, UnequippedBoots }
		};

		private IModifLogger Logger => _loggerFactory();

		public DurabilityDisplayService(PlayerMenuService playerMenuService, LevelCoroutines coroutines, Func<IModifLogger> loggerFactory)
		{
			_playerMenuService = playerMenuService;
			_coroutines = coroutines;
			_loggerFactory = loggerFactory;
			EquipmentPatches.AfterOnEquip += TrackEquippedItem;
			EquipmentPatches.AfterOnUnequip += UntrackEquippedItem;
			_playerMenuService.OnPlayerActionMenusConfigured += TryConfigureShowHide;
			SplitScreenManagerPatches.RemoveLocalPlayerAfter += SplitScreenManagerPatches_RemoveLocalPlayerAfter;
		}

		private void TryConfigureShowHide(PlayerActionMenus actionMenus, SplitPlayer splitPlayer)
		{
			try
			{
				ConfigureShowHide(actionMenus, splitPlayer);
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to configure DurabilityDisplayService.", ex);
			}
		}

		private void ConfigureShowHide(PlayerActionMenus actionMenus, SplitPlayer splitPlayer)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(splitPlayer.RewiredID);
			IActionUIProfileService profileService = servicesProvider.GetService<IActionUIProfileService>();
			Reset(actionMenus);
			profileService.OnActiveProfileChanged += delegate(IActionUIProfile profile)
			{
				ShowHide(splitPlayer.RewiredID, profile.DurabilityDisplayEnabled);
			};
			profileService.OnActiveProfileSwitched += delegate(IActionUIProfile profile)
			{
				ShowHide(splitPlayer.RewiredID, profile.DurabilityDisplayEnabled);
			};
			if (actionMenus.DurabilityDisplay.IsAwake)
			{
				ShowHide(splitPlayer.RewiredID, profileService.GetActiveProfile().DurabilityDisplayEnabled);
			}
			else
			{
				actionMenus.DurabilityDisplay.OnAwake.AddListener((UnityAction)delegate
				{
					ShowHide(splitPlayer.RewiredID, profileService.GetActiveProfile().DurabilityDisplayEnabled);
				});
			}
			_configured = true;
		}

		private void Reset(PlayerActionMenus actionMenus)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!actionMenus.DurabilityDisplay.IsAwake)
			{
				return;
			}
			Logger.LogDebug(string.Format("{0}::{1}: Stopping Durability tracking for all slots for rewiredId={2}.", "DurabilityDisplayService", "Reset", actionMenus.PlayerID));
			foreach (EquipSlots item in Enum.GetValues(typeof(EquipSlots)).Cast<EquipSlots>())
			{
				actionMenus.DurabilityDisplay.StopTracking(item);
			}
		}

		private void ShowHide(int playerId, bool showDurabilityDisplay)
		{
			Logger.LogDebug(string.Format("{0}::{1}: playerId={2}, showDurabilityDisplay={3}", "DurabilityDisplayService", "ShowHide", playerId, showDurabilityDisplay));
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(playerId);
			PlayerActionMenus service = servicesProvider.GetService<PlayerActionMenus>();
			DurabilityDisplay durabilityDisplay = service.DurabilityDisplay;
			if (showDurabilityDisplay)
			{
				if (!((Component)durabilityDisplay).gameObject.activeSelf)
				{
					((Component)durabilityDisplay).gameObject.SetActive(true);
				}
				_equipTracked = true;
				SplitPlayer val = ((IEnumerable<SplitPlayer>)SplitScreenManager.Instance.LocalPlayers).FirstOrDefault((Func<SplitPlayer, bool>)((SplitPlayer p) => p.RewiredID == playerId));
				if (val != null && (Object)(object)((val != null) ? val.AssignedCharacter : null) != (Object)null)
				{
					AddUnequippedTrackers(val.RewiredID);
					durabilityDisplay.StopTracking((EquipSlots)4);
					durabilityDisplay.StopTracking((EquipSlots)3);
					TrackAllEquipment(val.AssignedCharacter);
				}
			}
			else
			{
				if (((Component)durabilityDisplay).gameObject.activeSelf)
				{
					((Component)durabilityDisplay).gameObject.SetActive(false);
				}
				if (_equipTracked)
				{
					durabilityDisplay.StopAllTracking();
					_equipTracked = false;
				}
			}
		}

		private void TrackAllEquipment(Character character)
		{
			Logger.LogDebug(string.Format("{0}::{1}: Player RewiredID {2}", "DurabilityDisplayService", "TrackAllEquipment", character.CharacterUI.RewiredID));
			TrackEquipmentSlot(character, (EquipmentSlotIDs)0);
			TrackEquipmentSlot(character, (EquipmentSlotIDs)1);
			TrackEquipmentSlot(character, (EquipmentSlotIDs)3);
			TrackEquipmentSlot(character, (EquipmentSlotIDs)5);
			TrackEquipmentSlot(character, (EquipmentSlotIDs)6);
		}

		public void UntrackAllEquipment()
		{
		}

		private void TrackEquipmentSlot(Character character, EquipmentSlotIDs slot)
		{
			//IL_000c: 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_006f: 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_007f: Expected O, but got Unknown
			if (!character.Inventory.Equipment.IsEquipmentSlotEmpty(slot))
			{
				Logger.LogDebug(string.Format("{0}::{1}: Tracking Equipment Slot {2} for Player RewiredID {3}", "DurabilityDisplayService", "TrackEquipmentSlot", slot, character.CharacterUI.RewiredID));
				TrackEquippedItem(character, (Equipment)character.Inventory.Equipment.GetEquippedItem(slot));
			}
		}

		private void SplitScreenManagerPatches_RemoveLocalPlayerAfter(SplitScreenManager splitScreenManager, SplitPlayer player, string playerUID)
		{
			ShowHide(player.RewiredID, showDurabilityDisplay: false);
		}

		private void AddUnequippedTrackers(int playerId)
		{
			Logger.LogDebug(string.Format("{0}::{1}: Adding Unequipped Helm, Chest and Boots trackers for  for playerId {2}", "DurabilityDisplayService", "AddUnequippedTrackers", playerId));
			DurabilityDisplay durabilityDisplay = GetDurabilityDisplay(playerId);
			durabilityDisplay.TrackDurability((IDurability)(object)UnequippedHelm);
			durabilityDisplay.TrackDurability((IDurability)(object)UnequippedChest);
			durabilityDisplay.TrackDurability((IDurability)(object)UnequippedBoots);
			_unequipedAdded = true;
		}

		private void TrackEquippedItem(Character character, Equipment equipment)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if (!_equipTracked)
			{
				return;
			}
			DurabilityDisplay durabilityDisplay = GetDurabilityDisplay(character.OwnerPlayerSys.PlayerID);
			if ((Object)(object)durabilityDisplay == (Object)null)
			{
				return;
			}
			EquipSlots val = ((Item)equipment).CurrentEquipmentSlot.SlotType.ToDurableEquipmentSlot();
			if ((int)val == 0)
			{
				return;
			}
			if (!_unequipedAdded)
			{
				AddUnequippedTrackers(character.OwnerPlayerSys.PlayerID);
			}
			if (((Item)equipment).IsIndestructible || !character.Inventory.Equipment.HasItemEquipped(((Item)equipment).CurrentEquipmentSlot.SlotType))
			{
				if (Unequipped.TryGetValue(val, out var value))
				{
					durabilityDisplay.TrackDurability((IDurability)(object)value);
				}
				else
				{
					durabilityDisplay.StopTracking(val);
				}
			}
			else
			{
				Logger.LogDebug($"Tracking durability of equipment {((Object)equipment).name} for player {character.OwnerPlayerSys.PlayerID}.");
				durabilityDisplay.TrackDurability((IDurability)(object)new DurabilityTracker(equipment));
			}
		}

		private void UntrackEquippedItem(Character character, Equipment equipment)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if (!_equipTracked)
			{
				return;
			}
			DurabilityDisplay durabilityDisplay = GetDurabilityDisplay(character.OwnerPlayerSys.PlayerID);
			if ((Object)(object)durabilityDisplay == (Object)null)
			{
				return;
			}
			EquipSlots val = ((Item)equipment).CurrentEquipmentSlot.SlotType.ToDurableEquipmentSlot();
			if ((int)val == 0)
			{
				return;
			}
			if (!_unequipedAdded)
			{
				AddUnequippedTrackers(character.OwnerPlayerSys.PlayerID);
			}
			if (character.Inventory.Equipment.IsEquipmentSlotEmpty(equipment.EquipSlot))
			{
				if (!character.Inventory.Equipment.HasItemEquipped(((Item)equipment).CurrentEquipmentSlot.SlotType) && Unequipped.TryGetValue(val, out var value))
				{
					durabilityDisplay.TrackDurability((IDurability)(object)value);
					return;
				}
				durabilityDisplay.StopTracking(val);
				Logger.LogDebug($"Stopped tracking durability of equipment {((Object)equipment).name} for player {character.OwnerPlayerSys.PlayerID}.");
			}
		}

		private DurabilityDisplay GetDurabilityDisplay(int playerId)
		{
			UnityServicesProvider val = default(UnityServicesProvider);
			PlayerActionMenus val2 = default(PlayerActionMenus);
			if (Psp.Instance.TryGetServicesProvider(playerId, ref val) && val.TryGetService<PlayerActionMenus>(ref val2))
			{
				return val2.DurabilityDisplay;
			}
			return null;
		}
	}
	public class GlobalActionUIProfileService : IActionUIProfileService
	{
		private class GlobalActionUIProfile : IActionUIProfile
		{
			public string Name { get; set; } = "Global";


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


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


			public bool EquipmentSetsEnabled
			{
				get
				{
					return false;
				}
				set
				{
				}
			}

			public EquipmentSetsSettingsProfile EquipmentSetsSettingsProfile { get; set; } = new EquipmentSetsSettingsProfile();


			public StashSettingsProfile StashSettingsProfile { get; set; } = new StashSettingsProfile();


			public StorageSettingsProfile StorageSettingsProfile { get; set; } = new StorageSettingsProfile();

		}

		private GlobalActionUIProfile _globalProfile = new GlobalActionUIProfile();

		public event Action<IActionUIProfile> OnActiveProfileChanged;

		public event Action<IActionUIProfile> OnActiveProfileSwitched;

		public event Action<IActionUIProfile> OnActiveProfileSwitching;

		public IActionUIProfile GetActiveProfile()
		{
			return (IActionUIProfile)(object)_globalProfile;
		}

		public IEnumerable<string> GetProfileNames()
		{
			return new string[1] { "Global" };
		}

		public void Save()
		{
		}

		public void SaveNew(IActionUIProfile profile)
		{
		}

		public void SetActiveProfile(string name)
		{
		}

		public void Rename(string newName)
		{
		}
	}
	public class GlobalConfigService
	{
		public static GlobalConfigService Instance { get; private set; }

		public PositionsProfile PositionsProfile { get; private set; }

		public IHotbarProfile NavPanelProfile { get; private set; }

		public GlobalConfigService()
		{
			Instance = this;
			LoadPositions();
		}

		public void LoadPositions()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (string.IsNullOrEmpty(ActionUISettings.SerializedPositions.Value))
			{
				PositionsProfile = new PositionsProfile();
				return;
			}
			try
			{
				PositionsProfile = JsonConvert.DeserializeObject<PositionsProfile>(ActionUISettings.SerializedPositions.Value);
			}
			catch
			{
				PositionsProfile = new PositionsProfile();
			}
		}

		public void SavePositions()
		{
			if (PositionsProfile != null)
			{
				ActionUISettings.SerializedPositions.Value = JsonConvert.SerializeObject((object)PositionsProfile, (Formatting)0);
			}
		}
	}
	public class GlobalHotbarService : IHotbarProfileService
	{
		private HotbarProfileData _cachedProfile;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private Action<IHotbarProfile, HotbarProfileChangeTypes> m_OnProfileChanged;

		private IModifLogger Logger = LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		private CharacterSlotData _activeCharacterSlotData;

		private string _activeCharacterUID;

		private const int LegacyNoWeaponType = -1;

		private bool _isSaving = false;

		public event Action<IHotbarProfile, HotbarProfileChangeTypes> OnProfileChanged
		{
			[CompilerGenerated]
			add
			{
				Action<IHotbarProfile, HotbarProfileChangeTypes> val = this.m_OnProfileChanged;
				Action<IHotbarProfile, HotbarProfileChangeTypes> val2;
				do
				{
					val2 = val;
					Action<IHotbarProfile, HotbarProfileChangeTypes> value2 = (Action<IHotbarProfile, HotbarProfileChangeTypes>)(object)Delegate.Combine((Delegate?)(object)val2, (Delegate?)(object)value);
					val = Interlocked.CompareExchange(ref this.m_OnProfileChanged, value2, val2);
				}
				while (val != val2);
			}
			[CompilerGenerated]
			remove
			{
				Action<IHotbarProfile, HotbarProfileChangeTypes> val = this.m_OnProfileChanged;
				Action<IHotbarProfile, HotbarProfileChangeTypes> val2;
				do
				{
					val2 = val;
					Action<IHotbarProfile, HotbarProfileChangeTypes> value2 = (Action<IHotbarProfile, HotbarProfileChangeTypes>)(object)Delegate.Remove((Delegate?)(object)val2, (Delegate?)(object)value);
					val = Interlocked.CompareExchange(ref this.m_OnProfileChanged, value2, val2);
				}
				while (val != val2);
			}
		}

		public GlobalHotbarService()
		{
			LoadProfile();
			ActionUISettings.Rows.SettingChanged += delegate
			{
				UpdateFromSettings((HotbarProfileChangeTypes)3);
			};
			ActionUISettings.SlotsPerRow.SettingChanged += delegate
			{
				UpdateFromSettings((HotbarProfileChangeTypes)5);
			};
			ActionUISettings.Scale.SettingChanged += delegate
			{
				UpdateFromSettings((HotbarProfileChangeTypes)11);
			};
			ActionUISettings.HideLeftNav.SettingChanged += delegate
			{
				UpdateFromSettings((HotbarProfileChangeTypes)10);
			};
			ActionUISettings.CombatMode.SettingChanged += delegate
			{
				UpdateFromSettings((HotbarProfileChangeTypes)8);
			};
			ActionUISettings.ShowCooldownTimer.SettingChanged += delegate
			{
				UpdateFromSettings((HotbarProfileChangeTypes)7);
			};
			ActionUISettings.PreciseCooldownTime.SettingChanged += delegate
			{
				UpdateFromSettings((HotbarProfileChangeTypes)7);
			};
		}

		private void LoadProfile()
		{
			string value = ActionUISettings.SerializedHotbars.Value;
			if (string.IsNullOrEmpty(value))
			{
				_cachedProfile = CreateDefaultProfile();
				Save();
				return;
			}
			try
			{
				_cachedProfile = JsonConvert.DeserializeObject<HotbarProfileData>(value);
				if (_cachedProfile == null)
				{
					_cachedProfile = CreateDefaultProfile();
				}
				SyncSettingsToProfile(_cachedProfile);
			}
			catch
			{
				_cachedProfile = CreateDefaultProfile();
			}
		}

		private void SyncSettingsToProfile(HotbarProfileData profile)
		{
			profile.Rows = ActionUISettings.Rows.Value;
			profile.SlotsPerRow = ActionUISettings.SlotsPerRow.Value;
			profile.Scale = ActionUISettings.Scale.Value;
			profile.HideLeftNav = ActionUISettings.HideLeftNav.Value;
			profile.CombatMode = ActionUISettings.CombatMode.Value;
			foreach (IHotbarSlotData hotbar in profile.Hotbars)
			{
				foreach (ISlotData slot in hotbar.Slots)
				{
					slot.Config.ShowCooldownTime = ActionUISettings.ShowCooldownTimer.Value;
					slot.Config.PreciseCooldownTime = ActionUISettings.PreciseCooldownTime.Value;
				}
			}
			EnsureDimensions(profile, profile.Rows, profile.SlotsPerRow);
		}

		private void EnsureDimensions(HotbarProfileData profile, int rows, int slotsPerRow)
		{
			if (profile == null)
			{
				return;
			}
			profile.Rows = Math.Max(1, rows);
			profile.SlotsPerRow = Math.Max(1, slotsPerRow);
			if (profile.Hotbars == null || profile.Hotbars.Count == 0)
			{
				profile.Hotbars = DeepCloneHotbars(HotbarSettings.DefaulHotbarProfile.Hotbars);
			}
			int num = profile.Rows * profile.SlotsPerRow;
			for (int i = 0; i < profile.Hotbars.Count; i++)
			{
				HotbarData hotbarData = profile.Hotbars[i] as HotbarData;
				if (hotbarData == null)
				{
					hotbarData = new HotbarData
					{
						HotbarIndex = i,
						RewiredActionId = RewiredConstants.ActionSlots.HotbarNavActions[Math.Min(i, RewiredConstants.ActionSlots.HotbarNavActions.Count - 1)].id,
						RewiredActionName = RewiredConstants.ActionSlots.HotbarNavActions[Math.Min(i, RewiredConstants.ActionSlots.HotbarNavActions.Count - 1)].name,
						Slots = new List<ISlotData>()
					};
					profile.Hotbars[i] = (IHotbarSlotData)(object)hotbarData;
				}
				if (hotbarData.Slots == null)
				{
					hotbarData.Slots = new List<ISlotData>();
				}
				if (hotbarData.Slots.Count == 0)
				{
					hotbarData.Slots.Add((ISlotData)(object)CreateDefaultSlotData(0));
				}
				while (hotbarData.Slots.Count < num)
				{
					hotbarData.Slots.Add((ISlotData)(object)CreateSlotDataFrom(hotbarData.Slots[0], hotbarData.Slots.Count));
				}
				if (hotbarData.Slots.Count > num)
				{
					hotbarData.Slots.RemoveRange(num, hotbarData.Slots.Count - num);
				}
				ReindexSlots(hotbarData.Slots);
			}
		}

		private HotbarProfileData CreateDefaultProfile()
		{
			HotbarProfileData hotbarProfileData = new HotbarProfileData
			{
				Rows = ActionUISettings.Rows.Value,
				SlotsPerRow = ActionUISettings.SlotsPerRow.Value,
				Scale = ActionUISettings.Scale.Value,
				HideLeftNav = ActionUISettings.HideLeftNav.Value,
				CombatMode = ActionUISettings.CombatMode.Value,
				Hotbars = DeepCloneHotbars(HotbarSettings.DefaulHotbarProfile.Hotbars),
				NextRewiredActionId = RewiredConstants.ActionSlots.NextHotbarAction.id,
				NextRewiredActionName = RewiredConstants.ActionSlots.NextHotbarAction.name,
				PrevRewiredActionId = RewiredConstants.ActionSlots.PreviousHotbarAction.id,
				PrevRewiredActionName = RewiredConstants.ActionSlots.PreviousHotbarAction.name,
				NextRewiredAxisActionName = RewiredConstants.ActionSlots.NextHotbarAxisAction.name,
				NextRewiredAxisActionId = RewiredConstants.ActionSlots.NextHotbarAxisAction.id,
				PrevRewiredAxisActionName = RewiredConstants.ActionSlots.PreviousHotbarAxisAction.name,
				PrevRewiredAxisActionId = RewiredConstants.ActionSlots.PreviousHotbarAxisAction.id
			};
			EnsureDimensions(hotbarProfileData, hotbarProfileData.Rows, hotbarProfileData.SlotsPerRow);
			return hotbarProfileData;
		}

		public IHotbarProfile GetProfile()
		{
			if (_cachedProfile == null)
			{
				LoadProfile();
			}
			return (IHotbarProfile)(object)_cachedProfile;
		}

		public void Save()
		{
			SaveNew(GetProfile());
		}

		public void SaveNew(IHotbarProfile hotbarProfile)
		{
			if (_isSaving)
			{
				return;
			}
			_isSaving = true;
			try
			{
				if (ActionUISettings.Rows.Value != hotbarProfile.Rows)
				{
					ActionUISettings.Rows.Value = hotbarProfile.Rows;
				}
				if (ActionUISettings.SlotsPerRow.Value != hotbarProfile.SlotsPerRow)
				{
					ActionUISettings.SlotsPerRow.Value = hotbarProfile.SlotsPerRow;
				}
				if (ActionUISettings.Scale.Value != hotbarProfile.Scale)
				{
					ActionUISettings.Scale.Value = hotbarProfile.Scale;
				}
				if (ActionUISettings.HideLeftNav.Value != hotbarProfile.HideLeftNav)
				{
					ActionUISettings.HideLeftNav.Value = hotbarProfile.HideLeftNav;
				}
				if (ActionUISettings.CombatMode.Value != hotbarProfile.CombatMode)
				{
					ActionUISettings.CombatMode.Value = hotbarProfile.CombatMode;
				}
				if (hotbarProfile.Hotbars.Count > 0 && hotbarProfile.Hotbars[0].Slots.Count > 0)
				{
					IActionSlotConfig config = hotbarProfile.Hotbars[0].Slots[0].Config;
					if (ActionUISettings.ShowCooldownTimer.Value != config.ShowCooldownTime)
					{
						ActionUISettings.ShowCooldownTimer.Value = config.ShowCooldownTime;
					}
					if (ActionUISettings.PreciseCooldownTime.Value != config.PreciseCooldownTime)
					{
						ActionUISettings.PreciseCooldownTime.Value = config.PreciseCooldownTime;
					}
				}
				string text = JsonConvert.SerializeObject((object)hotbarProfile, (Formatting)0);
				if (ActionUISettings.SerializedHotbars.Value != text)
				{
					ActionUISettings.SerializedHotbars.Value = text;
				}
			}
			finally
			{
				_isSaving = false;
			}
		}

		public IHotbarProfile AddHotbar()
		{
			int num = GetProfile().Hotbars.Last().HotbarIndex + 1;
			HotbarData hotbarData = new HotbarData
			{
				HotbarIndex = num,
				RewiredActionId = RewiredConstants.ActionSlots.HotbarNavActions[num].id,
				RewiredActionName = RewiredConstants.ActionSlots.HotbarNavActions[num].name
			};
			foreach (ISlotData slot in GetProfile().Hotbars.First().Slots)
			{
				SlotData slotData = slot as SlotData;
				hotbarData.Slots.Add((ISlotData)(object)CreateSlotDataFrom(slot, slot.SlotIndex));
			}
			GetProfile().Hotbars.Add((IHotbarSlotData)(object)hotbarData);
			Save();
			this.OnProfileChanged?.Invoke(GetProfile(), (HotbarProfileChangeTypes)1);
			return GetProfile();
		}

		public IHotbarProfile RemoveHotbar()
		{
			if (GetProfile().Hotbars.Count > 1)
			{
				GetProfile().Hotbars.RemoveAt(GetProfile().Hotbars.Count - 1);
				Save();
				this.OnProfileChanged?.Invoke(GetProfile(), (HotbarProfileChangeTypes)2);
			}
			return GetProfile();
		}

		public IHotbarProfile AddRow()
		{
			IHotbarProfile profile = GetProfile();
			int rows = profile.Rows;
			profile.Rows = rows + 1;
			SyncStructure();
			Save();
			this.OnProfileChanged?.Invoke(GetProfile(), (HotbarProfileChangeTypes)3);
			return GetProfile();
		}

		public IHotbarProfile RemoveRow()
		{
			if (GetProfile().Rows > 1)
			{
				IHotbarProfile profile = GetProfile();
				int rows = profile.Rows;
				profile.Rows = rows - 1;
				SyncStructure();
				Save();
				this.OnProfileChanged?.Invoke(GetProfile(), (HotbarProfileChangeTypes)4);
			}
			return GetProfile();
		}

		public IHotbarProfile AddSlot()
		{
			IHotbarProfile profile = GetProfile();
			int slotsPerRow = profile.SlotsPerRow;
			profile.SlotsPerRow = slotsPerRow + 1;
			SyncStructure();
			Save();
			this.OnProfileChanged?.Invoke(GetProfile(), (HotbarProfileChangeTypes)5);
			return GetProfile();
		}

		public IHotbarProfile RemoveSlot()
		{
			if (GetProfile().SlotsPerRow > 1)
			{
				IHotbarProfile profile = GetProfile();
				int slotsPerRow = profile.SlotsPerRow;
				profile.SlotsPerRow = slotsPerRow - 1;
				SyncStructure();
				Save();
				this.OnProfileChanged?.Invoke(GetProfile(), (HotbarProfileChangeTypes)6);
			}
			return GetProfile();
		}

		public void Update(HotbarsContainer hotbar)
		{
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			if (((hotbar != null) ? hotbar.Hotbars : null) != null && _cachedProfile?.Hotbars != null)
			{
				bool flag = true;
				for (int i = 0; i < hotbar.Hotbars.Length; i++)
				{
					if (hotbar.Hotbars[i].Any((ActionSlot s) => s.SlotAction != null))
					{
						flag = false;
						break;
					}
				}
				bool flag2 = false;
				if (flag)
				{
					bool flag3 = false;
					foreach (IHotbarSlotData hotbar2 in _cachedProfile.Hotbars)
					{
						if (hotbar2.Slots.Any((ISlotData s) => s.ItemID > 0 || !string.IsNullOrEmpty(s.ItemUID)))
						{
							flag3 = true;
							break;
						}
					}
					if (flag3)
					{
						Logger.LogWarning("GlobalHotbarService: Detected update from EMPTY UI while profile has items. Preserving item assignments and syncing slot config only.");
						flag2 = true;
					}
				}
				for (int j = 0; j < hotbar.Hotbars.Length && j < _cachedProfile.Hotbars.Count; j++)
				{
					ActionSlot[] array = hotbar.Hotbars[j];
					IHotbarSlotData val = _cachedProfile.Hotbars[j];
					for (int k = 0; k < array.Length && k < val.Slots.Count; k++)
					{
						ActionSlot val2 = array[k];
						ISlotData val3 = val.Slots[k];
						if (!flag2 && val2.SlotAction != null)
						{
							val3.ItemID = val2.SlotAction.ActionId;
							val3.ItemUID = val2.SlotAction.ActionUid;
						}
						else if (!flag2)
						{
							val3.ItemID = -1;
							val3.ItemUID = null;
						}
						if (val2.Config != null)
						{
							val3.Config.EmptySlotOption = val2.Config.EmptySlotOption;
							val3.Config.IsDisabled = val2.Config.IsDisabled;
							val3.Config.IsDynamic = val2.Config.IsDynamic;
						}
					}
				}
			}
			Save();
		}

		public IHotbarProfile SetCooldownTimer(bool showTimer, bool preciseTime)
		{
			_cachedProfile.ShowCooldownTimer = showTimer;
			foreach (IHotbarSlotData hotbar in _cachedProfile.Hotbars)
			{
				foreach (ISlotData slot in hotbar.Slots)
				{
					slot.Config.ShowCooldownTime = showTimer;
					slot.Config.PreciseCooldownTime = preciseTime;
				}
			}
			Save();
			this.OnProfileChanged?.Invoke((IHotbarProfile)(object)_cachedProfile, (HotbarProfileChangeTypes)7);
			return (IHotbarProfile)(object)_cachedProfile;
		}

		public IHotbarProfile SetCombatMode(bool combatMode)
		{
			_cachedProfile.CombatMode = combatMode;
			Save();
			this.OnProfileChanged?.Invoke((IHotbarProfile)(object)_cachedProfile, (HotbarProfileChangeTypes)8);
			return (IHotbarProfile)(object)_cachedProfile;
		}

		public IHotbarProfile SetEmptySlotView(EmptySlotOptions option)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			foreach (IHotbarSlotData hotbar in _cachedProfile.Hotbars)
			{
				foreach (ISlotData slot in hotbar.Slots)
				{
					slot.Config.EmptySlotOption = option;
				}
			}
			Save();
			this.OnProfileChanged?.Invoke((IHotbarProfile)(object)_cachedProfile, (HotbarProfileChangeTypes)9);
			return (IHotbarProfile)(object)_cachedProfile;
		}

		public IHotbarProfile SetHideLeftNav(bool hideLeftNav)
		{
			_cachedProfile.HideLeftNav = hideLeftNav;
			Save();
			this.OnProfileChanged?.Invoke((IHotbarProfile)(object)_cachedProfile, (HotbarProfileChangeTypes)10);
			return (IHotbarProfile)(object)_cachedProfile;
		}

		public IHotbarProfile SetScale(int scale)
		{
			_cachedProfile.Scale = scale;
			Save();
			this.OnProfileChanged?.Invoke((IHotbarProfile)(object)_cachedProfile, (HotbarProfileChangeTypes)11);
			return (IHotbarProfile)(object)_cachedProfile;
		}

		private void SyncStructure()
		{
			EnsureDimensions(_cachedProfile, _cachedProfile.Rows, _cachedProfile.SlotsPerRow);
		}

		private void UpdateFromSettings(HotbarProfileChangeTypes type)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!_isSaving)
			{
				SyncSettingsToProfile(_cachedProfile);
				SyncStructure();
				Save();
				this.OnProfileChanged?.Invoke((IHotbarProfile)(object)_cachedProfile, type);
			}
		}

		private void ReindexSlots(List<ISlotData> slots)
		{
			for (int i = 0; i < slots.Count; i++)
			{
				slots[i].SlotIndex = i;
				if (i < RewiredConstants.ActionSlots.Actions.Count)
				{
					((ActionConfig)(object)slots[i].Config).RewiredActionId = RewiredConstants.ActionSlots.Actions[i].id;
					((ActionConfig)(object)slots[i].Config).RewiredActionName = RewiredConstants.ActionSlots.Actions[i].name;
				}
			}
		}

		private SlotData CreateSlotDataFrom(ISlotData source, int slotIndex)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			ActionConfig config = new ActionConfig
			{
				EmptySlotOption = source.Config.EmptySlotOption,
				ShowCooldownTime = source.Config.ShowCooldownTime,
				PreciseCooldownTime = source.Config.PreciseCooldownTime,
				ShowZeroStackAmount = source.Config.ShowZeroStackAmount,
				IsDisabled = source.Config.IsDisabled,
				IsDynamic = source.Config.IsDynamic
			};
			return new SlotData
			{
				SlotIndex = slotIndex,
				Config = (IActionSlotConfig)(object)config,
				ItemID = -1,
				ItemUID = null
			};
		}

		private List<IHotbarSlotData> DeepCloneHotbars(List<IHotbarSlotData> original)
		{
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got I4
			//IL_01c0->IL01c0: Incompatible stack types: O vs I4
			//IL_01bb->IL01c0: Incompatible stack types: I4 vs O
			//IL_01bb->IL01c0: Incompatible stack types: O vs I4
			List<IHotbarSlotData> list = new List<IHotbarSlotData>();
			if (original == null)
			{
				return list;
			}
			for (int i = 0; i < original.Count; i++)
			{
				IHotbarSlotData val = original[i];
				HotbarData hotbarData = val as HotbarData;
				HotbarData hotbarData2 = new HotbarData
				{
					HotbarIndex = val.HotbarIndex,
					RewiredActionId = (hotbarData?.RewiredActionId ?? RewiredConstants.ActionSlots.HotbarNavActions[Math.Min(i, RewiredConstants.ActionSlots.HotbarNavActions.Count - 1)].id),
					RewiredActionName = (hotbarData?.RewiredActionName ?? RewiredConstants.ActionSlots.HotbarNavActions[Math.Min(i, RewiredConstants.ActionSlots.HotbarNavActions.Count - 1)].name),
					HotbarHotkey = val.HotbarHotkey,
					Slots = new List<ISlotData>()
				};
				if (val.Slots != null)
				{
					for (int j = 0; j < val.Slots.Count; j++)
					{
						ISlotData val2 = val.Slots[j];
						object obj = hotbarData2.Slots;
						SlotData slotData = new SlotData
						{
							SlotIndex = val2.SlotIndex,
							ItemID = val2.ItemID,
							ItemUID = val2.ItemUID
						};
						object obj2 = slotData;
						ActionConfig actionConfig = new ActionConfig();
						IActionSlotConfig config = val2.Config;
						actionConfig.HotkeyText = ((config != null) ? config.HotkeyText : null);
						IActionSlotConfig config2 = val2.Config;
						actionConfig.ShowCooldownTime = config2 != null && config2.ShowCooldownTime;
						IActionSlotConfig config3 = val2.Config;
						actionConfig.PreciseCooldownTime = config3 != null && config3.PreciseCooldownTime;
						IActionSlotConfig config4 = val2.Config;
						actionConfig.ShowZeroStackAmount = config4 != null && config4.ShowZeroStackAmount;
						obj2 = actionConfig;
						IActionSlotConfig config5 = val2.Config;
						int num;
						if (config5 == null)
						{
							num = 0;
							obj = num;
							num = (int)obj;
						}
						else
						{
							obj = config5.EmptySlotOption;
							num = (int)obj;
						}
						((ActionConfig)obj2).EmptySlotOption = (EmptySlotOptions)obj;
						actionConfig.RewiredActionName = (val2.Config as ActionConfig)?.RewiredActionName;
						actionConfig.RewiredActionId = (val2.Config as ActionConfig)?.RewiredActionId ?? 0;
						IActionSlotConfig config6 = val2.Config;
						actionConfig.IsDisabled = config6 != null && config6.IsDisabled;
						IActionSlotConfig config7 = val2.Config;
						actionConfig.IsDynamic = config7 != null && config7.IsDynamic;
						((SlotData)obj2).Config = (IActionSlotConfig)(object)actionConfig;
						((List<ISlotData>)num).Add((ISlotData)(object)slotData);
					}
				}
				list.Add((IHotbarSlotData)(object)hotbarData2);
			}
			return list;
		}

		private SlotData CreateDefaultSlotData(int slotIndex)
		{
			int index = Math.Min(slotIndex, RewiredConstants.ActionSlots.Actions.Count - 1);
			return new SlotData
			{
				SlotIndex = slotIndex,
				ItemID = -1,
				ItemUID = null,
				Config = (IActionSlotConfig)(object)new ActionConfig
				{
					RewiredActionId = RewiredConstants.ActionSlots.Actions[index].id,
					RewiredActionName = RewiredConstants.ActionSlots.Actions[index].name,
					EmptySlotOption = (EmptySlotOptions)0,
					ShowCooldownTime = ActionUISettings.ShowCooldownTimer.Value,
					PreciseCooldownTime = ActionUISettings.PreciseCooldownTime.Value,
					ShowZeroStackAmount = false,
					IsDisabled = false,
					IsDynamic = false
				}
			};
		}

		public void LoadCharacterSlots(string characterUID)
		{
			if (string.IsNullOrEmpty(characterUID))
			{
				Logger.LogWarning("LoadCharacterSlots called with empty characterUID");
				return;
			}
			_activeCharacterUID = characterUID;
			_activeCharacterSlotData = new CharacterSlotData
			{
				CharacterUID = characterUID,
				Slots = new Dictionary<string, SlotDataEntry>(),
				DisabledSlots = new HashSet<string>(),
				DynamicPresets = new Dictionary<string, Dictionary<string, SlotDataEntry>>()
			};
			string characterSlotFilePath = GetCharacterSlotFilePath(characterUID);
			if (!File.Exists(characterSlotFilePath))
			{
				Logger.LogDebug("No character slot file found for " + characterUID + " at " + characterSlotFilePath + ". Starting with empty slots.");
				{
					foreach (IHotbarSlotData hotbar in _cachedProfile.Hotbars)
					{
						foreach (ISlotData slot in hotbar.Slots)
						{
							slot.ItemID = -1;
							slot.ItemUID = null;
						}
					}
					return;
				}
			}
			try
			{
				string text = File.ReadAllText(characterSlotFilePath);
				CharacterSlotData characterSlotData = JsonConvert.DeserializeObject<CharacterSlotData>(text);
				if (characterSlotData == null)
				{
					return;
				}
				if (characterSlotData.Slots == null)
				{
					characterSlotData.Slots = new Dictionary<string, SlotDataEntry>();
				}
				if (characterSlotData.DisabledSlots == null)
				{
					characterSlotData.DisabledSlots = new HashSet<string>();
				}
				if (characterSlotData.DynamicPresets == null)
				{
					characterSlotData.DynamicPresets = new Dictionary<string, Dictionary<string, SlotDataEntry>>();
				}
				MigrateLegacyDynamicPresetKeys(characterSlotData);
				_activeCharacterSlotData = characterSlotData;
				foreach (IHotbarSlotData hotbar2 in _cachedProfile.Hotbars)
				{
					int num = _cachedProfile.Hotbars.IndexOf(hotbar2);
					foreach (ISlotData slot2 in hotbar2.Slots)
					{
						int num2 = hotbar2.Slots.IndexOf(slot2);
						string key = $"{num}_{num2}";
						if (characterSlotData.Slots.TryGetValue(key, out var value))
						{
							slot2.ItemID = value.ItemID;
							slot2.ItemUID = value.ItemUID;
						}
						else
						{
							slot2.ItemID = -1;
							slot2.ItemUID = null;
						}
					}
				}
				Logger.LogDebug("Loaded character slots for " + characterUID + " from " + characterSlotFilePath + ".");
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to load character slots for " + characterUID, ex);
			}
		}

		public void SaveCharacterSlots(string characterUID)
		{
			if (string.IsNullOrEmpty(characterUID))
			{
				Logger.LogWarning("SaveCharacterSlots called with empty characterUID");
				return;
			}
			try
			{
				string characterHotbarsPath = ActionUISettings.CharacterHotbarsPath;
				if (!Directory.Exists(characterHotbarsPath))
				{
					Directory.CreateDirectory(characterHotbarsPath);
				}
				CharacterSlotData characterSlotData = _activeCharacterSlotData;
				if (characterSlotData == null || !string.Equals(_activeCharacterUID, characterUID, StringComparison.Ordinal))
				{
					characterSlotData = new CharacterSlotData
					{
						CharacterUID = characterUID,
						Slots = new Dictionary<string, SlotDataEntry>(),
						DisabledSlots = new HashSet<string>(),
						DynamicPresets = new Dictionary<string, Dictionary<string, SlotDataEntry>>()
					};
				}
				characterSlotData.CharacterUID = characterUID;
				characterSlotData.Slots = new Dictionary<string, SlotDataEntry>();
				if (characterSlotData.DisabledSlots == null)
				{
					characterSlotData.DisabledSlots = new HashSet<string>();
				}
				if (characterSlotData.DynamicPresets == null)
				{
					characterSlotData.DynamicPresets = new Dictionary<string, Dictionary<string, SlotDataEntry>>();
				}
				foreach (IHotbarSlotData hotbar in _cachedProfile.Hotbars)
				{
					int num = _cachedProfile.Hotbars.IndexOf(hotbar);
					foreach (ISlotData slot in hotbar.Slots)
					{
						int num2 = hotbar.Slots.IndexOf(slot);
						string key = $"{num}_{num2}";
						if (slot.ItemID > 0 || !string.IsNullOrEmpty(slot.ItemUID))
						{
							characterSlotData.Slots[key] = new SlotDataEntry
							{
								ItemID = slot.ItemID,
								ItemUID = slot.ItemUID
							};
						}
					}
				}
				string characterSlotFilePath = GetCharacterSlotFilePath(characterUID);
				string contents = JsonConvert.SerializeObject((object)characterSlotData, (Formatting)1);
				File.WriteAllText(characterSlotFilePath, contents);
				_activeCharacterUID = characterUID;
				_activeCharacterSlotData = characterSlotData;
				Logger.LogDebug("Saved character slots for " + characterUID + " to " + characterSlotFilePath + ".");
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to save character slots for " + characterUID, ex);
			}
		}

		public bool TryGetDynamicPresetSlot(string contextKey, int hotbarIndex, int slotIndex, out SlotDataEntry slotEntry)
		{
			slotEntry = null;
			if (string.IsNullOrWhiteSpace(contextKey) || _activeCharacterSlotData?.DynamicPresets == null)
			{
				return false;
			}
			string slotKey = GetSlotKey(hotbarIndex, slotIndex);
			if (!_activeCharacterSlotData.DynamicPresets.TryGetValue(contextKey, out var value) || value == null)
			{
				return false;
			}
			return value.TryGetValue(slotKey, out slotEntry) && slotEntry != null;
		}

		public void SetDynamicPresetSlot(string contextKey, int hotbarIndex, int slotIndex, int itemId, string itemUid)
		{
			if (!string.IsNullOrWhiteSpace(contextKey))
			{
				if (_activeCharacterSlotData == null)
				{
					_activeCharacterSlotData = new CharacterSlotData
					{
						CharacterUID = _activeCharacterUID,
						Slots = new Dictionary<string, SlotDataEntry>(),
						DisabledSlots = new HashSet<string>(),
						DynamicPresets = new Dictionary<string, Dictionary<string, SlotDataEntry>>()
					};
				}
				if (_activeCharacterSlotData.DynamicPresets == null)
				{
					_activeCharacterSlotData.DynamicPresets = new Dictionary<string, Dictionary<string, SlotDataEntry>>();
				}
				string slotKey = GetSlotKey(hotbarIndex, slotIndex);
				if (!_activeCharacterSlotData.DynamicPresets.TryGetValue(contextKey, out var value) || value == null)
				{
					value = new Dictionary<string, SlotDataEntry>();
					_activeCharacterSlotData.DynamicPresets[contextKey] = value;
				}
				value[slotKey] = new SlotDataEntry
				{
					ItemID = itemId,
					ItemUID = itemUid
				};
			}
		}

		public void RemoveDynamicPresetSlot(string contextKey, int hotbarIndex, int slotIndex)
		{
			if (string.IsNullOrWhiteSpace(contextKey) || _activeCharacterSlotData?.DynamicPresets == null)
			{
				return;
			}
			string slotKey = GetSlotKey(hotbarIndex, slotIndex);
			if (_activeCharacterSlotData.DynamicPresets.TryGetValue(contextKey, out var value) && value != null)
			{
				value.Remove(slotKey);
				if (value.Count == 0)
				{
					_activeCharacterSlotData.DynamicPresets.Remove(contextKey);
				}
			}
		}

		private string GetCharacterSlotFilePath(string characterUID)
		{
			string text = characterUID.Replace("\\", "_").Replace("/", "_").Replace(":", "_");
			return Path.Combine(ActionUISettings.CharacterHotbarsPath, text + ".json");
		}

		private static string GetSlotKey(int hotbarIndex, int slotIndex)
		{
			return $"{hotbarIndex}_{slotIndex}";
		}

		public static string GetBaselineContextKey()
		{
			return "baseline";
		}

		public static string GetMainContextKey(int mainType)
		{
			return $"main:{mainType}";
		}

		public static string GetOffContextKey(int offType)
		{
			return $"off:{offType}";
		}

		public static string GetComboContextKey(int mainType, int offType)
		{
			return $"combo:{mainType}:{offType}";
		}

		private static void MigrateLegacyDynamicPresetKeys(CharacterSlotData charData)
		{
			if (charData?.DynamicPresets == null || charData.DynamicPresets.Count == 0)
			{
				return;
			}
			Dictionary<string, Dictionary<string, SlotDataEntry>> dictionary = new Dictionary<string, Dictionary<string, SlotDataEntry>>(StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, Dictionary<string, SlotDataEntry>> dynamicPreset in charData.DynamicPresets)
			{
				string text = NormalizeDynamicContextKey(dynamicPreset.Key);
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				if (!dictionary.TryGetValue(text, out var value) || value == null)
				{
					value = (dictionary[text] = new Dictionary<string, SlotDataEntry>());
				}
				if (dynamicPreset.Value == null)
				{
					continue;
				}
				foreach (KeyValuePair<string, SlotDataEntry> item in dynamicPreset.Value)
				{
					value[item.Key] = item.Value;
				}
			}
			charData.DynamicPresets = dictionary;
		}

		private static string NormalizeDynamicContextKey(string rawKey)
		{
			if (string.IsNullOrWhiteSpace(rawKey))
			{
				return null;
			}
			string text = rawKey.Trim();
			if (text.StartsWith("combo:", StringComparison.OrdinalIgnoreCase) || text.StartsWith("main:", StringComparison.OrdinalIgnoreCase) || text.StartsWith("off:", StringComparison.OrdinalIgnoreCase) || text.Equals("baseline", StringComparison.OrdinalIgnoreCase))
			{
				return text.ToLowerInvariant();
			}
			if (int.TryParse(text, out var result))
			{
				if (result == -1)
				{
					return GetBaselineContextKey();
				}
				return GetMainContextKey(result);
			}
			return text.ToLowerInvariant();
		}
	}
	public class GlobalPositionsService : IPositionsProfileService
	{
		private PositionsProfile _cachedProfile;

		public event Action<PositionsProfile> OnProfileChanged;

		public GlobalPositionsService()
		{
			LoadProfile();
		}

		private void LoadProfile()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			string value = ActionUISettings.SerializedPositions.Value;
			if (string.IsNullOrEmpty(value))
			{
				_cachedProfile = new PositionsProfile();
				return;
			}
			try
			{
				_cachedProfile = JsonConvert.DeserializeObject<PositionsProfile>(value);
			}
			catch
			{
				_cachedProfile = new PositionsProfile();
			}
		}

		public PositionsProfile GetProfile()
		{
			if (_cachedProfile == null)
			{
				LoadProfile();
			}
			return _cachedProfile;
		}

		public void Save()
		{
			SaveNew(GetProfile());
		}

		public void SaveNew(PositionsProfile positionsProfile)
		{
			string text = JsonConvert.SerializeObject((object)positionsProfile, (Formatting)0);
			if (ActionUISettings.SerializedPositions.Value != text)
			{
				ActionUISettings.SerializedPositions.Value = text;
			}
			this.OnProfileChanged?.Invoke(positionsProfile);
		}

		public void AddOrUpdate(UIPositions position)
		{
			GetProfile().AddOrReplacePosition(position);
			Save();
		}

		public void Remove(UIPositions position)
		{
			if (GetProfile().RemovePosition(position))
			{
				Save();
			}
		}
	}
	public class PlayerMenuService : IDisposable
	{
		public delegate void PlayerActionMenusConfigured(PlayerActionMenus actionMenus, SplitPlayer splitPlayer);

		[CompilerGenerated]
		private sealed class <ResizePauseMenu>d__32 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PauseMenu pauseMenu;

			public PlayerMenuService <>4__this;

			private RectTransform <parentRect>5__1;

			private Transform <hideOnPause>5__2;

			private VerticalLayoutGroup <vertLayout>5__3;

			private Button[] <buttons>5__4;

			private float <btnHeight>5__5;

			private float <increaseHeight>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<parentRect>5__1 = null;
				<hideOnPause>5__2 = null;
				<vertLayout>5__3 = null;
				<buttons>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: 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_0079: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<parentRect>5__1 = ((Component)((Component)pauseMenu).transform.Find("Buttons")).GetComponent<RectTransform>();
					Rect rect;
					if (<>4__this._initialPauseMenuHeight == 0f)
					{
						PlayerMenuService playerMenuService = <>4__this;
						rect = <parentRect>5__1.rect;
						playerMenuService._initialPauseMenuHeight = ((Rect)(ref rect)).height;
					}
					<hideOnPause>5__2 = ((Component)pauseMenu).transform.Find("Buttons/Content/HideOnPause");
					<vertLayout>5__3 = ((Component)<hideOnPause>5__2).GetComponent<VerticalLayoutGroup>();
					<buttons>5__4 = ((Component)<hideOnPause>5__2).GetComponentsInChildren<Button>();
					rect = ((Component)<buttons>5__4.First()).GetComponent<RectTransform>().rect;
					<btnHeight>5__5 = ((Rect)(ref rect)).height;
					<increaseHeight>5__6 = (((HorizontalOrVerticalLayoutGroup)<vertLayout>5__3).spacing + <btnHeight>5__5) * (float)(<buttons>5__4.Length - 7);
					IModifLogger logger = <>4__this.Logger;
					rect = <parentRect>5__1.rect;
					logger.LogDebug($"Resizing Pause Menu height from {((Rect)(ref rect)).height} to {<>4__this._initialPauseMenuHeight + <increaseHeight>5__6}.");
					<parentRect>5__1.SetSizeWithCurrentAnchors((Axis)1, <>4__this._initialPauseMenuHeight + <increaseHeight>5__6);
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <SetSortOrderNextFrame>d__29 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject actionMenus;

			public PlayerMenuService <>4__this;

			private Canvas <mainCanvas>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<mainCanvas>5__1 = ((Component)actionMenus.transform.Find("MenuCanvas")).gameObject.GetComponent<Canvas>();
					IModifLogger logger = <>4__this.Logger;
					Canvas obj = <mainCanvas>5__1;
					logger.LogDebug("PlayerMenuService::ConfigureCharacterUI(): Setting overrideSorting to true for Canvas " + ((obj != null) ? ((Object)obj).name : null) + ".");
					<mainCanvas>5__1.overrideSorting = true;
					<mainCanvas>5__1.sortingOrder = 2;
					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 readonly Func<IModifLogger> _getLogger;

		private readonly BaseUnityPlugin _baseUnityPlugin;

		private readonly GameObject _playerMenuPrefab;

		private readonly PositionsService _positionsService;

		private readonly LevelCoroutines _coroutine;

		private readonly GameObject _modInactivableGo;

		private readonly SharedServicesInjector _sharedServicesInjector;

		private float _initialPauseMenuHeight;

		private const int _baseActivePauseButtons = 7;

		private Button _actionUiGo;

		private bool disposedValue;

		private static readonly Dictionary<int, ControllerMap> _controllerMaps = new Dictionary<int, ControllerMap>();

		private IModifLogger Logger => _getLogger();

		public Button ActionMenusButton => _actionUiGo;

		public event PlayerActionMenusConfigured OnPlayerActionMenusConfigured;

		public PlayerMenuService(BaseUnityPlugin baseUnityPlugin, GameObject playerMenuPrefab, SharedServicesInjector sharedServicesInjector, PositionsService positionsService, LevelCoroutines coroutine, ModifGoService modifGoService, Func<IModifLogger> getLogger)
		{
			_baseUnityPlugin = baseUnityPlugin;
			_playerMenuPrefab = playerMenuPrefab;
			_sharedServicesInjector = sharedServicesInjector;
			_positionsService = positionsService;
			_coroutine = coroutine;
			_modInactivableGo = modifGoService.GetModResources("ModifAmorphic.Outward.ActionUI", false);
			_getLogger = getLogger;
			SplitPlayerPatches.SetCharacterAfter += DelayedInit;
			SplitScreenManagerPatches.RemoveLocalPlayerAfter += RemovePlayerMenu;
			PauseMenuPatches.AfterRefreshDisplay += delegate(PauseMenu pauseMenu)
			{
				((ModifCoroutine)_coroutine).StartRoutine(ResizePauseMenu(pauseMenu));
			};
		}

		private void DelayedInit(SplitPlayer splitPlayer, Character character)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogDebug($"DelayedInit:: Character {character.UID}.");
			_coroutine.InvokeAfterLevelAndPlayersLoaded(NetworkLevelLoader.Instance, (Action)delegate
			{
				InitActionUI(splitPlayer, character);
			}, 300, 0.25f);
		}

		private void InitActionUI(SplitPlayer splitPlayer, Character character)
		{
			if (!character.IsLocalPlayer)
			{
				Logger.LogDebug("Character " + ((Object)character).name + " is not a local character. Ending ActionUI init.");
				return;
			}
			if (!TryInjectMenus(splitPlayer))
			{
				Logger.LogDebug(string.Format("{0}::{1}(): PlayerActionMenus already injected for player rewiredId {2}. Ending ActionUI init.", "PlayerMenuService", "InitActionUI", splitPlayer.RewiredID));
				return;
			}
			ConfigureCharacterUI(splitPlayer);
			try
			{
				UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(splitPlayer.RewiredID);
				PlayerActionMenus service = servicesProvider.GetService<PlayerActionMenus>();
				this.OnPlayerActionMenusConfigured?.Invoke(service, splitPlayer);
			}
			catch (Exception ex)
			{
				Logger.LogException(ex);
			}
		}

		private bool TryInjectMenus(SplitPlayer splitPlayer)
		{
			Logger.LogDebug(string.Format("{0}::{1}(): Injecting PlayerActionMenus for player rewiredId {2}.", "PlayerMenuService", "TryInjectMenus", splitPlayer.RewiredID));
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(splitPlayer.RewiredID);
			PlayerActionMenus val = default(PlayerActionMenus);
			if (servicesProvider.TryGetService<PlayerActionMenus>(ref val))
			{
				return false;
			}
			GameObject gameObject = _playerMenuPrefab.gameObject;
			Transform val2 = ((Component)splitPlayer.CharUI).transform.Find("Canvas/GameplayPanels");
			Logger.LogDebug(string.Format("{0}::{1}(): Creating PlayerActionMenus instance for player rewiredId {2}.", "PlayerMenuService", "TryInjectMenus", splitPlayer.RewiredID));
			GameObject val3 = Object.Instantiate<GameObject>(gameObject, val2);
			servicesProvider.AddSingleton<HotkeyCaptureMenu>(val3.GetComponentInChildren<HotkeyCaptureMenu>(true));
			val3.SetActive(false);
			PlayerActionMenus playerMenu = val3.GetComponent<PlayerActionMenus>();
			servicesProvider.AddSingleton<PlayerActionMenus>(playerMenu);
			if ((Object)(object)playerMenu.DurabilityDisplay != (Object)null)
			{
				((Component)playerMenu.DurabilityDisplay).gameObject.SetActive(false);
			}
			Logger.LogDebug("PlayerMenuService::TryInjectMenus(): Injecting Positionable UI component.");
			_positionsService.InjectPositionableUIs(splitPlayer.CharUI);
			playerMenu.SetIDs(splitPlayer.RewiredID);
			if (!CharacterUIPatches.GetIsMenuFocused.ContainsKey(splitPlayer.RewiredID))
			{
				CharacterUIPatches.GetIsMenuFocused.Add(splitPlayer.RewiredID, (int playerId) => GetAnyMenuShowing(playerMenu, playerId));
			}
			InjectPauseMenu(splitPlayer, playerMenu);
			return true;
		}

		private bool GetAnyMenuShowing(PlayerActionMenus actionMenus, int playerId)
		{
			if (actionMenus.PlayerID != playerId)
			{
				return false;
			}
			return actionMenus.AnyActionMenuShowing();
		}

		private bool ShouldQuickslotItemBeDestroyed(bool actionSlotsActive, int playerID, int requestingPlayerID)
		{
			return !actionSlotsActive || playerID != requestingPlayerID;
		}

		private void ConfigureCharacterUI(SplitPlayer splitPlayer)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(splitPlayer.RewiredID);
			PlayerActionMenus service = servicesProvider.GetService<PlayerActionMenus>();
			GameObject gameObject = ((Component)service).gameObject;
			Character assignedCharacter = splitPlayer.AssignedCharacter;
			((Object)gameObject).name = "PlayerActionMenus_" + UID.op_Implicit(assignedCharacter.UID);
			Logger.LogDebug(string.Format("{0}::{1}(): Activating {2} for rewired ID {3}.", "PlayerMenuService", "ConfigureCharacterUI", ((Object)gameObject).name, splitPlayer.RewiredID));
			gameObject.SetActive(true);
			IActionUIProfileService service2 = servicesProvider.GetService<IActionUIProfileService>();
			IActionUIProfile activeProfile = service2.GetActiveProfile();
			_positionsService.ToggleQuickslotsPositonable(activeProfile, service, assignedCharacter.CharacterUI);
			Player player = ReInput.players.GetPlayer(splitPlayer.RewiredID);
			Transform val = ((Component)splitPlayer.CharUI).transform.Find("Canvas/GameplayPanels/HUD");
			service.ConfigureNavigation(GetNavigationActions(player));
			Logger.LogDebug("PlayerMenuService::ConfigureCharacterUI(): Adding SplitScreenScaler component to Action UIs.");
			AddSplitScreenScaler(service, assignedCharacter.CharacterUI);
			_positionsService.StartKeepPostionablesVisible(service, assignedCharacter.CharacterUI);
			if (activeProfile.ActionSlotsEnabled)
			{
				Transform val2 = ((Component)splitPlayer.CharUI).transform.Find("Canvas/GameplayPanels/Menus/DropPanel");
				Canvas dropCanvas = UnityEngineExtensions.GetOrAddComponent<Canvas>(val2);
				UnityEngineExtensions.GetOrAddComponent<GraphicRaycaster>(val2);
				((ModifCoroutine)_coroutine).DoNextFrame((Action)delegate
				{
					dropCanvas.overrideSorting = true;
					dropCanvas.sortingOrder = 0;
					Logger.LogDebug(string.Format("{0}::{1}(): Changed '{2}' sortingOrder to {3}.", "PlayerMenuService", "ConfigureCharacterUI", GameObjectExtensions.GetPath(((Component)dropCanvas).gameObject), dropCanvas.sortingOrder));
				});
			}
			bool isActionSlotsEnabled = activeProfile.ActionSlotsEnabled;
			if (!CharacterQuickSlotManagerPatches.AllowItemDestroyed.ContainsKey(splitPlayer.RewiredID))
			{
				CharacterQuickSlotManagerPatches.AllowItemDestroyed.Add(splitPlayer.RewiredID, (int requestingPlayerId) => ShouldQuickslotItemBeDestroyed(isActionSlotsEnabled, splitPlayer.RewiredID, requestingPlayerId));
			}
		}

		private MenuNavigationActions GetNavigationActions(Player player)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0039: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			return new MenuNavigationActions
			{
				MoveUp = () => player.GetButtonDown(ControlsInput.GetMenuActionName((MenuActions)1)),
				MoveDown = () => player.GetButtonDown(ControlsInput.GetMenuActionName((MenuActions)2)),
				MoveLeft = () => player.GetButtonDown(ControlsInput.GetMenuActionName((MenuActions)4)),
				MoveRight = () => player.GetButtonDown(ControlsInput.GetMenuActionName((MenuActions)5)),
				Cancel = () => player.GetButtonDown(ControlsInput.GetMenuActionName((MenuActions)8))
			};
		}

		private void AddSplitScreenScaler(PlayerActionMenus actionMenus, CharacterUI characterUI)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				IActionMenu[] componentsInChildren = ((Component)actionMenus).GetComponentsInChildren<IActionMenu>(true);
				IActionMenu[] array = componentsInChildren;
				foreach (IActionMenu val in array)
				{
					SplitScreenScaler orAddComponent = UnityEngineExtensions.GetOrAddComponent<SplitScreenScaler>(((Component)(MonoBehaviour)val).gameObject);
					orAddComponent.CharacterUI = characterUI;
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("Unexpected error adding split screen scaler.", ex);
			}
		}

		[IteratorStateMachine(typeof(<SetSortOrderNextFrame>d__29))]
		private IEnumerator SetSortOrderNextFrame(GameObject actionMenus)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetSortOrderNextFrame>d__29(0)
			{
				<>4__this = this,
				actionMenus = actionMenus
			};
		}

		private void RemovePlayerMenu(SplitScreenManager splitScreenManager, SplitPlayer player, string playerId)
		{
			PlayerActionMenus val = default(PlayerActionMenus);
			if (Psp.Instance.GetServicesProvider(player.RewiredID).TryGetService<PlayerActionMenus>(ref val))
			{
				if (CharacterUIPatches.GetIsMenuFocused.ContainsKey(player.RewiredID))
				{
					CharacterUIPatches.GetIsMenuFocused.Remove(player.RewiredID);
				}
				Object.Destroy((Object)(object)((Component)val).gameObject);
				Psp.Instance.GetServicesProvider(player.RewiredID).TryRemove<PlayerActionMenus>();
			}
		}

		private void InjectPauseMenu(SplitPlayer splitPlayer, PlayerActionMenus actionMenus)
		{
			Logger.LogDebug("PlayerMenuService::InjectPauseMenu(): Adding 'Action UI' button to pause menu.");
			GameObject gameObject = ((Component)((Component)splitPlayer.CharUI).transform.Find("Canvas/PauseMenu/Buttons/Content/HideOnPause/")).gameObject;
			Button[] componentsInChildren = gameObject.GetComponentsInChildren<Button>();
			Button val = ((IEnumerable<Button>)componentsInChildren).FirstOrDefault((Func<Button, bool>)((Button b) => ((Object)b).name == "btnActionUiSettings"));
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		[IteratorStateMachine(typeof(<ResizePauseMenu>d__32))]
		private IEnumerator ResizePauseMenu(PauseMenu pauseMenu)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResizePauseMenu>d__32(0)
			{
				<>4__this = this,
				pauseMenu = pauseMenu
			};
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				SplitPlayerPatches.SetCharacterAfter -= DelayedInit;
				SplitScreenManagerPatches.RemoveLocalPlayerAfter -= RemovePlayerMenu;
				PauseMenuPatches.AfterRefreshDisplay -= delegate(PauseMenu pauseMenu)
				{
					((ModifCoroutine)_coroutine).StartRoutine(ResizePauseMenu(pauseMenu));
				};
			}
			disposedValue = true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class PositionsService
	{
		[CompilerGenerated]
		private sealed class <KeepPositionablesVisible>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PositionableUI[] positionables;

			public PositionsService <>4__this;

			private List<PositionableUI> <needsDisable>5__1;

			private List<CanvasGroup> <zeroAlphas>5__2;

			private List<CanvasGroup> <noBlocks>5__3;

			private PositionableUI <cdl>5__4;

			private bool <cdlNeedsInactive>5__5;

			private GameObject <interactionPress>5__6;

			private int <i>5__7;

			private CanvasGroup <cg>5__8;

			private List<PositionableUI>.Enumerator <>s__9;

			private PositionableUI <positionable>5__10;

			private List<CanvasGroup>.Enumerator <>s__11;

			private CanvasGroup <cg>5__12;

			private List<CanvasGroup>.Enumerator <>s__13;

			private CanvasGroup <cg>5__14;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<needsDisable>5__1 = null;
				<zeroAlphas>5__2 = null;
				<noBlocks>5__3 = null;
				<cdl>5__4 = null;
				<interactionPress>5__6 = null;
				<cg>5__8 = null;
				<positionable>5__10 = null;
				<cg>5__12 = null;
				<cg>5__14 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_023a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0244: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<needsDisable>5__1 = new List<PositionableUI>();
					<zeroAlphas>5__2 = new List<CanvasGroup>();
					<noBlocks>5__3 = new List<CanvasGroup>();
					<cdl>5__4 = ((IEnumerable<PositionableUI>)positionables).FirstOrDefault((Func<PositionableUI, bool>)((PositionableUI p) => ((Object)p).name == "ConfirmDeployListener"));
					<cdlNeedsInactive>5__5 = false;
					if ((Object)(object)<cdl>5__4 != (Object)null)
					{
						<interactionPress>5__6 = ((Component)((Component)<cdl>5__4).transform.Find("InteractionPress")).gameObject;
						if (!<interactionPress>5__6.activeSelf)
						{
							<cdlNeedsInactive>5__5 = true;
							<interactionPress>5__6.SetActive(true);
						}
						<interactionPress>5__6 = null;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (positionables[0].IsPositionable)
				{
					<i>5__7 = 1;
					while (<i>5__7 < positionables.Length)
					{
						if (!(((Object)positionables[<i>5__7]).name == "Keyboard"))
						{
							if (!((Component)positionables[<i>5__7]).gameObject.activeSelf)
							{
								((Component)positionables[<i>5__7]).gameObject.SetActive(true);
								<needsDisable>5__1.Add(positionables[<i>5__7]);
							}
							<cg>5__8 = ((Component)positionables[<i>5__7]).GetComponent<CanvasGroup>();
							if ((Object)(object)<cg>5__8 != (Object)null)
							{
								if (<cg>5__8.alpha == 0f)
								{
									<cg>5__8.alpha = 1f;
									<zeroAlphas>5__2.Add(<cg>5__8);
								}
								if (!<cg>5__8.blocksRaycasts)
								{
									<cg>5__8.blocksRaycasts = true;
									<noBlocks>5__3.Add(<cg>5__8);
								}
							}
							<cg>5__8 = null;
						}
						<i>5__7++;
					}
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				}
				if (<cdlNeedsInactive>5__5)
				{
					((Component)((Component)<cdl>5__4).transform.Find("InteractionPress")).gameObject.SetActive(false);
				}
				<>s__9 = <needsDisable>5__1.GetEnumerator();
				try
				{
					while (<>s__9.MoveNext())
					{
						<positionable>5__10 = <>s__9.Current;
						if (((Component)<positionable>5__10).gameObject.activeSelf)
						{
							((Component)<positionable>5__10).gameObject.SetActive(false);
						}
						<positionable>5__10 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__9).Dispose();
				}
				<>s__11 = <zeroAlphas>5__2.GetEnumerator();
				try
				{
					while (<>s__11.MoveNext())
					{
						<cg>5__12 = <>s__11.Current;
						if (<cg>5__12.alpha > 0f)
						{
							<cg>5__12.alpha = 0f;
						}
						<cg>5__12 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__11).Dispose();
				}
				<>s__13 = <noBlocks>5__3.GetEnumerator();
				try
				{
					while (<>s__13.MoveNext())
					{
						<cg>5__14 = <>s__13.Current;
						if (<cg>5__14.blocksRaycasts)
						{
							<cg>5__14.blocksRaycasts = false;
						}
						<cg>5__14 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__13).Dispose();
				}
				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 readonly Func<IModifLogger> _getLogger;

		private readonly ModifCoroutine _coroutine;

		private readonly GameObject _modInactivableGo;

		private static readonly HashSet<string> _positionBlocklist = new HashSet<string>
		{
			"CorruptionSmog", "PanicOverlay", "TargetingFlare", "CharacterBars", "LowHealth", "LowStamina", "Chat - Panel", "Durability", "ConfirmDeployListener", "InteractionDisplay",
			"InteractionSpot"
		};

		private bool _isKeepPositionablesListening = false;

		private IModifLogger Logger => _getLogger();

		public PositionsService(ModifCoroutine coroutine, ModifGoService modifGoService, Func<IModifLogger> getLogger)
		{
			_coroutine = coroutine;
			_modInactivableGo = modifGoService.GetModResources("ModifAmorphic.Outward.ActionUI", false);
			_getLogger = getLogger;
		}

		public void InjectPositionableUIs(CharacterUI characterUI)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: 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_01b7: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)characterUI).transform.Find("Canvas/GameplayPanels/HUD");
			string text = null;
			RectTransform val2 = ((IEnumerable<RectTransform>)((Component)val).GetComponentsInChildren<RectTransform>(true)).FirstOrDefault((Func<RectTransform, bool>)((RectTransform r) => ((Object)r).name == "InteractionDisplay" || ((Object)r).name == "InteractionSpot"));
			if ((Object)(object)val2 != (Object)null)
			{
				RectTransform val3 = val2;
				while ((Object)(object)((Transform)val3).parent != (Object)null && (Object)(object)((Transform)val3).parent != (Object)(object)val)
				{
					Transform parent = ((Transform)val3).parent;
					val3 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				}
				if ((Object)(object)((Transform)val3).parent == (Object)(object)val)
				{
					text = ((Object)val3).name;
				}
			}
			GameObject gameObject = ((Component)_modInactivableGo.transform.Find("Prefabs/PositionableBg")).gameObject;
			for (int i = 0; i < val.childCount; i++)
			{
				Transform child = val.GetChild(i);
				RectTransform val4 = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (val4 == null)
				{
					continue;
				}
				if (((Object)val4).name == "Tutorialization_DropBag" || ((Object)val4).name == "Tutorialization_UseBandage")
				{
					Transform obj = ((Transform)val4).Find("Panel");
					val4 = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				}
				if (((Object)val4).name == "QuickSlot")
				{
					Transform obj2 = ((Transform)val4).Find("Keyboard");
					val4 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				}
				Rect rect = val4.rect;
				if (!(((Rect)(ref rect)).width < 10f))
				{
					rect = val4.rect;
					if (!(((Rect)(ref rect)).height < 10f))
					{
						goto IL_01d1;
					}
				}
				RectTransform obj3 = val4;
				rect = val4.rect;
				obj3.SetSizeWithCurrentAnchors((Axis)0, Mathf.Max(((Rect)(ref rect)).width, 300f));
				RectTransform obj4 = val4;
				rect = val4.rect;
				obj4.SetSizeWithCurrentAnchors((Axis)1, Mathf.Max(((Rect)(ref rect)).height, 100f));
				goto IL_01d1;
				IL_01d1:
				if (!_positionBlocklist.Contains(((Object)val4).name) && ((Object)val4).name != text)
				{
					AddPositionableUI(val4, gameObject);
				}
			}
		}

		public void DestroyPositionableUIs(CharacterUI characterUI)
		{
			Transform val = ((Component)characterUI).transform.Find("Canvas/GameplayPanels/HUD");
			PositionableUI[] componentsInChildren = ((Component)val).GetComponentsInChildren<PositionableUI>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren[i]);
			}
		}

		private static void AddPositionableUI(RectTransform transform, GameObject positionablePrefab)
		{
			GameObject val = Object.Instantiate<GameObject>(positionablePrefab, (Transform)(object)transform);
			((Object)val).name = ((Object)positionablePrefab).name;
			val.transform.SetAsLastSibling();
			PositionableUI val2 = ((Component)transform).gameObject.AddComponent<PositionableUI>();
			val2.BackgroundImage = val.GetComponent<Image>();
			val2.ResetButton = val.GetComponentInChildren<Button>();
			val.GetComponentInChildren<Text>().text = ((Object)transform).name;
		}

		public void ToggleQuickslotsPositonable(IActionUIProfile profile, PlayerActionMenus actionMenus, CharacterUI characterUI)
		{
			if (!profile.ActionSlotsEnabled)
			{
				HotbarsContainer componentInChildren = ((Component)actionMenus).gameObject.GetComponentInChildren<HotbarsContainer>();
				GameObjectExtensions.Destroy(((Component)componentInChildren).gameObject);
				return;
			}
			Transform val = ((Component)characterUI).transform.Find("Canvas/GameplayPanels/HUD");
			GameObject gameObject = ((Component)val.Find("QuickSlot/Keyboard")).gameObject;
			PositionableUI component = gameObject.GetComponent<PositionableUI>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
				GameObjectExtensions.Destroy(((Component)gameObject.transform.Find("PositionableBg")).gameObject);
			}
			Transform val2 = gameObject.transform.Find("PositionableBg");
			if ((Object)(object)val2 != (Object)null)
			{
				GameObjectExtensions.Destroy(((Component)val2).gameObject);
			}
		}

		public void StartKeepPostionablesVisible(PlayerActionMenus actionMenus, CharacterUI characterUI)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			if (_isKeepPositionablesListening)
			{
				return;
			}
			try
			{
				UIPositionScreen componentInChildren = ((Component)actionMenus).GetComponentInChildren<UIPositionScreen>(true);
				Transform val = ((Component)characterUI).transform.Find("Canvas/GameplayPanels/HUD");
				IEnumerable<PositionableUI> positonables = from p in ((Component)val).GetComponentsInChildren<PositionableUI>(true)
					where (Object)(object)p != (Object)null
					select p;
				componentInChildren.OnShow.AddListener((UnityAction)delegate
				{
					_coroutine.StartRoutine(KeepPositionablesVisible(positonables.ToArray()));
				});
				_isKeepPositionablesListening = true;
			}
			catch (Exception ex)
			{
				Logger.LogException("Failed to start Keep Postionables Visible coroutine", ex);
			}
		}

		[IteratorStateMachine(typeof(<KeepPositionablesVisible>d__13))]
		private IEnumerator KeepPositionablesVisible(PositionableUI[] positionables)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <KeepPositionablesVisible>d__13(0)
			{
				<>4__this = this,
				positionables = positionables
			};
		}
	}
	internal class ResetActionUIsService
	{
		private readonly Func<IModifLogger> _getLogger;

		private readonly ServicesProvider _services;

		private readonly LevelCoroutines _coroutine;

		private IModifLogger Logger => _getLogger();

		public ResetActionUIsService(ServicesProvider services, LevelCoroutines coroutine, Func<IModifLogger> getLogger)
		{
			_services = services;
			_coroutine = coroutine;
			_getLogger = getLogger;
			CharacterUIPatches.BeforeReleaseUI += ResetUIs;
			LobbySystemPatches.BeforeClearPlayerSystems += ResetAllPlayerUIs;
		}

		private void ResetAllPlayerUIs(LobbySystem lobbySystem)
		{
			List<PlayerSystem> list = lobbySystem.PlayersInLobby.FindAll((PlayerSystem p) => p.IsLocalPlayer);
			foreach (PlayerSystem item in list)
			{
				ResetUIs(item.ControlledCharacter.CharacterUI, item.PlayerID);
			}
		}

		private void ResetUIs(CharacterUI characterUI, int rewiredId)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			try
			{
			}
			catch (Exception ex)
			{
				Logger.LogException($"Unexpected error occured when saving profiles for character {characterUI.TargetCharacter.UID}.", ex);
			}
			Logger.LogDebug($"Destroying Action UIs for player {rewiredId}");
			UnityServicesProvider val = default(UnityServicesProvider);
			PositionsService positionsService = default(PositionsService);
			if (Psp.Instance.TryGetServicesProvider(rewiredId, ref val) && val.TryGetService<PositionsService>(ref positionsService))
			{
				try
				{
					positionsService.DestroyPositionableUIs(characterUI);
				}
				catch (Exception ex2)
				{
					Logger.LogException("Dispose of PositionableUIs failed.", ex2);
				}
			}
			Psp.Instance.TryDisposeServicesProvider(rewiredId);
			CharacterUIPatches.GetIsMenuFocusedDelegate getIsMenuFocusedDelegate = default(CharacterUIPatches.GetIsMenuFocusedDelegate);
			IDictionaryExtensions.TryRemove<int, CharacterUIPatches.GetIsMenuFocusedDelegate>((IDictionary<int, CharacterUIPatches.GetIsMenuFocusedDelegate>)CharacterUIPatches.GetIsMenuFocused, rewiredId, ref getIsMenuFocusedDelegate);
			try
			{
				GameObjectExtensions.Destroy(((Component)((Component)characterUI).GetComponentInChildren<EquipmentSetMenu>(true)).gameObject);
			}
			catch (Exception ex3)
			{
				Logger.LogException("Dispose of EquipmentSetMenu gameobject failed.", ex3);
			}
			try
			{
				GameObjectExtensions.Destroy(((Component)((Component)characterUI).GetComponentInChildren<PlayerActionMenus>(true)).gameObject);
			}
			catch (Exception ex4)
			{
				Logger.LogException("Dispose of PlayerActionMenus gameobject failed.", ex4);
			}
		}
	}
	internal class DurabilityActionSlotTracker : IBarProgress
	{
		private readonly EquipmentSlotAction _equipSlotAction;

		private readonly BarPositions _barPosition;

		private float _lastDurability = -1f;

		private static readonly Color Grey = new Color(0.5f, 0.5f, 0.5f, 1f);

		private static readonly Color Yellow = new Color(83f / 106f, 0.7024478f, 0.04924639f, 1f);

		private static readonly Color Orange = new Color(0.9433962f, 0.5298792f, 0.08603289f, 1f);

		private static readonly Color Red = new Color(0.7169812f, 0.08259042f, 0.03832913f, 1f);

		private List<ColorRange> colorRanges = new List<ColorRange>
		{
			new ColorRange
			{
				Min = 0.5f,
				Max = 1f,
				Color = Grey
			},
			new ColorRange
			{
				Min = 0.25f,
				Max = 0.499f,
				Color = Yellow
			},
			new ColorRange
			{
				Min = 0f,
				Max = 0.249f,
				Color = Orange
			},
			new ColorRange
			{
				Min = 0f,
				Max = 0f,
				Color = Red
			}
		};

		public BarPositions BarPosition => _barPosition;

		public bool IsEnabled { get; internal set; }

		public List<ColorRange> ColorRanges => colorRanges;

		public DurabilityActionSlotTracker(EquipmentSlotAction equipSlotAction, BarPositions barPosition)
		{
			//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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0040: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00a2: 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)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			_equipSlotAction = equipSlotAction;
			_barPosition = barPosition;
			IsEnabled = true;
		}

		public float GetProgress()
		{
			if (!string.IsNullOrEmpty(((Item)_equipSlotAction.ActionEquipment).UID))
			{
				if (((Item)_equipSlotAction.ActionEquipment).CurrentDurability != _lastDurability)
				{
					_lastDurability = ((Item)_equipSlotAction.ActionEquipment).CurrentDurability;
					_equipSlotAction.DurabilityChanged(((Item)_equipSlotAction.ActionEquipment).CurrentDurability);
				}
				return IsEnabled ? ((Item)_equipSlotAction.ActionEquipment).DurabilityRatio : 0f;
			}
			return IsEnabled ? 1f : 0f;
		}
	}
	internal class DurabilityTracker : IDurability
	{
		private readonly Equipment _equipment;

		private static readonly Color Grey = new Color(0.3f, 0.3f, 0.3f, 0.8f);

		private static readonly Color Yellow = new Color(83f / 106f, 0.7024478f, 0.04924639f, 0.8f);

		private static readonly Color Orange = new Color(0.9433962f, 0.5298792f, 0.08603289f, 0.8f);

		private static readonly Color Red = new Color(0.7169812f, 0.08259042f, 0.03832913f, 0.9f);

		private List<ColorRange> colorRanges = new List<ColorRange>
		{
			new ColorRange
			{
				Min = 0.5f,
				Max = 1f,
				Color = Grey
			},
			new ColorRange
			{
				Min = 0.25f,
				Max = 0.499f,
				Color = Yellow
			},
			new ColorRange
			{
				Min = 0f,
				Max = 0.249f,
				Color = Orange
			},
			new ColorRange
			{
				Min = 0f,
				Max = 0f,
				Color = Red
			}
		};

		public List<ColorRange> ColorRanges => colorRanges;

		public DurableEquipmentType DurableEquipmentType => _equipment.GetDurableEquipmentType();

		public EquipSlots DurableEquipmentSlot => ((Item)_equipment).CurrentEquipmentSlot.SlotType.ToDurableEquipmentSlot();

		public float MinimumDisplayValue => 0.499f;

		public DurabilityTracker(Equipment equipment)
		{
			//IL_0007: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_0097: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			_equipment = equipment;
		}

		public float GetDurabilityRatio()
		{
			return ((Item)_equipment).DurabilityRatio;
		}
	}
	internal class UnequippedDurabilityTracker : IDurability
	{
		private static readonly Color Grey = new Color(0.3f, 0.3f, 0.3f, 0.75f);

		private static readonly Color Yellow = new Color(83f / 106f, 0.7024478f, 0.04924639f, 0.8f);

		private static readonly Color Orange = new Color(0.9433962f, 0.5298792f, 0.08603289f, 0.8f);

		private static readonly Color Red = new Color(0.7169812f, 0.08259042f, 0.03832913f, 0.9f);

		private List<ColorRange> colorRanges = new List<ColorRange>
		{
			new ColorRange
			{
				Min = 0.5f,
				Max = 1f,
				Color = Grey
			},
			new ColorRange
			{
				Min = 0.25f,
				Max = 0.499f,
				Color = Yellow
			},
			new ColorRange
			{
				Min = 0f,
				Max = 0.249f,
				Color = Orange
			},
			new ColorRange
			{
				Min = 0f,
				Max = 0f,
				Color = Red
			}
		};

		private readonly DurableEquipmentType _equipmentType;

		private readonly EquipSlots _slot;

		private readonly float _durabilityRatio;

		public List<ColorRange> ColorRanges => colorRanges;

		public DurableEquipmentType DurableEquipmentType => _equipmentType;

		public EquipSlots DurableEquipmentSlot => _slot;

		public float MinimumDisplayValue => 0f;

		public UnequippedDurabilityTracker(EquipSlots slot, DurableEquipmentType equipmentType, float durabilityRatio)
		{
			//IL_0007: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_0097: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			_slot = slot;
			_equipmentType = equipmentType;
			_durabilityRatio = durabilityRatio;
		}

		public float GetDurabilityRatio()
		{
			return _durabilityRatio;
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Services.Injectors
{
	internal class HotbarServicesInjector
	{
		private readonly ServicesProvider _provider;

		private PlayerMenuService _playerMenuService;

		private readonly LevelCoroutines _levelCoroutines;

		private Func<IModifLogger> _getLogger;

		private IModifLogger Logger => _getLogger();

		public HotbarServicesInjector(ServicesProvider provider, PlayerMenuService playerMenuService, LevelCoroutines levelCoroutines, Func<IModifLogger> getLogger)
		{
			_provider = provider;
			_playerMenuService = playerMenuService;
			_levelCoroutines = levelCoroutines;
			_getLogger = getLogger;
			_playerMenuService.OnPlayerActionMenusConfigured += TryAddHotbarServices;
		}

		private void TryAddHotbarServices(PlayerActionMenus actionMenus, SplitPlayer splitPlayer)
		{
			try
			{
				AddHotbarServices(actionMenus, splitPlayer);
			}
			catch (Exception ex)
			{
				Logger.LogException($"Failed to enable Action Slots for player {splitPlayer.RewiredID}.", ex);
			}
		}

		private void AddHotbarServices(PlayerActionMenus actionMenus, SplitPlayer splitPlayer)
		{
			Logger.LogDebug(string.Format("{0}::{1} Beginning Hotbar Services Injection for player {2}.", "HotbarServicesInjector", "AddHotbarServices", splitPlayer.RewiredID));
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(splitPlayer.RewiredID);
			if (servicesProvider.ContainsService<HotbarsContainer>())
			{
				Logger.LogDebug(string.Format("{0}::{1} Hotbars already injected for player {2}.", "HotbarServicesInjector", "AddHotbarServices", splitPlayer.RewiredID));
				return;
			}
			IActionUIProfileService service = servicesProvider.GetService<IActionUIProfileService>();
			if (service.GetActiveProfile().ActionSlotsEnabled)
			{
				HotbarsContainer componentInChildren = ((Component)actionMenus).gameObject.GetComponentInChildren<HotbarsContainer>(true);
				Player player = ReInput.players.GetPlayer(splitPlayer.RewiredID);
				servicesProvider.AddSingleton<HotbarsContainer>(componentInChildren).AddSingleton<HotbarService>(new HotbarService(componentInChildren, player, splitPlayer.AssignedCharacter, servicesProvider.GetService<IHotbarProfileService>(), servicesProvider.GetService<IActionUIProfileService>(), servicesProvider.GetService<SlotDataService>(), _levelCoroutines, _getLogger)).AddSingleton<ControllerMapService>(new ControllerMapService(servicesProvider.GetService<HotkeyCaptureMenu>(), servicesProvider.GetService<IHotbarProfileService>(), servicesProvider.GetService<IActionUIProfileService>(), servicesProvider.GetService<HotbarService>(), player, (ModifCoroutine)(object)_levelCoroutines, _getLogger))
					.AddSingleton<IActionViewData>((IActionViewData)(object)new SlotActionViewData(player, splitPlayer.AssignedCharacter, servicesProvider.GetService<SlotDataService>(), servicesProvider.GetService<IActionUIProfileService>(), _getLogger))
					.AddSingleton<IHotbarNavActions>((IHotbarNavActions)(object)new HotbarKeyListener(player));
				servicesProvider.GetService<ControllerMapService>().LoadConfigMaps();
				Logger.LogDebug("HotbarServicesInjector::AddHotbarServices Completed Hotbar Services Injection.");
			}
		}

		private void RemoveHotbarServices(UnityServicesProvider usp)
		{
			Logger.LogDebug("HotbarServicesInjector::RemoveHotbarServices Destroying existing Hotbar Services.");
			usp.TryDispose<IHotbarNavActions>();
			usp.TryDispose<IActionViewData>();
			usp.TryDispose<ControllerMapService>();
			usp.TryDispose<HotbarService>();
			usp.TryDispose<SlotDataService>();
			usp.TryDispose<IHotbarProfileService>();
			usp.TryRemove<HotbarsContainer>();
		}
	}
	public class InventoryServicesInjector
	{
		private readonly ServicesProvider _services;

		private Func<IModifLogger> _getLogger;

		private readonly ModifGoService _modifGoService;

		private readonly LevelCoroutines _coroutines;

		private IModifLogger Logger => _getLogger();

		public InventoryServicesInjector(ServicesProvider services, PlayerMenuService playerMenuService, ModifGoService modifGoService, LevelCoroutines coroutines, Func<IModifLogger> getLogger)
		{
			_services = services;
			_modifGoService = modifGoService;
			_coroutines = coroutines;
			_getLogger = getLogger;
			_services.GetService<SharedServicesInjector>().OnSharedServicesInjected += TryAddServiceProfiles;
			playerMenuService.OnPlayerActionMenusConfigured += TryAddInventoryServices;
		}

		private void TryAddServiceProfiles(int playerID, string characterUID)
		{
			try
			{
				AddServiceProfiles(playerID, characterUID);
			}
			catch (Exception ex)
			{
				Logger.LogException($"Failed to load equipment set profiles for player {playerID}.", ex);
			}
		}

		private void AddServiceProfiles(int playerID, string characterUID)
		{
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(playerID);
		}

		private void TryAddInventoryServices(PlayerActionMenus actionMenus, SplitPlayer splitPlayer)
		{
			try
			{
				AddInventoryServices(actionMenus, splitPlayer);
			}
			catch (Exception ex)
			{
				Logger.LogException($"Failed to enable Inventory UIs for player {splitPlayer.RewiredID}.", ex);
			}
		}

		private void AddInventoryServices(PlayerActionMenus actionMenus, SplitPlayer splitPlayer)
		{
			Logger.LogDebug($"Adding Inventory Services for player {splitPlayer.RewiredID}");
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(splitPlayer.RewiredID);
			servicesProvider.AddSingleton<InventoryService>(new InventoryService(splitPlayer.AssignedCharacter, servicesProvider.GetService<IActionUIProfileService>(), _coroutines, _getLogger));
			Starter.TryStart(servicesProvider.GetService<InventoryService>());
		}
	}
	internal class PositionsServicesInjector
	{
		private readonly ServicesProvider _services;

		private readonly ModifGoService _modifGoService;

		private readonly ModifCoroutine _coroutines;

		private Func<IModifLogger> _getLogger;

		private IModifLogger Logger => _getLogger();

		public PositionsServicesInjector(ServicesProvider services, PlayerMenuService playerMenuService, ModifGoService modifGoService, ModifCoroutine coroutines, Func<IModifLogger> getLogger)
		{
			_services = services;
			_modifGoService = modifGoService;
			_coroutines = coroutines;
			_getLogger = getLogger;
			playerMenuService.OnPlayerActionMenusConfigured += TryAddPositionsServices;
		}

		private void TryAddPositionsServices(PlayerActionMenus actionMenus, SplitPlayer splitPlayer)
		{
			try
			{
				AddPositionsServices(actionMenus, splitPlayer);
			}
			catch (Exception ex)
			{
				Logger.LogException($"Failed to enable Positioning UI for player {splitPlayer.RewiredID}.", ex);
			}
		}

		private void AddPositionsServices(PlayerActionMenus actionMenus, SplitPlayer splitPlayer)
		{
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(splitPlayer.RewiredID);
			servicesProvider.AddSingleton<IPositionsProfileService>(_services.GetService<IPositionsProfileService>());
			if (!servicesProvider.ContainsService<IPositionsProfileService>())
			{
				servicesProvider.AddSingleton<IPositionsProfileService>(_services.GetService<IPositionsProfileService>());
			}
		}
	}
	public class SharedServicesInjector
	{
		public delegate void SharedServicesInjectedDelegate(int playerID, string characterUID);

		private readonly ServicesProvider _services;

		private Func<IModifLogger> _getLogger;

		private IModifLogger Logger => _getLogger();

		public event SharedServicesInjectedDelegate OnSharedServicesInjected;

		public SharedServicesInjector(ServicesProvider services, Func<IModifLogger> getLogger)
		{
			_services = services;
			_getLogger = getLogger;
			SplitPlayerPatches.SetCharacterAfter += AddSharedServices;
		}

		private void AddSharedServices(SplitPlayer splitPlayer, Character character)
		{
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(splitPlayer.RewiredID);
			Player player = ReInput.players.GetPlayer(splitPlayer.RewiredID);
			servicesProvider.AddSingleton<IHotbarProfileService>(_services.GetService<IHotbarProfileService>());
			servicesProvider.AddSingleton<IPositionsProfileService>(_services.GetService<IPositionsProfileService>());
			servicesProvider.AddSingleton<IActionUIProfileService>(_services.GetService<IActionUIProfileService>());
			servicesProvider.AddSingleton<SlotDataService>(new SlotDataService(player, splitPlayer.AssignedCharacter, servicesProvider.GetService<IHotbarProfileService>(), _getLogger));
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Services.CharacterServices
{
	internal class CharacterMenuStashService : IDisposable
	{
		public void Start()
		{
		}

		public void Dispose()
		{
		}
	}
	internal class EquipService : IDisposable
	{
		public void Start()
		{
		}

		public void Dispose()
		{
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Patches
{
	[HarmonyPatch(typeof(CharacterInventory))]
	internal static class CharacterInventoryPatches
	{
		public delegate void InventoryIngredientsDelegate(CharacterInventory characterInventory, Character character, Tag craftingStationTag, ref DictionaryExt<int, CompatibleIngredient> sortedIngredients);

		public delegate bool OwnsItemDelegate(string itemUID);

		public static Dictionary<int, OwnsItemDelegate> OwnsItemDelegates = new Dictionary<int, OwnsItemDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event InventoryIngredientsDelegate AfterInventoryIngredients;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void InventoryIngredientsPostFix(CharacterInventory __instance, Character ___m_character, Tag _craftingStationTag, ref DictionaryExt<int, CompatibleIngredient> _sortedIngredient)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)___m_character == (Object)null) && !((Object)(object)___m_character?.OwnerPlayerSys == (Object)null) && ___m_character.IsLocalPlayer)
				{
					Logger.LogTrace("CharacterInventoryPatches::InventoryIngredientsPostFix(): Invoking AfterInventoryIngredients.");
					CharacterInventoryPatches.AfterInventoryIngredients?.Invoke(__instance, ___m_character, _craftingStationTag, ref _sortedIngredient);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("CharacterInventoryPatches::InventoryIngredientsPostFix(): Exception invoking AfterInventoryIngredients.", ex);
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPatch(new Type[] { typeof(string) })]
		[HarmonyPostfix]
		private static void OwnsItemPostFix(CharacterInventory __instance, Character ___m_character, string _itemUID, ref bool __result)
		{
			try
			{
				if (!__result && !((Object)(object)___m_character?.OwnerPlayerSys == (Object)null) && ___m_character.IsLocalPlayer)
				{
					int playerID = ___m_character.OwnerPlayerSys.PlayerID;
					if (OwnsItemDelegates.TryGetValue(playerID, out var value))
					{
						__result = value(_itemUID);
					}
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger = Logger;
				object[] obj = new object[4] { "CharacterInventoryPatches", "OwnsItemPostFix", "OwnsItemDelegates", null };
				int? obj2;
				if (___m_character == null)
				{
					obj2 = null;
				}
				else
				{
					PlayerSystem ownerPlayerSys = ___m_character.OwnerPlayerSys;
					obj2 = ((ownerPlayerSys != null) ? new int?(ownerPlayerSys.PlayerID) : null);
				}
				obj[3] = obj2;
				logger.LogException(string.Format("{0}::{1}(): Exception invoking {2} delegate for PlayerID {3}.", obj), ex);
			}
		}
	}
	[HarmonyPatch(typeof(CharacterManager))]
	internal static class CharacterManagerPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<Character> AfterAddCharacter;

		[HarmonyPatch("AddCharacter")]
		[HarmonyPatch(new Type[] { typeof(Character) })]
		[HarmonyPostfix]
		private static void AddCharacterPostfix(Character _char)
		{
			try
			{
				if (_char.IsLocalPlayer && !_char.IsAI)
				{
					Logger.LogTrace("CharacterManagerPatches::AddCharacterPostfix(): Invoked. Invoking AfterAddCharacter for character " + ((_char != null) ? ((Object)_char).name : null) + ".");
					CharacterManagerPatches.AfterAddCharacter?.Invoke(_char);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("CharacterManagerPatches::AddCharacterPostfix(): Exception Invoking AfterAddCharacter for character " + ((_char != null) ? ((Object)_char).name : null) + ".", ex);
			}
		}
	}
	[HarmonyPatch(typeof(CharacterQuickSlotManager))]
	internal static class CharacterQuickSlotManagerPatches
	{
		public delegate bool AllowItemDestroyedDelegate(int rewiredId);

		public static Dictionary<int, AllowItemDestroyedDelegate> AllowItemDestroyed = new Dictionary<int, AllowItemDestroyedDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch("ItemDestroyed")]
		[HarmonyPatch(new Type[]
		{
			typeof(Item),
			typeof(int)
		})]
		[HarmonyPrefix]
		private static bool ItemDestroyedPrefix(Character ___m_character, QuickSlot[] ___m_quickSlots, Item _item, int _quickSlotID)
		{
			try
			{
				if ((Object)(object)___m_character == (Object)null || (Object)(object)___m_character?.OwnerPlayerSys == (Object)null || !___m_character.IsLocalPlayer)
				{
					return true;
				}
				IModifLogger logger = Logger;
				int? obj;
				if (___m_character == null)
				{
					obj = null;
				}
				else
				{
					PlayerSystem ownerPlayerSys = ___m_character.OwnerPlayerSys;
					obj = ((ownerPlayerSys != null) ? new int?(ownerPlayerSys.PlayerID) : null);
				}
				logger.LogTrace(string.Format("{0}::{1}(): Invoked for PlayerID {2}.", "CharacterQuickSlotManagerPatches", "ItemDestroyedPrefix", obj));
				if ((Object)(object)___m_character?.OwnerPlayerSys != (Object)null)
				{
					if (___m_quickSlots.Length > _quickSlotID && (Object)(object)___m_quickSlots[_quickSlotID] != (Object)null)
					{
						return true;
					}
					int playerID = ___m_character.OwnerPlayerSys.PlayerID;
					if (AllowItemDestroyed.TryGetValue(playerID, out var value))
					{
						bool flag = value(playerID);
						Logger.LogTrace(string.Format("{0}::{1}(): PlayerID {2}: Allow item in quickslot {3} to be destroyed? {4}.", "CharacterQuickSlotManagerPatches", "ItemDestroyedPrefix", playerID, _quickSlotID, flag));
						return flag;
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("CharacterQuickSlotManagerPatches::ItemDestroyedPrefix(): Exception calling AllowItemDestroyed Delegate.", ex);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterUI))]
	internal static class CharacterUIPatches
	{
		public delegate bool GetIsMenuFocusedDelegate(int rewiredId);

		public delegate void ReleaseUIDelegate(CharacterUI characterUI, int rewiredId);

		public delegate void ShowMenuDelegate(CharacterUI characterUI, MenuScreens menu, Item item);

		public static Dictionary<int, GetIsMenuFocusedDelegate> GetIsMenuFocused = new Dictionary<int, GetIsMenuFocusedDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event ReleaseUIDelegate BeforeReleaseUI;

		public static event ShowMenuDelegate BeforeShowMenu;

		public static event Action<CharacterUI> AfterRefreshHUDVisibility;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void IsMenuFocusedPostfix(CharacterUI __instance, ref bool __result)
		{
			try
			{
				if (!((Object)(object)__instance.TargetCharacter == (Object)null) && !((Object)(object)__instance.TargetCharacter.OwnerPlayerSys == (Object)null) && __instance.TargetCharacter.IsLocalPlayer)
				{
					int playerID = __instance.TargetCharacter.OwnerPlayerSys.PlayerID;
					if (GetIsMenuFocused.TryGetValue(playerID, out var value) && value(playerID))
					{
						__result = true;
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("CharacterUIPatches::IsMenuFocusedPostfix(): Exception Invoking GetIsMenuFocused.", ex);
			}
		}

		[HarmonyPatch("ReleaseUI")]
		[HarmonyPrefix]
		private static void ReleaseUIPrefix(CharacterUI __instance, int ___m_rewiredID)
		{
			try
			{
				if (___m_rewiredID != -1)
				{
					Logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for RewiredID {3}.", "CharacterUIPatches", "ReleaseUIPrefix", "BeforeReleaseUI", ___m_rewiredID));
					CharacterUIPatches.BeforeReleaseUI?.Invoke(__instance, ___m_rewiredID);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException(string.Format("{0}::{1}(): Exception Invoking {2} for RewiredID {3}.", "CharacterUIPatches", "ReleaseUIPrefix", "BeforeReleaseUI", ___m_rewiredID), ex);
			}
		}

		[HarmonyPatch("ShowMenu")]
		[HarmonyPatch(new Type[]
		{
			typeof(MenuScreens),
			typeof(Item)
		})]
		[HarmonyPrefix]
		private static void ShowMenuPrefix(CharacterUI __instance, MenuScreens _menu, Item _item)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)__instance.TargetCharacter == (Object)null) && !((Object)(object)__instance.TargetCharacter.OwnerPlayerSys == (Object)null) && __instance.TargetCharacter.IsLocalPlayer)
				{
					Logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for character {3}.", "CharacterUIPatches", "ShowMenuPrefix", "BeforeShowMenu", __instance.TargetCharacter.UID));
					CharacterUIPatches.BeforeShowMenu?.Invoke(__instance, _menu, _item);
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger = Logger;
				object[] obj = new object[4] { "CharacterUIPatches", "ShowMenuPrefix", "BeforeShowMenu", null };
				Character targetCharacter = __instance.TargetCharacter;
				obj[3] = ((targetCharacter != null) ? new UID?(targetCharacter.UID) : null);
				logger.LogException(string.Format("{0}::{1}(): Exception Invoking {2} for character {3}.", obj), ex);
			}
		}

		[HarmonyPatch("RefreshHUDVisibility")]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPostfix]
		private static void RefreshHUDVisibilityPostfix(CharacterUI __instance)
		{
			try
			{
				if (!((Object)(object)__instance.TargetCharacter == (Object)null) && !((Object)(object)__instance.TargetCharacter.OwnerPlayerSys == (Object)null) && __instance.TargetCharacter.IsLocalPlayer)
				{
					int playerID = __instance.TargetCharacter.OwnerPlayerSys.PlayerID;
					Logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for PlayerID {3}.", "CharacterUIPatches", "RefreshHUDVisibilityPostfix", "AfterRefreshHUDVisibility", playerID));
					CharacterUIPatches.AfterRefreshHUDVisibility?.Invoke(__instance);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("CharacterUIPatches::RefreshHUDVisibilityPostfix(): Exception Invoking AfterRefreshHUDVisibility.", ex);
			}
		}
	}
	[HarmonyPatch(typeof(ControlsInput))]
	internal static class ControlsInputPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch("SetQuickSlotActive")]
		[HarmonyPrefix]
		private static void SetQuickSlotActivePrefix(int _playerID, ref bool _active)
		{
			try
			{
				HotbarsContainer val = default(HotbarsContainer);
				if (!ControlsInput.IsLastActionGamepad(_playerID) && Psp.Instance.GetServicesProvider(_playerID).TryGetService<HotbarsContainer>(ref val) && val.IsAwake)
				{
					ReInput.players.GetPlayer(_playerID).controllers.maps.SetMapsEnabled(_active, (ControllerType)0, 131000);
					PlayerActionMenus val2 = default(PlayerActionMenus);
					if (!_active && Psp.Instance.GetServicesProvider(_playerID).TryGetService<PlayerActionMenus>(ref val2) && val2.MainSettingsMenu.IsShowing)
					{
						val.Controller.ToggleActionSlotEdits(!_active, true);
					}
					else
					{
						val.Controller.ToggleActionSlotEdits(!_active, false);
					}
					_active = false;
				}
			}
			catch (Exception ex)
			{
				Logger.LogException(string.Format("{0}::{1}(): Exception disabling quickslots for player {2}.", "ControlsInputPatches", "SetQuickSlotActivePrefix", _playerID), ex);
			}
		}
	}
	[HarmonyPatch(typeof(CurrencyDisplayClick))]
	internal static class CurrencyDisplayClickPatches
	{
		public delegate bool TryOverrideOnCurrencyCtrlClickedDelegate(CurrencyDisplay currencyDisplay, bool stashKeyPressed);

		public static Dictionary<int, TryOverrideOnCurrencyCtrlClickedDelegate> PlayersOnCurrencyCtrlClicked = new Dictionary<int, TryOverrideOnCurrencyCtrlClickedDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch("DoubleClick")]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPrefix]
		private static bool DoubleClickPrefix(CurrencyDisplayClick __instance, CurrencyDisplay ___m_currencyDisplay)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Invalid comparison between Unknown and I4
			try
			{
				if (((___m_currencyDisplay != null) ? ___m_currencyDisplay.CurrentCurrencyHolder : null) == null)
				{
					return true;
				}
				if (!PlayersOnCurrencyCtrlClicked.TryGetValue(((UIElement)___m_currencyDisplay).PlayerID, out var value))
				{
					return true;
				}
				Player player = ReInput.players.GetPlayer(((UIElement)___m_currencyDisplay).PlayerID);
				if ((int)player.controllers.GetLastActiveController().type != 0 && (int)player.controllers.GetLastActiveController().type != 1)
				{
					return true;
				}
				bool stashKeyPressed = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
				Logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for CurrencyDisplayClick {3} and player ID {4}.", "CurrencyDisplayClickPatches", "DoubleClickPrefix", "PlayersOnCurrencyCtrlClicked", ((Object)__instance).name, ((UIElement)___m_currencyDisplay).PlayerID));
				if (value(___m_currencyDisplay, stashKeyPressed))
				{
					return false;
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("CurrencyDisplayClickPatches::DoubleClickPrefix(): Exception invoking PlayersOnCurrencyCtrlClicked for CurrencyDisplayClick " + ((Object)__instance).name + ".", ex);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EquipmentMenu))]
	internal static class EquipmentMenuPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<EquipmentMenu> AfterShow;

		public static event Action<EquipmentMenu> AfterOnHide;

		[HarmonyPatch("Show")]
		[HarmonyPostfix]
		private static void ShowPostfix(EquipmentMenu __instance)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)((UIElement)__instance).LocalCharacter == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					IModifLogger logger = Logger;
					object[] obj = new object[4] { "EquipmentMenuPatches", "ShowPostfix", "AfterShow", null };
					Character localCharacter = ((UIElement)__instance).LocalCharacter;
					obj[3] = ((localCharacter != null) ? new UID?(localCharacter.UID) : null);
					logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for character {3}.", obj));
					EquipmentMenuPatches.AfterShow?.Invoke(__instance);
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger2 = Logger;
				object[] obj2 = new object[4] { "EquipmentMenuPatches", "ShowPostfix", "AfterShow", null };
				UID? obj3;
				if (__instance == null)
				{
					obj3 = null;
				}
				else
				{
					Character localCharacter2 = ((UIElement)__instance).LocalCharacter;
					obj3 = ((localCharacter2 != null) ? new UID?(localCharacter2.UID) : null);
				}
				obj2[3] = obj3;
				logger2.LogException(string.Format("{0}::{1}(): Exception invoking {2} for character {3}.", obj2), ex);
			}
		}

		[HarmonyPatch("OnHide")]
		[HarmonyPostfix]
		private static void OnHidePostfix(EquipmentMenu __instance)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)((UIElement)__instance).LocalCharacter == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					IModifLogger logger = Logger;
					object[] obj = new object[4] { "EquipmentMenuPatches", "OnHidePostfix", "AfterOnHide", null };
					Character localCharacter = ((UIElement)__instance).LocalCharacter;
					obj[3] = ((localCharacter != null) ? new UID?(localCharacter.UID) : null);
					logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for character {3}.", obj));
					EquipmentMenuPatches.AfterOnHide?.Invoke(__instance);
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger2 = Logger;
				object[] obj2 = new object[4] { "EquipmentMenuPatches", "OnHidePostfix", "AfterOnHide", null };
				UID? obj3;
				if (__instance == null)
				{
					obj3 = null;
				}
				else
				{
					Character localCharacter2 = ((UIElement)__instance).LocalCharacter;
					obj3 = ((localCharacter2 != null) ? new UID?(localCharacter2.UID) : null);
				}
				obj2[3] = obj3;
				logger2.LogException(string.Format("{0}::{1}(): Exception invoking {2} for character {3}.", obj2), ex);
			}
		}
	}
	[HarmonyPatch(typeof(Equipment))]
	internal static class EquipmentPatches
	{
		public delegate void OnEquipDelegate(Character character, Equipment equipment);

		public delegate void OnUnequipDelegate(Character character, Equipment equipment);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event OnEquipDelegate AfterOnEquip;

		public static event OnUnequipDelegate AfterOnUnequip;

		[HarmonyPatch("OnEquip")]
		[HarmonyPatch(new Type[] { typeof(Character) })]
		[HarmonyPostfix]
		private static void OnEquipPostfix(Equipment __instance, Character _char)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)_char == (Object)null) && !((Object)(object)_char.OwnerPlayerSys == (Object)null) && _char.IsLocalPlayer)
				{
					Logger.LogTrace(string.Format("{0}::{1}(): Invoked. Equipped item '{2}' to slot '{3}' for character {4}. Invoking {5}.", "EquipmentPatches", "OnEquipPostfix", ((Object)__instance).name, ((Item)__instance).CurrentEquipmentSlot?.SlotType, (_char != null) ? ((Object)_char).name : null, "AfterOnEquip"));
					EquipmentPatches.AfterOnEquip?.Invoke(_char, __instance);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("EquipmentPatches::OnEquipPostfix(): Exception Invoking AfterOnEquip for equipment item '" + ((__instance != null) ? ((Object)__instance).name : null) + "' and character " + ((_char != null) ? ((Object)_char).name : null) + ".", ex);
			}
		}

		[HarmonyPatch("OnUnequip")]
		[HarmonyPatch(new Type[] { typeof(Character) })]
		[HarmonyPostfix]
		private static void OnUnequipPostfix(Equipment __instance, Character _char)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)_char == (Object)null) && !((Object)(object)_char.OwnerPlayerSys == (Object)null) && _char.IsLocalPlayer)
				{
					Logger.LogTrace(string.Format("{0}::{1}(): Invoked. Unequipped item '{2}' from slot '{3}' for character {4}. Invoking {5}.", "EquipmentPatches", "OnUnequipPostfix", ((Object)__instance).name, ((Item)__instance).CurrentEquipmentSlot?.SlotType, (_char != null) ? ((Object)_char).name : null, "AfterOnUnequip"));
					EquipmentPatches.AfterOnUnequip?.Invoke(_char, __instance);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("EquipmentPatches::OnUnequipPostfix(): Exception invoking AfterOnUnequip for character " + ((_char != null) ? ((Object)_char).name : null) + " and equipment " + ((__instance != null) ? ((Object)__instance).name : null) + ".", ex);
			}
		}
	}
	[HarmonyPatch(typeof(InputManager_Base))]
	public class InputManager_BasePatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<InputManager_Base> BeforeInitialize;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void InitializePrefix(InputManager_Base __instance)
		{
			try
			{
				Logger.LogTrace("InputManager_BasePatches::InitializePrefix(): Invoked. Invoking BeforeInitialize(InputManager_Base).");
				InputManager_BasePatches.BeforeInitialize?.Invoke(__instance);
			}
			catch (Exception ex)
			{
				Logger.LogException("InputManager_BasePatches::InitializePrefix(): Exception Invoking BeforeInitialize(InputManager_Base).", ex);
			}
		}
	}
	[HarmonyPatch(typeof(InventoryContentDisplay))]
	internal static class InventoryContentDisplayPatches
	{
		public delegate void AfterFocusMostRelevantItemDelegate(InventoryContentDisplay inventoryContentDisplay, ItemListDisplay excludedList, bool result);

		public delegate void AfterSetContainersVisibilityDelegate(InventoryContentDisplay inventoryContentDisplay, bool showPouch, bool showBag, bool showEquipment);

		public delegate void AfterRefreshReferencesDelegate(InventoryContentDisplay inventoryContentDisplay, bool forceRefresh);

		public delegate void AfterRefreshContainerDisplaysDelegate(InventoryContentDisplay inventoryContentDisplay, bool clearAssignedDisplay);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<InventoryContentDisplay> AfterShow;

		public static event Action<InventoryContentDisplay> AfterOnHide;

		public static event AfterFocusMostRelevantItemDelegate AfterFocusMostRelevantItem;

		public static event AfterSetContainersVisibilityDelegate AfterSetContainersVisibility;

		public static event AfterRefreshReferencesDelegate AfterRefreshReferences;

		public static event AfterRefreshContainerDisplaysDelegate AfterRefreshContainerDisplays;

		[HarmonyPatch("Show")]
		[HarmonyPostfix]
		private static void ShowPostfix(InventoryContentDisplay __instance)
		{
			try
			{
				if (!((Object)(object)((UIElement)__instance).LocalCharacter == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					Logger.LogDebug("InventoryContentDisplay::ShowPostfix(): Invoking AfterShow.");
					InventoryContentDisplayPatches.AfterShow?.Invoke(__instance);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("InventoryContentDisplay::ShowPostfix(): Exception invoking AfterShow.", ex);
			}
		}

		[HarmonyPatch("OnHide")]
		[HarmonyPostfix]
		private static void OnHidePostfix(InventoryContentDisplay __instance)
		{
			try
			{
				if (!((Object)(object)((UIElement)__instance).LocalCharacter == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					Logger.LogDebug("InventoryContentDisplay::OnHidePostfix(): Invoking AfterOnHide.");
					InventoryContentDisplayPatches.AfterOnHide?.Invoke(__instance);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("InventoryContentDisplay::OnHidePostfix(): Exception invoking AfterOnHide.", ex);
			}
		}

		[HarmonyPatch("FocusMostRelevantItem")]
		[HarmonyPatch(new Type[] { typeof(ItemListDisplay) })]
		[HarmonyPostfix]
		private static void FocusMostRelevantItemPostfix(InventoryContentDisplay __instance, ItemListDisplay _excludedList, bool __result)
		{
			try
			{
				Logger.LogTrace("InventoryContentDisplay::FocusMostRelevantItemPostfix(): Invoking AfterFocusMostRelevantItem.");
				InventoryContentDisplayPatches.AfterFocusMostRelevantItem?.Invoke(__instance, _excludedList, __result);
			}
			catch (Exception ex)
			{
				Logger.LogException("InventoryContentDisplay::FocusMostRelevantItemPostfix(): Exception invoking AfterFocusMostRelevantItem.", ex);
			}
		}

		[HarmonyPatch("SetContainersVisibility")]
		[HarmonyPatch(new Type[]
		{
			typeof(bool),
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void SetContainersVisibilityPostfix(InventoryContentDisplay __instance, bool _showPouch, bool _showBag, bool _showEquipment)
		{
			try
			{
				Logger.LogDebug("InventoryContentDisplay::SetContainersVisibilityPostfix(): Invoking AfterSetContainersVisibility.");
				InventoryContentDisplayPatches.AfterSetContainersVisibility?.Invoke(__instance, _showPouch, _showBag, _showEquipment);
			}
			catch (Exception ex)
			{
				Logger.LogException("InventoryContentDisplay::SetContainersVisibilityPostfix(): Exception invoking AfterSetContainersVisibility.", ex);
			}
		}

		[HarmonyPatch("RefreshReferences")]
		[HarmonyPatch(new Type[] { typeof(bool) })]
		[HarmonyPostfix]
		private static void RefreshReferencesPostfix(InventoryContentDisplay __instance, bool _forceRefresh)
		{
			try
			{
				Logger.LogDebug("InventoryContentDisplay::RefreshReferencesPostfix(): Invoking AfterRefreshReferences.");
				InventoryContentDisplayPatches.AfterRefreshReferences?.Invoke(__instance, _forceRefresh);
			}
			catch (Exception ex)
			{
				Logger.LogException("InventoryContentDisplay::RefreshReferencesPostfix(): Exception invoking AfterRefreshReferences.", ex);
			}
		}

		[HarmonyPatch("RefreshContainerDisplays")]
		[HarmonyPatch(new Type[] { typeof(bool) })]
		[HarmonyPostfix]
		private static void RefreshContainerDisplaysPostfix(InventoryContentDisplay __instance, bool _clearAssignedDisplay)
		{
			try
			{
				Logger.LogDebug("InventoryContentDisplay::RefreshContainerDisplaysPostfix(): Invoking AfterRefreshContainerDisplays.");
				InventoryContentDisplayPatches.AfterRefreshContainerDisplays?.Invoke(__instance, _clearAssignedDisplay);
			}
			catch (Exception ex)
			{
				Logger.LogException("InventoryContentDisplay::RefreshContainerDisplaysPostfix(): Exception invoking AfterRefreshContainerDisplays.", ex);
			}
		}
	}
	[HarmonyPatch(typeof(ItemDisplayClick))]
	internal static class ItemDisplayClickPatches
	{
		public delegate bool TryOverrideOnItemCtrlClickedDelegate(ItemDisplay itemDisplay, bool stashKeyPressed);

		public static Dictionary<int, TryOverrideOnItemCtrlClickedDelegate> PlayersOnItemCtrlClicked = new Dictionary<int, TryOverrideOnItemCtrlClickedDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch("DoubleClick")]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPrefix]
		private static bool DoubleClickPrefix(ItemDisplayClick __instance, ItemDisplay ___m_itemDisplay)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			try
			{
				if ((Object)(object)___m_itemDisplay == (Object)null || (Object)(object)___m_itemDisplay.RefItem == (Object)null)
				{
					return true;
				}
				if (___m_itemDisplay.RefItem is Skill || !PlayersOnItemCtrlClicked.TryGetValue(((UIElement)___m_itemDisplay).PlayerID, out var value))
				{
					return true;
				}
				Player player = ReInput.players.GetPlayer(((UIElement)___m_itemDisplay).PlayerID);
				if ((int)player.controllers.GetLastActiveController().type != 0 && (int)player.controllers.GetLastActiveController().type != 1)
				{
					return true;
				}
				bool stashKeyPressed = Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305);
				Logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for ItemDisplayClick {3} and player ID {4}.", "ItemDisplayClickPatches", "DoubleClickPrefix", "PlayersOnItemCtrlClicked", ((Object)__instance).name, ((UIElement)___m_itemDisplay).PlayerID));
				if (value(___m_itemDisplay, stashKeyPressed))
				{
					return false;
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("ItemDisplayClickPatches::DoubleClickPrefix(): Exception invoking PlayersOnItemCtrlClicked for ItemDisplayClick " + ((Object)__instance).name + ".", ex);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ItemDisplayDropGround))]
	internal static class ItemDisplayDropGroundPatches
	{
		public delegate bool TryGetIsDropValidDelegate(ItemDisplay draggedDisplay, Character character, out bool result);

		public static Dictionary<int, TryGetIsDropValidDelegate> TryGetIsDropValids = new Dictionary<int, TryGetIsDropValidDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch("IsDropValid")]
		[HarmonyPostfix]
		private static void IsDropValidPostfix(ItemDisplay ___m_draggedDisplay, ref bool __result)
		{
			try
			{
				if (!((Object)(object)((___m_draggedDisplay != null) ? ((UIElement)___m_draggedDisplay).LocalCharacter : null) == (Object)null) && !((Object)(object)((UIElement)___m_draggedDisplay).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)___m_draggedDisplay).LocalCharacter.IsLocalPlayer)
				{
					int playerID = ((UIElement)___m_draggedDisplay).LocalCharacter.OwnerPlayerSys.PlayerID;
					if (TryGetIsDropValids.TryGetValue(playerID, out var value) && value(___m_draggedDisplay, ((UIElement)___m_draggedDisplay).LocalCharacter, out var result))
					{
						__result = result;
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("ItemDisplayDropGroundPatches::IsDropValidPostfix(): Exception Invoking TryGetIsDropValids.", ex);
			}
		}
	}
	[HarmonyPatch(typeof(ItemDisplayOptionPanel))]
	internal static class ItemDisplayOptionPanelPatches
	{
		public delegate bool TryGetActiveActionsDelegate(int rewiredId, Item item, List<int> baseActiveActions, out List<int> activeActions);

		public delegate void PressedActionDelegate(int actionID, ItemDisplay itemDisplay);

		public static int PlayersMoveToStashID = -1;

		public static Dictionary<int, TryGetActiveActionsDelegate> TryGetActiveActions = new Dictionary<int, TryGetActiveActionsDelegate>();

		public static Dictionary<int, PressedActionDelegate> PlayersPressedAction = new Dictionary<int, PressedActionDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch("StartInit")]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPostfix]
		private static void AddStashActionString(ItemDisplayOptionPanel __instance, ref string[] ___ActionStrings)
		{
			try
			{
				int num = UnityEngineExtensions.IndexOf<string>(___ActionStrings, "Context_Item_MoveToStash");
				Logger.LogTrace(string.Format("{0}::{1}(): Adding new context action string {2}. indexOf == {3}", "ItemDisplayOptionPanelPatches", "AddStashActionString", "Context_Item_MoveToStash", num));
				if (num != -1)
				{
					PlayersMoveToStashID = num;
					return;
				}
				List<string> list = ___ActionStrings.ToList();
				list.Add("Context_Item_MoveToStash");
				___ActionStrings = list.ToArray();
				PlayersMoveToStashID = ___ActionStrings.Length - 1;
			}
			catch (Exception ex)
			{
				Logger.LogException("ItemDisplayOptionPanelPatches::AddStashActionString(): Exception adding new action Context_Item_MoveToStash.", ex);
			}
		}

		[HarmonyPatch("GetActiveActions")]
		[HarmonyPatch(new Type[] { typeof(GameObject) })]
		[HarmonyPostfix]
		private static void GetActiveActionsPostfix(ItemDisplayOptionPanel __instance, Item ___m_pendingItem, GameObject pointerPress, ref List<int> __result)
		{
			try
			{
				if (!((Object)(object)___m_pendingItem == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter?.OwnerPlayerSys == (Object)null))
				{
					int playerID = ((UIElement)__instance).LocalCharacter.OwnerPlayerSys.PlayerID;
					if (TryGetActiveActions.TryGetValue(playerID, out var value) && value(playerID, ___m_pendingItem, __result, out var activeActions))
					{
						__result = activeActions;
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("ItemDisplayOptionPanelPatches::GetActiveActionsPostfix(): Exception Invoking TryGetActiveActions.", ex);
			}
		}

		[HarmonyPatch("ActionHasBeenPressed")]
		[HarmonyPatch(new Type[] { typeof(int) })]
		[HarmonyPrefix]
		private static void ActionHasBeenPressedPrefix(ItemDisplayOptionPanel __instance, ItemDisplay ___m_activatedItemDisplay, int _actionID)
		{
			try
			{
				if ((Object)(object)((UIElement)__instance).LocalCharacter?.OwnerPlayerSys == (Object)null)
				{
					return;
				}
				Character localCharacter = ((UIElement)__instance).LocalCharacter;
				if (!((Object)(object)((localCharacter != null) ? localCharacter.Inventory : null) == (Object)null))
				{
					int playerID = ((UIElement)__instance).LocalCharacter.OwnerPlayerSys.PlayerID;
					if (PlayersPressedAction.TryGetValue(playerID, out var value))
					{
						Logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for for player {3}.", "ItemDisplayOptionPanelPatches", "ActionHasBeenPressedPrefix", PlayersPressedAction, playerID));
						value(_actionID, ___m_activatedItemDisplay);
					}
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger = Logger;
				object[] obj = new object[4] { "ItemDisplayOptionPanelPatches", "ActionHasBeenPressedPrefix", "PlayersPressedAction", null };
				Character localCharacter2 = ((UIElement)__instance).LocalCharacter;
				int? obj2;
				if (localCharacter2 == null)
				{
					obj2 = null;
				}
				else
				{
					PlayerSystem ownerPlayerSys = localCharacter2.OwnerPlayerSys;
					obj2 = ((ownerPlayerSys != null) ? new int?(ownerPlayerSys.PlayerID) : null);
				}
				obj[3] = obj2;
				logger.LogException(string.Format("{0}::{1}(): Exception Invoking {2} for PlayerID {3}.", obj), ex);
			}
		}
	}
	[HarmonyPatch(typeof(ItemDisplay))]
	internal static class ItemDisplayPatches
	{
		public delegate void AfterSetReferencedItemDelegate(ItemDisplay itemDisplay, Item item);

		public delegate bool BeforeUpdateValueDisplayDelegate(ItemDisplay itemDisplay);

		public static Dictionary<int, BeforeUpdateValueDisplayDelegate> PlayersUpdateValueDisplay = new Dictionary<int, BeforeUpdateValueDisplayDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event AfterSetReferencedItemDelegate AfterSetReferencedItem;

		[HarmonyPatch("SetReferencedItem")]
		[HarmonyPatch(new Type[] { typeof(Item) })]
		[HarmonyPostfix]
		private static void SetReferencedItemPostfix(ItemDisplay __instance, Item _item)
		{
			try
			{
				if (!((Object)(object)_item == (Object)null) && !((Object)(object)((__instance != null) ? ((UIElement)__instance).LocalCharacter : null) == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					Logger.LogTrace("ItemDisplayPatches::SetReferencedItemPostfix(): Invoking AfterSetReferencedItem for Item " + ((Object)_item).name + ".");
					ItemDisplayPatches.AfterSetReferencedItem?.Invoke(__instance, _item);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("ItemDisplayPatches::SetReferencedItemPostfix(): Exception invoking AfterSetReferencedItem for Item " + ((_item != null) ? ((Object)_item).name : null) + ".", ex);
			}
		}

		[HarmonyPatch("UpdateValueDisplay")]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPrefix]
		private static bool UpdateValueDisplayPrefix(ItemDisplay __instance)
		{
			try
			{
				if ((Object)(object)((__instance != null) ? ((UIElement)__instance).LocalCharacter : null) == (Object)null || (Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null || !((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					return true;
				}
				if (!PlayersUpdateValueDisplay.TryGetValue(((UIElement)__instance).LocalCharacter.OwnerPlayerSys.PlayerID, out var value))
				{
					return true;
				}
				if (value(__instance))
				{
					return false;
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("ItemDisplayPatches::UpdateValueDisplayPrefix(): Exception invoking PlayersUpdateValueDisplay.", ex);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(LobbySystem))]
	internal static class LobbySystemPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<LobbySystem> BeforeClearPlayerSystems;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void ClearPlayerSystemsPrefix(LobbySystem __instance, bool _hostLost = false)
		{
			try
			{
				Logger.LogDebug("LobbySystemPatches::ClearPlayerSystemsPrefix: Invoking BeforeClearPlayerSystems.");
				LobbySystemPatches.BeforeClearPlayerSystems?.Invoke(__instance);
			}
			catch (Exception ex)
			{
				Logger.LogException("LobbySystemPatches::ClearPlayerSystemsPrefix: Exception Invoking BeforeClearPlayerSystems", ex);
			}
		}
	}
	[HarmonyPatch(typeof(MenuPanel))]
	internal static class MenuPanelPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<InventoryMenu> AfterShowInventoryMenu;

		public static event Action<SkillMenu> AfterShowSkillMenu;

		public static event Action<InventoryMenu> AfterOnHideInventoryMenu;

		public static event Action<SkillMenu> AfterOnHideSkillMenu;

		public static event Action<MenuPanel> AfterOnHideMenuPanel;

		[HarmonyPatch("Show")]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPostfix]
		private static void ShowPostfix(MenuPanel __instance)
		{
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)((UIElement)__instance).LocalCharacter == (Object)null || (Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null || !((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					return;
				}
				InventoryMenu val = (InventoryMenu)(object)((__instance is InventoryMenu) ? __instance : null);
				if (val != null)
				{
					IModifLogger logger = Logger;
					object[] obj = new object[4] { "MenuPanelPatches", "ShowPostfix", "AfterShowInventoryMenu", null };
					UID? obj2;
					if (__instance == null)
					{
						obj2 = null;
					}
					else
					{
						Character localCharacter = ((UIElement)__instance).LocalCharacter;
						obj2 = ((localCharacter != null) ? new UID?(localCharacter.UID) : null);
					}
					obj[3] = obj2;
					logger.LogDebug(string.Format("{0}::{1}(): Invoking {2} event for character {3}.", obj));
					MenuPanelPatches.AfterShowInventoryMenu?.Invoke(val);
					return;
				}
				SkillMenu val2 = (SkillMenu)(object)((__instance is SkillMenu) ? __instance : null);
				if (val2 != null)
				{
					IModifLogger logger2 = Logger;
					object[] obj3 = new object[4] { "MenuPanelPatches", "ShowPostfix", "AfterShowSkillMenu", null };
					UID? obj4;
					if (__instance == null)
					{
						obj4 = null;
					}
					else
					{
						Character localCharacter2 = ((UIElement)__instance).LocalCharacter;
						obj4 = ((localCharacter2 != null) ? new UID?(localCharacter2.UID) : null);
					}
					obj3[3] = obj4;
					logger2.LogDebug(string.Format("{0}::{1}(): Invoking {2} event for character {3}.", obj3));
					MenuPanelPatches.AfterShowSkillMenu?.Invoke(val2);
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger3 = Logger;
				UID? obj5;
				if (__instance == null)
				{
					obj5 = null;
				}
				else
				{
					Character localCharacter3 = ((UIElement)__instance).LocalCharacter;
					obj5 = ((localCharacter3 != null) ? new UID?(localCharacter3.UID) : null);
				}
				logger3.LogException(string.Format("{0}::{1}(): Exception invoking Show event for character {2}.", "MenuPanelPatches", "ShowPostfix", obj5), ex);
			}
		}

		[HarmonyPatch("OnHide")]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPostfix]
		private static void OnHidePostfix(MenuPanel __instance)
		{
			//IL_013d: 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)
			try
			{
				if ((Object)(object)((UIElement)__instance).LocalCharacter == (Object)null || (Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null || !((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					return;
				}
				IModifLogger logger = Logger;
				object[] obj = new object[4] { "MenuPanelPatches", "OnHidePostfix", "AfterOnHideMenuPanel", null };
				UID? obj2;
				if (__instance == null)
				{
					obj2 = null;
				}
				else
				{
					Character localCharacter = ((UIElement)__instance).LocalCharacter;
					obj2 = ((localCharacter != null) ? new UID?(localCharacter.UID) : null);
				}
				obj[3] = obj2;
				logger.LogDebug(string.Format("{0}::{1}(): Invoking {2} event for character {3}.", obj));
				MenuPanelPatches.AfterOnHideMenuPanel?.Invoke(__instance);
				InventoryMenu val = (InventoryMenu)(object)((__instance is InventoryMenu) ? __instance : null);
				if (val != null)
				{
					MenuPanelPatches.AfterOnHideInventoryMenu?.Invoke(val);
					return;
				}
				SkillMenu val2 = (SkillMenu)(object)((__instance is SkillMenu) ? __instance : null);
				if (val2 != null)
				{
					MenuPanelPatches.AfterOnHideSkillMenu?.Invoke(val2);
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger2 = Logger;
				UID? obj3;
				if (__instance == null)
				{
					obj3 = null;
				}
				else
				{
					Character localCharacter2 = ((UIElement)__instance).LocalCharacter;
					obj3 = ((localCharacter2 != null) ? new UID?(localCharacter2.UID) : null);
				}
				logger2.LogException(string.Format("{0}::{1}(): Exception invoking OnHide event for character {2}.", "MenuPanelPatches", "OnHidePostfix", obj3), ex);
			}
		}
	}
	[HarmonyPatch(typeof(NetworkInstantiateManager))]
	internal static class NetworkInstantiateManagerPatches
	{
		public delegate void AddLocalPlayerDelegate(NetworkInstantiateManager manager, int playerID, CharacterSave save);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event AddLocalPlayerDelegate BeforeAddLocalPlayer;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void AddLocalPlayerPrefix(NetworkInstantiateManager __instance, int _playerID, CharacterSave _save)
		{
			try
			{
				IModifLogger logger = Logger;
				if (logger != null)
				{
					logger.LogTrace("NetworkInstantiateManagerPatches::AddLocalPlayerPrefix called. Invoking BeforeAddLocalPlayer.");
				}
				NetworkInstantiateManagerPatches.BeforeAddLocalPlayer?.Invoke(__instance, _playerID, _save);
			}
			catch (Exception ex)
			{
				IModifLogger logger2 = Logger;
				if (logger2 != null)
				{
					logger2.LogException("NetworkInstantiateManagerPatches::AddLocalPlayerPrefix. Exception invoking BeforeAddLocalPlayer.", ex);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PauseMenu))]
	internal static class PauseMenuPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<PauseMenu> AfterRefreshDisplay;

		[HarmonyPatch("RefreshDisplay")]
		[HarmonyPostfix]
		private static void RefreshDisplayPostfix(PauseMenu __instance)
		{
			try
			{
				Logger.LogTrace("PauseMenu::RefreshDisplayPostfix(): Invoked. Invoking AfterRefreshDisplay.");
				PauseMenuPatches.AfterRefreshDisplay?.Invoke(__instance);
			}
			catch (Exception ex)
			{
				Logger.LogException("PauseMenu::RefreshDisplayPostfix(): Exception invoking AfterRefreshDisplay.", ex);
			}
		}

		[HarmonyPatch("TogglePause")]
		[HarmonyPrefix]
		private static bool TogglePausePrefix(PauseMenu __instance)
		{
			PlayerActionMenus[] array = Object.FindObjectsOfType<PlayerActionMenus>();
			PlayerActionMenus[] array2 = array;
			foreach (PlayerActionMenus val in array2)
			{
				HotbarsContainer componentInChildren = ((Component)val).GetComponentInChildren<HotbarsContainer>();
				if ((Object)(object)componentInChildren != (Object)null && componentInChildren.Controller != null)
				{
					if (componentInChildren.Controller.IsInHotkeyEditMode)
					{
						return false;
					}
					if (componentInChildren.Controller.JustExitedHotkeyMode)
					{
						componentInChildren.Controller.JustExitedHotkeyMode = false;
						return false;
					}
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(QuickSlotPanel))]
	internal class QuickSlotPanelPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<KeyboardQuickSlotPanel> StartInitAfter;

		[HarmonyPatch("StartInit")]
		[HarmonyPostfix]
		private static void StartInitPostfix(QuickSlotPanel __instance)
		{
			try
			{
				if (!((Object)(object)((__instance != null) ? ((UIElement)__instance).LocalCharacter : null) == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					KeyboardQuickSlotPanel val = (KeyboardQuickSlotPanel)(object)((__instance is KeyboardQuickSlotPanel) ? __instance : null);
					if (val != null)
					{
						Logger.LogTrace("QuickSlotPanelPatches::StartInitPostfix(): Invoked. Invoking StartInitAfter(KeyboardQuickSlotPanel).");
						QuickSlotPanelPatches.StartInitAfter?.Invoke(val);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("QuickSlotPanelPatches::StartInitPostfix(): Exception Invoking StartInitAfter(KeyboardQuickSlotPanel).", ex);
			}
		}
	}
	[HarmonyPatch(typeof(RewiredInputs))]
	internal static class RewiredInputsPatches
	{
		public delegate void AfterExportXmlDataDelegate(int playerId);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<RewiredInputs> AfterSaveAllMaps;

		public static event AfterExportXmlDataDelegate AfterExportXmlData;

		[HarmonyPatch("SaveAllMaps")]
		[HarmonyPostfix]
		private static void SaveAllMapsPostfix(RewiredInputs __instance)
		{
			try
			{
				Logger.LogTrace(string.Format("{0}::{1}(): Invoked. Invoking {2} for player {3}.", "RewiredInputsPatches", "SaveAllMapsPostfix", RewiredInputsPatches.AfterSaveAllMaps, __instance.PlayerID));
				RewiredInputsPatches.AfterSaveAllMaps?.Invoke(__instance);
			}
			catch (Exception ex)
			{
				Logger.LogException(string.Format("{0}::{1}(): Exception invoking {2} for player {3}.", "RewiredInputsPatches", "SaveAllMapsPostfix", RewiredInputsPatches.AfterSaveAllMaps, __instance.PlayerID), ex);
			}
		}

		[HarmonyPatch("ExportXmlData")]
		[HarmonyPostfix]
		private static void ExportXmlDataPostfix(RewiredInputs __instance)
		{
			try
			{
				Logger.LogTrace(string.Format("{0}::{1}(): Invoked. Invoking {2} for player {3}.", "RewiredInputsPatches", "ExportXmlDataPostfix", RewiredInputsPatches.AfterExportXmlData, __instance.PlayerID));
				RewiredInputsPatches.AfterExportXmlData?.Invoke(__instance.PlayerID);
			}
			catch (Exception ex)
			{
				Logger.LogException(string.Format("{0}::{1}(): Exception invoking {2} for player {3}.", "RewiredInputsPatches", "ExportXmlDataPostfix", RewiredInputsPatches.AfterExportXmlData, __instance.PlayerID), ex);
			}
		}
	}
	[HarmonyPatch(typeof(Item))]
	internal static class ItemPatches
	{
		public delegate float GetAdjustedReduceDurabilityDelegate(Item item, Character character, float durabilityLost);

		public static Dictionary<int, GetAdjustedReduceDurabilityDelegate> GetAdjustedReduceDurability = new Dictionary<int, GetAdjustedReduceDurabilityDelegate>();

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch("ReduceDurability")]
		[HarmonyPatch(new Type[] { typeof(float) })]
		[HarmonyPrefix]
		private static void ReduceDurabilityPrefix(Item __instance, ref float _durabilityLost)
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!__instance.IsPerishable || (Object)(object)((EffectSynchronizer)__instance).OwnerCharacter == (Object)null || !((EffectSynchronizer)__instance).OwnerCharacter.IsLocalPlayer || ((EffectSynchronizer)__instance).OwnerCharacter.IsAI || !__instance.IsInContainer || CharacterExtensions.IsHostCharacter(((EffectSynchronizer)__instance).OwnerCharacter))
				{
					return;
				}
				Character ownerCharacter = ((EffectSynchronizer)__instance).OwnerCharacter;
				Transform privateField = ReflectionExtensions.GetPrivateField<Item, Transform>(__instance, "m_lastParentTrans");
				ItemContainer privateField2 = ReflectionExtensions.GetPrivateField<Item, ItemContainer>(__instance, "m_lastParentItemContainer");
				if ((Object)(object)privateField == (Object)null || (Object)(object)privateField2 == (Object)null)
				{
					return;
				}
				string uID = ((Item)privateField2).UID;
				ItemContainer stash = ownerCharacter.Stash;
				if (!(uID != ((stash != null) ? ((Item)stash).UID : null)))
				{
					Logger.LogTrace(string.Format("{0}::{1}(): Invoked for character {2}, Item {3}, DurabilityLost {4}. Invoking {5}", "ItemPatches", "ReduceDurabilityPrefix", (ownerCharacter != null) ? new UID?(ownerCharacter.UID) : null, ((Object)__instance).name, _durabilityLost, "GetAdjustedReduceDurability"));
					int playerID = ownerCharacter.OwnerPlayerSys.PlayerID;
					if (GetAdjustedReduceDurability.TryGetValue(playerID, out var value))
					{
						float num = _durabilityLost;
						_durabilityLost = value(__instance, ownerCharacter, _durabilityLost);
						Logger.LogTrace(string.Format("{0}::{1}(): PlayerID {2}: Adjusted durability of item {3} from {4} to {5}.", "ItemPatches", "ReduceDurabilityPrefix", playerID, ((Object)__instance).name, num, _durabilityLost));
					}
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("ItemPatches::ReduceDurabilityPrefix(): Exception calling GetAdjustedReduceDurability Delegate.", ex);
			}
		}
	}
	[HarmonyPatch(typeof(NetworkLevelLoader))]
	internal class NetworkLevelLoaderPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<NetworkLevelLoader> MidLoadLevelAfter;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void MidLoadLevelPostfix(NetworkLevelLoader __instance)
		{
			try
			{
				IModifLogger logger = Logger;
				if (logger != null)
				{
					logger.LogTrace("NetworkLevelLoaderPatches::MidLoadLevelPostfix called. Invoking MidLoadLevelAfter.");
				}
				NetworkLevelLoaderPatches.MidLoadLevelAfter?.Invoke(__instance);
			}
			catch (Exception ex)
			{
				IModifLogger logger2 = Logger;
				if (logger2 != null)
				{
					logger2.LogException("Exception in NetworkLevelLoaderPatches::MidLoadLevelPostfix.", ex);
				}
			}
		}
	}
	[HarmonyPatch(typeof(QuickSlotControllerSwitcher))]
	internal class QuickSlotControllerSwitcherPatches
	{
		public delegate void StartInit(QuickSlotControllerSwitcher controllerSwitcher);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event StartInit StartInitAfter;

		[HarmonyPatch("StartInit")]
		[HarmonyPostfix]
		private static void StartInitPostfix(QuickSlotControllerSwitcher __instance)
		{
			try
			{
				if (!((Object)(object)((__instance != null) ? ((UIElement)__instance).LocalCharacter : null) == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					Logger.LogTrace("QuickSlotControllerSwitcherPatches::StartInitPostfix(): Invoked. Invoking StartInitAfter(KeyboardQuickSlotPanel).");
					QuickSlotControllerSwitcherPatches.StartInitAfter?.Invoke(__instance);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("QuickSlotControllerSwitcherPatches::StartInitPostfix(): Exception Invoking StartInitAfter(KeyboardQuickSlotPanel).", ex);
			}
		}
	}
	[HarmonyPatch(typeof(SkillMenu))]
	internal static class SkillMenuPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<ItemListDisplay> AfterOnSectionSelected;

		[HarmonyPatch("OnSectionSelected")]
		[HarmonyPatch(new Type[] { typeof(int) })]
		[HarmonyPostfix]
		private static void OnSectionSelectedPostfix(ItemListDisplay ___m_skillList, int _sectionID)
		{
			try
			{
				if (!((Object)(object)((___m_skillList != null) ? ((UIElement)___m_skillList).LocalCharacter : null) == (Object)null) && !((Object)(object)((UIElement)___m_skillList).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)___m_skillList).LocalCharacter.IsLocalPlayer)
				{
					Logger.LogTrace("SkillMenuPatches::OnSectionSelectedPostfix(): Invoked. Invoking AfterOnSectionSelected.");
					SkillMenuPatches.AfterOnSectionSelected?.Invoke(___m_skillList);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("SkillMenuPatches::OnSectionSelectedPostfix(): Exception invoking AfterOnSectionSelected.", ex);
			}
		}
	}
	[HarmonyPatch(typeof(SplitPlayer))]
	internal static class SplitPlayerPatches
	{
		public delegate void SetCharacter(SplitPlayer splitPlayer, Character character);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event SetCharacter SetCharacterAfter;

		[HarmonyPatch("SetCharacter")]
		[HarmonyPatch(new Type[] { typeof(Character) })]
		[HarmonyPostfix]
		private static void SetCharacterPostfix(SplitPlayer __instance, Character _character)
		{
			try
			{
				if (!((Object)(object)((__instance != null) ? __instance.AssignedCharacter : null) == (Object)null) && !((Object)(object)__instance.AssignedCharacter.OwnerPlayerSys == (Object)null) && __instance.AssignedCharacter.IsLocalPlayer)
				{
					Logger.LogTrace("SplitPlayerPatches::SetCharacterPostfix(): Invoked. Invoking SetCharacterAfter(SplitPlayer, Character).");
					SplitPlayerPatches.SetCharacterAfter?.Invoke(__instance, _character);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("SplitPlayerPatches::SetCharacterPostfix(): Exception Invoking SetCharacterAfter(SplitPlayer, Character).", ex);
			}
		}
	}
	[HarmonyPatch(typeof(SplitScreenManager))]
	internal static class SplitScreenManagerPatches
	{
		public delegate void RemoveLocalPlayer(SplitScreenManager splitScreenManager, SplitPlayer player, string playerUID);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event RemoveLocalPlayer RemoveLocalPlayerAfter;

		[HarmonyPatch("RemoveLocalPlayer")]
		[HarmonyPatch(new Type[]
		{
			typeof(SplitPlayer),
			typeof(string)
		})]
		[HarmonyPostfix]
		private static void RemoveLocalPlayerPostfix(SplitScreenManager __instance, SplitPlayer _player, string _playerUID)
		{
			try
			{
				if (!((Object)(object)((_player != null) ? _player.AssignedCharacter : null) == (Object)null) && !((Object)(object)_player.AssignedCharacter.OwnerPlayerSys == (Object)null) && _player.AssignedCharacter.IsLocalPlayer && ((Behaviour)__instance).enabled)
				{
					Logger.LogTrace("SplitScreenManagerPatches::RemoveLocalPlayerPostfix(): Invoked. Invoking RemoveLocalPlayerAfter(SplitScreenManager, SplitPlayer, string).");
					SplitScreenManagerPatches.RemoveLocalPlayerAfter?.Invoke(__instance, _player, _playerUID);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("SplitScreenManagerPatches::RemoveLocalPlayerPostfix(): Exception Invoking RemoveLocalPlayerAfter(SplitScreenManager, SplitPlayer, string).", ex);
			}
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Patches.Sandbox
{
	[HarmonyPatch(typeof(CharacterEquipment))]
	internal static class CharacterEquipmentPatches
	{
		public delegate void EquipDelegate(Character character, Equipment equipment);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event EquipDelegate AfterEquip;

		[HarmonyPatch("EquipItem")]
		[HarmonyPatch(new Type[]
		{
			typeof(Equipment),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void EquipPostfix(CharacterEquipment __instance, Character ___m_character, Equipment _itemToEquip, bool _playAnim)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (___m_character.IsLocalPlayer)
				{
					Logger.LogTrace(string.Format("{0}::{1}(): Invoked. Equipment item '{2}' equiped to slot '{3}' for character {4}. Invoking {5}.", "CharacterEquipmentPatches", "EquipPostfix", ((Object)_itemToEquip).name, ((Item)_itemToEquip).CurrentEquipmentSlot?.SlotType, (___m_character != null) ? ((Object)___m_character).name : null, "AfterEquip"));
					CharacterEquipmentPatches.AfterEquip?.Invoke(___m_character, _itemToEquip);
				}
			}
			catch (Exception ex)
			{
				Logger.LogException("CharacterEquipmentPatches::EquipPostfix(): Exception invoking AfterEquip for character " + ((___m_character != null) ? ((Object)___m_character).name : null) + ".", ex);
			}
		}
	}
	[HarmonyPatch(typeof(Character))]
	internal static class CharacterPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<Character> AfterProcessInit;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void ProcessInitPostFix(Character __instance)
		{
			try
			{
				Logger.LogDebug("CharacterPatches::ProcessInitPostFix(): Invoking AfterProcessInit.");
				CharacterPatches.AfterProcessInit?.Invoke(__instance);
			}
			catch (Exception ex)
			{
				Logger.LogException("CharacterPatches::ProcessInitPostFix(): Exception invoking AfterProcessInit.", ex);
			}
		}
	}
	[HarmonyPatch(typeof(CharacterSave))]
	internal static class CharacterSavePatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<Character> BeforeApplyLoadedSaveToCharPrefix;

		[HarmonyPatch("ApplyLoadedSaveToChar")]
		[HarmonyPatch(new Type[] { typeof(Character) })]
		[HarmonyPostfix]
		private static void ApplyLoadedSaveToCharPrefix(Character _char)
		{
			try
			{
				Logger.LogTrace("CharacterSavePatches::ApplyLoadedSaveToCharPrefix(): Invoked. Invoking BeforeApplyLoadedSaveToCharPrefix for character " + ((_char != null) ? ((Object)_char).name : null) + ".");
				CharacterSavePatches.BeforeApplyLoadedSaveToCharPrefix?.Invoke(_char);
			}
			catch (Exception ex)
			{
				Logger.LogException("CharacterSavePatches::ApplyLoadedSaveToCharPrefix(): Exception Invoking BeforeApplyLoadedSaveToCharPrefix for character " + ((_char != null) ? ((Object)_char).name : null) + ".", ex);
			}
		}
	}
	[HarmonyPatch(typeof(EquipmentMenu))]
	internal static class InventoryMenuPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<InventoryMenu> AfterShow;

		public static event Action<InventoryMenu> AfterOnHide;

		[HarmonyPatch("Show")]
		[HarmonyPostfix]
		private static void ShowPostfix(InventoryMenu __instance)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)((UIElement)__instance).LocalCharacter == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					IModifLogger logger = Logger;
					object[] obj = new object[4] { "InventoryMenuPatches", "ShowPostfix", "AfterShow", null };
					Character localCharacter = ((UIElement)__instance).LocalCharacter;
					obj[3] = ((localCharacter != null) ? new UID?(localCharacter.UID) : null);
					logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for character {3}.", obj));
					InventoryMenuPatches.AfterShow?.Invoke(__instance);
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger2 = Logger;
				object[] obj2 = new object[4] { "InventoryMenuPatches", "ShowPostfix", "AfterShow", null };
				UID? obj3;
				if (__instance == null)
				{
					obj3 = null;
				}
				else
				{
					Character localCharacter2 = ((UIElement)__instance).LocalCharacter;
					obj3 = ((localCharacter2 != null) ? new UID?(localCharacter2.UID) : null);
				}
				obj2[3] = obj3;
				logger2.LogException(string.Format("{0}::{1}(): Exception invoking {2} for character {3}.", obj2), ex);
			}
		}

		[HarmonyPatch("OnHide")]
		[HarmonyPostfix]
		private static void OnHidePostfix(InventoryMenu __instance)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)((UIElement)__instance).LocalCharacter == (Object)null) && !((Object)(object)((UIElement)__instance).LocalCharacter.OwnerPlayerSys == (Object)null) && ((UIElement)__instance).LocalCharacter.IsLocalPlayer)
				{
					IModifLogger logger = Logger;
					object[] obj = new object[4] { "InventoryMenuPatches", "OnHidePostfix", "AfterOnHide", null };
					Character localCharacter = ((UIElement)__instance).LocalCharacter;
					obj[3] = ((localCharacter != null) ? new UID?(localCharacter.UID) : null);
					logger.LogTrace(string.Format("{0}::{1}(): Invoking {2} for character {3}.", obj));
					InventoryMenuPatches.AfterOnHide?.Invoke(__instance);
				}
			}
			catch (Exception ex)
			{
				IModifLogger logger2 = Logger;
				object[] obj2 = new object[4] { "InventoryMenuPatches", "OnHidePostfix", "AfterOnHide", null };
				UID? obj3;
				if (__instance == null)
				{
					obj3 = null;
				}
				else
				{
					Character localCharacter2 = ((UIElement)__instance).LocalCharacter;
					obj3 = ((localCharacter2 != null) ? new UID?(localCharacter2.UID) : null);
				}
				obj2[3] = obj3;
				logger2.LogException(string.Format("{0}::{1}(): Exception invoking {2} for character {3}.", obj2), ex);
			}
		}
	}
	[HarmonyPatch(typeof(ItemDisplayDrop))]
	internal static class ItemDisplayDropPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Action<ItemDisplayDrop, PointerEventData, ItemDisplay> AfterGetDraggedElement;

		[HarmonyPatch("GetDraggedElement")]
		[HarmonyPatch(new Type[] { typeof(PointerEventData) })]
		[HarmonyPostfix]
		private static void GetDraggedElementPostfix(ItemDisplayDrop __instance, PointerEventData _data, ItemDisplay __result)
		{
			try
			{
				IModifLogger logger = Logger;
				string[] obj = new string[5]
				{
					"ItemDisplayDropPatches::GetDraggedElementPostfix(): Invoked. Invoking AfterGetDraggedElement. ItemDisplay: ",
					(__result != null) ? ((Object)__result).name : null,
					", PointerEventData.pointerDrag: ",
					null,
					null
				};
				GameObject pointerDrag = _data.pointerDrag;
				obj[3] = ((pointerDrag != null) ? ((Object)pointerDrag).name : null);
				obj[4] = ".";
				logger.LogTrace(string.Concat(obj));
				ItemDisplayDropPatches.AfterGetDraggedElement?.Invoke(__instance, _data, __result);
			}
			catch (Exception ex)
			{
				Logger.LogException("ItemDisplayDropPatches::GetDraggedElementPostfix(): Exception invoking AfterGetDraggedElement.", ex);
			}
		}
	}
	public class MapHelperPatches
	{
	}
	[HarmonyPatch]
	public class MapHelperConstructorPatch
	{
		public delegate void NewMapHelperDelegate(MapHelper mapHelper, Player player, ControllerHelper parent);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event NewMapHelperDelegate OnNewMapHelper;

		public static MethodBase TargetMethod()
		{
			return UnityEngineExtensions.FirstOrDefault<ConstructorInfo>((IList<ConstructorInfo>)typeof(MapHelper).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic));
		}

		public static void Postfix(MapHelper __instance, Player player, ControllerHelper parent)
		{
			try
			{
				Logger.LogTrace(string.Format("{0}::{1}(): Invoked for player {2}.", "MapHelperConstructorPatch", "Postfix", (player != null) ? new int?(player.id) : null));
				MapHelperConstructorPatch.OnNewMapHelper?.Invoke(__instance, player, parent);
			}
			catch (Exception ex)
			{
				Logger.LogException("MapHelperConstructorPatch::Postfix(): Exception", ex);
			}
		}
	}
	[HarmonyPatch]
	public class PlayerConstructorPatch
	{
		public delegate void NewPlayerDelegate(Player player);

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event NewPlayerDelegate OnNewPlayer;

		public static MethodBase TargetMethod()
		{
			return UnityEngineExtensions.FirstOrDefault<ConstructorInfo>((IList<ConstructorInfo>)typeof(Player).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic));
		}

		public static void Postfix(Player __instance)
		{
			try
			{
				Logger.LogTrace(string.Format("{0}::{1}(): Invoked for player {2}.", "PlayerConstructorPatch", "Postfix", (__instance != null) ? new int?(__instance.id) : null));
				PlayerConstructorPatch.OnNewPlayer?.Invoke(__instance);
			}
			catch (Exception ex)
			{
				Logger.LogException("PlayerConstructorPatch::Postfix(): Exception", ex);
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal static class MenuManagerPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public static event Func<bool> GetIsApplicationFocused;

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		private static void IsApplicationFocusedPostfix(MenuManager __instance, ref bool __result)
		{
			try
			{
				__result = __result || (MenuManagerPatches.GetIsApplicationFocused?.Invoke() ?? false);
			}
			catch (Exception ex)
			{
				Logger.LogException("MenuManagerPatches::IsApplicationFocusedPostfix(): Exception Invoking GetIsApplicationFocused(MenuManagerPatches).", ex);
			}
		}
	}
	[HarmonyPatch(typeof(UserData))]
	public class UserDataPatches
	{
		private static bool outputList;

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void GetActions_CopyPostfix(UserData __instance, List<InputAction> __result)
		{
			try
			{
				Logger.LogTrace("UserDataPatches::GetActions_CopyPostfix(): Invoked.");
				if (outputList)
				{
					return;
				}
				string text = "UserDataPatches::GetActions_CopyPostfix(): Output of result List<InputAction>:";
				foreach (InputAction item in __result)
				{
					text = text + "\n\t name: " + item.name + "\n\t\t descriptiveName: " + item.descriptiveName + $"\n\t\t categoryId: {item.categoryId}" + $"\n\t\t id: {item.id}";
				}
				Logger.LogDebug(text);
				outputList = true;
			}
			catch (Exception ex)
			{
				Logger.LogException("UserDataPatches::GetActions_CopyPostfix(): Exception", ex);
			}
		}
	}
	[HarmonyPatch(typeof(UserDataStore_PlayerPrefs))]
	public class UserDataStore_PlayerPrefsPatches
	{
		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPatch(new Type[] { })]
		[HarmonyPostfix]
		public static void OnInitializePostfix(UserDataStore_PlayerPrefsPatches __instance)
		{
			try
			{
				Logger.LogTrace("UserDataStore_PlayerPrefsPatches::OnInitializePostfix(): Invoked. Adding new ActionCategory and Actions");
			}
			catch (Exception ex)
			{
				Logger.LogException("UserDataStore_PlayerPrefsPatches::OnInitializePostfix(): Exception", ex);
			}
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Monobehaviours
{
	internal class ActionItemViewDropper : MonoBehaviour, IDropHandler, IEventSystemHandler, IPointerEnterHandler, IPointerExitHandler
	{
		private ItemDisplay _draggedItemDisplay;

		private ActionItemView _actionSlot;

		[SerializeField]
		private int _playerID;

		private Func<IModifLogger> _getLogger;

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		private void Awake()
		{
			_actionSlot = ((Component)this).GetComponentInParent<ActionItemView>();
		}

		private void Start()
		{
		}

		public void SetPlayerID(int playerID)
		{
			_playerID = playerID;
		}

		public void SetLogger(Func<IModifLogger> getLogger)
		{
			_getLogger = getLogger;
		}

		public void OnDrop(PointerEventData eventData)
		{
			_draggedItemDisplay = GetDraggedElement(eventData);
			IModifLogger logger = Logger;
			string[] obj = new string[6]
			{
				"ActionSlotDropper:OnDrop: ActionItemView ",
				((Object)_actionSlot).name,
				", ItemDisplay: ",
				null,
				null,
				null
			};
			ItemDisplay draggedItemDisplay = _draggedItemDisplay;
			obj[3] = ((draggedItemDisplay != null) ? ((Object)draggedItemDisplay).name : null);
			obj[4] = ", RefItem: ";
			ItemDisplay draggedItemDisplay2 = _draggedItemDisplay;
			object obj2;
			if (draggedItemDisplay2 == null)
			{
				obj2 = null;
			}
			else
			{
				Item refItem = draggedItemDisplay2.RefItem;
				obj2 = ((refItem != null) ? ((Object)refItem).name : null);
			}
			obj[5] = (string)obj2;
			logger.LogDebug(string.Concat(obj));
			ItemDisplay draggedItemDisplay3 = _draggedItemDisplay;
			if ((Object)(object)((draggedItemDisplay3 != null) ? draggedItemDisplay3.RefItem : null) != (Object)null && _draggedItemDisplay.RefItem.IsQuickSlotable)
			{
				ISlotAction slotAction = GetSlotDataService().GetSlotAction(_draggedItemDisplay.RefItem);
				IModifLogger logger2 = Logger;
				string name = ((Object)_actionSlot).name;
				ItemDisplay draggedItemDisplay4 = _draggedItemDisplay;
				object obj3;
				if (draggedItemDisplay4 == null)
				{
					obj3 = null;
				}
				else
				{
					Item refItem2 = draggedItemDisplay4.RefItem;
					obj3 = ((refItem2 != null) ? ((Object)refItem2).name : null);
				}
				logger2.LogDebug("ActionSlotDropper:OnDrop: ActionItemView " + name + ". Got SlotAction for RefItem " + (string?)obj3);
				_actionSlot.SetViewItem(slotAction);
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_draggedItemDisplay = GetDraggedElement(eventData);
			IModifLogger logger = Logger;
			string name = ((Object)_actionSlot).name;
			ItemDisplay draggedItemDisplay = _draggedItemDisplay;
			logger.LogDebug("ActionSlotDropper:OnPointerEnter: ActionItemView " + name + ", ItemDisplay: " + ((draggedItemDisplay != null) ? ((Object)draggedItemDisplay).name : null));
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			Logger.LogDebug("ActionSlotDropper:OnPointerExit: ActionItemView " + ((Object)_actionSlot).name);
			_draggedItemDisplay = null;
		}

		private ItemDisplay GetDraggedElement(PointerEventData eventData)
		{
			GameObject pointerDrag = eventData.pointerDrag;
			IModifLogger logger = Logger;
			string name = ((Object)_actionSlot).name;
			GameObject pointerDrag2 = eventData.pointerDrag;
			logger.LogDebug("ActionSlotDropper:GetDraggedElement: ActionItemView " + name + ". pointerDrag: " + ((pointerDrag2 != null) ? ((Object)pointerDrag2).name : null));
			if ((Object)(object)pointerDrag == (Object)null)
			{
				return null;
			}
			return pointerDrag.GetComponent<ItemDisplay>();
		}

		private SlotDataService GetSlotDataService()
		{
			return Psp.Instance.GetServicesProvider(_playerID).GetService<SlotDataService>();
		}
	}
	internal class ActionSlotDropper : MonoBehaviour, IDropHandler, IEventSystemHandler, IPointerEnterHandler, IPointerExitHandler
	{
		private ItemDisplay _draggedItemDisplay;

		private ActionSlot _actionSlot;

		private Func<IModifLogger> _getLogger;

		private IModifLogger Logger => (IModifLogger)(((object)_getLogger?.Invoke()) ?? ((object)NullLogger.Instance));

		private void Awake()
		{
			_actionSlot = ((Component)this).GetComponentInParent<ActionSlot>();
			Logger.LogDebug(string.Format("{0}:{1}: ActionSlot SlotId: {2}", "ActionSlotDropper", "Awake", _actionSlot.SlotId));
		}

		private void Start()
		{
			IModifLogger logger = Logger;
			ActionSlot actionSlot = _actionSlot;
			logger.LogDebug(string.Format("{0}:{1}: ActionSlot SlotId: {2}", "ActionSlotDropper", "Start", (actionSlot != null) ? new int?(actionSlot.SlotId) : null));
		}

		public void SetLogger(Func<IModifLogger> getLogger)
		{
			_getLogger = getLogger;
		}

		public void OnDrop(PointerEventData eventData)
		{
			_draggedItemDisplay = GetDraggedElement(eventData);
			IModifLogger logger = Logger;
			object[] obj = new object[5] { "ActionSlotDropper", "OnDrop", _actionSlot.SlotId, null, null };
			ItemDisplay draggedItemDisplay = _draggedItemDisplay;
			obj[3] = ((draggedItemDisplay != null) ? ((Object)draggedItemDisplay).name : null);
			ItemDisplay draggedItemDisplay2 = _draggedItemDisplay;
			object obj2;
			if (draggedItemDisplay2 == null)
			{
				obj2 = null;
			}
			else
			{
				Item refItem = draggedItemDisplay2.RefItem;
				obj2 = ((refItem != null) ? ((Object)refItem).name : null);
			}
			obj[4] = obj2;
			logger.LogDebug(string.Format("{0}:{1}: ActionSlot SlotId: {2}, ItemDisplay: {3}, RefItem: {4}", obj));
			ItemDisplay draggedItemDisplay3 = _draggedItemDisplay;
			if ((Object)(object)((draggedItemDisplay3 != null) ? draggedItemDisplay3.RefItem : null) != (Object)null && _draggedItemDisplay.RefItem.IsQuickSlotable)
			{
				ISlotAction slotAction = GetSlotDataService().GetSlotAction(_draggedItemDisplay.RefItem);
				IModifLogger logger2 = Logger;
				object[] obj3 = new object[4] { "ActionSlotDropper", "OnDrop", _actionSlot.SlotId, null };
				ItemDisplay draggedItemDisplay4 = _draggedItemDisplay;
				object obj4;
				if (draggedItemDisplay4 == null)
				{
					obj4 = null;
				}
				else
				{
					Item refItem2 = draggedItemDisplay4.RefItem;
					obj4 = ((refItem2 != null) ? ((Object)refItem2).name : null);
				}
				obj3[3] = obj4;
				logger2.LogDebug(string.Format("{0}:{1}: ActionSlot SlotId: {2}. Got SlotAction for RefItem {3}", obj3));
				_actionSlot.Controller.AssignSlotAction(slotAction, false);
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_draggedItemDisplay = GetDraggedElement(eventData);
			IModifLogger logger = Logger;
			object[] obj = new object[4] { "ActionSlotDropper", "OnPointerEnter", _actionSlot.SlotId, null };
			ItemDisplay draggedItemDisplay = _draggedItemDisplay;
			obj[3] = ((draggedItemDisplay != null) ? ((Object)draggedItemDisplay).name : null);
			logger.LogDebug(string.Format("{0}:{1}: ActionSlot SlotId: {2}, ItemDisplay: {3}", obj));
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			Logger.LogDebug(string.Format("{0}:{1}: ActionSlot SlotId: {2}", "ActionSlotDropper", "OnPointerExit", _actionSlot.SlotId));
			_draggedItemDisplay = null;
		}

		private ItemDisplay GetDraggedElement(PointerEventData eventData)
		{
			GameObject pointerDrag = eventData.pointerDrag;
			IModifLogger logger = Logger;
			object[] obj = new object[4] { "ActionSlotDropper", "GetDraggedElement", _actionSlot.SlotId, null };
			GameObject pointerDrag2 = eventData.pointerDrag;
			obj[3] = ((pointerDrag2 != null) ? ((Object)pointerDrag2).name : null);
			logger.LogDebug(string.Format("{0}:{1}: ActionSlot SlotId: {2}. pointerDrag: {3}", obj));
			if ((Object)(object)pointerDrag == (Object)null)
			{
				return null;
			}
			return pointerDrag.GetComponent<ItemDisplay>();
		}

		private SlotDataService GetSlotDataService()
		{
			int playerID = _actionSlot.HotbarsContainer.PlayerActionMenus.PlayerID;
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(playerID);
			return servicesProvider.GetService<SlotDataService>();
		}
	}
	public class SplitScreenScaler : MonoBehaviour
	{
		public CharacterUI CharacterUI { get; set; }

		private void Awake()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			SplitScreenManager instance = SplitScreenManager.Instance;
			instance.onSplitScreenRefresh = (UnityAction)Delegate.Combine((Delegate?)(object)instance.onSplitScreenRefresh, (Delegate?)new UnityAction(Scale));
		}

		private void Start()
		{
			Scale();
			((MonoBehaviour)this).InvokeRepeating("Scale", 1f, 1f);
		}

		private void OnDisable()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			((MonoBehaviour)this).CancelInvoke("Scale");
			SplitScreenManager instance = SplitScreenManager.Instance;
			instance.onSplitScreenRefresh = (UnityAction)Delegate.Remove((Delegate?)(object)instance.onSplitScreenRefresh, (Delegate?)new UnityAction(Scale));
		}

		private void Scale()
		{
			//IL_0033: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)CharacterUI == (Object)null || !((Component)this).gameObject.activeSelf)
			{
				return;
			}
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			Rect rect = component.rect;
			Transform transform = ((Component)CharacterUI).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			Rect rect2 = val.rect;
			if (((Rect)(ref rect2)).width >= ((Rect)(ref rect)).width && ((Rect)(ref rect2)).height >= ((Rect)(ref rect)).height)
			{
				if (((Transform)component).localScale != Vector3.one)
				{
					((Transform)component).localScale = Vector3.one;
				}
			}
			else
			{
				float num = ((Rect)(ref rect2)).width / ((Rect)(ref rect)).width;
				float num2 = ((Rect)(ref rect2)).height / ((Rect)(ref rect)).height;
				float num3 = ((num <= num2) ? num : num2) - 0.05f;
				((Transform)component).localScale = new Vector3(num3, num3);
			}
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Models
{
	internal class ActionConfig : IActionSlotConfig
	{
		public string HotkeyText { get; set; }

		public bool ShowCooldownTime { get; set; }

		public bool PreciseCooldownTime { get; set; }

		public bool ShowZeroStackAmount { get; set; }

		public EmptySlotOptions EmptySlotOption { get; set; }

		public string RewiredActionName { get; set; }

		public int RewiredActionId { get; set; }

		public bool IsDisabled { get; set; }

		public bool IsDynamic { get; set; }
	}
	internal class ActionsDisplayTab : IActionsDisplayTab
	{
		public string DisplayName { get; internal set; }

		public int TabOrder { get; internal set; }

		public Func<IEnumerable<ISlotAction>> GetSlotActionsQuery { get; internal set; }

		public IEnumerable<ISlotAction> GetSlotActions()
		{
			return GetSlotActionsQuery();
		}
	}
	internal class ArmorSetSkill : EquipmentSetSkill
	{
		private ArmorSet _armorSet
		{
			get
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Expected O, but got Unknown
				if (TryGetEquipmentSet(out var equipmentSet))
				{
					return (ArmorSet)equipmentSet;
				}
				return null;
			}
		}

		protected override void OnAwake()
		{
			base.OnAwake();
		}

		protected override bool OwnerHasAllRequiredItems(bool _tryingToActivate)
		{
			if (_armorSet == null)
			{
				return false;
			}
			if (TryGetEquipService(out var _) && TryGetEquipmentSet(out var _))
			{
				return false;
			}
			return false;
		}

		protected override void QuickSlotUse()
		{
			if (_armorSet != null && !TryGetEquipService(out var _))
			{
			}
		}

		protected override bool TryGetEquipmentSet(out IEquipmentSet equipmentSet)
		{
			equipmentSet = null;
			if ((Object)(object)((Item)this).m_ownerCharacter == (Object)null)
			{
				return false;
			}
			UnityServicesProvider val = default(UnityServicesProvider);
			IEquipmentSetService<ArmorSet> val2 = default(IEquipmentSetService<ArmorSet>);
			if (Psp.Instance.TryGetServicesProvider(((Item)this).m_ownerCharacter.OwnerPlayerSys.PlayerID, ref val) && val.TryGetService<IEquipmentSetService<ArmorSet>>(ref val2))
			{
				equipmentSet = (IEquipmentSet)(object)val2.GetEquipmentSet(_setName);
				return equipmentSet != null;
			}
			return false;
		}
	}
	internal class ChainedSlotAction : SlotActionBase
	{
		public SortedList<int, Item> ActionChain { get; internal set; }

		public ChainedSlotAction(Skill chainSkill, SortedList<int, Item> actionChain, Player player, Character character, SlotDataService slotData, bool combatModeEnabled, Func<IModifLogger> getLogger)
			: base((Item)(object)chainSkill, player, character, slotData, combatModeEnabled, getLogger)
		{
			ActionChain = actionChain;
		}

		public override void ActivateTarget()
		{
			throw new NotImplementedException();
		}

		public override bool GetEnabled()
		{
			throw new NotImplementedException();
		}

		protected override bool GetIsLocked()
		{
			throw new NotImplementedException();
		}
	}
	public abstract class EquipmentSetSkill : Skill
	{
		[SerializeField]
		protected string _setName;

		[SerializeField]
		protected int _setID;

		[SerializeField]
		protected EquipSlots _iconSlot;

		private static IModifLogger Logger => LoggerFactory.GetLogger("ModifAmorphic.Outward.ActionUI");

		public ItemDisplay ItemDisplay => ((Item)this).m_refItemDisplay;

		protected override void OnAwake()
		{
			ReflectionExtensions.SetPrivateField<Skill, ActivationCondition[]>((Skill)(object)this, "m_additionalConditions", (ActivationCondition[])(object)new ActivationCondition[0]);
			((Item)this).HasDynamicQuickSlotIcon = true;
			Logger.LogDebug("EquipmentSetSkill::OnAwake: " + ((Item)this).m_name);
			((Item)this).OnAwake();
			SetIcon();
		}

		protected override void ChangeOwner(Character _newOwner)
		{
			((Item)this).ChangeOwner(_newOwner);
			if (!((Object)(object)_newOwner == (Object)null))
			{
				SetIcon();
			}
		}

		public void SetEquipmentSet(IEquipmentSet set)
		{
			//IL_0033: 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)
			_setName = set.Name;
			((Item)this).m_name = set.Name;
			_setID = set.SetID;
			((Item)this).ItemID = set.SetID;
			_iconSlot = set.IconSlot;
			base.RequiredItems = set.ToItemsRequired().ToArray();
			SetIcon();
		}

		public void SetParent(Transform parentTransform)
		{
			if ((Object)(object)((Component)this).transform.parent != (Object)(object)parentTransform)
			{
				((Component)this).transform.SetParent(parentTransform);
				((Item)this).ForceUpdateParentChange();
			}
		}

		private void SetIcon()
		{
			Item iconOwnerPrefab = GetIconOwnerPrefab();
			((Item)this).m_itemIcon = ((iconOwnerPrefab != null) ? iconOwnerPrefab.ItemIcon : null) ?? ActionMenuResources.Instance.SpriteResources["EmptySlotIcon"];
			((Item)this).ItemIconPath = ((iconOwnerPrefab != null) ? iconOwnerPrefab.ItemIconPath : null);
			ItemDisplay refItemDisplay = ((Item)this).m_refItemDisplay;
			if (refItemDisplay != null)
			{
				refItemDisplay.RefreshIcon();
			}
		}

		protected override bool OwnerHasAllRequiredItems(bool _tryingToActivate)
		{
			if (TryGetEquipService(out var _) && TryGetEquipmentSet(out var _))
			{
				return false;
			}
			return false;
		}

		protected Item GetIconOwnerPrefab()
		{
			if (!TryGetEquipmentSet(out var equipmentSet))
			{
				return null;
			}
			EquipSlot iconEquipSlot = equipmentSet.GetIconEquipSlot();
			if (iconEquipSlot == null)
			{
				return null;
			}
			return ResourcesPrefabManager.Instance.GetItemPrefab(iconEquipSlot.ItemID);
		}

		protected bool TryGetEquipService(out object equipService)
		{
			equipService = null;
			return false;
		}

		protected abstract bool TryGetEquipmentSet(out IEquipmentSet equipmentSet);
	}
	internal class EquipmentSlotAction : SlotActionBase
	{
		private Equipment equipment;

		private bool isEquipBroken;

		public Equipment ActionEquipment => equipment;

		public EquipmentSlotAction(Equipment equipment, Player player, Character character, SlotDataService slotData, bool combatModeEnabled, Func<IModifLogger> getLogger)
			: base((Item)(object)equipment, player, character, slotData, combatModeEnabled, getLogger)
		{
			this.equipment = equipment;
			if (!((Item)equipment).IsIndestructible)
			{
				_activeBars.Add((BarPositions)1, (IBarProgress)(object)new DurabilityActionSlotTracker(this, (BarPositions)1));
			}
		}

		public override bool GetEnabled()
		{
			if (base.IsCombatModeEnabled && character.InCombat && (hotbarIndex != 0 || slotIndex > 8))
			{
				return false;
			}
			if (inventory.OwnsItem(itemUid))
			{
				if (!actionItem.IsEquipped)
				{
					return true;
				}
				return false;
			}
			if (slotData.TryFindOwnedItem(base.ActionId, base.ActionUid, out var item))
			{
				Equipment val = (Equipment)(object)((item is Equipment) ? item : null);
				if (val != null)
				{
					actionItem = (Item)(object)val;
					itemUid = item.UID;
					actionItem.SetQuickSlot(0);
					return true;
				}
			}
			return false;
		}

		public override void ActivateTarget()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)actionItem == (Object)null))
			{
				if (inventory.OwnsItem(actionItem.UID))
				{
					actionItem.TryQuickSlotUse();
					return;
				}
				character.CharacterUI.ShowInfoNotification(LocalizationManager.Instance.GetLoc("Notification_Quickslot_NoItemInventory", new string[1] { Global.SetTextColor(actionItem.Name, Global.HIGHLIGHT) }));
			}
		}

		protected override List<ActionSlotIcon> GetActionIcons(bool isLocked)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			List<ActionSlotIcon> actionIcons = base.GetActionIcons(isLocked);
			if (isEquipBroken)
			{
				base.Logger.LogDebug($"SlotIndex: {slotIndex}. Adding CrackedIcon to Sprites for slot.");
				actionIcons.Add(new ActionSlotIcon
				{
					Name = "CrackedIcon",
					Icon = ActionMenuResources.Instance.SpriteResources["CrackedIcon"],
					IsTopSprite = true
				});
			}
			return actionIcons;
		}

		internal void DurabilityChanged(float durability)
		{
			base.Logger.LogDebug($"SlotIndex: {slotIndex}. Durability changed to {durability}. isEquipBroken is {isEquipBroken}.");
			if (durability > 0f && isEquipBroken)
			{
				isEquipBroken = false;
				RaiseOnIconsChanged();
			}
			else if (Mathf.Approximately(durability, 0f) && !isEquipBroken)
			{
				isEquipBroken = true;
				RaiseOnIconsChanged();
			}
			base.Logger.LogDebug($"SlotIndex: {slotIndex}. Durability changed done. isEquipBroken is {isEquipBroken}.");
		}

		protected override bool GetIsLocked()
		{
			return ((Item)equipment).IsEquipped || !inventory.OwnsItem(((Item)equipment).ItemID);
		}
	}
	public class EquipSkillPreview : ISlotAction, IDisposable
	{
		private EquipmentSlot _equipmentSlot;

		private bool disposedValue;

		public string DisplayName { get; internal set; }

		public int ActionId => -1;

		public string ActionUid => null;

		public ICooldown Cooldown { get; internal set; }

		public IStackable Stack => null;

		public Dictionary<BarPositions, IBarProgress> ActiveBars => null;

		public bool HasDynamicIcon => true;

		public ActionSlotIcon[] ActionIcons { get; internal set; }

		public bool CheckOnUpdate => true;

		public Action TargetAction => null;

		public event Action OnActionRequested;

		public event Action OnEditRequested;

		public event Action<ActionSlotIcon[]> OnIconsChanged;

		public EquipSkillPreview(EquipmentSlot equipmentSlot)
		{
			_equipmentSlot = equipmentSlot;
			EquipmentPatches.AfterOnEquip += EquipmentChanged;
			EquipmentPatches.AfterOnUnequip += EquipmentChanged;
			UpdateIcons();
		}

		private void EquipmentChanged(Character character, Equipment equipment)
		{
			//IL_0007: 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)
			if (((Item)equipment).CurrentEquipmentSlot.SlotType == _equipmentSlot.SlotType)
			{
				UpdateIcons();
			}
		}

		private void UpdateIcons()
		{
			//IL_000a: 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)
			//IL_0063: 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_00a2: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			ActionSlotIcon[] array = new ActionSlotIcon[2];
			ActionSlotIcon val = new ActionSlotIcon();
			Equipment equippedItem = _equipmentSlot.EquippedItem;
			object obj;
			if (equippedItem == null)
			{
				obj = null;
			}
			else
			{
				Sprite itemIcon = ((Item)equippedItem).ItemIcon;
				obj = ((itemIcon != null) ? ((Object)itemIcon).name : null);
			}
			if (obj == null)
			{
				Equipment equippedItem2 = _equipmentSlot.EquippedItem;
				obj = ((equippedItem2 != null) ? ((Object)equippedItem2).name : null) ?? _equipmentSlot.SlotName;
			}
			val.Name = (string)obj;
			Equipment equippedItem3 = _equipmentSlot.EquippedItem;
			val.Icon = ((equippedItem3 != null) ? ((Item)equippedItem3).ItemIcon : null) ?? ActionMenuResources.Instance.SpriteResources["EmptySlotIcon"];
			val.IsTopSprite = false;
			array[0] = val;
			array[1] = new ActionSlotIcon
			{
				Name = "EquipmentSetIcon",
				Icon = ActionMenuResources.Instance.SpriteResources["EquipmentSetIcon"],
				IsTopSprite = false
			};
			ActionIcons = (ActionSlotIcon[])(object)array;
			this.OnIconsChanged?.Invoke(ActionIcons);
		}

		public ActionSlotIcon[] GetDynamicIcons()
		{
			return ActionIcons;
		}

		public bool GetEnabled()
		{
			return true;
		}

		public bool GetIsActionRequested()
		{
			return false;
		}

		public bool GetIsEditRequested()
		{
			return false;
		}

		public void SlotActionAssigned(ActionSlot assignedSlot)
		{
			throw new NotImplementedException();
		}

		public void SlotActionUnassigned()
		{
			throw new NotImplementedException();
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!disposedValue)
			{
				if (disposing)
				{
					EquipmentPatches.AfterOnEquip -= EquipmentChanged;
					EquipmentPatches.AfterOnUnequip -= EquipmentChanged;
				}
				_equipmentSlot = null;
				disposedValue = true;
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	internal interface IOutwardItem
	{
		string ActionUid { get; }

		Item ActionItem { get; }
	}
	internal class ItemSlotAction : ISlotAction, IOutwardItem
	{
		private readonly Player player;

		private readonly Character character;

		private readonly CharacterInventory inventory;

		private readonly SlotDataService slotData;

		private ActionConfig actionConfig;

		private Item item;

		private readonly int itemId;

		private string itemUid;

		private int hotbarIndex;

		private int slotIndex;

		private readonly Func<IModifLogger> _getLogger;

		private static HashSet<string> ignored = new HashSet<string>
		{
			"Icon", "border", "break", "background", "Dot", "Background", "Fill", "imgNew", "imgHighlight", "Backbround",
			"CoinIcon"
		};

		public Item ActionItem => item;

		public int ActionId => itemId;

		public string ActionUid => itemUid;

		private IModifLogger Logger => _getLogger();

		public bool IsEditable { get; internal set; }

		public string DisplayName { get; internal set; }

		public ICooldown Cooldown { get; internal set; }

		public IStackable Stack { get; internal set; }

		public Dictionary<BarPositions, IBarProgress> ActiveBars => null;

		public ActionSlotIcon[] ActionIcons { get; internal set; }

		public bool HasDynamicIcon { get; internal set; }

		public bool IsCombatModeEnabled { get; private set; }

		public Action TargetAction => TryActivateTarget;

		public bool CheckOnUpdate { get; internal set; } = true;


		public event Action OnActionRequested;

		public event Action OnEditRequested;

		public event Action<ActionSlotIcon[]> OnIconsChanged;

		public ItemSlotAction(Item item, Player player, Character character, SlotDataService slotData, bool combatModeEnabled, Func<IModifLogger> getLogger)
		{
			this.item = item;
			this.player = player;
			this.character = character;
			this.slotData = slotData;
			_getLogger = getLogger;
			inventory = character.Inventory;
			ActionIcons = GetItemSprites(isLocked: false);
			DisplayName = item.DisplayName;
			HasDynamicIcon = item.HasDynamicQuickSlotIcon;
			IsCombatModeEnabled = combatModeEnabled;
			Stack = (IStackable)(object)(item.IsStackable() ? new StackTracker(this, character.Inventory) : null);
			itemId = item.ItemID;
			itemUid = item.UID;
		}

		public ActionSlotIcon[] GetDynamicIcons()
		{
			Item obj = item;
			Skill val = (Skill)(object)((obj is Skill) ? obj : null);
			bool isLocked;
			if (val != null)
			{
				isLocked = !((Item)val).IsChildToCharacter || !val.GetIsQuickSlotReq();
			}
			else
			{
				Item obj2 = item;
				Equipment val2 = (Equipment)(object)((obj2 is Equipment) ? obj2 : null);
				isLocked = (val2 != null && ((Item)val2).IsEquipped) || !inventory.OwnsItem(item.ItemID);
			}
			return GetItemSprites(isLocked);
		}

		private ActionSlotIcon[] GetItemSprites(bool isLocked)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0071: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			Sprite val = (isLocked ? (item.LockedIcon ?? item.QuickSlotIcon ?? item.ItemIcon) : item.QuickSlotIcon);
			ItemDisplay privateField = ReflectionExtensions.GetPrivateField<Item, ItemDisplay>(item, "m_refItemDisplay");
			List<ActionSlotIcon> list = new List<ActionSlotIcon>
			{
				new ActionSlotIcon
				{
					Name = ((Object)val).name,
					Icon = val
				}
			};
			if ((Object)(object)privateField != (Object)null)
			{
				for (int i = 0; i < ((Component)privateField).transform.childCount; i++)
				{
					Transform child = ((Component)privateField).transform.GetChild(i);
					Image component = ((Component)child).GetComponent<Image>();
					if ((Object)(object)component != (Object)null && ((Component)component).gameObject.activeSelf && !ignored.Contains(((Object)component).name) && ((Object)(object)component.sprite != (Object)null || (Object)(object)component.overrideSprite != (Object)null))
					{
						list.Add(new ActionSlotIcon
						{
							Name = ((Object)component).name,
							Icon = (component.overrideSprite ?? component.sprite)
						});
					}
				}
			}
			return list.ToArray();
		}

		public bool GetIsActionRequested()
		{
			return !IsEditable && player.GetButtonDown(actionConfig.RewiredActionId) && GetEnabled();
		}

		public bool GetIsEditRequested()
		{
			return IsEditable && player.GetButtonDown(actionConfig.RewiredActionId);
		}

		private void TryActivateTarget()
		{
			try
			{
				ActivateTarget();
			}
			catch (Exception ex)
			{
				IModifLogger logger = Logger;
				string[] obj = new string[6] { "Failed to activate ", actionConfig.RewiredActionName, " item/skill ", null, null, null };
				Item obj2 = item;
				obj[3] = ((obj2 != null) ? ((Object)obj2).name : null);
				obj[4] = " for character ";
				Character obj3 = character;
				obj[5] = ((obj3 != null) ? ((Object)obj3).name : null);
				logger.LogException(string.Concat(obj), ex);
			}
		}

		public void ActivateTarget()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			if (!inventory.OwnsItem(item.UID))
			{
				Item obj = item;
				Skill val = (Skill)(object)((obj is Skill) ? obj : null);
				if (val == null || !inventory.LearnedSkill((Item)(object)val))
				{
					character.CharacterUI.ShowInfoNotification(LocalizationManager.Instance.GetLoc("Notification_Quickslot_NoItemInventory", new string[1] { Global.SetTextColor(item.Name, Global.HIGHLIGHT) }));
					return;
				}
			}
			item.TryQuickSlotUse();
		}

		public bool GetEnabled()
		{
			if (IsCombatModeEnabled && character.InCombat && (hotbarIndex != 0 || slotIndex > 8))
			{
				return false;
			}
			Item obj = item;
			Skill val = (Skill)(object)((obj is Skill) ? obj : null);
			if (val != null && ((Item)val).IsChildToCharacter && val.GetIsQuickSlotReq())
			{
				return true;
			}
			Item obj2 = item;
			Equipment val2 = (Equipment)(object)((obj2 is Equipment) ? obj2 : null);
			if (val2 != null && inventory.OwnsItem(item.UID))
			{
				if (!((Item)val2).IsEquipped)
				{
					return true;
				}
				return false;
			}
			if (slotData.TryFindOwnedItem(ActionId, ActionUid, out var val3))
			{
				item = val3;
				itemUid = val3.UID;
				item.SetQuickSlot(0);
				return true;
			}
			return false;
		}

		public void SlotActionAssigned(ActionSlot assignedSlot)
		{
			hotbarIndex = assignedSlot.HotbarIndex;
			slotIndex = assignedSlot.SlotIndex;
			item.SetQuickSlot(0);
			actionConfig = (ActionConfig)(object)assignedSlot.Config;
		}

		public void SlotActionUnassigned()
		{
			item.SetQuickSlot(-1);
		}
	}
	internal class SkillSlotAction : SlotActionBase
	{
		private Skill skill;

		private readonly bool isEquipmentSetSkill;

		private EquipmentSetSkill equipmentSetSkill;

		public Skill ActionSkill => skill;

		public SkillSlotAction(Skill skill, Player player, Character character, SlotDataService slotData, bool combatModeEnabled, Func<IModifLogger> getLogger)
			: base((Item)(object)skill, player, character, slotData, combatModeEnabled, getLogger)
		{
			this.skill = skill;
			base.Cooldown = (ICooldown)(object)new ItemCooldownTracker(skill);
			base.Stack = (IStackable)(object)((skill.RequiredItems != null && skill.RequiredItems.Length != 0) ? new StackTracker(this, character.Inventory) : null);
		}

		public override bool GetEnabled()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			if (base.IsCombatModeEnabled && character.InCombat && (hotbarIndex != 0 || slotIndex > 7))
			{
				return false;
			}
			if (((Item)skill).IsChildToCharacter && skill.GetIsQuickSlotReq())
			{
				return true;
			}
			if (!((Item)skill).IsChildToCharacter)
			{
				Skill val = (Skill)((IEnumerable<Item>)((CharacterKnowledge)inventory.SkillKnowledge).GetLearnedItems()).FirstOrDefault((Func<Item, bool>)((Item i) => i.ItemID == ((Item)skill).ItemID));
				if ((Object)(object)val != (Object)null)
				{
					skill = val;
					((Item)skill).SetQuickSlot(0);
					((ItemCooldownTracker)(object)base.Cooldown).SetSkill(skill);
				}
			}
			return false;
		}

		public override void ActivateTarget()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)skill == (Object)null))
			{
				if (inventory.LearnedSkill((Item)(object)skill))
				{
					((Item)skill).TryQuickSlotUse();
					return;
				}
				character.CharacterUI.ShowInfoNotification(LocalizationManager.Instance.GetLoc("Notification_Quickslot_NoItemInventory", new string[1] { Global.SetTextColor(((Item)skill).Name, Global.HIGHLIGHT) }));
			}
		}

		protected override bool GetIsLocked()
		{
			return !((Item)skill).IsChildToCharacter || !skill.GetIsQuickSlotReq();
		}

		protected override void AssignRefItemDisplay(ActionSlot assignedSlot)
		{
			base.AssignRefItemDisplay(assignedSlot);
		}
	}
	internal abstract class SlotActionBase : ISlotAction, IOutwardItem
	{
		protected readonly Player player;

		protected readonly Character character;

		protected readonly CharacterInventory inventory;

		protected readonly SlotDataService slotData;

		protected readonly int itemId;

		protected readonly Dictionary<BarPositions, IBarProgress> _activeBars = new Dictionary<BarPositions, IBarProgress>();

		protected string itemUid;

		protected int hotbarIndex;

		protected int slotIndex;

		protected ItemDisplay refItemDisplay;

		protected ActionConfig actionConfig;

		protected Item actionItem;

		private readonly Func<IModifLogger> _getLogger;

		private static HashSet<string> ignoredIcons = new HashSet<string>
		{
			"Icon", "border", "break", "background", "Dot", "Background", "Fill", "imgNew", "imgHighlight", "Backbround",
			"CoinIcon"
		};

		public Item ActionItem => actionItem;

		public int ActionId => itemId;

		public string ActionUid => itemUid;

		public bool IsEditable { get; internal set; }

		public string DisplayName { get; internal set; }

		public ICooldown Cooldown { get; internal set; }

		public IStackable Stack { get; internal set; }

		public Dictionary<BarPositions, IBarProgress> ActiveBars => _activeBars;

		public ActionSlotIcon[] ActionIcons { get; internal set; }

		public bool HasDynamicIcon { get; internal set; }

		public bool IsCombatModeEnabled { get; private set; }

		public Action TargetAction => TryActivateTarget;

		public bool CheckOnUpdate { get; internal set; } = true;


		protected IModifLogger Logger => _getLogger();

		public event Action OnActionRequested;

		public event Action OnEditRequested;

		public event Action<ActionSlotIcon[]> OnIconsChanged;

		public SlotActionBase(Item item, Player player, Character character, SlotDataService slotData, bool combatModeEnabled, Func<IModifLogger> getLogger)
		{
			actionItem = item;
			this.player = player;
			this.character = character;
			this.slotData = slotData;
			_getLogger = getLogger;
			inventory = character.Inventory;
			ActionIcons = GetActionIcons(isLocked: false).ToArray();
			DisplayName = item.DisplayName;
			HasDynamicIcon = item.HasDynamicQuickSlotIcon;
			IsCombatModeEnabled = combatModeEnabled;
			Stack = (IStackable)(object)(item.IsStackable() ? new StackTracker(this, character.Inventory) : null);
			itemId = item.ItemID;
			itemUid = item.UID;
		}

		public abstract void ActivateTarget();

		public ActionSlotIcon[] GetDynamicIcons()
		{
			return GetActionIcons(GetIsLocked()).ToArray();
		}

		public abstract bool GetEnabled();

		public bool GetIsActionRequested()
		{
			return !IsEditable && player.GetButtonDown(actionConfig.RewiredActionId);
		}

		public bool GetIsEditRequested()
		{
			return IsEditable && player.GetButtonDown(actionConfig.RewiredActionId);
		}

		public void SlotActionAssigned(ActionSlot assignedSlot)
		{
			hotbarIndex = assignedSlot.HotbarIndex;
			slotIndex = assignedSlot.SlotIndex;
			actionItem.SetQuickSlot(0);
			actionConfig = (ActionConfig)(object)assignedSlot.Config;
			if ((Object)(object)refItemDisplay != (Object)null)
			{
				GameObjectExtensions.Destroy(((Component)refItemDisplay).gameObject);
			}
			AssignRefItemDisplay(assignedSlot);
			this.OnIconsChanged?.Invoke(GetActionIcons(isLocked: false).ToArray());
		}

		protected virtual void AssignRefItemDisplay(ActionSlot assignedSlot)
		{
			if ((Object)(object)UIUtilities.ItemDisplayPrefab != (Object)null)
			{
				refItemDisplay = Object.Instantiate<ItemDisplay>(UIUtilities.ItemDisplayPrefab);
				((Component)refItemDisplay).transform.SetParent(((Component)assignedSlot.ActionImages).transform);
				((Component)refItemDisplay).transform.SetAsLastSibling();
				UnityEngineExtensions.ResetLocal(((Component)refItemDisplay).transform, true);
				refItemDisplay.SetReferencedItem(actionItem);
				((Component)refItemDisplay).gameObject.SetActive(false);
			}
		}

		protected void RaiseOnActionRequested()
		{
			this.OnActionRequested?.Invoke();
		}

		protected void RaiseOnEditRequested()
		{
			this.OnEditRequested?.Invoke();
		}

		protected void RaiseOnIconsChanged()
		{
			this.OnIconsChanged?.Invoke(GetActionIcons(GetIsLocked()).ToArray());
		}

		protected abstract bool GetIsLocked();

		public virtual void SlotActionUnassigned()
		{
			actionItem.SetQuickSlot(-1);
		}

		protected virtual List<ActionSlotIcon> GetActionIcons(bool isLocked)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0071: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			Sprite val = (isLocked ? (actionItem.LockedIcon ?? actionItem.QuickSlotIcon ?? actionItem.ItemIcon) : actionItem.QuickSlotIcon);
			ItemDisplay privateField = ReflectionExtensions.GetPrivateField<Item, ItemDisplay>(actionItem, "m_refItemDisplay");
			List<ActionSlotIcon> list = new List<ActionSlotIcon>
			{
				new ActionSlotIcon
				{
					Name = ((Object)val).name,
					Icon = val
				}
			};
			if ((Object)(object)privateField != (Object)null)
			{
				for (int i = 0; i < ((Component)privateField).transform.childCount; i++)
				{
					Transform child = ((Component)privateField).transform.GetChild(i);
					Image component = ((Component)child).GetComponent<Image>();
					if ((Object)(object)component != (Object)null && ((Component)component).gameObject.activeSelf && !ignoredIcons.Contains(((Object)component).name) && ((Object)(object)component.sprite != (Object)null || (Object)(object)component.overrideSprite != (Object)null))
					{
						list.Add(new ActionSlotIcon
						{
							Name = ((Object)component).name,
							Icon = (component.overrideSprite ?? component.sprite)
						});
					}
				}
			}
			return list;
		}

		private void TryActivateTarget()
		{
			try
			{
				ActivateTarget();
			}
			catch (Exception ex)
			{
				IModifLogger logger = Logger;
				string[] obj = new string[6] { "Failed to activate ", actionConfig.RewiredActionName, " item/skill ", null, null, null };
				Item obj2 = actionItem;
				obj[3] = ((obj2 != null) ? ((Object)obj2).name : null);
				obj[4] = " for character ";
				Character obj3 = character;
				obj[5] = ((obj3 != null) ? ((Object)obj3).name : null);
				logger.LogException(string.Concat(obj), ex);
			}
		}
	}
	internal class WeaponSetSkill : EquipmentSetSkill
	{
		private WeaponSet _weaponSet
		{
			get
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Expected O, but got Unknown
				if (TryGetEquipmentSet(out var equipmentSet))
				{
					return (WeaponSet)equipmentSet;
				}
				return null;
			}
		}

		protected override void OnAwake()
		{
			base.OnAwake();
		}

		protected override bool OwnerHasAllRequiredItems(bool _tryingToActivate)
		{
			if (_weaponSet == null)
			{
				return false;
			}
			if (TryGetEquipService(out var _) && TryGetEquipmentSet(out var _))
			{
				return false;
			}
			return false;
		}

		protected override void QuickSlotUse()
		{
			if (_weaponSet != null && !TryGetEquipService(out var _))
			{
			}
		}

		protected override bool TryGetEquipmentSet(out IEquipmentSet equipmentSet)
		{
			equipmentSet = null;
			if ((Object)(object)((Item)this).m_ownerCharacter == (Object)null)
			{
				return false;
			}
			UnityServicesProvider val = default(UnityServicesProvider);
			IEquipmentSetService<WeaponSet> val2 = default(IEquipmentSetService<WeaponSet>);
			if (Psp.Instance.TryGetServicesProvider(((Item)this).m_ownerCharacter.OwnerPlayerSys.PlayerID, ref val) && val.TryGetService<IEquipmentSetService<WeaponSet>>(ref val2))
			{
				equipmentSet = (IEquipmentSet)(object)val2.GetEquipmentSet(_setName);
				return equipmentSet != null;
			}
			return false;
		}
	}
	internal class ItemCooldownTracker : ICooldown
	{
		private Skill skill;

		public bool HasCooldown => (Object)(object)skill != (Object)null;

		public bool GetIsInCooldown()
		{
			Skill obj = skill;
			return obj != null && obj.InCooldown();
		}

		public float GetProgress()
		{
			if (!GetIsInCooldown())
			{
				return 0f;
			}
			return SkillExtensions.GetCooldownProgress(skill);
		}

		public float GetSecondsRemaining()
		{
			return SkillExtensions.GetCooldownSecondsRemaining(skill);
		}

		public ItemCooldownTracker(Skill skill)
		{
			this.skill = skill;
		}

		internal void SetSkill(Skill skill)
		{
			this.skill = skill;
		}
	}
	internal class StackTracker : IStackable
	{
		private IOutwardItem _outwardItem;

		private readonly CharacterInventory _inventory;

		public bool IsStackable => true;

		public StackTracker(IOutwardItem item, CharacterInventory inventory)
		{
			if (item == null || (Object)(object)item.ActionItem == (Object)null)
			{
				throw new ArgumentNullException("item");
			}
			if ((Object)(object)inventory == (Object)null)
			{
				throw new ArgumentNullException("inventory");
			}
			_outwardItem = item;
			_inventory = inventory;
		}

		public int GetAmount()
		{
			return (_outwardItem.ActionItem.GroupItemInDisplay || _outwardItem.ActionItem.IsStackable) ? _inventory.ItemCount(_outwardItem.ActionItem.ItemID) : _outwardItem.ActionItem.QuickSlotCountDisplay;
		}
	}
}
namespace ModifAmorphic.Outward.ActionUI.Extensions
{
	internal static class ActionSlotExtensions
	{
		public static SlotData ToSlotData(this ActionSlot actionSlot)
		{
			SlotData slotData = new SlotData
			{
				SlotIndex = actionSlot.SlotIndex,
				Config = actionSlot.Config
			};
			if (actionSlot.SlotAction is IOutwardItem outwardItem)
			{
				slotData.ItemID = outwardItem.ActionItem.ItemID;
				slotData.ItemUID = outwardItem.ActionItem.UID;
			}
			return slotData;
		}
	}
	internal static class EquipmentExtensions
	{
		public static DurableEquipmentType GetDurableEquipmentType(this Equipment equipment)
		{
			//IL_0007: 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_000d: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected I4, but got Unknown
			//IL_0034: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			EquipmentSlotIDs slotType = ((Item)equipment).CurrentEquipmentSlot.SlotType;
			EquipmentSlotIDs val = slotType;
			switch ((int)val)
			{
			case 0:
				return (DurableEquipmentType)1;
			case 1:
				return (DurableEquipmentType)2;
			case 5:
			case 6:
			{
				MeleeWeapon val2 = (MeleeWeapon)(object)((equipment is MeleeWeapon) ? equipment : null);
				if (val2 != null)
				{
					if ((int)((Weapon)val2).Type == 100)
					{
						return (DurableEquipmentType)5;
					}
					return (DurableEquipmentType)4;
				}
				if (equipment is ProjectileWeapon)
				{
					return (DurableEquipmentType)3;
				}
				return (DurableEquipmentType)0;
			}
			case 2:
				return (DurableEquipmentType)6;
			default:
				return (DurableEquipmentType)0;
			}
		}
	}
	internal static class EquipmentSetExtensions
	{
		public static IEnumerable<ItemRequired> ToItemsRequired(this IEquipmentSet set)
		{
			return (from s in set.GetEquipSlots()
				where s != null
				select s).Select((Func<EquipSlot, ItemRequired>)((EquipSlot s) => new ItemRequired
			{
				Consume = false,
				Quantity = 1,
				Item = ItemManager.Instance.GetItem(s.UID)
			}));
		}
	}
	internal static class EquipmentSlotIDsExtensions
	{
		public static EquipSlots ToDurableEquipmentSlot(this EquipmentSlotIDs slot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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)
			//IL_0027: Expected I4, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_003a: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			return (EquipSlots)((int)slot switch
			{
				0 => 1, 
				1 => 2, 
				6 => 4, 
				5 => 3, 
				3 => 5, 
				_ => 0, 
			});
		}
	}
	internal static class HotbarsContainerExtensions
	{
		public static List<IHotbarSlotData> ToHotbarSlotData(this HotbarsContainer hbc, HotbarData[] hotbarDatas)
		{
			List<IHotbarSlotData> list = new List<IHotbarSlotData>();
			for (int i = 0; i < hbc.Hotbars.Length; i++)
			{
				HotbarData hotbarData = new HotbarData();
				if (hotbarDatas.Length > i)
				{
					hotbarData = hotbarDatas[i];
					hotbarData.Slots.Clear();
				}
				else
				{
					hotbarData.HotbarIndex = i;
					hotbarData.RewiredActionId = RewiredConstants.ActionSlots.HotbarNavActions[i].id;
					hotbarData.RewiredActionName = RewiredConstants.ActionSlots.HotbarNavActions[i].name;
				}
				for (int j = 0; j < hbc.Hotbars[i].Length; j++)
				{
					hotbarData.Slots.Add((ISlotData)(object)hbc.Hotbars[i][j].ToSlotData());
				}
				list.Add((IHotbarSlotData)(object)hotbarData);
			}
			return list;
		}
	}
	internal static class ItemExtensions
	{
		public static bool IsStackable(this Item item)
		{
			return item.IsStackable || item.HasMultipleUses || item.GroupItemInDisplay || item is Skill;
		}
	}
	internal static class SlotDataExtensions
	{
	}
}
namespace ModifAmorphic.Outward.ActionUI.DataModels
{
	public class CharacterSlotData
	{
		public string CharacterUID { get; set; }

		public Dictionary<string, SlotDataEntry> Slots { get; set; } = new Dictionary<string, SlotDataEntry>();


		public HashSet<string> DisabledSlots { get; set; } = new HashSet<string>();


		public Dictionary<string, Dictionary<string, SlotDataEntry>> DynamicPresets { get; set; } = new Dictionary<string, Dictionary<string, SlotDataEntry>>();

	}
	public class SlotDataEntry
	{
		public int ItemID { get; set; }

		public string ItemUID { get; set; }
	}
	public class ConcreteTypeConverter<TConcrete> : JsonConverter
	{
		public override bool CanConvert(Type objectType)
		{
			return true;
		}

		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			return serializer.Deserialize<TConcrete>(reader);
		}

		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
		{
			serializer.Serialize(writer, value);
		}
	}
	internal class HotbarData : IHotbarSlotData
	{
		public int HotbarIndex { get; set; }

		[JsonProperty(ItemConverterType = typeof(ConcreteTypeConverter<SlotData>))]
		public List<ISlotData> Slots { get; set; } = new List<ISlotData>();


		public string HotbarHotkey { get; set; }

		public string RewiredActionName { get; set; }

		public int RewiredActionId { get; set; }
	}
	internal class HotbarProfileData : IHotbarProfile
	{
		public int Rows { get; set; }

		public int SlotsPerRow { get; set; }

		public bool HideLeftNav { get; set; }

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


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


		[JsonProperty(ItemConverterType = typeof(ConcreteTypeConverter<HotbarData>))]
		public List<IHotbarSlotData> Hotbars { get; set; }

		public string NextHotkey { get; set; }

		public string NextRewiredActionName { get; set; } = RewiredConstants.ActionSlots.NextHotbarAction.name;


		public int NextRewiredActionId { get; set; } = RewiredConstants.ActionSlots.NextHotbarAction.id;


		public string PrevHotkey { get; set; }

		public string PrevRewiredActionName { get; set; } = RewiredConstants.ActionSlots.PreviousHotbarAction.name;


		public int PrevRewiredActionId { get; set; } = RewiredConstants.ActionSlots.PreviousHotbarAction.id;


		public string NextRewiredAxisActionName { get; set; } = RewiredConstants.ActionSlots.NextHotbarAxisAction.name;


		public int NextRewiredAxisActionId { get; set; } = RewiredConstants.ActionSlots.NextHotbarAxisAction.id;


		public string PrevRewiredAxisActionName { get; set; } = RewiredConstants.ActionSlots.PreviousHotbarAxisAction.name;


		public int PrevRewiredAxisActionId { get; set; } = RewiredConstants.ActionSlots.PreviousHotbarAxisAction.id;


		[DefaultValue(100)]
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public int Scale { get; set; } = 100;

	}
	internal class SlotData : ISlotData
	{
		public int SlotIndex { get; set; }

		public int ItemID { get; set; } = -1;


		public string ItemUID { get; set; }

		[JsonConverter(typeof(ConcreteTypeConverter<ActionConfig>))]
		public IActionSlotConfig Config { get; set; }
	}
}
namespace ModifAmorphic.Outward.ActionUI.DataModels.Global
{
	public enum EquipmentSetTypes
	{
		Armor,
		Weapon
	}
	public class CharacterEquipmentSet
	{
		public int SetID { get; set; }

		public string CharacterUID { get; set; }

		public string Name { get; set; }

		public EquipmentSetTypes EquipmentSetType { get; set; }
	}
	public class GlobalProfile
	{
		public Dictionary<int, CharacterEquipmentSet> CharacterEquipmentSets { get; set; } = new Dictionary<int, CharacterEquipmentSet>();


		public Dictionary<int, string> CharacterItemIDs { get; set; } = new Dictionary<int, string>();

	}
}