using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("EpicLoot-UnityLib")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Randy Knapp Mods")]
[assembly: AssemblyProduct("EpicLoot-UnityLib")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fb508e8d-0c64-4ec6-b746-f668f510296f")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EpicLoot_UnityLib
{
	public class AugmentUI : EnchantingTableUIPanelBase
	{
		public delegate List<InventoryItemListElement> GetAugmentableItemsDelegate();

		public delegate List<Tuple<string, bool>> GetAugmentableEffectsDelegate(ItemData item);

		public delegate string GetAvailableEffectsDelegate(ItemData item, int augmentIndex);

		public delegate List<InventoryItemListElement> GetAugmentCostDelegate(ItemData item, int augmentIndex);

		public delegate GameObject AugmentItemDelegate(ItemData item, int augmentIndex);

		public Text AvailableEffectsText;

		public Text AvailableEffectsHeader;

		public Scrollbar AvailableEffectsScrollbar;

		public List<Toggle> AugmentSelectors;

		[Header("Cost")]
		public Text CostLabel;

		public MultiSelectItemList CostList;

		public static GetAugmentableItemsDelegate GetAugmentableItems;

		public static GetAugmentableEffectsDelegate GetAugmentableEffects;

		public static GetAvailableEffectsDelegate GetAvailableEffects;

		public static GetAugmentCostDelegate GetAugmentCost;

		public static AugmentItemDelegate AugmentItem;

		private int _augmentIndex;

		private GameObject _choiceDialog;

		public override void Awake()
		{
			base.Awake();
			for (int i = 0; i < AugmentSelectors.Count; i++)
			{
				((UnityEvent<bool>)(object)AugmentSelectors[i].onValueChanged).AddListener((UnityAction<bool>)OnAugmentSelectorToggled);
			}
		}

		[UsedImplicitly]
		public void OnEnable()
		{
			_augmentIndex = -1;
			foreach (Toggle augmentSelector in AugmentSelectors)
			{
				augmentSelector.isOn = false;
			}
			if ((Object)(object)AvailableEffectsHeader != (Object)null)
			{
				int num = 2;
				Tuple<float, float> featureCurrentValue = EnchantingTableUI.instance.SourceTable.GetFeatureCurrentValue(EnchantingFeature.Augment);
				if (!float.IsNaN(featureCurrentValue.Item1))
				{
					num = (int)featureCurrentValue.Item1;
				}
				string text = ((num > 2) ? "<color=#EAA800>" : "");
				string text2 = ((num > 2) ? "</color>" : "");
				AvailableEffectsHeader.text = Localization.instance.Localize("$mod_epicloot_augment_availableeffects " + text + "($mod_epicloot_augment_choices)" + text2, new string[1] { num.ToString() });
			}
			OnAugmentIndexChanged();
			List<InventoryItemListElement> source = GetAugmentableItems();
			AvailableItems.SetItems(source.Cast<IListElement>().ToList());
			DeselectAll();
		}

		public override void Update()
		{
			base.Update();
			if (!_locked && ZInput.IsGamepadActive())
			{
				if (ZInput.GetButtonDown("JoyButtonY"))
				{
					int num = AugmentSelectors.Count((Toggle x) => ((Behaviour)x).isActiveAndEnabled);
					int index = (_augmentIndex + 1) % num;
					AugmentSelectors[index].isOn = true;
					ZInput.ResetButtonStatus("JoyButtonY");
				}
				if ((Object)(object)AvailableEffectsScrollbar != (Object)null)
				{
					float joyRightStickY = ZInput.GetJoyRightStickY();
					if (Mathf.Abs(joyRightStickY) > 0.5f)
					{
						AvailableEffectsScrollbar.value = Mathf.Clamp01(AvailableEffectsScrollbar.value + joyRightStickY * -0.1f);
					}
				}
			}
			if (!((Object)(object)_choiceDialog != (Object)null) || _choiceDialog.activeSelf)
			{
				return;
			}
			Unlock();
			Object.Destroy((Object)(object)_choiceDialog);
			_choiceDialog = null;
			Cancel();
			AvailableItems.ForeachElement(delegate(int i, MultiSelectItemListElement e)
			{
				if (e.IsSelected())
				{
					e.SetItem(e.GetListElement());
					e.Refresh();
				}
			});
			RefreshAugmentSelectors();
			OnAugmentIndexChanged();
		}

		public void OnAugmentSelectorToggled(bool isOn)
		{
			if (isOn)
			{
				for (int i = 0; i < AugmentSelectors.Count; i++)
				{
					if (AugmentSelectors[i].isOn)
					{
						SelectAugmentIndex(i);
						break;
					}
				}
			}
			else if (!AugmentSelectors.Any((Toggle x) => x.isOn))
			{
				SelectAugmentIndex(-1);
			}
		}

		public void SelectAugmentIndex(int index)
		{
			if (index != _augmentIndex)
			{
				_augmentIndex = index;
				OnAugmentIndexChanged();
			}
		}

		public void OnAugmentIndexChanged()
		{
			Tuple<InventoryItemListElement, int> singleSelectedItem = AvailableItems.GetSingleSelectedItem<InventoryItemListElement>();
			if (singleSelectedItem?.Item1.GetItem() == null)
			{
				((Selectable)MainButton).interactable = false;
				AvailableEffectsText.text = "";
				((Behaviour)CostLabel).enabled = false;
				CostList.SetItems(new List<IListElement>());
				_augmentIndex = -1;
				{
					foreach (Toggle augmentSelector in AugmentSelectors)
					{
						augmentSelector.isOn = false;
					}
					return;
				}
			}
			if (_augmentIndex < 0)
			{
				AvailableEffectsText.text = string.Empty;
				((Behaviour)CostLabel).enabled = false;
				CostList.SetItems(new List<IListElement>());
				((Selectable)MainButton).interactable = false;
				return;
			}
			ItemData item = singleSelectedItem.Item1.GetItem();
			string text = GetAvailableEffects(item, _augmentIndex);
			AvailableEffectsText.text = text;
			ScrollEnchantInfoToTop();
			((Behaviour)CostLabel).enabled = true;
			List<InventoryItemListElement> list = GetAugmentCost(item, _augmentIndex);
			CostList.SetItems(list.Cast<IListElement>().ToList());
			Tuple<float, float> featureCurrentValue = EnchantingTableUI.instance.SourceTable.GetFeatureCurrentValue(EnchantingFeature.Augment);
			float num = (float.IsNaN(featureCurrentValue.Item2) ? 0f : featureCurrentValue.Item2);
			if (num > 0f)
			{
				CostLabel.text = Localization.instance.Localize($"$mod_epicloot_augmentcost <color=#EAA800>(-{num}% $item_coins!)</color>");
			}
			else
			{
				CostLabel.text = Localization.instance.Localize("$mod_epicloot_augmentcost");
			}
			bool flag = EnchantingTableUIPanelBase.LocalPlayerCanAffordCost(list);
			bool flag2 = EnchantingTableUI.instance.SourceTable.IsFeatureUnlocked(EnchantingFeature.Augment);
			((Selectable)MainButton).interactable = flag2 && flag && _augmentIndex >= 0;
		}

		private void ScrollEnchantInfoToTop()
		{
			AvailableEffectsScrollbar.value = 1f;
		}

		protected override void DoMainAction()
		{
			Tuple<InventoryItemListElement, int> singleSelectedItem = AvailableItems.GetSingleSelectedItem<InventoryItemListElement>();
			if (singleSelectedItem?.Item1.GetItem() == null)
			{
				Cancel();
				return;
			}
			ItemData item = singleSelectedItem.Item1.GetItem();
			List<InventoryItemListElement> list = GetAugmentCost(item, _augmentIndex);
			Player localPlayer = Player.m_localPlayer;
			if (!localPlayer.NoCostCheat())
			{
				if (!EnchantingTableUIPanelBase.LocalPlayerCanAffordCost(list))
				{
					Debug.LogError((object)"[Augment Item] ERROR: Tried to augment item but could not afford the cost. This should not happen!");
					return;
				}
				Inventory inventory = ((Humanoid)localPlayer).GetInventory();
				foreach (InventoryItemListElement item3 in list)
				{
					ItemData item2 = item3.GetItem();
					inventory.RemoveItem(item2.m_shared.m_name, item2.m_stack, -1, true);
				}
			}
			if ((Object)(object)_choiceDialog != (Object)null)
			{
				Object.Destroy((Object)(object)_choiceDialog);
			}
			_choiceDialog = AugmentItem(item, _augmentIndex);
			Lock();
		}

		protected override void OnSelectedItemsChanged()
		{
			ItemData val = AvailableItems.GetSingleSelectedItem<InventoryItemListElement>()?.Item1.GetItem();
			List<Tuple<string, bool>> list = GetAugmentableEffects(val);
			if (list.Count > AugmentSelectors.Count)
			{
				Debug.LogError((object)$"[Epic Loot] ERROR: Too many magic effects to show! (Max: {AugmentSelectors.Count})");
			}
			for (int i = 0; i < AugmentSelectors.Count; i++)
			{
				Toggle val2 = AugmentSelectors[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				val2.SetIsOnWithoutNotify(i == 0);
				((Component)val2).gameObject.SetActive(val != null && i < list.Count);
				if (((Component)val2).gameObject.activeSelf)
				{
					Text componentInChildren = ((Component)val2).GetComponentInChildren<Text>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						componentInChildren.text = list[i].Item1;
						((Selectable)val2).interactable = list[i].Item2;
					}
				}
			}
			if (val == null)
			{
				AvailableEffectsText.text = string.Empty;
			}
			_augmentIndex = 0;
			OnAugmentIndexChanged();
		}

		private void RefreshAugmentSelectors()
		{
			ItemData val = AvailableItems.GetSingleSelectedItem<InventoryItemListElement>()?.Item1.GetItem();
			List<Tuple<string, bool>> list = GetAugmentableEffects(val);
			for (int i = 0; i < AugmentSelectors.Count; i++)
			{
				Toggle val2 = AugmentSelectors[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				val2.SetIsOnWithoutNotify(i == _augmentIndex);
				((Component)val2).gameObject.SetActive(val != null && i < list.Count);
				if (((Component)val2).gameObject.activeSelf)
				{
					Text componentInChildren = ((Component)val2).GetComponentInChildren<Text>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						componentInChildren.text = list[i].Item1;
						((Selectable)val2).interactable = list[i].Item2;
					}
				}
			}
		}

		public override bool CanCancel()
		{
			if (!base.CanCancel())
			{
				if ((Object)(object)_choiceDialog != (Object)null)
				{
					return _choiceDialog.activeSelf;
				}
				return false;
			}
			return true;
		}

		public override void Cancel()
		{
			base.Cancel();
			OnAugmentIndexChanged();
		}

		public override void Lock()
		{
			base.Lock();
			foreach (Toggle augmentSelector in AugmentSelectors)
			{
				((Selectable)augmentSelector).interactable = false;
			}
		}

		public override void Unlock()
		{
			base.Unlock();
			foreach (Toggle augmentSelector in AugmentSelectors)
			{
				((Selectable)augmentSelector).interactable = true;
			}
		}

		public override void DeselectAll()
		{
			AvailableItems.DeselectAll();
		}
	}
	[RequireComponent(typeof(CanvasGroup))]
	public class EnchantBonus : MonoBehaviour
	{
		public float Delay = 1f;

		public float FadeTime = 1f;

		private CanvasGroup _group;

		private Coroutine _coroutine;

		public void Awake()
		{
			_group = ((Component)this).GetComponent<CanvasGroup>();
			_group.alpha = 0f;
		}

		public void OnEnable()
		{
			_group.alpha = 0f;
		}

		public void OnDestroy()
		{
			if (_coroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_coroutine);
			}
		}

		public IEnumerator FadeOut()
		{
			yield return (object)new WaitForSeconds(Delay);
			while (_group.alpha > 0f)
			{
				CanvasGroup group = _group;
				group.alpha -= Time.deltaTime * (1f / FadeTime);
				yield return null;
			}
		}

		public void Show()
		{
			if (_coroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_coroutine);
			}
			_group.alpha = 1f;
			_coroutine = ((MonoBehaviour)this).StartCoroutine(FadeOut());
		}
	}
	public class FeatureStatus : MonoBehaviour
	{
		public delegate void MakeFeatureUnlockTooltipDelegate(GameObject obj);

		public delegate bool UpgradesActiveDelegate(EnchantingFeature feature, out bool featureActive);

		public EnchantingFeature Feature;

		public Transform UnlockedContainer;

		public Transform LockedContainer;

		public GameObject UnlockedLabel;

		public Image[] Stars;

		public Text ManyStarsLabel;

		public UITooltip Tooltip;

		public static MakeFeatureUnlockTooltipDelegate MakeFeatureUnlockTooltip;

		public static UpgradesActiveDelegate UpgradesActive;

		public void Awake()
		{
			if ((Object)(object)Tooltip != (Object)null)
			{
				MakeFeatureUnlockTooltip(((Component)Tooltip).gameObject);
			}
		}

		public void OnEnable()
		{
			if ((Object)(object)EnchantingTableUI.instance != (Object)null && (Object)(object)EnchantingTableUI.instance.SourceTable != (Object)null)
			{
				EnchantingTableUI.instance.SourceTable.OnFeatureLevelChanged += OnFeatureLevelChanged;
			}
			Refresh();
		}

		public void OnDisable()
		{
			if ((Object)(object)EnchantingTableUI.instance != (Object)null && (Object)(object)EnchantingTableUI.instance.SourceTable != (Object)null)
			{
				EnchantingTableUI.instance.SourceTable.OnFeatureLevelChanged -= OnFeatureLevelChanged;
			}
		}

		public void SetFeature(EnchantingFeature feature)
		{
			if (Feature != feature)
			{
				Feature = feature;
				Refresh();
			}
		}

		public void Refresh()
		{
			if ((Object)(object)EnchantingTableUI.instance == (Object)null || (Object)(object)EnchantingTableUI.instance.SourceTable == (Object)null)
			{
				return;
			}
			if (!EnchantingTableUI.instance.SourceTable.IsFeatureAvailable(Feature))
			{
				if ((Object)(object)UnlockedContainer != (Object)null)
				{
					((Component)UnlockedContainer).gameObject.SetActive(false);
				}
				if ((Object)(object)LockedContainer != (Object)null)
				{
					((Component)LockedContainer).gameObject.SetActive(false);
				}
				return;
			}
			bool featureActive;
			if (EnchantingTableUI.instance.SourceTable.IsFeatureLocked(Feature))
			{
				if ((Object)(object)UnlockedContainer != (Object)null)
				{
					((Component)UnlockedContainer).gameObject.SetActive(false);
				}
				if ((Object)(object)LockedContainer != (Object)null)
				{
					((Component)LockedContainer).gameObject.SetActive(true);
				}
			}
			else
			{
				if ((Object)(object)UnlockedContainer != (Object)null)
				{
					((Component)UnlockedContainer).gameObject.SetActive(true);
				}
				if ((Object)(object)LockedContainer != (Object)null)
				{
					((Component)LockedContainer).gameObject.SetActive(false);
				}
				int featureLevel = EnchantingTableUI.instance.SourceTable.GetFeatureLevel(Feature);
				if (featureLevel > Stars.Length)
				{
					for (int i = 0; i < Stars.Length; i++)
					{
						((Behaviour)Stars[i]).enabled = i == 0;
					}
					if ((Object)(object)ManyStarsLabel != (Object)null)
					{
						((Behaviour)ManyStarsLabel).enabled = true;
						ManyStarsLabel.text = $"×{featureLevel}";
					}
				}
				else
				{
					for (int j = 0; j < Stars.Length; j++)
					{
						((Component)Stars[j]).gameObject.SetActive(featureLevel > j && UpgradesActive(Feature, out featureActive));
					}
					if ((Object)(object)ManyStarsLabel != (Object)null)
					{
						((Behaviour)ManyStarsLabel).enabled = false;
					}
				}
				if ((Object)(object)UnlockedLabel != (Object)null)
				{
					UnlockedLabel.SetActive(featureLevel == 0);
				}
			}
			if ((Object)(object)Tooltip != (Object)null && UpgradesActive(Feature, out featureActive))
			{
				Tooltip.m_topic = Localization.instance.Localize(EnchantingTableUpgrades.GetFeatureName(Feature));
				StringBuilder stringBuilder = new StringBuilder();
				bool num = EnchantingTableUI.instance.SourceTable.IsFeatureLocked(Feature);
				int featureLevel2 = EnchantingTableUI.instance.SourceTable.GetFeatureLevel(Feature);
				int featureMaxLevel = EnchantingTableUpgrades.GetFeatureMaxLevel(Feature);
				if (num)
				{
					stringBuilder.AppendLine(Localization.instance.Localize("$mod_epicloot_currentlevel: <color=#AD1616><b>$mod_epicloot_featurelocked</b></color>"));
				}
				else if (featureLevel2 == 0)
				{
					stringBuilder.AppendLine(Localization.instance.Localize($"$mod_epicloot_currentlevel: <color=#1AACEF><b>$mod_epicloot_featureunlocked</b></color> / {featureMaxLevel}"));
				}
				else
				{
					stringBuilder.AppendLine(Localization.instance.Localize($"$mod_epicloot_currentlevel: <color=#EAA800><b>{featureLevel2}</b></color> / {featureMaxLevel}"));
				}
				if (!num && featureLevel2 > 0)
				{
					string featureUpgradeLevelDescription = EnchantingTableUpgrades.GetFeatureUpgradeLevelDescription(EnchantingTableUI.instance.SourceTable, Feature, featureLevel2);
					stringBuilder.AppendLine("<color=#EAA800>" + featureUpgradeLevelDescription + "</color>");
				}
				stringBuilder.AppendLine();
				stringBuilder.AppendLine(Localization.instance.Localize(EnchantingTableUpgrades.GetFeatureDescription(Feature)));
				Tooltip.m_text = Localization.instance.Localize(stringBuilder.ToString());
			}
		}

		private void OnFeatureLevelChanged(EnchantingFeature feature, int _)
		{
			if (((Behaviour)this).isActiveAndEnabled && feature == Feature)
			{
				Refresh();
			}
		}
	}
	public class DisenchantUI : EnchantingTableUIPanelBase
	{
		public delegate List<InventoryItemListElement> GetDisenchantItemsDelegate();

		public delegate List<InventoryItemListElement> GetDisenchantCostDelegate(ItemData item);

		public delegate List<InventoryItemListElement> DisenchantItemDelegate(ItemData item);

		public Text CostLabel;

		public MultiSelectItemList CostList;

		public EnchantBonus BonusPanel;

		public static GetDisenchantItemsDelegate GetDisenchantItems;

		public static GetDisenchantCostDelegate GetDisenchantCost;

		public static DisenchantItemDelegate DisenchantItem;

		[UsedImplicitly]
		public void OnEnable()
		{
			List<InventoryItemListElement> source = GetDisenchantItems();
			AvailableItems.SetItems(source.Cast<IListElement>().ToList());
			AvailableItems.DeselectAll();
		}

		protected override void DoMainAction()
		{
			Cancel();
			Tuple<IListElement, int> singleSelectedItem = AvailableItems.GetSingleSelectedItem<IListElement>();
			if (singleSelectedItem?.Item1.GetItem() == null)
			{
				return;
			}
			ItemData item = singleSelectedItem.Item1.GetItem();
			List<InventoryItemListElement> list = GetDisenchantCost(item);
			if (!EnchantingTableUIPanelBase.LocalPlayerCanAffordCost(list))
			{
				return;
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			foreach (InventoryItemListElement item3 in list)
			{
				ItemData item2 = item3.GetItem();
				inventory.RemoveItem(item2.m_shared.m_name, item2.m_stack, -1, true);
			}
			List<InventoryItemListElement> list2 = DisenchantItem(item);
			if (list2.Count > 0)
			{
				EnchantingTableUI.instance.PlayEnchantBonusSFX();
				BonusPanel.Show();
				EnchantingTableUIPanelBase.GiveItemsToPlayer(list2);
			}
			RefreshAvailableItems();
		}

		public void RefreshAvailableItems()
		{
			List<InventoryItemListElement> source = GetDisenchantItems();
			AvailableItems.SetItems(source.Cast<IListElement>().ToList());
			AvailableItems.DeselectAll();
			OnSelectedItemsChanged();
		}

		protected override void OnSelectedItemsChanged()
		{
			Tuple<InventoryItemListElement, int> singleSelectedItem = AvailableItems.GetSingleSelectedItem<InventoryItemListElement>();
			if (singleSelectedItem != null)
			{
				((Behaviour)CostLabel).enabled = true;
				List<InventoryItemListElement> list = GetDisenchantCost(singleSelectedItem.Item1.GetItem());
				CostList.SetItems(list.Cast<IListElement>().ToList());
				Tuple<float, float> featureCurrentValue = EnchantingTableUI.instance.SourceTable.GetFeatureCurrentValue(EnchantingFeature.Disenchant);
				int num = ((!float.IsNaN(featureCurrentValue.Item2)) ? ((int)featureCurrentValue.Item2) : 0);
				if (num > 0 && list.Count > 0)
				{
					CostLabel.text = Localization.instance.Localize("$mod_epicloot_disenchantcost <color=#EAA800>($mod_epicloot_disenchantcostreduction)</color>", new string[1] { num.ToString() });
				}
				else
				{
					CostLabel.text = Localization.instance.Localize("$mod_epicloot_disenchantcost");
				}
				bool flag = EnchantingTableUIPanelBase.LocalPlayerCanAffordCost(list);
				bool flag2 = EnchantingTableUI.instance.SourceTable.IsFeatureUnlocked(EnchantingFeature.Disenchant);
				((Selectable)MainButton).interactable = flag2 && flag;
			}
			else
			{
				CostList.SetItems(new List<IListElement>());
				((Behaviour)CostLabel).enabled = false;
				((Selectable)MainButton).interactable = false;
			}
		}

		public override void DeselectAll()
		{
			AvailableItems.DeselectAll();
		}
	}
	public class EnchantingTable : MonoBehaviour, Hoverable, Interactable
	{
		public delegate bool UpgradesActiveDelegate(EnchantingFeature feature, out bool featureActive);

		public const float UseDistance = 2.7f;

		public const string DisplayNameLocID = "mod_epicloot_assets_enchantingtable";

		public const int FeatureUnavailableSentinel = -2;

		public const int FeatureLockedSentinel = -1;

		public const int FeatureLevelOne = 1;

		public GameObject EnchantingUIPrefab;

		public static UpgradesActiveDelegate UpgradesActive;

		private static readonly List<EnchantingFeatureUpgradeRequest> _upgradeRequests = new List<EnchantingFeatureUpgradeRequest>();

		private ZNetView _nview;

		private Player _interactingPlayer;

		public event Action<EnchantingFeature, int> OnFeatureLevelChanged;

		public event Action OnAnyFeatureLevelChanged;

		public bool Interact(Humanoid user, bool repeat, bool alt)
		{
			if (repeat || (Object)(object)user != (Object)(object)Player.m_localPlayer || !InUseDistance(user))
			{
				return false;
			}
			EnchantingTableUI.Show(EnchantingUIPrefab, this);
			_interactingPlayer = Player.m_localPlayer;
			return false;
		}

		public void Awake()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: 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)
			//IL_007e: Expected O, but got Unknown
			//IL_0091: 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_00ac: Expected O, but got Unknown
			_nview = ((Component)this).GetComponent<ZNetView>();
			if (!((Object)(object)_nview == (Object)null) && _nview.GetZDO() != null)
			{
				WearNTear component = ((Component)this).GetComponent<WearNTear>();
				if ((Object)(object)component != (Object)null)
				{
					component.m_destroyedEffect.m_effectPrefabs = (EffectData[])(object)new EffectData[2]
					{
						new EffectData
						{
							m_prefab = ZNetScene.instance.GetPrefab("vfx_SawDust")
						},
						new EffectData
						{
							m_prefab = ZNetScene.instance.GetPrefab("sfx_wood_destroyed")
						}
					};
					component.m_hitEffect.m_effectPrefabs = (EffectData[])(object)new EffectData[1]
					{
						new EffectData
						{
							m_prefab = ZNetScene.instance.GetPrefab("vfx_SawDust")
						}
					};
				}
				_nview.Register<ZDOID, int, int>("el.TableUpgradeRequest", (Action<long, ZDOID, int, int>)RPC_TableUpgradeRequest);
				_nview.Register<ZDOID, int, int, bool>("el.TableUpgradeResponse", (Method<ZDOID, int, int, bool>)RPC_TableUpgradeResponse);
				InitFeatureLevels();
			}
		}

		public void RequestTableUpgrade(EnchantingFeature feature, int toLevel, Action<bool> responseCallback)
		{
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			ZDOID uid = _nview.GetZDO().m_uid;
			_upgradeRequests.Add(new EnchantingFeatureUpgradeRequest
			{
				TableZDO = uid,
				Feature = feature,
				ToLevel = toLevel,
				ResponseCallback = responseCallback
			});
			_nview.InvokeRPC("el.TableUpgradeRequest", new object[3]
			{
				uid,
				(int)feature,
				toLevel
			});
		}

		private void RPC_TableUpgradeRequest(long sender, ZDOID tableZDO, int featureI, int toLevel)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!_nview.IsOwner())
			{
				return;
			}
			GameObject val = ZNetScene.instance.FindInstance(tableZDO);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			EnchantingTable component = val.GetComponent<EnchantingTable>();
			if (!((Object)(object)component == (Object)null))
			{
				if (component.IsFeatureAvailable((EnchantingFeature)featureI) && toLevel == component.GetFeatureLevel((EnchantingFeature)featureI) + 1)
				{
					component.SetFeatureLevel((EnchantingFeature)featureI, toLevel);
					_nview.InvokeRPC(sender, "el.TableUpgradeResponse", new object[4] { tableZDO, featureI, toLevel, true });
					this.OnFeatureLevelChanged?.Invoke((EnchantingFeature)featureI, toLevel);
					this.OnAnyFeatureLevelChanged?.Invoke();
				}
				else
				{
					_nview.InvokeRPC(sender, "el.TableUpgradeResponse", new object[4] { tableZDO, featureI, toLevel, false });
				}
			}
		}

		private void RPC_TableUpgradeResponse(long sender, ZDOID tableZDO, int featureI, int toLevel, bool success)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			foreach (EnchantingFeatureUpgradeRequest item in _upgradeRequests.ToList())
			{
				if (!(item.TableZDO == tableZDO) || item.Feature != (EnchantingFeature)featureI || item.ToLevel != toLevel)
				{
					continue;
				}
				item.ResponseCallback(success);
				_upgradeRequests.Remove(item);
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					if (toLevel == 0)
					{
						((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize("$mod_epicloot_unlockmessage", new string[1] { EnchantingTableUpgrades.GetFeatureName((EnchantingFeature)featureI) }), 0, (Sprite)null);
					}
					else
					{
						((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize("$mod_epicloot_upgrademessage", new string[2]
						{
							EnchantingTableUpgrades.GetFeatureName((EnchantingFeature)featureI),
							toLevel.ToString()
						}), 0, (Sprite)null);
					}
				}
			}
		}

		public void Update()
		{
			if ((Object)(object)_interactingPlayer != (Object)null && (Object)(object)EnchantingTableUI.instance != (Object)null && ((Behaviour)EnchantingTableUI.instance).isActiveAndEnabled && !InUseDistance((Humanoid)(object)_interactingPlayer))
			{
				EnchantingTableUI.Hide();
				_interactingPlayer = null;
			}
		}

		public void Refresh()
		{
			this.OnAnyFeatureLevelChanged?.Invoke();
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		public bool InUseDistance(Humanoid human)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return Vector3.Distance(((Component)human).transform.position, ((Component)this).transform.position) < 2.7f;
		}

		public string GetHoverText()
		{
			if (InUseDistance((Humanoid)(object)Player.m_localPlayer))
			{
				return Localization.instance.Localize("$mod_epicloot_assets_enchantingtable\n[<color=yellow><b>$KEY_Use</b></color>] $piece_use");
			}
			return Localization.instance.Localize("<color=#808080ff>$piece_toofar</color>");
		}

		public string GetHoverName()
		{
			return "mod_epicloot_assets_enchantingtable";
		}

		private string FormatFeatureName(string featureName)
		{
			return string.Format("el.et.v1." + featureName);
		}

		private void InitFeatureLevels()
		{
			foreach (EnchantingFeature value in Enum.GetValues(typeof(EnchantingFeature)))
			{
				string featureName = value.ToString();
				if (_nview.GetZDO().GetInt(FormatFeatureName(featureName), -888) == -888)
				{
					_nview.GetZDO().Set(FormatFeatureName(featureName), GetDefaultFeatureLevel(value) + 1);
				}
			}
		}

		private static int GetDefaultFeatureLevel(EnchantingFeature feature)
		{
			if (!UpgradesActive(feature, out var featureActive))
			{
				return 1;
			}
			if (!featureActive)
			{
				return -2;
			}
			if (!EnchantingTableUpgrades.Config.DefaultFeatureLevels.TryGetValue(feature, out var value))
			{
				return -2;
			}
			return value;
		}

		public void Reset()
		{
			foreach (EnchantingFeature value in Enum.GetValues(typeof(EnchantingFeature)))
			{
				SetFeatureLevel(value, GetDefaultFeatureLevel(value));
			}
		}

		public int GetFeatureLevel(EnchantingFeature feature)
		{
			if ((Object)(object)_nview == (Object)null || _nview.GetZDO() == null)
			{
				return -2;
			}
			if (!UpgradesActive(feature, out var featureActive))
			{
				return 1;
			}
			if (!featureActive)
			{
				return -2;
			}
			string featureName = feature.ToString();
			int @int = _nview.GetZDO().GetInt(FormatFeatureName(featureName), -2);
			_ = -2;
			if (@int != -2)
			{
				return @int - 1;
			}
			return -2;
		}

		public void SetFeatureLevel(EnchantingFeature feature, int level)
		{
			if (!((Object)(object)_nview == (Object)null))
			{
				int value;
				if (!UpgradesActive(feature, out var _))
				{
					level = 1;
				}
				else if (level > ((!EnchantingTableUpgrades.Config.MaximumFeatureLevels.TryGetValue(feature, out value)) ? 1 : value))
				{
					return;
				}
				string featureName = feature.ToString();
				_nview.GetZDO().Set(FormatFeatureName(featureName), level + 1);
				this.OnFeatureLevelChanged?.Invoke(feature, level);
				this.OnAnyFeatureLevelChanged?.Invoke();
			}
		}

		public bool IsFeatureAvailable(EnchantingFeature feature)
		{
			return GetFeatureLevel(feature) > -2;
		}

		public bool IsFeatureLocked(EnchantingFeature feature)
		{
			return GetFeatureLevel(feature) == -1;
		}

		public bool IsFeatureUnlocked(EnchantingFeature feature)
		{
			return GetFeatureLevel(feature) > -1;
		}

		public bool IsFeatureMaxLevel(EnchantingFeature feature)
		{
			return GetFeatureLevel(feature) == EnchantingTableUpgrades.GetFeatureMaxLevel(feature);
		}

		public List<InventoryItemListElement> GetFeatureUnlockCost(EnchantingFeature feature)
		{
			if (IsFeatureUnlocked(feature))
			{
				Debug.LogWarning((object)$"[EpicLoot] Warning: tried to get unlock cost for a feature that is already unlocked! ({feature})");
			}
			return EnchantingTableUpgrades.GetUpgradeCost(feature, 0);
		}

		public List<InventoryItemListElement> GetFeatureUpgradeCost(EnchantingFeature feature)
		{
			if (IsFeatureLocked(feature) || !IsFeatureAvailable(feature))
			{
				Debug.LogWarning((object)$"[EpicLoot] Warning: tried to get enchanting feature unlock cost for a feature that is locked or unavailable! ({feature})");
			}
			int featureLevel = GetFeatureLevel(feature);
			return EnchantingTableUpgrades.GetUpgradeCost(feature, featureLevel + 1);
		}

		public Tuple<float, float> GetFeatureValue(EnchantingFeature feature, int level)
		{
			if (!IsFeatureAvailable(feature))
			{
				return new Tuple<float, float>(float.NaN, float.NaN);
			}
			if (level < 0 || level > EnchantingTableUpgrades.GetFeatureMaxLevel(feature))
			{
				return new Tuple<float, float>(float.NaN, float.NaN);
			}
			List<float[]> list = feature switch
			{
				EnchantingFeature.Sacrifice => EnchantingTableUpgrades.Config.UpgradeValues.Sacrifice, 
				EnchantingFeature.ConvertMaterials => EnchantingTableUpgrades.Config.UpgradeValues.ConvertMaterials, 
				EnchantingFeature.Enchant => EnchantingTableUpgrades.Config.UpgradeValues.Enchant, 
				EnchantingFeature.Augment => EnchantingTableUpgrades.Config.UpgradeValues.Augment, 
				EnchantingFeature.Disenchant => EnchantingTableUpgrades.Config.UpgradeValues.Disenchant, 
				EnchantingFeature.Helheim => EnchantingTableUpgrades.Config.UpgradeValues.Helheim, 
				_ => throw new ArgumentOutOfRangeException("feature", feature, null), 
			};
			if (level >= list.Count)
			{
				return new Tuple<float, float>(float.NaN, float.NaN);
			}
			float[] array = list[level];
			if (array.Length == 1)
			{
				return new Tuple<float, float>(array[0], float.NaN);
			}
			if (array.Length >= 2)
			{
				return new Tuple<float, float>(array[0], array[1]);
			}
			return new Tuple<float, float>(float.NaN, float.NaN);
		}

		public Tuple<float, float> GetFeatureCurrentValue(EnchantingFeature feature)
		{
			return GetFeatureValue(feature, GetFeatureLevel(feature));
		}
	}
	public class EnchantingTableUI : MonoBehaviour
	{
		public delegate void AugaFixupDelegate(EnchantingTableUI ui);

		public delegate void TabActivationDelegate(EnchantingTableUI ui);

		public GameObject Root;

		public GameObject Scrim;

		public TabHandler TabHandler;

		public GameObject TabScrim;

		[Header("Content")]
		public EnchantingTableUIPanelBase[] Panels;

		[Header("Audio")]
		public AudioSource Audio;

		public AudioClip TabClickSFX;

		public AudioClip EnchantBonusSFX;

		public static AugaFixupDelegate AugaFixup;

		public static TabActivationDelegate TabActivation;

		private int _hiddenFrames;

		public EnchantingTable SourceTable { get; private set; }

		public static EnchantingTableUI instance { get; set; }

		public void Awake()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			instance = this;
			Localization.instance.Localize(((Component)this).transform);
			GameObject val = GameObject.Find("sfx_gui_button");
			if (Object.op_Implicit((Object)(object)val))
			{
				Audio.outputAudioMixerGroup = val.GetComponent<AudioSource>().outputAudioMixerGroup;
			}
			for (int i = 0; i < TabHandler.m_tabs.Count; i++)
			{
				Tab obj = TabHandler.m_tabs[i];
				obj.m_onClick.AddListener(new UnityAction(PlayTabSelectSFX));
				FeatureStatus component = ((Component)obj.m_button).gameObject.GetComponent<FeatureStatus>();
				if ((Object)(object)component != (Object)null)
				{
					component.SetFeature((EnchantingFeature)i);
				}
			}
			AugaFixup(this);
			TabActivation(this);
		}

		public static void Show(GameObject enchantingUiPrefab, EnchantingTable source)
		{
			if ((Object)(object)instance == (Object)null && (Object)(object)StoreGui.instance != (Object)null)
			{
				Transform parent = ((Component)StoreGui.instance).transform.parent;
				int siblingIndex = ((Component)StoreGui.instance).transform.GetSiblingIndex() + 1;
				Object.Instantiate<GameObject>(enchantingUiPrefab, parent).transform.SetSiblingIndex(siblingIndex);
			}
			if (!((Object)(object)instance == (Object)null))
			{
				instance.SourceTable = source;
				instance.Root.SetActive(true);
				instance.Scrim.SetActive(true);
				instance.SourceTable.Refresh();
				EnchantingTableUIPanelBase[] panels = instance.Panels;
				for (int i = 0; i < panels.Length; i++)
				{
					panels[i].DeselectAll();
				}
			}
		}

		public static void Hide()
		{
			if (!((Object)(object)instance == (Object)null))
			{
				instance.Root.SetActive(false);
				instance.Scrim.SetActive(false);
				instance.SourceTable = null;
			}
		}

		public static bool IsVisible()
		{
			if ((Object)(object)instance != (Object)null)
			{
				if (instance._hiddenFrames > 2)
				{
					if ((Object)(object)instance.Root != (Object)null)
					{
						return instance.Root.activeSelf;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		public static bool IsInTextInput()
		{
			if (!IsVisible())
			{
				return false;
			}
			InputField[] componentsInChildren = instance.Root.GetComponentsInChildren<InputField>(false);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (componentsInChildren[i].isFocused)
				{
					return true;
				}
			}
			return false;
		}

		public void Update()
		{
			if ((Object)(object)Root == (Object)null)
			{
				return;
			}
			if (!Root.activeSelf)
			{
				_hiddenFrames++;
				return;
			}
			_hiddenFrames = 0;
			if (((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus()) || Console.IsVisible() || Menu.IsVisible() || ((Object)(object)TextViewer.instance != (Object)null && TextViewer.instance.IsVisible()) || ((Character)Player.m_localPlayer).InCutscene() || (!ZInput.GetButtonDown("JoyButtonB") && !Input.GetKeyDown((KeyCode)27) && !Input.GetKeyDown((KeyCode)9)))
			{
				return;
			}
			ZInput.ResetButtonStatus("JoyButtonB");
			ZInput.ResetButtonStatus("JoyJump");
			bool flag = false;
			EnchantingTableUIPanelBase[] panels = Panels;
			foreach (EnchantingTableUIPanelBase enchantingTableUIPanelBase in panels)
			{
				if (((Behaviour)enchantingTableUIPanelBase).isActiveAndEnabled && enchantingTableUIPanelBase.CanCancel())
				{
					enchantingTableUIPanelBase.Cancel();
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Hide();
			}
		}

		public static void UpdateTabActivation()
		{
			TabActivation(instance);
		}

		public static void UpdateUpgradeActivation()
		{
			TabActivation(instance);
		}

		public void LockTabs()
		{
			TabScrim.SetActive(true);
		}

		public void UnlockTabs()
		{
			TabScrim.SetActive(false);
		}

		public void PlayTabSelectSFX()
		{
			Audio.PlayOneShot(TabClickSFX);
		}

		public void PlayEnchantBonusSFX()
		{
			Audio.PlayOneShot(EnchantBonusSFX);
		}
	}
	public abstract class EnchantingTableUIPanelBase : MonoBehaviour
	{
		public const float CountdownTime = 0.8f;

		public MultiSelectItemList AvailableItems;

		public Button MainButton;

		public GameObject LevelDisplay;

		public GuiBar ProgressBar;

		public AudioSource Audio;

		public AudioClip ProgressLoopSFX;

		public AudioClip CompleteSFX;

		protected bool _inProgress;

		protected float _countdown;

		protected Text _buttonLabel;

		protected TMP_Text _tmpButtonLabel;

		protected bool _useTMP;

		protected string _defaultButtonLabelText;

		protected bool _locked;

		protected abstract void DoMainAction();

		protected abstract void OnSelectedItemsChanged();

		public virtual void Awake()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			if ((Object)(object)AvailableItems != (Object)null)
			{
				AvailableItems.OnSelectedItemsChanged += OnSelectedItemsChanged;
				AvailableItems.GiveFocus(focused: true, 0);
			}
			if ((Object)(object)MainButton != (Object)null)
			{
				((UnityEvent)MainButton.onClick).AddListener(new UnityAction(OnMainButtonClicked));
				_buttonLabel = ((Component)MainButton).GetComponentInChildren<Text>();
				if ((Object)(object)_buttonLabel == (Object)null)
				{
					_tmpButtonLabel = ((Component)MainButton).GetComponentInChildren<TMP_Text>();
					_useTMP = true;
				}
				_defaultButtonLabelText = (_useTMP ? _tmpButtonLabel.text : _buttonLabel.text);
			}
			GameObject val = GameObject.Find("sfx_gui_button");
			if (Object.op_Implicit((Object)(object)val) && (Object)(object)Audio != (Object)null)
			{
				Audio.outputAudioMixerGroup = val.GetComponent<AudioSource>().outputAudioMixerGroup;
			}
		}

		protected virtual void OnMainButtonClicked()
		{
			if (_inProgress)
			{
				Cancel();
			}
			else
			{
				StartProgress();
			}
		}

		public virtual void DeselectAll()
		{
		}

		public virtual void Update()
		{
			if ((Object)(object)ProgressBar != (Object)null)
			{
				((Component)ProgressBar).gameObject.SetActive(_inProgress);
			}
			if ((Object)(object)LevelDisplay != (Object)null)
			{
				LevelDisplay.gameObject.SetActive(!_inProgress);
			}
			if (!_inProgress)
			{
				return;
			}
			if ((Object)(object)ProgressBar != (Object)null)
			{
				ProgressBar.SetValue(0.8f - _countdown);
			}
			_countdown -= Time.deltaTime;
			if (_countdown < 0f)
			{
				_inProgress = false;
				_countdown = 0f;
				if ((Object)(object)Audio != (Object)null)
				{
					Audio.loop = false;
					Audio.Stop();
				}
				DoMainAction();
				PlayCompleteSFX();
			}
		}

		private void PlayCompleteSFX()
		{
			AudioClip completeAudioClip = GetCompleteAudioClip();
			if ((Object)(object)Audio != (Object)null && (Object)(object)completeAudioClip != (Object)null)
			{
				Audio.PlayOneShot(completeAudioClip);
			}
		}

		protected virtual AudioClip GetCompleteAudioClip()
		{
			return CompleteSFX;
		}

		public virtual void StartProgress()
		{
			if (_useTMP)
			{
				_tmpButtonLabel.text = Localization.instance.Localize("$menu_cancel");
			}
			else
			{
				_buttonLabel.text = Localization.instance.Localize("$menu_cancel");
			}
			_inProgress = true;
			_countdown = 0.8f;
			if ((Object)(object)ProgressBar != (Object)null)
			{
				ProgressBar.SetMaxValue(0.8f);
			}
			if ((Object)(object)Audio != (Object)null)
			{
				Audio.loop = true;
				Audio.clip = ProgressLoopSFX;
				Audio.Play();
			}
			Lock();
		}

		public virtual bool CanCancel()
		{
			return _inProgress;
		}

		public virtual void Cancel()
		{
			if (_useTMP)
			{
				_tmpButtonLabel.text = Localization.instance.Localize(_defaultButtonLabelText);
			}
			else
			{
				_buttonLabel.text = Localization.instance.Localize(_defaultButtonLabelText);
			}
			_inProgress = false;
			_countdown = 0f;
			if ((Object)(object)Audio != (Object)null)
			{
				Audio.loop = false;
				Audio.Stop();
			}
			Unlock();
		}

		public virtual void Lock()
		{
			_locked = true;
			MultiSelectItemList[] componentsInChildren = ((Component)this).GetComponentsInChildren<MultiSelectItemList>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].Lock();
			}
			EnchantingTableUI.instance.LockTabs();
		}

		public virtual void Unlock()
		{
			_locked = false;
			MultiSelectItemList[] componentsInChildren = ((Component)this).GetComponentsInChildren<MultiSelectItemList>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].Unlock();
			}
			EnchantingTableUI.instance.UnlockTabs();
		}

		protected static bool LocalPlayerCanAffordCost(List<InventoryItemListElement> cost)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer.NoCostCheat())
			{
				return true;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			foreach (InventoryItemListElement item2 in cost)
			{
				ItemData item = item2.GetItem();
				if (inventory.CountItems(item.m_shared.m_name, -1, true) < item.m_stack)
				{
					return false;
				}
			}
			return true;
		}

		protected static void GiveItemsToPlayer(List<InventoryItemListElement> sacrificeProducts)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			foreach (InventoryItemListElement sacrificeProduct in sacrificeProducts)
			{
				ItemData item = sacrificeProduct.GetItem();
				do
				{
					ItemData val = item.Clone();
					val.m_stack = Mathf.Min(item.m_stack, item.m_shared.m_maxStackSize);
					item.m_stack -= val.m_stack;
					if (inventory.CanAddItem(val, -1))
					{
						inventory.AddItem(val);
						((Character)localPlayer).Message((MessageType)1, "$msg_added " + val.m_shared.m_name, val.m_stack, val.GetIcon());
					}
					else
					{
						ItemDrop val2 = ItemDrop.DropItem(val, val.m_stack, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward + ((Component)localPlayer).transform.up, ((Component)localPlayer).transform.rotation);
						((Component)val2).GetComponent<Rigidbody>().velocity = Vector3.up * 5f;
						((Character)localPlayer).Message((MessageType)1, "$msg_dropped " + val2.m_itemData.m_shared.m_name + " $mod_epicloot_sacrifice_inventoryfullexplanation", val2.m_itemData.m_stack, val2.m_itemData.GetIcon());
					}
				}
				while (item.m_stack > 0);
			}
		}
	}
	public enum EnchantingFeature
	{
		Sacrifice,
		ConvertMaterials,
		Enchant,
		Augment,
		Disenchant,
		Helheim
	}
	[Serializable]
	public class ItemAmount
	{
		public string Item = "";

		public int Amount = 1;
	}
	[Serializable]
	public class EnchantingUpgradeCosts
	{
		public List<List<ItemAmount>> Sacrifice;

		public List<List<ItemAmount>> ConvertMaterials;

		public List<List<ItemAmount>> Enchant;

		public List<List<ItemAmount>> Augment;

		public List<List<ItemAmount>> Disenchant;

		public List<List<ItemAmount>> Helheim;
	}
	[Serializable]
	public class EnchantingFeatureValues
	{
		public List<float[]> Sacrifice;

		public List<float[]> ConvertMaterials;

		public List<float[]> Enchant;

		public List<float[]> Augment;

		public List<float[]> Disenchant;

		public List<float[]> Helheim;
	}
	[Serializable]
	public class EnchantingUpgradesConfig
	{
		public Dictionary<EnchantingFeature, int> DefaultFeatureLevels;

		public Dictionary<EnchantingFeature, int> MaximumFeatureLevels;

		public EnchantingUpgradeCosts UpgradeCosts;

		public EnchantingFeatureValues UpgradeValues;
	}
	public class EnchantingFeatureUpgradeRequest
	{
		public ZDOID TableZDO;

		public EnchantingFeature Feature;

		public int ToLevel;

		public Action<bool> ResponseCallback;
	}
	public static class EnchantingTableUpgrades
	{
		public static EnchantingUpgradesConfig Config;

		public static void InitializeConfig(EnchantingUpgradesConfig config)
		{
			Config = config;
		}

		public static string GetFeatureName(EnchantingFeature feature)
		{
			return (new string[6] { "$mod_epicloot_sacrifice", "$mod_epicloot_convertmaterials", "$mod_epicloot_enchant", "$mod_epicloot_augment", "$mod_epicloot_disenchant", "$mod_epicloot_helheim" })[(int)feature];
		}

		public static string GetFeatureDescription(EnchantingFeature feature)
		{
			return (new string[6] { "$mod_epicloot_featureinfo_sacrifice", "$mod_epicloot_featureinfo_convertmaterials", "$mod_epicloot_featureinfo_enchant", "$mod_epicloot_featureinfo_augment", "$mod_epicloot_featureinfo_disenchant", "$mod_epicloot_featureinfo_helheim" })[(int)feature];
		}

		public static string GetFeatureUpgradeLevelDescription(EnchantingTable table, EnchantingFeature feature, int level)
		{
			string[] array = new string[6] { "$mod_epicloot_featureupgrade_sacrifice", "$mod_epicloot_featureupgrade_convertmaterials", "$mod_epicloot_featureupgrade_enchant", "$mod_epicloot_featureupgrade_augment", "$mod_epicloot_featureupgrade_disenchant", "$mod_epicloot_featureupgrade_helheim" };
			Tuple<float, float> featureValue = table.GetFeatureValue(feature, level);
			return Localization.instance.Localize(array[(int)feature], new string[2]
			{
				featureValue.Item1.ToString("0.#"),
				featureValue.Item2.ToString("0.#")
			});
		}

		public static int GetFeatureMaxLevel(EnchantingFeature feature)
		{
			if (!Config.MaximumFeatureLevels.TryGetValue(feature, out var value))
			{
				return 1;
			}
			return value;
		}

		public static List<InventoryItemListElement> GetUpgradeCost(EnchantingFeature feature, int level)
		{
			List<InventoryItemListElement> list = new List<InventoryItemListElement>();
			List<List<ItemAmount>> list2 = feature switch
			{
				EnchantingFeature.Sacrifice => Config.UpgradeCosts.Sacrifice, 
				EnchantingFeature.ConvertMaterials => Config.UpgradeCosts.ConvertMaterials, 
				EnchantingFeature.Enchant => Config.UpgradeCosts.Enchant, 
				EnchantingFeature.Augment => Config.UpgradeCosts.Augment, 
				EnchantingFeature.Disenchant => Config.UpgradeCosts.Disenchant, 
				EnchantingFeature.Helheim => Config.UpgradeCosts.Helheim, 
				_ => throw new ArgumentOutOfRangeException("feature", feature, null), 
			};
			if (list2 == null)
			{
				return list;
			}
			if (level < 0 || level >= list2.Count)
			{
				Debug.LogWarning((object)$"[EpicLoot] Warning: tried to get enchanting feature upgrade cost for level that does not exist ({feature}, {level})");
				return list;
			}
			List<ItemAmount> list3 = list2[level];
			if (list3 == null)
			{
				return list;
			}
			foreach (ItemAmount item in list3)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item.Item);
				if ((Object)(object)itemPrefab == (Object)null)
				{
					Debug.LogWarning((object)$"[EpicLoot] Tried to add unknown item ({item.Item}) to upgrade cost for feature ({feature}, {level})");
					continue;
				}
				ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null)
				{
					Debug.LogWarning((object)$"[EpicLoot] Tried to add item without ItemDrop ({item.Item}) to upgrade cost for feature ({feature}, {level})");
					continue;
				}
				ItemData val = component.m_itemData.Clone();
				val.m_dropPrefab = itemPrefab;
				val.m_stack = item.Amount;
				list.Add(new InventoryItemListElement
				{
					Item = val
				});
			}
			return list;
		}
	}
	public class EnchantUI : EnchantingTableUIPanelBase
	{
		public delegate List<InventoryItemListElement> GetEnchantableItemsDelegate();

		public delegate string GetEnchantInfoDelegate(ItemData item, MagicRarityUnity rarity);

		public delegate List<InventoryItemListElement> GetEnchantCostDelegate(ItemData item, MagicRarityUnity rarity);

		public delegate GameObject EnchantItemDelegate(ItemData item, MagicRarityUnity rarity);

		public Text EnchantInfo;

		public Scrollbar EnchantInfoScrollbar;

		public List<Toggle> RarityButtons;

		[Header("Cost")]
		public Text CostLabel;

		public MultiSelectItemList CostList;

		public AudioClip[] EnchantCompleteSFX;

		public static GetEnchantableItemsDelegate GetEnchantableItems;

		public static GetEnchantInfoDelegate GetEnchantInfo;

		public static GetEnchantCostDelegate GetEnchantCost;

		public static EnchantItemDelegate EnchantItem;

		private ToggleGroup _toggleGroup;

		private MagicRarityUnity _rarity;

		private GameObject _successDialog;

		public override void Awake()
		{
			base.Awake();
			if (RarityButtons.Count > 0)
			{
				_toggleGroup = RarityButtons[0].group;
				_toggleGroup.EnsureValidState();
			}
			for (int i = 0; i < RarityButtons.Count; i++)
			{
				((UnityEvent<bool>)(object)RarityButtons[i].onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
				{
					if (isOn)
					{
						RefreshRarity();
					}
				});
			}
		}

		[UsedImplicitly]
		public void OnEnable()
		{
			_rarity = MagicRarityUnity.Magic;
			OnRarityChanged();
			RarityButtons[0].isOn = true;
			List<InventoryItemListElement> source = GetEnchantableItems();
			AvailableItems.SetItems(source.Cast<IListElement>().ToList());
		}

		public override void Update()
		{
			base.Update();
			if (!_locked && ZInput.IsGamepadActive())
			{
				if (ZInput.GetButtonDown("JoyButtonY"))
				{
					int index = (int)(_rarity + 1) % RarityButtons.Count;
					RarityButtons[index].isOn = true;
					ZInput.ResetButtonStatus("JoyButtonY");
				}
				if ((Object)(object)EnchantInfoScrollbar != (Object)null)
				{
					float joyRightStickY = ZInput.GetJoyRightStickY();
					if (Mathf.Abs(joyRightStickY) > 0.5f)
					{
						EnchantInfoScrollbar.value = Mathf.Clamp01(EnchantInfoScrollbar.value + joyRightStickY * -0.1f);
					}
				}
			}
			if ((Object)(object)_successDialog != (Object)null && !_successDialog.activeSelf)
			{
				Unlock();
				Object.Destroy((Object)(object)_successDialog);
				_successDialog = null;
			}
		}

		public void RefreshRarity()
		{
			MagicRarityUnity rarity = _rarity;
			for (int i = 0; i < RarityButtons.Count; i++)
			{
				if (RarityButtons[i].isOn)
				{
					_rarity = (MagicRarityUnity)i;
				}
			}
			if (rarity != _rarity)
			{
				OnRarityChanged();
			}
		}

		public void OnRarityChanged()
		{
			Tuple<InventoryItemListElement, int> singleSelectedItem = AvailableItems.GetSingleSelectedItem<InventoryItemListElement>();
			if (singleSelectedItem?.Item1.GetItem() == null)
			{
				((Selectable)MainButton).interactable = false;
				EnchantInfo.text = "";
				((Behaviour)CostLabel).enabled = false;
				CostList.SetItems(new List<IListElement>());
				return;
			}
			ItemData item = singleSelectedItem.Item1.GetItem();
			string text = GetEnchantInfo(item, _rarity);
			EnchantInfo.text = text;
			ScrollEnchantInfoToTop();
			((Behaviour)CostLabel).enabled = true;
			List<InventoryItemListElement> list = GetEnchantCost(item, _rarity);
			CostList.SetItems(list.Cast<IListElement>().ToList());
			bool flag = EnchantingTableUIPanelBase.LocalPlayerCanAffordCost(list);
			bool flag2 = EnchantingTableUI.instance.SourceTable.IsFeatureUnlocked(EnchantingFeature.Enchant);
			((Selectable)MainButton).interactable = flag2 && flag;
		}

		private void ScrollEnchantInfoToTop()
		{
			EnchantInfoScrollbar.value = 1f;
		}

		protected override void DoMainAction()
		{
			Tuple<InventoryItemListElement, int> tuple = AvailableItems.GetSelectedItems<InventoryItemListElement>().FirstOrDefault();
			Cancel();
			if (tuple?.Item1.GetItem() == null)
			{
				return;
			}
			ItemData item = tuple.Item1.GetItem();
			List<InventoryItemListElement> list = GetEnchantCost(item, _rarity);
			Player localPlayer = Player.m_localPlayer;
			if (!localPlayer.NoCostCheat())
			{
				if (!EnchantingTableUIPanelBase.LocalPlayerCanAffordCost(list))
				{
					Debug.LogError((object)"[Enchant Item] ERROR: Tried to enchant item but could not afford the cost. This should not happen!");
					return;
				}
				Inventory inventory = ((Humanoid)localPlayer).GetInventory();
				foreach (InventoryItemListElement item3 in list)
				{
					ItemData item2 = item3.GetItem();
					inventory.RemoveItem(item2.m_shared.m_name, item2.m_stack, -1, true);
				}
			}
			if ((Object)(object)_successDialog != (Object)null)
			{
				Object.Destroy((Object)(object)_successDialog);
			}
			DeselectAll();
			Lock();
			_successDialog = EnchantItem(item, _rarity);
			RefreshAvailableItems();
		}

		protected override AudioClip GetCompleteAudioClip()
		{
			return EnchantCompleteSFX[(int)_rarity];
		}

		public void RefreshAvailableItems()
		{
			List<InventoryItemListElement> source = GetEnchantableItems();
			AvailableItems.SetItems(source.Cast<IListElement>().ToList());
			AvailableItems.DeselectAll();
			OnSelectedItemsChanged();
		}

		protected override void OnSelectedItemsChanged()
		{
			OnRarityChanged();
		}

		public override bool CanCancel()
		{
			if (!base.CanCancel())
			{
				if ((Object)(object)_successDialog != (Object)null)
				{
					return _successDialog.activeSelf;
				}
				return false;
			}
			return true;
		}

		public override void Cancel()
		{
			base.Cancel();
			if ((Object)(object)_successDialog != (Object)null && _successDialog.activeSelf)
			{
				Object.Destroy((Object)(object)_successDialog);
				_successDialog = null;
			}
			OnRarityChanged();
		}

		public override void Lock()
		{
			base.Lock();
			foreach (Toggle rarityButton in RarityButtons)
			{
				((Selectable)rarityButton).interactable = false;
			}
		}

		public override void Unlock()
		{
			base.Unlock();
			foreach (Toggle rarityButton in RarityButtons)
			{
				((Selectable)rarityButton).interactable = true;
			}
		}

		public override void DeselectAll()
		{
			AvailableItems.DeselectAll();
		}
	}
	public class FeatureStatus3D : MonoBehaviour
	{
		public EnchantingTable SourceTable;

		public EnchantingFeature Feature;

		public GameObject UnlockedObject;

		public GameObject[] LevelObjects;

		public void OnEnable()
		{
			SourceTable.OnAnyFeatureLevelChanged += Refresh;
			Refresh();
		}

		public void OnDisable()
		{
			SourceTable.OnAnyFeatureLevelChanged -= Refresh;
		}

		public void Refresh()
		{
			bool flag = SourceTable.IsFeatureAvailable(Feature) && SourceTable.IsFeatureUnlocked(Feature);
			if ((Object)(object)UnlockedObject != (Object)null)
			{
				UnlockedObject.SetActive(flag);
			}
			int featureLevel = SourceTable.GetFeatureLevel(Feature);
			for (int i = 0; i < LevelObjects.Length; i++)
			{
				GameObject val = LevelObjects[i];
				if (!((Object)(object)val == (Object)null))
				{
					val.SetActive(flag && featureLevel == i);
				}
			}
			if (flag && featureLevel >= LevelObjects.Length && (Object)(object)LevelObjects[LevelObjects.Length - 1] != (Object)null)
			{
				LevelObjects[LevelObjects.Length - 1].SetActive(true);
			}
		}
	}
	public interface IListElement
	{
		ItemData GetItem();

		int GetMax();

		string GetDisplayNameSuffix();
	}
	public class InventoryItemListElement : IListElement
	{
		public ItemData Item;

		public ItemData GetItem()
		{
			return Item;
		}

		public int GetMax()
		{
			return Item?.m_stack ?? 0;
		}

		public string GetDisplayNameSuffix()
		{
			return string.Empty;
		}
	}
	public class MultiSelectItemList : MonoBehaviour
	{
		public enum SortMode
		{
			Rarity,
			Name,
			Quantity
		}

		public delegate List<IListElement> SortByRarityDelegate(List<IListElement> items);

		public delegate List<IListElement> SortByNameDelegate(List<IListElement> items);

		public bool Multiselect = true;

		public bool Filterable = true;

		public bool Sortable = true;

		public bool ReadOnly;

		public Transform ListContainer;

		public MultiSelectItemListElement ElementPrefab;

		public Dropdown SortByDropdown;

		public InputField FilterByText;

		public Toggle SelectAllToggle;

		public static SortByRarityDelegate SortByRarity;

		public static SortByNameDelegate SortByName;

		private bool _locked;

		private bool _hasGamepadFocus;

		private ScrollRectEnsureVisible _scrollRectEnsureVisible;

		public event Action OnSelectedItemsChanged;

		public event Action OnItemsChanged;

		public void Awake()
		{
			ScrollRect componentInChildren = ((Component)this).GetComponentInChildren<ScrollRect>();
			_scrollRectEnsureVisible = (((Object)(object)componentInChildren != (Object)null) ? ((Component)componentInChildren).GetComponent<ScrollRectEnsureVisible>() : null);
			if ((Object)(object)SelectAllToggle != (Object)null)
			{
				((UnityEvent<bool>)(object)SelectAllToggle.onValueChanged).AddListener((UnityAction<bool>)OnSelectAllToggled);
			}
			if ((Object)(object)SortByDropdown != (Object)null)
			{
				foreach (OptionData option in SortByDropdown.options)
				{
					option.text = Localization.instance.Localize(option.text);
				}
				((UnityEvent<int>)(object)SortByDropdown.onValueChanged).AddListener((UnityAction<int>)OnSortModeChanged);
			}
			if ((Object)(object)FilterByText != (Object)null)
			{
				((UnityEvent<string>)(object)FilterByText.onValueChanged).AddListener((UnityAction<string>)OnFilterChanged);
			}
			Refresh();
		}

		public void Update()
		{
			if (_locked || !HasGamepadFocus() || !ZInput.IsGamepadActive() || (Object)(object)ListContainer == (Object)null)
			{
				return;
			}
			int childCount = ListContainer.childCount;
			MultiSelectItemListElement focusedElement = GetFocusedElement();
			if ((Object)(object)focusedElement == (Object)null)
			{
				return;
			}
			int siblingIndex = ((Component)focusedElement).transform.GetSiblingIndex();
			GridLayoutGroup component = ((Component)ListContainer).GetComponent<GridLayoutGroup>();
			if ((Object)(object)((Component)ListContainer).GetComponent<VerticalLayoutGroup>() != (Object)null)
			{
				if (siblingIndex > 0 && ZInput.GetButtonDown("JoyLStickUp"))
				{
					focusedElement.GiveFocus(focused: false);
					MultiSelectItemListElement element = GetElement(siblingIndex - 1);
					element.GiveFocus(focused: true);
					CenterOnItem(element);
					ZInput.ResetButtonStatus("JoyLStickUp");
				}
				else if (siblingIndex < childCount - 1 && ZInput.GetButtonDown("JoyLStickDown"))
				{
					focusedElement.GiveFocus(focused: false);
					MultiSelectItemListElement element2 = GetElement(siblingIndex + 1);
					element2.GiveFocus(focused: true);
					CenterOnItem(element2);
					ZInput.ResetButtonStatus("JoyLStickDown");
				}
				else if (ZInput.GetButtonDown("JoyLStickLeft"))
				{
					ZInput.ResetButtonStatus("JoyLStickLeft");
				}
				else if (ZInput.GetButtonDown("JoyLStickRight"))
				{
					ZInput.ResetButtonStatus("JoyLStickRight");
				}
			}
			else if ((Object)(object)component != (Object)null)
			{
				int constraintCount = component.constraintCount;
				if (siblingIndex >= constraintCount && ZInput.GetButtonDown("JoyLStickUp"))
				{
					focusedElement.GiveFocus(focused: false);
					MultiSelectItemListElement element3 = GetElement(siblingIndex - constraintCount);
					element3.GiveFocus(focused: true);
					CenterOnItem(element3);
					ZInput.ResetButtonStatus("JoyLStickUp");
				}
				else if (siblingIndex < childCount - constraintCount && ZInput.GetButtonDown("JoyLStickDown"))
				{
					focusedElement.GiveFocus(focused: false);
					MultiSelectItemListElement element4 = GetElement(siblingIndex + constraintCount);
					element4.GiveFocus(focused: true);
					CenterOnItem(element4);
					ZInput.ResetButtonStatus("JoyLStickDown");
				}
				else if (siblingIndex % constraintCount > 0 && ZInput.GetButtonDown("JoyLStickLeft"))
				{
					focusedElement.GiveFocus(focused: false);
					MultiSelectItemListElement element5 = GetElement(siblingIndex - 1);
					element5.GiveFocus(focused: true);
					CenterOnItem(element5);
					ZInput.ResetButtonStatus("JoyLStickLeft");
				}
				else if (siblingIndex % constraintCount < constraintCount - 1 && siblingIndex < childCount - 1 && ZInput.GetButtonDown("JoyLStickRight"))
				{
					focusedElement.GiveFocus(focused: false);
					MultiSelectItemListElement element6 = GetElement(siblingIndex + 1);
					element6.GiveFocus(focused: true);
					CenterOnItem(element6);
					ZInput.ResetButtonStatus("JoyLStickRight");
				}
			}
			if (Multiselect && (Object)(object)SelectAllToggle != (Object)null && ZInput.GetButtonDown("JoyLStick"))
			{
				SelectAllToggle.isOn = !SelectAllToggle.isOn;
				ZInput.ResetButtonStatus("JoyLStick");
			}
			if (Sortable && (Object)(object)SortByDropdown != (Object)null && ZInput.GetButtonDown("JoyRStick"))
			{
				int value = SortByDropdown.value;
				int count = SortByDropdown.options.Count;
				value = (value + 1) % count;
				SortByDropdown.value = value;
				ZInput.ResetButtonStatus("JoyRStick");
			}
		}

		private void CenterOnItem(MultiSelectItemListElement element)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			if ((Object)(object)_scrollRectEnsureVisible != (Object)null)
			{
				_scrollRectEnsureVisible.CenterOnItem((RectTransform)((Component)element).transform);
			}
		}

		private void OnFilterChanged(string _)
		{
			Refresh();
		}

		public void Refresh()
		{
			RefreshFilter();
			RefreshSelectAllToggle();
		}

		private void RefreshFilter()
		{
			if ((Object)(object)FilterByText != (Object)null && !Filterable && ((Component)FilterByText).gameObject.activeSelf)
			{
				((Component)FilterByText).gameObject.SetActive(false);
			}
			if (!Filterable || (Object)(object)FilterByText == (Object)null)
			{
				return;
			}
			string text = FilterByText.text;
			bool flag = string.IsNullOrEmpty(text) || string.IsNullOrWhiteSpace(text);
			string[] array = (flag ? Array.Empty<string>() : text.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries));
			int childCount = ListContainer.childCount;
			for (int i = 0; i < childCount; i++)
			{
				MultiSelectItemListElement component = ((Component)ListContainer.GetChild(i)).GetComponent<MultiSelectItemListElement>();
				string text2 = component.ItemName.text;
				text2 = new Regex("<[^>]*>").Replace(text2, string.Empty);
				bool active = flag;
				string[] array2 = array;
				foreach (string value in array2)
				{
					if (text2.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						active = true;
						break;
					}
				}
				((Component)component).gameObject.SetActive(active);
			}
		}

		public void RefreshSelectAllToggle()
		{
			if (!((Object)(object)SelectAllToggle != (Object)null))
			{
				return;
			}
			if (!Multiselect && ((Component)SelectAllToggle).gameObject.activeSelf)
			{
				((Component)SelectAllToggle).gameObject.SetActive(false);
				return;
			}
			bool isOnWithoutNotify = true;
			int childCount = ListContainer.childCount;
			for (int i = 0; i < childCount; i++)
			{
				if (!((Component)ListContainer.GetChild(i)).GetComponent<MultiSelectItemListElement>().IsMaxSelected())
				{
					isOnWithoutNotify = false;
				}
			}
			SelectAllToggle.SetIsOnWithoutNotify(isOnWithoutNotify);
		}

		private void OnSelectAllToggled(bool _ = true)
		{
			if ((Object)(object)SelectAllToggle == (Object)null)
			{
				return;
			}
			if (SelectAllToggle.isOn)
			{
				ForeachElement(delegate(int _, MultiSelectItemListElement x)
				{
					x.SelectMaxQuantity(noSound: true);
				});
			}
			else
			{
				ForeachElement(delegate(int _, MultiSelectItemListElement x)
				{
					x.Deselect(noSound: true);
				});
			}
			RefreshSelectAllToggle();
		}

		private void OnSortModeChanged(int sortModeValue)
		{
			if (!Sortable || (Object)(object)SortByDropdown == (Object)null)
			{
				return;
			}
			Dictionary<IListElement, int> currentSelectionAmounts = GetCurrentSelectionAmounts();
			List<IListElement> items = currentSelectionAmounts.Keys.ToList();
			SortMode value = (SortMode)SortByDropdown.value;
			List<IListElement> list = SortItems(value, items);
			for (int i = 0; i < list.Count; i++)
			{
				Transform child = ListContainer.GetChild(i);
				IListElement listElement = list[i];
				MultiSelectItemListElement component = ((Component)child).GetComponent<MultiSelectItemListElement>();
				component.SuppressEvents = true;
				component.SetItem(listElement);
				if (currentSelectionAmounts.TryGetValue(listElement, out var value2))
				{
					component.SelectQuantity(value2, noSound: true);
				}
				component.SuppressEvents = false;
			}
			RefreshSelectAllToggle();
		}

		public Dictionary<IListElement, int> GetCurrentSelectionAmounts()
		{
			Dictionary<IListElement, int> dictionary = new Dictionary<IListElement, int>();
			int childCount = ListContainer.childCount;
			for (int i = 0; i < childCount; i++)
			{
				MultiSelectItemListElement component = ((Component)ListContainer.GetChild(i)).GetComponent<MultiSelectItemListElement>();
				if ((Object)(object)component != (Object)null && component.GetItem() != null)
				{
					dictionary.Add(component.GetListElement(), component.GetSelectedQuantity());
				}
			}
			return dictionary;
		}

		private void MakeEnoughElements(int itemCount)
		{
			int childCount = ListContainer.childCount;
			if (childCount > itemCount)
			{
				for (int num = childCount - 1; num >= itemCount; num--)
				{
					Transform child = ListContainer.GetChild(num);
					((Component)child).GetComponent<MultiSelectItemListElement>().OnSelectionChanged -= OnElementSelectionChanged;
					Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
				}
			}
			else if (childCount < itemCount)
			{
				for (int i = childCount; i < itemCount; i++)
				{
					MultiSelectItemListElement multiSelectItemListElement = Object.Instantiate<MultiSelectItemListElement>(ElementPrefab, ListContainer);
					multiSelectItemListElement.SuppressEvents = true;
					multiSelectItemListElement.OnSelectionChanged += OnElementSelectionChanged;
				}
			}
		}

		public void SetItems(List<IListElement> items)
		{
			int count = items.Count;
			Dictionary<IListElement, int> currentSelectionAmounts = GetCurrentSelectionAmounts();
			MultiSelectItemListElement focusedElement = GetFocusedElement();
			MakeEnoughElements(count);
			List<IListElement> list = items;
			if (Sortable && (Object)(object)SortByDropdown != (Object)null)
			{
				SortMode value = (SortMode)SortByDropdown.value;
				list = SortItems(value, items);
			}
			bool flag = false;
			for (int i = 0; i < count; i++)
			{
				Transform child = ListContainer.GetChild(i);
				IListElement listElement = list[i];
				MultiSelectItemListElement component = ((Component)child).GetComponent<MultiSelectItemListElement>();
				component.SuppressEvents = true;
				component.SetItem(listElement);
				if (currentSelectionAmounts.TryGetValue(listElement, out var value2))
				{
					component.SelectQuantity(value2, noSound: true);
				}
				component.SuppressEvents = false;
				bool flag2 = HasGamepadFocus() && (((Object)(object)focusedElement == (Object)null && i == 0) || (Object)(object)component == (Object)(object)focusedElement);
				component.GiveFocus(flag2);
				if (flag2)
				{
					flag = true;
					CenterOnItem(component);
				}
			}
			if (HasGamepadFocus() && !flag && ListContainer.childCount > 0)
			{
				_hasGamepadFocus = false;
				GiveFocus(focused: true, 0);
				CenterOnItem(GetElement(0));
			}
			this.OnItemsChanged?.Invoke();
			this.OnSelectedItemsChanged?.Invoke();
			RefreshSelectAllToggle();
		}

		private void OnElementSelectionChanged(MultiSelectItemListElement element, bool isSelected, int selectedQuantity)
		{
			if (!Multiselect)
			{
				ForeachElement(delegate(int _, MultiSelectItemListElement x)
				{
					if ((Object)(object)x != (Object)(object)element)
					{
						x.SuppressEvents = true;
						x.Deselect(noSound: true);
						x.SuppressEvents = false;
					}
				});
			}
			this.OnSelectedItemsChanged?.Invoke();
			RefreshSelectAllToggle();
		}

		public List<IListElement> SortItems(SortMode mode, List<IListElement> items)
		{
			switch (mode)
			{
			case SortMode.Rarity:
				if (SortByRarity != null)
				{
					return SortByRarity(items);
				}
				return items.ToList();
			case SortMode.Name:
				if (SortByName != null)
				{
					return SortByName(items);
				}
				return (from x in items
					orderby Localization.instance.Localize(x.GetItem().m_shared.m_name), x.GetItem().m_stack descending
					select x).ToList();
			case SortMode.Quantity:
				return (from x in items
					orderby x.GetItem().m_stack descending, Localization.instance.Localize(x.GetItem().m_shared.m_name)
					select x).ToList();
			default:
				throw new ArgumentOutOfRangeException("mode", mode, null);
			}
		}

		public List<Tuple<T, int>> GetSelectedItems<T>()
		{
			List<Tuple<T, int>> list = new List<Tuple<T, int>>();
			int childCount = ListContainer.childCount;
			for (int i = 0; i < childCount; i++)
			{
				MultiSelectItemListElement component = ((Component)ListContainer.GetChild(i)).GetComponent<MultiSelectItemListElement>();
				int selectedQuantity = component.GetSelectedQuantity();
				if (selectedQuantity > 0)
				{
					list.Add(new Tuple<T, int>((T)component.GetListElement(), selectedQuantity));
				}
			}
			return list;
		}

		public Tuple<T, int> GetSingleSelectedItem<T>()
		{
			int childCount = ListContainer.childCount;
			for (int i = 0; i < childCount; i++)
			{
				MultiSelectItemListElement component = ((Component)ListContainer.GetChild(i)).GetComponent<MultiSelectItemListElement>();
				int selectedQuantity = component.GetSelectedQuantity();
				if (selectedQuantity > 0)
				{
					return new Tuple<T, int>((T)component.GetListElement(), selectedQuantity);
				}
			}
			return null;
		}

		public int GetFirstSelectedIndex()
		{
			int childCount = ListContainer.childCount;
			for (int i = 0; i < childCount; i++)
			{
				if (((Component)ListContainer.GetChild(i)).GetComponent<MultiSelectItemListElement>().GetSelectedQuantity() > 0)
				{
					return i;
				}
			}
			return -1;
		}

		public void Lock()
		{
			_locked = true;
			if ((Object)(object)SortByDropdown != (Object)null)
			{
				((Selectable)SortByDropdown).interactable = false;
			}
			if ((Object)(object)FilterByText != (Object)null)
			{
				((Selectable)FilterByText).interactable = false;
			}
			if ((Object)(object)SelectAllToggle != (Object)null)
			{
				((Selectable)SelectAllToggle).interactable = false;
			}
			ForeachElement(delegate(int _, MultiSelectItemListElement e)
			{
				e.Lock();
			});
		}

		public void Unlock()
		{
			_locked = false;
			if ((Object)(object)SortByDropdown != (Object)null)
			{
				((Selectable)SortByDropdown).interactable = Sortable && !ReadOnly;
			}
			if ((Object)(object)FilterByText != (Object)null)
			{
				((Selectable)FilterByText).interactable = Filterable && !ReadOnly;
			}
			if ((Object)(object)SelectAllToggle != (Object)null)
			{
				((Selectable)SelectAllToggle).interactable = Multiselect && !ReadOnly;
			}
			ForeachElement(delegate(int _, MultiSelectItemListElement e)
			{
				e.Unlock();
			});
		}

		private MultiSelectItemListElement GetElement(int index)
		{
			Transform child = ListContainer.GetChild(index);
			if (!((Object)(object)child == (Object)null))
			{
				return ((Component)child).GetComponent<MultiSelectItemListElement>();
			}
			return null;
		}

		public void ForeachElement(Action<int, MultiSelectItemListElement> func)
		{
			if ((Object)(object)ListContainer == (Object)null)
			{
				return;
			}
			int childCount = ListContainer.childCount;
			for (int i = 0; i < childCount; i++)
			{
				MultiSelectItemListElement element = GetElement(i);
				if ((Object)(object)element != (Object)null)
				{
					func(i, element);
				}
			}
		}

		public void DeselectAll()
		{
			SuppressEvents(suppress: true);
			ForeachElement(delegate(int _, MultiSelectItemListElement e)
			{
				e.Deselect(noSound: true);
			});
			SuppressEvents(suppress: false);
			this.OnSelectedItemsChanged?.Invoke();
			RefreshSelectAllToggle();
		}

		public void SuppressEvents(bool suppress)
		{
			ForeachElement(delegate(int _, MultiSelectItemListElement e)
			{
				e.SuppressEvents = suppress;
			});
		}

		public void GiveFocus(bool focused, int tryFocusIndex)
		{
			if (_hasGamepadFocus == focused)
			{
				return;
			}
			_hasGamepadFocus = focused;
			int focusIndex = (focused ? Mathf.Clamp(tryFocusIndex, 0, ListContainer.childCount - 1) : (-1));
			ForeachElement(delegate(int i, MultiSelectItemListElement e)
			{
				bool flag = i == focusIndex;
				e.GiveFocus(flag);
				if (flag)
				{
					CenterOnItem(e);
				}
			});
		}

		public bool HasGamepadFocus()
		{
			return _hasGamepadFocus;
		}

		public MultiSelectItemListElement GetFocusedElement()
		{
			if ((Object)(object)ListContainer == (Object)null || !ZInput.IsGamepadActive())
			{
				return null;
			}
			int childCount = ListContainer.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = ListContainer.GetChild(i);
				if (!((Object)(object)child == (Object)null))
				{
					MultiSelectItemListElement component = ((Component)child).GetComponent<MultiSelectItemListElement>();
					if ((Object)(object)component != (Object)null && component.HasGamepadFocus())
					{
						return component;
					}
				}
			}
			return null;
		}

		public int GetItemCount()
		{
			if ((Object)(object)ListContainer == (Object)null)
			{
				return 0;
			}
			int childCount = ListContainer.childCount;
			int num = 0;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = ListContainer.GetChild(i);
				if ((Object)(object)child != (Object)null && ((Component)child).gameObject.activeSelf)
				{
					num++;
				}
			}
			return num;
		}

		public bool IsGrid()
		{
			if ((Object)(object)ListContainer != (Object)null)
			{
				return (Object)(object)((Component)ListContainer).GetComponent<GridLayoutGroup>() != (Object)null;
			}
			return false;
		}

		public void InitWithExistingItems()
		{
			for (int i = 0; i < ListContainer.childCount; i++)
			{
				((Component)ListContainer.GetChild(i)).GetComponent<MultiSelectItemListElement>().OnSelectionChanged += OnElementSelectionChanged;
			}
			DeselectAll();
			this.OnItemsChanged?.Invoke();
			this.OnSelectedItemsChanged?.Invoke();
			RefreshSelectAllToggle();
		}
	}
	public class MultiSelectItemListElement : MonoBehaviour
	{
		public delegate void SetMagicItemDelegate(MultiSelectItemListElement element, ItemData item, UITooltip tooltip);

		public const string TotalQuantityFormat = "/ {0}";

		public const string ReadOnlyQuantityFormat = "{0}";

		public Button MainButton;

		public Toggle SelectedToggle;

		public GameObject SelectedBackground;

		public Text ItemName;

		public Image MagicBG;

		public Image ItemIcon;

		public Text ItemTotalQuantity;

		public InputField ItemSelectedQuantity;

		public Button QuantityUpButton;

		public Button QuantityDownButton;

		public UITooltip Tooltip;

		public bool ReadOnly;

		public bool CheckPlayerInventory;

		public bool NoMax;

		public AudioSource Audio;

		public AudioClip OnClickSFX;

		public GameObject GamepadFocusIndicator;

		[NonSerialized]
		public bool SuppressEvents;

		public static SetMagicItemDelegate SetMagicItem;

		private IListElement _item;

		private int _selectedQuantity;

		private bool _locked;

		private bool _hasGamepadFocus;

		public event Action<MultiSelectItemListElement, bool, int> OnSelectionChanged;

		public void Awake()
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			if ((Object)(object)ItemIcon != (Object)null || (Object)(object)MagicBG != (Object)null)
			{
				Material material = ((Graphic)((Component)InventoryGui.instance.m_dragItemPrefab.transform.Find("icon")).GetComponent<Image>()).material;
				if ((Object)(object)material != (Object)null)
				{
					if ((Object)(object)ItemIcon != (Object)null)
					{
						((Graphic)ItemIcon).material = material;
					}
					if ((Object)(object)MagicBG != (Object)null)
					{
						((Graphic)MagicBG).material = material;
					}
				}
			}
			if ((Object)(object)Tooltip != (Object)null)
			{
				GameObject tooltipPrefab = StoreGui.instance.m_listElement.GetComponent<UITooltip>().m_tooltipPrefab;
				Tooltip.m_tooltipPrefab = tooltipPrefab;
			}
			if ((Object)(object)Audio != (Object)null)
			{
				GameObject val = GameObject.Find("sfx_gui_button");
				if ((Object)(object)val != (Object)null)
				{
					Audio.outputAudioMixerGroup = val.GetComponent<AudioSource>().outputAudioMixerGroup;
				}
			}
			if (!ReadOnly)
			{
				if ((Object)(object)MainButton != (Object)null)
				{
					((UnityEvent)MainButton.onClick).AddListener(new UnityAction(OnClicked));
				}
				if ((Object)(object)ItemSelectedQuantity != (Object)null)
				{
					((UnityEvent<string>)(object)ItemSelectedQuantity.onEndEdit).AddListener((UnityAction<string>)OnSelectedAmountChanged);
				}
				if ((Object)(object)SelectedToggle != (Object)null)
				{
					((UnityEvent<bool>)(object)SelectedToggle.onValueChanged).AddListener((UnityAction<bool>)OnSelectedToggleChanged);
				}
				if ((Object)(object)QuantityUpButton != (Object)null)
				{
					((UnityEvent)QuantityUpButton.onClick).AddListener(new UnityAction(OnQuantityUpButtonClicked));
				}
				if ((Object)(object)QuantityDownButton != (Object)null)
				{
					((UnityEvent)QuantityDownButton.onClick).AddListener(new UnityAction(OnQuantityDownButtonClicked));
				}
			}
			Refresh();
		}

		public void Update()
		{
			if (!_locked && ZInput.IsGamepadActive() && HasGamepadFocus() && !ReadOnly)
			{
				if (ZInput.GetButtonDown("JoyButtonA"))
				{
					OnClicked();
					ZInput.ResetButtonStatus("JoyButtonA");
				}
				else if (ZInput.GetButtonDown("JoyDPadUp"))
				{
					SelectQuantity(_selectedQuantity + 1, noSound: false);
					ZInput.ResetButtonStatus("JoyDPadUp");
				}
				else if (ZInput.GetButtonDown("JoyDPadDown"))
				{
					SelectQuantity(_selectedQuantity - 1, noSound: false);
					ZInput.ResetButtonStatus("JoyDPadDown");
				}
				else if (ZInput.GetButtonDown("JoyDPadLeft"))
				{
					ZInput.ResetButtonStatus("JoyDPadLeft");
				}
				else if (ZInput.GetButtonDown("JoyDPadRight"))
				{
					ZInput.ResetButtonStatus("JoyDPadRight");
				}
			}
			RefreshGamepadFocusIndicator();
		}

		private void OnClicked()
		{
			if (IsSelected())
			{
				Deselect(noSound: false);
			}
			else
			{
				SelectMaxQuantity(noSound: false);
			}
		}

		public void SelectMaxQuantity(bool noSound)
		{
			int quantity = ((NoMax || _item == null) ? 1 : (_item?.GetItem()?.m_stack).GetValueOrDefault());
			SelectQuantity(quantity, noSound);
		}

		public bool IsSelected()
		{
			return _selectedQuantity > 0;
		}

		public bool IsMaxSelected()
		{
			if (_item != null)
			{
				return _selectedQuantity >= _item.GetItem().m_stack;
			}
			return _selectedQuantity > 0;
		}

		private void OnSelectedAmountChanged(string typedInAmount)
		{
			if (!int.TryParse(typedInAmount, out var result))
			{
				Deselect(noSound: false);
			}
			else
			{
				SelectQuantity(result, noSound: false);
			}
		}

		private void OnSelectedToggleChanged(bool _)
		{
			if (SelectedToggle.isOn)
			{
				SelectMaxQuantity(noSound: true);
			}
			else
			{
				Deselect(noSound: true);
			}
		}

		private void OnQuantityUpButtonClicked()
		{
			SelectQuantity(_selectedQuantity + 1, noSound: false);
		}

		private void OnQuantityDownButtonClicked()
		{
			SelectQuantity(_selectedQuantity - 1, noSound: false);
		}

		public void SetItem(IListElement item)
		{
			bool num = _item == item;
			_item = item;
			if (_item?.GetItem() == null)
			{
				if ((Object)(object)MagicBG != (Object)null)
				{
					((Behaviour)MagicBG).enabled = false;
				}
				if ((Object)(object)ItemIcon != (Object)null)
				{
					ItemIcon.sprite = null;
				}
				if ((Object)(object)ItemName != (Object)null)
				{
					ItemName.text = "<no item>";
				}
				if ((Object)(object)Tooltip != (Object)null)
				{
					Tooltip.m_topic = string.Empty;
					Tooltip.m_text = string.Empty;
				}
			}
			else
			{
				if (SetMagicItem != null)
				{
					SetMagicItem(this, _item.GetItem(), Tooltip);
				}
				else
				{
					if ((Object)(object)MagicBG != (Object)null)
					{
						((Behaviour)MagicBG).enabled = false;
					}
					if ((Object)(object)ItemIcon != (Object)null)
					{
						ItemIcon.sprite = _item.GetItem().GetIcon();
					}
					if ((Object)(object)ItemName != (Object)null)
					{
						ItemName.text = Localization.instance.Localize(_item.GetItem().m_shared.m_name);
					}
					if ((Object)(object)Tooltip != (Object)null)
					{
						Tooltip.m_topic = Localization.instance.Localize(_item.GetItem().m_shared.m_name);
						Tooltip.m_text = Localization.instance.Localize(_item.GetItem().GetTooltip());
					}
				}
				if ((Object)(object)ItemName != (Object)null)
				{
					Text itemName = ItemName;
					itemName.text += _item.GetDisplayNameSuffix();
				}
			}
			if (!num)
			{
				Deselect(noSound: true);
			}
			RefreshGamepadFocusIndicator();
		}

		public void Deselect(bool noSound)
		{
			SelectQuantity(0, noSound);
		}

		public void SelectQuantity(int quantity, bool noSound)
		{
			int selectedQuantity = _selectedQuantity;
			if (_item == null)
			{
				_selectedQuantity = quantity;
			}
			else if (NoMax)
			{
				_selectedQuantity = Mathf.Clamp(quantity, 0, 999);
			}
			else if (_item.GetItem().m_shared.m_maxStackSize == 1)
			{
				_selectedQuantity = Mathf.Clamp(quantity, 0, 1);
			}
			else
			{
				_selectedQuantity = Mathf.Clamp(quantity, 0, _item.GetItem().m_stack);
			}
			if (!SuppressEvents && selectedQuantity != _selectedQuantity)
			{
				this.OnSelectionChanged?.Invoke(this, IsSelected(), _selectedQuantity);
			}
			if ((Object)(object)Audio != (Object)null && !ReadOnly && !noSound && selectedQuantity != _selectedQuantity)
			{
				Audio.PlayOneShot(OnClickSFX);
			}
			Refresh();
		}

		public void Refresh()
		{
			RefreshGamepadFocusIndicator();
			bool flag = _item != null && _item.GetItem().m_shared.m_maxStackSize > 1;
			if ((Object)(object)MainButton != (Object)null)
			{
				((Selectable)MainButton).interactable = !_locked;
			}
			if ((Object)(object)SelectedToggle != (Object)null)
			{
				((Selectable)SelectedToggle).interactable = !_locked;
				((Component)SelectedToggle).gameObject.SetActive(!ReadOnly);
				SelectedToggle.SetIsOnWithoutNotify(_selectedQuantity > 0);
			}
			if ((Object)(object)ItemSelectedQuantity != (Object)null)
			{
				((Selectable)ItemSelectedQuantity).interactable = !_locked;
				((Component)ItemSelectedQuantity).gameObject.SetActive(!ReadOnly && flag);
				ItemSelectedQuantity.text = _selectedQuantity.ToString();
			}
			if ((Object)(object)ItemTotalQuantity != (Object)null && _item != null)
			{
				((Component)ItemTotalQuantity).gameObject.SetActive(ReadOnly || flag);
				string text = string.Format(ReadOnly ? "{0}" : "/ {0}", _item.GetMax());
				if (CheckPlayerInventory && ((Humanoid)Player.m_localPlayer).GetInventory().CountItems(_item.GetItem().m_shared.m_name, -1, true) < _item.GetItem().m_stack)
				{
					text = "<color=red>" + text + "</color>";
				}
				ItemTotalQuantity.text = text;
			}
			if ((Object)(object)QuantityUpButton != (Object)null)
			{
				((Selectable)QuantityUpButton).interactable = !_locked;
				((Component)QuantityUpButton).gameObject.SetActive(!ReadOnly && flag);
			}
			if ((Object)(object)QuantityDownButton != (Object)null)
			{
				((Selectable)QuantityDownButton).interactable = !_locked;
				((Component)QuantityDownButton).gameObject.SetActive(!ReadOnly && flag);
			}
			if ((Object)(object)SelectedBackground != (Object)null)
			{
				SelectedBackground.SetActive(!ReadOnly && _selectedQuantity > 0);
			}
			Localization.instance.Localize(((Component)this).transform);
		}

		public ItemData GetItem()
		{
			return _item.GetItem();
		}

		public IListElement GetListElement()
		{
			return _item;
		}

		public int GetSelectedQuantity()
		{
			return _selectedQuantity;
		}

		public void Lock()
		{
			_locked = true;
			Refresh();
		}

		public void Unlock()
		{
			_locked = false;
			Refresh();
		}

		public void GiveFocus(bool focused)
		{
			_hasGamepadFocus = focused;
			RefreshGamepadFocusIndicator();
		}

		private void RefreshGamepadFocusIndicator()
		{
			if (!((Object)(object)GamepadFocusIndicator == (Object)null))
			{
				GamepadFocusIndicator.SetActive(ZInput.IsGamepadActive() && _hasGamepadFocus);
			}
		}

		public bool HasGamepadFocus()
		{
			return _hasGamepadFocus;
		}
	}
	public class MultiSelectListFocusController : MonoBehaviour
	{
		public List<MultiSelectItemList> Lists = new List<MultiSelectItemList>();

		public GameObject[] SortHints;

		public GameObject[] SelectAllHints;

		public GameObject[] SelectHints;

		private int _focusedListIndex;

		private bool _gamepadWasEnabled;

		public void OnEnable()
		{
			_focusedListIndex = 0;
			for (int i = 0; i < Lists.Count; i++)
			{
				Lists[i].GiveFocus(i == _focusedListIndex, 0);
			}
			RefreshHints();
		}

		public void Update()
		{
			if (Lists.Count == 0)
			{
				return;
			}
			MultiSelectItemList multiSelectItemList = Lists[_focusedListIndex];
			int num = 0;
			int itemCount = multiSelectItemList.GetItemCount();
			while (itemCount == 0)
			{
				multiSelectItemList.GiveFocus(focused: false, 0);
				_focusedListIndex = (_focusedListIndex + 1) % Lists.Count;
				multiSelectItemList = Lists[_focusedListIndex];
				itemCount = multiSelectItemList.GetItemCount();
				if (multiSelectItemList.GetItemCount() > 0)
				{
					multiSelectItemList.GiveFocus(focused: true, 0);
					RefreshHints();
					break;
				}
				num++;
				if (num >= Lists.Count)
				{
					return;
				}
			}
			if (ZInput.IsGamepadActive())
			{
				int num2 = _focusedListIndex;
				if (ZInput.GetButtonDown("JoyTabLeft"))
				{
					num2 = Mathf.Max(_focusedListIndex - 1, 0);
					ZInput.ResetButtonStatus("JoyTabLeft");
				}
				else if (ZInput.GetButtonDown("JoyTabRight"))
				{
					num2 = Mathf.Min(_focusedListIndex + 1, Lists.Count - 1);
					ZInput.ResetButtonStatus("JoyTabRight");
				}
				if (num2 != _focusedListIndex)
				{
					int num3 = num2 - _focusedListIndex;
					if (Lists[num2].GetItemCount() == 0)
					{
						num2 = (num2 + num3 + Lists.Count) % Lists.Count;
					}
					if (Lists[num2].GetItemCount() == 0)
					{
						num2 = _focusedListIndex;
					}
				}
				FocusList(num2);
			}
			if (_gamepadWasEnabled != ZInput.IsGamepadActive())
			{
				RefreshHints();
			}
			_gamepadWasEnabled = ZInput.IsGamepadActive();
		}

		public void FocusList(int newFocusedIndex)
		{
			MultiSelectItemListElement focusedElement = Lists[_focusedListIndex].GetFocusedElement();
			int num = (((Object)(object)focusedElement != (Object)null) ? ((Component)focusedElement).transform.GetSiblingIndex() : (-1));
			if (newFocusedIndex != _focusedListIndex && newFocusedIndex >= 0 && newFocusedIndex < Lists.Count)
			{
				_focusedListIndex = newFocusedIndex;
				for (int i = 0; i < Lists.Count; i++)
				{
					bool flag = Lists[i].IsGrid();
					Lists[i].GiveFocus(i == _focusedListIndex, (!flag) ? num : 0);
				}
				RefreshHints();
			}
		}

		private void RefreshHints()
		{
			if (((Behaviour)this).isActiveAndEnabled && ZInput.IsGamepadActive() && Lists.Count != 0)
			{
				MultiSelectItemList multiSelectItemList = Lists[_focusedListIndex];
				GameObject[] sortHints = SortHints;
				for (int i = 0; i < sortHints.Length; i++)
				{
					sortHints[i].SetActive(multiSelectItemList.Sortable && (Object)(object)multiSelectItemList.SortByDropdown != (Object)null && ((Behaviour)multiSelectItemList.SortByDropdown).isActiveAndEnabled);
				}
				sortHints = SelectAllHints;
				for (int i = 0; i < sortHints.Length; i++)
				{
					sortHints[i].SetActive(multiSelectItemList.Multiselect && (Object)(object)multiSelectItemList.SelectAllToggle != (Object)null && ((Behaviour)multiSelectItemList.SelectAllToggle).isActiveAndEnabled);
				}
				sortHints = SelectHints;
				for (int i = 0; i < sortHints.Length; i++)
				{
					sortHints[i].SetActive(!multiSelectItemList.ReadOnly && (Object)(object)multiSelectItemList.GetFocusedElement() != (Object)null);
				}
			}
		}
	}
	[RequireComponent(typeof(Toggle))]
	public class PlaySoundOnChecked : MonoBehaviour
	{
		public AudioSource Audio;

		public AudioClip SFX;

		private Toggle _toggle;

		public void Awake()
		{
			_toggle = ((Component)this).GetComponent<Toggle>();
			((UnityEvent<bool>)(object)_toggle.onValueChanged).AddListener((UnityAction<bool>)OnToggleChanged);
		}

		public void OnDestroy()
		{
			((UnityEvent<bool>)(object)_toggle.onValueChanged).RemoveListener((UnityAction<bool>)OnToggleChanged);
		}

		private void OnToggleChanged(bool _)
		{
			if ((Object)(object)Audio != (Object)null && (Object)(object)SFX != (Object)null && _toggle.isOn)
			{
				Audio.PlayOneShot(SFX);
			}
		}
	}
	public enum MaterialConversionMode
	{
		Upgrade,
		Convert,
		Junk
	}
	public class ConversionRecipeCostUnity
	{
		public ItemData Item;

		public int Amount;
	}
	public class ConversionRecipeUnity : IListElement
	{
		public ItemData Product;

		public int Amount;

		public List<ConversionRecipeCostUnity> Cost;

		public ItemData GetItem()
		{
			return Product;
		}

		public string GetDisplayNameSuffix()
		{
			if (Amount <= 1)
			{
				return string.Empty;
			}
			return $" x{Amount}";
		}

		public int GetMax()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return 0;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			int num = int.MaxValue;
			foreach (ConversionRecipeCostUnity item in Cost)
			{
				int num2 = Mathf.FloorToInt((float)inventory.CountItems(item.Item.m_shared.m_name, -1, true) / (float)item.Amount);
				num = Mathf.Min(num, num2);
			}
			return num;
		}
	}
	public class ConvertUI : EnchantingTableUIPanelBase
	{
		public delegate List<ConversionRecipeUnity> GetConversionRecipesDelegate(int mode);

		public MultiSelectItemList Products;

		public List<Toggle> ModeButtons;

		[Header("Cost")]
		public Text CostLabel;

		public MultiSelectItemList CostList;

		public static GetConversionRecipesDelegate GetConversionRecipes;

		private Text _progressLabel;

		private ToggleGroup _toggleGroup;

		private MaterialConversionMode _mode;

		public override void Awake()
		{
			base.Awake();
			_progressLabel = ((Component)ProgressBar).gameObject.GetComponentInChildren<Text>();
			if (ModeButtons.Count > 0)
			{
				_toggleGroup = ModeButtons[0].group;
				_toggleGroup.EnsureValidState();
			}
			for (int i = 0; i < ModeButtons.Count; i++)
			{
				((UnityEvent<bool>)(object)ModeButtons[i].onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
				{
					if (isOn)
					{
						RefreshMode();
					}
				});
			}
		}

		[UsedImplicitly]
		public void OnEnable()
		{
			_mode = MaterialConversionMode.Upgrade;
			RefreshMode();
			List<ConversionRecipeUnity> source = GetConversionRecipes((int)_mode);
			AvailableItems.SetItems(source.Cast<IListElement>().ToList());
		}

		public override void Update()
		{
			base.Update();
			if (!_locked && ZInput.IsGamepadActive() && ZInput.GetButtonDown("JoyButtonY"))
			{
				int index = (int)(_mode + 1) % ModeButtons.Count;
				ModeButtons[index].isOn = true;
				ZInput.ResetButtonStatus("JoyButtonY");
			}
		}

		public void RefreshMode()
		{
			MaterialConversionMode mode = _mode;
			for (int i = 0; i < ModeButtons.Count; i++)
			{
				if (ModeButtons[i].isOn)
				{
					_mode = (MaterialConversionMode)i;
				}
			}
			if (mode != _mode)
			{
				OnModeChanged();
			}
		}

		public void OnModeChanged()
		{
			DeselectAll();
			RefreshAvailableItems();
			switch (_mode)
			{
			case MaterialConversionMode.Upgrade:
				CostLabel.text = Localization.instance.Localize("$mod_epicloot_upgradecost");
				_progressLabel.text = Localization.instance.Localize("$mod_epicloot_upgradeprogress");
				if (_useTMP)
				{
					_tmpButtonLabel.text = Localization.instance.Localize("$mod_epicloot_upgrade");
				}
				else
				{
					_buttonLabel.text = Localization.instance.Localize("$mod_epicloot_upgrade");
				}
				break;
			case MaterialConversionMode.Convert:
				CostLabel.text = Localization.instance.Localize("$mod_epicloot_convertcost");
				_progressLabel.text = Localization.instance.Localize("$mod_epicloot_convertprogress");
				if (_useTMP)
				{
					_tmpButtonLabel.text = Localization.instance.Localize("$mod_epicloot_convert");
				}
				else
				{
					_buttonLabel.text = Localization.instance.Localize("$mod_epicloot_convert");
				}
				break;
			case MaterialConversionMode.Junk:
				CostLabel.text = Localization.instance.Localize("$mod_epicloot_junkcost");
				_progressLabel.text = Localization.instance.Localize("$mod_epicloot_junkprogress");
				if (_useTMP)
				{
					_tmpButtonLabel.text = Localization.instance.Localize("$mod_epicloot_junk");
				}
				else
				{
					_buttonLabel.text = Localization.instance.Localize("$mod_epicloot_junk");
				}
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
		}

		protected override void DoMainAction()
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			List<Tuple<ConversionRecipeUnity, int>> selectedItems = AvailableItems.GetSelectedItems<ConversionRecipeUnity>();
			List<InventoryItemListElement> conversionProducts = GetConversionProducts(selectedItems);
			List<InventoryItemListElement> conversionCost = GetConversionCost(selectedItems);
			Cancel();
			Player localPlayer = Player.m_localPlayer;
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			foreach (InventoryItemListElement item3 in conversionCost)
			{
				ItemData item = item3.GetItem();
				inventory.RemoveItem(item.m_shared.m_name, item.m_stack, -1, true);
			}
			foreach (InventoryItemListElement item4 in conversionProducts)
			{
				ItemData item2 = item4.GetItem();
				if (inventory.CanAddItem(item2, -1))
				{
					inventory.AddItem(item2);
					((Character)localPlayer).Message((MessageType)1, "$msg_added " + item2.m_shared.m_name, item2.m_stack, item2.GetIcon());
				}
				else
				{
					ItemDrop val = ItemDrop.DropItem(item2, item2.m_stack, ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward + ((Component)localPlayer).transform.up, ((Component)localPlayer).transform.rotation);
					((Component)val).GetComponent<Rigidbody>().velocity = Vector3.up * 5f;
					((Character)localPlayer).Message((MessageType)1, "$msg_dropped " + val.m_itemData.m_shared.m_name + " $mod_epicloot_sacrifice_inventoryfullexplanation", val.m_itemData.m_stack, val.m_itemData.GetIcon());
				}
			}
			DeselectAll();
			RefreshAvailableItems();
		}

		public static List<InventoryItemListElement> GetConversionProducts(List<Tuple<ConversionRecipeUnity, int>> selectedRecipes)
		{
			Dictionary<string, ItemData> dictionary = new Dictionary<string, ItemData>();
			foreach (Tuple<ConversionRecipeUnity, int> selectedRecipe in selectedRecipes)
			{
				ConversionRecipeUnity item = selectedRecipe.Item1;
				int item2 = selectedRecipe.Item2;
				if (dictionary.TryGetValue(item.Product.m_shared.m_name, out var value))
				{
					ItemData obj = value;
					obj.m_stack += item.Amount * item2;
				}
				else
				{
					value = item.Product.Clone();
					value.m_stack = item.Amount * item2;
					dictionary.Add(value.m_shared.m_name, value);
				}
			}
			return (from x in dictionary.Values
				orderby Localization.instance.Localize(x.m_shared.m_name)
				select new InventoryItemListElement
				{
					Item = x
				}).ToList();
		}

		public static List<InventoryItemListElement> GetConversionCost(List<Tuple<ConversionRecipeUnity, int>> selectedRecipes)
		{
			Dictionary<string, ItemData> dictionary = new Dictionary<string, ItemData>();
			foreach (Tuple<ConversionRecipeUnity, int> selectedRecipe in selectedRecipes)
			{
				ConversionRecipeUnity item = selectedRecipe.Item1;
				int item2 = selectedRecipe.Item2;
				foreach (ConversionRecipeCostUnity item3 in item.Cost)
				{
					if (dictionary.TryGetValue(item3.Item.m_shared.m_name, out var value))
					{
						ItemData obj = value;
						obj.m_stack += item3.Amount * item2;
					}
					else
					{
						value = item3.Item.Clone();
						value.m_stack = item3.Amount * item2;
						dictionary.Add(value.m_shared.m_name, value);
					}
				}
			}
			return (from x in dictionary.Values
				orderby Localization.instance.Localize(x.m_shared.m_name)
				select new InventoryItemListElement
				{
					Item = x
				}).ToList();
		}

		public void RefreshAvailableItems()
		{
			List<ConversionRecipeUnity> source = GetConversionRecipes((int)_mode);
			AvailableItems.SetItems(source.Cast<IListElement>().ToList());
			AvailableItems.DeselectAll();
			OnSelectedItemsChanged();
		}

		protected override void OnSelectedItemsChanged()
		{
			List<Tuple<ConversionRecipeUnity, int>> selectedItems = AvailableItems.GetSelectedItems<ConversionRecipeUnity>();
			List<InventoryItemListElement> conversionProducts = GetConversionProducts(selectedItems);
			Products.SetItems(conversionProducts.Cast<IListElement>().ToList());
			List<InventoryItemListElement> conversionCost = GetConversionCost(selectedItems);
			CostList.SetItems(conversionCost.Cast<IListElement>().ToList());
			Tuple<float, float> featureValue = EnchantingTableUI.instance.SourceTable.GetFeatureValue(EnchantingFeature.ConvertMaterials, 0);
			Tuple<float, float> featureCurrentValue = EnchantingTableUI.instance.SourceTable.GetFeatureCurrentValue(EnchantingFeature.ConvertMaterials);
			bool flag = false;
			if (_mode == MaterialConversionMode.Upgrade)
			{
				if (featureCurrentValue.Item1 < featureValue.Item1 && conversionProducts.Any((InventoryItemListElement x) => x.Item.m_shared.m_ammoType.EndsWith("MagicCraftingMaterial")))
				{
					flag = true;
				}
				if (featureCurrentValue.Item2 < featureValue.Item2 && conversionProducts.Any((InventoryItemListElement x) => x.Item.m_shared.m_ammoType.EndsWith("Runestone")))
				{
					flag = true;
				}
				if (flag && conversionCost.Count > 0)
				{
					CostLabel.text = Localization.instance.Localize("<color=#EAA800>($mod_epicloot_bonus)</color> $mod_epicloot_upgradecost");
				}
				else
				{
					CostLabel.text = Localization.instance.Localize("$mod_epicloot_upgradecost");
				}
			}
			bool flag2 = EnchantingTableUIPanelBase.LocalPlayerCanAffordCost(conversionCost);
			bool flag3 = EnchantingTableUI.instance.SourceTable.IsFeatureUnlocked(EnchantingFeat