using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
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+a580093fb59052c6205677075b91d046d390cb6a")]
[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 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);

		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));
		}

		private IEnumerator NextFrameCoroutine(Action action)
		{
			yield return null;
			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
	{
		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;
		}

		private IEnumerator SetDurabilityValue(DurabilitySlot slot, Func<float> getDurability)
		{
			while (true)
			{
				slot.SetValue(getDurability());
				yield return (object)new WaitForSeconds(1f);
			}
		}

		private IEnumerator AddToPsp()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)Psp.Instance != (Object)null && PlayerActionMenus.PlayerID > -1));
			UnityServicesProvider psp = Psp.Instance.GetServicesProvider(PlayerActionMenus.PlayerID);
			if (!psp.TryGetService<DurabilityDisplay>(out var _))
			{
				psp.AddSingleton(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;

		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()
		{
			_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);
		}

		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
	{
		public UnityEvent OnLeftClick;

		public UnityEvent OnRightClick;

		public UnityEvent OnMiddleClick;

		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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 0)
			{
				OnLeftClick.Invoke();
			}
			else if ((int)eventData.button == 1)
			{
				OnRightClick.Invoke();
			}
			else if ((int)eventData.button == 2)
			{
				OnMiddleClick.Invoke();
			}
		}
	}
	[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)component == (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 void SetPositionFromProfile(PositionsProfile profile)
		{
			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);
				_originPosition = uIPositions.OriginPosition;
			}
		}

		private void OnProfileChanged(PositionsProfile profile)
		{
			DebugLogger.Log("[Debug  :ActionMenus] PositionableUI{" + ((Object)this).name + "}: OnProfileChanged for PositionableUI " + ((Object)this).name + ".");
			ResetToOrigin();
			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
	{
		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;
			EmptySlotDropdown.ClearOptions();
			List<OptionData> list = ((IEnumerable<string>)Enum.GetNames(typeof(EmptySlotOptions))).Select((Func<string, OptionData>)((string name) => new OptionData(name))).ToList();
			EmptySlotDropdown.AddOptions(list);
			string selectedName = Enum.GetName(typeof(EmptySlotOptions), config?.EmptySlotOption ?? EmptySlotOptions.Image);
			EmptySlotDropdown.value = list.FindIndex((OptionData o) => o.text.Equals(selectedName, StringComparison.InvariantCultureIgnoreCase));
		}

		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);
			});
			((UnityEvent<int>)(object)EmptySlotDropdown.onValueChanged).AddListener((UnityAction<int>)delegate(int value)
			{
				_hotbarService.SetEmptySlotView((EmptySlotOptions)value);
			});
		}

		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());
		}

		private IEnumerator CheckSetSelectedSetting()
		{
			yield return null;
			yield return (object)new WaitForEndOfFrame();
			if (!_selectables.Any((SelectableTransitions s) => s.Selected) && !MainSettingsMenu.MenuItemSelected && ((Component)this).gameObject.activeSelf && (Object)(object)_lastSelected != (Object)null)
			{
				_lastSelected.Select();
			}
		}

		private IEnumerator SelectNextFrame(Selectable selectable)
		{
			yield return null;
			yield return (object)new WaitForEndOfFrame();
			selectable.Select();
		}
	}
	[UnityScriptComponent]
	public class SettingsView : MonoBehaviour, ISettingsView
	{
		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());
		}

		private IEnumerator CheckSetSelectedSetting()
		{
			yield return null;
			yield return (object)new WaitForEndOfFrame();
			if (!_selectables.Any((SelectableTransitions s) => s.Selected) && !MainSettingsMenu.MenuItemSelected && ((Component)this).gameObject.activeSelf && (Object)(object)_lastSelected != (Object)null)
			{
				_lastSelected.Select();
			}
		}

		private IEnumerator SelectNextFrame(Selectable selectable)
		{
			yield return null;
			yield return (object)new WaitForEndOfFrame();
			selectable.Select();
		}
	}
	[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[] positionableUIs = MainSettingsMenu.PlayerMenu.GetPositionableUIs();
			PositionableUI[] array = positionableUIs;
			foreach (PositionableUI positionableUI in array)
			{
				positionableUI.EnableMovement();
			}
		}

		private void DisableAndSavePositions()
		{
			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.");
			Positionabl