using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using FateForge.Core;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using SoftReferenceableAssets;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("FateForge")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.8.0")]
[assembly: AssemblyInformationalVersion("0.4.8")]
[assembly: AssemblyProduct("FateForge")]
[assembly: AssemblyTitle("FateForge")]
[assembly: AssemblyVersion("0.4.8.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 FateForge.Mod
{
	public sealed class EpicLootInspection
	{
		public bool Special;

		public bool Magic;

		public bool Unidentified;

		public bool Available;

		public string Reason = "";

		public string Summary = "";

		public string DisplaySuffix = "";

		public string MagicJson = "";

		public string EnchantCostsJson = "";

		public string SacrificeProductsJson = "";

		public string Fingerprint = "";

		public int Rarity = -1;

		public int? WagerRarity;
	}
	public sealed class EpicLootEnchantOption
	{
		public int Rarity;

		public string Display = "";

		public string Color = "#FFFFFF";

		public string CostSummary = "";

		public string CostsJson = "";

		public string BlockReason = "";

		public bool Available;
	}
	public static class EpicLootBridge
	{
		public const string PluginId = "randyknapp.mods.epicloot";

		public const string InspectedVersion = "0.14.5";

		private static readonly string[] RarityNames;

		private static readonly string[] QueryNames;

		private static Assembly _assembly;

		private static Type _api;

		private static Type _validatedApi;

		private static bool _resolved;

		private static string _pluginVersion;

		private static readonly object ApiLock;

		private static readonly MethodInfo ShallowCopy;

		private static readonly Dictionary<(Type, string, Type, Type, Type), MethodInfo> Methods;

		private static Type ApiType
		{
			get
			{
				ResolveApi();
				return _api;
			}
		}

		private static bool AssemblyPresent
		{
			get
			{
				ResolveApi();
				return _assembly != null;
			}
		}

		public static bool IsInstalled => AssemblyPresent;

		public static bool SupportedApiPresent
		{
			get
			{
				if (!AssemblyPresent)
				{
					return false;
				}
				try
				{
					Ready();
					return true;
				}
				catch
				{
					return false;
				}
			}
		}

		internal static Assembly ConfigurationAssembly => Ready().Assembly;

		public static string Status
		{
			get
			{
				if (!AssemblyPresent)
				{
					return "Epic Loot optional: not loaded. Ordinary gambling is available.";
				}
				try
				{
					Ready();
					return "Epic Loot " + _pluginVersion + " detected (public API 1). Existing magic offerings include configured enchant costs and a gear rarity premium; individual effects receive no invented bonus.";
				}
				catch (Exception ex)
				{
					return ex.GetBaseException().Message;
				}
			}
		}

		static EpicLootBridge()
		{
			RarityNames = new string[6] { "Magic", "Rare", "Epic", "Legendary", "Mythic", "Ancient" };
			QueryNames = new string[7] { "IsMagicItem", "IsUnidentified", "IsEpicLootItem", "IsRunestone", "IsShardStone", "IsMagicCraftingMaterial", "CanBeMagicItem" };
			ApiLock = new object();
			ShallowCopy = typeof(object).GetMethod("MemberwiseClone", BindingFlags.Instance | BindingFlags.NonPublic);
			Methods = new Dictionary<(Type, string, Type, Type, Type), MethodInfo>();
			AppDomain.CurrentDomain.AssemblyLoad += delegate(object _, AssemblyLoadEventArgs args)
			{
				if (args.LoadedAssembly.GetName().Name != "EpicLoot")
				{
					return;
				}
				lock (ApiLock)
				{
					_resolved = false;
					_validatedApi = null;
				}
			};
		}

		private static void ResolveApi()
		{
			lock (ApiLock)
			{
				if (!_resolved)
				{
					_assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly x) => string.Equals(x.GetName().Name, "EpicLoot", StringComparison.Ordinal));
					_api = _assembly?.GetType("EpicLoot.API", throwOnError: false);
					_resolved = true;
				}
			}
		}

		private static MethodInfo Required(Type api, string name, Type result, params Type[] parameters)
		{
			if (api == null || parameters.Length > 2)
			{
				throw new MissingMethodException("Unsupported Epic Loot public endpoint: " + name);
			}
			(Type, string, Type, Type, Type) key = (api, name, result, (parameters.Length != 0) ? parameters[0] : null, (parameters.Length > 1) ? parameters[1] : null);
			lock (ApiLock)
			{
				if (Methods.TryGetValue(key, out var value))
				{
					return value;
				}
				MethodInfo method = api.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameters, null);
				if (method == null || method.ReturnType != result)
				{
					throw new MissingMethodException("Unsupported Epic Loot public endpoint: " + name);
				}
				Methods.Add(key, method);
				return method;
			}
		}

		private static T Query<T>(Type api, string name, ItemData item)
		{
			return (T)Required(api, name, typeof(T), typeof(ItemData)).Invoke(null, new object[1] { item });
		}

		private static T Scalar<T>(Type api, string name)
		{
			return (T)Required(api, name, typeof(T)).Invoke(null, null);
		}

		private static string RarityText(Type api, string name, int rarity)
		{
			return (string)Required(api, name, typeof(string), typeof(int)).Invoke(null, new object[1] { rarity });
		}

		private static string EnchantCosts(Type api, ItemData item, int rarity)
		{
			return (string)Required(api, "GetEnchantCostsJson", typeof(string), typeof(ItemData), typeof(int)).Invoke(null, new object[2] { item, rarity });
		}

		private static string Localize(string value)
		{
			if (Localization.instance != null)
			{
				return Localization.instance.Localize(value);
			}
			return value;
		}

		public static void ValidateContract(Type api)
		{
			if (api == null)
			{
				throw new MissingMemberException("Epic Loot public API is unavailable.");
			}
			string[] queryNames = QueryNames;
			foreach (string name in queryNames)
			{
				Required(api, name, typeof(bool), typeof(ItemData));
			}
			queryNames = new string[2] { "GetMagicItemJson", "GetSacrificeProductsJson" };
			foreach (string name2 in queryNames)
			{
				Required(api, name2, typeof(string), typeof(ItemData));
			}
			queryNames = new string[2] { "GetApiVersion", "GetRarityCount" };
			foreach (string name3 in queryNames)
			{
				Required(api, name3, typeof(int));
			}
			Required(api, "GetPluginVersion", typeof(string));
			Required(api, "TryGetRarity", typeof(bool), typeof(ItemData), typeof(int).MakeByRefType());
			Required(api, "GetEnchantCostsJson", typeof(string), typeof(ItemData), typeof(int));
			queryNames = new string[2] { "GetRarityDisplayNameByIndex", "GetRarityColorByIndex" };
			foreach (string name4 in queryNames)
			{
				Required(api, name4, typeof(string), typeof(int));
			}
		}

		internal static string ValidateRuntimeContract(Type api)
		{
			string text = "unknown version";
			try
			{
				text = Scalar<string>(api, "GetPluginVersion");
				if (string.IsNullOrWhiteSpace(text) || text.Length > 128)
				{
					throw new NotSupportedException("Invalid public plugin version.");
				}
				ValidateContract(api);
				int num = Scalar<int>(api, "GetApiVersion");
				if (num != 1)
				{
					throw new NotSupportedException("Public API " + num + " has not been reviewed; API 1 is required.");
				}
				if (Scalar<int>(api, "GetRarityCount") != 6)
				{
					throw new NotSupportedException("Unsupported public rarity count.");
				}
				for (int i = 0; i < RarityNames.Length; i++)
				{
					if (RarityText(api, "GetRarityDisplayNameByIndex", i) != "$mod_epicloot_" + RarityNames[i])
					{
						throw new NotSupportedException("Unsupported public rarity order at index " + i + ".");
					}
				}
				return text;
			}
			catch (Exception ex)
			{
				throw new NotSupportedException("Epic Loot " + text + " is incompatible with Fate Forge: " + ex.GetBaseException().Message + " Pricing is stopped to avoid incorrect fallback values.");
			}
		}

		private static Type Ready()
		{
			Type apiType = ApiType;
			if ((object)_validatedApi != apiType || apiType == null)
			{
				_pluginVersion = ValidateRuntimeContract(apiType);
				_validatedApi = apiType;
			}
			return apiType;
		}

		internal static void EnsureCompatibleIfPresent()
		{
			if (AssemblyPresent)
			{
				Ready();
			}
		}

		internal static int? PublicRarity(ItemData item)
		{
			Type api = Ready();
			object[] array = new object[2]
			{
				Detached(item),
				-1
			};
			if (!(bool)Required(api, "TryGetRarity", typeof(bool), typeof(ItemData), typeof(int).MakeByRefType()).Invoke(null, array))
			{
				return null;
			}
			int num = (int)array[1];
			if (num < 0 || num >= Scalar<int>(api, "GetRarityCount"))
			{
				return null;
			}
			return num;
		}

		internal static bool TryMaterial(ItemData item, out int rarity, out string kind, out IReadOnlyList<EpicLootCost> sacrifice)
		{
			rarity = -1;
			kind = "";
			sacrifice = Array.Empty<EpicLootCost>();
			Type api = Ready();
			ItemData val = Detached(item);
			if (Query<bool>(api, "IsShardStone", val))
			{
				kind = "stone";
			}
			else if (Query<bool>(api, "IsRunestone", val))
			{
				kind = "rune";
			}
			else
			{
				if (!Query<bool>(api, "IsMagicCraftingMaterial", val))
				{
					return false;
				}
				kind = "material";
			}
			object[] array = new object[2] { val, -1 };
			if (!(bool)Required(api, "TryGetRarity", typeof(bool), typeof(ItemData), typeof(int).MakeByRefType()).Invoke(null, array))
			{
				return false;
			}
			rarity = (int)array[1];
			if (rarity < 0 || rarity >= Scalar<int>(api, "GetRarityCount") || rarity > 99)
			{
				return false;
			}
			if (kind == "stone")
			{
				sacrifice = EpicLootMetadata.ParseCosts(Query<string>(api, "GetSacrificeProductsJson", val));
			}
			return true;
		}

		public static EpicLootInspection Inspect(ItemData item)
		{
			EpicLootInspection epicLootInspection = new EpicLootInspection();
			if (item?.m_shared == null)
			{
				epicLootInspection.Reason = "Missing item data.";
				return epicLootInspection;
			}
			Dictionary<string, string> dictionary = item.m_customData ?? new Dictionary<string, string>();
			epicLootInspection.Available = true;
			try
			{
				if (AssemblyPresent)
				{
					if (dictionary.Count > 256 || dictionary.Any((KeyValuePair<string, string> x) => x.Key == null || x.Key.Length > 256 || (x.Value?.Length ?? 0) > 65536) || dictionary.Sum((KeyValuePair<string, string> x) => (long)x.Key.Length + (long)(x.Value?.Length ?? 0)) > 262144)
					{
						throw new InvalidOperationException("Metadata inspection bounds exceeded.");
					}
					Type api = Ready();
					ItemData val = Detached(item);
					epicLootInspection.Unidentified = Query<bool>(api, "IsUnidentified", val);
					epicLootInspection.Magic = epicLootInspection.Unidentified || Query<bool>(api, "IsMagicItem", val);
					bool flag = Query<bool>(api, "IsRunestone", val);
					bool flag2 = Query<bool>(api, "IsShardStone", val);
					epicLootInspection.Special = epicLootInspection.Magic || flag || flag2 || Query<bool>(api, "IsMagicCraftingMaterial", val) || Query<bool>(api, "IsEpicLootItem", val);
					if (epicLootInspection.Special)
					{
						object[] array = new object[2] { val, -1 };
						bool flag3 = (bool)Required(api, "TryGetRarity", typeof(bool), typeof(ItemData), typeof(int).MakeByRefType()).Invoke(null, array);
						int num = Scalar<int>(api, "GetRarityCount");
						epicLootInspection.Rarity = (flag3 ? ((int)array[1]) : (-1));
						if (num < 1 || num > 100 || (flag3 && (epicLootInspection.Rarity < 0 || epicLootInspection.Rarity >= num)))
						{
							throw new InvalidOperationException("Unsupported Epic Loot rarity bounds.");
						}
						string text = (flag3 ? Localize(RarityText(api, "GetRarityDisplayNameByIndex", epicLootInspection.Rarity)) : "Epic Loot");
						epicLootInspection.DisplaySuffix = " [" + (epicLootInspection.Unidentified ? "Unidentified" : (text + (flag ? " rune" : (flag2 ? " shard" : "")))) + "]";
						if (epicLootInspection.Unidentified)
						{
							epicLootInspection.Summary = "Unidentified magic item; effects are hidden.";
						}
						else if (epicLootInspection.Magic)
						{
							epicLootInspection.MagicJson = Query<string>(api, "GetMagicItemJson", val) ?? "";
							EpicLootMagicData val2 = EpicLootMetadata.ParseMagic(epicLootInspection.MagicJson);
							if (val2.IsUnidentified || !flag3 || val2.Rarity != epicLootInspection.Rarity)
							{
								throw new InvalidOperationException("Epic Loot identity metadata mismatch.");
							}
							epicLootInspection.Summary = EpicLootMetadata.DescribeMagic(val2);
						}
						else
						{
							epicLootInspection.Summary = "Epic Loot material: registered base or progression estimate.";
						}
						if (epicLootInspection.Magic && flag3 && Query<bool>(api, "CanBeMagicItem", val))
						{
							epicLootInspection.WagerRarity = epicLootInspection.Rarity;
						}
					}
				}
				if (!epicLootInspection.Special && (EpicLootMetadata.HasUnreviewedCustomData((IEnumerable<KeyValuePair<string, string>>)dictionary, SupportedApiPresent) || item.m_shared.m_name.StartsWith("$mod_epicloot", StringComparison.Ordinal)))
				{
					epicLootInspection.Special = true;
					epicLootInspection.DisplaySuffix = " [Custom item]";
					epicLootInspection.Reason = "Existing custom item uses its registered base or progression estimate; custom effects add no guessed value.";
					epicLootInspection.Summary = epicLootInspection.Reason;
				}
			}
			catch (Exception)
			{
				epicLootInspection.Special = true;
				epicLootInspection.WagerRarity = null;
				epicLootInspection.MagicJson = "";
				epicLootInspection.Reason = "Epic Loot details unavailable; using the item's base estimate without a magic bonus.";
				epicLootInspection.Summary = (epicLootInspection.Unidentified ? "Unidentified magic item; effects are hidden. Base estimate only." : epicLootInspection.Reason);
			}
			epicLootInspection.Fingerprint = EpicLootMetadata.Fingerprint(epicLootInspection.MagicJson, epicLootInspection.EnchantCostsJson, epicLootInspection.SacrificeProductsJson, (IEnumerable<KeyValuePair<string, string>>)(item.m_customData ?? new Dictionary<string, string>()));
			return epicLootInspection;
		}

		public static PriceResult Price(Economy economy, ItemData item)
		{
			int? wagerRarity;
			return Price(economy, item, out wagerRarity);
		}

		public static PriceResult PriceCanonicalReward(Economy economy, GameObject registered, int quality = 1)
		{
			ItemData val = (((Object)(object)registered == (Object)null) ? null : registered.GetComponent<ItemDrop>()?.m_itemData);
			if (val?.m_shared == null || (Object)(object)ObjectDB.instance == (Object)null || ObjectDB.instance.GetItemPrefab(GameAdapter.PrefabName(registered)) != registered)
			{
				return PriceResult.Unavailable("Missing or changed canonical reward definition.");
			}
			ItemData val2 = Detached(val);
			val2.m_dropPrefab = registered;
			val2.m_quality = quality;
			return Price(economy, val2);
		}

		public static PriceResult Price(Economy economy, ItemData item, out int? wagerRarity)
		{
			EpicLootInspection epicLootInspection = Inspect(item);
			wagerRarity = epicLootInspection.WagerRarity;
			if (!epicLootInspection.Available)
			{
				return PriceResult.Unavailable(epicLootInspection.Reason);
			}
			string text = GameAdapter.PrefabName(item);
			if (EpicSupplementValuation.IsFixedRelic(text))
			{
				wagerRarity = null;
			}
			GameObject val = ((wagerRarity.HasValue && (Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(text) : null);
			if ((Object)(object)val == (Object)null)
			{
				wagerRarity = null;
			}
			PriceResult val2 = (wagerRarity.HasValue ? PriceForRarity(economy, val, item.m_quality, wagerRarity) : economy.Price(text, item.m_quality));
			if (val2.Available && epicLootInspection.Special && !wagerRarity.HasValue)
			{
				return PriceResult.Priced(val2.UnitValue, "Existing custom/special item uses its base value; no effect bonus. " + val2.Reason);
			}
			return val2;
		}

		public static PriceResult PriceForRarity(Economy economy, GameObject registered, int quality, int? rarity)
		{
			ItemData val = (((Object)(object)registered == (Object)null) ? null : registered.GetComponent<ItemDrop>()?.m_itemData);
			if (val?.m_shared == null)
			{
				return PriceResult.Unavailable("Missing registered item definition.");
			}
			string text = GameAdapter.PrefabName(registered);
			PriceResult val2 = economy.Price(text, quality);
			if (!rarity.HasValue || !val2.Available || EpicSupplementValuation.IsFixedRelic(text))
			{
				return val2;
			}
			try
			{
				Type api = Ready();
				int num = Scalar<int>(api, "GetRarityCount");
				ItemData val3 = Detached(val);
				val3.m_quality = quality;
				val3.m_dropPrefab = registered;
				if (num != 6 || rarity.Value < 0 || rarity.Value >= num || !Query<bool>(api, "CanBeMagicItem", val3))
				{
					return PriceResult.Unavailable("Invalid rarity or an item that cannot be enchanted.");
				}
				IReadOnlyList<EpicLootCost> readOnlyList = EpicLootMetadata.ParseCosts(EnchantCosts(api, val3, rarity.Value));
				PriceResult val4 = EpicLootMetadata.EnchantPrice(economy, text, quality, readOnlyList);
				if (!val4.Available)
				{
					if (readOnlyList.Count != 0 && !readOnlyList.Any((EpicLootCost x) => !economy.BasePrice(x.Item, 1).Available))
					{
						return val4;
					}
					val4 = PriceResult.Priced(val2.UnitValue, "Base estimate only: " + val4.Reason);
				}
				return EpicGearValuation.Apply(val4, rarity.Value);
			}
			catch (Exception ex)
			{
				return PriceResult.Unavailable("Epic Loot enchant valuation unavailable: " + ex.GetBaseException().Message);
			}
		}

		public static bool CanBeWagered(ItemData item)
		{
			return item?.m_shared != null;
		}

		public static ItemData Detached(ItemData item)
		{
			//IL_0025: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0046: 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_006d: Expected O, but got Unknown
			if (item?.m_shared == null)
			{
				throw new ArgumentException("Missing item data.");
			}
			ItemData val = (ItemData)ShallowCopy.Invoke(item, null);
			val.m_shared = (SharedData)ShallowCopy.Invoke(item.m_shared, null);
			val.m_customData = new Dictionary<string, string>(item.m_customData ?? new Dictionary<string, string>(), StringComparer.Ordinal);
			val.m_equipped = false;
			return val;
		}

		public static bool HasPotentiallyOrdinaryMetadata(ItemData item)
		{
			if (item?.m_shared != null)
			{
				return !EpicLootMetadata.HasUnreviewedCustomData((IEnumerable<KeyValuePair<string, string>>)(item.m_customData ?? new Dictionary<string, string>()), true);
			}
			return false;
		}

		public static IReadOnlyList<EpicLootEnchantOption> GetEnchantOptions(ItemData item, Economy economy)
		{
			List<EpicLootEnchantOption> list = new List<EpicLootEnchantOption>();
			if (!AssemblyPresent || item?.m_shared == null)
			{
				return list;
			}
			try
			{
				Type api = Ready();
				item = Detached(item);
				if (!Query<bool>(api, "CanBeMagicItem", item) || Query<bool>(api, "IsUnidentified", item))
				{
					return list;
				}
				int num = Scalar<int>(api, "GetRarityCount");
				if (num < 1 || num > 100)
				{
					throw new InvalidOperationException("Unsupported rarity count.");
				}
				for (int i = 0; i < num; i++)
				{
					string text = EnchantCosts(api, item, i);
					IReadOnlyList<EpicLootCost> readOnlyList = EpicLootMetadata.ParseCosts(text);
					PriceResult val = EpicGearValuation.Apply(EpicLootMetadata.EnchantPrice(economy, GameAdapter.PrefabName(item), item.m_quality, readOnlyList), i);
					list.Add(new EpicLootEnchantOption
					{
						Rarity = i,
						Display = Localize(RarityText(api, "GetRarityDisplayNameByIndex", i)),
						Color = RarityText(api, "GetRarityColorByIndex", i),
						CostsJson = text,
						CostSummary = EpicLootMetadata.DescribeCosts(readOnlyList),
						BlockReason = val.Reason,
						Available = false
					});
				}
			}
			catch (Exception ex)
			{
				list.Clear();
				list.Add(new EpicLootEnchantOption
				{
					Rarity = -1,
					Display = "Epic Loot unavailable",
					BlockReason = ex.GetBaseException().Message
				});
			}
			return list;
		}
	}
	public sealed class FateForgeStation : MonoBehaviour, Hoverable, Interactable
	{
		public const float InteractionRange = 4f;

		public string GetHoverName()
		{
			return "Fate Forge";
		}

		public string GetHoverText()
		{
			if (!SessionGuard.Allows(out var reason))
			{
				return "Fate Forge\n" + reason;
			}
			if (Localization.instance == null)
			{
				return "Fate Forge\n[E] Open";
			}
			return Localization.instance.Localize("Fate Forge\n[<color=yellow><b>$KEY_Use</b></color>] Open");
		}

		public float GetHoverOffset()
		{
			return 0f;
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			if (hold || (Object)(object)user == (Object)null || (Object)(object)user != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			if (!SessionGuard.Allows(out var reason))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, reason, 0, (Sprite)null, false);
				return false;
			}
			if (!IsAccessible(Player.m_localPlayer))
			{
				return false;
			}
			return StationRegistration.Open(this);
		}

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

		public bool IsAccessible(Player player, float distance = 4f)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || !((Behaviour)this).isActiveAndEnabled || !((Component)this).gameObject.activeInHierarchy || float.IsNaN(distance) || float.IsInfinity(distance) || distance <= 0f)
			{
				return false;
			}
			ZNetView component = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			return Vector3.Distance(((Component)player).transform.position, ((Component)this).transform.position) <= Math.Min(distance, 6f);
		}

		public static FateForgeStation FindNearest(Player player, float distance = 4f)
		{
			//IL_0030: 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)
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			FateForgeStation result = null;
			float num = distance;
			FateForgeStation[] array = Object.FindObjectsByType<FateForgeStation>((FindObjectsSortMode)0);
			foreach (FateForgeStation fateForgeStation in array)
			{
				if (fateForgeStation.IsAccessible(player, distance))
				{
					float num2 = Vector3.Distance(((Component)player).transform.position, ((Component)fateForgeStation).transform.position);
					if (num2 <= num)
					{
						num = num2;
						result = fateForgeStation;
					}
				}
			}
			return result;
		}
	}
	internal sealed class ForgeAssets
	{
		public Texture2D Atlas { get; }

		public Texture2D Emblem { get; }

		public Sprite Icon { get; }

		public ForgeAssets()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_0100: 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)
			using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("FateForge.atlas.png"))
			{
				using MemoryStream memoryStream = new MemoryStream();
				if (stream == null)
				{
					throw new InvalidOperationException("Fate Forge texture atlas is missing.");
				}
				stream.CopyTo(memoryStream);
				Atlas = new Texture2D(2, 2, (TextureFormat)4, true)
				{
					name = "FateForge_OriginalAtlas",
					wrapMode = (TextureWrapMode)1
				};
				if (!ImageConversion.LoadImage(Atlas, memoryStream.ToArray(), false))
				{
					throw new InvalidDataException("Invalid Fate Forge texture atlas.");
				}
			}
			int num = ((Texture)Atlas).width / 2;
			int num2 = ((Texture)Atlas).height / 2;
			Emblem = new Texture2D(num, num2, (TextureFormat)4, true)
			{
				name = "FateForge_OriginalEmblem",
				wrapMode = (TextureWrapMode)1
			};
			Emblem.SetPixels(Atlas.GetPixels(num, 0, num, num2));
			Emblem.Apply(true, true);
			Icon = Sprite.Create(Emblem, new Rect(0f, 0f, (float)num, (float)num2), new Vector2(0.5f, 0.5f), 100f);
			((Object)Icon).name = "FateForge_HammerIcon";
			Object.DontDestroyOnLoad((Object)(object)Atlas);
			Object.DontDestroyOnLoad((Object)(object)Emblem);
			Object.DontDestroyOnLoad((Object)(object)Icon);
		}
	}
	internal sealed class Quote
	{
		public string Id = Guid.NewGuid().ToString("N");

		public ItemData Stake;

		public WagerSelection Wager;

		public Player Owner;

		public Inventory Inventory;

		public ZNet Network;

		public long WorldUid;

		public byte[] InventoryState;

		public string StakePrefab;

		public int StakeQuality;

		public int StakeQuantity;

		public int RewardQuality;

		public int RewardQuantity;

		public int? StakeRarity;

		public string RewardPrefab;

		public string RewardMetadataFingerprint;

		public decimal StakeUnitValue;

		public decimal RewardUnitValue;

		public decimal WagerValue;

		public decimal RewardValue;

		public decimal Probability;

		public float Created;

		public void RequireInventory(Inventory current)
		{
			if (Inventory == null || Inventory != current)
			{
				throw new InvalidOperationException("Player inventory changed. Review again.");
			}
		}

		public void RequireContext()
		{
			if (Owner != Player.m_localPlayer || Network != ZNet.instance || (Object)(object)Owner == (Object)null || (Object)(object)ZNet.instance == (Object)null || WorldUid != ZNet.instance.GetWorldUID())
			{
				throw new InvalidOperationException("Player or world changed. Review again.");
			}
			RequireInventory(((Humanoid)Owner).GetInventory());
			if (((Character)Owner).IsDead() || ((Character)Owner).IsTeleporting())
			{
				throw new InvalidOperationException("Character died or began teleporting. Inventory changes cannot continue or be refunded safely.");
			}
		}
	}
	[DataContract]
	internal sealed class AuditRecord
	{
		[DataMember]
		public string id;

		[DataMember]
		public string state;

		[DataMember]
		public string utc;

		[DataMember]
		public string stake;

		[DataMember]
		public string reward;

		[DataMember]
		public string probability;

		[DataMember]
		public string detail;

		[DataMember]
		public int stakeQuality;

		[DataMember]
		public int stakeQuantity;

		[DataMember]
		public int rewardQuality;

		[DataMember]
		public int rewardQuantity;

		public string Serialize()
		{
			using MemoryStream memoryStream = new MemoryStream();
			new DataContractJsonSerializer(typeof(AuditRecord)).WriteObject(memoryStream, this);
			return Encoding.UTF8.GetString(memoryStream.ToArray());
		}
	}
	internal sealed class GambleOutcome
	{
		public WheelRoll Roll;

		public string Message;
	}
	internal sealed class GambleSession
	{
		private readonly string _journal;

		private readonly TransactionCoordinator _transactions = new TransactionCoordinator((Func<double>)(() => Time.realtimeSinceStartup));

		private Quote _issued;

		public bool Quarantined => _transactions.Quarantined;

		public GambleSession(string journal)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			_journal = journal;
		}

		public void CancelQuote()
		{
			_issued = null;
		}

		internal void ValidateMultiplayer(Quote quote, Catalogue catalogue, Func<bool> accessible)
		{
			if (quote == null || _issued != quote)
			{
				throw new InvalidOperationException("The review was cancelled. Nothing was spent.");
			}
			quote.RequireContext();
			if (!accessible() || Time.realtimeSinceStartup - quote.Created > 30f)
			{
				throw new InvalidOperationException("Review expired or you left the station. Nothing was spent.");
			}
			Quote quote2 = CreateQuote(catalogue, quote.Stake, quote.StakeQuantity, quote.RewardPrefab, quote.RewardQuantity, quote.RewardQuality);
			if (quote2.StakePrefab != quote.StakePrefab || quote2.StakeQuality != quote.StakeQuality || quote2.StakeRarity != quote.StakeRarity || quote2.RewardMetadataFingerprint != quote.RewardMetadataFingerprint || quote2.StakeUnitValue != quote.StakeUnitValue || quote2.RewardUnitValue != quote.RewardUnitValue || quote2.WagerValue != quote.WagerValue || quote2.RewardValue != quote.RewardValue || quote2.Probability != quote.Probability || !quote2.InventoryState.SequenceEqual(quote.InventoryState))
			{
				throw new InvalidOperationException("Inventory or prices changed. Review again; nothing was spent.");
			}
			_issued = null;
		}

		public Quote Quote(Catalogue catalogue, ItemData stake, int stakeCount, string rewardPrefab, int rewardCount, int rewardQuality)
		{
			_issued = null;
			return _issued = CreateQuote(catalogue, stake, stakeCount, rewardPrefab, rewardCount, rewardQuality);
		}

		private Quote CreateQuote(Catalogue catalogue, ItemData stake, int stakeCount, string rewardPrefab, int rewardCount, int rewardQuality)
		{
			if (!SessionGuard.Allows(out var reason))
			{
				throw new InvalidOperationException(reason);
			}
			if (Quarantined)
			{
				throw new InvalidOperationException("Gambling is locked for this session.");
			}
			if (!GameAdapter.RuntimeStillCurrent(catalogue))
			{
				throw new InvalidOperationException("Loaded mods, registered items, or recipes changed. Reopen Fate Forge.");
			}
			Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
			if (stake == null || !inventory.GetAllItems().Contains(stake) || stake.m_equipped)
			{
				throw new InvalidOperationException("Select an unequipped item still in your inventory.");
			}
			WagerSelection wager = WagerSelection.Create(inventory, stake, stakeCount);
			if (!catalogue.Items.TryGetValue(rewardPrefab ?? "", out var value))
			{
				throw new InvalidOperationException("Select a valid reward.");
			}
			if (!GameAdapter.IsLiveItem(catalogue, value))
			{
				throw new InvalidOperationException("The reward is no longer present in the loaded game. Reopen Fate Forge.");
			}
			if (rewardQuality < 1 || rewardQuality > value.MaxQuality || rewardCount < 1 || rewardCount > value.MaxStack)
			{
				throw new InvalidOperationException("Invalid reward quantity/quality. This prototype awards at most one inventory stack.");
			}
			string text = GameAdapter.PrefabName(stake);
			if (!catalogue.Items.TryGetValue(text, out var value2) || !GameAdapter.IsLiveItem(catalogue, value2))
			{
				throw new InvalidOperationException("The offering is no longer registered in the loaded game. Reopen Fate Forge.");
			}
			int? wagerRarity;
			PriceResult val = EpicLootBridge.Price(catalogue.Economy, stake, out wagerRarity);
			PriceResult val2 = EpicLootBridge.PriceCanonicalReward(catalogue.Economy, value.Object, rewardQuality);
			string text2 = RewardMetadataIdentity.Capture(value.Drop.m_itemData);
			EpicLootInspection epicLootInspection = EpicLootBridge.Inspect(value.Drop.m_itemData);
			if (!epicLootInspection.Available)
			{
				throw new InvalidOperationException("Reward unavailable: " + epicLootInspection.Reason);
			}
			RewardMetadataIdentity.RequireCurrent(value.Drop.m_itemData, text2);
			ItemData val3 = EpicLootBridge.Detached(value.Drop.m_itemData);
			StackLimits.PrepareReward(val3, value.Drop.m_itemData);
			RewardMetadataIdentity.RequireCurrent(val3, text2);
			val3.m_dropPrefab = value.Object;
			val3.m_quality = rewardQuality;
			val3.m_stack = rewardCount;
			val3.m_equipped = false;
			val3.m_durability = val3.GetMaxDurability();
			new RewardSafety(inventory, val3);
			if (!val.Available)
			{
				throw new InvalidOperationException("Wager is unpriced: " + val.Reason);
			}
			if (!val2.Available)
			{
				throw new InvalidOperationException("Reward is unpriced: " + val2.Reason);
			}
			decimal num = Odds.Total(val.UnitValue, stakeCount);
			decimal num2 = Odds.Total(val2.UnitValue, rewardCount);
			decimal num3 = Odds.Probability(num, num2);
			if (Odds.WinningDrawCount(num3) == 0L)
			{
				throw new InvalidOperationException("This wager is below the supported probability resolution. Increase it.");
			}
			return new Quote
			{
				Owner = Player.m_localPlayer,
				Inventory = inventory,
				Network = ZNet.instance,
				WorldUid = ZNet.instance.GetWorldUID(),
				InventoryState = InventorySnapshot.Serialize(inventory),
				Stake = stake,
				Wager = wager,
				StakePrefab = text,
				StakeQuality = stake.m_quality,
				StakeQuantity = stakeCount,
				StakeRarity = wagerRarity,
				RewardPrefab = rewardPrefab,
				RewardQuantity = rewardCount,
				RewardMetadataFingerprint = text2,
				RewardQuality = rewardQuality,
				StakeUnitValue = val.UnitValue,
				RewardUnitValue = val2.UnitValue,
				WagerValue = num,
				RewardValue = num2,
				Probability = num3,
				Created = Time.realtimeSinceStartup
			};
		}

		public GambleOutcome Execute(Catalogue catalogue, Quote quote, Func<bool> stationStillAccessible)
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZNet.IsOpenServer() || ZNet.instance.GetPeers().Count != 0)
			{
				throw new InvalidOperationException("Multiplayer gambling requires a built Fate Forge.");
			}
			if (quote == null || _issued != quote)
			{
				throw new InvalidOperationException("Review a current wager first.");
			}
			_issued = null;
			InventorySnapshot backup = null;
			Inventory inventory = null;
			RewardSafety deliverySafety = null;
			WheelRoll roll = null;
			try
			{
				TransactionResult val = _transactions.Execute(quote.Id, (double)quote.Created, (Func<bool>)delegate
				{
					quote.RequireContext();
					if (!stationStillAccessible())
					{
						throw new InvalidOperationException("You left the crafting station or closed the panel.");
					}
					Quote quote2 = CreateQuote(catalogue, quote.Stake, quote.StakeQuantity, quote.RewardPrefab, quote.RewardQuantity, quote.RewardQuality);
					quote.RequireContext();
					quote.RequireInventory(quote2.Inventory);
					if (quote2.StakePrefab != quote.StakePrefab || quote2.StakeQuality != quote.StakeQuality || quote2.StakeRarity != quote.StakeRarity || quote2.RewardMetadataFingerprint != quote.RewardMetadataFingerprint || quote2.WagerValue != quote.WagerValue || quote2.RewardValue != quote.RewardValue || quote2.Probability != quote.Probability || !quote2.InventoryState.SequenceEqual(quote.InventoryState))
					{
						throw new InvalidOperationException("Inventory, items, or prices changed. Review again.");
					}
					inventory = quote.Inventory;
					return true;
				}, (Func<object>)(() => backup = new InventorySnapshot(inventory, quote.Owner)), (Action)delegate
				{
					Append(quote, "prepared", "Local synchronous test; not crash-recoverable.");
				}, (Func<bool>)delegate
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Expected O, but got Unknown
					roll = new WheelRoll(quote.Probability, Odds.Draw());
					return roll.Won;
				}, (Action)delegate
				{
					quote.RequireContext();
					quote.Wager.Consume(inventory, quote.RequireContext);
					quote.RequireContext();
					backup.VerifyConsumed(quote.Wager);
				}, (Action)delegate
				{
					quote.RequireContext();
					CatalogueEntry catalogueEntry = catalogue.Items[quote.RewardPrefab];
					if (!GameAdapter.RuntimeStillCurrent(catalogue) || !GameAdapter.IsLiveItem(catalogue, catalogueEntry))
					{
						throw new InvalidOperationException("The loaded reward prefab changed during delivery.");
					}
					RewardMetadataIdentity.RequireCurrent(catalogueEntry.Drop.m_itemData, quote.RewardMetadataFingerprint);
					ItemData val2 = EpicLootBridge.Detached(catalogueEntry.Drop.m_itemData);
					StackLimits.PrepareReward(val2, catalogueEntry.Drop.m_itemData);
					RewardMetadataIdentity.RequireCurrent(val2, quote.RewardMetadataFingerprint);
					val2.m_dropPrefab = catalogueEntry.Object;
					val2.m_quality = quote.RewardQuality;
					val2.m_stack = quote.RewardQuantity;
					val2.m_equipped = false;
					val2.m_durability = val2.GetMaxDurability();
					RewardMetadataIdentity.RequireCurrent(val2, quote.RewardMetadataFingerprint);
					deliverySafety = new RewardSafety(inventory, val2);
					if (!deliverySafety.Deliver(quote.RequireContext))
					{
						throw new InvalidOperationException("The reward could not be added in full.");
					}
					quote.RequireContext();
				}, (Action<bool>)delegate(bool won)
				{
					quote.RequireContext();
					backup.VerifyResult(quote.Wager, quote.RewardPrefab, quote.RewardQuality, quote.RewardQuantity, won);
					if (won)
					{
						deliverySafety.VerifyDelivered();
					}
				}, (Action<object>)delegate(object state)
				{
					quote.RequireContext();
					((InventorySnapshot)state).Restore();
					quote.RequireContext();
				}, (Action<bool>)delegate(bool won)
				{
					Append(quote, won ? "won" : "lost", "Exact inventory mutation verified; normal game saving still applies.");
				});
				string text = ((val.JournalWarning == "") ? "" : (" Result committed; journal failed: " + val.JournalWarning));
				return new GambleOutcome
				{
					Roll = roll,
					Message = (val.Won ? "WIN: exact reward received. Your wager was consumed." : "LOSS: your wager was consumed; no reward.") + text
				};
			}
			catch (Exception ex)
			{
				try
				{
					Append(quote, Quarantined ? "quarantined" : "aborted", ex.Message);
				}
				catch
				{
				}
				throw;
			}
		}

		private void Append(Quote quote, string state, string detail)
		{
			Directory.CreateDirectory(Path.GetDirectoryName(_journal));
			AuditRecord auditRecord = new AuditRecord
			{
				id = quote.Id,
				state = state,
				utc = DateTime.UtcNow.ToString("O"),
				stake = quote.StakePrefab,
				stakeQuality = quote.StakeQuality,
				stakeQuantity = quote.StakeQuantity,
				reward = quote.RewardPrefab,
				rewardQuality = quote.RewardQuality,
				rewardQuantity = quote.RewardQuantity,
				probability = quote.Probability.ToString(CultureInfo.InvariantCulture),
				detail = detail
			};
			File.AppendAllText(_journal, auditRecord.Serialize() + Environment.NewLine);
		}
	}
	internal sealed class GambleWheel : IDisposable
	{
		private const int TextureSize = 512;

		private const int NeedleTextureSize = 64;

		private const float MarkerOrbit = 0.414f;

		private const float MarkerSize = 0.18f;

		private static readonly Color WinColor = new Color(0.2f, 0.73f, 0.4f, 1f);

		private static readonly Color LossColor = new Color(0.6f, 0.18f, 0.13f, 1f);

		private static readonly Color GoldColor = new Color(0.85f, 0.69f, 0.38f, 1f);

		private Texture2D _ring;

		private Texture2D _needle;

		private GUIStyle _percentStyle;

		private GUIStyle _smallStyle;

		private GUIStyle _outcomeStyle;

		private decimal _textureProbability = -1m;

		private decimal _needleTurn = -1m;

		private readonly Color32[] _needlePixels = (Color32[])(object)new Color32[4096];

		private double _started;

		private bool _disposed;

		private Texture2D _faceTexture;

		public WheelRoll Result { get; private set; }

		public bool HasResult => Result != null;

		public bool IsSpinning
		{
			get
			{
				if (HasResult)
				{
					return !WheelPresentation.Finished(Elapsed);
				}
				return false;
			}
		}

		public Texture2D FaceTexture
		{
			get
			{
				return _faceTexture;
			}
			set
			{
				if ((Object)(object)_faceTexture != (Object)(object)value)
				{
					_faceTexture = value;
					_textureProbability = -1m;
				}
			}
		}

		private double Elapsed => Math.Max(0.0, Time.realtimeSinceStartupAsDouble - _started);

		public void Start(WheelRoll committedRoll)
		{
			Start(committedRoll, Time.realtimeSinceStartupAsDouble);
		}

		public void Start(WheelRoll committedRoll, double startedAt)
		{
			if (_disposed)
			{
				throw new ObjectDisposedException("GambleWheel");
			}
			if (double.IsNaN(startedAt) || double.IsInfinity(startedAt) || startedAt < 0.0)
			{
				throw new ArgumentOutOfRangeException("startedAt");
			}
			Result = committedRoll ?? throw new ArgumentNullException("committedRoll");
			_started = startedAt;
		}

		public void Clear()
		{
			Result = null;
		}

		public void Draw(Rect bounds, decimal rawPreviewProbability)
		{
			//IL_03f1: 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_009f: 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_00a6: 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_00be: 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_00e8: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_01e5: 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_01fd: 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_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed || ((Rect)(ref bounds)).width < 40f || ((Rect)(ref bounds)).height < 70f)
			{
				return;
			}
			decimal num = (HasResult ? Result.EffectiveProbability : Odds.EffectiveProbability(rawPreviewProbability));
			EnsureResources(num);
			EnsureStyles();
			float num2 = Math.Min(((Rect)(ref bounds)).width, ((Rect)(ref bounds)).height - 76f);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref bounds)).x + (((Rect)(ref bounds)).width - num2) / 2f, ((Rect)(ref bounds)).y, num2, num2);
			Vector2 center = ((Rect)(ref val)).center;
			bool isSpinning = IsSpinning;
			Color color = GUI.color;
			try
			{
				GUI.color = Color.white;
				if ((Object)(object)FaceTexture != (Object)null)
				{
					GUI.DrawTexture(new Rect(center.x - num2 * 0.34f, center.y - num2 * 0.34f, num2 * 0.68f, num2 * 0.68f), (Texture)(object)FaceTexture, (ScaleMode)2, true);
				}
				GUI.DrawTexture(val, (Texture)(object)_ring, (ScaleMode)2, true);
				decimal turns = (HasResult ? WheelPresentation.RotationTurns(Result, Elapsed) : 0m);
				EnsureNeedle(turns);
				GUI.DrawTexture(MarkerRect(val, turns), (Texture)(object)_needle, (ScaleMode)0, true);
				_percentStyle.fontSize = Math.Max(16, (int)(num2 * 0.112f));
				_percentStyle.normal.textColor = GoldColor;
				GUI.Label(new Rect(center.x - num2 * 0.33f, center.y - num2 * 0.17f, num2 * 0.66f, num2 * 0.25f), new GUIContent(CompactPercent(num), "Win chance: " + CompactPercent(num)), _percentStyle);
				_smallStyle.normal.textColor = new Color(0.83f, 0.81f, 0.72f);
				GUI.Label(new Rect(center.x - num2 * 0.3f, center.y + num2 * 0.028f, num2 * 0.6f, 21f), "WIN CHANCE", _smallStyle);
				_outcomeStyle.normal.textColor = (Color)((!HasResult || isSpinning) ? GoldColor : (Result.Won ? WinColor : new Color(0.96f, 0.46f, 0.32f)));
				string text = ((!HasResult) ? "THE FATES AWAIT" : (isSpinning ? "THE FATES TURN..." : (Result.Won ? "WIN" : "LOSS - WAGER SPENT")));
				GUI.Label(new Rect(((Rect)(ref bounds)).x, ((Rect)(ref val)).yMax + 1f, ((Rect)(ref bounds)).width, 23f), text, _outcomeStyle);
				_smallStyle.normal.textColor = new Color(0.79f, 0.76f, 0.66f);
				GUI.Label(new Rect(((Rect)(ref bounds)).x, ((Rect)(ref val)).yMax + 26f, ((Rect)(ref bounds)).width, 20f), "GREEN: WIN   /   RED: LOSS", _smallStyle);
				string text2 = ((HasResult && !isSpinning && WheelPresentation.NeedsPixelPrecisionNote(Result, (double)num2 * 0.43)) ? "Arc/boundary below pixel size. Exact result above." : (HasResult ? "Wager settled. Closing cannot change the result." : ((num == 0m) ? "Review a valid wager to see its chance." : (((double)num * (Math.PI * 2.0 * (double)num2 * 0.43) < 1.0) ? "The winning area is too small to see." : "Green area follows your exact chance."))));
				GUI.Label(new Rect(((Rect)(ref bounds)).x, ((Rect)(ref val)).yMax + 47f, ((Rect)(ref bounds)).width, 29f), text2, _smallStyle);
			}
			finally
			{
				GUI.color = color;
			}
		}

		internal static string CompactPercent(decimal probability)
		{
			if (probability < 0m || probability > 0.95m)
			{
				throw new ArgumentOutOfRangeException("probability");
			}
			decimal num = probability * 100m;
			string text = ((num >= 0.01m) ? "0.##" : ((num >= 0.000001m || num == 0m) ? "0.######" : "0.###E+0"));
			return num.ToString(text, CultureInfo.InvariantCulture) + "%";
		}

		internal static Rect MarkerRect(Rect ring, decimal turns)
		{
			//IL_00c2: 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_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)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: 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)
			if (turns < 0m || !Finite(((Rect)(ref ring)).x) || !Finite(((Rect)(ref ring)).y) || !Finite(((Rect)(ref ring)).width) || !Finite(((Rect)(ref ring)).height) || ((Rect)(ref ring)).width <= 0f || ((Rect)(ref ring)).height <= 0f || Math.Abs(((Rect)(ref ring)).width - ((Rect)(ref ring)).height) > 0.001f)
			{
				throw new ArgumentOutOfRangeException("ring", "Marker geometry requires a finite square ring and nonnegative phase.");
			}
			double num = (double)(turns % 1m) * Math.PI * 2.0;
			float num2 = ((Rect)(ref ring)).width * 0.18f;
			Vector2 val = ((Rect)(ref ring)).center + new Vector2((float)Math.Sin(num), 0f - (float)Math.Cos(num)) * (((Rect)(ref ring)).width * 0.414f);
			return new Rect(val.x - num2 / 2f, val.y - num2 / 2f, num2, num2);
		}

		internal static Vector2[] MarkerVertices(decimal turns)
		{
			//IL_005e: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00a0: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if (turns < 0m)
			{
				throw new ArgumentOutOfRangeException("turns");
			}
			double num = (double)(turns % 1m) * Math.PI * 2.0;
			float num2 = (float)Math.Cos(num);
			float num3 = (float)Math.Sin(num);
			Vector2[] array = (Vector2[])(object)new Vector2[7]
			{
				new Vector2(0f, 0.06f),
				new Vector2(-0.042f, -0.02f),
				new Vector2(-0.014f, -0.02f),
				new Vector2(-0.014f, -0.077f),
				new Vector2(0.014f, -0.077f),
				new Vector2(0.014f, -0.02f),
				new Vector2(0.042f, -0.02f)
			};
			for (int i = 0; i < array.Length; i++)
			{
				Vector2 val = array[i];
				array[i] = new Vector2(0.5f + (val.x * num2 - val.y * num3) / 0.18f, 0.5f + (val.x * num3 + val.y * num2) / 0.18f);
			}
			return array;
		}

		private static bool Finite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private void EnsureStyles()
		{
			//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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			if (_percentStyle == null)
			{
				_percentStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					fontStyle = (FontStyle)1
				};
				_smallStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					fontSize = 11,
					wordWrap = true
				};
				_outcomeStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					fontSize = 14,
					fontStyle = (FontStyle)1
				};
			}
		}

		private void EnsureResources(decimal probability)
		{
			//IL_001b: 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_002b: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_00f0: 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_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: 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_022c: 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_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_ring == (Object)null)
			{
				_ring = new Texture2D(512, 512, (TextureFormat)4, false)
				{
					name = "FateForge_ChanceRing",
					hideFlags = (HideFlags)61,
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
			}
			if (_textureProbability == probability)
			{
				return;
			}
			Color32[] array = (Color32[])(object)new Color32[262144];
			for (int i = 0; i < 512; i++)
			{
				for (int j = 0; j < 512; j++)
				{
					double num = ((double)j + 0.5 - 256.0) / 256.0;
					double num2 = ((double)i + 0.5 - 256.0) / 256.0;
					double num3 = Math.Sqrt(num * num + num2 * num2);
					double num4 = Math.Atan2(num, num2) / (Math.PI * 2.0);
					if (num4 < 0.0)
					{
						num4 += 1.0;
					}
					Color val = Color.clear;
					if (num3 < 0.974)
					{
						float num5 = (float)(0.026 * Math.Sin(num * 94.0 + Math.Sin(num2 * 31.0) * 3.0) + 0.018 * Math.Sin(num2 * 180.0));
						((Color)(ref val))..ctor(0.15f + num5, 0.109f + num5 * 0.7f, 0.067f + num5 * 0.4f, 0.98f);
						if (num3 < 0.64)
						{
							((Color)(ref val))..ctor(0.041f, 0.052f, 0.046f, ((Object)(object)FaceTexture != (Object)null) ? 0.81f : 0.98f);
						}
						else if (num3 > 0.7 && num3 < 0.925)
						{
							double num6 = 1.0 / (512.0 * num3 * 2.0 * Math.PI);
							float num7 = (float)WheelPresentation.GreenCoverage(probability, num4, num6);
							val = Color.Lerp(LossColor, WinColor, num7);
							float num8 = (float)(0.78 + 0.22 * Math.Sin((num3 - 0.7) / 0.225 * Math.PI));
							val *= num8;
							val.a = 1f;
						}
						else if ((num3 > 0.654 && num3 < 0.68) || num3 > 0.94)
						{
							val = GoldColor * (float)(0.67 + 0.2 * Math.Cos(num4 * Math.PI * 32.0));
						}
						if (num3 > 0.935 && Math.Abs(num4 * 32.0 - Math.Round(num4 * 32.0)) < 0.06)
						{
							((Color)(ref val))..ctor(0.12f, 0.095f, 0.05f, 1f);
						}
						val.a *= (float)Math.Min(1.0, (0.974 - num3) * 512.0 / 2.0);
					}
					array[i * 512 + j] = Color32.op_Implicit(val);
				}
			}
			_ring.SetPixels32(array);
			_ring.Apply(false, false);
			_textureProbability = probability;
		}

		private void EnsureNeedle(decimal turns)
		{
			//IL_0021: 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_0031: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_00c0: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_00e1: 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_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: 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_0179: 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_0182: 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_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: 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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: 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)
			decimal num = turns % 1m;
			if ((Object)(object)_needle == (Object)null)
			{
				_needle = new Texture2D(64, 64, (TextureFormat)4, false)
				{
					name = "FateForge_RuneNeedle",
					hideFlags = (HideFlags)61,
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
				_needleTurn = -1m;
			}
			if (_needleTurn == num)
			{
				return;
			}
			Vector2[] array = MarkerVertices(num);
			Vector2 val = default(Vector2);
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					((Vector2)(ref val))..ctor(((float)j + 0.5f) / 64f, 1f - ((float)i + 0.5f) / 64f);
					bool flag = false;
					float num2 = float.MaxValue;
					int num3 = 0;
					int num4 = array.Length - 1;
					while (num3 < array.Length)
					{
						Vector2 val2 = array[num4];
						Vector2 val3 = array[num3];
						if (val2.y > val.y != val3.y > val.y && val.x < (val3.x - val2.x) * (val.y - val2.y) / (val3.y - val2.y) + val2.x)
						{
							flag = !flag;
						}
						Vector2 val4 = val3 - val2;
						float num5 = Math.Max(0f, Math.Min(1f, Vector2.Dot(val - val2, val4) / ((Vector2)(ref val4)).sqrMagnitude));
						float val5 = num2;
						Vector2 val6 = val - (val2 + val4 * num5);
						num2 = Math.Min(val5, ((Vector2)(ref val6)).sqrMagnitude);
						num4 = num3++;
					}
					_needlePixels[i * 64 + j] = Color32.op_Implicit((Color)((!flag) ? Color.clear : ((num2 < 0.00065f) ? new Color(0.2f, 0.12f, 0.04f, 1f) : new Color(1f, 0.88f, 0.57f, 1f))));
				}
			}
			_needle.SetPixels32(_needlePixels);
			_needle.Apply(false, false);
			_needleTurn = num;
		}

		public void Dispose()
		{
			if ((Object)(object)_ring != (Object)null)
			{
				Object.Destroy((Object)(object)_ring);
			}
			if ((Object)(object)_needle != (Object)null)
			{
				Object.Destroy((Object)(object)_needle);
			}
			_ring = null;
			_needle = null;
			Result = null;
			_disposed = true;
		}
	}
	[Serializable]
	public sealed class AnchorFile
	{
		public int schema;

		public string profile;

		public AnchorRow[] anchors;
	}
	[Serializable]
	public sealed class AnchorRow
	{
		public string prefab;

		public string value;

		public bool enabled;

		public string note;
	}
	public sealed class CatalogueEntry
	{
		public string Prefab;

		public string Display;

		public GameObject Object;

		public ItemDrop Drop;

		public int MaxQuality;

		public int MaxStack;

		public bool ShowInBrowser;

		public bool IsInventoryItem;
	}
	public sealed class Catalogue
	{
		public Economy Economy;

		public ObjectDB Database;

		public GameObject[] RuntimeObjects;

		public string PluginSignature;

		public string StackConfigurationSignature;

		public string ProcessorSignature;

		public RuntimeRecipeSnapshot RecipeSnapshot;

		public NativeOriginSnapshot SourceSnapshot;

		public IReadOnlyDictionary<string, BiomeAdjustment> RouteBiomes;

		public RuntimeEpicLootValuationSnapshot EpicMaterialSnapshot;

		public bool EpicApiInstalled;

		public Dictionary<string, CatalogueEntry> Items;

		public List<string> Warnings = new List<string>();
	}
	internal static class GameFields
	{
		private const BindingFlags Flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static FieldInfo Field(Type type, string name)
		{
			while (type != null)
			{
				FieldInfo field = type.GetField(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return field;
				}
				type = type.BaseType;
			}
			return null;
		}

		public static T Required<T>(object instance, string name)
		{
			FieldInfo fieldInfo = Field(instance.GetType(), name);
			if (fieldInfo == null)
			{
				throw new MissingFieldException(instance.GetType().FullName, name);
			}
			return (T)fieldInfo.GetValue(instance);
		}

		public static bool OptionalBool(object instance, string name)
		{
			object obj = Field(instance.GetType(), name)?.GetValue(instance);
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		public static object InvokeZero(object instance, string name)
		{
			MethodInfo? method = instance.GetType().GetMethod(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (method == null)
			{
				throw new MissingMethodException(instance.GetType().FullName, name);
			}
			return method.Invoke(method.IsStatic ? null : instance, null);
		}
	}
	internal static class SessionGuard
	{
		public static bool Allows(out string reason)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			reason = "Enter a world with a living player to use Fate Forge.";
			if ((Object)(object)ZNet.instance == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			try
			{
				ZNet instance = ZNet.instance;
				if ((bool)GameFields.InvokeZero(instance, "IsDedicated"))
				{
					return false;
				}
				if (!instance.IsServer() && (int)ZNet.GetConnectionStatus() != 2)
				{
					return false;
				}
				if (((Character)Player.m_localPlayer).IsDead())
				{
					reason = "Cannot gamble while dead.";
					return false;
				}
				if (((Character)Player.m_localPlayer).IsTeleporting())
				{
					reason = "Wait until teleporting finishes before gambling.";
					return false;
				}
				reason = "";
				return true;
			}
			catch (Exception ex)
			{
				reason = "Session API needs verification; gambling blocked: " + ex.GetBaseException().Message;
				return false;
			}
		}
	}
	internal static class GameAdapter
	{
		private static readonly KeyValuePair<string, string>[] ReviewedProcessorOutputs = new KeyValuePair<string, string>[15]
		{
			new KeyValuePair<string, string>("charcoal_kiln", "Coal"),
			new KeyValuePair<string, string>("smelter", "Copper"),
			new KeyValuePair<string, string>("smelter", "Tin"),
			new KeyValuePair<string, string>("smelter", "Iron"),
			new KeyValuePair<string, string>("smelter", "Silver"),
			new KeyValuePair<string, string>("smelter", "Bronze"),
			new KeyValuePair<string, string>("blastfurnace", "BlackMetal"),
			new KeyValuePair<string, string>("blastfurnace", "FlametalNew"),
			new KeyValuePair<string, string>("blastfurnace", "Gold"),
			new KeyValuePair<string, string>("eitrrefinery", "Eitr"),
			new KeyValuePair<string, string>("piece_spinningwheel", "LinenThread"),
			new KeyValuePair<string, string>("windmill", "BarleyFlour"),
			new KeyValuePair<string, string>("windmill", "Oat"),
			new KeyValuePair<string, string>("windmill", "OatFlour"),
			new KeyValuePair<string, string>("piece_FrostKiln", "FrozenFuel")
		};

		public static string PrefabName(GameObject obj)
		{
			if (!((Object)(object)obj == (Object)null))
			{
				return ((Object)obj).name.Replace("(Clone)", "").Trim();
			}
			return "";
		}

		public static string PrefabName(ItemData item)
		{
			if (item != null)
			{
				return PrefabName(item.m_dropPrefab);
			}
			return "";
		}

		public static string Name(ItemData item)
		{
			if (Localization.instance != null)
			{
				return Localization.instance.Localize(item.m_shared.m_name);
			}
			return item.m_shared.m_name;
		}

		public static string CatalogueName(ItemData item)
		{
			return CataloguePolicy.DisplayName(PrefabName(item), Name(item));
		}

		public static Catalogue Build(string configPath)
		{
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Expected O, but got Unknown
			//IL_0599: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Expected O, but got Unknown
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Expected O, but got Unknown
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				throw new InvalidOperationException("The world item database is not ready.");
			}
			EpicLootBridge.EnsureCompatibleIfPresent();
			EconomyConfiguration val = EconomyConfiguration.Parse(File.ReadAllText(configPath));
			IReadOnlyDictionary<string, decimal> anchors = val.ActiveAnchors;
			IReadOnlyList<string> unreviewedEnabled = val.UnreviewedEnabled;
			Catalogue catalogue = new Catalogue
			{
				Database = ObjectDB.instance,
				EpicApiInstalled = EpicLootBridge.IsInstalled,
				RuntimeObjects = GameFields.Required<List<GameObject>>(ObjectDB.instance, "m_items").ToArray(),
				PluginSignature = InstalledModCatalogue.CurrentPluginSignature(),
				StackConfigurationSignature = StackLimits.ConfigurationSignature,
				Items = new Dictionary<string, CatalogueEntry>(StringComparer.Ordinal)
			};
			Dictionary<string, string> blocks = new Dictionary<string, string>(StringComparer.Ordinal);
			if (val.LegacyDefaultsSupplemented)
			{
				catalogue.Warnings.Add("Pristine older default uses the current progression profile and biome adjustments; Wood remains 0.3. Your configuration file is unchanged.");
			}
			foreach (string item in unreviewedEnabled)
			{
				catalogue.Warnings.Add("Ignored draft anchor; using live acquisition costs or difficulty estimate: " + item);
			}
			foreach (GameObject item2 in GameFields.Required<List<GameObject>>(ObjectDB.instance, "m_items"))
			{
				if ((Object)(object)item2 == (Object)null)
				{
					continue;
				}
				ItemDrop component = item2.GetComponent<ItemDrop>();
				if ((Object)(object)component == (Object)null || component.m_itemData == null || component.m_itemData.m_shared == null)
				{
					continue;
				}
				SharedData shared = component.m_itemData.m_shared;
				string text = PrefabName(item2);
				if (!string.IsNullOrWhiteSpace(text))
				{
					if (catalogue.Items.ContainsKey(text))
					{
						throw new InvalidDataException("Duplicate runtime prefab: " + text);
					}
					bool flag = shared.m_maxQuality >= 1 && shared.m_maxQuality <= 100 && shared.m_maxStackSize >= 1 && !string.IsNullOrWhiteSpace(shared.m_name) && ((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString() != "None" && ((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString() != "Customization";
					if (!flag)
					{
						blocks[text] = "Not a supported obtainable inventory item.";
					}
					string text2 = (string.IsNullOrWhiteSpace(shared.m_name) ? text : CataloguePolicy.DisplayName(text, Name(component.m_itemData)));
					catalogue.Items.Add(text, new CatalogueEntry
					{
						Prefab = text,
						Display = (string.IsNullOrWhiteSpace(text2) ? text : text2),
						Object = item2,
						Drop = component,
						MaxQuality = Math.Max(1, Math.Min(100, shared.m_maxQuality)),
						MaxStack = (flag ? StackLimits.ForTemplate(component.m_itemData) : Math.Max(1, shared.m_maxStackSize)),
						IsInventoryItem = flag,
						ShowInBrowser = (flag && !CataloguePolicy.IsExcluded(text) && shared.m_icons != null && shared.m_icons.Any((Sprite icon) => (Object)(object)icon != (Object)null))
					});
				}
			}
			foreach (string key2 in anchors.Keys)
			{
				if (!catalogue.Items.ContainsKey(key2))
				{
					catalogue.Warnings.Add("Enabled anchor not present in this installation: " + key2);
				}
			}
			List<Recipe> list = GameFields.Required<List<Recipe>>(ObjectDB.instance, "m_recipes");
			catalogue.RecipeSnapshot = new RuntimeRecipeSnapshot(list);
			Dictionary<string, List<CraftRoute>> routes = new Dictionary<string, List<CraftRoute>>(StringComparer.Ordinal);
			foreach (Recipe item3 in list)
			{
				if ((Object)(object)item3 == (Object)null || !GameFields.Required<bool>(item3, "m_enabled"))
				{
					continue;
				}
				ItemDrop val2 = GameFields.Required<ItemDrop>(item3, "m_item");
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				string key = PrefabName(((Component)val2).gameObject);
				if (!catalogue.Items.TryGetValue(key, out var value))
				{
					continue;
				}
				if (value.IsInventoryItem)
				{
					value.ShowInBrowser = !CataloguePolicy.IsExcluded(value.Prefab);
				}
				if (!routes.TryGetValue(key, out var value2))
				{
					value2 = (routes[key] = new List<CraftRoute>());
				}
				try
				{
					ValidateRecipeIdentities(catalogue, item3);
					int num = GameFields.Required<int>(item3, "m_amount");
					string text3 = null;
					if (GameFields.Required<bool>(item3, "m_noCraftOnlyUpgrade"))
					{
						text3 = "Upgrade-only recipe needs an audited base acquisition route.";
					}
					if (GameFields.Required<bool>(item3, "m_requireOnlyOneIngredient"))
					{
						text3 = "Alternative-ingredient recipe needs a dedicated adapter.";
					}
					if (text3 == null)
					{
						num = OrdinaryOutputCount(item3);
					}
					Requirement[] array = GameFields.Required<Requirement[]>(item3, "m_resources");
					List<IReadOnlyList<Material>> list3 = new List<IReadOnlyList<Material>>();
					for (int num2 = 1; num2 <= value.MaxQuality; num2++)
					{
						ValidateOrdinaryCraftingStation(item3, num2);
						List<Material> list4 = new List<Material>();
						Requirement[] array2 = array;
						foreach (Requirement val3 in array2)
						{
							if (val3 == null)
							{
								continue;
							}
							int num4 = OrdinaryRequirementAmount(val3, num2);
							if (num4 != 0)
							{
								if ((Object)(object)val3.m_resItem == (Object)null)
								{
									throw new InvalidDataException("Ingredient prefab is missing.");
								}
								list4.Add(new Material(PrefabName(((Component)val3.m_resItem).gameObject), num4));
							}
						}
						list3.Add(list4);
					}
					value2.Add(new CraftRoute(((Object)item3).name, num, (IReadOnlyList<IReadOnlyList<Material>>)list3, text3, RecipeMarkupRate(val2)));
				}
				catch (Exception ex)
				{
					value2.Add(new CraftRoute(((Object)item3).name, 1, (IReadOnlyList<IReadOnlyList<Material>>)Array.Empty<IReadOnlyList<Material>>(), "Recipe import failed: " + ex.GetBaseException().Message));
				}
			}
			Smelter[] processors = RelevantProcessors().ToArray();
			ImportReviewedProcessors(catalogue, routes, blocks, processors);
			catalogue.ProcessorSignature = ReviewedProcessorSignature(processors);
			RuntimeDifficultyValuation.AddFermentationRoutes(catalogue, routes);
			RuntimeCookingValuation.AddConversionRoutes(catalogue, routes, val.CustomizedAnchors());
			RuntimeTraderValuation.AddConversionRoutes(catalogue, routes, val.CustomizedAnchors());
			RuntimeAlternativeConversionValuation.AddConversionRoutes(catalogue, routes, val.CustomizedAnchors());
			RuntimeEpicSupplementValuation.AddAccessoryRoutes(catalogue, routes);
			RuntimeEpicLootValuation.AddConversionRoutes(catalogue, routes, val.CustomizedAnchors());
			catalogue.SourceSnapshot = NativeOriginSnapshot.Capture();
			IReadOnlyDictionary<string, BiomeAdjustment> biomeAdjustments;
			IReadOnlyDictionary<string, DifficultyEstimate> estimates = RuntimeDifficultyValuation.Build(catalogue, anchors, out biomeAdjustments, routes);
			decimal value3;
			List<CraftRoute> value4;
			string value5;
			IEnumerable<ItemSpec> source = ((IEnumerable<CatalogueEntry>)catalogue.Items.Values).Select((Func<CatalogueEntry, ItemSpec>)((CatalogueEntry entry) => new ItemSpec(entry.Prefab, entry.MaxQuality, entry.MaxStack, anchors.TryGetValue(entry.Prefab, out value3) ? new decimal?(value3) : ((decimal?)null), (IReadOnlyList<CraftRoute>)(routes.TryGetValue(entry.Prefab, out value4) ? value4 : null), blocks.TryGetValue(entry.Prefab, out value5) ? value5 : null, TrophyValuation.IsTrophyType(((object)Unsafe.As<ItemType, ItemType>(ref entry.Drop.m_itemData.m_shared.m_itemType)/*cast due to .constrained prefix*/).ToString()), LimitConversionValue(entry))));
			HashSet<string> disabled = new HashSet<string>(val.DisabledReviewedAnchors, StringComparer.Ordinal);
			catalogue.Economy = BuildEconomyWithEstimates(source.Select((ItemSpec item) => (ItemSpec)(disabled.Contains(item.Prefab) ? ((object)new ItemSpec(item.Prefab, item.MaxQuality, item.MaxStack, item.Anchor, item.Routes, "Explicitly disabled in economy configuration.", item.IsTrophy, item.LimitConversionValue)) : ((object)item))), catalogue.Warnings, estimates, biomeAdjustments, TierMinimums(catalogue, biomeAdjustments, val.CustomizedAnchors()), catalogue.RouteBiomes);
			foreach (CatalogueEntry value6 in catalogue.Items.Values)
			{
				if (CataloguePolicy.IsExcluded(value6.Prefab))
				{
					value6.ShowInBrowser = false;
				}
			}
			foreach (IGrouping<string, CatalogueEntry> item4 in from x in catalogue.Items.Values.Where((CatalogueEntry x) => x.ShowInBrowser).GroupBy<CatalogueEntry, string>((CatalogueEntry x) => x.Display, StringComparer.OrdinalIgnoreCase)
				where x.Count() > 1
				select x)
			{
				foreach (CatalogueEntry item5 in item4)
				{
					item5.Display = item5.Display + " (" + item5.Prefab + ")";
				}
			}
			if (!catalogue.RecipeSnapshot.Matches(list))
			{
				throw new InvalidDataException("Recipe definitions changed while importing prices. Reopen Fate Forge.");
			}
			if (catalogue.StackConfigurationSignature != StackLimits.ConfigurationSignature)
			{
				throw new InvalidDataException("Item stack settings changed while loading the catalogue. Reopen Fate Forge.");
			}
			if (!catalogue.SourceSnapshot.Matches())
			{
				throw new InvalidDataException("Acquisition definitions changed while loading the catalogue. Reopen Fate Forge.");
			}
			return catalogue;
		}

		public static void ValidateRecipeIdentities(Catalogue catalogue, Recipe recipe)
		{
			if ((Object)(object)recipe == (Object)null || (Object)(object)recipe.m_item == (Object)null)
			{
				throw new InvalidDataException("Recipe output is missing.");
			}
			RequireLiveItemDefinition(catalogue, recipe.m_item);
			if (recipe.m_resources == null)
			{
				throw new InvalidDataException("Recipe ingredients are missing.");
			}
			int maxQuality = recipe.m_item.m_itemData.m_shared.m_maxQuality;
			Requirement[] resources = recipe.m_resources;
			foreach (Requirement requirement in resources)
			{
				if (requirement != null && !requirement.m_upgraderResource && Enumerable.Range(1, Math.Max(1, Math.Min(100, maxQuality))).Any((int q) => OrdinaryRequirementAmount(requirement, q) != 0))
				{
					RequireLiveItemDefinition(catalogue, requirement.m_resItem);
				}
			}
		}

		public static bool IsDurableWeapon(CatalogueEntry entry)
		{
			SharedData shared = entry.Drop.m_itemData.m_shared;
			return DurableWeaponValuation.IsEligible(((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString(), shared.m_useDurability, Math.Max(0m, (decimal)((DamageTypes)(ref shared.m_damages)).GetTotalDamage()));
		}

		public static bool LimitConversionValue(CatalogueEntry entry)
		{
			if (IsDurableWeapon(entry))
			{
				return false;
			}
			SharedData shared = entry.Drop.m_itemData.m_shared;
			string text = ((object)Unsafe.As<ItemType, ItemType>(ref shared.m_itemType)/*cast due to .constrained prefix*/).ToString();
			if (shared.m_useDurability)
			{
				switch (text)
				{
				default:
					return !(text == "Shield");
				case "Helmet":
				case "Chest":
				case "Legs":
				case "Shoulder":
					return false;
				}
			}
			return true;
		}

		public static IReadOnlyDictionary<string, decimal> TierMinimums(Catalogue catalogue, IReadOnlyDictionary<string, BiomeAdjustment> biomes, IEnumerable<string> customAnchors = null)
		{
			return TierBaseValuation.CreateMinimums(biomes, (customAnchors ?? Array.Empty<string>()).Concat(new string[1] { "Andvaranaut" }), from x in catalogue.Items.Values.Where(IsDurableWeapon)
				select x.Prefab);
		}

		public static Economy BuildConfiguredEconomy(IEnumerable<ItemSpec> source, EconomyConfiguration configuration, ICollection<string> warnings)
		{
			HashSet<string> disabled = new HashSet<string>(configuration.DisabledReviewedAnchors, StringComparer.Ordinal);
			return BuildReviewedEconomy(source.Select((ItemSpec item) => (ItemSpec)(disabled.Contains(item.Prefab) ? ((object)new ItemSpec(item.Prefab, item.MaxQuality, item.MaxStack, item.Anchor, item.Routes, "Explicitly disabled in economy configuration.", item.IsTrophy, item.LimitConversionValue)) : ((object)item))), warnings);
		}

		public static Economy BuildReviewedEconomy(IEnumerable<ItemSpec> source, ICollection<string> warnings)
		{
			return BuildEconomyWithEstimates(source, warnings, null);
		}

		private static Economy BuildEconomyWithEstimates(IEnumerable<ItemSpec> source, ICollection<string> warnings, IReadOnlyDictionary<string, DifficultyEstimate> estimates, IReadOnlyDictionary<string, BiomeAdjustment> biomes = null, IReadOnlyDictionary<string, decimal> tierMinimums = null, IReadOnlyDictionary<string, BiomeAdjustment> routeBiomes = null)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			ItemSpec[] array = source.ToArray();
			Economy val = new Economy((IEnumerable<ItemSpec>)array, estimates, biomes, tierMinimums, routeBiomes);
			Dictionary<string, string> violations = new Dictionary<string, string>(StringComparer.Ordinal);
			KeyValuePair<string, decimal>[] array2 = new KeyValuePair<string, decimal>[1]
			{
				new KeyValuePair<string, decimal>("Wood", 0.3m)
			};
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<string, decimal> keyValuePair = array2[i];
				PriceResult val2 = val.BasePrice(keyValuePair.Key, 1);
				if (val2.Available && !(val2.UnitValue == keyValuePair.Value))
				{
					string text = "Fixed base-cost conflict: imported " + keyValuePair.Key + " costs " + val2.UnitValue.ToString(CultureInfo.InvariantCulture) + "; required value is " + keyValuePair.Value.ToString(CultureInfo.InvariantCulture) + ". Review the changed acquisition costs.";
					violations.Add(keyValuePair.Key, text);
					warnings?.Add(text);
				}
			}
			string value;
			if (violations.Count != 0)
			{
				return new Economy(((IEnumerable<ItemSpec>)array).Select((Func<ItemSpec, ItemSpec>)((ItemSpec item) => new ItemSpec(item.Prefab, item.MaxQuality, item.MaxStack, item.Anchor, item.Routes, violations.TryGetValue(item.Prefab, out value) ? value : item.BlockReason, item.IsTrophy, item.LimitConversionValue))), estimates, biomes, tierMinimums, routeBiomes);
			}
			return val;
		}

		public static decimal RecipeMarkupRate(ItemDrop output)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)output == (Object)null || output.m_itemData?.m_shared == null)
			{
				throw new InvalidDataException("Recipe output metadata is missing.");
			}
			if (PrefabName(((Component)output).gameObject) == "SharpeningStone")
			{
				return 0.20m;
			}
			return RecipeMarkupRateForType(output.m_itemData.m_shared.m_itemType);
		}

		public static decimal RecipeMarkupRateForType(ItemType type)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			if (!Enum.IsDefined(typeof(ItemType), type) || (int)type == 0 || (int)type == 10)
			{
				throw new InvalidDataException("Recipe output type has no reviewed markup classification.");
			}
			if ((int)type == 1)
			{
				return 0.10m;
			}
			return 0.20m;
		}

		public static int OrdinaryOutputCount(Recipe recipe)
		{
			if (GameFields.Required<bool>(recipe, "m_noCraftOnlyUpgrade"))
			{
				throw new InvalidDataException("Upgrade-only recipe needs an audited base acquisition route.");
			}
			if (GameFields.Required<bool>(recipe, "m_requireOnlyOneIngredient"))
			{
				throw new InvalidDataException("Alternative-ingredient recipe needs a dedicated adapter.");
			}
			int num = GameFields.Required<int>(recipe, "m_amount");
			int num2 = default(int);
			ItemData val = default(ItemData);
			int amount = recipe.GetAmount(1, ref num2, ref val, 1);
			if (amount < 1 || amount != num || num2 != 0 || val != null)
			{
				throw new InvalidDataException("Ordinary recipe output differs from the audited single-craft rule.");
			}
			return amount;
		}

		public static void ValidateOrdinaryCraftingStation(Recipe recipe, int quality)
		{
			CraftingStation requiredStation = recipe.GetRequiredStation(quality);
			if ((Object)(object)requiredStation != (Object)null && requiredStation.m_upgrader)
			{
				throw new InvalidDataException("Special upgrader station acquisition requires a dedicated adapter.");
			}
		}

		public static int OrdinaryRequirementAmount(Requirement requirement, int quality)
		{
			if (requirement != null && !requirement.m_upgraderResource)
			{
				return requirement.GetAmount(quality);
			}
			return 0;
		}

		private static void ImportReviewedProcessors(Catalogue catalogue, Dictionary<string, List<CraftRoute>> routes, Dictionary<string, string> blocks, Smelter[] processors)
		{
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			KeyValuePair<string, string>[] reviewedProcessorOutputs = ReviewedProcessorOutputs;
			for (int i = 0; i < reviewedProcessorOutputs.Length; i++)
			{
				KeyValuePair<string, string> pair = reviewedProcessorOutputs[i];
				try
				{
					GameObject prefab = PrefabManager.Instance.GetPrefab(pair.Key);
					Smelter val = (((Object)(object)prefab == (Object)null) ? null : prefab.GetComponent<Smelter>());
					if ((Object)(object)val == (Object)null)
					{
						throw new InvalidDataException("Reviewed processor prefab is not loaded: " + pair.Key);
					}
					bool flag = ValidateReviewedProcessorCycle(val, pair.Key, pair.Value);
					ItemConversion[] array = ReviewedProcessorConversions(val, pair.Value);
					if (array.Length == 0)
					{
						throw new InvalidDataException("Reviewed output conversion is missing.");
					}
					List<CraftRoute> list = new List<CraftRoute>();
					ItemConversion[] array2 = array;
					foreach (ItemConversion val2 in array2)
					{
						string text = (flag ? "fuel only" : RequireLiveItemDefinition(catalogue, val2.m_from));
						ValidateProcessorSelection(val, val2);
						if (RequireLiveItemDefinition(catalogue, val2.m_to) != pair.Value)
						{
							throw new InvalidDataException("Processor output identity changed.");
						}
						List<Material> list2 = new List<Material>();
						if (!flag)
						{
							list2.Add(new Material(text, 1));
						}
						if (val.m_maxFuel > 0)
						{
							if (val.m_fuelPerProduct < 1)
							{
								throw new InvalidDataException("Processor fuel consumption is invalid.");
							}
							list2.Add(new Material(RequireLiveItemDefinition(catalogue, val.m_fuelItem), val.m_fuelPerProduct));
						}
						list.Add(new CraftRoute("Processor " + pair.Key + ": " + text + " -> " + pair.Value, 1, (IReadOnlyList<IReadOnlyList<Material>>)new IReadOnlyList<Material>[1] { list2 }, (string)null, 0.10m));
					}
					string text2 = ProcessorShape(val);
					foreach (Smelter item in processors.Where((Smelter x) => x.m_conversion.Any((ItemConversion c) => c != null && (Object)(object)c.m_to != (Object)null && PrefabName(((Component)c.m_to).gameObject) == pair.Value)))
					{
						if (PrefabName(((Component)item).gameObject) != pair.Key || ProcessorShape(item) != text2)
						{
							throw new InvalidDataException("An additional or changed processor route needs review.");
						}
					}
					if (!routes.TryGetValue(pair.Value, out var value))
					{
						value = (routes[pair.Value] = new List<CraftRoute>());
					}
					value.AddRange(list);
				}
				catch (Exception ex)
				{
					string text3 = "Processor acquisition estimated: " + ex.GetBaseException().Message;
					if (!routes.TryGetValue(pair.Value, out var value2))
					{
						value2 = (routes[pair.Value] = new List<CraftRoute>());
					}
					value2.Add(new CraftRoute("Processor " + pair.Key, 1, (IReadOnlyList<IReadOnlyList<Material>>)Array.Empty<IReadOnlyList<Material>>(), text3));
					catalogue.Warnings.Add(pair.Value + ": " + text3);
				}
			}
		}

		public static bool ValidateReviewedProcessorCycle(Smelter processor, string processorPrefab, string output)
		{
			if ((Object)(object)processor == (Object)null || PrefabName(((Component)processor).gameObject) != processorPrefab || !ReviewedProcessorOutputs.Any((KeyValuePair<string, string> pair) => pair.Key == processorPrefab && pair.Value == output) || processor.m_conversion == null || processor.m_conversion.Any((ItemConversion c) => c == null) || float.IsNaN(processor.m_secPerProduct) || float.IsInfinity(processor.m_secPerProduct) || processor.m_secPerProduct <= 0f || processor.m_secPerProduct % 1f != 0f || processor.m_maxFuel < 0 || processor.m_maxOre < 0)
			{
				throw new InvalidDataException("Processor no longer uses a reviewed production cycle.");
			}
			int num;
			if (processorPrefab == "piece_FrostKiln")
			{
				num = ((output == "FrozenFuel") ? 1 : 0);
				if (num != 0)
				{
					if (processor.m_maxOre != 0 || processor.m_maxFuel < 1 || processor.m_fuelPerProduct < 1 || (Object)(object)processor.m_fuelItem == (Object)null || (Object)(object)processor.m_windmill != (Object)null || processor.m_conversion.Count == 0 || processor.m_conversion.Any((ItemConversion c) => (Object)(object)c.m_from != (Object)null) || (processor.m_spawnStack && !GameFields.Required<bool>(processor, "m_noSourceConversion")))
					{
						throw new InvalidDataException("Fuel-only processor no longer uses the reviewed null-source cycle.");
					}
					goto IL_01e4;
				}
			}
			else
			{
				num = 0;
			}
			if (GameFields.Required<bool>(processor, "m_noSourceConversion") || processor.m_maxOre < 1 || ((Object)(object)processor.m_windmill != (Object)null && (processorPrefab != "windmill" || processor.m_maxFuel != 0)))
			{
				throw new InvalidDataException("Processor no longer uses the audited one-input/one-output cycle.");
			}
			goto IL_01e4;
			IL_01e4:
			return (byte)num != 0;
		}

		public static ItemConversion[] ReviewedProcessorConversions(Smelter processor, string output)
		{
			if ((Object)(object)processor == (Object)null || processor.m_conversion == null)
			{
				throw new InvalidDataException("Reviewed processor conversions are missing.");
			}
			List<ItemConversion> list = new List<ItemConversion>();
			foreach (ItemConversion conversion in processor.m_conversion.Where((ItemConversion c) => c != null && (Object)(object)c.m_to != (Object)null && PrefabName(((Component)c.m_to).gameObject) == output))
			{
				ValidateProcessorSelection(processor, conversion);
				if (!list.Any((ItemConversion c) => c.m_from == conversion.m_from && c.m_to == conversion.m_to))
				{
					list.Add(conversion);
				}
			}
			return list.ToArray();
		}

		private static string RequireLiveItemDefinition(Catalogue catalogue, ItemDrop drop)
		{
			if ((Object)(object)drop == (Object)null)
			{
				throw new InvalidDataException("Ingredient or output prefab is missing.");
			}
			string text = PrefabName(((Component)drop).gameObject);
			if (!catalogue.Items.TryGetValue(text, out var value) || value.Drop != drop || !IsLiveItem(catalogue, value))
			{
				throw new InvalidDataException("Item is not the exact live inventory definition: " + text);
			}
			return text;
		}

		public static void ValidateProcessorSelection(Smelter processor, ItemConversion conversion)
		{
			if ((Object)(object)processor == (Object)null || conversion == null || (Object)(object)conversion.m_to == (Object)null || ((Object)(object)conversion.m_from == (Object)null && (processor.m_maxOre != 0 || processor.m_maxFuel < 1)))
			{
				throw new InvalidDataException("Reviewed processor conversion is incomplete.");
			}
			MethodInfo? method = typeof(Smelter).GetMethod("GetItemConversion", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
			if (method == null)
			{
				throw new MissingMethodException("Smelter.GetItemConversion(string)");
			}
			object? obj = method.Invoke(processor, new object[1] { ((Object)(object)conversion.m_from == (Object)null) ? "" : ((Object)((Component)conversion.m_from).gameObject).name });
			ItemConversion val = (ItemConversion)((obj is ItemConversion) ? obj : null);
			if (val == null || val.m_from != conversion.m_from || val.m_to != conversion.m_to)
			{
				throw new InvalidDataException("An earlier processor conversion shadows this reviewed output.");
			}
		}

		private static IEnumerable<Smelter> RelevantProcessors()
		{
			return from x in Resources.FindObjectsOfTypeAll<Smelter>()
				where (Object)(object)x != (Object)null && x.m_conversion != null && x.m_conversion.Any((ItemConversion c) => c != null && (Object)(object)c.m_to != (Object)null && ReviewedProcessorOutputs.Any((KeyValuePair<string, string> pair) => pair.Value == PrefabName(((Component)c.m_to).gameObject)))
				select x;
		}

		private static string ProcessorShape(Smelter processor)
		{
			return string.Join("|", PrefabName(((Component)processor).gameObject), processor.m_maxOre.ToString(CultureInfo.InvariantCulture), processor.m_maxFuel.ToString(CultureInfo.InvariantCulture), processor.m_fuelPerProduct.ToString(CultureInfo.InvariantCulture), processor.m_secPerProduct.ToString("R", CultureInfo.InvariantCulture), Item(processor.m_fuelItem), GameFields.Required<bool>(processor, "m_noSourceConversion").ToString(), ((Object)(object)processor.m_windmill != (Object)null).ToString(), processor.m_spawnStack.ToString(), processor.m_requiresRoof.ToString(), string.Join(";", processor.m_conversion.Select((ItemConversion c) => (c != null) ? (Item(c.m_from) + ">" + Item(c.m_to)) : "null")));
			static string Item(ItemDrop item)
			{
				if (!((Object)(object)item == (Object)null))
				{
					return PrefabName(((Component)item).gameObject) + "#" + ((Object)item).GetInstanceID();
				}
				return "missing";
			}
		}

		private static string ReviewedProcessorSignature(IEnumerable<Smelter> processors = null)
		{
			try
			{
				return string.Join("\n", (processors ?? RelevantProcessors()).Select(ProcessorShape).Distinct().OrderBy<string, string>((string x) => x, StringComparer.Ordinal));
			}
			catch
			{
				return "unavailable";
			}
		}

		public static bool IsLiveItem(Catalogue catalogue, CatalogueEntry entry)
		{
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null || instance != catalogue.Database || (Object)(object)entry?.Object == (Object)null || (Object)(object)entry.Drop == (Object)null)
			{
				return false;
			}
			if (instance.GetItemPrefab(entry.Prefab) != entry.Object || entry.Object.GetComponent<ItemDrop>() != entry.Drop || !GameFields.Required<List<GameObject>>(instance, "m_items").Any((GameObject x) => x == entry.Object))
			{
				return false;
			}
			SharedData val = entry.Drop.m_itemData?.m_shared;
			if (val != null && val.m_maxQuality == entry.MaxQuality)
			{
				return StackLimits.ForTemplate(entry.Drop.m_itemData) == entry.MaxStack;
			}
			return false;
		}

		public static IEnumerable<string> LiveItemIds(Catalogue catalogue)
		{
			ObjectDB database = ObjectDB.instance;
			if ((Object)(object)database == (Object)null || catalogue == null || database != catalogue.Database)
			{
				yield break;
			}
			HashSet<object> present = new HashSet<object>(database.m_items.Cast<object>(), InstalledModCatalogue.ObjectIdentityComparer.Instance);
			foreach (CatalogueEntry value in catalogue.Items.Values)
			{
				if (value.ShowInBrowser && !CataloguePolicy.IsExcluded(value.Prefab) && !((Object)(object)value.Object == (Object)null) && !((Object)(object)value.Drop == (Object)null) && present.Contains(value.Object) && database.GetItemPrefab(value.Prefab) == value.Object && value.Object.GetComponent<ItemDrop>() == value.Drop)
				{
					SharedData val = value.Drop.m_itemData?.m_shared;
					if (val != null && val.m_maxQuality == value.MaxQuality && StackLimits.ForTemplate(value.Drop.m_itemData) == value.MaxStack)
					{
						yield return value.Prefab;
					}
				}
			}
		}

		public static bool RuntimeStillCurrent(Catalogue catalogue)
		{
			if (catalogue == null || (Object)(object)ObjectDB.instance == (Object)null || catalogue.Database != ObjectDB.instance || catalogue.EpicApiInstalled != EpicLootBridge.IsInstalled || catalogue.PluginSignature != InstalledModCatalogue.CurrentPluginSignature() || catalogue.StackConfigurationSignature != StackLimits.ConfigurationSignature || catalogue.RecipeSnapshot == null || !catalogue.RecipeSnapshot.Matches(ObjectDB.instance.m_recipes) || catalogue.ProcessorSignature != ReviewedProcessorSignature() || (catalogue.SourceSnapshot != null && !catalogue.SourceSnapshot.Matches()) || (catalogue.EpicMaterialSnapshot != null && !catalogue.EpicMaterialSnapshot.Matches()))
			{
				return false;
			}
			List<GameObject> list = GameFields.Required<List<GameObject>>(ObjectDB.instance, "m_items");
			if (list.Count == catalogue.RuntimeObjects.Length)
			{
				return !list.Where((GameObject item, int index) => item != catalogue.RuntimeObjects[index]).Any();
			}
			return false;
		}

		public static CraftingStation FindStation(Player player, float distance)
		{
			//IL_0032: 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)
			CraftingStation result = null;
			float num = distance;
			CraftingStation[] array = Object.FindObjectsByType<CraftingStation>((FindObjectsSortMode)0);
			foreach (CraftingStation val in array)
			{
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					float num2 = Vector3.Distance(((Component)player).transform.position, ((Component)val).transform.position);
					if (num2 <= num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		public static string ExportAudit(Catalogue catalogue, string directory)
		{
			Directory.CreateDirectory(directory);
			string text = Path.Combine(directory, "catalogue-" + DateTime.UtcNow.ToString("yyyyMMdd-HHmmss-fffffff") + ".csv");
			InstalledModSnapshot installedModSnapshot = InstalledModCatalogue.Capture(catalogue.Items.Values);
			StringBuilder stringBuilder = new StringBuilder("prefab,display_name,source,quality,max_stack,browser_visible,base_value,normal_value,biome,biome_multiplier,unit_value,status,reason,tier_minimum,biome_reason\n");
			foreach (CatalogueEntry item in catalogue.Items.Values.OrderBy<CatalogueEntry, string>((CatalogueEntry x) => x.Prefab, StringComparer.Ordinal))
			{
				for (int num = 1; num <= item.MaxQuality; num++)
				{
					PriceResult val = EpicLootBridge.PriceCanonicalReward(catalogue.Economy, item.Object, num);
					PriceResult val2 = catalogu