using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.UIElements;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("ItemAPI")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ItemAPI")]
[assembly: AssemblyTitle("ItemAPI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ItemAPI
{
	[BepInPlugin("com.mattcy.itemapi", "ItemAPI", "1.0.0")]
	public class ItemAPIPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		private static ItemAPIPlugin _instance;

		private void Awake()
		{
			_instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			ItemAPI.Init(((BaseUnityPlugin)this).Logger);
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		private void Update()
		{
			ItemAPI.OnUpdate();
		}
	}
	public class ItemAPI
	{
		public enum RoomsToSpawn
		{
			ALL,
			Kitchen,
			LivingRoom,
			DiningRoom,
			Bedroom,
			Bathroom,
			Sauna,
			DefaultRoom,
			ArtRoom,
			KidsRoom,
			HallwayRoom
		}

		private class PlayerState
		{
			public readonly List<int> InHotbar = new List<int>();

			public readonly Dictionary<int, float> TrackedItemDurability = new Dictionary<int, float>();

			public float LeftClickHoldTimer = 0f;

			public bool HasSentLeftHoldTrue = false;
		}

		[HarmonyPatch(typeof(NetworkManager), "StartHost")]
		internal static class NetworkManagerInitializationPatch
		{
			[CompilerGenerated]
			private static class <>O
			{
				public static HandleNamedMessageDelegate <0>__ReceiveDurabilityRequestOnServer;

				public static HandleNamedMessageDelegate <1>__ReceiveSpawnRequest;

				public static HandleNamedMessageDelegate <2>__ReceiveInventoryItemRequest;
			}

			private static void Postfix(NetworkManager __instance)
			{
				//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_005e: Expected O, but got Unknown
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: 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_00b6: Expected O, but got Unknown
				if (!((Object)(object)__instance == (Object)null) && __instance.CustomMessagingManager != null && (__instance.IsServer || __instance.IsHost))
				{
					CustomMessagingManager customMessagingManager = __instance.CustomMessagingManager;
					object obj = <>O.<0>__ReceiveDurabilityRequestOnServer;
					if (obj == null)
					{
						HandleNamedMessageDelegate val = ReceiveDurabilityRequestOnServer;
						<>O.<0>__ReceiveDurabilityRequestOnServer = val;
						obj = (object)val;
					}
					customMessagingManager.RegisterNamedMessageHandler("RequestConsumeDurability", (HandleNamedMessageDelegate)obj);
					CustomMessagingManager customMessagingManager2 = __instance.CustomMessagingManager;
					object obj2 = <>O.<1>__ReceiveSpawnRequest;
					if (obj2 == null)
					{
						HandleNamedMessageDelegate val2 = ReceiveSpawnRequest;
						<>O.<1>__ReceiveSpawnRequest = val2;
						obj2 = (object)val2;
					}
					customMessagingManager2.RegisterNamedMessageHandler("ModdedRequestItemSpawn", (HandleNamedMessageDelegate)obj2);
					CustomMessagingManager customMessagingManager3 = __instance.CustomMessagingManager;
					object obj3 = <>O.<2>__ReceiveInventoryItemRequest;
					if (obj3 == null)
					{
						HandleNamedMessageDelegate val3 = ReceiveInventoryItemRequest;
						<>O.<2>__ReceiveInventoryItemRequest = val3;
						obj3 = (object)val3;
					}
					customMessagingManager3.RegisterNamedMessageHandler("ModdedRequestInventoryItem", (HandleNamedMessageDelegate)obj3);
				}
			}
		}

		public static class NetworkSpawner
		{
			public unsafe static void RequestSpawn(string itemName, Vector3 position, string? uniqueId)
			{
				//IL_0044: 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)
				lastUniqueId = uniqueId ?? "";
				if ((Object)(object)NetworkManager.Singleton == (Object)null)
				{
					return;
				}
				if (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost)
				{
					ExecuteSpawn(itemName, position, uniqueId);
					return;
				}
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(128, (Allocator)2, -1);
				try
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(itemName, false);
					((FastBufferWriter)(ref val)).WriteValueSafe(ref position);
					((FastBufferWriter)(ref val)).WriteValueSafe(uniqueId ?? "", false);
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("ModdedRequestItemSpawn", 0uL, val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
				}
			}

			public static void ExecuteSpawn(string itemName, Vector3 position, string UniqueId)
			{
				//IL_00db: 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_00f2: 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)
				NetworkManager singleton = NetworkManager.Singleton;
				object obj;
				if (singleton == null)
				{
					obj = null;
				}
				else
				{
					NetworkConfig networkConfig = singleton.NetworkConfig;
					if (networkConfig == null)
					{
						obj = null;
					}
					else
					{
						NetworkPrefabs prefabs = networkConfig.Prefabs;
						obj = ((prefabs != null) ? prefabs.Prefabs : null);
					}
				}
				if (obj == null)
				{
					return;
				}
				GameObject val = ((IEnumerable<NetworkPrefab>)NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs).FirstOrDefault((Func<NetworkPrefab, bool>)((NetworkPrefab p) => (Object)(object)p.Prefab != (Object)null && ((Object)p.Prefab).name.Equals(itemName, StringComparison.OrdinalIgnoreCase)))?.Prefab;
				if ((Object)(object)val == (Object)null)
				{
					try
					{
						GetAllItems().SpawnItemInstance(itemName, position);
						return;
					}
					catch
					{
						try
						{
							AiDirector val2 = Object.FindFirstObjectByType<AiDirector>();
							if ((Object)(object)val2 == (Object)null)
							{
								return;
							}
							PlayerNetworking localPlayer = GetLocalPlayer();
							if (!((Object)(object)localPlayer == (Object)null))
							{
								val2.SpawnEnemy(itemName, position);
								return;
							}
						}
						catch
						{
							return;
						}
					}
				}
				GameObject val3 = Object.Instantiate<GameObject>(val, position, Quaternion.identity);
				NetworkObject component = val3.GetComponent<NetworkObject>();
				if ((Object)(object)component != (Object)null)
				{
					component.Spawn(false);
					onItemSpawnedViaRequest(val3, UniqueId);
				}
				else
				{
					Object.Destroy((Object)(object)val3);
				}
			}
		}

		[HarmonyPatch]
		internal static class OnSpawnedPrivatePatch
		{
			[HarmonyTargetMethod]
			private static MethodBase TargetMethod()
			{
				Type nestedType = typeof(AiDirector).GetNestedType("RuntimeEntityCollection", BindingFlags.Public | BindingFlags.NonPublic);
				if (nestedType == null)
				{
					return null;
				}
				return nestedType.GetMethod("OnSpawned", BindingFlags.Instance | BindingFlags.NonPublic);
			}

			[HarmonyPostfix]
			private static void Postfix(object __instance, object instance)
			{
				if (instance == null)
				{
					return;
				}
				PropertyInfo property = instance.GetType().GetProperty("gameObject", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null)
				{
					object? value = property.GetValue(instance);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					if ((Object)(object)val != (Object)null)
					{
						onEnnemySpawnedViaRequest(val, lastUniqueId);
					}
				}
			}
		}

		[HarmonyPatch(typeof(NetworkBehaviour), "OnNetworkSpawn")]
		internal static class PlayerNetworkingSpawnPatch
		{
			private static void Postfix(NetworkBehaviour __instance)
			{
				PlayerNetworking val = (PlayerNetworking)(object)((__instance is PlayerNetworking) ? __instance : null);
				if (!((Object)(object)val == (Object)null))
				{
					playersById[((NetworkBehaviour)val).OwnerClientId] = val;
					if (((NetworkBehaviour)val).IsLocalPlayer)
					{
						localPlayer = val;
					}
				}
			}
		}

		[HarmonyPatch(typeof(NetworkBehaviour), "OnNetworkDespawn")]
		internal static class PlayerNetworkingDespawnPatch
		{
			private static void Postfix(NetworkBehaviour __instance)
			{
				PlayerNetworking val = (PlayerNetworking)(object)((__instance is PlayerNetworking) ? __instance : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				ulong ownerClientId = ((NetworkBehaviour)val).OwnerClientId;
				playersById.Remove(ownerClientId);
				itemsEquipped.Remove(ownerClientId);
				slotItemName.Remove(ownerClientId);
				if (_slotVisual.TryGetValue(ownerClientId, out var value))
				{
					for (int i = 0; i < value.Length; i++)
					{
						if ((Object)(object)value[i] != (Object)null)
						{
							Object.Destroy((Object)(object)value[i]);
						}
					}
					_slotVisual.Remove(ownerClientId);
				}
				if ((Object)(object)localPlayer == (Object)(object)val)
				{
					localPlayer = null;
				}
			}
		}

		[HarmonyPatch]
		internal static class EquipmentSlotTrackingPatch
		{
			[HarmonyTargetMethod]
			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(typeof(EquipmentController), "<UpdateEquipmentState>g__UpdateHandlerState|32_0", (Type[])null, (Type[])null);
			}

			[HarmonyPrefix]
			private static void Prefix(EquipmentController __instance, int inventorySlotIndex, Action<string> activationFunction)
			{
				//IL_0045: 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)
				int slotType = GetSlotType(activationFunction);
				if (slotType == -1)
				{
					return;
				}
				PlayerNetworking component = ((Component)__instance).GetComponent<PlayerNetworking>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				string newItemName = null;
				if (inventorySlotIndex != -1)
				{
					InventoryItem itemInSlot = ((InventoryBase)component.Inventory).GetItemInSlot(inventorySlotIndex);
					if (((InventoryItem)(ref itemInSlot)).IsValidItem && (Object)(object)AllItems != (Object)null && ((InventoryItem)(ref itemInSlot)).ItemIndex >= 0 && ((InventoryItem)(ref itemInSlot)).ItemIndex < AllItems.items.Length)
					{
						ItemData obj = AllItems.items[((InventoryItem)(ref itemInSlot)).ItemIndex];
						newItemName = ((obj != null) ? ((Object)obj).name : null);
					}
				}
				UpdateSlotTracking(component, slotType, newItemName);
			}

			private static int GetSlotType(Action<string> activationFunction)
			{
				return activationFunction.Method.Name switch
				{
					"SetHandEquipment" => 0, 
					"SetWearedEquipment" => 1, 
					"SetOtherWearedEquipment" => 2, 
					_ => -1, 
				};
			}

			private static void UpdateSlotTracking(PlayerNetworking player, int slotType, string newItemName)
			{
				ulong ownerClientId = ((NetworkBehaviour)player).OwnerClientId;
				if (!slotItemName.TryGetValue(ownerClientId, out var value))
				{
					value = new string[3];
					slotItemName[ownerClientId] = value;
				}
				string text = value[slotType];
				if (text == newItemName)
				{
					return;
				}
				if (!_slotVisual.TryGetValue(ownerClientId, out var value2))
				{
					value2 = (GameObject[])(object)new GameObject[3];
					_slotVisual[ownerClientId] = value2;
				}
				if (!itemsEquipped.TryGetValue(ownerClientId, out var value3))
				{
					value3 = new HashSet<string>();
					itemsEquipped[ownerClientId] = value3;
				}
				if (!string.IsNullOrEmpty(text))
				{
					value3.Remove(text);
					if ((Object)(object)value2[slotType] != (Object)null)
					{
						Object.Destroy((Object)(object)value2[slotType]);
						value2[slotType] = null;
					}
					if (RegisteredEquipment.TryGetValue(text, out var value4))
					{
						value4.OnUnequip(player);
					}
				}
				if (!string.IsNullOrEmpty(newItemName))
				{
					value3.Add(newItemName);
					if (RegisteredEquipment.TryGetValue(newItemName, out var value5))
					{
						GameObject val = null;
						if ((Object)(object)value5.Prefab != (Object)null)
						{
							val = Object.Instantiate<GameObject>(value5.Prefab, ((Component)player).transform, false);
							((Object)val).name = $"CustomItemVisual_{ownerClientId}_{slotType}";
							value2[slotType] = val;
						}
						value5.OnEquip(val ?? ((Component)player).gameObject, player);
					}
				}
				value[slotType] = newItemName;
			}
		}

		[HarmonyPatch(typeof(InventoryBase), "OnNetworkSpawn")]
		internal static class InventoryOnNetworkSpawnPatch
		{
			private static void Postfix(InventoryBase __instance)
			{
				AllItems = __instance.BoundItems;
				RegisterItems(AllItems);
				RebuildItemNameIndex();
			}
		}

		[HarmonyPatch(typeof(GnomiumDeposit), "OnNetworkSpawn")]
		internal static class GnomiumDepositOnNetworkSpawnPatch
		{
			private static void Postfix(GnomiumDeposit __instance)
			{
				((MonoBehaviour)__instance).StartCoroutine(RegisterRecipesCoroutine(__instance));
			}
		}

		[HarmonyPatch(typeof(ItemInstance), "OnNetworkSpawn")]
		internal static class ItemInstanceStartPatch
		{
			private static void Postfix(ItemInstance __instance)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance == (Object)null) && RegisteredEquipmentByIndex.TryGetValue(__instance.InstanceData.itemIndex, out var value))
				{
					ApplyWorldVisuals(__instance, value);
				}
			}
		}

		[HarmonyPatch(typeof(ItemInstance), "OnDropped")]
		internal static class ItemInstanceOnDroppedPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ItemInstance __instance, Vector3 velocity, InventoryBase droppedFrom)
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)droppedFrom == (Object)null)
				{
					return;
				}
				PlayerNetworking val = ((IEnumerable<PlayerNetworking>)playersById.Values).FirstOrDefault((Func<PlayerNetworking, bool>)((PlayerNetworking p) => (Object)(object)p.Inventory == (Object)(object)droppedFrom));
				if (!((Object)(object)val == (Object)null))
				{
					int itemIndex = __instance.InstanceData.itemIndex;
					if (RegisteredEquipmentByIndex.TryGetValue(itemIndex, out var value))
					{
						value.OnLost(val);
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemInstance), "OnInstanceDataChange")]
		internal static class ItemInstanceOnInstanceDataChangePatch
		{
			private static void Postfix(ItemInstance __instance)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance == (Object)null) && RegisteredEquipmentByIndex.TryGetValue(__instance.InstanceData.itemIndex, out var value))
				{
					ApplyWorldVisuals(__instance, value);
				}
			}
		}

		[HarmonyPatch(typeof(ItemInstance), "Interact")]
		internal static class ItemInstanceInteract
		{
			private static void Postfix(ItemInstance __instance, PlayerNetworking player)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				int itemIndex = __instance.InstanceData.itemIndex;
				if (RegisteredEquipmentByIndex.TryGetValue(itemIndex, out var value))
				{
					value.OnPickup(player);
				}
			}
		}

		[HarmonyPatch(typeof(CabinetDrawer), "OnCabinetOpen")]
		public static class Patch_CabinetDrawer_OnCabinetOpen
		{
			[HarmonyPrefix]
			public static void Prefix(CabinetDrawer __instance)
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
				if (!((NetworkBehaviour)__instance).IsServer)
				{
					return;
				}
				Traverse val = Traverse.Create((object)__instance);
				if (val.Field("wasInit").GetValue<bool>())
				{
					return;
				}
				RoomManager instance = RoomManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				Vector3 position = ((Component)__instance).transform.position;
				RoomTriggerListener val2 = default(RoomTriggerListener);
				if (!instance.TryGetRoomEnvelopingPoint(position, ref val2))
				{
					return;
				}
				string roomName = ((Object)((Component)val2).gameObject).name;
				SpawnRectangle[] value = val.Field("spawnAreas").GetValue<SpawnRectangle[]>();
				Random random = new Random();
				foreach (KeyValuePair<int, Equipment> item in RegisteredEquipmentByIndex)
				{
					Equipment value2 = item.Value;
					if (value2.SpawnChance.HasValue && value2.RoomsToSpawn != null && value2.RoomsToSpawn.Length != 0 && (value2.RoomsToSpawn.Contains(RoomsToSpawn.ALL) || value2.RoomsToSpawn.Any((RoomsToSpawn r) => roomName.Contains(r.ToString()))) && !(random.NextDouble() * 100.0 >= (double)value2.SpawnChance.Value))
					{
						Vector3 position2 = position;
						if (value != null && value.Length != 0)
						{
							SpawnRectangle val3 = value[random.Next(0, value.Length)];
							Vector3 randomPoint = val3.GetRandomPoint(random);
							position2 = ((Component)__instance).transform.TransformPoint(randomPoint);
						}
						RequestSpawn(value2.Name, position2, "Spawn" + value2.Name);
					}
				}
			}
		}

		public abstract class Equipment
		{
			public abstract string Name { get; }

			public abstract string Description { get; }

			public abstract EquipmentType ItemType { get; }

			public virtual Sprite Icon { get; set; }

			public virtual GameObject Prefab { get; set; }

			public virtual int? maxDurability { get; set; }

			public virtual int? maxStackSize { get; set; }

			public virtual Vector3? DroppedSize { get; set; } = null;

			public virtual Vector3? DroppedOffset { get; set; } = null;

			public virtual RoomsToSpawn[] RoomsToSpawn { get; set; } = null;

			public virtual float? SpawnChance { get; set; } = null;

			public int ItemIndex { get; internal set; }

			public virtual void OnEquip(GameObject visualObject, PlayerNetworking player)
			{
			}

			public virtual void OnUnequip(PlayerNetworking player)
			{
			}

			public virtual void OnLeftClick(bool isHolding, PlayerNetworking player)
			{
			}

			public virtual void OnLost(PlayerNetworking player)
			{
			}

			public virtual void OnBreak(PlayerNetworking player)
			{
			}

			public virtual void OnDurabilityChange(float Durability, PlayerNetworking player)
			{
			}

			public virtual void OnPickup(PlayerNetworking player)
			{
			}
		}

		public readonly struct CraftingCost
		{
			public readonly ResourceTypes? ResourceType;

			public readonly ItemData Item;

			public readonly int Amount;

			private CraftingCost(ResourceTypes? resourceType, ItemData item, int amount)
			{
				ResourceType = resourceType;
				Item = item;
				Amount = amount;
			}

			public static implicit operator CraftingCost((ResourceTypes Resource, int Amount) tuple)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return new CraftingCost(tuple.Resource, null, tuple.Amount);
			}

			public static implicit operator CraftingCost((ItemData Item, int Amount) tuple)
			{
				return new CraftingCost(null, tuple.Item, tuple.Amount);
			}
		}

		public abstract class CraftingRecipe
		{
			public virtual bool TakeItemFromInventory { get; set; }

			public virtual int? itemAmount { get; set; }

			public abstract Equipment Equipment { get; }

			public abstract CraftingCost[] CostTable { get; }
		}

		[HarmonyPatch(typeof(CraftinPanelControl), "UpdateCraftingPreview")]
		public static class CraftinPanelControlPatch
		{
			private static readonly FieldInfo craftingPanelDataField = AccessTools.Field(typeof(CraftinPanelControl), "craftingPanelData");

			private static readonly FieldInfo currentCraftingRecipeIndexField = AccessTools.Field(typeof(CraftinPanelControl), "currentCraftingRecipeIndex");

			private static readonly FieldInfo craftingCostElementParentField = AccessTools.Field(typeof(CraftinPanelControl), "craftingCostElementParent");

			private static readonly FieldInfo craftTargetInventoryField = AccessTools.Field(typeof(CraftinPanelControl), "craftTargetInventory");

			[HarmonyPostfix]
			public static void Postfix(CraftinPanelControl __instance)
			{
				//IL_0216: Unknown result type (might be due to invalid IL or missing references)
				object? value = craftingPanelDataField.GetValue(__instance);
				CraftingPanelData val = (CraftingPanelData)((value is CraftingPanelData) ? value : null);
				if (val == null)
				{
					return;
				}
				int num = (int)currentCraftingRecipeIndexField.GetValue(__instance);
				if (num < 0 || num >= val.equipmentCraftingRecipes.Count)
				{
					return;
				}
				Recipe val2 = val.equipmentCraftingRecipes[num];
				ItemData itemData = default(ItemData);
				ref ItemData reference = ref itemData;
				CraftableItemBase craftResult = val2.CraftResult;
				reference = (ItemData)(object)((craftResult is ItemData) ? craftResult : null);
				if ((Object)(object)itemData == (Object)null)
				{
					return;
				}
				CraftingRecipe craftingRecipe = RegisteredRecipesList.FirstOrDefault((CraftingRecipe r) => r.Equipment != null && r.Equipment.Name.Equals(((CraftableItemBase)itemData).Name, StringComparison.OrdinalIgnoreCase));
				if (craftingRecipe == null || !craftingRecipe.TakeItemFromInventory)
				{
					return;
				}
				object? value2 = craftingCostElementParentField.GetValue(__instance);
				VisualElement val3 = (VisualElement)((value2 is VisualElement) ? value2 : null);
				object? value3 = craftTargetInventoryField.GetValue(__instance);
				InventoryBase val4 = (InventoryBase)((value3 is InventoryBase) ? value3 : null);
				if (val3 == null || (Object)(object)val4 == (Object)null)
				{
					return;
				}
				HashSet<string> hashSet = new HashSet<string>(from c in craftingRecipe.CostTable
					where (Object)(object)c.Item != (Object)null && !IsResourceOrDepositableCost(c)
					select ((Object)c.Item).name, StringComparer.OrdinalIgnoreCase);
				for (int num2 = 0; num2 < val2.cost.Length; num2++)
				{
					if (val2.cost[num2].amount > 0 && !((Object)(object)val2.cost[num2].item == (Object)null) && hashSet.Contains(((Object)val2.cost[num2].item).name))
					{
						VisualElement obj = val3[num2];
						ItemDisplayView val5 = (ItemDisplayView)(object)((obj is ItemDisplayView) ? obj : null);
						if (val5 != null)
						{
							int itemIndex = GetItemIndex(((Object)val2.cost[num2].item).name);
							int num3 = CountItemInInventory(val4, itemIndex);
							((VisualElement)val5).style.display = StyleEnum<DisplayStyle>.op_Implicit((DisplayStyle)0);
							val5.Bind(val2.cost[num2].item, num3, val2.cost[num2].amount, "Items");
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerController), "UpdateInventoryCraftingContext")]
		public static class UpdateInventoryCraftingContextPatch
		{
			[HarmonyPostfix]
			public static void Postfix(CraftingPanelData craftingPanelData, Recipe recipe, InventoryBase resourceInventory, InventoryBase targetInventory)
			{
				ItemData itemData = default(ItemData);
				ref ItemData reference = ref itemData;
				CraftableItemBase craftResult = recipe.CraftResult;
				reference = (ItemData)(object)((craftResult is ItemData) ? craftResult : null);
				if ((Object)(object)itemData == (Object)null)
				{
					return;
				}
				CraftingRecipe craftingRecipe = RegisteredRecipesList.FirstOrDefault((CraftingRecipe r) => r.Equipment != null && r.Equipment.Name.Equals(((CraftableItemBase)itemData).Name, StringComparison.OrdinalIgnoreCase));
				if (craftingRecipe == null || !craftingRecipe.TakeItemFromInventory)
				{
					return;
				}
				bool flag = true;
				CraftingCost[] costTable = craftingRecipe.CostTable;
				for (int num = 0; num < costTable.Length; num++)
				{
					CraftingCost cost = costTable[num];
					int ownedCountForCost = GetOwnedCountForCost(cost, targetInventory, resourceInventory);
					if (ownedCountForCost < cost.Amount)
					{
						flag = false;
						break;
					}
				}
				if (flag && !targetInventory.CanFitItem(itemData))
				{
					craftingPanelData.canCraftCurrentItem = false;
					craftingPanelData.craftingInfo = "Inventory full";
				}
				else
				{
					craftingPanelData.canCraftCurrentItem = flag;
					craftingPanelData.craftingInfo = (flag ? "" : "Can't afford");
				}
			}
		}

		[HarmonyPatch(typeof(CraftingRecipes), "TryCraftItem")]
		public static class TryCraftItemPatch
		{
			[HarmonyPrefix]
			public static bool Prefix(Recipe recipe, InventoryBase craftedItemTargetInventory, InventoryBase resourceSourceInventory, HomeManager homeManager, ref bool craftEvenIfMissingResources, ref bool __result, out bool __state)
			{
				__state = false;
				if (craftEvenIfMissingResources)
				{
					return true;
				}
				ItemData itemData = default(ItemData);
				ref ItemData reference = ref itemData;
				CraftableItemBase craftResult = recipe.CraftResult;
				reference = (ItemData)(object)((craftResult is ItemData) ? craftResult : null);
				if ((Object)(object)itemData == (Object)null)
				{
					return true;
				}
				CraftingRecipe craftingRecipe = RegisteredRecipesList.FirstOrDefault((CraftingRecipe r) => r.Equipment != null && r.Equipment.Name.Equals(((CraftableItemBase)itemData).Name, StringComparison.OrdinalIgnoreCase));
				if (craftingRecipe == null || !craftingRecipe.TakeItemFromInventory)
				{
					return true;
				}
				bool flag = true;
				CraftingCost[] costTable = craftingRecipe.CostTable;
				for (int num = 0; num < costTable.Length; num++)
				{
					CraftingCost cost = costTable[num];
					int ownedCountForCost = GetOwnedCountForCost(cost, craftedItemTargetInventory, resourceSourceInventory);
					if (ownedCountForCost < cost.Amount)
					{
						flag = false;
						break;
					}
				}
				if (!flag)
				{
					__result = false;
					return false;
				}
				__state = true;
				craftEvenIfMissingResources = true;
				return true;
			}

			[HarmonyPostfix]
			public static void Postfix(Recipe recipe, InventoryBase craftedItemTargetInventory, InventoryBase resourceSourceInventory, HomeManager homeManager, bool craftEvenIfMissingResources, ref bool __result)
			{
				if (!__result)
				{
					return;
				}
				ItemData itemData = default(ItemData);
				ref ItemData reference = ref itemData;
				CraftableItemBase craftResult = recipe.CraftResult;
				reference = (ItemData)(object)((craftResult is ItemData) ? craftResult : null);
				if ((Object)(object)itemData == (Object)null)
				{
					return;
				}
				CraftingRecipe craftingRecipe = RegisteredRecipesList.FirstOrDefault((CraftingRecipe r) => r.Equipment != null && r.Equipment.Name.Equals(((CraftableItemBase)itemData).Name, StringComparison.OrdinalIgnoreCase));
				if (craftingRecipe == null)
				{
					return;
				}
				CraftingCost[] costTable = craftingRecipe.CostTable;
				for (int num = 0; num < costTable.Length; num++)
				{
					CraftingCost cost = costTable[num];
					if (IsResourceOrDepositableCost(cost) || (Object)(object)cost.Item == (Object)null)
					{
						continue;
					}
					string name = ((Object)cost.Item).name;
					if (!craftedItemTargetInventory.TryRemoveItem(name, cost.Amount))
					{
						PlayerNetworking localPlayer = GetLocalPlayer();
						if (localPlayer != null)
						{
							((InventoryBase)localPlayer.Inventory).TryRemoveItem(name, cost.Amount);
						}
					}
				}
				if (craftingRecipe.itemAmount.HasValue)
				{
					int num2 = craftingRecipe.itemAmount.Value - 1;
					if (num2 > 0)
					{
						craftedItemTargetInventory.TryAddItem(craftingRecipe.Equipment.Name, num2);
					}
				}
			}
		}

		private static ManualLogSource logger;

		public static Dictionary<string, Equipment> RegisteredEquipment = new Dictionary<string, Equipment>();

		public static Dictionary<int, Equipment> RegisteredEquipmentByIndex = new Dictionary<int, Equipment>();

		private static List<Assembly> registeredAssemblies = new List<Assembly>();

		private static AllItems AllItems;

		private static bool isInitialized = false;

		private static Dictionary<string, Sprite> _spriteCache = new Dictionary<string, Sprite>();

		private static Dictionary<string, AssetBundle> _bundleCache = new Dictionary<string, AssetBundle>();

		private static readonly FieldInfo RecipeItemField = AccessTools.Field(typeof(Recipe), "item");

		private static string VisualRootName = "CustomItemWorldVisual";

		private static bool itemRegistered = false;

		private static readonly Dictionary<ulong, PlayerNetworking> playersById = new Dictionary<ulong, PlayerNetworking>();

		private static PlayerNetworking localPlayer;

		private static readonly Dictionary<ulong, string[]> slotItemName = new Dictionary<ulong, string[]>();

		private static readonly Dictionary<ulong, GameObject[]> _slotVisual = new Dictionary<ulong, GameObject[]>();

		private static readonly Dictionary<ulong, HashSet<string>> itemsEquipped = new Dictionary<ulong, HashSet<string>>();

		private static readonly Dictionary<string, int> itemNameToIndex = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		public static Action<GameObject, string?> onItemSpawnedViaRequest = delegate
		{
		};

		public static Action<GameObject, string?> onEnnemySpawnedViaRequest = delegate
		{
		};

		private static readonly PlayerState playerState = new PlayerState();

		private static string lastUniqueId = "";

		private static readonly List<CraftingRecipe> RegisteredRecipesList = new List<CraftingRecipe>();

		public static void Init(ManualLogSource source)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			logger = source;
			Assembly callingAssembly = Assembly.GetCallingAssembly();
			if (!registeredAssemblies.Contains(callingAssembly))
			{
				registeredAssemblies.Add(callingAssembly);
			}
			if (!isInitialized)
			{
				isInitialized = true;
				new Harmony("ItemAPI_Core").PatchAll(typeof(ItemAPI).Assembly);
				AsyncOperationHandle<LocalizationSettings> initializationOperation = LocalizationSettings.InitializationOperation;
				initializationOperation.Completed += OnLocalizationInitialized;
				LogInfo("ItemAPI Initialized.");
			}
		}

		public static void ReceiveSpawnRequest(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsServer)
			{
				string itemName = default(string);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref itemName, false);
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				string uniqueId = default(string);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref uniqueId, false);
				NetworkSpawner.ExecuteSpawn(itemName, position, uniqueId);
			}
		}

		public static void ReceiveInventoryItemRequest(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0025: 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)
			if (NetworkManager.Singleton.IsServer)
			{
				string itemName = default(string);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref itemName, false);
				int count = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref count, default(ForPrimitives));
				ExecuteGiveInventoryItem(senderClientId, itemName, count);
			}
		}

		public unsafe static void RequestInventoryItem(string itemName, int count)
		{
			//IL_0065: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NetworkManager.Singleton == (Object)null)
			{
				return;
			}
			if (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost)
			{
				ExecuteGiveInventoryItem(NetworkManager.Singleton.LocalClientId, itemName, count);
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(64, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe(itemName, false);
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref count, default(ForPrimitives));
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("ModdedRequestInventoryItem", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public static void ExecuteGiveInventoryItem(ulong clientId, string itemName, int count)
		{
			if (playersById.TryGetValue(clientId, out var value) && !((Object)(object)value.Inventory == (Object)null))
			{
				((InventoryBase)value.Inventory).TryAddItem(itemName, count);
			}
		}

		public unsafe static void ConsumeItemDurability(int index, int amount)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NetworkManager.Singleton == (Object)null)
			{
				return;
			}
			if (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost)
			{
				ApplyDurabilityDamage(NetworkManager.Singleton.LocalClientId, index, amount);
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref index, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref amount, default(ForPrimitives));
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("RequestConsumeDurability", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private static void ReceiveDurabilityRequestOnServer(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0007: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			int index = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref index, default(ForPrimitives));
			int amount = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref amount, default(ForPrimitives));
			ApplyDurabilityDamage(senderClientId, index, amount);
		}

		public static void ApplyDurabilityDamage(ulong clientId, int index, int amount)
		{
			//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_0089: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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)
			if (!playersById.TryGetValue(clientId, out var value))
			{
				return;
			}
			PlayerInventory inventory = value.Inventory;
			if (((inventory != null) ? ((InventoryBase)inventory).Contents : null) == null)
			{
				return;
			}
			NetworkList<InventoryItem> contents = ((InventoryBase)value.Inventory).Contents;
			for (int i = 0; i < contents.Count; i++)
			{
				InventoryItem val = contents[i];
				if (!((InventoryItem)(ref val)).IsValidItem || ((InventoryItem)(ref val)).ItemIndex != index)
				{
					continue;
				}
				if (!RegisteredEquipmentByIndex.TryGetValue(index, out var value2))
				{
					break;
				}
				if (val.data.durability <= (float)amount)
				{
					if (((InventoryItem)(ref val)).ItemCount > 1)
					{
						InventoryItem val2 = val;
						ushort itemCount = ((InventoryItem)(ref val2)).ItemCount;
						((InventoryItem)(ref val2)).ItemCount = (ushort)(itemCount - 1);
						contents[i] = val2;
					}
					else
					{
						contents.RemoveAt(i);
					}
					value2.OnBreak(value);
				}
				else
				{
					val.data.durability -= amount;
					contents[i] = val;
					value2.OnDurabilityChange(val.data.durability, value);
				}
				break;
			}
		}

		public static void OnUpdate()
		{
			if (isInitialized && !((Object)(object)NetworkManager.Singleton == (Object)null) && !((Object)(object)localPlayer == (Object)null) && !((Object)(object)localPlayer.Inventory == (Object)null))
			{
				ProcessLocalPlayerMechanics(localPlayer);
			}
		}

		private static void ProcessLocalPlayerMechanics(PlayerNetworking player)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			PlayerState playerState = ItemAPI.playerState;
			for (int i = 0; i < ((InventoryBase)player.Inventory).SlotCount; i++)
			{
				InventoryItem itemInSlot = ((InventoryBase)player.Inventory).GetItemInSlot(i);
				if (((InventoryItem)(ref itemInSlot)).IsValidItem && RegisteredEquipmentByIndex.TryGetValue(((InventoryItem)(ref itemInSlot)).ItemIndex, out var value))
				{
					if (!playerState.InHotbar.Contains(((InventoryItem)(ref itemInSlot)).ItemIndex))
					{
						playerState.InHotbar.Add(((InventoryItem)(ref itemInSlot)).ItemIndex);
					}
					float durability = itemInSlot.data.durability;
					if (playerState.TrackedItemDurability.TryGetValue(((InventoryItem)(ref itemInSlot)).ItemIndex, out var value2) && durability != value2)
					{
						value.OnDurabilityChange(durability, player);
					}
					playerState.TrackedItemDurability[((InventoryItem)(ref itemInSlot)).ItemIndex] = durability;
				}
			}
			if (!slotItemName.TryGetValue(((NetworkBehaviour)player).OwnerClientId, out var value3) || (value3[0] == null && value3[1] == null && value3[2] == null))
			{
				return;
			}
			if (Input.GetMouseButton(0))
			{
				playerState.LeftClickHoldTimer += Time.deltaTime;
				if (playerState.LeftClickHoldTimer >= 0.2f && !playerState.HasSentLeftHoldTrue)
				{
					LeftClick(isHolding: true, player, value3);
					playerState.HasSentLeftHoldTrue = true;
				}
			}
			if (Input.GetMouseButtonUp(0))
			{
				if (!playerState.HasSentLeftHoldTrue)
				{
					LeftClick(isHolding: false, player, value3);
				}
				playerState.LeftClickHoldTimer = 0f;
				playerState.HasSentLeftHoldTrue = false;
			}
		}

		private static void LeftClick(bool isHolding, PlayerNetworking player, string[] slots)
		{
			for (int i = 0; i < slots.Length; i++)
			{
				if (slots[i] != null && RegisteredEquipment.TryGetValue(slots[i], out var value))
				{
					value.OnLeftClick(isHolding, player);
				}
			}
		}

		public static bool isItemEquipped(string Name)
		{
			return (Object)(object)localPlayer != (Object)null && isItemEquipped(((NetworkBehaviour)localPlayer).OwnerClientId, Name);
		}

		public static bool isItemEquipped(ulong clientId, string Name)
		{
			HashSet<string> value;
			return itemsEquipped.TryGetValue(clientId, out value) && value.Contains(Name);
		}

		public static IReadOnlyCollection<string> GetEquippedItems(ulong clientId)
		{
			IReadOnlyCollection<string> result;
			if (!itemsEquipped.TryGetValue(clientId, out var value))
			{
				IReadOnlyCollection<string> readOnlyCollection = (IReadOnlyCollection<string>)(object)Array.Empty<string>();
				result = readOnlyCollection;
			}
			else
			{
				IReadOnlyCollection<string> readOnlyCollection = value;
				result = readOnlyCollection;
			}
			return result;
		}

		public static IReadOnlyCollection<string> GetEquippedItems()
		{
			IReadOnlyCollection<string> result;
			if (!((Object)(object)localPlayer != (Object)null))
			{
				IReadOnlyCollection<string> readOnlyCollection = (IReadOnlyCollection<string>)(object)Array.Empty<string>();
				result = readOnlyCollection;
			}
			else
			{
				result = GetEquippedItems(((NetworkBehaviour)localPlayer).OwnerClientId);
			}
			return result;
		}

		public static GameObject LoadGameObject(string bundleName, string prefabName)
		{
			if (!_bundleCache.TryGetValue(bundleName, out var value))
			{
				Assembly callingAssembly = Assembly.GetCallingAssembly();
				using Stream stream = callingAssembly.GetManifestResourceStream(bundleName);
				if (stream == null)
				{
					ManualLogSource obj = logger;
					if (obj != null)
					{
						obj.LogError((object)("Could not find embedded bundle resource: " + bundleName + " in assembly " + callingAssembly.GetName().Name));
					}
					return null;
				}
				value = AssetBundle.LoadFromStream(stream);
				if ((Object)(object)value == (Object)null)
				{
					ManualLogSource obj2 = logger;
					if (obj2 != null)
					{
						obj2.LogError((object)("Failed to load AssetBundle from stream: " + bundleName));
					}
					return null;
				}
				_bundleCache[bundleName] = value;
			}
			GameObject val = value.LoadAsset<GameObject>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource obj3 = logger;
				if (obj3 != null)
				{
					obj3.LogError((object)("Could not find prefab '" + prefabName + "' inside bundle '" + bundleName + "'"));
				}
				return null;
			}
			return val;
		}

		public static void LogEmbeddedResources(Assembly assembly)
		{
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			if (manifestResourceNames.Length == 0)
			{
				ManualLogSource obj = logger;
				if (obj != null)
				{
					obj.LogInfo((object)("[" + assembly.GetName().Name + "] No embedded resources found."));
				}
				return;
			}
			string[] array = manifestResourceNames;
			foreach (string text in array)
			{
				ManualLogSource obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogInfo((object)("[" + assembly.GetName().Name + "] Embedded resource: " + text));
				}
			}
		}

		public static List<PlayerNetworking> GetAllPlayers()
		{
			return new List<PlayerNetworking>(playersById.Values);
		}

		public static PlayerNetworking GetLocalPlayer()
		{
			return localPlayer;
		}

		public static AllItems GetAllItems()
		{
			return AllItems ?? null;
		}

		public static Transform FindChildRecursive(Transform parent, string name)
		{
			if (((Object)parent).name == name)
			{
				return parent;
			}
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform val = FindChildRecursive(parent.GetChild(i), name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		public static int GetItemIndex(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return -1;
			}
			if (RegisteredEquipment.TryGetValue(name, out var value))
			{
				return value.ItemIndex;
			}
			if (itemNameToIndex.TryGetValue(name, out var value2))
			{
				return value2;
			}
			LogInfo("Equipment not found: " + name);
			return -1;
		}

		public static ItemData GetItemData(string name)
		{
			return ((IEnumerable<ItemData>)AllItems.items).FirstOrDefault((Func<ItemData, bool>)((ItemData item) => ((Object)item).name.Equals(name, StringComparison.OrdinalIgnoreCase)));
		}

		public static InventoryItem GetItemInInventory(int index)
		{
			//IL_0027: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			PlayerNetworking obj = localPlayer;
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				PlayerInventory inventory = obj.Inventory;
				obj2 = ((inventory != null) ? ((InventoryBase)inventory).Contents : null);
			}
			if (obj2 == null)
			{
				return default(InventoryItem);
			}
			NetworkList<InventoryItem> contents = ((InventoryBase)localPlayer.Inventory).Contents;
			for (int i = 0; i < contents.Count; i++)
			{
				InventoryItem result = contents[i];
				if (((InventoryItem)(ref result)).IsValidItem && ((InventoryItem)(ref result)).ItemIndex == index)
				{
					return result;
				}
			}
			return default(InventoryItem);
		}

		public static bool HasItemInInventory(int index)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			PlayerNetworking obj = localPlayer;
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				PlayerInventory inventory = obj.Inventory;
				obj2 = ((inventory != null) ? ((InventoryBase)inventory).Contents : null);
			}
			if (obj2 == null)
			{
				return false;
			}
			NetworkList<InventoryItem> contents = ((InventoryBase)localPlayer.Inventory).Contents;
			for (int i = 0; i < contents.Count; i++)
			{
				InventoryItem val = contents[i];
				if (((InventoryItem)(ref val)).IsValidItem && ((InventoryItem)(ref val)).ItemIndex == index)
				{
					return true;
				}
			}
			return false;
		}

		public static void RegisterEquipment(int index, Equipment equipment)
		{
			equipment.ItemIndex = index;
			RegisteredEquipmentByIndex[index] = equipment;
		}

		public static void RequestSpawn(string itemName, Vector3 position, string? uniqueId)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			NetworkSpawner.RequestSpawn(itemName, position, uniqueId ?? "");
		}

		private static void LogInfo(string mess)
		{
			ManualLogSource obj = logger;
			if (obj != null)
			{
				obj.LogInfo((object)mess);
			}
		}

		private static void OnLocalizationInitialized(AsyncOperationHandle<LocalizationSettings> handle)
		{
			LoadItemsNames();
		}

		private static void LoadItemsNames()
		{
			//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_0091: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			List<Type> equipmentTypes = new List<Type>();
			foreach (Assembly registeredAssembly in registeredAssemblies)
			{
				equipmentTypes.AddRange(from t in registeredAssembly.GetTypes()
					where t.IsSubclassOf(typeof(Equipment)) && !t.IsAbstract
					select t);
			}
			AsyncOperationHandle<StringTable> tableAsync = ((LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase).GetTableAsync(TableReference.op_Implicit("Items"), (Locale)null);
			tableAsync.Completed += delegate(AsyncOperationHandle<StringTable> handle)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Invalid comparison between Unknown and I4
				if ((int)handle.Status != 1)
				{
					return;
				}
				StringTable result = handle.Result;
				foreach (Type item in equipmentTypes)
				{
					Equipment equipment = (Equipment)Activator.CreateInstance(item);
					((DetailedLocalizationTable<StringTableEntry>)(object)result).AddEntry(equipment.Name, equipment.Name);
				}
			};
			AsyncOperationHandle<StringTable> tableAsync2 = ((LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase).GetTableAsync(TableReference.op_Implicit("Items Descriptions"), (Locale)null);
			tableAsync2.Completed += delegate(AsyncOperationHandle<StringTable> handle)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Invalid comparison between Unknown and I4
				if ((int)handle.Status != 1)
				{
					return;
				}
				StringTable result = handle.Result;
				foreach (Type item2 in equipmentTypes)
				{
					Equipment equipment = (Equipment)Activator.CreateInstance(item2);
					((DetailedLocalizationTable<StringTableEntry>)(object)result).AddEntry(equipment.Description, equipment.Description);
				}
			};
		}

		private static void RebuildItemNameIndex()
		{
			itemNameToIndex.Clear();
			if (AllItems?.items == null)
			{
				return;
			}
			for (int i = 0; i < AllItems.items.Length; i++)
			{
				if ((Object)(object)AllItems.items[i] != (Object)null)
				{
					itemNameToIndex[((Object)AllItems.items[i]).name] = i;
				}
			}
		}

		private static void ApplyWorldVisuals(ItemInstance itemInstance, Equipment equipment)
		{
			//IL_0132: 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_0062: 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_0160: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)equipment.Prefab == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)itemInstance).transform;
			Transform val = FindExistingVisual(transform);
			HideDefaultVisualsAndColliders(transform, val);
			if ((Object)(object)val != (Object)null)
			{
				val.localScale = (equipment.DroppedSize.HasValue ? equipment.DroppedSize.Value : Vector3.one);
				val.localPosition = (equipment.DroppedOffset.HasValue ? equipment.DroppedOffset.Value : Vector3.zero);
				if (!equipment.DroppedSize.HasValue && !equipment.DroppedOffset.HasValue)
				{
					SetupVisualTransform(val);
				}
				EnableColliders(val);
				return;
			}
			GameObject val2 = Object.Instantiate<GameObject>(equipment.Prefab, transform, false);
			((Object)val2).name = VisualRootName;
			SetLayerRecursively(val2, ((Component)transform).gameObject.layer);
			Transform transform2 = val2.transform;
			transform2.localScale = (equipment.DroppedSize.HasValue ? equipment.DroppedSize.Value : Vector3.one);
			transform2.localPosition = (equipment.DroppedOffset.HasValue ? equipment.DroppedOffset.Value : Vector3.zero);
			transform2.localRotation = Quaternion.identity;
			if (!equipment.DroppedSize.HasValue && !equipment.DroppedOffset.HasValue)
			{
				SetupVisualTransform(transform2);
			}
			EnableColliders(transform2);
		}

		private static void SetLayerRecursively(GameObject obj, int layer)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			obj.layer = layer;
			foreach (Transform item in obj.transform)
			{
				Transform val = item;
				SetLayerRecursively(((Component)val).gameObject, layer);
			}
		}

		private static void HideDefaultVisualsAndColliders(Transform root, Transform existingVisual)
		{
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsInsideVisual(((Component)val).transform, existingVisual))
				{
					val.enabled = false;
				}
			}
			Collider[] componentsInChildren2 = ((Component)root).GetComponentsInChildren<Collider>(true);
			foreach (Collider val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsInsideVisual(((Component)val2).transform, existingVisual))
				{
					val2.enabled = false;
				}
			}
		}

		private static void EnableColliders(Transform visual)
		{
			Collider[] componentsInChildren = ((Component)visual).GetComponentsInChildren<Collider>(true);
			if (componentsInChildren.Length != 0)
			{
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = true;
				}
			}
			else
			{
				AddBoxCollider(visual);
			}
		}

		private static void AddBoxCollider(Transform visual)
		{
			//IL_0043: 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: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_00a8: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] componentsInChildren = ((Component)visual).GetComponentsInChildren<Renderer>(true);
			if (componentsInChildren.Length == 0)
			{
				ManualLogSource obj = logger;
				if (obj != null)
				{
					obj.LogWarning((object)("No renderers found under '" + ((Object)visual).name + "' to generate a collider from."));
				}
				return;
			}
			Bounds bounds = componentsInChildren[0].bounds;
			for (int i = 1; i < componentsInChildren.Length; i++)
			{
				((Bounds)(ref bounds)).Encapsulate(componentsInChildren[i].bounds);
			}
			Vector3 center = visual.InverseTransformPoint(((Bounds)(ref bounds)).center);
			Vector3 val = visual.InverseTransformVector(((Bounds)(ref bounds)).size);
			((Vector3)(ref val))..ctor(Mathf.Abs(val.x), Mathf.Abs(val.y), Mathf.Abs(val.z));
			BoxCollider val2 = ((Component)visual).gameObject.AddComponent<BoxCollider>();
			val2.center = center;
			val2.size = val;
		}

		private static void SetupVisualTransform(Transform visual)
		{
			//IL_0002: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			visual.localPosition = Vector3.zero;
			visual.localRotation = Quaternion.identity;
			visual.localScale = Vector3.one;
		}

		private static bool IsInsideVisual(Transform candidate, Transform existingVisual)
		{
			if ((Object)(object)existingVisual == (Object)null)
			{
				return false;
			}
			return (Object)(object)candidate == (Object)(object)existingVisual || candidate.IsChildOf(existingVisual);
		}

		private static Transform FindExistingVisual(Transform root)
		{
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)(object)root && ((Object)componentsInChildren[i]).name == VisualRootName)
				{
					return componentsInChildren[i];
				}
			}
			return null;
		}

		private static ItemData CreateItem(string name, string description, Sprite icon, EquipmentType itemType, int? maxDura, int? maxStackSize, GameObject prefab, AllItems allItems)
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0049: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0066: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			ItemData val = ScriptableObject.CreateInstance<ItemData>();
			((Object)val).name = name;
			((CraftableItemBase)val).icon = icon ?? ((CraftableItemBase)allItems.items[0]).icon;
			((CraftableItemBase)val).localizedName = new LocalizedString(TableReference.op_Implicit("Items"), TableEntryReference.op_Implicit(name));
			((CraftableItemBase)val).localizedDesc = new LocalizedString(TableReference.op_Implicit("Items Descriptions"), TableEntryReference.op_Implicit(description));
			val.description = description;
			val.equipmentType = itemType;
			val.maxStackSize = maxStackSize ?? 1;
			val.usageType = (UsageType)0;
			val.durabilityLoss = (EquipmentDurabilityLossType)2;
			val.maxDurability = maxDura ?? 100;
			val.prefab = allItems.defaultPrefab;
			val.dontAllowEquipTogetherWith = (ItemData[])(object)new ItemData[0];
			((Object)val).hideFlags = (HideFlags)32;
			return val;
		}

		private static void RegisterItems(AllItems allItems)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			List<Type> list = new List<Type>();
			foreach (Assembly registeredAssembly in registeredAssemblies)
			{
				list.AddRange(from t in registeredAssembly.GetTypes()
					where t.IsSubclassOf(typeof(Equipment)) && !t.IsAbstract
					select t);
			}
			List<ItemData> list2 = new List<ItemData>();
			Dictionary<ItemData, Equipment> dictionary = new Dictionary<ItemData, Equipment>();
			foreach (Type item in list)
			{
				Equipment equipment = (Equipment)Activator.CreateInstance(item);
				if (!((Object)(object)FindExisting(allItems, equipment.Name) != (Object)null))
				{
					ItemData val = CreateItem(equipment.Name, equipment.Description, equipment.Icon, equipment.ItemType, equipment.maxDurability, equipment.maxStackSize, equipment.Prefab, allItems);
					list2.Add(val);
					dictionary.Add(val, equipment);
					if (!RegisteredEquipment.ContainsKey(equipment.Name))
					{
						RegisteredEquipment.Add(equipment.Name, equipment);
					}
				}
			}
			if (list2.Count <= 0)
			{
				return;
			}
			int num = allItems.items.Length;
			Array.Resize(ref allItems.items, num + list2.Count);
			for (int num2 = 0; num2 < list2.Count; num2++)
			{
				int num3 = num + num2;
				allItems.items[num3] = list2[num2];
				if (dictionary.TryGetValue(list2[num2], out var value) && !RegisteredEquipmentByIndex.ContainsKey(num3))
				{
					RegisterEquipment(num3, value);
				}
				LogInfo("Registered item: " + ((Object)list2[num2]).name + " Item Index: " + num3);
			}
			itemRegistered = true;
		}

		private static ItemData FindExisting(AllItems allItems, string itemName)
		{
			ItemData[] items = allItems.items;
			foreach (ItemData val in items)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name == itemName)
				{
					return val;
				}
			}
			return null;
		}

		public static Sprite LoadSpriteFromEmbedded(string resourcePath)
		{
			return LoadSpriteFromEmbedded(resourcePath, Assembly.GetCallingAssembly());
		}

		public static Sprite LoadSpriteFromEmbedded(string resourcePath, Assembly assembly)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00ab: 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)
			if (_spriteCache.TryGetValue(resourcePath, out var value))
			{
				return value;
			}
			using Stream stream = assembly.GetManifestResourceStream(resourcePath);
			if (stream == null)
			{
				ManualLogSource obj = logger;
				if (obj != null)
				{
					obj.LogError((object)("Could not find embedded resource: " + resourcePath + " in assembly " + assembly.GetName().Name));
				}
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			_spriteCache[resourcePath] = val2;
			return val2;
		}

		public static void AddRecipe(CraftingRecipe recipe)
		{
			if (recipe != null && !RegisteredRecipesList.Contains(recipe))
			{
				RegisteredRecipesList.Add(recipe);
			}
		}

		private static bool HasRecipe(CraftingRecipes recipes, ItemData result)
		{
			Recipe[] recipes2 = recipes.recipes;
			foreach (Recipe val in recipes2)
			{
				if (val != null && (Object)(object)val.CraftResult == (Object)(object)result)
				{
					return true;
				}
			}
			return false;
		}

		private static int CountItemInInventory(InventoryBase inventory, int itemIndex)
		{
			//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_0024: 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)
			int num = 0;
			foreach (InventoryItem inventoryItem in inventory.GetInventoryItems())
			{
				InventoryItem current = inventoryItem;
				if (((InventoryItem)(ref current)).IsValidItem && current.data.itemIndex == itemIndex)
				{
					num += ((InventoryItem)(ref current)).ItemCount;
				}
			}
			return num;
		}

		private static bool IsResourceOrDepositableCost(CraftingCost cost)
		{
			if (cost.ResourceType.HasValue)
			{
				return true;
			}
			if ((Object)(object)cost.Item != (Object)null && ((Object)cost.Item).name.Equals("Gnomium", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return false;
		}

		private static int GetOwnedCountForCost(CraftingCost cost, InventoryBase targetInventory, InventoryBase resourceInventory)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected I4, but got Unknown
			if (cost.ResourceType.HasValue)
			{
				string resourceName = ResourceStorage.GetResourceName((int)cost.ResourceType.Value);
				return resourceInventory.GetItemCount(resourceName);
			}
			if ((Object)(object)cost.Item == (Object)null)
			{
				return 0;
			}
			if (((Object)cost.Item).name.Equals("Gnomium", StringComparison.OrdinalIgnoreCase))
			{
				return resourceInventory.GetItemCount(((Object)cost.Item).name);
			}
			int itemIndex = GetItemIndex(((Object)cost.Item).name);
			return CountItemInInventory(targetInventory, itemIndex);
		}

		private static IEnumerator RegisterRecipesCoroutine(GnomiumDeposit gnomiumDeposit)
		{
			while (!itemRegistered)
			{
				yield return (object)new WaitForEndOfFrame();
			}
			if ((Object)(object)gnomiumDeposit == (Object)null || (Object)(object)gnomiumDeposit.Recipes == (Object)null || (Object)(object)gnomiumDeposit.ResourceInventory == (Object)null)
			{
				yield break;
			}
			foreach (Assembly assembly in registeredAssemblies)
			{
				IEnumerable<Type> recipeTypes = from t in assembly.GetTypes()
					where t.IsSubclassOf(typeof(CraftingRecipe)) && !t.IsAbstract
					select t;
				foreach (Type type in recipeTypes)
				{
					if (!RegisteredRecipesList.Any((CraftingRecipe r) => r.GetType() == type))
					{
						CraftingRecipe recipeInstance = (CraftingRecipe)Activator.CreateInstance(type);
						RegisteredRecipesList.Add(recipeInstance);
					}
				}
			}
			int num2 = default(int);
			foreach (CraftingRecipe customRecipe in RegisteredRecipesList)
			{
				if (customRecipe.Equipment == null)
				{
					continue;
				}
				ItemData resultItem = FindExisting(gnomiumDeposit.ResourceInventory.BoundItems, customRecipe.Equipment.Name);
				if ((Object)(object)resultItem == (Object)null || HasRecipe(gnomiumDeposit.Recipes, resultItem))
				{
					continue;
				}
				List<ItemCost> costs = new List<ItemCost>();
				CraftingCost[] costTable = customRecipe.CostTable;
				for (int num = 0; num < costTable.Length; num++)
				{
					CraftingCost costEntry = costTable[num];
					ItemData ingredientItem;
					if (costEntry.ResourceType.HasValue)
					{
						string resourceName = ResourceStorage.GetResourceName((int)costEntry.ResourceType.Value);
						ingredientItem = gnomiumDeposit.ResourceInventory.BoundItems.GetItem(resourceName, ref num2);
					}
					else
					{
						ingredientItem = costEntry.Item;
					}
					if ((Object)(object)ingredientItem != (Object)null)
					{
						costs.Add(new ItemCost
						{
							item = ingredientItem,
							amount = costEntry.Amount
						});
					}
					else
					{
						LogInfo("Could not resolve cost ingredient for recipe: " + customRecipe.Equipment.Name);
					}
				}
				if (costs.Count != 0)
				{
					Recipe recipe = new Recipe
					{
						craftResultType = (CraftResultType)0,
						cost = costs.ToArray()
					};
					RecipeItemField?.SetValue(recipe, resultItem);
					Array.Resize(ref gnomiumDeposit.Recipes.recipes, gnomiumDeposit.Recipes.recipes.Length + 1);
					gnomiumDeposit.Recipes.recipes[gnomiumDeposit.Recipes.recipes.Length - 1] = recipe;
					LogInfo("Registered custom recipe for item: " + customRecipe.Equipment.Name);
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ItemAPI";

		public const string PLUGIN_NAME = "ItemAPI";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}