using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Timers;
using APIManager;
using AdventureBackpacks.API;
using AdventureBackpacks.Assets;
using AdventureBackpacks.Assets.Effects;
using AdventureBackpacks.Assets.Factories;
using AdventureBackpacks.Assets.Items;
using AdventureBackpacks.Assets.Items.BackpackItems;
using AdventureBackpacks.Compats;
using AdventureBackpacks.Components;
using AdventureBackpacks.Configuration;
using AdventureBackpacks.Extensions;
using AdventureBackpacks.Features;
using AdventureBackpacks.Patches;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Preloader;
using BepInEx.Preloader.Patching;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Vapok.Common.Abstractions;
using Vapok.Common.Managers;
using Vapok.Common.Managers.Configuration;
using Vapok.Common.Managers.Creature;
using Vapok.Common.Managers.LocalizationManager;
using Vapok.Common.Managers.Location;
using Vapok.Common.Managers.PieceManager;
using Vapok.Common.Managers.Skill;
using Vapok.Common.Managers.StatusEffects;
using Vapok.Common.Shared;
using Vapok.Common.Tools;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("AdventureBackpacks")]
[assembly: AssemblyDescription("A Valheim Mod for adding progression multiple backpacks as an item/utility gear addition.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Vapok Gaming")]
[assembly: AssemblyProduct("AdventureBackpacks")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("997CB563-FCC7-44B7-8F71-069747D27CC5")]
[assembly: AssemblyFileVersion("1.9.13.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.9.13.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 AdventureBackpacks
{
	[BepInPlugin("vapok.mods.adventurebackpacks", "Adventure Backpacks", "1.9.13")]
	[BepInIncompatibility("JotunnBackpacks")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class AdventureBackpacks : BaseUnityPlugin, IPluginInfo
	{
		public class Waiting
		{
			public event EventHandler StatusChanged;

			public void ValheimIsAwake(bool awakeFlag)
			{
				if (awakeFlag)
				{
					this.StatusChanged?.Invoke(this, EventArgs.Empty);
				}
			}
		}

		private const string _pluginId = "vapok.mods.adventurebackpacks";

		private const string _displayName = "Adventure Backpacks";

		private const string _version = "1.9.13";

		public static bool ValheimAwake;

		public static bool PerformYardSale;

		public static bool QuickDropping;

		public static bool BypassMoveProtection;

		public static Waiting Waiter;

		private static AdventureBackpacks _instance;

		private static ConfigSyncBase _config;

		private static ILogIt _log;

		private Harmony _harmony;

		public string PluginId => "vapok.mods.adventurebackpacks";

		public string DisplayName => "Adventure Backpacks";

		public string Version => "1.9.13";

		public BaseUnityPlugin Instance => (BaseUnityPlugin)(object)_instance;

		public static ILogIt Log => _log;

		public static ConfigSyncBase ActiveConfig => _config;

		[UsedImplicitly]
		private void Awake()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			_instance = this;
			Patcher.Patch(new string[1] { "AdventureBackpacks.API" });
			Waiter = new Waiting();
			CustomLocalization localization = LocalizationManager.Instance.GetLocalization();
			LogManager.Init(PluginId, out _log);
			Initializer.LoadManagers(localization, enableCreatureManager: false, enableItemManager: true, enableLocationManager: true, enableMaterialReplacer: true, enablePieceManager: false, enableSkillManager: false, enableEffectManager: true);
			_config = new ConfigRegistry(_instance);
			ItemManager.PrefabManager.Initalized = true;
			_harmony = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			if (Chainloader.PluginInfos.ContainsKey("com.chebgonaz.ChebsNecromancy"))
			{
				ChebsNecromancy.SetupNecromancyBackpackUsingApi();
			}
			if (Chainloader.PluginInfos.ContainsKey("com.maxsch.valheim.contentswithin"))
			{
				ContentsWithin.Awake(_harmony, "com.maxsch.valheim.contentswithin");
			}
		}

		private void Start()
		{
			Localizer.Waiter.StatusChanged += InitializeBackpacks;
			QuickTransfer.FeatureInitialized = true;
		}

		private void Update()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || !Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			if (PerformYardSale)
			{
				BackpackComponent equippedBackpack = Player.m_localPlayer.GetEquippedBackpack();
				if (equippedBackpack != null)
				{
					Backpacks.PerformYardSale(Player.m_localPlayer, equippedBackpack.Item);
				}
			}
			if (ZInput.GetButton("Forward") || ZInput.GetButton("Backward") || ZInput.GetButton("Left") || ZInput.GetButton("Right"))
			{
				KeyboardShortcut value = ConfigRegistry.HotKeyDrop.Value;
				if (ZInput.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey, true) && ConfigRegistry.OutwardMode.Value)
				{
					Player.m_localPlayer.QuickDropBackpack();
				}
			}
			EffectsFactory.Instance.ToggleEffects();
			InventoryPatches.ProcessItemsAddedQueue();
		}

		public void InitializeBackpacks(object send, EventArgs args)
		{
			if (!ValheimAwake)
			{
				new EffectsFactory(_log, _config).RegisterEffects();
				new BackpackFactory(_log, _config).CreateAssets();
				IronBackpackIconFix.Apply();
				SilverBackpackIconFix.Apply();
				Backpacks.LoadBackpackTypes(BackpackFactory.BackpackTypes());
				BoneReorder.ApplyOnEquipmentChanged(((BaseUnityPlugin)this).Info.Metadata.GUID);
				ConfigRegistry.Waiter.ConfigurationComplete(configDone: true);
				ValheimAwake = true;
			}
		}

		private void OnDestroy()
		{
			_instance = null;
		}
	}
}
namespace AdventureBackpacks.API
{
	[PublicAPI]
	public class ABAPI
	{
		public struct Backpack
		{
			public string Name;

			public ItemData ItemData;

			public Inventory Inventory;

			public BackpackDefinition Definition;
		}

		public class BackpackDefinition
		{
			public GameObject BackPackGo;

			public AssetBundle AssetBundle;

			public string PrefabName;

			public string ItemName;

			public string ConfigSection = "";

			public string CraftingTable;

			public int StationLevel;

			public int MaxRequiredStationLevel;

			public readonly List<RecipeIngredient> RecipeIngredients = new List<RecipeIngredient>();

			public readonly List<RecipeIngredient> UpgradeIngredients = new List<RecipeIngredient>();

			public readonly List<DropTarget> DropsFrom = new List<DropTarget>();

			public readonly Dictionary<BackpackBiomes, KeyValuePair<StatusEffect, int>> EffectsToApply = new Dictionary<BackpackBiomes, KeyValuePair<StatusEffect, int>>();

			public Dictionary<int, Vector2> BackpackSizeByQuality = new Dictionary<int, Vector2>();

			public StatusEffect ItemSetStatusEffect;

			public float WeightMultiplier;

			public int CarryBonus;

			public float SpeedMod;

			public bool EnableFreezing;

			public BackpackBiomes BackpackBiome;

			public BackpackDefinition()
			{
			}

			public BackpackDefinition(GameObject backPackGo)
			{
				BackPackGo = backPackGo;
			}

			public BackpackDefinition(AssetBundle assetBundle, string prefabName)
			{
				AssetBundle = assetBundle;
				PrefabName = prefabName;
			}
		}

		public struct DropTarget
		{
			public string Creature;

			public int Min;

			public int? Max;

			public float Chance;

			public DropTarget(string creature, float chance, int min = 1, int? max = null)
			{
				Creature = creature;
				Chance = chance;
				Min = min;
				Max = max;
			}
		}

		public struct EffectDefinition
		{
			public readonly string Name;

			public readonly string LocalizedName;

			public readonly string EffectName;

			public readonly string Description;

			public readonly StatusEffect StatusEffect;

			public EffectDefinition(string name, string localizedName, string effectName, string description, StatusEffect statusEffect)
			{
				Name = name;
				LocalizedName = localizedName;
				EffectName = effectName;
				Description = description;
				StatusEffect = statusEffect;
			}
		}

		public struct RecipeIngredient
		{
			public string ItemPrefabName;

			public int Quantity;

			public RecipeIngredient(string itemPrefabName, int quantity)
			{
				ItemPrefabName = itemPrefabName;
				Quantity = quantity;
			}
		}

		public static bool IsLoaded()
		{
			return true;
		}

		public static bool IsBackpack(ItemData itemData)
		{
			return itemData?.IsBackpack() ?? false;
		}

		public static bool IsBackpackEquipped(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return player.IsBackpackEquipped();
			}
			return false;
		}

		public static bool CanOpenBackpack(Player player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return player.CanOpenBackpack();
			}
			return false;
		}

		public static bool IsThisBackpackEquipped(Player player, ItemData itemData)
		{
			if ((Object)(object)player != (Object)null)
			{
				return player.IsThisBackpackEquipped(itemData);
			}
			return false;
		}

		public static Backpack? GetEquippedBackpack(Player player)
		{
			return ConvertBackpackItem(player.GetEquippedBackpack());
		}

		public static Backpack? GetBackpack(ItemData itemData)
		{
			return ConvertBackpackItem(itemData);
		}

		public static HashSet<StatusEffect> GetActiveBackpackStatusEffects()
		{
			return EquipmentEffectCache.ActiveEffects;
		}

		public static HashSet<StatusEffect> GetRegisterdStatusEffects()
		{
			return EffectsFactory.GetRegisteredEffects();
		}

		public static void OpenBackpack(Player player, InventoryGui gui)
		{
			if ((Object)(object)player != (Object)null)
			{
				player.OpenBackpack(gui);
			}
		}

		public static void RegisterEffect(EffectDefinition effectDefinition)
		{
			EffectsFactory.RegisterExternalEffect(effectDefinition);
		}

		public static void RegisterBackpack(BackpackDefinition definition)
		{
			BackpackFactory.RegisterExternalBackpack(definition);
		}

		private static Backpack? ConvertBackpackItem(BackpackComponent component)
		{
			BackpackDefinition backPackDefinitionFromComponent = GetBackPackDefinitionFromComponent(component);
			if (backPackDefinitionFromComponent == null)
			{
				return null;
			}
			return new Backpack
			{
				Name = backPackDefinitionFromComponent.ItemName,
				ItemData = component.Item,
				Definition = backPackDefinitionFromComponent,
				Inventory = component.GetInventory()
			};
		}

		private static Backpack? ConvertBackpackItem(ItemData itemData)
		{
			if (!itemData.IsBackpack())
			{
				return null;
			}
			return ConvertBackpackItem(itemData.Data().GetOrCreate<BackpackComponent>());
		}

		private static Dictionary<int, Vector2> GetBackpackSizing(BackpackItem backpack)
		{
			return backpack.BackpackSize.ToDictionary((KeyValuePair<int, ConfigEntry<Vector2>> entry) => entry.Key, (KeyValuePair<int, ConfigEntry<Vector2>> entry) => entry.Value.Value);
		}

		private static BackpackDefinition GetBackPackDefinitionFromComponent(BackpackComponent component)
		{
			if (component.Item.TryGetBackpackItem(out var backpack))
			{
				return null;
			}
			return GetBackPackDefinition(backpack);
		}

		private static BackpackDefinition GetBackPackDefinition(BackpackItem backpack)
		{
			return new BackpackDefinition
			{
				ItemName = backpack.ItemName,
				PrefabName = backpack.PrefabName,
				BackpackSizeByQuality = GetBackpackSizing(backpack),
				WeightMultiplier = backpack.WeightMultiplier.Value,
				CarryBonus = backpack.CarryBonus.Value,
				SpeedMod = backpack.SpeedMod.Value,
				EnableFreezing = backpack.EnableFreezing.Value,
				BackpackBiome = backpack.BackpackBiome.Value
			};
		}
	}
	[Flags]
	public enum BackpackBiomes : uint
	{
		None = 0u,
		Meadows = 1u,
		BlackForest = 2u,
		Swamp = 4u,
		Mountains = 8u,
		Plains = 0x10u,
		Mistlands = 0x20u,
		Ashlands = 0x40u,
		DeepNorth = 0x80u,
		EffectBiome1 = 0x100000u,
		EffectBiome2 = 0x200000u,
		EffectBiome3 = 0x400000u,
		EffectBiome4 = 0x800000u,
		EffectBiome5 = 0x1000000u
	}
}
namespace AdventureBackpacks.Compats
{
	public static class ChebsNecromancy
	{
		public static void SetupNecromancyBackpackUsingApi()
		{
			//IL_00ca: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: 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_025e: Unknown result type (might be due to invalid IL or missing references)
			string text = "SetEffect_NecromancyArmor";
			string text2 = "chebgonaz";
			string path = "Assets";
			string text3 = "";
			string text4 = "friendlyskeletonwand_necromancy_skill";
			StatusEffect val = null;
			if (!ABAPI.IsLoaded())
			{
				return;
			}
			PluginInfo val2 = Chainloader.PluginInfos["com.chebgonaz.ChebsNecromancy"];
			text3 = Path.Combine(Paths.PluginPath, Path.GetDirectoryName(val2.Location) ?? "", path, text2);
			if (!File.Exists(text3))
			{
				text3 = Path.Combine(Paths.PluginPath, Path.GetDirectoryName(val2.Location) ?? "", text2);
			}
			AssetBundle val3 = ((!File.Exists(text3)) ? null : AssetBundle.LoadFromFile(text3));
			if ((Object)(object)val3 == (Object)null)
			{
				AdventureBackpacks.Log.Error("Can't find Asset Bundle for Status Effect: " + text + " - Effect Not Registered");
				return;
			}
			SkillType skillLevel = (SkillType)Math.Abs(StringExtensionMethods.GetStableHashCode(text4));
			SE_Stats val4 = val3.LoadAsset<SE_Stats>(text);
			if ((Object)(object)val4 != (Object)null)
			{
				val4.m_skillLevel = skillLevel;
				val4.m_skillLevelModifier = 10f;
			}
			val = (StatusEffect)(object)val4;
			ABAPI.RegisterEffect(new ABAPI.EffectDefinition("Necromancy Armor Effect", "Necromancy Armor Effect", text, "When activated the backpack provides the Necromancy Armor effect from Cheb's Necromancy", val));
			AssetBundle val5 = Utilities.LoadAssetBundle("chebsbackpack");
			if ((Object)(object)val5 == (Object)null)
			{
				AdventureBackpacks.Log.Warning("Asset Bundle Not Found");
				return;
			}
			string prefabName = "BackpackNecromancy";
			ABAPI.RegisterBackpack(new ABAPI.BackpackDefinition(val5, prefabName)
			{
				ItemName = "$item_friendlyskeletonwand_spectralshroud_backpack",
				CraftingTable = "piece_workbench",
				StationLevel = 1,
				MaxRequiredStationLevel = 4,
				RecipeIngredients = 
				{
					new ABAPI.RecipeIngredient("ChebGonaz_SpectralShroud", 1),
					new ABAPI.RecipeIngredient("TrollHide", 5)
				},
				UpgradeIngredients = 
				{
					new ABAPI.RecipeIngredient("Chain", 1),
					new ABAPI.RecipeIngredient("TrollHide", 5)
				},
				DropsFrom = 
				{
					new ABAPI.DropTarget("ChebGonaz_GuardianWraith", 0.002f)
				},
				BackpackBiome = (BackpackBiomes.BlackForest | BackpackBiomes.EffectBiome1),
				BackpackSizeByQuality = 
				{
					{
						1,
						new Vector2(3f, 3f)
					},
					{
						2,
						new Vector2(4f, 3f)
					},
					{
						3,
						new Vector2(5f, 3f)
					},
					{
						4,
						new Vector2(6f, 3f)
					}
				},
				WeightMultiplier = 20f,
				EffectsToApply = { 
				{
					BackpackBiomes.EffectBiome1,
					new KeyValuePair<StatusEffect, int>(val, 1)
				} },
				ItemSetStatusEffect = val
			});
		}
	}
	public static class ContentsWithin
	{
		private static PluginInfo _plugin;

		private static Assembly _assembly;

		public static Type Main;

		public static Type InventoryGuiPatch;

		public static void Awake(Harmony harmony, string guidID)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			if (Chainloader.PluginInfos.TryGetValue(guidID, out _plugin))
			{
				_assembly = Assembly.LoadFile(_plugin.Location);
				Main = _assembly.GetType("ContentsWithin.ContentsWithin");
				InventoryGuiPatch = Main.GetNestedType("InventoryGuiPatch");
				MethodInfo methodInfo = AccessTools.Method(InventoryGuiPatch, "HasContainerAccess", (Type[])null, (Type[])null);
				if (InventoryGuiPatch != null)
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(ContentsWithin), "ContainerAccessPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static bool ContainerAccessPrefix(Container container, ref bool __result)
		{
			if ((Object)(object)container == (Object)null)
			{
				return true;
			}
			if (!((Object)container).name.Equals("Player(Clone)"))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
}
namespace AdventureBackpacks.Patches
{
	public static class ArmorStandPatches
	{
		[HarmonyPatch(typeof(ArmorStand), "UpdateAttach")]
		private static class ArmorStandUpdateAttachPatch
		{
			private static void Prefix(ArmorStand __instance)
			{
				AdventureBackpacks.BypassMoveProtection = true;
			}

			private static void Postfix(ArmorStand __instance)
			{
				AdventureBackpacks.BypassMoveProtection = false;
			}
		}
	}
	public static class ContainerPatches
	{
		[HarmonyPatch(typeof(Container), "TakeAll")]
		private static class ContainerTakeAllPatch
		{
			private static void Prefix(Container __instance)
			{
				AdventureBackpacks.BypassMoveProtection = true;
			}

			private static void Postfix(Container __instance)
			{
				AdventureBackpacks.BypassMoveProtection = false;
			}
		}

		[HarmonyPatch(typeof(Container), "Interact")]
		private static class ContainerInteractPatch
		{
			private static bool Prefix(Container __instance, ref bool __result)
			{
				if (((Object)__instance).name.Equals("Player(Clone)"))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Container), "Awake")]
		private static class ContainerAwakePatch
		{
			private static void UpdateZDO(Container instance, ZNetView nview)
			{
				if (((Object)instance).name.Equals("Player(Clone)"))
				{
					nview.GetZDO().Set(StringExtensionMethods.GetStableHashCode("creator"), 1L);
				}
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator ilGenerator)
			{
				bool patchedSuccess = false;
				List<CodeInstruction> instrs = instructions.ToList();
				int counter = 0;
				MethodInfo invokeRepeatingMethod = AccessTools.DeclaredMethod(typeof(MonoBehaviour), "InvokeRepeating", new Type[3]
				{
					typeof(string),
					typeof(float),
					typeof(float)
				}, (Type[])null);
				FieldInfo nviewField = AccessTools.DeclaredField(typeof(Container), "m_nview");
				int i = 0;
				while (i < instrs.Count)
				{
					if (i > 5 && instrs[i].opcode == OpCodes.Ret && instrs[i - 1].opcode == OpCodes.Call && instrs[i - 1].operand.Equals(invokeRepeatingMethod))
					{
						yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
						counter++;
						yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
						counter++;
						yield return new CodeInstruction(OpCodes.Ldfld, (object)nviewField);
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ContainerAwakePatch), "UpdateZDO", (Type[])null, (Type[])null)));
						counter++;
						patchedSuccess = true;
					}
					yield return LogMessage(instrs[i]);
					counter++;
					int num = i + 1;
					i = num;
				}
				if (!patchedSuccess)
				{
					AdventureBackpacks.Log.Error("Container.Awake Transpiler Failed To Patch");
					Thread.Sleep(5000);
				}
				CodeInstruction LogMessage(CodeInstruction instruction)
				{
					AdventureBackpacks.Log.Debug($"IL_{counter}: Opcode: {instruction.opcode} Operand: {instruction.operand}");
					return instruction;
				}
			}
		}
	}
	public static class DoorPatches
	{
		[HarmonyPatch(typeof(Door), "HaveKey")]
		private static class HaveDoorKeyPatch
		{
			private static void Postfix(Door __instance, ref bool __result)
			{
				if (!((Object)(object)__instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null) && Player.m_localPlayer.IsBackpackEquipped() && !__result)
				{
					BackpackComponent equippedBackpack = Player.m_localPlayer.GetEquippedBackpack();
					__result = (Object)(object)__instance.m_keyItem == (Object)null || equippedBackpack.GetInventory().HaveItem(__instance.m_keyItem.m_itemData.m_shared.m_name, true);
				}
			}
		}
	}
	public class EnvManPatches
	{
		[HarmonyPatch(typeof(EnvMan), "IsCold")]
		public static class EnvManIsCold
		{
			[UsedImplicitly]
			[HarmonyPriority(800)]
			public static bool Prefix(EnvMan __instance, ref bool __result)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return true;
				}
				if (EffectsFactory.EffectList[BackpackEffect.ColdResistance].IsEffectActive((Humanoid)(object)Player.m_localPlayer))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(EnvMan), "IsWet")]
		public static class EnvManIsWet
		{
			[UsedImplicitly]
			[HarmonyPriority(800)]
			public static bool Prefix(EnvMan __instance, ref bool __result)
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return true;
				}
				if (EffectsFactory.EffectList[BackpackEffect.WaterResistance].IsEffectActive((Humanoid)(object)Player.m_localPlayer))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}
	}
	public class FejdStartupPatches
	{
		[HarmonyPatch(typeof(FejdStartup), "Start")]
		[HarmonyAfter(new string[] { "org.bepinex.helpers.LocalizationManager" })]
		[HarmonyBefore(new string[] { "org.bepinex.helpers.ItemManager" })]
		public static class FejdStartupAwakePatch
		{
			private static void Postfix()
			{
				AdventureBackpacks.Waiter.ValheimIsAwake(awakeFlag: true);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Start")]
		[HarmonyAfter(new string[] { "org.bepinex.helpers.ItemManager" })]
		private static class FejdStartupAfterItemManagerIconFix
		{
			private static void Postfix()
			{
				IronBackpackIconFix.Apply();
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Start")]
		[HarmonyAfter(new string[] { "org.bepinex.helpers.ItemManager" })]
		private static class FejdStartupAfterItemManagerSilverIconFix
		{
			private static void Postfix()
			{
				SilverBackpackIconFix.Apply();
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static class ObjectDBAwakeIronIconFix
		{
			private static void Postfix()
			{
				IronBackpackIconFix.Apply();
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static class ObjectDBAwakeSilverIconFix
		{
			private static void Postfix()
			{
				SilverBackpackIconFix.Apply();
			}
		}
	}
	public class GuiBarPatches
	{
		[HarmonyPatch(typeof(GuiBar), "Awake")]
		public static class GuiBarAwakePatch
		{
			public const string eaqsGUID = "randyknapp.mods.equipmentandquickslots";

			private static bool Prefix(GuiBar __instance)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				if (!Chainloader.PluginInfos.ContainsKey("randyknapp.mods.equipmentandquickslots") && ((Object)__instance).name == "durability" && __instance.m_bar.sizeDelta.x != 54f)
				{
					__instance.m_bar.sizeDelta = new Vector2(54f, 0f);
				}
				return true;
			}
		}
	}
	public class HumanoidPatches
	{
		[HarmonyPatch(typeof(Humanoid), "UpdateEquipmentStatusEffects")]
		private static class HumanoidUpdateEquipmentStatusEffectsPatch
		{
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				bool patchedSuccess = false;
				List<CodeInstruction> instrs = instructions.ToList();
				int counter = 0;
				CodeInstruction ldlocInstruction = new CodeInstruction(OpCodes.Ldloc_0, (object)null);
				int i = 0;
				while (i < instrs.Count)
				{
					yield return LogMessage(instrs[i]);
					counter++;
					if (i > 0 && instrs[i].opcode == OpCodes.Stloc_0 && instrs[i - 1].opcode == OpCodes.Newobj)
					{
						if (instrs[i].labels.Count > 0)
						{
							CodeInstructionExtensions.MoveLabelsTo(instrs[i], ldlocInstruction);
						}
						yield return LogMessage(ldlocInstruction);
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(EquipmentEffectCache), "AddActiveBackpackEffects", (Type[])null, (Type[])null)));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Stloc_0, (object)null));
						counter++;
						patchedSuccess = true;
					}
					int num = i + 1;
					i = num;
				}
				if (!patchedSuccess)
				{
					AdventureBackpacks.Log.Error("UpdateEquipmentStatusEffects Transpiler Failed To Patch");
					Thread.Sleep(5000);
				}
				CodeInstruction LogMessage(CodeInstruction instruction)
				{
					AdventureBackpacks.Log.Debug($"IL_{counter}: Opcode: {instruction.opcode} Operand: {instruction.operand}");
					return instruction;
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
		private static class HumanoidUnequipItemPatch
		{
			private static void Prefix(ItemData __0)
			{
				//IL_0012: 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_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Expected O, but got Unknown
				if (__0 == null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name.Equals("start"))
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (!__0.IsBackpack() || ((Humanoid)localPlayer).m_shoulderItem != __0)
				{
					return;
				}
				BackpackComponent equippedBackpack = localPlayer.GetEquippedBackpack();
				if (equippedBackpack != null)
				{
					equippedBackpack.Save();
					InventoryGui instance = InventoryGui.instance;
					if ((Object)(object)instance != (Object)null && instance.IsContainerOpen())
					{
						instance.CloseContainer();
						InventoryGuiPatches.BackpackIsOpen = false;
					}
					Container component = ((Component)localPlayer).gameObject.GetComponent<Container>();
					if (!((Object)(object)component == (Object)null))
					{
						component.m_inventory = new Inventory("Empty", (Sprite)null, 1, 1);
						InventoryGuiPatches.BackpackEquipped = false;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		private static class HumanoidEquipItemPatch
		{
			private static void Postfix(ItemData __0, bool __result)
			{
				//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_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				AdventureBackpacks.Log.Debug("##########   EquipItem Start");
				if (__0 == null || !__result || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name.Equals("start"))
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (__0.IsBackpack() && __0.TryGetBackpackItem(out var backpack))
				{
					InventoryGuiPatches.BackpackEquipped = true;
					BackpackComponent orCreate = __0.Data().GetOrCreate<BackpackComponent>();
					if (!orCreate.IsEmptyingBackpack)
					{
						Vector2i inventorySize = backpack.GetInventorySize(orCreate.Item.m_quality);
						if (orCreate.InventoryNeedsValidating(inventorySize))
						{
							Backpacks.ValidateBackpackInventorySizing(localPlayer, orCreate.Item);
						}
						else
						{
							Container backpackContainer = ((Component)localPlayer).gameObject.GetComponent<Container>();
							if ((Object)(object)backpackContainer != (Object)null)
							{
								orCreate.UpdateContainerSizing(ref backpackContainer);
							}
						}
					}
				}
				AdventureBackpacks.Log.Debug("##########   EquipItem End");
			}
		}
	}
	public static class InventoryPatches
	{
		[HarmonyPatch(typeof(Inventory), "Changed")]
		private static class InventoryChangedPatch
		{
			private static void Postfix(Inventory __instance)
			{
				if (__instance == null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (!__instance.IsBackPackInventory())
				{
					return;
				}
				new StackTrace();
				AdventureBackpacks.Log.Debug("#### Patch Inventory Changed: " + __instance.m_name);
				AdventureBackpacks.Log.Debug($"#### Patch Inventory Count: {__instance.m_inventory.Count}");
				if (!localPlayer.IsBackpackEquipped())
				{
					return;
				}
				BackpackComponent equippedBackpack = localPlayer.GetEquippedBackpack();
				AdventureBackpacks.Log.Debug("########################################");
				AdventureBackpacks.Log.Debug("####       Inventory.Changed       #####");
				AdventureBackpacks.Log.Debug("Inventory Instance: " + __instance.m_name);
				AdventureBackpacks.Log.Debug("Backpack Name: " + equippedBackpack.Item.m_shared.m_name);
				AdventureBackpacks.Log.Debug("########################################");
				if (equippedBackpack.GetInventory() == __instance)
				{
					AdventureBackpacks.Log.Debug($"#### Before Save BackpackComponent Inventory Count: {equippedBackpack.GetInventory().m_inventory.Count}");
					if (equippedBackpack.IsLoadingInventory)
					{
						AdventureBackpacks.Log.Debug("Bypassing Save - Inventory Is Loading ----->");
					}
					else
					{
						equippedBackpack.Save(__instance);
					}
					AdventureBackpacks.Log.Debug($"#### After Save BackpackComponent Inventory Count: {equippedBackpack.GetInventory().m_inventory.Count}");
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnDropOutside")]
		[HarmonyPriority(800)]
		private static class OnDropOutsideItemPatch
		{
			private static void Prefix(InventoryGui __instance)
			{
				if (!((Object)(object)__instance == (Object)null) && __instance.m_dragItem != null)
				{
					if (__instance.m_dragItem.IsBackpack() && __instance.m_dragItem.m_stack == 0)
					{
						__instance.m_dragItem.m_stack = 1;
					}
					_droppingOutside = true;
				}
			}

			private static void Postfix()
			{
				_droppingOutside = false;
			}
		}

		[HarmonyPatch(typeof(Humanoid), "DropItem", new Type[]
		{
			typeof(Inventory),
			typeof(ItemData),
			typeof(int)
		})]
		[HarmonyPriority(800)]
		private static class HumanoidDropItemPatch
		{
			private static void Prefix(ItemData item)
			{
				_droppingOutside = true;
			}

			private static void Postfix()
			{
				_droppingOutside = false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "RemoveItem", new Type[] { typeof(ItemData) })]
		[HarmonyPriority(800)]
		private static class RemoveItem1Patch
		{
			private static bool Prefix(Inventory __instance, ItemData item, ref bool __result)
			{
				if (item == null || __instance == null)
				{
					return true;
				}
				if (!RemoveItemPrefix(__instance, item))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Inventory), "RemoveItem", new Type[]
		{
			typeof(ItemData),
			typeof(int)
		})]
		[HarmonyPriority(800)]
		private static class RemoveItem2Patch
		{
			private static bool Prefix(Inventory __instance, ItemData item, ref bool __result)
			{
				if (item == null || __instance == null)
				{
					return true;
				}
				if (!RemoveItemPrefix(__instance, item))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Inventory), "RemoveOneItem", new Type[] { typeof(ItemData) })]
		[HarmonyPriority(800)]
		private static class RemoveItem3Patch
		{
			private static bool Prefix(Inventory __instance, ItemData item, ref bool __result)
			{
				if (item == null || __instance == null)
				{
					return true;
				}
				if (!RemoveItemPrefix(__instance, item))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(long),
			typeof(string),
			typeof(Vector2i),
			typeof(bool)
		})]
		[HarmonyPriority(800)]
		private static class AddItemCraftingPatch
		{
			private static void Postfix(Inventory __instance, ref ItemData __result)
			{
				if (IsDoingCrafting && __instance != null)
				{
					_savedBackpackData = null;
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[] { typeof(ItemData) })]
		[HarmonyPriority(800)]
		private static class AddItemPatch
		{
			private static bool Prefix(Inventory __instance, ItemData item, ref bool __result)
			{
				if (item == null)
				{
					return false;
				}
				if (item.IsBackpack() && __instance.HaveEmptySlot())
				{
					bool flag = Backpacks.CheckForInception(__instance, item);
					if (flag && !_movingItemBetweenContainers)
					{
						ItemsAddedQueue.Enqueue(new KeyValuePair<ItemData, DateTime>(item, DateTime.Now));
					}
					__result = flag;
					return flag;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "DropItem", new Type[]
		{
			typeof(Inventory),
			typeof(ItemData),
			typeof(int),
			typeof(Vector2i)
		})]
		[HarmonyPriority(800)]
		private static class InventoryGridDropItemPatch
		{
			private static bool Prefix(InventoryGrid __instance, Inventory fromInventory, ItemData item, int amount, Vector2i pos)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				ItemData itemAt = __instance.m_inventory.GetItemAt(pos.x, pos.y);
				if (itemAt == item)
				{
					return true;
				}
				if (itemAt == null || (!(itemAt.m_shared.m_name != item.m_shared.m_name) && (item.m_shared.m_maxQuality <= 1 || itemAt.m_quality == item.m_quality) && itemAt.m_shared.m_maxStackSize != 1) || item.m_stack != amount)
				{
					return true;
				}
				if (AdventureBackpacks.PerformYardSale)
				{
					return true;
				}
				if (itemAt.IsBackpack() && fromInventory.IsBackPackInventory())
				{
					return Backpacks.CheckForInception(fromInventory, itemAt);
				}
				if (item.IsBackpack() && __instance.m_inventory.IsBackPackInventory())
				{
					return Backpacks.CheckForInception(__instance.m_inventory, item);
				}
				_movingItemBetweenContainers = true;
				return true;
			}
		}

		[HarmonyPatch(typeof(Inventory), "MoveAll", new Type[] { typeof(Inventory) })]
		[HarmonyPriority(800)]
		private static class MoveAllPatch
		{
			private static void Prefix(Inventory fromInventory, Inventory __instance)
			{
				if (fromInventory != null && !__instance.IsBackPackInventory())
				{
					_movingItemBetweenContainers = true;
				}
			}

			private static void Postfix()
			{
				_movingItemBetweenContainers = false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "MoveItemToThis", new Type[]
		{
			typeof(Inventory),
			typeof(ItemData),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		[HarmonyPriority(800)]
		private static class MoveItemToThisPatch
		{
			private static bool Prefix(Inventory __0, ItemData __1, int __2, int __3, int __4, Inventory __instance)
			{
				if (__0 == null || __1 == null)
				{
					return false;
				}
				if (!__instance.IsBackPackInventory())
				{
					_movingItemBetweenContainers = true;
					return true;
				}
				return Backpacks.CheckForInception(__instance, __1);
			}

			private static void Postfix()
			{
				_movingItemBetweenContainers = false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "MoveItemToThis", new Type[]
		{
			typeof(Inventory),
			typeof(ItemData)
		})]
		[HarmonyPriority(800)]
		private static class MoveItemToThisOtherPatch
		{
			private static bool Prefix(Inventory __0, ItemData __1, Inventory __instance)
			{
				if (__0 == null || __1 == null)
				{
					return false;
				}
				if (!__instance.IsBackPackInventory())
				{
					_movingItemBetweenContainers = true;
					return true;
				}
				return Backpacks.CheckForInception(__instance, __1);
			}

			private static void Postfix()
			{
				_movingItemBetweenContainers = false;
			}
		}

		[HarmonyPatch(typeof(Inventory), "UpdateTotalWeight")]
		private static class UpdateTotalWeightPatch
		{
			[HarmonyPatch(typeof(Inventory), "IsTeleportable")]
			private static class IsTeleportablePatch
			{
				private static void Postfix(Inventory __instance, ref bool __result)
				{
					if (__instance == null || (Object)(object)Player.m_localPlayer == (Object)null)
					{
						return;
					}
					List<ItemData> allItems = __instance.GetAllItems();
					if (__instance != ((Humanoid)Player.m_localPlayer).GetInventory())
					{
						return;
					}
					if (Player.m_localPlayer.IsBackpackEquipped())
					{
						BackpackComponent equippedBackpack = Player.m_localPlayer.GetEquippedBackpack();
						if (equippedBackpack != null && !equippedBackpack.GetInventory().IsTeleportable())
						{
							__result = false;
							return;
						}
					}
					foreach (ItemData item in allItems)
					{
						if (item != null && item.IsBackpack() && !item.Data().GetOrCreate<BackpackComponent>().GetInventory()
							.IsTeleportable())
						{
							__result = false;
							break;
						}
					}
				}
			}

			private static void Postfix(Inventory __instance)
			{
				if (__instance == null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (__instance.IsBackPackInventory() && localPlayer.IsBackpackEquipped())
				{
					BackpackComponent equippedBackpack = localPlayer.GetEquippedBackpack();
					AdventureBackpacks.Log.Debug("########################################");
					AdventureBackpacks.Log.Debug("####       UpdateTotalWeight       #####");
					AdventureBackpacks.Log.Debug("Inventory Instance: " + __instance.m_name);
					AdventureBackpacks.Log.Debug("Backpack Name: " + equippedBackpack.Item.m_shared.m_name);
					AdventureBackpacks.Log.Debug("########################################");
					if (equippedBackpack.GetInventory() == __instance)
					{
						((Humanoid)localPlayer).GetInventory().UpdateTotalWeight();
					}
				}
			}
		}

		private static bool _movingItemBetweenContainers;

		private static bool _droppingOutside;

		public static bool IsDoingCrafting = false;

		private static BackpackComponent _savedBackpackData = null;

		private static readonly Queue<KeyValuePair<ItemData, DateTime>> ItemsAddedQueue = new Queue<KeyValuePair<ItemData, DateTime>>();

		private static bool IsItemFromQueue(this ItemData item)
		{
			if (ItemsAddedQueue.Any((KeyValuePair<ItemData, DateTime> x) => ((object)x.Key).Equals((object?)item)))
			{
				AdventureBackpacks.Log.Debug("Item " + item.m_shared.m_name + " Found!");
				return true;
			}
			AdventureBackpacks.Log.Debug("Item Not Found!");
			return false;
		}

		public static void ProcessItemsAddedQueue()
		{
			while (ItemsAddedQueue.Any() && DateTime.Now.Subtract(ItemsAddedQueue.Peek().Value).TotalSeconds > 0.5)
			{
				AdventureBackpacks.Log.Debug($"Process Cache Removing {ItemsAddedQueue.Peek().Key.m_shared.m_name} for Date {ItemsAddedQueue.Peek().Value} with a difference of {DateTime.Now.Subtract(ItemsAddedQueue.Peek().Value).TotalSeconds} total seconds.");
				ItemsAddedQueue.Dequeue();
			}
		}

		private static bool RemoveItemPrefix(Inventory __instance, ItemData item)
		{
			if (__instance == null || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return true;
			}
			if (_movingItemBetweenContainers || _droppingOutside)
			{
				return true;
			}
			if (IsDoingCrafting)
			{
				if (item.IsBackpack())
				{
					_savedBackpackData = item.Data().Get<BackpackComponent>();
				}
				return true;
			}
			if (AdventureBackpacks.PerformYardSale || AdventureBackpacks.QuickDropping || AdventureBackpacks.BypassMoveProtection)
			{
				return true;
			}
			if (!item.TryGetBackpackItem(out var _))
			{
				return true;
			}
			AdventureBackpacks.Log.Debug("Checking for Backpack " + item.m_shared.m_name);
			if (item.IsItemFromQueue())
			{
				AdventureBackpacks.Log.Debug("Exiting RemoveItem for " + item.m_shared.m_name);
				return true;
			}
			BackpackComponent backpackComponent = item.Data().Get<BackpackComponent>();
			if (backpackComponent == null)
			{
				return true;
			}
			Inventory inventory = backpackComponent.GetInventory();
			if (inventory == null || inventory.m_inventory.Count == 0)
			{
				return true;
			}
			if (!Backpacks.PerformYardSale(Player.m_localPlayer, item, backpackOnly: true))
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "$vapok_mod_yard_sale_blocked", 0, (Sprite)null);
				return false;
			}
			return true;
		}
	}
	internal static class InventoryGuiPatches
	{
		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		private static class InventoryGuiDoCraftingPrefix
		{
			[UsedImplicitly]
			private static void Prefix(InventoryGui __instance)
			{
				AdventureBackpacks.Log.Debug("########################################");
				AdventureBackpacks.Log.Debug("####       DoCrafting.Prefix       #####");
				AdventureBackpacks.Log.Debug("########################################");
				InventoryPatches.IsDoingCrafting = true;
			}

			private static void Postfix(InventoryGui __instance)
			{
				AdventureBackpacks.Log.Debug("########################################");
				AdventureBackpacks.Log.Debug("####       DoCrafting.Postfix      #####");
				AdventureBackpacks.Log.Debug("########################################");
				InventoryPatches.IsDoingCrafting = false;
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Player localPlayer = Player.m_localPlayer;
				if (__instance.m_craftUpgradeItem == null || !__instance.m_craftUpgradeItem.IsBackpack())
				{
					return;
				}
				AdventureBackpacks.Log.Debug("Item: " + __instance.m_craftUpgradeItem.m_shared.m_name + " ");
				BackpackComponent backpackComponent = __instance.m_craftUpgradeItem.Data().Get<BackpackComponent>();
				AdventureBackpacks.Log.Debug("Backpack: " + __instance.m_craftUpgradeItem.m_shared.m_name + " ");
				if (backpackComponent != null)
				{
					backpackComponent?.Load();
					if (localPlayer.IsThisBackpackEquipped(backpackComponent.Item))
					{
						Container backpackContainer = ((Component)localPlayer).gameObject.GetComponent<Container>();
						backpackComponent?.UpdateContainerSizing(ref backpackContainer);
					}
					((Humanoid)localPlayer).UpdateEquipmentStatusEffects();
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
		private static class InventoryGuiOnSelectedItem
		{
			[UsedImplicitly]
			private static Exception Finalizer(Exception __exception, InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod, InventoryGui __instance)
			{
				if (__exception != null)
				{
					if (__exception is NullReferenceException && (Object)(object)__instance != (Object)null && (Object)(object)__instance.m_currentContainer == (Object)null && (Object)(object)grid != (Object)null && grid.GetInventory() != null && (Object)(object)Player.m_localPlayer != (Object)null && item != null && item.m_shared != null && Backpacks.BackpackTypes.Contains(item.m_shared.m_name))
					{
						((Humanoid)Player.m_localPlayer).DropItem(((Humanoid)Player.m_localPlayer).GetInventory(), item, 1);
						BackpackIsOpen = false;
						__instance.Hide();
						((Character)Player.m_localPlayer).Message((MessageType)1, "$vapok_mod_you_droped_bag", 0, (Sprite)null);
						return null;
					}
					AdventureBackpacks.Log.Warning("The following error was captured by Adventure Backpacks, but was caused by another mod. Advanced Backpacks is going to allow the operation to continue, but is going to replay the error below:");
					AdventureBackpacks.Log.Error("External Mod Error Message: " + __exception.Message);
					AdventureBackpacks.Log.Error("External Mod Error Source: " + __exception.Source);
					AdventureBackpacks.Log.Error("External Mod Error Stack Trace: " + __exception.StackTrace);
					AdventureBackpacks.Log.Warning("Please check with other mod authors listed above.");
				}
				return null;
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "Update")]
		private static class InventoryGuiUpdateTranspiler
		{
			[UsedImplicitly]
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator ilGenerator)
			{
				List<CodeInstruction> instrs = instructions.ToList();
				int counter = 0;
				bool patchedHideBackpackMethod = false;
				bool patchedShowBackpackMethod = false;
				bool patchedDetectInputHideMethod = false;
				bool patchedDetectInputShowMethod = false;
				MethodInfo resetButtonStatus = AccessTools.DeclaredMethod(typeof(ZInput), "ResetButtonStatus", (Type[])null, (Type[])null);
				AccessTools.DeclaredMethod(typeof(Menu), "IsVisible", (Type[])null, (Type[])null);
				MethodInfo hideMethod = AccessTools.DeclaredMethod(typeof(InventoryGui), "Hide", (Type[])null, (Type[])null);
				MethodInfo showMethod = AccessTools.DeclaredMethod(typeof(InventoryGui), "Show", (Type[])null, (Type[])null);
				MethodInfo tutorialMethod = AccessTools.DeclaredMethod(typeof(Player), "ShowTutorial", (Type[])null, (Type[])null);
				MethodInfo zInputKeyDown = AccessTools.DeclaredMethod(typeof(ZInput), "GetKeyDown", new Type[2]
				{
					typeof(KeyCode),
					typeof(bool)
				}, (Type[])null);
				MethodInfo zInputButtonDown = AccessTools.DeclaredMethod(typeof(ZInput), "GetButtonDown", new Type[1] { typeof(string) }, (Type[])null);
				int i = 0;
				while (i < instrs.Count)
				{
					if (i > 6 && instrs[i].opcode == OpCodes.Call && instrs[i].operand.Equals(resetButtonStatus) && instrs[i + 1].opcode == OpCodes.Ldarg_0 && instrs[i + 2].opcode == OpCodes.Call && instrs[i + 2].operand.Equals(hideMethod))
					{
						CodeInstruction ldArgInstruction = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
						if (instrs[i].labels.Count > 0)
						{
							CodeInstructionExtensions.MoveLabelsTo(instrs[i], ldArgInstruction);
						}
						yield return LogMessage(instrs[i]);
						counter++;
						yield return LogMessage(ldArgInstruction);
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(InventoryGuiPatches), "HideBackpack", (Type[])null, (Type[])null)));
						counter++;
						patchedHideBackpackMethod = true;
					}
					else if (i > 6 && ((instrs[i].opcode == OpCodes.Call && instrs[i].operand.Equals(showMethod) && instrs[i - 1].opcode == OpCodes.Ldc_I4_1 && instrs[i - 2].opcode == OpCodes.Ldnull && instrs[i - 3].opcode == OpCodes.Ldarg_0) || (instrs[i - 4].opcode == OpCodes.Callvirt && instrs[i - 4].operand.Equals(tutorialMethod))))
					{
						CodeInstruction ldArgInstruction = new CodeInstruction(OpCodes.Ldloc_1, (object)null);
						if (instrs[i].labels.Count > 0)
						{
							CodeInstructionExtensions.MoveLabelsTo(instrs[i], ldArgInstruction);
						}
						yield return LogMessage(instrs[i]);
						counter++;
						yield return LogMessage(ldArgInstruction);
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(InventoryGuiPatches), "ShowBackpack", (Type[])null, (Type[])null)));
						counter++;
						patchedShowBackpackMethod = true;
					}
					else if (i > 6 && instrs[i].opcode == OpCodes.Call && instrs[i].operand.Equals(zInputKeyDown) && instrs[i - 1].opcode == OpCodes.Ldc_I4_1 && instrs[i - 2].opcode == OpCodes.Ldc_I4_S && instrs[i - 2].operand.Equals((sbyte)27) && instrs[i + 2].opcode == OpCodes.Ldstr && instrs[i + 2].operand.Equals("Use"))
					{
						yield return LogMessage(instrs[i]);
						counter++;
						yield return LogMessage(instrs[i + 1]);
						counter++;
						Label label = (Label)instrs[i + 1].operand;
						CodeInstruction val = FindInstructionWithLabel(instrs, i + 2, label);
						if (val == null)
						{
							AdventureBackpacks.Log.Error($"Can't Find Instruction with Label {label}");
						}
						else
						{
							i++;
							Label detectHideLabel = ilGenerator.DefineLabel();
							val.labels.Add(detectHideLabel);
							yield return LogMessage(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
							counter++;
							yield return LogMessage(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
							counter++;
							yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(InventoryGuiPatches), "DetectInputToHide", (Type[])null, (Type[])null)));
							counter++;
							yield return LogMessage(new CodeInstruction(OpCodes.Brtrue, (object)detectHideLabel));
							counter++;
							patchedDetectInputHideMethod = true;
						}
					}
					else if (i > 6 && instrs[i].opcode == OpCodes.Call && instrs[i].operand.Equals(zInputButtonDown) && instrs[i - 1].operand.Equals("Inventory") && instrs[i + 1].opcode == OpCodes.Brtrue && instrs[i + 2].opcode == OpCodes.Ldstr && instrs[i + 2].operand.Equals("JoyButtonY"))
					{
						yield return LogMessage(instrs[i]);
						counter++;
						yield return LogMessage(instrs[i + 1]);
						counter++;
						Label label2 = (Label)instrs[i + 1].operand;
						CodeInstruction val2 = FindInstructionWithLabel(instrs, i + 2, label2);
						if (val2 == null)
						{
							AdventureBackpacks.Log.Error($"Can't Find Instruction with Label {label2}");
						}
						else
						{
							i++;
							Label detectHideLabel = ilGenerator.DefineLabel();
							val2.labels.Add(detectHideLabel);
							yield return LogMessage(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
							counter++;
							yield return LogMessage(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
							counter++;
							yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(InventoryGuiPatches), "DetectInputToShow", (Type[])null, (Type[])null)));
							counter++;
							yield return LogMessage(new CodeInstruction(OpCodes.Brtrue, (object)detectHideLabel));
							counter++;
							patchedDetectInputShowMethod = true;
						}
					}
					else
					{
						yield return LogMessage(instrs[i]);
						counter++;
					}
					int num = i + 1;
					i = num;
				}
				if (!patchedHideBackpackMethod || !patchedShowBackpackMethod || !patchedDetectInputHideMethod || !patchedDetectInputShowMethod)
				{
					AdventureBackpacks.Log.Error("InventoryGui.Update Transpiler Failed To Patch");
					AdventureBackpacks.Log.Warning($" patchedHideBackpackMethod {patchedHideBackpackMethod}");
					AdventureBackpacks.Log.Warning($" patchedShowBackpackMethod {patchedShowBackpackMethod}");
					AdventureBackpacks.Log.Warning($" patchedDetectInputHideMethod {patchedDetectInputHideMethod}");
					AdventureBackpacks.Log.Warning($" patchedDetectInputShowMethod {patchedDetectInputShowMethod}");
					AdventureBackpacks.Log.Error("Please inform Mod Author.");
					Thread.Sleep(5000);
				}
				static CodeInstruction FindInstructionWithLabel(List<CodeInstruction> codeInstructions, int index, Label label3)
				{
					if (index >= codeInstructions.Count)
					{
						return null;
					}
					if (codeInstructions[index].labels.Contains(label3))
					{
						return codeInstructions[index];
					}
					return FindInstructionWithLabel(codeInstructions, index + 1, label3);
				}
				CodeInstruction LogMessage(CodeInstruction instruction)
				{
					AdventureBackpacks.Log.Debug($"IL_{counter}: Opcode: {instruction.opcode} Operand: {instruction.operand}");
					return instruction;
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGui), "SetupRequirement")]
		private static class InventoryGuiSetupRequirementPatch
		{
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				bool patchedSuccess = false;
				List<CodeInstruction> instrs = instructions.ToList();
				int counter = 0;
				CodeInstruction ldArgInstruction = new CodeInstruction(OpCodes.Ldarg_2, (object)null);
				MethodInfo countItemsMethod = AccessTools.DeclaredMethod(typeof(Inventory), "CountItems", new Type[3]
				{
					typeof(string),
					typeof(int),
					typeof(bool)
				}, (Type[])null);
				int i = 0;
				while (i < instrs.Count)
				{
					yield return LogMessage(instrs[i]);
					counter++;
					if (i > 5 && instrs[i - 1].opcode == OpCodes.Callvirt && instrs[i - 1].operand.Equals(countItemsMethod) && instrs[i].opcode == OpCodes.Stloc_S)
					{
						if (instrs[i].labels.Count > 0)
						{
							CodeInstructionExtensions.MoveLabelsTo(instrs[i], ldArgInstruction);
						}
						yield return LogMessage(ldArgInstruction);
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldarg_1, (object)null));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldloc_S, instrs[i].operand));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PlayerPatches), "AdjustCountIfEquipped", (Type[])null, (Type[])null)));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Stloc_S, instrs[i].operand));
						counter++;
						patchedSuccess = true;
					}
					int num = i + 1;
					i = num;
				}
				if (!patchedSuccess)
				{
					AdventureBackpacks.Log.Error("InventoryGui.SetupRequirement Transpiler Failed To Patch");
					Thread.Sleep(5000);
				}
				CodeInstruction LogMessage(CodeInstruction instruction)
				{
					AdventureBackpacks.Log.Debug($"IL_{counter}: Opcode: {instruction.opcode} Operand: {instruction.operand}");
					return instruction;
				}
			}
		}

		public static bool BackpackIsOpen;

		public static bool BackpackEquipped;

		private static bool _showBackpack;

		public static bool CheckForTextInput()
		{
			return TextInput.IsVisible();
		}

		public static void ShowBackpack(Player player, InventoryGui instance)
		{
			if (ConfigRegistry.OpenWithInventory.Value && !BackpackIsOpen && player.CanOpenBackpack())
			{
				_showBackpack = true;
			}
			if (_showBackpack)
			{
				if (!BackpackIsOpen && (Object)(object)instance.m_currentContainer != (Object)null)
				{
					instance.m_currentContainer.SetInUse(false);
					instance.m_currentContainer = null;
				}
				_showBackpack = false;
				player.OpenBackpack(instance);
			}
		}

		public static void HideBackpack(InventoryGui instance)
		{
			if (BackpackIsOpen)
			{
				instance.CloseContainer();
				BackpackIsOpen = false;
				if (ConfigRegistry.CloseInventory.Value && !ConfigRegistry.OpenWithHoverInteract.Value)
				{
					instance.Hide();
				}
			}
		}

		public static bool DetectInputToHide(Player player, InventoryGui instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = ConfigRegistry.HotKeyOpen.Value;
			bool keyDown = ZInput.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey, true);
			bool flag = ConfigRegistry.CloseInventory.Value && keyDown && !ConfigRegistry.OpenWithHoverInteract.Value;
			int num;
			if (ConfigRegistry.OutwardMode.Value)
			{
				value = ConfigRegistry.HotKeyDrop.Value;
				num = (ZInput.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey, true) ? 1 : 0);
			}
			else
			{
				num = 0;
			}
			bool flag2 = (byte)num != 0;
			bool flag3 = keyDown && !BackpackIsOpen && player.CanOpenBackpack() && !ConfigRegistry.OpenWithHoverInteract.Value;
			List<InventoryGrid> list = new List<InventoryGrid>();
			list.AddRange(((Component)instance.m_player).GetComponentsInChildren<InventoryGrid>());
			if (keyDown && !BackpackIsOpen && ConfigRegistry.OpenWithHoverInteract.Value && !CheckForTextInput())
			{
				ItemData val = null;
				foreach (InventoryGrid item in list)
				{
					if (item.GetHoveredElement() != null)
					{
						Element hoveredElement = item.GetHoveredElement();
						val = item.GetInventory().GetItemAt(hoveredElement.m_pos.x, hoveredElement.m_pos.y);
					}
				}
				if (ZInput.IsGamepadActive() && val == null)
				{
					foreach (InventoryGrid item2 in list)
					{
						if (item2.GetGamepadSelectedItem() != null)
						{
							val = item2.GetGamepadSelectedItem();
						}
					}
				}
				if (val != null && val.IsBackpack() && val.m_equipped && !BackpackIsOpen && player.CanOpenBackpack())
				{
					flag3 = true;
				}
			}
			if (flag3 & !CheckForTextInput())
			{
				if ((Object)(object)instance.m_currentContainer != (Object)null)
				{
					instance.m_currentContainer.SetInUse(false);
					instance.m_currentContainer = null;
				}
				player.OpenBackpack(instance);
				return false;
			}
			if (keyDown && BackpackIsOpen && (!flag || ConfigRegistry.OpenWithHoverInteract.Value) && !CheckForTextInput())
			{
				bool flag4 = false;
				if (ConfigRegistry.OpenWithHoverInteract.Value)
				{
					ItemData val2 = null;
					foreach (InventoryGrid item3 in list)
					{
						if (item3.GetHoveredElement() != null)
						{
							Element hoveredElement2 = item3.GetHoveredElement();
							val2 = item3.GetInventory().GetItemAt(hoveredElement2.m_pos.x, hoveredElement2.m_pos.y);
						}
					}
					if (ZInput.IsGamepadActive() && val2 == null)
					{
						foreach (InventoryGrid item4 in list)
						{
							if (item4.GetGamepadSelectedItem() != null)
							{
								val2 = item4.GetGamepadSelectedItem();
							}
						}
					}
					if (val2 != null && val2.IsBackpack() && val2.m_equipped && BackpackIsOpen)
					{
						flag4 = true;
					}
				}
				else
				{
					flag4 = true;
				}
				if (flag4)
				{
					instance.CloseContainer();
					BackpackIsOpen = false;
					return false;
				}
			}
			if (flag2 && !CheckForTextInput())
			{
				player.QuickDropBackpack();
			}
			if (flag || flag2)
			{
				return !CheckForTextInput();
			}
			return false;
		}

		public static bool DetectInputToShow(Player player, InventoryGui instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = ConfigRegistry.HotKeyOpen.Value;
			bool keyDown = ZInput.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey, true);
			if (ConfigRegistry.OutwardMode.Value)
			{
				value = ConfigRegistry.HotKeyDrop.Value;
				if (ZInput.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey, true) && !CheckForTextInput())
				{
					player.QuickDropBackpack();
				}
			}
			if (keyDown && !ConfigRegistry.OpenWithHoverInteract.Value && !BackpackIsOpen && player.CanOpenBackpack() && !CheckForTextInput())
			{
				_showBackpack = true;
			}
			if (_showBackpack)
			{
				return !CheckForTextInput();
			}
			return false;
		}
	}
	public class ItemDropPatches
	{
		[HarmonyPatch(typeof(ItemData), "GetWeight")]
		private static class ItemDataGetWeightTranspiler
		{
			public static float OverrideBackpackWeight(ItemData item, float originalWeight)
			{
				//IL_0041: 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_0050: Unknown result type (might be due to invalid IL or missing references)
				float num = originalWeight;
				if (!string.IsNullOrEmpty(item.m_shared.m_name) && item.TryGetBackpackItem(out var backpack))
				{
					BackpackComponent orCreate = item.Data().GetOrCreate<BackpackComponent>();
					Vector2i inventorySize = backpack.GetInventorySize(orCreate.Item.m_quality);
					if (!orCreate.IsEmptyingBackpack && orCreate.InventoryNeedsValidating(inventorySize))
					{
						AdventureBackpacks.Log.Debug("[GetWeight() - Item Name: " + item.m_shared.m_name);
						AdventureBackpacks.Log.Debug("[GetWeight() - Backpack Item: " + orCreate.Item.m_shared.m_name);
						AdventureBackpacks.Log.Debug("[GetWeight() - Backpack: " + backpack.ItemName);
						Backpacks.ValidateBackpackInventorySizing(Player.m_localPlayer, orCreate.Item);
					}
					Inventory inventory = orCreate.GetInventory();
					float num2 = ((inventory != null) ? inventory.GetTotalWeight() : 0f);
					num += num2 * backpack.WeightMultiplier.Value;
				}
				return num;
			}

			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				bool patchedSuccess = false;
				List<CodeInstruction> instrs = instructions.ToList();
				int counter = 0;
				FieldInfo scaleWeightByQualityField = AccessTools.DeclaredField(typeof(SharedData), "m_scaleWeightByQuality");
				int i = 0;
				while (i < instrs.Count)
				{
					if (i > 6 && instrs[i].opcode == OpCodes.Ldloc_1 && instrs[i - 1].opcode == OpCodes.Stloc_1 && instrs[i - 2].opcode == OpCodes.Add && instrs[i - 3].opcode == OpCodes.Mul && instrs[i - 4].opcode == OpCodes.Ldfld && instrs[i - 4].operand.Equals(scaleWeightByQualityField))
					{
						CodeInstruction val = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
						if (instrs[i].labels.Count > 0)
						{
							CodeInstructionExtensions.MoveLabelsTo(instrs[i], val);
						}
						yield return LogMessage(val);
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemDataGetWeightTranspiler), "OverrideBackpackWeight", (Type[])null, (Type[])null)));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Stloc_1, (object)null));
						counter++;
						yield return LogMessage(instrs[i]);
						counter++;
						patchedSuccess = true;
					}
					else
					{
						yield return LogMessage(instrs[i]);
						counter++;
					}
					int num = i + 1;
					i = num;
				}
				if (!patchedSuccess)
				{
					AdventureBackpacks.Log.Error("GetWeight Transpiler Failed To Patch");
					Thread.Sleep(5000);
				}
				CodeInstruction LogMessage(CodeInstruction instruction)
				{
					AdventureBackpacks.Log.Debug($"IL_{counter}: Opcode: {instruction.opcode} Operand: {instruction.operand}");
					return instruction;
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetIcon")]
		private static class ItemDataGetIconHdBackpack
		{
			private static bool Prefix(ItemData __instance, ref Sprite __result)
			{
				if (IronBackpackIconFix.IsIronHdBackpack(__instance))
				{
					Sprite orCreateIcon = IronBackpackIconFix.GetOrCreateIcon();
					if ((Object)(object)orCreateIcon != (Object)null)
					{
						__result = orCreateIcon;
						IronBackpackIconFix.NotifyGetIconOverride(__instance);
						return false;
					}
					return true;
				}
				if (!SilverBackpackIconFix.IsSilverHdBackpack(__instance))
				{
					return true;
				}
				Sprite orCreateIcon2 = SilverBackpackIconFix.GetOrCreateIcon();
				if ((Object)(object)orCreateIcon2 == (Object)null)
				{
					return true;
				}
				__result = orCreateIcon2;
				SilverBackpackIconFix.NotifyGetIconOverride(__instance);
				return false;
			}
		}
	}
	public class PlayerPatches
	{
		[HarmonyPatch(typeof(Player), "Awake")]
		private static class PlayerAwakePatch
		{
			private static void Postfix(Player __instance)
			{
				((Component)__instance).gameObject.AddComponent<Container>();
			}
		}

		[HarmonyPatch(typeof(Player), "HaveRequirementItems")]
		private static class PlayerHaveRequirementItemsPatch
		{
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator ilGenerator)
			{
				bool patchedSuccess = false;
				List<CodeInstruction> instrs = instructions.ToList();
				int counter = 0;
				CodeInstruction ldArgInstruction = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
				AccessTools.DeclaredMethod(typeof(Inventory), "CountItems", new Type[3]
				{
					typeof(string),
					typeof(int),
					typeof(bool)
				}, (Type[])null);
				int i = 0;
				while (i < instrs.Count)
				{
					if (i > 5 && instrs[i].opcode == OpCodes.Stloc_S && instrs[i + 1].opcode == OpCodes.Ldloc_S && instrs[i + 2].opcode == OpCodes.Ldloc_S && instrs[i - 1].opcode == OpCodes.Callvirt)
					{
						if (instrs[i].labels.Count > 0)
						{
							CodeInstructionExtensions.MoveLabelsTo(instrs[i], ldArgInstruction);
						}
						yield return LogMessage(instrs[i]);
						counter++;
						yield return LogMessage(ldArgInstruction);
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldloc_2, (object)null));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldloc_S, instrs[i].operand));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PlayerPatches), "AdjustCountIfEquipped", (Type[])null, (Type[])null)));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Stloc_S, instrs[i].operand));
						counter++;
						patchedSuccess = true;
					}
					else
					{
						yield return LogMessage(instrs[i]);
						counter++;
					}
					int num = i + 1;
					i = num;
				}
				if (!patchedSuccess)
				{
					AdventureBackpacks.Log.Error("HaveRequirementItems Transpiler Failed To Patch");
					Thread.Sleep(5000);
				}
				CodeInstruction LogMessage(CodeInstruction instruction)
				{
					AdventureBackpacks.Log.Debug($"IL_{counter}: Opcode: {instruction.opcode} Operand: {instruction.operand}");
					return instruction;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "ConsumeResources")]
		private static class PlayerConsumeResourcesPatch
		{
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				bool patchedSuccess = false;
				List<CodeInstruction> instrs = instructions.ToList();
				int counter = 0;
				CodeInstruction ldArgInstruction = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
				MethodInfo getAmountMethod = AccessTools.DeclaredMethod(typeof(Requirement), "GetAmount", new Type[1] { typeof(int) }, (Type[])null);
				int i = 0;
				while (i < instrs.Count)
				{
					yield return LogMessage(instrs[i]);
					counter++;
					if (i > 5 && instrs[i].opcode == OpCodes.Stloc_3 && instrs[i - 1].opcode == OpCodes.Mul && instrs[i - 2].opcode == OpCodes.Ldarg_S && instrs[i - 3].opcode == OpCodes.Callvirt && instrs[i - 3].operand.Equals(getAmountMethod))
					{
						if (instrs[i].labels.Count > 0)
						{
							CodeInstructionExtensions.MoveLabelsTo(instrs[i], ldArgInstruction);
						}
						yield return LogMessage(ldArgInstruction);
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldloc_2, (object)null));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PlayerPatches), "ConsumeUnEquippedItems", (Type[])null, (Type[])null)));
						counter++;
						yield return LogMessage(new CodeInstruction(OpCodes.Stloc_3, (object)null));
						counter++;
						patchedSuccess = true;
					}
					int num = i + 1;
					i = num;
				}
				if (!patchedSuccess)
				{
					AdventureBackpacks.Log.Error("ConsumeResources Transpiler Failed To Patch");
					Thread.Sleep(5000);
				}
				CodeInstruction LogMessage(CodeInstruction instruction)
				{
					AdventureBackpacks.Log.Debug($"IL_{counter}: Opcode: {instruction.opcode} Operand: {instruction.operand}");
					return instruction;
				}
			}
		}

		public static int AdjustCountIfEquipped(Player player, Requirement resource, int itemCount)
		{
			int num = itemCount;
			if (num < 1 || !resource.m_resItem.m_itemData.IsEquipable())
			{
				return num;
			}
			Inventory val = ((player != null) ? ((Humanoid)player).GetInventory() : null);
			if (val == null)
			{
				return num;
			}
			string itemName = resource.m_resItem.m_itemData.m_shared.m_name;
			if (val.GetEquippedItems().Any((ItemData x) => x.m_shared.m_name.Equals(itemName)))
			{
				num--;
			}
			return num;
		}

		public static int ConsumeUnEquippedItems(Player player, Requirement resource, int amount)
		{
			if (amount < 1 || !resource.m_resItem.m_itemData.IsEquipable())
			{
				return amount;
			}
			string itemName = resource.m_resItem.m_itemData.m_shared.m_name;
			List<ItemData> list = (from x in ((Humanoid)player).m_inventory.GetAllItems()
				where x.m_shared.m_name.Equals(itemName)
				select x).ToList();
			int num = 0;
			for (int num2 = 0; num2 < amount; num2++)
			{
				foreach (ItemData item in list)
				{
					if (!item.m_equipped && num < amount)
					{
						((Humanoid)player).m_inventory.RemoveItem(item, 1);
						num++;
					}
				}
			}
			return amount - num;
		}
	}
	public static class SEManPatches
	{
		[HarmonyPatch(typeof(SEMan), "RemoveStatusEffect", new Type[]
		{
			typeof(int),
			typeof(bool)
		})]
		public static class RemoveStatusEffects
		{
			[UsedImplicitly]
			[HarmonyPriority(800)]
			public static bool Prefix(int nameHash, ref bool __result)
			{
				if (EquipmentEffectCache.ActiveEffects == null)
				{
					return true;
				}
				if (EquipmentEffectCache.ActiveEffects.Any((StatusEffect x) => x.NameHash().Equals(nameHash)))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}
	}
	public static class ItemStandStandPatches
	{
		[HarmonyPatch(typeof(ItemStand), "UpdateAttach")]
		private static class ItemStandUpdateAttachPatch
		{
			private static void Prefix(ItemStand __instance)
			{
				AdventureBackpacks.BypassMoveProtection = true;
			}

			private static void Postfix(ItemStand __instance)
			{
				AdventureBackpacks.BypassMoveProtection = false;
			}
		}
	}
	public class InventoryGridPatches
	{
		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		public static class UpdateGuiPatch
		{
			[UsedImplicitly]
			[HarmonyPriority(800)]
			public static bool Prefix(InventoryGrid __instance)
			{
				if (!((Object)__instance).name.Equals("ContainerGrid"))
				{
					return true;
				}
				if (__instance.m_elements.Count >= __instance.m_inventory.m_inventory.Count)
				{
					return true;
				}
				if (__instance.m_width != __instance.m_inventory.m_width || __instance.m_height != __instance.m_inventory.m_height)
				{
					return true;
				}
				__instance.m_width = __instance.m_inventory.m_width + 1;
				__instance.m_height = __instance.m_inventory.m_height + 1;
				return true;
			}
		}
	}
}
namespace AdventureBackpacks.Features
{
	public static class EquipmentEffectCache
	{
		public static HashSet<StatusEffect> ActiveEffects = new HashSet<StatusEffect>();

		public static HashSet<StatusEffect> AddActiveBackpackEffects(HashSet<StatusEffect> other, Humanoid instance)
		{
			if (other == null)
			{
				AdventureBackpacks.Log.Debug("other HashSet argument is null. Expecting initialized object.");
				other = new HashSet<StatusEffect>();
			}
			Player val = (Player)(object)((instance is Player) ? instance : null);
			if (val != null && (Object)(object)val == (Object)(object)Player.m_localPlayer)
			{
				ActiveEffects = new HashSet<StatusEffect>();
				foreach (KeyValuePair<BackpackEffect, EffectsBase> effect in EffectsFactory.EffectList)
				{
					if (effect.Value.HasActiveStatusEffect((Humanoid)(object)val, out var statusEffect))
					{
						ActiveEffects.Add(statusEffect);
					}
				}
				other.UnionWith(ActiveEffects);
				AdventureBackpacks.Log.Debug($"Adding {other.Count} Active Backpack Effects.");
			}
			return other;
		}
	}
	public static class QuickTransfer
	{
		[HarmonyPatch(typeof(InventoryGui), "OnRightClickItem")]
		[HarmonyPriority(800)]
		private static class OnRightClickItemPatch
		{
			private static void Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item)
			{
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected I4, but got Unknown
				if (!FeatureInitialized || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)__instance == (Object)null || item == null || (Object)(object)__instance.m_currentContainer == (Object)null || !__instance.IsContainerOpen() || !EnableQuickTransfer.Value)
				{
					return;
				}
				if (Chainloader.PluginInfos.ContainsKey("blumaye.quicktransfer"))
				{
					AdventureBackpacks.Log.Warning("blumaye.quicktransfer mod is enabled. Adventure Backpack's Quick Transfer disabled.");
				}
				else
				{
					if (item.m_equipped)
					{
						return;
					}
					if (item.IsEquipable() && grid.m_inventory == ((Humanoid)Player.m_localPlayer).GetInventory())
					{
						ItemType itemType = item.m_shared.m_itemType;
						switch (itemType - 3)
						{
						case 3:
							if (((Humanoid)Player.m_localPlayer).m_helmetItem == null)
							{
								return;
							}
							break;
						case 4:
							if (((Humanoid)Player.m_localPlayer).m_chestItem == null)
							{
								return;
							}
							break;
						case 8:
							if (((Humanoid)Player.m_localPlayer).m_legItem == null)
							{
								return;
							}
							break;
						case 0:
						case 1:
						case 11:
							if (((Humanoid)Player.m_localPlayer).m_rightItem == null)
							{
								return;
							}
							break;
						case 14:
							if (((Humanoid)Player.m_localPlayer).m_shoulderItem == null)
							{
								return;
							}
							break;
						case 15:
							if (((Humanoid)Player.m_localPlayer).m_utilityItem == null)
							{
								return;
							}
							break;
						case 2:
							if (((Humanoid)Player.m_localPlayer).m_leftItem == null)
							{
								return;
							}
							break;
						}
					}
					Inventory inventory = __instance.m_currentContainer.GetInventory();
					if (item.IsBackpack() && inventory.IsBackPackInventory())
					{
						return;
					}
					Inventory inventory2 = ((Humanoid)Player.m_localPlayer).GetInventory();
					if (inventory2 != null && inventory != null && !((Object)(object)grid == (Object)null))
					{
						_inventoryGuiInstance = __instance;
						if (grid.m_inventory == inventory)
						{
							_fromInventory = inventory;
							_toInventory = inventory2;
						}
						else
						{
							_fromInventory = inventory2;
							_toInventory = inventory;
						}
						_processingRightClick = true;
					}
				}
			}

			private static void Postfix()
			{
				_processingRightClick = false;
				_toInventory = null;
				_fromInventory = null;
				_inventoryGuiInstance = null;
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UseItem")]
		[HarmonyPriority(800)]
		private static class UseItemPatch
		{
			private static bool Prefix(ItemData item)
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				if (!_processingRightClick)
				{
					return true;
				}
				if (_toInventory == null || _fromInventory == null || (Object)(object)_inventoryGuiInstance == (Object)null || item == null)
				{
					return true;
				}
				_toInventory.MoveItemToThis(_fromInventory, item);
				_inventoryGuiInstance.m_moveItemEffects.Create(((Component)_inventoryGuiInstance).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				return false;
			}
		}

		public static bool FeatureInitialized;

		public static ConfigEntry<bool> EnableQuickTransfer;

		private static InventoryGui _inventoryGuiInstance;

		private static Inventory _fromInventory;

		private static Inventory _toInventory;

		private static bool _processingRightClick;

		static QuickTransfer()
		{
			ConfigRegistry.Waiter.StatusChanged += delegate
			{
				RegisterConfiguraitonFile();
			};
		}

		private static void RegisterConfiguraitonFile()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			ConfigSyncBase.UnsyncedConfig("Local Config", "Enable Quick Right Click Item Transfer", value: false, new ConfigDescription("When enabled, can move items to/from player inventory to container, by right clicking.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = 5
			} }), ref EnableQuickTransfer);
		}
	}
	public static class Utilities
	{
		private const string EmbeddedFolder = "Assets.Bundles";

		public static AssetBundle LoadAssetBundle(string assetBundleFileName, string folderName = "Assets.Bundles")
		{
			AssetBundle val = FindLoadedAssetBundle(assetBundleFileName);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return AssetUtils.LoadAssetBundleFromResources(folderName + "." + assetBundleFileName, typeof(Utilities).Assembly);
		}

		public static AssetBundle FindLoadedAssetBundle(string bundleFileName)
		{
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				if (!((Object)(object)allLoadedAssetBundle == (Object)null) && !string.IsNullOrEmpty(((Object)allLoadedAssetBundle).name) && ((Object)allLoadedAssetBundle).name.IndexOf(bundleFileName, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return allLoadedAssetBundle;
				}
			}
			string probePrefabName = GetProbePrefabName(bundleFileName);
			if (probePrefabName == null)
			{
				return null;
			}
			foreach (AssetBundle allLoadedAssetBundle2 in AssetBundle.GetAllLoadedAssetBundles())
			{
				if (!((Object)(object)allLoadedAssetBundle2 == (Object)null) && ContainsAsset<GameObject>(allLoadedAssetBundle2, probePrefabName))
				{
					return allLoadedAssetBundle2;
				}
			}
			return null;
		}

		private static string GetProbePrefabName(string bundleFileName)
		{
			return bundleFileName switch
			{
				"vapokbackpacks" => "CapeIronBackpack", 
				"backpack_meadows" => "BackpackMeadows", 
				"backpack_black_forest" => "BackpackBlackForest", 
				"backpack_swamp" => "BackpackSwamp", 
				"backpack_mountains" => "BackpackMountains", 
				"backpack_plains" => "BackpackPlains", 
				"backpack_mistlands" => "BackpackMistlands", 
				_ => null, 
			};
		}

		private static bool ContainsAsset<T>(AssetBundle bundle, string assetName) where T : Object
		{
			if ((Object)(object)bundle.LoadAsset<T>(assetName) != (Object)null)
			{
				return true;
			}
			return (Object)(object)bundle.LoadAsset<T>("Assets/vapok/Prefabs/" + assetName + ".prefab") != (Object)null;
		}
	}
}
namespace AdventureBackpacks.Extensions
{
	public static class InventoryExtensions
	{
		public static bool IsBackPackInventory(this Inventory inventory)
		{
			if (inventory != null && !string.IsNullOrEmpty(inventory.m_name))
			{
				return inventory.m_name.Contains("$vapok_mod_level");
			}
			return false;
		}

		public static bool ContainsBackpack(this Inventory inventory, ItemData backpackItem)
		{
			return IsBackpackItemAt(inventory.m_width - 1, inventory.m_height - 1);
			bool IsBackpackItemAt(int x, int y)
			{
				if (x < 0)
				{
					x = inventory.m_width - 1;
					y--;
				}
				if (y < 0)
				{
					return false;
				}
				ItemData itemAt = inventory.GetItemAt(x, y);
				if (itemAt != null && itemAt == backpackItem)
				{
					return true;
				}
				return IsBackpackItemAt(x - 1, y);
			}
		}

		public static bool HasEmptySlot(this Inventory inventory)
		{
			return IsBackpackItemAt(inventory.m_width - 1, inventory.m_height - 1);
			bool IsBackpackItemAt(int x, int y)
			{
				if (x < 0)
				{
					x = inventory.m_width - 1;
					y--;
				}
				if (y < 0)
				{
					return false;
				}
				if (inventory.GetItemAt(x, y) == null)
				{
					return true;
				}
				return IsBackpackItemAt(x - 1, y);
			}
		}

		public static ItemData FindNonBackpackItem(this Inventory inventory)
		{
			return GetNonBackpackItem(inventory.m_width - 1, inventory.m_height - 1);
			ItemData GetNonBackpackItem(int x, int y)
			{
				if (x < 0)
				{
					x = inventory.m_width - 1;
					y--;
				}
				if (y < 0)
				{
					return null;
				}
				ItemData val = inventory.GetItemAt(x, y);
				if (val != null && val.IsBackpack())
				{
					val = GetNonBackpackItem(x - 1, y);
				}
				return val;
			}
		}
	}
	public static class ItemDataExtensions
	{
		public static bool IsBackpack(this ItemData item)
		{
			return Backpacks.BackpackTypes.Contains(item.m_shared.m_name);
		}
	}
	public static class PlayerExtensions
	{
		public static bool IsBackpackEquipped(this Player player)
		{
			if ((Object)(object)player == (Object)null || ((Humanoid)player).GetInventory() == null)
			{
				return false;
			}
			if (((Humanoid)player).m_shoulderItem == null)
			{
				return false;
			}
			return ((Humanoid)player).m_shoulderItem.IsBackpack();
		}

		public static bool IsThisBackpackEquipped(this Player player, ItemData itemData)
		{
			if ((Object)(object)player == (Object)null || ((Humanoid)player).GetInventory() == null)
			{
				return false;
			}
			if (((Humanoid)player).m_shoulderItem == null)
			{
				return false;
			}
			if (!((Humanoid)player).m_shoulderItem.IsBackpack())
			{
				return false;
			}
			return ((object)((Humanoid)player).m_shoulderItem).Equals((object?)itemData);
		}

		public static BackpackComponent GetEquippedBackpack(this Player player)
		{
			if ((Object)(object)player == (Object)null || ((Humanoid)player).GetInventory() == null)
			{
				return null;
			}
			if (((Humanoid)player).m_shoulderItem == null)
			{
				return null;
			}
			if (((Humanoid)player).m_shoulderItem.IsBackpack())
			{
				return ((Humanoid)player).m_shoulderItem.Data().GetOrCreate<BackpackComponent>();
			}
			return null;
		}

		public static bool CanOpenBackpack(this Player player)
		{
			return player.IsBackpackEquipped();
		}

		public static void OpenBackpack(this Player player, InventoryGui instance)
		{
			if (!((Object)(object)player == (Object)null))
			{
				Container backpackContainer = ((Component)player).gameObject.GetComponent<Container>();
				player.GetEquippedBackpack()?.UpdateContainerSizing(ref backpackContainer);
				InventoryGuiPatches.BackpackIsOpen = true;
				instance.Show(backpackContainer, 1);
			}
		}

		public static void QuickDropBackpack(this Player player)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			BackpackComponent equippedBackpack = player.GetEquippedBackpack();
			if (equippedBackpack == null)
			{
				return;
			}
			ItemData val = null;
			bool flag = false;
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (!inventory.ContainsBackpack(equippedBackpack.Item) && !inventory.HasEmptySlot())
			{
				val = inventory.FindNonBackpackItem();
				if (val == null || !inventory.RemoveItem(val))
				{
					((Character)player).Message((MessageType)2, "$vapok_mod_quick_drop_unavailable", 0, (Sprite)null);
					return;
				}
				flag = true;
			}
			AdventureBackpacks.QuickDropping = true;
			AdventureBackpacks.Log.Message("Quick dropping backpack.");
			((Humanoid)player).RemoveEquipAction(equippedBackpack.Item);
			((Humanoid)player).UnequipItem(equippedBackpack.Item, true);
			if (!((Humanoid)player).m_inventory.RemoveItem(equippedBackpack.Item))
			{
				if (flag)
				{
					inventory.AddItem(val);
				}
				AdventureBackpacks.QuickDropping = false;
				((Character)player).Message((MessageType)2, "$vapok_mod_quick_drop_unavailable", 0, (Sprite)null);
				return;
			}
			ItemDrop val2 = ItemDrop.DropItem(equippedBackpack.Item, 1, ((Component)player).transform.position - ((Component)player).transform.forward + ((Component)player).transform.up, ((Component)player).transform.rotation);
			if ((Object)(object)val2 != (Object)null)
			{
				Rigidbody component = ((Component)val2).GetComponent<Rigidbody>();
				if ((Object)(object)component != (Object)null)
				{
					component.linearVelocity = (Vector3.up - ((Component)player).transform.forward) * 5f;
				}
				val2.Save();
			}
			((Humanoid)player).m_dropEffects.Create(((Component)player).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
			if (flag)
			{
				inventory.AddItem(val);
			}
			InventoryGuiPatches.BackpackIsOpen = false;
			AdventureBackpacks.QuickDropping = false;
		}
	}
}
namespace AdventureBackpacks.Configuration
{
	public class ConfigRegistry : ConfigSyncBase
	{
		internal static ConfigEntry<KeyboardShortcut> HotKeyOpen;

		internal static ConfigEntry<KeyboardShortcut> HotKeyDrop;

		internal static ConfigEntry<bool> OpenWithInventory;

		internal static ConfigEntry<bool> OpenWithHoverInteract;

		internal static ConfigEntry<bool> CloseInventory;

		internal static ConfigEntry<bool> OutwardMode;

		internal static ConfigEntry<bool> ReplaceShader;

		public static Waiting Waiter;

		public ConfigRegistry(IPluginInfo mod)
			: base(mod)
		{
			Waiter = new Waiting();
			InitializeConfigurationSettings();
		}

		public sealed override void InitializeConfigurationSettings()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			if (ConfigSyncBase._config != null)
			{
				ConfigSyncBase.UnsyncedConfig("Local Config", "Open Backpack", new KeyboardShortcut((KeyCode)105, Array.Empty<KeyCode>()), new ConfigDescription("Hotkey to open backpack.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
				{
					Order = 3
				} }), ref HotKeyOpen);
				ConfigSyncBase.UnsyncedConfig("Local Config", "Quickdrop Backpack", new KeyboardShortcut((KeyCode)121, Array.Empty<KeyCode>()), new ConfigDescription("Hotkey to quickly drop backpack while on the run.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
				{
					Order = 1
				} }), ref HotKeyDrop);
				ConfigSyncBase.UnsyncedConfig("Local Config", "Open with Inventory", value: false, new ConfigDescription("If enabled, both backpack and inventory will open when Inventory is opened.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
				{
					Order = 3
				} }), ref OpenWithInventory);
				ConfigSyncBase.UnsyncedConfig("Local Config", "Open with Interactive Hover", value: false, new ConfigDescription("If enabled, backpack will only open while hovering over equipped backpack and pressing hotkey.  This option overrides Open with Inventory.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
				{
					Order = 3
				} }), ref OpenWithHoverInteract);
				ConfigSyncBase.UnsyncedConfig("Local Config", "Close Inventory", value: true, new ConfigDescription("If enabled, both backpack and inventory will close with Open Backpack keybind is pressed while Inventory is open.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
				{
					Order = 2
				} }), ref CloseInventory);
				ConfigSyncBase.UnsyncedConfig("Local Config", "Outward Mode", value: false, new ConfigDescription("You can use a hotkey to quickly drop your equipped backpack in order to run faster away from danger.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
				{
					Order = 1
				} }), ref OutwardMode);
				ConfigSyncBase.UnsyncedConfig("Local Config", "Replace Shader", value: true, new ConfigDescription("Toggle To use the Material Shader Replacer (Requires Game Restart)", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
				{
					Order = 1
				} }), ref ReplaceShader);
			}
		}
	}
	public class Waiting
	{
		public event EventHandler StatusChanged;

		public void ConfigurationComplete(bool configDone)
		{
			if (configDone)
			{
				this.StatusChanged?.Invoke(this, EventArgs.Empty);
			}
		}
	}
}
namespace AdventureBackpacks.Components
{
	public class BackpackComponent : CustomItemData
	{
		public static string OldPluginCustomData = "JotunnBackpacks#JotunnBackpacks.BackpackComponent";

		private Inventory _backpackInventory;

		private CustomSE _statusEffects;

		public bool IsLoadingInventory;

		public bool IsEmptyingBackpack;

		private ILogIt _log = AdventureBackpacks.Log;

		public void SetInventory(Inventory inventoryInstance)
		{
			_backpackInventory = inventoryInstance;
			Save(_backpackInventory);
		}

		public bool InventoryNeedsValidating(Vector2i backpackDimension)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (_backpackInventory.m_width == backpackDimension.x)
			{
				return _backpackInventory.m_height != backpackDimension.y;
			}
			return true;
		}

		public Inventory GetInventory()
		{
			return _backpackInventory;
		}

		public void UpdateContainerSizing(ref Container backpackContainer)
		{
			Inventory inventory = GetInventory();
			backpackContainer.m_inventory = inventory;
			backpackContainer.m_width = inventory.m_width;
			backpackContainer.m_height = inventory.m_height;
			backpackContainer.m_bkg = base.Item.m_shared.m_icons[0];
		}

		public string Serialize()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			_log.Debug($"[Serialize() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Starting..");
			ZPackage val = new ZPackage();
			if (_backpackInventory == null)
			{
				_backpackInventory = Backpacks.NewInventoryInstance(base.Item.m_shared.m_name, base.Item.m_quality);
			}
			_backpackInventory.Save(val);
			string result = (base.Value = val.GetBase64());
			_log.Debug($"[Serialize() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Value = {base.Value}");
			return result;
		}

		public void Deserialize(string data)
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			_log.Debug($"[Deserialize() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Starting..");
			try
			{
				string name = base.Item.m_shared.m_name;
				_backpackInventory = Backpacks.NewInventoryInstance(name, base.Item.m_quality);
				_log.Debug($"[Deserialize() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Value Before = {base.Value}");
				_log.Debug($"[Deserialize() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] data = {data}");
				base.Value = data;
				_log.Debug($"[Deserialize() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Value After = {base.Value}");
				ZPackage val = new ZPackage(data);
				_log.Debug($"[Deserialize() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Inventory Count Before Load: {_backpackInventory.m_inventory.Count}");
				_backpackInventory.Load(val);
				_log.Debug($"[Deserialize() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Inventory Count After Load: {_backpackInventory.m_inventory.Count}");
				_statusEffects = Backpacks.UpdateStatusEffects(base.Item);
			}
			catch (Exception arg)
			{
				_log.Error($" - {base.Item.m_shared.m_name} Backpack info is corrupt!\n{arg}");
			}
		}

		public override void FirstLoad()
		{
			string name = base.Item.m_shared.m_name;
			_log.Debug($"[FirstLoad - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] {name}");
			if (!Backpacks.BackpackTypes.Contains(name))
			{
				return;
			}
			if (_backpackInventory == null)
			{
				_backpackInventory = Backpacks.NewInventoryInstance(name, base.Item.m_quality);
				if (!string.IsNullOrEmpty(base.Value))
				{
					Deserialize(base.Value);
				}
				if (base.Item.m_customData.ContainsKey(OldPluginCustomData) && string.IsNullOrEmpty(base.Value))
				{
					string value = base.Item.m_customData[OldPluginCustomData];
					base.Value = value;
					Deserialize(base.Value);
				}
				else
				{
					_log.Debug($"[Load - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Backpack null, creating...");
					Serialize();
				}
			}
			else if (string.IsNullOrEmpty(base.Value))
			{
				Serialize();
			}
		}

		public override void Load()
		{
			_log.Debug($"[Load - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Starting");
			IsLoadingInventory = true;
			if (!string.IsNullOrEmpty(base.Value))
			{
				_log.Debug($"[Load - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Value = {base.Value}");
				Deserialize(base.Value);
			}
			else
			{
				if (_backpackInventory == null)
				{
					_log.Debug($"[Load - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Backpack null, creating...");
					string name = base.Item.m_shared.m_name;
					_backpackInventory = Backpacks.NewInventoryInstance(name, base.Item.m_quality);
				}
				Serialize();
			}
			IsLoadingInventory = false;
		}

		public override void Save()
		{
			if (_backpackInventory == null)
			{
				Serialize();
				return;
			}
			_log.Debug($"[Save() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Starting Value = {base.Value}");
			_log.Debug($"[Save() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Starting backpack count {_backpackInventory.m_inventory.Count}");
			base.Value = Serialize();
			_log.Debug($"[Save() - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Ending backpack count {_backpackInventory.m_inventory.Count}");
		}

		public void Save(Inventory backpack)
		{
			if (backpack == null)
			{
				_log.Warning($"[Save(Inventory) - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Ignoring save: inventory argument was null.");
				return;
			}
			_log.Debug($"[Save(Inventory) - {base.Item.m_shared.m_name}-Q{base.Item.m_quality}] Starting backpack count {backpack.m_inventory.Count}");
			_backpackInventory = backpack;
			Save();
		}

		public CustomItemData Clone()
		{
			return MemberwiseClone() as CustomItemData;
		}
	}
}
namespace AdventureBackpacks.Assets
{
	public static class Backpacks
	{
		private static ILogIt _log = AdventureBackpacks.Log;

		private static List<string> _backpackTypes = new List<string>();

		public static List<string> BackpackTypes => _backpackTypes;

		public static void LoadBackpackTypes(List<string> backpackTypes)
		{
			_backpackTypes = backpackTypes;
		}

		internal static bool TryGetBackpackItem(this ItemData itemData, out BackpackItem backpack)
		{
			backpack = null;
			if (itemData == null)
			{
				return false;
			}
			return TryGetBackpackItemByName(itemData.m_shared.m_name, out backpack);
		}

		internal static bool TryGetBackpackItemByName(string name, out BackpackItem backpack)
		{
			backpack = null;
			if (Utility.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			backpack = BackpackFactory.BackpackItems.FirstOrDefault((BackpackItem x) => x.ItemName.Equals(name));
			return backpack != null;
		}

		public static void UpdateItemDataConfigValues(object sender, EventArgs e)
		{
			Player player;
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && ((Humanoid)Player.m_localPlayer).GetInventory() != null)
			{
				player = Player.m_localPlayer;
				if ((Object)(object)InventoryGui.instance != (Object)null)
				{
					InventoryGui.instance.Hide();
				}
				Inventory inventory = ((Humanoid)Player.m_localPlayer).GetInventory();
				if (inventory != null)
				{
					SearchInventory(inventory.m_inventory);
				}
				List<ItemData> equippedItems = ((Humanoid)Player.m_localPlayer).GetInventory().GetEquippedItems();
				if (equippedItems != null)
				{
					SearchInventory(equippedItems);
				}
				((Humanoid)Player.m_localPlayer).UpdateEquipmentStatusEffects();
			}
			void SearchInventory(List<ItemData> list)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				if (list == null)
				{
					return;
				}
				foreach (ItemData item in list)
				{
					if (item != null && item.IsBackpack() && item.TryGetBackpackItem(out var backpack))
					{
						BackpackComponent orCreate = item.Data().GetOrCreate<BackpackComponent>();
						Vector2i inventorySize = backpack.GetInventorySize(orCreate.Item.m_quality);
						if (orCreate.InventoryNeedsValidating(inventorySize))
						{
							ValidateBackpackInventorySizing(player, item);
						}
					}
				}
			}
		}

		public static Inventory NewInventoryInstance(string name, int itemMQuality = 1)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			string text = $"{name} $vapok_mod_level {itemMQuality}";
			if (!TryGetBackpackItemByName(name, out var backpack))
			{
				return null;
			}
			Vector2i inventorySize = backpack.GetInventorySize(itemMQuality);
			return new Inventory(text, (Sprite)null, inventorySize.x, inventorySize.y);
		}

		public static Vector2 ValidateMinMaxChestSize(float x, float y)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (x < 1f)
			{
				x = 1f;
			}
			if (y < 1f)
			{
				y = 1f;
			}
			return new Vector2(x, y);
		}

		public static void ValidateBackpackInventorySizing(Player player, ItemData currentBackpack)
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || currentBackpack?.m_shared == null)
			{
				return;
			}
			AdventureBackpacks.Log.Debug("############################################");
			AdventureBackpacks.Log.Debug("####  ValidateBackpackInventorySizing  #####");
			AdventureBackpacks.Log.Debug(currentBackpack.m_shared.m_name ?? "");
			AdventureBackpacks.Log.Debug("############################################");
			StackTrace stackTrace = new StackTrace();
			for (int i = 1; i <= 20 && stackTrace.FrameCount >= i; i++)
			{
				MethodBase methodBase = stackTrace.GetFrame(i)?.GetMethod();
				AdventureBackpacks.Log.Debug($"[{i}]Called by: {methodBase?.DeclaringType?.FullName}.{methodBase?.Name}");
			}
			if (!currentBackpack.TryGetBackpackItem(out var backpack))
			{
				return;
			}
			if (!backpack.BackpackSize.TryGetValue(currentBackpack.m_quality, out var value))
			{
				AdventureBackpacks.Log.Warning($"Backpack '{currentBackpack.m_shared.m_name}' has unexpected quality '{currentBackpack.m_quality}'. " + "Falling back to quality 1.");
				value = backpack.BackpackSize[1];
			}
			Vector2 val = ValidateMinMaxChestSize(value.Value.x, value.Value.y);
			int num = (int)Math.Floor(val.x) * (int)Math.Floor(val.y);
			AdventureBackpacks.Log.Debug($"[{currentBackpack.m_shared.m_name}]### Backpack Slot Size: {num}");
			BackpackComponent orCreate = currentBackpack.Data().GetOrCreate<BackpackComponent>();
			Inventory inventory = orCreate.GetInventory();
			if (inventory == null)
			{
				AdventureBackpacks.Log.Warning("[" + currentBackpack.m_shared.m_name + "] ValidateBackpackInventorySizing: backpack inventory was null; skipping.");
				return;
			}
			AdventureBackpacks.Log.Debug($"[{currentBackpack.m_shared.m_name}]### Current Inventory Slot Size: {inventory.m_inventory.Count}");
			if (num < inventory.m_inventory.Count)
			{
				int num2 = inventory.m_inventory.Count - num;
				AdventureBackpacks.Log.Debug($"[{currentBackpack.m_shared.m_name}]### I need to YEET {num2} items");
				PerformYardSale(player, orCreate.Item, backpackOnly: true, num2);
				int count = inventory.m_inventory.Count;
				AdventureBackpacks.Log.Debug($"[{currentBackpack.m_shared.m_name}]### New Inventory Size {count}");
				orCreate.IsLoadingInventory = true;
				Inventory val2 = NewInventoryInstance(backpack.ItemName, currentBackpack.m_quality);
				if (val2 == null)
				{
					AdventureBackpacks.Log.Warning("[" + currentBackpack.m_shared.m_name + "] Could not create resized inventory instance; skipping MoveAll.");
					orCreate.IsLoadingInventory = false;
				}
				else
				{
					val2.MoveAll(inventory);
					orCreate.IsLoadingInventory = false;
					orCreate.Save(val2);
				}
			}
			orCreate.Load();
			if (player.IsThisBackpackEquipped(currentBackpack))
			{
				Container backpackContainer = ((Component)player).gameObject.GetComponent<Container>();
				if ((Object)(object)backpackContainer != (Object)null)
				{
					orCreate.UpdateContainerSizing(ref backpackContainer);
				}
			}
			AdventureBackpacks.Log.Debug("############################################");
			AdventureBackpacks.Log.Debug("DONE  ValidateBackpackInventorySizing  DONE");
			AdventureBackpacks.Log.Debug(currentBackpack.m_shared.m_name ?? "");
			AdventureBackpacks.Log.Debug("############################################");
		}

		public static bool CheckForInception(Inventory instance, ItemData item)
		{
			if (instance.IsBackPackInventory() && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				if (item.TryGetBackpackItem(out var backpack))
				{
					backpack.InceptionCounter++;
					switch (backpack.InceptionCounter)
					{
					case 1:
						((Character)Player.m_localPlayer).Message((MessageType)2, "$vapok_mod_no_inception1", 0, (Sprite)null);
						break;
					case 2:
						((Character)Player.m_localPlayer).Message((MessageType)2, "$vapok_mod_no_inception2", 0, (Sprite)null);
						break;
					case 5:
						((Character)Player.m_localPlayer).Message((MessageType)2, "$vapok_mod_no_inception3", 0, (Sprite)null);
						break;
					case 10:
					{
						((Character)Player.m_localPlayer).Message((MessageType)2, "$vapok_mod_no_inception4", 0, (Sprite)null);
						int num = new Random(42).Next(5000, 20000);
						backpack.YardSaleTimer = new System.Timers.Timer(num);
						backpack.YardSaleTimer.AutoReset = false;
						backpack.YardSaleTimer.Enabled = false;
						backpack.YardSaleTimer.Elapsed += delegate
						{
							YardSaleEvent(backpack);
						};
						backpack.YardSaleTimer.Start();
						break;
					}
					}
					return false;
				}
			}
			return true;
		}

		public static bool PerformYardSale(Player mLocalPlayer, ItemData itemData, bool backpackOnly = false, int numberItems = 0)
		{
			if (!itemData.IsBackpack())
			{
				return true;
			}
			BackpackComponent backpack = itemData.Data().Get<BackpackComponent>();
			if (backpack == null)
			{
				return true;
			}
			bool dropWasBlocked = false;
			EmtpyInventory(backpack.GetInventory());
			if (dropWasBlocked)
			{
				if (!backpackOnly)
				{
					AdventureBackpacks.PerformYardSale = false;
				}
				return false;
			}
			if (!backpackOnly)
			{
				Inventory inventory = ((Humanoid)mLocalPlayer).GetInventory();
				EmtpyInventory(inventory);
				((Humanoid)mLocalPlayer).UnequipAllItems();
				EmtpyInventory(inventory);
				((Character)Player.m_localPlayer).Message((MessageType)2, "$vapok_mod_no_inception5", 0, (Sprite)null);
				AdventureBackpacks.PerformYardSale = false;
			}
			else
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "$vapok_mod_thor_saves_contents", 0, (Sprite)null);
			}
			return true;
			void EmtpyInventory(Inventory val)
			{
				if (backpack.IsEmptyingBackpack)
				{
					return;
				}
				AdventureBackpacks.Log.Debug($"[{itemData.m_shared.m_name}]Number of Items: {numberItems}");
				AdventureBackpacks.Log.Debug($"[{itemData.m_shared.m_name}]Inventory Count: {val.m_inventory.Count}");
				backpack.IsEmptyingBackpack = true;
				try
				{
					if (numberItems == 0)
					{
						while (val.m_inventory.Count > 0 && val.m_inventory.Count != 0 && val.m_inventory[0] != null)
						{
							ItemData val2 = val.m_inventory[0];
							int num = val.CountItems(val2.m_shared.m_name, -1, true);
							int num2 = ((num > val2.m_stack) ? val2.m_stack : num);
							int num3 = val.CountItems(val2.m_shared.m_name, -1, true);
							((Humanoid)mLocalPlayer).DropItem(val, val2, num2);
							if (val.CountItems(val2.m_shared.m_name, -1, true) >= num3)
							{
								AdventureBackpacks.Log.Warning("[" + itemData.m_shared.m_name + "] DropItem did not remove from inventory (another mod may have blocked it). Stopping to avoid duplication.");
								dropWasBlocked = true;
								break;
							}
						}
					}
					else
					{
						for (int i = 0; i < numberItems; i++)
						{
							if (val.m_inventory.Count <= 0)
							{
								break;
							}
							if (val.m_inventory.Count == 0)
							{
								break;
							}
							if (val.m_inventory[0] == null)
							{
								break;
							}
							ItemData val3 = val.m_inventory[0];
							int num4 = val.CountItems(val3.m_shared.m_name, -1, true);
							AdventureBackpacks.Log.Debug($"[{itemData.m_shared.m_name}] Number of {val3.m_shared.m_name}: {num4}");
							AdventureBackpacks.Log.Debug($"[{itemData.m_shared.m_name}] Stack Size of {val3.m_shared.m_name}: {val3.m_stack}");
							int num5 = ((num4 > val3.m_stack) ? val3.m_stack : num4);
							AdventureBackpacks.Log.Debug($"[{itemData.m_shared.m_name}] Drop Amount: {num5}");
							int num6 = val.CountItems(val3.m_shared.m_name, -1, true);
							((Humanoid)mLocalPlayer).DropItem(val, val3, num5);
							if (val.CountItems(val3.m_shared.m_name, -1, true) >= num6)
							{
								AdventureBackpacks.Log.Warning("[" + itemData.m_shared.m_name + "] DropItem did not remove from inventory (another mod may have blocked it). Stopping to avoid duplication.");
								dropWasBlocked = true;
								break;
							}
						}
					}
					AdventureBackpacks.Log.Debug($"[{itemData.m_shared.m_name}] Inventory Count (end): {val.m_inventory.Count}");
				}
				finally
				{
					backpack.IsEmptyingBackpack = false;
				}
			}
		}

		private static void YardSaleEvent(BackpackItem backpack)
		{
			backpack.YardSaleTimer.Stop();
			AdventureBackpacks.PerformYardSale = true;
		}

		public static CustomSE UpdateStatusEffects(ItemData itemData)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: 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)
			if (itemData == null)
			{
				return null;
			}
			if (!itemData.TryGetBackpackItem(out var backpack))
			{
				return null;
			}
			string name = itemData.m_shared.m_name;
			int quality = itemData.m_quality;
			CustomSE customSE = new CustomSE(Enums.StatusEffects.Stats, $"SE_{name}_{quality}");
			string text = $"{name} $vapok_mod_level {quality} $vapok_mod_effect";
			if (backpack.ShowBackpackStatusEffect.Value)
			{
				customSE.Effect.m_name = (string.IsNullOrEmpty(backpack.CustomStatusEffectName.Value) ? text : backpack.CustomStatusEffectName.Value);
				customSE.Effect.m_startMessageType = (MessageType)1;
				customSE.Effect.m_startMessage = "$vapok_mod_useful_backpack";
			}
			List<DamageModPair> list = new List<DamageModPair>();
			itemData.m_shared.m_armor = itemData.m_shared.m_armorPerLevel * (float)quality;
			if (EffectsFactory.EffectList[BackpackEffect.FrostResistance].IsEffectActive(itemData))
			{
				list.Add(FrostResistance.EffectMod);
			}
			if (EffectsFactory.EffectList[BackpackEffect.TrollArmor].HasActiveStatusEffect(itemData, out var statusEffect))
			{
				itemData.m_shared.m_setName = "troll";
				itemData.m_shared.m_setSize = 4;
				itemData.m_shared.m_setStatusEffect = statusEffect;
			}
			else
			{
				itemData.m_shared.m_setName = string.Empty;
				itemData.m_shared.m_setSize = 0;
				itemData.m_shared.m_setStatusEffect = null;
			}
			backpack.UpdateStatusEffects(quality, customSE, list, itemData);
			itemData.m_shared.m_maxDurability = 1000f;
			((SE_Stats)customSE.Effect).m_mods = list;
			if (backpack.ShowBackpackStatusEffect.Value)
			{
				((StatusEffect)(SE_Stats)customSE.Effect).m_icon = itemData.GetIcon();
			}
			itemData.AddSEToItem(customSE);
			return customSE;
		}
	}
}
namespace AdventureBackpacks.Assets.Items
{
	internal interface IAssetItem
	{
		string PrefabName { get; }

		string ItemName { get; }

		Item Item { get; }
	}
	internal abstract class AssetItem : IAssetItem
	{
		private readonly string _assetFolderName = "Assets.Bundles";

		private readonly Item _item;

		public string AssetName { get; }

		public string PrefabName { get; }

		public string ItemName { get; }

		public Item Item => _item;

		internal AssetItem(GameObject goItem, string itemName)
		{
			PrefabName = ((Object)goItem).name;
			ItemName = itemName;
			_item = new Item(goItem)
			{
				Configurable = Configurability.Disabled
			};
			SetupItem();
		}

		internal AssetItem(AssetBundle bundle, string prefabName, string itemName)
		{
			PrefabName = prefabName;
			ItemName = itemName;
			_item = new Item(bundle, prefabName)
			{
				Configurable = Configurability.Disabled
			};
			SetupItem();
		}

		internal AssetItem(string assetName, string prefabName, string itemName)
		{
			AssetName = assetName;
			PrefabName = prefabName;
			ItemName = itemName;
			_item = new Item(AssetName, PrefabName, _assetFolderName)
			{
				Configurable = Configurability.Disabled
			};
			SetupItem();
		}

		private void SetupItem()
		{
			SetPersistence();
			ResetPrefabArmor();
		}

		internal void AssignCraftingTable(ItemManager.CraftingTable craftingTable, int stationLevel)
		{
			_item.Crafting.Add(craftingTable, stationLevel);
		}

		internal void AssignCraftingTable(string craftingTable, int stationLevel)
		{
			if (Enum.TryParse<ItemManager.CraftingTable>(craftingTable, ignoreCase: true, out var result))
			{
				_item.Crafting.Add(result, stationLevel);
			}
			else
			{
				_item.Crafting.Add(craftingTable, stationLevel);
			}
		}

		internal void AddRecipeIngredient(string prefabName, int quantity)
		{
			_item.RequiredItems.Add(prefabName, quantity);
		}

		internal void AddUpgradeIngredient(string prefabName, int quantity)
		{
			_item.RequiredUpgradeItems.Add(prefabName, quantity);
		}

		internal ItemDrop GetItemDrop()
		{
			Item item = _item;
			if (item == null)
			{
				return null;
			}
			return item.Prefab.GetComponent<ItemDrop>();
		}

		internal void RegisterShaderSwap(MaterialReplacer.ShaderType shaderType = MaterialReplacer.ShaderType.PieceShader)
		{
			if (ConfigRegistry.ReplaceShader.Value)
			{
				MaterialReplacer.RegisterGameObjectForShaderSwap(_item.Prefab, shaderType);
			}
		}

		internal void SetPersistence()
		{
			_item.Prefab.GetComponent<ZNetView>().m_persistent = true;
		}

		internal void ResetPrefabArmor()
		{
			ItemDrop itemDrop = GetItemDrop();
			ItemData itemData = itemDrop.m_itemData;
			if (itemData != null)
			{
				itemDrop.m_autoPickup = true;
				itemData.m_shared.m_armor = itemData.m_shared.m_armorPerLevel;
				itemDrop.Save();
			}
		}
	}
	internal static class IronBackpackIconFix
	{
		internal const string IconTextureName = "IronBackpack_Icon";

		private const string EmbeddedPngSuffix = "Icons.IronBackpack_Icon.png";

		private static readonly string[] TargetPrefabNames = new string[2] { "BackpackBlackForest", "CapeIronBackpack" };

		private static readonly string[] ItemNameTokens = new string[2] { "vapok_mod_item_backpack_blackforest", "vapok_mod_item_rugged_backpack" };

		private static Sprite _cachedIcon;

		private static bool _loggedFailure;

		private static bool _loggedGetIcon;

		internal static bool IsIronHdBackpack(SharedData shared)
		{
			if (shared == null || shared.m_name == null)
			{
				return false;
			}
			string[] itemNameTokens = ItemNameTokens;
			foreach (string value in itemNameTokens)
			{
				if (shared.m_name.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsIronHdBackpack(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			if (IsIronHdBackpack(item.m_shared))
			{
				return true;
			}
			if (item.TryGetBackpackItem(out var backpack) && IsTargetPrefab(backpack.PrefabName))
			{
				return true;
			}
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return false;
			}
			string[] targetPrefabNames = TargetPrefabNames;
			foreach (string text in targetPrefabNames)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
				ItemDrop val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val != (Object)null && item.m_shared == val.m_itemData.m_shared)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsTargetPrefab(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			string[] targetPrefabNames = TargetPrefabNames;
			foreach (string b in targetPrefabNames)
			{
				if (string.Equals(prefabName, b, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		internal static Sprite GetOrCreateIcon()
		{
			if ((Object)(object)_cachedIcon != (Object)null)
			{
				return _cachedIcon;
			}
			_cachedIcon = LoadEmbeddedPngIcon();
			if ((Object)(object)_cachedIcon != (Object)null)
			{
				AdventureBackpacks.Log.Message($"[IronBackpack] Icon loaded from embedded PNG ({((Texture)_cachedIcon.texture).width}x{((Texture)_cachedIcon.texture).height}).");
				return _cachedIcon;
			}
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				if (!((Object)(object)allLoadedAssetBundle == (Object)null) && TryCreateIconFromBundleTexture(allLoadedAssetBundle, out _cachedIcon))
				{
					AdventureBackpacks.Log.Message($"[IronBackpack] Icon built from bundle texture '{((Object)allLoadedAssetBundle).name}' ({((Texture)_cachedIcon.texture).width}x{((Texture)_cachedIcon.texture).height}).");
					return _cachedIcon;
				}
			}
			LogOnce("Could not load IronBackpack_Icon (embedded PNG or bundle texture).");
			return null;
		}

		private static Sprite LoadEmbeddedPngIcon()
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			Assembly assembly = typeof(IronBackpackIconFix).Assembly;
			string text = null;
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			foreach (string text2 in manifestResourceNames)
			{
				if (text2.EndsWith("Icons.IronBackpack_Icon.png", StringComparison.OrdinalIgnoreCase) || text2.EndsWith("IronBackpack_Icon.png", StringComparison.OrdinalIgnoreCase))
				{
					text = text2;
					break;
				}
			}
			if (text == null)
			{
				AdventureBackpacks.Log.Warning("[IronBackpack] Embedded PNG resource not found in mod assembly.");
				return null;
			}
			using Stream stream = assembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val = AssetUtils.LoadImage(array);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Sprite obj = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)obj).name = "IronBackpack_Icon";
			return obj;
		}

		private static bool TryCreateIconFromBundleTexture(AssetBundle bundle, out Sprite icon)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			icon = null;
			if ((Object)(object)bundle == (Object)null)
			{
				return false;
			}
			Texture2D val = null;
			Texture2D[] array = bundle.LoadAllAssets<Texture2D>();
			foreach (Texture2D val2 in array)
			{
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name.IndexOf("IronBackpack_Icon", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					val = val2;
					break;
				}
			}
			if (val == null)
			{
				val = bundle.LoadAsset<Texture2D>("IronBackpack_Icon");
			}
			if (val == null)
			{
				val = bundle.LoadAsset<Texture2D>("Assets/Texture2D/IronBackpack_Icon.png");
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Texture2D val3 = DuplicateReadableTexture(val);
			if ((Object)(object)val3 == (Object)null)
			{
				return false;
			}
			icon = Sprite.Create(val3, new Rect(0f, 0f, (float)((Texture)val3).width, (float)((Texture)val3).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)icon).name = "IronBackpack_Icon";
			return true;
		}

		private static Texture2D DuplicateReadableTexture(Texture2D source)
		{
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			try
			{
				return AssetUtils.DuplicateTexture(source);
			}
			catch (Exception ex)
			{
				AdventureBackpacks.Log.Warning("[IronBackpack] DuplicateTexture failed: " + ex.Message);
				return null;
			}
		}

		internal static void Apply()
		{
			Sprite orCreateIcon = GetOrCreateIcon();
			if ((Object)(object)orCreateIcon == (Object)null)
			{
				return;
			}
			string[] targetPrefabNames = TargetPrefabNames;
			foreach (string text in targetPrefabNames)
			{
				foreach (BackpackItem backpackItem in BackpackFactory.BackpackItems)
				{
					if (string.Equals(backpackItem.PrefabName, text, StringComparison.Ordinal))
					{
						Item item = backpackItem.Item;
						object drop;
						if (item == null)
						{
							drop = null;
						}
						else
						{
							GameObject prefab = item.Prefab;
							drop = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
						}
						ApplyToItemDrop((ItemDrop)drop, orCreateIcon);
					}
				}
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					GameObject prefab2 = ZNetScene.instance.GetPrefab(text);
					ApplyToItemDrop((prefab2 != null) ? prefab2.GetComponent<ItemDrop>() : null, orCreateIcon);
				}
				if ((Object)(object)ObjectDB.instance != (Object)null)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
					ApplyToItemDrop((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null, orCreateIcon);
				}
			}
			AdventureBackpacks.Log.Message("[IronBackpack] Prefab icon arrays patched (BackpackBlackForest, CapeIronBackpack).");
		}

		internal static void NotifyGetIconOverride(ItemData item)
		{
			if (!_loggedGetIcon)
			{
				_loggedGetIcon = true;
				string text = item?.m_shared?.m_name ?? "(unknown)";
				AdventureBackpacks.Log.Message("[IronBackpack] GetIcon override active for '" + text + "'.");
			}
		}

		private static void ApplyToItemDrop(ItemDrop drop, Sprite icon)
		{
			if (drop?.m_itemData?.m_shared != null)
			{
				Sprite[] array = (Sprite[])(object)new Sprite[Math.Max(1, drop.m_itemData.m_shared.m_variants)];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = icon;
				}
				drop.m_itemData.m_shared.m_icons = array;
				drop.Save();
			}
		}

		private static void LogOnce(string message)
		{
			if (!_loggedFailure)
			{
				_loggedFailure = true;
				AdventureBackpacks.Log.Warning("[IronBackpack] Inventory icon fix failed: " + message);
			}
		}
	}
	internal static class SilverBackpackIconFix
	{
		internal const string IconTextureName = "SilverBackpack_Icon";

		private const string EmbeddedPngSuffix = "Icons.SilverBackpack_Icon.png";

		private static readonly string[] TargetPrefabNames = new string[2] { "BackpackMountains", "CapeSilverBackpack" };

		private static readonly string[] ItemNameTokens = new string[2] { "vapok_mod_item_backpack_mountains", "vapok_mod_item_arctic_backpack" };

		private static Sprite _cachedIcon;

		private static bool _loggedFailure;

		private static bool _loggedGetIcon;

		internal static bool IsSilverHdBackpack(SharedData shared)
		{
			if (shared == null || shared.m_name == null)
			{
				return false;
			}
			string[] itemNameTokens = ItemNameTokens;
			foreach (string value in itemNameTokens)
			{
				if (shared.m_name.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsSilverHdBackpack(ItemData item)
		{
			if (item?.m_shared == null)
			{
				return false;
			}
			if (IsSilverHdBackpack(item.m_shared))
			{
				return true;
			}
			if (item.TryGetBackpackItem(out var backpack) && IsTargetPrefab(backpack.PrefabName))
			{
				return true;
			}
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return false;
			}
			string[] targetPrefabNames = TargetPrefabNames;
			foreach (string text in targetPrefabNames)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
				ItemDrop val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val != (Object)null && item.m_shared == val.m_itemData.m_shared)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsTargetPrefab(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			string[] targetPrefabNames = TargetPrefabNames;
			foreach (string b in targetPrefabNames)
			{
				if (string.Equals(prefabName, b, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		internal static Sprite GetOrCreateIcon()
		{
			if ((Object)(object)_cachedIcon != (Object)null)
			{
				return _cachedIcon;
			}
			_cachedIcon = LoadEmbeddedPngIcon();
			if ((Object)(object)_cachedIcon != (Object)null)
			{
				AdventureBackpacks.Log.Message($"[SilverBackpack] Icon loaded from embedded PNG ({((Texture)_cachedIcon.texture).width}x{((Texture)_cachedIcon.texture).height}).");
				return _cachedIcon;
			}
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				if (!((Object)(object)allLoadedAssetBundle == (Object)null) && TryCreateIconFromBundleTexture(allLoadedAssetBundle, out _cachedIcon))
				{
					AdventureBackpacks.Log.Message($"[SilverBackpack] Icon built from bundle texture '{((Object)allLoadedAssetBundle).name}' ({((Texture)_cachedIcon.texture).width}x{((Texture)_cachedIcon.texture).height}).");
					return _cachedIcon;
				}
			}
			LogOnce("Could not load SilverBackpack_Icon (embedded PNG or bundle texture).");
			return null;
		}

		private static Sprite LoadEmbeddedPngIcon()
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			Assembly assembly = typeof(SilverBackpackIconFix).Assembly;
			string text = null;
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			foreach (string text2 in manifestResourceNames)
			{
				if (text2.EndsWith("Icons.SilverBackpack_Icon.png", StringComparison.OrdinalIgnoreCase) || text2.EndsWith("SilverBackpack_Icon.png", StringComparison.OrdinalIgnoreCase))
				{
					text = text2;
					break;
				}
			}
			if (text == null)
			{
				AdventureBackpacks.Log.Warning("[SilverBackpack] Embedded PNG resource not found in mod assembly.");
				return null;
			}
			using Stream stream = assembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val = AssetUtils.LoadImage(array);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Sprite obj = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)obj).name = "SilverBackpack_Icon";
			return obj;
		}

		private static bool TryCreateIconFromBundleTexture(AssetBundle bundle, out Sprite icon)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			icon = null;
			if ((Object)(object)bundle == (Object)null)
			{
				return false;
			}
			Texture2D val = null;
			Texture2D[] array = bundle.LoadAllAssets<Texture2D>();
			foreach (Texture2D val2 in array)
			{
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name.IndexOf("SilverBackpack_Icon", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					val = val2;
					break;
				}
			}
			if (val == null)
			{
				val = bundle.LoadAsset<Texture2D>("SilverBackpack_Icon");
			}
			if (val == null)
			{
				val = bundle.LoadAsset<Texture2D>("Assets/Texture2D/SilverBackpack_Icon.png");
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Texture2D val3 = DuplicateReadableTexture(val);
			if ((Object)(object)val3 == (Object)null)
			{
				return false;
			}
			icon = Sprite.Create(val3, new Rect(0f, 0f, (float)((Texture)val3).width, (float)((Texture)val3).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)icon).name = "SilverBackpack_Icon";
			return true;
		}

		private static Texture2D DuplicateReadableTexture(Texture2D source)
		{
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			try
			{
				return AssetUtils.DuplicateTexture(source);
			}
			catch (Exception ex)
			{
				AdventureBackpacks.Log.Warning("[SilverBackpack] DuplicateTexture failed: " + ex.Message);
				return null;
			}
		}

		internal static void Apply()
		{
			Sprite orCreateIcon = GetOrCreateIcon();
			if ((Object)(object)orCreateIcon == (Object)null)
			{
				return;
			}
			string[] targetPrefabNames = TargetPrefabNames;
			foreach (string text in targetPrefabNames)
			{
				foreach (BackpackItem backpackItem in BackpackFactory.BackpackItems)
				{
					if (string.Equals(backpackItem.PrefabName, text, StringComparison.Ordinal))
					{
						Item item = backpackItem.Item;
						object drop;
						if (item == null)
						{
							drop = null;
						}
						else
						{
							GameObject prefab = item.Prefab;
							drop = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
						}
						ApplyToItemDrop((ItemDrop)drop, orCreateIcon);
					}
				}
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					GameObject prefab2 = ZNetScene.instance.GetPrefab(text);
					ApplyToItemDrop((prefab2 != null) ? prefab2.GetComponent<ItemDrop>() : null, orCreateIcon);
				}
				if ((Object)(object)ObjectDB.instance != (Object)null)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
					ApplyToItemDrop((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null, orCreateIcon);
				}
			}
			AdventureBackpacks.Log.Message("[SilverBackpack] Prefab icon arrays patched (BackpackMountains, CapeSilverBackpack).");
		}

		internal static void NotifyGetIconOverride(ItemData item)
		{
			if (!_loggedGetIcon)
			{
				_loggedGetIcon = true;
				string text = item?.m_shared?.m_name ?? "(unknown)";
				AdventureBackpacks.Log.Message("[SilverBackpack] GetIcon override active for '" + text + "'.");
			}
		}

		private static void ApplyToItemDrop(ItemDrop drop, Sprite icon)
		{
			if (drop?.m_itemData?.m_shared != null)
			{
				Sprite[] array = (Sprite[])(object)new Sprite[Math.Max(1, drop.m_itemData.m_shared.m_variants)];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = icon;
				}
				drop.m_itemData.m_shared.m_icons = array;
				drop.Save();
			}
		}

		private static void LogOnce(string message)
		{
			if (!_loggedFailure)
			{
				_loggedFailure = true;
				AdventureBackpacks.Log.Warning("[SilverBackpack] Inventory icon fix failed: " + message);
			}
		}
	}
	internal interface IBackpackItem : IAssetItem
	{
	}
	internal abstract class BackpackItem : AssetItem, IBackpackItem, IAssetItem
	{
		private static ConfigSyncBase _config;

		private static ILogIt _logger;

		private string _configSection;

		private string _englishSection;

		private string _localizedCategory;

		public System.Timers.Timer InceptionTimer;

		public System.Timers.Timer YardSaleTimer;

		private int _inceptionCounter;

		internal Dictionary<int, ConfigEntry<Vector2>> BackpackSize;

		internal ConfigEntry<float> WeightMultiplier;

		internal ConfigEntry<int> CarryBonus;

		internal ConfigEntry<float> SpeedMod;

		internal ConfigEntry<bool> EnableFreezing;

		internal ConfigEntry<bool> ShowBackpackStatusEffect;

		internal ConfigEntry<string> CustomStatusEffectName;

		internal ConfigEntry<BackpackBiomes> BackpackBiome;

		public int InceptionCounter
		{
			get
			{
				return _inceptionCounter;
			}
			set
			{
				_inceptionCounter = value;
				if (value > 0)
				{
					InceptionTimer.Stop();
					InceptionTimer.Start();
				}
			}
		}

		internal ConfigSyncBase Config => _config;

		internal ILogIt Log => _logger;

		protected BackpackItem(ABAPI.BackpackDefinition definition, GameObject goItem)
			: base(goItem, definition.ItemName)
		{
			_configSection = (string.IsNullOrEmpty(definition.ConfigSection) ? ("Backpack: " + definition.ItemName) : definition.ConfigSection);
			SetupLocalization();
			SetupBackpackDef();
		}

		protected BackpackItem(ABAPI.BackpackDefinition definition)
			: base(definition.AssetBundle, definition.PrefabName, definition.ItemName)
		{
			_configSection = (string.IsNullOrEmpty(definition.ConfigSection) ? ("Backpack: " + definition.ItemName) : definition.ConfigSection);
			SetupLocalization();
			SetupBackpackDef();
		}

		protected BackpackItem(string assetName, string prefabName, string itemName, string configSection = "", bool externalLocalize = false)
			: base(assetName, prefabName, itemName)
		{
			_configSection = (string.IsNullOrEmpty(configSection) ? ("Backpack: " + itemName) : configSection);
			_englishSection = Localizer.GetTranslation("English", _configSection);
			if (externalLocalize)
			{
				_localizedCategory = Localization.m_instance.Localize(_configSection);
			}
			else
			{
				_localizedCategory = Localization.instance.Localize(_configSection);
			}
			SetupBackpackDef();
		}

		internal void SetupLocalization()
		{
			_englishSection = Localizer.GetTranslation("English", _configSection);
			_localizedCategory = Localization.m_instance.Localize(_configSection);
			if (_localizedCategory.Equals(_configSection))
			{
				_localizedCategory = Localization.instance.Localize(_configSection);
			}
		}

		private void SetupBackpackDef()
		{
			base.Item.SectionName = _configSection;
			BackpackSize = new Dictionary<int, ConfigEntry<Vector2>>();
			InceptionTimer = new System.Timers.Timer(10000.0);
			InceptionTimer.AutoReset = false;
			InceptionTimer.Enabled = false;
			InceptionTimer.Elapsed += InceptionCounterReset;
		}

		private void InceptionCounterReset(object source, ElapsedEventArgs e)
		{
			InceptionCounter = 0;
			Log.Message("Odin walks away.");
		}

		internal static void SetConfig(ConfigSyncBase configSync)
		{
			_config = configSync;
		}

		internal static void SetLogger(ILogIt logger)
		{
			_logger = logger;
		}

		internal abstract void RegisterConfigSettings();

		internal virtual Vector2i GetInventorySize(int quality)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			quality = Mathf.Clamp(quality, 1, 4);
			return new Vector2i(Mathf.Clamp((int)BackpackSize[quality].Value.x, 1, 256), Mathf.Clamp((int)BackpackSize[quality].Value.y, 1, 256));
		}

		internal abstract void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData);

		internal virtual void RegisterBackpackSize(int quality = 1, int x = 6, int y = 3)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			ConfigEntry<Vector2> configEntry = null;
			ConfigSyncBase.SyncedConfig(_englishSection, $"Backpack Size - Level {quality}", new Vector2((float)x, (float)y), new ConfigDescription("Backpack size (width, height).\nMax width is 8 unless you want to break things.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Category = _localizedCategory,
				Order = 3
			} }), ref configEntry);
			BackpackSize.Add(quality, configEntry);
			BackpackSize[quality].SettingChanged += Backpacks.UpdateItemDataConfigValues;
		}

		internal virtual void RegisterWeightMultiplier(float defaultValue = 0.5f)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0046: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			ConfigSyncBase.SyncedConfig(_englishSection, "Weight Multiplier", defaultValue, new ConfigDescription("The weight of items stored in the backpack gets multiplied by this value. Setting to 100% or 1.0 disables weight reduction.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				Category = _localizedCategory,
				Order = 4
			} }), ref WeightMultiplier);
			WeightMultiplier.SettingChanged += Backpacks.UpdateItemDataConfigValues;
		}

		internal virtual void RegisterBackpackBiome(BackpackBiomes defaultValue = BackpackBiomes.None)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			ConfigSyncBase.SyncedConfig(_englishSection, "Backpack Biome", defaultValue, new ConfigDescription("The Biome this bag will draw it's effects from.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Category = _localizedCategory,
				Order = 5
			} }), ref BackpackBiome);
			BackpackBiome.SettingChanged += Backpacks.UpdateItemDataConfigValues;
		}

		internal virtual void RegisterCarryBonus(int defaultValue = 0)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			ConfigSyncBase.SyncedConfig(_englishSection, "Carry Bonus", defaultValue, new ConfigDescription("Increases your carry capacity by this much (multiplied by item level) while wearing the backpack.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 300), new object[1] { (object)new ConfigurationManagerAttributes
			{
				Category = _localizedCategory,
				Order = 6
			} }), ref CarryBonus);
			CarryBonus.SettingChanged += Backpacks.UpdateItemDataConfigValues;
		}

		internal virtual void RegisterStatusEffectInfo(bool defaultShowStatus = true, string defaultEffectName = "")
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			ConfigSyncBase.SyncedConfig(_englishSection, "Show Status Effect", defaultShowStatus, new ConfigDescription("Toggles the visibility of the Backpack Status Effect", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Category = _localizedCategory,
				Order = 1
			} }), ref ShowBackpackStatusEffect);
			ShowBackpackStatusEffect.SettingChanged += Backpacks.UpdateItemDataConfigValues;
			ConfigSyncBase.SyncedConfig(_englishSection, "Custom Effect Name", defaultEffectName, new ConfigDescription("Set your own effect name. Leave Empty to use Default Effect name", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Category = _localizedCategory,
				Order = 2
			} }), ref CustomStatusEffectName);
			CustomStatusEffectName.SettingChanged += Backpacks.UpdateItemDataConfigValues;
		}

		internal virtual void RegisterSpeedMod(float defaultValue = -0.15f)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0046: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			ConfigSyncBase.SyncedConfig(_englishSection, "Speed Modifier", defaultValue, new ConfigDescription("Wearing the backpack slows you down by this much.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-1f, -0f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				Category = _localizedCategory,
				Order = 7
			} }), ref SpeedMod);
			SpeedMod.SettingChanged += Backpacks.UpdateItemDataConfigValues;
		}

		internal virtual void RegisterEnableFreezing(bool defaultValue = true)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			ConfigSyncBase.SyncedConfig(_englishSection, "Prevent freezing/cold?", defaultValue, new ConfigDescription("Wearing the backpack protects you against freezing/cold, just like capes.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Category = _localizedCategory,
				Order = 8
			} }), ref EnableFreezing);
			EnableFreezing.SettingChanged += Backpacks.UpdateItemDataConfigValues;
		}
	}
}
namespace AdventureBackpacks.Assets.Items.BackpackItems
{
	internal class BackpackBlackForest : BackpackItem
	{
		public BackpackBlackForest(string assetName, string prefabName, string itemName)
			: base(assetName, prefabName, itemName)
		{
			RegisterConfigSettings();
			base.Item.Configurable = Configurability.Recipe | Configurability.Drop;
			AssignCraftingTable(ItemManager.CraftingTable.Forge, 1);
			base.Item.MaximumRequiredStationLevel = 3;
			AddRecipeIngredient("CapeTrollHide", 1);
			AddRecipeIngredient("Copper", 5);
			AddUpgradeIngredient("TrollHide", 3);
			AddUpgradeIngredient("Bronze", 3);
			base.Item.DropsFrom.Add("Greydwarf", 0.002f);
			base.Item.DropsFrom.Add("Greydwarf_Elite", 0.004f);
			base.Item.DropsFrom.Add("Greydwarf_Shaman", 0.004f);
			base.Item.DropsFrom.Add("Troll", 0.01f);
			base.Item.DropsFrom.Add("Bjorn", 0.04f);
			base.Item.DropsFrom.Add("gd_king", 0.08f);
		}

		internal sealed override void RegisterConfigSettings()
		{
			RegisterBackpackBiome(BackpackBiomes.BlackForest);
			RegisterBackpackSize(1, 3, 2);
			RegisterBackpackSize(2, 4, 2);
			RegisterBackpackSize(3, 5, 2);
			RegisterBackpackSize(4, 6, 2);
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier();
			RegisterCarryBonus(10);
			RegisterSpeedMod();
			if ((BackpackBiome.Value & BackpackBiomes.BlackForest) != BackpackBiomes.None)
			{
				EffectsFactory.EffectList[BackpackEffect.ColdResistance].RegisterEffectBiomeQuality(BackpackBiomes.BlackForest, 1);
				EffectsFactory.EffectList[BackpackEffect.TrollArmor].RegisterEffectBiomeQuality(BackpackBiomes.BlackForest, 2);
			}
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
	internal class BackpackMeadows : BackpackItem
	{
		public BackpackMeadows(string assetName, string prefabName, string itemName)
			: base(assetName, prefabName, itemName)
		{
			RegisterConfigSettings();
			base.Item.Configurable = Configurability.Recipe | Configurability.Drop;
			AssignCraftingTable(ItemManager.CraftingTable.Workbench, 2);
			base.Item.MaximumRequiredStationLevel = 3;
			AddRecipeIngredient("CapeDeerHide", 1);
			AddRecipeIngredient("DeerHide", 8);
			AddRecipeIngredient("BoneFragments", 2);
			AddUpgradeIngredient("LeatherScraps", 5);
			AddUpgradeIngredient("DeerHide", 3);
			base.Item.DropsFrom.Add("Greyling", 0.002f);
			base.Item.DropsFrom.Add("Eikthyr", 0.04f);
		}

		internal sealed override void RegisterConfigSettings()
		{
			RegisterBackpackBiome(BackpackBiomes.Meadows);
			RegisterBackpackSize(1, 3, 1);
			RegisterBackpackSize(2, 4, 1);
			RegisterBackpackSize(3, 5, 1);
			RegisterBackpackSize(4, 6, 1);
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier();
			RegisterCarryBonus(5);
			RegisterSpeedMod();
			if ((BackpackBiome.Value & BackpackBiomes.Meadows) != BackpackBiomes.None)
			{
				EffectsFactory.EffectList[BackpackEffect.ColdResistance].RegisterEffectBiomeQuality(BackpackBiomes.Meadows, 3);
			}
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
	internal class BackpackMistlands : BackpackItem
	{
		public BackpackMistlands(string assetName, string prefabName, string itemName)
			: base(assetName, prefabName, itemName)
		{
			RegisterConfigSettings();
			base.Item.Configurable = Configurability.Recipe | Configurability.Drop;
			AssignCraftingTable(ItemManager.CraftingTable.BlackForge, 1);
			base.Item.MaximumRequiredStationLevel = 2;
			AddRecipeIngredient("CapeFeather", 1);
			AddRecipeIngredient("ScaleHide", 5);
			AddRecipeIngredient("Eitr", 10);
			AddUpgradeIngredient("ScaleHide", 4);
			AddUpgradeIngredient("Eitr", 2);
			AddUpgradeIngredient("Softtissue", 5);
			base.Item.DropsFrom.Add("Dverger", 0.002f);
			base.Item.DropsFrom.Add("DvergerMage", 0.002f);
			base.Item.DropsFrom.Add("DvergerMageFire", 0.002f);
			base.Item.DropsFrom.Add("DvergerMageIce", 0.002f);
			base.Item.DropsFrom.Add("DvergerMageSupport", 0.002f);
			base.Item.DropsFrom.Add("SeekerQueen", 0.08f);
		}

		internal sealed override void RegisterConfigSettings()
		{
			RegisterBackpackBiome(BackpackBiomes.Mistlands);
			RegisterBackpackSize(1, 8, 2);
			RegisterBackpackSize(2, 5, 4);
			RegisterBackpackSize(3, 6, 4);
			RegisterBackpackSize(4, 7, 4);
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier();
			RegisterCarryBonus(30);
			RegisterSpeedMod();
			if ((BackpackBiome.Value & BackpackBiomes.Mistlands) != BackpackBiomes.None)
			{
				EffectsFactory.EffectList[BackpackEffect.FeatherFall].RegisterEffectBiomeQuality(BackpackBiomes.Mistlands, 3);
				EffectsFactory.EffectList[BackpackEffect.Demister].RegisterEffectBiomeQuality(BackpackBiomes.Mistlands, 4);
				EffectsFactory.EffectList[BackpackEffect.FrostResistance].RegisterEffectBiomeQuality(BackpackBiomes.Mistlands, 2);
				EffectsFactory.EffectList[BackpackEffect.ColdResistance].RegisterEffectBiomeQuality(BackpackBiomes.Mistlands, 1);
			}
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
	internal class BackpackMountains : BackpackItem
	{
		public BackpackMountains(string assetName, string prefabName, string itemName)
			: base(assetName, prefabName, itemName)
		{
			RegisterConfigSettings();
			base.Item.Configurable = Configurability.Recipe | Configurability.Drop;
			AssignCraftingTable(ItemManager.CraftingTable.Forge, 3);
			base.Item.MaximumRequiredStationLevel = 7;
			AddRecipeIngredient("CapeWolf", 1);
			AddRecipeIngredient("WolfHairBundle", 10);
			AddUpgradeIngredient("WolfPelt", 5);
			AddUpgradeIngredient("Silver", 5);
			base.Item.DropsFrom.Add("Fenring_Cultist", 0.002f);
			base.Item.DropsFrom.Add("Ulv", 0.001f);
			base.Item.DropsFrom.Add("Fenring", 0.008f);
			base.Item.DropsFrom.Add("Dragon", 0.04f);
		}

		internal sealed override void RegisterConfigSettings()
		{
			RegisterBackpackBiome(BackpackBiomes.Mountains);
			RegisterBackpackSize(1, 3);
			RegisterBackpackSize(2, 4);
			RegisterBackpackSize(3, 5);
			RegisterBackpackSize(4);
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier();
			RegisterCarryBonus(20);
			RegisterSpeedMod();
			if ((BackpackBiome.Value & BackpackBiomes.Mountains) != BackpackBiomes.None)
			{
				EffectsFactory.EffectList[BackpackEffect.FeatherFall].RegisterEffectBiomeQuality(BackpackBiomes.Mountains, 4);
				EffectsFactory.EffectList[BackpackEffect.FrostResistance].RegisterEffectBiomeQuality(BackpackBiomes.Mountains, 1);
				EffectsFactory.EffectList[BackpackEffect.ColdResistance].RegisterEffectBiomeQuality(BackpackBiomes.Mountains, 1);
			}
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
	internal class BackpackPlains : BackpackItem
	{
		public BackpackPlains(string assetName, string prefabName, string itemName)
			: base(assetName, prefabName, itemName)
		{
			RegisterConfigSettings();
			base.Item.Configurable = Configurability.Recipe | Configurability.Drop;
			AssignCraftingTable(ItemManager.CraftingTable.Forge, 3);
			base.Item.MaximumRequiredStationLevel = 7;
			AddRecipeIngredient("CapeLox", 1);
			AddRecipeIngredient("Tar", 5);
			AddRecipeIngredient("BlackMetal", 5);
			AddUpgradeIngredient("LoxPelt", 2);
			AddUpgradeIngredient("BlackMetal", 5);
			base.Item.DropsFrom.Add("Goblin", 0.002f);
			base.Item.DropsFrom.Add("GoblinArcher", 0.002f);
			base.Item.DropsFrom.Add("GoblinBrute", 0.002f);
			base.Item.DropsFrom.Add("GoblinShaman", 0.002f);
			base.Item.DropsFrom.Add("Unbjorn", 0.02f);
			base.Item.DropsFrom.Add("GoblinKing", 0.04f);
		}

		internal sealed override void RegisterConfigSettings()
		{
			RegisterBackpackBiome(BackpackBiomes.Plains);
			RegisterBackpackSize(1, 3, 4);
			RegisterBackpackSize(2, 4, 4);
			RegisterBackpackSize(3, 5, 4);
			RegisterBackpackSize(4, 6, 4);
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier();
			RegisterCarryBonus(25);
			RegisterSpeedMod();
			if ((BackpackBiome.Value & BackpackBiomes.Plains) != BackpackBiomes.None)
			{
				EffectsFactory.EffectList[BackpackEffect.FrostResistance].RegisterEffectBiomeQuality(BackpackBiomes.Plains, 3);
				EffectsFactory.EffectList[BackpackEffect.ColdResistance].RegisterEffectBiomeQuality(BackpackBiomes.Plains, 1);
			}
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
	internal class BackpackSwamp : BackpackItem
	{
		public BackpackSwamp(string assetName, string prefabName, string itemName)
			: base(assetName, prefabName, itemName)
		{
			RegisterConfigSettings();
			base.Item.Configurable = Configurability.Recipe | Configurability.Drop;
			AssignCraftingTable(ItemManager.CraftingTable.Workbench, 2);
			base.Item.MaximumRequiredStationLevel = 5;
			AddRecipeIngredient("Bloodbag", 10);
			AddRecipeIngredient("Root", 4);
			AddRecipeIngredient("Guck", 4);
			AddUpgradeIngredient("Bloodbag", 2);
			AddUpgradeIngredient("Iron", 5);
			base.Item.DropsFrom.Add("Draugr", 0.002f);
			base.Item.DropsFrom.Add("Draugr_Ranged", 0.004f);
			base.Item.DropsFrom.Add("Draugr_Elite", 0.004f);
			base.Item.DropsFrom.Add("Abomination", 0.008f);
			base.Item.DropsFrom.Add("Bonemass", 0.04f);
		}

		internal sealed override void RegisterConfigSettings()
		{
			RegisterBackpackBiome(BackpackBiomes.Swamp);
			RegisterBackpackSize(1, 2);
			RegisterBackpackSize(2, 3);
			RegisterBackpackSize(3, 4);
			RegisterBackpackSize(4, 5);
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier();
			RegisterCarryBonus(15);
			RegisterSpeedMod();
			if ((BackpackBiome.Value & BackpackBiomes.Swamp) != BackpackBiomes.None)
			{
				EffectsFactory.EffectList[BackpackEffect.WaterResistance].RegisterEffectBiomeQuality(BackpackBiomes.Swamp, 2);
				EffectsFactory.EffectList[BackpackEffect.ColdResistance].RegisterEffectBiomeQuality(BackpackBiomes.Swamp, 1);
			}
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
	internal class LegacyIronBackpack : BackpackItem
	{
		public LegacyIronBackpack(string assetName, string prefabName, string itemName)
			: base(assetName, prefabName, itemName)
		{
			RegisterConfigSettings();
		}

		internal sealed override void RegisterConfigSettings()
		{
			RegisterBackpackBiome();
			RegisterBackpackSize();
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier();
			RegisterCarryBonus(25);
			RegisterSpeedMod();
			RegisterEnableFreezing(defaultValue: false);
		}

		internal override Vector2i GetInventorySize(int quality)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return base.GetInventorySize(1);
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			if (EnableFreezing.Value)
			{
				modifierList.Add(FrostResistance.EffectMod);
			}
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
	internal class LegacySilverBackpack : BackpackItem
	{
		public LegacySilverBackpack(string assetName, string prefabName, string itemName)
			: base(assetName, prefabName, itemName)
		{
			RegisterConfigSettings();
		}

		internal sealed override void RegisterConfigSettings()
		{
			RegisterBackpackBiome();
			RegisterBackpackSize();
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier();
			RegisterCarryBonus(45);
			RegisterSpeedMod();
			RegisterEnableFreezing();
		}

		internal override Vector2i GetInventorySize(int quality)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return base.GetInventorySize(1);
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			if (EnableFreezing.Value)
			{
				modifierList.Add(FrostResistance.EffectMod);
			}
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
	internal class ExternalBackpack : BackpackItem
	{
		private readonly ABAPI.BackpackDefinition _backpackDefinition;

		private static EffectsBase _setEffectsBase;

		public ExternalBackpack(ABAPI.BackpackDefinition backpackDefinition, GameObject goItem)
			: base(backpackDefinition, goItem)
		{
			_backpackDefinition = backpackDefinition;
			SetupBackpack();
		}

		public ExternalBackpack(ABAPI.BackpackDefinition backpackDefinition)
			: base(backpackDefinition)
		{
			_backpackDefinition = backpackDefinition;
			SetupBackpack();
		}

		public void SetupBackpack()
		{
			RegisterConfigSettings();
			base.Item.Configurable = Configurability.Recipe | Configurability.Drop;
			AssignCraftingTable(_backpackDefinition.CraftingTable, _backpackDefinition.StationLevel);
			base.Item.MaximumRequiredStationLevel = _backpackDefinition.MaxRequiredStationLevel;
			foreach (ABAPI.RecipeIngredient recipeIngredient in _backpackDefinition.RecipeIngredients)
			{
				AddRecipeIngredient(recipeIngredient.ItemPrefabName, recipeIngredient.Quantity);
			}
			foreach (ABAPI.RecipeIngredient upgradeIngredient in _backpackDefinition.UpgradeIngredients)
			{
				AddUpgradeIngredient(upgradeIngredient.ItemPrefabName, upgradeIngredient.Quantity);
			}
			foreach (ABAPI.DropTarget item in _backpackDefinition.DropsFrom)
			{
				base.Item.DropsFrom.Add(item.Creature, item.Chance, item.Min, item.Max);
			}
			AdventureBackpacks.Waiter.StatusChanged += delegate
			{
				RegisterEffects();
			};
		}

		private void RegisterEffects()
		{
			foreach (KeyValuePair<BackpackBiomes, KeyValuePair<StatusEffect, int>> item in _backpackDefinition.EffectsToApply)
			{
				if ((BackpackBiome.Value & item.Key) == 0)
				{
					continue;
				}
				foreach (EffectsBase allEffect in EffectsFactory.AllEffects)
				{
					if ((Object)(object)allEffect.GetStatusEffect() == (Object)null)
					{
						allEffect.LoadStatusEffect();
					}
					if (allEffect.GetStatusEffect().m_name.Equals(item.Value.Key.m_name))
					{
						if ((Object)(object)_backpackDefinition.ItemSetStatusEffect != (Object)null && _backpackDefinition.ItemSetStatusEffect.m_name.Equals(allEffect.GetStatusEffect().m_name))
						{
							_setEffectsBase = allEffect;
						}
						allEffect.RegisterEffectBiomeQuality(item.Key, item.Value.Value);
					}
				}
			}
		}

		internal sealed override void RegisterConfigSettings()
		{
			//IL_0036: 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)
			RegisterBackpackBiome(_backpackDefinition.BackpackBiome);
			foreach (KeyValuePair<int, Vector2> item in _backpackDefinition.BackpackSizeByQuality)
			{
				RegisterBackpackSize(item.Key, (int)item.Value.x, (int)item.Value.y);
			}
			RegisterStatusEffectInfo();
			RegisterWeightMultiplier(_backpackDefinition.WeightMultiplier);
			RegisterCarryBonus(_backpackDefinition.CarryBonus);
			RegisterSpeedMod(_backpackDefinition.SpeedMod);
			RegisterShaderSwap();
		}

		internal override void UpdateStatusEffects(int quality, CustomSE statusEffects, List<DamageModPair> modifierList, ItemData itemData)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			itemData.m_shared.m_movementModifier = SpeedMod.Value / (float)quality;
			if (_setEffectsBase != null)
			{
				if (_setEffectsBase.HasActiveStatusEffect(itemData, out var statusEffect))
				{
					itemData.m_shared.m_setStatusEffect = statusEffect;
				}
				else
				{
					itemData.m_shared.m_setStatusEffect = null;
				}
			}
			((SE_Stats)statusEffects.Effect).m_addMaxCarryWeight = CarryBonus.Value * quality;
		}
	}
}
namespace AdventureBackpacks.Assets.Factories
{
	internal abstract class AssetFactory : FactoryBase
	{
		internal AssetFactory(ILogIt logger, ConfigSyncBase configs)
			: base(logger, configs)
		{
		}

		internal abstract void CreateAssets();
	}
	internal class BackpackFactory : AssetFactory
	{
		private static HashSet<BackpackItem> _backpackItems = new HashSet<BackpackItem>();

		private static bool _initialized;

		private static List<ABAPI.BackpackDefinition> _externalBackpacks = new List<ABAPI.BackpackDefinition>();

		internal static IEnumerable<BackpackItem> BackpackItems => _backpackItems;

		internal BackpackFactory(ILogIt logger, ConfigSyncBase configSync)
			: base(logger, configSync)
		{
			if (!_initialized)
			{
				BackpackItem.SetConfig(configSync);
				BackpackItem.SetLogger(logger);
				_initialized = true;
			}
		}

		public static void RegisterExternalBackpack(ABAPI.BackpackDefinition backpackDefinition)
		{
			_externalBackpacks.Add(backpackDefinition);
		}

		internal override void CreateAssets()
		{
			_backpackItems.Add(new BackpackMeadows("backpack_meadows", "BackpackMeadows", "$vapok_mod_item_backpack_meadows"));
			_backpackItems.Add(new BackpackBlackForest("backpack_black_forest", "BackpackBlackForest", "$vapok_mod_item_backpack_blackforest"));
			_backpackItems.Add(new BackpackSwamp("backpack_swamp", "BackpackSwamp", "$vapok_mod_item_backpack_swamp"));
			_backpackItems.Add(new BackpackMountains("backpack_mountains", "BackpackMountains", "$vapok_mod_item_backpack_mountains"));
			_backpackItems.Add(new BackpackPlains("backpack_plains", "BackpackPlains", "$vapok_mod_item_backpack_plains"));
			_backpackItems.Add(new BackpackMistlands("backpack_mistlands", "BackpackMistlands", "$vapok_mod_item_backpack_mistlands"));
			_backpackItems.Add(new LegacyIronBackpack("vapokbackpacks", "CapeIronBackpack", "$vapok_mod_item_rugged_backpack"));
			_backpackItems.Add(new LegacySilverBackpack("vapokbackpacks", "CapeSilverBackpack", "$vapok_mod_item_arctic_backpack"));
			foreach (ABAPI.BackpackDefinition backpackDefinition in _externalBackpacks)
			{
				if (_backpackItems.Any((BackpackItem x) => x.ItemName.Equals(backpackDefinition.ItemName)))
				{
					break;
				}
				ExternalBackpack item = (((Object)(object)backpackDefinition.BackPackGo != (Object)null) ? new ExternalBackpack(backpackDefinition, backpackDefinition.BackPackGo) : new ExternalBackpack(backpackDefinition));
				_backpackItems.Add(item);
			}
		}

		internal static List<string> BackpackTypes()
		{
			return BackpackItems.Select((BackpackItem x) => x.ItemName).ToList();
		}
	}
	public enum BackpackEffect
	{
		FeatherFall,
		ColdResistance,
		Demister,
		WaterResistance,
		FrostResistance,
		TrollArmor,
		NecromancyArmor,
		ExternalEffect
	}
	public class EffectsFactory : FactoryBase
	{
		private static Dictionary<BackpackEffect, EffectsBase> _effectList = new Dictionary<BackpackEffect, EffectsBase>();

		private static HashSet<EffectsBase> _externalEffects = new HashSet<EffectsBase>();

		private static HashSet<EffectsBase> _allEffects = new HashSet<EffectsBase>();

		private static readonly List<EffectsBase> PerFrameToggleEffects = new List<EffectsBase>();

		private static bool _registerEffectsCompleted;

		public static EffectsFactory Instance;

		public static HashSet<EffectsBase> AllEffects => _allEffects;

		public static Dictionary<BackpackEffect, EffectsBase> EffectList => _effectList;

		public EffectsFactory(ILogIt logger, ConfigSyncBase configs)
			: base(logger, configs)
		{
			Instance = this;
		}

		public static HashSet<StatusEffect> GetRegisteredEffects()
		{
			HashSet<StatusEffect> hashSet = new HashSet<StatusEffect>();
			foreach (KeyValuePair<BackpackEffect, EffectsBase> effect in _effectList)
			{
				hashSet.Add(effect.Value.GetStatusEffect());
			}
			foreach (EffectsBase externalEffect in _externalEffects)
			{
				hashSet.Add(externalEffect.GetStatusEffect());
			}
			return hashSet;
		}

		public static void RegisterExternalEffect(ABAPI.EffectDefinition effectDefinition)
		{
			if (_externalEffects.Any((EffectsBase x) => x.EffectName.Equals(effectDefinition.EffectName)))
			{
				return;
			}
			ExternalEffect externalEffect = new ExternalEffect(effectDefinition);
			_externalEffects.Add(externalEffect);
			if (_registerEffectsCompleted)
			{
				externalEffect.RegisterEffectConfiguration();
				_allEffects.Add(externalEffect);
				if (externalEffect.RequiresPerFrameToggle)
				{
					PerFrameToggleEffects.Add(externalEffect);
				}
			}
		}

		public void RegisterEffects()
		{
			_effectList.Add(BackpackEffect.FeatherFall, new FeatherFall("Feather Fall", "When activated allows you to slow fall gracefully and without damage from high elevations."));
			_effectList.Add(BackpackEffect.ColdResistance, new ColdResistance("Cold Immunity", "When activated keeps you from feeling cold. Does not prevent freezing."));
			_effectList.Add(BackpackEffect.Demister, new Demister("Demister", "When activated provides you with the Wisplight Effect, which clears mist from a small area around you while in the Mistlands."));
			_effectList.Add(BackpackEffect.WaterResistance, new Waterproof("Water Resistance", "When activated allows you to stay dry from the rain. Will still get wet if swimming."));
			_effectList.Add(BackpackEffect.FrostResistance, new FrostResistance("Frost Resistance", "When activated allows you to stay warm in freezing conditions, negating the freezing debuff."));
			_effectList.Add(BackpackEffect.TrollArmor, new TrollArmor("Troll Armor Set", "When activated the backpack acts as the Shoulder Set piece of the Troll Armor Set allowing the set to complete for the Sneak Effect"));
			foreach (BackpackEffect value in Enum.GetValues(typeof(BackpackEffect)))
			{
				switch (value)
				{
				case BackpackEffect.ExternalEffect:
					foreach (EffectsBase externalEffect in _externalEffects)
					{
						_allEffects.Add(externalEffect);
						externalEffect.RegisterEffectConfiguration();
					}
					break;
				case BackpackEffect.FeatherFall:
				case BackpackEffect.ColdResistance:
				case BackpackEffect.Demister:
				case BackpackEffect.WaterResistance:
				case BackpackEffect.FrostResistance:
				case BackpackEffect.TrollArmor:
				case BackpackEffect.NecromancyArmor:
					if (EffectList.ContainsKey(value))
					{
						_allEffects.Add(EffectList[value]);
						EffectList[value].RegisterEffectConfiguration();
					}
					break;
				}
			}
			_registerEffectsCompleted = true;
			RebuildPerFrameToggleList();
		}

		private static void RebuildPerFrameToggleList()
		{
			PerFrameToggleEffects.Clear();
			foreach (EffectsBase allEffect in _allEffects)
			{
				if (allEffect.RequiresPerFrameToggle)
				{
					PerFrameToggleEffects.Add(allEffect);
				}
			}
		}

		public void ToggleEffects()
		{
			for (int i = 0; i < PerFrameToggleEffects.Count; i++)
			{
				PerFrameToggleEffects[i].ToggleEffect();
			}
		}
	}
	public abstract class FactoryBase
	{
		private ILogIt _logger;

		private ConfigSyncBase _config;

		internal ILogIt Log => _logger;

		internal ConfigSyncBase Config => _config;

		internal FactoryBase(ILogIt logger, ConfigSyncBase configs)
		{
			_logger = logger;
			_config = configs;
		}
	}
}
namespace AdventureBackpacks.Assets.Effects
{
	public class ColdResistance : EffectsBase
	{
		private StatusEffect _externalStatusEffect;

		public ColdResistance(string effectName, string effectDesc)
			: base(effectName, effectDesc)
		{
		}

		private void LoadExternalStatusEffect()
		{
			if ((Object)(object)_externalStatusEffect == (Object)null)
			{
				StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect("Cold".GetHashCode());
				CustomSE customSE = new CustomSE(Enums.StatusEffects.Stats, "SE_vapok_ab_cold_immunity");
				customSE.Effect.m_name = "$vapok_mod_se_cold_immunity";
				customSE.Effect.m_icon = statusEffect.m_icon;
				_externalStatusEffect = customSE.Effect;
				SetStatusEffect(_externalStatusEffect);
			}
		}

		public override void LoadStatusEffect()
		{
			LoadExternalStatusEffect();
		}

		public override bool HasActiveStatusEffect(Humanoid human, out StatusEffect statusEffect)
		{
			LoadExternalStatusEffect();
			SetStatusEffect(_externalStatusEffect);
			return base.HasActiveStatusEffect(human, out statusEffect);
		}

		public override bool HasActiveStatusEffect(ItemData item, out StatusEffect statusEffect)
		{
			LoadExternalStatusEffect();
			SetStatusEffect(_externalStatusEffect);
			return base.HasActiveStatusEffect(item, out statusEffect);
		}
	}
	public class Demister : EffectsBase
	{
		private static Biome _previouseBiome;

		private static ConfigEntry<KeyboardShortcut> WisplightKeyToggle;

		private static ConfigEntry<bool> WisplightBiomeLogic;

		public override bool RequiresPerFrameToggle => true;

		public Demister(string effectName, string effectDesc)
			: base(effectName, effectDesc)
		{
		}

		public override void ToggleEffect()
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)Player.m_localPlayer) || !Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			ref Biome currentBiome = ref localPlayer.m_currentBiome;
			object obj = (object)(Biome)512;
			if ((((object)Unsafe.As<Biome, Biome>(ref currentBiome)/*cast due to .constrained prefix*/).Equals(obj) && WisplightBiomeLogic.Value) || !WisplightBiomeLogic.Value)
			{
				if (Player.m_localPlayer.IsBackpackEquipped())
				{
					if ((int)_previouseBiome != 512 && WisplightBiomeLogic.Value)
					{
						SetEffectSwitch(switchValue: true);
						((Humanoid)localPlayer).UpdateEquipmentStatusEffects();
					}
					KeyboardShortcut value = WisplightKeyToggle.Value;
					if (ZInput.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey, true) && IsEffectActive((Humanoid)(object)Player.m_localPlayer))
					{
						ToggleEffectSwitch();
						((Humanoid)localPlayer).UpdateEquipmentStatusEffects();
					}
				}
			}
			else if (CurrectSwitchSetting() && WisplightBiomeLogic.Value && IsEffectActive((Humanoid)(object)Player.m_localPlayer))
			{
				SetEffectSwitch(switchValue: false);
				((Humanoid)localPlayer).UpdateEquipmentStatusEffects();
			}
			_previouseBiome = localPlayer.GetCurrentBiome();
		}

		public override void LoadStatusEffect()
		{
			if (CurrectSwitchSetting())
			{
				SetStatusEffect("Demister");
			}
		}

		public override bool HasActiveStatusEffect(Humanoid human, out StatusEffect statusEffect)
		{
			if (!CurrectSwitchSetting())
			{
				statusEffect = null;
				return false;
			}
			SetStatusEffect("Demister");
			return base.HasActiveStatusEffect(human, out statusEffect);
		}

		public override void RegisterEffectConfiguration()
		{
			//IL_0017: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			base.RegisterEffectConfiguration();
			ConfigSyncBase.UnsyncedConfig("Wisplight Client Settings", "Wisplight Effect Key Toggle", new KeyboardShortcut((KeyCode)108, Array.Empty<KeyCode>()), new ConfigDescription("Hotkey to turn Wisplight on and off", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = 1
			} }), ref WisplightKeyToggle);
			ConfigSyncBase.UnsyncedConfig("Wisplight Client Settings", "Wisplight Biome Logic", value: true, new ConfigDescription("If enabled, the Wisplight will automatically turn on when entering Mistlands, and turn off when exiting.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = 2
			} }), ref WisplightBiomeLogic);
		}
	}
	public abstract class EffectsBase
	{
		public ConfigEntry<bool> EnabledEffect;

		public Dictionary<BackpackBiomes, ConfigEntry<int>> BiomeQualityLevels;

		private string _configSection;

		private string _effectName;

		private string _description;

		private StatusEffect _statusEffect;

		private bool _isSetItemStatusEffect;

		private bool _effectSwitch = true;

		public string EffectName => _effectName;

		public virtual bool RequiresPerFrameToggle => false;

		public EffectsBase(string effectName, string effectDesc, bool IsItemSetStatusEffect = false)
		{
			_effectName = effectName;
			_description = (string.IsNullOrEmpty(effectDesc) ? "Enables the effect." : effectDesc);
			_configSection = "Effect: " + effectName;
			_isSetItemStatusEffect = IsItemSetStatusEffect;
			AdventureBackpacks.Waiter.StatusChanged += delegate
			{
				LoadStatusEffect();
			};
		}

		public abstract void LoadStatusEffect();

		public virtual StatusEffect GetStatusEffect()
		{
			return _statusEffect;
		}

		public virtual void SetStatusEffect(StatusEffect statusEffect)
		{
			_statusEffect = statusEffect;
		}

		public virtual void SetStatusEffect(string effectName)
		{
			_statusEffect = (((Object)(object)_statusEffect == (Object)null) ? ObjectDB.instance.GetStatusEffect(effectName.GetHashCode()) : _statusEffect);
		}

		public virtual bool HasActiveStatusEffect(Humanoid human, out StatusEffect statusEffect)
		{
			statusEffect = _statusEffect;
			if ((Object)(object)statusEffect != (Object)null && IsEffectActive(human))
			{
				return !_isSetItemStatusEffect;
			}
			return false;
		}

		public virtual bool HasActiveStatusEffect(ItemData item, out StatusEffect statusEffect)
		{
			statusEffect = _statusEffect;
			if ((Object)(object)statusEffect != (Object)null)
			{
				return IsEffectActive(item);
			}
			return false;
		}

		public virtual bool IsEffectActive(Humanoid human)
		{
			Player val = (Player)(object)((human is Player) ? human : null);
			if (val != null)
			{
				BackpackComponent equippedBackpack = val.GetEquippedBackpack();
				if (equippedBackpack == null || !EnabledEffect.Value)
				{
					return false;
				}
				ItemData item = equippedBackpack.Item;
				item.TryGetBackpackItem(out var backpack);
				BackpackBiomes value = backpack.BackpackBiome.Value;
				int num = 0;
				foreach (BackpackBiomes key in BiomeQualityLevels.Keys)
				{
					if ((value & key) != BackpackBiomes.None)
					{
						num = ((BiomeQualityLevels[key].Value > num) ? BiomeQualityLevels[key].Value : num);
					}
				}
				if (num == 0)
				{
					return false;
				}
				return item.m_quality >= num;
			}
			return false;
		}

		public virtual void ToggleEffect()
		{
		}

		public virtual void ToggleEffectSwitch()
		{
			_effectSwitch = !_effectSwitch;
		}

		public virtual void SetEffectSwitch(bool switchValue)
		{
			_effectSwitch = switchValue;
		}

		public virtual bool CurrectSwitchSetting()
		{
			return _effectSwitch;
		}

		public virtual bool IsEffectActive(ItemData itemData)
		{
			if (!EnabledEffect.Value)
			{
				return false;
			}
			if (itemData != null && itemData.TryGetBackpackItem(out var backpack))
			{
				BackpackBiomes value = backpack.BackpackBiome.Value;
				int num = 0;
				foreach (BackpackBiomes key in BiomeQualityLevels.Keys)
				{
					if ((value & key) != BackpackBiomes.None)
					{
						num = ((BiomeQualityLevels[key].Value > num) ? BiomeQualityLevels[key].Value : num);
					}
				}
				if (num == 0)
				{
					return false;
				}
				return itemData.m_quality >= num;
			}
			return false;
		}

		public virtual void RegisterEffectConfiguration()
		{
			//IL_0026: 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_0038: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			BiomeQualityLevels = new Dictionary<BackpackBiomes, ConfigEntry<int>>();
			ConfigSyncBase.SyncedConfig(_configSection, "Effect Enabled", value: true, new ConfigDescription(_description, (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				Order = 1
			} }), ref EnabledEffect);
			ConfigRegistry.Waiter.StatusChanged += delegate
			{
				AdditionalConfiguration(_configSection);
			};
		}

		public virtual void AdditionalConfiguration(string configSection)
		{
			FillBiomeSettings();
		}

		private void FillBiomeSettings()
		{
			foreach (BackpackBiomes value in Enum.GetValues(typeof(BackpackBiomes)))
			{
				RegisterEffectBiomeQuality(value);
			}
		}

		public void RegisterEffectBiomeQuality(BackpackBiomes biome, int defaultQuality = 0)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			if (biome == BackpackBiomes.None)
			{
				return;
			}
			foreach (BackpackBiomes value in Enum.GetValues(typeof(BackpackBiomes)))
			{
				if ((biome & value) != BackpackBiomes.None)
				{
					ConfigEntry<int> configEntry = null;
					ConfigSyncBase.SyncedConfig(_configSection, "Effective Quality Level: " + value, defaultQuality, new ConfigDescription("Quality Level needed to apply effect to backpack. Zero disables effect for Biome.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 5), new object[1] { (object)new ConfigurationManagerAttributes
					{
						Order = 2
					} }), ref configEntry);
					ConfigEntry<int> val = configEntry;
					if (!BiomeQualityLevels.ContainsKey(value) && val != null)
					{
						BiomeQualityLevels.Add(value, val);
						val.SettingChanged += Backpacks.UpdateItemDataConfigValues;
					}
				}
			}
		}
	}
	public class FeatherFall : EffectsBase
	{
		public FeatherFall(string effectName, string effectDesc)
			: base(effectName, effectDesc)
		{
		}

		public override void LoadStatusEffect()
		{
			SetStatusEffect("SlowFall");
		}

		public override bool HasActiveStatusEffect(Humanoid human, out StatusEffect statusEffect)
		{
			SetStatusEffect("SlowFall");
			return base.HasActiveStatusEffect(human, out statusEffect);
		}
	}
	public class FrostResistance : EffectsBase
	{
		private StatusEffect _externalStatusEffect;

		public static DamageModPair EffectMod = new DamageModPair
		{
			m_type = (DamageType)64,
			m_modifier = (DamageModifier)1
		};

		public FrostResistance(string effectName, string effectDesc)
			: base(effectName, effectDesc)
		{
		}

		private void LoadExternalStatusEffect()
		{
			if ((Object)(object)_externalStatusEffect == (Object)null)
			{
				StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect("Freezing".GetHashCode());
				CustomSE customSE = new CustomSE(Enums.StatusEffects.Stats, "SE_vapok_ab_frost_resistance");
				customSE.Effect.m_name = "$vapok_mod_se_frost_resistance";
				customSE.Effect.m_icon = statusEffect.m_icon;
				_externalStatusEffect = customSE.Effect;
				SetStatusEffect(_externalStatusEffect);
			}
		}

		public override void LoadStatusEffect()
		{
			LoadExternalStatusEffect();
		}

		public override bool HasActiveStatusEffect(Humanoid human, out StatusEffect statusEffect)
		{
			LoadExternalStatusEffect();
			SetStatusEffect(_externalStatusEffect);
			return base.HasActiveStatusEffect(human, out statusEffect);
		}

		public override bool HasActiveStatusEffect(ItemData item, out StatusEffect statusEffect)
		{
			LoadExternalStatusEffect();
			SetStatusEffect(_externalStatusEffect);
			return base.HasActiveStatusEffect(item, out statusEffect);
		}

		public override bool IsEffectActive(Humanoid human)
		{
			Player val = (Player)(object)((human is Player) ? human : null);
			if (val != null)
			{
				BackpackComponent equippedBackpack = val.GetEquippedBackpack();
				if (equippedBackpack == null || !EnabledEffect.Value)
				{
					return false;
				}
				ItemData item = equippedBackpack.Item;
				return IsEffectActive(item);
			}
			return false;
		}
	}
	public class TrollArmor : EffectsBase
	{
		private string _effectName = "SetEffect_TrollArmor";

		public TrollArmor(string effectName, string effectDesc)
			: base(effectName, effectDesc, IsItemSetStatusEffect: true)
		{
		}

		public override void LoadStatusEffect()
		{
			SetStatusEffect(_effectName);
		}

		public override bool HasActiveStatusEffect(ItemData item, out StatusEffect statusEffect)
		{
			SetStatusEffect(_effectName);
			return base.HasActiveStatusEffect(item, out statusEffect);
		}

		public override bool IsEffectActive(Humanoid human)
		{
			Player val = (Player)(object)((human is Player) ? human : null);
			if (val != null)
			{
				BackpackComponent equippedBackpack = val.GetEquippedBackpack();
				if (equippedBackpack == null || !EnabledEffect.Value)
				{
					return false;
				}
				ItemData item = equippedBackpack.Item;
				return IsEffectActive(item);
			}
			return false;
		}
	}
	public class Waterproof : EffectsBase
	{
		private StatusEffect _externalStatusEffect;

		public Waterproof(string effectName, string effectDesc)
			: base(effectName, effectDesc)
		{
		}

		private void LoadExternalStatusEffect()
		{
			if ((Object)(object)_externalStatusEffect == (Object)null)
			{
				StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect("Wet".GetHashCode());
				CustomSE customSE = new CustomSE(Enums.StatusEffects.Stats, "SE_vapok_ab_wet_resistance");
				customSE.Effect.m_name = "$vapok_mod_se_wet_resistance";
				customSE.Effect.m_icon = statusEffect.m_icon;
				_externalStatusEffect = customSE.Effect;
				SetStatusEffect(_externalStatusEffect);
			}
		}

		public override void LoadStatusEffect()
		{
			LoadExternalStatusEffect();
		}

		public override bool HasActiveStatusEffect(Humanoid human, out StatusEffect statusEffect)
		{
			LoadExternalStatusEffect();
			SetStatusEffect(_externalStatusEffect);
			return base.HasActiveStatusEffect(human, out statusEffect);
		}

		public override bool HasActiveStatusEffect(ItemData item, out StatusEffect statusEffect)
		{
			LoadExternalStatusEffect();
			SetStatusEffect(_externalStatusEffect);
			return base.HasActiveStatusEffect(item, out statusEffect);
		}
	}
	public class ExternalEffect : EffectsBase
	{
		private string _effectName = string.Empty;

		private StatusEffect _externalStatusEffect;

		private ABAPI.EffectDefinition _effectDefinition;

		public ExternalEffect(ABAPI.EffectDefinition effectDefinition)
			: base(effectDefinition.Name, effectDefinition.Description)
		{
			_effectDefinition = effectDefinition;
			if (!string.IsNullOrEmpty(_effectDefinition.EffectName))
			{
				_effectName = _effectDefinition.EffectName;
			}
		}

		public override void RegisterEffectConfiguration()
		{
			base.RegisterEffectConfiguration();
			if ((Object)(object)_effectDefinition.StatusEffect == (Object)null)
			{
				AdventureBackpacks.Log.Error("Status Effect is null for " + _effectDefinition.Name + " - Disabling Status Effect");
				EnabledEffect.Value = false;
			}
		}

		public override void AdditionalConfiguration(string configSection)
		{
		}

		private void LoadExternalStatusEffect()
		{
			try
			{
				if (!((Object)(object)_externalStatusEffect != (Object)null))
				{
					_externalStatusEffect = _effectDefinition.StatusEffect;
					SetStatusEffect(_externalStatusEffect);
				}
			}
			catch (Exception ex)
			{
				AdventureBackpacks.Log.Error("Can't Load External Status Effect: " + _effectName + " - Message: " + ex.Message);
			}
		}

		public override void LoadStatusEffect()
		{
			LoadExternalStatusEffect();
		}

		public override bool HasActiveStatusEffect(Humanoid human, out StatusEffect statusEffect)
		{
			statusEffect = null;
			if (!EnabledEffect.Value)
			{
				return false;
			}
			LoadExternalStatusEffect();
			SetStatusEffect(_externalStatusEffect);
			return base.HasActiveStatusEffect(human, out statusEffect);
		}

		public override bool HasActiveStatusEffect(ItemData item, out StatusEffect statusEffect)
		{
			statusEffect = null;
			if (!EnabledEffect.Value)
			{
				return false;
			}
			LoadExternalStatusEffect();
			SetStatusEffect(_externalStatusEffect);
			return base.HasActiveStatusEffect(item, out statusEffect);
		}

		public override bool IsEffectActive(Humanoid human)
		{
			Player val = (Player)(object)((human is Player) ? human : null);
			if (val != null)
			{
				BackpackComponent equippedBackpack = val.GetEquippedBackpack();
				if (equippedBackpack == null || !EnabledEffect.Value)
				{
					return false;
				}
				ItemData item = equippedBackpack.Item;
				return IsEffectActive(item);
			}
			return false;
		}
	}
}
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;
		}
	}
}
namespace ItemManager
{
	[PublicAPI]
	internal enum CraftingTable
	{
		Disabled,
		Inventory,
		[InternalName("piece_workbench")]
		Workbench,
		[InternalName("piece_cauldron")]
		Cauldron,
		[InternalName("forge")]
		Forge,
		[InternalName("piece_artisanstation")]
		ArtisanTable,
		[InternalName("piece_stonecutter")]
		StoneCutter,
		[InternalName("piece_magetable")]
		MageTable,
		[InternalName("blackforge")]
		BlackForge,
		[InternalName("piece_preptable")]
		FoodPreparationTable,
		[InternalName("piece_MeadCauldron")]
		MeadKetill,
		Custom
	}
	[PublicAPI]
	internal enum ConversionPiece
	{
		Disabled,
		[InternalName("smelter")]
		Smelter,
		[InternalName("charcoal_kiln")]
		CharcoalKiln,
		[InternalName("blastfurnace")]
		BlastFurnace,
		[InternalName("windmill")]
		Windmill,
		[InternalName("piece_spinningwheel")]
		SpinningWheel,
		[InternalName("eitrrefinery")]
		EitrRefinery,
		Custom
	}
	internal class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[PublicAPI]
	internal class RequiredResourceList
	{
		public readonly List<Requirement> Requirements = new List<Requirement>();

		public bool Free;

		public void Add(string itemName, int amount, int quality = 0)
		{
			Requirements.Add(new Requirement
			{
				itemName = itemName,
				amount = amount,
				quality = quality
			});
		}

		public void Add(string itemName, ConfigEntry<int> amountConfig, int quality = 0)
		{
			Requirements.Add(new Requirement
			{
				itemName = itemName,
				amountConfig = amountConfig,
				quality = quality
			});
		}
	}
	[PublicAPI]
	internal class CraftingStationList
	{
		public readonly List<CraftingStationConfig> Stations = new List<CraftingStationConfig>();

		public void Add(CraftingTable table, int level)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = table,
				level = level
			});
		}

		public void Add(string customTable, int level)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = CraftingTable.Custom,
				level = level,
				custom = customTable
			});
		}
	}
	[PublicAPI]
	internal class ItemRecipe
	{
		public readonly RequiredResourceList RequiredItems = new RequiredResourceList();

		public readonly RequiredResourceList RequiredUpgradeItems = new RequiredResourceList();

		public readonly CraftingStationList Crafting = new CraftingStationList();

		public int CraftAmount = 1;

		public bool RequireOnlyOneIngredient;

		public float QualityResultAmountMultiplier = 1f;

		public ConfigEntryBase? RecipeIsActive;
	}
	[PublicAPI]
	internal class Trade
	{
		public Trader Trader;

		public uint Price;

		public uint Stack = 1u;

		public string? RequiredGlobalKey;
	}
	[PublicAPI]
	[Flags]
	internal enum Trader
	{
		None = 0,
		Haldor = 1,
		Hildir = 2
	}
	internal struct Requirement
	{
		public string itemName;

		public int amount;

		public ConfigEntry<int>? amountConfig;

		[Description("Set to a non-zero value to apply the requirement only for a specific quality")]
		public int quality;
	}
	internal struct CraftingStationConfig
	{
		public CraftingTable Table;

		public int level;

		public string? custom;
	}
	[Flags]
	internal enum Configurability
	{
		Disabled = 0,
		Recipe = 1,
		Stats = 2,
		Drop = 4,
		Trader = 8,
		Full = 0xF
	}
	[PublicAPI]
	internal class DropTargets
	{
		public readonly List<DropTarget> Drops = new List<DropTarget>();

		public void Add(string creatureName, float chance, int min = 1, int? max = null, bool levelMultiplier = true)
		{
			Drops.Add(new DropTarget
			{
				creature = creatureName,
				chance = chance,
				min = min,
				max = (max ?? min),
				levelMultiplier = levelMultiplier
			});
		}
	}
	internal struct DropTarget
	{
		public string creature;

		public int min;

		public int max;

		public float chance;

		public bool levelMultiplier;
	}
	internal enum Toggle
	{
		On = 1,
		Off = 0
	}
	[PublicAPI]
	internal class Item
	{
		private class ItemConfig
		{
			public ConfigEntry<string>? craft;

			public ConfigEntry<string>? upgrade;

			public ConfigEntry<CraftingTable> table;

			public ConfigEntry<int> tableLevel;

			public ConfigEntry<string> customTable;

			public ConfigEntry<int>? maximumTableLevel;

			public ConfigEntry<Toggle> requireOneIngredient;

			public ConfigEntry<float> qualityResultAmountMultiplier;
		}

		private class TraderConfig
		{
			public ConfigEntry<Trader> trader;

			public ConfigEntry<uint> price;

			public ConfigEntry<uint> stack;

			public ConfigEntry<string> requiredGlobalKey;
		}

		private class RequirementQuality
		{
			public int quality;
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string? Category;

			[UsedImplicitly]
			public Action<ConfigEntryBase>? CustomDrawer;

			public Func<bool>? browsability;
		}

		[PublicAPI]
		public enum DamageModifier
		{
			Normal,
			Resistant,
			Weak,
			Immune,
			Ignore,
			VeryResistant,
			VeryWeak,
			None
		}

		private delegate void setDmgFunc(ref DamageTypes dmg, float value);

		private class SerializedRequirements
		{
			public readonly List<Requirement> Reqs;

			public SerializedRequirements(List<Requirement> reqs)
			{
				Reqs = reqs;
			}

			public SerializedRequirements(string reqs)
				: this(reqs.Split(new char[1] { ',' }).Select(delegate(string r)
				{
					string[] array = r.Split(new char[1] { ':' });
					int result;
					int result2;
					return new Requirement
					{
						itemName = array[0],
						amount = ((array.Length <= 1 || !int.TryParse(array[1], out result)) ? 1 : result),
						quality = ((array.Length > 2 && int.TryParse(array[2], out result2)) ? result2 : 0)
					};
				}).ToList())
			{
			}

			public override string ToString()
			{
				return string.Join(",", Reqs.Select((Requirement r) => $"{r.itemName}:{r.amount}"));
			}

			public static ItemDrop? fetchByName(ObjectDB objectDB, string name)
			{
				GameObject itemPrefab = objectDB.GetItemPrefab(name);
				ItemDrop obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					LogManager.Log.Warning("The required item '" + name + "' does not exist.");
				}
				return obj;
			}

			public static Requirement[] toPieceReqs(ObjectDB objectDB, SerializedRequirements craft, SerializedRequirements upgrade)
			{
				//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_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: 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_0185: 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_018f: Expected O, but got Unknown
				//IL_0194: Expected O, but got Unknown
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				Dictionary<string, Requirement> dictionary = craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary((Func<Requirement, string>)((Requirement r) => r.itemName), (Func<Requirement, Requirement>)delegate(Requirement r)
				{
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					//IL_003e: Expected O, but got Unknown
					ItemDrop val6 = ResItem(r);
					return (val6 != null) ? new Requirement
					{
						m_amount = (r.amountConfig?.Value ?? r.amount),
						m_resItem = val6,
						m_amountPerLevel = 0
					} : ((Requirement)null);
				});
				List<Requirement> list = dictionary.Values.Where((Requirement v) => v != null).ToList();
				foreach (Requirement item in upgrade.Reqs.Where((Requirement r) => r.itemName != ""))
				{
					if (item.quality > 0)
					{
						ItemDrop val = ResItem(item);
						if (val != null)
						{
							Requirement val2 = new Requirement
							{
								m_resItem = val,
								m_amountPerLevel = (item.amountConfig?.Value ?? item.amount),
								m_amount = 0
							};
							list.Add(val2);
							requirementQuality.Add(val2, new RequirementQuality
							{
								quality = item.quality
							});
						}
						continue;
					}
					if (!dictionary.TryGetValue(item.itemName, out var value) || value == null)
					{
						ItemDrop val3 = ResItem(item);
						if (val3 != null)
						{
							string itemName = item.itemName;
							Requirement val4 = new Requirement
							{
								m_resItem = val3,
								m_amount = 0
							};
							Requirement val5 = val4;
							dictionary[itemName] = val4;
							value = val5;
							list.Add(value);
						}
					}
					if (value != null)
					{
						value.m_amountPerLevel = item.amountConfig?.Value ?? item.amount;
					}
				}
				return list.ToArray();
				ItemDrop? ResItem(Requirement r)
				{
					return fetchByName(objectDB, r.itemName);
				}
			}
		}

		private class SerializedDrop
		{
			public readonly List<DropTarget> Drops;

			public SerializedDrop(List<DropTarget> drops)
			{
				Drops = drops;
			}

			public SerializedDrop(string drops)
			{
				Drops = ((drops == "") ? ((IEnumerable<string>)Array.Empty<string>()) : ((IEnumerable<string>)drops.Split(new char[1] { ',' }))).Select(delegate(string r)
				{
					string[] array = r.Split(new char[1] { ':' });
					if (array.Length <= 2 || !int.TryParse(array[2], out var result))
					{
						result = 1;
					}
					if (array.Length <= 3 || !int.TryParse(array[3], out var result2))
					{
						result2 = result;
					}
					bool levelMultiplier = array.Length <= 4 || array[4] != "0";
					float result3;
					return new DropTarget
					{
						creature = array[0],
						chance = ((array.Length > 1 && float.TryParse(array[1], out result3)) ? result3 : 1f),
						min = result,
						max = result2,
						levelMultiplier = levelMultiplier
					};
				}).ToList();
			}

			public override string ToString()
			{
				return string.Join(",", Drops.Select((DropTarget r) => $"{r.creature}:{r.chance.ToString(CultureInfo.InvariantCulture)}:{r.min}:" + ((r.min == r.max) ? "" : $"{r.max}") + (r.levelMultiplier ? "" : ":0")));
			}

			private static Character? fetchByName(ZNetScene netScene, string name)
			{
				GameObject prefab = netScene.GetPrefab(name);
				Character obj = ((prefab != null) ? prefab.GetComponent<Character>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					LogManager.Log.Debug("The drop target character '" + name + "' does not exist.");
				}
				return obj;
			}

			public Dictionary<Character, Drop> toCharacterDrops(ZNetScene netScene, GameObject item)
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: 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: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				Dictionary<Character, Drop> dictionary = new Dictionary<Character, Drop>();
				foreach (DropTarget drop in Drops)
				{
					Character val = fetchByName(netScene, drop.creature);
					if (val != null)
					{
						dictionary[val] = new Drop
						{
							m_prefab = item,
							m_amountMin = drop.min,
							m_amountMax = drop.max,
							m_chance = drop.chance,
							m_levelMultiplier = drop.levelMultiplier
						};
					}
				}
				return dictionary;
			}
		}

		private static bool _initialized = false;

		private static readonly List<Item> registeredItems = new List<Item>();

		private static readonly Dictionary<ItemDrop, Item> itemDropMap = new Dictionary<ItemDrop, Item>();

		private static Dictionary<Item, Dictionary<string, List<Recipe>>> activeRecipes = new Dictionary<Item, Dictionary<string, List<Recipe>>>();

		private static Dictionary<Recipe, ConfigEntryBase?> hiddenCraftRecipes = new Dictionary<Recipe, ConfigEntryBase>();

		private static Dictionary<Recipe, ConfigEntryBase?> hiddenUpgradeRecipes = new Dictionary<Recipe, ConfigEntryBase>();

		private static Dictionary<Item, Dictionary<string, ItemConfig>> itemCraftConfigs = new Dictionary<Item, Dictionary<string, ItemConfig>>();

		private static Dictionary<Item, ConfigEntry<string>> itemDropConfigs = new Dictionary<Item, ConfigEntry<string>>();

		private static Dictionary<Item, ConfigEntry<bool>> itemDropEnabledConfig = new Dictionary<Item, ConfigEntry<bool>>();

		private Dictionary<CharacterDrop, Drop> characterDrops = new Dictionary<CharacterDrop, Drop>();

		private readonly Dictionary<ConfigEntryBase, Action> statsConfigs = new Dictionary<ConfigEntryBase, Action>();

		private static readonly ConditionalWeakTable<Requirement, RequirementQuality> requirementQuality = new ConditionalWeakTable<Requirement, RequirementQuality>();

		public string SectionName = string.Empty;

		public static Configurability DefaultConfigurability = Configurability.Full;

		public Configurability? Configurable;

		private Configurability configurationVisible = Configurability.Full;

		private TraderConfig? traderConfig;

		public readonly GameObject Prefab;

		[Description("Specifies the maximum required crafting station level to upgrade and repair the item.\nDefault is calculated from crafting station level and maximum quality.")]
		public int MaximumRequiredStationLevel = int.MaxValue;

		[Description("Assigns the item as a drop item to a creature.\nUses a creature name, a drop chance and a minimum and maximum amount.")]
		public readonly DropTargets DropsFrom = new DropTargets();

		[Description("Configures whether the item can be bought at the trader.\nDon't forget to set cost to something above 0 or the item will be sold for free.")]
		public readonly Trade Trade = new Trade();

		internal List<Conversion> Conversions = new List<Conversion>();

		internal List<ItemConversion> conversions = new List<ItemConversion>();

		public Dictionary<string, ItemRecipe> Recipes = new Dictionary<string, ItemRecipe>();

		private static object? configManager;

		private static BaseUnityPlugin? _plugin;

		private Configurability configurability => Configurable ?? DefaultConfigurability;

		[Description("Specifies the resources needed to craft the item.\nUse .Add to add resources with their internal ID and an amount.\nUse one .Add for each resource type the item should need.")]
		public RequiredResourceList RequiredItems => this[""].RequiredItems;

		[Description("Specifies the resources needed to upgrade the item.\nUse .Add to add resources with their internal ID and an amount. This amount will be multipled by the item quality level.\nUse one .Add for each resource type the upgrade should need.")]
		public RequiredResourceList RequiredUpgradeItems => this[""].RequiredUpgradeItems;

		[Description("Specifies the crafting station needed to craft the item.\nUse .Add to add a crafting station, using the CraftingTable enum and a minimum level for the crafting station.\nUse one .Add for each crafting station.")]
		public CraftingStationList Crafting => this[""].Crafting;

		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		public ConfigEntryBase? RecipeIsActive
		{
			get
			{
				return this[""].RecipeIsActive;
			}
			set
			{
				this[""].RecipeIsActive = value;
			}
		}

		[Description("Specifies the number of items that should be given to the player with a single craft of the item.\nDefaults to 1.")]
		public int CraftAmount
		{
			get
			{
				return this[""].CraftAmount;
			}
			set
			{
				this[""].CraftAmount = value;
			}
		}

		public bool RequireOnlyOneIngredient
		{
			get
			{
				return this[""].RequireOnlyOneIngredient;
			}
			set
			{
				this[""].RequireOnlyOneIngredient = value;
			}
		}

		public float QualityResultAmountMultiplier
		{
			get
			{
				return this[""].QualityResultAmountMultiplier;
			}
			set
			{
				this[""].QualityResultAmountMultiplier = value;
			}
		}

		public ItemRecipe this[string name]
		{
			get
			{
				if (Recipes.TryGetValue(name, out ItemRecipe value))
				{
					return value;
				}
				return Recipes[name] = new ItemRecipe();
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		public static void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
			}
		}

		public Item(string assetBundleFileName, string prefabName, string folderName = "assets")
			: this(PrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
		{
		}

		public Item(AssetBundle bundle, string prefabName)
			: this(PrefabManager.RegisterPrefab(bundle, prefabName, addToObjectDb: true), skipRegistering: true)
		{
		}

		public Item(GameObject prefab, bool skipRegistering = false)
		{
			if (!skipRegistering)
			{
				PrefabManager.RegisterPrefab(prefab, addToObjectDb: true);
			}
			Prefab = prefab;
			registeredItems.Add(this);
			itemDropMap[Prefab.GetComponent<ItemDrop>()] = this;
			Prefab.GetComponent<ItemDrop>().m_itemData.m_dropPrefab = Prefab;
		}

		public void ToggleConfigurationVisibility(Configurability visible)
		{
			configurationVisible = visible;
			if (itemDropConfigs.TryGetValue(this, out ConfigEntry<string> value))
			{
				Toggle((ConfigEntryBase)(object)value, Configurability.Drop);
			}
			if (itemCraftConfigs.TryGetValue(this, out Dictionary<string, ItemConfig> value2))
			{
				foreach (ItemConfig value4 in value2.Values)
				{
					ToggleObj(value4, Configurability.Recipe);
				}
			}
			foreach (Conversion conversion in Conversions)
			{
				if (conversion.config != null)
				{
					ToggleObj(conversion.config, Configurability.Recipe);
				}
			}
			foreach (KeyValuePair<ConfigEntryBase, Action> statsConfig in statsConfigs)
			{
				Toggle(statsConfig.Key, Configurability.Stats);
				if ((visible & Configurability.Stats) != Configurability.Disabled)
				{
					statsConfig.Value();
				}
			}
			reloadConfigDisplay();
			void Toggle(ConfigEntryBase cfg, Configurability check)
			{
				object[] tags = cfg.Description.Tags;
				for (int i = 0; i < tags.Length; i++)
				{
					if (tags[i] is ConfigurationManagerAttributes configurationManagerAttributes)
					{
						configurationManagerAttributes.Browsable = (visible & check) != Configurability.Disabled && (configurationManagerAttributes.browsability == null || configurationManagerAttributes.browsability());
					}
				}
			}
			void ToggleObj(object obj, Configurability check)
			{
				FieldInfo[] fields = obj.GetType().GetFields();
				for (int i = 0; i < fields.Length; i++)
				{
					object? value3 = fields[i].GetValue(obj);
					ConfigEntryBase val = (ConfigEntryBase)((value3 is ConfigEntryBase) ? value3 : null);
					if (val != null)
					{
						Toggle(val, check);
					}
				}
			}
		}

		internal static void reloadConfigDisplay()
		{
			object obj = configManager?.GetType().GetProperty("DisplayingWindow").GetValue(configManager);
			if (obj is bool && (bool)obj)
			{
				configManager.GetType().GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
			}
		}

		private void UpdateItemTableConfig(string recipeKey, CraftingTable table, string customTableValue)
		{
			if (activeRecipes.ContainsKey(this) && activeRecipes[this].TryGetValue(recipeKey, out List<Recipe> value))
			{
				value.First().m_enabled = table != CraftingTable.Disabled;
				if ((uint)table <= 1u)
				{
					value.First().m_craftingStation = null;
				}
				else if (table == CraftingTable.Custom)
				{
					Recipe obj = value.First();
					GameObject prefab = ZNetScene.instance.GetPrefab(customTableValue);
					obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
				}
				else
				{
					value.First().m_craftingStation = ZNetScene.instance.GetPrefab(getInternalName(table)).GetComponent<CraftingStation>();
				}
			}
		}

		private void UpdateCraftConfig(string recipeKey, SerializedRequirements craftRequirements, SerializedRequirements upgradeRequirements)
		{
			if (!Object.op_Implicit((Object)(object)ObjectDB.instance) || !activeRecipes.ContainsKey(this) || !activeRecipes[this].TryGetValue(recipeKey, out List<Recipe> value))
			{
				return;
			}
			foreach (Recipe item in value)
			{
				item.m_resources = SerializedRequirements.toPieceReqs(ObjectDB.instance, craftRequirements, upgradeRequirements);
			}
		}

		internal static void Patch_FejdStartup()
		{
			//IL_107a: Unknown result type (might be due to invalid IL or missing references)
			//IL_107f: Unknown result type (might be due to invalid IL or missing references)
			//IL_2333: Unknown result type (might be due to invalid IL or missing references)
			//IL_2340: Expected O, but got Unknown
			//IL_1143: Unknown result type (might be due to invalid IL or missing references)
			//IL_1146: Unknown result type (might be due to invalid IL or missing references)
			//IL_119c: Expected I4, but got Unknown
			//IL_0c4a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c5c: Expected O, but got Unknown
			//IL_0d1c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d29: Expected O, but got Unknown
			//IL_12d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_12d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_12d5: Invalid comparison between Unknown and I4
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Expected O, but got Unknown
			//IL_12d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_12db: Invalid comparison between Unknown and I4
			//IL_0e7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e99: Expected O, but got Unknown
			//IL_0f29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f45: Expected O, but got Unknown
			//IL_12dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_12e1: Invalid comparison between Unknown and I4
			//IL_0fde: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ffa: Expected O, but got Unknown
			//IL_14dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_14df: Unknown result type (might be due to invalid IL or missing references)
			//IL_14e1: Invalid comparison between Unknown and I4
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ae: Expected O, but got Unknown
			//IL_14e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_14e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_14e9: Invalid comparison between Unknown and I4
			//IL_14eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_14ef: Invalid comparison between Unknown and I4
			//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ea: Expected O, but got Unknown
			//IL_15c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_15c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_15cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_15ce: Invalid comparison between Unknown and I4
			//IL_15d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_15d4: Invalid comparison between Unknown and I4
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0703: Expected O, but got Unknown
			//IL_1643: Unknown result type (might be due to invalid IL or missing references)
			//IL_1646: Unknown result type (might be due to invalid IL or missing references)
			//IL_1648: Invalid comparison between Unknown and I4
			//IL_164a: Unknown result type (might be due to invalid IL or missing references)
			//IL_164e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1650: Invalid comparison between Unknown and I4
			//IL_07cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e3: Expected O, but got Unknown
			//IL_1652: Unknown result type (might be due to invalid IL or missing references)
			//IL_1656: Invalid comparison between Unknown and I4
			//IL_1793: Unknown result type (might be due to invalid IL or missing references)
			//IL_1796: Invalid comparison between Unknown and I4
			//IL_08d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ee: Expected O, but got Unknown
			//IL_1993: Unknown result type (might be due to invalid IL or missing references)
			//IL_199a: Invalid comparison between Unknown and I4
			//IL_1a63: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a68: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a6a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a70: Invalid comparison between Unknown and I4
			//IL_1adf: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ae2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ae4: Invalid comparison between Unknown and I4
			//IL_1709: Unknown result type (might be due to invalid IL or missing references)
			//IL_170e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ae6: Unknown result type (might be due to invalid IL or missing references)
			//IL_1aea: Invalid comparison between Unknown and I4
			//IL_1aec: Unknown result type (might be due to invalid IL or missing references)
			//IL_1af0: Invalid comparison between Unknown and I4
			//IL_1f5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f60: Invalid comparison between Unknown and I4
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			if (DefaultConfigurability != Configurability.Disabled)
			{
				bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
				plugin.Config.SaveOnConfigSet = false;
				foreach (Item item3 in registeredItems.Where((Item i) => i.configurability != Configurability.Disabled))
				{
					Item item = item3;
					string text = (string.IsNullOrEmpty(item.SectionName) ? item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name : item.SectionName);
					string englishName = new Regex("['[\"\\]]").Replace(Localizer.GetTranslation("English", text), "").Trim();
					string localizedName = Localization.instance.Localize(text).Trim();
					int order = 0;
					if ((item.configurability & Configurability.Recipe) != Configurability.Disabled)
					{
						itemCraftConfigs[item] = new Dictionary<string, ItemConfig>();
						foreach (string item4 in item.Recipes.Keys.DefaultIfEmpty(""))
						{
							string configKey = item4;
							string text2 = ((configKey == "") ? "" : (" (" + configKey + ")"));
							if (configKey == "")
							{
								Configurability? configurable = item.Configurable;
								if (configurable.HasValue && item.Crafting.Stations.Count == 0)
								{
									item.Crafting.Add(CraftingTable.Disabled, 1);
								}
							}
							if (!item.Recipes.ContainsKey(configKey) || item.Recipes[configKey].Crafting.Stations.Count <= 0)
							{
								continue;
							}
							ItemConfig itemConfig = (itemCraftConfigs[item][configKey] = new ItemConfig());
							ItemConfig cfg = itemConfig;
							List<ConfigurationManagerAttributes> hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
							ConfigSyncBase.SyncedConfig(englishName, "Crafting Station" + text2, item.Recipes[configKey].Crafting.Stations.First().Table, new ConfigDescription("Crafting station where " + englishName + " is available.", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									Browsable = ((item.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								}
							}), ref cfg.table);
							ConfigurationManagerAttributes customTableAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = CustomTableBrowsability,
								Browsable = (CustomTableBrowsability() && (item.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							ConfigSyncBase.SyncedConfig(englishName, "Custom Crafting Station" + text2, item.Recipes[configKey].Crafting.Stations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }), ref cfg.customTable);
							cfg.table.SettingChanged += TableConfigChanged;
							cfg.customTable.SettingChanged += TableConfigChanged;
							ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = TableLevelBrowsability,
								Browsable = (TableLevelBrowsability() && (item.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							hideWhenNoneAttributes.Add(configurationManagerAttributes);
							ConfigSyncBase.SyncedConfig(englishName, "Crafting Station Level" + text2, item.Recipes[configKey].Crafting.Stations.First().level, new ConfigDescription("Required crafting station level to craft " + englishName + ".", (AcceptableValueBase)null, new object[1] { configurationManagerAttributes }), ref cfg.tableLevel);
							cfg.tableLevel.SettingChanged += delegate
							{
								if (activeRecipes.ContainsKey(item) && activeRecipes[item].TryGetValue(configKey, out List<Recipe> value))
								{
									value.First().m_minStationLevel = cfg.tableLevel.Value;
								}
							};
							if (item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality > 1)
							{
								ConfigSyncBase.SyncedConfig(englishName, "Maximum Crafting Station Level" + text2, (item.MaximumRequiredStationLevel == int.MaxValue) ? (item.Recipes[configKey].Crafting.Stations.First().level + item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality - 1) : item.MaximumRequiredStationLevel, new ConfigDescription("Maximum crafting station level to upgrade and repair " + englishName + ".", (AcceptableValueBase)null, new object[1] { configurationManagerAttributes }), ref cfg.maximumTableLevel);
							}
							ConfigSyncBase.SyncedConfig(englishName, "Require only one resource" + text2, item.Recipes[configKey].RequireOnlyOneIngredient ? Toggle.On : Toggle.Off, new ConfigDescription("Whether only one of the ingredients is needed to craft " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Order = (order -= 1),
									browsability = TableLevelBrowsability,
									Browsable = (TableLevelBrowsability() && (item.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								}
							}), ref cfg.requireOneIngredient);
							ConfigurationManagerAttributes qualityResultAttributes = new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								browsability = QualityResultBrowsability,
								Browsable = (QualityResultBrowsability() && (item.configurationVisible & Configurability.Recipe) != 0),
								Category = localizedName
							};
							cfg.requireOneIngredient.SettingChanged += delegate
							{
								if (activeRecipes.ContainsKey(item) && activeRecipes[item].TryGetValue(configKey, out List<Recipe> value))
								{
									foreach (Recipe item5 in value)
									{
										item5.m_requireOnlyOneIngredient = cfg.requireOneIngredient.Value == Toggle.On;
									}
								}
								qualityResultAttributes.Browsable = QualityResultBrowsability();
								reloadConfigDisplay();
							};
							ConfigSyncBase.SyncedConfig(englishName, "Quality Multiplier" + text2, item.Recipes[configKey].QualityResultAmountMultiplier, new ConfigDescription("Multiplies the crafted amount based on the quality of the resources when crafting " + englishName + ". Only works, if Require Only One Resource is true.", (AcceptableValueBase)null, new object[1] { qualityResultAttributes }), ref cfg.qualityResultAmountMultiplier);
							cfg.qualityResultAmountMultiplier.SettingChanged += delegate
							{
								if (activeRecipes.ContainsKey(item) && activeRecipes[item].TryGetValue(configKey, out List<Recipe> value))
								{
									foreach (Recipe item6 in value)
									{
										item6.m_qualityResultAmountMultiplier = cfg.qualityResultAmountMultiplier.Value;
									}
								}
							};
							if ((!item.Recipes[configKey].RequiredItems.Free || item.Recipes[configKey].RequiredItems.Requirements.Count > 0) && item.Recipes[configKey].RequiredItems.Requirements.All((Requirement r) => r.amountConfig == null))
							{
								cfg.craft = itemConfig3("Crafting Costs" + text2, new SerializedRequirements(item.Recipes[configKey].RequiredItems.Requirements).ToString(), "Item costs to craft " + englishName, isUpgrade: false);
							}
							if (item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality > 1 && (!item.Recipes[configKey].RequiredUpgradeItems.Free || item.Recipes[configKey].RequiredUpgradeItems.Requirements.Count > 0) && item.Recipes[configKey].RequiredUpgradeItems.Requirements.All((Requirement r) => r.amountConfig == null))
							{
								cfg.upgrade = itemConfig3("Upgrading Costs" + text2, new SerializedRequirements(item.Recipes[configKey].RequiredUpgradeItems.Requirements).ToString(), "Item costs per level to upgrade " + englishName, isUpgrade: true);
							}
							if (cfg.craft != null)
							{
								cfg.craft.SettingChanged += ConfigChanged;
							}
							if (cfg.upgrade != null)
							{
								cfg.upgrade.SettingChanged += ConfigChanged;
							}
							void ConfigChanged(object o, EventArgs e)
							{
								item.UpdateCraftConfig(configKey, new SerializedRequirements(cfg.craft?.Value ?? ""), new SerializedRequirements(cfg.upgrade?.Value ?? ""));
							}
							bool CustomTableBrowsability()
							{
								return cfg.table.Value == CraftingTable.Custom;
							}
							bool ItemBrowsability()
							{
								return cfg.table.Value != CraftingTable.Disabled;
							}
							bool QualityResultBrowsability()
							{
								return cfg.requireOneIngredient.Value == Toggle.On;
							}
							void TableConfigChanged(object o, EventArgs e)
							{
								item.UpdateItemTableConfig(configKey, cfg.table.Value, cfg.customTable.Value);
								customTableAttributes.Browsable = cfg.table.Value == CraftingTable.Custom;
								foreach (ConfigurationManagerAttributes item7 in hideWhenNoneAttributes)
								{
									item7.Browsable = cfg.table.Value != CraftingTable.Disabled;
								}
								reloadConfigDisplay();
							}
							bool TableLevelBrowsability()
							{
								return cfg.table.Value != CraftingTable.Disabled;
							}
							ConfigEntry<string> itemConfig3(string name, string value, string desc, bool isUpgrade)
							{
								//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
								//IL_00b6: Expected O, but got Unknown
								ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes
								{
									CustomDrawer = drawRequirementsConfigTable(item, isUpgrade),
									Order = (order -= 1),
									browsability = ItemBrowsability,
									Browsable = (ItemBrowsability() && (item.configurationVisible & Configurability.Recipe) != 0),
									Category = localizedName
								};
								hideWhenNoneAttributes.Add(configurationManagerAttributes2);
								ConfigEntry<string> configEntry3 = null;
								ConfigSyncBase.SyncedConfig(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes2 }), ref configEntry3);
								return configEntry3;
							}
						}
						if ((item.configurability & Configurability.Drop) != Configurability.Disabled)
						{
							ConfigEntry<bool> dropsEnabledConfig = null;
							ConfigSyncBase.SyncedConfig(englishName, "Drops Enabled", value: false, new ConfigDescription("Enables " + englishName + " drops", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item.configurationVisible & Configurability.Drop) != 0)
								}
							}), ref dropsEnabledConfig);
							itemDropEnabledConfig[item] = dropsEnabledConfig;
							ConfigEntry<string> configEntry = null;
							ConfigSyncBase.SyncedConfig(englishName, "Drops from", new SerializedDrop(item.DropsFrom.Drops).ToString(), new ConfigDescription("Creatures " + englishName + " drops from", (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									CustomDrawer = drawDropsConfigTable,
									Category = localizedName,
									Browsable = ((item.configurationVisible & Configurability.Drop) != 0)
								}
							}), ref configEntry);
							itemDropConfigs[item] = configEntry;
							dropsEnabledConfig.SettingChanged += delegate
							{
								item.UpdateCharacterDrop(dropsEnabledConfig.Value);
							};
							configEntry.SettingChanged += delegate
							{
								item.UpdateCharacterDrop(dropsEnabledConfig.Value);
							};
							item.UpdateCharacterDrop(dropsEnabledConfig.Value);
						}
						for (int num = 0; num < item.Conversions.Count; num++)
						{
							string text3 = ((item.Conversions.Count > 1) ? $"{num + 1}. " : "");
							Conversion conversion = item.Conversions[num];
							conversion.config = new Conversion.ConversionConfig();
							int index = num;
							ConfigSyncBase.SyncedConfig(englishName, text3 + "Conversion Input Item", conversion.Input, new ConfigDescription("Input item to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item.configurationVisible & Configurability.Recipe) != 0)
								}
							}), ref conversion.config.input);
							conversion.config.input.SettingChanged += delegate
							{
								if (index < item.conversions.Count)
								{
									ObjectDB instance = ObjectDB.instance;
									if (instance != null)
									{
										ItemDrop val = SerializedRequirements.fetchByName(instance, conversion.config.input.Value);
										item.conversions[index].m_from = val;
										UpdatePiece();
									}
								}
							};
							ConfigSyncBase.SyncedConfig(englishName, text3 + "Conversion Piece", conversion.Piece, new ConfigDescription("Conversion piece used to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item.configurationVisible & Configurability.Recipe) != 0)
								}
							}), ref conversion.config.piece);
							conversion.config.piece.SettingChanged += delegate
							{
								UpdatePiece();
							};
							ConfigSyncBase.SyncedConfig(englishName, text3 + "Conversion Custom Piece", conversion.customPiece ?? "", new ConfigDescription("Custom conversion piece to create " + englishName, (AcceptableValueBase)null, new object[1]
							{
								new ConfigurationManagerAttributes
								{
									Category = localizedName,
									Browsable = ((item.configurationVisible & Configurability.Recipe) != 0)
								}
							}), ref conversion.config.customPiece);
							conversion.config.customPiece.SettingChanged += delegate
							{
								UpdatePiece();
							};
							void UpdatePiece()
							{
								if (index < item.conversions.Count && Object.op_Implicit((Object)(object)ZNetScene.instance))
								{
									string text4 = ((conversion.config.piece.Value == ConversionPiece.Disabled) ? null : ((conversion.config.piece.Value == ConversionPiece.Custom) ? conversion.config.customPiece.Value : getInternalName(conversion.config.piece.Value)));
									string activePiece = conversion.config.activePiece;
									if (conversion.config.activePiece != null)
									{
										int num4 = ZNetScene.instance.GetPrefab(conversion.config.activePiece).GetComponent<Smelter>().m_conversion.IndexOf(item.conversions[index]);
										if (num4 >= 0)
										{
											Smelter[] array3 = Resources.FindObjectsOfTypeAll<Smelter>();
											foreach (Smelter val in array3)
											{
												if (Utils.GetPrefabName(((Component)val).gameObject) == activePiece)
												{
													val.m_conversion.RemoveAt(num4);
												}
											}
										}
										conversion.config.activePiece = null;
									}
									if (item.conversions[index].m_from != null && conversion.config.piece.Value != ConversionPiece.Disabled)
									{
										GameObject prefab = ZNetScene.instance.GetPrefab(text4);
										if (((prefab != null) ? prefab.GetComponent<Smelter>() : null) != null)
										{
											conversion.config.activePiece = text4;
											Smelter[] array3 = Resources.FindObjectsOfTypeAll<Smelter>();
											foreach (Smelter val2 in array3)
											{
												if (Utils.GetPrefabName(((Component)val2).gameObject) == text4)
												{
													val2.m_conversion.Add(item.conversions[index]);
												}
											}
										}
									}
								}
							}
						}
					}
					if ((item.configurability & Configurability.Stats) != Configurability.Disabled)
					{
						item.statsConfigs.Clear();
						SharedData shared = item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
						ItemType itemType = shared.m_itemType;
						statcfg<float>("Weight", "Weight of " + englishName + ".", (SharedData val) => val.m_weight, delegate(SharedData val, float value)
						{
							val.m_weight = value;
						});
						statcfg<int>("Trader Value", "Trader value of " + englishName + ".", (SharedData val) => val.m_value, delegate(SharedData val, int value)
						{
							val.m_value = value;
						});
						bool flag;
						switch (itemType - 3)
						{
						case 0:
						case 1:
						case 2:
						case 3:
						case 4:
						case 8:
						case 9:
						case 11:
						case 14:
						case 16:
						case 19:
							flag = true;
							break;
						default:
							flag = false;
							break;
						}
						if (flag)
						{
							statcfg<float>("Durability", "Durability of " + englishName + ".", (SharedData val) => val.m_maxDurability, delegate(SharedData val, float value)
							{
								val.m_maxDurability = value;
							});
							statcfg<float>("Durability per Level", "Durability gain per level of " + englishName + ".", (SharedData val) => val.m_durabilityPerLevel, delegate(SharedData val, float value)
							{
								val.m_durabilityPerLevel = value;
							});
							statcfg<float>("Movement Speed Modifier", "Movement speed modifier of " + englishName + ".", (SharedData val) => val.m_movementModifier, delegate(SharedData val, float value)
							{
								val.m_movementModifier = value;
							});
						}
						if ((itemType - 3 <= 2 || (int)itemType == 14 || (int)itemType == 22) ? true : false)
						{
							statcfg<float>("Block Armor", "Block armor of " + englishName + ".", (SharedData val) => val.m_blockPower, delegate(SharedData val, float value)
							{
								val.m_blockPower = value;
							});
							statcfg<float>("Block Armor per Level", "Block armor per level for " + englishName + ".", (SharedData val) => val.m_blockPowerPerLevel, delegate(SharedData val, float value)
							{
								val.m_blockPowerPerLevel = value;
							});
							statcfg<float>("Block Force", "Block force of " + englishName + ".", (SharedData val) => val.m_deflectionForce, delegate(SharedData val, float value)
							{
								val.m_deflectionForce = value;
							});
							statcfg<float>("Block Force per Level", "Block force per level for " + englishName + ".", (SharedData val) => val.m_deflectionForcePerLevel, delegate(SharedData val, float value)
							{
								val.m_deflectionForcePerLevel = value;
							});
							statcfg<float>("Parry Bonus", "Parry bonus of " + englishName + ".", (SharedData val) => val.m_timedBlockBonus, delegate(SharedData val, float value)
							{
								val.m_timedBlockBonus = value;
							});
						}
						else if ((itemType - 6 <= 1 || itemType - 11 <= 1 || (int)itemType == 17) ? true : false)
						{
							statcfg<float>("Armor", "Armor of " + englishName + ".", (SharedData val) => val.m_armor, delegate(SharedData val, float value)
							{
								val.m_armor = value;
							});
							statcfg<float>("Armor per Level", "Armor per level for " + englishName + ".", (SharedData val) => val.m_armorPerLevel, delegate(SharedData val, float value)
							{
								val.m_armorPerLevel = value;
							});
						}
						SkillType skillType = shared.m_skillType;
						if (((int)skillType == 7 || (int)skillType == 12) ? true : false)
						{
							statcfg<int>("Tool tier", "Tool tier of " + englishName + ".", (SharedData val) => val.m_toolTier, delegate(SharedData val, int value)
							{
								val.m_toolTier = value;
							});
						}
						if ((itemType - 5 <= 2 || itemType - 11 <= 1 || (int)itemType == 17) ? true : false)
						{
							Dictionary<DamageType, DamageModifier> modifiers = shared.m_damageModifiers.ToDictionary((DamageModPair d) => d.m_type, (DamageModPair d) => (DamageModifier)d.m_modifier);
							DamageType[] first = (DamageType[])Enum.GetValues(typeof(DamageType));
							DamageType[] array = new DamageType[5];
							RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
							foreach (DamageType damageType in first.Except((IEnumerable<DamageType>)(object)array))
							{
								statcfg<DamageModifier>(((object)Unsafe.As<DamageType, DamageType>(ref damageType)/*cast due to .constrained prefix*/).ToString() + " Resistance", ((object)Unsafe.As<DamageType, DamageType>(ref damageType)/*cast due to .constrained prefix*/).ToString() + " resistance of " + englishName + ".", (SharedData _) => (!modifiers.TryGetValue(damageType, out var value)) ? DamageModifier.None : value, delegate(SharedData val2, DamageModifier value)
								{
									//IL_0002: Unknown result type (might be due to invalid IL or missing references)
									//IL_000b: Unknown result type (might be due to invalid IL or missing references)
									//IL_0010: Unknown result type (might be due to invalid IL or missing references)
									//IL_0018: Unknown result type (might be due to invalid IL or missing references)
									//IL_001d: Unknown result type (might be due to invalid IL or missing references)
									//IL_001e: Unknown result type (might be due to invalid IL or missing references)
									//IL_002a: Unknown result type (might be due to invalid IL or missing references)
									//IL_002f: Unknown result type (might be due to invalid IL or missing references)
									//IL_0035: Unknown result type (might be due to invalid IL or missing references)
									//IL_0077: Unknown result type (might be due to invalid IL or missing references)
									//IL_0054: Unknown result type (might be due to invalid IL or missing references)
									DamageModPair val = new DamageModPair
									{
										m_type = damageType,
										m_modifier = (DamageModifier)value
									};
									for (int i = 0; i < val2.m_damageModifiers.Count; i++)
									{
										if (val2.m_damageModifiers[i].m_type == damageType)
										{
											if (value == DamageModifier.None)
											{
												val2.m_damageModifiers.RemoveAt(i);
											}
											else
											{
												val2.m_damageModifiers[i] = val;
											}
											return;
										}
									}
									if (value != DamageModifier.None)
									{
										val2.m_damageModifiers.Add(val);
									}
								});
							}
						}
						if ((int)itemType == 2 && shared.m_food > 0f)
						{
							statcfg<float>("Health", "Health value of " + englishName + ".", (SharedData val) => val.m_food, delegate(SharedData val, float value)
							{
								val.m_food = value;
							});
							statcfg<float>("Stamina", "Stamina value of " + englishName + ".", (SharedData val) => val.m_foodStamina, delegate(SharedData val, float value)
							{
								val.m_foodStamina = value;
							});
							statcfg<float>("Eitr", "Eitr value of " + englishName + ".", (SharedData val) => val.m_foodEitr, delegate(SharedData val, float value)
							{
								val.m_foodEitr = value;
							});
							statcfg<float>("Duration", "Duration of " + englishName + ".", (SharedData val) => val.m_foodBurnTime, delegate(SharedData val, float value)
							{
								val.m_foodBurnTime = value;
							});
							statcfg<float>("Health Regen", "Health regen value of " + englishName + ".", (SharedData val) => val.m_foodRegen, delegate(SharedData val, float value)
							{
								val.m_foodRegen = value;
							});
						}
						if ((int)shared.m_skillType == 10)
						{
							statcfg<float>("Health Cost", "Health cost of " + englishName + ".", (SharedData val) => val.m_attack.m_attackHealth, delegate(SharedData val, float value)
							{
								val.m_attack.m_attackHealth = value;
							});
							statcfg<float>("Health Cost Percentage", "Health cost percentage of " + englishName + ".", (SharedData val) => val.m_attack.m_attackHealthPercentage, delegate(SharedData val, float value)
							{
								val.m_attack.m_attackHealthPercentage = value;
							});
						}
						skillType = shared.m_skillType;
						if (skillType - 9 <= 1)
						{
							statcfg<float>("Eitr Cost", "Eitr cost of " + englishName + ".", (SharedData val) => val.m_attack.m_attackEitr, delegate(SharedData val, float value)
							{
								val.m_attack.m_attackEitr = value;
							});
						}
						if ((itemType - 3 <= 1 || (int)itemType == 14 || (int)itemType == 22) ? true : false)
						{
							statcfg<float>("Knockback", "Knockback of " + englishName + ".", (SharedData val) => val.m_attackForce, delegate(SharedData val, float value)
							{
								val.m_attackForce = value;
							});
							statcfg<float>("Backstab Bonus", "Backstab bonus of " + englishName + ".", (SharedData val) => val.m_backstabBonus, delegate(SharedData val, float value)
							{
								val.m_backstabBonus = value;
							});
							statcfg<float>("Attack Stamina", "Attack stamina of " + englishName + ".", (SharedData val) => val.m_attack.m_attackStamina, delegate(SharedData val, float value)
							{
								val.m_attack.m_attackStamina = value;
							});
							SetDmg("True", (DamageTypes dmg) => dmg.m_damage, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_damage = val;
							});
							SetDmg("Slash", (DamageTypes dmg) => dmg.m_slash, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_slash = val;
							});
							SetDmg("Pierce", (DamageTypes dmg) => dmg.m_pierce, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_pierce = val;
							});
							SetDmg("Blunt", (DamageTypes dmg) => dmg.m_blunt, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_blunt = val;
							});
							SetDmg("Chop", (DamageTypes dmg) => dmg.m_chop, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_chop = val;
							});
							SetDmg("Pickaxe", (DamageTypes dmg) => dmg.m_pickaxe, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_pickaxe = val;
							});
							SetDmg("Fire", (DamageTypes dmg) => dmg.m_fire, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_fire = val;
							});
							SetDmg("Poison", (DamageTypes dmg) => dmg.m_poison, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_poison = val;
							});
							SetDmg("Frost", (DamageTypes dmg) => dmg.m_frost, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_frost = val;
							});
							SetDmg("Lightning", (DamageTypes dmg) => dmg.m_lightning, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_lightning = val;
							});
							SetDmg("Spirit", (DamageTypes dmg) => dmg.m_spirit, delegate(ref DamageTypes dmg, float val)
							{
								dmg.m_spirit = val;
							});
							if ((int)itemType == 4)
							{
								statcfg<int>("Projectiles", "Number of projectiles that " + englishName + " shoots at once.", (SharedData val) => val.m_attack.m_projectileBursts, delegate(SharedData val, int value)
								{
									val.m_attack.m_projectileBursts = value;
								});
								statcfg<float>("Burst Interval", "Time between the projectiles " + englishName + " shoots at once.", (SharedData val) => val.m_attack.m_burstInterval, delegate(SharedData val, float value)
								{
									val.m_attack.m_burstInterval = value;
								});
								statcfg<float>("Minimum Accuracy", "Minimum accuracy for " + englishName + ".", (SharedData val) => val.m_attack.m_projectileAccuracyMin, delegate(SharedData val, float value)
								{
									val.m_attack.m_projectileAccuracyMin = value;
								});
								statcfg<float>("Accuracy", "Accuracy for " + englishName + ".", (SharedData val) => val.m_attack.m_projectileAccuracy, delegate(SharedData val, float value)
								{
									val.m_attack.m_projectileAccuracy = value;
								});
								statcfg<float>("Minimum Velocity", "Minimum velocity for " + englishName + ".", (SharedData val) => val.m_attack.m_projectileVelMin, delegate(SharedData val, float value)
								{
									val.m_attack.m_projectileVelMin = value;
								});
								statcfg<float>("Velocity", "Velocity for " + englishName + ".", (SharedData val) => val.m_attack.m_projectileVel, delegate(SharedData val, float value)
								{
									val.m_attack.m_projectileVel = value;
								});
								statcfg<float>("Maximum Draw Time", "Time until " + englishName + " is fully drawn at skill level 0.", (SharedData val) => val.m_attack.m_drawDurationMin, delegate(SharedData val, float value)
								{
									val.m_attack.m_drawDurationMin = value;
								});
								statcfg<float>("Stamina Drain", "Stamina drain per second while drawing " + englishName + ".", (SharedData val) => val.m_attack.m_drawStaminaDrain, delegate(SharedData val, float value)
								{
									val.m_attack.m_drawStaminaDrain = value;
								});
							}
						}
					}
					List<ConfigurationManagerAttributes> traderAttributes;
					if ((item.configurability & Configurability.Trader) != Configurability.Disabled)
					{
						traderAttributes = new List<ConfigurationManagerAttributes>();
						ConfigEntry<Trader> configEntry2 = null;
						ConfigSyncBase.SyncedConfig(englishName, "Trader Selling", item.Trade.Trader, new ConfigDescription("Which traders sell " + englishName + ".", (AcceptableValueBase)null, new object[1]
						{
							new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								Browsable = ((item.configurationVisible & Configurability.Trader) != 0),
								Category = localizedName
							}
						}), ref configEntry2);
						item.traderConfig = new TraderConfig
						{
							trader = configEntry2
						};
						item.traderConfig.trader.SettingChanged += delegate
						{
							item.ReloadTraderConfiguration();
							foreach (ConfigurationManagerAttributes item8 in traderAttributes)
							{
								item8.Browsable = TraderBrowsability();
							}
							reloadConfigDisplay();
						};
						item.traderConfig.price = traderConfig<uint>("Trader Price", item.Trade.Price, "Price of " + englishName + " at the trader.");
						item.traderConfig.stack = traderConfig<uint>("Trader Stack", item.Trade.Stack, "Stack size of " + englishName + " in the trader. Also known as the number of items sold by a trader in one transaction.");
						item.traderConfig.requiredGlobalKey = traderConfig<string>("Trader Required Global Key", item.Trade.RequiredGlobalKey ?? "", "Required global key to unlock " + englishName + " at the trader.");
						if (item.traderConfig.trader.Value != Trader.None)
						{
							PrefabManager.AddItemToTrader(item.Prefab, item.traderConfig.trader.Value, item.traderConfig.price.Value, item.traderConfig.stack.Value, item.traderConfig.requiredGlobalKey.Value);
						}
					}
					else if (item.Trade.Trader != Trader.None)
					{
						PrefabManager.AddItemToTrader(item.Prefab, item.Trade.Trader, item.Trade.Price, item.Trade.Stack, item.Trade.RequiredGlobalKey);
					}
					void SetDmg(string dmgType, Func<DamageTypes, float> readDmg, setDmgFunc setDmg)
					{
						statcfg<float>(dmgType + " Damage", dmgType + " damage dealt by " + englishName + ".", (SharedData val) => readDmg(val.m_damages), delegate(SharedData val2, float val)
						{
							setDmg(ref val2.m_damages, val);
						});
						statcfg<float>(dmgType + " Damage Per Level", dmgType + " damage dealt increase per level for " + englishName + ".", (SharedData val) => readDmg(val.m_damagesPerLevel), delegate(SharedData val2, float val)
						{
							setDmg(ref val2.m_damagesPerLevel, val);
						});
					}
					bool TraderBrowsability()
					{
						return item.traderConfig.trader.Value != Trader.None;
					}
					void statcfg<T>(string configName, string description, Func<SharedData, T> readDefault, Action<SharedData, T> setValue) where T : notnull
					{
						//IL_007e: Unknown result type (might be due to invalid IL or missing references)
						//IL_008f: Expected O, but got Unknown
						SharedData shared2 = item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
						ConfigEntry<T> cfg2 = null;
						ConfigSyncBase.SyncedConfig(englishName, configName, readDefault(shared2), new ConfigDescription(description, (AcceptableValueBase)null, new object[1]
						{
							new ConfigurationManagerAttributes
							{
								Category = localizedName,
								Browsable = ((item.configurationVisible & Configurability.Stats) != 0)
							}
						}), ref cfg2);
						if ((item.configurationVisible & Configurability.Stats) != Configurability.Disabled)
						{
							setValue(shared2, cfg2.Value);
						}
						item.statsConfigs.Add((ConfigEntryBase)(object)cfg2, ApplyConfig);
						cfg2.SettingChanged += delegate
						{
							if ((item.configurationVisible & Configurability.Stats) != Configurability.Disabled)
							{
								ApplyConfig();
							}
						};
						void ApplyConfig()
						{
							item.ApplyToAllInstances(delegate(ItemData val)
							{
								setValue(val.m_shared, cfg2.Value);
							});
						}
					}
					ConfigEntry<T> traderConfig<T>(string name, T value, string desc) where T : notnull
					{
						//IL_009b: Unknown result type (might be due to invalid IL or missing references)
						//IL_00a8: Expected O, but got Unknown
						ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes
						{
							Order = (order -= 1),
							browsability = TraderBrowsability,
							Browsable = (TraderBrowsability() && (item.configurationVisible & Configurability.Trader) != 0),
							Category = localizedName
						};
						traderAttributes.Add(configurationManagerAttributes2);
						ConfigEntry<T> configEntry3 = null;
						ConfigSyncBase.SyncedConfig(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes2 }), ref configEntry3);
						configEntry3.SettingChanged += delegate
						{
							item.ReloadTraderConfiguration();
						};
						return configEntry3;
					}
				}
				if (saveOnConfigSet)
				{
					plugin.Config.SaveOnConfigSet = true;
					plugin.Config.Save();
				}
			}
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			foreach (Item registeredItem in registeredItems)
			{
				Item item2 = registeredItem;
				foreach (KeyValuePair<string, ItemRecipe> recipe in item2.Recipes)
				{
					KeyValuePair<string, ItemRecipe> kv = recipe;
					RequiredResourceList[] array2 = new RequiredResourceList[2]
					{
						kv.Value.RequiredItems,
						kv.Value.RequiredUpgradeItems
					};
					foreach (RequiredResourceList requiredResourceList in array2)
					{
						for (int num3 = 0; num3 < requiredResourceList.Requirements.Count; num3++)
						{
							ConfigEntry<int> amountCfg;
							int resourceIndex;
							if ((item2.configurability & Configurability.Recipe) != Configurability.Disabled)
							{
								amountCfg = requiredResourceList.Requirements[num3].amountConfig;
								if (amountCfg != null)
								{
									resourceIndex = num3;
									amountCfg.SettingChanged += ConfigChanged2;
								}
							}
							void ConfigChanged2(object o, EventArgs e)
							{
								if (Object.op_Implicit((Object)(object)ObjectDB.instance) && activeRecipes.ContainsKey(item2) && activeRecipes[item2].TryGetValue(kv.Key, out List<Recipe> value))
								{
									foreach (Recipe item9 in value)
									{
										item9.m_resources[resourceIndex].m_amount = amountCfg.Value;
									}
								}
							}
						}
					}
				}
				item2.InitializeNewRegisteredItem();
			}
		}

		private void InitializeNewRegisteredItem()
		{
			foreach (KeyValuePair<string, ItemRecipe> recipe in Recipes)
			{
				KeyValuePair<string, ItemRecipe> kv = recipe;
				ConfigEntryBase enabledCfg = kv.Value.RecipeIsActive;
				if (enabledCfg != null)
				{
					((object)enabledCfg).GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
				}
				void ConfigChanged(object o, EventArgs e)
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance) && activeRecipes.ContainsKey(this) && activeRecipes[this].TryGetValue(kv.Key, out List<Recipe> value))
					{
						foreach (Recipe item in value)
						{
							item.m_enabled = (int)enabledCfg.BoxedValue != 0;
						}
					}
				}
			}
		}

		public void ReloadCraftingConfiguration()
		{
			if (Object.op_Implicit((Object)(object)ObjectDB.instance) && ObjectDB.instance.GetItemPrefab(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name)) == null)
			{
				registerRecipesInObjectDB(ObjectDB.instance);
				ObjectDB.instance.m_items.Add(Prefab);
				ObjectDB.instance.m_itemByHash.Add(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name), Prefab);
				ZNetScene.instance.m_prefabs.Add(Prefab);
				ZNetScene.instance.m_namedPrefabs.Add(StringExtensionMethods.GetStableHashCode(((Object)Prefab).name), Prefab);
			}
			foreach (string item in Recipes.Keys.DefaultIfEmpty(""))
			{
				if (Recipes.TryGetValue(item, out ItemRecipe value) && value.Crafting.Stations.Count > 0)
				{
					UpdateItemTableConfig(item, value.Crafting.Stations.First().Table, value.Crafting.Stations.First().custom ?? "");
					UpdateCraftConfig(item, new SerializedRequirements(value.RequiredItems.Requirements), new SerializedRequirements(value.RequiredUpgradeItems.Requirements));
				}
			}
		}

		private void ReloadTraderConfiguration()
		{
			if (traderConfig.trader.Value == Trader.None)
			{
				PrefabManager.RemoveItemFromTrader(Prefab);
			}
			else
			{
				PrefabManager.AddItemToTrader(Prefab, traderConfig.trader.Value, traderConfig.price.Value, traderConfig.stack.Value, traderConfig.requiredGlobalKey.Value);
			}
		}

		public static void ApplyToAllInstances(GameObject prefab, Action<ItemData> callback)
		{
			callback(prefab.GetComponent<ItemDrop>().m_itemData);
			string name = prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_name;
			Inventory[] source = (from c in Player.s_players.Select((Player p) => ((Humanoid)p).GetInventory()).Concat(from c in Object.FindObjectsByType<Container>((FindObjectsInactive)1, (FindObjectsSortMode)1)
					select c.GetInventory())
				where c != null
				select c).ToArray();
			foreach (ItemData item in (from i in (from p in ObjectDB.instance.m_items
					select p.GetComponent<ItemDrop>() into c
					where Object.op_Implicit((Object)(object)c) && Object.op_Implicit((Object)(object)((Component)c).GetComponent<ZNetView>())
					select c).Concat(ItemDrop.s_instances)
				select i.m_itemData).Concat(source.SelectMany((Inventory i) => i.GetAllItems())))
			{
				if (item.m_shared.m_name == name)
				{
					callback(item);
				}
			}
		}

		public void ApplyToAllInstances(Action<ItemData> callback)
		{
			ApplyToAllInstances(Prefab, callback);
		}

		private static string getInternalName<T>(T value) where T : struct
		{
			return ((InternalName)typeof(T).GetMember(value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName;
		}

		private void registerRecipesInObjectDB(ObjectDB objectDB)
		{
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Expected O, but got Unknown
			activeRecipes[this] = new Dictionary<string, List<Recipe>>();
			itemCraftConfigs.TryGetValue(this, out Dictionary<string, ItemConfig> value);
			foreach (KeyValuePair<string, ItemRecipe> recipe in Recipes)
			{
				List<Recipe> list = new List<Recipe>();
				foreach (CraftingStationConfig station in recipe.Value.Crafting.Stations)
				{
					ItemConfig itemConfig = value?[recipe.Key];
					Recipe val = ScriptableObject.CreateInstance<Recipe>();
					string name = ((Object)Prefab).name;
					CraftingTable table = station.Table;
					((Object)val).name = name + "_Recipe_" + table;
					val.m_amount = recipe.Value.CraftAmount;
					ConfigEntryBase? recipeIsActive = recipe.Value.RecipeIsActive;
					val.m_enabled = (int)(((recipeIsActive != null) ? recipeIsActive.BoxedValue : null) ?? ((object)1)) != 0 && (itemConfig == null || itemConfig.table.Value != CraftingTable.Disabled);
					val.m_item = Prefab.GetComponent<ItemDrop>();
					val.m_resources = SerializedRequirements.toPieceReqs(objectDB, (itemConfig?.craft == null) ? new SerializedRequirements(recipe.Value.RequiredItems.Requirements) : new SerializedRequirements(itemConfig.craft.Value), (itemConfig?.upgrade == null) ? new SerializedRequirements(recipe.Value.RequiredUpgradeItems.Requirements) : new SerializedRequirements(itemConfig.upgrade.Value));
					table = ((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value);
					if ((uint)table <= 1u)
					{
						val.m_craftingStation = null;
					}
					else if (((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value) == CraftingTable.Custom)
					{
						GameObject prefab = ZNetScene.instance.GetPrefab((itemConfig == null || list.Count > 0) ? station.custom : itemConfig.customTable.Value);
						if (prefab != null)
						{
							val.m_craftingStation = prefab.GetComponent<CraftingStation>();
						}
						else
						{
							Debug.LogWarning((object)("Custom crafting station '" + ((itemConfig == null || list.Count > 0) ? station.custom : itemConfig.customTable.Value) + "' does not exist"));
						}
					}
					else
					{
						val.m_craftingStation = ZNetScene.instance.GetPrefab(getInternalName((itemConfig == null || list.Count > 0) ? station.Table : itemConfig.table.Value)).GetComponent<CraftingStation>();
					}
					val.m_minStationLevel = ((itemConfig == null || list.Count > 0) ? station.level : itemConfig.tableLevel.Value);
					val.m_requireOnlyOneIngredient = ((itemConfig == null) ? recipe.Value.RequireOnlyOneIngredient : (itemConfig.requireOneIngredient.Value == Toggle.On));
					val.m_qualityResultAmountMultiplier = itemConfig?.qualityResultAmountMultiplier.Value ?? recipe.Value.QualityResultAmountMultiplier;
					list.Add(val);
					RequiredResourceList requiredItems;
					if (station.Table != CraftingTable.Disabled)
					{
						requiredItems = recipe.Value.RequiredItems;
						if (requiredItems != null && !requiredItems.Free)
						{
							List<Requirement> requirements = requiredItems.Requirements;
							if (requirements != null && requirements.Count == 0)
							{
								hiddenCraftRecipes.Add(val, recipe.Value.RecipeIsActive);
							}
						}
					}
					requiredItems = recipe.Value.RequiredUpgradeItems;
					if (requiredItems != null && !requiredItems.Free)
					{
						List<Requirement> requirements = requiredItems.Requirements;
						if (requirements != null && requirements.Count == 0)
						{
							hiddenUpgradeRecipes.Add(val, recipe.Value.RecipeIsActive);
						}
					}
				}
				activeRecipes[this].Add(recipe.Key, list);
				objectDB.m_recipes.AddRange(list);
			}
			conversions = new List<ItemConversion>();
			for (int i = 0; i < Conversions.Count; i++)
			{
				Conversion conversion = Conversions[i];
				conversions.Add(new ItemConversion
				{
					m_from = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.input.Value ?? conversion.Input),
					m_to = Prefab.GetComponent<ItemDrop>()
				});
				ConversionPiece conversionPiece = conversion.config?.piece.Value ?? conversion.Piece;
				string text = null;
				if (conversionPiece != ConversionPiece.Disabled && conversions[i].m_from != null)
				{
					text = ((conversionPiece != ConversionPiece.Custom) ? getInternalName(conversionPiece) : (conversion.config?.customPiece.Value ?? conversion.customPiece));
					GameObject prefab2 = ZNetScene.instance.GetPrefab(text);
					Smelter val2 = ((prefab2 != null) ? prefab2.GetComponent<Smelter>() : null);
					if (val2 != null)
					{
						val2.m_conversion.Add(conversions[i]);
					}
					else
					{
						text = null;
					}
				}
				if (conversion.config != null)
				{
					conversion.config.activePiece = text;
				}
			}
		}

		[HarmonyPriority(0)]
		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			if ((Object)(object)__instance.GetItemPrefab("Wood") == (Object)null)
			{
				return;
			}
			hiddenCraftRecipes.Clear();
			hiddenUpgradeRecipes.Clear();
			foreach (Item registeredItem in registeredItems)
			{
				registeredItem.registerRecipesInObjectDB(__instance);
			}
		}

		internal static void Patch_TraderGetAvailableItems(Trader __instance, ref List<TradeItem> __result)
		{
			string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
			Trader trader = ((prefabName == "Haldor") ? Trader.Haldor : ((prefabName == "Hildir") ? Trader.Hildir : Trader.None));
			Trader trader2 = trader;
			__result.AddRange(from tuple in PrefabManager.CustomTradeItems.Values
				where (tuple.Item1 & trader2) != 0
				select tuple.Item2 into tradeItem
				where string.IsNullOrEmpty(tradeItem.m_requiredGlobalKey) || ZoneSystem.instance.GetGlobalKey(tradeItem.m_requiredGlobalKey)
				select tradeItem);
		}

		internal static void Patch_OnAddSmelterInput(ItemData item, bool __result)
		{
			if (__result)
			{
				((Humanoid)Player.m_localPlayer).UnequipItem(item, true);
			}
		}

		internal static void Patch_MaximumRequiredStationLevel(Recipe __instance, ref int __result, int quality)
		{
			if (!itemDropMap.TryGetValue(__instance.m_item, out Item value))
			{
				return;
			}
			IEnumerable<ItemConfig> source;
			if (!itemCraftConfigs.TryGetValue(value, out Dictionary<string, ItemConfig> value2))
			{
				source = Enumerable.Empty<ItemConfig>();
			}
			else
			{
				CraftingStation currentCraftingStation = Player.m_localPlayer.GetCurrentCraftingStation();
				if (currentCraftingStation != null)
				{
					string stationName = Utils.GetPrefabName(((Component)currentCraftingStation).gameObject);
					source = from c in value2.Where(delegate(KeyValuePair<string, ItemConfig> c)
						{
							switch (c.Value.table.Value)
							{
							case CraftingTable.Disabled:
							case CraftingTable.Inventory:
								return false;
							case CraftingTable.Custom:
								return c.Value.customTable.Value == stationName;
							default:
								return getInternalName(c.Value.table.Value) == stationName;
							}
						})
						select c.Value;
				}
				else
				{
					source = value2.Values;
				}
			}
			__result = Mathf.Min(Mathf.Max(1, __instance.m_minStationLevel) + (quality - 1), (from cfg in source
				where cfg.maximumTableLevel != null
				select cfg.maximumTableLevel.Value).DefaultIfEmpty(value.MaximumRequiredStationLevel).Max());
		}

		internal static void Patch_GetAvailableRecipesPrefix(ref Dictionary<Assembly, List<Recipe>>? __state)
		{
			if (__state == null)
			{
				__state = new Dictionary<Assembly, List<Recipe>>();
			}
			Dictionary<Recipe, ConfigEntryBase> source;
			if (InventoryGui.instance.InCraftTab())
			{
				source = hiddenCraftRecipes;
			}
			else
			{
				if (!InventoryGui.instance.InUpradeTab())
				{
					return;
				}
				source = hiddenUpgradeRecipes;
			}
			List<Recipe> list = (from kv in source
				select kv.Key into r
				where r.m_enabled
				select r).ToList();
			__state[Assembly.GetExecutingAssembly()] = list;
			foreach (Recipe item in list)
			{
				item.m_enabled = false;
			}
		}

		internal static void Patch_GetAvailableRecipesFinalizer(Dictionary<Assembly, List<Recipe>> __state)
		{
			if (!__state.TryGetValue(Assembly.GetExecutingAssembly(), out List<Recipe> value))
			{
				return;
			}
			foreach (Recipe item in value)
			{
				item.m_enabled = true;
			}
		}

		internal static IEnumerable<CodeInstruction> Transpile_SetupRequirementList(IEnumerable<CodeInstruction> instructionsEnumerable, ILGenerator ilg)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			List<CodeInstruction> list = instructionsEnumerable.ToList();
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(InventoryGui), "SetupRequirement", (Type[])null, (Type[])null);
			CodeInstruction val = null;
			CodeInstruction val2 = null;
			LocalBuilder localBuilder = ilg.DeclareLocal(typeof(int));
			Dictionary<Label, int> dictionary = new Dictionary<Label, int>();
			bool flag = false;
			int num = 0;
			int value = 0;
			Label? label = default(Label?);
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					val = list[i + 2];
					val2 = list[i + 5];
					flag = true;
				}
				if (flag)
				{
					if (CodeInstructionExtensions.Branches(list[i], ref label) && dictionary.TryGetValue(label.Value, out value))
					{
						num = i;
						break;
					}
					continue;
				}
				foreach (Label label4 in list[i].labels)
				{
					dictionary[label4] = i;
				}
			}
			if (list[value - 3].opcode == OpCodes.Dup)
			{
				return list;
			}
			Label label2 = ilg.DefineLabel();
			Label label3 = ilg.DefineLabel();
			list[num + 1].labels.Add(label2);
			list.InsertRange(num + 1, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[11]
			{
				new CodeInstruction(OpCodes.Ldloc, (object)localBuilder),
				new CodeInstruction(OpCodes.Brfalse, (object)label2),
				val.Clone(),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.DeclaredField(typeof(InventoryGui), "m_recipeRequirementList")),
				new CodeInstruction(OpCodes.Ldlen, (object)null),
				new CodeInstruction(OpCodes.Bgt, (object)label2),
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
				val2.Clone(),
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
				new CodeInstruction(OpCodes.Br, (object)label3)
			});
			list.InsertRange(value - 2, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Dup, (object)null)
				{
					labels = new List<Label> { label3 }
				},
				new CodeInstruction(OpCodes.Stloc, (object)localBuilder)
			});
			return list;
		}

		internal static bool Patch_RequirementGetAmount(Requirement __instance, int qualityLevel, ref int __result)
		{
			if (requirementQuality.TryGetValue(__instance, out RequirementQuality value))
			{
				__result = ((value.quality == qualityLevel) ? __instance.m_amountPerLevel : 0);
				return false;
			}
			return true;
		}

		internal static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (Item registeredItem in registeredItems)
			{
				if (itemDropEnabledConfig.ContainsKey(registeredItem))
				{
					registeredItem.AssignDropToCreature(itemDropEnabledConfig[registeredItem].Value);
				}
			}
		}

		public void AssignDropToCreature(bool enabled = true)
		{
			characterDrops.Clear();
			SerializedDrop serializedDrop = new SerializedDrop(DropsFrom.Drops);
			if (itemDropConfigs.TryGetValue(this, out ConfigEntry<string> value))
			{
				serializedDrop = new SerializedDrop(value.Value);
			}
			foreach (KeyValuePair<Character, Drop> item in serializedDrop.toCharacterDrops(ZNetScene.s_instance, Prefab))
			{
				LogManager.Log.Debug($"Logging Backpack Configured Drops for Character: {item.Key}");
				Log(item.Key, item.Value);
				CharacterDrop val = ((Component)item.Key).GetComponent<CharacterDrop>();
				if (val == null)
				{
					val = ((Component)item.Key).gameObject.AddComponent<CharacterDrop>();
				}
				LogManager.Log.Debug($"Logging Drops for Character Before Add: {item.Key}");
				foreach (Drop drop in val.m_drops)
				{
					Log(item.Key, drop);
				}
				LogManager.Log.Debug($"Drops for {((Object)Prefab).name} are Enabled: {enabled}");
				if (enabled)
				{
					val.m_drops.Add(item.Value);
					characterDrops.Add(val, item.Value);
				}
				LogManager.Log.Debug($"Logging Drops for Character After Add: {item.Key}");
				foreach (Drop drop2 in val.m_drops)
				{
					Log(item.Key, drop2);
				}
			}
			static void Log(Character character, Drop drop)
			{
				LogManager.Log.Debug($"Character: {character.m_name} - Drop: {((Object)drop.m_prefab).name} - Amount: {drop.m_amountMin} - Chance: {drop.m_chance}");
			}
		}

		public void UpdateCharacterDrop(bool enabled = true)
		{
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				return;
			}
			foreach (KeyValuePair<CharacterDrop, Drop> characterDrop in characterDrops)
			{
				if (!Object.op_Implicit((Object)(object)characterDrop.Key))
				{
					continue;
				}
				LogManager.Log.Debug($"Logging Drops for Character Before Remove: {characterDrop.Key}");
				foreach (Drop drop in characterDrop.Key.m_drops)
				{
					Log(((object)characterDrop.Key).ToString(), drop);
				}
				characterDrop.Key.m_drops.Remove(characterDrop.Value);
				LogManager.Log.Debug($"Logging Drops for Character After Remove: {characterDrop.Key}");
				foreach (Drop drop2 in characterDrop.Key.m_drops)
				{
					Log(((object)characterDrop.Key).ToString(), drop2);
				}
			}
			if (enabled)
			{
				AssignDropToCreature();
			}
			static void Log(string character, Drop drop)
			{
				LogManager.Log.Debug($"Character: {character} - Drop: {((Object)drop.m_prefab).name} - Amount: {drop.m_amountMin} - Chance: {drop.m_chance}");
			}
		}

		public void Snapshot(float lightIntensity = 1.3f, Quaternion? cameraRotation = null, Quaternion? itemRotation = null)
		{
			SnapshotItem(Prefab.GetComponent<ItemDrop>(), lightIntensity, cameraRotation, itemRotation);
		}

		public static void SnapshotItem(ItemDrop item, float lightIntensity = 1.3f, Quaternion? cameraRotation = null, Quaternion? itemRotation = null)
		{
			if (Object.op_Implicit((Object)(object)ObjectDB.instance))
			{
				Do();
			}
			else
			{
				((MonoBehaviour)plugin).StartCoroutine(Delay());
			}
			IEnumerator Delay()
			{
				yield return null;
				Do();
			}
			void Do()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0277: Unknown result type (might be due to invalid IL or missing references)
				//IL_0279: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0285: Unknown result type (might be due to invalid IL or missing references)
				//IL_028a: Unknown result type (might be due to invalid IL or missing references)
				//IL_028e: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_031c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0323: Expected O, but got Unknown
				//IL_0325: Unknown result type (might be due to invalid IL or missing references)
				//IL_0353: Unknown result type (might be due to invalid IL or missing references)
				//IL_035e: Unknown result type (might be due to invalid IL or missing references)
				Camera component = new GameObject("Camera", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				component.backgroundColor = Color.clear;
				component.clearFlags = (CameraClearFlags)2;
				component.fieldOfView = 0.5f;
				component.farClipPlane = 10000000f;
				component.cullingMask = 1073741824;
				((Component)component).transform.rotation = (Quaternion)(((??)cameraRotation) ?? Quaternion.Euler(90f, 0f, 45f));
				Light component2 = new GameObject("Light", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)component2).transform.rotation = Quaternion.Euler(150f, 0f, -5f);
				component2.type = (LightType)1;
				component2.cullingMask = 1073741824;
				component2.intensity = lightIntensity;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(0f, 0f, 64f, 64f);
				Transform val2 = ((Component)item).transform.Find("attach");
				GameObject val3;
				if (val2 != null)
				{
					val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject);
				}
				else
				{
					ZNetView.m_forceDisableInit = true;
					val3 = Object.Instantiate<GameObject>(((Component)item).gameObject);
					ZNetView.m_forceDisableInit = false;
				}
				if (itemRotation.HasValue)
				{
					val3.transform.rotation = itemRotation.Value;
				}
				Transform[] componentsInChildren = val3.GetComponentsInChildren<Transform>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.layer = 30;
				}
				Renderer[] componentsInChildren2 = val3.GetComponentsInChildren<Renderer>();
				Vector3 val4 = componentsInChildren2.Aggregate<Renderer, Vector3>(Vector3.positiveInfinity, delegate(Vector3 cur, Renderer renderer)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: 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)
					if (!(renderer is ParticleSystemRenderer))
					{
						Bounds bounds = renderer.bounds;
						return Vector3.Min(cur, ((Bounds)(ref bounds)).min);
					}
					return cur;
				});
				Vector3 val5 = componentsInChildren2.Aggregate<Renderer, Vector3>(Vector3.negativeInfinity, delegate(Vector3 cur, Renderer renderer)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: 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)
					if (!(renderer is ParticleSystemRenderer))
					{
						Bounds bounds = renderer.bounds;
						return Vector3.Max(cur, ((Bounds)(ref bounds)).max);
					}
					return cur;
				});
				Vector3 val6 = val5 - val4;
				component.targetTexture = RenderTexture.GetTemporary((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height);
				float num = Mathf.Max(val6.x, val6.z);
				float num2 = Mathf.Min(val6.x, val6.z);
				float num3 = (num + num2) / Mathf.Sqrt(2f) / Mathf.Tan(component.fieldOfView * ((float)Math.PI / 180f));
				Transform transform = ((Component)component).transform;
				Vector3 val7 = (val4 + val5) / 2f;
				val7.y = val5.y;
				transform.position = val7 + new Vector3(0f, num3, 0f);
				((Component)component2).transform.position = transform.position + new Vector3(-2f, 0f, 0.2f) / 3f * (0f - num3);
				component.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = component.targetTexture;
				Texture2D val8 = new Texture2D((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height, (TextureFormat)4, false);
				val8.ReadPixels(val, 0, 0);
				val8.Apply();
				RenderTexture.active = active;
				item.m_itemData.m_shared.m_icons = (Sprite[])(object)new Sprite[1] { Sprite.Create(val8, val, new Vector2(0.5f, 0.5f)) };
				Object.DestroyImmediate((Object)(object)val3);
				component.targetTexture.Release();
				Object.Destroy((Object)(object)component);
				Object.Destroy((Object)(object)component2);
			}
		}

		private static bool CheckItemIsUpgrade(InventoryGui gui)
		{
			ItemData itemData = ((RecipeDataPair)(ref gui.m_selectedRecipe)).ItemData;
			if (itemData == null)
			{
				return false;
			}
			return itemData.m_quality > 0;
		}

		internal static IEnumerable<CodeInstruction> Transpile_InventoryGui(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> instrs = instructions.ToList();
			FieldInfo amountField = AccessTools.DeclaredField(typeof(Recipe), "m_amount");
			int i = 0;
			while (i < instrs.Count)
			{
				yield return instrs[i];
				if (i > 1 && instrs[i - 2].opcode == OpCodes.Ldfld && CodeInstructionExtensions.OperandIs(instrs[i - 2], (MemberInfo)amountField) && instrs[i - 1].opcode == OpCodes.Ldc_I4_1 && instrs[i].operand is Label)
				{
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(Item), "CheckItemIsUpgrade", (Type[])null, (Type[])null));
					yield return new CodeInstruction(OpCodes.Brtrue, instrs[i].operand);
				}
				int num = i + 1;
				i = num;
			}
		}

		private static Action<ConfigEntryBase> drawRequirementsConfigTable(Item item, bool isUpgrade)
		{
			return delegate(ConfigEntryBase cfg)
			{
				bool locked = cfg.Description.Tags.Select((object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? ((bool?)null) : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue) == true;
				List<Requirement> newReqs = new List<Requirement>();
				bool wasUpdated = false;
				int RightColumnWidth = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
					.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				List<Requirement> reqs = new SerializedRequirements((string)cfg.BoxedValue).Reqs;
				bool flag = false;
				int maxQuality = item.Prefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_maxQuality;
				if (isUpgrade && maxQuality > 2)
				{
					flag = reqs.Any((Requirement r) => r.quality > 0);
					if (flag)
					{
						int count = reqs.Count;
						for (int num = 0; num < count; num++)
						{
							if (reqs[num].quality == 0)
							{
								List<Requirement> list = reqs;
								int index = num;
								Requirement value = reqs[num];
								value.quality = 2;
								list[index] = value;
								for (int num2 = 3; num2 <= maxQuality; num2++)
								{
									List<Requirement> list2 = reqs;
									value = reqs[num];
									value.quality = num2;
									list2.Add(value);
								}
							}
						}
					}
					if (flag != GUILayout.Toggle(flag, "Individual costs per upgrade level", Array.Empty<GUILayoutOption>()))
					{
						flag = !flag;
						wasUpdated = true;
						if (flag)
						{
							int count2 = reqs.Count;
							for (int num3 = 0; num3 < count2; num3++)
							{
								List<Requirement> list3 = reqs;
								int index2 = num3;
								Requirement value = reqs[num3];
								value.quality = 2;
								list3[index2] = value;
								for (int num4 = 3; num4 <= maxQuality; num4++)
								{
									List<Requirement> list4 = reqs;
									value = reqs[num3];
									value.quality = num4;
									list4.Add(value);
								}
							}
						}
						else
						{
							reqs.RemoveAll((Requirement req) => req.quality > 1);
							for (int num5 = 0; num5 < reqs.Count; num5++)
							{
								List<Requirement> list5 = reqs;
								int index3 = num5;
								Requirement value = reqs[num5];
								value.quality = 0;
								list5[index3] = value;
							}
						}
					}
				}
				if (flag)
				{
					for (int num6 = 2; num6 <= maxQuality; num6++)
					{
						GUILayout.Label($"Upgrade level {num6 - 1}:", Array.Empty<GUILayoutOption>());
						DisplayQuality(num6);
					}
				}
				else
				{
					DisplayQuality(0);
				}
				GUILayout.EndVertical();
				if (wasUpdated)
				{
					cfg.BoxedValue = new SerializedRequirements(newReqs).ToString();
				}
				void DisplayQuality(int quality)
				{
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0071: Unknown result type (might be due to invalid IL or missing references)
					//IL_0086: Expected O, but got Unknown
					//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e0: Expected O, but got Unknown
					//IL_0123: Unknown result type (might be due to invalid IL or missing references)
					//IL_0128: Unknown result type (might be due to invalid IL or missing references)
					//IL_013d: Expected O, but got Unknown
					//IL_0193: Unknown result type (might be due to invalid IL or missing references)
					//IL_0198: Unknown result type (might be due to invalid IL or missing references)
					//IL_01ad: Expected O, but got Unknown
					foreach (Requirement item2 in reqs.Where((Requirement r) => r.quality == quality))
					{
						GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
						int num7 = item2.amount;
						if (int.TryParse(GUILayout.TextField(num7.ToString(), new GUIStyle(GUI.skin.textField)
						{
							fixedWidth = 40f
						}, Array.Empty<GUILayoutOption>()), out var result) && result != num7 && !locked)
						{
							num7 = result;
							wasUpdated = true;
						}
						string text = GUILayout.TextField(item2.itemName, new GUIStyle(GUI.skin.textField)
						{
							fixedWidth = RightColumnWidth - 40 - 21 - 21 - 9
						}, Array.Empty<GUILayoutOption>());
						string text2 = (locked ? item2.itemName : text);
						wasUpdated = wasUpdated || text2 != item2.itemName;
						if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
						{
							fixedWidth = 21f
						}, Array.Empty<GUILayoutOption>()) && !locked)
						{
							wasUpdated = true;
						}
						else
						{
							newReqs.Add(new Requirement
							{
								amount = num7,
								itemName = text2,
								quality = quality
							});
						}
						if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
						{
							fixedWidth = 21f
						}, Array.Empty<GUILayoutOption>()) && !locked)
						{
							wasUpdated = true;
							newReqs.Add(new Requirement
							{
								amount = 1,
								itemName = "",
								quality = quality
							});
						}
						GUILayout.EndHorizontal();
					}
				}
			};
		}

		private static void drawDropsConfigTable(ConfigEntryBase cfg)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			//IL_0231: Expected O, but got Unknown
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Expected O, but got Unknown
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Expected O, but got Unknown
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select((object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? ((bool?)null) : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue) == true;
			List<DropTarget> list = new List<DropTarget>();
			bool flag = false;
			int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
				.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (DropTarget item in new SerializedDrop((string)cfg.BoxedValue).Drops.DefaultIfEmpty(new DropTarget
			{
				min = 1,
				max = 1,
				creature = "",
				chance = 1f
			}))
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				string text = GUILayout.TextField(item.creature, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 21 - 21 - 6
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? item.creature : text);
				flag = flag || text2 != item.creature;
				bool num2 = GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				bool flag2 = GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Chance: ", Array.Empty<GUILayoutOption>());
				float num3 = item.chance;
				float num4 = GUILayout.HorizontalSlider(num3, 0f, 1f, new GUIStyle(GUI.skin.horizontalSlider)
				{
					fixedWidth = 100f
				}, new GUIStyle(GUI.skin.horizontalSliderThumb), Array.Empty<GUILayoutOption>());
				if (!valueOrDefault && Math.Abs(num4 - num3) > 1E-05f)
				{
					num3 = num4;
					flag = true;
				}
				if (float.TryParse(GUILayout.TextField(num3.ToString(CultureInfo.InvariantCulture), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 45f
				}, Array.Empty<GUILayoutOption>()), NumberStyles.Any, CultureInfo.InvariantCulture, out var result) && !valueOrDefault)
				{
					num3 = Mathf.Clamp(result, 0f, 1f);
					flag = true;
				}
				GUILayout.Label((num3 * 100f).ToString(CultureInfo.InvariantCulture) + "%", Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Amount: ", Array.Empty<GUILayoutOption>());
				int num5 = item.min;
				if (int.TryParse(GUILayout.TextField(num5.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result2) && result2 != num5 && !valueOrDefault)
				{
					num5 = result2;
					flag = true;
				}
				GUILayout.Label(" - ", Array.Empty<GUILayoutOption>());
				int num6 = item.max;
				if (int.TryParse(GUILayout.TextField(num6.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result3) && result3 != num6 && !valueOrDefault)
				{
					num6 = result3;
					flag = true;
				}
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				bool flag3 = item.levelMultiplier;
				if (GUILayout.Toggle(flag3, "Level scaling drop amount", Array.Empty<GUILayoutOption>()) != flag3)
				{
					flag3 = !flag3;
					flag = true;
				}
				GUILayout.EndHorizontal();
				if (num2 && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(new DropTarget
					{
						creature = text2,
						min = num5,
						max = num6,
						chance = num3,
						levelMultiplier = flag3
					});
				}
				if (flag2 && !valueOrDefault)
				{
					flag = true;
					list.Add(new DropTarget
					{
						min = 1,
						max = 1,
						creature = "",
						chance = 1f,
						levelMultiplier = true
					});
				}
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new SerializedDrop(list).ToString();
			}
		}
	}
	[PublicAPI]
	internal static class PrefabManager
	{
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		public static bool Initalized;

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		private static readonly List<GameObject> prefabs;

		private static readonly List<GameObject> ZnetOnlyPrefabs;

		internal static readonly Dictionary<GameObject, Tuple<Trader, TradeItem>> CustomTradeItems;

		static PrefabManager()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_00ec: 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_0127: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Expected O, but got Unknown
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Expected O, but got Unknown
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Expected O, but got Unknown
			//IL_02e5: Expected O, but got Unknown
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Expected O, but got Unknown
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Expected O, but got Unknown
			//IL_035e: 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_0399: Expected O, but got Unknown
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			Initalized = false;
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			prefabs = new List<GameObject>();
			ZnetOnlyPrefabs = new List<GameObject>();
			CustomTradeItems = new Dictionary<GameObject, Tuple<Trader, TradeItem>>();
			Harmony val = new Harmony("org.bepinex.helpers.ItemManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "UpdateRecipe", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Transpile_InventoryGui", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "SetupRequirementList", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Transpile_SetupRequirementList", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Requirement), "GetAmount", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_RequirementGetAmount", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "GetAvailableRecipes", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_GetAvailableRecipesPrefix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_GetAvailableRecipesFinalizer", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Recipe), "GetRequiredStationLevel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_MaximumRequiredStationLevel", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Smelter), "OnAddFuel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_OnAddSmelterInput", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Smelter), "OnAddOre", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_OnAddSmelterInput", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Trader), "GetAvailableItems", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Item), "Patch_TraderGetAvailableItems", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId key = new BundleId
			{
				assetBundleFileName = assetBundleFileName,
				folderName = folderName
			};
			if (!bundleCache.TryGetValue(key, out AssetBundle value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static GameObject RegisterPrefab(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterPrefab(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName, bool addToObjectDb = false)
		{
			return RegisterPrefab(assets.LoadAsset<GameObject>(prefabName), addToObjectDb);
		}

		public static GameObject RegisterPrefab(GameObject prefab, bool addToObjectDb = false)
		{
			if (addToObjectDb)
			{
				prefabs.Add(prefab);
			}
			else
			{
				ZnetOnlyPrefabs.Add(prefab);
			}
			return prefab;
		}

		public static void AddItemToTrader(GameObject prefab, Trader trader, uint price, uint stack = 1u, string? requiredGlobalKey = null)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			CustomTradeItems[prefab] = new Tuple<Trader, TradeItem>(trader, new TradeItem
			{
				m_prefab = prefab.GetComponent<ItemDrop>(),
				m_price = (int)price,
				m_stack = (int)stack,
				m_requiredGlobalKey = (requiredGlobalKey ?? "")
			});
		}

		public static void RemoveItemFromTrader(GameObject prefab)
		{
			CustomTradeItems.Remove(prefab);
		}

		[HarmonyPriority(700)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			foreach (GameObject prefab in prefabs)
			{
				if (!__instance.m_items.Contains(prefab))
				{
					__instance.m_items.Add(prefab);
				}
				SharedData shared = prefab.GetComponent<ItemDrop>().m_itemData.m_shared;
				RegisterStatusEffect(shared.m_attackStatusEffect);
				RegisterStatusEffect(shared.m_consumeStatusEffect);
				RegisterStatusEffect(shared.m_equipStatusEffect);
				RegisterStatusEffect(shared.m_setStatusEffect);
			}
			__instance.UpdateRegisters();
			void RegisterStatusEffect(StatusEffect? statusEffect)
			{
				if (statusEffect != null && !Object.op_Implicit((Object)(object)__instance.GetStatusEffect(StringExtensionMethods.GetStableHashCode(((Object)statusEffect).name))))
				{
					__instance.m_StatusEffects.Add(statusEffect);
				}
			}
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject item in prefabs.Concat(ZnetOnlyPrefabs))
			{
				if (!__instance.m_prefabs.Contains(item))
				{
					__instance.m_prefabs.Add(item);
				}
				else
				{
					Debug.LogWarning((object)("ZNetScene already contains " + ((Object)item).name + " it cannot be added twice."));
				}
			}
		}
	}
	[PublicAPI]
	internal class Conversion
	{
		internal class ConversionConfig
		{
			public ConfigEntry<string> input;

			public string? activePiece;

			public ConfigEntry<ConversionPiece> piece;

			public ConfigEntry<string> customPiece;
		}

		public string Input;

		public ConversionPiece Piece;

		internal string? customPiece;

		internal ConversionConfig? config;

		public string? Custom
		{
			get
			{
				return customPiece;
			}
			set
			{
				customPiece = value;
				Piece = ConversionPiece.Custom;
			}
		}

		public Conversion(Item outputItem)
		{
			outputItem.Conversions.Add(this);
		}
	}
}
namespace Vapok.Common.Tools
{
	internal static class BoneReorder
	{
		private static bool applied;

		private static ILogIt? _log;

		public static void ApplyOnEquipmentChanged(string pluginId)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!applied)
			{
				_log = LogManager.GetLogger(pluginId);
				new Harmony(pluginId).PatchAll(typeof(BoneReorder));
				applied = true;
			}
		}

		public static bool IsReorderingEnabled()
		{
			return applied;
		}

		[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetLegEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_legItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_legItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetHelmetEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetHelmetEquiped(VisEquipment __instance, int hash, int hairHash, ref bool __result)
		{
			if (__result && (Object)(object)__instance.m_helmetItemInstance != (Object)null)
			{
				ReorderBones(__instance, hash, new List<GameObject> { __instance.m_helmetItemInstance });
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetChestEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_chestItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_chestItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetShoulderEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetShoulderEquiped(VisEquipment __instance, int hash, int variant, ref bool __result)
		{
			if (__result && __instance.m_shoulderItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_shoulderItemInstances);
			}
		}

		[HarmonyPatch(typeof(VisEquipment), "SetUtilityEquipped")]
		[HarmonyPostfix]
		private static void VisEquipmentOnSetUtilityEquiped(VisEquipment __instance, int hash, ref bool __result)
		{
			if (__result && __instance.m_utilityItemInstances != null)
			{
				ReorderBones(__instance, hash, __instance.m_utilityItemInstances);
			}
		}

		private static void ReorderBones(VisEquipment visEquipment, int itemPrefabHash, List<GameObject> instancesToFix)
		{
			if (!((Object)(object)visEquipment != (Object)null))
			{
				return;
			}
			try
			{
				Transform val = ((Component)visEquipment).transform.Find("Visual/Armature/Hips");
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(itemPrefabHash);
				if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)itemPrefab))
				{
					_log?.Debug($"Prefab missing components. Skipping {itemPrefab} {val}");
					return;
				}
				_log?.Debug("Reordering bones");
				int childCount = itemPrefab.transform.childCount;
				int num = 0;
				for (int i = 0; i < childCount; i++)
				{
					Transform child = itemPrefab.transform.GetChild(i);
					if (((Object)child).name.StartsWith("attach_skin"))
					{
						int num2 = 0;
						SkinnedMeshRenderer[] componentsInChildren = instancesToFix[num].GetComponentsInChildren<SkinnedMeshRenderer>(true);
						SkinnedMeshRenderer[] componentsInChildren2 = ((Component)child).GetComponentsInChildren<SkinnedMeshRenderer>(true);
						foreach (SkinnedMeshRenderer skinnedMeshRenderer in componentsInChildren2)
						{
							componentsInChildren[num2].SetBones(skinnedMeshRenderer.GetBoneNames(), val);
							num2++;
						}
						num++;
					}
				}
			}
			catch (Exception arg)
			{
				_log?.Warning($"Exception caught while reordering bones: {arg}");
			}
		}

		private static void SetBones(this SkinnedMeshRenderer skinnedMeshRenderer, string[] boneNames, Transform skeletonRoot)
		{
			Transform[] array = (Transform[])(object)new Transform[skinnedMeshRenderer.bones.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = FindInChildren(skeletonRoot, boneNames[i]);
			}
			skinnedMeshRenderer.bones = array;
			skinnedMeshRenderer.rootBone = skeletonRoot;
		}

		private static string[] GetBoneNames(this SkinnedMeshRenderer skinnedMeshRenderer)
		{
			List<string> list = new List<string>();
			Transform[] bones = skinnedMeshRenderer.bones;
			foreach (Transform val in bones)
			{
				list.Add(((Object)val).name);
			}
			return list.ToArray();
		}

		private static Transform FindInChildren(Transform transform, string name)
		{
			if (((Object)transform).name == name)
			{
				return transform;
			}
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform val = FindInChildren(transform.GetChild(i), name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}
	}
	internal static class Initializer
	{
		public static void LoadManagers(CustomLocalization localization, bool enableCreatureManager = false, bool enableItemManager = false, bool enableLocationManager = false, bool enableMaterialReplacer = false, bool enablePieceManager = false, bool enableSkillManager = false, bool enableEffectManager = false)
		{
			Localizer.Init(localization);
			if (enableCreatureManager)
			{
				Vapok.Common.Managers.Creature.PrefabManager.Init();
			}
			if (enableEffectManager)
			{
				EffectManager.Init();
			}
			if (enableLocationManager)
			{
				Location.Init();
			}
			if (enableMaterialReplacer)
			{
				MaterialReplacer.Init();
			}
			if (enablePieceManager)
			{
				PiecePrefabManager.Init();
			}
			if (enableSkillManager)
			{
				Skill.Init();
			}
		}
	}
	internal class KeyPressTool
	{
		public static bool IgnoreKeyPresses(bool extra = false)
		{
			if (!extra)
			{
				if (!((Object)(object)ZNetScene.instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null) && !Minimap.IsOpen() && !Console.IsVisible() && !TextInput.IsVisible() && !ZNet.instance.InPasswordDialog() && !Chat.instance.HasFocus())
				{
					return Menu.IsVisible();
				}
				return true;
			}
			if (!((Object)(object)ZNetScene.instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null) && !Minimap.IsOpen() && !Console.IsVisible() && !TextInput.IsVisible() && !ZNet.instance.InPasswordDialog() && !Chat.instance.HasFocus() && !StoreGui.IsVisible() && !InventoryGui.IsVisible() && !Menu.IsVisible())
			{
				return TextViewer.instance.IsVisible();
			}
			return true;
		}

		public static bool CheckKeyDown(KeyCode value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return Input.GetKeyDown(value);
			}
			catch
			{
				return false;
			}
		}

		public static bool CheckKeyHeld(KeyCode value, bool req = true)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return Input.GetKey(value);
			}
			catch
			{
				return !req;
			}
		}
	}
	internal class RepeatingTimer : IDisposable
	{
		private System.Threading.Timer _timer;

		private readonly TimeSpan _interval;

		private readonly Action _action;

		private bool _isRunning;

		public RepeatingTimer(TimeSpan interval, Action action)
		{
			_interval = interval;
			_action = action;
		}

		public void Start()
		{
			if (!_isRunning)
			{
				_timer = new System.Threading.Timer(delegate
				{
					OnTick();
				}, null, TimeSpan.Zero, _interval);
				_isRunning = true;
			}
		}

		private void OnTick()
		{
			try
			{
				_action();
			}
			catch (Exception ex)
			{
				LogManager.Log?.Error("RepeatingTimer callback threw: " + ex.Message);
				LogManager.Log?.Error(ex.StackTrace ?? "");
				Stop();
			}
		}

		public void Stop()
		{
			if (_isRunning)
			{
				_timer?.Change(-1, -1);
				_timer?.Dispose();
				_timer = null;
				_isRunning = false;
			}
		}

		public void Dispose()
		{
			Stop();
		}
	}
}
namespace Vapok.Common.Shared
{
	internal class ConfigurationManagerAttributes
	{
		private ILogIt? _log = LogManager.GetLogger("vapok.mods.core");

		public bool? ShowRangeAsPercent;

		public Action<ConfigEntryBase> CustomDrawer;

		public bool? Browsable;

		public string Category;

		public object DefaultValue;

		public bool? HideDefaultButton;

		public bool? HideSettingName;

		public string Description;

		public string DispName;

		public int? Order;

		public bool? ReadOnly;

		public bool? IsAdvanced;

		private bool isAdminOnly;

		private bool isUnlocked;

		private static readonly PropertyInfo[] _myProperties = typeof(ConfigurationManagerAttributes).GetProperties(BindingFlags.Instance | BindingFlags.Public);

		private static readonly FieldInfo[] _myFields = typeof(ConfigurationManagerAttributes).GetFields(BindingFlags.Instance | BindingFlags.Public);

		public bool IsAdminOnly
		{
			get
			{
				return isAdminOnly;
			}
			set
			{
				isAdminOnly = value;
				IsUnlocked = !value;
			}
		}

		public Color EntryColor { get; set; }

		public Color DescriptionColor { get; set; }

		public bool IsUnlocked
		{
			get
			{
				return isUnlocked;
			}
			internal set
			{
				ReadOnly = !value;
				HideDefaultButton = !value;
				isUnlocked = value;
			}
		}

		internal object? LocalValue { get; set; }

		public ConfigurationManagerAttributes()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			EntryColor = new Color(1f, 0.631f, 0.235f, 1f);
			DescriptionColor = Color.white;
		}

		public void SetFromAttributes(object[] attribs)
		{
			if (attribs.Length == 0)
			{
				return;
			}
			foreach (object obj in attribs)
			{
				if (obj == null)
				{
					continue;
				}
				if (!(obj is DisplayNameAttribute displayNameAttribute))
				{
					if (!(obj is CategoryAttribute categoryAttribute))
					{
						if (!(obj is DescriptionAttribute descriptionAttribute))
						{
							if (!(obj is DefaultValueAttribute defaultValueAttribute))
							{
								if (!(obj is ReadOnlyAttribute readOnlyAttribute))
								{
									if (!(obj is BrowsableAttribute browsableAttribute))
									{
										if (obj is string text)
										{
											switch (text)
											{
											case "ReadOnly":
												ReadOnly = true;
												break;
											case "Browsable":
												Browsable = true;
												break;
											case "Unbrowsable":
											case "Hidden":
												Browsable = false;
												break;
											case "Advanced":
												IsAdvanced = true;
												break;
											}
											continue;
										}
										Type type = obj.GetType();
										if (!(type.Name == "ConfigurationManagerAttributes"))
										{
											break;
										}
										FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
										foreach (var item in from my in _myProperties
											join other in fields on my.Name equals other.Name
											select new { my, other })
										{
											try
											{
												object value = item.other.GetValue(obj);
												if (value != null)
												{
													item.my.SetValue(this, value, null);
												}
											}
											catch (Exception ex)
											{
												_log?.Warning("Failed to copy value " + item.my.Name + " from provided tag object " + type.FullName + " - " + ex.Message);
											}
										}
										foreach (var item2 in from my in _myFields
											join other in fields on my.Name equals other.Name
											select new { my, other })
										{
											try
											{
												object value2 = item2.other.GetValue(obj);
												if (value2 != null)
												{
													item2.my.SetValue(this, value2);
												}
											}
											catch (Exception ex2)
											{
												_log?.Warning("Failed to copy value " + item2.my.Name + " from provided tag object " + type.FullName + " - " + ex2.Message);
											}
										}
									}
									else
									{
										Browsable = browsableAttribute.Browsable;
									}
								}
								else
								{
									ReadOnly = readOnlyAttribute.IsReadOnly;
								}
							}
							else
							{
								DefaultValue = defaultValueAttribute.Value;
							}
						}
						else
						{
							Description = descriptionAttribute.Description;
						}
					}
					else
					{
						Category = categoryAttribute.Category;
					}
				}
				else
				{
					DispName = displayNameAttribute.DisplayName;
				}
			}
		}
	}
	public class Enums
	{
		[PublicAPI]
		public enum StatusEffects
		{
			Burning,
			Cozy,
			Demister,
			Finder,
			Frost,
			Harpooned,
			HealthUpgrade,
			Poison,
			Puke,
			Rested,
			Shield,
			Smoke,
			Spawn,
			Stats,
			Wet,
			Custom
		}
	}
}
namespace Vapok.Common.Managers
{
	[PublicAPI]
	public abstract class CustomItemData
	{
		private string key;

		internal WeakReference<ItemInfo> info;

		public string CustomDataKey { get; private set; }

		protected virtual bool AllowStackingIdenticalValues { get; set; }

		public string Value
		{
			get
			{
				if (!Item.m_customData.TryGetValue(CustomDataKey, out var value))
				{
					return "";
				}
				return value;
			}
			set
			{
				Item.m_customData[CustomDataKey] = value;
			}
		}

		public string Key
		{
			get
			{
				return key;
			}
			internal set
			{
				key = value;
				CustomDataKey = ItemInfo.dataKey(ItemInfo.classKey(GetType(), Key));
			}
		}

		public bool IsCloned => Info.isCloned.Contains(CustomDataKey);

		public bool IsAlive
		{
			get
			{
				ItemInfo target;
				return info.TryGetTarget(out target);
			}
		}

		public ItemData Item => Info.ItemData;

		public ItemInfo Info
		{
			get
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				if (!info.TryGetTarget(out ItemInfo target))
				{
					return new ItemInfo(new ItemData());
				}
				return target;
			}
		}

		public virtual void FirstLoad()
		{
		}

		public virtual void Load()
		{
		}

		public virtual void Save()
		{
		}

		public virtual void Unload()
		{
		}

		public virtual void Upgraded()
		{
		}

		public virtual string? TryStack(CustomItemData? data)
		{
			if (!AllowStackingIdenticalValues || !(data?.Value == Value))
			{
				return null;
			}
			return Value;
		}
	}
	internal sealed class StringItemData : CustomItemData
	{
	}
	[PublicAPI]
	public class ItemInfo : IEnumerable<CustomItemData>, IEnumerable
	{
		public static HashSet<Type> ForceLoadTypes;

		internal static string? _modGuid;

		private static Dictionary<Type, HashSet<Type>> typeInheritorsCache;

		private static HashSet<string> knownTypes;

		private Dictionary<string, CustomItemData> data = new Dictionary<string, CustomItemData>();

		private WeakReference<ItemInfo>? selfReference;

		internal HashSet<string> isCloned = new HashSet<string>();

		private static ItemData? checkingForStackableItemData;

		private static Dictionary<string, string>? newValuesOnStackable;

		private static ItemData? currentlyUpgradingItem;

		internal static string modGuid => _modGuid ?? (_modGuid = ((Func<string>)delegate
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			IEnumerable<TypeInfo> source;
			try
			{
				source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
			}
			catch (ReflectionTypeLoadException ex)
			{
				source = from t in ex.Types
					where t != null
					select t.GetTypeInfo();
			}
			return ((BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)))).Info.Metadata.GUID;
		})());

		public string Mod => modGuid;

		public ItemData ItemData { get; private set; }

		public string? this[string key]
		{
			get
			{
				return Get<StringItemData>(key)?.Value;
			}
			set
			{
				GetOrCreate<StringItemData>(key).Value = value ?? "";
			}
		}

		internal static void addTypeToInheritorsCache(Type type, string typeKey)
		{
			if (!knownTypes.Contains(typeKey))
			{
				knownTypes.Add(typeKey);
				Type type2 = type;
				while ((object)type2 != null)
				{
					AddInterfaces(type2);
					type2 = type2.BaseType;
				}
			}
			void AddInterfaces(Type baseType)
			{
				if (!typeInheritorsCache.TryGetValue(baseType, out HashSet<Type> value))
				{
					HashSet<Type> hashSet = (typeInheritorsCache[baseType] = new HashSet<Type>());
					value = hashSet;
				}
				value.Add(type);
				Type[] interfaces = baseType.GetInterfaces();
				for (int i = 0; i < interfaces.Length; i++)
				{
					AddInterfaces(interfaces[i]);
				}
			}
		}

		internal static string classKey(Type type, string key)
		{
			string text = type.FullName + ((type.Assembly != Assembly.GetExecutingAssembly()) ? ("," + type.Assembly.GetName().Name) : "");
			addTypeToInheritorsCache(type, text);
			return text + ((key == "") ? "" : ("#" + key));
		}

		internal static string dataKey(string key)
		{
			return modGuid + "#" + key;
		}

		internal ItemInfo(ItemData itemData)
		{
			ItemData = itemData;
			string text = dataKey("");
			foreach (string item in ItemData.m_customData.Keys.ToList())
			{
				if (!item.StartsWith(text))
				{
					continue;
				}
				string[] array = item.Substring(text.Length).Split(new char[1] { '#' }, 2);
				if (!knownTypes.Contains(array[0]))
				{
					Type type = Type.GetType(array[0]);
					if ((object)type != null && typeof(CustomItemData).IsAssignableFrom(type))
					{
						addTypeToInheritorsCache(type, array[0]);
					}
				}
			}
		}

		public T GetOrCreate<T>(string key = "") where T : CustomItemData, new()
		{
			return Add<T>(key) ?? Get<T>(key);
		}

		public T? Add<T>(string key = "") where T : CustomItemData, new()
		{
			string key2 = classKey(typeof(T), key);
			string key3 = dataKey(key2);
			if (ItemData.m_customData.ContainsKey(key3))
			{
				return null;
			}
			ItemData.m_customData[key3] = "";
			T val = new T
			{
				info = (selfReference ?? (selfReference = new WeakReference<ItemInfo>(this))),
				Key = key
			};
			data[key2] = val;
			val.Value = "";
			val.FirstLoad();
			return val;
		}

		public T? Get<T>(string key = "") where T : class
		{
			if (!typeInheritorsCache.TryGetValue(typeof(T), out HashSet<Type> value))
			{
				if (!typeof(CustomItemData).IsAssignableFrom(typeof(T)) || typeof(T) == typeof(CustomItemData))
				{
					throw new Exception("Trying to get value from ItemDataManager for class not inheriting from ItemData");
				}
				return null;
			}
			foreach (Type item in value)
			{
				string key2 = classKey(item, key);
				if (data.TryGetValue(key2, out CustomItemData value2))
				{
					return (T)(object)value2;
				}
				string key3 = dataKey(key2);
				if (ItemData.m_customData.ContainsKey(key3))
				{
					return (T)(object)constructDataObj(key2);
				}
			}
			return null;
		}

		public Dictionary<string, T> GetAll<T>() where T : CustomItemData
		{
			LoadAll();
			return data.Values.Where((CustomItemData o) => o is T).ToDictionary((CustomItemData o) => o.Key, (CustomItemData o) => (T)o);
		}

		public bool Remove(string key = "")
		{
			return Remove<StringItemData>(key);
		}

		public bool Remove<T>(string key = "") where T : CustomItemData
		{
			string key2 = classKey(typeof(T), key);
			string key3 = dataKey(key2);
			if (ItemData.m_customData.Remove(key3))
			{
				if (data.TryGetValue(key2, out CustomItemData value))
				{
					value.Unload();
					data.Remove(key2);
				}
				return true;
			}
			return false;
		}

		public bool Remove<T>(T itemData) where T : CustomItemData
		{
			return Remove<T>(itemData.Key);
		}

		private CustomItemData? constructDataObj(string key)
		{
			string[] array = key.Split(new char[1] { '#' }, 2);
			Type type = Type.GetType(array[0]);
			if ((object)type == null || !typeof(CustomItemData).IsAssignableFrom(type))
			{
				return null;
			}
			CustomItemData customItemData = (CustomItemData)Activator.CreateInstance(type);
			data[key] = customItemData;
			customItemData.info = selfReference ?? new WeakReference<ItemInfo>(this);
			customItemData.Key = ((array.Length > 1) ? array[1] : "");
			customItemData.Load();
			return customItemData;
		}

		public void Save()
		{
			foreach (CustomItemData value in data.Values)
			{
				value.Save();
			}
		}

		public void LoadAll()
		{
			string text = dataKey("");
			foreach (string item in ItemData.m_customData.Keys.ToList())
			{
				if (item.StartsWith(text))
				{
					string key = item.Substring(text.Length);
					if (!data.ContainsKey(key))
					{
						constructDataObj(key);
					}
				}
			}
		}

		public IEnumerator<CustomItemData> GetEnumerator()
		{
			LoadAll();
			return data.Values.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private static void SavePrefix(ItemData __instance)
		{
			SaveItem(__instance);
		}

		private static void SaveInventoryPrefix(Inventory __instance)
		{
			foreach (ItemData item in __instance.m_inventory)
			{
				SaveItem(item);
			}
		}

		private static void SaveItem(ItemData item)
		{
			if (ItemExtensions.itemInfo.TryGetValue(item, out ItemInfo value))
			{
				value.Save();
			}
		}

		public Dictionary<string, string>? IsStackableWithOtherInfo(ItemInfo? info)
		{
			LoadAll();
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			if (info != null)
			{
				info.LoadAll();
				foreach (string item in new HashSet<string>(info.data.Keys.Intersect(data.Keys)))
				{
					string text = data[item].TryStack(info.data[item]);
					if (text == null)
					{
						return null;
					}
					dictionary[item] = text;
				}
				foreach (KeyValuePair<string, CustomItemData> datum in info.data)
				{
					if (!dictionary.ContainsKey(datum.Key))
					{
						string text2 = info.data[datum.Key].TryStack(null);
						if (text2 == null)
						{
							return null;
						}
						dictionary[datum.Key] = text2;
					}
				}
			}
			foreach (KeyValuePair<string, CustomItemData> datum2 in data)
			{
				if (!dictionary.ContainsKey(datum2.Key))
				{
					string text3 = data[datum2.Key].TryStack(null);
					if (text3 == null)
					{
						return null;
					}
					dictionary[datum2.Key] = text3;
				}
			}
			return dictionary.ToDictionary((KeyValuePair<string, string> kv) => dataKey(kv.Key), (KeyValuePair<string, string> kv) => kv.Value);
		}

		private static void RegisterForceLoadedTypesAddItem(ItemData? __result)
		{
			if (__result != null)
			{
				RegisterForceLoadedTypes(__result);
			}
		}

		private static void RegisterForceLoadedTypes(ItemData itemData)
		{
			foreach (Type forceLoadType in ForceLoadTypes)
			{
				string key = classKey(forceLoadType, "");
				string key2 = dataKey(key);
				if (itemData.m_customData.ContainsKey(key2))
				{
					itemData.Data().constructDataObj(key);
				}
			}
		}

		private static void ItemDropAwake(ItemDrop __instance)
		{
			GameObject dropPrefab = __instance.m_itemData.m_dropPrefab;
			if (dropPrefab != null && ItemExtensions.itemInfo.TryGetValue(dropPrefab.GetComponent<ItemDrop>().m_itemData, out ItemInfo value))
			{
				__instance.m_itemData.Data().isCloned = new HashSet<string>(value.data.Values.Select((CustomItemData i) => i.CustomDataKey));
			}
		}

		private static void ItemDropAwakeDelayed(ItemDrop __instance)
		{
			if (!ZNetView.m_forceDisableInit)
			{
				RegisterForceLoadedTypes(__instance.m_itemData);
			}
		}

		private static void ItemDataClonePrefix(ItemData __instance, ItemData __result)
		{
			SaveItem(__instance);
		}

		private static void ItemDataClonePostfix(ItemData __instance, ItemData __result)
		{
			if (ItemExtensions.itemInfo.TryGetValue(__instance, out ItemInfo value))
			{
				__result.Data().isCloned = new HashSet<string>(value.data.Values.Select((CustomItemData i) => i.CustomDataKey));
			}
		}

		private static void ItemDataClonePostfixDelayed(ItemData __result)
		{
			RegisterForceLoadedTypes(__result);
		}

		private static void RegisterForceLoadedTypesOnPlayerLoaded(Player __instance)
		{
			foreach (Food food in __instance.m_foods)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(food.m_name);
				if (itemPrefab.GetComponent<ItemDrop>().m_itemData == food.m_item)
				{
					food.m_item = food.m_item.Clone();
					food.m_item.m_dropPrefab = itemPrefab;
				}
				RegisterForceLoadedTypes(food.m_item);
			}
		}

		private static void SaveCheckingForStackableItemData(ItemData item)
		{
			checkingForStackableItemData = item;
		}

		private static void ResetCheckingForStackableItemData()
		{
			checkingForStackableItemData = null;
		}

		private static IEnumerable<CodeInstruction> CheckStackableInFindFreeStackMethods(IEnumerable<CodeInstruction> instructionsEnumerable)
		{
			CodeInstruction[] instructions = instructionsEnumerable.ToArray();
			Label target = (Label)instructions.First((CodeInstruction val) => val.opcode == OpCodes.Br || val.opcode == OpCodes.Br_S).operand;
			CodeInstruction targetedInstr = instructions.First((CodeInstruction val) => val.labels.Contains(target));
			Label? label = default(Label?);
			CodeInstruction lastBranch = instructions.Reverse().First((CodeInstruction val) => CodeInstructionExtensions.Branches(val, ref label) && targetedInstr.labels.Contains(label.Value));
			CodeInstruction loadingInstruction = null;
			int i = 0;
			while (i < instructions.Length)
			{
				yield return instructions[i];
				if (loadingInstruction == null && instructions[i].opcode == OpCodes.Call && ((MethodInfo)instructions[i].operand).Name == "get_Current")
				{
					loadingInstruction = instructions[i + 1].Clone();
					loadingInstruction.opcode = new Dictionary<OpCode, OpCode>
					{
						{
							OpCodes.Stloc_0,
							OpCodes.Ldloc_0
						},
						{
							OpCodes.Stloc_1,
							OpCodes.Ldloc_1
						},
						{
							OpCodes.Stloc_2,
							OpCodes.Ldloc_2
						},
						{
							OpCodes.Stloc_3,
							OpCodes.Ldloc_3
						},
						{
							OpCodes.Stloc_S,
							OpCodes.Ldloc_S
						}
					}[loadingInstruction.opcode];
				}
				if (instructions[i] == lastBranch)
				{
					yield return loadingInstruction;
					yield return new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.DeclaredField(typeof(ItemInfo), "checkingForStackableItemData"));
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckItemDataIsStackableFindFree", (Type[])null, (Type[])null));
					yield return new CodeInstruction(OpCodes.Brfalse, (object)target);
				}
				int num = i + 1;
				i = num;
			}
		}

		private static bool CheckItemDataIsStackableFindFree(ItemData item, ItemData? target)
		{
			if (target == null)
			{
				return true;
			}
			Dictionary<string, string> dictionary = IsStackable(item, target);
			if (dictionary != null)
			{
				newValuesOnStackable = dictionary;
				return true;
			}
			return false;
		}

		private static void ResetNewValuesOnStackable()
		{
			newValuesOnStackable = null;
		}

		private static void ApplyNewValuesOnStackable(ItemData? __result)
		{
			if (__result == null || newValuesOnStackable == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> item in newValuesOnStackable)
			{
				__result.m_customData[item.Key] = item.Value;
			}
		}

		private static Dictionary<string, string>? IsStackable(ItemData a, ItemData b)
		{
			ItemInfo itemInfo = a.Data();
			if (itemInfo != null)
			{
				return itemInfo.IsStackableWithOtherInfo(b.Data());
			}
			ItemInfo itemInfo2 = b.Data();
			if (itemInfo2 != null)
			{
				return itemInfo2.IsStackableWithOtherInfo(null);
			}
			return new Dictionary<string, string>();
		}

		private static bool CheckItemDataStackableAddItem(Inventory __instance, ItemData item, int x, int y, ref Dictionary<string, string>? __state, ref bool __result)
		{
			ItemData itemAt = __instance.GetItemAt(x, y);
			if (itemAt != null)
			{
				Dictionary<string, string> dictionary = IsStackable(item, itemAt);
				if (dictionary == null)
				{
					__result = false;
					return false;
				}
				__state = dictionary;
			}
			return true;
		}

		private static void ApplyCustomItemDataStackableAddItem(Inventory __instance, int x, int y, Dictionary<string, string>? __state, bool __result)
		{
			if (!__result || __state == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> item in __state)
			{
				__instance.GetItemAt(x, y).m_customData[item.Key] = item.Value;
			}
		}

		private static void ApplyCustomItemDataStackableAutoStack(ItemDrop item, Dictionary<string, string> customData)
		{
			item.m_itemData.m_customData = customData;
		}

		private static Dictionary<string, string>? IsStackableItemDrop(ItemDrop drop, ItemData item)
		{
			return IsStackable(drop.m_itemData, item);
		}

		private static IEnumerable<CodeInstruction> HandleAutostackableItems(IEnumerable<CodeInstruction> instructionList, ILGenerator ilg)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			List<CodeInstruction> list = instructionList.ToList();
			FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ItemData), "m_stack");
			FieldInfo fieldInfo2 = AccessTools.DeclaredField(typeof(ItemDrop), "m_itemData");
			Label? label = default(Label?);
			for (int i = 0; i < list.Count; i++)
			{
				if (!CodeInstructionExtensions.StoresField(list[i], fieldInfo))
				{
					continue;
				}
				for (int num = i; num > 0; num--)
				{
					if (CodeInstructionExtensions.Branches(list[num], ref label))
					{
						for (int num2 = num; num2 > 0; num2--)
						{
							if (CodeInstructionExtensions.LoadsField(list[num2], fieldInfo2, false))
							{
								LocalBuilder localBuilder = ilg.DeclareLocal(typeof(Dictionary<string, string>));
								LocalBuilder localBuilder2 = ilg.DeclareLocal(typeof(ItemData));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyCustomItemDataStackableAutoStack", (Type[])null, (Type[])null)));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Ldloc, (object)localBuilder.LocalIndex));
								list.Insert(i + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Brfalse, (object)label));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Stloc, (object)localBuilder.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Dup, (object)localBuilder.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "IsStackableItemDrop", (Type[])null, (Type[])null)));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Ldloc, (object)localBuilder2.LocalIndex));
								list.Insert(num + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
								list.Insert(num2 + 1, new CodeInstruction(OpCodes.Stloc, (object)localBuilder2.LocalIndex));
								list.Insert(num2 + 1, new CodeInstruction(OpCodes.Dup, (object)null));
								return list;
							}
						}
					}
				}
			}
			throw new Exception("Found no stack store in a branch");
		}

		private static IEnumerable<CodeInstruction> TransferCustomItemDataOnUpgrade(IEnumerable<CodeInstruction> instructions, ILGenerator ilg)
		{
			MethodInfo itemDeleter = AccessTools.DeclaredMethod(typeof(Inventory), "RemoveItem", new Type[1] { typeof(ItemData) }, (Type[])null);
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Callvirt && CodeInstructionExtensions.OperandIs(instruction, (MemberInfo)itemDeleter))
				{
					yield return new CodeInstruction(OpCodes.Dup, (object)null);
					yield return new CodeInstruction(OpCodes.Stsfld, (object)AccessTools.DeclaredField(typeof(ItemInfo), "currentlyUpgradingItem"));
				}
				yield return instruction;
			}
		}

		private static void ResetCurrentlyUpgradingItem()
		{
			currentlyUpgradingItem = null;
		}

		private static void CopyCustomDataFromUpgradedItem(ItemDrop item)
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			if (currentlyUpgradingItem != null)
			{
				item.m_itemData.m_customData = currentlyUpgradingItem.m_customData;
				if (ItemExtensions.itemInfo.TryGetValue(item.m_itemData, out ItemInfo value))
				{
					value.ItemData = item.m_itemData;
					ItemExtensions.itemInfo.Remove(currentlyUpgradingItem);
					ItemExtensions.itemInfo.Add(item.m_itemData, value);
					foreach (CustomItemData value2 in value.data.Values)
					{
						value2.Upgraded();
					}
				}
				currentlyUpgradingItem = null;
				return;
			}
			GameObject dropPrefab = item.m_itemData.m_dropPrefab;
			if (dropPrefab == null || item.m_itemData.m_customData.Count != 0)
			{
				return;
			}
			ZNetView component = ((Component)item).GetComponent<ZNetView>();
			ZDO val = ((Object.op_Implicit((Object)(object)component) && component.IsValid()) ? component.GetZDO() : null);
			if (val == null)
			{
				return;
			}
			if (!ZDOExtraData.s_ints.ContainsKey(val.m_uid))
			{
				LogManager.Log.Debug($"s_ints does not contain m_uid [{val.m_uid}] Adding.");
				ZDOExtraData.s_ints.Add(val.m_uid, new BinarySearchDictionary<int, int>());
			}
			if (ZDOExtraData.s_ints[val.m_uid].ContainsKey(StringExtensionMethods.GetStableHashCode("dataCount")))
			{
				return;
			}
			item.m_itemData.m_customData = new Dictionary<string, string>(dropPrefab.GetComponent<ItemDrop>().m_itemData.m_customData);
			int num = 0;
			val.Set("dataCount", item.m_itemData.m_customData.Count);
			foreach (KeyValuePair<string, string> customDatum in item.m_itemData.m_customData)
			{
				val.Set($"data_{num}", customDatum.Key);
				val.Set($"data__{num++}", customDatum.Value);
			}
		}

		private static IEnumerable<CodeInstruction> ImportCustomDataOnUpgrade(IEnumerable<CodeInstruction> instructionList)
		{
			List<CodeInstruction> list = instructionList.ToList();
			foreach (CodeInstruction instruction in list)
			{
				yield return instruction;
				if (instruction.opcode == OpCodes.Stfld && CodeInstructionExtensions.OperandIs(instruction, (MemberInfo)AccessTools.DeclaredField(typeof(ItemData), "m_dropPrefab")))
				{
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ItemInfo), "CopyCustomDataFromUpgradedItem", (Type[])null, (Type[])null));
				}
			}
		}

		static ItemInfo()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_015b: 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_0183: Expected O, but got Unknown
			//IL_0183: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			//IL_01f2: Expected O, but got Unknown
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Expected O, but got Unknown
			//IL_0254: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Expected O, but got Unknown
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Expected O, but got Unknown
			//IL_0304: Expected O, but got Unknown
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Expected O, but got Unknown
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Expected O, but got Unknown
			//IL_0396: Expected O, but got Unknown
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Expected O, but got Unknown
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Expected O, but got Unknown
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Expected O, but got Unknown
			//IL_053f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Expected O, but got Unknown
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Expected O, but got Unknown
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Expected O, but got Unknown
			//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_062c: Expected O, but got Unknown
			//IL_062c: Expected O, but got Unknown
			//IL_066b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Expected O, but got Unknown
			ForceLoadTypes = new HashSet<Type>();
			typeInheritorsCache = new Dictionary<Type, HashSet<Type>>();
			knownTypes = new HashSet<string>();
			Harmony val = new Harmony("org.bepinex.helpers.ItemDataManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "Save", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveInventoryPrefix", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			foreach (MethodInfo item in from m in typeof(ItemData).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name == "SaveToZDO"
				select m)
			{
				val.Patch((MethodBase)item, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SavePrefix", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[4]
			{
				typeof(ItemData),
				typeof(int),
				typeof(int),
				typeof(int)
			}, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckItemDataStackableAddItem", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyCustomItemDataStackableAddItem", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "CanAddItem", new Type[2]
			{
				typeof(ItemData),
				typeof(int)
			}, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveCheckingForStackableItemData", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemInfo), "ResetCheckingForStackableItemData", (Type[])null), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[1] { typeof(ItemData) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "SaveCheckingForStackableItemData", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(ItemInfo), "ResetCheckingForStackableItemData", (Type[])null), (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "FindFreeStackSpace", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckStackableInFindFreeStackMethods", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(Inventory), "FindFreeStackItem", (Type[])null, (Type[])null);
			HarmonyMethod val2 = new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "CheckStackableInFindFreeStackMethods", (Type[])null, (Type[])null));
			val.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ResetNewValuesOnStackable", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ApplyNewValuesOnStackable", (Type[])null, (Type[])null)), val2, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemDrop), "AutoStackItems", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "HandleAutostackableItems", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(InventoryGui), "DoCrafting", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "TransferCustomItemDataOnUpgrade", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ResetCurrentlyUpgradingItem", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			foreach (MethodInfo item2 in from m in typeof(ItemData).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name == "LoadFromZDO"
				select m)
			{
				val.Patch((MethodBase)item2, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypes", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "Load", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypesOnPlayerLoaded", (Type[])null, (Type[])null), 700, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Inventory), "AddItem", new Type[7]
			{
				typeof(string),
				typeof(int),
				typeof(int),
				typeof(int),
				typeof(long),
				typeof(string),
				typeof(bool)
			}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "RegisterForceLoadedTypesAddItem", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo2 = AccessTools.DeclaredMethod(typeof(ItemDrop), "Awake", (Type[])null, (Type[])null);
			val2 = new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ImportCustomDataOnUpgrade", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null);
			val.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDropAwake", (Type[])null, (Type[])null), 800, (string[])null, (string[])null, (bool?)null), val2, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemDrop), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDropAwakeDelayed", (Type[])null, (Type[])null), 799, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemData), "Clone", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePrefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePostfix", (Type[])null, (Type[])null), 500, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ItemData), "Clone", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ItemInfo), "ItemDataClonePostfixDelayed", (Type[])null, (Type[])null), 499, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	[PublicAPI]
	internal class ForeignItemInfo : IEnumerable<object>, IEnumerable
	{
		private readonly object foreignItemInfo;

		public string Mod => ((string)foreignItemInfo.GetType().GetProperty("Mod")?.GetValue(foreignItemInfo)) ?? "";

		public ItemData ItemData { get; private set; }

		public string? this[string key]
		{
			get
			{
				object obj = foreignItemInfo.GetType().InvokeMember("Item", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty, null, foreignItemInfo, new object[1] { key });
				if (obj != null)
				{
					return (string)obj.GetType().GetProperty("Value")?.GetValue(obj);
				}
				return null;
			}
			set
			{
				foreignItemInfo.GetType().GetMethod("set_Item", BindingFlags.Instance | BindingFlags.Public)?.Invoke(foreignItemInfo, new object[2] { key, value });
			}
		}

		internal ForeignItemInfo(ItemData itemData, object foreignItemInfo)
		{
			ItemData = itemData;
			this.foreignItemInfo = foreignItemInfo;
		}

		public T GetOrCreate<T>(string key = "") where T : class, new()
		{
			return Add<T>(key) ?? Get<T>(key);
		}

		private object? call(string name, object?[] values, Type?[] args, Type? generic = null)
		{
			MethodInfo[] methods = foreignItemInfo.GetType().GetMethods();
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == name && (from p in methodInfo.GetParameters()
					select (!p.ParameterType.IsGenericParameter) ? p.ParameterType : null).SequenceEqual<Type>(args) && (object)generic != null == methodInfo.IsGenericMethod)
				{
					MethodInfo methodInfo2 = methodInfo;
					if ((object)generic != null)
					{
						methodInfo2 = methodInfo2.MakeGenericMethod(generic);
					}
					methodInfo2.Invoke(foreignItemInfo, values);
				}
			}
			return null;
		}

		public T? Add<T>(string key = "") where T : class, new()
		{
			return call("Add", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as T;
		}

		public T? Get<T>(string key = "") where T : class
		{
			return call("Get", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as T;
		}

		public Dictionary<string, T> GetAll<T>() where T : class
		{
			return ((call("GetAll", Array.Empty<object>(), Array.Empty<Type>(), typeof(T)) as T) as Dictionary<string, T>) ?? new Dictionary<string, T>();
		}

		public bool Remove(string key = "")
		{
			return call("Add", new object[1] { key }, new Type[1] { typeof(string) }) as bool? == true;
		}

		public bool Remove<T>(string key = "") where T : class
		{
			return call("Remove", new object[1] { key }, new Type[1] { typeof(string) }, typeof(T)) as bool? == true;
		}

		public bool Remove<T>(T itemData) where T : class
		{
			return call("Remove", new object[1] { itemData }, new Type[1], typeof(T)) as bool? == true;
		}

		public void Save()
		{
			call("Save", Array.Empty<object>(), Array.Empty<Type>());
		}

		public void LoadAll()
		{
			call("LoadAll", Array.Empty<object>(), Array.Empty<Type>());
		}

		public IEnumerator<object> GetEnumerator()
		{
			return (IEnumerator<object>)((call("GetEnumerator", Array.Empty<object>(), Array.Empty<Type>()) as IEnumerator<object>) ?? ((object)new List<object>().GetEnumerator()));
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[PublicAPI]
	internal static class ItemExtensions
	{
		internal static readonly ConditionalWeakTable<ItemData, ItemInfo> itemInfo = new ConditionalWeakTable<ItemData, ItemInfo>();

		private static readonly ConditionalWeakTable<ItemData, Dictionary<string, ForeignItemInfo?>> foreignItemInfo = new ConditionalWeakTable<ItemData, Dictionary<string, ForeignItemInfo>>();

		public static ItemInfo Data(this ItemData item)
		{
			if (itemInfo.TryGetValue(item, out ItemInfo value))
			{
				return value;
			}
			itemInfo.Add(item, value = new ItemInfo(item));
			return value;
		}

		public static ForeignItemInfo? Data(this ItemData item, string mod)
		{
			Dictionary<string, ForeignItemInfo> orCreateValue = ItemExtensions.foreignItemInfo.GetOrCreateValue(item);
			if (orCreateValue.TryGetValue(mod, out var value))
			{
				return value;
			}
			if (!Chainloader.PluginInfos.TryGetValue(mod, out var value2))
			{
				return null;
			}
			object obj = ((object)value2.Instance).GetType().Assembly.GetType(typeof(ItemExtensions).FullName)?.GetMethod("Data", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(ItemData) }, Array.Empty<ParameterModifier>())?.Invoke(null, new object[1] { item });
			if (obj != null)
			{
				return orCreateValue[mod] = new ForeignItemInfo(item, obj);
			}
			LogManager.Log.Warning("Mod " + mod + " has an " + typeof(ItemExtensions).FullName + " class, but no Data(ItemDrop.ItemData) method could be called on it.");
			return orCreateValue[mod] = null;
		}
	}
	public enum LogLevels
	{
		Debug,
		Info,
		Warning,
		Error,
		Fatal
	}
	internal class LogManager
	{
		private static LogManager? _instance;

		private readonly Dictionary<string, Logger?> _loggers = new Dictionary<string, Logger>();

		public static ILogIt Log;

		public static void Init(string pluginName, out ILogIt? logger)
		{
			Init();
			logger = GetLogger(pluginName);
		}

		public static void Init()
		{
			if (_instance == null)
			{
				_instance = new LogManager();
				Log = GetLogger("vapok.mod.core");
			}
		}

		public static void Destroy()
		{
			if (_instance == null)
			{
				return;
			}
			foreach (KeyValuePair<string, Logger> logger in _instance._loggers)
			{
				if (logger.Value != null)
				{
					logger.Value.Destroy();
				}
			}
			_instance._loggers.Clear();
		}

		public static ILogIt? GetLogger(string pluginName)
		{
			if (_instance == null)
			{
				return null;
			}
			if (_instance._loggers.ContainsKey(pluginName))
			{
				return _instance._loggers[pluginName];
			}
			_instance._loggers.Add(pluginName, new Logger(pluginName));
			return _instance._loggers[pluginName];
		}
	}
	internal class Logger : ILogIt
	{
		private readonly ManualLogSource _logger;

		public Logger(string loggerName)
		{
			_logger = Logger.CreateLogSource(loggerName);
		}

		public void Destroy()
		{
			Logger.Sources.Remove((ILogSource)(object)_logger);
		}

		public void Debug(string message)
		{
			if (ConfigSyncBase.LoggingEnabled == null || ConfigSyncBase.LogLevel == null || (ConfigSyncBase.LoggingEnabled.Value && ConfigSyncBase.LogLevel.Value <= LogLevels.Debug))
			{
				LogIt((LogLevel)32, message);
			}
		}

		public void Info(string message)
		{
			if (ConfigSyncBase.LoggingEnabled == null || ConfigSyncBase.LogLevel == null || (ConfigSyncBase.LoggingEnabled.Value && ConfigSyncBase.LogLevel.Value <= LogLevels.Info))
			{
				LogIt((LogLevel)16, message);
			}
		}

		public void Message(string message)
		{
			LogIt((LogLevel)8, message);
		}

		public void Warning(string message)
		{
			if (ConfigSyncBase.LoggingEnabled == null || ConfigSyncBase.LogLevel == null || (ConfigSyncBase.LoggingEnabled.Value && ConfigSyncBase.LogLevel.Value <= LogLevels.Warning))
			{
				LogIt((LogLevel)4, message);
			}
		}

		public void Error(string message)
		{
			if (ConfigSyncBase.LoggingEnabled == null || ConfigSyncBase.LogLevel == null || (ConfigSyncBase.LoggingEnabled.Value && ConfigSyncBase.LogLevel.Value <= LogLevels.Error))
			{
				LogIt((LogLevel)2, message);
			}
		}

		public void Fatal(string message)
		{
			if (ConfigSyncBase.LoggingEnabled == null || ConfigSyncBase.LogLevel == null || (ConfigSyncBase.LoggingEnabled.Value && ConfigSyncBase.LogLevel.Value <= LogLevels.Fatal))
			{
				LogIt((LogLevel)1, message);
			}
		}

		private void LogIt(LogLevel level, string message)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Type declaringType = new StackFrame(2).GetMethod().DeclaringType;
			string name = new StackFrame(2).GetMethod().Name;
			_logger.Log(level, (object)$"[{declaringType}.{name}] {message}");
		}
	}
}
namespace Vapok.Common.Managers.StatusEffects
{
	[PublicAPI]
	[Description("The ItemDrop effect to apply the status effect")]
	public enum EffectType
	{
		Equip,
		Attack,
		Consume,
		Set
	}
	internal struct SE_Item
	{
		public StatusEffect Effect;

		public EffectType Type;
	}
	[PublicAPI]
	public class CustomSE
	{
		private static readonly List<CustomSE> RegisteredEffects = new List<CustomSE>();

		private static readonly Dictionary<StatusEffect, CustomSE> CustomEffectMap = new Dictionary<StatusEffect, CustomSE>();

		internal static readonly List<StatusEffect> CustomSEs = new List<StatusEffect>();

		internal static readonly Dictionary<SE_Item, string> AddToPrefabs = new Dictionary<SE_Item, string>();

		[Description("Instance of the StatusEffect.")]
		public readonly StatusEffect Effect;

		[Description("Set the type of effect you are adding. If the item can attack, consume, or be equipped, change this to correspond.")]
		public EffectType Type;

		private string _folderName = "icons";

		private AssetBundle? _assetBundle;

		[Description("Sets the icon for the StatusEffect. Must be 64x64")]
		public Sprite? IconSprite;

		private string? IconName;

		private LocalizeKey? _name;

		private static Localization? _english;

		private static BaseUnityPlugin? _plugin;

		[Description("Sets the icon for the StatusEffect. Must be 64x64")]
		public string? Icon
		{
			get
			{
				return IconName;
			}
			set
			{
				IconName = value;
				IconSprite = ((IconName == null) ? null : loadSprite(IconName));
				Effect.m_icon = IconSprite;
			}
		}

		[Description("Sets the in-game name for the StatusEffect")]
		public LocalizeKey Name
		{
			get
			{
				LocalizeKey name = _name;
				if (name != null)
				{
					return name;
				}
				StatusEffect effect = Effect;
				if (effect.m_name.StartsWith("$"))
				{
					_name = new LocalizeKey(effect.m_name);
				}
				else
				{
					string text = "$statuseffect_" + ((Object)Effect).name.Replace(" ", "_");
					_name = new LocalizeKey(text).English(effect.m_name);
					effect.m_name = text;
				}
				return _name;
			}
		}

		private static Localization english
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				if (_english == null)
				{
					_english = new Localization();
					_english.SetupLanguage("English");
				}
				return _english;
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		public CustomSE(string assetBundleFileName, string customEffectName, string folderName = "assets")
			: this(EffectManager.RegisterAssetBundle(assetBundleFileName, folderName), customEffectName)
		{
		}

		public CustomSE(AssetBundle bundle, string customEffectName)
		{
			Effect = EffectManager.RegisterCustomSE(bundle, customEffectName);
			_assetBundle = bundle;
			RegisteredEffects.Add(this);
			CustomEffectMap[Effect] = this;
		}

		public CustomSE(string customEffectName)
		{
			Effect = ScriptableObject.CreateInstance<StatusEffect>();
			EffectManager.RegisterCustomSE(Effect, customEffectName);
			RegisteredEffects.Add(this);
			CustomEffectMap[Effect] = this;
		}

		public CustomSE(Enums.StatusEffects statusEffect, string customEffectName)
		{
			switch (statusEffect)
			{
			case Enums.StatusEffects.Burning:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Burning>();
				break;
			case Enums.StatusEffects.Cozy:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Cozy>();
				break;
			case Enums.StatusEffects.Demister:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Demister>();
				break;
			case Enums.StatusEffects.Finder:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Finder>();
				break;
			case Enums.StatusEffects.Frost:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Frost>();
				break;
			case Enums.StatusEffects.Harpooned:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Harpooned>();
				break;
			case Enums.StatusEffects.HealthUpgrade:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_HealthUpgrade>();
				break;
			case Enums.StatusEffects.Poison:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Poison>();
				break;
			case Enums.StatusEffects.Puke:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Puke>();
				break;
			case Enums.StatusEffects.Rested:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Rested>();
				break;
			case Enums.StatusEffects.Shield:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Shield>();
				break;
			case Enums.StatusEffects.Smoke:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Smoke>();
				break;
			case Enums.StatusEffects.Spawn:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Spawn>();
				break;
			case Enums.StatusEffects.Stats:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Stats>();
				break;
			case Enums.StatusEffects.Wet:
				Effect = (StatusEffect)(object)ScriptableObject.CreateInstance<SE_Wet>();
				break;
			default:
				Effect = ScriptableObject.CreateInstance<StatusEffect>();
				break;
			}
			EffectManager.RegisterCustomSE(Effect, customEffectName);
			RegisteredEffects.Add(this);
			CustomEffectMap[Effect] = this;
		}

		private byte[]? ReadEmbeddedFileBytes(string name)
		{
			using MemoryStream memoryStream = new MemoryStream();
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + ((_folderName == "") ? "" : ".") + _folderName + "." + name);
			if (manifestResourceStream == null)
			{
				return null;
			}
			manifestResourceStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private Texture2D? loadTexture(string name)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			byte[] array = ReadEmbeddedFileBytes(name);
			if (array != null)
			{
				Texture2D val = new Texture2D(0, 0);
				val.LoadRawTextureData(array);
				return val;
			}
			return null;
		}

		private Sprite loadSprite(string name)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = loadTexture(name);
			if (val != null)
			{
				return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), Vector2.zero);
			}
			AssetBundle? assetBundle = _assetBundle;
			Sprite val2 = ((assetBundle != null) ? assetBundle.LoadAsset<Sprite>(name) : null);
			if (val2 != null)
			{
				return val2;
			}
			throw new FileNotFoundException("Could not find a file named " + name + " for the effect icon");
		}

		[Description("Adds the CustomSE to a prefab by adding it on ZNetScene awake. The effect type will be used to determine when the effect applies.")]
		public void AddSEToPrefab(CustomSE customSE, string prefabName)
		{
			SE_Item key = new SE_Item
			{
				Effect = customSE.Effect,
				Type = customSE.Type
			};
			AddToPrefabs.Add(key, prefabName);
		}
	}
	internal static class EffectManager
	{
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static bool _initialized;

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		static EffectManager()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			_initialized = false;
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			Harmony val = new Harmony("org.bepinex.helpers.StatusEffectManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(EffectManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(EffectManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
			}
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId key = new BundleId
			{
				assetBundleFileName = assetBundleFileName,
				folderName = folderName
			};
			if (!bundleCache.TryGetValue(key, out AssetBundle value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + ((folderName == "") ? "" : ".") + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static StatusEffect RegisterCustomSE(string assetBundleFileName, string customEffectName, string folderName = "assets")
		{
			return RegisterCustomSE(RegisterAssetBundle(assetBundleFileName, folderName), customEffectName);
		}

		public static StatusEffect RegisterCustomSE(AssetBundle assets, string customEffectName)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			StatusEffect val = (StatusEffect)assets.LoadAsset<ScriptableObject>(customEffectName);
			CustomSE.CustomSEs.Add(val);
			return val;
		}

		public static StatusEffect RegisterCustomSE(StatusEffect customSE, string customEffectName)
		{
			((Object)customSE).name = customEffectName;
			CustomSE.CustomSEs.Add(customSE);
			return customSE;
		}

		public static ItemData AddSEToItem(this ItemData itemData, CustomSE customSE)
		{
			SE_Item customSE2 = new SE_Item
			{
				Effect = customSE.Effect,
				Type = customSE.Type
			};
			return itemData.AddSEToItem(customSE2);
		}

		private static ItemData AddSEToItem(this ItemData itemData, SE_Item customSE)
		{
			switch (customSE.Type)
			{
			case EffectType.Equip:
				itemData.m_shared.m_equipStatusEffect = customSE.Effect;
				break;
			case EffectType.Attack:
				itemData.m_shared.m_attackStatusEffect = customSE.Effect;
				break;
			case EffectType.Consume:
				itemData.m_shared.m_consumeStatusEffect = customSE.Effect;
				break;
			case EffectType.Set:
				itemData.m_shared.m_setSize = 1;
				itemData.m_shared.m_setName = ((Object)customSE.Effect).name;
				itemData.m_shared.m_setStatusEffect = customSE.Effect;
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
			return itemData;
		}

		[HarmonyPriority(700)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			foreach (StatusEffect customSE in CustomSE.CustomSEs)
			{
				if (!__instance.m_StatusEffects.Contains(customSE))
				{
					__instance.m_StatusEffects.Add(customSE);
				}
			}
			__instance.UpdateRegisters();
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (KeyValuePair<SE_Item, string> addToPrefab in CustomSE.AddToPrefabs)
			{
				try
				{
					GameObject prefab = __instance.GetPrefab(addToPrefab.Value);
					if (prefab != null)
					{
						ItemDrop val = prefab.GetComponent<ItemDrop>() ?? prefab.GetComponentInChildren<ItemDrop>();
						Aoe val2 = prefab.GetComponent<Aoe>() ?? prefab.GetComponentInChildren<Aoe>();
						EffectArea val3 = prefab.GetComponent<EffectArea>() ?? prefab.GetComponentInChildren<EffectArea>();
						if (Object.op_Implicit((Object)(object)val))
						{
							val.m_itemData.AddSEToItem(addToPrefab.Key);
						}
						else if (Object.op_Implicit((Object)(object)val2))
						{
							val2.m_statusEffect = ((Object)addToPrefab.Key.Effect).name;
						}
						else if (Object.op_Implicit((Object)(object)val3))
						{
							val3.m_statusEffect = ((Object)addToPrefab.Key.Effect).name;
						}
						else
						{
							LogManager.Log.Warning("The prefab '" + ((Object)prefab).name + "' does not have an ItemDrop, AOE, or EffectArea component. Cannot add the StatusEffect to the prefab.");
						}
					}
				}
				catch (Exception ex)
				{
					LogManager.Log.Warning("BROKE - " + ex.Message);
				}
			}
		}
	}
}
namespace Vapok.Common.Managers.Skill
{
	[PublicAPI]
	internal class Skill
	{
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public string? Category;
		}

		private class SkillConfig
		{
			public Skill Skill;

			public ConfigEntry<float> SkillGain;

			public ConfigEntry<float> SkillEffect;

			public SkillConfig(Skill skill, ConfigEntry<float> conf1, ConfigEntry<float> conf2)
			{
				Skill = skill;
				SkillGain = conf1;
				SkillEffect = conf2;
			}
		}

		[HarmonyPatch(typeof(Skills), "IsSkillValid")]
		private static class Patch_Skills_IsSkillValid
		{
			private static void Postfix(SkillType type, ref bool __result)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				if (!__result && skills.ContainsKey(type))
				{
					__result = true;
				}
			}
		}

		private static bool _initialized;

		private static readonly Dictionary<SkillType, Skill> skills;

		internal static readonly Dictionary<string, Skill> skillByName;

		private readonly string skillName;

		private readonly string internalSkillName;

		private readonly SkillDef skillDef;

		public readonly LocalizeKey Name;

		public readonly LocalizeKey Description;

		private float skillEffectFactor = 1f;

		public bool Configurable;

		private static bool InitializedTerminal;

		private static BaseUnityPlugin? _plugin;

		public float SkillGainFactor
		{
			get
			{
				return skillDef.m_increseStep;
			}
			set
			{
				skillDef.m_increseStep = value;
				this.SkillGainFactorChanged?.Invoke(value);
			}
		}

		public float SkillEffectFactor
		{
			get
			{
				return skillEffectFactor;
			}
			set
			{
				skillEffectFactor = value;
				this.SkillEffectFactorChanged?.Invoke(value);
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_0041: 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_004c: Expected O, but got Unknown
				object obj = _plugin;
				if (obj == null)
				{
					BaseUnityPlugin val = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)Assembly.GetExecutingAssembly().DefinedTypes.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
					_plugin = val;
					obj = (object)val;
				}
				return (BaseUnityPlugin)obj;
			}
		}

		public event Action<float>? SkillGainFactorChanged;

		public event Action<float>? SkillEffectFactorChanged;

		public Skill(string englishName, string icon)
			: this(englishName, loadSprite(icon, 64, 64))
		{
		}

		public unsafe Skill(string englishName, Sprite icon)
		{
			//IL_0012: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			SkillType val = fromName(englishName);
			string text = new Regex("[^a-zA-Z]").Replace(englishName, "_");
			skills[val] = this;
			skillByName[englishName] = this;
			skillDef = new SkillDef
			{
				m_description = "$skilldesc_" + text,
				m_icon = icon,
				m_increseStep = 1f,
				m_skill = val
			};
			internalSkillName = text;
			skillName = englishName;
			Name = new LocalizeKey("skill_" + ((object)(*(SkillType*)(&val))/*cast due to .constrained prefix*/).ToString()).English(englishName);
			Description = new LocalizeKey("skilldesc_" + text);
		}

		public static SkillType fromName(string englishName)
		{
			return (SkillType)Math.Abs(StringExtensionMethods.GetStableHashCode(englishName));
		}

		static Skill()
		{
			//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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00a2: 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_00dd: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_016e: Expected O, but got Unknown
			_initialized = false;
			skills = new Dictionary<SkillType, Skill>();
			skillByName = new Dictionary<string, Skill>();
			InitializedTerminal = false;
			Harmony val = new Harmony("org.bepinex.helpers.skillmanager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "GetSkillDef", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_GetSkillDef", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "CheatRaiseSkill", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_CheatRaiseskill", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Skills), "CheatResetSkill", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Skills_CheatResetSkill", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Terminal), "InitTerminal", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Terminal_InitTerminal_Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Skill), "Patch_Terminal_InitTerminal", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
			}
		}

		private static void Patch_FejdStartup()
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			List<SkillConfig> list = new List<SkillConfig>();
			foreach (Skill skill in skills.Values)
			{
				if (skill.Configurable)
				{
					ConfigEntry<float> skillGain = null;
					ConfigEntry<float> skillEffect = null;
					string key = skill.Name.Key;
					Regex regex = new Regex("['[\"\\]]");
					CustomLocalization jvlLocalization = Localizer.JvlLocalization;
					string text = "English";
					string text2 = regex.Replace(jvlLocalization.GetTranslations(ref text)[key], "").Trim();
					string category = Localization.instance.Localize(key).Trim();
					ConfigSyncBase.SyncedConfig(text2, "Skill gain factor", skill.SkillGainFactor, new ConfigDescription("The rate at which you gain experience for the skill.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 5f), new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = category
						}
					}), ref skillGain);
					skill.SkillGainFactor = skillGain.Value;
					skillGain.SettingChanged += delegate
					{
						skill.SkillGainFactor = skillGain.Value;
					};
					ConfigSyncBase.SyncedConfig(text2, "Skill effect factor", skill.SkillEffectFactor, new ConfigDescription("The power of the skill, based on the default power.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 5f), new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = category
						}
					}), ref skillEffect);
					skill.SkillEffectFactor = skillEffect.Value;
					skillEffect.SettingChanged += delegate
					{
						skill.SkillEffectFactor = skillEffect.Value;
					};
					list.Add(new SkillConfig(skill, skillGain, skillEffect));
				}
			}
		}

		private static void Patch_Skills_GetSkillDef(ref SkillDef? __result, List<SkillDef> ___m_skills, SkillType type)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (__result == null)
			{
				SkillDef val = GetSkillDef(type);
				if (val != null)
				{
					___m_skills.Add(val);
					__result = val;
				}
			}
		}

		private unsafe static bool Patch_Skills_CheatRaiseskill(Skills __instance, string name, float value, Player ___m_player)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			foreach (SkillType key in skills.Keys)
			{
				Skill skill = skills[key];
				if (string.Equals(skill.internalSkillName, name, StringComparison.CurrentCultureIgnoreCase))
				{
					Skill skill2 = __instance.GetSkill(key);
					skill2.m_level += value;
					skill2.m_level = Mathf.Clamp(skill2.m_level, 0f, 100f);
					((Character)___m_player).Message((MessageType)1, "Skill increased " + Localization.instance.Localize("$skill_" + ((object)(*(SkillType*)(&key))/*cast due to .constrained prefix*/).ToString()) + ": " + (int)skill2.m_level, 0, skill2.m_info.m_icon);
					Console.instance.Print("Skill " + skill.internalSkillName + " = " + skill2.m_level);
					return false;
				}
			}
			return true;
		}

		private static bool Patch_Skills_CheatResetSkill(Skills __instance, string name)
		{
			//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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			foreach (SkillType key in skills.Keys)
			{
				Skill skill = skills[key];
				if (string.Equals(skill.internalSkillName, name, StringComparison.CurrentCultureIgnoreCase))
				{
					__instance.ResetSkill(key);
					Console.instance.Print("Skill " + skill.internalSkillName + " reset");
					return false;
				}
			}
			return true;
		}

		private static void Patch_Terminal_InitTerminal_Prefix()
		{
			InitializedTerminal = Terminal.m_terminalInitialized;
		}

		private static void Patch_Terminal_InitTerminal()
		{
			if (!InitializedTerminal)
			{
				AddSkill(Terminal.commands["raiseskill"]);
				AddSkill(Terminal.commands["resetskill"]);
			}
			static void AddSkill(ConsoleCommand command)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				ConsoleOptionsFetcher fetcher = command.m_tabOptionsFetcher;
				command.m_tabOptionsFetcher = (ConsoleOptionsFetcher)delegate
				{
					List<string> list = fetcher.Invoke();
					list.AddRange(skills.Values.Select((Skill skill) => skill.internalSkillName));
					return list;
				};
			}
		}

		private static SkillDef? GetSkillDef(SkillType skillType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!skills.ContainsKey(skillType))
			{
				return null;
			}
			return skills[skillType].skillDef;
		}

		private static byte[] ReadEmbeddedFileBytes(string name)
		{
			string text = Assembly.GetExecutingAssembly().GetName().Name + "." + name;
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(text);
			if (manifestResourceStream == null)
			{
				throw new FileNotFoundException("Embedded resource not found: " + text + ". Ensure the file is included as an embedded resource.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			manifestResourceStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private static Texture2D loadTexture(string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			Texture2D val = new Texture2D(0, 0);
			val.LoadRawTextureData(ReadEmbeddedFileBytes("icons." + name));
			return val;
		}

		private static Sprite loadSprite(string name, int width, int height)
		{
			//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)
			return Sprite.Create(loadTexture(name), new Rect(0f, 0f, (float)width, (float)height), Vector2.zero);
		}
	}
	[PublicAPI]
	internal static class SkillExtensions
	{
		public static float GetSkillFactor(this Character character, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return character.GetSkillFactor(Skill.fromName(name)) * Skill.skillByName[name].SkillEffectFactor;
		}

		public static float GetSkillFactor(this Skills skills, string name)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return skills.GetSkillFactor(Skill.fromName(name)) * Skill.skillByName[name].SkillEffectFactor;
		}

		public static void RaiseSkill(this Character character, string name, float value = 1f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			character.RaiseSkill(Skill.fromName(name), value);
		}

		public static void RaiseSkill(this Skills skill, string name, float value = 1f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			skill.RaiseSkill(Skill.fromName(name), value);
		}
	}
}
namespace Vapok.Common.Managers.PieceManager
{
	[PublicAPI]
	internal static class MaterialReplacer
	{
		public enum ShaderType
		{
			PieceShader,
			VegetationShader,
			RockShader,
			RugShader,
			GrassShader,
			CustomCreature,
			UseUnityShader
		}

		private static readonly Dictionary<GameObject, bool> ObjectToSwap;

		internal static readonly Dictionary<string, Material> OriginalMaterials;

		private static readonly Dictionary<GameObject, ShaderType> ObjectsForShaderReplace;

		private static readonly HashSet<Shader> CachedShaders;

		private static bool hasRun;

		private static bool _initialized;

		static MaterialReplacer()
		{
			//IL_0039: 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_0072: Expected O, but got Unknown
			CachedShaders = new HashSet<Shader>();
			hasRun = false;
			_initialized = false;
			OriginalMaterials = new Dictionary<string, Material>();
			ObjectToSwap = new Dictionary<GameObject, bool>();
			ObjectsForShaderReplace = new Dictionary<GameObject, ShaderType>();
			new Harmony("org.bepinex.helpers.PieceManager").Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZoneSystem), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(MaterialReplacer), "ReplaceAllMaterialsWithOriginal", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void RegisterGameObjectForShaderSwap(GameObject go, ShaderType type)
		{
			if (!ObjectsForShaderReplace.ContainsKey(go))
			{
				ObjectsForShaderReplace.Add(go, type);
			}
		}

		public static void RegisterGameObjectForMatSwap(GameObject go, bool isJotunnMock = false)
		{
			if (!ObjectToSwap.ContainsKey(go))
			{
				ObjectToSwap.Add(go, isJotunnMock);
			}
		}

		private static void GetAllMaterials()
		{
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				OriginalMaterials[((Object)val).name] = val;
			}
		}

		public static void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
			}
		}

		[HarmonyPriority(700)]
		private static void ReplaceAllMaterialsWithOriginal()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)SystemInfo.graphicsDeviceType == 4 || hasRun)
			{
				return;
			}
			if (OriginalMaterials.Count == 0)
			{
				GetAllMaterials();
			}
			foreach (KeyValuePair<GameObject, bool> item in ObjectToSwap)
			{
				GameObject key = item.Key;
				bool value = item.Value;
				ProcessGameObjectMaterials(key, value);
			}
			AssetBundle[] array = Resources.FindObjectsOfTypeAll<AssetBundle>();
			foreach (AssetBundle val in array)
			{
				IEnumerable<Shader> enumerable3;
				try
				{
					IEnumerable<Shader> enumerable2;
					if (!val.isStreamedSceneAssetBundle || !Object.op_Implicit((Object)(object)val))
					{
						IEnumerable<Shader> enumerable = val.LoadAllAssets<Shader>();
						enumerable2 = enumerable;
					}
					else
					{
						enumerable2 = from shader in ((IEnumerable<string>)val.GetAllAssetNames()).Select((Func<string, Shader>)val.LoadAsset<Shader>)
							where (Object)(object)shader != (Object)null
							select shader;
					}
					enumerable3 = enumerable2;
				}
				catch (Exception)
				{
					continue;
				}
				if (enumerable3 == null)
				{
					continue;
				}
				foreach (Shader item2 in enumerable3)
				{
					CachedShaders.Add(item2);
				}
			}
			foreach (KeyValuePair<GameObject, ShaderType> item3 in ObjectsForShaderReplace)
			{
				GameObject key2 = item3.Key;
				ShaderType value2 = item3.Value;
				ProcessGameObjectShaders(key2, value2);
			}
			hasRun = true;
		}

		private static void ProcessGameObjectMaterials(GameObject go, bool isJotunnMock)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer obj in componentsInChildren)
			{
				Material[] sharedMaterials = obj.sharedMaterials.Select((Material material) => ReplaceMaterial(material, isJotunnMock)).ToArray();
				obj.sharedMaterials = sharedMaterials;
			}
		}

		private static Material ReplaceMaterial(Material originalMaterial, bool isJotunnMock)
		{
			string text = (isJotunnMock ? "JVLmock_" : "_REPLACE_");
			if (!((Object)originalMaterial).name.StartsWith(text, StringComparison.Ordinal))
			{
				return originalMaterial;
			}
			string text2 = ((Object)originalMaterial).name.Replace(" (Instance)", "").Replace(text, "");
			if (OriginalMaterials.TryGetValue(text2, out Material value))
			{
				return value;
			}
			LogManager.Log.Warning("No suitable material found to replace: " + text2);
			return originalMaterial;
		}

		private static void ProcessGameObjectShaders(GameObject go, ShaderType shaderType)
		{
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Material[] sharedMaterials = componentsInChildren[i].sharedMaterials;
				foreach (Material val in sharedMaterials)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.shader = GetShaderForType(val.shader, shaderType, ((Object)val.shader).name);
					}
				}
			}
		}

		private static Shader GetShaderForType(Shader orig, ShaderType shaderType, string originalShaderName)
		{
			return (Shader)(shaderType switch
			{
				ShaderType.PieceShader => FindShaderWithName(orig, "Custom/Piece"), 
				ShaderType.VegetationShader => FindShaderWithName(orig, "Custom/Vegetation"), 
				ShaderType.RockShader => FindShaderWithName(orig, "Custom/StaticRock"), 
				ShaderType.RugShader => FindShaderWithName(orig, "Custom/Rug"), 
				ShaderType.GrassShader => FindShaderWithName(orig, "Custom/Grass"), 
				ShaderType.CustomCreature => FindShaderWithName(orig, "Custom/Creature"), 
				ShaderType.UseUnityShader => FindShaderWithName(orig, ((Object)(object)FindShaderWithName(orig, originalShaderName) != (Object)null) ? originalShaderName : "ToonDeferredShading2017"), 
				_ => FindShaderWithName(orig, "Standard"), 
			});
		}

		public static Shader FindShaderWithName(Shader origShader, string name)
		{
			foreach (Shader cachedShader in CachedShaders)
			{
				if (((Object)cachedShader).name == name)
				{
					return cachedShader;
				}
			}
			return origShader;
		}
	}
	[PublicAPI]
	internal enum CraftingTable
	{
		None,
		[InternalName("piece_workbench")]
		Workbench,
		[InternalName("piece_cauldron")]
		Cauldron,
		[InternalName("forge")]
		Forge,
		[InternalName("piece_artisanstation")]
		ArtisanTable,
		[InternalName("piece_stonecutter")]
		StoneCutter,
		[InternalName("piece_magetable")]
		MageTable,
		[InternalName("blackforge")]
		BlackForge,
		Custom
	}
	internal class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	[PublicAPI]
	internal class ExtensionList
	{
		public readonly List<ExtensionConfig> ExtensionStations = new List<ExtensionConfig>();

		public void Set(CraftingTable table, int maxStationDistance = 5)
		{
			ExtensionStations.Add(new ExtensionConfig
			{
				Table = table,
				maxStationDistance = maxStationDistance
			});
		}

		public void Set(string customTable, int maxStationDistance = 5)
		{
			ExtensionStations.Add(new ExtensionConfig
			{
				Table = CraftingTable.Custom,
				custom = customTable,
				maxStationDistance = maxStationDistance
			});
		}
	}
	internal struct ExtensionConfig
	{
		public CraftingTable Table;

		public float maxStationDistance;

		public string? custom;
	}
	[PublicAPI]
	internal class CraftingStationList
	{
		public readonly List<CraftingStationConfig> Stations = new List<CraftingStationConfig>();

		public void Set(CraftingTable table)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = table
			});
		}

		public void Set(string customTable)
		{
			Stations.Add(new CraftingStationConfig
			{
				Table = CraftingTable.Custom,
				custom = customTable
			});
		}
	}
	internal struct CraftingStationConfig
	{
		public CraftingTable Table;

		public int level;

		public string? custom;
	}
	[PublicAPI]
	internal enum BuildPieceCategory
	{
		Misc = 0,
		Crafting = 1,
		BuildingWorkbench = 2,
		BuildingStonecutter = 3,
		Furniture = 4,
		All = 100,
		Custom = 99
	}
	[PublicAPI]
	internal class RequiredResourcesList
	{
		public readonly List<Requirement> Requirements = new List<Requirement>();

		public void Add(string item, int amount, bool recover)
		{
			Requirements.Add(new Requirement
			{
				itemName = item,
				amount = amount,
				recover = recover
			});
		}
	}
	internal struct Requirement
	{
		public string itemName;

		public int amount;

		public bool recover;
	}
	internal struct SpecialProperties
	{
		[Description("Admins should be the only ones that can build this piece.")]
		public bool AdminOnly;

		[Description("Turns off generating a config for this build piece.")]
		public bool NoConfig;
	}
	[PublicAPI]
	internal class BuildingPieceCategory
	{
		public BuildPieceCategory Category;

		public string custom = "";

		public void Set(BuildPieceCategory category)
		{
			Category = category;
		}

		public void Set(string customCategory)
		{
			Category = BuildPieceCategory.Custom;
			custom = customCategory;
		}
	}
	[PublicAPI]
	internal class PieceTool
	{
		public readonly HashSet<string> Tools = new HashSet<string>();

		public void Add(string tool)
		{
			Tools.Add(tool);
		}
	}
	[PublicAPI]
	internal class BuildPiece
	{
		internal class PieceConfig
		{
			public ConfigEntry<string> craft;

			public ConfigEntry<BuildPieceCategory> category;

			public ConfigEntry<string> customCategory;

			public ConfigEntry<string> tools;

			public ConfigEntry<CraftingTable> extensionTable;

			public ConfigEntry<string> customExtentionTable;

			public ConfigEntry<float> maxStationDistance;

			public ConfigEntry<CraftingTable> table;

			public ConfigEntry<string> customTable;
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string? Category;

			[UsedImplicitly]
			public Action<ConfigEntryBase>? CustomDrawer;
		}

		private class SerializedRequirements
		{
			public readonly List<Requirement> Reqs;

			public SerializedRequirements(List<Requirement> reqs)
			{
				Reqs = reqs;
			}

			public SerializedRequirements(string reqs)
			{
				Reqs = reqs.Split(new char[1] { ',' }).Select(delegate(string r)
				{
					string[] array = r.Split(new char[1] { ':' });
					int result;
					bool result2 = default(bool);
					return new Requirement
					{
						itemName = array[0],
						amount = ((array.Length <= 1 || !int.TryParse(array[1], out result)) ? 1 : result),
						recover = (array.Length <= 2 || !bool.TryParse(array[2], out result2) || result2)
					};
				}).ToList();
			}

			public override string ToString()
			{
				return string.Join(",", Reqs.Select((Requirement r) => $"{r.itemName}:{r.amount}:{r.recover}"));
			}

			public static ItemDrop? fetchByName(ObjectDB objectDB, string name)
			{
				GameObject itemPrefab = objectDB.GetItemPrefab(name);
				ItemDrop obj = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if ((Object)(object)obj == (Object)null)
				{
					LogManager.Log.Warning(((!string.IsNullOrWhiteSpace(((Object)plugin).name)) ? ("[" + ((Object)plugin).name + "]") : "") + " The required item '" + name + "' does not exist.");
				}
				return obj;
			}

			public static Requirement[] toPieceReqs(SerializedRequirements craft)
			{
				return craft.Reqs.Where((Requirement r) => r.itemName != "").ToDictionary((Func<Requirement, string>)((Requirement r) => r.itemName), (Func<Requirement, Requirement>)delegate(Requirement r)
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Expected O, but got Unknown
					ItemDrop val = ResItem(r);
					return (val != null) ? new Requirement
					{
						m_amount = r.amount,
						m_resItem = val,
						m_recover = r.recover
					} : ((Requirement)null);
				}).Values.Where((Requirement v) => v != null).ToArray();
				static ItemDrop? ResItem(Requirement r)
				{
					return fetchByName(ObjectDB.instance, r.itemName);
				}
			}
		}

		internal static readonly List<BuildPiece> registeredPieces = new List<BuildPiece>();

		private static readonly Dictionary<Piece, BuildPiece> pieceMap = new Dictionary<Piece, BuildPiece>();

		internal static Dictionary<BuildPiece, PieceConfig> pieceConfigs = new Dictionary<BuildPiece, PieceConfig>();

		internal List<Conversion> Conversions = new List<Conversion>();

		internal List<ItemConversion> conversions = new List<ItemConversion>();

		[Description("Disables generation of the configs for your pieces. This is global, this turns it off for all pieces in your mod.")]
		public static bool ConfigurationEnabled = true;

		public readonly GameObject Prefab;

		[Description("Specifies the resources needed to craft the piece.\nUse .Add to add resources with their internal ID and an amount.\nUse one .Add for each resource type the building piece should need.")]
		public readonly RequiredResourcesList RequiredItems = new RequiredResourcesList();

		[Description("Sets the category for the building piece.")]
		public readonly BuildingPieceCategory Category = new BuildingPieceCategory();

		[Description("Specifies the tool needed to build your piece.\nUse .Add to add a tool.")]
		public readonly PieceTool Tool = new PieceTool();

		[Description("Specifies the crafting station needed to build your piece.\nUse .Add to add a crafting station, using the CraftingTable enum and a minimum level for the crafting station.")]
		public CraftingStationList Crafting = new CraftingStationList();

		[Description("Makes this piece a station extension")]
		public ExtensionList Extension = new ExtensionList();

		[Description("Change the extended/special properties of your build piece.")]
		public SpecialProperties SpecialProperties;

		[Description("Specifies a config entry which toggles whether a recipe is active.")]
		public ConfigEntryBase? RecipeIsActive;

		internal string[] activeTools;

		private static object? configManager;

		internal static BaseUnityPlugin? _plugin = null;

		internal static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Expected O, but got Unknown
				if (_plugin != null)
				{
					return _plugin;
				}
				IEnumerable<TypeInfo> source;
				try
				{
					source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
				}
				catch (ReflectionTypeLoadException ex)
				{
					source = from t in ex.Types
						where t != null
						select t.GetTypeInfo();
				}
				_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				return _plugin;
			}
		}

		public BuildPiece(string assetBundleFileName, string prefabName, string folderName = "assets")
			: this(PiecePrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
		{
		}

		public BuildPiece(AssetBundle bundle, string prefabName)
		{
			Prefab = PiecePrefabManager.RegisterPrefab(bundle, prefabName);
			registeredPieces.Add(this);
		}

		internal static void Patch_FejdStartup(FejdStartup __instance)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Expected O, but got Unknown
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Expected O, but got Unknown
			//IL_057d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0599: Expected O, but got Unknown
			//IL_0843: Unknown result type (might be due to invalid IL or missing references)
			//IL_085f: Expected O, but got Unknown
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_060a: Expected O, but got Unknown
			//IL_0690: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Expected O, but got Unknown
			//IL_08b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d0: Expected O, but got Unknown
			//IL_0abd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad9: Expected O, but got Unknown
			//IL_0b57: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b73: Expected O, but got Unknown
			Type configManagerType = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			configManager = ((configManagerType == null) ? null : Chainloader.ManagerObject.GetComponent(configManagerType));
			foreach (BuildPiece registeredPiece in registeredPieces)
			{
				registeredPiece.activeTools = registeredPiece.Tool.Tools.DefaultIfEmpty("Hammer").ToArray();
				if (registeredPiece.Category.Category != BuildPieceCategory.Custom)
				{
					registeredPiece.Prefab.GetComponent<Piece>().m_category = (PieceCategory)registeredPiece.Category.Category;
				}
				else
				{
					registeredPiece.Prefab.GetComponent<Piece>().m_category = PiecePrefabManager.GetCategory(registeredPiece.Category.custom);
				}
			}
			if (!ConfigurationEnabled)
			{
				return;
			}
			bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
			plugin.Config.SaveOnConfigSet = false;
			foreach (BuildPiece registeredPiece2 in registeredPieces)
			{
				BuildPiece piece = registeredPiece2;
				if (piece.SpecialProperties.NoConfig)
				{
					continue;
				}
				PieceConfig pieceConfig = (pieceConfigs[piece] = new PieceConfig());
				PieceConfig cfg = pieceConfig;
				Piece piecePrefab = piece.Prefab.GetComponent<Piece>();
				string pieceName = piecePrefab.m_name;
				string englishName = new Regex("[=\\n\\t\\\\\"\\'\\[\\]]*").Replace(Localizer.GetTranslation("English", pieceName), "").Trim();
				string localizedName = Localization.instance.Localize(pieceName).Trim();
				int order = 0;
				ConfigSyncBase.SyncedConfig(englishName, "Build Table Category", piece.Category.Category, new ConfigDescription("Build Category where " + localizedName + " is available.", (AcceptableValueBase)null, new object[1]
				{
					new ConfigurationManagerAttributes
					{
						Order = (order -= 1),
						Category = localizedName
					}
				}), ref cfg.category);
				ConfigurationManagerAttributes customTableAttributes = new ConfigurationManagerAttributes
				{
					Order = (order -= 1),
					Browsable = (cfg.category.Value == BuildPieceCategory.Custom),
					Category = localizedName
				};
				ConfigSyncBase.SyncedConfig(englishName, "Custom Build Category", piece.Category.custom, new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }), ref cfg.customCategory);
				cfg.category.SettingChanged += BuildTableConfigChanged;
				cfg.customCategory.SettingChanged += BuildTableConfigChanged;
				if (cfg.category.Value == BuildPieceCategory.Custom)
				{
					piecePrefab.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
				}
				else
				{
					piecePrefab.m_category = (PieceCategory)cfg.category.Value;
				}
				ConfigSyncBase.SyncedConfig(englishName, "Tools", string.Join(", ", piece.activeTools), new ConfigDescription("Comma separated list of tools where " + localizedName + " is available.", (AcceptableValueBase)null, new object[1] { customTableAttributes }), ref cfg.tools);
				piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
					select s.Trim()).ToArray();
				cfg.tools.SettingChanged += delegate
				{
					Inventory[] source = (from c in Player.s_players.Select((Player p) => ((Humanoid)p).GetInventory()).Concat(from c in Object.FindObjectsByType<Container>((FindObjectsInactive)1, (FindObjectsSortMode)1)
							select c.GetInventory())
						where c != null
						select c).ToArray();
					Dictionary<string, List<PieceTable>> dictionary = (from kv in (from i in (from p in ObjectDB.instance.m_items
								select p.GetComponent<ItemDrop>() into c
								where Object.op_Implicit((Object)(object)c) && Object.op_Implicit((Object)(object)((Component)c).GetComponent<ZNetView>())
								select c).Concat(ItemDrop.s_instances)
							select new KeyValuePair<string, ItemData>(Utils.GetPrefabName(((Component)i).gameObject), i.m_itemData)).Concat(from i in source.SelectMany((Inventory i) => i.GetAllItems())
							select new KeyValuePair<string, ItemData>(((Object)i.m_dropPrefab).name, i))
						where Object.op_Implicit((Object)(object)kv.Value.m_shared.m_buildPieces)
						group kv by kv.Key).ToDictionary((IGrouping<string, KeyValuePair<string, ItemData>> g) => g.Key, (IGrouping<string, KeyValuePair<string, ItemData>> g) => g.Select((KeyValuePair<string, ItemData> kv) => kv.Value.m_shared.m_buildPieces).Distinct().ToList());
					string[] array4 = piece.activeTools;
					foreach (string key in array4)
					{
						if (dictionary.TryGetValue(key, out var value))
						{
							foreach (PieceTable item3 in value)
							{
								item3.m_pieces.Remove(piece.Prefab);
							}
						}
					}
					piece.activeTools = (from s in cfg.tools.Value.Split(new char[1] { ',' })
						select s.Trim()).ToArray();
					if (Object.op_Implicit((Object)(object)ObjectDB.instance))
					{
						array4 = piece.activeTools;
						foreach (string key2 in array4)
						{
							if (dictionary.TryGetValue(key2, out var value2))
							{
								foreach (PieceTable item4 in value2)
								{
									if (!item4.m_pieces.Contains(piece.Prefab))
									{
										item4.m_pieces.Add(piece.Prefab);
									}
								}
							}
						}
						if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
						{
							((Humanoid)Player.m_localPlayer).SetPlaceMode(Player.m_localPlayer.m_buildPieces);
						}
					}
				};
				StationExtension pieceExtensionComp;
				List<ConfigurationManagerAttributes> hideWhenNoneAttributes;
				if (piece.Extension.ExtensionStations.Count > 0)
				{
					pieceExtensionComp = piece.Prefab.GetOrAddComponent<StationExtension>();
					string text = englishName;
					CraftingTable table = piece.Extension.ExtensionStations.First().Table;
					string text2 = "Crafting station that " + localizedName + " extends.";
					object[] array = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes = new ConfigurationManagerAttributes();
					int num = order - 1;
					order = num;
					configurationManagerAttributes.Order = num;
					array[0] = configurationManagerAttributes;
					ConfigSyncBase.SyncedConfig(text, "Extends Station", table, new ConfigDescription(text2, (AcceptableValueBase)null, array), ref cfg.extensionTable);
					ConfigSyncBase.SyncedConfig(englishName, "Custom Extend Station", piece.Extension.ExtensionStations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }), ref cfg.customExtentionTable);
					string text3 = englishName;
					float maxStationDistance = piece.Extension.ExtensionStations.First().maxStationDistance;
					string text4 = "Distance from the station that " + localizedName + " can be placed.";
					object[] array2 = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes2 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes2.Order = num;
					array2[0] = configurationManagerAttributes2;
					ConfigSyncBase.SyncedConfig(text3, "Max Station Distance", maxStationDistance, new ConfigDescription(text4, (AcceptableValueBase)null, array2), ref cfg.maxStationDistance);
					hideWhenNoneAttributes = new List<ConfigurationManagerAttributes>();
					cfg.extensionTable.SettingChanged += ExtensionTableConfigChanged;
					cfg.customExtentionTable.SettingChanged += ExtensionTableConfigChanged;
					cfg.maxStationDistance.SettingChanged += ExtensionTableConfigChanged;
					ConfigurationManagerAttributes configurationManagerAttributes3 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes3.Order = num;
					configurationManagerAttributes3.Browsable = cfg.extensionTable.Value != CraftingTable.None;
					ConfigurationManagerAttributes item = configurationManagerAttributes3;
					hideWhenNoneAttributes.Add(item);
				}
				List<ConfigurationManagerAttributes> hideWhenNoneAttributes2;
				if (piece.Crafting.Stations.Count > 0)
				{
					hideWhenNoneAttributes2 = new List<ConfigurationManagerAttributes>();
					string text5 = englishName;
					CraftingTable table2 = piece.Crafting.Stations.First().Table;
					string text6 = "Crafting station where " + localizedName + " is available.";
					object[] array3 = new object[1];
					ConfigurationManagerAttributes configurationManagerAttributes4 = new ConfigurationManagerAttributes();
					int num = order - 1;
					order = num;
					configurationManagerAttributes4.Order = num;
					array3[0] = configurationManagerAttributes4;
					ConfigSyncBase.SyncedConfig(text5, "Crafting Station", table2, new ConfigDescription(text6, (AcceptableValueBase)null, array3), ref cfg.table);
					ConfigSyncBase.SyncedConfig(englishName, "Custom Crafting Station", piece.Crafting.Stations.First().custom ?? "", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { customTableAttributes }), ref cfg.customTable);
					cfg.table.SettingChanged += TableConfigChanged;
					cfg.customTable.SettingChanged += TableConfigChanged;
					ConfigurationManagerAttributes configurationManagerAttributes5 = new ConfigurationManagerAttributes();
					num = order - 1;
					order = num;
					configurationManagerAttributes5.Order = num;
					configurationManagerAttributes5.Browsable = cfg.table.Value != CraftingTable.None;
					ConfigurationManagerAttributes item2 = configurationManagerAttributes5;
					hideWhenNoneAttributes2.Add(item2);
				}
				cfg.craft = itemConfig("Crafting Costs", new SerializedRequirements(piece.RequiredItems.Requirements).ToString(), "Item costs to craft " + localizedName);
				cfg.craft.SettingChanged += delegate
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance) && (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") != (Object)null)
					{
						Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
						piecePrefab.m_resources = resources;
						Piece[] array4 = Object.FindObjectsByType<Piece>((FindObjectsInactive)1, (FindObjectsSortMode)1);
						foreach (Piece val in array4)
						{
							if (val.m_name == pieceName)
							{
								val.m_resources = resources;
							}
						}
					}
				};
				for (int num2 = 0; num2 < piece.Conversions.Count; num2++)
				{
					string text7 = ((piece.Conversions.Count > 1) ? $"{num2 + 1}. " : "");
					Conversion conversion = piece.Conversions[num2];
					conversion.config = new Conversion.ConversionConfig();
					int index = num2;
					ConfigSyncBase.SyncedConfig(englishName, text7 + "Conversion Input Item", conversion.Input, new ConfigDescription("Conversion input item within " + englishName, (AcceptableValueBase)null, new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = localizedName
						}
					}), ref conversion.config.input);
					conversion.config.input.SettingChanged += delegate
					{
						if (index < piece.conversions.Count)
						{
							ObjectDB instance = ObjectDB.instance;
							if (instance != null)
							{
								ItemDrop val = SerializedRequirements.fetchByName(instance, conversion.config.input.Value);
								piece.conversions[index].m_from = val;
							}
						}
					};
					ConfigSyncBase.SyncedConfig(englishName, text7 + "Conversion Output Item", conversion.Output, new ConfigDescription("Conversion output item within " + englishName, (AcceptableValueBase)null, new object[1]
					{
						new ConfigurationManagerAttributes
						{
							Category = localizedName
						}
					}), ref conversion.config.output);
					conversion.config.output.SettingChanged += delegate
					{
						if (index < piece.conversions.Count)
						{
							ObjectDB instance = ObjectDB.instance;
							if (instance != null)
							{
								ItemDrop to = SerializedRequirements.fetchByName(instance, conversion.config.output.Value);
								piece.conversions[index].m_to = to;
							}
						}
					};
				}
				void BuildTableConfigChanged(object o, EventArgs e)
				{
					//IL_0059: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					if (registeredPieces.Count > 0)
					{
						if (cfg.category.Value == BuildPieceCategory.Custom)
						{
							piecePrefab.m_category = PiecePrefabManager.GetCategory(cfg.customCategory.Value);
						}
						else
						{
							piecePrefab.m_category = (PieceCategory)cfg.category.Value;
						}
						if (Object.op_Implicit((Object)(object)Hud.instance))
						{
							PiecePrefabManager.CreateCategoryTabs();
						}
					}
					customTableAttributes.Browsable = cfg.category.Value == BuildPieceCategory.Custom;
					ReloadConfigDisplay();
				}
				void ExtensionTableConfigChanged(object o, EventArgs e)
				{
					if (piece.RequiredItems.Requirements.Count > 0)
					{
						if (cfg.extensionTable.Value == CraftingTable.Custom)
						{
							StationExtension obj = pieceExtensionComp;
							GameObject prefab = ZNetScene.instance.GetPrefab(cfg.customExtentionTable.Value);
							obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
						}
						else
						{
							pieceExtensionComp.m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(cfg.extensionTable.Value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						pieceExtensionComp.m_maxStationDistance = cfg.maxStationDistance.Value;
					}
					customTableAttributes.Browsable = cfg.extensionTable.Value == CraftingTable.Custom;
					foreach (ConfigurationManagerAttributes item5 in hideWhenNoneAttributes)
					{
						item5.Browsable = cfg.extensionTable.Value != CraftingTable.None;
					}
					ReloadConfigDisplay();
					plugin.Config.Save();
				}
				void TableConfigChanged(object o, EventArgs e)
				{
					if (piece.RequiredItems.Requirements.Count > 0)
					{
						switch (cfg.table.Value)
						{
						case CraftingTable.None:
							piecePrefab.m_craftingStation = null;
							break;
						case CraftingTable.Custom:
						{
							Piece obj = piecePrefab;
							GameObject prefab = ZNetScene.instance.GetPrefab(cfg.customTable.Value);
							obj.m_craftingStation = ((prefab != null) ? prefab.GetComponent<CraftingStation>() : null);
							break;
						}
						default:
							piecePrefab.m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(cfg.table.Value.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
							break;
						}
					}
					customTableAttributes.Browsable = cfg.table.Value == CraftingTable.Custom;
					foreach (ConfigurationManagerAttributes item6 in hideWhenNoneAttributes2)
					{
						item6.Browsable = cfg.table.Value != CraftingTable.None;
					}
					ReloadConfigDisplay();
					plugin.Config.Save();
				}
				ConfigEntry<string> itemConfig(string name, string value, string desc)
				{
					//IL_0065: Unknown result type (might be due to invalid IL or missing references)
					//IL_0072: Expected O, but got Unknown
					ConfigurationManagerAttributes configurationManagerAttributes6 = new ConfigurationManagerAttributes
					{
						CustomDrawer = DrawConfigTable,
						Order = (order -= 1),
						Category = localizedName
					};
					ConfigEntry<string> configEntry = null;
					ConfigSyncBase.SyncedConfig(englishName, name, value, new ConfigDescription(desc, (AcceptableValueBase)null, new object[1] { configurationManagerAttributes6 }), ref configEntry);
					return configEntry;
				}
			}
			foreach (BuildPiece registeredPiece3 in registeredPieces)
			{
				ConfigEntryBase enabledCfg = registeredPiece3.RecipeIsActive;
				Piece piecePrefab2;
				if (enabledCfg != null)
				{
					piecePrefab2 = registeredPiece3.Prefab.GetComponent<Piece>();
					ConfigChanged(null, null);
					((object)enabledCfg).GetType().GetEvent("SettingChanged").AddEventHandler(enabledCfg, new EventHandler(ConfigChanged));
				}
				registeredPiece3.InitializeNewRegisteredPiece(registeredPiece3);
				void ConfigChanged(object? o, EventArgs? e)
				{
					piecePrefab2.m_enabled = (int)enabledCfg.BoxedValue != 0;
				}
			}
			if (saveOnConfigSet)
			{
				plugin.Config.SaveOnConfigSet = true;
				plugin.Config.Save();
			}
			void ReloadConfigDisplay()
			{
				object obj = configManagerType?.GetProperty("DisplayingWindow").GetValue(configManager);
				if (obj is bool && (bool)obj)
				{
					configManagerType.GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
				}
			}
		}

		private void InitializeNewRegisteredPiece(BuildPiece piece)
		{
			ConfigEntryBase recipeIsActive = piece.RecipeIsActive;
			PieceConfig cfg;
			Piece piecePrefab;
			string pieceName;
			if (recipeIsActive != null)
			{
				pieceConfigs.TryGetValue(piece, out cfg);
				piecePrefab = piece.Prefab.GetComponent<Piece>();
				pieceName = piecePrefab.m_name;
				((object)recipeIsActive).GetType().GetEvent("SettingChanged").AddEventHandler(recipeIsActive, new EventHandler(ConfigChanged));
			}
			void ConfigChanged(object o, EventArgs e)
			{
				if (Object.op_Implicit((Object)(object)ObjectDB.instance) && (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") != (Object)null && cfg != null)
				{
					Requirement[] resources = SerializedRequirements.toPieceReqs(new SerializedRequirements(cfg.craft.Value));
					piecePrefab.m_resources = resources;
					Piece[] array = Object.FindObjectsByType<Piece>((FindObjectsInactive)1, (FindObjectsSortMode)1);
					foreach (Piece val in array)
					{
						if (val.m_name == pieceName)
						{
							val.m_resources = resources;
						}
					}
				}
			}
		}

		[HarmonyPriority(700)]
		internal static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Expected O, but got Unknown
			if ((Object)(object)__instance.GetItemPrefab("YmirRemains") == (Object)null)
			{
				return;
			}
			foreach (BuildPiece registeredPiece in registeredPieces)
			{
				pieceConfigs.TryGetValue(registeredPiece, out PieceConfig value);
				registeredPiece.Prefab.GetComponent<Piece>().m_resources = SerializedRequirements.toPieceReqs((value == null) ? new SerializedRequirements(registeredPiece.RequiredItems.Requirements) : new SerializedRequirements(value.craft.Value));
				foreach (ExtensionConfig extensionStation in registeredPiece.Extension.ExtensionStations)
				{
					switch ((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.Table : value.extensionTable.Value)
					{
					case CraftingTable.None:
						registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = null;
						break;
					case CraftingTable.Custom:
					{
						GameObject prefab = ZNetScene.instance.GetPrefab((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.custom : value.customExtentionTable.Value);
						if (prefab != null)
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = prefab.GetComponent<CraftingStation>();
						}
						else
						{
							LogManager.Log.Warning("Custom crafting station '" + ((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.custom : value.customExtentionTable.Value) + "' does not exist");
						}
						break;
					}
					default:
						if (value != null && value.table.Value == CraftingTable.None)
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = null;
						}
						else
						{
							registeredPiece.Prefab.GetComponent<StationExtension>().m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(((value == null || registeredPiece.Extension.ExtensionStations.Count > 0) ? extensionStation.Table : value.extensionTable.Value).ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						break;
					}
				}
				foreach (CraftingStationConfig station in registeredPiece.Crafting.Stations)
				{
					switch ((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.Table : value.table.Value)
					{
					case CraftingTable.None:
						registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = null;
						break;
					case CraftingTable.Custom:
					{
						GameObject prefab2 = ZNetScene.instance.GetPrefab((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.custom : value.customTable.Value);
						if (prefab2 != null)
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = prefab2.GetComponent<CraftingStation>();
						}
						else
						{
							LogManager.Log.Warning("Custom crafting station '" + ((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.custom : value.customTable.Value) + "' does not exist");
						}
						break;
					}
					default:
						if (value != null && value.table.Value == CraftingTable.None)
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = null;
						}
						else
						{
							registeredPiece.Prefab.GetComponent<Piece>().m_craftingStation = ZNetScene.instance.GetPrefab(((InternalName)typeof(CraftingTable).GetMember(((value == null || registeredPiece.Crafting.Stations.Count > 0) ? station.Table : value.table.Value).ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).GetComponent<CraftingStation>();
						}
						break;
					}
				}
				registeredPiece.conversions = new List<ItemConversion>();
				for (int i = 0; i < registeredPiece.Conversions.Count; i++)
				{
					Conversion conversion = registeredPiece.Conversions[i];
					registeredPiece.conversions.Add(new ItemConversion
					{
						m_from = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.input.Value ?? conversion.Input),
						m_to = SerializedRequirements.fetchByName(ObjectDB.instance, conversion.config?.output.Value ?? conversion.Output)
					});
					if (registeredPiece.conversions[i].m_from != null && registeredPiece.conversions[i].m_to != null)
					{
						registeredPiece.Prefab.GetComponent<Smelter>().m_conversion.Add(registeredPiece.conversions[i]);
					}
				}
			}
		}

		public void Snapshot(float lightIntensity = 1.3f, Quaternion? cameraRotation = null)
		{
			SnapshotPiece(Prefab, lightIntensity, cameraRotation);
		}

		internal void SnapshotPiece(GameObject prefab, float lightIntensity = 1.3f, Quaternion? cameraRotation = null)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Expected O, but got Unknown
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab == (Object)null) && (prefab.GetComponentsInChildren<Renderer>().Any() || prefab.GetComponentsInChildren<MeshFilter>().Any()))
			{
				Camera component = new GameObject("CameraIcon", new Type[1] { typeof(Camera) }).GetComponent<Camera>();
				component.backgroundColor = Color.clear;
				component.clearFlags = (CameraClearFlags)2;
				((Component)component).transform.position = new Vector3(10000f, 10000f, 10000f);
				((Component)component).transform.rotation = (Quaternion)(((??)cameraRotation) ?? Quaternion.Euler(0f, 180f, 0f));
				component.fieldOfView = 0.5f;
				component.farClipPlane = 100000f;
				component.cullingMask = 8;
				Light component2 = new GameObject("LightIcon", new Type[1] { typeof(Light) }).GetComponent<Light>();
				((Component)component2).transform.position = new Vector3(10000f, 10000f, 10000f);
				((Component)component2).transform.rotation = Quaternion.Euler(5f, 180f, 5f);
				component2.type = (LightType)1;
				component2.cullingMask = 8;
				component2.intensity = lightIntensity;
				GameObject val = Object.Instantiate<GameObject>(prefab);
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.layer = 3;
				}
				val.transform.position = Vector3.zero;
				val.transform.rotation = Quaternion.Euler(23f, 51f, 25.8f);
				((Object)val).name = ((Object)prefab).name;
				MeshRenderer[] componentsInChildren2 = val.GetComponentsInChildren<MeshRenderer>();
				Vector3 val2 = componentsInChildren2.Aggregate(Vector3.positiveInfinity, delegate(Vector3 cur, MeshRenderer renderer)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					Bounds bounds = ((Renderer)renderer).bounds;
					return Vector3.Min(cur, ((Bounds)(ref bounds)).min);
				});
				Vector3 val3 = componentsInChildren2.Aggregate(Vector3.negativeInfinity, delegate(Vector3 cur, MeshRenderer renderer)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					Bounds bounds = ((Renderer)renderer).bounds;
					return Vector3.Max(cur, ((Bounds)(ref bounds)).max);
				});
				val.transform.position = new Vector3(10000f, 10000f, 10000f) - (val2 + val3) / 2f;
				Vector3 val4 = val3 - val2;
				val.AddComponent<TimedDestruction>().Trigger(1f);
				Rect val5 = default(Rect);
				((Rect)(ref val5))..ctor(0f, 0f, 128f, 128f);
				component.targetTexture = RenderTexture.GetTemporary((int)((Rect)(ref val5)).width, (int)((Rect)(ref val5)).height);
				component.fieldOfView = 20f;
				float num = (Mathf.Max(val4.x, val4.y) + 0.1f) / Mathf.Tan(component.fieldOfView * ((float)Math.PI / 180f)) * 1.1f;
				((Component)component).transform.position = new Vector3(10000f, 10000f, 10000f) + new Vector3(0f, 0f, num);
				component.Render();
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = component.targetTexture;
				Texture2D val6 = new Texture2D((int)((Rect)(ref val5)).width, (int)((Rect)(ref val5)).height, (TextureFormat)4, false);
				val6.ReadPixels(new Rect(0f, 0f, (float)(int)((Rect)(ref val5)).width, (float)(int)((Rect)(ref val5)).height), 0, 0);
				val6.Apply();
				RenderTexture.active = active;
				prefab.GetComponent<Piece>().m_icon = Sprite.Create(val6, new Rect(0f, 0f, (float)(int)((Rect)(ref val5)).width, (float)(int)((Rect)(ref val5)).height), Vector2.one / 2f);
				((Component)component2).gameObject.SetActive(false);
				component.targetTexture.Release();
				((Component)component).gameObject.SetActive(false);
				val.SetActive(false);
				Object.DestroyImmediate((Object)(object)val);
				Object.Destroy((Object)(object)((Component)component).gameObject);
				Object.Destroy((Object)(object)((Component)component2).gameObject);
			}
		}

		private static void DrawConfigTable(ConfigEntryBase cfg)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select((object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? ((bool?)null) : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue) == true;
			List<Requirement> list = new List<Requirement>();
			bool flag = false;
			int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
				.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (Requirement req in new SerializedRequirements((string)cfg.BoxedValue).Reqs)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num2 = req.amount;
				if (int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 40f
				}, Array.Empty<GUILayoutOption>()), out var result) && result != num2 && !valueOrDefault)
				{
					num2 = result;
					flag = true;
				}
				string text = GUILayout.TextField(req.itemName, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 40 - 67 - 21 - 21 - 12
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? req.itemName : text);
				flag = flag || text2 != req.itemName;
				bool flag2 = req.recover;
				if (GUILayout.Toggle(req.recover, "Recover", new GUIStyle(GUI.skin.toggle)
				{
					fixedWidth = 67f
				}, Array.Empty<GUILayoutOption>()) != req.recover)
				{
					flag2 = !flag2;
					flag = true;
				}
				if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
				}
				else
				{
					list.Add(new Requirement
					{
						amount = num2,
						itemName = text2,
						recover = flag2
					});
				}
				if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
					list.Add(new Requirement
					{
						amount = 1,
						itemName = "",
						recover = false
					});
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new SerializedRequirements(list).ToString();
			}
		}
	}
	internal static class GoExtensions
	{
		public static T GetOrAddComponent<T>(this GameObject gameObject) where T : Component
		{
			return gameObject.GetComponent<T>() ?? gameObject.AddComponent<T>();
		}
	}
	internal class AdminSyncing
	{
		private static bool isServer;

		internal static bool registeredOnClient;

		[HarmonyPriority(700)]
		internal static void AdminStatusSync(ZNet __instance)
		{
			isServer = __instance.IsServer();
			if (BuildPiece._plugin != null)
			{
				if (isServer)
				{
					ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", (Action<long, ZPackage>)RPC_AdminPieceAddRemove);
				}
				else if (!registeredOnClient)
				{
					ZRoutedRpc.instance.Register<ZPackage>(BuildPiece._plugin.Info.Metadata.Name + " PMAdminStatusSync", (Action<long, ZPackage>)RPC_AdminPieceAddRemove);
					registeredOnClient = true;
				}
			}
			if (isServer)
			{
				((MonoBehaviour)ZNet.instance).StartCoroutine(WatchAdminListChanges());
			}
			static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				ZPackage val = new ZPackage();
				val.Write(isAdmin);
				((MonoBehaviour)ZNet.instance).StartCoroutine(sendZPackage(peers, val));
			}
			static IEnumerator WatchAdminListChanges()
			{
				List<string> currentList = new List<string>(ZNet.instance.m_adminList.GetList());
				while (true)
				{
					yield return (object)new WaitForSeconds(30f);
					if (!ZNet.instance.m_adminList.GetList().SequenceEqual(currentList))
					{
						currentList = new List<string>(ZNet.instance.m_adminList.GetList());
						List<ZNetPeer> list = (from p in ZNet.instance.GetPeers()
							where ZNet.instance.ListContainsId(ZNet.instance.m_adminList, p.m_rpc.GetSocket().GetHostName())
							select p).ToList();
						SendAdmin(ZNet.instance.GetPeers().Except(list).ToList(), isAdmin: false);
						SendAdmin(list, isAdmin: true);
					}
				}
			}
		}

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

		private static IEnumerator<bool> TellPeerAdminStatus(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc != null)
			{
				SendPackage(package);
			}
			void SendPackage(ZPackage pkg)
			{
				BaseUnityPlugin? plugin = BuildPiece._plugin;
				string text = ((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			yield break;
		}

		internal static void RPC_AdminPieceAddRemove(long sender, ZPackage package)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			ZNetPeer peer = ZNet.instance.GetPeer(sender);
			bool flag = false;
			try
			{
				flag = package.ReadBool();
			}
			catch
			{
			}
			if (isServer)
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				long everybody = ZRoutedRpc.Everybody;
				BaseUnityPlugin? plugin = BuildPiece._plugin;
				instance.InvokeRoutedRPC(everybody, ((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { (object)new ZPackage() });
				if (ZNet.instance.ListContainsId(ZNet.instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()))
				{
					ZPackage val = new ZPackage();
					val.Write(true);
					ZRpc rpc = peer.m_rpc;
					BaseUnityPlugin? plugin2 = BuildPiece._plugin;
					rpc.Invoke(((plugin2 != null) ? plugin2.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { val });
				}
				return;
			}
			foreach (BuildPiece registeredPiece in BuildPiece.registeredPieces)
			{
				if (!registeredPiece.SpecialProperties.AdminOnly)
				{
					continue;
				}
				Piece component = registeredPiece.Prefab.GetComponent<Piece>();
				string name = component.m_name;
				Localization.instance.Localize(name).Trim();
				if (!Object.op_Implicit((Object)(object)ObjectDB.instance) || (Object)(object)ObjectDB.instance.GetItemPrefab("YmirRemains") == (Object)null)
				{
					continue;
				}
				Piece[] array = Object.FindObjectsByType<Piece>((FindObjectsInactive)1, (FindObjectsSortMode)1);
				foreach (Piece val2 in array)
				{
					if (flag)
					{
						if (val2.m_name == name)
						{
							val2.m_enabled = true;
						}
					}
					else if (val2.m_name == name)
					{
						val2.m_enabled = false;
					}
				}
				List<GameObject> pieces = ObjectDB.instance.GetItemPrefab("Hammer").GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces.m_pieces;
				if (flag)
				{
					if (!pieces.Contains(ZNetScene.instance.GetPrefab(((Object)component).name)))
					{
						pieces.Add(ZNetScene.instance.GetPrefab(((Object)component).name));
					}
				}
				else if (pieces.Contains(ZNetScene.instance.GetPrefab(((Object)component).name)))
				{
					pieces.Remove(ZNetScene.instance.GetPrefab(((Object)component).name));
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
	internal class RegisterClientRPCPatch
	{
		private static void Postfix(ZNet __instance, ZNetPeer peer)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if (!__instance.IsServer())
			{
				ZRpc rpc = peer.m_rpc;
				BaseUnityPlugin? plugin = BuildPiece._plugin;
				rpc.Register<ZPackage>(((plugin != null) ? plugin.Info.Metadata.Name : null) + " PMAdminStatusSync", (Action<ZRpc, ZPackage>)RPC_InitialAdminSync);
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(__instance.ListContainsId(__instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()));
			ZRpc rpc2 = peer.m_rpc;
			BaseUnityPlugin? plugin2 = BuildPiece._plugin;
			rpc2.Invoke(((plugin2 != null) ? plugin2.Info.Metadata.Name : null) + " PMAdminStatusSync", new object[1] { val });
		}

		private static void RPC_InitialAdminSync(ZRpc rpc, ZPackage package)
		{
			AdminSyncing.RPC_AdminPieceAddRemove(0L, package);
		}
	}
	internal static class PiecePrefabManager
	{
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static bool _initialized;

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		private static readonly List<GameObject> piecePrefabs;

		private static readonly Dictionary<string, PieceCategory> PieceCategories;

		private static readonly Dictionary<string, PieceCategory> OtherPieceCategories;

		private const string _hiddenCategoryMagic = "(HiddenCategory)";

		static PiecePrefabManager()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Expected O, but got Unknown
			//IL_026d: Expected O, but got Unknown
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Expected O, but got Unknown
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Expected O, but got Unknown
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Expected O, but got Unknown
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Expected O, but got Unknown
			_initialized = false;
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			piecePrefabs = new List<GameObject>();
			PieceCategories = new Dictionary<string, PieceCategory>();
			OtherPieceCategories = new Dictionary<string, PieceCategory>();
			Harmony val = new Harmony("org.bepinex.helpers.PieceManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(BuildPiece), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "CopyOtherDB", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ObjectDBInit", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AdminSyncing), "AdminStatusSync", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RefFixPatch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Transpiler", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PieceTable), "UpdateAvailable", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Prefix", (Type[])null, (Type[])null)), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "UpdateAvailable_Postfix", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "SetPlaceMode", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Patch_SetPlaceMode", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "Hud_AwakeCreateTabs", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Hud), "UpdateBuild", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "RepositionCats", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Enum), "GetValues", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetValuesPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Enum), "GetNames", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "EnumGetNamesPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
			}
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId key = new BundleId
			{
				assetBundleFileName = assetBundleFileName,
				folderName = folderName
			};
			if (!bundleCache.TryGetValue(key, out AssetBundle value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static IEnumerable<GameObject> FixRefs(AssetBundle assetBundle)
		{
			return assetBundle.LoadAllAssets<GameObject>();
		}

		public static GameObject RegisterPrefab(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterPrefab(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName)
		{
			if ((Object)(object)assets == (Object)null)
			{
				LogManager.Log.Error("Failed to load asset bundle. Please make sure to mark all asset bundles as embedded resources.");
				return null;
			}
			GameObject val = assets.LoadAsset<GameObject>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				LogManager.Log.Error("Failed to load prefab " + prefabName + " from asset bundle " + ((Object)assets).name);
				return null;
			}
			piecePrefabs.Add(val);
			return val;
		}

		public static Sprite RegisterSprite(string assetBundleFileName, string prefabName, string folderName = "assets")
		{
			return RegisterSprite(RegisterAssetBundle(assetBundleFileName, folderName), prefabName);
		}

		public static Sprite RegisterSprite(AssetBundle assets, string prefabName)
		{
			return assets.LoadAsset<Sprite>(prefabName);
		}

		private static void EnumGetValuesPatch(Type enumType, ref Array __result)
		{
			if (!(enumType != typeof(PieceCategory)) && PieceCategories.Count != 0)
			{
				PieceCategory[] array = (PieceCategory[])(object)new PieceCategory[__result.Length + PieceCategories.Count];
				__result.CopyTo(array, 0);
				PieceCategories.Values.CopyTo(array, __result.Length);
				__result = array;
			}
		}

		private static void EnumGetNamesPatch(Type enumType, ref string[] __result)
		{
			if (!(enumType != typeof(PieceCategory)) && PieceCategories.Count != 0)
			{
				__result = CollectionExtensions.AddRangeToArray<string>(__result, PieceCategories.Keys.ToArray());
			}
		}

		public static Dictionary<PieceCategory, string> GetPieceCategoriesMap()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Array values = Enum.GetValues(typeof(PieceCategory));
			string[] names = Enum.GetNames(typeof(PieceCategory));
			Dictionary<PieceCategory, string> dictionary = new Dictionary<PieceCategory, string>();
			for (int i = 0; i < values.Length; i++)
			{
				dictionary[(PieceCategory)values.GetValue(i)] = names[i];
			}
			return dictionary;
		}

		public static PieceCategory GetCategory(string name)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<PieceCategory>(name, ignoreCase: true, out PieceCategory result))
			{
				return result;
			}
			if (PieceCategories.TryGetValue(name, out result))
			{
				return result;
			}
			if (OtherPieceCategories.TryGetValue(name, out result))
			{
				return result;
			}
			Dictionary<PieceCategory, string> pieceCategoriesMap = GetPieceCategoriesMap();
			foreach (KeyValuePair<PieceCategory, string> item in pieceCategoriesMap)
			{
				if (item.Value == name)
				{
					result = item.Key;
					OtherPieceCategories[name] = result;
					return result;
				}
			}
			result = (PieceCategory)(pieceCategoriesMap.Count - 1);
			PieceCategories[name] = result;
			string categoryToken = GetCategoryToken(name);
			Localization.instance.AddWord(categoryToken, name);
			return result;
		}

		internal static void CreateCategoryTabs()
		{
			int num = ModifiedMaxCategory();
			for (int i = Hud.instance.m_pieceCategoryTabs.Length; i < num; i++)
			{
				GameObject val = CreateCategoryTab();
				Hud.instance.m_pieceCategoryTabs = CollectionExtensions.AddItem<GameObject>((IEnumerable<GameObject>)Hud.instance.m_pieceCategoryTabs, val).ToArray();
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
			{
				RepositionCategories(Player.m_localPlayer.m_buildPieces);
				Player.m_localPlayer.UpdateAvailablePiecesList();
			}
		}

		private static GameObject CreateCategoryTab()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Hud.instance.m_pieceCategoryTabs[0];
			GameObject val2 = Object.Instantiate<GameObject>(Hud.instance.m_pieceCategoryTabs[0], val.transform.parent);
			val2.SetActive(false);
			UIInputHandler orAddComponent = val2.GetOrAddComponent<UIInputHandler>();
			orAddComponent.m_onLeftDown = (Action<UIInputHandler>)Delegate.Combine(orAddComponent.m_onLeftDown, new Action<UIInputHandler>(Hud.instance.OnLeftClickCategory));
			TMP_Text[] componentsInChildren = val2.GetComponentsInChildren<TMP_Text>();
			foreach (TMP_Text obj in componentsInChildren)
			{
				obj.rectTransform.offsetMin = new Vector2(3f, 1f);
				obj.rectTransform.offsetMax = new Vector2(-3f, -1f);
				obj.enableAutoSizing = true;
				obj.fontSizeMin = 12f;
				obj.fontSizeMax = 20f;
				obj.lineSpacing = 0.8f;
				obj.textWrappingMode = (TextWrappingModes)1;
				obj.overflowMode = (TextOverflowModes)3;
			}
			return val2;
		}

		private static int ModifiedMaxCategory()
		{
			return Enum.GetValues(typeof(PieceCategory)).Length - 1;
		}

		private static int GetMaxCategoryOrDefault()
		{
			try
			{
				return (int)Enum.Parse(typeof(PieceCategory), "Max");
			}
			catch (ArgumentException)
			{
				Debug.LogWarning((object)"Could not find Piece.PieceCategory.Max, using fallback value 4");
				return 4;
			}
		}

		private static List<CodeInstruction> TranspileMaxCategory(IEnumerable<CodeInstruction> instructions, int maxOffset)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			int num = GetMaxCategoryOrDefault() + maxOffset;
			List<CodeInstruction> list = new List<CodeInstruction>();
			foreach (CodeInstruction instruction in instructions)
			{
				if (CodeInstructionExtensions.LoadsConstant(instruction, (long)num))
				{
					list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(PiecePrefabManager), "ModifiedMaxCategory", (Type[])null, (Type[])null)));
					if (maxOffset != 0)
					{
						list.Add(new CodeInstruction(OpCodes.Ldc_I4, (object)maxOffset));
						list.Add(new CodeInstruction(OpCodes.Add, (object)null));
					}
				}
				else
				{
					list.Add(instruction);
				}
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> UpdateAvailable_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return TranspileMaxCategory(instructions, 0);
		}

		private static HashSet<PieceCategory> CategoriesInPieceTable(PieceTable pieceTable)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			HashSet<PieceCategory> hashSet = new HashSet<PieceCategory>();
			Piece val = default(Piece);
			foreach (GameObject item in pieceTable.m_pieces.Where((GameObject pieceFab) => (Object)(object)pieceFab != (Object)null))
			{
				if (item.TryGetComponent<Piece>(ref val))
				{
					hashSet.Add(val.m_category);
				}
			}
			return hashSet;
		}

		private static void InitializeDefaultCategories(PieceTable pieceTable)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)pieceTable == (Object)null)
			{
				return;
			}
			foreach (PieceCategory item in (from category in CategoriesInPieceTable(pieceTable)
				where (int)category != 100 && (int)category != 8
				select category).ToHashSet().ToList())
			{
				string categoryLabel = GetCategoryLabel(item);
				if (!string.IsNullOrWhiteSpace(categoryLabel) && !pieceTable.m_categories.Contains(item))
				{
					pieceTable.m_categories.Add(item);
					pieceTable.m_categoryLabels.Add(categoryLabel);
				}
			}
		}

		private static string GetCategoryLabel(PieceCategory category)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected I4, but got Unknown
			return (int)category switch
			{
				0 => "$hud_misc", 
				1 => "$hud_crafting", 
				2 => "$hud_building", 
				3 => "$hud_building2", 
				4 => "$hud_furniture", 
				5 => "$hud_feasts", 
				7 => "$hud_meads", 
				6 => "$hud_food", 
				_ => "", 
			};
		}

		private static void RepositionCats()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Player.m_localPlayer.m_buildPieces))
			{
				RepositionCategories(Player.m_localPlayer.m_buildPieces);
			}
		}

		private static void RepositionCategories(PieceTable pieceTable)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_002c: 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_0046: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: 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_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			InitializeDefaultCategories(pieceTable);
			RectTransform val = (RectTransform)Hud.instance.m_pieceCategoryTabs[0].transform;
			RectTransform val2 = (RectTransform)Hud.instance.m_pieceCategoryRoot.transform;
			RectTransform val3 = (RectTransform)Hud.instance.m_pieceSelectionWindow.transform;
			HorizontalLayoutGroup val4 = default(HorizontalLayoutGroup);
			if (((Component)((Transform)val).parent).TryGetComponent<HorizontalLayoutGroup>(ref val4))
			{
				Object.DestroyImmediate((Object)(object)val4);
			}
			Rect rect = val.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			GridLayoutGroup val5 = default(GridLayoutGroup);
			GridLayoutGroup obj = (((Component)((Transform)val).parent).TryGetComponent<GridLayoutGroup>(ref val5) ? val5 : ((Component)((Transform)val).parent).gameObject.AddComponent<GridLayoutGroup>());
			obj.cellSize = size;
			obj.spacing = new Vector2(0f, 1f);
			obj.constraint = (Constraint)1;
			obj.constraintCount = 5;
			((LayoutGroup)obj).childAlignment = (TextAnchor)4;
			HashSet<PieceCategory> hashSet = CategoriesInPieceTable(pieceTable);
			UpdatePieceTableCategories(pieceTable, hashSet);
			rect = val2.rect;
			int num = Mathf.Max((int)(((Rect)(ref rect)).width / size.x), 1);
			int count = pieceTable.m_categories.Count;
			float num2 = (0f - size.x) * (float)num / 2f + size.x / 2f;
			float num3 = (size.y + 1f) * Mathf.Floor((float)(count - 1) / (float)num) + 5f;
			new Vector2(num2, num3);
			int num4 = Mathf.CeilToInt((float)count / (float)num);
			float num5 = (size.y + 1f) * (float)num4;
			RectTransform component = ((Component)((Transform)val).parent).GetComponent<RectTransform>();
			component.anchoredPosition = new Vector2(component.anchoredPosition.x, num5 / 2f);
			int num6 = 0;
			for (int i = 0; i < Hud.instance.m_pieceCategoryTabs.Length; i++)
			{
				GameObject val6 = Hud.instance.m_pieceCategoryTabs[i];
				if ((Object)(object)val6 == (Object)null)
				{
					continue;
				}
				if (i >= pieceTable.m_categories.Count)
				{
					val6.SetActive(false);
					continue;
				}
				PieceCategory item = pieceTable.m_categories[i];
				string text = pieceTable.m_categoryLabels[i];
				if (hashSet.Contains(item))
				{
					num6++;
				}
				val6.GetComponentInChildren<TMP_Text>().text = Localization.instance.Localize(text);
			}
			Transform obj2 = ((Transform)val3).Find("Bkg2");
			RectTransform val7 = (RectTransform)((obj2 != null) ? ((Component)obj2).transform : null);
			if (Object.op_Implicit((Object)(object)val7))
			{
				float num7 = (size.y + 1f) * (float)Mathf.Max(0, Mathf.FloorToInt((float)(num6 - 1) / (float)num));
				val7.offsetMax = new Vector2(val7.offsetMax.x, num7);
			}
			else
			{
				Debug.LogWarning((object)"RefreshCategories: Could not find background image");
			}
			((Component)Hud.instance).GetComponentInParent<Localize>().RefreshLocalization();
		}

		private static void UpdatePieceTableCategories(PieceTable pieceTable, HashSet<PieceCategory> visibleCategories)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<string, PieceCategory> pieceCategory in PieceCategories)
			{
				string key = pieceCategory.Key;
				PieceCategory value = pieceCategory.Value;
				if (visibleCategories.Contains(value) && !pieceTable.m_categories.Contains(value))
				{
					pieceTable.m_categories.Add(value);
					pieceTable.m_categoryLabels.Add("$" + GetCategoryToken(key));
				}
				if (visibleCategories.Contains(value) && !pieceTable.m_categoryLabels.Contains("$" + GetCategoryToken(key)))
				{
					pieceTable.m_categoryLabels.Add("$" + GetCategoryToken(key));
				}
				if (!visibleCategories.Contains(value) && pieceTable.m_categories.Contains(value))
				{
					int index = pieceTable.m_categories.IndexOf(value);
					pieceTable.m_categories.RemoveAt(index);
					pieceTable.m_categoryLabels.RemoveAt(index);
				}
			}
		}

		private static string GetCategoryToken(string name)
		{
			char[] endChars = Localization.instance.m_endChars;
			string text = string.Concat(name.ToLower().Split(endChars));
			return "piecemanager_cat_" + text;
		}

		private static void Patch_SetPlaceMode(Player __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance.m_buildPieces))
			{
				RepositionCategories(__instance.m_buildPieces);
			}
		}

		private static void UpdateAvailable_Prefix(PieceTable __instance)
		{
			if (__instance.m_availablePieces.Count > 0)
			{
				int num = ModifiedMaxCategory() - __instance.m_availablePieces.Count;
				for (int i = 0; i < num; i++)
				{
					__instance.m_availablePieces.Add(new List<Piece>());
				}
			}
		}

		private static void UpdateAvailable_Postfix(PieceTable __instance)
		{
			Array.Resize(ref __instance.m_selectedPiece, __instance.m_availablePieces.Count);
			Array.Resize(ref __instance.m_lastSelectedPiece, __instance.m_availablePieces.Count);
		}

		[HarmonyPriority(200)]
		private static void Hud_AwakeCreateTabs()
		{
			CreateCategoryTabs();
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject piecePrefab in piecePrefabs)
			{
				if (!__instance.m_prefabs.Contains(piecePrefab))
				{
					__instance.m_prefabs.Add(piecePrefab);
				}
			}
		}

		[HarmonyPriority(700)]
		private static void RefFixPatch_ZNetSceneAwake(ZNetScene __instance)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			foreach (GameObject piecePrefab in piecePrefabs)
			{
				if (__instance.m_prefabs.Contains(piecePrefab) && Object.op_Implicit((Object)(object)piecePrefab.GetComponent<StationExtension>()))
				{
					piecePrefab.GetComponent<Piece>().m_isUpgrade = true;
					piecePrefab.GetComponent<StationExtension>().m_connectionPrefab = __instance.GetPrefab("piece_workbench_ext3").GetComponent<StationExtension>().m_connectionPrefab;
					piecePrefab.GetComponent<StationExtension>().m_connectionOffset = __instance.GetPrefab("piece_workbench_ext3").GetComponent<StationExtension>().m_connectionOffset;
				}
			}
		}

		[HarmonyPriority(300)]
		private static void Patch_ObjectDBInit(ObjectDB __instance)
		{
			foreach (BuildPiece registeredPiece in BuildPiece.registeredPieces)
			{
				string[] activeTools = registeredPiece.activeTools;
				foreach (string text in activeTools)
				{
					GameObject itemPrefab = __instance.GetItemPrefab(text);
					PieceTable val = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>().m_itemData.m_shared.m_buildPieces : null);
					if (val != null && !val.m_pieces.Contains(registeredPiece.Prefab))
					{
						val.m_pieces.Add(registeredPiece.Prefab);
					}
				}
			}
		}
	}
	[PublicAPI]
	internal class Conversion
	{
		internal class ConversionConfig
		{
			public ConfigEntry<string> input;

			public ConfigEntry<string> output;
		}

		public string Input;

		public string Output;

		internal ConversionConfig? config;

		public Conversion(BuildPiece conversionPiece)
		{
			conversionPiece.Conversions.Add(this);
		}
	}
	internal class SnapPoint
	{
		public GameObject GameObject { get; private set; }

		public bool IsInUse { get; set; }

		public SnapPoint(GameObject gameObject)
		{
			GameObject = gameObject;
		}
	}
	[PublicAPI]
	internal class SnapPointMaker
	{
		public enum SnapPointType
		{
			Vertices,
			Center,
			Poles,
			Equator
		}

		private static readonly List<GameObject> ObjectsToApplySnaps = new List<GameObject>();

		private static readonly List<SnapPoint> SnapPoints = new List<SnapPoint>();

		public static void AddObjectForSnapPoints(GameObject obj)
		{
			ObjectsToApplySnaps.Add(obj);
		}

		public static void ApplySnapPoints(SnapPointType snapPointType)
		{
			foreach (GameObject objectsToApplySnap in ObjectsToApplySnaps)
			{
				GrabVerticesAssignSnaps(objectsToApplySnap, snapPointType);
			}
		}

		private static void GrabVerticesAssignSnaps(GameObject obj, SnapPointType snapPointType)
		{
			Collider component = obj.GetComponent<Collider>();
			BoxCollider val = (BoxCollider)(object)((component is BoxCollider) ? component : null);
			if (val != null)
			{
				Vector3[] boxColliderSnapPoints = GetBoxColliderSnapPoints(obj, val, snapPointType);
				AttachSnapPoints(obj, boxColliderSnapPoints);
				return;
			}
			SphereCollider val2 = (SphereCollider)(object)((component is SphereCollider) ? component : null);
			if (val2 != null)
			{
				Vector3[] sphereColliderSnapPoints = GetSphereColliderSnapPoints(obj, val2, snapPointType);
				AttachSnapPoints(obj, sphereColliderSnapPoints);
			}
			else
			{
				Debug.LogWarning((object)("Unsupported collider type for " + ((Object)obj).name + ": " + ((object)component).GetType()));
			}
		}

		private static Vector3[] GetBoxColliderSnapPoints(GameObject obj, BoxCollider col, SnapPointType snapPointType)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0030: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Transform transform = obj.transform;
			Vector3 val = col.center - col.size * 0.5f;
			Vector3 val2 = col.center + col.size * 0.5f;
			if (snapPointType == SnapPointType.Vertices || snapPointType == SnapPointType.Center)
			{
				list.Add(transform.TransformPoint(new Vector3(val.x, val.y, val.z)));
				list.Add(transform.TransformPoint(new Vector3(val.x, val.y, val2.z)));
				list.Add(transform.TransformPoint(new Vector3(val.x, val2.y, val.z)));
				list.Add(transform.TransformPoint(new Vector3(val.x, val2.y, val2.z)));
				list.Add(transform.TransformPoint(new Vector3(val2.x, val.y, val.z)));
				list.Add(transform.TransformPoint(new Vector3(val2.x, val.y, val2.z)));
				list.Add(transform.TransformPoint(new Vector3(val2.x, val2.y, val.z)));
				list.Add(transform.TransformPoint(new Vector3(val2.x, val2.y, val2.z)));
			}
			if (snapPointType == SnapPointType.Center)
			{
				list.Add(transform.TransformPoint(col.center));
			}
			return list.ToArray();
		}

		private static Vector3[] GetSphereColliderSnapPoints(GameObject obj, SphereCollider col, SnapPointType snapPointType)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Transform transform = obj.transform;
			if (snapPointType == SnapPointType.Poles || snapPointType == SnapPointType.Center)
			{
				list.Add(transform.TransformPoint(new Vector3(0f, col.radius, 0f)));
				list.Add(transform.TransformPoint(new Vector3(0f, 0f - col.radius, 0f)));
			}
			if (snapPointType == SnapPointType.Equator)
			{
				list.Add(transform.TransformPoint(new Vector3(0f - col.radius, 0f, 0f)));
				list.Add(transform.TransformPoint(new Vector3(col.radius, 0f, 0f)));
				list.Add(transform.TransformPoint(new Vector3(0f, 0f, 0f - col.radius)));
				list.Add(transform.TransformPoint(new Vector3(0f, 0f, col.radius)));
			}
			if (snapPointType == SnapPointType.Center)
			{
				list.Add(transform.TransformPoint(col.center));
			}
			return list.ToArray();
		}

		private static Vector3[] GetColliderVertexPosRotated(GameObject obj)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[8];
			BoxCollider componentInChildren = obj.GetComponentInChildren<BoxCollider>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return array;
			}
			Transform transform = obj.transform;
			Vector3 val = componentInChildren.center - componentInChildren.size * 0.5f;
			Vector3 val2 = componentInChildren.center + componentInChildren.size * 0.5f;
			array[0] = transform.TransformPoint(new Vector3(val.x, val.y, val.z));
			array[1] = transform.TransformPoint(new Vector3(val.x, val.y, val2.z));
			array[2] = transform.TransformPoint(new Vector3(val.x, val2.y, val.z));
			array[3] = transform.TransformPoint(new Vector3(val.x, val2.y, val2.z));
			array[4] = transform.TransformPoint(new Vector3(val2.x, val.y, val.z));
			array[5] = transform.TransformPoint(new Vector3(val2.x, val.y, val2.z));
			array[6] = transform.TransformPoint(new Vector3(val2.x, val2.y, val.z));
			array[7] = transform.TransformPoint(new Vector3(val2.x, val2.y, val2.z));
			return array;
		}

		private static void AttachSnapPoints(GameObject objecttosnap, Vector3[] vector3S)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			foreach (Vector3 position in vector3S)
			{
				AddSnapPoint(objecttosnap, position).GameObject.SetActive(false);
			}
		}

		public static SnapPoint AddSnapPoint(GameObject parent, Vector3 position)
		{
			//IL_003f: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			foreach (SnapPoint snapPoint2 in SnapPoints)
			{
				if (!snapPoint2.IsInUse)
				{
					snapPoint2.GameObject.transform.SetParent(parent.transform, false);
					snapPoint2.GameObject.transform.position = position;
					snapPoint2.IsInUse = true;
					return snapPoint2;
				}
			}
			GameObject val = new GameObject("_snappoint")
			{
				tag = "snappoint",
				layer = 10
			};
			val.transform.SetParent(parent.transform, false);
			val.transform.position = position;
			SnapPoint snapPoint = new SnapPoint(val);
			snapPoint.IsInUse = true;
			SnapPoints.Add(snapPoint);
			return snapPoint;
		}

		public static void ReleaseSnapPoint(SnapPoint snapPoint)
		{
			snapPoint.GameObject.transform.parent = null;
			snapPoint.IsInUse = false;
		}
	}
}
namespace Vapok.Common.Managers.Location
{
	internal enum ShowIcon
	{
		Always,
		Never,
		Explored
	}
	internal enum Rotation
	{
		Fixed,
		Random,
		Slope
	}
	[PublicAPI]
	internal struct Range
	{
		public float min;

		public float max;

		public Range(float min, float max)
		{
			this.min = min;
			this.max = max;
		}
	}
	[PublicAPI]
	internal class Location
	{
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;
		}

		private static class PrefabManager
		{
			private struct BundleId
			{
				[UsedImplicitly]
				public string assetBundleFileName;

				[UsedImplicitly]
				public string folderName;
			}

			private static readonly Dictionary<BundleId, AssetBundle> bundleCache = new Dictionary<BundleId, AssetBundle>();

			public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
			{
				BundleId key = new BundleId
				{
					assetBundleFileName = assetBundleFileName,
					folderName = folderName
				};
				if (!bundleCache.TryGetValue(key, out AssetBundle value))
				{
					Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
					AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + ((folderName == "") ? "" : ".") + folderName + "." + assetBundleFileName));
					AssetBundle result = obj;
					dictionary[key] = obj;
					return result;
				}
				return value;
			}
		}

		private static bool _initialized;

		public bool CanSpawn = true;

		public Biome Biome = (Biome)1;

		[Description("If the location should spawn more towards the edge of the biome or towards the center.\nUse 'Edge' to make it spawn towards the edge.\nUse 'Median' to make it spawn towards the center.\nUse 'Everything' if it doesn't matter.")]
		public BiomeArea SpawnArea = (BiomeArea)3;

		[Description("Maximum number of locations to spawn in.\nDoes not mean that this many locations will spawn. But Valheim will try its best to spawn this many, if there is space.")]
		public int Count = 1;

		[Description("If set to true, this location will be prioritized over other locations, if they would spawn in the same area.")]
		public bool Prioritize;

		[Description("If set to true, Valheim will try to spawn your location as close to the center of the map as possible.")]
		public bool PreferCenter;

		[Description("If set to true, all other locations will be deleted, once the first one has been discovered by a player.")]
		public bool Unique;

		[Description("The name of the group of the location, used by the minimum distance from group setting.")]
		public string GroupName;

		[Description("Locations in the same group will keep at least this much distance between each other.")]
		public float MinimumDistanceFromGroup;

		[Description("When to show the map icon of the location. Requires an icon to be set.\nUse 'Never' to not show a map icon for the location.\nUse 'Always' to always show a map icon for the location.\nUse 'Explored' to start showing a map icon for the location as soon as a player has explored the area.")]
		public ShowIcon ShowMapIcon = ShowIcon.Never;

		private string? mapIconName;

		[Description("Sets the map icon for the location.")]
		public Sprite? MapIconSprite;

		[Description("How to rotate the location.\nUse 'Fixed' to use the rotation of the prefab.\nUse 'Random' to randomize the rotation.\nUse 'Slope' to rotate the location along a possible slope.")]
		public Rotation Rotation = Rotation.Random;

		[Description("The minimum and maximum height difference of the terrain below the location.")]
		public Range HeightDelta = new Range(0f, 2f);

		[Description("If the location should spawn near water.")]
		public bool SnapToWater;

		[Description("If the location should spawn in a forest.\nEverything above 1.15 is considered a forest by Valheim.\n2.19 is considered a thick forest by Valheim.")]
		public Range ForestThreshold = new Range(0f, 2.19f);

		[Description("Minimum and maximum range from the center of the map for the location.")]
		public Range SpawnDistance = new Range(0f, 10000f);

		[Description("Minimum and maximum altitude for the location.")]
		public Range SpawnAltitude = new Range(-1000f, 1000f);

		[Description("Adds a creature to a spawner that has been added to the location prefab.")]
		public Dictionary<string, string> CreatureSpawner = new Dictionary<string, string>();

		public static bool ConfigurationEnabled;

		private readonly Location location;

		private string folderName = "";

		private AssetBundle? assetBundle;

		private static readonly List<Location> registeredLocations;

		private static Transform? _cachedLocationMisc;

		private static bool firstStartup;

		private static BaseUnityPlugin? _plugin;

		[Description("Sets the map icon for the location.")]
		public string? MapIcon
		{
			get
			{
				return mapIconName;
			}
			set
			{
				mapIconName = value;
				MapIconSprite = ((mapIconName == null) ? null : loadSprite(mapIconName));
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		public Location(string assetBundleFileName, string prefabName, string folderName = "assets")
			: this(PrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
		{
			this.folderName = folderName;
		}

		public Location(AssetBundle bundle, string prefabName)
			: this(bundle.LoadAsset<GameObject>(prefabName))
		{
			assetBundle = bundle;
		}

		public Location(GameObject location)
			: this(location.GetComponent<Location>())
		{
			if ((Object)(object)this.location == (Object)null)
			{
				throw new ArgumentNullException("location", "The GameObject does not have a location component.");
			}
		}

		public Location(Location location)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			this.location = location;
			GroupName = ((Object)location).name;
			registeredLocations.Add(this);
		}

		public static void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
			}
		}

		private byte[]? ReadEmbeddedFileBytes(string name)
		{
			using MemoryStream memoryStream = new MemoryStream();
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + ((folderName == "") ? "" : ".") + folderName + "." + name);
			if (manifestResourceStream == null)
			{
				return null;
			}
			manifestResourceStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private Texture2D? loadTexture(string name)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			byte[] array = ReadEmbeddedFileBytes(name);
			if (array != null)
			{
				Texture2D val = new Texture2D(0, 0);
				val.LoadRawTextureData(array);
				return val;
			}
			return null;
		}

		private Sprite loadSprite(string name)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = loadTexture(name);
			if (val != null)
			{
				return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), Vector2.zero);
			}
			AssetBundle? obj = assetBundle;
			Sprite val2 = ((obj != null) ? obj.LoadAsset<Sprite>(name) : null);
			if (val2 != null)
			{
				return val2;
			}
			throw new FileNotFoundException("Could not find a file named " + name + " for the map icon");
		}

		private static void AddLocationToZoneSystem(ZoneSystem __instance)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: 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_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)_cachedLocationMisc))
			{
				GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
				foreach (GameObject val in array)
				{
					if (((Object)val).name == "_Locations")
					{
						Transform val2 = val.transform.Find("Misc");
						if (val2 != null)
						{
							_cachedLocationMisc = val2;
							break;
						}
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)_cachedLocationMisc))
			{
				return;
			}
			Transform cachedLocationMisc = _cachedLocationMisc;
			foreach (Location registeredLocation in registeredLocations)
			{
				GameObject val3 = Object.Instantiate<GameObject>(((Component)registeredLocation.location).gameObject, cachedLocationMisc, true);
				((Object)val3).name = ((Object)registeredLocation.location).name;
				__instance.m_locations.Add(new ZoneLocation
				{
					m_prefabName = ((Object)val3).name,
					m_enable = registeredLocation.CanSpawn,
					m_biome = registeredLocation.Biome,
					m_biomeArea = registeredLocation.SpawnArea,
					m_quantity = registeredLocation.Count,
					m_prioritized = registeredLocation.Prioritize,
					m_centerFirst = registeredLocation.PreferCenter,
					m_unique = registeredLocation.Unique,
					m_group = registeredLocation.GroupName,
					m_minDistanceFromSimilar = registeredLocation.MinimumDistanceFromGroup,
					m_iconAlways = (registeredLocation.ShowMapIcon == ShowIcon.Always),
					m_iconPlaced = (registeredLocation.ShowMapIcon == ShowIcon.Explored),
					m_randomRotation = (registeredLocation.Rotation == Rotation.Random),
					m_slopeRotation = (registeredLocation.Rotation == Rotation.Slope),
					m_snapToWater = registeredLocation.SnapToWater,
					m_minTerrainDelta = registeredLocation.HeightDelta.min,
					m_maxTerrainDelta = registeredLocation.HeightDelta.max,
					m_inForest = true,
					m_forestTresholdMin = registeredLocation.ForestThreshold.min,
					m_forestTresholdMax = registeredLocation.ForestThreshold.max,
					m_minDistance = registeredLocation.SpawnDistance.min,
					m_maxDistance = registeredLocation.SpawnDistance.max,
					m_minAltitude = registeredLocation.SpawnAltitude.min,
					m_maxAltitude = registeredLocation.SpawnAltitude.max
				});
			}
		}

		private static void AddLocationZNetViewsToZNetScene(ZNetScene __instance)
		{
			foreach (ZNetView item in registeredLocations.SelectMany((Location l) => ((Component)l.location).GetComponentsInChildren<ZNetView>(true)))
			{
				if (__instance.m_namedPrefabs.ContainsKey(StringExtensionMethods.GetStableHashCode(((Object)item).name)))
				{
					string name = ((Object)__instance.m_namedPrefabs[StringExtensionMethods.GetStableHashCode(((Object)item).name)]).name;
					if (((Object)item).name != name)
					{
						LogManager.Log.Error($"Found hash collision for names of prefabs {((Object)item).name} and {name} in {Assembly.GetExecutingAssembly()}. Skipping.");
					}
				}
				else
				{
					__instance.m_prefabs.Add(((Component)item).gameObject);
					__instance.m_namedPrefabs[StringExtensionMethods.GetStableHashCode(((Object)item).name)] = ((Component)item).gameObject;
				}
			}
			foreach (Location registeredLocation in registeredLocations)
			{
				CreatureSpawner[] componentsInChildren = ((Component)((Component)registeredLocation.location).transform).GetComponentsInChildren<CreatureSpawner>();
				foreach (CreatureSpawner val in componentsInChildren)
				{
					if (registeredLocation.CreatureSpawner.TryGetValue(((Object)val).name, out string value))
					{
						val.m_creaturePrefab = __instance.GetPrefab(value);
					}
				}
			}
		}

		private static void AddMinimapIcons(Minimap __instance)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			foreach (Location registeredLocation in registeredLocations)
			{
				Sprite mapIconSprite = registeredLocation.MapIconSprite;
				if (mapIconSprite != null)
				{
					__instance.m_locationIcons.Add(new LocationSpriteData
					{
						m_icon = mapIconSprite,
						m_name = ((Object)registeredLocation.location).name
					});
				}
			}
		}

		internal static void Patch_FejdStartup()
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			if (ConfigurationEnabled && firstStartup)
			{
				bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
				plugin.Config.SaveOnConfigSet = false;
				foreach (Location location in registeredLocations)
				{
					int num = 0;
					foreach (KeyValuePair<string, string> kv in location.CreatureSpawner)
					{
						ConfigEntry<string> spawnerCreature = null;
						ConfigSyncBase.SyncedConfig(((Object)location.location).name, kv.Key + " spawns", kv.Value, new ConfigDescription("", (AcceptableValueBase)null, new object[1]
						{
							new ConfigurationManagerAttributes
							{
								Order = (num -= 1)
							}
						}), ref spawnerCreature);
						spawnerCreature.SettingChanged += delegate
						{
							location.CreatureSpawner[kv.Key] = spawnerCreature.Value;
							if (Object.op_Implicit((Object)(object)ZNetScene.instance))
							{
								CreatureSpawner val = ((IEnumerable<CreatureSpawner>)((Component)((Component)location.location).transform).GetComponentsInChildren<CreatureSpawner>()).FirstOrDefault((Func<CreatureSpawner, bool>)((CreatureSpawner s) => ((Object)s).name == kv.Key));
								if (val != null)
								{
									val.m_creaturePrefab = ZNetScene.instance.GetPrefab(spawnerCreature.Value);
								}
							}
						};
					}
				}
				if (saveOnConfigSet)
				{
					plugin.Config.SaveOnConfigSet = true;
					plugin.Config.Save();
				}
			}
			firstStartup = false;
		}

		static Location()
		{
			//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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			_initialized = false;
			ConfigurationEnabled = true;
			registeredLocations = new List<Location>();
			firstStartup = true;
			Harmony val = new Harmony("org.bepinex.helpers.LocationManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Location), "AddLocationZNetViewsToZNetScene", (Type[])null, (Type[])null), 100, (string[])null, (string[])null, (bool?)null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZoneSystem), "SetupLocations", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Location), "AddLocationToZoneSystem", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Minimap), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Location), "AddMinimapIcons", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Location), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
}
namespace Vapok.Common.Managers.LocalizationManager
{
	[PublicAPI]
	public class LocalizeKey
	{
		public readonly string Key;

		public readonly Dictionary<string, string> Localizations = new Dictionary<string, string>();

		public LocalizeKey(string key)
		{
			Key = key.Replace("$", "");
		}

		public LocalizeKey English(string key)
		{
			return addForLang("English", key);
		}

		public LocalizeKey Swedish(string key)
		{
			return addForLang("Swedish", key);
		}

		public LocalizeKey French(string key)
		{
			return addForLang("French", key);
		}

		public LocalizeKey Italian(string key)
		{
			return addForLang("Italian", key);
		}

		public LocalizeKey German(string key)
		{
			return addForLang("German", key);
		}

		public LocalizeKey Spanish(string key)
		{
			return addForLang("Spanish", key);
		}

		public LocalizeKey Russian(string key)
		{
			return addForLang("Russian", key);
		}

		public LocalizeKey Romanian(string key)
		{
			return addForLang("Romanian", key);
		}

		public LocalizeKey Bulgarian(string key)
		{
			return addForLang("Bulgarian", key);
		}

		public LocalizeKey Macedonian(string key)
		{
			return addForLang("Macedonian", key);
		}

		public LocalizeKey Finnish(string key)
		{
			return addForLang("Finnish", key);
		}

		public LocalizeKey Danish(string key)
		{
			return addForLang("Danish", key);
		}

		public LocalizeKey Norwegian(string key)
		{
			return addForLang("Norwegian", key);
		}

		public LocalizeKey Icelandic(string key)
		{
			return addForLang("Icelandic", key);
		}

		public LocalizeKey Turkish(string key)
		{
			return addForLang("Turkish", key);
		}

		public LocalizeKey Lithuanian(string key)
		{
			return addForLang("Lithuanian", key);
		}

		public LocalizeKey Czech(string key)
		{
			return addForLang("Czech", key);
		}

		public LocalizeKey Hungarian(string key)
		{
			return addForLang("Hungarian", key);
		}

		public LocalizeKey Slovak(string key)
		{
			return addForLang("Slovak", key);
		}

		public LocalizeKey Polish(string key)
		{
			return addForLang("Polish", key);
		}

		public LocalizeKey Dutch(string key)
		{
			return addForLang("Dutch", key);
		}

		public LocalizeKey Portuguese_European(string key)
		{
			return addForLang("Portuguese_European", key);
		}

		public LocalizeKey Portuguese_Brazilian(string key)
		{
			return addForLang("Portuguese_Brazilian", key);
		}

		public LocalizeKey Chinese(string key)
		{
			return addForLang("Chinese", key);
		}

		public LocalizeKey Chinese_Trad(string key)
		{
			return addForLang("Chinese_Trad", key);
		}

		public LocalizeKey Japanese(string key)
		{
			return addForLang("Japanese", key);
		}

		public LocalizeKey Korean(string key)
		{
			return addForLang("Korean", key);
		}

		public LocalizeKey Hindi(string key)
		{
			return addForLang("Hindi", key);
		}

		public LocalizeKey Thai(string key)
		{
			return addForLang("Thai", key);
		}

		public LocalizeKey Abenaki(string key)
		{
			return addForLang("Abenaki", key);
		}

		public LocalizeKey Croatian(string key)
		{
			return addForLang("Croatian", key);
		}

		public LocalizeKey Georgian(string key)
		{
			return addForLang("Georgian", key);
		}

		public LocalizeKey Greek(string key)
		{
			return addForLang("Greek", key);
		}

		public LocalizeKey Serbian(string key)
		{
			return addForLang("Serbian", key);
		}

		public LocalizeKey Ukrainian(string key)
		{
			return addForLang("Ukrainian", key);
		}

		private LocalizeKey addForLang(string lang, string value)
		{
			Localizer.JvlLocalization.AddTranslation(ref lang, ref Key, value);
			return this;
		}
	}
	[PublicAPI]
	internal class Localizer
	{
		public class Waiting
		{
			public event EventHandler StatusChanged;

			public void TranslationsLoaded(bool loadDone)
			{
				if (loadDone)
				{
					this.StatusChanged?.Invoke(this, EventArgs.Empty);
				}
			}
		}

		private static bool _initialized;

		private static readonly Regex TokenRegex;

		public static Waiting Waiter;

		public static CustomLocalization JvlLocalization;

		private static readonly Regex sWhitespace;

		private static readonly List<string> fileExtensions;

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Expected O, but got Unknown
				IEnumerable<TypeInfo> source;
				try
				{
					source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
				}
				catch (ReflectionTypeLoadException ex)
				{
					source = from t in ex.Types
						where t != null
						select t.GetTypeInfo();
				}
				return (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
			}
		}

		static Localizer()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			_initialized = false;
			TokenRegex = new Regex("\\$[\\w_]+", RegexOptions.Compiled);
			Waiter = null;
			sWhitespace = new Regex("\\s+");
			fileExtensions = new List<string> { ".json", ".yml" };
			Waiter = new Waiting();
			new Harmony("org.bepinex.helpers.LocalizationManager").Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static string GetTranslation(string language, string input)
		{
			if (string.IsNullOrEmpty(input))
			{
				return input;
			}
			return TokenRegex.Replace(input, delegate(Match match)
			{
				string key = match.Value.Substring(1);
				string value;
				return JvlLocalization.GetTranslations(ref language).TryGetValue(key, out value) ? value : match.Value;
			});
		}

		public static void Init(CustomLocalization localization)
		{
			if (!_initialized)
			{
				_initialized = true;
			}
			JvlLocalization = localization;
			JvlLocalization.AddJsonFile("English", Encoding.UTF8.GetString(LoadTranslationFromAssembly("English") ?? Array.Empty<byte>()));
			LogManager.Log.Debug("Finished Loading English File");
			string directoryName = Path.GetDirectoryName(Paths.PluginPath);
			LogManager.Log.Debug("Plugin Path: " + directoryName + " ");
			string text = sWhitespace.Replace(plugin.Info.Metadata.Name + ".*", "");
			LogManager.Log.Debug("File Names: " + text + " ");
			List<string> list = (from f in Directory.GetFiles(directoryName, text, SearchOption.AllDirectories)
				where fileExtensions.IndexOf(Path.GetExtension(f)) >= 0
				select f).ToList();
			LogManager.Log.Debug($"Language Files Found: {list.Count()} ");
			foreach (string item in list)
			{
				LogManager.Log.Debug("Language File Found: " + item + " ");
				try
				{
					if (Path.GetFileNameWithoutExtension(item).Split(new char[1] { '.' }).Length == 0)
					{
						LogManager.Log.Debug("No Language found in File Name: " + item + " ");
					}
					string text2 = Path.GetFileNameWithoutExtension(item).Split(new char[1] { '.' })[1];
					LogManager.Log.Debug("Language Key From File: " + text2 + " ");
					string text3 = File.ReadAllText(item);
					JvlLocalization.AddJsonFile(text2, text3);
				}
				catch (Exception ex)
				{
					LogManager.Log.Error("Error Processing Language File: " + item + " Error: " + ex.Message);
					LogManager.Log.Error("Stack Trace: " + ex.StackTrace);
				}
			}
		}

		[HarmonyPriority(800)]
		private static void Patch_FejdStartup()
		{
			Waiter.TranslationsLoaded(loadDone: true);
		}

		private static byte[]? LoadTranslationFromAssembly(string language)
		{
			foreach (string fileExtension in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
				if (array != null)
				{
					return array;
				}
				byte[] array2 = ReadEmbeddedFileBytes("Translations." + language + fileExtension);
				if (array2 != null)
				{
					return array2;
				}
			}
			return null;
		}

		public static byte[]? ReadEmbeddedFileBytes(string resourceFileName, Assembly? containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault((string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
}
namespace Vapok.Common.Managers.Creature
{
	internal enum Toggle
	{
		On,
		Off
	}
	[PublicAPI]
	internal enum GlobalKey
	{
		[InternalName("")]
		None,
		[InternalName("defeated_bonemass")]
		KilledBonemass,
		[InternalName("defeated_gdking")]
		KilledElder,
		[InternalName("defeated_goblinking")]
		KilledYagluth,
		[InternalName("defeated_dragon")]
		KilledModer,
		[InternalName("defeated_eikthyr")]
		KilledEikthyr,
		[InternalName("KilledTroll")]
		KilledTroll,
		[InternalName("killed_surtling")]
		KilledSurtling
	}
	[Flags]
	[PublicAPI]
	internal enum Weather
	{
		[InternalName("")]
		None = 0,
		[InternalName("Clear")]
		ClearSkies = 1,
		[InternalName("Heath clear")]
		MeadowsClearSkies = 4,
		[InternalName("LightRain")]
		LightRain = 8,
		[InternalName("Rain")]
		Rain = 0x10,
		[InternalName("ThunderStorm")]
		ThunderStorm = 0x20,
		[InternalName("nofogts")]
		ClearThunderStorm = 0x40,
		[InternalName("SwampRain")]
		SwampRain = 0x80,
		[InternalName("Darklands_dark")]
		MistlandsDark = 0x100,
		[InternalName("Ashrain")]
		AshlandsAshrain = 0x200,
		[InternalName("Snow")]
		MountainSnow = 0x400,
		[InternalName("SnowStorm")]
		MountainBlizzard = 0x800,
		[InternalName("DeepForest Mist")]
		BlackForestFog = 0x1000,
		[InternalName("Misty")]
		Fog = 0x2000,
		[InternalName("Twilight_Snow")]
		DeepNorthSnow = 0x4000,
		[InternalName("Twilight_SnowStorm")]
		DeepNorthSnowStorm = 0x8000,
		[InternalName("Twilight_Clear")]
		DeepNorthClear = 0x10000,
		[InternalName("Eikthyr")]
		EikthyrsThunderstorm = 0x20000,
		[InternalName("GDKing")]
		EldersHaze = 0x40000,
		[InternalName("Bonemass")]
		BonemassDownpour = 0x80000,
		[InternalName("Moder")]
		ModersVortex = 0x100000,
		[InternalName("GoblinKing")]
		YagluthsMagicBlizzard = 0x200000,
		[InternalName("Crypt")]
		Crypt = 0x400000,
		[InternalName("SunkenCrypt")]
		SunkenCrypt = 0x800000
	}
	internal class InternalName : Attribute
	{
		public readonly string internalName;

		public InternalName(string internalName)
		{
			this.internalName = internalName;
		}
	}
	internal enum DropOption
	{
		Disabled,
		Default,
		Custom
	}
	internal enum SpawnOption
	{
		Disabled,
		Default,
		Custom
	}
	internal enum SpawnTime
	{
		Day,
		Night,
		Always
	}
	internal enum SpawnArea
	{
		Center,
		Edge,
		Everywhere
	}
	internal enum Forest
	{
		Yes,
		No,
		Both
	}
	[PublicAPI]
	internal struct Range
	{
		public float min;

		public float max;

		public Range(float min, float max)
		{
			this.min = min;
			this.max = max;
		}
	}
	[PublicAPI]
	internal class Creature
	{
		[PublicAPI]
		public class DropList
		{
			internal class SerializedDrops
			{
				public readonly List<KeyValuePair<string, Drop>> Drops;

				public SerializedDrops(DropList drops, Creature creature)
				{
					Drops = (drops.drops ?? creature.Prefab.GetComponent<CharacterDrop>()?.m_drops.ToDictionary((Drop drop) => ((Object)drop.m_prefab).name, (Drop drop) => new Drop
					{
						Amount = new Range(drop.m_amountMin, drop.m_amountMax),
						DropChance = drop.m_chance,
						DropOnePerPlayer = drop.m_onePerPlayer,
						MultiplyDropByLevel = drop.m_levelMultiplier
					}) ?? new Dictionary<string, Drop>()).ToList();
				}

				public SerializedDrops(List<KeyValuePair<string, Drop>> drops)
				{
					Drops = drops;
				}

				public SerializedDrops(string reqs)
				{
					Drops = (from r in reqs.Split(new char[1] { ',' })
						select r.Split(new char[1] { ':' })).ToDictionary((string[] l) => l[0], delegate(string[] parts)
					{
						Range amount = new Range(1f, 1f);
						if (parts.Length > 1)
						{
							string[] array = parts[1].Split(new char[1] { '-' });
							if (!int.TryParse(array[0], out var result))
							{
								result = 1;
							}
							if (array.Length == 1 || !int.TryParse(array[1], out var result2))
							{
								result2 = result;
							}
							amount = new Range(result, result2);
						}
						float result3;
						return new Drop
						{
							Amount = amount,
							DropChance = ((parts.Length > 2 && float.TryParse(parts[2], NumberStyles.Any, CultureInfo.InvariantCulture, out result3)) ? result3 : 100f),
							DropOnePerPlayer = (parts.Length > 3 && parts[3] == "onePerPlayer"),
							MultiplyDropByLevel = (parts.Length > 4 && parts[4] == "multiplyByLevel")
						};
					}).ToList();
				}

				public override string ToString()
				{
					return string.Join(",", Drops.Select<KeyValuePair<string, Drop>, string>((KeyValuePair<string, Drop> kv) => string.Format("{0}:{1}-{2}:{3}:{4}:{5}", kv.Key, kv.Value.Amount.min, kv.Value.Amount.max, kv.Value.DropChance, kv.Value.DropOnePerPlayer ? "onePerPlayer" : "unrestricted", kv.Value.MultiplyDropByLevel ? "multiplyByLevel" : "unaffectedByLevel")));
				}
			}

			private Dictionary<string, Drop>? drops;

			public Drop this[string prefabName]
			{
				get
				{
					if (!(drops ?? (drops = new Dictionary<string, Drop>())).TryGetValue(prefabName, out Drop value))
					{
						return drops[prefabName] = new Drop();
					}
					return value;
				}
			}

			public void None()
			{
				drops = new Dictionary<string, Drop>();
			}

			[HarmonyPriority(700)]
			internal static void AddDropsToCreature()
			{
				foreach (Creature registeredCreature in registeredCreatures)
				{
					UpdateDrops(registeredCreature);
				}
			}

			internal static void UpdateDrops(Creature creature)
			{
				if (creatureConfigs[creature].Drops.get() == DropOption.Default && creature.Drops.drops == null)
				{
					return;
				}
				CharacterDrop val = creature.Prefab.GetComponent<CharacterDrop>() ?? creature.Prefab.AddComponent<CharacterDrop>();
				val.m_drops = (from d in (creatureConfigs[creature].Drops.get() switch
					{
						DropOption.Custom => new SerializedDrops(creatureConfigs[creature].CustomDrops.get()).Drops, 
						DropOption.Disabled => new List<KeyValuePair<string, Drop>>(), 
						_ => creature.Drops.drops.ToList(), 
					}).Select((Func<KeyValuePair<string, Drop>, Drop>)delegate(KeyValuePair<string, Drop> kv)
					{
						//IL_0063: Unknown result type (might be due to invalid IL or missing references)
						//IL_0068: Unknown result type (might be due to invalid IL or missing references)
						//IL_006f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0087: Unknown result type (might be due to invalid IL or missing references)
						//IL_009f: Unknown result type (might be due to invalid IL or missing references)
						//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
						//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
						//IL_00dc: Expected O, but got Unknown
						if (kv.Key == "" || ZNetScene.instance == null)
						{
							return (Drop)null;
						}
						GameObject prefab = ZNetScene.instance.GetPrefab(kv.Key);
						if (prefab != null)
						{
							return new Drop
							{
								m_prefab = prefab,
								m_amountMin = (int)kv.Value.Amount.min,
								m_amountMax = (int)kv.Value.Amount.max,
								m_chance = kv.Value.DropChance / 100f,
								m_onePerPlayer = kv.Value.DropOnePerPlayer,
								m_levelMultiplier = kv.Value.MultiplyDropByLevel
							};
						}
						LogManager.Log.Warning("Found invalid prefab name " + kv.Key + " for creature " + ((Object)creature.Prefab).name);
						return (Drop)null;
					})
					where d != null
					select d).ToList();
			}
		}

		[PublicAPI]
		public class Drop
		{
			public Range Amount = new Range(1f, 1f);

			public float DropChance = 100f;

			public bool DropOnePerPlayer;

			public bool MultiplyDropByLevel = true;
		}

		private class CustomConfig<T>
		{
			public Func<T> get;

			public ConfigEntry<T>? config;
		}

		private class CreatureConfig
		{
			public readonly CustomConfig<SpawnOption> Spawn = new CustomConfig<SpawnOption>();

			public readonly CustomConfig<Toggle> CanBeTamed = new CustomConfig<Toggle>();

			public readonly CustomConfig<string> ConsumesItemName = new CustomConfig<string>();

			public readonly CustomConfig<SpawnTime> SpecificSpawnTime = new CustomConfig<SpawnTime>();

			public readonly CustomConfig<Range> RequiredAltitude = new CustomConfig<Range>();

			public readonly CustomConfig<Range> RequiredOceanDepth = new CustomConfig<Range>();

			public readonly CustomConfig<GlobalKey> RequiredGlobalKey = new CustomConfig<GlobalKey>();

			public readonly CustomConfig<Range> GroupSize = new CustomConfig<Range>();

			public readonly CustomConfig<Biome> Biome = new CustomConfig<Biome>();

			public readonly CustomConfig<SpawnArea> SpecificSpawnArea = new CustomConfig<SpawnArea>();

			public readonly CustomConfig<Weather> RequiredWeather = new CustomConfig<Weather>();

			public readonly CustomConfig<float> SpawnAltitude = new CustomConfig<float>();

			public readonly CustomConfig<Toggle> CanHaveStars = new CustomConfig<Toggle>();

			public readonly CustomConfig<Toggle> AttackImmediately = new CustomConfig<Toggle>();

			public readonly CustomConfig<int> CheckSpawnInterval = new CustomConfig<int>();

			public readonly CustomConfig<float> SpawnChance = new CustomConfig<float>();

			public readonly CustomConfig<Forest> ForestSpawn = new CustomConfig<Forest>();

			public readonly CustomConfig<int> Maximum = new CustomConfig<int>();

			public readonly CustomConfig<DropOption> Drops = new CustomConfig<DropOption>();

			public readonly CustomConfig<string> CustomDrops = new CustomConfig<string>();
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string? Category;

			[UsedImplicitly]
			public Action<ConfigEntryBase>? CustomDrawer;
		}

		private class AcceptableEnumValues<T> : AcceptableValueBase where T : struct, IConvertible
		{
			[PublicAPI]
			public virtual T[] AcceptableValues { get; }

			public AcceptableEnumValues(params T[] acceptableValues)
				: base(typeof(T))
			{
				AcceptableValues = acceptableValues;
			}

			public override object Clamp(object value)
			{
				if (!((AcceptableValueBase)this).IsValid(value))
				{
					return AcceptableValues[0];
				}
				return value;
			}

			public override bool IsValid(object value)
			{
				return AcceptableValues.Contains((T)value);
			}

			public override string ToDescriptionString()
			{
				return string.Join(", ", AcceptableValues);
			}
		}

		public bool ConfigurationEnabled = true;

		public readonly GameObject Prefab;

		public DropList Drops = new DropList();

		public bool CanSpawn = true;

		public bool CanBeTamed;

		[Description("List of items the creature consumes to get tame.\nFor multiple item names, separate them with a comma.")]
		public string FoodItems;

		[Description("Sets the time of day the creature can spawn.")]
		public SpawnTime SpecificSpawnTime = SpawnTime.Always;

		[Description("Sets the minimum and maximum altitude for the creature to spawn.")]
		public Range RequiredAltitude = new Range(5f, 1000f);

		[Description("Sets the minimum and maximum depth of the ocean for the creature to spawn.")]
		public Range RequiredOceanDepth = new Range(0f, 0f);

		[Description("Sets a global key required for the creature to spawn.")]
		public GlobalKey RequiredGlobalKey;

		[Description("Sets a range for the group size the creature spawns in.")]
		public Range GroupSize = new Range(1f, 1f);

		[Description("Sets the biome the creature spawns in.")]
		public Biome Biome = (Biome)1;

		[Description("Sets spawning area for the creature inside the biome.\nUse SpawnArea.Edge, to make the creature spawn more towards the edge of the biome.\nUse SpawnArea.Center, to make the creature spawn more towards the center of the biome.")]
		public SpawnArea SpecificSpawnArea = SpawnArea.Everywhere;

		[Description("Sets the weather condition for the creature to spawn.\nUse the Weather enum for easy configuration.")]
		public Weather RequiredWeather;

		[Description("Sets altitude relative to the current ground level for the creature to spawn.\nShould be a higher number for flying creatures, so they spawn in the sky.")]
		public float SpawnAltitude = 0.5f;

		public bool CanHaveStars = true;

		[Description("Controls the first AI command right after spawn.\nSet to true for the creature to immediately start to hunt down the player.")]
		public bool AttackImmediately;

		[Description("The time between attempts to spawn the creature in.")]
		public int CheckSpawnInterval = 600;

		[Description("The chance in percent for the creature to spawn, every time Valheim checks if it should spawn.")]
		public float SpawnChance = 100f;

		[Description("Can be used to make the creature spawn in forests or prevent it from spawning in forests.\nUse the Forest enum for easy configuration.")]
		public Forest ForestSpawn = Forest.Both;

		[Description("Sets the maximum number of the creature that can be near the player, before Valheim disables its spawn.")]
		public int Maximum = 1;

		private static readonly List<Creature> registeredCreatures = new List<Creature>();

		private static Dictionary<Creature, CreatureConfig> creatureConfigs = new Dictionary<Creature, CreatureConfig>();

		private static object? configManager;

		private static List<SpawnData> lastRegisteredSpawns = new List<SpawnData>();

		private static Localization? _english;

		private static BaseUnityPlugin? _plugin;

		private static Localization english
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				if (_english == null)
				{
					_english = new Localization();
					_english.SetupLanguage("English");
				}
				return _english;
			}
		}

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		public Creature(string assetBundleFileName, string prefabName, string folderName = "assets")
			: this(PrefabManager.RegisterAssetBundle(assetBundleFileName, folderName), prefabName)
		{
		}

		public Creature(AssetBundle bundle, string prefabName)
			: this(PrefabManager.RegisterPrefab(bundle, prefabName))
		{
		}

		public Creature(GameObject creature)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Prefab = creature;
			registeredCreatures.Add(this);
			CanBeTamed = Object.op_Implicit((Object)(object)creature.GetComponent<Tameable>());
			FoodItems = string.Join(",", (from i in creature.GetComponent<MonsterAI>()?.m_consumeItems
				where Object.op_Implicit((Object)(object)i.m_itemData.m_dropPrefab)
				select ((Object)i.m_itemData.m_dropPrefab).name) ?? Enumerable.Empty<string>());
		}

		public LocalizeKey Localize()
		{
			return new LocalizeKey(Prefab.GetComponent<Character>().m_name);
		}

		internal static void Patch_FejdStartup()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_068f: Expected O, but got Unknown
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "ConfigurationManager")?.GetType("ConfigurationManager.ConfigurationManager");
			configManager = ((type == null) ? null : Chainloader.ManagerObject.GetComponent(type));
			if (!TomlTypeConverter.CanConvert(typeof(Range)))
			{
				TomlTypeConverter.AddConverter(typeof(Range), new TypeConverter
				{
					ConvertToObject = delegate(string s, Type _)
					{
						Match match = Regex.Match(s, "^(-?\\d+(?:\\.\\d*)?)\\s*-\\s*(-?\\d+(?:\\.\\d*)?)$");
						return match.Success ? new Range(float.Parse(match.Groups[1].Value), float.Parse(match.Groups[2].Value)) : default(Range);
					},
					ConvertToString = delegate(object obj, Type _)
					{
						Range range = (Range)obj;
						return $"{range.min} - {range.max}";
					}
				});
			}
			bool saveOnConfigSet = plugin.Config.SaveOnConfigSet;
			plugin.Config.SaveOnConfigSet = false;
			foreach (Creature registeredCreature in registeredCreatures)
			{
				Creature creature = registeredCreature;
				CreatureConfig creatureConfig = (creatureConfigs[creature] = new CreatureConfig());
				CreatureConfig cfg = creatureConfig;
				string name = creature.Prefab.GetComponent<Character>().m_name;
				string englishName = new Regex("['[\"\\]]").Replace(Localizer.GetTranslation("English", name), "").Trim();
				string localizedName = Localization.instance.Localize(name).Trim();
				int order = 0;
				ConfigurationManagerAttributes tameConfigVisibility = new ConfigurationManagerAttributes();
				config<Toggle>(cfg.CanBeTamed, () => (!creature.CanBeTamed) ? Toggle.Off : Toggle.On, delegate
				{
					tameConfigVisibility.Browsable = cfg.CanBeTamed.get() == Toggle.On;
					reloadConfigDisplay();
					updateAI();
				}, "Can be tamed", "Decides, if the creature can be tamed.");
				tameConfigVisibility.Browsable = cfg.CanBeTamed.get() == Toggle.On;
				configWithDesc<string>(cfg.ConsumesItemName, () => creature.FoodItems, updateAI, "Food items", new ConfigDescription("The items the creature consumes to get tame.", (AcceptableValueBase)null, new object[1] { tameConfigVisibility }));
				ConfigurationManagerAttributes spawnConfigVisibility = new ConfigurationManagerAttributes();
				ConfigurationManagerAttributes dropConfigVisibility = new ConfigurationManagerAttributes();
				config<SpawnOption>(cfg.Spawn, () => creature.CanSpawn ? SpawnOption.Default : SpawnOption.Disabled, delegate
				{
					spawnConfigVisibility.Browsable = cfg.Spawn.get() == SpawnOption.Custom;
					reloadConfigDisplay();
					updateAllSpawnConfigs();
				}, "Spawn", "Configures the spawn for the creature.");
				spawnConfigVisibility.Browsable = cfg.Spawn.get() == SpawnOption.Custom;
				spawnConfig<SpawnTime>(cfg.SpecificSpawnTime, () => creature.SpecificSpawnTime, "Spawn time", "Configures the time of day for the creature to spawn.");
				spawnConfig<Range>(cfg.RequiredAltitude, () => creature.RequiredAltitude, "Required altitude", "Configures the altitude required for the creature to spawn.");
				spawnConfig<Range>(cfg.RequiredOceanDepth, () => creature.RequiredOceanDepth, "Required ocean depth", "Configures the ocean depth required for the creature to spawn.");
				spawnConfig<GlobalKey>(cfg.RequiredGlobalKey, () => creature.RequiredGlobalKey, "Required global key", "Configures the global key required for the creature to spawn.");
				spawnConfig<Range>(cfg.GroupSize, () => creature.GroupSize, "Group size", "Configures the size of the groups in which the creature spawns.");
				spawnConfig<Biome>(cfg.Biome, () => creature.Biome, "Biome", "Configures the biome required for the creature to spawn.");
				spawnConfig<SpawnArea>(cfg.SpecificSpawnArea, () => creature.SpecificSpawnArea, "Spawn area", "Configures if the creature spawns more towards the center or the edge of the biome.");
				spawnConfig<Weather>(cfg.RequiredWeather, () => creature.RequiredWeather, "Required weather", "Configures the weather required for the creature to spawn.");
				spawnConfig<float>(cfg.SpawnAltitude, () => creature.SpawnAltitude, "Spawn altitude", "Configures the height from the ground in which the creature will spawn.");
				spawnConfig<Toggle>(cfg.CanHaveStars, () => (!creature.CanHaveStars) ? Toggle.Off : Toggle.On, "Can have stars", "If the creature can have stars.");
				spawnConfig<Toggle>(cfg.AttackImmediately, () => (!creature.AttackImmediately) ? Toggle.Off : Toggle.On, "Hunt player", "Makes the creature immediately hunt down the player after it spawns.");
				spawnConfig<int>(cfg.CheckSpawnInterval, () => creature.CheckSpawnInterval, "Maximum spawn interval", "Configures the timespan that Valheim has to make the creature spawn.");
				spawnConfig<float>(cfg.SpawnChance, () => creature.SpawnChance, "Spawn chance", "Sets the chance for the creature to be spawned, every time Valheim checks the spawn.");
				spawnConfig<Forest>(cfg.ForestSpawn, () => creature.ForestSpawn, "Forest condition", "If the creature can spawn in forests or cannot spawn in forests. Or both.");
				spawnConfig<int>(cfg.Maximum, () => creature.Maximum, "Maximum creature count", "The maximum number of this creature near the player, before Valheim stops spawning it in. Setting this lower than the upper limit of the group size does not make sense.");
				config<DropOption>(cfg.Drops, () => DropOption.Default, delegate
				{
					dropConfigVisibility.Browsable = cfg.Drops.get() == DropOption.Custom;
					reloadConfigDisplay();
					DropList.UpdateDrops(creature);
				}, "Drops", "Configures the drops for the creature.");
				dropConfigVisibility.Browsable = cfg.Drops.get() == DropOption.Custom;
				configWithDesc<string>(cfg.CustomDrops, () => new DropList.SerializedDrops(creature.Drops, creature).ToString(), delegate
				{
					DropList.UpdateDrops(creature);
				}, "Drop config", new ConfigDescription("", (AcceptableValueBase)null, new object[1] { dropConfigVisibility }));
				void config<T>(CustomConfig<T> customConfig, Func<T> getter, Action configChanged, string name2, string desc) where T : notnull
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Expected O, but got Unknown
					configWithDesc<T>(customConfig, getter, configChanged, name2, new ConfigDescription(desc, (AcceptableValueBase)null, Array.Empty<object>()));
				}
				void configWithDesc<T>(CustomConfig<T> customConfig, Func<T> getter, Action configChanged, string configName, ConfigDescription desc) where T : notnull
				{
					//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
					//IL_0111: Expected O, but got Unknown
					if (creature.ConfigurationEnabled)
					{
						ConfigSyncBase.SyncedConfig(englishName, configName, getter(), new ConfigDescription(desc.Description, desc.AcceptableValues, desc.Tags.Concat(new ConfigurationManagerAttributes[1]
						{
							new ConfigurationManagerAttributes
							{
								Order = (order -= 1),
								CustomDrawer = (((object)customConfig == cfg.CustomDrops) ? new Action<ConfigEntryBase>(drawConfigTable) : ((typeof(T) == typeof(Range)) ? new Action<ConfigEntryBase>(drawRange) : null)),
								Category = localizedName
							}
						}).ToArray()), ref customConfig.config);
						customConfig.config.SettingChanged += delegate
						{
							configChanged();
						};
						customConfig.get = () => customConfig.config.Value;
					}
					else
					{
						customConfig.get = getter;
					}
				}
				void spawnConfig<T>(CustomConfig<T> customConfig, Func<T> getter, string name2, string desc, AcceptableValueBase? acceptableValues = null) where T : notnull
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Expected O, but got Unknown
					configWithDesc<T>(customConfig, getter, updateAllSpawnConfigs, name2, new ConfigDescription(desc, acceptableValues, new object[1] { spawnConfigVisibility }));
				}
				void updateAI()
				{
					if (Object.op_Implicit((Object)(object)ObjectDB.instance))
					{
						BaseAI[] array = Object.FindObjectsByType<BaseAI>((FindObjectsInactive)1, (FindObjectsSortMode)1);
						foreach (BaseAI ai in array)
						{
							creature.updateAi(ai);
						}
						creature.updateAi(creature.Prefab.GetComponent<BaseAI>());
					}
				}
				void updateAllSpawnConfigs()
				{
					SpawnSystem[] array = Object.FindObjectsByType<SpawnSystem>((FindObjectsInactive)1, (FindObjectsSortMode)1);
					for (int i = 0; i < array.Length; i++)
					{
						foreach (SpawnSystemList spawnList in array[i].m_spawnLists)
						{
							foreach (SpawnData spawner in spawnList.m_spawners)
							{
								if ((Object)(object)creature.Prefab == (Object)(object)spawner.m_prefab)
								{
									creature.updateSpawnData(spawner);
								}
							}
						}
					}
				}
			}
			if (saveOnConfigSet)
			{
				plugin.Config.SaveOnConfigSet = true;
				plugin.Config.Save();
			}
			static void reloadConfigDisplay()
			{
				object obj = configManager?.GetType().GetProperty("DisplayingWindow").GetValue(configManager);
				if (obj is bool && (bool)obj)
				{
					configManager.GetType().GetMethod("BuildSettingList").Invoke(configManager, Array.Empty<object>());
				}
			}
		}

		private static void drawRange(ConfigEntryBase cfg)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select((object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? ((bool?)null) : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue) == true;
			ConfigEntry<Range> val = (ConfigEntry<Range>)(object)cfg;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			float.TryParse(GUILayout.TextField(val.Value.min.ToString(CultureInfo.InvariantCulture), Array.Empty<GUILayoutOption>()), out var result);
			GUILayout.Label(" - ", new GUIStyle(GUI.skin.label)
			{
				fixedWidth = 14f
			}, Array.Empty<GUILayoutOption>());
			float.TryParse(GUILayout.TextField(val.Value.max.ToString(CultureInfo.InvariantCulture), Array.Empty<GUILayoutOption>()), out var result2);
			GUILayout.EndHorizontal();
			if (!valueOrDefault && (Math.Abs(val.Value.min - result) > 1E-05f || Math.Abs(val.Value.max - result2) > 1E-05f))
			{
				val.Value = new Range(result, result2);
			}
		}

		private static void drawConfigTable(ConfigEntryBase cfg)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//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_016d: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			//IL_0261: 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_027b: Expected O, but got Unknown
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Expected O, but got Unknown
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Expected O, but got Unknown
			bool valueOrDefault = cfg.Description.Tags.Select((object a) => (!(a.GetType().Name == "ConfigurationManagerAttributes")) ? ((bool?)null) : ((bool?)a.GetType().GetField("ReadOnly")?.GetValue(a))).FirstOrDefault((bool? v) => v.HasValue) == true;
			List<KeyValuePair<string, Drop>> list = new List<KeyValuePair<string, Drop>>();
			bool flag = false;
			int num = (int)(configManager?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true)
				.Invoke(configManager, Array.Empty<object>()) ?? ((object)130));
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			foreach (KeyValuePair<string, Drop> drop in new DropList.SerializedDrops((string)cfg.BoxedValue).Drops)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				int num2 = Mathf.RoundToInt(drop.Value.Amount.min);
				if (int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result) && result != num2 && !valueOrDefault)
				{
					num2 = result;
					flag = true;
				}
				GUILayout.Label(" - ", new GUIStyle(GUI.skin.label)
				{
					fixedWidth = 14f
				}, Array.Empty<GUILayoutOption>());
				int num3 = Mathf.RoundToInt(drop.Value.Amount.max);
				if (int.TryParse(GUILayout.TextField(num3.ToString(), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 35f
				}, Array.Empty<GUILayoutOption>()), out var result2) && result2 != num3 && !valueOrDefault)
				{
					num3 = result2;
					flag = true;
				}
				GUILayout.Label(" ", new GUIStyle(GUI.skin.label)
				{
					fixedWidth = 10f
				}, Array.Empty<GUILayoutOption>());
				string text = GUILayout.TextField(drop.Key, new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = num - 35 - 14 - 35 - 10 - 21 - 18
				}, Array.Empty<GUILayoutOption>());
				string text2 = (valueOrDefault ? drop.Key : text);
				flag = flag || text2 != drop.Key;
				bool num4 = GUILayout.Button("x", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault;
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				float num5 = drop.Value.DropChance;
				if (float.TryParse(GUILayout.TextField(num5.ToString(CultureInfo.InvariantCulture), new GUIStyle(GUI.skin.textField)
				{
					fixedWidth = 45f
				}, Array.Empty<GUILayoutOption>()), out var result3) && Math.Abs(result3 - num5) > 1E-05f && !valueOrDefault)
				{
					num5 = result3;
					flag = true;
				}
				GUILayout.Label("% ", Array.Empty<GUILayoutOption>());
				string tooltip = GUI.tooltip;
				bool flag2 = drop.Value.MultiplyDropByLevel;
				bool flag3 = GUILayout.Toggle(flag2, new GUIContent(flag2 ? "per level" : "fixed", "Loot is multiplied by the creature's level."), Array.Empty<GUILayoutOption>());
				if (flag3 != flag2 && !valueOrDefault)
				{
					flag2 = flag3;
					flag = true;
				}
				bool flag4 = drop.Value.DropOnePerPlayer;
				bool flag5 = GUILayout.Toggle(flag4, new GUIContent(flag4 ? "per player" : "independent", "Drops one per player."), Array.Empty<GUILayoutOption>());
				if (flag5 != flag4 && !valueOrDefault)
				{
					flag4 = flag5;
					flag = true;
				}
				if (GUI.tooltip != tooltip)
				{
					Vector3 mousePosition = Input.mousePosition;
					GUI.Label(new Rect(mousePosition.x, mousePosition.y, 100f, 35f), GUI.tooltip);
				}
				if (num4)
				{
					flag = true;
				}
				else
				{
					Drop value = new Drop
					{
						Amount = new Range(num2, num3),
						DropChance = num5,
						MultiplyDropByLevel = flag2,
						DropOnePerPlayer = flag4
					};
					list.Add(new KeyValuePair<string, Drop>(text2, value));
				}
				if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
				{
					fixedWidth = 21f
				}, Array.Empty<GUILayoutOption>()) && !valueOrDefault)
				{
					flag = true;
					list.Add(new KeyValuePair<string, Drop>("", new Drop()));
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndVertical();
			if (flag)
			{
				cfg.BoxedValue = new DropList.SerializedDrops(list).ToString();
			}
		}

		private void updateAi(BaseAI ai)
		{
			CreatureConfig creatureConfig = creatureConfigs[this];
			if (Object.op_Implicit((Object)(object)((Component)ai).GetComponent<Tameable>()) != (creatureConfig.CanBeTamed.get() == Toggle.On))
			{
				if (creatureConfig.CanBeTamed.get() == Toggle.On)
				{
					ai.m_tamable = ((Component)ai).gameObject.AddComponent<Tameable>();
				}
				else
				{
					Object.Destroy((Object)(object)ai.m_tamable);
					ai.m_tamable = null;
				}
			}
			MonsterAI val = (MonsterAI)(object)((ai is MonsterAI) ? ai : null);
			if (val == null)
			{
				return;
			}
			val.m_consumeItems.Clear();
			string[] array = creatureConfig.ConsumesItemName.get().Split(new char[1] { ',' });
			foreach (string text in array)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text.Trim());
				ItemDrop val2 = ((itemPrefab != null) ? itemPrefab.GetComponent<ItemDrop>() : null);
				if (val2 != null)
				{
					val.m_consumeItems.Add(val2);
				}
			}
		}

		internal static void UpdateCreatureAis(ObjectDB __instance)
		{
			foreach (Creature registeredCreature in registeredCreatures)
			{
				registeredCreature.updateAi(registeredCreature.Prefab.GetComponent<BaseAI>());
			}
		}

		private void updateSpawnData(SpawnData spawnData)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			CreatureConfig cfg = creatureConfigs[this];
			spawnData.m_enabled = cfg.Spawn.get() != SpawnOption.Disabled;
			spawnData.m_biome = cfg.Biome.get();
			SpawnData val = spawnData;
			val.m_biomeArea = (BiomeArea)(cfg.SpecificSpawnArea.get() switch
			{
				SpawnArea.Center => 2, 
				SpawnArea.Edge => 1, 
				_ => 3, 
			});
			spawnData.m_maxSpawned = cfg.Maximum.get();
			spawnData.m_spawnInterval = cfg.CheckSpawnInterval.get();
			spawnData.m_spawnChance = cfg.SpawnChance.get();
			spawnData.m_requiredGlobalKey = ((InternalName)typeof(GlobalKey).GetMember(cfg.RequiredGlobalKey.get().ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName;
			spawnData.m_requiredEnvironments = (from Weather w in Enum.GetValues(typeof(Weather))
				where (w & cfg.RequiredWeather.get()) != 0
				select ((InternalName)typeof(Weather).GetMember(w.ToString())[0].GetCustomAttributes(typeof(InternalName)).First()).internalName).ToList();
			spawnData.m_groupSizeMin = (int)cfg.GroupSize.get().min;
			spawnData.m_groupSizeMax = (int)cfg.GroupSize.get().max;
			val = spawnData;
			SpawnTime spawnTime = cfg.SpecificSpawnTime.get();
			bool spawnAtNight = (uint)(spawnTime - 1) <= 1u;
			val.m_spawnAtNight = spawnAtNight;
			val = spawnData;
			spawnTime = cfg.SpecificSpawnTime.get();
			spawnAtNight = ((spawnTime == SpawnTime.Day || spawnTime == SpawnTime.Always) ? true : false);
			val.m_spawnAtDay = spawnAtNight;
			spawnData.m_minAltitude = cfg.RequiredAltitude.get().min;
			spawnData.m_maxAltitude = cfg.RequiredAltitude.get().max;
			val = spawnData;
			Forest forest = cfg.ForestSpawn.get();
			spawnAtNight = ((forest == Forest.Yes || forest == Forest.Both) ? true : false);
			val.m_inForest = spawnAtNight;
			val = spawnData;
			forest = cfg.ForestSpawn.get();
			spawnAtNight = (uint)(forest - 1) <= 1u;
			val.m_outsideForest = spawnAtNight;
			spawnData.m_minOceanDepth = cfg.RequiredOceanDepth.get().min;
			spawnData.m_maxOceanDepth = cfg.RequiredOceanDepth.get().max;
			spawnData.m_huntPlayer = cfg.AttackImmediately.get() == Toggle.On;
			spawnData.m_groundOffset = cfg.SpawnAltitude.get();
			spawnData.m_maxLevel = ((cfg.CanHaveStars.get() != Toggle.On) ? 1 : 3);
		}

		[HarmonyPriority(700)]
		internal static void AddToSpawnSystem(SpawnSystem __instance)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			SpawnSystemList val = __instance.m_spawnLists.First();
			foreach (SpawnData lastRegisteredSpawn in lastRegisteredSpawns)
			{
				val.m_spawners.Remove(lastRegisteredSpawn);
			}
			lastRegisteredSpawns.Clear();
			foreach (Creature registeredCreature in registeredCreatures)
			{
				SpawnData val2 = new SpawnData
				{
					m_name = ((Object)registeredCreature.Prefab).name,
					m_prefab = registeredCreature.Prefab
				};
				registeredCreature.updateSpawnData(val2);
				lastRegisteredSpawns.Add(val2);
				val.m_spawners.Add(val2);
			}
		}
	}
	internal static class PrefabManager
	{
		private struct BundleId
		{
			[UsedImplicitly]
			public string assetBundleFileName;

			[UsedImplicitly]
			public string folderName;
		}

		private static bool _initialized;

		private static readonly Dictionary<BundleId, AssetBundle> bundleCache;

		private static readonly List<GameObject> prefabs;

		static PrefabManager()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			_initialized = false;
			bundleCache = new Dictionary<BundleId, AssetBundle>();
			prefabs = new List<GameObject>();
			Harmony val = new Harmony("org.bepinex.helpers.CreatureManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "Patch_ZNetSceneAwake", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature.DropList), "AddDropsToCreature", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(SpawnSystem), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "AddToSpawnSystem", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(ObjectDB), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "UpdateCreatureAis", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Creature), "Patch_FejdStartup", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			if (!typeof(Biome).GetCustomAttributes(typeof(FlagsAttribute), inherit: false).Any())
			{
				val.Patch((MethodBase)AccessTools.Method(typeof(Biome).GetType(), "GetCustomAttributes", new Type[2]
				{
					typeof(Type),
					typeof(bool)
				}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(PrefabManager), "BiomeIsFlags", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void BiomeIsFlags(Type __instance, Type attributeType, ref object[] __result)
		{
			if (__instance == typeof(Biome) && attributeType == typeof(FlagsAttribute))
			{
				__result = new object[1]
				{
					new FlagsAttribute()
				};
			}
		}

		public static void Init()
		{
			if (!_initialized)
			{
				_initialized = true;
			}
		}

		public static AssetBundle RegisterAssetBundle(string assetBundleFileName, string folderName = "assets")
		{
			BundleId key = new BundleId
			{
				assetBundleFileName = assetBundleFileName,
				folderName = folderName
			};
			if (!bundleCache.TryGetValue(key, out AssetBundle value))
			{
				Dictionary<BundleId, AssetBundle> dictionary = bundleCache;
				AssetBundle? obj = ((IEnumerable<AssetBundle>)Resources.FindObjectsOfTypeAll<AssetBundle>()).FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle a) => ((Object)a).name == assetBundleFileName)) ?? AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetName().Name + "." + folderName + "." + assetBundleFileName));
				AssetBundle result = obj;
				dictionary[key] = obj;
				return result;
			}
			return value;
		}

		public static GameObject RegisterPrefab(AssetBundle assets, string prefabName)
		{
			GameObject val = assets.LoadAsset<GameObject>(prefabName);
			prefabs.Add(val);
			return val;
		}

		[HarmonyPriority(700)]
		private static void Patch_ZNetSceneAwake(ZNetScene __instance)
		{
			foreach (GameObject prefab in prefabs)
			{
				__instance.m_prefabs.Add(prefab);
			}
		}
	}
}
namespace Vapok.Common.Managers.Configuration
{
	public abstract class ConfigSyncBase
	{
		private static ConfigSyncBase? _instance;

		protected static ConfigFile? _config;

		private string _configurationFileName;

		public static ConfigEntry<bool>? ServerEnforced { get; private set; }

		public static ConfigEntry<LogLevels>? LogLevel { get; private set; }

		public static ConfigEntry<bool>? LoggingEnabled { get; private set; }

		protected ConfigSyncBase(IPluginInfo _mod, bool enableLockedConfigs = true)
		{
			//IL_0069: 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_007b: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_00ba: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			if (_instance == null)
			{
				_instance = this;
			}
			if (_config == null)
			{
				_config = _mod.Instance.Config;
			}
			_configurationFileName = _mod.PluginId + ".cfg";
			_config.SaveOnConfigSet = true;
			LoggingEnabled = _config.Bind<bool>("Log Output Configuration", "Logging Enabled", true, new ConfigDescription("Toggles Log Output", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			LogLevel = _config.Bind<LogLevels>("Log Output Configuration", "Log Level", LogLevels.Warning, new ConfigDescription("Minimum Log Level to Output", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdvanced = true
			} }));
			SetupWatcher(_config);
		}

		private void SetupWatcher(ConfigFile config)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, _configurationFileName);
			fileSystemWatcher.Changed += delegate
			{
				ReloadConfigOnChange(config);
			};
			fileSystemWatcher.Deleted += delegate
			{
				ReloadConfigOnChange(config);
			};
			fileSystemWatcher.Renamed += delegate
			{
				ReloadConfigOnChange(config);
			};
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReloadConfigOnChange(ConfigFile config)
		{
			try
			{
				config.Reload();
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Problem Reading Config [" + _configurationFileName + "]: " + ex.Message));
			}
		}

		public abstract void InitializeConfigurationSettings();

		public static void SyncedConfig<T>(string group, string configName, T value, ConfigDescription description, ref ConfigEntry<T> configEntry, bool synchronizedSetting = true)
		{
			if (_config != null)
			{
				AddConfig(RemoveInvalidCharacters(configName), RemoveInvalidCharacters(group), description, synchronizedSetting, value, ref configEntry);
			}
		}

		public static void UnsyncedConfig<T>(string group, string configName, T value, ConfigDescription description, ref ConfigEntry<T> configEntry)
		{
			if (_config != null)
			{
				AddConfig(RemoveInvalidCharacters(configName), RemoveInvalidCharacters(group), description, synced: false, value, ref configEntry);
			}
		}

		private static void AddConfig<T>(string key, string section, ConfigDescription description, bool synced, T value, ref ConfigEntry<T> configEntry)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			if (_config != null)
			{
				object? obj = (description.Tags ?? Array.Empty<object>()).FirstOrDefault((object t) => t is ConfigurationManagerAttributes);
				ConfigurationManagerAttributes val = (ConfigurationManagerAttributes)((obj is ConfigurationManagerAttributes) ? obj : null);
				if (val == null)
				{
					val = new ConfigurationManagerAttributes();
				}
				val.IsAdminOnly = synced;
				ConfigDescription val2 = new ConfigDescription(GetExtendedDescription(description.Description, synced), description.AcceptableValues, new object[1] { val });
				configEntry = _config.Bind<T>(section, key, value, val2);
			}
		}

		private static string GetExtendedDescription(string description, bool synchronizedSetting)
		{
			return description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]");
		}

		private static string RemoveInvalidCharacters(string sectionName)
		{
			List<char> list = new List<char>();
			list.Add('\n');
			list.Add('\t');
			list.Add('"');
			list.Add('\'');
			list.Add('[');
			list.Add(']');
			list.ForEach(delegate(char c)
			{
				sectionName = sectionName.Replace(c.ToString(), string.Empty);
			});
			return sectionName;
		}
	}
}
namespace Vapok.Common.Abstractions
{
	public interface ILogIt
	{
		void Debug(string message);

		void Info(string message);

		void Message(string message);

		void Warning(string message);

		void Error(string message);

		void Fatal(string message);
	}
	public interface IPluginInfo
	{
		string PluginId { get; }

		string DisplayName { get; }

		string Version { get; }

		BaseUnityPlugin Instance { get; }
	}
}
namespace APIManager
{
	internal static class Patcher
	{
		private class MonoAssemblyResolver : IAssemblyResolver, IDisposable
		{
			public AssemblyDefinition Resolve(AssemblyNameReference name)
			{
				return AssemblyDefinition.ReadAssembly(AppDomain.CurrentDomain.Load(name.FullName).Location);
			}

			public AssemblyDefinition Resolve(AssemblyNameReference name, ReaderParameters parameters)
			{
				return Resolve(name);
			}

			public void Dispose()
			{
			}
		}

		private class AssemblyLoadInterceptor
		{
			private static string? assemblyPath;

			private static MethodInfo TargetMethod()
			{
				return AccessTools.DeclaredMethod(typeof(Assembly), "Load", new Type[1] { typeof(byte[]) }, (Type[])null);
			}

			private static bool Prefix(ref byte[] __0, ref Assembly? __result)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				assemblyPath = null;
				if (modifyNextLoad)
				{
					modifyNextLoad = false;
					try
					{
						AssemblyDefinition val = AssemblyDefinition.ReadAssembly((Stream)new MemoryStream(__0), new ReaderParameters
						{
							AssemblyResolver = (IAssemblyResolver)(object)new MonoAssemblyResolver()
						});
						try
						{
							((Dictionary<string, string>)typeof(EnvVars).Assembly.GetType("BepInEx.Preloader.RuntimeFixes.UnityPatches").GetProperty("AssemblyLocations").GetValue(null))[val.FullName] = currentAssemblyPath;
							FixupModuleReferences(val.MainModule);
							using MemoryStream memoryStream = new MemoryStream();
							val.Write((Stream)memoryStream);
							__0 = memoryStream.ToArray();
							string dumpedAssembliesPath = Patcher.dumpedAssembliesPath;
							char directorySeparatorChar = Path.DirectorySeparatorChar;
							string path = dumpedAssembliesPath + directorySeparatorChar + ((AssemblyNameReference)val.Name).Name + ".dll";
							if (loadDumpedAssemblies.Value || dumpAssemblies.Value)
							{
								File.WriteAllBytes(path, __0);
							}
							if (loadDumpedAssemblies.Value)
							{
								assemblyPath = path;
								__result = null;
								return false;
							}
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}
					catch (BadImageFormatException)
					{
					}
					catch (Exception ex2)
					{
						Debug.LogError((object)("Failed patching ... " + ex2));
					}
				}
				return true;
			}

			private static void Postfix(ref Assembly? __result)
			{
				if (assemblyPath != null && __result == null)
				{
					__result = Assembly.LoadFrom(assemblyPath);
				}
			}
		}

		private static PluginInfo? lastPluginInfo;

		private static bool modifyNextLoad = false;

		private static string modGUID = null;

		private static HashSet<string> redirectedNamespaces = null;

		private static readonly Assembly patchingAssembly = Assembly.GetExecutingAssembly();

		private static string currentAssemblyPath = null;

		private static readonly ConfigEntry<bool> dumpAssemblies = (ConfigEntry<bool>)AccessTools.DeclaredField(typeof(AssemblyPatcher), "ConfigDumpAssemblies").GetValue(null);

		private static readonly ConfigEntry<bool> loadDumpedAssemblies = (ConfigEntry<bool>)AccessTools.DeclaredField(typeof(AssemblyPatcher), "ConfigLoadDumpedAssemblies").GetValue(null);

		private static readonly string dumpedAssembliesPath = (string)AccessTools.DeclaredField(typeof(AssemblyPatcher), "DumpedAssembliesPath").GetValue(null);

		private static void GrabPluginInfo(PluginInfo __instance)
		{
			lastPluginInfo = __instance;
		}

		[HarmonyPriority(700)]
		private static void CheckAssemblyLoadFile(string __0)
		{
			PluginInfo? obj = lastPluginInfo;
			if (__0 == ((obj != null) ? obj.Location : null) && lastPluginInfo.Dependencies.Any((BepInDependency d) => d.DependencyGUID == modGUID))
			{
				modifyNextLoad = true;
				currentAssemblyPath = __0;
			}
			lastPluginInfo = null;
		}

		[HarmonyPriority(500)]
		private static bool InterceptAssemblyLoadFile(string __0, ref Assembly? __result)
		{
			if (modifyNextLoad && (object)__result == null)
			{
				__result = Assembly.Load(File.ReadAllBytes(__0));
				return false;
			}
			return true;
		}

		private static void FixupModuleReferences(ModuleDefinition module)
		{
			foreach (TypeDefinition type3 in module.GetTypes())
			{
				if ((object)patchingAssembly.GetType(((MemberReference)type3).FullName) == null)
				{
					Dispatch(type3);
				}
			}
			static bool AreSame(TypeReference a, TypeReference b)
			{
				return (bool)typeof(MetadataResolver).Assembly.GetType("Mono.Cecil.MetadataResolver").GetMethod("AreSame", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[2]
				{
					typeof(TypeReference),
					typeof(TypeReference)
				}, null).Invoke(null, new object[2] { a, b });
			}
			void Dispatch(TypeDefinition type)
			{
				if (type.BaseType != null && (object)type.BaseType.Scope == module && redirectedNamespaces.Contains(baseDeclaringType(type.BaseType).Namespace))
				{
					Type type2 = patchingAssembly.GetType(((MemberReference)type.BaseType).FullName);
					if ((object)type2 != null)
					{
						type.BaseType = module.ImportReference(type2);
					}
				}
				DispatchGenericParameters((IGenericParameterProvider)(object)type, ((MemberReference)type).FullName);
				DispatchInterfaces(type, ((MemberReference)type).FullName);
				DispatchAttributes((ICustomAttributeProvider)(object)type, ((MemberReference)type).FullName);
				DispatchFields(type, ((MemberReference)type).FullName);
				DispatchProperties(type, ((MemberReference)type).FullName);
				DispatchEvents(type, ((MemberReference)type).FullName);
				DispatchMethods(type);
			}
			void DispatchAttributes(ICustomAttributeProvider provider, string referencingEntityName)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: 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_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: 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_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				if (!provider.HasCustomAttributes)
				{
					return;
				}
				Enumerator<CustomAttribute> enumerator2 = provider.CustomAttributes.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						CustomAttribute current2 = enumerator2.Current;
						MethodReference val = importMethodReference(current2.Constructor);
						if (val != null)
						{
							current2.Constructor = val;
						}
						else
						{
							VisitMethod(current2.Constructor, referencingEntityName);
						}
						for (int i = 0; i < current2.ConstructorArguments.Count; i++)
						{
							CustomAttributeArgument val2 = current2.ConstructorArguments[i];
							current2.ConstructorArguments[i] = new CustomAttributeArgument(VisitType(((CustomAttributeArgument)(ref val2)).Type, referencingEntityName), ((CustomAttributeArgument)(ref val2)).Value);
						}
						CustomAttributeArgument argument;
						for (int j = 0; j < current2.Properties.Count; j++)
						{
							CustomAttributeNamedArgument val3 = current2.Properties[j];
							Collection<CustomAttributeNamedArgument> properties = current2.Properties;
							int num = j;
							string name = ((CustomAttributeNamedArgument)(ref val3)).Name;
							argument = ((CustomAttributeNamedArgument)(ref val3)).Argument;
							TypeReference? obj = VisitType(((CustomAttributeArgument)(ref argument)).Type, referencingEntityName);
							argument = ((CustomAttributeNamedArgument)(ref val3)).Argument;
							properties[num] = new CustomAttributeNamedArgument(name, new CustomAttributeArgument(obj, ((CustomAttributeArgument)(ref argument)).Value));
						}
						for (int k = 0; k < current2.Fields.Count; k++)
						{
							CustomAttributeNamedArgument val4 = current2.Fields[k];
							Collection<CustomAttributeNamedArgument> fields = current2.Fields;
							int num2 = k;
							string name2 = ((CustomAttributeNamedArgument)(ref val4)).Name;
							argument = ((CustomAttributeNamedArgument)(ref val4)).Argument;
							TypeReference? obj2 = VisitType(((CustomAttributeArgument)(ref argument)).Type, referencingEntityName);
							argument = ((CustomAttributeNamedArgument)(ref val4)).Argument;
							fields[num2] = new CustomAttributeNamedArgument(name2, new CustomAttributeArgument(obj2, ((CustomAttributeArgument)(ref argument)).Value));
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchEvents(TypeDefinition type, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<EventDefinition> enumerator2 = type.Events.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						EventDefinition current2 = enumerator2.Current;
						((EventReference)current2).EventType = VisitType(((EventReference)current2).EventType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current2, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchFields(TypeDefinition type, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<FieldDefinition> enumerator2 = type.Fields.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						FieldDefinition current2 = enumerator2.Current;
						((FieldReference)current2).FieldType = VisitType(((FieldReference)current2).FieldType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current2, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchGenericArguments(IGenericInstance genericInstance, string referencingEntityName)
			{
				for (int i = 0; i < genericInstance.GenericArguments.Count; i++)
				{
					genericInstance.GenericArguments[i] = VisitType(genericInstance.GenericArguments[i], referencingEntityName);
				}
			}
			void DispatchGenericParameters(IGenericParameterProvider provider, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<GenericParameter> enumerator2 = provider.GenericParameters.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						GenericParameter current2 = enumerator2.Current;
						DispatchAttributes((ICustomAttributeProvider)(object)current2, referencingEntityName);
						for (int i = 0; i < current2.Constraints.Count; i++)
						{
							current2.Constraints[i] = VisitType(current2.Constraints[i], referencingEntityName);
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchInterfaces(TypeDefinition type, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<InterfaceImplementation> enumerator2 = type.Interfaces.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						InterfaceImplementation current2 = enumerator2.Current;
						current2.InterfaceType = VisitType(current2.InterfaceType, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchMethod(MethodDefinition method)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				((MethodReference)method).ReturnType = VisitType(((MethodReference)method).ReturnType, ((MemberReference)method).FullName);
				DispatchAttributes((ICustomAttributeProvider)(object)((MethodReference)method).MethodReturnType, ((MemberReference)method).FullName);
				DispatchGenericParameters((IGenericParameterProvider)(object)method, ((MemberReference)method).FullName);
				Enumerator<ParameterDefinition> enumerator2 = ((MethodReference)method).Parameters.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						ParameterDefinition current2 = enumerator2.Current;
						((ParameterReference)current2).ParameterType = VisitType(((ParameterReference)current2).ParameterType, ((MemberReference)method).FullName);
						DispatchAttributes((ICustomAttributeProvider)(object)current2, ((MemberReference)method).FullName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
				for (int i = 0; i < method.Overrides.Count; i++)
				{
					MethodReference val = importMethodReference(method.Overrides[i]);
					if (val != null)
					{
						method.Overrides[i] = val;
					}
					else
					{
						VisitMethod(method.Overrides[i], ((MemberReference)method).FullName);
					}
				}
				if (method.HasBody)
				{
					DispatchMethodBody(method.Body);
				}
			}
			void DispatchMethodBody(MethodBody body)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<VariableDefinition> enumerator2 = body.Variables.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						VariableDefinition current2 = enumerator2.Current;
						((VariableReference)current2).VariableType = VisitType(((VariableReference)current2).VariableType, ((MemberReference)body.Method).FullName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
				Enumerator<Instruction> enumerator3 = body.Instructions.GetEnumerator();
				try
				{
					while (enumerator3.MoveNext())
					{
						Instruction current3 = enumerator3.Current;
						object operand = current3.Operand;
						FieldReference val = (FieldReference)((operand is FieldReference) ? operand : null);
						if (val == null)
						{
							MethodReference val2 = (MethodReference)((operand is MethodReference) ? operand : null);
							if (val2 == null)
							{
								TypeReference val3 = (TypeReference)((operand is TypeReference) ? operand : null);
								if (val3 != null)
								{
									current3.Operand = VisitType(val3, ((MemberReference)body.Method).FullName);
								}
							}
							else
							{
								MethodReference val4 = importMethodReference(val2);
								if (val4 != null)
								{
									current3.Operand = val4;
								}
								else
								{
									VisitMethod(val2, ((MemberReference)body.Method).FullName);
								}
							}
						}
						else
						{
							FieldReference val5 = importFieldReference(val);
							if (val5 != null)
							{
								current3.Operand = val5;
							}
							else
							{
								VisitField(val, ((MemberReference)body.Method).FullName);
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchMethods(TypeDefinition type)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<MethodDefinition> enumerator2 = type.Methods.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						MethodDefinition current2 = enumerator2.Current;
						DispatchMethod(current2);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			void DispatchProperties(TypeDefinition type, string referencingEntityName)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Enumerator<PropertyDefinition> enumerator2 = type.Properties.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						PropertyDefinition current2 = enumerator2.Current;
						((PropertyReference)current2).PropertyType = VisitType(((PropertyReference)current2).PropertyType, referencingEntityName);
						DispatchAttributes((ICustomAttributeProvider)(object)current2, referencingEntityName);
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			TypeReference FixupType(TypeReference type)
			{
				if ((object)type.Scope == module && redirectedNamespaces.Contains(baseDeclaringType(type).Namespace))
				{
					if (type.IsNested)
					{
						return FixupType(((MemberReference)type).DeclaringType);
					}
					Type type2 = patchingAssembly.GetType(((MemberReference)type).FullName);
					if ((object)type2 != null)
					{
						return module.ImportReference(type2);
					}
				}
				return type;
			}
			void VisitField(FieldReference? field, string referencingEntityName)
			{
				if (field != null)
				{
					field.FieldType = VisitType(field.FieldType, referencingEntityName);
					if (!(field is FieldDefinition))
					{
						((MemberReference)field).DeclaringType = VisitType(((MemberReference)field).DeclaringType, referencingEntityName);
					}
				}
			}
			void VisitMethod(MethodReference? method, string referencingEntityName)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				if (method != null)
				{
					GenericInstanceMethod val = (GenericInstanceMethod)(object)((method is GenericInstanceMethod) ? method : null);
					if (val != null)
					{
						DispatchGenericArguments((IGenericInstance)(object)val, referencingEntityName);
					}
					method.ReturnType = VisitType(method.ReturnType, referencingEntityName);
					Enumerator<ParameterDefinition> enumerator2 = method.Parameters.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							ParameterDefinition current2 = enumerator2.Current;
							((ParameterReference)current2).ParameterType = VisitType(((ParameterReference)current2).ParameterType, referencingEntityName);
						}
					}
					finally
					{
						((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
					if (!(method is MethodSpecification))
					{
						((MemberReference)method).DeclaringType = VisitType(((MemberReference)method).DeclaringType, referencingEntityName);
					}
				}
			}
			TypeReference? VisitType(TypeReference? type, string referencingEntityName)
			{
				if (type == null)
				{
					return type;
				}
				if (type.GetElementType().IsGenericParameter)
				{
					return type;
				}
				GenericInstanceType val = (GenericInstanceType)(object)((type is GenericInstanceType) ? type : null);
				if (val != null)
				{
					DispatchGenericArguments((IGenericInstance)(object)val, referencingEntityName);
				}
				return FixupType(type);
			}
			static TypeReference baseDeclaringType(TypeReference type)
			{
				while (((MemberReference)type).DeclaringType != null)
				{
					type = ((MemberReference)type).DeclaringType;
				}
				return type;
			}
			FieldReference? importFieldReference(FieldReference field)
			{
				if ((object)((MemberReference)field).DeclaringType.Scope == module && redirectedNamespaces.Contains(baseDeclaringType(((MemberReference)field).DeclaringType).Namespace))
				{
					FieldInfo fieldInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)field).DeclaringType).FullName)?.GetField(((MemberReference)field).Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if ((object)fieldInfo != null)
					{
						return module.ImportReference(fieldInfo);
					}
				}
				return null;
			}
			MethodReference? importMethodReference(MethodReference method)
			{
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Expected O, but got Unknown
				if ((object)((MemberReference)method).DeclaringType.Scope == module && redirectedNamespaces.Contains(baseDeclaringType(((MemberReference)method).DeclaringType).Namespace))
				{
					if (((MemberReference)method).Name == ".cctor")
					{
						ConstructorInfo[] array = patchingAssembly.GetType(((MemberReference)((MemberReference)method).DeclaringType).FullName)?.GetConstructors(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						if (array != null && array.Length == 1)
						{
							return module.ImportReference((MethodBase)array[0]);
						}
					}
					else if (((MemberReference)method).Name == ".ctor")
					{
						ConstructorInfo constructorInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)method).DeclaringType).FullName)?.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(CompareMethods);
						if ((object)constructorInfo != null)
						{
							return module.ImportReference((MethodBase)constructorInfo);
						}
					}
					else
					{
						MethodInfo methodInfo = patchingAssembly.GetType(((MemberReference)((MemberReference)method).DeclaringType).FullName)?.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo m)
						{
							if (m.Name != ((MemberReference)method).Name)
							{
								return false;
							}
							return (((MemberReference)method.ReturnType).ContainsGenericParameter == m.ReturnType.IsGenericParameter || AreSame(method.ReturnType, module.ImportReference(m.ReturnType))) && CompareMethods(m);
						});
						if ((object)methodInfo != null)
						{
							MethodReference val = module.ImportReference((MethodBase)methodInfo);
							MethodReference obj = method;
							GenericInstanceMethod val2 = (GenericInstanceMethod)(object)((obj is GenericInstanceMethod) ? obj : null);
							if (val2 != null)
							{
								GenericInstanceMethod val3 = new GenericInstanceMethod(val);
								for (int num = 0; num < val2.GenericArguments.Count; num++)
								{
									val2.GenericArguments[num] = VisitType(val2.GenericArguments[num], ((MemberReference)method).FullName);
									val3.GenericArguments.Add(val2.GenericArguments[num]);
								}
								val = (MethodReference)(object)val3;
							}
							return val;
						}
					}
				}
				return null;
				bool CompareMethods(MethodBase m)
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (method.IsGenericInstance != m.IsGenericMethodDefinition || parameters.Length != 0 != method.HasParameters)
					{
						return false;
					}
					if (method.HasParameters)
					{
						if (method.Parameters.Count != parameters.Length)
						{
							return false;
						}
						for (int i = 0; i < method.Parameters.Count; i++)
						{
							if (parameters[i].ParameterType.IsGenericParameter ? (!((ParameterReference)method.Parameters[i]).ParameterType.IsGenericParameter) : (!AreSame(((ParameterReference)method.Parameters[i]).ParameterType, module.ImportReference(parameters[i].ParameterType))))
							{
								return false;
							}
						}
					}
					return true;
				}
			}
		}

		public static void Patch(IEnumerable<string>? extraNamespaces = null)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			Harmony val = new Harmony("org.bepinex.plugins.APIManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(PluginInfo), "ToString", (Type[])null, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "GrabPluginInfo", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Assembly), "LoadFile", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "InterceptAssemblyLoadFile", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Assembly), "LoadFile", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Patcher), "CheckAssemblyLoadFile", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			new PatchClassProcessor(val, typeof(AssemblyLoadInterceptor), true).Patch();
			IEnumerable<TypeInfo> source;
			try
			{
				source = patchingAssembly.DefinedTypes.ToList();
			}
			catch (ReflectionTypeLoadException ex)
			{
				source = from t in ex.Types
					where t != null
					select t.GetTypeInfo();
			}
			BaseUnityPlugin val2 = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
			redirectedNamespaces = new HashSet<string>(extraNamespaces ?? Array.Empty<string>()) { ((object)val2).GetType().Namespace };
			modGUID = val2.Info.Metadata.GUID;
		}
	}
}