using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using AzuExtendedPlayerInventory;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using ExtraSlotsAPI;
using GUIFramework;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using MyLittleUI;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("My Little UI")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("My Little UI")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("345181bf-e9ed-4c88-a4f4-38450f53cc41")]
[assembly: AssemblyFileVersion("1.2.12")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.12.0")]
[module: UnverifiableCode]
[HarmonyPatch]
public static class Advize_StumpsRegrow_Compat
{
	internal const string GUID = "advize.StumpsRegrow";

	private static ConfigEntry<float> stumpGrowthTime;

	private static bool initialized;

	private static bool hasGrowthTime;

	public static MethodBase target;

	private static double GetTimeSincePlanted(ZNetView nview)
	{
		return (ZNet.instance.GetTime() - new DateTime(nview.GetZDO().GetLong(ZDOVars.s_plantTime, 0L))).TotalSeconds;
	}

	private static float GetGrowTime()
	{
		return (stumpGrowthTime != null) ? Mathf.Max(stumpGrowthTime.Value, 1f) : 1f;
	}

	private static void Postfix(object __instance, ref string __result)
	{
		if (!global::MyLittleUI.MyLittleUI.modEnabled.Value || __instance == null || !global::MyLittleUI.MyLittleUI.hoverStumpGrowerEnabled.Value || global::MyLittleUI.MyLittleUI.hoverStumpGrower.Value == global::MyLittleUI.MyLittleUI.StationHover.Vanilla || string.IsNullOrWhiteSpace(__result))
		{
			return;
		}
		if (!initialized)
		{
			initialized = true;
			hasGrowthTime = Chainloader.PluginInfos.TryGetValue("advize.StumpsRegrow", out var value) && value.Instance.Config.TryGetEntry<float>("General", "StumpGrowthTime", ref stumpGrowthTime);
		}
		if (!hasGrowthTime)
		{
			return;
		}
		object obj = ((__instance is MonoBehaviour) ? __instance : null);
		ZNetView val = ((obj != null) ? ((Component)obj).GetComponent<ZNetView>() : null);
		if (!((Object)(object)val == (Object)null) && val.IsValid())
		{
			if (global::MyLittleUI.MyLittleUI.hoverStumpGrower.Value == global::MyLittleUI.MyLittleUI.StationHover.Percentage)
			{
				__result += $"\n{GetTimeSincePlanted(val) / (double)GetGrowTime():P0}";
			}
			else if (global::MyLittleUI.MyLittleUI.hoverStumpGrower.Value == global::MyLittleUI.MyLittleUI.StationHover.Bar)
			{
				__result = __result + "\n" + global::MyLittleUI.MyLittleUI.FromPercent(GetTimeSincePlanted(val) / (double)GetGrowTime());
			}
			else if (global::MyLittleUI.MyLittleUI.hoverStumpGrower.Value == global::MyLittleUI.MyLittleUI.StationHover.MinutesSeconds)
			{
				__result = __result + "\n" + global::MyLittleUI.MyLittleUI.FromSeconds((double)GetGrowTime() - GetTimeSincePlanted(val));
			}
		}
	}

	public static bool Prepare(MethodBase original)
	{
		if (!Chainloader.PluginInfos.TryGetValue("advize.StumpsRegrow", out var value))
		{
			return false;
		}
		if ((object)target == null)
		{
			target = AccessTools.Method(((object)value.Instance).GetType().Assembly.GetType("Advize_StumpsRegrow.StumpGrower"), "GetHoverText", (Type[])null, (Type[])null);
		}
		if (target == null)
		{
			return false;
		}
		if (original == null)
		{
			global::MyLittleUI.MyLittleUI.LogInfo("Advize_StumpsRegrow.StumpGrower:GetHoverText method is patched to show configurable hover");
		}
		return true;
	}

	public static MethodBase TargetMethod()
	{
		return target;
	}
}
namespace MyLittleUI
{
	internal class AmmoCountIcon
	{
		public class ElementExtraData
		{
			public TMP_Text m_ammo;

			public Image m_icon;

			public Image m_bait;

			public Image m_mead;

			public ItemData m_item;

			public void UpdateState(ElementData elementData)
			{
				if (m_item == null)
				{
					TMP_Text ammo = m_ammo;
					if (ammo != null)
					{
						((Component)ammo).gameObject.SetActive(false);
					}
					Image icon = m_icon;
					if (icon != null)
					{
						((Component)icon).gameObject.SetActive(false);
					}
					Image bait = m_bait;
					if (bait != null)
					{
						((Component)bait).gameObject.SetActive(false);
					}
					Image mead = m_mead;
					if (mead != null)
					{
						((Component)mead).gameObject.SetActive(false);
					}
					return;
				}
				ItemData currentAmmo = GetCurrentAmmo();
				int num = ((currentAmmo != null) ? ((Humanoid)Player.m_localPlayer).GetInventory().CountItems(currentAmmo.m_shared.m_name, -1, true) : 0);
				TMP_Text ammo2 = m_ammo;
				if (ammo2 != null)
				{
					((Component)ammo2).gameObject.SetActive(MyLittleUI.ammoCountEnabled.Value && num > 0);
				}
				if (num > 0)
				{
					TMP_Text ammo3 = m_ammo;
					if (ammo3 != null)
					{
						ammo3.SetText(num.ToString());
					}
				}
				Sprite val = ((currentAmmo != null) ? currentAmmo.GetIcon() : null);
				Image icon2 = m_icon;
				if (icon2 != null)
				{
					((Component)icon2).gameObject.SetActive(MyLittleUI.ammoIconEnabled.Value && (Object)(object)val != (Object)null);
				}
				if ((Object)(object)val != (Object)null && (Object)(object)m_icon != (Object)null)
				{
					m_icon.overrideSprite = val;
				}
				ItemData currentBait = GetCurrentBait();
				Sprite val2 = ((currentBait != null) ? currentBait.GetIcon() : null);
				Image bait2 = m_bait;
				if (bait2 != null)
				{
					((Component)bait2).gameObject.SetActive(MyLittleUI.baitIconEnabled.Value && (Object)(object)val2 != (Object)null);
				}
				if ((Object)(object)val2 != (Object)null && (Object)(object)m_bait != (Object)null)
				{
					m_bait.overrideSprite = val2;
				}
				int num2 = ((currentBait != null) ? ((Humanoid)Player.m_localPlayer).GetInventory().CountItems(currentBait.m_shared.m_name, -1, true) : 0);
				if (num2 > 0 && MyLittleUI.baitCountEnabled.Value && !((Component)elementData.m_amount).gameObject.activeSelf)
				{
					((Component)elementData.m_amount).gameObject.SetActive(true);
					elementData.m_amount.SetText(num2.ToString());
				}
				ItemData currentMead = GetCurrentMead();
				Sprite val3 = ((currentMead != null) ? currentMead.GetIcon() : null);
				Image mead2 = m_mead;
				if (mead2 != null)
				{
					((Component)mead2).gameObject.SetActive(MyLittleUI.meadIconEnabled.Value && (Object)(object)val3 != (Object)null);
				}
				if ((Object)(object)val3 != (Object)null && (Object)(object)m_mead != (Object)null)
				{
					m_mead.overrideSprite = val3;
				}
			}

			private ItemData GetCurrentAmmo()
			{
				if (m_item == null || Utility.IsNullOrWhiteSpace(m_item.m_shared.m_ammoType) || IsBaitAmmo() || IsAmmo() || IsMeadAmmo())
				{
					return null;
				}
				ItemData ammoItem = ((Humanoid)Player.m_localPlayer).GetAmmoItem();
				if (ammoItem == null || ammoItem.m_shared.m_ammoType != m_item.m_shared.m_ammoType || !((Humanoid)Player.m_localPlayer).GetInventory().ContainsItem(ammoItem))
				{
					ammoItem = ((Humanoid)Player.m_localPlayer).GetInventory().GetAmmoItem(m_item.m_shared.m_ammoType, (string)null);
				}
				return ammoItem;
			}

			private ItemData GetCurrentBait()
			{
				if (m_item == null || Utility.IsNullOrWhiteSpace(m_item.m_shared.m_ammoType) || !IsBaitAmmo() || IsAmmo())
				{
					return null;
				}
				ItemData ammoItem = ((Humanoid)Player.m_localPlayer).GetAmmoItem();
				if (ammoItem == null || ammoItem.m_shared.m_ammoType != m_item.m_shared.m_ammoType || !((Humanoid)Player.m_localPlayer).GetInventory().ContainsItem(ammoItem))
				{
					ammoItem = ((Humanoid)Player.m_localPlayer).GetInventory().GetAmmoItem(m_item.m_shared.m_ammoType, (string)null);
				}
				return ammoItem;
			}

			private ItemData GetCurrentMead()
			{
				if (m_item == null || Utility.IsNullOrWhiteSpace(m_item.m_shared.m_ammoType) || IsBaitAmmo() || IsAmmo() || !IsMeadAmmo())
				{
					return null;
				}
				return ((Humanoid)Player.m_localPlayer).GetInventory().GetAmmoItem(m_item.m_shared.m_ammoType, (string)null);
			}

			private bool IsAmmo()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Invalid comparison between Unknown and I4
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Invalid comparison between Unknown and I4
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Invalid comparison between Unknown and I4
				return (int)m_item.m_shared.m_itemType == 9 || (int)m_item.m_shared.m_itemType == 23 || (int)m_item.m_shared.m_itemType == 2;
			}

			private bool IsBaitAmmo()
			{
				return m_item.m_shared.m_ammoType == "$item_fishingbait";
			}

			private bool IsMeadAmmo()
			{
				return m_item.m_shared.m_ammoType == "mead";
			}
		}

		[HarmonyPatch(typeof(HotkeyBar), "OnEnable")]
		public static class HotkeyBar_OnEnable_AddCustomElementsToHotkeyPrefab
		{
			private static void FillFields(RectTransform rtSource, RectTransform rtDestination)
			{
				//IL_0003: 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)
				rtDestination.anchoredPosition = rtSource.anchoredPosition;
				rtDestination.sizeDelta = rtSource.sizeDelta;
			}

			public static void Postfix(HotkeyBar __instance)
			{
				if (!((Object)(object)__instance.m_elementPrefab == (Object)null))
				{
					isDirty[__instance] = false;
					elementPrefab = __instance.m_elementPrefab;
					int num = __instance.m_elementPrefab.transform.Find("icon").GetSiblingIndex() + 1;
					Transform obj = __instance.m_elementPrefab.transform.Find("MLUI_AmmoAmount");
					ammoCount = ((obj != null) ? ((Component)obj).gameObject : null);
					if ((Object)(object)ammoCount == (Object)null)
					{
						GameObject gameObject = ((Component)__instance.m_elementPrefab.transform.Find("amount")).gameObject;
						ammoCount = Object.Instantiate<GameObject>(gameObject);
						((Object)ammoCount).name = "MLUI_AmmoAmount";
						ammoCount.transform.SetParent(__instance.m_elementPrefab.transform);
						ammoCount.transform.SetSiblingIndex(num);
						num++;
						ammoCount.SetActive(false);
						FillFields(gameObject.GetComponent<RectTransform>(), ammoCount.GetComponent<RectTransform>());
					}
					Transform obj2 = __instance.m_elementPrefab.transform.Find("MLUI_AmmoIcon");
					ammoIcon = ((obj2 != null) ? ((Component)obj2).gameObject : null);
					if ((Object)(object)ammoIcon == (Object)null)
					{
						GameObject gameObject2 = ((Component)__instance.m_elementPrefab.transform.Find("icon")).gameObject;
						ammoIcon = Object.Instantiate<GameObject>(gameObject2);
						((Object)ammoIcon).name = "MLUI_AmmoIcon";
						ammoIcon.transform.SetParent(__instance.m_elementPrefab.transform);
						ammoIcon.transform.SetSiblingIndex(num);
						num++;
						ammoIcon.SetActive(false);
						FillFields(gameObject2.GetComponent<RectTransform>(), ammoIcon.GetComponent<RectTransform>());
					}
					Transform obj3 = __instance.m_elementPrefab.transform.Find("MLUI_AmmoBait");
					ammoBait = ((obj3 != null) ? ((Component)obj3).gameObject : null);
					if ((Object)(object)ammoBait == (Object)null)
					{
						GameObject gameObject3 = ((Component)__instance.m_elementPrefab.transform.Find("icon")).gameObject;
						ammoBait = Object.Instantiate<GameObject>(gameObject3);
						((Object)ammoBait).name = "MLUI_AmmoBait";
						ammoBait.transform.SetParent(__instance.m_elementPrefab.transform);
						ammoBait.transform.SetSiblingIndex(num);
						num++;
						ammoBait.SetActive(false);
						FillFields(gameObject3.GetComponent<RectTransform>(), ammoBait.GetComponent<RectTransform>());
					}
					Transform obj4 = __instance.m_elementPrefab.transform.Find("MLUI_AmmoMead");
					ammoMead = ((obj4 != null) ? ((Component)obj4).gameObject : null);
					if ((Object)(object)ammoMead == (Object)null)
					{
						GameObject gameObject4 = ((Component)__instance.m_elementPrefab.transform.Find("icon")).gameObject;
						ammoMead = Object.Instantiate<GameObject>(gameObject4);
						((Object)ammoMead).name = "MLUI_AmmoMead";
						ammoMead.transform.SetParent(__instance.m_elementPrefab.transform);
						ammoMead.transform.SetSiblingIndex(num);
						num++;
						ammoMead.SetActive(false);
						FillFields(gameObject4.GetComponent<RectTransform>(), ammoMead.GetComponent<RectTransform>());
					}
					UpdateVisibility();
				}
			}
		}

		[HarmonyPatch(typeof(HotkeyBar), "Update")]
		public static class HotkeyBar_Update_UpdateAmmoIconCountDirtyState
		{
			[HarmonyPriority(0)]
			[HarmonyBefore(new string[] { "Azumatt.AzuExtendedPlayerInventory", "shudnal.ExtraSlots" })]
			public static void Prefix(HotkeyBar __instance)
			{
				if (MyLittleUI.modEnabled.Value && GeneralExtensions.GetValueSafe<HotkeyBar, bool>(isDirty, __instance))
				{
					isDirty[__instance] = false;
					if (__instance.m_elements.Count > 0)
					{
						__instance.m_items.Clear();
						__instance.UpdateIcons((Player)null);
					}
				}
			}
		}

		[HarmonyPatch(typeof(HotkeyBar), "UpdateIcons")]
		public static class HotkeyBar_UpdateIcons_UpdateAmmoCountAndIcon
		{
			[HarmonyPriority(0)]
			[HarmonyAfter(new string[] { "Azumatt.AzuExtendedPlayerInventory", "shudnal.ExtraSlots" })]
			public static void Postfix(HotkeyBar __instance, Player player)
			{
				if (!MyLittleUI.modEnabled.Value)
				{
					return;
				}
				if (!elementExtraDatas.ContainsKey(__instance))
				{
					elementExtraDatas.Add(__instance, new Dictionary<ElementData, ElementExtraData>());
				}
				Dictionary<ElementData, ElementExtraData> dictionary = elementExtraDatas[__instance];
				if (!Object.op_Implicit((Object)(object)player) || ((Character)player).IsDead())
				{
					dictionary.Clear();
					return;
				}
				if (dictionary.Count != __instance.m_elements.Count)
				{
					dictionary.Clear();
				}
				if (dictionary.Count > 0 && __instance.m_elements.Count > 0 && !dictionary.ContainsKey(__instance.m_elements[0]))
				{
					dictionary.Clear();
				}
				if (dictionary.Count == 0)
				{
					for (int i = 0; i < __instance.m_elements.Count; i++)
					{
						ElementData val = __instance.m_elements[i];
						ElementExtraData value = new ElementExtraData
						{
							m_ammo = ((Component)val.m_go.transform.Find("MLUI_AmmoAmount")).GetComponent<TMP_Text>(),
							m_icon = ((Component)val.m_go.transform.Find("MLUI_AmmoIcon")).GetComponent<Image>(),
							m_bait = ((Component)val.m_go.transform.Find("MLUI_AmmoBait")).GetComponent<Image>(),
							m_mead = ((Component)val.m_go.transform.Find("MLUI_AmmoMead")).GetComponent<Image>()
						};
						dictionary.Add(val, value);
					}
				}
				int num = 0;
				for (int j = 0; j < __instance.m_elements.Count; j++)
				{
					ElementData val2 = __instance.m_elements[j];
					ElementExtraData elementExtraData = dictionary[val2];
					if (elementExtraData == null)
					{
						continue;
					}
					if (!val2.m_used || num > __instance.m_items.Count)
					{
						elementExtraData.m_item = null;
					}
					else
					{
						elementExtraData.m_item = __instance.m_items[num];
						if ((Object)(object)elementExtraData.m_item.GetIcon() != (Object)(object)val2.m_icon.sprite)
						{
							elementExtraData.m_item = null;
						}
						num++;
					}
					elementExtraData.UpdateState(val2);
				}
			}
		}

		internal const string objectAmmoName = "MLUI_AmmoAmount";

		internal const string objectIconName = "MLUI_AmmoIcon";

		internal const string objectBaitName = "MLUI_AmmoBait";

		internal const string objectMeadName = "MLUI_AmmoMead";

		internal static GameObject elementPrefab;

		internal static GameObject ammoCount;

		internal static GameObject ammoIcon;

		internal static GameObject ammoBait;

		internal static GameObject ammoMead;

		internal static readonly Dictionary<HotkeyBar, bool> isDirty = new Dictionary<HotkeyBar, bool>();

		internal static readonly Dictionary<HotkeyBar, Dictionary<ElementData, ElementExtraData>> elementExtraDatas = new Dictionary<HotkeyBar, Dictionary<ElementData, ElementExtraData>>();

		public static void UpdateVisibility()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ammoCount.GetComponent<RectTransform>();
			component.anchoredPosition = MyLittleUI.ammoCountPosition.Value;
			TMP_Text component2 = ammoCount.GetComponent<TMP_Text>();
			component2.fontSize = MyLittleUI.ammoCountFontSize.Value;
			((Graphic)component2).color = ((MyLittleUI.ammoCountColor.Value == Color.clear) ? ((Graphic)((Component)elementPrefab.transform.Find("amount")).GetComponent<TMP_Text>()).color : MyLittleUI.ammoCountColor.Value);
			component2.horizontalAlignment = MyLittleUI.ammoCountAlignment.Value;
			RectTransform component3 = ammoIcon.GetComponent<RectTransform>();
			component3.anchoredPosition = MyLittleUI.ammoIconPosition.Value;
			component3.sizeDelta = MyLittleUI.ammoIconSize.Value;
			RectTransform component4 = ammoBait.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0.5f, 0f);
			component4.anchorMax = new Vector2(1f, 0.5f);
			RectTransform component5 = ammoMead.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0.6f, 0.6f);
			component5.anchorMax = new Vector2(1f, 1f);
			foreach (HotkeyBar item in isDirty.Keys.ToList())
			{
				isDirty[item] = true;
			}
		}
	}
	internal class ChestItem
	{
		public int m_stack;

		public int m_value;

		public string m_name;

		public float m_weight;

		public ItemType m_itemType;

		public ChestItem(ItemData itemData)
		{
			//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)
			m_name = itemData.m_shared.m_name;
			m_itemType = itemData.m_shared.m_itemType;
		}
	}
	internal static class ChestHoverText
	{
		[HarmonyPatch(typeof(Container), "OnContainerChanged")]
		private static class Container_OnContainerChanged_HoverCacheReset
		{
			private static void Postfix(Container __instance)
			{
				if (MyLittleUI.modEnabled.Value)
				{
					ResetCache(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Container), "GetHoverText")]
		private static class Container_GetHoverText_Duration
		{
			private static readonly StringBuilder result = new StringBuilder();

			private static void ReorderItemList(ref List<ChestItem> itemsInChest)
			{
				if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Position)
				{
					return;
				}
				if (MyLittleUI.chestContentSortDir.Value == MyLittleUI.ContentSortDir.Desc)
				{
					if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Name)
					{
						itemsInChest = itemsInChest.OrderByDescending((ChestItem item) => item.m_name).ToList();
					}
					else if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Weight)
					{
						itemsInChest = itemsInChest.OrderByDescending((ChestItem item) => item.m_weight).ToList();
					}
					else if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Amount)
					{
						itemsInChest = itemsInChest.OrderByDescending((ChestItem item) => item.m_stack).ToList();
					}
					else if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Value)
					{
						itemsInChest = itemsInChest.OrderByDescending((ChestItem item) => item.m_value).ToList();
					}
				}
				else if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Name)
				{
					itemsInChest = itemsInChest.OrderBy((ChestItem item) => item.m_name).ToList();
				}
				else if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Weight)
				{
					itemsInChest = itemsInChest.OrderBy((ChestItem item) => item.m_weight).ToList();
				}
				else if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Amount)
				{
					itemsInChest = itemsInChest.OrderBy((ChestItem item) => item.m_stack).ToList();
				}
				else if (MyLittleUI.chestContentSortType.Value == MyLittleUI.ContentSortType.Value)
				{
					itemsInChest = itemsInChest.OrderBy((ChestItem item) => item.m_value).ToList();
				}
			}

			private static void AddChestContent(Container container)
			{
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Expected I4, but got Unknown
				if (container.GetInventory().NrOfItems() == 0)
				{
					return;
				}
				result.Append("\n");
				List<ChestItem> itemsInChest = new List<ChestItem>();
				foreach (ItemData itemData in container.GetInventory().GetAllItemsInGridOrder())
				{
					ChestItem chestItem = itemsInChest.Find((ChestItem item) => item.m_name == itemData.m_shared.m_name);
					if (chestItem == null)
					{
						chestItem = new ChestItem(itemData);
						itemsInChest.Add(chestItem);
					}
					chestItem.m_stack += itemData.m_stack;
					chestItem.m_value += itemData.GetValue();
					chestItem.m_weight += itemData.GetWeight(-1);
				}
				ReorderItemList(ref itemsInChest);
				string itemFormat = "<color=#" + ColorUtility.ToHtmlStringRGBA(MyLittleUI.chestContentItemColor.Value) + ">{0}</color>";
				string amountFormat = "<color=#" + ColorUtility.ToHtmlStringRGBA(MyLittleUI.chestContentAmountColor.Value) + ">{0}</color>";
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				int num5 = 0;
				for (int i = 0; i < itemsInChest.Count; i++)
				{
					ChestItem chestItem2 = itemsInChest[i];
					if (i < MyLittleUI.chestContentLinesToShow.Value)
					{
						AddItemLine(chestItem2.m_name, chestItem2.m_stack);
						continue;
					}
					ItemType itemType = chestItem2.m_itemType;
					ItemType val = itemType;
					switch (val - 1)
					{
					case 1:
						num3++;
						break;
					case 0:
						num5++;
						break;
					case 2:
					case 3:
					case 4:
					case 13:
					case 14:
					case 18:
					case 19:
					case 21:
						num4++;
						break;
					case 5:
					case 6:
					case 9:
					case 10:
					case 11:
					case 16:
					case 17:
						num2++;
						break;
					default:
						num++;
						break;
					}
				}
				if (num + num2 + num3 + num4 + num5 != 0)
				{
					result.Append("\n+");
					if (num4 != 0)
					{
						AddItemLine("$radial_handitems", num4);
					}
					if (num2 != 0)
					{
						AddItemLine("$radial_armor_utility", num2);
					}
					if (num3 != 0)
					{
						AddItemLine("$radial_consumables", num3);
					}
					if (num5 != 0)
					{
						AddItemLine("$hud_crafting", num5);
					}
					if (num != 0)
					{
						AddItemLine("$hud_misc", num);
					}
				}
				void AddItemLine(string itemName, int amount)
				{
					result.AppendFormat("\n" + MyLittleUI.chestContentEntryFormat.Value, string.Format(itemFormat, itemName), string.Format(amountFormat, amount));
				}
			}

			private static void Postfix(Container __instance, ref string __result, bool ___m_checkGuardStone, string ___m_name, Inventory ___m_inventory)
			{
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				if (!MyLittleUI.modEnabled.Value || (MyLittleUI.chestHoverName.Value == MyLittleUI.ChestNameHover.Vanilla && MyLittleUI.chestHoverItems.Value == MyLittleUI.ChestItemsHover.Vanilla) || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid() || (___m_checkGuardStone && !PrivateArea.CheckAccess(((Component)__instance).transform.position, 0f, false, false)))
				{
					return;
				}
				string key = ((object)__instance.m_nview.GetZDO()).ToString();
				if (hoverTextCache.TryGetValue(key, out var value))
				{
					__result = value;
					return;
				}
				result.Clear();
				string @string = __instance.m_nview.GetZDO().GetString(ZDOVars.s_text, "");
				if (MyLittleUI.chestHoverName.Value == MyLittleUI.ChestNameHover.Vanilla || !MyLittleUI.chestCustomName.Value || Utility.IsNullOrWhiteSpace(@string))
				{
					result.Append(___m_name);
				}
				else if (MyLittleUI.chestHoverName.Value == MyLittleUI.ChestNameHover.CustomName)
				{
					result.Append(@string);
				}
				else if (MyLittleUI.chestHoverName.Value == MyLittleUI.ChestNameHover.TypeThenCustomName)
				{
					result.Append(___m_name);
					result.Append(" (");
					result.Append(@string);
					result.Append(")");
				}
				else if (MyLittleUI.chestHoverName.Value == MyLittleUI.ChestNameHover.CustomNameThenType)
				{
					result.Append(@string);
					result.Append(" (");
					result.Append(___m_name);
					result.Append(")");
				}
				if (__instance.CheckAccess(Game.instance.GetPlayerProfile().GetPlayerID()))
				{
					result.Append(" ");
					if (MyLittleUI.chestHoverItems.Value == MyLittleUI.ChestItemsHover.Percentage)
					{
						result.Append($"{___m_inventory.SlotsUsedPercentage():F0}%");
					}
					else if (MyLittleUI.chestHoverItems.Value == MyLittleUI.ChestItemsHover.FreeSlots)
					{
						result.Append($"{___m_inventory.GetEmptySlots()}");
					}
					else if (MyLittleUI.chestHoverItems.Value == MyLittleUI.ChestItemsHover.ItemsMaxRoom)
					{
						result.Append($"{___m_inventory.NrOfItems()}/{___m_inventory.GetWidth() * ___m_inventory.GetHeight()}");
					}
					else if (___m_inventory.NrOfItems() == 0)
					{
						result.Append("( $piece_container_empty )");
					}
					result.Append("\n[<color=#ffff00ff><b>$KEY_Use</b></color>] $piece_container_open");
					if (MyLittleUI.chestShowHoldToStack.Value)
					{
						result.Append(" $msg_stackall_hover");
					}
					if (MyLittleUI.chestShowRename.Value)
					{
						if (!ZInput.IsNonClassicFunctionality() || !ZInput.IsGamepadActive())
						{
							result.Append("\n[<color=#ffff00ff><b>$KEY_AltPlace + $KEY_Use</b></color>] $hud_rename");
						}
						else
						{
							result.Append("\n[<color=#ffff00ff><b>$KEY_JoyAltKeys + $KEY_Use</b></color>] $hud_rename");
						}
					}
					if (MyLittleUI.chestContentEnabled.Value)
					{
						AddChestContent(__instance);
					}
				}
				__result = Localization.instance.Localize(result.ToString());
				hoverTextCache.Add(key, __result);
			}
		}

		[HarmonyPatch(typeof(Container), "Interact")]
		private class Container_Interact_ChestRename
		{
			private static bool Prefix(Container __instance, Humanoid character, bool hold, bool alt, bool ___m_checkGuardStone)
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				if (!MyLittleUI.modEnabled.Value)
				{
					return true;
				}
				if (!MyLittleUI.chestCustomName.Value)
				{
					return true;
				}
				if (!alt)
				{
					return true;
				}
				if (hold)
				{
					return true;
				}
				if (___m_checkGuardStone && !PrivateArea.CheckAccess(((Component)__instance).transform.position, 0f, true, false))
				{
					((Character)character).Message((MessageType)2, "$piece_noaccess", 0, (Sprite)null);
					return true;
				}
				long playerID = Game.instance.GetPlayerProfile().GetPlayerID();
				if (!__instance.CheckAccess(playerID))
				{
					((Character)character).Message((MessageType)2, "$piece_noaccess", 0, (Sprite)null);
					return true;
				}
				textInputForContainer = __instance;
				TextInput.instance.Show("$hud_rename " + __instance.m_name, __instance.m_nview.GetZDO().GetString(ZDOVars.s_text, ""), 32);
				return false;
			}
		}

		[HarmonyPatch(typeof(TextInput), "setText")]
		private class TextInput_setText_ChestRename
		{
			private static void Postfix(string text)
			{
				if (MyLittleUI.modEnabled.Value && !((Object)(object)textInputForContainer == (Object)null))
				{
					textInputForContainer.m_nview.GetZDO().Set(ZDOVars.s_text, text);
					textInputForContainer.OnContainerChanged();
					textInputForContainer = null;
				}
			}
		}

		[HarmonyPatch(typeof(TextInput), "Hide")]
		private class TextInput_Hide_ChestRename
		{
			private static void Postfix()
			{
				if (MyLittleUI.modEnabled.Value && !((Object)(object)textInputForContainer == (Object)null))
				{
					textInputForContainer = null;
				}
			}
		}

		private static Container textInputForContainer;

		private static readonly Dictionary<string, string> hoverTextCache = new Dictionary<string, string>();

		internal static void ResetCache(Container container)
		{
			if (!((Object)(object)container == (Object)null) && !((Object)(object)container.m_nview == (Object)null) && container.m_nview.IsValid())
			{
				hoverTextCache.Remove(((object)container.m_nview.GetZDO()).ToString());
			}
		}

		internal static void ResetHoverCache()
		{
			hoverTextCache.Clear();
		}
	}
	public static class CookingStationRemoveItem
	{
		[HarmonyPatch(typeof(CookingStation), "RPC_AddItem")]
		public static class CookingStation_RPC_AddItem_SetItemAuthor
		{
			public static long author;

			public static void Prefix(long sender)
			{
				author = sender;
			}

			public static void Postfix()
			{
				author = 0L;
			}
		}

		[HarmonyPatch(typeof(CookingStation), "SetSlot")]
		public static class CookingStation_SetSlot_RemoveLastItem
		{
			public static void Postfix(CookingStation __instance, int slot)
			{
				if (__instance.m_nview.IsValid() && CookingStation_RPC_AddItem_SetItemAuthor.author != 0)
				{
					__instance.m_nview.GetZDO().Set(ZDOSlotAuthor(slot), CookingStation_RPC_AddItem_SetItemAuthor.author);
				}
			}
		}

		[HarmonyPatch(typeof(CookingStation), "Interact")]
		public static class CookingStation_Interact_RemoveLastItem
		{
			public static bool Prefix(CookingStation __instance, Humanoid user, bool hold, bool alt)
			{
				if (hold || (Object)(object)__instance.m_addFoodSwitch != (Object)null || !alt)
				{
					return true;
				}
				RemoveLastItemFromStation(__instance, user);
				return false;
			}
		}

		[HarmonyPatch(typeof(Switch), "Interact")]
		public static class Switch_Interact_RemoveLastItem
		{
			public static bool Prefix(Switch __instance, Humanoid character, bool hold, bool alt)
			{
				if (hold || !alt || !MyLittleUI.hoverCookingRemoveLastItem.Value)
				{
					return true;
				}
				if (__instance.m_onUse != null)
				{
					CookingStation componentInParent = ((Component)__instance).GetComponentInParent<CookingStation>();
					if (componentInParent != null && (Object)(object)componentInParent.m_addFoodSwitch == (Object)(object)__instance)
					{
						RemoveLastItemFromStation(componentInParent, character);
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Start")]
		public static class ZoneSystem_Start_Taxi
		{
			private static void Postfix()
			{
				ZRoutedRpc.instance.Register<ZDOID, Vector3>("RPC_MLUI_RemoveLastUncookedItem", (Action<long, ZDOID, Vector3>)RPC_MLUI_RemoveLastUncookedItem);
				ZRoutedRpc.instance.Register("RPC_MLUI_UndoCookingSkillRaise", (Action<long>)RPC_MLUI_UndoCookingSkillRaise);
			}
		}

		private static string ZDOSlotAuthor(int slot)
		{
			return "slotauthor" + slot;
		}

		private static long GetCurrentAuthor(CookingStation __instance, int slot)
		{
			return __instance.m_nview.GetZDO().GetLong(ZDOSlotAuthor(slot), 0L);
		}

		public static int GetSlotToRemove(CookingStation station, out string itemName, out long author)
		{
			float num2 = default(float);
			Status val = default(Status);
			for (int num = station.m_slots.Length - 1; num >= 0; num--)
			{
				station.GetSlot(num, ref itemName, ref num2, ref val);
				if (!(itemName == "") && !station.IsItemDone(itemName))
				{
					author = GetCurrentAuthor(station, num);
					return num;
				}
			}
			author = 0L;
			itemName = "";
			return -1;
		}

		public static void RPC_MLUI_RemoveLastUncookedItem(long sender, ZDOID targetZDO, Vector3 userPoint)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (((ZDOID)(ref targetZDO)).IsNone())
			{
				return;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(targetZDO);
			if (zDO == null)
			{
				return;
			}
			ZNetView val = ZNetScene.instance.FindInstance(zDO);
			if ((Object)(object)val != (Object)null && val.IsValid() && val.IsOwner())
			{
				CookingStation componentInParent = ((Component)val).GetComponentInParent<CookingStation>();
				if (componentInParent != null)
				{
					RemoveLastItem(sender, componentInParent, userPoint);
				}
			}
		}

		internal static void RemoveLastItem(long sender, CookingStation station, Vector3 userPoint)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			string itemName;
			long author;
			int slotToRemove = GetSlotToRemove(station, out itemName, out author);
			if (slotToRemove != -1)
			{
				station.SpawnItem(itemName, slotToRemove, userPoint);
				station.SetSlot(slotToRemove, "", 0f, (Status)0);
				station.m_nview.InvokeRPC(ZNetView.Everybody, "RPC_SetSlotVisual", new object[2] { slotToRemove, "" });
				if (author != 0)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(author, "RPC_MLUI_UndoCookingSkillRaise", Array.Empty<object>());
				}
			}
		}

		internal static void RPC_MLUI_UndoCookingSkillRaise(long sender)
		{
			((Character)Player.m_localPlayer).RaiseSkill((SkillType)105, -0.4f);
		}

		private static void RemoveLastItemFromStation(CookingStation station, Humanoid user)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)station.m_nview != (Object)null && station.m_nview.IsValid())
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(station.m_nview.GetZDO().GetOwner(), "RPC_MLUI_RemoveLastUncookedItem", new object[2]
				{
					station.m_nview.GetZDO().m_uid,
					((Component)user).transform.position
				});
			}
		}
	}
	public static class CraftFilter
	{
		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		public static class StoreGui_Awake_InitializePanel
		{
			[HarmonyPriority(800)]
			private static void Postfix()
			{
				InitFilterField();
				UpdateVisibility();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		public static class InventoryGui_Show_ClearCache
		{
			public static void Postfix()
			{
				ClearText();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnDestroy")]
		public static class InventoryGui_OnDestroy_ClearCache
		{
			public static void Postfix()
			{
				recipeCache.Clear();
			}
		}

		[HarmonyPatch(typeof(Chat), "HasFocus")]
		public static class Chat_HasFocus_FocusOverride
		{
			public static void Postfix(ref bool __result)
			{
				__result = __result || (IsCraftingFilterEnabled && ((TMP_InputField)playerFilter).isFocused);
			}
		}

		[HarmonyPatch(typeof(Player), "GetAvailableRecipes")]
		public static class Player_GetAvailableRecipes_FilterRecipeList
		{
			[HarmonyPriority(0)]
			public static void Postfix(ref List<Recipe> available)
			{
				if (IsCraftingFilterEnabled && applyFilter)
				{
					Stopwatch stopwatch = Stopwatch.StartNew();
					CollectionExtensions.Do<Recipe>((IEnumerable<Recipe>)available, (Action<Recipe>)CacheRecipe);
					MyLittleUI.LogInfo($"Recipe cache: verified {recipeCache.Count} in {(double)stopwatch.ElapsedTicks / (double)Stopwatch.Frequency * 1000.0:F2} ms");
					stopwatch.Reset();
					MyLittleUI.LogInfo($"Recipe filter: removed {available.RemoveAll((Recipe recipe) => !FitsFilterString(recipe))} in {(double)stopwatch.ElapsedTicks / (double)Stopwatch.Frequency * 1000.0:F2} ms");
					stopwatch.Stop();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
		public static class InventoryGui_UpdateRecipe_HandleFieldFocus
		{
			public static void Postfix()
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Invalid comparison between Unknown and I4
				if (!IsCraftingFilterEnabled)
				{
					return;
				}
				bool flag = (int)ZInput.InputLayout == 1;
				bool button = ZInput.GetButton("JoyLBumper");
				bool button2 = ZInput.GetButton("JoyLTrigger");
				if (((TMP_InputField)playerFilter).isFocused)
				{
					if (ZInput.GetButtonDown("Chat") || ZInput.GetButtonDown("Block") || ZInput.GetButtonDown("Console") || ZInput.GetButtonDown("Escape") || ZInput.GetButtonDown("Inventory") || (ZInput.GetButtonDown("JoyChat") && ZInput.GetButton("JoyAltKeys") && !(flag && button2) && !(!flag && button)))
					{
						((TMP_InputField)playerFilter).DeactivateInputField(false);
					}
				}
				else if ((Object)(object)Player.m_localPlayer != (Object)null && !Console.IsVisible() && !TextInput.IsVisible() && !Minimap.InTextInput() && !Menu.IsVisible() && (ZInput.GetButtonDown("Chat") || (ZInput.GetButtonDown("JoyChat") && ZInput.GetButton("JoyAltKeys") && !(flag && button2) && !(!flag && button))))
				{
					playerFilter.ActivateInputField();
				}
			}
		}

		private const float fieldHeight = 32f;

		private static Vector2 listAnchorMin = new Vector2(-1f, -1f);

		private static readonly Dictionary<Recipe, string> recipeCache = new Dictionary<Recipe, string>();

		private static GuiInputField playerFilter;

		private static string[] filterString = Array.Empty<string>();

		private static bool applyFilter;

		private static readonly StringBuilder sb = new StringBuilder();

		private static readonly StringBuilder sbItem = new StringBuilder();

		public static bool IsCraftingFilterEnabled => MyLittleUI.modEnabled.Value && MyLittleUI.craftingFilterEnabled.Value && !MyLittleUI.AAA_Crafting && !MyLittleUI.ZenUI;

		private static void InitFilterField()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			if (!MyLittleUI.AAA_Crafting && !MyLittleUI.ZenUI)
			{
				Transform parent = ((Component)InventoryGui.instance.m_recipeListScroll).transform.parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				GameObject val2 = Object.Instantiate<GameObject>(((Component)TextInput.instance.m_inputField).gameObject, ((Transform)val).parent);
				((Object)val2).name = "MLUI_FilterField";
				val2.transform.SetSiblingIndex(((Transform)val).GetSiblingIndex() + 1);
				RectTransform component = val2.GetComponent<RectTransform>();
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.zero;
				Rect rect = val.rect;
				component.sizeDelta = new Vector2(((Rect)(ref rect)).width, 32f);
				component.anchoredPosition = new Vector2(val.anchoredPosition.x, 4f);
				component.pivot = Vector2.zero;
				playerFilter = val2.GetComponent<GuiInputField>();
				playerFilter.VirtualKeyboardTitle = "$menu_filter";
				((Component)((Component)playerFilter).transform.Find("Text Area/Placeholder")).GetComponent<TMP_Text>().SetText(Localization.instance.Localize("$menu_filter"));
				((TMP_InputField)playerFilter).restoreOriginalTextOnEscape = false;
				Button val3 = Object.Instantiate<Button>(InventoryGui.instance.m_splitOkButton, val2.transform);
				((Object)val3).name = "ClearTextButton";
				((UnityEventBase)val3.onClick).RemoveAllListeners();
				((UnityEvent)val3.onClick).AddListener(new UnityAction(ClearText));
				RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(1f, 0.5f);
				component2.anchorMax = new Vector2(1f, 0.5f);
				component2.sizeDelta = Vector2.one * 28f;
				component2.anchoredPosition = new Vector2(-16f, 0f);
				TextMeshProUGUI component3 = ((Component)((Component)val3).transform.Find("Text")).GetComponent<TextMeshProUGUI>();
				((TMP_Text)component3).SetText("✖");
				((TMP_Text)component3).margin = Vector4.one * -2f;
				((Component)val3).transform.Find("gamepad_hint").localPosition = new Vector3(-0.75f, 23.8f, 0f);
				((UnityEvent<string>)(object)((TMP_InputField)playerFilter).onValueChanged).AddListener((UnityAction<string>)delegate
				{
					UpdateFilterString();
					StartPanelUpdate();
				});
			}
		}

		public static void UpdateVisibility()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (MyLittleUI.AAA_Crafting || MyLittleUI.ZenUI)
			{
				return;
			}
			GuiInputField obj = playerFilter;
			if (obj != null)
			{
				GameObject gameObject = ((Component)obj).gameObject;
				if (gameObject != null)
				{
					gameObject.SetActive(IsCraftingFilterEnabled);
				}
			}
			if (Object.op_Implicit((Object)(object)InventoryGui.instance.m_recipeListScroll))
			{
				Transform parent = ((Component)InventoryGui.instance.m_recipeListScroll).transform.parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if (listAnchorMin.x == -1f)
				{
					listAnchorMin = val.anchorMin;
				}
				GuiInputField obj2 = playerFilter;
				val.anchorMin = ((obj2 != null && ((Behaviour)obj2).isActiveAndEnabled) ? (listAnchorMin + new Vector2(0f, 0.05f)) : listAnchorMin);
			}
		}

		public static void UpdateFilterString()
		{
			GuiInputField obj = playerFilter;
			if (applyFilter = !string.IsNullOrWhiteSpace((obj != null) ? ((TMP_InputField)obj).text : null))
			{
				GuiInputField obj2 = playerFilter;
				filterString = ((obj2 != null) ? ((TMP_InputField)obj2).text.ToLower().Split(new char[1] { ' ' }, StringSplitOptions.None) : null);
			}
		}

		public static void ClearText()
		{
			applyFilter = false;
			if (Object.op_Implicit((Object)(object)playerFilter))
			{
				((TMP_InputField)playerFilter).text = "";
			}
		}

		private static string GetItemFullString(ItemDrop itemDrop)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			sbItem.Clear();
			sbItem.Append(((Object)itemDrop).name);
			sbItem.Append(' ');
			sbItem.Append(itemDrop.m_itemData.m_shared.m_itemType);
			sbItem.Append(' ');
			sbItem.Append(itemDrop.m_itemData.m_shared.m_setName);
			sbItem.Append(' ');
			sbItem.Append(itemDrop.m_itemData.m_shared.m_name);
			sbItem.Append(' ');
			sbItem.Append(Localization.instance.Localize(itemDrop.m_itemData.m_shared.m_name));
			sbItem.Append(' ');
			sbItem.Append(itemDrop.m_itemData.GetTooltip(-1));
			return sbItem.ToString();
		}

		private static void CacheRecipe(Recipe recipe)
		{
			if (!recipeCache.ContainsKey(recipe))
			{
				sb.Clear();
				sb.Append(((Object)recipe).name);
				sb.Append(' ');
				sb.Append(GetItemFullString(recipe.m_item));
				sb.Append(' ');
				CollectionExtensions.Do<Requirement>((IEnumerable<Requirement>)recipe.m_resources, (Action<Requirement>)delegate(Requirement req)
				{
					sb.Append(GetItemFullString(req.m_resItem));
					sb.Append(' ');
				});
				recipeCache[recipe] = sb.ToString().ToLower();
			}
		}

		private static bool FitsFilterString(Recipe recipe)
		{
			return recipeCache.ContainsKey(recipe) && filterString.All((string substr) => recipeCache[recipe].Contains(substr));
		}

		private static void StartPanelUpdate()
		{
			((MonoBehaviour)MyLittleUI.instance).CancelInvoke("UpdateCraftingPanel");
			((MonoBehaviour)MyLittleUI.instance).Invoke("UpdateCraftingPanel", ((float)recipeCache.Count == 0f) ? 0.4f : 0.2f);
		}

		public static void UpdateCraftingPanel()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)InventoryGui.instance))
			{
				InventoryGui.instance.UpdateCraftingPanel(true);
				InventoryGui.instance.m_moveItemEffects.Create(((Component)Player.m_localPlayer).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
			}
		}
	}
	public static class CraftSort
	{
		public class FilteringPanel
		{
			public string name;

			public RectTransform panel;

			public RectTransform selectedFrame;

			public List<FilteringState> filters;

			public bool enabled;

			public int enabledFilters;

			public override string ToString()
			{
				return name;
			}

			public FilteringPanel(string name)
			{
				this.name = name;
				ref RectTransform reference = ref panel;
				Transform repairPanel = InventoryGui.instance.m_repairPanel;
				reference = Object.Instantiate<RectTransform>((RectTransform)(object)((repairPanel is RectTransform) ? repairPanel : null), (Transform)(object)sortPanel);
				((Object)panel).name = "MLUI_SortingPanel_" + name;
				if (Object.op_Implicit((Object)(object)InventoryGui.instance.m_repairPanelSelection))
				{
					ref RectTransform reference2 = ref selectedFrame;
					Transform repairPanelSelection = InventoryGui.instance.m_repairPanelSelection;
					reference2 = Object.Instantiate<RectTransform>((RectTransform)(object)((repairPanelSelection is RectTransform) ? repairPanelSelection : null), ((Component)InventoryGui.instance.m_repairPanelSelection).transform.parent);
					((Object)selectedFrame).name = "selected (" + ((Object)panel).name + ")";
				}
				filters = new List<FilteringState>();
				panels.Add(this);
			}

			public void AddFilter(FilteringState filter)
			{
				filters.Add(filter);
			}

			public void UpdatePosition(ref int height)
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				int num = Mathf.CeilToInt((float)enabledFilters / 3f);
				int num2 = 34 * num - 2 + 12;
				int num3 = 0;
				if (enabledFilters == 2)
				{
					num3 = 34;
				}
				else if (enabledFilters == 1)
				{
					num3 = 68;
				}
				panel.sizeDelta = new Vector2(120f - (float)num3, (float)num2);
				height += num2;
				panel.anchoredPosition = new Vector2(0f, (float)(-height));
				if (Object.op_Implicit((Object)(object)selectedFrame))
				{
					selectedFrame.sizeDelta = panel.sizeDelta + new Vector2(4f, 4f);
					selectedFrame.anchoredPosition = panel.anchoredPosition - new Vector2(panel.sizeDelta.x + 2f, 202f);
				}
			}

			public void UpdateVisibility()
			{
				RectTransform obj = panel;
				if (obj != null)
				{
					((Component)obj).gameObject.SetActive(enabled);
				}
				RectTransform obj2 = selectedFrame;
				if (obj2 != null)
				{
					((Component)obj2).gameObject.SetActive(enabled);
				}
			}

			public void ClearPanel()
			{
				enabled = false;
				enabledFilters = 0;
				CollectionExtensions.Do<FilteringState>((IEnumerable<FilteringState>)filters, (Action<FilteringState>)delegate(FilteringState state)
				{
					state.ClearFiltering();
				});
				UpdateVisibility();
			}
		}

		public class FilteringState
		{
			public int position;

			public bool selectable;

			public bool enabled;

			public bool selected;

			public bool lastSelected;

			public string category;

			public string tooltip;

			public Sprite icon;

			public string name;

			public Color imageColor;

			public bool unique = true;

			public RectTransform element;

			public Button button;

			public Image image;

			public GameObject active;

			public GameObject select;

			public FilteringPanel panel;

			public Comparison<RecipeDataPair> sort;

			public Func<ItemData, bool> filter;

			public FilteringState()
			{
				filteringStates.Add(this);
			}

			public void CreateElement()
			{
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: 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_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Expected O, but got Unknown
				if (!Object.op_Implicit((Object)(object)element))
				{
					element = Object.Instantiate<RectTransform>(elementPrefab, (Transform)(object)panel.panel);
					((Object)element).name = name;
					((Component)element).gameObject.SetActive(true);
					((Component)element).GetComponent<UITooltip>().m_text = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(Localization.instance.Localize(tooltip));
					image = ((Component)((Transform)element).Find("icon")).GetComponent<Image>();
					if (Object.op_Implicit((Object)(object)image))
					{
						image.overrideSprite = icon;
						((Graphic)image).color = ((imageColor != Color.clear) ? imageColor : Color.white);
						Transform transform = ((Component)image).transform;
						transform.localScale *= 0.9f;
					}
					button = ((Component)element).GetComponent<Button>();
					Transform obj = ((Transform)element).Find("active");
					active = ((obj != null) ? ((Component)obj).gameObject : null);
					Transform obj2 = ((Transform)element).Find("selected");
					select = ((obj2 != null) ? ((Component)obj2).gameObject : null);
					((UnityEvent)button.onClick).AddListener(new UnityAction(OnClick));
					UpdateElementPosition();
				}
			}

			public void UpdateElementPosition()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)element))
				{
					element.anchoredPosition = new Vector2(8f + (float)(position % 3) * 34f, -6f - (float)(position / 3) * 34f);
				}
			}

			public void UpdatePosition(ref int currentPosition)
			{
				position = currentPosition;
				if (selectable)
				{
					currentPosition++;
				}
				UpdateElementPosition();
			}

			public void UpdateEnabled()
			{
				GameObject obj = active;
				if (obj != null)
				{
					obj.SetActive(enabled);
				}
			}

			public void UpdateSelectable()
			{
				RectTransform obj = element;
				if (obj != null)
				{
					GameObject gameObject = ((Component)obj).gameObject;
					if (gameObject != null)
					{
						gameObject.SetActive(selectable);
					}
				}
			}

			public void UpdateSelect()
			{
				GameObject obj = select;
				if (obj != null)
				{
					obj.SetActive(selected);
				}
			}

			public void SetSelected(bool selected)
			{
				this.selected = selected;
				if (selected)
				{
					lastSelected = true;
					CollectionExtensions.DoIf<FilteringState>((IEnumerable<FilteringState>)filteringStates, (Func<FilteringState, bool>)((FilteringState fs) => fs != this), (Action<FilteringState>)delegate(FilteringState fs)
					{
						fs.lastSelected = false;
					});
				}
			}

			public void ClearFiltering()
			{
				selectable = false;
				enabled = false;
				selected = false;
				position = 0;
				UpdateEnabled();
				UpdateSelectable();
				UpdateSelect();
			}

			public bool IsSelectable(ItemData item)
			{
				return filter != null && filter(item);
			}

			public void OnClick()
			{
				enabled = !enabled;
				UpdateEnabled();
				if (unique)
				{
					CollectionExtensions.DoIf<FilteringState>((IEnumerable<FilteringState>)filteringStates, (Func<FilteringState, bool>)((FilteringState fs) => fs != this), (Action<FilteringState>)delegate(FilteringState fs)
					{
						fs.enabled = false;
						fs.UpdateEnabled();
					});
				}
				InventoryGui.instance.UpdateCraftingPanel(true);
			}
		}

		[HarmonyPatch(typeof(Game), "SpawnPlayer")]
		public static class Game_SpawnPlayer_InitializePanel
		{
			public static void Postfix()
			{
				CheckPanels();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Update")]
		public static class InventoryGui_Update_SortingPanelVisibility
		{
			public static void Postfix()
			{
				UpdateVisibility();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Show")]
		public static class InventoryGui_Show_ClearFiltersState
		{
			public static void Prefix()
			{
				ClearPanels();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnDestroy")]
		public static class InventoryGui_OnDestroy_ClearData
		{
			public static void Prefix()
			{
				filteringStates.Clear();
				tempEnabledStates.Clear();
				panels.Clear();
				sortPanel = null;
				elementPrefab = null;
				foodSprite = null;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateCraftingPanel")]
		public static class InventoryGui_UpdateCraftingPanel_HideWithOtherMods
		{
			[HarmonyPriority(0)]
			public static void Postfix(InventoryGui __instance)
			{
				if (!__instance.InCraftTab() && !__instance.InUpradeTab())
				{
					ClearPanels();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Update")]
		public static class InventoryGui_Update_HideWithOtherMods
		{
			[HarmonyPriority(0)]
			public static void Postfix(InventoryGui __instance)
			{
				if (!__instance.InCraftTab() && !__instance.InUpradeTab())
				{
					ClearPanels();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeList")]
		public static class InventoryGui_UpdateRecipeList_FilteringAndSorting
		{
			[HarmonyPriority(800)]
			[HarmonyAfter(new string[] { "ZenDragon.ZenUI" })]
			public static void Prefix(InventoryGui __instance, List<Recipe> recipes)
			{
				FilterRecipes(recipes, __instance.InCraftTab(), __instance.InUpradeTab());
			}

			[HarmonyPriority(800)]
			[HarmonyAfter(new string[] { "ZenDragon.ZenUI" })]
			public static void Postfix()
			{
				SortRecipes();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Update")]
		public static class InventoryGui_Update_GamepadControls
		{
			public static FilteringState GetSelectedFilter()
			{
				return filteringStates.FirstOrDefault((FilteringState fs) => fs.selectable && fs.selected);
			}

			[HarmonyPriority(800)]
			public static void Prefix(InventoryGui __instance)
			{
				if (!IsCraftingFilterEnabled || !InventoryGui.IsVisible() || !__instance.m_inventoryGroup.IsActive || __instance.m_activeGroup != 3)
				{
					return;
				}
				if (!ZInput.IsGamepadActive() || ZInput.GetButtonDown("JoyLStickDown") || ZInput.GetButtonDown("JoyLStickUp") || ((MyLittleUI.ZenUI || MyLittleUI.AAA_Crafting) ? ZInput.GetButtonDown("JoyRStickRight") : ZInput.GetButtonDown("JoyLStickRight")))
				{
					CollectionExtensions.Do<FilteringState>((IEnumerable<FilteringState>)filteringStates, (Action<FilteringState>)delegate(FilteringState fs)
					{
						fs.SetSelected(selected: false);
					});
					return;
				}
				string text = ((MyLittleUI.ZenUI || MyLittleUI.AAA_Crafting) ? "JoyRStickLeft" : "JoyLStickLeft");
				if (ZInput.GetButtonDown(text))
				{
					FilteringState filteringState = filteringStates.FirstOrDefault((FilteringState fs) => fs.selectable && fs.enabled);
					if (filteringState != null)
					{
						filteringState.SetSelected(selected: true);
						ZInput.ResetButtonStatus(text);
					}
					else if (panels.Count > 0)
					{
						FilteringState selectedFilter = GetSelectedFilter();
						selectedFilter = filteringStates.FirstOrDefault((FilteringState fs) => fs.selectable && fs.lastSelected) ?? filteringStates.FirstOrDefault((FilteringState fs) => fs.selectable);
						if (selectedFilter != null)
						{
							selectedFilter.SetSelected(selected: true);
							ZInput.ResetButtonStatus(text);
						}
					}
				}
				else if (ZInput.GetButtonDown("JoyDPadLeft"))
				{
					FilteringState selectedFilter2 = GetSelectedFilter();
					if (selectedFilter2 != null)
					{
						for (int num = selectedFilter2.panel.filters.IndexOf(selectedFilter2) - 1; num >= 0; num--)
						{
							if (selectedFilter2.panel.filters[num].selectable)
							{
								selectedFilter2.SetSelected(selected: false);
								selectedFilter2.panel.filters[num].SetSelected(selected: true);
								ZInput.ResetButtonStatus("JoyDPadLeft");
								return;
							}
						}
						int num2 = panels.IndexOf(selectedFilter2.panel);
						for (int num3 = num2 - 1; num3 >= 0; num3--)
						{
							FilteringState filteringState2 = panels[num3].filters.LastOrDefault((FilteringState fs) => fs.selectable);
							if (filteringState2 != null)
							{
								selectedFilter2.SetSelected(selected: false);
								filteringState2.SetSelected(selected: true);
								ZInput.ResetButtonStatus("JoyDPadLeft");
								return;
							}
						}
						FilteringState filteringState3 = filteringStates.LastOrDefault((FilteringState fs) => fs.selectable);
						if (filteringState3 != null)
						{
							selectedFilter2.SetSelected(selected: false);
							filteringState3.SetSelected(selected: true);
							ZInput.ResetButtonStatus("JoyDPadLeft");
						}
						return;
					}
					if (!MyLittleUI.AAA_Crafting)
					{
						FilteringState filteringState4 = filteringStates.FirstOrDefault((FilteringState fs) => fs.selectable && fs.enabled);
						if (filteringState4 != null)
						{
							filteringState4.SetSelected(selected: true);
							ZInput.ResetButtonStatus("JoyDPadLeft");
							return;
						}
					}
					if (!MyLittleUI.AAA_Crafting && panels.Count > 0)
					{
						selectedFilter2 = filteringStates.FirstOrDefault((FilteringState fs) => fs.selectable && fs.lastSelected) ?? filteringStates.FirstOrDefault((FilteringState fs) => fs.selectable);
						if (selectedFilter2 != null)
						{
							selectedFilter2.SetSelected(selected: true);
							ZInput.ResetButtonStatus("JoyDPadLeft");
						}
					}
				}
				else if (ZInput.GetButtonDown("JoyDPadRight"))
				{
					FilteringState selectedFilter3 = GetSelectedFilter();
					if (selectedFilter3 == null)
					{
						return;
					}
					for (int i = selectedFilter3.panel.filters.IndexOf(selectedFilter3) + 1; i < selectedFilter3.panel.filters.Count; i++)
					{
						if (selectedFilter3.panel.filters[i].selectable)
						{
							selectedFilter3.SetSelected(selected: false);
							selectedFilter3.panel.filters[i].SetSelected(selected: true);
							ZInput.ResetButtonStatus("JoyDPadRight");
							return;
						}
					}
					int num4 = panels.IndexOf(selectedFilter3.panel);
					for (int j = num4 + 1; j < panels.Count; j++)
					{
						FilteringState filteringState5 = panels[j].filters.FirstOrDefault((FilteringState fs) => fs.selectable);
						if (filteringState5 != null)
						{
							selectedFilter3.SetSelected(selected: false);
							filteringState5.SetSelected(selected: true);
							ZInput.ResetButtonStatus("JoyDPadRight");
							return;
						}
					}
					FilteringState filteringState6 = filteringStates.FirstOrDefault((FilteringState fs) => fs.selectable);
					if (filteringState6 != null)
					{
						selectedFilter3.SetSelected(selected: false);
						filteringState6.SetSelected(selected: true);
						ZInput.ResetButtonStatus("JoyDPadRight");
					}
				}
				else if (ZInput.GetButtonDown("JoyDPadUp"))
				{
					FilteringState selectedFilter4 = GetSelectedFilter();
					if (selectedFilter4 == null)
					{
						return;
					}
					int num5 = 0;
					for (int num6 = selectedFilter4.panel.filters.IndexOf(selectedFilter4); num6 >= 0; num6--)
					{
						if (selectedFilter4.panel.filters[num6].selectable)
						{
							if (num5 >= 3)
							{
								selectedFilter4.SetSelected(selected: false);
								selectedFilter4.panel.filters[num6].SetSelected(selected: true);
								ZInput.ResetButtonStatus("JoyDPadUp");
								return;
							}
							num5++;
						}
					}
					int num7 = panels.IndexOf(selectedFilter4.panel);
					List<FilteringState> list2 = selectedFilter4.panel.filters.Where((FilteringState fs) => fs.selectable).ToList();
					int column2 = list2.IndexOf(selectedFilter4) % 3;
					if (list2.Count == 2)
					{
						column2++;
					}
					else if (list2.Count == 1)
					{
						column2 += 2;
					}
					for (int num8 = num7 + panels.Count - 1; num8 > num7; num8--)
					{
						FilteringPanel filteringPanel = panels[num8 % panels.Count];
						list2 = filteringPanel.filters.Where((FilteringState fs) => fs.selectable).ToList();
						if (list2.Count == 2)
						{
							column2 = Math.Max(0, column2 - 1);
						}
						else if (list2.Count == 1)
						{
							column2 = Math.Max(0, column2 - 2);
						}
						FilteringState filteringState7 = list2.LastOrDefault((FilteringState fs) => list2.IndexOf(fs) % 3 == column2) ?? filteringPanel.filters.LastOrDefault((FilteringState fs) => fs.selectable);
						if (filteringState7 != null)
						{
							selectedFilter4.SetSelected(selected: false);
							filteringState7.SetSelected(selected: true);
							ZInput.ResetButtonStatus("JoyDPadUp");
							break;
						}
					}
				}
				else if (ZInput.GetButtonDown("JoyDPadDown"))
				{
					FilteringState selectedFilter5 = GetSelectedFilter();
					if (selectedFilter5 == null)
					{
						return;
					}
					int num9 = 0;
					for (int k = selectedFilter5.panel.filters.IndexOf(selectedFilter5); k < selectedFilter5.panel.filters.Count; k++)
					{
						if (selectedFilter5.panel.filters[k].selectable)
						{
							if (num9 >= 3)
							{
								selectedFilter5.SetSelected(selected: false);
								selectedFilter5.panel.filters[k].SetSelected(selected: true);
								ZInput.ResetButtonStatus("JoyDPadDown");
								return;
							}
							num9++;
						}
					}
					int num10 = panels.IndexOf(selectedFilter5.panel);
					List<FilteringState> list = selectedFilter5.panel.filters.Where((FilteringState fs) => fs.selectable).ToList();
					int column = list.IndexOf(selectedFilter5) % 3;
					if (list.Count == 2)
					{
						column++;
					}
					else if (list.Count == 1)
					{
						column += 2;
					}
					for (int l = num10 + 1; l < panels.Count + num10; l++)
					{
						FilteringPanel filteringPanel2 = panels[l % panels.Count];
						list = filteringPanel2.filters.Where((FilteringState fs) => fs.selectable).ToList();
						if (list.Count == 2)
						{
							column = Math.Max(0, column - 1);
						}
						else if (list.Count == 1)
						{
							column = Math.Max(0, column - 2);
						}
						FilteringState filteringState8 = list.FirstOrDefault((FilteringState fs) => list.IndexOf(fs) % 3 == column) ?? filteringPanel2.filters.FirstOrDefault((FilteringState fs) => fs.selectable);
						if (filteringState8 != null)
						{
							selectedFilter5.SetSelected(selected: false);
							filteringState8.SetSelected(selected: true);
							ZInput.ResetButtonStatus("JoyDPadDown");
							break;
						}
					}
				}
				else if (ZInput.GetButtonDown("JoyRStick"))
				{
					FilteringState selectedFilter6 = GetSelectedFilter();
					if (selectedFilter6 != null)
					{
						selectedFilter6.OnClick();
						ZInput.ResetButtonStatus("JoyRStick");
					}
				}
				else if (ZInput.GetButtonDown("JoyJump"))
				{
					FilteringState selectedFilter7 = GetSelectedFilter();
					if (selectedFilter7 != null)
					{
						selectedFilter7.OnClick();
						ZInput.ResetButtonStatus("JoyJump");
					}
				}
			}

			public static void Postfix()
			{
				CollectionExtensions.Do<FilteringState>((IEnumerable<FilteringState>)filteringStates, (Action<FilteringState>)delegate(FilteringState fs)
				{
					fs.UpdateSelect();
				});
			}
		}

		public static readonly List<FilteringPanel> panels = new List<FilteringPanel>();

		public static readonly List<FilteringState> filteringStates = new List<FilteringState>();

		public static readonly List<FilteringState> tempEnabledStates = new List<FilteringState>();

		public static readonly List<string> tempUnfitItems = new List<string>();

		public static RectTransform sortPanel;

		public static RectTransform elementPrefab;

		public static Sprite foodSprite;

		public static bool IsCraftingFilterEnabled => MyLittleUI.modEnabled.Value && MyLittleUI.craftingSortingEnabled.Value;

		public static void UpdateVisibility()
		{
			RectTransform obj = sortPanel;
			if (obj != null)
			{
				((Component)obj).gameObject.SetActive(IsCraftingFilterEnabled);
			}
		}

		internal static void InitElementPrefab(Transform parent)
		{
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)elementPrefab))
			{
				return;
			}
			elementPrefab = Object.Instantiate<GameObject>(InventoryGui.instance.m_playerGrid.m_elementPrefab, parent).GetComponent<RectTransform>();
			for (int num = ((Transform)elementPrefab).childCount - 1; num >= 0; num--)
			{
				Transform child = ((Transform)elementPrefab).GetChild(num);
				((Component)child).gameObject.SetActive(false);
				switch (((Object)child).name)
				{
				case "foodicon":
					if (foodSprite == null)
					{
						foodSprite = ((Component)child).GetComponent<Image>().sprite;
					}
					Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
					break;
				case "amount":
				case "durability":
				case "binding":
				case "quality":
				case "noteleport":
				case "equiped":
					Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
					break;
				case "icon":
					((Component)child).gameObject.SetActive(true);
					break;
				case "queued":
					((Object)child).name = "active";
					break;
				}
			}
			((Object)elementPrefab).name = "filterElement";
			elementPrefab.sizeDelta = Vector2.one * 32f;
			((Component)elementPrefab).gameObject.SetActive(false);
			((Component)elementPrefab).GetComponent<UITooltip>().m_tooltipPrefab = ((Component)InventoryGui.instance.m_repairButton).GetComponent<UITooltip>().m_tooltipPrefab;
			((UnityEventBase)((Component)elementPrefab).GetComponent<Button>().onClick).RemoveAllListeners();
		}

		internal static void InitSortingPanel()
		{
			//IL_00d7: 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)
			if (IsCraftingFilterEnabled && Object.op_Implicit((Object)(object)InventoryGui.instance) && !Object.op_Implicit((Object)(object)sortPanel) && Object.op_Implicit((Object)(object)InventoryGui.instance.m_repairPanel) && Object.op_Implicit((Object)(object)InventoryGui.instance.m_repairButton) && Object.op_Implicit((Object)(object)InventoryGui.instance.m_playerGrid.m_elementPrefab))
			{
				Transform repairPanel = InventoryGui.instance.m_repairPanel;
				sortPanel = Object.Instantiate<RectTransform>((RectTransform)(object)((repairPanel is RectTransform) ? repairPanel : null), ((Component)InventoryGui.instance.m_repairPanel).transform.parent);
				((Object)sortPanel).name = "MLUI_SortingPanels";
				((Transform)sortPanel).SetSiblingIndex(InventoryGui.instance.m_repairPanel.GetSiblingIndex() + 1);
				sortPanel.anchoredPosition = new Vector2(0f, -200f);
				sortPanel.sizeDelta = new Vector2(0f, 0f);
				((Component)sortPanel).gameObject.SetActive(false);
				panels.Clear();
				filteringStates.Clear();
				InitElementPrefab((Transform)(object)sortPanel);
				InitFoodCategory();
				InitArmorCategory();
				InitSkillsCategory();
				InitBowsCategory();
				InitCrossbowsCategory();
				InitMagicCategory();
				InitToolsCategory();
				filteringStates.ForEach(delegate(FilteringState fs)
				{
					fs.CreateElement();
				});
			}
		}

		private static void InitFoodCategory()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			FilteringPanel filteringPanel = new FilteringPanel("Food");
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "food",
				category = "$hud_food",
				tooltip = "$item_food_health",
				icon = foodSprite,
				imageColor = InventoryGui.instance.m_playerGrid.m_foodHealthColor,
				unique = true,
				sort = delegate(RecipeDataPair a, RecipeDataPair b)
				{
					float num3 = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_appendToolTip?.m_itemData.m_shared.m_food ?? ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_food;
					float value3 = ((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_appendToolTip?.m_itemData.m_shared.m_food ?? ((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_food;
					return num3.CompareTo(value3);
				},
				filter = (ItemData item) => ((int)item.m_shared.m_itemType == 2 && item.m_shared.m_food > 0f) || ((int)item.m_shared.m_itemType == 1 && (Object)(object)item.m_shared.m_appendToolTip != (Object)null && item.m_shared.m_appendToolTip.m_itemData.m_shared.m_food > 0f)
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "food_stamina",
				category = "$hud_food",
				tooltip = "$item_food_stamina",
				icon = foodSprite,
				imageColor = InventoryGui.instance.m_playerGrid.m_foodStaminaColor,
				unique = true,
				sort = delegate(RecipeDataPair a, RecipeDataPair b)
				{
					float num2 = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_appendToolTip?.m_itemData.m_shared.m_foodStamina ?? ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_foodStamina;
					float value2 = ((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_appendToolTip?.m_itemData.m_shared.m_foodStamina ?? ((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_foodStamina;
					return num2.CompareTo(value2);
				},
				filter = (ItemData item) => ((int)item.m_shared.m_itemType == 2 && item.m_shared.m_foodStamina > 0f) || ((int)item.m_shared.m_itemType == 1 && (Object)(object)item.m_shared.m_appendToolTip != (Object)null && item.m_shared.m_appendToolTip.m_itemData.m_shared.m_foodStamina > 0f)
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "food_eitr",
				category = "$hud_food",
				tooltip = "$item_food_eitr",
				icon = foodSprite,
				imageColor = InventoryGui.instance.m_playerGrid.m_foodEitrColor,
				unique = true,
				sort = delegate(RecipeDataPair a, RecipeDataPair b)
				{
					float num = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_appendToolTip?.m_itemData.m_shared.m_foodEitr ?? ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_foodEitr;
					float value = ((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_appendToolTip?.m_itemData.m_shared.m_foodEitr ?? ((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_foodEitr;
					return num.CompareTo(value);
				},
				filter = (ItemData item) => ((int)item.m_shared.m_itemType == 2 && item.m_shared.m_foodEitr > 0f) || ((int)item.m_shared.m_itemType == 1 && (Object)(object)item.m_shared.m_appendToolTip != (Object)null && item.m_shared.m_appendToolTip.m_itemData.m_shared.m_foodEitr > 0f)
			});
		}

		private static void InitArmorCategory()
		{
			FilteringPanel filteringPanel = new FilteringPanel("Armor");
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "armor_helmet",
				category = "Armor",
				tooltip = "$radial_armor_utility",
				icon = ObjectDB.instance.GetItemPrefab("HelmetBronze").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByArmor,
				filter = (ItemData item) => (int)item.m_shared.m_itemType == 6 || (int)item.m_shared.m_attachOverride == 6
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "armor_chest",
				category = "Armor",
				tooltip = "$radial_armor_utility",
				icon = ObjectDB.instance.GetItemPrefab("ArmorIronChest").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByArmor,
				filter = (ItemData item) => (int)item.m_shared.m_itemType == 7 || (int)item.m_shared.m_attachOverride == 7
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "armor_legs",
				category = "Armor",
				tooltip = "$radial_armor_utility",
				icon = ObjectDB.instance.GetItemPrefab("ArmorIronLegs").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByArmor,
				filter = (ItemData item) => (int)item.m_shared.m_itemType == 11 || (int)item.m_shared.m_attachOverride == 11
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "armor_cape",
				category = "Armor",
				tooltip = "$radial_armor_utility",
				icon = ObjectDB.instance.GetItemPrefab("CapeDeerHide").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = SortCape,
				filter = (ItemData item) => (int)item.m_shared.m_itemType == 17 || (int)item.m_shared.m_attachOverride == 17
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "armor_utility",
				category = "Armor",
				tooltip = "$radial_armor_utility",
				icon = ObjectDB.instance.GetItemPrefab("Demister").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByArmor,
				filter = (ItemData item) => (int)item.m_shared.m_itemType == 18 || (int)item.m_shared.m_attachOverride == 18
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "armor_trinket",
				category = "Armor",
				tooltip = "$radial_armor_utility",
				icon = ObjectDB.instance.GetItemPrefab("TrinketBronzeHealth").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByAdrenaline,
				filter = (ItemData item) => (int)item.m_shared.m_itemType == 24 || (int)item.m_shared.m_attachOverride == 24
			});
		}

		private static void InitSkillsCategory()
		{
			FilteringPanel panel = new FilteringPanel("Skills");
			Skills skills2 = ((Character)Player.m_localPlayer).GetSkills();
			AddMelee(skills2, (SkillType)1);
			AddMelee(skills2, (SkillType)2);
			AddMelee(skills2, (SkillType)3);
			AddMelee(skills2, (SkillType)4);
			AddMelee(skills2, (SkillType)5);
			AddMelee(skills2, (SkillType)7);
			AddMelee(skills2, (SkillType)11);
			AddMelee(skills2, (SkillType)12);
			panel.AddFilter(new FilteringState
			{
				panel = panel,
				name = "skill_shields",
				category = "Melee",
				tooltip = "$skill_shields",
				icon = skills2.GetSkillDef((SkillType)6).m_icon,
				sort = SortShield,
				filter = (ItemData item) => (int)item.m_shared.m_skillType == 6
			});
			void AddMelee(Skills skills, SkillType skill)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				panel.AddFilter(new FilteringState
				{
					panel = panel,
					name = "skill_" + ((object)(SkillType)(ref skill)).ToString().ToLower(),
					category = "Melee",
					tooltip = "$skill_" + ((object)(SkillType)(ref skill)).ToString().ToLower(),
					icon = skills.GetSkillDef(skill).m_icon,
					sort = ByTotalDamage,
					filter = (ItemData item) => item.m_shared.m_skillType == skill && item.m_shared.m_attack.m_attackAnimation != "" && ((DamageTypes)(ref item.m_shared.m_damages)).GetTotalDamage() > 0f
				});
			}
		}

		private static void InitBowsCategory()
		{
			FilteringPanel filteringPanel = new FilteringPanel("Bows");
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "skill_bows",
				category = "Bows",
				tooltip = "$skill_bows",
				icon = ((Character)Player.m_localPlayer).GetSkills().GetSkillDef((SkillType)8).m_icon,
				sort = ByTotalDamage,
				filter = (ItemData item) => (int)item.m_shared.m_skillType == 8 && item.m_shared.m_attack.m_attackAnimation != "" && ((DamageTypes)(ref item.m_shared.m_damages)).GetTotalDamage() > 0f
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "ammo_arrows",
				category = "Bows",
				tooltip = "$ammo_arrows",
				icon = ObjectDB.instance.GetItemPrefab("ArrowIron").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByTotalDamage,
				filter = (ItemData item) => item.m_shared.m_attack.m_attackAnimation == "" && item.m_shared.m_ammoType == "$ammo_arrows" && ((DamageTypes)(ref item.m_shared.m_damages)).GetTotalDamage() > 0f
			});
		}

		private static void InitCrossbowsCategory()
		{
			FilteringPanel filteringPanel = new FilteringPanel("Crossbows");
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "skill_crossbows",
				category = "Crossbows",
				tooltip = "$skill_crossbows",
				icon = ((Character)Player.m_localPlayer).GetSkills().GetSkillDef((SkillType)14).m_icon,
				sort = ByTotalDamage,
				filter = (ItemData item) => (int)item.m_shared.m_skillType == 14 && item.m_shared.m_attack.m_attackAnimation != "" && ((DamageTypes)(ref item.m_shared.m_damages)).GetTotalDamage() > 0f
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "ammo_arrows",
				category = "Crossbows",
				tooltip = "$ammo_bolts",
				icon = ObjectDB.instance.GetItemPrefab("BoltIron").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByTotalDamage,
				filter = (ItemData item) => item.m_shared.m_attack.m_attackAnimation == "" && item.m_shared.m_ammoType == "$ammo_bolts" && ((DamageTypes)(ref item.m_shared.m_damages)).GetTotalDamage() > 0f
			});
		}

		private static void InitMagicCategory()
		{
			FilteringPanel filteringPanel = new FilteringPanel("Magic");
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "skill_elementalmagic",
				category = "Magic",
				tooltip = "$skill_elementalmagic",
				icon = ((Character)Player.m_localPlayer).GetSkills().GetSkillDef((SkillType)9).m_icon,
				sort = ByTotalDamage,
				filter = (ItemData item) => (int)item.m_shared.m_skillType == 9 && item.m_shared.m_attack.m_attackAnimation != "" && ((DamageTypes)(ref item.m_shared.m_damages)).GetTotalDamage() > 0f
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "skill_bloodmagic",
				category = "Magic",
				tooltip = "$skill_bloodmagic",
				icon = ((Character)Player.m_localPlayer).GetSkills().GetSkillDef((SkillType)10).m_icon,
				sort = ByDefault,
				filter = (ItemData item) => (int)item.m_shared.m_skillType == 10 && item.m_shared.m_attack.m_attackAnimation != ""
			});
		}

		private static void InitToolsCategory()
		{
			FilteringPanel filteringPanel = new FilteringPanel("Tools");
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "tools_crafting",
				category = "Tools",
				tooltip = "$radial_weapons_tools",
				icon = ((Character)Player.m_localPlayer).GetSkills().GetSkillDef((SkillType)107).m_icon,
				sort = ByDefault,
				filter = (ItemData item) => (int)item.m_shared.m_itemType == 19 || item.m_shared.m_attack.m_attackAnimation == "throw_bomb" || (int)item.m_shared.m_skillType == 106 || item.m_shared.m_ammoType == "mead"
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "tools_consumables",
				category = "Tools",
				tooltip = "$radial_consumables",
				icon = ObjectDB.instance.GetItemPrefab("MeadBaseTasty").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByDefault,
				filter = (ItemData item) => ((int)item.m_shared.m_itemType == 2 && (Object)(object)item.m_shared.m_consumeStatusEffect != (Object)null) || ((int)item.m_shared.m_itemType == 1 && (Object)(object)item.m_shared.m_consumeStatusEffect != (Object)null)
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "tools_material",
				category = "Tools",
				tooltip = "$skill_crafting",
				icon = ObjectDB.instance.GetItemPrefab("Bronze").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByDefault,
				filter = (ItemData item) => ((int)item.m_shared.m_itemType == 1 && (Object)(object)item.m_shared.m_appendToolTip == (Object)null && (Object)(object)item.m_shared.m_consumeStatusEffect == (Object)null && !item.m_shared.m_name.StartsWith("$jc_")) || (int)item.m_shared.m_itemType == 23
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "skill_fishing",
				category = "Tools",
				tooltip = "$skill_fishing",
				icon = ObjectDB.instance.GetItemPrefab("FishingRod").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByDefault,
				filter = (ItemData item) => (int)item.m_shared.m_skillType == 104 || item.m_shared.m_name == "$item_helmet_fishinghat" || item.m_shared.m_ammoType == "$item_fishingbait"
			});
			filteringPanel.AddFilter(new FilteringState
			{
				panel = filteringPanel,
				name = "tools_misc",
				category = "Tools",
				tooltip = "$hud_misc",
				icon = ObjectDB.instance.GetItemPrefab("BoneFragments").GetComponent<ItemDrop>().m_itemData.GetIcon(),
				sort = ByDefault,
				filter = (ItemData item) => tempUnfitItems.Contains(item.m_shared.m_name) || (((int)item.m_shared.m_itemType == 16 || (int)item.m_shared.m_attachOverride == 16 || (int)item.m_shared.m_itemType > 25) && !item.m_shared.m_name.StartsWith("$jc_"))
			});
			if (!MyLittleUI.Jewelcrafting)
			{
				return;
			}
			FilteringState filteringState = new FilteringState
			{
				panel = filteringPanel,
				name = "tools_jewelcrafting",
				category = "Tools",
				tooltip = "$jc_jewelcrafting_skill_name"
			};
			FilteringState filteringState2 = filteringState;
			object obj = MyLittleUI.GetJewelcraftingIcon();
			if (obj == null)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("GemstoneRed");
				if (itemPrefab == null)
				{
					obj = null;
				}
				else
				{
					ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
					if (component == null)
					{
						obj = null;
					}
					else
					{
						ItemData itemData = component.m_itemData;
						obj = ((itemData != null) ? itemData.GetIcon() : null);
					}
				}
			}
			filteringState2.icon = (Sprite)obj;
			filteringState.sort = ByName;
			filteringState.filter = (ItemData item) => (int)item.m_shared.m_itemType != 18 && item.m_shared.m_name.StartsWith("$jc_");
			filteringPanel.AddFilter(filteringState);
		}

		private static int ByAdrenaline(RecipeDataPair a, RecipeDataPair b)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			int num = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_maxAdrenaline.CompareTo(((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_maxAdrenaline);
			if (num == 0)
			{
				num = ByName(a, b);
			}
			return num;
		}

		private static int SortCape(RecipeDataPair a, RecipeDataPair b)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)
			int num = ByArmor(a, b);
			if (num == 0)
			{
				num = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.GetMaxDurability().CompareTo(((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.GetMaxDurability());
			}
			if (num == 0)
			{
				num = ByName(a, b);
			}
			return num;
		}

		private static int SortShield(RecipeDataPair a, RecipeDataPair b)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			int num = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.GetBaseBlockPower().CompareTo(((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.GetBaseBlockPower());
			if (num == 0)
			{
				num = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_timedBlockBonus.CompareTo(((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_timedBlockBonus);
			}
			if (num == 0)
			{
				num = ByName(a, b);
			}
			return num;
		}

		private static int ByArmor(RecipeDataPair a, RecipeDataPair b)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			int num = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.GetArmor().CompareTo(((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.GetArmor());
			if (num == 0)
			{
				num = ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.GetMaxDurability().CompareTo(((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.GetMaxDurability());
			}
			if (num == 0)
			{
				num = ByName(a, b);
			}
			return num;
		}

		private static int ByTotalDamage(RecipeDataPair a, RecipeDataPair b)
		{
			return ((DamageTypes)(ref ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_damages)).GetTotalDamage().CompareTo(((DamageTypes)(ref ((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_damages)).GetTotalDamage());
		}

		private static int ByName(RecipeDataPair a, RecipeDataPair b)
		{
			return Localization.instance.Localize(((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_name).CompareTo(Localization.instance.Localize(((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_name));
		}

		private static int ByDefault(RecipeDataPair a, RecipeDataPair b)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			int num = ((RecipeDataPair)(ref a)).Recipe.m_listSortWeight.CompareTo(((RecipeDataPair)(ref b)).Recipe.m_listSortWeight);
			if (num == 0)
			{
				num = ((Enum)(ItemType)(ref ((RecipeDataPair)(ref b)).Recipe.m_item.m_itemData.m_shared.m_itemType)).CompareTo((object?)((RecipeDataPair)(ref a)).Recipe.m_item.m_itemData.m_shared.m_itemType);
			}
			if (num == 0)
			{
				num = ByName(a, b);
			}
			return num;
		}

		internal static void FilterRecipes(List<Recipe> recipes, bool inCraftTab, bool inUpradeTab)
		{
			tempEnabledStates.Clear();
			int height = 0;
			foreach (FilteringPanel panel in panels)
			{
				int currentPosition = 0;
				panel.enabled = false;
				panel.enabledFilters = 0;
				if (IsCraftingFilterEnabled)
				{
					foreach (FilteringState state in panel.filters)
					{
						if (inCraftTab)
						{
							state.selectable = recipes.Any((Recipe recipe) => state.IsSelectable(recipe.m_item.m_itemData));
						}
						else if (inUpradeTab)
						{
							state.selectable = recipes.Any((Recipe recipe) => state.IsSelectable(recipe.m_item.m_itemData) && recipe.m_item.m_itemData.m_shared.m_maxQuality > 1 && ((Humanoid)Player.m_localPlayer).GetInventory().GetItem(recipe.m_item.m_itemData.m_shared.m_name, -1, false) != null);
						}
						else
						{
							state.selectable = false;
						}
						state.enabled = state.enabled && state.selectable;
						state.UpdateSelectable();
						if (state.enabled)
						{
							tempEnabledStates.Add(state);
						}
						state.UpdatePosition(ref currentPosition);
						if (state.selectable)
						{
							panel.enabledFilters++;
							panel.enabled = true;
						}
					}
				}
				if (panel.enabled)
				{
					panel.UpdatePosition(ref height);
				}
				panel.UpdateVisibility();
			}
			tempUnfitItems.Clear();
			tempUnfitItems.AddRange(from rec in recipes
				where !filteringStates.Any((FilteringState fs) => fs.IsSelectable(rec.m_item.m_itemData))
				select rec.m_item.m_itemData.m_shared.m_name);
			if (tempEnabledStates.Count <= 0)
			{
				return;
			}
			recipes.RemoveAll(delegate(Recipe recipe)
			{
				bool flag = false;
				foreach (FilteringState tempEnabledState in tempEnabledStates)
				{
					if (tempEnabledState.filter(recipe.m_item.m_itemData))
					{
						flag = true;
						break;
					}
				}
				return !flag;
			});
		}

		internal static void SortRecipes()
		{
			if (tempEnabledStates.Count == 0)
			{
				return;
			}
			InventoryGui.instance.m_availableRecipes.Sort(delegate(RecipeDataPair a, RecipeDataPair b)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				foreach (FilteringState tempEnabledState in tempEnabledStates)
				{
					int num = tempEnabledState.sort(a, b);
					if (num != 0)
					{
						return num;
					}
				}
				return 0;
			});
			SortAvailableRecipes();
		}

		public static void SortAvailableRecipes()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < InventoryGui.instance.m_availableRecipes.Count; i++)
			{
				RecipeDataPair val = InventoryGui.instance.m_availableRecipes[i];
				GameObject interfaceElement = ((RecipeDataPair)(ref val)).InterfaceElement;
				Transform obj = ((interfaceElement != null) ? interfaceElement.transform : null);
				RectTransform val2 = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val2 != null)
				{
					val2.anchoredPosition = new Vector2(0f, (float)i * (0f - InventoryGui.instance.m_recipeListSpace));
				}
			}
		}

		internal static void ClearPanels()
		{
			CollectionExtensions.Do<FilteringPanel>((IEnumerable<FilteringPanel>)panels, (Action<FilteringPanel>)delegate(FilteringPanel panel)
			{
				panel.ClearPanel();
			});
		}

		public static void CheckPanels()
		{
			InitSortingPanel();
			UpdateVisibility();
		}
	}
	internal static class HoldToFuel
	{
		[HarmonyPatch(typeof(Switch), "Interact")]
		public static class Switch_Interact_HoldToRepeat
		{
			public static bool Prefix()
			{
				return worker == null;
			}

			public static void Postfix(Switch __instance, Humanoid character, bool hold, bool __runOriginal)
			{
				if (MyLittleUI.hoverSmelterHoldToAddSeveral.Value && hold && __runOriginal && __instance.m_onUse != null)
				{
					Smelter componentInParent = ((Component)__instance).GetComponentInParent<Smelter>();
					if (componentInParent != null)
					{
						worker = AddOnHold(__instance, componentInParent, character);
						((MonoBehaviour)MyLittleUI.instance).StartCoroutine(worker);
					}
				}
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <>c__DisplayClass3_0
		{
			public Switch addOreFuelSwitch;

			public Smelter smelter;
		}

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

			private object <>2__current;

			public Switch addOreFuelSwitch;

			public Smelter smelter;

			public Humanoid human;

			private <>c__DisplayClass3_0 <>8__1;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1.addOreFuelSwitch = addOreFuelSwitch;
					<>8__1.smelter = smelter;
					<>2__current = (object)new WaitForSeconds(0.4f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)<>8__1.smelter))
					{
						worker = null;
						return false;
					}
					if (!<>8__1.smelter.m_nview.IsOwner())
					{
						<>8__1.smelter.m_nview.ClaimOwnership();
						<i>5__2 = 0;
						goto IL_0123;
					}
					break;
				case 2:
					<>1__state = -1;
					goto IL_0110;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_0110:
					<i>5__2++;
					goto IL_0123;
					IL_0123:
					if (<i>5__2 < 5)
					{
						if (!<>8__1.smelter.m_nview.IsOwner())
						{
							<>2__current = wait;
							<>1__state = 2;
							return true;
						}
						goto IL_0110;
					}
					if (!Object.op_Implicit((Object)(object)<>8__1.smelter) || !<>8__1.smelter.m_nview.IsOwner())
					{
						MyLittleUI.LogInfo($"Still not the owner: {<>8__1.smelter}");
						worker = null;
						return false;
					}
					break;
				}
				if (ZInput.GetButtonPressedTimer("Use") >= 0.4f && Object.op_Implicit((Object)(object)<>8__1.smelter) && <AddOnHold>g__HaveRoomForOreFuel|3_0(ref <>8__1) && (Object)(object)((Humanoid)Player.m_localPlayer).GetHoverObject() == (Object)(object)((Component)<>8__1.addOreFuelSwitch).gameObject)
				{
					<>8__1.addOreFuelSwitch.m_onUse.Invoke(<>8__1.addOreFuelSwitch, human, (ItemData)null);
					MyLittleUI.LogInfo($"used {<>8__1.addOreFuelSwitch}");
					<>2__current = wait;
					<>1__state = 3;
					return true;
				}
				worker = null;
				return false;
			}

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

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

		private static readonly WaitForSeconds wait = new WaitForSeconds(0.1f);

		private const float delay = 0.4f;

		private static IEnumerator worker;

		[IteratorStateMachine(typeof(<AddOnHold>d__3))]
		public static IEnumerator AddOnHold(Switch addOreFuelSwitch, Smelter smelter, Humanoid human)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AddOnHold>d__3(0)
			{
				addOreFuelSwitch = addOreFuelSwitch,
				smelter = smelter,
				human = human
			};
		}

		[CompilerGenerated]
		internal static bool <AddOnHold>g__HaveRoomForOreFuel|3_0(ref <>c__DisplayClass3_0 P_0)
		{
			return ((Object)(object)P_0.addOreFuelSwitch == (Object)(object)P_0.smelter.m_addOreSwitch && P_0.smelter.GetQueueSize() < P_0.smelter.m_maxOre) || ((Object)(object)P_0.addOreFuelSwitch == (Object)(object)P_0.smelter.m_addWoodSwitch && P_0.smelter.GetFuel() < (float)P_0.smelter.m_maxFuel);
		}
	}
	internal static class InfoBlocks
	{
		[HarmonyPatch(typeof(EnvMan), "UpdateTriggers")]
		public static class EnvMan_UpdateTriggers_UpdateDayTime
		{
			private static int Fraction(float dayFraction)
			{
				return (int)(dayFraction * (float)((MyLittleUI.clockTimeType.Value == MyLittleUI.ClockTimeType.Fuzzy && fuzzyTime != null && fuzzyTime.Length != 0) ? 40 : 1000));
			}

			public static void Postfix(float oldDayFraction, float newDayFraction, Biome biome)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Invalid comparison between Unknown and I4
				if (MyLittleUI.modEnabled.Value && !((Object)(object)Player.m_localPlayer == (Object)null) && (int)biome != 0 && (Fraction(oldDayFraction) != Fraction(newDayFraction) || newDayFraction < oldDayFraction))
				{
					UpdateClock();
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "Awake")]
		public static class Hud_Awake_AddInfoBlocks
		{
			[HarmonyAfter(new string[] { "Azumatt.MinimalUI", "org.bepinex.plugins.passivepowers" })]
			public static void Postfix(Hud __instance)
			{
				if (MyLittleUI.modEnabled.Value)
				{
					if (!Object.op_Implicit((Object)(object)__instance.m_rootObject.transform.Find("MyLittleUI_Parent")))
					{
						AddInfoBlocks(__instance.m_rootObject.transform);
						InventoryPanel.AddBlock(parentObject);
					}
					UpdateVisibility();
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "OnDestroy")]
		public static class Hud_OnDestroy_Clear
		{
			public static void Postfix()
			{
				if (MyLittleUI.modEnabled.Value)
				{
					WeatherForecast.windList.Clear();
					WeatherForecast.winds.Clear();
					WeatherForecast.windsTransition.Clear();
					parentObject = null;
					clockObject = null;
					clockDayObject = null;
					clockTimeObject = null;
					dayText = null;
					timeText = null;
					forecastObject = null;
					windsObject = null;
					windTemplate = null;
					windsProgress = null;
					windsProgressRect = null;
					windsObjectRect = null;
					weatherText = null;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		public static class Player_OnSpawned_UpdateInfoBlocksVisibility
		{
			public static void Postfix()
			{
				if (MyLittleUI.modEnabled.Value)
				{
					UpdateVisibility();
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "SetMapMode")]
		public static class Minimap_SetMapMode_UpdateInfoBlocksVisibility
		{
			public static void Postfix()
			{
				if (MyLittleUI.modEnabled.Value)
				{
					UpdateInfoBlocksVisibility();
				}
			}
		}

		private const string objectRootName = "MyLittleUI_Parent";

		private const string objectClockName = "Clock";

		private const string objectClockDayName = "Day";

		private const string objectClockTimeName = "Time";

		private const string objectForecastName = "Forecast";

		private const string objectForecastWeatherText = "weather_text";

		private const string objectForecastWeatherIcon = "weather_icon";

		private const string objectWindsName = "Winds";

		private const string objectWindsTemplateName = "WindElement";

		private const string objectWindsProgressName = "WindProgress";

		public static GameObject parentObject;

		public static GameObject clockObject;

		public static GameObject clockDayObject;

		public static GameObject clockTimeObject;

		public static TMP_Text dayText;

		public static TMP_Text timeText;

		private static Image minimapBackground;

		private static Image clockBackground;

		private static Image forecastBackground;

		private static Image windsBackground;

		private static Image windsProgressBackground;

		public static GameObject forecastObject;

		public static GameObject windsObject;

		public static GameObject windTemplate;

		private static GameObject windsProgress;

		public static RectTransform windsProgressRect;

		public static RectTransform windsObjectRect;

		public static TMP_Text weatherText;

		public static Image weatherIcon;

		private static string[] fuzzyTime;

		private static void AddInfoBlocks(Transform parentTransform)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)Minimap.instance?.m_biomeNameSmall))
			{
				MyLittleUI.LogInfo("Minimap is not initialized, skipping clock init");
				return;
			}
			parentObject = new GameObject("MyLittleUI_Parent", new Type[1] { typeof(RectTransform) })
			{
				layer = MyLittleUI.layerUI
			};
			parentObject.transform.SetParent(parentTransform, false);
			RectTransform component = parentObject.GetComponent<RectTransform>();
			component.anchoredPosition = Vector2.zero;
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			clockObject = new GameObject("Clock", new Type[1] { typeof(RectTransform) })
			{
				layer = MyLittleUI.layerUI
			};
			clockObject.transform.SetParent(parentObject.transform, false);
			UpdateDayTimeBackground();
			clockDayObject = Object.Instantiate<GameObject>(((Component)Minimap.instance.m_biomeNameSmall).gameObject, clockObject.transform);
			((Object)clockDayObject).name = "Day";
			dayText = clockDayObject.GetComponent<TMP_Text>();
			dayText.text = "Day 0";
			dayText.textWrappingMode = (TextWrappingModes)0;
			dayText.verticalAlignment = (VerticalAlignmentOptions)512;
			clockTimeObject = Object.Instantiate<GameObject>(((Component)Minimap.instance.m_biomeNameSmall).gameObject, clockObject.transform);
			((Object)clockTimeObject).name = "Time";
			timeText = clockTimeObject.GetComponent<TMP_Text>();
			timeText.text = "Time";
			timeText.textWrappingMode = (TextWrappingModes)0;
			timeText.verticalAlignment = (VerticalAlignmentOptions)512;
			forecastObject = new GameObject("Forecast", new Type[1] { typeof(RectTransform) })
			{
				layer = MyLittleUI.layerUI
			};
			forecastObject.transform.SetParent(parentObject.transform, false);
			UpdateForecastBackground();
			weatherText = Object.Instantiate<GameObject>(((Component)Minimap.instance.m_biomeNameSmall).gameObject, forecastObject.transform).GetComponent<TMP_Text>();
			weatherText.text = "0:00";
			weatherText.textWrappingMode = (TextWrappingModes)0;
			weatherText.verticalAlignment = (VerticalAlignmentOptions)512;
			weatherText.horizontalAlignment = (HorizontalAlignmentOptions)1;
			((Object)((Component)weatherText).gameObject).name = "weather_text";
			weatherIcon = Object.Instantiate<GameObject>(((Component)Minimap.instance.m_windMarker).gameObject, forecastObject.transform).GetComponent<Image>();
			((Object)((Component)weatherIcon).gameObject).name = "weather_icon";
			windsObject = new GameObject("Winds", new Type[1] { typeof(RectTransform) })
			{
				layer = MyLittleUI.layerUI
			};
			windsObject.transform.SetParent(parentObject.transform, false);
			windsObjectRect = windsObject.GetComponent<RectTransform>();
			windTemplate = Object.Instantiate<GameObject>(((Component)Minimap.instance.m_windMarker).gameObject, parentObject.transform);
			((Object)windTemplate).name = "WindElement";
			UpdateWindsBackground();
			UpdateWindsBlock();
			MyLittleUI.LogInfo("Info blocks added to hud");
		}

		internal static void UpdateForecastBackground()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)forecastObject))
			{
				return;
			}
			if ((Object)(object)minimapBackground == (Object)null)
			{
				Minimap instance = Minimap.instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					GameObject smallRoot = instance.m_smallRoot;
					obj = ((smallRoot != null) ? smallRoot.GetComponent<Image>() : null);
				}
				minimapBackground = (Image)obj;
			}
			if ((Object)(object)forecastBackground == (Object)null)
			{
				forecastBackground = forecastObject.AddComponent<Image>();
			}
			((Behaviour)forecastBackground).enabled = (Object)(object)minimapBackground != (Object)null && MyLittleUI.forecastShowBackground.Value;
			if (((Behaviour)forecastBackground).enabled)
			{
				((Graphic)forecastBackground).color = GetBackgroundColor(MyLittleUI.forecastBackgroundColor.Value);
				forecastBackground.sprite = minimapBackground.sprite;
				forecastBackground.type = minimapBackground.type;
			}
		}

		internal static void UpdateForecastBlock()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)forecastObject))
			{
				forecastObject.SetActive(MyLittleUI.forecastEnabled.Value);
				((Graphic)weatherText).color = ((MyLittleUI.forecastFontColor.Value == Color.clear) ? ((Graphic)((Component)Minimap.instance.m_biomeNameSmall).GetComponent<TMP_Text>()).color : MyLittleUI.forecastFontColor.Value);
				weatherText.fontSizeMin = ((MyLittleUI.forecastFontSize.Value == 0f) ? ((Component)Minimap.instance.m_biomeNameSmall).GetComponent<TMP_Text>().fontSizeMin : MyLittleUI.forecastFontSize.Value);
				weatherText.fontSize = ((MyLittleUI.forecastFontSize.Value == 0f) ? weatherText.fontSizeMin : MyLittleUI.forecastFontSize.Value);
				RectTransform component = forecastObject.GetComponent<RectTransform>();
				component.SetAnchor(MyLittleUI.forecastPositionAnchor.Value);
				component.anchoredPosition = (Game.m_noMap ? MyLittleUI.forecastPositionNomap.Value : MyLittleUI.forecastPosition.Value);
				component.sizeDelta = MyLittleUI.forecastSize.Value;
				float y = MyLittleUI.forecastSize.Value.y;
				RectTransform component2 = ((Component)weatherText).GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0f, 0.5f);
				component2.anchorMax = new Vector2(0f, 0.5f);
				component2.anchoredPosition = new Vector2(y + MyLittleUI.forecastTextPadding.Value, 1f);
				component2.sizeDelta = Vector2.zero;
				RectTransform component3 = ((Component)weatherIcon).GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(0f, 0.5f);
				component3.anchorMax = new Vector2(0f, 0.5f);
				component3.sizeDelta = Vector2.one * y;
				component3.anchoredPosition = new Vector2(y / 2f, 0f);
			}
		}

		internal static void UpdateWindsBackground()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)windsObject))
			{
				return;
			}
			if ((Object)(object)minimapBackground == (Object)null)
			{
				Minimap instance = Minimap.instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					GameObject smallRoot = instance.m_smallRoot;
					obj = ((smallRoot != null) ? smallRoot.GetComponent<Image>() : null);
				}
				minimapBackground = (Image)obj;
			}
			if ((Object)(object)windsBackground == (Object)null)
			{
				windsBackground = windsObject.AddComponent<Image>();
			}
			((Behaviour)windsBackground).enabled = (Object)(object)minimapBackground != (Object)null && MyLittleUI.windsShowBackground.Value;
			if (((Behaviour)windsBackground).enabled)
			{
				((Graphic)windsBackground).color = GetBackgroundColor(MyLittleUI.windsBackgroundColor.Value);
				windsBackground.sprite = minimapBackground.sprite;
				windsBackground.type = minimapBackground.type;
			}
			if ((Object)(object)windsProgressBackground == (Object)null)
			{
				windsProgress = new GameObject("WindProgress", new Type[1] { typeof(RectTransform) })
				{
					layer = MyLittleUI.layerUI
				};
				windsProgress.transform.SetParent(windsObject.transform, false);
				windsProgressRect = windsProgress.GetComponent<RectTransform>();
				windsProgressRect.anchoredPosition = Vector2.zero;
				windsProgressRect.anchorMin = Vector2.zero;
				windsProgressRect.anchorMax = Vector2.one;
				windsProgressRect.sizeDelta = Vector2.zero;
				windsProgressBackground = windsProgress.AddComponent<Image>();
			}
			((Behaviour)windsProgressBackground).enabled = (Object)(object)minimapBackground != (Object)null && MyLittleUI.windsShowProgress.Value;
			if (((Behaviour)windsProgressBackground).enabled)
			{
				((Graphic)windsProgressBackground).color = GetBackgroundColor(MyLittleUI.windsProgressColor.Value);
				windsProgressBackground.sprite = minimapBackground.sprite;
				windsProgressBackground.type = minimapBackground.type;
			}
		}

		private static Color GetBackgroundColor(Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (color == Color.clear)
			{
				return ((Graphic)minimapBackground).color;
			}
			if (color.a != 0f && color.r == 0f && color.g == 0f && color.b == 0f)
			{
				return new Color(((Graphic)minimapBackground).color.r, ((Graphic)minimapBackground).color.g, ((Graphic)minimapBackground).color.b, color.a);
			}
			return color;
		}

		internal static void UpdateWindsBlock(bool forceRebuildList = false)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)windsObject))
			{
				windsObject.SetActive(MyLittleUI.windsEnabled.Value);
				windTemplate.SetActive(false);
				windsObjectRect.SetAnchor(MyLittleUI.ElementAnchor.TopRight);
				windsObjectRect.anchoredPosition = GetWindsPosition();
				windsObjectRect.sizeDelta = GetWindsSize();
				RectTransform component = windTemplate.GetComponent<RectTransform>();
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.zero;
				Image component2 = windTemplate.GetComponent<Image>();
				if (((Graphic)component2).color != MyLittleUI.windsArrowColor.Value)
				{
					((Graphic)component2).color = MyLittleUI.windsArrowColor.Value;
					forceRebuildList = true;
				}
				if (forceRebuildList)
				{
					WeatherForecast.UpdateNextWinds(forceRebuildList);
				}
			}
		}

		internal static Vector2 GetWindsSize()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return Game.m_noMap ? MyLittleUI.windsSizeNomap.Value : MyLittleUI.windsSize.Value;
		}

		private static Vector2 GetWindsPosition()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return Game.m_noMap ? MyLittleUI.windsPositionNomap.Value : MyLittleUI.windsPosition.Value;
		}

		internal static void UpdateDayTimeBackground()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)clockObject))
			{
				return;
			}
			if ((Object)(object)minimapBackground == (Object)null)
			{
				Minimap instance = Minimap.instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					GameObject smallRoot = instance.m_smallRoot;
					obj = ((smallRoot != null) ? smallRoot.GetComponent<Image>() : null);
				}
				minimapBackground = (Image)obj;
			}
			if ((Object)(object)clockBackground == (Object)null)
			{
				clockBackground = clockObject.AddComponent<Image>();
			}
			((Behaviour)clockBackground).enabled = (Object)(object)minimapBackground != (Object)null && MyLittleUI.clockShowBackground.Value;
			if (((Behaviour)clockBackground).enabled)
			{
				((Graphic)clockBackground).color = GetBackgroundColor(MyLittleUI.clockBackgroundColor.Value);
				clockBackground.sprite = minimapBackground.sprite;
				clockBackground.type = minimapBackground.type;
			}
		}

		internal static void UpdateDayTimeText()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)clockObject))
			{
				clockObject.SetActive(MyLittleUI.clockShowTime.Value || MyLittleUI.clockShowDay.Value);
				clockTimeObject.SetActive(MyLittleUI.clockShowTime.Value);
				clockDayObject.SetActive(MyLittleUI.clockShowDay.Value);
				timeText.horizontalAlignment = (HorizontalAlignmentOptions)((!MyLittleUI.clockShowDay.Value) ? 2 : (MyLittleUI.clockSwapDayTime.Value ? 1 : 4));
				((Graphic)timeText).color = ((MyLittleUI.clockFontColor.Value == Color.clear) ? ((Graphic)((Component)Minimap.instance.m_biomeNameSmall).GetComponent<TMP_Text>()).color : MyLittleUI.clockFontColor.Value);
				timeText.fontSizeMin = ((MyLittleUI.clockFontSize.Value == 0f) ? ((Component)Minimap.instance.m_biomeNameSmall).GetComponent<TMP_Text>().fontSizeMin : MyLittleUI.clockFontSize.Value);
				timeText.fontSize = ((MyLittleUI.clockFontSize.Value == 0f) ? timeText.fontSizeMin : MyLittleUI.clockFontSize.Value);
				dayText.horizontalAlignment = (HorizontalAlignmentOptions)((!MyLittleUI.clockShowTime.Value) ? 2 : ((!MyLittleUI.clockSwapDayTime.Value) ? 1 : 4));
				((Graphic)dayText).color = ((MyLittleUI.clockFontColor.Value == Color.clear) ? ((Graphic)timeText).color : MyLittleUI.clockFontColor.Value);
				dayText.fontSizeMin = ((MyLittleUI.clockFontSize.Value == 0f) ? timeText.fontSizeMin : MyLittleUI.clockFontSize.Value);
				dayText.fontSize = ((MyLittleUI.clockFontSize.Value == 0f) ? dayText.fontSizeMin : MyLittleUI.clockFontSize.Value);
				RectTransform component = clockObject.GetComponent<RectTransform>();
				component.SetAnchor(MyLittleUI.clockPositionAnchor.Value);
				component.anchoredPosition = MyLittleUI.clockPosition.Value;
				component.sizeDelta = MyLittleUI.clockSize.Value;
				RectTransform component2 = clockDayObject.GetComponent<RectTransform>();
				component2.anchorMin = Vector2.zero;
				component2.anchorMax = Vector2.one;
				component2.anchoredPosition = new Vector2((float)((!MyLittleUI.clockSwapDayTime.Value) ? 1 : (-1)) * ((MyLittleUI.clockShowDay.Value && MyLittleUI.clockShowTime.Value) ? MyLittleUI.clockTextPadding.Value : 0f), 1f);
				component2.sizeDelta = Vector2.zero;
				RectTransform component3 = clockTimeObject.GetComponent<RectTransform>();
				component3.anchorMin = Vector2.zero;
				component3.anchorMax = Vector2.one;
				component3.anchoredPosition = new Vector2((float)(MyLittleUI.clockSwapDayTime.Value ? 1 : (-1)) * ((MyLittleUI.clockShowDay.Value && MyLittleUI.clockShowTime.Value) ? MyLittleUI.clockTextPadding.Value : 0f), 1f);
				component3.sizeDelta = Vector2.zero;
			}
		}

		internal static void UpdateInfoBlocksVisibility()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			GameObject obj = parentObject;
			if (obj != null)
			{
				obj.SetActive(MyLittleUI.modEnabled.Value && Object.op_Implicit((Object)(object)Minimap.instance) && (Game.m_noMap ? ((int)Minimap.instance.m_mode != 2) : ((int)Minimap.instance.m_mode == 1)));
			}
		}

		internal static void UpdateVisibility()
		{
			UpdateInfoBlocksVisibility();
			UpdateDayTimeText();
			UpdateClock();
			UpdateForecastBlock();
			UpdateWindsBlock();
			WeatherForecast.UpdateWeather();
			WeatherForecast.UpdateNextWinds();
		}

		internal static void UpdateClock()
		{
			if (Object.op_Implicit((Object)(object)EnvMan.instance) && Object.op_Implicit((Object)(object)clockObject) && clockObject.activeSelf)
			{
				TMP_Text obj = dayText;
				if (obj != null)
				{
					obj.SetText(Localization.instance.Localize("$msg_newday", new string[1] { EnvMan.instance.GetCurrentDay().ToString() }));
				}
				TMP_Text obj2 = timeText;
				if (obj2 != null)
				{
					obj2.SetText(GetTimeString());
				}
				UpdateDayTimeBackground();
			}
		}

		internal static void FuzzyWordsOnChange()
		{
			fuzzyTime = null;
			UpdateClock();
		}

		internal static string GetRealTime()
		{
			return DateTime.Now.ToString(MyLittleUI.clockTimeFormat24h.Value ? "HH:mm" : "hh:mm tt");
		}

		internal static string GetGameTime()
		{
			float smoothDayFraction = EnvMan.instance.m_smoothDayFraction;
			int num = Mathf.CeilToInt(smoothDayFraction * 24f);
			int num2 = 5 * (Mathf.CeilToInt((smoothDayFraction * 24f - (float)num) * 60f) / 5);
			return DateTime.MinValue.AddMonths(2).AddDays(EnvMan.instance.GetCurrentDay()).AddHours(num)
				.AddMinutes(num2)
				.ToString(MyLittleUI.clockTimeFormat24h.Value ? "HH:mm" : "hh:mm tt");
		}

		internal static string GetTimeString()
		{
			if (MyLittleUI.clockTimeType.Value == MyLittleUI.ClockTimeType.Fuzzy)
			{
				if (fuzzyTime == null)
				{
					fuzzyTime = (from str in MyLittleUI.clockFuzzy.Value.Split(',')
						select str.Trim()).ToArray();
				}
				if (fuzzyTime.Length != 0)
				{
					float num = EnvMan.instance.m_smoothDayFraction + (float)(1 / (fuzzyTime.Length * 2));
					return (num >= 1f) ? fuzzyTime[0] : fuzzyTime[Mathf.Clamp((int)(num * (float)fuzzyTime.Length), 0, fuzzyTime.Length - 1)];
				}
			}
			else
			{
				if (MyLittleUI.clockTimeType.Value == MyLittleUI.ClockTimeType.RealTime)
				{
					return GetRealTime();
				}
				if (MyLittleUI.clockTimeType.Value == MyLittleUI.ClockTimeType.GameTime)
				{
					return GetGameTime();
				}
			}
			return string.Format(MyLittleUI.clockFormatGameAndRealTime.Value, GetGameTime(), GetRealTime());
		}
	}
	internal static class InventoryCharacterStats
	{
		[HarmonyPatch(typeof(InventoryGui), "UpdateCharacterStats")]
		private class InventoryGui_UpdateCharacterStats_CharacterStats
		{
			private static void Postfix(InventoryGui __instance, Player player, TextsDialog ___m_textsDialog)
			{
				if (!MyLittleUI.modEnabled.Value || (!MyLittleUI.statsCharacterArmor.Value && !MyLittleUI.statsCharacterEffects.Value))
				{
					return;
				}
				if ((MyLittleUI.statsCharacterArmor.Value && (Object)(object)characterStatsTooltip == (Object)null) || (MyLittleUI.statsCharacterEffects.Value && (Object)(object)characterEffectsTooltip == (Object)null))
				{
					InitCharacterTooltips(__instance, player);
				}
				if (ZNet.instance.GetTimeSeconds() - totalSecondTooltipWasUpdated > 3.0)
				{
					totalSecondTooltipWasUpdated = ZNet.instance.GetTimeSeconds();
					if (MyLittleUI.statsCharacterArmor.Value)
					{
						characterStatsTooltip.m_text = TooltipStats(player);
					}
					if (MyLittleUI.statsCharacterEffects.Value)
					{
						characterEffectsTooltip.m_text = TooltipEffects(player, ___m_textsDialog);
					}
				}
			}
		}

		[HarmonyPatch]
		public static class Humanoid_TooltipUpdate
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

				[DebuggerHidden]
				public <TargetMethods>d__0(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Humanoid), "EquipItem", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Humanoid), "UnequipItem", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						return false;
					}
				}

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

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

				[DebuggerHidden]
				IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<MethodBase>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<TargetMethods>d__0))]
			private static IEnumerable<MethodBase> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__0(-2);
			}

			private static void Postfix(Humanoid __instance)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
				{
					totalSecondTooltipWasUpdated = 0.0;
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "RemoveAllStatusEffects")]
		private class SEMan_RemoveAllStatusEffects_TooltipUpdate
		{
			private static void Postfix(SEMan __instance)
			{
				if (MyLittleUI.modEnabled.Value && (MyLittleUI.statsCharacterArmor.Value || MyLittleUI.statsCharacterEffects.Value))
				{
					Player localPlayer = Player.m_localPlayer;
					if (__instance == ((localPlayer != null) ? ((Character)localPlayer).GetSEMan() : null))
					{
						totalSecondTooltipWasUpdated = 0.0;
					}
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new Type[]
		{
			typeof(StatusEffect),
			typeof(bool),
			typeof(int),
			typeof(float)
		})]
		private class SEMan_AddStatusEffect_TooltipUpdate
		{
			private static void Postfix(SEMan __instance, StatusEffect __result)
			{
				if (MyLittleUI.modEnabled.Value && (MyLittleUI.statsCharacterArmor.Value || MyLittleUI.statsCharacterEffects.Value) && (Object)(object)__result != (Object)null)
				{
					Player localPlayer = Player.m_localPlayer;
					if (__instance == ((localPlayer != null) ? ((Character)localPlayer).GetSEMan() : null))
					{
						totalSecondTooltipWasUpdated = 0.0;
					}
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "RemoveStatusEffect", new Type[]
		{
			typeof(int),
			typeof(bool)
		})]
		private class SEMan_RemoveStatusEffect_TooltipUpdate
		{
			private static void Postfix(SEMan __instance, bool __result)
			{
				if (MyLittleUI.modEnabled.Value && (MyLittleUI.statsCharacterArmor.Value || MyLittleUI.statsCharacterEffects.Value) && __result)
				{
					Player localPlayer = Player.m_localPlayer;
					if (__instance == ((localPlayer != null) ? ((Character)localPlayer).GetSEMan() : null))
					{
						totalSecondTooltipWasUpdated = 0.0;
					}
				}
			}
		}

		private static UITooltip characterStatsTooltip;

		private static UITooltip characterEffectsTooltip;

		private static double totalSecondTooltipWasUpdated = 0.0;

		private static readonly StringBuilder sb = new StringBuilder();

		private static readonly Dictionary<SkillType, float> skills = new Dictionary<SkillType, float>();

		private static readonly Dictionary<DamageType, DamageModifier> mods = new Dictionary<DamageType, DamageModifier>();

		private static SE_Stats stats;

		private static GameObject effectsTooltip;

		private static void ClearStats(this SE_Stats statsEffect)
		{
			foreach (FieldInfo declaredField in AccessTools.GetDeclaredFields(typeof(SE_Stats)))
			{
				declaredField.SetValue(statsEffect, null);
			}
			statsEffect.m_mods = new List<DamageModPair>();
			statsEffect.m_healthOverTimeInterval = 5f;
			statsEffect.m_healthRegenMultiplier = 1f;
			statsEffect.m_staminaRegenMultiplier = 1f;
			statsEffect.m_eitrRegenMultiplier = 1f;
			statsEffect.m_damageModifier = 1f;
		}

		public static void UpdateTooltipState()
		{
			if ((Object)(object)characterStatsTooltip != (Object)null)
			{
				((Behaviour)characterStatsTooltip).enabled = MyLittleUI.statsCharacterArmor.Value;
			}
			if ((Object)(object)characterEffectsTooltip != (Object)null)
			{
				((Behaviour)characterEffectsTooltip).enabled = MyLittleUI.statsCharacterEffects.Value;
			}
		}

		private static void InitEffectsTooltipPrefab(UITooltip prefabTooltip)
		{
			effectsTooltip = Object.Instantiate<GameObject>(prefabTooltip.m_tooltipPrefab);
			((Object)effectsTooltip).name = "InventoryCharacterEffectsTooltip";
			CollectionExtensions.Do<RectTransform>((IEnumerable<RectTransform>)effectsTooltip.GetComponentsInChildren<RectTransform>(true), (Action<RectTransform>)delegate(RectTransform rt)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				rt.sizeDelta += new Vector2(150f, 0f);
			});
		}

		private static void InitCharacterTooltips(InventoryGui __instance, Player player)
		{
			UITooltip component = __instance.m_containerGrid.m_elementPrefab.GetComponent<UITooltip>();
			if ((Object)(object)effectsTooltip == (Object)null)
			{
				InitEffectsTooltipPrefab(component);
			}
			if ((Object)(object)characterStatsTooltip == (Object)null)
			{
				characterStatsTooltip = InitTooltip(component, component.m_tooltipPrefab, __instance.m_armor, player.GetPlayerName(), __instance.m_containerGrid.m_tooltipAnchor);
			}
			if ((Object)(object)characterEffectsTooltip == (Object)null)
			{
				characterEffectsTooltip = InitTooltip(component, effectsTooltip, __instance.m_weight, "$inventory_activeeffects", __instance.m_containerGrid.m_tooltipAnchor);
			}
			MyLittleUI.LogInfo("Character inventory stats patched");
		}

		private static UITooltip InitTooltip(UITooltip uiTooltip, GameObject tooltipPrefab, TMP_Text text, string topic, RectTransform tooltipAnchor)
		{
			FieldInfo[] fields = ((object)uiTooltip).GetType().GetFields();
			UITooltip val = ((Component)text.transform.parent).gameObject.AddComponent<UITooltip>();
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				fieldInfo.SetValue(val, fieldInfo.GetValue(uiTooltip));
			}
			val.m_topic = topic;
			val.m_anchor = tooltipAnchor;
			val.m_gamepadFocusObject = null;
			val.m_tooltipPrefab = tooltipPrefab;
			return val;
		}

		private static void AddRegenStat(ref float stat, float multiplier)
		{
			if (multiplier > 1f)
			{
				stat += multiplier - 1f;
			}
			else
			{
				stat *= multiplier;
			}
		}

		private static bool ShouldOverride(DamageModifier a, DamageModifier b)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Invalid comparison between Unknown and I4
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Invalid comparison between Unknown and I4
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Invalid comparison between Unknown and I4
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Invalid comparison between Unknown and I4
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Invalid comparison between Unknown and I4
			if ((int)a == 4)
			{
				return false;
			}
			if ((int)b == 3)
			{
				return true;
			}
			if ((int)a == 5 && (int)b == 1)
			{
				return false;
			}
			if ((int)a == 6 && (int)b == 2)
			{
				return false;
			}
			if (((int)a == 5 || (int)a == 1) && (int)b == 7)
			{
				return false;
			}
			if (((int)a == 6 || (int)a == 2) && (int)b == 8)
			{
				return false;
			}
			if (((int)a == 1 || (int)a == 5 || (int)a == 7 || (int)a == 3) && ((int)b == 2 || (int)b == 6 || (int)b == 8))
			{
				return false;
			}
			return true;
		}

		private static string TooltipModifierColored(string tooltip, float value, bool flat)
		{
			string arg = ((value >= 0f) ? "#00FF00" : "#FF0000");
			return flat ? $"{tooltip}: <color={arg}>{value}</color>\n" : $"{tooltip}: <color={arg}>{value:P0}</color>\n";
		}

		private static string TooltipEffects(Player player, TextsDialog textsDialog)
		{
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0636: Unknown result type (might be due to invalid IL or missing references)
			//IL_063b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_0649: Unknown result type (might be due to invalid IL or missing references)
			//IL_064e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0712: Unknown result type (might be due to invalid IL or missing references)
			//IL_0717: Unknown result type (might be due to invalid IL or missing references)
			sb.Clear();
			for (int i = 0; i < player.m_equipmentModifierValues.Length; i++)
			{
				if (player.m_equipmentModifierValues[i] != 0f)
				{
					sb.Append(TooltipModifierColored(Player.s_equipmentModifierTooltips[i], player.m_equipmentModifierValues[i], i >= 10));
				}
			}
			skills.Clear();
			mods.Clear();
			if ((Object)(object)stats == (Object)null)
			{
				ScriptableObject obj = ScriptableObject.CreateInstance("SE_Stats");
				stats = (SE_Stats)(object)((obj is SE_Stats) ? obj : null);
			}
			else
			{
				stats.ClearStats();
			}
			SkillType key;
			foreach (StatusEffect item in ((Character)player).GetSEMan().GetStatusEffects().ToList())
			{
				SE_Stats val = (SE_Stats)(object)((item is SE_Stats) ? item : null);
				if (val != null)
				{
					SE_Stats obj2 = stats;
					obj2.m_jumpStaminaUseModifier += val.m_jumpStaminaUseModifier;
					SE_Stats obj3 = stats;
					obj3.m_runStaminaDrainModifier += val.m_runStaminaDrainModifier;
					SE_Stats obj4 = stats;
					obj4.m_healthOverTime += val.m_healthOverTime;
					SE_Stats obj5 = stats;
					obj5.m_staminaOverTime += val.m_staminaOverTime;
					SE_Stats obj6 = stats;
					obj6.m_eitrOverTime += val.m_eitrOverTime;
					AddRegenStat(ref stats.m_healthRegenMultiplier, val.m_healthRegenMultiplier);
					AddRegenStat(ref stats.m_staminaRegenMultiplier, val.m_staminaRegenMultiplier);
					if (((Character)player).GetMaxEitr() > 0f)
					{
						AddRegenStat(ref stats.m_eitrRegenMultiplier, val.m_eitrRegenMultiplier);
					}
					SE_Stats obj7 = stats;
					obj7.m_addMaxCarryWeight += val.m_addMaxCarryWeight;
					SE_Stats obj8 = stats;
					obj8.m_noiseModifier += val.m_noiseModifier;
					SE_Stats obj9 = stats;
					obj9.m_stealthModifier += val.m_stealthModifier;
					SE_Stats obj10 = stats;
					obj10.m_speedModifier += val.m_speedModifier;
					SE_Stats obj11 = stats;
					obj11.m_maxMaxFallSpeed += val.m_maxMaxFallSpeed;
					SE_Stats obj12 = stats;
					obj12.m_fallDamageModifier += val.m_fallDamageModifier;
					SE_Stats obj13 = stats;
					obj13.m_adrenalineModifier += val.m_adrenalineModifier;
					SE_Stats obj14 = stats;
					obj14.m_staggerModifier += val.m_staggerModifier;
					SE_Stats obj15 = stats;
					obj15.m_blockStaminaUseFlatValue += val.m_blockStaminaUseFlatValue;
					SE_Stats obj16 = stats;
					obj16.m_timedBlockBonus += val.m_timedBlockBonus;
					SE_Stats obj17 = stats;
					obj17.m_swimSpeedModifier += val.m_swimSpeedModifier;
					SE_Stats obj18 = stats;
					obj18.m_addArmor += val.m_addArmor;
					SE_Stats obj19 = stats;
					obj19.m_armorMultiplier += val.m_armorMultiplier;
					if (skills.ContainsKey(val.m_skillLevel))
					{
						Dictionary<SkillType, float> dictionary = skills;
						key = val.m_skillLevel;
						dictionary[key] += val.m_skillLevelModifier;
					}
					else
					{
						skills.Add(val.m_skillLevel, val.m_skillLevelModifier);
					}
					if (skills.ContainsKey(val.m_skillLevel2))
					{
						Dictionary<SkillType, float> dictionary = skills;
						key = val.m_skillLevel2;
						dictionary[key] += val.m_skillLevelModifier2;
					}
					else
					{
						skills.Add(val.m_skillLevel2, val.m_skillLevelModifier2);
					}
					foreach (DamageModPair mod in val.m_mods)
					{
						if (mods.ContainsKey(mod.m_type))
						{
							if (ShouldOverride(mods[mod.m_type], mod.m_modifier))
							{
								mods[mod.m_type] = mod.m_modifier;
							}
						}
						else
						{
							mods[mod.m_type] = mod.m_modifier;
						}
					}
				}
				else
				{
					string text = item.GetTooltipString();
					if (!Utility.IsNullOrWhiteSpace(item.m_tooltip))
					{
						text = text.Replace(item.m_tooltip, "");
					}
					if (!Utility.IsNullOrWhiteSpace(text))
					{
						sb.Append("\n");
						sb.Append("<color=orange>" + item.m_name + "</color>");
						sb.Append(text);
					}
				}
			}
			foreach (ItemData equippedItem in ((Humanoid)player).GetInventory().GetEquippedItems())
			{
				if (equippedItem == null || equippedItem.m_shared.m_damageModifiers.Count == 0)
				{
					continue;
				}
				foreach (DamageModPair damageModifier in equippedItem.m_shared.m_damageModifiers)
				{
					if (mods.ContainsKey(damageModifier.m_type))
					{
						if (ShouldOverride(mods[damageModifier.m_type], damageModifier.m_modifier))
						{
							mods[damageModifier.m_type] = damageModifier.m_modifier;
						}
					}
					else
					{
						mods[damageModifier.m_type] = damageModifier.m_modifier;
					}
				}
			}
			foreach (KeyValuePair<DamageType, DamageModifier> mod2 in mods)
			{
				stats.m_mods.Add(new DamageModPair
				{
					m_modifier = mod2.Value,
					m_type = mod2.Key
				});
			}
			if (((Character)player).GetMaxEitr() > 0f)
			{
				SE_Stats obj20 = stats;
				obj20.m_eitrRegenMultiplier += player.GetEquipmentEitrRegenModifier();
			}
			string tooltipString = ((StatusEffect)stats).GetTooltipString();
			if (!Utility.IsNullOrWhiteSpace(tooltipString))
			{
				sb.Append("\n");
				sb.Append(tooltipString);
			}
			foreach (KeyValuePair<SkillType, float> skill in skills)
			{
				if (skill.Value != 0f)
				{
					StringBuilder stringBuilder = sb;
					key = skill.Key;
					stringBuilder.AppendFormat("\n{0} <color=orange>{1}</color>", "$skill_" + ((object)(SkillType)(ref key)).ToString().ToLower(), skill.Value.ToString("+0;-0"));
				}
			}
			return Localization.instance.Localize(sb.ToString()).Trim();
		}

		private static string TooltipStats(Player player)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Invalid comparison between Unknown and I4
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			sb.Clear();
			sb.AppendFormat("$item_armor: <color=orange>{0}</color>", ((Character)player).GetBodyArmor());
			ItemData currentWeapon = ((Humanoid)player).GetCurrentWeapon();
			if (currentWeapon != null)
			{
				DamageTypes damage = currentWeapon.GetDamage(currentWeapon.m_quality, (float)Game.m_worldLevel);
				ItemData ammoItem = ((Humanoid)player).GetAmmoItem();
				if (ammoItem != null && currentWeapon.m_shared.m_skillType == ammoItem.m_shared.m_skillType && ((int)currentWeapon.m_shared.m_skillType == 8 || (int)currentWeapon.m_shared.m_skillType == 14))
				{
					((DamageTypes)(ref damage)).Add(((Humanoid)player).GetAmmoItem().GetDamage(), 1);
				}
				sb.Append("\n");
				ItemData.AddHandedTip(currentWeapon, sb);
				sb.Append(((DamageTypes)(ref damage)).GetTooltipString(currentWeapon.m_shared.m_skillType) ?? "");
				sb.Append($"\n$item_knockback: <color=orange>{currentWeapon.m_shared.m_attackForce}</color>");
				sb.Append($"\n$item_backstab: <color=orange>{currentWeapon.m_shared.m_backstabBonus}x</color>");
			}
			ItemData currentBlocker = ((Humanoid)player).GetCurrentBlocker();
			if (currentBlocker != null)
			{
				int quality = currentBlocker.m_quality;
				sb.Append("\n");
				sb.Append($"\n$item_blockpower: <color=orange>{currentBlocker.GetBlockPowerTooltip(quality):0}</color>");
				if (currentBlocker.m_shared.m_timedBlockBonus > 1f)
				{
					sb.Append($"\n$item_blockforce: <color=orange>{currentBlocker.GetDeflectionForce(quality)}</color>");
					sb.Append($"\n$item_parrybonus: <color=orange>{currentBlocker.m_shared.m_timedBlockBonus}x</color>");
				}
				string damageModifiersTooltipString = SE_Stats.GetDamageModifiersTooltipString(currentBlocker.m_shared.m_damageModifiers);
				if (damageModifiersTooltipString.Length > 0)
				{
					sb.Append(damageModifiersTooltipString);
				}
			}
			return Localization.instance.Localize(sb.ToString()).Trim();
		}
	}
	internal static class ItemIcon
	{
		private static class DefaultQualityStyle
		{
			public static bool initialized;

			public static TextWrappingModes textWrappingMode;

			public static float fontSize;

			public static Color color;

			public static bool isRightToLeftText;

			public static float lineSpacing;

			public static float characterSpacing;

			public static void Save(TMP_Text quality)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				initialized = true;
				textWrappingMode = quality.textWrappingMode;
				fontSize = quality.fontSize;
				color = ((Graphic)quality).color;
				isRightToLeftText = quality.isRightToLeftText;
				lineSpacing = quality.lineSpacing;
				characterSpacing = quality.characterSpacing;
			}

			public static void Load(TMP_Text quality)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				quality.textWrappingMode = textWrappingMode;
				quality.fontSize = fontSize;
				((Graphic)quality).color = color;
				quality.isRightToLeftText = isRightToLeftText;
				quality.lineSpacing = lineSpacing;
				quality.characterSpacing = characterSpacing;
			}

			public static bool IsTextWasChanged(TMP_Text quality)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: 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_0021: Unknown result type (might be due to invalid IL or missing references)
				return quality.textWrappingMode != textWrappingMode || quality.fontSize != fontSize || ((Graphic)quality).color != color || quality.isRightToLeftText != isRightToLeftText || quality.lineSpacing != lineSpacing || quality.lineSpacing != characterSpacing;
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		private static class InventoryGrid_UpdateGui_DurabilityAndScale
		{
			private static readonly HashSet<ItemData> filterItemQuality = new HashSet<ItemData>();

			private static readonly HashSet<ItemData> hideItemQuality = new HashSet<ItemData>();

			private static readonly List<ItemData> azuEpiSlotsItems = new List<ItemData>();

			private static bool IsEAQSEquipmentGrid(InventoryGrid grid)
			{
				return ((Object)grid).name == "EquipmentSlotGrid";
			}

			private static bool IsEAQSQuickSlotGrid(InventoryGrid grid)
			{
				return ((Object)grid).name == "QuickSlotGrid";
			}

			private static List<ItemData> GetAzuEPIEqupmentSlotsItems()
			{
				azuEpiSlotsItems.Clear();
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return azuEpiSlotsItems;
				}
				Func<Player, ItemData>[] getItemFuncs = AzuExtendedPlayerInventory.API.GetSlots().GetItemFuncs;
				if (getItemFuncs == null)
				{
					return azuEpiSlotsItems;
				}
				foreach (Func<Player, ItemData> func in getItemFuncs)
				{
					if (func != null)
					{
						ItemData val = func(Player.m_localPlayer);
						if (val != null)
						{
							azuEpiSlotsItems.Add(val);
						}
					}
				}
				return azuEpiSlotsItems;
			}

			private static void FillItemsToFilter()
			{
				if (AzuExtendedPlayerInventory.API.IsLoaded())
				{
					List<ItemData> azuEPIEqupmentSlotsItems = GetAzuEPIEqupmentSlotsItems();
					if (MyLittleUI.itemQualityIgnoreCustomSlots.Value)
					{
						for (int i = 0; i < azuEPIEqupmentSlotsItems.Count; i++)
						{
							filterItemQuality.Add(azuEPIEqupmentSlotsItems[i]);
						}
					}
					else if (MyLittleUI.itemQualityIgnoreCustomEquipmentSlots.Value)
					{
						for (int j = 0; j < azuEPIEqupmentSlotsItems.Count; j++)
						{
							if (azuEPIEqupmentSlotsItems[j].IsEquipable())
							{
								filterItemQuality.Add(azuEPIEqupmentSlotsItems[j]);
							}
						}
					}
				}
				if (!ExtraSlotsAPI.API.IsReady())
				{
					return;
				}
				if (MyLittleUI.itemQualityIgnoreCustomSlots.Value)
				{
					foreach (ItemData allExtraSlotsItem in ExtraSlotsAPI.API.GetAllExtraSlotsItems())
					{
						filterItemQuality.Add(allExtraSlotsItem);
					}
					return;
				}
				if (!MyLittleUI.itemQualityIgnoreCustomEquipmentSlots.Value)
				{
					return;
				}
				foreach (ItemData equipmentSlotsItem in ExtraSlotsAPI.API.GetEquipmentSlotsItems())
				{
					filterItemQuality.Add(equipmentSlotsItem);
				}
			}

			private static void FillItemsToHide()
			{
				if (AzuExtendedPlayerInventory.API.IsLoaded())
				{
					List<ItemData> azuEPIEqupmentSlotsItems = GetAzuEPIEqupmentSlotsItems();
					for (int i = 0; i < azuEPIEqupmentSlotsItems.Count; i++)
					{
						hideItemQuality.Add(azuEPIEqupmentSlotsItems[i]);
					}
				}
				if (!ExtraSlotsAPI.API.IsReady())
				{
					return;
				}
				foreach (ItemData equipmentSlotsItem in ExtraSlotsAPI.API.GetEquipmentSlotsItems())
				{
					hideItemQuality.Add(equipmentSlotsItem);
				}
			}

			private static bool IgnoreItemQuality(InventoryGrid grid, ItemData item)
			{
				return filterItemQuality.Contains(item) || (MyLittleUI.itemQualityIgnoreCustomEquipmentSlots.Value && IsEAQSEquipmentGrid(grid)) || (MyLittleUI.itemQualityIgnoreCustomSlots.Value && (IsEAQSQuickSlotGrid(grid) || IsEAQSEquipmentGrid(grid)));
			}

			private static bool HideEquipmentSlotsQuality(InventoryGrid grid, ItemData item)
			{
				return IsEAQSEquipmentGrid(grid) || hideItemQuality.Contains(item);
			}

			[HarmonyPriority(0)]
			[HarmonyAfter(new string[] { "Azumatt.AzuExtendedPlayerInventory", "shudnal.ExtraSlots" })]
			private static void Postfix(InventoryGrid __instance, Inventory ___m_inventory, List<Element> ___m_elements)
			{
				if (!MyLittleUI.modEnabled.Value)
				{
					return;
				}
				filterItemQuality.Clear();
				if (MyLittleUI.itemQualityIgnoreCustomEquipmentSlots.Value || MyLittleUI.itemQualityIgnoreCustomSlots.Value)
				{
					FillItemsToFilter();
				}
				hideItemQuality.Clear();
				if (MyLittleUI.itemQualityHideCustomEquipmentSlots.Value)
				{
					FillItemsToHide();
				}
				int width = ___m_inventory.GetWidth();
				foreach (ItemData allItem in ___m_inventory.GetAllItems())
				{
					int num = allItem.m_gridPos.y * width + allItem.m_gridPos.x;
					if (0 > num || num >= ___m_elements.Count)
					{
						continue;
					}
					Element val = ___m_elements[num];
					UpdateItemIcon(val.m_durability, val.m_icon, val.m_equiped);
					if (HideEquipmentSlotsQuality(__instance, allItem) || (MyLittleUI.itemQualityHideLvl1.Value && allItem.m_quality < 2))
					{
						val.m_quality.SetText("");
					}
					else if (!IgnoreItemQuality(__instance, allItem))
					{
						UpdateItemQuality(val.m_quality, allItem.m_quality);
					}
					if (MyLittleUI.inventoryHideLongStack.Value && val.m_amount.text.Length > 7)
					{
						int num2 = val.m_amount.text.IndexOf('/');
						if (num2 > 0)
						{
							val.m_amount.text = val.m_amount.text.Substring(0, num2);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(HotkeyBar), "UpdateIcons")]
		private class HotkeyBar_UpdateIcons_DurabilityAndScale
		{
			[HarmonyPriority(0)]
			[HarmonyAfter(new string[] { "Azumatt.AzuExtendedPlayerInventory", "shudnal.ExtraSlots" })]
			private static void Postfix(HotkeyBar __instance, Player player)
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				if (!MyLittleUI.modEnabled.Value || !Object.op_Implicit((Object)(object)player) || ((Character)player).IsDead())
				{
					return;
				}
				foreach (ElementData element in __instance.m_elements)
				{
					UpdateItemIcon(element.m_durability, element.m_icon, (MyLittleUI.itemEquippedColor.Value != Color.clear) ? element.m_equiped.GetComponent<Image>() : null);
					if (MyLittleUI.inventoryHideLongStack.Value && element.m_amount.text.Length > 9)
					{
						element.m_amount.text = StringExtensionMethods.ToFastString(element.m_stackText);
					}
				}
			}
		}

		private static Vector3 itemIconScaleOriginal = Vector3.zero;

		private static Color itemEquippedColorOriginal = Color.clear;

		private static Gradient gradient;

		private static readonly Dictionary<int, string> qualityCache = new Dictionary<int, string>();

		private static void UpdateItemIcon(GuiBar durability, Image icon, Image equiped)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (itemIconScaleOriginal == Vector3.zero)
			{
				itemIconScaleOriginal = ((Component)icon).transform.localScale;
			}
			((Component)icon).transform.localScale = itemIconScaleOriginal * Mathf.Clamp(MyLittleUI.itemIconScale.Value, 0.2f, 2f);
			if ((Object)(object)equiped != (Object)null)
			{
				if (itemEquippedColorOriginal == Color.clear)
				{
					itemEquippedColorOriginal = ((Graphic)equiped).color;
				}
				if (MyLittleUI.itemEquippedColor.Value != Color.clear)
				{
					((Graphic)equiped).color = MyLittleUI.itemEquippedColor.Value;
				}
				else if (itemEquippedColorOriginal != Color.clear)
				{
					((Graphic)equiped).color = itemEquippedColorOriginal;
				}
			}
			if (!MyLittleUI.durabilityEnabled.Value || !((Object)(object)durability != (Object)null))
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)durability.m_barImage) && Object.op_Implicit((Object)(object)durability.m_bar))
			{
				durability.m_barImage = ((Component)durability.m_bar).GetComponent<Image>();
			}
			UpdateGradient(force: false);
			if (durability.GetSmoothValue() >= 1f)
			{
				if (durability.GetColor() == Color.red)
				{
					durability.SetColor(MyLittleUI.durabilityBroken.Value);
				}
				else if (durability.GetColor() != Color.clear)
				{
					((Component)durability).gameObject.SetActive(false);
				}
			}
			else
			{
				durability.SetColor(gradient.Evaluate(durability.GetSmoothValue()));
			}
		}

		public static void UpdateGradient(bool force = true)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if (gradient == null || force)
			{
				gradient = new Gradient();
				gradient.SetKeys((GradientColorKey[])(object)new GradientColorKey[4]
				{
					new GradientColorKey(MyLittleUI.durabilityBroken.Value, 0f),
					new GradientColorKey(MyLittleUI.durabilityAtRisk.Value, 0.33f),
					new GradientColorKey(MyLittleUI.durabilityWorn.Value, 0.66f),
					new GradientColorKey(MyLittleUI.durabilityFine.Value, 1f)
				}, Array.Empty<GradientAlphaKey>());
			}
		}

		private static char GetQualitySymbol()
		{
			return Utility.IsNullOrWhiteSpace(MyLittleUI.itemQualitySymbol.Value) ? '★' : MyLittleUI.itemQualitySymbol.Value[0];
		}

		public static void FillItemQualityCache()
		{
			StringBuilder stringBuilder = new StringBuilder();
			qualityCache.Clear();
			int num = Math.Min(MyLittleUI.itemQualityMax.Value, MyLittleUI.itemQualityColumns.Value * MyLittleUI.itemQualityRows.Value);
			for (int i = 1; i <= num; i++)
			{
				stringBuilder.Append(GetQualitySymbol());
				qualityCache.Add(i, stringBuilder.ToString());
				if (i % MyLittleUI.itemQualityColumns.Value == 0)
				{
					stringBuilder.Append("\n");
				}
			}
		}

		private static void UpdateItemQuality(TMP_Text quality, int m_quality)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (!MyLittleUI.itemQuality.Value || !((Behaviour)quality).enabled)
			{
				return;
			}
			if (!DefaultQualityStyle.initialized)
			{
				DefaultQualityStyle.Save(quality);
			}
			if (!qualityCache.ContainsKey(m_quality))
			{
				if (DefaultQualityStyle.IsTextWasChanged(quality))
				{
					DefaultQualityStyle.Load(quality);
				}
				return;
			}
			quality.text = qualityCache[m_quality];
			quality.textWrappingMode = (TextWrappingModes)3;
			quality.fontSize = MyLittleUI.itemQualitySymbolSize.Value;
			((Graphic)quality).color = MyLittleUI.itemQualitySymbolColor.Value;
			quality.isRightToLeftText = true;
			quality.lineSpacing = MyLittleUI.itemQualityLineSpacing.Value;
			quality.characterSpacing = MyLittleUI.itemQualityCharacterSpacing.Value;
		}
	}
	public static class ItemTooltip
	{
		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		private class InventoryGui_Awake_ItemTooltipCraftingFontSize
		{
			private static void Postfix()
			{
				UpdateRecipeDescriptionFontSize();
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
		{
			typeof(ItemData),
			typeof(int),
			typeof(bool),
			typeof(float),
			typeof(int)
		})]
		private class ItemDropItemData_GetTooltip_ItemTooltip
		{
			[HarmonyPriority(800)]
			private static void Postfix(ItemData item, int qualityLevel, bool crafting, float worldLevel, ref string __result)
			{
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				if (!MyLittleUI.modEnabled.Value || !MyLittleUI.itemTooltip.Value || UnityInput.Current.GetKey((KeyCode)308) || UnityInput.Current.GetKey((KeyCode)307))
				{
					return;
				}
				if (tooltipCache.Count > 200)
				{
					tooltipCache.Clear();
				}
				int stableHashCode = StringExtensionMethods.GetStableHashCode(__result);
				if (tooltipCache.ContainsKey(stableHashCode))
				{
					__result = tooltipCache[stableHashCode];
				}
				else
				{
					if (item == null)
					{
						return;
					}
					int num = __result.IndexOf("\n\n", StringComparison.InvariantCulture);
					if (num == -1)
					{
						return;
					}
					sb.Clear();
					string text = __result.Substring(0, num + 2);
					__result = __result.Substring(text.Length);
					sb.Append(text);
					int num2 = -1;
					string statusEffectTooltip = item.GetStatusEffectTooltip(qualityLevel, ((Character)Player.m_localPlayer).GetSkillLevel(item.m_shared.m_skillType));
					if (!string.IsNullOrEmpty(statusEffectTooltip))
					{
						tails.Insert(0, "\n\n" + statusEffectTooltip.Substring(0, statusEffectTooltip.IndexOf("</color>\n", StringComparison.OrdinalIgnoreCase)));
					}
					foreach (string tail in tails)
					{
						num2 = __result.IndexOf(tail, StringComparison.InvariantCulture);
						if (num2 != -1)
						{
							break;
						}
					}
					if (!string.IsNullOrEmpty(statusEffectTooltip))
					{
						tails.RemoveAt(0);
					}
					string value = "";
					if (num2 != -1)
					{
						value = __result.Substring(num2);
						__result = __result.Substring(0, num2);
					}
					tokenPositions.Clear();
					arrResult.Clear();
					arrResult.AddRange(__result.Split(new char[1] { '\n' }, StringSplitOptions.None));
					int i;
					for (i = 0; i < arrResult.Count; i++)
					{
						if (arrResult[i] == "\n")
						{
							continue;
						}
						List<KeyValuePair<string, string>> list = localizedTooltipTokens.Where((KeyValuePair<string, string> kvp) => arrResult[i].IndexOf(kvp.Key) > -1).ToList();
						if (list.Count() > 0)
						{
							if (tokenPositions.ContainsKey(list[0].Value))
							{
								tokenPositions[list[0].Value].Add(i);
								continue;
							}
							tokenPositions.Add(list[0].Value, new List<int> { i });
						}
						else if (tokenPositions.Count > 0)
						{
							tokenPositions.Last().Value.Add(i);
						}
						else
						{
							sb.Append(arrResult[i]);
							sb.Append("\n");
							arrResult.RemoveAt(i);
							i--;
						}
					}
					ReorderTooltip(item, qualityLevel, worldLevel, crafting && 1 < qualityLevel && qualityLevel <= item.m_shared.m_maxQuality);
					if (num2 != -1)
					{
						sb.Append(value);
					}
					__result = sb.ToString();
					__result = __result.Replace("<color=orange>", MyLittleUI.itemTooltipColored.Value ? "<color=#ffa500ff>" : "<color=#add8e6ff>").Replace("<color=yellow>", MyLittleUI.itemTooltipColored.Value ? "<color=#ffff00ff>" : "<color=#c0c0c0ff>").Replace("<color=silver>", "<color=#c0c0c0ff>")
						.Replace("<color=lightblue>", "<color=#add8e6ff>")
						.Replace("\n\n\n", "\n\n");
					tooltipCache.Add(stableHashCode, __result);
				}
			}
		}

		private const string projectileTooltipGroup = "projectile";

		private static readonly Dictionary<string, string> localizedTooltipTokens = new Dictionary<string, string>();

		private static readonly List<string> tails = new List<string>();

		private static readonly List<string> tokens = new List<string>();

		private static readonly HashSet<string> craftingTokens = new HashSet<string>();

		private static readonly StringBuilder sb = new StringBuilder();

		private static readonly Dictionary<string, List<int>> tokenPositions = new Dictionary<string, List<int>>();

		private static readonly List<string> arrResult = new List<string>();

		private static readonly Dictionary<int, string> tooltipCache = new Dictionary<int, string>();

		private const int tooltipCachedEntriesMax = 200;

		public static void Initialize()
		{
			FillTooltipTails();
			InitTooltipTokens();
			InitializeTokenGroups();
		}

		private static void FillTooltipTails()
		{
			tails.Clear();
			if (MyLittleUI.epicLootAssembly != null)
			{
				MethodInfo methodInfo = AccessTools.Method(MyLittleUI.epicLootAssembly.GetType("EpicLoot.EpicLoot"), "GetRarityColor", (Type[])null, (Type[])null);
				Type type = MyLittleUI.epicLootAssembly.GetType("EpicLoot.ItemRarity");
				if (methodInfo != null && type != null)
				{
					foreach (object enumValue in type.GetEnumValues())
					{
						tails.Add($"<color={methodInfo.Invoke(methodInfo, new object[1] { enumValue })}>\n");
						tails.Add($"\n<color={methodInfo.Invoke(methodInfo, new object[1] { enumValue })}>");
					}
				}
			}
			tails.Add("\n\n$item_seteffect");
			tails.Add("\n$item_fulladrenaline:");
		}

		private static void InitTooltipTokens()
		{
			string[] array = new string[50]
			{
				"$item_dlc", "$item_onehanded", "$item_twohanded", "$item_crafter", "$item_noteleport", "$item_value", "$item_weight", "$item_quality", "$item_durability", "$item_repairlevel",
				"$item_food_health", "$item_food_stamina", "$item_food_eitr", "$item_food_duration", "$item_food_regen", "$item_staminause", "$item_eitruse", "$item_healthuse", "$item_staminahold", "$item_knockback",
				"$item_backstab", "$item_blockpower", "$item_blockarmor", "$item_blockforce", "$item_deflection", "$item_parrybonus", "$item_armor", "$item_movement_modifier", "$item_eitrregen_modifier", "$base_item_modifier",
				"$item_seteffect", "$inventory_dmgmod", "$inventory_damage", "$inventory_blunt", "$inventory_slash", "$inventory_pierce", "$inventory_fire", "$inventory_frost", "$inventory_lightning", "$inventory_poison",
				"$inventory_spirit", "$se_staminaregen", "$se_eitrregen", "$item_newgameplusitem", "$item_tamedonly", "$item_chancetoapplyse", "$item_damagemultipliertotal", "$item_damagemultiplierhp", "$item_parryadrenaline", "$item_fulladrenaline"
			};
			string[] array2 = array;
			foreach (string text in array2)
			{
				localizedTooltipTokens[text] = text;
			}
			craftingTokens.Clear();
			craftingTokens.Add("$item_armor");
			craftingTokens.Add("$item_weight");
			craftingTokens.Add("$item_quality");
			craftingTokens.Add("$item_durability");
			craftingTokens.Add("$item_repairlevel");
			craftingTokens.Add("$item_blockpower");
			craftingTokens.Add("$item_blockarmor");
			craftingTokens.Add("$item_blockforce");
			craftingTokens.Add("$inventory_damage");
			craftingTokens.Add("$inventory_blunt");
			craftingTokens.Add("$inventory_slash");
			craftingTokens.Add("$inventory_pierce");
			craftingTokens.Add("$inventory_fire");
			craftingTokens.Add("$inventory_frost");
			craftingTokens.Add("$inventory_lightning");
			craftingTokens.Add("$inventory_poison");
			craftingTokens.Add("$inventory_spirit");
		}

		private static void InitializeTokenGroups()
		{
			tokens.Clear();
			tokens.Add("$item_dlc");
			tokens.Add("$item_newgameplusitem");
			tokens.Add("$item_onehanded");
			tokens.Add("$item_twohanded");
			tokens.Add("$item_noteleport");
			tokens.Add("$item_value");
			tokens.Add("$item_tamedonly");
			tokens.Add("");
			tokens.Add("$item_food_health");
			tokens.Add("$item_food_stamina");
			tokens.Add("$item_food_eitr");
			tokens.Add("");
			tokens.Add("$item_food_regen");
			tokens.Add("$se_staminaregen");
			tokens.Add("$se_eitrregen");
			tokens.Add("");
			tokens.Add("$item_food_duration");
			tokens.Add("");
			tokens.Add("$inventory_damage");
			tokens.Add("$inventory_blunt");
			tokens.Add("$inventory_slash");
			tokens.Add("$inventory_pierce");
			tokens.Add("$inventory_fire");
			tokens.Add("$inventory_frost");
			tokens.Add("$inventory_lightning");
			tokens.Add("$inventory_poison");
			tokens.Add("$inventory_spirit");
			tokens.Add("$item_knockback");
			tokens.Add("$item_backstab");
			tokens.Add("$item_staminause");
			tokens.Add("$item_eitruse");
			tokens.Add("$item_healthuse");
			tokens.Add("$item_staminahold");
			tokens.Add("$item_damagemultipliertotal");
			tokens.Add("$item_damagemultiplierhp");
			tokens.Add("$item_chancetoapplyse");
			tokens.Add("");
			tokens.Add("$item_blockpower");
			tokens.Add("$item_blockarmor");
			tokens.Add("$item_blockforce");
			tokens.Add("$item_deflection");
			tokens.Add("$item_parrybonus");
			tokens.Add("$item_parryadrenaline");
			tokens.Add("projectile");
			tokens.Add("$item_armor");
			tokens.Add("$inventory_dmgmod");
			tokens.Add("");
			tokens.Add("$item_durability");
			tokens.Add("$item_repairlevel");
			tokens.Add("");
			tokens.Add("$item_movement_modifier");
			tokens.Add("$item_eitrregen_modifier");
			tokens.Add("$base_item_modifier");
			tokens.Add("");
			tokens.Add("$item_weight");
			tokens.Add("$item_crafter");
			tokens.Add("$item_quality");
		}

		private static void ReorderTooltip(ItemData item, int m_quality, float m_worldLevel, bool upgradingTooltip)
		{
			bool flag = false;
			foreach (string token in tokens)
			{
				if (token == "")
				{
					if (flag)
					{
						sb.Append('\n');
					}
					flag = false;
				}
				else if (token == "projectile")
				{
					string projectileTooltip = item.GetProjectileTooltip(m_quality);
					if (projectileTooltip.Length > 0)
					{
						flag = true;
						sb.Append("\n\n");
						sb.Append(projectileTooltip);
					}
					if (flag)
					{
						sb.Append('\n');
					}
					flag = false;
				}
				else
				{
					flag = AppendToken(token, item, m_quality, m_worldLevel, upgradingTooltip) || flag;
				}
			}
		}

		private static bool AppendToken(string token, ItemData item, int m_quality, float m_worldLevel, bool upgrading)
		{
			if (!tokenPositions.ContainsKey(token))
			{
				return false;
			}
			List<int> list = tokenPositions[token];
			for (int i = 0; i < list.Count; i++)
			{
				sb.AppendFormat("\n{0}", GetTokenString(list, i, token, item, m_quality, m_worldLevel, upgrading));
			}
			return true;
		}

		private static string DamageRange(float damage, float minFactor, float maxFactor)
		{
			int num = Mathf.RoundToInt(damage * minFactor);
			int num2 = Mathf.RoundToInt(damage * maxFactor);
			return "<color=orange>" + Mathf.RoundToInt(damage) + "</color> <color=yellow>(" + num + "-" + num2 + ") </color>";
		}

		private static string GetTokenString(List<int> tokPos, int i, string token, ItemData item, int m_quality, float m_worldLevel, bool upgrading)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (!upgrading || i > 0 || !craftingTokens.Contains(token))
			{
				return arrResult[tokPos[i]];
			}
			string text = arrResult[tokPos[i]];
			int num = text.IndexOf(": ");
			if (num == -1)
			{
				return text;
			}
			num += 2;
			if (token.StartsWith("$inventory_"))
			{
				DamageTypes damage = item.GetDamage(m_quality, m_worldLevel);
				DamageTypes damage2 = item.GetDamage(m_quality - 1, m_worldLevel);
				float minFactor = default(float);
				float maxFactor = default(float);
				((Character)Player.m_localPlayer).GetSkills().GetRandomSkillRange(ref minFactor, ref maxFactor, item.m_shared.m_skillType);
				float damageByToken = GetDamageByToken(token, damage2);
				if (damageByToken != -1f && damageByToken != GetDamageByToken(token, damage))
				{
					return text.Insert(num, GetStringUpgradeFrom(DamageRange(damageByToken, minFactor, maxFactor)));
				}
			}
			else
			{
				switch (token)
				{
				case "$item_weight":
					if (item.m_shared.m_scaleWeightByQuality != 0f)
					{
						int quality = item.m_quality;
						item.m_quality = m_quality - 1;
						string value2 = item.GetWeight(-1).ToString("0.0");
						item.m_quality = quality;
						return text.Insert(num, GetStringUpgradeFrom(value2));
					}
					break;
				case "$item_quality":
					return text.Insert(num, GetStringUpgradeFrom($"<color=orange>{m_quality - 1}</color>"));
				case "$item_durability":
					if (item.GetMaxDurability(m_quality) != item.GetMaxDurability(m_quality - 1))
					{
						return text.Insert(num, GetStringUpgradeFrom($"<color=orange>{item.GetMaxDurability(m_quality - 1)}</color>"));
					}
					goto default;
				default:
					if (token == "$item_blockarmor" && item.GetBaseBlockPower(m_quality) != item.GetBaseBlockPower(m_quality - 1))
					{
						return text.Insert(num, GetStringUpgradeFrom(string.Format("<color=orange>{0}</color> <color=yellow>({1})</color>", item.GetBaseBlockPower(m_quality - 1), item.GetBlockPowerTooltip(m_quality - 1).ToString("0"))));
					}
					if (token == "$item_blockforce" && item.GetDeflectionForce(m_quality) != item.GetDeflectionForce(m_quality - 1))
					{
						return text.Insert(num, GetStringUpgradeFrom($"<color=orange>{item.GetDeflectionForce(m_quality - 1)}</color>"));
					}
					if (token == "$item_armor" && item.GetArmor(m_quality, (float)Game.m_worldLevel) != item.GetArmor(m_quality - 1, (float)Game.m_worldLevel))
					{
						return text.Insert(num, GetStringUpgradeFrom($"<color=orange>{item.GetArmor(m_quality - 1, (float)Game.m_worldLevel)}</color>"));
					}
					break;
				}
			}
			return text;
			static string GetStringUpgradeFrom(string value)
			{
				return value.Replace("<color=yellow>", "<color=silver>").Replace("<color=orange>", "<color=lightblue>") + " → ";
			}
		}

		private static float GetDamageByToken(string token, DamageTypes damages)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			float result = token switch
			{
				"$inventory_damage" => damages.m_damage, 
				"$inventory_blunt" => damages.m_blunt, 
				"$inventory_slash" => damages.m_slash, 
				"$inventory_pierce" => damages.m_pierce, 
				"$inventory_fire" => damages.m_fire, 
				"$inventory_frost" => damages.m_frost, 
				"$inventory_lightning" => damages.m_lightning, 
				"$inventory_poison" => damages.m_poison, 
				"$inventory_spirit" => damages.m_spirit, 
				_ => -1f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static void UpdateRecipeDescriptionFontSize()
		{
			if (Object.op_Implicit((Object)(object)InventoryGui.instance) && !((Object)(object)InventoryGui.instance.m_recipeDecription == (Object)null))
			{
				InventoryGui.instance.m_recipeDecription.fontSizeMin = Math.Min(MyLittleUI.itemTooltipRecipeFontSize.Value, InventoryGui.instance.m_recipeDecription.fontSizeMin);
			}
		}
	}
	internal static class CustomStatusEffectsList
	{
		[HarmonyPatch(typeof(Hud), "Awake")]
		public static class Hud_Awake_CustomTemplate
		{
			[HarmonyBefore(new string[] { "Azumatt.MinimalUI", "org.bepinex.plugins.passivepowers" })]
			public static void Postfix()
			{
				UpdateStatusEffectList();
			}
		}

		[HarmonyPatch(typeof(Hud), "OnDestroy")]
		public static class Hud_OnDestroy_CustomTemplate
		{
			public static void Prefix()
			{
				m_statusEffectTemplate = null;
				m_statusEffectTemplateOriginal = null;
			}
		}

		[HarmonyPatch(typeof(Hud), "UpdateStatusEffects")]
		public static class Hud_UpdateStatusEffects_Patch
		{
			[HarmonyAfter(new string[] { "Azumatt.MinimalUI", "org.bepinex.plugins.passivepowers" })]
			public static void Postfix(Hud __instance, List<StatusEffect> statusEffects, List<RectTransform> ___m_statusEffects)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				if (!MyLittleUI.modEnabled.Value || !GetStatusEffectsPositionEnabled())
				{
					return;
				}
				for (int i = 0; i < ___m_statusEffects.Count; i++)
				{
					___m_statusEffects[i].anchoredPosition = Vector2.op_Implicit(GetStatusEffectPosition(i));
					if (GetStatusEffectsElementEnabled())
					{
						TMP_Text component = ((Component)((Transform)___m_statusEffects[i]).Find("TimeText")).GetComponent<TMP_Text>();
						bool flag = !((Component)component).gameObject.activeSelf;
						TMP_Text component2 = ((Component)((Transform)___m_statusEffects[i]).Find("Name")).GetComponent<TMP_Text>();
						if (string.IsNullOrWhiteSpace(component2.text) && i < statusEffects.Count)
						{
							component2.SetText(Localization.instance.Localize(statusEffects[i].m_name));
						}
						component2.verticalAlignment = (VerticalAlignmentOptions)(flag ? 512 : 256);
						component2.textWrappingMode = (TextWrappingModes)(flag ? 1 : 0);
						component2.overflowMode = (TextOverflowModes)((!flag) ? 1 : 0);
						component.verticalAlignment = (VerticalAlignmentOptions)((!flag && string.IsNullOrWhiteSpace(component2.text)) ? 512 : 1024);
					}
				}
				Transform val = ((Transform)__instance.m_statusEffectListRoot).Find("WeightSE");
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).GetComponent<RectTransform>().anchoredPosition = Vector2.op_Implicit(GetStatusEffectPosition(___m_statusEffects.Count));
					((Component)val.Find("TimeText")).GetComponent<TMP_Text>().verticalAlignment = (VerticalAlignmentOptions)512;
				}
			}
		}

		[HarmonyPatch(typeof(Game), "UpdateNoMap")]
		public static class Game_UpdateNoMap_UpdateForecastPosition
		{
			public static void Postfix()
			{
				if (MyLittleUI.modEnabled.Value)
				{
					UpdateStatusEffectList();
				}
			}
		}

		private const string templateName = "SE_Template_MLU";

		private static RectTransform m_statusEffectTemplateOriginal;

		private static Vector2 m_statusEffectListRootPositionOriginal = Vector2.zero;

		private static RectTransform m_statusEffectTemplate;

		private static Vector2 m_shipWindIndicatorRootPositionOriginal = Vector2.zero;

		private static Vector2 m_shipWindIconRootPositionOriginal = Vector2.zero;

		private static Vector3 GetStatusEffectPosition(int i)
		{
			//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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			float num = i * (Game.m_noMap ? (MyLittleUI.statusEffectsPositionSpacingNomap.Value + MyLittleUI.statusEffectsElementSizeNomap.Value) : (MyLittleUI.statusEffectsPositionSpacing.Value + MyLittleUI.statusEffectsElementSize.Value));
			MyLittleUI.ListDirection listDirection = (Game.m_noMap ? MyLittleUI.statusEffectsFillingDirectionNomap.Value : MyLittleUI.statusEffectsFillingDirection.Value);
			if (1 == 0)
			{
			}
			Vector3 result = (Vector3)(listDirection switch
			{
				MyLittleUI.ListDirection.LeftToRight => new Vector3(num, 0f, 0f), 
				MyLittleUI.ListDirection.RightToLeft => new Vector3(0f - num, 0f, 0f), 
				MyLittleUI.ListDirection.TopToBottom => new Vector3(0f, 0f - num, 0f), 
				MyLittleUI.ListDirection.BottomToTop => new Vector3(0f, num, 0f), 
				_ => new Vector3(0f - num, 0f, 0f), 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		public static void UpdateStatusEffectList()
		{
			InitializeStatusEffectTemplate();
			ChangeSailingIndicator();
		}

		public static void InitializeStatusEffectTemplate()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Hud.instance == (Object)null))
			{
				if ((Object)(object)m_statusEffectTemplateOriginal == (Object)null)
				{
					m_statusEffectTemplateOriginal = Hud.instance.m_statusEffectTemplate;
					m_statusEffectListRootPositionOriginal = Hud.instance.m_statusEffectListRoot.anchoredPosition;
				}
				if ((Object)(object)m_statusEffectTemplate == (Object)null)
				{
					m_statusEffectTemplate = Object.Instantiate<RectTransform>(m_statusEffectTemplateOriginal, (Transform)(object)Hud.instance.m_statusEffectListRoot);
				}
				((Component)m_statusEffectTemplate).gameObject.SetActive(false);
				((Object)m_statusEffectTemplate).name = "SE_Template_MLU";
				int num = (Game.m_noMap ? MyLittleUI.statusEffectsElementSizeNomap.Value : MyLittleUI.statusEffectsElementSize.Value);
				RectTransform component = ((Component)((Transform)m_statusEffectTemplate).Find("Icon")).GetComponent<RectTransform>();
				component.SetSizeWithCurrentAnchors((Axis)1, (float)num);
				component.SetSizeWithCurrentAnchors((Axis)0, (float)num);
				component.anchoredPosition = new Vector2((float)(-num), 0f);
				RectTransform component2 = ((Component)((Transform)m_statusEffectTemplate).Find("Cooldown")).GetComponent<RectTransform>();
				component2.sizeDelta = component.sizeDelta;
				component2.anchoredPosition = component.anchoredPosition;
				RectTransform component3 = ((Component)((Transform)m_statusEffectTemplate).Find("Name")).GetComponent<RectTransform>();
				component3.SetSizeWithCurrentAnchors((Axis)1, (float)(num + 4));
				component3.SetSizeWithCurrentAnchors((Axis)0, 200f);
				component3.anchorMin = Vector2.one;
				component3.anchorMax = Vector2.one;
				((Transform)component3).localPosition = Vector2.op_Implicit(new Vector2(64f, ((Transform)component).localPosition.y));
				TextMeshProUGUI component4 = ((Component)component3).GetComponent<TextMeshProUGUI>();
				((TMP_Text)component4).alignment = (TextAlignmentOptions)257;
				((TMP_Text)component4).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)component4).fontSizeMax = num / 2;
				((TMP_Text)component4).fontSizeMin = num / 2;
				RectTransform component5 = ((Component)((Transform)m_statusEffectTemplate).Find("TimeText")).GetComponent<RectTransform>();
				component5.sizeDelta = component3.sizeDelta;
				component5.anchorMin = component3.anchorMin;
				component5.anchorMax = component3.anchorMax;
				((Transform)component5).localPosition = ((Transform)component3).localPosition;
				TextMeshProUGUI component6 = ((Component)component5).GetComponent<TextMeshProUGUI>();
				((TMP_Text)component6).alignment = (TextAlignmentOptions)1025;
				((TMP_Text)component6).textWrappingMode = ((TMP_Text)component4).textWrappingMode;
				((TMP_Text)component6).fontSizeMax = ((TMP_Text)component4).fontSizeMax;
				((TMP_Text)component6).fontSizeMin = ((TMP_Text)component4).fontSizeMin;
				if (Hud.instance.m_statusEffects.Count > 0)
				{
					Object.Destroy((Object)(object)((Component)Hud.instance.m_statusEffects.Last()).gameObject);
					Hud.instance.m_statusEffects.RemoveAt(Hud.instance.m_statusEffects.Count - 1);
				}
				Hud.instance.m_statusEffectListRoot.anchoredPosition = ((MyLittleUI.modEnabled.Value && GetStatusEffectsPositionEnabled()) ? GetStatusEffectsPositionAnchor() : m_statusEffectListRootPositionOriginal);
				Hud.instance.m_statusEffectTemplate = ((MyLittleUI.modEnabled.Value && GetStatusEffectsElementEnabled()) ? m_statusEffectTemplate : m_statusEffectTemplateOriginal);
			}
		}

		public static void ChangeSailingIndicator()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Hud.instance == (Object)null))
			{
				if (m_shipWindIndicatorRootPositionOriginal == Vector2.zero)
				{
					m_shipWindIndicatorRootPositionOriginal = Hud.instance.m_shipWindIndicatorRoot.anchoredPosition;
					m_shipWindIconRootPositionOriginal = ((Component)Hud.instance.m_shipHudRoot.transform.Find("PowerIcon")).GetComponent<RectTransform>().anchoredPosition;
				}
				Hud.instance.m_shipWindIndicatorRoot.anchoredPosition = ((MyLittleUI.modEnabled.Value && GetSailingIndicatorEnabled()) ? GetSailingIndicatorWindIndicatorPosition() : m_shipWindIndicatorRootPositionOriginal);
				((Transform)Hud.instance.m_shipWindIndicatorRoot).localScale = Vector3.one * ((MyLittleUI.modEnabled.Value && GetSailingIndicatorEnabled()) ? GetSailingIndicatorWindIndicatorScale() : 1f);
				((Component)Hud.instance.m_shipHudRoot.transform.Find("PowerIcon")).GetComponent<RectTransform>().anchoredPosition = ((MyLittleUI.modEnabled.Value && GetSailingIndicatorEnabled()) ? GetSailingIndicatorPowerIconPosition() : m_shipWindIconRootPositionOriginal);
				((Transform)((Component)Hud.instance.m_shipHudRoot.transform.Find("PowerIcon")).GetComponent<RectTransform>()).localScale = Vector3.one * ((MyLittleUI.modEnabled.Value && GetSailingIndicatorEnabled()) ? GetSailingIndicatorPowerIconScale() : 1f);
			}
		}

		private static Vector2 GetStatusEffectsPositionAnchor()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (MyLittleUI.fixStatusEffectAndForecastPosition.Value && ((BaseUnityPlugin)MyLittleUI.instance).Info.Metadata.Version >= new Version("1.0.11") && MyLittleUI.statusEffectsPositionAnchor.Value == new Vector2(-170f, -240f))
			{
				MyLittleUI.statusEffectsPositionAnchor.Value = (Vector2)((ConfigEntryBase)MyLittleUI.statusEffectsPositionAnchor).DefaultValue;
			}
			return Game.m_noMap ? MyLittleUI.statusEffectsPositionAnchorNomap.Value : MyLittleUI.statusEffectsPositionAnchor.Value;
		}

		private static bool GetSailingIndicatorEnabled()
		{
			return Game.m_noMap ? MyLittleUI.sailingIndicatorEnabledNomap.Value : MyLittleUI.sailingIndicatorEnabled.Value;
		}

		private static Vector2 GetSailingIndicatorWindIndicatorPosition()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return Game.m_noMap ? MyLittleUI.sailingIndicatorWindIndicatorPositionNomap.Value : MyLittleUI.sailingIndicatorWindIndicatorPosition.Value;
		}

		private static float GetSailingIndicatorWindIndicatorScale()
		{
			return Game.m_noMap ? MyLittleUI.sailingIndicatorWindIndicatorScaleNomap.Value : MyLittleUI.sailingIndicatorWindIndicatorScale.Value;
		}

		private static Vector2 GetSailingIndicatorPowerIconPosition()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return Game.m_noMap ? MyLittleUI.sailingIndicatorPowerIconPositionNomap.Value : MyLittleUI.sailingIndicatorPowerIconPosition.Value;
		}

		private static float GetSailingIndicatorPowerIconScale()
		{
			return Game.m_noMap ? MyLittleUI.sailingIndicatorPowerIconScaleNomap.Value : MyLittleUI.sailingIndicatorPowerIconScale.Value;
		}

		private static bool GetStatusEffectsPositionEnabled()
		{
			return Game.m_noMap ? MyLittleUI.statusEffectsPositionEnabledNomap.Value : MyLittleUI.statusEffectsPositionEnabled.Value;
		}

		private static bool GetStatusEffectsElementEnabled()
		{
			return Game.m_noMap ? MyLittleUI.statusEffectsElementEnabledNomap.Value : MyLittleUI.statusEffectsElementEnabled.Value;
		}
	}
	public static class MultiCraft
	{
		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipe")]
		public static class InventoryGui_UpdateRecipe_MulticraftShowButtons
		{
			internal static bool isCrafting;

			private static bool queueNextCraft;

			private static bool IsCrafting(InventoryGui __instance)
			{
				return __instance.m_craftTimer != -1f;
			}

			public static void Prefix(InventoryGui __instance)
			{
				isCrafting = IsCrafting(__instance);
			}

			[HarmonyPriority(0)]
			[HarmonyAfter(new string[] { "Azumatt.AzuCraftyBoxes", "aedenthorn.CraftFromContainers", "org.bepinex.plugins.valheim_plus" })]
			public static void Postfix(InventoryGui __instance)
			{
				if (MyLittleUI.AAA_Crafting)
				{
					return;
				}
				UpdateMulticraftPanel();
				textCrafting.SetText(Localization.instance.Localize("$inventory_craftingprog"));
				if (!showPanel)
				{
					return;
				}
				if (Object.op_Implicit((Object)(object)buttonIncrease))
				{
					((Selectable)buttonIncrease).interactable = ((Selectable)__instance.m_craftButton).interactable;
				}
				if (Object.op_Implicit((Object)(object)buttonDecrease))
				{
					((Selectable)buttonDecrease).interactable = ((Selectable)__instance.m_craftButton).interactable;
				}
				TMP_Text textAmount = MultiCraft.textAmount;
				if (textAmount != null)
				{
					textAmount.SetText("0");
				}
				if (!((Selectable)__instance.m_craftButton).interactable)
				{
					return;
				}
				if (isCrafting && !IsCrafting(__instance))
				{
					amount--;
					queueNextCraft = amount > 0;
				}
				int maxAmount = GetMaxAmountCached();
				if (AmountScrollHandler.hovered && ZInput.GetMouseScrollWheel() != 0f && Time.frameCount - lastScrollTriggerFrame > 2)
				{
					if (ZInput.GetMouseScrollWheel() > 0f)
					{
						if (Object.op_Implicit((Object)(object)buttonIncrease) && CanIncrease())
						{
							((UnityEvent)buttonIncrease.onClick).Invoke();
						}
					}
					else if (Object.op_Implicit((Object)(object)buttonDecrease) && CanDecrease())
					{
						((UnityEvent)buttonDecrease.onClick).Invoke();
					}
					lastScrollTriggerFrame = Time.frameCount;
				}
				amount = Mathf.Clamp(amount, (!isCrafting) ? 1 : 0, maxAmount);
				TMP_Text textAmount2 = MultiCraft.textAmount;
				if (textAmount2 != null)
				{
					textAmount2.SetText(amount.ToString());
				}
				if (Object.op_Implicit((Object)(object)buttonIncrease))
				{
					((Selectable)buttonIncrease).interactable = CanIncrease();
				}
				if (Object.op_Implicit((Object)(object)buttonDecrease))
				{
					((Selectable)buttonDecrease).interactable = CanDecrease();
				}
				if (amount > 1)
				{
					textCrafting.SetText(Localization.instance.Localize($"$inventory_craftingprog ({amount})"));
				}
				if (queueNextCraft)
				{
					((UnityEvent)__instance.m_craftButton.onClick).Invoke();
				}
				queueNextCraft = false;
				static bool CanDecrease()
				{
					return amount > 1;
				}
				bool CanIncrease()
				{
					return amount < maxAmount;
				}
			}

			private static string CombinedResAmount()
			{
				if (MultiCraft.resAmountElements.Count == 0)
				{
					for (int i = 0; i < InventoryGui.instance.m_recipeRequirementList.Length; i++)
					{
						List<TMP_Text> resAmountElements = MultiCraft.resAmountElements;
						Transform obj = InventoryGui.instance.m_recipeRequirementList[i].transform.Find("res_amount");
						resAmountElements.Add((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
					}
				}
				if (MultiCraft.resAmountElements.Count == 0)
				{
					return "";
				}
				bool flag = false;
				sb.Clear();
				foreach (TMP_Text resAmountElement in MultiCraft.resAmountElements)
				{
					if ((Object)(object)resAmountElement == (Object)null)
					{
						flag = true;
						break;
					}
					if (((Behaviour)resAmountElement).isActiveAndEnabled)
					{
						sb.Append(resAmountElement.text);
					}
				}
				if (flag)
				{
					MultiCraft.resAmountElements.Clear();
					return CombinedResAmount();
				}
				return sb.ToString();
			}

			private static string GetNumbersString()
			{
				string text = CombinedResAmount();
				if (Utility.IsNullOrWhiteSpace(text))
				{
					return text;
				}
				string text2 = Regex.Replace(Regex.Replace(text, "<.*?>", string.Empty), "[^\\d]", string.Empty);
				if (((RecipeDataPair)(ref InventoryGui.instance.m_selectedRecipe)).Recipe.m_requireOnlyOneIngredient)
				{
					text2 += Mathf.Sin(Time.time * 5f) > 0f;
				}
				return text2;
			}

			private static int GetMaxAmountCached()
			{
				string numbersString = GetNumbersString();
				if (Utility.IsNullOrWhiteSpace(numbersString))
				{
					return 0;
				}
				if (cachedAmount.TryGetValue(((RecipeDataPair)(ref InventoryGui.instance.m_selectedRecipe)).Recipe, out var value) && value.Item1 == numbersString)
				{
					return value.Item2;
				}
				Stopwatch stopwatch = Stopwatch.StartNew();
				int maximumAmount = GetMaximumAmount(((RecipeDataPair)(ref InventoryGui.instance.m_selectedRecipe)).Recipe, Player.m_localPlayer);
				MyLittleUI.LogInfo($"Multicraft max amount calculated in {(double)stopwatch.ElapsedTicks / (double)Stopwatch.Frequency * 1000.0:F2} ms");
				stopwatch.Stop();
				cachedAmount[((RecipeDataPair)(ref InventoryGui.instance.m_selectedRecipe)).Recipe] = Tuple.Create(numbersString, maximumAmount);
				return maximumAmount;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		public static class InventoryGui_Awake_MulticraftCreateButtons
		{
			public static void Postfix(InventoryGui __instance)
			{
				if (!MyLittleUI.AAA_Crafting)
				{
					Button craftButton = __instance.m_craftButton;
					MultiCraft.craftButton = ((craftButton != null) ? ((Component)craftButton).GetComponent<RectTransform>() : null);
					CreateMulticraftPanel();
					UpdateMulticraftPanel();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnDestroy")]
		public static class InventoryGui_OnDestroy_MulticraftOnDestroy
		{
			public static void Postfix()
			{
				panel = null;
				craftButton = null;
				buttonIncrease = null;
				buttonDecrease = null;
				textAmount = null;
				resAmountElements.Clear();
			}
		}

		[HarmonyPatch(typeof(Player), "ToggleNoPlacementCost")]
		public static class Player_ToggleNoPlacementCost_MulticraftUpdateMaxAmount
		{
			public static void Postfix()
			{
				cachedAmount.Clear();
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "SetRecipe")]
		public static class InventoryGui_SetRecipe_ResetMulticraftAfterRecipeChange
		{
			public static void Prefix(InventoryGui __instance, ref Recipe __state)
			{
				__state = ((RecipeDataPair)(ref __instance.m_selectedRecipe)).Recipe;
			}

			public static void Postfix(InventoryGui __instance, Recipe __state)
			{
				if ((Object)(object)__state != (Object)(object)((RecipeDataPair)(ref __instance.m_selectedRecipe)).Recipe && InventoryGui_UpdateRecipe_MulticraftShowButtons.isCrafting)
				{
					amount = 0;
				}
			}
		}

		public const string panelName = "MLUI_Multicraft";

		public const string buttonIncreaseName = "Increase";

		public const string buttonDecreaseName = "Decrease";

		public const string textAmountName = "Amount";

		private static readonly Recipe tempRecipe = ScriptableObject.CreateInstance<Recipe>();

		private static readonly StringBuilder sb = new StringBuilder(10);

		private static readonly Dictionary<Recipe, Tuple<string, int>> cachedAmount = new Dictionary<Recipe, Tuple<string, int>>();

		private static readonly List<TMP_Text> resAmountElements = new List<TMP_Text>();

		private static RectTransform panel;

		private static RectTransform craftButton;

		private static Button buttonIncrease;

		private static Button buttonDecrease;

		private static TMP_Text textAmount;

		private static TMP_Text textCrafting;

		private static int amount = 1;

		private static bool showPanel;

		public static int lastScrollTriggerFrame;

		public const int minScrollDeltaFrames = 2;

		public static bool IsMulticraftEnabled => MyLittleUI.modEnabled.Value && MyLittleUI.showMulticraftButtons.Value && !MyLittleUI.AAA_Crafting;

		private static int GetMaximumAmount(Recipe recipe, Player player)
		{
			if (player.NoCostCheat())
			{
				return 99;
			}
			CraftingStation currentCraftingStation = player.GetCurrentCraftingStation();
			if (Object.op_Implicit((Object)(object)recipe.GetRequiredStation(1)) && (!Object.op_Implicit((Object)(object)currentCraftingStation) || !currentCraftingStation.CheckUsable(player, false)))
			{
				return 0;
			}
			if (ZoneSystem.instance.GetGlobalKey((GlobalKeys)20))
			{
				return 99;
			}
			if (!recipe.m_requireOnlyOneIngredient)
			{
				return GetMaxCraftAmount(player, recipe);
			}
			tempRecipe.m_item = recipe.m_item;
			tempRecipe.m_amount = recipe.m_amount;
			tempRecipe.m_enabled = recipe.m_enabled;
			tempRecipe.m_qualityResultAmountMultiplier = recipe.m_qualityResultAmountMultiplier;
			tempRecipe.m_craftingStation = recipe.m_craftingStation;
			tempRecipe.m_repairStation = recipe.m_repairStation;
			tempRecipe.m_minStationLevel = recipe.m_minStationLevel;
			tempRecipe.m_listSortWeight = recipe.m_listSortWeight;
			tempRecipe.m_requireOnlyOneIngredient = false;
			tempRecipe.m_resources = (Requirement[])(object)new Requirement[1];
			int num = 0;
			for (int i = 0; i < recipe.m_resources.Length; i++)
			{
				Requirement val = recipe.m_resources[i];
				if (player.IsKnownMaterial(val.m_resItem.m_itemData.m_shared.m_name) && val.m_amount >= 1)
				{
					tempRecipe.m_resources[0] = JsonUtility.FromJson<Requirement>(JsonUtility.ToJson((object)val));
					num += GetMaxCraftAmount(player, tempRecipe);
					if (num >= 99)
					{
						num = 99;
						break;
					}
				}
			}
			return num;
		}

		private static int GetMaxCraftAmount(Player player, Recipe recipe)
		{
			if (!HaveRequirements(1))
			{
				return 0;
			}
			int num = 1;
			int num2 = 99;
			while (num < num2)
			{
				int num3 = (num + num2 + 1) / 2;
				if (HaveRequirements(num3))
				{
					num = num3;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return num;
			bool HaveRequirements(int amount)
			{
				return player.HaveRequirements(recipe, false, 1, amount);
			}
		}

		private static void CreateMulticraftPanel()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Expected O, but got Unknown
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)craftButton))
			{
				Transform craftProgressPanel = InventoryGui.instance.m_craftProgressPanel;
				object obj;
				if (craftProgressPanel == null)
				{
					obj = null;
				}
				else
				{
					Transform obj2 = craftProgressPanel.Find("Text");
					obj = ((obj2 != null) ? ((Component)obj2).GetComponent<TMP_Text>() : null);
				}
				textCrafting = (TMP_Text)obj;
				panel = new GameObject("MLUI_Multicraft", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Transform)panel).SetParent(((Transform)craftButton).parent, false);
				panel.anchorMin = new Vector2(0.75f, 0f);
				panel.anchorMax = Vector2.one;
				panel.offsetMin = Vector2.zero;
				panel.offsetMax = new Vector2(0f, -5f);
				((Component)panel).gameObject.AddComponent<AmountScrollHandler>();
				GameObject val = Object.Instantiate<GameObject>(((Component)craftButton).gameObject, (Transform)(object)panel);
				((Object)val).name = "Increase";
				buttonIncrease = val.GetComponent<Button>();
				((UnityEventBase)buttonIncrease.onClick).RemoveAllListeners();
				((UnityEvent)buttonIncrease.onClick).AddListener(new UnityAction(OnIncreaseButtonPressed));
				((Component)buttonIncrease).gameObject.AddComponent<ButtonSfx>().m_sfxPrefab = ((Component)InventoryGui.instance.m_tabCraft).GetComponent<ButtonSfx>().m_sfxPrefab;
				UIGamePad component = ((Component)buttonIncrease).GetComponent<UIGamePad>();
				component.m_zinputKey = "JoyRStickUp";
				component.m_keyCode = (KeyCode)273;
				Object.Destroy((Object)(object)component.m_hint);
				component.m_hint = null;
				RectTransform component2 = val.GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0.5f, 0.5f);
				component2.anchorMax = Vector2.one;
				component2.offsetMin = Vector2.zero;
				component2.offsetMax = Vector2.zero;
				TMP_Text component3 = ((Component)((Transform)component2).Find("Text")).GetComponent<TMP_Text>();
				component3.SetText("+");
				RectTransform component4 = ((Component)component3).GetComponent<RectTransform>();
				component4.offsetMin = new Vector2(0f, 2f);
				component4.offsetMax = Vector2.zero;
				GameObject val2 = Object.Instantiate<GameObject>(((Component)craftButton).gameObject, (Transform)(object)panel);
				((Object)val2).name = "Decrease";
				buttonDecrease = val2.GetComponent<Button>();
				((UnityEventBase)buttonDecrease.onClick).RemoveAllListeners();
				((UnityEvent)buttonDecrease.onClick).AddListener(new UnityAction(OnDecreaseButtonPressed));
				((Component)buttonDecrease).gameObject.AddComponent<ButtonSfx>().m_sfxPrefab = ((Component)InventoryGui.instance.m_tabCraft).GetComponent<ButtonSfx>().m_sfxPrefab;
				UIGamePad component5 = ((Component)buttonDecrease).GetComponent<UIGamePad>();
				component5.m_zinputKey = "JoyRStickDown";
				component5.m_keyCode = (KeyCode)274;
				Object.Destroy((Object)(object)component5.m_hint);
				component5.m_hint = null;
				RectTransform component6 = val2.GetComponent<RectTransform>();
				component6.anchorMin = new Vector2(0.5f, 0f);
				component6.anchorMax = new Vector2(1f, 0.5f);
				component6.offsetMin = Vector2.zero;
				component6.offsetMax = Vector2.zero;
				TMP_Text component7 = ((Component)((Transform)component6).Find("Text")).GetComponent<TMP_Text>();
				component7.SetText("-");
				RectTransform component8 = ((Component)component7).GetComponent<RectTransform>();
				component8.offsetMin = new Vector2(0f, 2f);
				component8.offsetMax = Vector2.zero;
				GameObject val3 = Object.Instantiate<GameObject>(((Component)((Component)craftButton).transform.Find("Text")).gameObject, (Transform)(object)panel);
				((Object)val3).name = "Amount";
				RectTransform component9 = val3.GetComponent<RectTransform>();
				component9.anchorMin = Vector2.zero;
				component9.anchorMax = new Vector2(0.5f, 1f);
				component9.offsetMin = Vector2.zero;
				component9.offsetMax = Vector2.zero;
				component9.sizeDelta = new Vector2(-4f, 0f);
				textAmount = val3.GetComponent<TMP_Text>();
				textAmount.SetText("99");
				textAmount.fontSizeMax = 32f;
				MyLittleUI.LogInfo("Multicraft panel initialized");
			}
		}

		internal static void UpdateMulticraftPanel()
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)InventoryGui.instance) && !MyLittleUI.AAA_Crafting)
			{
				showPanel = IsMulticraftEnabled && (Object)(object)((RecipeDataPair)(ref InventoryGui.instance.m_selectedRecipe)).Recipe != (Object)null && ((RecipeDataPair)(ref InventoryGui.instance.m_selectedRecipe)).ItemData == null && (((RecipeDataPair)(ref InventoryGui.instance.m_selectedRecipe)).CanCraft || Player.m_localPlayer.NoCostCheat());
				RectTransform obj = panel;
				if (obj != null)
				{
					((Component)obj).gameObject.SetActive(showPanel && ((Behaviour)InventoryGui.instance.m_craftButton).isActiveAndEnabled);
				}
				if (Object.op_Implicit((Object)(object)craftButton))
				{
					craftButton.anchorMax = (Vector2)(showPanel ? new Vector2(0.75f, 1f) : Vector2.one);
				}
			}
		}

		private static void OnIncreaseButtonPressed()
		{
			ChangeAmount(1);
		}

		private static void OnDecreaseButtonPressed()
		{
			ChangeAmount(-1);
		}

		private static void ChangeAmount(int direction)
		{
			int num = 1;
			if (UnityInput.Current.GetKey((KeyCode)306))
			{
				num = 99;
			}
			else if (UnityInput.Current.GetKey((KeyCode)304))
			{
				num = 10;
			}
			amount += direction * num;
		}
	}
	[BepInPlugin("shudnal.MyLittleUI", "My Little UI", "1.2.12")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("randyknapp.mods.auga")]
	public class MyLittleUI : BaseUnityPlugin
	{
		public enum StationHover
		{
			Vanilla,
			Percentage,
			MinutesSeconds,
			Bar
		}

		public enum ChestItemsHover
		{
			Vanilla,
			Percentage,
			ItemsMaxRoom,
			FreeSlots
		}

		public enum ChestNameHover
		{
			Vanilla,
			CustomName,
			TypeThenCustomName,
			CustomNameThenType
		}

		public enum ListDirection
		{
			RightToLeft,
			LeftToRight,
			TopToBottom,
			BottomToTop
		}

		public enum ContentSortType
		{
			Position,
			Name,
			Weight,
			Amount,
			Value
		}

		public enum ContentSortDir
		{
			Asc,
			Desc
		}

		public enum ClockTimeType
		{
			GameTime,
			Fuzzy,
			RealTime,
			GameAndRealTime
		}

		public enum ElementAnchor
		{
			TopLeft,
			Top,
			TopRight,
			Right,
			BottomRight,
			Bottom,
			BottomLeft,
			Left,
			Middle
		}

		[HarmonyPatch(typeof(Fermenter), "GetHoverText")]
		private class Fermenter_GetHoverText_Duration
		{
			private static void Postfix(Fermenter __instance, ref string __result, bool ___m_exposed)
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Invalid comparison between Unknown and I4
				if (!modEnabled.Value || !hoverFermenterEnabled.Value || hoverFermenter.Value == StationHover.Vanilla || string.IsNullOrWhiteSpace(__result) || ___m_exposed || !PrivateArea.CheckAccess(((Component)__instance).transform.position, 0f, false, false))
				{
					return;
				}
				string text = Localization.instance.Localize(__instance.GetContentName());
				if (!string.IsNullOrEmpty(text) && __result.Contains(text + ", "))
				{
					__result = __result.Replace(text + ", ", "") + "\n" + text;
				}
				if ((int)__instance.GetStatus() == 1)
				{
					if (hoverFermenter.Value == StationHover.Percentage)
					{
						__result += $"\n{__instance.GetFermentationTime() / (double)__instance.m_fermentationDuration:P0}";
					}
					else if (hoverFermenter.Value == StationHover.Bar)
					{
						__result = __result + "\n" + FromPercent(__instance.GetFermentationTime() / (double)__instance.m_fermentationDuration);
					}
					else if (hoverFermenter.Value == StationHover.MinutesSeconds)
					{
						__result = __result + "\n" + FromSeconds((double)__instance.m_fermentationDuration - __instance.GetFermentationTime());
					}
				}
			}
		}

		[HarmonyPatch(typeof(Plant), "GetHoverText")]
		private class Plant_GetHoverText_Duration
		{
			private static void Postfix(Plant __instance, ref string __result)
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Invalid comparison between Unknown and I4
				if (modEnabled.Value && hoverPlantEnabled.Value && hoverPlant.Value != 0 && !string.IsNullOrWhiteSpace(__result) && (int)__instance.GetStatus() <= 0)
				{
					if (hoverPlant.Value == StationHover.Percentage)
					{
						__result += $"\n{__instance.TimeSincePlanted() / (double)__instance.GetGrowTime():P0}";
					}
					else if (hoverPlant.Value == StationHover.Bar)
					{
						__result = __result + "\n" + FromPercent(__instance.TimeSincePlanted() / (double)__instance.GetGrowTime());
					}
					else if (hoverPlant.Value == StationHover.MinutesSeconds)
					{
						__result = __result + "\n" + FromSeconds((double)__instance.GetGrowTime() - __instance.TimeSincePlanted());
					}
				}
			}
		}

		[HarmonyPatch(typeof(Pickable), "GetHoverText")]
		private class Pickable_GetHoverText_Duration
		{
			private static void Postfix(Pickable __instance, ref string __result)
			{
				if (!modEnabled.Value || !hoverPickableEnabled.Value || hoverPickable.Value == StationHover.Vanilla || !__instance.m_picked || __instance.m_enabled == 0 || (Object)(object)__instance.m_nview == (Object)null || !__instance.m_nview.IsValid())
				{
					return;
				}
				long @long = __instance.m_nview.GetZDO().GetLong(ZDOVars.s_pickedTime, 0L);
				if (@long > 1)
				{
					if (string.IsNullOrWhiteSpace(__result))
					{
						__result = Localization.instance.Localize(__instance.GetHoverName());
					}
					TimeSpan timeSpan = ZNet.instance.GetTime() - new DateTime(@long);
					if (hoverPickable.Value == StationHover.Percentage)
					{
						__result += $"\n{timeSpan.TotalSeconds / (double)(__instance.m_respawnTimeMinutes * 60f):P0}";
					}
					else if (hoverPickable.Value == StationHover.Bar)
					{
						__result = __result + "\n" + FromPercent(timeSpan.TotalSeconds / (double)(__instance.m_respawnTimeMinutes * 60f));
					}
					else if (hoverPickable.Value == StationHover.MinutesSeconds)
					{
						__result = __result + "\n" + FromSeconds((double)(__instance.m_respawnTimeMinutes * 60f) - timeSpan.TotalSeconds);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Beehive), "GetHoverText")]
		private class Beehive_GetHoverText_Duration
		{
			private static void Postfix(Beehive __instance, ref string __result)
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				if (!modEnabled.Value || !hoverBeeHiveEnabled.Value || hoverBeeHive.Value == StationHover.Vanilla || string.IsNullOrWhiteSpace(__result))
				{
					return;
				}
				int honeyLevel = __instance.GetHoneyLevel();
				if (!PrivateArea.CheckAccess(((Component)__instance).transform.position, 0f, false, false) || honeyLevel == __instance.m_maxHoney)
				{
					return;
				}
				float @float = __instance.m_nview.GetZDO().GetFloat("product", 0f);
				if (hoverBeeHive.Value == StationHover.Percentage)
				{
					__result += $"\n{@float / __instance.m_secPerUnit:P0}";
				}
				else if (hoverBeeHive.Value == StationHover.Bar)
				{
					__result = __result + "\n" + FromPercent(@float / __instance.m_secPerUnit);
				}
				else if (hoverBeeHive.Value == StationHover.MinutesSeconds)
				{
					__result = __result + "\n" + FromSeconds(__instance.m_secPerUnit - @float);
				}
				if (hoverBeeHiveTotal.Value && honeyLevel < 3)
				{
					if (hoverBeeHive.Value == StationHover.Percentage)
					{
						__result += $"\n{(@float + __instance.m_secPerUnit * (float)honeyLevel) / (__instance.m_secPerUnit * (float)__instance.m_maxHoney):P0}";
					}
					else if (hoverBeeHive.Value == StationHover.Bar)
					{
						__result = __result + "\n" + FromPercent((@float + __instance.m_secPerUnit * (float)honeyLevel) / (__instance.m_secPerUnit * (float)__instance.m_maxHoney));
					}
					else if (hoverBeeHive.Value == StationHover.MinutesSeconds)
					{
						__result = __result + "\n" + FromSeconds(__instance.m_secPerUnit * (float)__instance.m_maxHoney - (@float + __instance.m_secPerUnit * (float)honeyLevel));
					}
				}
			}
		}

		[HarmonyPatch(typeof(CookingStation), "Awake")]
		public class CookingStation_Awake_HoverDelegate
		{
			public static void Postfix(CookingStation __instance)
			{
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				if (modEnabled.Value && hoverCookingEnabled.Value && hoverCooking.Value != 0 && __instance.m_nview.IsValid() && Object.op_Implicit((Object)(object)__instance.m_addFoodSwitch))
				{
					Switch addFoodSwitch = __instance.m_addFoodSwitch;
					if (addFoodSwitch.m_onHover == null)
					{
						addFoodSwitch.m_onHover = new TooltipCallback(__instance.HoverText);
					}
				}
			}
		}

		[HarmonyPatch(typeof(CookingStation), "UpdateCooking")]
		public class CookingStation_UpdateCooking_HoverUpdate
		{
			public static void Postfix(CookingStation __instance)
			{
				if (modEnabled.Value && hoverCookingEnabled.Value && hoverCooking.Value != 0 && __instance.m_nview.IsValid() && Object.op_Implicit((Object)(object)__instance.m_addFoodSwitch) && __instance.m_addFoodSwitch.m_onHover == null)
				{
					__instance.m_addFoodSwitch.m_hoverText = CookingStation_HoverText_ExtendedHover.HoverText(__instance, __instance.m_name, __instance.m_addItemTooltip);
				}
			}
		}

		[HarmonyPatch(typeof(CookingStation), "HoverText")]
		public class CookingStation_HoverText_ExtendedHover
		{
			private static readonly StringBuilder sb = new StringBuilder();

			private static string GetItemName(CookingStation __instance, string currentItem, out bool itemReady, out ItemConversion conversion)
			{
				string text = currentItem;
				conversion = __instance.GetItemConversion(currentItem);
				if (conversion != null)
				{
					itemReady = ((Object)((Component)conversion.m_to).gameObject).name == text;
					text = (itemReady ? conversion.m_to.GetHoverName() : conversion.m_from.GetHoverName());
				}
				else
				{
					itemReady = false;
					List<ItemDrop> allItems = ObjectDB.instance.GetAllItems((ItemType)1, currentItem);
					if (allItems.Count > 0)
					{
						text = allItems[0].GetHoverName();
					}
				}
				return text;
			}

			public static ItemData FindCookableItem(CookingStation __instance, Inventory inventory)
			{
				foreach (ItemConversion item2 in __instance.m_conversion)
				{
					ItemData item = inventory.GetItem(item2.m_from.m_itemData.m_shared.m_name, -1, false);
					if (item != null)
					{
						return item;
					}
				}
				return null;
			}

			public static string HoverText(CookingStation __instance, string m_name, string m_addItemTooltip)
			{
				sb.Clear();
				sb.Append(m_name);
				sb.Append("\n[<color=yellow><b>$KEY_Use</b></color>] ");
				sb.Append(m_addItemTooltip);
				if (hoverCookingNextItem.Value && (Object)(object)Player.m_localPlayer != (Object)null)
				{
					ItemData val = FindCookableItem(__instance, ((Humanoid)Player.m_localPlayer).GetInventory());
					if (val != null)
					{
						sb.Append(" (<color=#add8e6ff>" + val.m_shared.m_name + "</color>)");
					}
				}
				if (hoverCookingRemoveLastItem.Value)
				{
					ZNetView nview = __instance.m_nview;
					if (nview != null && nview.IsValid() && __instance.GetFreeSlot() != 0 && CookingStationRemoveItem.GetSlotToRemove(__instance, out var itemName, out var _) != -1)
					{
						if (!ZInput.IsNonClassicFunctionality() || !ZInput.IsGamepadActive())
						{
							sb.Append("\n[<color=yellow><b>$KEY_AltPlace + $KEY_Use</b></color>] $hud_remove");
						}
						else
						{
							sb.Append("\n[<color=yellow><b>$KEY_JoyAltKeys + $KEY_Use</b></color>] $hud_remove");
						}
						StringBuilder stringBuilder = sb;
						GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(itemName);
						stringBuilder.Append(" (<color=#add8e6ff>" + ((itemPrefab == null) ? null : itemPrefab.GetComponent<ItemDrop>()?.m_itemData.m_shared.m_name) + "</color>)");
					}
				}
				if (!ZInput.GamepadActive)
				{
					sb.Append("\n[<color=yellow><b>1-8</b></color>] ");
					sb.Append(m_addItemTooltip);
				}
				string text = default(string);
				float num = default(float);
				Status val2 = default(Status);
				for (int i = 0; i < __instance.m_slots?.Length; i++)
				{
					__instance.GetSlot(i, ref text, ref num, ref val2);
					if (text == "")
					{
						continue;
					}
					sb.Append("\n");
					bool itemReady;
					ItemConversion conversion;
					string itemName2 = GetItemName(__instance, text, out itemReady, out conversion);
					if (conversion != null)
					{
						string text2 = text;
						ItemDrop overCookedItem = __instance.m_overCookedItem;
						if (!(text2 == ((overCookedItem != null) ? ((Object)overCookedItem).name : null)))
						{
							sb.Append(itemName2);
							sb.Append(" ");
							bool flag = itemReady && Mathf.Sin(Time.time * 10f) > 0f;
							if (flag)
							{
								sb.Append("<color=red>");
							}
							if (hoverCooking.Value == StationHover.Percentage)
							{
								sb.Append($"{(num - (itemReady ? conversion.m_cookTime : 0f)) / conversion.m_cookTime:P0}");
							}
							else if (hoverCooking.Value == StationHover.Bar)
							{
								sb.Append("\n");
								sb.Append(FromPercent((num - (itemReady ? conversion.m_cookTime : 0f)) / conversion.m_cookTime));
							}
							else if (hoverCooking.Value == StationHover.MinutesSeconds)
							{
								sb.Append(FromSeconds(conversion.m_cookTime - (num - (itemReady ? conversion.m_cookTime : 0f))));
							}
							if (flag)
							{
								sb.Append("</color>");
							}
							continue;
						}
					}
					sb.Append(itemName2);
				}
				return Localization.instance.Localize(sb.ToString());
			}

			private static void Postfix(CookingStation __instance, ref string __result)
			{
				if (modEnabled.Value && hoverCookingEnabled.Value && hoverCooking.Value != 0)
				{
					ZNetView nview = __instance.m_nview;
					if (nview != null && nview.IsValid())
					{
						__result = HoverText(__instance, __instance.m_name, __instance.m_addItemTooltip);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Smelter), "OnHoverAddFuel")]
		private class Smelter_OnHoverAddFuel_SmelterHover
		{
			private static readonly StringBuilder sb = new StringBuilder();

			private static void Postfix(Smelter __instance, ref string __result, string ___m_name, ItemDrop ___m_fuelItem, int ___m_maxFuel, int ___m_maxOre, int ___m_fuelPerProduct, float ___m_secPerProduct, Windmill ___m_windmill)
			{
				if (modEnabled.Value && (hoverSmelterShowFuelAndItem.Value || hoverSmelterEstimatedTime.Value))
				{
					float fuel = __instance.GetFuel();
					int queueSize = __instance.GetQueueSize();
					sb.Clear();
					sb.Append(___m_name);
					if (hoverSmelterShowFuelAndItem.Value && ___m_maxOre > 0)
					{
						sb.Append($" ({queueSize}/{___m_maxOre})");
					}
					sb.Append(" (");
					sb.Append(___m_fuelItem.m_itemData.m_shared.m_name);
					sb.Append($" {Mathf.CeilToInt(fuel)}/{___m_maxFuel})");
					sb.Append("\n[<color=yellow><b>$KEY_Use</b></color>] $piece_smelter_add ");
					sb.Append(___m_fuelItem.m_itemData.m_shared.m_name);
					if (hoverSmelterEstimatedTime.Value && __instance.IsActive() && ___m_maxOre > 0)
					{
						sb.Append("\n");
						float num = Mathf.Max(((Object)(object)___m_windmill != (Object)null) ? ___m_windmill.GetPowerOutput() : 1f, 0.0001f);
						float num2 = (float)((___m_fuelPerProduct != 0) ? Math.Min(Mathf.FloorToInt(fuel / (float)___m_fuelPerProduct), queueSize) : queueSize) * ___m_secPerProduct;
						sb.Append(FromSeconds((___m_fuelPerProduct == 0 || fuel / (float)___m_fuelPerProduct >= (float)queueSize) ? ((num2 - __instance.GetBakeTimer()) / num) : (___m_secPerProduct * fuel / (float)___m_fuelPerProduct)));
					}
					__result = Localization.instance.Localize(sb.ToString());
				}
			}
		}

		[HarmonyPatch(typeof(Smelter), "OnHoverAddOre")]
		private class Smelter_OnHoverAddOre_SmelterHover
		{
			private static readonly StringBuilder sb = new StringBuilder();

			private static string GetItemName(Smelter __instance, string currentItem, ref bool nonconversionItem)
			{
				string result = currentItem;
				ItemConversion itemConversion = __instance.GetItemConversion(currentItem);
				if (itemConversion != null)
				{
					result = itemConversion.m_from.m_itemData.m_shared.m_name;
				}
				else
				{
					nonconversionItem = true;
					List<ItemDrop> allItems = ObjectDB.instance.GetAllItems((ItemType)1, currentItem);
					if (allItems.Count > 0)
					{
						result = allItems[0].m_itemData.m_shared.m_name;
					}
				}
				return result;
			}

			private static void Postfix(Smelter __instance, ref string __result, string ___m_name, ItemDrop ___m_fuelItem, int ___m_maxFuel, int ___m_maxOre, int ___m_fuelPerProduct, float ___m_secPerProduct, bool ___m_requiresRoof, bool ___m_haveRoof, string ___m_addOreTooltip, ZNetView ___m_nview, List<ItemConversion> ___m_conversion, Windmill ___m_windmill)
			{
				if (!modEnabled.Value || (!hoverSmelterShowFuelAndItem.Value && !hoverSmelterEstimatedTime.Value && !hoverSmelterShowQueuedItems.Value))
				{
					return;
				}
				float fuel = __instance.GetFuel();
				int queueSize = __instance.GetQueueSize();
				sb.Clear();
				sb.Append(___m_name);
				sb.Append($" ({queueSize}/{___m_maxOre})");
				if (hoverSmelterShowFuelAndItem.Value)
				{
					if ((Object)(object)___m_fuelItem != (Object)null && ___m_maxFuel > 0)
					{
						sb.Append(" (");
						sb.Append(___m_fuelItem.m_itemData.m_shared.m_name);
						sb.Append($" {Mathf.CeilToInt(fuel)}/{___m_maxFuel})");
					}
					if ((Object)(object)__instance.m_emptyOreSwitch != (Object)null)
					{
						sb.Append($" ({__instance.GetProcessedQueueSize()} $piece_smelter_ready)");
					}
				}
				if (___m_requiresRoof && !___m_haveRoof && Mathf.Sin(Time.time * 10f) > 0f)
				{
					sb.Append(" <color=yellow>$piece_smelter_reqroof</color>");
				}
				sb.Append("\n[<color=yellow><b>$KEY_Use</b></color>] " + ___m_addOreTooltip);
				if (hoverSmelterEstimatedTime.Value && __instance.IsActive() && ___m_maxOre > 0)
				{
					sb.Append("\n");
					float num = Mathf.Max(((Object)(object)___m_windmill != (Object)null) ? ___m_windmill.GetPowerOutput() : 1f, 0.0001f);
					float num2 = (float)((___m_fuelPerProduct != 0) ? Math.Min(Mathf.FloorToInt(fuel / (float)___m_fuelPerProduct), queueSize) : queueSize) * ___m_secPerProduct;
					sb.Append(FromSeconds((___m_fuelPerProduct == 0 || fuel / (float)___m_fuelPerProduct >= (float)queueSize) ? ((num2 - __instance.GetBakeTimer()) / num) : (___m_secPerProduct * fuel / (float)___m_fuelPerProduct)));
				}
				if (hoverSmelterShowQueuedItems.Value && __instance.GetQueuedOre() != "")
				{
					List<string> list = new List<string>();
					int num3 = 0;
					string text = "";
					bool nonconversionItem = false;
					for (int i = 0; i < queueSize; i++)
					{
						string @string = ___m_nview.GetZDO().GetString($"item{i}", "");
						if (@string == "")
						{
							break;
						}
						if (text == "")
						{
							num3++;
							text = @string;
						}
						else if (@string == text)
						{
							num3++;
						}
						else
						{
							list.Add($"{GetItemName(__instance, text, ref nonconversionItem)} x{num3}");
							num3 = 1;
							text = @string;
						}
					}
					if (text != "" && num3 > 0)
					{
						list.Add($"{GetItemName(__instance, text, ref nonconversionItem)} x{num3}");
					}
					if (___m_conversion.Count > 1 || list.Count > 1 || nonconversionItem)
					{
						sb.Append("\n");
						sb.Append("\n");
						sb.Append(string.Join("\n", list));
					}
				}
				__result = Localization.instance.Localize(sb.ToString());
			}
		}

		[HarmonyPatch(typeof(Smelter), "OnHoverEmptyOre")]
		private class Smelter_OnHoverEmptyOre_SmelterHover
		{
			private static readonly StringBuilder sb = new StringBuilder();

			private static void Postfix(Smelter __instance, ref string __result, string ___m_name, int ___m_maxOre, int ___m_fuelPerProduct, float ___m_secPerProduct, Windmill ___m_windmill)
			{
				if (!modEnabled.Value || (!hoverSmelterShowFuelAndItem.Value && !hoverSmelterEstimatedTime.Value))
				{
					return;
				}
				int processedQueueSize = __instance.GetProcessedQueueSize();
				int queueSize = __instance.GetQueueSize();
				sb.Clear();
				sb.Append(___m_name);
				sb.Append($" ({processedQueueSize} $piece_smelter_ready)");
				if (hoverSmelterShowFuelAndItem.Value && ___m_maxOre > 0)
				{
					string queuedOre = __instance.GetQueuedOre();
					if (queuedOre != "")
					{
						ObjectDB instance = ObjectDB.instance;
						object obj;
						if (instance == null)
						{
							obj = null;
						}
						else
						{
							GameObject itemPrefab = instance.GetItemPrefab(queuedOre);
							obj = ((itemPrefab == null) ? null : itemPrefab.GetComponent<ItemDrop>()?.m_itemData);
						}
						ItemData val = (ItemData)obj;
						if (val != null)
						{
							sb.Append(" " + val.m_shared.m_name);
						}
					}
					sb.Append($" ({queueSize}/{___m_maxOre})");
				}
				sb.Append("\n[<color=yellow><b>$KEY_Use</b></color>] " + __instance.m_emptyOreTooltip);
				if (hoverSmelterEstimatedTime.Value && __instance.IsActive() && ___m_maxOre > 0)
				{
					sb.Append("\n");
					float fuel = __instance.GetFuel();
					float num = Mathf.Max(((Object)(object)___m_windmill != (Object)null) ? ___m_windmill.GetPowerOutput() : 1f, 0.0001f);
					float num2 = (float)((___m_fuelPerProduct != 0) ? Math.Min(Mathf.FloorToInt(fuel / (float)___m_fuelPerProduct), queueSize) : queueSize) * ___m_secPerProduct;
					sb.Append(FromSeconds((___m_fuelPerProduct == 0 || fuel / (float)___m_fuelPerProduct >= (float)queueSize) ? ((num2 - __instance.GetBakeTimer()) / num) : (___m_secPerProduct * fuel / (float)___m_fuelPerProduct)));
				}
				__result = Localization.instance.Localize(sb.ToString());
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "UpdateCharacterList")]
		private class FejdStartup_UpdateCharacterList_MainMenuStats
		{
			private static readonly StringBuilder sb = new StringBuilder();

			private static PlayerProfile playerProfile;

			private static int statCount = 0;

			private static string GetStatName(PlayerStatType stat)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				string name = Enum.GetName(typeof(PlayerStatType), stat);
				StringBuilder stringBuilder = new StringBuilder();
				string text = name;
				foreach (char c in text)
				{
					if (char.IsUpper(c) && stringBuilder.Length > 0)
					{
						stringBuilder.Append(' ');
					}
					stringBuilder.Append(c);
				}
				return stringBuilder.ToString();
			}

			private static void AddStat(PlayerStatType stat, string statName = "", bool showIfZero = false)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				if (playerProfile.m_playerStats.m_stats.ContainsKey(stat))
				{
					float num = playerProfile.m_playerStats.m_stats[stat];
					if (num != 0f || showIfZero)
					{
						sb.Append("\n");
						sb.Append(string.Format("{0}: {1}", (statName != "") ? statName : GetStatName(stat), num));
						statCount++;
					}
				}
			}

			private static void AddLine()
			{
				if (statCount > 0)
				{
					sb.Append("\n");
				}
				statCount = 0;
			}

			private static void Postfix(TMP_Text ___m_csSourceInfo, List<PlayerProfile> ___m_profiles, int ___m_profileIndex, GameObject ___m_playerInstance)
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Invalid comparison between Unknown and I4
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				if (!modEnabled.Value || !statsMainMenu.Value || !Object.op_Implicit((Object)(object)___m_playerInstance))
				{
					return;
				}
				playerProfile = ___m_profiles[___m_profileIndex];
				sb.Append(Localization.instance.Localize((((int)playerProfile.m_fileSource == 3) ? "$menu_legacynotice \n\n" : "") + ((!FileHelpers.CloudStorageEnabled) ? "$menu_cloudsavesdisabled" : "")));
				if (statsMainMenuAll.Value)
				{
					((Component)___m_csSourceInfo.transform).GetComponent<RectTransform>().anchorMax = Vector2.one;
					___m_csSourceInfo.transform.localPosition = new Vector3(___m_csSourceInfo.transform.localPosition.x, 0f, ___m_csSourceInfo.transform.localPosition.z);
					foreach (PlayerStatType value in Enum.GetValues(typeof(PlayerStatType)))
					{
						AddStat(value);
					}
				}
				else
				{
					AddStat((PlayerStatType)6, "Kills", showIfZero: true);
					AddStat((PlayerStatType)0, "", showIfZero: true);
					AddStat((PlayerStatType)1, "Crafts", showIfZero: true);
					AddStat((PlayerStatType)2, "", showIfZero: true);
					if (statsMainMenuAdvanced.Value)
					{
						AddLine();
						AddStat((PlayerStatType)8);
						AddStat((PlayerStatType)9);
						AddStat((PlayerStatType)85);
						AddStat((PlayerStatType)96);
						AddLine();
						AddStat((PlayerStatType)3);
						AddStat((PlayerStatType)4);
						AddStat((PlayerStatType)23);
						AddStat((PlayerStatType)49);
						AddLine();
						AddStat((PlayerStatType)28);
						AddStat((PlayerStatType)36);
						AddStat((PlayerStatType)38);
						AddStat((PlayerStatType)76);
						AddStat((PlayerStatType)77);
						AddStat((PlayerStatType)48);
						AddLine();
						AddStat((PlayerStatType)50);
						AddStat((PlayerStatType)15);
						AddStat((PlayerStatType)51);
						AddStat((PlayerStatType)52);
						AddStat((PlayerStatType)53);
					}
				}
				___m_csSourceInfo.text = sb.ToString();
				sb.Clear();
			}
		}

		[HarmonyPatch(typeof(Tameable), "GetHoverText")]
		private class Tameable_GetHoverText_Tameable
		{
			private static void Postfix(Tameable __instance, ZNetView ___m_nview, ref string __result)
			{
				if (!modEnabled.Value || hoverTame.Value == StationHover.Vanilla || !___m_nview.IsValid())
				{
					return;
				}
				if (!__instance.IsTamed())
				{
					if (__instance.m_tamingTime == 0f || !hoverTameTimeToTame.Value)
					{
						return;
					}
					float remainingTime = __instance.GetRemainingTime();
					if (remainingTime != __instance.m_tamingTime)
					{
						if (hoverTame.Value == StationHover.Percentage)
						{
							__result += Localization.instance.Localize($"\n$hud_tame: {(__instance.m_tamingTime - remainingTime) / __instance.m_tamingTime:P0}");
						}
						else if (hoverTame.Value == StationHover.Bar)
						{
							__result += Localization.instance.Localize("\n$hud_tame: \n" + FromPercent((__instance.m_tamingTime - remainingTime) / __instance.m_tamingTime));
						}
						else if (hoverTame.Value == StationHover.MinutesSeconds)
						{
							__result += Localization.instance.Localize("\n$hud_tame: " + FromSeconds(remainingTime));
						}
					}
				}
				else
				{
					if (!hoverTameTimeToFed.Value)
					{
						return;
					}
					DateTime dateTime = new DateTime(___m_nview.GetZDO().GetLong(ZDOVars.s_tameLastFeeding, 0L));
					double totalSeconds = (ZNet.instance.GetTime() - dateTime).TotalSeconds;
					if (!(totalSeconds >= (double)__instance.m_fedDuration))
					{
						double num = (double)__instance.m_fedDuration - totalSeconds;
						if (hoverTame.Value == StationHover.Percentage)
						{
							__result += Localization.instance.Localize($"\n$hud_tamehappy: {num / (double)__instance.m_fedDuration:P0}");
						}
						else if (hoverTame.Value == StationHover.Bar)
						{
							__result += Localization.instance.Localize("\n$hud_tamehappy: \n" + FromPercent(num / (double)__instance.m_fedDuration));
						}
						else if (hoverTame.Value == StationHover.MinutesSeconds)
						{
							__result += Localization.instance.Localize("\n$hud_tamehappy: " + FromSeconds(num));
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(Character), "GetHoverText")]
		private class Character_GetHoverText_GrowUpDevelopment
		{
			private static void Postfix(Character __instance, ZNetView ___m_nview, ref string __result)
			{
				if (!modEnabled.Value || !___m_nview.IsValid())
				{
					return;
				}
				Growup val = default(Growup);
				if (hoverCharacter.Value != 0 && hoverCharacterGrowth.Value && ((Component)__instance).TryGetComponent<Growup>(ref val) && val.m_growTime != 0f)
				{
					double totalSeconds = val.m_baseAI.GetTimeSinceSpawned().TotalSeconds;
					if (totalSeconds <= (double)val.m_growTime)
					{
						string name = ((Object)val.GetPrefab()).name;
						if (!characterNames.ContainsKey(name))
						{
							characterNames.Add(name, val.GetPrefab().GetComponent<Character>()?.m_name);
						}
						switch (hoverCharacter.Value)
						{
						case StationHover.Percentage:
							__result += $"\n{Localization.instance.Localize(characterNames[name])}: {totalSeconds / (double)val.m_growTime:P0}";
							break;
						case StationHover.Bar:
							__result = __result + "\n" + Localization.instance.Localize(characterNames[name]) + ": \n" + FromPercent(totalSeconds / (double)val.m_growTime);
							break;
						case StationHover.MinutesSeconds:
							__result = __result + "\n" + Localization.instance.Localize(characterNames[name]) + ": " + FromSeconds((double)val.m_growTime - totalSeconds);
							break;
						}
					}
				}
				Procreation val2 = default(Procreation);
				if (!((Component)__instance).TryGetComponent<Procreation>(ref val2))
				{
					return;
				}
				if (hoverCharacter.Value != 0 && hoverCharacterProcreation.Value && val2.IsPregnant())
				{
					long @long = ___m_nview.GetZDO().GetLong(ZDOVars.s_pregnant, 0L);
					double totalSeconds2 = (ZNet.instance.GetTime() - new DateTime(@long)).TotalSeconds;
					if (totalSeconds2 <= (double)val2.m_pregnancyDuration)
					{
						string name2 = ((Object)val2.m_offspring).name;
						if (!characterNames.ContainsKey(name2))
						{
							characterNames.Add(name2, val2.m_offspring.GetComponent<Character>()?.m_name);
						}
						switch (hoverCharacter.Value)
						{
						case StationHover.Percentage:
							__result += $"\n{Localization.instance.Localize(characterNames[name2])}: {totalSeconds2 / (double)val2.m_pregnancyDuration:P0}";
							break;
						case StationHover.Bar:
							__result = __result + "\n" + Localization.instance.Localize(characterNames[name2]) + ": \n" + FromPercent(totalSeconds2 / (double)val2.m_pregnancyDuration);
							break;
						case StationHover.MinutesSeconds:
							__result = __result + "\n" + Localization.instance.Localize(characterNames[name2]) + ": " + FromSeconds((double)val2.m_pregnancyDuration - totalSeconds2);
							break;
						}
					}
				}
				if (hoverCharacterLovePoints.Value && val2.m_requiredLovePoints > 0)
				{
					Tameable tameable = val2.m_tameable;
					if (tameable != null && tameable.IsTamed())
					{
						__result = __result + "\n" + GetBar(val2.GetLovePoints(), val2.m_requiredLovePoints, '♥');
					}
				}
			}
		}

		[HarmonyPatch(typeof(EggGrow), "GetHoverText")]
		private class EggGrow_GetHoverText_EggGrow
		{
			private static void Postfix(EggGrow __instance, ItemDrop ___m_item, ZNetView ___m_nview, ref string __result)
			{
				if (!modEnabled.Value || hoverCharacter.Value == StationHover.Vanilla || !Object.op_Implicit((Object)(object)___m_item) || !Object.op_Implicit((Object)(object)___m_nview) || !___m_nview.IsValid())
				{
					return;
				}
				float @float = ___m_nview.GetZDO().GetFloat(ZDOVars.s_growStart, 0f);
				bool flag = @float > 0f;
				if (!(hoverCharacterEggGrow.Value && flag))
				{
					return;
				}
				double num = ZNet.instance.GetTimeSeconds() - (double)@float;
				if (!(num > (double)__instance.m_growTime))
				{
					GameObject grownPrefab = __instance.m_grownPrefab;
					string name = ((Object)grownPrefab).name;
					if (!characterNames.ContainsKey(name))
					{
						characterNames.Add(name, grownPrefab.GetComponent<Character>()?.m_name);
					}
					switch (hoverCharacter.Value)
					{
					case StationHover.Percentage:
						__result += $"\n{Localization.instance.Localize(characterNames[name])}: {num / (double)__instance.m_growTime:P0}";
						break;
					case StationHover.Bar:
						__result = __result + "\n" + Localization.instance.Localize(characterNames[name]) + ": \n" + FromPercent(num / (double)__instance.m_growTime);
						break;
					case StationHover.MinutesSeconds:
						__result = __result + "\n" + Localization.instance.Localize(characterNames[name]) + ": " + FromSeconds((double)__instance.m_growTime - num);
						break;
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "SetupRequirement")]
		public static class InventoryGui_SetupRequirement_AddAvailableAmount
		{
			public static void Postfix(Transform elementRoot, Requirement req, Player player, bool __result)
			{
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				if (modEnabled.Value && showAvailableItemsAmount.Value && __result && !UnityInput.Current.GetKey((KeyCode)308) && !UnityInput.Current.GetKey((KeyCode)307))
				{
					Transform obj = ((Component)elementRoot).transform.Find("res_amount");
					TMP_Text val = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
					if (int.TryParse(val.text, out var _) && val != null)
					{
						val.SetText(val.text + $" <color=#{ColorUtility.ToHtmlStringRGBA(availableItemsAmountColor.Value)}>({((Humanoid)player).GetInventory().CountItems(req.m_resItem.m_itemData.m_shared.m_name, -1, true)})</color>");
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		public static class InventoryGui_Awake_AddAvailableAmount
		{
			public static void Postfix()
			{
				if (modEnabled.Value && inventoryOpenCloseAnimationSpeed.Value != 1f)
				{
					SetInventoryAnimationSpeed();
				}
			}
		}

		[HarmonyPatch(typeof(ZInput), "GetBoundKeyString")]
		public static class ZInput_GetBoundKeyString_NonlocalizedButtons
		{
			public static bool mapUpdated = false;

			public static readonly List<string> keyCodeValues = (from key in Enum.GetValues(typeof(Key)).OfType<Key>()
				where 15 <= (int)key && (int)key <= 40
				select ((object)(Key)(ref key)).ToString()).ToList();

			public static void OnChange()
			{
				mapUpdated = false;
			}

			public static void Prefix()
			{
				if (!modEnabled.Value || mapUpdated)
				{
					return;
				}
				mapUpdated = true;
				if (modEnabled.Value && nonlocalizedButtons.Value)
				{
					CollectionExtensions.Do<string>((IEnumerable<string>)keyCodeValues, (Action<string>)delegate(string key)
					{
						ZInput.s_keyLocalizationMap[key] = key;
					});
				}
				else
				{
					CollectionExtensions.Do<string>((IEnumerable<string>)keyCodeValues, (Action<string>)delegate(string key)
					{
						ZInput.s_keyLocalizationMap.Remove(key);
					});
				}
			}
		}

		[HarmonyPatch(typeof(Chat), "UpdateWorldTextField")]
		public static class Chat_UpdateWorldTextField_ChangeWorldTextColor
		{
			public static void Postfix(WorldTextInstance wt)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Invalid comparison between Unknown and I4
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Invalid comparison between Unknown and I4
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Invalid comparison between Unknown and I4
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Invalid comparison between Unknown and I4
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Invalid comparison between Unknown and I4
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0210: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: Unknown result type (might be due to invalid IL or missing references)
				if (!modEnabled.Value || !inworldTextChanges.Value)
				{
					return;
				}
				if ((int)wt.m_type == 2)
				{
					((Graphic)wt.m_textMeshField).color = inworldShoutColor.Value;
				}
				else if ((int)wt.m_type == 3)
				{
					((TMP_Text)wt.m_textMeshField).text = ((TMP_Text)wt.m_textMeshField).text.Replace("PING", Localization.instance.Localize(inworldPingText.Value));
					((Graphic)wt.m_textMeshField).color = inworldPingColor.Value;
				}
				else if ((int)wt.m_type == 0)
				{
					((Graphic)wt.m_textMeshField).color = inworldWhisperColor.Value;
				}
				else
				{
					((Graphic)wt.m_textMeshField).color = inworldDefaultColor.Value;
				}
				bool flag = inworldAddDarken.Value && ((int)wt.m_type == 2 || (int)wt.m_type == 3);
				if (!flag)
				{
					Transform val = wt.m_gui.transform.Find("Darken");
					if (val != null)
					{
						Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
						return;
					}
				}
				if (flag && wt.m_gui.transform.Find("Darken") == null)
				{
					InventoryGui instance = InventoryGui.instance;
					object obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						RectTransform player = instance.m_player;
						obj = ((player != null) ? ((Transform)player).Find("Darken") : null);
					}
					RectTransform val2 = (RectTransform)((obj is RectTransform) ? obj : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						RectTransform val3 = Object.Instantiate<RectTransform>(val2, wt.m_gui.transform);
						((Transform)val3).localPosition = wt.m_gui.transform.Find("Text").localPosition;
						((Object)val3).name = "Darken";
						((Transform)val3).localScale = ((Transform)val3).localScale * 0.7f;
						val3.sizeDelta = new Vector2(200f, 40f);
						((Transform)val3).SetAsFirstSibling();
						((Graphic)((Component)val3).GetComponent<Image>()).color = new Color(1f, 1f, 1f, inworldDarkenIntensity.Value);
					}
				}
			}
		}

		public const string pluginID = "shudnal.MyLittleUI";

		public const string pluginName = "My Little UI";

		public const string pluginVersion = "1.2.12";

		private readonly Harmony harmony = new Harmony("shudnal.MyLittleUI");

		internal static readonly ConfigSync configSync = new ConfigSync("shudnal.MyLittleUI")
		{
			DisplayName = "My Little UI",
			CurrentVersion = "1.2.12",
			MinimumRequiredVersion = "1.2.12"
		};

		public static MyLittleUI instance;

		public static ConfigEntry<bool> modEnabled;

		public static ConfigEntry<bool> configLocked;

		public static ConfigEntry<bool> loggingEnabled;

		public static ConfigEntry<bool> nonlocalizedButtons;

		public static ConfigEntry<bool> fixStatusEffectAndForecastPosition;

		public static ConfigEntry<bool> clockShowDay;

		public static ConfigEntry<bool> clockShowTime;

		public static ConfigEntry<bool> clockTimeFormat24h;

		public static ConfigEntry<bool> clockShowBackground;

		public static ConfigEntry<Color> clockBackgroundColor;

		public static ConfigEntry<float> clockTextPadding;

		public static ConfigEntry<Vector2> clockPosition;

		public static ConfigEntry<ElementAnchor> clockPositionAnchor;

		public static ConfigEntry<Vector2> clockSize;

		public static ConfigEntry<bool> clockSwapDayTime;

		public static ConfigEntry<float> clockFontSize;

		public static ConfigEntry<Color> clockFontColor;

		public static ConfigEntry<ClockTimeType> clockTimeType;

		public static ConfigEntry<string> clockFuzzy;

		public static ConfigEntry<string> clockFormatGameAndRealTime;

		public static ConfigEntry<bool> forecastEnabled;

		public static ConfigEntry<bool> forecastShowBackground;

		public static ConfigEntry<Color> forecastBackgroundColor;

		public static ConfigEntry<ElementAnchor> forecastPositionAnchor;

		public static ConfigEntry<Vector2> forecastPosition;

		public static ConfigEntry<Vector2> forecastPositionNomap;

		public static ConfigEntry<Vector2> forecastSize;

		public static ConfigEntry<float> forecastFontSize;

		public static ConfigEntry<Color> forecastFontColor;

		public static ConfigEntry<float> forecastTextPadding;

		public static ConfigEntry<string> forecastListRain;

		public static ConfigEntry<string> forecastListSnow;

		public static ConfigEntry<string> forecastListThunder;

		public static ConfigEntry<string> forecastListMist;

		public static ConfigEntry<string> forecastListRainCinder;

		public static ConfigEntry<bool> windsEnabled;

		public static ConfigEntry<bool> windsShowBackground;

		public static ConfigEntry<bool> windsShowProgress;

		public static ConfigEntry<Color> windsBackgroundColor;

		public static ConfigEntry<Color> windsProgressColor;

		public static ConfigEntry<Color> windsArrowColor;

		public static ConfigEntry<float> windsMinimumAlpha;

		public static ConfigEntry<bool> windsAlphaIntensity;

		public static ConfigEntry<ElementAnchor> windsPositionAnchor;

		public static ConfigEntry<Vector2> windsPosition;

		public static ConfigEntry<Vector2> windsPositionNomap;

		public static ConfigEntry<Vector2> windsSize;

		public static ConfigEntry<Vector2> windsSizeNomap;

		public static ConfigEntry<int> windsCount;

		public static ConfigEntry<int> windsCountNomap;

		public static ConfigEntry<float> windsPositionSpacing;

		public static ConfigEntry<float> windsPositionSpacingNomap;

		public static ConfigEntry<ListDirection> windsFillingDirection;

		public static ConfigEntry<ListDirection> windsFillingDirectionNomap;

		public static ConfigEntry<bool> ammoCountEnabled;

		public static ConfigEntry<Color> ammoCountColor;

		public static ConfigEntry<Vector2> ammoCountPosition;

		public static ConfigEntry<int> ammoCountFontSize;

		public static ConfigEntry<HorizontalAlignmentOptions> ammoCountAlignment;

		public static ConfigEntry<bool> ammoIconEnabled;

		public static ConfigEntry<Vector2> ammoIconPosition;

		public static ConfigEntry<Vector2> ammoIconSize;

		public static ConfigEntry<bool> baitIconEnabled;

		public static ConfigEntry<bool> baitCountEnabled;

		public static ConfigEntry<bool> meadIconEnabled;

		public static ConfigEntry<bool> showAvailableItemsAmount;

		public static ConfigEntry<Color> availableItemsAmountColor;

		public static ConfigEntry<bool> showMulticraftButtons;

		public static ConfigEntry<bool> craftingFilterEnabled;

		public static ConfigEntry<bool> craftingSortingEnabled;

		public static ConfigEntry<bool> craftingNewMarkEnabled;

		public static ConfigEntry<bool> craftingNewMarkShowOnlyWithUnlocks;

		public static ConfigEntry<string> craftingNewMarkText;

		public static ConfigEntry<Color> craftingNewMarkColor;

		public static ConfigEntry<float> craftingNewMarkFontSize;

		public static ConfigEntry<FontStyles> craftingNewMarkFontStyle;

		public static ConfigEntry<bool> durabilityEnabled;

		public static ConfigEntry<Color> durabilityFine;

		public static ConfigEntry<Color> durabilityWorn;

		public static ConfigEntry<Color> durabilityAtRisk;

		public static ConfigEntry<Color> durabilityBroken;

		public static ConfigEntry<float> itemIconScale;

		public static ConfigEntry<Color> itemEquippedColor;

		public static ConfigEntry<bool> itemTooltip;

		public static ConfigEntry<bool> itemTooltipColored;

		public static ConfigEntry<float> itemTooltipRecipeFontSize;

		public static ConfigEntry<bool> itemQuality;

		public static ConfigEntry<string> itemQualitySymbol;

		public static ConfigEntry<Color> itemQualitySymbolColor;

		public static ConfigEntry<float> itemQualitySymbolSize;

		public static ConfigEntry<int> itemQualityMax;

		public static ConfigEntry<int> itemQualityRows;

		public static ConfigEntry<int> itemQualityColumns;

		public static ConfigEntry<float> itemQualityLineSpacing;

		public static ConfigEntry<float> itemQualityCharacterSpacing;

		public static ConfigEntry<bool> itemQualityIgnoreCustomEquipmentSlots;

		public static ConfigEntry<bool> itemQualityIgnoreCustomSlots;

		public static ConfigEntry<bool> itemQualityHideLvl1;

		public static ConfigEntry<bool> itemQualityHideCustomEquipmentSlots;

		public static ConfigEntry<float> inventoryOpenCloseAnimationSpeed;

		public static ConfigEntry<bool> inventoryHideLongStack;

		public static ConfigEntry<bool> inventoryEnableRepairOnHold;

		public static ConfigEntry<bool> statsMainMenu;

		public static ConfigEntry<bool> statsMainMenuAdvanced;

		public static ConfigEntry<bool> statsMainMenuAll;

		public static ConfigEntry<bool> statsCharacterArmor;

		public static ConfigEntry<bool> statsCharacterEffects;

		public static ConfigEntry<bool> hoverFermenterEnabled;

		public static ConfigEntry<bool> hoverPlantEnabled;

		public static ConfigEntry<bool> hoverPickableEnabled;

		public static ConfigEntry<bool> hoverCookingEnabled;

		public static ConfigEntry<bool> hoverBeeHiveEnabled;

		public static ConfigEntry<StationHover> hoverFermenter;

		public static ConfigEntry<StationHover> hoverPlant;

		public static ConfigEntry<StationHover> hoverPickable;

		public static ConfigEntry<StationHover> hoverCooking;

		public static ConfigEntry<StationHover> hoverBeeHive;

		public static ConfigEntry<bool> hoverBeeHiveTotal;

		public static ConfigEntry<bool> hoverCookingNextItem;

		public static ConfigEntry<bool> hoverCookingRemoveLastItem;

		public static ConfigEntry<bool> hoverStumpGrowerEnabled;

		public static ConfigEntry<StationHover> hoverStumpGrower;

		public static ConfigEntry<StationHover> hoverCharacter;

		public static ConfigEntry<bool> hoverCharacterGrowth;

		public static ConfigEntry<bool> hoverCharacterProcreation;

		public static ConfigEntry<bool> hoverCharacterEggGrow;

		public static ConfigEntry<bool> hoverCharacterLovePoints;

		public static ConfigEntry<StationHover> hoverTame;

		public static ConfigEntry<bool> hoverTameTimeToTame;

		public static ConfigEntry<bool> hoverTameTimeToFed;

		public static ConfigEntry<bool> hoverSmelterEstimatedTime;

		public static ConfigEntry<bool> hoverSmelterShowFuelAndItem;

		public static ConfigEntry<bool> hoverSmelterShowQueuedItems;

		public static ConfigEntry<bool> hoverSmelterHoldToAddSeveral;

		public static ConfigEntry<ChestItemsHover> chestHoverItems;

		public static ConfigEntry<ChestNameHover> chestHoverName;

		public static ConfigEntry<bool> chestCustomName;

		public static ConfigEntry<bool> chestShowHoldToStack;

		public static ConfigEntry<bool> chestShowRename;

		public static ConfigEntry<bool> chestContentEnabled;

		public static ConfigEntry<int> chestContentLinesToShow;

		public static ConfigEntry<ContentSortType> chestContentSortType;

		public static ConfigEntry<ContentSortDir> chestContentSortDir;

		public static ConfigEntry<string> chestContentEntryFormat;

		public static ConfigEntry<Color> chestContentItemColor;

		public static ConfigEntry<Color> chestContentAmountColor;

		public static ConfigEntry<bool> statusEffectsPositionEnabled;

		public static ConfigEntry<Vector2> statusEffectsPositionAnchor;

		public static ConfigEntry<ListDirection> statusEffectsFillingDirection;

		public static ConfigEntry<int> statusEffectsPositionSpacing;

		public static ConfigEntry<bool> statusEffectsElementEnabled;

		public static ConfigEntry<int> statusEffectsElementSize;

		public static ConfigEntry<bool> statusEffectsPositionEnabledNomap;

		public static ConfigEntry<Vector2> statusEffectsPositionAnchorNomap;

		public static ConfigEntry<ListDirection> statusEffectsFillingDirectionNomap;

		public static ConfigEntry<int> statusEffectsPositionSpacingNomap;

		public static ConfigEntry<bool> statusEffectsElementEnabledNomap;

		public static ConfigEntry<int> statusEffectsElementSizeNomap;

		public static ConfigEntry<bool> sailingIndicatorEnabled;

		public static ConfigEntry<Vector2> sailingIndicatorPowerIconPosition;

		public static ConfigEntry<float> sailingIndicatorPowerIconScale;

		public static ConfigEntry<Vector2> sailingIndicatorWindIndicatorPosition;

		public static ConfigEntry<float> sailingIndicatorWindIndicatorScale;

		public static ConfigEntry<bool> sailingIndicatorEnabledNomap;

		public static ConfigEntry<Vector2> sailingIndicatorPowerIconPositionNomap;

		public static ConfigEntry<float> sailingIndicatorPowerIconScaleNomap;

		public static ConfigEntry<Vector2> sailingIndicatorWindIndicatorPositionNomap;

		public static ConfigEntry<float> sailingIndicatorWindIndicatorScaleNomap;

		public static ConfigEntry<bool> showWeight;

		public static ConfigEntry<bool> showSlots;

		public static ConfigEntry<Color> weightBackgroundColor;

		public static ConfigEntry<Color> slotsBackgroundColor;

		public static ConfigEntry<bool> showWeightLeft;

		public static ConfigEntry<bool> showSlotsTaken;

		public static ConfigEntry<Color> weightSlotsFine;

		public static ConfigEntry<Color> weightSlotsHalf;

		public static ConfigEntry<Color> weightSlotsALot;

		public static ConfigEntry<Color> weightSlotsFull;

		public static ConfigEntry<Vector2> weightPosition;

		public static ConfigEntry<Vector2> slotsPosition;

		public static ConfigEntry<ElementAnchor> weightPositionAnchor;

		public static ConfigEntry<ElementAnchor> slotsPositionAnchor;

		public static ConfigEntry<Color> weightFontColor;

		public static ConfigEntry<Color> slotsFontColor;

		public static ConfigEntry<bool> inworldTextChanges;

		public static ConfigEntry<Color> inworldDefaultColor;

		public static ConfigEntry<Color> inworldWhisperColor;

		public static ConfigEntry<Color> inworldShoutColor;

		public static ConfigEntry<Color> inworldPingColor;

		public static ConfigEntry<string> inworldPingText;

		public static ConfigEntry<bool> inworldAddDarken;

		public static ConfigEntry<float> inworldDarkenIntensity;

		private static readonly Dictionary<string, string> characterNames = new Dictionary<string, string>();

		public static Assembly epicLootAssembly;

		public static readonly int layerUI = LayerMask.NameToLayer("UI");

		public static readonly bool AAA_Crafting = Chainloader.PluginInfos.ContainsKey("Azumatt.AzuAntiArthriticCrafting");

		public static readonly bool ZenUI = Chainloader.PluginInfos.ContainsKey("ZenDragon.ZenUI");

		public static readonly bool Jewelcrafting = Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.jewelcrafting");

		public static Sprite GetJewelcraftingIcon()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			if (!Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.jewelcrafting", out var value))
			{
				return null;
			}
			object value2 = AccessTools.Field(Assembly.GetAssembly(((object)value.Instance).GetType()).GetType("Jewelcrafting.Jewelcrafting"), "jewelcrafting").GetValue(null);
			if (value2 == null)
			{
				return null;
			}
			FieldInfo fieldInfo = AccessTools.Field(value2.GetType(), "skillDef");
			if (fieldInfo == null)
			{
				return null;
			}
			return ((SkillDef)fieldInfo.GetValue(value2))?.m_icon;
		}

		private void Awake()
		{
			instance = this;
			ConfigInit();
			configSync.AddLockingConfigEntry<bool>(configLocked);
			if (Chainloader.PluginInfos.TryGetValue("randyknapp.mods.epicloot", out var value) && (object)epicLootAssembly == null)
			{
				epicLootAssembly = Assembly.GetAssembly(((object)value.Instance).GetType());
			}
			ItemTooltip.Initialize();
			LoadIcons();
			Game.isModded = true;
			harmony.PatchAll();
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}

		public static void LogInfo(object data)
		{
			if (loggingEnabled.Value)
			{
				((BaseUnityPlugin)instance).Logger.LogInfo(data);
			}
		}

		private void ConfigInit()
		{
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0592: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_066c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0928: Unknown result type (might be due to invalid IL or missing references)
			//IL_0964: Unknown result type (might be due to invalid IL or missing references)
			//IL_0984: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c5a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c84: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e8e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eb8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f37: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f61: Unknown result type (might be due to invalid IL or missing references)
			//IL_11ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_1327: Unknown result type (might be due to invalid IL or missing references)
			//IL_1485: Unknown result type (might be due to invalid IL or missing references)
			//IL_14b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_14ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_1521: Unknown result type (might be due to invalid IL or missing references)
			//IL_1609: Unknown result type (might be due to invalid IL or missing references)
			//IL_16fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ec8: Unknown result type (might be due to invalid IL or missing references)
			//IL_1efc: Unknown result type (might be due to invalid IL or missing references)
			//IL_2068: Unknown result type (might be due to invalid IL or missing references)
			//IL_21c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_2211: Unknown result type (might be due to invalid IL or missing references)
			//IL_2349: Unknown result type (might be due to invalid IL or missing references)
			//IL_24a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_24f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_2651: Unknown result type (might be due to invalid IL or missing references)
			//IL_2685: Unknown result type (might be due to invalid IL or missing references)
			//IL_2745: Unknown result type (might be due to invalid IL or missing references)
			//IL_2779: Unknown result type (might be due to invalid IL or missing references)
			//IL_27ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_27e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_28eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_2915: Unknown result type (might be due to invalid IL or missing references)
			//IL_2949: Unknown result type (might be due to invalid IL or missing references)
			//IL_297d: Unknown result type (might be due to invalid IL or missing references)
			//IL_2997: Unknown result type (might be due to invalid IL or missing references)
			//IL_29a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_29d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_29e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_29c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_2a31: Unknown result type (might be due to invalid IL or missing references)
			//IL_2a65: Unknown result type (might be due to invalid IL or missing references)
			//IL_2a85: Unknown result type (might be due to invalid IL or missing references)
			//IL_2ab9: Unknown result type (might be due to invalid IL or missing references)
			//IL_29ff: Unknown result type (might be due to invalid IL or missing references)
			((BaseUnityPlugin)this).Config.Bind<int>("General", "NexusID", 2562, "Nexus mod ID for updates");
			modEnabled = config("General", "Enabled", defaultValue: true, "Enable the mod. [Synced with Server]", synchronizedSetting: true);
			configLocked = config("General", "Lock Configuration", defaultValue: true, "Configuration is locked and can be changed by server admins only. [Synced with Server]", synchronizedSetting: true);
			loggingEnabled = config("General", "Logging enabled", defaultValue: false, "Enable logging.");
			nonlocalizedButtons = config("General", "Nonlocalized button keys", defaultValue: true, "Keyboard keys A-Z will not be localized in the current keyboard layout. If changed while in game then time should pass for some cached localization strings to be cleared.");
			fixStatusEffectAndForecastPosition = config("General", "Status effects and forecast position fix", defaultValue: true, "If status effect position was not changed prior to 1.0.11 version - fix status effect list position for forecast.");
			modEnabled.SettingChanged += delegate
			{
				InfoBlocks.UpdateVisibility();
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
				CustomStatusEffectsList.ChangeSailingIndicator();
				ZInput_GetBoundKeyString_NonlocalizedButtons.OnChange();
			};
			nonlocalizedButtons.SettingChanged += delegate
			{
				ZInput_GetBoundKeyString_NonlocalizedButtons.OnChange();
			};
			clockShowDay = config("Info - Clock", "Show day", defaultValue: true, "Enable day number [Synced with Server]", synchronizedSetting: true);
			clockShowTime = config("Info - Clock", "Show time", defaultValue: true, "Enable time [Synced with Server]", synchronizedSetting: true);
			clockTimeFormat24h = config("Info - Clock", "Time format 24h", defaultValue: true, "Show time in HH:mm format");
			clockShowBackground = config("Info - Clock", "Background enabled", defaultValue: false, "Show clock background");
			clockBackgroundColor = config<Color>("Info - Clock", "Background color", Color.clear, "Clock background color. If not set - minimap background color is used.");
			clockTextPadding = config("Info - Clock", "Padding", 5f, "Left and right indentation for text if both time and day used");
			clockPosition = config<Vector2>("Info - Clock", "Position", new Vector2(-140f, -25f), "anchoredPosition of clock object transform");
			clockPositionAnchor = config("Info - Clock", "Position Anchor", ElementAnchor.TopRight, "Anchor point of clock object transform");
			clockSize = config<Vector2>("Info - Clock", "Size", new Vector2(200f, 25f), "sizeDelta of clock object transform");
			clockSwapDayTime = config("Info - Clock", "Swap day and time", defaultValue: false, "Swap day and time positions");
			clockFontSize = config("Info - Clock", "Font size", 0f, "If not set - value is taken from minimap small biome label");
			clockFontColor = config<Color>("Info - Clock", "Font color", Color.clear, "If not set - value is taken from minimap small biome label");
			clockTimeType = config("Info - Clock", "Time type", ClockTimeType.GameTime, "Time to show");
			clockFuzzy = config("Info - Clock", "Time fuzzy words", "Midnight,Early Morning,Before Dawn,Dawn,Morning,Late Morning,Midday,Early Afternoon,Afternoon,Evening,Night,Late Night", "The length of the day will be divided into equal periods of time according to the number of words specified.");
			clockFormatGameAndRealTime = config("Info - Clock", "Time format game and real time", "{0} ({1})", "String format for GameAndRealTime time type. Where {0} is game time and {1} is real time");
			clockShowBackground.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeBackground();
			};
			clockBackgroundColor.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeBackground();
			};
			clockShowDay.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockShowTime.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockTextPadding.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockPosition.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockPositionAnchor.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockSize.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockSwapDayTime.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockFontSize.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockFontColor.SettingChanged += delegate
			{
				InfoBlocks.UpdateDayTimeText();
			};
			clockTimeFormat24h.SettingChanged += delegate
			{
				InfoBlocks.UpdateClock();
			};
			clockTimeType.SettingChanged += delegate
			{
				InfoBlocks.UpdateClock();
			};
			clockFuzzy.SettingChanged += delegate
			{
				InfoBlocks.FuzzyWordsOnChange();
			};
			clockFormatGameAndRealTime.SettingChanged += delegate
			{
				InfoBlocks.UpdateClock();
			};
			forecastEnabled = config("Info - Forecast", "Enabled", defaultValue: true, "Enable next change of weather [Synced with Server]", synchronizedSetting: true);
			forecastShowBackground = config("Info - Forecast", "Weather background enabled", defaultValue: false, "Show forecast background");
			forecastBackgroundColor = config<Color>("Info - Forecast", "Weather background color", Color.clear, "Forecast background color. If not set - minimap background color is used.");
			forecastPositionAnchor = config("Info - Forecast", "Position Anchor", ElementAnchor.TopRight, "Anchor point of forecast object transform");
			forecastPosition = config<Vector2>("Info - Forecast", "Position", new Vector2(-78f, -255f), "anchoredPosition of forecast object transform");
			forecastPositionNomap = config<Vector2>("Info - Forecast", "Position in nomap", new Vector2(-78f, -55f), "anchoredPosition of forecast object transform in nomap mode");
			forecastSize = config<Vector2>("Info - Forecast", "Size", new Vector2(75f, 25f), "sizeDelta of forecast object transform");
			forecastFontSize = config("Info - Forecast", "Font size", 0f, "If not set - value is taken from minimap small biome label");
			forecastFontColor = config<Color>("Info - Forecast", "Font color", Color.clear, "If not set - value is taken from minimap small biome label");
			forecastTextPadding = config("Info - Forecast", "Text padding", 2f, "Margin between icon and text");
			forecastShowBackground.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBackground();
			};
			forecastBackgroundColor.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBackground();
			};
			forecastEnabled.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBlock();
			};
			forecastPositionAnchor.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBlock();
			};
			forecastPosition.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBlock();
			};
			forecastPositionNomap.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBlock();
			};
			forecastSize.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBlock();
			};
			forecastFontSize.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBlock();
			};
			forecastFontColor.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBlock();
			};
			forecastTextPadding.SettingChanged += delegate
			{
				InfoBlocks.UpdateForecastBlock();
			};
			forecastListRain = config("Info - Forecast - Lists", "Rain", "Rain,LightRain,MistlandsRain,SlimeRain", "Comma separated list of m_psySystems or m_envObject names associated with Rain environments");
			forecastListSnow = config("Info - Forecast - Lists", "Snow", "SnowStorm", "Comma separated list of m_psySystems or m_envObject names associated with Snow environments");
			forecastListThunder = config("Info - Forecast - Lists", "Thunder", "Thunder,MistlandsThunder,AshlandsThunder", "Comma separated list of m_psySystems or m_envObject names associated with Thunder environments");
			forecastListMist = config("Info - Forecast - Lists", "Mist", "Mist,Ashlands_Misty", "Comma separated list of m_psySystems or m_envObject names associated with Mist environments");
			forecastListRainCinder = config("Info - Forecast - Lists", "Ash Rain", "Ashlands_RainCinder,Ashlands_CinderRain", "Comma separated list of m_psySystems or m_envObject names associated with Ash Cinder Rain environments");
			windsEnabled = config("Info - Winds", "Enabled", defaultValue: true, "Enable next winds [Synced with Server]", synchronizedSetting: true);
			windsShowBackground = config("Info - Winds", "Winds background enabled", defaultValue: true, "Show winds background");
			windsBackgroundColor = config<Color>("Info - Winds", "Winds background color", Color.clear, "Winds background color. If not set - minimap background color is used.");
			windsShowProgress = config("Info - Winds", "Progress enabled", defaultValue: true, "Show winds progress");
			windsProgressColor = config<Color>("Info - Winds", "Progress color", Color.clear, "Winds progress color. If not set - minimap background color is used.");
			windsArrowColor = config<Color>("Info - Winds", "Winds arrow color", Color.white, "Winds arrow color.");
			windsMinimumAlpha = config("Info - Winds", "Minimum wind arrow alpha", 0.5f, "Amount of winds to forecast");
			windsAlphaIntensity = config("Info - Winds", "Set wind arrow alpha as intensity", defaultValue: true, "If enabled - wind arrow will be more transparent with less wind intensity");
			windsShowBackground.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBackground();
			};
			windsBackgroundColor.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBackground();
			};
			windsShowProgress.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBackground();
			};
			windsProgressColor.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBackground();
			};
			windsEnabled.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBlock();
			};
			windsArrowColor.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBlock();
			};
			windsMinimumAlpha.SettingChanged += delegate
			{
				WeatherForecast.UpdateNextWinds(forceRebuildList: true);
			};
			windsAlphaIntensity.SettingChanged += delegate
			{
				WeatherForecast.UpdateNextWinds(forceRebuildList: true);
			};
			windsCount = config("Info - Winds - List", "Wind arrows amount", 5, "Amount of winds to forecast");
			windsFillingDirection = config("Info - Winds - List", "Direction", ListDirection.LeftToRight, "Direction of filling");
			windsPositionSpacing = config("Info - Winds - List", "Spacing", 1f, "Spacing between arrows");
			windsPositionAnchor = config("Info - Winds - List", "Position Anchor", ElementAnchor.TopRight, "Anchor point of winds object transform");
			windsPosition = config<Vector2>("Info - Winds - List", "Position", new Vector2(-180f, -255f), "anchoredPosition of winds object transform");
			windsSize = config<Vector2>("Info - Winds - List", "Size", new Vector2(119f, 25f), "sizeDelta of winds object transform");
			windsCountNomap = config("Info - Winds - List", "Nomap Wind arrows amount", 5, "Amount of winds to forecast");
			windsFillingDirectionNomap = config("Info - Winds - List", "Nomap Direction", ListDirection.LeftToRight, "Direction of filling");
			windsPositionSpacingNomap = config("Info - Winds - List", "Nomap Spacing", 1f, "Spacing between arrows");
			windsPositionNomap = config<Vector2>("Info - Winds - List", "Nomap Position", new Vector2(-180f, -55f), "anchoredPosition of winds object transform in nomap mode");
			windsSizeNomap = config<Vector2>("Info - Winds - List", "Nomap Size", new Vector2(119f, 25f), "sizeDelta of winds object transform");
			windsPositionAnchor.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBlock();
			};
			windsPosition.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBlock();
			};
			windsPositionNomap.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBlock();
			};
			windsSize.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBlock(forceRebuildList: true);
			};
			windsSizeNomap.SettingChanged += delegate
			{
				InfoBlocks.UpdateWindsBlock(forceRebuildList: true);
			};
			windsCount.SettingChanged += delegate
			{
				WeatherForecast.UpdateNextWinds();
			};
			windsCountNomap.SettingChanged += delegate
			{
				WeatherForecast.UpdateNextWinds();
			};
			windsFillingDirection.SettingChanged += delegate
			{
				WeatherForecast.UpdateNextWinds(forceRebuildList: true);
			};
			windsFillingDirectionNomap.SettingChanged += delegate
			{
				WeatherForecast.UpdateNextWinds(forceRebuildList: true);
			};
			windsPositionSpacing.SettingChanged += delegate
			{
				WeatherForecast.UpdateNextWinds(forceRebuildList: true);
			};
			windsPositionSpacingNomap.SettingChanged += delegate
			{
				WeatherForecast.UpdateNextWinds(forceRebuildList: true);
			};
			ammoCountEnabled = config("Item - Ammo icon and count", "Ammo count Enabled", defaultValue: true, "Show amount of available ammo and ammo icon for weapon in hotbar  [Synced with Server]", synchronizedSetting: true);
			ammoCountColor = config<Color>("Item - Ammo icon and count", "Ammo count Color", Color.clear, "Color of available ammo for weapon in hotbar");
			ammoCountPosition = config<Vector2>("Item - Ammo icon and count", "Ammo count Position", new Vector2(0f, -14f), "Position of available ammo for weapon in hotbar");
			ammoCountFontSize = config("Item - Ammo icon and count", "Ammo count FontSize", 14, "Show amount of available ammo and ammo icon for weapon in hotbar");
			ammoCountAlignment = config<HorizontalAlignmentOptions>("Item - Ammo icon and count", "Ammo count Alignment", (HorizontalAlignmentOptions)2, "Text horizontal alignment of available ammo for weapon in hotbar");
			ammoIconEnabled = config("Item - Ammo icon and count", "Ammo icon Enabled", defaultValue: true, "Show icon of available ammo for weapon in hotbar [Synced with Server]", synchronizedSetting: true);
			ammoIconPosition = config<Vector2>("Item - Ammo icon and count", "Ammo icon Position", new Vector2(0f, -40f), "Position of ammo icon for weapon in hotbar");
			ammoIconSize = config<Vector2>("Item - Ammo icon and count", "Ammo icon Size", new Vector2(-10f, -10f), "Ammo icon for weapon in hotbar");
			baitIconEnabled = config("Item - Ammo icon and count", "Bait icon Enabled", defaultValue: true, "Show amount of available bait and bait icon for weapon in hotbar [Synced with Server]", synchronizedSetting: true);
			baitCountEnabled = config("Item - Ammo icon and count", "Bait ammo Enabled", defaultValue: true, "Show amount of available ammo and ammo icon for weapon in hotbar [Synced with Server]", synchronizedSetting: true);
			meadIconEnabled = config("Item - Ammo icon and count", "Mead icon Enabled", defaultValue: true, "Show mead icon for weapon in hotbar [Synced with Server]", synchronizedSetting: true);
			ammoCountEnabled.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			ammoCountColor.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			ammoCountPosition.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			ammoCountFontSize.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			ammoCountAlignment.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			ammoIconEnabled.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			ammoIconPosition.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			ammoIconSize.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			baitIconEnabled.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			baitCountEnabled.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			meadIconEnabled.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			showAvailableItemsAmount = config("Item - Available resources amount", "Enabled", defaultValue: true, "Show amount of available resources for crafting in requirements list (player inventory only) [Synced with Server]", synchronizedSetting: true);
			availableItemsAmountColor = config<Color>("Item - Available resources amount", "Color", new Color(0.68f, 0.85f, 0.9f), "Color of amount of available resources.");
			showMulticraftButtons = config("Item - Available resources amount", "Multicraft", defaultValue: true, "Show multicraft buttons [Synced with Server]", synchronizedSetting: true);
			showMulticraftButtons.SettingChanged += delegate
			{
				MultiCraft.UpdateMulticraftPanel();
			};
			craftingFilterEnabled = config("Item - Crafting - Filter", "Enabled", defaultValue: true, "Enable filtering of craft list. [Synced with Server]", synchronizedSetting: true);
			craftingSortingEnabled = config("Item - Crafting - Filter", "Enable sorting panels", defaultValue: true, "Enable sorting and filtering of craft list. [Synced with Server]", synchronizedSetting: true);
			craftingFilterEnabled.SettingChanged += delegate
			{
				CraftFilter.UpdateVisibility();
			};
			craftingSortingEnabled.SettingChanged += delegate
			{
				CraftSort.CheckPanels();
			};
			craftingNewMarkEnabled = config("Item - Crafting - New Mark", "Enabled", defaultValue: true, "Enable mark of new items in craft list. [Synced with Server]", synchronizedSetting: true);
			craftingNewMarkShowOnlyWithUnlocks = config("Item - Crafting - New Mark", "Show only unlocks", defaultValue: true, "Show only items that, when crafted, will potentially unlock new recipes.\nThis means items that are used in other recipes.\nIf disabled, all items not yet known to the character will be shown. [Synced with Server]", synchronizedSetting: true);
			craftingNewMarkText = config("Item - Crafting - New Mark", "Text", "?", "Text to show.");
			craftingNewMarkColor = config<Color>("Item - Crafting - New Mark", "Color", new Color(1f, 0.64f, 0f), "Text color.");
			craftingNewMarkFontSize = config("Item - Crafting - New Mark", "Font size", 16f, "Text size.");
			craftingNewMarkFontStyle = config<FontStyles>("Item - Crafting - New Mark", "Font style", (FontStyles)1, "Text style.");
			craftingNewMarkEnabled.SettingChanged += delegate
			{
				InventoryGui obj5 = InventoryGui.instance;
				if (obj5 != null)
				{
					obj5.UpdateCraftingPanel(false);
				}
			};
			craftingNewMarkShowOnlyWithUnlocks.SettingChanged += delegate
			{
				InventoryGui obj4 = InventoryGui.instance;
				if (obj4 != null)
				{
					obj4.UpdateCraftingPanel(false);
				}
			};
			craftingNewMarkText.SettingChanged += delegate
			{
				InventoryGui obj3 = InventoryGui.instance;
				if (obj3 != null)
				{
					obj3.UpdateCraftingPanel(false);
				}
			};
			craftingNewMarkFontSize.SettingChanged += delegate
			{
				InventoryGui obj2 = InventoryGui.instance;
				if (obj2 != null)
				{
					obj2.UpdateCraftingPanel(false);
				}
			};
			craftingNewMarkFontStyle.SettingChanged += delegate
			{
				InventoryGui obj = InventoryGui.instance;
				if (obj != null)
				{
					obj.UpdateCraftingPanel(false);
				}
			};
			durabilityEnabled = config("Item - Durability", "0 - Enabled", defaultValue: true, "Enable color of durability. [Synced with Server]", synchronizedSetting: true);
			durabilityFine = config<Color>("Item - Durability", "1 - Fine", new Color(0.11765f, 0.72941f, 0.03529f, 1f), "Color of durability > 75%.");
			durabilityWorn = config<Color>("Item - Durability", "2 - Worn", new Color(0.72941f, 0.72941f, 0.03529f, 1f), "Color of durability > 50%.");
			durabilityAtRisk = config<Color>("Item - Durability", "3 - At risk", new Color(0.72941f, 0.34902f, 0.03529f, 1f), "Color of durability > 25%.");
			durabilityBroken = config<Color>("Item - Durability", "4 - Broken", new Color(0.72941f, 0.03529f, 0.03529f, 1f), "Color of durability >= 0%.");
			durabilityFine.SettingChanged += delegate
			{
				ItemIcon.UpdateGradient();
			};
			durabilityWorn.SettingChanged += delegate
			{
				ItemIcon.UpdateGradient();
			};
			durabilityAtRisk.SettingChanged += delegate
			{
				ItemIcon.UpdateGradient();
			};
			durabilityBroken.SettingChanged += delegate
			{
				ItemIcon.UpdateGradient();
			};
			itemIconScale = config("Item - Icon", "Icon scale", 1f, "Relative scale size of item icons.");
			itemEquippedColor = config<Color>("Item - Icon", "Equipped color", Color.clear, "Override for color of equipped items.");
			itemTooltip = config("Item - Tooltip", "Enabled", defaultValue: true, "Updated item tooltip. Hold Alt to see original tooltip");
			itemTooltipColored = config("Item - Tooltip", "Colored numbers", defaultValue: true, "Orange and yellow value numbers in tooltip, light blue if disabled");
			itemTooltipRecipeFontSize = config("Item - Tooltip", "Recipe description min font size", 9f, "Make description font smaller to fit more lines");
			itemTooltipRecipeFontSize.SettingChanged += delegate
			{
				ItemTooltip.UpdateRecipeDescriptionFontSize();
			};
			itemQuality = config("Item - Quality", "Enabled", defaultValue: true, "Show item quality as symbol");
			itemQualitySymbol = config("Item - Quality", "Symbol", "★", "Symbol to show.");
			itemQualitySymbolColor = config<Color>("Item - Quality", "Symbol Color", new Color(1f, 0.65f, 0f, 1f), "Symbol color");
			itemQualitySymbolSize = config("Item - Quality", "Symbol Size", 10f, "Symbol size");
			itemQualityMax = config("Item - Quality", "Maximum symbols", 8, "Maximum amount of symbols to show.");
			itemQualityRows = config("Item - Quality", "Maximum rows", 2, "Maximum amount of rows to show.");
			itemQualityColumns = config("Item - Quality", "Maximum columns", 4, "Maximum amount of columns to show.");
			itemQualityLineSpacing = config("Item - Quality", "Space between lines", -35f, "Line spacing.");
			itemQualityCharacterSpacing = config("Item - Quality", "Space between characters", 8f, "Character spacing.");
			itemQualityIgnoreCustomEquipmentSlots = config("Item - Quality", "Ignore equipment slots", defaultValue: false, "Ignore custom equipment slots added by AzuEPI or EaQS. Quick slot items will remain.");
			itemQualityIgnoreCustomSlots = config("Item - Quality", "Ignore any custom slot", defaultValue: false, "Ignore every custom slot outside of shown inventory rows.");
			itemQualitySymbol.SettingChanged += delegate
			{
				itemQualitySymbol.Value = itemQualitySymbol.Value[0].ToString();
			};
			itemQualitySymbol.SettingChanged += delegate
			{
				ItemIcon.FillItemQualityCache();
			};
			itemQualityMax.SettingChanged += delegate
			{
				ItemIcon.FillItemQualityCache();
			};
			itemQualityRows.SettingChanged += delegate
			{
				ItemIcon.FillItemQualityCache();
			};
			itemQualityColumns.SettingChanged += delegate
			{
				ItemIcon.FillItemQualityCache();
			};
			ItemIcon.FillItemQualityCache();
			itemQualityHideLvl1 = config("Item - Quality - Display", "Hide quality on lvl 1 items", defaultValue: false, "Hide lvl 1 quality if item lvl is 1.");
			itemQualityHideCustomEquipmentSlots = config("Item - Quality - Display", "Hide quality on equipment slots", defaultValue: false, "Hide quality if item is in equipment slots.");
			itemQualityHideLvl1.SettingChanged += delegate
			{
				AmmoCountIcon.UpdateVisibility();
			};
			inventoryOpenCloseAnimationSpeed = config("Inventory", "Animation speed", 1f, "Inventory show/close animation speed");
			inventoryHideLongStack = config("Inventory", "Hide long stacks", defaultValue: true, "Hide max stack size if it is too long to show in inventory or hotbar");
			inventoryEnableRepairOnHold = config("Inventory", "Enable repair on hold", defaultValue: true, "Hold Use key on crafting station to repair all items and close crafting station [Synced with Server]", synchronizedSetting: true);
			inventoryOpenCloseAnimationSpeed.SettingChanged += delegate
			{
				SetInventoryAnimationSpeed();
			};
			statsMainMenu = config("Stats - Main menu", "Show stats in main menu", defaultValue: true, "Show character statistics in main menu");
			statsMainMenuAdvanced = config("Stats - Main menu", "Show advanced stats in main menu", defaultValue: true, "Show advanced character statistics in main menu");
			statsMainMenuAll = config("Stats - Main menu", "Show all stats in main menu", defaultValue: false, "Show all character statistics in main menu");
			statsCharacterArmor = config("Stats - Character", "Show character stats on armor hover", defaultValue: true, "Show character stats in armor tooltip");
			statsCharacterEffects = config("Stats - Character", "Show character active effects on weight hover", defaultValue: true, "Show character active effects in weight tooltip");
			statsCharacterArmor.SettingChanged += delegate
			{
				InventoryCharacterStats.UpdateTooltipState();
			};
			statsCharacterEffects.SettingChanged += delegate
			{
				InventoryCharacterStats.UpdateTooltipState();
			};
			hoverCharacter = config("Hover - Character", "Character Hover", StationHover.Vanilla, "Format of baby development's total needed time/percent.");
			hoverCharacterGrowth = config("Hover - Character", "Show baby growth", defaultValue: true, "Show total growth percentage/remaining for babies. [Synced with Server]", synchronizedSetting: true);
			hoverCharacterProcreation = config("Hover - Character", "Show offspring", defaultValue: true, "Show percentage/remaining for new offspring. [Synced with Server]", synchronizedSetting: true);
			hoverCharacterEggGrow = config("Hover - Character", "Show egg hatching", defaultValue: true, "Show percentage/remaining for egg hatching. [Synced with Server]", synchronizedSetting: true);
			hoverCharacterLovePoints = config("Hover - Character", "Show love points", defaultValue: true, "Show how many love points creature has (likeliness to be pregnant). [Synced with Server]", synchronizedSetting: true);
			hoverFermenterEnabled = config("Hover - Stations", "Fermenter Hover Enabled", defaultValue: true, "Enable Hover text for fermenter. [Synced with Server]", synchronizedSetting: true);
			hoverPlantEnabled = config("Hover - Stations", "Plants Hover Enabled", defaultValue: true, "Enable Hover text for plants. [Synced with Server]", synchronizedSetting: true);
			hoverPickableEnabled = config("Hover - Stations", "Pickables Hover Enabled", defaultValue: true, "Enable Hover text for pickables. [Synced with Server]", synchronizedSetting: true);
			hoverCookingEnabled = config("Hover - Stations", "Cooking stations Hover Enabled", defaultValue: true, "Enable Hover text for cooking stations. [Synced with Server]", synchronizedSetting: true);
			hoverBeeHiveEnabled = config("Hover - Stations", "Bee Hive Hover Enabled", defaultValue: true, "Enable Hover text for bee hive. [Synced with Server]", synchronizedSetting: true);
			hoverFermenter = config("Hover - Stations", "Fermenter Hover", StationHover.Vanilla, "Hover text for fermenter.");
			hoverPlant = config("Hover - Stations", "Plants Hover", StationHover.Vanilla, "Hover text for plants.");
			hoverPickable = config("Hover - Stations", "Pickables Hover", StationHover.Vanilla, "Hover text for pickables.");
			hoverCooking = config("Hover - Stations", "Cooking stations Hover", StationHover.Vanilla, "Hover text for cooking stations.");
			hoverBeeHive = config("Hover - Stations", "Bee Hive Hover", StationHover.Vanilla, "Hover text for bee hive.");
			hoverBeeHiveTotal = config("Hover - Stations", "Bee Hive Show total", defaultValue: true, "Show total needed time/percent for bee hive.");
			hoverCookingNextItem = config("Hover - Stations", "Cooking station next item", defaultValue: true, "Show next item to be added to cooking station. Player inventory only.");
			hoverCookingRemoveLastItem = config("Hover - Stations", "Cooking station Remove last item", defaultValue: true, "Add an option to remove last uncooked item. [Synced with Server]", synchronizedSetting: true);
			hoverStumpGrowerEnabled = config("Hover - Stations", "Stump Hover Enabled", defaultValue: true, "Enable Hover text for stumps when Advize_StumpsRegrow is installed. [Synced with Server]", synchronizedSetting: true);
			hoverStumpGrower = config("Hover - Stations", "Stump Hover", StationHover.Vanilla, "Hover text for stumps.");
			hoverTame = config("Hover - Tameable", "Tameable Hover", StationHover.Vanilla, "Format of total needed time/percent to tame or to stay fed.");
			hoverTameTimeToTame = config("Hover - Tameable", "Show time to tame", defaultValue: true, "Show total needed time/percent to tame. [Synced with Server]", synchronizedSetting: true);
			hoverTameTimeToFed = config("Hover - Tameable", "Show time to stay fed", defaultValue: true, "Show total needed time/percent to stay fed. [Synced with Server]", synchronizedSetting: true);
			hoverSmelterEstimatedTime = config("Hover - Smelters", "Show estimated time", defaultValue: true, "Show estimated end time for a smelter station (charcoal kiln, forge, etc. including non vanilla). [Synced with Server]", synchronizedSetting: true);
			hoverSmelterShowFuelAndItem = config("Hover - Smelters", "Always show fuel and item", defaultValue: true, "Show current smelting item and fuel loaded on both fuel and ore switches.");
			hoverSmelterShowQueuedItems = config("Hover - Smelters", "Show queued items", defaultValue: true, "Show queued items currently being smelted. Doesn't show the list if there is only one item to smelt. [Synced with Server]", synchronizedSetting: true);
			hoverSmelterHoldToAddSeveral = config("Hover - Smelters", "Hold E to add several items", defaultValue: true, "Hold E to add several items in faster manner. Can't add more items than station capacity [Synced with Server]", synchronizedSetting: true);
			chestCustomName = config("Hover - Chests", "Enable custom names", defaultValue: true, "Enable custom names for chests. [Synced with Server]", synchronizedSetting: true);
			chestHoverItems = config("Hover - Chests", "Hover items format", ChestItemsHover.Vanilla, "Chest items details format to be shown in hover.");
			chestHoverName = config("Hover - Chests", "Hover name format", ChestNameHover.TypeThenCustomName, "Chest name format to be shown in hover.");
			chestShowRename = config("Hover - Chests", "Show rename hint in hover", defaultValue: true, "Show rename hotkey hint. You can hide it to make it less noisy.");
			chestShowHoldToStack = config("Hover - Chests", "Show hold to stack hint in hover", defaultValue: true, "Show hold to stack hint. You can hide it to make it less noisy.");
			chestContentEnabled = config("Hover - Chests - Content", "Enable chest content", defaultValue: true, "Enable custom names for chests. [Synced with Server]", synchronizedSetting: true);
			chestContentLinesToShow = config("Hover - Chests - Content", "Lines to show", 11, "Amount of lines to be shown.");
			chestContentSortType = config("Hover - Chests - Content", "Sorting type", ContentSortType.Position, "Sorting type. Position means item position in chest grid.");
			chestContentSortDir = config("Hover - Chests - Content", "Sorting direction", ContentSortDir.Asc, "Sorting direction.");
			chestContentEntryFormat = config("Hover - Chests - Content", "Entry format", "{1} {0}", "0 for item name, 1 for total amount");
			chestContentAmountColor = config<Color>("Hover - Chests - Content", "Entry amount color", new Color(1f, 1f, 0f, 0.6f), "Color for amount");
			chestContentItemColor = config<Color>("Hover - Chests - Content", "Entry item name color", new Color(0.75f, 0.75f, 0.75f, 0.6f), "Color for item name");
			chestContentEnabled.SettingChanged += delegate
			{
				ChestHoverText.ResetHoverCache();
			};
			chestContentLinesToShow.SettingChanged += delegate
			{
				ChestHoverText.ResetHoverCache();
			};
			chestContentSortType.SettingChanged += delegate
			{
				ChestHoverText.ResetHoverCache();
			};
			chestContentSortDir.SettingChanged += delegate
			{
				ChestHoverText.ResetHoverCache();
			};
			chestContentEntryFormat.SettingChanged += delegate
			{
				ChestHoverText.ResetHoverCache();
			};
			chestContentItemColor.SettingChanged += delegate
			{
				ChestHoverText.ResetHoverCache();
			};
			chestContentAmountColor.SettingChanged += delegate
			{
				ChestHoverText.ResetHoverCache();
			};
			statusEffectsPositionEnabled = config("Status effects - Map - List", "Enable", defaultValue: true, "Enable repositioning of status effect list. [Synced with Server]", synchronizedSetting: true);
			statusEffectsPositionAnchor = config<Vector2>("Status effects - Map - List", "Position", new Vector2(-170f, -265f), "Anchored position of list.");
			statusEffectsFillingDirection = config("Status effects - Map - List", "Direction", ListDirection.TopToBottom, "Direction of filling");
			statusEffectsPositionSpacing = config("Status effects - Map - List", "Spacing", 8, "Spacing between status effects");
			statusEffectsElementEnabled = config("Status effects - Map - List element", "Custom element enabled", defaultValue: true, "Enables using of horizontal status effect element [Synced with Server]", synchronizedSetting: true);
			statusEffectsElementSize = config("Status effects - Map - List element", "Size", 32, "Vertical capsule size");
			statusEffectsPositionEnabled.SettingChanged += delegate
			{
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
			};
			statusEffectsPositionAnchor.SettingChanged += delegate
			{
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
			};
			statusEffectsElementEnabled.SettingChanged += delegate
			{
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
			};
			statusEffectsElementSize.SettingChanged += delegate
			{
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
			};
			sailingIndicatorEnabled = config("Status effects - Map - Sailing indicator", "Enabled", defaultValue: true, "Enable changing of sailing indicator [Synced with Server]", synchronizedSetting: true);
			sailingIndicatorPowerIconPosition = config<Vector2>("Status effects - Map - Sailing indicator", "Sail power indicator position", new Vector2(-350f, -290f), "Sail size and rudder indicator position");
			sailingIndicatorPowerIconScale = config("Status effects - Map - Sailing indicator", "Sail power indicator scale", 1f, "Sail size and rudder indicator scale");
			sailingIndicatorWindIndicatorPosition = config<Vector2>("Status effects - Map - Sailing indicator", "Wind indicator position", new Vector2(-350f, -140f), "Wind indicator (ship and wind direction) position");
			sailingIndicatorWindIndicatorScale = config("Status effects - Map - Sailing indicator", "Wind indicator scale", 1f, "Wind indicator (ship and wind direction) scale");
			sailingIndicatorEnabled.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			sailingIndicatorPowerIconPosition.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			sailingIndicatorPowerIconScale.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			sailingIndicatorWindIndicatorPosition.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			sailingIndicatorWindIndicatorScale.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			statusEffectsPositionEnabledNomap = config("Status effects - Nomap - List", "Enable", defaultValue: true, "Enable repositioning of status effect list. [Synced with Server]", synchronizedSetting: true);
			statusEffectsPositionAnchorNomap = config<Vector2>("Status effects - Nomap - List", "Position", new Vector2(-170f, -70f), "Anchored position of list.");
			statusEffectsFillingDirectionNomap = config("Status effects - Nomap - List", "Direction", ListDirection.TopToBottom, "Direction of filling");
			statusEffectsPositionSpacingNomap = config("Status effects - Nomap - List", "Spacing", 10, "Spacing between status effects");
			statusEffectsElementEnabledNomap = config("Status effects - Nomap - List element", "Custom element enabled", defaultValue: true, "Enables using of horizontal status effect element [Synced with Server]", synchronizedSetting: true);
			statusEffectsElementSizeNomap = config("Status effects - Nomap - List element", "Size", 36, "Vertical capsule size");
			statusEffectsPositionEnabledNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
			};
			statusEffectsPositionAnchorNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
			};
			statusEffectsElementEnabledNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
			};
			statusEffectsElementSizeNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.InitializeStatusEffectTemplate();
			};
			sailingIndicatorEnabledNomap = config("Status effects - Nomap - Sailing indicator", "Enabled", defaultValue: true, "Enable changing of sailing indicator [Synced with Server]", synchronizedSetting: true);
			sailingIndicatorPowerIconPositionNomap = config<Vector2>("Status effects - Nomap - Sailing indicator", "Sail power indicator position", new Vector2(-350f, -320f), "Sail size and rudder indicator position");
			sailingIndicatorPowerIconScaleNomap = config("Status effects - Nomap - Sailing indicator", "Sail power indicator scale", 1.1f, "Sail size and rudder indicator scale");
			sailingIndicatorWindIndicatorPositionNomap = config<Vector2>("Status effects - Nomap - Sailing indicator", "Wind indicator position", new Vector2(-350f, -170f), "Wind indicator (ship and wind direction) position");
			sailingIndicatorWindIndicatorScaleNomap = config("Status effects - Nomap - Sailing indicator", "Wind indicator scale", 1.1f, "Wind indicator (ship and wind direction) scale");
			sailingIndicatorEnabledNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			sailingIndicatorPowerIconPositionNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			sailingIndicatorPowerIconScaleNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			sailingIndicatorWindIndicatorPositionNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			sailingIndicatorWindIndicatorScaleNomap.SettingChanged += delegate
			{
				CustomStatusEffectsList.ChangeSailingIndicator();
			};
			showWeight = config("Info - Inventory", "Show current weight", defaultValue: true, "Enable showing weight (current / max) [Synced with Server]", synchronizedSetting: true);
			showSlots = config("Info - Inventory", "Show current slots", defaultValue: true, "Enable current slots (emtpy / max) [Synced with Server]", synchronizedSetting: true);
			weightBackgroundColor = config<Color>("Info - Inventory", "Weight background", new Color(0f, 0f, 0f, 0.5f), "Color of weight block background");
			slotsBackgroundColor = config<Color>("Info - Inventory", "Slots background", new Color(0f, 0f, 0f, 0.5f), "Color of slots block background");
			showWeightLeft = config("Info - Inventory", "Show weight left until encumbered", defaultValue: false, "Invert weight value. Show how much weight you can take until encumbered.");
			showSlotsTaken = config("Info - Inventory", "Show slots space taken", defaultValue: false, "Invern current slots. Show how much space is taken.");
			showWeightLeft.SettingChanged += delegate
			{
				InventoryPanel.UpdateStats();
			};
			showSlotsTaken.SettingChanged += delegate
			{
				InventoryPanel.UpdateStats();
			};
			weightSlotsFine = config<Color>("Info - Inventory - Colors", "1 - Fine", new Color(0.11765f, 0.72941f, 0.03529f, 1f), "Color of amount < 50%.");
			weightSlotsHalf = config<Color>("Info - Inventory - Colors", "2 - Half", new Color(0.72941f, 0.72941f, 0.03529f, 1f), "Color of amount > 50%.");
			weightSlotsALot = config<Color>("Info - Inventory - Colors", "3 - A lot", new Color(0.72941f, 0.34902f, 0.03529f, 1f), "Color of amount > 75%.");
			weightSlotsFull = config<Color>("Info - Inventory - Colors", "4 - Full", new Color(0.72941f, 0.03529f, 0.03529f, 1f), "Color of amount >= 100%.");
			weightSlotsFine.SettingChanged += delegate
			{
				InventoryPanel.UpdateGradient();
			};
			weightSlotsHalf.SettingChanged += delegate
			{
				InventoryPanel.UpdateGradient();
			};
			weightSlotsALot.SettingChanged += delegate
			{
				InventoryPanel.UpdateGradient();
			};
			weightSlotsFull.SettingChanged += delegate
			{
				InventoryPanel.UpdateGradient();
			};
			weightPositionAnchor = config("Info - Inventory", "Weight position Anchor", ElementAnchor.BottomLeft, "Anchor point of an element");
			slotsPositionAnchor = config("Info - Inventory", "Slots position Anchor", ElementAnchor.BottomLeft, "Anchor point of an element");
			weightPosition = config<Vector2>("Info - Inventory", "Weight position", new Vector2(62f, 332f), "anchoredPosition from anchor point");
			slotsPosition = config<Vector2>("Info - Inventory", "Slots position", new Vector2(62f, 265f), "anchoredPosition from anchor point");
			weightFontColor = config<Color>("Info - Inventory", "Weight font color", new Color(1f, 0.848f, 0f, 1f), "Font color.");
			slotsFontColor = config<Color>("Info - Inventory", "Slots font color", new Color(1f, 0.848f, 0f, 1f), "Font color.");
			if (weightPosition.Value == new Vector2(-898f, -276.1f))
			{
				weightPosition.Value = (Vector2)((ConfigEntryBase)weightPosition).DefaultValue;
			}
			if (slotsPosition.Value == new Vector2(-898f, -209.9f))
			{
				slotsPosition.Value = (Vector2)((ConfigEntryBase)slotsPosition).DefaultValue;
			}
			inworldTextChanges = config("Chat - Inworld text", "Enabled", defaultValue: false, "Enable changes of inworld floating texts.");
			inworldDefaultColor = config<Color>("Chat - Inworld text", "Default font color", Color.white, "Font color.");
			inworldWhisperColor = config<Color>("Chat - Inworld text", "Whisper font color", new Color(1f, 1f, 1f, 0.75f), "Font color.");
			inworldShoutColor = config<Color>("Chat - Inworld text", "Shout font color", Color.yellow, "Font color.");
			inworldPingColor = config<Color>("Chat - Inworld text", "Ping font color", new Color(0.6f, 0.7f, 1f, 1f), "Font color.");
			inworldPingText = config("Chat - Inworld text", "Ping text", "PING", "Ping text.");
			inworldAddDarken = config("Chat - Inworld text", "Add a darker backking", defaultValue: true, "Add darker back to shouts and pings to make text more visible.");
			inworldDarkenIntensity = config("Chat - Inworld text", "Darker backking intensity", 0.8f, "Transparency of darken element.");
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, ConfigDescription description, bool synchronizedSetting = false)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, defaultValue, description);
			SyncedConfigEntry<T> syncedConfigEntry = configSync.AddConfigEntry<T>(val);
			syncedConfigEntry.SynchronizedConfig = synchronizedSetting;
			return val;
		}

		private ConfigEntry<T> config<T>(string group, string name, T defaultValue, string description, bool synchronizedSetting = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		private void LoadIcons()
		{
			LoadIcon("Clear.png", ref WeatherForecast.iconClear);
			LoadIcon("Rain.png", ref WeatherForecast.iconRain);
			LoadIcon("Snow.png", ref WeatherForecast.iconSnow);
			LoadIcon("Thunder.png", ref WeatherForecast.iconThunder);
			LoadIcon("Mist.png", ref WeatherForecast.iconMist);
			LoadIcon("RainCinder.png", ref WeatherForecast.iconRainCinder);
		}

		internal static void LoadIcon(string filename, ref Sprite icon)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Texture2D tex = new Texture2D(2, 2);
			if (LoadTexture(filename, ref tex))
			{
				icon = Sprite.Create(tex, new Rect(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height), Vector2.zero);
			}
		}

		internal static bool LoadTexture(string filename, ref Texture2D tex)
		{
			string text = Path.Combine(Paths.PluginPath, filename);
			if (File.Exists(text))
			{
				LogInfo("Loaded image: " + text);
				return ImageConversion.LoadImage(tex, File.ReadAllBytes(text));
			}
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(filename));
			Stream manifestResourceStream = executingAssembly.GetManifestResourceStream(name);
			byte[] array = new byte[manifestResourceStream.Length];
			manifestResourceStream.Read(array, 0, array.Length);
			((Object)tex).name = Path.GetFileNameWithoutExtension(filename);
			return ImageConversion.LoadImage(tex, array, true);
		}

		internal static string FromSeconds(double seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			return timeSpan.ToString((timeSpan.Hours > 0) ? "h\\:mm\\:ss" : "m\\:ss");
		}

		internal static string FromPercent(double percent)
		{
			return GetBar(Mathf.RoundToInt((float)percent * 10f), 10);
		}

		private static string GetBar(int amount, int total, char symbol = '▀')
		{
			return ("<sup><alpha=#ff>" + new string(symbol, total) + "<alpha=#ff></sup>").Insert(Mathf.Clamp(amount, 0, total) + 16, "<alpha=#33>");
		}

		private static void SetInventoryAnimationSpeed()
		{
			if (Object.op_Implicit((Object)(object)InventoryGui.instance) && Object.op_Implicit((Object)(object)InventoryGui.instance.m_animator))
			{
				InventoryGui.instance.m_animator.speed = Mathf.Max(inventoryOpenCloseAnimationSpeed.Value, 0f);
			}
		}

		public void UpdateCraftingPanel()
		{
			CraftFilter.UpdateCraftingPanel();
		}
	}
	public class AmountScrollHandler : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public static bool hovered;

		private void Start()
		{
			hovered = false;
		}

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

		public void OnPointerExit(PointerEventData eventData)
		{
			hovered = false;
		}
	}
	internal static class RectTransformExtensions
	{
		public static void SetAnchor(this RectTransform rectTransform, MyLittleUI.ElementAnchor anchor)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			switch (anchor)
			{
			case MyLittleUI.ElementAnchor.TopLeft:
				rectTransform.anchorMin = new Vector2(0f, 1f);
				rectTransform.anchorMax = new Vector2(0f, 1f);
				break;
			case MyLittleUI.ElementAnchor.Top:
				rectTransform.anchorMin = new Vector2(0.5f, 1f);
				rectTransform.anchorMax = new Vector2(0.5f, 1f);
				break;
			case MyLittleUI.ElementAnchor.TopRight:
				rectTransform.anchorMin = new Vector2(1f, 1f);
				rectTransform.anchorMax = new Vector2(1f, 1f);
				break;
			case MyLittleUI.ElementAnchor.Right:
				rectTransform.anchorMin = new Vector2(1f, 0.5f);
				rectTransform.anchorMax = new Vector2(1f, 0.5f);
				break;
			case MyLittleUI.ElementAnchor.BottomRight:
				rectTransform.anchorMin = new Vector2(1f, 0f);
				rectTransform.anchorMax = new Vector2(1f, 0f);
				break;
			case MyLittleUI.ElementAnchor.Bottom:
				rectTransform.anchorMin = new Vector2(0.5f, 0f);
				rectTransform.anchorMax = new Vector2(0.5f, 0f);
				break;
			case MyLittleUI.ElementAnchor.BottomLeft:
				rectTransform.anchorMin = new Vector2(0f, 0f);
				rectTransform.anchorMax = new Vector2(0f, 0f);
				break;
			case MyLittleUI.ElementAnchor.Left:
				rectTransform.anchorMin = new Vector2(0f, 0.5f);
				rectTransform.anchorMax = new Vector2(0f, 0.5f);
				break;
			case MyLittleUI.ElementAnchor.Middle:
				rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
				rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
				break;
			default:
				throw new ArgumentOutOfRangeException("anchor", anchor, null);
			}
		}
	}
	internal static class StationRepair
	{
		[HarmonyPatch(typeof(CraftingStation), "Interact")]
		public static class CraftingStation_Interact_RepairOnHold
		{
			public static void Postfix(CraftingStation __instance, bool __result)
			{
				if (!__result && InventoryGui.IsVisible())
				{
					((MonoBehaviour)__instance).StartCoroutine(RepairOnHold());
				}
			}
		}

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

			private object <>2__current;

			private int <itemsRepaired>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)InventoryGui.instance))
					{
						return false;
					}
					<>2__current = (object)new WaitForSeconds(0.4f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<itemsRepaired>5__1 = 0;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (ZInput.GetButtonPressedTimer("Use") >= 0.4f && InventoryGui.instance.HaveRepairableItems())
				{
					InventoryGui.instance.RepairOneItem();
					<itemsRepaired>5__1++;
					<>2__current = wait;
					<>1__state = 2;
					return true;
				}
				if (!ZInput.GetButton("Use"))
				{
					return false;
				}
				if (<itemsRepaired>5__1 == 0)
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize("$settings_inventory $msg_doesnotneedrepair", new string[1] { <itemsRepaired>5__1.ToString() }), 0, (Sprite)null);
				}
				else
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, Localization.instance.Localize("$msg_repaired", new string[1] { <itemsRepaired>5__1.ToString() }), 0, (Sprite)null);
				}
				InventoryGui.instance.Hide();
				return false;
			}

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

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

		private static readonly WaitForSeconds wait = new WaitForSeconds(0.1f);

		private const float delay = 0.4f;

		[IteratorStateMachine(typeof(<RepairOnHold>d__2))]
		public static IEnumerator RepairOnHold()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RepairOnHold>d__2(0);
		}
	}
	internal static class WeatherForecast
	{
		public enum WeatherState
		{
			Clear,
			Rain,
			Snow,
			Thunder,
			Mist,
			RainCinder
		}

		[HarmonyPatch(typeof(EnvMan), "UpdateEnvironment")]
		public static class EnvMan_UpdateEnvironment_UpdateForecast
		{
			private static long preCalculatedPeriod = -1L;

			public static void Prefix(EnvMan __instance)
			{
				preCalculatedPeriod = __instance.m_environmentPeriod;
			}

			public static void Postfix(EnvMan __instance)
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				if (MyLittleUI.modEnabled.Value && MyLittleUI.forecastEnabled.Value)
				{
					if (__instance.m_environmentPeriod == environmentPeriod && __instance.m_environmentPeriod == preCalculatedPeriod && __instance.m_currentBiome == currentBiome && __instance.m_inAshlandsOrDeepnorth == inAshlandsOrDeepnorth)
					{
						UpdateWeatherTimer();
						return;
					}
					environmentPeriod = __instance.m_environmentPeriod;
					currentBiome = __instance.m_currentBiome;
					inAshlandsOrDeepnorth = __instance.m_inAshlandsOrDeepnorth;
					UpdateNextWeather();
				}
			}
		}

		[HarmonyPatch(typeof(EnvMan), "UpdateWind")]
		public static class EnvMan_UpdateWind_UpdateWindStatus
		{
			public static void Postfix(EnvMan __instance, long timeSec, float dt)
			{
				if (MyLittleUI.modEnabled.Value && MyLittleUI.windsEnabled.Value)
				{
					if (windPeriod == GetCurrentWindPeriod(timeSec))
					{
						UpdateWindTimer(dt);
						return;
					}
					windPeriod = GetCurrentWindPeriod(timeSec);
					UpdateNextWinds();
				}
			}
		}

		[HarmonyPatch(typeof(Game), "UpdateNoMap")]
		public static class Game_UpdateNoMap_UpdateForecastPosition
		{
			public static void Postfix()
			{
				if (MyLittleUI.modEnabled.Value)
				{
					InfoBlocks.UpdateForecastBlock();
					InfoBlocks.UpdateWindsBlock(forceRebuildList: true);
				}
			}
		}

		[HarmonyPatch]
		public static class Humanoid_TooltipUpdate
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

				[DebuggerHidden]
				public <TargetMethods>d__0(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(EnvMan), "SetDebugWind", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(EnvMan), "ResetDebugWind", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						return false;
					}
				}

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

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

				[DebuggerHidden]
				IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<MethodBase>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<TargetMethods>d__0))]
			private static IEnumerable<MethodBase> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__0(-2);
			}

			private static void Postfix()
			{
				UpdateNextWinds();
			}
		}

		public static Biome currentBiome;

		public static bool inAshlandsOrDeepnorth;

		public static long environmentPeriod = -1L;

		public static long windPeriod = -1L;

		public static long nextWindChange;

		public static long nextWeatherChange;

		public static WeatherState nextWeatherState;

		public static Sprite iconClear;

		public static Sprite iconRain;

		public static Sprite iconSnow;

		public static Sprite iconThunder;

		public static Sprite iconMist;

		public static Sprite iconRainCinder;

		public static readonly List<GameObject> windList = new List<GameObject>();

		public static readonly List<Vector4> winds = new List<Vector4>();

		public static readonly List<Vector4> windsTransition = new List<Vector4>();

		public const float windsTransitionDuration = 5f;

		public static float windsTransitionTimer = -1f;

		public static void UpdateWeather()
		{
			InfoBlocks.forecastObject.SetActive(nextWeatherChange > 0);
			UpdateWeatherIcon();
			InfoBlocks.UpdateForecastBackground();
			if (Object.op_Implicit((Object)(object)EnvMan.instance))
			{
				UpdateWeatherTimer();
			}
		}

		public static void UpdateWindTimer(float time)
		{
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			if (!MyLittleUI.windsEnabled.Value)
			{
				return;
			}
			InfoBlocks.windsObject.SetActive(MyLittleUI.windsEnabled.Value && (double)nextWindChange >= EnvMan.instance.m_totalSeconds && !EnvMan.instance.m_debugWind);
			if (!InfoBlocks.windsObject.activeSelf)
			{
				return;
			}
			if (EnvMan.instance.m_totalSeconds % 5.0 <= 0.10000000149011612)
			{
				InfoBlocks.UpdateWindsBackground();
			}
			if (windsTransition.Count > 0)
			{
				if (windsTransition.Count != winds.Count)
				{
					winds.Clear();
					winds.AddRange(windsTransition);
					windsTransitionTimer = -1f;
					SetWindsDirection(1f);
				}
				else if (windsTransitionTimer > 5f)
				{
					windsTransitionTimer = -1f;
					SetWindsDirection(1f);
				}
				else if (windsTransitionTimer >= 0f)
				{
					SetWindsDirection(windsTransitionTimer / 5f);
					windsTransitionTimer += time;
				}
			}
			float num = Mathf.Clamp01((float)((double)nextWindChange - EnvMan.instance.m_totalSeconds) / (float)GetWindPeriodDuration()) - 1f;
			InfoBlocks.windsProgressRect.offsetMax = Vector2.zero;
			InfoBlocks.windsProgressRect.offsetMin = Vector2.zero;
			Rect rect;
			switch (GetWindsListDirection())
			{
			case MyLittleUI.ListDirection.LeftToRight:
			{
				RectTransform windsProgressRect4 = InfoBlocks.windsProgressRect;
				rect = InfoBlocks.windsObjectRect.rect;
				windsProgressRect4.offsetMax = new Vector2(((Rect)(ref rect)).width * num, 0f);
				break;
			}
			case MyLittleUI.ListDirection.RightToLeft:
			{
				RectTransform windsProgressRect3 = InfoBlocks.windsProgressRect;
				rect = InfoBlocks.windsObjectRect.rect;
				windsProgressRect3.offsetMin = new Vector2((0f - ((Rect)(ref rect)).width) * num, 0f);
				break;
			}
			case MyLittleUI.ListDirection.BottomToTop:
			{
				RectTransform windsProgressRect2 = InfoBlocks.windsProgressRect;
				rect = InfoBlocks.windsObjectRect.rect;
				windsProgressRect2.offsetMax = new Vector2(0f, ((Rect)(ref rect)).height * num);
				break;
			}
			case MyLittleUI.ListDirection.TopToBottom:
			{
				RectTransform windsProgressRect = InfoBlocks.windsProgressRect;
				rect = InfoBlocks.windsObjectRect.rect;
				windsProgressRect.offsetMin = new Vector2(0f, (0f - ((Rect)(ref rect)).height) * num);
				break;
			}
			}
		}

		public static void SetWindsDirection(float transition)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_00c7: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < Math.Min(windList.Count, windsTransition.Count); i++)
			{
				Vector4 val = Vector4.Lerp(winds[i], windsTransition[i], transition);
				Quaternion val2 = Quaternion.LookRotation(Vector4.op_Implicit(val));
				Image component = windList[i].GetComponent<Image>();
				((Component)component).transform.rotation = Quaternion.Euler(0f, 0f, 0f - ((Quaternion)(ref val2)).eulerAngles.y);
				if (MyLittleUI.windsAlphaIntensity.Value)
				{
					((Graphic)component).color = new Color(MyLittleUI.windsArrowColor.Value.r, MyLittleUI.windsArrowColor.Value.g, MyLittleUI.windsArrowColor.Value.b, Mathf.Lerp(MyLittleUI.windsMinimumAlpha.Value, MyLittleUI.windsArrowColor.Value.a, val.w));
				}
				else
				{
					((Graphic)component).color = MyLittleUI.windsArrowColor.Value;
				}
				if (transition >= 1f)
				{
					winds[i] = val;
				}
			}
		}

		public static long GetWindPeriodDuration()
		{
			return EnvMan.instance.m_windPeriodDuration / 8;
		}

		public static long GetWeatherPeriodDuration()
		{
			return EnvMan.instance.m_environmentDuration;
		}

		public static long GetCurrentWindPeriod(double sec)
		{
			return (int)sec / GetWindPeriodDuration();
		}

		public static long GetCurrentWeatherPeriod(double sec)
		{
			return (long)sec / GetWeatherPeriodDuration();
		}

		public static void UpdateWeatherTimer()
		{
			if (nextWeatherChange > 0)
			{
				TMP_Text weatherText = InfoBlocks.weatherText;
				if (weatherText != null)
				{
					weatherText.SetText(GetNextWeatherTimer());
				}
			}
		}

		public static void UpdateWeatherIcon()
		{
			if (nextWeatherChange > 0 && (Object)(object)InfoBlocks.weatherIcon != (Object)null)
			{
				InfoBlocks.weatherIcon.overrideSprite = GetWeatherSprite();
			}
		}

		public static Sprite GetWeatherSprite()
		{
			WeatherState weatherState = nextWeatherState;
			if (1 == 0)
			{
			}
			Sprite result = (Sprite)(weatherState switch
			{
				WeatherState.Rain => iconRain, 
				WeatherState.Snow => iconSnow, 
				WeatherState.Thunder => iconThunder, 
				WeatherState.Mist => iconMist, 
				WeatherState.RainCinder => iconRainCinder, 
				_ => iconClear, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		private static string GetNextWeatherTimer()
		{
			if ((double)nextWeatherChange < EnvMan.instance.m_totalSeconds)
			{
				return "";
			}
			return GetWeatherTimerString((double)nextWeatherChange - EnvMan.instance.m_totalSeconds);
		}

		private static string GetWeatherTimerString(double seconds)
		{
			if (seconds < 60.0)
			{
				return DateTime.FromBinary(599266080000000000L).AddSeconds(seconds).ToString("ss\\s");
			}
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			if (timeSpan.Hours > 0)
			{
				return string.Format(((int)seconds % 2 == 0) ? "{0:d2}:{1:d2}" : "{0:d2}<alpha=#00>:<alpha=#ff>{1:d2}", (int)timeSpan.TotalHours, timeSpan.Minutes);
			}
			return timeSpan.ToString("mm\\:ss");
		}

		private static string TimerString(double seconds)
		{
			if (seconds < 60.0)
			{
				return DateTime.FromBinary(599266080000000000L).AddSeconds(seconds).ToString("ss\\s");
			}
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			if (timeSpan.TotalHours > 24.0)
			{
				return $"{(int)timeSpan.TotalHours:d2}:{timeSpan.Minutes:d2}:{timeSpan.Seconds:d2}";
			}
			return timeSpan.ToString((timeSpan.Hours > 0) ? "hh\\:mm\\:ss" : "mm\\:ss");
		}

		public static void UpdateNextWeather()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			nextWeatherState = WeatherState.Clear;
			nextWeatherChange = 0L;
			if (environmentPeriod > 0 && (string.IsNullOrEmpty(EnvMan.instance.m_forceEnv) || EnvMan.instance.GetEnv(EnvMan.instance.m_forceEnv) == null))
			{
				Vector3 position = ((Component)Utils.GetMainCamera()).transform.position;
				bool isAshlands = WorldGenerator.IsAshlands(position.x, position.z);
				bool isDeepNorth = WorldGenerator.IsDeepnorth(position.x, position.y);
				WeatherState weatherState = GetWeatherState(EnvMan.instance.m_nextEnv ?? EnvMan.instance.GetCurrentEnvironment());
				for (int i = 1; i <= 30; i++)
				{
					WeatherState weatherState2 = GetWeatherState(GetEnvironment(environmentPeriod + i, currentBiome, isAshlands, isDeepNorth));
					if (weatherState != weatherState2)
					{
						nextWeatherState = weatherState2;
						nextWeatherChange = (environmentPeriod + i) * GetWeatherPeriodDuration();
						break;
					}
				}
			}
			UpdateWeather();
			UpdateNextWinds();
		}

		public static void UpdateNextWinds(bool forceRebuildList = false)
		{
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			if (!MyLittleUI.windsEnabled.Value || !Object.op_Implicit((Object)(object)EnvMan.instance))
			{
				return;
			}
			nextWindChange = 0L;
			if (Object.op_Implicit((Object)(object)InfoBlocks.windTemplate) && (GetWindsCount() != windList.Count || forceRebuildList || windList.Any((GameObject wind) => !Object.op_Implicit((Object)(object)wind))))
			{
				foreach (GameObject wind in windList)
				{
					Object.Destroy((Object)(object)wind);
				}
				RectTransform component = InfoBlocks.windsObject.GetComponent<RectTransform>();
				windList.Clear();
				for (int i = 0; i < GetWindsCount(); i++)
				{
					GameObject val = Object.Instantiate<GameObject>(InfoBlocks.windTemplate, InfoBlocks.windsObject.transform);
					val.SetActive(true);
					SetWindPosition(val.GetComponent<RectTransform>(), i, component);
					windList.Add(val);
				}
			}
			if (windPeriod > 0)
			{
				windsTransition.Clear();
				windsTransitionTimer = 0f;
				for (int j = 1; j <= windList.Count; j++)
				{
					if (j == 1)
					{
						nextWindChange = (windPeriod + j) * GetWindPeriodDuration();
					}
					windsTransition.Add(GetWind(j));
				}
			}
			InfoBlocks.UpdateWindsBackground();
		}

		private static int GetWindsCount()
		{
			return Game.m_noMap ? MyLittleUI.windsCountNomap.Value : MyLittleUI.windsCount.Value;
		}

		private static float GetWindsSpacing()
		{
			return Game.m_noMap ? MyLittleUI.windsPositionSpacingNomap.Value : MyLittleUI.windsPositionSpacing.Value;
		}

		public static MyLittleUI.ListDirection GetWindsListDirection()
		{
			return Game.m_noMap ? MyLittleUI.windsFillingDirectionNomap.Value : MyLittleUI.windsFillingDirection.Value;
		}

		internal static bool IsWindListVertical()
		{
			MyLittleUI.ListDirection windsListDirection = GetWindsListDirection();
			if (1 == 0)
			{
			}
			bool result = windsListDirection switch
			{
				MyLittleUI.ListDirection.TopToBottom => true, 
				MyLittleUI.ListDirection.BottomToTop => true, 
				_ => false, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static void SetWindPosition(RectTransform rtWind, int i, RectTransform rtParent)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			float num = (IsWindListVertical() ? InfoBlocks.GetWindsSize().x : InfoBlocks.GetWindsSize().y) - 1f;
			rtWind.sizeDelta = Vector2.one * num;
			float num2 = GetWindsSpacing() * (1f - (float)i) + num * ((float)i + 0.5f);
			MyLittleUI.ListDirection windsListDirection = GetWindsListDirection();
			if (1 == 0)
			{
			}
			Vector3 val;
			Rect rect;
			switch (windsListDirection)
			{
			case MyLittleUI.ListDirection.LeftToRight:
				val = new Vector3(num2, num / 2f, 0f);
				break;
			case MyLittleUI.ListDirection.RightToLeft:
				rect = rtParent.rect;
				val = new Vector3(((Rect)(ref rect)).width - num2, num / 2f, 0f);
				break;
			case MyLittleUI.ListDirection.TopToBottom:
			{
				float num3 = num / 2f;
				rect = rtParent.rect;
				val = new Vector3(num3, ((Rect)(ref rect)).height - num2, 0f);
				break;
			}
			case MyLittleUI.ListDirection.BottomToTop:
				val = new Vector3(num / 2f, num2, 0f);
				break;
			default:
				val = new Vector3(num2, num / 2f, 0f);
				break;
			}
			if (1 == 0)
			{
			}
			rtWind.anchoredPosition = Vector2.op_Implicit(val);
		}

		private static Vector4 GetWind(int period)
		{
			//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)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)EnvMan.instance))
			{
				return Vector4.zero;
			}
			State state = Random.state;
			float num = 0f;
			float num2 = 0.5f;
			long num3 = (windPeriod + period) * GetWindPeriodDuration();
			EnvMan.instance.AddWindOctave(num3, 1, ref num, ref num2);
			EnvMan.instance.AddWindOctave(num3, 2, ref num, ref num2);
			EnvMan.instance.AddWindOctave(num3, 4, ref num, ref num2);
			EnvMan.instance.AddWindOctave(num3, 8, ref num, ref num2);
			Random.state = state;
			return new Vector4(Mathf.Sin(num), 0f, Mathf.Cos(num), Mathf.Clamp(num2, 0.05f, 1f));
		}

		private static WeatherState GetWeatherState(EnvSetup env)
		{
			if (env == null)
			{
				return WeatherState.Clear;
			}
			if (IsInList(env, MyLittleUI.forecastListRainCinder.Value.Split(',')))
			{
				return WeatherState.RainCinder;
			}
			if (IsInList(env, MyLittleUI.forecastListMist.Value.Split(',')))
			{
				return WeatherState.Mist;
			}
			if (IsInList(env, MyLittleUI.forecastListThunder.Value.Split(',')))
			{
				return WeatherState.Thunder;
			}
			if (IsInList(env, MyLittleUI.forecastListSnow.Value.Split(',')))
			{
				return WeatherState.Snow;
			}
			if (IsInList(env, MyLittleUI.forecastListRain.Value.Split(',')))
			{
				return WeatherState.Rain;
			}
			return WeatherState.Clear;
		}

		private static bool IsInList(EnvSetup env, string[] environmentSystems)
		{
			return ((Object)(object)env.m_envObject != (Object)null && environmentSystems.Contains(((Object)env.m_envObject).name)) || (env.m_psystems != null && env.m_psystems.Any((GameObject ps) => ((Object)ps).name != null && environmentSystems.Contains(((Object)ps).name)));
		}

		private static EnvSetup GetEnvironment(long period, Biome biome, bool isAshlands, bool isDeepNorth)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			State state = Random.state;
			Random.InitState((int)period);
			EnvSetup availableEnvironment = GetAvailableEnvironment(biome, isAshlands, isDeepNorth);
			Random.state = state;
			return availableEnvironment;
		}

		private static EnvSetup GetAvailableEnvironment(Biome biome, bool isAshlands, bool isDeepNorth)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			List<EnvEntry> availableEnvironments = EnvMan.instance.GetAvailableEnvironments(biome);
			if (availableEnvironments != null && availableEnvironments.Count > 0)
			{
				EnvSetup result = EnvMan.instance.SelectWeightedEnvironment(availableEnvironments);
				foreach (EnvEntry item in availableEnvironments)
				{
					if (item.m_ashlandsOverride && isAshlands)
					{
						result = item.m_env;
					}
					if (item.m_deepnorthOverride && isDeepNorth)
					{
						result = item.m_env;
					}
				}
				return result;
			}
			return null;
		}
	}
	public static class InventoryPanel
	{
		[HarmonyPatch(typeof(Hud), "OnDestroy")]
		public static class Hud_OnDestroy_Clear
		{
			public static void Postfix()
			{
				if (MyLittleUI.modEnabled.Value)
				{
					weight = null;
					slots = null;
					weightText = null;
					slotsText = null;
					weightBar = null;
					slotsBar = null;
					weightBackground = null;
					slotsBackground = null;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnInventoryChanged")]
		public static class Player_OnInventoryChanged_UpdateStats
		{
			public static void Postfix(Player __instance)
			{
				if (MyLittleUI.modEnabled.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !__instance.m_isLoading)
				{
					UpdateStats();
				}
			}
		}

		[HarmonyPatch]
		public static class Humanoid_UpdateStats
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

				[DebuggerHidden]
				public <TargetMethods>d__0(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Humanoid), "EquipItem", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = AccessTools.Method(typeof(Humanoid), "UnequipItem", (Type[])null, (Type[])null);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						return false;
					}
				}

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

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

				[DebuggerHidden]
				IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__0(0);
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<MethodBase>)this).GetEnumerator();
				}
			}

			[IteratorStateMachine(typeof(<TargetMethods>d__0))]
			private static IEnumerable<MethodBase> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__0(-2);
			}

			private static void Postfix(Humanoid __instance)
			{
				if (MyLittleUI.modEnabled.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !((Player)((__instance is Player) ? __instance : null)).m_isLoading)
				{
					UpdateStats();
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		public static class Player_OnSpawned_UpdateStats
		{
			public static void Postfix(Player __instance)
			{
				if (MyLittleUI.modEnabled.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					UpdateStats();
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "Update")]
		public static class Hud_Update_UpdateVisuals
		{
			public static void Postfix()
			{
				if (MyLittleUI.modEnabled.Value)
				{
					UpdateVisuals();
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "AddStatusEffect", new Type[]
		{
			typeof(StatusEffect),
			typeof(bool),
			typeof(int),
			typeof(float)
		})]
		public static class SEManAddStatusEffect_UpdateStats
		{
			public static void Postfix(StatusEffect __result)
			{
				if (MyLittleUI.modEnabled.Value)
				{
					SE_Stats val = (SE_Stats)(object)((__result is SE_Stats) ? __result : null);
					if (val != null && val.m_addMaxCarryWeight > 0f)
					{
						UpdateVisuals();
					}
				}
			}
		}

		private const string objectWeightName = "Weight";

		private const string objectSlotsName = "Slots";

		public static RectTransform weight;

		public static RectTransform slots;

		public static TMP_Text weightText;

		public static TMP_Text slotsText;

		public static GuiBar weightBar;

		public static GuiBar slotsBar;

		private static Image weightBackground;

		private static Image slotsBackground;

		private static int totalWeight;

		private static int maxWeight;

		private static int emptySlots;

		private static int maxSlots;

		private static Gradient gradient;

		internal static void AddBlock(GameObject parentObject)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)parentObject == (Object)null))
			{
				weight = new GameObject("Weight", new Type[1] { typeof(RectTransform) })
				{
					layer = MyLittleUI.layerUI
				}.GetComponent<RectTransform>();
				((Transform)weight).SetParent(parentObject.transform, false);
				weight.SetAnchor(MyLittleUI.ElementAnchor.BottomLeft);
				weight.sizeDelta = Vector2.one * 64f;
				weight.anchoredPosition = new Vector2(62f, 332f);
				TMP_Text obj = InventoryGui.instance.m_weight;
				object obj2;
				if (obj == null)
				{
					obj2 = null;
				}
				else
				{
					Transform obj3 = obj.transform.parent.Find("weight_icon");
					obj2 = ((obj3 != null) ? ((Component)obj3).transform : null);
				}
				RectTransform val = Object.Instantiate<RectTransform>((RectTransform)((obj2 is RectTransform) ? obj2 : null), (Transform)(object)weight);
				((Object)val).name = "Icon";
				val.anchorMin = Vector2.one * 0.5f;
				val.anchorMax = Vector2.one * 0.5f;
				val.sizeDelta = Vector2.one * 32f;
				val.anchoredPosition = new Vector2(0f, 12f);
				TMP_Text obj4 = InventoryGui.instance.m_weight;
				Transform obj5 = ((obj4 != null) ? obj4.transform : null);
				RectTransform val2 = Object.Instantiate<RectTransform>((RectTransform)(object)((obj5 is RectTransform) ? obj5 : null), (Transform)(object)weight);
				((Object)val2).name = "Text";
				val2.anchorMin = Vector2.one * 0.5f;
				val2.anchorMax = Vector2.one * 0.5f;
				val2.sizeDelta = new Vector2(64f, 22f);
				val2.anchoredPosition = new Vector2(0f, -11f);
				weightText = ((Component)val2).GetComponent<TMP_Text>();
				GameObject elementPrefab = InventoryGui.instance.m_playerGrid.m_elementPrefab;
				Transform obj6 = Object.Instantiate<Transform>((elementPrefab != null) ? elementPrefab.transform.Find("durability") : null, (Transform)(object)weight);
				RectTransform val3 = ((obj6 != null) ? ((Component)obj6).GetComponent<RectTransform>() : null);
				((Object)val3).name = "Bar";
				val3.anchorMin = Vector2.one * 0.5f;
				val3.anchorMax = Vector2.one * 0.5f;
				val3.sizeDelta = new Vector2(54f, 5f);
				val3.anchoredPosition = new Vector2(0f, -25f);
				weightBar = ((Component)val3).GetComponent<GuiBar>();
				Image component = InventoryGui.instance.m_playerGrid.m_elementPrefab.GetComponent<Image>();
				weightBackground = ((Component)weight).gameObject.AddComponent<Image>();
				weightBackground.sprite = component.sprite;
				((Graphic)weightBackground).color = new Color(0f, 0f, 0f, 0.5f);
				slots = Object.Instantiate<RectTransform>(weight, parentObject.transform);
				((Object)slots).name = "Slots";
				slots.anchoredPosition = new Vector2(62f, 265f);
				Transform obj7 = ((Transform)slots).Find("Icon");
				RectTransform val4 = (RectTransform)(object)((obj7 is RectTransform) ? obj7 : null);
				((Component)val4).GetComponent<Image>().sprite = Minimap.instance.m_locationIcons.Select((LocationSpriteData loc) => loc.m_icon).FirstOrDefault((Func<Sprite, bool>)((Sprite icon) => ((Object)icon).name == "mapicon_trader"));
				val4.anchoredPosition = new Vector2(0f, 12.5f);
				val4.sizeDelta = Vector2.one * 38f;
				slotsText = ((Component)((Transform)slots).Find("Text")).GetComponent<TMP_Text>();
				slotsBar = ((Component)((Transform)slots).Find("Bar")).GetComponent<GuiBar>();
				slotsBackground = ((Component)slots).GetComponent<Image>();
			}
		}

		public static void UpdateStats()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				UpdateGradient();
				totalWeight = Mathf.FloorToInt(((Humanoid)Player.m_localPlayer).GetInventory().GetTotalWeight());
				maxWeight = Mathf.FloorToInt(Player.m_localPlayer.GetMaxCarryWeight());
				GetCurrentSlotsAmount(out emptySlots, out maxSlots);
			}
		}

		public static void UpdateGradient()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			if (gradient == null)
			{
				gradient = new Gradient();
			}
			gradient.SetKeys((GradientColorKey[])(object)new GradientColorKey[4]
			{
				new GradientColorKey(MyLittleUI.weightSlotsFine.Value, 0f),
				new GradientColorKey(MyLittleUI.weightSlotsHalf.Value, 0.5f),
				new GradientColorKey(MyLittleUI.weightSlotsALot.Value, 0.75f),
				new GradientColorKey(MyLittleUI.weightSlotsFull.Value, 1f)
			}, Array.Empty<GradientAlphaKey>());
		}

		public static void UpdateConfigurableValues()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)weightBackground))
			{
				((Graphic)weightBackground).color = MyLittleUI.weightBackgroundColor.Value;
			}
			if (Object.op_Implicit((Object)(object)slotsBackground))
			{
				((Graphic)slotsBackground).color = MyLittleUI.slotsBackgroundColor.Value;
			}
			if (Object.op_Implicit((Object)(object)weight))
			{
				((Component)weight).gameObject.SetActive(MyLittleUI.modEnabled.Value && MyLittleUI.showWeight.Value);
				if (((Component)weight).gameObject.activeInHierarchy)
				{
					weight.SetAnchor(MyLittleUI.weightPositionAnchor.Value);
					weight.anchoredPosition = MyLittleUI.weightPosition.Value;
					if (Object.op_Implicit((Object)(object)weightText))
					{
						((Graphic)weightText).color = MyLittleUI.weightFontColor.Value;
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)slots))
			{
				return;
			}
			((Component)slots).gameObject.SetActive(MyLittleUI.modEnabled.Value && MyLittleUI.showSlots.Value);
			if (((Component)slots).gameObject.activeInHierarchy)
			{
				slots.SetAnchor(MyLittleUI.slotsPositionAnchor.Value);
				slots.anchoredPosition = MyLittleUI.slotsPosition.Value;
				if (Object.op_Implicit((Object)(object)slotsText))
				{
					((Graphic)slotsText).color = MyLittleUI.slotsFontColor.Value;
				}
			}
		}

		public static void UpdateVisuals()
		{
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return;
			}
			UpdateConfigurableValues();
			if (Object.op_Implicit((Object)(object)weight) && ((Component)weight).gameObject.activeInHierarchy)
			{
				int num = (MyLittleUI.showWeightLeft.Value ? (maxWeight - totalWeight) : totalWeight);
				TMP_Text obj = weightText;
				if (obj != null)
				{
					obj.SetText((maxWeight <= 0) ? StringExtensionMethods.ToFastString(num) : string.Format(GetFormatString(totalWeight > maxWeight), num, maxWeight));
				}
				if (Object.op_Implicit((Object)(object)weightBar))
				{
					weightBar.SetMaxValue((float)maxWeight);
					weightBar.SetValue((float)totalWeight);
					if (gradient != null && weightBar.m_maxValue != 0f)
					{
						weightBar.SetColor(gradient.Evaluate(Mathf.Clamp01(weightBar.m_value / weightBar.m_maxValue)));
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)slots) || !((Component)slots).gameObject.activeInHierarchy)
			{
				return;
			}
			TMP_Text obj2 = slotsText;
			if (obj2 != null)
			{
				obj2.SetText(string.Format(GetFormatString(emptySlots <= 0), StringExtensionMethods.ToFastString(MyLittleUI.showSlotsTaken.Value ? (maxSlots - emptySlots) : emptySlots), StringExtensionMethods.ToFastString(maxSlots)));
			}
			if (Object.op_Implicit((Object)(object)slotsBar))
			{
				slotsBar.SetMaxValue((float)maxSlots);
				slotsBar.SetValue((float)(maxSlots - emptySlots));
				if (gradient != null && slotsBar.m_maxValue != 0f)
				{
					slotsBar.SetColor(gradient.Evaluate(Mathf.Clamp01(slotsBar.m_value / slotsBar.m_maxValue)));
				}
			}
			static string GetFormatString(bool condition)
			{
				return (condition && Mathf.Sin(Time.time * 10f) > 0f) ? "<color=red>{0}</color>/{1}" : "{0}/{1}";
			}
		}

		public static void GetCurrentSlotsAmount(out int emptySlots, out int slotsAmount)
		{
			int width = ((Humanoid)Player.m_localPlayer).GetInventory().GetWidth();
			int height = ((Humanoid)Player.m_localPlayer).GetInventory().GetHeight();
			if (AzuExtendedPlayerInventory.API.IsLoaded())
			{
				height -= AzuExtendedPlayerInventory.API.GetAddedRows(width);
			}
			else if (ExtraSlotsAPI.API.IsReady())
			{
				height = ExtraSlotsAPI.API.GetInventoryHeightPlayer();
			}
			slotsAmount = width * height;
			emptySlots = slotsAmount - ((Humanoid)Player.m_localPlayer).GetInventory().m_inventory.Where((ItemData item) => item.m_gridPos.x < width && item.m_gridPos.y < height).Count();
			PluginInfo value;
			ConfigEntry<bool> val = default(ConfigEntry<bool>);
			if (AzuExtendedPlayerInventory.API.IsLoaded())
			{
				int num = AzuExtendedPlayerInventory.API.GetQuickSlots().SlotNames.Length;
				emptySlots += num - AzuExtendedPlayerInventory.API.GetQuickSlotsItems().Count;
				slotsAmount += num;
			}
			else if (ExtraSlotsAPI.API.IsReady())
			{
				int num2 = ExtraSlotsAPI.API.GetQuickSlots().Count((ExtraSlot slot) => slot.IsActive);
				emptySlots += num2 - ExtraSlotsAPI.API.GetQuickSlotsItems().Count;
				slotsAmount += num2;
			}
			else if (Chainloader.PluginInfos.TryGetValue("randyknapp.mods.equipmentandquickslots", out value) && value.Instance.Config.TryGetEntry<bool>("Toggles", "Enable Quick Slots", ref val) && val.Value)
			{
				slotsAmount += 3;
				emptySlots = ((Humanoid)Player.m_localPlayer).GetInventory().GetEmptySlots();
			}
		}
	}
}
namespace MyLittleUI.Crafting
{
	public static class CraftNew
	{
		[HarmonyPatch(typeof(InventoryGui), "UpdateRecipeList")]
		public static class InventoryGui_UpdateRecipeList_CraftNewRecipeMark
		{
			[HarmonyPriority(0)]
			public static void Postfix()
			{
				UpdateCraftNewMark();
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		public static class Player_Load_FillRequiredItems
		{
			[HarmonyPriority(0)]
			public static void Postfix()
			{
				FillRequiredItems();
			}
		}

		public static readonly HashSet<string> requiredItems = new HashSet<string>();

		public static bool IsEnabled => MyLittleUI.modEnabled.Value && MyLittleUI.craftingNewMarkEnabled.Value;

		public static bool IsItemToShow(ItemData item)
		{
			return Object.op_Implicit((Object)(object)Player.m_localPlayer) && !Player.m_localPlayer.IsKnownMaterial(item.m_shared.m_name) && (!MyLittleUI.craftingNewMarkShowOnlyWithUnlocks.Value || requiredItems.Contains(item.m_shared.m_name));
		}

		public static void UpdateCraftNewMark()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			if (!IsEnabled)
			{
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			if (instance == null || !instance.InCraftTab() || InventoryGui.instance.m_availableRecipes.Count == 0 || requiredItems.Count == 0)
			{
				return;
			}
			foreach (RecipeDataPair availableRecipe in InventoryGui.instance.m_availableRecipes)
			{
				RecipeDataPair current = availableRecipe;
				if (((RecipeDataPair)(ref current)).ItemData == null && (Object)(object)((RecipeDataPair)(ref current)).InterfaceElement != (Object)null && (Object)(object)((RecipeDataPair)(ref current)).Recipe != (Object)null && IsItemToShow(((RecipeDataPair)(ref current)).Recipe.m_item.m_itemData))
				{
					Transform obj = ((RecipeDataPair)(ref current)).InterfaceElement.transform.Find("QualityLevel");
					TMP_Text val = ((obj != null) ? ((Component)obj).GetComponent<TMP_Text>() : null);
					if (!((Component)val).gameObject.activeSelf)
					{
						val.SetText(MyLittleUI.craftingNewMarkText.Value);
						val.fontStyle = MyLittleUI.craftingNewMarkFontStyle.Value;
						val.fontSize = MyLittleUI.craftingNewMarkFontSize.Value;
						((Graphic)val).color = MyLittleUI.craftingNewMarkColor.Value;
						((Component)val).gameObject.SetActive(true);
					}
				}
			}
		}

		public static void FillRequiredItems()
		{
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				return;
			}
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				if (!((Object)(object)item != (Object)null))
				{
					continue;
				}
				ItemDrop component = item.GetComponent<ItemDrop>();
				if (component == null)
				{
					continue;
				}
				ItemData itemData = component.m_itemData;
				if (itemData == null)
				{
					continue;
				}
				SharedData shared = itemData.m_shared;
				if (shared == null)
				{
					continue;
				}
				PieceTable buildPieces = shared.m_buildPieces;
				if (buildPieces == null)
				{
					continue;
				}
				foreach (GameObject piece in buildPieces.m_pieces)
				{
					Piece component2 = piece.GetComponent<Piece>();
					if (component2 == null || component2.m_resources == null)
					{
						continue;
					}
					Requirement[] resources = component2.m_resources;
					foreach (Requirement val in resources)
					{
						if (!((Object)(object)val.m_resItem != (Object)null))
						{
							continue;
						}
						ItemData itemData2 = val.m_resItem.m_itemData;
						if (itemData2 != null)
						{
							SharedData shared2 = itemData2.m_shared;
							if (shared2 != null)
							{
								requiredItems.Add(shared2.m_name);
							}
						}
					}
				}
			}
			foreach (Recipe recipe in ObjectDB.instance.m_recipes)
			{
				if (recipe.m_resources == null)
				{
					continue;
				}
				Requirement[] resources2 = recipe.m_resources;
				foreach (Requirement val2 in resources2)
				{
					if (!((Object)(object)val2.m_resItem != (Object)null))
					{
						continue;
					}
					ItemData itemData3 = val2.m_resItem.m_itemData;
					if (itemData3 != null)
					{
						SharedData shared3 = itemData3.m_shared;
						if (shared3 != null)
						{
							requiredItems.Add(shared3.m_name);
						}
					}
				}
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZRpc rpc2 = rpc;
				ZNet __instance2 = __instance;
				Dictionary<Assembly, BufferingSocket> __state2 = __state;
				ZNetPeer peer;
				if (__instance2.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc2.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			CustomSyncedValueBase customValue2 = customValue;
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue2.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue2);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue2.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue2);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZNetPeer peer2 = peer;
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer2.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer2.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer2.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
						peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer2);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			ZPackage package2 = package;
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package2.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package2 = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package2)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace AzuExtendedPlayerInventory
{
	[PublicAPI]
	internal class API
	{
		public delegate void SlotAddedHandler(string slotName);

		public delegate void SlotRemovedHandler(string slotName);

		public static event Action<Hud>? OnHudAwake;

		public static event Action<Hud>? OnHudAwakeComplete;

		public static event Action<Hud>? OnHudUpdate;

		public static event Action<Hud>? OnHudUpdateComplete;

		public static event SlotAddedHandler? SlotAdded;

		public static event SlotRemovedHandler? SlotRemoved;

		public static bool IsLoaded()
		{
			return false;
		}

		public static bool AddSlot(string slotName, Func<Player, ItemData?> getItem, Func<ItemData, bool> isValid, int index = -1)
		{
			return false;
		}

		public static bool RemoveSlot(string slotName)
		{
			return false;
		}

		public static SlotInfo GetSlots()
		{
			return new SlotInfo();
		}

		public static SlotInfo GetQuickSlots()
		{
			return new SlotInfo();
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			return new List<ItemData>();
		}

		public static int GetAddedRows(int width)
		{
			return 0;
		}
	}
	[PublicAPI]
	internal class SlotInfo
	{
		public string[] SlotNames { get; set; } = new string[0];


		public Vector2[] SlotPositions { get; set; } = (Vector2[])(object)new Vector2[0];


		public Func<Player, ItemData?>?[] GetItemFuncs { get; set; } = new Func<Player, ItemData>[0];


		public Func<ItemData, bool>?[] IsValidFuncs { get; set; } = new Func<ItemData, bool>[0];

	}
}
namespace ExtraSlotsAPI
{
	internal static class API
	{
		private static bool _isNotReady;

		private static readonly List<ItemData> _emptyItemList = new List<ItemData>();

		private static readonly List<ExtraSlot> _emptySlotList = new List<ExtraSlot>();

		internal static Type _typeAPI;

		internal static Type _typeSlot;

		public static bool IsReady()
		{
			if (_isNotReady)
			{
				return false;
			}
			if (_typeAPI != null && _typeSlot != null)
			{
				return true;
			}
			_isNotReady = !Chainloader.PluginInfos.ContainsKey("shudnal.ExtraSlots");
			if (_isNotReady)
			{
				return false;
			}
			if (_typeAPI == null || _typeSlot == null)
			{
				Assembly assembly = Assembly.GetAssembly(((object)Chainloader.PluginInfos["shudnal.ExtraSlots"].Instance).GetType());
				if (assembly == null)
				{
					_isNotReady = true;
					return false;
				}
				_typeAPI = assembly.GetType("ExtraSlots.API");
				_typeSlot = assembly.GetType("ExtraSlots.Slots+Slot");
			}
			if (_typeAPI != null)
			{
				return _typeSlot != null;
			}
			return false;
		}

		public static List<ExtraSlot> GetExtraSlots()
		{
			if (!IsReady())
			{
				return _emptySlotList;
			}
			return ((IEnumerable<object>)AccessTools.Method(_typeAPI, "GetExtraSlots", (Type[])null, (Type[])null).Invoke(_typeAPI, null)).Select((object slot) => slot.ToExtraSlot()).ToList();
		}

		public static List<ExtraSlot> GetEquipmentSlots()
		{
			if (!IsReady())
			{
				return _emptySlotList;
			}
			return ((IEnumerable<object>)AccessTools.Method(_typeAPI, "GetEquipmentSlots", (Type[])null, (Type[])null).Invoke(_typeAPI, null)).Select((object slot) => slot.ToExtraSlot()).ToList();
		}

		public static List<ExtraSlot> GetQuickSlots()
		{
			if (!IsReady())
			{
				return _emptySlotList;
			}
			return ((IEnumerable<object>)AccessTools.Method(_typeAPI, "GetQuickSlots", (Type[])null, (Type[])null).Invoke(_typeAPI, null)).Select((object slot) => slot.ToExtraSlot()).ToList();
		}

		public static List<ExtraSlot> GetFoodSlots()
		{
			if (!IsReady())
			{
				return _emptySlotList;
			}
			return ((IEnumerable<object>)AccessTools.Method(_typeAPI, "GetFoodSlots", (Type[])null, (Type[])null).Invoke(_typeAPI, null)).Select((object slot) => slot.ToExtraSlot()).ToList();
		}

		public static List<ExtraSlot> GetAmmoSlots()
		{
			if (!IsReady())
			{
				return _emptySlotList;
			}
			return ((IEnumerable<object>)AccessTools.Method(_typeAPI, "GetAmmoSlots", (Type[])null, (Type[])null).Invoke(_typeAPI, null)).Select((object slot) => slot.ToExtraSlot()).ToList();
		}

		public static List<ExtraSlot> GetMiscSlots()
		{
			if (!IsReady())
			{
				return _emptySlotList;
			}
			return ((IEnumerable<object>)AccessTools.Method(_typeAPI, "GetMiscSlots", (Type[])null, (Type[])null).Invoke(_typeAPI, null)).Select((object slot) => slot.ToExtraSlot()).ToList();
		}

		public static ExtraSlot FindSlot(string slotID)
		{
			if (!IsReady())
			{
				return null;
			}
			return AccessTools.Method(_typeAPI, "FindSlot", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[1] { slotID }).ToExtraSlot();
		}

		public static List<ItemData> GetAllExtraSlotsItems()
		{
			if (!IsReady())
			{
				return _emptyItemList;
			}
			return (List<ItemData>)AccessTools.Method(_typeAPI, "GetAllExtraSlotsItems", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static List<ItemData> GetEquipmentSlotsItems()
		{
			if (!IsReady())
			{
				return _emptyItemList;
			}
			return (List<ItemData>)AccessTools.Method(_typeAPI, "GetEquipmentSlotsItems", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static List<ItemData> GetQuickSlotsItems()
		{
			if (!IsReady())
			{
				return _emptyItemList;
			}
			return (List<ItemData>)AccessTools.Method(_typeAPI, "GetQuickSlotsItems", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static List<ItemData> GetFoodSlotsItems()
		{
			if (!IsReady())
			{
				return _emptyItemList;
			}
			return (List<ItemData>)AccessTools.Method(_typeAPI, "GetFoodSlotsItems", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static List<ItemData> GetAmmoSlotsItems()
		{
			if (!IsReady())
			{
				return _emptyItemList;
			}
			return (List<ItemData>)AccessTools.Method(_typeAPI, "GetAmmoSlotsItems", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static List<ItemData> GetMiscSlotsItems()
		{
			if (!IsReady())
			{
				return _emptyItemList;
			}
			return (List<ItemData>)AccessTools.Method(_typeAPI, "GetMiscSlotsItems", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static int GetExtraRows()
		{
			if (!IsReady())
			{
				return -1;
			}
			return (int)AccessTools.Method(_typeAPI, "GetExtraRows", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static int GetInventoryHeightFull()
		{
			if (!IsReady())
			{
				return -1;
			}
			return (int)AccessTools.Method(_typeAPI, "GetInventoryHeightFull", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static int GetInventoryHeightPlayer()
		{
			if (!IsReady())
			{
				return -1;
			}
			return (int)AccessTools.Method(_typeAPI, "GetInventoryHeightPlayer", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
		}

		public static bool IsGridPositionASlot(Vector2i gridPos)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "IsGridPositionASlot", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[1] { gridPos });
		}

		public static bool IsItemInSlot(ItemData item)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "IsItemInSlot", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[1] { item });
		}

		public static bool IsItemInEquipmentSlot(ItemData item)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "IsItemInEquipmentSlot", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[1] { item });
		}

		public static bool IsAnyGlobalKeyActive(string requiredKeys)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "requiredKeys", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[1] { requiredKeys });
		}

		public static bool IsItemTypeKnown(ItemType itemType)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "IsItemTypeKnown", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[1] { itemType });
		}

		public static bool IsAnyMaterialDiscovered(string itemNames)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "IsAnyMaterialDiscovered", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[1] { itemNames });
		}

		public static bool AddSlot(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "AddSlot", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[5] { slotID, -1, getName, itemIsValid, isActive });
		}

		public static bool AddSlotWithIndex(string slotID, int slotIndex, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "AddSlotWithIndex", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[5] { slotID, slotIndex, getName, itemIsValid, isActive });
		}

		public static bool AddSlotBefore(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive, params string[] slotIDs)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "AddSlotBefore", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[5] { slotID, getName, itemIsValid, isActive, slotIDs });
		}

		public static bool AddSlotAfter(string slotID, Func<string> getName, Func<ItemData, bool> itemIsValid, Func<bool> isActive, params string[] slotIDs)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "AddSlotAfter", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[5] { slotID, getName, itemIsValid, isActive, slotIDs });
		}

		public static bool RemoveSlot(string slotID)
		{
			if (!IsReady())
			{
				return false;
			}
			return (bool)AccessTools.Method(_typeAPI, "RemoveSlot", (Type[])null, (Type[])null).Invoke(_typeAPI, new object[1] { slotID });
		}

		public static void UpdateSlots()
		{
			if (IsReady())
			{
				AccessTools.Method(_typeAPI, "UpdateSlots", (Type[])null, (Type[])null).Invoke(_typeAPI, null);
			}
		}
	}
	internal static class Extensions
	{
		internal static ExtraSlot ToExtraSlot(this object slot)
		{
			return new ExtraSlot
			{
				_id = () => (string)AccessTools.Property(API._typeSlot, "ID").GetValue(slot),
				_name = () => (string)AccessTools.Property(API._typeSlot, "Name").GetValue(slot),
				_gridPosition = () => (Vector2i)AccessTools.Property(API._typeSlot, "GridPosition").GetValue(slot),
				_item = () => (ItemData)AccessTools.Property(API._typeSlot, "Item").GetValue(slot),
				_itemFits = (ItemData item) => (bool)AccessTools.Method(API._typeSlot, "ItemFits", (Type[])null, (Type[])null).Invoke(slot, new object[1] { item }),
				_isActive = () => (bool)AccessTools.Property(API._typeSlot, "IsActive").GetValue(slot),
				_isFree = () => (bool)AccessTools.Property(API._typeSlot, "IsFree").GetValue(slot),
				_isHotkeySlot = () => (bool)AccessTools.Property(API._typeSlot, "IsHotkeySlot").GetValue(slot),
				_isEquipmentSlot = () => (bool)AccessTools.Property(API._typeSlot, "IsEquipmentSlot").GetValue(slot),
				_isQuickSlot = () => (bool)AccessTools.Property(API._typeSlot, "IsQuickSlot").GetValue(slot),
				_isMiscSlot = () => (bool)AccessTools.Property(API._typeSlot, "IsMiscSlot").GetValue(slot),
				_isAmmoSlot = () => (bool)AccessTools.Property(API._typeSlot, "IsAmmoSlot").GetValue(slot),
				_isFoodSlot = () => (bool)AccessTools.Property(API._typeSlot, "IsFoodSlot").GetValue(slot),
				_isCustomSlot = () => (bool)AccessTools.Property(API._typeSlot, "IsCustomSlot").GetValue(slot),
				_isEmptySlot = () => (bool)AccessTools.Property(API._typeSlot, "IsEmptySlot").GetValue(slot)
			};
		}
	}
	internal class ExtraSlot
	{
		internal Func<string> _id;

		internal Func<string> _name;

		internal Func<Vector2i> _gridPosition;

		internal Func<ItemData> _item;

		internal Func<ItemData, bool> _itemFits;

		internal Func<bool> _isActive;

		internal Func<bool> _isFree;

		internal Func<bool> _isHotkeySlot;

		internal Func<bool> _isEquipmentSlot;

		internal Func<bool> _isQuickSlot;

		internal Func<bool> _isMiscSlot;

		internal Func<bool> _isAmmoSlot;

		internal Func<bool> _isFoodSlot;

		internal Func<bool> _isCustomSlot;

		internal Func<bool> _isEmptySlot;

		public static readonly Vector2i emptyPosition = new Vector2i(-1, -1);

		public string ID
		{
			get
			{
				if (_id != null)
				{
					return _id();
				}
				return "";
			}
		}

		public string Name
		{
			get
			{
				if (_name != null)
				{
					return _name();
				}
				return "";
			}
		}

		public Vector2i GridPosition
		{
			get
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (_gridPosition != null)
				{
					return _gridPosition();
				}
				return emptyPosition;
			}
		}

		public ItemData Item
		{
			get
			{
				if (_item != null)
				{
					return _item();
				}
				return null;
			}
		}

		public bool IsActive
		{
			get
			{
				if (_isActive != null)
				{
					return _isActive();
				}
				return false;
			}
		}

		public bool IsFree
		{
			get
			{
				if (_isFree != null)
				{
					return _isFree();
				}
				return false;
			}
		}

		public bool IsHotkeySlot
		{
			get
			{
				if (_isHotkeySlot != null)
				{
					return _isHotkeySlot();
				}
				return false;
			}
		}

		public bool IsEquipmentSlot
		{
			get
			{
				if (_isEquipmentSlot != null)
				{
					return _isEquipmentSlot();
				}
				return false;
			}
		}

		public bool IsQuickSlot
		{
			get
			{
				if (_isQuickSlot != null)
				{
					return _isQuickSlot();
				}
				return false;
			}
		}

		public bool IsMiscSlot
		{
			get
			{
				if (_isMiscSlot != null)
				{
					return _isMiscSlot();
				}
				return false;
			}
		}

		public bool IsAmmoSlot
		{
			get
			{
				if (_isAmmoSlot != null)
				{
					return _isAmmoSlot();
				}
				return false;
			}
		}

		public bool IsFoodSlot
		{
			get
			{
				if (_isFoodSlot != null)
				{
					return _isFoodSlot();
				}
				return false;
			}
		}

		public bool IsCustomSlot
		{
			get
			{
				if (_isCustomSlot != null)
				{
					return _isCustomSlot();
				}
				return false;
			}
		}

		public bool IsEmptySlot
		{
			get
			{
				if (_isEmptySlot != null)
				{
					return _isEmptySlot();
				}
				return false;
			}
		}

		public bool ItemFits(ItemData item)
		{
			if (_itemFits != null)
			{
				return _itemFits(item);
			}
			return false;
		}
	}
}