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.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("RuneVault")]
[assembly: AssemblyDescription("A virtual bank for Valheim building materials")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Ruijven")]
[assembly: AssemblyProduct("RuneVault")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RuneVault;

public class ConfigManager
{
	[CompilerGenerated]
	private sealed class <ReloadConfigDelayed>d__29 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public ConfigManager <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.ReloadConfig();
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					((Character)Player.m_localPlayer).Message((MessageType)2, "RuneVault: Configuration reloaded", 0, (Sprite)null);
				}
				return false;
			}
		}

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

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

	private string configDir;

	private string allowedItemsPath;

	private DateTime lastConfigReloadTime = DateTime.MinValue;

	private ConfigFile bepInExConfig;

	private readonly HashSet<string> autoAllowedItems = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private static readonly Dictionary<string, string> ItemNameMappings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
	{
		{ "boar_meat", "rawmeat" },
		{ "mushroomcommon", "mushroom" },
		{ "mushroom_yellow", "yellowmushroom" },
		{ "mushroom_blue", "bluemushroom" },
		{ "mushroom_jotunpuffs", "mushroomjotunpuffs" },
		{ "mushroom_magecap", "mushroommagecap" },
		{ "mushroom_smokepuff", "mushroomsmokepuff" },
		{ "Raspberry", "raspberry" },
		{ "Cloudberry", "cloudberry" },
		{ "Bloodbag", "bloodbag" },
		{ "AmberPearl", "amberpearl" }
	};

	public static ConfigManager Instance { get; private set; }

	public RuneVaultConfig Config { get; private set; }

	private void LoadConfig()
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Expected O, but got Unknown
		try
		{
			if (!Directory.Exists(configDir))
			{
				Directory.CreateDirectory(configDir);
			}
			if (File.Exists(allowedItemsPath))
			{
				string text = File.ReadAllText(allowedItemsPath);
				IDeserializer val = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
				Config = val.Deserialize<RuneVaultConfig>(text);
				Logger.LogInfo((object)$"RuneVault: Loaded {Config.AllowedItems.Count} allowed items from config");
			}
			else
			{
				CreateDefaultAllowedItemsFile();
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error loading config: " + ex.Message));
			CreateDefaultAllowedItemsFile();
		}
	}

	public bool IsItemAllowed(string itemName)
	{
		if (string.IsNullOrEmpty(itemName))
		{
			Logger.LogWarning((object)"RuneVault: Empty item name provided to IsItemAllowed");
			return false;
		}
		string lowerItemName = itemName.ToLowerInvariant();
		if (itemName.StartsWith("Trophy", StringComparison.OrdinalIgnoreCase) || lowerItemName.Contains("trophy"))
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Auto-allowing trophy '" + itemName + "'"));
			}
			return true;
		}
		if (lowerItemName.Contains("gemstone") || lowerItemName.Contains("socket") || lowerItemName.Contains("uncut"))
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Auto-allowing jewelcrafting item '" + itemName + "'"));
			}
			return true;
		}
		if ((lowerItemName.Contains("raspberry") || lowerItemName.Contains("cloudberry") || lowerItemName.Contains("blueberry") || lowerItemName.Contains("mushroom")) && Config.AllowedItems.Any(delegate(AllowedItem item)
		{
			string text = item.ItemName.ToLowerInvariant();
			return (lowerItemName.Contains("raspberry") && text.Contains("raspberry")) || (lowerItemName.Contains("cloudberry") && text.Contains("cloudberry")) || (lowerItemName.Contains("blueberry") && text.Contains("blueberry")) || (lowerItemName.Contains("mushroom") && text.Contains("mushroom"));
		}))
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Special berry/mushroom match for '" + itemName + "'"));
			}
			return true;
		}
		bool flag = IsItemInAllowedList(itemName);
		if (Config.StrictYamlFiltering)
		{
			if (!flag)
			{
				if (Config.DebugMode)
				{
					Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' is not in the allowed list from YAML (strict mode)"));
				}
				return false;
			}
			ItemData itemDataFromPrefabName = GetItemDataFromPrefabName(itemName);
			if (itemDataFromPrefabName != null)
			{
				if (IsCraftingMaterial(itemDataFromPrefabName))
				{
					if (Config.DebugMode)
					{
						Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' is in YAML and is a crafting material (strict mode)"));
					}
					return true;
				}
				if (Config.DebugMode)
				{
					Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' is in YAML but is NOT a crafting material (strict mode)"));
				}
				return false;
			}
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' is in YAML but couldn't get item data, allowing it (strict mode)"));
			}
			return true;
		}
		if (flag)
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' is in YAML list - non-strict mode, allowing"));
			}
			return true;
		}
		string item2 = NormalizeItemName(itemName);
		if (autoAllowedItems.Contains(item2))
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' is in auto-detected allowed set"));
			}
			return true;
		}
		ItemData itemDataFromPrefabName2 = GetItemDataFromPrefabName(itemName);
		if (itemDataFromPrefabName2 != null)
		{
			if (IsCraftingMaterial(itemDataFromPrefabName2))
			{
				autoAllowedItems.Add(item2);
				if (Config.DebugMode)
				{
					Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' auto-detected as crafting material and added to allowed set"));
				}
				return true;
			}
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' auto-detected as NOT a crafting material"));
			}
			return false;
		}
		if (Config.DebugMode)
		{
			Logger.LogDebug((object)("RuneVault: Item '" + itemName + "' not in YAML and item data could not be resolved; disallowing"));
		}
		return false;
	}

	private ItemData GetItemDataFromPrefabName(string prefabName)
	{
		try
		{
			ZNetScene instance = ZNetScene.instance;
			GameObject val = ((instance != null) ? instance.GetPrefab(prefabName) : null);
			if ((Object)(object)val != (Object)null)
			{
				ItemDrop component = val.GetComponent<ItemDrop>();
				if ((Object)(object)component != (Object)null && component.m_itemData != null)
				{
					return component.m_itemData;
				}
			}
		}
		catch (Exception ex)
		{
			if (Config.DebugMode)
			{
				Logger.LogWarning((object)("RuneVault: Error getting item data for " + prefabName + ": " + ex.Message));
			}
		}
		return null;
	}

	private bool IsItemInAllowedList(string itemName)
	{
		if (string.IsNullOrEmpty(itemName))
		{
			return false;
		}
		string normalizedItemName = NormalizeItemName(itemName);
		List<AllowedItem> list = Config.AllowedItems.Where((AllowedItem item) => NormalizeItemName(item.ItemName).Equals(normalizedItemName, StringComparison.OrdinalIgnoreCase)).ToList();
		if (list.Count > 0)
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Found direct match in config: " + list[0].ItemName));
			}
			return true;
		}
		if (normalizedItemName.StartsWith("$"))
		{
			string withoutPrefix = normalizedItemName.Substring(1);
			List<AllowedItem> list2 = Config.AllowedItems.Where((AllowedItem item) => NormalizeItemName(item.ItemName).Equals(withoutPrefix, StringComparison.OrdinalIgnoreCase)).ToList();
			if (list2.Count > 0)
			{
				if (Config.DebugMode)
				{
					Logger.LogDebug((object)("RuneVault: Found match without $ prefix: " + list2[0].ItemName));
				}
				return true;
			}
		}
		List<AllowedItem> list3 = Config.AllowedItems.Where(delegate(AllowedItem item)
		{
			string text2 = NormalizeItemName(item.ItemName);
			return text2.StartsWith("$") && text2.Substring(1).Equals(normalizedItemName, StringComparison.OrdinalIgnoreCase);
		}).ToList();
		if (list3.Count > 0)
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Found match with $ prefix in config: " + list3[0].ItemName));
			}
			return true;
		}
		if (normalizedItemName.Contains("berry") || normalizedItemName.Contains("mushroom"))
		{
			string itemType = ExtractItemType(normalizedItemName);
			if (!string.IsNullOrEmpty(itemType))
			{
				List<AllowedItem> list4 = Config.AllowedItems.Where((AllowedItem item) => NormalizeItemName(item.ItemName).Contains(itemType)).ToList();
				if (list4.Count > 0)
				{
					if (Config.DebugMode)
					{
						Logger.LogDebug((object)("RuneVault: Found special match for " + itemType + ": " + list4[0].ItemName));
					}
					return true;
				}
			}
		}
		List<AllowedItem> list5 = Config.AllowedItems.Where(delegate(AllowedItem item)
		{
			string text = NormalizeItemName(item.ItemName);
			return normalizedItemName.Contains(text) && text.Length >= 5;
		}).ToList();
		if (list5.Count > 0)
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Found safe partial match in config: " + list5[0].ItemName));
			}
			return true;
		}
		return false;
	}

	private string ExtractItemType(string itemName)
	{
		if (string.IsNullOrEmpty(itemName))
		{
			return string.Empty;
		}
		string text = (itemName.StartsWith("$") ? itemName.Substring(1) : itemName);
		string[] array = new string[2] { "item_", "material_" };
		string[] array2 = array;
		foreach (string text2 in array2)
		{
			if (text.StartsWith(text2, StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(text2.Length);
				break;
			}
		}
		return text;
	}

	private bool IsCraftingMaterial(ItemData item)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Invalid comparison between Unknown and I4
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Invalid comparison between Unknown and I4
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Invalid comparison between Unknown and I4
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Invalid comparison between Unknown and I4
		if (item == null || item.m_shared == null)
		{
			return false;
		}
		if (IsSpecialCaseMaterial(item))
		{
			return true;
		}
		if ((int)item.m_shared.m_itemType == 1)
		{
			return true;
		}
		if ((int)item.m_shared.m_itemType == 13)
		{
			return true;
		}
		if ((int)item.m_shared.m_itemType == 2)
		{
			return true;
		}
		if (item.m_shared.m_maxStackSize > 1 && (int)item.m_shared.m_itemType != 9 && !IsExcludedStackableItem(item))
		{
			return true;
		}
		return false;
	}

	private bool IsSpecialCaseMaterial(ItemData item)
	{
		if (item == null || item.m_shared == null)
		{
			return false;
		}
		string text = item.m_shared.m_name.ToLowerInvariant();
		if (text.Contains("cloudberry") || text.Contains("raspberry") || text.Contains("blueberry") || text.Contains("mushroom"))
		{
			return true;
		}
		if (text.Contains("trophy"))
		{
			return true;
		}
		if (text.Contains("gemstone") || text.Contains("socket") || text.Contains("uncut"))
		{
			return true;
		}
		return false;
	}

	private bool IsExcludedStackableItem(ItemData item)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Invalid comparison between Unknown and I4
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Invalid comparison between Unknown and I4
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Invalid comparison between Unknown and I4
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Invalid comparison between Unknown and I4
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Invalid comparison between Unknown and I4
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Invalid comparison between Unknown and I4
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Invalid comparison between Unknown and I4
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Invalid comparison between Unknown and I4
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Invalid comparison between Unknown and I4
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Invalid comparison between Unknown and I4
		if (item == null || item.m_shared == null)
		{
			return false;
		}
		if ((int)item.m_shared.m_itemType == 3 || (int)item.m_shared.m_itemType == 14 || (int)item.m_shared.m_itemType == 4 || (int)item.m_shared.m_itemType == 5 || (int)item.m_shared.m_itemType == 19 || (int)item.m_shared.m_itemType == 15)
		{
			return true;
		}
		if ((int)item.m_shared.m_itemType == 6 || (int)item.m_shared.m_itemType == 7 || (int)item.m_shared.m_itemType == 11 || (int)item.m_shared.m_itemType == 17)
		{
			return true;
		}
		if (item.m_shared.m_name.ToLowerInvariant().Contains("piece") || item.m_shared.m_description.ToLowerInvariant().Contains("build"))
		{
			return true;
		}
		return false;
	}

	private string SimplifyModdedItemName(string itemName)
	{
		if (string.IsNullOrEmpty(itemName))
		{
			return string.Empty;
		}
		string text = itemName.ToLowerInvariant();
		StringBuilder stringBuilder = new StringBuilder();
		bool flag = false;
		bool flag2 = false;
		string text2 = text;
		foreach (char c in text2)
		{
			if (char.IsLetter(c))
			{
				flag = true;
				flag2 = true;
				stringBuilder.Append(c);
			}
			else if (char.IsWhiteSpace(c) && flag2)
			{
				stringBuilder.Append(c);
			}
			else if (char.IsDigit(c) && flag2)
			{
				stringBuilder.Append(c);
			}
			else if (flag2)
			{
				stringBuilder.Append(' ');
				flag2 = false;
			}
		}
		if (!flag)
		{
			return text;
		}
		string text3 = stringBuilder.ToString().Trim();
		while (text3.Contains("  "))
		{
			text3 = text3.Replace("  ", " ");
		}
		return text3;
	}

	private string NormalizeItemName(string itemName)
	{
		if (string.IsNullOrEmpty(itemName))
		{
			return string.Empty;
		}
		string text = itemName;
		if (itemName.StartsWith("$item_", StringComparison.OrdinalIgnoreCase))
		{
			itemName = itemName.Substring(6);
		}
		if (itemName.StartsWith("item_", StringComparison.OrdinalIgnoreCase))
		{
			itemName = itemName.Substring(5);
		}
		if (ItemNameMappings.TryGetValue(itemName, out var value))
		{
			if (Config.DebugMode)
			{
				Logger.LogDebug((object)("RuneVault: Special case mapping: " + text + " -> " + itemName + " -> " + value));
			}
			return value;
		}
		string text2 = itemName.ToLowerInvariant();
		text2 = text2.Replace("_", "");
		if (Config.DebugMode)
		{
			Logger.LogDebug((object)("RuneVault: Normalized item name: " + text + " -> " + itemName + " -> " + text2));
		}
		return text2;
	}

	public ConfigManager(ConfigFile configFile)
	{
		Instance = this;
		bepInExConfig = configFile;
		configDir = Path.Combine(Paths.ConfigPath, "RuneVault");
		Directory.CreateDirectory(configDir);
		allowedItemsPath = Path.Combine(configDir, "RuneVaultItems.yaml");
		InitConfig();
		SetupConfigFileWatcher();
	}

	private void InitConfig()
	{
		Config = new RuneVaultConfig();
		Config.DebugMode = bepInExConfig.Bind<bool>("General", "DebugMode", false, "Enable debug mode").Value;
		Config.VaultRange = bepInExConfig.Bind<float>("General", "VaultRange", 35f, "Range in meters at which the RuneVault can be accessed").Value;
		if (!File.Exists(allowedItemsPath))
		{
			Logger.LogWarning((object)("RuneVault: YAML file not found at " + allowedItemsPath + ". Creating default file."));
			CreateDefaultAllowedItemsFile();
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "RuneVault: Created default items config file.", 0, (Sprite)null);
			}
		}
		LoadAllowedItems();
		Logger.LogInfo((object)$"RuneVault: Loaded {Config.AllowedItems.Count} allowed items from config");
		if (!Config.DebugMode)
		{
			return;
		}
		foreach (AllowedItem allowedItem in Config.AllowedItems)
		{
			Logger.LogDebug((object)("RuneVault: Allowed item: " + allowedItem.ItemName));
		}
	}

	private void LoadAllowedItems()
	{
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Expected O, but got Unknown
		if (!File.Exists(allowedItemsPath))
		{
			Logger.LogError((object)("RuneVault: YAML file not found at " + allowedItemsPath + ". No items will be allowed."));
			Config.AllowedItems = new List<AllowedItem>();
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "RuneVault: Items config file missing! Check logs.", 0, (Sprite)null);
			}
			return;
		}
		try
		{
			string text = File.ReadAllText(allowedItemsPath);
			if (string.IsNullOrEmpty(text))
			{
				Logger.LogError((object)("RuneVault: YAML file at " + allowedItemsPath + " is empty."));
				Config.AllowedItems = new List<AllowedItem>();
				return;
			}
			IDeserializer val = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
			try
			{
				RuneVaultConfig runeVaultConfig = val.Deserialize<RuneVaultConfig>(text);
				if (runeVaultConfig != null && runeVaultConfig.AllowedItems != null && runeVaultConfig.AllowedItems.Count > 0)
				{
					Config.AllowedItems = runeVaultConfig.AllowedItems;
					Logger.LogInfo((object)$"RuneVault: Successfully loaded {Config.AllowedItems.Count} items directly from YAML.");
					return;
				}
			}
			catch (Exception)
			{
				Logger.LogDebug((object)"RuneVault: Direct deserialization failed, trying AllowedItemsConfig format.");
			}
			AllowedItemsConfig allowedItemsConfig = val.Deserialize<AllowedItemsConfig>(text);
			if (allowedItemsConfig != null && allowedItemsConfig.Items != null && allowedItemsConfig.Items.Count > 0)
			{
				Config.AllowedItems = allowedItemsConfig.Items;
				Logger.LogInfo((object)$"RuneVault: Successfully loaded {Config.AllowedItems.Count} items from YAML using AllowedItemsConfig format.");
			}
			else
			{
				Logger.LogWarning((object)("RuneVault: YAML file at " + allowedItemsPath + " contains no items or has invalid format."));
				Config.AllowedItems = new List<AllowedItem>();
			}
		}
		catch (Exception ex2)
		{
			Logger.LogError((object)("RuneVault: Error loading allowed items: " + ex2.Message + "\n" + ex2.StackTrace));
			Config.AllowedItems = new List<AllowedItem>();
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)2, "RuneVault: Error loading items config! Check logs.", 0, (Sprite)null);
			}
		}
	}

	private void SetupConfigFileWatcher()
	{
		try
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher
			{
				Path = configDir,
				NotifyFilter = (NotifyFilters.LastWrite | NotifyFilters.CreationTime),
				Filter = "RuneVaultItems.yaml",
				EnableRaisingEvents = true
			};
			fileSystemWatcher.Changed += OnConfigFileChanged;
			fileSystemWatcher.Created += OnConfigFileChanged;
			Logger.LogInfo((object)("RuneVault: Config file watcher set up for " + allowedItemsPath));
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error setting up config file watcher: " + ex.Message));
		}
	}

	private void OnConfigFileChanged(object sender, FileSystemEventArgs e)
	{
		if (!(DateTime.Now.Subtract(lastConfigReloadTime).TotalSeconds < 2.0))
		{
			lastConfigReloadTime = DateTime.Now;
			Logger.LogInfo((object)("RuneVault: Config file changed: " + e.FullPath + ", reloading..."));
			RuneVault runeVault = Object.FindObjectOfType<RuneVault>();
			if (runeVault != null)
			{
				((MonoBehaviour)runeVault).StartCoroutine(ReloadConfigDelayed());
			}
		}
	}

	[IteratorStateMachine(typeof(<ReloadConfigDelayed>d__29))]
	private IEnumerator ReloadConfigDelayed()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ReloadConfigDelayed>d__29(0)
		{
			<>4__this = this
		};
	}

	public void ReloadConfig()
	{
		try
		{
			Logger.LogInfo((object)"RuneVault: Reloading configuration...");
			LoadAllowedItems();
			Logger.LogInfo((object)$"RuneVault: Reloaded {Config.AllowedItems.Count} allowed items from config");
			if (!Config.DebugMode)
			{
				return;
			}
			foreach (AllowedItem allowedItem in Config.AllowedItems)
			{
				Logger.LogDebug((object)("RuneVault: Allowed item: " + allowedItem.ItemName));
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error reloading config: " + ex.Message));
		}
	}

	private void CreateDefaultAllowedItemsFile()
	{
		//IL_0c48: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c57: Expected O, but got Unknown
		RuneVaultConfig runeVaultConfig = new RuneVaultConfig
		{
			enableMod = true,
			DebugMode = false,
			VaultRange = 35f,
			AllowedItems = new List<AllowedItem>
			{
				new AllowedItem
				{
					ItemName = "Wood"
				},
				new AllowedItem
				{
					ItemName = "FineWood"
				},
				new AllowedItem
				{
					ItemName = "RoundLog"
				},
				new AllowedItem
				{
					ItemName = "ElderBark"
				},
				new AllowedItem
				{
					ItemName = "YggdrasilWood"
				},
				new AllowedItem
				{
					ItemName = "Blackwood"
				},
				new AllowedItem
				{
					ItemName = "BirchSeeds"
				},
				new AllowedItem
				{
					ItemName = "BeechSeeds"
				},
				new AllowedItem
				{
					ItemName = "Acorn"
				},
				new AllowedItem
				{
					ItemName = "FirCone"
				},
				new AllowedItem
				{
					ItemName = "PineCone"
				},
				new AllowedItem
				{
					ItemName = "AncientSeed"
				},
				new AllowedItem
				{
					ItemName = "Stone"
				},
				new AllowedItem
				{
					ItemName = "Flint"
				},
				new AllowedItem
				{
					ItemName = "Obsidian"
				},
				new AllowedItem
				{
					ItemName = "BlackMarble"
				},
				new AllowedItem
				{
					ItemName = "Grausten"
				},
				new AllowedItem
				{
					ItemName = "CopperOre"
				},
				new AllowedItem
				{
					ItemName = "TinOre"
				},
				new AllowedItem
				{
					ItemName = "IronOre"
				},
				new AllowedItem
				{
					ItemName = "SilverOre"
				},
				new AllowedItem
				{
					ItemName = "BlackMetalOre"
				},
				new AllowedItem
				{
					ItemName = "BlackMetalScrap"
				},
				new AllowedItem
				{
					ItemName = "BronzeScrap"
				},
				new AllowedItem
				{
					ItemName = "CopperScrap"
				},
				new AllowedItem
				{
					ItemName = "IronScrap"
				},
				new AllowedItem
				{
					ItemName = "FlametalOreNew"
				},
				new AllowedItem
				{
					ItemName = "Copper"
				},
				new AllowedItem
				{
					ItemName = "Tin"
				},
				new AllowedItem
				{
					ItemName = "Bronze"
				},
				new AllowedItem
				{
					ItemName = "Iron"
				},
				new AllowedItem
				{
					ItemName = "Silver"
				},
				new AllowedItem
				{
					ItemName = "BlackMetal"
				},
				new AllowedItem
				{
					ItemName = "FlametalNew"
				},
				new AllowedItem
				{
					ItemName = "Ruby"
				},
				new AllowedItem
				{
					ItemName = "Amber"
				},
				new AllowedItem
				{
					ItemName = "AmberPearl"
				},
				new AllowedItem
				{
					ItemName = "Coins"
				},
				new AllowedItem
				{
					ItemName = "SilverNecklace"
				},
				new AllowedItem
				{
					ItemName = "Thistle"
				},
				new AllowedItem
				{
					ItemName = "Dandelion"
				},
				new AllowedItem
				{
					ItemName = "Turnip"
				},
				new AllowedItem
				{
					ItemName = "Carrot"
				},
				new AllowedItem
				{
					ItemName = "Onion"
				},
				new AllowedItem
				{
					ItemName = "TurnipSeeds"
				},
				new AllowedItem
				{
					ItemName = "CarrotSeeds"
				},
				new AllowedItem
				{
					ItemName = "OnionSeeds"
				},
				new AllowedItem
				{
					ItemName = "Blueberries"
				},
				new AllowedItem
				{
					ItemName = "Raspberry"
				},
				new AllowedItem
				{
					ItemName = "Cloudberry"
				},
				new AllowedItem
				{
					ItemName = "BarleyFlour"
				},
				new AllowedItem
				{
					ItemName = "Barley"
				},
				new AllowedItem
				{
					ItemName = "Vineberry"
				},
				new AllowedItem
				{
					ItemName = "VineberrySeeds"
				},
				new AllowedItem
				{
					ItemName = "VineGreenSeeds"
				},
				new AllowedItem
				{
					ItemName = "Mushroom"
				},
				new AllowedItem
				{
					ItemName = "YellowMushroom"
				},
				new AllowedItem
				{
					ItemName = "BlueMushroom"
				},
				new AllowedItem
				{
					ItemName = "MushroomBlue"
				},
				new AllowedItem
				{
					ItemName = "MushroomYellow"
				},
				new AllowedItem
				{
					ItemName = "MushroomJotunPuffs"
				},
				new AllowedItem
				{
					ItemName = "MushroomMagecap"
				},
				new AllowedItem
				{
					ItemName = "MushroomSmokePuff"
				},
				new AllowedItem
				{
					ItemName = "Fiddleheadfern"
				},
				new AllowedItem
				{
					ItemName = "Honey"
				},
				new AllowedItem
				{
					ItemName = "QueenBee"
				},
				new AllowedItem
				{
					ItemName = "RoyalJelly"
				},
				new AllowedItem
				{
					ItemName = "NeckTail"
				},
				new AllowedItem
				{
					ItemName = "Bloodbag"
				},
				new AllowedItem
				{
					ItemName = "RawMeat"
				},
				new AllowedItem
				{
					ItemName = "DeerMeat"
				},
				new AllowedItem
				{
					ItemName = "FishRaw"
				},
				new AllowedItem
				{
					ItemName = "SerpentMeat"
				},
				new AllowedItem
				{
					ItemName = "Entrails"
				},
				new AllowedItem
				{
					ItemName = "WolfMeat"
				},
				new AllowedItem
				{
					ItemName = "LoxMeat"
				},
				new AllowedItem
				{
					ItemName = "HareMeat"
				},
				new AllowedItem
				{
					ItemName = "ChickenMeat"
				},
				new AllowedItem
				{
					ItemName = "BugMeat"
				},
				new AllowedItem
				{
					ItemName = "VoltureMeat"
				},
				new AllowedItem
				{
					ItemName = "AsksvinMeat"
				},
				new AllowedItem
				{
					ItemName = "BoneMawSerpentMeat"
				},
				new AllowedItem
				{
					ItemName = "LeatherScraps"
				},
				new AllowedItem
				{
					ItemName = "DeerHide"
				},
				new AllowedItem
				{
					ItemName = "TrollHide"
				},
				new AllowedItem
				{
					ItemName = "WolfPelt"
				},
				new AllowedItem
				{
					ItemName = "LoxPelt"
				},
				new AllowedItem
				{
					ItemName = "ScaleHide"
				},
				new AllowedItem
				{
					ItemName = "AskHide"
				},
				new AllowedItem
				{
					ItemName = "Chitin"
				},
				new AllowedItem
				{
					ItemName = "SerpentScale"
				},
				new AllowedItem
				{
					ItemName = "Carapace"
				},
				new AllowedItem
				{
					ItemName = "BonemawSerpentScale"
				},
				new AllowedItem
				{
					ItemName = "Resin"
				},
				new AllowedItem
				{
					ItemName = "GreydwarfEye"
				},
				new AllowedItem
				{
					ItemName = "Coal"
				},
				new AllowedItem
				{
					ItemName = "BoneFragments"
				},
				new AllowedItem
				{
					ItemName = "Feathers"
				},
				new AllowedItem
				{
					ItemName = "Chain"
				},
				new AllowedItem
				{
					ItemName = "Root"
				},
				new AllowedItem
				{
					ItemName = "WitheredBone"
				},
				new AllowedItem
				{
					ItemName = "Guck"
				},
				new AllowedItem
				{
					ItemName = "Ooze"
				},
				new AllowedItem
				{
					ItemName = "WolfFang"
				},
				new AllowedItem
				{
					ItemName = "WolfClaw"
				},
				new AllowedItem
				{
					ItemName = "WolfHairBundle"
				},
				new AllowedItem
				{
					ItemName = "FreezeGland"
				},
				new AllowedItem
				{
					ItemName = "Crystal"
				},
				new AllowedItem
				{
					ItemName = "DragonEgg"
				},
				new AllowedItem
				{
					ItemName = "Needle"
				},
				new AllowedItem
				{
					ItemName = "Tar"
				},
				new AllowedItem
				{
					ItemName = "Eitr"
				},
				new AllowedItem
				{
					ItemName = "Mandible"
				},
				new AllowedItem
				{
					ItemName = "BileBag"
				},
				new AllowedItem
				{
					ItemName = "Softtissue"
				},
				new AllowedItem
				{
					ItemName = "AskBladder"
				},
				new AllowedItem
				{
					ItemName = "BonemawSerpentTooth"
				},
				new AllowedItem
				{
					ItemName = "CelestialFeather"
				},
				new AllowedItem
				{
					ItemName = "Charcoalresin"
				},
				new AllowedItem
				{
					ItemName = "CharredBone"
				},
				new AllowedItem
				{
					ItemName = "SurtlingCore"
				},
				new AllowedItem
				{
					ItemName = "BlackCore"
				},
				new AllowedItem
				{
					ItemName = "MoltenCore"
				},
				new AllowedItem
				{
					ItemName = "JuteRed"
				},
				new AllowedItem
				{
					ItemName = "Flax"
				},
				new AllowedItem
				{
					ItemName = "LinenThread"
				},
				new AllowedItem
				{
					ItemName = "JuteBlue"
				},
				new AllowedItem
				{
					ItemName = "IronNails"
				},
				new AllowedItem
				{
					ItemName = "BronzeNails"
				}
			}
		};
		try
		{
			ISerializer val = ((BuilderSkeleton<SerializerBuilder>)new SerializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build();
			string contents = val.Serialize((object)runeVaultConfig);
			File.WriteAllText(allowedItemsPath, contents);
			Config.AllowedItems = runeVaultConfig.AllowedItems;
			Logger.LogInfo((object)$"RuneVault: Created default allowed items file at {allowedItemsPath} with {runeVaultConfig.AllowedItems.Count} items");
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error creating default allowed items file: " + ex.Message));
		}
	}
}
public class RuneVaultConfig
{
	public bool enableMod { get; set; } = true;


	public bool DebugMode { get; set; } = false;


	public float VaultRange { get; set; } = 35f;


	public bool StrictYamlFiltering { get; set; } = true;


	public List<AllowedItem> AllowedItems { get; set; } = new List<AllowedItem>();

}
public class AllowedItemsConfig
{
	public List<AllowedItem> Items { get; set; } = new List<AllowedItem>();

}
public class AllowedItem
{
	public string ItemName { get; set; }
}
public class GlobalMaterialBank
{
	private Dictionary<string, int> materialCounts = new Dictionary<string, int>();

	private const string BANK_DATA_KEY = "$runevault_bank_data";

	private static bool _hasShownEmptyBankWarning;

	private Player player;

	private bool dataLoaded = false;

	private bool initialized = false;

	public static GlobalMaterialBank Instance { get; private set; }

	public event Action OnBankChanged;

	private string GetPlayerSpecificKey(Player p)
	{
		if ((Object)(object)p == (Object)null)
		{
			return "$runevault_bank_data";
		}
		return "$runevault_bank_data_" + p.GetPlayerID();
	}

	public void SetDataLoaded(bool loaded)
	{
		dataLoaded = loaded;
		Logger.LogInfo((object)$"RuneVault: Data loaded flag set to {loaded}");
	}

	public GlobalMaterialBank()
	{
		Instance = this;
	}

	public void Init()
	{
		ZoneManager.OnVanillaLocationsAvailable += OnWorldLoaded;
		Logger.LogInfo((object)"RuneVault: Registering for game events");
		Logger.LogInfo((object)"RuneVault: Will handle player events in InitializeAfterWorldLoad");
	}

	private void OnWorldLoaded()
	{
		InitializeAfterWorldLoad();
	}

	private void InitializeAfterWorldLoad()
	{
		if (!initialized)
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				Player localPlayer = Player.m_localPlayer;
				((Character)localPlayer).m_onDeath = (Action)Delegate.Combine(((Character)localPlayer).m_onDeath, new Action(OnPlayerDied));
			}
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				Logger.LogInfo((object)"RuneVault: Will save data on game save");
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				OnPlayerSpawned(Player.m_localPlayer);
			}
			initialized = true;
			Logger.LogInfo((object)"RuneVault: GlobalMaterialBank initialized successfully");
		}
	}

	public void SetPlayerReference(Player p)
	{
		bool flag = (Object)(object)player != (Object)(object)p;
		player = p;
		Logger.LogInfo((object)"RuneVault: Player reference set");
		if (flag)
		{
			Logger.LogInfo((object)"RuneVault: Player changed, reloading bank data");
			materialCounts = new Dictionary<string, int>();
			SetDataLoaded(loaded: false);
			LoadBankData();
		}
	}

	public void OnPlayerSpawned(Player p)
	{
		SetPlayerReference(p);
	}

	private void OnPlayerDied()
	{
		Logger.LogInfo((object)"RuneVault: Player died");
	}

	private void OnPlayerSpawnedEvent()
	{
		if ((Object)(object)Player.m_localPlayer != (Object)null)
		{
			OnPlayerSpawned(Player.m_localPlayer);
		}
	}

	private void OnWorldSavingEvent(object sender, EventArgs e)
	{
		SaveBankData();
	}

	private void OnWorldSaving()
	{
		SaveBankData();
	}

	public bool Deposit(string itemName, int amount)
	{
		EnsureBankDataLoaded();
		if (string.IsNullOrEmpty(itemName) || amount <= 0)
		{
			return false;
		}
		if (!materialCounts.ContainsKey(itemName))
		{
			materialCounts[itemName] = 0;
		}
		materialCounts[itemName] += amount;
		this.OnBankChanged?.Invoke();
		SaveBankData();
		return true;
	}

	public bool Withdraw(string itemName, int amount)
	{
		EnsureBankDataLoaded();
		bool flag = ConfigManager.Instance != null && ConfigManager.Instance.Config != null && ConfigManager.Instance.Config.DebugMode;
		if (flag)
		{
			Logger.LogInfo((object)"===== BANK WITHDRAW DEBUG START =====");
			Logger.LogInfo((object)$"Attempting to withdraw {amount}x {itemName}");
			Logger.LogInfo((object)"Current bank contents before withdrawal:");
			foreach (KeyValuePair<string, int> materialCount in materialCounts)
			{
				Logger.LogInfo((object)$"  {materialCount.Key}: {materialCount.Value}");
			}
		}
		if (amount <= 0)
		{
			Logger.LogWarning((object)$"Withdraw failed: Amount {amount} is <= 0");
			return false;
		}
		if (!materialCounts.TryGetValue(itemName, out var value))
		{
			Logger.LogWarning((object)("Withdraw failed: Item " + itemName + " not found in bank"));
			return false;
		}
		if (value < amount)
		{
			Logger.LogWarning((object)$"Withdraw failed: Not enough {itemName} in bank. Requested: {amount}, Available: {value}");
			return false;
		}
		materialCounts[itemName] -= amount;
		if (flag)
		{
			Logger.LogInfo((object)$"Withdrew {amount}x {itemName}, new amount: {materialCounts[itemName]}");
		}
		if (materialCounts[itemName] <= 0)
		{
			if (flag)
			{
				Logger.LogInfo((object)("Removed " + itemName + " from bank as amount is now 0"));
			}
			materialCounts.Remove(itemName);
		}
		if (flag)
		{
			Logger.LogInfo((object)"Current bank contents after withdrawal:");
			foreach (KeyValuePair<string, int> materialCount2 in materialCounts)
			{
				Logger.LogInfo((object)$"  {materialCount2.Key}: {materialCount2.Value}");
			}
		}
		SaveBankData();
		if (flag)
		{
			Logger.LogInfo((object)"Bank data saved after withdrawal");
			Logger.LogInfo((object)"Notifying listeners that bank has changed");
		}
		this.OnBankChanged?.Invoke();
		if (flag)
		{
			Logger.LogInfo((object)"===== BANK WITHDRAW DEBUG END =====");
		}
		return true;
	}

	public bool HasItem(string itemName, int amount)
	{
		EnsureBankDataLoaded();
		if (string.IsNullOrEmpty(itemName) || amount <= 0)
		{
			return false;
		}
		if (!materialCounts.ContainsKey(itemName))
		{
			return false;
		}
		return materialCounts[itemName] >= amount;
	}

	public int GetItemAmount(string itemName)
	{
		EnsureBankDataLoaded();
		if (string.IsNullOrEmpty(itemName))
		{
			return 0;
		}
		if (!materialCounts.ContainsKey(itemName))
		{
			return 0;
		}
		return materialCounts[itemName];
	}

	public Dictionary<string, int> GetAllItems()
	{
		EnsureBankDataLoaded();
		return new Dictionary<string, int>(materialCounts);
	}

	public void SaveBankData()
	{
		if ((Object)(object)player == (Object)null)
		{
			Logger.LogWarning((object)"RuneVault: Cannot save bank data, player is null");
			return;
		}
		ZNetView component = ((Component)player).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			Logger.LogWarning((object)"RuneVault: Cannot save bank data, player network view is invalid");
			return;
		}
		string text = SerializeBankData();
		Logger.LogDebug((object)$"RuneVault: Saving bank data with {materialCounts.Count} items");
		string playerSpecificKey = GetPlayerSpecificKey(player);
		player.m_customData[playerSpecificKey] = text;
		ZDO zDO = component.GetZDO();
		zDO.Set(playerSpecificKey, text);
		zDO.SetOwner(zDO.GetOwner());
		dataLoaded = true;
		_hasShownEmptyBankWarning = false;
	}

	public bool EnsureBankDataLoaded()
	{
		if (dataLoaded)
		{
			return true;
		}
		Logger.LogDebug((object)"RuneVault: Loading bank data on demand");
		LoadBankData();
		return dataLoaded;
	}

	public void LoadBankData()
	{
		if ((Object)(object)player == (Object)null)
		{
			Logger.LogWarning((object)"RuneVault: Cannot load bank data, player is null");
			materialCounts = new Dictionary<string, int>();
			return;
		}
		ZNetView component = ((Component)player).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			Logger.LogWarning((object)"RuneVault: Cannot load bank data, player network view is invalid");
			materialCounts = new Dictionary<string, int>();
			dataLoaded = true;
			return;
		}
		string playerSpecificKey = GetPlayerSpecificKey(player);
		string text = null;
		if (player.m_customData.ContainsKey(playerSpecificKey))
		{
			text = player.m_customData[playerSpecificKey];
			Logger.LogDebug((object)"RuneVault: Found bank data in player's custom data");
		}
		if (string.IsNullOrEmpty(text))
		{
			text = component.GetZDO().GetString(playerSpecificKey, "");
			if (!string.IsNullOrEmpty(text))
			{
				Logger.LogDebug((object)"RuneVault: Found bank data in player's ZDO");
			}
		}
		if (string.IsNullOrEmpty(text))
		{
			if (!_hasShownEmptyBankWarning)
			{
				Logger.LogWarning((object)"RuneVault: No bank data found, initializing empty bank");
				_hasShownEmptyBankWarning = true;
			}
			else
			{
				Logger.LogDebug((object)"RuneVault: No bank data found, initializing empty bank");
			}
			materialCounts = new Dictionary<string, int>();
			return;
		}
		try
		{
			DeserializeBankData(text);
			Logger.LogDebug((object)$"RuneVault: Loaded bank data with {materialCounts.Count} items");
			SetDataLoaded(loaded: true);
			this.OnBankChanged?.Invoke();
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error deserializing bank data: " + ex.Message));
			materialCounts = new Dictionary<string, int>();
		}
	}

	public void SaveToZDO(ZDO zdo)
	{
		if (zdo != null)
		{
			string text = SerializeBankData();
			string text2 = (((Object)(object)player != (Object)null) ? GetPlayerSpecificKey(player) : "$runevault_bank_data");
			zdo.Set(text2, text);
			this.OnBankChanged?.Invoke();
		}
	}

	public void LoadFromZDO(ZDO zdo)
	{
		if (zdo != null)
		{
			string text = (((Object)(object)player != (Object)null) ? GetPlayerSpecificKey(player) : "$runevault_bank_data");
			string @string = zdo.GetString(text, "");
			if (string.IsNullOrEmpty(@string))
			{
				materialCounts = new Dictionary<string, int>();
				return;
			}
			DeserializeBankData(@string);
			this.OnBankChanged?.Invoke();
		}
	}

	private string SerializeBankData()
	{
		return string.Join(",", materialCounts.Select((KeyValuePair<string, int> kv) => $"{kv.Key}:{kv.Value}"));
	}

	private void DeserializeBankData(string bankData)
	{
		materialCounts.Clear();
		string[] array = bankData.Split(new char[1] { ',' });
		string[] array2 = array;
		foreach (string text in array2)
		{
			if (string.IsNullOrEmpty(text))
			{
				continue;
			}
			string[] array3 = text.Split(new char[1] { ':' });
			if (array3.Length == 2)
			{
				string key = array3[0];
				if (int.TryParse(array3[1], out var result) && result > 0)
				{
					materialCounts[key] = result;
				}
			}
		}
	}

	public void ClearBank()
	{
		materialCounts.Clear();
		this.OnBankChanged?.Invoke();
		SaveBankData();
	}

	public bool RemoveItem(string itemName)
	{
		EnsureBankDataLoaded();
		bool flag = ConfigManager.Instance != null && ConfigManager.Instance.Config != null && ConfigManager.Instance.Config.DebugMode;
		if (flag)
		{
			Logger.LogInfo((object)"===== BANK REMOVE ITEM DEBUG START =====");
			Logger.LogInfo((object)("Attempting to remove item: " + itemName));
		}
		if (string.IsNullOrEmpty(itemName))
		{
			Logger.LogWarning((object)"Remove failed: Item name is null or empty");
			return false;
		}
		if (!materialCounts.ContainsKey(itemName))
		{
			Logger.LogWarning((object)("Remove failed: Item " + itemName + " not found in bank"));
			return false;
		}
		materialCounts.Remove(itemName);
		if (flag)
		{
			Logger.LogInfo((object)("Successfully removed " + itemName + " from the bank"));
		}
		SaveBankData();
		if (flag)
		{
			Logger.LogInfo((object)"Bank data saved after item removal");
			Logger.LogInfo((object)"Notifying listeners that bank has changed");
		}
		this.OnBankChanged?.Invoke();
		if (flag)
		{
			Logger.LogInfo((object)"===== BANK REMOVE ITEM DEBUG END =====");
		}
		return true;
	}

	public bool IsPlayerNearRuneVault()
	{
		//IL_0041: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null)
		{
			player = Player.m_localPlayer;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
		}
		bool flag = RuneVaultPrefab.IsNearRuneVaultForInteraction(((Component)player).transform.position);
		if (!flag)
		{
			Piece[] array = Object.FindObjectsOfType<Piece>();
			Piece[] array2 = array;
			foreach (Piece val in array2)
			{
				if ((Object)(object)val != (Object)null && val.m_name != null && (val.m_name.Contains("runevault") || val.m_name.Contains("$piece_runevault") || ((Object)(object)((Component)val).gameObject != (Object)null && ((Object)((Component)val).gameObject).name.Contains("runevault"))))
				{
					float num = Vector3.Distance(((Component)player).transform.position, ((Component)val).transform.position);
					if (num <= 5f)
					{
						return true;
					}
				}
			}
		}
		return flag;
	}

	public static bool IsNearRuneVault(bool forCrafting = true)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		if (Instance == null || (Object)(object)Player.m_localPlayer == (Object)null)
		{
			return false;
		}
		if (forCrafting)
		{
			return RuneVaultPrefab.IsNearRuneVaultForBuilding(((Component)Player.m_localPlayer).transform.position);
		}
		return Instance.IsPlayerNearRuneVault();
	}
}
[BepInPlugin("ruijven.runevault", "RuneVault", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
internal class RuneVault : BaseUnityPlugin
{
	public const string PluginGUID = "ruijven.runevault";

	public const string PluginName = "RuneVault";

	public const string PluginVersion = "1.0.0";

	public static CustomLocalization Localization = LocalizationManager.Instance.GetLocalization();

	private GlobalMaterialBank materialBank;

	private ConfigManager configManager;

	private RuneVaultPrefab prefabManager;

	private RuneVaultSync syncManager;

	private RuneVaultUI uiManager;

	private RuneVaultDebug debugManager;

	private RuneVaultCompatibility compatibilityManager;

	private Harmony harmony;

	public static ManualLogSource Logger;

	public static RuneVault Instance { get; private set; }

	private void Awake()
	{
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Expected O, but got Unknown
		Instance = this;
		Logger = ((BaseUnityPlugin)this).Logger;
		try
		{
			Logger.LogInfo((object)"Ensuring YamlDotNet is loaded...");
			YamlDotNetLoader.EnsureYamlDotNetLoaded();
			Logger.LogInfo((object)"YamlDotNet loaded successfully");
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("Failed to load YamlDotNet: " + ex.Message));
			Logger.LogError((object)"Please ensure YamlDotNet.dll is in your BepInEx/plugins folder");
			Logger.LogError((object)ex.StackTrace);
		}
		configManager = new ConfigManager(((BaseUnityPlugin)this).Config);
		materialBank = new GlobalMaterialBank();
		syncManager = ((Component)this).gameObject.AddComponent<RuneVaultSync>();
		uiManager = ((Component)this).gameObject.AddComponent<RuneVaultUI>();
		debugManager = ((Component)this).gameObject.AddComponent<RuneVaultDebug>();
		compatibilityManager = ((Component)this).gameObject.AddComponent<RuneVaultCompatibility>();
		prefabManager = new RuneVaultPrefab();
		PrefabManager.OnPrefabsRegistered += RegisterPrefabsAndPieces;
		ZoneManager.OnVanillaLocationsAvailable += OnWorldLoaded;
		harmony = new Harmony("ruijven.runevault");
	}

	private void OnWorldLoaded()
	{
		materialBank.Init();
		syncManager.Init(materialBank, configManager);
		uiManager.Init(materialBank, configManager);
		debugManager.Init(materialBank, configManager);
		compatibilityManager.Init(materialBank, configManager);
		Logger.LogInfo((object)"RuneVault world initialization complete");
	}

	private void Start()
	{
		harmony.PatchAll(typeof(RuneVaultPatches));
		Logger.LogInfo((object)"RuneVault initialized");
	}

	private void OnDestroy()
	{
		harmony.UnpatchSelf();
	}

	private void RegisterPrefabsAndPieces()
	{
		prefabManager.RegisterPrefabAndPiece();
		PrefabManager.OnPrefabsRegistered -= RegisterPrefabsAndPieces;
	}

	public static bool IsDebug()
	{
		return (Object)(object)Instance != (Object)null && Instance.configManager != null && Instance.configManager.Config.DebugMode;
	}
}
public class RuneVaultCompatibility : MonoBehaviour
{
	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static CoroutineHandler <>9__20_1;

		public static CoroutineHandler <>9__20_3;

		internal IEnumerator <InitializeNetworkHandlers>b__20_1(long sender, ZPackage package)
		{
			return null;
		}

		internal IEnumerator <InitializeNetworkHandlers>b__20_3(long sender, ZPackage package)
		{
			return null;
		}
	}

	private HashSet<long> m_knownPeers = new HashSet<long>();

	private float m_peerCheckInterval = 2f;

	private float m_peerCheckTimer = 0f;

	private GlobalMaterialBank materialBank;

	private ConfigManager configManager;

	private List<string> connectedPlayers = new List<string>();

	private CustomRPC clientConnectedRPC;

	private CustomRPC clientDisconnectedRPC;

	private CustomRPC versionInfoRPC;

	private const string RPC_VERSION_INFO = "RuneVault_VersionInfo";

	private Dictionary<long, string> peerVersions = new Dictionary<long, string>();

	private Dictionary<long, bool> trackedPlayers = new Dictionary<long, bool>();

	private const string COMPATIBILITY_VERSION = "0.1.0";

	private bool initialized = false;

	public static RuneVaultCompatibility Instance { get; private set; }

	public void Init(GlobalMaterialBank bank, ConfigManager config)
	{
		Instance = this;
		materialBank = bank;
		configManager = config;
		Logger.LogInfo((object)"RuneVault: Compatibility manager initialized");
		ZoneManager.OnVanillaLocationsAvailable += OnWorldLoaded;
	}

	private void OnWorldLoaded()
	{
		InitializeNetworkHandlers();
	}

	private void InitializeNetworkHandlers()
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Expected O, but got Unknown
		//IL_006f: 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_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Expected O, but got Unknown
		//IL_0098: Expected O, but got Unknown
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Expected O, but got Unknown
		//IL_00c5: Expected O, but got Unknown
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Expected O, but got Unknown
		if (initialized || NetworkManager.Instance == null)
		{
			return;
		}
		NetworkManager instance = NetworkManager.Instance;
		CoroutineHandler val = delegate(long sender, ZPackage package)
		{
			OnClientConnected(sender);
			return null;
		};
		object obj = <>c.<>9__20_1;
		if (obj == null)
		{
			CoroutineHandler val2 = (long sender, ZPackage package) => null;
			<>c.<>9__20_1 = val2;
			obj = (object)val2;
		}
		clientConnectedRPC = instance.AddRPC("RuneVault_ClientConnected", val, (CoroutineHandler)obj);
		NetworkManager instance2 = NetworkManager.Instance;
		CoroutineHandler val3 = delegate(long sender, ZPackage package)
		{
			OnClientDisconnected(sender);
			return null;
		};
		object obj2 = <>c.<>9__20_3;
		if (obj2 == null)
		{
			CoroutineHandler val4 = (long sender, ZPackage package) => null;
			<>c.<>9__20_3 = val4;
			obj2 = (object)val4;
		}
		clientDisconnectedRPC = instance2.AddRPC("RuneVault_ClientDisconnected", val3, (CoroutineHandler)obj2);
		versionInfoRPC = NetworkManager.Instance.AddRPC("RuneVault_VersionInfo", (CoroutineHandler)delegate(long senderId, ZPackage package)
		{
			HandleVersionInfo(senderId, package);
			return null;
		}, (CoroutineHandler)delegate(long senderId, ZPackage package)
		{
			HandleVersionInfo(senderId, package);
			return null;
		});
		Logger.LogInfo((object)"RuneVault: Setting up peer connection handlers");
		ZRoutedRpc.instance.Register<ZPackage>("PlayerConnected", (Action<long, ZPackage>)delegate(long sender, ZPackage pkg)
		{
			OnClientConnected(sender);
		});
		m_knownPeers = new HashSet<long>();
		if ((Object)(object)ZNet.instance != (Object)null)
		{
			foreach (ZNetPeer connectedPeer in ZNet.instance.GetConnectedPeers())
			{
				if (connectedPeer != null)
				{
					m_knownPeers.Add(connectedPeer.m_uid);
				}
			}
		}
		Logger.LogInfo((object)"RuneVault: Registered for peer connection events");
		Logger.LogInfo((object)"RuneVault: Compatibility manager initialized");
		initialized = true;
	}

	private void OnServerStarted()
	{
		Logger.LogInfo((object)"RuneVault: Server started");
	}

	private void Update()
	{
		if ((Object)(object)ZNet.instance != (Object)null)
		{
			m_peerCheckTimer -= Time.deltaTime;
			if (m_peerCheckTimer <= 0f)
			{
				m_peerCheckTimer = m_peerCheckInterval;
				CheckForDisconnectedPeers();
			}
		}
	}

	private void CheckForDisconnectedPeers()
	{
		if ((Object)(object)ZNet.instance == (Object)null)
		{
			return;
		}
		HashSet<long> hashSet = new HashSet<long>();
		foreach (ZNetPeer connectedPeer in ZNet.instance.GetConnectedPeers())
		{
			if (connectedPeer != null)
			{
				hashSet.Add(connectedPeer.m_uid);
			}
		}
		foreach (long knownPeer in m_knownPeers)
		{
			if (!hashSet.Contains(knownPeer))
			{
				OnClientDisconnected(knownPeer);
			}
		}
		m_knownPeers = hashSet;
	}

	private void OnDestroy()
	{
		Instance = null;
	}

	private void OnClientDisconnected(long peerId)
	{
		Logger.LogInfo((object)$"RuneVault: Client disconnected {peerId}");
		if (trackedPlayers.ContainsKey(peerId))
		{
			trackedPlayers.Remove(peerId);
		}
	}

	public CustomRPC GetVersionInfoRPC()
	{
		return versionInfoRPC;
	}

	private void OnClientConnected(long peerId)
	{
		try
		{
			if (trackedPlayers.ContainsKey(peerId))
			{
				return;
			}
			trackedPlayers.Add(peerId, value: true);
			Logger.LogInfo((object)$"RuneVault: Player connected: {peerId}");
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				ZNetPeer peer = ZNet.instance.GetPeer(peerId);
				if (peer != null)
				{
					CheckVersionCompatibility(peer);
				}
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error handling client connection: " + ex.Message));
		}
	}

	private void HandleVersionInfo(long senderId, ZPackage package)
	{
		try
		{
			string text = package.ReadString();
			Logger.LogInfo((object)$"RuneVault: Received version info from peer {senderId}: {text}");
			if (!peerVersions.ContainsKey(senderId))
			{
				peerVersions[senderId] = text;
			}
			else
			{
				peerVersions[senderId] = text;
			}
		}
		catch (Exception ex)
		{
			Logger.LogWarning((object)("RuneVault: Error handling version info: " + ex.Message));
		}
	}

	private void OnClientDisconnected(ZNetPeer peer)
	{
		try
		{
			if (trackedPlayers.ContainsKey(peer.m_uid))
			{
				trackedPlayers.Remove(peer.m_uid);
				Logger.LogInfo((object)$"RuneVault: Player disconnected: {peer.m_playerName} ({peer.m_uid})");
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error handling client disconnection: " + ex.Message));
		}
	}

	private void CheckVersionCompatibility(ZNetPeer peer)
	{
		try
		{
			string peerVersion = GetPeerVersion(peer);
			if (string.IsNullOrEmpty(peerVersion))
			{
				return;
			}
			if (!IsVersionCompatible(peerVersion))
			{
				Logger.LogWarning((object)("RuneVault: Version mismatch with " + peer.m_playerName + ": " + peerVersion + " vs 1.0.0"));
				if (ZNet.instance.IsServer())
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "ChatMessage", new object[3]
					{
						0L,
						2,
						"[RuneVault] Warning: Version mismatch. Server: 1.0.0, Client: " + peerVersion
					});
				}
			}
			else
			{
				Logger.LogInfo((object)("RuneVault: Version compatible with " + peer.m_playerName + ": " + peerVersion));
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error checking version compatibility: " + ex.Message));
		}
	}

	private string GetPeerVersion(ZNetPeer peer)
	{
		try
		{
			if (peer.m_rpc != null && peer.m_rpc.GetSocket() != null && peer.m_rpc.GetSocket().GetHostName().Contains("RuneVault"))
			{
				string hostName = peer.m_rpc.GetSocket().GetHostName();
				string[] array = hostName.Split(new string[1] { "RuneVault/" }, StringSplitOptions.None);
				if (array.Length > 1)
				{
					return array[1].Split(' ', ',')[0];
				}
			}
			return null;
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error getting peer version: " + ex.Message));
			return null;
		}
	}

	private bool IsVersionCompatible(string peerVersion)
	{
		try
		{
			string[] array = "1.0.0".Split(new char[1] { '.' });
			string[] array2 = peerVersion.Split(new char[1] { '.' });
			if (array.Length >= 2 && array2.Length >= 2)
			{
				int num = int.Parse(array[0]);
				int num2 = int.Parse(array[1]);
				int num3 = int.Parse(array2[0]);
				int num4 = int.Parse(array2[1]);
				return num == num3 && num2 == num4;
			}
			return false;
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error checking version compatibility: " + ex.Message));
			return false;
		}
	}

	public static void CheckModConflicts()
	{
		try
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				string name = pluginInfo.Value.Metadata.Name;
				if (name.Contains("BuildFromContainers") || name.Contains("CraftFromContainers") || name.Contains("InventoryManager"))
				{
					list.Add(name);
				}
			}
			if (list.Count <= 0)
			{
				return;
			}
			Logger.LogWarning((object)"RuneVault: Potential mod conflicts detected:");
			foreach (string item in list)
			{
				Logger.LogWarning((object)("  - " + item));
			}
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, $"[RuneVault] Warning: {list.Count} potentially conflicting mods detected. Check logs for details.", 0, (Sprite)null);
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error checking mod conflicts: " + ex.Message));
		}
	}
}
[HarmonyPatch]
public static class MultiplayerPatches
{
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	[HarmonyPostfix]
	private static void ZNet_RPC_PeerInfo_Postfix(ZNet __instance, ZRpc rpc, ZPackage pkg)
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		try
		{
			long num = rpc.GetSocket().GetHostName().GetHashCode();
			ZNetPeer peer = __instance.GetPeer(num);
			if (peer == null)
			{
				return;
			}
			try
			{
				ZPackage val = new ZPackage();
				val.Write("RuneVault/1.0.0");
				if ((Object)(object)RuneVaultCompatibility.Instance != (Object)null && RuneVaultCompatibility.Instance.GetVersionInfoRPC() != null)
				{
					RuneVaultCompatibility.Instance.GetVersionInfoRPC().SendPackage(peer.m_uid, val);
				}
				else
				{
					Logger.LogWarning((object)"RuneVault: versionInfoRPC is not initialized, cannot send version info");
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("RuneVault: Could not send version info: " + ex.Message));
			}
		}
		catch (Exception ex2)
		{
			Logger.LogError((object)("RuneVault: Error patching ZNet.RPC_PeerInfo: " + ex2.Message));
		}
	}

	[HarmonyPatch(typeof(Game), "Start")]
	[HarmonyPostfix]
	private static void Game_Start_Postfix()
	{
		try
		{
			RuneVaultCompatibility.CheckModConflicts();
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error patching Game.Start: " + ex.Message));
		}
	}
}
public class RuneVaultDebug : MonoBehaviour
{
	private float _lastProximityCheckTime = 0f;

	private bool? _isNearRuneVault = null;

	private GameObject debugPanel;

	private GUIStyle labelStyle;

	private GUIStyle buttonStyle;

	private GlobalMaterialBank materialBank;

	private ConfigManager configManager;

	private bool showDebugInfo = false;

	private Vector2 scrollPosition = Vector2.zero;

	private string debugItemName = "Wood";

	private int debugItemAmount = 100;

	private const float DEBUG_PANEL_WIDTH = 400f;

	private const float DEBUG_PANEL_HEIGHT = 600f;

	private const int DEBUG_BUTTON_HEIGHT = 30;

	public static RuneVaultDebug Instance { get; private set; }

	public void Init(GlobalMaterialBank bank, ConfigManager config)
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Expected O, but got Unknown
		if (RuneVault.IsDebug())
		{
			Instance = this;
			materialBank = bank;
			configManager = config;
			materialBank.OnBankChanged += UpdateDebugInfo;
			CreateStyles();
			debugPanel = new GameObject("RuneVaultDebugPanel");
			debugPanel.SetActive(false);
			Logger.LogInfo((object)"RuneVault: Debug tools initialized");
		}
	}

	private void CreateStyles()
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		//IL_0091: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Expected O, but got Unknown
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Expected O, but got Unknown
		labelStyle = new GUIStyle();
		buttonStyle = new GUIStyle();
		if ((Object)(object)GUI.skin != (Object)null)
		{
			if (GUI.skin.label != null)
			{
				labelStyle = new GUIStyle(GUI.skin.label);
			}
			if (GUI.skin.button != null)
			{
				buttonStyle = new GUIStyle(GUI.skin.button);
			}
		}
		labelStyle.fontSize = 14;
		labelStyle.normal.textColor = Color.white;
		buttonStyle.fontSize = 14;
		buttonStyle.normal.textColor = Color.white;
	}

	private void UpdateDebugInfo()
	{
		if (RuneVault.IsDebug() && showDebugInfo)
		{
			Repaint();
		}
	}

	private void Repaint()
	{
		if ((Object)(object)debugPanel != (Object)null)
		{
			debugPanel.SetActive(false);
			debugPanel.SetActive(true);
		}
	}

	private void OnGUI()
	{
		//IL_004e: 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_0104: 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_0138: 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)
		if (!RuneVault.IsDebug())
		{
			return;
		}
		if (labelStyle == null || buttonStyle == null)
		{
			CreateStyles();
		}
		Rect val = new Rect((float)(Screen.width - 150), 10f, 140f, 30f);
		string obj = (showDebugInfo ? "Hide Debug" : "Show Debug");
		object obj2 = buttonStyle;
		if (obj2 == null)
		{
			GUISkin skin = GUI.skin;
			obj2 = ((skin != null) ? skin.button : null);
		}
		if (GUI.Button(val, obj, (GUIStyle)obj2))
		{
			showDebugInfo = !showDebugInfo;
			UpdateDebugInfo();
		}
		if (!showDebugInfo)
		{
			return;
		}
		try
		{
			GUI.Box(new Rect((float)Screen.width - 400f - 10f, 50f, 400f, 600f), "RuneVault Debug");
			GUILayout.BeginArea(new Rect((float)Screen.width - 400f - 5f, 80f, 390f, 560f));
			scrollPosition = GUILayout.BeginScrollView(scrollPosition, false, true, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(390f),
				GUILayout.Height(510f)
			});
			DrawDebugInfo();
			GUILayout.EndScrollView();
			DrawDebugControls();
			GUILayout.EndArea();
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault Debug UI error: " + ex.Message));
		}
	}

	private void DrawDebugInfo()
	{
		//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d1: 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_02e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f5: Expected O, but got Unknown
		//IL_0021: 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_0083: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			object obj = labelStyle;
			if (obj == null)
			{
				GUISkin skin = GUI.skin;
				obj = ((object)((skin != null) ? skin.label : null)) ?? ((object)new GUIStyle());
			}
			GUIStyle val = (GUIStyle)obj;
			GUILayout.Label("Player Info:", val, Array.Empty<GUILayoutOption>());
			Player localPlayer = Player.m_localPlayer;
			GUILayout.Label("Name: " + (((localPlayer != null) ? localPlayer.GetPlayerName() : null) ?? "N/A"), val, Array.Empty<GUILayoutOption>());
			Player localPlayer2 = Player.m_localPlayer;
			object obj2;
			if (localPlayer2 == null)
			{
				obj2 = null;
			}
			else
			{
				Vector3 position = ((Component)localPlayer2).transform.position;
				obj2 = ((object)(Vector3)(ref position)).ToString();
			}
			if (obj2 == null)
			{
				obj2 = "N/A";
			}
			GUILayout.Label("Position: " + (string?)obj2, val, Array.Empty<GUILayoutOption>());
			if (!_isNearRuneVault.HasValue || Time.time - _lastProximityCheckTime >= 2f)
			{
				_lastProximityCheckTime = Time.time;
				_isNearRuneVault = GlobalMaterialBank.IsNearRuneVault();
			}
			GUILayout.Label($"Near RuneVault: {_isNearRuneVault}", val, Array.Empty<GUILayoutOption>());
			GUILayout.Label("", val, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Bank Info:", val, Array.Empty<GUILayoutOption>());
			if (materialBank != null)
			{
				Dictionary<string, int> allItems = materialBank.GetAllItems();
				foreach (KeyValuePair<string, int> item in allItems)
				{
					GUILayout.Label($"{item.Key}: {item.Value}", val, Array.Empty<GUILayoutOption>());
				}
			}
			else
			{
				GUILayout.Label("Material bank not initialized", val, Array.Empty<GUILayoutOption>());
			}
			GUILayout.Label("", val, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Config Info:", val, Array.Empty<GUILayoutOption>());
			if (configManager != null && configManager.Config != null)
			{
				GUILayout.Label($"Debug Mode: {configManager.Config.DebugMode}", val, Array.Empty<GUILayoutOption>());
				GUILayout.Label($"Vault Range: {configManager.Config.VaultRange}", val, Array.Empty<GUILayoutOption>());
				GUILayout.Label($"Allowed Items: {configManager.Config.AllowedItems?.Count ?? 0}", val, Array.Empty<GUILayoutOption>());
			}
			else
			{
				GUILayout.Label("Config manager not initialized", val, Array.Empty<GUILayoutOption>());
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault DrawDebugInfo error: " + ex.Message));
			try
			{
				GUIStyle val2 = new GUIStyle
				{
					fontSize = 14
				};
				val2.normal.textColor = Color.red;
				GUILayout.Label("Error displaying debug info", val2, Array.Empty<GUILayoutOption>());
			}
			catch
			{
			}
		}
	}

	private void DrawDebugControls()
	{
		//IL_022f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0234: 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_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0258: Expected O, but got Unknown
		//IL_0021: 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)
		try
		{
			object obj = labelStyle;
			if (obj == null)
			{
				GUISkin skin = GUI.skin;
				obj = ((object)((skin != null) ? skin.label : null)) ?? ((object)new GUIStyle());
			}
			GUIStyle val = (GUIStyle)obj;
			object obj2 = buttonStyle;
			if (obj2 == null)
			{
				GUISkin skin2 = GUI.skin;
				obj2 = ((object)((skin2 != null) ? skin2.button : null)) ?? ((object)new GUIStyle());
			}
			GUIStyle val2 = (GUIStyle)obj2;
			GUILayout.Label("", val, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Debug Controls:", val, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Item Name:", val, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) });
			debugItemName = GUILayout.TextField(debugItemName ?? "", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(280f) });
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Amount:", val, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) });
			string s = GUILayout.TextField(debugItemAmount.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(280f) });
			if (int.TryParse(s, out var result))
			{
				debugItemAmount = result;
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Add Item", val2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				AddDebugItem();
			}
			if (GUILayout.Button("Remove Item", val2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				RemoveDebugItem();
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Clear Bank", val2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				ClearBank();
			}
			if (GUILayout.Button("Reload Config", val2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
			{
				ReloadConfig();
			}
			GUILayout.EndHorizontal();
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault DrawDebugControls error: " + ex.Message));
			try
			{
				GUIStyle val3 = new GUIStyle
				{
					fontSize = 14
				};
				val3.normal.textColor = Color.red;
				GUILayout.Label("Error displaying debug controls", val3, Array.Empty<GUILayoutOption>());
			}
			catch
			{
			}
		}
	}

	private void AddDebugItem()
	{
		try
		{
			if (!string.IsNullOrEmpty(debugItemName))
			{
				if (materialBank == null)
				{
					Logger.LogError((object)"RuneVault Debug: Material bank not initialized");
					return;
				}
				materialBank.Deposit(debugItemName, debugItemAmount);
				Logger.LogInfo((object)$"RuneVault Debug: Added {debugItemAmount} {debugItemName} to bank");
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault Debug: Error adding item: " + ex.Message));
		}
	}

	private void RemoveDebugItem()
	{
		try
		{
			if (!string.IsNullOrEmpty(debugItemName))
			{
				if (materialBank == null)
				{
					Logger.LogError((object)"RuneVault Debug: Material bank not initialized");
					return;
				}
				materialBank.Withdraw(debugItemName, debugItemAmount);
				Logger.LogInfo((object)$"RuneVault Debug: Removed {debugItemAmount} {debugItemName} from bank");
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault Debug: Error removing item: " + ex.Message));
		}
	}

	private void ClearBank()
	{
		try
		{
			if (materialBank == null)
			{
				Logger.LogError((object)"RuneVault Debug: Material bank not initialized");
				return;
			}
			Dictionary<string, int> allItems = materialBank.GetAllItems();
			foreach (KeyValuePair<string, int> item in allItems)
			{
				materialBank.Withdraw(item.Key, item.Value);
			}
			Logger.LogInfo((object)"RuneVault Debug: Cleared bank");
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault Debug: Error clearing bank: " + ex.Message));
		}
	}

	private void ReloadConfig()
	{
		try
		{
			Logger.LogInfo((object)"RuneVault Debug: Config reload not available - config is loaded at startup only");
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault Debug: Error in config reload: " + ex.Message));
		}
	}
}
public class RuneVaultInteraction : MonoBehaviour, Interactable
{
	private Piece piece;

	private ZNetView zNetView;

	private void Awake()
	{
		piece = ((Component)this).GetComponent<Piece>();
		zNetView = ((Component)this).GetComponent<ZNetView>();
		if (Object.op_Implicit((Object)(object)piece))
		{
			RuneVaultPrefab.AddRuneVaultPiece(piece);
		}
	}

	private void OnDestroy()
	{
		if (Object.op_Implicit((Object)(object)piece))
		{
			RuneVaultPrefab.RemoveRuneVaultPiece(piece);
		}
	}

	public string GetHoverText()
	{
		return Localization.instance.Localize("$piece_runevault") + "\n[<color=yellow><b>$KEY_Use</b></color>] $piece_use";
	}

	public string GetHoverName()
	{
		return Localization.instance.Localize("$piece_runevault");
	}

	public bool Interact(Humanoid user, bool hold, bool alt)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		if (hold)
		{
			return false;
		}
		if (!PrivateArea.CheckAccess(((Component)this).transform.position, 0f, true, false))
		{
			((Character)user).Message((MessageType)2, "$piece_noaccess", 0, (Sprite)null);
			return false;
		}
		Player val = (Player)(object)((user is Player) ? user : null);
		if (!Object.op_Implicit((Object)(object)val))
		{
			return false;
		}
		val.SetControls(Vector3.zero, false, false, false, false, false, false, false, false, false, false, false);
		InventoryGui.instance.Show((Container)null, 1);
		RuneVaultUI.Instance?.Show();
		return true;
	}

	public bool UseItem(Humanoid user, ItemData item)
	{
		return false;
	}
}
[HarmonyPatch]
public class RuneVaultPatches
{
	private enum LogLevel
	{
		None,
		Critical,
		Important,
		Verbose
	}

	private static float lastProximityCheckTime = 0f;

	private static bool lastProximityCheckResult = false;

	private static float proximityCheckInterval = 1f;

	private static LogLevel CurrentLogLevel
	{
		get
		{
			if (!ConfigManager.Instance.Config.enableMod)
			{
				return LogLevel.None;
			}
			if (!ConfigManager.Instance.Config.DebugMode)
			{
				return LogLevel.Critical;
			}
			return LogLevel.Important;
		}
	}

	private static GlobalMaterialBank materialBank => GlobalMaterialBank.Instance;

	private static void Log(string message, LogLevel level)
	{
		if (level <= CurrentLogLevel)
		{
			Logger.LogInfo((object)("RuneVault: " + message));
		}
	}

	[HarmonyPatch(typeof(ZNet), "Save")]
	[HarmonyPrefix]
	public static void ZNet_Save_Prefix()
	{
		if (materialBank != null)
		{
			Log("ZNet.Save detected, saving bank data", LogLevel.Important);
			materialBank.SaveBankData();
		}
	}

	[HarmonyPatch(typeof(Player), "SetLocalPlayer")]
	[HarmonyPostfix]
	public static void Player_SetLocalPlayer_Postfix(Player __instance)
	{
		if (materialBank != null && (Object)(object)__instance != (Object)null)
		{
			Log("Player.SetLocalPlayer detected, setting player reference", LogLevel.Important);
			materialBank.SetPlayerReference(__instance);
		}
	}

	private static bool IsNearRuneVaultCached(bool forCrafting = true)
	{
		if (Time.time - lastProximityCheckTime > proximityCheckInterval)
		{
			lastProximityCheckResult = GlobalMaterialBank.IsNearRuneVault(forCrafting);
			lastProximityCheckTime = Time.time;
			string text = (forCrafting ? "35m (crafting)" : "5m (interaction)");
			Log("Player is " + (lastProximityCheckResult ? "near" : "not near") + " RuneVault using " + text + " radius", LogLevel.Verbose);
		}
		return lastProximityCheckResult;
	}

	[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
	{
		typeof(Recipe),
		typeof(bool),
		typeof(int),
		typeof(int)
	})]
	[HarmonyPrefix]
	public static bool Player_HaveRequirements_Prefix(ref bool __result, Player __instance, Recipe recipe, bool discover, int qualityLevel, int amount = 1)
	{
		if (materialBank == null || !ConfigManager.Instance.Config.enableMod)
		{
			return true;
		}
		if (!IsNearRuneVaultCached())
		{
			return true;
		}
		if (discover)
		{
			return true;
		}
		bool flag = true;
		Requirement[] resources = recipe.m_resources;
		foreach (Requirement val in resources)
		{
			if (!((Object)(object)val.m_resItem == (Object)null))
			{
				string name = ((Object)val.m_resItem).name;
				string name2 = val.m_resItem.m_itemData.m_shared.m_name;
				int num = val.GetAmount(qualityLevel) * amount;
				int num2 = Math.Max(((Humanoid)__instance).GetInventory().CountItems(name, -1, true), ((Humanoid)__instance).GetInventory().CountItems(name2, -1, true));
				int num3 = Math.Max(materialBank.GetItemAmount(name), materialBank.GetItemAmount(name2));
				Log($"Checking requirement {name}/{name2}: Need {num}, Have {num2} in inventory + {num3} in bank", LogLevel.Verbose);
				if (num2 + num3 < num)
				{
					flag = false;
					Log("Not enough " + name + "/" + name2 + " for crafting", LogLevel.Verbose);
					break;
				}
			}
		}
		if (flag && !__result)
		{
			__result = true;
			Log("Allowing crafting with RuneVault resources", LogLevel.Verbose);
		}
		return !flag;
	}

	[HarmonyPatch(typeof(Player), "HaveRequirements", new Type[]
	{
		typeof(Piece),
		typeof(RequirementMode)
	})]
	[HarmonyPrefix]
	public static bool Player_HaveRequirements_Piece_Prefix(ref bool __result, Player __instance, Piece piece, RequirementMode mode)
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Invalid comparison between Unknown and I4
		//IL_0053: 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)
		if (materialBank == null || !ConfigManager.Instance.Config.enableMod)
		{
			return true;
		}
		if (!IsNearRuneVaultCached())
		{
			return true;
		}
		if ((int)mode > 0)
		{
			return true;
		}
		if (ZoneSystem.instance.GetGlobalKey(piece.FreeBuildKey()))
		{
			return true;
		}
		if ((Object)(object)piece.m_craftingStation != (Object)null && !Object.op_Implicit((Object)(object)CraftingStation.HaveBuildStationInRange(piece.m_craftingStation.m_name, ((Component)__instance).transform.position)) && !ZoneSystem.instance.GetGlobalKey((GlobalKeys)22))
		{
			Log("Required crafting station " + piece.m_craftingStation.m_name + " not in range", LogLevel.Verbose);
			return true;
		}
		bool flag = true;
		Requirement[] resources = piece.m_resources;
		foreach (Requirement val in resources)
		{
			if (!((Object)(object)val.m_resItem == (Object)null))
			{
				string name = ((Object)val.m_resItem).name;
				string name2 = val.m_resItem.m_itemData.m_shared.m_name;
				int amount = val.m_amount;
				int num = Math.Max(((Humanoid)__instance).GetInventory().CountItems(name, -1, true), ((Humanoid)__instance).GetInventory().CountItems(name2, -1, true));
				int num2 = Math.Max(materialBank.GetItemAmount(name), materialBank.GetItemAmount(name2));
				Log($"Checking building requirement {name}/{name2}: Need {amount}, Have {num} in inventory + {num2} in bank", LogLevel.Verbose);
				if (num + num2 < amount)
				{
					flag = false;
					Log("Not enough " + name + "/" + name2 + " for building", LogLevel.Verbose);
					break;
				}
			}
		}
		if (flag && !__result)
		{
			__result = true;
			Log("Allowing building with RuneVault resources", LogLevel.Verbose);
		}
		return !flag;
	}

	[HarmonyPatch(typeof(Player), "ConsumeResources", new Type[]
	{
		typeof(Requirement[]),
		typeof(int),
		typeof(int),
		typeof(int)
	})]
	[HarmonyPrefix]
	public static bool Player_ConsumeResources_Prefix(Player __instance, Requirement[] requirements, int qualityLevel, int multiplier)
	{
		if (materialBank == null || !ConfigManager.Instance.Config.enableMod)
		{
			return true;
		}
		if (!IsNearRuneVaultCached())
		{
			return true;
		}
		if (ConfigManager.Instance.Config.DebugMode)
		{
			Log($"ConsumeResources called for {requirements.Length} requirements", LogLevel.Verbose);
		}
		foreach (Requirement val in requirements)
		{
			if ((Object)(object)val.m_resItem == (Object)null)
			{
				continue;
			}
			string name = ((Object)val.m_resItem).name;
			string name2 = val.m_resItem.m_itemData.m_shared.m_name;
			int num = val.GetAmount(qualityLevel) * multiplier;
			int val2 = ((Humanoid)__instance).GetInventory().CountItems(name, -1, true);
			int num2 = ((Humanoid)__instance).GetInventory().CountItems(name2, -1, true);
			string text = ((num2 > 0) ? name2 : name);
			int num3 = Math.Max(val2, num2);
			if (ConfigManager.Instance.Config.DebugMode)
			{
				Log($"Consuming {num} of {name}/{name2}, have {num3} in inventory", LogLevel.Verbose);
			}
			int num4 = Math.Min(num3, num);
			if (num4 > 0)
			{
				((Humanoid)__instance).GetInventory().RemoveItem(text, num4, -1, true);
				Log($"Consumed {num4} {text} from inventory", LogLevel.Important);
			}
			int num5 = num - num4;
			if (num5 > 0)
			{
				int itemAmount = materialBank.GetItemAmount(name);
				int itemAmount2 = materialBank.GetItemAmount(name2);
				if (itemAmount >= num5)
				{
					materialBank.Withdraw(name, num5);
					Log($"Consumed {num5} {name} from bank", LogLevel.Important);
					continue;
				}
				if (itemAmount2 >= num5)
				{
					materialBank.Withdraw(name2, num5);
					Log($"Consumed {num5} {name2} from bank", LogLevel.Important);
					continue;
				}
				Log($"Not enough {name}/{name2} in bank! Need {num5}, have {itemAmount}/{itemAmount2}", LogLevel.Critical);
			}
		}
		return false;
	}

	[HarmonyPatch(typeof(Smelter), "OnAddOre")]
	[HarmonyPrefix]
	public static bool Smelter_OnAddOre_Prefix(ref bool __result, Smelter __instance, Switch sw, Humanoid user, ItemData item)
	{
		return true;
	}

	[HarmonyPatch(typeof(Smelter), "OnAddFuel")]
	[HarmonyPrefix]
	public static bool Smelter_OnAddFuel_Prefix(ref bool __result, Smelter __instance, Switch sw, Humanoid user, ItemData item)
	{
		return true;
	}
}
public class RuneVaultPrefab
{
	public const string AssetBundleName = "runevaultbundle_ru";

	public const string PrefabName = "runevault_ru";

	public const string DisplayName = "RuneVault";

	public const string IconName = "runevault_icon";

	public const string InternalPrefabName = "runevault_ru";

	private CustomPiece customPiece;

	private static List<GameObject> runeVaultPieces = new List<GameObject>();

	private static bool _loggedTrackingInfo = false;

	private static bool _loggedFallbackWarning = false;

	private static float _lastFallbackScanTime = 0f;

	private static readonly float FallbackScanInterval = 5f;

	public void RegisterPrefabAndPiece()
	{
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Expected O, but got Unknown
		//IL_0212: Unknown result type (might be due to invalid IL or missing references)
		//IL_0217: Unknown result type (might be due to invalid IL or missing references)
		//IL_0223: Unknown result type (might be due to invalid IL or missing references)
		//IL_022c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0235: Expected O, but got Unknown
		//IL_0237: Unknown result type (might be due to invalid IL or missing references)
		//IL_023c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_0251: Unknown result type (might be due to invalid IL or missing references)
		//IL_025a: Expected O, but got Unknown
		//IL_025c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0261: Unknown result type (might be due to invalid IL or missing references)
		//IL_026d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0275: Unknown result type (might be due to invalid IL or missing references)
		//IL_027e: Expected O, but got Unknown
		//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c3: Expected O, but got Unknown
		try
		{
			Logger.LogInfo((object)"RuneVault: Beginning prefab registration for runevault_ru");
			GameObject val = LoadRuneVaultPrefab();
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogWarning((object)"RuneVault: Failed to load prefab from asset bundle, using mock prefab instead");
				val = CreateMockRuneVaultPrefab();
				if ((Object)(object)val == (Object)null)
				{
					Logger.LogError((object)"RuneVault: Failed to create mock prefab - this will cause proximity detection to fail");
					return;
				}
				Logger.LogInfo((object)("RuneVault: Created mock prefab with name: " + ((Object)val).name));
			}
			else
			{
				Logger.LogInfo((object)("RuneVault: Successfully loaded prefab from asset bundle with name: " + ((Object)val).name));
			}
			if (((Object)val).name != "runevault_ru")
			{
				Logger.LogInfo((object)("RuneVault: Renaming prefab from '" + ((Object)val).name + "' to 'runevault_ru'"));
				((Object)val).name = "runevault_ru";
			}
			Sprite val2 = null;
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				string name = executingAssembly.GetName().Name + ".Assets.runevaultbundle_ru";
				using Stream stream = executingAssembly.GetManifestResourceStream(name);
				if (stream != null)
				{
					byte[] array = new byte[stream.Length];
					stream.Read(array, 0, array.Length);
					AssetBundle val3 = AssetBundle.LoadFromMemory(array);
					if ((Object)(object)val3 != (Object)null)
					{
						val2 = val3.LoadAsset<Sprite>("runevault_icon");
						if ((Object)(object)val2 != (Object)null)
						{
							Logger.LogInfo((object)"RuneVault: Loaded icon sprite 'runevault_icon' from asset bundle");
							Logger.LogInfo((object)"RuneVault: Successfully loaded icon sprite 'runevault_icon'");
						}
						else
						{
							Logger.LogWarning((object)"RuneVault: Icon sprite 'runevault_icon' not found in asset bundle");
						}
						val3.Unload(false);
					}
					else
					{
						Logger.LogWarning((object)"RuneVault: Could not load asset bundle for icon registration");
					}
				}
				else
				{
					Logger.LogWarning((object)"RuneVault: Could not get asset bundle stream for icon registration");
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("RuneVault: Exception during icon sprite loading/registration: " + ex.Message));
			}
			PieceConfig val4 = new PieceConfig();
			val4.Name = "$piece_runevault";
			val4.Description = "$piece_runevault_description";
			val4.PieceTable = "Hammer";
			val4.Category = "Misc";
			val4.Requirements = (RequirementConfig[])(object)new RequirementConfig[3]
			{
				new RequirementConfig
				{
					Item = "Stone",
					Amount = 50,
					Recover = true
				},
				new RequirementConfig
				{
					Item = "Thistle",
					Amount = 20,
					Recover = true
				},
				new RequirementConfig
				{
					Item = "SurtlingCore",
					Amount = 5,
					Recover = true
				}
			};
			val4.CraftingStation = "Workbench";
			val4.Icon = (((Object)(object)val2 != (Object)null) ? val2 : null);
			PieceConfig val5 = val4;
			val5.CraftingStation = "Workbench";
			customPiece = new CustomPiece(val, false, val5);
			PieceManager.Instance.AddPiece(customPiece);
			RegisterLocalization();
			VerifyPrefabRegistration();
			Logger.LogInfo((object)"RuneVault: Registered RuneVault prefab and piece");
		}
		catch (Exception ex2)
		{
			Logger.LogError((object)("RuneVault: Error registering RuneVault prefab and piece: " + ex2.Message + "\n" + ex2.StackTrace));
		}
	}

	private void VerifyPrefabRegistration()
	{
		try
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab("runevault_ru");
			if ((Object)(object)prefab != (Object)null)
			{
				Logger.LogInfo((object)"RuneVault: Successfully verified prefab registration for runevault_ru");
				Piece component = prefab.GetComponent<Piece>();
				if ((Object)(object)component != (Object)null)
				{
					Logger.LogInfo((object)("RuneVault: Prefab has Piece component with name: " + component.m_name));
				}
				else
				{
					Logger.LogWarning((object)"RuneVault: Prefab is missing Piece component!");
				}
				RuneVaultInteraction component2 = prefab.GetComponent<RuneVaultInteraction>();
				if ((Object)(object)component2 != (Object)null)
				{
					Logger.LogInfo((object)"RuneVault: Prefab has RuneVaultInteraction component");
				}
				else
				{
					Logger.LogWarning((object)"RuneVault: Prefab is missing RuneVaultInteraction component!");
				}
				return;
			}
			Logger.LogError((object)"RuneVault: Failed to verify prefab registration for runevault_ru");
			GameObject[] array = Object.FindObjectsOfType<GameObject>();
			GameObject[] array2 = array;
			foreach (GameObject val in array2)
			{
				if (((Object)val).name.Contains("runevault"))
				{
					Logger.LogInfo((object)("RuneVault: Found object with similar name: " + ((Object)val).name));
				}
			}
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error verifying prefab registration: " + ex.Message));
		}
	}

	private void RegisterLocalization()
	{
		CustomLocalization localization = LocalizationManager.Instance.GetLocalization();
		string text = "English";
		localization.AddTranslation(ref text, new Dictionary<string, string>
		{
			{ "piece_runevault", "RuneVault" },
			{ "piece_runevault_description", "A mystical runestone that stores building materials across dimensions." }
		});
	}

	private GameObject LoadRuneVaultPrefab()
	{
		try
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = executingAssembly.GetName().Name + ".Assets.runevaultbundle_ru";
			Logger.LogInfo((object)("RuneVault: Loading asset bundle from " + text));
			using Stream stream = executingAssembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				Logger.LogError((object)("RuneVault: Failed to load asset bundle stream from " + text));
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			AssetBundle val = AssetBundle.LoadFromMemory(array);
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogError((object)"RuneVault: Failed to load asset bundle from memory");
				return null;
			}
			GameObject val2 = val.LoadAsset<GameObject>("runevault_ru");
			if ((Object)(object)val2 == (Object)null)
			{
				Logger.LogError((object)"RuneVault: Failed to load prefab runevault_ru from asset bundle");
				val.Unload(false);
				return null;
			}
			EnsureRequiredComponents(val2);
			val.Unload(false);
			Logger.LogInfo((object)"RuneVault: Successfully loaded prefab runevault_ru from asset bundle");
			return val2;
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error loading asset bundle: " + ex.Message));
			return null;
		}
	}

	private void EnsureRequiredComponents(GameObject prefab)
	{
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		if (prefab.layer != LayerMask.NameToLayer("piece"))
		{
			prefab.layer = LayerMask.NameToLayer("piece");
		}
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<ZNetView>()))
		{
			Logger.LogWarning((object)"RuneVault: ZNetView component missing from prefab, adding one");
			prefab.AddComponent<ZNetView>();
		}
		Piece val = prefab.GetComponent<Piece>();
		if (!Object.op_Implicit((Object)(object)val))
		{
			Logger.LogWarning((object)"RuneVault: Piece component missing from prefab, adding one");
			val = prefab.AddComponent<Piece>();
		}
		val.m_name = "$piece_runevault";
		val.m_description = "$piece_runevault_description";
		try
		{
			Sprite sprite = GUIManager.Instance.GetSprite("runevault_icon");
			if ((Object)(object)sprite != (Object)null)
			{
				val.m_icon = sprite;
			}
		}
		catch (Exception ex)
		{
			Logger.LogWarning((object)("RuneVault: Could not load icon: " + ex.Message));
		}
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<Collider>()))
		{
			Logger.LogWarning((object)"RuneVault: Collider component missing from prefab, adding one");
			CapsuleCollider val2 = prefab.AddComponent<CapsuleCollider>();
			val2.radius = 0.5f;
			val2.height = 2f;
			((Collider)val2).isTrigger = false;
		}
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<WearNTear>()))
		{
			WearNTear val3 = prefab.AddComponent<WearNTear>();
			val3.m_health = 1500f;
			val3.m_damages = default(DamageModifiers);
			val3.m_damages.m_blunt = (DamageModifier)0;
			val3.m_damages.m_slash = (DamageModifier)1;
			val3.m_damages.m_pierce = (DamageModifier)1;
			val3.m_supports = true;
		}
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<HoverText>()))
		{
			HoverText val4 = prefab.AddComponent<HoverText>();
			val4.m_text = "$piece_runevault";
		}
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<ZNetView>()))
		{
			prefab.AddComponent<ZNetView>();
		}
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<RuneVaultInteraction>()))
		{
			prefab.AddComponent<RuneVaultInteraction>();
		}
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<RuneVaultInteraction>()))
		{
			prefab.AddComponent<RuneVaultInteraction>();
		}
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<LODGroup>()))
		{
			Logger.LogWarning((object)"RuneVault: LODGroup component missing from prefab");
		}
	}

	private GameObject CreateMockRuneVaultPrefab()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Expected O, but got Unknown
		//IL_00ce: 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_013b: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Logger.LogInfo((object)"RuneVault: Creating mock prefab with name 'runevault_ru'");
			GameObject val = new GameObject("runevault_ru");
			ZNetView val2 = val.AddComponent<ZNetView>();
			Piece val3 = val.AddComponent<Piece>();
			val3.m_name = "$piece_runevault";
			val3.m_description = "$piece_runevault_description";
			val3.m_comfort = 0;
			val3.m_groundPiece = true;
			val3.m_allowedInDungeons = false;
			val3.m_cultivatedGroundOnly = false;
			val3.m_waterPiece = false;
			val3.m_noInWater = true;
			val3.m_notOnWood = false;
			val3.m_notOnTiltingSurface = true;
			val3.m_vegetationGroundOnly = false;
			val.layer = LayerMask.NameToLayer("piece");
			CapsuleCollider val4 = val.AddComponent<CapsuleCollider>();
			val4.radius = 0.5f;
			val4.height = 2f;
			((Collider)val4).isTrigger = false;
			WearNTear val5 = val.AddComponent<WearNTear>();
			val5.m_health = 1500f;
			val5.m_damages = default(DamageModifiers);
			val5.m_supports = true;
			HoverText val6 = val.AddComponent<HoverText>();
			val6.m_text = "$piece_runevault";
			RuneVaultInteraction runeVaultInteraction = val.AddComponent<RuneVaultInteraction>();
			GameObject val7 = GameObject.CreatePrimitive((PrimitiveType)2);
			val7.transform.SetParent(val.transform);
			val7.transform.localPosition = Vector3.zero;
			val7.transform.localScale = new Vector3(0.5f, 1f, 0.5f);
			Logger.LogInfo((object)("RuneVault: Mock prefab created successfully with name '" + ((Object)val).name + "'"));
			return val;
		}
		catch (Exception ex)
		{
			Logger.LogError((object)("RuneVault: Error creating mock prefab: " + ex.Message + "\n" + ex.StackTrace));
			return null;
		}
	}

	public static void AddRuneVaultPiece(Piece piece)
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)piece == (Object)null) && !((Object)(object)((Component)piece).gameObject == (Object)null))
		{
			GameObject gameObject = ((Component)piece).gameObject;
			if (!runeVaultPieces.Contains(gameObject))
			{
				runeVaultPieces.Add(gameObject);
				Logger.LogInfo((object)$"RuneVault: Added RuneVault piece at {((Component)piece).transform.position}");
			}
		}
	}

	public static void RemoveRuneVaultPiece(Piece piece)
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)piece == (Object)null) && !((Object)(object)((Component)piece).gameObject == (Object)null))
		{
			GameObject gameObject = ((Component)piece).gameObject;
			if (runeVaultPieces.Contains(gameObject))
			{
				runeVaultPieces.Remove(gameObject);
				Logger.LogInfo((object)$"RuneVault: Removed RuneVault piece at {((Component)piece).transform.position}");
			}
		}
	}

	public static bool IsNearRuneVault(Vector3 position, float maxDistance)
	{
		//IL_022e: 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_016e: 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)
		if (!_loggedTrackingInfo)
		{
			Logger.LogDebug((object)$"RuneVault: Proximity check system using {runeVaultPieces.Count} tracked pieces");
			_loggedTrackingInfo = true;
		}
		if (runeVaultPieces.Count == 0)
		{
			if (Time.time - _lastFallbackScanTime < FallbackScanInterval)
			{
				return false;
			}
			_lastFallbackScanTime = Time.time;
			if (!_loggedFallbackWarning)
			{
				Logger.LogWarning((object)"RuneVault: No RuneVault pieces are being tracked! Using fallback detection method.");
				_loggedFallbackWarning = true;
				GameObject prefab = PrefabManager.Instance.GetPrefab("runevault_ru");
				if ((Object)(object)prefab != (Object)null)
				{
					Logger.LogDebug((object)("RuneVault: Found prefab instance via PrefabManager: " + ((Object)prefab).name));
				}
				else
				{
					Logger.LogWarning((object)"RuneVault: Could not find prefab 'runevault_ru' via PrefabManager");
				}
			}
			Piece[] array = Object.FindObjectsOfType<Piece>();
			Piece[] array2 = array;
			foreach (Piece val in array2)
			{
				if ((Object)(object)val == (Object)null || val.m_name == null || (!val.m_name.Contains("runevault") && !val.m_name.Contains("$piece_runevault") && (!((Object)(object)((Component)val).gameObject != (Object)null) || !((Object)((Component)val).gameObject).name.Contains("runevault"))))
				{
					continue;
				}
				float num = Vector3.Distance(position, ((Component)val).transform.position);
				if (num <= maxDistance)
				{
					GameObject gameObject = ((Component)val).gameObject;
					if (!runeVaultPieces.Contains(gameObject))
					{
						runeVaultPieces.Add(gameObject);
						Logger.LogInfo((object)"RuneVault: Added previously untracked RuneVault piece to tracking list");
					}
					return true;
				}
			}
			return false;
		}
		foreach (GameObject runeVaultPiece in runeVaultPieces)
		{
			if ((Object)(object)runeVaultPiece == (Object)null)
			{
				continue;
			}
			Piece component = runeVaultPiece.GetComponent<Piece>();
			if (!((Object)(object)component == (Object)null))
			{
				float num2 = Vector3.Distance(position, runeVaultPiece.transform.position);
				if (num2 <= maxDistance)
				{
					return true;
				}
			}
		}
		return false;
	}

	public static bool IsNearRuneVaultForInteraction(Vector3 position)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		return IsNearRuneVault(position, 5f);
	}

	public static bool IsNearRuneVaultForBuilding(Vector3 position)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		return IsNearRuneVault(position, 35f);
	}
}
public class RuneVaultSync : MonoBehaviour
{
	private GlobalMaterialBank materialBank;

	private ConfigManager configManager;

	private const string RPC_DEPOSIT = "RuneVault_Deposit";

	private const string RPC_WITHDRAW = "RuneVault_Withdraw";

	private const string RPC_CONSUME = "RuneVault_Consume";

	private bool rpcRegistered = false;

	public static RuneVaultSync Instance { get; private set; }

	public void Init(GlobalMaterialBank bank, ConfigManager config)
	{
		Instance = this;
		materialBank = bank;
		configManager = config;
		Logger.LogInfo((object)"RuneVault: Sync manager initialized");
	}

	private void Update()
	{
		if (!rpcRegistered && ZRoutedRpc.instance != null)
		{
			ZRoutedRpc.instance.Register<ZPackage>("RuneVault_Deposit", (Action<long, ZPackage>)RPC_DepositHandler);
			ZRoutedRpc.instance.Register<ZPackage>("RuneVault_Withdraw", (Action<long, ZPackage>)RPC_WithdrawHandler);
			ZRoutedRpc.instance.Register<ZPackage>("RuneVault_Consume", (Action<long, ZPackage>)RPC_ConsumeHandler);
			rpcRegistered = true;
			Logger.LogInfo((object)"RuneVault: RPC methods registered");
		}
	}

	public bool RequestDeposit(string itemName, int amount)
	{
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Expected O, but got Unknown
		if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
		{
			return false;
		}
		if (!GlobalMaterialBank.IsNearRuneVault())
		{
			((Character)Player.m_localPlayer).Message((MessageType)2, "$msg_toofar", 0, (Sprite)null);
			return false;
		}
		if (!configManager.IsItemAllowed(itemName))
		{
			((Character)Player.m_localPlayer).Message((MessageType)2, "$msg_itemnotallowed", 0, (Sprite)null);
			return false;
		}
		ZPackage val = new ZPackage();
		val.Write(Player.m_localPlayer.GetPlayerID());
		val.Write(itemName);
		val.Write(amount);
		ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "RuneVault_Deposit", new object[1] { val });
		return true;
	}

	public bool RequestWithdr