using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using ModifAmorphic.Outward.Unity.ActionMenus;
using ModifAmorphic.Outward.Unity.ActionUI;
using ModifAmorphic.Outward.Unity.ActionUI.Controllers;
using ModifAmorphic.Outward.Unity.ActionUI.Data;
using ModifAmorphic.Outward.Unity.ActionUI.EquipmentSets;
using ModifAmorphic.Outward.Unity.ActionUI.Extensions;
using ModifAmorphic.Outward.Unity.ActionUI.Models.EquipmentSets;
using ModifAmorphic.Outward.Unity.ActionUI.Services;
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")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0748ee4c3e5cabdf3003c1bbf7caa92a7535e9c1")]
[assembly: AssemblyProduct("ModifAmorphic.Outward.ActionUI")]
[assembly: AssemblyTitle("ModifAmorphic.Outward.ActionUI")]
[assembly: AssemblyVersion("1.0.0.0")]
public class ActionImages : MonoBehaviour
{
	public static readonly Color DisabledColor = new Color(0f, 0f, 0f, 0.9f);

	public Image BaseImage;

	private Dictionary<string, Image> _bottomImages = new Dictionary<string, Image>();

	private Dictionary<string, Image> _topImages = new Dictionary<string, Image>();

	private const string DisabledKey = "disabled";

	public Image AddOrUpdateImage(ActionSlotIcon slotIcon)
	{
		if (_bottomImages.TryGetValue(slotIcon.Name, out var value))
		{
			if ((Object)(object)value.sprite != (Object)(object)slotIcon.Icon)
			{
				value.sprite = slotIcon.Icon;
			}
			return value;
		}
		Image val = Object.Instantiate<Image>(BaseImage, ((Component)this).transform);
		val.sprite = slotIcon.Icon;
		val.overrideSprite = null;
		((Component)val).gameObject.SetActive(true);
		((Object)val).name = slotIcon.Name;
		if (!slotIcon.IsTopSprite)
		{
			_bottomImages.Add(slotIcon.Name, val);
		}
		else
		{
			_topImages.Add(slotIcon.Name, val);
		}
		SetSiblingIndexes();
		return val;
	}

	public void ToggleEnabled(bool enabled)
	{
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		if (enabled && _bottomImages.TryGetValue("disabled", out var value))
		{
			Object.Destroy((Object)(object)((Component)value).gameObject);
			_bottomImages.Remove("disabled");
		}
		else if (!enabled && !_bottomImages.ContainsKey("disabled"))
		{
			value = AddOrUpdateImage(new ActionSlotIcon
			{
				Name = "disabled",
				Icon = null
			});
			((Graphic)value).color = DisabledColor;
		}
	}

	public void RemoveImage(string imageName)
	{
		if (_bottomImages.TryGetValue(imageName, out var value))
		{
			if ((Object)(object)((value != null) ? ((Component)value).gameObject : null) != (Object)null)
			{
				((Component)value).gameObject.Destroy();
			}
			_bottomImages.Remove(imageName);
		}
		if (_topImages.TryGetValue(imageName, out var value2))
		{
			if ((Object)(object)((value2 != null) ? ((Component)value2).gameObject : null) != (Object)null)
			{
				((Component)value2).gameObject.Destroy();
			}
			_topImages.Remove(imageName);
		}
	}

	public void ClearImages()
	{
		foreach (Image value in _bottomImages.Values)
		{
			if ((Object)(object)((value != null) ? ((Component)value).gameObject : null) != (Object)null)
			{
				((Component)value).gameObject.Destroy();
			}
		}
		foreach (Image value2 in _topImages.Values)
		{
			if ((Object)(object)((value2 != null) ? ((Component)value2).gameObject : null) != (Object)null)
			{
				((Component)value2).gameObject.Destroy();
			}
		}
		_bottomImages.Clear();
		_topImages.Clear();
	}

	private void SetSiblingIndexes()
	{
		int num = 0;
		foreach (Image value in _bottomImages.Values)
		{
			((Component)value).transform.SetSiblingIndex(num);
			num++;
		}
		foreach (Image value2 in _topImages.Values)
		{
			((Component)value2).transform.SetSiblingIndex(num);
			num++;
		}
	}
}
public class ToggleChild : MonoBehaviour
{
	public Color EnabledColor = new Color(0.8392157f, 0.7215686f, 0.3921569f, 1f);

	public Color DisabledColor = new Color(Color.gray.r, Color.gray.g, Color.gray.b, 0.7f);

	public InputField InputField;

	public Selectable ChildToggle;

	public Selectable[] ChildToggles;

	public void Toggle(bool enabled)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		((Graphic)InputField.textComponent).color = (enabled ? EnabledColor : DisabledColor);
		if (ChildToggles != null)
		{
			for (int i = 0; i < ChildToggles.Length; i++)
			{
				ChildToggles[i].interactable = enabled;
			}
		}
	}
}
public class ToggleParent : MonoBehaviour
{
	public List<ToggleChild> Children;

	private void Awake()
	{
		((UnityEvent<bool>)(object)((Component)this).GetComponent<Toggle>().onValueChanged).AddListener((UnityAction<bool>)ToggleChildren);
	}

	private void Start()
	{
		ToggleChildren(((Component)this).GetComponent<Toggle>().isOn);
	}

	public void ToggleChildren(bool enabled)
	{
		if (Children == null)
		{
			return;
		}
		foreach (ToggleChild child in Children)
		{
			child.Toggle(enabled);
		}
	}
}
namespace ModifAmorphic.Outward.Unity.ActionMenus
{
	[UnityScriptComponent]
	public class ActionItemView : MonoBehaviour, IEventSystemHandler, IPointerEnterHandler, IPointerExitHandler
	{
		public ActionImages ActionImages;

		public MouseClickListener MouseClickListener;

		public UnityEvent<int> OnSlotActionSet;

		public UnityEvent<int> OnSlotActionReset;

		private ISlotAction _slotAction;

		private int _viewID = -1;

		private Button _button;

		private Text _text;

		private Text _stackText;

		private Image _borderImage;

		private Image _borderHighlightImage;

		private bool _isAwake;

		public ISlotAction SlotAction => _slotAction;

		public int ViewID => _viewID;

		public Button Button => _button;

		public Image BorderImage => _borderImage;

		public Image ActionBorderHighlight => _borderHighlightImage;

		private void Awake()
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			_button = ((Component)this).GetComponentInChildren<Button>(true);
			_text = ((Component)this).GetComponentsInChildren<Text>(true).First((Text t) => ((Object)t).name.Equals("ActionText"));
			_stackText = ((Component)_button).GetComponentsInChildren<Text>(true).First((Text t) => ((Object)t).name.Equals("StackText"));
			_borderImage = ((Component)this).GetComponentsInChildren<Image>(true).First((Image i) => ((Object)i).name == "ActionBorder");
			_borderHighlightImage = ((Component)this).GetComponentsInChildren<Image>(true).First((Image i) => ((Object)i).name == "ActionBorderHighlight");
			((Behaviour)_borderHighlightImage).enabled = false;
			((Behaviour)_borderImage).enabled = true;
			MouseClickListener.OnRightClick.AddListener(new UnityAction(ResetViewItem));
			_isAwake = true;
		}

		public void SetViewID(int viewID)
		{
			_viewID = viewID;
		}

		public void SetViewItem(ISlotAction action)
		{
			if (_slotAction != null)
			{
				DebugLogger.Log("SetViewItem: ClearImages()");
				_slotAction.OnIconsChanged -= UpdateActionIcons;
				ActionImages.ClearImages();
			}
			_slotAction = action;
			for (int i = 0; i < _slotAction.ActionIcons.Length; i++)
			{
				DebugLogger.Log($"SetViewItem: AddOrUpdateImage({i})");
				ActionImages.AddOrUpdateImage(_slotAction.ActionIcons[i]);
			}
			DebugLogger.Log("SetViewItem: Setting action text.");
			_text.text = action.DisplayName;
			_stackText.text = ((action.Stack != null && action.Stack.IsStackable && action.Stack.GetAmount() > 0) ? action.Stack.GetAmount().ToString() : string.Empty);
			if (action.HasDynamicIcon)
			{
				action.OnIconsChanged += UpdateActionIcons;
			}
			DebugLogger.Log($"SetViewItem: Raising OnSlotActionSet for ViewID {ViewID}.");
			OnSlotActionSet.Invoke(ViewID);
		}

		public void ResetViewItem()
		{
			if (_slotAction != null)
			{
				_slotAction.OnIconsChanged -= UpdateActionIcons;
			}
			ActionImages?.ClearImages();
			_slotAction = null;
			_text.text = string.Empty;
			_stackText.text = string.Empty;
			DebugLogger.Log($"SetViewItem: Raising OnSlotActionReset for ViewID {ViewID}.");
			OnSlotActionReset.Invoke(ViewID);
		}

		private void UpdateActionIcons(ActionSlotIcon[] icons)
		{
			ActionImages.ClearImages();
			for (int i = 0; i < _slotAction.ActionIcons.Length; i++)
			{
				ActionImages.AddOrUpdateImage(_slotAction.ActionIcons[i]);
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (_isAwake)
			{
				((Behaviour)_borderHighlightImage).enabled = true;
				((Behaviour)_borderImage).enabled = false;
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			if (_isAwake)
			{
				((Behaviour)_borderHighlightImage).enabled = false;
				((Behaviour)_borderImage).enabled = true;
			}
		}
	}
	[UnityScriptComponent]
	public class ActionMenuResources : MonoBehaviour
	{
		public Dictionary<string, Sprite> SpriteResources;

		public static ActionMenuResources Instance { get; private set; }

		private void Awake()
		{
			SpriteResources = new Dictionary<string, Sprite>();
			GameObject gameObject = ((Component)((Component)this).transform.Find("SpriteImages")).gameObject;
			Image[] componentsInChildren = gameObject.GetComponentsInChildren<Image>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				SpriteResources.Add(((Object)componentsInChildren[i]).name, componentsInChildren[i].sprite);
				((Component)componentsInChildren[i]).gameObject.SetActive(false);
			}
			Instance = this;
		}
	}
	[UnityScriptComponent]
	public class ActionSlot : MonoBehaviour
	{
		private MouseClickListener _mouseClickListener;

		private ISlotAction _slotAction;

		private IActionSlotConfig _config;

		private Transform _slotPanel;

		private Canvas _parentCanvas;

		private CanvasGroup _canvasGroup;

		private Image _hotkeyPanel;

		private Text _keyText;

		private Button _keyButton;

		private Button _actionButton;

		private ActionImages _actionImages;

		private Image _cooldownImage;

		private Image _cooldownTextBackground;

		private Text _cooldownText;

		private Text _stackText;

		private Image _emptyImage;

		private Image _borderImage;

		private Dictionary<BarPositions, ProgressBar> _progressBars = new Dictionary<BarPositions, ProgressBar>();

		private IActionSlotController _controller;

		public HotbarsContainer HotbarsContainer { get; internal set; }

		public MouseClickListener MouseClickListener => _mouseClickListener;

		public int HotbarIndex { get; internal set; }

		public int SlotIndex { get; internal set; }

		public int SlotId => HotbarIndex * 10000 + SlotIndex;

		public ISlotAction SlotAction
		{
			get
			{
				return _slotAction;
			}
			internal set
			{
				_slotAction = value;
			}
		}

		public IActionSlotConfig Config
		{
			get
			{
				return _config;
			}
			internal set
			{
				_config = value;
			}
		}

		public Transform SlotPanel => _slotPanel;

		public Canvas ParentCanvas => _parentCanvas;

		public CanvasGroup CanvasGroup => _canvasGroup;

		public Image HotkeyPanel => _hotkeyPanel;

		public Text KeyText => _keyText;

		public Button KeyButton => _keyButton;

		public Button ActionButton => _actionButton;

		public ActionImages ActionImages => _actionImages;

		public Image CooldownImage => _cooldownImage;

		public Image CooldownTextBackground => _cooldownTextBackground;

		public Text CooldownText => _cooldownText;

		public Text StackText => _stackText;

		public Image EmptyImage => _emptyImage;

		public Image BorderImage => _borderImage;

		public Dictionary<BarPositions, ProgressBar> ProgressBars => _progressBars;

		public IActionSlotController Controller => _controller;

		public bool IsInEditMode => HotbarsContainer.IsInHotkeyEditMode;

		public Func<Action, bool> ActionRequested { get; private set; }

		private void Awake()
		{
			SetComponents();
			if (((Object)this).name != "BaseActionSlot")
			{
				((Object)this).name = $"ActionSlot_{HotbarIndex}_{SlotIndex}";
				_controller = new ActionSlotController(this);
				_controller.ActionSlotAwake();
			}
		}

		private void OnEnable()
		{
			if (SlotAction != null)
			{
				DebugLogger.Log("ActionSlot::OnEnable: Reassigning SlotAction " + SlotAction.DisplayName);
				_controller.AssignSlotAction(SlotAction, surpressChangeFlag: true);
			}
		}

		private void Update()
		{
			_controller.ActionSlotUpdate();
		}

		private void SetComponents()
		{
			Transform parent = ((Component)this).transform.parent;
			object parentCanvas;
			if (parent == null)
			{
				parentCanvas = null;
			}
			else
			{
				Transform parent2 = parent.parent;
				parentCanvas = ((parent2 != null) ? ((Component)parent2).GetComponent<Canvas>() : null);
			}
			_parentCanvas = (Canvas)parentCanvas;
			_slotPanel = ((Component)this).transform.Find("SlotPanel");
			_canvasGroup = ((Component)this).GetComponent<CanvasGroup>();
			_hotkeyPanel = ((Component)((Component)this).transform.Find("HotkeyPanel")).GetComponent<Image>();
			_keyText = ((Component)_hotkeyPanel).GetComponentsInChildren<Text>(true).First((Text t) => ((Object)t).name == "KeyText");
			_keyButton = ((Component)_hotkeyPanel).GetComponentsInChildren<Button>(true).First((Button t) => ((Object)t).name == "KeyButton");
			_borderImage = ((Component)_slotPanel).GetComponentsInChildren<Image>(true).First((Image i) => ((Object)i).name == "ActionBorder");
			_actionButton = ((Component)_slotPanel).GetComponentInChildren<Button>(true);
			_mouseClickListener = ((Component)_actionButton).GetComponent<MouseClickListener>();
			_actionImages = ((Component)_actionButton).GetComponentInChildren<ActionImages>();
			_progressBars.Add(BarPositions.Top, ((Component)_actionButton).GetComponentsInChildren<ProgressBar>().First((ProgressBar s) => ((Object)s).name == "TopBar"));
			_progressBars.Add(BarPositions.Right, ((Component)_actionButton).GetComponentsInChildren<ProgressBar>().First((ProgressBar s) => ((Object)s).name == "RightBar"));
			_progressBars.Add(BarPositions.Bottom, ((Component)_actionButton).GetComponentsInChildren<ProgressBar>().First((ProgressBar s) => ((Object)s).name == "BottomBar"));
			_progressBars.Add(BarPositions.Left, ((Component)_actionButton).GetComponentsInChildren<ProgressBar>().First((ProgressBar s) => ((Object)s).name == "LeftBar"));
			_stackText = ((Component)_actionButton).GetComponentsInChildren<Text>().First((Text t) => ((Object)t).name == "StackText");
			_cooldownText = ((Component)_actionButton).GetComponentsInChildren<Text>().First((Text t) => ((Object)t).name == "CooldownText");
			_cooldownTextBackground = ((Component)_actionButton).GetComponentsInChildren<Image>().First((Image i) => ((Object)i).name == "CooldownTextBackground");
			_cooldownImage = ((Component)_actionButton).GetComponentsInChildren<Image>().First((Image i) => ((Object)i).name == "CooldownImage");
			_emptyImage = ((Component)_actionButton).GetComponentsInChildren<Image>().First((Image i) => ((Object)i).name == "EmptyImage");
		}

		internal void SetButtonNormalColor(Color color)
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock colors = ((Selectable)ActionButton).colors;
			((ColorBlock)(ref colors)).normalColor = color;
			((Selectable)ActionButton).colors = colors;
		}
	}
	[UnityScriptComponent]
	public class ActionsViewer : MonoBehaviour, IActionMenu
	{
		public delegate void SlotActionSelected(int slotId, ISlotAction slotAction);

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

			private object <>2__current;

			public Action action;

			public ActionsViewer <>4__this;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>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;
					action();
					return false;
				}
			}

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

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

		public PlayerActionMenus PlayerMenu;

		public ViewerLeftNav LeftNav;

		private GridLayoutGroup _gridLayout;

		public GameObject BaseGridAction;

		private int _slotId;

		public bool IsShowing => ((Component)this).gameObject.activeSelf;

		public bool HasData => GetViewData() != null;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		public event SlotActionSelected OnSlotActionSelected;

		private void Awake()
		{
			_gridLayout = ((Component)this).GetComponentInChildren<GridLayoutGroup>();
			BaseGridAction.SetActive(false);
			Hide();
		}

		private void Start()
		{
			Clear();
		}

		public void Clear()
		{
			ActionItemView[] componentsInChildren = ((Component)this).GetComponentsInChildren<ActionItemView>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (((Object)componentsInChildren[i]).name != "BaseSlotPanel")
				{
					((Component)componentsInChildren[i]).gameObject.Destroy();
				}
			}
		}

		public void LoadData(IEnumerable<ISlotAction> actionViews)
		{
			Clear();
			if (!HasData)
			{
				return;
			}
			foreach (ISlotAction actionView in actionViews)
			{
				AddActionView(actionView);
			}
		}

		public void AddActionView(ISlotAction slotAction)
		{
			AddGridItem(slotAction);
		}

		public void Show(int slotId)
		{
			_slotId = slotId;
			if (!((Component)this).gameObject.activeSelf)
			{
				((Component)this).gameObject.SetActive(true);
			}
			InitLeftNav();
			DoNextFrame(LeftNav.ClickSelectedTab);
			UnityEvent onShow = OnShow;
			if (onShow != null)
			{
				onShow.Invoke();
			}
		}

		public void Hide()
		{
			_slotId = 0;
			if (((Component)this).gameObject.activeSelf)
			{
				((Component)this).gameObject.SetActive(false);
			}
			UnityEvent onHide = OnHide;
			if (onHide != null)
			{
				onHide.Invoke();
			}
		}

		private void InitLeftNav()
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			LeftNav.ClearViewTabs();
			IActionViewData viewData = GetViewData();
			if (viewData.GetActionsTabData() != null)
			{
				foreach (IActionsDisplayTab tabView in from d in viewData.GetActionsTabData()
					orderby d.TabOrder
					select d)
				{
					Button val = LeftNav.AddViewTab(tabView.DisplayName);
					((UnityEvent)val.onClick).AddListener((UnityAction)delegate
					{
						LoadData(tabView.GetSlotActions());
					});
				}
			}
			((UnityEvent)LeftNav.AddViewTab("All").onClick).AddListener((UnityAction)delegate
			{
				LoadData(viewData.GetAllActions());
			});
		}

		private IActionViewData GetViewData()
		{
			return Psp.Instance.GetServicesProvider(PlayerMenu.PlayerID).GetService<IActionViewData>();
		}

		private void AddGridItem(ISlotAction slotAction)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(BaseGridAction, ((Component)_gridLayout).transform);
			int num = ((Component)_gridLayout).GetComponentsInChildren<ActionItemView>().Count();
			val.SetActive(true);
			ActionItemView actionItem = val.GetComponent<ActionItemView>();
			actionItem.SetViewItem(slotAction);
			((Object)actionItem).name = "SlotActionView_" + num;
			((UnityEvent)actionItem.Button.onClick).AddListener((UnityAction)delegate
			{
				RaiseSelectionAndHide(_slotId, actionItem.SlotAction);
			});
		}

		private void RaiseSelectionAndHide(int slotId, ISlotAction slotAction)
		{
			this.OnSlotActionSelected?.Invoke(slotId, slotAction);
			Clear();
			DoNextFrame(Hide);
		}

		private void DoNextFrame(Action action)
		{
			((MonoBehaviour)this).StartCoroutine(NextFrameCoroutine(action));
		}

		[IteratorStateMachine(typeof(<NextFrameCoroutine>d__31))]
		private IEnumerator NextFrameCoroutine(Action action)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <NextFrameCoroutine>d__31(0)
			{
				<>4__this = this,
				action = action
			};
		}
	}
	[UnityScriptComponent]
	public class ArrowInput : MonoBehaviour
	{
		public Button LeftArrow;

		public Button RightArrow;

		public InputField InputText;

		public int Minimum = 1;

		public int Maximum = 100;

		public UnityEvent<int> OnValueChanged;

		public int Amount
		{
			get
			{
				int result;
				return int.TryParse(InputText.text, out result) ? result : Minimum;
			}
		}

		private void Start()
		{
			((UnityEvent<string>)(object)InputText.onValueChanged).AddListener((UnityAction<string>)delegate
			{
				ValidateInput(Amount);
			});
		}

		public void SetAmount(int amount)
		{
			if (amount >= Minimum && amount <= Maximum)
			{
				InputText.text = amount.ToString();
			}
		}

		public void IncreaseAmount()
		{
			if (Amount < Maximum)
			{
				InputText.text = (Amount + 1).ToString();
			}
		}

		public void DecreaseAmount()
		{
			if (Amount > Minimum)
			{
				InputText.text = (Amount - 1).ToString();
			}
		}

		private void ValidateInput(int amount)
		{
			int num = amount;
			if (amount < Minimum)
			{
				num = Minimum;
			}
			else if (amount > Maximum)
			{
				num = Maximum;
			}
			InputText.SetTextWithoutNotify(num.ToString());
			OnValueChanged.Invoke(num);
		}
	}
	[UnityScriptComponent]
	public class ConfirmationPanel : MonoBehaviour
	{
		public Button ConfirmButton;

		public Button CancelButton;

		public Text PromptText;

		public Text DisplayText;

		private bool _isShowInvoked;

		private Action _confirmationAction;

		public bool IsShowing => ((Component)this).gameObject.activeSelf;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		private void Awake()
		{
			if (!_isShowInvoked)
			{
				Hide(raiseEvent: false);
			}
		}

		public void Show(Action confirmationAction, string promptText)
		{
			PromptText.text = promptText;
			_confirmationAction = confirmationAction;
			_isShowInvoked = true;
			((Component)this).gameObject.SetActive(true);
			OnShow.TryInvoke();
		}

		public void Hide()
		{
			Hide(raiseEvent: true);
		}

		private void Hide(bool raiseEvent)
		{
			((Component)this).gameObject.SetActive(false);
			_isShowInvoked = false;
			if (raiseEvent)
			{
				OnHide.TryInvoke();
			}
		}

		public void OnConfirm()
		{
			_confirmationAction();
			Hide();
		}
	}
	[UnityScriptComponent]
	public class DurabilityDisplay : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <AddToPsp>d__28 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DurabilityDisplay <>4__this;

			private UnityServicesProvider <psp>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)Psp.Instance != (Object)null && <>4__this.PlayerActionMenus.PlayerID > -1));
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<psp>5__1 = Psp.Instance.GetServicesProvider(<>4__this.PlayerActionMenus.PlayerID);
					if (!<psp>5__1.TryGetService<DurabilityDisplay>(out var _))
					{
						<psp>5__1.AddSingleton(<>4__this);
					}
					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 <SetDurabilityValue>d__27 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DurabilitySlot slot;

			public Func<float> getDurability;

			public DurabilityDisplay <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				slot.SetValue(getDurability());
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			}

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

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

		public PlayerActionMenus PlayerActionMenus;

		public DurabilitySlot Head;

		public DurabilitySlot Chest;

		public DurabilitySlot RightHand;

		public DurabilitySlot LeftHand;

		public DurabilitySlot Feet;

		private Canvas _canvas;

		private PositionableUI _positionable;

		private Dictionary<EquipSlots, DurabilitySlot> _durabilitySlots = new Dictionary<EquipSlots, DurabilitySlot>();

		private bool isAwake = false;

		private Dictionary<EquipSlots, float> _displayMinimums = new Dictionary<EquipSlots, float>();

		private Dictionary<EquipSlots, Coroutine> _coroutines = new Dictionary<EquipSlots, Coroutine>();

		public Dictionary<EquipSlots, DurabilitySlot> DurabilitySlots => _durabilitySlots;

		public bool IsAwake => isAwake;

		public UnityEvent OnAwake { get; } = new UnityEvent();


		private void Awake()
		{
			_canvas = ((Component)this).GetComponent<Canvas>();
			_positionable = ((Component)this).GetComponent<PositionableUI>();
			if ((Object)(object)_positionable != (Object)null)
			{
				_positionable.OnIsPositionableChanged.AddListener((UnityAction<bool>)delegate
				{
					RefreshDisplay();
				});
			}
			_durabilitySlots.Add(EquipSlots.Head, Head);
			_durabilitySlots.Add(EquipSlots.Chest, Chest);
			_durabilitySlots.Add(EquipSlots.RightHand, RightHand);
			_durabilitySlots.Add(EquipSlots.LeftHand, LeftHand);
			_durabilitySlots.Add(EquipSlots.Feet, Feet);
			foreach (DurabilitySlot value in _durabilitySlots.Values)
			{
				DurabilitySlot changedSlot = value;
				value.OnValueChanged += delegate
				{
					OnSlotValueChanged(changedSlot);
				};
			}
			isAwake = true;
			OnAwake.TryInvoke();
		}

		private void Start()
		{
			UnityServicesProvider servicesProvider = Psp.Instance.GetServicesProvider(PlayerActionMenus.PlayerID);
			if (!servicesProvider.TryGetService<DurabilityDisplay>(out var _))
			{
				servicesProvider.AddSingleton(this);
			}
			RefreshDisplay();
		}

		public void TrackDurability(IDurability durability)
		{
			StopTracking(durability.DurableEquipmentSlot);
			SetMinimumDisplayValue(durability.DurableEquipmentSlot, durability.MinimumDisplayValue);
			foreach (ColorRange colorRange in durability.ColorRanges)
			{
				_durabilitySlots[durability.DurableEquipmentSlot].AddColorRange(colorRange);
			}
			_durabilitySlots[durability.DurableEquipmentSlot].SetEquipmentType(durability.DurableEquipmentType);
			_coroutines.Add(durability.DurableEquipmentSlot, ((MonoBehaviour)this).StartCoroutine(SetDurabilityValue(_durabilitySlots[durability.DurableEquipmentSlot], durability.GetDurabilityRatio)));
			RefreshDisplay();
		}

		public void StopTracking(EquipSlots slot)
		{
			if (_coroutines.ContainsKey(slot))
			{
				if (_coroutines[slot] != null)
				{
					((MonoBehaviour)this).StopCoroutine(_coroutines[slot]);
				}
				_coroutines.Remove(slot);
				_durabilitySlots[slot].ResetColorRanges();
				_durabilitySlots[slot].SetValue(0f);
				SetMinimumDisplayValue(slot, -1f);
			}
		}

		public void StopAllTracking()
		{
			foreach (EquipSlots item in Enum.GetValues(typeof(EquipSlots)).Cast<EquipSlots>())
			{
				if (_coroutines.ContainsKey(item) && _coroutines[item] != null)
				{
					((MonoBehaviour)this).StopCoroutine(_coroutines[item]);
				}
			}
		}

		private void SetMinimumDisplayValue(EquipSlots slot, float minimum)
		{
			if (_displayMinimums.ContainsKey(slot))
			{
				_displayMinimums[slot] = minimum;
			}
			else
			{
				_displayMinimums.Add(slot, minimum);
			}
			RefreshDisplay();
		}

		private void OnSlotValueChanged(DurabilitySlot equipSlot)
		{
			if (_displayMinimums.TryGetValue(equipSlot.EquipmentSlot, out var value) && ((equipSlot.Value <= value && !((Behaviour)_canvas).enabled) || (equipSlot.Value > value && ((Behaviour)_canvas).enabled)))
			{
				RefreshDisplay();
			}
		}

		private void RefreshDisplay()
		{
			bool flag = _positionable?.IsPositionable ?? false;
			foreach (KeyValuePair<EquipSlots, DurabilitySlot> durabilitySlot in _durabilitySlots)
			{
				if (_displayMinimums.ContainsKey(durabilitySlot.Key) && durabilitySlot.Value.Value <= _displayMinimums[durabilitySlot.Key])
				{
					((Behaviour)durabilitySlot.Value.Image).enabled = true;
					flag = true;
				}
			}
			if (flag)
			{
				((Behaviour)LeftHand.Image).enabled = _coroutines.ContainsKey(EquipSlots.LeftHand);
				((Behaviour)RightHand.Image).enabled = _coroutines.ContainsKey(EquipSlots.RightHand);
				((Behaviour)Head.Image).enabled = true;
				((Behaviour)Chest.Image).enabled = true;
				((Behaviour)Feet.Image).enabled = true;
			}
			else
			{
				((Behaviour)Head.Image).enabled = false;
				((Behaviour)Chest.Image).enabled = false;
				((Behaviour)Feet.Image).enabled = false;
			}
			((Behaviour)_canvas).enabled = flag;
		}

		[IteratorStateMachine(typeof(<SetDurabilityValue>d__27))]
		private IEnumerator SetDurabilityValue(DurabilitySlot slot, Func<float> getDurability)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetDurabilityValue>d__27(0)
			{
				<>4__this = this,
				slot = slot,
				getDurability = getDurability
			};
		}

		[IteratorStateMachine(typeof(<AddToPsp>d__28))]
		private IEnumerator AddToPsp()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AddToPsp>d__28(0)
			{
				<>4__this = this
			};
		}
	}
	[UnityScriptComponent]
	public class DurabilitySlot : DynamicColorImage
	{
		private Dictionary<DurableEquipmentType, Image> _equipmentImages;

		public EquipSlots EquipmentSlot;

		public DurableEquipmentType EquipmentType;

		protected override void OnAwake()
		{
			_equipmentImages = ((Component)this).GetComponentsInChildren<Image>().ToDictionary((Image i) => (DurableEquipmentType)Enum.Parse(typeof(DurableEquipmentType), ((Object)i).name, ignoreCase: true), (Image i) => i);
			SetDisplayImage(EquipmentType);
		}

		public void SetEquipmentType(DurableEquipmentType equipmentType)
		{
			EquipmentType = equipmentType;
			if (_isAwake)
			{
				SetDisplayImage(equipmentType);
			}
		}

		private void SetDisplayImage(DurableEquipmentType equipmentType)
		{
			foreach (KeyValuePair<DurableEquipmentType, Image> equipmentImage in _equipmentImages)
			{
				((Behaviour)equipmentImage.Value).enabled = equipmentImage.Key == equipmentType;
			}
			if (equipmentType != 0)
			{
				Image = _equipmentImages[equipmentType];
			}
		}
	}
	public abstract class DynamicColorImage : MonoBehaviour
	{
		public Image Image;

		protected List<ColorRange> initColorRanges = new List<ColorRange>();

		protected Dictionary<int, Color> colorMap = new Dictionary<int, Color>();

		protected bool _isAwake = false;

		protected float _value;

		public float Value => _value;

		public event Action<Color> OnColorChanged;

		public event Action<float> OnValueChanged;

		private void Awake()
		{
			ResetColorRanges();
			_isAwake = true;
			if (initColorRanges.Any())
			{
				DebugLogger.Log("Init Colors ranges found. Adding ColorMaps for image.");
				foreach (ColorRange initColorRange in initColorRanges)
				{
					AddColorMaps(initColorRange);
				}
				initColorRanges.Clear();
			}
			OnAwake();
		}

		protected abstract void OnAwake();

		public void AddColorRange(ColorRange colorRange)
		{
			if (colorRange.Min < 0f)
			{
				throw new ArgumentOutOfRangeException("Min");
			}
			if (colorRange.Max > 1f)
			{
				throw new ArgumentOutOfRangeException("Max");
			}
			if (!_isAwake)
			{
				initColorRanges.Add(colorRange);
			}
			else
			{
				AddColorMaps(colorRange);
			}
		}

		public void ResetColorRanges()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			colorMap.Clear();
			for (int i = 0; i <= 1000; i++)
			{
				colorMap.Add(i, Color.gray);
			}
		}

		public virtual void SetValue(float value)
		{
			//IL_003c: 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)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!(value < 0f) && !(value > 1f))
			{
				int key = (int)(value * 1000f);
				if (colorMap.TryGetValue(key, out var value2) && ((Graphic)Image).color != value2)
				{
					((Graphic)Image).color = value2;
					this.OnColorChanged?.Invoke(value2);
				}
				if (_value != value)
				{
					_value = value;
					this.OnValueChanged?.Invoke(_value);
				}
			}
		}

		private void AddColorMaps(ColorRange colorRange)
		{
			//IL_0052: 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)
			int num = (int)(1000f * colorRange.Min);
			int num2 = (int)(1000f * colorRange.Max);
			for (int i = num; i <= num2; i++)
			{
				if (!colorMap.ContainsKey(i))
				{
					colorMap.Add(i, colorRange.Color);
				}
				else
				{
					colorMap[i] = colorRange.Color;
				}
			}
		}
	}
	[UnityScriptComponent]
	public class EquipmentSetMenu : MonoBehaviour, IActionMenu
	{
		private enum EquipmentSetViews
		{
			Weapons,
			Armor
		}

		public Toggle WeaponToggle;

		public Toggle ArmorToggle;

		public EquipmentSetView ArmorSetView;

		public EquipmentSetView WeaponSetView;

		private EquipmentSetViews _lastView;

		public bool IsShowing => ((Component)this).gameObject.activeSelf;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		private void Awake()
		{
			((UnityEvent<bool>)(object)WeaponToggle.onValueChanged).AddListener((UnityAction<bool>)ToggleWeaponsView);
			((UnityEvent<bool>)(object)ArmorToggle.onValueChanged).AddListener((UnityAction<bool>)ToggleArmorView);
			Hide();
		}

		public void Show()
		{
			((Component)this).gameObject.SetActive(true);
			if (WeaponToggle.isOn)
			{
				ToggleArmorView(isOn: false);
				ToggleWeaponsView(isOn: true);
			}
			else
			{
				ToggleArmorView(isOn: true);
				ToggleWeaponsView(isOn: false);
			}
			OnShow.TryInvoke();
		}

		public void Hide()
		{
			((Component)this).gameObject.SetActive(false);
			OnHide.TryInvoke();
		}

		private void ToggleWeaponsView(bool isOn)
		{
			if (isOn)
			{
				WeaponSetView.Show();
			}
			else
			{
				WeaponSetView.Hide();
			}
		}

		private void ToggleArmorView(bool isOn)
		{
			if (isOn)
			{
				ArmorSetView.Show();
			}
			else
			{
				ArmorSetView.Hide();
			}
		}
	}
	[UnityScriptComponent]
	public class EquipmentSetNameInput : MonoBehaviour
	{
		public InputField NameInput;

		public Button OkButton;

		public Text Caption;

		public Text DisplayText;

		public EquipmentSetView ParentEquipmentSet;

		public bool IsShowing => ((Component)this).gameObject.activeSelf;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		private void Awake()
		{
			Hide(raiseEvent: false);
		}

		public void Show(EquipmentSetTypes equipmentSetType, EquipSlots setIconSlot)
		{
			((Component)this).gameObject.SetActive(true);
			OnShow?.TryInvoke();
		}

		public void Show(EquipmentSetTypes equipmentSetType, string setName)
		{
			((Component)this).gameObject.SetActive(true);
			OnShow?.TryInvoke();
		}

		public void Hide()
		{
			Hide(raiseEvent: true);
		}

		private void Hide(bool raiseEvent)
		{
			((Component)this).gameObject.SetActive(false);
			if (raiseEvent)
			{
				OnHide?.TryInvoke();
			}
		}
	}
	public enum EquipmentSetTypes
	{
		Weapon,
		Armor
	}
	[UnityScriptComponent]
	public class EquipmentSetView : MonoBehaviour
	{
		public PlayerActionMenus PlayerMenu;

		public EquipmentSetTypes EquipmentSetType;

		public Dropdown EquipmentSetDropdown;

		public Button NewSetButton;

		public Button RenameSetButton;

		public Button SaveSetButton;

		public Button DeleteSetButton;

		public Dropdown EquipmentIconDropdown;

		public ActionItemView EquipmentIcon;

		public EquipmentSetNameInput SetNamePanel;

		public ConfirmationPanel ConfirmationPanel;

		private void Awake()
		{
		}

		private void Start()
		{
		}

		public void Show()
		{
			((Component)this).gameObject.SetActive(true);
		}

		public void Hide()
		{
			((Component)this).gameObject.SetActive(false);
		}

		public void Refresh()
		{
		}
	}
	[UnityScriptComponent]
	public class HotbarsContainer : MonoBehaviour
	{
		private RectTransform _leftDisplay;

		private KeyboardQuickSlotPanel _vanillaKeyboardPanel;

		private IHotbarController _controller;

		public PlayerActionMenus PlayerActionMenus;

		public List<CanvasGroup> VanillaOverlayTargets = new List<CanvasGroup>();

		public List<GameObject> VanillaSuppressionTargets = new List<GameObject>();

		private Canvas _actionBarsCanvas;

		public LeftHotbarNav LeftHotbarNav;

		private Canvas _baseHotbarCanvas;

		[SerializeField]
		private GridLayoutGroup _baseGrid;

		private GridLayoutGroup[] _hotbarGrid;

		private GameObject _baseActionSlot;

		private ActionSlot[][] _hotbars;

		private Dictionary<int, ActionSlot> _actionSlots = new Dictionary<int, ActionSlot>();

		private int _selectedHotbar;

		private bool _hasChanges = false;

		public IHotbarController Controller => _controller;

		public bool HotbarsEnabled => ((Component)_actionBarsCanvas).gameObject.activeSelf;

		public Canvas ActionBarsCanvas => _actionBarsCanvas;

		internal Canvas BaseHotbarCanvas => _baseHotbarCanvas;

		internal GridLayoutGroup BaseGrid => _baseGrid;

		internal GridLayoutGroup[] HotbarGrid => _hotbarGrid;

		internal GameObject BaseActionSlot => _baseActionSlot;

		public ActionSlot[][] Hotbars => _hotbars;

		public Dictionary<int, ActionSlot> ActionSlots => _actionSlots;

		public int SelectedHotbar
		{
			get
			{
				return _selectedHotbar;
			}
			internal set
			{
				_selectedHotbar = value;
			}
		}

		public bool IsInHotkeyEditMode { get; internal set; }

		public bool IsInActionSlotEditMode { get; internal set; }

		public bool HasChanges
		{
			get
			{
				return _hasChanges;
			}
			internal set
			{
				bool hasChanges = _hasChanges;
				_hasChanges = value;
				if (value && !hasChanges)
				{
					OnHasChanges.Invoke();
				}
			}
		}

		public UnityEvent OnHasChanges { get; } = new UnityEvent();


		public bool IsAwake { get; private set; }

		public event Action OnAwake;

		public void ClearChanges()
		{
			_hasChanges = false;
		}

		private void Awake()
		{
			SetComponents();
			_controller = new HotbarsController(this);
			PlayerActionMenus.OnPlayerIdAssigned.AddListener((UnityAction<PlayerActionMenus>)OnPlayerAssigned);
			IsAwake = true;
			this.OnAwake?.Invoke();
		}

		private void OnPlayerAssigned(PlayerActionMenus menus)
		{
			if ((Object)(object)menus == (Object)(object)PlayerActionMenus)
			{
				IHotbarProfileService service = menus.ServicesProvider.GetService<IHotbarProfileService>();
				if (service != null)
				{
					service.OnProfileChanged += OnProfileChanged;
				}
			}
		}

		private void OnProfileChanged(IHotbarProfile profile, HotbarProfileChangeTypes type)
		{
			_controller.ConfigureHotbars(profile);
		}

		private void Update()
		{
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			if (VanillaOverlayTargets != null)
			{
				foreach (CanvasGroup vanillaOverlayTarget in VanillaOverlayTargets)
				{
					if (!((Object)(object)vanillaOverlayTarget != (Object)null) || !((Component)vanillaOverlayTarget).gameObject.activeInHierarchy || !(vanillaOverlayTarget.alpha > 0.01f))
					{
						continue;
					}
					RectTransform component = ((Component)vanillaOverlayTarget).GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null)
					{
						Rect rect = component.rect;
						float num2 = ((Rect)(ref rect)).height * ((Component)vanillaOverlayTarget).transform.lossyScale.y;
						if (((Component)this).transform.lossyScale.y > 0.0001f)
						{
							num = Mathf.Max(num, num2 / ((Component)this).transform.lossyScale.y);
							continue;
						}
						float num3 = num;
						rect = component.rect;
						num = Mathf.Max(num3, ((Rect)(ref rect)).height);
					}
				}
			}
			if ((Object)(object)_vanillaKeyboardPanel == (Object)null)
			{
				_vanillaKeyboardPanel = ((Component)((Component)this).transform.root).GetComponentInChildren<KeyboardQuickSlotPanel>(true);
			}
			if ((Object)(object)_vanillaKeyboardPanel != (Object)null && ((Component)_vanillaKeyboardPanel).gameObject.activeSelf)
			{
				((Component)_vanillaKeyboardPanel).gameObject.SetActive(false);
			}
			if (VanillaSuppressionTargets != null)
			{
				for (int i = 0; i < VanillaSuppressionTargets.Count; i++)
				{
					GameObject val = VanillaSuppressionTargets[i];
					if ((Object)(object)val != (Object)null)
					{
						if (val.activeSelf)
						{
							val.SetActive(false);
						}
						if (val.transform.localScale != Vector3.zero)
						{
							val.transform.localScale = Vector3.zero;
						}
					}
				}
			}
			PositionableUI component2 = ((Component)this).GetComponent<PositionableUI>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.DynamicOffset = new Vector2(0f, num);
			}
			Controller.HotbarsContainerUpdate();
		}

		private void SetComponents()
		{
			//IL_00f3: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			_actionBarsCanvas = ((Component)((Component)this).transform.parent).GetComponent<Canvas>();
			LeftHotbarNav = ((Component)this).GetComponentInChildren<LeftHotbarNav>();
			_leftDisplay = ((Component)((Component)this).transform.Find("LeftDisplay")).GetComponent<RectTransform>();
			_baseHotbarCanvas = ((Component)((Component)this).transform.Find("BaseHotbarCanvas")).GetComponent<Canvas>();
			_baseGrid = ((Component)_baseHotbarCanvas).GetComponentsInChildren<GridLayoutGroup>().First((GridLayoutGroup g) => ((Object)g).name == "BaseHotbarGrid");
			_baseActionSlot = ((Component)((Component)_baseGrid).GetComponentInChildren<ActionSlot>()).gameObject;
			((Component)_baseHotbarCanvas).gameObject.SetActive(false);
			((Component)_baseGrid).gameObject.SetActive(false);
			_baseActionSlot.SetActive(false);
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				component.anchorMin = new Vector2(1f, 0f);
				component.anchorMax = new Vector2(1f, 0f);
				component.pivot = new Vector2(1f, 0f);
			}
		}

		internal void ResetCollections()
		{
			_hotbarGrid = (GridLayoutGroup[])(object)new GridLayoutGroup[0];
			_hotbars = new ActionSlot[0][];
			_actionSlots = new Dictionary<int, ActionSlot>();
		}

		internal void Resize(float hotbarWidth, float hotbarHeight)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			Rect rect = _leftDisplay.rect;
			component.SetSizeWithCurrentAnchors((Axis)0, hotbarWidth + ((Rect)(ref rect)).width);
			((Component)this).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, hotbarHeight);
		}

		internal void ConfigureHotbars(int barsAmount)
		{
			_hotbarGrid = (GridLayoutGroup[])(object)new GridLayoutGroup[barsAmount];
			_hotbars = new ActionSlot[barsAmount][];
		}

		internal void ConfigureActionSlots(int bar, int slotsAmount)
		{
			_hotbars[bar] = new ActionSlot[slotsAmount];
		}
	}
	public enum AxisDirections
	{
		None,
		Up,
		Down
	}
	public class KeyGroup
	{
		public List<KeyCode> Modifiers { get; set; } = new List<KeyCode>();


		public KeyCode KeyCode { get; set; }

		public AxisDirections AxisDirection { get; set; } = AxisDirections.None;

	}
	[UnityScriptComponent]
	public class HotkeyCaptureMenu : MonoBehaviour, ISettingsView
	{
		public delegate void OnKeysSelectedDelegate(int id, HotkeyCategories category, KeyGroup keyGroup);

		public delegate void OnClearPressedDelegate(int id, HotkeyCategories category);

		public GameObject Dialog;

		public Image BackPanel;

		public Button CloseButton;

		public Button ClearButton;

		public Text CaptureHotkeyMenuText;

		public HotbarsContainer Hotbars;

		private int _slotIndex;

		private HotkeyCategories _category;

		private KeyGroup _keyGroup = new KeyGroup();

		private bool _modifierUp = false;

		private Text _text;

		private bool _monitorKeys = false;

		private bool _isInit;

		private static Dictionary<KeyCode, string> MouseButtonNames = new Dictionary<KeyCode, string>
		{
			{
				(KeyCode)323,
				"LMB"
			},
			{
				(KeyCode)324,
				"RMB"
			},
			{
				(KeyCode)325,
				"MWheel"
			},
			{
				(KeyCode)326,
				"Mouse 3"
			},
			{
				(KeyCode)327,
				"Mouse 4"
			},
			{
				(KeyCode)328,
				"Mouse 5"
			}
		};

		private bool _mouseWheelActive => _category == HotkeyCategories.NextHotbar || _category == HotkeyCategories.PreviousHotbar;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		public bool IsShowing => ((Component)this).gameObject.activeSelf && _isInit;

		public event OnKeysSelectedDelegate OnKeysSelected;

		public event OnClearPressedDelegate OnClearPressed;

		private void Awake()
		{
			DebugLogger.Log("HotkeyCaptureDialog::Awake");
			_text = ((Component)this).GetComponentsInChildren<Text>().First((Text t) => ((Object)t).name.Equals("ContentText"));
			Hide(raiseEvent: false);
			_isInit = true;
		}

		private void Start()
		{
			DebugLogger.Log("HotkeyCaptureDialog::Start");
		}

		private void Update()
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: 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_00b2: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			if (!_monitorKeys && IsShowing && Input.GetKeyDown((KeyCode)27))
			{
				Hide();
			}
			else
			{
				if (!_monitorKeys)
				{
					return;
				}
				PropertyInfo property = typeof(Selectable).GetProperty("currentSelectionState", BindingFlags.Instance | BindingFlags.NonPublic);
				if (IsClosedOrClear())
				{
					return;
				}
				if (Input.anyKeyDown)
				{
					if (Input.GetKeyDown((KeyCode)27))
					{
						HideDialog();
						return;
					}
					foreach (KeyCode item in Enum.GetValues(typeof(KeyCode)).Cast<KeyCode>())
					{
						if (Input.GetKeyDown(item) && _keyGroup.KeyCode != item && !_keyGroup.Modifiers.Contains(item))
						{
							AddKeyCode(item);
							break;
						}
					}
				}
				if (Input.mouseScrollDelta.y > 0f && _mouseWheelActive)
				{
					AddKeyCode((KeyCode)325, AxisDirections.Up);
				}
				else if (Input.mouseScrollDelta.y < 0f && _mouseWheelActive)
				{
					AddKeyCode((KeyCode)325, AxisDirections.Down);
				}
				for (int i = 0; i < _keyGroup.Modifiers.Count; i++)
				{
					if (Input.GetKeyUp(_keyGroup.Modifiers[i]))
					{
						_modifierUp = true;
						break;
					}
				}
				if (Input.GetKeyUp(_keyGroup.KeyCode) || (_modifierUp && (int)_keyGroup.KeyCode != 0) || (!Mathf.Approximately(Input.mouseScrollDelta.y, 0f) && _mouseWheelActive))
				{
					try
					{
						this.OnKeysSelected?.Invoke(_slotIndex, _category, _keyGroup);
						Hotbars.Controller.ToggleHotkeyEdits(enabled: true);
					}
					catch (Exception ex)
					{
						Debug.LogException(ex);
					}
					HideDialog();
				}
			}
		}

		private bool IsClosedOrClear()
		{
			return ((Selectable)(object)ClearButton).GetSelectionState() == SelectableExtensions.SelectionState.Selected || ((Selectable)(object)ClearButton).GetSelectionState() == SelectableExtensions.SelectionState.Highlighted || ((Selectable)(object)ClearButton).GetSelectionState() == SelectableExtensions.SelectionState.Pressed || ((Selectable)(object)CloseButton).GetSelectionState() == SelectableExtensions.SelectionState.Selected || ((Selectable)(object)CloseButton).GetSelectionState() == SelectableExtensions.SelectionState.Highlighted || ((Selectable)(object)CloseButton).GetSelectionState() == SelectableExtensions.SelectionState.Pressed;
		}

		private void AddKeyCode(KeyCode key, AxisDirections axis = AxisDirections.None)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_003a: 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_0040: Invalid comparison between Unknown and I4
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected I4, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected I4, but got Unknown
			//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)
			//IL_0075: Invalid comparison between Unknown and I4
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrWhiteSpace(_text.text))
			{
				Text text = _text;
				text.text += "+";
			}
			KeyCode val = key;
			KeyCode val2 = val;
			if (val2 - 48 > 9)
			{
				switch (val2 - 303)
				{
				case 4:
				case 5:
				{
					_keyGroup.Modifiers = new List<KeyCode>
					{
						(KeyCode)307,
						(KeyCode)308
					};
					Text text4 = _text;
					text4.text += "Alt";
					return;
				}
				case 2:
				case 3:
				{
					_keyGroup.Modifiers = new List<KeyCode>
					{
						(KeyCode)305,
						(KeyCode)306
					};
					Text text3 = _text;
					text3.text += "Ctrl";
					return;
				}
				case 0:
				case 1:
				{
					_keyGroup.Modifiers = new List<KeyCode>
					{
						(KeyCode)303,
						(KeyCode)304
					};
					Text text2 = _text;
					text2.text += "Shift";
					return;
				}
				}
				if (val2 - 323 <= 6)
				{
					_keyGroup.Modifiers.Clear();
					_keyGroup.KeyCode = key;
					_keyGroup.AxisDirection = axis;
					_text.text = MouseButtonNames[key];
					if (axis != 0)
					{
						_text.text = "MW_" + axis;
					}
				}
				else
				{
					_keyGroup.KeyCode = key;
					Text text5 = _text;
					text5.text += ((object)(KeyCode)(ref key)).ToString();
				}
			}
			else
			{
				_keyGroup.KeyCode = key;
				Text text6 = _text;
				text6.text += key - 48;
			}
		}

		public void ClearPressed()
		{
			this.OnClearPressed?.Invoke(_slotIndex, _category);
			this.OnKeysSelected?.Invoke(_slotIndex, _category, new KeyGroup
			{
				KeyCode = (KeyCode)0
			});
			Hotbars.Controller.ToggleHotkeyEdits(enabled: true);
			HideDialog();
		}

		public void Show()
		{
			((Component)this).gameObject.SetActive(true);
			((Component)BackPanel).gameObject.SetActive(true);
			((Component)CaptureHotkeyMenuText).gameObject.SetActive(true);
			Dialog.SetActive(false);
			Hotbars.Controller.ToggleHotkeyEdits(enabled: true);
			OnShow?.TryInvoke();
		}

		public void ShowDialog(int slotIndex, HotkeyCategories category)
		{
			DebugLogger.Log($"Capturing Hotkey for slot index {slotIndex} in category {category}.");
			_modifierUp = false;
			_keyGroup.KeyCode = (KeyCode)0;
			_keyGroup.Modifiers.Clear();
			_keyGroup.AxisDirection = AxisDirections.None;
			_text.text = string.Empty;
			_slotIndex = slotIndex;
			_category = category;
			Dialog.SetActive(true);
			_monitorKeys = true;
		}

		public void HideDialog()
		{
			_slotIndex = 0;
			_modifierUp = false;
			_category = HotkeyCategories.None;
			_text.text = string.Empty;
			_keyGroup.KeyCode = (KeyCode)0;
			_keyGroup.Modifiers.Clear();
			Dialog.SetActive(false);
			_monitorKeys = false;
		}

		public void Hide()
		{
			Hide(raiseEvent: true);
		}

		private void Hide(bool raiseEvent)
		{
			Hotbars.Controller?.ToggleHotkeyEdits(enabled: false);
			if (_isInit)
			{
				HideDialog();
			}
			((Component)this).gameObject.SetActive(false);
			((Component)BackPanel).gameObject.SetActive(false);
			((Component)CaptureHotkeyMenuText).gameObject.SetActive(false);
			if (raiseEvent)
			{
				OnHide?.TryInvoke();
			}
		}

		private bool IsModifier(KeyCode keyCode)
		{
			//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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if (keyCode - 303 <= 5)
			{
				return true;
			}
			return false;
		}
	}
	[UnityScriptComponent]
	public class LeftHotbarNav : MonoBehaviour
	{
		public PlayerActionMenus PlayerMenu;

		public HotbarsContainer HotbarsContainer;

		private Button _nextButton;

		private Button _nextHotkeyButton;

		private Button _previousButton;

		private Button _previousHotkeyButton;

		private Text _barText;

		private Text _nextHotkeyText;

		private Text _previousHotkeyText;

		private GameObject _barHotkeyGo;

		private Button _hotkeyButton;

		private Text _hotkeyText;

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

		private Canvas _leftNavCanvas;

		private bool _isHidden;

		private bool _awake = false;

		private bool _inEditMode;

		private bool _inHotkeyEditMode;

		public bool InEditMode => _inEditMode;

		public bool InHotkeyEditMode => _inHotkeyEditMode;

		private IHotbarNavActions GetHotbarNavActions()
		{
			UnityServicesProvider unityServicesProvider = Psp.Instance?.GetServicesProvider(PlayerMenu.PlayerID);
			if (unityServicesProvider != null && unityServicesProvider.TryGetService<IHotbarNavActions>(out var service))
			{
				return service;
			}
			return null;
		}

		private void Awake()
		{
			SetComponents();
			SetBarText(string.Empty);
			SetNextHotkeyText(string.Empty);
			SetPreviousHotkeyText(string.Empty);
			SetHotkeyText(string.Empty);
			HookButtonEvents();
			_awake = true;
			ToggleActionSlotEditMode(enableEdits: false);
			ToggleHotkeyEditMode(enableEdits: false);
		}

		private void Update()
		{
			if (_inHotkeyEditMode || _inEditMode)
			{
				return;
			}
			IHotbarNavActions hotbarNavActions = GetHotbarNavActions();
			if (hotbarNavActions != null)
			{
				int hotbarIndex;
				if (hotbarNavActions.IsNextRequested())
				{
					HotbarsContainer.Controller.SelectNext();
				}
				else if (hotbarNavActions.IsPreviousRequested())
				{
					HotbarsContainer.Controller.SelectPrevious();
				}
				else if (hotbarNavActions.IsHotbarRequested(out hotbarIndex))
				{
					HotbarsContainer.Controller.SelectHotbar(hotbarIndex);
				}
			}
		}

		private void SetComponents()
		{
			GameObject gameObject = ((Component)((Component)this).transform.Find("BarNumber/NextHotbar")).gameObject;
			_nextButton = gameObject.GetComponentsInChildren<Button>().First((Button b) => ((Object)b).name.Equals("NextButton"));
			_nextHotkeyButton = gameObject.GetComponentsInChildren<Button>().First((Button b) => ((Object)b).name.Equals("HotkeyButton"));
			_nextHotkeyText = gameObject.GetComponentInChildren<Text>();
			GameObject gameObject2 = ((Component)((Component)this).transform.Find("BarNumber/PreviousHotbar")).gameObject;
			_previousButton = gameObject2.GetComponentsInChildren<Button>().First((Button b) => ((Object)b).name.Equals("PreviousButton"));
			_previousHotkeyButton = gameObject2.GetComponentsInChildren<Button>().First((Button b) => ((Object)b).name.Equals("HotkeyButton"));
			_previousHotkeyText = gameObject2.GetComponentInChildren<Text>();
			_barHotkeyGo = ((Component)((Component)this).transform.Find("BarNumber/BarHotkey")).gameObject;
			_hotkeyButton = _barHotkeyGo.GetComponentsInChildren<Button>().First((Button b) => ((Object)b).name.Equals("HotkeyButton"));
			_hotkeyText = _barHotkeyGo.GetComponentInChildren<Text>();
			GameObject gameObject3 = ((Component)((Component)this).transform.Find("BarNumber/BarIcon")).gameObject;
			_barText = gameObject3.GetComponentInChildren<Text>();
			_leftNavCanvas = ((Component)this).GetComponent<Canvas>();
		}

		public void Show()
		{
			_isHidden = false;
			((Behaviour)_leftNavCanvas).enabled = true;
		}

		public void Hide()
		{
			_isHidden = true;
			((Behaviour)_leftNavCanvas).enabled = false;
		}

		public void SetBarText(string text)
		{
			_barText.text = text;
		}

		public void SetNextHotkeyText(string text)
		{
			_nextHotkeyText.text = text;
		}

		public void SetPreviousHotkeyText(string text)
		{
			_previousHotkeyText.text = text;
		}

		public void SetHotkeyText(string text)
		{
			_hotkeyText.text = text;
			if (string.IsNullOrWhiteSpace(text) && _barHotkeyGo.activeSelf && !_inEditMode)
			{
				_barHotkeyGo.SetActive(false);
			}
			else if (!string.IsNullOrWhiteSpace(text) && !_barHotkeyGo.activeSelf)
			{
				_barHotkeyGo.SetActive(true);
			}
		}

		public void SetHotkeys(IEnumerable<string> hotbarTexts)
		{
			_hotbarHotkeys = hotbarTexts.ToList();
		}

		public void SelectHotbar(int barIndex)
		{
			_barText.text = (barIndex + 1).ToString();
			List<string> hotbarHotkeys = _hotbarHotkeys;
			SetHotkeyText((hotbarHotkeys != null && hotbarHotkeys.Count > barIndex) ? _hotbarHotkeys[barIndex] : string.Empty);
		}

		public void ToggleActionSlotEditMode(bool enableEdits)
		{
			if (_awake)
			{
				_inEditMode = enableEdits;
				((Component)_nextButton).gameObject.SetActive(enableEdits);
				((Component)_previousButton).gameObject.SetActive(enableEdits);
				ToggleShowHide(enableEdits);
			}
		}

		public void ToggleHotkeyEditMode(bool enableEdits)
		{
			if (!_awake)
			{
				return;
			}
			_inHotkeyEditMode = enableEdits;
			Button nextHotkeyButton = _nextHotkeyButton;
			if (nextHotkeyButton != null)
			{
				GameObject gameObject = ((Component)nextHotkeyButton).gameObject;
				if (gameObject != null)
				{
					gameObject.SetActive(enableEdits);
				}
			}
			Button previousHotkeyButton = _previousHotkeyButton;
			if (previousHotkeyButton != null)
			{
				GameObject gameObject2 = ((Component)previousHotkeyButton).gameObject;
				if (gameObject2 != null)
				{
					gameObject2.SetActive(enableEdits);
				}
			}
			Button hotkeyButton = _hotkeyButton;
			if (hotkeyButton != null)
			{
				GameObject gameObject3 = ((Component)hotkeyButton).gameObject;
				if (gameObject3 != null)
				{
					gameObject3.SetActive(enableEdits);
				}
			}
			if (enableEdits)
			{
				GameObject barHotkeyGo = _barHotkeyGo;
				if (barHotkeyGo != null)
				{
					barHotkeyGo.SetActive(true);
				}
			}
			else if (!enableEdits)
			{
				Text hotkeyText = _hotkeyText;
				if (string.IsNullOrWhiteSpace((hotkeyText != null) ? hotkeyText.text : null))
				{
					GameObject barHotkeyGo2 = _barHotkeyGo;
					if (barHotkeyGo2 != null)
					{
						barHotkeyGo2.SetActive(false);
					}
				}
			}
			ToggleShowHide(enableEdits);
		}

		private void ToggleShowHide(bool editsEnabled)
		{
			if (editsEnabled)
			{
				((Behaviour)_leftNavCanvas).enabled = true;
			}
			else if (!editsEnabled && _isHidden)
			{
				((Behaviour)_leftNavCanvas).enabled = false;
			}
		}

		private void HookButtonEvents()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			((UnityEvent)_nextButton.onClick).AddListener((UnityAction)delegate
			{
				HotbarsContainer.Controller.SelectNext();
			});
			((UnityEvent)_previousButton.onClick).AddListener((UnityAction)delegate
			{
				HotbarsContainer.Controller.SelectPrevious();
			});
			((UnityEvent)_nextHotkeyButton.onClick).AddListener((UnityAction)delegate
			{
				PlayerMenu.MainSettingsMenu.HotkeyCaptureMenu.ShowDialog(0, HotkeyCategories.NextHotbar);
			});
			((UnityEvent)_previousHotkeyButton.onClick).AddListener((UnityAction)delegate
			{
				PlayerMenu.MainSettingsMenu.HotkeyCaptureMenu.ShowDialog(1, HotkeyCategories.PreviousHotbar);
			});
			((UnityEvent)_hotkeyButton.onClick).AddListener((UnityAction)delegate
			{
				PlayerMenu.MainSettingsMenu.HotkeyCaptureMenu.ShowDialog(HotbarsContainer.SelectedHotbar, HotkeyCategories.Hotbar);
			});
		}
	}
	public enum ActionSettingsMenus
	{
		Settings,
		ActionSlots,
		EquipmentSets,
		ProfileName,
		HotkeyCapture,
		UIPosition,
		Stash
	}
	[UnityScriptComponent]
	public class MainSettingsMenu : MonoBehaviour, IActionMenu
	{
		public PlayerActionMenus PlayerMenu;

		public SettingsView SettingsView;

		public HotbarSettingsView HotbarSettingsView;

		public HotkeyCaptureMenu HotkeyCaptureMenu;

		public UIPositionScreen UIPositionScreen;

		public EquipmentSetsSettingsView EquipmentSetsSettingsView;

		public StorageSettingsView StorageSettingsView;

		public Toggle SettingsViewToggle;

		public Toggle HotbarViewToggle;

		public Toggle EquipmentSetViewToggle;

		public Toggle StashViewToggle;

		private Dictionary<ActionSettingsMenus, ISettingsView> _menus;

		private Dictionary<ActionSettingsMenus, ISettingsView> _settingsViews;

		private SelectableTransitions[] _selectables;

		private bool _isInit;

		public bool IsShowing => ((Component)this).gameObject.activeSelf || HotkeyCaptureMenu.IsShowing || UIPositionScreen.IsShowing;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		public bool MenuItemSelected => _selectables != null && _selectables.Any((SelectableTransitions s) => s.Selected);

		private void Awake()
		{
			DebugLogger.Log("MainSettingsMenu::Awake");
			_menus = new Dictionary<ActionSettingsMenus, ISettingsView>();
			_menus.Add(ActionSettingsMenus.Settings, SettingsView);
			_menus.Add(ActionSettingsMenus.ActionSlots, HotbarSettingsView);
			_menus.Add(ActionSettingsMenus.EquipmentSets, EquipmentSetsSettingsView);
			_menus.Add(ActionSettingsMenus.HotkeyCapture, HotkeyCaptureMenu);
			_menus.Add(ActionSettingsMenus.UIPosition, UIPositionScreen);
			_menus.Add(ActionSettingsMenus.Stash, StorageSettingsView);
			_settingsViews = new Dictionary<ActionSettingsMenus, ISettingsView>
			{
				{
					ActionSettingsMenus.Settings,
					SettingsView
				},
				{
					ActionSettingsMenus.ActionSlots,
					HotbarSettingsView
				},
				{
					ActionSettingsMenus.EquipmentSets,
					EquipmentSetsSettingsView
				},
				{
					ActionSettingsMenus.Stash,
					StorageSettingsView
				}
			};
			((UnityEvent<bool>)(object)SettingsViewToggle.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				ShowMenu(ActionSettingsMenus.Settings);
			});
			((UnityEvent<bool>)(object)HotbarViewToggle.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				ShowMenu(ActionSettingsMenus.ActionSlots);
			});
			((UnityEvent<bool>)(object)EquipmentSetViewToggle.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				ShowMenu(ActionSettingsMenus.EquipmentSets);
			});
			((UnityEvent<bool>)(object)StashViewToggle.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				ShowMenu(ActionSettingsMenus.Stash);
			});
			_selectables = ((Component)this).GetComponentsInChildren<SelectableTransitions>();
		}

		private void Start()
		{
			DebugLogger.Log("MainSettingsMenu::Start");
			if (!_isInit)
			{
				Hide(raiseEvent: false);
			}
			_isInit = true;
		}

		public void Show()
		{
			DebugLogger.Log("MainSettingsMenu::Show");
			((Component)this).gameObject.SetActive(true);
			OnShow?.TryInvoke();
			if (HotbarViewToggle.isOn)
			{
				ShowMenu(ActionSettingsMenus.ActionSlots);
			}
			else if (EquipmentSetViewToggle.isOn)
			{
				ShowMenu(ActionSettingsMenus.EquipmentSets);
			}
			else if (StashViewToggle.isOn)
			{
				ShowMenu(ActionSettingsMenus.Stash);
			}
			else
			{
				ShowMenu(ActionSettingsMenus.Settings);
			}
		}

		public void Hide()
		{
			Hide(raiseEvent: true);
		}

		private void Hide(bool raiseEvent)
		{
			DebugLogger.Log("MainSettingsMenu::Hide");
			IEnumerable<ISettingsView> enumerable = from kvp in _menus
				where kvp.Value.IsShowing && !_settingsViews.ContainsKey(kvp.Key)
				select kvp.Value;
			bool flag = false;
			foreach (ISettingsView item in enumerable)
			{
				item.Hide();
				flag = true;
			}
			DebugLogger.Log($"MainSettingsMenu::Hide: hideMenus.Count == {enumerable?.Count()}");
			if (!flag && ((Component)this).gameObject.activeSelf)
			{
				DebugLogger.Log("MainSettingsMenu::Hide: SetActive(false)");
				((Component)this).gameObject.SetActive(false);
				if (raiseEvent)
				{
					OnHide?.TryInvoke();
				}
			}
		}

		public void ShowMenu(ActionSettingsMenus menuType)
		{
			_menus[menuType].Show();
			IEnumerable<ISettingsView> enumerable = from kvp in _menus
				where kvp.Key != menuType
				select kvp.Value;
			foreach (ISettingsView item in enumerable)
			{
				try
				{
					item.Hide();
				}
				catch (Exception ex)
				{
					Debug.LogError((object)$"Failed to hide menu type {menuType}. Disabling menu.");
					Debug.LogException(ex);
					MonoBehaviour val = (MonoBehaviour)((item is MonoBehaviour) ? item : null);
					if (val != null)
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}
		}
	}
	[UnityScriptComponent]
	public class MouseClickListener : MonoBehaviour, IPointerClickHandler, IEventSystemHandler, IPointerDownHandler, IPointerEnterHandler, IPointerExitHandler
	{
		public UnityEvent OnLeftClick = new UnityEvent();

		public UnityEvent OnRightClick = new UnityEvent();

		public UnityEvent OnMiddleClick = new UnityEvent();

		private bool _isPointerOver;

		private float _lastMiddleClickInvokeTime;

		private const float MiddleClickDebounceSeconds = 0.08f;

		private void Update()
		{
			if ((_isPointerOver || IsPointerInsideSelf()) && (Input.GetMouseButtonDown(2) || Input.GetKeyDown((KeyCode)325)))
			{
				InvokeMiddleClick();
			}
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 0)
			{
				UnityEvent onLeftClick = OnLeftClick;
				if (onLeftClick != null)
				{
					onLeftClick.Invoke();
				}
			}
			else if ((int)eventData.button == 1)
			{
				UnityEvent onRightClick = OnRightClick;
				if (onRightClick != null)
				{
					onRightClick.Invoke();
				}
			}
			else if ((int)eventData.button == 2)
			{
				InvokeMiddleClick();
			}
		}

		public void OnPointerDown(PointerEventData eventData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 2)
			{
				InvokeMiddleClick();
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_isPointerOver = true;
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			_isPointerOver = false;
		}

		private void InvokeMiddleClick()
		{
			if (!(Time.unscaledTime - _lastMiddleClickInvokeTime < 0.08f))
			{
				_lastMiddleClickInvokeTime = Time.unscaledTime;
				UnityEvent onMiddleClick = OnMiddleClick;
				if (onMiddleClick != null)
				{
					onMiddleClick.Invoke();
				}
			}
		}

		private bool IsPointerInsideSelf()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val == null)
			{
				return false;
			}
			Camera val2 = null;
			Canvas componentInParent = ((Component)this).GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode > 0)
			{
				val2 = componentInParent.worldCamera;
			}
			return RectTransformUtility.RectangleContainsScreenPoint(val, Vector2.op_Implicit(Input.mousePosition), val2);
		}
	}
	[UnityScriptComponent]
	public class PlayerActionMenus : MonoBehaviour
	{
		private int _playerID = -1;

		public MainSettingsMenu MainSettingsMenu;

		public DurabilityDisplay DurabilityDisplay;

		public EquipmentSetMenu EquipmentSetMenus;

		public ActionsViewer ActionsViewer;

		private UnityServicesProvider _servicesProvider;

		private IActionMenu[] _actionMenus;

		private MenuNavigationActions _navActions;

		private bool _isAwake = false;

		private bool _isPlayerAssigned = false;

		private static readonly UnityEvent<PlayerActionMenus> _onPlayerIdAssigned = new UnityEvent<PlayerActionMenus>();

		public int PlayerID => _playerID;

		public UnityServicesProvider ServicesProvider => _servicesProvider;

		public MenuNavigationActions NavActions => _navActions;

		public bool IsPlayerAssigned => _isPlayerAssigned;

		public static UnityEvent<PlayerActionMenus> OnPlayerIdAssigned => _onPlayerIdAssigned;

		public void SetIDs(int playerID)
		{
			_playerID = playerID;
			_servicesProvider = Psp.Instance.GetServicesProvider(playerID);
			IPositionsProfileService service = _servicesProvider.GetService<IPositionsProfileService>();
			PositionableUI[] positionableUIs = GetPositionableUIs();
			PositionableUI[] array = positionableUIs;
			foreach (PositionableUI positionableUI in array)
			{
				positionableUI.SetPositionsService(service);
			}
			_isPlayerAssigned = true;
			_onPlayerIdAssigned.Invoke(this);
		}

		public PositionableUI[] GetPositionableUIs()
		{
			return ((Component)((Component)this).transform.parent).GetComponentsInChildren<PositionableUI>(true);
		}

		private void Awake()
		{
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			Transform[] componentsInChildren = ((Component)this).GetComponentsInChildren<Transform>(true);
			Transform[] array = componentsInChildren;
			foreach (Transform val in array)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).gameObject != (Object)null && ((Object)val).name.Contains("SkillChain"))
				{
					DebugLogger.Log("Destroying persistent SkillChain object: " + ((Object)val).name);
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			_actionMenus = ((Component)this).GetComponentsInChildren<IActionMenu>(true);
			for (int j = 0; j < _actionMenus.Length; j++)
			{
				DebugLogger.Log($"_actionMenus[{j}] == null == {_actionMenus[j] == null}. _actionMenus[{j}].OnShow == null == {_actionMenus[j]?.OnShow == null}");
				int menuIndex = j;
				_actionMenus[j].OnShow.AddListener((UnityAction)delegate
				{
					OnShowMenu(menuIndex);
				});
				_actionMenus[j].OnHide.AddListener(new UnityAction(OnHideMenu));
			}
			_isAwake = true;
		}

		private void Update()
		{
			if (_navActions == null)
			{
				return;
			}
			Func<bool> cancel = _navActions.Cancel;
			if (cancel == null || !cancel())
			{
				return;
			}
			for (int i = 0; i < _actionMenus.Length; i++)
			{
				if (_actionMenus[i].IsShowing)
				{
					_actionMenus[i].Hide();
				}
			}
		}

		public void ConfigureNavigation(MenuNavigationActions navActions)
		{
			_navActions = navActions;
		}

		public bool AnyActionMenuShowing()
		{
			return _isAwake && _actionMenus.Any((IActionMenu m) => m.IsShowing);
		}

		private void OnShowMenu(int menuIndex)
		{
			for (int i = 0; i < _actionMenus.Length; i++)
			{
				if (i != menuIndex && _actionMenus[i].IsShowing)
				{
					_actionMenus[i].Hide();
				}
			}
		}

		private void OnHideMenu()
		{
		}
	}
	[UnityScriptComponent]
	public class PositionableUI : MonoBehaviour, IDragHandler, IEventSystemHandler, IBeginDragHandler, IEndDragHandler
	{
		public Image BackgroundImage;

		public Button ResetButton;

		private UIPosition _originPosition;

		private bool _positioningEnabled = false;

		private IPositionsProfileService _positionsProfileService;

		private bool profileChangeEventNeeded = false;

		private bool _buttonInit;

		private bool _raycasterAdded;

		private bool _canvasAdded;

		private Vector2 _startPosition;

		private bool _startPositionSet;

		private Vector2 _logicalPosition;

		private bool _logicalPositionInit = false;

		private Vector2 _offset;

		public string TransformPath => ((Component)this).transform.GetPath();

		public string NormalizedTransformPath => ((Component)this).transform.GetNormalizedPath();

		public RectTransform RectTransform => ((Component)this).GetComponent<RectTransform>();

		public UIPosition OriginPosition => _originPosition;

		public bool HasMoved => _startPositionSet && (!Mathf.Approximately(StartPosition.x, RectTransform.anchoredPosition.x) || !Mathf.Approximately(StartPosition.y, RectTransform.anchoredPosition.y));

		public UnityEvent<bool> OnIsPositionableChanged { get; private set; } = new UnityEvent<bool>();


		public bool IsPositionable => _positioningEnabled;

		public Vector2 StartPosition
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _startPosition;
			}
			private set
			{
				//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)
				_startPosition = value;
				_startPositionSet = true;
			}
		}

		public Vector2 DynamicOffset { get; set; } = Vector2.zero;


		public UnityEvent<PositionableUI> UIElementMoved { get; } = new UnityEvent<PositionableUI>();


		private void InitializeLogicalPosition()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!_logicalPositionInit)
			{
				_logicalPosition = RectTransform.anchoredPosition;
				_logicalPositionInit = true;
			}
		}

		private void Start()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			InitializeLogicalPosition();
			if ((Object)(object)ResetButton != (Object)null && !_buttonInit)
			{
				((UnityEvent)ResetButton.onClick).AddListener(new UnityAction(ResetToOrigin));
				_buttonInit = true;
			}
			if (_originPosition == null)
			{
				_originPosition = RectTransform.ToRectTransformPosition();
			}
			StartPosition = new Vector2(RectTransform.anchoredPosition.x, RectTransform.anchoredPosition.y);
			_logicalPosition = StartPosition;
			if (_positionsProfileService != null)
			{
				SetPositionFromProfile(_positionsProfileService.GetProfile());
			}
			if ((Object)(object)BackgroundImage != (Object)null)
			{
				((Component)BackgroundImage).gameObject.SetActive(_positioningEnabled);
			}
		}

		private void Update()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (_logicalPositionInit)
			{
				RectTransform.anchoredPosition = _logicalPosition + DynamicOffset;
			}
			if (profileChangeEventNeeded && _positionsProfileService != null)
			{
				profileChangeEventNeeded = false;
				DebugLogger.Log("[Debug  :ActionMenus] PositionableUI{" + ((Object)this).name + "}::Update: Adding OnProfileChanged listener.");
				_positionsProfileService.OnProfileChanged += OnProfileChanged;
			}
		}

		public void SetPositionsService(IPositionsProfileService positionsProfileService)
		{
			_positionsProfileService = positionsProfileService;
			profileChangeEventNeeded = true;
			if (_positionsProfileService != null)
			{
				DebugLogger.Log("[Debug  :ActionMenus] PositionableUI{" + ((Object)this).name + "}::SetPositionsService: Adding OnProfileChanged listener.");
				_positionsProfileService.OnProfileChanged += OnProfileChanged;
				profileChangeEventNeeded = false;
				SetPositionFromProfile(_positionsProfileService.GetProfile());
			}
		}

		public void EnableMovement()
		{
			_positioningEnabled = true;
			if ((Object)(object)BackgroundImage != (Object)null)
			{
				((Component)BackgroundImage).gameObject.SetActive(_positioningEnabled);
			}
			Canvas component = ((Component)this).gameObject.GetComponent<Canvas>();
			if ((Object)(object)component == (Object)null)
			{
				((Component)this).gameObject.AddComponent<Canvas>();
				_canvasAdded = true;
			}
			GraphicRaycaster component2 = ((Component)this).GetComponent<GraphicRaycaster>();
			if ((Object)(object)component2 == (Object)null)
			{
				((Component)this).gameObject.AddComponent<GraphicRaycaster>();
				_raycasterAdded = true;
			}
			OnIsPositionableChanged.Invoke(_positioningEnabled);
		}

		public void DisableMovement()
		{
			_positioningEnabled = false;
			if ((Object)(object)BackgroundImage != (Object)null)
			{
				((Component)BackgroundImage).gameObject.SetActive(_positioningEnabled);
			}
			if (_raycasterAdded)
			{
				GraphicRaycaster component = ((Component)this).GetComponent<GraphicRaycaster>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				_raycasterAdded = false;
			}
			if (_canvasAdded)
			{
				Canvas component2 = ((Component)this).gameObject.GetComponent<Canvas>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.Destroy((Object)(object)component2);
				}
				_canvasAdded = false;
			}
			OnIsPositionableChanged.Invoke(_positioningEnabled);
		}

		public void SetPosition(float x, float y)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			InitializeLogicalPosition();
			_logicalPosition = new Vector2(x, y);
			RectTransform.anchoredPosition = _logicalPosition + DynamicOffset;
		}

		public void SetPosition(UIPosition position)
		{
			SetPosition(position.AnchoredPosition.X, position.AnchoredPosition.Y);
		}

		public bool SetPositionFromProfile(PositionsProfile profile)
		{
			if (profile == null)
			{
				return false;
			}
			string normalizedPath = NormalizedTransformPath;
			UIPositions uIPositions = profile.Positions?.FirstOrDefault((UIPositions p) => TransformExtensions.NormalizePath(p.TransformPath) == normalizedPath);
			if (uIPositions != null)
			{
				DebugLogger.Log($"[Debug  :ActionMenus] PositionableUI{{{((Object)this).name}}}: Setting position of PositionableUI {((Object)this).name} to modified position of ({uIPositions.ModifiedPosition.AnchoredPosition.X}, {uIPositions.ModifiedPosition.AnchoredPosition.Y}).");
				SetPosition(uIPositions.ModifiedPosition);
				return true;
			}
			return false;
		}

		private void OnProfileChanged(PositionsProfile profile)
		{
			DebugLogger.Log("[Debug  :ActionMenus] PositionableUI{" + ((Object)this).name + "}: OnProfileChanged for PositionableUI " + ((Object)this).name + ".");
			SetPositionFromProfile(profile);
		}

		public void ResetToOrigin()
		{
			if (_originPosition != null)
			{
				DebugLogger.Log($"[Debug  :ActionMenus] PositionableUI{{{((Object)this).name}}}: Setting position of PositionableUI {((Object)this).name} to origin position of ({_originPosition.AnchoredPosition.X}, {_originPosition.AnchoredPosition.Y}).");
				SetPosition(_originPosition);
			}
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_004e: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			if (_positioningEnabled)
			{
				((Component)this).transform.position = Vector2.op_Implicit(new Vector2(Input.mousePosition.x, Input.mousePosition.y) - _offset);
				_logicalPosition = RectTransform.anchoredPosition - DynamicOffset;
			}
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0043: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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)
			if (_positioningEnabled)
			{
				DebugLogger.Log("Dragging started.");
				if (_originPosition == null)
				{
					_originPosition = RectTransform.ToRectTransformPosition();
				}
				InitializeLogicalPosition();
				StartPosition = _logicalPosition;
				_offset = eventData.position - new Vector2(((Transform)RectTransform).position.x, ((Transform)RectTransform).position.y);
			}
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			if (_positioningEnabled)
			{
				if (HasMoved)
				{
					UIElementMoved?.TryInvoke(this);
				}
				DebugLogger.Log("Dragging Done.");
			}
		}

		public UIPositions GetUIPositions()
		{
			return new UIPositions
			{
				ModifiedPosition = RectTransform.ToRectTransformPosition(),
				OriginPosition = _originPosition,
				TransformPath = ((Component)this).transform.GetNormalizedPath()
			};
		}
	}
	[UnityScriptComponent]
	public class ProgressBar : DynamicColorImage
	{
		public Image Frame;

		public override void SetValue(float value)
		{
			//IL_000f: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			base.SetValue(value);
			if (((Graphic)Image).color != ((Graphic)Frame).color)
			{
				((Graphic)Frame).color = ((Graphic)Image).color;
			}
			Image.fillAmount = value;
		}

		protected override void OnAwake()
		{
		}
	}
	[UnityScriptComponent]
	public class Psp : MonoBehaviour
	{
		private ConcurrentDictionary<int, UnityServicesProvider> services;

		public static Psp Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			services = new ConcurrentDictionary<int, UnityServicesProvider>();
		}

		public UnityServicesProvider GetServicesProvider(int playerId)
		{
			return services.GetOrAdd(playerId, new UnityServicesProvider());
		}

		public bool TryGetServicesProvider(int playerId, out UnityServicesProvider usp)
		{
			return services.TryGetValue(playerId, out usp);
		}

		public bool TryDisposeServicesProvider(int playerId)
		{
			if (services.TryGetValue(playerId, out var value))
			{
				try
				{
					value.Dispose();
				}
				catch (Exception ex)
				{
					Debug.LogError((object)string.Format("ActionUI: Dispose of {0} for playerID {1} failed.", "UnityServicesProvider", playerId));
					Debug.LogException(ex);
				}
			}
			UnityServicesProvider value2;
			return services.TryRemove(playerId, out value2);
		}
	}
	[UnityScriptComponent]
	public class SelectableTransitions : MonoBehaviour, ISelectHandler, IEventSystemHandler, IDeselectHandler
	{
		public Image SelectImage;

		private Selectable _selectable;

		private bool _selected;

		public Selectable Selectable => _selectable;

		public SelectableExtensions.SelectionState SelectionState => _selectable?.GetSelectionState() ?? SelectableExtensions.SelectionState.Normal;

		public bool Selected => _selected;

		public event Action<SelectableTransitions> OnSelected;

		public event Action<SelectableTransitions> OnDeselected;

		private void Awake()
		{
			_selectable = ((Component)this).GetComponent<Selectable>();
		}

		private void Start()
		{
			if ((Object)(object)SelectImage != (Object)null)
			{
				((Behaviour)SelectImage).enabled = _selected;
			}
		}

		public void OnSelect(BaseEventData eventData)
		{
			if ((Object)(object)SelectImage != (Object)null)
			{
				((Behaviour)SelectImage).enabled = true;
			}
			_selected = true;
			this.OnSelected?.Invoke(this);
		}

		public void OnDeselect(BaseEventData eventData)
		{
			if ((Object)(object)SelectImage != (Object)null)
			{
				((Behaviour)SelectImage).enabled = false;
			}
			_selected = false;
			this.OnDeselected?.Invoke(this);
		}
	}
	[UnityScriptComponent]
	public class EquipmentSetsSettingsView : MonoBehaviour, ISettingsView
	{
		public Toggle ArmorSetsCombat;

		public Toggle SkipWeaponAnimation;

		public Toggle EquipFromStash;

		public Toggle StashEquipAnywhere;

		public Toggle UnequipToStash;

		public Toggle StashUnequipAnywhere;

		public MainSettingsMenu MainSettingsMenu;

		public bool IsShowing => ((Component)this).gameObject.activeSelf;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		private void Awake()
		{
		}

		private void Start()
		{
		}

		public void Show()
		{
			((Component)this).gameObject.SetActive(true);
			UnityEvent onShow = OnShow;
			if (onShow != null)
			{
				onShow.Invoke();
			}
		}

		public void Hide()
		{
			((Component)this).gameObject.SetActive(false);
		}
	}
	[UnityScriptComponent]
	public class HotbarSettingsView : MonoBehaviour, ISettingsView
	{
		[CompilerGenerated]
		private sealed class <CheckSetSelectedSetting>d__41 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HotbarSettingsView <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!<>4__this._selectables.Any((SelectableTransitions s) => s.Selected) && !<>4__this.MainSettingsMenu.MenuItemSelected && ((Component)<>4__this).gameObject.activeSelf && (Object)(object)<>4__this._lastSelected != (Object)null)
					{
						<>4__this._lastSelected.Select();
					}
					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 <SelectNextFrame>d__42 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Selectable selectable;

			public HotbarSettingsView <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					selectable.Select();
					return false;
				}
			}

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

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

		public UnityEvent<int> OnBarsChanged;

		public UnityEvent<int> OnRowsChanged;

		public UnityEvent<int> OnSlotsChanged;

		public MainSettingsMenu MainSettingsMenu;

		public HotkeyCaptureMenu HotkeyCaptureMenu;

		public ArrowInput BarAmountInput;

		public ArrowInput RowAmountInput;

		public ArrowInput SlotAmountInput;

		public Toggle ShowCooldownTimer;

		public Toggle ShowPrecisionTime;

		public Toggle HideLeftNav;

		public Toggle CombatMode;

		public Dropdown EmptySlotDropdown;

		public ArrowInput ScaleAmountInput;

		public Button SetHotkeys;

		public HotbarsContainer Hotbars;

		private bool _eventsAdded;

		private SelectableTransitions[] _selectables;

		private Selectable _lastSelected;

		public bool IsShowing => ((Component)this).gameObject.activeSelf;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		private IHotbarProfileService _hotbarService => MainSettingsMenu.PlayerMenu.ServicesProvider.GetService<IHotbarProfileService>();

		private IHotbarProfile _hotbarProfile => _hotbarService.GetProfile();

		private void Awake()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			((UnityEvent)SetHotkeys.onClick).AddListener(new UnityAction(EnableHotkeyEdits));
			_selectables = ((Component)this).GetComponentsInChildren<SelectableTransitions>();
			for (int i = 0; i < _selectables.Length; i++)
			{
				_selectables[i].OnSelected += SettingSelected;
				_selectables[i].OnDeselected += SettingDeselected;
			}
		}

		private void Start()
		{
			if (!_eventsAdded)
			{
				HookControls();
				_eventsAdded = true;
			}
		}

		public void Show()
		{
			DebugLogger.Log("HotbarSettingsViewer::Show");
			((Component)this).gameObject.SetActive(true);
			SetControls();
			((MonoBehaviour)this).StartCoroutine(SelectNextFrame((Selectable)(object)MainSettingsMenu.HotbarViewToggle));
			UnityEvent onShow = OnShow;
			if (onShow != null)
			{
				onShow.Invoke();
			}
		}

		public void Hide()
		{
			Hide(raiseEvent: true);
		}

		private void Hide(bool raiseEvent)
		{
			DebugLogger.Log("HotbarSettingsViewer::Hide");
			((Component)this).gameObject.SetActive(false);
			if (raiseEvent)
			{
				UnityEvent onHide = OnHide;
				if (onHide != null)
				{
					onHide.Invoke();
				}
			}
		}

		private void SetControls()
		{
			IActionSlotConfig config = _hotbarProfile.Hotbars.First().Slots.First().Config;
			BarAmountInput.SetAmount(_hotbarProfile.Hotbars.Count);
			RowAmountInput.SetAmount(_hotbarProfile.Rows);
			SlotAmountInput.SetAmount(_hotbarProfile.SlotsPerRow);
			ScaleAmountInput.SetAmount(_hotbarProfile.Scale);
			ShowCooldownTimer.isOn = config?.ShowCooldownTime ?? false;
			ShowPrecisionTime.isOn = config?.PreciseCooldownTime ?? false;
			HideLeftNav.isOn = _hotbarProfile?.HideLeftNav ?? false;
			CombatMode.isOn = _hotbarProfile.CombatMode;
			if ((Object)(object)EmptySlotDropdown != (Object)null)
			{
				((Component)EmptySlotDropdown).gameObject.SetActive(false);
			}
		}

		private void HookControls()
		{
			BarAmountInput.OnValueChanged.AddListener((UnityAction<int>)delegate(int amount)
			{
				if (_hotbarProfile.Hotbars.Count < amount)
				{
					_hotbarService.AddHotbar();
				}
				else if (_hotbarProfile.Hotbars.Count > amount)
				{
					_hotbarService.RemoveHotbar();
				}
			});
			RowAmountInput.OnValueChanged.AddListener((UnityAction<int>)delegate(int amount)
			{
				if (_hotbarProfile.Rows < amount)
				{
					_hotbarService.AddRow();
				}
				else if (_hotbarProfile.Rows > amount)
				{
					_hotbarService.RemoveRow();
				}
			});
			SlotAmountInput.OnValueChanged.AddListener((UnityAction<int>)delegate(int amount)
			{
				if (_hotbarProfile.SlotsPerRow < amount)
				{
					_hotbarService.AddSlot();
				}
				else if (_hotbarProfile.SlotsPerRow > amount)
				{
					_hotbarService.RemoveSlot();
				}
			});
			ScaleAmountInput.OnValueChanged.AddListener((UnityAction<int>)delegate(int amount)
			{
				_hotbarService.SetScale(amount);
			});
			((UnityEvent<bool>)(object)ShowCooldownTimer.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				_hotbarService.SetCooldownTimer(ShowCooldownTimer.isOn, ShowPrecisionTime.isOn);
			});
			((UnityEvent<bool>)(object)ShowPrecisionTime.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				_hotbarService.SetCooldownTimer(ShowCooldownTimer.isOn, ShowPrecisionTime.isOn);
			});
			((UnityEvent<bool>)(object)HideLeftNav.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				_hotbarService.SetHideLeftNav(HideLeftNav.isOn);
			});
			((UnityEvent<bool>)(object)CombatMode.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				_hotbarService.SetCombatMode(CombatMode.isOn);
			});
		}

		private void EnableHotkeyEdits()
		{
			HotkeyCaptureMenu.Show();
			((Component)MainSettingsMenu).gameObject.SetActive(false);
		}

		private void SettingSelected(SelectableTransitions transition)
		{
			DebugLogger.Log(((Object)transition).name + " Selected.");
			_lastSelected = transition.Selectable;
		}

		private void SettingDeselected(SelectableTransitions transition)
		{
			DebugLogger.Log(((Object)transition).name + " Deselected.");
			((MonoBehaviour)this).StartCoroutine(CheckSetSelectedSetting());
		}

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

		[IteratorStateMachine(typeof(<SelectNextFrame>d__42))]
		private IEnumerator SelectNextFrame(Selectable selectable)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SelectNextFrame>d__42(0)
			{
				<>4__this = this,
				selectable = selectable
			};
		}
	}
	[UnityScriptComponent]
	public class SettingsView : MonoBehaviour, ISettingsView
	{
		[CompilerGenerated]
		private sealed class <CheckSetSelectedSetting>d__30 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SettingsView <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!<>4__this._selectables.Any((SelectableTransitions s) => s.Selected) && !<>4__this.MainSettingsMenu.MenuItemSelected && ((Component)<>4__this).gameObject.activeSelf && (Object)(object)<>4__this._lastSelected != (Object)null)
					{
						<>4__this._lastSelected.Select();
					}
					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 <SelectNextFrame>d__31 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Selectable selectable;

			public SettingsView <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					selectable.Select();
					return false;
				}
			}

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

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

		public MainSettingsMenu MainSettingsMenu;

		public Toggle ActionSlotsToggle;

		public Toggle DurabilityToggle;

		public Toggle EquipmentSetsToggle;

		public Button MoveUIButton;

		public Button ResetUIButton;

		private SelectableTransitions[] _selectables;

		private Selectable _lastSelected;

		public bool IsShowing => ((Component)this).gameObject.activeSelf;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		private IActionUIProfileService _profileService => MainSettingsMenu.PlayerMenu.ServicesProvider.GetService<IActionUIProfileService>();

		private IActionUIProfile _profile => _profileService.GetActiveProfile();

		private void Awake()
		{
			_selectables = ((Component)this).GetComponentsInChildren<SelectableTransitions>();
			for (int i = 0; i < _selectables.Length; i++)
			{
				_selectables[i].OnSelected += SettingSelected;
				_selectables[i].OnDeselected += SettingDeselected;
			}
		}

		private void Start()
		{
			if ((Object)(object)DurabilityToggle != (Object)null && (Object)(object)((Component)DurabilityToggle).gameObject != (Object)null)
			{
				((Component)DurabilityToggle).gameObject.SetActive(false);
			}
			SetControls();
			HookControls();
		}

		public void Show()
		{
			DebugLogger.Log("SettingsView::Show");
			((Component)this).gameObject.SetActive(true);
			SetControls();
			((MonoBehaviour)this).StartCoroutine(SelectNextFrame((Selectable)(object)MainSettingsMenu.SettingsViewToggle));
			UnityEvent onShow = OnShow;
			if (onShow != null)
			{
				onShow.Invoke();
			}
		}

		public void Hide()
		{
			DebugLogger.Log("SettingsView::Hide");
			((Component)this).gameObject.SetActive(false);
			UnityEvent onHide = OnHide;
			if (onHide != null)
			{
				onHide.Invoke();
			}
		}

		private void SetControls()
		{
			ActionSlotsToggle.SetIsOnWithoutNotify(_profile?.ActionSlotsEnabled ?? false);
			if ((Object)(object)DurabilityToggle != (Object)null)
			{
				DurabilityToggle.SetIsOnWithoutNotify(_profile?.DurabilityDisplayEnabled ?? false);
			}
			EquipmentSetsToggle.SetIsOnWithoutNotify(_profile?.EquipmentSetsEnabled ?? false);
		}

		private void HookControls()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			((UnityEvent<bool>)(object)ActionSlotsToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
			{
				_profile.ActionSlotsEnabled = isOn;
				DebugLogger.Log($"Before ProfileService: isOn == {isOn}; ActionSlotsEnabled == {_profile.ActionSlotsEnabled}");
				IActionUIProfileService profileService = _profileService;
				DebugLogger.Log($"Before Save: isOn == {isOn}; ActionSlotsEnabled == {_profile.ActionSlotsEnabled}");
				profileService.Save();
				DebugLogger.Log($"After Save: isOn == {isOn}; ActionSlotsEnabled == {_profile.ActionSlotsEnabled}");
			});
			if ((Object)(object)DurabilityToggle != (Object)null)
			{
				((UnityEvent<bool>)(object)DurabilityToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
				{
					DebugLogger.Log($"DurabilityToggle changed from {!isOn} to {isOn}. Saving profile.");
					_profile.DurabilityDisplayEnabled = isOn;
					_profileService.Save();
				});
			}
			((UnityEvent<bool>)(object)EquipmentSetsToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
			{
				DebugLogger.Log($"EquipmentSetsToggle changed from {!isOn} to {isOn}. Saving profile.");
				_profile.EquipmentSetsEnabled = isOn;
				_profileService.Save();
			});
			((UnityEvent)MoveUIButton.onClick).AddListener(new UnityAction(ShowPositionScreen));
			((UnityEvent)ResetUIButton.onClick).AddListener(new UnityAction(ResetUIPositions));
		}

		private void ShowPositionScreen()
		{
			((Component)MainSettingsMenu).gameObject.SetActive(false);
			MainSettingsMenu.UIPositionScreen.Show();
		}

		private void ResetUIPositions()
		{
			PositionableUI[] positionableUIs = MainSettingsMenu.PlayerMenu.GetPositionableUIs();
			IPositionsProfileService service = MainSettingsMenu.PlayerMenu.ServicesProvider.GetService<IPositionsProfileService>();
			PositionsProfile profile = service.GetProfile();
			bool flag = false;
			DebugLogger.Log($"Checking {positionableUIs.Length} UI Element positons for changes.");
			PositionableUI[] array = positionableUIs;
			foreach (PositionableUI positionableUI in array)
			{
				positionableUI.ResetToOrigin();
				UIPositions uIPositions = positionableUI.GetUIPositions();
				if (positionableUI.HasMoved)
				{
					profile.AddOrReplacePosition(positionableUI.GetUIPositions());
					flag = true;
				}
			}
			if (flag)
			{
				service.Save();
			}
		}

		private void SettingSelected(SelectableTransitions transition)
		{
			DebugLogger.Log(((Object)transition).name + " Selected.");
			_lastSelected = transition.Selectable;
		}

		private void SettingDeselected(SelectableTransitions transition)
		{
			DebugLogger.Log(((Object)transition).name + " Deselected.");
			((MonoBehaviour)this).StartCoroutine(CheckSetSelectedSetting());
		}

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

		[IteratorStateMachine(typeof(<SelectNextFrame>d__31))]
		private IEnumerator SelectNextFrame(Selectable selectable)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SelectNextFrame>d__31(0)
			{
				<>4__this = this,
				selectable = selectable
			};
		}
	}
	[UnityScriptComponent]
	public class StorageSettingsView : MonoBehaviour, ISettingsView
	{
		public MainSettingsMenu MainSettingsMenu;

		public Toggle DisplayCurrencyToggle;

		public Toggle StashInventoryToggle;

		public Toggle StashInventoryAnywhereToggle;

		public Toggle MerchantStashToggle;

		public Toggle MerchantStashAnywhereToggle;

		public Toggle CraftFromStashToggle;

		public Toggle CraftFromStashAnywhereToggle;

		public Toggle PreserveFoodToggle;

		public InputField PreserveFoodAmount;

		public UnityEvent OnShow;

		public UnityEvent OnHide;

		public bool IsShowing => ((Component)this).gameObject.activeSelf;

		private void Awake()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (OnShow == null)
			{
				OnShow = new UnityEvent();
			}
			if (OnHide == null)
			{
				OnHide = new UnityEvent();
			}
		}

		private void Start()
		{
		}

		public void Show()
		{
			((Component)this).gameObject.SetActive(true);
			UnityEvent onShow = OnShow;
			if (onShow != null)
			{
				onShow.Invoke();
			}
		}

		public void Hide()
		{
			((Component)this).gameObject.SetActive(false);
			UnityEvent onHide = OnHide;
			if (onHide != null)
			{
				onHide.Invoke();
			}
		}
	}
	[UnityScriptComponent]
	public class SlotPanel : MonoBehaviour, IEventSystemHandler, IPointerEnterHandler, IPointerExitHandler
	{
		private Image _borderImage;

		private Image _borderHighlightImage;

		private bool _isAwake;

		public Image BorderImage => _borderImage;

		public Image ActionBorderHighlight => _borderHighlightImage;

		private void Awake()
		{
			_borderImage = ((Component)this).GetComponentsInChildren<Image>(true).First((Image i) => ((Object)i).name == "ActionBorder");
			_borderHighlightImage = ((Component)this).GetComponentsInChildren<Image>(true).First((Image i) => ((Object)i).name == "ActionBorderHighlight");
			((Behaviour)_borderHighlightImage).enabled = false;
			((Behaviour)_borderImage).enabled = true;
			_isAwake = true;
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (_isAwake)
			{
				((Behaviour)_borderHighlightImage).enabled = true;
				((Behaviour)_borderImage).enabled = false;
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			if (_isAwake)
			{
				((Behaviour)_borderHighlightImage).enabled = false;
				((Behaviour)_borderImage).enabled = true;
			}
		}
	}
	[UnityScriptComponent]
	public class UIPositionScreen : MonoBehaviour, ISettingsView
	{
		public MainSettingsMenu MainSettingsMenu;

		public Image BackPanel;

		public Text ExitScreenText;

		private bool _isInit;

		public UnityEvent OnShow { get; } = new UnityEvent();


		public UnityEvent OnHide { get; } = new UnityEvent();


		public bool IsShowing => ((Component)this).gameObject.activeSelf && _isInit;

		private void Awake()
		{
			DebugLogger.Log("UIPositionScreen::Awake");
			Hide(raiseEvent: false);
			_isInit = true;
		}

		private void Start()
		{
			DebugLogger.Log("UIPositionScreen::Start");
		}

		public void Show()
		{
			((Component)this).gameObject.SetActive(true);
			((Component)BackPanel).gameObject.SetActive(true);
			((Component)ExitScreenText).gameObject.SetActive(true);
			EnableUIPositioning();
			OnShow?.TryInvoke();
		}

		public void Hide()
		{
			Hide(raiseEvent: true);
		}

		private void Hide(bool raiseEvent)
		{
			DebugLogger.Log("UIPositionScreen::Hide");
			((Component)this).gameObject.SetActive(false);
			((Component)BackPanel).gameObject.SetActive(false);
			((Component)ExitScreenText).gameObject.SetActive(false);
			if (_isInit)
			{
				DisableAndSavePositions();
			}
			if (raiseEvent)
			{
				OnHide?.TryInvoke();
			}
		}

		private void EnableUIPositioning()
		{
			PositionableUI[] array = Object.FindObjectsOfType<PositionableUI>();
			PositionableUI[] array2 = array;
			foreach (PositionableUI positionableUI in array2)
			{
				positionableUI.EnableMovement();
			}
		}

		private void DisableAndSavePositions()
		{
			PositionableUI[] array = Object.FindObjectsOfType<PositionableUI>();
			IPositionsProfileService service = MainSettingsMenu.PlayerMenu.ServicesProvider.GetService<IPositionsProfileService>();
			PositionsProfile profile = service.GetProfile();
			bool flag = false;
			DebugLogger.Log($"Checking {array.Length} UI Element positons for changes.");
			PositionableUI[] array2 = array;
			foreach (PositionableUI positionableUI in array2)
			{
				positionableUI.DisableMovement();
				UIPositions uIPositions = positionableUI.GetUIPositions();
				if (positionableUI.HasMoved)
				{
					profile.AddOrReplacePosition(positionableUI.GetUIPositions());
					DebugLogger.Log("Found position change for UI element '" + positionableUI.TransformPath + ".");
					flag = true;
				}
			}
			if (flag)
			{
				service.Save();
			}
		}
	}
	public class UnityServicesProvider : IDisposable
	{
		private readonly ConcurrentDictionary<Type, Delegate> _serviceFactories = new ConcurrentDictionary<Type, Delegate>();

		public static UnityServicesProvider _instance;

		private bool disposedValue;

		public static UnityServicesProvider Instance { get; private set; }

		private void Awake()
		{
			_instance = this;
		}

		public UnityServicesProvider AddSingleton<T>(T serviceInstance)
		{
			DebugLogger.Log($"Adding {typeof(T)} singleton to UnityServicesProvider.");
			_serviceFactories.TryAdd(typeof(T), (Func<T>)(() => serviceInstance));
			return this;
		}

		public UnityServicesProvider AddFactory<T>(Func<T> serviceFactory)
		{
			DebugLogger.Log($"Adding {typeof(T)} factory to UnityServicesProvider.");
			_serviceFactories.TryAdd(typeof(T), serviceFactory);
			return this;
		}

		public bool TryRemove<T>()
		{
			Delegate value;
			return _serviceFactories.TryRemove(typeof(T), out value);
		}

		public bool TryDispose<T>()
		{
			return TryDispose(typeof(T));
		}

		public bool TryDispose(Type typeKey)
		{
			bool flag = false;
			if (_serviceFactories.TryGetValue(typeKey, out var value))
			{
				try
				{
					object obj = value.DynamicInvoke();
					if (obj is IDisposable disposable)
					{
						disposable.Dispose();
						flag = true;
					}
				}
				catch (Exception ex)
				{
					Debug.LogError((object)$"ActionUI: Dispose of {typeKey} failed.");
					Debug.LogException(ex);
				}
			}
			Delegate value2;
			return _serviceFactories.TryRemove(typeKey, out value2) && flag;
		}

		public Func<T> GetServiceFactory<T>()
		{
			return (Func<T>)_serviceFactories[typeof(T)];
		}

		public T GetService<T>()
		{
			return (T)_serviceFactories[typeof(T)].DynamicInvoke();
		}

		public object GetService(Type type)
		{
			return _serviceFactories[type].DynamicInvoke();
		}

		public List<T> GetServices<T>()
		{
			return (from kvp in _serviceFactories
				where typeof(T).IsAssignableFrom(kvp.Key)
				select (T)kvp.Value.DynamicInvoke()).ToList();
		}

		public List<Func<T>> GetServiceFactories<T>()
		{
			return (from kvp in _serviceFactories
				where typeof(T).IsAssignableFrom(kvp.Key)
				select (Func<T>)kvp.Value).ToList();
		}

		public bool TryGetService<T>(out T service)
		{
			service = default(T);
			if (!_serviceFactories.TryGetValue(typeof(T), out var value))
			{
				return false;
			}
			service = (T)value.DynamicInvoke();
			return !EqualityComparer<T>.Default.Equals(service, default(T));
		}

		public bool ContainsService<T>()
		{
			return _serviceFactories.ContainsKey(typeof(T));
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				Type[] array = _serviceFactories.Keys.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					TryDispose(array[i]);
				}
			}
			disposedValue = true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	[UnityScriptComponent]
	public class ViewerLeftNav : MonoBehaviour
	{
		public GameObject BaseActionGo;

		private readonly Dictionary<int, GameObject> _viewTabs = new Dictionary<int, GameObject>();

		private int _tabCounter = 0;

		private int _lastSelectedId = 0;

		private void Awake()
		{
			BaseActionGo.SetActive(false);
		}

		public Button AddViewTab(string displayText)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(BaseActionGo, ((Component)this).transform);
			int tabId = _tabCounter;
			_viewTabs.Add(tabId, val);
			Button componentInChildren = val.GetComponentInChildren<Button>();
			((UnityEvent)componentInChildren.onClick).AddListener((UnityAction)delegate
			{
				ToggleViewTabs(tabId);
			});
			((Component)componentInChildren).GetComponentInChildren<Text>().text = displayText;
			val.SetActive(true);
			if (!_viewTabs.Any())
			{
				ToggleViewTabs(tabId);
			}
			else
			{
				ToggleViewTab(val, selected: false);
			}
			_tabCounter++;
			return val.GetComponent<Button>();
		}

		public void ClearViewTabs()
		{
			for (int i = 0; i < _viewTabs.Count; i++)
			{
				_viewTabs[i].Destroy();
			}
			_viewTabs.Clear();
			_tabCounter = 0;
			_lastSelectedId = 0;
		}

		public void ClickSelectedTab()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			if (_viewTabs.Any())
			{
				ExecuteEvents.Execute<ISubmitHandler>(_viewTabs[_lastSelectedId], (BaseEventData)new PointerEventData(EventSystem.current), ExecuteEvents.submitHandler);
			}
		}

		private void ToggleViewTabs(int selectedTabId)
		{
			if (!_viewTabs.ContainsKey(selectedTabId))
			{
				throw new ArgumentOutOfRangeException("selectedTabId");
			}
			foreach (KeyValuePair<int, GameObject> viewTab in _viewTabs)
			{
				ToggleViewTab(viewTab.Value, viewTab.Key == selectedTabId);
			}
			_lastSelectedId = selectedTabId;
		}

		private void ToggleViewTab(GameObject viewTab, bool selected)
		{
			//IL_0092: 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)
			Image[] componentsInChildren = viewTab.GetComponentsInChildren<Image>(true);
			Image val = componentsInChildren.First((Image i) => ((Object)i).name.Equals("ActiveImage"));
			Image val2 = componentsInChildren.First((Image i) => ((Object)i).name.Equals("InactiveImage"));
			Text componentInChildren = viewTab.GetComponentInChildren<Text>();
			((Component)val).gameObject.SetActive(selected);
			((Component)val2).gameObject.SetActive(!selected);
			if (selected)
			{
				((Graphic)componentInChildren).color = Color.white;
			}
			else
			{
				((Graphic)componentInChildren).color = Color.grey;
			}
		}
	}
}
namespace ModifAmorphic.Outward.Unity.ActionUI
{
	internal static class Timings
	{
		public const float StackDelay = 0.25f;

		public const float EnabledWait = 0.25f;

		public const float InteractiveWait = 0.25f;

		public const float CooldownWait = 0.05f;

		public const float ProgressBarWait = 1f;

		public const float DynamicIconWait = 0.1f;

		public const float DurabilityWait = 1f;
	}
	internal static class DebugLogger
	{
		public static void Log(string message)
		{
			Debug.Log((object)message);
		}
	}
	public class ActionSlotIcon
	{
		public string Name { get; set; }

		public Sprite Icon { get; set; }

		public bool IsTopSprite { get; set; }
	}
	public class ColorRange
	{
		public Color Color { get; set; }

		public float Min { get; set; }

		public float Max { get; set; }
	}
	public enum EquipSlots
	{
		None,
		Head,
		Chest,
		RightHand,
		LeftHand,
		Feet
	}
	public enum DurableEquipmentType
	{
		None,
		Helm,
		Chest,
		RangedWeapon,
		MeleeWeapon,
		Shield,
		Boots
	}
	public enum HotkeyCategories
	{
		None,
		ActionSlot,
		PreviousHotbar,
		NextHotbar,
		Hotbar
	}
	public interface IActionMenu
	{
		bool IsShowing { get; }

		UnityEvent OnShow { get; }

		UnityEvent OnHide { get; }

		void Hide();
	}
	public interface IActionsDisplayTab
	{
		string DisplayName { get; }

		int TabOrder { get; }

		IEnumerable<ISlotAction> GetSlotActions();
	}
	public interface IActionSlotConfig
	{
		string HotkeyText { get; set; }

		bool ShowCooldownTime { get; set; }

		bool PreciseCooldownTime { get; set; }

		bool ShowZeroStackAmount { get; set; }

		EmptySlotOptions EmptySlotOption { get; set; }

		bool IsDisabled { get; set; }

		bool IsDynamic { get; set; }
	}
	public enum EmptySlotOptions
	{
		Transparent,
		Image,
		Hidden
	}
	public interface IActionViewData
	{
		IEnumerable<ISlotAction> GetAllActions();

		IEnumerable<IActionsDisplayTab> GetActionsTabData();
	}
	public enum BarPositions
	{
		Top,
		Right,
		Bottom,
		Left
	}
	public interface IBarProgress
	{
		BarPositions BarPosition { get; }

		List<ColorRange> ColorRanges { get; }

		bool IsEnabled { get; }

		float GetProgress();
	}
	public interface ICooldown
	{
		bool HasCooldown { get; }

		bool GetIsInCooldown();

		float GetProgress();

		float GetSecondsRemaining();
	}
	public interface IDurability
	{
		DurableEquipmentType DurableEquipmentType { get; }

		EquipSlots DurableEquipmentSlot { get; }

		List<ColorRange> ColorRanges { get; }

		float MinimumDisplayValue { get; }

		float GetDurabilityRatio();
	}
	public interface IHotbarNavActions
	{
		bool IsNextRequested();

		bool IsPreviousRequested();

		bool IsHotbarRequested(out int hotbarIndex);
	}
	internal interface ISettingsView
	{
		bool IsShowing { get; }

		void Show();

		void Hide();
	}
	public interface ISlotAction
	{
		string DisplayName { get; }

		int ActionId { get; }

		string ActionUid { get; }

		ICooldown Cooldown { get; }

		IStackable Stack { get; }

		Dictionary<BarPositions, IBarProgress> ActiveBars { get; }

		bool HasDynamicIcon { get; }

		ActionSlotIcon[] ActionIcons { get; }

		bool CheckOnUpdate { get; }

		Action TargetAction { get; }

		event Action OnActionRequested;

		event Action OnEditRequested;

		event Action<ActionSlotIcon[]> OnIconsChanged;

		ActionSlotIcon[] GetDynamicIcons();

		bool GetIsActionRequested();

		bool GetEnabled();

		bool GetIsEditRequested();

		void SlotActionAssigned(ActionSlot assignedSlot);

		void SlotActionUnassigned();
	}
	public interface IStackable
	{
		bool IsStackable { get; }

		int GetAmount();
	}
	public class MenuNavigationActions
	{
		public Func<bool> MoveUp { get; set; }

		public Func<bool> MoveDown { get; set; }

		public Func<bool> MoveLeft { get; set; }

		public Func<bool> MoveRight { get; set; }

		public Func<bool> Cancel { get; set; }
	}
	public class UIPosition : IEquatable<UIPosition>
	{
		public UIPosition2D Position { get; set; }

		public UIPosition2D AnchoredPosition { get; set; }

		public UIPosition2D AnchoredMin { get; set; }

		public UIPosition2D AnchoredMax { get; set; }

		public UIPosition2D OffsetMin { get; set; }

		public UIPosition2D OffsetMax { get; set; }

		public UIPosition2D Pivot { get; set; }

		public bool Equals(UIPosition other)
		{
			if (other == null)
			{
				return false;
			}
			return AnchoredPosition.Equals(other.AnchoredPosition);
		}

		public override bool Equals(object obj)
		{
			if (obj == null || !(obj is UIPosition other))
			{
				return false;
			}
			return Equals(other);
		}

		public static bool operator ==(UIPosition pos1, UIPosition pos2)
		{
			if ((object)pos1 == null && (object)pos1 == null)
			{
				return true;
			}
			if ((object)pos1 == null || (object)pos2 == null)
			{
				return false;
			}
			return pos1.Equals(pos2);
		}

		public static bool operator !=(UIPosition pos1, UIPosition pos2)
		{
			if ((object)pos1 == null && (object)pos1 == null)
			{
				return false;
			}
			if ((object)pos1 == null || (object)pos2 == null)
			{
				return true;
			}
			return !pos1.Equals(pos2);
		}
	}
	public class UIPosition2D : IEquatable<UIPosition2D>
	{
		private const double upperDouble = 8.988465674311579E+307;

		public float X { get; set; }

		public float Y { get; set; }

		public bool Equals(UIPosition2D other)
		{
			if (other == null)
			{
				return false;
			}
			return Mathf.Approximately(X, other.X) && Mathf.Approximately(Y, other.Y);
		}

		public override bool Equals(object obj)
		{
			if (obj == null || !(obj is UIPosition2D other))
			{
				return false;
			}
			return Equals(other);
		}

		public static bool operator ==(UIPosition2D pos1, UIPosition2D pos2)
		{
			if ((object)pos1 == null && (object)pos1 == null)
			{
				return true;
			}
			if ((object)pos1 == null || (object)pos2 == null)
			{
				return false;
			}
			return pos1.Equals(pos2);
		}

		public static bool operator !=(UIPosition2D pos1, UIPosition2D pos2)
		{
			if ((object)pos1 == null && (object)pos1 == null)
			{
				return false;
			}
			if ((object)pos1 == null || (object)pos2 == null)
			{
				return true;
			}
			return !pos1.Equals(pos2);
		}

		public override int GetHashCode()
		{
			return GetHashCode(this);
		}

		public int GetHashCode(UIPosition2D uiPosition)
		{
			return ((double)uiPosition.X + 8.988465674311579E+307 + (double)uiPosition.Y).GetHashCode();
		}
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
	public class UnityScriptComponentAttribute : Attribute
	{
		public string ComponentPath { get; set; }
	}
}
namespace ModifAmorphic.Outward.Unity.ActionUI.Services
{
	internal class CooldownService : IDisposable
	{
		[CompilerGenerated]
		private sealed class <DisplayCooldown>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CooldownService <>4__this;

			private int <timeCeiling>5__1;

			private Color <bgColor>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_021c: Expected O, but got Unknown
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this._cooldown.GetIsInCooldown())
				{
					<>4__this._image.fillAmount = Mathf.Clamp01(<>4__this._cooldown.GetProgress());
					<timeCeiling>5__1 = Mathf.CeilToInt(<>4__this._cooldown.GetSecondsRemaining());
					if (<>4__this._showTime && (<timeCeiling>5__1 > 0 || <>4__this._isPreciseTime))
					{
						if (<>4__this._isPreciseTime && <>4__this._cooldown.GetSecondsRemaining() <= 9.9f)
						{
							<>4__this._text.text = <>4__this._cooldown.GetSecondsRemaining().ToString(<>4__this._timeFormat);
						}
						else
						{
							<>4__this._text.text = <timeCeiling>5__1.ToString();
						}
						if (((Graphic)<>4__this._controller.ActionSlot.CooldownTextBackground).color.a != 0.9f && !string.IsNullOrWhiteSpace(<>4__this._text.text))
						{
							<bgColor>5__2 = ((Graphic)<>4__this._controller.ActionSlot.CooldownTextBackground).color;
							<bgColor>5__2.a = 0.8f;
							((Graphic)<>4__this._controller.ActionSlot.CooldownTextBackground).color = <bgColor>5__2;
						}
					}
					<>4__this._hideNeeded = true;
				}
				else if (<>4__this._hideNeeded)
				{
					<>4__this._controller.HideCooldown();
					<>4__this._hideNeeded = false;
				}
				<>2__current = (object)new WaitForSeconds(0.05f);
				<>1__state = 1;
				return true;
			}

			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 ActionSlotController _controller;

		private ICooldown _cooldown;

		private Coroutine _coroutine;

		private bool _coroutineStarted = false;

		private bool _hideNeeded;

		private readonly Image _image;

		private readonly Text _text;

		private bool _showTime;

		private bool _isPreciseTime;

		private bool disposedValue;

		private string _timeFormat;

		public CooldownService(Image cooldownImage, Text cooldownText, bool showTime, bool isPreciseTime, ActionSlotController controller)
		{
			_image = cooldownImage;
			_text = cooldownText;
			_showTime = showTime;
			_isPreciseTime = isPreciseTime;
			_controller = controller;
			UpdateTimeFormat();
		}

		public void Configure(bool showTime, bool isPreciseTime)
		{
			bool showTime2 = showTime;
			bool isPreciseTime2 = isPreciseTime;
			_showTime = showTime2;
			_isPreciseTime = isPreciseTime2;
			UpdateTimeFormat();
		}

		public void TrackCooldown(ICooldown cooldown)
		{
			_cooldown = cooldown;
			if (_coroutine == null || !_coroutineStarted)
			{
				_coroutine = ((MonoBehaviour)_controller.ActionSlot).StartCoroutine(DisplayCooldown());
				_coroutineStarted = true;
			}
		}

		public void StopTracking()
		{
			if (_coroutine != null)
			{
				ActionSlot actionSlot = _controller.ActionSlot;
				if (actionSlot != null)
				{
					((MonoBehaviour)actionSlot).StopCoroutine(_coroutine);
				}
				_controller.HideCooldown();
			}
			_coroutineStarted = false;
		}

		private void UpdateTimeFormat()
		{
			_timeFormat = (_isPreciseTime ? "0.0" : "0");
		}

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

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

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

			private object <>2__current;

			public EnableToggleService <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this._getEnabled() || <>4__this._controller.ActionSlot.IsInEditMode)
				{
					<>4__this._controller.ToggleEnabled(enabled: true);
				}
				else
				{
					<>4__this._controller.ToggleEnabled(enabled: false);
				}
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 1;
				return true;
			}

			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 ActionSlotController _controller;

		private Func<bool> _getEnabled;

		private Coroutine _coroutine;

		private bool _coroutineStarted = false;

		private bool disposedValue;

		public EnableToggleService(ActionSlotController controller)
		{
			_controller = controller;
		}

		public void TrackEnableToggle(Func<bool> getEnabled)
		{
			_getEnabled = getEnabled;
			if (_coroutine == null || !_coroutineStarted)
			{
				_coroutine = ((MonoBehaviour)_controller.ActionSlot).StartCoroutine(ToggleActionSlot());
				_coroutineStarted = true;
			}
		}

		public void StopTracking()
		{
			if (_coroutine != null)
			{
				((MonoBehaviour)_controller.ActionSlot).StopCoroutine(_coroutine);
			}
			_coroutineStarted = false;
		}

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

		protected virtual void Dispose(bool disposing)
		{
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				ActionSlotController controller = _controller;
				if (controller != null)
				{
					ActionSlot actionSlot = controller.ActionSlot;
					if (actionSlot != null)
					{
						((MonoBehaviour)actionSlot).StopCoroutine(_coroutine);
					}
				}
			}
			disposedValue = true;
		}

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

			private object <>2__current;

			public InteractiveToggleService <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this._getInteractive() || <>4__this._controller.ActionSlot.IsInEditMode)
				{
					<>4__this._controller.ToggleInteractive(interactive: true);
				}
				else
				{
					<>4__this._controller.ToggleInteractive(interactive: false);
				}
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 1;
				return true;
			}

			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 ActionSlotController _controller;

		private Func<bool> _getInteractive;

		private Coroutine _coroutine;

		private bool _coroutineStarted = false;

		private bool disposedValue;

		public InteractiveToggleService(ActionSlotController controller)
		{
			_controller = controller;
		}

		public void TrackInteractiveToggle(Func<bool> getInteractive)
		{
			_getInteractive = getInteractive;
			if (_coroutine == null || !_coroutineStarted)
			{
				_coroutine = ((MonoBehaviour)_controller.ActionSlot).StartCoroutine(ToggleActionSlot());
				_coroutineStarted = true;
			}
		}

		public void StopTracking()
		{
			if (_coroutine != null)
			{
				((MonoBehaviour)_controller.ActionSlot).StopCoroutine(_coroutine);
			}
			_coroutineStarted = false;
		}

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

		protected virtual void Dispose(bool disposing)
		{
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				ActionSlotController controller = _controller;
				if (controller != null)
				{
					ActionSlot actionSlot = controller.ActionSlot;
					if (actionSlot != null)
					{
						((MonoBehaviour)actionSlot).StopCoroutine(_coroutine);
					}
				}
			}
			disposedValue = true;
		}

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

			private object <>2__current;

			public ProgressBarService <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<>4__this._bar.SetValue(<>4__this._barProgress.GetProgress());
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			}

			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 ActionSlotController _controller;

		private Coroutine _coroutine;

		private bool _coroutineStarted = false;

		private readonly ProgressBar _bar;

		private readonly BarPositions _barPosition;

		private IBarProgress _barProgress;

		private bool disposedValue;

		public ProgressBarService(ProgressBar bar, BarPositions barPosition, ActionSlotController controller)
		{
			_bar = bar;
			_barPosition = barPosition;
			_controller = controller;
		}

		public void TrackSlider(IBarProgress sliderProgress)
		{
			_barProgress = sliderProgress;
			_bar.ResetColorRanges();
			if (_barProgress.ColorRanges != null)
			{
				foreach (ColorRange colorRange in _barProgress.ColorRanges)
				{
					_bar.AddColorRange(colorRange);
				}
			}
			_controller.ShowSlider(_barPosition);
			if (_coroutine == null || !_coroutineStarted)
			{
				_coroutine = ((MonoBehaviour)_controller.ActionSlot).StartCoroutine(DisplayProgress());
				_coroutineStarted = true;
			}
		}

		public void StopTracking()
		{
			if (_coroutine != null)
			{
				ActionSlot actionSlot = _controller.ActionSlot;
				if (actionSlot != null)
				{
					((MonoBehaviour)actionSlot).StopCoroutine(_coroutine);
				}
				_controller.HideSlider(_barPosition);
			}
			_coroutineStarted = false;
		}

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

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

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

			private object <>2__current;

			public StackService <>4__this;

			private int <remaining>5__1;

			private Exception <ex>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				try
				{
					<remaining>5__1 = <>4__this._getAmount();
					if (<remaining>5__1 > 0 || <>4__this._showWhenZero)
					{
						<>4__this._hideNeeded = true;
						<>4__this._text.text = <remaining>5__1.ToString();
					}
					else if (<>4__this._hideNeeded)
					{
						<>4__this._controller.HideStackAmount();
						<>4__this._hideNeeded = false;
					}
				}
				catch (Exception ex)
				{
					<ex>5__2 = ex;
					Debug.LogError((object)"ActionUI: Stack tracking coroutine encountered an unexpected exception.");
					Debug.LogException(<ex>5__2);
				}
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 1;
				return true;
			}

			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 ActionSlotController _controller;

		private Func<int> _getAmount;

		private Coroutine _coroutine;

		private bool _coroutineStarted = false;

		private bool _hideNeeded;

		private bool _showWhenZero;

		private readonly Text _text;

		private bool disposedValue;

		public StackService(Text stackText, bool showWhenZero, ActionSlotController controller)
		{
			_text = stackText;
			_showWhenZero = showWhenZero;
			_controller = controller;
		}

		public void Configure(bool showWhenZero)
		{
			_showWhenZero = showWhenZero;
		}

		public void TrackStackAmount(Func<int> getStackAmount)
		{
			_getAmount = getStackAmount;
			if (_coroutine == null || !_coroutineStarted)
			{
				_coroutine = ((MonoBehaviour)_controller.ActionSlot).StartCoroutine(DisplayStackAmount());
				_coroutineStarted = true;
			}
		}

		public void StopTracking()
		{
			if (_coroutine != null)
			{
				((MonoBehaviour)_controller.ActionSlot).StopCoroutine(_coroutine);
				_controller.HideStackAmount();
			}
			_coroutineStarted = false;
		}

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

		protected virtual void Dispose(bool disposing)
		{
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				ActionSlotController controller = _controller;
				if (controller != null)
				{
					ActionSlot actionSlot = controller.ActionSlot;
					if (actionSlot != null)
					{
						((MonoBehaviour)actionSlot).StopCoroutine(_coroutine);
					}
				}
			}
			disposedValue = true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
}
namespace ModifAmorphic.Outward.Unity.ActionUI.Models.EquipmentSets
{
	public interface IEquipmentSet
	{
		string Name { get; set; }

		EquipSlots IconSlot { get; set; }

		int SetID { get; set; }

		IEnumerable<EquipSlot> GetEquipSlots();

		EquipSlot GetIconEquipSlot();
	}
}
namespace ModifAmorphic.Outward.Unity.ActionUI.EquipmentSets
{
	public class ArmorSet : IEquipmentSet
	{
		private Dictionary<EquipSlots, EquipSlot> _equipSlots = new Dictionary<EquipSlots, EquipSlot>
		{
			{
				EquipSlots.Head,
				null
			},
			{
				EquipSlots.Chest,
				null
			},
			{
				EquipSlots.Feet,
				null
			}
		};

		private string _name;

		private GameObject _notificationObject;

		public int SetID { get; set; }

		public string Name
		{
			get
			{
				return _name;
			}
			set
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				_name = value;
				_notificationObject = new GameObject(_name);
			}
		}

		public EquipSlots IconSlot { get; set; } = EquipSlots.Chest;


		public EquipSlot Head
		{
			get
			{
				EquipSlot value;
				return _equipSlots.TryGetValue(EquipSlots.Head, out value) ? value : null;
			}
			set
			{
				if (_equipSlots.ContainsKey(EquipSlots.Head))
				{
					_equipSlots[EquipSlots.Head] = value;
				}
				else
				{
					_equipSlots.Add(EquipSlots.Head, value);
				}
			}
		}

		public EquipSlot Chest
		{
			get
			{
				EquipSlot value;
				return _equipSlots.TryGetValue(EquipSlots.Chest, out value) ? value : null;
			}
			set
			{
				if (_equipSlots.ContainsKey(EquipSlots.Chest))
				{
					_equipSlots[EquipSlots.Chest] = value;
				}
				else
				{
					_equipSlots.Add(EquipSlots.Chest, value);
				}
			}
		}

		public EquipSlot Feet
		{
			get
			{
				EquipSlot value;
				return _equipSlots.TryGetValue(EquipSlots.Feet, out value) ? value : null;
			}
			set
			{
				if (_equipSlots.ContainsKey(EquipSlots.Feet))
				{
					_equipSlots[EquipSlots.Feet] = value;
				}
				else
				{
					_equipSlots.Add(EquipSlots.Feet, value);
				}
			}
		}

		public GameObject GetNotificationObject()
		{
			return _notificationObject;
		}

		public EquipSlot GetIconEquipSlot()
		{
			EquipSlot value;
			return _equipSlots.TryGetValue(IconSlot, out value) ? value : null;
		}

		public IEnumerable<EquipSlot> GetEquipSlots()
		{
			return _equipSlots.Values;
		}
	}
	public class EquipSlot
	{
		public int ItemID { get; set; }

		public string UID { get; set; }

		public EquipSlots Slot { get; set; }
	}
	public class WeaponSet : IEquipmentSet
	{
		private Dictionary<EquipSlots, EquipSlot> _equipSlots = new Dictionary<EquipSlots, EquipSlot>
		{
			{
				EquipSlots.RightHand,
				null
			},
			{
				EquipSlots.LeftHand,
				null
			}
		};

		private string _name;

		private GameObject _notificationObject;

		public int SetID { get; set; }

		public string Name
		{
			get
			{
				return _name;
			}
			set
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				_name = value;
				_notificationObject = new GameObject(_name);
			}
		}

		public EquipSlots IconSlot { get; set; } = EquipSlots.RightHand;


		public EquipSlot LeftHand
		{
			get
			{
				EquipSlot value;
				return _equipSlots.TryGetValue(EquipSlots.LeftHand, out value) ? value : null;
			}
			set
			{
				if (_equipSlots.ContainsKey(EquipSlots.LeftHand))
				{
					_equipSlots[EquipSlots.LeftHand] = value;
				}
				else
				{
					_equipSlots.Add(EquipSlots.LeftHand, value);
				}
			}
		}

		public EquipSlot RightHand
		{
			get
			{
				EquipSlot value;
				return _equipSlots.TryGetValue(EquipSlots.RightHand, out value) ? value : null;
			}
			set
			{
				if (_equipSlots.ContainsKey(EquipSlots.RightHand))
				{
					_equipSlots[EquipSlots.RightHand] = value;
				}
				else
				{
					_equipSlots.Add(EquipSlots.RightHand, value);
				}
			}
		}

		public IEnumerable<EquipSlot> GetEquipSlots()
		{
			return _equipSlots.Values;
		}

		public EquipSlot GetIconEquipSlot()
		{
			EquipSlot value;
			return _equipSlots.TryGetValue(IconSlot, out value) ? value : null;
		}

		public GameObject GetNotificationObject()
		{
			return _notificationObject;
		}
	}
}
namespace ModifAmorphic.Outward.Unity.ActionUI.Extensions
{
	public static class DropdownExtensions
	{
		private static readonly DropdownEvent noDropdownEvent = new DropdownEvent();

		public static void SetValue(this Dropdown dropdown, int value)
		{
			DropdownEvent onValueChanged = dropdown.onValueChanged;
			dropdown.onValueChanged = noDropdownEvent;
			dropdown.value = value;
			dropdown.onValueChanged = onValueChanged;
		}

		public static void ClearOptionsSilent(this Dropdown dropdown)
		{
			DropdownEvent onValueChanged = dropdown.onValueChanged;
			dropdown.onValueChanged = noDropdownEvent;
			dropdown.ClearOptions();
			dropdown.onValueChanged = onValueChanged;
		}

		public static void AddOptionSilent(this Dropdown dropdown, List<OptionData> options)
		{
			DropdownEvent onValueChanged = dropdown.onValueChanged;
			dropdown.onValueChanged = noDropdownEvent;
			dropdown.AddOptions(options.ToList());
			dropdown.onValueChanged = onValueChanged;
		}

		public static OptionData GetSelectedOption(this Dropdown dropdown)
		{
			return dropdown.options[dropdown.value];
		}

		public static int SelectOption(this Dropdown dropdown, string optionText, bool caseSensitive = false)
		{
			for (int i = 0; i < dropdown.options.Count; i++)
			{
				if (dropdown.options[i].text.Equals(optionText, StringComparison.InvariantCultureIgnoreCase))
				{
					dropdown.value = i;
					return i;
				}
			}
			return -1;
		}

		public static int SelectOptionSilent(this Dropdown dropdown, string optionText, bool caseSensitive = false)
		{
			for (int i = 0; i < dropdown.options.Count; i++)
			{
				if (dropdown.options[i].text.Equals(optionText, StringComparison.InvariantCultureIgnoreCase))
				{
					dropdown.SetValueWithoutNotify(i);
					return i;
				}
			}
			return -1;
		}
	}
	public static class EventExtensions
	{
		public static bool TryInvoke(this UnityEvent unityEvent)
		{
			try
			{
				unityEvent.Invoke();
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			return false;
		}

		public static bool TryInvoke<T>(this UnityEvent<T> unityEvent, T eventArg)
		{
			try
			{
				unityEvent.Invoke(eventArg);
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			return false;
		}

		public static bool TryInvoke<T1, T2>(this UnityEvent<T1, T2> unityEvent, T1 eventArg1, T2 eventArg2)
		{
			try
			{
				unityEvent.Invoke(eventArg1, eventArg2);
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			return false;
		}

		public static bool TryInvoke(this Action action)
		{
			try
			{
				action();
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			return false;
		}

		public static bool TryInvoke<T>(this Action<T> action, T eventArg)
		{
			try
			{
				action(eventArg);
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			return false;
		}

		public static bool TryInvoke<T1, T2>(this Action<T1, T2> action, T1 eventArg1, T2 eventArg2)
		{
			try
			{
				action.Invoke(eventArg1, eventArg2);
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			return false;
		}

		public static bool TryInvoke<T1, T2, T3>(this Action<T1, T2, T3> action, T1 eventArg1, T2 eventArg2, T3 eventArg3)
		{
			try
			{
				action(eventArg1, eventArg2, eventArg3);
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			return false;
		}
	}
	internal static class GameObjectExtensions
	{
		internal static void Destroy(this GameObject gameObject)
		{
			if (Application.isEditor)
			{
				Object.DestroyImmediate((Object)(object)gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)gameObject);
			}
			gameObject = null;
		}
	}
	public static class SelectableExtensions
	{
		public enum SelectionState
		{
			Normal,
			Highlighted,
			Pressed,
			Selected,
			Disabled
		}

		private static readonly PropertyInfo _selectionStatePropInfo = typeof(Selectable).GetProperty("currentSelectionState", BindingFlags.Instance | BindingFlags.NonPublic);

		public static SelectionState GetSelectionState(this Selectable selectable)
		{
			return (SelectionState)_selectionStatePropInfo.GetValue(selectable);
		}
	}
	public static class ToggleExtensions
	{
	}
	public static class TransformExtensions
	{
		private static readonly Regex CharacterUIDPattern = new Regex("(?<=/|^)_?[A-Za-z0-9_\\-+]{20,24}(?=/|$)", RegexOptions.Compiled);

		public static string GetPath(this Transform transform)
		{
			string text = ((Object)((Component)transform).gameObject).name;
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return "/" + text;
		}

		public static string GetNormalizedPath(this Transform transform)
		{
			string path = transform.GetPath();
			return NormalizePath(path);
		}

		public static string NormalizePath(string path)
		{
			if (string.IsNullOrWhiteSpace(path))
			{
				return path;
			}
			return CharacterUIDPattern.Replace(path, "[CHARACTER]");
		}

		public static UIPosition ToRectTransformPosition(this RectTransform rectTransform)
		{
			//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_002c: 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_0050: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			return new UIPosition
			{
				Position = ((Transform)rectTransform).position.ToUIPosition2D(),
				AnchoredPosition = rectTransform.anchoredPosition.ToUIPosition2D(),
				AnchoredMin = rectTransform.anchorMin.ToUIPosition2D(),
				AnchoredMax = rectTransform.anchorMax.ToUIPosition2D(),
				OffsetMin = rectTransform.offsetMin.ToUIPosition2D(),
				OffsetMax = rectTransform.offsetMax.ToUIPosition2D(),
				Pivot = rectTransform.pivot.ToUIPosition2D()
			};
		}
	}
	public static class VectorExtensions
	{
		public static UIPosition2D ToUIPosition2D(this Vector2 vector)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new UIPosition2D
			{
				X = vector.x,
				Y = vector.y
			};
		}

		public static UIPosition2D ToUIPosition2D(this Vector3 vector)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return new UIPosition2D
			{
				X = vector.x,
				Y = vector.y
			};
		}
	}
}
namespace ModifAmorphic.Outward.Unity.ActionUI.Data
{
	public class EquipmentSetsProfile<T> where T : IEquipmentSet
	{
		public List<T> EquipmentSets { get; set; } = new List<T>();

	}
	public interface IActionUIProfile
	{
		string Name { get; set; }

		bool ActionSlotsEnabled { get; set; }

		bool DurabilityDisplayEnabled { get; set; }

		bool EquipmentSetsEnabled { get; set; }

		EquipmentSetsSettingsProfile EquipmentSetsSettingsProfile { get; set; }

		StashSettingsProfile StashSettingsProfile { get; set; }

		StorageSettingsProfile StorageSettingsProfile { get; set; }
	}
	public class EquipmentSetsSettingsProfile
	{
		public bool ArmorSetsInCombatEnabled { get; set; }

		public bool SkipWeaponAnimationsEnabled { get; set; }

		public bool StashEquipEnabled { get; set; }

		public bool StashEquipAnywhereEnabled { get; set; }

		public bool StashUnequipEnabled { get; set; }

		public bool StashUnequipAnywhereEnabled { get; set; }
	}
	public class StashSettingsProfile
	{
		public bool CharInventoryEnabled { get; set; }

		public bool CharInventoryAnywhereEnabled { get; set; }

		public bool MerchantEnabled { get; set; }

		public bool MerchantAnywhereEnabled { get; set; }

		public bool CraftingInventoryEnabled { get; set; }

		public bool CraftingInventoryAnywhereEnabled { get; set; }

		public bool PreservesFoodEnabled { get; set; }

		public int PreservesFoodAmount { get; set; }
	}
	public class StorageSettingsProfile
	{
		public bool DisplayCurrencyEnabled { get; set; }
	}
	public interface IActionUIProfileService
	{
		event Action<IActionUIProfile> OnActiveProfileChanged;

		event Action<IActionUIProfile> OnActiveProfileSwitched;

		event Action<IActionUIProfile> OnActiveProfileSwitching;

		IEnumerable<string> GetProfileNames();

		IActionUIProfile GetActiveProfile();

		void SetActiveProfile(string name);

		void Save();

		void SaveNew(IActionUIProfile profile);

		void Rename(string newName);
	}
	public delegate void OnRenamedSetDelegate<T>(T equipmentSet, string oldName, string newName) where T : IEquipmentSet;
	public interface IEquipmentSetService<T> where T : IEquipmentSet
	{
		event Action<T> OnNewSet;

		event OnRenamedSetDelegate<T> OnRenamedSet;

		event Action<string> OnDeletedSet;

		EquipmentSetsProfile<T> GetEquipmentSetsProfile();

		T GetEquipmentSet(string name);

		void RenameEquipmentSet(string setName, string newName);

		void SaveEquipmentSet(T set);

		void SaveNew(EquipmentSetsProfile<T> profile);

		void DeleteEquipmentSet(string setName);

		ISlotAction GetSlotActionPreview(IEquipmentSet set);

		T CreateNewEquipmentSet(string name, EquipSlots iconSlot);

		T GetEquippedAsSet(string name);

		bool TryEquipSet(T equipmentSet);

		bool IsSetEquipped(string name);

		bool IsSetEquipped(T equipmentSet);

		bool IsContainedInSet(string itemUID);
	}
	public interface IHotbarProfile
	{
		List<IHotbarSlotData> Hotbars { get; set; }

		int Rows { get; set; }

		int SlotsPerRow { get; set; }

		bool HideLeftNav { get; set; }

		bool CombatMode { get; set; }

		string NextHotkey { get; set; }

		string PrevHotkey { get; set; }

		int Scale { get; set; }
	}
	public interface IHotbarProfileService
	{
		event Action<IHotbarProfile, HotbarProfileChangeTypes> OnProfileChanged;

		IHotbarProfile GetProfile();

		void Save();

		void SaveNew(IHotbarProfile hotbarProfile);

		void Update(HotbarsContainer hotbar);

		IHotbarProfile AddHotbar();

		IHotbarProfile RemoveHotbar();

		IHotbarProfile AddRow();

		IHotbarProfile RemoveRow();

		IHotbarProfile AddSlot();

		IHotbarProfile RemoveSlot();

		IHotbarProfile SetCooldownTimer(bool showTimer, bool preciseTime);

		IHotbarProfile SetCombatMode(bool combatMode);

		IHotbarProfile SetEmptySlotView(EmptySlotOptions option);

		IHotbarProfile SetHideLeftNav(bool hideLeftNav);

		IHotbarProfile SetScale(int scale);
	}
	public enum HotbarProfileChangeTypes
	{
		ProfileRefreshed,
		HotbarAdded,
		HotbarRemoved,
		RowAdded,
		RowRemoved,
		SlotAdded,
		SlotRemoved,
		CooldownTimer,
		CombatMode,
		EmptySlotView,
		HideLeftNav,
		Scale
	}
	public interface IHotbarSlotData
	{
		int HotbarIndex { get; set; }

		string HotbarHotkey { get; set; }

		List<ISlotData> Slots { get; set; }
	}
	public interface IPositionsProfileService
	{
		event Action<PositionsProfile> OnProfileChanged;

		PositionsProfile GetProfile();

		void Save();

		void SaveNew(PositionsProfile positionsProfile);

		void AddOrUpdate(UIPositions position);

		void Remove(UIPositions position);
	}
	public interface ISlotData
	{
		int SlotIndex { get; set; }

		int ItemID { get; set; }

		string ItemUID { get; set; }

		IActionSlotConfig Config { get; set; }
	}
	public class PositionsProfile
	{
		public List<UIPositions> Positions { get; set; } = new List<UIPositions>();


		public void AddOrReplacePosition(UIPositions position)
		{
			if (Positions.Contains(position))
			{
				Positions.Remove(position);
			}
			Positions.Add(position);
		}

		public bool RemovePosition(UIPositions position)
		{
			return Positions.Remove(position);
		}
	}
	public class UIPositions : IEquatable<UIPositions>, IComparable<UIPositions>
	{
		public string TransformPath { get; set; }

		public UIPosition OriginPosition { get; set; }

		public UIPosition ModifiedPosition { get; set; }

		public int CompareTo(UIPositions other)
		{
			if (other == null)
			{
				return 1;
			}
			return TransformPath.CompareTo(other.TransformPath);
		}

		public bool Equals(UIPositions other)
		{
			if ((object)other == null)
			{
				return false;
			}
			return TransformPath.Equals(other.TransformPath, StringComparison.OrdinalIgnoreCase);
		}

		public override bool Equals(object obj)
		{
			if (obj == null || !(obj is UIPositions other))
			{
				return false;
			}
			return Equals(other);
		}

		public static bool operator ==(UIPositions pos1, UIPositions pos2)
		{
			if ((object)pos1 == null && (object)pos1 == null)
			{
				return true;
			}
			if ((object)pos1 == null || (object)pos2 == null)
			{
				return false;
			}
			return pos1.Equals(pos2);
		}

		public static bool operator !=(UIPositions pos1, UIPositions pos2)
		{
			if ((object)pos1 == null && (object)pos1 == null)
			{
				return false;
			}
			if ((object)pos1 == null || (object)pos2 == null)
			{
				return true;
			}
			return !pos1.Equals(pos2);
		}

		public override int GetHashCode()
		{
			return GetHashCode(this);
		}

		public int GetHashCode(UIPositions uiPosition)
		{
			return uiPosition.TransformPath.GetHashCode();
		}
	}
}
namespace ModifAmorphic.Outward.Unity.ActionUI.Controllers
{
	internal class ActionSlotController : IActionSlotController, IDisposable
	{
		[CompilerGenerated]
		private sealed class <AssignIconCoroutine>d__61 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Func<ActionSlotIcon[]> getIcons;

			public ActionSlotController <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<>4__this.AssignSlotIcons(getIcons());
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 1;
				return true;
			}

			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 CooldownService _cooldownService;

		private readonly Dictionary<BarPositions, ProgressBarService> _progressBarServices = new Dictionary<BarPositions, ProgressBarService>();

		private StackService _stackService;

		private EnableToggleService _toggleService;

		private Coroutine _iconCoroutine;

		private MouseClickListener _keyButtonMouseClickListener;

		private Image _dynamicOverlayImage;

		private readonly Sprite _defaultEmptySprite;

		private static Sprite _hiddenEmptySprite;

		private static bool _hiddenEmptySpriteLoadAttempted;

		private static Sprite _dynamicOverlaySprite;

		private static bool _dynamicOverlaySpriteLoadAttempted;

		private ActionSlotIcon[] dynamicSprites;

		private bool disposedValue;

		public ActionSlot ActionSlot { get; private set; }

		public bool IsUpdateEnabled => ActionSlot.SlotAction?.TargetAction != null && ActionSlot.SlotAction.CheckOnUpdate;

		public bool IsActionNeeded => (Object)(object)ActionSlot.ParentCanvas != (Object)null && ((Behaviour)ActionSlot.ParentCanvas).enabled && ActionSlot.SlotAction?.TargetAction != null && ActionSlot.SlotAction.GetIsActionRequested() && ((Selectable)ActionSlot.ActionButton).interactable && !ActionSlot.HotbarsContainer.IsInActionSlotEditMode;

		public ActionSlotController(ActionSlot actionSlot)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			ActionSlot = actionSlot ?? throw new ArgumentNullException("actionSlot");
			Image emptyImage = actionSlot.EmptyImage;
			_defaultEmptySprite = ((emptyImage != null) ? emptyImage.sprite : null);
			actionSlot.MouseClickListener.OnRightClick.AddListener(new UnityAction(OnRemoveRequested));
			actionSlot.MouseClickListener.OnMiddleClick.AddListener(new UnityAction(OnMiddleClickRequested));
			((UnityEvent)actionSlot.ActionButton.onClick).AddListener(new UnityAction(OnActionButtonClicked));
			_keyButtonMouseClickListener = ((Component)actionSlot.KeyButton).gameObject.GetComponent<MouseClickListener>();
			if ((Object)(object)_keyButtonMouseClickListener == (Object)null)
			{
				_keyButtonMouseClickListener = ((Component)actionSlot.KeyButton).gameObject.AddComponent<MouseClickListener>();
			}
			_keyButtonMouseClickListener.OnRightClick.AddListener(new UnityAction(OnRemoveRequested));
			_keyButtonMouseClickListener.OnMiddleClick.AddListener(new UnityAction(OnMiddleClickRequested));
			((UnityEvent)actionSlot.KeyButton.onClick).AddListener(new UnityAction(OnHotkeyEditRequested));
		}

		public void AssignEmptyAction()
		{
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: 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_0287: Unknown result type (might be due to invalid IL or missing references)
			UnassignSlotAction();
			dynamicSprites = null;
			ActionSlot.ActionImages.ClearImages();
			DisableCooldownService();
			DisableStackService();
			StopEnableToggleService();
			foreach (KeyValuePair<BarPositions, ProgressBar> progressBar in ActionSlot.ProgressBars)
			{
				DisableBarService(progressBar.Key);
			}
			((Behaviour)ActionSlot.StackText).enabled = false;
			foreach (ProgressBar value in ActionSlot.ProgressBars.Values)
			{
				((Component)value).gameObject.SetActive(false);
			}
			if (ActionSlot.Config.EmptySlotOption == EmptySlotOptions.Hidden)
			{
				((Component)ActionSlot.EmptyImage).gameObject.SetActive(true);
				ActionSlot.EmptyImage.sprite = GetHiddenEmptySprite() ?? _defaultEmptySprite;
				((Graphic)ActionSlot.EmptyImage).color = Color.white;
				if (ActionSlot.CanvasGroup.alpha != 0f)
				{
					ActionSlot.CanvasGroup.alpha = 0f;
				}
			}
			else if (ActionSlot.Config.EmptySlotOption == EmptySlotOptions.Transparent)
			{
				Color grey = Color.grey;
				grey.a = 0.18f;
				((Component)ActionSlot.EmptyImage).gameObject.SetActive(false);
				Image val = ActionSlot.ActionImages.AddOrUpdateImage(new ActionSlotIcon
				{
					Name = "emptyTransparentAction",
					Icon = null
				});
				((Graphic)val).color = grey;
				if (ActionSlot.CanvasGroup.alpha != 1f)
				{
					ActionSlot.CanvasGroup.alpha = 1f;
				}
			}
			else if (ActionSlot.Config.EmptySlotOption == EmptySlotOptions.Image)
			{
				((Component)ActionSlot.EmptyImage).gameObject.SetActive(true);
				ActionSlot.EmptyImage.sprite = _defaultEmptySprite;
				((Graphic)ActionSlot.EmptyImage).color = Color.white;
				if (ActionSlot.CanvasGroup.alpha != 1f)
				{
					ActionSlot.CanvasGroup.alpha = 1f;
				}
			}
			ApplyDynamicOverlay();
		}

		public void AssignSlotAction(ISlotAction slotAction, bool surpressChangeFlag = false)
		{
			if (slotAction == null)
			{
				throw new ArgumentNullException("slotAction");
			}
			UnassignSlotAction();
			EnableActiveSlot();
			ActionSlot.SlotAction = slotAction;
			ActionSlot.SlotAction.OnActionRequested += OnActionRequested;
			ActionSlot.SlotAction.OnEditRequested += OnEditRequested;
			if (!slotAction.HasDynamicIcon)
			{
				ActionSlot.SlotAction.OnIconsChanged += AssignSlotIcons;
			}
			if (!slotAction.HasDynamicIcon)
			{
				AssignSlotIcons(slotAction.ActionIcons);
			}
			else
			{
				AssignDynamicIcon(slotAction.GetDynamicIcons);
			}
			((Component)ActionSlot.EmptyImage).gameObject.SetActive(false);
			if (slotAction.Cooldown != null && slotAction.Cooldown.HasCooldown)
			{
				EnableCooldownService(slotAction.Cooldown);
			}
			else
			{
				DisableCooldownService();
			}
			if (slotAction.Stack != null && slotAction.Stack.IsStackable)
			{
				EnableStackService(slotAction.Stack.GetAmount);
			}
			else
			{
				DisableStackService();
			}
			foreach (KeyValuePair<BarPositions, ProgressBar> progressBar in ActionSlot.ProgressBars)
			{
				if (slotAction.ActiveBars != null && slotAction.ActiveBars.TryGetValue(progressBar.Key, out var value) && value.IsEnabled)
				{
					EnableBarService(value);
				}
				else
				{
					DisableBarService(progressBar.Key);
				}
			}
			StartEnableToggleService(slotAction.GetEnabled);
			ApplyDynamicOverlay();
			try
			{
				slotAction.SlotActionAssigned(ActionSlot);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Call to SlotActionAssigned failed for Slot Action '" + slotAction.DisplayName + "'."));
				Debug.LogException(ex);
			}
			if (!surpressChangeFlag)
			{
				ActionSlot.HotbarsContainer.HasChanges = true;
			}
		}

		public void Refresh()
		{
			if (ActionSlot.SlotAction != null)
			{
				AssignSlotAction(ActionSlot.SlotAction);
			}
			else
			{
				AssignEmptyAction();
			}
		}

		public void ActionSlotAwake()
		{
			Refresh();
			if (ActionSlot.Config != null)
			{
				_cooldownService?.Configure(ActionSlot.Config.ShowCooldownTime, ActionSlot.Config.PreciseCooldownTime);
				_stackService?.Configure(ActionSlot.Config.ShowZeroStackAmount);
				SetHotkeyText(ActionSlot.Config.HotkeyText);
			}
			else
			{
				SetHotkeyText(string.Empty);
			}
			ToggleHotkeyEditMode(toggle: false);
		}

		public void ActionSlotUpdate()
		{
			if (IsUpdateEnabled)
			{
				if (IsActionNeeded)
				{
					ActionSlot.SlotAction.TargetAction();
				}
				else if (ActionSlot.SlotAction.GetIsEditRequested())
				{
					ActionSlot.HotbarsContainer.PlayerActionMenus.ActionsViewer.Show(ActionSlot.SlotId);
				}
			}
		}

		public void ActionSlotOnDisable()
		{
			_cooldownService?.StopTracking();
			foreach (ProgressBarService value in _progressBarServices.Values)
			{
				value.StopTracking();
			}
			_stackService?.StopTracking();
			_toggleService?.StopTracking();
			if (_iconCoroutine != null)
			{
				((MonoBehaviour)ActionSlot).StopCoroutine(_iconCoroutine);
			}
		}

		private void OnActionButtonClicked()
		{
			if (ActionSlot.HotbarsContainer.IsInActionSlotEditMode)
			{
				OnEditRequested();
			}
			else if (ActionSlot.SlotAction != null)
			{
				OnActionRequested();
			}
		}

		public void Configure(IActionSlotConfig config)
		{
			ActionSlot.Config = config ?? throw new ArgumentNullException("config");
			Refresh();
			_cooldownService?.Configure(ActionSlot.Config.ShowCooldownTime, ActionSlot.Config.PreciseCooldownTime);
			_stackService?.Configure(ActionSlot.Config.ShowZeroStackAmount);
			SetHotkeyText(ActionSlot.Config.HotkeyText);
		}

		public void HideCooldown()
		{
			//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_006f: Unknown result type (might be due to invalid IL or missing references)
			ActionSlot.CooldownImage.fillAmount = 0f;
			if (((Component)ActionSlot.CooldownText).gameObject.activeSelf)
			{
				ActionSlot.CooldownText.text = string.Empty;
				Color color = ((Graphic)ActionSlot.CooldownTextBackground).color;
				color.a = 0f;
				((Graphic)ActionSlot.CooldownTextBackground).color = color;
			}
		}

		public void HideStackAmount()
		{
			ActionSlot.StackText.text = string.Empty;
		}

		public void ShowSlider(BarPositions barPosition)
		{
			if (!((Component)ActionSlot.ProgressBars[barPosition]).gameObject.activeSelf)
			{
				((Component)ActionSlot.ProgressBars[barPosition]).gameObject.SetActive(true);
			}
		}

		public void HideSlider(BarPositions barPosition)
		{
			if (((Component)ActionSlot.ProgressBars[barPosition]).gameObject.activeSelf)
			{
				((Component)ActionSlot.ProgressBars[barPosition]).gameObject.SetActive(false);
			}
		}

		public void ToggleInteractive(bool interactive)
		{
			if (interactive && !((Selectable)ActionSlot.ActionButton).interactable)
			{
				((Selectable)ActionSlot.ActionButton).interactable = true;
			}
			else if (!interactive && ((Selectable)ActionSlot.ActionButton).interactable)
			{
				((Selectable)ActionSlot.ActionButton).interactable = false;
			}
		}

		public void ToggleEnabled(bool enabled)
		{
			ActionSlot.ActionImages.ToggleEnabled(enabled);
		}

		public void ToggleHotkeyEditMode(bool toggle)
		{
			((Component)ActionSlot.KeyButton).gameObject.SetActive(toggle);
			if (toggle)
			{
				if (ActionSlot.CanvasGroup.alpha == 0f)
				{
					ActionSlot.CanvasGroup.alpha = 1f;
				}
				ActionSlot.CanvasGroup.interactable = true;
				ActionSlot.CanvasGroup.blocksRaycasts = true;
				if ((Object)(object)ActionSlot.KeyButton != (Object)null)
				{
					((Selectable)ActionSlot.KeyButton).interactable = true;
				}
			}
			else
			{
				ActionSlot.CanvasGroup.interactable = true;
				ActionSlot.CanvasGroup.blocksRaycasts = true;
				if (ActionSlot.Config.EmptySlotOption == EmptySlotOptions.Hidden && ActionSlot.SlotAction == null)
				{
					ActionSlot.CanvasGroup.alpha = 0f;
				}
			}
			((Selectable)ActionSlot.ActionButton).interactable = !toggle;
		}

		public void ToggleEditMode(bool toggle, bool showHidden = false)
		{
			bool flag = ActionSlot.Config.EmptySlotOption == EmptySlotOptions.Hidden && ActionSlot.SlotAction == null;
			bool flag2 = showHidden || (ActionSlot.Config.EmptySlotOption != EmptySlotOptions.Hidden && ActionSlot.SlotAction != null) || (ActionSlot.Config.EmptySlotOption == EmptySlotOptions.Hidden && !string.IsNullOrWhiteSpace(ActionSlot.KeyText.text));
			if (toggle && ActionSlot.CanvasGroup.alpha == 0f && (ActionSlot.Config.EmptySlotOption != EmptySlotOptions.Hidden || flag2))
			{
				ActionSlot.CanvasGroup.alpha = 1f;
			}
			else if (!toggle && ActionSlot.CanvasGroup.alpha != 0f && flag)
			{
				ActionSlot.CanvasGroup.alpha = 0f;
			}
			else if (!flag2 && flag)
			{
				ActionSlot.CanvasGroup.alpha = 0f;
			}
		}

		private void OnActionRequested()
		{
			if ((Object)(object)ActionSlot.ParentCanvas != (Object)null && ((Behaviour)ActionSlot.ParentCanvas).enabled && ActionSlot.SlotAction?.TargetAction != null && ((Selectable)ActionSlot.ActionButton).interactable)
			{
				ActionSlot.SlotAction.TargetAction();
			}
		}

		private void OnEditRequested()
		{
		}

		private void OnRemoveRequested()
		{
			DebugLogger.Log("[Debug  :ActionMenus] ActionSlotController:OnRemoveRequested");
			if (ActionSlot.HotbarsContainer.IsInHotkeyEditMode)
			{
				ActionSlot.Config.EmptySlotOption = GetNextEmptySlotOption(ActionSlot.Config.EmptySlotOption);
				ActionSlot.HotbarsContainer.HasChanges = true;
				Refresh();
				if (ActionSlot.CanvasGroup.alpha == 0f)
				{
					ActionSlot.CanvasGroup.alpha = 1f;
				}
			}
			else if ((Object)(object)ActionSlot.ParentCanvas != (Object)null && ((Behaviour)ActionSlot.ParentCanvas).enabled && ((Selectable)ActionSlot.ActionButton).interactable)
			{
				AssignEmptyAction();
				ActionSlot.HotbarsContainer.HasChanges = true;
			}
		}

		private void OnMiddleClickRequested()
		{
			if (ActionSlot.HotbarsContainer.IsInHotkeyEditMode || ActionSlot.HotbarsContainer.IsInActionSlotEditMode)
			{
				ActionSlot.Config.IsDynamic = !ActionSlot.Config.IsDynamic;
				ActionSlot.HotbarsContainer.HasChanges = true;
				Refresh();
				if (ActionSlot.CanvasGroup.alpha == 0f)
				{
					ActionSlot.CanvasGroup.alpha = 1f;
				}
			}
		}

		private void OnHotkeyEditRequested()
		{
			if ((Object)(object)ActionSlot.ParentCanvas != (Object)null && ((Behaviour)ActionSlot.ParentCanvas).enabled)
			{
				ActionSlot.HotbarsContainer.PlayerActionMenus.MainSettingsMenu.HotkeyCaptureMenu.ShowDialog(ActionSlot.SlotIndex, HotkeyCategories.ActionSlot);
			}
		}

		private void EnableActiveSlot()
		{
			((Behaviour)ActionSlot.CooldownImage).enabled = true;
			((Behaviour)ActionSlot.CooldownText).enabled = true;
			((Behaviour)ActionSlot.StackText).enabled = true;
			ActionSlot.CooldownText.text = string.Empty;
			ActionSlot.StackText.text = string.Empty;
			ActionSlot.CanvasGroup.alpha = 1f;
		}

		private Sprite GetHiddenEmptySprite()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00c5: 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)
			if (_hiddenEmptySpriteLoadAttempted)
			{
				return _hiddenEmptySprite;
			}
			_hiddenEmptySpriteLoadAttempted = true;
			try
			{
				string location = typeof(ActionSlotController).Assembly.Location;
				if (string.IsNullOrWhiteSpace(location))
				{
					return null;
				}
				string directoryName = Path.GetDirectoryName(location);
				if (string.IsNullOrWhiteSpace(directoryName))
				{
					return null;
				}
				string path = Path.Combine(directoryName, "ActionSlotHiddenImage.png");
				if (!File.Exists(path))
				{
					return null;
				}
				byte[] array = File.ReadAllBytes(path);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, array))
				{
					return null;
				}
				_hiddenEmptySprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
			catch
			{
				_hiddenEmptySprite = null;
			}
			return _hiddenEmptySprite;
		}

		private Sprite GetDynamicOverlaySprite()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00c5: 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)
			if (_dynamicOverlaySpriteLoadAttempted)
			{
				return _dynamicOverlaySprite;
			}
			_dynamicOverlaySpriteLoadAttempted = true;
			try
			{
				string location = typeof(ActionSlotController).Assembly.Location;
				if (string.IsNullOrWhiteSpace(location))
				{
					return null;
				}
				string directoryName = Path.GetDirectoryName(location);
				if (string.IsNullOrWhiteSpace(directoryName))
				{
					return null;
				}
				string path = Path.Combine(directoryName, "ActionSlotDynamicImage.png");
				if (!File.Exists(path))
				{
					return null;
				}
				byte[] array = File.ReadAllBytes(path);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, array))
				{
					return null;
				}
				_dynamicOverlaySprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
			catch
			{
				_dynamicOverlaySprite = null;
			}
			return _dynamicOverlaySprite;
		}

		private void ApplyDynamicOverlay()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_dynamicOverlayImage == (Object)null)
			{
				GameObject val = new GameObject("DynamicOverlayImage");
				val.transform.SetParent(((Component)ActionSlot.ActionButton).transform, false);
				RectTransform val2 = val.AddComponent<RectTransform>();
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.one;
				val2.offsetMin = Vector2.zero;
				val2.offsetMax = Vector2.zero;
				((Transform)val2).localScale = Vector3.one;
				_dynamicOverlayImage = val.AddComponent<Image>();
				((Graphic)_dynamicOverlayImage).raycastTarget = false;
				_dynamicOverlayImage.preserveAspect = false;
				((Behaviour)_dynamicOverlayImage).enabled = false;
			}
			((Component)_dynamicOverlayImage).transform.SetAsLastSibling();
			IActionSlotConfig config = ActionSlot.Config;
			if (config != null && config.IsDynamic)
			{
				_dynamicOverlayImage.sprite = GetDynamicOverlaySprite();
				((Graphic)_dynamicOverlayImage).color = Color.white;
				((Behaviour)_dynamicOverlayImage).enabled = (Object)(object)_dynamicOverlayImage.sprite != (Object)null;
			}
			else
			{
				((Behaviour)_dynamicOverlayImage).enabled = false;
			}
		}

		private EmptySlotOptions GetNextEmptySlotOption(EmptySlotOptions currentOption)
		{
			return currentOption switch
			{
				EmptySlotOptions.Hidden => EmptySlotOptions.Image, 
				EmptySlotOptions.Image => EmptySlotOptions.Transparent, 
				_ => EmptySlotOptions.Hidden, 
			};
		}

		private void UnassignSlotAction()
		{
			if (ActionSlot.SlotAction != null)
			{
				ActionSlot.SlotAction.OnActionRequested -= OnActionRequested;
				ActionSlot.SlotAction.OnEditRequested -= OnEditRequested;
				if (!ActionSlot.SlotAction.HasDynamicIcon)
				{
					ActionSlot.SlotAction.OnIconsChanged -= AssignSlotIcons;
				}
				ActionSlot.SlotAction.SlotActionUnassigned();
				ActionSlot.SlotAction = null;
			}
			if (_iconCoroutine != null)
			{
				((MonoBehaviour)ActionSlot).StopCoroutine(_iconCoroutine);
				_iconCoroutine = null;
			}
			ActionSlot.CooldownText.text = string.Empty;
			ActionSlot.StackText.text = string.Empty;
		}

		private void AssignSlotIcons(ActionSlotIcon[] spriteIcons)
		{
			string text = string.Empty;
			try
			{
				bool flag = false;
				if (dynamicSprites != null && dynamicSprites.Length == spriteIcons.Length)
				{
					for (int i = 0; i < spriteIcons.Length; i++)
					{
						if (spriteIcons[i].Name != dynamicSprites[i].Name)
						{
							flag = true;
							break;
						}
					}
				}
				else
				{
					flag = true;
				}
				dynamicSprites = spriteIcons;
				if (flag)
				{
					ActionSlot.ActionImages.ClearImages();
					for (int j = 0; j < spriteIcons.Length; j++)
					{
						text = $"AssignSlotIcon: ActionSlot.ActionImages == null == {(Object)(object)ActionSlot.ActionImages == (Object)null}.  spriteIcon[{j}] == null == {spriteIcons[j] == null}";
						ActionSlot.ActionImages.AddOrUpdateImage(spriteIcons[j]);
					}
					ApplyDynamicOverlay();
				}
			}
			catch (Exception ex)
			{
				ActionSlot actionSlot = ActionSlot;
				Debug.LogError((object)("Could not assign sprite icons to ActionSlot " + ((actionSlot != null) ? ((Object)actionSlot).name : null) + ". " + text));
				Debug.LogException(ex);
			}
		}

		private void EnableCooldownService(ICooldown cooldown)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (cooldown == null)
			{
				throw new ArgumentNullException("cooldown");
			}
			if (_cooldownService != null)
			{
				_cooldownService.StopTracking();
				_cooldownService = null;
			}
			((Component)ActionSlot.CooldownImage).gameObject.SetActive(true);
			if (ActionSlot.Config.ShowCooldownTime)
			{
				((Component)ActionSlot.CooldownText).gameObject.SetActive(true);
				((Component)ActionSlot.CooldownTextBackground).gameObject.SetActive(true);
				Color color = ((Graphic)ActionSlot.CooldownTextBackground).color;
				color.a = 0f;
				((Graphic)ActionSlot.CooldownTextBackground).color = color;
			}
			_cooldownService = new CooldownService(ActionSlot.CooldownImage, ActionSlot.CooldownText, ActionSlot.Config.ShowCooldownTime, ActionSlot.Config.PreciseCooldownTime, this);
			_cooldownService.TrackCooldown(cooldown);
		}

		private void DisableCooldownService()
		{
			_cooldownService?.StopTracking();
			((Component)ActionSlot.CooldownImage).gameObject.SetActive(false);
			((Component)ActionSlot.CooldownText).gameObject.SetActive(false);
			((Component)ActionSlot.CooldownTextBackground).gameObject.SetActive(false);
		}

		private void EnableStackService(Func<int> getStackAmount)
		{
			if (getStackAmount == null)
			{
				throw new ArgumentNullException("getStackAmount");
			}
			if (_stackService != null)
			{
				_stackService.StopTracking();
				_stackService = null;
			}
			_stackService = new StackService(ActionSlot.StackText, ActionSlot.Config.ShowZeroStackAmount, this);
			_stackService.TrackStackAmount(getStackAmount);
		}

		private void DisableStackService()
		{
			_stackService?.StopTracking();
		}

		private void EnableBarService(IBarProgress bar)
		{
			if (bar == null)
			{
				throw new ArgumentNullException("bar");
			}
			if (_progressBarServices.TryGetValue(bar.BarPosition, out var value))
			{
				value.StopTracking();
				value = null;
				_progressBarServices.Remove(bar.BarPosition);
			}
			_progressBarServices.Add(bar.BarPosition, new ProgressBarService(ActionSlot.ProgressBars[bar.BarPosition], bar.BarPosition, this));
			_progressBarServices[bar.BarPosition].TrackSlider(bar);
		}

		private void DisableBarService(BarPositions barPosition)
		{
			if (_progressBarServices.TryGetValue(barPosition, out var value))
			{
				value.StopTracking();
				value = null;
				_progressBarServices.Remove(barPosition);
			}
			HideSlider(barPosition);
		}

		private void SetHotkeyText(string text)
		{
			ActionSlot.KeyText.text = text;
			if (!string.IsNullOrEmpty(text))
			{
				((Behaviour)ActionSlot.HotkeyPanel).enabled = true;
			}
			else
			{
				((Behaviour)ActionSlot.HotkeyPanel).enabled = false;
			}
		}

		private void StartEnableToggleService(Func<bool> getEnabled)
		{
			if (getEnabled == null)
			{
				throw new ArgumentNullException("getEnabled");
			}
			if (_toggleService != null)
			{
				_toggleService.StopTracking();
			}
			else
			{
				_toggleService = new EnableToggleService(this);
			}
			_toggleService.TrackEnableToggle(getEnabled);
		}

		private void StopEnableToggleService()
		{
			if (_toggleService != null)
			{
				_toggleService.StopTracking();
			}
		}

		private void AssignDynamicIcon(Func<ActionSlotIcon[]> getIcon)
		{
			_iconCoroutine = ((MonoBehaviour)ActionSlot).StartCoroutine(AssignIconCoroutine(getIcon));
		}

		[IteratorStateMachine(typeof(<AssignIconCoroutine>d__61))]
		private IEnumerator AssignIconCoroutine(Func<ActionSlotIcon[]> getIcons)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AssignIconCoroutine>d__61(0)
			{
				<>4__this = this,
				getIcons = getIcons
			};
		}

		protected virtual void Dispose(bool disposing)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			if (disposedValue)
			{
				return;
			}
			if (disposing)
			{
				MouseClickListener mouseClickListener = ActionSlot.MouseClickListener;
				if (mouseClickListener != null)
				{
					mouseClickListener.OnRightClick.RemoveListener(new UnityAction(OnRemoveRequested));
				}
				MouseClickListener mouseClickListener2 = ActionSlot.MouseClickListener;
				if (mouseClickListener2 != null)
				{
					mouseClickListener2.OnMiddleClick.RemoveListener(new UnityAction(OnMiddleClickRequested));
				}
				MouseClickListener keyButtonMouseClickListener = _keyButtonMouseClickListener;
				if (keyButtonMouseClickListener != null)
				{
					keyButtonMouseClickListener.OnRightClick.RemoveListener(new UnityAction(OnRemoveRequested));
				}
				MouseClickListener keyButtonMouseClickListener2 = _keyButtonMouseClickListener;
				if (keyButtonMouseClickListener2 != null)
				{
					keyButtonMouseClickListener2.OnMiddleClick.RemoveListener(new UnityAction(OnMiddleClickRequested));
				}
				_cooldownService?.Dispose();
				_stackService?.Dispose();
				_toggleService?.Dispose();
				foreach (ProgressBarService value in _progressBarServices.Values)
				{
					value.Dispose();
				}
				((MonoBehaviour)ActionSlot).StopAllCoroutines();
			}
			disposedValue = true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class HotbarsController : IHotbarController
	{
		private readonly HotbarsContainer _hbc;

		private bool _resizeNeeded = false;

		public HotbarsContainer HotbarsContainer => _hbc;

		public bool IsInHotkeyEditMode => _hbc.IsInHotkeyEditMode;

		public bool JustExitedHotkeyMode { get; set; }

		public HotbarsController(HotbarsContainer hotbarsContainer)
		{
			_hbc = hotbarsContainer ?? throw new ArgumentNullException("hotbarsContainer");
			_hbc.PlayerActionMenus.ActionsViewer.OnSlotActionSelected += AssignSlotAction;
		}

		private void AssignSlotAction(int slotId, ISlotAction slotAction)
		{
			if (_hbc.ActionSlots.TryGetValue(slotId, out var value))
			{
				value.Controller.AssignSlotAction(slotAction);
			}
		}

		public void ConfigureHotbars(IHotbarProfile profile)
		{
			int selectedHotbar = _hbc.SelectedHotbar;
			Reset();
			_hbc.BaseGrid.constraintCount = profile.SlotsPerRow;
			_hbc.ConfigureHotbars(profile.Hotbars.Count);
			DebugLogger.Log("[Debug  :ActionMenus] Configuring ActionSlots.");
			_hbc.LeftHotbarNav.SetNextHotkeyText(profile.NextHotkey);
			_hbc.LeftHotbarNav.SetPreviousHotkeyText(profile.PrevHotkey);
			_hbc.LeftHotbarNav.SetHotkeys(profile.Hotbars.Select((IHotbarSlotData b) => b.HotbarHotkey));
			_hbc.LeftHotbarNav.SetBarText((_hbc.SelectedHotbar + 1).ToString());
			if (profile.HideLeftNav)
			{
				_hbc.LeftHotbarNav.Hide();
			}
			else
			{
				_hbc.LeftHotbarNav.Show();
			}
			for (int i = 0; i < profile.Hotbars.Count; i++)
			{
				Canvas val = Object.Instantiate<Canvas>(_hbc.BaseHotbarCanvas);
				((Component)val).transform.SetParent(((Component)_hbc.BaseHotbarCanvas).transform.parent, false);
				((Object)val).name = "HotbarCanvas" + i;
				((Component)val).gameObject.SetActive(true);
				_hbc.HotbarGrid[i] = Object.Instantiate<GridLayoutGroup>(_hbc.BaseGrid, ((Component)val).transform);
				((Object)_hbc.HotbarGrid[i]).name = "HotbarsGrid" + i;
				((Component)_hbc.HotbarGrid[i]).gameObject.SetActive(true);
				_hbc.ConfigureActionSlots(i, profile.SlotsPerRow * profile.Rows);
				for (int j = 0; j < profile.SlotsPerRow * profile.Rows; j++)
				{
					GameObject val2 = Object.Instantiate<GameObject>(_hbc.BaseActionSlot);
					val2.transform.SetParent(((Component)_hbc.HotbarGrid[i]).transform, false);
					ActionSlot component = val2.GetComponent<ActionSlot>();
					component.SlotIndex = j;
					component.HotbarIndex = i;
					component.HotbarsContainer = _hbc;
					component.Config = profile.Hotbars[i].Slots[j].Config;
					val2.SetActive(true);
					_hbc.Hotbars[i][j] = component;
					_hbc.ActionSlots.Add(component.SlotId, component);
				}
				((Behaviour)val).enabled = i == 0;
			}
			DebugLogger.Log($"[Debug  :ActionMenus] Added {_hbc.Hotbars.Length} Hotbars with {UnityEngineExtensions.FirstOrDefault<ActionSlot[]>((IList<ActionSlot[]>)_hbc.Hotbars)?.Length} Action Slots each. Calling StartCoroutine ResizeLayoutGroup().");
			_resizeNeeded = true;
			if (selectedHotbar != _hbc.SelectedHotbar && selectedHotbar < GetHotbarCount())
			{
				SelectHotbar(selectedHotbar);
			}
			else if (selectedHotbar != _hbc.SelectedHotbar)
			{
				SelectHotbar(GetHotbarCount() - 1);
			}
			else
			{
				SelectHotbar(_hbc.SelectedHotbar);
			}
		}

		public void EnableHotbars()
		{
			((Component)_hbc.ActionBarsCanvas).gameObject.SetActive(true);
			PositionableUI component = ((Component)_hbc).GetComponent<PositionableUI>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = true;
				if ((Object)(object)component.BackgroundImage != (Object)null)
				{
					((Component)component.BackgroundImage).gameObject.SetActive(true);
				}
			}
		}

		public void DisableHotbars()
		{
			((Component)_hbc.ActionBarsCanvas).gameObject.SetActive(false);
			PositionableUI component = ((Component)_hbc).GetComponent<PositionableUI>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
				if ((Object)(object)component.BackgroundImage != (Object)null)
				{
					((Component)component.BackgroundImage).gameObject.SetActive(false);
				}
			}
		}

		public void ReassignActionSlots()
		{
			Canvas[] componentsInChildren = ((Component)_hbc).GetComponentsInChildren<Canvas>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				GridLayoutGroup componentInChildren = ((Component)componentsInChildren[i]).GetComponentInChildren<GridLayoutGroup>(true);
				if (!((Object)(object)componentInChildren != (Object)null) || !((Object)(object)componentInChildren != (Object)(object)_hbc.BaseGrid))
				{
					continue;
				}
				ActionSlot[] componentsInChildren2 = ((Component)componentInChildren).GetComponentsInChildren<ActionSlot>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					if (componentsInChildren2[j].Controller != null)
					{
						if (componentsInChildren2[j].SlotAction != null)
						{
							componentsInChildren2[j].Controller.AssignSlotAction(componentsInChildren2[j].SlotAction, surpressChangeFlag: true);
						}
						else
						{
							componentsInChildren2[j].Controller.AssignEmptyAction();
						}
					}
				}
			}
		}

		public void SelectHotbar(int barIndex)
		{
			if (barIndex < 0 || barIndex >= _hbc.HotbarGrid.Length)
			{
				throw new ArgumentOutOfRangeException("barIndex");
			}
			for (int i = 0; i < _hbc.HotbarGrid.Length; i++)
			{
				((Behaviour)((Component)((Component)_hbc.HotbarGrid[i]).transform.parent).GetComponent<Canvas>()).enabled = i == barIndex;
			}
			_hbc.SelectedHotbar = barIndex;
			_hbc.LeftHotbarNav.SelectHotbar(barIndex);
		}

		public void SelectNext()
		{
			int barIndex = ((_hbc.SelectedHotbar + 1 < GetHotbarCount()) ? (_hbc.SelectedHotbar + 1) : 0);
			SelectHotbar(barIndex);
		}

		public void SelectPrevious()
		{
			int barIndex = ((_hbc.SelectedHotbar - 1 < 0) ? (GetHotbarCount() - 1) : (_hbc.SelectedHotbar - 1));
			SelectHotbar(barIndex);
		}

		public int GetHotbarCount()
		{
			if (_hbc.HotbarGrid == null)
			{
				return 0;
			}
			return _hbc.HotbarGrid.Length;
		}

		public int GetActionSlotsPerRow()
		{
			if (_hbc.HotbarGrid == null || _hbc.HotbarGrid.Length == 0)
			{
				return _hbc.BaseGrid.constraintCount;
			}
			return _hbc.HotbarGrid[0].constraintCount;
		}

		public int GetActionSlotsPerBar()
		{
			if (_hbc.Hotbars == null || _hbc.Hotbars.Length == 0)
			{
				return 0;
			}
			return _hbc.Hotbars[0].Length;
		}

		public GridLayoutGroup[] GetHotbarGrids()
		{
			return _hbc.HotbarGrid;
		}

		public ActionSlot[][] GetActionSlots()
		{
			return _hbc.Hotbars;
		}

		public int GetRowCount()
		{
			if (_hbc.Hotbars == null || _hbc.Hotbars.Length == 0 || _hbc.HotbarGrid == null || _hbc.HotbarGrid.Length == 0)
			{
				return 1;
			}
			return _hbc.Hotbars[0].Length / _hbc.HotbarGrid[0].constraintCount;
		}

		public void HotbarsContainerUpdate()
		{
			if (_hbc.IsInHotkeyEditMode)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
				HotkeyCaptureMenu hotkeyCaptureMenu = _hbc.PlayerActionMenus.MainSettingsMenu.HotkeyCaptureMenu;
				if ((!((Object)(object)hotkeyCaptureMenu != (Object)null) || !hotkeyCaptureMenu.IsShowing) && Input.GetKeyDown((KeyCode)27))
				{
					JustExitedHotkeyMode = true;
					ToggleHotkeyEdits(editMode: false);
				}
			}
			if (_resizeNeeded)
			{
				ResizeLayoutGroup();
			}
		}

		public void Reset()
		{
			Canvas[] componentsInChildren = ((Component)_hbc).GetComponentsInChildren<Canvas>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				GridLayoutGroup componentInChildren = ((Component)componentsInChildren[i]).GetComponentInChildren<GridLayoutGroup>(true);
				if (!((Object)(object)componentInChildren != (Object)null) || !((Object)(object)componentInChildren != (Object)(object)_hbc.BaseGrid))
				{
					continue;
				}
				ActionSlot[] componentsInChildren2 = ((Component)componentInChildren).GetComponentsInChildren<ActionSlot>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					if (componentsInChildren2[j].Controller is IDisposable disposable)
					{
						disposable?.Dispose();
					}
					((Component)componentsInChildren2[j]).gameObject.Destroy();
				}
				((Component)componentInChildren).gameObject.Destroy();
				((Component)componentsInChildren[i]).gameObject.Destroy();
			}
			_hbc.ResetCollections();
			_hbc.SelectedHotbar = 0;
		}

		private void ResizeLayoutGroup()
		{
			//IL_000e: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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)
			if (_hbc.HotbarGrid[0].cellSize.x != 0f)
			{
				float hotbarWidth = (_hbc.HotbarGrid[0].cellSize.x + _hbc.HotbarGrid[0].spacing.x) * (float)_hbc.HotbarGrid[0].constraintCount + (float)((LayoutGroup)_hbc.HotbarGrid[0]).padding.horizontal;
				float hotbarHeight = (_hbc.HotbarGrid[0].cellSize.y + _hbc.HotbarGrid[0].spacing.y) * (float)GetRowCount() + (float)((LayoutGroup)_hbc.HotbarGrid[0]).padding.vertical;
				DebugLogger.Log("[Debug  :ActionMenus] ResizeLayoutGroup() called. Calculated width is " + hotbarWidth);
				_hbc.Resize(hotbarWidth, hotbarHeight);
				_resizeNeeded = false;
			}
		}

		public void ToggleActionSlotEdits(bool editMode, bool showHidden = false)
		{
			if (!_hbc.IsAwake)
			{
				return;
			}
			_hbc.LeftHotbarNav.ToggleActionSlotEditMode(editMode);
			_hbc.IsInActionSlotEditMode = editMode;
			foreach (ActionSlot value in _hbc.ActionSlots.Values)
			{
				value.Controller.ToggleEditMode(editMode, showHidden);
			}
		}

		public void ToggleHotkeyEdits(bool editMode)
		{
			if (!_hbc.IsAwake)
			{
				return;
			}
			_hbc.LeftHotbarNav.ToggleHotkeyEditMode(editMode);
			_hbc.IsInHotkeyEditMode = editMode;
			foreach (ActionSlot value in _hbc.ActionSlots.Values)
			{
				value.Controller.ToggleHotkeyEditMode(editMode);
			}
			if (editMode)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
				Time.timeScale = 0f;
			}
			else
			{
				Cursor.visible = false;
				Cursor.lockState = (CursorLockMode)1;
				Time.timeScale = 1f;
			}
		}

		public void Refresh()
		{
			foreach (ActionSlot value in _hbc.ActionSlots.Values)
			{
				value.Controller.Refresh();
			}
		}
	}
	public interface IActionSlotController
	{
		ActionSlot ActionSlot { get; }

		void AssignEmptyAction();

		void AssignSlotAction(ISlotAction slotAction, bool surpressChangeFlag = false);

		void Configure(IActionSlotConfig config);

		void Refresh();

		void ActionSlotUpdate();

		void ActionSlotAwake();

		void ActionSlotOnDisable();

		void ToggleEditMode(bool toggle, bool showHidden = false);

		void ToggleHotkeyEditMode(bool toggle);

		void HideCooldown();

		void HideSlider(BarPositions slider);
	}
	public interface IHotbarController
	{
		bool IsInHotkeyEditMode { get; }

		bool JustExitedHotkeyMode { get; set; }

		GridLayoutGroup[] GetHotbarGrids();

		ActionSlot[][] GetActionSlots();

		int GetRowCount();

		int GetHotbarCount();

		int GetActionSlotsPerRow();

		int GetActionSlotsPerBar();

		void HotbarsContainerUpdate();

		void SelectHotbar(int hotbarIndex);

		void SelectNext();

		void SelectPrevious();

		void ConfigureHotbars(IHotbarProfile profile);

		void EnableHotbars();

		void DisableHotbars();

		void ReassignActionSlots();

		void Refresh();

		void ToggleActionSlotEdits(bool enabled, bool showHidden = false);

		void ToggleHotkeyEdits(bool enabled);
	}
}